DeltaLima/TheNetNode-CB
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
TheNetNode-CB/os/win32/ax25ip.c

3388 lines
92 KiB
C
Raw Normal View History

initial commit
2019-05-15 00:19:53 +02:00
/************************************************************************/
/* */
/* ***** ***** */
/* ***** ***** */
/* ***** ***** */
/* ***** ***** */
/* *************** *************** */
/* ***************** ***************** */
/* *************** *************** */
/* ***** ***** TheNetNode */
/* ***** ***** Portable */
/* ***** ***** Network */
/* ***** ***** Software */
/* */
/* File os/linux/ax25ip.c (maintained by: DG9OBU) */
/* */
/* 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 */
/* */
/************************************************************************/
/************************************************************************/
/* */
/* AX25IP.C V1.05 01.9.98 by DG1KWA / Andreas */
/* extended by DG9OBU / Marc */
/************************************************************************/
#include "tnn.h"
#ifdef AX25IP
#include "ax25ip.h"
/*************************************************************************/
/* AX25IP-Hausaufgaben : RX, TX und Routingtabellenpflege */
/*************************************************************************/
void ax25ip(void)
{
register UBYTE uEntry = 0;
/* nur wenn Interface aktiv ist */
if (!ax25ip_active)
return;
/* empfangene Frames abholen */
ax25ip_recv();
/* IP-Adressen der Routentabelle pflegen */
if ((uNamesUpdate != 0) && (tic10 % uNamesUpdate == 0))
{
for (; uEntry <= TABLE_SIZE; ++uEntry)
route_update(&route_tbl[uEntry]);
route_update(&default_route);
}
/* ausstehende Frames senden wenn vorhanden */
if (kick[ax25ip_port])
ax25ip_send();
}
/*************************************************************************/
/* Einen Eintrag aus der Routingtabelle ausgeben */
/*************************************************************************/
void show_rt_entry(struct route_table_entry rp, MBHEAD *bufpoi)
{
/* erst mal merken, wo wir sind */
bufpoi->l4time = bufpoi->mbpc;
/* Check auf Eintrag fuer die default-Route */
if (rp.callsign[0] != 1)
putprintf(bufpoi, "%s", call_to_a(&rp.callsign[0]));
else
putstr("default", bufpoi);
putspa(11, bufpoi);
/* IP-Adresse ausgeben */
show_ip_addr(ntohl(rp.ip_addr), bufpoi);
putspa(29, bufpoi);
/* UDP-Port ausgeben wenn UDP-Port gesetzt */
if (rp.udp_port != 0)
{
/* Eine UDP-Route */
putstr("UDP", bufpoi);
putspa(35, bufpoi);
putnum(ntohs(rp.udp_port), bufpoi);
}
else
/* Eine IP-Route */
putstr("IP", bufpoi);
/* Routen-Timeout anzeigen */
if (rp.timeout != 0)
{
ULONG d = rp.timeout;
ULONG h, m, s; /* Stunden, Minuten, Sekunden */
s = d % 60L;
d /= 60L;
m = d % 60L;
d /= 60L;
h = d % 24L;
putspa(40, bufpoi);
putprintf(bufpoi, " %02lu:%02lu:%02lu", h, m, s); /* hh:mm:ss */
}
if (rp.hostname[0] != 0)
{
putspa(50, bufpoi);
putprintf(bufpoi, "%s", rp.hostname);
}
putstr("\r", bufpoi);
}
/* Anzahl von IP- oder UDP-Routen in der Routingtabelle feststellen */
/* (IP-Routen haben keinen UDP-Port gesetzt) */
/* UDP = FALSE -> IP-Routen zaehlen, UDP = TRUE -> UDP-Routen zaehlen */
/* Default-Route wird beachtet */
unsigned int count_routes(BOOLEAN udp)
{
register unsigned int i;
register unsigned int j = 0;
/* Gesamte Routingtabelle durchgehen */
for (i = 0; i < (unsigned int)route_tbl_top; ++i)
{
if ( ((udp == TRUE) && (route_tbl[i].udp_port != 0)) /* UDP-Route */
|| ((udp == FALSE) && (route_tbl[i].udp_port == 0))) /* IP-Route */
++j;
}
/* Default-Route */
if (default_route.callsign[0] != 0)
{
if ( ((udp == TRUE) && (default_route.udp_port != 0)) /* UDP-Route */
|| ((udp == FALSE) && (default_route.udp_port == 0))) /* IP-Route */
++j;
}
/* Anzahl Routen melden */
return (j);
}
/* Timeout fuer gelernte Routen */
void route_age(void)
{
register unsigned int i = 0;
#ifdef AXIPR_HTML
/* htmlstatistik-timer. */
h_timer();
#endif
/* Gesamte Routingtabelle durchgehen */
for (; i < (unsigned int)route_tbl_top; ++i)
{
/* Route mit laufendem Timer */
if (route_tbl[i].timeout != 0)
{
/* Timer laeuft jetzt ab */
if (--route_tbl[i].timeout == 0)
/* Route loeschen */
route_del(route_tbl[i].callsign);
}
}
}
/* Hostname -> IP-Adressen aufloesen */
void route_update(struct route_table_entry *rtentry)
{
struct hostent *hstent;
/* Kein Hostname, dann auch keine Umwandlung moeglich */
if (rtentry->hostname[0] == 0)
return;
/* Hostname im IP-Adresse konvertieren */
if ((hstent = gethostbyname((char*)&rtentry->hostname[0])) != NULL)
{
/* Bei Aenderung uebernehmen */
if (memcmp(&rtentry->ip_addr, &hstent->h_addr_list[0][0], 4) != 0)
{
/* IP-Adresse hat sich geaendert */
memcpy(&rtentry->ip_addr, &hstent->h_addr_list[0][0], 4);
LOGL1("IP-adress for %s changed !", rtentry->hostname);
}
}
#ifdef AXIPR_UDP
/* Original UDP-Port setzen. */
rtentry->udp_port = rtentry->org_udp_port;
#endif /* AXIPR_UDP */
}
/* Partielle Frame-Analyse fuer dyn. Eintraege */
BOOLEAN route_canlearn(MBHEAD *fbp)
{
char *p; /* Zeiger im Header */
register int n;
UBYTE ctl;
rwndmb(fbp); /* Frame von vorne */
for (p = rxfhdr, n = 1; n <= L2INUM + L2VNUM; ++n)
{
if (!getfid(p, fbp)) /* naechstes Call lesen */
return (FALSE);
p += L2IDLEN;
if (*(p - 1) & L2CEOA)
break; /* Ende des Addressfeldes */
}
*(p - 1) &= ~L2CEOA;
*p = NUL;
ctl = getchr(fbp); /* Control-Byte extrahieren */
ctl &= ~L2CPF; /* Poll-Flag loeschen */
/* Nur UI, UA und SABM/SABME erzeugen einen dynamischen Eintrag */
if ( ctl == L2CUI /* UI */
|| ctl == L2CUA /* UA */
|| ctl == L2CSABM /* SABM */
#ifdef EAX25
|| ctl == L2CSABME /* SABME (EAX.25) */
)
#endif
return (TRUE);
#ifndef AXIPR_UDP
/* Alle anderen Kontrollcodes landen hier und bewirken keinen Eintrag */
return (FALSE);
#else
return (TRUE);
#endif
}
/*************************************************************************/
/* Kommandointerface fuer Operationen auf die AX25IP-Routentabelle */
/*************************************************************************/
/* Eine Route anhand eines Calls loeschen, liefert TRUE wenn erfolgreich */
BOOLEAN route_del(unsigned char *call)
{
register int i;
register int j;
/* Soll die Default-Route geloescht werden ? */
if ((call == NULL) || (call[0] == NUL))
{
/* Als unbenutzt markieren */
default_route.callsign[0] = NUL;
/* Pruefen, ob Sockets noch notwendig */
ax25ip_check_down();
return (TRUE);
}
/* Uebergebenes Call in der Tabelle suchen */
for (i = 0; i < route_tbl_top; ++i)
{
if (addrmatch(call, route_tbl[i].callsign))
{
/* BINGO ! */
/* Problem: die Tabelle hat keinen Merker, ob ein Eintrag gueltig ist, */
/* die Eintraege haengen einfach hintereinander. Deshalb alle */
/* Eintraege oberhalb des gefundenen Eintrages einen nach */
/* unten kopieren und den "table-top" einen herabsetzen. */
for (j = i; j < route_tbl_top; ++j)
route_tbl[j] = route_tbl[j + 1];
/* Ein Tabelleneintrag weniger */
route_tbl_top--;
/* Pruefen, ob Sockets noch notwendig */
ax25ip_check_down();
return(TRUE);
}
}
return(FALSE);
}
static const char inv_mode[] = "Invalid Mode\r";
static const char inv_call[] = "Invalid Callsign\r";
static const char inv_ip[] = "Invalid IP adress\r";
static const char inv_par[] = "Invalid Parameter\r";
void
ccpaxipr(void)
{
MBHEAD *mbp;
int port = 0;
register int i;
int tmp_fd = -1;
int new_udp = 0;
unsigned char call[L2IDLEN];
char hostname[HNLEN + 1];
struct hostent *host = NULL;
int uNewTimeout;
#ifdef AXIPR_UDP
char *Hostname = hostname;
int NewLogLevel = FALSE;
#endif
#ifdef AXIPR_HTML
char *timeset = set_time();
int NewHtmlStat = FALSE;
#endif
char cBuf[BUFLEN + 1];
unsigned int uCmd = OP_NONE;
unsigned int uMode = NO_MODE;
#ifdef AXIPR_HTML
#define OP_HTMLSTAT 10
#endif
memset(hostname, 0, sizeof(hostname));
/* AX25IP ueberhaupt aktiv ? */
if (ax25ip_active == FALSE)
{
putmsg("No AX25IP-interface present, nothing to configure or show !\r");
return;
}
/* neuen Parser verwenden ? */
if (new_parser == TRUE)
{
/* Sysop will aendern und noch was in der Zeile da ? */
if (issyso() && skipsp(&clicnt, &clipoi))
{
/* Frischer Buffer */
memset(cBuf, 0, sizeof(cBuf));
/* Operation lesen (add, delete) */
for (i = 0; i < BUFLEN; ++i)
{
if ((!clicnt) || (*clipoi == ' '))
break;
clicnt--;
cBuf[i] = toupper(*clipoi++);
}
/* Zum alten Parser zurueckschalten */
if ( (strcmp(cBuf, "OLD") == 0)
|| (cBuf[0] == 'O')
)
{
new_parser = FALSE;
putmsg("Switched to old axipr-parser !!!\r");
return;
}
/* Hinzufuegen (add oder +) */
if ( (strcmp(cBuf, "ADD") == 0)
|| (cBuf[0] == '+')
)
uCmd = OP_ADD;
/* Loeschen (delete, del oder -) */
if ( (strcmp(cBuf, "DELETE") == 0)
|| (strcmp(cBuf, "DEL") == 0)
|| (cBuf[0] == '-')
)
uCmd = OP_DEL;
/* eigenen UDP-Port aendern */
if (strcmp(cBuf, "MYUDP") == 0)
uCmd = OP_MYUDP;
/* Namensaufloesungsintervall einstellen */
if (strcmp(cBuf, "LOOKUP") == 0)
uCmd = OP_HNUPD;
/* Loglevel */
if ( (strcmp(cBuf, "LOGLEVEL") == 0)
|| (strcmp(cBuf, "LOG") == 0)
)
uCmd = OP_LOG;
/* Timeout fuer dynamische Routen */
if (strcmp(cBuf, "TIMEOUT") == 0)
uCmd = OP_TIMEOUT;
#ifdef AXIPR_HTML
/* htmlstatistik */
if ( (strcmp(cBuf, "HTMLSTAT") == 0)
|| (strcmp(cBuf, "H") == 0))
uCmd = OP_HTMLSTAT;
#endif
/* Fehler bei der Auswertung ? */
if (uCmd == OP_NONE)
{
putmsg(inv_mode);
return;
}
/* Hier rein, wenn der Timeout fuer dynamische Routen geaendert werden soll */
if (uCmd == OP_TIMEOUT)
{
int uNewTimeout;
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
putprintf(mbp, "the actual timeout for dynamic routes is : %u\r", uDynTimeout);
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* Timeout lesen */
uNewTimeout = nxtlong(&clicnt, &clipoi);
if ( (uNewTimeout < 0)
||(uNewTimeout > (86400))) /* max. 1 Tag */
{
putmsg("error: timeout out of range (0 - 86400) !\r");
return;
}
/* Wert uebernehmen */
uDynTimeout = uNewTimeout;
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
}
/* Hier rein, wenn das Intervall der Namensaufloesung geaendert werden soll */
if (uCmd == OP_HNUPD)
{
UWORD uNewInterval;
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
putprintf(mbp, "Hostname-update ");
if (uNamesUpdate != 0)
putprintf(mbp, "occurs every %u seconds.\r", uNamesUpdate / 100);
else
putprintf(mbp, "is disabled at the moment.\r");
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* Timeout lesen */
uNewInterval = nxtnum(&clicnt, &clipoi);
if (uNewInterval > 3600) /* max. eine Stunde */
{
putmsg("error: value out of range (0 - 3600 seconds) !\r");
return;
}
/* Wert uebernehmen */
uNamesUpdate = uNewInterval * 100;
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
}
/* Hier rein, wenn der Loglevel geaendert werden soll */
if (uCmd == OP_LOG)
{
int new_loglevel;
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
putprintf(mbp, "my actual loglevel is : %u\r", loglevel);
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* neues Loglevel lesen */
new_loglevel = nxtnum(&clicnt, &clipoi);
if ( (new_loglevel < 0)
||(new_loglevel > 4))
{
putmsg("error: loglevel out of range (0 - 4) !!!\r");
return;
}
/* Wert uebernehmen */
loglevel = new_loglevel;
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
}
#ifdef AXIPR_HTML
if (uCmd == OP_HTMLSTAT)
{
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
#ifdef SPEECH
putprintf(mbp, speech_message(347),HtmlStat);
#else
putprintf(mbp, "HTML-Statistic is %d\r", HtmlStat);
#endif
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* Timeout lesen */
NewHtmlStat = nxtnum(&clicnt, &clipoi);
if ( (NewHtmlStat < 0)
||(NewHtmlStat > 1))
{
#ifdef SPEECH
putmsg(speech_message(300));
#else
putmsg("errors: Log level worth from 0 to 1!\r");
#endif
return;
}
/* Wert uebernehmen */
HtmlStat = NewHtmlStat;
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
}
#endif /* AXIPR_HTML */
/* Hier nur rein, wenn wir als naechstes eine UDP-Portnummer erwarten */
if (uCmd == OP_MYUDP)
{
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
putprintf(mbp, "my actual UDP-port is : %u\r", ntohs(my_udp));
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* neue UDP-Portnummer lesen */
new_udp = nxtlong(&clicnt, &clipoi);
if ( (new_udp <= 0)
||(new_udp > 65535))
{
putmsg("error: UDP-port number not valid (0 - 65535) !!!\r");
return;
}
#ifdef AXIPR_UDP
/* Neuer UDP-Port gleich MY-UDP? */
/* Keine Aenderungen durchfuehren. */
if (my_udp == htons((unsigned short)new_udp))
{
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
}
#endif /* AXIPR_UDP */
#ifndef AXIPR_UDP
/* Laufendes UDP aendern */
if (fd_udp != -1)
{
#endif
/* Versuchen, neuen UDP-Port anzulegen */
if ((tmp_fd = setup_udp(htons((unsigned short)new_udp))) != -1)
{
#ifndef AXIPR_UDP
/* Neuen Descriptor eintragen und alten schliessen */
close(fd_udp);
#else
/* Nur wenn alter Socket noch lebt, */
if (fd_udp != EOF)
/* dann schliessen wir den Socket. */
close(fd_udp);
#endif /* AXIPR_UDP */
fd_udp = tmp_fd;
/* Gibt es einen Eintrag. */
if (l1pp)
/* Check, ob neuer Filedescriptor groesser ist */
l1pp->kisslink = max(fd_ip, fd_udp);
/* Neuen UDP-Port merken */
my_udp = htons((unsigned short)new_udp);
}
else
{
putmsg("error: changing the UDP-port failed !!!\r");
return;
}
#ifndef AXIPR_UDP
}
else
{
/* neuen UDP-Port merken */
my_udp = htons(new_udp);
}
#endif
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
}
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
putmsg("syntax error: callsign missing\r");
return;
}
/* Frischer Buffer */
memset(cBuf, 0, sizeof(cBuf));
/* Call lesen */
for (i = 0; i < BUFLEN; ++i)
{
if ((!clicnt) || (*clipoi == ' '))
break;
clicnt--;
cBuf[i] = toupper(*clipoi++);
}
/* Operation auf Default-Route ? */
if (strcmp(cBuf, "DEFAULT") == 0)
call[0] = NUL; /* Leere Callstring als Indikator fuer Defaultroute */
else
{
/* Call konvertieren und pruefen */
if (a_to_call(cBuf, call) != 0)
{
putmsg(inv_call);
return;
}
}
/* Wenn wir loeschen wollen, brauchen wir nichts mehr */
if (uCmd != OP_DEL)
{
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
putmsg("syntax error: IP-adress missing\r");
return;
}
/* Frische Buffer */
memset(hostname, 0, sizeof(hostname));
/* Hostnamen / IP-Adresse lesen */
for (i = 0; i < HNLEN; ++i)
{
if (!clicnt || *clipoi == ' ')
break;
clicnt--;
hostname[i] = *clipoi++;
}
/* eventuellen Hostnamen aufloesen */
if ((host = gethostbyname(hostname)) == NULL)
{
mbp = getmbp();
putprintf(mbp, "Warning: can't resolve IP for host %s ! I keep trying ...\r", hostname);
prompt(mbp);
seteom(mbp);
}
else
{
strncpy(hostname, host->h_name, sizeof(hostname));
}
} /* if (uCmd != OP_DEL) */
/* Optionale UDP-Parameter lesen */
skipsp(&clicnt, &clipoi);
/* Frischer Buffer */
memset(cBuf, 0, sizeof(cBuf));
/* Mode lesen (IP, UDP) */
for (i = 0; i < BUFLEN; ++i)
{
if ((!clicnt) || (*clipoi == ' '))
break;
clicnt--;
cBuf[i] = toupper(*clipoi++);
}
/* Mode bestimmen (UDP) */
/* Bei der Initialisierung wurde bereits IP eingestellt */
if ( (strcmp(cBuf, "UDP") == 0)
|| (cBuf[0] == 'U')
)
uMode = UDP_MODE;
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
port = DEFAULT_UDP_PORT;
else
{
/* neue UDP-Portnummer lesen */
port = nxtlong(&clicnt, &clipoi);
if ( (port <= 0)
||(port > 65535))
{
putmsg("error: UDP-port number not valid\r");
return;
}
}
/* Operation ausfuehren */
switch (uCmd)
{
/* Route hinzufuegen */
case OP_ADD :
#ifndef AXIPR_UDP
route_add((unsigned char*)&hostname, host, call, (uMode == UDP_MODE ? port : 0), (call[0] == 0 ? TRUE : FALSE)
break;
#else
if (route_add((unsigned char*)&hostname
, host
, call
, (uMode == UDP_MODE ? (int)port : 0)
, (call[0] == 0 ? TRUE : FALSE)
, 0
, hostname
#ifdef AXIPR_HTML
, timeset
, P_USER
#endif /* AXIPR_HTML */
))
putmsg("Call is registerd.\r");
return;
#endif /* AXIPR_UDP */
/* Route loeschen */
case OP_DEL :
#ifndef AXIPR_UDP
route_del(call);
break;
#else
if (route_del(call))
putmsg("Call is deleted!\r");
else
putmsg("Call no deleted!\r");
return;
#endif /* AXIPR_UDP. */
default : break;
}
mbp = getmbp();
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
}
else
{
/* ALTE SYNTAX */
/* Sysop will aendern und noch was in der Zeile da ? */
if (issyso() && skipsp(&clicnt, &clipoi))
{
clicnt--;
switch (toupper(*clipoi++))
{
case 'P': /* Parser aendern */
/* wir koennen nur in den neuen Parser umschalten */
new_parser = TRUE;
putmsg("Switched to new axipr-parser !!!\r");
return;
break;
case 'R': /* Routen-Eintrag */
/* Kommandozeile pruefen */
if (!skipsp(&clicnt, &clipoi))
{
putmsg(inv_par);
return;
}
clicnt--;
switch (*clipoi++)
{
case '-': /* Route loeschen */
/* Call lesen */
if (getcal(&clicnt, &clipoi, TRUE, (char *)call) != YES)
{
invcal();
return;
}
/* Call konvertieren */
for (i = 0; i < L2CALEN; ++i)
call[i] = call[i] << 1;
#ifdef AXIPR_UDP
/* und ab die Post ... */
mbp = getmbp();
if (route_del(call))
putstr("Call is delete!\r", mbp);
else
putstr("Call no delete!\r", mbp);
prompt(mbp);
seteom(mbp);
return;
#else
/* Route loeschen */
route_del(call);
break;
#endif /* AXIPR_UDP. */
case '+': /* Route hinzufuegen */
/* Call lesen */
if (getcal(&clicnt, &clipoi, TRUE, (char *)call) != YES)
{
invcal();
return;
}
/* Call linksschieben */
for (i = 0; i < L2CALEN; ++i)
call[i] = call[i] << 1;
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
putmsg("IP-Adress/Hostname missing\r");
return;
}
/* Frische Buffer */
memset(hostname, 0, sizeof(hostname));
/* Hostnamen / IP-Adresse lesen */
for (i = 0; i < HNLEN; ++i)
{
if (!clicnt || *clipoi == ' ')
break;
clicnt--;
hostname[i] = *clipoi++;
}
/* Hostname / IP-Adresse aufloesen */
if ((host = gethostbyname(hostname)) == NULL)
{
putmsg(inv_ip);
return;
}
/* Mode-Parameter vorhanden ? */
if (skipsp(&clicnt, &clipoi))
{
--clicnt;
switch (toupper(*clipoi++))
{
case 'I': /* IP: Port steht fest */
break;
case 'U': /* UDP: abweichenden Port lesen wenn vorhanden */
nextspace(&clicnt, &clipoi);
if (!skipsp(&clicnt, &clipoi))
port = DEFAULT_UDP_PORT;
else
{
port = nxtlong(&clicnt, &clipoi);
if ( (port <= 0)
||(port > 65535))
{
putmsg("error: UDP-port number not valid\r");
return;
}
}
break;
default: /* unbekannter Modus */
putmsg(inv_mode);
return;
}
}
/* Route hinzufuegen */
#ifndef AXIPR_UDP
route_add((unsigned char*)&hostname, host, call, (int) port, FALSE, 0);
break;
#else
if (route_add((unsigned char*)&hostname
, host
, call
, (int) port
, FALSE
, 0
, hostname
#ifdef AXIPR_HTML
, timeset
, P_USER
#endif /* AXIPR_HTML */
))
putmsg("Call is registerd.\r");
return;
#endif /* AXIPR_UDP */
}
break;
case 'D': /* Default Route aendern */
nextspace(&clicnt, &clipoi);
/* Noch Eingaben da ? */
if (!skipsp(&clicnt, &clipoi))
{
putmsg(inv_mode);
return;
}
clicnt--;
/* Operation bestimmen */
switch (*clipoi++)
{
case '-': /* Default Route loeschen */
#ifdef AXIPR_UDP
/* und ab die Post ... */
mbp = getmbp();
if (route_del((unsigned char *)""))
putstr("Call is delete!\r", mbp);
else
putstr("Call no delete!\r", mbp);
prompt(mbp);
seteom(mbp);
return;
#else
route_del((unsigned char *)"");
break;
#endif /* AXIPR_UDP. */
case '+': /* Default Route eingeben */
/* IP-Adresse / Hostname lesen */
if (!skipsp(&clicnt, &clipoi))
{
putmsg(inv_ip);
return;
}
/* Frische Buffer */
memset(hostname, 0, sizeof(hostname));
/* IP-Adresse / Hostname kopieren */
for (i = 0; i < HNLEN; ++i)
{
if (!clicnt || *clipoi == ' ')
break;
clicnt--;
hostname[i] = *clipoi++;
}
/* aufloesen */
if ((host = gethostbyname(hostname)) == NULL)
{
putmsg(inv_ip);
return;
}
/* Modus-Kennzeichner lesen falls vorhanden */
if (skipsp(&clicnt, &clipoi))
{
--clicnt;
switch (toupper(*clipoi++))
{
case 'I': /* IP: Port steht fest */
break;
case 'U': /* UDP: eventuell abweichenden Port lesen */
nextspace(&clicnt, &clipoi);
if (!skipsp(&clicnt, &clipoi))
port = DEFAULT_UDP_PORT;
else
{
port = nxtlong(&clicnt, &clipoi);
if ( (port <= 0)
||(port > 65535))
{
putmsg("error: UDP-port number not valid\r");
return;
}
}
break;
default: /* unbekannter Modus */
putmsg(inv_mode);
return;
}
}
/* Route eintragen */
#ifndef AXIPR_UDP
route_add((unsigned char*)&hostname, host, NULL, (int) port, TRUE, 0);
break;
#else
if (route_add((unsigned char*)&hostname
, host
, NULL
, (int) port
, TRUE
, 0
, hostname
#ifdef AXIPR_HTML
, timeset
, P_USER
#endif /* AXIPR_HTML */
))
putmsg("Call is registerd.\r");
return;
#endif /* AXIPR_UDP */
default:
putmsg(inv_mode);
return;
}
break;
/* Eigenen UDP-Port aendern */
case 'U':
/* neuer Port muss vorhanden sein */
if (!skipsp(&clicnt, &clipoi))
{
putmsg(inv_par);
return;
}
/* Port ermitteln. */
new_udp = nxtlong(&clicnt, &clipoi);
if ( (new_udp <= 0)
||(new_udp >= 65535))
{
putmsg("UDP-Port not valid, not changed !!!\r");
return;
}
#ifdef AXIPR_UDP
/* Neuer UDP-Port gleich MY-UDP? */
/* Keine Aenderungen durchfuehren. */
if (my_udp == htons((unsigned short)new_udp))
{
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
}
#endif /* AXIPR_UDP */
#ifndef AXIPR_UDP
/* Laufendes UDP aendern */
if (fd_udp != -1)
{
#endif
/* Versuchen, neuen UDP-Port anzulegen */
if ((tmp_fd = setup_udp(htons((unsigned short)new_udp))) != -1)
{
#ifndef AXIPR_UDP
/* Neuen Descriptor eintragen und alten schliessen */
close(fd_udp);
#else
/* Nur wenn alter Socket noch lebt, */
if (fd_udp != EOF)
/* dann schliessen wir den Socket. */
close(fd_udp);
#endif /* AXIPR_UDP */
fd_udp = tmp_fd;
/* Gibt es einen Eintrag. */
if (l1pp)
/* Check, ob neuer Filedescriptor groesser ist */
l1pp->kisslink = max(fd_ip, fd_udp);
/* Neuen UDP-Port merken */
my_udp = htons((unsigned short)new_udp);
}
else
{
putmsg("ERROR: Changing UDP-Port failed, Port not changed !!!\r");
return;
}
#ifndef AXIPR_UDP
}
else
{
/* neuen UDP-Port merken */
my_udp = htons(new_udp);
}
#endif
putmsg("UDP-Port successfully changed\r");
#ifdef AXIPR_UDP
return;
#else
break;
#endif /* AXIPR_UDP. */
/* Timeout fuer dynamische Routen aendern. */
case 'T':
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
putprintf(mbp, "the actual timeout for dynamic routes is : %u\r", uDynTimeout);
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* Timeout lesen */
uNewTimeout = nxtlong(&clicnt, &clipoi);
if ( (uNewTimeout < 0)
||(uNewTimeout > (86400))) /* max. 1 Tag */
{
putmsg("error: timeout out of range (0 - 86400) !\r");
return;
}
/* Wert uebernehmen */
uDynTimeout = uNewTimeout;
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
#ifdef AXIPR_UDP
/* Loglevel aendern. */
case 'L':
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
#ifdef SPEECH
putprintf(mbp, speech_message(299),loglevel);
#else
putprintf(mbp, "My LogLevel: %d\r",loglevel);
#endif
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* Loglevel lesen */
NewLogLevel = nxtnum(&clicnt, &clipoi);
if ( (NewLogLevel < 0)
||(NewLogLevel > 4))
{
#ifdef SPEECH
putmsg(speech_message(300));
#else
putmsg("errors: Log level worth from 0 to 4!\r");
#endif
return;
}
/* Wert uebernehmen */
loglevel = NewLogLevel;
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
#endif /* AXIPR_UDP */
#ifdef AXIPR_HTML
/* htmlstatistik aendern. */
case 'H':
/* Noch was da in der Kommandozeile ? */
if (!skipsp(&clicnt, &clipoi))
{
mbp = getmbp();
#ifdef SPEECH
putprintf(mbp, speech_message(347),HtmlStat);
#else
putprintf(mbp, "HTML-Statistic is %d\r", HtmlStat);
#endif
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
/* Loglevel lesen */
NewHtmlStat = nxtnum(&clicnt, &clipoi);
if ( (NewHtmlStat < 0)
||(NewHtmlStat > 1))
{
#ifdef SPEECH
putmsg(speech_message(348));
#else
putmsg("Error: HTML-Statistic worth from 0 to 1!\r\r");
#endif
return;
}
/* Wert uebernehmen */
HtmlStat = NewHtmlStat;
/* und ab die Post ... */
mbp = getmbp();
prompt(mbp);
seteom(mbp);
return;
#endif
/* Unbekannte Kommandos */
default:
putmsg(inv_par);
return;
}
}
}
mbp = putals("AXIP-Routes:\rCall-------IP----------------Mode--Port--Timeout--IP/Hostname----\r");
/* Alle Routingtabelleneintraege durchgehen und ausgeben */
for (i = 0; i < route_tbl_top; ++i)
show_rt_entry(route_tbl[i], mbp);
/* Default-Route ausgeben wenn vorhanden */
if (default_route.callsign[0] == 1)
show_rt_entry(default_route, mbp);
putprintf(mbp, "-----------------------------------------------------------------\r");
/* Eigenen UDP-Port ausgeben */
putprintf(mbp, "UDP-port (%u): ", ntohs(my_udp));
putprintf(mbp, "%s", (fd_udp != -1 ? "active" : "not active"));
/* IP-Status ausgeben */
putprintf(mbp, ", IP-protocol (family %u): ", IPPROTO_AX25);
putprintf(mbp, "%s", (fd_ip != -1 ? "active" : "not active"));
/* Timeout des dynamischen Routenlerners ausgeben */
putprintf(mbp, "\rTimeout for dynamically learned routes is %u seconds.\r", uDynTimeout);
/* Hostname -> IP-Adresse Aktualisierungsintervall ausgeben */
putprintf(mbp, "Hostname-to-IP-adress conversion ");
if (uNamesUpdate != 0)
putprintf(mbp, "occurs every %u seconds.\r", uNamesUpdate / 100);
else
putprintf(mbp, "is disabled.\r");
#ifdef AXIPR_UDP
#ifdef SPEECH
putprintf(mbp, speech_message(299), loglevel);
#else
putprintf(mbp, "My LOGLevel is %u.\r", loglevel);
#endif /* SPEECH */
#endif /* AXIPR_UDP */
#ifdef AXIPR_HTML
#ifdef SPEECH
putprintf(mbp, speech_message(347), HtmlStat);
#else
putprintf(mbp, "My HTML-Statistic is %d.\r", HtmlStat);
#endif /* SPEECH */
#endif /* AXIPR_HTML */
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
}
/* Routeneintraege fuer parms.tnb ausgeben */
void dump_ax25ip(MBHEAD* mbp)
{
register int i;
putstr(";\r; AX25IP Routes\r;\r", mbp);
if (ax25ip_active == FALSE)
return;
if (new_parser == TRUE)
{
putstr("; WARNING: this section is written using the new syntax of the AXIPR-command,\r", mbp);
putstr("; DO NOT USE with older TNNs compiled only for old style syntax !!!\r;\r", mbp);
/* Falls wir noch im alten Parser sind, dann umschalten */
putprintf(mbp, "AXIPR P\r");
/* eigenen UDP-Port ausgeben */
putprintf(mbp, "AXIPR MYUDP %u\r", ntohs(my_udp));
/* Timeout fuer dynamische Routen ausgeben */
putprintf(mbp, "AXIPR TIMEOUT %u\r", uDynTimeout);
/* Intervall fuer Hostnamen-Update ausgeben */
putprintf(mbp, "AXIPR LOOKUP %u\r", uNamesUpdate);
}
#ifdef AXIPR_UDP
/* eigenen UDP-Port ausgeben */
putprintf(mbp, "AXIPR U %u\r", ntohs(my_udp));
/* Timeout fuer dynamische Routen ausgeben */
putprintf(mbp, "AXIPR T %u\r", uDynTimeout);
putprintf(mbp, "AXIPR L %d\r",loglevel);
#ifdef AXIPR_HTML
putprintf(mbp, "AXIPR H %d\r",HtmlStat);
#endif /* AXIPR_HTML */
#endif /* AXIPR_UDP */
/* alle Routingtabelleneintraege durchgehen und ausgeben */
for (i = 0; i < route_tbl_top; ++i)
{
/* Dynamisch gelernte Routen werden inaktiv zur Information geschrieben ! */
if (route_tbl[i].timeout != 0)
continue;
/* putprintf(mbp, "; ");*/
/* Eintrag einer Route erzeugen */
putprintf(mbp, (new_parser == FALSE ? "AXIPR R + %s " : "AXIPR ADD %s ")
, call_to_a(&route_tbl[i].callsign[0]));
/* Den Hostnamen ausgeben */
putprintf(mbp, "%s", route_tbl[i].hostname);
/* Mode und ggf. Port ausgeben wenn UDP */
if (route_tbl[i].udp_port != 0)
{
putstr((new_parser == FALSE ? " U " : " UDP "), mbp);
putnum(ntohs(route_tbl[i].udp_port), mbp);
}
putstr("\r", mbp);
}
/* Die Defaultroute ausgeben wenn gesetzt */
if (default_route.callsign[0] == 1)
{
/* Kommandokopf schreiben */
putstr((new_parser == FALSE ? "AXIPR D + " : "AXIPR ADD DEFAULT "), mbp);
/* Den Hostnamen ausgeben */
putprintf(mbp, "%s", default_route.hostname);
/* Mode und ggf. Port ausgeben wenn UDP */
if (default_route.udp_port != 0)
{
putstr((new_parser == FALSE ? " U " : " UDP "), mbp);
putnum(ntohs(default_route.udp_port), mbp);
}
putstr("\r", mbp);
}
}
/************************************************************************/
/* AX25IP Initialisierung */
/************************************************************************/
BOOLEAN ax25ip_l1init(int l2port)
{
if (ax25ip_active == TRUE)
return(TRUE);
/* Socketstrukturen initialisieren */
memset((char*)&to, 0, sizeof(to));
memset((char*)&from, 0, sizeof(from));
ax25ip_port = l2port;
l1pp = &l1port[l1ptab[l2port]];
l2flp = (LHEAD *) &txl2fl[l2port];
/* Routingtabelle initialisieren */
route_init();
/* Konfiguration einlesen */
if (config_read() == FALSE)
return(FALSE);
/* Notwendige Sockets anlegen */
#ifndef AXIPR_UDP
ax25ip_check_up();
#endif
/* Wir sind fertig */
ax25ip_active = TRUE;
return(TRUE);
}
/* Einen Filedescriptor fuer IP anlegen */
int setup_ip(void)
{
/* Temporaerer Filedescriptor */
int tmp_fd = -1;
/* Adressstruktur loeschen */
memset((char*)&ipbind, 0, sizeof(ipbind));
/* Rohen IP-Socket anlegen */
if ((tmp_fd = socket(AF_INET, SOCK_RAW, IPPROTO_AX25)) < 0)
{
xprintf("AX25IP : cannot create ip raw-socket: %s\n", strerror(errno));
LOGL2("AX25IP : cannot create ip raw-socket: %s\n", strerror(errno));
return(-1);
}
/* Nonblocking-IO */
if (fcntl(tmp_fd, F_SETFL, FNDELAY) < 0)
{
xprintf("AX25IP : cannot set non-blocking I/O on ip raw-socket\n");
LOGL2("AX25IP : cannot set non-blocking I/O on ip raw-socket\n");
close(tmp_fd);
return(-1);
}
/* Adressstruktur mit notwendigen Werten fuellen */
ipbind.sin_family = AF_INET;
ipbind.sin_addr.s_addr = htonl(INADDR_ANY);
return (tmp_fd);
}
/* Einen Filedescriptor fuer UDP anlegen */
/* Es muss der UDP-Port angegeben werden, auf dem wir hoeren wollen */
/* (Achtung: UDP-Port in Network-Byteorder) */
int setup_udp(unsigned short udp_port)
{
/* Temporaerer Filedescriptor */
int tmp_fd = -1;
/* Port-Check */
if (udp_port == 0)
return(-1);
/* Adressstruktur loeschen */
memset((char*)&udpbind, 0, sizeof(udpbind));
/* UDP-Socket anlegen */
if ((tmp_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
xprintf("AX25IP : cannot create socket: %s\n", strerror(errno));
LOGL2("AX25IP : cannot create socket: %s\n", strerror(errno));
return(-1);
}
/* Nonblocking-IO */
if (fcntl(tmp_fd, F_SETFL, FNDELAY) < 0)
{
xprintf("AX25IP : cannot set non-blocking I/O on udp socket\n");
LOGL2("AX25IP : cannot set non-blocking I/O on udp socket\n");
close(tmp_fd);
return(-1);
}
/* Socket-Optionen fuer UDP einstellen */
/* SO_KEEPALIVE einschalten */
if (sockopt_keepalive == TRUE)
{
int iFlag = 1;
if (setsockopt(tmp_fd, SOL_SOCKET, SO_KEEPALIVE, (const char *)&iFlag, sizeof(int)) < 0)
{
xprintf("AX25IP : cannot set SO_KEEPALIVE for udp : %s\n", strerror(errno));
LOGL2("AX25IP : cannot set SO_KEEPALIVE for udp : %s\n", strerror(errno));
}
}
/* Socket auf max. Durchsatz */
if (sockopt_throughput == TRUE)
{
int iFlag = IPTOS_THROUGHPUT;
if (setsockopt(tmp_fd, IPPROTO_IP, IP_TOS, (const char *)&iFlag, sizeof(IPTOS_THROUGHPUT)) < 0)
{
xprintf("AX25IP : cannot set IPTOS_THROUGHPUT for udp : %s\n", strerror(errno));
LOGL2("AX25IP : cannot set IPTOS_THROUGHPUT for udp : %s\n", strerror(errno));
}
}
/* Adressstruktur fuellen */
udpbind.sin_addr.s_addr = htonl(INADDR_ANY);
udpbind.sin_port = udp_port;
udpbind.sin_family = AF_INET;
/* Adresse und Port binden */
if (bind(tmp_fd, (struct sockaddr *)&udpbind, sizeof(udpbind)) < 0)
{
xprintf("AX25IP : cannot bind udp socket: %s\n", strerror(errno));
LOGL2("AX25IP : cannot bind udp socket: %s\n", strerror(errno));
close(tmp_fd);
return(-1);
}
return(tmp_fd);
}
/* Pruefen, ob schon Sockets angelegt sind, wenn nicht, dann notwendige */
/* Sockets oeffnen */
void ax25ip_check_up(void)
{
/* IP notwendig ? */
if ((count_routes(FALSE) != 0) && (fd_ip == -1))
fd_ip = setup_ip(); /* IP starten */
/* UDP notwendig ? */
if ((count_routes(TRUE) != 0) && (fd_udp == -1))
fd_udp = setup_udp(my_udp); /* UDP starten */
#ifdef AXIPR_UDP
if (l1pp != NULL)
#endif
/* Markieren, ob IP oder UDP laufen */
l1pp->kisslink = max(fd_ip, fd_udp);
}
/* Pruefen, ob Sockets angelegt sind und diese noch benoetigt werden. */
/* Falls nicht, Sockets schliessen */
void ax25ip_check_down(void)
{
/* IP notwendig ? */
if ((count_routes(FALSE) == 0) && (fd_ip != -1))
{
close(fd_ip);
fd_ip = -1;
}
/* UDP notwendig ? */
if ((count_routes(TRUE) == 0) && (fd_udp != -1))
{
close(fd_udp);
fd_udp = -1;
}
/* Gibt es einen Eintrag. */
if (l1pp)
/* Markieren, ob IP oder UDP laufen */
l1pp->kisslink = max(fd_ip, fd_udp);
}
/*************************************************************************/
/* AX25IP Pakete empfangen */
/*************************************************************************/
void ax25ip_recv(void)
{
struct iphdr *ipptr;
struct timeval tv;
int l = 0;
int iDescriptorsReady = 0;
register int i = 0;
register int max_fd = -1;
socklen_t fromlen = sizeof(from);
int hdr_len = 0;
UBYTE buf[MAX_FRAME+1];
UBYTE *bufptr;
MBHEAD *rxfhd;
BOOLEAN UDP_Frame = FALSE;
fd_set rmask;
#ifdef AXIPR_UDP
if (LookAX25IP)
return;
#endif /* AX25IP_UDP */
FD_ZERO(&rmask);
/* IP-Filedescriptor eintragen */
if (fd_ip != -1)
{
FD_SET((unsigned int)fd_ip, &rmask);
if (fd_ip > max_fd - 1)
max_fd = fd_ip + 1;
}
/* UDP-Filedescriptor eintragen */
if (fd_udp != -1)
{
FD_SET((unsigned int)fd_udp, &rmask);
if (fd_udp > max_fd - 1)
max_fd = fd_udp + 1;
}
/* ist was aktiv ? */
if (max_fd == -1)
return;
tv.tv_usec = 0;
tv.tv_sec = 0;
iDescriptorsReady = select(max_fd, &rmask, NULL, NULL, &tv);
/* nix da */
if (iDescriptorsReady == 0)
return;
/* Fehler */
if (iDescriptorsReady == -1)
{
LOGL2("select()-Error %i: %s", errno, strerror(errno));
return;
}
/* RX fuer IP */
if ((fd_ip != -1) && (FD_ISSET(fd_ip, &rmask)))
{
l = recvfrom(fd_ip, (UBYTE *)(bufptr = buf), MAX_FRAME, 0, (struct sockaddr *) &from, &fromlen);
if (l > 0)
{
if (l > (signed)sizeof(struct iphdr*))
{
ipptr = (struct iphdr*)buf;
hdr_len = 20;
if (!ok_crc(buf + hdr_len, l - hdr_len))
{ /* stimmt die CRC ? */
LOGL2("IP-RX: CRC-Error, frame dropped");
return; /* Fehler */
}
}
else
{
LOGL2("IP-RX: frame too short, frame dropped");
return; /* Fehler */
}
}
i = hdr_len;
}
/* RX fuer UDP, aber nur, wenn nicht schon TCP was empfangen hat */
if ((fd_udp != -1) && (FD_ISSET(fd_udp, &rmask) && (l == 0)))
{
l = recvfrom(fd_udp, (UBYTE *)(bufptr = buf), MAX_FRAME, 0, (struct sockaddr *) &from, &fromlen);
if (l > 0)
{
if (!ok_crc(buf, l))
{ /* stimmt die CRC ? */
LOGL2("UDP-RX: CRC-Error, frame dropped");
return; /* Fehler */
}
}
UDP_Frame = TRUE;
}
/* Ab hier gemeinsame Behandlung */
/* Erst mal gucken, ob was gekommen ist */
if (l == 0)
return; /* nix da */
l -= 2; /* CRC abschneiden */
if (l < 15)
{
LOGL2("AX25IP: RX frame dropped, length wrong, frame is too short !");
return;
}
/* Hier angekommen haben wir (hoffentlich) ein gueltiges Frame. Die */
/* weitere Behandlung ist fuer IP und UDP nahezu identisch. */
/* Frame in Buffer umkopieren und Empfangsport eintragen */
rxfhd = cpyflatmb((char*)&buf[i], l - i);
rxfhd->l2port = ax25ip_port;
/* Frame in die L2-RX-Kette einhaengen */
relink((LEHEAD *)rxfhd, (LEHEAD *)rxfl.tail);
/* Jetzt noch das Frame an den Routenlerner zur Analyse */
if (route_canlearn(rxfhd))
{
/* Frame kann zum Lernen benutzt werden */
/* Absenderrufzeichen ermitteln und konvertieren */
/* Wir brauchen hier nicht den eigentlichen Absender, */
/* sondern den, der als letztes gedigipeated hat. */
struct in_addr ipaddr;
#ifndef AXIPR_UDP
struct route_table_entry* rtptr;
#endif /* AXIPR_UDP */
unsigned char srccall[L2IDLEN + 1];
cpyid((char *)srccall, dheardcall(rxfhdr));
/* Call linksschieben */
for (i = 0; i < L2CALEN; ++i)
srccall[i] = srccall[i] << 1;
/* Gibt es schon eine IP fuer dieses Call, dann kann sich die IP */
/* geaendert haben. Falls ja und es sich um einen dynamischen Eintrag */
/* handelt, dann loeschen und neuen Eintrag anlegen. */
#ifndef AXIPR_UDP
if ((rtptr = call_to_ip(srccall)) != NULL)
{
if (( (rtptr->ip_addr != from.sin_addr.s_addr)
|| (rtptr->udp_port != (UDP_Frame == TRUE ? ntohs(from.sin_port) : 0)))
&& (rtptr->timeout != 0))
route_del(srccall); /* Route loeschen */
else
{
if (rtptr != &default_route)
return; /* Adresse unveraendert */
}
}
#endif /* AXIPR_UDP */
ipaddr.s_addr = from.sin_addr.s_addr;
#ifndef AXIPR_UDP
/* Route eintragen */
route_add((unsigned char*)inet_ntoa(ipaddr), NULL, srccall,
(UDP_Frame == TRUE ? ntohs(from.sin_port) : 0), FALSE, uDynTimeout);
#else
route_analyse(ipaddr, srccall,
(UDP_Frame == TRUE ? ntohs(from.sin_port) : 0));
}
#endif /* AXIPR_UDP */
}
/*************************************************************************/
/* AX25IP Pakete senden */
/*************************************************************************/
void ax25ip_send(void)
{
unsigned char buf[MAX_FRAME];
int len = 0;
int fd = -1;
MBHEAD *txfhdl;
struct route_table_entry *rt;
struct hostent *hstent;
unsigned char *call;
if (kick[ax25ip_port]) /* haben wir was zu senden ? */
{
/* Sicherheitsabfrage, da kick[] auch manipuliert werden kann */
if (l2flp->head == l2flp)
{
kick[ax25ip_port] = FALSE;
return;
}
ulink((LEHEAD *)(txfhdl = (MBHEAD *) l2flp->head));/*Zeiger holen*/
/* Daten aus den internen Puffern in einen linearen Puffer uebertragen */
len = cpymbflat((char*)&buf[0], txfhdl);
relink((LEHEAD *)txfhdl, /* als gesendet betrachten und in */
(LEHEAD *)stfl.tail); /* die gesendet Liste umhaengen */
kick[ax25ip_port] = ((LHEAD *)l2flp->head != l2flp);
/* Naechstes Call der Digipeaterkette holen */
call = next_addr(buf);
/* IP-Adresse des naechsten Digipeaters ermitteln */
rt = call_to_ip(call);
if (rt == NULL) /* wir kennen das Ziel nicht */
{
#ifdef AXIPR_UDP
if ((rt = search_route(call)) == NULL)
{
#endif
LOGL2("no route for %s, can't send", call_to_a(call));
return;
}
#ifdef AXIPR_UDP
}
#endif
/* Ein Host, zu dem bisher keine IP-Adresse aufgeloest werden konnte */
if (rt->ip_addr == 0L)
{
/* Versuchen, jetzt eine IP-Adresse zu bestimmen */
if ((hstent = gethostbyname((char*)rt->hostname)) != NULL)
memcpy((unsigned char*)&rt->hostname, (unsigned char *)&hstent->h_addr_list[0][0], 4);
}
/* Checksumme anhaengen */
add_ax25crc(buf, len);
/* CRC-Bytes sind dazugekommen */
len += 2;
/* Ziel-IP-Adresse in Sendestruktur eintragen */
memcpy((char *) &to.sin_addr, (char *)&rt->ip_addr, 4);
/* Ziel-Port nur bei UDP eintragen */
if (rt->udp_port != 0)
memcpy((char *) &to.sin_port, (char *)&rt->udp_port, 2);
else
to.sin_port = 0; /* bei IP kein Port */
to.sin_family = AF_INET;
/* Unterscheidung IP oder UDP */
if (to.sin_port == 0)
fd = fd_ip;
else
fd = fd_udp;
if (fd == -1)
{
LOGL2("error: no descriptor, can't send !!!");
return;
}
if (sendto(fd, (char *)buf, len, 0, (struct sockaddr *)&to, sizeof(to)) < 0)
LOGL2("error: sendto failed, fd=%u error=%s", fd, strerror(errno));
}
}
/*************************************************************************/
/* AX25IP Deinitialisierung, Port und Sockets schliessen */
/*************************************************************************/
void ax25ip_l1exit(void)
{
/* Nur wenn aktiv */
if (ax25ip_active == FALSE)
return;
/* IP-Socket schliessen wenn offen */
if (fd_ip != -1)
{
close(fd_ip);
fd_ip = -1;
}
/* UDP-Socket schliessen wenn offen */
if (fd_udp != -1)
{
close(fd_udp);
fd_udp = -1;
}
/* AX25IP nicht mehr aktiv */
ax25ip_active = FALSE;
/* Gibt es einen Eintrag. */
if (l1pp)
l1pp->kisslink = -1;
}
void ax25ip_l1ctl(int req, int port)
{
/* nur eigene Ports bearbeiten */
if ((ax25ip_active == FALSE) || (kissmode(port) != KISS_AXIP))
return;
switch (req)
{
/* Testpattern auf dem Port senden (wird unterdrueckt) */
case L1CTST : testflag[port] = FALSE;
kick[port] = FALSE;
break;
default : break;
}
}
void ax25ip_hwstr(int port, MBHEAD *mbp)
{
#ifdef AXIPR_UDP
putstr(" ", mbp);
/* My UDP-Port ausgeben. */
putprintf(mbp,"%u", ntohs(my_udp));
#endif
}
BOOLEAN ax25ip_dcd(int port)
{
return (FALSE);
}
/* routing.c Routing table manipulation routines
*
* Copyright 1991, Michael Westerhof, Sun Microsystems, Inc.
* This software may be freely used, distributed, or modified, providing
* this header is not removed.
*
* Modified for use in TNN by DG1KWA & DG9OBU
*/
/* Initialize the routing table */
void route_init(void)
{
/* Defaultroute initialisieren */
memset(&default_route, 0 , sizeof(struct route_table_entry));
/* Routen initialisieren */
memset(&route_tbl, 0, (TABLE_SIZE * sizeof(struct route_table_entry)));
}
/* Add a new route entry */
#ifndef AXIPR_UDP
static void route_add(unsigned char* hostname, struct hostent *hstent, unsigned char *call, int udpport,
int default_rt, int timeout)
#else
static BOOLEAN route_add(unsigned char *host, struct hostent *hstent, unsigned char *call, int udpport,
int default_rt, int timeout, char *hostname
#ifdef AXIPR_HTML
, char *timeset, UWORD protokoll
#endif /* AXIPR_HTML */
)
#endif /* AXIPR_UDP */
{
register unsigned int i = 0;
struct route_table_entry *rtptr;
struct hostent *hst;
/* Eintrag soll Defaultroute sein */
if (default_rt)
{
for (i = 1; i < 7 ;++i)
default_route.callsign[i] = 0;
if (hstent != NULL)
memcpy(&default_route.ip_addr, (unsigned char *)&hstent->h_addr_list[0][0], 4);
else
memset(&default_route.ip_addr, 0, 4);
default_route.udp_port = htons((unsigned short)udpport);
default_route.timeout = 0; /* Defaultroute ohne Timeout */
if (hostname != NULL)
strncpy((char*)&default_route.hostname, (char*)hostname, HNLEN);
default_route.callsign[0] = 1; /* mark valid */
/* Socket ggf. installieren */
ax25ip_check_up();
#ifndef AXIPR_UDP
return;
#else
return(TRUE);
#endif /* AXIPR_UDP */
}
/* Normale Routen nur wenn Call vorhanden */
if (call == NULL)
#ifndef AXIPR_UDP
return;
#else
return(FALSE);
#endif /* AXIPR_UDP */
/* Check auf doppelte Eintraege, Eintrag wird nur angenommen wenn */
/* es noch noch keinen Eintrag unter diesem Call gibt. */
if (((rtptr = call_to_ip(call)) != NULL) && (rtptr->ip_addr != default_route.ip_addr))
{
#ifndef AXIPR_UDP
putmsg("A route to this callsign is already set up, delete it first.\r");
return;
#else
#ifndef AXIPR_HTML
UpdateRoute(call, udpport, timeout, hostname);
#else
UpdateRoute(call, udpport, timeout, hostname, timeset, protokoll);
#endif /* AXIPR_HTML */
return(FALSE);
#endif /* AXIPR_UDP */
}
/* Passt noch ein Eintrag in die Tabelle ? */
if (route_tbl_top >= TABLE_SIZE)
{
xprintf("Routing table is full; entry ignored.\n");
LOGL2("Routing table is full; entry ignored");
putmsg("Routing table is full, entry ignored\r");
#ifndef AXIPR_UDP
return;
#else
return(FALSE);
#endif /* AXIPR_UDP */
}
/* Call eintragen */
for (i = 0; i < 6; ++i)
route_tbl[route_tbl_top].callsign[i] = call[i] & 0xfe;
/* SSID eintragen */
route_tbl[route_tbl_top].callsign[6] = (call[6] & 0x1e) | 0x60;
if (hstent != NULL && hstent->h_length != 0)
{
memcpy((unsigned char*)&route_tbl[route_tbl_top].ip_addr, (unsigned char *)&hstent->h_addr_list[0][0], 4);
}
else
memset(&route_tbl[route_tbl_top].ip_addr, 0, sizeof(route_tbl[route_tbl_top].ip_addr));
route_tbl[route_tbl_top].udp_port = htons((unsigned short)udpport);
route_tbl[route_tbl_top].timeout = timeout;
if (hostname != NULL)
{
memcpy(&route_tbl[route_tbl_top].hostname, hostname, strlen((char*)hostname));
/* Keine Adressaufloesung bisher, dann probieren wir es noch einmal */
if (hstent == NULL)
{
if ((hst = gethostbyname((char*)hostname)) != NULL)
memcpy((unsigned char*)&route_tbl[route_tbl_top].ip_addr, &hst->h_addr_list[0][0], 4);
}
}
#ifdef AXIPR_UDP
/* Original UDP-Port eintragen. */
route_tbl[route_tbl_top].org_udp_port = htons((UWORD)udpport);
#endif
#ifdef AXIPR_HTML
/* Hostname eintragen. */
(void)memcpy(route_tbl[route_tbl_top].timeset, timeset, 17);
/* Protokoll eintragen. */
route_tbl[route_tbl_top].protokoll = P_USER;
/* Route als offline markieren. */
route_tbl[route_tbl_top].online = FALSE;
#endif
/* Ein Routeneintrag mehr */
route_tbl_top++;
/* Socket ggf. installieren */
ax25ip_check_up();
#ifndef AXIPR_UDP
return;
#else
return(TRUE);
#endif /* AXIPR_UDP */
}
/*
* Return an IP address and port number given a callsign.
* We return a pointer to the route structure for this callsign
* or a NULL-pointer if no route was found.
*/
struct route_table_entry* call_to_ip(unsigned char *call)
{
register int i;
unsigned char mycall[7];
/* Leere Calls koennen nicht verarbeitet werden */
if (call == NULL)
return (NULL);
/* Call-Bytes kopieren, letztes Bit abschneiden (entspricht >> 1 & 7F) */
for (i = 0; i < 6; ++i)
mycall[i] = call[i] & 0xfe;
/* SSID kopieren */
mycall[6] = (call[6] & 0x1e) | 0x60;
/* Routingtabelle durchsuchen */
for (i = 0; i < route_tbl_top; ++i)
{
if (addrmatch(mycall , route_tbl[i].callsign))
{
/* Aktivitaet auf diesem Eintrag, dann Timeout erneuern */
if (route_tbl[i].timeout)
route_tbl[i].timeout = uDynTimeout;
return (&route_tbl[i]); /* Eintrag gefunden */
}
}
/* Kein Routingeintrag vorhanden, Default-Route melden wenn vorhanden */
if (default_route.callsign[0])
return (&default_route);
/* Kein Routingeintrag gefunden, keine Defaultroute */
return (NULL);
}
/*
* tack on the CRC for the frame. Note we assume the buffer is long
* enough to have the two bytes tacked on.
*/
void add_ax25crc(unsigned char *buf, int l)
{
unsigned short int u = compute_crc(buf, l);
buf[l] = u & 0xff; /* lsb first */
buf[l + 1] = (u >> 8) & 0xff; /* msb next */
}
/*
**********************************************************************
* The following code was taken from Appendix B of RFC 1171
* (Point-to-Point Protocol)
*
* The RFC credits the following sources for this implementation:
*
* Perez, "Byte-wise CRC Calculations", IEEE Micro, June, 1983.
*
* Morse, G., "Calculating CRC's by Bits and Bytes", Byte,
* September 1986.
*
* LeVan, J., "A Fast CRC", Byte, November 1987.
*
*
* The HDLC polynomial: x**0 + x**5 + x**12 + x**16
*/
/*
* u16 represents an unsigned 16-bit number. Adjust the typedef for
* your hardware.
*/
/*typedef unsigned short u16;*/
/*
* FCS lookup table as calculated by the table generator in section 2.
*/
static UWORD fcstab[256] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};
#define PPPINITFCS 0xffff /* Initial FCS value */
#define PPPGOODFCS 0xf0b8 /* Good final FCS value */
/*
* Calculate a new fcs given the current fcs and the new data.
*/
UWORD pppfcs(register UWORD fcs, register unsigned char *cp, register int len)
{
while (len--)
fcs = (fcs >> 8) ^ fcstab[(fcs ^ *cp++) & 0xff];
return(fcs);
}
/*
* End code from Appendix B of RFC 1171
**********************************************************************
*/
/*
* The following routines are simply convenience routines...
* I'll merge them into the mainline code when suitably debugged
*/
/* Return the computed CRC */
UWORD compute_crc(unsigned char *buf, int l)
{
UWORD fcs = (pppfcs(PPPINITFCS, buf, l) ^ 0xFFFF);
return (fcs);
}
/* Return true if the CRC is correct */
BOOLEAN ok_crc(unsigned char *buf, int l)
{
UWORD fcs = pppfcs(PPPINITFCS, buf, l);
return (fcs == PPPGOODFCS);
}
/* return true if the addresses supplied match */
int addrmatch(unsigned char *a, unsigned char *b)
{
if ((*a == '\0') || (*b == '\0')) return(0);
if ((*a++ ^ *b++) & 0xfe) return(0); /* "K" */
if ((*a++ ^ *b++) & 0xfe) return(0); /* "A" */
if ((*a++ ^ *b++) & 0xfe) return(0); /* "9" */
if ((*a++ ^ *b++) & 0xfe) return(0); /* "W" */
if ((*a++ ^ *b++) & 0xfe) return(0); /* "S" */
if ((*a++ ^ *b++) & 0xfe) return(0); /* "B" */
if ((*a++ ^ *b++) & 0x1e) return(0); /* ssid */
return(1);
}
/* return pointer to the next station to get this packet */
unsigned char *next_addr(unsigned char *f)
{
unsigned char *a;
/* If no digis, return the destination address */
if (NO_DIGIS(f)) return(f);
/* check each digi field. The first one that hasn't seen it is the one */
a = f + 7;
do {
a += 7;
if (NOTREPEATED(a)) return(a);
} while (NOT_LAST(a));
/* all the digis have seen it. return the destination address */
return(f);
}
/* Open and read the config file */
int config_read(void)
{
FILE *cf;
char buf[256], cbuf[256];
int errflag = 0;
int e = 0;
int lineno = 0;
char cfgfile[256];
strcpy(cfgfile, confpath);
strcat(cfgfile, CONFIG_FILE);
if ((cf = fopen(cfgfile, "r")) == NULL)
{
#ifdef INIPATH
strcpy(cfgfile, INIPATH);
strcat(cfgfile, CONFIG_FILE);
if ((cf = fopen(cfgfile, "r")) == NULL)
{
#endif
#ifdef AXIPR_UDP
/* AX25IP.CFG ist nicht mehr noetig, */
/* kann aber weiterhin benutzt werden. */
return(TRUE);
#endif
xprintf("AX25IP: Config file %s not found or could not be opened\n", CONFIG_FILE);
return(FALSE);
#ifdef INIPATH
}
#endif
}
while (fgets(buf, 255, cf) != NULL)
{
(void)strcpy(cbuf, buf);
++lineno;
if ((e = parse_line(buf)) < 0)
{
xprintf("Config error at line %d: ", lineno);
switch (e)
{
case -1 : xprintf("Missing argument\n"); break;
case -2 : xprintf("Bad callsign format\n"); break;
case -3 : xprintf("Bad option - on/off\n"); break;
case -4 : xprintf("Bad option - tnc/digi\n"); break;
case -5 : xprintf("Host not known\n"); break;
case -6 : xprintf("Unknown command\n"); break;
case -7 : xprintf("Text string too long\n"); break;
case -8 : xprintf("Bad option - every/after\n"); break;
case -9 : xprintf("Bad option - ip/udp\n"); break;
default: xprintf("Unknown error\n"); break;
}
xprintf("%s", cbuf);
++errflag;
}
}
if (errflag)
exit(1);
if (mode == NO_MODE)
{
xprintf("Must specify ip and/or udp sockets\n");
return(FALSE);
}
fclose(cf);
return(TRUE);
}
/* Process each line from the config file. The return value is encoded. */
int parse_line(char *buf)
{
char *p;
char *q;
char hostname[HNLEN];
unsigned char tcall[7];
struct hostent hstent;
struct hostent *he;
int i = 0;
int uport = 0;
int dfalt = 0;
#ifdef AXIPR_HTML
char *timeset = set_time();
#endif
p = strtok(buf, " \t\n\r");
memset(&hstent, 0, sizeof(hstent));
/* Leere Zeilen */
if (p == NULL)
return(0);
/* Kommentarzeilen nicht auswerten */
if (*p == '#')
return(0);
if (strcmp(p, "socket") == 0)
{
q = strtok(NULL, " \t\n\r");
if (q == NULL)
return(-1);
if (strcmp(q, "ip") == 0)
mode = IP_MODE;
else if (strcmp(q, "udp") == 0)
{
mode = UDP_MODE;
my_udp = htons(DEFAULT_UDP_PORT);
/* Bei UDP optionale Portnummer lesen */
q = strtok(NULL, " \t\n\r");
/* Nummer war vorhanden, auswerten */
if (q != NULL)
{
i = atoi(q);
/* Nummer ist gueltig, uebernehmen */
if (i > 0)
my_udp = htons((unsigned short)i);
}
}
else
return(-9);
return(0);
}
else if (strcmp(p, "socketoption") == 0)
{
q = strtok(NULL, " \t\n\r");
/* Pruefung auf leere Zeile */
if (q == NULL)
return(-1);
if (strcmp(q, "SO_KEEPALIVE") == 0)
{
sockopt_keepalive = TRUE;
}
else if (strcmp(q, "IPTOS_THROUGHPUT") == 0)
{
sockopt_throughput = TRUE;
}
else return(-9);
return(0);
} else if (strcmp(p, "loglevel") == 0) {
q = strtok(NULL, " \t\n\r");
if (q == NULL) return(-1);
loglevel = atoi(q);
return(0);
} else if (strcmp(p, "route") == 0) {
uport = 0;
dfalt = 0;
q = strtok(NULL, " \t\n\r");
/* Pruefung auf leere Zeile */
if (q == NULL)
return(-1);
/* Pruefung auf default-Route */
if (strcmp(q, "default") == 0)
dfalt = 1;
else
{
/* Ziel der Route pruefen */
if (a_to_call(q, tcall) != 0)
return(-2);
}
/* Hostnamen holen, dies kann auch eine IP-Adresse sein */
q = strtok(NULL, " \t\n\r");
if (q == NULL)
return(-1);
he = gethostbyname(q);
/* Keine gueltige IP-Adresse ? */
if (he == NULL)
{
/* Da route_add() eine hostent-Struktur braucht, bauen wir ihm eine. */
/* Den Hostname sichern und den Zeiger auf den Puffer im hostent eintragen. */
strncpy(hostname, q, HNLEN);
he = &hstent;
he->h_name = hostname;
}
q = strtok(NULL, " \t\n\r");
if (q != NULL)
{
if (strcmp(q, "udp") == 0)
{
uport = DEFAULT_UDP_PORT;
q = strtok(NULL, " \t\n\r");
if (q != NULL)
{
i = atoi(q);
if (i > 0)
uport = i;
}
}
}
#ifndef AXIPR_UDP
route_add((unsigned char*)he->h_name, he, tcall, uport, dfalt, 0);
#else
route_add((unsigned char*)he->h_name, he, tcall, uport, dfalt, 0, (char*)he->h_name
#ifdef AXIPR_HTML
, timeset, P_USER
#endif /* AXIPR_HTML */
);
#endif /* AXIPR_UDP */
return(0);
}
return(-999);
}
/* Convert ascii callsign to internal format */
int a_to_call(char *text, unsigned char *tcall)
{
register size_t i = 0;
int ssid = 0;
unsigned char c;
if (strlen(text) == 0)
return(-1);
for (i = 0; i < 6; ++i)
tcall[i] = (' ' << 1);
tcall[6] = '\0';
for (i = 0; i < strlen(text); ++i)
{
c = text[i];
if (c == '-')
{
ssid = atoi(&text[i + 1]);
if (ssid > 15)
return(-1);
tcall[6] = (ssid << 1);
return(0);
}
if (islower(c))
c = toupper(c);
if (i > 5)
return(-1);
tcall[i] = (c << 1);
}
return(0);
}
/* Convert internal callsign to printable format */
char *call_to_a(unsigned char *tcall)
{
int i = 0;
int ssid = 0;
char *tptr;
static char t[10];
for (i = 0, tptr = t; i < 6; ++i)
{
if (tcall[i] == (' ' << 1))
break;
*tptr = tcall[i] >> 1;
tptr++;
}
ssid = (tcall[6] >> 1) & 0x0f;
if (ssid > 0)
{
*tptr = '-';
tptr++;
if (ssid > 9)
{
*tptr = '1';
tptr++;
ssid -= 10;
}
*tptr = '0' + ssid;
tptr++;
}
*tptr = '\0';
return(&t[0]);
}
void write_log(const char *format, ...)
{
FILE *fp;
va_list arg_ptr;
struct tm *lt;
fp = fopen("ax25ip.log", "a+");
if (fp != NULL)
{
lt = localtime(&sys_time);
fprintf(fp, "%16.16s:", ctime(&sys_time));
va_start(arg_ptr, format);
vfprintf(fp, format, arg_ptr);
va_end(arg_ptr);
fprintf(fp, "\n");
fclose(fp);
}
else
loglevel = 0; /* Logging aus da Fehler mit der Logdatei */
}
#ifdef AXIPR_UDP
/* AX25IP-Frame untersuchen, wenn Aenderungen */
/* z.B. UDP-Port, IP-Adresse in TBL Aktualisieren.*/
void route_analyse(struct in_addr ip, unsigned char *call, int uport)
{
register int i;
char mycall[7];
#ifdef AXIPR_HTML
char *timeset = set_time();
#endif /* AXIPR_HTML */
/* Leere Calls koennen nicht verarbeitet werden */
if (call[0] == FALSE)
return;
/* Call-Bytes kopieren, letztes Bit abschneiden (entspricht >> 1 & 7F) */
for (i = 0; i < 6; ++i)
mycall[i] = call[i] & 0xfe;
/* SSID kopieren */
mycall[6] = (call[6] & 0x1e) | 0x60;
/* Routingtabelle durchsuchen */
for (i = 0; i < route_tbl_top; ++i)
{
if (addrmatch((unsigned char *)mycall , route_tbl[i].callsign))
{
/* Bei Aenderung uebernehmen */
if (memcmp(&ip, &route_tbl[i].ip_addr, 4) != 0)
/* IP-Adresse hat sich geaendert */
memcpy(&route_tbl[i].ip_addr, &ip, 4);
/* UDP-Port unterschiedlich? */
if (route_tbl[i].udp_port != htons((UWORD)uport))
/* UDP-Port updaten. */
route_tbl[i].udp_port = htons((UWORD)uport);
#ifdef AXIPR_HTML
/* Route ggf. auf online setzen. */
if (!route_tbl[i].online)
route_tbl[i].online = TRUE;
#endif
/* Aktivitaet auf diesem Eintrag, dann Timeout erneuern */
if (route_tbl[i].timeout)
route_tbl[i].timeout = uDynTimeout;
/* Aktualisierung beendet. */
return;
}
}
#ifndef AXIPR_HTML
/* Auto-Route eintragen */
route_add((unsigned char*)inet_ntoa(ip), NULL, call,uport, FALSE, uDynTimeout, (char*)inet_ntoa(ip));
#else
/* Auto-Route eintragen */
route_add((unsigned char*)inet_ntoa(ip), NULL, call,uport, FALSE, uDynTimeout, (char*)inet_ntoa(ip), timeset, P_USER);
#endif /* AXIPR_HTML */
}
/* Per Rufzeichen, ohne die SSID zubeachten, einen */
/* Routeneintrag suchen. Gibt es keinen Eintrag, */
/* wird sofort abgebrochen, ansonsten werden die */
/* routeneintraege IP-Adresse und UDP-Port ueber- */
/* nommen und das neue Rufzeichen wird eingetragen.*/
struct route_table_entry *search_route(unsigned char *call)
{
register int i;
char srccall[10];
#ifdef AXIPR_HTML
char *timeset = set_time();
#endif /* AXIPR_HTML */
/* Konvertiere Rufzeichen. */
callss2str((char *)srccall, call_to_a(call));
/* TB durchgehen. */
for (i = 0; i < route_tbl_top; ++i)
{
/* Suche Rufzeichen. */
if (cmpcal(srccall, call_to_a(&route_tbl[i].callsign[0])))
{
#ifndef AXIPR_HTML
/* Auto-Route eintragen */
route_add((unsigned char *)&route_tbl[i].ip_addr, NULL, (unsigned char *)call, htons(route_tbl[i].org_udp_port), FALSE, uDynTimeout, (char *)route_tbl[i].hostname);
#else
/* Auto-Route eintragen */
route_add((unsigned char *)&route_tbl[i].ip_addr, NULL, (unsigned char *)call, htons(route_tbl[i].org_udp_port), FALSE, uDynTimeout, (char *)route_tbl[i].hostname, timeset, P_USER);
#endif /* AXIPR_HTML */
/* Aktuellen Eintrag weiterreichen. */
return (&route_tbl[i]); /* Eintrag gefunden */
}
}
/* Kein Rufzeichen gefunden. */
return (NULL);
}
/* Eine AX-Route Updaten. */
void UpdateRoute(unsigned char *srccall,
int udpport,
int timeout,
char *hostname
#ifdef AXIPR_HTML
, char *timeset
, UWORD protokoll
#endif /* AXIPR_HTML */
)
{
MBHEAD *mbp;
register int i;
/* TB durchgehen. */
for (i = 0; i < route_tbl_top; ++i)
{
/* Suche Rufzeichen. */
if (addrmatch((unsigned char *)srccall , route_tbl[i].callsign))
{
route_tbl[i].org_udp_port = route_tbl[i].udp_port = htons((unsigned short)udpport);
/* Hostname eintragen. */
(void)memcpy(route_tbl[i].hostname, hostname, HNLEN);
/* ggf. Timeout setzen. */
route_tbl[i].timeout = timeout;
#ifdef AXIPR_HTML
/* Hostname eintragen. */
(void)memcpy(route_tbl[i].timeset, timeset, 17);
/* Protokoll eintragen. */
route_tbl[i].protokoll = P_USER;
#endif /* AXIPR_HTML */
mbp = getmbp();
/* und ab die Post ... */
prompt(mbp);
seteom(mbp);
return;
}
}
}
#ifdef AXIPR_HTML
/* Protokoll fuer HTML-Ausgabe setzen. */
void SetHTML(int port, char *call, PEER *pp, BOOLEAN flag)
{
register int i;
char srccall[10 + 1];
call2str(srccall, call);
/* Routingtabelle durchsuchen */
for (i = 0; i < route_tbl_top; ++i)
{
if (!strcmp(srccall , call_to_a(&route_tbl[i].callsign[0])))
{
/* Protokoll setzen. */
set_status(i, port, pp);
/* Route auf online/offline stellen. */
route_tbl[i].online = flag;
break;
}
}
}
/* Aktualisiere Loginzeit fuer TB */
char *set_time(void)
{
time_t go;
struct tm *zeit;
static char c[17];
char *timeset = c;
/* aktuelle Kalenderzeit */
time(&go);
/* konvertiert Datum und Uhrzeit. */
zeit = localtime(&go);
/* Formatiere eine Zeit-/Datumsangabe */
strftime(c,17,"%d-%b-%H:%M:%S",zeit);
/* Aktuelle Login Date/Time */
return(timeset);
}
/* Protokoll setzen. */
void set_status(register int a, int port, PEER *pp)
{
if (pp == NULL) /* Route wird ausgetragen. */
{
route_tbl[a].protokoll = P_OFFLINE; /* Route auf OFFLINE setzen. */
route_tbl[a].online = FALSE;
return;
}
switch(pp->typ) /* Protokol-TYP. */
{
case INP : /* INP-TYP. */
route_tbl[a].protokoll = P_INP; /* INP-TYP setzen. */
break;
case TNN : /* TNN-TYP */
case THENET : /* THENET-TYP. */
route_tbl[a].protokoll = P_THENET; /* TNN/THENET-TYP setzen. */
break;
case FLEXNET: /* FLEXNET-TYP. */
route_tbl[a].protokoll = P_FLEXNET; /* FLEXNET-TYP setzen. */
break;
default:
route_tbl[a].protokoll = P_OFFLINE; /* Route auf OFFLINE setzen. */
route_tbl[a].online = FALSE;
return;
}
route_tbl[a].online = TRUE;
}
/* Timer fuer htmlstatistik. */
void h_timer(void)
{
static LONG h_Timer = 0L;
/* Timer abgelaufen. */
if (h_Timer <= 0L)
{
/* Timer neu setzen. */
/* fest auf 60 sec. */
h_Timer = 60L;
/* html auf Platte schreiben. */
w_statistik();
}
/* Timer runter zaehlen. */
h_Timer--;
}
/* Hiermit checken wir ob die rstat.css existiert. */
/* FALSE = keine rstat.css gefunden */
/* TRUE = es existiert eine rstat.css */
static int check_css_file(void)
{
char cssfile[255];
/* Path kopieren. */
strcpy(cssfile, htmlpath);
/* CSS-Dateiname anhaengen. */
strcat(cssfile, CSS_RFILE);
/* Pruefe ob Datei existiert.*/
if (!access(cssfile,FALSE))
/* Datei existiert. */
return(TRUE);
else
/* Nix gefunden! */
return(FALSE);
}
/* Eine default RSTAT.CSS schreiben */
static void rstat_css_default_file(void)
{
FILE *fp;
char cfgfile[255];
if (HtmlStat == FALSE)
return;
strcpy(cfgfile, htmlpath);
strcat(cfgfile, CSS_RFILE);
if ((fp = fopen(cfgfile, "w+t")) == NULL)
return;
fprintf(fp,"BODY {\n"
" BACKGROUND-IMAGE: url('bg.jpg');\n"
" BACKGROUND-COLOR: #000080;\n"
" COLOR: #FFFFFF;\n"
" FONT-FAMILY: Verdana, Arial;\n"
" FONT-SIZE: 12;\n"
"}\n");
fprintf(fp,"H1 {\n"
" FONT-SIZE: 18; COLOR: #FFCC00;\n"
"}\n");
fprintf(fp,"H2 {\n"
" FONT-SIZE: 12; COLOR: #FFFFFF;\n"
"}\n");
fprintf(fp,"a:link, a:visited {\n"
" COLOR: #FFFFFF;\n"
" text-weight: bold;\n"
" text-decoration: none;\n"
"}\n");
fprintf(fp,"a:hover {\n"
" COLOR: #FF6600;\n"
" text-weight: bold;\n"
" text-decoration: none;\n"
"}\n"
".info {\n"
" FONT-SIZE: 12; COLOR: #99CCFF;\n"
"}\n");
fprintf(fp,"table.box {\n"
" background-color: #ffbb00;\n"
" backcolor: #220000;\n"
" backcolorlight: #00ff00;\n"
" backcolordark: #000000;\n"
" border-width: 0px;\n"
" width: 95%%;\n"
" border-style: outset;\n"
" border-spacing: 2px;\n"
" border-padding: 8px;\n"
"}\n");
fprintf(fp,".status {\n"
" FONT-SIZE: 10; BACKGROUND: #000000; COLOR: #FFCC00; TEXT-ALIGN: center;\n"
"}\n");
fprintf(fp,".off {\n"
" FONT-SIZE: 10; BACKGROUND: #000000; COLOR: #ffffff;\n"
"}");
fprintf(fp,".offline {\n"
" FONT-SIZE: 10; BACKGROUND: #9f00FF; COLOR: #ffffff;\n"
"}");
fprintf(fp,".user {\n"
" FONT-SIZE: 10; BACKGROUND: #E06060; COLOR: #ffffff;\n"
"}\n");
fprintf(fp,".thenet {\n"
" FONT-SIZE: 10; BACKGROUND: #E00060; COLOR: #ffffff;\n"
"}\n");
fprintf(fp,".inp {\n"
" FONT-SIZE: 10; BACKGROUND: #0070C0; COLOR: #ffffff;\n"
"}\n");
fprintf(fp,".Flexnet {\n"
" FONT-SIZE: 10; BACKGROUND: #006060; COLOR: #ffffff;\n"
"}\n");
fprintf(fp,".about {\n"
" FONT-SIZE: 13; COLOR: #ffffff;\n"
"}\n");
fclose(fp);
}
/* Wie viel Ports sind nich frei ? */
static int free_ports(void)
{
int free = FALSE;
return(free = TABLE_SIZE - route_tbl_top);
}
/* Wie viel L2-Links (USER) - sind aktiv ? */
static int activ_user(void)
{
register int a;
int user = FALSE;
/* TB durchgehen */
for (a = 0; a < route_tbl_top; a++)
/* nur die als User markiert sind */
if ( route_tbl[a].protokoll == P_USER
/* und online sind !!! */
&& route_tbl[a].online > 0)
/* Alle USER zaehlen */
user++;
return(user);
}
/* Wie viel L2/L4_links sind aktiv ? */
static int activ_links(void)
{
register int a;
int links = FALSE;
/* TB durchgehen */
for (a = 0; a < route_tbl_top; a++)
/* L2/L4-Link online ? */
if ( route_tbl[a].online > 0
/* wir zaehlen alle Protokolle, ausser USER */
&& route_tbl[a].protokoll != 1)
links++;
return(links);
}
/* Die Aktuelle Uhrzeit fuer HTML ausgeben */
static char *puttim_stat(void)
{
struct tm *p;
static char tim[20];
time_t timet;
char *atime = tim;
time(&timet);
p = localtime(&timet);
sprintf(tim,"%02i.%02i.%02i %02i:%02i:%02i",
p->tm_mday, p->tm_mon+1, p->tm_year % 100,
p->tm_hour, p->tm_min, p->tm_sec);
return(atime);
}
static char *set_class(UWORD flag, register int a)
{
static char o[8];
char *protokoll = o;
switch(flag)
{
case P_OFFLINE :
if (!route_tbl[a].online)
strcpy(o, "offline");
break;
case P_USER :
if (route_tbl[a].online)
strcpy(o, "user");
else
strcpy(o, "offline");
break;
case P_THENET :
if (route_tbl[a].online)
strcpy(o, "thenet");
else
strcpy(o, "offline");
break;
case P_INP :
if (route_tbl[a].online)
strcpy(o, "inp");
else
strcpy(o, "offline");
break;
case P_FLEXNET :
if (route_tbl[a].online)
strcpy(o, "flexnet");
else
strcpy(o, "offline");
break;
default:
strcpy(o, "unknown");
break;
}
return(protokoll);
}
static char *set_pname(register int a)
{
static char p[8];
char *protokoll = p;
switch(route_tbl[a].protokoll)
{
case P_USER :
strcpy(p, "L2");
break;
case P_THENET :
strcpy(p, "THENET");
break;
case P_INP :
strcpy(p, "INP");
break;
case P_FLEXNET :
strcpy(p, "FLEXNET");
break;
default:
strcpy(p, "UNKNOWN");
break;
}
return(protokoll);
}
static void all_route(FILE *fp, UWORD flag, register int a)
{
char *pclass = set_class(flag, a);
char *protokoll = set_pname(a);
/* Nummer einer Route. */
fprintf(fp," <td class=\"%s\"><center>%d</td>\n"
, pclass, a);
/* Rufzeichen. */
fprintf(fp," <td class=\"%s\">%s</td>\n"
, pclass
, call_to_a(&route_tbl[a].callsign[0]));
/* IP-Adresse. */
fprintf(fp," <td class=\"%s\">"
" <a href=\"http://%s\" target=\"_http\">%s</a></td>\n"
, pclass
, route_tbl[a].hostname
, route_tbl[a].hostname);
/* Hostname/IP-Adresse. */
fprintf(fp," <td class=\"%s\"><center>%s</td>\n"
, pclass
, route_tbl[a].hostname);
/* UDP-Port */
fprintf(fp," <td class=\"%s\"><center>%d</td>\n"
, pclass
, htons(route_tbl[a].udp_port));
/* Loginzeit */
fprintf(fp," <td class=\"%s\"><center>%s</td>\n"
, pclass
, route_tbl[a].timeset);
if (route_tbl[a].timeout)
/* Timeout */
fprintf(fp," <td class=\"%s\"><center>%d</td>\n"
, pclass
, route_tbl[a].timeout);
else
/* Statische Route */
fprintf(fp," <td class=\"%s\"><center>Statisch</td>\n"
, pclass);
/* Protokoll */
fprintf(fp," <td class=\"%s\"><center>%s</td></tr>\n"
, pclass
, protokoll);
}
static void show_route(FILE *fp, UWORD flag, register int a)
{
switch(flag)
{
case P_OFFLINE :
if (!route_tbl[a].online)
fprintf(fp," <tr class=\"offline\">\n");
break;
case P_USER :
if ( route_tbl[a].protokoll == flag
&& route_tbl[a].online)
fprintf(fp," <tr class=\"user\">\n");
else
fprintf(fp," <tr class=\"offline\">\n");
break;
case P_THENET :
if ( route_tbl[a].protokoll == flag
&& route_tbl[a].online)
fprintf(fp," <tr class=\"thenet\">\n");
else
fprintf(fp," <tr class=\"offline\">\n");
break;
case P_INP :
if ( route_tbl[a].protokoll == flag
&& route_tbl[a].online)
fprintf(fp," <tr class=\"inp\">\n");
else
fprintf(fp," <tr class=\"offline\">\n");
break;
case P_FLEXNET :
if ( route_tbl[a].protokoll == flag
&& route_tbl[a].online)
fprintf(fp," <tr class=\"flexnet\">\n");
else
fprintf(fp," <tr class=\"offline\">\n");
break;
default:
if ( route_tbl[a].protokoll == flag
&& route_tbl[a].online)
fprintf(fp," <tr class=\"unknow\">\n");
else
fprintf(fp," <tr class=\"offline\">\n");
break;
}
all_route(fp, flag, a);
}
/* Schreibe htmlstatistik auf Platte. */
void w_statistik(void)
{
FILE *fp;
char cfgfile[255],mycall[10];
char *atime = puttim_stat();
register int a;
char runtime[8 + 1];
#ifndef CONNECTTIME
unsigned long upt,
upd,
uph;
#endif /* CONNECTTIME */
/* Pruefe, ob htmlstatistik eingeschaltet ist. */
if (HtmlStat == FALSE)
/* Ist nicht eingeschaltet, abbruch. */
return;
else
{
/* Pruefe ob CSS-Datei exisiert. */
if (!check_css_file())
/* Nein, dann neuschreiben. */
rstat_css_default_file();
}
strcpy(cfgfile,htmlpath );
strcat(cfgfile, HTML_RFILE);
if ((fp = fopen(cfgfile,"w+t")) == NULL)
return;
call2str(mycall,myid);
#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;
if (upd > 0)
sprintf(runtime, "%2lud,%2luh", upd, uph);
else
if (uph > 0)
sprintf(runtime, "%2luh,%2lus", uph, upt);
else
if (upt > 0)
sprintf(runtime, " %2lus", upt);
else
sprintf(runtime, " ");
#else
sprintf(runtime, "%s", ConnectTime(tic10 / 100));
#endif /* CONNECTTIME */
fprintf(fp,"<html>"
"<head>\n"
"<meta http-equiv=\"refresh\" content=\"%d\">\n"
"<title>AXIPR-Statistik</title>\n"
"<link rel=stylesheet type=text/css href=rstat.css>\n"
"</head>\n<body>\n",HTML_INV);
fprintf(fp,"<DIV ALIGN=\"CENTER\"><CENTER>\n"
"<H1><U>%s%s)</U></H1>\n",signon,mycall);
fprintf(fp,"<H2>Date/Time: %s Runtime: %s, %d Frei</H2>\n\n",atime, runtime, free_ports());
fprintf(fp,"<FONT class=\"info\"><B> %d L2/L4-LINKS</b></FONT>\n",activ_links());
fprintf(fp,"<table class=\"box\" cellspacing=\"2\" cellpadding=\"2\" style=\"border-collapse: collapse\">\n");
fprintf(fp," <tr class=\"status\">\n"
" <td class=\"status\">Nr.</td>\n"
" <td class=\"status\">Rufzeichen</td>\n"
" <td class=\"status\">IP-Adresse</td>\n"
" <td class=\"status\">DYNDNS</td>\n"
" <td class=\"status\">UDP</td>\n"
" <td class=\"status\">Login</td>\n"
" <td class=\"status\">Timeout</td>\n"
" <td class=\"status\">Protokoll</td>\n"
" </tr>\n");
/* TB durchgehen. */
for (a = 0; a < route_tbl_top; a++)
{
/* Nur aktive Routen zeigen. */
if (route_tbl[a].online == FALSE)
/* zum naechsten Eintrag. */
continue;
/* Nur INP- oder FLEXNET-Routen bearbeiten */
if (route_tbl[a].protokoll > P_USER)
/* und anzeigen. */
show_route(fp, route_tbl[a].protokoll, a);
}
fprintf(fp,"</table><br><br>\n");
fprintf(fp,"<FONT class=\"info\"><B>%d USER</B></FONT>\n",activ_user());
fprintf(fp,"<table class=\"box\" cellspacing=\"2\" cellpadding=\"2\" style=\"border-collapse: collapse\">\n");
fprintf(fp," <tr class=\"status\">\n"
" <td class=\"status\">Nr.</td>\n"
" <td class=\"status\">Rufzeichen</td>\n"
" <td class=\"status\">IP-Adresse</td>\n"
" <td class=\"status\">DYNDNS</td>\n"
" <td class=\"status\">UDP</td>\n"
" <td class=\"status\">Login</td>\n"
" <td class=\"status\">Timeout</td>\n"
" <td class=\"status\">Protokoll</td>\n"
" </tr>\n");
/* TB durchgehen */
for (a = 0; a < route_tbl_top; a++)
{
/* Nur aktive Routen zeigen. */
if (route_tbl[a].online == FALSE)
/* zum naechsten Eintrag. */
continue;
/* Nur USER-Routen bearbeiten */
if (route_tbl[a].protokoll == P_USER)
/* und anzeigen. */
show_route(fp, route_tbl[a].protokoll, a);
}
fprintf(fp,"</table>\n\n");
fprintf(fp,"<BR><FONT class=\"info\"><B>My UDP-Port: %u</B></FONT>\n",htons(my_udp));
fprintf(fp,"</body></html>\n");
fclose(fp);
}
#endif /* AXIPR_HTML */
#endif /* AXIPR_UDP */
#endif
/* End of os/win32/ax25ip.c */
Reference in a new issue Copy permalink