src/ngircd/irc.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: irc.c,v 1.58 2002/02/17 17:18:59 alex Exp $
  13  *
  14  * irc.c: IRC-Befehle
  15  *
  16  * $Log: irc.c,v $
  17  * Revision 1.58  2002/02/17 17:18:59  alex
  18  * - NICK korrigiert.
  19  *
  20  * Revision 1.57  2002/02/13 23:05:29  alex
  21  * - Nach Connect eines Users werden LUSERS-Informationen angezeigt.
  22  *
  23  * Revision 1.56  2002/02/13 17:52:27  alex
  24  * - es werden nun Channel- und User-Modes von Usern angenommen.
  25  *
  26  * Revision 1.55  2002/02/12 14:40:37  alex
  27  * - via NJOIN gemeldete Benutzer wurden nicht in Channels bekannt gemacht.
  28  *
  29  * Revision 1.54  2002/02/11 23:33:35  alex
  30  * - weitere Anpassungen an Channel-Modes und Channel-User-Modes.
  31  *
  32  * Revision 1.53  2002/02/11 16:06:21  alex
  33  * - Die Quelle von MODE-Aenderungen wird nun korrekt weitergegeben.
  34  *
  35  * Revision 1.52  2002/02/11 15:52:21  alex
  36  * - PONG an den Server selber wurde faelschlicherweise versucht zu forwarden.
  37  * - Channel-Modes wurden falsch geliefert (als User-Modes).
  38  *
  39  * Revision 1.51  2002/02/11 15:15:53  alex
  40  * - PING und PONG werden nun auch korrekt an andere Server geforwarded.
  41  * - bei MODE-Meldungen wird der letzte Parameter nicht mehr mit ":" getrennt.
  42  *
  43  * Revision 1.50  2002/02/11 01:03:20  alex
  44  * - Aenderungen und Anpassungen an Channel-Modes und Channel-User-Modes:
  45  *   Modes werden besser geforwarded, lokale User, fuer die ein Channel
  46  *   angelegt wird, werden Channel-Operator, etc. pp. ...
  47  * - NJOIN's von Servern werden nun korrekt an andere Server weitergeleitet.
  48  *
  49  * Revision 1.49  2002/02/06 16:51:22  alex
  50  * - neue Funktion zur MODE-Behandlung, fuer Channel-Modes vorbereitet.
  51  *
  52  * Revision 1.48  2002/01/29 00:13:45  alex
  53  * - WHOIS zeigt nun auch die Channels an, in denen der jeweilige User Mitglied ist.
  54  * - zu jedem Server wird nun der "Top-Server" gespeichert, somit funktioniert
  55  *   LINKS wieder korrekt.
  56  *
  57  * Revision 1.47  2002/01/28 13:05:48  alex
  58  * - nach einem JOIN wird die Liste der Mitglieder an den Client geschickt.
  59  * - MODE fuer Channels wird nun komplett ignoriert (keine Fehlermeldung mehr).
  60  *
  61  * Revision 1.46  2002/01/28 01:45:43  alex
  62  * - SERVER-Meldungen an neue Server sind nun in der richtigen Reihenfolge.
  63  *
  64  * Revision 1.45  2002/01/28 01:18:14  alex
  65  * - connectierenden Servern werden Channels nun mit NJOIN bekannt gemacht.
  66  *
  67  * Revision 1.44  2002/01/28 00:55:08  alex
  68  * - ein neu connectierender Server wird nun korrekt im Netz bekannt gemacht.
  69  *
  70  * Revision 1.43  2002/01/27 21:56:39  alex
  71  * - IRC_WriteStrServersPrefixID() und IRC_WriteStrClientPrefixID() wieder entfernt.
  72  * - einige kleinere Fixes bezueglich Channels ...
  73  *
  74  * Revision 1.42  2002/01/27 18:28:01  alex
  75  * - bei NICK wurde das falsche Prefix an andere Server weitergegeben.
  76  *
  77  * Revision 1.41  2002/01/27 17:15:49  alex
  78  * - anderungen an den Funktions-Prototypen von IRC_WriteStrChannel() und
  79  *   IRC_WriteStrChannelPrefix(),
  80  * - neue: IRC_WriteStrClientPrefixID() und IRC_WriteStrServersPrefixID().
  81  *
  82  * Revision 1.40  2002/01/26 18:43:11  alex
  83  * - neue Funktionen IRC_WriteStrChannelPrefix() und IRC_WriteStrChannel(),
  84  *   die IRC_Write_xxx_Related() sind dafuer entfallen.
  85  * - IRC_PRIVMSG() kann nun auch mit Channels als Ziel umgehen.
  86  *
  87  * Revision 1.39  2002/01/21 00:05:11  alex
  88  * - neue Funktionen IRC_JOIN und IRC_PART begonnen, ebenso die Funktionen
  89  *   IRC_WriteStrRelatedPrefix und IRC_WriteStrRelatedChannelPrefix().
  90  * - diverse Aenderungen im Zusammenhang mit Channels.
  91  *
  92  * Revision 1.38  2002/01/18 15:31:32  alex
  93  * - die User-Modes bei einem NICK von einem Server wurden falsch uebernommen.
  94  *
  95  * Revision 1.37  2002/01/16 22:10:18  alex
  96  * - IRC_LUSERS() implementiert.
  97  *
  98  * Revision 1.36  2002/01/11 23:50:55  alex
  99  * - LINKS implementiert, LUSERS begonnen.
 100  *
 101  * Revision 1.35  2002/01/09 21:30:45  alex
 102  * - WHOIS wurde faelschlicherweise an User geforwarded statt vom Server beantwortet.
 103  *
 104  * Revision 1.34  2002/01/09 01:09:58  alex
 105  * - WHOIS wird im "Strict-RFC-Mode" nicht mehr automatisch geforwarded,
 106  * - andere Server werden nun ueber bisherige Server und User informiert.
 107  *
 108  * Revision 1.33  2002/01/07 23:42:12  alex
 109  * - Es werden fuer alle Server eigene Token generiert,
 110  * - QUIT von einem Server fuer einen User wird an andere Server geforwarded,
 111  * - ebenso NICK-Befehle, die "fremde" User einfuehren.
 112  *
 113  * Revision 1.32  2002/01/07 16:02:36  alex
 114  * - Loglevel von Remote-Mode-Aenderungen angepasst (nun Debug).
 115  * - Im Debug-Mode werden nun auch PING's protokolliert.
 116  *
 117  * Revision 1.31  2002/01/07 15:39:46  alex
 118  * - Server nimmt nun Server-Links an: PASS und SERVER entsprechend angepasst.
 119  * - MODE und NICK melden nun die Aenderungen an andere Server.
 120  *
 121  * Revision 1.30  2002/01/06 15:21:29  alex
 122  * - Loglevel und Meldungen nochmals ueberarbeitet.
 123  * - QUIT und SQUIT forwarden nun den Grund der Trennung,
 124  * - WHOIS wird nun immer an den "Original-Server" weitergeleitet.
 125  *
 126  * Revision 1.29  2002/01/05 23:24:54  alex
 127  * - WHOIS erweitert: Anfragen koennen an andere Server weitergeleitet werden.
 128  * - Vorbereitungen fuer Ident-Abfragen bei neuen Client-Strukturen.
 129  *
 130  * Revision 1.28  2002/01/05 20:08:02  alex
 131  * - Div. Aenderungen fuer die Server-Links (u.a. WHOIS, QUIT, NICK angepasst).
 132  * - Neue Funktionen IRC_WriteStrServer() und IRC_WriteStrServerPrefix().
 133  *
 134  * Revision 1.27  2002/01/05 19:15:03  alex
 135  * - Fehlerpruefung bei select() in der "Hauptschleife" korrigiert.
 136  *
 137  * Revision 1.26  2002/01/05 16:51:18  alex
 138  * - das Passwort von Servern wird nun ueberprueft (PASS- und SERVER-Befehl).
 139  *
 140  * Revision 1.25  2002/01/05 00:48:33  alex
 141  * - bei SQUIT wurde immer die Verbindung getrennt, auch bei Remote-Servern.
 142  *
 143  * Revision 1.24  2002/01/04 17:58:44  alex
 144  * - IRC_WriteStrXXX()-Funktionen eingefuehrt, groessere Anpassungen daran.
 145  * - neuer Befehl SQUIT, QUIT an Server-Links angepasst.
 146  *
 147  * Revision 1.23  2002/01/04 01:36:40  alex
 148  * - Loglevel ein wenig angepasst.
 149  *
 150  * Revision 1.22  2002/01/04 01:21:47  alex
 151  * - Client-Strukruren werden nur noch ueber Funktionen angesprochen.
 152  * - Weitere Anpassungen und Erweiterungen der Server-Links.
 153  *
 154  * Revision 1.21  2002/01/03 02:26:51  alex
 155  * - neue Befehle SERVER und NJOIN begonnen,
 156  * - begonnen, diverse IRC-Befehle an Server-Links anzupassen.
 157  *
 158  * Revision 1.20  2002/01/02 12:46:41  alex
 159  * - die Gross- und Kleinschreibung des Nicks kann mit NICK nun geaendert werden.
 160  *
 161  * Revision 1.19  2002/01/02 02:51:39  alex
 162  * - Copyright-Texte angepasst.
 163  * - neuer Befehl "ERROR".
 164  *
 165  * Revision 1.17  2001/12/31 15:33:13  alex
 166  * - neuer Befehl NAMES, kleinere Bugfixes.
 167  * - Bug bei PING behoben: war zu restriktiv implementiert :-)
 168  *
 169  * Revision 1.16  2001/12/31 02:18:51  alex
 170  * - viele neue Befehle (WHOIS, ISON, OPER, DIE, RESTART),
 171  * - neuen Header "defines.h" mit (fast) allen Konstanten.
 172  * - Code Cleanups und viele "kleine" Aenderungen & Bugfixes.
 173  *
 174  * Revision 1.15  2001/12/30 19:26:11  alex
 175  * - Unterstuetzung fuer die Konfigurationsdatei eingebaut.
 176  *
 177  * Revision 1.14  2001/12/30 11:42:00  alex
 178  * - der Server meldet nun eine ordentliche "Start-Zeit".
 179  *
 180  * Revision 1.13  2001/12/29 03:10:06  alex
 181  * - Neue Funktion IRC_MODE() implementiert, div. Aenderungen.
 182  * - neue configure-Optione "--enable-strict-rfc".
 183  *
 184  * Revision 1.12  2001/12/27 19:17:26  alex
 185  * - neue Befehle PRIVMSG, NOTICE, PING.
 186  *
 187  * Revision 1.11  2001/12/27 16:55:41  alex
 188  * - neu: IRC_WriteStrRelated(), Aenderungen auch in IRC_WriteStrClient().
 189  *
 190  * Revision 1.10  2001/12/26 22:48:53  alex
 191  * - MOTD-Datei ist nun konfigurierbar und wird gelesen.
 192  *
 193  * Revision 1.9  2001/12/26 14:45:37  alex
 194  * - "Code Cleanups".
 195  *
 196  * Revision 1.8  2001/12/26 03:21:46  alex
 197  * - PING/PONG-Befehle implementiert,
 198  * - Meldungen ueberarbeitet: enthalten nun (fast) immer den Nick.
 199  *
 200  * Revision 1.7  2001/12/25 23:25:18  alex
 201  * - und nochmal Aenderungen am Logging ;-)
 202  *
 203  * Revision 1.6  2001/12/25 23:13:33  alex
 204  * - Debug-Meldungen angepasst.
 205  *
 206  * Revision 1.5  2001/12/25 22:02:42  alex
 207  * - neuer IRC-Befehl "/QUIT". Verbessertes Logging & Debug-Ausgaben.
 208  *
 209  * Revision 1.4  2001/12/25 19:19:30  alex
 210  * - bessere Fehler-Abfragen, diverse Bugfixes.
 211  * - Nicks werden nur einmal vergeben :-)
 212  * - /MOTD wird unterstuetzt.
 213  *
 214  * Revision 1.3  2001/12/24 01:34:06  alex
 215  * - USER und NICK wird nun in beliebiger Reihenfolge akzeptiert (wg. BitchX)
 216  * - MOTD-Ausgabe begonnen zu implementieren.
 217  *
 218  * Revision 1.2  2001/12/23 21:57:16  alex
 219  * - erste IRC-Befehle zu implementieren begonnen.
 220  *
 221  * Revision 1.1  2001/12/14 08:13:43  alex
 222  * - neues Modul begonnen :-)
 223  */
 224
 225
 226 #include <portab.h>
 227 #include "global.h"
 228
 229 #include <imp.h>
 230 #include <assert.h>
 231 #include <errno.h>
 232 #include <stdarg.h>
 233 #include <stdio.h>
 234 #include <stdlib.h>
 235 #include <string.h>
 236
 237 #include "ngircd.h"
 238 #include "channel.h"
 239 #include "client.h"
 240 #include "conf.h"
 241 #include "conn.h"
 242 #include "log.h"
 243 #include "messages.h"
 244 #include "parse.h"
 245 #include "tool.h"
 246
 247 #include <exp.h>
 248 #include "irc.h"
 249
 250
 251 #define CONNECTED TRUE
 252 #define DISCONNECTED FALSE
 253
 254
 255 LOCAL BOOLEAN Hello_User( CLIENT *Client );
 256 LOCAL BOOLEAN Show_MOTD( CLIENT *Client );
 257
 258 LOCAL VOID Kill_Nick( CHAR *Nick );
 259
 260 LOCAL BOOLEAN Send_NAMES( CLIENT *Client, CHANNEL *Chan );
 261 LOCAL BOOLEAN Send_LUSERS( CLIENT *Client );
 262
 263
 264 GLOBAL VOID IRC_Init( VOID )
 265 {
 266 } /* IRC_Init */
 267
 268
 269 GLOBAL VOID IRC_Exit( VOID )
 270 {
 271 } /* IRC_Exit */
 272
 273
 274 GLOBAL BOOLEAN IRC_WriteStrClient( CLIENT *Client, CHAR *Format, ... )
 275 {
 276         CHAR buffer[1000];
 277         BOOLEAN ok = CONNECTED;
 278         va_list ap;
 279
 280         assert( Client != NULL );
 281         assert( Format != NULL );
 282
 283         va_start( ap, Format );
 284         vsnprintf( buffer, 1000, Format, ap );
 285         va_end( ap );
 286
 287         /* an den Client selber */
 288         ok = IRC_WriteStrClientPrefix( Client, Client_ThisServer( ), buffer );
 289
 290         return ok;
 291 } /* IRC_WriteStrClient */
 292
 293
 294 GLOBAL BOOLEAN IRC_WriteStrClientPrefix( CLIENT *Client, CLIENT *Prefix, CHAR *Format, ... )
 295 {
 296         /* Text an Clients, lokal bzw. remote, senden. */
 297
 298         CHAR buffer[1000];
 299         va_list ap;
 300
 301         assert( Client != NULL );
 302         assert( Format != NULL );
 303         assert( Prefix != NULL );
 304
 305         va_start( ap, Format );
 306         vsnprintf( buffer, 1000, Format, ap );
 307         va_end( ap );
 308
 309         return Conn_WriteStr( Client_Conn( Client_NextHop( Client )), ":%s %s", Client_ID( Prefix ), buffer );
 310 } /* IRC_WriteStrClientPrefix */
 311
 312
 313 GLOBAL BOOLEAN IRC_WriteStrChannel( CLIENT *Client, CHANNEL *Chan, BOOLEAN Remote, CHAR *Format, ... )
 314 {
 315         CHAR buffer[1000];
 316         va_list ap;
 317
 318         assert( Client != NULL );
 319         assert( Format != NULL );
 320
 321         va_start( ap, Format );
 322         vsnprintf( buffer, 1000, Format, ap );
 323         va_end( ap );
 324
 325         return IRC_WriteStrChannelPrefix( Client, Chan, Client_ThisServer( ), Remote, buffer );
 326 } /* IRC_WriteStrChannel */
 327
 328
 329 GLOBAL BOOLEAN IRC_WriteStrChannelPrefix( CLIENT *Client, CHANNEL *Chan, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
 330 {
 331         CHAR buffer[1000];
 332         BOOLEAN sock[MAX_CONNECTIONS], ok = CONNECTED;
 333         CL2CHAN *cl2chan;
 334         CLIENT *c;
 335         INT s, i;
 336         va_list ap;
 337
 338         assert( Client != NULL );
 339         assert( Chan != NULL );
 340         assert( Prefix != NULL );
 341         assert( Format != NULL );
 342
 343         va_start( ap, Format );
 344         vsnprintf( buffer, 1000, Format, ap );
 345         va_end( ap );
 346
 347         for( i = 0; i < MAX_CONNECTIONS; i++ ) sock[i] = FALSE;
 348
 349         /* An alle Clients, die in den selben Channels sind.
 350          * Dabei aber nur einmal je Remote-Server */
 351         cl2chan = Channel_FirstMember( Chan );
 352         while( cl2chan )
 353         {
 354                 c = Channel_GetClient( cl2chan );
 355                 if( ! Remote )
 356                 {
 357                         if( Client_Conn( c ) <= NONE ) c = NULL;
 358                         else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 359                 }
 360                 if( c ) c = Client_NextHop( c );
 361
 362                 if( c && ( c != Client ))
 363                 {
 364                         /* Ok, anderer Client */
 365                         s = Client_Conn( c );
 366                         assert( s >= 0 );
 367                         assert( s < MAX_CONNECTIONS );
 368                         sock[s] = TRUE;
 369                 }
 370                 cl2chan = Channel_NextMember( Chan, cl2chan );
 371         }
 372
 373         /* Senden ... */
 374         for( i = 0; i < MAX_CONNECTIONS; i++ )
 375         {
 376                 if( sock[i] )
 377                 {
 378                         ok = Conn_WriteStr( i, ":%s %s", Client_ID( Prefix ), buffer );
 379                         if( ! ok ) break;
 380                 }
 381         }
 382         return ok;
 383 } /* IRC_WriteStrChannelPrefix */
 384
 385
 386 GLOBAL VOID IRC_WriteStrServers( CLIENT *ExceptOf, CHAR *Format, ... )
 387 {
 388         CHAR buffer[1000];
 389         va_list ap;
 390
 391         assert( Format != NULL );
 392
 393         va_start( ap, Format );
 394         vsnprintf( buffer, 1000, Format, ap );
 395         va_end( ap );
 396
 397         /* an den Client selber */
 398         return IRC_WriteStrServersPrefix( ExceptOf, Client_ThisServer( ), buffer );
 399 } /* IRC_WriteStrServers */
 400
 401
 402 GLOBAL VOID IRC_WriteStrServersPrefix( CLIENT *ExceptOf, CLIENT *Prefix, CHAR *Format, ... )
 403 {
 404         CHAR buffer[1000];
 405         CLIENT *c;
 406         va_list ap;
 407
 408         assert( Format != NULL );
 409         assert( Prefix != NULL );
 410
 411         va_start( ap, Format );
 412         vsnprintf( buffer, 1000, Format, ap );
 413         va_end( ap );
 414
 415         c = Client_First( );
 416         while( c )
 417         {
 418                 if(( Client_Type( c ) == CLIENT_SERVER ) && ( Client_Conn( c ) > NONE ) && ( c != Client_ThisServer( )) && ( c != ExceptOf ))
 419                 {
 420                         /* Ziel-Server gefunden */
 421                         IRC_WriteStrClientPrefix( c, Prefix, buffer );
 422                 }
 423                 c = Client_Next( c );
 424         }
 425 } /* IRC_WriteStrServersPrefix */
 426
 427
 428 GLOBAL BOOLEAN IRC_WriteStrRelatedPrefix( CLIENT *Client, CLIENT *Prefix, BOOLEAN Remote, CHAR *Format, ... )
 429 {
 430         BOOLEAN sock[MAX_CONNECTIONS], ok = CONNECTED;
 431         CL2CHAN *chan_cl2chan, *cl2chan;
 432         CHAR buffer[1000];
 433         CHANNEL *chan;
 434         va_list ap;
 435         CLIENT *c;
 436         INT i, s;
 437
 438         assert( Client != NULL );
 439         assert( Prefix != NULL );
 440         assert( Format != NULL );
 441
 442         va_start( ap, Format );
 443         vsnprintf( buffer, 1000, Format, ap );
 444         va_end( ap );
 445
 446         /* initialisieren */
 447         for( i = 0; i < MAX_CONNECTIONS; i++ ) sock[i] = FALSE;
 448
 449         /* An alle Clients, die in einem Channel mit dem "Ausloeser" sind,
 450          * den Text schicken. An Remote-Server aber jeweils nur einmal. */
 451         chan_cl2chan = Channel_FirstChannelOf( Client );
 452         while( chan_cl2chan )
 453         {
 454                 /* Channel des Users durchsuchen */
 455                 chan = Channel_GetChannel( chan_cl2chan );
 456                 cl2chan = Channel_FirstMember( chan );
 457                 while( cl2chan )
 458                 {
 459                         c = Channel_GetClient( cl2chan );
 460                         if( ! Remote )
 461                         {
 462                                 if( Client_Conn( c ) <= NONE ) c = NULL;
 463                                 else if( Client_Type( c ) == CLIENT_SERVER ) c = NULL;
 464                         }
 465                         if( c ) c = Client_NextHop( c );
 466
 467                         if( c && ( c != Client ))
 468                         {
 469                                 /* Ok, anderer Client */
 470                                 s = Client_Conn( c );
 471                                 assert( s >= 0 );
 472                                 assert( s < MAX_CONNECTIONS );
 473                                 sock[s] = TRUE;
 474                         }
 475                         cl2chan = Channel_NextMember( chan, cl2chan );
 476                 }
 477
 478                 /* naechsten Channel */
 479                 chan_cl2chan = Channel_NextChannelOf( Client, chan_cl2chan );
 480         }
 481
 482         /* Senden ... */
 483         for( i = 0; i < MAX_CONNECTIONS; i++ )
 484         {
 485                 if( sock[i] )
 486                 {
 487                         ok = Conn_WriteStr( i, ":%s %s", Client_ID( Prefix ), buffer );
 488                         if( ! ok ) break;
 489                 }
 490         }
 491         return ok;
 492 } /* IRC_WriteStrRelatedPrefix */
 493
 494
 495
 496 GLOBAL BOOLEAN IRC_PASS( CLIENT *Client, REQUEST *Req )
 497 {
 498         assert( Client != NULL );
 499         assert( Req != NULL );
 500
 501         /* Fehler liefern, wenn kein lokaler Client */
 502         if( Client_Conn( Client ) <= NONE ) return IRC_WriteStrClient( Client, ERR_UNKNOWNCOMMAND_MSG, Client_ID( Client ), Req->command );
 503
 504         if(( Client_Type( Client ) == CLIENT_UNKNOWN ) && ( Req->argc == 1))
 505         {
 506                 /* noch nicht registrierte unbekannte Verbindung */
 507                 Log( LOG_DEBUG, "Connection %d: got PASS command ...", Client_Conn( Client ));
 508
 509                 /* Passwort speichern */
 510                 Client_SetPassword( Client, Req->argv[0] );
 511
 512                 Client_SetType( Client, CLIENT_GOTPASS );
 513                 return CONNECTED;
 514         }
 515         else if((( Client_Type( Client ) == CLIENT_UNKNOWN ) || ( Client_Type( Client ) == CLIENT_UNKNOWNSERVER )) && (( Req->argc == 3 ) || ( Req->argc == 4 )))
 516         {
 517                 /* noch nicht registrierte Server-Verbindung */
 518                 Log( LOG_DEBUG, "Connection %d: got PASS command (new server link) ...", Client_Conn( Client ));
 519
 520                 /* Passwort speichern */
 521                 Client_SetPassword( Client, Req->argv[0] );
 522
 523                 Client_SetType( Client, CLIENT_GOTPASSSERVER );
 524                 return CONNECTED;
 525         }
 526         else if(( Client_Type( Client ) == CLIENT_UNKNOWN  ) || ( Client_Type( Client ) == CLIENT_UNKNOWNSERVER ))
 527         {
 528                 /* Falsche Anzahl Parameter? */
 529                 return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 530         }
 531         else return IRC_WriteStrClient( Client, ERR_ALREADYREGISTRED_MSG, Client_ID( Client ));
 532 } /* IRC_PASS */
 533
 534
 535 GLOBAL BOOLEAN IRC_SERVER( CLIENT *Client, REQUEST *Req )
 536 {
 537         CHAR str[LINE_LEN], *ptr;
 538         CLIENT *from, *c, *cl;
 539         CL2CHAN *cl2chan;
 540         INT max_hops, i;
 541         CHANNEL *chan;
 542         BOOLEAN ok;
 543
 544         assert( Client != NULL );
 545         assert( Req != NULL );
 546
 547         /* Fehler liefern, wenn kein lokaler Client */
 548         if( Client_Conn( Client ) <= NONE ) return IRC_WriteStrClient( Client, ERR_UNKNOWNCOMMAND_MSG, Client_ID( Client ), Req->command );
 549
 550         if( Client_Type( Client ) == CLIENT_GOTPASSSERVER )
 551         {
 552                 /* Verbindung soll als Server-Server-Verbindung registriert werden */
 553                 Log( LOG_DEBUG, "Connection %d: got SERVER command (new server link) ...", Client_Conn( Client ));
 554
 555                 /* Falsche Anzahl Parameter? */
 556                 if(( Req->argc != 2 ) && ( Req->argc != 3 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 557
 558                 /* Ist dieser Server bei uns konfiguriert? */
 559                 for( i = 0; i < Conf_Server_Count; i++ ) if( strcasecmp( Req->argv[0], Conf_Server[i].name ) == 0 ) break;
 560                 if( i >= Conf_Server_Count )
 561                 {
 562                         /* Server ist nicht konfiguriert! */
 563                         Log( LOG_ERR, "Connection %d: Server \"%s\" not configured here!", Client_Conn( Client ), Req->argv[0] );
 564                         Conn_Close( Client_Conn( Client ), NULL, "Server not configured here", TRUE );
 565                         return DISCONNECTED;
 566                 }
 567                 if( strcmp( Client_Password( Client ), Conf_Server[i].pwd ) != 0 )
 568                 {
 569                         /* Falsches Passwort */
 570                         Log( LOG_ERR, "Connection %d: Bad password for server \"%s\"!", Client_Conn( Client ), Req->argv[0] );
 571                         Conn_Close( Client_Conn( Client ), NULL, "Bad password", TRUE );
 572                         return DISCONNECTED;
 573                 }
 574
 575                 /* Ist ein Server mit dieser ID bereits registriert? */
 576                 if( ! Client_CheckID( Client, Req->argv[0] )) return DISCONNECTED;
 577
 578                 /* Server-Strukturen fuellen ;-) */
 579                 Client_SetID( Client, Req->argv[0] );
 580                 Client_SetHops( Client, 1 );
 581                 Client_SetInfo( Client, Req->argv[Req->argc - 1] );
 582
 583                 /* Meldet sich der Server bei uns an? */
 584                 if( Req->argc == 2 )
 585                 {
 586                         /* Unseren SERVER- und PASS-Befehl senden */
 587                         ok = TRUE;
 588                         if( ! IRC_WriteStrClient( Client, "PASS %s "PASSSERVERADD, Conf_Server[i].pwd )) ok = FALSE;
 589                         else ok = IRC_WriteStrClient( Client, "SERVER %s 1 :%s", Conf_ServerName, Conf_ServerInfo );
 590                         if( ! ok )
 591                         {
 592                                 Conn_Close( Client_Conn( Client ), "Unexpected server behavior!", NULL, FALSE );
 593                                 return DISCONNECTED;
 594                         }
 595                         Client_SetIntroducer( Client, Client );
 596                         Client_SetToken( Client, 1 );
 597                 }
 598                 else  Client_SetToken( Client, atoi( Req->argv[1] ));
 599
 600                 Log( LOG_NOTICE, "Server \"%s\" registered (connection %d, 1 hop - direct link).", Client_ID( Client ), Client_Conn( Client ));
 601
 602                 Client_SetType( Client, CLIENT_SERVER );
 603
 604                 /* maximalen Hop Count ermitteln */
 605                 max_hops = 0;
 606                 c = Client_First( );
 607                 while( c )
 608                 {
 609                         if( Client_Hops( c ) > max_hops ) max_hops = Client_Hops( c );
 610                         c = Client_Next( c );
 611                 }
 612
 613                 /* Alle bisherigen Server dem neuen Server bekannt machen,
 614                  * die bisherigen Server ueber den neuen informierenn */
 615                 for( i = 0; i < ( max_hops + 1 ); i++ )
 616                 {
 617                         c = Client_First( );
 618                         while( c )
 619                         {
 620                                 if(( Client_Type( c ) == CLIENT_SERVER ) && ( c != Client ) && ( c != Client_ThisServer( )) && ( Client_Hops( c ) == i ))
 621                                 {
 622                                         if( Client_Conn( c ) > NONE )
 623                                         {
 624                                                 /* Dem gefundenen Server gleich den neuen
 625                                                  * Server bekannt machen */
 626                                                 if( ! IRC_WriteStrClient( c, "SERVER %s %d %d :%s", Client_ID( Client ), Client_Hops( Client ) + 1, Client_MyToken( Client ), Client_Info( Client ))) return DISCONNECTED;
 627                                         }
 628
 629                                         /* Den neuen Server ueber den alten informieren */
 630                                         if( ! IRC_WriteStrClientPrefix( Client, Client_Hops( c ) == 1 ? Client_ThisServer( ) : Client_Introducer( c ), "SERVER %s %d %d :%s", Client_ID( c ), Client_Hops( c ) + 1, Client_MyToken( c ), Client_Info( c ))) return DISCONNECTED;
 631                                 }
 632                                 c = Client_Next( c );
 633                         }
 634                 }
 635
 636                 /* alle User dem neuen Server bekannt machen */
 637                 c = Client_First( );
 638                 while( c )
 639                 {
 640                         if( Client_Type( c ) == CLIENT_USER )
 641                         {
 642                                 /* User an neuen Server melden */
 643                                 if( ! IRC_WriteStrClient( Client, "NICK %s %d %s %s %d +%s :%s", Client_ID( c ), Client_Hops( c ) + 1, Client_User( c ), Client_Hostname( c ), Client_MyToken( Client_Introducer( c )), Client_Modes( c ), Client_Info( c ))) return DISCONNECTED;
 644                         }
 645                         c = Client_Next( c );
 646                 }
 647
 648                 /* Channels dem neuen Server bekannt machen */
 649                 chan = Channel_First( );
 650                 while( chan )
 651                 {
 652                         sprintf( str, "NJOIN %s :", Channel_Name( chan ));
 653
 654                         /* alle Member suchen */
 655                         cl2chan = Channel_FirstMember( chan );
 656                         while( cl2chan )
 657                         {
 658                                 cl = Channel_GetClient( cl2chan );
 659                                 assert( cl != NULL );
 660
 661                                 /* Nick, ggf. mit Modes, anhaengen */
 662                                 if( str[strlen( str ) - 1] != ':' ) strcat( str, "," );
 663                                 if( strchr( Channel_UserModes( chan, cl ), 'v' )) strcat( str, "+" );
 664                                 if( strchr( Channel_UserModes( chan, cl ), 'o' )) strcat( str, "@" );
 665                                 strcat( str, Client_ID( cl ));
 666
 667                                 if( strlen( str ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
 668                                 {
 669                                         /* Zeile senden */
 670                                         if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
 671                                         sprintf( str, "NJOIN %s :", Channel_Name( chan ));
 672                                 }
 673
 674                                 cl2chan = Channel_NextMember( chan, cl2chan );
 675                         }
 676
 677                         /* noch Daten da? */
 678                         if( str[strlen( str ) - 1] != ':')
 679                         {
 680                                 /* Ja; Also senden ... */
 681                                 if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
 682                         }
 683
 684                         /* naechsten Channel suchen */
 685                         chan = Channel_Next( chan );
 686                 }
 687
 688                 return CONNECTED;
 689         }
 690         else if( Client_Type( Client ) == CLIENT_SERVER )
 691         {
 692                 /* Neuer Server wird im Netz angekuendigt */
 693
 694                 /* Falsche Anzahl Parameter? */
 695                 if( Req->argc != 4 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 696
 697                 /* Ist ein Server mit dieser ID bereits registriert? */
 698                 if( ! Client_CheckID( Client, Req->argv[0] )) return DISCONNECTED;
 699
 700                 /* Ueberfluessige Hostnamen aus Info-Text entfernen */
 701                 ptr = strchr( Req->argv[3] + 2, '[' );
 702                 if( ! ptr ) ptr = Req->argv[3];
 703
 704                 from = Client_GetFromID( Req->prefix );
 705                 if( ! from )
 706                 {
 707                         /* Hm, Server, der diesen einfuehrt, ist nicht bekannt!? */
 708                         Log( LOG_ALERT, "Unknown ID in prefix of SERVER: \"%s\"! (on connection %d)", Req->prefix, Client_Conn( Client ));
 709                         Conn_Close( Client_Conn( Client ), NULL, "Unknown ID in prefix of SERVER", TRUE );
 710                         return DISCONNECTED;
 711                 }
 712
 713                 /* Neue Client-Struktur anlegen */
 714                 c = Client_NewRemoteServer( Client, Req->argv[0], from, atoi( Req->argv[1] ), atoi( Req->argv[2] ), ptr, TRUE );
 715                 if( ! c )
 716                 {
 717                         /* Neue Client-Struktur konnte nicht angelegt werden */
 718                         Log( LOG_ALERT, "Can't create client structure for server! (on connection %d)", Client_Conn( Client ));
 719                         Conn_Close( Client_Conn( Client ), NULL, "Can't allocate client structure for remote server", TRUE );
 720                         return DISCONNECTED;
 721                 }
 722
 723                 /* Log-Meldung zusammenbauen und ausgeben */
 724                 if(( Client_Hops( c ) > 1 ) && ( Req->prefix[0] )) sprintf( str, "connected to %s, ", Client_ID( from ));
 725                 else strcpy( str, "" );
 726                 Log( LOG_NOTICE, "Server \"%s\" registered (via %s, %s%d hop%s).", Client_ID( c ), Client_ID( Client ), str, Client_Hops( c ), Client_Hops( c ) > 1 ? "s": "" );
 727
 728                 /* Andere Server informieren */
 729                 IRC_WriteStrServersPrefix( Client, from, "SERVER %s %d %d :%s", Client_ID( c ), Client_Hops( c ) + 1, Client_MyToken( c ), Client_Info( c ));
 730
 731                 return CONNECTED;
 732         }
 733         else return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 734 } /* IRC_SERVER */
 735
 736
 737 GLOBAL BOOLEAN IRC_NJOIN( CLIENT *Client, REQUEST *Req )
 738 {
 739         CHAR *channame, *ptr, modes[8];
 740         BOOLEAN is_op, is_voiced;
 741         CHANNEL *chan;
 742         CLIENT *c;
 743
 744         assert( Client != NULL );
 745         assert( Req != NULL );
 746
 747         if( Client_Type( Client ) != CLIENT_SERVER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTEREDSERVER_MSG, Client_ID( Client ));
 748
 749         /* Falsche Anzahl Parameter? */
 750         if( Req->argc != 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 751
 752         channame = Req->argv[0];
 753         ptr = strtok( Req->argv[1], "," );
 754         while( ptr )
 755         {
 756                 is_op = is_voiced = FALSE;
 757
 758                 /* Prefixe abschneiden */
 759                 while(( *ptr == '@' ) || ( *ptr == '+' ))
 760                 {
 761                         if( *ptr == '@' ) is_op = TRUE;
 762                         if( *ptr == '+' ) is_voiced = TRUE;
 763                         ptr++;
 764                 }
 765
 766                 c = Client_GetFromID( ptr );
 767                 if( c )
 768                 {
 769                         Channel_Join( c, channame );
 770                         chan = Channel_Search( channame );
 771                         assert( chan != NULL );
 772
 773                         if( is_op ) Channel_UserModeAdd( chan, c, 'o' );
 774                         if( is_voiced ) Channel_UserModeAdd( chan, c, 'v' );
 775
 776                         /* im Channel bekannt machen */
 777                         IRC_WriteStrChannelPrefix( Client, chan, c, FALSE, "JOIN :%s", channame );
 778
 779                         /* Channel-User-Modes setzen */
 780                         strcpy( modes, Channel_UserModes( chan, c ));
 781                         if( modes[0] )
 782                         {
 783                                 /* Modes im Channel bekannt machen */
 784                                 IRC_WriteStrChannelPrefix( Client, chan, Client, FALSE, "MODE %s +%s %s", channame, modes, Client_ID( c ));
 785                         }
 786                 }
 787                 else Log( LOG_ERR, "Got NJOIN for unknown nick \"%s\" for channel \"%s\"!", ptr, channame );
 788
 789                 /* naechsten Nick suchen */
 790                 ptr = strtok( NULL, "," );
 791         }
 792
 793         /* an andere Server weiterleiten */
 794         IRC_WriteStrServersPrefix( Client, Client_ThisServer( ), "NJOIN %s :%s", Req->argv[0], Req->argv[1] );
 795
 796         return CONNECTED;
 797 } /* IRC_NJOIN */
 798
 799
 800 GLOBAL BOOLEAN IRC_NICK( CLIENT *Client, REQUEST *Req )
 801 {
 802         CLIENT *intr_c, *target, *c;
 803         CHAR *modes;
 804
 805         assert( Client != NULL );
 806         assert( Req != NULL );
 807
 808         /* Zumindest BitchX sendet NICK-USER in der falschen Reihenfolge. */
 809 #ifndef STRICT_RFC
 810         if( Client_Type( Client ) == CLIENT_UNKNOWN || Client_Type( Client ) == CLIENT_GOTPASS || Client_Type( Client ) == CLIENT_GOTNICK || Client_Type( Client ) == CLIENT_GOTUSER || Client_Type( Client ) == CLIENT_USER || ( Client_Type( Client ) == CLIENT_SERVER && Req->argc == 1 ))
 811 #else
 812         if( Client_Type( Client ) == CLIENT_UNKNOWN || Client_Type( Client ) == CLIENT_GOTPASS || Client_Type( Client ) == CLIENT_GOTNICK || Client_Type( Client ) == CLIENT_USER || ( Client_Type( Client ) == CLIENT_SERVER && Req->argc == 1 ))
 813 #endif
 814         {
 815                 /* User-Registrierung bzw. Nick-Aenderung */
 816
 817                 /* Falsche Anzahl Parameter? */
 818                 if( Req->argc != 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 819
 820                 /* "Ziel-Client" ermitteln */
 821                 if( Client_Type( Client ) == CLIENT_SERVER )
 822                 {
 823                         target = Client_GetFromID( Req->prefix );
 824                         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[0] );
 825                 }
 826                 else
 827                 {
 828                         /* Ist der Client "restricted"? */
 829                         if( Client_HasMode( Client, 'r' )) return IRC_WriteStrClient( Client, ERR_RESTRICTED_MSG, Client_ID( Client ));
 830                         target = Client;
 831                 }
 832
 833 #ifndef STRICT_RFC
 834                 /* Wenn der Client zu seinem eigenen Nick wechseln will, so machen
 835                  * wir nichts. So macht es das Original und mind. Snak hat probleme,
 836                  * wenn wir es nicht so machen. Ob es so okay ist? Hm ... */
 837                 if( strcmp( Client_ID( target ), Req->argv[0] ) == 0 ) return CONNECTED;
 838 #endif
 839
 840                 /* pruefen, ob Nick bereits vergeben. Speziallfall: der Client
 841                  * will nur die Gross- und Kleinschreibung aendern. Das darf
 842                  * er natuerlich machen :-) */
 843                 if( strcasecmp( Client_ID( target ), Req->argv[0] ) != 0 )
 844                 {
 845                         if( ! Client_CheckNick( target, Req->argv[0] )) return CONNECTED;
 846                 }
 847
 848                 if( Client_Type( Client ) == CLIENT_USER )
 849                 {
 850                         /* Nick-Aenderung: allen mitteilen! */
 851                         Log( LOG_INFO, "User \"%s\" changed nick: \"%s\" -> \"%s\".", Client_Mask( target ), Client_ID( target ), Req->argv[0] );
 852                         IRC_WriteStrClient( Client, "NICK :%s", Req->argv[0] );
 853                         IRC_WriteStrRelatedPrefix( Client, Client, TRUE, "NICK :%s", Req->argv[0] );
 854                 }
 855                 else if( Client_Type( Client ) == CLIENT_SERVER )
 856                 {
 857                         /* Nick-Aenderung: allen mitteilen! */
 858                         Log( LOG_DEBUG, "User \"%s\" changed nick: \"%s\" -> \"%s\".", Client_Mask( target ), Client_ID( target ), Req->argv[0] );
 859                         IRC_WriteStrServersPrefix( Client, target, "NICK :%s", Req->argv[0] );
 860                         IRC_WriteStrRelatedPrefix( target, target, FALSE, "NICK :%s", Req->argv[0] );
 861                 }
 862
 863                 /* Client-Nick registrieren */
 864                 Client_SetID( target, Req->argv[0] );
 865
 866                 if(( Client_Type( target ) != CLIENT_USER ) && ( Client_Type( target ) != CLIENT_SERVER ))
 867                 {
 868                         /* Neuer Client */
 869                         Log( LOG_DEBUG, "Connection %d: got NICK command ...", Client_Conn( Client ));
 870                         if( Client_Type( Client ) == CLIENT_GOTUSER ) return Hello_User( Client );
 871                         else Client_SetType( Client, CLIENT_GOTNICK );
 872                 }
 873                 return CONNECTED;
 874         }
 875         else if( Client_Type( Client ) == CLIENT_SERVER )
 876         {
 877                 /* Server fuehrt neuen Client ein */
 878
 879                 /* Falsche Anzahl Parameter? */
 880                 if( Req->argc != 7 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 881
 882                 /* Nick ueberpruefen */
 883                 c = Client_GetFromID( Req->argv[0] );
 884                 if( c )
 885                 {
 886                         /* Der neue Nick ist auf diesem Server bereits registriert:
 887                          * sowohl der neue, als auch der alte Client muessen nun
 888                          * disconnectiert werden. */
 889                         Log( LOG_ERR, "Server %s introduces already registered nick \"%s\"!", Client_ID( Client ), Req->argv[0] );
 890                         Kill_Nick( Req->argv[0] );
 891                         return CONNECTED;
 892                 }
 893
 894                 /* Server, zu dem der Client connectiert ist, suchen */
 895                 intr_c = Client_GetFromToken( Client, atoi( Req->argv[4] ));
 896                 if( ! intr_c )
 897                 {
 898                         Log( LOG_ERR, "Server %s introduces nick \"%s\" on unknown server!?", Client_ID( Client ), Req->argv[0] );
 899                         Kill_Nick( Req->argv[0] );
 900                         return CONNECTED;
 901                 }
 902
 903                 /* Neue Client-Struktur anlegen */
 904                 c = Client_NewRemoteUser( intr_c, Req->argv[0], atoi( Req->argv[1] ), Req->argv[2], Req->argv[3], atoi( Req->argv[4] ), Req->argv[5] + 1, Req->argv[6], TRUE );
 905                 if( ! c )
 906                 {
 907                         /* Eine neue Client-Struktur konnte nicht angelegt werden.
 908                          * Der Client muss disconnectiert werden, damit der Netz-
 909                          * status konsistent bleibt. */
 910                         Log( LOG_ALERT, "Can't create client structure! (on connection %d)", Client_Conn( Client ));
 911                         Kill_Nick( Req->argv[0] );
 912                         return CONNECTED;
 913                 }
 914
 915                 modes = Client_Modes( c );
 916                 if( *modes ) Log( LOG_DEBUG, "User \"%s\" (+%s) registered (via %s, on %s, %d hop%s).", Client_Mask( c ), modes, Client_ID( Client ), Client_ID( intr_c ), Client_Hops( c ), Client_Hops( c ) > 1 ? "s": "" );
 917                 else Log( LOG_DEBUG, "User \"%s\" registered (via %s, on %s, %d hop%s).", Client_Mask( c ), Client_ID( Client ), Client_ID( intr_c ), Client_Hops( c ), Client_Hops( c ) > 1 ? "s": "" );
 918
 919                 /* Andere Server, ausser dem Introducer, informieren */
 920                 IRC_WriteStrServersPrefix( Client, Client, "NICK %s %d %s %s %d %s :%s", Req->argv[0], atoi( Req->argv[1] ) + 1, Req->argv[2], Req->argv[3], Client_MyToken( intr_c ), Req->argv[5], Req->argv[6] );
 921
 922                 return CONNECTED;
 923         }
 924         else return IRC_WriteStrClient( Client, ERR_ALREADYREGISTRED_MSG, Client_ID( Client ));
 925 } /* IRC_NICK */
 926
 927
 928 GLOBAL BOOLEAN IRC_USER( CLIENT *Client, REQUEST *Req )
 929 {
 930         assert( Client != NULL );
 931         assert( Req != NULL );
 932
 933 #ifndef STRICT_RFC
 934         if( Client_Type( Client ) == CLIENT_GOTNICK || Client_Type( Client ) == CLIENT_GOTPASS || Client_Type( Client ) == CLIENT_UNKNOWN )
 935 #else
 936         if( Client_Type( Client ) == CLIENT_GOTNICK || Client_Type( Client ) == CLIENT_GOTPASS )
 937 #endif
 938         {
 939                 /* Falsche Anzahl Parameter? */
 940                 if( Req->argc != 4 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 941
 942                 Client_SetUser( Client, Req->argv[0], FALSE );
 943                 Client_SetInfo( Client, Req->argv[3] );
 944
 945                 Log( LOG_DEBUG, "Connection %d: got USER command ...", Client_Conn( Client ));
 946                 if( Client_Type( Client ) == CLIENT_GOTNICK ) return Hello_User( Client );
 947                 else Client_SetType( Client, CLIENT_GOTUSER );
 948                 return CONNECTED;
 949         }
 950         else if( Client_Type( Client ) == CLIENT_USER || Client_Type( Client ) == CLIENT_SERVER || Client_Type( Client ) == CLIENT_SERVICE )
 951         {
 952                 return IRC_WriteStrClient( Client, ERR_ALREADYREGISTRED_MSG, Client_ID( Client ));
 953         }
 954         else return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 955 } /* IRC_USER */
 956
 957
 958 GLOBAL BOOLEAN IRC_QUIT( CLIENT *Client, REQUEST *Req )
 959 {
 960         CLIENT *target;
 961
 962         assert( Client != NULL );
 963         assert( Req != NULL );
 964
 965         if(( Client_Type( Client ) == CLIENT_USER ) || ( Client_Type( Client ) == CLIENT_SERVICE ))
 966         {
 967                 /* User / Service */
 968
 969                 /* Falsche Anzahl Parameter? */
 970                 if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 971
 972                 if( Req->argc == 0 ) Conn_Close( Client_Conn( Client ), "Got QUIT command.", NULL, TRUE );
 973                 else Conn_Close( Client_Conn( Client ), "Got QUIT command.", Req->argv[0], TRUE );
 974
 975                 return DISCONNECTED;
 976         }
 977         else if ( Client_Type( Client ) == CLIENT_SERVER )
 978         {
 979                 /* Server */
 980
 981                 /* Falsche Anzahl Parameter? */
 982                 if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 983
 984                 target = Client_Search( Req->prefix );
 985                 if( ! target )
 986                 {
 987                         Log( LOG_ERR, "Got QUIT from %s for unknown client!?", Client_ID( Client ));
 988                         return CONNECTED;
 989                 }
 990
 991                 if( Req->argc == 0 ) Client_Destroy( target, "Got QUIT command.", NULL );
 992                 else Client_Destroy( target, "Got QUIT command.", Req->argv[0] );
 993
 994                 return CONNECTED;
 995         }
 996         else return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 997 } /* IRC_QUIT */
 998
 999
1000 GLOBAL BOOLEAN IRC_SQUIT( CLIENT *Client, REQUEST *Req )
1001 {
1002         CLIENT *target;
1003
1004         assert( Client != NULL );
1005         assert( Req != NULL );
1006
1007         /* SQUIT ist nur fuer Server erlaubt */
1008         if( Client_Type( Client ) != CLIENT_SERVER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1009
1010         /* Falsche Anzahl Parameter? */
1011         if( Req->argc != 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1012
1013         target = Client_GetFromID( Req->argv[0] );
1014         if( ! target )
1015         {
1016                 Log( LOG_ERR, "Got SQUIT from %s for unknown server \%s\"!?", Client_ID( Client ), Req->argv[0] );
1017                 return CONNECTED;
1018         }
1019
1020         if( target == Client ) Log( LOG_DEBUG, "Got SQUIT from %s: %s", Client_ID( Client ), Req->argv[1] );
1021         else Log( LOG_DEBUG, "Got SQUIT from %s for %s: %s", Client_ID( Client ), Client_ID( target ), Req->argv[1] );
1022
1023         /* SQUIT an alle Server weiterleiten */
1024         IRC_WriteStrServers( Client, "SQUIT %s :%s", Req->argv[0], Req->argv[1] );
1025
1026         if( Client_Conn( target ) > NONE )
1027         {
1028                 if( Req->argv[1][0] ) Conn_Close( Client_Conn( target ), "Got SQUIT command.", Req->argv[1], TRUE );
1029                 else Conn_Close( Client_Conn( target ), "Got SQUIT command.", NULL, TRUE );
1030                 return DISCONNECTED;
1031         }
1032         else
1033         {
1034                 Client_Destroy( target, "Got SQUIT command.", Req->argv[1] );
1035                 return CONNECTED;
1036         }
1037 } /* IRC_SQUIT */
1038
1039
1040 GLOBAL BOOLEAN IRC_PING( CLIENT *Client, REQUEST *Req )
1041 {
1042         CLIENT *target, *from;
1043
1044         assert( Client != NULL );
1045         assert( Req != NULL );
1046
1047         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1048
1049         /* Falsche Anzahl Parameter? */
1050         if( Req->argc < 1 ) return IRC_WriteStrClient( Client, ERR_NOORIGIN_MSG, Client_ID( Client ));
1051         if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1052
1053         if( Req->argc == 2 )
1054         {
1055                 /* es wurde ein Ziel-Client angegeben */
1056                 target = Client_GetFromID( Req->argv[1] );
1057                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
1058                 if( target != Client_ThisServer( ))
1059                 {
1060                         /* ok, forwarden */
1061                         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
1062                         else from = Client;
1063                         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->prefix );
1064                         return IRC_WriteStrClientPrefix( Client_NextHop( target ), from, "PING %s :%s", Client_ID( from ), Req->argv[1] );
1065                 }
1066         }
1067
1068         Log( LOG_DEBUG, "Connection %d: got PING, sending PONG ...", Client_Conn( Client ));
1069         return IRC_WriteStrClient( Client, "PONG %s :%s", Client_ID( Client_ThisServer( )), Client_ID( Client ));
1070 } /* IRC_PING */
1071
1072
1073 GLOBAL BOOLEAN IRC_PONG( CLIENT *Client, REQUEST *Req )
1074 {
1075         CLIENT *target, *from;
1076
1077         assert( Client != NULL );
1078         assert( Req != NULL );
1079
1080         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1081
1082         /* Falsche Anzahl Parameter? */
1083         if( Req->argc < 1 ) return IRC_WriteStrClient( Client, ERR_NOORIGIN_MSG, Client_ID( Client ));
1084         if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1085
1086         /* forwarden? */
1087         if( Req->argc == 2 )
1088         {
1089                 target = Client_GetFromID( Req->argv[1] );
1090                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
1091                 if( target != Client_ThisServer( ))
1092                 {
1093                         /* ok, forwarden */
1094                         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
1095                         else from = Client;
1096                         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->prefix );
1097                         return IRC_WriteStrClientPrefix( Client_NextHop( target ), from, "PONG %s :%s", Client_ID( from ), Req->argv[1] );
1098                 }
1099         }
1100
1101         /* Der Connection-Timestamp wurde schon beim Lesen aus dem Socket
1102          * aktualisiert, daher muss das hier nicht mehr gemacht werden. */
1103
1104         if( Client_Conn( Client ) > NONE ) Log( LOG_DEBUG, "Connection %d: received PONG. Lag: %d seconds.", Client_Conn( Client ), time( NULL ) - Conn_LastPing( Client_Conn( Client )));
1105         else Log( LOG_DEBUG, "Connection %d: received PONG.", Client_Conn( Client ));
1106
1107         return CONNECTED;
1108 } /* IRC_PONG */
1109
1110
1111 GLOBAL BOOLEAN IRC_MOTD( CLIENT *Client, REQUEST *Req )
1112 {
1113         assert( Client != NULL );
1114         assert( Req != NULL );
1115
1116         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1117
1118         /* Falsche Anzahl Parameter? */
1119         if( Req->argc != 0 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1120
1121         return Show_MOTD( Client );
1122 } /* IRC_MOTD */
1123
1124
1125 GLOBAL BOOLEAN IRC_PRIVMSG( CLIENT *Client, REQUEST *Req )
1126 {
1127         CLIENT *to, *from;
1128         CHANNEL *chan;
1129
1130         assert( Client != NULL );
1131         assert( Req != NULL );
1132
1133         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1134
1135         /* Falsche Anzahl Parameter? */
1136         if( Req->argc == 0 ) return IRC_WriteStrClient( Client, ERR_NORECIPIENT_MSG, Client_ID( Client ), Req->command );
1137         if( Req->argc == 1 ) return IRC_WriteStrClient( Client, ERR_NOTEXTTOSEND_MSG, Client_ID( Client ));
1138         if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1139
1140         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
1141         else from = Client;
1142         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1143
1144         to = Client_Search( Req->argv[0] );
1145         if( to )
1146         {
1147                 /* Okay, Ziel ist ein User */
1148                 if( Client_Conn( from ) > NONE ) Conn_UpdateIdle( Client_Conn( from ));
1149                 return IRC_WriteStrClientPrefix( to, from, "PRIVMSG %s :%s", Client_ID( to ), Req->argv[1] );
1150         }
1151
1152         chan = Channel_Search( Req->argv[0] );
1153         if( chan )
1154         {
1155                 /* Okay, Ziel ist ein Channel */
1156                 if( Client_Conn( from ) > NONE ) Conn_UpdateIdle( Client_Conn( from ));
1157                 return IRC_WriteStrChannelPrefix( Client, chan, from, TRUE, "PRIVMSG %s :%s", Req->argv[0], Req->argv[1] );
1158         }
1159
1160         return IRC_WriteStrClient( from, ERR_NOSUCHNICK_MSG, Client_ID( from ), Req->argv[0] );
1161 } /* IRC_PRIVMSG */
1162
1163
1164 GLOBAL BOOLEAN IRC_NOTICE( CLIENT *Client, REQUEST *Req )
1165 {
1166         CLIENT *to, *from;
1167
1168         assert( Client != NULL );
1169         assert( Req != NULL );
1170
1171         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1172
1173         /* Falsche Anzahl Parameter? */
1174         if( Req->argc != 2 ) return CONNECTED;
1175
1176         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
1177         else from = Client;
1178         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1179
1180         to = Client_Search( Req->argv[0] );
1181         if( to )
1182         {
1183                 /* Okay, Ziel ist ein User */
1184                 return IRC_WriteStrClientPrefix( to, from, "NOTICE %s :%s", Client_ID( to ), Req->argv[1] );
1185         }
1186         else return CONNECTED;
1187 } /* IRC_NOTICE */
1188
1189
1190 GLOBAL BOOLEAN IRC_MODE( CLIENT *Client, REQUEST *Req )
1191 {
1192         CHAR *mode_ptr, the_modes[CLIENT_MODE_LEN], x[2];
1193         CLIENT *cl, *chan_cl, *prefix;
1194         BOOLEAN set, ok;
1195         CHANNEL *chan;
1196
1197         assert( Client != NULL );
1198         assert( Req != NULL );
1199
1200         cl = chan_cl = prefix = NULL;
1201         chan = NULL;
1202
1203         /* Valider Client? */
1204         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1205
1206         /* Keine Parameter? */
1207         if( Req->argc < 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1208
1209         /* Ziel suchen: Client bzw. Channel */
1210         if( Client_IsValidNick( Req->argv[0] )) cl = Client_Search( Req->argv[0] );
1211         if( Channel_IsValidName( Req->argv[0] )) chan = Channel_Search( Req->argv[0] );
1212
1213         /* Kein Ziel gefunden? */
1214         if(( ! cl ) && ( ! chan )) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[0] );
1215
1216         assert(( cl && chan ) != TRUE );
1217
1218         /* Falsche Anzahl Parameter? */
1219         if(( cl ) && ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1220         if(( chan ) && ( Req->argc > 3 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1221
1222         /* Client ermitteln, wenn bei Channel-Modes mit 3 Parametern */
1223         if(( chan ) && (Req->argc == 3 ))
1224         {
1225                 chan_cl = Client_Search( Req->argv[2] );
1226                 if( ! chan_cl ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[0] );
1227         }
1228
1229         /* Wenn Anfragender ein User ist: Zugriff erlaubt? */
1230         if( Client_Type( Client ) == CLIENT_USER )
1231         {
1232                 if( cl )
1233                 {
1234                         /* MODE ist nur fuer sich selber zulaessig! */
1235                         if( cl != Client ) return IRC_WriteStrClient( Client, ERR_USERSDONTMATCH_MSG, Client_ID( Client ));
1236                 }
1237                 if( chan )
1238                 {
1239                         /* Darf der User die Channel-Modes ermitteln? */
1240                 }
1241         }
1242
1243         /* Werden die Modes "nur" erfragt? */
1244         if(( cl ) && ( Req->argc == 1 )) return IRC_WriteStrClient( Client, RPL_UMODEIS_MSG, Client_ID( Client ), Client_Modes( cl ));
1245         if(( chan ) && ( Req->argc == 1 )) return IRC_WriteStrClient( Client, RPL_CHANNELMODEIS_MSG, Client_ID( Client ), Channel_Name( chan ), Channel_Modes( chan ));
1246
1247         mode_ptr = Req->argv[1];
1248
1249         /* Sollen Modes gesetzt oder geloescht werden? */
1250         if( cl )
1251         {
1252                 if( *mode_ptr == '+' ) set = TRUE;
1253                 else if( *mode_ptr == '-' ) set = FALSE;
1254                 else return IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client ));
1255                 mode_ptr++;
1256         }
1257         else
1258         {
1259                 if( *mode_ptr == '-' ) set = FALSE;
1260                 else set = TRUE;
1261                 if(( *mode_ptr == '-' ) || ( *mode_ptr == '+' )) mode_ptr++;
1262         }
1263
1264         /* Prefix fuer Antworten etc. ermitteln */
1265         if( Client_Type( Client ) == CLIENT_SERVER )
1266         {
1267                 prefix = Client_GetFromID( Req->prefix );
1268                 if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1269         }
1270         else prefix = Client;
1271
1272         /* Reply-String mit Aenderungen vorbereiten */
1273         if( set ) strcpy( the_modes, "+" );
1274         else strcpy( the_modes, "-" );
1275
1276         ok = TRUE;
1277         x[1] = '\0';
1278         while( *mode_ptr )
1279         {
1280                 x[0] = '\0';
1281                 if( Client_Type( Client ) == CLIENT_SERVER )
1282                 {
1283                         /* Befehl kommt von einem Server, daher
1284                          * trauen wir ihm "unbesehen" ... */
1285                         x[0] = *mode_ptr;
1286                 }
1287                 else
1288                 {
1289                         /* Modes validieren */
1290                         if( cl )
1291                         {
1292                                 /* User-Modes */
1293                                 switch( *mode_ptr )
1294                                 {
1295                                         case 'i':
1296                                                 /* invisible */
1297                                                 x[0] = 'i';
1298                                                 break;
1299                                         case 'r':
1300                                                 /* restricted (kann nur gesetzt werden) */
1301                                                 if( set ) x[0] = 'r';
1302                                                 else ok = IRC_WriteStrClient( Client, ERR_RESTRICTED_MSG, Client_ID( Client ));
1303                                                 break;
1304                                         case 'o':
1305                                                 /* operator (kann nur geloescht werden) */
1306                                                 if( ! set )
1307                                                 {
1308                                                         Client_SetOperByMe( Client, FALSE );
1309                                                         x[0] = 'o';
1310                                                 }
1311                                                 else ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client ));
1312                                                 break;
1313                                         default:
1314                                                 Log( LOG_DEBUG, "Unknown mode \"%c%c\" from \"%s\"!?", set ? '+' : '-', *mode_ptr, Client_ID( Client ));
1315                                                 ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client ));
1316                                                 x[0] = '\0';
1317                                 }
1318                         }
1319                         if( chan )
1320                         {
1321                                 /* Ist der User ein Channel Operator? */
1322                                 if( ! strchr( Channel_UserModes( chan, Client ), 'o' ))
1323                                 {
1324                                         Log( LOG_DEBUG, "Can't change modes: \"%s\" is not operator on %s!", Client_ID( Client ), Channel_Name( chan ));
1325                                         ok = IRC_WriteStrClient( Client, ERR_CHANOPRIVSNEEDED_MSG, Client_ID( Client ), Channel_Name( chan ));
1326                                         break;
1327                                 }
1328
1329                                 /* Channel-Modes oder Channel-User-Modes */
1330                                 if( chan_cl )
1331                                 {
1332                                         /* Channel-User-Modes */
1333                                         switch( *mode_ptr )
1334                                         {
1335                                                 case 'o':
1336                                                         /* Channel Operator */
1337                                                         x[0] = 'o';
1338                                                         break;
1339                                                 case 'v':
1340                                                         /* Voice */
1341                                                         x[0] = 'v';
1342                                                         break;
1343                                                 default:
1344                                                         Log( LOG_DEBUG, "Unknown channel-user-mode \"%c%c\" from \"%s\" on \"%s\" at %s!?", set ? '+' : '-', *mode_ptr, Client_ID( Client ), Client_ID( chan_cl ), Channel_Name( chan ));
1345                                                         ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client ));
1346                                                         x[0] = '\0';
1347                                         }
1348                                 }
1349                                 else
1350                                 {
1351                                         /* Channel-Modes */
1352                                         switch( *mode_ptr )
1353                                         {
1354                                                 case 'a':
1355                                                         /* Anonymous */
1356                                                         x[0] = 'a';
1357                                                         break;
1358                                                 case 'm':
1359                                                         /* Moderated */
1360                                                         x[0] = 'm';
1361                                                         break;
1362                                                 case 'n':
1363                                                         /* kein Schreiben in den Channel von aussen */
1364                                                         x[0] = 'n';
1365                                                         break;
1366                                                 case 'p':
1367                                                         /* Private */
1368                                                         x[0] = 'p';
1369                                                         break;
1370                                                 case 'q':
1371                                                         /* Quite */
1372                                                         x[0] = 'q';
1373                                                         break;
1374                                                 case 's':
1375                                                         /* Secret */
1376                                                         x[0] = 's';
1377                                                         break;
1378                                                 case 't':
1379                                                         /* Topic Lock */
1380                                                         x[0] = 't';
1381                                                         break;
1382                                                 default:
1383                                                         Log( LOG_DEBUG, "Unknown channel-mode \"%c%c\" from \"%s\" at %s!?", set ? '+' : '-', *mode_ptr, Client_ID( Client ), Channel_Name( chan ));
1384                                                         ok = IRC_WriteStrClient( Client, ERR_UMODEUNKNOWNFLAG_MSG, Client_ID( Client ));
1385                                                         x[0] = '\0';
1386                                         }
1387                                 }
1388                         }
1389                 }
1390                 if( ! ok ) break;
1391
1392                 mode_ptr++;
1393                 if( ! x[0] ) continue;
1394
1395                 /* Okay, gueltigen Mode gefunden */
1396                 if( cl )
1397                 {
1398                         /* Es geht um User-Modes */
1399                         if( set )
1400                         {
1401                                 /* Mode setzen. Wenn der Client ihn noch nicht hatte: merken */
1402                                 if( Client_ModeAdd( cl, x[0] )) strcat( the_modes, x );
1403                         }
1404                         else
1405                         {
1406                                 /* Modes geloescht. Wenn der Client ihn hatte: merken */
1407                                 if( Client_ModeDel( cl, x[0] )) strcat( the_modes, x );
1408                         }
1409                 }
1410                 if( chan )
1411                 {
1412                         /* Es geht um Channel-Modes oder Channel-User-Modes */
1413                         if( chan_cl )
1414                         {
1415                                 /* Channel-User-Modes */
1416                                 if( set )
1417                                 {
1418                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
1419                                         if( Channel_UserModeAdd( chan, chan_cl, x[0] )) strcat( the_modes, x );
1420                                 }
1421                                 else
1422                                 {
1423                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
1424                                         if( Channel_UserModeDel( chan, chan_cl, x[0] )) strcat( the_modes, x );
1425                                 }
1426                         }
1427                         else
1428                         {
1429                                 /* Channel-Mode */
1430                                 if( set )
1431                                 {
1432                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
1433                                         if( Channel_ModeAdd( chan, x[0] )) strcat( the_modes, x );
1434                                 }
1435                                 else
1436                                 {
1437                                         /* Mode setzen. Wenn der Channel ihn noch nicht hatte: merken */
1438                                         if( Channel_ModeDel( chan, x[0] )) strcat( the_modes, x );
1439                                 }
1440                         }
1441                 }
1442         }
1443
1444         /* Wurden Modes geaendert? */
1445         if( the_modes[1] )
1446         {
1447                 if( cl )
1448                 {
1449                         /* Client-Mode */
1450                         if( Client_Type( Client ) == CLIENT_SERVER )
1451                         {
1452                                 /* Modes an andere Server forwarden */
1453                                 IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Client_ID( cl ), the_modes );
1454                         }
1455                         else
1456                         {
1457                                 /* Bestaetigung an Client schicken & andere Server informieren */
1458                                 ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s", Client_ID( cl ), the_modes );
1459                                 IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Client_ID( cl ), the_modes );
1460                         }
1461                         Log( LOG_DEBUG, "User \"%s\": Mode change, now \"%s\".", Client_Mask( cl ), Client_Modes( cl ));
1462                 }
1463                 if( chan )
1464                 {
1465                         /* Channel-Modes oder Channel-User-Mode */
1466                         if( chan_cl )
1467                         {
1468                                 /* Channel-User-Mode */
1469                                 if( Client_Type( Client ) == CLIENT_SERVER )
1470                                 {
1471                                         /* Modes an andere Server und Channel-User forwarden */
1472                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s %s :%s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
1473                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
1474                                 }
1475                                 else
1476                                 {
1477                                         /* Bestaetigung an Client schicken & andere Server sowie Channel-User informieren */
1478                                         ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
1479                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s %s :%s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
1480                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s %s", Channel_Name( chan ), the_modes, Client_ID( chan_cl));
1481                                 }
1482                                 Log( LOG_DEBUG, "User \"%s\" on %s: Mode change, now \"%s\".", Client_Mask( chan_cl), Channel_Name( chan ), Channel_UserModes( chan, chan_cl ));
1483                         }
1484                         else
1485                         {
1486                                 /* Channel-Mode */
1487                                 if( Client_Type( Client ) == CLIENT_SERVER )
1488                                 {
1489                                         /* Modes an andere Server und Channel-User forwarden */
1490                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Channel_Name( chan ), the_modes );
1491                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s", Channel_Name( chan ), the_modes );
1492                                 }
1493                                 else
1494                                 {
1495                                         /* Bestaetigung an Client schicken & andere Server sowie Channel-User informieren */
1496                                         ok = IRC_WriteStrClientPrefix( Client, prefix, "MODE %s %s", Channel_Name( chan ), the_modes );
1497                                         IRC_WriteStrServersPrefix( Client, prefix, "MODE %s :%s", Channel_Name( chan ), the_modes );
1498                                         IRC_WriteStrChannelPrefix( Client, chan, prefix, FALSE, "MODE %s %s", Channel_Name( chan ), the_modes );
1499                                 }
1500                                 Log( LOG_DEBUG, "Channel \"%s\": Mode change, now \"%s\".", Channel_Name( chan ), Channel_Modes( chan ));
1501                         }
1502                 }
1503         }
1504
1505         return ok;
1506 } /* IRC_MODE */
1507
1508
1509 GLOBAL BOOLEAN IRC_OPER( CLIENT *Client, REQUEST *Req )
1510 {
1511         INT i;
1512
1513         assert( Client != NULL );
1514         assert( Req != NULL );
1515
1516         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1517
1518         /* Falsche Anzahl Parameter? */
1519         if( Req->argc != 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1520
1521         /* Operator suchen */
1522         for( i = 0; i < Conf_Oper_Count; i++)
1523         {
1524                 if( Conf_Oper[i].name[0] && Conf_Oper[i].pwd[0] && ( strcmp( Conf_Oper[i].name, Req->argv[0] ) == 0 )) break;
1525         }
1526         if( i >= Conf_Oper_Count )
1527         {
1528                 Log( LOG_WARNING, "Got invalid OPER from \"%s\": Name \"%s\" not configured!", Client_Mask( Client ), Req->argv[0] );
1529                 return IRC_WriteStrClient( Client, ERR_PASSWDMISMATCH_MSG, Client_ID( Client ));
1530         }
1531
1532         /* Stimmt das Passwort? */
1533         if( strcmp( Conf_Oper[i].pwd, Req->argv[1] ) != 0 )
1534         {
1535                 Log( LOG_WARNING, "Got invalid OPER from \"%s\": Bad password for \"%s\"!", Client_Mask( Client ), Conf_Oper[i].name );
1536                 return IRC_WriteStrClient( Client, ERR_PASSWDMISMATCH_MSG, Client_ID( Client ));
1537         }
1538
1539         if( ! Client_HasMode( Client, 'o' ))
1540         {
1541                 /* noch kein o-Mode gesetzt */
1542                 Client_ModeAdd( Client, 'o' );
1543                 if( ! IRC_WriteStrClient( Client, "MODE %s :+o", Client_ID( Client ))) return DISCONNECTED;
1544                 IRC_WriteStrServersPrefix( NULL, Client, "MODE %s :+o", Client_ID( Client ));
1545         }
1546
1547         if( ! Client_OperByMe( Client )) Log( LOG_NOTICE, "Got valid OPER from \"%s\", user is an IRC operator now.", Client_Mask( Client ));
1548
1549         Client_SetOperByMe( Client, TRUE );
1550         return IRC_WriteStrClient( Client, RPL_YOUREOPER_MSG, Client_ID( Client ));
1551 } /* IRC_OPER */
1552
1553
1554 GLOBAL BOOLEAN IRC_DIE( CLIENT *Client, REQUEST *Req )
1555 {
1556         assert( Client != NULL );
1557         assert( Req != NULL );
1558
1559         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1560
1561         /* Falsche Anzahl Parameter? */
1562         if( Req->argc != 0 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1563
1564         if(( ! Client_HasMode( Client, 'o' )) || ( ! Client_OperByMe( Client ))) return IRC_WriteStrClient( Client, ERR_NOPRIVILEGES_MSG, Client_ID( Client ));
1565
1566         Log( LOG_NOTICE, "Got DIE command from \"%s\", going down!", Client_Mask( Client ));
1567         NGIRCd_Quit = TRUE;
1568         return CONNECTED;
1569 } /* IRC_DIE */
1570
1571
1572 GLOBAL BOOLEAN IRC_RESTART( CLIENT *Client, REQUEST *Req )
1573 {
1574         assert( Client != NULL );
1575         assert( Req != NULL );
1576
1577         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1578
1579         /* Falsche Anzahl Parameter? */
1580         if( Req->argc != 0 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1581
1582         if(( ! Client_HasMode( Client, 'o' )) || ( ! Client_OperByMe( Client ))) return IRC_WriteStrClient( Client, ERR_NOPRIVILEGES_MSG, Client_ID( Client ));
1583
1584         Log( LOG_NOTICE, "Got RESTART command from \"%s\", going down!", Client_Mask( Client ));
1585         NGIRCd_Restart = TRUE;
1586         return CONNECTED;
1587 } /* IRC_RESTART */
1588
1589
1590 GLOBAL BOOLEAN IRC_NAMES( CLIENT *Client, REQUEST *Req )
1591 {
1592         CHAR rpl[COMMAND_LEN];
1593         CLIENT *c;
1594
1595         assert( Client != NULL );
1596         assert( Req != NULL );
1597
1598         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1599
1600         /* Falsche Anzahl Parameter? */
1601         if( Req->argc != 0 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1602
1603         /* Noch alle User ausgeben, die in keinem Channel sind */
1604         rpl[0] = '\0';
1605         c = Client_First( );
1606         while( c )
1607         {
1608                 if( Client_Type( c ) == CLIENT_USER )
1609                 {
1610                         /* Okay, das ist ein User */
1611                         strcat( rpl, Client_ID( c ));
1612                         strcat( rpl, " " );
1613                 }
1614
1615                 /* Antwort zu lang? Splitten. */
1616                 if( strlen( rpl ) > 480 )
1617                 {
1618                         if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
1619                         if( ! IRC_WriteStrClient( Client, RPL_NAMREPLY_MSG, Client_ID( Client ), "*", "*", rpl )) return DISCONNECTED;
1620                         rpl[0] = '\0';
1621                 }
1622
1623                 c = Client_Next( c );
1624         }
1625         if( rpl[0] )
1626         {
1627                 /* es wurden User gefunden */
1628                 if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
1629                 if( ! IRC_WriteStrClient( Client, RPL_NAMREPLY_MSG, Client_ID( Client ), "*", "*", rpl )) return DISCONNECTED;
1630         }
1631         return IRC_WriteStrClient( Client, RPL_ENDOFNAMES_MSG, Client_ID( Client ), "*" );
1632 } /* IRC_NAMES */
1633
1634
1635 GLOBAL BOOLEAN IRC_ISON( CLIENT *Client, REQUEST *Req )
1636 {
1637         CHAR rpl[COMMAND_LEN];
1638         CLIENT *c;
1639         CHAR *ptr;
1640         INT i;
1641
1642         assert( Client != NULL );
1643         assert( Req != NULL );
1644
1645         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1646
1647         /* Falsche Anzahl Parameter? */
1648         if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1649
1650         strcpy( rpl, RPL_ISON_MSG );
1651         for( i = 0; i < Req->argc; i++ )
1652         {
1653                 ptr = strtok( Req->argv[i], " " );
1654                 while( ptr )
1655                 {
1656                         ngt_TrimStr( ptr );
1657                         c = Client_GetFromID( ptr );
1658                         if( c && ( Client_Type( c ) == CLIENT_USER ))
1659                         {
1660                                 /* Dieser Nick ist "online" */
1661                                 strcat( rpl, ptr );
1662                                 strcat( rpl, " " );
1663                         }
1664                         ptr = strtok( NULL, " " );
1665                 }
1666         }
1667         if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
1668
1669         return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
1670 } /* IRC_ISON */
1671
1672
1673 GLOBAL BOOLEAN IRC_WHOIS( CLIENT *Client, REQUEST *Req )
1674 {
1675         CLIENT *from, *target, *c;
1676         CHAR str[LINE_LEN + 1], *ptr = NULL;
1677         CL2CHAN *cl2chan;
1678         CHANNEL *chan;
1679
1680         assert( Client != NULL );
1681         assert( Req != NULL );
1682
1683         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1684
1685         /* Falsche Anzahl Parameter? */
1686         if(( Req->argc < 1 ) || ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1687
1688         /* Client suchen */
1689         c = Client_GetFromID( Req->argv[Req->argc - 1] );
1690         if(( ! c ) || ( Client_Type( c ) != CLIENT_USER )) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[Req->argc - 1] );
1691
1692         /* Empfaenger des WHOIS suchen */
1693         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
1694         else from = Client;
1695         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1696
1697         /* Forwarden an anderen Server? */
1698         if( Req->argc > 1 )
1699         {
1700                 /* angegebenen Ziel-Server suchen */
1701                 target = Client_GetFromID( Req->argv[1] );
1702                 if( ! target ) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[1] );
1703                 ptr = Req->argv[1];
1704         }
1705 #ifndef STRICT_RFC
1706         else if( Client_Conn( c ) == NONE )
1707         {
1708                 /* Client ist nicht von uns. Ziel-Server suchen */
1709                 target = c;
1710                 ptr = Req->argv[0];
1711         }
1712 #endif
1713         else target = NULL;
1714
1715         if( target && ( Client_NextHop( target ) != Client_ThisServer( )) && ( Client_Type( Client_NextHop( target )) == CLIENT_SERVER )) return IRC_WriteStrClientPrefix( target, from, "WHOIS %s :%s", Req->argv[0], ptr );
1716
1717         /* Nick, User und Name */
1718         if( ! IRC_WriteStrClient( from, RPL_WHOISUSER_MSG, Client_ID( from ), Client_ID( c ), Client_User( c ), Client_Hostname( c ), Client_Info( c ))) return DISCONNECTED;
1719
1720         /* Server */
1721         if( ! IRC_WriteStrClient( from, RPL_WHOISSERVER_MSG, Client_ID( from ), Client_ID( c ), Client_ID( Client_Introducer( c )), Client_Info( Client_Introducer( c )))) return DISCONNECTED;
1722
1723         /* Channels */
1724         sprintf( str, RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
1725         cl2chan = Channel_FirstChannelOf( c );
1726         while( cl2chan )
1727         {
1728                 chan = Channel_GetChannel( cl2chan );
1729                 assert( chan != NULL );
1730
1731                 /* Channel-Name anhaengen */
1732                 if( str[strlen( str ) - 1] != ':' ) strcat( str, " " );
1733                 if( strchr( Channel_UserModes( chan, c ), 'v' )) strcat( str, "+" );
1734                 if( strchr( Channel_UserModes( chan, c ), 'o' )) strcat( str, "@" );
1735                 strcat( str, Channel_Name( chan ));
1736
1737                 if( strlen( str ) > ( LINE_LEN - CHANNEL_NAME_LEN - 4 ))
1738                 {
1739                         /* Zeile wird zu lang: senden! */
1740                         if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
1741                         sprintf( str, RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
1742                 }
1743
1744                 /* naechstes Mitglied suchen */
1745                 cl2chan = Channel_NextChannelOf( c, cl2chan );
1746         }
1747         if( str[strlen( str ) - 1] != ':')
1748         {
1749                 /* Es sind noch Daten da, die gesendet werden muessen */
1750                 if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
1751         }
1752
1753         /* IRC-Operator? */
1754         if( Client_HasMode( c, 'o' ))
1755         {
1756                 if( ! IRC_WriteStrClient( from, RPL_WHOISOPERATOR_MSG, Client_ID( from ), Client_ID( c ))) return DISCONNECTED;
1757         }
1758
1759         /* Idle (nur lokale Clients) */
1760         if( Client_Conn( c ) > NONE )
1761         {
1762                 if( ! IRC_WriteStrClient( from, RPL_WHOISIDLE_MSG, Client_ID( from ), Client_ID( c ), Conn_GetIdle( Client_Conn ( c )))) return DISCONNECTED;
1763         }
1764
1765         /* End of Whois */
1766         return IRC_WriteStrClient( from, RPL_ENDOFWHOIS_MSG, Client_ID( from ), Client_ID( c ));
1767 } /* IRC_WHOIS */
1768
1769
1770 GLOBAL BOOLEAN IRC_USERHOST( CLIENT *Client, REQUEST *Req )
1771 {
1772         CHAR rpl[COMMAND_LEN];
1773         CLIENT *c;
1774         INT max, i;
1775
1776         assert( Client != NULL );
1777         assert( Req != NULL );
1778
1779         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1780
1781         /* Falsche Anzahl Parameter? */
1782         if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1783
1784         if( Req->argc > 5 ) max = 5;
1785         else max = Req->argc;
1786
1787         strcpy( rpl, RPL_USERHOST_MSG );
1788         for( i = 0; i < max; i++ )
1789         {
1790                 c = Client_GetFromID( Req->argv[i] );
1791                 if( c && ( Client_Type( c ) == CLIENT_USER ))
1792                 {
1793                         /* Dieser Nick ist "online" */
1794                         strcat( rpl, Client_ID( c ));
1795                         if( Client_HasMode( c, 'o' )) strcat( rpl, "*" );
1796                         strcat( rpl, "=" );
1797                         if( Client_HasMode( c, 'a' )) strcat( rpl, "-" );
1798                         else strcat( rpl, "+" );
1799                         strcat( rpl, Client_User( c ));
1800                         strcat( rpl, "@" );
1801                         strcat( rpl, Client_Hostname( c ));
1802                         strcat( rpl, " " );
1803                 }
1804         }
1805         if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
1806
1807         return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
1808 } /* IRC_USERHOST */
1809
1810
1811 GLOBAL BOOLEAN IRC_ERROR( CLIENT *Client, REQUEST *Req )
1812 {
1813         assert( Client != NULL );
1814         assert( Req != NULL );
1815
1816         if( Req->argc < 1 ) Log( LOG_NOTICE, "Got ERROR from \"%s\"!", Client_Mask( Client ));
1817         else Log( LOG_NOTICE, "Got ERROR from \"%s\": %s!", Client_Mask( Client ), Req->argv[0] );
1818
1819         return CONNECTED;
1820 } /* IRC_ERROR */
1821
1822
1823 GLOBAL BOOLEAN IRC_LUSERS( CLIENT *Client, REQUEST *Req )
1824 {
1825         CLIENT *target, *from;
1826
1827         assert( Client != NULL );
1828         assert( Req != NULL );
1829
1830         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1831
1832         /* Falsche Anzahl Parameter? */
1833         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1834
1835         /* Absender ermitteln */
1836         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
1837         else from = Client;
1838         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1839
1840         /* An anderen Server forwarden? */
1841         if( Req->argc == 2 )
1842         {
1843                 target = Client_GetFromID( Req->argv[1] );
1844                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
1845                 else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LUSERS %s %s", Req->argv[0], Req->argv[1] );
1846         }
1847
1848         /* Wer ist der Absender? */
1849         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_GetFromID( Req->prefix );
1850         else target = Client;
1851         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1852
1853         Send_LUSERS( target );
1854
1855         return CONNECTED;
1856 } /* IRC_LUSERS */
1857
1858
1859 GLOBAL BOOLEAN IRC_LINKS( CLIENT *Client, REQUEST *Req )
1860 {
1861         CLIENT *target, *from, *c;
1862         CHAR *mask;
1863
1864         assert( Client != NULL );
1865         assert( Req != NULL );
1866
1867         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1868
1869         /* Falsche Anzahl Parameter? */
1870         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1871
1872         /* Server-Mask ermitteln */
1873         if( Req->argc > 0 ) mask = Req->argv[Req->argc - 1];
1874         else mask = "*";
1875
1876         /* Absender ermitteln */
1877         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
1878         else from = Client;
1879         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1880
1881         /* An anderen Server forwarden? */
1882         if( Req->argc == 2 )
1883         {
1884                 target = Client_GetFromID( Req->argv[0] );
1885                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[0] );
1886                 else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LINKS %s %s", Req->argv[0], Req->argv[1] );
1887         }
1888
1889         /* Wer ist der Absender? */
1890         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_GetFromID( Req->prefix );
1891         else target = Client;
1892         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1893
1894         c = Client_First( );
1895         while( c )
1896         {
1897                 if( Client_Type( c ) == CLIENT_SERVER )
1898                 {
1899                         if( ! IRC_WriteStrClient( target, RPL_LINKS_MSG, Client_ID( target ), Client_ID( c ), Client_ID( Client_TopServer( c ) ? Client_TopServer( c ) : Client_ThisServer( )), Client_Hops( c ), Client_Info( c ))) return DISCONNECTED;
1900                 }
1901                 c = Client_Next( c );
1902         }
1903
1904         return IRC_WriteStrClient( target, RPL_ENDOFLINKS_MSG, Client_ID( target ), mask );
1905 } /* IRC_LINKS */
1906
1907
1908 GLOBAL BOOLEAN IRC_JOIN( CLIENT *Client, REQUEST *Req )
1909 {
1910         CHAR *channame, *flags, modes[8];
1911         BOOLEAN is_new_chan;
1912         CLIENT *target;
1913         CHANNEL *chan;
1914
1915         assert( Client != NULL );
1916         assert( Req != NULL );
1917
1918         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
1919
1920         /* Falsche Anzahl Parameter? */
1921         if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
1922
1923         /* Wer ist der Absender? */
1924         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_GetFromID( Req->prefix );
1925         else target = Client;
1926         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
1927
1928         /* Channel-Namen durchgehen */
1929         channame = strtok( Req->argv[0], "," );
1930         while( channame )
1931         {
1932                 /* wird der Channel neu angelegt? */
1933                 flags = NULL;
1934
1935                 if( Channel_Search( channame )) is_new_chan = FALSE;
1936                 else is_new_chan = TRUE;
1937
1938                 /* Hat ein Server Channel-User-Modes uebergeben? */
1939                 if( Client_Type( Client ) == CLIENT_SERVER )
1940                 {
1941                         /* Channel-Flags extrahieren */
1942                         flags = strchr( channame, 0x7 );
1943                         if( flags ) *flags++ = '\0';
1944                 }
1945
1946                 /* neuer Channel udn lokaler Client? */
1947                 if( is_new_chan && ( Client_Type( Client ) == CLIENT_USER ))
1948                 {
1949                         /* Dann soll der Client Channel-Operator werden! */
1950                         flags = "o";
1951                 }
1952
1953                 /* Channel joinen (und ggf. anlegen) */
1954                 if( ! Channel_Join( target, channame ))
1955                 {
1956                         /* naechsten Namen ermitteln */
1957                         channame = strtok( NULL, "," );
1958                         continue;
1959                 }
1960                 chan = Channel_Search( channame );
1961                 assert( chan != NULL );
1962
1963                 /* Modes setzen (wenn vorhanden) */
1964                 while( flags && *flags )
1965                 {
1966                         Channel_UserModeAdd( chan, target, *flags );
1967                         flags++;
1968                 }
1969
1970                 /* Muessen Modes an andere Server gemeldet werden? */
1971                 strcpy( &modes[1], Channel_UserModes( chan, target ));
1972                 if( modes[1] ) modes[0] = 0x7;
1973                 else modes[0] = '\0';
1974
1975                 /* An andere Server weiterleiten */
1976                 IRC_WriteStrServersPrefix( Client, target, "JOIN :%s%s", channame, modes );
1977
1978                 /* im Channel bekannt machen */
1979                 IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "JOIN :%s", channame );
1980                 if( modes[1] )
1981                 {
1982                         /* Modes im Channel bekannt machen */
1983                         IRC_WriteStrChannelPrefix( Client, chan, target, FALSE, "MODE %s %s :%s", channame, modes, Client_ID( target ));
1984                 }
1985
1986                 if( Client_Type( Client ) == CLIENT_USER )
1987                 {
1988                         /* an Client bestaetigen */
1989                         IRC_WriteStrClientPrefix( Client, target, "JOIN :%s", channame );
1990                         /* Topic an Client schicken */
1991                         IRC_WriteStrClient( Client, RPL_TOPIC_MSG, Client_ID( Client ), channame, "What a wonderful channel!" );
1992                         /* Mitglieder an Client Melden */
1993                         Send_NAMES( Client, chan );
1994                 }
1995
1996                 /* naechsten Namen ermitteln */
1997                 channame = strtok( NULL, "," );
1998         }
1999         return CONNECTED;
2000 } /* IRC_JOIN */
2001
2002
2003 GLOBAL BOOLEAN IRC_PART( CLIENT *Client, REQUEST *Req )
2004 {
2005         CLIENT *target;
2006         CHAR *chan;
2007
2008         assert( Client != NULL );
2009         assert( Req != NULL );
2010
2011         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
2012
2013         /* Falsche Anzahl Parameter? */
2014         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
2015
2016         /* Wer ist der Absender? */
2017         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_GetFromID( Req->prefix );
2018         else target = Client;
2019         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
2020
2021         /* Channel-Namen durchgehen */
2022         chan = strtok( Req->argv[0], "," );
2023         while( chan )
2024         {
2025                 if( ! Channel_Part( target, Client, chan, Req->argc > 1 ? Req->argv[1] : Client_ID( target )))
2026                 {
2027                         /* naechsten Namen ermitteln */
2028                         chan = strtok( NULL, "," );
2029                         continue;
2030                 }
2031
2032                 /* naechsten Namen ermitteln */
2033                 chan = strtok( NULL, "," );
2034         }
2035         return CONNECTED;
2036 } /* IRC_PART */
2037
2038
2039 LOCAL BOOLEAN Hello_User( CLIENT *Client )
2040 {
2041         assert( Client != NULL );
2042
2043         /* Passwort ueberpruefen */
2044         if( strcmp( Client_Password( Client ), Conf_ServerPwd ) != 0 )
2045         {
2046                 /* Falsches Passwort */
2047                 Log( LOG_ERR, "User \"%s\" rejected (connection %d): Bad password!", Client_Mask( Client ), Client_Conn( Client ));
2048                 Conn_Close( Client_Conn( Client ), NULL, "Bad password", TRUE );
2049                 return DISCONNECTED;
2050         }
2051
2052         Log( LOG_NOTICE, "User \"%s\" registered (connection %d).", Client_Mask( Client ), Client_Conn( Client ));
2053
2054         /* Andere Server informieren */
2055         IRC_WriteStrServers( NULL, "NICK %s 1 %s %s 1 +%s :%s", Client_ID( Client ), Client_User( Client ), Client_Hostname( Client ), Client_Modes( Client ), Client_Info( Client ));
2056
2057         if( ! IRC_WriteStrClient( Client, RPL_WELCOME_MSG, Client_ID( Client ), Client_Mask( Client ))) return FALSE;
2058         if( ! IRC_WriteStrClient( Client, RPL_YOURHOST_MSG, Client_ID( Client ), Client_ID( Client_ThisServer( )))) return FALSE;
2059         if( ! IRC_WriteStrClient( Client, RPL_CREATED_MSG, Client_ID( Client ), NGIRCd_StartStr )) return FALSE;
2060         if( ! IRC_WriteStrClient( Client, RPL_MYINFO_MSG, Client_ID( Client ), Client_ID( Client_ThisServer( )))) return FALSE;
2061
2062         Client_SetType( Client, CLIENT_USER );
2063
2064         if( ! Send_LUSERS( Client )) return DISCONNECTED;
2065         if( ! Show_MOTD( Client )) return DISCONNECTED;
2066
2067         return CONNECTED;
2068 } /* Hello_User */
2069
2070
2071 LOCAL BOOLEAN Show_MOTD( CLIENT *Client )
2072 {
2073         BOOLEAN ok;
2074         CHAR line[127];
2075         FILE *fd;
2076
2077         assert( Client != NULL );
2078
2079         fd = fopen( Conf_MotdFile, "r" );
2080         if( ! fd )
2081         {
2082                 Log( LOG_WARNING, "Can't read MOTD file \"%s\": %s", Conf_MotdFile, strerror( errno ));
2083                 return IRC_WriteStrClient( Client, ERR_NOMOTD_MSG, Client_ID( Client ) );
2084         }
2085
2086         IRC_WriteStrClient( Client, RPL_MOTDSTART_MSG, Client_ID( Client ), Client_ID( Client_ThisServer( )));
2087         while( TRUE )
2088         {
2089                 if( ! fgets( line, 126, fd )) break;
2090                 if( line[strlen( line ) - 1] == '\n' ) line[strlen( line ) - 1] = '\0';
2091                 if( ! IRC_WriteStrClient( Client, RPL_MOTD_MSG, Client_ID( Client ), line ))
2092                 {
2093                         fclose( fd );
2094                         return FALSE;
2095                 }
2096         }
2097         ok = IRC_WriteStrClient( Client, RPL_ENDOFMOTD_MSG, Client_ID( Client ) );
2098
2099         fclose( fd );
2100
2101         return ok;
2102 } /* Show_MOTD */
2103
2104
2105 LOCAL VOID Kill_Nick( CHAR *Nick )
2106 {
2107         Log( LOG_ERR, "User(s) with nick \"%s\" will be disconnected!", Nick );
2108         /* FIXME */
2109         Log( LOG_ALERT, "[Kill_Nick() not implemented - OOOPS!]" );
2110 } /* Kill_Nick */
2111
2112
2113 LOCAL BOOLEAN Send_NAMES( CLIENT *Client, CHANNEL *Chan )
2114 {
2115         CHAR str[LINE_LEN + 1];
2116         CL2CHAN *cl2chan;
2117         CLIENT *cl;
2118
2119         assert( Client != NULL );
2120         assert( Chan != NULL );
2121
2122         /* Alle Mitglieder suchen */
2123         sprintf( str, RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
2124         cl2chan = Channel_FirstMember( Chan );
2125         while( cl2chan )
2126         {
2127                 cl = Channel_GetClient( cl2chan );
2128
2129                 /* Nick anhaengen */
2130                 if( str[strlen( str ) - 1] != ':' ) strcat( str, " " );
2131                 if( strchr( Channel_UserModes( Chan, cl ), 'v' )) strcat( str, "+" );
2132                 if( strchr( Channel_UserModes( Chan, cl ), 'o' )) strcat( str, "@" );
2133                 strcat( str, Client_ID( cl ));
2134
2135                 if( strlen( str ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
2136                 {
2137                         /* Zeile wird zu lang: senden! */
2138                         if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
2139                         sprintf( str, RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
2140                 }
2141
2142                 /* naechstes Mitglied suchen */
2143                 cl2chan = Channel_NextMember( Chan, cl2chan );
2144         }
2145         if( str[strlen( str ) - 1] != ':')
2146         {
2147                 /* Es sind noch Daten da, die gesendet werden muessen */
2148                 if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
2149         }
2150
2151         /* Ende anzeigen */
2152         IRC_WriteStrClient( Client, RPL_ENDOFNAMES_MSG, Client_ID( Client ), Channel_Name( Chan ));
2153
2154         return CONNECTED;
2155 } /* Send_NAMES */
2156
2157
2158 LOCAL BOOLEAN Send_LUSERS( CLIENT *Client )
2159 {
2160         INT cnt;
2161
2162         assert( Client != NULL );
2163
2164         /* Users, Services und Serevr im Netz */
2165         if( ! IRC_WriteStrClient( Client, RPL_LUSERCLIENT_MSG, Client_ID( Client ), Client_UserCount( ), Client_ServiceCount( ), Client_ServerCount( ))) return DISCONNECTED;
2166
2167         /* IRC-Operatoren im Netz */
2168         cnt = Client_OperCount( );
2169         if( cnt > 0 )
2170         {
2171                 if( ! IRC_WriteStrClient( Client, RPL_LUSEROP_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
2172         }
2173
2174         /* Unbekannt Verbindungen */
2175         cnt = Client_UnknownCount( );
2176         if( cnt > 0 )
2177         {
2178                 if( ! IRC_WriteStrClient( Client, RPL_LUSERUNKNOWN_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
2179         }
2180
2181         /* Channels im Netz */
2182         if( ! IRC_WriteStrClient( Client, RPL_LUSERCHANNELS_MSG, Client_ID( Client ), Channel_Count( ))) return DISCONNECTED;
2183
2184         /* Channels im Netz */
2185         if( ! IRC_WriteStrClient( Client, RPL_LUSERME_MSG, Client_ID( Client ), Client_MyUserCount( ), Client_MyServiceCount( ), Client_MyServerCount( ))) return DISCONNECTED;
2186
2187         return CONNECTED;
2188 } /* Send_LUSERS */
2189
2190
2191 /* -eof- */