src/ngircd/conn.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001-2010 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 static void Account_Connection PARAMS((void));
  99
 100
 101 static array My_Listeners;
 102 static array My_ConnArray;
 103 static size_t NumConnections, NumConnectionsMax, NumConnectionsAccepted;
 104
 105 #ifdef TCPWRAP
 106 int allow_severity = LOG_INFO;
 107 int deny_severity = LOG_ERR;
 108 #endif
 109
 110 static void server_login PARAMS((CONN_ID idx));
 111
 112 #ifdef SSL_SUPPORT
 113 extern struct SSLOptions Conf_SSLOptions;
 114 static void cb_connserver_login_ssl PARAMS((int sock, short what));
 115 static void cb_clientserver_ssl PARAMS((int sock, short what));
 116 #endif
 117 static void cb_Read_Resolver_Result PARAMS((int sock, UNUSED short what));
 118 static void cb_Connect_to_Server PARAMS((int sock, UNUSED short what));
 119 static void cb_clientserver PARAMS((int sock, short what));
 120
 121
 122 /**
 123  * IO callback for listening sockets: handle new connections. This callback
 124  * gets called when a new non-SSL connection should be accepted.
 125  * @param sock Socket descriptor
 126  * @param irrelevant (ignored IO specification)
 127  */
 128 static void
 129 cb_listen(int sock, short irrelevant)
 130 {
 131         (void) irrelevant;
 132         (void) New_Connection(sock);
 133 }
 134
 135
 136 #ifdef SSL_SUPPORT
 137 /**
 138  * IO callback for listening SSL sockets: handle new connections. This callback
 139  * gets called when a new SSL-enabled connection should be accepted.
 140  * @param sock Socket descriptor
 141  * @param irrelevant (ignored IO specification)
 142  */
 143 static void
 144 cb_listen_ssl(int sock, short irrelevant)
 145 {
 146         int fd;
 147
 148         (void) irrelevant;
 149         fd = New_Connection(sock);
 150         if (fd < 0)
 151                 return;
 152         io_event_setcb(My_Connections[fd].sock, cb_clientserver_ssl);
 153 }
 154 #endif
 155
 156
 157 /**
 158  * IO callback for new outgoing non-SSL server connections.
 159  * @param sock Socket descriptor
 160  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 161  */
 162 static void
 163 cb_connserver(int sock, UNUSED short what)
 164 {
 165         int res, err, server;
 166         socklen_t sock_len;
 167         CONN_ID idx = Socket2Index( sock );
 168
 169         if (idx <= NONE) {
 170                 LogDebug("cb_connserver wants to write on unknown socket?!");
 171                 io_close(sock);
 172                 return;
 173         }
 174
 175         assert(what & IO_WANTWRITE);
 176
 177         /* Make sure that the server is still configured; it could have been
 178          * removed in the meantime! */
 179         server = Conf_GetServer(idx);
 180         if (server < 0) {
 181                 Log(LOG_ERR, "Connection on socket %d to \"%s\" aborted!",
 182                     sock, My_Connections[idx].host);
 183                 Conn_Close(idx, "Connection aborted!", NULL, false);
 184                 return;
 185         }
 186
 187         /* connect() finished, get result. */
 188         sock_len = (socklen_t)sizeof(err);
 189         res = getsockopt(My_Connections[idx].sock, SOL_SOCKET, SO_ERROR,
 190                          &err, &sock_len );
 191         assert(sock_len == sizeof(err));
 192
 193         /* Error while connecting? */
 194         if ((res != 0) || (err != 0)) {
 195                 if (res != 0)
 196                         Log(LOG_CRIT, "getsockopt (connection %d): %s!",
 197                             idx, strerror(errno));
 198                 else
 199                         Log(LOG_CRIT,
 200                             "Can't connect socket to \"%s:%d\" (connection %d): %s!",
 201                             My_Connections[idx].host, Conf_Server[server].port,
 202                             idx, strerror(err));
 203
 204                 Conn_Close(idx, "Can't connect!", NULL, false);
 205
 206                 if (ng_ipaddr_af(&Conf_Server[server].dst_addr[0])) {
 207                         /* more addresses to try... */
 208                         New_Server(res, &Conf_Server[server].dst_addr[0]);
 209                         /* connection to dst_addr[0] is now in progress, so
 210                          * remove this address... */
 211                         Conf_Server[server].dst_addr[0] =
 212                                 Conf_Server[server].dst_addr[1];
 213                         memset(&Conf_Server[server].dst_addr[1], 0,
 214                                sizeof(Conf_Server[server].dst_addr[1]));
 215                 }
 216                 return;
 217         }
 218
 219         /* connect() succeeded, remove all additional addresses */
 220         memset(&Conf_Server[server].dst_addr, 0,
 221                sizeof(Conf_Server[server].dst_addr));
 222
 223         Conn_OPTION_DEL( &My_Connections[idx], CONN_ISCONNECTING );
 224 #ifdef SSL_SUPPORT
 225         if ( Conn_OPTION_ISSET( &My_Connections[idx], CONN_SSL_CONNECT )) {
 226                 io_event_setcb( sock, cb_connserver_login_ssl );
 227                 io_event_add( sock, IO_WANTWRITE|IO_WANTREAD );
 228                 return;
 229         }
 230 #endif
 231         server_login(idx);
 232 }
 233
 234
 235 /**
 236  * Login to a remote server.
 237  * @param idx Connection index
 238  */
 239 static void
 240 server_login(CONN_ID idx)
 241 {
 242         Log( LOG_INFO, "Connection %d with \"%s:%d\" established. Now logging in ...", idx,
 243                         My_Connections[idx].host, Conf_Server[Conf_GetServer( idx )].port );
 244
 245         io_event_setcb( My_Connections[idx].sock, cb_clientserver);
 246         io_event_add( My_Connections[idx].sock, IO_WANTREAD|IO_WANTWRITE);
 247
 248         /* Send PASS and SERVER command to peer */
 249         Conn_WriteStr( idx, "PASS %s %s", Conf_Server[Conf_GetServer( idx )].pwd_out, NGIRCd_ProtoID );
 250         Conn_WriteStr( idx, "SERVER %s :%s", Conf_ServerName, Conf_ServerInfo );
 251 }
 252
 253
 254 #ifdef SSL_SUPPORT
 255 /**
 256  * IO callback for new outgoing SSL-enabled server connections.
 257  * @param sock Socket descriptor
 258  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 259  */
 260 static void
 261 cb_connserver_login_ssl(int sock, short unused)
 262 {
 263         CONN_ID idx = Socket2Index(sock);
 264
 265         assert(idx >= 0);
 266         if (idx < 0) {
 267                 io_close(sock);
 268                 return;
 269         }
 270         (void) unused;
 271         switch (ConnSSL_Connect( &My_Connections[idx])) {
 272         case 1: break;
 273         case 0: LogDebug("ConnSSL_Connect: not ready");
 274                 return;
 275         case -1:
 276                 Log(LOG_ERR, "SSL connection on socket %d failed!", sock);
 277                 Conn_Close(idx, "Can't connect!", NULL, false);
 278                 return;
 279         }
 280
 281         Log( LOG_INFO, "SSL connection %d with \"%s:%d\" established.", idx,
 282                         My_Connections[idx].host, Conf_Server[Conf_GetServer( idx )].port );
 283
 284         server_login(idx);
 285 }
 286 #endif
 287
 288
 289 /**
 290  * IO callback for established non-SSL client and server connections.
 291  * @param sock Socket descriptor
 292  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 293  */
 294 static void
 295 cb_clientserver(int sock, short what)
 296 {
 297         CONN_ID idx = Socket2Index(sock);
 298
 299         assert(idx >= 0);
 300
 301         if (idx < 0) {
 302                 io_close(sock);
 303                 return;
 304         }
 305 #ifdef SSL_SUPPORT
 306         if (what & IO_WANTREAD
 307             || (Conn_OPTION_ISSET(&My_Connections[idx], CONN_SSL_WANT_WRITE))) {
 308                 /* if TLS layer needs to write additional data, call
 309                  * Read_Request() instead so that SSL/TLS can continue */
 310                 Read_Request(idx);
 311         }
 312 #else
 313         if (what & IO_WANTREAD)
 314                 Read_Request(idx);
 315 #endif
 316         if (what & IO_WANTWRITE)
 317                 Handle_Write(idx);
 318 }
 319
 320
 321 #ifdef SSL_SUPPORT
 322 /**
 323  * IO callback for established SSL-enabled client and server connections.
 324  * @param sock Socket descriptor
 325  * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
 326  */
 327 static void
 328 cb_clientserver_ssl(int sock, short what)
 329 {
 330         CONN_ID idx = Socket2Index(sock);
 331
 332         assert(idx >= 0);
 333
 334         if (idx < 0) {
 335                 io_close(sock);
 336                 return;
 337         }
 338
 339         switch (ConnSSL_Accept(&My_Connections[idx])) {
 340         case 1:
 341                 break;  /* OK */
 342         case 0:
 343                 return; /* EAGAIN: callback will be invoked again by IO layer */
 344         default:
 345                 Conn_Close(idx, "SSL accept error, closing socket", "SSL accept error", false);
 346                 return;
 347         }
 348         if (what & IO_WANTREAD)
 349                 Read_Request(idx);
 350
 351         if (what & IO_WANTWRITE)
 352                 Handle_Write(idx);
 353
 354         io_event_setcb(sock, cb_clientserver);  /* SSL handshake completed */
 355 }
 356 #endif
 357
 358
 359 /**
 360  * Initialite connecion module.
 361  */
 362 GLOBAL void
 363 Conn_Init( void )
 364 {
 365         CONN_ID i;
 366
 367         /* Speicher fuer Verbindungs-Pool anfordern */
 368         Pool_Size = CONNECTION_POOL;
 369         if ((Conf_MaxConnections > 0) &&
 370                 (Pool_Size > Conf_MaxConnections))
 371                         Pool_Size = Conf_MaxConnections;
 372
 373         if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)Pool_Size)) {
 374                 Log(LOG_EMERG, "Can't allocate memory! [Conn_Init]");
 375                 exit(1);
 376         }
 377
 378         /* FIXME: My_Connetions/Pool_Size is needed by other parts of the
 379          * code; remove them! */
 380         My_Connections = (CONNECTION*) array_start(&My_ConnArray);
 381
 382         LogDebug("Allocated connection pool for %d items (%ld bytes).",
 383                 array_length(&My_ConnArray, sizeof(CONNECTION)),
 384                 array_bytes(&My_ConnArray));
 385
 386         assert(array_length(&My_ConnArray, sizeof(CONNECTION)) >= (size_t)Pool_Size);
 387
 388         array_free( &My_Listeners );
 389
 390         for (i = 0; i < Pool_Size; i++)
 391                 Init_Conn_Struct(i);
 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, const char *Format, ...)
 813 #else
 814 GLOBAL bool
 815 Conn_WriteStr(Idx, Format, va_alist)
 816 CONN_ID Idx;
 817 const 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 long
