1b634e547f5d8007aedc2a36c58e7e61169c35ba
[ngircd-alex.git] / src / ngircd / client.c
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.53 2002/03/27 20:52:58 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|LOG_snotice, "Server \"%s\" unregistered (connection %d): %s", c->id, c->conn_id, txt );
249                                         else Log( LOG_NOTICE|LOG_snotice, "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- */