d9d73e842b9ade409ef280c47f1d8e9602046d4b
[ngircd-alex.git] / src / ngircd / conn.c
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001-2011 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 10
86 #define MAX_COMMANDS_SERVICE MAX_COMMANDS_SERVER
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
922 /**
923  * Append Data to the outbound write buffer of a connection.
924  *
925  * @param Idx   Index of the connection.
926  * @param Data  pointer to the data.
927  * @param Len   length of Data.
928  * @returns     true on success, false otherwise.
929  */
930 static bool
931 Conn_Write( CONN_ID Idx, char *Data, size_t Len )
932 {
933         CLIENT *c;
934         size_t writebuf_limit = WRITEBUFFER_MAX_LEN;
935         assert( Idx > NONE );
936         assert( Data != NULL );
937         assert( Len > 0 );
938
939         c = Conn_GetClient(Idx);
940         assert( c != NULL);
941
942         /* Servers do get special write buffer limits, so they can generate
943          * all the messages that are required while peering. */
944         if (Client_Type(c) == CLIENT_SERVER)
945                 writebuf_limit = WRITEBUFFER_SLINK_LEN;
946
947         /* Is the socket still open? A previous call to Conn_Write()
948          * may have closed the connection due to a fatal error.
949          * In this case it is sufficient to return an error, as well. */
950         if( My_Connections[Idx].sock <= NONE ) {
951                 LogDebug("Skipped write on closed socket (connection %d).", Idx);
952                 return false;
953         }
954
955 #ifdef ZLIB
956         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP )) {
957                 /* Compressed link:
958                  * Zip_Buffer() does all the dirty work for us: it flushes
959                  * the (pre-)compression buffers if required and handles
960                  * all error conditions. */
961                 if (!Zip_Buffer(Idx, Data, Len))
962                         return false;
963         }
964         else
965 #endif
966         {
967                 /* Uncompressed link:
968                  * Check if outbound buffer has enough space for the data. */
969                 if (array_bytes(&My_Connections[Idx].wbuf) + Len >=
970                     WRITEBUFFER_FLUSH_LEN) {
971                         /* Buffer is full, flush it. Handle_Write deals with
972                          * low-level errors, if any. */
973                         if (!Handle_Write(Idx))
974                                 return false;
975                 }
976
977                 /* When the write buffer is still too big after flushing it,
978                  * the connection will be killed. */
979                 if (array_bytes(&My_Connections[Idx].wbuf) + Len >=
980                     writebuf_limit) {
981                         Log(LOG_NOTICE,
982                             "Write buffer space exhausted (connection %d, limit is %lu bytes, %lu bytes new, %lu bytes pending)",
983                             Idx, writebuf_limit, Len,
984                             (unsigned long)array_bytes(&My_Connections[Idx].wbuf));
985                         Conn_Close(Idx, "Write buffer space exhausted", NULL, false);
986                         return false;
987                 }
988
989                 /* Copy data to write buffer */
990                 if (!array_catb(&My_Connections[Idx].wbuf, Data, Len))
991                         return false;
992
993                 My_Connections[Idx].bytes_out += Len;
994         }
995
996         /* Adjust global write counter */
997         WCounter += Len;
998
999         return true;
1000 } /* Conn_Write */
1001
1002
1003 /**
1004  * Shut down a connection.
1005  *
1006  * @param Idx           Connection index.
1007  * @param LogMsg        Message to write to the log or NULL. If no LogMsg
1008  *                      is given, the FwdMsg is logged.
1009  * @param FwdMsg        Message to forward to remote servers.
1010  * @param InformClient  If true, inform the client on the connection which is
1011  *                      to be shut down of the reason (FwdMsg) and send
1012  *                      connection statistics before disconnecting it.
1013  */
1014 GLOBAL void
1015 Conn_Close( CONN_ID Idx, const char *LogMsg, const char *FwdMsg, bool InformClient )
1016 {
1017         /* Close connection. Open pipes of asynchronous resolver
1018          * sub-processes are closed down. */
1019
1020         CLIENT *c;
1021         double in_k, out_k;
1022         UINT16 port;
1023 #ifdef ZLIB
1024         double in_z_k, out_z_k;
1025         int in_p, out_p;
1026 #endif
1027
1028         assert( Idx > NONE );
1029
1030         /* Is this link already shutting down? */
1031         if( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ISCLOSING )) {
1032                 /* Conn_Close() has been called recursively for this link;
1033                  * probabe reason: Handle_Write() failed  -- see below. */
1034                 LogDebug("Recursive request to close connection: %d", Idx );
1035                 return;
1036         }
1037
1038         assert( My_Connections[Idx].sock > NONE );
1039
1040         /* Mark link as "closing" */
1041         Conn_OPTION_ADD( &My_Connections[Idx], CONN_ISCLOSING );
1042
1043         port = ng_ipaddr_getport(&My_Connections[Idx].addr);
1044         Log(LOG_INFO, "Shutting down connection %d (%s) with %s:%d ...", Idx,
1045             LogMsg ? LogMsg : FwdMsg, My_Connections[Idx].host, port);
1046
1047         /* Search client, if any */
1048         c = Conn_GetClient( Idx );
1049
1050         /* Should the client be informed? */
1051         if (InformClient) {
1052 #ifndef STRICT_RFC
1053                 /* Send statistics to client if registered as user: */
1054                 if ((c != NULL) && (Client_Type(c) == CLIENT_USER)) {
1055                         Conn_WriteStr( Idx,
1056                          ":%s NOTICE %s :%sConnection statistics: client %.1f kb, server %.1f kb.",
1057                          Client_ID(Client_ThisServer()), Client_ID(c),
1058                          NOTICE_TXTPREFIX,
1059                          (double)My_Connections[Idx].bytes_in / 1024,
1060                          (double)My_Connections[Idx].bytes_out / 1024);
1061                 }
1062 #endif
1063                 /* Send ERROR to client (see RFC 2812, section 3.1.7) */
1064                 if (FwdMsg)
1065                         Conn_WriteStr(Idx, "ERROR :%s", FwdMsg);
1066                 else
1067                         Conn_WriteStr(Idx, "ERROR :Closing connection");
1068         }
1069
1070         /* Try to write out the write buffer. Note: Handle_Write() eventually
1071          * removes the CLIENT structure associated with this connection if an
1072          * error occurs! So we have to re-check if there is still an valid
1073          * CLIENT structure after calling Handle_Write() ...*/
1074         (void)Handle_Write( Idx );
1075
1076         /* Search client, if any (re-check!) */
1077         c = Conn_GetClient( Idx );
1078 #ifdef SSL_SUPPORT
1079         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_SSL )) {
1080                 Log(LOG_INFO, "SSL connection %d shutting down ...", Idx);
1081                 ConnSSL_Free(&My_Connections[Idx]);
1082         }
1083 #endif
1084         /* Shut down socket */
1085         if (! io_close(My_Connections[Idx].sock)) {
1086                 /* Oops, we can't close the socket!? This is ... ugly! */
1087                 Log(LOG_CRIT,
1088                     "Error closing connection %d (socket %d) with %s:%d - %s! (ignored)",
1089                     Idx, My_Connections[Idx].sock, My_Connections[Idx].host,
1090                     port, strerror(errno));
1091         }
1092
1093         /* Mark socket as invalid: */
1094         My_Connections[Idx].sock = NONE;
1095
1096         /* If there is still a client, unregister it now */
1097         if (c)
1098                 Client_Destroy(c, LogMsg, FwdMsg, true);
1099
1100         /* Calculate statistics and log information */
1101         in_k = (double)My_Connections[Idx].bytes_in / 1024;
1102         out_k = (double)My_Connections[Idx].bytes_out / 1024;
1103 #ifdef ZLIB
1104         if (Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP)) {
1105                 in_z_k = (double)My_Connections[Idx].zip.bytes_in / 1024;
1106                 out_z_k = (double)My_Connections[Idx].zip.bytes_out / 1024;
1107                 /* Make sure that no division by zero can occur during
1108                  * the calculation of in_p and out_p: in_z_k and out_z_k
1109                  * are non-zero, that's guaranteed by the protocol until
1110                  * compression can be enabled. */
1111                 if (! in_z_k)
1112                         in_z_k = in_k;
1113                 if (! out_z_k)
1114                         out_z_k = out_k;
1115                 in_p = (int)(( in_k * 100 ) / in_z_k );
1116                 out_p = (int)(( out_k * 100 ) / out_z_k );
1117                 Log(LOG_INFO,
1118                     "Connection %d with %s:%d closed (in: %.1fk/%.1fk/%d%%, out: %.1fk/%.1fk/%d%%).",
1119                     Idx, My_Connections[Idx].host, port,
1120                     in_k, in_z_k, in_p, out_k, out_z_k, out_p);
1121         }
1122         else
1123 #endif
1124         {
1125                 Log(LOG_INFO,
1126                     "Connection %d with %s:%d closed (in: %.1fk, out: %.1fk).",
1127                     Idx, My_Connections[Idx].host, port,
1128                     in_k, out_k);
1129         }
1130
1131         /* Servers: Modify time of next connect attempt? */
1132         Conf_UnsetServer( Idx );
1133
1134 #ifdef ZLIB
1135         /* Clean up zlib, if link was compressed */
1136         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_ZIP )) {
1137                 inflateEnd( &My_Connections[Idx].zip.in );
1138                 deflateEnd( &My_Connections[Idx].zip.out );
1139                 array_free(&My_Connections[Idx].zip.rbuf);
1140                 array_free(&My_Connections[Idx].zip.wbuf);
1141         }
1142 #endif
1143
1144         array_free(&My_Connections[Idx].rbuf);
1145         array_free(&My_Connections[Idx].wbuf);
1146
1147         /* Clean up connection structure (=free it) */
1148         Init_Conn_Struct( Idx );
1149
1150         assert(NumConnections > 0);
1151         if (NumConnections)
1152                 NumConnections--;
1153         LogDebug("Shutdown of connection %d completed, %ld connection%s left.",
1154                  Idx, NumConnections, NumConnections != 1 ? "s" : "");
1155 } /* Conn_Close */
1156
1157
1158 /**
1159  * Get current number of connections.
1160  *
1161  * @returns     Number of current connections.
1162  */
1163 GLOBAL long
1164 Conn_Count(void)
1165 {
1166         return NumConnections;
1167 } /* Conn_Count */
1168
1169
1170 /**
1171  * Get number of maximum simultaneous connections.
1172  *
1173  * @returns     Number of maximum simultaneous connections.
1174  */
1175 GLOBAL long
1176 Conn_CountMax(void)
1177 {
1178         return NumConnectionsMax;
1179 } /* Conn_CountMax */
1180
1181
1182 /**
1183  * Get number of connections accepted since the daemon startet.
1184  *
1185  * @returns     Number of connections accepted.
1186  */
1187 GLOBAL long
1188 Conn_CountAccepted(void)
1189 {
1190         return NumConnectionsAccepted;
1191 } /* Conn_CountAccepted */
1192
1193
1194 /**
1195  * Synchronize established connections and configured server structures
1196  * after a configuration update and store the correct connection IDs, if any.
1197  */
1198 GLOBAL void
1199 Conn_SyncServerStruct(void)
1200 {
1201         CLIENT *client;
1202         CONN_ID i;
1203         int c;
1204
1205         for (i = 0; i < Pool_Size; i++) {
1206                 if (My_Connections[i].sock == NONE)
1207                         continue;
1208
1209                 /* Server link? */
1210                 client = Conn_GetClient(i);
1211                 if (!client || Client_Type(client) != CLIENT_SERVER)
1212                         continue;
1213
1214                 for (c = 0; c < MAX_SERVERS; c++) {
1215                         /* Configured server? */
1216                         if (!Conf_Server[c].host[0])
1217                                 continue;
1218
1219                         if (strcasecmp(Conf_Server[c].name, Client_ID(client)) == 0)
1220                                 Conf_Server[c].conn_id = i;
1221                 }
1222         }
1223 } /* SyncServerStruct */
1224
1225
1226 /**
1227  * Send out data of write buffer; connect new sockets.
1228  *
1229  * @param Idx   Connection index.
1230  * @returns     true on success, false otherwise.
1231  */
1232 static bool
1233 Handle_Write( CONN_ID Idx )
1234 {
1235         ssize_t len;
1236         size_t wdatalen;
1237
1238         assert( Idx > NONE );
1239         if ( My_Connections[Idx].sock < 0 ) {
1240                 LogDebug("Handle_Write() on closed socket, connection %d", Idx);
1241                 return false;
1242         }
1243         assert( My_Connections[Idx].sock > NONE );
1244
1245         wdatalen = array_bytes(&My_Connections[Idx].wbuf );
1246
1247 #ifdef ZLIB
1248         if (wdatalen == 0) {
1249                 /* Write buffer is empty, so we try to flush the compression
1250                  * buffer and get some data to work with from there :-) */
1251                 if (!Zip_Flush(Idx))
1252                         return false;
1253
1254                 /* Now the write buffer most probably has changed: */
1255                 wdatalen = array_bytes(&My_Connections[Idx].wbuf);
1256         }
1257 #endif
1258
1259         if (wdatalen == 0) {
1260                 /* Still no data, fine. */
1261                 io_event_del(My_Connections[Idx].sock, IO_WANTWRITE );
1262                 return true;
1263         }
1264
1265 #ifdef DEBUG_BUFFER
1266         LogDebug
1267             ("Handle_Write() called for connection %d, %ld bytes pending ...",
1268              Idx, wdatalen);
1269 #endif
1270
1271 #ifdef SSL_SUPPORT
1272         if ( Conn_OPTION_ISSET( &My_Connections[Idx], CONN_SSL )) {
1273                 len = ConnSSL_Write(&My_Connections[Idx], array_start(&My_Connections[Idx].wbuf), wdatalen);
1274         } else
1275 #endif
1276         {
1277                 len = write(My_Connections[Idx].sock,
1278                             array_start(&My_Connections[Idx].wbuf), wdatalen );
1279         }
1280         if( len < 0 ) {
1281                 if (errno == EAGAIN || errno == EINTR)
1282                         return true;
1283
1284                 Log(LOG_ERR, "Write error on connection %d (socket %d): %s!",
1285                     Idx, My_Connections[Idx].sock, strerror(errno));
1286                 Conn_Close(Idx, "Write error!", NULL, false);
1287                 return false;
1288         }
1289
1290         /* move any data not yet written to beginning */
1291         array_moveleft(&My_Connections[Idx].wbuf, 1, (size_t)len);
1292
1293         return true;
1294 } /* Handle_Write */
1295
1296
1297 /**
1298  * Count established connections to a specific IP address.
1299  *
1300  * @returns     Number of established connections.
1301  */
1302 static int
1303 Count_Connections(ng_ipaddr_t *a)
1304 {
1305         int i, cnt;
1306
1307         cnt = 0;
1308         for (i = 0; i < Pool_Size; i++) {
1309                 if (My_Connections[i].sock <= NONE)
1310                         continue;
1311                 if (ng_ipaddr_ipequal(&My_Connections[i].addr, a))
1312                         cnt++;
1313         }
1314         return cnt;
1315 } /* Count_Connections */
1316
1317
1318 /**
1319  * Initialize new client connection on a listening socket.
1320  *
1321  * @param Sock  Listening socket descriptor.
1322  * @returns     Accepted socket descriptor or -1 on error.
1323  */
1324 static int
1325 New_Connection(int Sock)
1326 {
1327 #ifdef TCPWRAP
1328         struct request_info req;
1329 #endif
1330         ng_ipaddr_t new_addr;
1331         char ip_str[NG_INET_ADDRSTRLEN];
1332         int new_sock, new_sock_len, identsock;
1333         CLIENT *c;
1334         long cnt;
1335
1336         assert(Sock > NONE);
1337
1338         LogDebug("Accepting new connection on socket %d ...", Sock);
1339
1340         new_sock_len = (int)sizeof(new_addr);
1341         new_sock = accept(Sock, (struct sockaddr *)&new_addr,
1342                           (socklen_t *)&new_sock_len);
1343         if (new_sock < 0) {
1344                 Log(LOG_CRIT, "Can't accept connection: %s!", strerror(errno));
1345                 return -1;
1346         }
1347         NumConnectionsAccepted++;
1348
1349         if (!ng_ipaddr_tostr_r(&new_addr, ip_str)) {
1350                 Log(LOG_CRIT, "fd %d: Can't convert IP address!", new_sock);
1351                 Simple_Message(new_sock, "ERROR :Internal Server Error");
1352                 close(new_sock);
1353                 return -1;
1354         }
1355
1356 #ifdef TCPWRAP
1357         /* Validate socket using TCP Wrappers */
1358         request_init(&req, RQ_DAEMON, PACKAGE_NAME, RQ_FILE, new_sock,
1359                      RQ_CLIENT_SIN, &new_addr, NULL);
1360         fromhost(&req);
1361         if (!hosts_access(&req)) {
1362                 Log(deny_severity,
1363                     "Refused connection from %s (by TCP Wrappers)!", ip_str);
1364                 Simple_Message(new_sock, "ERROR :Connection refused");
1365                 close(new_sock);
1366                 return -1;
1367         }
1368 #endif
1369
1370         if (!Init_Socket(new_sock))
1371                 return -1;
1372
1373         /* Check global connection limit */
1374         if ((Conf_MaxConnections > 0) &&
1375             (NumConnections >= (size_t) Conf_MaxConnections)) {
1376                 Log(LOG_ALERT, "Can't accept connection: limit (%d) reached!",
1377                     Conf_MaxConnections);
1378                 Simple_Message(new_sock, "ERROR :Connection limit reached");
1379                 close(new_sock);
1380                 return -1;
1381         }
1382
1383         /* Check IP-based connection limit */
1384         cnt = Count_Connections(&new_addr);
1385         if ((Conf_MaxConnectionsIP > 0) && (cnt >= Conf_MaxConnectionsIP)) {
1386                 /* Access denied, too many connections from this IP address! */
1387                 Log(LOG_ERR,
1388                     "Refused connection from %s: too may connections (%ld) from this IP address!",
1389                     ip_str, cnt);
1390                 Simple_Message(new_sock,
1391                                "ERROR :Connection refused, too many connections from your IP address");
1392                 close(new_sock);
1393                 return -1;
1394         }
1395
1396         if (new_sock >= Pool_Size) {
1397                 if (!array_alloc(&My_ConnArray, sizeof(CONNECTION),
1398                                  (size_t) new_sock)) {
1399                         Log(LOG_EMERG,
1400                             "Can't allocate memory! [New_Connection]");
1401                         Simple_Message(new_sock, "ERROR: Internal error");
1402                         close(new_sock);
1403                         return -1;
1404                 }
1405                 LogDebug("Bumped connection pool to %ld items (internal: %ld items, %ld bytes)",
1406                          new_sock, array_length(&My_ConnArray,
1407                          sizeof(CONNECTION)), array_bytes(&My_ConnArray));
1408
1409                 /* Adjust pointer to new block */
1410                 My_Connections = array_start(&My_ConnArray);
1411                 while (Pool_Size <= new_sock)
1412                         Init_Conn_Struct(Pool_Size++);
1413         }
1414
1415         /* register callback */
1416         if (!io_event_create(new_sock, IO_WANTREAD, cb_clientserver)) {
1417                 Log(LOG_ALERT,
1418                     "Can't accept connection: io_event_create failed!");
1419                 Simple_Message(new_sock, "ERROR :Internal error");
1420                 close(new_sock);
1421                 return -1;
1422         }
1423
1424         c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWN, false);
1425         if (!c) {
1426                 Log(LOG_ALERT,
1427                     "Can't accept connection: can't create client structure!");
1428                 Simple_Message(new_sock, "ERROR :Internal error");
1429                 io_close(new_sock);
1430                 return -1;
1431         }
1432
1433         Init_Conn_Struct(new_sock);
1434         My_Connections[new_sock].sock = new_sock;
1435         My_Connections[new_sock].addr = new_addr;
1436         My_Connections[new_sock].client = c;
1437
1438         /* Set initial hostname to IP address. This becomes overwritten when
1439          * the DNS lookup is enabled and succeeds, but is used otherwise. */
1440         if (ng_ipaddr_af(&new_addr) != AF_INET)
1441                 snprintf(My_Connections[new_sock].host,
1442                          sizeof(My_Connections[new_sock].host), "[%s]", ip_str);
1443         else
1444                 strlcpy(My_Connections[new_sock].host, ip_str,
1445                         sizeof(My_Connections[new_sock].host));
1446
1447         Client_SetHostname(c, My_Connections[new_sock].host);
1448
1449         Log(LOG_INFO, "Accepted connection %d from %s:%d on socket %d.",
1450             new_sock, My_Connections[new_sock].host,
1451             ng_ipaddr_getport(&new_addr), Sock);
1452
1453         identsock = new_sock;
1454 #ifdef IDENTAUTH
1455         if (!Conf_Ident)
1456                 identsock = -1;
1457 #endif
1458         if (Conf_DNS) {
1459                 if (Conf_NoticeAuth) {
1460 #ifdef IDENTAUTH
1461                         if (Conf_Ident)
1462                                 (void)Conn_WriteStr(new_sock,
1463                                         "NOTICE AUTH :*** Looking up your hostname and checking ident");
1464                         else
1465 #endif
1466                                 (void)Conn_WriteStr(new_sock,
1467                                         "NOTICE AUTH :*** Looking up your hostname");
1468                 }
1469                 Resolve_Addr(&My_Connections[new_sock].proc_stat, &new_addr,
1470                              identsock, cb_Read_Resolver_Result);
1471         }
1472
1473         Account_Connection();
1474         return new_sock;
1475 } /* New_Connection */
1476
1477
1478 /**
1479  * Update global connection counters.
1480  */
1481 static void
1482 Account_Connection(void)
1483 {
1484         NumConnections++;
1485         if (NumConnections > NumConnectionsMax)
1486                 NumConnectionsMax = NumConnections;
1487         LogDebug("Total number of connections now %lu (max %lu).",
1488                  NumConnections, NumConnectionsMax);
1489 } /* Account_Connection */
1490
1491
1492 /**
1493  * Translate socket handle into connection index.
1494  *
1495  * @param Sock  Socket handle.
1496  * @returns     Connecion index or NONE, if no connection could be found.
1497  */
1498 static CONN_ID
1499 Socket2Index( int Sock )
1500 {
1501         assert( Sock >= 0 );
1502
1503         if( Sock >= Pool_Size || My_Connections[Sock].sock != Sock ) {
1504                 /* the Connection was already closed again, likely due to
1505                  * an error. */
1506                 LogDebug("Socket2Index: can't get connection for socket %d!", Sock);
1507                 return NONE;
1508         }
1509         return Sock;
1510 } /* Socket2Index */
1511
1512
1513 /**
1514  * Read data from the network to the read buffer. If an error occures,
1515  * the socket of this connection will be shut down.
1516  *
1517  * @param Idx   Connection index.
1518  */
1519 static void
1520 Read_Request( CONN_ID Idx )
1521 {
1522         ssize_t len;
1523         static const unsigned int maxbps = COMMAND_LEN / 2;
1524         char readbuf[READBUFFER_LEN];
1525         time_t t;
1526         CLIENT *c;
1527         assert( Idx > NONE );
1528         assert( My_Connections[Idx].sock > NONE );
1529
1530 #ifdef ZLIB
1531         if ((array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN) ||
1532                 (array_bytes(&My_Connections[Idx].zip.rbuf) >= READBUFFER_LEN))
1533 #else
1534         if (array_bytes(&My_Connections[Idx].rbuf) >= READBUFFER_LEN)
1535 #endif
1536         {
1537                 /* Read buffer is full */
1538                 Log(LOG_ERR,
1539                     "Receive buffer space exhausted (connection %d): %d bytes",
1540                     Idx, array_bytes(&My_Connections[Idx].rbuf));
1541                 Conn_Close(Idx, "Receive buffer space exhausted", NULL, false);
1542                 return;
1543         }
1544
1545 #ifdef SSL_SUPPORT
1546         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL))
1547                 len = ConnSSL_Read( &My_Connections[Idx], readbuf, sizeof(readbuf));
1548         else
1549 #endif
1550         len = read(My_Connections[Idx].sock, readbuf, sizeof(readbuf));
1551         if (len == 0) {
1552                 Log(LOG_INFO, "%s:%u (%s) is closing the connection ...",
1553                                 My_Connections[Idx].host,
1554                                 (unsigned int) ng_ipaddr_getport(&My_Connections[Idx].addr),
1555                                 ng_ipaddr_tostr(&My_Connections[Idx].addr));
1556                 Conn_Close(Idx,
1557                            "Socket closed!", "Client closed connection",
1558                            false);
1559                 return;
1560         }
1561
1562         if (len < 0) {
1563                 if( errno == EAGAIN ) return;
1564                 Log(LOG_ERR, "Read error on connection %d (socket %d): %s!",
1565                     Idx, My_Connections[Idx].sock, strerror(errno));
1566                 Conn_Close(Idx, "Read error!", "Client closed connection",
1567                            false);
1568                 return;
1569         }
1570 #ifdef ZLIB
1571         if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1572                 if (!array_catb(&My_Connections[Idx].zip.rbuf, readbuf,
1573                                 (size_t) len)) {
1574                         Log(LOG_ERR,
1575                             "Could not append recieved data to zip input buffer (connection %d): %d bytes!",
1576                             Idx, len);
1577                         Conn_Close(Idx, "Receive buffer space exhausted", NULL,
1578                                    false);
1579                         return;
1580                 }
1581         } else
1582 #endif
1583         {
1584                 if (!array_catb( &My_Connections[Idx].rbuf, readbuf, len)) {
1585                         Log(LOG_ERR,
1586                             "Could not append recieved data to input buffer (connection %d): %d bytes!",
1587                             Idx, len);
1588                         Conn_Close(Idx, "Receive buffer space exhausted", NULL, false );
1589                 }
1590         }
1591
1592         /* Update connection statistics */
1593         My_Connections[Idx].bytes_in += len;
1594         My_Connections[Idx].bps += Handle_Buffer(Idx);
1595
1596         /* Make sure that there is still a valid client registered */
1597         c = Conn_GetClient(Idx);
1598         if (!c)
1599                 return;
1600
1601         /* Update timestamp of last data received if this connection is
1602          * registered as a user, server or service connection. Don't update
1603          * otherwise, so users have at least Conf_PongTimeout seconds time to
1604          * register with the IRC server -- see Check_Connections().
1605          * Update "lastping", too, if time shifted backwards ... */
1606         if (Client_Type(c) == CLIENT_USER
1607             || Client_Type(c) == CLIENT_SERVER
1608             || Client_Type(c) == CLIENT_SERVICE) {
1609                 t = time(NULL);
1610                 if (My_Connections[Idx].lastdata != t)
1611                         My_Connections[Idx].bps = 0;
1612
1613                 My_Connections[Idx].lastdata = t;
1614                 if (My_Connections[Idx].lastping > t)
1615                         My_Connections[Idx].lastping = t;
1616         }
1617
1618         /* Look at the data in the (read-) buffer of this connection */
1619         if (Client_Type(c) != CLIENT_SERVER
1620             && Client_Type(c) != CLIENT_UNKNOWNSERVER
1621             && Client_Type(c) != CLIENT_SERVICE
1622             && My_Connections[Idx].bps >= maxbps) {
1623                 LogDebug("Throttling connection %d: BPS exceeded! (%u >= %u)",
1624                          Idx, My_Connections[Idx].bps, maxbps);
1625                 Conn_SetPenalty(Idx, 1);
1626         }
1627 } /* Read_Request */
1628
1629
1630 /**
1631  * Handle all data in the connection read-buffer.
1632  *
1633  * Data is processed until no complete command is left in the read buffer,
1634  * or MAX_COMMANDS[_SERVER|_SERVICE] commands were processed.
1635  * When a fatal error occurs, the connection is shut down.
1636  *
1637  * @param Idx   Index of the connection.
1638  * @returns     Number of bytes processed.
1639  */
1640 static unsigned int
1641 Handle_Buffer(CONN_ID Idx)
1642 {
1643 #ifndef STRICT_RFC
1644         char *ptr1, *ptr2, *first_eol;
1645 #endif
1646         char *ptr;
1647         size_t len, delta;
1648         time_t starttime;
1649 #ifdef ZLIB
1650         bool old_z;
1651 #endif
1652         unsigned int i, maxcmd = MAX_COMMANDS, len_processed = 0;
1653         CLIENT *c;
1654
1655         c = Conn_GetClient(Idx);
1656         starttime = time(NULL);
1657
1658         assert(c != NULL);
1659
1660         /* Servers do get special command limits, so they can process
1661          * all the messages that are required while peering. */
1662         switch (Client_Type(c)) {
1663             case CLIENT_SERVER:
1664                 /* Allow servers to send more commands in the first 10 secods
1665                  * to speed up server login and network synchronisation. */
1666                 if (starttime - Client_StartTime(c) < 10)
1667                         maxcmd = MAX_COMMANDS_SERVER * 5;
1668                 else
1669                         maxcmd = MAX_COMMANDS_SERVER;
1670                 break;
1671             case CLIENT_SERVICE:
1672                 maxcmd = MAX_COMMANDS_SERVICE; break;
1673         }
1674
1675         for (i=0; i < maxcmd; i++) {
1676                 /* Check penalty */
1677                 if (My_Connections[Idx].delaytime > starttime)
1678                         return 0;
1679 #ifdef ZLIB
1680                 /* Unpack compressed data, if compression is in use */
1681                 if (Conn_OPTION_ISSET(&My_Connections[Idx], CONN_ZIP)) {
1682                         /* When unzipping fails, Unzip_Buffer() shuts
1683                          * down the connection itself */
1684                         if (!Unzip_Buffer(Idx))
1685                                 return 0;
1686                 }
1687 #endif
1688
1689                 if (0 == array_bytes(&My_Connections[Idx].rbuf))
1690                         break;
1691
1692                 /* Make sure that the buffer is NULL terminated */
1693                 if (!array_cat0_temporary(&My_Connections[Idx].rbuf)) {
1694                         Conn_Close(Idx, NULL,
1695                                    "Can't allocate memory [Handle_Buffer]",
1696                                    true);
1697                         return 0;
1698                 }
1699
1700                 /* RFC 2812, section "2.3 Messages", 5th paragraph:
1701                  * "IRC messages are always lines of characters terminated
1702                  * with a CR-LF (Carriage Return - Line Feed) pair [...]". */
1703                 delta = 2;
1704                 ptr = strstr(array_start(&My_Connections[Idx].rbuf), "\r\n");
1705
1706 #ifndef STRICT_RFC
1707                 /* Check for non-RFC-compliant request (only CR or LF)?
1708                  * Unfortunately, there are quite a few clients out there
1709                  * that do this -- e. g. mIRC, BitchX, and Trillian :-( */
1710                 ptr1 = strchr(array_start(&My_Connections[Idx].rbuf), '\r');
1711                 ptr2 = strchr(array_start(&My_Connections[Idx].rbuf), '\n');
1712                 if (ptr) {
1713                         /* Check if there is a single CR or LF _before_ the
1714                          * corerct CR+LF line terminator:  */
1715                         first_eol = ptr1 < ptr2 ? ptr1 : ptr2;
1716                         if (first_eol < ptr) {
1717                                 /* Single CR or LF before CR+LF found */
1718                                 ptr = first_eol;
1719                                 delta = 1;
1720                         }
1721                 } else if (ptr1 || ptr2) {
1722                         /* No CR+LF terminated command found, but single
1723                          * CR or LF found ... */
1724                         if (ptr1 && ptr2)
1725                                 ptr = ptr1 < ptr2 ? ptr1 : ptr2;
1726                         else
1727                                 ptr = ptr1 ? ptr1 : ptr2;
1728                         delta = 1;
1729                 }
1730 #endif
1731
1732                 if (!ptr)
1733                         break;
1734
1735                 /* Complete (=line terminated) request found, handle it! */
1736                 *ptr = '\0';
1737
1738                 len = ptr - (char *)array_start(&My_Connections[Idx].rbuf) + delta;
1739
1740                 if (len > (COMMAND_LEN - 1)) {
1741                         /* Request must not exceed 512 chars (incl. CR+LF!),
1742                          * see RFC 2812. Disconnect Client if this happens. */
1743                         Log(LOG_ERR,
1744                             "Request too long (connection %d): %d bytes (max. %d expected)!",
1745                             Idx, array_bytes(&My_Connections[Idx].rbuf),
1746                             COMMAND_LEN - 1);
1747                         Conn_Close(Idx, NULL, "Request too long", true);
1748                         return 0;
1749                 }
1750
1751                 len_processed += (unsigned int)len;
1752                 if (len <= delta) {
1753                         /* Request is empty (only '\r\n', '\r' or '\n');
1754                          * delta is 2 ('\r\n') or 1 ('\r' or '\n'), see above */
1755                         array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1756                         continue;
1757                 }
1758 #ifdef ZLIB
1759                 /* remember if stream is already compressed */
1760                 old_z = My_Connections[Idx].options & CONN_ZIP;
1761 #endif
1762
1763                 My_Connections[Idx].msg_in++;
1764                 if (!Parse_Request
1765                     (Idx, (char *)array_start(&My_Connections[Idx].rbuf)))
1766                         return 0; /* error -> connection has been closed */
1767
1768                 array_moveleft(&My_Connections[Idx].rbuf, 1, len);
1769 #ifdef DEBUG_BUFFER
1770                 LogDebug("Connection %d: %d bytes left in read buffer.",
1771                          Idx, array_bytes(&My_Connections[Idx].rbuf));
1772 #endif
1773 #ifdef ZLIB
1774                 if ((!old_z) && (My_Connections[Idx].options & CONN_ZIP) &&
1775                     (array_bytes(&My_Connections[Idx].rbuf) > 0)) {
1776                         /* The last command activated socket compression.
1777                          * Data that was read after that needs to be copied
1778                          * to the unzip buffer for decompression: */
1779                         if (!array_copy
1780                             (&My_Connections[Idx].zip.rbuf,
1781                              &My_Connections[Idx].rbuf)) {
1782                                 Conn_Close(Idx, NULL,
1783                                            "Can't allocate memory [Handle_Buffer]",
1784                                            true);
1785                                 return 0;
1786                         }
1787
1788                         array_trunc(&My_Connections[Idx].rbuf);
1789                         LogDebug
1790                             ("Moved already received data (%u bytes) to uncompression buffer.",
1791                              array_bytes(&My_Connections[Idx].zip.rbuf));
1792                 }
1793 #endif
1794         }
1795         return len_processed;
1796 } /* Handle_Buffer */
1797
1798
1799 /**
1800  * Check whether established connections are still alive or not.
1801  * If not, play PING-PONG first; and if that doesn't help either,
1802  * disconnect the respective peer.
1803  */
1804 static void
1805 Check_Connections(void)
1806 {
1807         CLIENT *c;
1808         CONN_ID i;
1809         char msg[64];
1810
1811         for (i = 0; i < Pool_Size; i++) {
1812                 if (My_Connections[i].sock < 0)
1813                         continue;
1814
1815                 c = Conn_GetClient(i);
1816                 if (c && ((Client_Type(c) == CLIENT_USER)
1817                           || (Client_Type(c) == CLIENT_SERVER)
1818                           || (Client_Type(c) == CLIENT_SERVICE))) {
1819                         /* connected User, Server or Service */
1820                         if (My_Connections[i].lastping >
1821                             My_Connections[i].lastdata) {
1822                                 /* We already sent a ping */
1823                                 if (My_Connections[i].lastping <
1824                                     time(NULL) - Conf_PongTimeout) {
1825                                         /* Timeout */
1826                                         LogDebug
1827                                             ("Connection %d: Ping timeout: %d seconds.",
1828                                              i, Conf_PongTimeout);
1829                                         snprintf(msg, sizeof(msg), "Ping timeout: %d seconds", Conf_PongTimeout);
1830                                         Conn_Close(i, NULL, msg, true);
1831                                 }
1832                         } else if (My_Connections[i].lastdata <
1833                                    time(NULL) - Conf_PingTimeout) {
1834                                 /* We need to send a PING ... */
1835                                 LogDebug("Connection %d: sending PING ...", i);
1836                                 My_Connections[i].lastping = time(NULL);
1837                                 Conn_WriteStr(i, "PING :%s",
1838                                               Client_ID(Client_ThisServer()));
1839                         }
1840                 } else {
1841                         /* The connection is not fully established yet, so
1842                          * we don't do the PING-PONG game here but instead
1843                          * disconnect the client after "a short time" if it's
1844                          * still not registered. */
1845
1846                         if (My_Connections[i].lastdata <
1847                             time(NULL) - Conf_PongTimeout) {
1848                                 LogDebug
1849                                     ("Unregistered connection %d timed out ...",
1850                                      i);
1851                                 Conn_Close(i, NULL, "Timeout", false);
1852                         }
1853                 }
1854         }
1855 } /* Check_Connections */
1856
1857
1858 /**
1859  * Check if further server links should be established.
1860  */
1861 static void
1862 Check_Servers(void)
1863 {
1864         int i, n;
1865         time_t time_now;
1866
1867         time_now = time(NULL);
1868
1869         /* Check all configured servers */
1870         for (i = 0; i < MAX_SERVERS; i++) {
1871                 if (Conf_Server[i].conn_id != NONE)
1872                         continue;       /* Already establishing or connected */
1873                 if (!Conf_Server[i].host[0] || !Conf_Server[i].port > 0)
1874                         continue;       /* No host and/or port configured */
1875                 if (Conf_Server[i].flags & CONF_SFLAG_DISABLED)
1876                         continue;       /* Disabled configuration entry */
1877                 if (Conf_Server[i].lasttry > (time_now - Conf_ConnectRetry))
1878                         continue;       /* We have to wait a little bit ... */
1879
1880                 /* Is there already a connection in this group? */
1881                 if (Conf_Server[i].group > NONE) {
1882                         for (n = 0; n < MAX_SERVERS; n++) {
1883                                 if (n == i)
1884                                         continue;
1885                                 if ((Conf_Server[n].conn_id != NONE) &&
1886                                     (Conf_Server[n].group == Conf_Server[i].group))
1887                                         break;
1888                         }
1889                         if (n < MAX_SERVERS)
1890                                 continue;
1891                 }
1892
1893                 /* Okay, try to connect now */
1894                 Log(LOG_NOTICE,
1895                     "Preparing to establish a new server link for \"%s\" ...",
1896                     Conf_Server[i].name);
1897                 Conf_Server[i].lasttry = time_now;
1898                 Conf_Server[i].conn_id = SERVER_WAIT;
1899                 assert(Proc_GetPipeFd(&Conf_Server[i].res_stat) < 0);
1900                 Resolve_Name(&Conf_Server[i].res_stat, Conf_Server[i].host,
1901                              cb_Connect_to_Server);
1902         }
1903 } /* Check_Servers */
1904
1905
1906 /**
1907  * Establish a new outgoing server connection.
1908  *
1909  * @param Server        Configuration index of the server.
1910  * @param dest          Destination IP address to connect to.
1911  */
1912 static void
1913 New_Server( int Server , ng_ipaddr_t *dest)
1914 {
1915         /* Establish new server link */
1916         char ip_str[NG_INET_ADDRSTRLEN];
1917         int af_dest, res, new_sock;
1918         CLIENT *c;
1919
1920         assert( Server > NONE );
1921
1922         if (!ng_ipaddr_tostr_r(dest, ip_str)) {
1923                 Log(LOG_WARNING, "New_Server: Could not convert IP to string");
1924                 return;
1925         }
1926
1927         af_dest = ng_ipaddr_af(dest);
1928         new_sock = socket(af_dest, SOCK_STREAM, 0);
1929
1930         Log(LOG_INFO,
1931             "Establishing connection for \"%s\" to \"%s:%d\" (%s), socket %d ...",
1932             Conf_Server[Server].name, Conf_Server[Server].host,
1933             Conf_Server[Server].port, ip_str, new_sock);
1934
1935         if (new_sock < 0) {
1936                 Log(LOG_CRIT, "Can't create socket (af %d): %s!",
1937                     af_dest, strerror(errno));
1938                 return;
1939         }
1940
1941         if (!Init_Socket(new_sock))
1942                 return;
1943
1944         /* is a bind address configured? */
1945         res = ng_ipaddr_af(&Conf_Server[Server].bind_addr);
1946         /* if yes, bind now. If it fails, warn and let connect() pick a source address */
1947         if (res && bind(new_sock, (struct sockaddr *) &Conf_Server[Server].bind_addr,
1948                                 ng_ipaddr_salen(&Conf_Server[Server].bind_addr)))
1949         {
1950                 ng_ipaddr_tostr_r(&Conf_Server[Server].bind_addr, ip_str);
1951                 Log(LOG_WARNING, "Can't bind socket to %s: %s!", ip_str, strerror(errno));
1952         }
1953         ng_ipaddr_setport(dest, Conf_Server[Server].port);
1954         res = connect(new_sock, (struct sockaddr *) dest, ng_ipaddr_salen(dest));
1955         if(( res != 0 ) && ( errno != EINPROGRESS )) {
1956                 Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
1957                 close( new_sock );
1958                 return;
1959         }
1960
1961         if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)new_sock)) {
1962                 Log(LOG_ALERT,
1963                     "Cannot allocate memory for server connection (socket %d)",
1964                     new_sock);
1965                 close( new_sock );
1966                 return;
1967         }
1968
1969         if (!io_event_create( new_sock, IO_WANTWRITE, cb_connserver)) {
1970                 Log(LOG_ALERT, "io_event_create(): could not add fd %d", strerror(errno));
1971                 close(new_sock);
1972                 return;
1973         }
1974
1975         My_Connections = array_start(&My_ConnArray);
1976
1977         assert(My_Connections[new_sock].sock <= 0);
1978
1979         Init_Conn_Struct(new_sock);
1980
1981         ng_ipaddr_tostr_r(dest, ip_str);
1982         c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWNSERVER, false);
1983         if (!c) {
1984                 Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
1985                 io_close(new_sock);
1986                 return;
1987         }
1988
1989         /* Conn_Close() decrements this counter again */
1990         Account_Connection();
1991         Client_SetIntroducer( c, c );
1992         Client_SetToken( c, TOKEN_OUTBOUND );
1993
1994         /* Register connection */
1995         Conf_Server[Server].conn_id = new_sock;
1996         My_Connections[new_sock].sock = new_sock;
1997         My_Connections[new_sock].addr = *dest;
1998         My_Connections[new_sock].client = c;
1999         strlcpy( My_Connections[new_sock].host, Conf_Server[Server].host,
2000                                 sizeof(My_Connections[new_sock].host ));
2001
2002 #ifdef SSL_SUPPORT
2003         if (Conf_Server[Server].SSLConnect && !ConnSSL_PrepareConnect( &My_Connections[new_sock],
2004                                                                 &Conf_Server[Server] ))
2005         {
2006                 Log(LOG_ALERT, "Could not initialize SSL for outgoing connection");
2007                 Conn_Close( new_sock, "Could not initialize SSL for outgoing connection", NULL, false );
2008                 Init_Conn_Struct( new_sock );
2009                 Conf_Server[Server].conn_id = NONE;
2010                 return;
2011         }
2012 #endif
2013         LogDebug("Registered new connection %d on socket %d (%ld in total).",
2014                  new_sock, My_Connections[new_sock].sock, NumConnections);
2015         Conn_OPTION_ADD( &My_Connections[new_sock], CONN_ISCONNECTING );
2016 } /* New_Server */
2017
2018
2019 /**
2020  * Initialize connection structure.
2021  *
2022  * @param Idx   Connection index.
2023  */
2024 static void
2025 Init_Conn_Struct(CONN_ID Idx)
2026 {
2027         time_t now = time(NULL);
2028
2029         memset(&My_Connections[Idx], 0, sizeof(CONNECTION));
2030         My_Connections[Idx].sock = -1;
2031         My_Connections[Idx].signon = now;
2032         My_Connections[Idx].lastdata = now;
2033         My_Connections[Idx].lastprivmsg = now;
2034         Proc_InitStruct(&My_Connections[Idx].proc_stat);
2035 } /* Init_Conn_Struct */
2036
2037
2038 /**
2039  * Initialize options of a new socket.
2040  *
2041  * For example, we try to set socket options SO_REUSEADDR and IPTOS_LOWDELAY.
2042  * The socket is automatically closed if a fatal error is encountered.
2043  *
2044  * @param Sock  Socket handle.
2045  * @returns false if socket was closed due to fatal error.
2046  */
2047 static bool
2048 Init_Socket( int Sock )
2049 {
2050         int value;
2051
2052         if (!io_setnonblock(Sock)) {
2053                 Log( LOG_CRIT, "Can't enable non-blocking mode for socket: %s!", strerror( errno ));
2054                 close( Sock );
2055                 return false;
2056         }
2057
2058         /* Don't block this port after socket shutdown */
2059         value = 1;
2060         if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &value, (socklen_t)sizeof( value )) != 0 )
2061         {
2062                 Log( LOG_ERR, "Can't set socket option SO_REUSEADDR: %s!", strerror( errno ));
2063                 /* ignore this error */
2064         }
2065
2066         /* Set type of service (TOS) */
2067 #if defined(IPPROTO_IP) && defined(IPTOS_LOWDELAY)
2068         value = IPTOS_LOWDELAY;
2069         if (setsockopt(Sock, IPPROTO_IP, IP_TOS, &value,
2070                        (socklen_t) sizeof(value))) {
2071                 LogDebug("Can't set socket option IP_TOS: %s!",
2072                          strerror(errno));
2073                 /* ignore this error */
2074         } else
2075                 LogDebug("IP_TOS on socket %d has been set to IPTOS_LOWDELAY.",
2076                          Sock);
2077 #endif
2078
2079         return true;
2080 } /* Init_Socket */
2081
2082
2083 /**
2084  * Read results of a resolver sub-process and try to initiate a new server
2085  * connection.
2086  *
2087  * @param fd            File descriptor of the pipe to the sub-process.
2088  * @param events        (ignored IO specification)
2089  */
2090 static void
2091 cb_Connect_to_Server(int fd, UNUSED short events)
2092 {
2093         /* Read result of resolver sub-process from pipe and start connection */
2094         int i;
2095         size_t len;
2096         ng_ipaddr_t dest_addrs[4];      /* we can handle at most 3; but we read up to
2097                                            four so we can log the 'more than we can handle'
2098                                            condition. First result is tried immediately, rest
2099                                            is saved for later if needed. */
2100
2101         LogDebug("Resolver: Got forward lookup callback on fd %d, events %d", fd, events);
2102
2103         for (i=0; i < MAX_SERVERS; i++) {
2104                   if (Proc_GetPipeFd(&Conf_Server[i].res_stat) == fd )
2105                           break;
2106         }
2107
2108         if( i >= MAX_SERVERS) {
2109                 /* Ops, no matching server found?! */
2110                 io_close( fd );
2111                 LogDebug("Resolver: Got Forward Lookup callback for unknown server!?");
2112                 return;
2113         }
2114
2115         /* Read result from pipe */
2116         len = Proc_Read(&Conf_Server[i].res_stat, dest_addrs, sizeof(dest_addrs));
2117         Proc_Close(&Conf_Server[i].res_stat);
2118         if (len == 0) {
2119                 /* Error resolving hostname: reset server structure */
2120                 Conf_Server[i].conn_id = NONE;
2121                 return;
2122         }
2123
2124         assert((len % sizeof(ng_ipaddr_t)) == 0);
2125
2126         LogDebug("Got result from resolver: %u structs (%u bytes).", len/sizeof(ng_ipaddr_t), len);
2127
2128         memset(&Conf_Server[i].dst_addr, 0, sizeof(Conf_Server[i].dst_addr));
2129         if (len > sizeof(ng_ipaddr_t)) {
2130                 /* more than one address for this hostname, remember them
2131                  * in case first address is unreachable/not available */
2132                 len -= sizeof(ng_ipaddr_t);
2133                 if (len > sizeof(Conf_Server[i].dst_addr)) {
2134                         len = sizeof(Conf_Server[i].dst_addr);
2135                         Log(LOG_NOTICE,
2136                                 "Notice: Resolver returned more IP Addresses for host than we can handle, additional addresses dropped.");
2137                 }
2138                 memcpy(&Conf_Server[i].dst_addr, &dest_addrs[1], len);
2139         }
2140         /* connect() */
2141         New_Server(i, dest_addrs);
2142 } /* cb_Read_Forward_Lookup */
2143
2144
2145 /**
2146  * Read results of a resolver sub-process from the pipe and update the
2147  * apropriate connection/client structure(s): hostname and/or IDENT user name.
2148  *
2149  * @param r_fd          File descriptor of the pipe to the sub-process.
2150  * @param events        (ignored IO specification)
2151  */
2152 static void
2153 cb_Read_Resolver_Result( int r_fd, UNUSED short events )
2154 {
2155         CLIENT *c;
2156         CONN_ID i;
2157         size_t len;
2158         char *identptr;
2159 #ifdef IDENTAUTH
2160         char readbuf[HOST_LEN + 2 + CLIENT_USER_LEN];
2161 #else
2162         char readbuf[HOST_LEN + 1];
2163 #endif
2164
2165         LogDebug("Resolver: Got callback on fd %d, events %d", r_fd, events );
2166         i = Conn_GetFromProc(r_fd);
2167         if (i == NONE) {
2168                 /* Ops, none found? Probably the connection has already
2169                  * been closed!? We'll ignore that ... */
2170                 io_close( r_fd );
2171                 LogDebug("Resolver: Got callback for unknown connection!?");
2172                 return;
2173         }
2174
2175         /* Read result from pipe */
2176         len = Proc_Read(&My_Connections[i].proc_stat, readbuf, sizeof readbuf -1);
2177         Proc_Close(&My_Connections[i].proc_stat);
2178         if (len == 0)
2179                 return;
2180
2181         readbuf[len] = '\0';
2182         identptr = strchr(readbuf, '\n');
2183         assert(identptr != NULL);
2184         if (!identptr) {
2185                 Log( LOG_CRIT, "Resolver: Got malformed result!");
2186                 return;
2187         }
2188
2189         *identptr = '\0';
2190         LogDebug("Got result from resolver: \"%s\" (%u bytes read).", readbuf, len);
2191         /* Okay, we got a complete result: this is a host name for outgoing
2192          * connections and a host name and IDENT user name (if enabled) for
2193          * incoming connections.*/
2194         assert ( My_Connections[i].sock >= 0 );
2195         /* Incoming connection. Search client ... */
2196         c = Conn_GetClient( i );
2197         assert( c != NULL );
2198
2199         /* Only update client information of unregistered clients.
2200          * Note: user commands (e. g. WEBIRC) are always read _after_ reading
2201          * the resolver results, so we don't have to worry to override settings
2202          * from these commands here. */
2203         if(Client_Type(c) == CLIENT_UNKNOWN) {
2204                 strlcpy(My_Connections[i].host, readbuf,
2205                         sizeof(My_Connections[i].host));
2206                 Client_SetHostname(c, readbuf);
2207                 if (Conf_NoticeAuth)
2208                         (void)Conn_WriteStr(i,
2209                                         "NOTICE AUTH :*** Found your hostname");
2210 #ifdef IDENTAUTH
2211                 ++identptr;
2212                 if (*identptr) {
2213                         Log(LOG_INFO, "IDENT lookup for connection %d: \"%s\".", i, identptr);
2214                         Client_SetUser(c, identptr, true);
2215                         if (Conf_NoticeAuth)
2216                                 (void)Conn_WriteStr(i,
2217                                         "NOTICE AUTH :*** Got ident response");
2218                 } else {
2219                         Log(LOG_INFO, "IDENT lookup for connection %d: no result.", i);
2220                         if (Conf_NoticeAuth && Conf_Ident)
2221                                 (void)Conn_WriteStr(i,
2222                                         "NOTICE AUTH :*** No ident response");
2223                 }
2224 #endif
2225         }
2226 #ifdef DEBUG
2227                 else Log( LOG_DEBUG, "Resolver: discarding result for already registered connection %d.", i );
2228 #endif
2229 } /* cb_Read_Resolver_Result */
2230
2231
2232 /**
2233  * Write a "simple" (error) message to a socket.
2234  *
2235  * The message is sent without using the connection write buffers, without
2236  * compression/encryption, and even without any error reporting. It is
2237  * designed for error messages of e.g. New_Connection().
2238  *
2239  * @param Sock  Socket handle.
2240  * @param Msg   Message string to send.
2241  */
2242 static void
2243 Simple_Message(int Sock, const char *Msg)
2244 {
2245         char buf[COMMAND_LEN];
2246         size_t len;
2247
2248         assert(Sock > NONE);
2249         assert(Msg != NULL);
2250
2251         strlcpy(buf, Msg, sizeof buf - 2);
2252         len = strlcat(buf, "\r\n", sizeof buf);
2253         if (write(Sock, buf, len) < 0) {
2254                 /* Because this function most probably got called to log
2255                  * an error message, any write error is ignored here to
2256                  * avoid an endless loop. But casting the result of write()
2257                  * to "void" doesn't satisfy the GNU C code attribute
2258                  * "warn_unused_result" which is used by some versions of
2259                  * glibc (e.g. 2.11.1), therefore this silly error
2260                  * "handling" code here :-( */
2261                 return;
2262         }
2263 } /* Simple_Error */
2264
2265
2266 /**
2267  * Get CLIENT structure that belongs to a local connection identified by its
2268  * index number. Each connection belongs to a client by definition, so it is
2269  * not required that the caller checks for NULL return values.
2270  *
2271  * @param Idx   Connection index number.
2272  * @returns     Pointer to CLIENT structure.
2273  */
2274 GLOBAL CLIENT *
2275 Conn_GetClient( CONN_ID Idx ) 
2276 {
2277         CONNECTION *c;
2278
2279         assert(Idx >= 0);
2280         c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
2281         assert(c != NULL);
2282         return c ? c->client : NULL;
2283 }
2284
2285 /**
2286  * Get PROC_STAT sub-process structure of a connection.
2287  *
2288  * @param Idx   Connection index number.
2289  * @returns     PROC_STAT structure.
2290  */
2291 GLOBAL PROC_STAT *
2292 Conn_GetProcStat(CONN_ID Idx)
2293 {
2294         CONNECTION *c;
2295
2296         assert(Idx >= 0);
2297         c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
2298         assert(c != NULL);
2299         return &c->proc_stat;
2300 } /* Conn_GetProcStat */
2301
2302
2303 /**
2304  * Get CONN_ID from file descriptor associated to a subprocess structure.
2305  *
2306  * @param fd    File descriptor.
2307  * @returns     CONN_ID or NONE (-1).
2308  */
2309 GLOBAL CONN_ID
2310 Conn_GetFromProc(int fd)
2311 {
2312         int i;
2313
2314         assert(fd > 0);
2315         for (i = 0; i < Pool_Size; i++) {
2316                 if ((My_Connections[i].sock != NONE)
2317                     && (Proc_GetPipeFd(&My_Connections[i].proc_stat) == fd))
2318                         return i;
2319         }
2320         return NONE;
2321 } /* Conn_GetFromProc */
2322
2323
2324 #ifndef STRICT_RFC
2325
2326 GLOBAL long
2327 Conn_GetAuthPing(CONN_ID Idx)
2328 {
2329         assert (Idx != NONE);
2330         return My_Connections[Idx].auth_ping;
2331 } /* Conn_GetAuthPing */
2332
2333 GLOBAL void
2334 Conn_SetAuthPing(CONN_ID Idx, long ID)
2335 {
2336         assert (Idx != NONE);
2337         My_Connections[Idx].auth_ping = ID;
2338 } /* Conn_SetAuthPing */
2339
2340 #endif
2341
2342
2343 #ifdef SSL_SUPPORT
2344
2345 /**
2346  * Get information about used SSL chiper.
2347  *
2348  * @param Idx   Connection index number.
2349  * @param buf   Buffer for returned information text.
2350  * @param len   Size of return buffer "buf".
2351  * @returns     true on success, false otherwise.
2352  */
2353 GLOBAL bool
2354 Conn_GetCipherInfo(CONN_ID Idx, char *buf, size_t len)
2355 {
2356         if (Idx < 0)
2357                 return false;
2358         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2359         return ConnSSL_GetCipherInfo(&My_Connections[Idx], buf, len);
2360 }
2361
2362
2363 /**
2364  * Check if a connection is SSL-enabled or not.
2365  *
2366  * @param Idx   Connection index number.
2367  * @return      true if connection is SSL-enabled, false otherwise.
2368  */
2369 GLOBAL bool
2370 Conn_UsesSSL(CONN_ID Idx)
2371 {
2372         if (Idx < 0)
2373                 return false;
2374         assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
2375         return Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL);
2376 }
2377
2378 #endif
2379
2380
2381 #ifdef DEBUG
2382
2383 /**
2384  * Dump internal state of the "connection module".
2385  */
2386 GLOBAL void
2387 Conn_DebugDump(void)
2388 {
2389         int i;
2390
2391         Log(LOG_DEBUG, "Connection status:");
2392         for (i = 0; i < Pool_Size; i++) {
2393                 if (My_Connections[i].sock == NONE)
2394                         continue;
2395                 Log(LOG_DEBUG,
2396                     " - %d: host=%s, lastdata=%ld, lastping=%ld, delaytime=%ld, flag=%d, options=%d, bps=%d, client=%s",
2397                     My_Connections[i].sock, My_Connections[i].host,
2398                     My_Connections[i].lastdata, My_Connections[i].lastping,
2399                     My_Connections[i].delaytime, My_Connections[i].flag,
2400                     My_Connections[i].options, My_Connections[i].bps,
2401                     My_Connections[i].client ? Client_ID(My_Connections[i].client) : "-");
2402         }
2403 } /* Conn_DumpClients */
2404
2405 #endif
2406
2407
2408 /* -eof- */