/* send_linebuf()
*
* inputs - client to send to, linebuf to attach
* outputs -
* side effects - linebuf is attached to client
*/
static int
_send_linebuf(struct Client *to, buf_head_t *linebuf)
{
if(IsMe(to))
{
sendto_realops_snomask(SNO_GENERAL, L_ALL, "Trying to send message to myself!");
return 0;
}
if(!MyConnect(to) || IsIOError(to))
return 0;
if(linebuf_len(&to->localClient->buf_sendq) > get_sendq(to))
{
if(IsServer(to))
{
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"Max SendQ limit exceeded for %s: %u > %lu",
get_server_name(to, HIDE_IP),
linebuf_len(&to->localClient->buf_sendq),
get_sendq(to));
ilog(L_SERVER, "Max SendQ limit exceeded for %s: %u > %lu",
log_client_name(to, SHOW_IP),
linebuf_len(&to->localClient->buf_sendq),
get_sendq(to));
}
if(IsClient(to))
to->flags |= FLAGS_SENDQEX;
dead_link(to);
return -1;
}
else
{
/* just attach the linebuf to the sendq instead of
* generating a new one
*/
linebuf_attach(&to->localClient->buf_sendq, linebuf);
}
/*
** Update statistics. The following is slightly incorrect
** because it counts messages even if queued, but bytes
** only really sent. Queued bytes get updated in SendQueued.
*/
to->localClient->sendM += 1;
me.localClient->sendM += 1;
if(linebuf_len(&to->localClient->buf_sendq) > 0)
send_queued_write(to->localClient->fd, to);
return 0;
}
/** Try to send a buffer to a client, queueing it if needed.
* @param[in,out] to Client to send message to.
* @param[in] buf Message to send.
* @param[in] prio If non-zero, send as high priority.
*/
void send_buffer(struct Client* to, struct MsgBuf* buf, int prio)
{
assert(0 != to);
assert(0 != buf);
if (cli_from(to))
to = cli_from(to);
if (!can_send(to))
/*
* This socket has already been marked as dead
*/
return;
if (MsgQLength(&(cli_sendQ(to))) > get_sendq(to)) {
if (IsServer(to))
sendto_opmask(0, SNO_OLDSNO, "Max SendQ limit exceeded for %C: %zu > %zu",
to, MsgQLength(&(cli_sendQ(to))), get_sendq(to));
dead_link(to, "Max sendQ exceeded");
return;
}
Debug((DEBUG_SEND, "Sending [%p] to %s", buf, cli_name(to)));
#if defined(USE_SSL)
if (cli_socket(to).s_ssl)
prio = 0;
#endif
msgq_add(&(cli_sendQ(to)), buf, prio);
client_add_sendq(cli_connect(to), &send_queues);
update_write(to);
/*
* Update statistics. The following is slightly incorrect
* because it counts messages even if queued, but bytes
* only really sent. Queued bytes get updated in SendQueued.
*/
++(cli_sendM(to));
++(cli_sendM(&me));
/*
* This little bit is to stop the sendQ from growing too large when
* there is no need for it to. Thus we call send_queued() every time
* 2k has been added to the queue since the last non-fatal write.
* Also stops us from deliberately building a large sendQ and then
* trying to flood that link with data (possible during the net
* relinking done by servers with a large load).
*/
if (MsgQLength(&(cli_sendQ(to))) / 1024 > cli_lastsq(to))
send_queued(to);
}
/*
* safelist_sendq_exceeded()
*
* inputs - pointer to client that needs checking
* outputs - 1 if a client has exceeded the reserved
* sendq limit, 0 if not
* side effects - none
*
* When safelisting, we only use half of the SendQ at any
* given time.
*/
static int safelist_sendq_exceeded(struct Client *client_p)
{
if (rb_linebuf_len(&client_p->localClient->buf_sendq) > (get_sendq(client_p) / 2))
return YES;
else
return NO;
}
/*
** send_message
** Internal utility which appends given buffer to the sockets
** sendq.
*/
static void
send_message(struct Client *to, char *buf, int len)
{
#ifdef INVARIANTS
if (IsMe(to))
{
sendto_realops_flags(UMODE_ALL, L_ALL,
"Trying to send message to myself!");
return;
}
#endif
if (HasUmode(to, UMODE_NOCOLOUR))
strip_colour(buf);
if (dbuf_length(&to->localClient->buf_sendq) + len > get_sendq(to))
{
if (IsServer(to))
sendto_realops_flags(UMODE_ALL, L_ALL,
"Max SendQ limit exceeded for %s: %lu > %lu",
get_client_name(to, HIDE_IP),
(unsigned long)(dbuf_length(&to->localClient->buf_sendq) + len),
get_sendq(to));
if (IsClient(to))
SetSendQExceeded(to);
dead_link_on_write(to, 0);
return;
}
dbuf_put(&to->localClient->buf_sendq, buf, len);
/*
** Update statistics. The following is slightly incorrect
** because it counts messages even if queued, but bytes
** only really sent. Queued bytes get updated in SendQueued.
*/
to->localClient->sendM += 1;
me.localClient->sendM += 1;
if (dbuf_length(&to->localClient->buf_sendq) >
(IsServer(to) ? (unsigned int) 1024 : (unsigned int) 4096))
send_queued_write(to);
}
/*
** m_whowas
** parv[1] = nickname queried
*/
static int
m_whowas(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
struct Whowas *temp;
int cur = 0;
int max = -1, found = 0;
char *p;
const char *nick;
char tbuf[26];
long sendq_limit;
static time_t last_used = 0L;
if(MyClient(source_p) && !IsOper(source_p))
{
if(last_used + (parc > 3 ? ConfigFileEntry.pace_wait :
ConfigFileEntry.pace_wait_simple
) > rb_current_time())
{
sendto_one(source_p, form_str(RPL_LOAD2HI),
me.name, source_p->name, "WHOWAS");
sendto_one(source_p, form_str(RPL_ENDOFWHOWAS),
me.name, source_p->name, parv[1]);
return 0;
}
else
last_used = rb_current_time();
}
if(parc > 2)
max = atoi(parv[2]);
if(parc > 3)
if(hunt_server(client_p, source_p, ":%s WHOWAS %s %s :%s", 3, parc, parv))
return 0;
if(!MyClient(source_p) && (max <= 0 || max > 20))
max = 20;
if((p = strchr(parv[1], ',')))
*p = '\0';
nick = parv[1];
sendq_limit = get_sendq(client_p) * 9 / 10;
temp = WHOWASHASH[hash_whowas_name(nick)];
found = 0;
for (; temp; temp = temp->next)
{
if(!irccmp(nick, temp->name))
{
if(cur > 0 && rb_linebuf_len(&client_p->localClient->buf_sendq) > sendq_limit)
{
sendto_one(source_p, form_str(ERR_TOOMANYMATCHES),
me.name, source_p->name, "WHOWAS");
break;
}
sendto_one(source_p, form_str(RPL_WHOWASUSER),
me.name, source_p->name, temp->name,
temp->username, temp->hostname, temp->realname);
if (!EmptyString(temp->sockhost) &&
strcmp(temp->sockhost, "0") &&
show_ip_whowas(temp, source_p))
#if 0
sendto_one(source_p, form_str(RPL_WHOWASREAL),
me.name, source_p->name, temp->name,
"<untracked>", temp->sockhost);
#else
sendto_one_numeric(source_p, RPL_WHOISACTUALLY,
form_str(RPL_WHOISACTUALLY),
temp->name, temp->sockhost);
#endif
if (!EmptyString(temp->suser))
sendto_one_numeric(source_p, RPL_WHOISLOGGEDIN,
"%s %s :was logged in as",
temp->name, temp->suser);
sendto_one_numeric(source_p, RPL_WHOISSERVER,
form_str(RPL_WHOISSERVER),
temp->name, temp->servername,
rb_ctime(temp->logoff, tbuf, sizeof(tbuf)));
cur++;
found++;
}
if(max > 0 && cur >= max)
break;
}
if(!found)
sendto_one(source_p, form_str(ERR_WASNOSUCHNICK),
me.name, source_p->name, nick);
sendto_one(source_p, form_str(RPL_ENDOFWHOWAS),
me.name, source_p->name, parv[1]);
return 0;
}
/*
** send_message
** Internal utility which delivers one message buffer to the
** socket. Takes care of the error handling and buffering, if
** needed.
** if ZIP_LINKS is defined, the message will eventually be compressed,
** anything stored in the sendQ is compressed.
**
** If msg is a null pointer, we are flushing connection
*/
int send_message(aClient *to, char *msg, int len)
{
int i;
Debug((DEBUG_SEND,"Sending %s %d [%s] ", to->name, to->fd, msg));
if (to->from)
to = to->from;
if (to->fd < 0)
{
Debug((DEBUG_ERROR,
"Local socket %s with negative fd... AARGH!",
to->name));
}
if (IsMe(to))
{
sendto_flag(SCH_ERROR, "Trying to send to myself! [%s]", msg);
return 0;
}
if (IsDead(to))
return 0; /* This socket has already been marked as dead */
if (DBufLength(&to->sendQ) > (i=get_sendq(to, CBurst(to))))
{
to->exitc = EXITC_SENDQ;
if (IsService(to) || IsServer(to))
{
return dead_link(to,
"Max SendQ limit exceeded for %s: %d > %d",
get_client_name(to, FALSE),
DBufLength(&to->sendQ), i);
}
return dead_link(to, "Max Sendq exceeded");
}
# ifdef ZIP_LINKS
/*
** data is first stored in to->zip->outbuf until
** it's big enough to be compressed and stored in the sendq.
** send_queued is then responsible to never let the sendQ
** be empty and to->zip->outbuf not empty.
*/
if (to->flags & FLAGS_ZIP)
msg = zip_buffer(to, msg, &len, 0);
# endif /* ZIP_LINKS */
tryagain:
if (len && (i = dbuf_put(&to->sendQ, msg, len)) < 0)
{
if (i == -2 /* Poolsize was exceeded. */
#ifdef POOLSIZE_LIMITED
/*
** Defining this retains old ircd behaviour (will
** allow client quit with buffer allocation error
** as a result of poolsize starvation). As it may
** happen to all clients on a big channel without
** their fault, I think this is not right.
** In the long run it should not matter (poolsize
** or memory usage-wise), because if client lacks
** the poolsize, the poolsize is too small anyway
** and next netburst would probably make it grow.
** IMO increasing poolsize with no limits is good
** for clients -- hence this is not defined. --B.
*/
&& CBurst(to)
#endif
)
{
/* Anyway, 10% increase. */
poolsize *= 1.1;
sendto_flag(SCH_NOTICE,
"New poolsize %u. (reached)",
poolsize);
istat.is_dbufmore++;
goto tryagain;
}
else
{
to->exitc = EXITC_MBUF;
return dead_link(to,
"Buffer allocation error for %s",
get_client_name(to, FALSE));
}
}
/*
** Update statistics. The following is slightly incorrect
** because it counts messages even if queued, but bytes
** only really sent. Queued bytes get updated in SendQueued.
*/
to->sendM += 1;
me.sendM += 1;
if (to->acpt != &me)
to->acpt->sendM += 1;
/*
** This little bit is to stop the sendQ from growing too large when
** there is no need for it to. Thus we call send_queued() every time
** 2k has been added to the queue since the last non-fatal write.
** Also stops us from deliberately building a large sendQ and then
** trying to flood that link with data (possible during the net
** relinking done by servers with a large load).
*/
if (DBufLength(&to->sendQ)/1024 > to->lastsq)
send_queued(to);
return 0;
}
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;
}
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, " ");
}
