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