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