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