/** Handle a local user's attempt to get or set a channel topic.
*
* \a parv has the following elements:
* \li \a parv[1] is the channel name
* \li \a parv[\a parc - 1] is the topic (if \a parc > 2)
*
* 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_topic(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Channel *chptr;
char *topic = 0, *name, *p = 0;
if (parc < 2)
return need_more_params(sptr, "TOPIC");
if (parc > 2)
topic = parv[parc - 1];
for (; (name = ircd_strtok(&p, parv[1], ",")); parv[1] = 0)
{
chptr = 0;
/* Does the channel exist */
if (!IsChannelName(name) || !(chptr = FindChannel(name)))
{
send_reply(sptr,ERR_NOSUCHCHANNEL,name);
continue;
}
/* Trying to check a topic outside a secret channel */
if ((topic || SecretChannel(chptr)) && !find_channel_member(sptr, chptr))
{
send_reply(sptr, ERR_NOTONCHANNEL, chptr->chname);
continue;
}
/* only asking for topic */
if (!topic)
{
if (chptr->topic[0] == '\0')
send_reply(sptr, RPL_NOTOPIC, chptr->chname);
else
{
send_reply(sptr, RPL_TOPIC, chptr->chname, chptr->topic);
send_reply(sptr, RPL_TOPICWHOTIME, chptr->chname, chptr->topic_nick,
chptr->topic_time);
}
}
#if defined(DDB) || defined(SERVICES)
else if ((chptr->mode.mode & MODE_TOPICLIMIT) &&
!(is_chan_owner(sptr, chptr) || is_chan_op(sptr, chptr)))
#else
else if ((chptr->mode.mode & MODE_TOPICLIMIT) && !is_chan_op(sptr, chptr))
#endif
send_reply(sptr, ERR_CHANOPRIVSNEEDED, chptr->chname);
else if (!client_can_send_to_channel(sptr, chptr, 1))
send_reply(sptr, ERR_CANNOTSENDTOCHAN, chptr->chname);
else
do_settopic(sptr,cptr,chptr,topic,0);
}
return 0;
}
int modey_is_ok(aClient *sptr, aChannel *chptr, char *para, int checkt, int what)
{
short t;
if ((checkt == EXCHK_ACCESS) || (checkt == EXCHK_ACCESS_ERR))
{
if (!is_chan_op(sptr, chptr))
{
if (checkt == EXCHK_ACCESS_ERR)
sendto_one(sptr, err_str(ERR_CHANOPRIVSNEEDED), me.name, sptr->name, chptr->chname);
return 0;
} else {
return 1;
}
} else
if (checkt == EXCHK_PARAM)
{
t = (short)atoi(para);
if ((t < 0) || (t > 100))
{
sendto_one(sptr, ":%s NOTICE %s :chanmode +y requires a parameter in the range 0..100",
me.name, sptr->name);
return 0;
}
return 1;
}
return 0;
}
DLLFUNC char *restrictcolors_checkmsg(aClient *cptr, aClient *sptr, aChannel *chptr, char *text, int notice)
{
if (IsULine(sptr) || IsServer(sptr))
return text;
if (chptr->mode.extmode && RESTRICT_COLORS && !is_chan_op(sptr, chptr) && !is_halfop(sptr, chptr))
return StripColors(text);
return text;
}
static int has_common_channels(aClient *c1, aClient *c2)
{
Membership *lp;
for (lp = c1->user->channel; lp; lp = lp->next)
{
if (IsMember(c2, lp->chptr))
{
if (c1 == c2)
return 1;
/* We must ensure that c1 is allowed to "see" c2 */
if ((lp->chptr->mode.mode & MODE_AUDITORIUM) &&
!is_chan_op(c2, lp->chptr) && !is_chan_op(c1, lp->chptr))
break;
return 1;
}
}
return 0;
}
static void do_who(struct Client *sptr,
struct Client *acptr,
struct Channel *repchan,
Link *lp)
{
char status[5];
/* Using a pointer will compile faster than an index */
char *p = status;
if (acptr->user->away)
*p++ = 'G';
else
*p++ = 'H';
if (HasUmode(acptr,UMODE_OPER)
&& SeesOpers(sptr)
)
*p++ = '*';
if ((repchan != NULL) && (lp == NULL))
lp = find_user_link(repchan->members, acptr);
if (lp != NULL)
{
#ifdef HIDE_OPS
if(is_chan_op(sptr,repchan))
#endif
{
if (lp->flags & CHFL_CHANOP)
*p++ = '@';
else if (lp->flags & CHFL_VOICE)
*p++ = '+';
}
}
*p = '\0';
sendto_one(sptr, form_str(RPL_WHOREPLY), me.name, sptr->name,
(repchan) ? (repchan->chname) : "*",
acptr->username,
acptr->host,
#ifdef SERVERHIDE
HasUmode(sptr,UMODE_AUSPEX) ? acptr->user->server : NETWORK_NAME,
#else
acptr->user->server,
#endif
acptr->name,
status,
HasUmode(sptr,UMODE_SEEROUTING) ? acptr->hopcount : 0,
acptr->info);
}
void cmd_topic(t_message *msg, t_client *client, t_chan *chans)
{
t_chan *channel;
if (is_topic_valid(msg, client, chans) == true)
{
channel = find_chan(chans, msg->params[0]);
if (is_chan_op(client, channel) == false)
dprintf(client->client, ERR_CHANOPRIVSNEEDED, S_NAME, S_ADDR,
client->nick, msg->params[0]);
else
{
if (get_nb_params(msg->params) == 1)
display_topic(client, channel);
else
set_topic(msg, client, channel);
}
}
}
/*
* The function that actually prints out the WHO reply for a client found
*/
void do_who(struct Client* sptr, struct Client* acptr, struct Channel* repchan,
int fields, char* qrt)
{
char *p1;
struct Channel *chptr = repchan;
static char buf1[512];
/* NOTE: with current fields list and sizes this _cannot_ overrun,
and also the message finally sent shouldn't ever be truncated */
p1 = buf1;
buf1[1] = '\0';
/* If we don't have a channel and we need one... try to find it,
unless the listing is for a channel service, we already know
that there are no common channels, thus use PubChannel and not
SeeChannel */
if (!chptr && (!fields || (fields & (WHO_FIELD_CHA | WHO_FIELD_FLA))) &&
!IsChannelService(acptr))
{
struct Membership* chan;
for (chan = cli_user(acptr)->channel; chan && !chptr; chan = chan->next_channel)
if (PubChannel(chan->channel) &&
(acptr == sptr || !IsZombie(chan)))
chptr = chan->channel;
}
/* Place the fields one by one in the buffer and send it
note that fields == NULL means "default query" */
if (fields & WHO_FIELD_QTY) /* Query type */
{
*(p1++) = ' ';
if (BadPtr(qrt))
*(p1++) = '0';
else
while ((*qrt) && (*(p1++) = *(qrt++)));
}
if (!fields || (fields & WHO_FIELD_CHA))
{
char *p2;
*(p1++) = ' ';
if ((p2 = (chptr ? chptr->chname : NULL)))
while ((*p2) && (*(p1++) = *(p2++)));
else
*(p1++) = '*';
}
if (!fields || (fields & WHO_FIELD_UID))
{
char *p2 = cli_user(acptr)->username;
*(p1++) = ' ';
while ((*p2) && (*(p1++) = *(p2++)));
}
if (fields & WHO_FIELD_NIP)
{
const char* p2 = IsHiddenHost(acptr) && (!IsViewip(sptr) && acptr != sptr) ?
feature_str(FEAT_HIDDEN_IP) :
ircd_ntoa((const char*) &(cli_ip(acptr)));
*(p1++) = ' ';
while ((*p2) && (*(p1++) = *(p2++)));
}
if (!fields || (fields & WHO_FIELD_HOS))
{
char *p2 = (IsViewip(sptr) || acptr == sptr) ? get_realhost(acptr) : get_virtualhost(acptr);
*(p1++) = ' ';
while ((*p2) && (*(p1++) = *(p2++)));
}
if (!fields || (fields & WHO_FIELD_SER))
{
char *p2;
int haspriv = IsAnOper(sptr) || es_representante(sptr);
if (IsMe(cli_user(acptr)->server))
{
if ((sptr != acptr) && feature_bool(FEAT_HIS_WHO_SERVERNAME) && !haspriv)
p2 = (char *)feature_str(FEAT_HIS_SERVERNAME);
else
p2 = cli_name(&me);
}
else
{
if (IsHiddenserv(cli_user(acptr)->server) && !haspriv)
p2 = (char *)feature_str(FEAT_HIS_SERVERNAME);
else
p2 = cli_name(cli_user(acptr)->server);
}
*(p1++) = ' ';
while ((*p2) && (*(p1++) = *(p2++)));
}
if (!fields || (fields & WHO_FIELD_NIC))
{
char *p2 = cli_name(acptr);
*(p1++) = ' ';
while ((*p2) && (*(p1++) = *(p2++)));
}
if (!fields || (fields & WHO_FIELD_FLA))
{
*(p1++) = ' ';
if (cli_user(acptr)->away)
*(p1++) = 'G';
else
*(p1++) = 'H';
if ((IsAnOper(acptr) || es_representante(acptr) || IsPreoper(acptr))/* &&
(HasPriv(acptr, PRIV_DISPLAY) || HasPriv(sptr, PRIV_SEE_OPERS))*/)
*(p1++) = '*';
if (fields) {
/* If you specified flags then we assume you know how to parse
* multiple channel status flags, as this is currently the only
* way to know if someone has @'s *and* is +'d.
*/
if (chptr && is_chan_op(acptr, chptr))
*(p1++) = '@';
if (chptr && has_voice(acptr, chptr))
*(p1++) = '+';
if (chptr && is_chan_halfop(acptr, chptr))
*(p1++) = '%';
if (chptr && is_chan_owner(acptr, chptr))
*(p1++) = '.';
if (chptr && is_zombie(acptr, chptr))
*(p1++) = '!';
}
else {
if (chptr && is_chan_op(acptr, chptr))
*(p1++) = '@';
else if (chptr && has_voice(acptr, chptr))
*(p1++) = '+';
else if (chptr && is_zombie(acptr, chptr))
*(p1++) = '!';
else if (chptr && is_chan_halfop(acptr, chptr))
*(p1++) = '%';
else if (chptr && is_chan_owner(acptr, chptr))
*(p1++) = '.';
}
if (IsDeaf(acptr))
*(p1++) = 'd';
if (IsAnOper(sptr))
{
if (IsInvisible(acptr))
*(p1++) = 'i';
if (SendWallops(acptr))
*(p1++) = 'w';
if (SendDebug(acptr))
*(p1++) = 'g';
}
if (HasHiddenHost(acptr))
*(p1++) = 'x';
if (IsAnOper(acptr))
*(p1++) = 'o';
if (IsPreoper(acptr))
*(p1++) = 'p';
if (IsHelpOp(acptr))
*(p1++) = 'h';
if (IsCoadmin(acptr))
*(p1++) = 'a';
if (IsAdmin(acptr))
*(p1++) = 'A';
if (IsDevel(acptr))
*(p1++) = 'D';
if (IsViewip(acptr))
*(p1++) = 'X';
}
if (!fields || (fields & WHO_FIELD_DIS))
{
*p1++ = ' ';
if (!fields)
*p1++ = ':'; /* Place colon here for default reply */
if (feature_bool(FEAT_HIS_WHO_HOPCOUNT) && !IsAnOper(sptr))
*p1++ = (sptr == acptr) ? '0' : '3';
else
/* three digit hopcount maximum */
p1 += ircd_snprintf(0, p1, 3, "%d", cli_hopcount(acptr));
}
if (fields & WHO_FIELD_IDL)
{
*p1++ = ' ';
if (MyUser(acptr)) {
p1 += ircd_snprintf(0, p1, 11, "%d",
CurrentTime - cli_user(acptr)->last);
}
else {
*p1++ = '0';
}
}
if (!fields || (fields & WHO_FIELD_REN))
{
char *p2 = cli_info(acptr);
*p1++ = ' ';
if (fields)
*p1++ = ':'; /* Place colon here for special reply */
while ((*p2) && (*(p1++) = *(p2++)));
}
if (fields & WHO_FIELD_ACC)
{
char *p2 = cli_user(acptr)->account;
*(p1++) = ' ';
while ((*p2) && (*(p1++) = *(p2++)));
}
/* The first char will always be an useless blank and we
need to terminate buf1 */
*p1 = '\0';
p1 = buf1;
send_reply(sptr, fields ? RPL_WHOSPCRPL : RPL_WHOREPLY, ++p1);
}
/*
* ms_svshost - SVSHOST command handler
* parv[0] = sender prefix
* parv[1] = remote server
* parv[2] = client nick
* parv[3] = vhost to spoof
*/
static void ms_svshost(struct Client* client_p, struct Client* source_p,
int parc, char* parv[])
{
char *flag;
struct Client *victim;
struct Channel *chptr, *top_chptr, *banchans[100];
static char comment[] = "Spoofing with vhost...";
static char urbanned[] = "You are banned";
char modebuf[MODEBUFLEN], parabuf[MODEBUFLEN];
int hide_or_not;
dlink_node *ptr;
int i, num = 0;
if (ServerInfo.gateway && get_bridge_token(client_p))
return;
if (hunt_server(client_p, source_p, ":%s SVSHOST %s %s :%s",
1, parc, parv) != HUNTED_ISME)
return;
if (!find_z_conf(parv[0]))
return;
victim = find_client(parv[2]);
if (victim && !IsServer(victim) && MyConnect(victim))
{
extern int introduce_client(struct Client *, struct Client *,
struct User *, char *);
sendto_server(NULL, victim, NULL, NOCAPS, NOCAPS,
NOFLAGS, ":%s QUIT :%s", victim->name, comment);
/* sendto_common_channels_local(victim, ":%s!%s@%s QUIT :%s",
victim->name, victim->username, victim->host, comment);*/
/* ++current_serial; not needed i suppose */
if (victim->user->channel.head)
for (ptr = victim->user->channel.head; ptr; ptr = ptr->next) {
chptr = (struct Channel *)ptr->data;
sendto_channel_local_butone(victim, ALL_MEMBERS,
chptr, ":%s!%s@%s QUIT :%s",
victim->name, victim->username,
victim->host, comment);
}
strncpy(victim->host, parv[3], HOSTLEN)[HOSTLEN] = 0;
sendto_one(victim, ":%s NOTICE %s :*** Notice -- Spoofing your host as %s",
me.name, victim->name, victim->host);
if (victim->user->channel.head)
for (ptr = victim->user->channel.head; ptr; ptr = ptr->next) {
chptr = (struct Channel *)ptr->data;
#ifdef VCHANS
top_chptr = RootChan(chptr);
#else
top_chptr = chptr;
#endif
if (is_banned(chptr, victim) & (CHFL_BAN|CHFL_DENY)) {
sendto_one(victim, ":%s KICK %s %s :%s",
me.name, top_chptr->chname, victim->name,
urbanned);
/*remove_user_from_channel(chptr, victim);*/
banchans[num++] = chptr;
continue;
}
if (is_chan_op(chptr, victim))
flag = "+o";
#ifdef HALFOPS
else if (is_half_op(chptr, victim))
flag = "+h";
#endif
else if (is_voiced(chptr, victim))
flag = "+v";
else flag = "";
#ifdef REQUIRE_OANDV
if (find_user_link(&chptr->chanops_voiced, victim))
flag = "+ov";
#endif
sendto_channel_local_butone(victim, ALL_MEMBERS,
chptr, ":%s!%s@%s JOIN :%s",
victim->name, victim->username,
victim->host, top_chptr->chname);
#ifdef ANONOPS
if (chptr->mode.mode & MODE_HIDEOPS)
hide_or_not = ONLY_CHANOPS_HALFOPS;
else
#endif
hide_or_not = ALL_MEMBERS;
if (flag[0])
sendto_channel_local_butone(victim, hide_or_not,
chptr, ":%s MODE %s %s %s %s",
me.name, top_chptr->chname, flag,
victim->name, flag[2]? victim->name : "");
}
for (i=0; i < num; i++)
remove_user_from_channel(banchans[i], victim);
introduce_client(NULL, victim, victim->user, victim->name);
victim->lazyLinkClientExists = 0; /* force introducing to LL servers below... */
if (victim->user->channel.head)
for (ptr = victim->user->channel.head; ptr; ptr = ptr->next) {
chptr = (struct Channel *)ptr->data;
if (is_chan_op(chptr, victim))
flag = "@";
#ifdef HALFOPS
else if (is_half_op(chptr, victim))
flag = "%";
#endif
else if (is_voiced(chptr, victim))
flag = "+";
else flag = "";
#ifdef REQUIRE_OANDV
if (find_user_link(&chptr->chanops_voiced, victim))
flag = "@+";
#endif
channel_modes(chptr, victim, modebuf, parabuf);
sendto_server(NULL, victim, chptr, NOCAPS, NOCAPS,
LL_ICLIENT|LL_ICHAN, ":%s SJOIN %lu %s %s %s :%s%s",
me.name, (unsigned long)chptr->channelts,
chptr->chname, modebuf, parabuf,
flag, victim->name);
}
}
}
static int m_message(struct Client *cptr,
struct Client *sptr,
int parc,
char *parv[],
int notice)
{
struct Client *acptr;
#ifdef NEED_TLD_FOR_MASS_NOTICE
char *s;
#endif
struct Channel *chptr;
char *nick, *server, *host;
char errbuf[BUFSIZE];
const char *cmd;
int type=0, msgs=0;
#ifdef FLUD
int flud;
#endif
cmd = notice ? MSG_NOTICE : MSG_PRIVATE;
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(sptr, form_str(ERR_NORECIPIENT),
me.name, parv[0], cmd);
return -1;
}
if (parc < 3 || *parv[2] == '\0')
{
sendto_one(sptr, form_str(ERR_NOTEXTTOSEND), me.name, parv[0]);
return -1;
}
if (MyConnect(sptr))
{
#ifdef ANTI_SPAMBOT
#ifndef ANTI_SPAMBOT_WARN_ONLY
/* if its a spambot, just ignore it */
if(sptr->join_leave_count >= MAX_JOIN_LEAVE_COUNT)
return 0;
#endif
#endif
#ifdef NO_DUPE_MULTI_MESSAGES
if (strchr(parv[1],','))
parv[1] = canonize(parv[1]);
#endif
}
/*
** channels are privmsg'd a lot more than other clients, moved up here
** plain old channel msg ?
*/
while(msgs < MAX_MULTI_MESSAGES)
{
if(!msgs)
nick = strtok(parv[1], ",");
else
nick = strtok(NULL, ",");
if(!nick && msgs == 0)
nick = parv[1];
else if(!nick)
break;
if( IsChanPrefix(*nick)
&& (IsPerson(sptr) && (chptr = hash_find_channel(nick, NullChn))))
{
#ifdef FLUD
#ifdef DEATHFLUD
if(!notice && check_for_ctcp(parv[2])
&& check_for_flud(sptr, NULL, chptr, 1))
return 0;
if((flud = check_for_spam(sptr, NULL, chptr, parv[2])))
{
if (check_for_flud(sptr, NULL, chptr, flud))
return 0;
}
#else /* DEATHFLUD */
if(!notice)
if(check_for_ctcp(parv[2]))
check_for_flud(sptr, NULL, chptr, 1);
#endif /* DEATHFLUD */
#endif /* FLUD */
/*
* Channel color blocking. Usually set with the +c chanmode.
* - Andre Guibert de Bruet <*****@*****.**>
*/
if(chptr->mode.mode & MODE_NOCOLOR)
strip_colour(parv[2]);
switch (can_send(sptr, chptr))
{
case 0:
sendto_channel_message_butone(cptr, sptr, chptr, cmd, parv[2]);
break;
case MODE_QUIETUNIDENT:
if (!notice)
sendto_one(sptr, form_str(ERR_QUIETUNIDENT),
me.name, parv[0], nick);
break;
case MODE_MODERATED:
if (chptr->mode.mode & MODE_OPMODERATE)
{
/* The flag MODE_OPMODERATE will instruct sendto_channel_type()
* to put bare #channel in the message (instead of @#channel);
* it will still be sent to ops and servers with ops only.
* Strange things will happen if the user is not banned
* remotely.
* -- jilles
*/
sendto_channel_type(cptr, sptr, chptr,
MODE_CHANOP | MODE_OPMODERATE, nick, cmd,
parv[2]);
}
else
{
if (!notice)
sendto_one(sptr, form_str(ERR_CANNOTSENDTOCHAN),
me.name, parv[0], nick);
}
break;
default:
break;
}
msgs++;
continue;
}
/*
** @# type of channel msg?
*/
if(*nick == '@')
type = MODE_CHANOP;
else if(*nick == '+')
type = MODE_CHANOP|MODE_VOICE;
if(type)
{
/* Strip if using DALnet chanop/voice prefix. */
if (*(nick+1) == '@' || *(nick+1) == '+')
{
nick++;
*nick = '@';
type = MODE_CHANOP|MODE_VOICE;
}
/* suggested by Mortiis */
if(!*nick) /* if its a '\0' dump it, there is no recipient */
{
sendto_one(sptr, form_str(ERR_NORECIPIENT),
me.name, parv[0], cmd);
return -1;
}
if (!IsPerson(sptr)) /* This means, servers can't send messages */
return -1;
/* At this point, nick+1 should be a channel name i.e. #foo or &foo
* if the channel is found, fine, if not report an error
*/
if ( (chptr = hash_find_channel(nick+1, NullChn)) )
{
#ifdef FLUD
#ifdef DEATHFLUD
if(!notice && check_for_ctcp(parv[2])
&& check_for_flud(sptr, NULL, chptr, 1))
return 0;
if((flud = check_for_spam(sptr, NULL, chptr, parv[2])))
{
if (check_for_flud(sptr, NULL, chptr, flud))
return 0;
}
#else /* DEATHFLUD */
if(!notice)
if(check_for_ctcp(parv[2]))
check_for_flud(sptr, NULL, chptr, 1);
#endif /* DEATHFLUD */
#endif /* FLUD */
if (!is_chan_op(sptr,chptr))
{
if (!notice)
{
sendto_one(sptr, form_str(ERR_CANNOTSENDTOCHAN),
me.name, parv[0], nick);
}
msgs++;
continue;
}
else
{
sendto_channel_type(cptr,
sptr,
chptr,
type,
nick+1,
cmd,
parv[2]);
}
}
else
{
if (!IsServer(sptr))
sendto_one(sptr, form_str(ERR_NOSUCHNICK),
me.name, parv[0], nick);
msgs++;
continue;
}
return 0;
}
/*
** nickname addressed?
*/
if ((acptr = find_person(nick, NULL)))
{
#ifdef FLUD
#ifdef DEATHFLUD
if(!notice && MyConnect(sptr) && check_for_ctcp(parv[2])
&& check_for_flud(sptr, acptr, NULL, 1))
return 0;
if(MyConnect(sptr) && (flud = check_for_spam(sptr, acptr, NULL, parv[2])))
{
if (check_for_flud(sptr, acptr, NULL, flud))
return 0;
}
#else /* DEATHFLUD */
if(!notice && MyConnect(sptr))
if(check_for_ctcp(parv[2]))
if(check_for_flud(sptr, acptr, NULL, 1))
return 0;
#endif /* DEATHFLUD */
#endif /* FLUD */
#ifdef ANTI_DRONE_FLOOD
if(MyConnect(acptr) && IsClient(sptr) && !NoFloodProtection(sptr) && DRONETIME)
{
if((acptr->first_received_message_time+DRONETIME) < CurrentTime)
{
acptr->received_number_of_privmsgs=1;
acptr->first_received_message_time = CurrentTime;
acptr->drone_noticed = 0;
}
else
{
if(acptr->received_number_of_privmsgs > DRONECOUNT)
{
if(acptr->drone_noticed == 0) /* tiny FSM */
{
sendto_ops_flag(UMODE_BOTS,
"Possible Drone Flooder %s [%s@%s] on %s target: %s",
sptr->name, sptr->username,
sptr->host,
sptr->user->server, acptr->name);
acptr->drone_noticed = 1;
}
/* heuristic here, if target has been getting a lot
* of privmsgs from clients, and sendq is above halfway up
* its allowed sendq, then throw away the privmsg, otherwise
* let it through. This adds some protection, yet doesn't
* DOS the client.
* -Dianora
*/
if(DBufLength(&acptr->sendQ) > (get_sendq(acptr)/2UL))
{
if(acptr->drone_noticed == 1) /* tiny FSM */
{
sendto_ops_flag(UMODE_BOTS,
"ANTI_DRONE_FLOOD SendQ protection activated for %s",
acptr->name);
sendto_one(acptr,
":%s NOTICE %s :*** Notice -- Server drone flood protection activated for %s",
me.name, acptr->name, acptr->name);
acptr->drone_noticed = 2;
}
}
if(DBufLength(&acptr->sendQ) <= (get_sendq(acptr)/4UL))
{
if(acptr->drone_noticed == 2)
{
sendto_one(acptr,
":%s NOTICE %s :*** Notice -- Server drone flood protection de-activated for %s",
me.name, acptr->name, acptr->name);
acptr->drone_noticed = 1;
}
}
if(acptr->drone_noticed > 1)
return 0;
}
else
acptr->received_number_of_privmsgs++;
}
}
#endif
/*
* Simple herustic here... If PRIVMSG is locked down via
* F:noidprivmsg:1, then act like every client is +E.
* Otherwise, assume the normal behaviour. All in a nice
* single if statement. --nenolod
*/
if (MyClient(sptr) && sptr != acptr &&
(GlobalSetOptions.noidprivmsg != 0 ||
HasUmode(acptr,UMODE_BLOCK_NOTID))
&& !HasUmode(sptr,UMODE_IDENTIFIED)
&& !sptr->user->servlogin[0]
&& !HasUmode(acptr,UMODE_DONTBLOCK)
&& !HasUmode(sptr,UMODE_DONTBLOCK))
{
/* Replace errbuf with either the default or custom message,
* then send the numeric on...
* --nenolod
*/
if (GlobalSetOptions.noidprivmsg != 0 &&
GlobalSetOptions.noidprivmsg_notice[0])
{
strncpy_irc(errbuf, GlobalSetOptions.noidprivmsg_notice, BUFSIZE);
}
else
{
ircsnprintf(errbuf, BUFSIZE, get_str(STR_NOTID_DEFAULT),
nick);
}
sendto_one(sptr, form_str(ERR_BLOCKING_NOTID),
me.name, parv[0], errbuf);
return 0;
}
#ifdef SILENCE
/* only check silence masks at the recipient's server -- jilles */
if (!MyConnect(acptr) || !is_silenced(sptr, acptr)) {
#endif
if (MyConnect(sptr) && acptr->user && (sptr != acptr))
{
#ifdef NCTCP
/* NCTCP (umode +C) checks -- PMA */
if (parv[2][0] == 1) /* is CTCP */
/* Huh? No way, NOCTCP means NOCTCP. */
/* if (!HasUmode(sptr,UMODE_IMMUNE) && */
/* !HasUmode(acptr,UMODE_IMMUNE)) */
if (HasUmode(acptr,UMODE_NOCTCP) || /* block to +C */
(notice && HasUmode(sptr,UMODE_NOCTCP))) /* block replies from +C */
return 0; /* kill it! */
#endif /* NCTCP */
if (!notice && acptr->user->away)
sendto_one(sptr, form_str(RPL_AWAY), me.name,
parv[0], acptr->name,
acptr->user->away);
}
{
/* here's where we actually send the message */
int is_ctcp = check_for_ctcp(parv[2]);
int cap = is_ctcp ? CAP_IDENTIFY_CTCP : CAP_IDENTIFY_MSG;
sendto_prefix_one(acptr, sptr, ":%s %s %s :%s%s",
parv[0], cmd, nick,
!(acptr->caps & cap) ? "" :
(HasUmode(sptr, UMODE_IDENTIFIED) ? "+" : "-"),
parv[2]);
}
#ifdef SILENCE
}
#endif
msgs++;
continue;
}
/* Everything below here should be reserved for opers
* as pointed out by Mortiis, user%[email protected]
* syntax could be used to flood without FLUD protection
* its also a delightful way for non-opers to find users who
* have changed nicks -Dianora
*
* Grrr it was pointed out to me that x@service is valid
* for non-opers too, and wouldn't allow for flooding/stalking
* -Dianora
*
* Valid or not, @servername is unacceptable, it reveals what server
* a person is on. Auspexen only.
* -- asuffield
*/
/*
** the following two cases allow masks in NOTICEs
** (for OPERs only) (with +M -- asuffield)
**
** Armin, 8Jun90 ([email protected])
*/
if ((*nick == '$' || *nick == '>'))
{
if(!HasUmode(sptr,UMODE_MASSNOTICE))
{
sendto_one(sptr, form_str(ERR_NOSUCHNICK),
me.name, parv[0], nick);
return -1;
}
#ifdef NEED_TLD_FOR_MASS_NOTICE
if (!(s = (char *)strrchr(nick, '.')))
{
sendto_one(sptr, form_str(ERR_NOTOPLEVEL),
me.name, parv[0], nick);
msgs++;
continue;
}
while (*++s)
if (*s == '.' || *s == '*' || *s == '?')
break;
if (*s == '*' || *s == '?')
{
sendto_one(sptr, form_str(ERR_WILDTOPLEVEL),
me.name, parv[0], nick);
msgs++;
continue;
}
#endif /* NEED_TLD_FOR_MASS_NOTICE */
sendto_match_butone(IsServer(cptr) ? cptr : NULL,
sptr, nick + 1,
(*nick == '>') ? MATCH_HOST :
MATCH_SERVER,
":%s %s %s :%s", parv[0],
cmd, nick, parv[2]);
msgs++;
continue;
}
/*
** user[%host]@server addressed?
*/
if ((server = (char *)strchr(nick, '@')) &&
(acptr = find_server(server + 1)))
{
int count = 0;
/* Disable the whole farping mess for non-auspexen
* -- asuffield
*/
if (!HasUmode(sptr,UMODE_AUSPEX))
{
sendto_one(sptr, form_str(ERR_NOSUCHNICK),
me.name, parv[0], nick);
msgs++;
continue;
}
/* Disable the user%host@server form for non-opers
* -Dianora
*/
/* Disabled. This isn't very useful and I don't feel like mucking around with privs for it
* -- asuffield */
if((char *)strchr(nick,'%'))
{
sendto_one(sptr, form_str(ERR_NOSUCHNICK),
me.name, parv[0], nick);
msgs++;
continue;
}
/*
** Not destined for a user on me :-(
*/
if (!IsMe(acptr))
{
sendto_one(acptr,":%s %s %s :%s", parv[0],
cmd, nick, parv[2]);
msgs++;
continue;
}
*server = '\0';
/* special case opers@server */
/* We don't want this on OPN -- asuffield */
#if 0
if(!irccmp(nick,"opers") && SendWallops(sptr))
{
sendto_realops("To opers: From %s: %s",sptr->name,parv[2]);
msgs++;
continue;
}
#endif
if ((host = (char *)strchr(nick, '%')))
*host++ = '\0';
/*
** Look for users which match the destination host
** (no host == wildcard) and if one and one only is
** found connected to me, deliver message!
*/
acptr = find_userhost(nick, host, NULL, &count);
if (server)
*server = '@';
if (host)
*--host = '%';
if (acptr)
{
if (count == 1)
sendto_prefix_one(acptr, sptr,
":%s %s %s :%s",
parv[0], cmd,
nick, parv[2]);
else if (!notice)
sendto_one(sptr,
form_str(ERR_TOOMANYTARGETS),
me.name, parv[0], nick, MAX_MULTI_MESSAGES);
}
if (acptr)
{
msgs++;
continue;
}
}
/* Let's not send these remotely for channels */
if (MyConnect(sptr) || (nick[0] != '#'))
sendto_one(sptr, form_str(ERR_NOSUCHNICK), me.name,
parv[0], nick);
msgs++;
}
if (strtok(NULL, ","))
sendto_one(sptr, form_str(ERR_TOOMANYTARGETS),
me.name, parv[0], cmd, MAX_MULTI_MESSAGES);
return 0;
}
/*
* msg_channel
*
* inputs - flag privmsg or notice
* - pointer to command "PRIVMSG" or "NOTICE"
* - pointer to client_p
* - pointer to source_p
* - pointer to channel
* output - NONE
* side effects - message given channel
*/
static void
msg_channel(int p_or_n, char *command,
struct Client *client_p,
struct Client *source_p, struct Channel *chptr, char *text)
{
struct Channel *vchan = NULL;
char *chname = NULL;
int result;
chname = RootChan(chptr)->chname;
#ifdef VCHANS
if (HasVchans(chptr))
vchan = map_vchan(chptr, source_p);
#endif
if (!vchan)
vchan = chptr;
if (MyClient(source_p))
{
/* idle time shouldnt be reset by notices --fl */
if ((p_or_n != NOTICE) && source_p->user)
source_p->user->last = CurrentTime;
}
/* chanops and voiced can flood their own channel with impunity */
if ((result = can_send(vchan, source_p)))
{
if (result == CAN_SEND_NOTREG)
{
if (p_or_n != NOTICE)
sendto_one(source_p, form_str(source_p,ERR_CANNOTSENDNOTREG),
me.name, source_p->name, chname);
return;
}
if (result == CAN_SEND_OPV ||
!flood_attack_channel(p_or_n, source_p, vchan, chname))
{
dlink_node *ptr;
struct Ban *banptr;
char strbuf[BUFSIZE+1], buf[TOPICLEN+1];
char *word, *subst, *p = buf;
int drop = 0;
if (MyClient(source_p) && IsPerson(source_p))
if (!is_chan_op(vchan, source_p) && NoRepeatChannel(vchan))
if (check_repeat(source_p, vchan, text)) {
sendto_one(source_p, form_str(source_p,ERR_NOREPEATING),
me.name, source_p->name, chname);
return;
}
if (NoColorChannel(vchan))
/*strip_color(text);*/
text = strip_color(text, 0);
strncpy(strbuf, text, BUFSIZE)[BUFSIZE] = 0;
if (MyClient(source_p) && IsPerson(source_p))
if (!is_chan_op(vchan, source_p))
for (ptr = vchan->substlist.head; ptr; ptr = ptr->next, p = buf) {
banptr = ptr->data;
strncpy(buf, banptr->banstr, TOPICLEN)[TOPICLEN] = 0;
while (*p)
if (*p++ == '$')
*(p-1) = ' ';
subst = strchr(buf, '/'); if (subst) {
*subst++ = 0; word = buf;
if (strstr(strbuf, word) && !irccmp(subst, "&"))
drop = 1;
replace(strbuf, word, subst, BUFSIZE);
strbuf[BUFSIZE] = 0;
}
}
if (!drop) {
if (PaceChannel(vchan) && (vchan->msgs < MAX_PACEMSG))
add_pace_msg(vchan, client_p, source_p, command, strbuf);
else
sendto_channel_butone(client_p, source_p, vchan, command, ":%s", strbuf);
}
}
}
else
{
if (p_or_n != NOTICE)
sendto_one(source_p, form_str(source_p,ERR_CANNOTSENDTOCHAN),
me.name, source_p->name, chname);
}
}
static int can_see(aClient *sptr, aClient *acptr, aChannel *channel)
{
int ret = 0;
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 (!IsAnOper(acptr))
return ret | WHO_CANTSEE;
if (IsHideOper(acptr)) {
if (IsAnOper(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 (IsAnOper(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->user->ip_str;
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 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) || (!IsAnOper(sptr) && (acptr->umodes & UMODE_HIDEOPER)))
return WHO_CANTSEE;
}
if (wfl.umodes_dontwant)
{
if ((acptr->umodes & wfl.umodes_dontwant) && (!(acptr->umodes & UMODE_HIDEOPER) || IsAnOper(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 ((channel->mode.mode & MODE_AUDITORIUM) &&
!is_chan_op(acptr, channel) && !is_chan_op(sptr, channel))
break;
}
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 (IsAnOper(sptr))
return ret | WHO_OPERSEE | WHO_CANSEE;
else
{
if (sptr == acptr)
return ret | WHO_CANSEE;
else
return ret | WHO_CANTSEE;
}
}
/*
* m_topic
* parv[0] = sender prefix
* parv[1] = channel name
* parv[2] = new topic, if setting topic
*/
static void
m_topic(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
struct Channel *chptr = NULL;
char *p = NULL;
if((p = strchr(parv[1], ',')))
*p = '\0';
if(MyClient(source_p) && !IsFloodDone(source_p))
flood_endgrace(source_p);
if(parv[1] && IsChannelName(parv[1]))
{
chptr = hash_find_channel(parv[1]);
if(chptr == NULL)
{
sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
me.name, parv[0], parv[1]);
return;
}
/* setting topic */
if(parc > 2)
{
if(!IsMember(source_p, chptr))
{
sendto_one(source_p, form_str(ERR_NOTONCHANNEL), me.name, parv[0],
parv[1]);
return;
}
if((chptr->mode.mode & MODE_TOPICLIMIT) == 0 || is_chan_op(chptr, source_p))
{
char topic_info[USERHOST_REPLYLEN];
ircsprintf(topic_info, "%s!%s@%s",
source_p->name, source_p->username, source_p->host);
set_channel_topic(chptr, parv[2], topic_info, CurrentTime);
sendto_server(client_p, chptr, NOCAPS, NOCAPS,
":%s TOPIC %s :%s",
parv[0], chptr->chname,
chptr->topic == NULL ? "" : chptr->topic);
sendto_channel_local(ALL_MEMBERS,
chptr, ":%s!%s@%s TOPIC %s :%s",
source_p->name, source_p->username,
source_p->host, chptr->chname,
chptr->topic == NULL ? "" : chptr->topic);
}
else
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name, parv[0], parv[1]);
}
else /* only asking for topic */
{
if(!IsMember(source_p, chptr) && SecretChannel(chptr))
{
sendto_one(source_p, form_str(ERR_NOTONCHANNEL), me.name, parv[0],
parv[1]);
return;
}
if(chptr->topic == NULL)
sendto_one(source_p, form_str(RPL_NOTOPIC),
me.name, parv[0], parv[1]);
else
{
sendto_one(source_p, form_str(RPL_TOPIC),
me.name, parv[0], chptr->chname, chptr->topic);
sendto_one(source_p, form_str(RPL_TOPICWHOTIME),
me.name, parv[0], chptr->chname,
chptr->topic_info, chptr->topic_time);
}
}
}
else
{
sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL), me.name, parv[0], parv[1]);
}
}
/*
** m_whois
** parv[0] = sender prefix
** parv[1] = nickname masklist
*/
int m_whois(struct Client *cptr,
struct Client *sptr,
int parc,
char *parv[])
{
static anUser UnknownUser =
{
NULL, /* next */
NULL, /* channel */
NULL, /* invited */
NULL, /* silence */
NULL, /* away */
0, /* last */
1, /* refcount */
0, /* joined */
"<Unknown>" /* server */
};
static char rpl_oper[] = "an IRC Operator";
static char rpl_locop[] = "an IRC Operator - Local IRC Operator";
static char rpl_sadmin[] = "an IRC Operator - Services Administrator";
static char rpl_admin[] = "an IRC Operator - Server Administrator";
static char rpl_tadmin[] = "an IRC Operator - Technical Administrator";
static char rpl_nadmin[] = "an IRC Operator - Network Administrator";
Link *lp;
anUser *user;
struct Client *acptr, *a2cptr;
aChannel *chptr;
char *nick, *name;
/* char *tmp; */
char *p = NULL;
int found, len, mlen;
static time_t last_used=0L;
char *nick_match=NULL, *user_match=NULL, *host_match=NULL, *server_match=NULL;
char *name_match=NULL;
int found_mode;
int hits = 0;
char *mename = me.name;
if(sptr->user && sptr->user->vlink)
mename = sptr->user->vlink->name;
if (parc < 2)
{
sendto_one(sptr, form_str(ERR_NONICKNAMEGIVEN),
mename, parv[0]);
return 0;
}
if(parc > 2)
{
if (hunt_server(cptr,sptr,":%s WHOIS %s :%s", 1,parc,parv) !=
HUNTED_ISME)
return 0;
parv[1] = parv[2];
}
if(!IsAnOper(sptr) && !MyConnect(sptr)) /* pace non local requests */
{
if((last_used + WHOIS_WAIT) > CurrentTime)
{
/* Unfortunately, returning anything to a non local
* request =might= increase sendq to be usable in a split hack
* Sorry gang ;-( - Dianora
*/
return 0;
}
else
{
last_used = CurrentTime;
}
}
/* Multiple whois from remote hosts, can be used
* to flood a server off. One could argue that multiple whois on
* local server could remain. Lets think about that, for now
* removing it totally.
* -Dianora
*/
/* for (tmp = parv[1]; (nick = strtoken(&p, tmp, ",")); tmp = NULL) */
nick = parv[1];
p = strchr(parv[1],',');
if(p)
*p = '\0';
{
int invis, member, wilds;
found = 0;
(void)collapse(nick);
wilds = (nick[0]=='$' || strchr(nick, '?') || strchr(nick, '*'));
/*
** We're no longer allowing remote users to generate
** requests with wildcards.
*/
if (wilds && !IsAnOper(sptr))
{
sendto_one(sptr, form_str(ERR_NOSUCHNICK),
mename, parv[0], nick);
return 0;
}
/* continue; */
/* If the nick doesn't have any wild cards in it,
* then just pick it up from the hash table
* - Dianora
*/
if(!wilds)
{
acptr = hash_find_client(nick,(struct Client *)NULL);
if(!acptr)
{
sendto_one(sptr, form_str(ERR_NOSUCHNICK),
mename, parv[0], nick);
sendto_one(sptr, form_str(RPL_ENDOFWHOIS),
mename, parv[0], parv[1]);
return 0;
/* continue; */
}
if(IsStealth(acptr)) {
sendto_one(sptr, form_str(ERR_NOSUCHNICK), mename,
parv[0], nick);
return 0; // Add by ^Stinger^ after the idea of Soldier (:
}
if(!IsPerson(acptr))
{
sendto_one(sptr, form_str(RPL_ENDOFWHOIS),
mename, parv[0], parv[1]);
return 0;
}
/* continue; */
user = acptr->user ? acptr->user : &UnknownUser;
name = (!*acptr->name) ? "?" : acptr->name;
invis = IsInvisible(acptr);
member = (user->channel) ? 1 : 0;
a2cptr = find_server(user->server);
sendto_one(sptr, form_str(RPL_WHOISUSER), mename,
parv[0], name, acptr->username, acptr->host, acptr->info);
if((IsOper(sptr) || (acptr == sptr)) && WhoisExtension)
{
sendto_one(sptr, form_str(RPL_WHOISREALHOST), mename,
parv[0], name, acptr->realhost);
}
mlen = strlen(mename) + strlen(parv[0]) + 6 +
strlen(name);
*buf = '\0';
if (IsSsl(acptr))
{
sendto_one(sptr, form_str(RPL_WHOISSECURE), mename, parv[0], parv[1]);
}
if(((!IsPrivate(acptr) || IsOper(sptr)) || (acptr==sptr))
&& !IsStealth(acptr))
for (len = 0, *buf = '\0', lp = user->channel; lp;
lp = lp->next)
{
chptr = lp->value.chptr;
if (ShowChannel(sptr, chptr))
{
if (len + strlen(chptr->chname)
> (size_t) BUFSIZE - 4 - mlen)
{
sendto_one(sptr,
":%s %d %s %s :%s",
mename,
RPL_WHOISCHANNELS,
parv[0], name, buf);
*buf = '\0';
len = 0;
}
found_mode = user_channel_mode(acptr, chptr);
#ifdef HIDE_OPS
if(is_chan_op(sptr,chptr))
#endif
{
if(found_mode & CHFL_CHANOP)
*(buf + len++) = '@';
#ifdef HALFOPS
else if (found_mode & CHFL_HALFOP)
*(buf + len++) = '%';
#endif
else if (found_mode & CHFL_VOICE)
*(buf + len++) = '+';
}
if (len)
*(buf + len) = '\0';
(void)strcpy(buf + len, chptr->chname);
len += strlen(chptr->chname);
(void)strcat(buf + len, " ");
len++;
}
}
if (buf[0] != '\0')
sendto_one(sptr, form_str(RPL_WHOISCHANNELS),
mename, parv[0], name, buf);
if(IsAnOper(sptr) || !HideServerOnWhois)
{
#ifdef SERVERHIDE
if (!(IsAnOper(sptr) || acptr == sptr))
sendto_one(sptr, form_str(RPL_WHOISSERVER),
mename, parv[0], name, NetworkName,
NetworkDesc);
else
#endif
if(acptr->user && acptr->user->vlink)
sendto_one(sptr, form_str(RPL_WHOISSERVER),
mename, parv[0], name, user->vlink->name,
user->vlink->passwd);
else
{
if(!IsService(acptr) || IsAnOper(sptr) || !HideServicesServer)
sendto_one(sptr, form_str(RPL_WHOISSERVER),
mename, parv[0], name, user->server,
a2cptr?a2cptr->info:"*Not On This Net*");
}
} /* if(IsAnOper(sptr) || HideServerOnWhois) */
if (IsIdentified(acptr))
sendto_one(sptr, form_str(RPL_WHOISIDENTIFIED),
mename, parv[0], name);
if (IsHelper(acptr))
sendto_one(sptr, form_str(RPL_WHOISHELPOP),
mename, parv[0], name);
if(IsOper(sptr) && WhoisExtension)
{
sendto_one(sptr, form_str(RPL_WHOISMODE),
mename, parv[0], name, get_mode_string(acptr));
}
if (user->away)
sendto_one(sptr, form_str(RPL_AWAY), mename,
parv[0], name, user->away);
if(!IsHideOper(acptr) || IsOper(sptr))
{
if (IsNetAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_nadmin);
else if (IsTechAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_tadmin);
else if (IsSAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_sadmin);
else if (IsAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_admin);
else if (IsOper(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_oper);
else if (IsLocOp(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_locop);
}
#ifdef WHOIS_NOTICE
if ((IsOper(acptr)) && ((acptr)->umodes & UMODE_SPY) &&
(MyConnect(sptr)) && (IsPerson(sptr)) && (acptr != sptr) && !is_silenced(sptr, acptr))
sendto_one(acptr,
":%s NOTICE %s :*** Notice -- %s (%s@%s) is doing a /whois on you.",
me.name, acptr->name, parv[0], sptr->username,
sptr->realhost);
#endif /* #ifdef WHOIS_NOTICE */
if ((acptr->user
#ifdef SERVERHIDE
&& IsAnOper(sptr)
#endif
&& MyConnect(acptr)))
sendto_one(sptr, form_str(RPL_WHOISIDLE),
mename, parv[0], name,
CurrentTime - user->last,
acptr->firsttime);
sendto_one(sptr, form_str(RPL_ENDOFWHOIS), mename, parv[0], parv[1]);
return 0;
/* continue; */
}
/* wild is true so here we go */
if(nick[0]==':') /* real name match */
{
name_match = &nick[1];
nick_match = NULL;
}
else
if(nick[0]=='$') /* server name match */
{
server_match = &nick[1];
nick_match = NULL;
}
else
{
host_match = strchr(nick,'@');
if(host_match)
{
if(*host_match)
*(host_match++) = '\0';
user_match=nick;
if(host_match=='\0')
host_match="*";
if(user_match=='\0')
user_match="*";
}
else
nick_match = nick;
}
for (acptr = GlobalClientList; acptr;
acptr = acptr->next)
{
if (IsServer(acptr))
continue;
/*
* I'm always last :-) and acptr->next == NULL!!
*/
if (IsMe(acptr))
break;
/*
* 'Rules' established for sending a WHOIS reply:
*
*
* - if wildcards are being used dont send a reply if
* the querier isnt any common channels and the
* client in question is invisible and wildcards are
* in use (allow exact matches only);
*
* - only send replies about common or public channels
* the target user(s) are on;
*/
/* If its an unregistered client, ignore it, it can
be "seen" on a /trace anyway -Dianora */
if(!IsRegistered(acptr))
continue;
user = acptr->user ? acptr->user : &UnknownUser;
name = (!*acptr->name) ? "?" : acptr->name;
if( (server_match && !match(server_match, user->server))
|| (nick_match && !match(nick, name))
|| (host_match && !match(host_match, acptr->realhost)
&& !match(host_match, acptr->host))
|| (user_match && !match(user_match, acptr->username))
|| (name_match && !match(name_match, acptr->info))
)
continue;
++hits;
a2cptr = find_server(user->server);
sendto_one(sptr, form_str(RPL_WHOISUSER), mename,
parv[0], name,
acptr->username,
IsOper(sptr) ? acptr->realhost : acptr->host,
acptr->info);
found = 1;
mlen = strlen(mename) + strlen(parv[0]) + 6 +
strlen(name);
for (len = 0, *buf = '\0', lp = user->channel; lp;
lp = lp->next)
{
chptr = lp->value.chptr;
if (ShowChannel(sptr, chptr))
{
if (len + strlen(chptr->chname)
> (size_t) BUFSIZE - 4 - mlen)
{
sendto_one(sptr,
":%s %d %s %s :%s",
mename,
RPL_WHOISCHANNELS,
parv[0], name, buf);
*buf = '\0';
len = 0;
}
found_mode = user_channel_mode(acptr, chptr);
#ifdef HIDE_OPS
if(is_chan_op(sptr,chptr))
#endif
{
if (found_mode & CHFL_CHANOP)
*(buf + len++) = '@';
#ifdef HALFOPS
else if (found_mode & CHFL_HALFOP)
*(buf + len++) = '%';
#endif
else if (found_mode & CHFL_VOICE)
*(buf + len++) = '+';
}
if (len)
*(buf + len) = '\0';
(void)strcpy(buf + len, chptr->chname);
len += strlen(chptr->chname);
(void)strcat(buf + len, " ");
len++;
}
}
if (buf[0] != '\0')
sendto_one(sptr, form_str(RPL_WHOISCHANNELS),
mename, parv[0], name, buf);
#ifdef SERVERHIDE
if (!(IsAnOper(sptr) || acptr == sptr))
sendto_one(sptr, form_str(RPL_WHOISSERVER),
mename, parv[0], name, NetworkName,
NetworkDesc);
else
#endif
sendto_one(sptr, form_str(RPL_WHOISSERVER),
mename, parv[0], name, user->server,
a2cptr?a2cptr->info:"*Not On This Net*");
if (user->away)
sendto_one(sptr, form_str(RPL_AWAY), mename,
parv[0], name, user->away);
if (IsNetAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_nadmin);
else if (IsTechAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_tadmin);
else if (IsSAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_sadmin);
else if (IsAdmin(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_admin);
else if (IsAnOper(acptr))
sendto_one(sptr, form_str(RPL_WHOISOPERATOR),
mename, parv[0], name, rpl_oper);
#ifdef WHOIS_NOTICE
if ((MyOper(acptr)) && ((acptr)->umodes & UMODE_SPY) &&
(MyConnect(sptr)) && (IsPerson(sptr)) && (acptr != sptr))
sendto_one(acptr,
":%s NOTICE %s :*** Notice -- %s (%s@%s) is doing a /whois on you.",
mename, acptr->name, parv[0], sptr->username,
sptr->realhost);
#endif /* #ifdef WHOIS_NOTICE */
if ((acptr->user
#ifdef SERVERHIDE
&& IsAnOper(sptr)
#endif
&& MyConnect(acptr)))
sendto_one(sptr, form_str(RPL_WHOISIDLE),
mename, parv[0], name,
CurrentTime - user->last,
acptr->firsttime);
if(hits>50)
{
sendto_one(sptr,":%s NOTICE %s :Aborting /whois output as flood prevention",
mename, sptr->name);
break;
}
}
if (!found)
sendto_one(sptr, form_str(ERR_NOSUCHNICK),
mename, parv[0], nick);
else
sendto_one(sptr,":%s NOTICE %s :This /whois matched \2%i\2 user(s)",
mename, sptr->name,hits);
/*
if (p)
p[-1] = ',';
*/
}
sendto_one(sptr, form_str(RPL_ENDOFWHOIS), mename, parv[0], parv[1]);
return 0;
}
void checkClient(struct Client *sptr, struct Client *acptr)
{
struct Channel *chptr;
struct Membership *lp;
char outbuf[BUFSIZE];
char *privs;
time_t nowr;
/* Header */
send_reply(sptr, RPL_DATASTR, " ");
send_reply(sptr, RPL_CHKHEAD, "user", acptr->cli_name);
send_reply(sptr, RPL_DATASTR, " ");
ircd_snprintf(0, outbuf, sizeof(outbuf), " Nick:: %s (%s%s)", acptr->cli_name, NumNick(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
if (MyUser(acptr))
{
ircd_snprintf(0, outbuf, sizeof(outbuf), " Signed on:: %s", myctime(acptr->cli_firsttime));
send_reply(sptr, RPL_DATASTR, outbuf);
}
ircd_snprintf(0, outbuf, sizeof(outbuf), " Timestamp:: %s (%d)", myctime(acptr->cli_lastnick), acptr->cli_lastnick);
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " User/Hostmask:: %s@%s (%s)", acptr->cli_user->username, acptr->cli_user->host,
ircd_ntoa((const char*) &(cli_ip(acptr))));
send_reply(sptr, RPL_DATASTR, outbuf);
if (((feature_int(FEAT_HOST_HIDING_STYLE) == 1) ? HasHiddenHost(acptr) : IsHiddenHost(acptr)) || IsSetHost(acptr))
{
ircd_snprintf(0, outbuf, sizeof(outbuf), " Real User/Host:: %s@%s", acptr->cli_user->realusername, acptr->cli_user->realhost);
send_reply(sptr, RPL_DATASTR, outbuf);
}
ircd_snprintf(0, outbuf, sizeof(outbuf), " Real Name:: %s%c", cli_info(acptr), COLOR_OFF);
send_reply(sptr, RPL_DATASTR, outbuf);
if (IsService(cli_user(acptr)->server)) {
if (acptr)
send_reply(sptr, RPL_DATASTR, " Status:: Network Service");
else if (IsAdmin(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: IRC Administrator (service)");
else if (IsAnOper(acptr))
send_reply(sptr, RPL_DATASTR, " Status:: IRC Operator (service)");
else
send_reply(sptr, RPL_DATASTR, " Status:: Client (service)");
} else if (IsAdmin(acptr)) {
send_reply(sptr, RPL_DATASTR, " Status:: IRC Administrator");
} else if (IsAnOper(acptr)) {
send_reply(sptr, RPL_DATASTR, " Status:: IRC Operator");
} else {
send_reply(sptr, RPL_DATASTR, " Status:: Client");
}
if (MyUser(acptr)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " Class:: %s", get_client_class(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
privs = client_print_privs(acptr);
if (strlen(privs) > 1)
client_check_privs(acptr, sptr);
ircd_snprintf(0, outbuf, sizeof(outbuf), " Connected to:: %s", cli_name(acptr->cli_user->server));
send_reply(sptr, RPL_DATASTR, outbuf);
if (cli_version(acptr)) {
if (strlen(cli_version(acptr)) > 0) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " CTCP Version:: %s", cli_version(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
}
if (cli_user(acptr) && !EmptyString(cli_user(acptr)->swhois)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " SWHOIS:: %s", cli_user(acptr)->swhois);
send_reply(sptr, RPL_DATASTR, outbuf);
}
if (cli_webirc(acptr)) {
if (strlen(cli_webirc(acptr)) > 0) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " WebIRC:: %s", cli_webirc(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
}
if (cli_sslclifp(acptr) && (strlen(cli_sslclifp(acptr)) > 0)) {
ircd_snprintf(0, outbuf, sizeof(outbuf), "SSL Fingerprint:: %s", cli_sslclifp(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
if (MyUser(acptr))
get_eflags(sptr, acptr);
/* +s (SERV_NOTICE) is not relayed to us from remote servers,
* so we cannot tell if a remote client has that mode set.
* And hacking it onto the end of the output of umode_str is EVIL BAD AND WRONG
* (and breaks if the user is +r) so we won't do that either.
*/
if (strlen(umode_str(acptr)) < 1)
strcpy(outbuf, " Umode(s):: <none>");
else
ircd_snprintf(0, outbuf, sizeof(outbuf), " Umode(s):: +%s", umode_str(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
if (acptr->cli_user->joined == 0)
send_reply(sptr, RPL_DATASTR, " Channel(s):: <none>");
else if (acptr->cli_user->joined > 50)
{
/* NB. As a sanity check, we DO NOT show the individual channels the
* client is on if it is on > 50 channels. This is to prevent the ircd
* barfing ala Uworld when someone does /quote check Q :).. (I shouldn't imagine
* an Oper would want to see every single channel 'x' client is on anyway if
* they are on *that* many).
*/
ircd_snprintf(0, outbuf, sizeof(outbuf), " Channel(s):: - (total: %u)", acptr->cli_user->joined);
send_reply(sptr, RPL_DATASTR, outbuf);
}
else
{
char chntext[BUFSIZE];
int len = strlen(" Channel(s):: ");
int mlen = strlen(me.cli_name) + len + strlen(sptr->cli_name);
*chntext = '\0';
strcpy(chntext, " Channel(s):: ");
for (lp = acptr->cli_user->channel; lp; lp = lp->next_channel) {
chptr = lp->channel;
if (len + strlen(chptr->chname) + mlen > BUFSIZE - 5) {
send_reply(sptr, RPL_DATASTR, chntext);
*chntext = '\0';
strcpy(chntext, " Channel(s):: ");
len = strlen(chntext);
}
if (IsDeaf(acptr))
*(chntext + len++) = '-';
if (is_chan_op(acptr, chptr))
*(chntext + len++) = '@';
if (is_half_op(acptr, chptr))
*(chntext + len++) = '%';
if (IsOper(sptr) && !ShowChannel(sptr,chptr))
*(chntext + len++) = '*';
if (IsZombie(lp))
*(chntext + len++) = '!';
if (len)
*(chntext + len) = '\0';
strcpy(chntext + len, chptr->chname);
len += strlen(chptr->chname);
strcat(chntext + len, " ");
len++;
}
if (chntext[0] != '\0')
send_reply(sptr, RPL_DATASTR, chntext);
}
/* If client processing command ISN'T target (or a registered
* Network Service), show idle time since the last time we
* parsed something.
*/
if (MyUser(acptr) && !(IsService(acptr) == -1) && !(strCasediff(acptr->cli_name, sptr->cli_name) == 0)) {
nowr = CurrentTime - acptr->cli_user->last;
ircd_snprintf(0, outbuf, sizeof(outbuf), " Idle for:: %d days, %02ld:%02ld:%02ld",
nowr / 86400, (nowr / 3600) % 24, (nowr / 60) % 60, nowr % 60);
send_reply(sptr, RPL_DATASTR, outbuf);
}
/* Away message (if applicable) */
if (acptr->cli_user->away) {
ircd_snprintf(0, outbuf, sizeof(outbuf), " Away message:: %s", acptr->cli_user->away);
send_reply(sptr, RPL_DATASTR, outbuf);
}
/* If local user.. */
if (MyUser(acptr)) {
send_reply(sptr, RPL_DATASTR, " ");
ircd_snprintf(0, outbuf, sizeof(outbuf), " Ports:: %d -> %d (client -> server)",
cli_port(acptr), cli_listener(acptr)->port);
send_reply(sptr, RPL_DATASTR, outbuf);
if (feature_bool(FEAT_CHECK_EXTENDED)) {
/* Note: sendq = receiveq for a client (it makes sense really) */
ircd_snprintf(0, outbuf, sizeof(outbuf), " Data sent:: %u.%0.3u Kb (%u protocol messages)",
cli_receiveK(acptr), cli_receiveB(acptr), cli_receiveM(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " Data received:: %u.%0.3u Kb (%u protocol messages)",
cli_sendK(acptr), cli_sendB(acptr), cli_sendM(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " receiveQ size:: %d bytes (max. %d bytes)",
DBufLength(&(cli_recvQ(acptr))), feature_int(FEAT_CLIENT_FLOOD));
send_reply(sptr, RPL_DATASTR, outbuf);
ircd_snprintf(0, outbuf, sizeof(outbuf), " sendQ size:: %d bytes (max. %d bytes)",
DBufLength(&(cli_sendQ(acptr))), get_sendq(acptr));
send_reply(sptr, RPL_DATASTR, outbuf);
}
}
/* Send 'END OF CHECK' message */
send_reply(sptr, RPL_ENDOFCHECK, " ");
}
signed int checkHostmask(struct Client *sptr, char *hoststr, int flags) {
struct Client *acptr;
struct Channel *chptr;
struct Membership *lp;
int count = 0, found = 0, cidr_check_bits = 0;
char outbuf[BUFSIZE];
char targhost[NICKLEN + USERLEN + HOSTLEN + 3], curhost[NICKLEN + USERLEN + HOSTLEN + 3];
char nickm[NICKLEN + 1], userm[USERLEN + 1], hostm[HOSTLEN + 1];
char *p = NULL;
struct in_addr cidr_check;
strcpy(nickm,"*");
strcpy(userm,"*");
strcpy(hostm,"*");
if (!strchr(hoststr, '!') && !strchr(hoststr, '@'))
ircd_strncpy(hostm,hoststr,HOSTLEN);
else {
if ((p = strchr(hoststr, '@'))) {
*p++ = '\0';
if (*p) ircd_strncpy(hostm,p, HOSTLEN);
}
/* Get the nick!user mask */
if ((p = strchr(hoststr, '!'))) {
*p++ = '\0';
if (*p) ircd_strncpy(userm,p,USERLEN);
if (*hoststr) ircd_strncpy(nickm,hoststr,NICKLEN);
}
else if (*hoststr) {
/* Durz: We should only do the following *IF* the hoststr has not already been
* copied into hostm (ie. neither ! or @ specified).. otherwise, when we do
* /quote check *.barrysworld.com - we end up with targhost as: *!*.barryswo@*.barrysworld.com
*/
ircd_strncpy(userm,hoststr,USERLEN);
}
}
if ((p = strchr(hostm, '/')) || inet_aton(hostm, &cidr_check)) {
if (p)
*p = '\0';
if (inet_aton(hostm, &cidr_check)) {
cidr_check_bits = p ? atoi(p + 1) : 32;
if ((cidr_check_bits >= 0) && (cidr_check_bits <= 32)) {
flags |= CHECK_CIDRMASK;
cidr_check.s_addr &= NETMASK(cidr_check_bits);
}
}
if (p)
*p = '/';
}
/* Copy formatted string into "targhost" buffer */
ircd_snprintf(0, targhost, sizeof(targhost), "%s!%s@%s", nickm, userm, hostm);
targhost[sizeof(targhost) - 1] = '\0';
/* Note: we have to exclude the last client struct as it is not a real client
* structure, and therefore any attempt to access elements in it would cause
* a segfault.
*/
for (acptr = GlobalClientList; acptr; acptr = cli_next(acptr)) {
/* Dont process if acptr is a unregistered client, a server or a ping */
if (!IsRegistered(acptr) || IsServer(acptr))
continue;
if (IsMe(acptr)) /* Always the last acptr record */
break;
if(count > feature_int(FEAT_MAX_CHECK_OUTPUT)) { /* sanity stuff */
ircd_snprintf(0, outbuf, sizeof(outbuf), "More than %d results, truncating...", count);
send_reply(sptr, RPL_DATASTR, outbuf);
send_reply(sptr, RPL_ENDOFCHECK, " ");
break;
}
/* Copy host info into buffer */
curhost[0] = '\0';
ircd_snprintf(0, curhost, sizeof(curhost), "%s!%s@%s", acptr->cli_name, acptr->cli_user->realusername, acptr->cli_user->realhost);
if (flags & CHECK_CIDRMASK) {
if (((cli_ip(acptr).s_addr & NETMASK(cidr_check_bits)) == cidr_check.s_addr) && !match(nickm, acptr->cli_name)
&& (!match(userm, acptr->cli_user->realusername) || !match(userm, acptr->cli_user->username)))
found = 1;
}
else {
if(match((const char*)targhost,(const char*)curhost) == 0)
found = 1;
else {
curhost[0] = '\0';
ircd_snprintf(0, curhost, sizeof(curhost), "%s!%s@%s", acptr->cli_name, acptr->cli_user->username, acptr->cli_user->host);
if(match((const char*)targhost,(const char*)curhost) == 0)
found = 1;
}
}
if (found == 1) {
found = 0; /* reset that so it doesn't get crazy go nuts */
/* Show header if we've found at least 1 record */
if (count == 0) {
/* Output header */
send_reply(sptr, RPL_DATASTR, " ");
send_reply(sptr, RPL_CHKHEAD, "host", targhost);
send_reply(sptr, RPL_DATASTR, " ");
ircd_snprintf(0, outbuf, sizeof(outbuf), "%s %-*s%-*s%s", "No.", (NICKLEN + 2 ), "Nick",
(USERLEN + 2), "User", "Host");
send_reply(sptr, RPL_DATASTR, outbuf);
}
ircd_snprintf(0, outbuf, sizeof(outbuf), "%-4d %-*s%-*s%s", (count+1), (NICKLEN + 2),
acptr->cli_name, (USERLEN + 2), acptr->cli_user->realusername,
(flags & CHECK_SHOWIPS) ? ircd_ntoa((const char*)&(cli_ip(acptr))) : acptr->cli_user->realhost);
send_reply(sptr, RPL_DATASTR, outbuf);
/* Show channel output (if applicable) - the 50 channel limit sanity check
* is specifically to prevent coredumping when someone lamely tries to /check
* Q or some other channel service...
*/
if (flags & CHECK_CHECKCHAN) {
if (acptr->cli_user->joined > 0 && acptr->cli_user->joined <= 50) {
char chntext[BUFSIZE];
int len = strlen(" on channels: ");
int mlen = strlen(me.cli_name) + len + strlen(sptr->cli_name);
*chntext = '\0';
strcpy(chntext, " on channels: ");
for (lp = acptr->cli_user->channel; lp; lp = lp->next_channel) {
chptr = lp->channel;
if (len + strlen(chptr->chname) + mlen > BUFSIZE - 5) {
send_reply(sptr, RPL_DATASTR, chntext);
*chntext = '\0';
strcpy(chntext, " on channels: ");
len = strlen(chntext);
}
if (IsDeaf(acptr))
*(chntext + len++) = '-';
if (is_chan_op(acptr, chptr))
*(chntext + len++) = '@';
if (is_half_op(acptr, chptr))
*(chntext + len++) = '%';
if (IsOper(sptr) && !ShowChannel(sptr,chptr))
*(chntext + len++) = '*';
else if (has_voice(acptr, chptr))
*(chntext + len++) = '+';
else if (IsZombie(lp))
*(chntext + len++) = '!';
if (len)
*(chntext + len) = '\0';
strcpy(chntext + len, chptr->chname);
len += strlen(chptr->chname);
strcat(chntext + len, " ");
len++;
}
if (chntext[0] != '\0')
send_reply(sptr, RPL_DATASTR, chntext);
send_reply(sptr, RPL_DATASTR, " ");
}
}
count++;
}
}
if (count > 0) {
send_reply(sptr, RPL_DATASTR, " ");
ircd_snprintf(0, outbuf, sizeof(outbuf), "Matching records found:: %d", count);
send_reply(sptr, RPL_DATASTR, outbuf);
send_reply(sptr, RPL_ENDOFCHECK, " ");
}
return count;
}
DLLFUNC CMD_FUNC(m_names)
{
int uhnames = (MyConnect(sptr) && SupportUHNAMES(sptr)); // cache UHNAMES support
int bufLen = NICKLEN + (!uhnames ? 0 : (1 + USERLEN + 1 + HOSTLEN));
int mlen = strlen(me.name) + bufLen + 7;
aChannel *chptr;
aClient *acptr;
int member;
Member *cm;
int idx, flag = 1, spos;
char *s, *para = parv[1];
char nuhBuffer[NICKLEN+USERLEN+HOSTLEN+3];
if (parc < 2 || !MyConnect(sptr))
{
sendto_one(sptr, rpl_str(RPL_ENDOFNAMES), me.name,
parv[0], "*");
return 0;
}
for (s = para; *s; s++)
{
if (*s == ',')
{
if (strlen(para) > TRUNCATED_NAMES)
para[TRUNCATED_NAMES] = '\0';
sendto_realops("names abuser %s %s",
get_client_name(sptr, FALSE), para);
sendto_one(sptr, err_str(ERR_TOOMANYTARGETS),
me.name, sptr->name, "NAMES");
return 0;
}
}
chptr = find_channel(para, (aChannel *)NULL);
if (!chptr || (!ShowChannel(sptr, chptr) && !OPCanSeeSecret(sptr)))
{
sendto_one(sptr, rpl_str(RPL_ENDOFNAMES), me.name,
parv[0], para);
return 0;
}
/* cache whether this user is a member of this channel or not */
member = IsMember(sptr, chptr);
if (PubChannel(chptr))
buf[0] = '=';
else if (SecretChannel(chptr))
buf[0] = '@';
else
buf[0] = '*';
idx = 1;
buf[idx++] = ' ';
for (s = chptr->chname; *s; s++)
buf[idx++] = *s;
buf[idx++] = ' ';
buf[idx++] = ':';
/* If we go through the following loop and never add anything,
we need this to be empty, otherwise spurious things from the
LAST /names call get stuck in there.. - lucas */
buf[idx] = '\0';
spos = idx; /* starting point in buffer for names! */
for (cm = chptr->members; cm; cm = cm->next)
{
acptr = cm->cptr;
if (IsInvisible(acptr) && !member && !IsNetAdmin(sptr))
continue;
if (chptr->mode.mode & MODE_AUDITORIUM)
if (!is_chan_op(sptr, chptr)
&& !is_chanprot(sptr, chptr)
&& !is_chanowner(sptr, chptr))
if (!(cm->
flags & (CHFL_CHANOP | CHFL_CHANPROT |
CHFL_CHANOWNER)) && acptr != sptr)
continue;
if (!SupportNAMESX(sptr))
{
/* Standard NAMES reply */
#ifdef PREFIX_AQ
if (cm->flags & CHFL_CHANOWNER)
buf[idx++] = '~';
else if (cm->flags & CHFL_CHANPROT)
buf[idx++] = '&';
else
#endif
if (cm->flags & CHFL_CHANOP)
buf[idx++] = '@';
else if (cm->flags & CHFL_HALFOP)
buf[idx++] = '%';
else if (cm->flags & CHFL_VOICE)
buf[idx++] = '+';
} else {
/* NAMES reply with all rights included (NAMESX) */
#ifdef PREFIX_AQ
if (cm->flags & CHFL_CHANOWNER)
buf[idx++] = '~';
if (cm->flags & CHFL_CHANPROT)
buf[idx++] = '&';
#endif
if (cm->flags & CHFL_CHANOP)
buf[idx++] = '@';
if (cm->flags & CHFL_HALFOP)
buf[idx++] = '%';
if (cm->flags & CHFL_VOICE)
buf[idx++] = '+';
}
if (!uhnames) {
s = acptr->name;
} else {
strlcpy(nuhBuffer,
make_nick_user_host(acptr->name, acptr->user->username, GetHost(acptr)),
bufLen + 1);
s = nuhBuffer;
}
/* 's' is intialized above to point to either acptr->name (normal),
* or to nuhBuffer (for UHNAMES).
*/
for (; *s; s++)
buf[idx++] = *s;
buf[idx++] = ' ';
buf[idx] = '\0';
flag = 1;
if (mlen + idx + bufLen > BUFSIZE - 7)
{
sendto_one(sptr, rpl_str(RPL_NAMREPLY), me.name,
parv[0], buf);
idx = spos;
flag = 0;
}
}
if (flag)
sendto_one(sptr, rpl_str(RPL_NAMREPLY), me.name, parv[0], buf);
sendto_one(sptr, rpl_str(RPL_ENDOFNAMES), me.name, parv[0], para);
return 0;
}
/*
** Exit one client, local or remote. Assuming all dependants have
** been already removed, and socket closed for local client.
*/
static void exit_one_client(aClient *cptr, aClient *sptr, aClient *from,
const char *comment)
{
Reg aClient *acptr;
Reg int i;
Reg Link *lp;
invLink *ilp;
/*
** For a server or user quitting, propagage the information to
** other servers (except to the one where is came from (cptr))
*/
if (IsMe(sptr))
{
sendto_flag(SCH_ERROR,
"ERROR: tried to exit me! : %s", comment);
return; /* ...must *never* exit self!! */
}
else if (IsServer(sptr))
{
/*
** Old sendto_serv_but_one() call removed because we now
** need to send different names to different servers
** (domain name matching)
*/
if (!IsMasked(sptr))
{
istat.is_serv--;
}
if (!IsBursting(sptr))
{
istat.is_eobservers--;
}
for (i = fdas.highest; i >= 0; i--)
{
if (!(acptr = local[fdas.fd[i]]) || !IsServer(acptr) ||
acptr == cptr || IsMe(acptr))
{
continue;
}
if (!(sptr->flags & FLAGS_SQUIT))
{
/* Make sure we only send the last SQUIT
** to a 2.11. */
continue;
}
if ((acptr->flags & FLAGS_HIDDEN) &&
!IsMasked(sptr))
{
/* We need a special SQUIT reason, so
** the remote server can send the
** right quit message. */
sendto_one(acptr, ":%s SQUIT %s :%s %s",
sptr->serv->up->serv->sid,
sptr->serv->sid,
sptr->serv->up->name,
sptr->name);
}
else
{
sendto_one(acptr, ":%s SQUIT %s :%s",
sptr->serv->up->serv->sid,
sptr->serv->sid, comment);
}
}
#ifdef USE_SERVICES
check_services_butone(SERVICE_WANT_SQUIT, sptr->serv, sptr,
":%s SQUIT %s :%s", from->name,
sptr->name, comment);
#endif
del_from_sid_hash_table(sptr->serv);
remove_server_from_tree(sptr);
/* remove server from svrtop */
unregister_server(sptr);
}
else if (!IsPerson(sptr) && !IsService(sptr))
{
/* ...this test is *dubious*, would need
** some thougth.. but for now it plugs a
** nasty hole in the server... --msa
*/
; /* Nothing */
}
else if (sptr->name[0] && !IsService(sptr)) /* clean with QUIT... */
{
/*
** If this exit is generated from "m_kill", then there
** is no sense in sending the QUIT--KILL's have been
** sent instead.
*/
if ((sptr->flags & FLAGS_KILLED) == 0)
{
if ((sptr->flags & FLAGS_SPLIT) == 0)
{
sendto_serv_butone(cptr, ":%s QUIT :%s",
sptr->user->uid, comment);
#ifdef USE_SERVICES
check_services_butone(SERVICE_WANT_QUIT|
SERVICE_WANT_RQUIT,
(sptr->user) ?
sptr->user->servp
: NULL, cptr,
":%s QUIT :%s",
sptr->name, comment);
#endif
}
else
{
if (sptr->flags & FLAGS_HIDDEN)
/* joys of hostmasking */
for (i = fdas.highest; i >= 0; i--)
{
if (!(acptr =local[fdas.fd[i]])
|| acptr == cptr
|| IsMe(acptr))
continue;
if (acptr->flags & FLAGS_HIDDEN)
sendto_one(acptr,
":%s QUIT :%s",
sptr->user->uid,
comment);
}
#ifdef USE_SERVICES
check_services_butone(SERVICE_WANT_QUIT,
(sptr->user) ? sptr->user->servp
: NULL, cptr,
":%s QUIT :%s",
sptr->name, comment);
#endif
}
}
#ifdef USE_SERVICES
else
{
/* Send QUIT to services which desire such as well.
** Services with both _QUIT and _KILL will get both
** for now --jv
*/
check_services_butone(SERVICE_WANT_QUIT,
(sptr->user) ? sptr->user->servp
: NULL, cptr,
":%s QUIT :%s",
sptr->name, comment);
}
#endif
/*
** If a person is on a channel, send a QUIT notice
** to every client (person) on the same channel (so
** that the client can show the "**signoff" message).
** (Note: The notice is to the local clients *only*)
*/
if (sptr->user)
{
if (IsInvisible(sptr))
{
istat.is_user[1]--;
sptr->user->servp->usercnt[1]--;
}
else
{
istat.is_user[0]--;
sptr->user->servp->usercnt[0]--;
}
if (IsAnOper(sptr))
{
sptr->user->servp->usercnt[2]--;
istat.is_oper--;
}
sendto_common_channels(sptr, ":%s QUIT :%s",
sptr->name, comment);
if (!(acptr = cptr ? cptr : sptr->from))
acptr = sptr;
while ((lp = sptr->user->channel))
{
/*
** Mark channels from where remote chop left,
** this will eventually lock the channel.
** close_connection() has already been called,
** it makes MyConnect == False - krys
*/
if (sptr != cptr)
{
if (*lp->value.chptr->chname == '!')
{
if (!(sptr->flags &FLAGS_QUIT))
lp->value.chptr->history = timeofday + LDELAYCHASETIMELIMIT;
}
else if (
#ifndef BETTER_CDELAY
!(sptr->flags & FLAGS_QUIT) &&
#endif
is_chan_op(sptr, lp->value.chptr))
{
lp->value.chptr->history = timeofday + DELAYCHASETIMELIMIT;
}
}
if (IsAnonymous(lp->value.chptr) &&
!IsQuiet(lp->value.chptr))
{
sendto_channel_butserv(lp->value.chptr, sptr, ":%s PART %s :None", sptr->name, lp->value.chptr->chname);
}
remove_user_from_channel(sptr,lp->value.chptr);
}
/* Clean up invitefield */
while ((ilp = sptr->user->invited))
{
del_invite(sptr, ilp->chptr);
/* again, this is all that is needed */
}
/* remove from uid hash table */
if (sptr->user)
{
del_from_uid_hash_table(sptr->user->uid, sptr);
}
/* Add user to history */
#ifndef BETTER_NDELAY
add_history(sptr, (sptr->flags & FLAGS_QUIT) ?
&me : NULL);
#else
add_history(sptr, (sptr == cptr) ? &me : NULL);
#endif
off_history(sptr);
#ifdef USE_HOSTHASH
del_from_hostname_hash_table(sptr->user->host,
sptr->user);
#endif
#ifdef USE_IPHASH
del_from_ip_hash_table(sptr->user->sip, sptr->user);
#endif
}
}
else if (sptr->name[0] && IsService(sptr))
{
/*
** If this exit is generated from "m_kill", then there
** is no sense in sending the QUIT--KILL's have been
** sent instead.
*/
if ((sptr->flags & FLAGS_KILLED) == 0)
{
/*
** A service quitting is annoying, It has to be sent
** to connected servers depending on
** sptr->service->dist
*/
for (i = fdas.highest; i >= 0; i--)
{
if (!(acptr = local[fdas.fd[i]])
|| !IsServer(acptr) || acptr == cptr
|| IsMe(acptr))
{
continue;
}
if (match(sptr->service->dist, acptr->name) &&
match(sptr->service->dist, acptr->serv->sid))
{
continue;
}
sendto_one(acptr, ":%s QUIT :%s", sptr->name,
comment);
}
}
#ifdef USE_SERVICES
check_services_butone(SERVICE_WANT_SERVICE, NULL, NULL,
":%s QUIT :%s", sptr->name, comment);
#endif
/* MyConnect(sptr) is always FALSE here */
if (cptr == sptr)
{
sendto_flag(SCH_NOTICE, "Service %s disconnected",
get_client_name(sptr, TRUE));
}
sendto_flag(SCH_SERVICE, "Received QUIT %s from %s (%s)",
sptr->name, from->name, comment);
istat.is_service--;
}
/* Remove sptr from the client list */
if (del_from_client_hash_table(sptr->name, sptr) != 1)
{
Debug((DEBUG_ERROR, "%#x !in tab %s[%s] %#x %#x %#x %d %d %#x",
sptr, sptr->name,
sptr->from ? sptr->from->sockhost : "??host",
sptr->from, sptr->next, sptr->prev, sptr->fd,
sptr->status, sptr->user));
}
remove_client_from_list(sptr);
return;
}
/*
** m_part
** parv[0] = sender prefix
** parv[1] = channel
** parv[2] = comment (added by Lefler)
*/
DLLFUNC CMD_FUNC(m_part)
{
aChannel *chptr;
Membership *lp;
char *p = NULL, *name;
char *commentx = (parc > 2 && parv[2]) ? parv[2] : NULL;
char *comment;
int n;
if (parc < 2 || parv[1][0] == '\0')
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "PART");
return 0;
}
if (MyClient(sptr))
{
if (IsShunned(sptr))
commentx = NULL;
if (STATIC_PART)
{
if (!strcasecmp(STATIC_PART, "yes") || !strcmp(STATIC_PART, "1"))
commentx = NULL;
else if (!strcasecmp(STATIC_PART, "no") || !strcmp(STATIC_PART, "0"))
; /* keep original reason */
else
commentx = STATIC_PART;
}
if (commentx)
{
n = dospamfilter(sptr, commentx, SPAMF_PART, parv[1], 0, NULL);
if (n == FLUSH_BUFFER)
return n;
if (n < 0)
commentx = NULL;
}
}
for (; (name = strtoken(&p, parv[1], ",")); parv[1] = NULL)
{
chptr = get_channel(sptr, name, 0);
if (!chptr)
{
sendto_one(sptr, err_str(ERR_NOSUCHCHANNEL),
me.name, parv[0], name);
continue;
}
if (check_channelmask(sptr, cptr, name))
continue;
/* 'commentx' is the general part msg, but it can be changed
* per-channel (eg some chans block badwords, strip colors, etc)
* so we copy it to 'comment' and use that in this for loop :)
*/
comment = commentx;
if (!(lp = find_membership_link(sptr->user->channel, chptr)))
{
/* Normal to get get when our client did a kick
** for a remote client (who sends back a PART),
** so check for remote client or not --Run
*/
if (MyClient(sptr))
sendto_one(sptr,
err_str(ERR_NOTONCHANNEL), me.name,
parv[0], name);
continue;
}
if (!IsAnOper(sptr) && !is_chanownprotop(sptr, chptr)) {
#ifdef STRIPBADWORDS
int blocked = 0;
#endif
/* Banned? No comment allowed ;) */
if (comment && is_banned(sptr, chptr, BANCHK_MSG))
comment = NULL;
/* And other things... */
if ((chptr->mode.mode & MODE_NOCOLOR) && comment) {
if (strchr((char *)comment, 3) || strchr((char *)comment, 27)) {
comment = NULL;
}
}
if ((chptr->mode.mode & MODE_MODERATED) && comment &&
!has_voice(sptr, chptr) && !is_halfop(sptr, chptr))
{
comment = NULL;
}
if ((chptr->mode.mode & MODE_STRIP) && comment) {
comment = (char *)StripColors(comment);
}
#ifdef STRIPBADWORDS
#ifdef STRIPBADWORDS_CHAN_ALWAYS
if (comment)
{
comment = (char *)stripbadwords_channel(comment, &blocked);
}
#else
if ((chptr->mode.extmode & EXTMODE_STRIPBADWORDS) && comment) {
comment = (char *)stripbadwords_channel(comment, &blocked);
}
#endif
#endif
}
/* +M and not logged in to services? */
if ((chptr->mode.mode & MODE_MODREG) && !IsLoggedIn(sptr) && !IsAnOper(sptr))
comment = NULL;
if (MyConnect(sptr))
{
Hook *tmphook;
for (tmphook = Hooks[HOOKTYPE_PRE_LOCAL_PART]; tmphook; tmphook = tmphook->next) {
comment = (*(tmphook->func.pcharfunc))(sptr, chptr, comment);
if (!comment)
break;
}
}
/* Send to other servers... */
if (!comment)
sendto_serv_butone_token(cptr, parv[0],
MSG_PART, TOK_PART, "%s", chptr->chname);
else
sendto_serv_butone_token(cptr, parv[0],
MSG_PART, TOK_PART, "%s :%s", chptr->chname,
comment);
if (1)
{
if ((chptr->mode.mode & MODE_AUDITORIUM) && !is_chanownprotop(sptr, chptr))
{
if (!comment)
{
sendto_chanops_butone(NULL,
chptr, ":%s!%s@%s PART %s",
sptr->name, sptr->user->username, GetHost(sptr),
chptr->chname);
if (!is_chan_op(sptr, chptr) && MyClient(sptr))
sendto_one(sptr, ":%s!%s@%s PART %s",
sptr->name, sptr->user->username, GetHost(sptr), chptr->chname);
}
else
{
sendto_chanops_butone(NULL,
chptr,
":%s!%s@%s PART %s %s",
sptr->name,
sptr->user->username,
GetHost(sptr),
chptr->chname, comment);
if (!is_chan_op(cptr, chptr) && MyClient(sptr))
sendto_one(sptr,
":%s!%s@%s PART %s %s",
sptr->name, sptr->user->username, GetHost(sptr),
chptr->chname, comment);
}
}
else
{
if (!comment)
sendto_channel_butserv(chptr,
sptr, PARTFMT, parv[0],
chptr->chname);
else
sendto_channel_butserv(chptr,
sptr, PARTFMT2, parv[0],
chptr->chname, comment);
}
if (MyClient(sptr))
RunHook4(HOOKTYPE_LOCAL_PART, cptr, sptr, chptr, comment);
else
RunHook4(HOOKTYPE_REMOTE_PART, cptr, sptr, chptr, comment);
remove_user_from_channel(sptr, chptr);
}
}
return 0;
}
/*
** m_kick
** parv[0] = sender prefix
** parv[1] = channel
** parv[2] = client to kick
** parv[3] = kick comment
*/
static void m_kick(struct Client *client_p,
struct Client *source_p,
int parc,
char *parv[])
{
struct Client *who;
struct Channel *chptr;
int chasing = 0;
char *comment;
char *name;
char *p = (char *)NULL;
char *user;
static char buf[BUFSIZE];
if (*parv[2] == '\0')
{
sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "KICK");
return;
}
if(MyClient(source_p) && !IsFloodDone(source_p))
flood_endgrace(source_p);
comment = (BadPtr(parv[3])) ? parv[2] : parv[3];
if (strlen(comment) > (size_t) TOPICLEN)
comment[TOPICLEN] = '\0';
*buf = '\0';
if( (p = strchr(parv[1],',')) )
*p = '\0';
name = parv[1];
chptr = hash_find_channel(name);
if (!chptr)
{
sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL),
me.name, parv[0], name);
return;
}
if (!IsServer(source_p) && !is_chan_op(chptr, source_p) )
{
/* was a user, not a server, and user isn't seen as a chanop here */
if(MyConnect(source_p))
{
/* user on _my_ server, with no chanops.. so go away */
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name, parv[0], name);
return;
}
if(chptr->channelts == 0)
{
/* If its a TS 0 channel, do it the old way */
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name, parv[0], name);
return;
}
/* Its a user doing a kick, but is not showing as chanop locally
* its also not a user ON -my- server, and the channel has a TS.
* There are two cases we can get to this point then...
*
* 1) connect burst is happening, and for some reason a legit
* op has sent a KICK, but the SJOIN hasn't happened yet or
* been seen. (who knows.. due to lag...)
*
* 2) The channel is desynced. That can STILL happen with TS
*
* Now, the old code roger wrote, would allow the KICK to
* go through. Thats quite legit, but lets weird things like
* KICKS by users who appear not to be chanopped happen,
* or even neater, they appear not to be on the channel.
* This fits every definition of a desync, doesn't it? ;-)
* So I will allow the KICK, otherwise, things are MUCH worse.
* But I will warn it as a possible desync.
*
* -Dianora
*/
}
if( (p = strchr(parv[2],',')) )
*p = '\0';
user = parv[2]; /* strtoken(&p2, parv[2], ","); */
if (!(who = find_chasing(source_p, user, &chasing)))
{
return;
}
if (IsMember(who, chptr))
{
/* jdc
* - In the case of a server kicking a user (i.e. CLEARCHAN),
* the kick should show up as coming from the server which did
* the kick.
* - Personally, flame and I believe that server kicks shouldn't
* be sent anyways. Just waiting for some oper to abuse it...
*/
if (IsServer(source_p))
{
sendto_channel_local(ALL_MEMBERS, chptr, ":%s KICK %s %s :%s",
source_p->name, name, who->name, comment);
}
#ifdef ANONOPS
else if(chptr->mode.mode & MODE_HIDEOPS)
{
/* jdc -- Non-chanops get kicked from me.name, not
* who->name (themselves).
*/
sendto_channel_local(NON_CHANOPS, chptr,
":%s KICK %s %s :%s",
me.name,
name, who->name, comment);
sendto_channel_local(ONLY_CHANOPS, chptr,
":%s!%s@%s KICK %s %s :%s",
source_p->name,
source_p->username,
source_p->host,
name,
who->name, comment);
}
else
#endif
{
sendto_channel_local(ALL_MEMBERS, chptr,
":%s!%s@%s KICK %s %s :%s",
source_p->name,
source_p->username,
source_p->host,
name, who->name, comment);
}
sendto_server(client_p, NOCAPS, NOCAPS,
":%s KICK %s %s :%s",
parv[0], chptr->chname,
who->name, comment);
remove_user_from_channel(chptr, who);
}
else
sendto_one(source_p, form_str(ERR_USERNOTINCHANNEL),
me.name, parv[0], user, name);
}
/*
* m_invite - generic message handler
*
* parv[0] - sender prefix
* parv[1] - user to invite
* parv[2] - channel name
*
* - INVITE now is accepted only if who does it is chanop (this of course
* implies that channel must exist and he must be on it).
*
* - On the other side it IS processed even if channel is NOT invite only
* leaving room for other enhancements like inviting banned ppl. -- Nemesi
*
* - Invite with no parameters now lists the channels you are invited to.
* - Isomer 23 Oct 99
*/
int m_invite(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Client *acptr;
struct Channel *chptr;
if (parc < 2 ) {
/*
* list the channels you have an invite to.
*/
struct SLink *lp;
for (lp = cli_user(sptr)->invited; lp; lp = lp->next)
send_reply(cptr, RPL_INVITELIST, lp->value.chptr->chname);
send_reply(cptr, RPL_ENDOFINVITELIST);
return 0;
}
if (parc < 3 || EmptyString(parv[2]))
return need_more_params(sptr, "INVITE");
if (!(acptr = FindUser(parv[1]))) {
send_reply(sptr, ERR_NOSUCHNICK, parv[1]);
return 0;
}
if (is_silenced(sptr, acptr))
return 0;
if (!IsChannelName(parv[2])
|| !strIsIrcCh(parv[2])
|| !(chptr = FindChannel(parv[2]))) {
send_reply(sptr, ERR_NOSUCHCHANNEL, parv[2]);
return 0;
}
if (!find_channel_member(sptr, chptr)) {
send_reply(sptr, ERR_NOTONCHANNEL, chptr->chname);
return 0;
}
if (find_channel_member(acptr, chptr)) {
send_reply(sptr, ERR_USERONCHANNEL, cli_name(acptr), chptr->chname);
return 0;
}
if (!is_chan_op(sptr, chptr)) {
send_reply(sptr, ERR_CHANOPRIVSNEEDED, chptr->chname);
return 0;
}
/* If we get here, it was a VALID and meaningful INVITE */
if (check_target_limit(sptr, acptr, cli_name(acptr), 0))
return 0;
send_reply(sptr, RPL_INVITING, cli_name(acptr), chptr->chname);
if (cli_user(acptr)->away)
send_reply(sptr, RPL_AWAY, cli_name(acptr), cli_user(acptr)->away);
if (MyConnect(acptr)) {
add_invite(acptr, chptr);
sendcmdto_one(sptr, CMD_INVITE, acptr, "%s %H", cli_name(acptr), chptr);
} else if (!IsLocalChannel(chptr->chname)) {
sendcmdto_one(sptr, CMD_INVITE, acptr, "%s %H %Tu", cli_name(acptr), chptr,
chptr->creationtime);
}
if (!IsLocalChannel(chptr->chname) || MyConnect(acptr)) {
if (feature_bool(FEAT_ANNOUNCE_INVITES)) {
/* Announce to channel operators. */
sendcmdto_channel_butserv_butone(&his, get_error_numeric(RPL_ISSUEDINVITE)->str,
NULL, chptr, sptr, SKIP_NONOPS,
"%H %C %C :%C has been invited by %C",
chptr, acptr, sptr, acptr, sptr);
/* Announce to servers with channel operators. */
sendcmdto_channel_servers_butone(sptr, NULL, TOK_INVITE, chptr, acptr, SKIP_NONOPS,
"%s %H %Tu", cli_name(acptr),
chptr, chptr->creationtime);
}
}
return 0;
}
/*
* m_kick - generic message handler
*
* parv[0] = sender prefix
* parv[1] = channel
* parv[2] = client to kick
* parv[parc-1] = kick comment
*/
int m_kick(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *who;
struct Channel *chptr;
struct Membership *member = 0;
char *name, *comment;
ClrFlag(sptr, FLAG_TS8);
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 (!is_chan_op(sptr, chptr) && !is_half_op(sptr, chptr))
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 */
/*
* ASUKA_X:
* Allow +X'ed users to kick +k'ed, but not U-lined services.
* --Bigfoot
*/
if (IsChannelService(who) && IsService(cli_user(who)->server))
return send_reply(sptr, ERR_ISCHANSERVICE, cli_name(who), chptr->chname, "a network service");
if (IsChannelService(who) && !IsXtraOp(sptr) && (who!=sptr))
return send_reply(sptr, ERR_ISCHANSERVICE, cli_name(who), chptr->chname, "an IRC operator");
/* Don't allow halfops to kick chanops */
if (is_chan_op(who, chptr) && is_half_op(sptr, chptr) && !is_chan_op(sptr, chptr))
return send_reply(sptr, ERR_HALFCANTKICKOP, name);
/* 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);
/* We rely on ircd_snprintf to truncate the comment */
comment = EmptyString(parv[parc - 1]) ? parv[0] : parv[parc - 1];
if (!IsLocalChannel(name))
sendcmdto_serv_butone(sptr, CMD_KICK, cptr, "%H %C :%s", chptr, who,
comment);
sendcmdto_channel_butserv_butone((IsServer(sptr) ? &me : sptr), CMD_KICK,
chptr, NULL, 0, "%H %C :%s", chptr, who,
comment);
make_zombie(member, who, cptr, sptr, chptr);
return 0;
}
