#define CMD_VERSION "VERSION"
#define CMD_WALLCHOPS "WALLCHOPS"
#define CMD_WALLOPS "WALLOPS"
+#define CMD_WALLHOPS "WALLHOPS"
#define CMD_WALLUSERS "WALLUSERS"
#define CMD_WALLVOICES "WALLVOICES"
+#define CMD_WALLHOPS "WALLHOPS"
#define CMD_WHO "WHO"
#define CMD_WHOIS "WHOIS"
#define CMD_WHOWAS "WHOWAS"
#define TOK_VERSION "V"
#define TOK_WALLCHOPS "WC"
#define TOK_WALLOPS "WA"
+#define TOK_WALLHOPS "WH"
#define TOK_WALLUSERS "WU"
#define TOK_WALLVOICES "WV"
+#define TOK_WALLHOPS "WH"
#define TOK_WHO "H"
#define TOK_WHOIS "W"
#define TOK_WHOWAS "X"
#define P10_VERSION TYPE(VERSION)
#define P10_WALLCHOPS TYPE(WALLCHOPS)
#define P10_WALLOPS TYPE(WALLOPS)
+#define P10_WALLHOPS TYPE(WALLHOPS)
#define P10_WALLUSERS TYPE(WALLUSERS)
#define P10_WALLVOICES TYPE(WALLVOICES)
#define P10_WHO TYPE(WHO)
modes[modelen++] = 'd';
if (IsGlobal(user))
modes[modelen++] = 'g';
- if (IsHelperIrcu(user))
+ // sethost - reed/apples
+ // if (IsHelperIrcu(user))
+ if (IsSetHost(user))
modes[modelen++] = 'h';
+ if (IsFakeHost(user))
+ modes[modelen++] = 'f';
if (IsHiddenHost(user))
modes[modelen++] = 'x';
modes[modelen] = 0;
void
irc_gline(struct server *srv, struct gline *gline)
{
- putsock("%s " P10_GLINE " %s +%s %ld :%s",
- self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, gline->reason);
+ putsock("%s " P10_GLINE " %s +%s %ld :<%s> %s",
+ self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, gline->issuer, gline->reason);
}
void
int pos, base_len, len;
struct modeNode *mn;
struct banNode *bn;
+ struct exemptNode *en;
long last_mode=-1;
unsigned int n;
burst_line[pos++] = ':';
if (last_mode & MODE_CHANOP)
burst_line[pos++] = 'o';
+ if (last_mode & MODE_HALFOP)
+ burst_line[pos++] = 'h';
if (last_mode & MODE_VOICE)
burst_line[pos++] = 'v';
}
burst_line[pos++] = ' ';
}
}
+ if (chan->exemptlist.used) {
+ /* dump the exempt */
+ if (pos+2+strlen(chan->exemptlist.list[0]->exempt) > 505) {
+ burst_line[pos-1] = 0;
+ putsock("%s", burst_line);
+ pos = base_len;
+ } else {
+ burst_line[pos++] = ' ';
+ }
+
+ burst_line[pos++] = ' ';
+ burst_line[pos++] = '~';
+ burst_line[pos++] = ' ';
+ base_len = pos;
+ for (n=0; n<chan->exemptlist.used; n++) {
+ en = chan->exemptlist.list[n];
+ len = strlen(en->exempt);
+ if (pos+len+1 > 510) {
+ burst_line[pos-1] = 0; /* -1 to back up over the space or comma */
+ putsock("%s", burst_line);
+ pos = base_len;
+ }
+ memcpy(burst_line+pos, en->exempt, len);
+ pos += len;
+ burst_line[pos++] = ' ';
+ }
+ }
/* print the last line */
burst_line[pos] = 0;
putsock("%s", burst_line);
}
irc_numeric(from, RPL_WHOISUSER, "%s %s %s * :%s", who->nick, who->ident, who->hostname, who->info);
if (his_servername && his_servercomment)
- irc_numeric(from, RPL_WHOISSERVER, "%s %s :%s", who->nick, his_servername, his_servercomment);
+ irc_numeric(from, RPL_WHOISSERVER, "%s %s :%s", who->nick, his_servername, his_servercomment);
else
- irc_numeric(from, RPL_WHOISSERVER, "%s %s :%s", who->nick, who->uplink->name, who->uplink->description);
-
- if (IsOper(who)) {
+ irc_numeric(from, RPL_WHOISSERVER, "%s %s :%s", who->nick, who->uplink->name, who->uplink->description);
+ if (IsOper(who))
irc_numeric(from, RPL_WHOISOPERATOR, "%s :is a megalomaniacal power hungry tyrant", who->nick);
- }
irc_numeric(from, RPL_ENDOFWHOIS, "%s :End of /WHOIS list", who->nick);
return 1;
}
if (argc < 8)
return 0;
- if (origin) {
+ if (self->uplink) {
/* another server introduced us */
srv = AddServer(GetServerH(origin), argv[1], atoi(argv[2]), atoi(argv[3]), atoi(argv[4]), argv[6], argv[argc-1]);
if (!srv)
return;
}
- AddChannelUser(cd->user, AddChannel(name, cd->when, NULL, NULL));
+ AddChannelUser(cd->user, AddChannel(name, cd->when, NULL, NULL, NULL));
}
static CMD_FUNC(cmd_create)
static CMD_FUNC(cmd_burst)
{
extern int rel_age;
- char modes[MAXLEN], *members = "", *banlist = NULL;
+ char modes[MAXLEN], *members = "";
+ static char exemptlist[MAXLEN], banlist[MAXLEN];
unsigned int next = 3, res = 1;
+ int ctype = 0, echeck = 0, bcheck = 0;
struct chanNode *cNode;
struct userNode *un;
struct modeNode *mNode;
long mode;
char *user, *end, sep;
time_t in_timestamp;
+ char* parm = NULL;
if (argc < 3)
return 0;
modes[0] = 0;
+
+ exemptlist[0] = 0;
+ banlist[0] = 0;
+
while (next < argc) {
switch (argv[next][0]) {
case '+': {
next += n_modes;
break;
}
- case '%': banlist = argv[next++]+1; break;
- default: members = argv[next++]; break;
+ case '%': {
+ for(parm = mysep(&argv[next], " "); /* parm = first param */
+ parm; /* While param is not null */
+ parm = mysep(&argv[next], " ") /* parm = next param */
+ )
+ {
+ switch (parm[0]) {
+ case '%': {
+ ctype = 1;
+ break;
+ }
+ case '~': {
+ ctype = 2;
+ break;
+ }
+ default: {
+ break;
+ }
+ }
+ if (ctype == 1) {
+ if (bcheck == 0) {
+ /* strip % char off start of very first ban */
+ strncat(banlist, strtok(parm, "%"), sizeof(banlist) - 1 - strlen(banlist));
+ strncat(banlist, " ", sizeof(banlist) - 1 - strlen(banlist));
+ bcheck = 1;
+ } else {
+ strncat(banlist, parm, sizeof(banlist) - 1 - strlen(banlist));
+ strncat(banlist, " ", sizeof(banlist) - 1 - strlen(banlist));
+ }
+ } else if (ctype == 2) {
+ if (echeck == 0) {
+ echeck = 1;
+ } else {
+ strncat(exemptlist, parm, sizeof(exemptlist) - 1 - strlen(exemptlist));
+ strncat(exemptlist, " ", sizeof(exemptlist) - 1 - strlen(exemptlist));
+ }
+ }
+ }
+ next++;
+ break;
}
+ default: members = argv[next++]; break;
+ }
}
in_timestamp = atoi(argv[2]);
dict_remove(unbursted_channels, cNode->name);
irc_burst(cNode);
}
- cNode = AddChannel(argv[1], in_timestamp, modes, banlist);
+ cNode = AddChannel(argv[1], in_timestamp, modes, banlist, exemptlist);
/* Burst channel members in now. */
for (user = members, sep = *members, mode = 0; sep; user = end) {
while ((sep = *end++)) {
if (sep == 'o')
mode |= MODE_CHANOP;
+ else if (sep == 'h')
+ mode |= MODE_HALFOP;
else if (sep == 'v')
mode |= MODE_VOICE;
- else
+ else if (isdigit(sep)) {
+ mode |= MODE_CHANOP;
+ while (isdigit(*end)) end++;
+ } else
break;
}
if (rel_age < 0)
{
struct chanNode *cn;
struct userNode *un;
+ char *sethost; // sethost - reed/apples
+ int i; // sethost - reed/apples
if (argc < 3)
return 0;
log_module(MAIN_LOG, LOG_ERROR, "Unable to find user %s whose mode is changing.", argv[1]);
return 0;
}
+ // sethost - reed/apples
+ if (argc == 3)
mod_usermode(un, argv[2]);
+ else {
+ sethost = malloc(strlen(argv[2]) + 1 + strlen(argv[3]) + 1);
+ i = 0;
+ while((sethost[i++] = *argv[2]++));
+ i--;
+ sethost[i++] = ' ';
+ while((sethost[i++] = *argv[3]++));
+ mod_usermode(un, sethost); // sethost - reed/apples
+ }
+
return 1;
}
dict_insert(irc_func_dict, TOK_WALLCHOPS, cmd_dummy);
dict_insert(irc_func_dict, CMD_WALLVOICES, cmd_dummy);
dict_insert(irc_func_dict, TOK_WALLVOICES, cmd_dummy);
+ dict_insert(irc_func_dict, CMD_WALLHOPS, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_WALLHOPS, cmd_dummy);
/* Ignore opers being silly. */
dict_insert(irc_func_dict, CMD_WALLOPS, cmd_dummy);
dict_insert(irc_func_dict, TOK_WALLOPS, cmd_dummy);
+ dict_insert(irc_func_dict, CMD_WALLHOPS, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_WALLHOPS, cmd_dummy);
/* We have reliable clock! Always! Wraaa! */
dict_insert(irc_func_dict, CMD_SETTIME, cmd_dummy);
dict_insert(irc_func_dict, TOK_SETTIME, cmd_dummy);
}
struct userNode *
-AddService(const char *nick, const char *desc, const char *hostname)
+AddService(const char *nick, const char *modes, const char *desc, const char *hostname)
{
char numeric[COMBO_NUMERIC_LEN+1];
int local_num = get_local_numeric();
if (!hostname)
hostname = self->name;
make_numeric(self, local_num, numeric);
- return AddUser(self, nick, nick, hostname, "+oik", numeric, desc, now, "AAAAAA");
+ return AddUser(self, nick, nick, hostname, modes ? modes : "+oik", numeric, desc, now, "AAAAAA");
}
struct userNode *
if (!user || !mode_change)
return;
- while (*word != ' ' && *word) word++;\
- while (*word == ' ') word++; \
+ while (*word != ' ' && *word) word++;
+ while (*word == ' ') word++;
while (1) {
#define do_user_mode(FLAG) do { if (add) user->modes |= FLAG; else user->modes &= ~FLAG; } while (0)
switch (*mode_change++) {
case 'd': do_user_mode(FLAGS_DEAF); break;
case 'k': do_user_mode(FLAGS_SERVICE); break;
case 'g': do_user_mode(FLAGS_GLOBAL); break;
- case 'h': do_user_mode(FLAGS_HELPER); break;
+ // sethost - reed/apples
+ // case 'h': do_user_mode(FLAGS_HELPER); break;
+ // I check if there's an 'h' in the first part, and if there,
+ // then everything after the space becomes their new host.
+ case 'h': do_user_mode(FLAGS_SETHOST);
+ if (*word) {
+ char sethost[MAXLEN];
+ unsigned int ii;
+ for (ii=0; (*word != ' ') && (*word != '\0'); )
+ sethost[ii++] = *word++;
+ sethost[ii] = 0;
+ while (*word == ' ')
+ word++;
+ safestrncpy(user->sethost, sethost, sizeof(user->sethost));
+ }
+ break;
case 'x': do_user_mode(FLAGS_HIDDEN_HOST); break;
case 'r':
if (*word) {
case 'r': do_chan_mode(MODE_REGONLY); break;
case 's': do_chan_mode(MODE_SECRET); break;
case 't': do_chan_mode(MODE_TOPICLIMIT); break;
+ case 'S': do_chan_mode(MODE_STRIPCOLOR); break;
+ case 'M': do_chan_mode(MODE_MODUNREG); break;
+ case 'N': do_chan_mode(MODE_NONOTICE); break;
+ case 'Q': do_chan_mode(MODE_NOQUITMSGS); break;
+ case 'T': do_chan_mode(MODE_NOAMSG); break;
+ case 'O': do_chan_mode(MODE_OPERSONLY); break;
+// uncomment this when ssl is enabled on the network.
+// case 'z': do_chan_mode(MODE_SSLONLY); break;
#undef do_chan_mode
case 'l':
if (add) {
change->args[ch_arg].mode = MODE_BAN;
if (!add)
change->args[ch_arg].mode |= MODE_REMOVE;
- change->args[ch_arg++].hostmask = modes[in_arg++];
+ change->args[ch_arg++].u.hostmask = modes[in_arg++];
break;
- case 'o': case 'v':
+ case 'e':
+ if (!(flags & MCP_ALLOW_OVB))
+ goto error;
+ if (in_arg >= argc)
+ goto error;
+ change->args[ch_arg].mode = MODE_EXEMPT;
+ if (!add)
+ change->args[ch_arg].mode |= MODE_REMOVE;
+ change->args[ch_arg++].u.hostmask = modes[in_arg++];
+ break;
+ case 'o': case 'h': case 'v':
{
struct userNode *victim;
if (!(flags & MCP_ALLOW_OVB))
goto error;
if (in_arg >= argc)
goto error;
- change->args[ch_arg].mode = (modes[0][ii] == 'o') ? MODE_CHANOP : MODE_VOICE;
+
+ if (modes[0][ii] == 'o')
+ change->args[ch_arg].mode = MODE_CHANOP;
+ else if (modes[0][ii] == 'h')
+ change->args[ch_arg].mode = MODE_HALFOP;
+ else if (modes[0][ii] == 'v')
+ change->args[ch_arg].mode = MODE_VOICE;
+
if (!add)
change->args[ch_arg].mode |= MODE_REMOVE;
if (flags & MCP_FROM_SERVER)
victim = GetUserH(modes[in_arg++]);
if (!victim)
continue;
- if ((change->args[ch_arg].member = GetUserMode(channel, victim)))
+ if ((change->args[ch_arg].u.member = GetUserMode(channel, victim)))
ch_arg++;
break;
}
DO_MODE_CHAR(REGONLY, 'r');
DO_MODE_CHAR(NOCOLORS, 'c');
DO_MODE_CHAR(NOCTCPS, 'C');
+ DO_MODE_CHAR(STRIPCOLOR, 'S');
+ DO_MODE_CHAR(MODUNREG, 'M');
+ DO_MODE_CHAR(NONOTICE, 'N');
+ DO_MODE_CHAR(NOQUITMSGS, 'Q');
+ DO_MODE_CHAR(NOAMSG, 'T');
+ DO_MODE_CHAR(OPERSONLY, 'O');
+ // uncomment this for ssl support
+ //DO_MODE_CHAR(SSLONLY, 'z');
#undef DO_MODE_CHAR
if (change->modes_clear & channel->modes & MODE_KEY)
mod_chanmode_append(&chbuf, 'k', channel->key);
chbuf.modes[chbuf.modes_used++] = mode = '-';
switch (change->args[arg].mode & ~MODE_REMOVE) {
case MODE_BAN:
- mod_chanmode_append(&chbuf, 'b', change->args[arg].hostmask);
+ mod_chanmode_append(&chbuf, 'b', change->args[arg].u.hostmask);
+ break;
+ case MODE_EXEMPT:
+ mod_chanmode_append(&chbuf, 'e', change->args[arg].u.hostmask);
break;
default:
if (change->args[arg].mode & MODE_CHANOP)
- mod_chanmode_append(&chbuf, 'o', change->args[arg].member->user->numeric);
+ mod_chanmode_append(&chbuf, 'o', change->args[arg].u.member->user->numeric);
+ if (change->args[arg].mode & MODE_HALFOP)
+ mod_chanmode_append(&chbuf, 'h', change->args[arg].u.member->user->numeric);
if (change->args[arg].mode & MODE_VOICE)
- mod_chanmode_append(&chbuf, 'v', change->args[arg].member->user->numeric);
+ mod_chanmode_append(&chbuf, 'v', change->args[arg].u.member->user->numeric);
break;
}
}
DO_MODE_CHAR(REGONLY, 'r');
DO_MODE_CHAR(NOCOLORS, 'c');
DO_MODE_CHAR(NOCTCPS, 'C');
+ DO_MODE_CHAR(STRIPCOLOR, 'S');
+ DO_MODE_CHAR(MODUNREG, 'M');
+ DO_MODE_CHAR(NONOTICE, 'N');
+ DO_MODE_CHAR(NOQUITMSGS, 'Q');
+ DO_MODE_CHAR(NOAMSG, 'T');
+ DO_MODE_CHAR(OPERSONLY, 'O');
+ // uncomment this for ssl support
+ //DO_MODE_CHAR(SSLONLY, 'z');
#undef DO_MODE_CHAR
if(change->modes_set & MODE_KEY)
mod_chanmode_append(&chbuf, 'k', change->new_key);
chbuf.modes[chbuf.modes_used++] = mode = '+';
switch (change->args[arg].mode) {
case MODE_BAN:
- mod_chanmode_append(&chbuf, 'b', change->args[arg].hostmask);
+ mod_chanmode_append(&chbuf, 'b', change->args[arg].u.hostmask);
+ break;
+ case MODE_EXEMPT:
+ mod_chanmode_append(&chbuf, 'e', change->args[arg].u.hostmask);
break;
default:
if (change->args[arg].mode & MODE_CHANOP)
- mod_chanmode_append(&chbuf, 'o', change->args[arg].member->user->numeric);
+ mod_chanmode_append(&chbuf, 'o', change->args[arg].u.member->user->numeric);
+ if (change->args[arg].mode & MODE_HALFOP)
+ mod_chanmode_append(&chbuf, 'h', change->args[arg].u.member->user->numeric);
if (change->args[arg].mode & MODE_VOICE)
- mod_chanmode_append(&chbuf, 'v', change->args[arg].member->user->numeric);
+ mod_chanmode_append(&chbuf, 'v', change->args[arg].u.member->user->numeric);
break;
}
}
DO_MODE_CHAR(REGONLY, 'r');
DO_MODE_CHAR(NOCOLORS, 'c');
DO_MODE_CHAR(NOCTCPS, 'C');
+ DO_MODE_CHAR(STRIPCOLOR, 'S');
+ DO_MODE_CHAR(MODUNREG, 'M');
+ DO_MODE_CHAR(NONOTICE, 'N');
+ DO_MODE_CHAR(NOQUITMSGS, 'Q');
+ DO_MODE_CHAR(NOAMSG, 'T');
+ DO_MODE_CHAR(OPERSONLY, 'O');
+ // uncomment this for ssl support
+ //DO_MODE_CHAR(SSLONLY, 'z');
#undef DO_MODE_CHAR
}
if (change->modes_set) {
DO_MODE_CHAR(REGONLY, 'r');
DO_MODE_CHAR(NOCOLORS, 'c');
DO_MODE_CHAR(NOCTCPS, 'C');
+ DO_MODE_CHAR(STRIPCOLOR, 'S');
+ DO_MODE_CHAR(MODUNREG, 'M');
+ DO_MODE_CHAR(NONOTICE, 'N');
+ DO_MODE_CHAR(NOQUITMSGS, 'Q');
+ DO_MODE_CHAR(NOAMSG, 'T');
+ DO_MODE_CHAR(OPERSONLY, 'O');
+ // uncomment this for ssl support
+ //DO_MODE_CHAR(SSLONLY, 'z');
#undef DO_MODE_CHAR
switch (change->modes_set & (MODE_KEY|MODE_LIMIT)) {
case MODE_KEY|MODE_LIMIT:
for (remove = 0; *modes; modes++) {
switch (*modes) {
case 'o': remove |= MODE_CHANOP; break;
+ case 'h': remove |= MODE_HALFOP; break;
case 'v': remove |= MODE_VOICE; break;
case 'p': remove |= MODE_PRIVATE; break;
case 's': remove |= MODE_SECRET; break;
channel->limit = 0;
break;
case 'b': remove |= MODE_BAN; break;
+ case 'e': remove |= MODE_EXEMPT; break;
case 'D': remove |= MODE_DELAYJOINS; break;
case 'r': remove |= MODE_REGONLY; break;
case 'c': remove |= MODE_NOCOLORS;
case 'C': remove |= MODE_NOCTCPS; break;
+ case 'S': remove |= MODE_STRIPCOLOR; break;
+ case 'M': remove |= MODE_MODUNREG; break;
+ case 'N': remove |= MODE_NONOTICE; break;
+ case 'Q': remove |= MODE_NOQUITMSGS; break;
+ case 'T': remove |= MODE_NOAMSG; break;
+ case 'O': remove |= MODE_OPERSONLY; break;
}
}
channel->banlist.used = 0;
}
+ /* If removing exempts, kill 'em all. */
+ if ((remove & MODE_EXEMPT) && channel->exemptlist.used) {
+ unsigned int i;
+ for (i=0; i<channel->exemptlist.used; i++)
+ free(channel->exemptlist.list[i]);
+ channel->exemptlist.used = 0;
+ }
+
/* Remove member modes. */
- if ((remove & (MODE_CHANOP | MODE_VOICE)) && channel->members.used) {
- int mask = ~(remove & (MODE_CHANOP | MODE_VOICE));
+ if ((remove & (MODE_CHANOP | MODE_HALFOP | MODE_VOICE)) && channel->members.used) {
+ int mask = ~(remove & (MODE_CHANOP | MODE_HALFOP | MODE_VOICE));
unsigned int i;
for (i = 0; i < channel->members.used; i++)