Made on IRCNow

Blob

Date:: Thu Sep 26 15:59:02 2002 UTC
Message:: - Conn_Write() prueft nun, ob der Socket noch offen ist, ehe Daten gesendet werden.
Actions:: History | Blame | Raw File
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
4  *
5  * Dieses Programm ist freie Software. Sie koennen es unter den Bedingungen
6  * der GNU General Public License (GPL), wie von der Free Software Foundation
7  * herausgegeben, weitergeben und/oder modifizieren, entweder unter Version 2
8  * der Lizenz oder (wenn Sie es wuenschen) jeder spaeteren Version.
9  * Naehere Informationen entnehmen Sie bitter der Datei COPYING. Eine Liste
10  * der an ngIRCd beteiligten Autoren finden Sie in der Datei AUTHORS.
11  *
12  * $Id: conn.c,v 1.73 2002/09/26 15:59:02 alex Exp $
13  *
14  * connect.h: Verwaltung aller Netz-Verbindungen ("connections")
15  */
16 
17 
18 #include "portab.h"
19 
20 #include "imp.h"
21 #include <assert.h>
22 #include <stdarg.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <string.h>
29 #include <sys/socket.h>
30 #include <sys/time.h>
31 #include <sys/types.h>
32 #include <time.h>
33 #include <netinet/in.h>
34 
35 #ifdef HAVE_ARPA_INET_H
36 #include <arpa/inet.h>
37 #else
38 #define PF_INET AF_INET
39 #endif
40 
41 #ifdef HAVE_STDINT_H
42 #include <stdint.h>			/* u.a. fuer Mac OS X */
43 #endif
44 
45 #include "exp.h"
46 #include "conn.h"
47 
48 #include "imp.h"
49 #include "ngircd.h"
50 #include "client.h"
51 #include "resolve.h"
52 #include "conf.h"
53 #include "log.h"
54 #include "parse.h"
55 #include "tool.h"
56 
57 #include "exp.h"
58 
59 
60 #define SERVER_WAIT (NONE - 1)
61 
62 
63 typedef struct _Connection
64 {
65 	INT sock;			/* Socket Handle */
66 	struct sockaddr_in addr;	/* Adresse des Client */
67 	RES_STAT *res_stat;		/* "Resolver-Status", s.o. */
68 	CHAR host[HOST_LEN];		/* Hostname */
69 	CHAR rbuf[READBUFFER_LEN];	/* Lesepuffer */
70 	INT rdatalen;			/* Laenge der Daten im Lesepuffer */
71 	CHAR wbuf[WRITEBUFFER_LEN];	/* Schreibpuffer */
72 	INT wdatalen;			/* Laenge der Daten im Schreibpuffer */
73 	INT our_server;			/* wenn von uns zu connectender Server: ID */
74 	time_t lastdata;		/* Letzte Aktivitaet */
75 	time_t lastping;		/* Letzter PING */
76 	time_t lastprivmsg;		/* Letzte PRIVMSG */
77 	time_t delaytime;		/* Nicht beachten bis ("penalty") */
78 } CONNECTION;
79 
80 
81 LOCAL VOID Handle_Read PARAMS(( INT sock ));
82 LOCAL BOOLEAN Handle_Write PARAMS(( CONN_ID Idx ));
83 LOCAL VOID New_Connection PARAMS(( INT Sock ));
84 LOCAL CONN_ID Socket2Index PARAMS(( INT Sock ));
85 LOCAL VOID Read_Request PARAMS(( CONN_ID Idx ));
86 LOCAL BOOLEAN Try_Write PARAMS(( CONN_ID Idx ));
87 LOCAL VOID Handle_Buffer PARAMS(( CONN_ID Idx ));
88 LOCAL VOID Check_Connections PARAMS(( VOID ));
89 LOCAL VOID Check_Servers PARAMS(( VOID ));
90 LOCAL VOID Init_Conn_Struct PARAMS(( INT Idx ));
91 LOCAL BOOLEAN Init_Socket PARAMS(( INT Sock ));
92 LOCAL VOID New_Server PARAMS(( INT Server, CONN_ID Idx ));
93 LOCAL VOID Read_Resolver_Result PARAMS(( INT r_fd ));
94 
95 
96 LOCAL fd_set My_Listeners;
97 LOCAL fd_set My_Sockets;
98 LOCAL fd_set My_Connects;
99 
100 LOCAL CONNECTION My_Connections[MAX_CONNECTIONS];
101 
102 
103 GLOBAL VOID
104 Conn_Init( VOID )
105 {
106 	/* Modul initialisieren: statische Strukturen "ausnullen". */
107 
108 	CONN_ID i;
109 
110 	/* zu Beginn haben wir keine Verbindungen */
111 	FD_ZERO( &My_Listeners );
112 	FD_ZERO( &My_Sockets );
113 	FD_ZERO( &My_Connects );
114 
115 	Conn_MaxFD = 0;
116 
117 	/* Connection-Struktur initialisieren */
118 	for( i = 0; i < MAX_CONNECTIONS; i++ ) Init_Conn_Struct( i );
119 } /* Conn_Init */
120 
121 
122 GLOBAL VOID
123 Conn_Exit( VOID )
124 {
125 	/* Modul abmelden: alle noch offenen Connections
126 	 * schliessen und freigeben. */
127 
128 	CONN_ID idx;
129 	INT i;
130 
131 	/* Sockets schliessen */
132 	Log( LOG_DEBUG, "Shutting down all connections ..." );
133 	for( i = 0; i < Conn_MaxFD + 1; i++ )
134 	{
135 		if( FD_ISSET( i, &My_Sockets ))
136 		{
137 			for( idx = 0; idx < MAX_CONNECTIONS; idx++ )
138 			{
139 				if( My_Connections[idx].sock == i ) break;
140 			}
141 			if( FD_ISSET( i, &My_Listeners ))
142 			{
143 				close( i );
144 				Log( LOG_DEBUG, "Listening socket %d closed.", i );
145 			}
146 			else if( FD_ISSET( i, &My_Connects ))
147 			{
148 				close( i );
149 				Log( LOG_DEBUG, "Connection %d closed during creation (socket %d).", idx, i );
150 			}
151 			else if( idx < MAX_CONNECTIONS )
152 			{
153 				if( NGIRCd_Restart ) Conn_Close( idx, NULL, "Server going down (restarting)", TRUE );
154 				else Conn_Close( idx, NULL, "Server going down", TRUE );
155 			}
156 			else
157 			{
158 				Log( LOG_WARNING, "Closing unknown connection %d ...", i );
159 				close( i );
160 			}
161 		}
162 	}
163 } /* Conn_Exit */
164 
165 
166 GLOBAL BOOLEAN
167 Conn_NewListener( CONST UINT Port )
168 {
169 	/* Neuen Listen-Socket erzeugen: der Server wartet dann auf
170 	 * dem angegebenen Port auf Verbindungen. Kann der Listen-
171 	 * Socket nicht erteugt werden, so wird NULL geliefert.*/
172 
173 	struct sockaddr_in addr;
174 	INT sock;
175 
176 	/* Server-"Listen"-Socket initialisieren */
177 	memset( &addr, 0, sizeof( addr ));
178 	addr.sin_family = AF_INET;
179 	addr.sin_port = htons( Port );
180 	addr.sin_addr.s_addr = htonl( INADDR_ANY );
181 
182 	/* Socket erzeugen */
183 	sock = socket( PF_INET, SOCK_STREAM, 0);
184 	if( sock < 0 )
185 	{
186 		Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
187 		return FALSE;
188 	}
189 
190 	if( ! Init_Socket( sock )) return FALSE;
191 
192 	/* an Port binden */
193 	if( bind( sock, (struct sockaddr *)&addr, (socklen_t)sizeof( addr )) != 0 )
194 	{
195 		Log( LOG_CRIT, "Can't bind socket: %s!", strerror( errno ));
196 		close( sock );
197 		return FALSE;
198 	}
199 
200 	/* in "listen mode" gehen :-) */
201 	if( listen( sock, 10 ) != 0 )
202 	{
203 		Log( LOG_CRIT, "Can't listen on soecket: %s!", strerror( errno ));
204 		close( sock );
205 		return FALSE;
206 	}
207 
208 	/* Neuen Listener in Strukturen einfuegen */
209 	FD_SET( sock, &My_Listeners );
210 	FD_SET( sock, &My_Sockets );
211 
212 	if( sock > Conn_MaxFD ) Conn_MaxFD = sock;
213 
214 	Log( LOG_INFO, "Now listening on port %d (socket %d).", Port, sock );
215 
216 	return TRUE;
217 } /* Conn_NewListener */
218 
219 
220 GLOBAL VOID
221 Conn_Handler( VOID )
222 {
223 	/* "Hauptschleife": Aktive Verbindungen ueberwachen. Folgende Aktionen
224 	 * werden dabei durchgefuehrt, bis der Server terminieren oder neu
225 	 * starten soll:
226 	 *
227 	 *  - neue Verbindungen annehmen,
228 	 *  - Server-Verbindungen aufbauen,
229 	 *  - geschlossene Verbindungen loeschen,
230 	 *  - volle Schreibpuffer versuchen zu schreiben,
231 	 *  - volle Lesepuffer versuchen zu verarbeiten,
232 	 *  - Antworten von Resolver Sub-Prozessen annehmen.
233 	 */
234 
235 	fd_set read_sockets, write_sockets;
236 	struct timeval tv;
237 	time_t start, t;
238 	INT i;
239 
240 	start = time( NULL );
241 	while(( ! NGIRCd_Quit ) && ( ! NGIRCd_Restart ))
242 	{
243 		Check_Servers( );
244 
245 		Check_Connections( );
246 
247 		/* noch volle Lese-Buffer suchen */
248 		for( i = 0; i < MAX_CONNECTIONS; i++ )
249 		{
250 			if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].rdatalen > 0 ))
251 			{
252 				/* Kann aus dem Buffer noch ein Befehl extrahiert werden? */
253 				Handle_Buffer( i );
254 			}
255 		}
256 
257 		/* noch volle Schreib-Puffer suchen */
258 		FD_ZERO( &write_sockets );
259 		for( i = 0; i < MAX_CONNECTIONS; i++ )
260 		{
261 			if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].wdatalen > 0 ))
262 			{
263 				/* Socket der Verbindung in Set aufnehmen */
264 				FD_SET( My_Connections[i].sock, &write_sockets );
265 			}
266 		}
267 		/* Sockets mit im Aufbau befindlichen ausgehenden Verbindungen suchen */
268 		for( i = 0; i < MAX_CONNECTIONS; i++ )
269 		{
270 			if(( My_Connections[i].sock > NONE ) && ( FD_ISSET( My_Connections[i].sock, &My_Connects ))) FD_SET( My_Connections[i].sock, &write_sockets );
271 		}
272 
273 		/* von welchen Sockets koennte gelesen werden? */
274 		t = time( NULL );
275 		read_sockets = My_Sockets;
276 		for( i = 0; i < MAX_CONNECTIONS; i++ )
277 		{
278 			if(( My_Connections[i].sock > NONE ) && ( My_Connections[i].host[0] == '\0' ))
279 			{
280 				/* Hier muss noch auf den Resolver Sub-Prozess gewartet werden */
281 				FD_CLR( My_Connections[i].sock, &read_sockets );
282 			}
283 			if(( My_Connections[i].sock > NONE ) && ( FD_ISSET( My_Connections[i].sock, &My_Connects )))
284 			{
285 				/* Hier laeuft noch ein asyncrones connect() */
286 				FD_CLR( My_Connections[i].sock, &read_sockets );
287 			}
288 			if( My_Connections[i].delaytime > t )
289 			{
290 				/* Fuer die Verbindung ist eine "Penalty-Zeit" gesetzt */
291 				FD_CLR( My_Connections[i].sock, &read_sockets );
292 				FD_CLR( My_Connections[i].sock, &write_sockets );
293 			}
294 		}
295 		for( i = 0; i < Conn_MaxFD + 1; i++ )
296 		{
297 			/* Pipes von Resolver Sub-Prozessen aufnehmen */
298 			if( FD_ISSET( i, &Resolver_FDs ))
299 			{
300 				FD_SET( i, &read_sockets );
301 			}
302 		}
303 
304 		/* Timeout initialisieren */
305 		tv.tv_sec = 1;
306 		tv.tv_usec = 0;
307 		
308 		/* Auf Aktivitaet warten */
309 		i = select( Conn_MaxFD + 1, &read_sockets, &write_sockets, NULL, &tv );
310 		if( i == 0 )
311 		{
312 			/* keine Veraenderung an den Sockets */
313 			continue;
314 		}
315 		if( i == -1 )
316 		{
317 			/* Fehler (z.B. Interrupt) */
318 			if( errno != EINTR )
319 			{
320 				Log( LOG_EMERG, "select(): %s!", strerror( errno ));
321 				Log( LOG_ALERT, "%s exiting due to fatal errors!", PACKAGE );
322 				exit( 1 );
323 			}
324 			continue;
325 		}
326 
327 		/* Koennen Daten geschrieben werden? */
328 		for( i = 0; i < Conn_MaxFD + 1; i++ )
329 		{
330 			if( FD_ISSET( i, &write_sockets )) Handle_Write( Socket2Index( i ));
331 		}
332 
333 		/* Daten zum Lesen vorhanden? */
334 		for( i = 0; i < Conn_MaxFD + 1; i++ )
335 		{
336 			if( FD_ISSET( i, &read_sockets )) Handle_Read( i );
337 		}
338 	}
339 } /* Conn_Handler */
340 
341 
342 #ifdef PROTOTYPES
343 GLOBAL BOOLEAN
344 Conn_WriteStr( CONN_ID Idx, CHAR *Format, ... )
345 #else
346 GLOBAL BOOLEAN
347 Conn_WriteStr( Idx, Format, va_alist )
348 CONN_ID Idx;
349 CHAR *Format;
350 va_dcl
351 #endif
352 {
353 	/* String in Socket schreiben. CR+LF wird von dieser Funktion
354 	 * automatisch angehaengt. Im Fehlerfall wird dir Verbindung
355 	 * getrennt und FALSE geliefert. */
356 
357 	CHAR buffer[COMMAND_LEN];
358 	BOOLEAN ok;
359 	va_list ap;
360 
361 	assert( Idx >= 0 );
362 	assert( Format != NULL );
363 
364 #ifdef PROTOTYPES
365 	va_start( ap, Format );
366 #else
367 	va_start( ap );
368 #endif
369 	if( vsnprintf( buffer, COMMAND_LEN - 2, Format, ap ) == COMMAND_LEN - 2 )
370 	{
371 		Log( LOG_CRIT, "Text too long to send (connection %d)!", Idx );
372 		Conn_Close( Idx, "Text too long to send!", NULL, FALSE );
373 		return FALSE;
374 	}
375 
376 #ifdef SNIFFER
377 	if( NGIRCd_Sniffer ) Log( LOG_DEBUG, " -> connection %d: '%s'.", Idx, buffer );
378 #endif
379 
380 	strcat( buffer, "\r\n" );
381 	ok = Conn_Write( Idx, buffer, strlen( buffer ));
382 
383 	va_end( ap );
384 	return ok;
385 } /* Conn_WriteStr */
386 
387 
388 GLOBAL BOOLEAN
389 Conn_Write( CONN_ID Idx, CHAR *Data, INT Len )
390 {
391 	/* Daten in Socket schreiben. Bei "fatalen" Fehlern wird
392 	 * der Client disconnectiert und FALSE geliefert. */
393 
394 	assert( Idx >= 0 );
395 	assert( Data != NULL );
396 	assert( Len > 0 );
397 
398 	/* Ist der entsprechende Socket ueberhaupt noch offen?
399 	 * In einem "Handler-Durchlauf" kann es passieren, dass
400 	 * dem nicht mehr so ist, wenn einer von mehreren
401 	 * Conn_Write()'s fehlgeschlagen ist. In diesem Fall
402 	 * wird hier einfach ein Fehler geliefert. */
403 	if( ! My_Connections[Idx].sock > NONE )
404 	{
405 		Log( LOG_DEBUG, "Skipped write on closed socket (connection %d).", Idx );
406 		return FALSE;
407 	}
408 
409 	/* pruefen, ob Daten im Schreibpuffer sind. Wenn ja, zunaechst
410 	 * pruefen, ob diese gesendet werden koennen */
411 	if( My_Connections[Idx].wdatalen > 0 )
412 	{
413 		if( ! Try_Write( Idx )) return FALSE;
414 	}
415 
416 	/* pruefen, ob im Schreibpuffer genuegend Platz ist */
417 	if( WRITEBUFFER_LEN - My_Connections[Idx].wdatalen - Len <= 0 )
418 	{
419 		/* der Puffer ist dummerweise voll ... */
420 		Log( LOG_NOTICE, "Write buffer overflow (connection %d)!", Idx );
421 		Conn_Close( Idx, "Write buffer overflow!", NULL, FALSE );
422 		return FALSE;
423 	}
424 
425 	/* Daten in Puffer kopieren */
426 	memcpy( My_Connections[Idx].wbuf + My_Connections[Idx].wdatalen, Data, Len );
427 	My_Connections[Idx].wdatalen += Len;
428 
429 	/* pruefen, on Daten vorhanden sind und geschrieben werden koennen */
430 	if( My_Connections[Idx].wdatalen > 0 )
431 	{
432 		if( ! Try_Write( Idx )) return FALSE;
433 	}
434 
435 	return TRUE;
436 } /* Conn_Write */
437 
438 
439 GLOBAL VOID
440 Conn_Close( CONN_ID Idx, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN InformClient )
441 {
442 	/* Verbindung schliessen. Evtl. noch von Resolver
443 	 * Sub-Prozessen offene Pipes werden geschlossen. */
444 
445 	CLIENT *c;
446 
447 	assert( Idx >= 0 );
448 	assert( My_Connections[Idx].sock > NONE );
449 
450 	if( InformClient )
451 	{
452 		if( FwdMsg ) Conn_WriteStr( Idx, "ERROR :%s", FwdMsg );
453 		else Conn_WriteStr( Idx, "ERROR :Closing connection." );
454 		if( My_Connections[Idx].sock == NONE ) return;
455 	}
456 
457 	if( close( My_Connections[Idx].sock ) != 0 )
458 	{
459 		Log( LOG_ERR, "Error closing connection %d with %s:%d - %s!", Idx, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port), strerror( errno ));
460 	}
461 	else
462 	{
463 		Log( LOG_INFO, "Connection %d with %s:%d closed.", Idx, inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port ));
464 	}
465 
466 	c = Client_GetFromConn( Idx );
467 	if( c ) Client_Destroy( c, LogMsg, FwdMsg, TRUE );
468 
469 	if( My_Connections[Idx].res_stat )
470 	{
471 		/* Resolver-Strukturen freigeben, wenn noch nicht geschehen */
472 		FD_CLR( My_Connections[Idx].res_stat->pipe[0], &Resolver_FDs );
473 		close( My_Connections[Idx].res_stat->pipe[0] );
474 		close( My_Connections[Idx].res_stat->pipe[1] );
475 		free( My_Connections[Idx].res_stat );
476 	}
477 
478 	/* Bei Server-Verbindungen lasttry-Zeitpunkt so setzen, dass
479 	 * der naechste Verbindungsversuch in RECONNECT_DELAY Sekunden
480 	 * gestartet wird. */
481 	if(( My_Connections[Idx].our_server >= 0 ) && ( Conf_Server[My_Connections[Idx].our_server].lasttry <  time( NULL )))
482 	{
483 		/* Okay, die Verbindung stand schon "genuegend lange" */
484 		Conf_Server[My_Connections[Idx].our_server].lasttry = time( NULL ) - Conf_ConnectRetry + RECONNECT_DELAY;
485 	}
486 
487 	FD_CLR( My_Connections[Idx].sock, &My_Sockets );
488 	FD_CLR( My_Connections[Idx].sock, &My_Connects );
489 	My_Connections[Idx].sock = NONE;
490 } /* Conn_Close */
491 
492 
493 GLOBAL VOID
494 Conn_UpdateIdle( CONN_ID Idx )
495 {
496 	/* Idle-Timer zuruecksetzen */
497 
498 	assert( Idx >= 0 );
499 	My_Connections[Idx].lastprivmsg = time( NULL );
500 }
501 
502 
503 GLOBAL time_t
504 Conn_GetIdle( CONN_ID Idx )
505 {
506 	/* Idle-Time einer Verbindung liefern (in Sekunden) */
507 
508 	assert( Idx >= 0 );
509 	return time( NULL ) - My_Connections[Idx].lastprivmsg;
510 } /* Conn_GetIdle */
511 
512 
513 GLOBAL time_t
514 Conn_LastPing( CONN_ID Idx )
515 {
516 	/* Zeitpunkt des letzten PING liefern */
517 
518 	assert( Idx >= 0 );
519 	return My_Connections[Idx].lastping;
520 } /* Conn_LastPing */
521 
522 
523 GLOBAL VOID
524 Conn_SetPenalty( CONN_ID Idx, time_t Seconds )
525 {
526 	/* Penalty-Delay fuer eine Verbindung (in Sekunden) setzen;
527 	 * waehrend dieser Zeit wird der entsprechende Socket vom Server
528 	 * bei Lese-Operationen komplett ignoriert. Der Delay kann mit
529 	 * dieser Funktion nur erhoeht, nicht aber verringert werden. */
530 	
531 	time_t t;
532 	
533 	assert( Idx >= 0 );
534 	assert( Seconds >= 0 );
535 	
536 	t = time( NULL ) + Seconds;
537 	if( t > My_Connections[Idx].delaytime ) My_Connections[Idx].delaytime = t;
538 } /* Conn_SetPenalty */
539 
540 
541 LOCAL BOOLEAN
542 Try_Write( CONN_ID Idx )
543 {
544 	/* Versuchen, Daten aus dem Schreib-Puffer in den
545 	 * Socket zu schreiben. */
546 
547 	fd_set write_socket;
548 
549 	assert( Idx >= 0 );
550 	assert( My_Connections[Idx].sock > NONE );
551 	assert( My_Connections[Idx].wdatalen > 0 );
552 
553 	FD_ZERO( &write_socket );
554 	FD_SET( My_Connections[Idx].sock, &write_socket );
555 	if( select( My_Connections[Idx].sock + 1, NULL, &write_socket, NULL, 0 ) == -1 )
556 	{
557 		/* Fehler! */
558 		if( errno != EINTR )
559 		{
560 			Log( LOG_ALERT, "select() failed: %s!", strerror( errno ));
561 			Conn_Close( Idx, "Server error!", NULL, FALSE );
562 			return FALSE;
563 		}
564 	}
565 
566 	if( FD_ISSET( My_Connections[Idx].sock, &write_socket )) return Handle_Write( Idx );
567 	else return TRUE;
568 } /* Try_Write */
569 
570 
571 LOCAL VOID
572 Handle_Read( INT Sock )
573 {
574 	/* Aktivitaet auf einem Socket verarbeiten:
575 	 *  - neue Clients annehmen,
576 	 *  - Daten von Clients verarbeiten,
577 	 *  - Resolver-Rueckmeldungen annehmen. */
578 
579 	CONN_ID idx;
580 
581 	assert( Sock >= 0 );
582 
583 	if( FD_ISSET( Sock, &My_Listeners ))
584 	{
585 		/* es ist einer unserer Listener-Sockets: es soll
586 		 * also eine neue Verbindung aufgebaut werden. */
587 
588 		New_Connection( Sock );
589 	}
590 	else if( FD_ISSET( Sock, &Resolver_FDs ))
591 	{
592 		/* Rueckmeldung von einem Resolver Sub-Prozess */
593 
594 		Read_Resolver_Result( Sock );
595 	}
596 	else
597 	{
598 		/* Ein Client Socket: entweder ein User oder Server */
599 
600 		idx = Socket2Index( Sock );
601 		Read_Request( idx );
602 	}
603 } /* Handle_Read */
604 
605 
606 LOCAL BOOLEAN
607 Handle_Write( CONN_ID Idx )
608 {
609 	/* Daten aus Schreibpuffer versenden bzw. Connection aufbauen */
610 
611 	INT len, res, err;
612 
613 	assert( Idx >= 0 );
614 	assert( My_Connections[Idx].sock > NONE );
615 
616 	if( FD_ISSET( My_Connections[Idx].sock, &My_Connects ))
617 	{
618 		/* es soll nichts geschrieben werden, sondern ein
619 		 * connect() hat ein Ergebnis geliefert */
620 
621 		FD_CLR( My_Connections[Idx].sock, &My_Connects );
622 
623 		/* Ergebnis des connect() ermitteln */
624 		len = sizeof( err );
625 		res = getsockopt( My_Connections[Idx].sock, SOL_SOCKET, SO_ERROR, &err, &len );
626 		assert( len == sizeof( err ));
627 
628 		/* Fehler aufgetreten? */
629 		if(( res != 0 ) || ( err != 0 ))
630 		{
631 			/* Fehler! */
632 			if( res != 0 ) Log( LOG_CRIT, "getsockopt (connection %d): %s!", Idx, strerror( errno ));
633 			else Log( LOG_CRIT, "Can't connect socket to \"%s:%d\" (connection %d): %s!", My_Connections[Idx].host, Conf_Server[My_Connections[Idx].our_server].port, Idx, strerror( err ));
634 
635 			/* Socket etc. pp. aufraeumen */
636 			FD_CLR( My_Connections[Idx].sock, &My_Sockets );
637 			close( My_Connections[Idx].sock );
638 			Init_Conn_Struct( Idx );
639 
640 			/* Bei Server-Verbindungen lasttry-Zeitpunkt auf "jetzt" setzen */
641 			Conf_Server[My_Connections[Idx].our_server].lasttry = time( NULL );
642 
643 			return FALSE;
644 		}
645 		Log( LOG_DEBUG, "Connection %d with \"%s:%d\" established, now sendig PASS and SERVER ...", Idx, My_Connections[Idx].host, Conf_Server[My_Connections[Idx].our_server].port );
646 
647 		/* PASS und SERVER verschicken */
648 		Conn_WriteStr( Idx, "PASS %s %s", Conf_Server[My_Connections[Idx].our_server].pwd, NGIRCd_ProtoID );
649 		Conn_WriteStr( Idx, "SERVER %s :%s", Conf_ServerName, Conf_ServerInfo );
650 
651 		return TRUE;
652 	}
653 
654 	assert( My_Connections[Idx].wdatalen > 0 );
655 
656 	/* Daten schreiben */
657 	len = send( My_Connections[Idx].sock, My_Connections[Idx].wbuf, My_Connections[Idx].wdatalen, 0 );
658 	if( len < 0 )
659 	{
660 		/* Oops, ein Fehler! */
661 		Log( LOG_ERR, "Write error (buffer) on connection %d: %s!", Idx, strerror( errno ));
662 		Conn_Close( Idx, "Write error (buffer)!", NULL, FALSE );
663 		return FALSE;
664 	}
665 
666 	/* Puffer anpassen */
667 	My_Connections[Idx].wdatalen -= len;
668 	memmove( My_Connections[Idx].wbuf, My_Connections[Idx].wbuf + len, My_Connections[Idx].wdatalen );
669 
670 	return TRUE;
671 } /* Handle_Write */
672 
673 
674 LOCAL VOID
675 New_Connection( INT Sock )
676 {
677 	/* Neue Client-Verbindung von Listen-Socket annehmen und
678 	 * CLIENT-Struktur anlegen. */
679 
680 	struct sockaddr_in new_addr;
681 	INT new_sock, new_sock_len;
682 	RES_STAT *s;
683 	CONN_ID idx;
684 	CLIENT *c;
685 
686 	assert( Sock >= 0 );
687 
688 	new_sock_len = sizeof( new_addr );
689 	new_sock = accept( Sock, (struct sockaddr *)&new_addr, (socklen_t *)&new_sock_len );
690 	if( new_sock < 0 )
691 	{
692 		Log( LOG_CRIT, "Can't accept connection: %s!", strerror( errno ));
693 		return;
694 	}
695 
696 	/* Freie Connection-Struktur suschen */
697 	for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == NONE ) break;
698 	if( idx >= MAX_CONNECTIONS )
699 	{
700 		Log( LOG_ALERT, "Can't accept connection: limit reached (%d)!", MAX_CONNECTIONS );
701 		close( new_sock );
702 		return;
703 	}
704 
705 	/* Client-Struktur initialisieren */
706 	c = Client_NewLocal( idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWN, FALSE );
707 	if( ! c )
708 	{
709 		Log( LOG_ALERT, "Can't accept connection: can't create client structure!" );
710 		close( new_sock );
711 		return;
712 	}
713 
714 	/* Verbindung registrieren */
715 	Init_Conn_Struct( idx );
716 	My_Connections[idx].sock = new_sock;
717 	My_Connections[idx].addr = new_addr;
718 
719 	/* Neuen Socket registrieren */
720 	FD_SET( new_sock, &My_Sockets );
721 	if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
722 
723 	Log( LOG_INFO, "Accepted connection %d from %s:%d on socket %d.", idx, inet_ntoa( new_addr.sin_addr ), ntohs( new_addr.sin_port), Sock );
724 
725 	/* Hostnamen ermitteln */
726 	s = Resolve_Addr( &new_addr );
727 	if( s )
728 	{
729 		/* Sub-Prozess wurde asyncron gestartet */
730 		My_Connections[idx].res_stat = s;
731 	}
732 	else
733 	{
734 		/* kann Namen nicht aufloesen, daher wird die IP-Adresse verwendet */
735 		strcpy( My_Connections[idx].host, inet_ntoa( new_addr.sin_addr ));
736 		Client_SetHostname( c, My_Connections[idx].host );
737 	}
738 	
739 	/* Penalty-Zeit setzen */
740 	Conn_SetPenalty( idx, 1 );
741 } /* New_Connection */
742 
743 
744 LOCAL CONN_ID
745 Socket2Index( INT Sock )
746 {
747 	/* zum Socket passende Connection suchen */
748 
749 	CONN_ID idx;
750 
751 	assert( Sock >= 0 );
752 
753 	for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == Sock ) break;
754 
755 	assert( idx < MAX_CONNECTIONS );
756 	return idx;
757 } /* Socket2Index */
758 
759 
760 LOCAL VOID
761 Read_Request( CONN_ID Idx )
762 {
763 	/* Daten von Socket einlesen und entsprechend behandeln.
764 	 * Tritt ein Fehler auf, so wird der Socket geschlossen. */
765 
766 	INT len;
767 
768 	assert( Idx >= 0 );
769 	assert( My_Connections[Idx].sock > NONE );
770 
771 	if( READBUFFER_LEN - My_Connections[Idx].rdatalen - 2 < 0 )
772 	{
773 		/* Der Lesepuffer ist voll */
774 		Log( LOG_ERR, "Read buffer overflow (connection %d): %d bytes!", Idx, My_Connections[Idx].rdatalen );
775 		Conn_Close( Idx, "Read buffer overflow!", NULL, FALSE );
776 		return;
777 	}
778 
779 	len = recv( My_Connections[Idx].sock, My_Connections[Idx].rbuf + My_Connections[Idx].rdatalen, READBUFFER_LEN - My_Connections[Idx].rdatalen - 2, 0 );
780 
781 	if( len == 0 )
782 	{
783 		/* Socket wurde geschlossen */
784 		Log( LOG_INFO, "%s:%d is closing the connection ...", inet_ntoa( My_Connections[Idx].addr.sin_addr ), ntohs( My_Connections[Idx].addr.sin_port));
785 		Conn_Close( Idx, "Socket closed!", "Client closed connection", FALSE );
786 		return;
787 	}
788 
789 	if( len < 0 )
790 	{
791 		/* Fehler beim Lesen */
792 		Log( LOG_ERR, "Read error on connection %d: %s!", Idx, strerror( errno ));
793 		Conn_Close( Idx, "Read error!", "Client closed connection", FALSE );
794 		return;
795 	}
796 
797 	/* Lesebuffer updaten */
798 	My_Connections[Idx].rdatalen += len;
799 	assert( My_Connections[Idx].rdatalen < READBUFFER_LEN );
800 	My_Connections[Idx].rbuf[My_Connections[Idx].rdatalen] = '\0';
801 
802 	/* Timestamp aktualisieren */
803 	My_Connections[Idx].lastdata = time( NULL );
804 
805 	Handle_Buffer( Idx );
806 } /* Read_Request */
807 
808 
809 LOCAL VOID
810 Handle_Buffer( CONN_ID Idx )
811 {
812 	/* Daten im Lese-Puffer einer Verbindung verarbeiten. */
813 
814 	CHAR *ptr, *ptr1, *ptr2;
815 	INT len, delta;
816 
817 	/* Eine komplette Anfrage muss mit CR+LF enden, vgl.
818 	 * RFC 2812. Haben wir eine? */
819 	ptr = strstr( My_Connections[Idx].rbuf, "\r\n" );
820 
821 	if( ptr ) delta = 2;
822 #ifndef STRICT_RFC
823 	else
824 	{
825 		/* Nicht RFC-konforme Anfrage mit nur CR oder LF? Leider
826 		 * machen soetwas viele Clients, u.a. "mIRC" :-( */
827 		ptr1 = strchr( My_Connections[Idx].rbuf, '\r' );
828 		ptr2 = strchr( My_Connections[Idx].rbuf, '\n' );
829 		delta = 1;
830 		if( ptr1 && ptr2 ) ptr = ptr1 > ptr2 ? ptr2 : ptr1;
831 		else if( ptr1 ) ptr = ptr1;
832 		else if( ptr2 ) ptr = ptr2;
833 	}
834 #endif
835 
836 	if( ptr )
837 	{
838 		/* Ende der Anfrage wurde gefunden */
839 		*ptr = '\0';
840 		len = ( ptr - My_Connections[Idx].rbuf ) + delta;
841 		if( len > ( COMMAND_LEN - 1 ))
842 		{
843 			/* Eine Anfrage darf(!) nicht laenger als 512 Zeichen
844 			* (incl. CR+LF!) werden; vgl. RFC 2812. Wenn soetwas
845 			* empfangen wird, wird der Client disconnectiert. */
846 			Log( LOG_ERR, "Request too long (connection %d): %d bytes (max. %d expected)!", Idx, My_Connections[Idx].rdatalen, COMMAND_LEN - 1 );
847 			Conn_Close( Idx, NULL, "Request too long", TRUE );
848 			return;
849 		}
850 
851 		if( len > delta )
852 		{
853 			/* Es wurde ein Request gelesen */
854 			if( ! Parse_Request( Idx, My_Connections[Idx].rbuf )) return;
855 		}
856 
857 		/* Puffer anpassen */
858 		My_Connections[Idx].rdatalen -= len;
859 		memmove( My_Connections[Idx].rbuf, My_Connections[Idx].rbuf + len, My_Connections[Idx].rdatalen );
860 	}
861 } /* Handle_Buffer */
862 
863 
864 LOCAL VOID
865 Check_Connections( VOID )
866 {
867 	/* Pruefen, ob Verbindungen noch "alive" sind. Ist dies
868 	 * nicht der Fall, zunaechst PING-PONG spielen und, wenn
869 	 * auch das nicht "hilft", Client disconnectieren. */
870 
871 	CLIENT *c;
872 	INT i;
873 
874 	for( i = 0; i < MAX_CONNECTIONS; i++ )
875 	{
876 		if( My_Connections[i].sock == NONE ) continue;
877 
878 		c = Client_GetFromConn( i );
879 		if( c && (( Client_Type( c ) == CLIENT_USER ) || ( Client_Type( c ) == CLIENT_SERVER ) || ( Client_Type( c ) == CLIENT_SERVICE )))
880 		{
881 			/* verbundener User, Server oder Service */
882 			if( My_Connections[i].lastping > My_Connections[i].lastdata )
883 			{
884 				/* es wurde bereits ein PING gesendet */
885 				if( My_Connections[i].lastping < time( NULL ) - Conf_PongTimeout )
886 				{
887 					/* Timeout */
888 					Log( LOG_DEBUG, "Connection %d: Ping timeout: %d seconds.", i, Conf_PongTimeout );
889 					Conn_Close( i, NULL, "Ping timeout", TRUE );
890 				}
891 			}
892 			else if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
893 			{
894 				/* es muss ein PING gesendet werden */
895 				Log( LOG_DEBUG, "Connection %d: sending PING ...", i );
896 				My_Connections[i].lastping = time( NULL );
897 				Conn_WriteStr( i, "PING :%s", Client_ID( Client_ThisServer( )));
898 			}
899 		}
900 		else
901 		{
902 			/* noch nicht vollstaendig aufgebaute Verbindung */
903 			if( My_Connections[i].lastdata < time( NULL ) - Conf_PingTimeout )
904 			{
905 				/* Timeout */
906 				Log( LOG_DEBUG, "Connection %d timed out ...", i );
907 				Conn_Close( i, NULL, "Timeout", FALSE );
908 			}
909 		}
910 	}
911 } /* Check_Connections */
912 
913 
914 LOCAL VOID
915 Check_Servers( VOID )
916 {
917 	/* Pruefen, ob Server-Verbindungen aufgebaut werden
918 	 * muessen bzw. koennen */
919 
920 	INT idx, i, n;
921 	RES_STAT *s;
922 
923 	/* Wenn "Passive-Mode" aktiv: nicht verbinden */
924 	if( NGIRCd_Passive ) return;
925 
926 	for( i = 0; i < Conf_Server_Count; i++ )
927 	{
928 		/* Ist ein Hostname und Port definiert? */
929 		if(( ! Conf_Server[i].host[0] ) || ( ! Conf_Server[i].port > 0 )) continue;
930 
931 		/* Haben wir schon eine Verbindung? */
932 		for( n = 0; n < MAX_CONNECTIONS; n++ )
933 		{
934 			if( My_Connections[n].sock == NONE ) continue;
935 			
936 			/* Verbindung zu diesem Server? */
937 			if( My_Connections[n].our_server == i )
938 			{
939 				/* Komplett aufgebaute Verbindung? */
940 				if( My_Connections[n].sock > NONE ) break;
941 
942 				/* IP schon aufgeloest? */
943 				if( My_Connections[n].res_stat == NULL ) New_Server( i, n );
944 			}
945 
946 			/* Verbindung in dieser Server-Gruppe? */
947 			if(( My_Connections[n].our_server != NONE ) && ( Conf_Server[i].group != NONE ))
948 			{
949 				if( Conf_Server[My_Connections[n].our_server].group == Conf_Server[i].group ) break;
950 			}
951 		}
952 		if( n < MAX_CONNECTIONS ) continue;
953 
954 		/* Wann war der letzte Connect-Versuch? */
955 		if( Conf_Server[i].lasttry > time( NULL ) - Conf_ConnectRetry ) continue;
956 
957 		/* Okay, Verbindungsaufbau versuchen */
958 		Conf_Server[i].lasttry = time( NULL );
959 
960 		/* Freie Connection-Struktur suschen */
961 		for( idx = 0; idx < MAX_CONNECTIONS; idx++ ) if( My_Connections[idx].sock == NONE ) break;
962 		if( idx >= MAX_CONNECTIONS )
963 		{
964 			Log( LOG_ALERT, "Can't establist server connection: connection limit reached (%d)!", MAX_CONNECTIONS );
965 			return;
966 		}
967 		Log( LOG_DEBUG, "Preparing connection %d for \"%s\" ...", idx, Conf_Server[i].host );
968 
969 		/* Verbindungs-Struktur initialisieren */
970 		Init_Conn_Struct( idx );
971 		My_Connections[idx].sock = SERVER_WAIT;
972 		My_Connections[idx].our_server = i;
973 
974 		/* Hostnamen in IP aufloesen */
975 		s = Resolve_Name( Conf_Server[i].host );
976 		if( s )
977 		{
978 			/* Sub-Prozess wurde asyncron gestartet */
979 			My_Connections[idx].res_stat = s;
980 		}
981 		else
982 		{
983 			/* kann Namen nicht aufloesen: nun versuchen wir einfach,
984 			 * den "Text" direkt als IP-Adresse zu verwenden ... */
985 			strcpy( Conf_Server[My_Connections[idx].our_server].ip, Conf_Server[i].host );
986 		}
987 	}
988 } /* Check_Servers */
989 
990 
991 LOCAL VOID
992 New_Server( INT Server, CONN_ID Idx )
993 {
994 	/* Neue Server-Verbindung aufbauen */
995 
996 	struct sockaddr_in new_addr;
997 	struct in_addr inaddr;
998 	INT new_sock;
999 	CLIENT *c;
1000 
1001 	assert( Server >= 0 );
1002 	assert( Idx >= 0 );
1003 
1004 	/* Wurde eine gueltige IP-Adresse gefunden? */
1005 	if( ! Conf_Server[Server].ip[0] )
1006 	{
1007 		/* Nein. Verbindung wieder freigeben: */
1008 		Init_Conn_Struct( Idx );
1009 		Log( LOG_ERR, "Can't connect to \"%s\" (connection %d): ip address unknown!", Conf_Server[Server].host, Idx );
1010 		return;
1011 	}
1012 
1013 	Log( LOG_INFO, "Establishing connection to \"%s\", %s, port %d (connection %d) ... ", Conf_Server[Server].host, Conf_Server[Server].ip, Conf_Server[Server].port, Idx );
1014 
1015 #ifdef HAVE_INET_ATON
1016 	if( inet_aton( Conf_Server[Server].ip, &inaddr ) == 0 )
1017 #else
1018 	memset( &inaddr, 0, sizeof( inaddr ));
1019 	inaddr.s_addr = inet_addr( Conf_Server[Server].ip );
1020 	if( inaddr.s_addr == (unsigned)-1 )
1021 #endif
1022 	{
1023 		/* Konnte Adresse nicht konvertieren */
1024 		Init_Conn_Struct( Idx );
1025 		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 );
1026 		return;
1027 	}
1028 
1029 	memset( &new_addr, 0, sizeof( new_addr ));
1030 	new_addr.sin_family = AF_INET;
1031 	new_addr.sin_addr = inaddr;
1032 	new_addr.sin_port = htons( Conf_Server[Server].port );
1033 
1034 	new_sock = socket( PF_INET, SOCK_STREAM, 0 );
1035 	if ( new_sock < 0 )
1036 	{
1037 		Init_Conn_Struct( Idx );
1038 		Log( LOG_CRIT, "Can't create socket: %s!", strerror( errno ));
1039 		return;
1040 	}
1041 
1042 	if( ! Init_Socket( new_sock )) return;
1043 
1044 	connect( new_sock, (struct sockaddr *)&new_addr, sizeof( new_addr ));
1045 	if( errno != EINPROGRESS )
1046 	{
1047 
1048 		close( new_sock );
1049 		Init_Conn_Struct( Idx );
1050 		Log( LOG_CRIT, "Can't connect socket: %s!", strerror( errno ));
1051 		return;
1052 	}
1053 
1054 	/* Client-Struktur initialisieren */
1055 	c = Client_NewLocal( Idx, inet_ntoa( new_addr.sin_addr ), CLIENT_UNKNOWNSERVER, FALSE );
1056 	if( ! c )
1057 	{
1058 		close( new_sock );
1059 		Init_Conn_Struct( Idx );
1060 		Log( LOG_ALERT, "Can't establish connection: can't create client structure!" );
1061 		return;
1062 	}
1063 	Client_SetIntroducer( c, c );
1064 	Client_SetToken( c, TOKEN_OUTBOUND );
1065 
1066 	/* Verbindung registrieren */
1067 	My_Connections[Idx].sock = new_sock;
1068 	My_Connections[Idx].addr = new_addr;
1069 	strcpy( My_Connections[Idx].host, Conf_Server[Server].host );
1070 
1071 	/* Neuen Socket registrieren */
1072 	FD_SET( new_sock, &My_Sockets );
1073 	FD_SET( new_sock, &My_Connects );
1074 	if( new_sock > Conn_MaxFD ) Conn_MaxFD = new_sock;
1075 } /* New_Server */
1076 
1077 
1078 LOCAL VOID
1079 Init_Conn_Struct( INT Idx )
1080 {
1081 	/* Connection-Struktur initialisieren */
1082 
1083 	My_Connections[Idx].sock = NONE;
1084 	My_Connections[Idx].res_stat = NULL;
1085 	My_Connections[Idx].host[0] = '\0';
1086 	My_Connections[Idx].rbuf[0] = '\0';
1087 	My_Connections[Idx].rdatalen = 0;
1088 	My_Connections[Idx].wbuf[0] = '\0';
1089 	My_Connections[Idx].wdatalen = 0;
1090 	My_Connections[Idx].our_server = NONE;
1091 	My_Connections[Idx].lastdata = time( NULL );
1092 	My_Connections[Idx].lastping = 0;
1093 	My_Connections[Idx].lastprivmsg = time( NULL );
1094 	My_Connections[Idx].delaytime = 0;
1095 } /* Init_Conn_Struct */
1096 
1097 
1098 LOCAL BOOLEAN
1099 Init_Socket( INT Sock )
1100 {
1101 	/* Socket-Optionen setzen */
1102 
1103 	INT on = 1;
1104 
1105 #ifdef O_NONBLOCK	/* A/UX kennt das nicht? */
1106 	if( fcntl( Sock, F_SETFL, O_NONBLOCK ) != 0 )
1107 	{
1108 		Log( LOG_CRIT, "Can't enable non-blocking mode: %s!", strerror( errno ));
1109 		close( Sock );
1110 		return FALSE;
1111 	}
1112 #endif
1113 	if( setsockopt( Sock, SOL_SOCKET, SO_REUSEADDR, &on, (socklen_t)sizeof( on )) != 0)
1114 	{
1115 		Log( LOG_ERR, "Can't set socket options: %s!", strerror( errno ));
1116 		/* dieser Fehler kann ignoriert werden. */
1117 	}
1118 
1119 	return TRUE;
1120 } /* Init_Socket */
1121 
1122 
1123 LOCAL VOID
1124 Read_Resolver_Result( INT r_fd )
1125 {
1126 	/* Ergebnis von Resolver Sub-Prozess aus Pipe lesen
1127 	 * und entsprechende Connection aktualisieren */
1128 
1129 	CHAR result[HOST_LEN];
1130 	CLIENT *c;
1131 	INT len, i;
1132 
1133 	FD_CLR( r_fd, &Resolver_FDs );
1134 
1135 	/* Anfrage vom Parent lesen */
1136 	len = read( r_fd, result, HOST_LEN);
1137 	if( len < 0 )
1138 	{
1139 		/* Fehler beim Lesen aus der Pipe */
1140 		close( r_fd );
1141 		Log( LOG_CRIT, "Resolver: Can't read result: %s!", strerror( errno ));
1142 		return;
1143 	}
1144 	result[len] = '\0';
1145 
1146 	/* zugehoerige Connection suchen */
1147 	for( i = 0; i < MAX_CONNECTIONS; i++ )
1148 	{
1149 		if(( My_Connections[i].sock != NONE ) && ( My_Connections[i].res_stat ) && ( My_Connections[i].res_stat->pipe[0] == r_fd )) break;
1150 	}
1151 	if( i >= MAX_CONNECTIONS )
1152 	{
1153 		/* Opsa! Keine passende Connection gefunden!? Vermutlich
1154 		* wurde sie schon wieder geschlossen. */
1155 		close( r_fd );
1156 		Log( LOG_DEBUG, "Resolver: Got result for unknown connection!?" );
1157 		return;
1158 	}
1159 
1160 	/* Aufraeumen */
1161 	close( My_Connections[i].res_stat->pipe[0] );
1162 	close( My_Connections[i].res_stat->pipe[1] );
1163 	free( My_Connections[i].res_stat );
1164 	My_Connections[i].res_stat = NULL;
1165 
1166 	if( My_Connections[i].sock > NONE )
1167 	{
1168 		/* Eingehende Verbindung: Hostnamen setzen */
1169 		c = Client_GetFromConn( i );
1170 		assert( c != NULL );
1171 		strcpy( My_Connections[i].host, result );
1172 		Client_SetHostname( c, result );
1173 	}
1174 	else
1175 	{
1176 		/* Ausgehende Verbindung (=Server): IP setzen */
1177 		assert( My_Connections[i].our_server >= 0 );
1178 		strcpy( Conf_Server[My_Connections[i].our_server].ip, result );
1179 	}
1180 } /* Read_Resolver_Result */
1181 
1182 
1183 /* -eof- */