src/ngircd/conn.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001-2009 Alexander Barton (alex@barton.de)
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  * Please read the file COPYING, README and AUTHORS for more information.
  10  *
  11  * Connection management
  12  */
  13
  14
  15 #define CONN_MODULE
  16
  17 #include "portab.h"
  18 #include "conf-ssl.h"
  19 #include "io.h"
  20
  21 #include "imp.h"
  22 #include <assert.h>
  23 #ifdef PROTOTYPES
  24 #       include <stdarg.h>
  25 #else
  26 #       include <varargs.h>
  27 #endif
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <string.h>
  33 #include <sys/socket.h>
  34 #include <sys/time.h>
  35 #include <sys/types.h>
  36 #include <time.h>
  37 #include <netinet/in.h>
  38
  39 #ifdef HAVE_NETINET_IP_H
  40 # ifdef HAVE_NETINET_IN_SYSTM_H
  41 #  include <netinet/in_systm.h>
  42 # endif
  43 # include <netinet/ip.h>
  44 #endif
  45
  46 #ifdef HAVE_STDINT_H
  47 # include <stdint.h>                    /* e.g. for Mac OS X */
  48 #endif
  49
  50 #ifdef TCPWRAP
  51 # include <tcpd.h>                      /* for TCP Wrappers */
  52 #endif
  53
  54 #include "array.h"
  55 #include "defines.h"
  56 #include "resolve.h"
  57
  58 #include "exp.h"
  59 #include "conn.h"
  60
  61 #include "imp.h"
  62 #include "ngircd.h"
  63 #include "client.h"
  64 #include "conf.h"
  65 #include "conn-ssl.h"
  66 #include "conn-zip.h"
  67 #include "conn-func.h"
  68 #include "log.h"
  69 #include "parse.h"
  70 #include "tool.h"
  71
  72 #ifdef ZEROCONF
  73 # include "rendezvous.h"
  74 #endif
  75
  76 #include "exp.h"
  77
  78
  79 #define SERVER_WAIT (NONE - 1)
  80
  81 #define MAX_COMMANDS 3
  82 #define MAX_COMMANDS_SERVER 10
  83
  84
  85 static bool Handle_Write PARAMS(( CONN_ID Idx ));
  86 static bool Conn_Write PARAMS(( CONN_ID Idx, char *Data, size_t Len ));
  87 static int New_Connection PARAMS(( int Sock ));
  88 static CONN_ID Socket2Index PARAMS(( int Sock ));
  89 static void Read_Request PARAMS(( CONN_ID Idx ));
  90 static unsigned int Handle_Buffer PARAMS(( CONN_ID Idx ));
  91 static void Check_Connections PARAMS(( void ));
  92 static void Check_Servers PARAMS(( void ));
  93 static void Init_Conn_Struct PARAMS(( CONN_ID Idx ));
  94 static bool Init_Socket PARAMS(( int Sock ));
  95 static void New_Server PARAMS(( int Server, ng_ipaddr_t *dest ));
  96 static void Simple_Message PARAMS(( int Sock, const char *Msg ));
  97 static int NewListener PARAMS(( const char *listen_addr, UINT16 Port ));
  98
  99 static array My_Listeners;
 100 static array My_ConnArray;
 101 static size_t NumConnections;
 102
 103 #ifdef TCPWRAP
 104 int allow_severity = LOG_INFO;
 105 int deny_severity = LOG_ERR;
 106 #endif
 107
 108 static void server_login PARAMS((CONN_ID idx));
 109
 110 #ifdef SSL_SUPPORT
 111 extern struct SSLOptions Conf_SSLOptions;
 112 static void cb_connserver_login_ssl PARAMS((int sock, short what));
 113 static void cb_clientserver_ssl PARAMS((int sock, short what));
 114 #endif
 115 static void cb_Read_Resolver_Result PARAMS((int sock, UNUSED short what));
 116 static void cb_Connect_to_Server PARAMS((int sock, UNUSED short what));
 117 static void cb_clientserver PARAMS((int sock, short what));
 118
 119
 120 /**
 121  * IO callback for listening sockets: handle new connections. This callback
 122  * gets called when a new non-SSL connection should be accepted.
 123  * @param sock Socket descriptor
 124  * @param irrelevant (ignored IO specification)
 125  */
 126 static void
 127 cb_listen(int sock, short irrelevant)
 128 {
 129         (void) irrelevant;
 130         (void) New_Connection(sock);
 131 }
 132
 133
 134 #ifdef SSL_SUPPORT
 135 /**
 136  * IO callback for listening SSL sockets: handle new connections. This callback
 137  * gets called when a new SSL-enabled connection should be accepted.
 138  * @param sock Socket descriptor
 139  * @param irrelevant (ignored IO specification)
 140  */
 141 static void
 142 cb_listen_ssl(int sock, short irrelevant)
 143 {
 144         int fd;
 145
 146         (void) irrelevant;
 147         fd = New_Connection(sock);
 148         if (fd < 0)
 149                 return;
 150         io_event_setcb(My_Connections[fd].sock, cb_clientserver_ssl);
 151 }
 152 #endif
 153
 154
 155 /**
 156  * IO callback for new outgoing non-SSL server connections.
 157  * @param sock Socket descriptor
 158  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 159  */
 160 static void
 161 cb_connserver(int sock, UNUSED short what)
 162 {
 163         int res, err, server;
 164         socklen_t sock_len;
 165         CONN_ID idx = Socket2Index( sock );
 166
 167         if (idx <= NONE) {
 168                 LogDebug("cb_connserver wants to write on unknown socket?!");
 169                 io_close(sock);
 170                 return;
 171         }
 172
 173         assert(what & IO_WANTWRITE);
 174
 175         /* Make sure that the server is still configured; it could have been
 176          * removed in the meantime! */
 177         server = Conf_GetServer(idx);
 178         if (server < 0) {
 179                 Log(LOG_ERR, "Connection on socket %d to \"%s\" aborted!",
 180                     sock, My_Connections[idx].host);
 181                 Conn_Close(idx, "Connection aborted!", NULL, false);
 182                 return;
 183         }
 184
 185         /* connect() finished, get result. */
 186         sock_len = (socklen_t)sizeof(err);
 187         res = getsockopt(My_Connections[idx].sock, SOL_SOCKET, SO_ERROR,
 188                          &err, &sock_len );
 189         assert(sock_len == sizeof(err));
 190
 191         /* Error while connecting? */
 192         if ((res != 0) || (err != 0)) {
 193                 if (res != 0)
 194                         Log(LOG_CRIT, "getsockopt (connection %d): %s!",
 195                             idx, strerror(errno));
 196                 else
 197                         Log(LOG_CRIT,
 198                             "Can't connect socket to \"%s:%d\" (connection %d): %s!",
 199                             My_Connections[idx].host, Conf_Server[server].port,
 200                             idx, strerror(err));
 201
 202                 Conn_Close(idx, "Can't connect!", NULL, false);
 203
 204                 if (ng_ipaddr_af(&Conf_Server[server].dst_addr[0])) {
 205                         /* more addresses to try... */
 206                         New_Server(res, &Conf_Server[server].dst_addr[0]);
 207                         /* connection to dst_addr[0] is now in progress, so
 208                          * remove this address... */
 209                         Conf_Server[server].dst_addr[0] =
 210                                 Conf_Server[server].dst_addr[1];
 211                         memset(&Conf_Server[server].dst_addr[1], 0,
 212                                sizeof(Conf_Server[server].dst_addr[1]));
 213                 }
 214                 return;
 215         }
 216
 217         /* connect() succeeded, remove all additional addresses */
 218         memset(&Conf_Server[server].dst_addr, 0,
 219                sizeof(Conf_Server[server].dst_addr));
 220
 221         Conn_OPTION_DEL( &My_Connections[idx], CONN_ISCONNECTING );
 222 #ifdef SSL_SUPPORT
 223         if ( Conn_OPTION_ISSET( &My_Connections[idx], CONN_SSL_CONNECT )) {
 224                 io_event_setcb( sock, cb_connserver_login_ssl );
 225                 io_event_add( sock, IO_WANTWRITE|IO_WANTREAD );
 226                 return;
 227         }
 228 #endif
 229         server_login(idx);
 230 }
 231
 232
 233 /**
 234  * Login to a remote server.
 235  * @param idx Connection index
 236  */
 237 static void
 238 server_login(CONN_ID idx)
 239 {
 240         Log( LOG_INFO, "Connection %d with \"%s:%d\" established. Now logging in ...", idx,
 241                         My_Connections[idx].host, Conf_Server[Conf_GetServer( idx )].port );
 242
 243         io_event_setcb( My_Connections[idx].sock, cb_clientserver);
 244         io_event_add( My_Connections[idx].sock, IO_WANTREAD|IO_WANTWRITE);
 245
 246         /* Send PASS and SERVER command to peer */
 247         Conn_WriteStr( idx, "PASS %s %s", Conf_Server[Conf_GetServer( idx )].pwd_out, NGIRCd_ProtoID );
 248         Conn_WriteStr( idx, "SERVER %s :%s", Conf_ServerName, Conf_ServerInfo );
 249 }
 250
 251
 252 #ifdef SSL_SUPPORT
 253 /**
 254  * IO callback for new outgoing SSL-enabled server connections.
 255  * @param sock Socket descriptor
 256  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 257  */
 258 static void
 259 cb_connserver_login_ssl(int sock, short unused)
 260 {
 261         CONN_ID idx = Socket2Index(sock);
 262
 263         assert(idx >= 0);
 264         if (idx < 0) {
 265                 io_close(sock);
 266                 return;
 267         }
 268         (void) unused;
 269         switch (ConnSSL_Connect( &My_Connections[idx])) {
 270         case 1: break;
 271         case 0: LogDebug("ConnSSL_Connect: not ready");
 272                 return;
 273         case -1:
 274                 Log(LOG_ERR, "SSL connection on socket %d failed!", sock);
 275                 Conn_Close(idx, "Can't connect!", NULL, false);
 276                 return;
 277         }
 278
 279         Log( LOG_INFO, "SSL connection %d with \"%s:%d\" established.", idx,
 280                         My_Connections[idx].host, Conf_Server[Conf_GetServer( idx )].port );
 281
 282         server_login(idx);
 283 }
 284 #endif
 285
 286
 287 /**
 288  * IO callback for established non-SSL client and server connections.
 289  * @param sock Socket descriptor
 290  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 291  */
 292 static void
 293 cb_clientserver(int sock, short what)
 294 {
 295         CONN_ID idx = Socket2Index(sock);
 296
 297         assert(idx >= 0);
 298
 299         if (idx < 0) {
 300                 io_close(sock);
 301                 return;
 302         }
 303 #ifdef SSL_SUPPORT
 304         if (what & IO_WANTREAD
 305             || (Conn_OPTION_ISSET(&My_Connections[idx], CONN_SSL_WANT_WRITE))) {
 306                 /* if TLS layer needs to write additional data, call
 307                  * Read_Request() instead so that SSL/TLS can continue */
 308                 Read_Request(idx);
 309         }
 310 #else
 311         if (what & IO_WANTREAD)
 312                 Read_Request(idx);
 313 #endif
 314         if (what & IO_WANTWRITE)
 315                 Handle_Write(idx);
 316 }
 317
 318
 319 #ifdef SSL_SUPPORT
 320 /**
 321  * IO callback for established SSL-enabled client and server connections.
 322  * @param sock Socket descriptor
 323  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 324  */
 325 static void
 326 cb_clientserver_ssl(int sock, short what)
 327 {
 328         CONN_ID idx = Socket2Index(sock);
 329
 330         assert(idx >= 0);
 331
 332         if (idx < 0) {
 333                 io_close(sock);
 334                 return;
 335         }
 336
 337         switch (ConnSSL_Accept(&My_Connections[idx])) {
 338         case 1:
 339                 break;  /* OK */
 340         case 0:
 341                 return; /* EAGAIN: callback will be invoked again by IO layer */
 342         default:
 343                 Conn_Close(idx, "Socket closed!", "SSL accept error", false);
 344                 return;
 345         }
 346         if (what & IO_WANTREAD)
 347                 Read_Request(idx);
 348
 349         if (what & IO_WANTWRITE)
 350                 Handle_Write(idx);
 351
 352         io_event_setcb(sock, cb_clientserver);  /* SSL handshake completed */
 353 }
 354 #endif
 355
 356
 357 /**
 358  * Initialite connecion module.
 359  */
 360 GLOBAL void
 361 Conn_Init( void )
 362 {
 363         CONN_ID i;
 364
 365         /* Speicher fuer Verbindungs-Pool anfordern */
 366         Pool_Size = CONNECTION_POOL;
 367         if ((Conf_MaxConnections > 0) &&
 368                 (Pool_Size > Conf_MaxConnections))
 369                         Pool_Size = Conf_MaxConnections;
 370
 371         if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)Pool_Size)) {
 372                 Log( LOG_EMERG, "Can't allocate memory! [Conn_Init]" );
 373                 exit( 1 );
 374         }
 375
 376         /* FIXME: My_Connetions/Pool_Size is needed by other parts of the
 377          * code; remove them! */
 378         My_Connections = (CONNECTION*) array_start(&My_ConnArray);
 379
 380         LogDebug("Allocated connection pool for %d items (%ld bytes).",
 381                 array_length(&My_ConnArray, sizeof( CONNECTION )), array_bytes(&My_ConnArray));
 382
 383         assert( array_length(&My_ConnArray, sizeof( CONNECTION )) >= (size_t) Pool_Size);
 384
 385         array_free( &My_Listeners );
 386
 387         /* Connection-Struktur initialisieren */
 388         for( i = 0; i < Pool_Size; i++ ) Init_Conn_Struct( i );
 389
 390         /* Global write counter */
 391         WCounter = 0;
 392 } /* Conn_Init */
 393
 394
 395 /**
 396  * Clean up connection module.
 397  */
 398 GLOBAL void
 399 Conn_Exit( void )
 400 {
 401         CONN_ID idx;
 402
 403         Conn_ExitListeners();
 404
 405         LogDebug("Shutting down all connections ..." );
 406         for( idx = 0; idx < Pool_Size; idx++ ) {
 407                 if( My_Connections[idx].sock > NONE ) {
 408                         Conn_Close( idx, NULL, NGIRCd_SignalRestart ?
 409                                 "Server going down (restarting)":"Server going down", true );
 410                 }
 411         }
 412
 413         array_free(&My_ConnArray);
 414         My_Connections = NULL;
 415         Pool_Size = 0;
 416         io_library_shutdown();
 417 } /* Conn_Exit */
 418
 419
 420 static unsigned int
 421 ports_initlisteners(array *a, const char *listen_addr, void (*func)(int,short))
 422 {
 423         unsigned int created = 0;
 424         size_t len;
 425         int fd;
 426         UINT16 *port;
 427
 428         len = array_length(a, sizeof (UINT16));
 429         port = array_start(a);
 430         while (len--) {
 431                 fd = NewListener(listen_addr, *port);
 432                 if (fd < 0) {
 433                         port++;
 434                         continue;
 435                 }
 436                 if (!io_event_create( fd, IO_WANTREAD, func )) {
 437                         Log( LOG_ERR, "io_event_create(): Could not add listening fd %d (port %u): %s!",
 438                                                 fd, (unsigned int) *port, strerror(errno));
 439                         close(fd);
 440                         port++;
 441                         continue;
 442                 }
 443                 created++;
 444                 port++;
 445         }
 446         return created;
 447 }
 448
 449
 450 /**
 451  * Initialize all listening sockets.
 452  * @return Number of created listening sockets
 453  */
 454 GLOBAL unsigned int
 455 Conn_InitListeners( void )
 456 {
 457         /* Initialize ports on which the server should accept connections */
 458         unsigned int created = 0;
 459         char *copy, *listen_addr;
 460
 461         if (!io_library_init(CONNECTION_POOL)) {
 462                 Log(LOG_EMERG, "Cannot initialize IO routines: %s", strerror(errno));
 463                 return -1;
 464         }
 465
 466         assert(Conf_ListenAddress);
 467
 468         /* can't use Conf_ListenAddress directly, see below */
 469         copy = strdup(Conf_ListenAddress);
 470         if (!copy) {
 471                 Log(LOG_CRIT, "Cannot copy %s: %s", Conf_ListenAddress, strerror(errno));
 472                 return 0;
 473         }
 474         listen_addr = strtok(copy, ",");
 475
 476         while (listen_addr) {
 477                 ngt_TrimStr(listen_addr);
 478                 if (*listen_addr) {
 479                         created += ports_initlisteners(&Conf_ListenPorts, listen_addr, cb_listen);
 480 #ifdef SSL_SUPPORT
 481                         created += ports_initlisteners(&Conf_SSLOptions.ListenPorts, listen_addr, cb_listen_ssl);
 482 #endif
 483                 }
 484
 485                 listen_addr = strtok(NULL, ",");
 486         }
 487
 488         /* Can't free() Conf_ListenAddress here: on REHASH, if the config file
 489          * cannot be re-loaded, we'd end up with a NULL Conf_ListenAddress.
 490          * Instead, free() takes place in conf.c, before the config file
 491          * is being parsed. */
 492         free(copy);
 493
 494         return created;
 495 } /* Conn_InitListeners */
 496
 497
 498 GLOBAL void
 499 Conn_ExitListeners( void )
 500 {
 501         /* Close down all listening sockets */
 502         int *fd;
 503         size_t arraylen;
 504 #ifdef ZEROCONF
 505         Rendezvous_UnregisterListeners( );
 506 #endif
 507
 508         arraylen = array_length(&My_Listeners, sizeof (int));
 509         Log(LOG_INFO,
 510             "Shutting down all listening sockets (%d total) ...", arraylen);
 511         fd = array_start(&My_Listeners);
 512         while(arraylen--) {
 513                 assert(fd != NULL);
 514                 assert(*fd >= 0);
 515                 io_close(*fd);
 516                 LogDebug("Listening socket %d closed.", *fd );
 517                 fd++;
 518         }
 519         array_free(&My_Listeners);
 520 } /* Conn_ExitListeners */
 521
 522
 523 static bool
 524 InitSinaddrListenAddr(ng_ipaddr_t *addr, const char *listen_addrstr, UINT16 Port)
 525 {
 526         bool ret;
 527
 528         ret = ng_ipaddr_init(addr, listen_addrstr, Port);
 529         if (!ret) {
 530                 assert(listen_addrstr);
 531                 Log(LOG_CRIT, "Can't bind to [%s]:%u: can't convert ip address \"%s\"",
 532                                                 listen_addrstr, Port, listen_addrstr);
 533         }
 534         return ret;
 535 }
 536
 537
 538 static void
 539 set_v6_only(int af, int sock)
 540 {
 541 #if defined(IPV6_V6ONLY) && defined(WANT_IPV6)
 542         int on = 1;
 543
 544         if (af != AF_INET6)
 545                 return;
 546
 547         if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, (socklen_t)sizeof(on)))
 548                 Log(LOG_ERR, "Could not set IPV6_V6ONLY: %s", strerror(errno));
 549 #else
 550         (void)af;
 551         (void)sock;
 552 #endif
 553 }
 554
 555
 556 /* return new listening port file descriptor or -1 on failure */
 557 static int
 558 NewListener(const char *listen_addr, UINT16 Port)
 559 {
 560         /* Create new listening socket on specified port */
 561         ng_ipaddr_t addr;
 562         int sock, af;
 563 #ifdef ZEROCONF
 564         char name[CLIENT_ID_LEN], *info;
 565 #endif
 566         if (!InitSinaddrListenAddr(&addr, listen_addr, Port))
 567                 return -1;
 568
 569         af = ng_ipaddr_af(&addr);
 570         sock = socket(af, SOCK_STREAM, 0);
 571         if( sock < 0 ) {
 572                 Log(LOG_CRIT, "Can't create socket (af %d) : %s!", af, strerror(errno));
 573                 return -1;
 574         }
 575
 576         set_v6_only(af, sock);
 577
 578         if (!Init_Socket(sock))
 579                 return -1;
 580
 581         if (bind(sock, (struct sockaddr *)&addr, ng_ipaddr_salen(&addr)) != 0) {
 582                 Log(LOG_CRIT, "Can't bind socket to address %s:%d - %s",
 583                         ng_ipaddr_tostr(&addr), Port, strerror(errno));
 584                 close(sock);
 585                 return -1;
 586         }
 587
 588         if( listen( sock, 10 ) != 0 ) {
 589                 Log( LOG_CRIT, "Can't listen on socket: %s!", strerror( errno ));
 590                 close( sock );
 591                 return -1;
 592         }
 593
 594         /* keep fd in list so we can close it when ngircd restarts/shuts down */
 595         if (!array_catb( &My_Listeners,(char*) &sock, sizeof(int) )) {
 596                 Log( LOG_CRIT, "Can't add socket to My_Listeners array: %s!", strerror( errno ));
 597                 close( sock );
 598                 return -1;
 599         }
 600
 601         Log(LOG_INFO, "Now listening on [%s]:%d (socket %d).", ng_ipaddr_tostr(&addr), Port, sock);
 602
 603 #ifdef ZEROCONF
 604         /* Get best server description text */
 605         if( ! Conf_ServerInfo[0] ) info = Conf_ServerName;
 606         else
 607         {
 608                 /* Use server info string */
 609                 info = NULL;
 610                 if( Conf_ServerInfo[0] == '[' )
 611                 {
 612                         /* Cut off leading hostname part in "[]" */
 613                         info = strchr( Conf_ServerInfo, ']' );
 614                         if( info )
 615                         {
 616                                 info++;
 617                                 while( *info == ' ' ) info++;
 618                         }
 619                 }
 620                 if( ! info ) info = Conf_ServerInfo;
 621         }
 622
 623         /* Add port number to description if non-standard */
 624         if (Port != 6667)
 625                 snprintf(name, sizeof name, "%s (port %u)", info,
 626                          (unsigned int)Port);
 627         else
 628                 strlcpy(name, info, sizeof name);
 629
 630         /* Register service */
 631         Rendezvous_Register( name, MDNS_TYPE, Port );
 632 #endif
 633         return sock;
 634 } /* NewListener */
 635
 636
 637 #ifdef SSL_SUPPORT
 638 /*
 639  * SSL/TLS connections require extra treatment:
 640  * When either CONN_SSL_WANT_WRITE or CONN_SSL_WANT_READ is set, we
 641  * need to take care of that first, before checking read/write buffers.
 642  * For instance, while we might have data in our write buffer, the
 643  * TLS/SSL protocol might need to read internal data first for TLS/SSL
 644  * writes to succeed.
 645  *
 646  * If this function returns true, such a condition is met and we have
 647  * to reverse the condition (check for read even if we've data to write,
 648  * do not check for read but writeability even if write-buffer is empty).
 649  */
 650 static bool
 651 SSL_WantRead(const CONNECTION *c)
 652 {
 653         if (Conn_OPTION_ISSET(c, CONN_SSL_WANT_READ)) {
 654                 io_event_add(c->sock, IO_WANTREAD);
 655                 return true;
 656         }
 657         return false;
 658 }
 659 static bool
 660 SSL_WantWrite(const CONNECTION *c)
 661 {
 662         if (Conn_OPTION_ISSET(c, CONN_SSL_WANT_WRITE)) {
 663                 io_event_add(c->sock, IO_WANTWRITE);
 664                 return true;
 665         }
 666         return false;
 667 }
 668 #else
 669 static inline bool
 670 SSL_WantRead(UNUSED const CONNECTION *c) { return false; }
 671 static inline bool
 672 SSL_WantWrite(UNUSED const CONNECTION *c) { return false; }
 673 #endif
 674
 675
 676 /**
 677  * "Main Loop": Loop until shutdown or restart is signalled.
 678  * This function loops until a shutdown or restart of ngIRCd is signalled and
 679  * calls io_dispatch() to check for readable and writable sockets every second.
 680  * It checks for status changes on pending connections (e. g. when a hostname
 681  * has been resolved), checks for "penalties" and timeouts, and handles the
 682  * input buffers.
 683  */
 684 GLOBAL void
 685 Conn_Handler(void)
 686 {
 687         int i;
 688         unsigned int wdatalen, bytes_processed;
 689         struct timeval tv;
 690         time_t t;
 691
 692         while (!NGIRCd_SignalQuit && !NGIRCd_SignalRestart) {
 693                 t = time(NULL);
 694
 695 #ifdef ZEROCONF
 696                 Rendezvous_Handler();
 697 #endif
 698
 699                 /* Should the configuration be reloaded? */
 700                 if (NGIRCd_SignalRehash)
 701                         NGIRCd_Rehash();
 702
 703                 /* Check configured servers and established links */
 704                 Check_Servers();
 705                 Check_Connections();
 706
 707                 /* Look for non-empty read buffers ... */
 708                 for (i = 0; i < Pool_Size; i++) {
 709                         if ((My_Connections[i].sock > NONE)
 710                             && (array_bytes(&My_Connections[i].rbuf) > 0)
 711                             && (My_Connections[i].delaytime <= t)) {
 712                                 /* ... and try to handle the received data */
 713                                 bytes_processed = Handle_Buffer(i);
 714                                 /* if we processed data, and there might be
 715                                  * more commands in the input buffer, do not
 716                                  * try to read any more data now */
 717                                 if (bytes_processed &&
 718                                     array_bytes(&My_Connections[i].rbuf) > 2) {
 719                                         LogDebug
 720                                             ("Throttling connection %d: command limit reached!",
 721                                              i);
 722                                         Conn_SetPenalty(i, 1);
 723                                 }
 724                         }
 725                 }
 726
 727                 /* Look for non-empty write buffers ... */
 728                 for (i = 0; i < Pool_Size; i++) {
 729                         if (My_Connections[i].sock <= NONE)
 730                                 continue;
 731
 732                         wdatalen = (unsigned int)array_bytes(&My_Connections[i].wbuf);
 733 #ifdef ZLIB
 734                         if (wdatalen > 0 ||
 735                             array_bytes(&My_Connections[i].zip.wbuf) > 0)
 736 #else
 737                         if (wdatalen > 0)
 738 #endif
 739                         {
 740                                 if (SSL_WantRead(&My_Connections[i]))
 741                                         continue;
 742                                 io_event_add(My_Connections[i].sock,
 743                                              IO_WANTWRITE);
 744                         }
 745                 }
 746
 747                 /* Check from which sockets we possibly could read ... */
 748                 for (i = 0; i < Pool_Size; i++) {
 749                         if (My_Connections[i].sock <= NONE)
 750                                 continue;
 751 #ifdef SSL_SUPPORT
 752                         if (SSL_WantWrite(&My_Connections[i]))
 753                                 continue; /* TLS/SSL layer needs to write data; deal with this first */
 754 #endif
 755                         if (Resolve_INPROGRESS(&My_Connections[i].res_stat)) {
 756                                 /* Wait for completion of resolver sub-process ... */
 757                                 io_event_del(My_Connections[i].sock,
 758                                              IO_WANTREAD);
 759                                 continue;
 760                         }
 761
 762                         if (Conn_OPTION_ISSET(&My_Connections[i], CONN_ISCONNECTING))
 763                                 /* Wait for completion of connect() ... */
 764                                 continue;
 765
 766                         if (My_Connections[i].delaytime > t) {
 767                                 /* There is a "penalty time" set: ignore socket! */
 768                                 io_event_del(My_Connections[i].sock,
 769                                              IO_WANTREAD);
 770                                 continue;
 771                         }
 772                         io_event_add(My_Connections[i].sock, IO_WANTREAD);
 773                 }
 774
 775                 /* Set the timeout for reading from the network to 1 second,
 776                  * which is the granularity with witch we handle "penalty
 777                  * times" for example.
 778                  * Note: tv_sec/usec are undefined(!) after io_dispatch()
 779                  * returns, so we have to set it beforce each call to it! */
 780                 tv.tv_usec = 0;
 781                 tv.tv_sec = 1;
 782
 783                 /* Wait for activity ... */
 784                 i = io_dispatch(&tv);
 785                 if (i == -1 && errno != EINTR) {
 786                         Log(LOG_EMERG, "Conn_Handler(): io_dispatch(): %s!",
 787                             strerror(errno));
 788                         Log(LOG_ALERT, "%s exiting due to fatal errors!",
 789                             PACKAGE_NAME);
 790                         exit(1);
 791                 }
 792         }
 793
 794         if (NGIRCd_SignalQuit)
 795                 Log(LOG_NOTICE | LOG_snotice, "Server going down NOW!");
 796         else if (NGIRCd_SignalRestart)
 797                 Log(LOG_NOTICE | LOG_snotice, "Server restarting NOW!");
 798 } /* Conn_Handler */
 799
 800
 801 /**
 802  * Write a text string into the socket of a connection.
 803  * This function automatically appends CR+LF to the string and validates that
 804  * the result is a valid IRC message (oversized messages are shortened, for
 805  * example). Then it calls the Conn_Write() function to do the actual sending.
 806  * @param Idx Index fo the connection.
 807  * @param Format Format string, see printf().
 808  * @return true on success, false otherwise.
 809  */
 810 #ifdef PROTOTYPES
 811 GLOBAL bool
 812 Conn_WriteStr( CONN_ID Idx, char *Format, ... )
 813 #else
 814 GLOBAL bool
 815 Conn_WriteStr( Idx, Format, va_alist )
 816 CONN_ID Idx;
 817 char *Format;
 818 va_dcl
 819 #endif
 820 {
 821         char buffer[COMMAND_LEN];
 822         size_t len;
 823         bool ok;
 824         va_list ap;
 825
 826         assert( Idx > NONE );
 827         assert( Format != NULL );
 828
 829 #ifdef PROTOTYPES
 830         va_start( ap, Format );
 831 #else
 832         va_start( ap );
 833 #endif
 834         if (vsnprintf( buffer, COMMAND_LEN - 2, Format, ap ) >= COMMAND_LEN - 2 ) {
 835                 /*
 836                  * The string that should be written to the socket is longer
 837                  * than the allowed size of COMMAND_LEN bytes (including both
 838                  * the CR and LF characters). This can be caused by the
 839                  * IRC_WriteXXX() functions when the prefix of this server had
 840                  * to be added to an already "quite long" command line which
 841                  * has been received from a regular IRC client, for example.
 842                  *
 843                  * We are not allowed to send such "oversized" messages to
 844                  * other servers and clients, see RFC 2812 2.3 and 2813 3.3
 845                  * ("these messages SHALL NOT exceed 512 characters in length,
 846                  * counting all characters including the trailing CR-LF").
 847                  *
 848                  * So we have a big problem here: we should send more bytes
 849                  * to the network than we are allowed to and we don't know
 850                  * the originator (any more). The "old" behaviour of blaming
 851                  * the receiver ("next hop") is a bad idea (it could be just
 852                  * an other server only routing the message!), so the only
 853                  * option left is to shorten the string and to hope that the
 854                  * result is still somewhat useful ...
 855                  *                                                   -alex-
 856                  */
 857
 858                 strcpy (buffer + sizeof(buffer) - strlen(CUT_TXTSUFFIX) - 2 - 1,
 859                         CUT_TXTSUFFIX);
 860         }
 861
 862 #ifdef SNIFFER
 863         if (NGIRCd_Sniffer)
 864                 Log(LOG_DEBUG, " -> connection %d: '%s'.", Idx, buffer);
 865 #endif
 866
 867         len = strlcat( buffer, "\r\n", sizeof( buffer ));
 868         ok = Conn_Write(Idx, buffer, len);
 869         My_Connections[Idx].msg_out++;
 870
 871         va_end( ap );
 872         return ok;
 873 } /* Conn_WriteStr */
 874
 875
 876 /**
 877  * Append Data to the outbound write buffer of a connection.
 878  * @param Idx Index of the connection.
 879  * @param Data pointer to the data.
 880  * @param Len length of Data.
 881  * @return true on success, false otherwise.
 882  */
 883 static bool
 884 Conn_Write( CONN_ID Idx, char *Data, size_t Len )
 885 {
 886         CLIENT *c;
 887         size_t writebuf_limit = WRITEBUFFER_LEN;
 888         assert( Idx > NONE );
 889         assert( Data != NULL );
 890         assert( Len > 0 );
 891
 892         c = Conn_GetClient(Idx);
 893         assert( c != NULL);
 894
 895         /* Servers do get special write buffer limits, so they can generate
 896          * all the messages that are required while peering. */
 897         if (Client_Type(c) == CLIENT_SERVER)
 898                 writebuf_limit = WRITEBUFFER_SLINK_LEN;
 899
 900         /* Is the socket still open? A previous call to Conn_Write()
 901          * may have closed the connection due to a fatal error.
 902          * In this case it is sufficient to return an error, as well. */
 903         if( My_Connections[Idx].sock <= NONE ) {
 904                 LogDebug("Skipped write on closed socket (connection %d).", Idx);
 905                 return false;
 906         }
 907
 908 #ifdef ZLIB
 909         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP )) {
 910                 /* Compressed link:
 911                  * Zip_Buffer() does all the dirty work for us: it flushes
 912                  * the (pre-)compression buffers if required and handles
 913                  * all error conditions. */
 914                 if (!Zip_Buffer(Idx, Data, Len))
 915                         return false;
 916         }
 917         else
 918 #endif
 919         {
 920                 /* Uncompressed link:
 921                  * Check if outbound buffer has enough space for the data. */
 922                 if (array_bytes(&My_Connections[Idx].wbuf) + Len >=
 923                     writebuf_limit) {
 924                         /* Buffer is full, flush it. Handle_Write deals with
 925                          * low-level errors, if any. */
 926                         if (!Handle_Write(Idx))
 927                                 return false;
 928                 }
 929
 930                 /* When the write buffer is still too big after flushing it,
 931                  * the connection will be killed. */
 932                 if (array_bytes(&My_Connections[Idx].wbuf) + Len >=
 933                     writebuf_limit) {
 934                         Log(LOG_NOTICE,
 935                             "Write buffer overflow (connection %d, size %lu byte)!",
 936                             Idx,
 937                             (unsigned long)array_bytes(&My_Connections[Idx].wbuf));
 938                         Conn_Close(Idx, "Write buffer overflow!", NULL, false);
 939                         return false;
 940                 }
 941
 942                 /* Copy data to write buffer */
 943                 if (!array_catb(&My_Connections[Idx].wbuf, Data, Len))
 944                         return false;
 945
 946                 My_Connections[Idx].bytes_out += Len;
 947         }
 948
 949         /* Adjust global write counter */
 950         WCounter += Len;
 951
 952         return true;
 953 } /* Conn_Write */
 954
 955
 956 GLOBAL void
 957 Conn_Close( CONN_ID Idx, const char *LogMsg, const char *FwdMsg, bool InformClient )
 958 {
 959         /* Close connection. Open pipes of asyncronous resolver
 960          * sub-processes are closed down. */
 961
 962         CLIENT *c;
 963         double in_k, out_k;
 964         UINT16 port;
 965 #ifdef ZLIB
 966         double in_z_k, out_z_k;
 967         int in_p, out_p;
 968 #endif
 969
 970         assert( Idx > NONE );
 971
 972         /* Is this link already shutting down? */
 973         if( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ISCLOSING )) {
 974                 /* Conn_Close() has been called recursively for this link;
 975                  * probabe reason: Handle_Write() failed  -- see below. */
 976                 LogDebug("Recursive request to close connection: %d", Idx );
 977                 return;
 978         }
 979
 980         assert( My_Connections[Idx].sock > NONE );
 981
 982         /* Mark link as "closing" */
 983         Conn_OPTION_ADD( &My_Connections[Idx], CONN_ISCLOSING );
 984
 985         port = ng_ipaddr_getport(&My_Connections[Idx].addr);
 986         Log(LOG_INFO, "Shutting down connection %d (%s) with %s:%d ...", Idx,
 987             LogMsg ? LogMsg : FwdMsg, My_Connections[Idx].host, port);
 988
 989         /* Search client, if any */
 990         c = Conn_GetClient( Idx );
 991
 992         /* Should the client be informed? */
 993         if (InformClient) {
 994 #ifndef STRICT_RFC
 995                 /* Send statistics to client if registered as user: */
 996                 if ((c != NULL) && (Client_Type(c) == CLIENT_USER)) {
 997                         Conn_WriteStr( Idx,
 998                          ":%s NOTICE %s :%sConnection statistics: client %.1f kb, server %.1f kb.",
 999                          Client_ID(Client_ThisServer()), Client_ID(c),
1000                          NOTICE_TXTPREFIX,
1001                          (double)My_Connections[Idx].bytes_in / 1024,
1002                          (double)My_Connections[Idx].bytes_out / 1024);
1003                 }
1004 #endif
1005                 /* Send ERROR to client (see RFC 2812, section 3.1.7) */
1006                 if (FwdMsg)
1007                         Conn_WriteStr(Idx, "ERROR :%s", FwdMsg);
1008                 else
1009                         Conn_WriteStr(Idx, "ERROR :Closing connection.");
1010         }
1011
1012         /* Try to write out the write buffer. Note: Handle_Write() eventually
1013          * removes the CLIENT structure associated with this connection if an
1014          * error occurs! So we have to re-check if there is still an valid
1015          * CLIENT structure after calling Handle_Write() ...*/
1016         (void)Handle_Write( Idx );
1017
1018         /* Search client, if any (re-check!) */
1019         c = Conn_GetClient( Idx );
1020 #ifdef SSL_SUPPORT
1021         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_SSL )) {
1022                 Log(LOG_INFO, "SSL connection %d shutting down ...", Idx);
1023                 ConnSSL_Free(&My_Connections[Idx]);
1024         }
1025 #endif
1026         /* Shut down socket */
1027         if (! io_close(My_Connections[Idx].sock)) {
1028                 /* Oops, we can't close the socket!? This is ... ugly! */
1029                 Log(LOG_CRIT,
1030                     "Error closing connection %d (socket %d) with %s:%d - %s! (ignored)",
1031                     Idx, My_Connections[Idx].sock, My_Connections[Idx].host,
1032                     port, strerror(errno));
1033         }
1034
1035         /* Mark socket as invalid: */
1036         My_Connections[Idx].sock = NONE;
1037
1038         /* If there is still a client, unregister it now */
1039         if (c)
1040                 Client_Destroy(c, LogMsg, FwdMsg, true);
1041
1042         /* Calculate statistics and log information */
1043         in_k = (double)My_Connections[Idx].bytes_in / 1024;
1044         out_k = (double)My_Connections[Idx].bytes_out / 1024;
1045 #ifdef ZLIB
1046         if (Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP)) {
1047                 in_z_k = (double)My_Connections[Idx].zip.bytes_in / 1024;
1048                 out_z_k = (double)My_Connections[Idx].zip.bytes_out / 1024;
1049                 /* Make sure that no division by zero can occur during
1050                  * the calculation of in_p and out_p: in_z_k and out_z_k
1051                  * are non-zero, that's guaranteed by the protocol until
1052                  * compression can be enabled. */
1053                 if (! in_z_k)
1054                         in_z_k = in_k;
1055                 if (! out_z_k)
1056                         out_z_k = out_k;
1057                 in_p = (int)(( in_k * 100 ) / in_z_k );
1058                 out_p = (int)(( out_k * 100 ) / out_z_k );
1059                 Log(LOG_INFO,
1060                     "Connection %d with %s:%d closed (in: %.1fk/%.1fk/%d%%, out: %.1fk/%.1fk/%d%%).",
1061                     Idx, My_Connections[Idx].host, port,
1062                     in_k, in_z_k, in_p, out_k, out_z_k, out_p);
1063         }
1064         else
1065 #endif
1066         {
1067                 Log(LOG_INFO,
1068                     "Connection %d with %s:%d closed (in: %.1fk, out: %.1fk).",
1069                     Idx, My_Connections[Idx].host, port,
1070                     in_k, out_k);
1071         }
1072
1073         /* cancel running resolver */
1074         if (Resolve_INPROGRESS(&My_Connections[Idx].res_stat))
1075                 Resolve_Shutdown(&My_Connections[Idx].res_stat);
1076
1077         /* Servers: Modify time of next connect attempt? */
1078         Conf_UnsetServer( Idx );
1079
1080 #ifdef ZLIB
1081         /* Clean up zlib, if link was compressed */
1082         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP )) {
1083                 inflateEnd( &My_Connections[Idx].zip.in );
1084                 deflateEnd( &My_Connections[Idx].zip.out );
1085                 array_free(&My_Connections[Idx].zip.rbuf);
1086                 array_free(&My_Connections[Idx].zip.wbuf);
1087         }
1088 #endif
1089
1090         array_free(&My_Connections[Idx].rbuf);
1091         array_free(&My_Connections[Idx].wbuf);
1092
1093         /* Clean up connection structure (=free it) */
1094         Init_Conn_Struct( Idx );
1095
1096         assert(NumConnections > 0);
1097         if (NumConnections)
1098                 NumConnections--;
1099         LogDebug("Shutdown of connection %d completed, %ld connection%s left.",
1100                  Idx, NumConnections, NumConnections != 1 ? "s" : "");
1101 } /* Conn_Close */
1102
1103
1104 GLOBAL void
1105 Conn_SyncServerStruct( void )
1106 {
1107         /* Synchronize server structures (connection IDs):
1108          * connections <-> configuration */
1109
1110         CLIENT *client;
1111         CONN_ID i;
1112         int c;
1113
1114         for( i = 0; i < Pool_Size; i++ ) {
1115                 /* Established connection? */
1116                 if (My_Connections[i].sock < 0)
1117                         continue;
1118
1119                 /* Server connection? */
1120                 client = Conn_GetClient( i );
1121                 if(( ! client ) || ( Client_Type( client ) != CLIENT_SERVER )) continue;
1122
1123                 for( c = 0; c < MAX_SERVERS; c++ )
1124                 {
1125                         /* Configured server? */
1126                         if( ! Conf_Server[c].host[0] ) continue;
1127
1128                         /* Duplicate? */
1129                         if( strcmp( Conf_Server[c].name, Client_ID( client )) == 0 )
1130                                 Conf_Server[c].conn_id = i;
1131                 }
1132         }
1133 } /* SyncServerStruct */
1134
1135
1136 /**
1137  * Send out data of write buffer; connect new sockets.
1138  */
1139 static bool
1140 Handle_Write( CONN_ID Idx )
1141 {
1142         ssize_t len;
1143         size_t wdatalen;
1144
1145         assert( Idx > NONE );
1146         if ( My_Connections[Idx].sock < 0 ) {
1147                 LogDebug("Handle_Write() on closed socket, connection %d", Idx);
1148                 return false;
1149         }
1150         assert( My_Connections[Idx].sock > NONE );
1151
1152         wdatalen = array_bytes(&My_Connections[Idx].wbuf );
1153
1154 #ifdef ZLIB
1155         if (wdatalen == 0) {
1156                 /* Write buffer is empty, so we try to flush the compression
1157                  * buffer and get some data to work with from there :-) */
1158                 if (!Zip_Flush(Idx))
1159                         return false;
1160
1161                 /* Now the write buffer most probably has changed: */
1162                 wdatalen = array_bytes(&My_Connections[Idx].wbuf);
1163         }
1164 #endif
1165
1166         if (wdatalen == 0) {
1167                 /* Still no data, fine. */
1168                 io_event_del(My_Connections[Idx].sock, IO_WANTWRITE );
1169                 return true;
1170         }
1171
1172         LogDebug
1173             ("Handle_Write() called for connection %d, %ld bytes pending ...",
1174              Idx, wdatalen);
1175
1176 #ifdef SSL_SUPPORT
1177         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_SSL )) {
1178                 len = ConnSSL_Write(&My_Connections[Idx], array_start(&My_Connections[Idx].wbuf), wdatalen);
1179         } else
1180 #endif
1181         {
1182                 len = write(My_Connections[Idx].sock,
1183                             array_start(&My_Connections[Idx].wbuf), wdatalen );
1184         }
1185         if( len < 0 ) {
1186                 if (errno == EAGAIN || errno == EINTR)
1187                         return true;
1188
1189                 Log(LOG_ERR, "Write error on connection %d (socket %d): %s!",
1190                     Idx, My_Connections[Idx].sock, strerror(errno));
1191                 Conn_Close(Idx, "Write error!", NULL, false);
1192                 return false;
1193         }
1194
1195         /* move any data not yet written to beginning */
1196         array_moveleft(&My_Connections[Idx].wbuf, 1, (size_t)len);
1197
1198         return true;
1199 } /* Handle_Write */
1200
1201
1202 static int
1203 Count_Connections(ng_ipaddr_t *a)
1204 {
1205         int i, cnt;
1206
1207         cnt = 0;
1208         for (i = 0; i < Pool_Size; i++) {
1209                 if (My_Connections[i].sock <= NONE)
1210                         continue;
1211                 if (ng_ipaddr_ipequal(&My_Connections[i].addr, a))
1212                         cnt++;
1213         }
1214         return cnt;
1215 } /* Count_Connections */
1216
1217
1218 /**
1219  * Initialize new client connection on a listening socket.
1220  * @param Sock Listening socket descriptor
1221  * @return Accepted socket descriptor or -1 on error
1222  */
1223 static int
1224 New_Connection(int Sock)
1225 {
1226 #ifdef TCPWRAP
1227         struct request_info req;
1228 #endif
1229         ng_ipaddr_t new_addr;
1230         char ip_str[NG_INET_ADDRSTRLEN];
1231         int new_sock, new_sock_len, identsock;
1232         CLIENT *c;
1233         long cnt;
1234
1235         assert(Sock > NONE);
1236
1237         new_sock_len = (int)sizeof(new_addr);
1238         new_sock = accept(Sock, (struct sockaddr *)&new_addr,
1239                           (socklen_t *)&new_sock_len);
1240         if (new_sock < 0) {
1241                 Log(LOG_CRIT, "Can't accept connection: %s!", strerror(errno));
1242                 return -1;
1243         }
1244
1245         if (!ng_ipaddr_tostr_r(&new_addr, ip_str)) {
1246                 Log(LOG_CRIT, "fd %d: Can't convert IP address!", new_sock);
1247                 Simple_Message(new_sock, "ERROR :Internal Server Error");
1248                 close(new_sock);
1249                 return -1;
1250         }
1251
1252 #ifdef TCPWRAP
1253         /* Validate socket using TCP Wrappers */
1254         request_init(&req, RQ_DAEMON, PACKAGE_NAME, RQ_FILE, new_sock,
1255                      RQ_CLIENT_SIN, &new_addr, NULL);
1256         fromhost(&req);
1257         if (!hosts_access(&req)) {
1258                 Log(deny_severity,
1259                     "Refused connection from %s (by TCP Wrappers)!", ip_str);
1260                 Simple_Message(new_sock, "ERROR :Connection refused");
1261                 close(new_sock);
1262                 return -1;
1263         }
1264 #endif
1265
1266         if (!Init_Socket(new_sock))
1267                 return -1;
1268
1269         /* Check global connection limit */
1270         if ((Conf_MaxConnections > 0) &&
1271             (NumConnections >= (size_t) Conf_MaxConnections)) {
1272                 Log(LOG_ALERT, "Can't accept connection: limit (%d) reached!",
1273                     Conf_MaxConnections);
1274                 Simple_Message(new_sock, "ERROR :Connection limit reached");
1275                 close(new_sock);
1276                 return -1;
1277         }
1278
1279         /* Check IP-based connection limit */
1280         cnt = Count_Connections(&new_addr);
1281         if ((Conf_MaxConnectionsIP > 0) && (cnt >= Conf_MaxConnectionsIP)) {
1282                 /* Access denied, too many connections from this IP address! */
1283                 Log(LOG_ERR,
1284                     "Refused connection from %s: too may connections (%ld) from this IP address!",
1285                     ip_str, cnt);
1286                 Simple_Message(new_sock,
1287                                "ERROR :Connection refused, too many connections from your IP address!");
1288                 close(new_sock);
1289                 return -1;
1290         }
1291
1292         if (new_sock >= Pool_Size) {
1293                 if (!array_alloc(&My_ConnArray, sizeof(CONNECTION),
1294                                  (size_t) new_sock)) {
1295                         Log(LOG_EMERG,
1296                             "Can't allocate memory! [New_Connection]");
1297                         Simple_Message(new_sock, "ERROR: Internal error");
1298                         close(new_sock);
1299                         return -1;
1300                 }
1301                 LogDebug("Bumped connection pool to %ld items (internal: %ld items, %ld bytes)",
1302                          new_sock, array_length(&My_ConnArray,
1303                          sizeof(CONNECTION)), array_bytes(&My_ConnArray));
1304
1305                 /* Adjust pointer to new block */
1306                 My_Connections = array_start(&My_ConnArray);
1307                 while (Pool_Size <= new_sock)
1308                         Init_Conn_Struct(Pool_Size++);
1309         }
1310
1311         /* register callback */
1312         if (!io_event_create(new_sock, IO_WANTREAD, cb_clientserver)) {
1313                 Log(LOG_ALERT,
1314                     "Can't accept connection: io_event_create failed!");
1315                 Simple_Message(new_sock, "ERROR :Internal error");
1316                 close(new_sock);
1317                 return -1;
1318         }
1319
1320         c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWN, false);
1321         if (!c) {
1322                 Log(LOG_ALERT,
1323                     "Can't accept connection: can't create client structure!");
1324                 Simple_Message(new_sock, "ERROR :Internal error");
1325                 io_close(new_sock);
1326                 return -1;
1327         }
1328
1329         Init_Conn_Struct(new_sock);
1330         My_Connections[new_sock].sock = new_sock;
1331         My_Connections[new_sock].addr = new_addr;
1332         My_Connections[new_sock].client = c;
1333
1334         /* Set initial hostname to IP address. This becomes overwritten when
1335          * the DNS lookup is enabled and succeeds, but is used otherwise. */
1336         if (ng_ipaddr_af(&new_addr) != AF_INET)
1337                 snprintf(My_Connections[new_sock].host,
1338                          sizeof(My_Connections[new_sock].host), "[%s]", ip_str);
1339         else
1340                 strlcpy(My_Connections[new_sock].host, ip_str,
1341                         sizeof(My_Connections[new_sock].host));
1342
1343         Client_SetHostname(c, My_Connections[new_sock].host);
1344
1345         Log(LOG_INFO, "Accepted connection %d from %s:%d on socket %d.",
1346             new_sock, My_Connections[new_sock].host,
1347             ng_ipaddr_getport(&new_addr), Sock);
1348
1349         identsock = new_sock;
1350 #ifdef IDENTAUTH
1351         if (Conf_NoIdent)
1352                 identsock = -1;
1353 #endif
1354         if (!Conf_NoDNS)
1355                 Resolve_Addr(&My_Connections[new_sock].res_stat, &new_addr,
1356                              identsock, cb_Read_Resolver_Result);
1357
1358         /* ngIRCd waits up to 4 seconds for the result of the asynchronous
1359          * DNS and IDENT resolver subprocess using the "penalty" mechanism.
1360          * If there are results earlier, the delay is aborted. */
1361         Conn_SetPenalty(new_sock, 4);
1362
1363         NumConnections++;
1364         LogDebug("Total number of connections now %ld.", NumConnections);
1365         return new_sock;
1366 } /* New_Connection */
1367
1368
1369 static CONN_ID
1370 Socket2Index( int Sock )
1371 {
1372         assert( Sock >= 0 );
1373
1374         if( Sock >= Pool_Size || My_Connections[Sock].sock != Sock ) {
1375                 /* the Connection was already closed again, likely due to
1376                  * an error. */
1377                 LogDebug("Socket2Index: can't get connection for socket %d!", Sock);
1378                 return NONE;
1379         }
1380         return Sock;
1381 } /* Socket2Index */
1382
1383
1384 /**
1385  * Read data from the network to the read buffer. If an error occures,
1386  * the socket of this connection will be shut down.
1387  */
1388 static void
1389 Read_Request( CONN_ID Idx )
1390 {
1391         ssize_t len;
1392         static const unsigned int maxbps = COMMAND_LEN / 2;
1393         char readbuf[READBUFFER_LEN];
1394         time_t t;
1395         CLIENT *c;
1396         assert( Idx > NONE );
1397         assert( My_Connections[Idx].sock > NONE );
1398
1399 #ifdef ZLIB
1400         if ((array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN) ||
1401                 (array_bytes(&My_Connections[Idx].zip.rbuf) >= READBUFFER_LEN))
1402 #else
1403         if (array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN)
1404 #endif
1405         {
1406                 /* Read buffer is full */
1407                 Log(LOG_ERR,
1408                     "Receive buffer overflow (connection %d): %d bytes!",
1409                     Idx, array_bytes(&My_Connections[Idx].rbuf));
1410                 Conn_Close( Idx, "Receive buffer overflow!", NULL, false );
1411                 return;
1412         }
1413
1414 #ifdef SSL_SUPPORT
1415         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL))
1416                 len = ConnSSL_Read( &My_Connections[Idx], readbuf, sizeof(readbuf));
1417         else
1418 #endif
1419         len = read(My_Connections[Idx].sock, readbuf, sizeof(readbuf));
1420         if (len == 0) {
1421                 Log(LOG_INFO, "%s:%u (%s) is closing the connection ...",
1422                                 My_Connections[Idx].host,
1423                                 (unsigned int) ng_ipaddr_getport(&My_Connections[Idx].addr),
1424                                 ng_ipaddr_tostr(&My_Connections[Idx].addr));
1425                 Conn_Close(Idx,
1426                            "Socket closed!", "Client closed connection",
1427                            false);
1428                 return;
1429         }
1430
1431         if (len < 0) {
1432                 if( errno == EAGAIN ) return;
1433                 Log(LOG_ERR, "Read error on connection %d (socket %d): %s!",
1434                     Idx, My_Connections[Idx].sock, strerror(errno));
1435                 Conn_Close(Idx, "Read error!", "Client closed connection",
1436                            false);
1437                 return;
1438         }
1439 #ifdef ZLIB
1440         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1441                 if (!array_catb(&My_Connections[Idx].zip.rbuf, readbuf,
1442                                 (size_t) len)) {
1443                         Log(LOG_ERR,
1444                             "Could not append recieved data to zip input buffer (connn %d): %d bytes!",
1445                             Idx, len);
1446                         Conn_Close(Idx, "Receive buffer overflow!", NULL,
1447                                    false);
1448                         return;
1449                 }
1450         } else
1451 #endif
1452         {
1453                 if (!array_catb( &My_Connections[Idx].rbuf, readbuf, len)) {
1454                         Log( LOG_ERR, "Could not append recieved data to input buffer (connn %d): %d bytes!", Idx, len );
1455                         Conn_Close( Idx, "Receive buffer overflow!", NULL, false );
1456                 }
1457         }
1458
1459         /* Update connection statistics */
1460         My_Connections[Idx].bytes_in += len;
1461
1462         /* Update timestamp of last data received if this connection is
1463          * registered as a user, server or service connection. Don't update
1464          * otherwise, so users have at least Conf_PongTimeout seconds time to
1465          * register with the IRC server -- see Check_Connections().
1466          * Set "lastping", too, so we can handle time shifts backwards ... */
1467         c = Conn_GetClient(Idx);
1468         if (c && (Client_Type(c) == CLIENT_USER
1469                   || Client_Type(c) == CLIENT_SERVER
1470                   || Client_Type(c) == CLIENT_SERVICE)) {
1471                 t = time(NULL);
1472                 if (My_Connections[Idx].lastdata != t)
1473                         My_Connections[Idx].bps = 0;
1474
1475                 My_Connections[Idx].lastdata = t;
1476                 My_Connections[Idx].lastping = My_Connections[Idx].lastdata;
1477         }
1478
1479         /* Look at the data in the (read-) buffer of this connection */
1480         My_Connections[Idx].bps += Handle_Buffer(Idx);
1481         if (Client_Type(c) != CLIENT_SERVER
1482             && My_Connections[Idx].bps >= maxbps) {
1483                 LogDebug("Throttling connection %d: BPS exceeded! (%u >= %u)",
1484                          Idx, My_Connections[Idx].bps, maxbps);
1485                 Conn_SetPenalty(Idx, 1);
1486         }
1487 } /* Read_Request */
1488
1489
1490 /**
1491  * Handle all data in the connection read-buffer.
1492  * Data is processed until no complete command is left in the read buffer,
1493  * or MAX_COMMANDS[_SERVER] commands were processed.
1494  * When a fatal error occurs, the connection is shut down.
1495  * @param Idx Index of the connection.
1496  * @return number of bytes processed.
1497  */
1498 static unsigned int
1499 Handle_Buffer(CONN_ID Idx)
1500 {
1501 #ifndef STRICT_RFC
1502         char *ptr1, *ptr2, *first_eol;
1503 #endif
1504         char *ptr;
1505         size_t len, delta;
1506         time_t starttime;
1507 #ifdef ZLIB
1508         bool old_z;
1509 #endif
1510         unsigned int i, maxcmd = MAX_COMMANDS, len_processed = 0;
1511         CLIENT *c;
1512
1513         c = Conn_GetClient(Idx);
1514         assert( c != NULL);
1515
1516         /* Servers do get special command limits, so they can process
1517          * all the messages that are required while peering. */
1518         if (Client_Type(c) == CLIENT_SERVER)
1519                 maxcmd = MAX_COMMANDS_SERVER;
1520
1521         starttime = time(NULL);
1522         for (i=0; i < maxcmd; i++) {
1523                 /* Check penalty */
1524                 if (My_Connections[Idx].delaytime > starttime)
1525                         return 0;
1526 #ifdef ZLIB
1527                 /* Unpack compressed data, if compression is in use */
1528                 if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1529                         /* When unzipping fails, Unzip_Buffer() shuts
1530                          * down the connection itself */
1531                         if (!Unzip_Buffer(Idx))
1532                                 return 0;
1533                 }
1534 #endif
1535
1536                 if (0 == array_bytes(&My_Connections[Idx].rbuf))
1537                         break;
1538
1539                 /* Make sure that the buffer is NULL terminated */
1540                 if (!array_cat0_temporary(&My_Connections[Idx].rbuf)) {
1541                         Conn_Close(Idx, NULL,
1542                                    "Can't allocate memory [Handle_Buffer]",
1543                                    true);
1544                         return 0;
1545                 }
1546
1547                 /* RFC 2812, section "2.3 Messages", 5th paragraph:
1548                  * "IRC messages are always lines of characters terminated
1549                  * with a CR-LF (Carriage Return - Line Feed) pair [...]". */
1550                 delta = 2;
1551                 ptr = strstr(array_start(&My_Connections[Idx].rbuf), "\r\n");
1552
1553 #ifndef STRICT_RFC
1554                 /* Check for non-RFC-compliant request (only CR or LF)?
1555                  * Unfortunately, there are quite a few clients out there
1556                  * that do this -- e. g. mIRC, BitchX, and Trillian :-( */
1557                 ptr1 = strchr(array_start(&My_Connections[Idx].rbuf), '\r');
1558                 ptr2 = strchr(array_start(&My_Connections[Idx].rbuf), '\n');
1559                 if (ptr) {
1560                         /* Check if there is a single CR or LF _before_ the
1561                          * corerct CR+LF line terminator:  */
1562                         first_eol = ptr1 < ptr2 ? ptr1 : ptr2;
1563                         if (first_eol < ptr) {
1564                                 /* Single CR or LF before CR+LF found */
1565                                 ptr = first_eol;
1566                                 delta = 1;
1567                         }
1568                 } else if (ptr1 || ptr2) {
1569                         /* No CR+LF terminated command found, but single
1570                          * CR or LF found ... */
1571                         if (ptr1 && ptr2)
1572                                 ptr = ptr1 < ptr2 ? ptr1 : ptr2;
1573                         else
1574                                 ptr = ptr1 ? ptr1 : ptr2;
1575                         delta = 1;
1576                 }
1577 #endif
1578
1579                 if (!ptr)
1580                         break;
1581
1582                 /* Complete (=line terminated) request found, handle it! */
1583                 *ptr = '\0';
1584
1585                 len = ptr - (char *)array_start(&My_Connections[Idx].rbuf) + delta;
1586
1587                 if (len > (COMMAND_LEN - 1)) {
1588                         /* Request must not exceed 512 chars (incl. CR+LF!),
1589                          * see RFC 2812. Disconnect Client if this happens. */
1590                         Log(LOG_ERR,
1591                             "Request too long (connection %d): %d bytes (max. %d expected)!",
1592                             Idx, array_bytes(&My_Connections[Idx].rbuf),
1593                             COMMAND_LEN - 1);
1594                         Conn_Close(Idx, NULL, "Request too long", true);
1595                         return 0;
1596                 }
1597
1598                 len_processed += (unsigned int)len;
1599                 if (len <= delta) {
1600                         /* Request is empty (only '\r\n', '\r' or '\n');
1601                          * delta is 2 ('\r\n') or 1 ('\r' or '\n'), see above */
1602                         array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1603                         continue;
1604                 }
1605 #ifdef ZLIB
1606                 /* remember if stream is already compressed */
1607                 old_z = My_Connections[Idx].options & CONN_ZIP;
1608 #endif
1609
1610                 My_Connections[Idx].msg_in++;
1611                 if (!Parse_Request
1612                     (Idx, (char *)array_start(&My_Connections[Idx].rbuf)))
1613                         return 0; /* error -> connection has been closed */
1614
1615                 array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1616                 LogDebug("Connection %d: %d bytes left in read buffer.",
1617                          Idx, array_bytes(&My_Connections[Idx].rbuf));
1618 #ifdef ZLIB
1619                 if ((!old_z) && (My_Connections[Idx].options & CONN_ZIP) &&
1620                     (array_bytes(&My_Connections[Idx].rbuf) > 0)) {
1621                         /* The last command activated socket compression.
1622                          * Data that was read after that needs to be copied
1623                          * to the unzip buffer for decompression: */
1624                         if (!array_copy
1625                             (&My_Connections[Idx].zip.rbuf,
1626                              &My_Connections[Idx].rbuf)) {
1627                                 Conn_Close(Idx, NULL,
1628                                            "Can't allocate memory [Handle_Buffer]",
1629                                            true);
1630                                 return 0;
1631                         }
1632
1633                         array_trunc(&My_Connections[Idx].rbuf);
1634                         LogDebug
1635                             ("Moved already received data (%u bytes) to uncompression buffer.",
1636                              array_bytes(&My_Connections[Idx].zip.rbuf));
1637                 }
1638 #endif
1639         }
1640         return len_processed;
1641 } /* Handle_Buffer */
1642
1643
1644 static void
1645 Check_Connections(void)
1646 {
1647         /* check if connections are alive. if not, play PING-PONG first.
1648          * if this doesn't help either, disconnect client. */
1649         CLIENT *c;
1650         CONN_ID i;
1651         char msg[64];
1652
1653         for (i = 0; i < Pool_Size; i++) {
1654                 if (My_Connections[i].sock < 0)
1655                         continue;
1656
1657                 c = Conn_GetClient(i);
1658                 if (c && ((Client_Type(c) == CLIENT_USER)
1659                           || (Client_Type(c) == CLIENT_SERVER)
1660                           || (Client_Type(c) == CLIENT_SERVICE))) {
1661                         /* connected User, Server or Service */
1662                         if (My_Connections[i].lastping >
1663                             My_Connections[i].lastdata) {
1664                                 /* We already sent a ping */
1665                                 if (My_Connections[i].lastping <
1666                                     time(NULL) - Conf_PongTimeout) {
1667                                         /* Timeout */
1668                                         LogDebug
1669                                             ("Connection %d: Ping timeout: %d seconds.",
1670                                              i, Conf_PongTimeout);
1671                                         snprintf(msg, sizeof(msg), "Ping timeout: %d seconds", Conf_PongTimeout);
1672                                         Conn_Close(i, NULL, msg, true);
1673                                 }
1674                         } else if (My_Connections[i].lastdata <
1675                                    time(NULL) - Conf_PingTimeout) {
1676                                 /* We need to send a PING ... */
1677                                 LogDebug("Connection %d: sending PING ...", i);
1678                                 My_Connections[i].lastping = time(NULL);
1679                                 Conn_WriteStr(i, "PING :%s",
1680                                               Client_ID(Client_ThisServer()));
1681                         }
1682                 } else {
1683                         /* The connection is not fully established yet, so
1684                          * we don't do the PING-PONG game here but instead
1685                          * disconnect the client after "a short time" if it's
1686                          * still not registered. */
1687
1688                         if (My_Connections[i].lastdata <
1689                             time(NULL) - Conf_PongTimeout) {
1690                                 LogDebug
1691                                     ("Unregistered connection %d timed out ...",
1692                                      i);
1693                                 Conn_Close(i, NULL, "Timeout", false);
1694                         }
1695                 }
1696         }
1697 } /* Check_Connections */
1698
1699
1700 static void
1701 Check_Servers( void )
1702 {
1703         /* Check if we can establish further server links */
1704
1705         int i, n;
1706         time_t time_now;
1707
1708         /* Check all configured servers */
1709         for( i = 0; i < MAX_SERVERS; i++ ) {
1710                 /* Valid outgoing server which isn't already connected or disabled? */
1711                 if(( ! Conf_Server[i].host[0] ) || ( ! Conf_Server[i].port > 0 ) ||
1712                         ( Conf_Server[i].conn_id > NONE ) || ( Conf_Server[i].flags & CONF_SFLAG_DISABLED ))
1713                                 continue;
1714
1715                 /* Is there already a connection in this group? */
1716                 if( Conf_Server[i].group > NONE ) {
1717                         for (n = 0; n < MAX_SERVERS; n++) {
1718                                 if (n == i) continue;
1719                                 if ((Conf_Server[n].conn_id != NONE) &&
1720                                         (Conf_Server[n].group == Conf_Server[i].group))
1721                                                 break;
1722                         }
1723                         if (n < MAX_SERVERS) continue;
1724                 }
1725
1726                 /* Check last connect attempt? */
1727                 time_now = time(NULL);
1728                 if( Conf_Server[i].lasttry > (time_now - Conf_ConnectRetry))
1729                         continue;
1730
1731                 /* Okay, try to connect now */
1732                 Conf_Server[i].lasttry = time_now;
1733                 Conf_Server[i].conn_id = SERVER_WAIT;
1734                 assert(Resolve_Getfd(&Conf_Server[i].res_stat) < 0);
1735                 Resolve_Name(&Conf_Server[i].res_stat, Conf_Server[i].host, cb_Connect_to_Server);
1736         }
1737 } /* Check_Servers */
1738
1739
1740 static void
1741 New_Server( int Server , ng_ipaddr_t *dest)
1742 {
1743         /* Establish new server link */
1744         char ip_str[NG_INET_ADDRSTRLEN];
1745         int af_dest, res, new_sock;
1746         CLIENT *c;
1747
1748         assert( Server > NONE );
1749
1750         if (!ng_ipaddr_tostr_r(dest, ip_str)) {
1751                 Log(LOG_WARNING, "New_Server: Could not convert IP to string");
1752                 return;
1753         }
1754
1755         Log( LOG_INFO, "Establishing connection to \"%s\", %s, port %d ... ",
1756                         Conf_Server[Server].host, ip_str, Conf_Server[Server].port );
1757
1758         af_dest = ng_ipaddr_af(dest);
1759         new_sock = socket(af_dest, SOCK_STREAM, 0);
1760         if (new_sock < 0) {
1761                 Log( LOG_CRIT, "Can't create socket (af %d) : %s!", af_dest, strerror( errno ));
1762                 return;
1763         }
1764
1765         if (!Init_Socket(new_sock))
1766                 return;
1767
1768         /* is a bind address configured? */
1769         res = ng_ipaddr_af(&Conf_Server[Server].bind_addr);
1770         /* if yes, bind now. If it fails, warn and let connect() pick a source address */
1771         if (res && bind(new_sock, (struct sockaddr *) &Conf_Server[Server].bind_addr,
1772                                 ng_ipaddr_salen(&Conf_Server[Server].bind_addr)))
1773         {
1774                 ng_ipaddr_tostr_r(&Conf_Server[Server].bind_addr, ip_str);
1775                 Log(LOG_WARNING, "Can't bind socket to %s: %s!", ip_str, strerror(errno));
1776         }
1777         ng_ipaddr_setport(dest, Conf_Server[Server].port);
1778         res = connect(new_sock, (struct sockaddr *) dest, ng_ipaddr_salen(dest));
1779         if(( res != 0 ) && ( errno != EINPROGRESS )) {
1780                 Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
1781                 close( new_sock );
1782                 return;
1783         }
1784
1785         if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)new_sock)) {
1786                 Log(LOG_ALERT,
1787                     "Cannot allocate memory for server connection (socket %d)",
1788                     new_sock);
1789                 close( new_sock );
1790                 return;
1791         }
1792
1793         My_Connections = array_start(&My_ConnArray);
1794
1795         assert(My_Connections[new_sock].sock <= 0);
1796
1797         Init_Conn_Struct(new_sock);
1798
1799         ng_ipaddr_tostr_r(dest, ip_str);
1800         c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWNSERVER, false);
1801         if (!c) {
1802                 Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
1803                 close( new_sock );
1804                 return;
1805         }
1806
1807         /* Conn_Close() decrements this counter again */
1808         NumConnections++;
1809         Client_SetIntroducer( c, c );
1810         Client_SetToken( c, TOKEN_OUTBOUND );
1811
1812         /* Register connection */
1813         Conf_Server[Server].conn_id = new_sock;
1814         My_Connections[new_sock].sock = new_sock;
1815         My_Connections[new_sock].addr = *dest;
1816         My_Connections[new_sock].client = c;
1817         strlcpy( My_Connections[new_sock].host, Conf_Server[Server].host,
1818                                 sizeof(My_Connections[new_sock].host ));
1819
1820         /* Register new socket */
1821         if (!io_event_create( new_sock, IO_WANTWRITE, cb_connserver)) {
1822                 Log( LOG_ALERT, "io_event_create(): could not add fd %d", strerror(errno));
1823                 Conn_Close( new_sock, "io_event_create() failed", NULL, false );
1824                 Init_Conn_Struct( new_sock );
1825                 Conf_Server[Server].conn_id = NONE;
1826         }
1827 #ifdef SSL_SUPPORT
1828         if (Conf_Server[Server].SSLConnect && !ConnSSL_PrepareConnect( &My_Connections[new_sock],
1829                                                                 &Conf_Server[Server] ))
1830         {
1831                 Log(LOG_ALERT, "Could not initialize SSL for outgoing connection");
1832                 Conn_Close( new_sock, "Could not initialize SSL for outgoing connection", NULL, false );
1833                 Init_Conn_Struct( new_sock );
1834                 Conf_Server[Server].conn_id = NONE;
1835                 return;
1836         }
1837 #endif
1838         LogDebug("Registered new connection %d on socket %d (%ld in total).",
1839                  new_sock, My_Connections[new_sock].sock, NumConnections);
1840         Conn_OPTION_ADD( &My_Connections[new_sock], CONN_ISCONNECTING );
1841 } /* New_Server */
1842
1843
1844 /**
1845  * Initialize connection structure.
1846  */
1847 static void
1848 Init_Conn_Struct(CONN_ID Idx)
1849 {
1850         time_t now = time(NULL);
1851
1852         memset(&My_Connections[Idx], 0, sizeof(CONNECTION));
1853         My_Connections[Idx].sock = -1;
1854         My_Connections[Idx].signon = now;
1855         My_Connections[Idx].lastdata = now;
1856         My_Connections[Idx].lastprivmsg = now;
1857         Resolve_Init(&My_Connections[Idx].res_stat);
1858 } /* Init_Conn_Struct */
1859
1860
1861 static bool
1862 Init_Socket( int Sock )
1863 {
1864         /* Initialize socket (set options) */
1865
1866         int value;
1867
1868         if (!io_setnonblock(Sock)) {
1869                 Log( LOG_CRIT, "Can't enable non-blocking mode for socket: %s!", strerror( errno ));
1870                 close( Sock );
1871                 return false;
1872         }
1873
1874         /* Don't block this port after socket shutdown */
1875         value = 1;
1876         if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &value, (socklen_t)sizeof( value )) != 0 )
1877         {
1878                 Log( LOG_ERR, "Can't set socket option SO_REUSEADDR: %s!", strerror( errno ));
1879                 /* ignore this error */
1880         }
1881
1882         /* Set type of service (TOS) */
1883 #if defined(IPPROTO_IP) && defined(IPTOS_LOWDELAY)
1884         value = IPTOS_LOWDELAY;
1885         LogDebug("Setting IP_TOS on socket %d to IPTOS_LOWDELAY.", Sock);
1886         if (setsockopt(Sock, IPPROTO_IP, IP_TOS, &value,
1887                        (socklen_t) sizeof(value))) {
1888                 Log(LOG_ERR, "Can't set socket option IP_TOS: %s!",
1889                     strerror(errno));
1890                 /* ignore this error */
1891         }
1892 #endif
1893
1894         return true;
1895 } /* Init_Socket */
1896
1897
1898 static void
1899 cb_Connect_to_Server(int fd, UNUSED short events)
1900 {
1901         /* Read result of resolver sub-process from pipe and start connection */
1902         int i;
1903         size_t len;
1904         ng_ipaddr_t dest_addrs[4];      /* we can handle at most 3; but we read up to
1905                                            four so we can log the 'more than we can handle'
1906                                            condition. First result is tried immediately, rest
1907                                            is saved for later if needed. */
1908
1909         LogDebug("Resolver: Got forward lookup callback on fd %d, events %d", fd, events);
1910
1911         for (i=0; i < MAX_SERVERS; i++) {
1912                   if (Resolve_Getfd(&Conf_Server[i].res_stat) == fd )
1913                           break;
1914         }
1915
1916         if( i >= MAX_SERVERS) {
1917                 /* Ops, no matching server found?! */
1918                 io_close( fd );
1919                 LogDebug("Resolver: Got Forward Lookup callback for unknown server!?");
1920                 return;
1921         }
1922
1923         /* Read result from pipe */
1924         len = Resolve_Read(&Conf_Server[i].res_stat, dest_addrs, sizeof(dest_addrs));
1925         if (len == 0)
1926                 return;
1927
1928         assert((len % sizeof(ng_ipaddr_t)) == 0);
1929
1930         LogDebug("Got result from resolver: %u structs (%u bytes).", len/sizeof(ng_ipaddr_t), len);
1931
1932         memset(&Conf_Server[i].dst_addr, 0, sizeof(Conf_Server[i].dst_addr));
1933         if (len > sizeof(ng_ipaddr_t)) {
1934                 /* more than one address for this hostname, remember them
1935                  * in case first address is unreachable/not available */
1936                 len -= sizeof(ng_ipaddr_t);
1937                 if (len > sizeof(Conf_Server[i].dst_addr)) {
1938                         len = sizeof(Conf_Server[i].dst_addr);
1939                         Log(LOG_NOTICE,
1940                                 "Notice: Resolver returned more IP Addresses for host than we can handle, additional addresses dropped.");
1941                 }
1942                 memcpy(&Conf_Server[i].dst_addr, &dest_addrs[1], len);
1943         }
1944         /* connect() */
1945         New_Server(i, dest_addrs);
1946 } /* cb_Read_Forward_Lookup */
1947
1948
1949 static void
1950 cb_Read_Resolver_Result( int r_fd, UNUSED short events )
1951 {
1952         /* Read result of resolver sub-process from pipe and update the
1953          * apropriate connection/client structure(s): hostname and/or
1954          * IDENT user name.*/
1955
1956         CLIENT *c;
1957         int i;
1958         size_t len;
1959         char *identptr;
1960 #ifdef IDENTAUTH
1961         char readbuf[HOST_LEN + 2 + CLIENT_USER_LEN];
1962 #else
1963         char readbuf[HOST_LEN + 1];
1964 #endif
1965
1966         LogDebug("Resolver: Got callback on fd %d, events %d", r_fd, events );
1967
1968         /* Search associated connection ... */
1969         for( i = 0; i < Pool_Size; i++ ) {
1970                 if(( My_Connections[i].sock != NONE )
1971                   && ( Resolve_Getfd(&My_Connections[i].res_stat) == r_fd ))
1972                         break;
1973         }
1974         if( i >= Pool_Size ) {
1975                 /* Ops, none found? Probably the connection has already
1976                  * been closed!? We'll ignore that ... */
1977                 io_close( r_fd );
1978                 LogDebug("Resolver: Got callback for unknown connection!?");
1979                 return;
1980         }
1981
1982         /* Read result from pipe */
1983         len = Resolve_Read(&My_Connections[i].res_stat, readbuf, sizeof readbuf -1);
1984         if (len == 0)
1985                 return;
1986
1987         readbuf[len] = '\0';
1988         identptr = strchr(readbuf, '\n');
1989         assert(identptr != NULL);
1990         if (!identptr) {
1991                 Log( LOG_CRIT, "Resolver: Got malformed result!");
1992                 return;
1993         }
1994
1995         *identptr = '\0';
1996         LogDebug("Got result from resolver: \"%s\" (%u bytes read).", readbuf, len);
1997         /* Okay, we got a complete result: this is a host name for outgoing
1998          * connections and a host name and IDENT user name (if enabled) for
1999          * incoming connections.*/
2000         assert ( My_Connections[i].sock >= 0 );
2001         /* Incoming connection. Search client ... */
2002         c = Conn_GetClient( i );
2003         assert( c != NULL );
2004
2005         /* Only update client information of unregistered clients.
2006          * Note: user commands (e. g. WEBIRC) are always read _after_ reading
2007          * the resolver results, so we don't have to worry to override settings
2008          * from these commands here. */
2009         if(Client_Type(c) == CLIENT_UNKNOWN) {
2010                 strlcpy(My_Connections[i].host, readbuf,
2011                         sizeof(My_Connections[i].host));
2012                 Client_SetHostname(c, readbuf);
2013 #ifdef IDENTAUTH
2014                 ++identptr;
2015                 if (*identptr) {
2016                         Log(LOG_INFO, "IDENT lookup for connection %d: \"%s\".", i, identptr);
2017                         Client_SetUser(c, identptr, true);
2018                 } else {
2019                         Log(LOG_INFO, "IDENT lookup for connection %d: no result.", i);
2020                 }
2021 #endif
2022         }
2023 #ifdef DEBUG
2024                 else Log( LOG_DEBUG, "Resolver: discarding result for already registered connection %d.", i );
2025 #endif
2026         /* Reset penalty time */
2027         Conn_ResetPenalty( i );
2028 } /* cb_Read_Resolver_Result */
2029
2030
2031 /**
2032  * Write a "simple" (error) message to a socket.
2033  * The message is sent without using the connection write buffers, without
2034  * compression/encryption, and even without any error reporting. It is
2035  * designed for error messages of e.g. New_Connection(). */
2036 static void
2037 Simple_Message(int Sock, const char *Msg)
2038 {
2039         char buf[COMMAND_LEN];
2040         size_t len;
2041
2042         assert(Sock > NONE);
2043         assert(Msg != NULL);
2044
2045         strlcpy(buf, Msg, sizeof buf - 2);
2046         len = strlcat(buf, "\r\n", sizeof buf);
2047         if (write(Sock, buf, len) < 0) {
2048                 /* Because this function most probably got called to log
2049                  * an error message, any write error is ignored here to
2050                  * avoid an endless loop. But casting the result of write()
2051                  * to "void" doesn't satisfy the GNU C code attribute
2052                  * "warn_unused_result" which is used by some versions of
2053                  * glibc (e.g. 2.11.1), therefore this silly error
2054                  * "handling" code here :-( */
2055                 return;
2056         }
2057 } /* Simple_Error */
2058
2059
2060 /**
2061  * Get CLIENT structure that belongs to a local connection identified by its
2062  * index number. Each connection belongs to a client by definition, so it is
2063  * not required that the caller checks for NULL return values.
2064  * @param Idx Connection index number
2065  * @return Pointer to CLIENT structure
2066  */
2067 GLOBAL CLIENT *
2068 Conn_GetClient( CONN_ID Idx )
2069 {
2070         CONNECTION *c;
2071
2072         assert(Idx >= 0);
2073         c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
2074         assert(c != NULL);
2075         return c ? c->client : NULL;
2076 }
2077
2078
2079 #ifdef SSL_SUPPORT
2080
2081 /**
2082  * Get information about used SSL chiper.
2083  * @param Idx Connection index number
2084  * @param buf Buffer for returned information text
2085  * @param len Size of return buffer "buf"
2086  * @return true on success, false otherwise
2087  */
2088 GLOBAL bool
2089 Conn_GetCipherInfo(CONN_ID Idx, char *buf, size_t len)
2090 {
2091         if (Idx < 0)
2092                 return false;
2093         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2094         return ConnSSL_GetCipherInfo(&My_Connections[Idx], buf, len);
2095 }
2096
2097
2098 /**
2099  * Check if a connection is SSL-enabled or not.
2100  * @param Idx Connection index number
2101  * @return true if connection is SSL-enabled, false otherwise.
2102  */
2103 GLOBAL bool
2104 Conn_UsesSSL(CONN_ID Idx)
2105 {
2106         if (Idx < 0)
2107                 return false;
2108         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2109         return Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL);
2110 }
2111
2112 #endif
2113
2114
2115 /* -eof- */