X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?p=ngircd-alex.git;a=blobdiff_plain;f=src%2Fngircd%2Fconn.c;h=7b9dcdb3c0a053a43b6c7be7396e225f326b1473;hp=80da71d748c115cc4b2a4f917e5d740983bd3325;hb=b79b315dd4b5fcefb781d1e1e012f71e578a5346;hpb=e68cdf304f1242bbeb3f0b59323f3059d0d543c4

diff --git a/src/ngircd/conn.c b/src/ngircd/conn.c
index 80da71d7..7b9dcdb3 100644
--- a/src/ngircd/conn.c
+++ b/src/ngircd/conn.c
@@ -1,6 +1,6 @@
 /*
  * ngIRCd -- The Next Generation IRC Daemon
- * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
+ * Copyright (c)2001-2003 by 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
@@ -12,11 +12,11 @@
  */
 
 
-#define __conn_c__
+#define CONN_MODULE
 
 #include "portab.h"
 
-static char UNUSED id[] = "$Id: conn.c,v 1.112 2002/12/30 16:07:23 alex Exp $";
+static char UNUSED id[] = "$Id: conn.c,v 1.129 2003/12/27 13:01:12 alex Exp $";
 
 #include "imp.h"
 #include <assert.h>
@@ -40,7 +40,11 @@ static char UNUSED id[] = "$Id: conn.c,v 1.112 2002/12/30 16:07:23 alex Exp $";
 #endif
 
 #ifdef HAVE_STDINT_H
-#include <stdint.h>			/* u.a. fuer Mac OS X */
+#include <stdint.h>			/* e.g. for Mac OS X */
+#endif
+
+#ifdef TCPWRAP
+#include <tcpd.h>			/* for TCP Wrappers */
 #endif
 
 #include "defines.h"
@@ -54,10 +58,15 @@ static char UNUSED id[] = "$Id: conn.c,v 1.112 2002/12/30 16:07:23 alex Exp $";
 #include "client.h"
 #include "conf.h"
 #include "conn-zip.h"
+#include "conn-func.h"
 #include "log.h"
 #include "parse.h"
 #include "tool.h"
 
+#ifdef RENDEZVOUS
+#include "rendezvous.h"
+#endif
+
 #include "exp.h"
 
 
@@ -77,12 +86,17 @@ LOCAL VOID Init_Conn_Struct PARAMS(( CONN_ID Idx ));
 LOCAL BOOLEAN Init_Socket PARAMS(( INT Sock ));
 LOCAL VOID New_Server PARAMS(( INT Server, CONN_ID Idx ));
 LOCAL VOID Read_Resolver_Result PARAMS(( INT r_fd ));
+LOCAL VOID Simple_Message PARAMS(( INT Sock, CHAR *Msg ));
+LOCAL INT Count_Connections PARAMS(( struct sockaddr_in addr ));
 
 LOCAL fd_set My_Listeners;
 LOCAL fd_set My_Sockets;
 LOCAL fd_set My_Connects;
 
-LOCAL LONG WCounter;
+#ifdef TCPWRAP
+INT allow_severity = LOG_INFO;
+INT deny_severity = LOG_ERR;
+#endif
 
 
 GLOBAL VOID
@@ -106,7 +120,9 @@ Conn_Init( VOID )
 		Log( LOG_EMERG, "Can't allocate memory! [Conn_Init]" );
 		exit( 1 );
 	}
-	Log( LOG_DEBUG, "Allocted connection pool for %d items (%ld bytes).", Pool_Size, sizeof( CONNECTION ) * Pool_Size );
+#ifdef DEBUG
+	Log( LOG_DEBUG, "Allocated connection pool for %d items (%ld bytes).", Pool_Size, sizeof( CONNECTION ) * Pool_Size );
+#endif
 
 	/* zu Beginn haben wir keine Verbindungen */
 	FD_ZERO( &My_Listeners );
@@ -133,8 +149,15 @@ Conn_Exit( VOID )
 	CONN_ID idx;
 	INT i;
 
-	/* Sockets schliessen */
+#ifdef DEBUG
 	Log( LOG_DEBUG, "Shutting down all connections ..." );
+#endif
+
+#ifdef RENDEZVOUS
+	Rendezvous_UnregisterListeners( );
+#endif
+
+	/* Sockets schliessen */
 	for( i = 0; i < Conn_MaxFD + 1; i++ )
 	{
 		if( FD_ISSET( i, &My_Sockets ))
@@ -146,12 +169,16 @@ Conn_Exit( VOID )
 			if( FD_ISSET( i, &My_Listeners ))
 			{
 				close( i );
+#ifdef DEBUG
 				Log( LOG_DEBUG, "Listening socket %d closed.", i );
+#endif
 			}
 			else if( FD_ISSET( i, &My_Connects ))
 			{
 				close( i );
+#ifdef DEBUG
 				Log( LOG_DEBUG, "Connection %d closed during creation (socket %d).", idx, i );
+#endif
 			}
 			else if( idx < Pool_Size )
 			{
@@ -165,7 +192,7 @@ Conn_Exit( VOID )
 			}
 		}
 	}
-	
+
 	free( My_Connections );
 	My_Connections = NULL;
 	Pool_Size = 0;
@@ -196,13 +223,19 @@ Conn_ExitListeners( VOID )
 
 	INT i;
 
+#ifdef RENDEZVOUS
+	Rendezvous_UnregisterListeners( );
+#endif
+
 	Log( LOG_INFO, "Shutting down all listening sockets ..." );
 	for( i = 0; i < Conn_MaxFD + 1; i++ )
 	{
 		if( FD_ISSET( i, &My_Sockets ) && FD_ISSET( i, &My_Listeners ))
 		{
 			close( i );
+#ifdef DEBUG
 			Log( LOG_DEBUG, "Listening socket %d closed.", i );
+#endif
 		}
 	}
 } /* Conn_ExitListeners */
