/*

* parse.c: handles messages from the server. Believe it or not. I

* certainly wouldn't if I were you.

*

* Written By Michael Sandrof

*

* Copyright(c) 1990

* Modified Colten Edwards 1997

*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "irc.h"

#include "server.h"

#include "names.h"

#include "vars.h"

#include "ctcp.h"

#include "hook.h"

#include "commands.h"

#include "ignore.h"

#include "whois.h"

#include "lastlog.h"

#include "input.h"

#include "notice.h"

#include "ircaux.h"

#include "funny.h"

#include "input.h"

#include "ircterm.h"

#include "flood.h"

#include "window.h"

#include "screen.h"

#include "output.h"

#include "numbers.h"

#include "parse.h"

#include "notify.h"

#include "status.h"

#include "list.h"

#include "misc.h"

#include "whowas.h"

#include "timer.h"

#include "hash.h"

#include "fset.h"

#include "tcommand.h"

#define space ' '

static void strip_modes(char *, char *, char *);

extern char *do_nslookup(char *);

extern char *random_str(int, int);

char *last_split_server = NULL;

int in_server_ping = 0;

extern char *mircansi(char *);

#ifdef COMPRESS_MODES

extern char *compress_modes(int, char *, char *);

#endif

/* TODO: this needs to be someplace better */

/* in cmd_orignick.c */

void check_orig_nick(char *nick);

/*

* joined_nick: the nickname of the last person who joined the current

* channel

*/

char *joined_nick = NULL;

/* public_nick: nick of the last person to send a message to your channel */

char *public_nick = NULL;

/* User and host information from server 2.7 */

char *FromUserHost = empty_str;

/* doing a PRIVMSG */

int doing_privmsg = 0;

int chan_who = 0;

/* returns 1 if the ban is on the channel already, 0 if not */

BanList *ban_is_on_channel(char *ban, struct channel *chan)

{

register BanList *bans;

for (bans = chan->bans; bans; bans = bans->next) {

if (match(bans->ban, ban) || match(ban, bans->ban))

return bans;

else if (!my_stricmp(bans->ban, ban))

return bans;

}

return NULL;

}

void fake(void)

{

bitchsay("--- Fake Message recieved!!! ---");

return;

}

char *PasteArgs(char **Args, int StartPoint)

{

int i;

for (; StartPoint; Args++, StartPoint--)

if (!*Args)

return NULL;

for (i = 0; Args[i] && Args[i + 1]; i++)

Args[i][strlen(Args[i])] = ' ';

Args[1] = NULL;

return Args[0];

}

/*

* BreakArgs: breaks up the line from the server, in to where its from,

* setting FromUserHost if it should be, and returns all the arguements

* that are there. Re-written by phone, dec 1992.

*/

int BreakArgs(char *Input, char **Sender, char **OutPut, int ig_sender)

{

int ArgCount = 0;

/*

* The RFC describes it fully, but in a short form, a line looks like:

* [:sender[!user@host]] COMMAND ARGUMENT [[:]ARGUMENT]{0..14}

*/

/*

* Look to see if the optional :sender is present.

*/

if (!ig_sender) {

if (*Input == ':') {

*Sender = ++Input;

while (*Input && *Input != space)

Input++;

if (*Input == space)

*Input++ = 0;

/*

* Look to see if the optional !user@host is present.

*/

FromUserHost = *Sender;

while (*FromUserHost && *FromUserHost != '!')

FromUserHost++;

if (*FromUserHost == '!')

*FromUserHost++ = 0;

}

/*

* No sender present.

*/

else

*Sender = FromUserHost = empty_str;

}

/*

* Now we go through the argument list...

*/

for (;;) {

while (*Input && *Input == space)

Input++;

if (!*Input)

break;

if (*Input == ':') {

OutPut[ArgCount++] = ++Input;

break;

}

OutPut[ArgCount++] = Input;

if (ArgCount >= MAXPARA)

break;

while (*Input && *Input != space)

Input++;

if (*Input == space)

*Input++ = 0;

}

OutPut[ArgCount] = NULL;

return ArgCount;

}

/* in response to a TOPIC message from the server */

static void p_topic(char *from, char **ArgList)

