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