Made on IRCNow

Blob

Date:: Mon Mar 25 19:11:01 2002 UTC
Message:: - einige Anpassungen nach Code-Check mit SPLint ;-)
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: client.c,v 1.52 2002/03/25 19:11:01 alex Exp $
13  *
14  * client.c: Management aller Clients
15  *
16  * Der Begriff "Client" ist in diesem Fall evtl. etwas verwirrend: Clients sind
17  * alle Verbindungen, die im gesamten(!) IRC-Netzwerk bekannt sind. Das sind IRC-
18  * Clients (User), andere Server und IRC-Services.
19  * Ueber welchen IRC-Server die Verbindung nun tatsaechlich in das Netzwerk her-
20  * gestellt wurde, muss der jeweiligen Struktur entnommen werden. Ist es dieser
21  * Server gewesen, so existiert eine entsprechende CONNECTION-Struktur.
22  */
23 
24 
25 #define __client_c__
26 
27 
28 #include "portab.h"
29 
30 #include "imp.h"
31 #include <assert.h>
32 #include <unistd.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <netdb.h>
37 
38 #include "exp.h"
39 #include "client.h"
40 
41 #include <imp.h>
42 #include "ngircd.h"
43 #include "channel.h"
44 #include "conf.h"
45 #include "conn.h"
46 #include "hash.h"
47 #include "irc-write.h"
48 #include "log.h"
49 #include "messages.h"
50 
51 #include <exp.h>
52 
53 
54 LOCAL CLIENT *This_Server, *My_Clients;
55 LOCAL CHAR GetID_Buffer[CLIENT_ID_LEN];
56 
57 
58 LOCAL INT Count( CLIENT_TYPE Type );
59 LOCAL INT MyCount( CLIENT_TYPE Type );
60 
61 LOCAL CLIENT *New_Client_Struct( VOID );
62 LOCAL VOID Generate_MyToken( CLIENT *Client );
63 
64 
65 GLOBAL VOID Client_Init( VOID )
66 {
67 	struct hostent *h;
68 	
69 	This_Server = New_Client_Struct( );
70 	if( ! This_Server )
71 	{
72 		Log( LOG_EMERG, "Can't allocate client structure for server! Going down." );
73 		Log( LOG_ALERT, PACKAGE" exiting due to fatal errors!" );
74 		exit( 1 );
75 	}
76 
77 	/* Client-Struktur dieses Servers */
78 	This_Server->next = NULL;
79 	This_Server->type = CLIENT_SERVER;
80 	This_Server->conn_id = NONE;
81 	This_Server->introducer = This_Server;
82 	This_Server->mytoken = 1;
83 	This_Server->hops = 0;
84 
85 	gethostname( This_Server->host, CLIENT_HOST_LEN );
86 	h = gethostbyname( This_Server->host );
87 	if( h ) strcpy( This_Server->host, h->h_name );
88 
89 	Client_SetID( This_Server, Conf_ServerName );
90 	Client_SetInfo( This_Server, Conf_ServerInfo );
91 
92 	My_Clients = This_Server;
93 } /* Client_Init */
94 
95 
96 GLOBAL VOID Client_Exit( VOID )
97 {
98 	CLIENT *c, *next;
99 	INT cnt;
100 
101 	Client_Destroy( This_Server, "Server going down.", NULL, FALSE );
102 	
103 	cnt = 0;
104 	c = My_Clients;
105 	while( c )
106 	{
107 		cnt++;
108 		next = (CLIENT *)c->next;
109 		free( c );
110 		c = next;
111 	}
112 	if( cnt ) Log( LOG_INFO, "Freed %d client structure%s.", cnt, cnt == 1 ? "" : "s" );
113 } /* Client_Exit */
114 
115 
116 GLOBAL CLIENT *Client_ThisServer( VOID )
117 {
118 	return This_Server;
119 } /* Client_ThisServer */
120 
121 
122 GLOBAL CLIENT *Client_NewLocal( CONN_ID Idx, CHAR *Hostname, INT Type, BOOLEAN Idented )
123 {
124 	/* Neuen lokalen Client erzeugen: Wrapper-Funktion fuer Client_New(). */
125 	return Client_New( Idx, This_Server, NULL, Type, NULL, NULL, Hostname, NULL, 0, 0, NULL, Idented );
126 } /* Client_NewLocal */
127 
128 
129 GLOBAL CLIENT *Client_NewRemoteServer( CLIENT *Introducer, CHAR *Hostname, CLIENT *TopServer, INT Hops, INT Token, CHAR *Info, BOOLEAN Idented )
130 {
131 	/* Neuen Remote-Client erzeugen: Wrapper-Funktion fuer Client_New (). */
132 	return Client_New( NONE, Introducer, TopServer, CLIENT_SERVER, Hostname, NULL, Hostname, Info, Hops, Token, NULL, Idented );
133 } /* Client_NewRemoteServer */
134 
135 
136 GLOBAL CLIENT *Client_NewRemoteUser( CLIENT *Introducer, CHAR *Nick, INT Hops, CHAR *User, CHAR *Hostname, INT Token, CHAR *Modes, CHAR *Info, BOOLEAN Idented )
137 {
138 	/* Neuen Remote-Client erzeugen: Wrapper-Funktion fuer Client_New (). */
139 	return Client_New( NONE, Introducer, NULL, CLIENT_USER, Nick, User, Hostname, Info, Hops, Token, Modes, Idented );
140 } /* Client_NewRemoteUser */
141 
142 
143 GLOBAL CLIENT *Client_New( CONN_ID Idx, CLIENT *Introducer, CLIENT *TopServer, INT Type, CHAR *ID, CHAR *User, CHAR *Hostname, CHAR *Info, INT Hops, INT Token, CHAR *Modes, BOOLEAN Idented )
144 {
145 	CLIENT *client;
146 
147 	assert( Idx >= NONE );
148 	assert( Introducer != NULL );
149 	assert( Hostname != NULL );
150 
151 	client = New_Client_Struct( );
152 	if( ! client ) return NULL;
153 
154 	/* Initialisieren */
155 	client->conn_id = Idx;
156 	client->introducer = Introducer;
157 	client->topserver = TopServer;
158 	client->type = Type;
159 	if( ID ) Client_SetID( client, ID );
160 	if( User ) Client_SetUser( client, User, Idented );
161 	if( Hostname ) Client_SetHostname( client, Hostname );
162 	if( Info ) Client_SetInfo( client, Info );
163 	client->hops = Hops;
164 	client->token = Token;
165 	if( Modes ) Client_SetModes( client, Modes );
166 	if( Type == CLIENT_SERVER ) Generate_MyToken( client );
167 
168 	/* ist der User away? */
169 	if( strchr( client->modes, 'a' )) strcpy( client->away, DEFAULT_AWAY_MSG );
170 
171 	/* Verketten */
172 	client->next = (POINTER *)My_Clients;
173 	My_Clients = client;
174 
175 	return client;
176 } /* Client_New */
177 
178 
179 GLOBAL VOID Client_Destroy( CLIENT *Client, CHAR *LogMsg, CHAR *FwdMsg, BOOLEAN SendQuit )
180 {
181 	/* Client entfernen. */
182 	
183 	CLIENT *last, *c;
184 	CHAR msg[LINE_LEN], *txt;
185 
186 	assert( Client != NULL );
187 
188 	if( LogMsg ) txt = LogMsg;
189 	else txt = FwdMsg;
190 	if( ! txt ) txt = "Reason unknown.";
191 
192 	/* Netz-Split-Nachricht vorbereiten (noch nicht optimal) */
193 	if( Client->type == CLIENT_SERVER ) sprintf( msg, "%s: lost server %s", This_Server->id, Client->id );
194 
195 	last = NULL;
196 	c = My_Clients;
197 	while( c )
198 	{
199 		if(( Client->type == CLIENT_SERVER ) && ( c->introducer == Client ) && ( c != Client ))
200 		{
201 			/* der Client, der geloescht wird ist ein Server. Der Client, den wir gerade
202 			 * pruefen, ist ein Child von diesem und muss daher auch entfernt werden */
203 			Client_Destroy( c, NULL, msg, FALSE );
204 			last = NULL;
205 			c = My_Clients;
206 			continue;
207 		}
208 		if( c == Client )
209 		{
210 			/* Wir haben den Client gefunden: entfernen */
211 			if( last ) last->next = c->next;
212 			else My_Clients = (CLIENT *)c->next;
213 
214 			if( c->type == CLIENT_USER )
215 			{
216 				if( c->conn_id != NONE )
217 				{
218 					/* Ein lokaler User */
219 					Log( LOG_NOTICE, "User \"%s\" unregistered (connection %d): %s", Client_Mask( c ), c->conn_id, txt );
220 
221 					if( SendQuit )
222 					{
223 						/* Alle andere Server informieren! */
224 						if( FwdMsg ) IRC_WriteStrServersPrefix( NULL, c, "QUIT :%s", FwdMsg );
225 						else IRC_WriteStrServersPrefix( NULL, c, "QUIT :" );
226 					}
227 				}
228 				else
229 				{
230 					/* Remote User */
231 					Log( LOG_DEBUG, "User \"%s\" unregistered: %s", Client_Mask( c ), txt );
232 
233 					if( SendQuit )
234 					{
235 						/* Andere Server informieren, ausser denen, die "in
236 						 * Richtung dem liegen", auf dem der User registriert
237 						 * ist. Von denen haben wir das QUIT ja wohl bekommen. */
238 						if( FwdMsg ) IRC_WriteStrServersPrefix( Client_NextHop( c ), c, "QUIT :%s", FwdMsg );
239 						else IRC_WriteStrServersPrefix( Client_NextHop( c ), c, "QUIT :" );
240 					}
241 				}
242 				Channel_RemoveClient( c, FwdMsg ? FwdMsg : c->id );
243 			}
244 			else if( c->type == CLIENT_SERVER )
245 			{
246 				if( c != This_Server )
247 				{
248 					if( c->conn_id != NONE ) Log( LOG_NOTICE, "Server \"%s\" unregistered (connection %d): %s", c->id, c->conn_id, txt );
249 					else Log( LOG_NOTICE, "Server \"%s\" unregistered: %s", c->id, txt );
250 				}
251 
252 				/* andere Server informieren */
253 				if( ! NGIRCd_Quit )
254 				{
255 					if( FwdMsg ) IRC_WriteStrServersPrefix( Client_NextHop( c ), c, "SQUIT %s :%s", c->id, FwdMsg );
256 					else IRC_WriteStrServersPrefix( Client_NextHop( c ), c, "SQUIT %s :", c->id );
257 				}
258 			}
259 			else
260 			{
261 				if( c->conn_id != NONE )
262 				{
263 					if( c->id[0] ) Log( LOG_NOTICE, "Client \"%s\" unregistered (connection %d): %s", c->id, c->conn_id, txt );
264 					else Log( LOG_NOTICE, "Client unregistered (connection %d): %s", c->conn_id, txt );
265 				}
266 				else
267 				{
268 					if( c->id[0] ) Log( LOG_WARNING, "Unregistered unknown client \"%s\": %s", c->id, txt );
269 					else Log( LOG_WARNING, "Unregistered unknown client: %s", c->id, txt );
270 				}
271 			}
272 
273 			free( c );
274 			break;
275 		}
276 		last = c;
277 		c = (CLIENT *)c->next;
278 	}
279 } /* Client_Destroy */
280 
281 
282 GLOBAL VOID Client_SetHostname( CLIENT *Client, CHAR *Hostname )
283 {
284 	/* Hostname eines Clients setzen */
285 	
286 	assert( Client != NULL );
287 	assert( Hostname != NULL );
288 	
289 	strncpy( Client->host, Hostname, CLIENT_HOST_LEN - 1 );
290 	Client->host[CLIENT_HOST_LEN - 1] = '\0';
291 } /* Client_SetHostname */
292 
293 
294 GLOBAL VOID Client_SetID( CLIENT *Client, CHAR *ID )
295 {
296 	/* Hostname eines Clients setzen, Hash-Wert berechnen */
297 
298 	assert( Client != NULL );
299 	assert( ID != NULL );
300 	
301 	strncpy( Client->id, ID, CLIENT_ID_LEN - 1 );
302 	Client->id[CLIENT_ID_LEN - 1] = '\0';
303 
304 	/* Hash */
305 	Client->hash = Hash( Client->id );
306 } /* Client_SetID */
307 
308 
309 GLOBAL VOID Client_SetUser( CLIENT *Client, CHAR *User, BOOLEAN Idented )
310 {
311 	/* Username eines Clients setzen */
312 
313 	assert( Client != NULL );
314 	assert( User != NULL );
315 	
316 	if( Idented ) strncpy( Client->user, User, CLIENT_USER_LEN - 1 );
317 	else
318 	{
319 		Client->user[0] = '~';
320 		strncpy( Client->user + 1, User, CLIENT_USER_LEN - 2 );
321 	}
322 	Client->user[CLIENT_USER_LEN - 1] = '\0';
323 } /* Client_SetUser */
324 
325 
326 GLOBAL VOID Client_SetInfo( CLIENT *Client, CHAR *Info )
327 {
328 	/* Hostname eines Clients setzen */
329 
330 	assert( Client != NULL );
331 	assert( Info != NULL );
332 	
333 	strncpy( Client->info, Info, CLIENT_INFO_LEN - 1 );
334 	Client->info[CLIENT_INFO_LEN - 1] = '\0';
335 } /* Client_SetInfo */
336 
337 
338 GLOBAL VOID Client_SetModes( CLIENT *Client, CHAR *Modes )
339 {
340 	/* Hostname eines Clients setzen */
341 
342 	assert( Client != NULL );
343 	assert( Modes != NULL );
344 
345 	strncpy( Client->modes, Modes, CLIENT_MODE_LEN - 1 );
346 	Client->modes[CLIENT_MODE_LEN - 1] = '\0';
347 } /* Client_SetModes */
348 
349 
350 GLOBAL VOID Client_SetPassword( CLIENT *Client, CHAR *Pwd )
351 {
352 	/* Von einem Client geliefertes Passwort */
353 
354 	assert( Client != NULL );
355 	assert( Pwd != NULL );
356 	
357 	strncpy( Client->pwd, Pwd, CLIENT_PASS_LEN - 1 );
358 	Client->pwd[CLIENT_PASS_LEN - 1] = '\0';
359 } /* Client_SetPassword */
360 
361 
362 GLOBAL VOID Client_SetAway( CLIENT *Client, CHAR *Txt )
363 {
364 	/* Von einem Client gelieferte AWAY-Nachricht */
365 
366 	assert( Client != NULL );
367 
368 	if( Txt )
369 	{
370 		/* Client AWAY setzen */
371 		strncpy( Client->away, Txt, CLIENT_AWAY_LEN - 1 );
372 		Client->away[CLIENT_AWAY_LEN - 1] = '\0';
373 		Client_ModeAdd( Client, 'a' );
374 		Log( LOG_DEBUG, "User \"%s\" is away: %s", Client_Mask( Client ), Txt );
375 	}
376 	else
377 	{
378 		/* AWAY loeschen */
379 		Client_ModeDel( Client, 'a' );
380 		Log( LOG_DEBUG, "User \"%s\" is no longer away.", Client_Mask( Client ));
381 	}
382 } /* Client_SetAway */
383 
384 
385 GLOBAL VOID Client_SetType( CLIENT *Client, INT Type )
386 {
387 	assert( Client != NULL );
388 	Client->type = Type;
389 	if( Type == CLIENT_SERVER ) Generate_MyToken( Client );
390 } /* Client_SetType */
391 
392 
393 GLOBAL VOID Client_SetHops( CLIENT *Client, INT Hops )
394 {
395 	assert( Client != NULL );
396 	Client->hops = Hops;
397 } /* Client_SetHops */
398 
399 
400 GLOBAL VOID Client_SetToken( CLIENT *Client, INT Token )
401 {
402 	assert( Client != NULL );
403 	Client->token = Token;
404 } /* Client_SetToken */
405 
406 
407 GLOBAL VOID Client_SetIntroducer( CLIENT *Client, CLIENT *Introducer )
408 {
409 	assert( Client != NULL );
410 	assert( Introducer != NULL );
411 	Client->introducer = Introducer;
412 } /* Client_SetIntroducer */
413 
414 
415 GLOBAL VOID Client_SetOperByMe( CLIENT *Client, BOOLEAN OperByMe )
416 {
417 	assert( Client != NULL );
418 	Client->oper_by_me = OperByMe;
419 } /* Client_SetOperByMe */
420 
421 
422 GLOBAL BOOLEAN Client_ModeAdd( CLIENT *Client, CHAR Mode )
423 {
424 	/* Mode soll gesetzt werden. TRUE wird geliefert, wenn der
425 	 * Mode neu gesetzt wurde, FALSE, wenn der Client den Mode
426 	 * bereits hatte. */
427 
428 	CHAR x[2];
429 	
430 	assert( Client != NULL );
431 
432 	x[0] = Mode; x[1] = '\0';
433 	if( ! strchr( Client->modes, x[0] ))
434 	{
435 		/* Client hat den Mode noch nicht -> setzen */
436 		strcat( Client->modes, x );
437 		return TRUE;
438 	}
439 	else return FALSE;
440 } /* Client_ModeAdd */
441 
442 
443 GLOBAL BOOLEAN Client_ModeDel( CLIENT *Client, CHAR Mode )
444 {
445 	/* Mode soll geloescht werden. TRUE wird geliefert, wenn der
446 	* Mode entfernt wurde, FALSE, wenn der Client den Mode
447 	* ueberhaupt nicht hatte. */
448 
449 	CHAR x[2], *p;
450 
451 	assert( Client != NULL );
452 
453 	x[0] = Mode; x[1] = '\0';
454 
455 	p = strchr( Client->modes, x[0] );
456 	if( ! p ) return FALSE;
457 
458 	/* Client hat den Mode -> loeschen */
459 	while( *p )
460 	{
461 		*p = *(p + 1);
462 		p++;
463 	}
464 	return TRUE;
465 } /* Client_ModeDel */
466 
467 
468 GLOBAL CLIENT *Client_GetFromConn( CONN_ID Idx )
469 {
470 	/* Client-Struktur, die zur lokalen Verbindung Idx gehoert,
471 	 * liefern. Wird keine gefunden, so wird NULL geliefert. */
472 
473 	CLIENT *c;
474 
475 	assert( Idx >= 0 );
476 	
477 	c = My_Clients;
478 	while( c )
479 	{
480 		if( c->conn_id == Idx ) return c;
481 		c = (CLIENT *)c->next;
482 	}
483 	return NULL;
484 } /* Client_GetFromConn */
485 
486 
487 GLOBAL CLIENT *Client_Search( CHAR *Nick )
488 {
489 	/* Client-Struktur, die den entsprechenden Nick hat, liefern.
490 	 * Wird keine gefunden, so wird NULL geliefert. */
491 
492 	CHAR search_id[CLIENT_ID_LEN], *ptr;
493 	CLIENT *c = NULL;
494 	UINT32 search_hash;
495 
496 	assert( Nick != NULL );
497 
498 	/* Nick kopieren und ggf. Host-Mask abschneiden */
499 	strncpy( search_id, Nick, CLIENT_ID_LEN - 1 );
500 	search_id[CLIENT_ID_LEN - 1] = '\0';
501 	ptr = strchr( search_id, '!' );
502 	if( ptr ) *ptr = '\0';
503 
504 	search_hash = Hash( search_id );
505 
506 	c = My_Clients;
507 	while( c )
508 	{
509 		if( c->hash == search_hash )
510 		{
511 			/* lt. Hash-Wert: Treffer! */
512 			if( strcasecmp( c->id, search_id ) == 0 ) return c;
513 		}
514 		c = (CLIENT *)c->next;
515 	}
516 	return NULL;
517 } /* Client_Search */
518 
519 
520 GLOBAL CLIENT *Client_GetFromToken( CLIENT *Client, INT Token )
521 {
522 	/* Client-Struktur, die den entsprechenden Introducer (=Client)
523 	 * und das gegebene Token hat, liefern. Wird keine gefunden,
524 	 * so wird NULL geliefert. */
525 
526 	CLIENT *c;
527 
528 	assert( Client != NULL );
529 	assert( Token > 0 );
530 
531 	c = My_Clients;
532 	while( c )
533 	{
534 		if(( c->type == CLIENT_SERVER ) && ( c->introducer == Client ) && ( c->token == Token )) return c;
535 		c = (CLIENT *)c->next;
536 	}
537 	return NULL;
538 } /* Client_GetFromToken */
539 
540 
541 GLOBAL INT Client_Type( CLIENT *Client )
542 {
543 	assert( Client != NULL );
544 	return Client->type;
545 } /* Client_Type */
546 
547 
548 GLOBAL CONN_ID Client_Conn( CLIENT *Client )
549 {
550 	assert( Client != NULL );
551 	return Client->conn_id;
552 } /* Client_Conn */
553 
554 
555 GLOBAL CHAR *Client_ID( CLIENT *Client )
556 {
557 	assert( Client != NULL );
558 
559 #ifdef DEBUG
560 	if( Client->type == CLIENT_USER ) assert( strlen( Client->id ) < CLIENT_NICK_LEN );
561 #endif
562 						   
563 	if( Client->id[0] ) return Client->id;
564 	else return "*";
565 } /* Client_ID */
566 
567 
568 GLOBAL CHAR *Client_Info( CLIENT *Client )
569 {
570 	assert( Client != NULL );
571 	return Client->info;
572 } /* Client_Info */
573 
574 
575 GLOBAL CHAR *Client_User( CLIENT *Client )
576 {
577 	assert( Client != NULL );
578 	if( Client->user[0] ) return Client->user;
579 	else return "~";
580 } /* Client_User */
581 
582 
583 GLOBAL CHAR *Client_Hostname( CLIENT *Client )
584 {
585 	assert( Client != NULL );
586 	return Client->host;
587 } /* Client_Hostname */
588 
589 
590 GLOBAL CHAR *Client_Password( CLIENT *Client )
591 {
592 	assert( Client != NULL );
593 	return Client->pwd;
594 } /* Client_Password */
595 
596 
597 GLOBAL CHAR *Client_Modes( CLIENT *Client )
598 {
599 	assert( Client != NULL );
600 	return Client->modes;
601 } /* Client_Modes */
602 
603 
604 GLOBAL BOOLEAN Client_OperByMe( CLIENT *Client )
605 {
606 	assert( Client != NULL );
607 	return Client->oper_by_me;
608 } /* Client_OperByMe */
609 
610 
611 GLOBAL INT Client_Hops( CLIENT *Client )
612 {
613 	assert( Client != NULL );
614 	return Client->hops;
615 } /* Client_Hops */
616 
617 
618 GLOBAL INT Client_Token( CLIENT *Client )
619 {
620 	assert( Client != NULL );
621 	return Client->token;
622 } /* Client_Token */
623 
624 
625 GLOBAL INT Client_MyToken( CLIENT *Client )
626 {
627 	assert( Client != NULL );
628 	return Client->mytoken;
629 } /* Client_MyToken */
630 
631 
632 GLOBAL CLIENT *Client_NextHop( CLIENT *Client )
633 {
634 	CLIENT *c;
635 	
636 	assert( Client != NULL );
637 
638 	c = Client;
639 	while( c->introducer && ( c->introducer != c ) && ( c->introducer != This_Server )) c = c->introducer;
640 	return c;
641 } /* Client_NextHop */
642 
643 
644 GLOBAL CHAR *Client_Mask( CLIENT *Client )
645 {
646 	/* Client-"ID" liefern, wie sie z.B. fuer
647 	 * Prefixe benoetigt wird. */
648 
649 	assert( Client != NULL );
650 	
651 	if( Client->type == CLIENT_SERVER ) return Client->id;
652 
653 	sprintf( GetID_Buffer, "%s!%s@%s", Client->id, Client->user, Client->host );
654 	return GetID_Buffer;
655 } /* Client_Mask */
656 
657 
658 GLOBAL CLIENT *Client_Introducer( CLIENT *Client )
659 {
660 	assert( Client != NULL );
661 	return Client->introducer;
662 } /* Client_Introducer */
663 
664 
665 GLOBAL CLIENT *Client_TopServer( CLIENT *Client )
666 {
667 	assert( Client != NULL );
668 	return Client->topserver;
669 } /* Client_TopServer */
670 
671 
672 GLOBAL BOOLEAN Client_HasMode( CLIENT *Client, CHAR Mode )
673 {
674 	assert( Client != NULL );
675 	return strchr( Client->modes, Mode ) != NULL;
676 } /* Client_HasMode */
677 
678 
679 GLOBAL CHAR *Client_Away( CLIENT *Client )
680 {
681 	/* AWAY-Text liefern */
682 
683 	assert( Client != NULL );
684 	return Client->away;
685 } /* Client_Away */
686 
687 
688 GLOBAL BOOLEAN Client_CheckNick( CLIENT *Client, CHAR *Nick )
689 {
690 	/* Nick ueberpruefen */
691 
692 	assert( Client != NULL );
693 	assert( Nick != NULL );
694 	
695 	/* Nick ungueltig? */
696 	if( ! Client_IsValidNick( Nick ))
697 	{
698 		IRC_WriteStrClient( Client, ERR_ERRONEUSNICKNAME_MSG, Client_ID( Client ), Nick );
699 		return FALSE;
700 	}
701 
702 	/* Nick bereits vergeben? */
703 	if( Client_Search( Nick ))
704 	{
705 		/* den Nick gibt es bereits */
706 		IRC_WriteStrClient( Client, ERR_NICKNAMEINUSE_MSG, Client_ID( Client ), Nick );
707 		return FALSE;
708 	}
709 
710 	return TRUE;
711 } /* Client_CheckNick */
712 
713 
714 GLOBAL BOOLEAN Client_CheckID( CLIENT *Client, CHAR *ID )
715 {
716 	/* Nick ueberpruefen */
717 
718 	CHAR str[COMMAND_LEN];
719 	CLIENT *c;
720 
721 	assert( Client != NULL );
722 	assert( Client->conn_id > NONE );
723 	assert( ID != NULL );
724 
725 	/* Nick zu lang? */
726 	if( strlen( ID ) > CLIENT_ID_LEN )
727 	{
728 		IRC_WriteStrClient( Client, ERR_ERRONEUSNICKNAME_MSG, Client_ID( Client ), ID );
729 		return FALSE;
730 	}
731 
732 	/* ID bereits vergeben? */
733 	c = My_Clients;
734 	while( c )
735 	{
736 		if( strcasecmp( c->id, ID ) == 0 )
737 		{
738 			/* die Server-ID gibt es bereits */
739 			sprintf( str, "ID \"%s\" already registered!", ID );
740 			Log( LOG_ERR, "%s (on connection %d)", str, Client->conn_id );
741 			Conn_Close( Client->conn_id, str, str, TRUE );
742 			return FALSE;
743 		}
744 		c = (CLIENT *)c->next;
745 	}
746 
747 	return TRUE;
748 } /* Client_CheckID */
749 
750 
751 GLOBAL CLIENT *Client_First( VOID )
752 {
753 	/* Ersten Client liefern. */
754 
755 	return My_Clients;
756 } /* Client_First */
757 
758 
759 GLOBAL CLIENT *Client_Next( CLIENT *c )
760 {
761 	/* Naechsten Client liefern. Existiert keiner,
762 	 * so wird NULL geliefert. */
763 
764 	assert( c != NULL );
765 	return (CLIENT *)c->next;
766 } /* Client_Next */
767 
768 
769 GLOBAL INT Client_UserCount( VOID )
770 {
771 	return Count( CLIENT_USER );
772 } /* Client_UserCount */
773 
774 
775 GLOBAL INT Client_ServiceCount( VOID )
776 {
777 	return Count( CLIENT_SERVICE );;
778 } /* Client_ServiceCount */
779 
780 
781 GLOBAL INT Client_ServerCount( VOID )
782 {
783 	return Count( CLIENT_SERVER );
784 } /* Client_ServerCount */
785 
786 
787 GLOBAL INT Client_MyUserCount( VOID )
788 {
789 	return MyCount( CLIENT_USER );
790 } /* Client_MyUserCount */
791 
792 
793 GLOBAL INT Client_MyServiceCount( VOID )
794 {
795 	return MyCount( CLIENT_SERVICE );
796 } /* Client_MyServiceCount */
797 
798 
799 GLOBAL INT Client_MyServerCount( VOID )
800 {
801 	return MyCount( CLIENT_SERVER );
802 } /* Client_MyServerCount */
803 
804 
805 GLOBAL INT Client_OperCount( VOID )
806 {
807 	CLIENT *c;
808 	INT cnt;
809 
810 	cnt = 0;
811 	c = My_Clients;
812 	while( c )
813 	{
814 		if( c && ( c->type == CLIENT_USER ) && ( strchr( c->modes, 'o' ))) cnt++;
815 		c = (CLIENT *)c->next;
816 	}
817 	return cnt;
818 } /* Client_OperCount */
819 
820 
821 GLOBAL INT Client_UnknownCount( VOID )
822 {
823 	CLIENT *c;
824 	INT cnt;
825 
826 	cnt = 0;
827 	c = My_Clients;
828 	while( c )
829 	{
830 		if( c && ( c->type != CLIENT_USER ) && ( c->type != CLIENT_SERVICE ) && ( c->type != CLIENT_SERVER )) cnt++;
831 		c = (CLIENT *)c->next;
832 	}
833 	return cnt;
834 } /* Client_UnknownCount */
835 
836 
837 GLOBAL BOOLEAN Client_IsValidNick( CHAR *Nick )
838 {
839 	/* Ist der Nick gueltig? */
840 
841 	CHAR *ptr, goodchars[] = ";0123456789-";
842 	
843 	assert( Nick != NULL );
844 
845 	if( Nick[0] == '#' ) return FALSE;
846 	if( strchr( goodchars, Nick[0] )) return FALSE;
847 	if( strlen( Nick ) >= CLIENT_NICK_LEN ) return FALSE;
848 
849 	ptr = Nick;
850 	while( *ptr )
851 	{
852 		if(( *ptr < 'A' ) && ( ! strchr( goodchars, *ptr ))) return FALSE;
853 		if(( *ptr > '}' ) && ( ! strchr( goodchars, *ptr ))) return FALSE;
854 		ptr++;
855 	}
856 	
857 	return TRUE;
858 } /* Client_IsValidNick */
859 
860 
861 LOCAL INT Count( CLIENT_TYPE Type )
862 {
863 	CLIENT *c;
864 	INT cnt;
865 
866 	cnt = 0;
867 	c = My_Clients;
868 	while( c )
869 	{
870 		if( c && ( c->type == Type )) cnt++;
871 		c = (CLIENT *)c->next;
872 	}
873 	return cnt;
874 } /* Count */
875 
876 
877 LOCAL INT MyCount( CLIENT_TYPE Type )
878 {
879 	CLIENT *c;
880 	INT cnt;
881 
882 	cnt = 0;
883 	c = My_Clients;
884 	while( c )
885 	{
886 		if( c && ( c->introducer == This_Server ) && ( c->type == Type )) cnt++;
887 		c = (CLIENT *)c->next;
888 	}
889 	return cnt;
890 } /* MyCount */
891 
892 
893 LOCAL CLIENT *New_Client_Struct( VOID )
894 {
895 	/* Neue CLIENT-Struktur pre-initialisieren */
896 	
897 	CLIENT *c;
898 	
899 	c = malloc( sizeof( CLIENT ));
900 	if( ! c )
901 	{
902 		Log( LOG_EMERG, "Can't allocate memory!" );
903 		return NULL;
904 	}
905 
906 	c->next = NULL;
907 	c->hash = 0;
908 	c->type = CLIENT_UNKNOWN;
909 	c->conn_id = NONE;
910 	c->introducer = NULL;
911 	c->topserver = NULL;
912 	strcpy( c->id, "" );
913 	strcpy( c->pwd, "" );
914 	strcpy( c->host, "" );
915 	strcpy( c->user, "" );
916 	strcpy( c->info, "" );
917 	strcpy( c->modes, "" );
918 	c->oper_by_me = FALSE;
919 	c->hops = -1;
920 	c->token = -1;
921 	c->mytoken = -1;
922 	strcpy( c->away, "" );
923 
924 	return c;
925 } /* New_Client */
926 
927 
928 LOCAL VOID Generate_MyToken( CLIENT *Client )
929 {
930 	CLIENT *c;
931 	INT token;
932 
933 	c = My_Clients;
934 	token = 2;
935 	while( c )
936 	{
937 		if( c->mytoken == token )
938 		{
939 			/* Das Token wurde bereits vergeben */
940 			token++;
941 			c = My_Clients;
942 			continue;
943 		}
944 		else c = (CLIENT *)c->next;
945 	}
946 	Client->mytoken = token;
947 	Log( LOG_DEBUG, "Assigned token %d to server \"%s\".", token, Client->id );
948 } /* Generate_MyToken */
949 
950 
951 /* -eof- */