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.86 2002/03/04 01:43:20 alex Exp $
  13  *
  14  * irc.c: IRC-Befehle
  15  *
  16  * $Log: irc.c,v $
  17  * Revision 1.86  2002/03/04 01:43:20  alex
  18  * - der WHO-Befehl (ohne Argumente) gat teilweise Channel-Names vergessen.
  19  *
  20  * Revision 1.85  2002/03/03 19:44:30  alex
  21  * - WHO implementiert (bisher ohne Unterstuetzung von Masks)
  22  *
  23  * Revision 1.84  2002/03/03 17:15:11  alex
  24  * - Source in weitere Module fuer IRC-Befehle aufgesplitted.
  25  *
  26  * Revision 1.83  2002/02/28 00:48:26  alex
  27  * - Forwarding von TOPIC an andere Server gefixed. Hoffentlich ;-)
  28  *
  29  * Revision 1.82  2002/02/27 23:26:36  alex
  30  * - einige Funktionen in irc-xxx-Module ausgegliedert.
  31  *
  32  * Revision 1.81  2002/02/27 20:55:44  alex
  33  * - Channel-Topics werden nun auch korrekt von anderen Server angenommen.
  34  *
  35  * Revision 1.80  2002/02/27 20:33:13  alex
  36  * - Channel-Topics implementiert.
  37  *
  38  * Revision 1.79  2002/02/27 18:57:21  alex
  39  * - PRIVMSG zeugt nun bei Texten an User an, wenn diese "away" sind.
  40  *
  41  * Revision 1.78  2002/02/27 18:23:45  alex
  42  * - IRC-Befehl "AWAY" implementert.
  43  *
  44  * Revision 1.77  2002/02/27 17:05:41  alex
  45  * - PRIVMSG beachtet nun die Channel-Modes "n" und "m".
  46  *
  47  * Revision 1.76  2002/02/27 16:04:14  alex
  48  * - Bug bei belegtem Nickname bei User-Registrierung (NICK-Befehl) behoben.
  49  *
  50  * Revision 1.75  2002/02/27 15:23:27  alex
  51  * - NAMES beachtet nun das "invisible" Flag ("i") von Usern.
  52  *
  53  * Revision 1.74  2002/02/27 03:44:53  alex
  54  * - gerade eben in SQUIT eingefuehrten Bug behoben: entfernte Server werden nun
  55  *   nur noch geloescht, die Verbindung, von der SQUIT kam, bleibt wieder offen.
  56  *
  57  * Revision 1.73  2002/02/27 03:08:05  alex
  58  * - Log-Meldungen bei SQUIT erneut ueberarbeitet ...
  59  *
  60  * Revision 1.72  2002/02/27 02:26:58  alex
  61  * - SQUIT wird auf jeden Fall geforwarded, zudem besseres Logging.
  62  *
  63  * Revision 1.71  2002/02/27 00:50:05  alex
  64  * - einige unnoetige Client_NextHop()-Aufrufe entfernt.
  65  * - NAMES korrigiert und komplett implementiert.
  66  *
  67  * Revision 1.70  2002/02/26 22:06:40  alex
  68  * - Nick-Aenderungen werden nun wieder korrekt ins Logfile geschrieben.
  69  */
  70
  71
  72 #include <portab.h>
  73 #include "global.h"
  74
  75 #include <imp.h>
  76 #include <assert.h>
  77 #include <errno.h>
  78 #include <stdio.h>
  79 #include <stdlib.h>
  80 #include <string.h>
  81
  82 #include "ngircd.h"
  83 #include "channel.h"
  84 #include "client.h"
  85 #include "conf.h"
  86 #include "conn.h"
  87 #include "irc-write.h"
  88 #include "log.h"
  89 #include "messages.h"
  90 #include "tool.h"
  91
  92 #include <exp.h>
  93 #include "irc.h"
  94
  95
  96 GLOBAL BOOLEAN IRC_MOTD( CLIENT *Client, REQUEST *Req )
  97 {
  98         assert( Client != NULL );
  99         assert( Req != NULL );
 100
 101         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 102
 103         /* Falsche Anzahl Parameter? */
 104         if( Req->argc != 0 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 105
 106         return IRC_Show_MOTD( Client );
 107 } /* IRC_MOTD */
 108
 109
 110 GLOBAL BOOLEAN IRC_PRIVMSG( CLIENT *Client, REQUEST *Req )
 111 {
 112         BOOLEAN is_member, has_voice, is_op, ok;
 113         CLIENT *cl, *from;
 114         CHANNEL *chan;
 115
 116         assert( Client != NULL );
 117         assert( Req != NULL );
 118
 119         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 120
 121         /* Falsche Anzahl Parameter? */
 122         if( Req->argc == 0 ) return IRC_WriteStrClient( Client, ERR_NORECIPIENT_MSG, Client_ID( Client ), Req->command );
 123         if( Req->argc == 1 ) return IRC_WriteStrClient( Client, ERR_NOTEXTTOSEND_MSG, Client_ID( Client ));
 124         if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 125
 126         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
 127         else from = Client;
 128         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 129
 130         cl = Client_Search( Req->argv[0] );
 131         if( cl )
 132         {
 133                 /* Okay, Ziel ist ein User */
 134                 if(( Client_Type( Client ) != CLIENT_SERVER ) && ( strchr( Client_Modes( cl ), 'a' )))
 135                 {
 136                         /* Ziel-User ist AWAY: Meldung verschicken */
 137                         if( ! IRC_WriteStrClient( from, RPL_AWAY_MSG, Client_ID( from ), Client_ID( cl ), Client_Away( cl ))) return DISCONNECTED;
 138                 }
 139
 140                 /* Text senden */
 141                 if( Client_Conn( from ) > NONE ) Conn_UpdateIdle( Client_Conn( from ));
 142                 return IRC_WriteStrClientPrefix( cl, from, "PRIVMSG %s :%s", Client_ID( cl ), Req->argv[1] );
 143         }
 144
 145         chan = Channel_Search( Req->argv[0] );
 146         if( chan )
 147         {
 148                 /* Okay, Ziel ist ein Channel */
 149                 is_member = has_voice = is_op = FALSE;
 150                 if( Channel_IsMemberOf( chan, from ))
 151                 {
 152                         is_member = TRUE;
 153                         if( strchr( Channel_UserModes( chan, from ), 'v' )) has_voice = TRUE;
 154                         if( strchr( Channel_UserModes( chan, from ), 'o' )) is_op = TRUE;
 155                 }
 156
 157                 /* pruefen, ob Client in Channel schreiben darf */
 158                 ok = TRUE;
 159                 if( strchr( Channel_Modes( chan ), 'n' ) && ( ! is_member )) ok = FALSE;
 160                 if( strchr( Channel_Modes( chan ), 'm' ) && ( ! is_op ) && ( ! has_voice )) ok = FALSE;
 161
 162                 if( ! ok ) return IRC_WriteStrClient( from, ERR_CANNOTSENDTOCHAN_MSG, Client_ID( from ), Req->argv[0] );
 163
 164                 /* Text senden */
 165                 if( Client_Conn( from ) > NONE ) Conn_UpdateIdle( Client_Conn( from ));
 166                 return IRC_WriteStrChannelPrefix( Client, chan, from, TRUE, "PRIVMSG %s :%s", Req->argv[0], Req->argv[1] );
 167         }
 168
 169         return IRC_WriteStrClient( from, ERR_NOSUCHNICK_MSG, Client_ID( from ), Req->argv[0] );
 170 } /* IRC_PRIVMSG */
 171
 172
 173 GLOBAL BOOLEAN IRC_NOTICE( CLIENT *Client, REQUEST *Req )
 174 {
 175         CLIENT *to, *from;
 176
 177         assert( Client != NULL );
 178         assert( Req != NULL );
 179
 180         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 181
 182         /* Falsche Anzahl Parameter? */
 183         if( Req->argc != 2 ) return CONNECTED;
 184
 185         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
 186         else from = Client;
 187         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 188
 189         to = Client_Search( Req->argv[0] );
 190         if( to )
 191         {
 192                 /* Okay, Ziel ist ein User */
 193                 return IRC_WriteStrClientPrefix( to, from, "NOTICE %s :%s", Client_ID( to ), Req->argv[1] );
 194         }
 195         else return CONNECTED;
 196 } /* IRC_NOTICE */
 197
 198
 199 GLOBAL BOOLEAN IRC_NAMES( CLIENT *Client, REQUEST *Req )
 200 {
 201         CHAR rpl[COMMAND_LEN], *ptr;
 202         CLIENT *target, *from, *c;
 203         CHANNEL *chan;
 204
 205         assert( Client != NULL );
 206         assert( Req != NULL );
 207
 208         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 209
 210         /* Falsche Anzahl Parameter? */
 211         if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 212
 213         /* From aus Prefix ermitteln */
 214         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
 215         else from = Client;
 216         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->prefix );
 217
 218         if( Req->argc == 2 )
 219         {
 220                 /* an anderen Server forwarden */
 221                 target = Client_GetFromID( Req->argv[1] );
 222                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
 223
 224                 if( target != Client_ThisServer( ))
 225                 {
 226                         /* Ok, anderer Server ist das Ziel: forwarden */
 227                         return IRC_WriteStrClientPrefix( target, from, "NAMES %s :%s", Req->argv[0], Req->argv[1] );
 228                 }
 229         }
 230
 231         if( Req->argc > 0 )
 232         {
 233                 /* bestimmte Channels durchgehen */
 234                 ptr = strtok( Req->argv[0], "," );
 235                 while( ptr )
 236                 {
 237                         chan = Channel_Search( ptr );
 238                         if( chan )
 239                         {
 240                                 /* Namen ausgeben */
 241                                 if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
 242                         }
 243                         if( ! IRC_WriteStrClient( from, RPL_ENDOFNAMES_MSG, Client_ID( from ), ptr )) return DISCONNECTED;
 244
 245                         /* naechsten Namen ermitteln */
 246                         ptr = strtok( NULL, "," );
 247                 }
 248                 return CONNECTED;
 249         }
 250
 251         /* alle Channels durchgehen */
 252         chan = Channel_First( );
 253         while( chan )
 254         {
 255                 /* Namen ausgeben */
 256                 if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
 257
 258                 /* naechster Channel */
 259                 chan = Channel_Next( chan );
 260         }
 261
 262         /* Nun noch alle Clients ausgeben, die in keinem Channel sind */
 263         c = Client_First( );
 264         sprintf( rpl, RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
 265         while( c )
 266         {
 267                 if(( Client_Type( c ) == CLIENT_USER ) && ( Channel_FirstChannelOf( c ) == NULL ) && ( ! strchr( Client_Modes( c ), 'i' )))
 268                 {
 269                         /* Okay, das ist ein User: anhaengen */
 270                         if( rpl[strlen( rpl ) - 1] != ':' ) strcat( rpl, " " );
 271                         strcat( rpl, Client_ID( c ));
 272
 273                         if( strlen( rpl ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
 274                         {
 275                                 /* Zeile wird zu lang: senden! */
 276                                 if( ! IRC_WriteStrClient( from, rpl )) return DISCONNECTED;
 277                                 sprintf( rpl, RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
 278                         }
 279                 }
 280
 281                 /* naechster Client */
 282                 c = Client_Next( c );
 283         }
 284         if( rpl[strlen( rpl ) - 1] != ':')
 285         {
 286                 /* es wurden User gefunden */
 287                 if( ! IRC_WriteStrClient( from, rpl )) return DISCONNECTED;
 288         }
 289
 290         return IRC_WriteStrClient( from, RPL_ENDOFNAMES_MSG, Client_ID( from ), "*" );
 291 } /* IRC_NAMES */
 292
 293
 294 GLOBAL BOOLEAN IRC_ISON( CLIENT *Client, REQUEST *Req )
 295 {
 296         CHAR rpl[COMMAND_LEN];
 297         CLIENT *c;
 298         CHAR *ptr;
 299         INT i;
 300
 301         assert( Client != NULL );
 302         assert( Req != NULL );
 303
 304         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 305
 306         /* Falsche Anzahl Parameter? */
 307         if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 308
 309         strcpy( rpl, RPL_ISON_MSG );
 310         for( i = 0; i < Req->argc; i++ )
 311         {
 312                 ptr = strtok( Req->argv[i], " " );
 313                 while( ptr )
 314                 {
 315                         ngt_TrimStr( ptr );
 316                         c = Client_GetFromID( ptr );
 317                         if( c && ( Client_Type( c ) == CLIENT_USER ))
 318                         {
 319                                 /* Dieser Nick ist "online" */
 320                                 strcat( rpl, ptr );
 321                                 strcat( rpl, " " );
 322                         }
 323                         ptr = strtok( NULL, " " );
 324                 }
 325         }
 326         if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
 327
 328         return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
 329 } /* IRC_ISON */
 330
 331
 332 GLOBAL BOOLEAN IRC_WHOIS( CLIENT *Client, REQUEST *Req )
 333 {
 334         CLIENT *from, *target, *c;
 335         CHAR str[LINE_LEN + 1], *ptr = NULL;
 336         CL2CHAN *cl2chan;
 337         CHANNEL *chan;
 338
 339         assert( Client != NULL );
 340         assert( Req != NULL );
 341
 342         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 343
 344         /* Falsche Anzahl Parameter? */
 345         if(( Req->argc < 1 ) || ( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 346
 347         /* Client suchen */
 348         c = Client_GetFromID( Req->argv[Req->argc - 1] );
 349         if(( ! c ) || ( Client_Type( c ) != CLIENT_USER )) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->argv[Req->argc - 1] );
 350
 351         /* Empfaenger des WHOIS suchen */
 352         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
 353         else from = Client;
 354         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 355
 356         /* Forwarden an anderen Server? */
 357         if( Req->argc > 1 )
 358         {
 359                 /* angegebenen Ziel-Server suchen */
 360                 target = Client_GetFromID( Req->argv[1] );
 361                 if( ! target ) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[1] );
 362                 ptr = Req->argv[1];
 363         }
 364         else target = Client_ThisServer( );
 365
 366         assert( target != NULL );
 367
 368         if(( Client_NextHop( target ) != Client_ThisServer( )) && ( Client_Type( Client_NextHop( target )) == CLIENT_SERVER )) return IRC_WriteStrClientPrefix( target, from, "WHOIS %s :%s", Req->argv[0], ptr );
 369
 370         /* Nick, User und Name */
 371         if( ! IRC_WriteStrClient( from, RPL_WHOISUSER_MSG, Client_ID( from ), Client_ID( c ), Client_User( c ), Client_Hostname( c ), Client_Info( c ))) return DISCONNECTED;
 372
 373         /* Server */
 374         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;
 375
 376         /* Channels */
 377         sprintf( str, RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
 378         cl2chan = Channel_FirstChannelOf( c );
 379         while( cl2chan )
 380         {
 381                 chan = Channel_GetChannel( cl2chan );
 382                 assert( chan != NULL );
 383
 384                 /* Channel-Name anhaengen */
 385                 if( str[strlen( str ) - 1] != ':' ) strcat( str, " " );
 386                 if( strchr( Channel_UserModes( chan, c ), 'v' )) strcat( str, "+" );
 387                 if( strchr( Channel_UserModes( chan, c ), 'o' )) strcat( str, "@" );
 388                 strcat( str, Channel_Name( chan ));
 389
 390                 if( strlen( str ) > ( LINE_LEN - CHANNEL_NAME_LEN - 4 ))
 391                 {
 392                         /* Zeile wird zu lang: senden! */
 393                         if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
 394                         sprintf( str, RPL_WHOISCHANNELS_MSG, Client_ID( from ), Client_ID( c ));
 395                 }
 396
 397                 /* naechstes Mitglied suchen */
 398                 cl2chan = Channel_NextChannelOf( c, cl2chan );
 399         }
 400         if( str[strlen( str ) - 1] != ':')
 401         {
 402                 /* Es sind noch Daten da, die gesendet werden muessen */
 403                 if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
 404         }
 405
 406         /* IRC-Operator? */
 407         if( Client_HasMode( c, 'o' ))
 408         {
 409                 if( ! IRC_WriteStrClient( from, RPL_WHOISOPERATOR_MSG, Client_ID( from ), Client_ID( c ))) return DISCONNECTED;
 410         }
 411
 412         /* Idle (nur lokale Clients) */
 413         if( Client_Conn( c ) > NONE )
 414         {
 415                 if( ! IRC_WriteStrClient( from, RPL_WHOISIDLE_MSG, Client_ID( from ), Client_ID( c ), Conn_GetIdle( Client_Conn ( c )))) return DISCONNECTED;
 416         }
 417
 418         /* Away? */
 419         if( Client_HasMode( c, 'a' ))
 420         {
 421                 if( ! IRC_WriteStrClient( from, RPL_AWAY_MSG, Client_ID( from ), Client_ID( c ), Client_Away( c ))) return DISCONNECTED;
 422         }
 423
 424         /* End of Whois */
 425         return IRC_WriteStrClient( from, RPL_ENDOFWHOIS_MSG, Client_ID( from ), Client_ID( c ));
 426 } /* IRC_WHOIS */
 427
 428
 429 GLOBAL BOOLEAN IRC_WHO( CLIENT *Client, REQUEST *Req )
 430 {
 431         BOOLEAN ok, only_ops;
 432         CHAR flags[8], *ptr;
 433         CL2CHAN *cl2chan;
 434         CHANNEL *chan;
 435         CLIENT *c;
 436
 437         assert( Client != NULL );
 438         assert( Req != NULL );
 439
 440         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 441
 442         /* Falsche Anzahl Parameter? */
 443         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 444
 445         only_ops = FALSE;
 446         chan = NULL;
 447
 448         if( Req->argc == 2 )
 449         {
 450                 /* Nur OPs anzeigen? */
 451                 if( strcmp( Req->argv[1], "o" ) == 0 ) only_ops = TRUE;
 452 #ifdef STRICT_RFC
 453                 else return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 454 #endif
 455         }
 456
 457         if( Req->argc >= 1 )
 458         {
 459                 /* wurde ein Channel oder Nick-Mask angegeben? */
 460                 chan = Channel_Search( Req->argv[0] );
 461         }
 462
 463         if( chan )
 464         {
 465                 /* User eines Channels ausgeben */
 466                 if( ! IRC_Send_WHO( Client, chan, only_ops )) return DISCONNECTED;
 467         }
 468
 469         c = Client_First( );
 470         while( c )
 471         {
 472                 if(( Client_Type( c ) == CLIENT_USER ) && ( ! strchr( Client_Modes( c ), 'i' )))
 473                 {
 474                         ok = FALSE;
 475                         if( Req->argc == 0 ) ok = TRUE;
 476                         else
 477                         {
 478                                 if( strcasecmp( Req->argv[0], Client_ID( c )) == 0 ) ok = TRUE;
 479                                 else if( strcmp( Req->argv[0], "0" ) == 0 ) ok = TRUE;
 480                         }
 481
 482                         if( ok && (( ! only_ops ) || ( strchr( Client_Modes( c ), 'o' ))))
 483                         {
 484                                 /* Flags zusammenbasteln */
 485                                 strcpy( flags, "H" );
 486                                 if( strchr( Client_Modes( c ), 'o' )) strcat( flags, "*" );
 487
 488                                 /* ausgeben */
 489                                 cl2chan = Channel_FirstChannelOf( c );
 490                                 if( cl2chan ) ptr = Channel_Name( Channel_GetChannel( cl2chan ));
 491                                 else ptr = "*";
 492                                 if( ! IRC_WriteStrClient( Client, RPL_WHOREPLY_MSG, Client_ID( Client ), ptr, Client_User( c ), Client_Hostname( c ), Client_ID( Client_Introducer( c )), Client_ID( c ), flags, Client_Hops( c ), Client_Info( c ))) return DISCONNECTED;
 493                         }
 494                 }
 495
 496                 /* naechster Client */
 497                 c = Client_Next( c );
 498         }
 499
 500         if( chan ) return IRC_WriteStrClient( Client, RPL_ENDOFWHO_MSG, Client_ID( Client ), Channel_Name( chan ));
 501         else if( Req->argc == 0 ) return IRC_WriteStrClient( Client, RPL_ENDOFWHO_MSG, Client_ID( Client ), "*" );
 502         else return IRC_WriteStrClient( Client, RPL_ENDOFWHO_MSG, Client_ID( Client ), Req->argv[0] );
 503 } /* IRC_WHO */
 504
 505
 506 GLOBAL BOOLEAN IRC_USERHOST( CLIENT *Client, REQUEST *Req )
 507 {
 508         CHAR rpl[COMMAND_LEN];
 509         CLIENT *c;
 510         INT max, i;
 511
 512         assert( Client != NULL );
 513         assert( Req != NULL );
 514
 515         if( Client_Type( Client ) != CLIENT_USER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 516
 517         /* Falsche Anzahl Parameter? */
 518         if(( Req->argc < 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 519
 520         if( Req->argc > 5 ) max = 5;
 521         else max = Req->argc;
 522
 523         strcpy( rpl, RPL_USERHOST_MSG );
 524         for( i = 0; i < max; i++ )
 525         {
 526                 c = Client_GetFromID( Req->argv[i] );
 527                 if( c && ( Client_Type( c ) == CLIENT_USER ))
 528                 {
 529                         /* Dieser Nick ist "online" */
 530                         strcat( rpl, Client_ID( c ));
 531                         if( Client_HasMode( c, 'o' )) strcat( rpl, "*" );
 532                         strcat( rpl, "=" );
 533                         if( Client_HasMode( c, 'a' )) strcat( rpl, "-" );
 534                         else strcat( rpl, "+" );
 535                         strcat( rpl, Client_User( c ));
 536                         strcat( rpl, "@" );
 537                         strcat( rpl, Client_Hostname( c ));
 538                         strcat( rpl, " " );
 539                 }
 540         }
 541         if( rpl[strlen( rpl ) - 1] == ' ' ) rpl[strlen( rpl ) - 1] = '\0';
 542
 543         return IRC_WriteStrClient( Client, rpl, Client_ID( Client ) );
 544 } /* IRC_USERHOST */
 545
 546
 547 GLOBAL BOOLEAN IRC_ERROR( CLIENT *Client, REQUEST *Req )
 548 {
 549         assert( Client != NULL );
 550         assert( Req != NULL );
 551
 552         if( Req->argc < 1 ) Log( LOG_NOTICE, "Got ERROR from \"%s\"!", Client_Mask( Client ));
 553         else Log( LOG_NOTICE, "Got ERROR from \"%s\": %s!", Client_Mask( Client ), Req->argv[0] );
 554
 555         return CONNECTED;
 556 } /* IRC_ERROR */
 557
 558
 559 GLOBAL BOOLEAN IRC_LUSERS( CLIENT *Client, REQUEST *Req )
 560 {
 561         CLIENT *target, *from;
 562
 563         assert( Client != NULL );
 564         assert( Req != NULL );
 565
 566         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 567
 568         /* Falsche Anzahl Parameter? */
 569         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 570
 571         /* Absender ermitteln */
 572         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
 573         else from = Client;
 574         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 575
 576         /* An anderen Server forwarden? */
 577         if( Req->argc == 2 )
 578         {
 579                 target = Client_GetFromID( Req->argv[1] );
 580                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[1] );
 581                 else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LUSERS %s %s", Req->argv[0], Req->argv[1] );
 582         }
 583
 584         /* Wer ist der Absender? */
 585         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_GetFromID( Req->prefix );
 586         else target = Client;
 587         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 588
 589         IRC_Send_LUSERS( target );
 590
 591         return CONNECTED;
 592 } /* IRC_LUSERS */
 593
 594
 595 GLOBAL BOOLEAN IRC_LINKS( CLIENT *Client, REQUEST *Req )
 596 {
 597         CLIENT *target, *from, *c;
 598         CHAR *mask;
 599
 600         assert( Client != NULL );
 601         assert( Req != NULL );
 602
 603         if(( Client_Type( Client ) != CLIENT_USER ) && ( Client_Type( Client ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 604
 605         /* Falsche Anzahl Parameter? */
 606         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 607
 608         /* Server-Mask ermitteln */
 609         if( Req->argc > 0 ) mask = Req->argv[Req->argc - 1];
 610         else mask = "*";
 611
 612         /* Absender ermitteln */
 613         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_GetFromID( Req->prefix );
 614         else from = Client;
 615         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 616
 617         /* An anderen Server forwarden? */
 618         if( Req->argc == 2 )
 619         {
 620                 target = Client_GetFromID( Req->argv[0] );
 621                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[0] );
 622                 else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LINKS %s %s", Req->argv[0], Req->argv[1] );
 623         }
 624
 625         /* Wer ist der Absender? */
 626         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_GetFromID( Req->prefix );
 627         else target = Client;
 628         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
 629
 630         c = Client_First( );
 631         while( c )
 632         {
 633                 if( Client_Type( c ) == CLIENT_SERVER )
 634                 {
 635                         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;
 636                 }
 637                 c = Client_Next( c );
 638         }
 639
 640         return IRC_WriteStrClient( target, RPL_ENDOFLINKS_MSG, Client_ID( target ), mask );
 641 } /* IRC_LINKS */
 642
 643
 644 GLOBAL BOOLEAN IRC_VERSION( CLIENT *Client, REQUEST *Req )
 645 {
 646         CLIENT *target, *prefix;
 647
 648         assert( Client != NULL );
 649         assert( Req != NULL );
 650
 651         /* Falsche Anzahl Parameter? */
 652         if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 653
 654         /* Ziel suchen */
 655         if( Req->argc == 1 ) target = Client_GetFromID( Req->argv[0] );
 656         else target = Client_ThisServer( );
 657
 658         /* Prefix ermitteln */
 659         if( Client_Type( Client ) == CLIENT_SERVER ) prefix = Client_GetFromID( Req->prefix );
 660         else prefix = Client;
 661         if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->prefix );
 662
 663         /* An anderen Server weiterleiten? */
 664         if( target != Client_ThisServer( ))
 665         {
 666                 if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[0] );
 667
 668                 /* forwarden */
 669                 IRC_WriteStrClientPrefix( target, prefix, "VERSION %s", Req->argv[0] );
 670                 return CONNECTED;
 671         }
 672
 673         /* mit Versionsinfo antworten */
 674         return IRC_WriteStrClient( Client, RPL_VERSION_MSG, Client_ID( prefix ), NGIRCd_DebugLevel, Conf_ServerName, NGIRCd_VersionAddition( ));
 675 } /* IRC_VERSION */
 676
 677
 678 GLOBAL BOOLEAN IRC_KILL( CLIENT *Client, REQUEST *Req )
 679 {
 680         CLIENT *prefix, *c;
 681
 682         assert( Client != NULL );
 683         assert( Req != NULL );
 684
 685         if( Client_Type( Client ) != CLIENT_SERVER ) return IRC_WriteStrClient( Client, ERR_NOTREGISTERED_MSG, Client_ID( Client ));
 686
 687         /* Falsche Anzahl Parameter? */
 688         if(( Req->argc != 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
 689
 690         prefix = Client_GetFromID( Req->prefix );
 691         if( ! prefix )
 692         {
 693                 Log( LOG_WARNING, "Got KILL with invalid prefix: \"%s\"!", Req->prefix );
 694                 prefix = Client_ThisServer( );
 695         }
 696
 697         Log( LOG_NOTICE, "Got KILL command from \"%s\" for \"%s\": %s", Client_Mask( prefix ), Req->argv[0], Req->argv[1] );
 698
 699         /* andere Server benachrichtigen */
 700         IRC_WriteStrServersPrefix( Client, prefix, "KILL %s :%s", Req->argv[0], Req->argv[1] );
 701
 702         /* haben wir selber einen solchen Client? */
 703         c = Client_GetFromID( Req->argv[0] );
 704         if( c && ( Client_Conn( c ) != NONE )) Conn_Close( Client_Conn( c ), NULL, Req->argv[1], TRUE );
 705
 706         return CONNECTED;
 707 } /* IRC_KILL */
 708
 709
 710 GLOBAL BOOLEAN IRC_Show_MOTD( CLIENT *Client )
 711 {
 712         BOOLEAN ok;
 713         CHAR line[127];
 714         FILE *fd;
 715
 716         assert( Client != NULL );
 717
 718         fd = fopen( Conf_MotdFile, "r" );
 719         if( ! fd )
 720         {
 721                 Log( LOG_WARNING, "Can't read MOTD file \"%s\": %s", Conf_MotdFile, strerror( errno ));
 722                 return IRC_WriteStrClient( Client, ERR_NOMOTD_MSG, Client_ID( Client ) );
 723         }
 724
 725         IRC_WriteStrClient( Client, RPL_MOTDSTART_MSG, Client_ID( Client ), Client_ID( Client_ThisServer( )));
 726         while( TRUE )
 727         {
 728                 if( ! fgets( line, 126, fd )) break;
 729                 if( line[strlen( line ) - 1] == '\n' ) line[strlen( line ) - 1] = '\0';
 730                 if( ! IRC_WriteStrClient( Client, RPL_MOTD_MSG, Client_ID( Client ), line ))
 731                 {
 732                         fclose( fd );
 733                         return FALSE;
 734                 }
 735         }
 736         ok = IRC_WriteStrClient( Client, RPL_ENDOFMOTD_MSG, Client_ID( Client ) );
 737
 738         fclose( fd );
 739
 740         return ok;
 741 } /* IRC_Show_MOTD */
 742
 743
 744 GLOBAL BOOLEAN IRC_Send_NAMES( CLIENT *Client, CHANNEL *Chan )
 745 {
 746         BOOLEAN is_visible, is_member;
 747         CHAR str[LINE_LEN + 1];
 748         CL2CHAN *cl2chan;
 749         CLIENT *cl;
 750
 751         assert( Client != NULL );
 752         assert( Chan != NULL );
 753
 754         if( Channel_IsMemberOf( Chan, Client )) is_member = TRUE;
 755         else is_member = FALSE;
 756
 757         /* Alle Mitglieder suchen */
 758         sprintf( str, RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
 759         cl2chan = Channel_FirstMember( Chan );
 760         while( cl2chan )
 761         {
 762                 cl = Channel_GetClient( cl2chan );
 763
 764                 if( strchr( Client_Modes( cl ), 'i' )) is_visible = FALSE;
 765                 else is_visible = TRUE;
 766
 767                 if( is_member || is_visible )
 768                 {
 769                         /* Nick anhaengen */
 770                         if( str[strlen( str ) - 1] != ':' ) strcat( str, " " );
 771                         if( strchr( Channel_UserModes( Chan, cl ), 'v' )) strcat( str, "+" );
 772                         if( strchr( Channel_UserModes( Chan, cl ), 'o' )) strcat( str, "@" );
 773                         strcat( str, Client_ID( cl ));
 774
 775                         if( strlen( str ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
 776                         {
 777                                 /* Zeile wird zu lang: senden! */
 778                                 if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
 779                                 sprintf( str, RPL_NAMREPLY_MSG, Client_ID( Client ), "=", Channel_Name( Chan ));
 780                         }
 781                 }
 782
 783                 /* naechstes Mitglied suchen */
 784                 cl2chan = Channel_NextMember( Chan, cl2chan );
 785         }
 786         if( str[strlen( str ) - 1] != ':')
 787         {
 788                 /* Es sind noch Daten da, die gesendet werden muessen */
 789                 if( ! IRC_WriteStrClient( Client, str )) return DISCONNECTED;
 790         }
 791
 792         return CONNECTED;
 793 } /* IRC_Send_NAMES */
 794
 795
 796 GLOBAL BOOLEAN IRC_Send_WHO( CLIENT *Client, CHANNEL *Chan, BOOLEAN OnlyOps )
 797 {
 798         BOOLEAN is_visible, is_member;
 799         CL2CHAN *cl2chan;
 800         CHAR flags[8];
 801         CLIENT *c;
 802
 803         assert( Client != NULL );
 804         assert( Chan != NULL );
 805
 806         if( Channel_IsMemberOf( Chan, Client )) is_member = TRUE;
 807         else is_member = FALSE;
 808
 809         /* Alle Mitglieder suchen */
 810         cl2chan = Channel_FirstMember( Chan );
 811         while( cl2chan )
 812         {
 813                 c = Channel_GetClient( cl2chan );
 814
 815                 if( strchr( Client_Modes( c ), 'i' )) is_visible = FALSE;
 816                 else is_visible = TRUE;
 817
 818                 if( is_member || is_visible )
 819                 {
 820                         /* Flags zusammenbasteln */
 821                         strcpy( flags, "H" );
 822                         if( strchr( Client_Modes( c ), 'o' )) strcat( flags, "*" );
 823                         if( strchr( Channel_UserModes( Chan, c ), 'v' )) strcat( flags, "+" );
 824                         if( strchr( Channel_UserModes( Chan, c ), 'o' )) strcat( flags, "@" );
 825
 826                         /* ausgeben */
 827                         if(( ! OnlyOps ) || ( strchr( Client_Modes( c ), 'o' )))
 828                         {
 829                                 if( ! IRC_WriteStrClient( Client, RPL_WHOREPLY_MSG, Client_ID( Client ), Channel_Name( Chan ), Client_User( c ), Client_Hostname( c ), Client_ID( Client_Introducer( c )), Client_ID( c ), flags, Client_Hops( c ), Client_Info( c ))) return DISCONNECTED;
 830                         }
 831                 }
 832
 833                 /* naechstes Mitglied suchen */
 834                 cl2chan = Channel_NextMember( Chan, cl2chan );
 835         }
 836         return CONNECTED;
 837 } /* IRC_Send_WHO */
 838
 839
 840 GLOBAL BOOLEAN IRC_Send_LUSERS( CLIENT *Client )
 841 {
 842         INT cnt;
 843
 844         assert( Client != NULL );
 845
 846         /* Users, Services und Serevr im Netz */
 847         if( ! IRC_WriteStrClient( Client, RPL_LUSERCLIENT_MSG, Client_ID( Client ), Client_UserCount( ), Client_ServiceCount( ), Client_ServerCount( ))) return DISCONNECTED;
 848
 849         /* IRC-Operatoren im Netz */
 850         cnt = Client_OperCount( );
 851         if( cnt > 0 )
 852         {
 853                 if( ! IRC_WriteStrClient( Client, RPL_LUSEROP_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
 854         }
 855
 856         /* Unbekannt Verbindungen */
 857         cnt = Client_UnknownCount( );
 858         if( cnt > 0 )
 859         {
 860                 if( ! IRC_WriteStrClient( Client, RPL_LUSERUNKNOWN_MSG, Client_ID( Client ), cnt )) return DISCONNECTED;
 861         }
 862
 863         /* Channels im Netz */
 864         if( ! IRC_WriteStrClient( Client, RPL_LUSERCHANNELS_MSG, Client_ID( Client ), Channel_Count( ))) return DISCONNECTED;
 865
 866         /* Channels im Netz */
 867         if( ! IRC_WriteStrClient( Client, RPL_LUSERME_MSG, Client_ID( Client ), Client_MyUserCount( ), Client_MyServiceCount( ), Client_MyServerCount( ))) return DISCONNECTED;
 868
 869         return CONNECTED;
 870 } /* IRC_Send_LUSERS */
 871
 872
 873 /* -eof- */