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