8a2f963e036f18065ce30a98bcc10b80802166cb
[ircu2.10.12-pk.git] / ircd / whocmds.c
1 /*
2  * IRC - Internet Relay Chat, ircd/s_user.c (formerly ircd/s_msg.c)
3  * Copyright (C) 1990 Jarkko Oikarinen and
4  *                    University of Oulu, Computing Center
5  *
6  * See file AUTHORS in IRC package for additional names of
7  * the programmers.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 1, or (at your option)
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  * $Id$
24  */
25 #include "config.h"
26
27 #include "whocmds.h"
28 #include "channel.h"
29 #include "client.h"
30 #include "hash.h"
31 #include "ircd.h"
32 #include "ircd_chattr.h"
33 #include "ircd_features.h"
34 #include "ircd_reply.h"
35 #include "ircd_snprintf.h"
36 #include "ircd_string.h"
37 #include "list.h"
38 #include "match.h"
39 #include "numeric.h"
40 #include "numnicks.h"
41 #include "querycmds.h"
42 #include "random.h"
43 #include "s_bsd.h"
44 #include "s_conf.h"
45 #include "s_misc.h"
46 #include "s_user.h"
47 #include "send.h"
48 #include "struct.h"
49 #include "support.h"
50 #include "sys.h"
51 #include "userload.h"
52 #include "version.h"
53 #include "whowas.h"
54 #include "msg.h"
55
56 #include <arpa/inet.h>        /* inet_ntoa */
57 #include <fcntl.h>
58 #include <stdio.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <sys/stat.h>
62 #include <unistd.h>
63
64 /*
65  * The function that actually prints out the WHO reply for a client found
66  */
67 void do_who(struct Client* sptr, struct Client* acptr, struct Channel* repchan,
68             int fields, char* qrt)
69 {
70   char *p1;
71   struct Channel *chptr = repchan;
72
73   static char buf1[512];
74   /* NOTE: with current fields list and sizes this _cannot_ overrun, 
75      and also the message finally sent shouldn't ever be truncated */
76
77   p1 = buf1;
78   buf1[1] = '\0';
79
80   /* If we don't have a channel and we need one... try to find it,
81      unless the listing is for a channel service, we already know
82      that there are no common channels, thus use PubChannel and not
83      SeeChannel */
84   if (!chptr && (!fields || (fields & (WHO_FIELD_CHA | WHO_FIELD_FLA))) &&
85       !IsChannelService(acptr))
86   {
87     struct Membership* chan;
88     for (chan = cli_user(acptr)->channel; chan && !chptr; chan = chan->next_channel)
89       if (PubChannel(chan->channel) &&
90           (acptr == sptr || !IsZombie(chan)))
91         chptr = chan->channel;
92   }
93
94   /* Place the fields one by one in the buffer and send it
95      note that fields == NULL means "default query" */
96
97   if (fields & WHO_FIELD_QTY)   /* Query type */
98   {
99     *(p1++) = ' ';
100     if (BadPtr(qrt))
101       *(p1++) = '0';
102     else
103       while ((*qrt) && (*(p1++) = *(qrt++)));
104   }
105
106   if (!fields || (fields & WHO_FIELD_CHA))
107   {
108     char *p2;
109     *(p1++) = ' ';
110     if ((p2 = (chptr ? chptr->chname : NULL)))
111       while ((*p2) && (*(p1++) = *(p2++)));
112     else
113       *(p1++) = '*';
114   }
115
116   if (!fields || (fields & WHO_FIELD_UID))
117   {
118     char *p2 = cli_user(acptr)->username;
119     *(p1++) = ' ';
120     while ((*p2) && (*(p1++) = *(p2++)));
121   }
122
123   if (fields & WHO_FIELD_NIP)
124   {
125     const char* p2 = HasHiddenHost(acptr) && !IsAnOper(sptr) ?
126       feature_str(FEAT_HIDDEN_IP) :
127       ircd_ntoa((const char*) &(cli_ip(acptr)));
128     *(p1++) = ' ';
129     while ((*p2) && (*(p1++) = *(p2++)));
130   }
131
132   if (!fields || (fields & WHO_FIELD_HOS))
133   {
134     char *p2 = cli_user(acptr)->host;
135     *(p1++) = ' ';
136     while ((*p2) && (*(p1++) = *(p2++)));
137   }
138
139   if (!fields || (fields & WHO_FIELD_SER))
140   {
141     const char *p2 = (feature_bool(FEAT_HIS_WHO_SERVERNAME) && !IsAnOper(sptr)) ?
142                        feature_str(FEAT_HIS_SERVERNAME) :
143                        cli_name(cli_user(acptr)->server);
144     *(p1++) = ' ';
145     while ((*p2) && (*(p1++) = *(p2++)));
146   }
147
148   if (!fields || (fields & WHO_FIELD_NIC))
149   {
150     char *p2 = cli_name(acptr);
151     *(p1++) = ' ';
152     while ((*p2) && (*(p1++) = *(p2++)));
153   }
154
155   if (!fields || (fields & WHO_FIELD_FLA))
156   {
157     *(p1++) = ' ';
158     if (cli_user(acptr)->away)
159       *(p1++) = 'G';
160     else
161       *(p1++) = 'H';
162     if SeeOper(sptr,acptr)
163       *(p1++) = '*';
164     if (fields) {
165       /* If you specified flags then we assume you know how to parse
166        * multiple channel status flags, as this is currently the only
167        * way to know if someone has @'s *and* is +'d.
168        */
169       if (chptr && is_chan_op(acptr, chptr))
170         *(p1++) = '@';
171       if (chptr && has_voice(acptr, chptr))
172         *(p1++) = '+';
173       if (chptr && is_zombie(acptr, chptr))
174         *(p1++) = '!';
175     }
176     else {
177       if (chptr && is_chan_op(acptr, chptr))
178         *(p1++) = '@';
179       else if (chptr && has_voice(acptr, chptr))
180         *(p1++) = '+';
181       else if (chptr && is_zombie(acptr, chptr))
182         *(p1++) = '!';
183     }
184     if (IsDeaf(acptr))
185       *(p1++) = 'd';
186     if (IsAnOper(sptr))
187     {
188       if (IsInvisible(acptr))
189         *(p1++) = 'i';
190       if (SendWallops(acptr))
191         *(p1++) = 'w';
192       if (SendDebug(acptr))
193         *(p1++) = 'g';
194     }
195     if (HasHiddenHost(acptr))
196       *(p1++) = 'x';
197   }
198
199   if (!fields || (fields & WHO_FIELD_DIS))
200   {
201     *p1++ = ' ';
202     if (!fields)
203       *p1++ = ':';              /* Place colon here for default reply */
204     if (feature_bool(FEAT_HIS_WHO_HOPCOUNT) && !IsAnOper(sptr))
205       *p1++ = (sptr == acptr) ? '0' : '3';
206     else
207       /* three digit hopcount maximum */
208       p1 += ircd_snprintf(0, p1, 3, "%d", cli_hopcount(acptr));
209   }
210
211   if (fields & WHO_FIELD_IDL)
212   {
213     *p1++ = ' ';
214     if (MyUser(acptr) &&
215         (IsAnOper(sptr) || !feature_bool(FEAT_HIS_WHO_SERVERNAME) ||
216          acptr == sptr))
217       p1 += ircd_snprintf(0, p1, 11, "%d",
218                           CurrentTime - cli_user(acptr)->last);
219     else
220       *p1++ = '0';
221   }
222
223   if (fields & WHO_FIELD_ACC)
224   {
225     char *p2 = cli_user(acptr)->account;
226     *(p1++) = ' ';
227     if (*p2)
228       while ((*p2) && (*(p1++) = *(p2++)));
229     else
230       *(p1++) = '0';
231   }
232
233   if (!fields || (fields & WHO_FIELD_REN))
234   {
235     char *p2 = cli_info(acptr);
236     *p1++ = ' ';
237     if (fields)
238       *p1++ = ':';              /* Place colon here for special reply */
239     while ((*p2) && (*(p1++) = *(p2++)));
240   }
241
242   /* The first char will always be an useless blank and we 
243      need to terminate buf1 */
244   *p1 = '\0';
245   p1 = buf1;
246   send_reply(sptr, fields ? RPL_WHOSPCRPL : RPL_WHOREPLY, ++p1);
247 }
248
249 int
250 count_users(char *mask)
251 {
252   struct Client *acptr;
253   int count = 0;
254   char namebuf[USERLEN + HOSTLEN + 2];
255   char ipbuf[USERLEN + 16 + 2];
256
257   for (acptr = GlobalClientList; acptr; acptr = cli_next(acptr)) {
258     if (!IsUser(acptr))
259       continue;
260
261     ircd_snprintf(0, namebuf, sizeof(namebuf), "%s@%s",
262                   cli_user(acptr)->username, cli_user(acptr)->host);
263     ircd_snprintf(0, ipbuf, sizeof(ipbuf), "%s@%s", cli_user(acptr)->username,
264                   ircd_ntoa((const char *) &(cli_ip(acptr))));
265
266     if (!match(mask, namebuf) || !match(mask, ipbuf))
267       count++;
268   }
269
270   return count;
271 }