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)
{
}
} 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);
}
}
putsock("%s " P10_WALLOPS " :%s", self->numeric, buffer);
}
+
void
irc_notice(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)
{
}
}
+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
irc_ping(const char *payload)
{
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)) {
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)
{
host_in_topic = atoi(hstr);
}
- if (type == 5) {
+ 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);
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; n<user->channels.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
/* now that we know who our uplink is,
* we can center the routing map and activate auto-routing.
*/
- activate_routing(NULL, NULL, NULL);
+ //activate_routing(NULL, NULL, NULL);
+ routing_init();
}
sender->self_burst = 0;
recalc_bursts(sender);
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;
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;
+ 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;
+ }
+ if(!strcasecmp(argv[2], "DNSBL")) {
+ /* DNSBL <modes> */
+ return 1;
+ }
+ else if(!strcasecmp(argv[2], "DNSBL_DATA")) {
+ /* DNSBL_DATA name */
+ target->mark = strdup(argv[3]);
+ return 1;
+
+ }
+ /* unknown type of mark */
+ return 1;
+}
+
static CMD_FUNC(cmd_mode)
{
struct chanNode *cn;
if (argc < 3)
return 0;
- user = GetUserH(argv[1]);
+ user = GetUserN(argv[1]);
if (!user)
return 0;
parse_foreach(argv[2], part_helper, NULL, NULL, NULL, user);
pd.is_notice = 0;
pd.text = argv[2];
parse_foreach(argv[1], privmsg_chan_helper, NULL, privmsg_user_helper, privmsg_invalid, &pd);
+
return 1;
}
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);
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?
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);
dict_insert(irc_func_dict, CMD_PRIVS, cmd_privs);
dict_insert(irc_func_dict, TOK_PRIVS, cmd_privs);
/* Ignore remote luser */
userList_init(&dead_users);
reg_del_channel_func(remove_unbursted_channel);
reg_exit_func(parse_cleanup);
+ // reg_notice_func(opserv, check_ctcp);
}
int
}
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.
projects / irc / evilnet / x3.git / blobdiff