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;
}
/* 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);
}
void window_key_list(char dumb, char *dumber)
{
in_window_command = 1;
message_from(NULL, LOG_CURRENT);
window_list(curr_scr_win, NULL);
in_window_command = 0;
message_from(NULL, LOG_CRAP);
}
void window_shrink_one(char dumb, char *dumber)
{
in_window_command = 1;
message_from(NULL, LOG_CURRENT);
resize_window(1, curr_scr_win, -1);
update_all_windows();
in_window_command = 0;
message_from(NULL, LOG_CRAP);
}
void window_key_move(char dumb, char *dumber)
{
in_window_command = 1;
message_from(NULL, LOG_CURRENT);
move_window(curr_scr_win, 1);
update_all_windows();
in_window_command = 0;
message_from(NULL, LOG_CRAP);
}
void window_key_balance(char dumb, char *dumber)
{
in_window_command = 1;
message_from(NULL, LOG_CURRENT);
recalculate_windows();
update_all_windows();
in_window_command = 0;
message_from(NULL, LOG_CRAP);
}
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_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);
}
}
/*
* This is no longer directly sends information to its target.
* As part of a larger attempt to consolidate all data transmission
* into send_text, this function was modified so as to use send_text().
* This function can send both direct CTCP requests, as well as the
* appropriate CTCP replies. By its use of send_text(), it can send
* CTCPs to DCC CHAT and irc nickname peers, and handles encryption
* transparantly. This greatly reduces the logic, complexity, and
* possibility for error in this function.
*/
void send_ctcp (int type, const char *to, int datatag, const char *format, ...)
{
char putbuf [BIG_BUFFER_SIZE + 1],
*putbuf2;
int len;
int l;
const char *pb;
char *extra = NULL;
/* Make sure that the final \001 doesnt get truncated */
if ((len = IRCD_BUFFER_SIZE - (12 + strlen(to))) <= 0)
return; /* Whatever. */
putbuf2 = alloca(len);
l = message_from(to, LEVEL_CTCP);
if (format)
{
va_list args;
va_start(args, format);
vsnprintf(putbuf, BIG_BUFFER_SIZE, format, args);
va_end(args);
pb = outbound_recode(to, from_server, putbuf, &extra);
do_hook(SEND_CTCP_LIST, "%s %s %s %s",
ctcp_type[type], to,
ctcp_cmd[datatag].name, pb);
snprintf(putbuf2, len, "%c%s %s%c",
CTCP_DELIM_CHAR,
ctcp_cmd[datatag].name, pb,
CTCP_DELIM_CHAR);
new_free(&extra);
}
else
{
do_hook(SEND_CTCP_LIST, "%s %s %s",
ctcp_type[type], to,
ctcp_cmd[datatag].name);
snprintf(putbuf2, len, "%c%s%c",
CTCP_DELIM_CHAR,
ctcp_cmd[datatag].name,
CTCP_DELIM_CHAR);
}
/* XXX - Ugh. What a hack. */
putbuf2[len - 2] = CTCP_DELIM_CHAR;
putbuf2[len - 1] = 0;
send_text(from_server, to, putbuf2, ctcp_type[type], 0, 1);
pop_message_from(l);
}
static void
channel_topic(u_char *from, u_char **ArgList)
{
u_char *topic, *channel;
save_message_from();
if (ArgList[1] && is_channel(ArgList[0]))
{
topic = ArgList[1];
channel = ArgList[0];
message_from(channel, LOG_CRAP);
put_it("%s Topic for %s: %s", numeric_banner(), channel,
topic);
}
else
{
message_from(NULL, LOG_CURRENT);
PasteArgs(ArgList, 0);
put_it("%s Topic: %s", numeric_banner(), ArgList[0]);
}
restore_message_from();
}
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);
}
}
static void
invite(u_char *from, u_char **ArgList)
{
u_char *who,
*channel;
if ((who = ArgList[0]) && (channel = ArgList[1]))
{
save_message_from();
message_from(channel, LOG_CRAP);
if (do_hook(current_numeric(), "%s %s %s", from, who, channel))
put_it("%s Inviting %s to channel %s",
numeric_banner(), who, channel);
restore_message_from();
}
}
/*
* kill_process: sends the given signal to the specified process. It does
* not delete the process from the process table or anything like that, it
* only is for sending a signal to a sub process (most likely in an attempt
* to kill it.) The actual reaping of the children will take place async
* on the next parsing run.
*/
static void kill_process (int kill_index, int sig)
{
pid_t pgid;
int old_from_server, l;
if (!process_list || kill_index > process_list_size ||
!process_list[kill_index])
{
say("There is no such process %d", kill_index);
return;
}
old_from_server = from_server;
from_server = process_list[kill_index]->server;
l = message_from(NULL, LEVEL_OTHER);
say("Sending signal %s (%d) to process %d: %s",
sys_siglist[sig], sig, kill_index,
process_list[kill_index]->name);
pop_message_from(l);
from_server = old_from_server;
#ifdef HAVE_GETPGID
pgid = getpgid(process_list[kill_index]->pid);
#else
# ifndef GETPGRP_VOID
pgid = getpgrp(process_list[kill_index]->pid);
# else
pgid = process_list[kill_index]->pid;
# endif
#endif
#ifndef HAVE_KILLPG
# define killpg(pg, sig) kill(-(pg), (sig))
#endif
/* The exec'd process shouldn't be in our process group */
if (pgid == getpid())
{
yell("--- exec'd process is in my job control session! Something is hosed ---");
return;
}
killpg(pgid, sig);
kill(process_list[kill_index]->pid, sig);
}
/*
* syserr is exactly like say, except that if the error occured while
* you were loading a script, it tells you where it happened.
*/
static void vsyserr (int server, const char *format, va_list args)
{
char * str;
int l, old_from_server = from_server;
int i_set_from_server = 0;
if (!window_display || !format)
return;
*putbuf = 0;
if ((str = get_string_var(BANNER_VAR)))
{
if (get_int_var(BANNER_EXPAND_VAR))
{
char *foo;
foo = expand_alias(str, empty_string);
strlcpy(putbuf, foo, sizeof putbuf);
new_free(&foo);
}
else
strlcpy(putbuf, str, sizeof putbuf);
strlcat(putbuf, " INFO -- ", sizeof putbuf);
}
vsnprintf(putbuf + strlen(putbuf),
sizeof(putbuf) - strlen(putbuf) - 1,
format, args);
if (is_server_valid(server))
{
old_from_server = from_server;
from_server = server;
i_set_from_server = 1;
}
l = message_from(NULL, LEVEL_SYSERR);
if (do_hook(YELL_LIST, "%s", putbuf))
put_echo(putbuf);
pop_message_from(l);
if (i_set_from_server)
from_server = old_from_server;
}
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);
}
}
/*
* do_notice_ctcp: a re-entrant form of a CTCP reply parser.
* See the implementation notes in do_ctcp().
*/
char * do_notice_ctcp (const char *from, const char *to, char *str)
{
int flag;
char local_ctcp_buffer [BIG_BUFFER_SIZE + 1],
the_ctcp [IRCD_BUFFER_SIZE + 1],
last [IRCD_BUFFER_SIZE + 1];
char *ctcp_command,
*ctcp_argument;
int i;
char *ptr;
int allow_ctcp_reply = 1;
int l;
int delim_char = charcount(str, CTCP_DELIM_CHAR);
if (delim_char < 2)
return str; /* No CTCPs. */
if (delim_char > 8)
allow_ctcp_reply = 0; /* Ignore all the CTCPs. */
/* We handle ignore, but not flooding (obviously) */
flag = check_ignore_channel(from, FromUserHost, to, LEVEL_CTCP);
in_ctcp_flag++;
strlcpy(local_ctcp_buffer, str, sizeof(local_ctcp_buffer) - 2);
for (;;strlcat(local_ctcp_buffer, last, sizeof(local_ctcp_buffer) - 2))
{
if (split_CTCP(local_ctcp_buffer, the_ctcp, last))
break; /* All done! */
if (!*the_ctcp)
continue; /* Empty requests are ignored */
/*
* The logic of all this is essentially the same as
* do_ctcp
*/
if (!allow_ctcp_reply)
continue;
if (flag == IGNORED)
{
if (x_debug & DEBUG_CTCPS)
yell("CTCP REPLY from [%s] ignored", from);
allow_ctcp_reply = 0;
continue;
}
/* But we don't check ctcp flooding (obviously) */
/* Global messages -- just drop the CTCP */
if (*to == '$' || (is_channel(to) &&
!im_on_channel(to, from_server)))
{
allow_ctcp_reply = 0;
continue;
}
/*
* Parse CTCP message
* CTCP spec says word delim MUST be space
*/
ctcp_command = the_ctcp;
ctcp_argument = strchr(the_ctcp, ' ');
if (ctcp_argument)
*ctcp_argument++ = 0;
else
ctcp_argument = endstr(the_ctcp);
/* Set up the window level/logging */
if (is_channel(to))
l = message_from(to, LEVEL_CTCP);
else
l = message_from(from, LEVEL_CTCP);
/*
* Find the correct CTCP and run it.
*/
for (i = 0; i < NUMBER_OF_CTCPS; i++)
if (!strcmp(ctcp_command, ctcp_cmd[i].name))
break;
/*
* If its a built in CTCP command, check to see if its
* got a reply handler, call if appropriate.
*/
if (i < NUMBER_OF_CTCPS && ctcp_cmd[i].repl)
{
if ((ptr = ctcp_cmd[i].repl(ctcp_cmd + i, from, to,
ctcp_argument)))
{
strlcat(local_ctcp_buffer, ptr,
sizeof local_ctcp_buffer);
new_free(&ptr);
pop_message_from(l);
continue;
}
}
/* Toss it at the user. */
if (ctcp_cmd[i].flag & CTCP_TELLUSER)
{
if (do_hook(CTCP_REPLY_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
say("CTCP %s reply from %s: %s",
ctcp_command, from, ctcp_argument);
}
if (!(ctcp_cmd[i].flag & CTCP_NOLIMIT))
allow_ctcp_reply = 0;
pop_message_from(l);
}
in_ctcp_flag--;
/*
* local_ctcp_buffer is derived from 'str', so its always
* smaller or equal in size to 'str', so this copy is safe.
*/
strlcpy(str, local_ctcp_buffer, BIG_BUFFER_SIZE);
return str;
}
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);
}
/*
* do_notice_ctcp: a re-entrant form of a CTCP reply parser.
* See the implementation notes in do_ctcp().
*/
char * do_notice_ctcp (const char *from, const char *to, char *str)
{
int flag;
int lastlog_level;
char local_ctcp_buffer [BIG_BUFFER_SIZE + 1],
the_ctcp [IRCD_BUFFER_SIZE + 1],
last [IRCD_BUFFER_SIZE + 1];
char *ctcp_command,
*ctcp_argument;
int i;
char *ptr;
int allow_ctcp_reply = 1;
int delim_char = charcount(str, CTCP_DELIM_CHAR);
if (delim_char < 2)
return str; /* No CTCPs. */
if (delim_char > 8)
allow_ctcp_reply = 0; /* Ignore all the CTCPs. */
flag = check_ignore_channel(from, FromUserHost, to, IGNORE_CTCPS);
if (!in_ctcp_flag)
in_ctcp_flag = -1;
strlcpy(local_ctcp_buffer, str, IRCD_BUFFER_SIZE - 2);
for (;;strlcat(local_ctcp_buffer, last, sizeof local_ctcp_buffer))
{
if (split_CTCP(local_ctcp_buffer, the_ctcp, last))
break; /* All done! */
if (!*the_ctcp)
continue; /* Empty requests are ignored */
/*
* Apply sanity rules
*/
if (!allow_ctcp_reply)
continue;
if (flag == IGNORED)
{
if (x_debug & DEBUG_CTCPS)
yell("CTCP REPLY from [%s] ignored", from);
allow_ctcp_reply = 0;
continue;
}
/* Global messages -- just drop the CTCP */
if (*to == '$' || (*to == '#' && !im_on_channel(to, from_server)))
{
allow_ctcp_reply = 0;
continue;
}
/*
* Parse CTCP message
* CTCP spec says word delim MUST be space.
*/
ctcp_command = the_ctcp;
ctcp_argument = strchr(the_ctcp, ' ');
if (ctcp_argument)
*ctcp_argument++ = 0;
else
ctcp_argument = empty_string;
/*
* Find the correct CTCP and run it.
*/
for (i = 0; i < NUMBER_OF_CTCPS; i++)
if (!strcmp(ctcp_command, ctcp_cmd[i].name))
break;
/*
* If its a built in CTCP command, check to see if its
* got a reply handler, call if appropriate.
*/
if (i < NUMBER_OF_CTCPS && ctcp_cmd[i].repl)
{
if ((ptr = ctcp_cmd[i].repl(ctcp_cmd + i, from, to, ctcp_argument)))
{
strlcat(local_ctcp_buffer, ptr, sizeof local_ctcp_buffer);
new_free(&ptr);
continue;
}
}
/* Set up the window level/logging */
lastlog_level = set_lastlog_msg_level(LOG_CTCP);
message_from(NULL, LOG_CTCP);
/* Toss it at the user. */
if (do_hook(CTCP_REPLY_LIST, "%s %s %s %s", from, to, ctcp_command, ctcp_argument))
say("CTCP %s reply from %s: %s", ctcp_command, from, ctcp_argument);
/* Reset the window level/logging */
set_lastlog_msg_level(lastlog_level);
if (!(ctcp_cmd[i].flag & CTCP_NOLIMIT))
allow_ctcp_reply = 0;
}
if (in_ctcp_flag == -1)
in_ctcp_flag = 0;
/*
* local_ctcp_buffer is derived from 'str', so its always
* smaller or equal in size to 'str', so this copy is safe.
*/
strlcpy(str, local_ctcp_buffer, BIG_BUFFER_SIZE);
return str;
}
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 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);
}
/*
* numbered_command: does (hopefully) the right thing with the numbered
* responses from the server. I wasn't real careful to be sure I got them
* all, but the default case should handle any I missed (sorry)
*/
void
numbered_command(u_char *from, int comm, u_char **ArgList)
{
u_char *user;
u_char none_of_these = 0;
u_char blah[BIG_BUFFER_SIZE];
int flag,
lastlog_level;
const int from_server = parsing_server();
#if 0
int user_cnt,
inv_cnt,
server_cnt;
#endif /* 0 */
if (!from || !*from)
return;
if (!*ArgList[0])
user = NULL;
else
user = ArgList[0];
if (!ArgList[1])
return;
lastlog_level = set_lastlog_msg_level(LOG_CRAP);
save_message_from();
message_from(NULL, LOG_CRAP);
ArgList++;
current_numeric_local = -comm; /* must be negative of numeric! */
switch (comm)
{
case 001: /* #define RPL_WELCOME 001 */
PasteArgs(ArgList, 0);
if (my_strcmp(user, server_get_nickname(from_server)) != 0)
{
yell("=== Setting this servers nickname to \"%s\" from \"%s\"", user, server_get_nickname(from_server));
server_set_nickname(from_server, user);
}
if (do_hook(current_numeric(), "%s %s", from, *ArgList))
display_msg(from, ArgList);
clean_whois_queue();
break;
case 002: /* #define RPL_YOURHOST 002 */
PasteArgs(ArgList, 0);
snprintf(CP(blah), sizeof blah, "*** %s", ArgList[0]);
got_initial_version(blah);
if (do_hook(current_numeric(), "%s %s", from, *ArgList))
display_msg(from, ArgList);
break;
/* should do something with this some day, 2.8 had channel/user mode switches */
case 004: /* #define RPL_MYINFO 004 */
PasteArgs(ArgList, 0);
if (do_hook(current_numeric(), "%s %s", from, *ArgList))
display_msg(from, ArgList);
break;
/*
* this part of ircii has been broken for most of ircd 2.7, so someday I'll
* make it work for ircd 2.8 ... phone..
*/
#if 0
case 251: /* #define RPL_LUSERCLIENT 251 */
display_msg(from, ArgList);
if (is_server_connected(from_server))
break;
if (from_server == get_primary_server() && ((sscanf(ArgList[1],
"There are %d users and %d invisible on %d servers",
&user_cnt, &inv_cnt, &server_cnt) == 3)||(sscanf(ArgList[1],
"There are %d users and %d invisible on %d servers",
&user_cnt, &inv_cnt, &server_cnt) == 3)))
{
user_cnt =+ inv_cnt;
if ((server_cnt < get_int_var(MINIMUM_SERVERS_VAR)) ||
(user_cnt < get_int_var(MINIMUM_USERS_VAR)))
{
say("Trying better populated server...");
get_connected(from_server + 1);
}
}
break;
#endif /* 0 */
case 301: /* #define RPL_AWAY 301 */
user_is_away(from, ArgList);
break;
case 302: /* #define RPL_USERHOST 302 */
userhost_returned(from, ArgList);
break;
case 303: /* #define RPL_ISON 303 */
ison_returned(from, ArgList);
break;
case 311: /* #define RPL_WHOISUSER 311 */
whois_name(from, ArgList);
break;
case 312: /* #define RPL_WHOISSERVER 312 */
whois_server(from, ArgList);
break;
case 313: /* #define RPL_WHOISOPERATOR 313 */
whois_oper(from, ArgList);
break;
case 314: /* #define RPL_WHOWASUSER 314 */
whowas_name(from, ArgList);
break;
case 316: /* #define RPL_WHOISCHANOP 316 */
whois_chop(from, ArgList);
break;
case 317: /* #define RPL_WHOISIDLE 317 */
whois_lastcom(from, ArgList);
break;
case 318: /* #define RPL_ENDOFWHOIS 318 */
end_of_whois(from, ArgList);
break;
case 319: /* #define RPL_WHOISCHANNELS 319 */
whois_channels(from, ArgList);
break;
case 321: /* #define RPL_LISTSTART 321 */
ArgList[0] = UP("Channel\0Users\0Topic");
ArgList[1] = ArgList[0] + 8;
ArgList[2] = ArgList[1] + 6;
ArgList[3] = NULL;
funny_list(from, ArgList);
break;
case 322: /* #define RPL_LIST 322 */
funny_list(from, ArgList);
break;
case 324: /* #define RPL_CHANNELMODEIS 324 */
funny_mode(from, ArgList);
break;
case 341: /* #define RPL_INVITING 341 */
invite(from, ArgList);
break;
case 352: /* #define RPL_WHOREPLY 352 */
whoreply(NULL, ArgList);
break;
case 353: /* #define RPL_NAMREPLY 353 */
funny_namreply(from, ArgList);
break;
case 366: /* #define RPL_ENDOFNAMES 366 */
{
u_char *tmp = NULL,
*chan;
PasteArgs(ArgList, 0);
malloc_strcpy(&tmp, ArgList[0]);
chan = next_arg(tmp, 0);
flag = do_hook(current_numeric(), "%s %s", from, ArgList[0]);
if (flag &&
channel_mode_lookup(chan, CHAN_NAMES | CHAN_MODE, 0) &&
get_int_var(SHOW_END_OF_MSGS_VAR) && flag)
display_msg(from, ArgList);
new_free(&tmp);
}
break;
case 381: /* #define RPL_YOUREOPER 381 */
PasteArgs(ArgList, 0);
if (do_hook(current_numeric(), "%s %s", from, *ArgList))
display_msg(from, ArgList);
server_set_operator(parsing_server(), 1);
update_all_status(); /* fix the status line */
break;
case 401: /* #define ERR_NOSUCHNICK 401 */
no_such_nickname(from, ArgList);
break;
case 405: /* #define ERR_TOOMANYCHANNELS 405 */
remove_channel(ArgList[0], parsing_server());
break;
case 421: /* #define ERR_UNKNOWNCOMMAND 421 */
if (check_screen_redirect(ArgList[0]))
break;
if (check_wait_command(ArgList[0]))
break;
PasteArgs(ArgList, 0);
flag = do_hook(current_numeric(), "%s %s", from, *ArgList);
if (!my_strncmp("ISON", *ArgList, 4) || !my_strncmp("USERHOST",
*ArgList, 8))
{
server_set_2_6_2(parsing_server(), 0);
convert_to_whois();
}
else if (flag)
display_msg(from, ArgList);
break;
case 432: /* #define ERR_ERRONEUSNICKNAME 432 */
case 433: /* #define ERR_NICKNAMEINUSE 433 */
PasteArgs(ArgList, 0);
if (do_hook(current_numeric(), "%s %s", from, *ArgList))
display_msg(from, ArgList);
reset_nickname(from);
break;
case 437: /* #define ERR_UNAVAILRESOURCE 437 */
PasteArgs(ArgList, 0);
if (do_hook(current_numeric(), "%s %s", from, *ArgList))
display_msg(from, ArgList);
if (!is_channel(*ArgList))
reset_nickname(from);
break;
case 463: /* #define ERR_NOPERMFORHOST 463 */
display_msg(from, ArgList);
close_server(parsing_server(), empty_string());
window_check_servers();
if (!connected_to_server())
get_connected(parsing_server() + 1);
break;
case 464: /* #define ERR_PASSWDMISMATCH 464 */
PasteArgs(ArgList, 0);
flag = do_hook(current_numeric(), "%s %s", from, ArgList[0]);
if (server_get_oper_command())
{
if (flag)
display_msg(from, ArgList);
}
else
get_password();
break;
case 465: /* #define ERR_YOUREBANNEDCREEP 465 */
{
int klined_server = parsing_server();
PasteArgs(ArgList, 0);
if (do_hook(current_numeric(), "%s %s", from, ArgList[0]))
display_msg(from, ArgList);
close_server(parsing_server(), empty_string());
window_check_servers();
if (number_of_servers() > 1)
remove_from_server_list(klined_server);
if (!connected_to_server())
say("You are not connected to a server. Use /SERVER to connect.");
break;
}
case 471: /* #define ERR_CHANNELISFULL 471 */
case 473: /* #define ERR_INVITEONLYCHAN 473 */
case 474: /* #define ERR_BANNEDFROMCHAN 474 */
case 475: /* #define ERR_BADCHANNELKEY 475 */
case 476: /* #define ERR_BADCHANMASK 476 */
cannot_join_channel(from, ArgList);
break;
case 484: /* #define ERR_RESTRICTED 484 */
if (do_hook(current_numeric(), "%s %s", from, *ArgList))
display_msg(from, ArgList);
server_set_flag(parsing_server(), USER_MODE_R, 1);
break;
/*
* The following accumulates the remaining arguments
* in ArgSpace for hook detection. We can't use
* PasteArgs here because we still need the arguments
* separated for use elsewhere.
*/
default:
{
u_char *ArgSpace = NULL;
int i,
do_message_from = 0;
size_t len;
for (i = len = 0; ArgList[i]; len += my_strlen(ArgList[i++]))
;
len += (i - 1);
ArgSpace = new_malloc(len + 1);
ArgSpace[0] = '\0';
/* this is cheating */
if (ArgList[0] && is_channel(ArgList[0]))
do_message_from = 1;
for (i = 0; ArgList[i]; i++)
{
if (i)
my_strcat(ArgSpace, " ");
my_strcat(ArgSpace, ArgList[i]);
}
if (do_message_from)
message_from(ArgList[0], LOG_CRAP);
i = do_hook(current_numeric(), "%s %s", from, ArgSpace);
new_free(&ArgSpace);
if (do_message_from)
restore_message_from();
if (i == 0)
goto done;
none_of_these = 1;
}
}
/* the following do not hurt the ircII if intercepted by a hook */
if (none_of_these)
{
switch (comm)
{
case 221: /* #define RPL_UMODEIS 221 */
put_it("%s Your user mode is \"%s\"", numeric_banner(),
ArgList[0]);
break;
case 242: /* #define RPL_STATSUPTIME 242 */
PasteArgs(ArgList, 0);
if (from && !my_strnicmp(server_get_itsname(parsing_server()),
from, my_strlen(server_get_itsname(parsing_server()))))
from = NULL;
if (from)
put_it("%s %s from (%s)", numeric_banner(),
*ArgList, from);
else
put_it("%s %s", numeric_banner(), *ArgList);
break;
case 332: /* #define RPL_TOPIC 332 */
channel_topic(from, ArgList);
break;
case 351: /* #define RPL_VERSION 351 */
version(from, ArgList);
break;
case 364: /* #define RPL_LINKS 364 */
if (ArgList[2])
{
PasteArgs(ArgList, 2);
put_it("%s %-20s %-20s %s", numeric_banner(),
ArgList[0], ArgList[1], ArgList[2]);
}
else
{
PasteArgs(ArgList, 1);
put_it("%s %-20s %s", numeric_banner(),
ArgList[0], ArgList[1]);
}
break;
case 372: /* #define RPL_MOTD 372 */
if (!get_int_var(SUPPRESS_SERVER_MOTD_VAR) ||
!server_get_motd(parsing_server()))
{
PasteArgs(ArgList, 0);
put_it("%s %s", numeric_banner(), ArgList[0]);
}
break;
case 375: /* #define RPL_MOTDSTART 375 */
if (!get_int_var(SUPPRESS_SERVER_MOTD_VAR) ||
!server_get_motd(parsing_server()))
{
PasteArgs(ArgList, 0);
put_it("%s %s", numeric_banner(), ArgList[0]);
}
break;
case 376: /* #define RPL_ENDOFMOTD 376 */
if (server_get_attempting_to_connect(parsing_server()))
got_initial_version(UP("*** Your host is broken and not running any version"));
if (get_int_var(SHOW_END_OF_MSGS_VAR) &&
(!get_int_var(SUPPRESS_SERVER_MOTD_VAR) ||
!server_get_motd(parsing_server())))
{
PasteArgs(ArgList, 0);
put_it("%s %s", numeric_banner(), ArgList[0]);
}
server_set_motd(parsing_server(), 0);
break;
case 384: /* #define RPL_MYPORTIS 384 */
PasteArgs(ArgList, 0);
put_it("%s %s %s", numeric_banner(), ArgList[0], user);
break;
case 385: /* #define RPL_NOTOPERANYMORE 385 */
server_set_operator(parsing_server(), 0);
display_msg(from, ArgList);
update_all_status();
break;
case 403: /* #define ERR_NOSUCHCHANNEL 403 */
not_valid_channel(from, ArgList);
break;
case 451: /* #define ERR_NOTREGISTERED 451 */
/*
* Sometimes the server doesn't catch the USER line, so
* here we send a simplified version again -lynx
*/
send_to_server("USER %s %s . :%s", my_username(),
irc_umode(), my_realname());
send_to_server("NICK %s",
server_get_nickname(parsing_server()));
break;
case 462: /* #define ERR_ALREADYREGISTRED 462 */
display_msg(from, ArgList);
break;
#define RPL_CLOSEEND 363
#define RPL_SERVLISTEND 235
case 315: /* #define RPL_ENDOFWHO 315 */
case 323: /* #define RPL_LISTEND 323 */
funny_print_widelist();
case 219: /* #define RPL_ENDOFSTATS 219 */
case 232: /* #define RPL_ENDOFSERVICES 232 */
case 365: /* #define RPL_ENDOFLINKS 365 */
case 368: /* #define RPL_ENDOFBANLIST 368 */
case 369: /* #define RPL_ENDOFWHOWAS 369 */
case 374: /* #define RPL_ENDOFINFO 374 */
#if 0 /* this case needs special handing - see above */
case 376: /* #define RPL_ENDOFMOTD 376 */
#endif /* 0 */
case 394: /* #define RPL_ENDOFUSERS 394 */
if (!get_int_var(SHOW_END_OF_MSGS_VAR))
break;
default:
display_msg(from, ArgList);
}
}
set_lastlog_msg_level(lastlog_level);
done:
restore_message_from();
}
/*
* numbered_command: does (hopefully) the right thing with the numbered
* responses from the server. I wasn't real careful to be sure I got them
* all, but the default case should handle any I missed (sorry)
*
* The format of a numeric looks like so:
*
* :server-name XXX our-nick Arg1 Arg2 Arg3 ... :ArgN
*
* The last argument traditionally has a colon before it, but this is not
* compulsary. The BreakArgs function has already broken this up into
* words for us, so that what we get, looks like this:
*
* server-name -> from parameter
* XXX -> comm parameter
* our-nick -> ArgList[0]
* Arg1 -> ArgList[1]
* Arg2 -> ArgList[2]
* ... ...
*
* BUT! There's a wrinkle in the ointment. The first thing we do is slurp
* up ArgList[0] (our-nick) and put it in 'user'. Then we increment the
* ArgList array, so what we actually end up with is:
*
* server-name -> from parameter
* XXX -> comm parameter
* our-nick -> user
* Arg1 -> ArgList[0]
* Arg2 -> ArgList[1]
* ... ...
* ArgN -> ArgList[N-1]
* NULL -> ArgList[N]
*/
void numbered_command (const char *from, const char *comm, char const **ArgList)
{
const char *target;
char *copy;
int i;
int lastlog_level;
int old_current_numeric = current_numeric;
int numeric;
/* All numerics must have a target (our nickname) */
if (!comm || !*comm)
{ rfc1459_odd(from, comm, ArgList); return; }
numeric = atol(comm);
if (numeric < 0 || numeric > 999)
{ rfc1459_odd(from, comm, ArgList); return; }
if (!(target = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); return; }
ArgList++;
lastlog_level = set_lastlog_msg_level(LOG_CRAP);
if (ArgList[0] && is_channel(ArgList[0]))
message_from(ArgList[0], LOG_CRAP);
else
message_from(NULL, LOG_CRAP);
current_numeric = -numeric; /* must be negative of numeric! */
/*
* This first switch statement is only used for those numerics
* which either need to perform some action before the numeric
* is offered to the user, or by those actions which need to offer
* the numeric to the user in some special manner.
*
* Those numerics which require only special display if the user
* does not hook them, are handled below.
*
* Those numerics which require special action after the numeric
* is offered to the user, are also handled below.
*
* Each of these numerics must either "break" (go to step 2)
* or must "goto END" (goto step 3).
*/
switch (numeric)
{
/*
* I added the "set_server_nickname" here because the client
* when auto-fudging your nick will sometimes be confused as
* what your nickname really is when you connect. Since the
* server always tells us who the message was set to (ie, us)
* we just kind of take it at its word.
*/
case 001: /* #define RPL_WELCOME 001 */
{
Timeval i;
i.tv_sec = 0;
i.tv_usec = 50000;
select(0, NULL, NULL, NULL, &i);
accept_server_nickname(from_server, target);
server_is_registered(from_server, 1);
userhostbase(from_server, NULL, got_my_userhost, 1);
break;
}
/*
* Now instead of the terribly horrible hack using numeric 002
* to get the server name/server version info, we use the 004
* numeric which is what is the most logical choice for it.
*
* If any of the arguments are missing, we don't abort, because
* the client needs 004 to sync. Instead, we just pass in the
* NULL values and hope for the best...
*/
case 004: /* #define RPL_MYINFO 004 */
{
const char *server = NULL,
*version = NULL,
*umodes = NULL;
/* The 004 numeric is too import to "odd server stuff" over. */
/* So if the reply is useless, we'll just wing it */
if (!(server = ArgList[0]))
server = version = umodes = NULL;
else if (!(version = ArgList[1]))
server = version = umodes = NULL;
else if (!(umodes = ArgList[2]))
server = version = umodes = NULL;
else
{
/* Work around ratbox-1.2-3. */
if (!my_stricmp(umodes, "(brown"))
if (ArgList[3] && !my_stricmp(ArgList[3], "paper"))
if (ArgList[4] && !my_stricmp(ArgList[4], "bag"))
if (ArgList[5] && !my_stricmp(ArgList[5], "release)"))
{
if (!(umodes = ArgList[6]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
}
}
got_initial_version_28(server, version, umodes);
break;
}
case 005:
{
int arg;
char *set, *value;
for (arg = 0; ArgList[arg] && !strchr(ArgList[arg], ' '); arg++) {
set = LOCAL_COPY(ArgList[arg]);
value = strchr(set, '=');
if (value && *value)
*value++ = 0;
if (*set == '+') /* parameter append */
{
const char *ov = get_server_005(from_server, ++set);
value = malloc_strdup2(ov, value);
set_server_005(from_server, set, value);
new_free(&value);
}
else if (*set == '-') /* parameter removal */
set_server_005(from_server, ++set, NULL);
else if (value && *value)
set_server_005(from_server, set, value);
else
set_server_005(from_server, set, space);
}
break;
}
case 10: /* EFNext "Use another server" 010 */
{
const char *new_server, *new_port_s, *message;
int new_port, old_server;
PasteArgs(ArgList, 2);
if (!(new_server = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(new_port_s = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(message = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
new_port = atol(ArgList[1]);
/* Must do these things before calling "display_msg" */
old_server = from_server;
add_to_server_list(new_server, new_port, NULL, NULL,
get_server_group(from_server), NULL, 0);
server_reconnects_to(old_server, from_server);
from_server = old_server;
break;
}
case 14: /* Erf/TS4 "cookie" numeric 014 */
{
const char * cookie;
PasteArgs(ArgList, 0);
if (!(cookie = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
use_server_cookie(from_server);
set_server_cookie(from_server, cookie);
goto END;
}
case 42: /* ircnet's "unique id" numeric 042 */
{
const char * unique_id;
const char * message;
PasteArgs(ArgList, 1);
if (!(unique_id = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
else if (!(message = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
set_server_unique_id(from_server, unique_id);
if (do_hook(current_numeric, "%s %s %s",
from, unique_id, message))
goto DISPLAY;
goto END;
}
case 301: /* #define RPL_AWAY 301 */
{
const char *nick, *message;
PasteArgs(ArgList, 1);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(message = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/* Ach. /on 301 doesn't offer 'from' as $0. Bummer. */
if (do_hook(current_numeric, "%s %s", nick, message))
goto DISPLAY;
goto END;
}
case 340: /* #define RPL_USERIP 307 */
if (!get_server_005(from_server, "USERIP"))
break;
/* FALLTHROUGH */
case 302: /* #define RPL_USERHOST 302 */
userhost_returned(from_server, from, comm, ArgList);
goto END;
case 303: /* #define RPL_ISON 303 */
ison_returned(from_server, from, comm, ArgList);
goto END;
case 315: /* #define RPL_ENDOFWHO 315 */
who_end(from_server, from, comm, ArgList);
goto END;
case 321: /* #define RPL_LISTSTART 321 */
{
const char *channel, *user_cnt, *line;
channel = ArgList[0] = "Channel";
user_cnt = ArgList[1] = "Users";
line = ArgList[2] = "Topic";
ArgList[3] = NULL;
/* Then see if they want to hook /ON LIST */
if (!do_hook(LIST_LIST, "%s %s %s", channel, user_cnt, line))
goto END;
/*
* Otherwise, this line is ok.
*/
break;
}
case 322: /* #define RPL_LIST 322 */
{
const char *channel, *user_cnt, *line;
int cnt;
int funny_flags, funny_min, funny_max;
const char *funny_match;
PasteArgs(ArgList, 2);
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(user_cnt = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(line = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
funny_flags = get_server_funny_flags(from_server);
funny_min = get_server_funny_min(from_server);
funny_max = get_server_funny_max(from_server);
funny_match = get_server_funny_match(from_server);
/*
* Do not display if the channel has no topic and the user asked
* for only channels with topics.
*/
if (funny_flags & FUNNY_TOPIC && !(line && *line))
goto END;
/*
* Do not display if the channel does not have the necessary
* number of users the user asked for
*/
cnt = my_atol(user_cnt);
if (funny_min && (cnt < funny_min))
goto END;
if (funny_max && (cnt > funny_max))
goto END;
/*
* Do not display if the channel is not private or public as the
* user requested.
*/
if ((funny_flags & FUNNY_PRIVATE) && (*channel != '*'))
goto END;
if ((funny_flags & FUNNY_PUBLIC) && (*channel == '*'))
goto END;
/*
* Do not display if the channel does not match the user's
* supplied wildcard pattern
*/
if (funny_match && wild_match(funny_match, channel) == 0)
goto END;
/* Then see if they want to hook /ON LIST */
if (!do_hook(LIST_LIST, "%s %s %s", channel, user_cnt, line))
goto END;
/*
* Otherwise, this line is ok.
*/
break;
}
case 324: /* #define RPL_CHANNELMODEIS 324 */
{
const char *mode, *channel;
PasteArgs(ArgList, 1);
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(mode = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/* If we're waiting for MODE reply. */
if (channel_is_syncing(channel, from_server))
{
int numonchannel, maxnum;
copy = LOCAL_COPY(channel);
update_channel_mode(channel, mode);
update_all_status();
maxnum = get_server_max_cached_chan_size(from_server);
if (maxnum >= 0)
{
numonchannel = number_on_channel(copy, from_server);
if (numonchannel <= maxnum)
whobase(from_server, copy, add_user_who,
add_user_end);
else
channel_not_waiting(copy, from_server);
}
else
whobase(from_server, copy, add_user_who,
add_user_end);
#if 0
goto END;
#endif
}
break;
}
case 352: /* #define RPL_WHOREPLY 352 */
whoreply(from_server, NULL, comm, ArgList);
goto END;
case 353: /* #define RPL_NAMREPLY 353 */
{
const char *type, *channel, *line;
PasteArgs(ArgList, 2);
if (!(type = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(channel = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(line = ArgList[2]))
{ line = empty_string; }
if (channel_is_syncing(channel, from_server))
{
char *line_copy = LOCAL_COPY(line);
char *nick;
while ((nick = next_arg(line_copy, &line_copy)) != NULL)
{
/* XXX - Hack to work around space at end of 353 */
forcibly_remove_trailing_spaces(nick, NULL);
/*
* 1999 Oct 29 -- This is a hack to compensate for
* a bug in older ircd implementations that can result
* in a truncated nickname at the end of a names reply.
* The last nickname in a names list is then always
* treated with suspicion until the WHO reply is
* completed and we know that its not truncated. --esl
*/
if (!line || !*line)
add_to_channel(channel, nick, from_server,
1, 0, 0, 0);
else
add_to_channel(channel, nick, from_server,
0, 0, 0, 0);
}
message_from(channel, LOG_CRAP);
break;
}
else
{
int cnt;
const char *ptr;
int funny_flags, funny_min, funny_max;
const char *funny_match;
funny_flags = get_server_funny_flags(from_server);
funny_min = get_server_funny_min(from_server);
funny_max = get_server_funny_max(from_server);
funny_match = get_server_funny_match(from_server);
ptr = line;
for (cnt = -1; ptr; cnt++)
{
if ((ptr = strchr(ptr, ' ')) != NULL)
ptr++;
}
if (funny_min && (cnt < funny_min))
goto END;
else if (funny_max && (cnt > funny_max))
goto END;
if ((funny_flags & FUNNY_PRIVATE) &&
(*type == '='))
goto END;
if ((funny_flags & FUNNY_PUBLIC) &&
((*type == '*') || (*type == '@')))
goto END;
if (funny_match && wild_match(funny_match, channel) == 0)
goto END;
}
/* Everything is OK. */
break;
}
case 354: /* #define RPL_XWHOREPLY 354 */
xwhoreply(from_server, NULL, comm, ArgList);
goto END;
/* XXX Yea yea, these are out of order. so shoot me. */
case 346: /* #define RPL_INVITELIST (+I for erf) */
case 348: /* #define RPL_EXCEPTLIST (+e for erf) */
case 367: /* #define RPL_BANLIST */
number_of_bans++;
break;
case 347: /* #define END_OF_INVITELIST */
case 349: /* #define END_OF_EXCEPTLIST */
case 368: /* #define END_OF_BANLIST */
{
const char *channel;
if (!get_int_var(SHOW_END_OF_MSGS_VAR))
goto END;
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
#ifdef IRCII_LIKE_BAN_SUMMARY
if (do_hook(current_numeric, "%s %s %d",
from, channel, number_of_bans))
#else
if (do_hook(current_numeric, "%s %d %s",
from, number_of_bans, channel))
#endif
{
put_it("%s Total number of %s on %s - %d",
banner(),
numeric == 347 ? "invites" :
(numeric == 349 ? "exceptions" :
(numeric == 368 ? "bans" : "wounds")),
channel, number_of_bans);
}
goto END;
}
/* XXX Shouldn't this set "You're operator" flag for hybrid? */
case 381: /* #define RPL_YOUREOPER 381 */
if (!is_server_registered(from_server))
{ rfc1459_odd(from, comm, ArgList); goto END; }
break;
/* ":%s 401 %s %s :No such nick/channel" */
case 401: /* #define ERR_NOSUCHNICK 401 */
{
const char *nick;
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!is_channel(nick))
{
notify_mark(from_server, nick, 0, 0);
if (get_int_var(AUTO_WHOWAS_VAR))
{
int foo = get_int_var(NUM_OF_WHOWAS_VAR);
if (foo > -1)
send_to_server("WHOWAS %s %d", nick, foo);
else
send_to_server("WHOWAS %s", nick);
}
}
break;
}
/* Bizarre dalnet extended who replies. */
/* ":%s 402 %s %s :No such server" */
case 402:
{
const char *server;
if (!(server = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
fake_who_end(from_server, from, comm, server);
break;
}
/* Yet more bizarre dalnet extended who replies. */
/* ":%s 522 %s :/WHO Syntax incorrect, use /who ? for help" */
/* ":%s 523 %s :Error, /who limit of %d exceed." */
case 522:
case 523:
{
/*
* This dalnet error message doesn't even give us the
* courtesy of telling us which who request was in error,
* so we have to guess. Whee.
*/
fake_who_end(from_server, from, comm, NULL);
break;
}
case 403: /* #define ERR_NOSUCHCHANNEL 403 */
{
const char * s;
const char * channel;
const char * message;
PasteArgs(ArgList, 1);
/* Some servers BBC and send back an empty reply. */
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(message = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/* Do not accept 403's from remote servers. */
s = get_server_itsname(from_server);
if (my_strnicmp(s, from, strlen(s)))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/*
* Some servers BBC and send this instead of a
* 315 numeric when a who request has been completed.
*/
if (fake_who_end(from_server, from, comm, channel))
;
/*
* If you try to JOIN or PART the "*" named channel, as may
* happen if epic gets confused, the server may tell us that
* channel does not exist. But it would be death to try to
* destroy that channel as epic will surely do the wrong thing!
* Otherwise, we somehow tried to reference a channel that
* this server claims does not exist; we blow the channel away
* for good measure.
*/
else if (strcmp(channel, "*"))
remove_channel(channel, from_server);
break;
}
case 421: /* #define ERR_UNKNOWNCOMMAND 421 */
{
const char *token;
if (!(token = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (check_server_redirect(from_server, token))
goto END;
if (check_server_wait(from_server, token))
goto END;
break;
}
case 432: /* #define ERR_ERRONEUSNICKNAME 432 */
{
const char *nick;
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!my_stricmp(target, nick))
yell("WARNING: Strange invalid nick message received."
" You are probably lagged.");
else if (get_int_var(AUTO_NEW_NICK_VAR))
fudge_nickname(from_server);
else
reset_nickname(from_server);
break;
}
case 437: /* av2.9's "Nick collision" numeric 437 */
/* Also, undernet/dalnet "You are banned" */
/* Also, av2.10's "Can't do that" numeric */
/* Also, cs's "too many nick changes" num */
{
/*
* Ugh. What a total trainwreck this is. Sometimes, I
* really hate all the ircd's out there in the world that
* have to be supported.
*
* Well, there are at least four different, occasionally
* scrutable ways we can get this numeric.
*
* 1a) On ircnet -- As an unregistered user, the NICK that
* we are trying to register was used in the past 90
* seconds or so. The server expects us to send
* another NICK request.
* ARGV[0] IS NICK, REGISTERED IS NO
* 1b) On ircnet -- As a registered user, the NICK that
* we are trying to register was used in the past 90
* seconds or so. The server expects us not to do
* anything (like a 432 numeric).
* ARGV[0] IS NICK, REGISTERED IS YES
* 2) On ircnet -- As a registered user, we are trying to
* join a channel that was netsplit in the past 24 hours
* or so. The server expects us not to do anything.
* ARGV[0] IS CHANNEL, REGISTERED IS YES
* 3) On undernet/dalnet -- As a registered user, who is
* on a channel where we are banned, a NICK request
* was rejected (because we are banned). The server
* expects us not to do anything.
* ARGV[0] IS CHANNEL, REGISTERED IS YES
* 4) On a comstud efnet servers -- As a registered user,
* we have changed our nicknames too many times in
* too short a time. The server expects us not to do
* anything.
* ARGV[0] IS ERROR, ARGV[1] IS NULL.
* I understand this numeric will be moving to 439.
*/
/*
* Weed out the comstud one first, since it's the most bizarre.
*/
if (ArgList[0] && ArgList[1] == NULL)
{
accept_server_nickname(from_server, target);
break;
}
/*
* Now if it's a channel, it might be ircnet telling us we
* can't join the channel, or undernet telling us that we
* can't change our nickname because we're banned. The
* easiest way to tell is to see if we are on the channel.
*/
if (is_channel(ArgList[0]))
{
/* XXX Is this really neccesary? */
if (!im_on_channel(ArgList[0], from_server))
remove_channel(ArgList[0], from_server);
break;
}
/*
* Otherwise, a nick command failed. Oh boy.
* If we are registered, abort the nick change and
* hope for the best.
*/
if (is_server_registered(from_server))
{
accept_server_nickname(from_server, target);
break;
}
/*
* Otherwise, it's an ircnet "nick not available" error.
* Let the nickname reset numerics handle this mess.
*/
/* FALLTHROUGH */
}
case 433: /* #define ERR_NICKNAMEINUSE 433 */
case 438: /* EFnet/TS4 "nick collision" numeric 438 */
case 453: /* EFnet/TS4 "nickname lost" numeric 453 */
{
const char *nick;
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!my_stricmp(target, nick))
/*
* This should stop the "rolling nicks" in their tracks.
*/
yell("WARNING: Strange invalid nick message received."
" You are probably lagged.");
else if (get_int_var(AUTO_NEW_NICK_VAR))
fudge_nickname(from_server);
else
reset_nickname(from_server);
if (!from)
from = "-1";
break;
}
case 439: /* Comstud's "Can't change nickname" */
{
accept_server_nickname(from_server, target);
break;
}
case 442: /* #define ERR_NOTONCHANNEL 442 */
{
const char * s;
const char * channel;
const char * message;
PasteArgs(ArgList, 1);
/* Some servers BBC and send back an empty reply. */
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(message = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/* Do not accept this numeric from remote servers */
s = get_server_itsname(from_server);
if (my_strnicmp(s, from, strlen(s)))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/* Do not ever delete the "*" channel */
if (strcmp(ArgList[0], "*"))
remove_channel(ArgList[0], from_server);
break;
}
case 451: /* #define ERR_NOTREGISTERED 451 */
/*
* Sometimes the server doesn't catch the USER line, so
* here we send a simplified version again -lynx
*/
register_server(from_server, NULL);
break;
case 462: /* #define ERR_ALREADYREGISTRED 462 */
change_server_nickname(from_server, NULL);
break;
case 465: /* #define ERR_YOUREBANNEDCREEP 465 */
{
/*
* There used to be a say() here, but if we arent
* connected to a server, then doing say() is not
* a good idea. So now it just doesnt do anything.
*/
server_reconnects_to(from_server, NOSERV);
break;
}
case 477: /* #define ERR_NEEDREGGEDNICK 477 */
/* IRCnet has a different 477 numeric. */
if (ArgList[0] && *ArgList[0] == '+')
break;
/* FALLTHROUGH */
case 471: /* #define ERR_CHANNELISFULL 471 */
case 473: /* #define ERR_INVITEONLYCHAN 473 */
case 474: /* #define ERR_BANNEDFROMCHAN 474 */
case 475: /* #define ERR_BADCHANNELKEY 475 */
case 476: /* #define ERR_BADCHANMASK 476 */
{
const char *channel;
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
cant_join_channel(ArgList[0], from_server);
break;
}
}
/* DEFAULT OFFER */
/*
* This is the "default hook" case, where we offer to the user all of
* the numerics that were not offered above. We simply catenate
* all of the arguments into a string and offer to the user.
* If the user bites, then we skip the "default display" section.
*/
copy = alloca(IRCD_BUFFER_SIZE + 1);
*copy = 0;
for (i = 0; ArgList[i]; i++)
{
if (i)
strlcat(copy, " ", IRCD_BUFFER_SIZE);
strlcat(copy, ArgList[i], IRCD_BUFFER_SIZE);
}
if (!do_hook(current_numeric, "%s %s", from, copy))
goto END;
DISPLAY:
/* DEFAULT DISPLAY */
/*
* This is the "default display" case, where if the user does not
* hook the numeric, we output the message in some special way.
* If a numeric does not require special outputting, then we will
* just display it with ``display_msg''
*/
switch (numeric)
{
case 221: /* #define RPL_UMODEIS 221 */
{
const char *umode;
PasteArgs(ArgList, 0);
if (!(umode = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s Your user mode is \"%s\"", banner(), umode);
break;
}
case 271: /* #define SILENCE_LIST 271 */
{
const char *perp, *victim;
PasteArgs(ArgList, 1);
if (!(perp = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(victim = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s is ignoring %s", banner(), perp, victim);
break;
}
case 301: /* #define RPL_AWAY 301 */
{
const char *nick, *message;
PasteArgs(ArgList, 1);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(message = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s is away: %s", banner(), nick, message);
break;
}
case 311: /* #define RPL_WHOISUSER 311 */
{
const char *nick, *user, *host, *channel, *name;
PasteArgs(ArgList, 4);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(user = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(host = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(channel = ArgList[3]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(name = ArgList[4]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s is %s@%s (%s)", banner(), nick, user, host, name);
break;
}
case 312: /* #define RPL_WHOISSERVER 312 */
{
const char *nick, *server, *pithy;
PasteArgs(ArgList, 2);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(server = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(pithy = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s on irc via server %s (%s)", banner(), server, pithy);
break;
}
case 313: /* #define RPL_WHOISOPERATOR 313 */
{
const char *nick, *message;
PasteArgs(ArgList, 1);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(message = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s %s", banner(), ArgList[0], ArgList[1]);
break;
}
case 314: /* #define RPL_WHOWASUSER 314 */
{
const char *nick, *user, *host, *unused, *name;
PasteArgs(ArgList, 4);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(user = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(host = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(unused = ArgList[3]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(name = ArgList[4]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s was %s@%s (%s)",banner(), nick, user, host, name);
break;
}
case 317: /* #define RPL_WHOISIDLE 317 */
{
const char *nick, *idle_str, *startup_str;
int idle;
const char * unit;
char startup_ctime[128];
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(idle_str = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(startup_str = ArgList[2])) { /* No problem */; }
*startup_ctime = 0;
if (startup_str) /* Undernet/TS4 */
{
time_t startup;
if ((startup = atol(startup_str)) != 0)
snprintf(startup_ctime, 128, ", signed on at %s",
my_ctime(startup));
}
if ((idle = atoi(idle_str)) > 59)
{
idle /= 60;
unit = "minute";
}
else
unit = "second";
put_it ("%s %s has been idle %d %ss%s",
banner(), nick, idle, unit, startup_ctime);
break;
}
case 318: /* #define RPL_ENDOFWHOIS 318 */
{
PasteArgs(ArgList, 0);
if (get_int_var(SHOW_END_OF_MSGS_VAR))
display_msg(from, comm, ArgList);
break;
}
case 319: /* #define RPL_WHOISCHANNELS 319 */
{
const char *nick, *channels;
PasteArgs(ArgList, 1);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(channels = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s on channels: %s", banner(), channels);
break;
}
case 321: /* #define RPL_LISTSTART 321 */
/* Our screwy 321 handling demands this. BAH! */
put_it("%s Channel Users Topic", banner());
break;
case 322: /* #define RPL_LIST 322 */
{
static char format[25];
static int last_width = -1;
const char *channel, *user_cnt, *line;
PasteArgs(ArgList, 2);
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(user_cnt = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(line = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/* Figure out how to display this to the user. */
if (last_width != get_int_var(CHANNEL_NAME_WIDTH_VAR))
{
if ((last_width = get_int_var(CHANNEL_NAME_WIDTH_VAR)))
snprintf(format, 25, "%%-%u.%us %%-5s %%s",
(unsigned) last_width,
(unsigned) last_width);
else
strlcpy(format, "%s\t%-5s %s", sizeof format);
}
if (*channel == '*')
say(format, "Prv", user_cnt, line);
else
say(format, check_channel_type(channel),
user_cnt, line);
break;
}
case 324: /* #define RPL_CHANNELMODEIS 324 */
{
const char *mode, *channel;
PasteArgs(ArgList, 1);
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(mode = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s Mode for channel %s is \"%s\"",
banner(), channel, mode);
break;
}
case 329: /* #define CREATION_TIME 329 */
{
const char *channel, *time1_str, *time2_str, *time3_str;
time_t time1, time2, time3;
PasteArgs(ArgList, 2);
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(time1_str = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(time2_str = ArgList[2])) { /* No problem */; }
if (!(time3_str = ArgList[3])) { /* No problem */; }
/* Erf/TS4 support */
if (time2_str && time3_str)
{
time1 = (time_t)my_atol(time1_str);
time2 = (time_t)my_atol(time2_str);
time3 = (time_t)my_atol(time3_str);
put_it("%s Channel %s was created at %ld, "
"+c was last set at %ld, "
"and has been opless since %ld", banner(),
channel, time1, time2, time3);
}
else
{
time1 = (time_t)my_atol(time1_str);
put_it("%s Channel %s was created at %s",
banner(), channel, my_ctime(time1));
}
break;
}
case 330: /* #define RPL_WHOISLOGGEDIN 330 */
{
const char *nick, *login, *reason;
PasteArgs(ArgList, 2);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(login = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(reason = ArgList[2]))
{ reason = "is logged in as"; }
put_it("%s %s %s %s", banner(), nick, reason, login);
break;
}
case 332: /* #define RPL_TOPIC 332 */
{
const char *channel, *topic;
PasteArgs(ArgList, 1);
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(topic = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s Topic for %s: %s", banner(), channel, topic);
break;
}
case 333: /* #define RPL_TOPICWHOTIME 333 */
{
const char *channel, *nick, *when_str;
time_t howlong;
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(nick = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(when_str = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
howlong = time(NULL) - my_atol(when_str);
put_it("%s The topic was set by %s %ld sec ago",banner(),
nick, howlong);
break;
}
case 341: /* #define RPL_INVITING 341 */
{
const char *nick, *channel;
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(channel = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
message_from(channel, LOG_CRAP);
put_it("%s Inviting %s to channel %s", banner(), nick, channel);
break;
}
case 351: /* #define RPL_VERSION 351 */
{
const char *version, *itsname, *stuff;
PasteArgs(ArgList, 2);
if (!(version = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(itsname = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(stuff = ArgList[2]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s Server %s: %s %s",banner(), itsname, version, stuff);
break;
}
case 353: /* #define RPL_NAMREPLY 353 */
{
static int last_width;
char format[41];
const char *type, *channel, *line;
PasteArgs(ArgList, 2);
if (!(type = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(channel = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(line = ArgList[2]))
{ line = empty_string; }
/* This is only for when the user joined the channel */
if (channel_is_syncing(channel, from_server))
{
/* If the user bites on /ON NAMES, then skip the rest */
message_from(channel, LOG_CRAP);
if (do_hook(NAMES_LIST, "%s %s", channel, line))
if (get_int_var(SHOW_CHANNEL_NAMES_VAR))
say("Users on %s: %s",
check_channel_type(channel), line);
break;
}
/* If the user grabs /ON NAMES then just stop right here */
if (!do_hook(NAMES_LIST, "%s %s", channel, line))
break;
/* This all is for when the user has not just joined channel */
if (last_width != get_int_var(CHANNEL_NAME_WIDTH_VAR))
{
if ((last_width = get_int_var(CHANNEL_NAME_WIDTH_VAR)))
snprintf(format, 40, "%%s: %%-%u.%us %%s",
(unsigned char) last_width,
(unsigned char) last_width);
else
strlcpy(format, "%s: %s\t%s", sizeof format);
}
else
strlcpy(format, "%s: %s\t%s", sizeof format);
message_from(channel, LOG_CRAP);
if (*type == '=')
{
if (last_width && ((int)strlen(channel) > last_width))
{
char *channel_copy = LOCAL_COPY(channel);
channel_copy[last_width-1] = '>';
channel_copy[last_width] = 0;
channel = channel_copy;
}
put_it(format, "Pub", check_channel_type(channel), line);
}
else if (*type == '*')
put_it(format, "Prv", check_channel_type(channel), line);
else if (*type == '@')
put_it(format, "Sec", check_channel_type(channel), line);
break;
}
case 364: /* #define RPL_LINKS 364 */
{
const char *itsname, *uplink, *stuff;
PasteArgs(ArgList, 2);
if (!(itsname = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(uplink = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(stuff = ArgList[2])) { stuff = empty_string; }
if (stuff)
put_it("%s %-20s %-20s %s", banner(),
itsname, uplink, stuff);
else
put_it("%s %-20s %s", banner(), itsname, uplink);
break;
}
case 366: /* #define RPL_ENDOFNAMES 366 */
{
const char *channel;
if (!get_int_var(SHOW_END_OF_MSGS_VAR))
break;
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!channel_is_syncing(channel, from_server))
display_msg(from, comm, ArgList);
break;
}
case 346: /* +I on erf */
case 348: /* +e on erf */
case 367: /* +b */
{
const char *channel, *ban, *perp, *when_str;
time_t howlong;
if (!(channel = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(ban = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(perp = ArgList[2])) { /* No problem. */ }
if (!(when_str = ArgList[3])) { /* No problem. */ }
if (perp && when_str)
{
howlong = time(NULL) - my_atol(when_str);
put_it("%s %s %-25s set by %-10s %ld sec ago",
banner(), channel, ban, perp, howlong);
}
else
put_it("%s %s %s", banner(), channel, ban);
break;
}
case 401: /* #define ERR_NOSUCHNICK 401 */
{
const char *nick, *stuff;
PasteArgs(ArgList, 1);
if (!(nick = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
if (!(stuff = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s: %s", banner(), nick, stuff);
break;
}
case 219: /* #define RPL_ENDOFSTATS 219 */
case 232: /* #define RPL_ENDOFSERVICES 232 */
case 365: /* #define RPL_ENDOFLINKS 365 */
case 369: /* #define RPL_ENDOFWHOWAS 369 */
case 374: /* #define RPL_ENDOFINFO 374 */
case 394: /* #define RPL_ENDOFUSERS 394 */
{
PasteArgs(ArgList, 0);
if (get_int_var(SHOW_END_OF_MSGS_VAR))
display_msg(from, comm, ArgList);
break;
}
case 471: /* #define ERR_CHANNELISFULL 471 */
{
const char *message;
PasteArgs(ArgList, 0);
if (!(message = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s (Channel is full)", banner(), message);
break;
}
case 473: /* #define ERR_INVITEONLYCHAN 473 */
{
const char *message;
PasteArgs(ArgList, 0);
if (!(message = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s (You must be invited)", banner(), message);
break;
}
case 474: /* #define ERR_BANNEDFROMCHAN 474 */
{
const char *message;
PasteArgs(ArgList, 0);
if (!(message = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s (You are banned)", banner(), message);
break;
}
case 475: /* #define ERR_BADCHANNELKEY 475 */
{
const char *message;
PasteArgs(ArgList, 0);
if (!(message = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s (You must give the correct key)",
banner(), message);
break;
}
case 476: /* #define ERR_BADCHANMASK 476 */
{
const char *message;
PasteArgs(ArgList, 0);
if (!(message = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
put_it("%s %s (Bad channel mask)", banner(), message);
break;
}
case 477: /* #define ERR_NEEDREGGEDNICK 477 */
{
const char *message;
PasteArgs(ArgList, 0);
if (!(message = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); goto END; }
/* IRCnet has a different 477 numeric. */
if (message && *message == '+')
{
display_msg(from, comm, ArgList);
break;
}
PasteArgs(ArgList, 0);
put_it("%s %s (You must use a registered nickname)",
banner(), message);
break;
}
default:
display_msg(from, comm, ArgList);
}
END:
/*
* This is where we clean up after our numeric. Numeric-specific
* cleanups can occur here, and then below we reset the display
* settings.
*/
switch (numeric)
{
case 347: /* #define END_OF_INVITELIST */
case 349: /* #define END_OF_EXCEPTLIST */
case 368:
number_of_bans = 0;
break;
case 464: /* #define ERR_PASSWDMISMATCH 464 */
{
char server_num[8];
if (oper_command)
oper_command = 0;
else if (!is_server_registered(from_server))
{
server_reconnects_to(from_server, NOSERV);
say("Password required for connection to server %s",
get_server_name(from_server));
if (!dumb_mode)
{
strlcpy(server_num, ltoa(from_server), sizeof server_num);
add_wait_prompt("Server Password:",
password_sendline,
server_num, WAIT_PROMPT_LINE, 0);
}
}
}
}
current_numeric = old_current_numeric;
set_lastlog_msg_level(lastlog_level);
message_from(NULL, LOG_CRAP);
}
/*
* do_ctcp: a re-entrant form of a CTCP parser. The old one was lame,
* so i took a hatchet to it so it didnt suck.
*
* XXXX - important! The third argument -- 'str', is expected to be
* 'BIG_BUFFER_SIZE + 1' or larger. If it isnt, chaos will probably
* ensue if you get spammed with lots of CTCP UTC requests.
*
* UTC requests can be at minimum 5 bytes, and the expansion is always 24.
* That means you can cram (510 - strlen("PRIVMSG x :") / 5) UTCs (100)
* into a privmsg. That means itll expand to 2400 characters. We silently
* limit the number of valid CTCPs to 4. Anything more than that we dont
* even bother with. (4 * 24 + 11 -> 106), which is less than
* IRCD_BUFFER_SIZE, which gives us plenty of safety.
*
* XXXX - The normal way of implementation required two copies -- once into a
* temporary buffer, once back into the original buffer -- for the best case
* scenario. This is horrendously inefficient, since most privmsgs dont
* contain any CTCPs. So we check to see if there are any CTCPs in the
* message before we bother doing anything. THIS IS AN INELEGANT HACK!
* But the call to charcount() is less expensive than even one copy to
* strlcpy() since they both evaluate *each* character, and charcount()
* doesnt have to do a write unless the character is present. So it is
* definitely worth the cost to save CPU time for 99% of the PRIVMSGs.
*/
char * do_ctcp (const char *from, const char *to, char *str)
{
int flag;
int fflag;
char local_ctcp_buffer [BIG_BUFFER_SIZE + 1],
the_ctcp [IRCD_BUFFER_SIZE + 1],
last [IRCD_BUFFER_SIZE + 1];
char *ctcp_command,
*ctcp_argument;
int i;
char *ptr = NULL;
int allow_ctcp_reply = 1;
static time_t last_ctcp_parsed = 0;
int l;
char * extra = NULL;
int delim_char = charcount(str, CTCP_DELIM_CHAR);
if (delim_char < 2)
return str; /* No CTCPs. */
if (delim_char > 8)
allow_ctcp_reply = 0; /* Historical limit of 4 CTCPs */
flag = check_ignore_channel(from, FromUserHost, to, LEVEL_CTCP);
fflag = new_check_flooding(from, FromUserHost, is_channel(to) ? to : NULL,
str, LEVEL_CTCP);
in_ctcp_flag++;
strlcpy(local_ctcp_buffer, str, sizeof(local_ctcp_buffer) - 2);
for (;;strlcat(local_ctcp_buffer, last, sizeof(local_ctcp_buffer) - 2))
{
if (split_CTCP(local_ctcp_buffer, the_ctcp, last))
break; /* All done! */
if (!*the_ctcp)
continue; /* Empty requests are ignored */
/*
* Apply some integrety rules:
* -- If we've already replied to a CTCP, ignore it.
* -- If user is ignoring sender, ignore it.
* -- If we're being flooded, ignore it.
* -- If CTCP was a global msg, ignore it.
*/
/*
* Yes, this intentionally ignores "unlimited" CTCPs like
* UTC and SED. Ultimately, we have to make sure that
* CTCP expansions dont overrun any buffers that might
* contain this string down the road. So by allowing up to
* 4 CTCPs, we know we cant overflow -- but if we have more
* than 40, it might overflow, and its probably a spam, so
* no need to shed tears over ignoring them. Also makes
* the sanity checking much simpler.
*/
if (!allow_ctcp_reply)
continue;
/*
* Check to see if the user is ignoring person.
* Or if we're suppressing a flood.
*/
if (flag == IGNORED || fflag == 1)
{
if (x_debug & DEBUG_CTCPS)
yell("CTCP from [%s] ignored", from);
allow_ctcp_reply = 0;
continue;
}
/*
* Check for CTCP flooding
*/
if (get_int_var(NO_CTCP_FLOOD_VAR))
{
if (time(NULL) - last_ctcp_parsed < 2)
{
/*
* This extends the flood protection until
* we dont get a CTCP for 2 seconds.
*/
last_ctcp_parsed = time(NULL);
allow_ctcp_reply = 0;
if (x_debug & DEBUG_CTCPS)
say("CTCP flood from [%s] ignored", from);
continue;
}
}
/*
* Check for global message
*/
if (*to == '$' || (*to == '#' && !im_on_channel(to, from_server)))
{
allow_ctcp_reply = 0;
continue;
}
/*
* Now its ok to parse the CTCP.
* First we remove the argument.
* XXX - CTCP spec says word delim MUST be space.
*/
ctcp_command = the_ctcp;
ctcp_argument = strchr(the_ctcp, ' ');
if (ctcp_argument)
*ctcp_argument++ = 0;
else
ctcp_argument = endstr(the_ctcp);
/* Set up the window level/logging */
if (im_on_channel(to, from_server))
l = message_from(to, LEVEL_CTCP);
else
l = message_from(from, LEVEL_CTCP);
/*
* Then we look for the correct CTCP.
*/
for (i = 0; i < NUMBER_OF_CTCPS; i++)
if (!strcmp(ctcp_command, ctcp_cmd[i].name))
break;
/*
* We didnt find it?
*/
if (i == NUMBER_OF_CTCPS)
{
/*
* Offer it to the user.
* Maybe they know what to do with it.
*/
if (do_hook(CTCP_REQUEST_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
{
if (do_hook(CTCP_LIST, "%s %s %s %s", from, to,
ctcp_command, ctcp_argument))
{
say("Unknown CTCP %s from %s to %s: %s%s",
ctcp_command, from, to,
*ctcp_argument ? ": " : empty_string,
ctcp_argument);
}
}
time(&last_ctcp_parsed);
allow_ctcp_reply = 0;
pop_message_from(l);
continue;
}
/*
* rfc1459_any_to_utf8 specifically ignores CTCPs, because
* recoding binary data (such as an encrypted message) would
* corrupt the message.
*
* So some CTCPs are "recodable" and some are not.
*
* The CTCP_NORECODE is set for any CTCPs which are NOT
* to be recoded prior to handling. These are the encryption
* CTCPS.
*
* All other CTCPs have not been recoded by the time they
* reach here, so we must do it here!
*/
if (!(ctcp_cmd[i].flag & CTCP_NORECODE))
{
/*
* We must recode to UTF8
*/
inbound_recode(from, from_server, to, ctcp_argument, &extra);
if (extra)
ctcp_argument = extra;
}
/*
* We did find it. Acknowledge it.
*/
ptr = NULL;
if (do_hook(CTCP_REQUEST_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
{
ptr = ctcp_cmd[i].func(ctcp_cmd + i, from,
to, ctcp_argument);
}
/*
* If this isnt an 'unlimited' CTCP, set up flood protection.
*
* No, this wont allow users to flood any more than they
* would normally. The UTC/SED gets converted into a
* regular privmsg body, which is flagged via FLOOD_PUBLIC.
*/
if (!(ctcp_cmd[i].flag & CTCP_NOLIMIT))
{
time(&last_ctcp_parsed);
allow_ctcp_reply = 0;
}
/*
* We've only gotten to this point if its a valid CTCP
* query and we decided to parse it.
*/
/*
* If its an ``INLINE'' CTCP, we paste it back in.
*/
if (ctcp_cmd[i].flag & CTCP_INLINE)
strlcat(local_ctcp_buffer, ptr ? ptr : empty_string, sizeof local_ctcp_buffer);
/*
* If its ``INTERESTING'', tell the user.
* Note that this isnt mutex with ``INLINE'' in theory,
* even though it is in practice. Dont use 'else' here.
*/
if (ctcp_cmd[i].flag & CTCP_TELLUSER)
{
if (do_hook(CTCP_LIST, "%s %s %s %s",
from, to, ctcp_command, ctcp_argument))
{
if (is_me(from_server, to))
say("CTCP %s from %s%s%s",
ctcp_command, from,
*ctcp_argument ? ": " : empty_string,
ctcp_argument);
else
say("CTCP %s from %s to %s%s%s",
ctcp_command, from, to,
*ctcp_argument ? ": " : empty_string,
ctcp_argument);
}
}
new_free(&extra);
new_free(&ptr);
pop_message_from(l);
}
in_ctcp_flag--;
/*
* 'str' is required to be BIG_BUFFER_SIZE + 1 or bigger per the API.
*/
strlcpy(str, local_ctcp_buffer, BIG_BUFFER_SIZE);
return str;
}
/*
* This is the back end to do_processes, saves some repeated code
*/
static void handle_filedesc (Process *proc, int *fd, int hook_nonl, int hook_nl)
{
char exec_buffer[IO_BUFFER_SIZE + 1];
ssize_t len;
int ofs;
const char *callback = NULL;
int hook = -1;
int l;
char logical_name[1024];
const char *utf8_text;
char *extra = NULL;
/* No buffering! */
switch ((len = dgets(*fd, exec_buffer, IO_BUFFER_SIZE, 0)))
{
case -1: /* Something died */
{
*fd = new_close(*fd);
if (proc->p_stdout == -1 && proc->p_stderr == -1)
proc->dumb = 1;
return; /* PUNT! */
}
case 0: /* We didnt get a full line */
{
/*
* XXX This is a hack. dgets() can return 0 for a line
* containing solely a newline, as well as a line that didn't
* have a newline. So we have to check to see if the line
* contains only a newline!
*/
if (exec_buffer[0] != '\n')
{
if (hook_nl == EXEC_LIST)
{
if (proc->stdoutpc && *proc->stdoutpc)
callback = proc->stdoutpc;
}
else if (hook_nl == EXEC_ERRORS_LIST)
{
if (proc->stderrpc && *proc->stderrpc)
callback = proc->stderrpc;
}
hook = hook_nonl;
break;
}
/* XXX HACK -- Line contains only a newline. */
*exec_buffer = 0;
/* FALLTHROUGH */
}
default: /* We got a full line */
{
if (hook_nl == EXEC_LIST)
{
if (proc->stdoutc && *proc->stdoutc)
callback = proc->stdoutc;
}
else if (hook_nl == EXEC_ERRORS_LIST)
{
if (proc->stderrc && *proc->stderrc)
callback = proc->stderrc;
}
hook = hook_nl;
break;
}
}
ofs = from_server;
from_server = proc->server;
if (proc->refnum)
l = message_setall(proc->refnum, NULL, LEVEL_OTHER);
else
l = message_from(NULL, LEVEL_OTHER);
proc->counter++;
while (len > 0 && (exec_buffer[len - 1] == '\n' ||
exec_buffer[len - 1] == '\r'))
exec_buffer[--len] = 0;
index_to_target(proc->index, logical_name, sizeof(logical_name));
utf8_text = inbound_recode(logical_name, proc->server, empty_string, exec_buffer, &extra);
if (proc->redirect)
redirect_text(proc->server, proc->who,
utf8_text, proc->redirect, 1);
if (callback)
call_lambda_command("EXEC", callback, utf8_text);
else if (proc->logical)
{
if ((do_hook(hook, "%s %s", proc->logical, utf8_text)))
if (!proc->redirect)
put_it("%s", utf8_text);
}
else
{
if ((do_hook(hook, "%d %s", proc->index, utf8_text)))
if (!proc->redirect)
put_it("%s", utf8_text);
}
new_free(&extra);
pop_message_from(l);
from_server = ofs;
}
/*
* got_initial_version_28: this is called when ircii gets the serial
* number 004 reply. We do this becuase the 004 numeric gives us the
* server name and version in an easy to use fashion, and doesnt
* rely on the syntax or construction of the 002 numeric.
*
* Hacked as neccesary by jfn, May 1995
*/
void got_initial_version_28 (const char *server, const char *version, const char *umodes)
{
/* Worthless 004 reply. Hope for the best! */
if (!server || !version || !umodes)
{
set_server_version(from_server, Server2_8);
set_server_version_string(from_server, "<none provided>");
set_server_itsname(from_server, get_server_name(from_server));
}
else
{
if (!strncmp(version, "2.8", 3))
{
if (strstr(version, "mu") || strstr(version, "me"))
set_server_version(from_server, Server_u2_8);
else
set_server_version(from_server, Server2_8);
}
else if (!strncmp(version, "2.9", 3))
set_server_version(from_server, Server2_9);
else if (!strncmp(version, "2.10", 4))
set_server_version(from_server, Server2_10);
else if (!strncmp(version, "u2.9", 4))
set_server_version(from_server, Server_u2_9);
else if (!strncmp(version, "u2.10", 4))
set_server_version(from_server, Server_u2_10);
else if (!strncmp(version, "u3.0", 4))
set_server_version(from_server, Server_u3_0);
else
set_server_version(from_server, Server2_8);
set_server_version_string(from_server, version);
set_server_itsname(from_server, server);
set_possible_umodes(from_server, umodes);
}
reconnect_all_channels();
server_did_rejoin_channels(from_server);
message_from(NULL, LOG_CRAP);
reinstate_user_modes();
if (never_connected)
{
never_connected = 0;
permit_status_update(1);
if (!ircrc_loaded)
load_ircrc();
if (default_channel)
{
e_channel("JOIN", default_channel, empty_string);
new_free(&default_channel);
}
}
else if (get_server_away(from_server))
set_server_away(from_server, get_server_away(from_server));
update_all_status();
do_hook(CONNECT_LIST, "%s %d %s", get_server_name(from_server),
get_server_port(from_server), get_server_itsname(from_server));
window_check_channels();
}
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_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);
}
/*
* This function is called by the three places that can effect a change
* on the state of a running process:
* 1) get_child_exit, which can mark a process as exited
* 2) do_processes, which can mark a child as being done with I/O
* 3) execcmd, which can mark a child as being done with I/O
*
* Any processes that are found to have both exited and having completed
* their I/O will be summarily destroyed.
*/
static void cleanup_dead_processes (void)
{
int i;
List *cmd,
*next;
Process *deadproc, *proc;
char *exit_info;
int old_from_server, l;
if (!process_list)
return; /* Nothing to do */
old_from_server = from_server;
for (i = 0; i < process_list_size; i++)
{
if (!(proc = process_list[i]))
continue;
/*
* We do not parse the process if it has not
* both exited and finished its io, UNLESS
* it has been disowned.
*/
if ((!proc->exited || !proc->dumb) && !proc->disowned)
continue; /* Not really dead yet */
deadproc = process_list[i];
process_list[i] = NULL;
/*
* First thing to do is fill out the exit information
*/
if (deadproc->logical)
{
size_t len = strlen(deadproc->logical) + 25;
exit_info = alloca(len);
snprintf(exit_info, len, "%s %d %d",
deadproc->logical, deadproc->termsig,
deadproc->retcode);
}
else
{
exit_info = alloca(40);
snprintf(exit_info, 32, "%d %d %d",
deadproc->index, deadproc->termsig, deadproc->retcode);
}
from_server = deadproc->server;
l = message_from(NULL, LEVEL_OTHER);
/*
* First thing we do is run any /wait %proc -cmd commands
*/
next = deadproc->waitcmds;
deadproc->waitcmds = NULL;
while ((cmd = next))
{
next = cmd->next;
call_lambda_command("WAITPROC", cmd->name, exit_info);
new_free(&cmd->name);
new_free((char **)&cmd);
}
/*
* Throw /on exec_exit
*/
if (do_hook(EXEC_EXIT_LIST, "%s", exit_info))
{
if (get_int_var(NOTIFY_ON_TERMINATION_VAR))
{
if (deadproc->termsig > 0 && deadproc->termsig < NSIG)
{
say("Process %d (%s) terminated "
"with signal %s (%d)",
deadproc->index, deadproc->name,
sys_siglist[deadproc->termsig],
deadproc->termsig);
}
else if (deadproc->disowned)
{
say("Process %d (%s) disowned",
deadproc->index, deadproc->name);
}
else
{
say("Process %d (%s) terminated "
"with return code %d",
deadproc->index, deadproc->name,
deadproc->retcode);
}
}
}
pop_message_from(l);
deadproc->p_stdin = new_close(deadproc->p_stdin);
deadproc->p_stdout = new_close(deadproc->p_stdout);
deadproc->p_stderr = new_close(deadproc->p_stderr);
new_free(&deadproc->name);
new_free(&deadproc->logical);
new_free(&deadproc->who);
new_free(&deadproc->redirect);
new_free(&deadproc->stdoutc);
new_free(&deadproc->stdoutpc);
new_free(&deadproc->stderrc);
new_free(&deadproc->stderrpc);
new_free((char **)&deadproc);
}
/*
* Resize away any dead processes at the end
*/
for (i = process_list_size - 1; i >= 0; i--)
{
if (process_list[i])
break;
}
if (process_list_size != i + 1)
{
process_list_size = i + 1;
RESIZE(process_list, Process, process_list_size);
}
from_server = old_from_server;
}
/*
* help_me: The big one. The help procedure that handles working out
* what was actually requested, sets up the paused topic list if it is
* needed, does pretty much all the hard work.
*/
static void help_me (char *topics, char *args)
{
char * ptr;
glob_t g;
int entries = 0,
cnt,
i,
cols;
Stat stat_buf;
char path[BIG_BUFFER_SIZE+1];
int help_paused_first_call = 0;
char * help_paused_path = (char *) 0;
char * help_paused_name = (char *) 0;
char * temp;
char tmp[BIG_BUFFER_SIZE+1];
char buffer[BIG_BUFFER_SIZE+1];
char * pattern = NULL;
strlcpy(help_topic_list, topics, sizeof help_topic_list);
ptr = get_string_var(HELP_PATH_VAR);
snprintf(path, sizeof path, "%s/%s", ptr, topics);
for (ptr = path; (ptr = strchr(ptr, ' '));)
*ptr = '/';
/*
* first we check access to the help dir, whinge if we can't, then
* work out we need to ask them for more help, else we check the
* args list, and do the stuff
*/
if (help_show_directory)
{
help_show_paused_topic(paused_topic, empty_string);
help_show_directory = 0;
}
finished_help_paging = 0;
if (access(path, R_OK|X_OK))
{
help_put_it(no_help, "*** Cannot access help directory!");
set_help_screen((Screen *) 0);
return;
}
this_arg = next_arg(args, &args);
if (!this_arg && *help_topic_list && get_int_var(HELP_PROMPT_VAR))
{
if ((temp = strrchr(help_topic_list, ' ')) != NULL)
*temp = '\0';
else
*help_topic_list = '\0';
snprintf(tmp, sizeof tmp, "%s%sHelp? ", help_topic_list, *help_topic_list ? " " : empty_string);
if (!dumb_mode)
add_wait_prompt(tmp, help_me, help_topic_list, WAIT_PROMPT_LINE, 1);
return;
}
if (!this_arg)
{
set_help_screen((Screen *) 0);
return;
}
create_help_window();
if (!help_window)
return;
/*
* This is just a bogus while loop which is intended to allow
* the user to do '/help alias expressions' without having to
* include a slash inbetween the topic and subtopic.
*
* If all goes well, we 'break' at the bottom of the loop.
*/
while (this_arg)
{
entries = 0;
if (!*this_arg)
help_topic(path, NULL);
if (strcmp(this_arg, "?") == 0)
{
this_arg = empty_string;
if (!dont_pause_topic)
dont_pause_topic = 1;
}
/*
* entry_size is set to the width of the longest help topic
* (adjusted for compression extensions, of course.)
*/
entry_size = 0;
/*
* Gather up the names of the files in the help directory.
*/
{
size_t size;
#ifndef HAVE_FCHDIR
char opath[MAXPATHLEN + 1];
getcwd(opath, MAXPATHLEN);
#else
int cwd = open(".", O_RDONLY);
#endif
size = strlen(path) + 2 + strlen(this_arg) + 3;
chdir(path);
pattern = alloca(size);
snprintf(pattern, size, "%s*", this_arg);
#ifdef GLOB_INSENSITIVE
bsd_glob(pattern, GLOB_INSENSITIVE, NULL, &g);
#else
bsd_glob(pattern, 0, NULL, &g);
#endif
#ifndef HAVE_FCHDIR
chdir(opath);
#else
fchdir(cwd);
close(cwd);
#endif
}
for (i = 0; i < g.gl_matchc; i++)
{
char *tmp2 = g.gl_pathv[i];
int len = strlen(tmp2);
if (!end_strcmp(tmp2, ".gz", 3))
len -= 3;
entry_size = (len > entry_size) ? len : entry_size;
}
/*
* Right here we need to check for an 'exact match'.
* An 'exact match' would be sitting in gl_pathv[0],
* and it is 'exact' if it is identical to what we are
* looking for, or if it is the same except that it has
* a compression extension on it
*/
if (g.gl_matchc > 1)
{
char *str1 = g.gl_pathv[0];
const char *str2 = this_arg;
int len1 = strlen(str1);
int len2 = strlen(str2);
if (len1 == len2 && !my_stricmp(str1, str2))
entries = 1;
else if (len1 - 3 == len2 && !my_strnicmp(str1, str2, len2) && !end_strcmp(str1, ".gz", 3))
entries = 1;
else if (len1 - 2 == len2 && !my_strnicmp(str1, str2, len2) && !end_strcmp(str1, ".Z", 2))
entries = 1;
else if (len1 - 2 == len2 && !my_strnicmp(str1, str2, len2) && !end_strcmp(str1, ".z", 2))
entries = 1;
}
if (!*help_topic_list)
dont_pause_topic = 1;
/* reformatted */
/*
* entries: -1 means something really died, 0 means there
* was no help, 1, means it wasn't a directory, and so to
* show the help file, and the default means to add the
* stuff to the paused topic list..
*/
if (!entries)
entries = g.gl_matchc;
switch (entries)
{
case -1:
{
help_put_it(no_help, "*** Error during help function: %s", strerror(errno));
set_help_screen(NULL);
if (help_paused_first_call)
{
help_topic(help_paused_path, help_paused_name);
help_paused_first_call = 0;
new_free(&help_paused_path);
new_free(&help_paused_name);
}
message_from(NULL, LOG_CRAP);
return;
}
case 0:
{
help_put_it(this_arg, "*** No help available on %s: Use ? for list of topics", this_arg);
if (!get_int_var(HELP_PROMPT_VAR))
{
set_help_screen(NULL);
break;
}
snprintf(tmp, sizeof tmp, "%s%sHelp? ", help_topic_list, *help_topic_list ? " " : empty_string);
if (!dumb_mode)
add_wait_prompt(tmp, help_me, help_topic_list, WAIT_PROMPT_LINE, 1);
if (help_paused_first_call)
{
help_topic(help_paused_path, help_paused_name);
help_paused_first_call = 0;
new_free(&help_paused_path);
new_free(&help_paused_name);
}
break;
}
case 1:
{
snprintf(tmp, sizeof tmp, "%s/%s", path, g.gl_pathv[0]);
stat(tmp, &stat_buf);
if (stat_buf.st_mode & S_IFDIR)
{
strlcpy(path, tmp, sizeof path);
if (*help_topic_list)
strlcat(help_topic_list, " ", sizeof help_topic_list);
strlcat(help_topic_list, g.gl_pathv[0], sizeof help_topic_list);
if (!(this_arg = next_arg(args, &args)))
{
help_paused_first_call = 1;
malloc_strcpy(&help_paused_path, path);
malloc_strcpy(&help_paused_name, g.gl_pathv[0]);
dont_pause_topic = -1;
this_arg = "?";
}
bsd_globfree(&g);
continue;
}
else
{
help_topic(path, g.gl_pathv[0]);
finished_help_paging = 0;
break;
}
}
default:
{
help_show_directory = 1;
strlcpy(paused_topic, help_topic_list, sizeof paused_topic);
help_pause_add_line("*** %s choices:", help_topic_list);
entry_size += 2;
cols = (current_term->TI_cols - 10) / entry_size;
strlcpy(buffer, empty_string, sizeof(buffer));
cnt = 0;
for (i = 0; i < entries; i++)
{
if (!end_strcmp(g.gl_pathv[i], ".gz", 3))
chop(g.gl_pathv[i], 3);
strlcat(buffer, g.gl_pathv[i], sizeof buffer);
/*
* Since we already know how many columns each
* line will contain, we check to see if we have
* accumulated that many entries. If we have, we
* output the line to the screen.
*/
if (++cnt == cols)
{
help_pause_add_line("%s", buffer);
*buffer = 0;
cnt = 0;
}
/*
* If we have not finished this line, then we have
* to pad the name length out to the expected width.
* 'entry_size' is the column width. We also have
* do adjust for compression extension.
*/
else
strextend(buffer, ' ', entry_size - strlen(g.gl_pathv[i]));
}
help_pause_add_line("%s", buffer);
if (help_paused_first_call)
{
help_topic(help_paused_path, help_paused_name);
help_paused_first_call = 0;
new_free(&help_paused_path);
new_free(&help_paused_name);
}
if (dont_pause_topic == 1)
{
help_show_paused_topic(paused_topic, empty_string);
help_show_directory = 0;
}
break;
}
}
/* end of reformatting */
bsd_globfree(&g);
break;
}
/*
* This one is for when there was never a topic and the prompt
* never got a topic.. and help_screen was never reset..
* phone, jan 1993.
*/
if (!*help_topic_list && finished_help_paging)
set_help_screen((Screen *) 0);
message_from(NULL, LOG_CRAP);
}
/*
* The main handler for those wacky NOTICE commands...
* This is as much like p_privmsg as i can get away with.
*/
void p_notice (const char *from, const char *comm, const char **ArgList)
{
const char *target, *message;
int level,
hook_type;
const char * flood_channel = NULL;
char * high;
PasteArgs(ArgList, 1);
if (!(target = ArgList[0]))
{ rfc1459_odd(from, comm, ArgList); return; }
if (!(message = ArgList[1]))
{ rfc1459_odd(from, comm, ArgList); return; }
set_server_doing_notice(from_server, 1);
sed = 0;
/* Do normal /CTCP reply handling */
/* XXX -- Casting "message" to (char *) is cheating. */
message = do_notice_ctcp(from, target, (char *)
#ifdef HAVE_INTPTR_T
(intptr_t)
#endif
message);
if (!*message) {
set_server_doing_notice(from_server, 0);
return;
}
/* Check to see if it is a "Server Notice" */
if ((!from || !*from) || !strcmp(get_server_itsname(from_server), from))
{
parse_local_server_notice(from, target, message);
set_server_doing_notice(from_server, 0);
return;
}
/* For pesky prefix-less NOTICEs substitute the server's name */
if (!from || !*from)
from = get_server_name(from_server);
/*
* Note that NOTICEs from servers are not "server notices" unless
* the target is not a channel (ie, it is sent to us). Any notice
* that is sent to a channel is a normal NOTICE, notwithstanding
* _who_ sent it.
*/
if (is_channel(target) && im_on_channel(target, from_server))
{
flood_channel = target;
hook_type = PUBLIC_NOTICE_LIST;
}
else if (!is_me(from_server, target))
{
flood_channel = NULL;
hook_type = NOTICE_LIST;
}
else
{
flood_channel = NULL;
hook_type = NOTICE_LIST;
target = from;
}
/* Check for /ignore's */
switch (check_ignore_channel(from, FromUserHost, target, IGNORE_NOTICES))
{
case IGNORED:
set_server_doing_notice(from_server, 0);
return;
case HIGHLIGHTED:
high = highlight_char;
break; /* oops! */
default:
high = empty_string;
}
/* Let the user know if it is an encrypted notice */
/* Note that this is always hooked, even during a flood */
if (sed)
{
int do_return = 1;
sed = 0;
level = set_lastlog_msg_level(LOG_NOTICE);
message_from(target, LOG_NOTICE);
if (do_hook(ENCRYPTED_NOTICE_LIST, "%s %s %s",
from, target, message))
do_return = 0;
set_lastlog_msg_level(level);
message_from(NULL, LOG_CRAP);
if (do_return) {
set_server_doing_notice(from_server, 0);
return;
}
}
if (new_check_flooding(from, FromUserHost, flood_channel,
message, NOTICE_FLOOD)) {
set_server_doing_notice(from_server, 0);
return;
}
/* Beep the user if they asked us to */
if (beep_on_level & LOG_NOTICE)
beep_em(1);
/* Go ahead and throw it to the user */
level = set_lastlog_msg_level(LOG_NOTICE);
message_from(target, LOG_NOTICE);
if (do_hook(GENERAL_NOTICE_LIST, "%s %s %s", from, target, message))
{
if (hook_type == NOTICE_LIST)
{
if (do_hook(hook_type, "%s %s", from, message))
put_it("%s-%s-%s %s", high, from, high, message);
}
else
{
if (do_hook(hook_type, "%s %s %s", from, target, message))
put_it("%s-%s:%s-%s %s", high, from, target, high,
message);
}
}
/* Clean up and go home. */
set_lastlog_msg_level(level);
message_from(NULL, LOG_CRAP);
set_server_doing_notice(from_server, 0);
/* Alas, this is not protected by protocol enforcement. :( */
notify_mark(from_server, from, 1, 0);
}
