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