fix "beeing" typo

[ngircd-alex.git] / src / ngircd / conn.c

diff --git a/src/ngircd/conn.c b/src/ngircd/conn.c
index cd350a8d619700a2ca89034b5a05b132df6cba36..6994c8be8d7fb3876bc88961c95cac258a16f5d3 100644 (file)
--- a/src/ngircd/conn.c
+++ b/src/ngircd/conn.c
@@ -1,6 +1,6 @@
 /*
  * 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
@@ -37,6 +37,9 @@
 #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
 
@@ -92,10 +95,12 @@ static bool Init_Socket PARAMS(( int Sock ));
 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;
@@ -337,7 +342,7 @@ 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)
@@ -366,8 +371,8 @@ 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
@@ -375,17 +380,15 @@ Conn_Init( void )
        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 */
 
 
@@ -1098,6 +1101,27 @@ Conn_Close( CONN_ID Idx, const char *LogMsg, const char *FwdMsg, bool InformClie
 } /* 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 )
 {
@@ -1238,6 +1262,7 @@ New_Connection(int Sock)
                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);
@@ -1357,12 +1382,22 @@ New_Connection(int Sock)
         * If there are results earlier, the delay is aborted. */
        Conn_SetPenalty(new_sock, 4);
 
-       NumConnections++;
-       LogDebug("Total number of connections now %ld.", NumConnections);
+       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 )
 {
@@ -1802,7 +1837,7 @@ New_Server( int Server , ng_ipaddr_t *dest)
        }
 
        /* Conn_Close() decrements this counter again */
-       NumConnections++;
+       Account_Connection();
        Client_SetIntroducer( c, c );
        Client_SetToken( c, TOKEN_OUTBOUND );
 
@@ -2025,20 +2060,32 @@ cb_Read_Resolver_Result( int r_fd, UNUSED short events )
 } /* 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 */