/*
* ngIRCd -- The Next Generation IRC Daemon
- * Copyright (c)2001-2009 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 <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
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_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)
{
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)
{
}
+/**
+ * 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)
{
#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)
{
case 0:
return; /* EAGAIN: callback will be invoked again by IO layer */
default:
- Conn_Close(idx, "Socket closed!", "SSL accept error", false);
+ Conn_Close(idx, "SSL accept error, closing socket", "SSL accept error", false);
return;
}
if (what & IO_WANTREAD)
#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 )
{
}
+/**
+ * Initialize all listening sockets.
+ * @return Number of created listening sockets
+ */
GLOBAL unsigned int
Conn_InitListeners( void )
{
} /* Conn_Close */
+GLOBAL long
+Conn_Count(void)
+{
+ return NumConnections;
+} /* Conn_Count */
+
+
+GLOBAL long
+Conn_CountMax(void)
+{
+ return NumConnectionsMax;
+} /* Conn_CountMax */
+
+
+GLOBAL long
+Conn_CountAccepted(void)
+{
+ return NumConnectionsAccepted;
+} /* Conn_CountAccepted */
+
+
GLOBAL void
Conn_SyncServerStruct( void )
{
} /* 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)
{
- /* Neue Client-Verbindung von Listen-Socket annehmen und
- * CLIENT-Struktur anlegen. */
-
#ifdef TCPWRAP
struct request_info req;
#endif
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);
* DNS and IDENT resolver subprocess using the "penalty" mechanism.
* If there are results earlier, the delay is aborted. */
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 )
{
}
/* Conn_Close() decrements this counter again */
- NumConnections++;
+ Account_Connection();
Client_SetIntroducer( c, c );
Client_SetToken( c, TOKEN_OUTBOUND );
}
/* 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))) {
+ Log(LOG_ERR, "Can't set socket option IP_TOS: %s!",
+ strerror(errno));
/* ignore this error */
}
#endif
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) {
} /* 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);
#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)
{
projects / ngircd-alex.git / blobdiff