void setup_ov_mode(int on, int hide, int log)
{
#ifdef WANT_OPERVIEW
char *default_oper = "wsckf";
Window *win = NULL;
if (on)
{
if ((win = get_window_by_name("oper_view")))
{
if (win->log)
do_log(0, NULL, &win->log_fp);
delete_window(win);
update_all_windows();
set_input_prompt(current_window, get_string_var(INPUT_PROMPT_VAR), 0);
cursor_to_input();
}
send_to_server("MODE %s -%s%s", get_server_nickname(from_server), get_string_var(OPER_MODES_VAR)?get_string_var(OPER_MODES_VAR):default_oper, send_umode);
}
else
{
Window *tmp = NULL;
win = current_window;
if ((tmp = new_window(current_window->screen)))
{
malloc_strcpy(&tmp->name, "oper_view");
tmp->double_status = 0;
if (hide)
hide_window(tmp);
else
resize_window(1, tmp, -5);
tmp->window_level = LOG_WALLOP|LOG_OPNOTE|LOG_SNOTE;
tmp->absolute_size = 1;
tmp->skip = 1;
set_wset_string_var(tmp->wset, STATUS_FORMAT1_WSET, fget_string_var(FORMAT_OV_FSET));
build_status(tmp, NULL, 0);
update_all_windows();
set_input_prompt(current_window, get_string_var(INPUT_PROMPT_VAR), 0);
cursor_to_input();
send_to_server("MODE %s +%s", get_server_nickname(from_server), get_string_var(OPER_MODES_VAR)?get_string_var(OPER_MODES_VAR):default_oper);
set_screens_current_window(win->screen, win);
tmp->mangler = operlog_line_mangler;
if (log != -1)
{
tmp->log = log;
if (tmp->log)
do_log(log, "~/.BitchX/operview.log", &tmp->log_fp);
}
}
}
#endif
}
void got_initial_version_28 (char **ArgList)
{
char *server, *sversion, *user_modes, *channel_modes;
server = ArgList[0];
sversion = ArgList[1];
user_modes = ArgList[2];
channel_modes = ArgList[3];
if (sversion)
{
if (!strncmp(sversion, "2.8", 3))
{
if (strstr(sversion, "mu") || strstr(sversion, "me"))
set_server_version(from_server, Server_u2_8);
else if (strstr(sversion, "hybrid-6"))
set_server_version(from_server, Server2_8hybrid6);
else if (strstr(sversion, "hybrid"))
set_server_version(from_server, Server2_8hybrid);
else if (strstr(sversion, "comstud"))
set_server_version(from_server, Server2_8comstud);
else if (strstr(channel_modes, "che"))
set_server_version(from_server, Server2_8ts4);
else
set_server_version(from_server, Server2_8);
}
else if (!strncmp(sversion, "2.9", 3))
set_server_version(from_server, Server2_9);
else if (!strncmp(sversion, "2.10", 4))
set_server_version(from_server, Server2_10);
else if (!strncmp(sversion, "u2.9", 4))
set_server_version(from_server, Server_u2_9);
else if (!strncmp(sversion, "u2.10", 4))
set_server_version(from_server, Server_u2_10);
else if (!strncmp(sversion, "u3.0", 4))
set_server_version(from_server, Server_u3_0);
else
set_server_version(from_server, Server2_8);
} else
set_server_version(from_server, Server2_8);
set_server_version_string(from_server, sversion ? sversion : "2.8");
set_server_itsname(from_server, server);
reconnect_all_channels(from_server);
reset_display_target();
reinstate_user_modes();
if (use_nat_address == 1)
userhostbase(get_server_nickname(from_server), get_nat_address, 1, "%s", get_server_nickname(from_server));
update_all_status(current_window, NULL, 0);
do_hook(CONNECT_LIST, "%s %d %s", get_server_name(from_server), get_server_port(from_server), get_server_itsname(from_server));
}
void nap_firewall_start(int snum)
{
GetFile *gf;
unsigned char buffer[BIG_BUFFER_SIZE+1];
SocketList *s;
s = get_socket(snum);
if (!s || !(gf = (GetFile *)get_socketinfo(snum)))
{
close_socketread(snum);
return;
}
if (write(snum, "SEND", 4) == -1)
{
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
snprintf(buffer, BIG_BUFFER_SIZE, "%s \"%s\" %lu", get_server_nickname(from_server), gf->filename, gf->filesize);
convertnap_dos(buffer);
if (write(snum, buffer, strlen(buffer)) == -1)
{
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
s->func_read = nap_firewall_start1;
}
static void p_part(char *from, char **ArgList)
{
char *channel;
if (!from || !*from)
return;
channel = ArgList[0];
PasteArgs(ArgList, 1);
message_from(channel, LOG_CRAP);
in_on_who = 1;
if ((check_ignore(from, FromUserHost, channel, IGNORE_PARTS | IGNORE_CRAP, NULL) != IGNORED) &&
do_hook(LEAVE_LIST, "%s %s %s %s", from, channel, FromUserHost, ArgList[1] ? ArgList[1] : empty_str))
put_it("%s",
convert_output_format(get_format(FORMAT_LEAVE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from, FromUserHost,
channel, ArgList[1] ? ArgList[1] : empty_str));
if (!my_stricmp(from, get_server_nickname(from_server))) {
remove_channel(channel, from_server);
remove_from_mode_list(channel, from_server);
remove_from_join_list(channel, from_server);
set_input_prompt(curr_scr_win, get_string_var(INPUT_PROMPT_VAR), 0);
} else {
remove_from_channel(channel, from, from_server, 0, NULL);
}
update_all_status(curr_scr_win, NULL, 0);
update_input(UPDATE_ALL);
message_from(NULL, LOG_CRAP);
in_on_who = 0;
}
static void p_nick(char *from, char **ArgList)
{
int one_prints = 0, ign = 0, its_me = 0;
struct channel *chan;
char *line;
line = ArgList[0];
if (!my_stricmp(from, get_server_nickname(from_server))) {
accept_server_nickname(from_server, line);
its_me = 1;
user_changing_nickname = 0;
}
ign = check_ignore(from, FromUserHost, NULL, IGNORE_NICKS | IGNORE_CRAP, NULL);
for (chan = server_list[from_server].chan_list; chan; chan = chan->next) {
message_from(chan->channel, LOG_CRAP);
if (ign != IGNORED && do_hook(CHANNEL_NICK_LIST, "%s %s %s", chan->channel, from, line))
one_prints = 1;
}
if (one_prints) {
if (its_me) {
message_from(NULL, LOG_CRAP);
} else
message_from(what_channel(from, from_server), LOG_CRAP);
if (ign != IGNORED && do_hook(NICKNAME_LIST, "%s %s", from, line))
put_it("%s",
convert_output_format(get_format
(its_me ? FORMAT_NICKNAME_USER_FSET : im_on_channel(what_channel(from, from_server)) ?
FORMAT_NICKNAME_FSET : FORMAT_NICKNAME_OTHER_FSET), "%s %s %s %s", update_clock(GET_TIME),
from, "-", line));
}
rename_nick(from, line, from_server);
if (!its_me) {
char *user, *host;
user = m_strdup(FromUserHost);
host = strchr(user, '@');
*host++ = '\0';
notify_mark(from, user, host, 0);
notify_mark(line, user, host, 1);
new_free(&user);
}
}
void check_auto_invite(char *nick, char *userhost)
{
#ifdef WANT_USERLIST
ChannelList *chan = NULL;
UserList *tmp = NULL;
for (chan = get_server_channels(from_server); chan; chan = chan->next)
{
if ((tmp = lookup_userlevelc("*", userhost, chan->channel, NULL)))
{
NickList *n = NULL;
n = find_nicklist_in_channellist(nick, chan, 0);
if (!n && chan->have_op && get_cset_int_var(chan->csets, AINV_CSET) && (tmp->flags & ADD_INVITE) && get_cset_int_var(chan->csets, AINV_CSET))
{
bitchsay("Auto-inviting %s to %s", nick, chan->channel);
send_to_server("NOTICE %s :Auto-invite from %s", nick, get_server_nickname(from_server));
send_to_server("INVITE %s %s%s%s", nick, chan->channel, chan->key?space:empty_string, chan->key?chan->key:empty_string);
}
}
tmp = NULL;
}
#endif
}
static void p_invite(char *from, char **ArgList)
{
char *high;
switch (check_ignore(from, FromUserHost, ArgList[1] ? ArgList[1] : NULL, IGNORE_INVITES, NULL)) {
case IGNORED:
if (get_int_var(SEND_IGNORE_MSG_VAR))
send_to_server(SERVER(from_server), "NOTICE %s :%s is ignoring you", from, get_server_nickname(from_server));
return;
case HIGHLIGHTED:
high = highlight_char;
break;
default:
high = empty_str;
break;
}
if (ArgList[0] && ArgList[1]) {
struct channel *chan = NULL;
struct whowas_chan_list *w_chan = NULL;
message_from(from, LOG_CRAP);
malloc_strcpy(&invite_channel, ArgList[1]);
if (check_flooding(from, INVITE_FLOOD, ArgList[1], NULL) && do_hook(INVITE_LIST, "%s %s", from, ArgList[1])) {
put_it("%s", convert_output_format(get_format(FORMAT_INVITE_FSET), "%s %s %s", update_clock(GET_TIME), from, ArgList[1]));
}
if (!(chan = lookup_channel(invite_channel, from_server, 0)))
if ((w_chan = check_whowas_chan_buffer(invite_channel, 0)))
chan = w_chan->channellist;
if (chan && get_int_var(AUTO_REJOIN_VAR) && invite_channel) {
if (!in_join_list(invite_channel, from_server))
send_to_server(SERVER(from_server), "JOIN %s %s", invite_channel, ArgList[2] ? ArgList[2] : "");
}
malloc_strcpy(&recv_nick, from);
}
}
int BX_flood_prot (char *nick, char *userhost, char *type, int ctcp_type, int ignoretime, char *channel)
{
ChannelList *chan;
NickList *Nick;
char tmp[BIG_BUFFER_SIZE+1];
char *uh;
int old_window_display;
int kick_on_flood = 1;
if ((ctcp_type == CDCC_FLOOD || ctcp_type == CTCP_FLOOD || ctcp_type == CTCP_ACTION_FLOOD) && !get_int_var(CTCP_FLOOD_PROTECTION_VAR))
return 0;
else if (!get_int_var(FLOOD_PROTECTION_VAR))
return 0;
else if (!my_stricmp(nick, get_server_nickname(from_server)))
return 0;
switch (ctcp_type)
{
case WALL_FLOOD:
case MSG_FLOOD:
break;
case NOTICE_FLOOD:
break;
case PUBLIC_FLOOD:
if (channel)
{
if ((chan = lookup_channel(channel, from_server, 0)))
{
kick_on_flood = get_cset_int_var(chan->csets, PUBFLOOD_CSET);
if (kick_on_flood && (Nick = find_nicklist_in_channellist(nick, chan, 0)))
{
if (chan->have_op && (!Nick->userlist || (Nick->userlist && !(Nick->userlist->flags & ADD_FLOOD))))
if (!nick_isop(Nick) || get_cset_int_var(chan->csets, KICK_OPS_CSET))
send_to_server("KICK %s %s :\002%s\002 flooder", chan->channel, nick, type);
}
}
}
break;
case CTCP_FLOOD:
case CTCP_ACTION_FLOOD:
check_ctcp_ban_flood(channel, nick);
default:
if (get_int_var(FLOOD_KICK_VAR) && kick_on_flood && channel)
{
for (chan = get_server_channels(from_server); chan; chan = chan->next)
{
if (chan->have_op && (Nick = find_nicklist_in_channellist(nick, chan, 0)))
{
if ((!Nick->userlist || (Nick->userlist && !(Nick->userlist->flags & ADD_FLOOD))))
if (!nick_isop(Nick) || get_cset_int_var(chan->csets, KICK_OPS_CSET))
send_to_server("KICK %s %s :\002%s\002 flooder", chan->channel, nick, type);
}
}
}
}
if (!ignoretime)
return 0;
uh = clear_server_flags(userhost);
sprintf(tmp, "*!*%s", uh);
old_window_display = window_display;
window_display = 0;
ignore_nickname(tmp, ignore_type(type, strlen(type)), 0);
window_display = old_window_display;
sprintf(tmp, "%d ^IGNORE *!*%s NONE", ignoretime, uh);
timercmd("TIMER", tmp, NULL, NULL);
bitchsay("Auto-ignoring %s for %d minutes [\002%s\002 flood]", nick, ignoretime/60, type);
return 1;
}
void userhost_ban(UserhostItem *stuff, char *nick1, char *args)
{
char *temp;
char *str= NULL;
char *channel;
ChannelList *c = NULL;
NickList *n = NULL;
char *ob = "-o+b";
char *b = "+b";
char *host = NULL, *nick = NULL, *user = NULL, *chan = NULL;
WhowasList *whowas = NULL;
int f**k = 0;
int set_ignore = 0;
channel = next_arg(args, &args);
temp = next_arg(args, &args);
f**k = !my_stricmp("F**K", args);
set_ignore = !my_stricmp("BKI", args);
if (!stuff || !stuff->nick || !nick1 || !strcmp(stuff->user, "<UNKNOWN>") || my_stricmp(stuff->nick, nick1))
{
if (nick1 && channel && (whowas = check_whowas_nick_buffer(nick1, channel, 0)))
{
nick = whowas->nicklist->nick;
user = m_strdup(clear_server_flags(whowas->nicklist->host));
host = strchr(user, '@');
*host++ = 0;
bitchsay("Using WhoWas info for ban of %s ", nick1);
n = whowas->nicklist;
}
else if (nick1)
{
bitchsay("No match for the %s of %s on %s", f**k ? "F**k":"Ban", nick1, channel);
return;
}
}
else
{
nick = stuff->nick;
user = m_strdup(clear_server_flags(stuff->user));
host = stuff->host;
}
if (!(my_stricmp(nick, get_server_nickname(from_server))))
{
bitchsay("Try to kick yourself again!!");
new_free(&user);
return;
}
if (is_on_channel(channel, from_server, nick))
chan = channel;
c = lookup_channel(channel, from_server, 0);
if (c && !n)
n = find_nicklist_in_channellist(nick, c, 0);
send_to_server("MODE %s %s %s %s", channel, chan ? ob : b, chan?nick:empty_string, ban_it(nick, user, host, (n && n->ip)?n->ip:NULL));
if (f**k)
{
malloc_sprintf(&str, "%s!*%s@%s %s 3 Auto-Shit", nick, user, host, channel);
#ifdef WANT_USERLIST
add_shit(NULL, str, NULL, NULL);
#endif
new_free(&str);
} else if (set_ignore)
ignore_nickname(ban_it("*", user, host, NULL) , IGNORE_ALL, 0);
new_free(&user);
}
static void p_kick(char *from, char **ArgList)
{
char *channel, *who, *comment;
char *chankey = NULL;
struct channel *chan = NULL;
struct nick_list *tmpnick = NULL;
int t = 0;
channel = ArgList[0];
who = ArgList[1];
comment = ArgList[2] ? ArgList[2] : "(no comment)";
if ((chan = lookup_channel(channel, from_server, CHAN_NOUNLINK)))
tmpnick = find_nicklist_in_channellist(from, chan, 0);
message_from(channel, LOG_CRAP);
if (channel && who && chan) {
if (!my_stricmp(who, get_server_nickname(from_server))) {
Window *window = chan->window;
if (chan->key)
malloc_strcpy(&chankey, chan->key);
if (get_int_var(AUTO_REJOIN_VAR)) {
send_to_server(SERVER(from_server), "JOIN %s %s", channel, chankey ? chankey : empty_str);
add_to_join_list(channel, from_server, window ? window->refnum : 0);
}
new_free(&chankey);
remove_channel(channel, from_server);
update_all_status(curr_scr_win, NULL, 0);
update_input(UPDATE_ALL);
if (do_hook(KICK_LIST, "%s %s %s %s", who, from, channel, comment ? comment : empty_str))
put_it("%s",
convert_output_format(get_format(FORMAT_KICK_USER_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
channel, who, comment));
} else {
int itsme = 0;
itsme = !my_stricmp(get_server_nickname(from_server), from) ? 1 : 0;
if ((check_ignore(from, FromUserHost, channel, IGNORE_KICKS | IGNORE_CRAP, NULL) != IGNORED) &&
do_hook(KICK_LIST, "%s %s %s %s", who, from, channel, comment))
put_it("%s",
convert_output_format(get_format(FORMAT_KICK_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from, channel,
who, comment));
if (!itsme) {
struct nick_list *f_nick = NULL;
f_nick = find_nicklist_in_channellist(who, chan, 0);
if (chan->chop && tmpnick && is_other_flood(chan, tmpnick, KICK_FLOOD, &t)) {
if (get_int_var(KICK_ON_KICKFLOOD_VAR) > get_int_var(DEOP_ON_KICKFLOOD_VAR))
send_to_server(SERVER(from_server), "MODE %s -o %s", chan->channel, from);
else if (!f_nick->kickcount++)
send_to_server(SERVER(from_server), "KICK %s %s :\002Mass kick detected - (%d kicks in %dsec%s)\002",
chan->channel, from, get_int_var(KICK_ON_KICKFLOOD_VAR), t, plural(t));
}
}
remove_from_channel(channel, who, from_server, 0, NULL);
}
}
update_all_status(curr_scr_win, NULL, 0);
message_from(NULL, LOG_CRAP);
}
static void p_mode(char *from, char **ArgList)
{
char *channel;
char *line;
int flag;
struct channel *chan = NULL;
char buffer[BIG_BUFFER_SIZE + 1];
char *smode;
#ifdef COMPRESS_MODES
char *tmpbuf = NULL;
#endif
PasteArgs(ArgList, 1);
channel = ArgList[0];
line = ArgList[1];
smode = strchr(from, '.');
flag = check_ignore(from, FromUserHost, channel, (smode ? IGNORE_SMODES : IGNORE_MODES) | IGNORE_CRAP, NULL);
message_from(channel, LOG_CRAP);
if (channel && line) {
strcpy(buffer, line);
if (get_int_var(MODE_STRIPPER_VAR))
strip_modes(from, channel, line);
if (is_channel(channel)) {
#ifdef COMPRESS_MODES
chan = (struct channel *) find_in_list((struct list **) &server_list[from_server].chan_list, channel, 0);
if (get_int_var(COMPRESS_MODES_VAR)) {
tmpbuf = compress_modes(from_server, channel, line);
if (tmpbuf)
strcpy(line, tmpbuf);
else
goto end_p_mode;
}
#endif
/* CDE handle mode protection here instead of later */
update_channel_mode(from, channel, from_server, buffer, chan);
if (flag != IGNORED && do_hook(MODE_LIST, "%s %s %s", from, channel, line))
put_it("%s",
convert_output_format(get_format(smode ? FORMAT_SMODE_FSET : FORMAT_MODE_FSET), "%s %s %s %s %s",
update_clock(GET_TIME), from, smode ? "*" : FromUserHost, channel, line));
} else {
if (flag != IGNORED && do_hook(MODE_LIST, "%s %s %s", from, channel, line)) {
if (!my_stricmp(from, channel)) {
if (!my_stricmp(from, get_server_nickname(from_server)))
put_it("%s",
convert_output_format(get_format(FORMAT_USERMODE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
"*", channel, line));
else
put_it("%s",
convert_output_format(get_format(FORMAT_USERMODE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
smode ? "*" : FromUserHost, channel, line));
} else
put_it("%s",
convert_output_format(get_format(FORMAT_MODE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
smode ? "*" : FromUserHost, channel, line));
}
update_user_mode(line);
}
#ifdef COMPRESS_MODES
end_p_mode:
#endif
update_all_status(curr_scr_win, NULL, 0);
}
message_from(NULL, LOG_CRAP);
}
static void p_channel(char *from, char **ArgList)
{
char *channel;
char *user, *host;
struct channel *chan = NULL;
struct whowas_list *whowas = NULL;
int its_me = 0;
if (!strcmp(ArgList[0], "0")) {
fake();
return;
}
channel = ArgList[0];
message_from(channel, LOG_CRAP);
malloc_strcpy(&joined_nick, from);
if (!my_stricmp(from, get_server_nickname(from_server))) {
int refnum;
Window *old_window = curr_scr_win;
int switched = 0;
if (!in_join_list(channel, from_server))
add_to_join_list(channel, from_server, curr_scr_win->refnum);
else {
if (curr_scr_win->refnum != (refnum = get_win_from_join_list(channel, from_server))) {
switched = 1;
set_current_window(get_window_by_refnum(refnum));
}
}
if (*channel != '+')
send_to_server(SERVER(from_server), "MODE %s\r\nMODE %s b", channel, channel, channel);
(void) do_hook(JOIN_ME_LIST, "%s", channel);
its_me = 1;
chan = add_channel(channel, from_server);
if (*channel == '+') {
got_info(channel, from_server, GOTBANS);
got_info(channel, from_server, GOTMODE);
}
if (switched)
set_current_window(old_window);
} else {
int op = 0, vo = 0;
char *c;
/*
* Workaround for gratuitous protocol change in ef2.9
*/
if ((c = strchr(channel, '\007'))) {
for (*c++ = 0; *c; c++) {
if (*c == 'o')
op = 1;
else if (*c == 'v')
vo = 1;
}
}
chan = add_to_channel(channel, from, from_server, op, vo, FromUserHost, NULL, NULL);
}
flush_mode_all(chan);
user = m_strdup(FromUserHost);
host = strchr(user, '@');
*host++ = '\0';
if (check_ignore(from, FromUserHost, channel, IGNORE_JOINS | IGNORE_CRAP, NULL) != IGNORED && chan) {
irc_server *irc_serv = NULL;
char *tmp2 = NULL;
if (get_int_var(AUTO_NSLOOKUP_VAR) && isdigit(*(host + strlen(host) - 1)))
tmp2 = do_nslookup(host);
message_from(channel, LOG_CRAP);
if ((whowas = check_whosplitin_buffer(from, FromUserHost, channel, 0)) && (irc_serv = check_split_server(whowas->server1))) {
if (do_hook(LLOOK_JOIN_LIST, "%s %s", irc_serv->name, irc_serv->link))
put_it("%s",
convert_output_format(get_format(FORMAT_NETJOIN_FSET), "%s %s %s %d", update_clock(GET_TIME), irc_serv->name,
irc_serv->link, 0));
remove_split_server(whowas->server1);
}
if (do_hook(JOIN_LIST, "%s %s %s", from, channel, tmp2 ? tmp2 : FromUserHost ? FromUserHost : "UnKnown")) {
put_it("%s",
convert_output_format(get_format(FORMAT_JOIN_FSET), "%s %s %s %s", update_clock(GET_TIME), from,
tmp2 ? tmp2 : FromUserHost ? FromUserHost : "UnKnown", channel));
}
message_from(NULL, LOG_CRAP);
}
set_input_prompt(curr_scr_win, get_string_var(INPUT_PROMPT_VAR), 0);
update_all_status(curr_scr_win, NULL, 0);
notify_mark(from, user, host, 1);
new_free(&user);
}
static void p_privmsg(char *from, char **Args)
{
int level, list_type, flood_type, log_type, no_flood = 1, do_beep = 1;
unsigned char ignore_type;
char *ptr = NULL, *to;
char *high;
struct channel *channel = NULL;
struct nick_list *tmpnick = NULL;
if (!from)
return;
PasteArgs(Args, 1);
to = Args[0];
ptr = Args[1];
if (!to || !ptr) {
fake();
return;
}
doing_privmsg = 1;
if (is_channel(to) && im_on_channel(to)) {
message_from(to, LOG_MSG);
malloc_strcpy(&public_nick, from);
log_type = LOG_PUBLIC;
ignore_type = IGNORE_PUBLIC;
flood_type = PUBLIC_FLOOD;
if (!is_on_channel(to, from_server, from))
list_type = PUBLIC_MSG_LIST;
else {
if (is_current_channel(to, from_server, 0))
list_type = PUBLIC_LIST;
else
list_type = PUBLIC_OTHER_LIST;
channel = lookup_channel(to, from_server, CHAN_NOUNLINK);
if (channel)
tmpnick = find_nicklist_in_channellist(from, channel, 0);
}
} else {
message_from(from, LOG_MSG);
flood_type = MSG_FLOOD;
if (my_stricmp(to, get_server_nickname(from_server))) {
log_type = LOG_WALL;
ignore_type = IGNORE_WALLS;
list_type = MSG_GROUP_LIST;
} else {
log_type = LOG_MSG;
ignore_type = IGNORE_MSGS;
list_type = MSG_LIST;
}
}
switch (check_ignore(from, FromUserHost, to, ignore_type, ptr)) {
case IGNORED:
if ((list_type == MSG_LIST) && get_int_var(SEND_IGNORE_MSG_VAR))
send_to_server(SERVER(from_server), "NOTICE %s :%s is ignoring you", from, get_server_nickname(from_server));
doing_privmsg = 0;
return;
case HIGHLIGHTED:
high = highlight_char;
break;
case CHANNEL_GREP:
high = highlight_char;
break;
default:
high = empty_str;
break;
}
ptr = do_ctcp(from, to, ptr);
if (!ptr || !*ptr) {
doing_privmsg = 0;
return;
}
level = set_lastlog_msg_level(log_type);
if (flood_type == PUBLIC_FLOOD) {
int blah = 0;
if (is_other_flood(channel, tmpnick, PUBLIC_FLOOD, &blah)) {
no_flood = 0;
flood_prot(tmpnick->nick, FromUserHost, "PUBLIC", flood_type, get_int_var(PUBFLOOD_TIME_VAR), channel->channel);
}
} else
no_flood = check_flooding(from, flood_type, ptr, NULL);
{
switch (list_type) {
case PUBLIC_MSG_LIST:
logmsg(LOG_PUBLIC, from, ptr, 0);
if (no_flood && do_hook(list_type, "%s %s %s", from, to, ptr))
put_it("%s",
convert_output_format(get_format(FORMAT_PUBLIC_MSG_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
FromUserHost, to, get_int_var(MIRCS_VAR) ? mircansi(ptr) : ptr));
break;
case MSG_GROUP_LIST:
logmsg(LOG_PUBLIC, from, ptr, 0);
if (no_flood && do_hook(list_type, "%s %s %s", from, to, ptr))
put_it("%s",
convert_output_format(get_format(FORMAT_MSG_GROUP_FSET), "%s %s %s %s", update_clock(GET_TIME), from, to,
get_int_var(MIRCS_VAR) ? mircansi(ptr) : ptr));
break;
case MSG_LIST:
{
if (!no_flood)
break;
malloc_strcpy(&recv_nick, from);
if (away_set) {
do_beep = 0;
beep_em(get_int_var(BEEP_WHEN_AWAY_VAR));
set_int_var(MSGCOUNT_VAR, get_int_var(MSGCOUNT_VAR) + 1);
}
logmsg(LOG_MSG, from, ptr, 0);
addtabkey(from, "msg");
if (do_hook(list_type, "%s %s", from, ptr))
put_it("%s",
convert_output_format(get_format(FORMAT_MSG_FSET), "%s %s %s %s", update_clock(GET_TIME), from,
FromUserHost, get_int_var(MIRCS_VAR) ? mircansi(ptr) : ptr));
if (from_server > -1 && get_server_away(from_server) && get_int_var(SEND_AWAY_MSG_VAR)) {
send_to_server(SERVER(from_server), "NOTICE %s :%s", from,
stripansicodes(convert_output_format
(get_format(FORMAT_SEND_AWAY_FSET), "%l %l %s", time(NULL),
server_list[from_server].awaytime, get_int_var(MSGLOG_VAR) ? "On" : "Off")));
}
break;
}
case PUBLIC_LIST:{
logmsg(LOG_PUBLIC, from, ptr, 0);
if (no_flood && do_hook(list_type, "%s %s %s", from, to, ptr))
put_it("%s",
convert_output_format(get_format(FORMAT_PUBLIC_FSET), "%s %s %s %s", update_clock(GET_TIME), from, to,
get_int_var(MIRCS_VAR) ? mircansi(ptr) : ptr));
break;
}
case PUBLIC_OTHER_LIST:{
logmsg(LOG_PUBLIC, from, ptr, 0);
if (no_flood && do_hook(list_type, "%s %s %s", from, to, ptr))
put_it("%s",
convert_output_format(get_format(FORMAT_PUBLIC_OTHER_FSET), "%s %s %s %s", update_clock(GET_TIME), from, to,
get_int_var(MIRCS_VAR) ? mircansi(ptr) : ptr));
break;
} /* case */
} /* switch */
}
if (beep_on_level & log_type && do_beep)
beep_em(1);
set_lastlog_msg_level(level);
message_from(NULL, LOG_CRAP);
doing_privmsg = 0;
}
void check_hack(char *nick, ChannelList *channel, NickList *ThisNick, char *from)
{
#ifdef WANT_USERLIST
UserList *userptr = NULL;
ShitList *shitptr = NULL;
#endif
WhowasList *check_op = NULL;
int flag;
if (from && *from && !strchr(from, '.'))
return;
if (!channel || !are_you_opped(channel->channel) || !nick || !ThisNick || wild_match(nick, get_server_nickname(from_server)))
return;
if (!(flag = get_cset_int_var(channel->csets, HACKING_CSET)))
return;
if ((ThisNick->sent_deop) && (now - ThisNick->sent_deop_time < 10))
return;
#ifdef WANT_USERLIST
userptr = ThisNick->userlist;
shitptr = ThisNick->shitlist;
#endif
check_op = check_whosplitin_buffer(nick, ThisNick->host, channel->channel, 0);
if (check_op && check_op->has_ops)
return;
#ifdef WANT_USERLIST
if ( !userptr || (userptr && !check_channel_match(userptr->channels, channel->channel)) ||
(shitptr && check_channel_match(shitptr->channels, channel->channel)))
#endif
{
switch(flag)
{
case 1:
case 3:
if (is_chanop(channel->channel, nick))
add_mode(channel, "o", 0, nick, NULL, get_int_var(NUM_OPMODES_VAR));
ThisNick->sent_deop++;
ThisNick->sent_deop_time = now;
case 2:
if (flag != 1)
bitchsay("NetHack detected on %s by %s!%s", channel->channel, nick, ThisNick->host);
case 0:
default:
break;
}
}
}
void reinstate_user_modes (void)
{
char *modes = get_umode(from_server);
if (modes && *modes)
send_to_server("MODE %s +%s", get_server_nickname(from_server), modes);
}
