void load_scripts(void)
{
extern char *new_script;
static int done = 0;
#if !defined(WINNT) && !defined(__EMX__)
char buffer[BIG_BUFFER_SIZE+1];
int old_display = window_display;
#endif
if (!done++)
{
never_connected = 0;
#if !defined(WINNT) && !defined(__EMX__)
window_display = 0;
sprintf(buffer, "%s/bxglobal", SCRIPT_PATH);
loading_global = 1;
load("LOAD", buffer, empty_string, NULL);
loading_global = 0;
window_display = old_display;
#endif
if (!quick_startup)
{
loading_savefile++;
reload_save(NULL, NULL, empty_string, NULL);
loading_savefile--;
/* read the newscript/.bitchxrc/.ircrc file */
if (new_script && !access(new_script, R_OK))
load("LOAD", new_script, empty_string, NULL);
else if (!access(bircrc_file, R_OK))
load("LOAD", bircrc_file, empty_string, NULL);
else if (!access(ircrc_file, R_OK))
load("LOAD", ircrc_file, empty_string, NULL);
}
}
if (get_server_away(from_server))
set_server_away(from_server, get_server_away(from_server), 1);
}
/* update_clock: figUres out the current time and returns it in a nice format */
char *BX_update_clock(int flag)
{
static int min = -1,
hour = -1;
static time_t last_minute = -1;
time_t idlet;
static struct tm time_val;
time_t hideous;
int new_minute = 0;
int new_hour = 0;
hideous = now;
#if !defined(NO_CHEATING)
if (hideous / 60 > last_minute)
{
last_minute = hideous / 60;
time_val = *localtime(&hideous);
}
#else
time_val = *localtime(&hideous);
#endif
if (flag == RESET_TIME || time_val.tm_min != min || time_val.tm_hour != hour)
{
int ofs = from_server;
from_server = primary_server;
if (time_format) /* XXXX Bogus XXXX */
strftime(time_str, 60, time_format, &time_val);
else if (get_int_var(CLOCK_24HOUR_VAR))
strftime(time_str, 60, strftime_24hour, &time_val);
else
strftime(time_str, 60, strftime_12hour, &time_val);
lower(time_str);
if ((time_val.tm_min != min) || (time_val.tm_hour != hour))
{
int is_away = 0;
if (time_val.tm_hour != hour)
new_hour = 1;
new_minute = 1;
hour = time_val.tm_hour;
min = time_val.tm_min;
do_hook(TIMER_LIST, "%02d:%02d", hour, min);
if (min == 0 || new_hour)
do_hook(TIMER_HOUR_LIST, "%02d:%02d", hour, min);
idlet = (hideous - idle_time) / 60L;
if (from_server != -1)
is_away = get_server_away(from_server) ? 1 : 0;
if (do_hook(IDLE_LIST, "%lu", (unsigned long)idlet))
{
if (is_away && new_hour && get_int_var(TIMESTAMP_AWAYLOG_HOURLY_VAR))
logmsg(LOG_CRAP, NULL, 4, NULL);
if (!is_away && get_int_var(AUTO_AWAY_TIME_VAR) && (idlet >= get_int_var(AUTO_AWAY_TIME_VAR)/60))
auto_away(idlet);
}
check_channel_limits();
}
if (!((hideous - start_time) % 20))
check_serverlag();
from_server = ofs;
if (flag != RESET_TIME || new_minute)
return time_str;
else
return NULL;
}
if (flag == GET_TIME)
return time_str;
else
return NULL;
}
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;
}
/*
* 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();
}
