/*
* ngIRCd -- The Next Generation IRC Daemon
- * Copyright (c)2001-2007 Alexander Barton (alex@barton.de)
+ * Copyright (c)2001-2010 Alexander Barton <alex@barton.de>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#include "imp.h"
#include <assert.h>
#ifdef PROTOTYPES
-# include <stdarg.h>
+# include <stdarg.h>
#else
-# include <varargs.h>
+# include <varargs.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#ifdef HAVE_NETINET_IP_H
+# ifdef HAVE_NETINET_IN_SYSTM_H
+# include <netinet/in_systm.h>
+# endif
# include <netinet/ip.h>
#endif
#include "array.h"
#include "defines.h"
-#include "resolve.h"
#include "exp.h"
#include "conn.h"
#include "imp.h"
#include "ngircd.h"
+#include "array.h"
#include "client.h"
#include "conf.h"
#include "conn-ssl.h"
#include "conn-zip.h"
#include "conn-func.h"
#include "log.h"
+#include "ng_ipaddr.h"
#include "parse.h"
+#include "resolve.h"
#include "tool.h"
#ifdef ZEROCONF
#define MAX_COMMANDS 3
#define MAX_COMMANDS_SERVER 10
+#define MAX_COMMANDS_SERVICE MAX_COMMANDS_SERVER
static bool Handle_Write PARAMS(( CONN_ID Idx ));
static void New_Server PARAMS(( int Server, ng_ipaddr_t *dest ));
static void Simple_Message PARAMS(( int Sock, const char *Msg ));
static int NewListener PARAMS(( const char *listen_addr, UINT16 Port ));
+static void Account_Connection PARAMS((void));
+
static array My_Listeners;
static array My_ConnArray;
-static size_t NumConnections;
+static size_t NumConnections, NumConnectionsMax, NumConnectionsAccepted;
#ifdef TCPWRAP
int allow_severity = LOG_INFO;
static void cb_connserver_login_ssl PARAMS((int sock, short what));
static void cb_clientserver_ssl PARAMS((int sock, short what));
#endif
-static void cb_Read_Resolver_Result PARAMS(( int sock, UNUSED short what));
-static void cb_Connect_to_Server PARAMS(( int sock, UNUSED short what));
+static void cb_Read_Resolver_Result PARAMS((int sock, UNUSED short what));
+static void cb_Connect_to_Server PARAMS((int sock, UNUSED short what));
static void cb_clientserver PARAMS((int sock, short what));
+
+/**
+ * IO callback for listening sockets: handle new connections. This callback
+ * gets called when a new non-SSL connection should be accepted.
+ * @param sock Socket descriptor
+ * @param irrelevant (ignored IO specification)
+ */
static void
cb_listen(int sock, short irrelevant)
{
(void) irrelevant;
- if (New_Connection( sock ) >= 0)
- NumConnections++;
- LogDebug("Total number of connections now %ld.", NumConnections);
+ (void) New_Connection(sock);
}
#ifdef SSL_SUPPORT
+/**
+ * IO callback for listening SSL sockets: handle new connections. This callback
+ * gets called when a new SSL-enabled connection should be accepted.
+ * @param sock Socket descriptor
+ * @param irrelevant (ignored IO specification)
+ */
static void
cb_listen_ssl(int sock, short irrelevant)
{
int fd;
+
(void) irrelevant;
fd = New_Connection(sock);
if (fd < 0)
return;
-
- NumConnections++;
- LogDebug("Total number of connections now %ld.", NumConnections);
io_event_setcb(My_Connections[fd].sock, cb_clientserver_ssl);
}
#endif
+/**
+ * IO callback for new outgoing non-SSL server connections.
+ * @param sock Socket descriptor
+ * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
+ */
static void
cb_connserver(int sock, UNUSED short what)
{
- int res, err;
+ int res, err, server;
socklen_t sock_len;
CONN_ID idx = Socket2Index( sock );
+
if (idx <= NONE) {
LogDebug("cb_connserver wants to write on unknown socket?!");
io_close(sock);
return;
}
- assert( what & IO_WANTWRITE);
+ assert(what & IO_WANTWRITE);
+
+ /* Make sure that the server is still configured; it could have been
+ * removed in the meantime! */
+ server = Conf_GetServer(idx);
+ if (server < 0) {
+ Log(LOG_ERR, "Connection on socket %d to \"%s\" aborted!",
+ sock, My_Connections[idx].host);
+ Conn_Close(idx, "Connection aborted!", NULL, false);
+ return;
+ }
/* connect() finished, get result. */
- sock_len = sizeof( err );
- res = getsockopt( My_Connections[idx].sock, SOL_SOCKET, SO_ERROR, &err, &sock_len );
- assert( sock_len == sizeof( err ));
+ sock_len = (socklen_t)sizeof(err);
+ res = getsockopt(My_Connections[idx].sock, SOL_SOCKET, SO_ERROR,
+ &err, &sock_len );
+ assert(sock_len == sizeof(err));
/* Error while connecting? */
if ((res != 0) || (err != 0)) {
else
Log(LOG_CRIT,
"Can't connect socket to \"%s:%d\" (connection %d): %s!",
- My_Connections[idx].host,
- Conf_Server[Conf_GetServer(idx)].port,
+ My_Connections[idx].host, Conf_Server[server].port,
idx, strerror(err));
- res = Conf_GetServer(idx);
- assert(res >= 0);
-
Conn_Close(idx, "Can't connect!", NULL, false);
- if (res < 0)
- return;
- if (ng_ipaddr_af(&Conf_Server[res].dst_addr[0])) {
+ if (ng_ipaddr_af(&Conf_Server[server].dst_addr[0])) {
/* more addresses to try... */
- New_Server(res, &Conf_Server[res].dst_addr[0]);
- /* connection to dst_addr[0] in progress, remove this address... */
- Conf_Server[res].dst_addr[0] = Conf_Server[res].dst_addr[1];
-
- memset(&Conf_Server[res].dst_addr[1], 0, sizeof(&Conf_Server[res].dst_addr[1]));
+ New_Server(server, &Conf_Server[server].dst_addr[0]);
+ /* connection to dst_addr[0] is now in progress, so
+ * remove this address... */
+ Conf_Server[server].dst_addr[0] =
+ Conf_Server[server].dst_addr[1];
+ memset(&Conf_Server[server].dst_addr[1], 0,
+ sizeof(Conf_Server[server].dst_addr[1]));
}
return;
}
- res = Conf_GetServer(idx);
- assert(res >= 0);
- if (res >= 0) /* connect succeeded, remove all additional addresses */
- memset(&Conf_Server[res].dst_addr, 0, sizeof(&Conf_Server[res].dst_addr));
+ /* connect() succeeded, remove all additional addresses */
+ memset(&Conf_Server[server].dst_addr, 0,
+ sizeof(Conf_Server[server].dst_addr));
+
Conn_OPTION_DEL( &My_Connections[idx], CONN_ISCONNECTING );
#ifdef SSL_SUPPORT
if ( Conn_OPTION_ISSET( &My_Connections[idx], CONN_SSL_CONNECT )) {
}
+/**
+ * Login to a remote server.
+ * @param idx Connection index
+ */
static void
server_login(CONN_ID idx)
{
#ifdef SSL_SUPPORT
+/**
+ * IO callback for new outgoing SSL-enabled server connections.
+ * @param sock Socket descriptor
+ * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
+ */
static void
cb_connserver_login_ssl(int sock, short unused)
{
#endif
+/**
+ * IO callback for established non-SSL client and server connections.
+ * @param sock Socket descriptor
+ * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
+ */
static void
cb_clientserver(int sock, short what)
{
return;
}
#ifdef SSL_SUPPORT
- if (what & IO_WANTREAD || (Conn_OPTION_ISSET(&My_Connections[idx], CONN_SSL_WANT_WRITE)))
- Read_Request( idx ); /* if TLS layer needs to write additional data, call Read_Request instead so SSL/TLS can continue */
+ if (what & IO_WANTREAD
+ || (Conn_OPTION_ISSET(&My_Connections[idx], CONN_SSL_WANT_WRITE))) {
+ /* if TLS layer needs to write additional data, call
+ * Read_Request() instead so that SSL/TLS can continue */
+ Read_Request(idx);
+ }
#else
if (what & IO_WANTREAD)
- Read_Request( idx );
+ Read_Request(idx);
#endif
if (what & IO_WANTWRITE)
- Handle_Write( idx );
+ Handle_Write(idx);
}
#ifdef SSL_SUPPORT
+/**
+ * IO callback for established SSL-enabled client and server connections.
+ * @param sock Socket descriptor
+ * @param what IO specification (IO_WANTREAD/IO_WANTWRITE/...)
+ */
static void
cb_clientserver_ssl(int sock, short what)
{
}
switch (ConnSSL_Accept(&My_Connections[idx])) {
- case 1: break; /* OK */
- case 0: return; /* EAGAIN: this callback will be invoked again by the io layer */
- default:
- Conn_Close( idx, "Socket closed!", "SSL accept error", false );
- return;
+ case 1:
+ break; /* OK */
+ case 0:
+ return; /* EAGAIN: callback will be invoked again by IO layer */
+ default:
+ Conn_Close(idx, "SSL accept error, closing socket", "SSL accept error", false);
+ return;
}
if (what & IO_WANTREAD)
Read_Request(idx);
#endif
+/**
+ * Initialite connecion module.
+ */
GLOBAL void
Conn_Init( void )
{
Pool_Size = Conf_MaxConnections;
if (!array_alloc(&My_ConnArray, sizeof(CONNECTION), (size_t)Pool_Size)) {
- Log( LOG_EMERG, "Can't allocate memory! [Conn_Init]" );
- exit( 1 );
+ Log(LOG_EMERG, "Can't allocate memory! [Conn_Init]");
+ exit(1);
}
/* FIXME: My_Connetions/Pool_Size is needed by other parts of the
My_Connections = (CONNECTION*) array_start(&My_ConnArray);
LogDebug("Allocated connection pool for %d items (%ld bytes).",
- array_length(&My_ConnArray, sizeof( CONNECTION )), array_bytes(&My_ConnArray));
+ array_length(&My_ConnArray, sizeof(CONNECTION)),
+ array_bytes(&My_ConnArray));
- assert( array_length(&My_ConnArray, sizeof( CONNECTION )) >= (size_t) Pool_Size);
+ assert(array_length(&My_ConnArray, sizeof(CONNECTION)) >= (size_t)Pool_Size);
array_free( &My_Listeners );
- /* Connection-Struktur initialisieren */
- for( i = 0; i < Pool_Size; i++ ) Init_Conn_Struct( i );
-
- /* Global write counter */
- WCounter = 0;
+ for (i = 0; i < Pool_Size; i++)
+ Init_Conn_Struct(i);
} /* Conn_Init */
+/**
+ * Clean up connection module.
+ */
GLOBAL void
Conn_Exit( void )
{
} /* Conn_Exit */
+/**
+ * Close all sockets (file descriptors) of open connections.
+ * This is useful in forked child processes, for example, to make sure that
+ * they don't hold connections open that the main process wants to close.
+ */
+GLOBAL void
+Conn_CloseAllSockets(void)
+{
+ CONN_ID idx;
+
+ for(idx = 0; idx < Pool_Size; idx++) {
+ if(My_Connections[idx].sock > NONE)
+ close(My_Connections[idx].sock);
+ }
+}
+
+
static unsigned int
ports_initlisteners(array *a, const char *listen_addr, void (*func)(int,short))
{
}
+/**
+ * Initialize all listening sockets.
+ * @return Number of created listening sockets
+ */
GLOBAL unsigned int
Conn_InitListeners( void )
{
unsigned int created = 0;
char *copy, *listen_addr;
- if (!io_library_init(CONNECTION_POOL)) {
- Log(LOG_EMERG, "Cannot initialize IO routines: %s", strerror(errno));
- return -1;
- }
-
assert(Conf_ListenAddress);
/* can't use Conf_ListenAddress directly, see below */
listen_addr = strtok(NULL, ",");
}
- /*
- * can't free() Conf_ListenAddress here. On /REHASH, if the config file
+ /* Can't free() Conf_ListenAddress here: on REHASH, if the config file
* cannot be re-loaded, we'd end up with a NULL Conf_ListenAddress.
* Instead, free() takes place in conf.c, before the config file
- * is being parsed.
- */
+ * is being parsed. */
free(copy);
+
return created;
} /* Conn_InitListeners */
if (af != AF_INET6)
return;
- if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)))
+ if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, (socklen_t)sizeof(on)))
Log(LOG_ERR, "Could not set IPV6_V6ONLY: %s", strerror(errno));
#else
(void)af;
return sock;
} /* NewListener */
+
#ifdef SSL_SUPPORT
/*
* SSL/TLS connections require extra treatment:
}
#else
static inline bool
-SSL_WantRead(UNUSED const CONNECTION *c) { return false; }
+SSL_WantRead(UNUSED const CONNECTION *c)
+{ return false; }
static inline bool
-SSL_WantWrite(UNUSED const CONNECTION *c) { return false; }
+SSL_WantWrite(UNUSED const CONNECTION *c)
+{ return false; }
#endif
Rendezvous_Handler();
#endif
- /* Should the configuration be reloaded? */
- if (NGIRCd_SignalRehash)
- NGIRCd_Rehash();
-
/* Check configured servers and established links */
Check_Servers();
Check_Connections();
if (SSL_WantWrite(&My_Connections[i]))
continue; /* TLS/SSL layer needs to write data; deal with this first */
#endif
- if (Resolve_INPROGRESS(&My_Connections[i].res_stat)) {
- /* Wait for completion of resolver sub-process ... */
+ if (Proc_InProgress(&My_Connections[i].proc_stat)) {
+ /* Wait for completion of forked subprocess
+ * and ignore the socket in the meantime ... */
io_event_del(My_Connections[i].sock,
IO_WANTREAD);
continue;
IO_WANTREAD);
continue;
}
+
io_event_add(My_Connections[i].sock, IO_WANTREAD);
}
*/
#ifdef PROTOTYPES
GLOBAL bool
-Conn_WriteStr( CONN_ID Idx, char *Format, ... )
+Conn_WriteStr(CONN_ID Idx, const char *Format, ...)
#else
GLOBAL bool
-Conn_WriteStr( Idx, Format, va_alist )
+Conn_WriteStr(Idx, Format, va_alist)
CONN_ID Idx;
-char *Format;
+const char *Format;
va_dcl
#endif
{
in_k, out_k);
}
- /* cancel running resolver */
- if (Resolve_INPROGRESS(&My_Connections[Idx].res_stat))
- Resolve_Shutdown(&My_Connections[Idx].res_stat);
-
/* Servers: Modify time of next connect attempt? */
Conf_UnsetServer( Idx );
} /* Conn_Close */
-GLOBAL void
-Conn_SyncServerStruct( void )
+GLOBAL long
+Conn_Count(void)
{
- /* Synchronize server structures (connection IDs):
- * connections <-> configuration */
+ return NumConnections;
+} /* Conn_Count */
+
+
+GLOBAL long
+Conn_CountMax(void)
+{
+ return NumConnectionsMax;
+} /* Conn_CountMax */
+
+
+GLOBAL long
+Conn_CountAccepted(void)
+{
+ return NumConnectionsAccepted;
+} /* Conn_CountAccepted */
+
+/**
+ * Synchronize established connections and configured server structures
+ * after a configuration update and store the correct connection IDs, if any.
+ */
+GLOBAL void
+Conn_SyncServerStruct(void)
+{
CLIENT *client;
CONN_ID i;
int c;
- for( i = 0; i < Pool_Size; i++ ) {
- /* Established connection? */
- if (My_Connections[i].sock < 0)
+ for (i = 0; i < Pool_Size; i++) {
+ if (My_Connections[i].sock == NONE)
continue;
- /* Server connection? */
- client = Conn_GetClient( i );
- if(( ! client ) || ( Client_Type( client ) != CLIENT_SERVER )) continue;
+ /* Server link? */
+ client = Conn_GetClient(i);
+ if (!client || Client_Type(client) != CLIENT_SERVER)
+ continue;
- for( c = 0; c < MAX_SERVERS; c++ )
- {
+ for (c = 0; c < MAX_SERVERS; c++) {
/* Configured server? */
- if( ! Conf_Server[c].host[0] ) continue;
+ if (!Conf_Server[c].host[0])
+ continue;
- /* Duplicate? */
- if( strcmp( Conf_Server[c].name, Client_ID( client )) == 0 )
+ if (strcasecmp(Conf_Server[c].name, Client_ID(client)) == 0)
Conf_Server[c].conn_id = i;
}
}
} /* Count_Connections */
+/**
+ * Initialize new client connection on a listening socket.
+ * @param Sock Listening socket descriptor
+ * @return Accepted socket descriptor or -1 on error
+ */
static int
-New_Connection( int Sock )
+New_Connection(int Sock)
{
- /* Neue Client-Verbindung von Listen-Socket annehmen und
- * CLIENT-Struktur anlegen. */
-
#ifdef TCPWRAP
struct request_info req;
#endif
CLIENT *c;
long cnt;
- assert( Sock > NONE );
- /* Connection auf Listen-Socket annehmen */
- new_sock_len = (int)sizeof(new_addr);
+ assert(Sock > NONE);
+ new_sock_len = (int)sizeof(new_addr);
new_sock = accept(Sock, (struct sockaddr *)&new_addr,
(socklen_t *)&new_sock_len);
if (new_sock < 0) {
Log(LOG_CRIT, "Can't accept connection: %s!", strerror(errno));
return -1;
}
+ NumConnectionsAccepted++;
if (!ng_ipaddr_tostr_r(&new_addr, ip_str)) {
Log(LOG_CRIT, "fd %d: Can't convert IP address!", new_sock);
#ifdef TCPWRAP
/* Validate socket using TCP Wrappers */
- request_init( &req, RQ_DAEMON, PACKAGE_NAME, RQ_FILE, new_sock, RQ_CLIENT_SIN, &new_addr, NULL );
+ request_init(&req, RQ_DAEMON, PACKAGE_NAME, RQ_FILE, new_sock,
+ RQ_CLIENT_SIN, &new_addr, NULL);
fromhost(&req);
if (!hosts_access(&req)) {
- Log (deny_severity, "Refused connection from %s (by TCP Wrappers)!", ip_str);
- Simple_Message( new_sock, "ERROR :Connection refused" );
- close( new_sock );
+ Log(deny_severity,
+ "Refused connection from %s (by TCP Wrappers)!", ip_str);
+ Simple_Message(new_sock, "ERROR :Connection refused");
+ close(new_sock);
return -1;
}
#endif
- /* Socket initialisieren */
- if (!Init_Socket( new_sock ))
+ if (!Init_Socket(new_sock))
return -1;
+ /* Check global connection limit */
+ if ((Conf_MaxConnections > 0) &&
+ (NumConnections >= (size_t) Conf_MaxConnections)) {
+ Log(LOG_ALERT, "Can't accept connection: limit (%d) reached!",
+ Conf_MaxConnections);
+ Simple_Message(new_sock, "ERROR :Connection limit reached");
+ close(new_sock);
+ return -1;
+ }
+
/* Check IP-based connection limit */
cnt = Count_Connections(&new_addr);
if ((Conf_MaxConnectionsIP > 0) && (cnt >= Conf_MaxConnectionsIP)) {
/* Access denied, too many connections from this IP address! */
- Log( LOG_ERR, "Refused connection from %s: too may connections (%ld) from this IP address!", ip_str, cnt);
- Simple_Message( new_sock, "ERROR :Connection refused, too many connections from your IP address!" );
- close( new_sock );
- return -1;
- }
-
- if ((Conf_MaxConnections > 0) &&
- (NumConnections >= (size_t) Conf_MaxConnections))
- {
- Log( LOG_ALERT, "Can't accept connection: limit (%d) reached!", Conf_MaxConnections);
- Simple_Message( new_sock, "ERROR :Connection limit reached" );
- close( new_sock );
+ Log(LOG_ERR,
+ "Refused connection from %s: too may connections (%ld) from this IP address!",
+ ip_str, cnt);
+ Simple_Message(new_sock,
+ "ERROR :Connection refused, too many connections from your IP address!");
+ close(new_sock);
return -1;
}
- if( new_sock >= Pool_Size ) {
+ if (new_sock >= Pool_Size) {
if (!array_alloc(&My_ConnArray, sizeof(CONNECTION),
- (size_t)new_sock)) {
- Log( LOG_EMERG, "Can't allocate memory! [New_Connection]" );
- Simple_Message( new_sock, "ERROR: Internal error" );
- close( new_sock );
+ (size_t) new_sock)) {
+ Log(LOG_EMERG,
+ "Can't allocate memory! [New_Connection]");
+ Simple_Message(new_sock, "ERROR: Internal error");
+ close(new_sock);
return -1;
}
LogDebug("Bumped connection pool to %ld items (internal: %ld items, %ld bytes)",
- new_sock, array_length(&My_ConnArray, sizeof(CONNECTION)), array_bytes(&My_ConnArray));
+ new_sock, array_length(&My_ConnArray,
+ sizeof(CONNECTION)), array_bytes(&My_ConnArray));
/* Adjust pointer to new block */
My_Connections = array_start(&My_ConnArray);
}
/* register callback */
- if (!io_event_create( new_sock, IO_WANTREAD, cb_clientserver)) {
- Log(LOG_ALERT, "Can't accept connection: io_event_create failed!");
+ if (!io_event_create(new_sock, IO_WANTREAD, cb_clientserver)) {
+ Log(LOG_ALERT,
+ "Can't accept connection: io_event_create failed!");
Simple_Message(new_sock, "ERROR :Internal error");
close(new_sock);
return -1;
}
- c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWN, false );
- if( ! c ) {
- Log(LOG_ALERT, "Can't accept connection: can't create client structure!");
+ c = Client_NewLocal(new_sock, ip_str, CLIENT_UNKNOWN, false);
+ if (!c) {
+ Log(LOG_ALERT,
+ "Can't accept connection: can't create client structure!");
Simple_Message(new_sock, "ERROR :Internal error");
io_close(new_sock);
return -1;
}
- Init_Conn_Struct( new_sock );
+ Init_Conn_Struct(new_sock);
My_Connections[new_sock].sock = new_sock;
My_Connections[new_sock].addr = new_addr;
My_Connections[new_sock].client = c;
identsock = new_sock;
#ifdef IDENTAUTH
- if (Conf_NoIdent)
+ if (!Conf_Ident)
identsock = -1;
#endif
- if (!Conf_NoDNS)
- Resolve_Addr(&My_Connections[new_sock].res_stat, &new_addr,
+ if (Conf_DNS)
+ Resolve_Addr(&My_Connections[new_sock].proc_stat, &new_addr,
identsock, cb_Read_Resolver_Result);
- Conn_SetPenalty(new_sock, 4);
+
+ Account_Connection();
return new_sock;
} /* New_Connection */
+static void
+Account_Connection(void)
+{
+ NumConnections++;
+ if (NumConnections > NumConnectionsMax)
+ NumConnectionsMax = NumConnections;
+ LogDebug("Total number of connections now %lu (max %lu).",
+ NumConnections, NumConnectionsMax);
+} /* Account_Connection */
+
+
static CONN_ID
Socket2Index( int Sock )
{
* registered as a user, server or service connection. Don't update
* otherwise, so users have at least Conf_PongTimeout seconds time to
* register with the IRC server -- see Check_Connections().
- * Set "lastping", too, so we can handle time shifts backwards ... */
+ * Update "lastping", too, if time shifted backwards ... */
c = Conn_GetClient(Idx);
if (c && (Client_Type(c) == CLIENT_USER
|| Client_Type(c) == CLIENT_SERVER
My_Connections[Idx].bps = 0;
My_Connections[Idx].lastdata = t;
- My_Connections[Idx].lastping = My_Connections[Idx].lastdata;
+ if (My_Connections[Idx].lastping > t)
+ My_Connections[Idx].lastping = t;
}
/* Look at the data in the (read-) buffer of this connection */
My_Connections[Idx].bps += Handle_Buffer(Idx);
if (Client_Type(c) != CLIENT_SERVER
+ && Client_Type(c) != CLIENT_UNKNOWNSERVER
+ && Client_Type(c) != CLIENT_SERVICE
&& My_Connections[Idx].bps >= maxbps) {
LogDebug("Throttling connection %d: BPS exceeded! (%u >= %u)",
Idx, My_Connections[Idx].bps, maxbps);
/**
* Handle all data in the connection read-buffer.
* Data is processed until no complete command is left in the read buffer,
- * or MAX_COMMANDS[_SERVER] commands were processed.
+ * or MAX_COMMANDS[_SERVER|_SERVICE] commands were processed.
* When a fatal error occurs, the connection is shut down.
* @param Idx Index of the connection.
* @return number of bytes processed.
/* Servers do get special command limits, so they can process
* all the messages that are required while peering. */
- if (Client_Type(c) == CLIENT_SERVER)
- maxcmd = MAX_COMMANDS_SERVER;
+ switch (Client_Type(c)) {
+ case CLIENT_SERVER:
+ maxcmd = MAX_COMMANDS_SERVER; break;
+ case CLIENT_SERVICE:
+ maxcmd = MAX_COMMANDS_SERVICE; break;
+ }
starttime = time(NULL);
for (i=0; i < maxcmd; i++) {
return 0;
}
- len_processed += len;
+ len_processed += (unsigned int)len;
if (len <= delta) {
/* Request is empty (only '\r\n', '\r' or '\n');
* delta is 2 ('\r\n') or 1 ('\r' or '\n'), see above */
} /* Handle_Buffer */
+/**
+ * Check whether established connections are still alive or not.
+ * If not, play PING-PONG first; and if that doesn't help either,
+ * disconnect the respective peer.
+ */
static void
Check_Connections(void)
{
- /* check if connections are alive. if not, play PING-PONG first.
- * if this doesn't help either, disconnect client. */
CLIENT *c;
CONN_ID i;
char msg[64];
} /* Check_Connections */
+/**
+ * Check if further server links should be established.
+ */
static void
-Check_Servers( void )
+Check_Servers(void)
{
- /* Check if we can establish further server links */
-
int i, n;
time_t time_now;
+ time_now = time(NULL);
+
/* Check all configured servers */
- for( i = 0; i < MAX_SERVERS; i++ ) {
- /* Valid outgoing server which isn't already connected or disabled? */
- if(( ! Conf_Server[i].host[0] ) || ( ! Conf_Server[i].port > 0 ) ||
- ( Conf_Server[i].conn_id > NONE ) || ( Conf_Server[i].flags & CONF_SFLAG_DISABLED ))
- continue;
+ for (i = 0; i < MAX_SERVERS; i++) {
+ if (Conf_Server[i].conn_id != NONE)
+ continue; /* Already establishing or connected */
+ if (!Conf_Server[i].host[0] || !Conf_Server[i].port > 0)
+ continue; /* No host and/or port configured */
+ if (Conf_Server[i].flags & CONF_SFLAG_DISABLED)
+ continue; /* Disabled configuration entry */
+ if (Conf_Server[i].lasttry > (time_now - Conf_ConnectRetry))
+ continue; /* We have to wait a little bit ... */
/* Is there already a connection in this group? */
- if( Conf_Server[i].group > NONE ) {
+ if (Conf_Server[i].group > NONE) {
for (n = 0; n < MAX_SERVERS; n++) {
- if (n == i) continue;
+ if (n == i)
+ continue;
if ((Conf_Server[n].conn_id != NONE) &&
- (Conf_Server[n].group == Conf_Server[i].group))
- break;
+ (Conf_Server[n].group == Conf_Server[i].group))
+ break;
}
- if (n < MAX_SERVERS) continue;
+ if (n < MAX_SERVERS)
+ continue;
}
- /* Check last connect attempt? */
- time_now = time(NULL);
- if( Conf_Server[i].lasttry > (time_now - Conf_ConnectRetry))
- continue;
-
/* Okay, try to connect now */
+ Log(LOG_NOTICE,
+ "Preparing to establish a new server link for \"%s\" ...",
+ Conf_Server[i].name);
Conf_Server[i].lasttry = time_now;
Conf_Server[i].conn_id = SERVER_WAIT;
- assert(Resolve_Getfd(&Conf_Server[i].res_stat) < 0);
- Resolve_Name(&Conf_Server[i].res_stat, Conf_Server[i].host, cb_Connect_to_Server);
+ assert(Proc_GetPipeFd(&Conf_Server[i].res_stat) < 0);
+ Resolve_Name(&Conf_Server[i].res_stat, Conf_Server[i].host,
+ cb_Connect_to_Server);
}
} /* Check_Servers */
return;
}
- Log( LOG_INFO, "Establishing connection to \"%s\", %s, port %d ... ",
- Conf_Server[Server].host, ip_str, Conf_Server[Server].port );
+ Log(LOG_INFO, "Establishing connection for \"%s\" to \"%s\" (%s) port %d ... ",
+ Conf_Server[Server].name, Conf_Server[Server].host, ip_str,
+ Conf_Server[Server].port);
af_dest = ng_ipaddr_af(dest);
new_sock = socket(af_dest, SOCK_STREAM, 0);
}
/* Conn_Close() decrements this counter again */
- NumConnections++;
+ Account_Connection();
Client_SetIntroducer( c, c );
Client_SetToken( c, TOKEN_OUTBOUND );
My_Connections[Idx].signon = now;
My_Connections[Idx].lastdata = now;
My_Connections[Idx].lastprivmsg = now;
- Resolve_Init(&My_Connections[Idx].res_stat);
+ Proc_InitStruct(&My_Connections[Idx].proc_stat);
} /* Init_Conn_Struct */
}
/* Set type of service (TOS) */
-#if defined(IP_TOS) && defined(IPTOS_LOWDELAY)
+#if defined(IPPROTO_IP) && defined(IPTOS_LOWDELAY)
value = IPTOS_LOWDELAY;
- LogDebug("Setting option IP_TOS on socket %d to IPTOS_LOWDELAY (%d).", Sock, value );
- if( setsockopt( Sock, SOL_IP, IP_TOS, &value, (socklen_t)sizeof( value )) != 0 )
- {
- Log( LOG_ERR, "Can't set socket option IP_TOS: %s!", strerror( errno ));
+ LogDebug("Setting IP_TOS on socket %d to IPTOS_LOWDELAY.", Sock);
+ if (setsockopt(Sock, IPPROTO_IP, IP_TOS, &value,
+ (socklen_t) sizeof(value))) {
+ LogDebug("Can't set socket option IP_TOS: %s!",
+ strerror(errno));
/* ignore this error */
}
#endif
} /* Init_Socket */
-
static void
cb_Connect_to_Server(int fd, UNUSED short events)
{
size_t len;
ng_ipaddr_t dest_addrs[4]; /* we can handle at most 3; but we read up to
four so we can log the 'more than we can handle'
- condition */
+ condition. First result is tried immediately, rest
+ is saved for later if needed. */
LogDebug("Resolver: Got forward lookup callback on fd %d, events %d", fd, events);
for (i=0; i < MAX_SERVERS; i++) {
- if (Resolve_Getfd(&Conf_Server[i].res_stat) == fd )
+ if (Proc_GetPipeFd(&Conf_Server[i].res_stat) == fd )
break;
}
}
/* Read result from pipe */
- len = Resolve_Read(&Conf_Server[i].res_stat, dest_addrs, sizeof(dest_addrs));
- if (len == 0)
+ len = Proc_Read(&Conf_Server[i].res_stat, dest_addrs, sizeof(dest_addrs));
+ if (len == 0) {
+ /* Error resolving hostname: reset server structure */
+ Conf_Server[i].conn_id = NONE;
return;
+ }
assert((len % sizeof(ng_ipaddr_t)) == 0);
LogDebug("Got result from resolver: %u structs (%u bytes).", len/sizeof(ng_ipaddr_t), len);
- memset(&Conf_Server[i].dst_addr, 0, sizeof(&Conf_Server[i].dst_addr));
+ memset(&Conf_Server[i].dst_addr, 0, sizeof(Conf_Server[i].dst_addr));
if (len > sizeof(ng_ipaddr_t)) {
/* more than one address for this hostname, remember them
* in case first address is unreachable/not available */
len -= sizeof(ng_ipaddr_t);
- if (len > sizeof(&Conf_Server[i].dst_addr)) {
- len = sizeof(&Conf_Server[i].dst_addr);
+ if (len > sizeof(Conf_Server[i].dst_addr)) {
+ len = sizeof(Conf_Server[i].dst_addr);
Log(LOG_NOTICE,
"Notice: Resolver returned more IP Addresses for host than we can handle, additional addresses dropped.");
}
* IDENT user name.*/
CLIENT *c;
- int i;
+ CONN_ID i;
size_t len;
char *identptr;
#ifdef IDENTAUTH
#endif
LogDebug("Resolver: Got callback on fd %d, events %d", r_fd, events );
-
- /* Search associated connection ... */
- for( i = 0; i < Pool_Size; i++ ) {
- if(( My_Connections[i].sock != NONE )
- && ( Resolve_Getfd(&My_Connections[i].res_stat) == r_fd ))
- break;
- }
- if( i >= Pool_Size ) {
+ i = Conn_GetFromProc(r_fd);
+ if (i == NONE) {
/* Ops, none found? Probably the connection has already
* been closed!? We'll ignore that ... */
io_close( r_fd );
}
/* Read result from pipe */
- len = Resolve_Read(&My_Connections[i].res_stat, readbuf, sizeof readbuf -1);
+ len = Proc_Read(&My_Connections[i].proc_stat, readbuf, sizeof readbuf -1);
if (len == 0)
return;
c = Conn_GetClient( i );
assert( c != NULL );
- /* Only update client information of unregistered clients */
- if( Client_Type( c ) == CLIENT_UNKNOWN ) {
- strlcpy(My_Connections[i].host, readbuf, sizeof( My_Connections[i].host));
- Client_SetHostname( c, readbuf);
+ /* Only update client information of unregistered clients.
+ * Note: user commands (e. g. WEBIRC) are always read _after_ reading
+ * the resolver results, so we don't have to worry to override settings
+ * from these commands here. */
+ if(Client_Type(c) == CLIENT_UNKNOWN) {
+ strlcpy(My_Connections[i].host, readbuf,
+ sizeof(My_Connections[i].host));
+ Client_SetHostname(c, readbuf);
#ifdef IDENTAUTH
++identptr;
if (*identptr) {
#ifdef DEBUG
else Log( LOG_DEBUG, "Resolver: discarding result for already registered connection %d.", i );
#endif
- /* Reset penalty time */
- Conn_ResetPenalty( i );
} /* cb_Read_Resolver_Result */
+/**
+ * Write a "simple" (error) message to a socket.
+ * The message is sent without using the connection write buffers, without
+ * compression/encryption, and even without any error reporting. It is
+ * designed for error messages of e.g. New_Connection(). */
static void
-Simple_Message( int Sock, const char *Msg )
+Simple_Message(int Sock, const char *Msg)
{
char buf[COMMAND_LEN];
size_t len;
- /* Write "simple" message to socket, without using compression
- * or even the connection write buffers. Used e.g. for error
- * messages by New_Connection(). */
- assert( Sock > NONE );
- assert( Msg != NULL );
-
- strlcpy( buf, Msg, sizeof buf - 2);
- len = strlcat( buf, "\r\n", sizeof buf);
- (void)write(Sock, buf, len);
+
+ assert(Sock > NONE);
+ assert(Msg != NULL);
+
+ strlcpy(buf, Msg, sizeof buf - 2);
+ len = strlcat(buf, "\r\n", sizeof buf);
+ if (write(Sock, buf, len) < 0) {
+ /* Because this function most probably got called to log
+ * an error message, any write error is ignored here to
+ * avoid an endless loop. But casting the result of write()
+ * to "void" doesn't satisfy the GNU C code attribute
+ * "warn_unused_result" which is used by some versions of
+ * glibc (e.g. 2.11.1), therefore this silly error
+ * "handling" code here :-( */
+ return;
+ }
} /* Simple_Error */
+/**
+ * Get CLIENT structure that belongs to a local connection identified by its
+ * index number. Each connection belongs to a client by definition, so it is
+ * not required that the caller checks for NULL return values.
+ * @param Idx Connection index number
+ * @return Pointer to CLIENT structure
+ */
GLOBAL CLIENT *
Conn_GetClient( CONN_ID Idx )
{
- /* return Client-Structure that belongs to the local Connection Idx.
- * If none is found, return NULL.
- */
CONNECTION *c;
- assert( Idx >= 0 );
+ assert(Idx >= 0);
c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
-
assert(c != NULL);
-
return c ? c->client : NULL;
}
+/**
+ * Get PROC_STAT sub-process structure of a connection.
+ * @param Idx Connection index number
+ * @return PROC_STAT structure
+ */
+GLOBAL PROC_STAT *
+Conn_GetProcStat(CONN_ID Idx)
+{
+ CONNECTION *c;
+
+ assert(Idx >= 0);
+ c = array_get(&My_ConnArray, sizeof (CONNECTION), (size_t)Idx);
+ assert(c != NULL);
+ return &c->proc_stat;
+} /* Conn_GetProcStat */
+
+
+/**
+ * Get CONN_ID from file descriptor associated to a subprocess structure.
+ * @param fd File descriptor
+ * @return CONN_ID or NONE (-1)
+ */
+GLOBAL CONN_ID
+Conn_GetFromProc(int fd)
+{
+ int i;
+
+ assert(fd > 0);
+ for (i = 0; i < Pool_Size; i++) {
+ if ((My_Connections[i].sock != NONE)
+ && (Proc_GetPipeFd(&My_Connections[i].proc_stat) == fd))
+ return i;
+ }
+ return NONE;
+} /* Conn_GetFromProc */
+
+
#ifdef SSL_SUPPORT
-/* we cannot access My_Connections in irc-info.c */
+
+/**
+ * Get information about used SSL chiper.
+ * @param Idx Connection index number
+ * @param buf Buffer for returned information text
+ * @param len Size of return buffer "buf"
+ * @return true on success, false otherwise
+ */
GLOBAL bool
Conn_GetCipherInfo(CONN_ID Idx, char *buf, size_t len)
{
}
+/**
+ * Check if a connection is SSL-enabled or not.
+ * @param Idx Connection index number
+ * @return true if connection is SSL-enabled, false otherwise.
+ */
GLOBAL bool
Conn_UsesSSL(CONN_ID Idx)
{
assert(Idx < (int) array_length(&My_ConnArray, sizeof(CONNECTION)));
return Conn_OPTION_ISSET(&My_Connections[Idx], CONN_SSL);
}
+
+#endif
+
+
+#ifdef DEBUG
+
+GLOBAL void
+Conn_DebugDump(void)
+{
+ int i;
+
+ Log(LOG_DEBUG, "Connection status:");
+ for (i = 0; i < Pool_Size; i++) {
+ if (My_Connections[i].sock == NONE)
+ continue;
+ Log(LOG_DEBUG,
+ " - %d: host=%s, lastdata=%ld, lastping=%ld, delaytime=%ld, flag=%d, options=%d, bps=%d, client=%s",
+ My_Connections[i].sock, My_Connections[i].host,
+ My_Connections[i].lastdata, My_Connections[i].lastping,
+ My_Connections[i].delaytime, My_Connections[i].flag,
+ My_Connections[i].options, My_Connections[i].bps,
+ My_Connections[i].client ? Client_ID(My_Connections[i].client) : "-");
+ }
+} /* Conn_DumpClients */
+
#endif
+
+
/* -eof- */
projects / ngircd-alex.git / blobdiff