@@ -214,13 +247,32 @@ Conn_NewListener( CONST UINT Port )
 	/* Create new listening socket on specified port */
 
 	struct sockaddr_in addr;
+	struct in_addr inaddr;
 	INT sock;
+#ifdef RENDEZVOUS
+	CHAR name[CLIENT_ID_LEN], *info;
+#endif
 
 	/* Server-"Listen"-Socket initialisieren */
 	memset( &addr, 0, sizeof( addr ));
+	memset( &inaddr, 0, sizeof( inaddr ));
 	addr.sin_family = AF_INET;
 	addr.sin_port = htons( Port );
-	addr.sin_addr.s_addr = htonl( INADDR_ANY );
+	if( Conf_ListenAddress[0] )
+	{
+#ifdef HAVE_INET_ATON
+		if( inet_aton( Conf_ListenAddress, &inaddr ) == 0 )
+#else
+		inaddr.s_addr = inet_addr( Conf_ListenAddress );
+		if( inaddr.s_addr == (unsigned)-1 )
+#endif
+		{
+			Log( LOG_CRIT, "Can't listen on %s:%u: can't convert ip address %s!", Conf_ListenAddress, Port, Conf_ListenAddress );
+			return FALSE;
+		}
+	}
+	else inaddr.s_addr = htonl( INADDR_ANY );
+	addr.sin_addr = inaddr;
 
 	/* Socket erzeugen */
 	sock = socket( PF_INET, SOCK_STREAM, 0);
@@ -254,7 +306,36 @@ Conn_NewListener( CONST UINT Port )
 
 	if( sock > Conn_MaxFD ) Conn_MaxFD = sock;
 
-	Log( LOG_INFO, "Now listening on port %d (socket %d).", Port, sock );
+	if( Conf_ListenAddress[0]) Log( LOG_INFO, "Now listening on %s:%d (socket %d).", Conf_ListenAddress, Port, sock );
+	else Log( LOG_INFO, "Now listening on 0.0.0.0:%d (socket %d).", Port, sock );
+
+#ifdef RENDEZVOUS
+	/* Get best server description text */
+	if( ! Conf_ServerInfo[0] ) info = Conf_ServerName;
+	else
+	{
+		/* Use server info string */
+		info = NULL;
+		if( Conf_ServerInfo[0] == '[' )
+		{
+			/* Cut off leading hostname part in "[]" */
+			info = strchr( Conf_ServerInfo, ']' );
+			if( info )
+			{
+				info++;
+				while( *info == ' ' ) info++;
+			}
+		}
+		if( ! info ) info = Conf_ServerInfo;
+	}
+
+	/* Add port number to description if non-standard */
+	if( Port != 6667 ) snprintf( name, sizeof( name ), "%s (port %u)", info, Port );
+	else strlcpy( name, info, sizeof( name ));
+
+	/* Register service */
+	Rendezvous_Register( name, RENDEZVOUS_TYPE, Port );
+#endif
 
 	return TRUE;
 } /* Conn_NewListener */
@@ -286,6 +367,10 @@ Conn_Handler( VOID )
 	{
 		timeout = TRUE;
 
+#ifdef RENDEZVOUS
+		Rendezvous_Handler( );
+#endif
+
 		/* Should the configuration be reloaded? */
 		if( NGIRCd_SignalRehash ) NGIRCd_Rehash( );
 
@@ -293,10 +378,13 @@ Conn_Handler( VOID )
 		Check_Servers( );
 		Check_Connections( );
 
+		t = time( NULL );
+
 		/* noch volle Lese-Buffer suchen */
 		for( i = 0; i < Pool_Size; i++ )
 		{
-			if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].rdatalen > 0 ))
+			if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].rdatalen > 0 ) &&
+			 ( My_Connections[i].delaytime < t ))
 			{
 				/* Kann aus dem Buffer noch ein Befehl extrahiert werden? */
 				if( Handle_Buffer( i )) timeout = FALSE;
@@ -307,7 +395,7 @@ Conn_Handler( VOID )
 		FD_ZERO( &write_sockets );
 		for( i = 0; i < Pool_Size; i++ )
 		{
-#ifdef USE_ZLIB
+#ifdef ZLIB
 			if(( My_Connections[i].sock > NONE ) && (( My_Connections[i].wdatalen > 0 ) || ( My_Connections[i].zip.wdatalen > 0 )))
 #else
 			if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].wdatalen > 0 ))
@@ -325,7 +413,6 @@ Conn_Handler( VOID )
 		}
 
 		/* von welchen Sockets koennte gelesen werden? */
-		t = time( NULL );
 		read_sockets = My_Sockets;
 		for( i = 0; i < Pool_Size; i++ )
 		{
@@ -356,9 +443,9 @@ Conn_Handler( VOID )
 
 		/* Timeout initialisieren */
 		tv.tv_usec = 0;
-		if( timeout ) tv.tv_sec = TIME_RES;
+		if( timeout ) tv.tv_sec = 1;
 		else tv.tv_sec = 0;
-		
+
 		/* Auf Aktivitaet warten */
 		i = select( Conn_MaxFD + 1, &read_sockets, &write_sockets, NULL, &tv );
 		if( i == 0 )
@@ -372,7 +459,7 @@ Conn_Handler( VOID )
 			if( errno != EINTR )
 			{
 				Log( LOG_EMERG, "Conn_Handler(): select(): %s!", strerror( errno ));
-				Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE );
+				Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE_NAME );
 				exit( 1 );
 			}
 			continue;
@@ -386,7 +473,7 @@ Conn_Handler( VOID )
 			/* Es kann geschrieben werden ... */
 			idx = Socket2Index( i );
 			if( idx == NONE ) continue;