{

struct channel *tmp;

if (!ArgList[1]) {

fake();

return;

}

tmp = lookup_channel(ArgList[0], from_server, CHAN_NOUNLINK);

malloc_strcpy(&tmp->topic, ArgList[1]);

if (check_ignore(from, FromUserHost, tmp->channel, IGNORE_TOPICS | IGNORE_CRAP, NULL) != IGNORED) {

message_from(ArgList[0], LOG_CRAP);

if (do_hook(TOPIC_LIST, "%s %s %s", from, ArgList[0], ArgList[1])) {

if (ArgList[1] && *ArgList[1]) {

if (get_format(FORMAT_TOPIC_CHANGE_HEADER_FSET))

put_it("%s",

convert_output_format(get_format(FORMAT_TOPIC_CHANGE_HEADER_FSET), "%s %s %s %s", update_clock(GET_TIME),

from, ArgList[0], ArgList[1]));

put_it("%s",

convert_output_format(get_format(FORMAT_TOPIC_CHANGE_FSET), "%s %s %s %s", update_clock(GET_TIME), from,

ArgList[0], ArgList[1]));

} else

put_it("%s",

convert_output_format(get_format(FORMAT_TOPIC_UNSET_FSET), "%s %s %s", update_clock(GET_TIME), from,

ArgList[0]));

}

message_from(NULL, LOG_CRAP);

}

update_all_status(curr_scr_win, NULL, 0);

}

static void p_wallops(char *from, char **ArgList)

{

char *line;

int from_server = strchr(from, '.') ? 1 : 0;

if (!(line = PasteArgs(ArgList, 0))) {

fake();

return;

}

if (from_server || check_flooding(from, WALLOP_FLOOD, line, NULL)) {

/* The old server check, don't use the whois stuff for servers */

int level;

char *high;

switch (check_ignore(from, FromUserHost, NULL, IGNORE_WALLOPS, NULL)) {

case (IGNORED):

return;

case (HIGHLIGHTED):

high = highlight_char;

break;

default:

high = empty_str;

break;

}

message_from(from, LOG_WALLOP);

level = set_lastlog_msg_level(LOG_WALLOP);

if (do_hook(WALLOP_LIST, "%s %c %s", from, from_server ? 'S' : '*', line))

put_it("%s", convert_output_format(get_format(from_server ? FORMAT_WALLOP_FSET : FORMAT_WALL_FSET),

"%s %s %s %s", update_clock(GET_TIME), from, from_server ? "!" : "*", line));

if (beep_on_level & LOG_WALLOP)

beep_em(1);

set_lastlog_msg_level(level);

message_from(NULL, LOG_CRAP);

}

}

void whoreply(char *from, char **ArgList)

