#include "common.h"
#include "hash.h"
#include "hook.h"
-#include "irc_string.h"
-#include "sprintf_irc.h"
+#include "match.h"
#include "ircd.h"
#include "numeric.h"
#include "s_serv.h" /* captab */
#include "s_conf.h" /* ConfigFileEntry, ConfigChannel */
#include "s_newconf.h"
#include "logger.h"
+#include "chmode.h"
/* bitmasks for error returns, so we send once per call */
#define SM_ERR_NOTS 0x00000001 /* No TS on channel */
#define SM_ERR_RPL_Q 0x00000800
#define SM_ERR_RPL_F 0x00001000
-void set_channel_mode(struct Client *, struct Client *,
- struct Channel *, struct membership *, int, const char **);
-
-int add_id(struct Client *source_p, struct Channel *chptr,
- const char *banid, rb_dlink_list * list, long mode_type);
+#define MAXMODES_SIMPLE 46 /* a-zA-Z except bqeIov */
static struct ChModeChange mode_changes[BUFSIZE];
static int mode_count;
static int mode_limit;
+static int mode_limit_simple;
static int mask_pos;
-int
+char cflagsbuf[256];
+char cflagsmyinfo[256];
+
+int chmode_flags[256];
+
+/* OPTIMIZE ME! -- dwr */
+void
+construct_noparam_modes(void)
+{
+ int i;
+ char *ptr = cflagsbuf;
+ char *ptr2 = cflagsmyinfo;
+ static int prev_chmode_flags[256];
+
+ *ptr = '\0';
+ *ptr2 = '\0';
+
+ for(i = 0; i < 256; i++)
+ {
+ if( !(chmode_table[i].set_func == chm_ban) &&
+ !(chmode_table[i].set_func == chm_forward) &&
+ !(chmode_table[i].set_func == chm_throttle) &&
+ !(chmode_table[i].set_func == chm_key) &&
+ !(chmode_table[i].set_func == chm_limit) &&
+ !(chmode_table[i].set_func == chm_owner) &&
+ !(chmode_table[i].set_func == chm_op) &&
+ !(chmode_table[i].set_func == chm_halfop) &&
+ !(chmode_table[i].set_func == chm_voice))
+ {
+ chmode_flags[i] = chmode_table[i].mode_type;
+ }
+ else
+ {
+ chmode_flags[i] = 0;
+ }
+
+ if (prev_chmode_flags[i] != 0 && prev_chmode_flags[i] != chmode_flags[i])
+ {
+ if (chmode_flags[i] == 0)
+ {
+ chmode_table[i].set_func = chm_orphaned;
+ sendto_realops_snomask(SNO_DEBUG, L_ALL, "Cmode +%c is now orphaned", i);
+ }
+ else
+ {
+ sendto_realops_snomask(SNO_DEBUG, L_ALL, "Orphaned cmode +%c is picked up by module", i);
+ }
+ chmode_flags[i] = prev_chmode_flags[i];
+ }
+ else
+ prev_chmode_flags[i] = chmode_flags[i];
+
+ switch (chmode_flags[i])
+ {
+ case MODE_EXLIMIT:
+ case MODE_DISFORWARD:
+ if(ConfigChannel.use_forward)
+ {
+ *ptr++ = (char) i;
+ }
+
+ break;
+ case MODE_REGONLY:
+ if(rb_dlink_list_length(&service_list))
+ {
+ *ptr++ = (char) i;
+ }
+
+ break;
+ default:
+ if(chmode_flags[i] != 0)
+ {
+ *ptr++ = (char) i;
+ }
+ }
+
+ /* Should we leave orphaned check here? -- dwr */
+ if(!(chmode_table[i].set_func == chm_nosuch) && !(chmode_table[i].set_func == chm_orphaned))
+ {
+ *ptr2++ = (char) i;
+ }
+ }
+
+ *ptr++ = '\0';
+ *ptr2++ = '\0';
+}
+
+/*
+ * find_umode_slot
+ *
+ * inputs - NONE
+ * outputs - an available cflag bitmask or
+ * 0 if no cflags are available
+ * side effects - NONE
+ */
+unsigned int
+find_cflag_slot(void)
+{
+ unsigned int all_cflags = 0, my_cflag = 0, i;
+
+ for (i = 0; i < 256; i++)
+ all_cflags |= chmode_flags[i];
+
+ for (my_cflag = 1; my_cflag && (all_cflags & my_cflag);
+ my_cflag <<= 1);
+
+ return my_cflag;
+}
+
+static int
get_channel_access(struct Client *source_p, struct membership *msptr)
{
- if(!MyClient(source_p) || is_chanop(msptr))
+ if(!MyClient(source_p) || is_owner(msptr))
+ return CHFL_OWNER;
+ else if(is_chanop(msptr))
return CHFL_CHANOP;
+ else if(is_halfop(msptr))
+ return CHFL_HALFOP;
return CHFL_PEON;
}
if(IsPerson(source_p))
rb_sprintf(who, "%s!%s@%s", source_p->name, source_p->username, source_p->host);
else
- strlcpy(who, source_p->name, sizeof(who));
+ rb_strlcpy(who, source_p->name, sizeof(who));
actualBan = allocate_ban(realban, who);
actualBan->when = rb_current_time();
if(*t != '\0')
user = t;
}
- else if(strchr(mask, '.') != NULL || strchr(mask, ':') != NULL)
+ else if(strchr(mask, '.') != NULL || strchr(mask, ':') != NULL || strchr(mask, '/') != NULL)
{
if(*mask != '\0')
host = mask;
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
{
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
return;
}
- /* +ntspmaikl == 9 + MAXMODEPARAMS (4 * +o) */
- if(MyClient(source_p) && (++mode_limit > (9 + MAXMODEPARAMS)))
+ if(MyClient(source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
/* setting + */
}
}
+void
+chm_orphaned(struct Client *source_p, struct Channel *chptr,
+ int alevel, int parc, int *parn,
+ const char **parv, int *errors, int dir, char c, long mode_type)
+{
+ if(MyClient(source_p))
+ return;
+
+ if((dir == MODE_ADD) && !(chptr->mode.mode & mode_type))
+ {
+ chptr->mode.mode |= mode_type;
+
+ mode_changes[mode_count].letter = c;
+ mode_changes[mode_count].dir = MODE_ADD;
+ mode_changes[mode_count].caps = 0;
+ mode_changes[mode_count].nocaps = 0;
+ mode_changes[mode_count].id = NULL;
+ mode_changes[mode_count].mems = ALL_MEMBERS;
+ mode_changes[mode_count++].arg = NULL;
+ }
+ else if((dir == MODE_DEL) && (chptr->mode.mode & mode_type))
+ {
+ chptr->mode.mode &= ~mode_type;
+
+ mode_changes[mode_count].letter = c;
+ mode_changes[mode_count].dir = MODE_DEL;
+ mode_changes[mode_count].caps = 0;
+ mode_changes[mode_count].nocaps = 0;
+ mode_changes[mode_count].mems = ALL_MEMBERS;
+ mode_changes[mode_count].id = NULL;
+ mode_changes[mode_count++].arg = NULL;
+ }
+}
+
void
chm_staff(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
return;
}
+ if(MyClient(source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
+ return;
+
/* setting + */
if((dir == MODE_ADD) && !(chptr->mode.mode & mode_type))
{
*errors |= errorval;
/* non-ops cant see +eI lists.. */
- if(alevel != CHFL_CHANOP && mode_type != CHFL_BAN &&
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP && mode_type != CHFL_BAN &&
mode_type != CHFL_QUIET)
{
if(!(*errors & SM_ERR_NOOPS))
return;
}
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
}
}
+void
+chm_owner(struct Client *source_p, struct Channel *chptr,
+ int alevel, int parc, int *parn,
+ const char **parv, int *errors, int dir, char c, long mode_type)
+{
+ struct membership *mstptr;
+ const char *ownernick;
+ struct Client *targ_p;
+
+ if(!ConfigChannel.use_owner)
+ {
+ if(*errors & SM_ERR_UNKNOWN)
+ return;
+ *errors |= SM_ERR_UNKNOWN;
+ sendto_one(source_p, form_str(ERR_UNKNOWNMODE), me.name, source_p->name, c);
+ return;
+ }
+
+ if(alevel != CHFL_OWNER)
+ {
+ if(!(*errors & SM_ERR_NOOPS))
+ sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
+ me.name, source_p->name, chptr->chname);
+ *errors |= SM_ERR_NOOPS;
+ return;
+ }
+
+ if((dir == MODE_QUERY) || (parc <= *parn))
+ return;
+
+ ownernick = parv[(*parn)];
+ (*parn)++;
+
+ /* empty nick */
+ if(EmptyString(ownernick))
+ {
+ sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), "*");
+ return;
+ }
+
+ if((targ_p = find_chasing(source_p, ownernick, NULL)) == NULL)
+ {
+ return;
+ }
+
+ mstptr = find_channel_membership(chptr, targ_p);
+
+ if(mstptr == NULL)
+ {
+ if(!(*errors & SM_ERR_NOTONCHANNEL) && MyClient(source_p))
+ sendto_one_numeric(source_p, ERR_USERNOTINCHANNEL,
+ form_str(ERR_USERNOTINCHANNEL), ownernick, chptr->chname);
+ *errors |= SM_ERR_NOTONCHANNEL;
+ return;
+ }
+
+ if(MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
+ return;
+
+ if(dir == MODE_ADD)
+ {
+ if(targ_p == source_p)
+ return;
+
+ mode_changes[mode_count].letter = c;
+ mode_changes[mode_count].dir = MODE_ADD;
+ mode_changes[mode_count].caps = 0;
+ mode_changes[mode_count].nocaps = 0;
+ mode_changes[mode_count].mems = ALL_MEMBERS;
+ mode_changes[mode_count].id = targ_p->id;
+ mode_changes[mode_count].arg = targ_p->name;
+ mode_changes[mode_count++].client = targ_p;
+
+ mstptr->flags |= CHFL_OWNER;
+ }
+ else
+ {
+ if(MyClient(source_p) && IsService(targ_p))
+ {
+ sendto_one(source_p, form_str(ERR_ISCHANSERVICE),
+ me.name, source_p->name, targ_p->name, chptr->chname);
+ return;
+ }
+
+ mode_changes[mode_count].letter = c;
+ mode_changes[mode_count].dir = MODE_DEL;
+ mode_changes[mode_count].caps = 0;
+ mode_changes[mode_count].nocaps = 0;
+ mode_changes[mode_count].mems = ALL_MEMBERS;
+ mode_changes[mode_count].id = targ_p->id;
+ mode_changes[mode_count].arg = targ_p->name;
+ mode_changes[mode_count++].client = targ_p;
+
+ mstptr->flags &= ~CHFL_OWNER;
+ }
+}
+
void
chm_op(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char *opnick;
struct Client *targ_p;
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
}
}
+void
+chm_halfop(struct Client *source_p, struct Channel *chptr,
+ int alevel, int parc, int *parn,
+ const char **parv, int *errors, int dir, char c, long mode_type)
+{
+ struct membership *mstptr;
+ const char *halfopnick;
+ struct Client *targ_p;
+
+ if(!ConfigChannel.use_halfop)
+ {
+ if(*errors & SM_ERR_UNKNOWN)
+ return;
+ *errors |= SM_ERR_UNKNOWN;
+ sendto_one(source_p, form_str(ERR_UNKNOWNMODE), me.name, source_p->name, c);
+ return;
+ }
+
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
+ {
+ if(!(*errors & SM_ERR_NOOPS))
+ sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
+ me.name, source_p->name, chptr->chname);
+ *errors |= SM_ERR_NOOPS;
+ return;
+ }
+
+ if((dir == MODE_QUERY) || (parc <= *parn))
+ return;
+
+ halfopnick = parv[(*parn)];
+ (*parn)++;
+
+ /* empty nick */
+ if(EmptyString(halfopnick))
+ {
+ sendto_one_numeric(source_p, ERR_NOSUCHNICK, form_str(ERR_NOSUCHNICK), "*");
+ return;
+ }
+
+ if((targ_p = find_chasing(source_p, halfopnick, NULL)) == NULL)
+ {
+ return;
+ }
+
+ mstptr = find_channel_membership(chptr, targ_p);
+
+ if(mstptr == NULL)
+ {
+ if(!(*errors & SM_ERR_NOTONCHANNEL) && MyClient(source_p))
+ sendto_one_numeric(source_p, ERR_USERNOTINCHANNEL,
+ form_str(ERR_USERNOTINCHANNEL), halfopnick, chptr->chname);
+ *errors |= SM_ERR_NOTONCHANNEL;
+ return;
+ }
+
+ if(MyClient(source_p) && (++mode_limit > MAXMODEPARAMS))
+ return;
+
+ if(dir == MODE_ADD)
+ {
+ if(targ_p == source_p)
+ return;
+
+ mode_changes[mode_count].letter = c;
+ mode_changes[mode_count].dir = MODE_ADD;
+ mode_changes[mode_count].caps = 0;
+ mode_changes[mode_count].nocaps = 0;
+ mode_changes[mode_count].mems = ALL_MEMBERS;
+ mode_changes[mode_count].id = targ_p->id;
+ mode_changes[mode_count].arg = targ_p->name;
+ mode_changes[mode_count++].client = targ_p;
+
+ mstptr->flags |= CHFL_HALFOP;
+ }
+ else
+ {
+ if(MyClient(source_p) && IsService(targ_p))
+ {
+ sendto_one(source_p, form_str(ERR_ISCHANSERVICE),
+ me.name, source_p->name, targ_p->name, chptr->chname);
+ return;
+ }
+
+ mode_changes[mode_count].letter = c;
+ mode_changes[mode_count].dir = MODE_DEL;
+ mode_changes[mode_count].caps = 0;
+ mode_changes[mode_count].nocaps = 0;
+ mode_changes[mode_count].mems = ALL_MEMBERS;
+ mode_changes[mode_count].id = targ_p->id;
+ mode_changes[mode_count].arg = targ_p->name;
+ mode_changes[mode_count++].client = targ_p;
+
+ mstptr->flags &= ~CHFL_HALFOP;
+ }
+}
+
void
chm_voice(struct Client *source_p, struct Channel *chptr,
int alevel, int parc, int *parn,
const char *opnick;
struct Client *targ_p;
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
static char limitstr[30];
int limit;
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
if(dir == MODE_QUERY)
return;
+ if(MyClient(source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
+ return;
+
if((dir == MODE_ADD) && parc > *parn)
{
lstr = parv[(*parn)];
{
int joins = 0, timeslice = 0;
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
if(dir == MODE_QUERY)
return;
+ if(MyClient(source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
+ return;
+
if((dir == MODE_ADD) && parc > *parn)
{
sscanf(parv[(*parn)], "%d:%d", &joins, ×lice);
}
#ifndef FORWARD_OPERONLY
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
}
#endif
+ if(MyClient(source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
+ return;
+
if(dir == MODE_ADD && parc > *parn)
{
forward = parv[(*parn)];
if(MyClient(source_p) && !(targptr->mode.mode & MODE_FREETARGET))
{
if((msptr = find_channel_membership(targptr, source_p)) == NULL ||
- get_channel_access(source_p, msptr) != CHFL_CHANOP)
+ is_any_op(msptr))
{
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
me.name, source_p->name, targptr->chname);
}
}
- strlcpy(chptr->mode.forward, forward, sizeof(chptr->mode.forward));
+ rb_strlcpy(chptr->mode.forward, forward, sizeof(chptr->mode.forward));
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
{
char *key;
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
if(dir == MODE_QUERY)
return;
+ if(MyClient(source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
+ return;
+
if((dir == MODE_ADD) && parc > *parn)
{
key = LOCAL_COPY(parv[(*parn)]);
return;
s_assert(key[0] != ' ');
- strlcpy(chptr->mode.key, key, sizeof(chptr->mode.key));
+ rb_strlcpy(chptr->mode.key, key, sizeof(chptr->mode.key));
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = MODE_ADD;
int alevel, int parc, int *parn,
const char **parv, int *errors, int dir, char c, long mode_type)
{
- if(alevel != CHFL_CHANOP)
+ if(alevel != CHFL_CHANOP && alevel != CHFL_OWNER && alevel != CHFL_HALFOP)
{
if(!(*errors & SM_ERR_NOOPS))
sendto_one(source_p, form_str(ERR_CHANOPRIVSNEEDED),
if(dir == MODE_QUERY)
return;
- if(((dir == MODE_ADD) && (chptr->mode.mode & MODE_REGONLY)) ||
- ((dir == MODE_DEL) && !(chptr->mode.mode & MODE_REGONLY)))
+ if(((dir == MODE_ADD) && (chptr->mode.mode & mode_type)) ||
+ ((dir == MODE_DEL) && !(chptr->mode.mode & mode_type)))
+ return;
+
+ if(MyClient(source_p) && (++mode_limit_simple > MAXMODES_SIMPLE))
return;
if(dir == MODE_ADD)
- chptr->mode.mode |= MODE_REGONLY;
+ chptr->mode.mode |= mode_type;
else
- chptr->mode.mode &= ~MODE_REGONLY;
+ chptr->mode.mode &= ~mode_type;
mode_changes[mode_count].letter = c;
mode_changes[mode_count].dir = dir;
{chm_nosuch, 0 }, /* @ */
{chm_nosuch, 0 }, /* A */
{chm_nosuch, 0 }, /* B */
- {chm_nosuch, 0 }, /* C */
- {chm_nosuch, 0 }, /* D */
- {chm_nosuch, 0 }, /* E */
+ {chm_simple, MODE_NOCTCP }, /* C */
+ {chm_simple, MODE_NOACTION }, /* D */
+ {chm_simple, MODE_NOKICK }, /* E */
{chm_simple, MODE_FREETARGET }, /* F */
- {chm_nosuch, 0 }, /* G */
+ {chm_simple, MODE_NOCAPS }, /* G */
{chm_nosuch, 0 }, /* H */
{chm_ban, CHFL_INVEX }, /* I */
- {chm_nosuch, 0 }, /* J */
+ {chm_simple, MODE_NOREJOIN }, /* J */
{chm_nosuch, 0 }, /* K */
{chm_staff, MODE_EXLIMIT }, /* L */
{chm_nosuch, 0 }, /* M */
- {chm_nosuch, 0 }, /* N */
+ {chm_simple, MODE_NONICK }, /* N */
{chm_nosuch, 0 }, /* O */
{chm_staff, MODE_PERMANENT }, /* P */
{chm_simple, MODE_DISFORWARD }, /* Q */
{chm_nosuch, 0 }, /* R */
{chm_nosuch, 0 }, /* S */
- {chm_nosuch, 0 }, /* T */
+ {chm_simple, MODE_NONOTICE }, /* T */
{chm_nosuch, 0 }, /* U */
{chm_nosuch, 0 }, /* V */
{chm_nosuch, 0 }, /* W */
{chm_nosuch, 0 },
{chm_nosuch, 0 },
{chm_nosuch, 0 },
- {chm_nosuch, 0 }, /* a */
+ {chm_owner, 0 }, /* a */
{chm_ban, CHFL_BAN }, /* b */
{chm_simple, MODE_NOCOLOR }, /* c */
{chm_nosuch, 0 }, /* d */
{chm_ban, CHFL_EXCEPTION }, /* e */
{chm_forward, 0 }, /* f */
{chm_simple, MODE_FREEINVITE }, /* g */
- {chm_nosuch, 0 }, /* h */
+ {chm_halfop, 0 }, /* h */
{chm_simple, MODE_INVITEONLY }, /* i */
{chm_throttle, 0 }, /* j */
{chm_key, 0 }, /* k */
{chm_op, 0 }, /* o */
{chm_simple, MODE_PRIVATE }, /* p */
{chm_ban, CHFL_QUIET }, /* q */
- {chm_regonly, 0 }, /* r */
+ {chm_regonly, MODE_REGONLY }, /* r */
{chm_simple, MODE_SECRET }, /* s */
{chm_simple, MODE_TOPICLIMIT }, /* t */
{chm_nosuch, 0 }, /* u */
mask_pos = 0;
mode_count = 0;
mode_limit = 0;
+ mode_limit_simple = 0;
alevel = get_channel_access(source_p, msptr);