-			
+
 			if( ! Handle_Write( idx ))
 			{
 				/* Fehler beim Schreiben! Diesen Socket nun
@@ -470,7 +557,9 @@ Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
 	 * In diesem Fall wird hier einfach ein Fehler geliefert. */
 	if( My_Connections[Idx].sock <= NONE )
 	{
+#ifdef DEBUG
 		Log( LOG_DEBUG, "Skipped write on closed socket (connection %d).", Idx );
+#endif
 		return FALSE;
 	}
 
@@ -492,7 +581,7 @@ Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
 		}
 	}
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	if( My_Connections[Idx].options & CONN_ZIP )
 	{
 		/* Daten komprimieren und in Puffer kopieren */
@@ -522,7 +611,7 @@ Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
 
 	CLIENT *c;
 	DOUBLE in_k, out_k;
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	DOUBLE in_z_k, out_z_k;
 	INT in_p, out_p;
 #endif
@@ -530,6 +619,17 @@ Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
 	assert( Idx > NONE );
 	assert( My_Connections[Idx].sock > NONE );
 
+	/* Is this link already shutting down? */
+	if( My_Connections[Idx].options & CONN_ISCLOSING )
+	{
+		/* Conn_Close() has been called recursively for this link;
+		 * probabe reason: Try_Write() failed  -- see below. */
+		return;
+	}
+
+	/* Mark link as "closing" */
+	My_Connections[Idx].options |= CONN_ISCLOSING;
+
 	/* Search client, if any */
 	c = Client_GetFromConn( Idx );
 
@@ -551,14 +651,14 @@ Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
 	}
 
 	/* Try to write out the write buffer */
-	Try_Write( Idx );
+	(VOID)Try_Write( Idx );
 
 	/* Shut down socket */
 	if( close( My_Connections[Idx].sock ) != 0 )
 	{
 		/* Oops, we can't close the socket!? This is fatal! */
 		Log( LOG_EMERG, "Error closing connection %d (socket %d) with %s:%d - %s!", Idx, My_Connections[Idx].sock, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port), strerror( errno ));
-		Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE );
+		Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE_NAME );
 		exit( 1 );
 	}
 
