* the 'channel owners' can't get in because of a key
* or ban then apparently there was a fight/takeover
* on the channel and we want them to contact IRC opers
- * who then will educate them on the use of Apass/upass.
+ * who then will educate them on the use of Apass/Upass.
*/
+ if (!chptr->mode.apass[0]) /* If no Apass, reset all modes. */
+ {
+ struct Ban *link, *next;
+ chptr->mode.mode = 0;
+ *chptr->mode.key = '\0';
+ while (chptr->invites)
+ del_invite(chptr->invites->value.cptr, chptr);
+ for (link = chptr->banlist; link; link = next) {
+ next = link->next;
+ free_ban(link);
+ }
+ chptr->banlist = NULL;
- if (!chptr->mode.apass[0]) /* If no Apass, destroy now. */
- destruct_channel(chptr);
- else if (TStime() - chptr->creationtime < 172800) /* Channel younger than 48 hours? */
+ /* Immediately destruct empty -A channels if not using apass. */
+ if (!feature_bool(FEAT_OPLEVELS))
+ {
+ destruct_channel(chptr);
+ return 0;
+ }
+ }
+ if (TStime() - chptr->creationtime < 172800) /* Channel younger than 48 hours? */
schedule_destruct_event_1m(chptr); /* Get rid of it in approximately 4-5 minutes */
else
schedule_destruct_event_48h(chptr); /* Get rid of it in approximately 48 hours */
{
char nu[NICKLEN + USERLEN + 2];
char tmphost[HOSTLEN + 1];
+ char iphost[SOCKIPLEN + 1];
+ char *hostmask;
char *sr;
struct Ban *found;
/* Build nick!user and alternate host names. */
ircd_snprintf(0, nu, sizeof(nu), "%s!%s",
cli_name(cptr), cli_user(cptr)->username);
+ ircd_ntoa_r(iphost, &cli_ip(cptr));
if (!IsAccount(cptr))
sr = NULL;
else if (HasHiddenHost(cptr))
if (res)
continue;
/* Compare host portion of ban. */
+ hostmask = banlist->banstr + banlist->nu_len + 1;
if (!((banlist->flags & BAN_IPMASK)
&& ipmask_check(&cli_ip(cptr), &banlist->address, banlist->addrbits))
- && match(banlist->banstr + banlist->nu_len + 1, cli_user(cptr)->host)
- && !(sr && match(banlist->banstr + banlist->nu_len + 1, sr) == 0))
- continue;
+ && match(hostmask, cli_user(cptr)->host)
+ && !(sr && !match(hostmask, sr)))
+ continue;
/* If an exception matches, no ban can match. */
if (banlist->flags & BAN_EXCEPTION)
return NULL;
member->user = who;
member->channel = chptr;
member->status = flags;
- member->oplevel = oplevel;
+ SetOpLevel(member, oplevel);
member->next_member = chptr->members;
if (member->next_member)
*
* @param member The membership of the user
* @param reveal If true, the user will be "revealed" on a delayed
- * joined channel.
+ * joined channel.
*
* @returns True if the client can speak on the channel.
*/
{
assert(0 != member);
- /* Discourage using the Apass to get op. They should use the upass. */
- if (IsChannelManager(member) && *member->channel->mode.upass)
+ /* Do not check for users on other servers: This should be a
+ * temporary desynch, or maybe they are on an older server, but
+ * we do not want to send ERR_CANNOTSENDTOCHAN more than once.
+ */
+ if (!MyUser(member->user))
+ {
+ if (IsDelayedJoin(member) && reveal)
+ RevealDelayedJoin(member);
+ return 1;
+ }
+
+ /* Discourage using the Apass to get op. They should use the Upass. */
+ if (IsChannelManager(member) && member->channel->mode.apass[0])
return 0;
+ /* If you have voice or ops, you can speak. */
if (IsVoicedOrOpped(member))
return 1;
+
/*
* If it's moderated, and you aren't a privileged user, you can't
- * speak.
+ * speak.
*/
if (member->channel->mode.mode & MODE_MODERATED)
return 0;
+
/* If only logged in users may join and you're not one, you can't speak. */
if (member->channel->mode.mode & MODE_REGONLY && !IsAccount(member->user))
return 0;
- /*
- * If you're banned then you can't speak either.
- * but because of the amount of CPU time that is_banned chews
- * we only check it for our clients.
- */
- if (MyUser(member->user) && is_banned(member))
+
+ /* If you're banned then you can't speak either. */
+ if (is_banned(member))
return 0;
if (IsDelayedJoin(member) && reveal)
struct Membership* member;
for (member = (cli_user(cptr))->channel; member;
member = member->next_channel) {
- if (!IsVoicedOrOpped(member) &&
- (is_banned(member) ||
- (member->channel->mode.mode & MODE_MODERATED)))
+ if (IsVoicedOrOpped(member))
+ continue;
+ if ((member->channel->mode.mode & MODE_MODERATED)
+ || (member->channel->mode.mode & MODE_REGONLY && !IsAccount(cptr))
+ || is_banned(member))
return member->channel->chname;
}
}
*mbuf++ = 'D';
else if (MyUser(cptr) && (chptr->mode.mode & MODE_WASDELJOINS))
*mbuf++ = 'd';
+ if (chptr->mode.mode & MODE_REGISTERED)
+ *mbuf++ = 'R';
if (chptr->mode.limit) {
*mbuf++ = 'l';
ircd_snprintf(0, pbuf, buflen, "%u", chptr->mode.limit);
int opped_members_index = 0;
struct Membership** opped_members = NULL;
int last_oplevel = 0;
- int feat_oplevels = (chptr->mode.apass[0]) != '\0';
+ int send_oplevels = 0;
assert(0 != cptr);
assert(0 != chptr);
++number_of_ops;
else
opped_members[opped_members_index++] = member;
+ /* We also send oplevels if anyone is below the weakest level. */
+ if (OpLevel(member) < MAXOPLEVEL)
+ send_oplevels = 1;
}
/* Only handle the members with the flags that we are interested in. */
if ((member->status & CHFL_VOICED_OR_OPPED) == current_flags[flag_cnt])
if (IsChanOp(member)) /* flag_cnt == 2 or 3 */
{
/* append the absolute value of the oplevel */
- if (feat_oplevels)
+ if (send_oplevels)
loc += ircd_snprintf(0, tbuf + loc, sizeof(tbuf) - loc, "%u", last_oplevel = member->oplevel);
else
tbuf[loc++] = 'o';
msgq_append(&me, mb, tbuf);
new_mode = 0;
}
- else if (feat_oplevels && flag_cnt > 1 && last_oplevel != member->oplevel)
+ else if (send_oplevels && flag_cnt > 1 && last_oplevel != member->oplevel)
{
/*
* This can't be the first member of a (continued) BURST
user = mask;
host = ++ptr;
}
- else if (*ptr == '.')
+ else if (*ptr == '.' || *ptr == ':')
{
- /* Case 2: Found last '.' (without finding a '!' or '@' yet) */
+ /* Case 2: Found character specific to IP or hostname (without
+ * finding a '!' or '@' yet) */
last_dot = ptr;
continue;
}
send_reply(cptr, RPL_ENDOFBANLIST, chptr->chname);
}
-/** Check a key against a keyring.
- * We are now treating the key part of /join channellist key as a key
- * ring; that is, we try one key against the actual channel key, and if that
- * doesn't work, we try the next one, and so on. -Kev -Texaco
- * Returns: 0 on match, 1 otherwise
- * This version contributed by SeKs \<intru@info.polymtl.ca\>
- *
- * @param key Key to check
- * @param keyring Comma separated list of keys
- *
- * @returns True if the key was found and matches, false otherwise.
- */
-static int compall(char *key, char *keyring)
-{
- char *p1;
-
-top:
- p1 = key; /* point to the key... */
- while (*p1 && *p1 == *keyring)
- { /* step through the key and ring until they
- don't match... */
- p1++;
- keyring++;
- }
-
- if (!*p1 && (!*keyring || *keyring == ','))
- /* ok, if we're at the end of the and also at the end of one of the keys
- in the keyring, we have a match */
- return 0;
-
- if (!*keyring) /* if we're at the end of the key ring, there
- weren't any matches, so we return 1 */
- return 1;
-
- /* Not at the end of the key ring, so step
- through to the next key in the ring: */
- while (*keyring && *(keyring++) != ',');
-
- goto top; /* and check it against the key */
-}
-
-/** Returns if a user can join a channel with a specific key.
- *
- * @param sptr The client trying to join
- * @param chptr The channel to join
- * @param key The key to use
- *
- * @returns any error that occurred bit-wise OR'd with MAGIC_OPER_OVERRIDE
- * if the oper used the magic key, 0 if no error occurred.
- */
-int can_join(struct Client *sptr, struct Channel *chptr, char *key)
-{
- int overrideJoin = 0;
-
- /*
- * Now a banned user CAN join if invited -- Nemesi
- * Now a user CAN escape channel limit if invited -- bfriendly
- * Now a user CAN escape anything if invited -- Isomer
- */
-
- if (IsInvited(sptr, chptr))
- return 0;
-
- /* An oper can force a join on a local channel using "OVERRIDE" as the key.
- a HACK(4) notice will be sent if he would not have been supposed
- to join normally. */
- if (IsLocalChannel(chptr->chname) && HasPriv(sptr, PRIV_WALK_LCHAN) &&
- !BadPtr(key) && compall("OVERRIDE",chptr->mode.key) != 0 &&
- compall("OVERRIDE",key) == 0)
- overrideJoin = MAGIC_OPER_OVERRIDE;
-
- if (chptr->mode.mode & MODE_INVITEONLY)
- return overrideJoin + ERR_INVITEONLYCHAN;
-
- if (chptr->mode.limit && chptr->users >= chptr->mode.limit)
- return overrideJoin + ERR_CHANNELISFULL;
-
- if ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(sptr))
- return overrideJoin + ERR_NEEDREGGEDNICK;
-
- if (find_ban(sptr, chptr->banlist))
- return overrideJoin + ERR_BANNEDFROMCHAN;
-
- /*
- * now using compall (above) to test against a whole key ring -Kev
- */
- if (*chptr->mode.key && (EmptyString(key) || compall(chptr->mode.key, key)))
- return overrideJoin + ERR_BADCHANNELKEY;
-
- if (overrideJoin)
- return ERR_DONTCHEAT;
-
- return 0;
-}
-
-/** Remove bells and commas from channel name
- *
- * @param cn Channel name to clean, modified in place.
- */
-void clean_channelname(char *cn)
-{
- int i;
-
- for (i = 0; cn[i]; i++) {
- if (i >= CHANNELLEN || !IsChannelChar(cn[i])) {
- cn[i] = '\0';
- return;
- }
- if (IsChannelLower(cn[i])) {
- cn[i] = ToLower(cn[i]);
-#ifndef FIXME
- /*
- * Remove for .08+
- * toupper(0xd0)
- */
- if ((unsigned char)(cn[i]) == 0xd0)
- cn[i] = (char) 0xf0;
-#endif
- }
- }
-}
-
/** Get a channel block, creating if necessary.
* Get Channel block for chname (and allocate a new channel
* block, if it didn't exists before).
MODE_NOPRIVMSGS, 'n',
MODE_REGONLY, 'r',
MODE_DELJOINS, 'D',
- MODE_WASDELJOINS, 'd',
+ MODE_REGISTERED, 'R',
/* MODE_KEY, 'k', */
/* MODE_BAN, 'b', */
MODE_LIMIT, 'l',
/* MODE_UPASS, 'U', */
0x0, 0x0
};
+ static int local_flags[] = {
+ MODE_WASDELJOINS, 'd',
+ 0x0, 0x0
+ };
int i;
int *flag_p;
struct Client *app_source; /* where the MODE appears to come from */
- char addbuf[20]; /* accumulates +psmtin, etc. */
- int addbuf_i = 0;
- char rembuf[20]; /* accumulates -psmtin, etc. */
- int rembuf_i = 0;
+ char addbuf[20], addbuf_local[20]; /* accumulates +psmtin, etc. */
+ int addbuf_i = 0, addbuf_local_i = 0;
+ char rembuf[20], rembuf_local[20]; /* accumulates -psmtin, etc. */
+ int rembuf_i = 0, rembuf_local_i = 0;
char *bufptr; /* we make use of indirection to simplify the code */
int *bufptr_i;
/* Ok, if we were given the OPMODE flag, or its a server, hide the source.
*/
- if (mbuf->mb_dest & MODEBUF_DEST_OPMODE || IsServer(mbuf->mb_source))
- app_source = &me;
+ if (feature_bool(FEAT_HIS_MODEWHO) &&
+ (mbuf->mb_dest & MODEBUF_DEST_OPMODE ||
+ IsServer(mbuf->mb_source) ||
+ IsMe(mbuf->mb_source)))
+ app_source = &his;
else
app_source = mbuf->mb_source;
rembuf[rembuf_i++] = flag_p[1];
}
+ /* Some flags may be for local display only. */
+ for (flag_p = local_flags; flag_p[0]; flag_p += 2) {
+ if (*flag_p & mbuf->mb_add)
+ addbuf_local[addbuf_local_i++] = flag_p[1];
+ else if (*flag_p & mbuf->mb_rem)
+ rembuf_local[rembuf_local_i++] = flag_p[1];
+ }
+
/* Now go through the modes with arguments... */
for (i = 0; i < mbuf->mb_count; i++) {
if (MB_TYPE(mbuf, i) & MODE_ADD) { /* adding or removing? */
if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE)) {
tmp = strlen(cli_name(MB_CLIENT(mbuf, i)));
- if ((totalbuflen - IRCD_MAX(5, tmp)) <= 0) /* don't overflow buffer */
+ if ((totalbuflen - IRCD_MAX(9, tmp)) <= 0) /* don't overflow buffer */
MB_TYPE(mbuf, i) |= MODE_SAVE; /* save for later */
else {
bufptr[(*bufptr_i)++] = MB_TYPE(mbuf, i) & MODE_CHANOP ? 'o' : 'v';
- totalbuflen -= IRCD_MAX(5, tmp) + 1;
+ totalbuflen -= IRCD_MAX(9, tmp) + 1;
}
} else if (MB_TYPE(mbuf, i) & (MODE_BAN | MODE_APASS | MODE_UPASS)) {
tmp = strlen(MB_STRING(mbuf, i));
/* terminate the mode strings */
addbuf[addbuf_i] = '\0';
rembuf[rembuf_i] = '\0';
+ addbuf_local[addbuf_local_i] = '\0';
+ rembuf_local[rembuf_local_i] = '\0';
/* If we're building a user visible MODE or HACK... */
if (mbuf->mb_dest & (MODEBUF_DEST_CHANNEL | MODEBUF_DEST_HACK2 |
if (mbuf->mb_dest & MODEBUF_DEST_CHANNEL)
sendcmdto_channel_butserv_butone(app_source, CMD_MODE, mbuf->mb_channel, NULL, 0,
- "%H %s%s%s%s%s%s", mbuf->mb_channel,
- rembuf_i ? "-" : "", rembuf,
- addbuf_i ? "+" : "", addbuf, remstr, addstr);
+ "%H %s%s%s%s%s%s%s%s", mbuf->mb_channel,
+ rembuf_i || rembuf_local_i ? "-" : "",
+ rembuf, rembuf_local,
+ addbuf_i || addbuf_local_i ? "+" : "",
+ addbuf, addbuf_local,
+ remstr, addstr);
}
/* Now are we supposed to propagate to other servers? */
* limit is supressed if we're removing it; we have to figure out which
* direction is the direction for it to be removed, though...
*/
- limitdel |= (mbuf->mb_dest & MODEBUF_DEST_HACK2) ? MODE_DEL : MODE_ADD;
+ limitdel |= (mbuf->mb_dest & MODEBUF_DEST_BOUNCE) ? MODE_DEL : MODE_ADD;
for (i = 0; i < mbuf->mb_count; i++) {
if (MB_TYPE(mbuf, i) & MODE_SAVE)
strptr_i = &remstr_i;
}
- /* deal with modes that take clients */
- if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
+ /* if we're changing oplevels and we know the oplevel, pass it on */
+ if ((MB_TYPE(mbuf, i) & MODE_CHANOP)
+ && MB_OPLEVEL(mbuf, i) < MAXOPLEVEL)
+ *strptr_i += ircd_snprintf(0, strptr + *strptr_i, BUFSIZE - *strptr_i,
+ " %s%s:%d",
+ NumNick(MB_CLIENT(mbuf, i)),
+ MB_OPLEVEL(mbuf, i));
+
+ /* deal with other modes that take clients */
+ else if (MB_TYPE(mbuf, i) & (MODE_CHANOP | MODE_VOICE))
build_string(strptr, strptr_i, NumNick(MB_CLIENT(mbuf, i)), ' ');
/* deal with modes that take strings */
addbuf, remstr, addstr);
} else if (mbuf->mb_dest & MODEBUF_DEST_BOUNCE) {
/*
- * If HACK2 was set, we're bouncing; we send the MODE back to the
- * connection we got it from with the senses reversed and a TS of 0;
- * origin is us
+ * If HACK2 was set, we're bouncing; we send the MODE back to
+ * the connection we got it from with the senses reversed and
+ * the proper TS; origin is us
*/
sendcmdto_one(&me, CMD_MODE, mbuf->mb_connect, "%H %s%s%s%s%s%s %Tu",
mbuf->mb_channel, addbuf_i ? "-" : "", addbuf,
mbuf->mb_channel->creationtime);
} else {
/*
- * We're propagating a normal MODE command to the rest of the network;
- * we send the actual channel TS unless this is a HACK3 or a HACK4
+ * We're propagating a normal (or HACK3 or HACK4) MODE command
+ * to the rest of the network. We send the actual channel TS.
*/
- if (IsServer(mbuf->mb_source))
- sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
- "%H %s%s%s%s%s%s %Tu", mbuf->mb_channel,
- rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
- addbuf, remstr, addstr,
- (mbuf->mb_dest & MODEBUF_DEST_HACK4) ? 0 :
- mbuf->mb_channel->creationtime);
- else
- sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
- "%H %s%s%s%s%s%s", mbuf->mb_channel,
- rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
- addbuf, remstr, addstr);
+ sendcmdto_serv_butone(mbuf->mb_source, CMD_MODE, mbuf->mb_connect,
+ "%H %s%s%s%s%s%s %Tu", mbuf->mb_channel,
+ rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "",
+ addbuf, remstr, addstr,
+ mbuf->mb_channel->creationtime);
}
}
mode &= (MODE_ADD | MODE_DEL | MODE_PRIVATE | MODE_SECRET | MODE_MODERATED |
MODE_TOPICLIMIT | MODE_INVITEONLY | MODE_NOPRIVMSGS | MODE_REGONLY |
- MODE_DELJOINS | MODE_WASDELJOINS);
+ MODE_DELJOINS | MODE_WASDELJOINS | MODE_REGISTERED);
if (!(mode & ~(MODE_ADD | MODE_DEL))) /* don't add empty modes... */
return;
* @param mbuf The modebuf to append the mode to.
* @param mode The mode to append.
* @param client The client argument to append.
+ * @param oplevel The oplevel the user had or will have
*/
void
modebuf_mode_client(struct ModeBuf *mbuf, unsigned int mode,
- struct Client *client)
+ struct Client *client, int oplevel)
{
assert(0 != mbuf);
assert(0 != (mode & (MODE_ADD | MODE_DEL)));
MB_TYPE(mbuf, mbuf->mb_count) = mode;
MB_CLIENT(mbuf, mbuf->mb_count) = client;
+ MB_OPLEVEL(mbuf, mbuf->mb_count) = oplevel;
/* when we've reached the maximal count, flush the buffer */
if (++mbuf->mb_count >=
modebuf_flush_int(mbuf, 0);
}
+/** Check a channel for join-delayed members.
+ * @param[in] chan Channel to search.
+ * @return Non-zero if any members are join-delayed; false if none are.
+ */
+static int
+find_delayed_joins(const struct Channel *chan)
+{
+ const struct Membership *memb;
+ for (memb = chan->members; memb; memb = memb->next_member)
+ if (IsDelayedJoin(memb))
+ return 1;
+ return 0;
+}
+
/** The exported binding for modebuf_flush()
*
* @param mbuf The mode buffer to flush.
int
modebuf_flush(struct ModeBuf *mbuf)
{
- struct Membership *memb;
-
- /* Check if MODE_WASDELJOINS should be set */
- if (!(mbuf->mb_channel->mode.mode & (MODE_DELJOINS | MODE_WASDELJOINS))
- && (mbuf->mb_rem & MODE_DELJOINS)) {
- for (memb = mbuf->mb_channel->members; memb; memb = memb->next_member) {
- if (IsDelayedJoin(memb)) {
- mbuf->mb_channel->mode.mode |= MODE_WASDELJOINS;
- mbuf->mb_add |= MODE_WASDELJOINS;
- mbuf->mb_rem &= ~MODE_WASDELJOINS;
- break;
- }
- }
+ /* Check if MODE_WASDELJOINS should be set: */
+ /* Must be set if going -D and some clients are hidden */
+ if ((mbuf->mb_rem & MODE_DELJOINS)
+ && !(mbuf->mb_channel->mode.mode & (MODE_DELJOINS | MODE_WASDELJOINS))
+ && find_delayed_joins(mbuf->mb_channel)) {
+ mbuf->mb_channel->mode.mode |= MODE_WASDELJOINS;
+ mbuf->mb_add |= MODE_WASDELJOINS;
+ mbuf->mb_rem &= ~MODE_WASDELJOINS;
+ }
+ /* Must be cleared if +D is set */
+ if ((mbuf->mb_add & MODE_DELJOINS)
+ && ((mbuf->mb_channel->mode.mode & (MODE_WASDELJOINS | MODE_WASDELJOINS))
+ == (MODE_WASDELJOINS | MODE_WASDELJOINS))) {
+ mbuf->mb_channel->mode.mode &= ~MODE_WASDELJOINS;
+ mbuf->mb_add &= ~MODE_WASDELJOINS;
+ mbuf->mb_rem |= MODE_WASDELJOINS;
}
return modebuf_flush_int(mbuf, 1);
MODE_KEY, 'k',
MODE_APASS, 'A',
MODE_UPASS, 'U',
+ MODE_REGISTERED, 'R',
/* MODE_BAN, 'b', */
MODE_LIMIT, 'l',
MODE_REGONLY, 'r',
return;
}
-/** Simple function to invalidate bans
+/** Simple function to invalidate a channel's ban cache.
*
- * This function sets all bans as being valid.
+ * This function marks all members of the channel as being neither
+ * banned nor banned.
*
* @param chan The channel to operate on.
*/
/* What we've done for mode_parse so far... */
#define DONE_LIMIT 0x01 /**< We've set the limit */
-#define DONE_KEY 0x02 /**< We've set the key */
+#define DONE_KEY_ADD 0x02 /**< We've set the key */
#define DONE_BANLIST 0x04 /**< We've sent the ban list */
#define DONE_NOTOPER 0x08 /**< We've sent a "Not oper" error */
#define DONE_BANCLEAN 0x10 /**< We've cleaned bans... */
-#define DONE_UPASS 0x20 /**< We've set user pass */
-#define DONE_APASS 0x40 /**< We've set admin pass */
+#define DONE_UPASS_ADD 0x20 /**< We've set user pass */
+#define DONE_APASS_ADD 0x40 /**< We've set admin pass */
+#define DONE_KEY_DEL 0x80 /**< We've removed the key */
+#define DONE_UPASS_DEL 0x100 /**< We've removed the user pass */
+#define DONE_APASS_DEL 0x200 /**< We've removed the admin pass */
struct ParseState {
struct ModeBuf *mbuf;
struct Ban banlist[MAXPARA];
struct {
unsigned int flag;
+ unsigned short oplevel;
struct Client *client;
} cli_change[MAXPARA];
};
}
}
+/** Helper function to validate key-like parameters.
+ *
+ * @param[in] state Parse state for feedback to user.
+ * @param[in] s Key to validate.
+ * @param[in] command String to pass for need_more_params() command.
+ * @return Zero on an invalid key, non-zero if the key was okay.
+ */
+static int
+is_clean_key(struct ParseState *state, char *s, char *command)
+{
+ int ii;
+
+ if (s[0] == '\0') {
+ if (MyUser(state->sptr))
+ need_more_params(state->sptr, command);
+ return 0;
+ }
+ else if (s[0] == ':') {
+ if (MyUser(state->sptr))
+ send_reply(state->sptr, ERR_INVALIDKEY, state->chptr->chname);
+ return 0;
+ }
+ for (ii = 0; (ii <= KEYLEN) && (s[ii] != '\0'); ++ii) {
+ if ((unsigned char)s[ii] <= ' ' || s[ii] == ',') {
+ if (MyUser(state->sptr))
+ send_reply(state->sptr, ERR_INVALIDKEY, state->chptr->chname);
+ return 0;
+ }
+ }
+ if (ii > KEYLEN) {
+ if (MyUser(state->sptr))
+ send_reply(state->sptr, ERR_INVALIDKEY, state->chptr->chname);
+ return 0;
+ }
+ return 1;
+}
+
/*
* Helper function to convert keys
*/
static void
mode_parse_key(struct ParseState *state, int *flag_p)
{
- char *t_str, *s;
- int t_len;
+ char *t_str;
if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
return;
return;
}
- if (state->done & DONE_KEY) /* allow key to be set only once */
- return;
- state->done |= DONE_KEY;
-
- t_len = KEYLEN;
-
- /* clean up the key string */
- s = t_str;
- while (*s > ' ' && *s != ':' && *s != ',' && t_len--)
- s++;
- *s = '\0';
+ /* allow removing and then adding key, but not adding and then removing */
+ if (state->dir == MODE_ADD)
+ {
+ if (state->done & DONE_KEY_ADD)
+ return;
+ state->done |= DONE_KEY_ADD;
+ }
+ else
+ {
+ if (state->done & (DONE_KEY_ADD | DONE_KEY_DEL))
+ return;
+ state->done |= DONE_KEY_DEL;
+ }
- if (!*t_str) { /* warn if empty */
- if (MyUser(state->sptr))
- need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +k" :
- "MODE -k");
+ /* If the key is invalid, tell the user and bail. */
+ if (!is_clean_key(state, t_str, state->dir == MODE_ADD ? "MODE +k" :
+ "MODE -k"))
return;
- }
if (!state->mbuf)
return;
modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
if (state->flags & MODE_PARSE_SET) {
- if (state->dir == MODE_ADD) /* set the new key */
- ircd_strncpy(state->chptr->mode.key, t_str, KEYLEN);
- else /* remove the old key */
+ if (state->dir == MODE_DEL) /* remove the old key */
*state->chptr->mode.key = '\0';
+ else
+ ircd_strncpy(state->chptr->mode.key, t_str, KEYLEN);
}
}
static void
mode_parse_upass(struct ParseState *state, int *flag_p)
{
- char *t_str, *s;
- int t_len;
+ char *t_str;
if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
return;
if (*state->chptr->mode.apass) {
send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
state->chptr->chname);
- } else if (TStime() - state->chptr->creationtime >= 171000) {
- send_reply(state->sptr, ERR_NOMANAGER_LONG, state->chptr->chname);
} else {
- send_reply(state->sptr, ERR_NOMANAGER_SHORT, state->chptr->chname);
+ send_reply(state->sptr, ERR_NOMANAGER, state->chptr->chname,
+ (TStime() - state->chptr->creationtime < 172800) ?
+ "approximately 4-5 minutes" : "approximately 48 hours");
}
return;
}
- if (state->done & DONE_UPASS) /* allow upass to be set only once */
- return;
- state->done |= DONE_UPASS;
-
- t_len = PASSLEN + 1;
-
- /* clean up the upass string */
- s = t_str;
- while (*++s > ' ' && *s != ':' && --t_len)
- ;
- *s = '\0';
+ /* allow removing and then adding upass, but not adding and then removing */
+ if (state->dir == MODE_ADD)
+ {
+ if (state->done & DONE_UPASS_ADD)
+ return;
+ state->done |= DONE_UPASS_ADD;
+ }
+ else
+ {
+ if (state->done & (DONE_UPASS_ADD | DONE_UPASS_DEL))
+ return;
+ state->done |= DONE_UPASS_DEL;
+ }
- if (!*t_str) { /* warn if empty */
- if (MyUser(state->sptr))
- need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +U" :
- "MODE -U");
+ /* If the Upass is invalid, tell the user and bail. */
+ if (!is_clean_key(state, t_str, state->dir == MODE_ADD ? "MODE +U" :
+ "MODE -U"))
return;
- }
if (!state->mbuf)
return;
!ircd_strcmp(state->chptr->mode.upass, t_str))
return; /* no upass change */
+ /* Skip if this is a burst, we have a Upass already and the new Upass is
+ * after the old one alphabetically */
+ if ((state->flags & MODE_PARSE_BURST) &&
+ *(state->chptr->mode.upass) &&
+ ircd_strcmp(state->chptr->mode.upass, t_str) <= 0)
+ return;
+
if (state->flags & MODE_PARSE_BOUNCE) {
if (*state->chptr->mode.upass) /* reset old upass */
modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
modebuf_mode_string(state->mbuf, state->dir | flag_p[0], t_str, 0);
if (state->flags & MODE_PARSE_SET) {
- if (state->dir == MODE_ADD) /* set the new upass */
- ircd_strncpy(state->chptr->mode.upass, t_str, PASSLEN);
- else /* remove the old upass */
+ if (state->dir == MODE_DEL) /* remove the old upass */
*state->chptr->mode.upass = '\0';
+ else
+ ircd_strncpy(state->chptr->mode.upass, t_str, KEYLEN);
}
}
static void
mode_parse_apass(struct ParseState *state, int *flag_p)
{
- char *t_str, *s;
- int t_len;
+ struct Membership *memb;
+ char *t_str;
if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
return;
return;
}
- /* If a non-service user is trying to force it, refuse. */
- if (state->flags & MODE_PARSE_FORCE && MyUser(state->sptr)
- && !HasPriv(state->sptr, PRIV_APASS_OPMODE)) {
- send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
- state->chptr->chname);
- return;
- }
-
- /* Don't allow to change the Apass if the channel is older than 48 hours. */
- if (TStime() - state->chptr->creationtime >= 172800 && !IsAnOper(state->sptr)) {
- send_reply(state->sptr, ERR_CHANSECURED, state->chptr->chname);
- return;
- }
-
- /* If they are not the channel manager, they are not allowed to change it */
- if (MyUser(state->sptr) && !(state->flags & MODE_PARSE_FORCE || IsChannelManager(state->member))) {
- if (*state->chptr->mode.apass) {
- send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
- state->chptr->chname);
- } else if (TStime() - state->chptr->creationtime >= 171000) {
- send_reply(state->sptr, ERR_NOMANAGER_LONG, state->chptr->chname);
+ if (MyUser(state->sptr)) {
+ if (state->flags & MODE_PARSE_FORCE) {
+ /* If an unprivileged oper is trying to force it, refuse. */
+ if (!HasPriv(state->sptr, PRIV_APASS_OPMODE)) {
+ send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
+ state->chptr->chname);
+ return;
+ }
} else {
- send_reply(state->sptr, ERR_NOMANAGER_SHORT, state->chptr->chname);
+ /* If they are not the channel manager, they are not allowed to change it. */
+ if (!IsChannelManager(state->member)) {
+ if (*state->chptr->mode.apass) {
+ send_reply(state->sptr, ERR_NOTMANAGER, state->chptr->chname,
+ state->chptr->chname);
+ } else {
+ send_reply(state->sptr, ERR_NOMANAGER, state->chptr->chname,
+ (TStime() - state->chptr->creationtime < 172800) ?
+ "approximately 4-5 minutes" : "approximately 48 hours");
+ }
+ return;
+ }
+ /* Can't remove the Apass while Upass is still set. */
+ if (state->dir == MODE_DEL && *state->chptr->mode.upass) {
+ send_reply(state->sptr, ERR_UPASSSET, state->chptr->chname, state->chptr->chname);
+ return;
+ }
+ /* Can't add an Apass if one is set, nor can one remove the wrong Apass. */
+ if ((state->dir == MODE_ADD && *state->chptr->mode.apass) ||
+ (state->dir == MODE_DEL && ircd_strcmp(state->chptr->mode.apass, t_str))) {
+ send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
+ return;
+ }
}
- return;
- }
-
- if (state->done & DONE_APASS) /* allow apass to be set only once */
- return;
- state->done |= DONE_APASS;
- t_len = PASSLEN + 1;
+ /* Forbid removing the Apass if the channel is older than 48 hours
+ * unless an oper is doing it. */
+ if (TStime() - state->chptr->creationtime >= 172800
+ && state->dir == MODE_DEL
+ && !IsAnOper(state->sptr)) {
+ send_reply(state->sptr, ERR_CHANSECURED, state->chptr->chname);
+ return;
+ }
+ }
- /* clean up the apass string */
- s = t_str;
- while (*++s > ' ' && *s != ':' && --t_len)
- ;
- *s = '\0';
+ /* allow removing and then adding apass, but not adding and then removing */
+ if (state->dir == MODE_ADD)
+ {
+ if (state->done & DONE_APASS_ADD)
+ return;
+ state->done |= DONE_APASS_ADD;
+ }
+ else
+ {
+ if (state->done & (DONE_APASS_ADD | DONE_APASS_DEL))
+ return;
+ state->done |= DONE_APASS_DEL;
+ }
- if (!*t_str) { /* warn if empty */
- if (MyUser(state->sptr))
- need_more_params(state->sptr, state->dir == MODE_ADD ? "MODE +A" :
- "MODE -A");
+ /* If the Apass is invalid, tell the user and bail. */
+ if (!is_clean_key(state, t_str, state->dir == MODE_ADD ? "MODE +A" :
+ "MODE -A"))
return;
- }
if (!state->mbuf)
return;
- if (!(state->flags & MODE_PARSE_FORCE)) {
- /* can't remove the apass while upass is still set */
- if (state->dir == MODE_DEL && *state->chptr->mode.upass) {
- send_reply(state->sptr, ERR_UPASSSET, state->chptr->chname, state->chptr->chname);
- return;
- }
- /* can't add an apass if one is set, nor can one remove the wrong apass */
- if ((state->dir == MODE_ADD && *state->chptr->mode.apass) ||
- (state->dir == MODE_DEL && ircd_strcmp(state->chptr->mode.apass, t_str))) {
- send_reply(state->sptr, ERR_KEYSET, state->chptr->chname);
- return;
- }
- }
-
if (!(state->flags & MODE_PARSE_WIPEOUT) && state->dir == MODE_ADD &&
!ircd_strcmp(state->chptr->mode.apass, t_str))
return; /* no apass change */
+ /* Skip if this is a burst, we have an Apass already and the new Apass is
+ * after the old one alphabetically */
+ if ((state->flags & MODE_PARSE_BURST) &&
+ *(state->chptr->mode.apass) &&
+ ircd_strcmp(state->chptr->mode.apass, t_str) <= 0)
+ return;
+
if (state->flags & MODE_PARSE_BOUNCE) {
if (*state->chptr->mode.apass) /* reset old apass */
modebuf_mode_string(state->mbuf, MODE_DEL | flag_p[0],
if (state->flags & MODE_PARSE_SET) {
if (state->dir == MODE_ADD) { /* set the new apass */
+ /* Only accept the new apass if there is no current apass or
+ * this is a BURST. */
+ if (state->chptr->mode.apass[0] == '\0' ||
+ (state->flags & MODE_PARSE_BURST))
+ ircd_strncpy(state->chptr->mode.apass, t_str, KEYLEN);
/* Make it VERY clear to the user that this is a one-time password */
- ircd_strncpy(state->chptr->mode.apass, t_str, PASSLEN);
if (MyUser(state->sptr)) {
send_reply(state->sptr, RPL_APASSWARN_SET, state->chptr->mode.apass);
send_reply(state->sptr, RPL_APASSWARN_SECRET, state->chptr->chname,
state->chptr->mode.apass);
}
+ /* Give the channel manager level 0 ops.
+ There should not be tested for IsChannelManager here because
+ on the local server it is impossible to set the apass if one
+ isn't a channel manager and remote servers might need to sync
+ the oplevel here: when someone creates a channel (and becomes
+ channel manager) during a net.break, and only sets the Apass
+ after the net rejoined, they will have oplevel MAXOPLEVEL on
+ all remote servers. */
+ if (state->member)
+ SetOpLevel(state->member, 0);
} else { /* remove the old apass */
*state->chptr->mode.apass = '\0';
+ /* Clear Upass so that there is never a Upass set when a zannel is burst. */
+ *state->chptr->mode.upass = '\0';
if (MyUser(state->sptr))
send_reply(state->sptr, RPL_APASSWARN_CLEAR);
+ /* Revert everyone to MAXOPLEVEL. */
+ for (memb = state->chptr->members; memb; memb = memb->next_member) {
+ if (memb->status & MODE_CHANOP)
+ SetOpLevel(memb, MAXOPLEVEL);
+ }
}
}
}
old_ban->banstr[old_ban->nu_len] = new_ban->banstr[new_ban->nu_len] = '@';
if (res)
return res;
- /* Compare the addresses. */
- return !ipmask_check(&new_ban->address, &old_ban->address, old_ban->addrbits);
+ /* If the old ban's mask mismatches, cannot be a superset. */
+ if (!ipmask_check(&new_ban->address, &old_ban->address, old_ban->addrbits))
+ return 1;
+ /* Otherwise it depends on whether the old ban's text is a superset
+ * of the new. */
+ return mmatch(old_ban->banstr, new_ban->banstr);
}
/** Add a ban from a ban list and mark bans that should be removed
assert(newban->flags & (BAN_ADD|BAN_DEL));
if (newban->flags & BAN_ADD) {
size_t totlen = 0;
- /* If a less specific entry is found, fail. */
+ /* If a less specific *active* entry is found, fail. */
for (ban = *banlist; ban; ban = ban->next) {
- if (!bmatch(ban, newban)) {
+ if (!bmatch(ban, newban) && !(ban->flags & BAN_DEL)) {
if (do_free)
free_ban(newban);
return 1;
newban->flags = ((state->dir == MODE_ADD) ? BAN_ADD : BAN_DEL)
| (*flag_p == MODE_BAN ? 0 : BAN_EXCEPTION);
set_ban_mask(newban, collapse(pretty_mask(t_str)));
- ircd_strncpy(newban->who, cli_name(state->sptr), HOSTLEN);
+ ircd_strncpy(newban->who, IsUser(state->sptr) ? cli_name(state->sptr) : "*", NICKLEN);
newban->when = TStime();
apply_ban(&state->chptr->banlist, newban, 0);
}
len -= banlen;
} else {
if (state->flags & MODE_PARSE_SET && MyUser(state->sptr) &&
+ !(state->mbuf->mb_dest & MODEBUF_DEST_OPMODE) &&
(len > (feature_int(FEAT_AVBANLEN) * feature_int(FEAT_MAXBANS)) ||
count > feature_int(FEAT_MAXBANS))) {
send_reply(state->sptr, ERR_BANLISTFULL, state->chptr->chname,
mode_parse_client(struct ParseState *state, int *flag_p)
{
char *t_str;
+ char *colon;
struct Client *acptr;
+ struct Membership *member;
+ int oplevel = MAXOPLEVEL + 1;
+ int req_oplevel;
int i;
if (MyUser(state->sptr) && state->max_args <= 0) /* drop if too many args */
return;
}
- if (MyUser(state->sptr)) /* find client we're manipulating */
+ if (MyUser(state->sptr)) {
+ colon = strchr(t_str, ':');
+ if (colon != NULL) {
+ *colon++ = '\0';
+ req_oplevel = atoi(colon);
+ if (*flag_p == CHFL_VOICE || state->dir == MODE_DEL) {
+ /* Ignore the colon and its argument. */
+ } else if (!(state->flags & MODE_PARSE_FORCE)
+ && state->member
+ && (req_oplevel < OpLevel(state->member)
+ || (req_oplevel == OpLevel(state->member)
+ && OpLevel(state->member) < MAXOPLEVEL)
+ || req_oplevel > MAXOPLEVEL)) {
+ send_reply(state->sptr, ERR_NOTLOWEROPLEVEL,
+ t_str, state->chptr->chname,
+ OpLevel(state->member), req_oplevel, "op",
+ OpLevel(state->member) == req_oplevel ? "the same" : "a higher");
+ } else if (req_oplevel <= MAXOPLEVEL)
+ oplevel = req_oplevel;
+ }
+ /* find client we're manipulating */
acptr = find_chasing(state->sptr, t_str, NULL);
- else
+ } else {
+ if (t_str[5] == ':') {
+ t_str[5] = '\0';
+ oplevel = atoi(t_str + 6);
+ }
acptr = findNUser(t_str);
+ }
if (!acptr)
return; /* find_chasing() already reported an error to the user */
state->cli_change[i].flag & flag_p[0]))
break; /* found a slot */
+ /* If we are going to bounce this deop, mark the correct oplevel. */
+ if (state->flags & MODE_PARSE_BOUNCE
+ && state->dir == MODE_DEL
+ && flag_p[0] == MODE_CHANOP
+ && (member = find_member_link(state->chptr, acptr)))
+ oplevel = OpLevel(member);
+
/* Store what we're doing to them */
state->cli_change[i].flag = state->dir | flag_p[0];
+ state->cli_change[i].oplevel = oplevel;
state->cli_change[i].client = acptr;
}
continue;
}
- /* don't allow to deop members with an op level that is <= our own level */
- if (state->sptr != state->cli_change[i].client /* but allow to deop oneself */
- && state->chptr->mode.apass[0]
+ /* Forbid deopping other members with an oplevel less than
+ * one's own level, and other members with an oplevel the same
+ * as one's own unless both are at MAXOPLEVEL. */
+ if (state->sptr != state->cli_change[i].client
&& state->member
- && OpLevel(member) <= OpLevel(state->member)) {
+ && ((OpLevel(member) < OpLevel(state->member))
+ || (OpLevel(member) == OpLevel(state->member)
+ && OpLevel(member) < MAXOPLEVEL))) {
int equal = (OpLevel(member) == OpLevel(state->member));
send_reply(state->sptr, ERR_NOTLOWEROPLEVEL,
cli_name(state->cli_change[i].client),
"deop", equal ? "the same" : "a higher");
continue;
}
- }
+ }
}
/* set op-level of member being opped */
if ((state->cli_change[i].flag & (MODE_ADD | MODE_CHANOP)) ==
(MODE_ADD | MODE_CHANOP)) {
- /* If being opped by an outsider, get oplevel 0 for an apass
- * channel, else MAXOPLEVEL.
+ /* If a valid oplevel was specified, use it.
+ * Otherwise, if being opped by an outsider, get MAXOPLEVEL.
* Otherwise, if not an apass channel, or state->member has
* MAXOPLEVEL, get oplevel MAXOPLEVEL.
* Otherwise, get state->member's oplevel+1.
*/
- if (!state->member)
- SetOpLevel(member, state->chptr->mode.apass[0] ? 0 : MAXOPLEVEL);
- else if (!state->chptr->mode.apass[0] || OpLevel(state->member) == MAXOPLEVEL)
+ if (state->cli_change[i].oplevel <= MAXOPLEVEL)
+ SetOpLevel(member, state->cli_change[i].oplevel);
+ else if (!state->member)
SetOpLevel(member, MAXOPLEVEL);
+ else if (OpLevel(state->member) >= MAXOPLEVEL)
+ SetOpLevel(member, OpLevel(state->member));
else
SetOpLevel(member, OpLevel(state->member) + 1);
}
/* actually effect the change */
if (state->flags & MODE_PARSE_SET) {
if (state->cli_change[i].flag & MODE_ADD) {
- if (IsDelayedJoin(member))
+ if (IsDelayedJoin(member) && !IsZombie(member))
RevealDelayedJoin(member);
member->status |= (state->cli_change[i].flag &
(MODE_CHANOP | MODE_VOICE));
/* accumulate the change */
modebuf_mode_client(state->mbuf, state->cli_change[i].flag,
- state->cli_change[i].client);
+ state->cli_change[i].client,
+ state->cli_change[i].oplevel);
} /* for (i = 0; state->cli_change[i].flags; i++) */
}
if (!state->mbuf)
return;
+ /* Local users are not permitted to change registration status */
+ if (flag_p[0] == MODE_REGISTERED && !(state->flags & MODE_PARSE_FORCE) &&
+ MyUser(state->sptr))
+ return;
+
if (state->dir == MODE_ADD) {
state->add |= flag_p[0];
state->del &= ~flag_p[0];
state->add &= ~MODE_SECRET;
state->del |= MODE_SECRET;
}
- if (flag_p[0] & MODE_DELJOINS) {
- state->add &= ~MODE_WASDELJOINS;
- state->del |= MODE_WASDELJOINS;
- }
} else {
state->add &= ~flag_p[0];
state->del |= flag_p[0];
(state->add & (MODE_SECRET | MODE_PRIVATE)));
}
-/*
+/**
* This routine is intended to parse MODE or OPMODE commands and effect the
- * changes (or just build the bounce buffer). We pass the starting offset
- * as a
+ * changes (or just build the bounce buffer).
+ *
+ * \param[out] mbuf Receives parsed representation of mode change.
+ * \param[in] cptr Connection that sent the message to this server.
+ * \param[in] sptr Original source of the message.
+ * \param[in] chptr Channel whose modes are being changed.
+ * \param[in] parc Number of valid strings in \a parv.
+ * \param[in] parv Text arguments representing mode change, with the
+ * zero'th element containing a string like "+m" or "-o".
+ * \param[in] flags Set of bitwise MODE_PARSE_* flags.
+ * \param[in] member If non-null, the channel member attempting to change the modes.
*/
int
mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr,
MODE_KEY, 'k',
MODE_APASS, 'A',
MODE_UPASS, 'U',
+ MODE_REGISTERED, 'R',
MODE_BAN, 'b',
MODE_LIMIT, 'l',
MODE_REGONLY, 'r',
break;
case 'A': /* deal with Admin passes */
- if (feature_bool(FEAT_OPLEVELS))
+ if (IsServer(cptr) || feature_bool(FEAT_OPLEVELS))
mode_parse_apass(&state, flag_p);
break;
case 'U': /* deal with user passes */
- if (feature_bool(FEAT_OPLEVELS))
+ if (IsServer(cptr) || feature_bool(FEAT_OPLEVELS))
mode_parse_upass(&state, flag_p);
break;
state.parc--;
/* is it a TS? */
- if (IsServer(state.sptr) && !state.parc && IsDigit(*modestr)) {
+ if (IsServer(state.cptr) && !state.parc && IsDigit(*modestr)) {
time_t recv_ts;
if (!(state.flags & MODE_PARSE_SET)) /* don't set earlier TS if */
if (recv_ts && recv_ts < state.chptr->creationtime)
state.chptr->creationtime = recv_ts; /* respect earlier TS */
+ else if (recv_ts > state.chptr->creationtime) {
+ struct Client *sserv;
+
+ /* Check whether the originating server has fully processed
+ * the burst to it. */
+ sserv = state.cptr;
+ if (!IsServer(sserv))
+ sserv = cli_user(sserv)->server;
+ if (IsBurstOrBurstAck(sserv)) {
+ /* This is a legal but unusual case; the source server
+ * probably just has not processed the BURST for this
+ * channel. It SHOULD wipe out all its modes soon, so
+ * silently ignore the mode change rather than send a
+ * bounce that could desync modes from our side (that
+ * have already been sent).
+ */
+ state.mbuf->mb_add = 0;
+ state.mbuf->mb_rem = 0;
+ state.mbuf->mb_count = 0;
+ return state.args_used;
+ } else {
+ /* Server is desynced; bounce the mode and deop the source
+ * to fix it. */
+ state.flags &= ~MODE_PARSE_SET;
+ state.flags |= MODE_PARSE_BOUNCE;
+ state.mbuf->mb_dest &= ~(MODEBUF_DEST_CHANNEL | MODEBUF_DEST_HACK4);
+ state.mbuf->mb_dest |= MODEBUF_DEST_BOUNCE | MODEBUF_DEST_HACK2;
+ if (!IsServer(state.cptr))
+ state.mbuf->mb_dest |= MODEBUF_DEST_DEOP;
+ }
+ }
break; /* break out of while loop */
} else if (state.flags & MODE_PARSE_STRICT ||
if (state.chptr->mode.limit && !(state.done & DONE_LIMIT))
modebuf_mode_uint(state.mbuf, MODE_DEL | MODE_LIMIT,
state.chptr->mode.limit);
- if (*state.chptr->mode.key && !(state.done & DONE_KEY))
+ if (*state.chptr->mode.key && !(state.done & DONE_KEY_DEL))
modebuf_mode_string(state.mbuf, MODE_DEL | MODE_KEY,
state.chptr->mode.key, 0);
- if (*state.chptr->mode.upass && !(state.done & DONE_UPASS))
+ if (*state.chptr->mode.upass && !(state.done & DONE_UPASS_DEL))
modebuf_mode_string(state.mbuf, MODE_DEL | MODE_UPASS,
state.chptr->mode.upass, 0);
- if (*state.chptr->mode.apass && !(state.done & DONE_APASS))
+ if (*state.chptr->mode.apass && !(state.done & DONE_APASS_DEL))
modebuf_mode_string(state.mbuf, MODE_DEL | MODE_APASS,
state.chptr->mode.apass, 0);
}
assert(0 != jbuf);
if (!chan) {
- if (jbuf->jb_type == JOINBUF_TYPE_JOIN)
- sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect, "0");
-
+ sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect, "0");
return;
}
else
add_user_to_channel(chan, jbuf->jb_source, flags, oplevel);
- /* send notification to all servers */
+ /* send JOIN notification to all servers (CREATE is sent later). */
if (jbuf->jb_type != JOINBUF_TYPE_CREATE && !is_local)
- {
- if (flags & CHFL_CHANOP)
- sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect,
- "%u:%H %Tu", oplevel, chan, chan->creationtime);
- else
- sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect,
- "%H %Tu", chan, chan->creationtime);
- }
+ sendcmdto_serv_butone(jbuf->jb_source, CMD_JOIN, jbuf->jb_connect,
+ "%H %Tu", chan, chan->creationtime);
if (!((chan->mode.mode & MODE_DELJOINS) && !(flags & CHFL_VOICED_OR_OPPED))) {
/* Send the notification to the channel */
/* send an op, too, if needed */
if (flags & CHFL_CHANOP && (oplevel < MAXOPLEVEL || !MyUser(jbuf->jb_source)))
- sendcmdto_channel_butserv_butone((chan->mode.apass[0] ? &me : jbuf->jb_source),
+ sendcmdto_channel_butserv_butone((chan->mode.apass[0] ? &his : jbuf->jb_source),
CMD_MODE, chan, NULL, 0, "%H +o %C",
chan, jbuf->jb_source);
} else if (MyUser(jbuf->jb_source))
void CheckDelayedJoins(struct Channel *chan)
{
- struct Membership *memb2;
-
- if (chan->mode.mode & MODE_WASDELJOINS) {
- for (memb2=chan->members;memb2;memb2=memb2->next_member)
- if (IsDelayedJoin(memb2))
- break;
-
- if (!memb2) {
- /* clear +d */
- chan->mode.mode &= ~MODE_WASDELJOINS;
- sendcmdto_channel_butserv_butone(&me, CMD_MODE, chan, NULL, 0,
- "%H -d", chan);
- }
+ if ((chan->mode.mode & MODE_WASDELJOINS) && !find_delayed_joins(chan)) {
+ chan->mode.mode &= ~MODE_WASDELJOINS;
+ sendcmdto_channel_butserv_butone(&his, CMD_MODE, chan, NULL, 0,
+ "%H -d", chan);
}
}
+
+/** Send a join for the user if (s)he is a hidden member of the channel.
+ */
+void RevealDelayedJoinIfNeeded(struct Client *sptr, struct Channel *chptr)
+{
+ struct Membership *member = find_member_link(chptr, sptr);
+ if (member && IsDelayedJoin(member))
+ RevealDelayedJoin(member);
+}
projects / ircu2.10.12-pk.git / blobdiff