1105 Conn_Count(void)
1106 {
1107         return NumConnections;
1108 } /* Conn_Count */
1109
1110
1111 GLOBAL long
1112 Conn_CountMax(void)
1113 {
1114         return NumConnectionsMax;
1115 } /* Conn_CountMax */
1116
1117
1118 GLOBAL long
1119 Conn_CountAccepted(void)
1120 {
1121         return NumConnectionsAccepted;
1122 } /* Conn_CountAccepted */
1123
1124
1125 GLOBAL void
1126 Conn_SyncServerStruct( void )
1127 {
1128         /* Synchronize server structures (connection IDs):
1129          * connections <-> configuration */
1130
1131         CLIENT *client;
1132         CONN_ID i;
1133         int c;
1134
1135         for( i = 0; i < Pool_Size; i++ ) {
1136                 /* Established connection? */
1137                 if (My_Connections[i].sock < 0)
1138                         continue;
1139
1140                 /* Server connection? */
1141                 client = Conn_GetClient( i );
1142                 if(( ! client ) || ( Client_Type( client ) != CLIENT_SERVER )) continue;
1143
1144                 for( c = 0; c < MAX_SERVERS; c++ )
1145                 {
1146                         /* Configured server? */
1147                         if( ! Conf_Server[c].host[0] ) continue;
1148
1149                         /* Duplicate? */
1150                         if( strcmp( Conf_Server[c].name, Client_ID( client )) == 0 )
1151                                 Conf_Server[c].conn_id = i;
1152                 }
1153         }
1154 } /* SyncServerStruct */
1155
1156
1157 /**
1158  * Send out data of write buffer; connect new sockets.
1159  */
1160 static bool
1161 Handle_Write( CONN_ID Idx )
1162 {
1163         ssize_t len;
1164         size_t wdatalen;
1165
1166         assert( Idx > NONE );
1167         if ( My_Connections[Idx].sock < 0 ) {
1168                 LogDebug("Handle_Write() on closed socket, connection %d", Idx);
1169                 return false;
1170         }
1171         assert( My_Connections[Idx].sock > NONE );
1172
1173         wdatalen = array_bytes(&My_Connections[Idx].wbuf );
1174
1175 #ifdef ZLIB
1176         if (wdatalen == 0) {
1177                 /* Write buffer is empty, so we try to flush the compression
1178                  * buffer and get some data to work with from there :-) */
1179                 if (!Zip_Flush(Idx))
1180                         return false;
1181
1182                 /* Now the write buffer most probably has changed: */
1183                 wdatalen = array_bytes(&My_Connections[Idx].wbuf);
1184         }
1185 #endif
1186
1187         if (wdatalen == 0) {
1188                 /* Still no data, fine. */
1189                 io_event_del(My_Connections[Idx].sock, IO_WANTWRITE );
1190                 return true;
1191         }
1192
1193         LogDebug
1194             ("Handle_Write() called for connection %d, %ld bytes pending ...",
1195              Idx, wdatalen);
1196
1197 #ifdef SSL_SUPPORT
1198         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_SSL )) {
1199                 len = ConnSSL_Write(&My_Connections[Idx], array_start(&My_Connections[Idx].wbuf), wdatalen);
1200         } else
1201 #endif
1202         {
1203                 len = write(My_Connections[Idx].sock,
1204                             array_start(&My_Connections[Idx].wbuf), wdatalen );
1205         }
1206         if( len < 0 ) {
1207                 if (errno == EAGAIN || errno == EINTR)
1208                         return true;
1209
1210                 Log(LOG_ERR, "Write error on connection %d (socket %d): %s!",
1211                     Idx, My_Connections[Idx].sock, strerror(errno));
1212                 Conn_Close(Idx, "Write error!", NULL, false);
1213                 return false;
1214         }
1215
1216         /* move any data not yet written to beginning */
1217         array_moveleft(&My_Connections[Idx].wbuf, 1, (size_t)len);
1218
1219         return true;
1220 } /* Handle_Write */
1221
1222
1223 static int
1224 Count_Connections(ng_ipaddr_t *a)
1225 {
1226         int i, cnt;
1227
1228         cnt = 0;
1229         for (i = 0; i < Pool_Size; i++) {
1230                 if (My_Connections[i].sock <= NONE)
1231                         continue;
1232                 if (ng_ipaddr_ipequal(&My_Connections[i].addr, a))
1233                         cnt++;
1234         }
1235         return cnt;
1236 } /* Count_Connections */
1237
1238
1239 /**
1240  * Initialize new client connection on a listening socket.
1241  * @param Sock Listening socket descriptor
1242  * @return Accepted socket descriptor or -1 on error
1243  */
1244 static int
1245 New_Connection(int Sock)
1246 {
1247 #ifdef TCPWRAP
1248         struct request_info req;
1249 #endif
1250         ng_ipaddr_t new_addr;
1251         char ip_str[NG_INET_ADDRSTRLEN];
1252         int new_sock, new_sock_len, identsock;
1253         CLIENT *c;
1254         long cnt;
1255
1256         assert(Sock > NONE);
1257
1258         new_sock_len = (int)sizeof(new_addr);
1259         new_sock = accept(Sock, (struct sockaddr *)&new_addr,
1260                           (socklen_t *)&new_sock_len);
1261         if (new_sock < 0) {
1262                 Log(LOG_CRIT, "Can't accept connection: %s!", strerror(errno));
1263                 return -1;
1264         }
1265         NumConnectionsAccepted++;
1266
1267         if (!ng_ipaddr_tostr_r(&new_addr, ip_str)) {
1268                 Log(LOG_CRIT, "fd %d: Can't convert IP address!", new_sock);
1269                 Simple_Message(new_sock, "ERROR :Internal Server Error");
1270                 close(new_sock);
1271                 return -1;
1272         }
1273
1274 #ifdef TCPWRAP
1275         /* Validate socket using TCP Wrappers */
1276         request_init(&req, RQ_DAEMON, PACKAGE_NAME, RQ_FILE, new_sock,
1277                      RQ_CLIENT_SIN, &new_addr, NULL);
1278         fromhost(&req);
1279         if (!hosts_access(&req)) {
1280                 Log(deny_severity,
1281                     "Refused connection from %s (by TCP Wrappers)!", ip_str);
1282                 Simple_Message(new_sock, "ERROR :Connection refused");
1283                 close(new_sock);
1284                 return -1;
1285         }
1286 #endif
1287
1288         if (!Init_Socket(new_sock))
1289                 return -1;
1290
1291         /* Check global connection limit */
1292         if ((Conf_MaxConnections > 0) &&
1293             (NumConnections >= (size_t) Conf_MaxConnections)) {
1294                 Log(LOG_ALERT, "Can't accept connection: limit (%d) reached!",
1295                     Conf_MaxConnections);
1296                 Simple_Message(new_sock, "ERROR :Connection limit reached");
1297                 close(new_sock);
1298                 return -1;
1299         }
1300
1301         /* Check IP-based connection limit */
1302         cnt = Count_Connections(&new_addr);
1303         if ((Conf_MaxConnectionsIP > 0) && (cnt >= Conf_MaxConnectionsIP)) {
1304                 /* Access denied, too many connections from this IP address! */
1305                 Log(LOG_ERR,
1306                     "Refused connection from %s: too may connections (%ld) from this IP address!",
1307                     ip_str, cnt);
1308                 Simple_Message(new_sock,
1309                                "ERROR :Connection refused, too many connections from your IP address!");
1310                 close(new_sock);
1311                 return -1;
1312         }
1313
1314         if (new_sock >= Pool_Size) {
1315                 if (!array_alloc(&My_ConnArray, sizeof(CONNECTION),
1316                                  (size_t) new_sock)) {
1317                         Log(LOG_EMERG,
1318                             "Can't allocate memory! [New_Connection]");
1319                         Simple_Message(new_sock, "ERROR: Internal error");
1320                         close(new_sock);
1321                         return -1;
1322                 }
1323                 LogDebug("Bumped connection pool to %ld items (internal: %ld items, %ld bytes)",
1324                          new_sock, array_length(&My_ConnArray,
1325                          sizeof(CONNECTION)), array_bytes(&My_ConnArray));
1326
1327                 /* Adjust pointer to new block */
1328                 My_Connections = array_start(&My_ConnArray);
1329                 while (Pool_Size <= new_sock)
1330                         Init_Conn_Struct(Pool_Size++);
1331         }
1332
1333         /* register callback */
1334         if (!io_event_create(new_sock, IO_WANTREAD, cb_clientserver)) {
1335                 Log(LOG_ALERT,
1336                     "Can't accept connection: io_event_create failed!");
1337                 Simple_Message(new_sock, "ERROR :Internal error");
1338                 close(new_sock);
1339                 return -1;
1340         }
1341
1342         c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWN, false);
1343         if (!c) {
1344                 Log(LOG_ALERT,
1345                     "Can't accept connection: can't create client structure!");
1346                 Simple_Message(new_sock, "ERROR :Internal error");
1347                 io_close(new_sock);
1348                 return -1;
1349         }
1350
1351         Init_Conn_Struct(new_sock);
1352         My_Connections[new_sock].sock = new_sock;
1353         My_Connections[new_sock].addr = new_addr;
1354         My_Connections[new_sock].client = c;
1355
1356         /* Set initial hostname to IP address. This becomes overwritten when
1357          * the DNS lookup is enabled and succeeds, but is used otherwise. */
1358         if (ng_ipaddr_af(&new_addr) != AF_INET)
1359                 snprintf(My_Connections[new_sock].host,
1360                          sizeof(My_Connections[new_sock].host), "[%s]", ip_str);
1361         else
1362                 strlcpy(My_Connections[new_sock].host, ip_str,
1363                         sizeof(My_Connections[new_sock].host));
1364
1365         Client_SetHostname(c, My_Connections[new_sock].host);
1366
1367         Log(LOG_INFO, "Accepted connection %d from %s:%d on socket %d.",
1368             new_sock, My_Connections[new_sock].host,
1369             ng_ipaddr_getport(&new_addr), Sock);
1370
1371         identsock = new_sock;
1372 #ifdef IDENTAUTH
1373         if (Conf_NoIdent)
1374                 identsock = -1;
1375 #endif
1376         if (!Conf_NoDNS)
1377                 Resolve_Addr(&My_Connections[new_sock].res_stat, &new_addr,
1378                              identsock, cb_Read_Resolver_Result);
1379
1380         /* ngIRCd waits up to 4 seconds for the result of the asynchronous
1381          * DNS and IDENT resolver subprocess using the "penalty" mechanism.
1382          * If there are results earlier, the delay is aborted. */
1383         Conn_SetPenalty(new_sock, 4);
1384
1385         Account_Connection();
1386         return new_sock;
1387 } /* New_Connection */
1388
1389
1390 static void
1391 Account_Connection(void)
1392 {
1393         NumConnections++;
1394         if (NumConnections > NumConnectionsMax)
1395                 NumConnectionsMax = NumConnections;
1396         LogDebug("Total number of connections now %lu (max %lu).",
1397                  NumConnections, NumConnectionsMax);
1398 } /* Account_Connection */
1399
1400
1401 static CONN_ID
1402 Socket2Index( int Sock )
1403 {
1404         assert( Sock >= 0 );
1405
1406         if( Sock >= Pool_Size || My_Connections[Sock].sock != Sock ) {
1407                 /* the Connection was already closed again, likely due to
1408                  * an error. */
1409                 LogDebug("Socket2Index: can't get connection for socket %d!", Sock);
1410                 return NONE;
1411         }
1412         return Sock;
1413 } /* Socket2Index */
1414
1415
1416 /**
1417  * Read data from the network to the read buffer. If an error occures,
1418  * the socket of this connection will be shut down.
1419  */
1420 static void
1421 Read_Request( CONN_ID Idx )
1422 {
1423         ssize_t len;
1424         static const unsigned int maxbps = COMMAND_LEN / 2;
1425         char readbuf[READBUFFER_LEN];
1426         time_t t;
1427         CLIENT *c;
1428         assert( Idx > NONE );
1429         assert( My_Connections[Idx].sock > NONE );
1430
1431 #ifdef ZLIB
1432         if ((array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN) ||
1433                 (array_bytes(&My_Connections[Idx].zip.rbuf) >= READBUFFER_LEN))
1434 #else
1435         if (array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN)
1436 #endif
1437         {
1438                 /* Read buffer is full */
1439                 Log(LOG_ERR,
1440                     "Receive buffer overflow (connection %d): %d bytes!",
1441                     Idx, array_bytes(&My_Connections[Idx].rbuf));
1442                 Conn_Close( Idx, "Receive buffer overflow!", NULL, false );
1443                 return;
1444         }
1445
1446 #ifdef SSL_SUPPORT
1447         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL))
1448                 len = ConnSSL_Read( &My_Connections[Idx], readbuf, sizeof(readbuf));
1449         else
1450 #endif
1451         len = read(My_Connections[Idx].sock, readbuf, sizeof(readbuf));
1452         if (len == 0) {
1453                 Log(LOG_INFO, "%s:%u (%s) is closing the connection ...",
1454                                 My_Connections[Idx].host,
1455                                 (unsigned int) ng_ipaddr_getport(&My_Connections[Idx].addr),
1456                                 ng_ipaddr_tostr(&My_Connections[Idx].addr));
1457                 Conn_Close(Idx,
1458                            "Socket closed!", "Client closed connection",
1459                            false);
1460                 return;
1461         }
1462
1463         if (len < 0) {
1464                 if( errno == EAGAIN ) return;
1465                 Log(LOG_ERR, "Read error on connection %d (socket %d): %s!",
1466                     Idx, My_Connections[Idx].sock, strerror(errno));
1467                 Conn_Close(Idx, "Read error!", "Client closed connection",
1468                            false);
1469                 return;
1470         }
1471 #ifdef ZLIB
1472         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1473                 if (!array_catb(&My_Connections[Idx].zip.rbuf, readbuf,
1474                                 (size_t) len)) {
1475                         Log(LOG_ERR,
1476                             "Could not append recieved data to zip input buffer (connn %d): %d bytes!",
1477                             Idx, len);
1478                         Conn_Close(Idx, "Receive buffer overflow!", NULL,
1479                                    false);
1480                         return;
1481                 }
1482         } else
1483 #endif
1484         {
1485                 if (!array_catb( &My_Connections[Idx].rbuf, readbuf, len)) {
1486                         Log( LOG_ERR, "Could not append recieved data to input buffer (connn %d): %d bytes!", Idx, len );
1487                         Conn_Close( Idx, "Receive buffer overflow!", NULL, false );
1488                 }
1489         }
1490
1491         /* Update connection statistics */
1492         My_Connections[Idx].bytes_in += len;
1493
1494         /* Update timestamp of last data received if this connection is
1495          * registered as a user, server or service connection. Don't update
1496          * otherwise, so users have at least Conf_PongTimeout seconds time to
1497          * register with the IRC server -- see Check_Connections().
1498          * Set "lastping", too, so we can handle time shifts backwards ... */
1499         c = Conn_GetClient(Idx);
1500         if (c && (Client_Type(c) == CLIENT_USER
1501                   || Client_Type(c) == CLIENT_SERVER
1502                   || Client_Type(c) == CLIENT_SERVICE)) {
1503                 t = time(NULL);
1504                 if (My_Connections[Idx].lastdata != t)
1505                         My_Connections[Idx].bps = 0;
1506
1507                 My_Connections[Idx].lastdata = t;
1508                 My_Connections[Idx].lastping = My_Connections[Idx].lastdata;
1509         }
1510
1511         /* Look at the data in the (read-) buffer of this connection */
1512         My_Connections[Idx].bps += Handle_Buffer(Idx);
1513         if (Client_Type(c) != CLIENT_SERVER
1514             && My_Connections[Idx].bps >= maxbps) {
1515                 LogDebug("Throttling connection %d: BPS exceeded! (%u >= %u)",
1516                          Idx, My_Connections[Idx].bps, maxbps);
1517                 Conn_SetPenalty(Idx, 1);
1518         }
1519 } /* Read_Request */
1520
1521
1522 /**
1523  * Handle all data in the connection read-buffer.
1524  * Data is processed until no complete command is left in the read buffer,
1525  * or MAX_COMMANDS[_SERVER] commands were processed.
1526  * When a fatal error occurs, the connection is shut down.
1527  * @param Idx Index of the connection.
1528  * @return number of bytes processed.
1529  */
1530 static unsigned int
1531 Handle_Buffer(CONN_ID Idx)
1532 {
1533 #ifndef STRICT_RFC
1534         char *ptr1, *ptr2, *first_eol;
1535 #endif
1536         char *ptr;
1537         size_t len, delta;
1538         time_t starttime;
1539 #ifdef ZLIB
1540         bool old_z;
1541 #endif
1542         unsigned int i, maxcmd = MAX_COMMANDS, len_processed = 0;
1543         CLIENT *c;
1544
1545         c = Conn_GetClient(Idx);
1546         assert( c != NULL);
1547
1548         /* Servers do get special command limits, so they can process
1549          * all the messages that are required while peering. */
1550         if (Client_Type(c) == CLIENT_SERVER)
1551                 maxcmd = MAX_COMMANDS_SERVER;
1552
1553         starttime = time(NULL);
1554         for (i=0; i < maxcmd; i++) {
1555                 /* Check penalty */
1556                 if (My_Connections[Idx].delaytime > starttime)
1557                         return 0;
1558 #ifdef ZLIB
1559                 /* Unpack compressed data, if compression is in use */
1560                 if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1561                         /* When unzipping fails, Unzip_Buffer() shuts
1562                          * down the connection itself */
1563                         if (!Unzip_Buffer(Idx))
1564                                 return 0;
1565                 }
1566 #endif
1567
1568                 if (0 == array_bytes(&My_Connections[Idx].rbuf))
1569                         break;
1570
1571                 /* Make sure that the buffer is NULL terminated */
1572                 if (!array_cat0_temporary(&My_Connections[Idx].rbuf)) {
1573                         Conn_Close(Idx, NULL,
1574                                    "Can't allocate memory [Handle_Buffer]",
1575                                    true);
1576                         return 0;
1577                 }
1578
1579                 /* RFC 2812, section "2.3 Messages", 5th paragraph:
1580                  * "IRC messages are always lines of characters terminated
1581                  * with a CR-LF (Carriage Return - Line Feed) pair [...]". */
1582                 delta = 2;
1583                 ptr = strstr(array_start(&My_Connections[Idx].rbuf), "\r\n");
1584
1585 #ifndef STRICT_RFC
1586                 /* Check for non-RFC-compliant request (only CR or LF)?
1587                  * Unfortunately, there are quite a few clients out there
1588                  * that do this -- e. g. mIRC, BitchX, and Trillian :-( */
1589                 ptr1 = strchr(array_start(&My_Connections[Idx].rbuf), '\r');
1590                 ptr2 = strchr(array_start(&My_Connections[Idx].rbuf), '\n');
1591                 if (ptr) {
1592                         /* Check if there is a single CR or LF _before_ the
1593                          * corerct CR+LF line terminator:  */
1594                         first_eol = ptr1 < ptr2 ? ptr1 : ptr2;
1595                         if (first_eol < ptr) {
1596                                 /* Single CR or LF before CR+LF found */
1597                                 ptr = first_eol;
1598                                 delta = 1;
1599                         }
1600                 } else if (ptr1 || ptr2) {
1601                         /* No CR+LF terminated command found, but single
1602                          * CR or LF found ... */
1603                         if (ptr1 && ptr2)
1604                                 ptr = ptr1 < ptr2 ? ptr1 : ptr2;
1605                         else
1606                                 ptr = ptr1 ? ptr1 : ptr2;
1607                         delta = 1;
1608                 }
1609 #endif
1610
1611                 if (!ptr)
1612                         break;
1613
1614                 /* Complete (=line terminated) request found, handle it! */
1615                 *ptr = '\0';
1616
1617                 len = ptr - (char *)array_start(&My_Connections[Idx].rbuf) + delta;
1618
1619                 if (len > (COMMAND_LEN - 1)) {
1620                         /* Request must not exceed 512 chars (incl. CR+LF!),
1621                          * see RFC 2812. Disconnect Client if this happens. */
1622                         Log(LOG_ERR,
1623                             "Request too long (connection %d): %d bytes (max. %d expected)!",
1624                             Idx, array_bytes(&My_Connections[Idx].rbuf),
1625                             COMMAND_LEN - 1);
1626                         Conn_Close(Idx, NULL, "Request too long", true);
1627                         return 0;
1628                 }
1629
1630                 len_processed += (unsigned int)len;
1631                 if (len <= delta) {
1632                         /* Request is empty (only '\r\n', '\r' or '\n');
1633                          * delta is 2 ('\r\n') or 1 ('\r' or '\n'), see above */
1634                         array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1635                         continue;
1636                 }
1637 #ifdef ZLIB
1638                 /* remember if stream is already compressed */
1639                 old_z = My_Connections[Idx].options & CONN_ZIP;
1640 #endif
1641
1642                 My_Connections[Idx].msg_in++;
1643                 if (!Parse_Request
1644                     (Idx, (char *)array_start(&My_Connections[Idx].rbuf)))
1645                         return 0; /* error -> connection has been closed */
1646
1647                 array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1648                 LogDebug("Connection %d: %d bytes left in read buffer.",
1649                          Idx, array_bytes(&My_Connections[Idx].rbuf));
1650 #ifdef ZLIB
1651                 if ((!old_z) && (My_Connections[Idx].options & CONN_ZIP) &&
1652                     (array_bytes(&My_Connections[Idx].rbuf) > 0)) {
1653                         /* The last command activated socket compression.
1654                          * Data that was read after that needs to be copied
1655                          * to the unzip buffer for decompression: */
1656                         if (!array_copy
1657                             (&My_Connections[Idx].zip.rbuf,
1658                              &My_Connections[Idx].rbuf)) {
1659                                 Conn_Close(Idx, NULL,
1660                                            "Can't allocate memory [Handle_Buffer]",
1661                                            true);
1662                                 return 0;
1663                         }
1664
1665                         array_trunc(&My_Connections[Idx].rbuf);
1666                         LogDebug
1667                             ("Moved already received data (%u bytes) to uncompression buffer.",
1668                              array_bytes(&My_Connections[Idx].zip.rbuf));
1669                 }
1670 #endif
1671         }
1672         return len_processed;
1673 } /* Handle_Buffer */
1674
1675
1676 static void
1677 Check_Connections(void)
1678 {
1679         /* check if connections are alive. if not, play PING-PONG first.
1680          * if this doesn't help either, disconnect client. */
1681         CLIENT *c;
1682         CONN_ID i;
1683         char msg[64];
1684
1685         for (i = 0; i < Pool_Size; i++) {
1686                 if (My_Connections[i].sock < 0)
1687                         continue;
1688
1689                 c = Conn_GetClient(i);
1690                 if (c && ((Client_Type(c) == CLIENT_USER)
1691                           || (Client_Type(c) == CLIENT_SERVER)
1692                           || (Client_Type(c) == CLIENT_SERVICE))) {
1693                         /* connected User, Server or Service */
1694                         if (My_Connections[i].lastping >
1695                             My_Connections[i].lastdata) {
1696                                 /* We already sent a ping */
1697                                 if (My_Connections[i].lastping <
1698                                     time(NULL) - Conf_PongTimeout) {
1699                                         /* Timeout */
1700                                         LogDebug
1701                                             ("Connection %d: Ping timeout: %d seconds.",
1702                                              i, Conf_PongTimeout);
1703                                         snprintf(msg, sizeof(msg), "Ping timeout: %d seconds", Conf_PongTimeout);
1704                                         Conn_Close(i, NULL, msg, true);
1705                                 }
1706                         } else if (My_Connections[i].lastdata <
1707                                    time(NULL) - Conf_PingTimeout) {
1708                                 /* We need to send a PING ... */
1709                                 LogDebug("Connection %d: sending PING ...", i);
1710                                 My_Connections[i].lastping = time(NULL);
1711                                 Conn_WriteStr(i, "PING :%s",
1712                                               Client_ID(Client_ThisServer()));
1713                         }
1714                 } else {
1715                         /* The connection is not fully established yet, so
1716                          * we don't do the PING-PONG game here but instead
1717                          * disconnect the client after "a short time" if it's
1718                          * still not registered. */
1719
1720                         if (My_Connections[i].lastdata <
1721                             time(NULL) - Conf_PongTimeout) {
1722                                 LogDebug
1723                                     ("Unregistered connection %d timed out ...",
1724                                      i);
1725                                 Conn_Close(i, NULL, "Timeout", false);
1726                         }
1727                 }
1728         }
1729 } /* Check_Connections */
1730
1731
1732 static void
1733 Check_Servers( void )
1734 {
1735         /* Check if we can establish further server links */
1736
1737         int i, n;
1738         time_t time_now;
1739
1740         /* Check all configured servers */
1741         for( i = 0; i < MAX_SERVERS; i++ ) {
1742                 /* Valid outgoing server which isn't already connected or disabled? */
1743                 if(( ! Conf_Server[i].host[0] ) || ( ! Conf_Server[i].port > 0 ) ||
1744                         ( Conf_Server[i].conn_id > NONE ) || ( Conf_Server[i].flags & CONF_SFLAG_DISABLED ))
1745                                 continue;
1746
1747                 /* Is there already a connection in this group? */
1748                 if( Conf_Server[i].group > NONE ) {
1749                         for (n = 0; n < MAX_SERVERS; n++) {
1750                                 if (n == i) continue;
1751                                 if ((Conf_Server[n].conn_id != NONE) &&
1752                                         (Conf_Server[n].group == Conf_Server[i].group))
1753                                                 break;
1754                         }
1755                         if (n < MAX_SERVERS) continue;
1756                 }
1757
1758                 /* Check last connect attempt? */
1759                 time_now = time(NULL);
1760                 if( Conf_Server[i].lasttry > (time_now - Conf_ConnectRetry))
1761                         continue;
1762
1763                 /* Okay, try to connect now */
1764                 Conf_Server[i].lasttry = time_now;
1765                 Conf_Server[i].conn_id = SERVER_WAIT;
1766                 assert(Resolve_Getfd(&Conf_Server[i].res_stat) < 0);
1767                 Resolve_Name(&Conf_Server[i].res_stat, Conf_Server[i].host, cb_Connect_to_Server);
1768         }
1769 } /* Check_Servers */
1770
1771
1772 static void
1773 New_Server( int Server , ng_ipaddr_t *dest)
1774 {
1775         /* Establish new server link */
1776         char ip_str[NG_INET_ADDRSTRLEN];
1777         int af_dest, res, new_sock;
1778         CLIENT *c;
1779
1780         assert( Server > NONE );
1781
1782         if (!ng_ipaddr_tostr_r(dest, ip_str)) {
1783                 Log(LOG_WARNING, "New_Server: Could not convert IP to string");
1784                 return;
1785         }
1786
1787         Log( LOG_INFO, "Establishing connection to \"%s\", %s, port %d ... ",
1788                         Conf_Server[Server].host, ip_str, Conf_Server[Server].port );
1789
1790         af_dest = ng_ipaddr_af(dest);
1791         new_sock = socket(af_dest, SOCK_STREAM, 0);
1792         if (new_sock < 0) {
1793                 Log( LOG_CRIT, "Can't create socket (af %d) : %s!", af_dest, strerror( errno ));
1794                 return;
1795         }
1796
1797         if (!Init_Socket(new_sock))
1798                 return;
1799
1800         /* is a bind address configured? */
1801         res = ng_ipaddr_af(&Conf_Server[Server].bind_addr);
1802         /* if yes, bind now. If it fails, warn and let connect() pick a source address */
1803         if (res && bind(new_sock, (struct sockaddr *) &Conf_Server[Server].bind_addr,
1804                                 ng_ipaddr_salen(&Conf_Server[Server].bind_addr)))
1805         {
1806                 ng_ipaddr_tostr_r(&Conf_Server[Server].bind_addr, ip_str);
1807                 Log(LOG_WARNING, "Can't bind socket to %s: %s!", ip_str, strerror(errno));
1808         }
1809         ng_ipaddr_setport(dest, Conf_Server[Server].port);
1810         res = connect(new_sock, (struct sockaddr *) dest, ng_ipaddr_salen(dest));
1811         if(( res != 0 ) && ( errno != EINPROGRESS )) {
1812                 Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
1813                 close( new_sock );
1814                 return;
1815         }
1816
1817         if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)new_sock)) {
1818                 Log(LOG_ALERT,
1819                     "Cannot allocate memory for server connection (socket %d)",
1820                     new_sock);
1821                 close( new_sock );
1822                 return;
1823         }
1824
1825         My_Connections = array_start(&My_ConnArray);
1826
1827         assert(My_Connections[new_sock].sock <= 0);
1828
1829         Init_Conn_Struct(new_sock);
1830
1831         ng_ipaddr_tostr_r(dest, ip_str);
1832         c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWNSERVER, false);
1833         if (!c) {
1834                 Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
1835                 close( new_sock );
1836                 return;
1837         }
1838
1839         /* Conn_Close() decrements this counter again */
1840         Account_Connection();
1841         Client_SetIntroducer( c, c );
1842         Client_SetToken( c, TOKEN_OUTBOUND );
1843
1844         /* Register connection */
1845         Conf_Server[Server].conn_id = new_sock;
1846         My_Connections[new_sock].sock = new_sock;
1847         My_Connections[new_sock].addr = *dest;
1848         My_Connections[new_sock].client = c;
1849         strlcpy( My_Connections[new_sock].host, Conf_Server[Server].host,
1850                                 sizeof(My_Connections[new_sock].host ));
1851
1852         /* Register new socket */
1853         if (!io_event_create( new_sock, IO_WANTWRITE, cb_connserver)) {
1854                 Log( LOG_ALERT, "io_event_create(): could not add fd %d", strerror(errno));
1855                 Conn_Close( new_sock, "io_event_create() failed", NULL, false );
1856                 Init_Conn_Struct( new_sock );
1857                 Conf_Server[Server].conn_id = NONE;
1858         }
1859 #ifdef SSL_SUPPORT
1860         if (Conf_Server[Server].SSLConnect && !ConnSSL_PrepareConnect( &My_Connections[new_sock],
1861                                                                 &Conf_Server[Server] ))
1862         {
1863                 Log(LOG_ALERT, "Could not initialize SSL for outgoing connection");
1864                 Conn_Close( new_sock, "Could not initialize SSL for outgoing connection", NULL, false );
1865                 Init_Conn_Struct( new_sock );
1866                 Conf_Server[Server].conn_id = NONE;
1867                 return;
1868         }
1869 #endif
1870         LogDebug("Registered new connection %d on socket %d (%ld in total).",
1871                  new_sock, My_Connections[new_sock].sock, NumConnections);
1872         Conn_OPTION_ADD( &My_Connections[new_sock], CONN_ISCONNECTING );
1873 } /* New_Server */
1874
1875
1876 /**
1877  * Initialize connection structure.
1878  */
1879 static void
1880 Init_Conn_Struct(CONN_ID Idx)
1881 {
1882         time_t now = time(NULL);
1883
1884         memset(&My_Connections[Idx], 0, sizeof(CONNECTION));
1885         My_Connections[Idx].sock = -1;
1886         My_Connections[Idx].signon = now;
1887         My_Connections[Idx].lastdata = now;
1888         My_Connections[Idx].lastprivmsg = now;
1889         Resolve_Init(&My_Connections[Idx].res_stat);
1890 } /* Init_Conn_Struct */
1891
1892
1893 static bool
1894 Init_Socket( int Sock )
1895 {
1896         /* Initialize socket (set options) */
1897
1898         int value;
1899
1900         if (!io_setnonblock(Sock)) {
1901                 Log( LOG_CRIT, "Can't enable non-blocking mode for socket: %s!", strerror( errno ));
1902                 close( Sock );
1903                 return false;
1904         }
1905
1906         /* Don't block this port after socket shutdown */
1907         value = 1;
1908         if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &value, (socklen_t)sizeof( value )) != 0 )
1909         {
1910                 Log( LOG_ERR, "Can't set socket option SO_REUSEADDR: %s!", strerror( errno ));
1911                 /* ignore this error */
1912         }
1913
1914         /* Set type of service (TOS) */
1915 #if defined(IPPROTO_IP) && defined(IPTOS_LOWDELAY)
1916         value = IPTOS_LOWDELAY;
1917         LogDebug("Setting IP_TOS on socket %d to IPTOS_LOWDELAY.", Sock);
1918         if (setsockopt(Sock, IPPROTO_IP, IP_TOS, &value,
1919                        (socklen_t) sizeof(value))) {
1920                 Log(LOG_ERR, "Can't set socket option IP_TOS: %s!",
1921                     strerror(errno));
1922                 /* ignore this error */
1923         }
1924 #endif
1925
1926         return true;
1927 } /* Init_Socket */
1928
1929
1930 static void
1931 cb_Connect_to_Server(int fd, UNUSED short events)
1932 {
1933         /* Read result of resolver sub-process from pipe and start connection */
1934         int i;
1935         size_t len;
1936         ng_ipaddr_t dest_addrs[4];      /* we can handle at most 3; but we read up to
1937                                            four so we can log the 'more than we can handle'
1938                                            condition. First result is tried immediately, rest
1939                                            is saved for later if needed. */
1940
1941         LogDebug("Resolver: Got forward lookup callback on fd %d, events %d", fd, events);
1942
1943         for (i=0; i < MAX_SERVERS; i++) {
1944                   if (Resolve_Getfd(&Conf_Server[i].res_stat) == fd )
1945                           break;
1946         }
1947
1948         if( i >= MAX_SERVERS) {
1949                 /* Ops, no matching server found?! */
1950                 io_close( fd );
1951                 LogDebug("Resolver: Got Forward Lookup callback for unknown server!?");
1952                 return;
1953         }
1954
1955         /* Read result from pipe */
1956         len = Resolve_Read(&Conf_Server[i].res_stat, dest_addrs, sizeof(dest_addrs));
1957         if (len == 0)
1958                 return;
1959
1960         assert((len % sizeof(ng_ipaddr_t)) == 0);
1961
1962         LogDebug("Got result from resolver: %u structs (%u bytes).", len/sizeof(ng_ipaddr_t), len);
1963
1964         memset(&Conf_Server[i].dst_addr, 0, sizeof(Conf_Server[i].dst_addr));
1965         if (len > sizeof(ng_ipaddr_t)) {
1966                 /* more than one address for this hostname, remember them
1967                  * in case first address is unreachable/not available */
1968                 len -= sizeof(ng_ipaddr_t);
1969                 if (len > sizeof(Conf_Server[i].dst_addr)) {
1970                         len = sizeof(Conf_Server[i].dst_addr);
1971                         Log(LOG_NOTICE,
1972                                 "Notice: Resolver returned more IP Addresses for host than we can handle, additional addresses dropped.");
1973                 }
1974                 memcpy(&Conf_Server[i].dst_addr, &dest_addrs[1], len);
1975         }
1976         /* connect() */
1977         New_Server(i, dest_addrs);
1978 } /* cb_Read_Forward_Lookup */
1979
1980
1981 static void
1982 cb_Read_Resolver_Result( int r_fd, UNUSED short events )
1983 {
1984         /* Read result of resolver sub-process from pipe and update the
1985          * apropriate connection/client structure(s): hostname and/or
1986          * IDENT user name.*/
1987
1988         CLIENT *c;
1989         int i;
1990         size_t len;
1991         char *identptr;
1992 #ifdef IDENTAUTH
1993         char readbuf[HOST_LEN + 2 + CLIENT_USER_LEN];
1994 #else
1995         char readbuf[HOST_LEN + 1];
1996 #endif
1997
1998         LogDebug("Resolver: Got callback on fd %d, events %d", r_fd, events );
1999
2000         /* Search associated connection ... */
2001         for( i = 0; i < Pool_Size; i++ ) {
2002                 if(( My_Connections[i].sock != NONE )
2003                   && ( Resolve_Getfd(&My_Connections[i].res_stat) == r_fd ))
2004                         break;
2005         }
2006         if( i >= Pool_Size ) {
2007                 /* Ops, none found? Probably the connection has already
2008                  * been closed!? We'll ignore that ... */
2009                 io_close( r_fd );
2010                 LogDebug("Resolver: Got callback for unknown connection!?");
2011                 return;
2012         }
2013
2014         /* Read result from pipe */
2015         len = Resolve_Read(&My_Connections[i].res_stat, readbuf, sizeof readbuf -1);
2016         if (len == 0)
2017                 return;
2018
2019         readbuf[len] = '\0';
2020         identptr = strchr(readbuf, '\n');
2021         assert(identptr != NULL);
2022         if (!identptr) {
2023                 Log( LOG_CRIT, "Resolver: Got malformed result!");
2024                 return;
2025         }
2026
2027         *identptr = '\0';
2028         LogDebug("Got result from resolver: \"%s\" (%u bytes read).", readbuf, len);
2029         /* Okay, we got a complete result: this is a host name for outgoing
2030          * connections and a host name and IDENT user name (if enabled) for
2031          * incoming connections.*/
2032         assert ( My_Connections[i].sock >= 0 );
2033         /* Incoming connection. Search client ... */
2034         c = Conn_GetClient( i );
2035         assert( c != NULL );
2036
2037         /* Only update client information of unregistered clients.
2038          * Note: user commands (e. g. WEBIRC) are always read _after_ reading
2039          * the resolver results, so we don't have to worry to override settings
2040          * from these commands here. */
2041         if(Client_Type(c) == CLIENT_UNKNOWN) {
2042                 strlcpy(My_Connections[i].host, readbuf,
2043                         sizeof(My_Connections[i].host));
2044                 Client_SetHostname(c, readbuf);
2045 #ifdef IDENTAUTH
2046                 ++identptr;
2047                 if (*identptr) {
2048                         Log(LOG_INFO, "IDENT lookup for connection %d: \"%s\".", i, identptr);
2049                         Client_SetUser(c, identptr, true);
2050                 } else {
2051                         Log(LOG_INFO, "IDENT lookup for connection %d: no result.", i);
2052                 }
2053 #endif
2054         }
2055 #ifdef DEBUG
2056                 else Log( LOG_DEBUG, "Resolver: discarding result for already registered connection %d.", i );
2057 #endif
2058         /* Reset penalty time */
2059         Conn_ResetPenalty( i );
2060 } /* cb_Read_Resolver_Result */
2061
2062
2063 /**
2064  * Write a "simple" (error) message to a socket.
2065  * The message is sent without using the connection write buffers, without
2066  * compression/encryption, and even without any error reporting. It is
2067  * designed for error messages of e.g. New_Connection(). */
2068 static void
2069 Simple_Message(int Sock, const char *Msg)
2070 {
2071         char buf[COMMAND_LEN];
2072         size_t len;
2073
2074         assert(Sock > NONE);
2075         assert(Msg != NULL);
2076
2077         strlcpy(buf, Msg, sizeof buf - 2);
2078         len = strlcat(buf, "\r\n", sizeof buf);
2079         if (write(Sock, buf, len) < 0) {
2080                 /* Because this function most probably got called to log
2081                  * an error message, any write error is ignored here to
2082                  * avoid an endless loop. But casting the result of write()
2083                  * to "void" doesn't satisfy the GNU C code attribute
2084                  * "warn_unused_result" which is used by some versions of
2085                  * glibc (e.g. 2.11.1), therefore this silly error
2086                  * "handling" code here :-( */
2087                 return;
2088         }
2089 } /* Simple_Error */
2090
2091
2092 /**
2093  * Get CLIENT structure that belongs to a local connection identified by its
2094  * index number. Each connection belongs to a client by definition, so it is
2095  * not required that the caller checks for NULL return values.
2096  * @param Idx Connection index number
2097  * @return Pointer to CLIENT structure
2098  */
2099 GLOBAL CLIENT *
2100 Conn_GetClient( CONN_ID Idx )
2101 {
2102         CONNECTION *c;
2103
2104         assert(Idx >= 0);
2105         c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
2106         assert(c != NULL);
2107         return c ? c->client : NULL;
2108 }
2109
2110
2111 #ifdef SSL_SUPPORT
2112
2113 /**
2114  * Get information about used SSL chiper.
2115  * @param Idx Connection index number
2116  * @param buf Buffer for returned information text
2117  * @param len Size of return buffer "buf"
2118  * @return true on success, false otherwise
2119  */
2120 GLOBAL bool
2121 Conn_GetCipherInfo(CONN_ID Idx, char *buf, size_t len)
2122 {
2123         if (Idx < 0)
2124                 return false;
2125         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2126         return ConnSSL_GetCipherInfo(&My_Connections[Idx], buf, len);
2127 }
2128
2129
2130 /**
2131  * Check if a connection is SSL-enabled or not.
2132  * @param Idx Connection index number
2133  * @return true if connection is SSL-enabled, false otherwise.
2134  */
2135 GLOBAL bool
2136 Conn_UsesSSL(CONN_ID Idx)
2137 {
2138         if (Idx < 0)
2139                 return false;
2140         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2141         return Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL);
2142 }
2143
2144 #endif
2145
2146
2147 /* -eof- */