708 lines
24 KiB
C
Executable File
708 lines
24 KiB
C
Executable File
|
|
#include "tnn.h"
|
|
#ifdef OS_STACK
|
|
|
|
static T_INTERFACE *ifpp; /* Zeiger auf das aktuelle Interface */
|
|
|
|
struct sockaddr_in myaddr_in;
|
|
struct sockaddr_in peeraddr_in;
|
|
|
|
|
|
/* Schliesse aktuellen Socket. */
|
|
BOOLEAN CloseSockOS(BOOLEAN ALL, WORD INTERFACE)
|
|
{
|
|
int i,
|
|
j = 0;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(CloseSockOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
/* ALLE Socket-Verbindungen schliessen. */
|
|
if (ALL == TRUE)
|
|
{
|
|
/* TCPIP-TBL durchgehen. */
|
|
for (i = 0, tcppoi = tcptbl; i < MAXTCPIP; ++i, ++tcppoi)
|
|
{
|
|
/* Ist Socket noch offen? */
|
|
if ( INTERFACE == tcppoi->Interface
|
|
&& tcppoi->sock > TRUE)
|
|
{
|
|
if (tcppoi->mode != OS_MODE) /* Segment kein OS-STACK, */
|
|
continue; /* zum naechsten Segment. */
|
|
|
|
/* Socket schliessen. */
|
|
close(tcppoi->sock);
|
|
|
|
/* TCPIP-User/link aus der Liste raushaengen */
|
|
/* bzw. Parameter wieder auf 0 setzen. */
|
|
DiscTCP();
|
|
}
|
|
|
|
/* Sind alle aktiven Sockets durchlaufen, */
|
|
if (((tcppoi->activ) && (j++ >= tcp_tbl_top)) || (j == tcp_tbl_top))
|
|
/* brechen wir ab. */
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
/* Socket schliessen. */
|
|
close(tcppoi->sock);
|
|
|
|
/* TCPIP-User/Link aus der Liste raushaengen */
|
|
/* bzw. Parameter wieder auf 0 setzen. */
|
|
DiscTCP();
|
|
return(FALSE);
|
|
}
|
|
|
|
/* TCPIP-Port Initialisierung. */
|
|
BOOLEAN L1InitOS(UWORD Interface, int l2port, unsigned short TCPPort)
|
|
{
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(L1InitOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
if (l2port == EOF) /* Keine Portangabe!!!. */
|
|
{
|
|
printf("(L1InitOS): Fehler, keine L2-Portangabe!!!\n");
|
|
return(FALSE);
|
|
}
|
|
/* Zeiger auf das aktuelle Interface. */
|
|
if ((ifpp = SearchIf(Interface)) == NULL)
|
|
{
|
|
printf("(L1InitOS): Fehler, Interface existiert nicht!!!\n");
|
|
return(FALSE); /* Abbrechen. */
|
|
}
|
|
/* Einen neuen Filedescriptor anlegen. */
|
|
if ((ifpp->OsSock = SetupOS(ifpp, htons(TCPPort))) == EOF)
|
|
return(FALSE); /* Abbrechen. */
|
|
|
|
ifpp->l2port = l2port; /* L2-Port setzen. */
|
|
ifpp->tcpport = TCPPort; /* akt. TCP-Port setzen. */
|
|
|
|
return(TRUE); /* Erfolgreich Socket erstellt. */
|
|
}
|
|
|
|
/* TCPIP-Interface schliessen. */
|
|
void L1ExitOS(UWORD Interface)
|
|
{
|
|
T_INTERFACE *ifpoi;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(L1ExitOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
/* Zeiger auf das aktuelle Interface. */
|
|
if ((ifpoi = SearchIf(Interface)) == NULL)
|
|
/* Aktuelles Interface ist deaktiv, */
|
|
/* dann zum naechsten Interface. */
|
|
return;
|
|
|
|
/* Alle TCPIP-Verbindungen auf den Interface schliessen. */
|
|
CloseSockOS(TRUE, ifpoi->Interface);
|
|
|
|
/* Interface ist nicht aktiv, */
|
|
if (ifpoi->actively == FALSE)
|
|
/* damit ist hier schon schluss. */
|
|
return;
|
|
|
|
/* TCPIP-Socket schliessen. */
|
|
close(ifpoi->OsSock);
|
|
|
|
/* Markiere TCPIP-Interface als deaktiv. */
|
|
ifpoi->actively = FALSE;
|
|
}
|
|
|
|
/* Einen Filedescriptor anlegen. */
|
|
int SetupOS(T_INTERFACE *ifpp, /* Zeiger auf das aktuelle Interface. */
|
|
unsigned short tcp_port) /* Neuer TCP-Port. */
|
|
{
|
|
int tmp_fd = EOF; /* Temporaerer Filedescriptor */
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(SetupOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
if (tcp_port == FALSE) /* Kein Port angegeben. */
|
|
{
|
|
T_LOGL1(TRUE, "(SetupOS):\nKein TCP-Port angegeben.\n");
|
|
return(EOF); /* Abbruch. */
|
|
}
|
|
|
|
memset(&myaddr_in, 0, sizeof(myaddr_in)); /* Adressstruktur loeschen */
|
|
memset(&peeraddr_in, 0, sizeof(peeraddr_in));
|
|
myaddr_in.sin_family = AF_INET; /* Adressstruktur fuellen */
|
|
myaddr_in.sin_port = htons(tcp_port); /* TCP-Port setzen. */
|
|
myaddr_in.sin_addr.s_addr = INADDR_ANY; /* Jedes Netzwerk Geraet abfragen. */
|
|
|
|
/* Socket erstellen. */
|
|
if ((tmp_fd = socket(AF_INET, SOCK_STREAM, 0)) == EOF)
|
|
{
|
|
printf("Error %s: Socket cannot be constructed!\r", ifpp->name);
|
|
|
|
T_LOGL1(TRUE, "(SetupOS):\nNeuer Socket kann nicht geoeffnet werden.\n");
|
|
return(EOF); /* Keine freien Socket's. */
|
|
}
|
|
|
|
/* Bind Initialisieren. */
|
|
if (bind (tmp_fd, (struct sockaddr *) &myaddr_in, sizeof (struct sockaddr_in)) == EOF)
|
|
{
|
|
printf("Error %s: Bind cannot be initialized!\n", ifpp->name);
|
|
close(tmp_fd); /* Schliesse Socket. */
|
|
|
|
T_LOGL1(TRUE, "(SetupOS):\nBind Initialisierung fehlgeschlagen.\n");
|
|
return(EOF); /* Fehler beim Bind . */
|
|
}
|
|
|
|
if (listen (tmp_fd, 3) == EOF) /* Listen Initialisieren. */
|
|
{
|
|
printf("Error %s: listen cannot be initialized!\n", ifpp->name);
|
|
close(tmp_fd); /* Schliesse Socket. */
|
|
|
|
T_LOGL1(TRUE, "(SetupOS):\nListen Initialisierung fehlgeschlagen.\n");
|
|
return(EOF); /* Fehler beim Listen. */
|
|
}
|
|
|
|
T_LOGL1(TRUE, "(SetupOS):\nTCP-Port (%d) erfolgreich gesetzt.\n"
|
|
, ntohs(tcp_port));
|
|
return(tmp_fd); /* Aktuelle Filedescriptor. */
|
|
}
|
|
|
|
|
|
/* Anhand des Sockets den User aus der Liste holen. */
|
|
TCPIP *FdReadOS(fd_set *fds)
|
|
{
|
|
int i,
|
|
j = 0;
|
|
LHEAD *h_llp;
|
|
|
|
h_llp = &tcpactl;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(FdReadOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
/* TCPIP-TBL durchgehen. */
|
|
for (i = 0, tcppoi = tcptbl; i < MAXTCPIP; ++i, ++tcppoi)
|
|
{
|
|
if (tcppoi->mode != OS_MODE)
|
|
continue;
|
|
|
|
/* Nur wenn aktiv! */
|
|
if (tcppoi->activ)
|
|
{
|
|
/* Vergleiche die Sockets */
|
|
if (FD_ISSET(tcppoi->sock, fds))
|
|
{
|
|
/* wir haben einen Link gefunden */
|
|
ulink((LEHEAD *)tcppoi);
|
|
relink((LEHEAD *)tcppoi, (LEHEAD *)h_llp->tail);
|
|
return(tcppoi);
|
|
}
|
|
}
|
|
/* Sind alle aktiven Sockets durchlaufen, */
|
|
if (((tcppoi->activ) && (j++ >= tcp_tbl_top)) || (j == tcp_tbl_top))
|
|
/* brechen wir ab. */
|
|
break;
|
|
}
|
|
|
|
/* Keinen Eintrag gefunden. */
|
|
return(NULL);
|
|
}
|
|
|
|
int ReadSockOS(void) /* Empfangene TCPIP Packete. */
|
|
{
|
|
fd_set fdsI;
|
|
struct timeval timevalue;
|
|
int ret = EOF;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(ReadSockOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
if (tcppoi->rxc >= tcppoi->RecvLen) /* Sind alle Zeichen verarbeitet. */
|
|
{
|
|
if (!tcppoi->mode) /* OS-Stack. */
|
|
{
|
|
FD_ZERO(&fdsI); /* Inhalt loeschen. */
|
|
FD_SET((unsigned)tcppoi->sock, &fdsI); /* Socket setzen. */
|
|
|
|
timevalue.tv_usec = 0;
|
|
timevalue.tv_sec = 0;
|
|
/* Pruefe auf aktivitaet. */
|
|
ret = select(tcppoi->sock + 1, &fdsI, NULL , NULL ,&timevalue);
|
|
|
|
if (ret <= 0)
|
|
return((int)NULL); /* Keine aktivitaet auf den Socket. */
|
|
else
|
|
/* Zeichen vom Socket empfangen. */
|
|
tcppoi->RecvLen = recv (tcppoi->sock, tcppoi->rxbuf, RXLEN,0);
|
|
}
|
|
|
|
if (tcppoi->RecvLen < 1) /* Fehler beim Empfang. */
|
|
{
|
|
if (tcppoi->RecvLen == EOF) /* Socket wurde mittlerweile geloes. */
|
|
{
|
|
ifpp = SetInterface(tcppoi->Interface); /* akt. Interface setzen. */
|
|
/* ggf. Logbuch fuehren. */
|
|
T_LOGL1(TRUE, "(ReadSockOS):%s\n (Recv) Fehler beim empfang, Segment wird auf DISC gesetzt!\n"
|
|
, tcppoi->ip);
|
|
|
|
tcppoi->disflg |= 0x80; /* Segment auf DISC stellen. */
|
|
return((int)NULL);
|
|
}
|
|
|
|
if ( (ret)
|
|
&&(tcppoi->RecvLen == 0))
|
|
{
|
|
ifpp = SetInterface(tcppoi->Interface); /* akt. Interface setzen. */
|
|
/* ggf. Logbuch fuehren. */
|
|
T_LOGL1(TRUE, "(ReadSockOS):%s\n(Recv) Keine Zeichen, Segment wird auf DISC gesetzt!\n"
|
|
, tcppoi->ip);
|
|
|
|
tcppoi->disflg |= 0x80; /* Segment auf DISC stellen. */
|
|
return((int)NULL);
|
|
}
|
|
}
|
|
|
|
tcppoi->rxc = 0; /* RX-Zaehler auf 0 setzen. */
|
|
tcppoi->rxbuf[tcppoi->RecvLen] = 0; /* Nullzeichen setzen. */
|
|
/* ggf. Logbuch fuehren. */
|
|
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
T_LOGL3(TRUE, "(ReadSockOS):%s\nInput:\r%s\r"
|
|
, tcppoi->ip
|
|
, tcppoi->rxbuf);
|
|
}
|
|
|
|
ret = tcppoi->rxbuf[tcppoi->rxc++]; /* Zeichen vom rxbuf holen. */
|
|
|
|
return(ret); /* Aktuelle Zeichen weiterreichen. */
|
|
}
|
|
|
|
static int OsStackReadIndicationsSock(void) /* Zeichen vom Socket einlesen. */
|
|
{
|
|
TRILLIAN ok = ERRORS;
|
|
char s;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(OsStackReadIndicationsSock)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
while(1) /* Alle Zeichen von Socket einlesen. */
|
|
{
|
|
s = ReadSockOS(); /* Zeichen vom Socket. */
|
|
|
|
if (tcppoi->cmdlen >= RXLEN) /* Maximale Buffergroesse erreicht, */
|
|
{
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
T_LOGL1(TRUE, "(OsStackReadIndicationsSock):%s\nMaximale Buffergroesse erreicht!\n"
|
|
, tcppoi->ip);
|
|
return(TRUE);
|
|
}
|
|
|
|
switch(tcppoi->Interface) /* Interface. */
|
|
{
|
|
#ifdef L1TELNET
|
|
case KISS_TELNET : /* TELNET-Server. */
|
|
if ((ok = GetContensTEL(s)) == ERRORS) /* Aktuelle Zeichen auswerten.*/
|
|
break; /* Zeichen verarbeitet, kein Return. */
|
|
else
|
|
if (ok == YES) /* Zeichen verarbeitet und Return. */
|
|
{
|
|
tcppoi->cmd[tcppoi->cmdlen] = 0; /* Nullzeichen setzen. */
|
|
return(TRUE); /* Frame ist komplett. */
|
|
}
|
|
else
|
|
continue; /* Sind noch Zeichen im RXBUF, */
|
|
/* zum naechsten Zeichen. */
|
|
break;
|
|
#endif /* L1TELNET. */
|
|
|
|
#ifdef L1HTTPD
|
|
case KISS_HTTPD : /* HTTPD-Server. */
|
|
if ((ok = GetContensHTP(s)) == ERRORS) /* Aktuelle Zeichen auswerten.*/
|
|
break; /* Zeichen verarbeitet, kein Return. */
|
|
else
|
|
if (ok == YES) /* Zeichen verarbeitet und Return. */
|
|
{
|
|
tcppoi->cmd[tcppoi->cmdlen] = 0; /* Nullzeichen setzen. */
|
|
return(TRUE); /* Frame ist komplett. */
|
|
}
|
|
else
|
|
continue; /* Sind noch Zeichen im RXBUF, */
|
|
/* zum naechsten Zeichen. */
|
|
break;
|
|
#endif /* L1HTTPD. */
|
|
|
|
#ifdef L1IPCONV
|
|
/* IPCONV */
|
|
case KISS_IPCONV :
|
|
/* Aktuelle Zeichen auswerten. */
|
|
if ((ok = GetContensCVS(s)) == ERRORS)
|
|
/* Alle Zeichen verarbeitet, aber kein Return. */
|
|
break;
|
|
else
|
|
/* Alle Zeichen verarbeitet und Return? */
|
|
if (ok == YES)
|
|
{
|
|
/* User/Link noch kein Login. */
|
|
if (!tcppoi->login)
|
|
{
|
|
/* Pruefe auf Login. */
|
|
if (!strncmp(tcppoi->cmd, "/na", 3))
|
|
/* Kein Prompt senden. */
|
|
tcppoi->LoginPrompt = TRUE;
|
|
}
|
|
tcppoi->cmd[tcppoi->cmdlen] = 0;
|
|
/* Frame komplett. */
|
|
return(TRUE);
|
|
}
|
|
else
|
|
/* Sind noch Zeichen im RXBUF,*/
|
|
/* zum naechsten Zeichen. */
|
|
continue;
|
|
|
|
break;
|
|
#endif /* L1IPCONV */
|
|
|
|
#ifdef L1IRC
|
|
/* IPCONV */
|
|
case KISS_IRC :
|
|
/* Aktuelle Zeichen auswerten. */
|
|
if ((ok = GetContensCVS(s)) == ERRORS)
|
|
/* Alle Zeichen verarbeitet, aber kein Return. */
|
|
break;
|
|
else
|
|
/* Alle Zeichen verarbeitet und Return? */
|
|
if (ok == YES)
|
|
{
|
|
/* User/Link noch kein Login. */
|
|
if (!tcppoi->login)
|
|
{
|
|
/* Pruefe auf Login. */
|
|
if (!strncmp(tcppoi->cmd, "/na", 3))
|
|
/* Kein Prompt senden. */
|
|
tcppoi->LoginPrompt = TRUE;
|
|
}
|
|
tcppoi->cmd[tcppoi->cmdlen] = 0;
|
|
/* Frame komplett. */
|
|
return(TRUE);
|
|
}
|
|
else
|
|
/* Sind noch Zeichen im RXBUF,*/
|
|
/* zum naechsten Zeichen. */
|
|
continue;
|
|
|
|
break;
|
|
#endif /* L1IPCONV */
|
|
|
|
default : /* Ungueltiges Interface. */
|
|
break; /* Hier werden wir nie kommen. */
|
|
}
|
|
|
|
return(FALSE); /* Frame noch nicht komplett. */
|
|
}
|
|
|
|
return(FALSE); /* Frame noch nicht komplett. */
|
|
}
|
|
|
|
void ServOS(void) /* Empfangene Zeichen in Frames packen. */
|
|
{
|
|
READRX *SRx;
|
|
register int i;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(ServOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
if (OsStackReadIndicationsSock()) /* Empfangene Zeichen analysieren. */
|
|
{
|
|
if(tcppoi->cmdlen > 0) /* Es sind Zeichen im Buffer.*/
|
|
{
|
|
if ((SRx = (READRX *)allocb(ALLOC_L1TCPIP)) == NULL)/* RX-Seg. besorgen */
|
|
{
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
T_LOGL1(TRUE, "(ServOS):%s\nSpeicher (%d) ist voll!\n"
|
|
, tcppoi->ip
|
|
, nmbfre);
|
|
tcppoi->disflg |= 0x80; /* Segment auf Disconnect setzen. */
|
|
return; /* Kein Segment frei, abbruch. */
|
|
}
|
|
|
|
if ((SRx->Data = SetBuffer()) == NULL) /* Buffer besorgen. */
|
|
{
|
|
dealoc((MBHEAD *)ulink((LEHEAD *)SRx)); /* RX-Segment entsorgen. */
|
|
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
T_LOGL1(TRUE, "(ServOS):%s\nSpeicher (%d) ist voll!\n"
|
|
, tcppoi->ip
|
|
, nmbfre);
|
|
tcppoi->disflg |= 0x80; /* Segment auf Disconnect setzen. */
|
|
return; /* Buffer ist voll, abbruch. */
|
|
}
|
|
|
|
SRx->Sock = tcppoi->sock; /* Socket setzen. */
|
|
SRx->Interface = tcppoi->Interface; /* Inetrface setzen. */
|
|
SRx->Mode = tcppoi->mode; /* Stack-Mode setzen. */
|
|
|
|
for (i = 0; i < tcppoi->cmdlen; ++i)
|
|
putchr(tcppoi->cmd[i], SRx->Data); /* Buffer fuellen. */
|
|
|
|
tcppoi->cmdlen = 0; /* Buffer-Zaehler zuruecksetzen. */
|
|
tcppoi->cmd[0] = 0; /* Nullzeichen setzen. */
|
|
|
|
if (tcppoi->activ) /* Nur wenn Socket aktiv. */
|
|
relink((LEHEAD *) SRx, (LEHEAD *)rxflRX.tail);/* Ab in die Empf.-liste*/
|
|
else
|
|
{
|
|
ifpp = SetInterface(tcppoi->Interface); /* akt. Interface setzen. */
|
|
T_LOGL1(TRUE, "(ServOS):%s\nSegment ist nicht mehr aktiv!\n"
|
|
, tcppoi->ip);
|
|
|
|
if (SRx->Data != NULL)
|
|
dealmb(SRx->Data); /* Buffer entsorgen. */
|
|
|
|
dealoc((MBHEAD *)ulink((LEHEAD *)SRx)); /* RX-Segment entsorgen.*/
|
|
} /* Socket ist nicht mehr aktiv. */
|
|
} /* kein Zeichen im buffer. */
|
|
} /* Frame ist noch nicht komplett. */
|
|
}
|
|
|
|
/* Neue User hinzufuegen, vorrausgesetzt es sind noch freie Sockets vorhanden.*/
|
|
int AddUserOS(T_INTERFACE *ifpoi, /* TCP-Interface. */
|
|
unsigned NewSocket, /* Neuer Socket. */
|
|
char *ip) /* IP-Adresse. */
|
|
{
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(AddUserOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
while ((LHEAD *)tcpfrel.head != &tcpfrel)
|
|
{
|
|
tcppoi = (TCPIP *)ulink((LEHEAD *)tcpfrel.head);
|
|
SetDefaultWorthTCP(NewSocket, /* Defaultwerte setzen, neuer Socket. */
|
|
ip, /* IP-Adresse. */
|
|
ifpoi->l2port, /* L2-Port. */
|
|
ifpoi->Interface, /* TCPIP-Interface. */
|
|
OS_MODE); /* OS-STack. */
|
|
|
|
ServOS(); /* Empfangene Zeichen in Frames packen. */
|
|
return(FALSE);
|
|
}
|
|
|
|
ifpp = SetInterface(ifpoi->Interface); /* akt. Interface setzen. */
|
|
/* ggf. Logbuch fuehren. */
|
|
T_LOGL1(TRUE, "(AddUserOS):%s\nKann kein neues TCPIP-Segment anlegen !\n"
|
|
, ip);
|
|
return(TRUE);
|
|
}
|
|
|
|
void ListenTCP_OS(void)
|
|
{
|
|
fd_set rmask;
|
|
struct timeval timevalue;
|
|
UWORD Interface = KISS_TCPIP;
|
|
int max_fd;
|
|
register int i;
|
|
int count,
|
|
j = 0;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(ListenTCP_OS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
max_fd = 0;
|
|
FD_ZERO(&rmask);
|
|
|
|
/* Interface-Socket's setzen. */
|
|
for (i = 0; i < MAXINTERFACE; i++, Interface++)
|
|
{
|
|
/* Zeiger auf das aktuelle Interface. */
|
|
if ((ifpp = SearchIf(Interface)) == NULL)
|
|
continue;
|
|
|
|
if (ifpp->actively == FALSE)
|
|
continue;
|
|
|
|
/* Interface-Socket setzen. */
|
|
FD_SET((unsigned)ifpp->OsSock, &rmask);
|
|
|
|
if (ifpp->OsSock > max_fd - 1)
|
|
max_fd = ifpp->OsSock + 1;
|
|
}
|
|
|
|
/* User-Socket's setzen. */
|
|
for (i = 0, tcppoi = tcptbl; i < MAXTCPIP; ++i, ++tcppoi)
|
|
{
|
|
if (tcppoi->activ) /* Nur wenn Interface Socket aktiv! */
|
|
{
|
|
if (tcppoi->mode != OS_MODE) /* Kein OS-STACK, */
|
|
continue; /* zum naechsten Segment. */
|
|
|
|
if (tcppoi->sock < 1) /* Kein Socket gesetzt, */
|
|
continue; /* zum naechsten Segment. */
|
|
|
|
FD_SET((unsigned)tcppoi->sock, &rmask); /* Socket setzen */
|
|
|
|
if (tcppoi->sock > max_fd - 1)
|
|
max_fd = tcppoi->sock + 1;
|
|
}
|
|
|
|
if ( ((tcppoi->activ) /* Sind alle aktiven Sockets durchlaufen, */
|
|
&& (j++ >= tcp_tbl_top))
|
|
|| (j == tcp_tbl_top))
|
|
break; /* brechen wir ab. */
|
|
}
|
|
|
|
timevalue.tv_usec = 0;
|
|
timevalue.tv_sec = 0;
|
|
|
|
count = select(max_fd, &rmask, NULL, NULL, &timevalue);
|
|
|
|
if (count < 1)
|
|
return;
|
|
|
|
Interface = KISS_TCPIP;
|
|
|
|
for (i = 0; i < MAXINTERFACE; i++, Interface++)
|
|
{
|
|
if ((ifpp = SearchIf(Interface)) == NULL) /* Ungueltiges Interface, */
|
|
continue; /* zum naechsten Interface. */
|
|
|
|
if (ifpp->actively == FALSE) /* Interface nicht aktiv, */
|
|
continue; /* zum naechsten Interface. */
|
|
|
|
|
|
if (FD_ISSET(ifpp->OsSock, &rmask)) /* Interface-Socketvergleich. */
|
|
{
|
|
char ip[IPADDR + 1];
|
|
int NewSock;
|
|
socklen_t addrlen;
|
|
ULONG peerip = 0;
|
|
char *p = (char *)&peerip;
|
|
|
|
addrlen = sizeof peeraddr_in;
|
|
|
|
if ((NewSock = accept(ifpp->OsSock, (struct sockaddr *) &peeraddr_in, &addrlen)) != EOF)
|
|
{
|
|
peerip = peeraddr_in.sin_addr.s_addr;
|
|
sprintf (ip, "%d.%d.%d.%d",(p[0] & 255)
|
|
,(p[1] & 255)
|
|
,(p[2] & 255)
|
|
,(p[3] & 255));
|
|
/* Einen Neuen TCPIP-User/Link hinzufuegen. Bekannt */
|
|
/* ist das Interface, der Socket und die IP-Adresse. */
|
|
if (AddUserOS(ifpp, NewSock, ip))
|
|
{
|
|
close(NewSock);
|
|
return;
|
|
}
|
|
|
|
/* ggf. Logbuch fuehren. */
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
T_LOGL2(TRUE, "(ListenTCP_OS):\n"
|
|
"Verbindung zur IP-Adresse %s angenommen.\n"
|
|
"Neu erzeugter Socket ist (%d).\n"
|
|
, ip
|
|
, NewSock);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Anhand des Sockets den User aus der Liste Holen */
|
|
if ((tcppoi = FdReadOS(&rmask)) != NULL)
|
|
{
|
|
/* ggf. Logbuch fuehren. */
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
|
|
T_LOGL3(TRUE, "(ListenTCP_OS):%s\nAktuellen Socket (%d) in der Liste gefunden.\n"
|
|
, tcppoi->ip
|
|
, tcppoi->sock);
|
|
|
|
/* TCPIP Packete empfangen/bearbeiten/senden */
|
|
ServOS();
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
/* Frame aus der Sendeliste senden. */
|
|
int PutflushSockOS(void)
|
|
{
|
|
int ok = FALSE;
|
|
int ret = FALSE;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(PutflushSockOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
if (tcppoi->txc) /* Gibt es was zu senden. */
|
|
{
|
|
while (1) /* Gibt es was zu senden. */
|
|
{
|
|
fd_set wfdsI;
|
|
struct timeval Tv;
|
|
|
|
FD_ZERO(&wfdsI); /* Loesche inhalt. */
|
|
FD_SET((unsigned)tcppoi->sock, &wfdsI); /* Socket setzen. */
|
|
|
|
if (select(tcppoi->sock + 1, NULL, &wfdsI , NULL ,&Tv))/* Sender frei.*/
|
|
{
|
|
if (tcppoi->txstatus == TCP_TX_BUSY) /* Sender ist auf Busy. */
|
|
tcppoi->txstatus = TCP_TX_FREE; /* Sender auf frei stellen. */
|
|
|
|
/* Frame senden */
|
|
if ((ok = send(tcppoi->sock, tcppoi->txbuf + tcppoi->sum, tcppoi->txc - tcppoi->sum,0)) < 0)
|
|
{
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
T_LOGL1(TRUE, "(PutflushSockTCP):%s\nFrame senden fehlgeschlagen!\n"
|
|
, tcppoi->ip);
|
|
|
|
tcppoi->disflg |= 0x80; /* Segment auf Disconnect setzen. */
|
|
return(TRUE); /* Abbruch. */
|
|
}
|
|
|
|
ifpp = SetInterface(tcppoi->Interface); /* ggf. Logbuch fuehren. */
|
|
T_LOGL3(TRUE, "(PutflushSockOS):%s\nOutput:\r%s\r"
|
|
, tcppoi->ip
|
|
, tcppoi->txbuf);
|
|
|
|
tcppoi->sum += ok; /* Markiere, gesendete Zeichen. */
|
|
|
|
if (tcppoi->sum == tcppoi->txc) /* Alle Zeichen gesendet. */
|
|
break; /* Schleife verlassen. */
|
|
|
|
}
|
|
|
|
if (ret == FALSE) /* Sender ist nicht frei. */
|
|
{
|
|
tcppoi->txstatus = TCP_TX_BUSY; /* Sender auf Busy stellen. */
|
|
return(FALSE);
|
|
}
|
|
}
|
|
|
|
tcppoi->sum = 0; /* Zuruecksetzen. */
|
|
tcppoi->txc = 0;
|
|
tcppoi->txbuf[0] = 0;
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
BOOLEAN CheckSocketOS(void)
|
|
{
|
|
int ok = EOF;
|
|
#ifdef DEBUG_MODUS
|
|
lastfunc = "ostcpip(CheckSocketOS)";
|
|
#endif /* DEBUG_MODUS */
|
|
|
|
if ((ok = send(tcppoi->sock, "", 0, 0)) < 0) /* Socket noch aktiv. */
|
|
{
|
|
ifpp = SetInterface(tcppoi->Interface);
|
|
T_LOGL1(TRUE, "(CheckSocket):%s\nSocket ist nicht mehr aktiv!\n"
|
|
, tcppoi->ip);
|
|
|
|
tcppoi->disflg |= 0x80; /* Segment auf DISC setzen. */
|
|
return(TRUE); /* Socket ist nicht mehr aktiv */
|
|
}
|
|
else
|
|
return(FALSE); /* Socket ist aktiv. */
|
|
}
|
|
|
|
#endif /* OS_STACK */
|
|
|
|
/* End of os/linux/ostcpip.h */
|