src/ngircd/conn.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2001-2013 Alexander Barton (alex@barton.de) and Contributors.
   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
  12 #undef DEBUG_BUFFER
  13
  14 #define CONN_MODULE
  15
  16 #include "portab.h"
  17 #include "conf-ssl.h"
  18 #include "io.h"
  19
  20 /**
  21  * @file
  22  * Connection management
  23  */
  24
  25 #include "imp.h"
  26 #include <assert.h>
  27 #ifdef PROTOTYPES
  28 # include <stdarg.h>
  29 #else
  30 # include <varargs.h>
  31 #endif
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <errno.h>
  36 #include <string.h>
  37 #include <sys/socket.h>
  38 #include <sys/time.h>
  39 #include <sys/types.h>
  40 #include <time.h>
  41 #include <netinet/in.h>
  42
  43 #ifdef HAVE_NETINET_IP_H
  44 # ifdef HAVE_NETINET_IN_SYSTM_H
  45 #  include <netinet/in_systm.h>
  46 # endif
  47 # include <netinet/ip.h>
  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 "class.h"
  65 #include "conf.h"
  66 #include "conn-encoding.h"
  67 #include "conn-ssl.h"
  68 #include "conn-zip.h"
  69 #include "conn-func.h"
  70 #include "log.h"
  71 #include "ng_ipaddr.h"
  72 #include "parse.h"
  73 #include "resolve.h"
  74 #include "tool.h"
  75
  76 #include "exp.h"
  77
  78
  79 #define SERVER_WAIT (NONE - 1)
  80
  81 #define MAX_COMMANDS 3
  82 #define MAX_COMMANDS_SERVER_MIN 10
  83 #define MAX_COMMANDS_SERVICE 10
  84
  85 #define SD_LISTEN_FDS_START 3
  86
  87
  88 static bool Handle_Write PARAMS(( CONN_ID Idx ));
  89 static bool Conn_Write PARAMS(( CONN_ID Idx, char *Data, size_t Len ));
  90 static int New_Connection PARAMS(( int Sock, bool IsSSL ));
  91 static CONN_ID Socket2Index PARAMS(( int Sock ));
  92 static void Read_Request PARAMS(( CONN_ID Idx ));
  93 static unsigned int Handle_Buffer PARAMS(( CONN_ID Idx ));
  94 static void Check_Connections PARAMS(( void ));
  95 static void Check_Servers PARAMS(( void ));
  96 static void Init_Conn_Struct PARAMS(( CONN_ID Idx ));
  97 static bool Init_Socket PARAMS(( int Sock ));
  98 static void New_Server PARAMS(( int Server, ng_ipaddr_t *dest ));
  99 static void Simple_Message PARAMS(( int Sock, const char *Msg ));
 100 static int NewListener PARAMS(( const char *listen_addr, UINT16 Port ));
 101 static void Account_Connection PARAMS((void));
 102
 103
 104 static array My_Listeners;
 105 static array My_ConnArray;
 106 static size_t NumConnections, NumConnectionsMax, NumConnectionsAccepted;
 107
 108 #ifdef TCPWRAP
 109 int allow_severity = LOG_INFO;
 110 int deny_severity = LOG_ERR;
 111 #endif
 112
 113 static void server_login PARAMS((CONN_ID idx));
 114
 115 #ifdef SSL_SUPPORT
 116 extern struct SSLOptions Conf_SSLOptions;
 117 static void cb_connserver_login_ssl PARAMS((int sock, short what));
 118 static void cb_clientserver_ssl PARAMS((int sock, short what));
 119 #endif
 120 static void cb_Read_Resolver_Result PARAMS((int sock, UNUSED short what));
 121 static void cb_Connect_to_Server PARAMS((int sock, UNUSED short what));
 122 static void cb_clientserver PARAMS((int sock, short what));
 123
 124 time_t idle_t = 0;
 125
 126
 127 /**
 128  * Get number of sockets available from systemd(8).
 129  *
 130  * ngIRCd needs to implement its own sd_listen_fds(3) function and can't
 131  * use the one provided by systemd itself, because the sockets will be
 132  * used in a forked child process with a new PID, and this would trigger
 133  * an error in the standard implementation.
 134  *
 135  * @return Number of sockets available, -1 if sockets have already been
 136  *         initialized, or 0 when no sockets have been passed.
 137  */
 138 static int
 139 my_sd_listen_fds(void)
 140 {
 141         const char *e;
 142         int count;
 143
 144         /* Check if LISTEN_PID exists; but we ignore the result, because
 145          * normally ngircd forks a child before checking this, and therefore
 146          * the PID set in the environment is always wrong ... */
 147         e = getenv("LISTEN_PID");
 148         if (!e || !*e)
 149                 return 0;
 150
 151         e = getenv("LISTEN_FDS");
 152         if (!e || !*e)
 153                 return -1;
 154         count = atoi(e);
 155         unsetenv("LISTEN_FDS");
 156
 157         return count;
 158 }
 159
 160
 161 /**
 162  * IO callback for listening sockets: handle new connections. This callback
 163  * gets called when a new non-SSL connection should be accepted.
 164  *
 165  * @param sock          Socket descriptor.
 166  * @param irrelevant    (ignored IO specification)
 167  */
 168 static void
 169 cb_listen(int sock, short irrelevant)
 170 {
 171         (void) irrelevant;
 172         (void) New_Connection(sock, false);
 173 }
 174
 175
 176 #ifdef SSL_SUPPORT
 177 /**
 178  * IO callback for listening SSL sockets: handle new connections. This callback
 179  * gets called when a new SSL-enabled connection should be accepted.
 180  *
 181  * @param sock          Socket descriptor.
 182  * @param irrelevant    (ignored IO specification)
 183  */
 184 static void
 185 cb_listen_ssl(int sock, short irrelevant)
 186 {
 187         int fd;
 188
 189         (void) irrelevant;
 190         fd = New_Connection(sock, true);
 191         if (fd < 0)
 192                 return;
 193         io_event_setcb(My_Connections[fd].sock, cb_clientserver_ssl);
 194 }
 195 #endif
 196
 197
 198 /**
 199  * IO callback for new outgoing non-SSL server connections.
 200  *
 201  * @param sock  Socket descriptor.
 202  * @param what  IO specification (IO_WANTREAD/IO_WANTWRITE/...).
 203  */
 204 static void
 205 cb_connserver(int sock, UNUSED short what)
 206 {
 207         int res, err, server;
 208         socklen_t sock_len;
 209         CONN_ID idx = Socket2Index( sock );
 210
 211         if (idx <= NONE) {
 212                 LogDebug("cb_connserver wants to write on unknown socket?!");
 213                 io_close(sock);
 214                 return;
 215         }
 216
 217         assert(what & IO_WANTWRITE);
 218
 219         /* Make sure that the server is still configured; it could have been
 220          * removed in the meantime! */
 221         server = Conf_GetServer(idx);
 222         if (server < 0) {
 223                 Log(LOG_ERR, "Connection on socket %d to \"%s\" aborted!",
 224                     sock, My_Connections[idx].host);
 225                 Conn_Close(idx, "Connection aborted", NULL, false);
 226                 return;
 227         }
 228
 229         /* connect() finished, get result. */
 230         sock_len = (socklen_t)sizeof(err);
 231         res = getsockopt(My_Connections[idx].sock, SOL_SOCKET, SO_ERROR,
 232                          &err, &sock_len );
 233         assert(sock_len == sizeof(err));
 234
 235         /* Error while connecting? */
 236         if ((res != 0) || (err != 0)) {
 237                 if (res != 0)
 238                         Log(LOG_CRIT, "getsockopt (connection %d): %s!",
 239                             idx, strerror(errno));
 240                 else
 241                         Log(LOG_CRIT,
 242                             "Can't connect socket to \"%s:%d\" (connection %d): %s!",
 243                             My_Connections[idx].host, Conf_Server[server].port,
 244                             idx, strerror(err));
 245
 246                 Conn_Close(idx, "Can't connect", NULL, false);
 247
 248                 if (ng_ipaddr_af(&Conf_Server[server].dst_addr[0])) {
 249                         /* more addresses to try... */
 250                         New_Server(server, &Conf_Server[server].dst_addr[0]);
 251                         /* connection to dst_addr[0] is now in progress, so
 252                          * remove this address... */
 253                         Conf_Server[server].dst_addr[0] =
 254                                 Conf_Server[server].dst_addr[1];
 255                         memset(&Conf_Server[server].dst_addr[1], 0,
 256                                sizeof(Conf_Server[server].dst_addr[1]));
 257                 }
 258                 return;
 259         }
 260
 261         /* connect() succeeded, remove all additional addresses */
 262         memset(&Conf_Server[server].dst_addr, 0,
 263                sizeof(Conf_Server[server].dst_addr));
 264
 265         Conn_OPTION_DEL( &My_Connections[idx], CONN_ISCONNECTING );
 266 #ifdef SSL_SUPPORT
 267         if ( Conn_OPTION_ISSET( &My_Connections[idx], CONN_SSL_CONNECT )) {
 268                 io_event_setcb( sock, cb_connserver_login_ssl );
 269                 io_event_add( sock, IO_WANTWRITE|IO_WANTREAD );
 270                 return;
 271         }
 272 #endif
 273         server_login(idx);
 274 }
 275
 276
 277 /**
 278  * Login to a remote server.
 279  *
 280  * @param idx   Connection index.
 281  */
 282 static void
 283 server_login(CONN_ID idx)
 284 {
 285         Log(LOG_INFO,
 286             "Connection %d (socket %d) with \"%s:%d\" established. Now logging in ...",
 287             idx, My_Connections[idx].sock, My_Connections[idx].host,
 288             Conf_Server[Conf_GetServer(idx)].port);
 289
 290         io_event_setcb( My_Connections[idx].sock, cb_clientserver);
 291         io_event_add( My_Connections[idx].sock, IO_WANTREAD|IO_WANTWRITE);
 292
 293         /* Send PASS and SERVER command to peer */
 294         Conn_WriteStr( idx, "PASS %s %s", Conf_Server[Conf_GetServer( idx )].pwd_out, NGIRCd_ProtoID );
 295         Conn_WriteStr( idx, "SERVER %s :%s", Conf_ServerName, Conf_ServerInfo );
 296 }
 297
 298
 299 #ifdef SSL_SUPPORT
 300 /**
 301  * IO callback for new outgoing SSL-enabled server connections.
 302  *
 303  * @param sock          Socket descriptor.
 304  * @param unused        (ignored IO specification)
 305  */
 306 static void
 307 cb_connserver_login_ssl(int sock, short unused)
 308 {
 309         CONN_ID idx = Socket2Index(sock);
 310
 311         assert(idx >= 0);
 312         if (idx < 0) {
 313                 io_close(sock);
 314                 return;
 315         }
 316         (void) unused;
 317         switch (ConnSSL_Connect( &My_Connections[idx])) {
 318         case 1: break;
 319         case 0: LogDebug("ConnSSL_Connect: not ready");
 320                 return;
 321         case -1:
 322                 Log(LOG_ERR, "SSL connection on socket %d failed!", sock);
 323                 Conn_Close(idx, "Can't connect", NULL, false);
 324                 return;
 325         }
 326
 327         Log( LOG_INFO, "SSL connection %d with \"%s:%d\" established.", idx,
 328                         My_Connections[idx].host, Conf_Server[Conf_GetServer( idx )].port );
 329
 330         server_login(idx);
 331 }
 332 #endif
 333
 334
 335 /**
 336  * IO callback for established non-SSL client and server connections.
 337  *
 338  * @param sock  Socket descriptor.
 339  * @param what  IO specification (IO_WANTREAD/IO_WANTWRITE/...).
 340  */
 341 static void
 342 cb_clientserver(int sock, short what)
 343 {
 344         CONN_ID idx = Socket2Index(sock);
 345
 346         assert(idx >= 0);
 347
 348         if (idx < 0) {
 349                 io_close(sock);
 350                 return;
 351         }
 352 #ifdef SSL_SUPPORT
 353         if (what & IO_WANTREAD
 354             || (Conn_OPTION_ISSET(&My_Connections[idx], CONN_SSL_WANT_WRITE))) {
 355                 /* if TLS layer needs to write additional data, call
 356                  * Read_Request() instead so that SSL/TLS can continue */
 357                 Read_Request(idx);
 358         }
 359 #else
 360         if (what & IO_WANTREAD)
 361                 Read_Request(idx);
 362 #endif
 363         if (what & IO_WANTWRITE)
 364                 Handle_Write(idx);
 365 }
 366
 367
 368 #ifdef SSL_SUPPORT
 369 /**
 370  * IO callback for new SSL-enabled client and server connections.
 371  *
 372  * @param sock  Socket descriptor.
 373  * @param what  IO specification (IO_WANTREAD/IO_WANTWRITE/...).
 374  */
 375 static void
 376 cb_clientserver_ssl(int sock, UNUSED short what)
 377 {
 378         CONN_ID idx = Socket2Index(sock);
 379
 380         assert(idx >= 0);
 381
 382         if (idx < 0) {
 383                 io_close(sock);
 384                 return;
 385         }
 386
 387         switch (ConnSSL_Accept(&My_Connections[idx])) {
 388         case 1:
 389                 break;  /* OK */
 390         case 0:
 391                 return; /* EAGAIN: callback will be invoked again by IO layer */
 392         default:
 393                 Conn_Close(idx,
 394                            "SSL accept error, closing socket", "SSL accept error",
 395                            false);
 396                 return;
 397         }
 398
 399         io_event_setcb(sock, cb_clientserver);  /* SSL handshake completed */
 400 }
 401 #endif
 402
 403
 404 /**
 405  * Initialize connection module.
 406  */
 407 GLOBAL void
 408 Conn_Init( void )
 409 {
 410         CONN_ID i;
 411
 412         Pool_Size = CONNECTION_POOL;
 413         if ((Conf_MaxConnections > 0) &&
 414                 (Pool_Size > Conf_MaxConnections))
 415                         Pool_Size = Conf_MaxConnections;
 416
 417         if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)Pool_Size)) {
 418                 Log(LOG_EMERG, "Can't allocate memory! [Conn_Init]");
 419                 exit(1);
 420         }
 421
 422         /* FIXME: My_Connetions/Pool_Size is needed by other parts of the
 423          * code; remove them! */
 424         My_Connections = (CONNECTION*) array_start(&My_ConnArray);
 425
 426         LogDebug("Allocated connection pool for %d items (%ld bytes).",
 427                 array_length(&My_ConnArray, sizeof(CONNECTION)),
 428                 array_bytes(&My_ConnArray));
 429
 430         assert(array_length(&My_ConnArray, sizeof(CONNECTION)) >= (size_t)Pool_Size);
 431
 432         array_free( &My_Listeners );
 433
 434         for (i = 0; i < Pool_Size; i++)
 435                 Init_Conn_Struct(i);
 436 } /* Conn_Init */
 437
 438
 439 /**
 440  * Clean up connection module.
 441  */
 442 GLOBAL void
 443 Conn_Exit( void )
 444 {
 445         CONN_ID idx;
 446
 447         Conn_ExitListeners();
 448
 449         LogDebug("Shutting down all connections ..." );
 450         for( idx = 0; idx < Pool_Size; idx++ ) {
 451                 if( My_Connections[idx].sock > NONE ) {
 452                         Conn_Close( idx, NULL, NGIRCd_SignalRestart ?
 453                                 "Server going down (restarting)":"Server going down", true );
 454                 }
 455         }
 456
 457         array_free(&My_ConnArray);
 458         My_Connections = NULL;
 459         Pool_Size = 0;
 460         io_library_shutdown();
 461 } /* Conn_Exit */
 462
 463
 464 /**
 465  * Close all sockets (file descriptors) of open connections.
 466  * This is useful in forked child processes, for example, to make sure that
 467  * they don't hold connections open that the main process wants to close.
 468  */
 469 GLOBAL void
 470 Conn_CloseAllSockets(int ExceptOf)
 471 {
 472         CONN_ID idx;
 473
 474         for(idx = 0; idx < Pool_Size; idx++) {
 475                 if(My_Connections[idx].sock > NONE &&
 476                    My_Connections[idx].sock != ExceptOf)
 477                         close(My_Connections[idx].sock);
 478         }
 479 }
 480
 481
 482 /**
 483  * Initialize listening ports.
 484  *
 485  * @param a             Array containing the ports the daemon should listen on.
 486  * @param listen_addr   Address the socket should listen on (can be "0.0.0.0").
 487  * @param func          IO callback function to register.
 488  * @returns             Number of listening sockets created.
 489  */
 490 static unsigned int
 491 Init_Listeners(array *a, const char *listen_addr, void (*func)(int,short))
 492 {
 493         unsigned int created = 0;
 494         size_t len;
 495         int fd;
 496         UINT16 *port;
 497
 498         len = array_length(a, sizeof (UINT16));
 499         port = array_start(a);
 500         while (len--) {
 501                 fd = NewListener(listen_addr, *port);
 502                 if (fd < 0) {
 503                         port++;
 504                         continue;
 505                 }
 506                 if (!io_event_create( fd, IO_WANTREAD, func )) {
 507                         Log(LOG_ERR,
 508                             "io_event_create(): Can't add fd %d (port %u): %s!",
 509                             fd, (unsigned int) *port, strerror(errno));
 510                         close(fd);
 511                         port++;
 512                         continue;
 513                 }
 514                 created++;
 515                 port++;
 516         }
 517         return created;
 518 }
 519
 520
 521 /**
 522  * Initialize all listening sockets.
 523  *
 524  * @returns     Number of created listening sockets
 525  */
 526 GLOBAL unsigned int
 527 Conn_InitListeners( void )
 528 {
 529         /* Initialize ports on which the server should accept connections */
 530         unsigned int created = 0;
 531         char *af_str, *copy, *listen_addr;
 532         int count, fd, i, addr_len;
 533         ng_ipaddr_t addr;
 534
 535         assert(Conf_ListenAddress);
 536
 537         count = my_sd_listen_fds();
 538         if (count < 0) {
 539                 Log(LOG_INFO,
 540                     "Not re-initializing listening sockets of systemd(8) ...");
 541                 return 0;
 542         }
 543         if (count > 0) {
 544                 /* systemd(8) passed sockets to us, so don't try to initialize
 545                  * listening sockets on our own but use the passed ones */
 546                 LogDebug("Initializing %d systemd sockets ...", count);
 547                 for (i = 0; i < count; i++) {
 548                         fd = SD_LISTEN_FDS_START + i;
 549                         addr_len = (int)sizeof(addr);
 550                         getsockname(fd, (struct sockaddr *)&addr, (socklen_t*)&addr_len);
 551 #ifdef WANT_IPV6
 552                         if (addr.sin4.sin_family != AF_INET && addr.sin4.sin_family != AF_INET6)
 553 #else
 554                         if (addr.sin4.sin_family != AF_INET)
 555 #endif
 556                         {
 557                                 /* Socket is of unsupported type! For example, systemd passed in
 558                                  * an IPv6 socket but ngIRCd isn't compiled with IPv6 support. */
 559                                 switch (addr.sin4.sin_family)
 560                                 {
 561                                         case AF_UNSPEC: af_str = "AF_UNSPEC"; break;
 562                                         case AF_UNIX: af_str = "AF_UNIX"; break;
 563                                         case AF_INET: af_str = "AF_INET"; break;
 564 #ifdef AF_INET6
 565                                         case AF_INET6: af_str = "AF_INET6"; break;
 566 #endif
 567 #ifdef AF_NETLINK
 568                                         case AF_NETLINK: af_str = "AF_NETLINK"; break;
 569 #endif
 570                                         default: af_str = "unknown"; break;
 571                                 }
 572                                 Log(LOG_CRIT,
 573                                     "Socket %d is of unsupported type \"%s\" (%d), have to ignore it!",
 574                                     fd, af_str, addr.sin4.sin_family);
 575                                 close(fd);
 576                                 continue;
 577                         }
 578
 579                         Init_Socket(fd);
 580                         if (!io_event_create(fd, IO_WANTREAD, cb_listen)) {
 581                                 Log(LOG_ERR,
 582                                     "io_event_create(): Can't add fd %d: %s!",
 583                                     fd, strerror(errno));
 584                                 continue;
 585                         }
 586                         Log(LOG_INFO,
 587                             "Initialized socket %d from systemd(8): %s:%d.", fd,
 588                             ng_ipaddr_tostr(&addr), ng_ipaddr_getport(&addr));
 589                         created++;
 590                 }
 591                 return created;
 592         }
 593
 594         /* not using systemd socket activation, initialize listening sockets: */
 595
 596         /* can't use Conf_ListenAddress directly, see below */
 597         copy = strdup(Conf_ListenAddress);
 598         if (!copy) {
 599                 Log(LOG_CRIT, "Cannot copy %s: %s", Conf_ListenAddress,
 600                     strerror(errno));
 601                 return 0;
 602         }
 603         listen_addr = strtok(copy, ",");
 604
 605         while (listen_addr) {
 606                 ngt_TrimStr(listen_addr);
 607                 if (*listen_addr) {
 608                         created += Init_Listeners(&Conf_ListenPorts,
 609                                                   listen_addr, cb_listen);
 610 #ifdef SSL_SUPPORT
 611                         created += Init_Listeners(&Conf_SSLOptions.ListenPorts,
 612                                                   listen_addr, cb_listen_ssl);
 613 #endif
 614                 }
 615
 616                 listen_addr = strtok(NULL, ",");
 617         }
 618
 619         /* Can't free() Conf_ListenAddress here: on REHASH, if the config file
 620          * cannot be re-loaded, we'd end up with a NULL Conf_ListenAddress.
 621          * Instead, free() takes place in conf.c, before the config file
 622          * is being parsed. */
 623         free(copy);
 624
 625         return created;
 626 } /* Conn_InitListeners */
 627
 628
 629 /**
 630  * Shut down all listening sockets.
 631  */
 632 GLOBAL void
 633 Conn_ExitListeners( void )
 634 {
 635         /* Close down all listening sockets */
 636         int *fd;
 637         size_t arraylen;
 638
 639         /* Get number of listening sockets to shut down. There can be none
 640          * if ngIRCd has been "socket activated" by systemd. */
 641         arraylen = array_length(&My_Listeners, sizeof (int));
 642         if (arraylen < 1)
 643                 return;
 644
 645         Log(LOG_INFO,
 646             "Shutting down all listening sockets (%d total) ...", arraylen);
 647         fd = array_start(&My_Listeners);
 648         while(arraylen--) {
 649                 assert(fd != NULL);
 650                 assert(*fd >= 0);
 651                 io_close(*fd);
 652                 LogDebug("Listening socket %d closed.", *fd );
 653                 fd++;
 654         }
 655         array_free(&My_Listeners);
 656 } /* Conn_ExitListeners */
 657
 658
 659 /**
 660  * Bind a socket to a specific (source) address.
 661  *
 662  * @param addr                  Address structure.
 663  * @param listen_addrstr        Source address as string.
 664  * @param Port                  Port number.
 665  * @returns                     true on success, false otherwise.
 666  */
 667 static bool
 668 InitSinaddrListenAddr(ng_ipaddr_t *addr, const char *listen_addrstr, UINT16 Port)
 669 {
 670         bool ret;
 671
 672         ret = ng_ipaddr_init(addr, listen_addrstr, Port);
 673         if (!ret) {
 674                 assert(listen_addrstr);
 675                 Log(LOG_CRIT, "Can't bind to [%s]:%u: can't convert ip address \"%s\"!",
 676                                                 listen_addrstr, Port, listen_addrstr);
 677         }
 678         return ret;
 679 }
 680
 681
 682 /**
 683  * Set a socket to "IPv6 only". If the given socket doesn't belong to the
 684  * AF_INET6 family, or the operating system doesn't support this functionality,
 685  * this function retruns silently.
 686  *
 687  * @param af    Address family of the socket.
 688  * @param sock  Socket handle.
 689  */
 690 static void
 691 set_v6_only(int af, int sock)
 692 {
 693 #if defined(IPV6_V6ONLY) && defined(WANT_IPV6)
 694         int on = 1;
 695
 696         if (af != AF_INET6)
 697                 return;
 698
 699         if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, (socklen_t)sizeof(on)))
 700                 Log(LOG_ERR, "Could not set IPV6_V6ONLY: %s", strerror(errno));
 701 #else
 702         (void)af;
 703         (void)sock;
 704 #endif
 705 }
 706
 707
 708 /**
 709  * Initialize new listening port.
 710  *
 711  * @param listen_addr   Local address to bind the socet to (can be 0.0.0.0).
 712  * @param Port          Port number on which the new socket should be listening.
 713  * @returns             file descriptor of the socket or -1 on failure.
 714  */
 715 static int
 716 NewListener(const char *listen_addr, UINT16 Port)
 717 {
 718         /* Create new listening socket on specified port */
 719         ng_ipaddr_t addr;
 720         int sock, af;
 721
 722         if (!InitSinaddrListenAddr(&addr, listen_addr, Port))
 723                 return -1;
 724
 725         af = ng_ipaddr_af(&addr);
 726         sock = socket(af, SOCK_STREAM, 0);
 727         if (sock < 0) {
 728                 Log(LOG_CRIT, "Can't create socket (af %d) : %s!", af,
 729                     strerror(errno));
 730                 return -1;
 731         }
 732
 733         set_v6_only(af, sock);
 734
 735         if (!Init_Socket(sock))
 736                 return -1;
 737
 738         if (bind(sock, (struct sockaddr *)&addr, ng_ipaddr_salen(&addr)) != 0) {
 739                 Log(LOG_CRIT, "Can't bind socket to address %s:%d - %s!",
 740                     ng_ipaddr_tostr(&addr), Port, strerror(errno));
 741                 close(sock);
 742                 return -1;
 743         }
 744
 745         if (listen(sock, 10) != 0) {
 746                 Log(LOG_CRIT, "Can't listen on socket: %s!", strerror(errno));
 747                 close(sock);
 748                 return -1;
 749         }
 750
 751         /* keep fd in list so we can close it when ngircd restarts/shuts down */
 752         if (!array_catb(&My_Listeners, (char *)&sock, sizeof(int))) {
 753                 Log(LOG_CRIT, "Can't add socket to My_Listeners array: %s!",
 754                     strerror(errno));
 755                 close(sock);
 756                 return -1;
 757         }
 758
 759         Log(LOG_INFO, "Now listening on [%s]:%d (socket %d).",
 760             ng_ipaddr_tostr(&addr), Port, sock);
 761         return sock;
 762 } /* NewListener */
 763
 764
 765 #ifdef SSL_SUPPORT
 766
 767 /**
 768  * Check if SSL library needs to read SSL-protocol related data.
 769  *
 770  * SSL/TLS connections require extra treatment:
 771  * When either CONN_SSL_WANT_WRITE or CONN_SSL_WANT_READ is set, we
 772  * need to take care of that first, before checking read/write buffers.
 773  * For instance, while we might have data in our write buffer, the
 774  * TLS/SSL protocol might need to read internal data first for TLS/SSL
 775  * writes to succeed.
 776  *
 777  * If this function returns true, such a condition is met and we have
 778  * to reverse the condition (check for read even if we've data to write,
 779  * do not check for read but writeability even if write-buffer is empty).
 780  *
 781  * @param c     Connection to check.
 782  * @returns     true if SSL-library has to read protocol data.
 783  */
 784 static bool
 785 SSL_WantRead(const CONNECTION *c)
 786 {
 787         if (Conn_OPTION_ISSET(c, CONN_SSL_WANT_READ)) {
 788                 io_event_add(c->sock, IO_WANTREAD);
 789                 return true;
 790         }
 791         return false;
 792 }
 793
 794 /**
 795  * Check if SSL library needs to write SSL-protocol related data.
 796  *
 797  * Please see description of SSL_WantRead() for full description!
 798  *
 799  * @param c     Connection to check.
 800  * @returns     true if SSL-library has to write protocol data.
 801  */
 802 static bool
 803 SSL_WantWrite(const CONNECTION *c)
 804 {
 805         if (Conn_OPTION_ISSET(c, CONN_SSL_WANT_WRITE)) {
 806                 io_event_add(c->sock, IO_WANTWRITE);
 807                 return true;
 808         }
 809         return false;
 810 }
 811
 812 #else
 813
 814 static inline bool
 815 SSL_WantRead(UNUSED const CONNECTION *c)
 816 { return false; }
 817
 818 static inline bool
 819 SSL_WantWrite(UNUSED const CONNECTION *c)
 820 { return false; }
 821
 822 #endif
 823
 824
 825 /**
 826  * "Main Loop": Loop until shutdown or restart is signalled.
 827  *
 828  * This function loops until a shutdown or restart of ngIRCd is signalled and
 829  * calls io_dispatch() to check for readable and writable sockets every second.
 830  * It checks for status changes on pending connections (e. g. when a hostname
 831  * has been resolved), checks for "penalties" and timeouts, and handles the
 832  * input buffers.
 833  */
 834 GLOBAL void
 835 Conn_Handler(void)
 836 {
 837         int i;
 838         unsigned int wdatalen, bytes_processed;
 839         struct timeval tv;
 840         time_t t;
 841
 842         while (!NGIRCd_SignalQuit && !NGIRCd_SignalRestart) {
 843                 t = time(NULL);
 844
 845                 /* Check configured servers and established links */
 846                 Check_Servers();
 847                 Check_Connections();
 848
 849                 /* Expire outdated class/list items */
 850                 Class_Expire();
 851
 852                 /* Look for non-empty read buffers ... */
 853                 for (i = 0; i < Pool_Size; i++) {
 854                         if ((My_Connections[i].sock > NONE)
 855                             && (array_bytes(&My_Connections[i].rbuf) > 0)) {
 856                                 /* ... and try to handle the received data */
 857                                 bytes_processed = Handle_Buffer(i);
 858                                 /* if we processed data, and there might be
 859                                  * more commands in the input buffer, do not
 860                                  * try to read any more data now */
 861                                 if (bytes_processed &&
 862                                     array_bytes(&My_Connections[i].rbuf) > 2) {
 863                                         LogDebug
 864                                             ("Throttling connection %d: command limit reached!",
 865                                              i);
 866                                         Conn_SetPenalty(i, 1);
 867                                 }
 868                         }
 869                 }
 870
 871                 /* Look for non-empty write buffers ... */
 872                 for (i = 0; i < Pool_Size; i++) {
 873                         if (My_Connections[i].sock <= NONE)
 874                                 continue;
 875
 876                         wdatalen = (unsigned int)array_bytes(&My_Connections[i].wbuf);
 877 #ifdef ZLIB
 878                         if (wdatalen > 0 ||
 879                             array_bytes(&My_Connections[i].zip.wbuf) > 0)
 880 #else
 881                         if (wdatalen > 0)
 882 #endif
 883                         {
 884                                 if (SSL_WantRead(&My_Connections[i]))
 885                                         continue;
 886                                 io_event_add(My_Connections[i].sock,
 887                                              IO_WANTWRITE);
 888                         }
 889                 }
 890
 891                 /* Check from which sockets we possibly could read ... */
 892                 for (i = 0; i < Pool_Size; i++) {
 893                         if (My_Connections[i].sock <= NONE)
 894                                 continue;
 895 #ifdef SSL_SUPPORT
 896                         if (SSL_WantWrite(&My_Connections[i]))
 897                                 continue; /* TLS/SSL layer needs to write data; deal with this first */
 898 #endif
 899                         if (Proc_InProgress(&My_Connections[i].proc_stat)) {
 900                                 /* Wait for completion of forked subprocess
 901                                  * and ignore the socket in the meantime ... */
 902                                 io_event_del(My_Connections[i].sock,
 903                                              IO_WANTREAD);
 904                                 continue;
 905                         }
 906
 907                         if (Conn_OPTION_ISSET(&My_Connections[i], CONN_ISCONNECTING))
 908                                 /* Wait for completion of connect() ... */
 909                                 continue;
 910
 911                         if (My_Connections[i].delaytime > t) {
 912                                 /* There is a "penalty time" set: ignore socket! */
 913                                 io_event_del(My_Connections[i].sock,
 914                                              IO_WANTREAD);
 915                                 continue;
 916                         }
 917
 918                         io_event_add(My_Connections[i].sock, IO_WANTREAD);
 919                 }
 920
 921                 /* Set the timeout for reading from the network to 1 second,
 922                  * which is the granularity with witch we handle "penalty
 923                  * times" for example.
 924                  * Note: tv_sec/usec are undefined(!) after io_dispatch()
 925                  * returns, so we have to set it before each call to it! */
 926                 tv.tv_usec = 0;
 927                 tv.tv_sec = 1;
 928
 929                 /* Wait for activity ... */
 930                 i = io_dispatch(&tv);
 931                 if (i == -1 && errno != EINTR) {
 932                         Log(LOG_EMERG, "Conn_Handler(): io_dispatch(): %s!",
 933                             strerror(errno));
 934                         Log(LOG_ALERT, "%s exiting due to fatal errors!",
 935                             PACKAGE_NAME);
 936                         exit(1);
 937                 }
 938
 939                 /* Should ngIRCd timeout when idle? */
 940                 if (Conf_IdleTimeout > 0 && NumConnectionsAccepted > 0
 941                     && idle_t > 0 && time(NULL) - idle_t >= Conf_IdleTimeout) {
 942                         LogDebug("Server idle timeout reached: %d second%s. Initiating shutdown ...",
 943                                  Conf_IdleTimeout,
 944                                  Conf_IdleTimeout == 1 ? "" : "s");
 945                         NGIRCd_SignalQuit = true;
 946                 }
 947         }
 948
 949         if (NGIRCd_SignalQuit)
 950                 Log(LOG_NOTICE | LOG_snotice, "Server going down NOW!");
 951         else if (NGIRCd_SignalRestart)
 952                 Log(LOG_NOTICE | LOG_snotice, "Server restarting NOW!");
 953 } /* Conn_Handler */
 954
 955
 956 /**
 957  * Write a text string into the socket of a connection.
 958  *
 959  * This function automatically appends CR+LF to the string and validates that
 960  * the result is a valid IRC message (oversized messages are shortened, for
 961  * example). Then it calls the Conn_Write() function to do the actual sending.
 962  *
 963  * @param Idx           Index fo the connection.
 964  * @param Format        Format string, see printf().
 965  * @returns             true on success, false otherwise.
 966  */
 967 #ifdef PROTOTYPES
 968 GLOBAL bool
 969 Conn_WriteStr(CONN_ID Idx, const char *Format, ...)
 970 #else
 971 GLOBAL bool
 972 Conn_WriteStr(Idx, Format, va_alist)
 973 CONN_ID Idx;
 974 const char *Format;
 975 va_dcl
 976 #endif
 977 {
 978         char buffer[COMMAND_LEN];
 979 #ifdef ICONV
 980         char *ptr, *message;
 981 #endif
 982         size_t len;
 983         bool ok;
 984         va_list ap;
 985
 986         assert( Idx > NONE );
 987         assert( Format != NULL );
 988
 989 #ifdef PROTOTYPES
 990         va_start( ap, Format );
 991 #else
 992         va_start( ap );
 993 #endif
 994         if (vsnprintf( buffer, COMMAND_LEN - 2, Format, ap ) >= COMMAND_LEN - 2 ) {
 995                 /*
 996                  * The string that should be written to the socket is longer
 997                  * than the allowed size of COMMAND_LEN bytes (including both
 998                  * the CR and LF characters). This can be caused by the
 999                  * IRC_WriteXXX() functions when the prefix of this server had
1000                  * to be added to an already "quite long" command line which
1001                  * has been received from a regular IRC client, for example.
1002                  *
1003                  * We are not allowed to send such "oversized" messages to
1004                  * other servers and clients, see RFC 2812 2.3 and 2813 3.3
1005                  * ("these messages SHALL NOT exceed 512 characters in length,
1006                  * counting all characters including the trailing CR-LF").
1007                  *
1008                  * So we have a big problem here: we should send more bytes
1009                  * to the network than we are allowed to and we don't know
1010                  * the originator (any more). The "old" behavior of blaming
1011                  * the receiver ("next hop") is a bad idea (it could be just
1012                  * an other server only routing the message!), so the only
1013                  * option left is to shorten the string and to hope that the
1014                  * result is still somewhat useful ...
1015                  *                                                   -alex-
1016                  */
1017
1018                 strcpy (buffer + sizeof(buffer) - strlen(CUT_TXTSUFFIX) - 2 - 1,
1019                         CUT_TXTSUFFIX);
1020         }
1021
1022 #ifdef ICONV
1023         ptr = strchr(buffer + 1, ':');
1024         if (ptr) {
1025                 ptr++;
1026                 message = Conn_EncodingTo(Idx, ptr);
1027                 if (message != ptr)
1028                         strlcpy(ptr, message, sizeof(buffer) - (ptr - buffer));
1029         }
1030 #endif
1031
1032 #ifdef SNIFFER
1033         if (NGIRCd_Sniffer)
1034                 Log(LOG_DEBUG, " -> connection %d: '%s'.", Idx, buffer);
1035 #endif
1036
1037         len = strlcat( buffer, "\r\n", sizeof( buffer ));
1038         ok = Conn_Write(Idx, buffer, len);
1039         My_Connections[Idx].msg_out++;
1040
1041         va_end( ap );
1042         return ok;
1043 } /* Conn_WriteStr */
1044
1045 GLOBAL char*
1046 Conn_Password( CONN_ID Idx )
1047 {
1048         assert( Idx > NONE );
1049         if (My_Connections[Idx].pwd == NULL)
1050                 return (char*)"\0";
1051         else
1052                 return My_Connections[Idx].pwd;
1053 } /* Conn_Password */
1054
1055 GLOBAL void
1056 Conn_SetPassword( CONN_ID Idx, const char *Pwd )
1057 {
1058         assert( Idx > NONE );
1059
1060         if (My_Connections[Idx].pwd)
1061                 free(My_Connections[Idx].pwd);
1062
1063         My_Connections[Idx].pwd = strdup(Pwd);
1064         if (My_Connections[Idx].pwd == NULL) {
1065                 Log(LOG_EMERG, "Can't allocate memory! [Conn_SetPassword]");
1066                 exit(1);
1067         }
1068 } /* Conn_SetPassword */
1069
1070 /**
1071  * Append Data to the outbound write buffer of a connection.
1072  *
1073  * @param Idx   Index of the connection.
1074  * @param Data  pointer to the data.
1075  * @param Len   length of Data.
1076  * @returns     true on success, false otherwise.
1077  */
1078 static bool
1079 Conn_Write( CONN_ID Idx, char *Data, size_t Len )
1080 {
1081         CLIENT *c;
1082         size_t writebuf_limit = WRITEBUFFER_MAX_LEN;
1083         assert( Idx > NONE );
1084         assert( Data != NULL );
1085         assert( Len > 0 );
1086
1087         /* Is the socket still open? A previous call to Conn_Write()
1088          * may have closed the connection due to a fatal error.
1089          * In this case it is sufficient to return an error, as well. */
1090         if (My_Connections[Idx].sock <= NONE) {
1091                 LogDebug("Skipped write on closed socket (connection %d).", Idx);
1092                 return false;
1093         }
1094
1095         /* Make sure that there still exists a CLIENT structure associated
1096          * with this connection and check if this is a server or not: */
1097         c = Conn_GetClient(Idx);
1098         if (c) {
1099                 /* Servers do get special write buffer limits, so they can
1100                  * generate all the messages that are required while peering. */
1101                 if (Client_Type(c) == CLIENT_SERVER)
1102                         writebuf_limit = WRITEBUFFER_SLINK_LEN;
1103         } else
1104                 LogDebug("Write on socket without client (connection %d)!?", Idx);
1105
1106 #ifdef ZLIB
1107         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP )) {
1108                 /* Compressed link:
1109                  * Zip_Buffer() does all the dirty work for us: it flushes
1110                  * the (pre-)compression buffers if required and handles
1111                  * all error conditions. */
1112                 if (!Zip_Buffer(Idx, Data, Len))
1113                         return false;
1114         }
1115         else
1116 #endif
1117         {
1118                 /* Uncompressed link:
1119                  * Check if outbound buffer has enough space for the data. */
1120                 if (array_bytes(&My_Connections[Idx].wbuf) + Len >=
1121                     WRITEBUFFER_FLUSH_LEN) {
1122                         /* Buffer is full, flush it. Handle_Write deals with
1123                          * low-level errors, if any. */
1124                         if (!Handle_Write(Idx))
1125                                 return false;
1126                 }
1127
1128                 /* When the write buffer is still too big after flushing it,
1129                  * the connection will be killed. */
1130                 if (array_bytes(&My_Connections[Idx].wbuf) + Len >=
1131                     writebuf_limit) {
1132                         Log(LOG_NOTICE,
1133                             "Write buffer space exhausted (connection %d, limit is %lu bytes, %lu bytes new, %lu bytes pending)",
1134                             Idx, writebuf_limit, Len,
1135                             (unsigned long)array_bytes(&My_Connections[Idx].wbuf));
1136                         Conn_Close(Idx, "Write buffer space exhausted", NULL, false);
1137                         return false;
1138                 }
1139
1140                 /* Copy data to write buffer */
1141                 if (!array_catb(&My_Connections[Idx].wbuf, Data, Len))
1142                         return false;
1143
1144                 My_Connections[Idx].bytes_out += Len;
1145         }
1146
1147         /* Adjust global write counter */
1148         WCounter += Len;
1149
1150         return true;
1151 } /* Conn_Write */
1152
1153
1154 /**
1155  * Shut down a connection.
1156  *
1157  * @param Idx           Connection index.
1158  * @param LogMsg        Message to write to the log or NULL. If no LogMsg
1159  *                      is given, the FwdMsg is logged.
1160  * @param FwdMsg        Message to forward to remote servers.
1161  * @param InformClient  If true, inform the client on the connection which is
1162  *                      to be shut down of the reason (FwdMsg) and send
1163  *                      connection statistics before disconnecting it.
1164  */
1165 GLOBAL void
1166 Conn_Close( CONN_ID Idx, const char *LogMsg, const char *FwdMsg, bool InformClient )
1167 {
1168         /* Close connection. Open pipes of asynchronous resolver
1169          * sub-processes are closed down. */
1170
1171         CLIENT *c;
1172         double in_k, out_k;
1173         UINT16 port;
1174 #ifdef ZLIB
1175         double in_z_k, out_z_k;
1176         int in_p, out_p;
1177 #endif
1178
1179         assert( Idx > NONE );
1180
1181         /* Is this link already shutting down? */
1182         if( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ISCLOSING )) {
1183                 /* Conn_Close() has been called recursively for this link;
1184                  * probabe reason: Handle_Write() failed  -- see below. */
1185                 LogDebug("Recursive request to close connection: %d", Idx );
1186                 return;
1187         }
1188
1189         assert( My_Connections[Idx].sock > NONE );
1190
1191         /* Mark link as "closing" */
1192         Conn_OPTION_ADD( &My_Connections[Idx], CONN_ISCLOSING );
1193
1194         port = ng_ipaddr_getport(&My_Connections[Idx].addr);
1195         Log(LOG_INFO, "Shutting down connection %d (%s) with \"%s:%d\" ...", Idx,
1196             LogMsg ? LogMsg : FwdMsg, My_Connections[Idx].host, port);
1197
1198         /* Search client, if any */
1199         c = Conn_GetClient( Idx );
1200
1201         /* Should the client be informed? */
1202         if (InformClient) {
1203 #ifndef STRICT_RFC
1204                 /* Send statistics to client if registered as user: */
1205                 if ((c != NULL) && (Client_Type(c) == CLIENT_USER)) {
1206                         Conn_WriteStr( Idx,
1207                          ":%s NOTICE %s :%sConnection statistics: client %.1f kb, server %.1f kb.",
1208                          Client_ID(Client_ThisServer()), Client_ID(c),
1209                          NOTICE_TXTPREFIX,
1210                          (double)My_Connections[Idx].bytes_in / 1024,
1211                          (double)My_Connections[Idx].bytes_out / 1024);
1212                 }
1213 #endif
1214                 /* Send ERROR to client (see RFC 2812, section 3.1.7) */
1215                 if (FwdMsg)
1216                         Conn_WriteStr(Idx, "ERROR :%s", FwdMsg);
1217                 else
1218                         Conn_WriteStr(Idx, "ERROR :Closing connection");
1219         }
1220
1221         /* Try to write out the write buffer. Note: Handle_Write() eventually
1222          * removes the CLIENT structure associated with this connection if an
1223          * error occurs! So we have to re-check if there is still an valid
1224          * CLIENT structure after calling Handle_Write() ...*/
1225         (void)Handle_Write( Idx );
1226
1227         /* Search client, if any (re-check!) */
1228         c = Conn_GetClient( Idx );
1229 #ifdef SSL_SUPPORT
1230         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_SSL )) {
1231                 Log(LOG_INFO, "SSL connection %d shutting down ...", Idx);
1232                 ConnSSL_Free(&My_Connections[Idx]);
1233         }
1234 #endif
1235         /* Shut down socket */
1236         if (! io_close(My_Connections[Idx].sock)) {
1237                 /* Oops, we can't close the socket!? This is ... ugly! */
1238                 Log(LOG_CRIT,
1239                     "Error closing connection %d (socket %d) with %s:%d - %s! (ignored)",
1240                     Idx, My_Connections[Idx].sock, My_Connections[Idx].host,
1241                     port, strerror(errno));
1242         }
1243
1244         /* Mark socket as invalid: */
1245         My_Connections[Idx].sock = NONE;
1246
1247         /* If there is still a client, unregister it now */
1248         if (c)
1249                 Client_Destroy(c, LogMsg, FwdMsg, true);
1250
1251         /* Calculate statistics and log information */
1252         in_k = (double)My_Connections[Idx].bytes_in / 1024;
1253         out_k = (double)My_Connections[Idx].bytes_out / 1024;
1254 #ifdef ZLIB
1255         if (Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP)) {
1256                 in_z_k = (double)My_Connections[Idx].zip.bytes_in / 1024;
1257                 out_z_k = (double)My_Connections[Idx].zip.bytes_out / 1024;
1258                 /* Make sure that no division by zero can occur during
1259                  * the calculation of in_p and out_p: in_z_k and out_z_k
1260                  * are non-zero, that's guaranteed by the protocol until
1261                  * compression can be enabled. */
1262                 if (! in_z_k)
1263                         in_z_k = in_k;
1264                 if (! out_z_k)
1265                         out_z_k = out_k;
1266                 in_p = (int)(( in_k * 100 ) / in_z_k );
1267                 out_p = (int)(( out_k * 100 ) / out_z_k );
1268                 Log(LOG_INFO,
1269                     "Connection %d with \"%s:%d\" closed (in: %.1fk/%.1fk/%d%%, out: %.1fk/%.1fk/%d%%).",
1270                     Idx, My_Connections[Idx].host, port,
1271                     in_k, in_z_k, in_p, out_k, out_z_k, out_p);
1272         }
1273         else
1274 #endif
1275         {
1276                 Log(LOG_INFO,
1277                     "Connection %d with \"%s:%d\" closed (in: %.1fk, out: %.1fk).",
1278                     Idx, My_Connections[Idx].host, port,
1279                     in_k, out_k);
1280         }
1281
1282         /* Servers: Modify time of next connect attempt? */
1283         Conf_UnsetServer( Idx );
1284
1285 #ifdef ZLIB
1286         /* Clean up zlib, if link was compressed */
1287         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP )) {
1288                 inflateEnd( &My_Connections[Idx].zip.in );
1289                 deflateEnd( &My_Connections[Idx].zip.out );
1290                 array_free(&My_Connections[Idx].zip.rbuf);
1291                 array_free(&My_Connections[Idx].zip.wbuf);
1292         }
1293 #endif
1294
1295         array_free(&My_Connections[Idx].rbuf);
1296         array_free(&My_Connections[Idx].wbuf);
1297         if (My_Connections[Idx].pwd != NULL)
1298                 free(My_Connections[Idx].pwd);
1299
1300         /* Clean up connection structure (=free it) */
1301         Init_Conn_Struct( Idx );
1302
1303         assert(NumConnections > 0);
1304         if (NumConnections)
1305                 NumConnections--;
1306         LogDebug("Shutdown of connection %d completed, %ld connection%s left.",
1307                  Idx, NumConnections, NumConnections != 1 ? "s" : "");
1308
1309         idle_t = NumConnections > 0 ? 0 : time(NULL);
1310 } /* Conn_Close */
1311
1312
1313 /**
1314  * Get current number of connections.
1315  *
1316  * @returns     Number of current connections.
1317  */
1318 GLOBAL long
1319 Conn_Count(void)
1320 {
1321         return NumConnections;
1322 } /* Conn_Count */
1323
1324
1325 /**
1326  * Get number of maximum simultaneous connections.
1327  *
1328  * @returns     Number of maximum simultaneous connections.
1329  */
1330 GLOBAL long
1331 Conn_CountMax(void)
1332 {
1333         return NumConnectionsMax;
1334 } /* Conn_CountMax */
1335
1336
1337 /**
1338  * Get number of connections accepted since the daemon startet.
1339  *
1340  * @returns     Number of connections accepted.
1341  */
1342 GLOBAL long
1343 Conn_CountAccepted(void)
1344 {
1345         return NumConnectionsAccepted;
1346 } /* Conn_CountAccepted */
1347
1348
1349 /**
1350  * Synchronize established connections and configured server structures
1351  * after a configuration update and store the correct connection IDs, if any.
1352  */
1353 GLOBAL void
1354 Conn_SyncServerStruct(void)
1355 {
1356         CLIENT *client;
1357         CONN_ID i;
1358         int c;
1359
1360         for (i = 0; i < Pool_Size; i++) {
1361                 if (My_Connections[i].sock == NONE)
1362                         continue;
1363
1364                 /* Server link? */
1365                 client = Conn_GetClient(i);
1366                 if (!client || Client_Type(client) != CLIENT_SERVER)
1367                         continue;
1368
1369                 for (c = 0; c < MAX_SERVERS; c++) {
1370                         /* Configured server? */
1371                         if (!Conf_Server[c].host[0])
1372                                 continue;
1373
1374                         if (strcasecmp(Conf_Server[c].name, Client_ID(client)) == 0)
1375                                 Conf_Server[c].conn_id = i;
1376                 }
1377         }
1378 } /* SyncServerStruct */
1379
1380
1381 /**
1382  * Get IP address string of a connection.
1383  *
1384  * @param Idx Connection index.
1385  * @return Pointer to a global buffer containing the IP address as string.
1386  */
1387 GLOBAL const char *
1388 Conn_GetIPAInfo(CONN_ID Idx)
1389 {
1390         assert(Idx > NONE);
1391         return ng_ipaddr_tostr(&My_Connections[Idx].addr);
1392 }
1393
1394
1395 /**
1396  * Send out data of write buffer; connect new sockets.
1397  *
1398  * @param Idx   Connection index.
1399  * @returns     true on success, false otherwise.
1400  */
1401 static bool
1402 Handle_Write( CONN_ID Idx )
1403 {
1404         ssize_t len;
1405         size_t wdatalen;
1406
1407         assert( Idx > NONE );
1408         if ( My_Connections[Idx].sock < 0 ) {
1409                 LogDebug("Handle_Write() on closed socket, connection %d", Idx);
1410                 return false;
1411         }
1412         assert( My_Connections[Idx].sock > NONE );
1413
1414         wdatalen = array_bytes(&My_Connections[Idx].wbuf );
1415
1416 #ifdef ZLIB
1417         if (wdatalen == 0) {
1418                 /* Write buffer is empty, so we try to flush the compression
1419                  * buffer and get some data to work with from there :-) */
1420                 if (!Zip_Flush(Idx))
1421                         return false;
1422
1423                 /* Now the write buffer most probably has changed: */
1424                 wdatalen = array_bytes(&My_Connections[Idx].wbuf);
1425         }
1426 #endif
1427
1428         if (wdatalen == 0) {
1429                 /* Still no data, fine. */
1430                 io_event_del(My_Connections[Idx].sock, IO_WANTWRITE );
1431                 return true;
1432         }
1433
1434 #ifdef DEBUG_BUFFER
1435         LogDebug
1436             ("Handle_Write() called for connection %d, %ld bytes pending ...",
1437              Idx, wdatalen);
1438 #endif
1439
1440 #ifdef SSL_SUPPORT
1441         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_SSL )) {
1442                 len = ConnSSL_Write(&My_Connections[Idx], array_start(&My_Connections[Idx].wbuf), wdatalen);
1443         } else
1444 #endif
1445         {
1446                 len = write(My_Connections[Idx].sock,
1447                             array_start(&My_Connections[Idx].wbuf), wdatalen );
1448         }
1449         if( len < 0 ) {
1450                 if (errno == EAGAIN || errno == EINTR)
1451                         return true;
1452
1453                 Log(LOG_ERR, "Write error on connection %d (socket %d): %s!",
1454                     Idx, My_Connections[Idx].sock, strerror(errno));
1455                 Conn_Close(Idx, "Write error", NULL, false);
1456                 return false;
1457         }
1458
1459         /* move any data not yet written to beginning */
1460         array_moveleft(&My_Connections[Idx].wbuf, 1, (size_t)len);
1461
1462         return true;
1463 } /* Handle_Write */
1464
1465
1466 /**
1467  * Count established connections to a specific IP address.
1468  *
1469  * @returns     Number of established connections.
1470  */
1471 static int
1472 Count_Connections(ng_ipaddr_t *a)
1473 {
1474         int i, cnt;
1475
1476         cnt = 0;
1477         for (i = 0; i < Pool_Size; i++) {
1478                 if (My_Connections[i].sock <= NONE)
1479                         continue;
1480                 if (ng_ipaddr_ipequal(&My_Connections[i].addr, a))
1481                         cnt++;
1482         }
1483         return cnt;
1484 } /* Count_Connections */
1485
1486
1487 /**
1488  * Initialize new client connection on a listening socket.
1489  *
1490  * @param Sock  Listening socket descriptor.
1491  * @param IsSSL true if this socket expects SSL-encrypted data.
1492  * @returns     Accepted socket descriptor or -1 on error.
1493  */
1494 static int
1495 New_Connection(int Sock, UNUSED bool IsSSL)
1496 {
1497 #ifdef TCPWRAP
1498         struct request_info req;
1499 #endif
1500         ng_ipaddr_t new_addr;
1501         char ip_str[NG_INET_ADDRSTRLEN];
1502         int new_sock, new_sock_len;
1503         CLIENT *c;
1504         long cnt;
1505
1506         assert(Sock > NONE);
1507
1508         LogDebug("Accepting new connection on socket %d ...", Sock);
1509
1510         new_sock_len = (int)sizeof(new_addr);
1511         new_sock = accept(Sock, (struct sockaddr *)&new_addr,
1512                           (socklen_t *)&new_sock_len);
1513         if (new_sock < 0) {
1514                 Log(LOG_CRIT, "Can't accept connection: %s!", strerror(errno));
1515                 return -1;
1516         }
1517         NumConnectionsAccepted++;
1518
1519         if (!ng_ipaddr_tostr_r(&new_addr, ip_str)) {
1520                 Log(LOG_CRIT, "fd %d: Can't convert IP address!", new_sock);
1521                 Simple_Message(new_sock, "ERROR :Internal Server Error");
1522                 close(new_sock);
1523                 return -1;
1524         }
1525
1526 #ifdef TCPWRAP
1527         /* Validate socket using TCP Wrappers */
1528         request_init(&req, RQ_DAEMON, PACKAGE_NAME, RQ_FILE, new_sock,
1529                      RQ_CLIENT_SIN, &new_addr, NULL);
1530         fromhost(&req);
1531         if (!hosts_access(&req)) {
1532                 Log(deny_severity,
1533                     "Refused connection from %s (by TCP Wrappers)!", ip_str);
1534                 Simple_Message(new_sock, "ERROR :Connection refused");
1535                 close(new_sock);
1536                 return -1;
1537         }
1538 #endif
1539
1540         if (!Init_Socket(new_sock))
1541                 return -1;
1542
1543         /* Check global connection limit */
1544         if ((Conf_MaxConnections > 0) &&
1545             (NumConnections >= (size_t) Conf_MaxConnections)) {
1546                 Log(LOG_ALERT, "Can't accept connection: limit (%d) reached!",
1547                     Conf_MaxConnections);
1548                 Simple_Message(new_sock, "ERROR :Connection limit reached");
1549                 close(new_sock);
1550                 return -1;
1551         }
1552
1553         /* Check IP-based connection limit */
1554         cnt = Count_Connections(&new_addr);
1555         if ((Conf_MaxConnectionsIP > 0) && (cnt >= Conf_MaxConnectionsIP)) {
1556                 /* Access denied, too many connections from this IP address! */
1557                 Log(LOG_ERR,
1558                     "Refused connection from %s: too may connections (%ld) from this IP address!",
1559                     ip_str, cnt);
1560                 Simple_Message(new_sock,
1561                                "ERROR :Connection refused, too many connections from your IP address");
1562                 close(new_sock);
1563                 return -1;
1564         }
1565
1566         if (new_sock >= Pool_Size) {
1567                 if (!array_alloc(&My_ConnArray, sizeof(CONNECTION),
1568                                  (size_t) new_sock)) {
1569                         Log(LOG_EMERG,
1570                             "Can't allocate memory! [New_Connection]");
1571                         Simple_Message(new_sock, "ERROR: Internal error");
1572                         close(new_sock);
1573                         return -1;
1574                 }
1575                 LogDebug("Bumped connection pool to %ld items (internal: %ld items, %ld bytes)",
1576                          new_sock, array_length(&My_ConnArray,
1577                          sizeof(CONNECTION)), array_bytes(&My_ConnArray));
1578
1579                 /* Adjust pointer to new block */
1580                 My_Connections = array_start(&My_ConnArray);
1581                 while (Pool_Size <= new_sock)
1582                         Init_Conn_Struct(Pool_Size++);
1583         }
1584
1585         /* register callback */
1586         if (!io_event_create(new_sock, IO_WANTREAD, cb_clientserver)) {
1587                 Log(LOG_ALERT,
1588                     "Can't accept connection: io_event_create failed!");
1589                 Simple_Message(new_sock, "ERROR :Internal error");
1590                 close(new_sock);
1591                 return -1;
1592         }
1593
1594         c = Client_NewLocal(new_sock, NULL, CLIENT_UNKNOWN, false);
1595         if (!c) {
1596                 Log(LOG_ALERT,
1597                     "Can't accept connection: can't create client structure!");
1598                 Simple_Message(new_sock, "ERROR :Internal error");
1599                 io_close(new_sock);
1600                 return -1;
1601         }
1602
1603         Init_Conn_Struct(new_sock);
1604         My_Connections[new_sock].sock = new_sock;
1605         My_Connections[new_sock].addr = new_addr;
1606         My_Connections[new_sock].client = c;
1607
1608         /* Set initial hostname to IP address. This becomes overwritten when
1609          * the DNS lookup is enabled and succeeds, but is used otherwise. */
1610         if (ng_ipaddr_af(&new_addr) != AF_INET)
1611                 snprintf(My_Connections[new_sock].host,
1612                          sizeof(My_Connections[new_sock].host), "[%s]", ip_str);
1613         else
1614                 strlcpy(My_Connections[new_sock].host, ip_str,
1615                         sizeof(My_Connections[new_sock].host));
1616
1617         Client_SetHostname(c, My_Connections[new_sock].host);
1618
1619         Log(LOG_INFO, "Accepted connection %d from \"%s:%d\" on socket %d.",
1620             new_sock, My_Connections[new_sock].host,
1621             ng_ipaddr_getport(&new_addr), Sock);
1622         Account_Connection();
1623
1624 #ifdef SSL_SUPPORT
1625         /* Delay connection initalization until SSL handshake is finished */
1626         if (!IsSSL)
1627 #endif
1628                 Conn_StartLogin(new_sock);
1629
1630         return new_sock;
1631 } /* New_Connection */
1632
1633
1634 /**
1635  * Finish connection initialization, start resolver subprocess.
1636  *
1637  * @param Idx Connection index.
1638  */
1639 GLOBAL void
1640 Conn_StartLogin(CONN_ID Idx)
1641 {
1642         int ident_sock = -1;
1643
1644         assert(Idx >= 0);
1645
1646         /* Nothing to do if DNS (and resolver subprocess) is disabled */
1647         if (!Conf_DNS)
1648                 return;
1649
1650 #ifdef IDENTAUTH
1651         /* Should we make an IDENT request? */
1652         if (Conf_Ident)
1653                 ident_sock = My_Connections[Idx].sock;
1654 #endif
1655
1656         if (Conf_NoticeAuth) {
1657                 /* Send "NOTICE AUTH" messages to the client */
1658 #ifdef IDENTAUTH
1659                 if (Conf_Ident)
1660                         (void)Conn_WriteStr(Idx,
1661                                 "NOTICE AUTH :*** Looking up your hostname and checking ident");
1662                 else
1663 #endif
1664                         (void)Conn_WriteStr(Idx,
1665                                 "NOTICE AUTH :*** Looking up your hostname");
1666                 (void)Handle_Write(Idx);
1667         }
1668
1669         Resolve_Addr(&My_Connections[Idx].proc_stat, &My_Connections[Idx].addr,
1670                      ident_sock, cb_Read_Resolver_Result);
1671 }
1672
1673
1674 /**
1675  * Update global connection counters.
1676  */
1677 static void
1678 Account_Connection(void)
1679 {
1680         NumConnections++;
1681         idle_t = 0;
1682         if (NumConnections > NumConnectionsMax)
1683                 NumConnectionsMax = NumConnections;
1684         LogDebug("Total number of connections now %lu (max %lu).",
1685                  NumConnections, NumConnectionsMax);
1686 } /* Account_Connection */
1687
1688
1689 /**
1690  * Translate socket handle into connection index.
1691  *
1692  * @param Sock  Socket handle.
1693  * @returns     Connecion index or NONE, if no connection could be found.
1694  */
1695 static CONN_ID
1696 Socket2Index( int Sock )
1697 {
1698         assert( Sock >= 0 );
1699
1700         if( Sock >= Pool_Size || My_Connections[Sock].sock != Sock ) {
1701                 /* the Connection was already closed again, likely due to
1702                  * an error. */
1703                 LogDebug("Socket2Index: can't get connection for socket %d!", Sock);
1704                 return NONE;
1705         }
1706         return Sock;
1707 } /* Socket2Index */
1708
1709
1710 /**
1711  * Read data from the network to the read buffer. If an error occurs,
1712  * the socket of this connection will be shut down.
1713  *
1714  * @param Idx   Connection index.
1715  */
1716 static void
1717 Read_Request( CONN_ID Idx )
1718 {
1719         ssize_t len;
1720         static const unsigned int maxbps = COMMAND_LEN / 2;
1721         char readbuf[READBUFFER_LEN];
1722         time_t t;
1723         CLIENT *c;
1724         assert( Idx > NONE );
1725         assert( My_Connections[Idx].sock > NONE );
1726
1727 #ifdef ZLIB
1728         if ((array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN) ||
1729                 (array_bytes(&My_Connections[Idx].zip.rbuf) >= READBUFFER_LEN))
1730 #else
1731         if (array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN)
1732 #endif
1733         {
1734                 /* Read buffer is full */
1735                 Log(LOG_ERR,
1736                     "Receive buffer space exhausted (connection %d): %d bytes",
1737                     Idx, array_bytes(&My_Connections[Idx].rbuf));
1738                 Conn_Close(Idx, "Receive buffer space exhausted", NULL, false);
1739                 return;
1740         }
1741
1742 #ifdef SSL_SUPPORT
1743         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL))
1744                 len = ConnSSL_Read( &My_Connections[Idx], readbuf, sizeof(readbuf));
1745         else
1746 #endif
1747         len = read(My_Connections[Idx].sock, readbuf, sizeof(readbuf));
1748         if (len == 0) {
1749                 LogDebug("Client \"%s:%u\" is closing connection %d ...",
1750                          My_Connections[Idx].host,
1751                          ng_ipaddr_tostr(&My_Connections[Idx].addr), Idx);
1752                 Conn_Close(Idx, NULL, "Client closed connection", false);
1753                 return;
1754         }
1755
1756         if (len < 0) {
1757                 if( errno == EAGAIN ) return;
1758                 Log(LOG_ERR, "Read error on connection %d (socket %d): %s!",
1759                     Idx, My_Connections[Idx].sock, strerror(errno));
1760                 Conn_Close(Idx, "Read error", "Client closed connection",
1761                            false);
1762                 return;
1763         }
1764 #ifdef ZLIB
1765         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1766                 if (!array_catb(&My_Connections[Idx].zip.rbuf, readbuf,
1767                                 (size_t) len)) {
1768                         Log(LOG_ERR,
1769                             "Could not append received data to zip input buffer (connection %d): %d bytes!",
1770                             Idx, len);
1771                         Conn_Close(Idx, "Receive buffer space exhausted", NULL,
1772                                    false);
1773                         return;
1774                 }
1775         } else
1776 #endif
1777         {
1778                 if (!array_catb( &My_Connections[Idx].rbuf, readbuf, len)) {
1779                         Log(LOG_ERR,
1780                             "Could not append received data to input buffer (connection %d): %d bytes!",
1781                             Idx, len);
1782                         Conn_Close(Idx, "Receive buffer space exhausted", NULL, false );
1783                 }
1784         }
1785
1786         /* Update connection statistics */
1787         My_Connections[Idx].bytes_in += len;
1788         My_Connections[Idx].bps += Handle_Buffer(Idx);
1789
1790         /* Make sure that there is still a valid client registered */
1791         c = Conn_GetClient(Idx);
1792         if (!c)
1793                 return;
1794
1795         /* Update timestamp of last data received if this connection is
1796          * registered as a user, server or service connection. Don't update
1797          * otherwise, so users have at least Conf_PongTimeout seconds time to
1798          * register with the IRC server -- see Check_Connections().
1799          * Update "lastping", too, if time shifted backwards ... */
1800         if (Client_Type(c) == CLIENT_USER
1801             || Client_Type(c) == CLIENT_SERVER
1802             || Client_Type(c) == CLIENT_SERVICE) {
1803                 t = time(NULL);
1804                 if (My_Connections[Idx].lastdata != t)
1805                         My_Connections[Idx].bps = 0;
1806
1807                 My_Connections[Idx].lastdata = t;
1808                 if (My_Connections[Idx].lastping > t)
1809                         My_Connections[Idx].lastping = t;
1810         }
1811
1812         /* Look at the data in the (read-) buffer of this connection */
1813         if (Client_Type(c) != CLIENT_SERVER
1814             && Client_Type(c) != CLIENT_UNKNOWNSERVER
1815             && Client_Type(c) != CLIENT_SERVICE
1816             && My_Connections[Idx].bps >= maxbps) {
1817                 LogDebug("Throttling connection %d: BPS exceeded! (%u >= %u)",
1818                          Idx, My_Connections[Idx].bps, maxbps);
1819                 Conn_SetPenalty(Idx, 1);
1820         }
1821 } /* Read_Request */
1822
1823
1824 /**
1825  * Handle all data in the connection read-buffer.
1826  *
1827  * Data is processed until no complete command is left in the read buffer,
1828  * or MAX_COMMANDS[_SERVER|_SERVICE] commands were processed.
1829  * When a fatal error occurs, the connection is shut down.
1830  *
1831  * @param Idx   Index of the connection.
1832  * @returns     Number of bytes processed.
1833  */
1834 static unsigned int
1835 Handle_Buffer(CONN_ID Idx)
1836 {
1837 #ifndef STRICT_RFC
1838         char *ptr1, *ptr2, *first_eol;
1839 #endif
1840         char *ptr;
1841         size_t len, delta;
1842         time_t starttime;
1843 #ifdef ZLIB
1844         bool old_z;
1845 #endif
1846         unsigned int i, maxcmd = MAX_COMMANDS, len_processed = 0;
1847         CLIENT *c;
1848
1849         c = Conn_GetClient(Idx);
1850         starttime = time(NULL);
1851
1852         assert(c != NULL);
1853
1854         /* Servers get special command limits that depend on the user count */
1855         switch (Client_Type(c)) {
1856             case CLIENT_SERVER:
1857                 maxcmd = (int)(Client_UserCount() / 5)
1858                        + MAX_COMMANDS_SERVER_MIN;
1859                 /* Allow servers to handle even more commands while peering
1860                  * to speed up server login and network synchronization. */
1861                 if (Conn_LastPing(Idx) == 0)
1862                         maxcmd *= 5;
1863                 break;
1864             case CLIENT_SERVICE:
1865                 maxcmd = MAX_COMMANDS_SERVICE; break;
1866         }
1867
1868         for (i=0; i < maxcmd; i++) {
1869                 /* Check penalty */
1870                 if (My_Connections[Idx].delaytime > starttime)
1871                         return 0;
1872 #ifdef ZLIB
1873                 /* Unpack compressed data, if compression is in use */
1874                 if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1875                         /* When unzipping fails, Unzip_Buffer() shuts
1876                          * down the connection itself */
1877                         if (!Unzip_Buffer(Idx))
1878                                 return 0;
1879                 }
1880 #endif
1881
1882                 if (0 == array_bytes(&My_Connections[Idx].rbuf))
1883                         break;
1884
1885                 /* Make sure that the buffer is NULL terminated */
1886                 if (!array_cat0_temporary(&My_Connections[Idx].rbuf)) {
1887                         Conn_Close(Idx, NULL,
1888                                    "Can't allocate memory [Handle_Buffer]",
1889                                    true);
1890                         return 0;
1891                 }
1892
1893                 /* RFC 2812, section "2.3 Messages", 5th paragraph:
1894                  * "IRC messages are always lines of characters terminated
1895                  * with a CR-LF (Carriage Return - Line Feed) pair [...]". */
1896                 delta = 2;
1897                 ptr = strstr(array_start(&My_Connections[Idx].rbuf), "\r\n");
1898
1899 #ifndef STRICT_RFC
1900                 /* Check for non-RFC-compliant request (only CR or LF)?
1901                  * Unfortunately, there are quite a few clients out there
1902                  * that do this -- e. g. mIRC, BitchX, and Trillian :-( */
1903                 ptr1 = strchr(array_start(&My_Connections[Idx].rbuf), '\r');
1904                 ptr2 = strchr(array_start(&My_Connections[Idx].rbuf), '\n');
1905                 if (ptr) {
1906                         /* Check if there is a single CR or LF _before_ the
1907                          * corerct CR+LF line terminator:  */
1908                         first_eol = ptr1 < ptr2 ? ptr1 : ptr2;
1909                         if (first_eol < ptr) {
1910                                 /* Single CR or LF before CR+LF found */
1911                                 ptr = first_eol;
1912                                 delta = 1;
1913                         }
1914                 } else if (ptr1 || ptr2) {
1915                         /* No CR+LF terminated command found, but single
1916                          * CR or LF found ... */
1917                         if (ptr1 && ptr2)
1918                                 ptr = ptr1 < ptr2 ? ptr1 : ptr2;
1919                         else
1920                                 ptr = ptr1 ? ptr1 : ptr2;
1921                         delta = 1;
1922                 }
1923 #endif
1924
1925                 if (!ptr)
1926                         break;
1927
1928                 /* Complete (=line terminated) request found, handle it! */
1929                 *ptr = '\0';
1930
1931                 len = ptr - (char *)array_start(&My_Connections[Idx].rbuf) + delta;
1932
1933                 if (len > (COMMAND_LEN - 1)) {
1934                         /* Request must not exceed 512 chars (incl. CR+LF!),
1935                          * see RFC 2812. Disconnect Client if this happens. */
1936                         Log(LOG_ERR,
1937                             "Request too long (connection %d): %d bytes (max. %d expected)!",
1938                             Idx, array_bytes(&My_Connections[Idx].rbuf),
1939                             COMMAND_LEN - 1);
1940                         Conn_Close(Idx, NULL, "Request too long", true);
1941                         return 0;
1942                 }
1943
1944                 len_processed += (unsigned int)len;
1945                 if (len <= delta) {
1946                         /* Request is empty (only '\r\n', '\r' or '\n');
1947                          * delta is 2 ('\r\n') or 1 ('\r' or '\n'), see above */
1948                         array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1949                         continue;
1950                 }
1951 #ifdef ZLIB
1952                 /* remember if stream is already compressed */
1953                 old_z = My_Connections[Idx].options & CONN_ZIP;
1954 #endif
1955
1956                 My_Connections[Idx].msg_in++;
1957                 if (!Parse_Request
1958                     (Idx, (char *)array_start(&My_Connections[Idx].rbuf)))
1959                         return 0; /* error -> connection has been closed */
1960
1961                 array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1962 #ifdef DEBUG_BUFFER
1963                 LogDebug("Connection %d: %d bytes left in read buffer.",
1964                          Idx, array_bytes(&My_Connections[Idx].rbuf));
1965 #endif
1966 #ifdef ZLIB
1967                 if ((!old_z) && (My_Connections[Idx].options & CONN_ZIP) &&
1968                     (array_bytes(&My_Connections[Idx].rbuf) > 0)) {
1969                         /* The last command activated socket compression.
1970                          * Data that was read after that needs to be copied
1971                          * to the unzip buffer for decompression: */
1972                         if (!array_copy
1973                             (&My_Connections[Idx].zip.rbuf,
1974                              &My_Connections[Idx].rbuf)) {
1975                                 Conn_Close(Idx, NULL,
1976                                            "Can't allocate memory [Handle_Buffer]",
1977                                            true);
1978                                 return 0;
1979                         }
1980
1981                         array_trunc(&My_Connections[Idx].rbuf);
1982                         LogDebug
1983                             ("Moved already received data (%u bytes) to uncompression buffer.",
1984                              array_bytes(&My_Connections[Idx].zip.rbuf));
1985                 }
1986 #endif
1987         }
1988         return len_processed;
1989 } /* Handle_Buffer */
1990
1991
1992 /**
1993  * Check whether established connections are still alive or not.
1994  * If not, play PING-PONG first; and if that doesn't help either,
1995  * disconnect the respective peer.
1996  */
1997 static void
1998 Check_Connections(void)
1999 {
2000         CLIENT *c;
2001         CONN_ID i;
2002         char msg[64];
2003
2004         for (i = 0; i < Pool_Size; i++) {
2005                 if (My_Connections[i].sock < 0)
2006                         continue;
2007
2008                 c = Conn_GetClient(i);
2009                 if (c && ((Client_Type(c) == CLIENT_USER)
2010                           || (Client_Type(c) == CLIENT_SERVER)
2011                           || (Client_Type(c) == CLIENT_SERVICE))) {
2012                         /* connected User, Server or Service */
2013                         if (My_Connections[i].lastping >
2014                             My_Connections[i].lastdata) {
2015                                 /* We already sent a ping */
2016                                 if (My_Connections[i].lastping <
2017                                     time(NULL) - Conf_PongTimeout) {
2018                                         /* Timeout */
2019                                         snprintf(msg, sizeof(msg),
2020                                                  "Ping timeout: %d seconds",
2021                                                  Conf_PongTimeout);
2022                                         LogDebug("Connection %d: %s.", i, msg);
2023                                         Conn_Close(i, NULL, msg, true);
2024                                 }
2025                         } else if (My_Connections[i].lastdata <
2026                                    time(NULL) - Conf_PingTimeout) {
2027                                 /* We need to send a PING ... */
2028                                 LogDebug("Connection %d: sending PING ...", i);
2029                                 Conn_UpdatePing(i);
2030                                 Conn_WriteStr(i, "PING :%s",
2031                                               Client_ID(Client_ThisServer()));
2032                         }
2033                 } else {
2034                         /* The connection is not fully established yet, so
2035                          * we don't do the PING-PONG game here but instead
2036                          * disconnect the client after "a short time" if it's
2037                          * still not registered. */
2038
2039                         if (My_Connections[i].lastdata <
2040                             time(NULL) - Conf_PongTimeout) {
2041                                 LogDebug
2042                                     ("Unregistered connection %d timed out ...",
2043                                      i);
2044                                 Conn_Close(i, NULL, "Timeout", false);
2045                         }
2046                 }
2047         }
2048 } /* Check_Connections */
2049
2050
2051 /**
2052  * Check if further server links should be established.
2053  */
2054 static void
2055 Check_Servers(void)
2056 {
2057         int i, n;
2058         time_t time_now;
2059
2060         time_now = time(NULL);
2061
2062         /* Check all configured servers */
2063         for (i = 0; i < MAX_SERVERS; i++) {
2064                 if (Conf_Server[i].conn_id != NONE)
2065                         continue;       /* Already establishing or connected */
2066                 if (!Conf_Server[i].host[0] || !Conf_Server[i].port > 0)
2067                         continue;       /* No host and/or port configured */
2068                 if (Conf_Server[i].flags & CONF_SFLAG_DISABLED)
2069                         continue;       /* Disabled configuration entry */
2070                 if (Conf_Server[i].lasttry > (time_now - Conf_ConnectRetry))
2071                         continue;       /* We have to wait a little bit ... */
2072
2073                 /* Is there already a connection in this group? */
2074                 if (Conf_Server[i].group > NONE) {
2075                         for (n = 0; n < MAX_SERVERS; n++) {
2076                                 if (n == i)
2077                                         continue;
2078                                 if ((Conf_Server[n].conn_id != NONE) &&
2079                                     (Conf_Server[n].group == Conf_Server[i].group))
2080                                         break;
2081                         }
2082                         if (n < MAX_SERVERS)
2083                                 continue;
2084                 }
2085
2086                 /* Okay, try to connect now */
2087                 Log(LOG_NOTICE,
2088                     "Preparing to establish a new server link for \"%s\" ...",
2089                     Conf_Server[i].name);
2090                 Conf_Server[i].lasttry = time_now;
2091                 Conf_Server[i].conn_id = SERVER_WAIT;
2092                 assert(Proc_GetPipeFd(&Conf_Server[i].res_stat) < 0);
2093                 Resolve_Name(&Conf_Server[i].res_stat, Conf_Server[i].host,
2094                              cb_Connect_to_Server);
2095         }
2096 } /* Check_Servers */
2097
2098
2099 /**
2100  * Establish a new outgoing server connection.
2101  *
2102  * @param Server        Configuration index of the server.
2103  * @param dest          Destination IP address to connect to.
2104  */
2105 static void
2106 New_Server( int Server , ng_ipaddr_t *dest)
2107 {
2108         /* Establish new server link */
2109         char ip_str[NG_INET_ADDRSTRLEN];
2110         int af_dest, res, new_sock;
2111         CLIENT *c;
2112
2113         assert( Server > NONE );
2114
2115         /* Make sure that the remote server hasn't re-linked to this server
2116          * asynchronously on its own */
2117         if (Conf_Server[Server].conn_id > NONE) {
2118                 Log(LOG_INFO,
2119                         "Connection to \"%s\" meanwhile re-established, aborting preparation.");
2120                 return;
2121         }
2122
2123         if (!ng_ipaddr_tostr_r(dest, ip_str)) {
2124                 Log(LOG_WARNING, "New_Server: Could not convert IP to string");
2125                 return;
2126         }
2127
2128         af_dest = ng_ipaddr_af(dest);
2129         new_sock = socket(af_dest, SOCK_STREAM, 0);
2130
2131         Log(LOG_INFO,
2132             "Establishing connection for \"%s\" to \"%s:%d\" (%s), socket %d ...",
2133             Conf_Server[Server].name, Conf_Server[Server].host,
2134             Conf_Server[Server].port, ip_str, new_sock);
2135
2136         if (new_sock < 0) {
2137                 Log(LOG_CRIT, "Can't create socket (af %d): %s!",
2138                     af_dest, strerror(errno));
2139                 return;
2140         }
2141
2142         if (!Init_Socket(new_sock))
2143                 return;
2144
2145         /* is a bind address configured? */
2146         res = ng_ipaddr_af(&Conf_Server[Server].bind_addr);
2147         /* if yes, bind now. If it fails, warn and let connect() pick a source address */
2148         if (res && bind(new_sock, (struct sockaddr *) &Conf_Server[Server].bind_addr,
2149                                 ng_ipaddr_salen(&Conf_Server[Server].bind_addr)))
2150         {
2151                 ng_ipaddr_tostr_r(&Conf_Server[Server].bind_addr, ip_str);
2152                 Log(LOG_WARNING, "Can't bind socket to %s: %s!", ip_str, strerror(errno));
2153         }
2154         ng_ipaddr_setport(dest, Conf_Server[Server].port);
2155         res = connect(new_sock, (struct sockaddr *) dest, ng_ipaddr_salen(dest));
2156         if(( res != 0 ) && ( errno != EINPROGRESS )) {
2157                 Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
2158                 close( new_sock );
2159                 return;
2160         }
2161
2162         if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)new_sock)) {
2163                 Log(LOG_ALERT,
2164                     "Cannot allocate memory for server connection (socket %d)",
2165                     new_sock);
2166                 close( new_sock );
2167                 return;
2168         }
2169
2170         if (!io_event_create( new_sock, IO_WANTWRITE, cb_connserver)) {
2171                 Log(LOG_ALERT, "io_event_create(): could not add fd %d", strerror(errno));
2172                 close(new_sock);
2173                 return;
2174         }
2175
2176         My_Connections = array_start(&My_ConnArray);
2177
2178         assert(My_Connections[new_sock].sock <= 0);
2179
2180         Init_Conn_Struct(new_sock);
2181
2182         ng_ipaddr_tostr_r(dest, ip_str);
2183         c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWNSERVER, false);
2184         if (!c) {
2185                 Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
2186                 io_close(new_sock);
2187                 return;
2188         }
2189
2190         /* Conn_Close() decrements this counter again */
2191         Account_Connection();
2192         Client_SetIntroducer( c, c );
2193         Client_SetToken( c, TOKEN_OUTBOUND );
2194
2195         /* Register connection */
2196         if (!Conf_SetServer(Server, new_sock))
2197                 return;
2198         My_Connections[new_sock].sock = new_sock;
2199         My_Connections[new_sock].addr = *dest;
2200         My_Connections[new_sock].client = c;
2201         strlcpy( My_Connections[new_sock].host, Conf_Server[Server].host,
2202                                 sizeof(My_Connections[new_sock].host ));
2203
2204 #ifdef SSL_SUPPORT
2205         if (Conf_Server[Server].SSLConnect && !ConnSSL_PrepareConnect( &My_Connections[new_sock],
2206                                                                 &Conf_Server[Server] ))
2207         {
2208                 Log(LOG_ALERT, "Could not initialize SSL for outgoing connection");
2209                 Conn_Close( new_sock, "Could not initialize SSL for outgoing connection", NULL, false );
2210                 Init_Conn_Struct( new_sock );
2211                 Conf_Server[Server].conn_id = NONE;
2212                 return;
2213         }
2214 #endif
2215         LogDebug("Registered new connection %d on socket %d (%ld in total).",
2216                  new_sock, My_Connections[new_sock].sock, NumConnections);
2217         Conn_OPTION_ADD( &My_Connections[new_sock], CONN_ISCONNECTING );
2218 } /* New_Server */
2219
2220
2221 /**
2222  * Initialize connection structure.
2223  *
2224  * @param Idx   Connection index.
2225  */
2226 static void
2227 Init_Conn_Struct(CONN_ID Idx)
2228 {
2229         time_t now = time(NULL);
2230
2231         memset(&My_Connections[Idx], 0, sizeof(CONNECTION));
2232         My_Connections[Idx].sock = -1;
2233         My_Connections[Idx].signon = now;
2234         My_Connections[Idx].lastdata = now;
2235         My_Connections[Idx].lastprivmsg = now;
2236         Proc_InitStruct(&My_Connections[Idx].proc_stat);
2237
2238 #ifdef ICONV
2239         My_Connections[Idx].iconv_from = (iconv_t)(-1);
2240         My_Connections[Idx].iconv_to = (iconv_t)(-1);
2241 #endif
2242 } /* Init_Conn_Struct */
2243
2244
2245 /**
2246  * Initialize options of a new socket.
2247  *
2248  * For example, we try to set socket options SO_REUSEADDR and IPTOS_LOWDELAY.
2249  * The socket is automatically closed if a fatal error is encountered.
2250  *
2251  * @param Sock  Socket handle.
2252  * @returns false if socket was closed due to fatal error.
2253  */
2254 static bool
2255 Init_Socket( int Sock )
2256 {
2257         int value;
2258
2259         if (!io_setnonblock(Sock)) {
2260                 Log( LOG_CRIT, "Can't enable non-blocking mode for socket: %s!", strerror( errno ));
2261                 close( Sock );
2262                 return false;
2263         }
2264
2265         /* Don't block this port after socket shutdown */
2266         value = 1;
2267         if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &value, (socklen_t)sizeof( value )) != 0 )
2268         {
2269                 Log( LOG_ERR, "Can't set socket option SO_REUSEADDR: %s!", strerror( errno ));
2270                 /* ignore this error */
2271         }
2272
2273         /* Set type of service (TOS) */
2274 #if defined(IPPROTO_IP) && defined(IPTOS_LOWDELAY)
2275         value = IPTOS_LOWDELAY;
2276         if (setsockopt(Sock, IPPROTO_IP, IP_TOS, &value,
2277                        (socklen_t) sizeof(value))) {
2278                 LogDebug("Can't set socket option IP_TOS: %s!",
2279                          strerror(errno));
2280                 /* ignore this error */
2281         } else
2282                 LogDebug("IP_TOS on socket %d has been set to IPTOS_LOWDELAY.",
2283                          Sock);
2284 #endif
2285
2286         return true;
2287 } /* Init_Socket */
2288
2289
2290 /**
2291  * Read results of a resolver sub-process and try to initiate a new server
2292  * connection.
2293  *
2294  * @param fd            File descriptor of the pipe to the sub-process.
2295  * @param events        (ignored IO specification)
2296  */
2297 static void
2298 cb_Connect_to_Server(int fd, UNUSED short events)
2299 {
2300         /* Read result of resolver sub-process from pipe and start connection */
2301         int i;
2302         size_t len;
2303         ng_ipaddr_t dest_addrs[4];      /* we can handle at most 3; but we read up to
2304                                            four so we can log the 'more than we can handle'
2305                                            condition. First result is tried immediately, rest
2306                                            is saved for later if needed. */
2307
2308         LogDebug("Resolver: Got forward lookup callback on fd %d, events %d", fd, events);
2309
2310         for (i=0; i < MAX_SERVERS; i++) {
2311                   if (Proc_GetPipeFd(&Conf_Server[i].res_stat) == fd )
2312                           break;
2313         }
2314
2315         if( i >= MAX_SERVERS) {
2316                 /* Ops, no matching server found?! */
2317                 io_close( fd );
2318                 LogDebug("Resolver: Got Forward Lookup callback for unknown server!?");
2319                 return;
2320         }
2321
2322         /* Read result from pipe */
2323         len = Proc_Read(&Conf_Server[i].res_stat, dest_addrs, sizeof(dest_addrs));
2324         Proc_Close(&Conf_Server[i].res_stat);
2325         if (len == 0) {
2326                 /* Error resolving hostname: reset server structure */
2327                 Conf_Server[i].conn_id = NONE;
2328                 return;
2329         }
2330
2331         assert((len % sizeof(ng_ipaddr_t)) == 0);
2332
2333         LogDebug("Got result from resolver: %u structs (%u bytes).", len/sizeof(ng_ipaddr_t), len);
2334
2335         memset(&Conf_Server[i].dst_addr, 0, sizeof(Conf_Server[i].dst_addr));
2336         if (len > sizeof(ng_ipaddr_t)) {
2337                 /* more than one address for this hostname, remember them
2338                  * in case first address is unreachable/not available */
2339                 len -= sizeof(ng_ipaddr_t);
2340                 if (len > sizeof(Conf_Server[i].dst_addr)) {
2341                         len = sizeof(Conf_Server[i].dst_addr);
2342                         Log(LOG_NOTICE,
2343                                 "Notice: Resolver returned more IP Addresses for host than we can handle, additional addresses dropped.");
2344                 }
2345                 memcpy(&Conf_Server[i].dst_addr, &dest_addrs[1], len);
2346         }
2347         /* connect() */
2348         New_Server(i, dest_addrs);
2349 } /* cb_Read_Forward_Lookup */
2350
2351
2352 /**
2353  * Read results of a resolver sub-process from the pipe and update the
2354  * appropriate connection/client structure(s): hostname and/or IDENT user name.
2355  *
2356  * @param r_fd          File descriptor of the pipe to the sub-process.
2357  * @param events        (ignored IO specification)
2358  */
2359 static void
2360 cb_Read_Resolver_Result( int r_fd, UNUSED short events )
2361 {
2362         CLIENT *c;
2363         CONN_ID i;
2364         size_t len;
2365         char *identptr;
2366 #ifdef IDENTAUTH
2367         char readbuf[HOST_LEN + 2 + CLIENT_USER_LEN];
2368         char *ptr;
2369 #else
2370         char readbuf[HOST_LEN + 1];
2371 #endif
2372
2373         LogDebug("Resolver: Got callback on fd %d, events %d", r_fd, events );
2374         i = Conn_GetFromProc(r_fd);
2375         if (i == NONE) {
2376                 /* Ops, none found? Probably the connection has already
2377                  * been closed!? We'll ignore that ... */
2378                 io_close( r_fd );
2379                 LogDebug("Resolver: Got callback for unknown connection!?");
2380                 return;
2381         }
2382
2383         /* Read result from pipe */
2384         len = Proc_Read(&My_Connections[i].proc_stat, readbuf, sizeof readbuf -1);
2385         Proc_Close(&My_Connections[i].proc_stat);
2386         if (len == 0)
2387                 return;
2388
2389         readbuf[len] = '\0';
2390         identptr = strchr(readbuf, '\n');
2391         assert(identptr != NULL);
2392         if (!identptr) {
2393                 Log( LOG_CRIT, "Resolver: Got malformed result!");
2394                 return;
2395         }
2396
2397         *identptr = '\0';
2398         LogDebug("Got result from resolver: \"%s\" (%u bytes read).", readbuf, len);
2399         /* Okay, we got a complete result: this is a host name for outgoing
2400          * connections and a host name and IDENT user name (if enabled) for
2401          * incoming connections.*/
2402         assert ( My_Connections[i].sock >= 0 );
2403         /* Incoming connection. Search client ... */
2404         c = Conn_GetClient( i );
2405         assert( c != NULL );
2406
2407         /* Only update client information of unregistered clients.
2408          * Note: user commands (e. g. WEBIRC) are always read _after_ reading
2409          * the resolver results, so we don't have to worry to override settings
2410          * from these commands here. */
2411         if(Client_Type(c) == CLIENT_UNKNOWN) {
2412                 strlcpy(My_Connections[i].host, readbuf,
2413                         sizeof(My_Connections[i].host));
2414                 Client_SetHostname(c, readbuf);
2415                 if (Conf_NoticeAuth)
2416                         (void)Conn_WriteStr(i,
2417                                         "NOTICE AUTH :*** Found your hostname: %s",
2418                                         My_Connections[i].host);
2419 #ifdef IDENTAUTH
2420                 ++identptr;
2421                 if (*identptr) {
2422                         ptr = identptr;
2423                         while (*ptr) {
2424                                 if ((*ptr < '0' || *ptr > '9') &&
2425                                     (*ptr < 'A' || *ptr > 'Z') &&
2426                                     (*ptr < 'a' || *ptr > 'z'))
2427                                         break;
2428                                 ptr++;
2429                         }
2430                         if (*ptr) {
2431                                 /* Erroneous IDENT reply */
2432                                 Log(LOG_NOTICE,
2433                                     "Got invalid IDENT reply for connection %d! Ignored.",
2434                                     i);
2435                         } else {
2436                                 Log(LOG_INFO,
2437                                     "IDENT lookup for connection %d: \"%s\".",
2438                                     i, identptr);
2439                                 Client_SetUser(c, identptr, true);
2440                         }
2441                         if (Conf_NoticeAuth) {
2442                                 (void)Conn_WriteStr(i,
2443                                         "NOTICE AUTH :*** Got %sident response%s%s",
2444                                         *ptr ? "invalid " : "",
2445                                         *ptr ? "" : ": ",
2446                                         *ptr ? "" : identptr);
2447                         }
2448                 } else {
2449                         Log(LOG_INFO, "IDENT lookup for connection %d: no result.", i);
2450                         if (Conf_NoticeAuth && Conf_Ident)
2451                                 (void)Conn_WriteStr(i,
2452                                         "NOTICE AUTH :*** No ident response");
2453                 }
2454 #endif
2455
2456                 if (Conf_NoticeAuth)
2457                         (void)Handle_Write(i);
2458
2459                 Class_HandleServerBans(c);
2460         }
2461 #ifdef DEBUG
2462                 else Log( LOG_DEBUG, "Resolver: discarding result for already registered connection %d.", i );
2463 #endif
2464 } /* cb_Read_Resolver_Result */
2465
2466
2467 /**
2468  * Write a "simple" (error) message to a socket.
2469  *
2470  * The message is sent without using the connection write buffers, without
2471  * compression/encryption, and even without any error reporting. It is
2472  * designed for error messages of e.g. New_Connection().
2473  *
2474  * @param Sock  Socket handle.
2475  * @param Msg   Message string to send.
2476  */
2477 static void
2478 Simple_Message(int Sock, const char *Msg)
2479 {
2480         char buf[COMMAND_LEN];
2481         size_t len;
2482
2483         assert(Sock > NONE);
2484         assert(Msg != NULL);
2485
2486         strlcpy(buf, Msg, sizeof buf - 2);
2487         len = strlcat(buf, "\r\n", sizeof buf);
2488         if (write(Sock, buf, len) < 0) {
2489                 /* Because this function most probably got called to log
2490                  * an error message, any write error is ignored here to
2491                  * avoid an endless loop. But casting the result of write()
2492                  * to "void" doesn't satisfy the GNU C code attribute
2493                  * "warn_unused_result" which is used by some versions of
2494                  * glibc (e.g. 2.11.1), therefore this silly error
2495                  * "handling" code here :-( */
2496                 return;
2497         }
2498 } /* Simple_Error */
2499
2500
2501 /**
2502  * Get CLIENT structure that belongs to a local connection identified by its
2503  * index number. Each connection belongs to a client by definition, so it is
2504  * not required that the caller checks for NULL return values.
2505  *
2506  * @param Idx   Connection index number.
2507  * @returns     Pointer to CLIENT structure.
2508  */
2509 GLOBAL CLIENT *
2510 Conn_GetClient( CONN_ID Idx )
2511 {
2512         CONNECTION *c;
2513
2514         assert(Idx >= 0);
2515         c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
2516         assert(c != NULL);
2517         return c ? c->client : NULL;
2518 }
2519
2520 /**
2521  * Get PROC_STAT sub-process structure of a connection.
2522  *
2523  * @param Idx   Connection index number.
2524  * @returns     PROC_STAT structure.
2525  */
2526 GLOBAL PROC_STAT *
2527 Conn_GetProcStat(CONN_ID Idx)
2528 {
2529         CONNECTION *c;
2530
2531         assert(Idx >= 0);
2532         c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
2533         assert(c != NULL);
2534         return &c->proc_stat;
2535 } /* Conn_GetProcStat */
2536
2537
2538 /**
2539  * Get CONN_ID from file descriptor associated to a subprocess structure.
2540  *
2541  * @param fd    File descriptor.
2542  * @returns     CONN_ID or NONE (-1).
2543  */
2544 GLOBAL CONN_ID
2545 Conn_GetFromProc(int fd)
2546 {
2547         int i;
2548
2549         assert(fd > 0);
2550         for (i = 0; i < Pool_Size; i++) {
2551                 if ((My_Connections[i].sock != NONE)
2552                     && (Proc_GetPipeFd(&My_Connections[i].proc_stat) == fd))
2553                         return i;
2554         }
2555         return NONE;
2556 } /* Conn_GetFromProc */
2557
2558
2559 #ifndef STRICT_RFC
2560
2561 GLOBAL long
2562 Conn_GetAuthPing(CONN_ID Idx)
2563 {
2564         assert (Idx != NONE);
2565         return My_Connections[Idx].auth_ping;
2566 } /* Conn_GetAuthPing */
2567
2568 GLOBAL void
2569 Conn_SetAuthPing(CONN_ID Idx, long ID)
2570 {
2571         assert (Idx != NONE);
2572         My_Connections[Idx].auth_ping = ID;
2573 } /* Conn_SetAuthPing */
2574
2575 #endif
2576
2577
2578 #ifdef SSL_SUPPORT
2579
2580 /**
2581  * Get information about used SSL cipher.
2582  *
2583  * @param Idx   Connection index number.
2584  * @param buf   Buffer for returned information text.
2585  * @param len   Size of return buffer "buf".
2586  * @returns     true on success, false otherwise.
2587  */
2588 GLOBAL bool
2589 Conn_GetCipherInfo(CONN_ID Idx, char *buf, size_t len)
2590 {
2591         if (Idx < 0)
2592                 return false;
2593         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2594         return ConnSSL_GetCipherInfo(&My_Connections[Idx], buf, len);
2595 }
2596
2597
2598 /**
2599  * Check if a connection is SSL-enabled or not.
2600  *
2601  * @param Idx   Connection index number.
2602  * @return      true if connection is SSL-enabled, false otherwise.
2603  */
2604 GLOBAL bool
2605 Conn_UsesSSL(CONN_ID Idx)
2606 {
2607         if (Idx < 0)
2608                 return false;
2609         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2610         return Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL);
2611 }
2612
2613
2614 GLOBAL char *
2615 Conn_GetCertFp(CONN_ID Idx)
2616 {
2617         if (Idx < 0)
2618                 return NULL;
2619         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2620         return ConnSSL_GetCertFp(&My_Connections[Idx]);
2621 }
2622
2623
2624 GLOBAL bool
2625 Conn_SetCertFp(CONN_ID Idx, const char *fingerprint)
2626 {
2627         if (Idx < 0)
2628                 return false;
2629         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2630         return ConnSSL_SetCertFp(&My_Connections[Idx], fingerprint);
2631 }
2632 #else
2633 GLOBAL bool
2634 Conn_UsesSSL(UNUSED CONN_ID Idx)
2635 {
2636         return false;
2637 }
2638
2639
2640 GLOBAL char *
2641 Conn_GetCertFp(UNUSED CONN_ID Idx)
2642 {
2643         return NULL;
2644 }
2645
2646
2647 GLOBAL bool
2648 Conn_SetCertFp(UNUSED CONN_ID Idx, UNUSED const char *fingerprint)
2649 {
2650         return true;
2651 }
2652 #endif
2653
2654
2655 #ifdef DEBUG
2656
2657 /**
2658  * Dump internal state of the "connection module".
2659  */
2660 GLOBAL void
2661 Conn_DebugDump(void)
2662 {
2663         int i;
2664
2665         Log(LOG_DEBUG, "Connection status:");
2666         for (i = 0; i < Pool_Size; i++) {
2667                 if (My_Connections[i].sock == NONE)
2668                         continue;
2669                 Log(LOG_DEBUG,
2670                     " - %d: host=%s, lastdata=%ld, lastping=%ld, delaytime=%ld, flag=%d, options=%d, bps=%d, client=%s",
2671                     My_Connections[i].sock, My_Connections[i].host,
2672                     My_Connections[i].lastdata, My_Connections[i].lastping,
2673                     My_Connections[i].delaytime, My_Connections[i].flag,
2674                     My_Connections[i].options, My_Connections[i].bps,
2675                     My_Connections[i].client ? Client_ID(My_Connections[i].client) : "-");
2676         }
2677 } /* Conn_DumpClients */
2678
2679 #endif
2680
2681
2682 /* -eof- */