{

static char format[40];

static int last_width = -1;

int ok = 1, voice = 0, opped = 0;

char *channel, *user, *host, *server, *nick, *stat, *name;

struct channel *chan = NULL;

char buf_data[BIG_BUFFER_SIZE + 1];

if (!ArgList[5])

return;

if (last_width != get_int_var(CHANNEL_NAME_WIDTH_VAR)) {

if ((last_width = get_int_var(CHANNEL_NAME_WIDTH_VAR)) != 0)

snprintf(format, 39, "%%-%u.%us \002%%-9s\002 %%-3s %%s@%%s (%%s)",

(unsigned char) last_width, (unsigned char) last_width);

else

strcpy(format, "%s\t\002%-9s\002 %-3s %s@%s (%s)");

}

channel = ArgList[0];

user = ArgList[1];

host = ArgList[2];

server = ArgList[3];

nick = ArgList[4];

stat = ArgList[5];

name = ArgList[6];

PasteArgs(ArgList, 6);

message_from(channel, LOG_CRAP);

*buf_data = 0;

strmopencat(buf_data, BIG_BUFFER_SIZE, user, "@", host, NULL);

voice = (strchr(stat, '+') != NULL);

opped = (strchr(stat, '@') != NULL);

if (*stat == 'S') { /* this only true for the header WHOREPLY */

char buffer[BIG_BUFFER_SIZE + 1];

channel = "Channel";

snprintf(buffer, BIG_BUFFER_SIZE, "%s %s %s %s %s %s %s", channel, nick, stat, user, host, server, name);

if (do_hook(WHO_LIST, "%s", buffer))

put_it("%s",

convert_output_format(get_format(FORMAT_WHO_FSET), "%s %s %s %s %s %s %s", channel, nick, stat, user, host, server,

name));

message_from(NULL, LOG_CRAP);

return;

}

if (who_mask) {

if (who_mask & WHO_HERE)

ok = ok && (*stat == 'H');

if (who_mask & WHO_AWAY)

ok = ok && (*stat == 'G');

if (who_mask & WHO_OPS)

ok = ok && (*(stat + 1) == '*');

if (who_mask & WHO_LUSERS)

ok = ok && (*(stat + 1) != '*');

if (who_mask & WHO_CHOPS)

ok = ok && ((*(stat + 1) == '@') || (*(stat + 2) == '@'));

if (who_mask & WHO_NAME)

ok = ok && wild_match(who_name, user);

if (who_mask & WHO_NICK)

ok = ok && wild_match(who_nick, nick);

if (who_mask & WHO_HOST)

ok = ok && wild_match(who_host, host);

if (who_mask & WHO_REAL)

ok = ok && wild_match(who_real, name);

if (who_mask & WHO_SERVER)

ok = ok && wild_match(who_server, server);

}

if (ok) {

char buffer[BIG_BUFFER_SIZE + 1];

snprintf(buffer, BIG_BUFFER_SIZE, "%s %s %s %s %s %s %s", channel, nick, stat, user, host, server, name);

chan = add_to_channel(channel, nick, from_server, opped, voice, buf_data, server, stat);

if (do_hook(WHO_LIST, "%s", buffer)) {

if (!get_int_var(SHOW_WHO_HOPCOUNT_VAR))

next_arg(name, &name);

put_it("%s",

convert_output_format(get_format(FORMAT_WHO_FSET), "%s %s %s %s %s %s %s", channel, nick, stat, user, host, server,

name));

}

}

/*

else if ((who_mask && WHO_KILL) && !ok)

{

put_it("%s", convert_output_format("$G No such match for /whokill", NULL, NULL));

}

*/

message_from(NULL, LOG_CRAP);

}

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;

}

static void p_quit(char *from, char **ArgList)

{

int one_prints = 0;

char *chan = NULL;

char *Reason;

int netsplit = 0;

int ignore;

PasteArgs(ArgList, 0);

if (ArgList[0]) {

Reason = ArgList[0];

netsplit = check_split(from, Reason, chan);

} else

Reason = "?";

ignore = check_ignore(from, FromUserHost, NULL, (netsplit ? IGNORE_SPLITS : IGNORE_QUITS) | IGNORE_ALL, NULL);

for (chan = walk_channels(from, 1, from_server); chan; chan = walk_channels(from, 0, -1)) {

if (ignore != IGNORED) {

message_from(chan, LOG_CRAP);

if (do_hook(CHANNEL_SIGNOFF_LIST, "%s %s %s", chan, from, Reason))

one_prints = 1;

message_from(NULL, LOG_CURRENT);

}

}

if (one_prints) {

chan = what_channel(from, from_server);

ignore = check_ignore(from, FromUserHost, chan, (netsplit ? IGNORE_SPLITS : IGNORE_QUITS) | IGNORE_ALL, NULL);

message_from(chan, LOG_CRAP);

if ((ignore != IGNORED) && do_hook(SIGNOFF_LIST, "%s %s", from, Reason) && !netsplit)

put_it("%s",

convert_output_format(get_format(FORMAT_CHANNEL_SIGNOFF_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,

FromUserHost, chan, Reason));

message_from(NULL, LOG_CURRENT);

}

if (!netsplit)

check_orig_nick(from);

notify_mark(from, NULL, NULL, 0);

remove_from_channel(NULL, from, from_server, netsplit, Reason);

message_from(NULL, LOG_CRAP);

update_all_status(curr_scr_win, NULL, 0);

}

static void p_pong(char *from, char **ArgList)

{

int is_server = 0;

int i;

if (!ArgList[0])

return;

is_server = match("*.*", ArgList[0]);

if (in_server_ping && is_server) ;

{

int old_from_server = from_server;

for (i = 0; i < number_of_servers; i++) {

if ((!my_stricmp(ArgList[0], get_server_name(i)) || !my_stricmp(ArgList[0], get_server_itsname(i)))

&& is_server_connected(i)) {

int old_lag = server_list[i].lag;

from_server = i;

server_list[i].lag = time(NULL) - server_list[i].lag_time;

in_server_ping--;

if (old_lag != server_list[i].lag)

status_update(1);

from_server = old_from_server;

return;

}

}

from_server = old_from_server;

}

if (check_ignore(from, FromUserHost, NULL, IGNORE_PONGS | IGNORE_CRAP, NULL) != IGNORED) {

if (!is_server)

return;

if (!ArgList[1])

say("%s: PONG received from %s", ArgList[0], from);

else

say("%s: PING received from %s %s", ArgList[0], from, ArgList[1]);

}

}

static void p_error(char *from, char **ArgList)

{

PasteArgs(ArgList, 0);

if (!ArgList[0]) {

fake();

return;

}

say("%s", ArgList[0]);

}

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_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);

}

}

