- ausgehende Verbindungen mit ID 0 konnten nicht aufgebaut werden ... :-/
[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  * 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 ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
11  *
12  * $Id: conn.c,v 1.83 2002/10/15 09:24:54 alex Exp $
13  *
14  * connect.h: Verwaltung aller Netz-Verbindungen ("connections")
15  */
16
17
18 #include "portab.h"
19
20 #include "imp.h"
21 #include <assert.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <string.h>
29 #include <sys/socket.h>
30 #include <sys/time.h>
31 #include <sys/types.h>
32 #include <time.h>
33 #include <netinet/in.h>
34
35 #ifdef HAVE_ARPA_INET_H
36 #include <arpa/inet.h>
37 #else
38 #define PF_INET AF_INET
39 #endif
40
41 #ifdef HAVE_STDINT_H
42 #include <stdint.h>                     /* u.a. fuer Mac OS X */
43 #endif
44
45 #include "exp.h"
46 #include "conn.h"
47
48 #include "imp.h"
49 #include "ngircd.h"
50 #include "client.h"
51 #include "resolve.h"
52 #include "conf.h"
53 #include "log.h"
54 #include "parse.h"
55 #include "tool.h"
56
57 #include "exp.h"
58
59
60 #define SERVER_WAIT (NONE - 1)
61
62
63 typedef struct _Connection
64 {
65         INT sock;                       /* Socket Handle */
66         struct sockaddr_in addr;        /* Adresse des Client */
67         RES_STAT *res_stat;             /* "Resolver-Status", s.o. */
68         CHAR host[HOST_LEN];            /* Hostname */
69         CHAR rbuf[READBUFFER_LEN];      /* Lesepuffer */
70         INT rdatalen;                   /* Laenge der Daten im Lesepuffer */
71         CHAR wbuf[WRITEBUFFER_LEN];     /* Schreibpuffer */
72         INT wdatalen;                   /* Laenge der Daten im Schreibpuffer */
73         INT our_server;                 /* wenn von uns zu connectender Server: ID */
74         time_t lastdata;                /* Letzte Aktivitaet */
75         time_t lastping;                /* Letzter PING */
76         time_t lastprivmsg;             /* Letzte PRIVMSG */
77         time_t delaytime;               /* Nicht beachten bis ("penalty") */
78         LONG bytes_in, bytes_out;       /* Counter fuer Statistik */
79 } CONNECTION;
80
81
82 LOCAL VOID Handle_Read PARAMS(( INT sock ));
83 LOCAL BOOLEAN Handle_Write PARAMS(( CONN_ID Idx ));
84 LOCAL VOID New_Connection PARAMS(( INT Sock ));
85 LOCAL CONN_ID Socket2Index PARAMS(( INT Sock ));
86 LOCAL VOID Read_Request PARAMS(( CONN_ID Idx ));
87 LOCAL BOOLEAN Try_Write PARAMS(( CONN_ID Idx ));
88 LOCAL VOID Handle_Buffer PARAMS(( CONN_ID Idx ));
89 LOCAL VOID Check_Connections PARAMS(( VOID ));
90 LOCAL VOID Check_Servers PARAMS(( VOID ));
91 LOCAL VOID Init_Conn_Struct PARAMS(( INT Idx ));
92 LOCAL BOOLEAN Init_Socket PARAMS(( INT Sock ));
93 LOCAL VOID New_Server PARAMS(( INT Server, CONN_ID Idx ));
94 LOCAL VOID Read_Resolver_Result PARAMS(( INT r_fd ));
95
96
97 LOCAL fd_set My_Listeners;
98 LOCAL fd_set My_Sockets;
99 LOCAL fd_set My_Connects;
100
101 LOCAL CONNECTION My_Connections[MAX_CONNECTIONS];
102
103
104 GLOBAL VOID
105 Conn_Init( VOID )
106 {
107         /* Modul initialisieren: statische Strukturen "ausnullen". */
108
109         CONN_ID i;
110
111         /* zu Beginn haben wir keine Verbindungen */
112         FD_ZERO( &My_Listeners );
113         FD_ZERO( &My_Sockets );
114         FD_ZERO( &My_Connects );
115
116         Conn_MaxFD = 0;
117
118         /* Connection-Struktur initialisieren */
119         for( i = 0; i < MAX_CONNECTIONS; i++ ) Init_Conn_Struct( i );
120 } /* Conn_Init */
121
122
123 GLOBAL VOID
124 Conn_Exit( VOID )
125 {
126         /* Modul abmelden: alle noch offenen Connections
127          * schliessen und freigeben. */
128
129         CONN_ID idx;
130         INT i;
131
132         /* Sockets schliessen */
133         Log( LOG_DEBUG, "Shutting down all connections ..." );
134         for( i = 0; i < Conn_MaxFD + 1; i++ )
135         {
136                 if( FD_ISSET( i, &My_Sockets ))
137                 {
138                         for( idx = 0; idx < MAX_CONNECTIONS; idx++ )
139                         {
140                                 if( My_Connections[idx].sock == i ) break;
141                         }
142                         if( FD_ISSET( i, &My_Listeners ))
143                         {
144                                 close( i );
145                                 Log( LOG_DEBUG, "Listening socket %d closed.", i );
146                         }
147                         else if( FD_ISSET( i, &My_Connects ))
148                         {
149                                 close( i );
150                                 Log( LOG_DEBUG, "Connection %d closed during creation (socket %d).", idx, i );
151                         }
152                         else if( idx < MAX_CONNECTIONS )
153                         {
154                                 if( NGIRCd_Restart ) Conn_Close( idx, NULL, "Server going down (restarting)", TRUE );
155                                 else Conn_Close( idx, NULL, "Server going down", TRUE );
156                         }
157                         else
158                         {
159                                 Log( LOG_WARNING, "Closing unknown connection %d ...", i );
160                                 close( i );
161                         }
162                 }
163         }
164 } /* Conn_Exit */
165
166
167 GLOBAL BOOLEAN
168 Conn_NewListener( CONST UINT Port )
169 {
170         /* Neuen Listen-Socket erzeugen: der Server wartet dann auf
171          * dem angegebenen Port auf Verbindungen. Kann der Listen-
172          * Socket nicht erteugt werden, so wird NULL geliefert.*/
173
174         struct sockaddr_in addr;
175         INT sock;
176
177         /* Server-"Listen"-Socket initialisieren */
178         memset( &addr, 0, sizeof( addr ));
179         addr.sin_family = AF_INET;
180         addr.sin_port = htons( Port );
181         addr.sin_addr.s_addr = htonl( INADDR_ANY );
182
183         /* Socket erzeugen */
184         sock = socket( PF_INET, SOCK_STREAM, 0);
185         if( sock < 0 )
186         {
187                 Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
188                 return FALSE;
189         }
190
191         if( ! Init_Socket( sock )) return FALSE;
192
193         /* an Port binden */
194         if( bind( sock, (struct sockaddr *)&addr, (socklen_t)sizeof( addr )) != 0 )
195         {
196                 Log( LOG_CRIT, "Can't bind socket: %s!", strerror( errno ));
197                 close( sock );
198                 return FALSE;
199         }
200
201         /* in "listen mode" gehen :-) */
202         if( listen( sock, 10 ) != 0 )
203         {
204                 Log( LOG_CRIT, "Can't listen on soecket: %s!", strerror( errno ));
205                 close( sock );
206                 return FALSE;
207         }
208
209         /* Neuen Listener in Strukturen einfuegen */
210         FD_SET( sock, &My_Listeners );
211         FD_SET( sock, &My_Sockets );
212
213         if( sock > Conn_MaxFD ) Conn_MaxFD = sock;
214
215         Log( LOG_INFO, "Now listening on port %d (socket %d).", Port, sock );
216
217         return TRUE;
218 } /* Conn_NewListener */
219
220
221 GLOBAL VOID
222 Conn_Handler( VOID )
223 {
224         /* "Hauptschleife": Aktive Verbindungen ueberwachen. Folgende Aktionen
225          * werden dabei durchgefuehrt, bis der Server terminieren oder neu
226          * starten soll:
227          *
228          *  - neue Verbindungen annehmen,
229          *  - Server-Verbindungen aufbauen,
230          *  - geschlossene Verbindungen loeschen,
231          *  - volle Schreibpuffer versuchen zu schreiben,
232          *  - volle Lesepuffer versuchen zu verarbeiten,
233          *  - Antworten von Resolver Sub-Prozessen annehmen.
234          */
235
236         fd_set read_sockets, write_sockets;
237         struct timeval tv;
238         time_t start, t;
239         INT i, idx;
240
241         start = time( NULL );
242         while(( ! NGIRCd_Quit ) && ( ! NGIRCd_Restart ))
243         {
244                 Check_Servers( );
245
246                 Check_Connections( );
247
248                 /* noch volle Lese-Buffer suchen */
249                 for( i = 0; i < MAX_CONNECTIONS; i++ )
250                 {
251                         if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].rdatalen > 0 ))
252                         {
253                                 /* Kann aus dem Buffer noch ein Befehl extrahiert werden? */
254                                 Handle_Buffer( i );
255                         }
256                 }
257
258                 /* noch volle Schreib-Puffer suchen */
259                 FD_ZERO( &write_sockets );
260                 for( i = 0; i < MAX_CONNECTIONS; i++ )
261                 {
262                         if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].wdatalen > 0 ))
263                         {
264                                 /* Socket der Verbindung in Set aufnehmen */
265                                 FD_SET( My_Connections[i].sock, &write_sockets );
266                         }
267                 }
268                 /* Sockets mit im Aufbau befindlichen ausgehenden Verbindungen suchen */
269                 for( i = 0; i < MAX_CONNECTIONS; i++ )
270                 {
271                         if(( My_Connections[i].sock > NONE ) && ( FD_ISSET( My_Connections[i].sock, &My_Connects ))) FD_SET( My_Connections[i].sock, &write_sockets );
272                 }
273
274                 /* von welchen Sockets koennte gelesen werden? */
275                 t = time( NULL );
276                 read_sockets = My_Sockets;
277                 for( i = 0; i < MAX_CONNECTIONS; i++ )
278                 {
279                         if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].host[0] == '\0' ))
280                         {
281                                 /* Hier muss noch auf den Resolver Sub-Prozess gewartet werden */
282                                 FD_CLR( My_Connections[i].sock, &read_sockets );
283                         }
284                         if(( My_Connections[i].sock > NONE ) && ( FD_ISSET( My_Connections[i].sock, &My_Connects )))
285                         {
286                                 /* Hier laeuft noch ein asyncrones connect() */
287                                 FD_CLR( My_Connections[i].sock, &read_sockets );
288                         }
289                         if( My_Connections[i].delaytime > t )
290                         {
291                                 /* Fuer die Verbindung ist eine "Penalty-Zeit" gesetzt */
292                                 FD_CLR( My_Connections[i].sock, &read_sockets );
293                                 FD_CLR( My_Connections[i].sock, &write_sockets );
294                         }
295                 }
296                 for( i = 0; i < Conn_MaxFD + 1; i++ )
297                 {
298                         /* Pipes von Resolver Sub-Prozessen aufnehmen */
299                         if( FD_ISSET( i, &Resolver_FDs ))
300                         {
301                                 FD_SET( i, &read_sockets );
302                         }
303                 }
304
305                 /* Timeout initialisieren */
306                 tv.tv_sec = 1;
307                 tv.tv_usec = 0;
308                 
309                 /* Auf Aktivitaet warten */
310                 i = select( Conn_MaxFD + 1, &read_sockets, &write_sockets, NULL, &tv );
311                 if( i == 0 )
312                 {
313                         /* keine Veraenderung an den Sockets */
314                         continue;
315                 }
316                 if( i == -1 )
317                 {
318                         /* Fehler (z.B. Interrupt) */
319                         if( errno != EINTR )
320                         {
321                                 Log( LOG_EMERG, "Conn_Handler(): select(): %s!", strerror( errno ));
322                                 Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE );
323                                 exit( 1 );
324                         }
325                         continue;
326                 }
327
328                 /* Koennen Daten geschrieben werden? */
329                 for( i = 0; i < Conn_MaxFD + 1; i++ )
330                 {
331                         if( ! FD_ISSET( i, &write_sockets )) continue;
332
333                         /* Es kann geschrieben werden ... */
334                         idx = Socket2Index( i );
335                         if( idx == NONE ) continue;
336                         
337                         if( ! Handle_Write( idx ))
338                         {
339                                 /* Fehler beim Schreiben! Diesen Socket nun
340                                  * auch aus dem Read-Set entfernen: */
341                                 FD_CLR( i, &read_sockets );
342                         }
343                 }
344
345                 /* Daten zum Lesen vorhanden? */
346                 for( i = 0; i < Conn_MaxFD + 1; i++ )
347                 {
348                         if( FD_ISSET( i, &read_sockets )) Handle_Read( i );
349                 }
350         }
351 } /* Conn_Handler */
352
353
354 #ifdef PROTOTYPES
355 GLOBAL BOOLEAN
356 Conn_WriteStr( CONN_ID Idx, CHAR *Format, ... )
357 #else
358 GLOBAL BOOLEAN
359 Conn_WriteStr( Idx, Format, va_alist )
360 CONN_ID Idx;
361 CHAR *Format;
362 va_dcl
363 #endif
364 {
365         /* String in Socket schreiben. CR+LF wird von dieser Funktion
366          * automatisch angehaengt. Im Fehlerfall wird dir Verbindung
367          * getrennt und FALSE geliefert. */
368
369         CHAR buffer[COMMAND_LEN];
370         BOOLEAN ok;
371         va_list ap;
372
373         assert( Idx >= 0 );
374         assert( Format != NULL );
375
376 #ifdef PROTOTYPES
377         va_start( ap, Format );
378 #else
379         va_start( ap );
380 #endif
381         if( vsnprintf( buffer, COMMAND_LEN - 2, Format, ap ) == COMMAND_LEN - 2 )
382         {
383                 Log( LOG_CRIT, "Text too long to send (connection %d)!", Idx );
384                 Conn_Close( Idx, "Text too long to send!", NULL, FALSE );
385                 return FALSE;
386         }
387
388 #ifdef SNIFFER
389         if( NGIRCd_Sniffer ) Log( LOG_DEBUG, " -> connection %d: '%s'.", Idx, buffer );
390 #endif
391
392         strcat( buffer, "\r\n" );
393         ok = Conn_Write( Idx, buffer, strlen( buffer ));
394
395         va_end( ap );
396         return ok;
397 } /* Conn_WriteStr */
398
399
400 GLOBAL BOOLEAN
401 Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
402 {
403         /* Daten in Socket schreiben. Bei "fatalen" Fehlern wird
404          * der Client disconnectiert und FALSE geliefert. */
405
406         assert( Idx >= 0 );
407         assert( Data != NULL );
408         assert( Len > 0 );
409
410         /* Ist der entsprechende Socket ueberhaupt noch offen?
411          * In einem "Handler-Durchlauf" kann es passieren, dass
412          * dem nicht mehr so ist, wenn einer von mehreren
413          * Conn_Write()'s fehlgeschlagen ist. In diesem Fall
414          * wird hier einfach ein Fehler geliefert. */
415         if( My_Connections[Idx].sock <= NONE )
416         {
417                 Log( LOG_DEBUG, "Skipped write on closed socket (connection %d).", Idx );
418                 return FALSE;
419         }
420
421         /* pruefen, ob Daten im Schreibpuffer sind. Wenn ja, zunaechst
422          * pruefen, ob diese gesendet werden koennen */
423         if( My_Connections[Idx].wdatalen > 0 )
424         {
425                 if( ! Try_Write( Idx )) return FALSE;
426         }
427
428         /* pruefen, ob im Schreibpuffer genuegend Platz ist */
429         if( WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - Len <= 0 )
430         {
431                 /* der Puffer ist dummerweise voll ... */
432                 Log( LOG_NOTICE, "Write buffer overflow (connection %d)!", Idx );
433                 Conn_Close( Idx, "Write buffer overflow!", NULL, FALSE );
434                 return FALSE;
435         }
436
437         /* Daten in Puffer kopieren */
438         memcpy( My_Connections[Idx].wbuf + My_Connections[Idx].wdatalen, Data, Len );
439         My_Connections[Idx].wdatalen += Len;
440
441         /* pruefen, on Daten vorhanden sind und geschrieben werden koennen */
442         if( My_Connections[Idx].wdatalen > 0 )
443         {
444                 if( ! Try_Write( Idx )) return FALSE;
445         }
446
447         return TRUE;
448 } /* Conn_Write */
449
450
451 GLOBAL VOID
452 Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
453 {
454         /* Verbindung schliessen. Evtl. noch von Resolver
455          * Sub-Prozessen offene Pipes werden geschlossen. */
456
457         CLIENT *c;
458
459         assert( Idx >= 0 );
460         assert( My_Connections[Idx].sock > NONE );
461
462         c = Client_GetFromConn( Idx );
463
464         if( InformClient )
465         {
466                 /* Statistik an Client melden, wenn User */
467                 if(( c != NULL ) && ( Client_Type( c ) == CLIENT_USER ))
468                 {
469                         Conn_WriteStr( Idx, "NOTICE %s :%sConnection statistics: %.1f kb received, %.1f kb sent.", Client_ThisServer( ), NOTICE_TXTPREFIX, (DOUBLE)My_Connections[Idx].bytes_in / 1024,  (DOUBLE)My_Connections[Idx].bytes_out / 1024 );
470                 }
471
472                 /* ERROR an Client schicken (von RFC so vorgesehen!) */
473                 if( FwdMsg ) Conn_WriteStr( Idx, "ERROR :%s", FwdMsg );
474                 else Conn_WriteStr( Idx, "ERROR :Closing connection." );
475                 if( My_Connections[Idx].sock == NONE ) return;
476         }
477
478         if( close( My_Connections[Idx].sock ) != 0 )
479         {
480                 Log( LOG_ERR, "Error closing connection %d (socket %d) with %s:%d - %s!", Idx, My_Connections[Idx].sock, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port), strerror( errno ));
481         }
482         else
483         {
484                 Log( LOG_INFO, "Connection %d (socket %d) with %s:%d closed.", Idx, My_Connections[Idx].sock, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port ));
485         }
486         
487         /* Socket als "ungueltig" markieren */
488         FD_CLR( My_Connections[Idx].sock, &My_Sockets );
489         FD_CLR( My_Connections[Idx].sock, &My_Connects );
490         My_Connections[Idx].sock = NONE;
491
492         if( c ) Client_Destroy( c, LogMsg, FwdMsg, TRUE );
493
494         if( My_Connections[Idx].res_stat )
495         {
496                 /* Resolver-Strukturen freigeben, wenn noch nicht geschehen */
497                 FD_CLR( My_Connections[Idx].res_stat->pipe[0], &Resolver_FDs );
498                 close( My_Connections[Idx].res_stat->pipe[0] );
499                 close( My_Connections[Idx].res_stat->pipe[1] );
500                 free( My_Connections[Idx].res_stat );
501         }
502
503         /* Startzeit des naechsten Connect-Versuchs modifizieren? */
504         if(( My_Connections[Idx].our_server >= 0 ) && ( Conf_Server[My_Connections[Idx].our_server].lasttry <  time( NULL ) - Conf_ConnectRetry ))
505         {
506                 /* Okay, die Verbindung stand schon "genuegend lange":
507                  * lasttry-Zeitpunkt so setzen, dass der naechste
508                  * Verbindungsversuch in RECONNECT_DELAY Sekunden
509                  * gestartet wird. */
510                 Conf_Server[My_Connections[Idx].our_server].lasttry = time( NULL ) - Conf_ConnectRetry + RECONNECT_DELAY;
511         }
512
513         /* Connection-Struktur loeschen (=freigeben) */
514         Init_Conn_Struct( Idx );
515 } /* Conn_Close */
516
517
518 GLOBAL VOID
519 Conn_UpdateIdle( CONN_ID Idx )
520 {
521         /* Idle-Timer zuruecksetzen */
522
523         assert( Idx >= 0 );
524         My_Connections[Idx].lastprivmsg = time( NULL );
525 }
526
527
528 GLOBAL time_t
529 Conn_GetIdle( CONN_ID Idx )
530 {
531         /* Idle-Time einer Verbindung liefern (in Sekunden) */
532
533         assert( Idx >= 0 );
534         return time( NULL ) - My_Connections[Idx].lastprivmsg;
535 } /* Conn_GetIdle */
536
537
538 GLOBAL time_t
539 Conn_LastPing( CONN_ID Idx )
540 {
541         /* Zeitpunkt des letzten PING liefern */
542
543         assert( Idx >= 0 );
544         return My_Connections[Idx].lastping;
545 } /* Conn_LastPing */
546
547
548 GLOBAL VOID
549 Conn_SetPenalty( CONN_ID Idx, time_t Seconds )
550 {
551         /* Penalty-Delay fuer eine Verbindung (in Sekunden) setzen;
552          * waehrend dieser Zeit wird der entsprechende Socket vom Server
553          * bei Lese-Operationen komplett ignoriert. Der Delay kann mit
554          * dieser Funktion nur erhoeht, nicht aber verringert werden. */
555         
556         time_t t;
557         
558         assert( Idx >= 0 );
559         assert( Seconds >= 0 );
560         
561         t = time( NULL ) + Seconds;
562         if( t > My_Connections[Idx].delaytime ) My_Connections[Idx].delaytime = t;
563 } /* Conn_SetPenalty */
564
565
566 GLOBAL VOID
567 Conn_ResetPenalty( CONN_ID Idx )
568 {
569         assert( Idx >= 0 );
570         My_Connections[Idx].delaytime = 0;
571 } /* Conn_ResetPenalty */
572
573
574 LOCAL BOOLEAN
575 Try_Write( CONN_ID Idx )
576 {
577         /* Versuchen, Daten aus dem Schreib-Puffer in den
578          * Socket zu schreiben. */
579
580         fd_set write_socket;
581
582         assert( Idx >= 0 );
583         assert( My_Connections[Idx].sock > NONE );
584         assert( My_Connections[Idx].wdatalen > 0 );
585
586         FD_ZERO( &write_socket );
587         FD_SET( My_Connections[Idx].sock, &write_socket );
588         if( select( My_Connections[Idx].sock + 1, NULL, &write_socket, NULL, 0 ) == -1 )
589         {
590                 /* Fehler! */
591                 if( errno != EINTR )
592                 {
593                         Log( LOG_ALERT, "Try_Write(): select() failed: %s (con=%d, sock=%d)!", strerror( errno ), Idx, My_Connections[Idx].sock );
594                         Conn_Close( Idx, "Server error!", NULL, FALSE );
595                         return FALSE;
596                 }
597         }
598
599         if( FD_ISSET( My_Connections[Idx].sock, &write_socket )) return Handle_Write( Idx );
600         else return TRUE;
601 } /* Try_Write */
602
603
604 LOCAL VOID
605 Handle_Read( INT Sock )
606 {
607         /* Aktivitaet auf einem Socket verarbeiten:
608          *  - neue Clients annehmen,
609          *  - Daten von Clients verarbeiten,
610          *  - Resolver-Rueckmeldungen annehmen. */
611
612         CONN_ID idx;
613
614         assert( Sock >= 0 );
615
616         if( FD_ISSET( Sock, &My_Listeners ))
617         {
618                 /* es ist einer unserer Listener-Sockets: es soll
619                  * also eine neue Verbindung aufgebaut werden. */
620
621                 New_Connection( Sock );
622         }
623         else if( FD_ISSET( Sock, &Resolver_FDs ))
624         {
625                 /* Rueckmeldung von einem Resolver Sub-Prozess */
626
627                 Read_Resolver_Result( Sock );
628         }
629         else
630         {
631                 /* Ein Client Socket: entweder ein User oder Server */
632
633                 idx = Socket2Index( Sock );
634                 if( idx > NONE ) Read_Request( idx );
635         }
636 } /* Handle_Read */
637
638
639 LOCAL BOOLEAN
640 Handle_Write( CONN_ID Idx )
641 {
642         /* Daten aus Schreibpuffer versenden bzw. Connection aufbauen */
643
644         INT len, res, err;
645
646         assert( Idx > NONE );
647         assert( My_Connections[Idx].sock > NONE );
648
649         if( FD_ISSET( My_Connections[Idx].sock, &My_Connects ))
650         {
651                 /* es soll nichts geschrieben werden, sondern ein
652                  * connect() hat ein Ergebnis geliefert */
653
654                 FD_CLR( My_Connections[Idx].sock, &My_Connects );
655
656                 /* Ergebnis des connect() ermitteln */
657                 len = sizeof( err );
658                 res = getsockopt( My_Connections[Idx].sock, SOL_SOCKET, SO_ERROR, &err, &len );
659                 assert( len == sizeof( err ));
660
661                 /* Fehler aufgetreten? */
662                 if(( res != 0 ) || ( err != 0 ))
663                 {
664                         /* Fehler! */
665                         if( res != 0 ) Log( LOG_CRIT, "getsockopt (connection %d): %s!", Idx, strerror( errno ));
666                         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 ));
667
668                         /* Socket etc. pp. aufraeumen */
669                         FD_CLR( My_Connections[Idx].sock, &My_Sockets );
670                         close( My_Connections[Idx].sock );
671                         Init_Conn_Struct( Idx );
672
673                         /* Bei Server-Verbindungen lasttry-Zeitpunkt auf "jetzt" setzen */
674                         Conf_Server[My_Connections[Idx].our_server].lasttry = time( NULL );
675
676                         return FALSE;
677                 }
678                 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 );
679
680                 /* PASS und SERVER verschicken */
681                 Conn_WriteStr( Idx, "PASS %s %s", Conf_Server[My_Connections[Idx].our_server].pwd, NGIRCd_ProtoID );
682                 return Conn_WriteStr( Idx, "SERVER %s :%s", Conf_ServerName, Conf_ServerInfo );
683         }
684
685         assert( My_Connections[Idx].wdatalen > 0 );
686
687         /* Daten schreiben */
688         len = send( My_Connections[Idx].sock, My_Connections[Idx].wbuf, My_Connections[Idx].wdatalen, 0 );
689         if( len < 0 )
690         {
691                 /* Oops, ein Fehler! */
692                 Log( LOG_ERR, "Write error on connection %d (socket %d): %s!", Idx, My_Connections[Idx].sock, strerror( errno ));
693                 Conn_Close( Idx, "Write error!", NULL, FALSE );
694                 return FALSE;
695         }
696
697         /* Connection-Statistik aktualisieren */
698         My_Connections[Idx].bytes_out += len;
699
700         /* Puffer anpassen */
701         My_Connections[Idx].wdatalen -= len;
702         memmove( My_Connections[Idx].wbuf, My_Connections[Idx].wbuf + len, My_Connections[Idx].wdatalen );
703
704         return TRUE;
705 } /* Handle_Write */
706
707
708 LOCAL VOID
709 New_Connection( INT Sock )
710 {
711         /* Neue Client-Verbindung von Listen-Socket annehmen und
712          * CLIENT-Struktur anlegen. */
713
714         struct sockaddr_in new_addr;
715         INT new_sock, new_sock_len;
716         RES_STAT *s;
717         CONN_ID idx;
718         CLIENT *c;
719
720         assert( Sock >= 0 );
721
722         new_sock_len = sizeof( new_addr );
723         new_sock = accept( Sock, (struct sockaddr *)&new_addr, (socklen_t *)&new_sock_len );
724         if( new_sock < 0 )
725         {
726                 Log( LOG_CRIT, "Can't accept connection: %s!", strerror( errno ));
727                 return;
728         }
729
730         /* Freie Connection-Struktur suchen */
731         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == NONE ) break;
732         if( idx >= MAX_CONNECTIONS )
733         {
734                 Log( LOG_ALERT, "Can't accept connection: limit reached (%d)!", MAX_CONNECTIONS );
735                 close( new_sock );
736                 return;
737         }
738
739         /* Client-Struktur initialisieren */
740         c = Client_NewLocal( idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWN, FALSE );
741         if( ! c )
742         {
743                 Log( LOG_ALERT, "Can't accept connection: can't create client structure!" );
744                 close( new_sock );
745                 return;
746         }
747
748         /* Verbindung registrieren */
749         Init_Conn_Struct( idx );
750         My_Connections[idx].sock = new_sock;
751         My_Connections[idx].addr = new_addr;
752
753         /* Neuen Socket registrieren */
754         FD_SET( new_sock, &My_Sockets );
755         if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
756
757         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 );
758
759         /* Hostnamen ermitteln */
760         s = Resolve_Addr( &new_addr );
761         if( s )
762         {
763                 /* Sub-Prozess wurde asyncron gestartet */
764                 Conn_WriteStr( idx, "NOTICE AUTH :%sLooking up your hostname ...", NOTICE_TXTPREFIX );
765                 My_Connections[idx].res_stat = s;
766         }
767         else
768         {
769                 /* kann Namen nicht aufloesen, daher wird die IP-Adresse verwendet */
770                 strcpy( My_Connections[idx].host, inet_ntoa( new_addr.sin_addr ));
771                 Client_SetHostname( c, My_Connections[idx].host );
772         }
773         
774         /* Penalty-Zeit setzen */
775         Conn_SetPenalty( idx, 4 );
776 } /* New_Connection */
777
778
779 LOCAL CONN_ID
780 Socket2Index( INT Sock )
781 {
782         /* zum Socket passende Connection suchen */
783
784         CONN_ID idx;
785
786         assert( Sock >= 0 );
787
788         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == Sock ) break;
789
790         if( idx >= MAX_CONNECTIONS )
791         {
792                 /* die Connection wurde vermutlich (wegen eines
793                  * Fehlers) bereits wieder abgebaut ... */
794                 Log( LOG_DEBUG, "Socket2Index: can't get connection for socket %d!", Sock );
795                 return NONE;
796         }
797         else return idx;
798 } /* Socket2Index */
799
800
801 LOCAL VOID
802 Read_Request( CONN_ID Idx )
803 {
804         /* Daten von Socket einlesen und entsprechend behandeln.
805          * Tritt ein Fehler auf, so wird der Socket geschlossen. */
806
807         INT len;
808
809         assert( Idx >= 0 );
810         assert( My_Connections[Idx].sock > NONE );
811
812         if( READBUFFER_LEN - My_Connections[Idx].rdatalen - 2 < 0 )
813         {
814                 /* Der Lesepuffer ist voll */
815                 Log( LOG_ERR, "Read buffer overflow (connection %d): %d bytes!", Idx, My_Connections[Idx].rdatalen );
816                 Conn_Close( Idx, "Read buffer overflow!", NULL, FALSE );
817                 return;
818         }
819
820         len = recv( My_Connections[Idx].sock, My_Connections[Idx].rbuf + My_Connections[Idx].rdatalen, READBUFFER_LEN - My_Connections[Idx].rdatalen - 2, 0 );
821
822         if( len == 0 )
823         {
824                 /* Socket wurde geschlossen */
825                 Log( LOG_INFO, "%s:%d is closing the connection ...", inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port));
826                 Conn_Close( Idx, "Socket closed!", "Client closed connection", FALSE );
827                 return;
828         }
829
830         if( len < 0 )
831         {
832                 /* Fehler beim Lesen */
833                 Log( LOG_ERR, "Read error on connection %d (socket %d): %s!", Idx, My_Connections[Idx].sock, strerror( errno ));
834                 Conn_Close( Idx, "Read error!", "Client closed connection", FALSE );
835                 return;
836         }
837
838         /* Connection-Statistik aktualisieren */
839         My_Connections[Idx].bytes_in += len;
840
841         /* Lesebuffer updaten */
842         My_Connections[Idx].rdatalen += len;
843         assert( My_Connections[Idx].rdatalen < READBUFFER_LEN );
844         My_Connections[Idx].rbuf[My_Connections[Idx].rdatalen] = '\0';
845
846         /* Timestamp aktualisieren */
847         My_Connections[Idx].lastdata = time( NULL );
848
849         Handle_Buffer( Idx );
850 } /* Read_Request */
851
852
853 LOCAL VOID
854 Handle_Buffer( CONN_ID Idx )
855 {
856         /* Daten im Lese-Puffer einer Verbindung verarbeiten. */
857
858         CHAR *ptr, *ptr1, *ptr2;
859         INT len, delta;
860
861         /* Eine komplette Anfrage muss mit CR+LF enden, vgl.
862          * RFC 2812. Haben wir eine? */
863         ptr = strstr( My_Connections[Idx].rbuf, "\r\n" );
864
865         if( ptr ) delta = 2;
866 #ifndef STRICT_RFC
867         else
868         {
869                 /* Nicht RFC-konforme Anfrage mit nur CR oder LF? Leider
870                  * machen soetwas viele Clients, u.a. "mIRC" :-( */
871                 ptr1 = strchr( My_Connections[Idx].rbuf, '\r' );
872                 ptr2 = strchr( My_Connections[Idx].rbuf, '\n' );
873                 delta = 1;
874                 if( ptr1 && ptr2 ) ptr = ptr1 > ptr2 ? ptr2 : ptr1;
875                 else if( ptr1 ) ptr = ptr1;
876                 else if( ptr2 ) ptr = ptr2;
877         }
878 #endif
879
880         if( ptr )
881         {
882                 /* Ende der Anfrage wurde gefunden */
883                 *ptr = '\0';
884                 len = ( ptr - My_Connections[Idx].rbuf ) + delta;
885                 if( len > ( COMMAND_LEN - 1 ))
886                 {
887                         /* Eine Anfrage darf(!) nicht laenger als 512 Zeichen
888                         * (incl. CR+LF!) werden; vgl. RFC 2812. Wenn soetwas
889                         * empfangen wird, wird der Client disconnectiert. */
890                         Log( LOG_ERR, "Request too long (connection %d): %d bytes (max. %d expected)!", Idx, My_Connections[Idx].rdatalen, COMMAND_LEN - 1 );
891                         Conn_Close( Idx, NULL, "Request too long", TRUE );
892                         return;
893                 }
894
895                 if( len > delta )
896                 {
897                         /* Es wurde ein Request gelesen */
898                         if( ! Parse_Request( Idx, My_Connections[Idx].rbuf )) return;
899                 }
900
901                 /* Puffer anpassen */
902                 My_Connections[Idx].rdatalen -= len;
903                 memmove( My_Connections[Idx].rbuf, My_Connections[Idx].rbuf + len, My_Connections[Idx].rdatalen );
904         }
905 } /* Handle_Buffer */
906
907
908 LOCAL VOID
909 Check_Connections( VOID )
910 {
911         /* Pruefen, ob Verbindungen noch "alive" sind. Ist dies
912          * nicht der Fall, zunaechst PING-PONG spielen und, wenn
913          * auch das nicht "hilft", Client disconnectieren. */
914
915         CLIENT *c;
916         INT i;
917
918         for( i = 0; i < MAX_CONNECTIONS; i++ )
919         {
920                 if( My_Connections[i].sock == NONE ) continue;
921
922                 c = Client_GetFromConn( i );
923                 if( c && (( Client_Type( c ) == CLIENT_USER ) || ( Client_Type( c ) == CLIENT_SERVER ) || ( Client_Type( c ) == CLIENT_SERVICE )))
924                 {
925                         /* verbundener User, Server oder Service */
926                         if( My_Connections[i].lastping > My_Connections[i].lastdata )
927                         {
928                                 /* es wurde bereits ein PING gesendet */
929                                 if( My_Connections[i].lastping < time( NULL ) - Conf_PongTimeout )
930                                 {
931                                         /* Timeout */
932                                         Log( LOG_DEBUG, "Connection %d: Ping timeout: %d seconds.", i, Conf_PongTimeout );
933                                         Conn_Close( i, NULL, "Ping timeout", TRUE );
934                                 }
935                         }
936                         else if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
937                         {
938                                 /* es muss ein PING gesendet werden */
939                                 Log( LOG_DEBUG, "Connection %d: sending PING ...", i );
940                                 My_Connections[i].lastping = time( NULL );
941                                 Conn_WriteStr( i, "PING :%s", Client_ID( Client_ThisServer( )));
942                         }
943                 }
944                 else
945                 {
946                         /* noch nicht vollstaendig aufgebaute Verbindung */
947                         if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
948                         {
949                                 /* Timeout */
950                                 Log( LOG_DEBUG, "Connection %d timed out ...", i );
951                                 Conn_Close( i, NULL, "Timeout", FALSE );
952                         }
953                 }
954         }
955 } /* Check_Connections */
956
957
958 LOCAL VOID
959 Check_Servers( VOID )
960 {
961         /* Pruefen, ob Server-Verbindungen aufgebaut werden
962          * muessen bzw. koennen */
963
964         INT idx, i, n;
965         RES_STAT *s;
966
967         /* Wenn "Passive-Mode" aktiv: nicht verbinden */
968         if( NGIRCd_Passive ) return;
969
970         for( i = 0; i < Conf_Server_Count; i++ )
971         {
972                 /* Ist ein Hostname und Port definiert? */
973                 if(( ! Conf_Server[i].host[0] ) || ( ! Conf_Server[i].port > 0 )) continue;
974
975                 /* Haben wir schon eine Verbindung? */
976                 for( n = 0; n < MAX_CONNECTIONS; n++ )
977                 {
978                         if( My_Connections[n].sock == NONE ) continue;
979                         
980                         /* Verbindung zu diesem Server? */
981                         if( My_Connections[n].our_server == i )
982                         {
983                                 /* Komplett aufgebaute Verbindung? */
984                                 if( My_Connections[n].sock > NONE ) break;
985
986                                 /* IP schon aufgeloest? */
987                                 if( My_Connections[n].res_stat == NULL ) New_Server( i, n );
988                         }
989
990                         /* Verbindung in dieser Server-Gruppe? */
991                         if(( My_Connections[n].our_server != NONE ) && ( Conf_Server[i].group != NONE ))
992                         {
993                                 if( Conf_Server[My_Connections[n].our_server].group == Conf_Server[i].group ) break;
994                         }
995                 }
996                 if( n < MAX_CONNECTIONS ) continue;
997
998                 /* Wann war der letzte Connect-Versuch? */
999                 if( Conf_Server[i].lasttry > time( NULL ) - Conf_ConnectRetry ) continue;
1000
1001                 /* Okay, Verbindungsaufbau versuchen */
1002                 Conf_Server[i].lasttry = time( NULL );
1003
1004                 /* Freie Connection-Struktur suschen */
1005                 for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == NONE ) break;
1006                 if( idx >= MAX_CONNECTIONS )
1007                 {
1008                         Log( LOG_ALERT, "Can't establist server connection: connection limit reached (%d)!", MAX_CONNECTIONS );
1009                         return;
1010                 }
1011                 Log( LOG_DEBUG, "Preparing connection %d for \"%s\" ...", idx, Conf_Server[i].host );
1012
1013                 /* Verbindungs-Struktur initialisieren */
1014                 Init_Conn_Struct( idx );
1015                 My_Connections[idx].sock = SERVER_WAIT;
1016                 My_Connections[idx].our_server = i;
1017
1018                 /* Hostnamen in IP aufloesen */
1019                 s = Resolve_Name( Conf_Server[i].host );
1020                 if( s )
1021                 {
1022                         /* Sub-Prozess wurde asyncron gestartet */
1023                         My_Connections[idx].res_stat = s;
1024                 }
1025                 else
1026                 {
1027                         /* kann Namen nicht aufloesen: nun versuchen wir einfach,
1028                          * den "Text" direkt als IP-Adresse zu verwenden ... */
1029                         strcpy( Conf_Server[My_Connections[idx].our_server].ip, Conf_Server[i].host );
1030                 }
1031         }
1032 } /* Check_Servers */
1033
1034
1035 LOCAL VOID
1036 New_Server( INT Server, CONN_ID Idx )
1037 {
1038         /* Neue Server-Verbindung aufbauen */
1039
1040         struct sockaddr_in new_addr;
1041         struct in_addr inaddr;
1042         INT new_sock;
1043         CLIENT *c;
1044
1045         assert( Server >= 0 );
1046         assert( Idx >= 0 );
1047
1048         /* Wurde eine gueltige IP-Adresse gefunden? */
1049         if( ! Conf_Server[Server].ip[0] )
1050         {
1051                 /* Nein. Verbindung wieder freigeben: */
1052                 Init_Conn_Struct( Idx );
1053                 Log( LOG_ERR, "Can't connect to \"%s\" (connection %d): ip address unknown!", Conf_Server[Server].host, Idx );
1054                 return;
1055         }
1056
1057         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 );
1058
1059 #ifdef HAVE_INET_ATON
1060         if( inet_aton( Conf_Server[Server].ip, &inaddr ) == 0 )
1061 #else
1062         memset( &inaddr, 0, sizeof( inaddr ));
1063         inaddr.s_addr = inet_addr( Conf_Server[Server].ip );
1064         if( inaddr.s_addr == (unsigned)-1 )
1065 #endif
1066         {
1067                 /* Konnte Adresse nicht konvertieren */
1068                 Init_Conn_Struct( Idx );
1069                 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 );
1070                 return;
1071         }
1072
1073         memset( &new_addr, 0, sizeof( new_addr ));
1074         new_addr.sin_family = AF_INET;
1075         new_addr.sin_addr = inaddr;
1076         new_addr.sin_port = htons( Conf_Server[Server].port );
1077
1078         new_sock = socket( PF_INET, SOCK_STREAM, 0 );
1079         if ( new_sock < 0 )
1080         {
1081                 Init_Conn_Struct( Idx );
1082                 Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
1083                 return;
1084         }
1085
1086         if( ! Init_Socket( new_sock )) return;
1087
1088         connect( new_sock, (struct sockaddr *)&new_addr, sizeof( new_addr ));
1089         if( errno != EINPROGRESS )
1090         {
1091
1092                 close( new_sock );
1093                 Init_Conn_Struct( Idx );
1094                 Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
1095                 return;
1096         }
1097
1098         /* Client-Struktur initialisieren */
1099         c = Client_NewLocal( Idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWNSERVER, FALSE );
1100         if( ! c )
1101         {
1102                 close( new_sock );
1103                 Init_Conn_Struct( Idx );
1104                 Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
1105                 return;
1106         }
1107         Client_SetIntroducer( c, c );
1108         Client_SetToken( c, TOKEN_OUTBOUND );
1109
1110         /* Verbindung registrieren */
1111         My_Connections[Idx].sock = new_sock;
1112         My_Connections[Idx].addr = new_addr;
1113         strcpy( My_Connections[Idx].host, Conf_Server[Server].host );
1114
1115         /* Neuen Socket registrieren */
1116         FD_SET( new_sock, &My_Sockets );
1117         FD_SET( new_sock, &My_Connects );
1118         if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
1119         
1120         Log( LOG_DEBUG, "Registered new connection %d on socket %d.", Idx, My_Connections[Idx].sock );
1121 } /* New_Server */
1122
1123
1124 LOCAL VOID
1125 Init_Conn_Struct( INT Idx )
1126 {
1127         /* Connection-Struktur initialisieren */
1128
1129         My_Connections[Idx].sock = NONE;
1130         My_Connections[Idx].res_stat = NULL;
1131         My_Connections[Idx].host[0] = '\0';
1132         My_Connections[Idx].rbuf[0] = '\0';
1133         My_Connections[Idx].rdatalen = 0;
1134         My_Connections[Idx].wbuf[0] = '\0';
1135         My_Connections[Idx].wdatalen = 0;
1136         My_Connections[Idx].our_server = NONE;
1137         My_Connections[Idx].lastdata = time( NULL );
1138         My_Connections[Idx].lastping = 0;
1139         My_Connections[Idx].lastprivmsg = time( NULL );
1140         My_Connections[Idx].delaytime = 0;
1141         My_Connections[Idx].bytes_in = 0;
1142         My_Connections[Idx].bytes_out = 0;
1143 } /* Init_Conn_Struct */
1144
1145
1146 LOCAL BOOLEAN
1147 Init_Socket( INT Sock )
1148 {
1149         /* Socket-Optionen setzen */
1150
1151         INT on = 1;
1152
1153 #ifdef O_NONBLOCK       /* A/UX kennt das nicht? */
1154         if( fcntl( Sock, F_SETFL, O_NONBLOCK ) != 0 )
1155         {
1156                 Log( LOG_CRIT, "Can't enable non-blocking mode: %s!", strerror( errno ));
1157                 close( Sock );
1158                 return FALSE;
1159         }
1160 #endif
1161         if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &on, (socklen_t)sizeof( on )) != 0)
1162         {
1163                 Log( LOG_ERR, "Can't set socket options: %s!", strerror( errno ));
1164                 /* dieser Fehler kann ignoriert werden. */
1165         }
1166
1167         return TRUE;
1168 } /* Init_Socket */
1169
1170
1171 LOCAL VOID
1172 Read_Resolver_Result( INT r_fd )
1173 {
1174         /* Ergebnis von Resolver Sub-Prozess aus Pipe lesen
1175          * und entsprechende Connection aktualisieren */
1176
1177         CHAR result[HOST_LEN];
1178         CLIENT *c;
1179         INT len, i;
1180
1181         FD_CLR( r_fd, &Resolver_FDs );
1182
1183         /* Anfrage vom Parent lesen */
1184         len = read( r_fd, result, HOST_LEN - 1 );
1185         if( len < 0 )
1186         {
1187                 /* Fehler beim Lesen aus der Pipe */
1188                 close( r_fd );
1189                 Log( LOG_CRIT, "Resolver: Can't read result: %s!", strerror( errno ));
1190                 return;
1191         }
1192         result[len] = '\0';
1193
1194         /* zugehoerige Connection suchen */
1195         for( i = 0; i < MAX_CONNECTIONS; i++ )
1196         {
1197                 if(( My_Connections[i].sock != NONE ) && ( My_Connections[i].res_stat ) && ( My_Connections[i].res_stat->pipe[0] == r_fd )) break;
1198         }
1199         if( i >= MAX_CONNECTIONS )
1200         {
1201                 /* Opsa! Keine passende Connection gefunden!? Vermutlich
1202                  * wurde sie schon wieder geschlossen. */
1203                 close( r_fd );
1204                 Log( LOG_DEBUG, "Resolver: Got result for unknown connection!?" );
1205                 return;
1206         }
1207
1208         /* Aufraeumen */
1209         close( My_Connections[i].res_stat->pipe[0] );
1210         close( My_Connections[i].res_stat->pipe[1] );
1211         free( My_Connections[i].res_stat );
1212         My_Connections[i].res_stat = NULL;
1213
1214         if( My_Connections[i].sock > NONE )
1215         {
1216                 /* Eingehende Verbindung: Hostnamen setzen */
1217                 c = Client_GetFromConn( i );
1218                 assert( c != NULL );
1219                 strcpy( My_Connections[i].host, result );
1220                 Client_SetHostname( c, result );
1221
1222                 Conn_WriteStr( i, "NOTICE AUTH :%sGot your hostname.", NOTICE_TXTPREFIX );
1223         }
1224         else
1225         {
1226                 /* Ausgehende Verbindung (=Server): IP setzen */
1227                 assert( My_Connections[i].our_server >= 0 );
1228                 strcpy( Conf_Server[My_Connections[i].our_server].ip, result );
1229         }
1230
1231         /* Penalty-Zeit zurueck setzen */
1232         Conn_ResetPenalty( i );
1233 } /* Read_Resolver_Result */
1234
1235
1236 /* -eof- */