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