void reset_clock (const void *stuff)
{
if (x_debug & DEBUG_BROKEN_CLOCK)
reset_broken_clock();
else if (get_int_var(METRIC_TIME_VAR))
reset_metric_clock();
else
reset_standard_clock();
update_all_status();
cursor_to_input();
}
static void p_kill(char *from, char **ArgList)
{
char sc[20];
int port;
int local = 0;
port = get_server_port(from_server);
if (ArgList[1] && strstr(ArgList[1], get_server_name(from_server)))
if (!strchr(from, '.'))
local = 1;
snprintf(sc, 19, "+%i %d", from_server, port);
close_server(from_server, empty_str);
clean_whois_queue();
window_check_servers();
set_input_prompt(curr_scr_win, get_string_var(INPUT_PROMPT_VAR), 0);
if (strchr(from, '.')) {
say("Server [%s] has rejected you (probably due to a nick collision)", from);
t_parse_command("SERVER", NULL);
} else {
if (local && get_int_var(NEXT_SERVER_ON_LOCAL_KILL_VAR)) {
int i = from_server + 1;
if (i >= number_of_servers)
i = 0;
snprintf(sc, 19, "+%i", i);
from_server = -1;
}
if (do_hook(DISCONNECT_LIST, "Killed by %s (%s)", from, ArgList[1] ? ArgList[1] : "(No Reason Given)"))
put_it("%s",
convert_output_format(get_format(FORMAT_KILL_FSET), "%s %s", update_clock(GET_TIME),
ArgList[1] ? ArgList[1] : "You have been Killed"));
if (get_int_var(AUTO_RECONNECT_VAR))
t_parse_command("SERVER", NULL);
}
update_all_status(curr_scr_win, NULL, 0);
}
/*
* banner: This returns in a static string of either "xxx" where
* xxx is the current numeric, or "***" if SHOW_NUMBERS is OFF
*/
const char * banner (void)
{
static char thing[80];
char *str;
if (current_numeric > 0 && get_int_var(SHOW_NUMERICS_VAR))
snprintf(thing, sizeof thing, "%3.3u", current_numeric);
else if ((str = get_string_var(BANNER_VAR)))
{
if (get_int_var(BANNER_EXPAND_VAR))
{
char *foo = expand_alias(str, empty_string);
strlcpy(thing, foo, sizeof thing);
new_free(&foo);
}
else
strlcpy(thing, str, sizeof thing);
}
else
*thing = 0;
return (thing);
}
void check_hack(char *nick, ChannelList *channel, NickList *ThisNick, char *from)
{
#ifdef WANT_USERLIST
UserList *userptr = NULL;
ShitList *shitptr = NULL;
#endif
WhowasList *check_op = NULL;
int flag;
if (from && *from && !strchr(from, '.'))
return;
if (!channel || !are_you_opped(channel->channel) || !nick || !ThisNick || wild_match(nick, get_server_nickname(from_server)))
return;
if (!(flag = get_cset_int_var(channel->csets, HACKING_CSET)))
return;
if ((ThisNick->sent_deop) && (now - ThisNick->sent_deop_time < 10))
return;
#ifdef WANT_USERLIST
userptr = ThisNick->userlist;
shitptr = ThisNick->shitlist;
#endif
check_op = check_whosplitin_buffer(nick, ThisNick->host, channel->channel, 0);
if (check_op && check_op->has_ops)
return;
#ifdef WANT_USERLIST
if ( !userptr || (userptr && !check_channel_match(userptr->channels, channel->channel)) ||
(shitptr && check_channel_match(shitptr->channels, channel->channel)))
#endif
{
switch(flag)
{
case 1:
case 3:
if (is_chanop(channel->channel, nick))
add_mode(channel, "o", 0, nick, NULL, get_int_var(NUM_OPMODES_VAR));
ThisNick->sent_deop++;
ThisNick->sent_deop_time = now;
case 2:
if (flag != 1)
bitchsay("NetHack detected on %s by %s!%s", channel->channel, nick, ThisNick->host);
case 0:
default:
break;
}
}
}
void do_log(int flag, char *logfile, FILE **fp)
{
#ifdef PUBLIC_ACCESS
bitchsay("This command has been disabled on a public access system");
return;
#else
time_t t = now;
if (flag)
{
if (*fp)
say("Logging is already on");
else
{
if (!logfile)
return;
if (!(logfile = expand_twiddle(logfile)))
{
say("SET LOGFILE: No such user");
return;
}
if ((*fp = fopen(logfile, get_int_var(APPEND_LOG_VAR)?"a":"w")) != NULL)
{
say("Starting logfile %s", logfile);
chmod(logfile, S_IREAD | S_IWRITE);
fprintf(*fp, "IRC log started %.24s\n", ctime(&t));
fflush(*fp);
}
else
{
say("Couldn't open logfile %s: %s", logfile, strerror(errno));
*fp = NULL;
}
new_free(&logfile);
}
}
else
{
if (*fp)
{
fprintf(*fp, "IRC log ended %.24s\n", ctime(&t));
fflush(*fp);
fclose(*fp);
*fp = NULL;
say("Logfile ended");
}
}
#endif
}
void reset_clock (void *stuff)
{
char * sclock;
if (x_debug & DEBUG_BROKEN_CLOCK)
reset_broken_clock();
else if (get_int_var(METRIC_TIME_VAR))
reset_metric_clock();
else
reset_standard_clock();
sclock = get_string_var(STATUS_CLOCK_VAR);
if (sclock && *sclock)
update_all_status();
}
static void p_invite(char *from, char **ArgList)
{
char *high;
switch (check_ignore(from, FromUserHost, ArgList[1] ? ArgList[1] : NULL, IGNORE_INVITES, NULL)) {
case IGNORED:
if (get_int_var(SEND_IGNORE_MSG_VAR))
send_to_server(SERVER(from_server), "NOTICE %s :%s is ignoring you", from, get_server_nickname(from_server));
return;
case HIGHLIGHTED:
high = highlight_char;
break;
default:
high = empty_str;
break;
}
if (ArgList[0] && ArgList[1]) {
struct channel *chan = NULL;
struct whowas_chan_list *w_chan = NULL;
message_from(from, LOG_CRAP);
malloc_strcpy(&invite_channel, ArgList[1]);
if (check_flooding(from, INVITE_FLOOD, ArgList[1], NULL) && do_hook(INVITE_LIST, "%s %s", from, ArgList[1])) {
put_it("%s", convert_output_format(get_format(FORMAT_INVITE_FSET), "%s %s %s", update_clock(GET_TIME), from, ArgList[1]));
}
if (!(chan = lookup_channel(invite_channel, from_server, 0)))
if ((w_chan = check_whowas_chan_buffer(invite_channel, 0)))
chan = w_chan->channellist;
if (chan && get_int_var(AUTO_REJOIN_VAR) && invite_channel) {
if (!in_join_list(invite_channel, from_server))
send_to_server(SERVER(from_server), "JOIN %s %s", invite_channel, ArgList[2] ? ArgList[2] : "");
}
malloc_strcpy(&recv_nick, from);
}
}
int delay_opz (void *arg, char *sub)
{
char * args = (char *)arg;
char * from = NULL;
char * host = NULL;
char * channel = NULL;
char * mode = NULL;
char * serv_num = NULL;
ChannelList *chan = NULL;
int this_server = from_server;
char *p = (char *) arg; /* original args unmodified so we can free them */
channel = next_arg(args, &args);
from = next_arg(args, &args);
host = next_arg(args, &args);
mode = next_arg(args, &args);
if ((serv_num = next_arg(args, &args)))
this_server = my_atol(serv_num);
chan = lookup_channel(channel, this_server, 0);
if (chan && is_on_channel(channel, this_server, from) && chan->chop)
{
NickList *nick;
for (nick = next_nicklist(chan, NULL); nick; nick = next_nicklist(chan, nick))
{
if (!my_stricmp(nick->nick, from))
{
if (!my_stricmp(host, nick->host))
break;
else
{
new_free(&p); new_free(&sub);
return 0;
}
}
}
if (nick && ((!nick_isop(nick) && *mode == 'o') || (!nick_isvoice(nick) && *mode == 'v')))
{
my_send_to_server(this_server, "MODE %s +%s %s", channel, mode, from);
if (get_int_var(SEND_OP_MSG_VAR))
my_send_to_server(this_server, "NOTICE %s :You have been delay Auto-%s'd", from, *mode == 'o'? "op":"voice");
}
}
new_free(&p); new_free(&sub);
return 0;
}
/*
* delete_process: Removes the process specifed by index from the process
* list. The does not kill the process, close the descriptors, or any such
* thing. It only deletes it from the list. If appropriate, this will also
* shrink the list as needed
*/
static int delete_process(int process)
{
int flag;
if (process_list) {
if (process >= process_list_size)
return (-1);
if (process_list[process]) {
Process *dead;
dead = process_list[process];
process_list[process] = NULL;
if (process == (process_list_size - 1)) {
int i;
for (i = process_list_size - 1; process_list_size; process_list_size--, i--) {
if (process_list[i])
break;
}
if (process_list_size)
process_list = new_realloc(process_list, Process *, 0, process_list_size);
else {
new_free(&process_list);
process_list = NULL;
}
}
if (dead->logical)
flag = do_hook(EXEC_EXIT_LIST, "%s %d %d", dead->logical, dead->termsig, dead->retcode);
else
flag = do_hook(EXEC_EXIT_LIST, "%d %d %d", process, dead->termsig, dead->retcode);
if (flag) {
if (get_int_var(NOTIFY_ON_TERMINATION_VAR)) {
if (dead->termsig)
say("Process %d (%s) terminated with signal %s (%d)", process, dead->name, sys_siglist[dead->termsig],
dead->termsig);
else
say("Process %d (%s) terminated with return code %d", process, dead->name, dead->retcode);
}
}
new_free(&dead->name);
new_free(&dead->logical);
new_free(&dead->who);
new_free(&dead->redirect);
new_free(&dead);
return (0);
}
void check_shit(ChannelList *chan)
{
ShitList *Bans;
if (!chan || !chan->chop || !shitlist_list || chan->server <= -1 || !get_cset_int_var(chan->csets, SHITLIST_CSET))
return;
if (!check_channel_match(get_string_var(PROTECT_CHANNELS_VAR), chan->channel))
return;
for (Bans = shitlist_list; Bans; Bans = Bans->next)
{
/* this is a permanent ban */
if (!check_channel_match(Bans->channels, chan->channel))
continue;
if ((Bans->level == 4) && !ban_is_on_channel(Bans->filter, chan) && !eban_is_on_channel(Bans->filter, chan))
add_mode(chan, "b", 1, Bans->filter, NULL, get_int_var(NUM_BANMODES_VAR));
}
flush_mode_all(chan);
}
/*
* display_msg: handles the displaying of messages from the variety of
* possible formats that the irc server spits out.
*
* Simplified some time in 1996.
* -- called by more than one place.
*/
static void display_msg (const char *from, const char *comm, const char **ArgList)
{
char *ptr = NULL;
const char *rest;
int drem;
/* XXX -
* ArgList[0] was passed to who_from() which means we need to
* either reset who_from() with our own copy, or not detokenize
* ArgList[0], because this breaks channel targeting!
*/
if (!(rest = PasteArgs(ArgList, 0)))
{ rfc1459_odd(from, comm, ArgList); return; }
if (from && (my_strnicmp(get_server_itsname(from_server), from,
strlen(get_server_itsname(from_server))) == 0))
from = NULL;
/* This fix by SrfRog, again by |Rain| */
if (ptr && ptr > rest && ptr[-1] == ' ') /* per RFC 1459 */
*ptr++ = 0;
else
ptr = NULL;
drem = (from) && (!get_int_var(SUPPRESS_FROM_REMOTE_SERVER_VAR));
/*
* This handles all the different cases of server messages.
* If you dont believe me, try it out. :P
*
* There are 16 distinct possibilities, since there are 4
* independant variables. In practice only about 6 to 8 of
* the possibilities are used.
*/
put_it("%s %s%s%s%s%s%s%s",
banner(),
strlen(rest) ? rest : empty_string,
strlen(rest) && ptr ? ":" : empty_string,
strlen(rest) ? space : empty_string,
ptr ? ptr : empty_string,
drem ? "(from " : empty_string,
drem ? from : empty_string,
drem ? ")" : empty_string
);
}
/*
* 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;
}
/*
* input_add_character: adds the character c to the input buffer, repecting
* the current overwrite/insert mode status, etc
*/
void input_add_character(char c, char *unused)
{
int display_flag = NO_UPDATE;
cursor_to_input();
if (THIS_POS < INPUT_BUFFER_SIZE) {
if (get_int_var(INSERT_MODE_VAR)) {
if (THIS_CHAR) {
char *ptr = NULL;
ptr = strdup(&(THIS_CHAR));
THIS_CHAR = c;
NEXT_CHAR = 0;
ADD_TO_INPUT(ptr);
free(ptr);
if (term_insert(c)) {
term_putchar(c);
if (NEXT_CHAR)
display_flag = UPDATE_FROM_CURSOR;
else
display_flag = NO_UPDATE;
}
} else {
THIS_CHAR = c;
NEXT_CHAR = 0;
term_putchar(c);
}
} else {
if (THIS_CHAR == 0)
NEXT_CHAR = 0;
THIS_CHAR = c;
term_putchar(c);
}
THIS_POS++;
update_input(display_flag);
}
if (in_completion == STATE_COMPLETE && c == ' ' && input_lastmsg) {
new_free(&input_lastmsg);
*new_nick = 0;
in_completion = STATE_NORMAL;
}
}
static void reset_standard_clock (void)
{
static int min = -1;
static int hour = -1;
Timeval tv;
struct tm time_val;
time_t hideous;
/*
* Every time /set clock_interval goes off this function calls
* localtime() to update $Z. Localtime() is very expensive, so
* if you /set clock_interval too low you will use a lot of cpu.
*/
get_time(&tv);
hideous = tv.tv_sec;
time_val = *localtime(&hideous);
if (time_format) /* XXX Bogus XXX */
strftime(current_clock, sizeof current_clock,
time_format, &time_val);
else if (get_int_var(CLOCK_24HOUR_VAR))
strftime(current_clock, sizeof current_clock,
strftime_24hour, &time_val);
else
strftime(current_clock, sizeof current_clock,
strftime_12hour, &time_val);
/*
* Either way we only update /on timer and /on idle every minute.
*/
if ((time_val.tm_min != min) || (time_val.tm_hour != hour))
{
int old_server = from_server;
hour = time_val.tm_hour;
min = time_val.tm_min;
from_server = primary_server;
do_hook(TIMER_LIST, "%02d:%02d", hour, min);
do_hook(IDLE_LIST, "%ld", (tv.tv_sec - idle_time.tv_sec) / 60);
from_server = old_server;
}
}
void get_flood_val(ChannelList *chan, int type, int *flood_count, int *flood_rate)
{
*flood_count = get_int_var(FLOOD_AFTER_VAR);
*flood_rate = get_int_var(FLOOD_RATE_VAR);
if (chan)
{
switch(type)
{
case JOIN_FLOOD:
*flood_count = get_cset_int_var(chan->csets, KICK_ON_JOINFLOOD_CSET);
*flood_rate = get_cset_int_var(chan->csets, JOINFLOOD_TIME_CSET);
break;
case PUBLIC_FLOOD:
*flood_count = get_cset_int_var(chan->csets, KICK_ON_PUBFLOOD_CSET);
*flood_rate = get_cset_int_var(chan->csets, PUBFLOOD_TIME_CSET);
break;
case NICK_FLOOD:
*flood_count = get_cset_int_var(chan->csets, KICK_ON_NICKFLOOD_CSET);
*flood_rate = get_cset_int_var(chan->csets, NICKFLOOD_TIME_CSET);
break;
case KICK_FLOOD:
*flood_count = get_cset_int_var(chan->csets, KICK_ON_KICKFLOOD_CSET);
*flood_rate = get_cset_int_var(chan->csets, KICKFLOOD_TIME_CSET);
break;
case DEOP_FLOOD:
*flood_count = get_cset_int_var(chan->csets, KICK_ON_DEOPFLOOD_CSET);
*flood_rate = get_cset_int_var(chan->csets, DEOPFLOOD_TIME_CSET);
break;
default:
break;
}
}
else
{
switch(type)
{
case CDCC_FLOOD:
*flood_count = get_int_var(CDCC_FLOOD_AFTER_VAR);
*flood_rate = get_int_var(CDCC_FLOOD_RATE_VAR);
break;
case CTCP_FLOOD:
*flood_count = get_int_var(CTCP_FLOOD_AFTER_VAR);
*flood_rate = get_int_var(CTCP_FLOOD_RATE_VAR);
case CTCP_ACTION_FLOOD:
default:
break;
}
}
}
/*
* check_process_limits: checks each running process to see if it's reached
* the user selected maximum number of output lines. If so, the processes is
* effectively killed
*/
void check_process_limits(void)
{
int limit;
int i;
Process *proc;
if ((limit = get_int_var(SHELL_LIMIT_VAR)) && process_list) {
for (i = 0; i < process_list_size; i++) {
if ((proc = process_list[i]) != NULL) {
if (proc->counter >= limit) {
proc->p_stdin = exec_close(proc->p_stdin);
proc->p_stdout = exec_close(proc->p_stdout);
proc->p_stderr = exec_close(proc->p_stderr);
if (proc->exited)
delete_process(i);
}
}
}
}
}
/*
* try to negotiate a SOCKS4 connection.
*
*/
int socks4_connect(int s, int portnum, struct sockaddr_in *server)
{
struct _sock_connect {
char version;
char type;
unsigned short port;
unsigned long address;
char username[NAME_LEN+1];
} sock4_connect;
char socksreq[10];
char *p;
int red;
memset(&sock4_connect, 0, sizeof(sock4_connect));
sock4_connect.version = SOCKS4_VERSION;
sock4_connect.type = SOCKS_CONNECT;
sock4_connect.port = server->sin_port;
strncpy(sock4_connect.username, socks_user? socks_user: getenv("USER") ? getenv("USER") : username, NAME_LEN);
p = inet_ntoa(server->sin_addr);
sock4_connect.address = inet_addr(p);
if ((red = write(s, &sock4_connect, 8 + strlen(sock4_connect.username) + 1)) == -1)
{
bitchsay("Cannot write to socks proxy: %s", strerror(errno));
return 0;
}
alarm(get_int_var(CONNECT_TIMEOUT_VAR));
if ((red = read(s, socksreq, 8)) == -1)
{
alarm(0);
bitchsay("Cannot read from socks proxy: %s", strerror(errno));
return 0;
}
alarm(0);
if (socksreq[1] != 90)
{
bitchsay("Cannot connect to SOCKS4 proxy: %s", socks4_error(socksreq[1]));
return 0;
}
return 1;
}
static void reset_standard_clock (void)
{
static int min = -1;
static int hour = -1;
Timeval tv;
struct tm time_val;
time_t hideous;
/*
* This is cheating because we only call localtime() once per minute.
* This implicitly assumes that you only want to get the localtime
* info once every minute, which we do. If you wanted to get it every
* second (which we dont), you DONT WANT TO DO THIS!
*/
get_time(&tv);
hideous = tv.tv_sec;
time_val = *localtime(&hideous);
if (time_format) /* XXX Bogus XXX */
strftime(current_clock, sizeof current_clock,
time_format, &time_val);
else if (get_int_var(CLOCK_24HOUR_VAR))
strftime(current_clock, sizeof current_clock,
strftime_24hour, &time_val);
else
strftime(current_clock, sizeof current_clock,
strftime_12hour, &time_val);
if ((time_val.tm_min != min) || (time_val.tm_hour != hour))
{
int old_server = from_server;
hour = time_val.tm_hour;
min = time_val.tm_min;
from_server = primary_server;
do_hook(TIMER_LIST, "%02d:%02d", hour, min);
do_hook(IDLE_LIST, "%ld", (tv.tv_sec - idle_time.tv_sec) / 60);
from_server = old_server;
}
}
/*
* show_help: show's either a page of text from a help_fp, or the whole
* thing, depending on the value of HELP_PAGER_VAR. If it gets to the end,
* (in either case it will eventally), it closes the file, and returns 0
* to indicate this.
*
* -- This doesn't need to fiddle with 'to_window' -- help_put_it does
* all that for us. (hop, 09/23/2003)
*/
static int show_help (Window *window, char *name)
{
int rows = -1;
char line[256];
if (!help_fp)
return 0;
if (get_int_var(HELP_PAGER_VAR))
{
if (help_window)
rows = help_window->display_size;
else
rows = current_window->display_size;
}
while (rows)
{
if (!fgets(line, 255, help_fp))
{
fclose(help_fp);
help_fp = NULL;
return 0;
}
if (*(line + strlen(line) - 1) == '\n')
*(line + strlen(line) - 1) = (char) 0;
/*
* This is for compatability with ircII-4.4
*/
if (*line == '!' || *line == '#')
continue;
help_put_it(name, "%s", line);
rows--;
}
return (1);
}
/*
* This is a watchdog timer that checks to see when we're idle enough to
* turn on CPU SAVER mode. The above timers may honor what we do here but
* they're not required to.
*/
int cpu_saver_timer (void *schedule_only)
{
double interval;
double been_idlin;
if (cpu_saver)
return 0;
get_time(&now);
been_idlin = time_diff(idle_time, now);
interval = get_int_var(CPU_SAVER_AFTER_VAR) * 60;
if (interval < 1)
return 0;
if (been_idlin > interval)
cpu_saver_on(0, NULL);
else
add_timer(1, cpu_saver_timeref, interval - been_idlin,
1, cpu_saver_timer, NULL, NULL, -1);
return 0;
}
/*
* reset_nickname: when the server reports that the selected nickname is not
* a good one, it gets reset here.
*/
static void
reset_nickname(u_char *from)
{
u_char server_num[10];
const int from_server = get_from_server();
if (already_doing_reset_nickname ||
is_server_connected(from_server) ||
!server_get_attempting_to_connect(from_server))
return;
say("You have specified an illegal nickname");
if (!term_basic() && !get_int_var(NO_ASK_NICKNAME_VAR))
{
already_doing_reset_nickname = 1;
say("Please enter your nickname");
snprintf(CP(server_num), sizeof server_num, "%d", parsing_server());
add_wait_prompt(UP("Nickname: "), nickname_sendline, server_num,
WAIT_PROMPT_LINE);
}
update_all_status();
}
void print_funny_names(char *line)
{
register char *t;
int count = 0;
char buffer[BIG_BUFFER_SIZE+1];
char special = '\0';
int cols = get_int_var(NAMES_COLUMNS_VAR);
if (!cols)
cols = 1;
if (line && *line)
{
*buffer = 0;
t = next_arg(line, &line);
do {
if (!count && fget_string_var(FORMAT_NAMES_BANNER_FSET))
strcpy(buffer, convert_output_format(fget_string_var(FORMAT_NAMES_BANNER_FSET), NULL, NULL));
if (*t == '@' || *t == '+' || *t == '~' || *t == '-')
{
special = *t;
if (special == '+')
strcat(buffer, convert_output_format(fget_string_var(FORMAT_NAMES_VOICECOLOR_FSET),"%c %s", special, ++t));
else
strcat(buffer, convert_output_format(fget_string_var(FORMAT_NAMES_OPCOLOR_FSET),"%c %s", special, ++t));
}
else
strcat(buffer, convert_output_format(fget_string_var(FORMAT_NAMES_NICKCOLOR_FSET), "$ %s", t));
strcat(buffer, space);
if (count++ >= (cols - 1))
{
put_it("%s", buffer);
*buffer = 0;
count = 0;
}
} while ((t = next_arg(line, &line)));
if (buffer)
put_it("%s", buffer);
}
}
void mail_systimer (void)
{
int x;
switch ((x = get_int_var(MAIL_VAR)))
{
case 1:
checkmail->level1();
break;
case 2:
checkmail->level2();
break;
case 3:
checkmail->level3();
break;
default:
panic("mail_systimer called with set mail %d", x);
}
update_all_status();
cursor_to_input();
return;
}
/*
* do_processes: This is called from the main io() loop to handle any
* pending /exec'd events. All this does is call handle_filedesc() on
* the two reading descriptors. If an EOF is asserted on either, then they
* are closed. If EOF has been asserted on both, then we mark the process
* as being "dumb". Once it is reaped (exited), it is expunged.
*/
void do_processes (fd_set *rd, fd_set *wd)
{
int i;
int limit;
if (!process_list)
return;
limit = get_int_var(SHELL_LIMIT_VAR);
for (i = 0; i < process_list_size; i++)
{
Process *proc = process_list[i];
if (!proc)
continue;
if (proc->p_stdout != -1 && FD_ISSET(proc->p_stdout, rd))
{
FD_CLR(proc->p_stdout, rd);
handle_filedesc(proc, &proc->p_stdout,
EXEC_PROMPT_LIST, EXEC_LIST);
}
if (proc->p_stderr != -1 && FD_ISSET(proc->p_stderr, rd))
{
FD_CLR(proc->p_stderr, rd);
handle_filedesc(proc, &proc->p_stderr,
EXEC_PROMPT_LIST, EXEC_ERRORS_LIST);
}
if (limit && proc->counter >= limit)
ignore_process(proc->index);
}
/* Clean up any (now) dead processes */
cleanup_dead_processes();
}
void sync_shitlist(ShitList *added, int type)
{
ChannelList *chan;
NickList *nick;
int i;
char tmp[BIG_BUFFER_SIZE+1];
char *check;
for (i = 0; i < server_list_size(); i ++)
{
for (chan = get_server_channels(i); chan; chan = chan->next)
{
for (nick = next_nicklist(chan, NULL); nick; nick = next_nicklist(chan, nick))
{
check = clear_server_flags(nick->host);
sprintf(tmp, "%s!%s", nick->nick, check);
if (wild_match(added->filter, tmp))
{
if (type)
{
nick->shitlist = added;
check_auto(chan->channel, nick, chan);
}
else
{
BanList *b = NULL;
nick->shitlist = NULL;
if ((b = ban_is_on_channel(tmp, chan)) && !eban_is_on_channel(tmp, chan))
add_mode(chan, "b", 0, b->ban, NULL, get_int_var(NUM_BANMODES_VAR));
}
}
}
flush_mode_all(chan);
}
}
}
void do_log(int flag, char *logfile, FILE ** fp)
{
time_t t = time(NULL);
if (flag) {
if (*fp)
say("Logging is already on");
else {
if (!logfile)
return;
if (!(logfile = expand_twiddle(logfile))) {
say("SET LOGFILE: No such user");
return;
}
if ((*fp = fopen(logfile, get_int_var(APPEND_LOG_VAR) ? "a" : "w")) != NULL) {
say("Starting logfile %s", logfile);
chmod(logfile, S_IREAD | S_IWRITE);
fprintf(*fp, "IRC log started %.24s\n", ctime(&t));
fflush(*fp);
} else {
say("Couldn't open logfile %s: %s", logfile, strerror(errno));
*fp = NULL;
}
new_free(&logfile);
}
} else {
if (*fp) {
fprintf(*fp, "IRC log ended %.24s\n", ctime(&t));
fflush(*fp);
fclose(*fp);
*fp = NULL;
say("Logfile ended");
}
}
}
void io (const char *what)
{
static int first_time = 1;
long clock_timeout = 0,
timer_timeout = 0,
real_timeout = 0;
static struct timeval my_now,
my_timer,
*time_ptr = &my_timer;
int hold_over,
rc;
fd_set rd,
wd;
get_time(&my_now);
now = my_now.tv_sec;
/* CHECK FOR CPU SAVER MODE */
if (!cpu_saver && get_int_var(CPU_SAVER_AFTER_VAR))
if (now - idle_time > get_int_var(CPU_SAVER_AFTER_VAR) * 60)
cpu_saver_on(0, NULL);
rd = readables;
wd = writables;
FD_ZERO(&wd);
FD_ZERO(&rd);
set_screens(&rd, &wd);
set_server_bits(&rd, &wd);
set_process_bits(&rd);
set_socket_read(&rd, &wd);
icmp_sockets(&rd, &wd);
#if defined(WANT_THREAD)
#ifdef WANT_NSLOOKUP
set_dns_output_fd(&rd);
#endif
#ifdef WANT_PTEST
set_ptest_output_fd(&rd);
#endif
#ifdef WANT_MP3PLAYER
set_mp3_output_fd(&rd);
#endif
# if defined(GTK)
if (tgtk_okay())
tgtk_set_output_fd(&rd);
# endif
#endif
clock_timeout = (timeout_select - (my_now.tv_sec % timeout_select)) * 1000;
if (cpu_saver && get_int_var(CPU_SAVER_EVERY_VAR))
clock_timeout += (get_int_var(CPU_SAVER_EVERY_VAR) - 1) * 60000;
timer_timeout = TimerTimeout();
if ((hold_over = unhold_windows()))
real_timeout = 0;
else if (timer_timeout <= clock_timeout)
real_timeout = timer_timeout;
else
real_timeout = clock_timeout;
if (real_timeout == -1)
time_ptr = NULL;
else
{
time_ptr->tv_sec = real_timeout / 1000;
time_ptr->tv_usec = ((real_timeout % 1000) * 1000);
}
/* GO AHEAD AND WAIT FOR SOME DATA TO COME IN */
switch ((rc = new_select(&rd, &wd, time_ptr)))
{
case 0:
break;
case -1:
{
/* if we just got a sigint */
first_time = 0;
if (cntl_c_hit)
edit_char('\003');
else if (errno && errno != EINTR)
{
int ii = 0;
fd_set rd1, wd1;
char ii_buff_r[500];
char ii_buff_w[500];
int ii_r[FD_SETSIZE];
int ii_w[FD_SETSIZE];
yell("Select failed with [%d:%s]", errno, strerror(errno));
/* Reseed fd_sets so we can dig further */
yell("Packing fd_sets... Dump of fd's set in fd_set");
ii_buff_r[0] = '\0';
ii_buff_w[0] = '\0';
for (ii = 0; ii < FD_SETSIZE; ii++) {
ii_r[ii] = 0;
ii_w[ii] = 0;
}
FD_ZERO(&wd1);
FD_ZERO(&rd1);
set_screens(&rd1, &wd1);
set_server_bits(&rd1, &wd1);
set_process_bits(&rd1);
set_socket_read(&rd1, &wd1);
icmp_sockets(&rd1, &wd1);
#if defined(WANT_THREAD)
#ifdef WANT_NSLOOKUP
set_dns_output_fd(&rd1);
#endif
#ifdef WANT_PTEST
set_ptest_output_fd(&rd1);
#endif
#ifdef WANT_MP3PLAYER
set_mp3_output_fd(&rd1);
#endif
# if defined(GTK)
if (tgtk_okay())
tgtk_set_output_fd(&rd1);
# endif
#endif
for (ii = 0; ii <= global_max_fd; ii++) {
fd_set rblah, wblah;
memcpy(&rblah, &rd1, sizeof(fd_set));
FD_SET(ii, &rblah);
if (memcmp(&rblah, &rd1, sizeof(fd_set)) == 0) {
char blahblah[20];
sprintf(blahblah, "%d ", ii);
strcat(ii_buff_r, blahblah);
ii_r[ii] = 1;
}
memcpy(&wblah, &wd1, sizeof(fd_set));
FD_SET(ii, &wblah);
if (memcmp(&wblah, &wd1, sizeof(fd_set)) == 0) {
char blahblah[20];
yell("blah");
sprintf(blahblah, "%d ", ii);
strcat(ii_buff_w, blahblah);
ii_w[ii] = 1;
}
}
yell("Read fd's in set: %s", (ii_buff_r[0] == '\0') ? "<NONE>" : ii_buff_r);
for (ii = 0; ii <= global_max_fd; ii++) {
if (ii_r[ii] == 1) {
struct stat st;
if (fstat(ii, &st) == -1) {
yell("READ FD %d is causing the select failure!", ii);
}
else {
if (S_ISSOCK(st.st_mode))
yell("READ FD %d is a socket!", ii);
else if (S_ISREG(st.st_mode))
yell("READ FD %d is a regular file!", ii);
else if (S_ISFIFO(st.st_mode))
yell("READ FD %d is a FIFO!", ii);
else ;
}
}
}
yell("Write fd's in set: %s", (ii_buff_w[0] == '\0') ? "<NONE>" : ii_buff_w);
for (ii = 0; ii <= global_max_fd; ii++) {
if (ii_w[ii] == 1) {
struct stat st;
if (fstat(ii, &st) == -1) {
yell("WRITE FD %d is causing the select failure!", ii);
}
else {
if (S_ISSOCK(st.st_mode))
yell("WRITE FD %d is a socket!", ii);
else if (S_ISREG(st.st_mode))
yell("WRITE FD %d is a regular file!", ii);
else if (S_ISFIFO(st.st_mode))
yell("WRITE FD %d is a FIFO!", ii);
else ;
}
}
}
sleep(10);
}
else
{
#if 0
yell("errno 0 rc = -1, maybe it'll go away");
sleep(10);
#endif
}
break;
}
/* we got something on one of the descriptors */
default:
{
cntl_c_hit = 0;
now = time(NULL);
make_window_current(NULL);
do_screens(&rd);
check_icmpresult(&rd, &wd);
#if defined(WANT_THREAD)
#ifdef WANT_NSLOOKUP
dns_check(&rd);
#endif
#ifdef WANT_PTEST
ptest_check(&rd);
#endif
#ifdef WANT_MP3PLAYER
mp3_check(&rd);
#endif
# if defined(GTK)
if (tgtk_okay())
tgtk_check(&rd);
# endif
#endif
do_server(&rd, &wd);
do_processes(&rd);
scan_sockets(&rd, &wd);
clean_sockets();
break;
}
}
now = time(NULL);
ExecuteTimers();
get_child_exit(-1);
if (update_refresh)
{
update_refresh = 0;
refresh_screen(0, NULL);
}
if (!hold_over)
cursor_to_input();
if (update_clock(RESET_TIME))
{
if (get_int_var(CLOCK_VAR))
{
update_all_status(current_window, NULL, 0);
cursor_to_input();
}
clean_queue(get_int_var(TRANSFER_TIMEOUT_VAR)); /* timeout if send time is greater than 5 minutes */
}
/* (set in term.c) -- we should redraw the screen here */
if (need_redraw)
refresh_screen(0, NULL);
#ifdef WANT_THREAD
if (scan_done)
scan_is_done();
#endif
alloca(0);
return;
}
/*
* 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);
}
/*
* help_prompt: The main procedure called to display the help file
* currently being accessed. Using add_wait_prompt(), it sets it
* self up to be recalled when the next page is asked for. If
* called when we have finished paging the help file, we exit, as
* there is nothing left to show. If line is 'q' or 'Q', exit the
* help pager, clean up, etc.. If all is cool for now, we call
* show_help, and either if its finished, exit, or prompt for the
* next page. From here, if we've finished the help page, and
* doing help prompts, prompt for the help..
*/
static void help_prompt (char *name, char *line)
{
if (finished_help_paging)
{
if (*paused_topic)
help_show_paused_topic(paused_topic, empty_string);
return;
}
if (line && toupper(*line) == 'Q')
{
finished_help_paging = 1;
fclose(help_fp);
help_fp = NULL;
}
if (show_help(help_window, name))
{
if (dumb_mode)
help_prompt(name, NULL);
else
add_wait_prompt("*** Hit any key for more, 'q' to quit ***",
help_prompt, name, WAIT_PROMPT_KEY, 1);
}
else
{
finished_help_paging = 1;
if (help_fp)
fclose(help_fp);
help_fp = NULL;
if (help_show_directory)
{
if (get_int_var(HELP_PAGER_VAR))
{
if (dumb_mode)
help_show_paused_topic(name, empty_string);
else
add_wait_prompt("*** Hit any key to end ***",
help_show_paused_topic, paused_topic,
WAIT_PROMPT_KEY, 1);
}
else
{
help_show_paused_topic(paused_topic, empty_string);
set_help_screen((Screen *) 0);
}
help_show_directory = 0;
return;
}
}
if (finished_help_paging)
{
if (get_int_var(HELP_PROMPT_VAR))
{
char tmp[BIG_BUFFER_SIZE + 1];
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);
}
else
{
if (*paused_topic)
help_show_paused_topic(paused_topic, empty_string);
#if 0
set_help_screen((Screen *) 0);
#endif
}
}
}
void napfile_read(int snum)
{
GetFile *gf;
int rc;
SocketList *s;
s = get_socket(snum);
if (!(gf = (GetFile *)get_socketinfo(snum)))
{
unsigned char buff[2*BIG_BUFFER_SIZE+1];
unsigned char fbuff[2*BIG_BUFFER_SIZE+1];
char *nick, *filename, *args;
alarm(10);
if ((rc = read(snum, buff, 2 * BIG_BUFFER_SIZE)) < 0)
{
alarm(0);
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
alarm(0);
buff[rc] = 0;
args = &buff[0];
if (!*args || !strcmp(buff, "FILE NOT FOUND") ||
!strcmp(buff, "INVALID REQUEST") ||
!strcmp(buff, "FILE NOT REQUESTED"))
{
say("Error in napfile_read(%d/%s) %s", snum, (rc == 0) ? strerror(errno) : "", *args ? args : "unknown read");
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
nick = next_arg(args, &args);
if ((filename = new_next_arg(args, &args)) && *filename)
{
strcpy(fbuff, filename);
convertnap_unix(fbuff);
}
if (!nick || !filename || !*filename || !args || !*args
|| !(gf = find_in_getfile(0, nick, NULL, fbuff, 0, NAP_UPLOAD))
|| (gf->write == -1))
{
memset(buff, 0, 80);
if (!gf)
sprintf(buff, "INVALID REQUEST");
else
{
sprintf(buff, "FILE NOT FOUND");
break_from_list((List **)&transfer_struct, (List *)gf);
gf->socket = snum;
if (gf->write == -1)
{
send_ncommand(CMDS_REMOVEFILE, "%s", fbuff);
say("Unable to open [%s]", fbuff);
}
else
{
close(gf->write);
gf->write = -1;
}
}
write(snum, buff, strlen(buff));
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
gf->resume = my_atol(next_arg(args, &args));
if (gf->resume >= gf->filesize)
{
break_from_list((List **)&transfer_struct, (List *)gf);
close(gf->write);
gf->write = -1;
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
if (gf->socket != -1)
{
put_it("ERROR gf->socket != -1 %d %s %s", snum, nick, filename);
break_from_list((List **)&transfer_struct, (List *)gf);
close(gf->write);
gf->write = -1;
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
gf->socket = snum;
lseek(gf->write, SEEK_SET, gf->resume);
set_socketinfo(snum, gf);
memset(buff, 0, 80);
sprintf(buff, "%lu", gf->filesize);
write(snum, buff, strlen(buff));
s->func_write = s->func_read;
s->is_write = s->is_read;
if (do_hook(NAPSEND_LIST, "%s %s %lu \"%s\"", gf->resume ? "RESUME":"SEND", gf->nick, gf->filesize, gf->filename) && !get_int_var(QUIET_SENDS_VAR))
put_it("* %sing file to %s [%s] (%s)", gf->resume ? "Resum" : "Send", gf->nick, base_name(gf->filename), longcomma(gf->filesize));
set_non_blocking(snum);
build_status(current_window, NULL, 0);
send_ncommand(CMDS_UPDATE_SEND1, NULL);
return;
} else if (!gf->starttime)
gf->starttime = now;
s->func_write = s->func_read = napfile_sendfile;
napfile_sendfile(snum);
}
