/*
* Send whois information for acptr to sptr
*/
static void do_whois(struct Client* sptr, struct Client *acptr, int parc)
{
struct Client *a2cptr=0;
struct Channel *chptr=0;
int mlen;
int len;
static char buf[512];
const struct User* user = cli_user(acptr);
const char* name = (!*(cli_name(acptr))) ? "?" : cli_name(acptr);
a2cptr = feature_bool(FEAT_HIS_WHOIS_SERVERNAME) && !IsAnOper(sptr)
&& sptr != acptr ? &his : user->server;
assert(user);
send_reply(sptr, RPL_WHOISUSER, name, user->username, user->host,
cli_info(acptr));
/* Display the channels this user is on. */
if (!IsChannelService(acptr))
{
struct Membership* chan;
mlen = strlen(cli_name(&me)) + strlen(cli_name(sptr)) + 12 + strlen(name);
len = 0;
*buf = '\0';
for (chan = user->channel; chan; chan = chan->next_channel)
{
chptr = chan->channel;
if (!ShowChannel(sptr, chptr)
&& !(IsOper(sptr) && IsLocalChannel(chptr->chname)))
continue;
if (acptr != sptr && IsZombie(chan))
continue;
/* Don't show local channels when HIS is defined, unless it's a
* remote WHOIS --ULtimaTe_
*/
if (IsLocalChannel(chptr->chname) && (acptr != sptr) && (parc == 2)
&& feature_bool(FEAT_HIS_WHOIS_LOCALCHAN) && !IsAnOper(sptr))
continue;
if (len+strlen(chptr->chname) + mlen > BUFSIZE - 5)
{
send_reply(sptr, SND_EXPLICIT | RPL_WHOISCHANNELS, "%s :%s", name, buf);
*buf = '\0';
len = 0;
}
if (IsDeaf(acptr))
*(buf + len++) = '-';
if (!ShowChannel(sptr, chptr))
*(buf + len++) = '*';
if (IsDelayedJoin(chan) && (sptr != acptr))
*(buf + len++) = '<';
else if (IsChanOp(chan))
*(buf + len++) = '@';
else if (HasVoice(chan))
*(buf + len++) = '+';
else if (IsZombie(chan))
*(buf + len++) = '!';
if (len)
*(buf + len) = '\0';
strcpy(buf + len, chptr->chname);
len += strlen(chptr->chname);
strcat(buf + len, " ");
len++;
}
if (buf[0] != '\0')
send_reply(sptr, RPL_WHOISCHANNELS, name, buf);
}
send_reply(sptr, RPL_WHOISSERVER, name, cli_name(a2cptr),
cli_info(a2cptr));
if (user)
{
if (user->away)
send_reply(sptr, RPL_AWAY, name, user->away);
if (SeeOper(sptr,acptr))
send_reply(sptr, RPL_WHOISOPERATOR, name);
if (IsAccount(acptr))
send_reply(sptr, RPL_WHOISACCOUNT, name, user->account);
if (HasHiddenHost(acptr) && (IsAnOper(sptr) || acptr == sptr))
send_reply(sptr, RPL_WHOISACTUALLY, name, user->username,
user->realhost, ircd_ntoa(&cli_ip(acptr)));
/* Hint: if your looking to add more flags to a user, eg +h, here's
* probably a good place to add them :)
*/
if (MyConnect(acptr) && (!feature_bool(FEAT_HIS_WHOIS_IDLETIME) ||
(sptr == acptr || IsAnOper(sptr) || parc >= 3)))
send_reply(sptr, RPL_WHOISIDLE, name, CurrentTime - user->last,
cli_firsttime(acptr));
}
}
/** Handle a KICK message from a server connection.
*
* \a parv has the following elements:
* \li \a parv[1] is the channel name to kick someone from
* \li \a parv[2] is the numnick of the client to kick
* \li \a parv[\a parc - 1] is the kick comment
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int ms_kick(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *who;
struct Channel *chptr;
struct Membership *member = 0, *sptr_link = 0;
char *name, *comment;
if (parc < 3 || *parv[1] == '\0')
return need_more_params(sptr, "KICK");
name = parv[1];
comment = parv[parc - 1];
/* figure out who gets kicked from what */
if (IsLocalChannel(name) ||
!(chptr = get_channel(sptr, name, CGT_NO_CREATE)) ||
!(who = findNUser(parv[2])))
return 0;
/* We go ahead and pass on the KICK for users not on the channel */
member = find_member_link(chptr, who);
if (member && IsZombie(member))
{
/* We might get a KICK from a zombie's own server because the user
* net-rode during a burst (which always generates a KICK) *and*
* was kicked via another server. In that case, we must remove
* the user from the channel.
*/
if (sptr == cli_user(who)->server)
{
remove_user_from_channel(who, chptr);
}
/* Otherwise, we treat zombies like they are not channel members. */
member = 0;
}
/* Send HACK notice, but not for servers in BURST */
/* 2002-10-17: Don't send HACK if the users local server is kicking them */
if (IsServer(sptr) &&
!IsBurstOrBurstAck(sptr) &&
sptr!=cli_user(who)->server)
sendto_opmask(0, SNO_HACK4, "HACK: %C KICK %H %C %s", sptr, chptr,
who, comment);
/* Unless someone accepted it downstream (or the user isn't on the channel
* here), if kicker is not on channel, or if kicker is not a channel
* operator, bounce the kick
*/
#if defined(DDB) || defined(SERVICES)
if (!IsServer(sptr) && member && cli_from(who) != cptr && !IsService(cli_user(sptr)->server) &&
(!(sptr_link = find_member_link(chptr, sptr)) || !(IsChanOwner(sptr_link) || IsChanOp(sptr_link)))) {
#else
if (!IsServer(sptr) && member && cli_from(who) != cptr &&
(!(sptr_link = find_member_link(chptr, sptr)) || !IsChanOp(sptr_link))) {
#endif
sendto_opmask(0, SNO_HACK2, "HACK: %C KICK %H %C %s", sptr, chptr,
who, comment);
sendcmdto_one(who, CMD_JOIN, cptr, "%H", chptr);
/* Reop/revoice member */
if (IsChanOp(member) || HasVoice(member)) {
struct ModeBuf mbuf;
modebuf_init(&mbuf, sptr, cptr, chptr,
(MODEBUF_DEST_SERVER | /* Send mode to a server */
MODEBUF_DEST_DEOP | /* Deop the source */
MODEBUF_DEST_BOUNCE)); /* And bounce the MODE */
#if defined(UNDERNET)
if (IsChanOp(member))
modebuf_mode_client(&mbuf, MODE_DEL | MODE_CHANOP, who, OpLevel(member));
if (HasVoice(member))
modebuf_mode_client(&mbuf, MODE_DEL | MODE_VOICE, who, MAXOPLEVEL + 1);
#else
if (IsChanOp(member))
modebuf_mode_client(&mbuf, MODE_DEL | MODE_CHANOP, who, 0);
if (HasVoice(member))
modebuf_mode_client(&mbuf, MODE_DEL | MODE_VOICE, who, 0);
#endif
modebuf_flush(&mbuf);
}
} else {
/* Propagate kick... */
sendcmdto_serv(sptr, CMD_KICK, cptr, "%H %C :%s", chptr, who, comment);
if (member) { /* and tell the channel about it */
if (IsDelayedJoin(member)) {
if (MyUser(who))
sendcmdto_one(IsServer(sptr) ? &his : sptr, CMD_KICK,
who, "%H %C :%s", chptr, who, comment);
} else {
sendcmdto_channel(IsServer(sptr) ? &his : sptr, CMD_KICK,
chptr, NULL, SKIP_SERVERS, "%H %C :%s",
chptr, who, comment);
}
make_zombie(member, who, cptr, sptr, chptr);
}
}
return 0;
}
/** Handle a KICK message from a local connection.
*
* \a parv has the following elements:
* \li \a parv[1] is the channel name to kick someone from
* \li \a parv[2] is the nickname of the client to kick
* \li \a parv[\a parc - 1] (optional) is the kick comment
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int m_kick(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *who;
struct Channel *chptr;
struct Membership *member = 0;
struct Membership* member2;
char *name, *comment;
if (parc < 3 || *parv[1] == '\0')
return need_more_params(sptr, "KICK");
name = parv[1];
/* simple checks */
if (!(chptr = get_channel(sptr, name, CGT_NO_CREATE)))
return send_reply(sptr, ERR_NOSUCHCHANNEL, name);
#if defined(DDB) || defined(SERVICES)
if (!(member2 = find_member_link(chptr, sptr)) || IsZombie(member2)
|| !(IsChanOwner(member2) || IsChanOp(member2)))
#else
if (!(member2 = find_member_link(chptr, sptr)) || IsZombie(member2)
|| !IsChanOp(member2))
#endif
return send_reply(sptr, ERR_CHANOPRIVSNEEDED, name);
if (!(who = find_chasing(sptr, parv[2], 0)))
return 0; /* find_chasing sends the reply for us */
/* Don't allow the channel service to be kicked */
if (IsChannelService(who))
return send_reply(sptr, ERR_ISCHANSERVICE, cli_name(who), chptr->chname);
/* Prevent kicking opers from local channels -DM- */
if (IsLocalChannel(chptr->chname) && HasPriv(who, PRIV_DEOP_LCHAN))
return send_reply(sptr, ERR_ISOPERLCHAN, cli_name(who), chptr->chname);
/* check if kicked user is actually on the channel */
if (!(member = find_member_link(chptr, who)) || IsZombie(member))
return send_reply(sptr, ERR_USERNOTINCHANNEL, cli_name(who), chptr->chname);
#if defined(UNDERNET)
/* Don't allow to kick member with a higher op-level,
* or members with the same op-level unless both are MAXOPLEVEL.
*/
if (OpLevel(member) < OpLevel(member2)
|| (OpLevel(member) == OpLevel(member2)
&& OpLevel(member) < MAXOPLEVEL))
return send_reply(sptr, ERR_NOTLOWEROPLEVEL, cli_name(who), chptr->chname,
OpLevel(member2), OpLevel(member), "kick",
OpLevel(member) == OpLevel(member2) ? "the same" : "a higher");
#elif defined(DDB) || defined(SERVICES)
/* Don't allow to kick channel owner */
if (IsChanOwner(member) && !IsAnOper(sptr))
return send_reply(sptr, ERR_ISCHANSERVICE, cli_name(who), chptr->chname);
#endif
/* We rely on ircd_snprintf to truncate the comment */
comment = EmptyString(parv[parc - 1]) ? parv[0] : parv[parc - 1];
if (!IsLocalChannel(name))
sendcmdto_serv(sptr, CMD_KICK, cptr, "%H %C :%s", chptr, who, comment);
if (IsDelayedJoin(member)) {
/* If it's a delayed join, only send the KICK to the person doing
* the kicking and the victim */
if (MyUser(who))
sendcmdto_one(sptr, CMD_KICK, who, "%H %C :%s", chptr, who, comment);
sendcmdto_one(who, CMD_JOIN, sptr, "%H", chptr);
sendcmdto_one(sptr, CMD_KICK, sptr, "%H %C :%s", chptr, who, comment);
} else
sendcmdto_channel(sptr, CMD_KICK, chptr, NULL, SKIP_SERVERS,
"%H %C :%s", chptr, who, comment);
make_zombie(member, who, cptr, sptr, chptr);
return 0;
}
/** List some or all of of the users in a channel.
*
* The list contents depend on \a filter:
* NAMES_ALL - Lists all users on channel.
* NAMES_VIS - Only list visible (-i) users. --Gte (04/06/2000).
* NAMES_DEL - Only list delayed-join members.
* NAMES_EON - When OR'd with the other two, adds an 'End of Names' numeric
* used by m_join
*
* @param[in] sptr Client to whom to send the list.
* @param[in] chptr Channel to send list from.
* @param[in] filter Selector for list contents, as above.
*/
void do_names(struct Client* sptr, struct Channel* chptr, int filter)
{
int mlen;
int idx;
int flag;
int needs_space;
int len;
char buf[BUFSIZE];
struct Client *c2ptr;
struct Membership* member;
assert(chptr);
assert(sptr);
assert((filter&NAMES_ALL) != (filter&NAMES_VIS));
/* Tag Pub/Secret channels accordingly. */
strcpy(buf, "* ");
if (PubChannel(chptr))
*buf = '=';
else if (SecretChannel(chptr))
*buf = '@';
len = strlen(chptr->chname);
strcpy(buf + 2, chptr->chname);
strcpy(buf + 2 + len, " :");
idx = len + 4;
flag = 1;
needs_space = 0;
if (!ShowChannel(sptr, chptr)) /* Don't list private channels unless we are on them. */
return;
/* Iterate over all channel members, and build up the list. */
mlen = strlen(cli_name(&me)) + 10 + strlen(cli_name(sptr));
for (member = chptr->members; member; member = member->next_member)
{
c2ptr = member->user;
if (((filter&NAMES_VIS)!=0) && IsInvisible(c2ptr))
continue;
if (IsZombie(member) && member->user != sptr)
continue;
if (IsDelayedJoin(member) && (member->user != sptr) && !(filter & NAMES_DEL))
continue;
if ((!IsDelayedJoin(member) || (member->user == sptr)) && (filter & NAMES_DEL))
continue;
if (needs_space)
buf[idx++] = ' ';
needs_space=1;
if (IsZombie(member))
buf[idx++] = '!';
else if (IsChanOp(member))
buf[idx++] = '@';
else if (HasVoice(member))
buf[idx++] = '+';
strcpy(buf + idx, cli_name(c2ptr));
idx += strlen(cli_name(c2ptr));
flag = 1;
if (mlen + idx + NICKLEN + 5 > BUFSIZE)
/* space, modifier, nick, \r \n \0 */
{
send_reply(sptr, (filter & NAMES_DEL) ? RPL_DELNAMREPLY : RPL_NAMREPLY, buf);
idx = len + 4;
flag = 0;
needs_space=0;
}
}
if (flag)
send_reply(sptr, (filter & NAMES_DEL) ? RPL_DELNAMREPLY : RPL_NAMREPLY, buf);
if (filter&NAMES_EON)
send_reply(sptr, RPL_ENDOFNAMES, chptr->chname);
}