static void p_silence(char *from, char **ArgList)

{

char *target = ArgList[0];

char *mag = target++;

if (do_hook(SILENCE_LIST, "%c %s", *mag, target))

put_it("%s", convert_output_format(get_format(FORMAT_SILENCE_FSET), "%s %c %s", update_clock(GET_TIME), *mag, target));

}

static void p_kill(char *from, char **ArgList)

{

char sc[20];

int port;

int local = 0;

port = get_server_port(from_server);

if (ArgList[1] && strstr(ArgList[1], get_server_name(from_server)))

if (!strchr(from, '.'))

local = 1;

snprintf(sc, 19, "+%i %d", from_server, port);

close_server(from_server, empty_str);

clean_whois_queue();

window_check_servers();

set_input_prompt(curr_scr_win, get_string_var(INPUT_PROMPT_VAR), 0);

if (strchr(from, '.')) {

say("Server [%s] has rejected you (probably due to a nick collision)", from);

t_parse_command("SERVER", NULL);

} else {

if (local && get_int_var(NEXT_SERVER_ON_LOCAL_KILL_VAR)) {

int i = from_server + 1;

if (i >= number_of_servers)

i = 0;

snprintf(sc, 19, "+%i", i);

from_server = -1;

}

if (do_hook(DISCONNECT_LIST, "Killed by %s (%s)", from, ArgList[1] ? ArgList[1] : "(No Reason Given)"))

put_it("%s",

convert_output_format(get_format(FORMAT_KILL_FSET), "%s %s", update_clock(GET_TIME),

ArgList[1] ? ArgList[1] : "You have been Killed"));

if (get_int_var(AUTO_RECONNECT_VAR))

t_parse_command("SERVER", NULL);

}

update_all_status(curr_scr_win, NULL, 0);

}

static void p_ping(char **ArgList)

{

PasteArgs(ArgList, 0);

send_to_server(SERVER(from_server), "PONG %s", ArgList[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);

}

}

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 strip_modes(char *from, char *channel, char *line)

{

char *mode;

char *pointer;

char mag = '+'; /* XXXX Bogus */

char *copy = NULL;

#ifdef __GNUC__

char free_copy[strlen(line) + 1];

strcpy(free_copy, line);

#else

char *free_copy = NULL;

malloc_strcpy(&free_copy, line);

#endif

copy = free_copy;

mode = next_arg(copy, &copy);

if (is_channel(channel)) {

for (pointer = mode; *pointer; pointer++) {

char c = *pointer;

switch (c) {

case '+':

case '-':

mag = c;

break;

case 'l':

if (mag == '+')

do_hook(MODE_STRIPPED_LIST, "%s %s %c%c %s", from, channel, mag, c, next_arg(copy, &copy));

else

do_hook(MODE_STRIPPED_LIST, "%s %s %c%c", from, channel, mag, c);

break;

case 'a':

case 'i':

case 'm':

case 'n':

case 'p':

case 's':

case 't':

do_hook(MODE_STRIPPED_LIST, "%s %s %c%c", from, channel, mag, c);

break;

case 'b':

case 'k':

case 'o':

case 'v':

do_hook(MODE_STRIPPED_LIST, "%s %s %c%c %s", from, channel, mag, c, next_arg(copy, &copy));

break;

}

}

} else

/* User mode */

{

for (pointer = mode; *pointer; pointer++) {

char c = *pointer;

switch (c) {

case '+':

case '-':

mag = c;

break;

default:

do_hook(MODE_STRIPPED_LIST, "%s %s %c%c", from, channel, mag, c);

break;

}

}

}

#ifndef __GNUC__

new_free(&free_copy);

#endif

}

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;