|
/* m_whox.c - Add WHOX support to /WHO |
|
* Copyright (C) 1990 Jarkko Oikarinen and |
|
* University of Oulu, Computing Center |
|
* |
|
* See file AUTHORS in IRC package for additional names of |
|
* the programmers. |
|
* |
|
* This program is free softwmare; you can redistribute it and/or modify |
|
* it under the terms of the GNU General Public License as published by |
|
* the Free Software Foundation; either version 1, or (at your option) |
|
* any later version. |
|
* |
|
* This program is distributed in the hope that it will be useful, |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
* GNU General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU General Public License |
|
* along with this program; if not, write to the Free Software |
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
|
*/ |
|
|
|
/* based heavily on the original m_who.c. Due to the complexity of this |
|
* command, it's easier to override it entirely rather than attempting |
|
* to bolt on WHOX functionality (most of the code would need to be copied |
|
* anyway). */ |
|
|
|
#include "unrealircd.h" |
|
|
|
#define RPL_WHOSPCRPL 354 |
|
#define MSG_WHO "WHO" |
|
|
|
static int whox(Cmdoverride *ovr, aClient *cptr, aClient *sptr, int parc, char *parv[]); |
|
|
|
ModuleHeader MOD_HEADER(m_whox) = { |
|
"whox", |
|
"1.0", |
|
"WHOX support for /who", |
|
"3.2-b8-1", |
|
NULL |
|
}; |
|
|
|
MOD_INIT(m_whox) |
|
{ |
|
return MOD_SUCCESS; |
|
} |
|
|
|
MOD_LOAD(m_whox) |
|
{ |
|
if (!CmdoverrideAdd(modinfo->handle, "WHO", whox)) |
|
return MOD_FAILED; |
|
|
|
if (!IsupportAdd(modinfo->handle, "WHOX", NULL)) |
|
return MOD_FAILED; |
|
|
|
return MOD_SUCCESS; |
|
} |
|
|
|
MOD_UNLOAD(m_whox) |
|
{ |
|
return MOD_SUCCESS; |
|
} |
|
|
|
static void do_channel_who(aClient *sptr, aChannel *channel, char *mask); |
|
static void make_who_status(aClient *, aClient *, aChannel *, Member *, char *, int); |
|
static void do_other_who(aClient *sptr, char *mask); |
|
static void send_who_reply(aClient *, aClient *, char *, char *, char *); |
|
static char *first_visible_channel(aClient *, aClient *, int *); |
|
static int parse_who_options(aClient *, int, char **); |
|
static void who_sendhelp(aClient *); |
|
|
|
#define WF_OPERONLY 0x01 /**< only show opers */ |
|
#define WF_ONCHANNEL 0x02 /**< we're on the channel we're /who'ing */ |
|
#define WF_WILDCARD 0x04 /**< a wildcard /who */ |
|
#define WF_REALHOST 0x08 /**< want real hostnames */ |
|
#define WF_IP 0x10 /**< want IP addresses */ |
|
|
|
static int who_flags; |
|
|
|
#define WHO_CANTSEE 0x01 /**< set if we can't see them */ |
|
#define WHO_CANSEE 0x02 /**< set if we can */ |
|
#define WHO_OPERSEE 0x04 /**< set if we only saw them because we're an oper */ |
|
|
|
#define FVC_HIDDEN 0x01 |
|
|
|
#define WHO_WANT 1 |
|
#define WHO_DONTWANT 2 |
|
#define WHO_DONTCARE 0 |
|
|
|
struct { |
|
int want_away; |
|
int want_channel; |
|
char *channel; /**< if they want one */ |
|
int want_gecos; |
|
char *gecos; |
|
int want_server; |
|
char *server; |
|
int want_host; |
|
char *host; |
|
int want_nick; |
|
char *nick; |
|
int want_user; |
|
char *user; |
|
int want_ip; |
|
char *ip; |
|
int want_port; |
|
int port; |
|
int want_umode; |
|
int umodes_dontwant; |
|
int umodes_want; |
|
int common_channels_only; |
|
int whox_querytype; |
|
char whox_fields[13]; |
|
} wfl; |
|
|
|
/** The /who command: retrieves information from users. */ |
|
static int whox(Cmdoverride *ovr, aClient *cptr, aClient *sptr, int parc, char *parv[]) |
|
{ |
|
aChannel *target_channel; |
|
char *mask = parv[1]; |
|
char star[] = "*"; |
|
int i = 0; |
|
|
|
if (!MyClient(sptr)) |
|
return 0; |
|
|
|
who_flags = 0; |
|
memset(&wfl, 0, sizeof(wfl)); |
|
|
|
if (parc > 1) |
|
{ |
|
i = parse_who_options(sptr, parc - 1, parv + 1); |
|
if (i < 0) |
|
{ |
|
sendto_one(sptr, getreply(RPL_ENDOFWHO), me.name, sptr->name, mask); |
|
return 0; |
|
} |
|
} |
|
|
|
if (parc-i < 2 || strcmp(parv[1 + i], "0") == 0) |
|
mask = star; |
|
else |
|
mask = parv[1 + i]; |
|
|
|
collapse(mask); |
|
|
|
if (!i && parc > 2 && *parv[2] == 'o') |
|
who_flags |= WF_OPERONLY; |
|
else if (!i && parc > 2) |
|
{ |
|
i = parse_who_options(sptr, parc - 2, parv + 2); |
|
if (i < 0) |
|
{ |
|
sendto_one(sptr, getreply(RPL_ENDOFWHO), me.name, sptr->name, mask); |
|
return 0; |
|
} |
|
} |
|
if (*mask == '\0') |
|
{ |
|
/* no mask given */ |
|
sendto_one(sptr, getreply(RPL_ENDOFWHO), me.name, sptr->name, "*"); |
|
return 0; |
|
} |
|
|
|
if ((target_channel = find_channel(mask, NULL)) != NULL) |
|
{ |
|
do_channel_who(sptr, target_channel, mask); |
|
sendto_one(sptr, getreply(RPL_ENDOFWHO), me.name, sptr->name, mask); |
|
return 0; |
|
} |
|
|
|
if (wfl.channel && wfl.want_channel == WHO_WANT && |
|
(target_channel = find_channel(wfl.channel, NULL)) != NULL) |
|
{ |
|
do_channel_who(sptr, target_channel, mask); |
|
sendto_one(sptr, getreply(RPL_ENDOFWHO), me.name, sptr->name, mask); |
|
return 0; |
|
} |
|
else |
|
{ |
|
do_other_who(sptr, mask); |
|
sendto_one(sptr, getreply(RPL_ENDOFWHO), me.name, sptr->name, mask); |
|
return 0; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static void who_sendhelp(aClient *sptr) |
|
{ |
|
char *who_help[] = { |
|
"/WHO [+|-][achmnsuM][%tcuihsnfdlar[,<querytype>]] [args] [mask]", |
|
"Flags are specified like channel modes, the flags chmnsu all have arguments", |
|
"Flags are set to a positive check by +, a negative check by -", |
|
"The flags work as follows:", |
|
"Flag a: user is away", |
|
"Flag c <channel>: user is on <channel>,", |
|
" no wildcards accepted", |
|
"Flag h <host>: user has string <host> in their hostname,", |
|
" wildcards accepted", |
|
"Flag m <usermodes>: user has <usermodes> set, only o is allowed", |
|
"Flag n <nick>: user has string <nick> in their nickname,", |
|
" wildcards accepted", |
|
"Flag s <server>: user is on server <server>,", |
|
" wildcards not accepted", |
|
"Flag u <user>: user has string <user> in their username,", |
|
" wildcards accepted", |
|
"Behavior flags:", |
|
"Flag M: check for user in channels I am a member of", |
|
"Fields begin with the % character. If any fields are specified, the reply", |
|
"uses the 354 numeric instead of 352. Fields not specified are omitted from", |
|
"the reply, while those specified are outputted in the order listed here.", |
|
"The fields work as follows:", |
|
"Field t: outputs the number in <querytype> in reply", |
|
"Field c: channel", |
|
"Field u: username", |
|
"Field i: IP address", |
|
"Field h: host", |
|
"Field s: server", |
|
"Field n: nickname", |
|
"Field f: status", |
|
"Field d: hop count", |
|
"Field l: idle time (0 for users on other servers)", |
|
"Field a: services account name (0 if none)", |
|
"Field r: realname", |
|
NULL |
|
}; |
|
|
|
char *who_oper_help[] = { |
|
"/WHO [+|-][acghimnsuMRI][%tcuihsnfdlar[,<querytype>]] [args] [mask]", |
|
"Flags are specified like channel modes, the flags chigmnsu all have arguments", |
|
"Flags are set to a positive check by +, a negative check by -", |
|
"The flags work as follows:", |
|
"Flag a: user is away", |
|
"Flag c <channel>: user is on <channel>,", |
|
" no wildcards accepted", |
|
"Flag g <gcos/realname>: user has string <gcos> in their GCOS,", |
|
" wildcards accepted", |
|
"Flag h <host>: user has string <host> in their hostname,", |
|
" wildcards accepted", |
|
"Flag i <ip>: user has string <ip> in their IP address,", |
|
" wildcards accepted", |
|
"Flag p <port>: user is connecting on port <port>,", |
|
" local connections only", |
|
"Flag m <usermodes>: user has <usermodes> set", |
|
"Flag n <nick>: user has string <nick> in their nickname,", |
|
" wildcards accepted", |
|
"Flag s <server>: user is on server <server>,", |
|
" wildcards not accepted", |
|
"Flag u <user>: user has string <user> in their username,", |
|
" wildcards accepted", |
|
"Behavior flags:", |
|
"Flag M: check for user in channels I am a member of", |
|
"Flag R: show users' real hostnames", |
|
"Flag I: show users' IP addresses", |
|
"Fields begin with the % character. If any fields are specified, the reply", |
|
"uses the 354 numeric instead of 352. Fields not specified are omitted from", |
|
"the reply, while those specified are outputted in the order listed here.", |
|
"The fields work as follows:", |
|
"Field t: outputs the number in <querytype> in reply", |
|
"Field c: channel", |
|
"Field u: username", |
|
"Field i: IP address", |
|
"Field h: host", |
|
"Field s: server", |
|
"Field n: nickname", |
|
"Field f: status", |
|
"Field d: hop count", |
|
"Field l: idle time (0 for users on other servers)", |
|
"Field a: services account name (0 if none)", |
|
"Field r: realname", |
|
NULL |
|
}; |
|
char **s; |
|
|
|
if (IsOper(sptr)) |
|
s = who_oper_help; |
|
else |
|
s = who_help; |
|
|
|
for (; *s; s++) |
|
sendto_one(sptr, getreply(RPL_LISTSYNTAX), me.name, sptr->name, *s); |
|
} |
|
|
|
#define WHO_ADD 1 |
|
#define WHO_DEL 2 |
|
|
|
static int parse_who_options(aClient *sptr, int argc, char **argv) |
|
{ |
|
char *s = argv[0]; |
|
int what = WHO_ADD; |
|
int i = 1; |
|
|
|
/* A few helper macro's because this is used a lot, added during recode by Syzop. */ |
|
|
|
/** function requiress a parameter: check if there's one, if not: return -1. */ |
|
#define REQUIRE_PARAM() { if (i >= argc) { \ |
|
who_sendhelp(sptr); \ |
|
return -1; \ |
|
} } while(0); |
|
/** set option 'x' depending on 'what' (add/want or del/dontwant) */ |
|
#define SET_OPTION(x) { if (what == WHO_ADD) \ |
|
x = WHO_WANT; \ |
|
else \ |
|
x = WHO_DONTWANT; \ |
|
} while(0); |
|
/** Eat a param, set the param in memory and set the option to want or dontwant */ |
|
#define DOIT(x,y) { REQUIRE_PARAM(); x = argv[i]; SET_OPTION(y); i++; } while(0); |
|
if (*s != '-' && *s != '+' && *s != '%') |
|
return 0; |
|
|
|
while (*s) |
|
{ |
|
switch (*s) |
|
{ |
|
case '+': |
|
what = WHO_ADD; |
|
break; |
|
case '-': |
|
what = WHO_DEL; |
|
break; |
|
case 'a': |
|
SET_OPTION(wfl.want_away); |
|
break; |
|
case 'c': |
|
DOIT(wfl.channel, wfl.want_channel); |
|
break; |
|
case 'g': |
|
REQUIRE_PARAM() |
|
if (!IsOper(sptr)) |
|
break; /* oper-only */ |
|
wfl.gecos = argv[i]; |
|
SET_OPTION(wfl.want_gecos); |
|
i++; |
|
break; |
|
case 's': |
|
DOIT(wfl.server, wfl.want_server); |
|
break; |
|
case 'h': |
|
DOIT(wfl.host, wfl.want_host); |
|
break; |
|
case 'i': |
|
REQUIRE_PARAM() |
|
if (!IsOper(sptr)) |
|
break; /* oper-only */ |
|
wfl.ip = argv[i]; |
|
SET_OPTION(wfl.want_ip); |
|
i++; |
|
break; |
|
case 'n': |
|
DOIT(wfl.nick, wfl.want_nick); |
|
break; |
|
case 'u': |
|
DOIT(wfl.user, wfl.want_user); |
|
break; |
|
case 'm': |
|
REQUIRE_PARAM() |
|
{ |
|
char *s = argv[i]; |
|
int *umodes; |
|
|
|
if (what == WHO_ADD) |
|
umodes = &wfl.umodes_want; |
|
else |
|
umodes = &wfl.umodes_dontwant; |
|
|
|
while (*s) |
|
{ |
|
int i; |
|
for (i = 0; i <= Usermode_highest; i++) |
|
if (*s == Usermode_Table[i].flag) |
|
{ |
|
*umodes |= Usermode_Table[i].mode; |
|
break; |
|
} |
|
s++; |
|
} |
|
|
|
if (!IsOper(sptr)) |
|
*umodes = *umodes & UMODE_OPER; /* these are usermodes regular users may search for. just oper now. */ |
|
if (*umodes == 0) |
|
return -1; |
|
} |
|
i++; |
|
break; |
|
case 'p': |
|
REQUIRE_PARAM() |
|
if (!IsOper(sptr)) |
|
break; /* oper-only */ |
|
wfl.port = atoi(argv[i]); |
|
SET_OPTION(wfl.want_port); |
|
i++; |
|
break; |
|
case 'M': |
|
SET_OPTION(wfl.common_channels_only); |
|
break; |
|
case 'R': |
|
if (!IsOper(sptr)) |
|
break; |
|
if (what == WHO_ADD) |
|
who_flags |= WF_REALHOST; |
|
else |
|
who_flags &= ~WF_REALHOST; |
|
break; |
|
case 'I': |
|
if (!IsOper(sptr)) |
|
break; |
|
if (what == WHO_ADD) |
|
who_flags |= WF_IP; |
|
|
|
else |
|
who_flags &= ~WF_IP; |
|
break; |
|
case '%': |
|
s++; |
|
goto process_whox; |
|
default: |
|
who_sendhelp(sptr); |
|
return -1; |
|
} |
|
s++; |
|
} |
|
|
|
return i; |
|
process_whox: |
|
while (*s) |
|
{ |
|
switch (*s) |
|
{ |
|
case 't': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[1] = 1; |
|
break; |
|
case 'c': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[2] = 1; |
|
break; |
|
case 'u': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[3] = 1; |
|
break; |
|
case 'i': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[4] = 1; |
|
break; |
|
case 'h': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[5] = 1; |
|
break; |
|
case 's': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[6] = 1; |
|
break; |
|
case 'n': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[7] = 1; |
|
break; |
|
case 'f': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[8] = 1; |
|
break; |
|
case 'd': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[9] = 1; |
|
break; |
|
case 'l': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[10] = 1; |
|
break; |
|
case 'a': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[11] = 1; |
|
break; |
|
case 'r': |
|
wfl.whox_fields[0] = 1; |
|
wfl.whox_fields[12] = 1; |
|
break; |
|
case ',': |
|
s++; |
|
goto process_querytype; |
|
default: |
|
who_sendhelp(sptr); |
|
return -1; |
|
} |
|
s++; |
|
} |
|
|
|
return i; |
|
process_querytype: |
|
/* s points to a string representing an int querytype (could be empty) */ |
|
wfl.whox_querytype = strtol(s, NULL, 10); |
|
|
|
return i; |
|
#undef REQUIRE_PARAM |
|
#undef SET_OPTION |
|
#undef DOIT |
|
} |
|
|
|
static int can_see(aClient *sptr, aClient *acptr, aChannel *channel) |
|
{ |
|
int ret = 0; |
|
int i=0; |
|
Hook *h; |
|
char has_common_chan = 0; |
|
do { |
|
/* can only see people */ |
|
if (!IsPerson(acptr)) |
|
return WHO_CANTSEE; |
|
|
|
/* can only see opers if thats what they want */ |
|
if (who_flags & WF_OPERONLY) |
|
{ |
|
if (!IsOper(acptr)) |
|
return ret | WHO_CANTSEE; |
|
if (IsHideOper(acptr)) { |
|
if (IsOper(sptr)) |
|
ret |= WHO_OPERSEE; |
|
else |
|
return ret | WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people who are away */ |
|
if ((wfl.want_away == WHO_WANT && !acptr->user->away) || |
|
(wfl.want_away == WHO_DONTWANT && acptr->user->away)) |
|
return WHO_CANTSEE; |
|
|
|
/* if they only want people on a certain channel. */ |
|
if (wfl.want_channel != WHO_DONTCARE) |
|
{ |
|
aChannel *chan = find_channel(wfl.channel, NULL); |
|
if (!chan && wfl.want_channel == WHO_WANT) |
|
return WHO_CANTSEE; |
|
if ((wfl.want_channel == WHO_WANT) && !IsMember(acptr, chan)) |
|
return WHO_CANTSEE; |
|
if ((wfl.want_channel == WHO_DONTWANT) && IsMember(acptr, chan)) |
|
return WHO_CANTSEE; |
|
} |
|
|
|
/* if they only want people with a certain gecos */ |
|
if (wfl.want_gecos != WHO_DONTCARE) |
|
{ |
|
if (((wfl.want_gecos == WHO_WANT) && match(wfl.gecos, acptr->info)) || |
|
((wfl.want_gecos == WHO_DONTWANT) && !match(wfl.gecos, acptr->info))) |
|
{ |
|
return WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people with a certain server */ |
|
if (wfl.want_server != WHO_DONTCARE) |
|
{ |
|
if (((wfl.want_server == WHO_WANT) && stricmp(wfl.server, acptr->user->server)) || |
|
((wfl.want_server == WHO_DONTWANT) && !stricmp(wfl.server, acptr->user->server))) |
|
{ |
|
return WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people with a certain host */ |
|
if (wfl.want_host != WHO_DONTCARE) |
|
{ |
|
char *host; |
|
|
|
if (IsOper(sptr)) |
|
host = acptr->user->realhost; |
|
else |
|
host = GetHost(acptr); |
|
|
|
if (((wfl.want_host == WHO_WANT) && match(wfl.host, host)) || |
|
((wfl.want_host == WHO_DONTWANT) && !match(wfl.host, host))) |
|
{ |
|
return WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people with a certain IP */ |
|
if (wfl.want_ip != WHO_DONTCARE) |
|
{ |
|
char *ip; |
|
|
|
ip = acptr->ip; |
|
if (!ip) |
|
return WHO_CANTSEE; |
|
|
|
if (((wfl.want_ip == WHO_WANT) && match(wfl.ip, ip)) || |
|
((wfl.want_ip == WHO_DONTWANT) && !match(wfl.ip, ip))) |
|
{ |
|
return WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people connecting on a certain port */ |
|
if (wfl.want_port != WHO_DONTCARE) |
|
{ |
|
int port; |
|
|
|
if (!MyClient(acptr)) |
|
return WHO_CANTSEE; |
|
|
|
port = acptr->local->listener->port; |
|
|
|
if (((wfl.want_port == WHO_WANT) && wfl.port != port) || |
|
((wfl.want_port == WHO_DONTWANT) && wfl.port == port)) |
|
{ |
|
return WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people with a certain nick.. */ |
|
if (wfl.want_nick != WHO_DONTCARE) |
|
{ |
|
if (((wfl.want_nick == WHO_WANT) && match(wfl.nick, acptr->name)) || |
|
((wfl.want_nick == WHO_DONTWANT) && !match(wfl.nick, acptr->name))) |
|
{ |
|
return WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people with a certain username */ |
|
if (wfl.want_user != WHO_DONTCARE) |
|
{ |
|
if (((wfl.want_user == WHO_WANT) && match(wfl.user, acptr->user->username)) || |
|
((wfl.want_user == WHO_DONTWANT) && !match(wfl.user, acptr->user->username))) |
|
{ |
|
return WHO_CANTSEE; |
|
} |
|
} |
|
|
|
/* if they only want people with a certain umode */ |
|
if (wfl.umodes_want) |
|
{ |
|
if (!(acptr->umodes & wfl.umodes_want) || (!IsOper(sptr) && (acptr->umodes & UMODE_HIDEOPER))) |
|
return WHO_CANTSEE; |
|
} |
|
|
|
if (wfl.umodes_dontwant) |
|
{ |
|
if ((acptr->umodes & wfl.umodes_dontwant) && (!(acptr->umodes & UMODE_HIDEOPER) || IsOper(sptr))) |
|
return WHO_CANTSEE; |
|
} |
|
|
|
/* if they only want common channels */ |
|
if (wfl.common_channels_only) |
|
{ |
|
if (!has_common_channels(sptr, acptr)) |
|
return WHO_CANTSEE; |
|
has_common_chan = 1; |
|
} |
|
|
|
if (channel) |
|
{ |
|
int member = who_flags & WF_ONCHANNEL; |
|
|
|
if (SecretChannel(channel) || HiddenChannel(channel)) |
|
{ |
|
/* if they aren't on it.. they can't see it */ |
|
if (!(who_flags & WF_ONCHANNEL)) |
|
break; |
|
} |
|
if (IsInvisible(acptr) && !member) |
|
break; |
|
|
|
if (!user_can_see_member(sptr, acptr, channel)) |
|
continue; /* invisible (eg: due to delayjoin) */ |
|
} |
|
else |
|
{ |
|
/* a user/mask who */ |
|
|
|
/* If the common channel info hasn't been set, set it now */ |
|
if (!wfl.common_channels_only) |
|
has_common_chan = has_common_channels(sptr, acptr); |
|
|
|
if (IsInvisible(acptr) && !has_common_chan) |
|
{ |
|
/* don't show them unless it's an exact match |
|
or it is the user requesting the /who */ |
|
if ((who_flags & WF_WILDCARD) && sptr != acptr) |
|
break; |
|
} |
|
} |
|
|
|
/* phew.. show them. */ |
|
return WHO_CANSEE; |
|
} while (0); |
|
|
|
/* if we get here, it's oper-dependant. */ |
|
if (IsOper(sptr)) |
|
return ret | WHO_OPERSEE | WHO_CANSEE; |
|
else |
|
{ |
|
if (sptr == acptr) |
|
return ret | WHO_CANSEE; |
|
else |
|
return ret | WHO_CANTSEE; |
|
} |
|
} |
|
|
|
static void do_channel_who(aClient *sptr, aChannel *channel, char *mask) |
|
{ |
|
Member *cm = channel->members; |
|
if (IsMember(sptr, channel) || ValidatePermissionsForPath("override:see:who:onchannel",sptr,NULL,channel,NULL)) |
|
who_flags |= WF_ONCHANNEL; |
|
|
|
for (cm = channel->members; cm; cm = cm->next) |
|
{ |
|
aClient *acptr = cm->cptr; |
|
char status[32]; |
|
int cansee; |
|
if ((cansee = can_see(sptr, acptr, channel)) & WHO_CANTSEE) |
|
continue; |
|
|
|
make_who_status(sptr, acptr, channel, cm, status, cansee); |
|
send_who_reply(sptr, acptr, channel->chname, status, ""); |
|
} |
|
} |
|
|
|
static void make_who_status(aClient *sptr, aClient *acptr, aChannel *channel, |
|
Member *cm, char *status, int cansee) |
|
{ |
|
int i = 0; |
|
Hook *h; |
|
|
|
if (acptr->user->away) |
|
status[i++] = 'G'; |
|
else |
|
status[i++] = 'H'; |
|
|
|
if (IsARegNick(acptr)) |
|
status[i++] = 'r'; |
|
|
|
for (h = Hooks[HOOKTYPE_WHO_STATUS]; h; h = h->next) |
|
{ |
|
int ret = (*(h->func.intfunc))(sptr, acptr, channel, cm, status, cansee); |
|
if (ret != 0) |
|
status[i++] = (char)ret; |
|
} |
|
|
|
if (IsOper(acptr) && (!IsHideOper(acptr) || sptr == acptr || IsOper(sptr))) |
|
status[i++] = '*'; |
|
|
|
if (IsOper(acptr) && (IsHideOper(acptr) && sptr != acptr && IsOper(sptr))) |
|
status[i++] = '!'; |
|
|
|
if (cansee & WHO_OPERSEE) |
|
status[i++] = '?'; |
|
|
|
if (cm) |
|
{ |
|
if (SupportNAMESX(sptr)) |
|
{ |
|
#ifdef PREFIX_AQ |
|
if (cm->flags & CHFL_CHANOWNER) |
|
status[i++] = '~'; |
|
if (cm->flags & CHFL_CHANPROT) |
|
status[i++] = '&'; |
|
#endif |
|
if (cm->flags & CHFL_CHANOP) |
|
status[i++] = '@'; |
|
if (cm->flags & CHFL_HALFOP) |
|
status[i++] = '%'; |
|
if (cm->flags & CHFL_VOICE) |
|
status[i++] = '+'; |
|
} else { |
|
#ifdef PREFIX_AQ |
|
if (cm->flags & CHFL_CHANOWNER) |
|
status[i++] = '~'; |
|
else if (cm->flags & CHFL_CHANPROT) |
|
status[i++] = '&'; |
|
else |
|
#endif |
|
if (cm->flags & CHFL_CHANOP) |
|
status[i++] = '@'; |
|
else if (cm->flags & CHFL_HALFOP) |
|
status[i++] = '%'; |
|
else if (cm->flags & CHFL_VOICE) |
|
status[i++] = '+'; |
|
} |
|
} |
|
|
|
status[i] = '\0'; |
|
} |
|
|
|
static void do_other_who(aClient *sptr, char *mask) |
|
{ |
|
int oper = IsOper(sptr); |
|
|
|
if (strchr(mask, '*') || strchr(mask, '?')) |
|
{ |
|
int i = 0; |
|
/* go through all users.. */ |
|
aClient *acptr; |
|
who_flags |= WF_WILDCARD; |
|
|
|
list_for_each_entry(acptr, &client_list, client_node) |
|
{ |
|
int cansee; |
|
char status[20]; |
|
char *channel; |
|
int flg; |
|
|
|
if (!IsPerson(acptr)) |
|
continue; |
|
if (!oper) { |
|
/* non-opers can only search on nick here */ |
|
if (match(mask, acptr->name)) |
|
continue; |
|
} else { |
|
/* opers can search on name, ident, virthost, ip and realhost. |
|
* Yes, I like readable if's -- Syzop. |
|
*/ |
|
if (!match(mask, acptr->name) || !match(mask, acptr->user->realhost) || |
|
!match(mask, acptr->user->username)) |
|
goto matchok; |
|
if (IsHidden(acptr) && !match(mask, acptr->user->virthost)) |
|
goto matchok; |
|
if (acptr->ip && !match(mask, acptr->ip)) |
|
goto matchok; |
|
/* nothing matched... */ |
|
continue; |
|
} |
|
matchok: |
|
if ((cansee = can_see(sptr, acptr, NULL)) & WHO_CANTSEE) |
|
continue; |
|
if (WHOLIMIT && !IsOper(sptr) && ++i > WHOLIMIT) |
|
{ |
|
sendto_one(sptr, rpl_str(ERR_WHOLIMEXCEED), me.name, sptr->name, WHOLIMIT); |
|
return; |
|
} |
|
|
|
channel = first_visible_channel(sptr, acptr, &flg); |
|
make_who_status(sptr, acptr, NULL, NULL, status, cansee); |
|
send_who_reply(sptr, acptr, channel, status, (flg & FVC_HIDDEN) ? "~" : ""); |
|
} |
|
} |
|
else |
|
{ |
|
/* just a single client (no wildcards detected) */ |
|
aClient *acptr = find_client(mask, NULL); |
|
int cansee; |
|
char status[20]; |
|
char *channel; |
|
int flg; |
|
|
|
if (!acptr) |
|
return; |
|
|
|
if ((cansee = can_see(sptr, acptr, NULL)) == WHO_CANTSEE) |
|
return; |
|
|
|
channel = first_visible_channel(sptr, acptr, &flg); |
|
make_who_status(sptr, acptr, NULL, NULL, status, cansee); |
|
send_who_reply(sptr, acptr, channel, status, (flg & FVC_HIDDEN) ? "~" : ""); |
|
} |
|
} |
|
|
|
static void send_who_reply(aClient *sptr, aClient *acptr, |
|
char *channel, char *status, char *xstat) |
|
{ |
|
char *stat; |
|
char *host; |
|
char *ip; |
|
char *account; |
|
int flat = (FLAT_MAP && !IsOper(sptr)) ? 1 : 0; |
|
char *server; |
|
int hops; |
|
char hopsstr[12] = {0}; |
|
char querytype[12] = {0}; /* ensure we can comfortably fit the string representation of an int + trailing null */ |
|
char idle[12] = {0}; |
|
|
|
/* helper macro for WHOX replies */ |
|
#define MAYBE_BLANK(n, x) wfl.whox_fields[n] ? " " : "", wfl.whox_fields[n] ? (x) : "" |
|
#define MAYBE_BLANK_COLON(n, x) wfl.whox_fields[n] ? " :" : "", wfl.whox_fields[n] ? (x) : "" |
|
|
|
stat = malloc(strlen(status) + strlen(xstat) + 1); |
|
sprintf(stat, "%s%s", status, xstat); |
|
|
|
if (IsOper(sptr)) |
|
{ |
|
if (who_flags & WF_REALHOST) |
|
host = acptr->user->realhost; |
|
else if (who_flags & WF_IP) |
|
host = (acptr->ip ? acptr->ip : acptr->user->realhost); |
|
else |
|
host = GetHost(acptr); |
|
} |
|
else |
|
host = GetHost(acptr); |
|
|
|
if (!IsOper(sptr) && IsHidden(acptr)) |
|
ip = "255.255.255.255"; |
|
else |
|
ip = (acptr->ip ? acptr->ip : "255.255.255.255"); |
|
|
|
if (IsULine(acptr) && !IsOper(sptr) && !ValidatePermissionsForPath("map:ulines",sptr,acptr,NULL,NULL) && HIDE_ULINES) |
|
{ |
|
server = "hidden"; |
|
hops = 0; |
|
} |
|
else |
|
{ |
|
server = acptr->user->server; |
|
hops = flat ? 0 : acptr->hopcount; |
|
} |
|
|
|
account = (*acptr->user->svid == '*') ? "0" : acptr->user->svid; |
|
snprintf(querytype, 12, "%d", wfl.whox_querytype); |
|
snprintf(hopsstr, 12, "%d", hops); |
|
|
|
/* only show idle time if they're local and aren't an oper with +I */ |
|
if (MyConnect(acptr) && (IsOper(sptr) || !(acptr->umodes & UMODE_HIDLE))) |
|
snprintf(idle, 12, "%d", TStime() - acptr->local->last); |
|
else |
|
idle[0] = '0'; |
|
|
|
if (wfl.whox_fields[0]) |
|
sendto_one(sptr, ":%s 354 %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", me.name, sptr->name, |
|
MAYBE_BLANK(1, querytype), |
|
MAYBE_BLANK(2, channel), |
|
MAYBE_BLANK(3, acptr->user->username), |
|
MAYBE_BLANK(4, ip), |
|
MAYBE_BLANK(5, host), |
|
MAYBE_BLANK(6, server), |
|
MAYBE_BLANK(7, acptr->name), |
|
MAYBE_BLANK(8, stat), |
|
MAYBE_BLANK(9, hopsstr), |
|
MAYBE_BLANK(10, idle), |
|
MAYBE_BLANK(11, account), |
|
MAYBE_BLANK_COLON(12, acptr->info) |
|
); |
|
else |
|
sendto_one(sptr, getreply(RPL_WHOREPLY), me.name, sptr->name, |
|
channel, /* channel name */ |
|
acptr->user->username, /* user name */ |
|
host, /* hostname */ |
|
server, /* server name */ |
|
acptr->name, /* nick */ |
|
stat, /* status */ |
|
hops, /* hops */ |
|
acptr->info /* realname */ |
|
); |
|
|
|
free(stat); |
|
|
|
#undef MAYBE_BLANK |
|
#undef MAYBE_BLANK_COLON |
|
} |
|
|
|
static char *first_visible_channel(aClient *sptr, aClient *acptr, int *flg) |
|
{ |
|
Membership *lp; |
|
|
|
*flg = 0; |
|
|
|
for (lp = acptr->user->channel; lp; lp = lp->next) |
|
{ |
|
aChannel *chptr = lp->chptr; |
|
Hook *h; |
|
int ret = EX_ALLOW; |
|
int operoverride = 0; |
|
int showchannel = 0; |
|
|
|
/* Note that the code below is almost identical to the one in /WHOIS */ |
|
|
|
if (ShowChannel(sptr, chptr)) |
|
showchannel = 1; |
|
|
|
for (h = Hooks[HOOKTYPE_SEE_CHANNEL_IN_WHOIS]; h; h = h->next) |
|
{ |
|
int n = (*(h->func.intfunc))(sptr, acptr, chptr); |
|
/* Hook return values: |
|
* EX_ALLOW means 'yes is ok, as far as modules are concerned' |
|
* EX_DENY means 'hide this channel, unless oper overriding' |
|
* EX_ALWAYS_DENY means 'hide this channel, always' |
|
* ... with the exception that we always show the channel if you /WHOIS yourself |
|
*/ |
|
if (n == EX_DENY) |
|
{ |
|
ret = EX_DENY; |
|
} |
|
else if (n == EX_ALWAYS_DENY) |
|
{ |
|
ret = EX_ALWAYS_DENY; |
|
break; |
|
} |
|
} |
|
|
|
if (ret == EX_DENY) |
|
showchannel = 0; |
|
|
|
if (!showchannel && (ValidatePermissionsForPath("override:see:who:secret",sptr,NULL,chptr,NULL) || ValidatePermissionsForPath("override:see:whois",sptr,NULL,chptr,NULL))) |
|
{ |
|
showchannel = 1; /* OperOverride */ |
|
operoverride = 1; |
|
} |
|
|
|
if ((ret == EX_ALWAYS_DENY) && (acptr != sptr)) |
|
continue; /* a module asked us to really not expose this channel, so we don't (except target==ourselves). */ |
|
|
|
if (acptr == sptr) |
|
showchannel = 1; |
|
|
|
if (operoverride) |
|
*flg |= FVC_HIDDEN; |
|
|
|
if (showchannel) |
|
return chptr->chname; |
|
} |
|
|
|
/* no channels that they can see */ |
|
return "*"; |
|
} |
