#define CMD_PROTO "PROTO"
#define CMD_QUIT "QUIT"
#define CMD_REHASH "REHASH"
+#define CMD_REMOVE "REMOVE"
#define CMD_RESET "RESET"
#define CMD_RESTART "RESTART"
#define CMD_RPING "RPING"
#define CMD_RPONG "RPONG"
+#define CMD_SASL "SASL"
#define CMD_SERVER "SERVER"
#define CMD_SERVLIST "SERVLIST"
#define CMD_SERVSET "SERVSET"
#define CMD_SET "SET"
#define CMD_SETTIME "SETTIME"
+#define CMD_SGLINE "SGLINE"
#define CMD_SHUN "SHUN"
#define CMD_SILENCE "SILENCE"
+#define CMD_SMO "SMO"
+#define CMD_SNO "SNO"
+#define CMD_SSHUN "SSHUN"
+#define CMD_SPAMFILTER "SPAMFILTER"
#define CMD_SQUERY "SQUERY"
#define CMD_SQUIT "SQUIT"
#define CMD_STATS "STATS"
#define CMD_SVSJOIN "SVSJOIN"
#define CMD_SVSNICK "SVSNICK"
#define CMD_SVSPART "SVSPART"
+#define CMD_SVSQUIT "SVSQUIT"
#define CMD_SWHOIS "SWHOIS"
+#define CMD_TEMPSHUN "TEMPSHUN"
#define CMD_TIME "TIME"
#define CMD_TOPIC "TOPIC"
#define CMD_TRACE "TRACE"
#define CMD_WHO "WHO"
#define CMD_WHOIS "WHOIS"
#define CMD_WHOWAS "WHOWAS"
+#define CMD_ZLINE "ZLINE"
/* Tokenized commands. */
#define TOK_ACCOUNT "AC"
#define TOK_PROTO "PROTO"
#define TOK_QUIT "Q"
#define TOK_REHASH "REHASH"
+#define TOK_REMOVE "RM"
#define TOK_RESET "RESET"
#define TOK_RESTART "RESTART"
#define TOK_RPING "RI"
#define TOK_RPONG "RO"
+#define TOK_SASL "SASL"
#define TOK_SERVER "S"
#define TOK_SERVLIST "SERVSET"
#define TOK_SERVSET "SERVSET"
#define TOK_SET "SET"
#define TOK_SETTIME "SE"
+#define TOK_SGLINE "SGL"
#define TOK_SHUN "SU"
#define TOK_SILENCE "U"
+#define TOK_SMO "SMO"
+#define TOK_SNO "SNO"
+#define TOK_SSHUN "SSU"
+#define TOK_SPAMFILTER "SF"
#define TOK_SQUERY "SQUERY"
#define TOK_SQUIT "SQ"
#define TOK_STATS "R"
#define TOK_SVSJOIN "SJ"
#define TOK_SVSNICK "SN"
#define TOK_SVSPART "SP"
+#define TOK_SVSQUIT "SX"
#define TOK_SWHOIS "SW"
+#define TOK_TEMPSHUN "TS"
#define TOK_TIME "TI"
#define TOK_TOPIC "T"
#define TOK_TRACE "TR"
#define TOK_WHO "H"
#define TOK_WHOIS "W"
#define TOK_WHOWAS "X"
+#define TOK_ZLINE "ZL"
/* Protocol messages; aliased to full commands or tokens depending
on compile-time configuration. ircu prefers tokens WITH THE
#define P10_PROTO TYPE(PROTO)
#define P10_QUIT TYPE(QUIT)
#define P10_REHASH TYPE(REHASH)
+#define P10_REMOVE TYPE(REMOVE)
#define P10_RESET TYPE(RESET)
#define P10_RESTART TYPE(RESTART)
#define P10_RPING TYPE(RPING)
#define P10_RPONG TYPE(RPONG)
+#define P10_SASL TYPE(SASL)
#define P10_SERVER CMD_SERVER
#define P10_SERVLIST TYPE(SERVLIST)
#define P10_SERVSET TYPE(SERVSET)
#define P10_SET TYPE(SET)
#define P10_SETTIME TYPE(SETTIME)
+#define P10_SGLINE TYPE(SGLINE)
#define P10_SHUN TYPE(SHUN)
#define P10_SILENCE TYPE(SILENCE)
+#define P10_SMO TYPE(SMO)
+#define P10_SNO TYPE(SNO)
+#define P10_SSHUN TYPE(SSHUN)
+#define P10_SPAMFILTER TYPE(SPAMFILTER)
#define P10_SQUERY TYPE(SQUERY)
#define P10_SQUIT TYPE(SQUIT)
#define P10_STATS TYPE(STATS)
#define P10_SVSJOIN TYPE(SVSJOIN)
#define P10_SVSNICK TYPE(SVSNICK)
#define P10_SVSPART TYPE(SVSPART)
+#define P10_SVSQUIT TYPE(SVSQUIT)
#define P10_SWHOIS TYPE(SWHOIS)
+#define P10_TEMPSHUN TYPE(TEMPSHUN)
#define P10_TIME TYPE(TIME)
#define P10_TOPIC TYPE(TOPIC)
#define P10_TRACE TYPE(TRACE)
#define P10_WHO TYPE(WHO)
#define P10_WHOIS TYPE(WHOIS)
#define P10_WHOWAS TYPE(WHOWAS)
+#define P10_ZLINE TYPE(ZLINE)
#define P10_EXEMPT TYPE(EXEMPT)
/* Servers claiming to have a boot or link time before PREHISTORY
static privmsg_func_t *notice_funcs;
static unsigned int num_notice_funcs;
static struct dict *unbursted_channels;
-static char *his_servername;
-static char *his_servercomment;
+static const char *his_servername;
+static const char *his_servercomment;
static int extended_accounts;
+/* These correspond to 1 << X: 01234567890123456789012345 */
+const char irc_user_mode_chars[] = "oOiw dkgh x BnIX azDRWHLq";
+
static struct userNode *AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *numeric, const char *userinfo, time_t timestamp, const char *realip);
extern int off_channel;
inttobase64(extranum, srv->num_mask, (srv->numeric[1] || (srv->num_mask >= 64*64)) ? 3 : 2);
if (srv == self) {
- putsock(P10_SERVER " %s %d %li %li J10 %s%s +s6 :%s",
- srv->name, srv->hops+1, srv->boot, srv->link, srv->numeric, extranum, srv->description);
+ putsock(P10_SERVER " %s %d " FMT_TIME_T " " FMT_TIME_T " J10 %s%s +s6o :%s",
+ srv->name, srv->hops+1, srv->boot, srv->link_time, srv->numeric, extranum, srv->description);
} else {
- putsock("%s " P10_SERVER " %s %d %li %li %c10 %s%s +s6 :%s",
- self->numeric, srv->name, srv->hops+1, srv->boot, srv->link, (srv->self_burst ? 'J' : 'P'), srv->numeric, extranum, srv->description);
+ putsock("%s " P10_SERVER " %s %d " FMT_TIME_T " " FMT_TIME_T " %c10 %s%s +s6o :%s",
+ self->numeric, srv->name, srv->hops+1, srv->boot, srv->link_time, (srv->self_burst ? 'J' : 'P'), srv->numeric, extranum, srv->description);
}
}
-static void
+void
irc_p10_pton(irc_in_addr_t *ip, const char *input)
{
if (strlen(input) == 6) {
do {
if (*input == '_') {
unsigned int left;
- for (left = (25 - strlen(input)) / 3; left; left--)
+ for (left = (25 - strlen(input)) / 3 - pos; left; left--)
ip->in6[pos++] = 0;
input++;
} else {
}
}
-static void
+void
irc_p10_ntop(char *output, const irc_in_addr_t *ip)
{
if (!irc_in_addr_is_valid(*ip)) {
return;
irc_p10_ntop(b64ip, &user->ip);
if (user->modes) {
- int modelen;
char modes[32];
- modelen = 0;
- if (IsOper(user))
- modes[modelen++] = 'o';
- if (IsInvisible(user))
- modes[modelen++] = 'i';
- if (IsWallOp(user))
- modes[modelen++] = 'w';
- if (IsService(user))
- modes[modelen++] = 'k';
- if (IsServNotice(user))
- modes[modelen++] = 's';
- if (IsDeaf(user))
- modes[modelen++] = 'd';
- if (IsGlobal(user))
- modes[modelen++] = 'g';
- if (IsSetHost(user))
- modes[modelen++] = 'h';
- if (IsFakeHost(user))
- modes[modelen++] = 'f';
- if (IsHiddenHost(user))
- modes[modelen++] = 'x';
- if (IsNoChan(user))
- modes[modelen++] = 'n';
- if (IsNoIdle(user))
- modes[modelen++] = 'I';
- modes[modelen] = 0;
-
+ irc_user_modes(user, modes, sizeof(modes));
/* we don't need to put the + in modes because it's in the format string. */
- putsock("%s " P10_NICK " %s %d %li %s %s +%s %s %s :%s",
+ putsock("%s " P10_NICK " %s %d " FMT_TIME_T " %s %s +%s %s %s :%s",
user->uplink->numeric, user->nick, user->uplink->hops+1, user->timestamp, user->ident, user->hostname, modes, b64ip, user->numeric, user->info);
} else {
- putsock("%s " P10_NICK " %s %d %li %s %s %s %s :%s",
+ putsock("%s " P10_NICK " %s %d " FMT_TIME_T " %s %s %s %s :%s",
user->uplink->numeric, user->nick, user->uplink->hops+1, user->timestamp, user->ident, user->hostname, b64ip, user->numeric, user->info);
}
}
irc_account(struct userNode *user, const char *stamp, time_t timestamp)
{
if(extended_accounts)
- putsock("%s " P10_ACCOUNT " %s R %s %lu", self->numeric, user->numeric, stamp, timestamp);
+ putsock("%s " P10_ACCOUNT " %s R %s "FMT_TIME_T, self->numeric, user->numeric, stamp, timestamp);
else
- putsock("%s " P10_ACCOUNT " %s %s %lu", self->numeric, user->numeric, stamp, timestamp);
+ putsock("%s " P10_ACCOUNT " %s %s "FMT_TIME_T, self->numeric, user->numeric, stamp, timestamp);
}
void
{
if (to[0] == '#' || to[0] == '$'
|| !deliver_to_dummy(from, GetUserN(to), message, 0))
- putsock("%s " P10_NOTICE " %s :%s", from->numeric, to, message);
+ putsock("%s " P10_NOTICE " %s :%s", from->numeric, to, message);
}
void
irc_notice_user(struct userNode *from, struct userNode *to, const char *message)
{
if (!deliver_to_dummy(from, to, message, 0))
- putsock("%s " P10_NOTICE " %s :%s", from->numeric, to->numeric, message);
+ putsock("%s " P10_NOTICE " %s :%s", from->numeric, to->numeric, message);
}
void
{
if (to[0] == '#' || to[0] == '$'
|| !deliver_to_dummy(from, GetUserN(to), message, 1))
- putsock("%s " P10_PRIVMSG " %s :%s", from->numeric, to, message);
+ putsock("%s " P10_PRIVMSG " %s :%s", from->numeric, to, message);
}
void
{
char *delim;
struct timeval orig;
- struct timeval now;
+ struct timeval sys_now;
int diff;
orig.tv_sec = strtoul(orig_ts, &delim, 10);
orig.tv_usec = (*delim == '.') ? strtoul(delim + 1, NULL, 10) : 0;
- gettimeofday(&now, NULL);
- diff = (now.tv_sec - orig.tv_sec) * 1000 + (now.tv_usec - orig.tv_usec) / 1000;
- putsock("%s " P10_PONG " %s %s %d " FMT_TIME_T ".%06u", self->numeric, who, orig_ts, diff, now.tv_sec, (unsigned)now.tv_usec);
+ gettimeofday(&sys_now, NULL);
+ diff = (sys_now.tv_sec - orig.tv_sec) * 1000 + (sys_now.tv_usec - orig.tv_usec) / 1000;
+ putsock("%s " P10_PONG " %s %s %d %lu.%06lu", self->numeric, who, orig_ts, diff, (unsigned long)sys_now.tv_sec, (unsigned long)sys_now.tv_usec);
}
void
void
irc_gline(struct server *srv, struct gline *gline, int silent)
{
- if (gline->lastmod)
- putsock("%s " P10_GLINE " %s +%s %ld %ld :%s",
- self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, gline->lastmod, gline->reason);
- else
- putsock("%s " P10_GLINE " %s +%s %ld :%s<%s> %s",
- self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, silent ? "AUTO " : "", gline->issuer, gline->reason);
+ putsock("%s " P10_GLINE " %s +%s " FMT_TIME_T " " FMT_TIME_T " :%s<%s> %s",
+ self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, now, silent ? "AUTO " : "", gline->issuer, gline->reason);
}
void
irc_shun(struct server *srv, struct shun *shun)
{
- if (shun->lastmod)
- putsock("%s " P10_SHUN " %s +%s %ld %ld :%s",
- self->numeric, (srv ? srv->numeric : "*"), shun->target, shun->expires-now, shun->lastmod, shun->reason);
- else
- putsock("%s " P10_SHUN " %s +%s %ld :<%s> %s",
- self->numeric, (srv ? srv->numeric : "*"), shun->target, shun->expires-now, shun->issuer, shun->reason);
+ putsock("%s " P10_SHUN " %s +%s " FMT_TIME_T " " FMT_TIME_T " :<%s> %s",
+ self->numeric, (srv ? srv->numeric : "*"), shun->target, shun->expires-now, now, shun->issuer, shun->reason);
}
void
void
irc_ungline(const char *mask)
{
- putsock("%s " P10_GLINE " * -%s", self->numeric, mask);
+ putsock("%s " P10_GLINE " * -%s " FMT_TIME_T, self->numeric, mask, now);
}
void
irc_unshun(const char *mask)
{
- putsock("%s " P10_SHUN " * -%s", self->numeric, mask);
+ putsock("%s " P10_SHUN " * -%s " FMT_TIME_T, self->numeric, mask, now);
}
-static void
+void
irc_burst(struct chanNode *chan)
{
char burst_line[512];
struct banNode *bn;
struct exemptNode *en;
long last_mode=-1;
+ unsigned int first_ban;
+ unsigned int first_exempt;
unsigned int n;
base_len = sprintf(burst_line, "%s " P10_BURST " %s " FMT_TIME_T " ",
self->numeric, chan->name, chan->timestamp);
len = irc_make_chanmode(chan, burst_line+base_len);
pos = base_len + len;
- if (len)
+ if (len > 0 && chan->members.used > 0)
burst_line[pos++] = ' ';
if(chan->members.used < 1)
if ((n+1)<chan->members.used)
burst_line[pos++] = ',';
}
+
+ if (len > 0 && (chan->banlist.used > 0 || chan->exemptlist.used > 0))
+ burst_line[pos++] = ' ';
+
if (chan->banlist.used) {
/* dump the bans */
- if (pos+2+strlen(chan->banlist.list[0]->ban) > 505) {
- burst_line[pos-1] = 0;
- putsock("%s", burst_line);
- pos = base_len;
- } else {
- burst_line[pos++] = ' ';
- }
+ first_ban = 1;
- burst_line[pos++] = ':';
- burst_line[pos++] = '%';
- base_len = pos;
- for (n=0; n<chan->banlist.used; n++) {
+ for (n=0; n<chan->banlist.used; ) {
+ if (first_ban && (pos < 500)) {
+ burst_line[pos++] = ':';
+ burst_line[pos++] = '%';
+ }
bn = chan->banlist.list[n];
len = strlen(bn->ban);
- if (pos+len+1 > 510) {
- burst_line[pos-1] = 0; /* -1 to back up over the space or comma */
+ if (pos + 2 + len < 505) {
+ memcpy(burst_line + pos, bn->ban, len);
+ pos += len;
+ burst_line[pos++] = ' ';
+ first_ban = 0;
+ n++;
+ } else {
+ burst_line[pos-1] = 0;
putsock("%s", burst_line);
pos = base_len;
+ first_ban = 1;
}
- memcpy(burst_line+pos, bn->ban, len);
- pos += len;
- 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++) {
+ if (chan->exemptlist.used) {
+ /* dump the exempts */
+ first_exempt = 1;
+
+ for (n=0; n<chan->exemptlist.used; ) {
+ if (first_exempt && (pos < 500)) {
+ if (chan->banlist.used < 1) {
+ burst_line[pos++] = ':';
+ burst_line[pos++] = '%';
+ burst_line[pos++] = ' ';
+ }
+ burst_line[pos++] = '~';
+ burst_line[pos++] = ' ';
+ }
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 */
+ if (pos + 2 + len < 505) {
+ memcpy(burst_line + pos, en->exempt, len);
+ pos += len;
+ burst_line[pos++] = ' ';
+ first_exempt = 0;
+ n++;
+ } else {
+ burst_line[pos-1] = 0;
putsock("%s", burst_line);
pos = base_len;
+ first_exempt = 1;
}
- memcpy(burst_line+pos, en->exempt, len);
- pos += len;
- burst_line[pos++] = ' ';
}
}
/* print the last line */
irc_join(struct userNode *who, struct chanNode *what)
{
if (what->members.used == 1) {
- putsock("%s " P10_CREATE " %s %lu",
+ putsock("%s " P10_CREATE " %s "FMT_TIME_T,
who->numeric, what->name, what->timestamp);
} else {
- putsock("%s " P10_JOIN " %s %lu", who->numeric, what->name, what->timestamp);
+ putsock("%s " P10_JOIN " %s "FMT_TIME_T, who->numeric, what->name, what->timestamp);
}
}
putsock("%s " P10_SVSPART " %s %s", from->uplink->numeric, who->numeric, to->name);
}
+void
+irc_svsquit(struct userNode *from, struct userNode *who, char const *reason)
+{
+ putsock("%s " P10_SVSQUIT " %s :%s", from->uplink->numeric, who->numeric, reason);
+}
+
void
irc_kick(struct userNode *who, struct userNode *target, struct chanNode *channel, const char *msg)
{
}
+void
+irc_tempshun(struct userNode *from, struct userNode *target, int remove, const char *reason)
+{
+ putsock("%s " P10_TEMPSHUN " %s %s :%s", from->numeric, (remove ? "-" : "+"), target->numeric, reason);
+}
+
void
irc_part(struct userNode *who, struct chanNode *what, const char *reason)
{
irc_topic(struct userNode *service, struct userNode *who, struct chanNode *what, const char *topic)
{
- int type = 4;
- int host_in_topic = 0;
- const char *hstr, *tstr;
+ int type = 4, host_in_topic = 0, hasident = 0, hhtype = 0;
+ const char *hstr, *tstr, *hhstr, *htstr;
char *host, *hostmask;
char shost[MAXLEN];
char sident[MAXLEN];
tstr = conf_get_data("server/type", RECDB_QSTRING);
hstr = conf_get_data("server/host_in_topic", RECDB_QSTRING);
+ hhstr = conf_get_data("server/hidden_host", RECDB_QSTRING);
+ htstr = conf_get_data("server/hidden_host_type", RECDB_QSTRING);
if(tstr)
type = atoi(tstr);
else
type = 4;/* default to 040 style topics */
+ if (htstr)
+ hhtype = atoi(htstr);
if (hstr) {
- if (IsFakeHost(who))
+ if (IsHiddenHost(who) && IsFakeHost(who))
safestrncpy(shost, who->fakehost, sizeof(shost));
- else if (IsSetHost(who)) {
+ else if (IsHiddenHost(who) && IsSetHost(who)) {
hostmask = strdup(who->sethost);
- if ((host = (strrchr(hostmask, '@'))))
+ if ((host = (strrchr(hostmask, '@')))) {
+ hasident = 1;
*host++ = '\0';
- else
+ } else
host = hostmask;
- safestrncpy(sident, hostmask, sizeof(shost));
+ if (hasident)
+ safestrncpy(sident, hostmask, sizeof(shost));
+ else
+ safestrncpy(sident, who->ident, sizeof(shost));
+
safestrncpy(shost, host, sizeof(shost));
+ } else if (IsHiddenHost(who) && ((hhtype == 1) || (hhtype == 3)) && who->handle_info && hhstr) {
+ snprintf(shost, sizeof(shost), "%s.%s", who->handle_info->handle, hhstr);
+ } else if (IsHiddenHost(who) && ((hhtype == 2) || (hhtype == 3)) && who->crypthost[0]) {
+ safestrncpy(shost, who->crypthost, sizeof(shost));
} else
safestrncpy(shost, who->hostname, sizeof(shost));
irc_mark(struct userNode *user, char *mark)
{
char *host = user->hostname;
+ int type = 4;
+ const char *tstr = NULL;
+ unsigned int ii = 0;
+ int markfound = 0;
+
+ tstr = conf_get_data("server/type", RECDB_QSTRING);
+ if(tstr)
+ type = atoi(tstr);
+ else
+ type = 4;
+
+ if (user->marks)
+ for (ii=0; ii<user->marks->used; ii++)
+ if (!irccasecmp(user->marks->list[ii], mark))
+ markfound = 1;
+
+ if (!markfound)
+ {
+ if (!user->marks)
+ user->marks = alloc_string_list(1);
+ string_list_append(user->marks, strdup(mark));
+ }
+
+ if (type >= 9)
+ {
+ putsock("%s " CMD_MARK " %s MARK %s", self->numeric, user->nick, mark);
+ return;
+ }
/* TODO: Allow mark overwrite. If they are marked, and their fakehost is oldmark.hostname, update it to newmark.hostname so mark can be called multiple times. Probably requires ircd modification also */
if(user->mark)
}
}
+void irc_sno(unsigned int mask, char const* format, ...) {
+ va_list arg_list;
+ char buffer[MAXLEN];
+ va_start(arg_list, format);
+ vsnprintf(buffer, MAXLEN-2, format, arg_list);
+ buffer[MAXLEN-1] = 0;
+ putsock("%s " CMD_SNO " %d :%s", self->numeric, mask, buffer);
+}
+
+void
+irc_sasl(struct server* dest, const char *identifier, const char *subcmd, const char *data)
+{
+ putsock("%s " P10_SASL " %s %s %s %s", self->numeric, dest->numeric, identifier, subcmd, data);
+}
+
static void send_burst(void);
static void
log_module(MAIN_LOG, LOG_ERROR, "Could not find WHOIS origin user %s", origin);
return 0;
}
- if(!(who = GetUserH(argv[2]))) {
+ if (!(who = GetUserH(argv[2]))) {
irc_numeric(from, ERR_NOSUCHNICK, "%s@%s :No such nick", argv[2], self->name);
return 1;
}
else
irc_numeric(from, RPL_WHOISUSER, "%s %s %s * :%s", who->nick, who->ident, who->hostname, who->info);
- if ((!IsService(who) && !IsNoChan(who)) || (from == who)) {
+ if (!IsService(who) || (from == who)) {
struct modeNode *mn;
mlen = strlen(self->name) + strlen(from->nick) + 12 + strlen(who->nick);
len = 0;
*(buf + len++) = '*';
if (mn->modes & MODE_CHANOP)
*(buf + len++) = '@';
+ else if (mn->modes & MODE_HALFOP)
+ *(buf + len++) = '%';
else if (mn->modes & MODE_VOICE)
*(buf + len++) = '+';
if (IsAway(who))
irc_numeric(from, RPL_AWAY, "%s :Away", who->nick);
-
if (IsOper(who))
irc_numeric(from, RPL_WHOISOPERATOR, "%s :%s", who->nick, IsLocal(who) ? "is a megalomaniacal power hungry tyrant" : "is an IRC Operator");
if (who->handle_info)
irc_numeric(from, RPL_WHOISACCOUNT, "%s %s :is logged in as", who->nick, who->handle_info->handle);
if (IsHiddenHost(who) && who->handle_info && (IsOper(from) || from == who))
irc_numeric(from, RPL_WHOISACTUALLY, "%s %s@%s %s :Actual user@host, Actual IP", who->nick, who->ident, who->hostname, irc_ntoa(&who->ip));
- if (IsLocal(who) && !IsService(who) && (!IsNoIdle(who) || IsOper(from) || from == who))
+ if (IsLocal(who) && !IsService(who) && (IsOper(from) || from == who))
irc_numeric(from, RPL_WHOISIDLE, "%s %ld %ld :seconds idle, signon time", who->nick, now - who->idle_since, who->timestamp);
irc_numeric(from, RPL_ENDOFWHOIS, "%s :End of /WHOIS list", who->nick);
* Alternately, we are same age, but we accept their time
* since we are linking to them. */
self->boot = srv->boot;
- ioset_set_time(srv->link);
+ ioset_set_time(srv->link_time
+);
}
}
if (srv == self->uplink) {
{
struct server *sender;
dict_iterator_t it;
- unsigned int ii;
if (!(sender = GetServerH(origin)))
return 0;
}
sender->self_burst = 0;
recalc_bursts(sender);
- for (ii=0; ii<slf_used; ii++)
- slf_list[ii](sender);
+ call_server_link_funcs(sender);
/* let auto-routing figure out if we were
* wating on this server to link a child to it */
/* DONT call this if uplink is _US_ */
struct server *dest;
if (!(dest = GetServerN(argv[1])))
- return 0;
+ return 1; /* if its a jupe or something, return 1 so its silently ignored */
if (dest == self)
irc_rpong(argv[2], argv[3], argv[4], argv[5]);
return 1;
}
+static CMD_FUNC(cmd_sasl)
+{
+ struct server *serv;
+
+ if (argc < 5)
+ return 0;
+
+ serv = GetServerH(origin);
+ if (!serv)
+ return 0;
+
+ call_sasl_input_func(serv, argv[2], argv[3], argv[4], (argc>5 ? argv[argc-1] : NULL));
+
+ return 1;
+}
+
static CMD_FUNC(cmd_ping)
{
struct server *srv;
NickChange(user, argv[1], 1);
} else {
struct server *serv;
- struct userNode *nuser;
char modes[MAXLEN];
/* new nick */
if (argc < 9)
unsplit_string(argv+6, argc-9, modes);
else
strcpy(modes, "+");
- nuser = AddUser(serv, argv[1], argv[4], argv[5], modes, argv[argc-2], argv[argc-1], atoi(argv[3]), argv[argc-3]);
+ AddUser(serv, argv[1], argv[4], argv[5], modes, argv[argc-2], argv[argc-1], atoi(argv[3]), argv[argc-3]);
}
return 1;
}
if(!strcmp(argv[2],"C"))
{
- if((hi = loc_auth(argv[4], argv[5])))
+ if((hi = loc_auth(NULL, argv[4], argv[5], NULL)))
{
/* Return a AC A */
- putsock("%s " P10_ACCOUNT " %s A %s %lu", self->numeric, server->numeric , argv[3], hi->registered);
+ putsock("%s " P10_ACCOUNT " %s A %s "FMT_TIME_T, self->numeric, server->numeric , argv[3], hi->registered);
+ log_module(MAIN_LOG, LOG_DEBUG, "loc_auth: %s\n", user->nick);
+ }
+ else
+ {
+ /* Return a AC D */
+ putsock("%s " P10_ACCOUNT " %s D %s", self->numeric, server->numeric , argv[3]);
+ }
+ return 1;
+ }
+ else if(!strcmp(argv[2],"H")) /* New enhanced (host) version of C */
+ {
+ if((hi = loc_auth(NULL, argv[5], argv[6], argv[4] )))
+ {
+ /* Return a AC A */
+ putsock("%s " P10_ACCOUNT " %s A %s "FMT_TIME_T, self->numeric, server->numeric , argv[3], hi->registered);
+ }
+ else
+ {
+ /* Return a AC D */
+ putsock("%s " P10_ACCOUNT " %s D %s", self->numeric, server->numeric , argv[3]);
+ }
+ return 1;
+ }
+ else if(!strcmp(argv[2],"S"))
+ {
+ if((hi = loc_auth(argv[5], argv[6], argv[7], argv[4])))
+ {
+ /* Return a AC A */
+ putsock("%s " P10_ACCOUNT " %s A %s "FMT_TIME_T, self->numeric, server->numeric , argv[3], hi->registered);
}
else
{
P(BADCHAN), P(LOCAL_BADCHAN), P(SEE_CHAN), P(PROPAGATE),
P(DISPLAY), P(SEE_OPERS), P(WIDE_GLINE), P(FORCE_OPMODE),
P(FORCE_LOCAL_OPMODE), P(REMOTEREHASH), P(CHECK), P(SEE_SECRET_CHAN),
- P(SHUN), P(LOCAL_SHUN), P(WIDE_SHUN),
+ P(SHUN), P(LOCAL_SHUN), P(WIDE_SHUN), P(ZLINE),
+ P(LOCAL_ZLINE), P(WIDE_ZLINE), P(LIST_CHAN), P(WHOIS_NOTICE),
+ P(HIDE_IDLE), P(XTRAOP), P(HIDE_CHANNELS), P(DISPLAY_MODE),
+ P(FREEFORM), P(REMOVE), P(SPAMFILTER), P(ADMIN),
+ P(APASS_OPMODE), P(HIDE_OPER), P(REMOTE), P(SERVICE),
#undef P
{ 0, 0 }
};
return privbuf;
}
+int clear_privs(struct userNode *who) {
+ int i = 0;
+ assert(0 != who);
+
+ for (i = 0; privtab[i].name; i++)
+ RevokePriv(who, privtab[i].priv);
+
+ return 0;
+}
+
int client_modify_priv_by_name(struct userNode *who, char *priv, int what) {
int i = 0;
assert(0 != priv);
putsock("%s " P10_PRIVS " %s %s%s", self->numeric, target->numeric, (add == PRIV_ADD) ? "+" : "-", flag);
}
+void
+irc_raw_privs(struct userNode *target, const char *privs)
+{
+ putsock("%s " P10_PRIVS " %s %s", self->numeric, target->numeric, privs);
+}
+
static CMD_FUNC(cmd_privs)
{
- char *tstr = NULL;
- int type = 0;
+ char *tstr = NULL;
+ char buf[512] = "";
+ char *p = 0;
+ char *tmp;
- tstr = conf_get_data("server/type", RECDB_QSTRING);
- if(tstr)
- type = atoi(tstr);
+ int what = PRIV_ADD;
+ int type = 0;
- if (type < 6)
- return 1; /* silently ignore */
+ unsigned int i;
- struct userNode *user = argc > 1 ? GetUserN(argv[1]) : NULL;
- char buf[512] = "";
- int what = PRIV_ADD;
- char *p = 0;
- char *tmp;
- unsigned int i;
+ struct server *sender;
+ struct userNode *user;
- if (argc < 3)
- return 0;
- if (!user)
- return 0;
+ tstr = conf_get_data("server/type", RECDB_QSTRING);
+ if(tstr)
+ type = atoi(tstr);
- for (i=1; i<argc; i++) {
- strcat(buf, argv[i]);
- strcat(buf, " ");
- }
- for (i = 2; i < argc; i++) {
- if (*argv[i] == '+') { what = PRIV_ADD; argv[i]++; }
- if (*argv[i] == '-') { what = PRIV_DEL; argv[i]++; }
- for (tmp = x3_strtok(&p, argv[i], ","); tmp;
- tmp = x3_strtok(&p, NULL, ",")) {
- client_modify_priv_by_name(user, tmp, what);
+ if (!(sender = GetServerH(origin))) { /* from oper */
+ return 1; /* ignore as no services have privs set */
+ } else { /* from server */
+ if (type < 5)
+ return 1; /* silently ignore */
+
+ user = argc > 1 ? GetUserN(argv[1]) : NULL;
+
+ if (!user)
+ return 0;
+
+ for (i=1; i<argc; i++) {
+ strcat(buf, argv[i]);
+ strcat(buf, " ");
+ }
+
+ for (i = 2; i < argc; i++) {
+ if (*argv[i] == '+') { what = PRIV_ADD; argv[i]++; }
+ if (*argv[i] == '-') { what = PRIV_DEL; argv[i]++; }
+ for (tmp = x3_strtok(&p, argv[i], ","); tmp;
+ tmp = x3_strtok(&p, NULL, ",")) {
+ if (!strcmp(tmp, "PRIV_NONE")) {
+ if (now > user->timestamp+5)
+ clear_privs(user);
+ break;
+ } else
+ client_modify_priv_by_name(user, tmp, what);
+ }
+ }
}
- }
- return 1;
+ return 1;
}
static CMD_FUNC(cmd_burst)
static char exemptlist[MAXLEN], banlist[MAXLEN];
unsigned int next = 3, res = 1;
int ctype = 0, echeck = 0, bcheck = 0;
+ struct chanData *cData;
struct chanNode *cNode;
struct userNode *un;
struct modeNode *mNode;
long mode;
int oplevel = -1;
+ int type = 0;
char *user, *end, sep;
+ char *tstr;
time_t in_timestamp;
char* parm = NULL;
return 0;
modes[0] = 0;
+ tstr = conf_get_data("server/type", RECDB_QSTRING);
+ if(tstr) {
+ type = atoi(tstr);
+ }
+
exemptlist[0] = 0;
banlist[0] = 0;
int n_modes;
for (pos=argv[next], n_modes = 1; *pos; pos++)
if ((*pos == 'k') || (*pos == 'l') || (*pos == 'A')
- || (*pos == 'U'))
+ || (*pos == 'U') || ((type > 7) && (*pos == 'L')))
n_modes++;
if (next + n_modes > argc)
n_modes = argc - next;
break;
}
case '%': {
+ ctype = 1;
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 (0 == strcmp("~", parm))
+ ctype = 2;
if (ctype == 1) {
if (bcheck == 0) {
/* strip % char off start of very first ban */
irc_burst(cNode);
}
cNode = AddChannel(argv[1], in_timestamp, modes, banlist, exemptlist);
+ cData = cNode->channel_info;
+
+ if (!cData) {
+ if (cNode->modes & MODE_REGISTERED) {
+ irc_join(opserv, cNode);
+ irc_mode(opserv, cNode, "-z");
+ irc_part(opserv, cNode, "");
+ }
+ }
/* Burst channel members in now. */
for (user = members, sep = *members, mode = 0; sep; user = end) {
return res;
}
-/* TODO:
+/* TODO:
* This is a stub that doesn't actually do anything. It should be completed
* so that bans on *!*@markname.* match users as it does in nefarious
*/
static CMD_FUNC(cmd_mark)
{
+ const char *tstr;
+ int type = 4;
struct userNode *target;
- /*
+ /*
* log_module(MAIN_LOG, LOG_ERROR, "DEBUG: mark, user %s, type %s, arg %s", argv[1], argv[2], argv[3]);
*/
+ tstr = conf_get_data("server/type", RECDB_QSTRING);
+ if(tstr)
+ type = atoi(tstr);
+ else
+ type = 4;/* default to 040 style topics */
+
if(argc < 4)
return 0;
if(!strcasecmp(argv[2], "DNSBL")) {
/* DNSBL <modes> */
return 1;
}
- else if(!strcasecmp(argv[2], "DNSBL_DATA")) {
+ else if(!strcasecmp(argv[2], "DNSBL_DATA") || !strcasecmp(argv[2], "MARK")) {
+ int markfound = 0;
+ unsigned int ii = 0;
/* DNSBL_DATA name */
target = GetUserH(argv[1]);
if(!target) {
- log_module(MAIN_LOG, LOG_ERROR, "Unable to find user %s whose mark is changing.", argv[1]);
+ log_module(MAIN_LOG, LOG_ERROR, "Unable to find user %s whose dnsbl mark is changing.", argv[1]);
return 0;
}
- target->mark = strdup(argv[3]);
+ if (type >= 9) {
+ if (target->marks)
+ for (ii=0; ii<target->marks->used; ii++)
+ if (!irccasecmp(target->marks->list[ii], argv[3]))
+ markfound = 1;
+ if (!markfound)
+ {
+ if (!target->marks)
+ target->marks = alloc_string_list(1);
+ string_list_append(target->marks, strdup(argv[3]));
+ }
+ } else
+ target->mark = strdup(argv[3]);
+ return 1;
+
+ }
+ else if(!strcasecmp(argv[2], "CVERSION")) {
+ /* CTCP VERSION mark */
+ target = GetUserH(argv[1]);
+ if(!target) {
+ log_module(MAIN_LOG, LOG_ERROR, "Unable to find user %s whose version mark is changing.", argv[1]);
+ return 0;
+ }
+
+ char *version = unsplit_string(argv + 3, argc - 3, NULL);
+ if(!version)
+ version = "";
+
+ target->version_reply = strdup(version);
+
+ if(match_ircglob(version, "WebTV;*"))
+ target->no_notice = true; /* webbies cant see notices */
+
+ return 1;
+ }
+ else if(!strcasecmp(argv[2], "SSLCLIFP")) {
+ /* SSL fingerprint mark */
+ target = GetUserH(argv[1]);
+ if(!target) {
+ log_module(MAIN_LOG, LOG_ERROR, "Unable to find user %s whose SSL fingerprint mark is changing.", argv[1]);
+ return 0;
+ }
+
+ char *sslfp = unsplit_string(argv + 3, argc - 3, NULL);
+ if(!sslfp)
+ sslfp = "";
+
+ target->sslfp = strdup(sslfp);
+
+ nickserv_do_autoauth(target);
+
return 1;
-
}
/* unknown type of mark */
return 1;
static CMD_FUNC(cmd_topic)
{
struct chanNode *cn;
- time_t chan_ts, topic_ts;
+ time_t topic_ts;
struct userNode *user;
if (argc < 3)
if (argc == 5) { /* Asuka / Topic Bursting IRCu's */
user = GetUserH(origin);
- chan_ts = atoi(argv[2]);
topic_ts = atoi(argv[3]);
} else if (argc >= 6) { /* Nefarious 0.5.0 */
user = GetUserH(strtok(argv[2], "!"));
- chan_ts = atoi(argv[3]);
topic_ts = atoi(argv[4]);
} else { /* Regular IRCu (No Topic Bursting)*/
user = GetUserH(origin);
- chan_ts = cn->timestamp;
topic_ts = now;
}
static CMD_FUNC(cmd_num_gline)
{
- time_t lastmod;
- if (argc < 6)
- return 0;
- lastmod = (argc > 5) ? strtoul(argv[5], NULL, 0) : 0;
- gline_add(origin, argv[3], atoi(argv[4])-now, argv[argc - 1], now, lastmod, 0, 0);
+ if (argc < 7) {
+ if (argc < 6)
+ return 0;
+ else
+ gline_add(origin, argv[3], atoi(argv[4])-now, argv[5], now, 0, 0);
+ } else {
+ if (!strcmp(argv[5], "+"))
+ gline_add(origin, argv[3], atoi(argv[4])-now, argv[6], now, 0, 0);
+ }
return 1;
}
static CMD_FUNC(cmd_num_shun)
{
- time_t lastmod;
- if (argc < 6)
- return 0;
- lastmod = (argc > 5) ? strtoul(argv[5], NULL, 0) : 0;
- shun_add(origin, argv[3], atoi(argv[4])-now, argv[argc - 1], now, lastmod, 0);
+ if (argc < 7) {
+ if (argc < 6)
+ return 0;
+ else
+ shun_add(origin, argv[3], atoi(argv[4])-now, argv[5], now, 0);
+ } else {
+ if (!strcmp(argv[5], "+"))
+ shun_add(origin, argv[3], atoi(argv[4])-now, argv[6], now, 0);
+ }
return 1;
}
* Ghost response to a KILL we sent out earlier. So we only
* whine if the target is local.
*/
- if (!strncmp(argv[1], self->numeric, strlen(self->numeric)))
+ if (!strncmp(argv[1], self->numeric, strlen(self->numeric))) {
log_module(MAIN_LOG, LOG_ERROR, "Unable to find kill victim %s", argv[1]);
- return 0;
+ return 0;
+ }
+ return 1;
}
if (IsLocal(user) && IsService(user)) {
if (argc < 2)
return 0;
- user = GetUserN(argv[1]);
+ if (strncmp(argv[1], "*", 2) == 0)
+ {
+ if (!(user = GetUserH(origin))) {
+ log_module(MAIN_LOG, LOG_ERROR, "Could not find SILENCE origin user %s", origin);
+ return 0;
+ }
+ }
+ else
+ user = GetUserN(argv[1]);
/* Sanity, go nuts if this happens */
if (!user)
{
struct privmsg_desc pd;
struct server *srv;
- int nuser = 0;
- if (argc < 3)
+ if (argc != 3)
return 0;
pd.user = GetUserH(origin);
- if(!pd.user)
- nuser = 1;
if (!pd.user || (IsGagged(pd.user) && !IsOper(pd.user))) {
}
else {
pd.is_notice = 1;
- pd.text = argv[argc - 1];
+ pd.text = argv[2];
parse_foreach(argv[1], privmsg_chan_helper, NULL, privmsg_user_helper, privmsg_invalid, &pd);
}
static CMD_FUNC(cmd_gline)
{
- time_t lastmod;
-
if (argc < 3)
return 0;
if (argv[2][0] == '+') {
if (argc < 5)
return 0;
- lastmod = (argc > 5) ? strtoul(argv[5], NULL, 0) : 0;
- gline_add(origin, argv[2]+1, strtoul(argv[3], NULL, 0), argv[argc-1], now, lastmod, 0, 0);
+ gline_add(origin, argv[2]+1, strtoul(argv[3], NULL, 0), argv[argc-1], now, 0, 0);
return 1;
} else if (argv[2][0] == '-') {
gline_remove(argv[2]+1, 0);
return 0;
}
+static CMD_FUNC(cmd_sgline)
+{
+ struct server *sender;
+
+ if (argc < 4)
+ return 0;
+
+ if (!(sender = GetServerH(origin)))
+ return 0;
+
+ gline_add(origin, argv[1], strtoul(argv[2], NULL, 0), argv[argc-1], now, 1, 0);
+ return 1;
+}
+
+static CMD_FUNC(cmd_sshun)
+{
+ struct server *sender;
+
+ if (argc < 4)
+ return 0;
+
+ if (!(sender = GetServerH(origin)))
+ return 0;
+
+ shun_add(origin, argv[1], strtoul(argv[2], NULL, 0), argv[argc-1], now, 1);
+ return 1;
+}
+
static CMD_FUNC(cmd_shun)
{
- time_t lastmod;
if (argc < 3)
return 0;
if (argv[2][0] == '+') {
if (argc < 5)
return 0;
- lastmod = (argc > 5) ? strtoul(argv[5], NULL, 0) : 0;
- shun_add(origin, argv[2]+1, strtoul(argv[3], NULL, 0), argv[argc-1], now, lastmod, 0);
+ shun_add(origin, argv[2]+1, strtoul(argv[3], NULL, 0), argv[argc-1], now, 0);
return 1;
} else if (argv[2][0] == '-') {
shun_remove(argv[2]+1, 0);
return 1;
}
-static oper_func_t *of_list;
-static unsigned int of_size = 0, of_used = 0;
-
void
free_user(struct userNode *user)
{
}
static void
-parse_cleanup(void)
+parse_cleanup(UNUSED_ARG(void *extra))
{
unsigned int nn;
free(of_list);
+ free(of_list_extra);
free(privmsg_funcs);
num_privmsg_funcs = 0;
free(notice_funcs);
for (nn=0; nn<dead_users.used; nn++)
free_user(dead_users.list[nn]);
userList_clean(&dead_users);
- free(his_servername);
- free(his_servercomment);
}
static void
p10_conf_reload(void) {
hidden_host_suffix = conf_get_data("server/hidden_host", RECDB_QSTRING);
+ his_servername = conf_get_data("server/his_servername", RECDB_QSTRING);
+ his_servercomment = conf_get_data("server/his_servercomment", RECDB_QSTRING);
}
static void
-remove_unbursted_channel(struct chanNode *cNode) {
+remove_unbursted_channel(struct chanNode *cNode, UNUSED_ARG(void *extra)) {
if (unbursted_channels)
dict_remove(unbursted_channels, cNode->name);
}
else
inttobase64(numer, (numnick << 18) + (usermask & 0x3ffff), 5);
- str = conf_get_data("server/his_servername", RECDB_QSTRING);
- his_servername = str ? strdup(str) : NULL;
- str = conf_get_data("server/his_servercomment", RECDB_QSTRING);
- his_servercomment = str ? strdup(str) : NULL;
-
str = conf_get_data("server/hostname", RECDB_QSTRING);
desc = conf_get_data("server/description", RECDB_QSTRING);
if (!str || !desc) {
dict_insert(irc_func_dict, TOK_SVSPART, cmd_svspart);
dict_insert(irc_func_dict, CMD_SWHOIS, cmd_dummy);
dict_insert(irc_func_dict, TOK_SWHOIS, cmd_dummy);
+ dict_insert(irc_func_dict, CMD_TEMPSHUN, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_TEMPSHUN, cmd_dummy);
dict_insert(irc_func_dict, CMD_WHOIS, cmd_whois);
dict_insert(irc_func_dict, TOK_WHOIS, cmd_whois);
dict_insert(irc_func_dict, CMD_GLINE, cmd_gline);
dict_insert(irc_func_dict, TOK_GLINE, cmd_gline);
+ dict_insert(irc_func_dict, CMD_SGLINE, cmd_sgline);
+ dict_insert(irc_func_dict, TOK_SGLINE, cmd_sgline);
dict_insert(irc_func_dict, CMD_SHUN, cmd_shun);
dict_insert(irc_func_dict, TOK_SHUN, cmd_shun);
+ dict_insert(irc_func_dict, CMD_SSHUN, cmd_sshun);
+ dict_insert(irc_func_dict, TOK_SSHUN, cmd_sshun);
dict_insert(irc_func_dict, CMD_OPMODE, cmd_opmode);
dict_insert(irc_func_dict, TOK_OPMODE, cmd_opmode);
dict_insert(irc_func_dict, CMD_CLEARMODE, cmd_clearmode);
dict_insert(irc_func_dict, TOK_VERSION, cmd_version);
dict_insert(irc_func_dict, CMD_ADMIN, cmd_admin);
dict_insert(irc_func_dict, TOK_ADMIN, cmd_admin);
+ dict_insert(irc_func_dict, CMD_SMO, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_SMO, cmd_dummy);
+ dict_insert(irc_func_dict, CMD_SNO, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_SNO, cmd_dummy);
dict_insert(irc_func_dict, CMD_RPING, cmd_rping);
dict_insert(irc_func_dict, TOK_RPING, cmd_rping);
dict_insert(irc_func_dict, CMD_RPONG, cmd_dummy);
dict_insert(irc_func_dict, TOK_RPONG, cmd_dummy);
+ dict_insert(irc_func_dict, CMD_SASL, cmd_sasl);
+ dict_insert(irc_func_dict, TOK_SASL, cmd_sasl);
+
/* In P10, DESTRUCT doesn't do anything except be broadcast to servers.
* Apparently to obliterate channels from any servers that think they
* exist?
/* ignore ALIST for now */
dict_insert(irc_func_dict, TOK_ALIST, cmd_dummy);
dict_insert(irc_func_dict, CMD_ALIST, cmd_dummy);
+ /* ignore SPAMFILTER */
+ dict_insert(irc_func_dict, TOK_SPAMFILTER, cmd_dummy);
+ dict_insert(irc_func_dict, CMD_SPAMFILTER, cmd_dummy);
/* Ignore remote luser */
dict_insert(irc_func_dict, TOK_LUSERS, 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);
+ /* Ignore ZLINE/ZL/REMOVE/RM */
+ dict_insert(irc_func_dict, CMD_ZLINE, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_ZLINE, cmd_dummy);
+ dict_insert(irc_func_dict, CMD_REMOVE, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_REMOVE, cmd_dummy);
/* ignore /trace and /motd commands targetted at us */
dict_insert(irc_func_dict, TOK_TRACE, cmd_dummy);
dict_insert(irc_func_dict, TOK_MOTD, cmd_dummy);
+ dict_insert(irc_func_dict, TOK_UPING, cmd_dummy);
/* handle topics */
dict_insert(irc_func_dict, "331", cmd_num_topic);
dict_insert(irc_func_dict, "432", cmd_error_nick); /* Erroneus [sic] nickname */
/* ban list resetting */
/* "stats g" responses */
+ dict_insert(irc_func_dict, "230", cmd_dummy); /* ignore stats headers */
dict_insert(irc_func_dict, "247", cmd_num_gline);
dict_insert(irc_func_dict, "542", cmd_num_shun);
dict_insert(irc_func_dict, "219", cmd_dummy); /* "End of /STATS report" */
memset(notice_funcs, 0, sizeof(privmsg_func_t)*num_notice_funcs);
userList_init(&dead_users);
- reg_del_channel_func(remove_unbursted_channel);
- reg_exit_func(parse_cleanup);
+ reg_del_channel_func(remove_unbursted_channel, NULL);
+ reg_exit_func(parse_cleanup, NULL);
// reg_notice_func(opserv, check_ctcp);
}
}
struct server *
-AddServer(struct server *uplink, const char *name, int hops, time_t boot, time_t link, const char *numeric, const char *description)
+AddServer(struct server *uplink, const char *name, int hops, time_t boot, time_t link_time, const char *numeric, const char *description)
{
struct server* sNode;
int slen, mlen;
sNode->num_mask = base64toint(numeric+slen, mlen);
sNode->hops = hops;
sNode->boot = boot;
- sNode->link = link;
+ sNode->link_time = link_time;
strncpy(sNode->numeric, numeric, slen);
safestrncpy(sNode->description, description, sizeof(sNode->description));
sNode->users = calloc(sNode->num_mask+1, sizeof(*sNode->users));
if (!modes)
modes = "+oik";
+
if (old_user) {
if (IsLocal(old_user))
return old_user;
if (!hostname)
hostname = self->name;
make_numeric(self, local_num, numeric);
- return AddUser(self, nick, ident, hostname, modes, numeric, desc, now, "AAAAAA");
+ return AddUser(self, nick, ident, hostname, modes, numeric, desc, timestamp, "AAAAAA");
}
struct userNode *
AddUser(struct server* uplink, const char *nick, const char *ident, const char *hostname, const char *modes, const char *numeric, const char *userinfo, time_t timestamp, const char *realip)
{
struct userNode *oldUser, *uNode;
- unsigned int n, ignore_user, dummy;
+ unsigned int ignore_user, dummy;
+ char *tstr;
+ int type;
if ((strlen(numeric) < 3) || (strlen(numeric) > 5)) {
- log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): numeric %s wrong length!", uplink, nick, numeric);
+ log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): numeric %s wrong length!", (void*)uplink, nick, numeric);
return NULL;
}
if (!uplink) {
- log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): server for numeric %s doesn't exist!", uplink, nick, numeric);
+ log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): server for numeric %s doesn't exist!", (void*)uplink, nick, numeric);
return NULL;
}
if (uplink != GetServerN(numeric)) {
- log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): server for numeric %s differs from nominal uplink %s.", uplink, nick, numeric, uplink->name);
+ log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): server for numeric %s differs from nominal uplink %s.", (void*)uplink, nick, numeric, uplink->name);
return NULL;
}
if (dummy) {
++modes;
} else if (!is_valid_nick(nick)) {
- log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): invalid nickname detected.", uplink, nick);
+ log_module(MAIN_LOG, LOG_WARNING, "AddUser(%p, %s, ...): invalid nickname detected.", (void*)uplink, nick);
return NULL;
}
ignore_user = 0;
if ((oldUser = GetUserH(nick))) {
- if (IsLocal(oldUser) && (IsService(oldUser) || IsPersistent(oldUser))) {
- /* The service should collide the new user off. */
+ if (IsLocal(oldUser)
+ && (IsService(oldUser) || IsPersistent(oldUser))) {
+ /* The service should collide the new user off - but not
+ * if the new user is coming in during a burst. (During a
+ * burst, the bursting server will kill either our user --
+ * triggering a ReintroduceUser() -- or its own.)
+ */
oldUser->timestamp = timestamp - 1;
- irc_user(oldUser);
- }
- if (oldUser->timestamp > timestamp) {
+ ignore_user = 1;
+ if (!uplink->burst)
+ irc_user(oldUser);
+ } else if (oldUser->timestamp > timestamp) {
/* "Old" user is really newer; remove them */
DelUser(oldUser, 0, 1, "Overruled by older nick");
} else {
safestrncpy(uNode->numeric, numeric, sizeof(uNode->numeric));
irc_p10_pton(&uNode->ip, realip);
- if (irc_in_addr_is_ipv4(uNode->ip)) {
- make_virtip((char*)irc_ntoa(&uNode->ip), (char*)irc_ntoa(&uNode->ip), uNode->cryptip);
- make_virthost((char*)irc_ntoa(&uNode->ip), uNode->hostname, uNode->crypthost);
- } else if (irc_in_addr_is_ipv6(uNode->ip)) {
- make_ipv6virthost((char*)irc_ntoa(&uNode->ip), uNode->hostname, uNode->crypthost);
+ tstr = conf_get_data("server/type", RECDB_QSTRING);
+ type = atoi(tstr);
+ if (type == 7) {
+ if (irc_in_addr_is_ipv4(uNode->ip)) {
+ make_virtip((char*)irc_ntoa(&uNode->ip), (char*)irc_ntoa(&uNode->ip), uNode->cryptip);
+ make_virthost((char*)irc_ntoa(&uNode->ip), uNode->hostname, uNode->crypthost);
+ } else if (irc_in_addr_is_ipv6(uNode->ip)) {
+ make_ipv6virthost((char*)irc_ntoa(&uNode->ip), uNode->hostname, uNode->crypthost);
+ }
}
if (!uNode->crypthost && uNode->cryptip)
snprintf(uNode->crypthost, sizeof(uNode->crypthost), "%s", strdup(uNode->cryptip));
-
- uNode->timestamp = timestamp;
uNode->idle_since = timestamp;
+ uNode->timestamp = timestamp;
modeList_init(&uNode->channels);
uNode->uplink = uplink;
if (++uNode->uplink->clients > uNode->uplink->max_clients) {
}
if (IsLocal(uNode))
irc_user(uNode);
- for (n=0; n<nuf_used; n++)
- if (nuf_list[n](uNode))
- break;
+ call_new_user_funcs(uNode);
if ((uNode->loc == 1) && (uNode->handle_info))
send_func_list(uNode);
void
DelUser(struct userNode* user, struct userNode *killer, int announce, const char *why)
{
- unsigned int n;
verify(user);
/* remove user from all channels */
while (user->channels.used > 0)
- DelChannelUser(user, user->channels.list[user->channels.used-1]->channel, NULL, false);
+ DelChannelUser(user, user->channels.list[user->channels.used-1]->channel, NULL, 0);
/* Call these in reverse order so ChanServ can update presence
information before NickServ nukes the handle_info. */
- for (n = duf_used; n > 0; )
- duf_list[--n](user, killer, why);
+ call_del_user_funcs(user, killer, why);
user->uplink->clients--;
user->uplink->users[user->num_local] = NULL;
- if (IsOper(user))
+ if (IsOper(user)) {
userList_remove(&curr_opers, user);
+ if (count_opers > 0 && !IsBotM(user) && !IsService(user) && !IsHideOper(user))
+ count_opers--;
+ }
/* remove from global dictionary, but not if after a collide */
if (user == dict_find(clients, user->nick, NULL))
dict_remove(clients, user->nick);
irc_kill(killer, user, why);
}
+ if (IsLocal(user)) {
+ unsigned int num = user->num_local;
+ if (num < num_privmsg_funcs)
+ privmsg_funcs[num] = NULL;
+ if (num < num_notice_funcs)
+ notice_funcs[num] = NULL;
+ }
+
modeList_clean(&user->channels);
/* Clean up version data */
user->version_reply = NULL;
}
+ /* Clean up SSL fingerprint data */
+ if(user->sslfp) {
+ free(user->sslfp);
+ user->sslfp = NULL;
+ }
+
/* clean up mark */
if(user->mark) {
free(user->mark);
user->mark = NULL;
}
+ free_string_list(user->marks);
+ user->marks = NULL;
/* clean up geoip data if any */
if(user->country_code) free(user->country_code);
if(user->region) free(user->region);
if(user->postal_code) free(user->postal_code);
- if (IsLocal(user)) {
- unsigned int num = user->num_local;
- if (num < num_privmsg_funcs)
- privmsg_funcs[num] = NULL;
- if (num < num_notice_funcs)
- notice_funcs[num] = NULL;
- }
-
/* We don't free them, in case we try to privmsg them or something
* (like when a stupid oper kills themself). We just put them onto
* a list of clients that get freed after processing each line.
void mod_usermode(struct userNode *user, const char *mode_change) {
int add = 1;
+ long setmodes = 0;
+ int donemodes = 0;
const char *word = mode_change;
if (!user || !mode_change)
call_user_mode_funcs(user, mode_change);
+ setmodes = user->modes;
+
while (*word != ' ' && *word) word++;
while (*word == ' ') word++;
- while (1) {
+ while (!donemodes) {
#define do_user_mode(FLAG) do { if (add) user->modes |= FLAG; else user->modes &= ~FLAG; } while (0)
switch (*mode_change++) {
- case 0: case ' ': return;
+ case 0: case ' ':
+ donemodes = 1;
+ break;
case '+': add = 1; break;
case '-': add = 0; break;
case 'o':
- if (add) {
- if(!IsOper(user)) { /* Dont re-oper an oper */
- userList_append(&curr_opers, user);
- call_oper_funcs(user);
- }
- } else {
- userList_remove(&curr_opers, user);
- }
do_user_mode(FLAGS_OPER);
+ if (!add) {
+ userList_remove(&curr_opers, user);
+ } else if (!userList_contains(&curr_opers, user)) {
+ userList_append(&curr_opers, user);
+ call_oper_funcs(user);
+ }
break;
case 'O': do_user_mode(FLAGS_LOCOP); break;
case 'i': do_user_mode(FLAGS_INVISIBLE);
invis_clients--;
break;
case 'w': do_user_mode(FLAGS_WALLOP); break;
- case 's': do_user_mode(FLAGS_SERVNOTICE); break;
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 'B': do_user_mode(FLAGS_BOT); break;
+ case 'n': do_user_mode(FLAGS_HIDECHANS); break;
+ case 'p': do_user_mode(FLAGS_HIDECHANS); break;
+ case 'I': do_user_mode(FLAGS_HIDEIDLE); break;
+ case 'X': do_user_mode(FLAGS_XTRAOP); break;
+ case 'C': do_user_mode(FLAGS_CLOAKHOST);
+ if (*word) {
+ char cloakhost[MAXLEN];
+ unsigned int ii;
+ for (ii=0; (*word != ' ') && (*word != '\0'); )
+ cloakhost[ii++] = *word++;
+ cloakhost[ii] = 0;
+ while (*word == ' ')
+ word++;
+ safestrncpy(user->crypthost, cloakhost, sizeof(user->crypthost));
+ }
+ break;
+ case 'c': do_user_mode(FLAGS_CLOAKIP);
+ if (*word) {
+ char cloakip[MAXLEN];
+ unsigned int ii;
+ for (ii=0; (*word != ' ') && (*word != '\0'); )
+ cloakip[ii++] = *word++;
+ cloakip[ii] = 0;
+ while (*word == ' ')
+ word++;
+ safestrncpy(user->cryptip, cloakip, sizeof(user->cryptip));
+ }
+ 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];
safestrncpy(user->sethost, sethost, sizeof(user->sethost));
}
break;
- case 'n': do_user_mode(FLAGS_NOCHAN); break;
- case 'I': do_user_mode(FLAGS_NOIDLE); break;
case 'x': do_user_mode(FLAGS_HIDDEN_HOST); break;
case 'r':
if (*word) {
assign_fakehost(user, host, 0);
}
break;
+ case 'a': do_user_mode(FLAGS_ADMIN); break;
+ case 'z': do_user_mode(FLAGS_SSL); break;
+ case 'D': do_user_mode(FLAGS_PRIVDEAF); break;
+ case 'R': do_user_mode(FLAGS_ACCOUNTONLY); break;
+ case 'W': do_user_mode(FLAGS_WHOIS); break;
+ case 'H': do_user_mode(FLAGS_HIDEOPER); break;
+ case 'L': do_user_mode(FLAGS_NOLINK); break;
+ case 'q': do_user_mode(FLAGS_COMMONCHANSONLY); break;
}
#undef do_user_mode
}
+
+ // Set user mode +o
+ if (!(setmodes & FLAGS_OPER) && IsOper(user)) {
+ if (!IsBotM(user) && !IsService(user) && !IsHideOper(user))
+ count_opers++;
+ }
+
+ // Set user mode -o
+ if ((setmodes & FLAGS_OPER) && !IsOper(user)) {
+ if (count_opers > 1 && !(setmodes & FLAGS_BOT) &&
+ !(setmodes & FLAGS_SERVICE) && !(setmodes & FLAGS_HIDEOPER))
+ count_opers--;
+ }
+
+ // Set +H, +k or +B
+ if (!(setmodes & FLAGS_HIDEOPER) &&
+ !(setmodes & FLAGS_SERVICE) &&
+ !(setmodes & FLAGS_BOT) &&
+ (IsHideOper(user) || IsService(user) || IsBotM(user))) {
+ if ((setmodes & FLAGS_OPER) && IsOper(user) && count_opers > 0)
+ count_opers--;
+ }
+
+ // Set -H, -k or -B
+ if (((setmodes & FLAGS_HIDEOPER) ||
+ (setmodes & FLAGS_SERVICE) ||
+ (setmodes & FLAGS_BOT)) &&
+ !IsHideOper(user) && !IsService(user) && !IsBotM(user)) {
+ if ((setmodes & FLAGS_OPER) && IsOper(user))
+ count_opers++;
+ }
+}
+
+static int
+keyncpy(char output[], char input[], size_t output_size)
+{
+ size_t ii;
+
+ if (input[0] == ':')
+ {
+ output[0] = '\0';
+ return 1;
+ }
+
+ for (ii = 0; (ii + 1 < output_size) && (input[ii] != '\0'); ++ii)
+ {
+ output[ii] = input[ii];
+ }
+
+ output[ii] = '\0';
+ return 0;
}
struct mod_chanmode *
case 'Q': do_chan_mode(MODE_NOQUITMSGS); break;
case 'T': do_chan_mode(MODE_NOAMSG); break;
case 'O': do_chan_mode(MODE_OPERSONLY); break;
+ case 'a': do_chan_mode(MODE_ADMINSONLY); break;
case 'Z': do_chan_mode(MODE_SSLONLY); break;
case 'L': do_chan_mode(MODE_HIDEMODE); break;
case 'z':
if (!(flags & MCP_REGISTERED)) {
- do_chan_mode(MODE_REGISTERED);
+ do_chan_mode(MODE_REGISTERED);
} else {
- mod_chanmode_free(change);
- return NULL;
+ mod_chanmode_free(change);
+ return NULL;
}
break;
#undef do_chan_mode
break;
case 'k':
if (add) {
- if (in_arg >= argc)
+ if ((in_arg >= argc)
+ || keyncpy(change->new_key, modes[in_arg++], sizeof(change->new_key)))
goto error;
change->modes_set |= MODE_KEY;
- safestrncpy(change->new_key, modes[in_arg++], sizeof(change->new_key));
} else {
change->modes_clear |= MODE_KEY;
if (!(flags & MCP_KEY_FREE)) {
case 'U':
if (add)
{
- if (in_arg >= argc)
- goto error;
- change->modes_set |= MODE_UPASS;
- safestrncpy(change->new_upass, modes[in_arg++], sizeof(change->new_upass));
+ if ((in_arg >= argc)
+ || keyncpy(change->new_upass, modes[in_arg++], sizeof(change->new_upass)))
+ goto error;
+ change->modes_set |= MODE_UPASS;
} else {
change->modes_clear |= MODE_UPASS;
if (!(flags & MCP_UPASS_FREE)) {
break;
case 'A':
if (add) {
- if (in_arg >= argc)
+ if ((in_arg >= argc)
+ || keyncpy(change->new_apass, modes[in_arg++], sizeof(change->new_apass)))
goto error;
change->modes_set |= MODE_APASS;
- safestrncpy(change->new_apass, modes[in_arg++], sizeof(change->new_apass));
} else {
change->modes_clear |= MODE_APASS;
if (!(flags & MCP_APASS_FREE)) {
DO_MODE_CHAR(NOQUITMSGS, 'Q');
DO_MODE_CHAR(NOAMSG, 'T');
DO_MODE_CHAR(OPERSONLY, 'O');
+ DO_MODE_CHAR(ADMINSONLY, 'a');
DO_MODE_CHAR(REGISTERED, 'z');
DO_MODE_CHAR(SSLONLY, 'Z');
DO_MODE_CHAR(HIDEMODE, 'L');
DO_MODE_CHAR(NOQUITMSGS, 'Q');
DO_MODE_CHAR(NOAMSG, 'T');
DO_MODE_CHAR(OPERSONLY, 'O');
+ DO_MODE_CHAR(ADMINSONLY, 'a');
DO_MODE_CHAR(REGISTERED, 'z');
DO_MODE_CHAR(SSLONLY, 'Z');
DO_MODE_CHAR(HIDEMODE, 'L');
DO_MODE_CHAR(NOQUITMSGS, 'Q');
DO_MODE_CHAR(NOAMSG, 'T');
DO_MODE_CHAR(OPERSONLY, 'O');
+ DO_MODE_CHAR(ADMINSONLY, 'a');
DO_MODE_CHAR(REGISTERED, 'z');
DO_MODE_CHAR(SSLONLY, 'Z');
DO_MODE_CHAR(HIDEMODE, 'L');
DO_MODE_CHAR(NOQUITMSGS, 'Q');
DO_MODE_CHAR(NOAMSG, 'T');
DO_MODE_CHAR(OPERSONLY, 'O');
+ DO_MODE_CHAR(ADMINSONLY, 'a');
DO_MODE_CHAR(REGISTERED, 'z');
DO_MODE_CHAR(SSLONLY, 'Z');
DO_MODE_CHAR(HIDEMODE, 'L');
-#undef DO_MODE_CHAR
- switch (change->modes_set & (MODE_KEY|MODE_LIMIT|MODE_APASS|MODE_UPASS)) {
- /* Doing this implementation has been a pain in the arse, I hope I didn't forget a possible combination */
- case MODE_KEY|MODE_LIMIT|MODE_APASS|MODE_UPASS:
- used += sprintf(outbuff+used, "lkAU %d %s %s %s", change->new_limit, change->new_key,change->new_apass, change->new_upass);
- break;
-
- case MODE_KEY|MODE_LIMIT|MODE_APASS:
- used += sprintf(outbuff+used, "lkA %d %s %s", change->new_limit, change->new_key, change->new_apass);
- break;
- case MODE_KEY|MODE_LIMIT|MODE_UPASS:
- used += sprintf(outbuff+used, "lkU %d %s %s", change->new_limit, change->new_key, change->new_upass);
- break;
- case MODE_KEY|MODE_APASS|MODE_UPASS:
- used += sprintf(outbuff+used, "kAU %s %s %s", change->new_key, change->new_apass, change->new_upass);
- break;
-
- case MODE_KEY|MODE_APASS:
- used += sprintf(outbuff+used, "kA %s %s", change->new_key, change->new_apass);
- break;
- case MODE_KEY|MODE_UPASS:
- used += sprintf(outbuff+used, "kU %s %s", change->new_key, change->new_upass);
- break;
- case MODE_KEY|MODE_LIMIT:
- used += sprintf(outbuff+used, "lk %d %s", change->new_limit, change->new_key);
- break;
-
- case MODE_LIMIT|MODE_UPASS:
- used += sprintf(outbuff+used, "lU %d %s", change->new_limit, change->new_upass);
- break;
- case MODE_LIMIT|MODE_APASS:
- used += sprintf(outbuff+used, "lA %d %s", change->new_limit, change->new_apass);
- break;
- case MODE_APASS|MODE_UPASS:
- used += sprintf(outbuff+used, "AU %s %s", change->new_apass, change->new_upass);
- case MODE_LIMIT|MODE_APASS|MODE_UPASS:
- used += sprintf(outbuff+used, "lAU %d %s %s", change->new_limit, change->new_apass, change->new_upass);
- break;
+ DO_MODE_CHAR(KEY, 'k');
+ DO_MODE_CHAR(LIMIT, 'l');
+ DO_MODE_CHAR(APASS, 'A');
+ DO_MODE_CHAR(UPASS, 'U');
+#undef DO_MODE_CHAR
- case MODE_APASS:
- used += sprintf(outbuff+used, "A %s", change->new_apass);
- break;
- case MODE_UPASS:
- used += sprintf(outbuff+used, "U %s", change->new_upass);
- break;
- case MODE_KEY:
- used += sprintf(outbuff+used, "k %s", change->new_key);
- break;
- case MODE_LIMIT:
- used += sprintf(outbuff+used, "l %d", change->new_limit);
- break;
- }
+#define DO_MODE_PARM(BIT, PARM) if (change->modes_set & MODE_##BIT) used += sprintf(outbuff+used, " %s", PARM);
+ DO_MODE_PARM(KEY, change->new_key);
+ if (change->modes_set & MODE_LIMIT) used += sprintf(outbuff+used, " %d", change->new_limit);
+ DO_MODE_PARM(APASS, change->new_apass);
+ DO_MODE_PARM(UPASS, change->new_upass);
+#undef DO_MODE_PARM
}
outbuff[used] = 0;
return outbuff;
static int
clear_chanmode(struct chanNode *channel, const char *modes)
{
- unsigned int remove;
+ unsigned int cleared;
- for (remove = 0; *modes; modes++) {
+ for (cleared = 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;
- case 'm': remove |= MODE_MODERATED; break;
- case 't': remove |= MODE_TOPICLIMIT; break;
- case 'i': remove |= MODE_INVITEONLY; break;
- case 'n': remove |= MODE_NOPRIVMSGS; break;
+ case 'o': cleared |= MODE_CHANOP; break;
+ case 'h': cleared |= MODE_HALFOP; break;
+ case 'v': cleared |= MODE_VOICE; break;
+ case 'p': cleared |= MODE_PRIVATE; break;
+ case 's': cleared |= MODE_SECRET; break;
+ case 'm': cleared |= MODE_MODERATED; break;
+ case 't': cleared |= MODE_TOPICLIMIT; break;
+ case 'i': cleared |= MODE_INVITEONLY; break;
+ case 'n': cleared |= MODE_NOPRIVMSGS; break;
case 'k':
- remove |= MODE_KEY;
+ cleared |= MODE_KEY;
channel->key[0] = '\0';
break;
case 'A':
- remove |= MODE_APASS;
+ cleared |= MODE_APASS;
channel->apass[0] = '\0';
break;
case 'U':
- remove |= MODE_UPASS;
+ cleared |= MODE_UPASS;
channel->upass[0] = '\0';
break;
case 'l':
- remove |= MODE_LIMIT;
+ cleared |= MODE_LIMIT;
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; break;
- 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;
- case 'z': remove |= MODE_REGISTERED; break;
- case 'Z': remove |= MODE_SSLONLY; break;
- case 'L': remove |= MODE_HIDEMODE; break;
+ case 'b': cleared |= MODE_BAN; break;
+ case 'e': cleared |= MODE_EXEMPT; break;
+ case 'D': cleared |= MODE_DELAYJOINS; break;
+ case 'r': cleared |= MODE_REGONLY; break;
+ case 'c': cleared |= MODE_NOCOLORS; break;
+ case 'C': cleared |= MODE_NOCTCPS; break;
+ case 'S': cleared |= MODE_STRIPCOLOR; break;
+ case 'M': cleared |= MODE_MODUNREG; break;
+ case 'N': cleared |= MODE_NONOTICE; break;
+ case 'Q': cleared |= MODE_NOQUITMSGS; break;
+ case 'T': cleared |= MODE_NOAMSG; break;
+ case 'O': cleared |= MODE_OPERSONLY; break;
+ case 'a': cleared |= MODE_ADMINSONLY; break;
+ case 'z': cleared |= MODE_REGISTERED; break;
+ case 'Z': cleared |= MODE_SSLONLY; break;
+ case 'L': cleared |= MODE_HIDEMODE; break;
}
}
- if (!remove)
+ if (!cleared)
return 1;
/* Remove simple modes. */
- channel->modes &= ~remove;
+ channel->modes &= ~cleared;
/* If removing bans, kill 'em all. */
- if ((remove & MODE_BAN) && channel->banlist.used) {
+ if ((cleared & MODE_BAN) && channel->banlist.used) {
unsigned int i;
for (i=0; i<channel->banlist.used; i++)
free(channel->banlist.list[i]);
}
/* If removing exempts, kill 'em all. */
- if ((remove & MODE_EXEMPT) && channel->exemptlist.used) {
+ if ((cleared & 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_HALFOP | MODE_VOICE)) && channel->members.used) {
- int mask = ~(remove & (MODE_CHANOP | MODE_HALFOP | MODE_VOICE));
+ /* Removed member modes. */
+ if ((cleared & (MODE_CHANOP | MODE_HALFOP | MODE_VOICE)) && channel->members.used) {
+ int mask = ~(cleared & (MODE_CHANOP | MODE_HALFOP | MODE_VOICE));
unsigned int i;
for (i = 0; i < channel->members.used; i++)
unreg_privmsg_func(struct userNode *user)
{
if (!IsLocal(user) || user->num_local >= num_privmsg_funcs)
- return; /* this really only works with users */
+ return; /* this really only works with users */
privmsg_funcs[user->num_local] = NULL;
}
unreg_notice_func(struct userNode *user)
{
if (!IsLocal(user) || user->num_local >= num_privmsg_funcs)
- return; /* this really only works with users */
+ return; /* this really only works with users */
notice_funcs[user->num_local] = NULL;
}
-void
-reg_oper_func(oper_func_t handler)
-{
- if (of_used == of_size) {
- if (of_size) {
- of_size <<= 1;
- of_list = realloc(of_list, of_size*sizeof(oper_func_t));
- } else {
- of_size = 8;
- of_list = malloc(of_size*sizeof(oper_func_t));
- }
- }
- of_list[of_used++] = handler;
-}
-
-static void
-call_oper_funcs(struct userNode *user)
-{
- unsigned int n;
- if (IsLocal(user))
- return;
- for (n=0; n<of_used; n++)
- of_list[n](user);
-}
-
static void
send_burst(void)
{
projects / irc / evilnet / x3.git / blobdiff