@@ -573,7 +673,7 @@ Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
 	/* Calculate statistics and log information */
 	in_k = (DOUBLE)My_Connections[Idx].bytes_in / 1024;
 	out_k = (DOUBLE)My_Connections[Idx].bytes_out / 1024;
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	if( My_Connections[Idx].options & CONN_ZIP )
 	{
 		in_z_k = (DOUBLE)My_Connections[Idx].zip.bytes_in / 1024;
@@ -601,7 +701,7 @@ Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
 	/* Servers: Modify time of next connect attempt? */
 	Conf_UnsetServer( Idx );
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	/* Clean up zlib, if link was compressed */
 	if( Conn_Options( Idx ) & CONN_ZIP )
 	{
@@ -616,249 +716,34 @@ Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
 
 
 GLOBAL VOID
-Conn_UpdateIdle( CONN_ID Idx )
-{
-	/* Idle-Timer zuruecksetzen */
-
-	assert( Idx > NONE );
-	My_Connections[Idx].lastprivmsg = time( NULL );
-}
-
-
-GLOBAL time_t
-Conn_GetIdle( CONN_ID Idx )
-{
-	/* Idle-Time einer Verbindung liefern (in Sekunden) */
-
-	assert( Idx > NONE );
-	return time( NULL ) - My_Connections[Idx].lastprivmsg;
-} /* Conn_GetIdle */
-
-
-GLOBAL time_t
-Conn_LastPing( CONN_ID Idx )
+Conn_SyncServerStruct( VOID )
 {
-	/* Zeitpunkt des letzten PING liefern */
-
-	assert( Idx > NONE );
-	return My_Connections[Idx].lastping;
-} /* Conn_LastPing */
-
-
-GLOBAL VOID
-Conn_SetPenalty( CONN_ID Idx, time_t Seconds )
-{
-	/* Penalty-Delay fuer eine Verbindung (in Sekunden) setzen;
-	 * waehrend dieser Zeit wird der entsprechende Socket vom Server
-	 * bei Lese-Operationen komplett ignoriert. Der Delay kann mit
-	 * dieser Funktion nur erhoeht, nicht aber verringert werden. */
-	
-	time_t t;
-	
-	assert( Idx > NONE );
-	assert( Seconds >= 0 );
-	
-	t = time( NULL ) + Seconds;
-	if( t > My_Connections[Idx].delaytime ) My_Connections[Idx].delaytime = t;
-} /* Conn_SetPenalty */
-
-
-GLOBAL VOID
-Conn_ResetPenalty( CONN_ID Idx )
-{
-	assert( Idx > NONE );
-	My_Connections[Idx].delaytime = 0;
-} /* Conn_ResetPenalty */
-
-
-GLOBAL VOID
-Conn_ClearFlags( VOID )
-{
-	/* Alle Connection auf "nicht-markiert" setzen */
+	/* Synchronize server structures (connection IDs):
+	 * connections <-> configuration */
 
+	CLIENT *client;
 	CONN_ID i;
+	INT c;
 
-	for( i = 0; i < Pool_Size; i++ ) My_Connections[i].flag = 0;
-} /* Conn_ClearFlags */
-
-
-GLOBAL INT
-Conn_Flag( CONN_ID Idx )
-{
-	/* Ist eine Connection markiert (TRUE) oder nicht? */
-
-	assert( Idx > NONE );
-	return My_Connections[Idx].flag;
-} /* Conn_Flag */
-
-
-GLOBAL VOID
-Conn_SetFlag( CONN_ID Idx, INT Flag )
-{
-	/* Connection markieren */
-
-	assert( Idx > NONE );
-	My_Connections[Idx].flag = Flag;
-} /* Conn_SetFlag */
-
-
-GLOBAL CONN_ID
-Conn_First( VOID )
-{
-	/* Connection-Struktur der ersten Verbindung liefern;
-	 * Ist keine Verbindung vorhanden, wird NONE geliefert. */
-
-	CONN_ID i;
-	
 	for( i = 0; i < Pool_Size; i++ )
 	{
-		if( My_Connections[i].sock != NONE ) return i;
-	}
-	return NONE;
-} /* Conn_First */
+		/* Established connection? */
+		if( My_Connections[i].sock <= NONE ) continue;
 
+		/* Server connection? */
+		client = Client_GetFromConn( i );
+		if(( ! client ) || ( Client_Type( client ) != CLIENT_SERVER )) continue;
 
-GLOBAL CONN_ID
-Conn_Next( CONN_ID Idx )
-{
-	/* Naechste Verbindungs-Struktur liefern; existiert keine
-	 * weitere, so wird NONE geliefert. */
-
-	CONN_ID i = NONE;
+		for( c = 0; c < MAX_SERVERS; c++ )
+		{
+			/* Configured server? */
+			if( ! Conf_Server[c].host[0] ) continue;
 
-	assert( Idx > NONE );
-	
-	for( i = Idx + 1; i < Pool_Size; i++ )
-	{
-		if( My_Connections[i].sock != NONE ) return i;
+			/* Duplicate? */
+			if( strcmp( Conf_Server[c].name, Client_ID( client )) == 0 ) Conf_Server[c].conn_id = i;
+		}
 	}
-	return NONE;
-} /* Conn_Next */
-
-
-GLOBAL VOID
-Conn_SetOption( CONN_ID Idx, INT Option )
-{
-	/* Option fuer Verbindung setzen.
-	 * Initial sind alle Optionen _nicht_ gesetzt. */
-
-	assert( Idx > NONE );
-	assert( Option != 0 );
-
-	My_Connections[Idx].options |= Option;
-} /* Conn_SetOption */
-
-
-GLOBAL VOID
-Conn_UnsetOption( CONN_ID Idx, INT Option )
-{
-	/* Option fuer Verbindung loeschen */
-
-	assert( Idx > NONE );
-	assert( Option != 0 );
-
-	My_Connections[Idx].options &= ~Option;
-} /* Conn_UnsetOption */
-
-
-GLOBAL INT
-Conn_Options( CONN_ID Idx )
-{
-	assert( Idx > NONE );
-	return My_Connections[Idx].options;
-} /* Conn_Options */
-
-
-GLOBAL time_t
-Conn_StartTime( CONN_ID Idx )
-{
-	/* Zeitpunkt des Link-Starts liefern (in Sekunden) */
-
-	assert( Idx > NONE );
-	return My_Connections[Idx].starttime;
-} /* Conn_Uptime */
-
-
-GLOBAL INT
-Conn_SendQ( CONN_ID Idx )
-{
-	/* Laenge der Daten im Schreibbuffer liefern */
-
-	assert( Idx > NONE );
-#ifdef USE_ZLIB
-	if( My_Connections[Idx].options & CONN_ZIP ) return My_Connections[Idx].zip.wdatalen;
-	else
-#endif
-	return My_Connections[Idx].wdatalen;
-} /* Conn_SendQ */
-
-
-GLOBAL LONG
-Conn_SendMsg( CONN_ID Idx )
-{
-	/* Anzahl gesendeter Nachrichten liefern */
-
-	assert( Idx > NONE );
-	return My_Connections[Idx].msg_out;
-} /* Conn_SendMsg */
-
-
-GLOBAL LONG
-Conn_SendBytes( CONN_ID Idx )
-{
-	/* Anzahl gesendeter Bytes (unkomprimiert) liefern */
-
-	assert( Idx > NONE );
-	return My_Connections[Idx].bytes_out;
-} /* Conn_SendBytes */
-
-
-GLOBAL INT
-Conn_RecvQ( CONN_ID Idx )
-{
-	/* Laenge der Daten im Lesebuffer liefern */
-
-	assert( Idx > NONE );
-#ifdef USE_ZLIB
-	if( My_Connections[Idx].options & CONN_ZIP ) return My_Connections[Idx].zip.rdatalen;
-	else
-#endif
-	return My_Connections[Idx].rdatalen;
-} /* Conn_RecvQ */
-
-
-GLOBAL LONG
-Conn_RecvMsg( CONN_ID Idx )
-{
-	/* Anzahl empfangener Nachrichten liefern */
-
-	assert( Idx > NONE );
-	return My_Connections[Idx].msg_in;
-} /* Conn_RecvMsg */
-
-
-GLOBAL LONG
-Conn_RecvBytes( CONN_ID Idx )
-{
-	/* Anzahl empfangener Bytes (unkomprimiert) liefern */
-
-	assert( Idx > NONE );
-	return My_Connections[Idx].bytes_in;
-} /* Conn_RecvBytes */
-
-
-GLOBAL VOID
-Conn_ResetWCounter( VOID )
-{
-	WCounter = 0;
-} /* Conn_ResetWCounter */
-
-
-GLOBAL LONG
-Conn_WCounter( VOID )
-{
-	return WCounter;
-} /* Conn_WCounter */
+} /* SyncServerStruct */
 
 
 LOCAL BOOLEAN
@@ -877,7 +762,7 @@ Try_Write( CONN_ID Idx )
 	assert( My_Connections[Idx].sock > NONE );
 
 	/* sind ueberhaupt Daten vorhanden? */
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	if(( ! My_Connections[Idx].wdatalen > 0 ) && ( ! My_Connections[Idx].zip.wdatalen )) return TRUE;
 #else
 	if( ! My_Connections[Idx].wdatalen > 0 ) return TRUE;
@@ -945,6 +830,8 @@ Handle_Write( CONN_ID Idx )
 	/* Daten aus Schreibpuffer versenden bzw. Connection aufbauen */
 
 	INT len, res, err;
+	socklen_t sock_len;
+	CLIENT *c;
 
 	assert( Idx > NONE );
 	assert( My_Connections[Idx].sock > NONE );
@@ -957,9 +844,9 @@ Handle_Write( CONN_ID Idx )
 		FD_CLR( My_Connections[Idx].sock, &My_Connects );
 
 		/* Ergebnis des connect() ermitteln */
-		len = sizeof( err );
-		res = getsockopt( My_Connections[Idx].sock, SOL_SOCKET, SO_ERROR, &err, &len );
-		assert( len == sizeof( err ));
+		sock_len = sizeof( err );
+		res = getsockopt( My_Connections[Idx].sock, SOL_SOCKET, SO_ERROR, &err, &sock_len );
+		assert( sock_len == sizeof( err ));
 
 		/* Fehler aufgetreten? */
 		if(( res != 0 ) || ( err != 0 ))
@@ -968,8 +855,10 @@ Handle_Write( CONN_ID Idx )
 			if( res != 0 ) Log( LOG_CRIT, "getsockopt (connection %d): %s!", Idx, strerror( errno ));
 			else Log( LOG_CRIT, "Can't connect socket to \"%s:%d\" (connection %d): %s!", My_Connections[Idx].host, Conf_Server[Conf_GetServer( Idx )].port, Idx, strerror( err ));
 
-			/* Socket etc. pp. aufraeumen */
+			/* Clean up socket, connection and client structures */
 			FD_CLR( My_Connections[Idx].sock, &My_Sockets );
+			c = Client_GetFromConn( Idx );
+			if( c ) Client_DestroyNow( c );
 			close( My_Connections[Idx].sock );
 			Init_Conn_Struct( Idx );
 
@@ -979,14 +868,16 @@ Handle_Write( CONN_ID Idx )
 
 			return FALSE;
 		}
