/** 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_butone(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]);
/* Attach any necessary UWorld config items. */
attach_confs_byhost(cptr, host, CONF_UWORLD);
if (*parv[7] == '+')
set_server_flags(acptr, parv[7] + 1);
Count_newremoteserver(UserStats);
if (Protocol(acptr) < 10)
SetFlag(acptr, FLAG_TS8);
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_butone(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;
}
/** Modify a global Z-line.
* @param[in] cptr Client that sent us the Z-line modification.
* @param[in] sptr Client that originated the Z-line modification.
* @param[in] zline Z-line being modified.
* @param[in] action Resultant status of the Z-line.
* @param[in] reason Reason for Z-line.
* @param[in] expire Expiration time of Z-line.
* @param[in] lastmod Last modification time of Z-line.
* @param[in] lifetime Lifetime of Z-line.
* @param[in] flags Bitwise combination of ZLINE_* flags.
* @return Zero or CPTR_KILLED, depending on whether \a sptr is suicidal.
*/
int
zline_modify(struct Client *cptr, struct Client *sptr, struct Zline *zline,
enum ZlineAction action, char *reason, time_t expire,
time_t lastmod, time_t lifetime, unsigned int flags)
{
char buf[BUFSIZE], *op = "";
int pos = 0, non_auto = 0;
assert(zline);
assert(!ZlineIsLocal(zline));
Debug((DEBUG_DEBUG, "zline_modify(\"%s\", \"%s\", \"%s\", %s, \"%s\", "
"%Tu, %Tu, %Tu, 0x%04x)", cli_name(cptr), cli_name(sptr),
zline->zl_mask,
action == ZLINE_ACTIVATE ? "ZLINE_ACTIVATE" :
(action == ZLINE_DEACTIVATE ? "ZLINE_DEACTIVATE" :
(action == ZLINE_LOCAL_ACTIVATE ? "ZLINE_LOCAL_ACTIVATE" :
(action == ZLINE_LOCAL_DEACTIVATE ? "ZLINE_LOCAL_DEACTIVATE" :
(action == ZLINE_MODIFY ? "ZLINE_MODIFY" : "<UNKNOWN>")))),
reason, expire, lastmod, lifetime, flags));
/* First, let's check lastmod... */
if (action != ZLINE_LOCAL_ACTIVATE && action != ZLINE_LOCAL_DEACTIVATE) {
if (ZlineLastMod(zline) > lastmod) { /* we have a more recent version */
if (IsBurstOrBurstAck(cptr))
return 0; /* middle of a burst, it'll resync on its own */
return zline_resend(cptr, zline); /* resync the server */
} else if (ZlineLastMod(zline) == lastmod)
return 0; /* we have that version of the Z-line... */
}
/* All right, we know that there's a change of some sort. What is it? */
/* first, check out the expiration time... */
if ((flags & ZLINE_EXPIRE) && expire) {
if (!(flags & ZLINE_FORCE) &&
(expire <= TStime() || expire > TStime() + ZLINE_MAX_EXPIRE)) {
if (!IsServer(sptr) && MyConnect(sptr)) /* bad expiration time */
send_reply(sptr, ERR_BADEXPIRE, expire);
return 0;
}
} else
flags &= ~ZLINE_EXPIRE;
/* Now check to see if there's any change... */
if ((flags & ZLINE_EXPIRE) && expire == zline->zl_expire) {
flags &= ~ZLINE_EXPIRE; /* no change to expiration time... */
expire = 0;
}
/* Next, check out lifetime--this one's a bit trickier... */
if (!(flags & ZLINE_LIFETIME) || !lifetime)
lifetime = zline->zl_lifetime; /* use Z-line lifetime */
lifetime = IRCD_MAX(lifetime, expire); /* set lifetime to the max */
/* OK, let's see which is greater... */
if (lifetime > zline->zl_lifetime)
flags |= ZLINE_LIFETIME; /* have to update lifetime */
else {
flags &= ~ZLINE_LIFETIME; /* no change to lifetime */
lifetime = 0;
}
/* Finally, let's see if the reason needs to be updated */
if ((flags & ZLINE_REASON) && reason &&
!ircd_strcmp(zline->zl_reason, reason))
flags &= ~ZLINE_REASON; /* no changes to the reason */
/* OK, now let's take a look at the action... */
if ((action == ZLINE_ACTIVATE && (zline->zl_flags & ZLINE_ACTIVE)) ||
(action == ZLINE_DEACTIVATE && !(zline->zl_flags & ZLINE_ACTIVE)) ||
(action == ZLINE_LOCAL_ACTIVATE &&
(zline->zl_state == ZLOCAL_ACTIVATED)) ||
(action == ZLINE_LOCAL_DEACTIVATE &&
(zline->zl_state == ZLOCAL_DEACTIVATED)) ||
/* can't activate an expired Z-line */
IRCD_MAX(zline->zl_expire, expire) <= TStime())
action = ZLINE_MODIFY; /* no activity state modifications */
Debug((DEBUG_DEBUG, "About to perform changes; flags 0x%04x, action %s",
flags, action == ZLINE_ACTIVATE ? "ZLINE_ACTIVATE" :
(action == ZLINE_DEACTIVATE ? "ZLINE_DEACTIVATE" :
(action == ZLINE_LOCAL_ACTIVATE ? "ZLINE_LOCAL_ACTIVATE" :
(action == ZLINE_LOCAL_DEACTIVATE ? "ZLINE_LOCAL_DEACTIVATE" :
(action == ZLINE_MODIFY ? "ZLINE_MODIFY" : "<UNKNOWN>"))))));
/* If there are no changes to perform, do no changes */
if (!(flags & ZLINE_UPDATE) && action == ZLINE_MODIFY)
return 0;
/* Now we know what needs to be changed, so let's process the changes... */
/* Start by updating lastmod, if indicated... */
if (action != ZLINE_LOCAL_ACTIVATE && action != ZLINE_LOCAL_DEACTIVATE)
zline->zl_lastmod = lastmod;
/* Then move on to activity status changes... */
switch (action) {
case ZLINE_ACTIVATE: /* Globally activating Z-line */
zline->zl_flags |= ZLINE_ACTIVE; /* make it active... */
zline->zl_state = ZLOCAL_GLOBAL; /* reset local activity state */
pos += ircd_snprintf(0, buf, sizeof(buf), " globally activating Z-line");
op = "+"; /* operation for Z-line propagation */
break;
case ZLINE_DEACTIVATE: /* Globally deactivating Z-line */
zline->zl_flags &= ~ZLINE_ACTIVE; /* make it inactive... */
zline->zl_state = ZLOCAL_GLOBAL; /* reset local activity state */
pos += ircd_snprintf(0, buf, sizeof(buf), " globally deactivating Z-line");
op = "-"; /* operation for Z-line propagation */
break;
case ZLINE_LOCAL_ACTIVATE: /* Locally activating Z-line */
zline->zl_state = ZLOCAL_ACTIVATED; /* make it locally active */
pos += ircd_snprintf(0, buf, sizeof(buf), " locally activating Z-line");
break;
case ZLINE_LOCAL_DEACTIVATE: /* Locally deactivating Z-line */
zline->zl_state = ZLOCAL_DEACTIVATED; /* make it locally inactive */
pos += ircd_snprintf(0, buf, sizeof(buf), " locally deactivating Z-line");
break;
case ZLINE_MODIFY: /* no change to activity status */
break;
}
/* Handle expiration changes... */
if (flags & ZLINE_EXPIRE) {
zline->zl_expire = expire; /* save new expiration time */
if (pos < BUFSIZE)
pos += ircd_snprintf(0, buf + pos, sizeof(buf) - pos,
"%s%s changing expiration time to %Tu",
pos ? ";" : "",
pos && !(flags & (ZLINE_LIFETIME | ZLINE_REASON)) ?
" and" : "", expire);
}
/* Next, handle lifetime changes... */
if (flags & ZLINE_LIFETIME) {
zline->zl_lifetime = lifetime; /* save new lifetime */
if (pos < BUFSIZE)
pos += ircd_snprintf(0, buf + pos, sizeof(buf) - pos,
"%s%s extending record lifetime to %Tu",
pos ? ";" : "", pos && !(flags & ZLINE_REASON) ?
" and" : "", lifetime);
}
/* Now, handle reason changes... */
if (flags & ZLINE_REASON) {
non_auto = non_auto || ircd_strncmp(zline->zl_reason, "AUTO", 4);
MyFree(zline->zl_reason); /* release old reason */
DupString(zline->zl_reason, reason); /* store new reason */
if (pos < BUFSIZE)
pos += ircd_snprintf(0, buf + pos, sizeof(buf) - pos,
"%s%s changing reason to \"%s\"",
pos ? ";" : "", pos ? " and" : "", reason);
}
/* All right, inform ops... */
non_auto = non_auto || ircd_strncmp(zline->zl_reason, "AUTO", 4);
sendto_opmask_butone(0, non_auto ? SNO_GLINE : SNO_AUTO,
"%s modifying global ZLINE for %s:%s",
(feature_bool(FEAT_HIS_SNOTICES) || IsServer(sptr)) ?
cli_name(sptr) : cli_name((cli_user(sptr))->server),
zline->zl_mask, buf);
/* and log the change */
log_write(LS_GLINE, L_INFO, LOG_NOSNOTICE,
"%#C modifying global ZLINE for %s:%s", sptr, zline->zl_mask, buf);
/* We'll be simple for this release, but we can update this to change
* the propagation syntax on future updates
*/
if (action != ZLINE_LOCAL_ACTIVATE && action != ZLINE_LOCAL_DEACTIVATE)
sendcmdto_serv_butone(sptr, CMD_ZLINE, cptr,
"* %s%s%s %Tu %Tu %Tu :%s",
flags & ZLINE_OPERFORCE ? "!" : "", op,
zline->zl_mask, zline->zl_expire - TStime(),
zline->zl_lastmod, zline->zl_lifetime, zline->zl_reason);
/* OK, let's do the Z-line... */
return do_zline(cptr, sptr, zline);
}
/*
* ms_create - server message handler
*/
int ms_create(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
time_t chanTS; /* channel creation time */
char *p; /* strtok state */
char *name; /* channel name */
struct Channel *chptr; /* channel */
struct JoinBuf join; /* join and create buffers */
struct JoinBuf create;
struct ModeBuf mbuf; /* a mode buffer */
int badop; /* a flag */
if (IsServer(sptr))
return protocol_violation(sptr,"%s tried to CREATE a channel", cli_name(sptr));
/* sanity checks: Only accept CREATE messages from servers */
if (parc < 3 || *parv[2] == '\0')
return need_more_params(sptr,"CREATE");
chanTS = atoi(parv[2]);
/* A create that didn't appear during a burst has that servers idea of
* the current time. Use it for lag calculations.
*/
if (!IsBurstOrBurstAck(sptr) && 0 != chanTS)
cli_serv(cli_user(sptr)->server)->lag = TStime() - chanTS;
/* If this server is >1 minute fast, warn */
if (TStime() - chanTS<-60)
{
static time_t rate;
sendto_opmask_butone_ratelimited(0, SNO_NETWORK, &rate,
"Timestamp drift from %C (%is); issuing "
"SETTIME to correct this",
cli_user(sptr)->server,
chanTS - TStime());
/* Now issue a SETTIME to resync. If we're in the wrong, our
* (RELIABLE_CLOCK) hub will bounce a SETTIME back to us.
*/
sendcmdto_prio_one(&me, CMD_SETTIME, cli_user(sptr)->server,
"%Tu %C", TStime(), cli_user(sptr)->server);
}
joinbuf_init(&join, sptr, cptr, JOINBUF_TYPE_JOIN, 0, 0);
joinbuf_init(&create, sptr, cptr, JOINBUF_TYPE_CREATE, 0, chanTS);
/* For each channel in the comma separated list: */
for (name = ircd_strtok(&p, parv[1], ","); name;
name = ircd_strtok(&p, 0, ",")) {
badop = 0;
if (IsLocalChannel(name))
continue;
if ((chptr = FindChannel(name)))
{
/* Is the remote server confused? */
if (find_member_link(chptr, sptr)) {
protocol_violation(sptr, "%s tried to CREATE a channel already joined (%s)", cli_name(sptr), chptr->chname);
continue;
}
/* Check if we need to bounce a mode */
if (TStime() - chanTS > TS_LAG_TIME ||
(chptr->creationtime && chanTS > chptr->creationtime &&
/* Accept CREATE for zannels. This is only really necessary on a network
with servers prior to 2.10.12.02: we just accept their TS and ignore
the fact that it was a zannel. The influence of this on a network
that is completely 2.10.12.03 or higher is neglectable: Normally
a server only sends a CREATE after first sending a DESTRUCT. Thus,
by receiving a CREATE for a zannel one of three things happened:
1. The DESTRUCT was sent during a net.break; this could mean that
our zannel is at the verge of expiring too, it should have been
destructed. It is correct to copy the newer TS now, all modes
already have been reset, so it will be as if it was destructed
and immediately recreated. In order to avoid desyncs of modes,
we don't accept a CREATE for channels that have +A set.
2. The DESTRUCT passed, then someone created the channel on our
side and left it again. In this situation we have a near
simultaneous creation on two servers; the person on our side
already left within the time span of a message propagation.
The channel will therefore be less than 48 hours old and no
'protection' is necessary.
3. The source server sent the CREATE while linking,
before it got the BURST for our zannel. If this
happens, we should reset the channel back to the old
timestamp. This can be distinguished from case #1 by
checking IsBurstOrBurstAck(cli_user(sptr)->server).
*/
!(chptr->users == 0 && !chptr->mode.apass[0]))) {
if (!IsBurstOrBurstAck(cli_user(sptr)->server)) {
modebuf_init(&mbuf, sptr, cptr, chptr,
(MODEBUF_DEST_SERVER | /* Send mode to server */
MODEBUF_DEST_HACK2 | /* Send a HACK(2) message */
MODEBUF_DEST_BOUNCE)); /* And bounce the mode */
modebuf_mode_client(&mbuf, MODE_ADD | MODE_CHANOP, sptr, MAXOPLEVEL + 1);
modebuf_flush(&mbuf);
badop = 1;
} else if (chanTS > chptr->creationtime + 4) {
/* If their handling of the BURST will lead to deopping the
* user, have the user join without getting ops (if the
* server's handling of the BURST keeps their ops, the channel
* will use our timestamp).
*/
badop = 1;
}
if (badop)
joinbuf_join(&join, chptr, 0);
}
}
else /* Channel doesn't exist: create it */
chptr = get_channel(sptr, name, CGT_CREATE);
if (!badop) {
/* Set (or correct) our copy of the TS */
chptr->creationtime = chanTS;
joinbuf_join(&create, chptr, CHFL_CHANOP);
}
}
joinbuf_flush(&join); /* flush out the joins and creates */
joinbuf_flush(&create);
return 0;
}
/*
* ms_kick - server message handler
*
* parv[0] = sender prefix
* parv[1] = channel
* parv[2] = client to kick
* parv[parc-1] = kick comment
*/
int ms_kick(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *who;
struct Channel *chptr;
struct Membership *member = 0, *sptr_link = 0;
char *name, *comment;
ClrFlag(sptr, FLAG_TS8);
if (parc < 3 || *parv[1] == '\0')
return need_more_params(sptr, "KICK");
name = parv[1];
comment = parv[parc - 1];
/* figure out who gets kicked from what */
if (IsLocalChannel(name) ||
!(chptr = get_channel(sptr, name, CGT_NO_CREATE)) ||
!(who = findNUser(parv[2])))
return 0;
/* We go ahead and pass on the KICK for users not on the channel */
member = find_member_link(chptr, who);
if (member && IsZombie(member))
{
/* We might get a KICK from a zombie's own server because the user
* net-rode during a burst (which always generates a KICK) *and*
* was kicked via another server. In that case, we must remove
* the user from the channel.
*/
if (sptr == cli_user(who)->server)
{
remove_user_from_channel(who, chptr);
}
/* Otherwise, we treat zombies like they are not channel members. */
member = 0;
}
/* Send HACK notice, but not for servers in BURST */
/* 2002-10-17: Don't send HACK if the users local server is kicking them */
if (IsServer(sptr)
&& !IsBurstOrBurstAck(sptr)
&& sptr!=cli_from(who))
sendto_opmask_butone(0, SNO_HACK4, "HACK: %C KICK %H %C %s", sptr, chptr,
who, comment);
/* Unless someone accepted it downstream (or the user isn't on the channel
* here), if kicker is not on channel, or if kicker is not a channel
* operator, bounce the kick
*
* Don't bounce the kick if it's coming from a channel service, regardless
* of channel membership. -- aaronc
*/
if (!IsServer(sptr) && !IsChannelService(sptr) && member && cli_from(who) != cptr &&
(!(sptr_link = find_member_link(chptr, sptr)) || (!IsChanOp(sptr_link) && !IsHalfOp(sptr_link)))) {
sendto_opmask_butone(0, SNO_HACK2, "HACK: %C KICK %H %C %s", sptr, chptr,
who, comment);
sendcmdto_one(who, CMD_JOIN, cptr, "%H", chptr);
/* Reop/revoice member */
if (IsChanOp(member) || IsHalfOp(member) || HasVoice(member)) {
struct ModeBuf mbuf;
modebuf_init(&mbuf, sptr, cptr, chptr,
(MODEBUF_DEST_SERVER | /* Send mode to a server */
MODEBUF_DEST_DEOP | /* Deop the source */
MODEBUF_DEST_BOUNCE)); /* And bounce the MODE */
if (IsChanOp(member))
modebuf_mode_client(&mbuf, MODE_DEL | MODE_CHANOP, who);
if (IsHalfOp(member))
modebuf_mode_client(&mbuf, MODE_DEL | MODE_HALFOP, who);
if (HasVoice(member))
modebuf_mode_client(&mbuf, MODE_DEL | MODE_VOICE, who);
modebuf_flush(&mbuf);
}
} else {
/* Propagate kick... */
sendcmdto_serv_butone(sptr, CMD_KICK, cptr, "%H %C :%s", chptr, who,
comment);
if (member) { /* and tell the channel about it */
sendcmdto_channel_butserv_butone(IsServer(sptr) ? (feature_bool(FEAT_HIS_HIDEWHO) ? &his : &me) : sptr,
CMD_KICK, chptr, NULL, 0, "%H %C :%s", chptr, who,
comment);
make_zombie(member, who, cptr, sptr, chptr);
}
}
return 0;
}
/*
* ms_nick - server message handler for nicks
* parv[0] = sender prefix
* parv[1] = nickname
*
* If from server, source is client:
* parv[2] = timestamp
*
* Source is server:
* parv[2] = hopcount
* parv[3] = timestamp
* parv[4] = username
* parv[5] = hostname
* parv[6] = umode (optional)
* parv[parc-3] = IP# <- Only Protocol >= 10
* parv[parc-2] = YXX, numeric nick <- Only Protocol >= 10
* parv[parc-1] = info
* parv[0] = server
*/
int ms_nick(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Client *acptr;
char nick[NICKLEN + 2];
time_t lastnick = 0;
int differ = 1;
const char *type;
assert(0 != cptr);
assert(0 != sptr);
assert(IsServer(cptr));
if ((IsServer(sptr) && parc < 8) || parc < 3)
{
sendto_opmask_butone(0, SNO_OLDSNO, "bad NICK param count for %s from %C",
parv[1], cptr);
return need_more_params(sptr, "NICK");
}
ircd_strncpy(nick, parv[1], NICKLEN);
nick[NICKLEN] = '\0';
if (IsServer(sptr))
{
lastnick = atoi(parv[3]);
if (lastnick > OLDEST_TS && !IsBurstOrBurstAck(sptr))
cli_serv(sptr)->lag = TStime() - lastnick;
}
else
{
lastnick = atoi(parv[2]);
if (lastnick > OLDEST_TS && !IsBurstOrBurstAck(sptr))
cli_serv(cli_user(sptr)->server)->lag = TStime() - lastnick;
}
/*
* If do_nick_name() returns a null name OR if the server sent a nick
* name and do_nick_name() changed it in some way (due to rules of nick
* creation) then reject it. If from a server and we reject it,
* and KILL it. -avalon 4/4/92
*/
if (!do_nick_name(nick) || strcmp(nick, parv[1]))
{
send_reply(sptr, ERR_ERRONEUSNICKNAME, parv[1]);
++ServerStats->is_kill;
sendto_opmask_butone(0, SNO_OLDSNO, "Bad Nick: %s From: %s %C", parv[1],
parv[0], cptr);
sendcmdto_one(&me, CMD_KILL, cptr, "%s :%s (%s <- %s[%s])",
IsServer(sptr) ? parv[parc - 2] : parv[0], cli_name(&me), parv[1],
nick, cli_name(cptr));
if (!IsServer(sptr))
{
/*
* bad nick _change_
*/
sendcmdto_serv_butone(&me, CMD_KILL, 0, "%s :%s (%s <- %s!%s@%s)",
parv[0], cli_name(&me), cli_name(cptr), parv[0],
cli_user(sptr) ? cli_username(sptr) : "",
cli_user(sptr) ? cli_name(cli_user(sptr)->server) :
cli_name(cptr));
}
return 0;
}
/* Check against nick name collisions. */
if ((acptr = SeekClient(nick)) == NULL)
/* No collisions, all clear... */
return set_nick_name(cptr, sptr, nick, parc, parv, 0);
/*
* If acptr == sptr, then we have a client doing a nick
* change between *equivalent* nicknames as far as server
* is concerned (user is changing the case of his/her
* nickname or somesuch)
*/
if (acptr == sptr)
{
if (strcmp(cli_name(acptr), nick) != 0)
/* Allows change of case in his/her nick */
return set_nick_name(cptr, sptr, nick, parc, parv, 0);
else
/* Setting their nick to what it already is? Ignore it. */
return 0;
}
/* now we know we have a real collision. */
/*
* Note: From this point forward it can be assumed that
* acptr != sptr (point to different client structures).
*/
assert(acptr != sptr);
/*
* If the older one is "non-person", the new entry is just
* allowed to overwrite it. Just silently drop non-person,
* and proceed with the nick. This should take care of the
* "dormant nick" way of generating collisions...
*/
if (IsUnknown(acptr) && MyConnect(acptr))
{
ServerStats->is_ref++;
if (!find_except_conf(acptr, EFLAG_IPCHECK))
IPcheck_connect_fail(acptr, 0);
exit_client(cptr, acptr, &me, "Overridden by other sign on");
return set_nick_name(cptr, sptr, nick, parc, parv, 0);
}
/*
* Decide, we really have a nick collision and deal with it
*/
/*
* NICK was coming from a server connection.
* This means we have a race condition (two users signing on
* at the same time), or two net fragments reconnecting with the same nick.
* The latter can happen because two different users connected
* or because one and the same user switched server during a net break.
* If the TimeStamps are equal, we kill both (or only 'new'
* if it was a ":server NICK new ...").
* Otherwise we kill the youngest when user@host differ,
* or the oldest when they are the same.
* We treat user and ~user as different, because if it wasn't
* a faked ~user the AUTH wouldn't have added the '~'.
* --Run
*
*/
if (IsServer(sptr))
{
struct irc_in_addr ip;
/*
* A new NICK being introduced by a neighbouring
* server (e.g. message type ":server NICK new ..." received)
*
* compare IP address and username
*/
base64toip(parv[parc - 3], &ip);
differ = (0 != memcmp(&cli_ip(acptr), &ip, sizeof(cli_ip(acptr)))) ||
(0 != ircd_strcmp(cli_user(acptr)->username, parv[4]));
sendto_opmask_butone(0, SNO_OLDSNO, "Nick collision on %C (%C %Tu <- "
"%C %Tu (%s user@host))", acptr, cli_from(acptr),
cli_lastnick(acptr), cptr, lastnick,
differ ? "Different" : "Same");
}
else
{
/*
* A NICK change has collided (e.g. message type ":old NICK new").
*
* compare IP address and username
*/
differ = (0 != memcmp(&cli_ip(acptr), &cli_ip(sptr), sizeof(cli_ip(acptr)))) ||
(0 != ircd_strcmp(cli_user(acptr)->username, cli_user(sptr)->username));
sendto_opmask_butone(0, SNO_OLDSNO, "Nick change collision from %C to "
"%C (%C %Tu <- %C %Tu)", sptr, acptr, cli_from(acptr),
cli_lastnick(acptr), cptr, lastnick);
}
type = differ ? "overruled by older nick" : "nick collision from same user@host";
/*
* Now remove (kill) the nick on our side if it is the youngest.
* If no timestamp was received, we ignore the incoming nick
* (and expect a KILL for our legit nick soon ):
* When the timestamps are equal we kill both nicks. --Run
* acptr->from != cptr should *always* be true (?).
*
* This exits the client sending the NICK message
*/
if ((differ && lastnick >= cli_lastnick(acptr)) ||
(!differ && lastnick <= cli_lastnick(acptr)))
{
ServerStats->is_kill++;
if (!IsServer(sptr))
{
/* If this was a nick change and not a nick introduction, we
* need to ensure that we remove our record of the client, and
* send a KILL to the whole network.
*/
assert(!MyConnect(sptr));
/* Inform the rest of the net... */
sendcmdto_serv_butone(&me, CMD_KILL, 0, "%C :%s (%s)",
sptr, cli_name(&me), type);
/* Don't go sending off a QUIT message... */
SetFlag(sptr, FLAG_KILLED);
/* Remove them locally. */
exit_client_msg(cptr, sptr, &me,
"Killed (%s (%s))",
feature_str(FEAT_HIS_SERVERNAME), type);
}
else
{
/* If the origin is a server, this was a new client, so we only
* send the KILL in the direction it came from. We have no
* client record that we would have to clean up.
*/
sendcmdto_one(&me, CMD_KILL, cptr, "%s :%s (%s)",
parv[parc - 2], cli_name(&me), type);
}
/* If the timestamps differ and we just killed sptr, we don't need to kill
* acptr as well.
*/
if (lastnick != cli_lastnick(acptr))
return 0;
}
/* Tell acptr why we are killing it. */
send_reply(acptr, ERR_NICKCOLLISION, nick);
ServerStats->is_kill++;
SetFlag(acptr, FLAG_KILLED);
/*
* This exits the client we had before getting the NICK message
*/
sendcmdto_serv_butone(&me, CMD_KILL, NULL, "%C :%s (%s)",
acptr, feature_str(FEAT_HIS_SERVERNAME),
type);
exit_client_msg(cptr, acptr, &me, "Killed (%s (%s))",
feature_str(FEAT_HIS_SERVERNAME), type);
if (lastnick == cli_lastnick(acptr))
return 0;
if (sptr == NULL)
return 0;
return set_nick_name(cptr, sptr, nick, parc, parv, 0);
}
/** Send a (prefixed) command to all users on this channel, except for
* \a one and those matching \a skip.
* @warning \a pattern must not contain %v.
* @param[in] from Client originating the command.
* @param[in] cmd Long name of command.
* @param[in] tok Short name of command.
* @param[in] to Destination channel.
* @param[in] one Client direction to skip (or NULL).
* @param[in] skip Bitmask of SKIP_NONOPS, SKIP_NONVOICES, SKIP_DEAF, SKIP_BURST.
* @param[in] pattern Format string for command arguments.
*/
void sendcmdto_channel_butone(struct Client *from, const char *cmd,
const char *tok, struct Channel *to,
struct Client *one, unsigned int skip,
unsigned char prefix, const char *pattern, ...)
{
struct Membership *member;
struct VarData vd;
struct MsgBuf *user_mb;
struct MsgBuf *serv_mb;
struct Client *service;
const char *userfmt;
const char *usercmd;
vd.vd_format = pattern;
/* Build buffer to send to users */
usercmd = cmd;
userfmt = "%:#C %s %v";
if (skip & (SKIP_NONOPS | SKIP_NONHOPS | SKIP_NONVOICES)) {
usercmd = MSG_NOTICE;
if (skip & SKIP_NONVOICES)
userfmt = "%:#C %s +%v";
else if (skip & SKIP_NONHOPS)
userfmt = "%:#C %s %%%v";
else
userfmt = "%:#C %s @%v";
}
va_start(vd.vd_args, pattern);
user_mb = msgq_make(0, userfmt, from, usercmd, &vd);
va_end(vd.vd_args);
/* Build buffer to send to servers */
va_start(vd.vd_args, pattern);
serv_mb = msgq_make(&me, "%C %s %v", from, tok, &vd);
va_end(vd.vd_args);
/* send buffer along! */
bump_sentalong(one);
for (member = to->members; member; member = member->next_member) {
/* skip one, zombies, and deaf users... */
if (IsZombie(member) ||
(skip & SKIP_DEAF && IsDeaf(member->user)) ||
(skip & SKIP_NONOPS && !IsChanOp(member)) ||
(skip & SKIP_NONHOPS && !IsChanOp(member) && !IsHalfOp(member)) ||
(skip & SKIP_NONVOICES && !IsChanOp(member) && !IsHalfOp(member) && !HasVoice(member)) ||
(skip & SKIP_BURST && IsBurstOrBurstAck(cli_from(member->user))) ||
(is_silenced(from, member->user, 1)) ||
cli_fd(cli_from(member->user)) < 0 ||
cli_sentalong(member->user) == sentalong_marker)
continue;
cli_sentalong(member->user) = sentalong_marker;
if (MyConnect(member->user)) /* pick right buffer to send */
send_buffer(member->user, user_mb, 0);
else
send_buffer(member->user, serv_mb, 0);
}
/* Consult service forwarding table. */
if(GlobalForwards[prefix]
&& (service = FindServer(GlobalForwards[prefix]))
&& cli_sentalong(service) != sentalong_marker) {
cli_sentalong(service) = sentalong_marker;
send_buffer(service, serv_mb, 0);
}
msgq_clean(user_mb);
msgq_clean(serv_mb);
}
/*
* ms_gline - server message handler
*
* parv[0] = Sender prefix
* parv[1] = Target: server numeric
* parv[2] = (+|-)<G-line mask>
* parv[3] = G-line lifetime
*
* From Uworld:
*
* parv[4] = Comment
*
* From somewhere else:
*
* parv[4] = Last modification time
* parv[5] = Comment
*
*/
int
ms_gline(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *acptr = 0;
struct Gline *agline;
unsigned int flags = 0;
time_t expire_off, lastmod = 0;
char *mask = parv[2], *target = parv[1], *reason = "No reason";
if (*mask == '!') {
mask++;
flags |= GLINE_OPERFORCE; /* assume oper had WIDE_GLINE */
}
if ((parc == 3 && *mask == '-') || parc == 5) {
if (!find_conf_byhost(cli_confs(cptr), cli_name(sptr), CONF_UWORLD))
return need_more_params(sptr, "GLINE");
if (parc > 4)
reason = parv[4];
flags |= GLINE_FORCE;
} else if (parc > 5) {
lastmod = atoi(parv[4]);
reason = parv[5];
} else
return need_more_params(sptr, "GLINE");
if (!(target[0] == '*' && target[1] == '\0')) {
if (!(acptr = FindNServer(target)))
return 0; /* no such server */
if (!IsMe(acptr)) { /* manually propagate */
if (!lastmod)
sendcmdto_one(sptr, CMD_GLINE, acptr,
(parc == 3) ? "%C %s" : "%C %s %s :%s", acptr, mask,
parv[3], reason);
else
sendcmdto_one(sptr, CMD_GLINE, acptr, "%C %s%s %s %s :%s", acptr,
flags & GLINE_OPERFORCE ? "!" : "", mask, parv[3],
parv[4], reason);
return 0;
}
flags |= GLINE_LOCAL;
}
if (*mask == '-')
mask++;
else if (*mask == '+') {
flags |= GLINE_ACTIVE;
mask++;
} else
flags |= GLINE_ACTIVE;
expire_off = parc < 5 ? 0 : atoi(parv[3]);
agline = gline_find(mask, GLINE_ANY | GLINE_EXACT);
if (agline) {
if (GlineIsLocal(agline) && !(flags & GLINE_LOCAL)) /* global over local */
gline_free(agline);
else if (!lastmod && ((flags & GLINE_ACTIVE) == GlineIsRemActive(agline)))
return gline_propagate(cptr, sptr, agline);
else if (!lastmod || GlineLastMod(agline) < lastmod) { /* new mod */
if (flags & GLINE_ACTIVE)
return gline_activate(cptr, sptr, agline, lastmod, flags);
else
return gline_deactivate(cptr, sptr, agline, lastmod, flags);
} else if (GlineLastMod(agline) == lastmod || IsBurstOrBurstAck(cptr))
return 0;
else
return gline_resend(cptr, agline); /* other server desynched WRT gline */
} else if (parc == 3 && !(flags & GLINE_ACTIVE)) {
/* U-lined server removing a G-line we don't have; propagate the removal
* anyway.
*/
if (!(flags & GLINE_LOCAL))
sendcmdto_serv_butone(sptr, CMD_GLINE, cptr, "* -%s", mask);
return 0;
} else if (parc < 5)
return need_more_params(sptr, "GLINE");
return gline_add(cptr, sptr, mask, reason, expire_off, lastmod, flags);
}
/*
* ms_invite - server message handler
*
* parv[0] - sender prefix
* parv[1] - user to invite
* parv[2] - channel name
* parv[3] - (optional) channel timestamp
*
* - INVITE now is accepted only if who does it is chanop (this of course
* implies that channel must exist and he must be on it).
*
* - On the other side it IS processed even if channel is NOT invite only
* leaving room for other enhancements like inviting banned ppl. -- Nemesi
*
* - Invite with no parameters now lists the channels you are invited to.
* - Isomer 23 Oct 99
*
* - Invite with too-late timestamp, or with no timestamp from a bursting
* server, is silently discarded. - Entrope 19 Jan 05
*/
int ms_invite(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Client *acptr;
struct Channel *chptr;
time_t invite_ts;
if (IsServer(sptr)) {
/*
* this will blow up if we get an invite from a server
* we look for channel membership in sptr below.
*/
return protocol_violation(sptr,"Server attempting to invite");
}
if (parc < 3 || EmptyString(parv[2])) {
/*
* should have been handled upstream, ignore it.
*/
protocol_violation(sptr,"Too few arguments to invite");
return need_more_params(sptr,"INVITE");
}
if (!IsGlobalChannel(parv[2])) {
/*
* should not be sent
*/
return protocol_violation(sptr, "Invite to a non-standard channel %s",parv[2]);
}
if (!(acptr = FindUser(parv[1]))) {
send_reply(sptr, ERR_NOSUCHNICK, parv[1]);
return 0;
}
if (!(chptr = FindChannel(parv[2]))) {
/*
* allow invites to non existant channels, bleah
* avoid JOIN, INVITE, PART abuse
*/
sendcmdto_one(sptr, CMD_INVITE, acptr, "%C :%s", acptr, parv[2]);
return 0;
}
if (parc > 3) {
invite_ts = atoi(parv[3]);
if (invite_ts > chptr->creationtime)
return 0;
} else if (IsBurstOrBurstAck(cptr))
return 0;
if (!IsChannelService(sptr) && !find_channel_member(sptr, chptr)) {
send_reply(sptr, ERR_NOTONCHANNEL, chptr->chname);
return 0;
}
if (find_channel_member(acptr, chptr)) {
send_reply(sptr, ERR_USERONCHANNEL, cli_name(acptr), chptr->chname);
return 0;
}
if (is_silenced(sptr, acptr) && !is_silence_exempted(sptr, acptr))
return 0;
if (MyConnect(acptr)) {
add_invite(acptr, chptr);
sendcmdto_one(sptr, CMD_INVITE, acptr, "%s :%H", cli_name(acptr), chptr);
} else {
sendcmdto_one(sptr, CMD_INVITE, acptr, "%s %H %Tu", cli_name(acptr), chptr,
chptr->creationtime);
}
if (feature_bool(FEAT_ANNOUNCE_INVITES)) {
/* Announce to channel operators. */
sendcmdto_channel_butserv_butone(feature_bool(FEAT_HIS_HIDEWHO) ? &his : &me,
get_error_numeric(RPL_ISSUEDINVITE)->str,
NULL, chptr, sptr, SKIP_NONOPS,
"%H %C %C :%C has been invited by %C",
chptr, acptr, sptr, acptr, sptr);
/* Announce to servers with channel operators. */
sendcmdto_channel_servers_butone(sptr, NULL, TOK_INVITE, chptr, acptr, SKIP_NONOPS,
"%s %H %Tu", cli_name(acptr), chptr,
chptr->creationtime);
}
return 0;
}
