* ngIRCd -- The Next Generation IRC Daemon
* Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
*
- * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
- * der GNU General Public License (GPL), wie von der Free Software Foundation
- * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
- * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
- * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
- * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * Please read the file COPYING, README and AUTHORS for more information.
*
- * $Id: conn.c,v 1.97 2002/11/28 12:17:38 alex Exp $
- *
- * connect.h: Verwaltung aller Netz-Verbindungen ("connections")
+ * Connection management
*/
#include "portab.h"
+static char UNUSED id[] = "$Id: conn.c,v 1.106 2002/12/18 13:50:22 alex Exp $";
+
#include "imp.h"
#include <assert.h>
#include <stdarg.h>
CHAR wbuf[WRITEBUFFER_LEN]; /* Schreibpuffer */
INT wdatalen; /* Laenge der Daten im Schreibpuffer */
INT our_server; /* wenn von uns zu connectender Server: ID */
+ time_t starttime; /* Startzeit des Links */
time_t lastdata; /* Letzte Aktivitaet */
time_t lastping; /* Letzter PING */
time_t lastprivmsg; /* Letzte PRIVMSG */
time_t delaytime; /* Nicht beachten bis ("penalty") */
- LONG bytes_in, bytes_out; /* Counter fuer Statistik */
+ LONG bytes_in, bytes_out; /* Empfangene uns gesendete Bytes */
+ LONG msg_in, msg_out; /* Empfangene uns gesendete Nachtichten */
INT flag; /* "Markierungs-Flag" (vgl. "irc-write"-Modul) */
INT options; /* Link-Optionen */
#ifdef USE_ZLIB
LOCAL fd_set My_Connects;
LOCAL CONNECTION *My_Connections;
-LOCAL LONG Pool_Size;
+LOCAL LONG Pool_Size, WCounter;
GLOBAL VOID
Log( LOG_EMERG, "Can't allocate memory! [Conn_Init]" );
exit( 1 );
}
- Log( LOG_DEBUG, "Allocted connection pool for %ld items.", Pool_Size );
+ Log( LOG_DEBUG, "Allocted connection pool for %ld items (%ld bytes).", Pool_Size, sizeof( CONNECTION ) * Pool_Size );
/* zu Beginn haben wir keine Verbindungen */
FD_ZERO( &My_Listeners );
/* Connection-Struktur initialisieren */
for( i = 0; i < Pool_Size; i++ ) Init_Conn_Struct( i );
+
+ /* Global write counter */
+ WCounter = 0;
} /* Conn_Init */
strcat( buffer, "\r\n" );
ok = Conn_Write( Idx, buffer, strlen( buffer ));
+ My_Connections[Idx].msg_out++;
va_end( ap );
return ok;
My_Connections[Idx].bytes_out += Len;
}
+ /* Adjust global write counter */
+ WCounter += Len;
+
return TRUE;
} /* Conn_Write */
if( InformClient )
{
+#ifndef STRICT_RFC
/* Statistik an Client melden, wenn User */
if(( c != NULL ) && ( Client_Type( c ) == CLIENT_USER ))
{
Conn_WriteStr( Idx, "NOTICE %s :%sConnection statistics: client %.1f kb, server %.1f kb.", Client_ThisServer( ), NOTICE_TXTPREFIX, (DOUBLE)My_Connections[Idx].bytes_in / 1024, (DOUBLE)My_Connections[Idx].bytes_out / 1024 );
}
+#endif
/* ERROR an Client schicken (von RFC so vorgesehen!) */
if( FwdMsg ) Conn_WriteStr( Idx, "ERROR :%s", FwdMsg );
if( My_Connections[Idx].sock == NONE ) return;
}
+ /* zunaechst versuchen, noch im Schreibpuffer vorhandene
+ * Daten auf den Socket zu schreiben ... */
+ Try_Write( Idx );
+
if( close( My_Connections[Idx].sock ) != 0 )
{
Log( LOG_ERR, "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 ));
out_z_k = (DOUBLE)My_Connections[Idx].zip.bytes_out / 1024;
in_p = (INT)(( in_k * 100 ) / in_z_k );
out_p = (INT)(( out_k * 100 ) / out_z_k );
- Log( LOG_INFO, "Connection %d (socket %d) with %s:%d closed (in: %.1fk/%.1fk/%d%%, out: %.1fk/%.1fk/%d%%).", Idx, My_Connections[Idx].sock, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port ), in_k, in_z_k, in_p, out_k, out_z_k, out_p );
+ Log( LOG_INFO, "Connection %d with %s:%d closed (in: %.1fk/%.1fk/%d%%, out: %.1fk/%.1fk/%d%%).", Idx, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port ), in_k, in_z_k, in_p, out_k, out_z_k, out_p );
}
else
#endif
{
- Log( LOG_INFO, "Connection %d (socket %d) with %s:%d closed (in: %.1fk, out: %.1fk).", Idx, My_Connections[Idx].sock, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port ), in_k, out_k );
+ Log( LOG_INFO, "Connection %d with %s:%d closed (in: %.1fk, out: %.1fk).", Idx, My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port ), in_k, out_k );
}
}
return TRUE;
} /* Conn_InitZip */
+
+GLOBAL LONG
+Conn_SendBytesZip( CONN_ID Idx )
+{
+ /* Anzahl gesendeter Bytes (komprimiert!) liefern */
+
+ assert( Idx > NONE );
+ return My_Connections[Idx].zip.bytes_out;
+} /* Conn_SendBytesZip */
+
+
+GLOBAL LONG
+Conn_RecvBytesZip( CONN_ID Idx )
+{
+ /* Anzahl gesendeter Bytes (komprimiert!) liefern */
+
+ assert( Idx > NONE );
+ return My_Connections[Idx].zip.bytes_in;
+} /* Conn_RecvBytesZip */
+
+#endif
+
+
+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 */
LOCAL BOOLEAN
Try_Write( CONN_ID Idx )
{
- /* Versuchen, Daten aus dem Schreib-Puffer in den
- * Socket zu schreiben. */
+ /* Versuchen, Daten aus dem Schreib-Puffer in den Socket zu
+ * schreiben. TRUE wird geliefert, wenn entweder keine Daten
+ * zum Versenden vorhanden sind oder erfolgreich bearbeitet
+ * werden konnten. Im Fehlerfall wird FALSE geliefert und
+ * die Verbindung geschlossen. */
fd_set write_socket;
struct timeval tv;
assert( Idx > NONE );
assert( My_Connections[Idx].sock > NONE );
- assert( My_Connections[Idx].wdatalen > 0 );
+
+ /* sind ueberhaupt Daten vorhanden? */
+#ifdef USE_ZLIB
+ if(( ! My_Connections[Idx].wdatalen > 0 ) && ( ! My_Connections[Idx].zip.wdatalen )) return TRUE;
+#else
+ if( ! My_Connections[Idx].wdatalen > 0 ) return TRUE;
+#endif
/* Timeout initialisieren: 0 Sekunden, also nicht blockieren */
tv.tv_sec = 0; tv.tv_usec = 0;
/* Struktur umkopieren ... */
memcpy( ptr, My_Connections, sizeof( CONNECTION ) * Pool_Size );
- Log( LOG_DEBUG, "Allocated new connection pool for %ld items. [malloc()/memcpy()]", new_size );
+ Log( LOG_DEBUG, "Allocated new connection pool for %ld items (%ld bytes). [malloc()/memcpy()]", new_size, sizeof( CONNECTION ) * new_size );
}
- else Log( LOG_DEBUG, "Allocated new connection pool for %ld items. [realloc()]", new_size );
+ else Log( LOG_DEBUG, "Allocated new connection pool for %ld items (%ld bytes). [realloc()]", new_size, sizeof( CONNECTION ) * new_size );
+ /* 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;
}
if( s )
{
/* Sub-Prozess wurde asyncron gestartet */
- Conn_WriteStr( idx, "NOTICE AUTH :%sLooking up your hostname ...", NOTICE_TXTPREFIX );
My_Connections[idx].res_stat = s;
}
* Tritt ein Fehler auf, so wird der Socket geschlossen. */
INT len, bsize;
+#ifdef USE_ZLIB
CLIENT *c;
+#endif
assert( Idx > NONE );
assert( My_Connections[Idx].sock > NONE );
if( len == 0 )
{
/* Socket wurde geschlossen */
- Log( LOG_INFO, "%s:%d is closing the connection ...", inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port));
+ Log( LOG_INFO, "%s:%d (%s) is closing the connection ...", My_Connections[Idx].host, ntohs( My_Connections[Idx].addr.sin_port), inet_ntoa( My_Connections[Idx].addr.sin_addr ));
Conn_Close( Idx, "Socket closed!", "Client closed connection", FALSE );
return;
}
if( len > delta )
{
/* Es wurde ein Request gelesen */
+ My_Connections[Idx].msg_in++;
if( ! Parse_Request( Idx, My_Connections[Idx].rbuf )) return FALSE;
else action = TRUE;
}
My_Connections[Idx].wbuf[0] = '\0';
My_Connections[Idx].wdatalen = 0;
My_Connections[Idx].our_server = NONE;
+ My_Connections[Idx].starttime = time( NULL );
My_Connections[Idx].lastdata = time( NULL );
My_Connections[Idx].lastping = 0;
My_Connections[Idx].lastprivmsg = time( NULL );
My_Connections[Idx].delaytime = 0;
My_Connections[Idx].bytes_in = 0;
My_Connections[Idx].bytes_out = 0;
+ My_Connections[Idx].msg_in = 0;
+ My_Connections[Idx].msg_out = 0;
My_Connections[Idx].flag = 0;
My_Connections[Idx].options = 0;
assert( c != NULL );
strcpy( My_Connections[i].host, result );
Client_SetHostname( c, result );
-
- Conn_WriteStr( i, "NOTICE AUTH :%sGot your hostname.", NOTICE_TXTPREFIX );
}
else
{