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.6 2001/12/15 00:11:55 alex Exp $
  13  *
  14  * connect.h: Verwaltung aller Netz-Verbindungen ("connections")
  15  *
  16  * $Log: conn.c,v $
  17  * Revision 1.6  2001/12/15 00:11:55  alex
  18  * - Lese- und Schreib-Puffer implementiert.
  19  * - einige neue (Unter-)Funktionen eingefuehrt.
  20  * - diverse weitere kleinere Aenderungen.
  21  *
  22  * Revision 1.5  2001/12/14 08:16:47  alex
  23  * - Begonnen, Client-spezifische Lesepuffer zu implementieren.
  24  * - Umstellung auf Datentyp "CONN_ID".
  25  *
  26  * Revision 1.4  2001/12/13 02:04:16  alex
  27  * - boesen "Speicherschiesser" in Log() gefixt.
  28  *
  29  * Revision 1.3  2001/12/13 01:33:09  alex
  30  * - Conn_Handler() unterstuetzt nun einen Timeout.
  31  * - fuer Verbindungen werden keine FILE-Handles mehr benutzt.
  32  * - kleinere "Code Cleanups" ;-)
  33  *
  34  * Revision 1.2  2001/12/12 23:32:02  alex
  35  * - diverse Erweiterungen und Verbesserungen (u.a. sind nun mehrere
  36  *   Verbindungen und Listen-Sockets moeglich).
  37  *
  38  * Revision 1.1  2001/12/12 17:18:38  alex
  39  * - Modul zur Verwaltung aller Netzwerk-Verbindungen begonnen.
  40  */
  41
  42
  43 #include <portab.h>
  44 #include "global.h"
  45
  46 #include <imp.h>
  47 #include <assert.h>
  48 #include <stdio.h>
  49 #include <unistd.h>
  50 #include <errno.h>
  51 #include <fcntl.h>
  52 #include <string.h>
  53 #include <sys/socket.h>
  54 #include <sys/time.h>
  55 #include <sys/types.h>
  56 #include <netinet/in.h>
  57 #include <arpa/inet.h>
  58
  59 #ifdef HAVE_STDINT_H
  60 #include <stdint.h>                     /* u.a. fuer Mac OS X */
  61 #endif
  62
  63 #include "ngircd.h"
  64 #include "log.h"
  65 #include "tool.h"
  66
  67 #include <exp.h>
  68 #include "conn.h"
  69
  70
  71 #define MAX_CONNECTIONS 100             /* max. Anzahl von Verbindungen an diesem Server */
  72
  73 #define MAX_CMDLEN 512                  /* max. Laenge eines Befehls, vgl. RFC 2812, 3.2 */
  74
  75 #define READBUFFER_LEN 2 * MAX_CMDLEN   /* Laenge des Lesepuffers je Verbindung (Bytes) */
  76 #define WRITEBUFFER_LEN 4096            /* Laenge des Schreibpuffers je Verbindung (Bytes) */
  77
  78
  79 typedef struct _Connection
  80 {
  81         INT sock;                       /* Socket Handle */
  82         struct sockaddr_in addr;        /* Adresse des Client */
  83         CHAR rbuf[READBUFFER_LEN + 1];  /* Lesepuffer */
  84         INT rdatalen;                   /* Laenge der Daten im Lesepuffer */
  85         CHAR wbuf[WRITEBUFFER_LEN + 1]; /* Schreibpuffer */
  86         INT wdatalen;                   /* Laenge der Daten im Schreibpuffer */
  87 } CONNECTION;
  88
  89
  90 LOCAL VOID Handle_Read( INT sock );
  91 LOCAL BOOLEAN Handle_Write( CONN_ID Idx );
  92 LOCAL VOID New_Connection( INT Sock );
  93 LOCAL CONN_ID Socket2Index( INT Sock );
  94 LOCAL VOID Close_Connection( CONN_ID Idx, CHAR *Msg );
  95 LOCAL VOID Read_Request( CONN_ID Idx );
  96 LOCAL BOOLEAN Try_Write( CONN_ID Idx );
  97
  98
  99 LOCAL fd_set My_Listener;
 100 LOCAL fd_set My_Sockets;
 101
 102 LOCAL INT My_Max_Fd;
 103
 104 LOCAL CONNECTION My_Connections[MAX_CONNECTIONS];
 105
 106
 107 GLOBAL VOID Conn_Init( VOID )
 108 {
 109         CONN_ID i;
 110
 111         /* zu Beginn haben wir keine Verbindungen */
 112         FD_ZERO( &My_Listener );
 113         FD_ZERO( &My_Sockets );
 114
 115         My_Max_Fd = 0;
 116
 117         /* Connection-Struktur initialisieren */
 118         for( i = 0; i < MAX_CONNECTIONS; i++ ) My_Connections[i].sock = NONE;
 119 } /* Conn_Init */
 120
 121
 122 GLOBAL VOID Conn_Exit( VOID )
 123 {
 124         CONN_ID idx;
 125         INT i;
 126
 127         /* Sockets schliessen */
 128         for( i = 0; i < My_Max_Fd + 1; i++ )
 129         {
 130                 if( FD_ISSET( i, &My_Sockets ))
 131                 {
 132                         for( idx = 0; idx < MAX_CONNECTIONS; idx++ )
 133                         {
 134                                 if( My_Connections[idx].sock == i ) break;
 135                         }
 136                         if( idx < MAX_CONNECTIONS ) Close_Connection( idx, "Server going down ..." );
 137                         else if( FD_ISSET( i, &My_Listener ))
 138                         {
 139                                 close( i );
 140                                 Log( LOG_INFO, "Closed listening socket %d.", i );
 141                         }
 142                         else
 143                         {
 144                                 close( i );
 145                                 Log( LOG_WARNING, "Unknown connection %d closed.", i );
 146                         }
 147                 }
 148         }
 149 } /* Conn_Exit */
 150
 151
 152 GLOBAL BOOLEAN Conn_New_Listener( CONST INT Port )
 153 {
 154         /* Neuen Listen-Socket erzeugen: der Server wartet dann
 155          * auf dem angegebenen Port auf Verbindungen. */
 156
 157         struct sockaddr_in addr;
 158         INT sock, on = 1;
 159
 160         /* Server-"Listen"-Socket initialisieren */
 161         memset( &addr, 0, sizeof( addr ));
 162         addr.sin_family = AF_INET;
 163         addr.sin_port = htons( Port );
 164         addr.sin_addr.s_addr = htonl( INADDR_ANY );
 165
 166         /* Socket erzeugen */
 167         sock = socket( PF_INET, SOCK_STREAM, 0);
 168         if( sock < 0 )
 169         {
 170                 Log( LOG_ALERT, "Can't create socket: %s", strerror( errno ));
 171                 return FALSE;
 172         }
 173
 174         /* Socket-Optionen setzen */
 175         if( fcntl( sock, F_SETFL, O_NONBLOCK ) != 0 )
 176         {
 177                 Log( LOG_ALERT, "Can't enable non-blocking mode: %s", strerror( errno ));
 178                 close( sock );
 179                 return FALSE;
 180         }
 181         if( setsockopt( sock, SOL_SOCKET, SO_REUSEADDR, &on, (socklen_t)sizeof( on )) != 0)
 182         {
 183                 Log( LOG_CRIT, "Can't set socket options: %s", strerror( errno ));
 184                 /* dieser Fehler kann ignoriert werden. */
 185         }
 186
 187         /* an Port binden */
 188         if( bind( sock, (struct sockaddr *)&addr, (socklen_t)sizeof( addr )) != 0 )
 189         {
 190                 Log( LOG_ALERT, "Can't bind socket: %s", strerror( errno ));
 191                 close( sock );
 192                 return FALSE;
 193         }
 194
 195         /* in "listen mode" gehen :-) */
 196         if( listen( sock, 10 ) != 0 )
 197         {
 198                 Log( LOG_ALERT, "Can't listen on soecket: %s", strerror( errno ));
 199                 close( sock );
 200                 return FALSE;
 201         }
 202
 203         /* Neuen Listener in Strukturen einfuegen */
 204         FD_SET( sock, &My_Listener );
 205         FD_SET( sock, &My_Sockets );
 206
 207         if( sock > My_Max_Fd ) My_Max_Fd = sock;
 208
 209         Log( LOG_INFO, "Now listening on port %d, socket %d.", Port, sock );
 210
 211         return TRUE;
 212 } /* Conn_New_Listener */
 213
 214
 215 GLOBAL VOID Conn_Handler( INT Timeout )
 216 {
 217         fd_set read_sockets, write_sockets;
 218         struct timeval tv;
 219         INT i;
 220
 221         /* Timeout initialisieren */
 222         tv.tv_sec = Timeout;
 223         tv.tv_usec = 0;
 224
 225         /* noch volle Schreib-Puffer suchen */
 226         FD_ZERO( &write_sockets );
 227         for( i = 0; i < MAX_CONNECTIONS; i++ )
 228         {
 229                 if(( My_Connections[i].sock >= 0 ) && ( My_Connections[i].wdatalen > 0 ))
 230                 {
 231                         /* Socket der Verbindung in Set aufnehmen */
 232                         FD_SET( My_Connections[i].sock, &write_sockets );
 233                 }
 234         }
 235
 236         read_sockets = My_Sockets;
 237         if( select( My_Max_Fd + 1, &read_sockets, &write_sockets, NULL, &tv ) == -1 )
 238         {
 239                 if( errno != EINTR ) Log( LOG_ALERT, "select(): %s", strerror( errno ));
 240                 return;
 241         }
 242
 243         /* Koennen Daten geschrieben werden? */
 244         for( i = 0; i < My_Max_Fd + 1; i++ )
 245         {
 246                 if( FD_ISSET( i, &write_sockets )) Handle_Write( Socket2Index( i ));
 247         }
 248
 249         /* Daten zum Lesen vorhanden? */
 250         for( i = 0; i < My_Max_Fd + 1; i++ )
 251         {
 252                 if( FD_ISSET( i, &read_sockets )) Handle_Read( i );
 253         }
 254 } /* Conn_Handler */
 255
 256
 257 GLOBAL BOOLEAN Conn_WriteStr( CONN_ID Idx, CHAR *Data )
 258 {
 259         /* String in Socket schreiben. CR+LF wird von dieser Funktion
 260          * automatisch angehaengt. */
 261
 262         CHAR buffer[MAX_CMDLEN];
 263
 264         if( strlen( Data ) > MAX_CMDLEN - 2 )
 265         {
 266                 Log( LOG_ALERT, "String too long to send (connection %d)!", Idx );
 267                 Close_Connection( Idx, "Server error: String too long to send!" );
 268                 return FALSE;
 269         }
 270
 271         sprintf( buffer, "%s\r\n", Data );
 272         return Conn_Write( Idx, buffer, strlen( buffer ));
 273 } /* Conn_WriteStr */
 274
 275
 276 GLOBAL BOOLEAN Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
 277 {
 278         /* Daten in Socket schreiben. Bei "fatalen" Fehlern wird
 279          * der Client disconnectiert und FALSE geliefert. */
 280
 281         assert( Idx >= 0 );
 282         assert( My_Connections[Idx].sock >= 0 );
 283         assert( Data != NULL );
 284         assert( Len > 0 );
 285
 286         /* pruefen, ob Daten im Schreibpuffer sind. Wenn ja, zunaechst
 287          * pruefen, ob diese gesendet werden koennen */
 288         if( My_Connections[Idx].wdatalen > 0 )
 289         {
 290                 if( ! Try_Write( Idx )) return FALSE;
 291         }
 292
 293         /* pruefen, ob im Schreibpuffer genuegend Platz ist */
 294         if( WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - Len <= 0 )
 295         {
 296                 /* der Puffer ist dummerweise voll ... */
 297                 Log( LOG_NOTICE, "Write buffer overflow (connection %d)!", Idx );
 298                 Close_Connection( Idx, NULL );
 299                 return FALSE;
 300         }
 301
 302         /* Daten in Puffer kopieren */
 303         memcpy( My_Connections[Idx].wbuf + My_Connections[Idx].wdatalen, Data, Len );
 304         My_Connections[Idx].wdatalen += Len;
 305
 306         /* pruefen, on Daten vorhanden sind und geschrieben werden koennen */
 307         if( My_Connections[Idx].wdatalen > 0 )
 308         {
 309                 if( ! Try_Write( Idx )) return FALSE;
 310         }
 311
 312         return TRUE;
 313 } /* Conn_Write */
 314
 315
 316 LOCAL BOOLEAN Try_Write( CONN_ID Idx )
 317 {
 318         /* Versuchen, Daten aus dem Schreib-Puffer in den
 319          * Socket zu schreiben. */
 320
 321         fd_set write_socket;
 322
 323         assert( Idx >= 0 );
 324         assert( My_Connections[Idx].sock >= 0 );
 325         assert( My_Connections[Idx].wdatalen > 0 );
 326
 327         FD_ZERO( &write_socket );
 328         FD_SET( My_Connections[Idx].sock, &write_socket );
 329         if( select( My_Connections[Idx].sock + 1, NULL, &write_socket, NULL, 0 ) == -1 )
 330         {
 331                 /* Fehler! */
 332                 if( errno != EINTR )
 333                 {
 334                         Log( LOG_ALERT, "select(): %s", strerror( errno ));
 335                         Close_Connection( Idx, NULL );
 336                         return FALSE;
 337                 }
 338         }
 339
 340         if( FD_ISSET( My_Connections[Idx].sock, &write_socket )) return Handle_Write( Idx );
 341         else return TRUE;
 342 } /* Try_Write */
 343
 344
 345 LOCAL VOID Handle_Read( INT Sock )
 346 {
 347         /* Aktivitaet auf einem Socket verarbeiten */
 348
 349         CONN_ID idx;
 350
 351         assert( Sock >= 0 );
 352
 353         if( FD_ISSET( Sock, &My_Listener ))
 354         {
 355                 /* es ist einer unserer Listener-Sockets: es soll
 356                  * also eine neue Verbindung aufgebaut werden. */
 357
 358                 New_Connection( Sock );
 359         }
 360         else
 361         {
 362                 /* Ein Client Socket: entweder ein User oder Server */
 363
 364                 idx = Socket2Index( Sock );
 365                 Read_Request( idx );
 366         }
 367 } /* Handle_Read */
 368
 369
 370 LOCAL BOOLEAN Handle_Write( CONN_ID Idx )
 371 {
 372         /* Daten aus Schreibpuffer versenden */
 373
 374         INT len;
 375
 376         assert( Idx >= 0 );
 377         assert( My_Connections[Idx].sock >= 0 );
 378         assert( My_Connections[Idx].wdatalen > 0 );
 379
 380         /* Daten schreiben */
 381         len = send( My_Connections[Idx].sock, My_Connections[Idx].wbuf, My_Connections[Idx].wdatalen, 0 );
 382         if( len < 0 )
 383         {
 384                 /* Oops, ein Fehler! */
 385                 Log( LOG_ALERT, "Write error (buffer) on connection %d: %s", Idx, strerror( errno ));
 386                 Close_Connection( Idx, NULL );
 387                 return FALSE;
 388         }
 389
 390         /* Puffer anpassen */
 391         My_Connections[Idx].wdatalen -= len;
 392         memmove( My_Connections[Idx].wbuf, My_Connections[Idx].wbuf + len, My_Connections[Idx].wdatalen );
 393
 394         return TRUE;
 395 } /* Handle_Write */
 396
 397
 398 LOCAL VOID New_Connection( INT Sock )
 399 {
 400         /* Neue Client-Verbindung von Listen-Socket annehmen */
 401
 402         struct sockaddr_in new_addr;
 403         INT new_sock, new_sock_len;
 404         CONN_ID idx;
 405
 406         assert( Sock >= 0 );
 407
 408         new_sock_len = sizeof( new_addr );
 409         new_sock = accept( Sock, (struct sockaddr *)&new_addr, (socklen_t *)&new_sock_len );
 410         if( new_sock < 0 )
 411         {
 412                 Log( LOG_CRIT, "Can't accept connection: %s", strerror( errno ));
 413                 return;
 414         }
 415
 416         /* Freie Connection-Struktur suschen */
 417         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock < 0 ) break;
 418         if( idx >= MAX_CONNECTIONS )
 419         {
 420                 Log( LOG_ALERT, "Can't accept connection: limit reached (%d)!", MAX_CONNECTIONS );
 421                 close( new_sock );
 422                 return;
 423         }
 424
 425         /* Verbindung registrieren */
 426         My_Connections[idx].sock = new_sock;
 427         My_Connections[idx].addr = new_addr;
 428         My_Connections[idx].rdatalen = 0;
 429         My_Connections[idx].wdatalen = 0;
 430
 431         /* Neuen Socket registrieren */
 432         FD_SET( new_sock, &My_Sockets );
 433
 434         if( new_sock > My_Max_Fd ) My_Max_Fd = new_sock;
 435
 436         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 );
 437 } /* New_Connection */
 438
 439
 440 LOCAL CONN_ID Socket2Index( INT Sock )
 441 {
 442         /* zum Socket passende Connection suchen */
 443
 444         CONN_ID idx;
 445
 446         assert( Sock >= 0 );
 447
 448         for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == Sock ) break;
 449
 450         assert( idx < MAX_CONNECTIONS );
 451         return idx;
 452 } /* Socket2Index */
 453
 454
 455 LOCAL VOID Close_Connection( CONN_ID Idx, CHAR *Msg )
 456 {
 457         /* Verbindung schlie§en */
 458
 459         CHAR bye_str[MAX_CMDLEN];
 460
 461         assert( Idx >= 0 );
 462         assert( My_Connections[Idx].sock >= 0 );
 463
 464         if( Msg )
 465         {
 466                 sprintf( bye_str, "ERROR :%s", Msg );
 467                 Conn_WriteStr( Idx, bye_str );
 468         }
 469
 470         if( close( My_Connections[Idx].sock ) != 0 )
 471         {
 472                 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 ));
 473         }
 474         else
 475         {
 476                 Log( LOG_NOTICE, "Closed connection %d with %s:%d.", Idx, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port ));
 477         }
 478
 479         FD_CLR( My_Connections[Idx].sock, &My_Sockets );
 480         My_Connections[Idx].sock = NONE;
 481 } /* Close_Connection */
 482
 483
 484 LOCAL VOID Read_Request( CONN_ID Idx )
 485 {
 486         /* Daten von Socket einlesen und entsprechend behandeln.
 487          * Tritt ein Fehler auf, so wird der Socket geschlossen. */
 488
 489         INT len;
 490         CHAR *ptr;
 491
 492         assert( Idx >= 0 );
 493         assert( My_Connections[Idx].sock >= 0 );
 494
 495         len = recv( My_Connections[Idx].sock, My_Connections[Idx].rbuf + My_Connections[Idx].rdatalen, READBUFFER_LEN - My_Connections[Idx].rdatalen, 0 );
 496         My_Connections[Idx].rbuf[READBUFFER_LEN] = '\0';
 497
 498         if( len == 0 )
 499         {
 500                 /* Socket wurde geschlossen */
 501                 Close_Connection( Idx, NULL );
 502                 return;
 503         }
 504
 505         if( len < 0 )
 506         {
 507                 /* Fehler beim Lesen */
 508                 Log( LOG_ALERT, "Read error on connection %d!", Idx );
 509                 Close_Connection( Idx, "Read error!" );
 510                 return;
 511         }
 512
 513         My_Connections[Idx].rdatalen += len;
 514         assert( My_Connections[Idx].rdatalen <= READBUFFER_LEN );
 515         My_Connections[Idx].rbuf[My_Connections[Idx].rdatalen] = '\0';
 516
 517         if( My_Connections[Idx].rdatalen > MAX_CMDLEN )
 518         {
 519                 /* Eine Anfrage darf(!) nicht laenger als 512 Zeichen
 520                  * (incl. CR+LF!) werden; vgl. RFC 2812. Wenn soetwas
 521                  * empfangen wird, wird der Client disconnectiert. */
 522                 Log( LOG_ALERT, "Request too long (connection %d)!", Idx );
 523                 Close_Connection( Idx, "Request too long!" );
 524                 return;
 525         }
 526
 527         /* Eine komplette Anfrage muss mit CR+LF enden, vgl.
 528          * RFC 2812. Haben wir eine? */
 529         ptr = strstr( My_Connections[Idx].rbuf, "\r\n" );
 530         if( ptr )
 531         {
 532                 /* Ende der Anfrage (CR+LF) wurde gefunden */
 533                 *ptr = '\0';
 534                 len = ( ptr - My_Connections[Idx].rbuf ) + 2;
 535                 if( len > 2 )
 536                 {
 537                         printf( " in: '%s'\n", My_Connections[Idx].rbuf );
 538                 }
 539                 else Log( LOG_DEBUG, "Got null-request (connection %d).", Idx );
 540
 541                 /* Puffer anpassen */
 542                 My_Connections[Idx].rdatalen -= len;
 543                 memmove( My_Connections[Idx].rbuf, My_Connections[Idx].rbuf + len, My_Connections[Idx].rdatalen );
 544         }
 545 } /* Read_Request */
 546
 547
 548 /* -eof- */