+ if( My_Connections[i].sock == NONE ) continue;
+
+ c = Client_GetFromConn( i );
+ if( c && (( Client_Type( c ) == CLIENT_USER ) || ( Client_Type( c ) == CLIENT_SERVER ) || ( Client_Type( c ) == CLIENT_SERVICE )))
+ {
+ /* verbundener User, Server oder Service */
+ if( My_Connections[i].lastping > My_Connections[i].lastdata )
+ {
+ /* es wurde bereits ein PING gesendet */
+ if( My_Connections[i].lastping < time( NULL ) - Conf_PongTimeout )
+ {
+ /* Timeout */
+ Log( LOG_DEBUG, "Connection %d: Ping timeout: %d seconds.", i, Conf_PongTimeout );
+ Conn_Close( i, NULL, "Ping timeout", TRUE );
+ }
+ }
+ else if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
+ {
+ /* es muss ein PING gesendet werden */
+ Log( LOG_DEBUG, "Connection %d: sending PING ...", i );
+ My_Connections[i].lastping = time( NULL );
+ Conn_WriteStr( i, "PING :%s", Client_ID( Client_ThisServer( )));
+ }
+ }
+ else
+ {
+ /* noch nicht vollstaendig aufgebaute Verbindung */
+ if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
+ {
+ /* Timeout */
+ Log( LOG_DEBUG, "Connection %d timed out ...", i );
+ Conn_Close( i, NULL, "Timeout", FALSE );
+ }
+ }
+ }
+} /* Check_Connections */
+
+
+LOCAL VOID
+Check_Servers( VOID )
+{
+ /* Check if we can establish further server links */
+
+ RES_STAT *s;
+ CONN_ID idx;
+ INT i, n;
+
+ /* Serach all connections, are there results from the resolver? */
+ for( idx = 0; idx < Pool_Size; idx++ )
+ {
+ if( My_Connections[idx].sock != SERVER_WAIT ) continue;
+
+ /* IP resolved? */
+ if( My_Connections[idx].res_stat == NULL ) New_Server( Conf_GetServer( idx ), idx );
+ }
+
+ /* 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;
+
+ /* Is there already a connection in this group? */
+ if( Conf_Server[i].group > NONE )
+ {
+ for( n = 0; n < MAX_SERVERS; n++ )
+ {
+ if( n == i ) continue;
+ if(( Conf_Server[n].conn_id > NONE ) && ( Conf_Server[n].group == Conf_Server[i].group )) break;
+ }
+ if( n < MAX_SERVERS ) continue;
+ }
+
+ /* Check last connect attempt? */
+ if( Conf_Server[i].lasttry > time( NULL ) - Conf_ConnectRetry ) continue;
+
+ /* Okay, try to connect now */
+ Conf_Server[i].lasttry = time( NULL );
+
+ /* Search free connection structure */
+ for( idx = 0; idx < Pool_Size; idx++ ) if( My_Connections[idx].sock == NONE ) break;
+ if( idx >= Pool_Size )
+ {
+ Log( LOG_ALERT, "Can't establist server connection: connection limit reached (%d)!", Pool_Size );
+ return;
+ }
+ Log( LOG_DEBUG, "Preparing connection %d for \"%s\" ...", idx, Conf_Server[i].host );
+
+ /* Verbindungs-Struktur initialisieren */
+ Init_Conn_Struct( idx );
+ My_Connections[idx].sock = SERVER_WAIT;
+ Conf_Server[i].conn_id = idx;
+
+ /* Resolve Hostname. If this fails, try to use it as an IP address */
+ strlcpy( Conf_Server[i].ip, Conf_Server[i].host, sizeof( Conf_Server[i].ip ));
+ strlcpy( My_Connections[idx].host, Conf_Server[i].host, sizeof( My_Connections[idx].host ));
+ s = Resolve_Name( Conf_Server[i].host );
+ if( s )
+ {
+ /* Sub-Prozess wurde asyncron gestartet */
+ My_Connections[idx].res_stat = s;
+ }
+ }
+} /* Check_Servers */
+
+
+LOCAL VOID
+New_Server( INT Server, CONN_ID Idx )
+{
+ /* Neue Server-Verbindung aufbauen */
+
+ struct sockaddr_in new_addr;
+ struct in_addr inaddr;
+ INT res, new_sock;
+ CLIENT *c;
+
+ assert( Server > NONE );
+ assert( Idx > NONE );
+
+ /* Wurde eine gueltige IP-Adresse gefunden? */
+ if( ! Conf_Server[Server].ip[0] )
+ {
+ /* Nein. Verbindung wieder freigeben: */
+ Init_Conn_Struct( Idx );
+ Log( LOG_ERR, "Can't connect to \"%s\" (connection %d): ip address unknown!", Conf_Server[Server].host, Idx );