8e35e662cbc5697ba48cfe71240b688262e6b30d
[ngircd-alex.git] / src / ngircd / conn.c
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  * Please read the file COPYING, README and AUTHORS for more information.
10  *
11  * Connection management
12  */
13
14
15 #include "portab.h"
16
17 static char UNUSED id[] = "$Id: conn.c,v 1.107 2002/12/19 04:35:26 alex Exp $";
18
19 #include "imp.h"
20 #include <assert.h>
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <string.h>
28 #include <sys/socket.h>
29 #include <sys/time.h>
30 #include <sys/types.h>
31 #include <time.h>
32 #include <netinet/in.h>
33
34 #ifdef HAVE_ARPA_INET_H
35 #include <arpa/inet.h>
36 #else
37 #define PF_INET AF_INET
38 #endif
39
40 #ifdef HAVE_STDINT_H
41 #include <stdint.h>                     /* u.a. fuer Mac OS X */
42 #endif
43
44 #ifdef USE_ZLIB
45 #include <zlib.h>
46 #endif
47
48 #include "exp.h"
49 #include "conn.h"
50
51 #include "imp.h"
52 #include "ngircd.h"
53 #include "client.h"
54 #include "resolve.h"
55 #include "conf.h"
56 #include "log.h"
57 #include "parse.h"
58 #include "tool.h"
59
60 #include "exp.h"
61
62
63 #define SERVER_WAIT (NONE - 1)
64
65
66 #ifdef USE_ZLIB
67 typedef struct _ZipData
68 {
69         z_stream in;                    /* "Handle" fuer Input-Stream */
70         z_stream out;                   /* "Handle" fuer Output-Stream */
71         CHAR rbuf[READBUFFER_LEN];      /* Lesepuffer */
72         INT rdatalen;                   /* Laenge der Daten im Lesepuffer (komprimiert) */
73         CHAR wbuf[WRITEBUFFER_LEN];     /* Schreibpuffer */
74         INT wdatalen;                   /* Laenge der Daten im Schreibpuffer (unkomprimiert) */
75         LONG bytes_in, bytes_out;       /* Counter fuer Statistik (unkomprimiert!) */
76 } ZIPDATA;
77 #endif
78
79
80 typedef struct _Connection
81 {
82         INT sock;                       /* Socket Handle */
83         struct sockaddr_in addr;        /* Adresse des Client */
84         RES_STAT *res_stat;             /* "Resolver-Status", s.o. */
85         CHAR host[HOST_LEN];            /* Hostname */
86         CHAR rbuf[READBUFFER_LEN];      /* Lesepuffer */
87         INT rdatalen;                   /* Laenge der Daten im Lesepuffer */
88         CHAR wbuf[WRITEBUFFER_LEN];     /* Schreibpuffer */
89         INT wdatalen;                   /* Laenge der Daten im Schreibpuffer */
90         INT our_server;                 /* wenn von uns zu connectender Server: ID */
91         time_t starttime;               /* Startzeit des Links */
92         time_t lastdata;                /* Letzte Aktivitaet */
93         time_t lastping;                /* Letzter PING */
94         time_t lastprivmsg;             /* Letzte PRIVMSG */
95         time_t delaytime;               /* Nicht beachten bis ("penalty") */
96         LONG bytes_in, bytes_out;       /* Empfangene uns gesendete Bytes */
97         LONG msg_in, msg_out;           /* Empfangene uns gesendete Nachtichten */
98         INT flag;                       /* "Markierungs-Flag" (vgl. "irc-write"-Modul) */
99         INT options;                    /* Link-Optionen */
100 #ifdef USE_ZLIB
101         ZIPDATA zip;                    /* Kompressionsinformationen */
102 #endif
103 } CONNECTION;
104
105
106 LOCAL VOID Handle_Read PARAMS(( INT sock ));
107 LOCAL BOOLEAN Handle_Write PARAMS(( CONN_ID Idx ));
108 LOCAL VOID New_Connection PARAMS(( INT Sock ));
109 LOCAL CONN_ID Socket2Index PARAMS(( INT Sock ));
110 LOCAL VOID Read_Request PARAMS(( CONN_ID Idx ));
111 LOCAL BOOLEAN Try_Write PARAMS(( CONN_ID Idx ));
112 LOCAL BOOLEAN Handle_Buffer PARAMS(( CONN_ID Idx ));
113 LOCAL VOID Check_Connections PARAMS(( VOID ));
114 LOCAL VOID Check_Servers PARAMS(( VOID ));
115 LOCAL VOID Init_Conn_Struct PARAMS(( LONG Idx ));
116 LOCAL BOOLEAN Init_Socket PARAMS(( INT Sock ));
117 LOCAL VOID New_Server PARAMS(( INT Server, CONN_ID Idx ));
118 LOCAL VOID Read_Resolver_Result PARAMS(( INT r_fd ));
119
120 #ifdef USE_ZLIB
121 LOCAL BOOLEAN Zip_Buffer PARAMS(( CONN_ID Idx, CHAR *Data, INT Len ));
122 LOCAL BOOLEAN Zip_Flush PARAMS(( CONN_ID Idx ));
123 LOCAL BOOLEAN Unzip_Buffer PARAMS(( CONN_ID Idx ));
124 #endif
125
126
127 LOCAL fd_set My_Listeners;
128 LOCAL fd_set My_Sockets;
129 LOCAL fd_set My_Connects;
130
131 LOCAL CONNECTION *My_Connections;
132 LOCAL LONG Pool_Size, WCounter;
133
134
135 GLOBAL VOID
136 Conn_Init( VOID )
137 {
138         /* Modul initialisieren: statische Strukturen "ausnullen". */
139
140         CONN_ID i;
141
142         /* Speicher fuer Verbindungs-Pool anfordern */
143         Pool_Size = CONNECTION_POOL;
144         if( Conf_MaxConnections > 0 )
145         {
146                 /* konfiguriertes Limit beachten */
147                 if( Pool_Size > Conf_MaxConnections ) Pool_Size = Conf_MaxConnections;
148         }
149         My_Connections = malloc( sizeof( CONNECTION ) * Pool_Size );
150         if( ! My_Connections )
151         {
152                 /* Speicher konnte nicht alloziert werden! */
153                 Log( LOG_EMERG, "Can't allocate memory! [Conn_Init]" );
154                 exit( 1 );
155         }
156         Log( LOG_DEBUG, "Allocted connection pool for %ld items (%ld bytes).", Pool_Size, sizeof( CONNECTION ) * Pool_Size );
157
158         /* zu Beginn haben wir keine Verbindungen */
159         FD_ZERO( &My_Listeners );
160         FD_ZERO( &My_Sockets );
161         FD_ZERO( &My_Connects );
162
163         /* Groesster File-Descriptor fuer select() */
164         Conn_MaxFD = 0;
165
166         /* Connection-Struktur initialisieren */
167         for( i = 0; i < Pool_Size; i++ ) Init_Conn_Struct( i );
168
169         /* Global write counter */
170         WCounter = 0;
171 } /* Conn_Init */
172
173
174 GLOBAL VOID
175 Conn_Exit( VOID )
176 {
177         /* Modul abmelden: alle noch offenen Connections
178          * schliessen und freigeben. */
179
180         CONN_ID idx;
181         INT i;
182
183         /* Sockets schliessen */
184         Log( LOG_DEBUG, "Shutting down all connections ..." );
185         for( i = 0; i < Conn_MaxFD + 1; i++ )
186         {
187                 if( FD_ISSET( i, &My_Sockets ))
188                 {
189                         for( idx = 0; idx < Pool_Size; idx++ )
190                         {
191                                 if( My_Connections[idx].sock == i ) break;
192                         }
193                         if( FD_ISSET( i, &My_Listeners ))
194                         {
195                                 close( i );
196                                 Log( LOG_DEBUG, "Listening socket %d closed.", i );
197                         }
198                         else if( FD_ISSET( i, &My_Connects ))
199                         {
200                                 close( i );
201                                 Log( LOG_DEBUG, "Connection %d closed during creation (socket %d).", idx, i );
202                         }
203                         else if( idx < Pool_Size )
204                         {
205                                 if( NGIRCd_SignalRestart ) Conn_Close( idx, NULL, "Server going down (restarting)", TRUE );
206                                 else Conn_Close( idx, NULL, "Server going down", TRUE );
207                         }
208                         else
209                         {
210                                 Log( LOG_WARNING, "Closing unknown connection %d ...", i );
211                                 close( i );
212                         }
213                 }
214         }
215         
216         free( My_Connections );
217         My_Connections = NULL;
218         Pool_Size = 0;
219 } /* Conn_Exit */
220
221
222 GLOBAL INT
223 Conn_InitListeners( VOID )
224 {
225         /* Ports, auf denen der Server Verbindungen entgegennehmen
226         * soll, initialisieren */
227
228         INT created, i;
229
230         created = 0;
231         for( i = 0; i < Conf_ListenPorts_Count; i++ )
232         {
233                 if( Conn_NewListener( Conf_ListenPorts[i] )) created++;
234                 else Log( LOG_ERR, "Can't listen on port %u!", Conf_ListenPorts[i] );
235         }
236         return created;
237 } /* Conn_InitListeners */
238
239
240 GLOBAL VOID
241 Conn_ExitListeners( VOID )
242 {
243         /* Alle "Listen-Sockets" schliessen */
244
245         INT i;
246
247         Log( LOG_INFO, "Shutting down all listening sockets ..." );
248         for( i = 0; i < Conn_MaxFD + 1; i++ )
249         {
250                 if( FD_ISSET( i, &My_Sockets ) && FD_ISSET( i, &My_Listeners ))
251                 {
252                         close( i );
253                         Log( LOG_DEBUG, "Listening socket %d closed.", i );
254                 }
255         }
256 } /* Conn_ExitListeners */
257
258
259 GLOBAL BOOLEAN
260 Conn_NewListener( CONST UINT Port )
261 {
262         /* Neuen Listen-Socket erzeugen: der Server wartet dann auf
263          * dem angegebenen Port auf Verbindungen. Kann der Listen-
264          * Socket nicht erteugt werden, so wird NULL geliefert.*/
265
266         struct sockaddr_in addr;
267         INT sock;
268
269         /* Server-"Listen"-Socket initialisieren */
270         memset( &addr, 0, sizeof( addr ));
271         addr.sin_family = AF_INET;
272         addr.sin_port = htons( Port );
273         addr.sin_addr.s_addr = htonl( INADDR_ANY );
274
275         /* Socket erzeugen */
276         sock = socket( PF_INET, SOCK_STREAM, 0);
277         if( sock < 0 )
278         {
279                 Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
280                 return FALSE;
281         }
282
283         if( ! Init_Socket( sock )) return FALSE;
284
285         /* an Port binden */
286         if( bind( sock, (struct sockaddr *)&addr, (socklen_t)sizeof( addr )) != 0 )
287         {
288                 Log( LOG_CRIT, "Can't bind socket: %s!", strerror( errno ));
289                 close( sock );
290                 return FALSE;
291         }
292
293         /* in "listen mode" gehen :-) */
294         if( listen( sock, 10 ) != 0 )
295         {
296                 Log( LOG_CRIT, "Can't listen on soecket: %s!", strerror( errno ));
297                 close( sock );
298                 return FALSE;
299         }
300
301         /* Neuen Listener in Strukturen einfuegen */
302         FD_SET( sock, &My_Listeners );
303         FD_SET( sock, &My_Sockets );
304
305         if( sock > Conn_MaxFD ) Conn_MaxFD = sock;
306
307         Log( LOG_INFO, "Now listening on port %d (socket %d).", Port, sock );
308
309         return TRUE;
310 } /* Conn_NewListener */
311
312
313 GLOBAL VOID
314 Conn_Handler( VOID )
315 {
316         /* "Hauptschleife": Aktive Verbindungen ueberwachen. Folgende Aktionen
317          * werden dabei durchgefuehrt, bis der Server terminieren oder neu
318          * starten soll:
319          *
320          *  - neue Verbindungen annehmen,
321          *  - Server-Verbindungen aufbauen,
322          *  - geschlossene Verbindungen loeschen,
323          *  - volle Schreibpuffer versuchen zu schreiben,
324          *  - volle Lesepuffer versuchen zu verarbeiten,
325          *  - Antworten von Resolver Sub-Prozessen annehmen.
326          */
327
328         fd_set read_sockets, write_sockets;
329         struct timeval tv;
330         time_t start, t;
331         LONG i, idx;
332         BOOLEAN timeout;
333
334         start = time( NULL );
335         while(( ! NGIRCd_SignalQuit ) && ( ! NGIRCd_SignalRestart ))
336         {
337                 timeout = TRUE;
338
339                 /* Should the configuration be reloaded? */
340                 if( NGIRCd_SignalRehash ) NGIRCd_Rehash( );
341
342                 /* Check configured servers and established links */
343                 Check_Servers( );
344                 Check_Connections( );
345
346                 /* noch volle Lese-Buffer suchen */
347                 for( i = 0; i < Pool_Size; i++ )
348                 {
349                         if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].rdatalen > 0 ))
350                         {
351                                 /* Kann aus dem Buffer noch ein Befehl extrahiert werden? */
352                                 if( Handle_Buffer( i )) timeout = FALSE;
353                         }
354                 }
355
356                 /* noch volle Schreib-Puffer suchen */
357                 FD_ZERO( &write_sockets );
358                 for( i = 0; i < Pool_Size; i++ )
359                 {
360 #ifdef USE_ZLIB
361                         if(( My_Connections[i].sock > NONE ) && (( My_Connections[i].wdatalen > 0 ) || ( My_Connections[i].zip.wdatalen > 0 )))
362 #else
363                         if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].wdatalen > 0 ))
364 #endif
365                         {
366                                 /* Socket der Verbindung in Set aufnehmen */
367                                 FD_SET( My_Connections[i].sock, &write_sockets );
368                         }
369                 }
370                 /* Sockets mit im Aufbau befindlichen ausgehenden Verbindungen suchen */
371                 for( i = 0; i < Pool_Size; i++ )
372                 {
373                         if(( My_Connections[i].sock > NONE ) && ( FD_ISSET( My_Connections[i].sock, &My_Connects ))) FD_SET( My_Connections[i].sock, &write_sockets );
374                 }
375
376                 /* von welchen Sockets koennte gelesen werden? */
377                 t = time( NULL );
378                 read_sockets = My_Sockets;
379                 for( i = 0; i < Pool_Size; i++ )
380                 {
381                         if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].host[0] == '\0' ))
382                         {
383                                 /* Hier muss noch auf den Resolver Sub-Prozess gewartet werden */
384                                 FD_CLR( My_Connections[i].sock, &read_sockets );
385                         }
386                         if(( My_Connections[i].sock > NONE ) && ( FD_ISSET( My_Connections[i].sock, &My_Connects )))
387                         {
388                                 /* Hier laeuft noch ein asyncrones connect() */
389                                 FD_CLR( My_Connections[i].sock, &read_sockets );
390                         }
391                         if( My_Connections[i].delaytime > t )
392                         {
393                                 /* Fuer die Verbindung ist eine "Penalty-Zeit" gesetzt */
394                                 FD_CLR( My_Connections[i].sock, &read_sockets );
395                                 FD_CLR( My_Connections[i].sock, &write_sockets );
396                         }
397                 }
398                 for( i = 0; i < Conn_MaxFD + 1; i++ )
399                 {
400                         /* Pipes von Resolver Sub-Prozessen aufnehmen */
401                         if( FD_ISSET( i, &Resolver_FDs ))
402                         {
403                                 FD_SET( i, &read_sockets );
404                         }
405                 }
406
407                 /* Timeout initialisieren */
408                 tv.tv_usec = 0;
409                 if( timeout ) tv.tv_sec = TIME_RES;
410                 else tv.tv_sec = 0;
411                 
412                 /* Auf Aktivitaet warten */
413                 i = select( Conn_MaxFD + 1, &read_sockets, &write_sockets, NULL, &tv );
414                 if( i == 0 )
415                 {
416                         /* keine Veraenderung an den Sockets */
417                         continue;
418                 }
419                 if( i == -1 )
420                 {
421                         /* Fehler (z.B. Interrupt) */
422                         if( errno != EINTR )
423                         {
424                                 Log( LOG_EMERG, "Conn_Handler(): select(): %s!", strerror( errno ));
425                                 Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE );
426                                 exit( 1 );
427                         }
428                         continue;
429                 }
430
431                 /* Koennen Daten geschrieben werden? */
432                 for( i = 0; i < Conn_MaxFD + 1; i++ )
433                 {
434                         if( ! FD_ISSET( i, &write_sockets )) continue;
435
436                         /* Es kann geschrieben werden ... */
437                         idx = Socket2Index( i );
438                         if( idx == NONE ) continue;
439                         
440                         if( ! Handle_Write( idx ))
441                         {
442                                 /* Fehler beim Schreiben! Diesen Socket nun
443                                  * auch aus dem Read-Set entfernen: */
444                                 FD_CLR( i, &read_sockets );
445                         }
446                 }
447
448                 /* Daten zum Lesen vorhanden? */
449                 for( i = 0; i < Conn_MaxFD + 1; i++ )
450                 {
451                         if( FD_ISSET( i, &read_sockets )) Handle_Read( i );
452                 }
453         }
454
455         if( NGIRCd_SignalQuit ) Log( LOG_NOTICE|LOG_snotice, "Server going down NOW!" );
456         else if( NGIRCd_SignalRestart ) Log( LOG_NOTICE|LOG_snotice, "Server restarting NOW!" );
457 } /* Conn_Handler */
458
459
460 #ifdef PROTOTYPES
461 GLOBAL BOOLEAN
462 Conn_WriteStr( CONN_ID Idx, CHAR *Format, ... )
463 #else
464 GLOBAL BOOLEAN
465 Conn_WriteStr( Idx, Format, va_alist )
466 CONN_ID Idx;
467 CHAR *Format;
468 va_dcl
469 #endif
470 {
471         /* String in Socket schreiben. CR+LF wird von dieser Funktion
472          * automatisch angehaengt. Im Fehlerfall wird dir Verbindung
473          * getrennt und FALSE geliefert. */
474
475         CHAR buffer[COMMAND_LEN];
476         BOOLEAN ok;
477         va_list ap;
478
479         assert( Idx > NONE );
480         assert( Format != NULL );
481
482 #ifdef PROTOTYPES
483         va_start( ap, Format );
484 #else
485         va_start( ap );
486 #endif
487         if( vsnprintf( buffer, COMMAND_LEN - 2, Format, ap ) == COMMAND_LEN - 2 )
488         {
489                 Log( LOG_CRIT, "Text too long to send (connection %d)!", Idx );
490                 Conn_Close( Idx, "Text too long to send!", NULL, FALSE );
491                 return FALSE;
492         }
493
494 #ifdef SNIFFER
495         if( NGIRCd_Sniffer ) Log( LOG_DEBUG, " -> connection %d: '%s'.", Idx, buffer );
496 #endif
497
498         strcat( buffer, "\r\n" );
499         ok = Conn_Write( Idx, buffer, strlen( buffer ));
500         My_Connections[Idx].msg_out++;
501
502         va_end( ap );
503         return ok;
504 } /* Conn_WriteStr */
505
506
507 GLOBAL BOOLEAN
508 Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
509 {
510         /* Daten in Socket schreiben. Bei "fatalen" Fehlern wird
511          * der Client disconnectiert und FALSE geliefert. */
512
513         assert( Idx > NONE );
514         assert( Data != NULL );
515         assert( Len > 0 );
516
517         /* Ist der entsprechende Socket ueberhaupt noch offen? In einem
518          * "Handler-Durchlauf" kann es passieren, dass dem nicht mehr so
519          * ist, wenn einer von mehreren Conn_Write()'s fehlgeschlagen ist.
520          * In diesem Fall wird hier einfach ein Fehler geliefert. */
521         if( My_Connections[Idx].sock <= NONE )
522         {
523                 Log( LOG_DEBUG, "Skipped write on closed socket (connection %d).", Idx );
524                 return FALSE;
525         }
526
527         /* Pruefen, ob im Schreibpuffer genuegend Platz ist. Ziel ist es,
528          * moeglichts viel im Puffer zu haben und _nicht_ gleich alles auf den
529          * Socket zu schreiben (u.a. wg. Komprimierung). */
530         if( WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - Len <= 0 )
531         {
532                 /* Der Puffer ist dummerweise voll. Jetzt versuchen, den Puffer
533                  * zu schreiben, wenn das nicht klappt, haben wir ein Problem ... */
534                 if( ! Try_Write( Idx )) return FALSE;
535
536                 /* nun neu pruefen: */
537                 if( WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - Len <= 0 )
538                 {
539                         Log( LOG_NOTICE, "Write buffer overflow (connection %d)!", Idx );
540                         Conn_Close( Idx, "Write buffer overflow!", NULL, FALSE );
541                         return FALSE;
542                 }
543         }
544
545 #ifdef USE_ZLIB
546         if( My_Connections[Idx].options & CONN_ZIP )
547         {
548                 /* Daten komprimieren und in Puffer kopieren */
549                 if( ! Zip_Buffer( Idx, Data, Len )) return FALSE;
550         }
551         else
552 #endif
553         {
554                 /* Daten in Puffer kopieren */
555                 memcpy( My_Connections[Idx].wbuf + My_Connections[Idx].wdatalen, Data, Len );
556                 My_Connections[Idx].wdatalen += Len;
557                 My_Connections[Idx].bytes_out += Len;
558         }
559
560         /* Adjust global write counter */
561         WCounter += Len;
562
563         return TRUE;
564 } /* Conn_Write */
565
566
567 GLOBAL VOID
568 Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
569 {
570         /* Verbindung schliessen. Evtl. noch von Resolver
571          * Sub-Prozessen offene Pipes werden geschlossen. */
572
573         CLIENT *c;
574         DOUBLE in_k, out_k;
575 #ifdef USE_ZLIB
576         DOUBLE in_z_k, out_z_k;
577         INT in_p, out_p;
578 #endif
579
580         assert( Idx > NONE );
581         assert( My_Connections[Idx].sock > NONE );
582
583         c = Client_GetFromConn( Idx );
584
585         if( InformClient )
586         {
587 #ifndef STRICT_RFC
588                 /* Statistik an Client melden, wenn User */
589                 if(( c != NULL ) && ( Client_Type( c ) == CLIENT_USER ))
590                 {
591                         Conn_WriteStr( Idx, "NOTICE %s :%sConnection statistics: client %.1f kb, server %.1f kb.", Client_ThisServer( ), NOTICE_TXTPREFIX, (DOUBLE)My_Connections[Idx].bytes_in / 1024,  (DOUBLE)My_Connections[Idx].bytes_out / 1024 );
592                 }
593 #endif
594
595                 /* ERROR an Client schicken (von RFC so vorgesehen!) */
596                 if( FwdMsg ) Conn_WriteStr( Idx, "ERROR :%s", FwdMsg );
597                 else Conn_WriteStr( Idx, "ERROR :Closing connection." );
598                 if( My_Connections[Idx].sock == NONE ) return;
599         }
600
601         /* zunaechst versuchen, noch im Schreibpuffer vorhandene
602          * Daten auf den Socket zu schreiben ... */
603         Try_Write( Idx );
604
605         if( close( My_Connections[Idx].sock ) != 0 )
606         {
607                 Log( LOG_ERR, "Error closing connection %d (socket %d) with %s:%d - %s!", Idx, My_Connections[Idx].sock, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port), strerror( errno ));
608         }
609         else
610         {
611                 in_k = (DOUBLE)My_Connections[Idx].bytes_in / 1024;
612                 out_k = (DOUBLE)My_Connections[Idx].bytes_out / 1024;
613 #ifdef USE_ZLIB
614                 if( My_Connections[Idx].options & CONN_ZIP )
615                 {
616                         in_z_k = (DOUBLE)My_Connections[Idx].zip.bytes_in / 1024;
617                         out_z_k = (DOUBLE)My_Connections[Idx].zip.bytes_out / 1024;
618                         in_p = (INT)(( in_k * 100 ) / in_z_k );
619                         out_p = (INT)(( out_k * 100 ) / out_z_k );
620                         Log( LOG_INFO, "Connection %d with %s:%d closed (in: %.1fk/%.1fk/%d%%, out: %.1fk/%.1fk/%d%%).", Idx, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port ), in_k, in_z_k, in_p, out_k, out_z_k, out_p );
621                 }
622                 else
623 #endif
624                 {
625                         Log( LOG_INFO, "Connection %d with %s:%d closed (in: %.1fk, out: %.1fk).", Idx, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port ), in_k, out_k );
626                 }
627         }
628         
629         /* Socket als "ungueltig" markieren */
630         FD_CLR( My_Connections[Idx].sock, &My_Sockets );
631         FD_CLR( My_Connections[Idx].sock, &My_Connects );
632         My_Connections[Idx].sock = NONE;
633
634         if( c ) Client_Destroy( c, LogMsg, FwdMsg, TRUE );
635
636         if( My_Connections[Idx].res_stat )
637         {
638                 /* Resolver-Strukturen freigeben, wenn noch nicht geschehen */
639                 FD_CLR( My_Connections[Idx].res_stat->pipe[0], &Resolver_FDs );
640                 close( My_Connections[Idx].res_stat->pipe[0] );
641                 close( My_Connections[Idx].res_stat->pipe[1] );
642                 free( My_Connections[Idx].res_stat );
643         }
644
645         /* Startzeit des naechsten Connect-Versuchs modifizieren? */
646         if(( My_Connections[Idx].our_server > NONE ) && ( Conf_Server[My_Connections[Idx].our_server].lasttry <  time( NULL ) - Conf_ConnectRetry ))
647         {
648                 /* Okay, die Verbindung stand schon "genuegend lange":
649                  * lasttry-Zeitpunkt so setzen, dass der naechste
650                  * Verbindungsversuch in RECONNECT_DELAY Sekunden
651                  * gestartet wird. */
652                 Conf_Server[My_Connections[Idx].our_server].lasttry = time( NULL ) - Conf_ConnectRetry + RECONNECT_DELAY;
653         }
654
655 #ifdef USE_ZLIB
656         /* Ggf. zlib abmelden */
657         if( Conn_Options( Idx ) & CONN_ZIP )
658         {
659                 inflateEnd( &My_Connections[Idx].zip.in );
660                 deflateEnd( &My_Connections[Idx].zip.out );
661         }
662 #endif
663
664         /* Connection-Struktur loeschen (=freigeben) */
665         Init_Conn_Struct( Idx );
666 } /* Conn_Close */
667
668
669 GLOBAL VOID
670 Conn_UpdateIdle( CONN_ID Idx )
671 {
672         /* Idle-Timer zuruecksetzen */
673
674         assert( Idx > NONE );
675         My_Connections[Idx].lastprivmsg = time( NULL );
676 }
677
678
679 GLOBAL time_t
680 Conn_GetIdle( CONN_ID Idx )
681 {
682         /* Idle-Time einer Verbindung liefern (in Sekunden) */
683
684         assert( Idx > NONE );
685         return time( NULL ) - My_Connections[Idx].lastprivmsg;
686 } /* Conn_GetIdle */
687
688
689 GLOBAL time_t
690 Conn_LastPing( CONN_ID Idx )
691 {
692         /* Zeitpunkt des letzten PING liefern */
693
694         assert( Idx > NONE );
695         return My_Connections[Idx].lastping;
696 } /* Conn_LastPing */
697
698
699 GLOBAL VOID
700 Conn_SetPenalty( CONN_ID Idx, time_t Seconds )
701 {
702         /* Penalty-Delay fuer eine Verbindung (in Sekunden) setzen;
703          * waehrend dieser Zeit wird der entsprechende Socket vom Server
704          * bei Lese-Operationen komplett ignoriert. Der Delay kann mit
705          * dieser Funktion nur erhoeht, nicht aber verringert werden. */
706         
707         time_t t;
708         
709         assert( Idx > NONE );
710         assert( Seconds >= 0 );
711         
712         t = time( NULL ) + Seconds;
713         if( t > My_Connections[Idx].delaytime ) My_Connections[Idx].delaytime = t;
714 } /* Conn_SetPenalty */
715
716
717 GLOBAL VOID
718 Conn_ResetPenalty( CONN_ID Idx )
719 {
720         assert( Idx > NONE );
721         My_Connections[Idx].delaytime = 0;
722 } /* Conn_ResetPenalty */
723
724
725 GLOBAL VOID
726 Conn_ClearFlags( VOID )
727 {
728         /* Alle Connection auf "nicht-markiert" setzen */
729
730         LONG i;
731
732         for( i = 0; i < Pool_Size; i++ ) My_Connections[i].flag = 0;
733 } /* Conn_ClearFlags */
734
735
736 GLOBAL INT
737 Conn_Flag( CONN_ID Idx )
738 {
739         /* Ist eine Connection markiert (TRUE) oder nicht? */
740
741         assert( Idx > NONE );
742         return My_Connections[Idx].flag;
743 } /* Conn_Flag */
744
745
746 GLOBAL VOID
747 Conn_SetFlag( CONN_ID Idx, INT Flag )
748 {
749         /* Connection markieren */
750
751         assert( Idx > NONE );
752         My_Connections[Idx].flag = Flag;
753 } /* Conn_SetFlag */
754
755
756 GLOBAL CONN_ID
757 Conn_First( VOID )
758 {
759         /* Connection-Struktur der ersten Verbindung liefern;
760          * Ist keine Verbindung vorhanden, wird NONE geliefert. */
761
762         LONG i;
763         
764         for( i = 0; i < Pool_Size; i++ )
765         {
766                 if( My_Connections[i].sock != NONE ) return i;
767         }
768         return NONE;
769 } /* Conn_First */
770
771
772 GLOBAL CONN_ID
773 Conn_Next( CONN_ID Idx )
774 {
775         /* Naechste Verbindungs-Struktur liefern; existiert keine
776          * weitere, so wird NONE geliefert. */
777
778         LONG i = NONE;
779
780         assert( Idx > NONE );
781         
782         for( i = Idx + 1; i < Pool_Size; i++ )
783         {
784                 if( My_Connections[i].sock != NONE ) return i;
785         }
786         return NONE;
787 } /* Conn_Next */
788
789
790 GLOBAL VOID
791 Conn_SetServer( CONN_ID Idx, INT ConfServer )
792 {
793         /* Connection als Server markieren: Index des konfigurierten
794          * Servers speichern. Verbindung muss bereits bestehen! */
795         
796         assert( Idx > NONE );
797         assert( My_Connections[Idx].sock > NONE );
798         
799         My_Connections[Idx].our_server = ConfServer;
800 } /* Conn_SetServer */
801
802
803 GLOBAL VOID
804 Conn_SetOption( CONN_ID Idx, INT Option )
805 {
806         /* Option fuer Verbindung setzen.
807          * Initial sind alle Optionen _nicht_ gesetzt. */
808
809         assert( Idx > NONE );
810         assert( Option != 0 );
811
812         My_Connections[Idx].options |= Option;
813 } /* Conn_SetOption */
814
815
816 GLOBAL VOID
817 Conn_UnsetOption( CONN_ID Idx, INT Option )
818 {
819         /* Option fuer Verbindung loeschen */
820
821         assert( Idx > NONE );
822         assert( Option != 0 );
823
824         My_Connections[Idx].options &= ~Option;
825 } /* Conn_UnsetOption */
826
827
828 GLOBAL INT
829 Conn_Options( CONN_ID Idx )
830 {
831         assert( Idx > NONE );
832         return My_Connections[Idx].options;
833 } /* Conn_Options */
834
835
836 #ifdef USE_ZLIB
837
838 GLOBAL BOOLEAN
839 Conn_InitZip( CONN_ID Idx )
840 {
841         /* Kompression fuer Link initialisieren */
842
843         assert( Idx > NONE );
844
845         My_Connections[Idx].zip.in.avail_in = 0;
846         My_Connections[Idx].zip.in.total_in = 0;
847         My_Connections[Idx].zip.in.total_out = 0;
848         My_Connections[Idx].zip.in.zalloc = NULL;
849         My_Connections[Idx].zip.in.zfree = NULL;
850         My_Connections[Idx].zip.in.data_type = Z_ASCII;
851
852         if( inflateInit( &My_Connections[Idx].zip.in ) != Z_OK )
853         {
854                 /* Fehler! */
855                 Log( LOG_ALERT, "Can't initialize compression on connection %d (zlib inflate)!", Idx );
856                 return FALSE;
857         }
858         
859         My_Connections[Idx].zip.out.total_in = 0;
860         My_Connections[Idx].zip.out.total_in = 0;
861         My_Connections[Idx].zip.out.zalloc = NULL;
862         My_Connections[Idx].zip.out.zfree = NULL;
863         My_Connections[Idx].zip.out.data_type = Z_ASCII;
864
865         if( deflateInit( &My_Connections[Idx].zip.out, Z_DEFAULT_COMPRESSION ) != Z_OK )
866         {
867                 /* Fehler! */
868                 Log( LOG_ALERT, "Can't initialize compression on connection %d (zlib deflate)!", Idx );
869                 return FALSE;
870         }
871
872         My_Connections[Idx].zip.bytes_in = My_Connections[Idx].bytes_in;
873         My_Connections[Idx].zip.bytes_out = My_Connections[Idx].bytes_out;
874
875         Log( LOG_INFO, "Enabled link compression (zlib) on connection %d.", Idx );
876         Conn_SetOption( Idx, CONN_ZIP );
877
878         return TRUE;
879 } /* Conn_InitZip */
880
881
882 GLOBAL LONG
883 Conn_SendBytesZip( CONN_ID Idx )
884 {
885         /* Anzahl gesendeter Bytes (komprimiert!) liefern */
886
887         assert( Idx > NONE );
888         return My_Connections[Idx].zip.bytes_out;
889 } /* Conn_SendBytesZip */
890
891
892 GLOBAL LONG
893 Conn_RecvBytesZip( CONN_ID Idx )
894 {
895         /* Anzahl gesendeter Bytes (komprimiert!) liefern */
896
897         assert( Idx > NONE );
898         return My_Connections[Idx].zip.bytes_in;
899 } /* Conn_RecvBytesZip */
900
901 #endif
902
903
904 GLOBAL time_t
905 Conn_StartTime( CONN_ID Idx )
906 {
907         /* Zeitpunkt des Link-Starts liefern (in Sekunden) */
908
909         assert( Idx > NONE );
910         return My_Connections[Idx].starttime;
911 } /* Conn_Uptime */
912
913
914 GLOBAL INT
915 Conn_SendQ( CONN_ID Idx )
916 {
917         /* Laenge der Daten im Schreibbuffer liefern */
918
919         assert( Idx > NONE );
920 #ifdef USE_ZLIB
921         if( My_Connections[Idx].options & CONN_ZIP ) return My_Connections[Idx].zip.wdatalen;
922         else
923 #endif
924         return My_Connections[Idx].wdatalen;
925 } /* Conn_SendQ */
926
927
928 GLOBAL LONG
929 Conn_SendMsg( CONN_ID Idx )
930 {
931         /* Anzahl gesendeter Nachrichten liefern */
932
933         assert( Idx > NONE );
934         return My_Connections[Idx].msg_out;
935 } /* Conn_SendMsg */
936
937
938 GLOBAL LONG
939 Conn_SendBytes( CONN_ID Idx )
940 {
941         /* Anzahl gesendeter Bytes (unkomprimiert) liefern */
942
943         assert( Idx > NONE );
944         return My_Connections[Idx].bytes_out;
945 } /* Conn_SendBytes */
946
947
948 GLOBAL INT
949 Conn_RecvQ( CONN_ID Idx )
950 {
951         /* Laenge der Daten im Lesebuffer liefern */
952
953         assert( Idx > NONE );
954 #ifdef USE_ZLIB
955         if( My_Connections[Idx].options & CONN_ZIP ) return My_Connections[Idx].zip.rdatalen;
956         else
957 #endif
958         return My_Connections[Idx].rdatalen;
959 } /* Conn_RecvQ */
960
961
962 GLOBAL LONG
963 Conn_RecvMsg( CONN_ID Idx )
964 {
965         /* Anzahl empfangener Nachrichten liefern */
966
967         assert( Idx > NONE );
968         return My_Connections[Idx].msg_in;
969 } /* Conn_RecvMsg */
970
971
972 GLOBAL LONG
973 Conn_RecvBytes( CONN_ID Idx )
974 {
975         /* Anzahl empfangener Bytes (unkomprimiert) liefern */
976
977         assert( Idx > NONE );
978         return My_Connections[Idx].bytes_in;
979 } /* Conn_RecvBytes */
980
981
982 GLOBAL VOID
983 Conn_ResetWCounter( VOID )
984 {
985         WCounter = 0;
986 } /* Conn_ResetWCounter */
987
988
989 GLOBAL LONG
990 Conn_WCounter( VOID )
991 {
992         return WCounter;
993 } /* Conn_WCounter */
994
995
996 LOCAL BOOLEAN
997 Try_Write( CONN_ID Idx )
998 {
999         /* Versuchen, Daten aus dem Schreib-Puffer in den Socket zu
1000          * schreiben. TRUE wird geliefert, wenn entweder keine Daten
1001          * zum Versenden vorhanden sind oder erfolgreich bearbeitet
1002          * werden konnten. Im Fehlerfall wird FALSE geliefert und
1003          * die Verbindung geschlossen. */
1004
1005         fd_set write_socket;
1006         struct timeval tv;
1007
1008         assert( Idx > NONE );
1009         assert( My_Connections[Idx].sock > NONE );
1010
1011         /* sind ueberhaupt Daten vorhanden? */
1012 #ifdef USE_ZLIB
1013         if(( ! My_Connections[Idx].wdatalen > 0 ) && ( ! My_Connections[Idx].zip.wdatalen )) return TRUE;
1014 #else
1015         if( ! My_Connections[Idx].wdatalen > 0 ) return TRUE;
1016 #endif
1017
1018         /* Timeout initialisieren: 0 Sekunden, also nicht blockieren */
1019         tv.tv_sec = 0; tv.tv_usec = 0;
1020
1021         FD_ZERO( &write_socket );
1022         FD_SET( My_Connections[Idx].sock, &write_socket );
1023         if( select( My_Connections[Idx].sock + 1, NULL, &write_socket, NULL, &tv ) == -1 )
1024         {
1025                 /* Fehler! */
1026                 if( errno != EINTR )
1027                 {
1028                         Log( LOG_ALERT, "Try_Write(): select() failed: %s (con=%d, sock=%d)!", strerror( errno ), Idx, My_Connections[Idx].sock );
1029                         Conn_Close( Idx, "Server error!", NULL, FALSE );
1030                         return FALSE;
1031                 }
1032         }
1033
1034         if( FD_ISSET( My_Connections[Idx].sock, &write_socket )) return Handle_Write( Idx );
1035         else return TRUE;
1036 } /* Try_Write */
1037
1038
1039 LOCAL VOID
1040 Handle_Read( INT Sock )
1041 {
1042         /* Aktivitaet auf einem Socket verarbeiten:
1043          *  - neue Clients annehmen,
1044          *  - Daten von Clients verarbeiten,
1045          *  - Resolver-Rueckmeldungen annehmen. */
1046
1047         CONN_ID idx;
1048
1049         assert( Sock > NONE );
1050
1051         if( FD_ISSET( Sock, &My_Listeners ))
1052         {
1053                 /* es ist einer unserer Listener-Sockets: es soll
1054                  * also eine neue Verbindung aufgebaut werden. */
1055
1056                 New_Connection( Sock );
1057         }
1058         else if( FD_ISSET( Sock, &Resolver_FDs ))
1059         {
1060                 /* Rueckmeldung von einem Resolver Sub-Prozess */
1061
1062                 Read_Resolver_Result( Sock );
1063         }
1064         else
1065         {
1066                 /* Ein Client Socket: entweder ein User oder Server */
1067
1068                 idx = Socket2Index( Sock );
1069                 if( idx > NONE ) Read_Request( idx );
1070         }
1071 } /* Handle_Read */
1072
1073
1074 LOCAL BOOLEAN
1075 Handle_Write( CONN_ID Idx )
1076 {
1077         /* Daten aus Schreibpuffer versenden bzw. Connection aufbauen */
1078
1079         INT len, res, err;
1080
1081         assert( Idx > NONE );
1082         assert( My_Connections[Idx].sock > NONE );
1083
1084         if( FD_ISSET( My_Connections[Idx].sock, &My_Connects ))
1085         {
1086                 /* es soll nichts geschrieben werden, sondern ein
1087                  * connect() hat ein Ergebnis geliefert */
1088
1089                 FD_CLR( My_Connections[Idx].sock, &My_Connects );
1090
1091                 /* Ergebnis des connect() ermitteln */
1092                 len = sizeof( err );
1093                 res = getsockopt( My_Connections[Idx].sock, SOL_SOCKET, SO_ERROR, &err, &len );
1094                 assert( len == sizeof( err ));
1095
1096                 /* Fehler aufgetreten? */
1097                 if(( res != 0 ) || ( err != 0 ))
1098                 {
1099                         /* Fehler! */
1100                         if( res != 0 ) Log( LOG_CRIT, "getsockopt (connection %d): %s!", Idx, strerror( errno ));
1101                         else Log( LOG_CRIT, "Can't connect socket to \"%s:%d\" (connection %d): %s!", My_Connections[Idx].host, Conf_Server[My_Connections[Idx].our_server].port, Idx, strerror( err ));
1102
1103                         /* Socket etc. pp. aufraeumen */
1104                         FD_CLR( My_Connections[Idx].sock, &My_Sockets );
1105                         close( My_Connections[Idx].sock );
1106                         Init_Conn_Struct( Idx );
1107
1108                         /* Bei Server-Verbindungen lasttry-Zeitpunkt auf "jetzt" setzen */
1109                         Conf_Server[My_Connections[Idx].our_server].lasttry = time( NULL );
1110
1111                         return FALSE;
1112                 }
1113                 Log( LOG_DEBUG, "Connection %d with \"%s:%d\" established, now sendig PASS and SERVER ...", Idx, My_Connections[Idx].host, Conf_Server[My_Connections[Idx].our_server].port );
1114
1115                 /* PASS und SERVER verschicken */
1116                 Conn_WriteStr( Idx, "PASS %s %s", Conf_Server[My_Connections[Idx].our_server].pwd_out, NGIRCd_ProtoID );
1117                 return Conn_WriteStr( Idx, "SERVER %s :%s", Conf_ServerName, Conf_ServerInfo );
1118         }
1119
1120 #ifdef USE_ZLIB
1121         /* Schreibpuffer leer, aber noch Daten im Kompressionsbuffer?
1122          * Dann muss dieser nun geflushed werden! */
1123         if( My_Connections[Idx].wdatalen == 0 ) Zip_Flush( Idx );
1124 #endif
1125
1126         assert( My_Connections[Idx].wdatalen > 0 );
1127
1128         /* Daten schreiben */
1129         len = send( My_Connections[Idx].sock, My_Connections[Idx].wbuf, My_Connections[Idx].wdatalen, 0 );
1130         if( len < 0 )
1131         {
1132                 /* Operation haette Socket "nur" blockiert ... */
1133                 if( errno == EAGAIN ) return TRUE;
1134
1135                 /* Oops, ein Fehler! */
1136                 Log( LOG_ERR, "Write error on connection %d (socket %d): %s!", Idx, My_Connections[Idx].sock, strerror( errno ));
1137                 Conn_Close( Idx, "Write error!", NULL, FALSE );
1138                 return FALSE;
1139         }
1140
1141         /* Puffer anpassen */
1142         My_Connections[Idx].wdatalen -= len;
1143         memmove( My_Connections[Idx].wbuf, My_Connections[Idx].wbuf + len, My_Connections[Idx].wdatalen );
1144
1145         return TRUE;
1146 } /* Handle_Write */
1147
1148
1149 LOCAL VOID
1150 New_Connection( INT Sock )
1151 {
1152         /* Neue Client-Verbindung von Listen-Socket annehmen und
1153          * CLIENT-Struktur anlegen. */
1154
1155         struct sockaddr_in new_addr;
1156         INT new_sock, new_sock_len;
1157         RES_STAT *s;
1158         CONN_ID idx;
1159         CLIENT *c;
1160         POINTER *ptr;
1161         LONG new_size;
1162
1163         assert( Sock > NONE );
1164
1165         /* Connection auf Listen-Socket annehmen */
1166         new_sock_len = sizeof( new_addr );
1167         new_sock = accept( Sock, (struct sockaddr *)&new_addr, (socklen_t *)&new_sock_len );
1168         if( new_sock < 0 )
1169         {
1170                 Log( LOG_CRIT, "Can't accept connection: %s!", strerror( errno ));
1171                 return;
1172         }
1173
1174         /* Socket initialisieren */
1175         Init_Socket( new_sock );
1176
1177         /* Freie Connection-Struktur suchen */
1178         for( idx = 0; idx < Pool_Size; idx++ ) if( My_Connections[idx].sock == NONE ) break;
1179         if( idx >= Pool_Size )
1180         {
1181                 new_size = Pool_Size + CONNECTION_POOL;
1182                 
1183                 /* Im bisherigen Pool wurde keine freie Connection-Struktur mehr gefunden.
1184                  * Wenn erlaubt und moeglich muss nun der Pool vergroessert werden: */
1185                 
1186                 if( Conf_MaxConnections > 0 )
1187                 {
1188                         /* Es ist ein Limit konfiguriert */
1189                         if( Pool_Size >= Conf_MaxConnections )
1190                         {
1191                                 /* Mehr Verbindungen duerfen wir leider nicht mehr annehmen ... */
1192                                 Log( LOG_ALERT, "Can't accept connection: limit (%d) reached!", Pool_Size );
1193                                 close( new_sock );
1194                                 return;
1195                         }
1196                         if( new_size > Conf_MaxConnections ) new_size = Conf_MaxConnections;
1197                 }
1198                 
1199                 /* zunaechst realloc() versuchen; wenn das scheitert, malloc() versuchen
1200                  * und Daten ggf. "haendisch" umkopieren. (Haesslich! Eine wirklich
1201                  * dynamische Verwaltung waere wohl _deutlich_ besser ...) */
1202                 ptr = realloc( My_Connections, sizeof( CONNECTION ) * new_size );
1203                 if( ! ptr )
1204                 {
1205                         /* realloc() ist fehlgeschlagen. Nun malloc() probieren: */
1206                         ptr = malloc( sizeof( CONNECTION ) * new_size );
1207                         if( ! ptr )
1208                         {
1209                                 /* Offenbar steht kein weiterer Sepeicher zur Verfuegung :-( */
1210                                 Log( LOG_EMERG, "Can't allocate memory! [New_Connection]" );
1211                                 close( new_sock );
1212                                 return;
1213                         }
1214                         
1215                         /* Struktur umkopieren ... */
1216                         memcpy( ptr, My_Connections, sizeof( CONNECTION ) * Pool_Size );
1217                         
1218                         Log( LOG_DEBUG, "Allocated new connection pool for %ld items (%ld bytes). [malloc()/memcpy()]", new_size, sizeof( CONNECTION ) * new_size );
1219                 }
1220                 else Log( LOG_DEBUG, "Allocated new connection pool for %ld items (%ld bytes). [realloc()]", new_size, sizeof( CONNECTION ) * new_size );
1221                 
1222                 /* Adjust pointer to new block */
1223                 My_Connections = ptr;
1224                 
1225                 /* Initialize new items */
1226                 for( idx = Pool_Size; idx < new_size; idx++ ) Init_Conn_Struct( idx );
1227                 idx = Pool_Size;
1228                 
1229                 /* Adjust new pool size */
1230                 Pool_Size = new_size;
1231         }
1232
1233         /* Client-Struktur initialisieren */
1234         c = Client_NewLocal( idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWN, FALSE );
1235         if( ! c )
1236         {
1237                 Log( LOG_ALERT, "Can't accept connection: can't create client structure!" );
1238                 close( new_sock );
1239                 return;
1240         }
1241
1242         /* Verbindung registrieren */
1243         Init_Conn_Struct( idx );
1244         My_Connections[idx].sock = new_sock;
1245         My_Connections[idx].addr = new_addr;
1246
1247         /* Neuen Socket registrieren */
1248         FD_SET( new_sock, &My_Sockets );
1249         if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
1250
1251         Log( LOG_INFO, "Accepted connection %d from %s:%d on socket %d.", idx, inet_ntoa( new_addr.sin_addr ), ntohs( new_addr.sin_port), Sock );
1252
1253         /* Hostnamen ermitteln */
1254         strcpy( My_Connections[idx].host, inet_ntoa( new_addr.sin_addr ));
1255         Client_SetHostname( c, My_Connections[idx].host );
1256         s = Resolve_Addr( &new_addr );
1257         if( s )
1258         {
1259                 /* Sub-Prozess wurde asyncron gestartet */
1260                 My_Connections[idx].res_stat = s;
1261         }
1262         
1263         /* Penalty-Zeit setzen */
1264         Conn_SetPenalty( idx, 4 );
1265 } /* New_Connection */
1266
1267
1268 LOCAL CONN_ID
1269 Socket2Index( INT Sock )
1270 {
1271         /* zum Socket passende Connection suchen */
1272
1273         CONN_ID idx;
1274
1275         assert( Sock > NONE );
1276
1277         for( idx = 0; idx < Pool_Size; idx++ ) if( My_Connections[idx].sock == Sock ) break;
1278
1279         if( idx >= Pool_Size )
1280         {
1281                 /* die Connection wurde vermutlich (wegen eines
1282                  * Fehlers) bereits wieder abgebaut ... */
1283                 Log( LOG_DEBUG, "Socket2Index: can't get connection for socket %d!", Sock );
1284                 return NONE;
1285         }
1286         else return idx;
1287 } /* Socket2Index */
1288
1289
1290 LOCAL VOID
1291 Read_Request( CONN_ID Idx )
1292 {
1293         /* Daten von Socket einlesen und entsprechend behandeln.
1294          * Tritt ein Fehler auf, so wird der Socket geschlossen. */
1295
1296         INT len, bsize;
1297 #ifdef USE_ZLIB
1298         CLIENT *c;
1299 #endif
1300
1301         assert( Idx > NONE );
1302         assert( My_Connections[Idx].sock > NONE );
1303
1304         /* wenn noch nicht registriert: maximal mit ZREADBUFFER_LEN arbeiten,
1305          * ansonsten koennen Daten ggf. nicht umkopiert werden. */
1306         bsize = READBUFFER_LEN;
1307 #ifdef USE_ZLIB
1308         c = Client_GetFromConn( Idx );
1309         if(( Client_Type( c ) != CLIENT_USER ) && ( Client_Type( c ) != CLIENT_SERVER ) && ( Client_Type( c ) != CLIENT_SERVICE ) && ( bsize > ZREADBUFFER_LEN )) bsize = ZREADBUFFER_LEN;
1310 #endif
1311
1312 #ifdef USE_ZLIB
1313         if(( bsize - My_Connections[Idx].rdatalen - 1 < 1 ) || ( ZREADBUFFER_LEN - My_Connections[Idx].zip.rdatalen < 1 ))
1314 #else
1315         if( bsize - My_Connections[Idx].rdatalen - 1 < 1 )
1316 #endif
1317         {
1318                 /* Der Lesepuffer ist voll */
1319                 Log( LOG_ERR, "Read buffer overflow (connection %d): %d bytes!", Idx, My_Connections[Idx].rdatalen );
1320                 Conn_Close( Idx, "Read buffer overflow!", NULL, FALSE );
1321                 return;
1322         }
1323
1324 #ifdef USE_ZLIB
1325         if( My_Connections[Idx].options & CONN_ZIP )
1326         {
1327                 len = recv( My_Connections[Idx].sock, My_Connections[Idx].zip.rbuf + My_Connections[Idx].zip.rdatalen, ( ZREADBUFFER_LEN - My_Connections[Idx].zip.rdatalen ), 0 );
1328                 if( len > 0 ) My_Connections[Idx].zip.rdatalen += len;
1329         }
1330         else
1331 #endif
1332         {
1333                 len = recv( My_Connections[Idx].sock, My_Connections[Idx].rbuf + My_Connections[Idx].rdatalen, bsize - My_Connections[Idx].rdatalen - 1, 0 );
1334                 if( len > 0 ) My_Connections[Idx].rdatalen += len;
1335         }
1336
1337         if( len == 0 )
1338         {
1339                 /* Socket wurde geschlossen */
1340                 Log( LOG_INFO, "%s:%d (%s) is closing the connection ...", My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port), inet_ntoa( My_Connections[Idx].addr.sin_addr ));
1341                 Conn_Close( Idx, "Socket closed!", "Client closed connection", FALSE );
1342                 return;
1343         }
1344
1345         if( len < 0 )
1346         {
1347                 /* Operation haette Socket "nur" blockiert ... */
1348                 if( errno == EAGAIN ) return;
1349
1350                 /* Fehler beim Lesen */
1351                 Log( LOG_ERR, "Read error on connection %d (socket %d): %s!", Idx, My_Connections[Idx].sock, strerror( errno ));
1352                 Conn_Close( Idx, "Read error!", "Client closed connection", FALSE );
1353                 return;
1354         }
1355
1356         /* Connection-Statistik aktualisieren */
1357         My_Connections[Idx].bytes_in += len;
1358
1359         /* Timestamp aktualisieren */
1360         My_Connections[Idx].lastdata = time( NULL );
1361
1362         Handle_Buffer( Idx );
1363 } /* Read_Request */
1364
1365
1366 LOCAL BOOLEAN
1367 Handle_Buffer( CONN_ID Idx )
1368 {
1369         /* Daten im Lese-Puffer einer Verbindung verarbeiten.
1370          * Wurde ein Request verarbeitet, so wird TRUE geliefert,
1371          * ansonsten FALSE (auch bei Fehlern). */
1372
1373 #ifndef STRICT_RFC
1374         CHAR *ptr1, *ptr2;
1375 #endif
1376         CHAR *ptr;
1377         INT len, delta;
1378         BOOLEAN action, result;
1379 #ifdef USE_ZLIB
1380         BOOLEAN old_z;
1381 #endif
1382
1383         result = FALSE;
1384         do
1385         {
1386 #ifdef USE_ZLIB
1387                 /* ggf. noch unkomprimiete Daten weiter entpacken */
1388                 if( My_Connections[Idx].options & CONN_ZIP )
1389                 {
1390                         if( ! Unzip_Buffer( Idx )) return FALSE;
1391                 }
1392 #endif
1393         
1394                 if( My_Connections[Idx].rdatalen < 1 ) break;
1395
1396                 /* Eine komplette Anfrage muss mit CR+LF enden, vgl.
1397                  * RFC 2812. Haben wir eine? */
1398                 My_Connections[Idx].rbuf[My_Connections[Idx].rdatalen] = '\0';
1399                 ptr = strstr( My_Connections[Idx].rbuf, "\r\n" );
1400         
1401                 if( ptr ) delta = 2;
1402 #ifndef STRICT_RFC
1403                 else
1404                 {
1405                         /* Nicht RFC-konforme Anfrage mit nur CR oder LF? Leider
1406                          * machen soetwas viele Clients, u.a. "mIRC" :-( */
1407                         ptr1 = strchr( My_Connections[Idx].rbuf, '\r' );
1408                         ptr2 = strchr( My_Connections[Idx].rbuf, '\n' );
1409                         delta = 1;
1410                         if( ptr1 && ptr2 ) ptr = ptr1 > ptr2 ? ptr2 : ptr1;
1411                         else if( ptr1 ) ptr = ptr1;
1412                         else if( ptr2 ) ptr = ptr2;
1413                 }
1414 #endif
1415         
1416                 action = FALSE;
1417                 if( ptr )
1418                 {
1419                         /* Ende der Anfrage wurde gefunden */
1420                         *ptr = '\0';
1421                         len = ( ptr - My_Connections[Idx].rbuf ) + delta;
1422                         if( len > ( COMMAND_LEN - 1 ))
1423                         {
1424                                 /* Eine Anfrage darf(!) nicht laenger als 512 Zeichen
1425                                  * (incl. CR+LF!) werden; vgl. RFC 2812. Wenn soetwas
1426                                  * empfangen wird, wird der Client disconnectiert. */
1427                                 Log( LOG_ERR, "Request too long (connection %d): %d bytes (max. %d expected)!", Idx, My_Connections[Idx].rdatalen, COMMAND_LEN - 1 );
1428                                 Conn_Close( Idx, NULL, "Request too long", TRUE );
1429                                 return FALSE;
1430                         }
1431
1432 #ifdef USE_ZLIB
1433                         /* merken, ob Stream bereits komprimiert wird */
1434                         old_z = My_Connections[Idx].options & CONN_ZIP;
1435 #endif
1436
1437                         if( len > delta )
1438                         {
1439                                 /* Es wurde ein Request gelesen */
1440                                 My_Connections[Idx].msg_in++;
1441                                 if( ! Parse_Request( Idx, My_Connections[Idx].rbuf )) return FALSE;
1442                                 else action = TRUE;
1443                         }
1444
1445                         /* Puffer anpassen */
1446                         My_Connections[Idx].rdatalen -= len;
1447                         memmove( My_Connections[Idx].rbuf, My_Connections[Idx].rbuf + len, My_Connections[Idx].rdatalen );
1448
1449 #ifdef USE_ZLIB
1450                         if(( ! old_z ) && ( My_Connections[Idx].options & CONN_ZIP ) && ( My_Connections[Idx].rdatalen > 0 ))
1451                         {
1452                                 /* Mit dem letzten Befehl wurde Socket-Kompression aktiviert.
1453                                  * Evtl. schon vom Socket gelesene Daten in den Unzip-Puffer
1454                                  * umkopieren, damit diese nun zunaechst entkomprimiert werden */
1455                                 {
1456                                         if( My_Connections[Idx].rdatalen > ZREADBUFFER_LEN )
1457                                         {
1458                                                 /* Hupsa! Soviel Platz haben wir aber gar nicht! */
1459                                                 Log( LOG_ALERT, "Can't move read buffer: No space left in unzip buffer (need %d bytes)!", My_Connections[Idx].rdatalen );
1460                                                 return FALSE;
1461                                         }
1462                                         memcpy( My_Connections[Idx].zip.rbuf, My_Connections[Idx].rbuf, My_Connections[Idx].rdatalen );
1463                                         My_Connections[Idx].zip.rdatalen = My_Connections[Idx].rdatalen;
1464                                         My_Connections[Idx].rdatalen = 0;
1465                                         Log( LOG_DEBUG, "Moved already received data (%d bytes) to uncompression buffer.", My_Connections[Idx].zip.rdatalen );
1466                                 }
1467                         }
1468 #endif
1469                 }
1470                 
1471                 if( action ) result = TRUE;
1472         } while( action );
1473         
1474         return result;
1475 } /* Handle_Buffer */
1476
1477
1478 LOCAL VOID
1479 Check_Connections( VOID )
1480 {
1481         /* Pruefen, ob Verbindungen noch "alive" sind. Ist dies
1482          * nicht der Fall, zunaechst PING-PONG spielen und, wenn
1483          * auch das nicht "hilft", Client disconnectieren. */
1484
1485         CLIENT *c;
1486         LONG i;
1487
1488         for( i = 0; i < Pool_Size; i++ )
1489         {
1490                 if( My_Connections[i].sock == NONE ) continue;
1491
1492                 c = Client_GetFromConn( i );
1493                 if( c && (( Client_Type( c ) == CLIENT_USER ) || ( Client_Type( c ) == CLIENT_SERVER ) || ( Client_Type( c ) == CLIENT_SERVICE )))
1494                 {
1495                         /* verbundener User, Server oder Service */
1496                         if( My_Connections[i].lastping > My_Connections[i].lastdata )
1497                         {
1498                                 /* es wurde bereits ein PING gesendet */
1499                                 if( My_Connections[i].lastping < time( NULL ) - Conf_PongTimeout )
1500                                 {
1501                                         /* Timeout */
1502                                         Log( LOG_DEBUG, "Connection %d: Ping timeout: %d seconds.", i, Conf_PongTimeout );
1503                                         Conn_Close( i, NULL, "Ping timeout", TRUE );
1504                                 }
1505                         }
1506                         else if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
1507                         {
1508                                 /* es muss ein PING gesendet werden */
1509                                 Log( LOG_DEBUG, "Connection %d: sending PING ...", i );
1510                                 My_Connections[i].lastping = time( NULL );
1511                                 Conn_WriteStr( i, "PING :%s", Client_ID( Client_ThisServer( )));
1512                         }
1513                 }
1514                 else
1515                 {
1516                         /* noch nicht vollstaendig aufgebaute Verbindung */
1517                         if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
1518                         {
1519                                 /* Timeout */
1520                                 Log( LOG_DEBUG, "Connection %d timed out ...", i );
1521                                 Conn_Close( i, NULL, "Timeout", FALSE );
1522                         }
1523                 }
1524         }
1525 } /* Check_Connections */
1526
1527
1528 LOCAL VOID
1529 Check_Servers( VOID )
1530 {
1531         /* Pruefen, ob Server-Verbindungen aufgebaut werden
1532          * muessen bzw. koennen */
1533
1534         RES_STAT *s;
1535         LONG idx, n;
1536         INT i;
1537
1538         /* Wenn "Passive-Mode" aktiv: nicht verbinden */
1539         if( NGIRCd_Passive ) return;
1540
1541         for( i = 0; i < Conf_Server_Count; i++ )
1542         {
1543                 /* Ist ein Hostname und Port definiert? */
1544                 if(( ! Conf_Server[i].host[0] ) || ( ! Conf_Server[i].port > 0 )) continue;
1545
1546                 /* Haben wir schon eine Verbindung? */
1547                 for( n = 0; n < Pool_Size; n++ )
1548                 {
1549                         if( My_Connections[n].sock == NONE ) continue;
1550                         
1551                         /* Verbindung zu diesem Server? */
1552                         if( My_Connections[n].our_server == i )
1553                         {
1554                                 /* Komplett aufgebaute Verbindung? */
1555                                 if( My_Connections[n].sock > NONE ) break;
1556
1557                                 /* IP schon aufgeloest? */
1558                                 if( My_Connections[n].res_stat == NULL ) New_Server( i, n );
1559                         }
1560
1561                         /* Verbindung in dieser Server-Gruppe? */
1562                         if(( My_Connections[n].our_server != NONE ) && ( Conf_Server[i].group != NONE ))
1563                         {
1564                                 if( Conf_Server[My_Connections[n].our_server].group == Conf_Server[i].group ) break;
1565                         }
1566                 }
1567                 if( n < Pool_Size ) continue;
1568
1569                 /* Wann war der letzte Connect-Versuch? */
1570                 if( Conf_Server[i].lasttry > time( NULL ) - Conf_ConnectRetry ) continue;
1571
1572                 /* Okay, Verbindungsaufbau versuchen */
1573                 Conf_Server[i].lasttry = time( NULL );
1574
1575                 /* Freie Connection-Struktur suschen */
1576                 for( idx = 0; idx < Pool_Size; idx++ ) if( My_Connections[idx].sock == NONE ) break;
1577                 if( idx >= Pool_Size )
1578                 {
1579                         Log( LOG_ALERT, "Can't establist server connection: connection limit reached (%d)!", Pool_Size );
1580                         return;
1581                 }
1582                 Log( LOG_DEBUG, "Preparing connection %d for \"%s\" ...", idx, Conf_Server[i].host );
1583
1584                 /* Verbindungs-Struktur initialisieren */
1585                 Init_Conn_Struct( idx );
1586                 My_Connections[idx].sock = SERVER_WAIT;
1587                 My_Connections[idx].our_server = i;
1588
1589                 /* Hostnamen in IP aufloesen (Default bzw. im Fehlerfall: versuchen, den
1590                  * konfigurierten Text direkt als IP-Adresse zu verwenden ... */
1591                 strcpy( Conf_Server[My_Connections[idx].our_server].ip, Conf_Server[i].host );
1592                 strcpy( My_Connections[idx].host, Conf_Server[i].host );
1593                 s = Resolve_Name( Conf_Server[i].host );
1594                 if( s )
1595                 {
1596                         /* Sub-Prozess wurde asyncron gestartet */
1597                         My_Connections[idx].res_stat = s;
1598                 }
1599         }
1600 } /* Check_Servers */
1601
1602
1603 LOCAL VOID
1604 New_Server( INT Server, CONN_ID Idx )
1605 {
1606         /* Neue Server-Verbindung aufbauen */
1607
1608         struct sockaddr_in new_addr;
1609         struct in_addr inaddr;
1610         INT res, new_sock;
1611         CLIENT *c;
1612
1613         assert( Server > NONE );
1614         assert( Idx > NONE );
1615
1616         /* Wurde eine gueltige IP-Adresse gefunden? */
1617         if( ! Conf_Server[Server].ip[0] )
1618         {
1619                 /* Nein. Verbindung wieder freigeben: */
1620                 Init_Conn_Struct( Idx );
1621                 Log( LOG_ERR, "Can't connect to \"%s\" (connection %d): ip address unknown!", Conf_Server[Server].host, Idx );
1622                 return;
1623         }
1624
1625         Log( LOG_INFO, "Establishing connection to \"%s\", %s, port %d (connection %d) ... ", Conf_Server[Server].host, Conf_Server[Server].ip, Conf_Server[Server].port, Idx );
1626
1627 #ifdef HAVE_INET_ATON
1628         if( inet_aton( Conf_Server[Server].ip, &inaddr ) == 0 )
1629 #else
1630         memset( &inaddr, 0, sizeof( inaddr ));
1631         inaddr.s_addr = inet_addr( Conf_Server[Server].ip );
1632         if( inaddr.s_addr == (unsigned)-1 )
1633 #endif
1634         {
1635                 /* Konnte Adresse nicht konvertieren */
1636                 Init_Conn_Struct( Idx );
1637                 Log( LOG_ERR, "Can't connect to \"%s\" (connection %d): can't convert ip address %s!", Conf_Server[Server].host, Idx, Conf_Server[Server].ip );
1638                 return;
1639         }
1640
1641         memset( &new_addr, 0, sizeof( new_addr ));
1642         new_addr.sin_family = AF_INET;
1643         new_addr.sin_addr = inaddr;
1644         new_addr.sin_port = htons( Conf_Server[Server].port );
1645
1646         new_sock = socket( PF_INET, SOCK_STREAM, 0 );
1647         if ( new_sock < 0 )
1648         {
1649                 Init_Conn_Struct( Idx );
1650                 Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
1651                 return;
1652         }
1653
1654         if( ! Init_Socket( new_sock )) return;
1655
1656         res = connect( new_sock, (struct sockaddr *)&new_addr, sizeof( new_addr ));
1657         if(( res != 0 ) && ( errno != EINPROGRESS ))
1658         {
1659                 Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
1660                 close( new_sock );
1661                 Init_Conn_Struct( Idx );
1662                 return;
1663         }
1664
1665         /* Client-Struktur initialisieren */
1666         c = Client_NewLocal( Idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWNSERVER, FALSE );
1667         if( ! c )
1668         {
1669                 close( new_sock );
1670                 Init_Conn_Struct( Idx );
1671                 Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
1672                 return;
1673         }
1674         Client_SetIntroducer( c, c );
1675         Client_SetToken( c, TOKEN_OUTBOUND );
1676
1677         /* Verbindung registrieren */
1678         My_Connections[Idx].sock = new_sock;
1679         My_Connections[Idx].addr = new_addr;
1680         strcpy( My_Connections[Idx].host, Conf_Server[Server].host );
1681
1682         /* Neuen Socket registrieren */
1683         FD_SET( new_sock, &My_Sockets );
1684         FD_SET( new_sock, &My_Connects );
1685         if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
1686         
1687         Log( LOG_DEBUG, "Registered new connection %d on socket %d.", Idx, My_Connections[Idx].sock );
1688 } /* New_Server */
1689
1690
1691 LOCAL VOID
1692 Init_Conn_Struct( LONG Idx )
1693 {
1694         /* Connection-Struktur initialisieren */
1695
1696         My_Connections[Idx].sock = NONE;
1697         My_Connections[Idx].res_stat = NULL;
1698         My_Connections[Idx].host[0] = '\0';
1699         My_Connections[Idx].rbuf[0] = '\0';
1700         My_Connections[Idx].rdatalen = 0;
1701         My_Connections[Idx].wbuf[0] = '\0';
1702         My_Connections[Idx].wdatalen = 0;
1703         My_Connections[Idx].our_server = NONE;
1704         My_Connections[Idx].starttime = time( NULL );
1705         My_Connections[Idx].lastdata = time( NULL );
1706         My_Connections[Idx].lastping = 0;
1707         My_Connections[Idx].lastprivmsg = time( NULL );
1708         My_Connections[Idx].delaytime = 0;
1709         My_Connections[Idx].bytes_in = 0;
1710         My_Connections[Idx].bytes_out = 0;
1711         My_Connections[Idx].msg_in = 0;
1712         My_Connections[Idx].msg_out = 0;
1713         My_Connections[Idx].flag = 0;
1714         My_Connections[Idx].options = 0;
1715
1716 #ifdef USE_ZLIB
1717         My_Connections[Idx].zip.rbuf[0] = '\0';
1718         My_Connections[Idx].zip.rdatalen = 0;
1719         My_Connections[Idx].zip.wbuf[0] = '\0';
1720         My_Connections[Idx].zip.wdatalen = 0;
1721         My_Connections[Idx].zip.bytes_in = 0;
1722         My_Connections[Idx].zip.bytes_out = 0;
1723 #endif
1724 } /* Init_Conn_Struct */
1725
1726
1727 LOCAL BOOLEAN
1728 Init_Socket( INT Sock )
1729 {
1730         /* Socket-Optionen setzen */
1731
1732         INT on = 1;
1733
1734 #ifdef O_NONBLOCK       /* A/UX kennt das nicht? */
1735         if( fcntl( Sock, F_SETFL, O_NONBLOCK ) != 0 )
1736         {
1737                 Log( LOG_CRIT, "Can't enable non-blocking mode: %s!", strerror( errno ));
1738                 close( Sock );
1739                 return FALSE;
1740         }
1741 #endif
1742         if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &on, (socklen_t)sizeof( on )) != 0)
1743         {
1744                 Log( LOG_ERR, "Can't set socket options: %s!", strerror( errno ));
1745                 /* dieser Fehler kann ignoriert werden. */
1746         }
1747
1748         return TRUE;
1749 } /* Init_Socket */
1750
1751
1752 LOCAL VOID
1753 Read_Resolver_Result( INT r_fd )
1754 {
1755         /* Ergebnis von Resolver Sub-Prozess aus Pipe lesen
1756          * und entsprechende Connection aktualisieren */
1757
1758         CHAR result[HOST_LEN];
1759         CLIENT *c;
1760         INT len, i;
1761
1762         FD_CLR( r_fd, &Resolver_FDs );
1763
1764         /* Anfrage vom Parent lesen */
1765         len = read( r_fd, result, HOST_LEN - 1 );
1766         if( len < 0 )
1767         {
1768                 /* Fehler beim Lesen aus der Pipe */
1769                 close( r_fd );
1770                 Log( LOG_CRIT, "Resolver: Can't read result: %s!", strerror( errno ));
1771                 return;
1772         }
1773         result[len] = '\0';
1774
1775         /* zugehoerige Connection suchen */
1776         for( i = 0; i < Pool_Size; i++ )
1777         {
1778                 if(( My_Connections[i].sock != NONE ) && ( My_Connections[i].res_stat ) && ( My_Connections[i].res_stat->pipe[0] == r_fd )) break;
1779         }
1780         if( i >= Pool_Size )
1781         {
1782                 /* Opsa! Keine passende Connection gefunden!? Vermutlich
1783                  * wurde sie schon wieder geschlossen. */
1784                 close( r_fd );
1785                 Log( LOG_DEBUG, "Resolver: Got result for unknown connection!?" );
1786                 return;
1787         }
1788
1789         Log( LOG_DEBUG, "Resolver: %s is \"%s\".", My_Connections[i].host, result );
1790         
1791         /* Aufraeumen */
1792         close( My_Connections[i].res_stat->pipe[0] );
1793         close( My_Connections[i].res_stat->pipe[1] );
1794         free( My_Connections[i].res_stat );
1795         My_Connections[i].res_stat = NULL;
1796
1797         if( My_Connections[i].sock > NONE )
1798         {
1799                 /* Eingehende Verbindung: Hostnamen setzen */
1800                 c = Client_GetFromConn( i );
1801                 assert( c != NULL );
1802                 strcpy( My_Connections[i].host, result );
1803                 Client_SetHostname( c, result );
1804         }
1805         else
1806         {
1807                 /* Ausgehende Verbindung (=Server): IP setzen */
1808                 assert( My_Connections[i].our_server > NONE );
1809                 strcpy( Conf_Server[My_Connections[i].our_server].ip, result );
1810         }
1811
1812         /* Penalty-Zeit zurueck setzen */
1813         Conn_ResetPenalty( i );
1814 } /* Read_Resolver_Result */
1815
1816
1817 #ifdef USE_ZLIB
1818
1819 LOCAL BOOLEAN
1820 Zip_Buffer( CONN_ID Idx, CHAR *Data, INT Len )
1821 {
1822         /* Daten zum Komprimieren im "Kompressions-Puffer" sammeln.
1823          * Es wird TRUE bei Erfolg, sonst FALSE geliefert. */
1824
1825         assert( Idx > NONE );
1826         assert( Data != NULL );
1827         assert( Len > 0 );
1828
1829         /* Ist noch Platz im Kompressions-Puffer? */
1830         if( ZWRITEBUFFER_LEN - My_Connections[Idx].zip.wdatalen < Len + 50 )
1831         {
1832                 /* Nein! Puffer zunaechst leeren ...*/
1833                 if( ! Zip_Flush( Idx )) return FALSE;
1834         }
1835
1836         /* Daten kopieren */
1837         memmove( My_Connections[Idx].zip.wbuf + My_Connections[Idx].zip.wdatalen, Data, Len );
1838         My_Connections[Idx].zip.wdatalen += Len;
1839
1840         return TRUE;
1841 } /* Zip_Buffer */
1842
1843
1844 LOCAL BOOLEAN
1845 Zip_Flush( CONN_ID Idx )
1846 {
1847         /* Daten komprimieren und in Schreibpuffer kopieren.
1848          * Es wird TRUE bei Erfolg, sonst FALSE geliefert. */
1849
1850         INT result, out_len;
1851         z_stream *out;
1852
1853         out = &My_Connections[Idx].zip.out;
1854
1855         out->next_in = My_Connections[Idx].zip.wbuf;
1856         out->avail_in = My_Connections[Idx].zip.wdatalen;
1857         out->next_out = My_Connections[Idx].wbuf + My_Connections[Idx].wdatalen;
1858         out->avail_out = WRITEBUFFER_LEN - My_Connections[Idx].wdatalen;
1859
1860         result = deflate( out, Z_SYNC_FLUSH );
1861         if(( result != Z_OK ) || ( out->avail_in > 0 ))
1862         {
1863                 Log( LOG_ALERT, "Compression error: code %d!?", result );
1864                 Conn_Close( Idx, "Compression error!", NULL, FALSE );
1865                 return FALSE;
1866         }
1867
1868         out_len = WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - out->avail_out;
1869         My_Connections[Idx].wdatalen += out_len;
1870         My_Connections[Idx].bytes_out += out_len;
1871         My_Connections[Idx].zip.bytes_out += My_Connections[Idx].zip.wdatalen;
1872         My_Connections[Idx].zip.wdatalen = 0;
1873         
1874         return TRUE;
1875 } /* Zip_Flush */
1876
1877
1878 LOCAL BOOLEAN
1879 Unzip_Buffer( CONN_ID Idx )
1880 {
1881         /* Daten entpacken und in Lesepuffer kopieren. Bei Fehlern
1882          * wird FALSE geliefert, ansonsten TRUE. Der Fall, dass keine
1883          * Daten mehr zu entpacken sind, ist _kein_ Fehler! */
1884
1885         INT result, in_len, out_len;
1886         z_stream *in;
1887
1888         assert( Idx > NONE );
1889
1890         if( My_Connections[Idx].zip.rdatalen <= 0 ) return TRUE;
1891
1892         in = &My_Connections[Idx].zip.in;
1893
1894         in->next_in = My_Connections[Idx].zip.rbuf;
1895         in->avail_in = My_Connections[Idx].zip.rdatalen;
1896         in->next_out = My_Connections[Idx].rbuf + My_Connections[Idx].rdatalen;
1897         in->avail_out = READBUFFER_LEN - My_Connections[Idx].rdatalen - 1;
1898
1899         result = inflate( in, Z_SYNC_FLUSH );
1900         if( result != Z_OK )
1901         {
1902                 Log( LOG_ALERT, "Decompression error: code %d (ni=%d, ai=%d, no=%d, ao=%d)!?", result, in->next_in, in->avail_in, in->next_out, in->avail_out );
1903                 Conn_Close( Idx, "Decompression error!", NULL, FALSE );
1904                 return FALSE;
1905         }
1906
1907         in_len = My_Connections[Idx].zip.rdatalen - in->avail_in;
1908         out_len = READBUFFER_LEN - My_Connections[Idx].rdatalen - 1 - in->avail_out;
1909         My_Connections[Idx].rdatalen += out_len;
1910
1911         if( in->avail_in > 0 )
1912         {
1913                 /* es konnten nicht alle Daten entpackt werden, vermutlich war
1914                  * im Ziel-Puffer kein Platz mehr. Umkopieren ... */
1915                 My_Connections[Idx].zip.rdatalen -= in_len;
1916                 memmove( My_Connections[Idx].zip.rbuf, My_Connections[Idx].zip.rbuf + in_len, My_Connections[Idx].zip.rdatalen );
1917         }
1918         else My_Connections[Idx].zip.rdatalen = 0;
1919         My_Connections[Idx].zip.bytes_in += out_len;
1920
1921         return TRUE;
1922 } /* Unzip_Buffer */
1923
1924
1925 #endif
1926
1927
1928 /* -eof- */