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