X-Git-Url: https://jfr.im/git/irc/evilnet/x3.git/blobdiff_plain/0c835e0f71608e76dc4f5805233a79d6e6850c9f..412b1e16431d0eafbe1bacb0d7e610971144035c:/src/proto-p10.c diff --git a/src/proto-p10.c b/src/proto-p10.c index 1f82782..aa44db5 100644 --- a/src/proto-p10.c +++ b/src/proto-p10.c @@ -3,9 +3,9 @@ * * This file is part of x3. * - * srvx is free software; you can redistribute it and/or modify + * x3 is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or + * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, @@ -18,12 +18,18 @@ * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ +#include "nickserv.h" #include "chanserv.h" +#include "hash.h" +#include "helpfile.h" +#include "hosthiding.h" #include "proto-common.c" +#include "opserv.h" /* Full commands. */ #define CMD_ACCOUNT "ACCOUNT" #define CMD_ADMIN "ADMIN" +#define CMD_ALIST "ALIST" #define CMD_ASLL "ASLL" #define CMD_AWAY "AWAY" #define CMD_BURST "BURST" @@ -83,11 +89,15 @@ #define CMD_SERVSET "SERVSET" #define CMD_SET "SET" #define CMD_SETTIME "SETTIME" +#define CMD_SHUN "SHUN" #define CMD_SILENCE "SILENCE" #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_SWHOIS "SWHOIS" #define CMD_TIME "TIME" #define CMD_TOPIC "TOPIC" #define CMD_TRACE "TRACE" @@ -109,6 +119,7 @@ /* Tokenized commands. */ #define TOK_ACCOUNT "AC" #define TOK_ADMIN "AD" +#define TOK_ALIST "AL" #define TOK_ASLL "LL" #define TOK_AWAY "A" #define TOK_BURST "B" @@ -169,11 +180,15 @@ #define TOK_SERVSET "SERVSET" #define TOK_SET "SET" #define TOK_SETTIME "SE" +#define TOK_SHUN "SU" #define TOK_SILENCE "U" #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_SWHOIS "SW" #define TOK_TIME "TI" #define TOK_TOPIC "T" #define TOK_TRACE "TR" @@ -265,11 +280,15 @@ #define P10_SERVSET TYPE(SERVSET) #define P10_SET TYPE(SET) #define P10_SETTIME TYPE(SETTIME) +#define P10_SHUN TYPE(SHUN) #define P10_SILENCE TYPE(SILENCE) #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_SWHOIS TYPE(SWHOIS) #define P10_TIME TYPE(TIME) #define P10_TOPIC TYPE(TOPIC) #define P10_TRACE TYPE(TRACE) @@ -294,6 +313,8 @@ */ #define PREHISTORY 780000000 +#define MODELEN 40 + KEYLEN + static struct server *servers_num[64*64]; static privmsg_func_t *privmsg_funcs; static unsigned int num_privmsg_funcs; @@ -302,10 +323,18 @@ static unsigned int num_notice_funcs; static struct dict *unbursted_channels; static char *his_servername; static char *his_servercomment; +static int extended_accounts; 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; +extern int DefConLevel; +extern int DefConTimeOut; +extern char *DefConChanModes; + +static int parse_oplevel(char *str); + +char privbuf[512] = ""; /* Numerics can be XYY, XYYY, or XXYYY; with X's identifying the * server and Y's indentifying the client on that server. */ @@ -353,6 +382,32 @@ GetUserN(const char *numeric) /* using numeric */ return un; } +extern struct userNode *opserv; +static void +check_ctcp(struct userNode *user, struct userNode *bot, char *text, UNUSED_ARG(int server_qualified)) +{ + char *cmd; + /* if its a version reply, do an alert check (only alerts with version=something) */ + if(bot == opserv) { + if(text[0] == '\001') { + text++; + cmd = mysep(&text, " "); + if(!irccasecmp(cmd, "VERSION")) { + char *version = mysep(&text, "\n"); + if(!version) + version = ""; + /* opserv_debug("Opserv got CTCP VERSION Notice from %s: %s", user->nick, version); */ + /* TODO: setup a ctcp_funcs thing to handle this and other CTCPS properly */ + user->version_reply = strdup(version); + /* TODO: put this in the db */ + if(match_ircglob(version, "WebTV;*")) + user->no_notice = true; /* webbies cant see notices */ + } + } + } +} + + static void privmsg_user_helper(struct userNode *un, void *data) { @@ -364,11 +419,49 @@ privmsg_user_helper(struct userNode *un, void *data) } } else { if ((num < num_notice_funcs) && notice_funcs[num]) { + check_ctcp(pd->user, un, pd->text, pd->is_qualified); notice_funcs[num](pd->user, un, pd->text, pd->is_qualified); } } } +/* equiv to user doing /connect server port target */ +void irc_connect(struct userNode *user, char *server, unsigned int port, struct server *target) +{ + putsock("%s " P10_CONNECT " %s %d %s", user->numeric, server, port, target->numeric); +} + +void +irc_squit_route(struct server *srv, const char *message, ...) +{ + va_list arg_list; + char buffer[MAXLEN]; + va_start(arg_list, message); + vsnprintf(buffer, MAXLEN-2, message, arg_list); + buffer[MAXLEN-1] = 0; + + /* When would we squit ourselves exactly?? -Rubin */ + if(srv == self && cManager.uplink->state == CONNECTED ) { + unsigned int i; + + /* Quit all clients linked to me. */ + for(i = 0; i <= self->num_mask; i++) { + if(!self->users[i]) + continue; + irc_quit(self->users[i], buffer); + } + } + + putsock("%s " P10_SQUIT " %s %d :%s", self->numeric, srv->name, 0, buffer); + + if(srv == self) { + /* Force a reconnect to the currently selected server. */ + cManager.uplink->tries = 0; + log_module(MAIN_LOG, LOG_INFO, "Squitting from uplink: %s", buffer); + close_socket(); + } +} + void irc_server(struct server *srv) { @@ -376,22 +469,96 @@ irc_server(struct server *srv) inttobase64(extranum, srv->num_mask, (srv->numeric[1] || (srv->num_mask >= 64*64)) ? 3 : 2); if (srv == self) { - /* The +s, ignored by Run's ircu, means "service" to Undernet's ircu */ - putsock(P10_SERVER " %s %d %li %li J10 %s%s +s :%s", + 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); } else { - putsock("%s " P10_SERVER " %s %d %li %li %c10 %s%s +s :%s", + 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); } } +static void +irc_p10_pton(irc_in_addr_t *ip, const char *input) +{ + if (strlen(input) == 6) { + unsigned int value; + memset(ip, 0, 6 * sizeof(ip->in6[0])); + value = base64toint(input, 6); + if (value) + ip->in6[5] = htons(65535); + ip->in6[6] = htons(value >> 16); + ip->in6[7] = htons(value & 65535); + } else { + unsigned int pos = 0; + do { + if (*input == '_') { + unsigned int left; + for (left = (25 - strlen(input)) / 3; left; left--) + ip->in6[pos++] = 0; + input++; + } else { + ip->in6[pos++] = ntohs(base64toint(input, 3)); + input += 3; + } + } while (pos < 8); + } +} + +static void +irc_p10_ntop(char *output, const irc_in_addr_t *ip) +{ + if (!irc_in_addr_is_valid(*ip)) { + strcpy(output, "AAAAAA"); + } else if (irc_in_addr_is_ipv4(*ip)) { + unsigned int in4; + in4 = (ntohs(ip->in6[6]) << 16) | ntohs(ip->in6[7]); + inttobase64(output, in4, 6); + output[6] = '\0'; + } else if (irc_in_addr_is_ipv6(*ip)) { + unsigned int max_start, max_zeros, curr_zeros, zero, ii; + /* Can start by printing out the leading non-zero parts. */ + for (ii = 0; (ip->in6[ii]) && (ii < 8); ++ii) { + inttobase64(output, ntohs(ip->in6[ii]), 3); + output += 3; + } + /* Find the longest run of zeros. */ + for (max_start = zero = ii, max_zeros = curr_zeros = 0; ii < 8; ++ii) { + if (!ip->in6[ii]) + curr_zeros++; + else if (curr_zeros > max_zeros) { + max_start = ii - curr_zeros; + max_zeros = curr_zeros; + curr_zeros = 0; + } + } + if (curr_zeros > max_zeros) { + max_start = ii - curr_zeros; + max_zeros = curr_zeros; + curr_zeros = 0; + } + /* Print the rest of the address */ + for (ii = zero; ii < 8; ) { + if ((ii == max_start) && max_zeros) { + *output++ = '_'; + ii += max_zeros; + } else { + inttobase64(output, ntohs(ip->in6[ii]), 3); + output += 3; + } + } + *output = '\0'; + } else { + strcpy(output, "???"); + } +} + void irc_user(struct userNode *user) { - char b64ip[7]; + char b64ip[25]; if (!user) return; - inttobase64(b64ip, ntohl(user->ip.s_addr), 6); + irc_p10_ntop(b64ip, &user->ip); if (user->modes) { int modelen; char modes[32]; @@ -430,10 +597,27 @@ irc_user(struct userNode *user) } } +void +irc_rename(struct userNode *user, const char *new_handle) +{ + if(extended_accounts) + putsock("%s " P10_ACCOUNT " %s M %s", self->numeric, user->numeric, new_handle); +} + +void +irc_delete(struct userNode *user) +{ + if(extended_accounts) + putsock("%s " P10_ACCOUNT " %s U", self->numeric, user->numeric); +} + void irc_account(struct userNode *user, const char *stamp, time_t timestamp) { - putsock("%s " P10_ACCOUNT " %s R %s %lu", self->numeric, user->numeric, stamp, timestamp); + if(extended_accounts) + putsock("%s " P10_ACCOUNT " %s R %s %lu", self->numeric, user->numeric, stamp, timestamp); + else + putsock("%s " P10_ACCOUNT " %s %s %lu", self->numeric, user->numeric, stamp, timestamp); } void @@ -496,6 +680,18 @@ irc_wallchops(struct userNode *from, const char *to, const char *message) putsock("%s " P10_WALLCHOPS " %s :%s", from->numeric, to, message); } +void +irc_wallops(const char *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 " P10_WALLOPS " :%s", self->numeric, buffer); +} + + void irc_notice(struct userNode *from, const char *to, const char *message) { @@ -514,6 +710,18 @@ irc_privmsg(struct userNode *from, const char *to, const char *message) putsock("%s " P10_PRIVMSG " %s :%s", from->numeric, to, message); } +void +irc_privmsg_user(struct userNode *from, struct userNode *to, const char *message) +{ + putsock("%s " P10_PRIVMSG " %s :%s", from->numeric, to->numeric, message); +} + +void +irc_version_user(struct userNode *from, struct userNode *to) +{ + irc_privmsg_user(from, to, "\001VERSION\001"); +} + void irc_eob(void) { @@ -524,6 +732,24 @@ void irc_eob_ack(void) { putsock("%s " P10_EOB_ACK, self->numeric); + + char *nick; + const char *str; + str = conf_get_data("services/opserv/nick", RECDB_QSTRING); + nick = strdup(str); + + if (nick && (DefConLevel < 5)) { + DefConProcess(GetUserH(nick)); + + if (DefConTimeOut > 0) + timeq_add(now + DefConTimeOut, defcon_timeout, NULL); + } +} + +void +irc_rpong(const char *from1, const char *from2, const char *pingtime, const char *clientinfo) +{ + putsock("%s " P10_RPONG " %s %s %s :%s", self->numeric, from1, from2, pingtime, clientinfo); } void @@ -538,6 +764,21 @@ irc_pong(const char *who, const char *data) putsock("%s " P10_PONG " %s :%s", self->numeric, who, data); } +void +irc_pong_asll(const char *who, const char *orig_ts) +{ + char *delim; + struct timeval orig; + struct timeval 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); +} + void irc_pass(const char *passwd) { @@ -557,10 +798,17 @@ irc_introduce(const char *passwd) } void -irc_gline(struct server *srv, struct gline *gline) +irc_gline(struct server *srv, struct gline *gline, int silent) +{ + 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); +} + +void +irc_shun(struct server *srv, struct shun *shun) { - putsock("%s " P10_GLINE " %s +%s %ld :<%s> %s", - self->numeric, (srv ? srv->numeric : "*"), gline->target, gline->expires-now, gline->issuer, gline->reason); + putsock("%s " P10_SHUN " %s +%s %ld :<%s> %s", + self->numeric, (srv ? srv->numeric : "*"), shun->target, shun->expires-now, shun->issuer, shun->reason); } void @@ -578,6 +826,12 @@ irc_ungline(const char *mask) putsock("%s " P10_GLINE " * -%s", self->numeric, mask); } +void +irc_unshun(const char *mask) +{ + putsock("%s " P10_SHUN " * -%s", self->numeric, mask); +} + static void irc_burst(struct chanNode *chan) { @@ -596,6 +850,8 @@ irc_burst(struct chanNode *chan) if (len) burst_line[pos++] = ' '; + if(chan->members.used < 1) + return; /* dont burst empty channels (created by discrims) */ /* dump the users */ for (n=0; nmembers.used; n++) { mn = chan->members.list[n]; @@ -605,6 +861,7 @@ irc_burst(struct chanNode *chan) pos = base_len; last_mode = -1; } + memcpy(burst_line+pos, mn->user->numeric, strlen(mn->user->numeric)); pos += strlen(mn->user->numeric); if (mn->modes && (mn->modes != last_mode)) { @@ -709,6 +966,7 @@ irc_kill(struct userNode *from, struct userNode *target, const char *message) void irc_mode(struct userNode *from, struct chanNode *target, const char *modes) { + call_channel_mode_funcs(from, target, (char **)&modes, 0); putsock("%s " P10_MODE " %s %s "FMT_TIME_T, (from ? from->numeric : self->numeric), target->name, modes, target->timestamp); @@ -730,6 +988,12 @@ irc_invite(struct userNode *from, struct userNode *who, struct chanNode *to) putsock("%s " P10_INVITE " %s %s", from->numeric, who->nick, to->name); } +void +irc_silence(struct userNode *who, const char *mask, int add) +{ + putsock("%s " P10_SILENCE " %s %s%s", self->numeric, who->numeric, add ? "+" : "-", mask); +} + void irc_join(struct userNode *who, struct chanNode *what) { @@ -741,6 +1005,18 @@ irc_join(struct userNode *who, struct chanNode *what) } } +void +irc_svsjoin(struct userNode *from, struct userNode *who, struct chanNode *to) +{ + putsock("%s " P10_SVSJOIN " %s %s "FMT_TIME_T, from->uplink->numeric, who->numeric, to->name, now); +} + +void +irc_svspart(struct userNode *from, struct userNode *who, struct chanNode *to) +{ + putsock("%s " P10_SVSPART " %s %s", from->uplink->numeric, who->numeric, to->name); +} + void irc_kick(struct userNode *who, struct userNode *target, struct chanNode *channel, const char *msg) { @@ -763,6 +1039,14 @@ irc_svsnick(struct userNode *from, struct userNode *target, const char *newnick) putsock("%s " P10_SVSNICK " %s %s "FMT_TIME_T, from->uplink->numeric, target->numeric, newnick, now); } +void +irc_swhois(struct userNode *from, struct userNode *target, const char *message) +{ + putsock("%s " P10_SWHOIS " %s %s%s", from->uplink->numeric, target->numeric, message ? ":" : "", + message ? message : ""); + +} + void irc_part(struct userNode *who, struct chanNode *what, const char *reason) { @@ -774,9 +1058,49 @@ irc_part(struct userNode *who, struct chanNode *what, const char *reason) } void -irc_topic(struct userNode *who, struct chanNode *what, const char *topic) -{ - putsock("%s " P10_TOPIC " %s :%s", who->numeric, what->name, topic); +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; + 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); + if(tstr) + type = atoi(tstr); + else + type = 4;/* default to 040 style topics */ + + if (hstr) { + if (IsFakeHost(who)) + safestrncpy(shost, who->fakehost, sizeof(shost)); + else if (IsSetHost(who)) { + hostmask = strdup(who->sethost); + if ((host = (strrchr(hostmask, '@')))) + *host++ = '\0'; + else + host = hostmask; + + safestrncpy(sident, hostmask, sizeof(shost)); + safestrncpy(shost, host, sizeof(shost)); + } else + safestrncpy(shost, who->hostname, sizeof(shost)); + + host_in_topic = atoi(hstr); + } + + if (type >= 5) { + putsock("%s " P10_TOPIC " %s %s%s%s%s%s " FMT_TIME_T " " FMT_TIME_T " :%s", service->numeric, what->name, + who->nick, host_in_topic ? "!" : "", host_in_topic ? (IsSetHost(who) ? sident : who->ident) : "", + host_in_topic ? "@" : "", host_in_topic ? shost : "", what->timestamp, now, topic); + } else { + who = service; + putsock("%s " P10_TOPIC " %s :%s", who->numeric, what->name, topic); + } } void @@ -796,6 +1120,48 @@ irc_numeric(struct userNode *user, unsigned int num, const char *format, ...) putsock(":%s %03d %s %s", self->name, num, user->nick, buffer); } +void +irc_mark(struct userNode *user, char *mark) +{ + char *host = user->hostname; + + /* 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) + return; + + /* if the mark will put us over the host length, clip some off the left hand side + * to make room... + */ + if(strlen(host) + 1 + strlen(mark) > HOSTLEN) + host += 1 + ( (strlen(host) + 1 + strlen(mark)) - HOSTLEN ); + putsock("%s " CMD_MARK " %s DNSBL +m %s.%s", self->numeric, user->nick, mark, host); + putsock("%s " CMD_MARK " %s DNSBL_DATA %s", self->numeric, user->nick, mark); + + /* Save it in the user */ + user->mark = strdup(mark); + + /* If they are not otherwise marked, mark their host with fakehost */ + if(!IsFakeHost(user) && !IsSetHost(user) && !(IsHiddenHost(user) && user->handle_info) ) + { + struct modeNode *mn = NULL; + char fakehost[HOSTLEN]; + unsigned int count = 0; + unsigned int n = 0; + + putsock("%s " CMD_FAKEHOST " %s %s.%s", self->numeric, user->numeric, mark, host); + putsock("%s " CMD_MODE " %s +x", self->numeric, user->nick); + + snprintf(fakehost, sizeof(fakehost), "%s.%s", mark, host); + safestrncpy(user->fakehost, fakehost, sizeof(user->fakehost)); + + for (n=count=0; nchannels.used; n++) { + mn = user->channels.list[n]; + if (strlen(mn->channel->name) >= 1) /* Sanity */ + check_bans(user, mn->channel->name); + } + } +} + static void send_burst(void); static void @@ -898,6 +1264,7 @@ static CMD_FUNC(cmd_server) return 1; } + static CMD_FUNC(cmd_eob) { struct server *sender; @@ -914,11 +1281,22 @@ static CMD_FUNC(cmd_eob) unbursted_channels = NULL; irc_eob(); irc_eob_ack(); + + /* now that we know who our uplink is, + * we can center the routing map and activate auto-routing. + */ + //activate_routing(NULL, NULL, NULL); + routing_init(); } sender->self_burst = 0; recalc_bursts(sender); for (ii=0; iiuplink != self) + routing_handle_connect(sender->name, sender->uplink->name); return 1; } @@ -934,13 +1312,26 @@ static CMD_FUNC(cmd_eob_ack) return 1; } +static CMD_FUNC(cmd_rping) +{ + struct server *dest; + + if (!(dest = GetServerN(argv[1]))) + return 0; + + if (dest == self) + irc_rpong(argv[2], argv[3], argv[4], argv[5]); + + return 1; +} + static CMD_FUNC(cmd_ping) { struct server *srv; struct userNode *un; - if(argc > 3) - irc_pong(argv[2], argv[1]); + if (argc > 3) + irc_pong_asll(argv[2], argv[3]); else if ((srv = GetServerH(origin))) irc_pong(self->name, srv->numeric); else if ((un = GetUserH(origin))) @@ -1018,6 +1409,22 @@ static CMD_FUNC(cmd_join) return 1; } +static CMD_FUNC(cmd_svsjoin) +{ + struct create_desc cd; + + if (!(cd.user = GetUserH(argv[1]))) + return 0; + if (argc < 3) + return 0; + else if (argc < 4) + cd.when = now; + else + cd.when = atoi(argv[3]); + parse_foreach(argv[2], join_helper, create_helper, NULL, NULL, &cd); + return 1; +} + static CMD_FUNC(cmd_pong) { if (argc < 3) @@ -1041,6 +1448,7 @@ static CMD_FUNC(cmd_nick) NickChange(user, argv[1], 1); } else { struct server *serv; + struct userNode *nuser; char modes[MAXLEN]; /* new nick */ if (argc < 9) @@ -1050,7 +1458,7 @@ static CMD_FUNC(cmd_nick) unsplit_string(argv+6, argc-9, modes); else strcpy(modes, "+"); - AddUser(serv, argv[1], argv[4], argv[5], modes, argv[argc-2], argv[argc-1], atoi(argv[3]), argv[argc-3]); + nuser = AddUser(serv, argv[1], argv[4], argv[5], modes, argv[argc-2], argv[argc-1], atoi(argv[3]), argv[argc-3]); } return 1; } @@ -1068,6 +1476,9 @@ static CMD_FUNC(cmd_account) user = GetUserN(argv[1]); if (!user) return 1; /* A QUIT probably passed the ACCOUNT. */ + + if(!extended_accounts) /* any need for this function without? */ + return 1; if(!strcmp(argv[2],"C")) { @@ -1103,6 +1514,118 @@ static CMD_FUNC(cmd_fakehost) return 1; } +static struct { + char *name; + unsigned int priv; +} privtab[] = { +#define P(priv) { #priv, PRIV_ ## priv } + P(CHAN_LIMIT), P(MODE_LCHAN), P(WALK_LCHAN), P(DEOP_LCHAN), + P(SHOW_INVIS), P(SHOW_ALL_INVIS), P(UNLIMIT_QUERY), P(KILL), + P(LOCAL_KILL), P(REHASH), P(RESTART), P(DIE), + P(GLINE), P(LOCAL_GLINE), P(JUPE), P(LOCAL_JUPE), + P(OPMODE), P(LOCAL_OPMODE), P(SET), P(WHOX), + 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), +#undef P + { 0, 0 } +}; + +char *client_report_privs(struct userNode *client) +{ + int i; + + privbuf[0] = '\0'; + for (i = 0; privtab[i].name; i++) { + if (HasPriv(client, privtab[i].priv)) { + strcat(privbuf, privtab[i].name); + strcat(privbuf, " "); + } + } + + privbuf[strlen(privbuf)] = 0; + + return privbuf; +} + +int client_modify_priv_by_name(struct userNode *who, char *priv, int what) { + int i = 0; + assert(0 != priv); + assert(0 != who); + + for (i = 0; privtab[i].name; i++) { + if (0 == strcmp(privtab[i].name, priv)) { + if (what == PRIV_ADD) + GrantPriv(who, privtab[i].priv); + else if (what == PRIV_DEL) { + RevokePriv(who, privtab[i].priv); + } + } + } + return 0; +} + +int check_priv(char *priv) +{ + int i; + + for (i = 0; privtab[i].name; i++) { + if (0 == strcmp(privtab[i].name, priv)) { + return 1; + } + } + return 0; +} + +void +irc_privs(struct userNode *target, char *flag, int add) +{ + client_modify_priv_by_name(target, flag, add); + putsock("%s " P10_PRIVS " %s %s%s", self->numeric, target->numeric, (add == PRIV_ADD) ? "+" : "-", flag); +} + +static CMD_FUNC(cmd_privs) +{ + char *tstr = NULL; + int type = 0; + + tstr = conf_get_data("server/type", RECDB_QSTRING); + if(tstr) + type = atoi(tstr); + + if (type < 6) + return 1; /* silently ignore */ + + struct userNode *user = argc > 1 ? GetUserN(argv[1]) : NULL; + char buf[512] = ""; + int what = PRIV_ADD; + char *p = 0; + char *tmp; + unsigned int i; + + if (argc < 3) + return 0; + + if (!user) + return 0; + + for (i=1; i= 0) + oplevel += parse_oplevel(end); + else + oplevel = parse_oplevel(end); while (isdigit(*end)) end++; } else break; @@ -1218,13 +1750,47 @@ static CMD_FUNC(cmd_burst) res = 0; continue; } - if ((mNode = AddChannelUser(un, cNode))) + if ((mNode = AddChannelUser(un, cNode))) { mNode->modes = mode; + mNode->oplevel = oplevel; + } } return res; } +/* 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) +{ + struct userNode *target; + /* + * log_module(MAIN_LOG, LOG_ERROR, "DEBUG: mark, user %s, type %s, arg %s", argv[1], argv[2], argv[3]); + */ + + if(argc < 4) + return 0; + if(!strcasecmp(argv[2], "DNSBL")) { + /* DNSBL */ + return 1; + } + else if(!strcasecmp(argv[2], "DNSBL_DATA")) { + /* 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]); + return 0; + } + target->mark = strdup(argv[3]); + return 1; + + } + /* unknown type of mark */ + return 1; +} + static CMD_FUNC(cmd_mode) { struct chanNode *cn; @@ -1270,6 +1836,22 @@ static CMD_FUNC(cmd_mode) cn->timestamp = atoi(argv[argc-1]); } + if (checkDefCon(DEFCON_NO_MODE_CHANGE) && !IsOper(un)) { + const char *str; + str = conf_get_data("services/opserv/nick", RECDB_QSTRING); + if (str) { + char modes[MODELEN]; + struct userNode *opserv = GetUserH(str); + + send_message_type(4, un, opserv, "Channel modes cannot be changed due to DefCon level %d in effect, please try again soon", DefConLevel); + irc_make_chanmode(cn, modes); + irc_mode(opserv, cn, modes); + irc_mode(opserv, cn, DefConChanModes); + } + return 1; + } + + return mod_chanmode(un, cn, argv+2, argc-2, MCP_ALLOW_OVB|MCP_FROM_SERVER|(un ? MC_NOTIFY : 0)); } @@ -1327,6 +1909,7 @@ static CMD_FUNC(cmd_topic) { struct chanNode *cn; time_t chan_ts, topic_ts; + struct userNode *user; if (argc < 3) return 0; @@ -1334,15 +1917,23 @@ static CMD_FUNC(cmd_topic) log_module(MAIN_LOG, LOG_ERROR, "Unable to find channel %s whose topic is being set", argv[1]); return 0; } - if (argc >= 5) { - /* Looks like an Asuka style topic burst. */ + + + if (argc == 5) { /* Asuka / Topic Bursting IRCu's */ + user = GetUserH(origin); chan_ts = atoi(argv[2]); topic_ts = atoi(argv[3]); - } else { + } 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; } - SetChannelTopic(cn, GetUserH(origin), argv[argc-1], 0); + + SetChannelTopic(cn, user, user, argv[argc-1], 0); cn->topic_time = topic_ts; return 1; } @@ -1387,7 +1978,15 @@ static CMD_FUNC(cmd_num_gline) { if (argc < 6) return 0; - gline_add(origin, argv[3], atoi(argv[4])-now, argv[5], now, 0); + gline_add(origin, argv[3], atoi(argv[4])-now, argv[5], now, 0, 0); + return 1; +} + +static CMD_FUNC(cmd_num_shun) +{ + if (argc < 6) + return 0; + shun_add(origin, argv[3], atoi(argv[4])-now, argv[5], now, 0); return 1; } @@ -1442,6 +2041,62 @@ static CMD_FUNC(cmd_part) return 1; } +static CMD_FUNC(cmd_svspart) +{ + struct userNode *user; + + if (argc < 3) + return 0; + user = GetUserN(argv[1]); + if (!user) + return 0; + parse_foreach(argv[2], part_helper, NULL, NULL, NULL, user); + return 1; +} + +static CMD_FUNC(cmd_silence) +{ + struct userNode *user; + char *mask; + char *new_mask; + unsigned int i; + + if (argc < 2) + return 0; + + user = GetUserN(argv[1]); + + /* Sanity, go nuts if this happens */ + if (!user) + return 0; + + /* We can safely ignore this if a user adding a silence is not + * ignored. However this brings up a TODO. If a user logs in and + * they have silences on the IRCd then we need to set them here + * somehow + */ + if (!user->handle_info) + return 1; + + mask = argv[2]; + + if (*mask == '-') { + for (i=0; ihandle_info->ignores->used; i++) { + if (!irccasecmp(mask+1, user->handle_info->ignores->list[i])) + user->handle_info->ignores->list[i] = user->handle_info->ignores->list[--user->handle_info->ignores->used]; + } + } else { + for (i=0; ihandle_info->ignores->used; i++) { + if (!strcmp(mask+1, user->handle_info->ignores->list[i])) + return 1; /* Already on the users NickServ ignore list, safely ignore */ + } + + new_mask = strdup(mask+1); + string_list_append(user->handle_info->ignores, new_mask); + } + return 1; +} + static CMD_FUNC(cmd_kick) { if (argc < 3) @@ -1453,6 +2108,7 @@ static CMD_FUNC(cmd_kick) static CMD_FUNC(cmd_squit) { struct server *server; + char *uplink; if (argc < 4) return 0; @@ -1467,7 +2123,13 @@ static CMD_FUNC(cmd_squit) return 1; } + uplink = strdup(server->uplink->name); DelServer(server, 0, argv[3]); + /* if its a pingout and pingout connecting is enabled + or its a read error and readerror connecting is enabled + or were doing a "N" and i need to connect that server somewhere */ + routing_handle_squit(argv[1], uplink, argv[3]); + free(uplink); return 1; } @@ -1479,23 +2141,68 @@ static CMD_FUNC(cmd_privmsg) pd.user = GetUserH(origin); if (!pd.user || (IsGagged(pd.user) && !IsOper(pd.user))) return 1; + + if (checkDefCon(DEFCON_OPER_ONLY) && !IsOper(pd.user)) { + const char *str; + str = conf_get_data("services/opserv/nick", RECDB_QSTRING); + if (str) + send_message_type(4, pd.user, GetUserH(str), "Services are currently not available, please try again soon"); + return 1; + } + + if (checkDefCon(DEFCON_SILENT_OPER_ONLY) && !IsOper(pd.user)) + return 1; /* Silently Ignore */ + pd.is_notice = 0; pd.text = argv[2]; parse_foreach(argv[1], privmsg_chan_helper, NULL, privmsg_user_helper, privmsg_invalid, &pd); + return 1; } static CMD_FUNC(cmd_notice) { struct privmsg_desc pd; + struct server *srv; + int nuser = 0; + if (argc != 3) return 0; + pd.user = GetUserH(origin); - if (!pd.user || (IsGagged(pd.user) && !IsOper(pd.user))) - return 1; - pd.is_notice = 1; - pd.text = argv[2]; - parse_foreach(argv[1], privmsg_chan_helper, NULL, privmsg_user_helper, privmsg_invalid, &pd); + if(!pd.user) + nuser = 1; + if (!pd.user || (IsGagged(pd.user) && !IsOper(pd.user))) { + } + else { + pd.is_notice = 1; + pd.text = argv[2]; + parse_foreach(argv[1], privmsg_chan_helper, NULL, privmsg_user_helper, privmsg_invalid, &pd); + } + + srv = GetServerH(origin); + if(srv) { + char *sargv[MAXNUMPARAMS]; + int sargc; + + sargc = split_line(argv[2], true, MAXNUMPARAMS, sargv); + + if(!strcasecmp(sargv[0], "Connect:")) { + /* :Connect: Host shoe.loxxin.net not listed in ircd.conf */ + if(!strcasecmp(sargv[3], "not") && !strcasecmp(sargv[4], "listed")) { + routing_handle_connect_failure(srv, sargv[2], unsplit_string(sargv+3, sargc-3, NULL)); + } + } + else if(!strcasecmp(sargv[0], "Link")) { + /* :Link with mephisto.etheria.cx cancelled: Server mephisto.etheria.cx[216.46.33.71] + * + * :Link with laptop.afternet.org cancelled: Connection refused + */ + if(!strcasecmp(sargv[3], "cancelled:")) { + routing_handle_connect_failure(srv, sargv[2], unsplit_string(sargv+4, sargc-4, NULL)); + } + } + } return 1; } @@ -1520,7 +2227,7 @@ static CMD_FUNC(cmd_gline) if (argv[2][0] == '+') { if (argc < 5) return 0; - gline_add(origin, argv[2]+1, strtoul(argv[3], NULL, 0), argv[argc-1], now, 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); @@ -1529,6 +2236,22 @@ static CMD_FUNC(cmd_gline) return 0; } +static CMD_FUNC(cmd_shun) +{ + if (argc < 3) + return 0; + if (argv[2][0] == '+') { + if (argc < 5) + return 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; + } else + return 0; +} + static CMD_FUNC(cmd_svsnick) { struct userNode *target, *dest; @@ -1584,6 +2307,8 @@ init_parse(void) char numer[COMBO_NUMERIC_LEN+1]; /* read config items */ + str = conf_get_data("server/extended_accounts", RECDB_QSTRING); + extended_accounts = str ? enabled_string(str) : 1; str = conf_get_data("server/ping_freq", RECDB_QSTRING); ping_freq = str ? ParseInterval(str) : 120; str = conf_get_data("server/ping_timeout", RECDB_QSTRING); @@ -1630,6 +2355,8 @@ init_parse(void) dict_insert(irc_func_dict, TOK_EOB_ACK, cmd_eob_ack); dict_insert(irc_func_dict, CMD_MODE, cmd_mode); dict_insert(irc_func_dict, TOK_MODE, cmd_mode); + dict_insert(irc_func_dict, CMD_MARK, cmd_mark); + dict_insert(irc_func_dict, TOK_MARK, cmd_mark); dict_insert(irc_func_dict, CMD_NICK, cmd_nick); dict_insert(irc_func_dict, TOK_NICK, cmd_nick); dict_insert(irc_func_dict, CMD_ACCOUNT, cmd_account); @@ -1658,8 +2385,8 @@ init_parse(void) dict_insert(irc_func_dict, TOK_TOPIC, cmd_topic); dict_insert(irc_func_dict, CMD_AWAY, cmd_away); dict_insert(irc_func_dict, TOK_AWAY, cmd_away); - dict_insert(irc_func_dict, CMD_SILENCE, cmd_dummy); - dict_insert(irc_func_dict, TOK_SILENCE, cmd_dummy); + dict_insert(irc_func_dict, CMD_SILENCE, cmd_silence); + dict_insert(irc_func_dict, TOK_SILENCE, cmd_silence); dict_insert(irc_func_dict, CMD_KICK, cmd_kick); dict_insert(irc_func_dict, TOK_KICK, cmd_kick); dict_insert(irc_func_dict, CMD_SQUIT, cmd_squit); @@ -1670,12 +2397,20 @@ init_parse(void) dict_insert(irc_func_dict, TOK_NOTICE, cmd_notice); dict_insert(irc_func_dict, CMD_STATS, cmd_stats); dict_insert(irc_func_dict, TOK_STATS, cmd_stats); + dict_insert(irc_func_dict, CMD_SVSJOIN, cmd_svsjoin); + dict_insert(irc_func_dict, TOK_SVSJOIN, cmd_svsjoin); dict_insert(irc_func_dict, CMD_SVSNICK, cmd_svsnick); dict_insert(irc_func_dict, TOK_SVSNICK, cmd_svsnick); + dict_insert(irc_func_dict, CMD_SVSPART, cmd_svspart); + 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_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_SHUN, cmd_shun); + dict_insert(irc_func_dict, TOK_SHUN, cmd_shun); 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); @@ -1685,6 +2420,11 @@ init_parse(void) dict_insert(irc_func_dict, CMD_ADMIN, cmd_admin); dict_insert(irc_func_dict, TOK_ADMIN, cmd_admin); + 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); + /* In P10, DESTRUCT doesn't do anything except be broadcast to servers. * Apparently to obliterate channels from any servers that think they * exist? @@ -1712,14 +2452,21 @@ init_parse(void) dict_insert(irc_func_dict, TOK_WALLUSERS, cmd_dummy); /* Ignore dnsbl exemptions */ dict_insert(irc_func_dict, TOK_EXEMPT, cmd_dummy); - dict_insert(irc_func_dict, TOK_MARK, cmd_dummy); - /* Ignore privs */ - dict_insert(irc_func_dict, TOK_PRIVS, cmd_dummy); + dict_insert(irc_func_dict, CMD_PRIVS, cmd_privs); + dict_insert(irc_func_dict, TOK_PRIVS, cmd_privs); + /* ignore ALIST for now */ + dict_insert(irc_func_dict, TOK_ALIST, cmd_dummy); + dict_insert(irc_func_dict, CMD_ALIST, 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 /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); + /* handle topics */ dict_insert(irc_func_dict, "331", cmd_num_topic); dict_insert(irc_func_dict, "332", cmd_num_topic); @@ -1729,6 +2476,7 @@ init_parse(void) /* ban list resetting */ /* "stats g" responses */ 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" */ /* other numeric responses we might get */ dict_insert(irc_func_dict, "401", cmd_dummy); /* target left network */ @@ -1752,6 +2500,7 @@ init_parse(void) userList_init(&dead_users); reg_del_channel_func(remove_unbursted_channel); reg_exit_func(parse_cleanup); + // reg_notice_func(opserv, check_ctcp); } int @@ -1794,15 +2543,18 @@ static void parse_foreach(char *target_list, foreach_chanfunc cf, foreach_nonchan nc, foreach_userfunc uf, foreach_nonuser nu, void *data) { char *j, old; + do { j = target_list; while (*j != 0 && *j != ',') j++; old = *j; *j = 0; + if (IsChannelName(target_list) || (target_list[0] == '0' && target_list[1] == '\0')) { struct chanNode *chan = GetChannel(target_list); + if (chan) { if (cf) cf(chan, data); @@ -2022,6 +2774,8 @@ AddUser(struct server* uplink, const char *nick, const char *ident, const char * { struct userNode *oldUser, *uNode; unsigned int n, ignore_user; + 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); @@ -2068,7 +2822,22 @@ AddUser(struct server* uplink, const char *nick, const char *ident, const char * safestrncpy(uNode->info, userinfo, sizeof(uNode->info)); safestrncpy(uNode->hostname, hostname, sizeof(uNode->hostname)); safestrncpy(uNode->numeric, numeric, sizeof(uNode->numeric)); - uNode->ip.s_addr = htonl(base64toint(realip, 6)); + irc_p10_pton(&uNode->ip, realip); + + tstr = conf_get_data("server/type", RECDB_QSTRING); + type = atoi(tstr); + if (type > 6) { + 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; modeList_init(&uNode->channels); uNode->uplink = uplink; @@ -2078,6 +2847,9 @@ AddUser(struct server* uplink, const char *nick, const char *ident, const char * uNode->num_local = base64toint(numeric+strlen(uNode->uplink->numeric), 3) & uNode->uplink->num_mask; uNode->uplink->users[uNode->num_local] = uNode; mod_usermode(uNode, modes); + + set_geoip_info(uNode); + if (ignore_user) return uNode; @@ -2091,6 +2863,10 @@ AddUser(struct server* uplink, const char *nick, const char *ident, const char * for (n=0; nloc == 1) && (uNode->handle_info)) + send_func_list(uNode); + return uNode; } @@ -2136,6 +2912,25 @@ DelUser(struct userNode* user, struct userNode *killer, int announce, const char } modeList_clean(&user->channels); + + /* Clean up version data */ + if(user->version_reply) { + free(user->version_reply); + user->version_reply = NULL; + } + + /* clean up mark */ + if(user->mark) { + free(user->mark); + user->mark = NULL; + } + + /* clean up geoip data if any */ + if(user->country_code) free(user->country_code); + if(user->city) free(user->city); + if(user->region) free(user->region); + if(user->postal_code) free(user->postal_code); + /* 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. @@ -2154,6 +2949,9 @@ void mod_usermode(struct userNode *user, const char *mode_change) { if (!user || !mode_change) return; + + call_user_mode_funcs(user, mode_change); + while (*word != ' ' && *word) word++; while (*word == ' ') word++; while (1) { @@ -2189,6 +2987,30 @@ void mod_usermode(struct userNode *user, const char *mode_change) { // 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 '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; case 'h': do_user_mode(FLAGS_SETHOST); if (*word) { char sethost[MAXLEN]; @@ -2232,7 +3054,7 @@ void mod_usermode(struct userNode *user, const char *mode_change) { } struct mod_chanmode * -mod_chanmode_parse(struct chanNode *channel, char **modes, unsigned int argc, unsigned int flags) +mod_chanmode_parse(struct chanNode *channel, char **modes, unsigned int argc, unsigned int flags, short base_oplevel) { struct mod_chanmode *change; unsigned int ii, in_arg, ch_arg, add; @@ -2306,6 +3128,37 @@ mod_chanmode_parse(struct chanNode *channel, char **modes, unsigned int argc, un } } break; + 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)); + } else { + change->modes_clear |= MODE_UPASS; + if (!(flags & MCP_UPASS_FREE)) { + if (in_arg >= argc) + goto error; + in_arg++; + } + } + break; + case 'A': + if (add) { + if (in_arg >= argc) + 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)) { + if (in_arg >= argc) + goto error; + in_arg++; + } + } + break; case 'b': if (!(flags & MCP_ALLOW_OVB)) goto error; @@ -2329,6 +3182,29 @@ mod_chanmode_parse(struct chanNode *channel, char **modes, unsigned int argc, un case 'o': case 'h': case 'v': { struct userNode *victim; + char *oplevel_str; + int oplevel; + + if (in_arg >= argc) + goto error; + oplevel_str = strchr(modes[in_arg], ':'); + if (oplevel_str) + { + /* XXYYY M #channel +o XXYYY: */ + *oplevel_str++ = '\0'; + oplevel = parse_oplevel(oplevel_str); + if (oplevel <= base_oplevel && !(flags & MCP_FROM_SERVER)) + oplevel = base_oplevel + 1; + } + else if (channel->modes & MODE_UPASS) + oplevel = base_oplevel + 1; + else + oplevel = -1; + + /* Check that oplevel is within bounds. */ + if (oplevel > MAXOPLEVEL) + oplevel = MAXOPLEVEL; + if (!(flags & MCP_ALLOW_OVB)) goto error; if (in_arg >= argc) @@ -2350,7 +3226,11 @@ mod_chanmode_parse(struct chanNode *channel, char **modes, unsigned int argc, un if (!victim) continue; if ((change->args[ch_arg].u.member = GetUserMode(channel, victim))) + { + /* Apply the oplevel change */ + change->args[ch_arg].u.member->oplevel = oplevel; ch_arg++; + } break; } default: @@ -2451,6 +3331,10 @@ mod_chanmode_announce(struct userNode *who, struct chanNode *channel, struct mod #undef DO_MODE_CHAR if (change->modes_clear & channel->modes & MODE_KEY) mod_chanmode_append(&chbuf, 'k', channel->key); + if (change->modes_clear & channel->modes & MODE_UPASS) + mod_chanmode_append(&chbuf, 'U', channel->upass); + if (change->modes_clear * channel->modes & MODE_APASS) + mod_chanmode_append(&chbuf, 'A', channel->apass); } for (arg = 0; arg < change->argc; ++arg) { if (!(change->args[arg].mode & MODE_REMOVE)) @@ -2503,6 +3387,10 @@ mod_chanmode_announce(struct userNode *who, struct chanNode *channel, struct mod #undef DO_MODE_CHAR if(change->modes_set & MODE_KEY) mod_chanmode_append(&chbuf, 'k', change->new_key); + if (change->modes_set & MODE_UPASS) + mod_chanmode_append(&chbuf, 'U', change->new_upass); + if (change->modes_set & MODE_APASS) + mod_chanmode_append(&chbuf, 'A', change->new_apass); if(change->modes_set & MODE_LIMIT) { sprintf(int_buff, "%d", change->new_limit); mod_chanmode_append(&chbuf, 'l', int_buff); @@ -2556,6 +3444,8 @@ mod_chanmode_format(struct mod_chanmode *change, char *outbuff) DO_MODE_CHAR(NOPRIVMSGS, 'n'); DO_MODE_CHAR(LIMIT, 'l'); DO_MODE_CHAR(KEY, 'k'); + DO_MODE_CHAR(UPASS, 'U'); + DO_MODE_CHAR(APASS, 'A'); DO_MODE_CHAR(DELAYJOINS, 'D'); DO_MODE_CHAR(REGONLY, 'r'); DO_MODE_CHAR(NOCOLORS, 'c'); @@ -2594,10 +3484,51 @@ mod_chanmode_format(struct mod_chanmode *change, char *outbuff) DO_MODE_CHAR(SSLONLY, 'Z'); DO_MODE_CHAR(HIDEMODE, 'L'); #undef DO_MODE_CHAR - switch (change->modes_set & (MODE_KEY|MODE_LIMIT)) { + 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; + + 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; @@ -2630,6 +3561,14 @@ clear_chanmode(struct chanNode *channel, const char *modes) remove |= MODE_KEY; channel->key[0] = '\0'; break; + case 'A': + remove |= MODE_APASS; + channel->apass[0] = '\0'; + break; + case 'U': + remove |= MODE_UPASS; + channel->upass[0] = '\0'; + break; case 'l': remove |= MODE_LIMIT; channel->limit = 0; @@ -2806,3 +3745,16 @@ send_burst(void) for (it = dict_first(channels); it; it = iter_next(it)) dict_insert(unbursted_channels, iter_key(it), iter_data(it)); } + +/* + * Oplevel parsing + */ +static int +parse_oplevel(char *str) +{ + int oplevel = 0; + while (isdigit(*str)) + oplevel = oplevel * 10 + *str++ - '0'; + return oplevel; +} +