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