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