void relay_directed_message(struct Client* sptr, char* name, char* server, const char* text)
{
struct Client* acptr;
char* host;
assert(0 != sptr);
assert(0 != name);
assert(0 != text);
assert(0 != server);
if (0 == (acptr = FindServer(server + 1))) {
send_reply(sptr, ERR_NOSUCHNICK, name);
return;
}
/*
* NICK[%host]@server addressed? See if <server> is me first
*/
if (!IsMe(acptr)) {
sendcmdto_one(sptr, CMD_PRIVATE, acptr, "%s :%s", name, text);
return;
}
/*
* Look for an user whose NICK is equal to <name> and then
* check if it's hostname matches <host> and if it's a local
* user.
*/
*server = '\0';
if ((host = strchr(name, '%')))
*host++ = '\0';
/* As reported by Vampire-, it's possible to brute force finding users
* by sending a message to each server and see which one succeeded.
* This means we have to remove error reporting. Sigh. Better than
* removing the ability to send directed messages to client servers
* Thanks for the suggestion Vampire=. -- Isomer 2001-08-28
* Argh, /ping nick@server, disallow messages to non +k clients :/ I hate
* this. -- Isomer 2001-09-16
*/
if (!(acptr = FindUser(name)) || !MyUser(acptr) ||
(!EmptyString(host) && 0 != match(host, cli_user(acptr)->realhost)) ||
!IsChannelService(acptr)) {
#if 0
send_reply(sptr, ERR_NOSUCHNICK, name);
#endif
return;
}
*server = '@';
if (host)
*--host = '%';
if (!IsChannelService(sptr) && is_silenced(sptr, acptr)) {
send_reply(sptr, ERR_SILENCED, cli_name(acptr));
return;
}
if (IsOnlyreg(acptr) && !IsRegnick(sptr))
send_reply(sptr, RPL_MSGONLYREG, cli_name(acptr));
else
sendcmdto_one(sptr, CMD_PRIVATE, acptr, "%s :%s", name, text);
}
/** Handle a SERVER message from another server.
*
* \a parv has the following elements:
* \li \a parv[1] is the server name
* \li \a parv[2] is the hop count to the server
* \li \a parv[3] is the start timestamp for the server
* \li \a parv[4] is the link timestamp
* \li \a parv[5] is the protocol version (P10 or J10)
* \li \a parv[6] is the numnick mask for the server
* \li \a parv[7] is a string of flags like +hs to mark hubs and services
* \li \a parv[\a parc - 1] is the server description
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int ms_server(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
int i;
char* host;
struct Client* acptr;
struct Client* bcptr;
int hop;
int ret;
unsigned short prot;
time_t start_timestamp;
time_t timestamp;
if (parc < 8)
{
return need_more_params(sptr, "SERVER");
return exit_client(cptr, cptr, &me, "Need more parameters");
}
host = clean_servername(parv[1]);
if (!host)
{
sendto_opmask(0, SNO_OLDSNO, "Bogus server name (%s) from %s",
host, cli_name(cptr));
return exit_client_msg(cptr, cptr, &me, "Bogus server name (%s)", host);
}
/*
* Detect protocol
*/
hop = atoi(parv[2]);
start_timestamp = atoi(parv[3]);
timestamp = atoi(parv[4]);
prot = parse_protocol(parv[5]);
if (!prot)
return exit_client_msg(cptr, sptr, &me, "Bogus protocol (%s)", parv[5]);
else if (prot < atoi(MINOR_PROTOCOL))
return exit_new_server(cptr, sptr, host, timestamp,
"Incompatible protocol: %s", parv[5]);
Debug((DEBUG_INFO, "Got SERVER %s with timestamp [%s] age %Tu (%Tu)",
host, parv[4], start_timestamp, cli_serv(&me)->timestamp));
if (timestamp < OLDEST_TS)
return exit_client_msg(cptr, sptr, &me,
"Bogus timestamps (%s %s)", parv[3], parv[4]);
if (parv[parc - 1][0] == '\0')
return exit_client_msg(cptr, cptr, &me,
"No server info specified for %s", host);
ret = check_loop_and_lh(cptr, sptr, NULL, host, (parc > 7 ? parv[6] : NULL), timestamp, hop, parv[5][0] == 'J');
if (ret != 1)
return ret;
/*
* Server is informing about a new server behind
* this link. Create REMOTE server structure,
* add it to list and propagate word to my other
* server links...
*/
acptr = make_client(cptr, STAT_SERVER);
make_server(acptr);
cli_serv(acptr)->prot = prot;
cli_serv(acptr)->timestamp = timestamp;
cli_hopcount(acptr) = hop;
ircd_strncpy(cli_name(acptr), host, HOSTLEN);
ircd_strncpy(cli_info(acptr), parv[parc-1], REALLEN);
cli_serv(acptr)->up = sptr;
cli_serv(acptr)->updown = add_dlink(&(cli_serv(sptr))->down, acptr);
/* Use cptr, because we do protocol 9 -> 10 translation
for numeric nicks ! */
SetServerYXX(cptr, acptr, parv[6]);
update_uworld_flags(cptr);
if (*parv[7] == '+')
set_server_flags(acptr, parv[7] + 1);
Count_newremoteserver(UserStats);
add_client_to_list(acptr);
hAddClient(acptr);
if (*parv[5] == 'J')
{
SetBurst(acptr);
SetJunction(acptr);
for (bcptr = cli_serv(acptr)->up; !IsMe(bcptr); bcptr = cli_serv(bcptr)->up)
if (IsBurstOrBurstAck(bcptr))
break;
if (IsMe(bcptr))
sendto_opmask(0, SNO_NETWORK, "Net junction: %s %s",
cli_name(sptr), cli_name(acptr));
}
/*
* Old sendto_serv_but_one() call removed because we now need to send
* different names to different servers (domain name matching).
*/
for (i = 0; i <= HighestFd; i++)
{
if (!(bcptr = LocalClientArray[i]) || !IsServer(bcptr) ||
bcptr == cptr || IsMe(bcptr))
continue;
if (0 == match(cli_name(&me), cli_name(acptr)))
continue;
sendcmdto_one(sptr, CMD_SERVER, bcptr, "%s %d 0 %s %s %s%s +%s%s%s :%s",
cli_name(acptr), hop + 1, parv[4], parv[5],
NumServCap(acptr), IsHub(acptr) ? "h" : "",
IsService(acptr) ? "s" : "", IsIPv6(acptr) ? "6" : "",
cli_info(acptr));
}
return 0;
}
/*
*
* parc number of arguments ('sender' counted as one!)
* parv[0] pointer to 'sender' (may point to empty string) (not used)
* parv[1]..parv[parc-1]
* pointers to additional parameters, this is a NULL
* terminated list (parv[parc] == NULL).
*
* *WARNING*
* Numerics are mostly error reports. If there is something
* wrong with the message, just *DROP* it! Don't even think of
* sending back a neat error message -- big danger of creating
* a ping pong error message...
*/
static void
do_numeric(char numeric[], struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
struct Client *target_p;
struct Channel *chptr;
if(parc < 2 || !IsServer(source_p))
return;
/* Remap low number numerics. */
if(numeric[0] == '0')
numeric[0] = '1';
/*
* Prepare the parameter portion of the message into 'buffer'.
* (Because the buffer is twice as large as the message buffer
* for the socket, no overflow can occur here... ...on current
* assumptions--bets are off, if these are changed --msa)
* Note: if buffer is non-empty, it will begin with SPACE.
*/
if(parc > 1)
{
char *t = buffer; /* Current position within the buffer */
int i;
int tl; /* current length of presently being built string in t */
for (i = 2; i < (parc - 1); i++)
{
tl = ircsprintf(t, " %s", parv[i]);
t += tl;
}
ircsprintf(t, " :%s", parv[parc - 1]);
}
if((target_p = find_client(parv[1])) != NULL)
{
if(IsMe(target_p))
{
/*
* We shouldn't get numerics sent to us,
* any numerics we do get indicate a bug somewhere..
*/
/* ugh. this is here because of nick collisions. when two servers
* relink, they burst each other their nicks, then perform collides.
* if there is a nick collision, BOTH servers will kill their own
* nicks, and BOTH will kill the other servers nick, which wont exist,
* because it will have been already killed by the local server.
*
* unfortunately, as we cant guarantee other servers will do the
* "right thing" on a nick collision, we have to keep both kills.
* ergo we need to ignore ERR_NOSUCHNICK. --fl_
*/
/* quick comment. This _was_ tried. i.e. assume the other servers
* will do the "right thing" and kill a nick that is colliding.
* unfortunately, it did not work. --Dianora
*/
if(atoi(numeric) != ERR_NOSUCHNICK)
sendto_realops_flags(UMODE_ALL, L_ADMIN,
"*** %s(via %s) sent a %s numeric to me: %s",
source_p->name, client_p->name, numeric,
buffer);
return;
}
else if(target_p->from == client_p)
{
/* This message changed direction (nick collision?)
* ignore it.
*/
return;
}
/* csircd will send out unknown umode flag for +a (admin), drop it here. */
if((atoi(numeric) == ERR_UMODEUNKNOWNFLAG) && MyClient(target_p))
return;
/* Fake it for server hiding, if its our client */
if(ConfigServerHide.hide_servers && MyClient(target_p) && !IsOper(target_p))
sendto_one(target_p, ":%s %s %s%s", me.name, numeric, parv[1], buffer);
else
sendto_one(target_p, ":%s %s %s%s", source_p->name, numeric, parv[1],
buffer);
return;
}
else if((chptr = hash_find_channel(parv[1])) != NULL)
sendto_channel_local(ALL_MEMBERS, chptr,
":%s %s %s %s",
source_p->name, numeric, chptr->chname, buffer);
}
/*
* * DoNumeric (replacement for the old do_numeric) *
*
* parc number of arguments ('sender' counted as one!)
* parv[0] pointer to 'sender' (may point to empty string)
* parv[1]..parv[parc-1]
* pointers to additional parameters, this is a NULL
* terminated list (parv[parc] == NULL).
*
* *WARNING*
* Numerics are mostly error reports. If there is something
* wrong with the message, just *DROP* it! Don't even think of
* sending back a neat error message -- big danger of creating
* a ping pong error message...
*/
int do_numeric(int numeric, aClient *cptr, aClient *sptr, int parc,
char *parv[])
{
aClient *acptr;
aChannel *chptr;
char *nick, *p;
int i;
if (parc < 1 || !IsServer(sptr))
return 0;
/* Remap low number numerics. */
if (numeric < 100)
numeric += 100;
/*
* Prepare the parameter portion of the message into 'buffer'.
* (Because the buffer is twice as large as the message buffer for
* the socket, no overflow can occur here... ...on current
* assumptions--bets are off, if these are changed --msa)
* Note: if buffer is non-empty, it will begin with SPACE.
*/
buffer[0] = '\0';
if (parc > 1)
{
int bpos = 0;
char *p;
for (i = 2; i < (parc - 1); i++)
{
buffer[bpos++] = ' ';
for(p = parv[i]; *p; p++)
buffer[bpos++] = *p;
}
buffer[bpos++] = ' ';
buffer[bpos++] = ':';
for(p = parv[parc - 1]; *p; p++)
buffer[bpos++] = *p;
buffer[bpos] = '\0';
}
for (; (nick = strtoken(&p, parv[1], ",")); parv[1] = NULL)
{
if ((acptr = find_client(nick, (aClient *) NULL)))
{
int dohide;
/*
* Drop to bit bucket if for me... ...one might consider
* sendto_ops * here... --msa * And so it was done. -avalon *
* And regretted. Dont do it that way. Make sure * it goes
* only to non-servers. -avalon * Check added to make sure
* servers don't try to loop * with numerics which can happen
* with nick collisions. * - Avalon
*/
#ifdef HIDE_NUMERIC_SOURCE
dohide = MyClient(acptr) ? 1 : 0;
#else
dohide = 0;
#endif
if (!IsMe(acptr) && IsPerson(acptr))
sendto_prefix_one(acptr, dohide ? &me : sptr, ":%s %d %s%s",
dohide ? me.name : parv[0], numeric, nick, buffer);
else if (IsServer(acptr) && acptr->from != cptr)
sendto_prefix_one(acptr, sptr, ":%s %d %s%s",
parv[0], numeric, nick, buffer);
}
else if ((chptr = find_channel(nick, (aChannel *) NULL)))
{
int dohide;
#ifdef HIDE_NUMERIC_SOURCE
dohide = 1;
#else
dohide = 0;
#endif
sendto_channel_butserv(chptr, dohide ? &me : sptr, ":%s %d %s%s",
dohide ? me.name : parv[0], numeric,
chptr->chname, buffer);
sendto_channel_remote_butone(cptr, sptr, chptr,
parv[0], numeric,
chptr->chname, buffer);
}
}
return 0;
}
/** Handle a connection that has sent a valid PASS and SERVER.
* @param cptr New peer server.
* @param aconf Connect block for \a cptr.
* @return Zero.
*/
int server_estab(struct Client *cptr, struct ConfItem *aconf)
{
struct Client* acptr = 0;
const char* inpath;
int i;
assert(0 != cptr);
assert(0 != cli_local(cptr));
inpath = cli_name(cptr);
if (IsUnknown(cptr)) {
if (aconf->passwd[0])
sendrawto_one(cptr, MSG_PASS " :%s", aconf->passwd);
/*
* Pass my info to the new server
*/
sendrawto_one(cptr, MSG_SERVER " %s 1 %Tu %Tu J%s %s%s +%s6 :%s",
cli_name(&me), cli_serv(&me)->timestamp,
cli_serv(cptr)->timestamp, MAJOR_PROTOCOL, NumServCap(&me),
feature_bool(FEAT_HUB) ? "h" : "",
*(cli_info(&me)) ? cli_info(&me) : "IRCers United");
}
det_confs_butmask(cptr, CONF_SERVER);
if (!IsHandshake(cptr))
hAddClient(cptr);
SetServer(cptr);
cli_handler(cptr) = SERVER_HANDLER;
Count_unknownbecomesserver(UserStats);
SetBurst(cptr);
/* nextping = CurrentTime; */
/*
* NOTE: check for acptr->user == cptr->serv->user is necessary to insure
* that we got the same one... bleah
*/
if (cli_serv(cptr)->user && *(cli_serv(cptr))->by &&
(acptr = findNUser(cli_serv(cptr)->by))) {
if (cli_user(acptr) == cli_serv(cptr)->user) {
sendcmdto_one(&me, CMD_NOTICE, acptr, "%C :Link with %s established.",
acptr, inpath);
}
else {
/*
* if not the same client, set by to empty string
*/
acptr = 0;
*(cli_serv(cptr))->by = '\0';
}
}
sendto_opmask(acptr, SNO_OLDSNO, "Link with %s established.", inpath);
cli_serv(cptr)->up = &me;
cli_serv(cptr)->updown = add_dlink(&(cli_serv(&me))->down, cptr);
sendto_opmask(0, SNO_NETWORK, "Net junction: %s %s", cli_name(&me),
cli_name(cptr));
SetJunction(cptr);
/*
* Old sendto_serv_but_one() call removed because we now
* need to send different names to different servers
* (domain name matching) Send new server to other servers.
*/
for (i = 0; i <= HighestFd; i++)
{
if (!(acptr = LocalClientArray[i]) || !IsServer(acptr) ||
acptr == cptr || IsMe(acptr))
continue;
if (!match(cli_name(&me), cli_name(cptr)))
continue;
sendcmdto_one(&me, CMD_SERVER, acptr,
"%s 2 0 %Tu J%02u %s%s +%s%s%s :%s", cli_name(cptr),
cli_serv(cptr)->timestamp, Protocol(cptr), NumServCap(cptr),
IsHub(cptr) ? "h" : "", IsService(cptr) ? "s" : "",
IsIPv6(cptr) ? "6" : "", cli_info(cptr));
}
/* Send these as early as possible so that glined users/juped servers can
* be removed from the network while the remote server is still chewing
* our burst.
*/
gline_burst(cptr);
jupe_burst(cptr);
/*
* Pass on my client information to the new server
*
* First, pass only servers (idea is that if the link gets
* canceled because the server was already there,
* there are no NICK's to be canceled...). Of course,
* if cancellation occurs, all this info is sent anyway,
* and I guess the link dies when a read is attempted...? --msa
*
* Note: Link cancellation to occur at this point means
* that at least two servers from my fragment are building
* up connection this other fragment at the same time, it's
* a race condition, not the normal way of operation...
*/
for (acptr = &me; acptr; acptr = cli_prev(acptr)) {
/* acptr->from == acptr for acptr == cptr */
if (cli_from(acptr) == cptr)
continue;
if (IsServer(acptr)) {
const char* protocol_str;
if (Protocol(acptr) > 9)
protocol_str = IsBurst(acptr) ? "J" : "P";
else
protocol_str = IsBurst(acptr) ? "J0" : "P0";
if (0 == match(cli_name(&me), cli_name(acptr)))
continue;
sendcmdto_one(cli_serv(acptr)->up, CMD_SERVER, cptr,
"%s %d 0 %Tu %s%u %s%s +%s%s%s :%s", cli_name(acptr),
cli_hopcount(acptr) + 1, cli_serv(acptr)->timestamp,
protocol_str, Protocol(acptr), NumServCap(acptr),
IsHub(acptr) ? "h" : "", IsService(acptr) ? "s" : "",
IsIPv6(acptr) ? "6" : "", cli_info(acptr));
}
}
for (acptr = &me; acptr; acptr = cli_prev(acptr))
{
/* acptr->from == acptr for acptr == cptr */
if (cli_from(acptr) == cptr)
continue;
if (IsUser(acptr))
{
char xxx_buf[25];
char *s = umode_str(acptr);
sendcmdto_one(cli_user(acptr)->server, CMD_NICK, cptr,
"%s %d %Tu %s %s %s%s%s%s %s%s :%s",
cli_name(acptr), cli_hopcount(acptr) + 1, cli_lastnick(acptr),
cli_user(acptr)->username, cli_user(acptr)->realhost,
*s ? "+" : "", s, *s ? " " : "",
iptobase64(xxx_buf, &cli_ip(acptr), sizeof(xxx_buf), IsIPv6(cptr)),
NumNick(acptr), cli_info(acptr));
}
}
/*
* Last, send the BURST.
* (Or for 2.9 servers: pass all channels plus statuses)
*/
{
struct Channel *chptr;
for (chptr = GlobalChannelList; chptr; chptr = chptr->next)
send_channel_modes(cptr, chptr);
}
sendcmdto_one(&me, CMD_END_OF_BURST, cptr, "");
return 0;
}
void
exit_one_server(aClient *cptr, aClient *dead, aClient *from,
aClient *lcptr, char *spinfo, char *comment)
{
aClient *acptr, *next;
DLink *lp;
/* okay, this is annoying.
* first off, we need two loops.
* one: to remove all the clients.
* two: to remove all the servers.
* HOWEVER! removing a server may cause removal of more servers
* and more clients.
* and this may make our pointer to next bad. therefore, we have to restart
* the server loop each time we find a server.
* We _NEED_ two different loops: all clients must be removed "
* before the server is
* removed. Otherwise, bad things (tm) can happen.
*/
Debug((DEBUG_NOTICE, "server noquit: %s", cptr->name));
for (acptr = client; acptr; acptr = next)
{
next = acptr->next; /* we might destroy this client record
* in the loop. */
if(acptr->uplink != cptr || !IsPerson(acptr))
continue;
exit_one_client_in_split(acptr, dead, spinfo);
}
for (acptr = client; acptr; acptr = next)
{
next = acptr->next; /* we might destroy this client record in
* the loop. */
if(acptr->uplink != cptr || !IsServer(acptr))
continue;
exit_one_server(acptr, dead, from, lcptr, spinfo, comment);
next = client; /* restart the loop */
}
Debug((DEBUG_NOTICE, "done exiting server: %s", cptr->name));
for (lp = server_list; lp; lp = lp->next)
{
acptr = lp->value.cptr;
if (acptr == cptr || IsMe(acptr) ||
acptr == dead || acptr == lcptr)
continue;
/* if the server is noquit, we only want to send it
* information about 'dead'
* if it's not, this server gets split information for ALL
* dead servers.
*/
#ifdef NOQUIT
if(IsNoquit(acptr))
#endif
if(cptr != dead)
continue;
if (cptr->from == acptr) /* "upstream" squit */
sendto_one(&me, acptr, ":%s SQUIT %s :%s", from->name, cptr->name,
comment);
else
sendto_one(&me, acptr, "SQUIT %s :%s", cptr->name, comment);
}
del_from_client_hash_table(cptr->name, cptr);
hash_check_watch(cptr, RPL_LOGOFF);
remove_client_from_list(cptr);
}
/*
* handle_opers
*
* inputs - server pointer
* - client pointer
* - nick stuff to grok for opers
* - text to send if grok
* output - none
* side effects - all the traditional oper type messages are parsed here.
* i.e. "/msg #some.host."
* However, syntax has been changed.
* previous syntax "/msg #some.host.mask"
* now becomes "/msg $#some.host.mask"
* previous syntax of: "/msg $some.server.mask" remains
* This disambiguates the syntax.
*/
static void
handle_opers(int p_or_n, char *command, struct Client *client_p,
struct Client *source_p, char *nick, char *text)
{
struct Client *target_p;
char *host;
char *server;
char *s;
int count;
/*
* the following two cases allow masks in NOTICEs
* (for OPERs only)
*
* Armin, 8Jun90 ([email protected])
*/
if(*nick == '$')
{
if((*(nick+1) == '$' || *(nick+1) == '#'))
nick++;
else if(MyOper(source_p))
{
sendto_one(source_p,
":%s NOTICE %s :The command %s %s is no longer supported, please use $%s",
me.name, source_p->name, command, nick, nick);
return;
}
if ((s = strrchr(nick, '.')) == NULL)
{
sendto_one(source_p, form_str(source_p,ERR_NOTOPLEVEL),
me.name, source_p->name, nick);
return;
}
while (*++s)
if (*s == '.' || *s == '*' || *s == '?')
break;
if (*s == '*' || *s == '?')
{
sendto_one(source_p, form_str(source_p,ERR_WILDTOPLEVEL),
me.name, source_p->name, nick);
return;
}
sendto_match_butone(IsServer(client_p) ? client_p : NULL, source_p,
nick + 1,
(*nick == '#') ? MATCH_HOST : MATCH_SERVER,
"%s $%s :%s", command, nick, text);
if ((p_or_n != NOTICE) && source_p->user)
source_p->user->last = CurrentTime;
return;
}
/*
* user[%host]@server addressed?
*/
if ((server = strchr(nick, '@')) && (target_p = find_server(server + 1)))
{
count = 0;
/*
* Not destined for a user on me :-(
*/
if (!IsMe(target_p))
{
sendto_one(target_p, ":%s %s %s :%s", source_p->name,
command, nick, text);
if ((p_or_n != NOTICE) && source_p->user)
source_p->user->last = CurrentTime;
return;
}
*server = '\0';
if ((host = strchr(nick, '%')) != NULL)
*host++ = '\0';
/* Check if someones msg'ing [email protected] */
if (strcmp(nick, "opers") == 0)
{
sendto_realops_flags(FLAGS_ALL, L_ALL, "To opers: From: %s: %s",
source_p->name, text);
return;
}
/*
* Look for users which match the destination host
* (no host == wildcard) and if one and one only is
* found connected to me, deliver message!
*/
target_p = find_userhost(nick, host, &count);
if (target_p != NULL)
{
if (server != NULL)
*server = '@';
if (host != NULL)
*--host = '%';
if (count == 1)
{
sendto_anywhere(target_p, source_p, "%s %s :%s", command,
nick, text);
if ((p_or_n != NOTICE) && source_p->user)
source_p->user->last = CurrentTime;
}
else
sendto_one(source_p, form_str(source_p,ERR_TOOMANYTARGETS),
me.name, source_p->name, nick);
}
}
else if (server && *(server+1) && (target_p == NULL))
sendto_one(source_p, form_str(source_p,ERR_NOSUCHSERVER), me.name,
source_p->name, server+1);
else if (server && (target_p == NULL))
sendto_one(source_p, form_str(source_p,ERR_NOSUCHNICK), me.name,
source_p->name, nick);
}
/*
* mo_jupe - oper message handler
*
* parv[0] = Send prefix
* parv[1] = [[+|-]<server name>]
*
* Local (to me) style:
*
* parv[2] = [Expiration offset]
* parv[3] = [Comment]
*
* Global (or remote local) style:
*
* parv[2] = [target]
* parv[3] = [Expiration offset]
* parv[4] = [Comment]
*
*/
int mo_jupe(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Client *acptr = 0;
struct Jupe *ajupe;
unsigned int flags = 0;
time_t expire_off;
char *server = parv[1], *target = 0, *reason;
if (parc < 2)
return jupe_list(sptr, 0);
if (*server == '+') {
flags |= JUPE_ACTIVE;
server++;
} else if (*server == '-')
server++;
else
return jupe_list(sptr, server);
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "JUPE");
if (parc == 4) {
expire_off = atoi(parv[2]);
reason = parv[3];
flags |= JUPE_LOCAL;
} else if (parc > 4) {
target = parv[2];
expire_off = atoi(parv[3]);
reason = parv[4];
} else
return need_more_params(sptr, "JUPE");
if (target) {
if (!(target[0] == '*' && target[1] == '\0')) {
if (!(acptr = find_match_server(target)))
return send_reply(sptr, ERR_NOSUCHSERVER, target);
if (!IsMe(acptr)) { /* manually propagate, since we don't set it */
if (!HasPriv(sptr, PRIV_JUPE))
return send_reply(sptr, ERR_NOPRIVILEGES);
sendcmdto_one(sptr, CMD_JUPE, acptr, "%C %c%s %s %Tu :%s", acptr,
flags & JUPE_ACTIVE ? '+' : '-', server, parv[3],
TStime(), reason);
return 0;
} else if (!HasPriv(sptr, PRIV_LOCAL_JUPE))
return send_reply(sptr, ERR_NOPRIVILEGES);
flags |= JUPE_LOCAL;
} else if (!HasPriv(sptr, PRIV_JUPE))
return send_reply(sptr, ERR_NOPRIVILEGES);
}
ajupe = jupe_find(server);
if (ajupe) {
if (JupeIsLocal(ajupe) && !(flags & JUPE_LOCAL)) /* global over local */
jupe_free(ajupe);
else {
if (flags & JUPE_ACTIVE)
return jupe_activate(cptr, sptr, ajupe, TStime(), flags);
else
return jupe_deactivate(cptr, sptr, ajupe, TStime(), flags);
}
}
return jupe_add(cptr, sptr, server, reason, expire_off, TStime(), flags);
}
/** Reset a feature to its default values.
* @param[in] from Client trying to reset the feature, or NULL.
* @param[in] fields Parameters to set, starting with feature name.
* @param[in] count Number of fields in \a fields.
* @return Zero (or, theoretically, CPTR_KILLED).
*/
int
feature_reset(struct Client* from, const char* const* fields, int count)
{
int i, change = 0;
struct FeatureDesc *feat;
assert(0 != from);
if (!HasPriv(from, PRIV_SET))
return send_reply(from, ERR_NOPRIVILEGES);
if (count < 1) /* check arguments */
need_more_params(from, "RESET");
else if ((feat = feature_desc(from, fields[0]))) { /* get descriptor */
if (from && feat->flags & FEAT_READ)
return send_reply(from, ERR_NOFEATURE, fields[0]);
switch (feat_type(feat)) {
case FEAT_NONE: /* None... */
if (feat->reset && (i = (*feat->reset)(from, fields + 1, count - 1))) {
change++; /* feature handler wants a change recorded */
if (i > 0) /* call reset callback and parse mark return */
feat->flags |= FEAT_MARK;
else /* i < 0 */
feat->flags &= ~FEAT_MARK;
}
break;
case FEAT_INT: /* Integer... */
case FEAT_UINT:
case FEAT_BOOL: /* Boolean... */
if (feat->v_int != feat->def_int)
change++; /* change will be made */
feat->v_int = feat->def_int; /* set the default */
feat->flags &= ~FEAT_MARK; /* unmark it */
break;
case FEAT_STR: /* string! */
if (feat->v_str != feat->def_str) {
change++; /* change has been made */
if (feat->v_str)
MyFree(feat->v_str); /* free old value */
}
feat->v_str = feat->def_str; /* set it to default */
feat->flags &= ~FEAT_MARK; /* unmark it */
break;
}
if (change && feat->notify) /* call change notify function */
(*feat->notify)();
if(from && !IsServer(from) && !IsMe(from))
send_reply(from, SND_EXPLICIT | RPL_FEATURE, ":Value of %s reset to "
"default", feat->type);
if(change)
sendto_opmask_butone(0, SNO_OLDSNO, "%C reset %s to its default",
from, feat->type);
}
return 0;
}
void CSkypeProto::OnChatEvent(const JSONNode &node)
{
//std::string clientMsgId = node["clientmessageid"].as_string();
//std::string skypeEditedId = node["skypeeditedid"].as_string();
std::string fromLink = node["from"].as_string();
CMStringA from(ContactUrlToName(fromLink.c_str()));
time_t timestamp = IsoToUnixTime(node["composetime"].as_string().c_str());
std::string content = node["content"].as_string();
int emoteOffset = node["skypeemoteoffset"].as_int();
std::string conversationLink = node["conversationLink"].as_string();
CMStringA chatname(ChatUrlToName(conversationLink.c_str()));
CMString topic(node["threadtopic"].as_mstring());
if (FindChatRoom(chatname) == NULL)
SendRequest(new GetChatInfoRequest(m_szRegToken, chatname, m_szServer), &CSkypeProto::OnGetChatInfo, topic.Detach());
std::string messageType = node["messagetype"].as_string();
if (!mir_strcmpi(messageType.c_str(), "Text") || !mir_strcmpi(messageType.c_str(), "RichText"))
{
AddMessageToChat(_A2T(chatname), _A2T(from), content.c_str(), emoteOffset != NULL, emoteOffset, timestamp);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/AddMember"))
{
ptrA xinitiator, xtarget, initiator;
//content = <addmember><eventtime>1429186229164</eventtime><initiator>8:initiator</initiator><target>8:user</target></addmember>
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("addmember"));
if (xml == NULL)
return;
for (int i = 0; i < xmlGetChildCount(xml); i++)
{
HXML xmlNode = xmlGetNthChild(xml, L"target", i);
if (xmlNode == NULL)
break;
xtarget = mir_t2a(xmlGetText(xmlNode));
CMStringA target = ParseUrl(xtarget, "8:");
AddChatContact(_A2T(chatname), target, target, L"User");
}
xmlDestroyNode(xml);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/DeleteMember"))
{
ptrA xinitiator, xtarget;
//content = <addmember><eventtime>1429186229164</eventtime><initiator>8:initiator</initiator><target>8:user</target></addmember>
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("deletemember"));
if (xml != NULL) {
HXML xmlNode = xmlGetChildByPath(xml, _T("initiator"), 0);
xinitiator = node != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlNode = xmlGetChildByPath(xml, _T("target"), 0);
xtarget = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlDestroyNode(xml);
}
if (xtarget == NULL)
return;
CMStringA target = ParseUrl(xtarget, "8:");
CMStringA initiator = ParseUrl(xinitiator, "8:");
RemoveChatContact(_A2T(chatname), target, target, true, initiator);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/TopicUpdate"))
{
//content=<topicupdate><eventtime>1429532702130</eventtime><initiator>8:user</initiator><value>test topic</value></topicupdate>
ptrA xinitiator, value;
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("topicupdate"));
if (xml != NULL) {
HXML xmlNode = xmlGetChildByPath(xml, _T("initiator"), 0);
xinitiator = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlNode = xmlGetChildByPath(xml, _T("value"), 0);
value = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlDestroyNode(xml);
}
CMStringA initiator = ParseUrl(xinitiator, "8:");
RenameChat(chatname, value);
ChangeChatTopic(chatname, value, initiator);
}
else if (!mir_strcmpi(messageType.c_str(), "ThreadActivity/RoleUpdate"))
{
//content=<roleupdate><eventtime>1429551258363</eventtime><initiator>8:user</initiator><target><id>8:user1</id><role>admin</role></target></roleupdate>
ptrA xinitiator, xId, xRole;
HXML xml = xmlParseString(ptrT(mir_a2t(content.c_str())), 0, _T("roleupdate"));
if (xml != NULL) {
HXML xmlNode = xmlGetChildByPath(xml, _T("initiator"), 0);
xinitiator = xmlNode != NULL ? mir_t2a(xmlGetText(xmlNode)) : NULL;
xmlNode = xmlGetChildByPath(xml, _T("target"), 0);
if (xmlNode != NULL)
{
HXML xmlId = xmlGetChildByPath(xmlNode, _T("id"), 0);
HXML xmlRole = xmlGetChildByPath(xmlNode, _T("role"), 0);
xId = xmlId != NULL ? mir_t2a(xmlGetText(xmlId)) : NULL;
xRole = xmlRole != NULL ? mir_t2a(xmlGetText(xmlRole)) : NULL;
}
xmlDestroyNode(xml);
CMStringA initiator = ParseUrl(xinitiator, "8:");
CMStringA id = ParseUrl(xId, "8:");
GCDEST gcd = { m_szModuleName, _A2T(chatname), !mir_strcmpi(xRole, "Admin") ? GC_EVENT_ADDSTATUS : GC_EVENT_REMOVESTATUS };
GCEVENT gce = { sizeof(gce), &gcd };
ptrT tszId(mir_a2t(id));
ptrT tszRole(mir_a2t(xRole));
ptrT tszInitiator(mir_a2t(initiator));
gce.pDest = &gcd;
gce.dwFlags = GCEF_ADDTOLOG;
gce.ptszNick = tszId;
gce.ptszUID = tszId;
gce.ptszText = tszInitiator;
gce.time = time(NULL);
gce.bIsMe = IsMe(id);
gce.ptszStatus = TranslateT("Admin");
CallServiceSync(MS_GC_EVENT, 0, (LPARAM)&gce);
}
}
}
void CSkypeProto::OnGetServerHistory(const NETLIBHTTPREQUEST *response)
{
if (response == NULL)
return;
JSONNode root = JSONNode::parse(response->pData);
if (!root)
return;
const JSONNode &metadata = root["_metadata"];
const JSONNode &conversations = root["messages"].as_array();
int totalCount = metadata["totalCount"].as_int();
std::string syncState = metadata["syncState"].as_string();
bool markAllAsUnread = getBool("MarkMesUnread", true);
if (totalCount >= 99 || conversations.size() >= 99)
PushRequest(new GetHistoryOnUrlRequest(syncState.c_str(), li), &CSkypeProto::OnGetServerHistory);
for (int i = (int)conversations.size(); i >= 0; i--)
{
const JSONNode &message = conversations.at(i);
CMStringA szMessageId = message["clientmessageid"] ? message["clientmessageid"].as_string().c_str() : message["skypeeditedid"].as_string().c_str();
std::string messageType = message["messagetype"].as_string();
std::string from = message["from"].as_string();
std::string content = message["content"].as_string();
std::string conversationLink = message["conversationLink"].as_string();
int emoteOffset = message["skypeemoteoffset"].as_int();
time_t timestamp = IsoToUnixTime(message["composetime"].as_string().c_str());
CMStringA skypename(UrlToSkypename(from.c_str()));
bool isEdited = message["skypeeditedid"];
MCONTACT hContact = FindContact(UrlToSkypename(conversationLink.c_str()));
if (timestamp > db_get_dw(hContact, m_szModuleName, "LastMsgTime", 0))
db_set_dw(hContact, m_szModuleName, "LastMsgTime", (DWORD)timestamp);
int iFlags = DBEF_UTF;
if (!markAllAsUnread)
iFlags |= DBEF_READ;
if (IsMe(skypename))
iFlags |= DBEF_SENT;
if (strstr(conversationLink.c_str(), "/8:"))
{
if (messageType == "Text" || messageType == "RichText")
{
ptrA szMessage(messageType == "RichText" ? RemoveHtml(content.c_str()) : mir_strdup(content.c_str()));
MEVENT dbevent = GetMessageFromDb(hContact, szMessageId);
if (isEdited && dbevent != NULL)
{
AppendDBEvent(hContact, dbevent, szMessage, szMessageId, timestamp);
}
else AddDbEvent(emoteOffset == 0 ? EVENTTYPE_MESSAGE : SKYPE_DB_EVENT_TYPE_ACTION, hContact, timestamp, iFlags, &szMessage[emoteOffset], szMessageId);
}
else if (messageType == "Event/Call")
{
AddDbEvent(SKYPE_DB_EVENT_TYPE_CALL_INFO, hContact, timestamp, iFlags, content.c_str(), szMessageId);
}
else if (messageType == "RichText/Files")
{
AddDbEvent(SKYPE_DB_EVENT_TYPE_FILETRANSFER_INFO, hContact, timestamp, iFlags, content.c_str(), szMessageId);
}
else if (messageType == "RichText/UriObject")
{
AddDbEvent(SKYPE_DB_EVENT_TYPE_URIOBJ, hContact, timestamp, iFlags, content.c_str(), szMessageId);
}
else if (messageType == "RichText/Contacts")
{
ProcessContactRecv(hContact, timestamp, content.c_str(), szMessageId);
}
else
{
AddDbEvent(SKYPE_DB_EVENT_TYPE_UNKNOWN, hContact, timestamp, iFlags, content.c_str(), szMessageId);
}
}
else if (conversationLink.find("/19:") != -1)
{
CMStringA chatname(UrlToSkypename(conversationLink.c_str()));
if (messageType == "Text" || messageType == "RichText")
{
AddMessageToChat(_A2T(chatname), _A2T(skypename), content.c_str(), emoteOffset != NULL, emoteOffset, timestamp, true);
}
}
}
}
/*
** DoNumeric (replacement for the old do_numeric)
**
** parc number of arguments ('sender' counted as one!)
** parv[0] pointer to 'sender' (may point to empty string) (not used)
** parv[1]..parv[parc-1]
** pointers to additional parameters, this is a NULL
** terminated list (parv[parc] == NULL).
**
** *WARNING*
** Numerics are mostly error reports. If there is something
** wrong with the message, just *DROP* it! Don't even think of
** sending back a neat error message -- big danger of creating
** a ping pong error message...
*/
int do_numeric(int numeric, aClient *cptr, aClient *sptr, int parc, char *parv[])
{
aClient *acptr;
aChannel *chptr;
char *nick, *p;
int i;
/* Is this an outgoing connect, and we get a numeric 451 (not registered) back for the
* magic command __PANGPANG__ and we did not send a SERVER message yet?
* Then this means we are dealing with an Unreal server <3.2.9 and we should send the
* SERVER command right now.
*/
if (!IsServer(sptr) && !IsPerson(sptr) && (numeric == 451) && (parc > 2) && strstr(parv[1], "__PANGPANG__") &&
IsHandshake(cptr) && sptr->serv && !IsServerSent(sptr))
{
send_server_message(sptr);
return 0;
}
if (parc < 1 || !IsServer(sptr))
return 0;
/* Remap low number numerics. */
if (numeric < 100)
numeric += 100;
/*
** Prepare the parameter portion of the message into 'buffer'.
** (Because the buffer is twice as large as the message buffer
** for the socket, no overflow can occur here... ...on current
** assumptions--bets are off, if these are changed --msa)
** Note: if buffer is non-empty, it will begin with SPACE.
*/
buffer[0] = '\0';
if (parc > 2)
{
/*
* For strlcat nazis, please read above
*/
for (i = 2; i < (parc - 1); i++)
{
(void)strcat(buffer, " ");
(void)strcat(buffer, parv[i]);
}
(void)strcat(buffer, " :");
(void)strcat(buffer, parv[parc - 1]);
}
else
sendto_realops("do_numeric( %i, %s, %s, %i, { %s, %s } )!",
numeric, cptr->name, sptr->name, parc,
parv[0], parv[1] ? parv[1] : "<null>");
for (; (nick = strtoken(&p, parv[1], ",")); parv[1] = NULL)
{
if ((acptr = find_client(nick, (aClient *)NULL)))
{
/*
** Drop to bit bucket if for me...
** ...one might consider sendto_ops
** here... --msa
** And so it was done. -avalon
** And regretted. Dont do it that way. Make sure
** it goes only to non-servers. -avalon
** Check added to make sure servers don't try to loop
** with numerics which can happen with nick collisions.
** - Avalon
*/
if (!IsMe(acptr) && IsPerson(acptr))
{
/* Added for .U3.2. drop remote 'You are not on
** that channel', we should be synced anyway,
** and this is an annoying message with TSpre7
** still on the net; would result in numeric 442 for
** every KICK... Can be removed when TSpre7 is gone.
** --Run
if (numeric==ERR_NOTONCHANNEL) return 0;
*/
sendto_prefix_one(acptr, sptr, ":%s %d %s%s",
parv[0], numeric, nick, buffer);
}
else if (IsServer(acptr) && acptr->from != cptr)
sendto_prefix_one(acptr, sptr, ":%s %d %s%s",
parv[0], numeric, nick, buffer);
}
else if ((acptr = find_server_quick(nick)))
{
if (!IsMe(acptr) && acptr->from != cptr)
sendto_prefix_one(acptr, sptr, ":%s %d %s%s",
parv[0], numeric, nick, buffer);
}
else if ((chptr = find_channel(nick, (aChannel *)NULL)))
sendto_channel_butone(cptr, sptr, chptr, ":%s %d %s%s",
parv[0], numeric, chptr->chname, buffer);
}
return 0;
}
static time_t
check_pings(time_t currenttime)
{
aClient *cptr;
aConfItem *aconf = (aConfItem *) NULL;
int killflag, zkillflag, ping = 0, i;
time_t oldest = 0; /* timeout removed, see EXPLANATION below */
char *reason, *ktype, fbuf[512];
char *errtxt = "No response from %s, closing link";
for (i = 0; i <= highest_fd; i++)
{
if (!(cptr = local[i]) || IsMe(cptr) || IsLog(cptr))
continue;
/* Note: No need to notify opers here. It's
* already done when "FLAGS_DEADSOCKET" is set.
*/
if (cptr->flags & FLAGS_DEADSOCKET)
{
(void) exit_client(cptr, cptr, &me, (cptr->flags & FLAGS_SENDQEX) ?
"SendQ exceeded" : "Dead socket");
i--;
continue;
}
killflag = NO;
zkillflag = NO;
if (rehashed)
{
if (zline_in_progress)
{
if (IsPerson(cptr))
{
if ((aconf = find_zkill(cptr)))
zkillflag = YES;
}
}
else
{
if(IsPerson(cptr))
{
if((aconf = find_kill(cptr)))
killflag = YES;
}
}
}
/* Added a bit of code here to differentiate
* between K and Z-lines. -ThemBones
*/
if (zkillflag || killflag)
{
ktype = zkillflag ? "Z-lined" :
((aconf->status == CONF_KILL) ? "K-lined" : "Autokilled");
if (killflag)
{
sendto_ops("%s active for %s",
(aconf->status == CONF_KILL) ? "K-line" : "Autokill",
get_client_name(cptr, FALSE));
reason = aconf->passwd ? aconf->passwd : ktype;
}
else
{ /* its a Z line */
sendto_ops("Z-line active for %s",
get_client_name(cptr, FALSE));
reason = aconf->passwd ? aconf->passwd : "Z-lined";
}
sendto_one(cptr, err_str(ERR_YOUREBANNEDCREEP),
me.name, cptr->name, ktype);
ircsprintf(fbuf, "%s: %s", ktype, reason);
(void) exit_client(cptr, cptr, &me, fbuf);
i--; /* subtract out this fd so we check it again.. */
continue;
}
if (IsRegistered(cptr))
ping = cptr->pingval;
else
ping = CONNECTTIMEOUT;
/*
* Ok, so goto's are ugly and can be avoided here but this code
* is already indented enough so I think its justified. -avalon
*
* justified by what? laziness? <g>
* If the client pingtime is fine (ie, not larger than the client ping)
* skip over all the checks below. - lucas
*/
if (ping < (currenttime - cptr->lasttime))
{
/*
* If the server hasnt talked to us in 2*ping seconds and it has
* a ping time, then close its connection. If the client is a
* user and a KILL line was found to be active, close this
* connection too.
*/
if (((cptr->flags & FLAGS_PINGSENT) && ((currenttime - cptr->lasttime) >= (2 * ping))) ||
((!IsRegistered(cptr) && (currenttime - cptr->since) >= ping)))
{
if (!IsRegistered(cptr) && (DoingDNS(cptr) || DoingAuth(cptr)))
{
if (cptr->authfd >= 0)
{
(void) close(cptr->authfd);
cptr->authfd = -1;
cptr->count = 0;
*cptr->buffer = '\0';
}
#ifdef SHOW_HEADERS
if (DoingDNS(cptr))
ssl_send(cptr, REPORT_FAIL_DNS, R_fail_dns, 0);
if (DoingAuth(cptr))
ssl_send(cptr, REPORT_FAIL_ID, R_fail_id, 0);
#endif
Debug((DEBUG_NOTICE, "DNS/AUTH timeout %s",
get_client_name(cptr, TRUE)));
del_queries((char *) cptr);
ClearAuth(cptr);
ClearDNS(cptr);
SetAccess(cptr);
cptr->since = currenttime;
continue;
}
if (IsServer(cptr) || IsConnecting(cptr) || IsHandshake(cptr))
{
ircsprintf(fbuf, "from %s: %s", me.name, errtxt);
sendto_gnotice(fbuf, get_client_name(cptr, HIDEME));
ircsprintf(fbuf, ":%s GNOTICE :%s", me.name, errtxt);
sendto_serv_butone(cptr, fbuf, get_client_name(cptr, HIDEME));
}
(void) exit_client(cptr, cptr, &me, "Ping timeout");
i--; /* subtract out this fd so we check it again.. */
continue;
} /* don't send pings during a burst, as we send them already. */
else if (!(cptr->flags & (FLAGS_PINGSENT|FLAGS_BURST))) {
/*
* if we havent PINGed the connection and we havent heard from
* it in a while, PING it to make sure it is still alive.
*/
cptr->flags |= FLAGS_PINGSENT;
/*
* not nice but does the job
*/
cptr->lasttime = currenttime - ping;
sendto_one(cptr, "PING :%s", me.name);
}
}
/* see EXPLANATION below
*
* timeout = cptr->lasttime + ping;
* while (timeout <= currenttime)
* timeout += ping;
* if (timeout < oldest || !oldest)
* oldest = timeout;
*/
/*
* Check UNKNOWN connections - if they have been in this state
* for > 100s, close them.
*/
if (IsUnknown(cptr))
if (cptr->firsttime ? ((timeofday - cptr->firsttime) > 100) : 0)
(void) exit_client(cptr, cptr, &me, "Connection Timed Out");
}
rehashed = 0;
zline_in_progress = 0;
/* EXPLANATION
* on a server with a large volume of clients, at any given point
* there may be a client which needs to be pinged the next second,
* or even right away (a second may have passed while running
* check_pings). Preserving CPU time is more important than
* pinging clients out at exact times, IMO. Therefore, I am going to make
* check_pings always return currenttime + 9. This means that it may take
* a user up to 9 seconds more than pingfreq to timeout. Oh well.
* Plus, the number is 9 to 'stagger' our check_pings calls out over
* time, to avoid doing it and the other tasks ircd does at the same time
* all the time (which are usually done on intervals of 5 seconds or so).
* - lucas
*
* if (!oldest || oldest < currenttime)
* oldest = currenttime + PINGFREQUENCY;
*/
oldest = currenttime + 9;
Debug((DEBUG_NOTICE, "Next check_ping() call at: %s, %d %d %d",
myctime(oldest), ping, oldest, currenttime));
return oldest;
}
/*
** 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;
}
static int
do_server_estab(aClient *cptr)
{
aClient *acptr;
aConnect *aconn;
aChannel *chptr;
int i;
/* "refresh" inpath with host */
char *inpath = get_client_name(cptr, HIDEME);
SetServer(cptr);
Count.unknown--;
Count.server++;
Count.myserver++;
if(IsZipCapable(cptr) && DoZipThis(cptr))
{
sendto_one(cptr, "SVINFO ZIP");
SetZipOut(cptr);
cptr->serv->zip_out = zip_create_output_session();
}
#ifdef MAXBUFFERS
/* let's try to bump up server sock_opts... -Taner */
reset_sock_opts(cptr->fd, 1);
#endif
/* adds to server list */
add_to_list(&server_list, cptr);
set_effective_class(cptr);
/* Check one more time for good measure... is it there? */
if ((acptr = find_name(cptr->name, NULL)))
{
char nbuf[HOSTLEN * 2 + USERLEN + 5];
aClient *bcptr;
/*
* While negotiating stuff, another copy of this server appeared.
*
* Rather than KILL the link which introduced it, KILL the
* youngest of the two links. -avalon
*/
bcptr = (cptr->firsttime > acptr->from->firsttime) ? cptr :
acptr->from;
sendto_one(bcptr, "ERROR :Server %s already exists", cptr->name);
if (bcptr == cptr)
{
sendto_gnotice("from %s: Link %s cancelled, server %s already "
"exists (final phase)", me.name,
get_client_name(bcptr, HIDEME), cptr->name);
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, "
"server %s already exists (final phase)",
me.name, get_client_name(bcptr, HIDEME),
cptr->name);
return exit_client(bcptr, bcptr, &me,
"Server Exists (final phase)");
}
/* inform all those who care (set +n) -epi */
strcpy(nbuf, get_client_name(bcptr, HIDEME));
sendto_gnotice("from %s: Link %s cancelled, server %s reintroduced "
"by %s (final phase)", me.name, nbuf, cptr->name,
get_client_name(cptr, HIDEME));
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, server %s "
"reintroduced by %s (final phase)", me.name, nbuf,
cptr->name, get_client_name(cptr, HIDEME));
exit_client(bcptr, bcptr, &me, "Server Exists (final phase)");
}
/* error, error, error! if a server is U:'d, and it connects to us,
* we need to figure that out! So, do it here. - lucas
*/
if (find_aUserver(cptr->name))
{
Count.myulined++;
cptr->flags |= FLAGS_ULINE;
/* If the server has special u:line flags, let's set them.. */
cptr->serv->uflags = cptr->serv->aconn->uflags;
}
fakelinkserver_update(cptr->name, cptr->info);
sendto_gnotice("from %s: Link with %s established, states:%s%s%s%s",
me.name, inpath, ZipOut(cptr) ? " Output-compressed" : "",
RC4EncLink(cptr) ? " encrypted" : "",
IsULine(cptr) ? " ULined" : "",
DoesTS(cptr) ? " TS" : " Non-TS");
/*
* Notify everyone of the fact that this has just linked: the entire
* network should get two of these, one explaining the link between
* me->serv and the other between serv->me
*/
sendto_serv_butone(NULL, ":%s GNOTICE :Link with %s established: %s",
me.name, inpath,
DoesTS(cptr) ? "TS link" : "Non-TS link!");
add_to_client_hash_table(cptr->name, cptr);
/* add it to scache */
find_or_add(cptr->name);
/*
* Old sendto_serv_but_one() call removed because we now need to
* send different names to different servers (domain name
* matching) Send new server to other servers.
*/
for (i = 0; i <= highest_fd; i++)
{
if (!(acptr = local[i]) || !IsServer(acptr) || acptr == cptr ||
IsMe(acptr))
continue;
if ((aconn = acptr->serv->aconn) &&
!match(my_name_for_link(me.name, aconn), cptr->name))
continue;
sendto_one(acptr, ":%s SERVER %s 2 :%s", me.name, cptr->name,
cptr->info);
}
/*
* Pass on my client information to the new server
*
* First, pass only servers (idea is that if the link gets
* cancelled beacause the server was already there, there are no
* NICK's to be cancelled...). Of course, if cancellation occurs,
* all this info is sent anyway, and I guess the link dies when a
* read is attempted...? --msa
*
* Note: Link cancellation to occur at this point means that at
* least two servers from my fragment are building up connection
* this other fragment at the same time, it's a race condition,
* not the normal way of operation...
*
* ALSO NOTE: using the get_client_name for server names-- see
* previous *WARNING*!!! (Also, original inpath is
* destroyed...)
*/
aconn = cptr->serv->aconn;
for (acptr = &me; acptr; acptr = acptr->prev)
{
if (acptr->from == cptr)
continue;
if (IsServer(acptr))
{
if (match(my_name_for_link(me.name, aconn), acptr->name) == 0)
continue;
sendto_one(cptr, ":%s SERVER %s %d :%s",
acptr->serv->up, acptr->name,
acptr->hopcount + 1, acptr->info);
}
}
/* send out our SQLINES and SGLINES too */
send_simbans(cptr, SBAN_CHAN|SBAN_NETWORK);
send_simbans(cptr, SBAN_NICK|SBAN_NETWORK);
send_simbans(cptr, SBAN_GCOS|SBAN_NETWORK);
/* Send out fake server list and other 'fake' stuff */
fakeserver_sendserver(cptr);
/* Send UHM (user host-masking) type */
if(confopts & FLAGS_HUB)
sendto_one(cptr, "SVSUHM %d", uhm_type);
/* send clone list */
clones_send(cptr);
/* Bursts are about to start.. send a BURST */
if (IsBurst(cptr))
sendto_one(cptr, "BURST");
/*
* * Send it in the shortened format with the TS, if it's a TS
* server; walk the list of channels, sending all the nicks that
* haven't been sent yet for each channel, then send the channel
* itself -- it's less obvious than sending all nicks first, but
* on the receiving side memory will be allocated more nicely
* saving a few seconds in the handling of a split -orabidoo
*/
{
chanMember *cm;
static char nickissent = 1;
nickissent = 3 - nickissent;
/*
* flag used for each nick to check if we've sent it yet - must
* be different each time and !=0, so we alternate between 1 and
* 2 -orabidoo
*/
for (chptr = channel; chptr; chptr = chptr->nextch)
{
for (cm = chptr->members; cm; cm = cm->next)
{
acptr = cm->cptr;
if (acptr->nicksent != nickissent)
{
acptr->nicksent = nickissent;
if (acptr->from != cptr)
sendnick_TS(cptr, acptr);
}
}
send_channel_modes(cptr, chptr);
}
/* also send out those that are not on any channel */
for (acptr = &me; acptr; acptr = acptr->prev)
if (acptr->nicksent != nickissent)
{
acptr->nicksent = nickissent;
if (acptr->from != cptr)
sendnick_TS(cptr, acptr);
}
}
if(confopts & FLAGS_HUB)
fakelusers_sendlock(cptr);
if(ZipOut(cptr))
{
unsigned long inb, outb;
double rat;
zip_out_get_stats(cptr->serv->zip_out, &inb, &outb, &rat);
if(inb)
{
sendto_gnotice("from %s: Connect burst to %s: %lu bytes normal, "
"%lu compressed (%3.2f%%)", me.name,
get_client_name(cptr, HIDEME), inb, outb, rat);
sendto_serv_butone(cptr, ":%s GNOTICE :Connect burst to %s: %lu "
"bytes normal, %lu compressed (%3.2f%%)",
me.name, get_client_name(cptr, HIDEME), inb,
outb, rat);
}
}
/* stuff a PING at the end of this burst so we can figure out when
the other side has finished processing it. */
cptr->flags |= FLAGS_BURST|FLAGS_PINGSENT;
if (IsBurst(cptr)) cptr->flags |= FLAGS_SOBSENT;
sendto_one(cptr, "PING :%s", me.name);
return 0;
}
/** Given a feature vector string, set the value of a feature.
* @param[in] from Client trying to set the feature, or NULL.
* @param[in] fields Parameters to set, starting with feature name.
* @param[in] count Number of fields in \a fields.
* @return Zero (or, theoretically, CPTR_KILLED).
*/
int
feature_set(struct Client* from, const char* const* fields, int count)
{
int i, change = 0, tmp;
const char *t_str;
struct FeatureDesc *feat;
if (from && !HasPriv(from, PRIV_SET) && !IsServer(from))
return send_reply(from, ERR_NOPRIVILEGES);
if (count < 1) {
if (from) /* report an error in the number of arguments */
need_more_params(from, "SET");
else
log_write(LS_CONFIG, L_ERROR, 0, "Not enough fields in F line");
} else if ((feat = feature_desc(from, fields[0]))) { /* find feature */
if (from && feat->flags & FEAT_READ)
return send_reply(from, ERR_NOFEATURE, fields[0]);
switch (feat_type(feat)) {
case FEAT_NONE:
if (feat->set && (i = (*feat->set)(from, fields + 1, count - 1))) {
change++; /* feature handler wants a change recorded */
if (i > 0) /* call the set callback and do marking */
feat->flags |= FEAT_MARK;
else /* i < 0 */
feat->flags &= ~FEAT_MARK;
break;
}
case FEAT_INT: /* an integer value */
case FEAT_UINT:
tmp = feat->v_int; /* detect changes... */
if (count < 2) { /* reset value */
feat->v_int = feat->def_int;
feat->flags &= ~FEAT_MARK;
} else { /* ok, figure out the value and whether to mark it */
feat->v_int = strtoul(fields[1], 0, 0);
if (feat->v_int == feat->def_int)
feat->flags &= ~FEAT_MARK;
else
feat->flags |= FEAT_MARK;
}
if (feat->v_int != tmp) /* check for change */
change++;
break;
case FEAT_BOOL: /* it's a boolean value--true or false */
tmp = feat->v_int; /* detect changes... */
if (count < 2) { /* reset value */
feat->v_int = feat->def_int;
feat->flags &= ~FEAT_MARK;
} else { /* figure out the value and whether to mark it */
if (!ircd_strncmp(fields[1], "TRUE", strlen(fields[1])) ||
!ircd_strncmp(fields[1], "YES", strlen(fields[1])) ||
(strlen(fields[1]) >= 2 &&
!ircd_strncmp(fields[1], "ON", strlen(fields[1]))))
feat->v_int = 1;
else if (!ircd_strncmp(fields[1], "FALSE", strlen(fields[1])) ||
!ircd_strncmp(fields[1], "NO", strlen(fields[1])) ||
(strlen(fields[1]) >= 2 &&
!ircd_strncmp(fields[1], "OFF", strlen(fields[1]))))
feat->v_int = 0;
else if (from) /* report an error... */
return send_reply(from, ERR_BADFEATVALUE, fields[1], feat->type);
else {
log_write(LS_CONFIG, L_ERROR, 0, "Bad value \"%s\" for feature %s",
fields[1], feat->type);
return 0;
}
if (feat->v_int == feat->def_int) /* figure out whether to mark it */
feat->flags &= ~FEAT_MARK;
else
feat->flags |= FEAT_MARK;
}
if (feat->v_int != tmp) /* check for change */
change++;
break;
case FEAT_STR: /* it's a string value */
if (count < 2)
t_str = feat->def_str; /* changing to default */
else
t_str = *fields[1] ? fields[1] : 0;
if (!t_str && !(feat->flags & FEAT_NULL)) { /* NULL value permitted? */
if (from)
return send_reply(from, ERR_BADFEATVALUE, "NULL", feat->type);
else {
log_write(LS_CONFIG, L_ERROR, 0, "Bad value \"NULL\" for feature %s",
feat->type);
return 0;
}
}
if (t_str == feat->def_str ||
(t_str && feat->def_str &&
!(feat->flags & FEAT_CASE ? strcmp(t_str, feat->def_str) :
ircd_strcmp(t_str, feat->def_str)))) { /* resetting to default */
if (feat->v_str != feat->def_str) {
change++; /* change from previous value */
if (feat->v_str)
MyFree(feat->v_str); /* free old value */
}
feat->v_str = feat->def_str; /* very special... */
feat->flags &= ~FEAT_MARK;
} else if (!t_str) {
if (feat->v_str) {
change++; /* change from previous value */
if (feat->v_str != feat->def_str)
MyFree(feat->v_str); /* free old value */
}
feat->v_str = 0; /* set it to NULL */
feat->flags |= FEAT_MARK;
} else if (!feat->v_str ||
(feat->flags & FEAT_CASE ? strcmp(t_str, feat->v_str) :
ircd_strcmp(t_str, feat->v_str))) { /* new value */
change++; /* change from previous value */
if (feat->v_str && feat->v_str != feat->def_str)
MyFree(feat->v_str); /* free old value */
DupString(feat->v_str, t_str); /* store new value */
feat->flags |= FEAT_MARK;
} else /* they match, but don't match the default */
feat->flags |= FEAT_MARK;
break;
}
if (change && feat->notify) /* call change notify function */
(*feat->notify)();
if (change && from) {
if(!IsServer(from) && !IsMe(from))
send_reply(from, SND_EXPLICIT | RPL_FEATURE, ":Value of %s changed",
feat->type);
switch (feat_type(feat)) {
case FEAT_NONE:
sendto_opmask_butone(0, SNO_OLDSNO, "%C changed %s",
from, feat->type);
break;
case FEAT_INT:
sendto_opmask_butone(0, SNO_OLDSNO, "%C changed %s to %d",
from, feat->type, feat->v_int);
break;
case FEAT_BOOL:
sendto_opmask_butone(0, SNO_OLDSNO, "%C changed %s to %s", from,
feat->type, (feat->v_int ? "TRUE" : "FALSE"));
break;
case FEAT_STR:
if(feat->v_str)
sendto_opmask_butone(0, SNO_OLDSNO, "%C changed %s to: %s",
from, feat->type, feat->v_str);
else
sendto_opmask_butone(0, SNO_OLDSNO, "%C unset %s",
from, feat->type);
break;
} /* switch */
} /* if (change) */
}
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;
}
/*
* m_squit - SQUIT message handler
* parv[0] = sender prefix
* parv[1] = server name
* parv[2] = comment
*/
int m_squit(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct ConfItem* aconf;
char* server;
struct Client* acptr;
char *comment = (parc > 2 && parv[2]) ? parv[2] : cptr->name;
if (!(IsServer(sptr) || HasUmode(sptr,UMODE_REMOTE)))
{
if (SeesOperMessages(sptr))
sendto_one(sptr,":%s NOTICE %s :You have no R umode", me.name, parv[0]);
else
sendto_one(sptr, form_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (parc > 1)
{
server = parv[1];
/*
** To accomodate host masking, a squit for a masked server
** name is expanded if the incoming mask is the same as
** the server name for that link to the name of link.
*/
while ((*server == '*') && IsServer(cptr))
{
aconf = cptr->serv->nline;
if (!aconf)
break;
if (!irccmp(server, my_name_for_link(me.name, aconf)))
server = cptr->name;
break; /* WARNING is normal here */
/* NOTREACHED */
}
/*
** The following allows wild cards in SQUIT. Only useful
** when the command is issued by an oper.
*/
for (acptr = GlobalClientList; (acptr = next_client(acptr, server));
acptr = acptr->next)
if (IsServer(acptr) || IsMe(acptr))
break;
if (acptr && IsMe(acptr))
{
acptr = cptr;
server = cptr->name;
}
}
else
{
/*
** This is actually protocol error. But, well, closing
** the link is very proper answer to that...
**
** Closing the client's connection probably wouldn't do much
** good.. any oper out there should know that the proper way
** to disconnect is /QUIT :)
**
** its still valid if its not a local client, its then
** a protocol error for sure -Dianora
*/
if(MyClient(sptr))
{
sendto_one(sptr, form_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "SQUIT");
return 0;
}
else
{
server = cptr->host;
acptr = cptr;
}
}
/*
** SQUIT semantics is tricky, be careful...
**
** The old (irc2.2PL1 and earlier) code just cleans away the
** server client from the links (because it is never true
** "cptr == acptr".
**
** This logic here works the same way until "SQUIT host" hits
** the server having the target "host" as local link. Then it
** will do a real cleanup spewing SQUIT's and QUIT's to all
** directions, also to the link from which the orinal SQUIT
** came, generating one unnecessary "SQUIT host" back to that
** link.
**
** One may think that this could be implemented like
** "hunt_server" (e.g. just pass on "SQUIT" without doing
** nothing until the server having the link as local is
** reached). Unfortunately this wouldn't work in the real life,
** because either target may be unreachable or may not comply
** with the request. In either case it would leave target in
** links--no command to clear it away. So, it's better just
** clean out while going forward, just to be sure.
**
** ...of course, even better cleanout would be to QUIT/SQUIT
** dependant users/servers already on the way out, but
** currently there is not enough information about remote
** clients to do this... --msa
*/
if (!acptr)
{
sendto_one(sptr, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], server);
return 0;
}
if (MyClient(sptr) && !HasUmode(sptr,UMODE_REMOTE) && !MyConnect(acptr))
{
sendto_one(sptr,":%s NOTICE %s :You have no R umode",me.name,parv[0]);
return 0;
}
/*
** Notify all opers, if my local link is remotely squitted
*/
if (MyConnect(acptr) && IsServer(cptr))
{
sendto_ops_flag(UMODE_AUSPEX,
"%s received SQUIT %s from %s (%s)",
me.name, server, get_client_name(sptr,FALSE), comment);
logprintf(L_TRACE, "SQUIT From %s : %s (%s)", parv[0], server, comment);
}
else if (MyConnect(acptr))
sendto_ops_flag(UMODE_SERVNOTICE, "Received SQUIT %s from %s (%s)",
acptr->name, get_client_name(sptr,FALSE), comment);
return exit_client(cptr, acptr, sptr, comment);
}
/*
* 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, char *comment)
{
Link *lp;
/*
* For a server or user quitting, propogate the information to
* other servers (except to the one where is came from (cptr))
*/
if (IsMe(sptr))
{
sendto_ops("ERROR: tried to exit me! : %s", comment);
return; /* ...must *never* exit self!! */
}
else if (IsServer(sptr))
{
#ifdef ALWAYS_SEND_DURING_SPLIT
currently_processing_netsplit = YES;
#endif
exit_server(cptr, sptr, from, comment);
#ifdef ALWAYS_SEND_DURING_SPLIT
currently_processing_netsplit = NO;
#endif
return;
}
else if (!(IsPerson(sptr)))
/*
* ...this test is *dubious*, would need * some thought.. but for
* now it plugs a * nasty hole in the server... --msa
*/
; /* Nothing */
else if (sptr->name[0])
{
/* ...just clean all others 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)
{
sendto_serv_butone(cptr, ":%s QUIT :%s",
sptr->name, comment);
}
/*
* * 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)
{
send_part_to_common_channels(sptr, comment);
send_quit_to_common_channels(sptr, comment);
while ((lp = sptr->user->channel))
remove_user_from_channel(sptr, lp->value.chptr);
clones_remove(sptr);
#ifdef RWHO_PROBABILITY
probability_remove(sptr);
#endif
/* Clean up invitefield */
while ((lp = sptr->user->invited))
del_invite(sptr, lp->value.chptr);
/* Clean up silences */
while ((lp = sptr->user->silence))
del_silence(sptr, lp->value.cp);
remove_dcc_references(sptr);
/* again, this is all that is needed */
}
}
/* 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 user from watchlists */
if(IsRegistered(sptr))
hash_check_watch(sptr, RPL_LOGOFF);
remove_client_from_list(sptr);
return;
}
/** Test whether we can send to a client.
* @param[in] to Client we want to send to.
* @return Non-zero if we can send to the client.
*/
static int can_send(struct Client* to)
{
assert(0 != to);
return (IsDead(to) || IsMe(to) || -1 == cli_fd(to)) ? 0 : 1;
}
/*
** 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;
}
/** Handle a GLINE message from an operator.
*
* \a parv has the following elements:
* \li \a parv[1] is the G-line mask (preceded by modifier flags)
* \li \a parv[2] (optional) is the target server numnick or '*'
* \li \a parv[N+1] is the G-line lifetime in seconds
* \li \a parv[\a parc - 1] is the G-line comment
*
* Three modifier flags are recognized, and must be present in this
* order:
* \li '!' Indicates an G-line that an oper forcibly applied.
* \li '-' Indicates that the following G-line should be removed.
* \li '+' (exclusive of '-') indicates that the G-line should be
* activated.
*
* 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
mo_gline(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *acptr = 0;
struct Gline *agline = 0;
unsigned int flags = 0;
enum GlineAction action = GLINE_MODIFY;
time_t expire = 0;
char *mask = parv[1], *target = 0, *reason = 0, *end;
if (parc < 2)
return gline_list(sptr, 0);
if (*mask == '!') {
mask++;
if (HasPriv(sptr, PRIV_WIDE_GLINE))
flags |= GLINE_OPERFORCE;
}
switch (*mask) { /* handle +, -, <, and > */
case '+': /* activate the G-line */
action = GLINE_ACTIVATE;
mask++;
break;
case '-': /* deactivate the G-line */
action = GLINE_DEACTIVATE;
mask++;
break;
case '>': /* locally activate the G-line */
action = GLINE_LOCAL_ACTIVATE;
mask++;
break;
case '<': /* locally deactivate the G-line */
action = GLINE_LOCAL_DEACTIVATE;
mask++;
break;
}
/* OK, let's figure out the parameters... */
switch (action) {
case GLINE_MODIFY: /* no specific action on the G-line... */
if (parc == 2) /* user wants a listing of a specific G-line */
return gline_list(sptr, mask);
else if (parc < 4) /* must have target and expire, minimum */
return need_more_params(sptr, "GLINE");
target = parv[2]; /* get the target... */
expire = strtol(parv[3], &end, 10) + TStime(); /* and the expiration */
if (*end != '\0')
return send_reply(sptr, SND_EXPLICIT | ERR_BADEXPIRE, "%s :Bad expire time", parv[3]);
flags |= GLINE_EXPIRE; /* remember that we got an expire time */
if (parc > 4) { /* also got a reason... */
reason = parv[parc - 1];
flags |= GLINE_REASON;
}
/* target is not global, interpolate action and require reason */
if (target[0] != '*' || target[1] != '\0') {
if (!reason) /* have to have a reason for this */
return need_more_params(sptr, "GLINE");
action = GLINE_ACTIVATE;
}
break;
case GLINE_LOCAL_ACTIVATE: /* locally activate a G-line */
case GLINE_LOCAL_DEACTIVATE: /* locally deactivate a G-line */
if (parc > 2) { /* if target is available, pick it */
target = parv[2];
if (target[0] == '*' && target[1] == '\0')
return send_reply(sptr, ERR_NOSUCHSERVER, target);
}
break;
case GLINE_ACTIVATE: /* activating/adding a G-line */
case GLINE_DEACTIVATE: /* deactivating/removing a G-line */
if (parc < 3)
return need_more_params(sptr, "GLINE");
if (parc > 3) {
/* get expiration and target */
reason = parv[parc - 1];
expire = strtol(parv[parc - 2], &end, 10) + TStime();
if (*end != '\0')
return send_reply(sptr, SND_EXPLICIT | ERR_BADEXPIRE, "%s :Bad expire time", parv[parc - 2]);
flags |= GLINE_EXPIRE | GLINE_REASON; /* remember that we got 'em */
if (parc > 4) /* also have a target! */
target = parv[2];
} else {
target = parv[2]; /* target has to be present, and has to be '*' */
if (target[0] != '*' || target[1] != '\0')
return need_more_params(sptr, "GLINE");
}
break;
}
/* Is there no mask left? */
if (mask[0] == '\0')
return need_more_params(sptr, "GLINE");
/* Now let's figure out which is the target server */
if (!target) /* no target, has to be me... */
acptr = &me;
/* if it's not '*', look up the server */
else if ((target[0] != '*' || target[1] != '\0') &&
!(acptr = find_match_server(target)))
return send_reply(sptr, ERR_NOSUCHSERVER, target);
/* Now, is the G-line local or global? */
if (action == GLINE_LOCAL_ACTIVATE || action == GLINE_LOCAL_DEACTIVATE ||
!acptr)
flags |= GLINE_GLOBAL;
else /* it's some form of local G-line */
flags |= GLINE_LOCAL;
/* If it's a local activate/deactivate and server isn't me, propagate it */
if ((action == GLINE_LOCAL_ACTIVATE || action == GLINE_LOCAL_DEACTIVATE) &&
!IsMe(acptr)) {
/* check for permissions... */
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "GLINE");
else if (!HasPriv(sptr, PRIV_GLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
Debug((DEBUG_DEBUG, "I am forwarding a local change to a global gline "
"to a remote server; target %s, mask %s, operforce %s, action %c",
cli_name(acptr), mask, flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_LOCAL_ACTIVATE ? '>' : '<'));
sendcmdto_one(sptr, CMD_GLINE, acptr, "%C %s%c%s", acptr,
flags & GLINE_OPERFORCE ? "!" : "",
action == GLINE_LOCAL_ACTIVATE ? '>' : '<', mask);
return 0; /* all done */
}
/* Next, try to find the G-line... */
if ((flags & GLINE_GLOBAL) || IsMe(acptr)) /* don't bother if it's not me! */
agline = gline_find(mask, flags | GLINE_ANY | GLINE_EXACT);
/* We now have all the pieces to tell us what we've got; let's put
* it all together and convert the rest of the arguments.
*/
/* Handle the local G-lines first... */
if (flags & GLINE_LOCAL) {
assert(acptr);
/* normalize the action, first */
if (action == GLINE_LOCAL_ACTIVATE || action == GLINE_MODIFY)
action = GLINE_ACTIVATE;
else if (action == GLINE_LOCAL_DEACTIVATE)
action = GLINE_DEACTIVATE;
/* If it's not for us, forward */
/* UPDATE NOTE: Once all servers are updated to u2.10.12.11, the
* format string in this sendcmdto_one() may be updated to omit
* <lastmod> for GLINE_ACTIVATE and to omit <expire>, <lastmod>,
* and <reason> for GLINE_DEACTIVATE.
*/
if (!IsMe(acptr)) {
/* check for permissions... */
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "GLINE");
else if (!HasPriv(sptr, PRIV_GLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
Debug((DEBUG_DEBUG, "I am forwarding a local G-line to a remote "
"server; target %s, mask %s, operforce %s, action %c, "
"expire %Tu, reason %s", target, mask,
flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? '+' : '-', expire, reason));
sendcmdto_one(sptr, CMD_GLINE, acptr, "%C %s%c%s %Tu %Tu :%s",
acptr, flags & GLINE_OPERFORCE ? "!" : "",
action == GLINE_ACTIVATE ? '+' : '-', mask,
expire - TStime(), TStime(), reason);
return 0; /* all done */
}
/* check local G-line permissions... */
if (!HasPriv(sptr, PRIV_LOCAL_GLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
/* let's handle activation... */
if (action == GLINE_ACTIVATE) {
if (agline) /* G-line already exists, so let's ignore it... */
return 0;
/* OK, create the local G-line */
Debug((DEBUG_DEBUG, "I am creating a local G-line here; target %s, "
"mask %s, operforce %s, action %s, expire %Tu, reason: %s",
target, mask, flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? "+" : "-", expire, reason));
return gline_add(cptr, sptr, mask, reason, expire, 0, 0,
flags | GLINE_ACTIVE);
} else { /* OK, it's a deactivation/destruction */
if (!agline) /* G-line doesn't exist, so let's complain... */
return send_reply(sptr, ERR_NOSUCHGLINE, mask);
/* Let's now destroy the G-line */
Debug((DEBUG_DEBUG, "I am destroying a local G-line here; target %s, "
"mask %s, operforce %s, action %s", target, mask,
flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? "+" : "-"));
return gline_destroy(cptr, sptr, agline);
}
}
/* can't modify a G-line that doesn't exist...
* (and if we are creating a new one, we need a reason and expiration)
*/
if (!agline &&
(action == GLINE_MODIFY || action == GLINE_LOCAL_ACTIVATE ||
action == GLINE_LOCAL_DEACTIVATE || !reason || !expire))
return send_reply(sptr, ERR_NOSUCHGLINE, mask);
/* check for G-line permissions... */
if (action == GLINE_LOCAL_ACTIVATE || action == GLINE_LOCAL_DEACTIVATE) {
/* only need local privileges for locally-limited status changes */
if (!HasPriv(sptr, PRIV_LOCAL_GLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
} else { /* global privileges required */
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "GLINE");
else if (!HasPriv(sptr, PRIV_GLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
}
Debug((DEBUG_DEBUG, "I have a global G-line I am acting upon now; "
"target %s, mask %s, operforce %s, action %s, expire %Tu, "
"reason: %s; gline %s! (fields present: %s %s)", target,
mask, flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? "+" :
(action == GLINE_DEACTIVATE ? "-" :
(action == GLINE_LOCAL_ACTIVATE ? ">" :
(action == GLINE_LOCAL_DEACTIVATE ? "<" : "(MODIFY)"))),
expire, reason, agline ? "EXISTS" : "does not exist",
flags & GLINE_EXPIRE ? "expire" : "",
flags & GLINE_REASON ? "reason" : ""));
if (agline) /* modifying an existing G-line */
return gline_modify(cptr, sptr, agline, action, reason, expire,
TStime(), 0, flags);
assert(action != GLINE_LOCAL_ACTIVATE);
assert(action != GLINE_LOCAL_DEACTIVATE);
assert(action != GLINE_MODIFY);
/* create a new G-line */
return gline_add(cptr, sptr, mask, reason, expire, TStime(), 0,
flags | ((action == GLINE_ACTIVATE) ? GLINE_ACTIVE : 0));
}
int
m_scan_idle(struct Client *cptr, struct Client *sptr, int parc, char *parv[], char *varparv[])
{
struct Client *ptr, *target = NULL;
char *eptr, buffer[321];
int idle_time, check_time, len = 0, count = 0;
if(MyClient(sptr) && !HasUmode(sptr, UMODE_USER_AUSPEX))
{
if(SeesOperMessages(sptr))
sendto_one(sptr,":%s NOTICE %s :You have no a umode", me.name, parv[0]);
else
sendto_one(sptr, form_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if(parc < 3)
{
if (!IsServer(sptr))
sendto_one(sptr, form_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "SCAN IDLE");
return 0;
}
idle_time = strtoul(parv[2], &eptr, 10);
if(eptr == parv[2])
return 0;
/* Store the timestamp which last_sent should be >= to save time */
check_time = CurrentTime - idle_time;
/* If the query is for another server, pass it on and return. */
if(parc > 3)
{
if(MyClient(sptr) && !HasUmode(sptr, UMODE_REMOTEINFO))
{
if(SeesOperMessages(sptr))
sendto_one(sptr,":%s NOTICE %s :You have no S umode(cannot send remote)", me.name, parv[0]);
else
sendto_one(sptr, form_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if(!irccmp(parv[3], "GLOBAL") || !irccmp(parv[3], "*"))
sendto_serv_butone(cptr, ":%s SCAN IDLE %d *", parv[0], idle_time);
else if((target = find_server(parv[3])) == NULL) {
sendto_one(sptr, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], parv[3]);
return 0;
}else if(!IsMe(target)) { /* But only if the query is not on us... */
sendto_prefix_one(target, sptr, ":%s SCAN IDLE %d %s", parv[0],
idle_time, target->name);
return 0;
}
}
buffer[0] = '\0';
for(ptr = local_cptr_list; ptr; ptr = ptr->next_local_client)
{
if(ptr->user->last_sent < check_time)
continue;
if(len + strlen(ptr->name) > 319)
{
buffer[len - 1] = '\0'; /* Strip the trailing space */
send_markup(sptr, &me, "SCAN-IDLE", "%d %s", idle_time, buffer);
buffer[0] = '\0';
len = 0;
}
strcat(buffer, ptr->name);
strcat(buffer, " ");
len += strlen(ptr->name) + 1;
count++;
}
if(buffer[0])
{
buffer[len - 1] = '\0';
send_markup(sptr, &me, "SCAN-IDLE", "%d %s", idle_time, buffer);
}
send_markup(sptr, &me, "IDLE-END", "End of idle listing");
if(count > 0 || target || parc == 3) /* Don't give a summary for globals if no results matched */
send_markup(sptr, &me, "SCAN-SUMMARY", "%d matched", count);
return 0;
}
/** Handle a GLINE message from a server.
*
* \a parv has the following elements:
* \li \a parv[1] is the target server numnick or "*" for all servers
* \li \a parv[2] is the G-line mask (preceded by modifier flags)
* \li \a parv[3] is the G-line lifetime in seconds
* \li \a parv[4] (optional) is the G-line's last modification time
* \li \a parv[\a parc - 1] is the G-line comment
*
* If the issuer is a server or there is no timestamp, the issuer must
* be flagged as a UWorld server. In this case, if the '-' modifier
* flag is used, the G-line lifetime and all following arguments may
* be omitted.
*
* Three modifier flags are recognized, and must be present in this
* order:
* \li '!' Indicates an G-line that an oper forcibly applied.
* \li '-' Indicates that the following G-line should be removed.
* \li '+' (exclusive of '-') indicates that the G-line should be
* activated.
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int
ms_gline(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *acptr = 0;
struct Gline *agline = 0;
unsigned int flags = 0;
enum GlineAction action = GLINE_MODIFY;
time_t expire = 0, lastmod = 0, lifetime = 0;
char *mask = parv[2], *target = parv[1], *reason = "No reason", *tmp = 0;
if (parc < 3)
return need_more_params(sptr, "GLINE");
if (IsServer(sptr))
flags |= GLINE_FORCE;
if (*mask == '!') {
mask++;
flags |= GLINE_OPERFORCE; /* assume oper had WIDE_GLINE */
}
switch (*mask) { /* handle +, -, <, and > */
case '+': /* activate the G-line */
action = GLINE_ACTIVATE;
mask++;
break;
case '-': /* deactivate the G-line */
action = GLINE_DEACTIVATE;
mask++;
break;
case '>': /* locally activate the G-line */
action = GLINE_LOCAL_ACTIVATE;
mask++;
break;
case '<': /* locally deactivate the G-line */
action = GLINE_LOCAL_DEACTIVATE;
mask++;
break;
}
/* Is there no mask left? */
if (mask[0] == '\0')
return need_more_params(sptr, "GLINE");
/* Now, let's figure out if it's a local or global G-line */
if (action == GLINE_LOCAL_ACTIVATE || action == GLINE_LOCAL_DEACTIVATE ||
(target[0] == '*' && target[1] == '\0'))
flags |= GLINE_GLOBAL;
else
flags |= GLINE_LOCAL;
/* now figure out if we need to resolve a server */
if ((action == GLINE_LOCAL_ACTIVATE || action == GLINE_LOCAL_DEACTIVATE ||
(flags & GLINE_LOCAL)) && !(acptr = FindNServer(target)))
return 0; /* no such server, jump out */
/* If it's a local activate/deactivate and server isn't me, propagate it */
if ((action == GLINE_LOCAL_ACTIVATE || action == GLINE_LOCAL_DEACTIVATE) &&
!IsMe(acptr)) {
Debug((DEBUG_DEBUG, "I am forwarding a local change to a global gline "
"to a remote server; target %s, mask %s, operforce %s, action %c",
target, mask, flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_LOCAL_ACTIVATE ? '>' : '<'));
sendcmdto_one(sptr, CMD_GLINE, acptr, "%C %s%c%s", acptr,
flags & GLINE_OPERFORCE ? "!" : "",
action == GLINE_LOCAL_ACTIVATE ? '>' : '<', mask);
return 0; /* all done */
}
/* Next, try to find the G-line... */
if ((flags & GLINE_GLOBAL) || IsMe(acptr)) /* don't bother if it's not me! */
agline = gline_find(mask, flags | GLINE_ANY | GLINE_EXACT);
/* We now have all the pieces to tell us what we've got; let's put
* it all together and convert the rest of the arguments.
*/
/* Handle the local G-lines first... */
if (flags & GLINE_LOCAL) {
assert(acptr);
/* normalize the action, first */
if (action == GLINE_LOCAL_ACTIVATE || action == GLINE_MODIFY)
action = GLINE_ACTIVATE;
else if (action == GLINE_LOCAL_DEACTIVATE)
action = GLINE_DEACTIVATE;
if (action == GLINE_ACTIVATE) { /* get expiration and reason */
if (parc < 5) /* check parameter count... */
return need_more_params(sptr, "GLINE");
expire = atoi(parv[3]); /* get expiration... */
expire = abs_expire(expire); /* convert to absolute... */
reason = parv[parc - 1]; /* and reason */
if (IsMe(acptr)) {
if (agline) /* G-line already exists, so let's ignore it... */
return 0;
/* OK, create the local G-line */
Debug((DEBUG_DEBUG, "I am creating a local G-line here; target %s, "
"mask %s, operforce %s, action %s, expire %Tu, reason: %s",
target, mask, flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? "+" : "-", expire, reason));
return gline_add(cptr, sptr, mask, reason, expire, lastmod,
lifetime, flags | GLINE_ACTIVE);
}
} else if (IsMe(acptr)) { /* destroying a local G-line */
if (!agline) /* G-line doesn't exist, so let's complain... */
return send_reply(sptr, ERR_NOSUCHGLINE, mask);
/* Let's now destroy the G-line */;
Debug((DEBUG_DEBUG, "I am destroying a local G-line here; target %s, "
"mask %s, operforce %s, action %s", target, mask,
flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? "+" : "-"));
return gline_destroy(cptr, sptr, agline);
}
/* OK, we've converted arguments; if it's not for us, forward */
/* UPDATE NOTE: Once all servers are updated to u2.10.12.11, the
* format string in this sendcmdto_one() may be updated to omit
* <lastmod> for GLINE_ACTIVATE and to omit <expire>, <lastmod>,
* and <reason> for GLINE_DEACTIVATE.
*/
assert(!IsMe(acptr));
Debug((DEBUG_DEBUG, "I am forwarding a local G-line to a remote server; "
"target %s, mask %s, operforce %s, action %c, expire %Tu, "
"lastmod %Tu, reason: %s", target, mask,
flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? '+' : '-', expire, TStime(),
reason));
sendcmdto_one(sptr, CMD_GLINE, acptr, "%C %s%c%s %Tu %Tu :%s",
acptr, flags & GLINE_OPERFORCE ? "!" : "",
action == GLINE_ACTIVATE ? '+' : '-', mask,
expire - TStime(), TStime(), reason);
return 0; /* all done */
}
/* can't modify a G-line that doesn't exist, so remap to activate */
if (!agline && action == GLINE_MODIFY)
action = GLINE_ACTIVATE;
/* OK, let's figure out what other parameters we may have... */
switch (action) {
case GLINE_LOCAL_ACTIVATE: /* locally activating a G-line */
case GLINE_LOCAL_DEACTIVATE: /* locally deactivating a G-line */
if (!agline) /* no G-line to locally activate or deactivate? */
return send_reply(sptr, ERR_NOSUCHGLINE, mask);
lastmod = agline->gl_lastmod;
break; /* no additional parameters to manipulate */
case GLINE_ACTIVATE: /* activating a G-line */
case GLINE_DEACTIVATE: /* deactivating a G-line */
/* in either of these cases, we have at least a lastmod parameter */
if (parc < 4)
return need_more_params(sptr, "GLINE");
else if (parc == 4) /* lastmod only form... */
lastmod = atoi(parv[3]);
/*FALLTHROUGH*/
case GLINE_MODIFY: /* modifying a G-line */
/* convert expire and lastmod, look for lifetime and reason */
if (parc > 4) { /* protect against fall-through from 4-param form */
expire = atoi(parv[3]); /* convert expiration and lastmod */
expire = abs_expire(expire);
lastmod = atoi(parv[4]);
flags |= GLINE_EXPIRE; /* we have an expiration time update */
if (parc > 6) { /* no question, have a lifetime and reason */
lifetime = atoi(parv[5]);
reason = parv[parc - 1];
flags |= GLINE_LIFETIME | GLINE_REASON;
} else if (parc == 6) { /* either a lifetime or a reason */
if (!agline || /* gline creation, has to be the reason */
/* trial-convert as lifetime, and if it doesn't fully convert,
* it must be the reason */
(!(lifetime = strtoul(parv[5], &tmp, 10)) && !*tmp)) {
lifetime = 0;
reason = parv[5];
flags |= GLINE_REASON; /* have a reason update */
} else if (lifetime)
flags |= GLINE_LIFETIME; /* have a lifetime update */
}
}
}
if (!lastmod) /* must have a lastmod parameter by now */
return need_more_params(sptr, "GLINE");
Debug((DEBUG_DEBUG, "I have a global G-line I am acting upon now; "
"target %s, mask %s, operforce %s, action %s, expire %Tu, "
"lastmod %Tu, lifetime %Tu, reason: %s; gline %s! (fields "
"present: %s %s %s)", target, mask,
flags & GLINE_OPERFORCE ? "YES" : "NO",
action == GLINE_ACTIVATE ? "+" :
(action == GLINE_DEACTIVATE ? "-" :
(action == GLINE_LOCAL_ACTIVATE ? ">" :
(action == GLINE_LOCAL_DEACTIVATE ? "<" : "(MODIFY)"))),
expire, lastmod, lifetime, reason,
agline ? "EXISTS" : "does not exist",
flags & GLINE_EXPIRE ? "expire" : "",
flags & GLINE_LIFETIME ? "lifetime" : "",
flags & GLINE_REASON ? "reason" : ""));
/* OK, at this point, we have converted all available parameters.
* Let's actually do the action!
*/
if (agline)
return gline_modify(cptr, sptr, agline, action, reason, expire,
lastmod, lifetime, flags);
assert(action != GLINE_LOCAL_ACTIVATE);
assert(action != GLINE_LOCAL_DEACTIVATE);
assert(action != GLINE_MODIFY);
if (!expire) { /* Cannot *add* a G-line we don't have, but try hard */
Debug((DEBUG_DEBUG, "Propagating G-line %s for G-line we don't have",
action == GLINE_ACTIVATE ? "activation" : "deactivation"));
/* propagate the G-line, even though we don't have it */
sendcmdto_serv(sptr, CMD_GLINE, cptr, "* %c%s %Tu",
action == GLINE_ACTIVATE ? '+' : '-',
mask, lastmod);
return 0;
}
return gline_add(cptr, sptr, mask, reason, expire, lastmod, lifetime,
flags | ((action == GLINE_ACTIVATE) ? GLINE_ACTIVE : 0));
}
void CSteamProto::ParsePollData(JSONNode *data)
{
JSONNode *node, *item = NULL;
std::string steamIds;
for (size_t i = 0; i < json_size(data); i++)
{
item = json_at(data, i);
if (item == NULL)
break;
node = json_get(item, "steamid_from");
ptrA steamId(mir_t2a(ptrT(json_as_string(node))));
node = json_get(item, "utc_timestamp");
time_t timestamp = atol(ptrA(mir_t2a(ptrT(json_as_string(node)))));
node = json_get(item, "type");
ptrT type(json_as_string(node));
if (!lstrcmpi(type, _T("saytext")) || !lstrcmpi(type, _T("emote")) ||
!lstrcmpi(type, _T("my_saytext")) || !lstrcmpi(type, _T("my_emote")))
{
MCONTACT hContact = FindContact(steamId);
if (!hContact)
continue;
node = json_get(item, "text");
ptrT text(json_as_string(node));
T2Utf szMessage(text);
if (_tcsstr(type, _T("my_")) == NULL)
{
PROTORECVEVENT recv = { 0 };
recv.timestamp = timestamp;
recv.szMessage = szMessage;
ProtoChainRecvMsg(hContact, &recv);
}
else
{
AddDBEvent(hContact, EVENTTYPE_MESSAGE, timestamp, DBEF_UTF | DBEF_SENT, (int)mir_strlen(szMessage) + 1, (PBYTE)(char*)szMessage);
}
}
else if (!lstrcmpi(type, _T("typing")))
{
MCONTACT hContact = FindContact(steamId);
if (hContact)
{
CallService(MS_PROTO_CONTACTISTYPING, hContact, (LPARAM)STEAM_TYPING_TIME);
}
}
else if (!lstrcmpi(type, _T("personastate")))
{
node = json_get(item, "persona_state");
int status = node ? SteamToMirandaStatus(json_as_int(node)) : -1;
if (IsMe(steamId))
{
node = json_get(item, "persona_name");
setTString("Nick", ptrT(json_as_string(node)));
if (status == -1 || status == ID_STATUS_OFFLINE)
continue;
if (status != m_iStatus)
{
debugLog(_T("CSteamProto::ParsePollData: Change own status to %i"), status);
int oldStatus = m_iStatus;
m_iStatus = m_iDesiredStatus = status;
ProtoBroadcastAck(NULL, ACKTYPE_STATUS, ACKRESULT_SUCCESS, (HANDLE)oldStatus, m_iStatus);
}
continue;
}
MCONTACT hContact = FindContact(steamId);
if (hContact == NULL)
continue; // probably this is info about random player playing on same server, so we ignore it
if (status != -1)
SetContactStatus(hContact, status);
node = json_get(item, "persona_name");
setTString(hContact, "Nick", ptrT(json_as_string(node)));
// todo: find difference between state changing and info changing
steamIds.append(steamId).append(",");
}
else if (!lstrcmpi(type, _T("personarelationship")))
{
node = json_get(item, "persona_state");
int state = json_as_int(node);
switch (state)
{
case 0:
{// removed
MCONTACT hContact = FindContact(steamId);
if (hContact)
{
ContactIsRemoved(hContact);
}
}
break;
case 1:
{// ignored
MCONTACT hContact = FindContact(steamId);
if (hContact)
{
ContactIsIgnored(hContact);
}
}
break;
case 2:
{// auth request
/*MCONTACT hContact = FindContact(steamId);
if (!hContact)
hContact = AddContact(steamId, true);*/
//RaiseAuthRequestThread((void*)hContact);
ptrA token(getStringA("TokenSecret"));
PushRequest(
new GetUserSummariesRequest(token, steamId),
&CSteamProto::OnAuthRequested,
mir_strdup(steamId),
MirFreeArg);
}
break;
case 3:
// add to list
// todo
break;
default: continue;
}
}
/*else if (!lstrcmpi(type, _T("leftconversation")))
{
}*/
else
{
continue;
}
}
if (!steamIds.empty())
{
steamIds.pop_back();
ptrA token(getStringA("TokenSecret"));
PushRequest(
new GetUserSummariesRequest(token, steamIds.c_str()),
&CSteamProto::OnGotUserSummaries);
}
}
/*
** m_kill
** parv[0] = sender prefix
** parv[1] = kill victim(s) - comma separated list
** parv[2] = kill path
*/
DLLFUNC int m_kill(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
aClient *acptr;
anUser *auser;
char inpath[HOSTLEN * 2 + USERLEN + 5];
char *oinpath = get_client_name(cptr, FALSE);
char *user, *path, *killer, *nick, *p, *s;
int chasing = 0, kcount = 0;
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "KILL");
return 0;
}
user = parv[1];
path = parv[2]; /* Either defined or NULL (parc >= 2!!) */
strlcpy(inpath, oinpath, sizeof inpath);
#ifndef ROXnet
if (IsServer(cptr) && (s = (char *)index(inpath, '.')) != NULL)
*s = '\0'; /* Truncate at first "." */
#endif
if (!IsPrivileged(cptr))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (IsAnOper(cptr))
{
if (BadPtr(path))
{
sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS),
me.name, parv[0], "KILL");
return 0;
}
if (strlen(path) > (size_t)TOPICLEN)
path[TOPICLEN] = '\0';
}
if (MyClient(sptr))
user = (char *)canonize(user);
for (p = NULL, nick = strtoken(&p, user, ","); nick;
nick = strtoken(&p, NULL, ","))
{
chasing = 0;
if (!(acptr = find_client(nick, NULL)))
{
/*
** If the user has recently changed nick, we automaticly
** rewrite the KILL for this new nickname--this keeps
** servers in synch when nick change and kill collide
*/
if (!(acptr =
get_history(nick, (long)KILLCHASETIMELIMIT)))
{
sendto_one(sptr, err_str(ERR_NOSUCHNICK),
me.name, parv[0], nick);
continue;
}
sendto_one(sptr,
":%s %s %s :*** KILL changed from %s to %s",
me.name, IsWebTV(sptr) ? "PRIVMSG" : "NOTICE", parv[0], nick, acptr->name);
chasing = 1;
}
if ((!MyConnect(acptr) && MyClient(cptr) && !OPCanGKill(cptr))
|| (MyConnect(acptr) && MyClient(cptr)
&& !OPCanLKill(cptr)))
{
sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name,
parv[0]);
continue;
}
if (IsServer(acptr) || IsMe(acptr))
{
sendto_one(sptr, err_str(ERR_CANTKILLSERVER),
me.name, parv[0]);
continue;
}
if (!IsPerson(acptr))
{
/* Nick exists but user is not registered yet: IOTW "doesn't exist". -- Syzop */
sendto_one(sptr, err_str(ERR_NOSUCHNICK),
me.name, parv[0], nick);
continue;
}
if (IsServices(acptr) && !(IsNetAdmin(sptr) || IsULine(sptr)))
{
sendto_one(sptr, err_str(ERR_KILLDENY), me.name,
parv[0], parv[1]);
return 0;
}
/* From here on, the kill is probably going to be successful. */
kcount++;
if (!IsServer(sptr) && (kcount > MAXKILLS))
{
sendto_one(sptr,
":%s %s %s :*** Too many targets, kill list was truncated. Maximum is %d.",
me.name, IsWebTV(sptr) ? "PRIVMSG" : "NOTICE", parv[0], MAXKILLS);
break;
}
if (!IsServer(cptr))
{
/*
** The kill originates from this server, initialize path.
** (In which case the 'path' may contain user suplied
** explanation ...or some nasty comment, sigh... >;-)
**
** ...!operhost!oper
** ...!operhost!oper (comment)
*/
strlcpy(inpath, GetHost(cptr), sizeof inpath);
if (kcount < 2) { /* Only check the path the first time
around, or it gets appended to itself. */
if (!BadPtr(path))
{
(void)ircsprintf(buf, "%s%s (%s)",
cptr->name,
IsOper(sptr) ? "" : "(L)", path);
path = buf;
}
else
path = cptr->name;
}
}
else if (BadPtr(path))
path = "*no-path*"; /* Bogus server sending??? */
/*
** Notify all *local* opers about the KILL (this includes the one
** originating the kill, if from this server--the special numeric
** reply message is not generated anymore).
**
** Note: "acptr->name" is used instead of "user" because we may
** have changed the target because of the nickname change.
*/
auser = acptr->user;
sendto_snomask_normal(SNO_KILLS,
"*** Notice -- Received KILL message for %s!%s@%s from %s Path: %s!%s",
acptr->name, auser->username,
IsHidden(acptr) ? auser->virthost : auser->realhost,
parv[0], inpath, path);
#if defined(USE_SYSLOG) && defined(SYSLOG_KILL)
if (IsOper(sptr))
syslog(LOG_DEBUG, "KILL From %s For %s Path %s!%s",
parv[0], acptr->name, inpath, path);
#endif
/*
* By otherguy
*/
ircd_log
(LOG_KILL, "KILL (%s) by %s(%s!%s)",
make_nick_user_host
(acptr->name, acptr->user->username, GetHost(acptr)),
parv[0],
inpath,
path);
/*
** And pass on the message to other servers. Note, that if KILL
** was changed, the message has to be sent to all links, also
** back.
** Suicide kills are NOT passed on --SRB
*/
if (!MyConnect(acptr) || !MyConnect(sptr) || !IsAnOper(sptr))
{
sendto_serv_butone(cptr, ":%s KILL %s :%s!%s",
parv[0], acptr->name, inpath, path);
if (chasing && IsServer(cptr))
sendto_one(cptr, ":%s KILL %s :%s!%s",
me.name, acptr->name, inpath, path);
acptr->flags |= FLAGS_KILLED;
}
/*
** Tell the victim she/he has been zapped, but *only* if
** the victim is on current server--no sense in sending the
** notification chasing the above kill, it won't get far
** anyway (as this user don't exist there any more either)
*/
if (MyConnect(acptr))
sendto_prefix_one(acptr, sptr, ":%s KILL %s :%s!%s",
parv[0], acptr->name, inpath, path);
/*
** Set FLAGS_KILLED. This prevents exit_one_client from sending
** the unnecessary QUIT for this. (This flag should never be
** set in any other place)
*/
if (MyConnect(acptr) && MyConnect(sptr) && IsAnOper(sptr))
(void)ircsprintf(buf2, "[%s] Local kill by %s (%s)",
me.name, sptr->name,
BadPtr(parv[2]) ? sptr->name : parv[2]);
else
{
if ((killer = index(path, ' ')))
{
while ((killer >= path) && *killer && *killer != '!')
killer--;
if (!*killer)
killer = path;
else
killer++;
}
else
killer = path;
(void)ircsprintf(buf2, "Killed (%s)", killer);
}
if (MyClient(sptr))
RunHook3(HOOKTYPE_LOCAL_KILL, sptr, acptr, parv[2]);
if (exit_client(cptr, acptr, sptr, buf2) == FLUSH_BUFFER)
return FLUSH_BUFFER;
}
return 0;
}
/*
* cancel_clients
*
* inputs -
* output -
* side effects -
*/
static int
cancel_clients(struct Client *client_p, struct Client *source_p, char *cmd)
{
/*
* kill all possible points that are causing confusion here,
* I'm not sure I've got this all right...
* - avalon
*
* knowing avalon, probably not.
*/
/*
* with TS, fake prefixes are a common thing, during the
* connect burst when there's a nick collision, and they
* must be ignored rather than killed because one of the
* two is surviving.. so we don't bother sending them to
* all ops everytime, as this could send 'private' stuff
* from lagged clients. we do send the ones that cause
* servers to be dropped though, as well as the ones from
* non-TS servers -orabidoo
*/
/*
* Incorrect prefix for a server from some connection. If it is a
* client trying to be annoying, just QUIT them, if it is a server
* then the same deal.
*/
if(IsServer(source_p) || IsMe(source_p))
{
sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
"Message for %s[%s] from %s",
source_p->name, source_p->from->name,
get_client_name(client_p, SHOW_IP));
sendto_realops_flags(UMODE_DEBUG, L_OPER,
"Message for %s[%s] from %s",
source_p->name, source_p->from->name,
get_client_name(client_p, MASK_IP));
if(IsServer(client_p))
{
sendto_realops_flags(UMODE_DEBUG, L_ALL,
"Not dropping server %s (%s) for Fake Direction",
client_p->name, source_p->name);
return -1;
}
if(IsClient(client_p))
sendto_realops_flags(UMODE_DEBUG, L_ALL,
"Would have dropped client %s (%s@%s) [%s from %s]",
client_p->name, client_p->username, client_p->host,
client_p->user->server, client_p->from->name);
return -1;
/*
return exit_client(client_p, client_p, &me, "Fake Direction");
*/
}
/*
* Ok, someone is trying to impose as a client and things are
* confused. If we got the wrong prefix from a server, send out a
* kill, else just exit the lame client.
*/
if(IsServer(client_p))
{
/*
* If the fake prefix is coming from a TS server, discard it
* silently -orabidoo
*
* all servers must be TS these days --is
*/
if(source_p->user)
{
sendto_realops_flags(UMODE_DEBUG, L_ADMIN,
"Message for %s[%s@%s!%s] from %s (TS, ignored)",
source_p->name, source_p->username, source_p->host,
source_p->from->name, get_client_name(client_p,
SHOW_IP));
sendto_realops_flags(UMODE_DEBUG, L_OPER,
"Message for %s[%s@%s!%s] from %s (TS, ignored)",
source_p->name, source_p->username, source_p->host,
source_p->from->name, get_client_name(client_p,
MASK_IP));
}
return 0;
}
return exit_client(client_p, client_p, &me, "Fake prefix");
}
/*
* m_server
* parv[0] = sender prefix
* parv[1] = servername
* parv[2] = serverinfo/hopcount
* parv[3] = serverinfo
*/
int m_server(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
int i;
char info[REALLEN + 1], *host;
aClient *acptr, *bcptr;
aConnect *aconn;
int hop;
char nbuf[HOSTLEN * 2 + USERLEN + 5]; /* same size as in s_misc.c */
info[0] = '\0';
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(cptr, "ERROR :No servername");
return 0;
}
hop = 0;
host = parv[1];
if (parc > 3 && atoi(parv[2]))
{
hop = atoi(parv[2]);
strncpyzt(info, parv[3], REALLEN + 1);
}
else if (parc > 2)
{
strncpyzt(info, parv[2], REALLEN + 1);
if ((parc > 3) && ((i = strlen(info)) < (REALLEN - 2)))
{
strcat(info, " ");
strncat(info, parv[3], REALLEN - i - 2);
info[REALLEN] = '\0';
}
}
/*
* July 5, 1997
* Rewritten to throw away server cruft from users,
* combined the hostname validity test with cleanup of host name,
* so a cleaned up hostname can be returned as an error if
* necessary. - Dianora
*/
/* yes, the if(strlen) below is really needed!! */
if (strlen(host) > HOSTLEN)
host[HOSTLEN] = '\0';
if (IsPerson(cptr))
{
/* A local link that has been identified as a USER tries
* something fishy... ;-)
*/
sendto_one(cptr, err_str(ERR_UNKNOWNCOMMAND),
me.name, parv[0], "SERVER");
return 0;
}
else
/* hostile servername check */
{
/*
* Lets check for bogus names and clean them up we don't bother
* cleaning up ones from users, becasuse we will never see them
* any more - Dianora
*/
int bogus_server = 0;
int found_dot = 0;
char clean_host[(2 * HOSTLEN) + 1];
char *s;
char *d;
int n;
s = host;
d = clean_host;
n = (2 * HOSTLEN) - 2;
while (*s && n > 0)
{
if ((unsigned char) *s < (unsigned char) ' ')
/* Is it a control character? */
{
bogus_server = 1;
*d++ = '^';
*d++ = (char) ((unsigned char) *s + 0x40);
/* turn it into a printable */
n -= 2;
}
else if ((unsigned char) *s > (unsigned char) '~')
{
bogus_server = 1;
*d++ = '.';
n--;
}
else
{
if (*s == '.')
found_dot = 1;
*d++ = *s;
n--;
}
s++;
}
*d = '\0';
if ((!found_dot) || bogus_server)
{
sendto_one(sptr, "ERROR :Bogus server name (%s)",
clean_host);
return exit_client(cptr, cptr, cptr, "Bogus server name");
}
}
/* new connection */
if (IsUnknown(cptr) || IsHandshake(cptr))
{
strncpyzt(cptr->name, host, sizeof(cptr->name));
strncpyzt(cptr->info, info[0] ? info : me.name, REALLEN + 1);
cptr->hopcount = hop;
switch (check_server_init(cptr))
{
case 0:
return m_server_estab(cptr);
case 1:
sendto_ops("Access check for %s in progress",
get_client_name(cptr, HIDEME));
return 1;
default:
ircstp->is_ref++;
sendto_ops_lev(ADMIN_LEV, "Link %s dropped, no Connect block",
get_client_name(cptr, TRUE));
return exit_client(cptr, cptr, cptr, "No Connect block");
}
}
/* already linked server */
if (!IsServer(cptr))
return 0;
if ((acptr = find_name(host, NULL)))
{
/*
* * This link is trying feed me a server that I already have
* access through another path -- multiple paths not accepted
* currently, kill this link immediately!!
*
* Rather than KILL the link which introduced it, KILL the
* youngest of the two links. -avalon
*/
bcptr = (cptr->firsttime > acptr->from->firsttime) ? cptr :
acptr->from;
sendto_one(bcptr, "ERROR :Server %s already exists", host);
if (bcptr == cptr)
{
/* Don't complain for servers that are juped */
/* (don't complain if the server that already exists is U: lined,
unless I actually have a .conf U: line for it */
if(!IsULine(acptr) || find_aUserver(acptr->name))
{
sendto_gnotice("from %s: Link %s cancelled, server %s already "
"exists", me.name, get_client_name(bcptr, HIDEME),
host);
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, "
"server %s already exists", me.name,
get_client_name(bcptr, HIDEME), host);
}
return exit_client(bcptr, bcptr, &me, "Server Exists");
}
/* inform all those who care (set +n) -epi */
strcpy(nbuf, get_client_name(bcptr, HIDEME));
sendto_gnotice("from %s: Link %s cancelled, server %s reintroduced "
"by %s", me.name, nbuf, host,
get_client_name(cptr, HIDEME));
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, server %s "
"reintroduced by %s", me.name, nbuf, host,
get_client_name(cptr, HIDEME));
exit_client(bcptr, bcptr, &me, "Server Exists");
}
/*
* The following if statement would be nice to remove since user
* nicks never have '.' in them and servers must always have '.' in
* them. There should never be a server/nick name collision, but it
* is possible a capricious server admin could deliberately do
* something strange.
*
* -Dianora
*/
if ((acptr = find_client(host, NULL)) && acptr != cptr)
{
/*
* * Server trying to use the same name as a person. Would
* cause a fair bit of confusion. Enough to make it hellish for
* a while and servers to send stuff to the wrong place.
*/
sendto_one(cptr, "ERROR :Nickname %s already exists!", host);
strcpy(nbuf, get_client_name(cptr, HIDEME));
sendto_gnotice("from %s: Link %s cancelled, servername/nick collision",
me.name, nbuf);
sendto_serv_butone(cptr, ":%s GNOTICE :Link %s cancelled, "
"servername/nick collision", me.name, nbuf);
return exit_client(cptr, cptr, cptr, "Nick as Server");
}
if (IsServer(cptr))
{
/*
* * Server is informing about a new server behind this link.
* Create REMOTE server structure, add it to list and propagate
* word to my other server links...
*/
if (parc == 1 || info[0] == '\0')
{
sendto_one(cptr, "ERROR :No server info specified for %s", host);
return 0;
}
/*
* * See if the newly found server is behind a guaranteed leaf
* (L-line). If so, close the link.
*
* Depreciated. Kinda redundant with Hlines. -epi
*/
if (!(cptr->serv->aconn->flags & CONN_HUB))
{
aconn = cptr->serv->aconn;
sendto_gnotice("from %s: Non-Hub link %s introduced %s",
me.name, get_client_name(cptr, HIDEME), host);
sendto_serv_butone(cptr,":%s GNOTICE :Non-Hub link %s introduced "
"%s", me.name, get_client_name(cptr, HIDEME),
host);
sendto_one(cptr, "ERROR :You're not a hub (introducing %s)",
host);
return exit_client(cptr, cptr, cptr, "Too many servers");
}
acptr = make_client(cptr, sptr);
make_server(acptr);
acptr->hopcount = hop;
strncpyzt(acptr->name, host, sizeof(acptr->name));
strncpyzt(acptr->info, info, REALLEN + 1);
acptr->serv->up = find_or_add(parv[0]);
fakelinkserver_update(acptr->name, acptr->info);
SetServer(acptr);
/*
* if this server is behind a U-lined server, make it U-lined as
* well. - lucas
*/
if (IsULine(sptr) || find_aUserver(acptr->name))
{
acptr->flags |= FLAGS_ULINE;
sendto_realops_lev(DEBUG_LEV, "%s introducing super server %s",
cptr->name, acptr->name);
}
Count.server++;
add_client_to_list(acptr);
add_to_client_hash_table(acptr->name, acptr);
/*
* Old sendto_serv_but_one() call removed because we now need
* to send different names to different servers (domain name matching)
*/
for (i = 0; i <= highest_fd; i++)
{
if (!(bcptr = local[i]) || !IsServer(bcptr) || bcptr == cptr ||
IsMe(bcptr))
continue;
if (!(aconn = bcptr->serv->aconn))
{
sendto_gnotice("from %s: Lost Connect block for %s on %s."
" Closing", me.name,
get_client_name(cptr, HIDEME), host);
sendto_serv_butone(cptr, ":%s GNOTICE :Lost Connect block for"
" %s on %s. Closing", me.name,
get_client_name(cptr, HIDEME), host);
return exit_client(cptr, cptr, cptr, "Lost Connect block");
}
if (match(my_name_for_link(me.name, aconn), acptr->name) == 0)
continue;
sendto_one(bcptr, ":%s SERVER %s %d :%s",
parv[0], acptr->name, hop + 1, acptr->info);
}
return 0;
}
return 0;
}
/* handle_special()
*
* inputs - client pointer
* - nick stuff to grok for opers
* - text to send if grok
* output - none
* side effects - old style username@server is handled here for non opers
* opers are allowed username%hostname@server
* all the traditional oper type messages are also parsed here.
* i.e. "/msg #some.host."
* However, syntax has been changed.
* previous syntax "/msg #some.host.mask"
* now becomes "/msg $#some.host.mask"
* previous syntax of: "/msg $some.server.mask" remains
* This disambiguates the syntax.
*
* XXX N.B. dalnet changed it to nick@server as have other servers.
* we will stick with tradition for now.
* - Dianora
*/
static void
handle_special(int p_or_n, const char *command, struct Client *source_p,
const char *nick, const char *text)
{
struct Client *target_p = NULL;
const char *server = NULL, *s = NULL;
/*
* user[%host]@server addressed?
*/
if ((server = strchr(nick, '@')))
{
if ((target_p = hash_find_server(server + 1)) == NULL)
{
sendto_one_numeric(source_p, &me, ERR_NOSUCHSERVER, server + 1);
return;
}
if (!HasUMode(source_p, UMODE_OPER) && strchr(nick, '%'))
{
sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, nick);
return;
}
if (!IsMe(target_p))
{
sendto_one(target_p, ":%s %s %s :%s", source_p->id, command, nick, text);
return;
}
sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, nick);
return;
}
if (!HasUMode(source_p, UMODE_OPER))
{
sendto_one_numeric(source_p, &me, ERR_NOPRIVILEGES);
return;
}
/*
* The following two cases allow masks in NOTICEs
* (for OPERs only)
*
* Armin, 8Jun90 ([email protected])
*/
if (*nick == '$')
{
if (*(nick + 1) == '$' || *(nick + 1) == '#')
++nick;
else if (MyClient(source_p))
{
sendto_one_notice(source_p, &me, ":The command %s %s is no longer supported, please use $%s",
command, nick, nick);
return;
}
if ((s = strrchr(nick, '.')) == NULL)
{
sendto_one_numeric(source_p, &me, ERR_NOTOPLEVEL, nick);
return;
}
while (*++s)
if (*s == '.' || *s == '*' || *s == '?')
break;
if (*s == '*' || *s == '?')
{
sendto_one_numeric(source_p, &me, ERR_WILDTOPLEVEL, nick);
return;
}
sendto_match_butone(IsServer(source_p->from) ? source_p->from : NULL, source_p,
nick + 1, (*nick == '#') ? MATCH_HOST : MATCH_SERVER,
"%s $%s :%s", command, nick, text);
}
}
/* Rewritten by Run - 24 sept 94 */
static void exit_one_client(struct Client* bcptr, const char* comment)
{
struct SLink *lp;
struct Ban *bp;
if (cli_serv(bcptr) && cli_serv(bcptr)->client_list) /* Was SetServerYXX called ? */
ClearServerYXX(bcptr); /* Removes server from server_list[] */
if (IsUser(bcptr)) {
/*
* clear out uping requests
*/
if (IsUPing(bcptr))
uping_cancel(bcptr, 0);
/*
* Stop a running /LIST clean
*/
if (MyUser(bcptr) && cli_listing(bcptr)) {
MyFree(cli_listing(bcptr));
cli_listing(bcptr) = NULL;
}
/*
* 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*)
*/
sendcmdto_common_channels_butone(bcptr, CMD_QUIT, NULL, ":%s", comment);
remove_user_from_all_channels(bcptr);
/* Clean up invitefield */
while ((lp = cli_user(bcptr)->invited))
del_invite(bcptr, lp->value.chptr);
/* Clean up silencefield */
while ((bp = cli_user(bcptr)->silence)) {
cli_user(bcptr)->silence = bp->next;
free_ban(bp);
}
/* Clean up snotice lists */
if (MyUser(bcptr))
set_snomask(bcptr, ~0, SNO_DEL);
if (IsInvisible(bcptr)) {
assert(UserStats.inv_clients > 0);
--UserStats.inv_clients;
}
if (IsOper(bcptr)) {
assert(UserStats.opers > 0);
--UserStats.opers;
}
if (MyConnect(bcptr))
Count_clientdisconnects(bcptr, UserStats);
else
Count_remoteclientquits(UserStats, bcptr);
}
else if (IsServer(bcptr))
{
/* Remove downlink list node of uplink */
remove_dlink(&(cli_serv(cli_serv(bcptr)->up))->down, cli_serv(bcptr)->updown);
cli_serv(bcptr)->updown = 0;
if (MyConnect(bcptr))
Count_serverdisconnects(UserStats);
else
Count_remoteserverquits(UserStats);
}
else if (IsMe(bcptr))
{
sendto_opmask_butone(0, SNO_OLDSNO, "ERROR: tried to exit me! : %s",
comment);
return; /* ...must *never* exit self! */
}
else if (IsUnknown(bcptr) || IsConnecting(bcptr) || IsHandshake(bcptr))
Count_unknowndisconnects(UserStats);
/*
* Update IPregistry
*/
if (IsIPChecked(bcptr))
IPcheck_disconnect(bcptr);
/*
* Remove from serv->client_list
* NOTE: user is *always* NULL if this is a server
*/
if (cli_user(bcptr)) {
assert(!IsServer(bcptr));
/* bcptr->user->server->serv->client_list[IndexYXX(bcptr)] = NULL; */
RemoveYXXClient(cli_user(bcptr)->server, cli_yxx(bcptr));
}
/* Remove bcptr from the client list */
#ifdef DEBUGMODE
if (hRemClient(bcptr) != 0)
Debug((DEBUG_ERROR, "%p !in tab %s[%s] %p %p %p %d %d %p",
bcptr, cli_name(bcptr), cli_from(bcptr) ? cli_sockhost(cli_from(bcptr)) : "??host",
cli_from(bcptr), cli_next(bcptr), cli_prev(bcptr), cli_fd(bcptr),
cli_status(bcptr), cli_user(bcptr)));
#else
hRemClient(bcptr);
#endif
remove_client_from_list(bcptr);
}