src/ngircd/conn.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001 by Alexander Barton (alex@barton.de)
   4  *
   5  * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
   6  * der GNU General Public License (GPL), wie von der Free Software Foundation
   7  * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
   8  * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
   9  * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
  10  * der an comBase beteiligten Autoren finden Sie in der Datei AUTHORS.
  11  *
  12  * $Id: conn.c,v 1.18 2001/12/29 20:17:25 alex Exp $
  13  *
  14  * connect.h: Verwaltung aller Netz-Verbindungen ("connections")
  15  *
  16  * $Log: conn.c,v $
  17  * Revision 1.18  2001/12/29 20:17:25  alex
  18  * - asyncronen Resolver (IP->Name) implementiert, dadurch div. Aenderungen.
  19  *
  20  * Revision 1.17  2001/12/29 03:06:16  alex
  21  * - Loglevel (nochmal) angepasst.
  22  *
  23  * Revision 1.16  2001/12/27 19:32:44  alex
  24  * - bei "Null-Requests" wird nichts mehr geloggt. Uberfluessig, da normal.
  25  *
  26  * Revision 1.15  2001/12/27 16:35:04  alex
  27  * - vergessene Variable bei Ping-Timeout-Logmeldung ergaenzt. Opsa.
  28  *
  29  * Revision 1.14  2001/12/26 14:45:37  alex
  30  * - "Code Cleanups".
  31  *
  32  * Revision 1.13  2001/12/26 03:36:57  alex
  33  * - Verbindungen mit Lesefehlern werden nun korrekt terminiert.
  34  *
  35  * Revision 1.12  2001/12/26 03:20:53  alex
  36  * - PING/PONG-Timeout implementiert.
  37  *
  38  * Revision 1.11  2001/12/25 23:15:16  alex
  39  * - buffer werden nun periodisch geprueft, keine haengenden Clients mehr.
  40  *
  41  * Revision 1.10  2001/12/25 22:03:47  alex
  42  * - Conn_Close() eingefuehrt: war die lokale Funktion Close_Connection().
  43  *
  44  * Revision 1.9  2001/12/24 01:32:33  alex
  45  * - in Conn_WriteStr() wurde das CR+LF nicht angehaengt!
  46  * - Fehler-Ausgaben vereinheitlicht.
  47  *
  48  * Revision 1.8  2001/12/23 22:02:54  alex
  49  * - Conn_WriteStr() nimmt nun variable Parameter,
  50  * - diverse kleinere Aenderungen.
  51  *
  52  * Revision 1.7  2001/12/21 22:24:25  alex
  53  * - kleinere Aenderungen an den Log-Meldungen,
  54  * - Parse_Request() wird aufgerufen.
  55  *
  56  * Revision 1.6  2001/12/15 00:11:55  alex
  57  * - Lese- und Schreib-Puffer implementiert.
  58  * - einige neue (Unter-)Funktionen eingefuehrt.
  59  * - diverse weitere kleinere Aenderungen.
  60  *
  61  * Revision 1.5  2001/12/14 08:16:47  alex
  62  * - Begonnen, Client-spezifische Lesepuffer zu implementieren.
  63  * - Umstellung auf Datentyp "CONN_ID".
  64  *
  65  * Revision 1.4  2001/12/13 02:04:16  alex
  66  * - boesen "Speicherschiesser" in Log() gefixt.
  67  *
  68  * Revision 1.3  2001/12/13 01:33:09  alex
  69  * - Conn_Handler() unterstuetzt nun einen Timeout.
  70  * - fuer Verbindungen werden keine FILE-Handles mehr benutzt.
  71  * - kleinere "Code Cleanups" ;-)
  72  *
  73  * Revision 1.2  2001/12/12 23:32:02  alex
  74  * - diverse Erweiterungen und Verbesserungen (u.a. sind nun mehrere
  75  *   Verbindungen und Listen-Sockets moeglich).
  76  *
  77  * Revision 1.1  2001/12/12 17:18:38  alex
  78  * - Modul zur Verwaltung aller Netzwerk-Verbindungen begonnen.
  79  */
  80
  81
  82 #include <portab.h>
  83 #include "global.h"
  84
  85 #include <imp.h>
  86 #include <assert.h>
  87 #include <stdarg.h>
  88 #include <stdio.h>
  89 #include <unistd.h>
  90 #include <errno.h>
  91 #include <fcntl.h>
  92 #include <string.h>
  93 #include <sys/socket.h>
  94 #include <sys/time.h>
  95 #include <sys/types.h>
  96 #include <time.h>
  97 #include <netinet/in.h>
  98 #include <arpa/inet.h>
  99 #include <netdb.h>
 100
 101 #ifdef HAVE_STDINT_H
 102 #include <stdint.h>                     /* u.a. fuer Mac OS X */
 103 #endif
 104
 105 #include "ngircd.h"
 106 #include "client.h"
 107 #include "conf.h"
 108 #include "log.h"
 109 #include "parse.h"
 110 #include "tool.h"
 111
 112 #include <exp.h>
 113 #include "conn.h"
 114
 115
 116 #define MAX_CONNECTIONS 100             /* max. Anzahl von Verbindungen an diesem Server */
 117
 118 #define MAX_CMDLEN 512                  /* max. Laenge eines Befehls, vgl. RFC 2812, 3.2 */
 119
 120 #define READBUFFER_LEN 2 * MAX_CMDLEN   /* Laenge des Lesepuffers je Verbindung (Bytes) */
 121 #define WRITEBUFFER_LEN 4096            /* Laenge des Schreibpuffers je Verbindung (Bytes) */
 122
 123 #define HOST_LEN 256                    /* max. Laenge eines Hostnamen */
 124
 125
 126 typedef struct _Res_Stat
 127 {
 128         INT pid;                        /* PID des Child-Prozess */
 129         INT out_pipe[2];                /* Pipe fuer IPC: zum Client */
 130         INT in_pipe[2];                 /* Pipe fuer IPC: vom Client */
 131 } RES_STAT;
 132
 133
 134 typedef struct _Connection
 135 {
 136         INT sock;                       /* Socket Handle */
 137         struct sockaddr_in addr;        /* Adresse des Client */
 138         RES_STAT *res_stat;             /* "Resolver-Status", s.o. */
 139         CHAR host[HOST_LEN];            /* Hostname */
 140         CHAR rbuf[READBUFFER_LEN + 1];  /* Lesepuffer */
 141         INT rdatalen;                   /* Laenge der Daten im Lesepuffer */
 142         CHAR wbuf[WRITEBUFFER_LEN + 1]; /* Schreibpuffer */
 143         INT wdatalen;                   /* Laenge der Daten im Schreibpuffer */
 144         time_t lastdata;                /* Letzte Aktivitaet */
 145         time_t lastping;                /* Letzter PING */
 146 } CONNECTION;
 147
 148
 149 LOCAL VOID Handle_Read( INT sock );
 150 LOCAL BOOLEAN Handle_Write( CONN_ID Idx );
 151 LOCAL VOID New_Connection( INT Sock );
 152 LOCAL CONN_ID Socket2Index( INT Sock );
 153 LOCAL VOID Read_Request( CONN_ID Idx );
 154 LOCAL BOOLEAN Try_Write( CONN_ID Idx );
 155 LOCAL VOID Handle_Buffer( CONN_ID Idx );
 156 LOCAL VOID Check_Connections( VOID );
 157 LOCAL VOID Init_Conn_Struct( INT Idx );
 158
 159 LOCAL RES_STAT *Resolve( CHAR *Host );
 160 LOCAL VOID Do_Resolve( INT r_fd, INT w_fd );
 161 LOCAL VOID Read_Resolver_Result( INT r_fd );
 162
 163
 164 LOCAL fd_set My_Listeners;
 165 LOCAL fd_set My_Sockets;
 166 LOCAL fd_set My_Resolvers;
 167
 168 LOCAL INT My_Max_Fd;
 169
 170 LOCAL CONNECTION My_Connections[MAX_CONNECTIONS];
 171
 172
 173 GLOBAL VOID Conn_Init( VOID )
 174 {
 175         CONN_ID i;
 176
 177         /* zu Beginn haben wir keine Verbindungen */
 178         FD_ZERO( &My_Listeners );
 179         FD_ZERO( &My_Sockets );
 180         FD_ZERO( &My_Resolvers );
 181
 182         My_Max_Fd = 0;
 183
 184         /* Connection-Struktur initialisieren */
 185         for( i = 0; i < MAX_CONNECTIONS; i++ ) Init_Conn_Struct( i );
 186 } /* Conn_Init */
 187
 188
 189 GLOBAL VOID Conn_Exit( VOID )
 190 {
 191         CONN_ID idx;
 192         INT i;
 193
 194         /* Sockets schliessen */
 195         for( i = 0; i < My_Max_Fd + 1; i++ )
 196         {
 197                 if( FD_ISSET( i, &My_Sockets ))
 198                 {
 199                         for( idx = 0; idx < MAX_CONNECTIONS; idx++ )
 200                         {
 201                                 if( My_Connections[idx].sock == i ) break;
 202                         }
 203                         if( idx < MAX_CONNECTIONS ) Conn_Close( idx, "Server going down ..." );
 204                         else if( FD_ISSET( i, &My_Listeners ))
 205                         {
 206                                 close( i );
 207                                 Log( LOG_INFO, "Listening socket %d closed.", i );
 208                         }
 209                         else
 210                         {
 211                                 close( i );
 212                                 Log( LOG_WARNING, "Unknown connection %d closed.", i );
 213                         }
 214                 }
 215         }
 216 } /* Conn_Exit */
 217
 218
 219 GLOBAL BOOLEAN Conn_NewListener( CONST INT Port )
 220 {
 221         /* Neuen Listen-Socket erzeugen: der Server wartet dann
 222          * auf dem angegebenen Port auf Verbindungen. */
 223
 224         struct sockaddr_in addr;
 225         INT sock, on = 1;
 226
 227         /* Server-"Listen"-Socket initialisieren */
 228         memset( &addr, 0, sizeof( addr ));
 229         addr.sin_family = AF_INET;
 230         addr.sin_port = htons( Port );
 231         addr.sin_addr.s_addr = htonl( INADDR_ANY );
 232
 233         /* Socket erzeugen */
 234         sock = socket( PF_INET, SOCK_STREAM, 0);
 235         if( sock < 0 )
 236         {
 237                 Log( LOG_ALERT, "Can't create socket: %s!", strerror( errno ));
 238                 return FALSE;
 239         }
 240
 241         /* Socket-Optionen setzen */
 242         if( fcntl( sock, F_SETFL, O_NONBLOCK ) != 0 )
 243         {
 244                 Log( LOG_ALERT, "Can't enable non-blocking mode: %s!", strerror( errno ));
 245                 close( sock );
 246                 return FALSE;
 247         }
 248         if( setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &on, (socklen_t)sizeof( on )) != 0)
 249         {
 250                 Log( LOG_CRIT, "Can't set socket options: %s!", strerror( errno ));
 251                 /* dieser Fehler kann ignoriert werden. */
 252         }
 253
 254         /* an Port binden */
 255         if( bind( sock, (struct sockaddr *)&addr, (socklen_t)sizeof( addr )) != 0 )
 256         {
 257                 Log( LOG_ALERT, "Can't bind socket: %s!", strerror( errno ));
 258                 close( sock );
 259                 return FALSE;
 260         }
 261
 262         /* in "listen mode" gehen :-) */
 263         if( listen( sock, 10 ) != 0 )
 264         {
 265                 Log( LOG_ALERT, "Can't listen on soecket: %s!", strerror( errno ));
 266                 close( sock );
 267                 return FALSE;
 268         }
 269
 270         /* Neuen Listener in Strukturen einfuegen */
 271         FD_SET( sock, &My_Listeners );
 272         FD_SET( sock, &My_Sockets );
 273
 274         if( sock > My_Max_Fd ) My_Max_Fd = sock;
 275
 276         Log( LOG_INFO, "Now listening on port %d, socket %d.", Port, sock );
 277
 278         return TRUE;
 279 } /* Conn_NewListener */
 280
 281
 282 GLOBAL VOID Conn_Handler( INT Timeout )
 283 {
 284         fd_set read_sockets, write_sockets;
 285         struct timeval tv;
 286         time_t start;
 287         INT i;
 288
 289         start = time( NULL );
 290         while(( time( NULL ) - start < Timeout ) && ( ! NGIRCd_Quit ))
 291         {
 292                 Check_Connections( );
 293
 294                 /* Timeout initialisieren */
 295                 tv.tv_sec = 0;
 296                 tv.tv_usec = 50000;
 297
 298                 /* noch volle Lese-Buffer suchen */
 299                 for( i = 0; i < MAX_CONNECTIONS; i++ )
 300                 {
 301                         if(( My_Connections[i].sock >= 0 ) && ( My_Connections[i].rdatalen > 0 ))
 302                         {
 303                                 /* Kann aus dem Buffer noch ein Befehl extrahiert werden? */
 304                                 Handle_Buffer( i );
 305                         }
 306                 }
 307
 308                 /* noch volle Schreib-Puffer suchen */
 309                 FD_ZERO( &write_sockets );
 310                 for( i = 0; i < MAX_CONNECTIONS; i++ )
 311                 {
 312                         if(( My_Connections[i].sock >= 0 ) && ( My_Connections[i].wdatalen > 0 ))
 313                         {
 314                                 /* Socket der Verbindung in Set aufnehmen */
 315                                 FD_SET( My_Connections[i].sock, &write_sockets );
 316                         }
 317                 }
 318
 319                 /* von welchen Sockets koennte gelesen werden? */
 320                 read_sockets = My_Sockets;
 321                 for( i = 0; i < MAX_CONNECTIONS; i++ )
 322                 {
 323                         if(( My_Connections[i].sock >= 0 ) && ( My_Connections[i].host[0] == '\0' ))
 324                         {
 325                                 /* Hier muss noch auf den Resolver Sub-Prozess gewartet werden */
 326                                 FD_CLR( My_Connections[i].sock, &read_sockets );
 327                         }
 328                 }
 329                 for( i = 0; i < My_Max_Fd + 1; i++ )
 330                 {
 331                         /* Pipes von Resolver Sub-Prozessen aufnehmen */
 332                         if( FD_ISSET( i, &My_Resolvers ))
 333                         {
 334                                 FD_SET( i, &read_sockets );
 335                         }
 336                 }
 337
 338                 /* Auf Aktivitaet warten */
 339                 if( select( My_Max_Fd + 1, &read_sockets, &write_sockets, NULL, &tv ) == -1 )
 340                 {
 341                         if( errno != EINTR ) Log( LOG_ALERT, "select(): %s!", strerror( errno ));
 342                         return;
 343                 }
 344
 345                 /* Koennen Daten geschrieben werden? */
 346                 for( i = 0; i < My_Max_Fd + 1; i++ )
 347                 {
 348                         if( FD_ISSET( i, &write_sockets )) Handle_Write( Socket2Index( i ));
 349                 }
 350
 351                 /* Daten zum Lesen vorhanden? */
 352                 for( i = 0; i < My_Max_Fd + 1; i++ )
 353                 {
 354                         if( FD_ISSET( i, &read_sockets )) Handle_Read( i );
 355                 }
 356         }
 357 } /* Conn_Handler */
 358
 359
 360 GLOBAL BOOLEAN Conn_WriteStr( CONN_ID Idx, CHAR *Format, ... )
 361 {
 362         /* String in Socket schreiben. CR+LF wird von dieser Funktion
 363          * automatisch angehaengt. Im Fehlerfall wird dir Verbindung
 364          * getrennt und FALSE geliefert. */
 365
 366         CHAR buffer[MAX_CMDLEN];
 367         BOOLEAN ok;
 368         va_list ap;
 369
 370         va_start( ap, Format );
 371         if( vsnprintf( buffer, MAX_CMDLEN - 2, Format, ap ) == MAX_CMDLEN - 2 )
 372         {
 373                 Log( LOG_ALERT, "String too long to send (connection %d)!", Idx );
 374                 Conn_Close( Idx, "Server error: String too long to send!" );
 375                 return FALSE;
 376         }
 377
 378 #ifdef SNIFFER
 379         Log( LOG_DEBUG, " -> connection %d: '%s'.", Idx, buffer );
 380 #endif
 381
 382         strcat( buffer, "\r\n" );
 383         ok = Conn_Write( Idx, buffer, strlen( buffer ));
 384
 385         va_end( ap );
 386         return ok;
 387 } /* Conn_WriteStr */
 388
 389
 390 GLOBAL BOOLEAN Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
 391 {
 392         /* Daten in Socket schreiben. Bei "fatalen" Fehlern wird
 393          * der Client disconnectiert und FALSE geliefert. */
 394
 395         assert( Idx >= 0 );
 396         assert( My_Connections[Idx].sock >= 0 );
 397         assert( Data != NULL );
 398         assert( Len > 0 );
 399
 400         /* pruefen, ob Daten im Schreibpuffer sind. Wenn ja, zunaechst
 401          * pruefen, ob diese gesendet werden koennen */
 402         if( My_Connections[Idx].wdatalen > 0 )
 403         {
 404                 if( ! Try_Write( Idx )) return FALSE;
 405         }
 406
 407         /* pruefen, ob im Schreibpuffer genuegend Platz ist */
 408         if( WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - Len <= 0 )
 409         {
 410                 /* der Puffer ist dummerweise voll ... */
 411                 Log( LOG_NOTICE, "Write buffer overflow (connection %d)!", Idx );
 412                 Conn_Close( Idx, NULL );
 413                 return FALSE;
 414         }
 415
 416         /* Daten in Puffer kopieren */
 417         memcpy( My_Connections[Idx].wbuf + My_Connections[Idx].wdatalen, Data, Len );
 418         My_Connections[Idx].wdatalen += Len;
 419
 420         /* pruefen, on Daten vorhanden sind und geschrieben werden koennen */
 421         if( My_Connections[Idx].wdatalen > 0 )
 422         {
 423                 if( ! Try_Write( Idx )) return FALSE;
 424         }
 425
 426         return TRUE;
 427 } /* Conn_Write */
 428
 429
 430 GLOBAL VOID Conn_Close( CONN_ID Idx, CHAR *Msg )
 431 {
 432         /* Verbindung schliessen */
 433
 434         assert( Idx >= 0 );
 435         assert( My_Connections[Idx].sock >= 0 );
 436
 437         if( Msg ) Conn_WriteStr( Idx, "ERROR :%s", Msg );
 438
 439         if( close( My_Connections[Idx].sock ) != 0 )
 440         {
 441                 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 ));
 442                 return;
 443         }
 444         else
 445         {
 446                 Log( LOG_NOTICE, "Connection %d with %s:%d closed.", Idx, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port ));
 447         }
 448
 449         Client_Destroy( Client_GetFromConn( Idx ));
 450
 451         if( My_Connections[Idx].res_stat )
 452         {
 453                 /* Resolver-Strukturen freigeben, wenn noch nicht geschehen */
 454                 FD_CLR( My_Connections[Idx].res_stat->in_pipe[0], &My_Resolvers );
 455                 close( My_Connections[Idx].res_stat->out_pipe[0] );
 456                 close( My_Connections[Idx].res_stat->out_pipe[1] );
 457                 close( My_Connections[Idx].res_stat->in_pipe[0] );
 458                 close( My_Connections[Idx].res_stat->in_pipe[1] );
 459                 free( My_Connections[Idx].res_stat );
 460         }
 461
 462         FD_CLR( My_Connections[Idx].sock, &My_Sockets );
 463         My_Connections[Idx].sock = NONE;
 464 } /* Conn_Close */
 465
 466
 467 LOCAL BOOLEAN Try_Write( CONN_ID Idx )
 468 {
 469         /* Versuchen, Daten aus dem Schreib-Puffer in den
 470          * Socket zu schreiben. */
 471
 472         fd_set write_socket;
 473
 474         assert( Idx >= 0 );
 475         assert( My_Connections[Idx].sock >= 0 );
 476         assert( My_Connections[Idx].wdatalen > 0 );
 477
 478         FD_ZERO( &write_socket );
 479         FD_SET( My_Connections[Idx].sock, &write_socket );
 480         if( select( My_Connections[Idx].sock + 1, NULL, &write_socket, NULL, 0 ) == -1 )
 481         {
 482                 /* Fehler! */
 483                 if( errno != EINTR )
 484                 {
 485                         Log( LOG_ALERT, "select(): %s!", strerror( errno ));
 486                         Conn_Close( Idx, NULL );
 487                         return FALSE;
 488                 }
 489         }
 490
 491         if( FD_ISSET( My_Connections[Idx].sock, &write_socket )) return Handle_Write( Idx );
 492         else return TRUE;
 493 } /* Try_Write */
 494
 495
 496 LOCAL VOID Handle_Read( INT Sock )
 497 {
 498         /* Aktivitaet auf einem Socket verarbeiten */
 499
 500         CONN_ID idx;
 501
 502         assert( Sock >= 0 );
 503
 504         if( FD_ISSET( Sock, &My_Listeners ))
 505         {
 506                 /* es ist einer unserer Listener-Sockets: es soll
 507                  * also eine neue Verbindung aufgebaut werden. */
 508
 509                 New_Connection( Sock );
 510         }
 511         else if( FD_ISSET( Sock, &My_Resolvers ))
 512         {
 513                 /* Rueckmeldung von einem Resolver Sub-Prozess */
 514
 515                 Read_Resolver_Result( Sock );
 516         }
 517         else
 518         {
 519                 /* Ein Client Socket: entweder ein User oder Server */
 520
 521                 idx = Socket2Index( Sock );
 522                 Read_Request( idx );
 523         }
 524 } /* Handle_Read */
 525
 526
 527 LOCAL BOOLEAN Handle_Write( CONN_ID Idx )
 528 {
 529         /* Daten aus Schreibpuffer versenden */
 530
 531         INT len;
 532
 533         assert( Idx >= 0 );
 534         assert( My_Connections[Idx].sock >= 0 );
 535         assert( My_Connections[Idx].wdatalen > 0 );
 536
 537         /* Daten schreiben */
 538         len = send( My_Connections[Idx].sock, My_Connections[Idx].wbuf, My_Connections[Idx].wdatalen, 0 );
 539         if( len < 0 )
 540         {
 541                 /* Oops, ein Fehler! */
 542                 Log( LOG_ALERT, "Write error (buffer) on connection %d: %s!", Idx, strerror( errno ));
 543                 Conn_Close( Idx, NULL );
 544                 return FALSE;
 545         }
 546
 547         /* Puffer anpassen */
 548         My_Connections[Idx].wdatalen -= len;
 549         memmove( My_Connections[Idx].wbuf, My_Connections[Idx].wbuf + len, My_Connections[Idx].wdatalen );
 550
 551         return TRUE;
 552 } /* Handle_Write */
 553
 554
 555 LOCAL VOID New_Connection( INT Sock )
 556 {
 557         /* Neue Client-Verbindung von Listen-Socket annehmen und
 558          * CLIENT-Struktur anlegen. */
 559
 560         struct sockaddr_in new_addr;
 561         INT new_sock, new_sock_len;
 562         RES_STAT *s;
 563         CONN_ID idx;
 564
 565         assert( Sock >= 0 );
 566
 567         new_sock_len = sizeof( new_addr );
 568         new_sock = accept( Sock, (struct sockaddr *)&new_addr, (socklen_t *)&new_sock_len );
 569         if( new_sock < 0 )
 570         {
 571                 Log( LOG_CRIT, "Can't accept connection: %s!", strerror( errno ));
 572                 return;
 573         }
 574
 575         /* Freie Connection-Struktur suschen */
 576         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock < 0 ) break;
 577         if( idx >= MAX_CONNECTIONS )
 578         {
 579                 Log( LOG_ALERT, "Can't accept connection: limit reached (%d)!", MAX_CONNECTIONS );
 580                 close( new_sock );
 581                 return;
 582         }
 583
 584         /* Client-Struktur initialisieren */
 585         if( ! Client_NewLocal( idx, inet_ntoa( new_addr.sin_addr )))
 586         {
 587                 Log( LOG_ALERT, "Can't accept connection: can't create client structure!" );
 588                 close( new_sock );
 589                 return;
 590         }
 591
 592         /* Verbindung registrieren */
 593         Init_Conn_Struct( idx );
 594         My_Connections[idx].sock = new_sock;
 595         My_Connections[idx].addr = new_addr;
 596
 597         /* Neuen Socket registrieren */
 598         FD_SET( new_sock, &My_Sockets );
 599         if( new_sock > My_Max_Fd ) My_Max_Fd = new_sock;
 600
 601         Log( LOG_NOTICE, "Accepted connection %d from %s:%d on socket %d.", idx, inet_ntoa( new_addr.sin_addr ), ntohs( new_addr.sin_port), Sock );
 602
 603         /* Hostnamen ermitteln */
 604         s = Resolve( inet_ntoa( new_addr.sin_addr ));
 605         if( s )
 606         {
 607                 /* Sub-Prozess wurde asyncron gestartet */
 608                 My_Connections[idx].res_stat = s;
 609         }
 610         else
 611         {
 612                 /* kann Namen nicht aufloesen */
 613                 strcpy( My_Connections[idx].host, inet_ntoa( new_addr.sin_addr ));
 614         }
 615 } /* New_Connection */
 616
 617
 618 LOCAL CONN_ID Socket2Index( INT Sock )
 619 {
 620         /* zum Socket passende Connection suchen */
 621
 622         CONN_ID idx;
 623
 624         assert( Sock >= 0 );
 625
 626         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == Sock ) break;
 627
 628         assert( idx < MAX_CONNECTIONS );
 629         return idx;
 630 } /* Socket2Index */
 631
 632
 633 LOCAL VOID Read_Request( CONN_ID Idx )
 634 {
 635         /* Daten von Socket einlesen und entsprechend behandeln.
 636          * Tritt ein Fehler auf, so wird der Socket geschlossen. */
 637
 638         INT len;
 639
 640         assert( Idx >= 0 );
 641         assert( My_Connections[Idx].sock >= 0 );
 642
 643         len = recv( My_Connections[Idx].sock, My_Connections[Idx].rbuf + My_Connections[Idx].rdatalen, READBUFFER_LEN - My_Connections[Idx].rdatalen, 0 );
 644         My_Connections[Idx].rbuf[READBUFFER_LEN] = '\0';
 645
 646         if( len == 0 )
 647         {
 648                 /* Socket wurde geschlossen */
 649                 Log( LOG_INFO, "%s:%d is closing the connection ...", inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port));
 650                 Conn_Close( Idx, NULL );
 651                 return;
 652         }
 653
 654         if( len < 0 )
 655         {
 656                 /* Fehler beim Lesen */
 657                 Log( LOG_ALERT, "Read error on connection %d: %s!", Idx, strerror( errno ));
 658                 Conn_Close( Idx, NULL );
 659                 return;
 660         }
 661
 662         /* Lesebuffer updaten */
 663         My_Connections[Idx].rdatalen += len;
 664         assert( My_Connections[Idx].rdatalen <= READBUFFER_LEN );
 665         My_Connections[Idx].rbuf[My_Connections[Idx].rdatalen] = '\0';
 666
 667         if( My_Connections[Idx].rdatalen > MAX_CMDLEN )
 668         {
 669                 /* Eine Anfrage darf(!) nicht laenger als 512 Zeichen
 670                  * (incl. CR+LF!) werden; vgl. RFC 2812. Wenn soetwas
 671                  * empfangen wird, wird der Client disconnectiert. */
 672                 Log( LOG_ALERT, "Request too long (connection %d)!", Idx );
 673                 Conn_Close( Idx, "Request too long!" );
 674                 return;
 675         }
 676
 677         /* Timestamp aktualisieren */
 678         My_Connections[Idx].lastdata = time( NULL );
 679
 680         Handle_Buffer( Idx );
 681 } /* Read_Request */
 682
 683
 684 LOCAL VOID Handle_Buffer( CONN_ID Idx )
 685 {
 686         CHAR *ptr, *ptr1, *ptr2;
 687         INT len, delta;
 688
 689         /* Eine komplette Anfrage muss mit CR+LF enden, vgl.
 690          * RFC 2812. Haben wir eine? */
 691         ptr = strstr( My_Connections[Idx].rbuf, "\r\n" );
 692
 693         if( ptr ) delta = 2;
 694         else
 695         {
 696                 /* Nicht RFC-konforme Anfrage mit nur CR oder LF? Leider
 697                  * machen soetwas viele Clients, u.a. "mIRC" :-( */
 698                 ptr1 = strchr( My_Connections[Idx].rbuf, '\r' );
 699                 ptr2 = strchr( My_Connections[Idx].rbuf, '\n' );
 700                 delta = 1;
 701                 if( ptr1 && ptr2 ) ptr = ptr1 > ptr2 ? ptr2 : ptr1;
 702                 else if( ptr1 ) ptr = ptr1;
 703                 else if( ptr2 ) ptr = ptr2;
 704         }
 705
 706         if( ptr )
 707         {
 708                 /* Ende der Anfrage wurde gefunden */
 709                 *ptr = '\0';
 710                 len = ( ptr - My_Connections[Idx].rbuf ) + delta;
 711                 if( len > delta )
 712                 {
 713                         /* Es wurde ein Request gelesen */
 714                         if( ! Parse_Request( Idx, My_Connections[Idx].rbuf )) return;
 715                 }
 716
 717                 /* Puffer anpassen */
 718                 My_Connections[Idx].rdatalen -= len;
 719                 memmove( My_Connections[Idx].rbuf, My_Connections[Idx].rbuf + len, My_Connections[Idx].rdatalen );
 720         }
 721 } /* Handle_Buffer */
 722
 723
 724 LOCAL VOID Check_Connections( VOID )
 725 {
 726         /* Pruefen, ob Verbindungen noch "alive" sind */
 727
 728         INT i;
 729
 730         for( i = 0; i < MAX_CONNECTIONS; i++ )
 731         {
 732                 if( My_Connections[i].sock != NONE )
 733                 {
 734                         if( My_Connections[i].lastping > My_Connections[i].lastdata )
 735                         {
 736                                 /* es wurde bereits ein PING gesendet */
 737                                 if( My_Connections[i].lastping < time( NULL ) - Conf_PongTimeout )
 738                                 {
 739                                         /* Timeout */
 740                                         Log( LOG_INFO, "Connection %d: Ping timeout.", i );
 741                                         Conn_Close( i, "Ping timeout" );
 742                                 }
 743                         }
 744                         else if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
 745                         {
 746                                 /* es muss ein PING gesendet werden */
 747                                 Log( LOG_DEBUG, "Connection %d: sending PING ...", i );
 748                                 My_Connections[i].lastping = time( NULL );
 749                                 Conn_WriteStr( i, "PING :%s", This_Server->nick );
 750                         }
 751                 }
 752         }
 753 } /* Conn_Check */
 754
 755
 756 LOCAL VOID Init_Conn_Struct( INT Idx )
 757 {
 758         /* Connection-Struktur initialisieren */
 759
 760         My_Connections[Idx].sock = NONE;
 761         My_Connections[Idx].res_stat = NULL;
 762         My_Connections[Idx].host[0] = '\0';
 763         My_Connections[Idx].rbuf[0] = '\0';
 764         My_Connections[Idx].rdatalen = 0;
 765         My_Connections[Idx].wbuf[0] = '\0';
 766         My_Connections[Idx].wdatalen = 0;
 767         My_Connections[Idx].lastdata = time( NULL );
 768         My_Connections[Idx].lastping = 0;
 769 } /* Init_Conn_Struct */
 770
 771
 772 LOCAL RES_STAT *Resolve( CHAR *Host )
 773 {
 774         /* Hostnamen (asyncron!) aufloesen. Bei Fehler, z.B. wenn der
 775          * Child-Prozess nicht erzeugt werden kann, wird NULL geliefert.
 776          * Der Host kann dann nicht aufgeloest werden. */
 777
 778         RES_STAT *s;
 779         INT pid;
 780
 781         s = malloc( sizeof( RES_STAT ));
 782         if( ! s )
 783         {
 784                 Log( LOG_ALERT, "Resolver: Can't alloc memory!" );
 785                 return NULL;
 786         }
 787
 788         if( pipe( s->out_pipe ) != 0 )
 789         {
 790                 free( s );
 791                 Log( LOG_ALERT, "Resolver: Can't create output pipe: %s!", strerror( errno ));
 792                 return NULL;
 793         }
 794
 795         if( pipe( s->in_pipe ) != 0 )
 796         {
 797                 free( s );
 798                 Log( LOG_ALERT, "Resolver: Can't create input pipe: %s!", strerror( errno ));
 799                 return NULL;
 800         }
 801
 802         pid = fork( );
 803         if( pid > 0 )
 804         {
 805                 /* Haupt-Prozess */
 806                 if( write( s->out_pipe[1], Host, strlen( Host ) + 1 ) != ( strlen( Host ) + 1 ))
 807                 {
 808                         free( s );
 809                         Log( LOG_ALERT, "Resolver: Can't write to child: %s!", strerror( errno ));
 810                         return NULL;
 811                 }
 812
 813                 FD_SET( s->in_pipe[0], &My_Resolvers );
 814                 if( s->in_pipe[0] > My_Max_Fd ) My_Max_Fd = s->in_pipe[0];
 815
 816                 s->pid = pid;
 817
 818                 Log( LOG_DEBUG, "Resolver process for \"%s\" (PID %d) created.", Host, pid );
 819                 return s;
 820         }
 821         else if( pid == 0 )
 822         {
 823                 /* Sub-Prozess */
 824                 Log_Init_Resolver( );
 825                 Do_Resolve( s->out_pipe[0], s->in_pipe[1] );
 826                 Log_Exit_Resolver( );
 827                 exit( 0 );
 828         }
 829         else
 830         {
 831                 /* Fehler */
 832                 free( s );
 833                 Log( LOG_ALERT, "Resolver: Can't fork: %s!", strerror( errno ));
 834                 return NULL;
 835         }
 836 } /* Resolve */
 837
 838
 839 LOCAL VOID Read_Resolver_Result( INT r_fd )
 840 {
 841         /* Ergebnis von Resolver Sub-Prozess aus Pipe lesen
 842          * und entsprechende Connection aktualisieren */
 843
 844         CHAR hostname[HOST_LEN];
 845         CLIENT *c;
 846         INT i;
 847
 848         FD_CLR( r_fd, &My_Resolvers );
 849
 850         /* Anfrage vom Parent lesen */
 851         if( read( r_fd, hostname, HOST_LEN) < 0 )
 852         {
 853                 /* Fehler beim Lesen aus der Pipe */
 854                 close( r_fd );
 855                 Log( LOG_ALERT, "Resolver: Can't read result: %s!", strerror( errno ));
 856                 return;
 857         }
 858
 859         for( i = 0; i < MAX_CONNECTIONS; i++ )
 860         {
 861                 /* zugehoerige Connection suchen */
 862                 if(( My_Connections[i].sock >= 0 ) && ( My_Connections[i].res_stat ) && ( My_Connections[i].res_stat->in_pipe[0] == r_fd )) break;
 863         }
 864
 865         if( i >= MAX_CONNECTIONS )
 866         {
 867                 /* Opsa! Keine passende Connection gefunden!? */
 868                 close( r_fd );
 869                 Log( LOG_ALERT, "Resolver: Got result for unknown connection!?" );
 870                 return;
 871         }
 872
 873         /* Aufraeumen */
 874         close( My_Connections[i].res_stat->out_pipe[0] );
 875         close( My_Connections[i].res_stat->out_pipe[1] );
 876         close( My_Connections[i].res_stat->in_pipe[0] );
 877         close( My_Connections[i].res_stat->in_pipe[1] );
 878         free( My_Connections[i].res_stat );
 879         My_Connections[i].res_stat = NULL;
 880
 881         /* Hostnamen setzen */
 882         strcpy( My_Connections[i].host, hostname );
 883         c = Client_GetFromConn( i );
 884         if( c )
 885         {
 886                 Log( LOG_DEBUG, "Set hostname: \"%s\".", hostname );
 887                 Client_SetHostname( c, hostname );
 888         }
 889 } /* Read_Resolver_Result */
 890
 891
 892 LOCAL VOID Do_Resolve( INT r_fd, INT w_fd )
 893 {
 894         /* Resolver Sub-Prozess: aufzuloesenden Namen aus
 895          * der Pipe lesen, Ergebnis in Pipe schreiben. */
 896
 897         CHAR host[HOST_LEN], res_host[HOST_LEN];
 898         struct hostent *h;
 899
 900         /* Anfrage vom Parent lesen */
 901         if( read( r_fd, host, HOST_LEN) < 0 )
 902         {
 903                 Log_Resolver( LOG_ALERT, "Resolver: Can't read from parent: %s!", strerror( errno ));
 904                 close( r_fd ); close( w_fd );
 905                 return;
 906         }
 907         host[HOST_LEN] = '\0';
 908
 909         Log_Resolver( LOG_DEBUG, "Now resolving \"%s\" ...", host );
 910
 911         /* Namen aufloesen */
 912         h = gethostbyname( host );
 913         if( h ) strcpy( res_host, h->h_name );
 914         else
 915         {
 916                 Log_Resolver( LOG_WARNING, "Can't resolce host name (code %d)!", h_errno );
 917                 strcpy( res_host, host );
 918         }
 919
 920         /* Antwort an Parent schreiben */
 921         if( write( w_fd, res_host, strlen( res_host ) + 1 ) != ( strlen( res_host ) + 1 ))
 922         {
 923                 Log_Resolver( LOG_ALERT, "Resolver: Can't write to parent: %s!", strerror( errno ));
 924                 close( r_fd ); close( w_fd );
 925                 return;
 926         }
 927
 928         Log_Resolver( LOG_DEBUG, "Ok, translated \"%s\" to \"%s\".", host, res_host );
 929 } /* Do_Resolve */
 930
 931
 932 /* -eof- */