+#ifdef DEBUG
 		Log( LOG_DEBUG, "Connection %d with \"%s:%d\" established, now sendig PASS and SERVER ...", Idx, My_Connections[Idx].host, Conf_Server[Conf_GetServer( Idx )].port );
+#endif
 
 		/* PASS und SERVER verschicken */
 		Conn_WriteStr( Idx, "PASS %s %s", Conf_Server[Conf_GetServer( Idx )].pwd_out, NGIRCd_ProtoID );
 		return Conn_WriteStr( Idx, "SERVER %s :%s", Conf_ServerName, Conf_ServerInfo );
 	}
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	/* Schreibpuffer leer, aber noch Daten im Kompressionsbuffer?
 	 * Dann muss dieser nun geflushed werden! */
 	if( My_Connections[Idx].wdatalen == 0 ) Zip_Flush( Idx );
@@ -1021,13 +912,16 @@ New_Connection( INT Sock )
 	/* Neue Client-Verbindung von Listen-Socket annehmen und
 	 * CLIENT-Struktur anlegen. */
 
+#ifdef TCPWRAP
+	struct request_info req;
+#endif
 	struct sockaddr_in new_addr;
 	INT new_sock, new_sock_len;
 	RES_STAT *s;
 	CONN_ID idx;
 	CLIENT *c;
 	POINTER *ptr;
-	LONG new_size;
+	LONG new_size, cnt;
 
 	assert( Sock > NONE );
 
@@ -1040,18 +934,42 @@ New_Connection( INT Sock )
 		return;
 	}
 
+#ifdef TCPWRAP
+	/* Validate socket using TCP Wrappers */
+	request_init( &req, RQ_DAEMON, PACKAGE_NAME, RQ_FILE, new_sock, RQ_CLIENT_SIN, &new_addr, NULL );
+	if( ! hosts_access( &req ))
+	{
+		/* Access denied! */
+		Log( deny_severity, "Refused connection from %s (by TCP Wrappers)!", inet_ntoa( new_addr.sin_addr ));
+		Simple_Message( new_sock, "ERROR :Connection refused" );
+		close( new_sock );
+		return;
+	}
+#endif
+
 	/* Socket initialisieren */
 	Init_Socket( new_sock );
+	
+	/* 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! */
+		Log( LOG_ERR, "Refused connection from %s: too may connections (%ld) from this IP!", inet_ntoa( new_addr.sin_addr ), cnt);
+		Simple_Message( new_sock, "ERROR :Connection refused, too many connections from your IP!" );
+		close( new_sock );
+		return;
+	}
 
 	/* Freie Connection-Struktur suchen */
 	for( idx = 0; idx < Pool_Size; idx++ ) if( My_Connections[idx].sock == NONE ) break;
 	if( idx >= Pool_Size )
 	{
 		new_size = Pool_Size + CONNECTION_POOL;
-		
+
 		/* Im bisherigen Pool wurde keine freie Connection-Struktur mehr gefunden.
 		 * Wenn erlaubt und moeglich muss nun der Pool vergroessert werden: */
-		
+
 		if( Conf_MaxConnections > 0 )
 		{
 			/* Es ist ein Limit konfiguriert */
@@ -1059,6 +977,7 @@ New_Connection( INT Sock )
 			{
 				/* Mehr Verbindungen duerfen wir leider nicht mehr annehmen ... */
 				Log( LOG_ALERT, "Can't accept connection: limit (%d) reached!", Pool_Size );
+				Simple_Message( new_sock, "ERROR :Connection limit reached" );
 				close( new_sock );
 				return;
 			}
@@ -1067,10 +986,11 @@ New_Connection( INT Sock )
 		if( new_size < Pool_Size )
 		{
 			Log( LOG_ALERT, "Can't accespt connection: limit (%d) reached -- overflow!", Pool_Size );
+			Simple_Message( new_sock, "ERROR :Connection limit reached" );
 			close( new_sock );
 			return;
 		}
-		
+
 		/* zunaechst realloc() versuchen; wenn das scheitert, malloc() versuchen
 		 * und Daten ggf. "haendisch" umkopieren. (Haesslich! Eine wirklich
 		 * dynamische Verwaltung waere wohl _deutlich_ besser ...) */
@@ -1083,24 +1003,29 @@ New_Connection( INT Sock )
 			{
 				/* Offenbar steht kein weiterer Sepeicher zur Verfuegung :-( */
 				Log( LOG_EMERG, "Can't allocate memory! [New_Connection]" );
+				Simple_Message( new_sock, "ERROR: Internal error" );
 				close( new_sock );
 				return;
 			}
-			
+
 			/* Struktur umkopieren ... */
 			memcpy( ptr, My_Connections, sizeof( CONNECTION ) * Pool_Size );
-			
+
+#ifdef DEBUG
 			Log( LOG_DEBUG, "Allocated new connection pool for %ld items (%ld bytes). [malloc()/memcpy()]", new_size, sizeof( CONNECTION ) * new_size );
+#endif
 		}
+#ifdef DEBUG
 		else Log( LOG_DEBUG, "Allocated new connection pool for %ld items (%ld bytes). [realloc()]", new_size, sizeof( CONNECTION ) * new_size );
-		
+#endif
+
 		/* Adjust pointer to new block */
 		My_Connections = ptr;
-		
+
 		/* Initialize new items */
 		for( idx = Pool_Size; idx < new_size; idx++ ) Init_Conn_Struct( idx );
 		idx = Pool_Size;
-		
+
 		/* Adjust new pool size */
 		Pool_Size = new_size;
 	}
