ec0aab70558c34ce9a1562192bf56b9edd669159
[ngircd-alex.git] / src / ngircd / conn.c
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001 by Alexander Barton (alex@barton.de)
4  *
5  * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
6  * der GNU General Public License (GPL), wie von der Free Software Foundation
7  * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
8  * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
9  * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
10  * der an comBase beteiligten Autoren finden Sie in der Datei AUTHORS.
11  *
12  * $Id: conn.c,v 1.16 2001/12/27 19:32:44 alex Exp $
13  *
14  * connect.h: Verwaltung aller Netz-Verbindungen ("connections")
15  *
16  * $Log: conn.c,v $
17  * Revision 1.16  2001/12/27 19:32:44  alex
18  * - bei "Null-Requests" wird nichts mehr geloggt. Uberfluessig, da normal.
19  *
20  * Revision 1.15  2001/12/27 16:35:04  alex
21  * - vergessene Variable bei Ping-Timeout-Logmeldung ergaenzt. Opsa.
22  *
23  * Revision 1.14  2001/12/26 14:45:37  alex
24  * - "Code Cleanups".
25  *
26  * Revision 1.13  2001/12/26 03:36:57  alex
27  * - Verbindungen mit Lesefehlern werden nun korrekt terminiert.
28  *
29  * Revision 1.12  2001/12/26 03:20:53  alex
30  * - PING/PONG-Timeout implementiert.
31  *
32  * Revision 1.11  2001/12/25 23:15:16  alex
33  * - buffer werden nun periodisch geprueft, keine haengenden Clients mehr.
34  *
35  * Revision 1.10  2001/12/25 22:03:47  alex
36  * - Conn_Close() eingefuehrt: war die lokale Funktion Close_Connection().
37  *
38  * Revision 1.9  2001/12/24 01:32:33  alex
39  * - in Conn_WriteStr() wurde das CR+LF nicht angehaengt!
40  * - Fehler-Ausgaben vereinheitlicht.
41  *
42  * Revision 1.8  2001/12/23 22:02:54  alex
43  * - Conn_WriteStr() nimmt nun variable Parameter,
44  * - diverse kleinere Aenderungen.
45  *
46  * Revision 1.7  2001/12/21 22:24:25  alex
47  * - kleinere Aenderungen an den Log-Meldungen,
48  * - Parse_Request() wird aufgerufen.
49  *
50  * Revision 1.6  2001/12/15 00:11:55  alex
51  * - Lese- und Schreib-Puffer implementiert.
52  * - einige neue (Unter-)Funktionen eingefuehrt.
53  * - diverse weitere kleinere Aenderungen.
54  *
55  * Revision 1.5  2001/12/14 08:16:47  alex
56  * - Begonnen, Client-spezifische Lesepuffer zu implementieren.
57  * - Umstellung auf Datentyp "CONN_ID".
58  *
59  * Revision 1.4  2001/12/13 02:04:16  alex
60  * - boesen "Speicherschiesser" in Log() gefixt.
61  *
62  * Revision 1.3  2001/12/13 01:33:09  alex
63  * - Conn_Handler() unterstuetzt nun einen Timeout.
64  * - fuer Verbindungen werden keine FILE-Handles mehr benutzt.
65  * - kleinere "Code Cleanups" ;-)
66  *
67  * Revision 1.2  2001/12/12 23:32:02  alex
68  * - diverse Erweiterungen und Verbesserungen (u.a. sind nun mehrere
69  *   Verbindungen und Listen-Sockets moeglich).
70  *
71  * Revision 1.1  2001/12/12 17:18:38  alex
72  * - Modul zur Verwaltung aller Netzwerk-Verbindungen begonnen.
73  */
74
75
76 #include <portab.h>
77 #include "global.h"
78
79 #include <imp.h>
80 #include <assert.h>
81 #include <stdarg.h>
82 #include <stdio.h>
83 #include <unistd.h>
84 #include <errno.h>
85 #include <fcntl.h>
86 #include <string.h>
87 #include <sys/socket.h>
88 #include <sys/time.h>
89 #include <sys/types.h>
90 #include <time.h>
91 #include <netinet/in.h>
92 #include <arpa/inet.h>
93
94 #ifdef HAVE_STDINT_H
95 #include <stdint.h>                     /* u.a. fuer Mac OS X */
96 #endif
97
98 #include "ngircd.h"
99 #include "client.h"
100 #include "conf.h"
101 #include "log.h"
102 #include "parse.h"
103 #include "tool.h"
104
105 #include <exp.h>
106 #include "conn.h"
107
108
109 #define MAX_CONNECTIONS 100             /* max. Anzahl von Verbindungen an diesem Server */
110
111 #define MAX_CMDLEN 512                  /* max. Laenge eines Befehls, vgl. RFC 2812, 3.2 */
112
113 #define READBUFFER_LEN 2 * MAX_CMDLEN   /* Laenge des Lesepuffers je Verbindung (Bytes) */
114 #define WRITEBUFFER_LEN 4096            /* Laenge des Schreibpuffers je Verbindung (Bytes) */
115
116
117 typedef struct _Connection
118 {
119         INT sock;                       /* Socket Handle */
120         struct sockaddr_in addr;        /* Adresse des Client */
121         CHAR rbuf[READBUFFER_LEN + 1];  /* Lesepuffer */
122         INT rdatalen;                   /* Laenge der Daten im Lesepuffer */
123         CHAR wbuf[WRITEBUFFER_LEN + 1]; /* Schreibpuffer */
124         INT wdatalen;                   /* Laenge der Daten im Schreibpuffer */
125         time_t lastdata;                /* Letzte Aktivitaet */
126         time_t lastping;                /* Letzter PING */
127 } CONNECTION;
128
129
130 LOCAL VOID Handle_Read( INT sock );
131 LOCAL BOOLEAN Handle_Write( CONN_ID Idx );
132 LOCAL VOID New_Connection( INT Sock );
133 LOCAL CONN_ID Socket2Index( INT Sock );
134 LOCAL VOID Read_Request( CONN_ID Idx );
135 LOCAL BOOLEAN Try_Write( CONN_ID Idx );
136 LOCAL VOID Handle_Buffer( CONN_ID Idx );
137 LOCAL VOID Check_Connections( VOID );
138
139
140 LOCAL fd_set My_Listener;
141 LOCAL fd_set My_Sockets;
142
143 LOCAL INT My_Max_Fd;
144
145 LOCAL CONNECTION My_Connections[MAX_CONNECTIONS];
146
147
148 GLOBAL VOID Conn_Init( VOID )
149 {
150         CONN_ID i;
151
152         /* zu Beginn haben wir keine Verbindungen */
153         FD_ZERO( &My_Listener );
154         FD_ZERO( &My_Sockets );
155
156         My_Max_Fd = 0;
157
158         /* Connection-Struktur initialisieren */
159         for( i = 0; i < MAX_CONNECTIONS; i++ ) My_Connections[i].sock = NONE;
160 } /* Conn_Init */
161
162
163 GLOBAL VOID Conn_Exit( VOID )
164 {
165         CONN_ID idx;
166         INT i;
167
168         /* Sockets schliessen */
169         for( i = 0; i < My_Max_Fd + 1; i++ )
170         {
171                 if( FD_ISSET( i, &My_Sockets ))
172                 {
173                         for( idx = 0; idx < MAX_CONNECTIONS; idx++ )
174                         {
175                                 if( My_Connections[idx].sock == i ) break;
176                         }
177                         if( idx < MAX_CONNECTIONS ) Conn_Close( idx, "Server going down ..." );
178                         else if( FD_ISSET( i, &My_Listener ))
179                         {
180                                 close( i );
181                                 Log( LOG_INFO, "Listening socket %d closed.", i );
182                         }
183                         else
184                         {
185                                 close( i );
186                                 Log( LOG_WARNING, "Unknown connection %d closed.", i );
187                         }
188                 }
189         }
190 } /* Conn_Exit */
191
192
193 GLOBAL BOOLEAN Conn_NewListener( CONST INT Port )
194 {
195         /* Neuen Listen-Socket erzeugen: der Server wartet dann
196          * auf dem angegebenen Port auf Verbindungen. */
197
198         struct sockaddr_in addr;
199         INT sock, on = 1;
200
201         /* Server-"Listen"-Socket initialisieren */
202         memset( &addr, 0, sizeof( addr ));
203         addr.sin_family = AF_INET;
204         addr.sin_port = htons( Port );
205         addr.sin_addr.s_addr = htonl( INADDR_ANY );
206
207         /* Socket erzeugen */
208         sock = socket( PF_INET, SOCK_STREAM, 0);
209         if( sock < 0 )
210         {
211                 Log( LOG_ALERT, "Can't create socket: %s!", strerror( errno ));
212                 return FALSE;
213         }
214
215         /* Socket-Optionen setzen */
216         if( fcntl( sock, F_SETFL, O_NONBLOCK ) != 0 )
217         {
218                 Log( LOG_ALERT, "Can't enable non-blocking mode: %s!", strerror( errno ));
219                 close( sock );
220                 return FALSE;
221         }
222         if( setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &on, (socklen_t)sizeof( on )) != 0)
223         {
224                 Log( LOG_CRIT, "Can't set socket options: %s!", strerror( errno ));
225                 /* dieser Fehler kann ignoriert werden. */
226         }
227
228         /* an Port binden */
229         if( bind( sock, (struct sockaddr *)&addr, (socklen_t)sizeof( addr )) != 0 )
230         {
231                 Log( LOG_ALERT, "Can't bind socket: %s!", strerror( errno ));
232                 close( sock );
233                 return FALSE;
234         }
235
236         /* in "listen mode" gehen :-) */
237         if( listen( sock, 10 ) != 0 )
238         {
239                 Log( LOG_ALERT, "Can't listen on soecket: %s!", strerror( errno ));
240                 close( sock );
241                 return FALSE;
242         }
243
244         /* Neuen Listener in Strukturen einfuegen */
245         FD_SET( sock, &My_Listener );
246         FD_SET( sock, &My_Sockets );
247
248         if( sock > My_Max_Fd ) My_Max_Fd = sock;
249
250         Log( LOG_INFO, "Now listening on port %d, socket %d.", Port, sock );
251
252         return TRUE;
253 } /* Conn_NewListener */
254
255
256 GLOBAL VOID Conn_Handler( INT Timeout )
257 {
258         fd_set read_sockets, write_sockets;
259         struct timeval tv;
260         time_t start;
261         INT i;
262
263         start = time( NULL );
264         while(( time( NULL ) - start < Timeout ) && ( ! NGIRCd_Quit ))
265         {
266                 Check_Connections( );
267
268                 /* Timeout initialisieren */
269                 tv.tv_sec = 0;
270                 tv.tv_usec = 50000;
271
272                 /* noch volle Lese-Buffer suchen */
273                 for( i = 0; i < MAX_CONNECTIONS; i++ )
274                 {
275                         if(( My_Connections[i].sock >= 0 ) && ( My_Connections[i].rdatalen > 0 ))
276                         {
277                                 /* Kann aus dem Buffer noch ein Befehl extrahiert werden? */
278                                 Handle_Buffer( i );
279                         }
280                 }
281                 
282                 /* noch volle Schreib-Puffer suchen */
283                 FD_ZERO( &write_sockets );
284                 for( i = 0; i < MAX_CONNECTIONS; i++ )
285                 {
286                         if(( My_Connections[i].sock >= 0 ) && ( My_Connections[i].wdatalen > 0 ))
287                         {
288                                 /* Socket der Verbindung in Set aufnehmen */
289                                 FD_SET( My_Connections[i].sock, &write_sockets );
290                         }
291                 }
292                 
293                 read_sockets = My_Sockets;
294                 if( select( My_Max_Fd + 1, &read_sockets, &write_sockets, NULL, &tv ) == -1 )
295                 {
296                         if( errno != EINTR ) Log( LOG_ALERT, "select(): %s!", strerror( errno ));
297                         return;
298                 }
299
300                 /* Koennen Daten geschrieben werden? */
301                 for( i = 0; i < My_Max_Fd + 1; i++ )
302                 {
303                         if( FD_ISSET( i, &write_sockets )) Handle_Write( Socket2Index( i ));
304                 }
305
306                 /* Daten zum Lesen vorhanden? */
307                 for( i = 0; i < My_Max_Fd + 1; i++ )
308                 {
309                         if( FD_ISSET( i, &read_sockets )) Handle_Read( i );
310                 }
311         }
312 } /* Conn_Handler */
313
314
315 GLOBAL BOOLEAN Conn_WriteStr( CONN_ID Idx, CHAR *Format, ... )
316 {
317         /* String in Socket schreiben. CR+LF wird von dieser Funktion
318          * automatisch angehaengt. Im Fehlerfall wird dir Verbindung
319          * getrennt und FALSE geliefert. */
320
321         CHAR buffer[MAX_CMDLEN];
322         BOOLEAN ok;
323         va_list ap;
324
325         va_start( ap, Format );
326         if( vsnprintf( buffer, MAX_CMDLEN - 2, Format, ap ) == MAX_CMDLEN - 2 )
327         {
328                 Log( LOG_ALERT, "String too long to send (connection %d)!", Idx );
329                 Conn_Close( Idx, "Server error: String too long to send!" );
330                 return FALSE;
331         }
332
333 #ifdef SNIFFER
334         Log( LOG_DEBUG, " -> connection %d: '%s'.", Idx, buffer );
335 #endif
336
337         strcat( buffer, "\r\n" );
338         ok = Conn_Write( Idx, buffer, strlen( buffer ));
339
340         va_end( ap );
341         return ok;
342 } /* Conn_WriteStr */
343
344
345 GLOBAL BOOLEAN Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
346 {
347         /* Daten in Socket schreiben. Bei "fatalen" Fehlern wird
348          * der Client disconnectiert und FALSE geliefert. */
349
350         assert( Idx >= 0 );
351         assert( My_Connections[Idx].sock >= 0 );
352         assert( Data != NULL );
353         assert( Len > 0 );
354
355         /* pruefen, ob Daten im Schreibpuffer sind. Wenn ja, zunaechst
356          * pruefen, ob diese gesendet werden koennen */
357         if( My_Connections[Idx].wdatalen > 0 )
358         {
359                 if( ! Try_Write( Idx )) return FALSE;
360         }
361
362         /* pruefen, ob im Schreibpuffer genuegend Platz ist */
363         if( WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - Len <= 0 )
364         {
365                 /* der Puffer ist dummerweise voll ... */
366                 Log( LOG_NOTICE, "Write buffer overflow (connection %d)!", Idx );
367                 Conn_Close( Idx, NULL );
368                 return FALSE;
369         }
370
371         /* Daten in Puffer kopieren */
372         memcpy( My_Connections[Idx].wbuf + My_Connections[Idx].wdatalen, Data, Len );
373         My_Connections[Idx].wdatalen += Len;
374
375         /* pruefen, on Daten vorhanden sind und geschrieben werden koennen */
376         if( My_Connections[Idx].wdatalen > 0 )
377         {
378                 if( ! Try_Write( Idx )) return FALSE;
379         }
380
381         return TRUE;
382 } /* Conn_Write */
383
384
385 GLOBAL VOID Conn_Close( CONN_ID Idx, CHAR *Msg )
386 {
387         /* Verbindung schliessen */
388
389         assert( Idx >= 0 );
390         assert( My_Connections[Idx].sock >= 0 );
391
392         if( Msg ) Conn_WriteStr( Idx, "ERROR :%s", Msg );
393
394         if( close( My_Connections[Idx].sock ) != 0 )
395         {
396                 Log( LOG_ERR, "Error closing connection %d with %s:%d - %s!", Idx, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port), strerror( errno ));
397                 return;
398         }
399         else
400         {
401                 Log( LOG_NOTICE, "Connection %d with %s:%d closed.", Idx, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port ));
402         }
403
404         Client_Destroy( Client_GetFromConn( Idx ));
405
406         FD_CLR( My_Connections[Idx].sock, &My_Sockets );
407         My_Connections[Idx].sock = NONE;
408 } /* Conn_Close */
409
410
411 LOCAL BOOLEAN Try_Write( CONN_ID Idx )
412 {
413         /* Versuchen, Daten aus dem Schreib-Puffer in den
414          * Socket zu schreiben. */
415
416         fd_set write_socket;
417
418         assert( Idx >= 0 );
419         assert( My_Connections[Idx].sock >= 0 );
420         assert( My_Connections[Idx].wdatalen > 0 );
421
422         FD_ZERO( &write_socket );
423         FD_SET( My_Connections[Idx].sock, &write_socket );
424         if( select( My_Connections[Idx].sock + 1, NULL, &write_socket, NULL, 0 ) == -1 )
425         {
426                 /* Fehler! */
427                 if( errno != EINTR )
428                 {
429                         Log( LOG_ALERT, "select(): %s!", strerror( errno ));
430                         Conn_Close( Idx, NULL );
431                         return FALSE;
432                 }
433         }
434
435         if( FD_ISSET( My_Connections[Idx].sock, &write_socket )) return Handle_Write( Idx );
436         else return TRUE;
437 } /* Try_Write */
438
439
440 LOCAL VOID Handle_Read( INT Sock )
441 {
442         /* Aktivitaet auf einem Socket verarbeiten */
443
444         CONN_ID idx;
445
446         assert( Sock >= 0 );
447
448         if( FD_ISSET( Sock, &My_Listener ))
449         {
450                 /* es ist einer unserer Listener-Sockets: es soll
451                  * also eine neue Verbindung aufgebaut werden. */
452
453                 New_Connection( Sock );
454         }
455         else
456         {
457                 /* Ein Client Socket: entweder ein User oder Server */
458
459                 idx = Socket2Index( Sock );
460                 Read_Request( idx );
461         }
462 } /* Handle_Read */
463
464
465 LOCAL BOOLEAN Handle_Write( CONN_ID Idx )
466 {
467         /* Daten aus Schreibpuffer versenden */
468
469         INT len;
470
471         assert( Idx >= 0 );
472         assert( My_Connections[Idx].sock >= 0 );
473         assert( My_Connections[Idx].wdatalen > 0 );
474
475         /* Daten schreiben */
476         len = send( My_Connections[Idx].sock, My_Connections[Idx].wbuf, My_Connections[Idx].wdatalen, 0 );
477         if( len < 0 )
478         {
479                 /* Oops, ein Fehler! */
480                 Log( LOG_ALERT, "Write error (buffer) on connection %d: %s!", Idx, strerror( errno ));
481                 Conn_Close( Idx, NULL );
482                 return FALSE;
483         }
484
485         /* Puffer anpassen */
486         My_Connections[Idx].wdatalen -= len;
487         memmove( My_Connections[Idx].wbuf, My_Connections[Idx].wbuf + len, My_Connections[Idx].wdatalen );
488
489         return TRUE;
490 } /* Handle_Write */
491
492
493 LOCAL VOID New_Connection( INT Sock )
494 {
495         /* Neue Client-Verbindung von Listen-Socket annehmen und
496          * CLIENT-Struktur anlegen. */
497
498         struct sockaddr_in new_addr;
499         INT new_sock, new_sock_len;
500         CONN_ID idx;
501
502         assert( Sock >= 0 );
503
504         new_sock_len = sizeof( new_addr );
505         new_sock = accept( Sock, (struct sockaddr *)&new_addr, (socklen_t *)&new_sock_len );
506         if( new_sock < 0 )
507         {
508                 Log( LOG_CRIT, "Can't accept connection: %s!", strerror( errno ));
509                 return;
510         }
511
512         /* Freie Connection-Struktur suschen */
513         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock < 0 ) break;
514         if( idx >= MAX_CONNECTIONS )
515         {
516                 Log( LOG_ALERT, "Can't accept connection: limit reached (%d)!", MAX_CONNECTIONS );
517                 close( new_sock );
518                 return;
519         }
520
521         /* Client-Struktur initialisieren */
522         if( ! Client_NewLocal( idx, inet_ntoa( new_addr.sin_addr )))
523         {
524                 Log( LOG_ALERT, "Can't accept connection: can't create client structure!" );
525                 close( new_sock );
526                 return;
527         }
528
529         /* Verbindung registrieren */
530         My_Connections[idx].sock = new_sock;
531         My_Connections[idx].addr = new_addr;
532         My_Connections[idx].rdatalen = 0;
533         My_Connections[idx].wdatalen = 0;
534         My_Connections[idx].lastdata = time( NULL );
535         My_Connections[idx].lastping = 0;
536
537         /* Neuen Socket registrieren */
538         FD_SET( new_sock, &My_Sockets );
539
540         if( new_sock > My_Max_Fd ) My_Max_Fd = new_sock;
541
542         Log( LOG_NOTICE, "Accepted connection %d from %s:%d on socket %d.", idx, inet_ntoa( new_addr.sin_addr ), ntohs( new_addr.sin_port), Sock );
543 } /* New_Connection */
544
545
546 LOCAL CONN_ID Socket2Index( INT Sock )
547 {
548         /* zum Socket passende Connection suchen */
549
550         CONN_ID idx;
551
552         assert( Sock >= 0 );
553
554         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == Sock ) break;
555
556         assert( idx < MAX_CONNECTIONS );
557         return idx;
558 } /* Socket2Index */
559
560
561 LOCAL VOID Read_Request( CONN_ID Idx )
562 {
563         /* Daten von Socket einlesen und entsprechend behandeln.
564          * Tritt ein Fehler auf, so wird der Socket geschlossen. */
565
566         INT len;
567
568         assert( Idx >= 0 );
569         assert( My_Connections[Idx].sock >= 0 );
570
571         len = recv( My_Connections[Idx].sock, My_Connections[Idx].rbuf + My_Connections[Idx].rdatalen, READBUFFER_LEN - My_Connections[Idx].rdatalen, 0 );
572         My_Connections[Idx].rbuf[READBUFFER_LEN] = '\0';
573
574         if( len == 0 )
575         {
576                 /* Socket wurde geschlossen */
577                 Log( LOG_INFO, "%s:%d is closing the connection ...", inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port));
578                 Conn_Close( Idx, NULL );
579                 return;
580         }
581
582         if( len < 0 )
583         {
584                 /* Fehler beim Lesen */
585                 Log( LOG_ALERT, "Read error on connection %d: %s!", Idx, strerror( errno ));
586                 Conn_Close( Idx, NULL );
587                 return;
588         }
589
590         /* Lesebuffer updaten */
591         My_Connections[Idx].rdatalen += len;
592         assert( My_Connections[Idx].rdatalen <= READBUFFER_LEN );
593         My_Connections[Idx].rbuf[My_Connections[Idx].rdatalen] = '\0';
594
595         if( My_Connections[Idx].rdatalen > MAX_CMDLEN )
596         {
597                 /* Eine Anfrage darf(!) nicht laenger als 512 Zeichen
598                  * (incl. CR+LF!) werden; vgl. RFC 2812. Wenn soetwas
599                  * empfangen wird, wird der Client disconnectiert. */
600                 Log( LOG_ALERT, "Request too long (connection %d)!", Idx );
601                 Conn_Close( Idx, "Request too long!" );
602                 return;
603         }
604
605         /* Timestamp aktualisieren */
606         My_Connections[Idx].lastdata = time( NULL );
607
608         Handle_Buffer( Idx );
609 } /* Read_Request */
610
611
612 LOCAL VOID Handle_Buffer( CONN_ID Idx )
613 {
614         CHAR *ptr, *ptr1, *ptr2;
615         INT len, delta;
616         
617         /* Eine komplette Anfrage muss mit CR+LF enden, vgl.
618          * RFC 2812. Haben wir eine? */
619         ptr = strstr( My_Connections[Idx].rbuf, "\r\n" );
620
621         if( ptr ) delta = 2;
622         else
623         {
624                 /* Nicht RFC-konforme Anfrage mit nur CR oder LF? Leider
625                  * machen soetwas viele Clients, u.a. "mIRC" :-( */
626                 ptr1 = strchr( My_Connections[Idx].rbuf, '\r' );
627                 ptr2 = strchr( My_Connections[Idx].rbuf, '\n' );
628                 delta = 1;
629                 if( ptr1 && ptr2 ) ptr = ptr1 > ptr2 ? ptr2 : ptr1;
630                 else if( ptr1 ) ptr = ptr1;
631                 else if( ptr2 ) ptr = ptr2;
632         }
633
634         if( ptr )
635         {
636                 /* Ende der Anfrage wurde gefunden */
637                 *ptr = '\0';
638                 len = ( ptr - My_Connections[Idx].rbuf ) + delta;
639                 if( len > delta )
640                 {
641                         /* Es wurde ein Request gelesen */
642                         if( ! Parse_Request( Idx, My_Connections[Idx].rbuf )) return;
643                 }
644
645                 /* Puffer anpassen */
646                 My_Connections[Idx].rdatalen -= len;
647                 memmove( My_Connections[Idx].rbuf, My_Connections[Idx].rbuf + len, My_Connections[Idx].rdatalen );
648         }
649 } /* Handle_Buffer */
650
651
652 LOCAL VOID Check_Connections( VOID )
653 {
654         /* Pruefen, ob Verbindungen noch "alive" sind */
655
656         INT i;
657
658         for( i = 0; i < MAX_CONNECTIONS; i++ )
659         {
660                 if( My_Connections[i].sock != NONE )
661                 {
662                         if( My_Connections[i].lastping > My_Connections[i].lastdata )
663                         {
664                                 /* es wurde bereits ein PING gesendet */
665                                 if( My_Connections[i].lastping < time( NULL ) - Conf_PongTimeout )
666                                 {
667                                         /* Timeout */
668                                         Log( LOG_NOTICE, "Connection %d: Ping timeout.", i );
669                                         Conn_Close( i, "Ping timeout" );
670                                 }
671                         }
672                         else if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
673                         {
674                                 /* es muss ein PING gesendet werden */
675                                 Log( LOG_DEBUG, "Connection %d: sending PING ...", i );
676                                 My_Connections[i].lastping = time( NULL );
677                                 Conn_WriteStr( i, "PING :%s", This_Server->nick );
678                         }
679                 }
680         }
681 } /* Conn_Check */
682
683
684 /* -eof- */