Spelling fix: "nick name" -> "nickname"
[ngircd-alex.git] / src / ngircd / irc-info.c
1 /*
2  * ngIRCd -- The Next Generation IRC Daemon
3  * Copyright (c)2001-2012 Alexander Barton (alex@barton.de) and Contributors.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  * Please read the file COPYING, README and AUTHORS for more information.
10  */
11
12 #include "portab.h"
13
14 /**
15  * @file
16  * IRC info commands
17  */
18
19 #include "imp.h"
20 #include <assert.h>
21 #include <errno.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <strings.h>
26
27 #include "ngircd.h"
28 #include "conn-func.h"
29 #include "conn-zip.h"
30 #include "channel.h"
31 #include "class.h"
32 #include "conf.h"
33 #include "defines.h"
34 #include "lists.h"
35 #include "log.h"
36 #include "messages.h"
37 #include "match.h"
38 #include "tool.h"
39 #include "parse.h"
40 #include "irc.h"
41 #include "irc-write.h"
42 #include "client-cap.h"
43
44 #include "exp.h"
45 #include "irc-info.h"
46
47
48 GLOBAL bool
49 IRC_ADMIN(CLIENT *Client, REQUEST *Req )
50 {
51         CLIENT *target, *prefix;
52
53         assert( Client != NULL );
54         assert( Req != NULL );
55
56         if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
57
58         /* find target ... */
59         if( Req->argc == 1 ) target = Client_Search( Req->argv[0] );
60         else target = Client_ThisServer( );
61
62         /* find Prefix */
63         if( Client_Type( Client ) == CLIENT_SERVER ) prefix = Client_Search( Req->prefix );
64         else prefix = Client;
65         if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
66
67         /* forwad message to another server? */
68         if( target != Client_ThisServer( ))
69         {
70                 if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( prefix, ERR_NOSUCHSERVER_MSG, Client_ID( prefix ), Req->argv[0] );
71
72                 /* forward */
73                 IRC_WriteStrClientPrefix( target, prefix, "ADMIN %s", Req->argv[0] );
74                 return CONNECTED;
75         }
76
77         /* mit Versionsinfo antworten */
78         if( ! IRC_WriteStrClient( Client, RPL_ADMINME_MSG, Client_ID( prefix ), Conf_ServerName )) return DISCONNECTED;
79         if( ! IRC_WriteStrClient( Client, RPL_ADMINLOC1_MSG, Client_ID( prefix ), Conf_ServerAdmin1 )) return DISCONNECTED;
80         if( ! IRC_WriteStrClient( Client, RPL_ADMINLOC2_MSG, Client_ID( prefix ), Conf_ServerAdmin2 )) return DISCONNECTED;
81         if( ! IRC_WriteStrClient( Client, RPL_ADMINEMAIL_MSG, Client_ID( prefix ), Conf_ServerAdminMail )) return DISCONNECTED;
82
83         IRC_SetPenalty( Client, 1 );
84         return CONNECTED;
85 } /* IRC_ADMIN */
86
87
88 /**
89  * Handler for the IRC command "INFO".
90  * See RFC 2812 section 3.4.10.
91  */
92 GLOBAL bool
93 IRC_INFO(CLIENT * Client, REQUEST * Req)
94 {
95         CLIENT *target, *prefix;
96         char msg[510];
97
98         assert(Client != NULL);
99         assert(Req != NULL);
100
101         /* Wrong number of parameters? */
102         if (Req->argc > 1)
103                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
104                                           Client_ID(Client), Req->command);
105
106         /* Determine prefix */
107         if (Client_Type(Client) == CLIENT_SERVER)
108                 prefix = Client_Search(Req->prefix);
109         else
110                 prefix = Client;
111         if (!prefix)
112                 return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
113                                           Client_ID(Client), Req->prefix);
114
115         /* Look for a target */
116         if (Req->argc > 0)
117                 target = Client_Search(Req->argv[0]);
118         else
119                 target = Client_ThisServer();
120
121         /* Make sure that the target is a server */
122         if (target && Client_Type(target) != CLIENT_SERVER)
123                 target = Client_Introducer(target);
124
125         if (!target)
126                 return IRC_WriteStrClient(prefix, ERR_NOSUCHSERVER_MSG,
127                                           Client_ID(prefix), Req->argv[0]);
128
129         /* Pass on to another server? */
130         if (target != Client_ThisServer()) {
131                 IRC_WriteStrClientPrefix(target, prefix, "INFO %s",
132                                          Req->argv[0]);
133                 return CONNECTED;
134         }
135
136         if (!IRC_WriteStrClient(Client, RPL_INFO_MSG, Client_ID(prefix),
137                                 NGIRCd_Version))
138                 return DISCONNECTED;
139
140 #if defined(__DATE__) && defined(__TIME__)
141         snprintf(msg, sizeof(msg), "Birth Date: %s at %s", __DATE__, __TIME__);
142         if (!IRC_WriteStrClient(Client, RPL_INFO_MSG, Client_ID(prefix), msg))
143                 return DISCONNECTED;
144 #endif
145
146         strlcpy(msg, "On-line since ", sizeof(msg));
147         strlcat(msg, NGIRCd_StartStr, sizeof(msg));
148         if (!IRC_WriteStrClient(Client, RPL_INFO_MSG, Client_ID(prefix), msg))
149                 return DISCONNECTED;
150
151         if (!IRC_WriteStrClient(Client, RPL_ENDOFINFO_MSG, Client_ID(prefix)))
152                 return DISCONNECTED;
153
154         IRC_SetPenalty(Client, 2);
155         return CONNECTED;
156 } /* IRC_INFO */
157
158
159 /**
160  * Handler for the IRC "ISON" command.
161  *
162  * See RFC 2812, 4.9 "Ison message".
163  *
164  * @param Client The client from which this command has been received.
165  * @param Req Request structure with prefix and all parameters.
166  * @return CONNECTED or DISCONNECTED.
167  */
168 GLOBAL bool
169 IRC_ISON( CLIENT *Client, REQUEST *Req )
170 {
171         char rpl[COMMAND_LEN];
172         CLIENT *c;
173         char *ptr;
174         int i;
175
176         assert(Client != NULL);
177         assert(Req != NULL);
178
179         /* Bad number of arguments? */
180         if (Req->argc < 1)
181                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
182                                           Client_ID(Client), Req->command);
183
184         strlcpy(rpl, RPL_ISON_MSG, sizeof rpl);
185         for (i = 0; i < Req->argc; i++) {
186                 /* "All" ircd even parse ":<x> <y> ..." arguments and split
187                  * them up; so we do the same ... */
188                 ptr = strtok(Req->argv[i], " ");
189                 while (ptr) {
190                         ngt_TrimStr(ptr);
191                         c = Client_Search(ptr);
192                         if (c && Client_Type(c) == CLIENT_USER) {
193                                 strlcat(rpl, Client_ID(c), sizeof(rpl));
194                                 strlcat(rpl, " ", sizeof(rpl));
195                         }
196                         ptr = strtok(NULL, " ");
197                 }
198         }
199         ngt_TrimLastChr(rpl, ' ');
200
201         return IRC_WriteStrClient(Client, rpl, Client_ID(Client));
202 } /* IRC_ISON */
203
204
205 /**
206  * Handler for the IRC "LINKS" command.
207  *
208  * See RFC 2812, 3.4.5 "Links message".
209  *
210  * @param Client The client from which this command has been received.
211  * @param Req Request structure with prefix and all parameters.
212  * @return CONNECTED or DISCONNECTED.
213  */
214 GLOBAL bool
215 IRC_LINKS(CLIENT *Client, REQUEST *Req)
216 {
217         CLIENT *target, *from, *c;
218         char *mask;
219
220         assert(Client != NULL);
221         assert(Req != NULL);
222
223         IRC_SetPenalty(Client, 1);
224
225         if (Req->argc > 2)
226                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
227                                           Client_ID(Client), Req->command);
228
229         /* Get pointer to server mask or "*", if none given */
230         if (Req->argc > 0)
231                 mask = Req->argv[Req->argc - 1];
232         else
233                 mask = "*";
234
235         if (Client_Type(Client) == CLIENT_SERVER)
236                 from = Client_Search(Req->prefix);
237         else
238                 from = Client;
239         if (!from)
240                 return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
241                                           Client_ID(Client), Req->prefix);
242
243         /* Forward? */
244         if (Req->argc == 2) {
245                 target = Client_Search(Req->argv[0]);
246                 if (! target || Client_Type(target) != CLIENT_SERVER)
247                         return IRC_WriteStrClient(from, ERR_NOSUCHSERVER_MSG,
248                                                   Client_ID(from),
249                                                   Req->argv[0] );
250                 else
251                         if (target != Client_ThisServer())
252                                 return IRC_WriteStrClientPrefix(target, from,
253                                                 "LINKS %s %s", Req->argv[0],
254                                                 Req->argv[1]);
255         }
256
257         c = Client_First();
258         while (c) {
259                 if (Client_Type(c) == CLIENT_SERVER
260                     && MatchCaseInsensitive(mask, Client_ID(c))) {
261                         if (!IRC_WriteStrClient(from, RPL_LINKS_MSG,
262                                         Client_ID(from), Client_ID(c),
263                                         Client_ID(Client_TopServer(c)
264                                                   ? Client_TopServer(c)
265                                                   : Client_ThisServer()),
266                                         Client_Hops(c), Client_Info(c)))
267                                 return DISCONNECTED;
268                 }
269                 c = Client_Next(c);
270         }
271         return IRC_WriteStrClient(from, RPL_ENDOFLINKS_MSG,
272                                   Client_ID(from), mask);
273 } /* IRC_LINKS */
274
275
276 GLOBAL bool
277 IRC_LUSERS( CLIENT *Client, REQUEST *Req )
278 {
279         CLIENT *target, *from;
280
281         assert( Client != NULL );
282         assert( Req != NULL );
283
284         if(( Req->argc > 2 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
285
286         /* Absender ermitteln */
287         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
288         else from = Client;
289         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
290
291         /* An anderen Server forwarden? */
292         if( Req->argc == 2 )
293         {
294                 target = Client_Search( Req->argv[1] );
295                 if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[1] );
296                 else if( target != Client_ThisServer( )) return IRC_WriteStrClientPrefix( target, from, "LUSERS %s %s", Req->argv[0], Req->argv[1] );
297         }
298
299         /* Wer ist der Absender? */
300         if( Client_Type( Client ) == CLIENT_SERVER ) target = Client_Search( Req->prefix );
301         else target = Client;
302         if( ! target ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
303
304         IRC_Send_LUSERS( target );
305
306         IRC_SetPenalty( target, 1 );
307         return CONNECTED;
308 } /* IRC_LUSERS */
309
310
311 /**
312  * Handler for the IRC command "SERVLIST".
313  * List registered services, see RFC 2811, section 3.5.1: the syntax is
314  * "SERVLIST [<mask> [<type>]]".
315  */
316 GLOBAL bool
317 IRC_SERVLIST(CLIENT *Client, REQUEST *Req)
318 {
319         CLIENT *c;
320
321         assert(Client != NULL);
322         assert(Req != NULL);
323
324         if (Req->argc > 2)
325                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
326                                           Client_ID(Client), Req->command);
327
328         if (Req->argc < 2 || strcmp(Req->argv[1], "0") == 0) {
329                 for (c = Client_First(); c!= NULL; c = Client_Next(c)) {
330                         if (Client_Type(c) != CLIENT_SERVICE)
331                                 continue;
332                         if (Req->argc > 0 && !MatchCaseInsensitive(Req->argv[0],
333                                                                   Client_ID(c)))
334                                 continue;
335                         if (!IRC_WriteStrClient(Client, RPL_SERVLIST_MSG,
336                                         Client_ID(Client), Client_Mask(c),
337                                         Client_Mask(Client_Introducer(c)), "*",
338                                         0, Client_Hops(c), Client_Info(c)))
339                                 return DISCONNECTED;
340                 }
341         }
342
343         return IRC_WriteStrClient(Client, RPL_SERVLISTEND_MSG, Client_ID(Client),
344                                   Req->argc > 0 ? Req->argv[0] : "*",
345                                   Req->argc > 1 ? Req->argv[1] : "0");
346 } /* IRC_SERVLIST */
347
348
349 GLOBAL bool
350 IRC_MOTD( CLIENT *Client, REQUEST *Req )
351 {
352         CLIENT *from, *target;
353
354         assert( Client != NULL );
355         assert( Req != NULL );
356
357         if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
358
359         /* From aus Prefix ermitteln */
360         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
361         else from = Client;
362         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
363
364         if( Req->argc == 1 )
365         {
366                 /* forward? */
367                 target = Client_Search( Req->argv[0] );
368                 if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[0] );
369
370                 if( target != Client_ThisServer( ))
371                 {
372                         /* Ok, anderer Server ist das Ziel: forwarden */
373                         return IRC_WriteStrClientPrefix( target, from, "MOTD %s", Req->argv[0] );
374                 }
375         }
376
377         IRC_SetPenalty( from, 3 );
378         return IRC_Show_MOTD( from );
379 } /* IRC_MOTD */
380
381
382 GLOBAL bool
383 IRC_NAMES( CLIENT *Client, REQUEST *Req )
384 {
385         char rpl[COMMAND_LEN], *ptr;
386         CLIENT *target, *from, *c;
387         CHANNEL *chan;
388
389         assert( Client != NULL );
390         assert( Req != NULL );
391
392         if( Req->argc > 2 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
393
394         /* use prefix to determine "From" */
395         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
396         else from = Client;
397         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
398
399         if( Req->argc == 2 )
400         {
401                 /* forward to another server? */
402                 target = Client_Search( Req->argv[1] );
403                 if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( from, ERR_NOSUCHSERVER_MSG, Client_ID( from ), Req->argv[1] );
404
405                 if( target != Client_ThisServer( )) {
406                         /* target is another server, forward */
407                         return IRC_WriteStrClientPrefix( target, from, "NAMES %s :%s", Req->argv[0], Req->argv[1] );
408                 }
409         }
410
411         if( Req->argc > 0 )
412         {
413                 /* bestimmte Channels durchgehen */
414                 ptr = strtok( Req->argv[0], "," );
415                 while( ptr )
416                 {
417                         chan = Channel_Search( ptr );
418                         if( chan )
419                         {
420                                 /* print name */
421                                 if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
422                         }
423                         if( ! IRC_WriteStrClient( from, RPL_ENDOFNAMES_MSG, Client_ID( from ), ptr )) return DISCONNECTED;
424
425                         /* get next channel name */
426                         ptr = strtok( NULL, "," );
427                 }
428                 return CONNECTED;
429         }
430
431         chan = Channel_First( );
432         while( chan )
433         {
434                 if( ! IRC_Send_NAMES( from, chan )) return DISCONNECTED;
435
436                 chan = Channel_Next( chan );
437         }
438
439         /* Now print all clients which are not in any channel */
440         c = Client_First( );
441         snprintf( rpl, sizeof( rpl ), RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
442         while( c )
443         {
444                 if(( Client_Type( c ) == CLIENT_USER ) && ( Channel_FirstChannelOf( c ) == NULL ) && ( ! strchr( Client_Modes( c ), 'i' )))
445                 {
446                         /* its a user, concatenate ... */
447                         if( rpl[strlen( rpl ) - 1] != ':' ) strlcat( rpl, " ", sizeof( rpl ));
448                         strlcat( rpl, Client_ID( c ), sizeof( rpl ));
449
450                         if( strlen( rpl ) > ( LINE_LEN - CLIENT_NICK_LEN - 4 ))
451                         {
452                                 /* Line is gwoing too long, send now */
453                                 if( ! IRC_WriteStrClient( from, "%s", rpl )) return DISCONNECTED;
454                                 snprintf( rpl, sizeof( rpl ), RPL_NAMREPLY_MSG, Client_ID( from ), "*", "*" );
455                         }
456                 }
457
458                 c = Client_Next( c );
459         }
460         if( rpl[strlen( rpl ) - 1] != ':')
461         {
462                 if( ! IRC_WriteStrClient( from, "%s", rpl )) return DISCONNECTED;
463         }
464
465         IRC_SetPenalty( from, 1 );
466         return IRC_WriteStrClient( from, RPL_ENDOFNAMES_MSG, Client_ID( from ), "*" );
467 } /* IRC_NAMES */
468
469
470 static unsigned int
471 t_diff(time_t *t, const time_t d)
472 {
473         time_t diff, remain;
474
475         diff = *t / d;
476         remain = diff * d;
477         *t -= remain;
478
479         return (unsigned int)diff;
480 }
481
482
483 static unsigned int
484 uptime_days(time_t *now)
485 {
486         return t_diff(now, 60 * 60 * 24);
487 }
488
489
490 static unsigned int
491 uptime_hrs(time_t *now)
492 {
493         return t_diff(now, 60 * 60);
494 }
495
496
497 static unsigned int
498 uptime_mins(time_t *now)
499 {
500          return t_diff(now, 60);
501 }
502
503
504 /**
505  * Handler for the IRC command "STATS".
506  * See RFC 2812 section 3.4.4.
507  */
508 GLOBAL bool
509 IRC_STATS( CLIENT *Client, REQUEST *Req )
510 {
511         CLIENT *from, *target, *cl;
512         CONN_ID con;
513         char query;
514         COMMAND *cmd;
515         time_t time_now;
516         unsigned int days, hrs, mins;
517         struct list_head *list;
518         struct list_elem *list_item;
519
520         assert(Client != NULL);
521         assert(Req != NULL);
522
523         if (Req->argc > 2)
524                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
525                                           Client_ID(Client), Req->command);
526
527         /* use prefix to determine "From" */
528         if (Client_Type(Client) == CLIENT_SERVER)
529                 from = Client_Search(Req->prefix);
530         else
531                 from = Client;
532
533         if (!from)
534                 return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
535                                           Client_ID(Client), Req->prefix);
536
537         if (Req->argc == 2) {
538                 /* forward to another server? */
539                 target = Client_Search(Req->argv[1]);
540                 if ((!target) || (Client_Type(target) != CLIENT_SERVER))
541                         return IRC_WriteStrClient(from, ERR_NOSUCHSERVER_MSG,
542                                                  Client_ID(from), Req->argv[1]);
543
544                 if (target != Client_ThisServer()) {
545                         /* forward to another server */
546                         return IRC_WriteStrClientPrefix(target, from,
547                                      "STATS %s %s", Req->argv[0], Req->argv[1]);
548                 }
549         }
550
551         if (Req->argc > 0)
552                 query = Req->argv[0][0] ? Req->argv[0][0] : '*';
553         else
554                 query = '*';
555
556         switch (query) {
557         case 'g':       /* Network-wide bans ("G-Lines") */
558         case 'G':
559         case 'k':       /* Server-local bans ("K-Lines") */
560         case 'K':
561                 if (!Client_HasMode(from, 'o'))
562                     return IRC_WriteStrClient(from, ERR_NOPRIVILEGES_MSG,
563                                               Client_ID(from));
564                 if (query == 'g' || query == 'G')
565                         list = Class_GetList(CLASS_GLINE);
566                 else
567                         list = Class_GetList(CLASS_KLINE);
568                         list_item = Lists_GetFirst(list);
569                         while (list_item) {
570                                 if (!IRC_WriteStrClient(from, RPL_STATSXLINE_MSG,
571                                                 Client_ID(from), query,
572                                                 Lists_GetMask(list_item),
573                                                 Lists_GetValidity(list_item),
574                                                 Lists_GetReason(list_item)))
575                                         return DISCONNECTED;
576                                 list_item = Lists_GetNext(list_item);
577                         }
578                 break;
579         case 'l':       /* Link status (servers and own link) */
580         case 'L':
581                 time_now = time(NULL);
582                 for (con = Conn_First(); con != NONE; con = Conn_Next(con)) {
583                         cl = Conn_GetClient(con);
584                         if (!cl)
585                                 continue;
586                         if ((Client_Type(cl) == CLIENT_SERVER)
587                             || (cl == Client)) {
588                                 /* Server link or our own connection */
589 #ifdef ZLIB
590                                 if (Conn_Options(con) & CONN_ZIP) {
591                                         if (!IRC_WriteStrClient
592                                             (from, RPL_STATSLINKINFOZIP_MSG,
593                                              Client_ID(from), Client_Mask(cl),
594                                              Conn_SendQ(con), Conn_SendMsg(con),
595                                              Zip_SendBytes(con),
596                                              Conn_SendBytes(con),
597                                              Conn_RecvMsg(con),
598                                              Zip_RecvBytes(con),
599                                              Conn_RecvBytes(con),
600                                              (long)(time_now - Conn_StartTime(con))))
601                                                 return DISCONNECTED;
602                                         continue;
603                                 }
604 #endif
605                                 if (!IRC_WriteStrClient
606                                     (from, RPL_STATSLINKINFO_MSG,
607                                      Client_ID(from), Client_Mask(cl),
608                                      Conn_SendQ(con), Conn_SendMsg(con),
609                                      Conn_SendBytes(con), Conn_RecvMsg(con),
610                                      Conn_RecvBytes(con),
611                                      (long)(time_now - Conn_StartTime(con))))
612                                         return DISCONNECTED;
613                         }
614                 }
615                 break;
616         case 'm':       /* IRC command status (usage count) */
617         case 'M':
618                 cmd = Parse_GetCommandStruct();
619                 for (; cmd->name; cmd++) {
620                         if (cmd->lcount == 0 && cmd->rcount == 0)
621                                 continue;
622                         if (!IRC_WriteStrClient
623                             (from, RPL_STATSCOMMANDS_MSG, Client_ID(from),
624                              cmd->name, cmd->lcount, cmd->bytes, cmd->rcount))
625                                 return DISCONNECTED;
626                 }
627                 break;
628         case 'u':       /* Server uptime */
629         case 'U':
630                 time_now = time(NULL) - NGIRCd_Start;
631                 days = uptime_days(&time_now);
632                 hrs = uptime_hrs(&time_now);
633                 mins = uptime_mins(&time_now);
634                 if (!IRC_WriteStrClient(from, RPL_STATSUPTIME, Client_ID(from),
635                                        days, hrs, mins, (unsigned int)time_now))
636                         return DISCONNECTED;
637                 break;
638         }
639
640         IRC_SetPenalty(from, 2);
641         return IRC_WriteStrClient(from, RPL_ENDOFSTATS_MSG,
642                                   Client_ID(from), query);
643 } /* IRC_STATS */
644
645
646 /**
647  * Handler for the IRC command "SUMMON".
648  * See RFC 2812 section 4.5. ngIRCd doesn't implement this functionality and
649  * therefore answers with ERR_SUMMONDISABLED.
650  */
651 GLOBAL bool
652 IRC_SUMMON(CLIENT * Client, UNUSED REQUEST * Req)
653 {
654         return IRC_WriteStrClient(Client, ERR_SUMMONDISABLED_MSG,
655                                   Client_ID(Client));
656 } /* IRC_SUMMON */
657
658
659 GLOBAL bool
660 IRC_TIME( CLIENT *Client, REQUEST *Req )
661 {
662         CLIENT *from, *target;
663         char t_str[64];
664         time_t t;
665
666         assert( Client != NULL );
667         assert( Req != NULL );
668
669         if( Req->argc > 1 ) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
670
671         if( Client_Type( Client ) == CLIENT_SERVER ) from = Client_Search( Req->prefix );
672         else from = Client;
673         if( ! from ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
674
675         if( Req->argc == 1 )
676         {
677                 target = Client_Search( Req->argv[0] );
678                 if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( Client, ERR_NOSUCHSERVER_MSG, Client_ID( Client ), Req->argv[0] );
679
680                 if( target != Client_ThisServer( ))
681                 {
682                         return IRC_WriteStrClientPrefix( target, from, "TIME %s", Req->argv[0] );
683                 }
684         }
685
686         t = time( NULL );
687         (void)strftime( t_str, 60, "%A %B %d %Y -- %H:%M %Z", localtime( &t ));
688         return IRC_WriteStrClient( from, RPL_TIME_MSG, Client_ID( from ), Client_ID( Client_ThisServer( )), t_str );
689 } /* IRC_TIME */
690
691
692 /**
693  * Handler for the IRC command "USERHOST".
694  * See RFC 2812 section 4.8.
695  */
696 GLOBAL bool
697 IRC_USERHOST(CLIENT *Client, REQUEST *Req)
698 {
699         char rpl[COMMAND_LEN];
700         CLIENT *c;
701         int max, i;
702
703         assert(Client != NULL);
704         assert(Req != NULL);
705
706         if ((Req->argc < 1))
707                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
708                                           Client_ID(Client), Req->command);
709
710         if (Req->argc > 5)
711                 max = 5;
712         else
713                 max = Req->argc;
714
715         strlcpy(rpl, RPL_USERHOST_MSG, sizeof rpl);
716         for (i = 0; i < max; i++) {
717                 c = Client_Search(Req->argv[i]);
718                 if (c && (Client_Type(c) == CLIENT_USER)) {
719                         /* This Nick is "online" */
720                         strlcat(rpl, Client_ID(c), sizeof(rpl));
721                         if (Client_HasMode(c, 'o'))
722                                 strlcat(rpl, "*", sizeof(rpl));
723                         strlcat(rpl, "=", sizeof(rpl));
724                         if (Client_HasMode(c, 'a'))
725                                 strlcat(rpl, "-", sizeof(rpl));
726                         else
727                                 strlcat(rpl, "+", sizeof(rpl));
728                         strlcat(rpl, Client_User(c), sizeof(rpl));
729                         strlcat(rpl, "@", sizeof(rpl));
730                         strlcat(rpl, Client_HostnameCloaked(c), sizeof(rpl));
731                         strlcat(rpl, " ", sizeof(rpl));
732                 }
733         }
734         ngt_TrimLastChr(rpl, ' ');
735
736         return IRC_WriteStrClient(Client, rpl, Client_ID(Client));
737 } /* IRC_USERHOST */
738
739
740 /**
741  * Handler for the IRC command "USERS".
742  * See RFC 2812 section 4.6. As suggested there the command is disabled.
743  */
744 GLOBAL bool
745 IRC_USERS(CLIENT * Client, UNUSED REQUEST * Req)
746 {
747         return IRC_WriteStrClient(Client, ERR_USERSDISABLED_MSG,
748                                   Client_ID(Client));
749 } /* IRC_USERS */
750
751
752 GLOBAL bool
753 IRC_VERSION( CLIENT *Client, REQUEST *Req )
754 {
755         CLIENT *target, *prefix;
756
757         assert( Client != NULL );
758         assert( Req != NULL );
759
760         if(( Req->argc > 1 )) return IRC_WriteStrClient( Client, ERR_NEEDMOREPARAMS_MSG, Client_ID( Client ), Req->command );
761
762         /* Ziel suchen */
763         if( Req->argc == 1 ) target = Client_Search( Req->argv[0] );
764         else target = Client_ThisServer( );
765
766         /* Prefix ermitteln */
767         if( Client_Type( Client ) == CLIENT_SERVER ) prefix = Client_Search( Req->prefix );
768         else prefix = Client;
769         if( ! prefix ) return IRC_WriteStrClient( Client, ERR_NOSUCHNICK_MSG, Client_ID( Client ), Req->prefix );
770
771         /* An anderen Server weiterleiten? */
772         if( target != Client_ThisServer( ))
773         {
774                 if(( ! target ) || ( Client_Type( target ) != CLIENT_SERVER )) return IRC_WriteStrClient( prefix, ERR_NOSUCHSERVER_MSG, Client_ID( prefix ), Req->argv[0] );
775
776                 /* forwarden */
777                 IRC_WriteStrClientPrefix( target, prefix, "VERSION %s", Req->argv[0] );
778                 return CONNECTED;
779         }
780
781         /* send version information */
782         IRC_SetPenalty(Client, 1);
783         return IRC_WriteStrClient(Client, RPL_VERSION_MSG, Client_ID(prefix),
784                                   PACKAGE_NAME, PACKAGE_VERSION,
785                                   NGIRCd_DebugLevel, Conf_ServerName,
786                                   NGIRCd_VersionAddition);
787 } /* IRC_VERSION */
788
789
790 static bool
791 write_whoreply(CLIENT *Client, CLIENT *c, const char *channelname, const char *flags)
792 {
793         return IRC_WriteStrClient(Client, RPL_WHOREPLY_MSG, Client_ID(Client),
794                                   channelname, Client_User(c),
795                                   Client_HostnameCloaked(c),
796                                   Client_ID(Client_Introducer(c)), Client_ID(c),
797                                   flags, Client_Hops(c), Client_Info(c));
798 }
799
800
801 static const char *
802 who_flags_status(const char *client_modes)
803 {
804         if (strchr(client_modes, 'a'))
805                 return "G"; /* away */
806         return "H";
807 }
808
809
810 /**
811  * Return channel user mode prefix(es).
812  *
813  * @param Client The client requesting the mode prefixes.
814  * @param chan_user_modes String with channel user modes.
815  * @param str String buffer to which the prefix(es) will be appended.
816  * @param len Size of "str" buffer.
817  * @return Pointer to "str".
818  */
819 static char *
820 who_flags_qualifier(CLIENT *Client, const char *chan_user_modes,
821                     char *str, size_t len)
822 {
823         assert(Client != NULL);
824
825         if (Client_Cap(Client) & CLIENT_CAP_MULTI_PREFIX) {
826                 if (strchr(chan_user_modes, 'q'))
827                         strlcat(str, "~", len);
828                 if (strchr(chan_user_modes, 'a'))
829                         strlcat(str, "&", len);
830                 if (strchr(chan_user_modes, 'o'))
831                         strlcat(str, "@", len);
832                 if (strchr(chan_user_modes, 'h'))
833                         strlcat(str, "%", len);
834                 if (strchr(chan_user_modes, 'v'))
835                         strlcat(str, "+", len);
836
837                 return str;
838         }
839
840         if (strchr(chan_user_modes, 'q'))
841                 strlcat(str, "~", len);
842         else if (strchr(chan_user_modes, 'a'))
843                 strlcat(str, "&", len);
844         else if (strchr(chan_user_modes, 'o'))
845                 strlcat(str, "@", len);
846         else if (strchr(chan_user_modes, 'h'))
847                 strlcat(str, "%", len);
848         else if (strchr(chan_user_modes, 'v'))
849                 strlcat(str, "+", len);
850
851         return str;
852 }
853
854
855 /**
856  * Send WHO reply for a "channel target" ("WHO #channel").
857  *
858  * @param Client Client requesting the information.
859  * @param Chan Channel being requested.
860  * @param OnlyOps Only display IRC operators.
861  * @return CONNECTED or DISCONNECTED.
862  */
863 static bool
864 IRC_WHO_Channel(CLIENT *Client, CHANNEL *Chan, bool OnlyOps)
865 {
866         bool is_visible, is_member, is_ircop;
867         CL2CHAN *cl2chan;
868         const char *client_modes;
869         char flags[10];
870         CLIENT *c;
871         int count = 0;
872
873         assert( Client != NULL );
874         assert( Chan != NULL );
875
876         IRC_SetPenalty(Client, 1);
877
878         is_member = Channel_IsMemberOf(Chan, Client);
879
880         /* Secret channel? */
881         if (!is_member && strchr(Channel_Modes(Chan), 's'))
882                 return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG,
883                                           Client_ID(Client), Channel_Name(Chan));
884
885         cl2chan = Channel_FirstMember(Chan);
886         for (; cl2chan ; cl2chan = Channel_NextMember(Chan, cl2chan)) {
887                 c = Channel_GetClient(cl2chan);
888
889                 client_modes = Client_Modes(c);
890                 is_ircop = strchr(client_modes, 'o') != NULL;
891                 if (OnlyOps && !is_ircop)
892                         continue;
893
894                 is_visible = strchr(client_modes, 'i') == NULL;
895                 if (is_member || is_visible) {
896                         strcpy(flags, who_flags_status(client_modes));
897                         if (is_ircop)
898                                 strlcat(flags, "*", sizeof(flags));
899
900                         who_flags_qualifier(Client, Channel_UserModes(Chan, c),
901                                             flags, sizeof(flags));
902
903                         if (!write_whoreply(Client, c, Channel_Name(Chan),
904                                             flags))
905                                 return DISCONNECTED;
906                         count++;
907                 }
908         }
909
910         /* If there are a lot of clients, augment penalty a bit */
911         if (count > MAX_RPL_WHO)
912                 IRC_SetPenalty(Client, 1);
913
914         return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG, Client_ID(Client),
915                                   Channel_Name(Chan));
916 }
917
918
919 /**
920  * Send WHO reply for a "mask target" ("WHO m*sk").
921  *
922  * @param Client Client requesting the information.
923  * @param Mask Mask being requested or NULL for "all" clients.
924  * @param OnlyOps Only display IRC operators.
925  * @return CONNECTED or DISCONNECTED.
926  */
927 static bool
928 IRC_WHO_Mask(CLIENT *Client, char *Mask, bool OnlyOps)
929 {
930         CLIENT *c;
931         CL2CHAN *cl2chan;
932         CHANNEL *chan;
933         bool client_match, is_visible;
934         char flags[4];
935         int count = 0;
936
937         assert (Client != NULL);
938
939         if (Mask)
940                 ngt_LowerStr(Mask);
941
942         IRC_SetPenalty(Client, 3);
943         for (c = Client_First(); c != NULL; c = Client_Next(c)) {
944                 if (Client_Type(c) != CLIENT_USER)
945                         continue;
946
947                 if (OnlyOps && !Client_HasMode(c, 'o'))
948                         continue;
949
950                 if (Mask) {
951                         /* Match pattern against user host/server/name/nick */
952                         client_match = MatchCaseInsensitive(Mask,
953                                                 Client_Hostname(c));
954                         if (!client_match)
955                                 client_match = MatchCaseInsensitive(Mask,
956                                                 Client_ID(Client_Introducer(c)));
957                         if (!client_match)
958                                 client_match = MatchCaseInsensitive(Mask,
959                                                 Client_Info(c));
960                         if (!client_match)
961                                 client_match = MatchCaseInsensitive(Mask,
962                                                 Client_ID(c));
963                         if (!client_match)
964                                 continue;       /* no match: skip this client */
965                 }
966
967                 is_visible = !Client_HasMode(c, 'i');
968
969                 /* Target client is invisible, but mask matches exactly? */
970                 if (!is_visible && Mask && strcasecmp(Client_ID(c), Mask) == 0)
971                         is_visible = true;
972
973                 /* Target still invisible, but are both on the same channel? */
974                 if (!is_visible) {
975                         cl2chan = Channel_FirstChannelOf(Client);
976                         while (cl2chan && !is_visible) {
977                                 chan = Channel_GetChannel(cl2chan);
978                                 if (Channel_IsMemberOf(chan, c))
979                                         is_visible = true;
980                                 cl2chan = Channel_NextChannelOf(Client, cl2chan);
981                         }
982                 }
983
984                 if (!is_visible)        /* target user is not visible */
985                         continue;
986
987                 if (IRC_CheckListTooBig(Client, count, MAX_RPL_WHO, "WHO"))
988                         break;
989
990                 strcpy(flags, who_flags_status(Client_Modes(c)));
991                 if (strchr(Client_Modes(c), 'o'))
992                         strlcat(flags, "*", sizeof(flags));
993
994                 if (!write_whoreply(Client, c, "*", flags))
995                         return DISCONNECTED;
996                 count++;
997         }
998
999         return IRC_WriteStrClient(Client, RPL_ENDOFWHO_MSG, Client_ID(Client),
1000                                   Mask ? Mask : "*");
1001 }
1002
1003
1004 /**
1005  * Handler for the IRC "WHO" command.
1006  *
1007  * See RFC 2812, 3.6.1 "Who query".
1008  *
1009  * @param Client The client from which this command has been received.
1010  * @param Req Request structure with prefix and all parameters.
1011  * @return CONNECTED or DISCONNECTED.
1012  */
1013 GLOBAL bool
1014 IRC_WHO(CLIENT *Client, REQUEST *Req)
1015 {
1016         bool only_ops;
1017         CHANNEL *chan;
1018
1019         assert (Client != NULL);
1020         assert (Req != NULL);
1021
1022         if (Req->argc > 2)
1023                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
1024                                           Client_ID(Client), Req->command);
1025
1026         only_ops = false;
1027
1028         if (Req->argc == 2) {
1029                 if (strcmp(Req->argv[1], "o") == 0)
1030                         only_ops = true;
1031 #ifdef STRICT_RFC
1032                 else
1033                         return IRC_WriteStrClient(Client,
1034                                                   ERR_NEEDMOREPARAMS_MSG,
1035                                                   Client_ID(Client),
1036                                                   Req->command);
1037 #endif
1038         }
1039
1040         IRC_SetPenalty(Client, 1);
1041         if (Req->argc >= 1) {
1042                 /* Channel or mask given */
1043                 chan = Channel_Search(Req->argv[0]);
1044                 if (chan) {
1045                         /* Members of a channel have been requested */
1046                         return IRC_WHO_Channel(Client, chan, only_ops);
1047                 }
1048                 if (strcmp(Req->argv[0], "0") != 0) {
1049                         /* A mask has been given. But please note this RFC
1050                          * stupidity: "0" is same as no arguments ... */
1051                         return IRC_WHO_Mask(Client, Req->argv[0], only_ops);
1052                 }
1053         }
1054
1055         /* No channel or (valid) mask given */
1056         IRC_SetPenalty(Client, 2);
1057         return IRC_WHO_Mask(Client, NULL, only_ops);
1058 } /* IRC_WHO */
1059
1060
1061 /**
1062  * Generate WHOIS reply of one actual client.
1063  *
1064  * @param Client The client from which this command has been received.
1065  * @param from The client requesting the information ("originator").
1066  * @param c The client of which information should be returned.
1067  * @return CONNECTED or DISCONNECTED.
1068  */
1069 static bool
1070 IRC_WHOIS_SendReply(CLIENT *Client, CLIENT *from, CLIENT *c)
1071 {
1072         char str[LINE_LEN + 1];
1073         CL2CHAN *cl2chan;
1074         CHANNEL *chan;
1075
1076         assert(Client != NULL);
1077         assert(from != NULL);
1078         assert(c != NULL);
1079
1080         /* Nick, user, hostname and client info */
1081         if (!IRC_WriteStrClient(from, RPL_WHOISUSER_MSG, Client_ID(from),
1082                                 Client_ID(c), Client_User(c),
1083                                 Client_HostnameCloaked(c), Client_Info(c)))
1084                 return DISCONNECTED;
1085
1086         /* Server */
1087         if (!IRC_WriteStrClient(from, RPL_WHOISSERVER_MSG, Client_ID(from),
1088                                 Client_ID(c), Client_ID(Client_Introducer(c)),
1089                                 Client_Info(Client_Introducer(c))))
1090                 return DISCONNECTED;
1091
1092         /* Channels */
1093         snprintf(str, sizeof(str), RPL_WHOISCHANNELS_MSG,
1094                  Client_ID(from), Client_ID(c));
1095         cl2chan = Channel_FirstChannelOf(c);
1096         while (cl2chan) {
1097                 chan = Channel_GetChannel(cl2chan);
1098                 assert(chan != NULL);
1099
1100                 /* next */
1101                 cl2chan = Channel_NextChannelOf(c, cl2chan);
1102
1103                 /* Secret channel? */
1104                 if (strchr(Channel_Modes(chan), 's')
1105                     && !Channel_IsMemberOf(chan, Client))
1106                         continue;
1107
1108                 /* Local channel and request is not from a user? */
1109                 if (Client_Type(Client) == CLIENT_SERVER
1110                     && Channel_IsLocal(chan))
1111                         continue;
1112
1113                 /* Concatenate channel names */
1114                 if (str[strlen(str) - 1] != ':')
1115                         strlcat(str, " ", sizeof(str));
1116
1117                 who_flags_qualifier(Client, Channel_UserModes(chan, c),
1118                                     str, sizeof(str));
1119                 strlcat(str, Channel_Name(chan), sizeof(str));
1120
1121                 if (strlen(str) > (LINE_LEN - CHANNEL_NAME_LEN - 4)) {
1122                         /* Line becomes too long: send it! */
1123                         if (!IRC_WriteStrClient(Client, "%s", str))
1124                                 return DISCONNECTED;
1125                         snprintf(str, sizeof(str), RPL_WHOISCHANNELS_MSG,
1126                                  Client_ID(from), Client_ID(c));
1127                 }
1128         }
1129         if(str[strlen(str) - 1] != ':') {
1130                 /* There is data left to send: */
1131                 if (!IRC_WriteStrClient(Client, "%s", str))
1132                         return DISCONNECTED;
1133         }
1134
1135         /* IRC-Operator? */
1136         if (Client_HasMode(c, 'o') &&
1137             !IRC_WriteStrClient(from, RPL_WHOISOPERATOR_MSG,
1138                                 Client_ID(from), Client_ID(c)))
1139                 return DISCONNECTED;
1140
1141         /* IRC-Bot? */
1142         if (Client_HasMode(c, 'B') &&
1143             !IRC_WriteStrClient(from, RPL_WHOISBOT_MSG,
1144                                 Client_ID(from), Client_ID(c)))
1145                 return DISCONNECTED;
1146
1147         /* Connected using SSL? */
1148         if (Conn_UsesSSL(Client_Conn(c)) &&
1149             !IRC_WriteStrClient(from, RPL_WHOISSSL_MSG, Client_ID(from),
1150                                 Client_ID(c)))
1151                 return DISCONNECTED;
1152
1153         /* Registered nickname? */
1154         if (Client_HasMode(c, 'R') &&
1155             !IRC_WriteStrClient(from, RPL_WHOISREGNICK_MSG,
1156                                 Client_ID(from), Client_ID(c)))
1157                 return DISCONNECTED;
1158
1159         /* Local client and requester is the user itself or an IRC Op? */
1160         if (Client_Conn(c) > NONE &&
1161             (from == c || (!Conf_MorePrivacy && Client_HasMode(from, 'o')))) {
1162                 /* Client hostname */
1163                 if (!IRC_WriteStrClient(from, RPL_WHOISHOST_MSG,
1164                     Client_ID(from), Client_ID(c), Client_Hostname(c),
1165                     Conn_GetIPAInfo(Client_Conn(c))))
1166                         return DISCONNECTED;
1167                 /* Client modes */
1168                 if (!IRC_WriteStrClient(from, RPL_WHOISMODES_MSG,
1169                     Client_ID(from), Client_ID(c), Client_Modes(c)))
1170                         return DISCONNECTED;
1171         }
1172
1173         /* Idle and signon time (local clients only!) */
1174         if (!Conf_MorePrivacy && Client_Conn(c) > NONE &&
1175             !IRC_WriteStrClient(from, RPL_WHOISIDLE_MSG,
1176                                 Client_ID(from), Client_ID(c),
1177                                 (unsigned long)Conn_GetIdle(Client_Conn(c)),
1178                                 (unsigned long)Conn_GetSignon(Client_Conn(c))))
1179                 return DISCONNECTED;
1180
1181         /* Away? */
1182         if (Client_HasMode(c, 'a') &&
1183             !IRC_WriteStrClient(from, RPL_AWAY_MSG,
1184                                 Client_ID(from), Client_ID(c), Client_Away(c)))
1185                 return DISCONNECTED;
1186
1187         return CONNECTED;
1188 } /* IRC_WHOIS_SendReply */
1189
1190
1191 /**
1192  * Handler for the IRC "WHOIS" command.
1193  *
1194  * See RFC 2812, 3.6.2 "Whois query".
1195  *
1196  * @param Client        The client from which this command has been received.
1197  * @param Req           Request structure with prefix and all parameters.
1198  * @return              CONNECTED or DISCONNECTED.
1199  */
1200 GLOBAL bool
1201 IRC_WHOIS( CLIENT *Client, REQUEST *Req )
1202 {
1203         CLIENT *from, *target, *c;
1204         unsigned int match_count = 0, found = 0;
1205         bool has_wildcards, is_remote;
1206         bool got_wildcard = false;
1207         char mask[COMMAND_LEN], *query;
1208
1209         assert( Client != NULL );
1210         assert( Req != NULL );
1211
1212         /* Bad number of parameters? */
1213         if (Req->argc < 1 || Req->argc > 2)
1214                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
1215                                           Client_ID(Client), Req->command);
1216
1217         /* Search sender of the WHOIS */
1218         if (Client_Type(Client) == CLIENT_SERVER) {
1219                 from = Client_Search(Req->prefix);
1220         } else {
1221                 IRC_SetPenalty(Client, 1);
1222                 from = Client;
1223         }
1224         if (!from)
1225                 return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
1226                                           Client_ID(Client), Req->prefix);
1227
1228         /* Get target server for this command */
1229         if (Req->argc > 1) {
1230                 /* Search the target server, which can be specified as a
1231                  * nickname on that server as well: */
1232                 target = Client_Search(Req->argv[0]);
1233                 if (!target)
1234                         return IRC_WriteStrClient(from, ERR_NOSUCHSERVER_MSG,
1235                                                 Client_ID(from), Req->argv[0]);
1236         } else
1237                 target = Client_ThisServer();
1238         assert(target != NULL);
1239
1240         /* Forward to other server? */
1241         if (Client_NextHop(target) != Client_ThisServer() &&
1242             Client_Type(Client_NextHop(target)) == CLIENT_SERVER)
1243                 return IRC_WriteStrClientPrefix(target, from,
1244                                                 "WHOIS %s :%s",
1245                                                 Req->argv[0], Req->argv[1]);
1246
1247         is_remote = Client_Conn(from) < 0;
1248         strlcpy(mask, Req->argv[Req->argc - 1], sizeof(mask));
1249         for (query = strtok(ngt_LowerStr(mask), ",");
1250                         query && found < 3;
1251                         query = strtok(NULL, ","), found++)
1252         {
1253                 has_wildcards = query[strcspn(query, "*?")] != 0;
1254                 /*
1255                  * follows ircd 2.10 implementation:
1256                  *  - handle up to 3 targets
1257                  *  - no wildcards for remote clients
1258                  *  - only one wildcard target per local client
1259                  *
1260                  *  Also, at most MAX_RPL_WHOIS matches are returned.
1261                  */
1262                 if (!has_wildcards || is_remote) {
1263                         c = Client_Search(query);
1264                         if (c && Client_Type(c) == CLIENT_USER) {
1265                                 if (!IRC_WHOIS_SendReply(Client, from, c))
1266                                         return DISCONNECTED;
1267                         } else {
1268                                 if (!IRC_WriteStrClient(Client,
1269                                                         ERR_NOSUCHNICK_MSG,
1270                                                         Client_ID(Client),
1271                                                         query))
1272                                         return DISCONNECTED;
1273                         }
1274                         continue;
1275                 }
1276                 if (got_wildcard) {
1277                         /* we already handled one wildcard query */
1278                         if (!IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
1279                              Client_ID(Client), query))
1280                                 return DISCONNECTED;
1281                         continue;
1282                 }
1283                 got_wildcard = true;
1284                 IRC_SetPenalty(Client, 3);
1285
1286                 for (c = Client_First(); c; c = Client_Next(c)) {
1287                         if (IRC_CheckListTooBig(Client, match_count,
1288                                             MAX_RPL_WHOIS, "WHOIS"))
1289                                 break;
1290
1291                         if (Client_Type(c) != CLIENT_USER)
1292                                 continue;
1293                         if (!MatchCaseInsensitive(query, Client_ID(c)))
1294                                 continue;
1295                         if (!IRC_WHOIS_SendReply(Client, from, c))
1296                                 return DISCONNECTED;
1297
1298                         match_count++;
1299                 }
1300
1301                 if (match_count == 0)
1302                         IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
1303                                            Client_ID(Client),
1304                                            Req->argv[Req->argc - 1]);
1305         }
1306         return IRC_WriteStrClient(from, RPL_ENDOFWHOIS_MSG,
1307                                   Client_ID(from), Req->argv[Req->argc - 1]);
1308 } /* IRC_WHOIS */
1309
1310
1311 static bool
1312 WHOWAS_EntryWrite(CLIENT *prefix, WHOWAS *entry)
1313 {
1314         char t_str[60];
1315
1316         (void)strftime(t_str, sizeof(t_str), "%a %b %d %H:%M:%S %Y",
1317                                         localtime(&entry->time));
1318
1319         if (!IRC_WriteStrClient(prefix, RPL_WHOWASUSER_MSG, Client_ID(prefix),
1320                         entry->id, entry->user, entry->host, entry->info))
1321                                 return DISCONNECTED;
1322
1323         return IRC_WriteStrClient(prefix, RPL_WHOISSERVER_MSG, Client_ID(prefix),
1324                   entry->id, entry->server, t_str);
1325 }
1326
1327 /**
1328  * IRC "WHOWAS" function.
1329  * This function implements the IRC command "WHOWHAS". It handles local
1330  * requests and request that should be forwarded to other servers.
1331  */
1332 GLOBAL bool
1333 IRC_WHOWAS( CLIENT *Client, REQUEST *Req )
1334 {
1335         CLIENT *target, *prefix;
1336         WHOWAS *whowas;
1337         char tok_buf[COMMAND_LEN];
1338         int max, last, count, i, nc;
1339         const char *nick;
1340
1341         assert( Client != NULL );
1342         assert( Req != NULL );
1343
1344         /* Do not reveal any info on disconnected users? */
1345         if (Conf_MorePrivacy)
1346                 return CONNECTED;
1347
1348         /* Wrong number of parameters? */
1349         if (Req->argc > 3)
1350                 return IRC_WriteStrClient(Client, ERR_NEEDMOREPARAMS_MSG,
1351                                         Client_ID(Client), Req->command);
1352         if (Req->argc < 1)
1353                 return IRC_WriteStrClient(Client, ERR_NONICKNAMEGIVEN_MSG, Client_ID(Client));
1354
1355         /* Search target */
1356         if (Req->argc == 3)
1357                 target = Client_Search(Req->argv[2]);
1358         else
1359                 target = Client_ThisServer();
1360
1361         /* Get prefix */
1362         if (Client_Type(Client) == CLIENT_SERVER)
1363                 prefix = Client_Search(Req->prefix);
1364         else
1365                 prefix = Client;
1366
1367         if (!prefix)
1368                 return IRC_WriteStrClient(Client, ERR_NOSUCHNICK_MSG,
1369                                                 Client_ID(Client), Req->prefix);
1370
1371         /* Forward to other server? */
1372         if (target != Client_ThisServer()) {
1373                 if (!target || (Client_Type(target) != CLIENT_SERVER))
1374                         return IRC_WriteStrClient(prefix, ERR_NOSUCHSERVER_MSG,
1375                                         Client_ID(prefix), Req->argv[2]);
1376
1377                 /* Forward */
1378                 IRC_WriteStrClientPrefix( target, prefix, "WHOWAS %s %s %s",
1379                                           Req->argv[0], Req->argv[1],
1380                                           Req->argv[2] );
1381                 return CONNECTED;
1382         }
1383
1384         whowas = Client_GetWhowas( );
1385         last = Client_GetLastWhowasIndex( );
1386         if (last < 0)
1387                 last = 0;
1388
1389         max = DEF_RPL_WHOWAS;
1390         if (Req->argc > 1) {
1391                 max = atoi(Req->argv[1]);
1392                 if (max < 1)
1393                         max = MAX_RPL_WHOWAS;
1394         }
1395
1396         /*
1397          * Break up the nick argument into a list of nicks, if applicable
1398          * Can't modify Req->argv[0] because we need it for RPL_ENDOFWHOWAS_MSG.
1399          */
1400         strlcpy(tok_buf, Req->argv[0], sizeof(tok_buf));
1401         nick = strtok(tok_buf, ",");
1402
1403         for (i=last, count=0; nick != NULL ; nick = strtok(NULL, ",")) {
1404                 nc = 0;
1405                 do {
1406                         /* Used entry? */
1407                         if (whowas[i].time > 0 && strcasecmp(nick, whowas[i].id) == 0) {
1408                                 if (!WHOWAS_EntryWrite(prefix, &whowas[i]))
1409                                         return DISCONNECTED;
1410                                 nc++;
1411                                 count++;
1412                         }
1413                         /* previous entry */
1414                         i--;
1415
1416                         /* "underflow", wrap around */
1417                         if (i < 0)
1418                                 i = MAX_WHOWAS - 1;
1419
1420                         if (nc && count >= max)
1421                                 break;
1422                 } while (i != last);
1423
1424                 if (nc == 0 && !IRC_WriteStrClient(prefix, ERR_WASNOSUCHNICK_MSG,
1425                                                 Client_ID(prefix), nick))
1426                         return DISCONNECTED;
1427         }
1428         return IRC_WriteStrClient(prefix, RPL_ENDOFWHOWAS_MSG, Client_ID(prefix), Req->argv[0]);
1429 } /* IRC_WHOWAS */
1430
1431
1432 /**
1433  * Send LUSERS reply to a client.
1434  *
1435  * @param Client The receipient of the information.
1436  * @return CONNECTED or DISCONNECTED.
1437  */
1438 GLOBAL bool
1439 IRC_Send_LUSERS(CLIENT *Client)
1440 {
1441         unsigned long cnt;
1442 #ifndef STRICT_RFC
1443         unsigned long max;
1444 #endif
1445
1446         assert(Client != NULL);
1447
1448         /* Users, services and serevers in the network */
1449         if (!IRC_WriteStrClient(Client, RPL_LUSERCLIENT_MSG, Client_ID(Client),
1450                                 Client_UserCount(), Client_ServiceCount(),
1451                                 Client_ServerCount()))
1452                 return DISCONNECTED;
1453
1454         /* Number of IRC operators */
1455         cnt = Client_OperCount( );
1456         if (cnt > 0) {
1457                 if (!IRC_WriteStrClient(Client, RPL_LUSEROP_MSG,
1458                                         Client_ID(Client), cnt))
1459                         return DISCONNECTED;
1460         }
1461
1462         /* Unknown connections */
1463         cnt = Client_UnknownCount( );
1464         if (cnt > 0) {
1465                 if (!IRC_WriteStrClient(Client, RPL_LUSERUNKNOWN_MSG,
1466                                         Client_ID(Client), cnt))
1467                         return DISCONNECTED;
1468         }
1469
1470         /* Number of created channels */
1471         if (!IRC_WriteStrClient(Client, RPL_LUSERCHANNELS_MSG,
1472                                 Client_ID(Client),
1473                                 Channel_CountVisible(Client)))
1474                 return DISCONNECTED;
1475
1476         /* Number of local users, services and servers */
1477         if (!IRC_WriteStrClient(Client, RPL_LUSERME_MSG, Client_ID(Client),
1478                                 Client_MyUserCount(), Client_MyServiceCount(),
1479                                 Client_MyServerCount()))
1480                 return DISCONNECTED;
1481
1482 #ifndef STRICT_RFC
1483         /* Maximum number of local users */
1484         cnt = Client_MyUserCount();
1485         max = Client_MyMaxUserCount();
1486         if (! IRC_WriteStrClient(Client, RPL_LOCALUSERS_MSG, Client_ID(Client),
1487                         cnt, max, cnt, max))
1488                 return DISCONNECTED;
1489         /* Maximum number of users in the network */
1490         cnt = Client_UserCount();
1491         max = Client_MaxUserCount();
1492         if(! IRC_WriteStrClient(Client, RPL_NETUSERS_MSG, Client_ID(Client),
1493                         cnt, max, cnt, max))
1494                 return DISCONNECTED;
1495         /* Connection counters */
1496         if (! IRC_WriteStrClient(Client, RPL_STATSCONN_MSG, Client_ID(Client),
1497                         Conn_CountMax(), Conn_CountAccepted()))
1498                 return DISCONNECTED;
1499 #endif
1500
1501         return CONNECTED;
1502 } /* IRC_Send_LUSERS */
1503
1504
1505 static bool
1506 Show_MOTD_Start(CLIENT *Client)
1507 {
1508         return IRC_WriteStrClient(Client, RPL_MOTDSTART_MSG,
1509                 Client_ID( Client ), Client_ID( Client_ThisServer( )));
1510 }
1511
1512 static bool
1513 Show_MOTD_Sendline(CLIENT *Client, const char *msg)
1514 {
1515         return IRC_WriteStrClient(Client, RPL_MOTD_MSG, Client_ID( Client ), msg);
1516 }
1517
1518 static bool
1519 Show_MOTD_End(CLIENT *Client)
1520 {
1521         if (!IRC_WriteStrClient(Client, RPL_ENDOFMOTD_MSG, Client_ID(Client)))
1522                 return DISCONNECTED;
1523
1524         if (*Conf_CloakHost)
1525                 return IRC_WriteStrClient(Client, RPL_HOSTHIDDEN_MSG,
1526                                           Client_ID(Client),
1527                                           Client_Hostname(Client));
1528
1529         return CONNECTED;
1530 }
1531
1532 #ifdef SSL_SUPPORT
1533 static bool Show_MOTD_SSLInfo(CLIENT *Client)
1534 {
1535         bool ret = true;
1536         char buf[COMMAND_LEN] = "Connected using Cipher ";
1537
1538         if (!Conn_GetCipherInfo(Client_Conn(Client), buf + 23, sizeof buf - 23))
1539                 return true;
1540
1541         if (!Show_MOTD_Sendline(Client, buf))
1542                 ret = false;
1543
1544         return ret;
1545 }
1546 #else
1547 static inline bool
1548 Show_MOTD_SSLInfo(UNUSED CLIENT *c)
1549 { return true; }
1550 #endif
1551
1552 GLOBAL bool
1553 IRC_Show_MOTD( CLIENT *Client )
1554 {
1555         const char *line;
1556         size_t len_tot, len_str;
1557
1558         assert( Client != NULL );
1559
1560         len_tot = array_bytes(&Conf_Motd);
1561         if (len_tot == 0 && !Conn_UsesSSL(Client_Conn(Client)))
1562                 return IRC_WriteStrClient(Client, ERR_NOMOTD_MSG, Client_ID(Client));
1563
1564         if (!Show_MOTD_Start(Client))
1565                 return DISCONNECTED;
1566
1567         line = array_start(&Conf_Motd);
1568         while (len_tot > 0) {
1569                 len_str = strlen(line) + 1;
1570
1571                 assert(len_tot >= len_str);
1572                 len_tot -= len_str;
1573
1574                 if (!Show_MOTD_Sendline(Client, line))
1575                         return DISCONNECTED;
1576                 line += len_str;
1577         }
1578
1579         if (!Show_MOTD_SSLInfo(Client))
1580                 return DISCONNECTED;
1581         return Show_MOTD_End(Client);
1582 } /* IRC_Show_MOTD */
1583
1584
1585 /**
1586  * Send NAMES reply for a specific client and channel.
1587  *
1588  * @param Client The client requesting the NAMES information.
1589  * @param Chan The channel
1590  * @return CONNECTED or DISCONNECTED.
1591  */
1592 GLOBAL bool
1593 IRC_Send_NAMES(CLIENT * Client, CHANNEL * Chan)
1594 {
1595         bool is_visible, is_member;
1596         char str[LINE_LEN + 1];
1597         CL2CHAN *cl2chan;
1598         CLIENT *cl;
1599
1600         assert(Client != NULL);
1601         assert(Chan != NULL);
1602
1603         if (Channel_IsMemberOf(Chan, Client))
1604                 is_member = true;
1605         else
1606                 is_member = false;
1607
1608         /* Do not print info on channel memberships to anyone that is not member? */
1609         if (Conf_MorePrivacy && !is_member)
1610                 return CONNECTED;
1611
1612         /* Secret channel? */
1613         if (!is_member && strchr(Channel_Modes(Chan), 's'))
1614                 return CONNECTED;
1615
1616         snprintf(str, sizeof(str), RPL_NAMREPLY_MSG, Client_ID(Client), "=",
1617                  Channel_Name(Chan));
1618         cl2chan = Channel_FirstMember(Chan);
1619         while (cl2chan) {
1620                 cl = Channel_GetClient(cl2chan);
1621
1622                 if (strchr(Client_Modes(cl), 'i'))
1623                         is_visible = false;
1624                 else
1625                         is_visible = true;
1626
1627                 if (is_member || is_visible) {
1628                         if (str[strlen(str) - 1] != ':')
1629                                 strlcat(str, " ", sizeof(str));
1630
1631                         who_flags_qualifier(Client, Channel_UserModes(Chan, cl),
1632                                             str, sizeof(str));
1633                         strlcat(str, Client_ID(cl), sizeof(str));
1634
1635                         if (strlen(str) > (LINE_LEN - CLIENT_NICK_LEN - 4)) {
1636                                 if (!IRC_WriteStrClient(Client, "%s", str))
1637                                         return DISCONNECTED;
1638                                 snprintf(str, sizeof(str), RPL_NAMREPLY_MSG,
1639                                          Client_ID(Client), "=",
1640                                          Channel_Name(Chan));
1641                         }
1642                 }
1643
1644                 cl2chan = Channel_NextMember(Chan, cl2chan);
1645         }
1646         if (str[strlen(str) - 1] != ':') {
1647                 if (!IRC_WriteStrClient(Client, "%s", str))
1648                         return DISCONNECTED;
1649         }
1650
1651         return CONNECTED;
1652 } /* IRC_Send_NAMES */
1653
1654
1655 /**
1656  * Send the ISUPPORT numeric (005).
1657  * This numeric indicates the features that are supported by this server.
1658  * See <http://www.irc.org/tech_docs/005.html> for details.
1659  */
1660 GLOBAL bool
1661 IRC_Send_ISUPPORT(CLIENT * Client)
1662 {
1663         if (!IRC_WriteStrClient(Client, RPL_ISUPPORT1_MSG, Client_ID(Client),
1664                                 Conf_MaxJoins))
1665                 return DISCONNECTED;
1666         return IRC_WriteStrClient(Client, RPL_ISUPPORT2_MSG, Client_ID(Client),
1667                                   CHANNEL_NAME_LEN - 1, Conf_MaxNickLength - 1,
1668                                   COMMAND_LEN - 23, CLIENT_AWAY_LEN - 1,
1669                                   COMMAND_LEN - 113, MAX_HNDL_MODES_ARG,
1670                                   MAX_HNDL_CHANNEL_LISTS);
1671 } /* IRC_Send_ISUPPORT */
1672
1673
1674 /* -eof- */