@@ -1110,6 +1035,7 @@ New_Connection( INT Sock )
 	if( ! c )
 	{
 		Log( LOG_ALERT, "Can't accept connection: can't create client structure!" );
+		Simple_Message( new_sock, "ERROR :Internal error" );
 		close( new_sock );
 		return;
 	}
@@ -1128,13 +1054,17 @@ New_Connection( INT Sock )
 	/* Hostnamen ermitteln */
 	strlcpy( My_Connections[idx].host, inet_ntoa( new_addr.sin_addr ), sizeof( My_Connections[idx].host ));
 	Client_SetHostname( c, My_Connections[idx].host );
+#ifdef IDENTAUTH
+	s = Resolve_Addr( &new_addr, My_Connections[idx].sock );
+#else
 	s = Resolve_Addr( &new_addr );
+#endif
 	if( s )
 	{
 		/* Sub-Prozess wurde asyncron gestartet */
 		My_Connections[idx].res_stat = s;
 	}
-	
+
 	/* Penalty-Zeit setzen */
 	Conn_SetPenalty( idx, 4 );
 } /* New_Connection */
@@ -1155,7 +1085,9 @@ Socket2Index( INT Sock )
 	{
 		/* die Connection wurde vermutlich (wegen eines
 		 * Fehlers) bereits wieder abgebaut ... */
+#ifdef DEBUG
 		Log( LOG_DEBUG, "Socket2Index: can't get connection for socket %d!", Sock );
+#endif
 		return NONE;
 	}
 	else return idx;
@@ -1169,7 +1101,7 @@ Read_Request( CONN_ID Idx )
 	 * Tritt ein Fehler auf, so wird der Socket geschlossen. */
 
 	INT len, bsize;
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	CLIENT *c;
 #endif
 
@@ -1179,12 +1111,12 @@ Read_Request( CONN_ID Idx )
 	/* wenn noch nicht registriert: maximal mit ZREADBUFFER_LEN arbeiten,
 	 * ansonsten koennen Daten ggf. nicht umkopiert werden. */
 	bsize = READBUFFER_LEN;
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	c = Client_GetFromConn( Idx );
 	if(( Client_Type( c ) != CLIENT_USER ) && ( Client_Type( c ) != CLIENT_SERVER ) && ( Client_Type( c ) != CLIENT_SERVICE ) && ( bsize > ZREADBUFFER_LEN )) bsize = ZREADBUFFER_LEN;
 #endif
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	if(( bsize - My_Connections[Idx].rdatalen - 1 < 1 ) || ( ZREADBUFFER_LEN - My_Connections[Idx].zip.rdatalen < 1 ))
 #else
 	if( bsize - My_Connections[Idx].rdatalen - 1 < 1 )
@@ -1196,7 +1128,7 @@ Read_Request( CONN_ID Idx )
 		return;
 	}
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	if( My_Connections[Idx].options & CONN_ZIP )
 	{
 		len = recv( My_Connections[Idx].sock, My_Connections[Idx].zip.rbuf + My_Connections[Idx].zip.rdatalen, ( ZREADBUFFER_LEN - My_Connections[Idx].zip.rdatalen ), 0 );
@@ -1251,28 +1183,31 @@ Handle_Buffer( CONN_ID Idx )
 	CHAR *ptr;
 	INT len, delta;
 	BOOLEAN action, result;
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	BOOLEAN old_z;
 #endif
 
 	result = FALSE;
 	do
 	{
-#ifdef USE_ZLIB
+		/* Check penalty */
+		if( My_Connections[Idx].delaytime > time( NULL )) return result;
+		
+#ifdef ZLIB
 		/* ggf. noch unkomprimiete Daten weiter entpacken */
 		if( My_Connections[Idx].options & CONN_ZIP )
 		{
 			if( ! Unzip_Buffer( Idx )) return FALSE;
 		}
 #endif
-	
+
 		if( My_Connections[Idx].rdatalen < 1 ) break;
 
 		/* Eine komplette Anfrage muss mit CR+LF enden, vgl.
 		 * RFC 2812. Haben wir eine? */
 		My_Connections[Idx].rbuf[My_Connections[Idx].rdatalen] = '\0';
 		ptr = strstr( My_Connections[Idx].rbuf, "\r\n" );
-	
+
 		if( ptr ) delta = 2;
 #ifndef STRICT_RFC
 		else
@@ -1287,7 +1222,7 @@ Handle_Buffer( CONN_ID Idx )
 			else if( ptr2 ) ptr = ptr2;
 		}
 #endif
-	
+
 		action = FALSE;
 		if( ptr )
 		{
@@ -1304,7 +1239,7 @@ Handle_Buffer( CONN_ID Idx )
 				return FALSE;
 			}
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 			/* merken, ob Stream bereits komprimiert wird */
 			old_z = My_Connections[Idx].options & CONN_ZIP;
 #endif
@@ -1321,7 +1256,7 @@ Handle_Buffer( CONN_ID Idx )
 			My_Connections[Idx].rdatalen -= len;
 			memmove( My_Connections[Idx].rbuf, My_Connections[Idx].rbuf + len, My_Connections[Idx].rdatalen );
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 			if(( ! old_z ) && ( My_Connections[Idx].options & CONN_ZIP ) && ( My_Connections[Idx].rdatalen > 0 ))
 			{
 				/* Mit dem letzten Befehl wurde Socket-Kompression aktiviert.
@@ -1337,15 +1272,17 @@ Handle_Buffer( CONN_ID Idx )
 					memcpy( My_Connections[Idx].zip.rbuf, My_Connections[Idx].rbuf, My_Connections[Idx].rdatalen );
 					My_Connections[Idx].zip.rdatalen = My_Connections[Idx].rdatalen;
 					My_Connections[Idx].rdatalen = 0;
+#ifdef DEBUG
 					Log( LOG_DEBUG, "Moved already received data (%d bytes) to uncompression buffer.", My_Connections[Idx].zip.rdatalen );
+#endif
 				}
 			}
 #endif
 		}
-		
+
 		if( action ) result = TRUE;
 	} while( action );
-	
+
 	return result;
 } /* Handle_Buffer */
 
@@ -1374,14 +1311,18 @@ Check_Connections( VOID )
 				if( My_Connections[i].lastping < time( NULL ) - Conf_PongTimeout )
 				{
 					/* Timeout */
+#ifdef DEBUG
 					Log( LOG_DEBUG, "Connection %d: Ping timeout: %d seconds.", i, Conf_PongTimeout );
+#endif
 					Conn_Close( i, NULL, "Ping timeout", TRUE );
 				}
 			}
 			else if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
 			{
 				/* es muss ein PING gesendet werden */
+#ifdef DEBUG
 				Log( LOG_DEBUG, "Connection %d: sending PING ...", i );
+#endif
 				My_Connections[i].lastping = time( NULL );
 				Conn_WriteStr( i, "PING :%s", Client_ID( Client_ThisServer( )));
 			}
@@ -1392,7 +1333,9 @@ Check_Connections( VOID )
 			if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
 			{
 				/* Timeout */
+#ifdef DEBUG
 				Log( LOG_DEBUG, "Connection %d timed out ...", i );
+#endif
 				Conn_Close( i, NULL, "Timeout", FALSE );
 			}
 		}
