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;
}
/** Send a (prefixed) WALL of type \a type to all users except \a one.
* @warning \a pattern must not contain %v.
* @param[in] from Source of the command.
* @param[in] type One of WALL_DESYNCH, WALL_WALLOPS or WALL_WALLUSERS.
* @param[in] one Client direction to skip (or NULL).
* @param[in] pattern Format string for command arguments.
*/
void sendwallto_group_butone(struct Client *from, int type, struct Client *one,
const char *pattern, ...)
{
struct VarData vd;
struct Client *cptr;
struct MsgBuf *mb;
struct DLink *lp;
char *prefix=NULL;
char *tok=NULL;
int his_wallops;
int i;
vd.vd_format = pattern;
/* Build buffer to send to users */
va_start(vd.vd_args, pattern);
switch (type) {
case WALL_DESYNCH:
prefix="";
tok=TOK_DESYNCH;
break;
case WALL_WALLOPS:
prefix="* ";
tok=TOK_WALLOPS;
break;
case WALL_WALLUSERS:
prefix="$ ";
tok=TOK_WALLUSERS;
break;
default:
assert(0);
}
mb = msgq_make(0, "%:#C " MSG_WALLOPS " :%s%v", from, prefix,&vd);
va_end(vd.vd_args);
/* send buffer along! */
his_wallops = feature_bool(FEAT_HIS_WALLOPS);
for (i = 0; i <= HighestFd; i++)
{
if (!(cptr = LocalClientArray[i]) ||
(cli_fd(cli_from(cptr)) < 0) ||
(type == WALL_DESYNCH && !SendDebug(cptr)) ||
(type == WALL_WALLOPS &&
(!SendWallops(cptr) || (his_wallops && !IsAnOper(cptr)))) ||
(type == WALL_WALLUSERS && !SendWallops(cptr)))
continue; /* skip it */
send_buffer(cptr, mb, 1);
}
msgq_clean(mb);
/* Build buffer to send to servers */
va_start(vd.vd_args, pattern);
mb = msgq_make(&me, "%C %s :%v", from, tok, &vd);
va_end(vd.vd_args);
/* send buffer along! */
for (lp = cli_serv(&me)->down; lp; lp = lp->next) {
if (one && lp->value.cptr == cli_from(one))
continue;
send_buffer(lp->value.cptr, mb, 1);
}
msgq_clean(mb);
}
/*
* 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);
}
