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