+
+ memset( &new_addr, 0, sizeof( new_addr ));
+ new_addr.sin_family = AF_INET;
+ new_addr.sin_addr = inaddr;
+ new_addr.sin_port = htons( Conf_Server[Server].port );
+
+ new_sock = socket( PF_INET, SOCK_STREAM, 0 );
+ if ( new_sock < 0 )
+ {
+ Init_Conn_Struct( Idx );
+ Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
+ return;
+ }
+
+ if( ! Init_Socket( new_sock )) return;
+
+ res = connect( new_sock, (struct sockaddr *)&new_addr, sizeof( new_addr ));
+ if(( res != 0 ) && ( errno != EINPROGRESS ))
+ {
+ Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
+ close( new_sock );
+ Init_Conn_Struct( Idx );
+ return;
+ }
+
+ /* Client-Struktur initialisieren */
+ c = Client_NewLocal( Idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWNSERVER, FALSE );
+ if( ! c )
+ {
+ close( new_sock );
+ Init_Conn_Struct( Idx );
+ Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
+ return;
+ }
+ Client_SetIntroducer( c, c );
+ Client_SetToken( c, TOKEN_OUTBOUND );
+
+ /* Verbindung registrieren */
+ 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 */
+ FD_SET( new_sock, &My_Sockets );
+ FD_SET( new_sock, &My_Connects );
+ if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
+
+ Log( LOG_DEBUG, "Registered new connection %d on socket %d.", Idx, My_Connections[Idx].sock );
+} /* New_Server */
+
+
+LOCAL VOID
+Init_Conn_Struct( CONN_ID Idx )
+{
+ /* Connection-Struktur initialisieren */
+
+ My_Connections[Idx].sock = NONE;
+ My_Connections[Idx].res_stat = NULL;
+ My_Connections[Idx].host[0] = '\0';
+ My_Connections[Idx].rbuf[0] = '\0';
+ My_Connections[Idx].rdatalen = 0;
+ My_Connections[Idx].wbuf[0] = '\0';
+ My_Connections[Idx].wdatalen = 0;
+ 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;
+
+#ifdef USE_ZLIB
+ My_Connections[Idx].zip.rbuf[0] = '\0';
+ My_Connections[Idx].zip.rdatalen = 0;
+ My_Connections[Idx].zip.wbuf[0] = '\0';
+ My_Connections[Idx].zip.wdatalen = 0;
+ My_Connections[Idx].zip.bytes_in = 0;
+ My_Connections[Idx].zip.bytes_out = 0;
+#endif
+} /* Init_Conn_Struct */
+
+
+LOCAL BOOLEAN
+Init_Socket( INT Sock )
+{
+ /* Socket-Optionen setzen */
+
+ INT on = 1;
+
+#ifdef O_NONBLOCK /* A/UX kennt das nicht? */
+ if( fcntl( Sock, F_SETFL, O_NONBLOCK ) != 0 )
+ {
+ Log( LOG_CRIT, "Can't enable non-blocking mode: %s!", strerror( errno ));
+ close( Sock );
+ return FALSE;
+ }
+#endif
+ if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &on, (socklen_t)sizeof( on )) != 0)
+ {
+ Log( LOG_ERR, "Can't set socket options: %s!", strerror( errno ));
+ /* dieser Fehler kann ignoriert werden. */
+ }
+
+ return TRUE;
+} /* Init_Socket */
+
+
+LOCAL VOID
+Read_Resolver_Result( INT r_fd )
+{
+ /* Ergebnis von Resolver Sub-Prozess aus Pipe lesen
+ * und entsprechende Connection aktualisieren */
+
+ CHAR result[HOST_LEN];
+ CLIENT *c;
+ INT len, i, n;
+
+ FD_CLR( r_fd, &Resolver_FDs );
+
+ /* Anfrage vom Parent lesen */
+ len = read( r_fd, result, HOST_LEN - 1 );
+ if( len < 0 )
+ {
+ /* Fehler beim Lesen aus der Pipe */
+ close( r_fd );
+ Log( LOG_CRIT, "Resolver: Can't read result: %s!", strerror( errno ));
+ return;
+ }
+ result[len] = '\0';
+
+ /* zugehoerige Connection suchen */
+ 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. */
+ close( r_fd );
+ Log( LOG_DEBUG, "Resolver: Got result for unknown connection!?" );
+ return;
+ }
+
+ Log( LOG_DEBUG, "Resolver: %s is \"%s\".", My_Connections[i].host, result );
+
+ /* Aufraeumen */
+ close( My_Connections[i].res_stat->pipe[0] );
+ close( My_Connections[i].res_stat->pipe[1] );
+ free( My_Connections[i].res_stat );
+ My_Connections[i].res_stat = NULL;
+
+ if( My_Connections[i].sock > NONE )
+ {
+ /* Eingehende Verbindung: Hostnamen setzen */
+ c = Client_GetFromConn( i );
+ assert( c != NULL );
+ strlcpy( My_Connections[i].host, result, sizeof( My_Connections[i].host ));
+ Client_SetHostname( c, result );
+ }
+ else
+ {
+ /* Ausgehende Verbindung (=Server): IP setzen */
+ 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 */
+ Conn_ResetPenalty( i );
+} /* Read_Resolver_Result */