@@ -1409,9 +1352,6 @@ Check_Servers( VOID )
 	CONN_ID idx;
 	INT i, n;
 
-	/* Don't connect in "passive mode" */
-	if( NGIRCd_Passive ) return;
-
 	/* Serach all connections, are there results from the resolver? */
 	for( idx = 0; idx < Pool_Size; idx++ )
 	{
@@ -1424,8 +1364,8 @@ Check_Servers( VOID )
 	/* Check all configured servers */
 	for( i = 0; i < MAX_SERVERS; i++ )
 	{
-		/* Valid outgoing server which isn't already connected? */
-		if(( ! Conf_Server[i].host[0] ) || ( ! Conf_Server[i].port > 0 ) || ( Conf_Server[i].conn_id > NONE )) continue;
+		/* 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;
 
 		/* Is there already a connection in this group? */
 		if( Conf_Server[i].group > NONE )
@@ -1451,7 +1391,9 @@ Check_Servers( VOID )
 			Log( LOG_ALERT, "Can't establist server connection: connection limit reached (%d)!", Pool_Size );
 			return;
 		}
+#ifdef DEBUG
 		Log( LOG_DEBUG, "Preparing connection %d for \"%s\" ...", idx, Conf_Server[i].host );
+#endif
 
 		/* Verbindungs-Struktur initialisieren */
 		Init_Conn_Struct( idx );
@@ -1474,7 +1416,7 @@ Check_Servers( VOID )
 LOCAL VOID
 New_Server( INT Server, CONN_ID Idx )
 {
-	/* Neue Server-Verbindung aufbauen */
+	/* Establish new server link */
 
 	struct sockaddr_in new_addr;
 	struct in_addr inaddr;
@@ -1484,11 +1426,12 @@ New_Server( INT Server, CONN_ID Idx )
 	assert( Server > NONE );
 	assert( Idx > NONE );
 
-	/* Wurde eine gueltige IP-Adresse gefunden? */
+	/* Did we get a valid IP address? */
 	if( ! Conf_Server[Server].ip[0] )
 	{
-		/* Nein. Verbindung wieder freigeben: */
+		/* No. Free connection structure and abort: */
 		Init_Conn_Struct( Idx );
+		Conf_Server[Server].conn_id = NONE;
 		Log( LOG_ERR, "Can't connect to \"%s\" (connection %d): ip address unknown!", Conf_Server[Server].host, Idx );
 		return;
 	}
@@ -1503,8 +1446,9 @@ New_Server( INT Server, CONN_ID Idx )
 	if( inaddr.s_addr == (unsigned)-1 )
 #endif
 	{
-		/* Konnte Adresse nicht konvertieren */
+		/* Can't convert IP address */
 		Init_Conn_Struct( Idx );
+		Conf_Server[Server].conn_id = NONE;
 		Log( LOG_ERR, "Can't connect to \"%s\" (connection %d): can't convert ip address %s!", Conf_Server[Server].host, Idx, Conf_Server[Server].ip );
 		return;
 	}
@@ -1517,7 +1461,9 @@ New_Server( INT Server, CONN_ID Idx )
 	new_sock = socket( PF_INET, SOCK_STREAM, 0 );
 	if ( new_sock < 0 )
 	{
+		/* Can't create socket */
 		Init_Conn_Struct( Idx );
+		Conf_Server[Server].conn_id = NONE;
 		Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
 		return;
 	}
@@ -1527,9 +1473,11 @@ New_Server( INT Server, CONN_ID Idx )
 	res = connect( new_sock, (struct sockaddr *)&new_addr, sizeof( new_addr ));
 	if(( res != 0 ) && ( errno != EINPROGRESS ))
 	{
+		/* Can't connect socket */
 		Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
 		close( new_sock );
 		Init_Conn_Struct( Idx );
+		Conf_Server[Server].conn_id = NONE;
 		return;
 	}
 
@@ -1537,25 +1485,29 @@ New_Server( INT Server, CONN_ID Idx )
 	c = Client_NewLocal( Idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWNSERVER, FALSE );
 	if( ! c )
 	{
+		/* Can't create new client structure */
 		close( new_sock );
 		Init_Conn_Struct( Idx );
+		Conf_Server[Server].conn_id = NONE;
 		Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
 		return;
 	}
 	Client_SetIntroducer( c, c );
 	Client_SetToken( c, TOKEN_OUTBOUND );
 
-	/* Verbindung registrieren */
+	/* Register connection */
 	My_Connections[Idx].sock = new_sock;
 	My_Connections[Idx].addr = new_addr;
 	strlcpy( My_Connections[Idx].host, Conf_Server[Server].host, sizeof( My_Connections[Idx].host ));
 
-	/* Neuen Socket registrieren */
+	/* Register new socket */
 	FD_SET( new_sock, &My_Sockets );
 	FD_SET( new_sock, &My_Connects );
 	if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
-	
+
+#ifdef DEBUG
 	Log( LOG_DEBUG, "Registered new connection %d on socket %d.", Idx, My_Connections[Idx].sock );
+#endif
 } /* New_Server */
 
 
@@ -1583,7 +1535,7 @@ Init_Conn_Struct( CONN_ID Idx )
 	My_Connections[Idx].flag = 0;
 	My_Connections[Idx].options = 0;
 
-#ifdef USE_ZLIB
+#ifdef ZLIB
 	My_Connections[Idx].zip.rbuf[0] = '\0';
 	My_Connections[Idx].zip.rdatalen = 0;
 	My_Connections[Idx].zip.wbuf[0] = '\0';
@@ -1631,34 +1583,38 @@ Read_Resolver_Result( INT r_fd )
 
 	FD_CLR( r_fd, &Resolver_FDs );
 
-	/* Anfrage vom Parent lesen */
+	/* Read result from pipe */
 	len = read( r_fd, result, HOST_LEN - 1 );
 	if( len < 0 )
 	{
-		/* Fehler beim Lesen aus der Pipe */
+		/* Error! */
 		close( r_fd );
 		Log( LOG_CRIT, "Resolver: Can't read result: %s!", strerror( errno ));
 		return;
 	}
 	result[len] = '\0';
 
-	/* zugehoerige Connection suchen */
+	/* Search associated connection ... */
 	for( i = 0; i < Pool_Size; i++ )
 	{
 		if(( My_Connections[i].sock != NONE ) && ( My_Connections[i].res_stat ) && ( My_Connections[i].res_stat->pipe[0] == r_fd )) break;
 	}
 	if( i >= Pool_Size )
 	{
-		/* Opsa! Keine passende Connection gefunden!? Vermutlich
-		 * wurde sie schon wieder geschlossen. */
+		/* Ops, none found? Probably the connection has already
+		 * been closed. */
 		close( r_fd );
+#ifdef DEBUG
 		Log( LOG_DEBUG, "Resolver: Got result for unknown connection!?" );
+#endif
 		return;
 	}
 
+#ifdef DEBUG
 	Log( LOG_DEBUG, "Resolver: %s is \"%s\".", My_Connections[i].host, result );
-	
-	/* Aufraeumen */
+#endif
+
+	/* Clean up ... */
 	close( My_Connections[i].res_stat->pipe[0] );
 	close( My_Connections[i].res_stat->pipe[1] );
 	free( My_Connections[i].res_stat );
@@ -1666,23 +1622,68 @@ Read_Resolver_Result( INT r_fd )
 
 	if( My_Connections[i].sock > NONE )
 	{
-		/* Eingehende Verbindung: Hostnamen setzen */
+#ifdef IDENTAUTH
+		CHAR *ident;
+#endif
+		/* Incoming connection: set hostname */
 		c = Client_GetFromConn( i );
 		assert( c != NULL );
 		strlcpy( My_Connections[i].host, result, sizeof( My_Connections[i].host ));
 		Client_SetHostname( c, result );
+
+#ifdef IDENTAUTH
+		ident = strchr( result, 0 );
+		ident++;
+
+		/* Do we have a result of the IDENT lookup? */
+		if( *ident )
+		{
+			Log( LOG_INFO, "IDENT lookup on connection %ld: \"%s\".", i, ident );
+			Client_SetUser( c, ident, TRUE );
+		}
+		else Log( LOG_INFO, "IDENT lookup on connection %ld: no result.", i );
+#endif
 	}
 	else
 	{
-		/* Ausgehende Verbindung (=Server): IP setzen */
+		/* Outgoing connection (server link!): set IP address */
 		n = Conf_GetServer( i );
 		if( n > NONE ) strlcpy( Conf_Server[n].ip, result, sizeof( Conf_Server[n].ip ));
 		else Log( LOG_ERR, "Got resolver result for non-configured server!?" );
 	}
 
-	/* Penalty-Zeit zurueck setzen */
+	/* Reset penalty time */
 	Conn_ResetPenalty( i );
 } /* Read_Resolver_Result */
 
 
+LOCAL VOID
+Simple_Message( INT Sock, CHAR *Msg )
+{
+	/* 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 );
+
+	(VOID)send( Sock, Msg, strlen( Msg ), 0 );
+	(VOID)send( Sock, "\r\n", 2, 0 );
+} /* Simple_Error */
+
+
+LOCAL INT
+Count_Connections( struct sockaddr_in addr_in )
+{
+	INT i, cnt;
+	
+	cnt = 0;
+	for( i = 0; i < Pool_Size; i++ )
+	{
+		if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].addr.sin_addr.s_addr == addr_in.sin_addr.s_addr )) cnt++;
+	}
+	return cnt;
+} /* Count_Connections */
+
+
 /* -eof- */