void wait_server_backoff(unsigned int timeout /* seconds */,
jsonrpc_server_t* server, bool delay)
{
if(!server) {
ERR("Trying to close/reconnect a NULL server\n");
return;
}
if(delay == false) {
if (requests_using_server(server) <= 0) {
if(server->status == JSONRPC_SERVER_RECONNECTING) {
bev_connect(server);
} else if(server->status == JSONRPC_SERVER_CLOSING) {
close_server(server);
}
return;
}
}
const struct timeval tv = {timeout, 0};
server_backoff_args_t* args = pkg_malloc(sizeof(server_backoff_args_t));
CHECK_MALLOC_VOID(args);
memset(args, 0, sizeof(server_backoff_args_t));
args->ev = evtimer_new(global_ev_base, server_backoff_cb, (void*)args);
CHECK_MALLOC_GOTO(args->ev, error);
args->server = server;
args->timeout = timeout;
if(evtimer_add(args->ev, &tv)<0) {
ERR("event_add failed while setting request timer (%s).", strerror(errno));
goto error;
}
return;
error:
ERR("schedule_server failed.\n");
if(args) {
if(args->ev) {
evtimer_del(args->ev);
}
pkg_free(args);
}
if (server->status == JSONRPC_SERVER_CLOSING) {
ERR("Closing server now...\n");
close_server(server);
} else if (server->status == JSONRPC_SERVER_RECONNECTING) {
ERR("Reconnecting server now...\n");
force_reconnect(server);
}
}
void
set_socket_opt(int sock, addr_info_t * addr) {
int on = 1, ret;
ret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (ret == -1) close_server("setsocketopt 'SO_REUSEADDR' failed", sock, addr);
if (addr->ai_addr->sa_family == AF_INET6) {
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on));
if (ret == -1) close_server("setsockopt 'IPV6_V6ONLY' failed", sock, addr);
}
}
void Boot(void)
{
FILE *fd;
char buffer[BOOT_BUFFER_LENGTH];
int length = 0;
long size = 0;
static char Flicks[] = "|/-\\|/-\\";
int flick = 0;
unsigned char ops_res;
/* Open the boot file */
fd = fopen(BootFileName, "rb");
if (fd == NULL) {
sprintf(ErrMsg,"Boot: cannot find file \"%s\"", BootFileName);
close_server(MISC_EXIT, ErrMsg);
}
infomsg("Booting root transputer...");
/* Read the file in large chunks */
while ((length = fread(buffer, 1, BOOT_BUFFER_LENGTH, fd)) > 0) {
dbgmsg("%d", length);
ops_res = OPS_BootWrite(ConnId, buffer, (unsigned long) length);
if (ops_res != STATUS_NOERROR) {
sprintf(ErrMsg,"Boot: write failed after %ld bytes because:\n %s\n",
size, lnkops_errorstring);
close_server(MISC_EXIT, ErrMsg);
}
size += length;
if (isatty(1)) {
infomsg("%c\b", Flicks[flick]);
if (++flick == 8)
flick = 0;
}
}
if (isatty(1))
infomsg("\r \r");
else
infomsg("ok\n");
fclose(fd);
dbgmsg("booted %ld bytes", size);
}
int main(int argc,
char **argv)
{
SOCKET listen_sock;
struct sockaddr_un addr;
union conv_sockaddr u_sock_addr;
int len, nb_str;
char **print_me;
listen_sock = create_socket();
strcpy(addr.sun_path, get_path());
addr.sun_family = AF_LOCAL;
u_sock_addr.un = &addr;
if (connect(listen_sock, u_sock_addr.ad, sizeof(addr)) == -1)
{
printf("Client not connected.\n");
return (-1);
}
if ((nb_str =parse_arg(argc, argv, &print_me)) == 0)
return (close_server(listen_sock));
for (; nb_str > 0; nb_str--)
{
len = strlen(print_me[nb_str - 1]);
write(listen_sock, &len, sizeof(len));
write(listen_sock, print_me[nb_str - 1], len);
}
close(listen_sock);
free(print_me);
return (0);
}
static void close_bev(struct bufferevent *bev, struct conn_desc *conn)
{
if (IS_SERVER(bev, conn))
close_server(conn);
else
close_client(conn);
}
// main loop
int main( int argc, char **argv )
{
printf("Hello world\n");
Management manager = new_manager();
// add actions to the manager
action_add_to_manager( manager );
// add rooms to manager
room_add_to_manager( manager );
Server server = new_server();
if( start_server( server, 5555 ) < 0 ){
return 1;
}
environment_loop( server, manager );
/* ---------------------------------------
* Clean up
*/
close_server( server );
destroy_server( server );
destroy_manager( manager );
return 0;
}
/*
** brief: allow us to handle signal like ctlr^C and do something like close
** @sig: macro like SIGINT
*/
void sig_handler(int sig)
{
if (sig == SIGINT)
{
my_printf(1, "\n");
close_server(g_ports);
exit(EXIT_SUCCESS);
}
}
/*
** brief: check signals like SIGINT
** @ports: array of ports used to close FD_SERVER port
*/
void check_signal(int *ports)
{
g_ports = ports;
if (signal(SIGINT, sig_handler) == SIG_ERR)
{
perror("signal");
close_server(ports);
exit(EXIT_FAILURE);
}
}
static void irc_server_timeout(void)
{
int timeout;
timeout = irc_server_is_timeout();
if (timeout > 0) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Server Connection Timed Out (%u seconds) on %s", timeout, gnetwork->name);
close_server();
}
}
int main(int argc, char* argv[]) {
init_database(database, table);
init_server(argc, argv);
recv_from_client();
close_server();
close_database();
return EXIT_SUCCESS;
}
/*
* sig_handler really only handles the timeout and pipe signals.
* This ensures that we do not wait forever on a request
* to our server, and also that if the server dies, we do not
* die from a sigpipe problem.
*/
static void
sig_handler (int signo ATTRIBUTE_UNUSED)
{
#ifdef DEBUG
/* FIXME: this is illegal to do in a signal handler. */
fprintf (stderr,
"fixincl ERROR: sig_handler: killed pid %ld due to %s\n",
(long) server_id, signo == SIGPIPE ? "SIGPIPE" : "SIGALRM");
#endif
close_server ();
read_pipe_timeout = BOOL_TRUE;
}
/**
* Stop server.
*
* This call is be used to stop a server from different thread.
*
* @return 0 if successful, otherwise -1.
*/
void ad_server_stop(ad_server_t *server) {
DEBUG("Send loopexit notification.");
notify_loopexit(server);
sleep(1);
if (ad_server_get_option_int(server, "server.thread")) {
close_server(server);
if (ad_server_get_option_int(server, "server.free_on_stop")) {
ad_server_free(server);
}
}
}
void command_kill(t_serv *server, t_token *req)
{
t_fd *tmp;
tmp = server->fd_lst;
while (tmp)
{
command_quit(server, tmp);
tmp = server->fd_lst;
}
free(req->content);
free(req);
close_server(server);
return ;
}
/*
* get_password: when a host responds that the user needs to supply a
* password, it gets handled here! the user is prompted for a password and
* then reconnection is attempted with that password. but, the reality of
* the situation is that no one really uses user passwords. ah well
*/
static void
get_password(void)
{
u_char server_num[8];
say("password required for connection to server %s",
server_get_name(parsing_server()));
close_server(parsing_server(), empty_string());
if (!term_basic())
{
snprintf(CP(server_num), sizeof server_num, "%d", parsing_server());
add_wait_prompt(UP("Server Password:"), password_sendline,
server_num, WAIT_PROMPT_LINE);
}
}
void io_shutdown(int sig)
{
INFO("Shutting down JSONRPC IO process...\n");
lock_get(jsonrpc_server_group_lock); /* blocking */
INIT_SERVER_LOOP
FOREACH_SERVER_IN(global_server_group)
close_server(server);
ENDFOR
evdns_base_free(global_evdns_base, 0);
event_base_loopexit(global_ev_base, NULL);
event_base_free(global_ev_base);
lock_release(jsonrpc_server_group_lock);
}
void BreakHandler()
{
#ifndef SUN
#ifndef SOLARIS
#ifndef SGI
signal(SIGINT, BreakHandler);
#endif
#endif
#endif
fputc('\n', stderr);
dbgmsg("break exit");
if (InShell) {
printf("aborted by user\n");
longjmp(SafePlace, 42);
}
else
close_server(USER_EXIT, "aborted by user");
}
static void Core()
{
unsigned char ops_res;
infomsg("Peeking root transputer...");
ops_res = OPS_Peek32(ConnId, ProcId, (unsigned long) CoreSize>>2, 0x80000000L, CoreDump);
if (ops_res != STATUS_NOERROR) {
sprintf(ErrMsg,"Core: failed to peek root transputer because:\n %s\n",
lnkops_errorstring);
close_server(MISC_EXIT, ErrMsg);
}
if (isatty(1))
infomsg("\r \r");
else
infomsg("ok\n");
dbgmsg("peeked %d chars", CoreSize);
}
/**
* Release server object and all the resources.
*/
void ad_server_free(ad_server_t *server) {
if (server == NULL) return;
int thread = ad_server_get_option_int(server, "server.thread");
if (thread && server->thread) {
notify_loopexit(server);
sleep(1);
close_server(server);
}
if (server->evbase) {
event_base_free(server->evbase);
}
if (server->sslctx) {
SSL_CTX_free(server->sslctx);
ERR_clear_error();
ERR_remove_state(0);
}
if (server->options) {
server->options->free(server->options);
}
if (server->stats) {
server->stats->free(server->stats);
}
if (server->hooks) {
qlist_t *tbl = server->hooks;
ad_hook_t *hook;
while ((hook = tbl->popfirst(tbl, NULL))) {
if (hook->method) free(hook->method);
free(hook);
}
server->hooks->free(server->hooks);
}
free(server);
DEBUG("Server terminated.");
}
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);
}
int
open_server(struct task *tsk)
{
int server_socket;
int can_open = 0;
if(tsk->pair.server != -1) {
if(redirect_flag) {
return 0;
} else {
close_server(tsk);
}
}
pthread_mutex_lock(&mtx);
if(server_num < MAX_SERVER_NUM) {
can_open = 1;
server_num++;
}
pthread_mutex_unlock(&mtx);
if(can_open) {
if(redirect_flag) {
server_socket = open_client_socket(redirect_host, (short)atol(redirect_port));
} else {
server_socket = open_client_socket(tsk->pkg.host, tsk->pkg.port);
}
if(server_socket < 0) {
pthread_mutex_lock(&mtx);
server_num--;
pthread_mutex_unlock(&mtx);
return -1;
};
} else {
return LACK_OF_PORT;
}
tsk->pair.server = server_socket;
set_server_num(server_num);
return 0;
}
void
listen_socket(int sock, addr_info_t * info, char * addr, char * port) {
int ret = listen(sock, 20);
if (ret == -1) close_server("listen failed", sock, info);
INFO("Listening on %s:%s\n", addr, port);
}
static void close_connection(struct conn_desc *conn)
{
close_client(conn);
close_server(conn);
}
static void ir_parseline2(ir_parseline_t *ipl)
{
channel_t *ch;
char *nick;
char *part3a;
char *t;
unsigned int i;
caps(ipl->part[1]);
/* NOTICE nick */
if (!strcmp(ipl->part[1], "NOTICE")) {
if (gnetwork->caps_nick && ipl->part[2]) {
if (!strcmp(caps(ipl->part[2]), gnetwork->caps_nick)) {
/* nickserv */
identify_check(ipl->line);
#ifdef USE_RUBY
if (do_myruby_notice(ipl->line) == 0)
#endif /* USE_RUBY */
privmsgparse(0, 0, ipl->line);
}
}
}
/* PRIVMSG */
if (!strcmp(ipl->part[1], "PRIVMSG")) {
#ifndef WITHOUT_BLOWFISH
char *line2;
line2 = test_fish_message(ipl->line, ipl->part[2], ipl->part[3], ipl->part[4]);
if (line2) {
#ifdef USE_RUBY
if (do_myruby_privmsg(line2) == 0)
#endif /* USE_RUBY */
privmsgparse(1, 1, line2);
mydelete(line2);
} else {
#endif /* WITHOUT_BLOWFISH */
#ifdef USE_RUBY
if (do_myruby_privmsg(ipl->line) == 0)
#endif /* USE_RUBY */
privmsgparse(1, 0, ipl->line);
#ifndef WITHOUT_BLOWFISH
}
#endif /* WITHOUT_BLOWFISH */
}
/* :server 001 xxxx :welcome.... */
if ( !strcmp(ipl->part[1], "001") ) {
irc_001(ipl);
return;
}
/* :server 005 xxxx aaa bbb=x ccc=y :are supported... */
if ( !strcmp(ipl->part[1], "005") ) {
irc_005(ipl);
return;
}
/* :server 401 botnick usernick :No such nick/channel */
if ( !strcmp(ipl->part[1], "401") ) {
if (ipl->part[2] && ipl->part[3]) {
if (!strcmp(ipl->part[2], "*")) {
lost_nick(ipl->part[3]);
}
}
return;
}
/* :server 433 old new :Nickname is already in use. */
if ( !strcmp(ipl->part[1], "433") ) {
if (ipl->part[2] && ipl->part[3]) {
if (!strcmp(ipl->part[2], "*")) {
ioutput(OUT_S|OUT_L, COLOR_NO_COLOR,
"Nickname %s already in use on %s, trying %s%u",
ipl->part[3],
gnetwork->name,
get_config_nick(),
gnetwork->nick_number);
/* generate new nick and retry */
writeserver(WRITESERVER_NORMAL, "NICK %s%u",
get_config_nick(),
(gnetwork->nick_number)++);
}
}
return;
}
/* :server 470 botnick #channel :(you are banned) transfering you to #newchannel */
if ( !strcmp(ipl->part[1], "470") ) {
if (ipl->part[2] && ipl->part[3]) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"channel on %s: %s", gnetwork->name, strstr(ipl->line, "470"));
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(caps(ipl->part[2]), gnetwork->caps_nick))
continue;
if (strcmp(caps(ipl->part[3]), ch->name))
continue;
ch->flags |= CHAN_KICKED;
}
}
return;
}
/* names list for a channel */
/* :server 353 our_nick = #channel :nick @nick +nick nick */
if ( !strcmp(ipl->part[1], "353") ) {
if (ipl->part[2] && ipl->part[3] && ipl->part[5]) {
caps(ipl->part[4]);
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(ipl->part[4], ch->name) != 0)
continue;
for (i=0; (t = getpart(ipl->line, 6+i)); ++i) {
addtomemberlist(ch, i == 0 ? t+1 : t);
mydelete(t);
}
return;
}
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Got name data for %s which is not a known channel on %s!",
ipl->part[4], gnetwork->name);
writeserver(WRITESERVER_NORMAL, "PART %s", ipl->part[4]);
}
return;
}
if (gnetwork->lastping != 0) {
if (strcmp(ipl->part[1], "PONG") == 0) {
lag_message();
return;
}
}
#if PING_SRVR
/* server ping */
if (strncmp(ipl->line, "PING :", 6) == 0) {
if (gdata.debug > 0)
ioutput(OUT_S, COLOR_NO_COLOR,
"Server Ping on %s: %s",
gnetwork->name, ipl->line);
writeserver(WRITESERVER_NOW, "PO%s", ipl->line+2);
return;
}
#endif
/* QUIT */
if (strcmp(ipl->part[1], "QUIT") == 0) {
if (gnetwork->caps_nick) {
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we quit? */
outerror(OUTERROR_TYPE_WARN_LOUD,
"Forced quit on %s: %s", gnetwork->name, ipl->line);
close_server();
clean_send_buffers();
/* do not reconnect */
gnetwork->serverstatus = SERVERSTATUS_EXIT;
} else {
/* someone else quit */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
removefrommemberlist(ch, nick);
}
reverify_restrictsend();
}
mydelete(nick);
}
return;
}
/* MODE #channel +x ... */
if (strcmp(ipl->part[1], "MODE") == 0) {
if (ipl->part[2] && ipl->part[3]) {
/* find channel */
for (ch = irlist_get_head(&(gnetwork->channels)); ch; ch = irlist_get_next(ch)) {
char *ptr;
unsigned int plus;
unsigned int part;
unsigned int ii;
if (strcasecmp(ch->name, ipl->part[2]) != 0)
continue;
plus = 0;
part = 4;
for (ptr = ipl->part[3]; *ptr; ++ptr) {
if (*ptr == '+') {
plus = 1;
} else if (*ptr == '-') {
plus = 0;
} else {
for (ii = 0; (ii < MAX_PREFIX && gnetwork->prefixes[ii].p_mode); ++ii) {
if (*ptr == gnetwork->prefixes[ii].p_mode) {
/* found a nick mode */
nick = getpart(ipl->line, ++part);
if (nick) {
if (nick[strlen(nick)-1] == IRCCTCP) {
nick[strlen(nick)-1] = '\0';
}
if (plus == 0) {
if (strcasecmp(nick, get_config_nick()) == 0) {
identify_needed(0);
}
}
changeinmemberlist_mode(ch, nick,
gnetwork->prefixes[ii].p_symbol,
plus);
mydelete(nick);
}
break;
}
}
for (ii = 0; (ii < MAX_CHANMODES && gnetwork->chanmodes[ii]); ++ii) {
if (*ptr == gnetwork->chanmodes[ii]) {
/* found a channel mode that has an argument */
++part;
break;
}
}
}
}
return;
}
if (strcasecmp(ipl->part[2], get_config_nick()) == 0) {
if (ipl->part[3][0] == '-') {
identify_needed(0);
}
}
}
return;
}
if (ipl->part[2] && ipl->part[2][0] == ':') {
part3a = ipl->part[2] + 1;
} else {
part3a = ipl->part[2];
}
/* JOIN */
if (strcmp(ipl->part[1], "JOIN") == 0) {
if (gnetwork->caps_nick && part3a) {
caps(part3a);
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we joined */
/* clear now, we have succesfully logged in */
gnetwork->serverconnectbackoff = 0;
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Joined %s on %s", part3a, gnetwork->name);
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
ch->flags |= CHAN_ONCHAN;
ch->lastjoin = gdata.curtime;
ch->nextann = gdata.curtime + gdata.waitafterjoin;
ch->nextmsg = gdata.curtime + gdata.waitafterjoin;
if (ch->joinmsg) {
writeserver(WRITESERVER_NOW, "PRIVMSG %s :%s", ch->name, ch->joinmsg);
}
gnetwork->botstatus = BOTSTATUS_JOINED;
start_sends();
mydelete(nick);
return;
}
} else {
/* someone else joined */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
addtomemberlist(ch, nick);
mydelete(nick);
return;
}
}
ir_unknown_channel(part3a);
mydelete(nick);
}
return;
}
/* PART */
if (strcmp(ipl->part[1], "PART") == 0) {
if (gnetwork->caps_nick && part3a) {
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we left? */
mydelete(nick);
return;
} else {
/* someone else left */
caps(part3a);
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
removefrommemberlist(ch, nick);
mydelete(nick);
reverify_restrictsend();
return;
}
}
ir_unknown_channel(part3a);
mydelete(nick);
}
return;
}
/* NICK */
if (strcmp(ipl->part[1], "NICK") == 0) {
if (gnetwork->caps_nick && part3a) {
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we changed, update nick */
mydelete(gnetwork->user_nick);
mydelete(gnetwork->caps_nick);
gnetwork->user_nick = mystrdup(part3a);
gnetwork->caps_nick = mystrdup(part3a);
caps(gnetwork->caps_nick);
gnetwork->nick_number = 0;
++(gdata.needsclear);
identify_needed(0);
} else {
/* someone else has a new nick */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
changeinmemberlist_nick(ch, nick, part3a);
}
user_changed_nick(nick, part3a);
}
mydelete(nick);
}
return;
}
/* KICK */
if (strcmp(ipl->part[1], "KICK") == 0) {
if (gnetwork->caps_nick && part3a && ipl->part[3]) {
caps(part3a);
if (!strcmp(caps(ipl->part[3]), gnetwork->caps_nick)) {
/* we were kicked */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
if (gdata.noautorejoin) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"Kicked on %s: %s", gnetwork->name, ipl->line);
ch->flags |= CHAN_KICKED;
clearmemberlist(ch);
reverify_restrictsend();
} else {
outerror(OUTERROR_TYPE_WARN_LOUD,
"Kicked on %s, Rejoining: %s", gnetwork->name, ipl->line);
ch->flags &= ~CHAN_ONCHAN;
joinchannel(ch);
}
}
} else {
/* someone else was kicked */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
removefrommemberlist(ch, ipl->part[3]);
reverify_restrictsend();
return;
}
}
}
return;
}
/* ERROR :Closing Link */
if (strncmp(ipl->line, "ERROR :Closing Link", strlen("ERROR :Closing Link")) == 0) {
if (gdata.exiting) {
gnetwork->recentsent = 0;
return;
}
ioutput(OUT_S|OUT_L|OUT_D, COLOR_RED,
"Server Closed Connection on %s: %s",
gnetwork->name, ipl->line);
close_server();
return;
}
}
/**
* Creates the main mechanical loop.
* @param server the server for this environment
* @param manager where most of our variables come from
*/
void environment_loop( Server server, Management manager ) {
signal( SIGINT, interrupted );
// create a struct to pass to the connection accepting thread
ConnectionThreadStruct conn = malloc(
sizeof( struct connection_struct )
);
conn->server = server;
conn->manager = manager;
// start a thread to accept connections
pthread_t thread;
int err = pthread_create(
&thread,
NULL,
connection_thread,
conn);
// check for error
if (err != 0) {
perror("Creating connection thread");
}
// TODO spawn real time activity thread
// time values
struct timeval last_time;
gettimeofday(&last_time, NULL);
// number of quarter ticks since last tick
unsigned int quarter_ticks = 0;
// environment loop actual
while( cease != 1 ){
/* --------------------------------------------------
* Check for ticks
*/
// get current time
struct timeval current_time;
gettimeofday(¤t_time, NULL);
// difference in usecs, used for quarter tick intervals, if needed
long int diff = (last_time.tv_usec + 1000000 * last_time.tv_sec) -
(current_time.tv_usec + 1000000 * current_time.tv_sec);
int sec_diff = current_time.tv_sec - last_time.tv_sec;
if( sec_diff >= EVOLUTION_TICK_INTERVAL_S ){
// do something with the tick
last_time = current_time;
} else {
// give up thread control
sched_yield();
}
}
// set manager cease flag
manager->cease = 1;
// TODO Disconnect all clients
// wait for connection thread to end
close_server( server );
// pthread_kill( thread, SIGINT );
pthread_join( thread, NULL );
// free conn arg
free( conn );
printf("exiting\n");
}
/* handle irc server connectipn */
void irc_perform(int changesec)
{
channel_t *ch;
unsigned int ss;
unsigned int i;
unsigned int j;
int length;
int timeout;
updatecontext();
for (ss=0; ss<gdata.networks_online; ++ss) {
gnetwork = &(gdata.networks[ss]);
if (gdata.needsswitch) {
switchserver(-1);
continue;
}
/*----- see if gdata.ircserver is sending anything to us ----- */
if (gnetwork->serverstatus == SERVERSTATUS_CONNECTED) {
if (FD_ISSET(gnetwork->ircserver, &gdata.readset)) {
char tempbuffa[INPUT_BUFFER_LENGTH];
gnetwork->lastservercontact = gdata.curtime;
gnetwork->servertime = 0;
memset(&tempbuffa, 0, INPUT_BUFFER_LENGTH);
length = readserver_ssl(&tempbuffa, INPUT_BUFFER_LENGTH);
if (length < 1) {
if (errno != EAGAIN) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_RED,
"Closing Server Connection on %s: %s",
gnetwork->name, (length<0) ? strerror(errno) : "Closed");
if (gdata.exiting) {
gnetwork->recentsent = 0;
}
close_server();
mydelete(gnetwork->curserveractualname);
}
continue;
}
j = strlen(gnetwork->server_input_line);
for (i=0; i<(unsigned int)length; ++i) {
if ((tempbuffa[i] == '\n') || (j == (INPUT_BUFFER_LENGTH-1))) {
if (j && (gnetwork->server_input_line[j-1] == 0x0D)) {
--j;
}
gnetwork->server_input_line[j] = '\0';
ir_parseline(gnetwork->server_input_line);
j = 0;
} else {
gnetwork->server_input_line[j] = tempbuffa[i];
++j;
}
}
gnetwork->server_input_line[j] = '\0';
}
continue;
}
if (gnetwork->serverstatus == SERVERSTATUS_SSL_HANDSHAKE) {
if ((FD_ISSET(gnetwork->ircserver, &gdata.writeset)) || (FD_ISSET(gnetwork->ircserver, &gdata.readset))) {
handshake_ssl();
}
if (changesec)
irc_server_timeout();
continue;
}
if (gnetwork->serverstatus == SERVERSTATUS_TRYING) {
if (FD_ISSET(gnetwork->ircserver, &gdata.writeset)) {
int callval_i;
int connect_error;
SIGNEDSOCK int connect_error_len = sizeof(connect_error);
SIGNEDSOCK int addrlen;
callval_i = getsockopt(gnetwork->ircserver,
SOL_SOCKET, SO_ERROR,
&connect_error, &connect_error_len);
if (callval_i < 0) {
outerror(OUTERROR_TYPE_WARN,
"Couldn't determine connection status: %s on %s",
strerror(errno), gnetwork->name);
close_server();
continue;
}
if (connect_error) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Server Connection Failed: %s on %s", strerror(connect_error), gnetwork->name);
close_server();
continue;
}
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Server Connection to %s Established, Logging In", gnetwork->name);
gnetwork->serverstatus = SERVERSTATUS_CONNECTED;
gnetwork->connecttime = gdata.curtime;
gnetwork->botstatus = BOTSTATUS_LOGIN;
ch = irlist_get_head(&(gnetwork->channels));
if (ch == NULL) {
gnetwork->botstatus = BOTSTATUS_JOINED;
start_sends();
}
FD_CLR(gnetwork->ircserver, &gdata.writeset);
addrlen = sizeof(gnetwork->myip);
bzero((char *) &(gnetwork->myip), sizeof(gnetwork->myip));
if (getsockname(gnetwork->ircserver, &(gnetwork->myip.sa), &addrlen) >= 0) {
if (gdata.debug > 0) {
char *msg;
msg = mymalloc(maxtextlength);
my_getnameinfo(msg, maxtextlength -1, &(gnetwork->myip.sa));
ioutput(OUT_S, COLOR_YELLOW, "using %s", msg);
mydelete(msg);
}
if (!gnetwork->usenatip) {
gnetwork->ourip = ntohl(gnetwork->myip.sin.sin_addr.s_addr);
if (gdata.debug > 0) {
ioutput(OUT_S, COLOR_YELLOW, "ourip = " IPV4_PRINT_FMT,
IPV4_PRINT_DATA(gnetwork->ourip));
}
}
} else {
outerror(OUTERROR_TYPE_WARN, "couldn't get ourip on %s", gnetwork->name);
}
handshake_ssl();
}
if (changesec)
irc_server_timeout();
continue;
}
if (gnetwork->serverstatus == SERVERSTATUS_RESOLVING) {
if (FD_ISSET(gnetwork->serv_resolv.sp_fd[0], &gdata.readset)) {
res_addrinfo_t remote;
length = read(gnetwork->serv_resolv.sp_fd[0],
&remote, sizeof(res_addrinfo_t));
kill(gnetwork->serv_resolv.child_pid, SIGKILL);
FD_CLR(gnetwork->serv_resolv.sp_fd[0], &gdata.readset);
if (length != sizeof(res_addrinfo_t)) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_RED,
"Error resolving server %s on %s",
gnetwork->curserver.hostname, gnetwork->name);
gnetwork->serverstatus = SERVERSTATUS_NEED_TO_CONNECT;
} else {
/* continue with connect */
if (connectirc2(&remote)) {
/* failed */
gnetwork->serverstatus = SERVERSTATUS_NEED_TO_CONNECT;
}
}
}
if (changesec) {
timeout = irc_server_is_timeout();
if (timeout > 0) {
kill(gnetwork->serv_resolv.child_pid, SIGKILL);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Server Resolve Timed Out (%u seconds) on %s", timeout, gnetwork->name);
gnetwork->serverstatus = SERVERSTATUS_NEED_TO_CONNECT;
}
}
continue;
}
if (gnetwork->offline)
continue;
if (gnetwork->serverstatus == SERVERSTATUS_NEED_TO_CONNECT) {
if (changesec) {
timeout = irc_server_is_timeout();
if (timeout > 0) {
if (gdata.debug > 0) {
ioutput(OUT_S, COLOR_YELLOW,
"Reconnecting to server (%u seconds) on %s",
timeout, gnetwork->name);
}
switchserver(-1);
}
}
continue;
}
} /* networks */
gnetwork = NULL;
/* reset after done on all networks */
if (gdata.needsswitch)
gdata.needsswitch = 0;
}
void
bind_socket(int sock, addr_info_t * addr) {
int ret = bind(sock, addr->ai_addr, addr->ai_addrlen);
if (ret == -1) close_server("bind failed", sock, addr);
}
/*
* run_shell
*
* Run a shell command on the server. The command string
* passed in is wrapped inside the sequence:
*
* cd <original directory>
* <command string>
* echo
* echo <end-of-command-marker>
*
* This ensures that all commands start at a known place in
* the directory structure, that any incomplete output lines
* are completed and that our special marker sequence appears on
* a line by itself. We have chosen a marker that is
* excessively unlikely to be reproduced in normal output:
*
* "ShElL-OuTpUt-HaS-bEeN-cOmPlEtEd"
*/
char *
run_shell (const char* pz_cmd)
{
tSCC zNoServer[] = "Server not running, cannot run:\n%s\n\n";
t_bool retry = BOOL_TRUE;
do_retry:
/* IF the shell server process is not running yet,
THEN try to start it. */
if (server_id == NULLPROCESS)
{
def_args[0] = find_shell ();
server_id = proc2_fopen (&server_pair, def_args);
if (server_id > 0)
server_setup ();
}
/* IF it is still not running, THEN return the nil string. */
if (server_id <= 0)
{
fprintf (stderr, zNoServer, pz_cmd);
return xcalloc (1, 1);
}
/* Make sure the process will pay attention to us, send the
supplied command, and then have it output a special marker that
we can find. */
fprintf (server_pair.pf_write, "cd %s\n%s\n\necho\necho %s\n",
p_cur_dir, pz_cmd, z_done);
fflush (server_pair.pf_write);
/* IF the server died and we received a SIGPIPE,
THEN return an empty string. */
if (server_id == NULLPROCESS)
{
fprintf (stderr, zNoServer, pz_cmd);
return xcalloc (1, 1);
}
/* Now try to read back all the data. If we fail due to either a
sigpipe or sigalrm (timeout), we will return the nil string. */
{
char *pz = load_data (server_pair.pf_read);
if (pz == (char *) NULL)
{
close_server ();
if (retry)
{
retry = BOOL_FALSE;
goto do_retry;
}
fprintf (stderr, "CLOSING SHELL SERVER - command failure:\n\t%s\n",
pz_cmd);
pz = xcalloc (1, 1);
}
#ifdef DEBUG
fprintf( stderr, "run_shell command success: %s\n", pz );
#endif
return pz;
}
}
int
create_socket(addr_info_t * addr) {
int sock = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
if (sock == -1) close_server("socket failed", -1, addr);
return sock;
}
void QScope::closeCMOSserver(){
fprintf(stderr,"Closing server socket (%i).\n",data_sock);
// close socket */
close_server(data_sock);
}
static void mainloop (void) {
/* data is persistant across calls */
static struct timeval timestruct;
static int changequartersec, changesec, changemin, changehour;
static time_t lasttime, lastmin, lasthour, last4sec, last5sec, last20sec;
static time_t lastautoadd;
static time_t last3min, last2min, lastignoredec;
static int first_loop = 1;
static ir_uint64 last250ms;
userinput *pubplist;
userinput *urehash;
ir_uint64 xdccsent;
unsigned int i;
int highests;
unsigned int ss;
upload *ul;
transfer *tr;
channel_t *ch;
xdcc *xd;
dccchat_t *chat;
updatecontext();
gnetwork = NULL;
if (first_loop)
{
/* init if first time called */
FD_ZERO(&gdata.readset);
FD_ZERO(&gdata.writeset);
changehour=changemin=changesec=changequartersec=0;
gettimeofday(×truct, NULL);
last250ms = gdata.curtimems;
gdata.curtimems = timeval_to_ms(×truct);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR, "Startup"
" running: %ld ms", (long)(gdata.curtimems - last250ms));
gdata.curtime = timestruct.tv_sec;
lasttime=gdata.curtime;
last250ms = gdata.curtimems;
lastmin=(lasttime/60)-1;
lasthour=(lasttime/60/60)-1;
last4sec = last5sec = last20sec = last2min = last3min = lasttime;
lastignoredec = lasttime;
for (ss=0; ss<gdata.networks_online; ss++)
{
gdata.networks[ss].lastnotify = lasttime;
gdata.networks[ss].lastslow = lasttime;
gdata.networks[ss].server_input_line[0] = '\0';
}
gdata.cursendptr = 0;
lastautoadd = gdata.curtime + 60;
first_loop = 0;
}
updatecontext();
FD_ZERO(&gdata.readset);
FD_ZERO(&gdata.writeset);
FD_ZERO(&gdata.execset);
highests = 0;
#ifdef USE_CURL
fetch_multi_fdset(&gdata.readset, &gdata.writeset, &gdata.execset, &highests);
#endif /* USE_CURL */
highests = irc_select(highests);
if (!gdata.background)
{
FD_SET(fileno(stdin), &gdata.readset);
highests = max2(highests, fileno(stdin));
}
highests = chat_select_fdset(highests);
highests = t_select_fdset(highests, changequartersec);
highests = l_select_fdset(highests, changequartersec);
#ifndef WITHOUT_TELNET
highests = telnet_select_fdset(highests);
#endif /* WITHOUT_TELNET */
#ifndef WITHOUT_HTTP
highests = h_select_fdset(highests, changequartersec);
#endif /* WITHOUT_HTTP */
if (gdata.md5build.file_fd != FD_UNUSED)
{
assert(gdata.md5build.xpack);
FD_SET(gdata.md5build.file_fd, &gdata.readset);
highests = max2(highests, gdata.md5build.file_fd);
}
updatecontext();
if (gdata.debug > 81)
{
select_dump("try", highests);
}
if (gdata.attop) gotobot();
tostdout_write();
gettimeofday(×truct, NULL);
gdata.selecttimems = timeval_to_ms(×truct);
if (ir_kqueue_select(highests+1, &gdata.readset, &gdata.writeset, &gdata.execset) < 0)
{
if (errno != EINTR)
{
outerror(OUTERROR_TYPE_WARN,"Select returned an error: %s",strerror(errno));
usleep(10000); /* prevent fast spinning */
}
/* data is undefined on error, zero and continue */
FD_ZERO(&gdata.readset);
FD_ZERO(&gdata.writeset);
FD_ZERO(&gdata.execset);
}
if (gdata.debug > 81)
{
select_dump("got", highests);
}
/*----- one second check ----- */
updatecontext();
if (gettimeofday(×truct, NULL) < 0)
{
outerror(OUTERROR_TYPE_CRASH,"gettimeofday() failed! %s\n",strerror(errno));
}
gdata.curtimems = timeval_to_ms(×truct);
gdata.curtime = timestruct.tv_sec;
if (gdata.curtimems > gdata.selecttimems + 1000)
outerror(OUTERROR_TYPE_WARN, "Iroffer was blocked for %lims",
(long)(gdata.curtimems - gdata.selecttimems));
/* adjust for drift and cpu usage */
if ((gdata.curtimems > (last250ms+1000)) ||
(gdata.curtimems < last250ms))
{
/* skipped forward or backwards, correct */
last250ms = gdata.curtimems-250;
}
if (gdata.curtimems >= (last250ms+250))
{
changequartersec = 1;
/* note bandwidth limiting requires no drift! */
last250ms += 250;
}
else
{
changequartersec = 0;
}
changesec = 0;
if (gdata.curtime != lasttime) {
if (gdata.curtime < lasttime - MAX_WAKEUP_WARN) {
outerror(OUTERROR_TYPE_WARN, "System Time Changed Backwards %lim %lis!!\n",
(long)(lasttime-gdata.curtime)/60, (long)(lasttime-gdata.curtime)%60);
}
if (gdata.curtime > lasttime + MAX_WAKEUP_WARN) {
outerror(OUTERROR_TYPE_WARN, "System Time Changed Forward or Mainloop Skipped %lim %lis!!\n",
(long)(gdata.curtime-lasttime)/60, (long)(gdata.curtime-lasttime)%60);
if (gdata.debug > 0) {
dump_slow_context();
}
}
if (gdata.curtime > lasttime + MAX_WAKEUP_ERR) {
outerror(OUTERROR_TYPE_WARN, "System Time Changed Forward or Mainloop Skipped %lim %lis!!\n",
(long)(gdata.curtime-lasttime)/60, (long)(gdata.curtime-lasttime)%60);
if (gdata.debug > 0)
{
dumpcontext();
}
}
lasttime = gdata.curtime;
changesec = 1;
}
if (changesec && lasttime/60/60 != lasthour) {
lasthour = lasttime/60/60;
changehour = 1;
}
if (changesec && lasttime/60 != lastmin) {
lastmin = lasttime/60;
changemin = 1;
}
if (gdata.needsshutdown)
{
gdata.needsshutdown = 0;
shutdowniroffer();
}
if (gdata.needsreap)
{
gdata.needsreap = 0;
irc_resolved();
}
#ifdef USE_CURL
fetch_perform();
#endif /* USE_CURL */
updatecontext();
if (changesec) {
gdata.totaluptime++;
gdata.xdccsent[(gdata.curtime+1)%XDCC_SENT_SIZE] = 0;
gdata.xdccrecv[(gdata.curtime+1)%XDCC_SENT_SIZE] = 0;
xdccsent = 0;
for (i=0; i<XDCC_SENT_SIZE; i++)
xdccsent += (ir_uint64)gdata.xdccsum[i];
if (((float)xdccsent)/XDCC_SENT_SIZE/1024.0 > gdata.sentrecord)
gdata.sentrecord = ((float)xdccsent)/XDCC_SENT_SIZE/1024.0;
gdata.xdccsum[(gdata.curtime+1)%XDCC_SENT_SIZE] = 0;
run_delayed_jobs();
}
updatecontext();
/*----- see if anything waiting on console ----- */
gdata.needsclear = 0;
if (!gdata.background && FD_ISSET(fileno(stdin), &gdata.readset))
parseconsole();
irc_perform(changesec);
l_perform(changesec);
chat_perform();
t_perform(changesec, changequartersec);
#ifndef WITHOUT_TELNET
telnet_perform();
#endif /* WITHOUT_TELNET */
#ifndef WITHOUT_HTTP
h_perform(changesec, changequartersec);
#endif /* WITHOUT_HTTP */
/*----- time for a delayed shutdown? ----- */
if (changesec && gdata.delayedshutdown)
{
if (!irlist_size(&gdata.trans))
{
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Delayed Shutdown Activated, No Transfers Remaining");
shutdowniroffer();
}
}
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/*----- send server stuff ----- */
if (changesec) {
sendserver();
if (gdata.curtime%INAMNT_SIZE == (INAMNT_SIZE-1))
gnetwork->inamnt[0] = 0;
else
gnetwork->inamnt[gdata.curtime%INAMNT_SIZE+1] = 0;
}
/*----- see if we can send out some xdcc lists */
if (changesec && gnetwork->serverstatus == SERVERSTATUS_CONNECTED) {
if (!irlist_size((&gnetwork->serverq_normal)) && !irlist_size(&(gnetwork->serverq_slow)))
sendxdlqueue();
}
}
gnetwork = NULL;
/*----- see if its time to change maxb */
if (changehour) {
gdata.maxb = gdata.overallmaxspeed;
if (gdata.overallmaxspeeddayspeed != gdata.overallmaxspeed) {
struct tm *localt;
localt = localtime(&gdata.curtime);
if ((unsigned int)localt->tm_hour >= gdata.overallmaxspeeddaytimestart
&& (unsigned int)localt->tm_hour < gdata.overallmaxspeeddaytimeend
&& ( gdata.overallmaxspeeddaydays & (1 << (unsigned int)localt->tm_wday)) )
gdata.maxb = gdata.overallmaxspeeddayspeed;
}
isrotatelog();
expire_options();
}
/*----- see if we've hit a transferlimit or need to reset counters */
if (changesec)
{
unsigned int ii;
unsigned int transferlimits_over = 0;
for (ii=0; ii<NUMBER_TRANSFERLIMITS; ii++)
{
/* reset counters? */
if ((!gdata.transferlimits[ii].ends) ||
(gdata.transferlimits[ii].ends < gdata.curtime))
{
struct tm *localt;
if (gdata.transferlimits[ii].limit && gdata.transferlimits[ii].ends)
{
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Resetting %s transfer limit, used %" LLPRINTFMT "uMB of the %" LLPRINTFMT "uMB limit",
transferlimit_type_to_string(ii),
gdata.transferlimits[ii].used / 1024 / 1024,
gdata.transferlimits[ii].limit / 1024 / 1024);
}
/* find our next end time */
localt = localtime(&gdata.curtime);
localt->tm_sec = localt->tm_min = localt->tm_hour = 0; /* midnight */
switch (ii)
{
case TRANSFERLIMIT_DAILY:
/* tomorrow */
localt->tm_mday++;
break;
case TRANSFERLIMIT_WEEKLY:
/* next sunday morning */
localt->tm_mday += 7 - localt->tm_wday;
break;
case TRANSFERLIMIT_MONTHLY:
/* next month */
localt->tm_mday = gdata.start_of_month;
localt->tm_mon++;
break;
default:
outerror(OUTERROR_TYPE_CRASH, "unknown type %u", ii);
}
/* tm_wday and tm_yday are ignored in mktime() */
gdata.transferlimits[ii].ends = mktime(localt);
gdata.transferlimits[ii].used = 0;
if ( ii == TRANSFERLIMIT_DAILY )
reset_download_limits();
}
if (!transferlimits_over &&
gdata.transferlimits[ii].limit &&
(gdata.transferlimits[ii].used >= gdata.transferlimits[ii].limit))
{
transferlimits_over = 1 + ii;
if (!gdata.transferlimits_over)
{
char *tempstr = transfer_limit_exceeded_msg(ii);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"All %" LLPRINTFMT "uMB of the %s transfer limit used. Stopping transfers.",
gdata.transferlimits[ii].limit / 1024 / 1024,
transferlimit_type_to_string(ii));
/* remove queued users */
queue_all_remove(&gdata.mainqueue, tempstr);
queue_all_remove(&gdata.idlequeue, tempstr);
/* stop transfers */
for (tr = irlist_get_head(&gdata.trans); tr; tr = irlist_get_next(tr))
{
if (tr->tr_status != TRANSFER_STATUS_DONE)
{
gnetwork = &(gdata.networks[tr->net]);
t_closeconn(tr,tempstr,0);
}
}
gnetwork = NULL;
mydelete(tempstr);
}
}
}
if (gdata.transferlimits_over != transferlimits_over)
{
if (!transferlimits_over)
{
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"No longer over any transfer limits. Transfers are now allowed.");
}
gdata.transferlimits_over = transferlimits_over;
}
}
/*----- gdata.autoignore_threshold seconds ----- */
if (changesec && ((unsigned)gdata.curtime > (lastignoredec + gdata.autoignore_threshold)))
{
igninfo *ignore;
lastignoredec += gdata.autoignore_threshold;
ignore = irlist_get_head(&gdata.ignorelist);
while(ignore)
{
ignore->bucket--;
if ((ignore->flags & IGN_IGNORING) && (ignore->bucket == 0))
{
ignore->flags &= ~IGN_IGNORING;
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Ignore removed for %s",ignore->hostmask);
write_statefile();
}
if (ignore->bucket == 0)
{
mydelete(ignore->hostmask);
ignore = irlist_delete(&gdata.ignorelist, ignore);
}
else
{
ignore = irlist_get_next(ignore);
}
}
}
/*----- periodicmsg_time seconds ----- */
if (changesec) {
send_periodicmsg();
}
updatecontext();
/*----- 5 seconds ----- */
if (changesec && (gdata.curtime - last5sec > 4)) {
last5sec = gdata.curtime;
updatecontext();
/*----- server timeout ----- */
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
if (gdata.needsshutdown)
continue;
if ((gnetwork->serverstatus == SERVERSTATUS_CONNECTED) &&
(gdata.curtime > gnetwork->lastservercontact + SRVRTOUT)) {
if (gnetwork->servertime < 3)
{
const char *servname = gnetwork->curserveractualname ? gnetwork->curserveractualname : gnetwork->curserver.hostname;
size_t len = 6 + strlen(servname);
char *tempstr3 = mymalloc(len + 1);
snprintf(tempstr3, len + 1, "PING %s\n", servname);
writeserver_ssl(tempstr3, len);
if (gdata.debug > 0)
{
tempstr3[len-1] = '\0';
len--;
ioutput(OUT_S, COLOR_MAGENTA, "<NORES<: %s", tempstr3);
}
mydelete(tempstr3);
gnetwork->servertime++;
}
else if (gnetwork->servertime == 3) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_RED,
"Closing Server Connection on %s: No Response for %u minutes.",
gnetwork->name, SRVRTOUT/60);
close_server();
gnetwork->servertime = 0;
}
}
/*----- ping server ----- */
if (gnetwork->recentsent) {
pingserver();
gnetwork->recentsent--;
}
}
} /* networks */
gnetwork = NULL;
/*----- 4 seconds ----- */
if (changesec && (gdata.curtime - last4sec > 3))
{
/*----- update lastspeed, check minspeed ----- */
tr = irlist_get_head(&gdata.trans);
while(tr)
{
if ( tr->con.connecttime+(MIN_TL/2) > gdata.curtime ) /* initial */
{
tr->lastspeed =
(tr->lastspeed)*DCL_SPDW_I +
(((float)(tr->bytessent-tr->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_I)/((float)(gdata.curtime-last4sec)*1.0);
}
else /* ongoing */
{
tr->lastspeed =
(tr->lastspeed)*DCL_SPDW_O +
(((float)(tr->bytessent-tr->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_O)/((float)(gdata.curtime-last4sec)*1.0);
}
tr->lastspeedamt = tr->bytessent;
t_checkminspeed(tr);
tr = irlist_get_next(tr);
}
ul = irlist_get_head(&gdata.uploads);
while(ul)
{
if ( ul->con.connecttime+(MIN_TL/2) > gdata.curtime ) /* initial */
{
ul->lastspeed =
(ul->lastspeed)*DCL_SPDW_I +
(((float)(ul->bytesgot-ul->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_I)/((float)(gdata.curtime-last4sec)*1.0);
}
else /* ongoing */
{
ul->lastspeed =
(ul->lastspeed)*DCL_SPDW_O +
(((float)(ul->bytesgot-ul->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_O)/((float)(gdata.curtime-last4sec)*1.0);
}
ul->lastspeedamt = ul->bytesgot;
ul = irlist_get_next(ul);
}
last4sec = gdata.curtime;
}
updatecontext();
/*----- check for size change ----- */
if (changesec)
checktermsize();
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/*----- plist stuff ----- */
if ((gnetwork->serverstatus == SERVERSTATUS_CONNECTED) &&
changemin &&
irlist_size(&gdata.xdccs) &&
!gdata.transferlimits_over &&
(irlist_size(&(gnetwork->serverq_channel)) < irlist_size(&gdata.xdccs)) &&
(!gdata.queuesize || irlist_size(&gdata.mainqueue) < gdata.queuesize) &&
(gdata.nolisting <= gdata.curtime))
{
char *tchanf = NULL, *tchanm = NULL, *tchans = NULL;
for(ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch))
{
if ((ch->flags & CHAN_ONCHAN) &&
(ch->nextann < gdata.curtime) &&
ch->plisttime &&
(((gdata.curtime / 60) % ch->plisttime) == ch->plistoffset))
{
ch->nextmsg = gdata.curtime + ch->delay;
if (ch->pgroup != NULL)
{
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (pgroup)", ch->name);
pubplist = mycalloc(sizeof(userinput));
pubplist->method = method_xdl_channel;
pubplist->net = gnetwork->net;
pubplist->level = ADMIN_LEVEL_PUBLIC;
a_fillwith_plist(pubplist, ch->name, ch);
u_parseit(pubplist);
mydelete(pubplist);
continue;
}
if (ch->flags & CHAN_MINIMAL)
{
if (tchanm)
{
strncat(tchanm,",",maxtextlength-strlen(tchanm)-1);
strncat(tchanm,ch->name,maxtextlength-strlen(tchanm)-1);
}
else
{
tchanm = mymalloc(maxtextlength);
strncpy(tchanm,ch->name,maxtextlength-1);
}
}
else if (ch->flags & CHAN_SUMMARY)
{
if (tchans)
{
strncat(tchans,",",maxtextlength-strlen(tchans)-1);
strncat(tchans,ch->name,maxtextlength-strlen(tchans)-1);
}
else
{
tchans = mymalloc(maxtextlength);
strncpy(tchans,ch->name,maxtextlength-1);
}
}
else
{
if (tchanf)
{
strncat(tchanf,",",maxtextlength-strlen(tchanf)-1);
strncat(tchanf,ch->name,maxtextlength-strlen(tchanf)-1);
}
else
{
tchanf = mymalloc(maxtextlength);
strncpy(tchanf,ch->name,maxtextlength-1);
}
}
}
}
if (tchans)
{
if (gdata.restrictprivlist && !gdata.creditline && !irlist_size(&gdata.headline))
{
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR,
"Can't send Summary Plist to %s (restrictprivlist is set and no creditline or headline, summary makes no sense!)", tchans);
}
else
{
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (summary)", tchans);
pubplist = mycalloc(sizeof(userinput));
a_fillwith_msg2(pubplist, tchans, "XDL");
pubplist->method = method_xdl_channel_sum;
u_parseit(pubplist);
mydelete(pubplist);
}
mydelete(tchans);
}
if (tchanf) {
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (full)", tchanf);
pubplist = mycalloc(sizeof(userinput));
a_fillwith_plist(pubplist, tchanf, NULL);
pubplist->method = method_xdl_channel;
u_parseit(pubplist);
mydelete(pubplist);
mydelete(tchanf);
}
if (tchanm) {
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (minimal)", tchanm);
pubplist = mycalloc(sizeof(userinput));
a_fillwith_msg2(pubplist, tchanm, "XDL");
pubplist->method = method_xdl_channel_min;
u_parseit(pubplist);
mydelete(pubplist);
mydelete(tchanm);
}
}
} /* networks */
gnetwork = NULL;
updatecontext();
/*----- low bandwidth send, save state file ----- */
if (changesec && (gdata.curtime - last3min > 180)) {
last3min = gdata.curtime;
xdccsent = 0;
for (i=0; i<XDCC_SENT_SIZE; i++)
xdccsent += (ir_uint64)gdata.xdccsent[i];
xdccsent /= XDCC_SENT_SIZE*1024;
if ((xdccsent < (unsigned)gdata.lowbdwth) &&
!gdata.exiting &&
irlist_size(&gdata.mainqueue) &&
(irlist_size(&gdata.trans) < gdata.maxtrans))
{
check_idle_queue(0);
send_from_queue(1, 0, NULL);
}
write_files();
}
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/*----- queue notify ----- */
if (changesec && gdata.notifytime && (!gdata.quietmode) &&
((unsigned)gdata.curtime > (gnetwork->lastnotify + (gdata.notifytime*60))))
{
gnetwork->lastnotify = gdata.curtime;
if (gnetwork->serverstatus == SERVERSTATUS_CONNECTED)
{
if ((irlist_size(&(gnetwork->serverq_fast)) >= 10) ||
(irlist_size(&(gnetwork->serverq_normal)) >= 10) ||
(irlist_size(&(gnetwork->serverq_slow)) >= 50))
{
ioutput(OUT_S|OUT_D|OUT_L, COLOR_NO_COLOR,
"notifications skipped on %s, server queue is rather large",
gnetwork->name);
}
else
{
notifyqueued();
notifybandwidth();
notifybandwidthtrans();
}
}
}
} /* networks */
gnetwork = NULL;
updatecontext();
/*----- log stats / remote admin stats ----- */
if ( changesec &&
((unsigned)gdata.curtime >= (last2min + gdata.status_time_dcc_chat)))
{
last2min = gdata.curtime;
if (gdata.logstats)
{
logstat();
chat_writestatus();
}
}
updatecontext();
/* look to see if any files changed */
if (changesec)
look_for_file_remove();
updatecontext();
/*----- 20 seconds ----- */
if (changesec && (gdata.curtime - last20sec > 19)) {
expire_badip();
if (gdata.logfd != FD_UNUSED)
{
/* cycle */
close(gdata.logfd);
gdata.logfd = FD_UNUSED;
}
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/* try rejoining channels not on */
ch = irlist_get_head(&(gnetwork->channels));
while(ch)
{
if ((gnetwork->serverstatus == SERVERSTATUS_CONNECTED) &&
!(ch->flags & CHAN_ONCHAN))
{
joinchannel(ch);
}
ch = irlist_get_next(ch);
}
} /* networks */
gnetwork = NULL;
last20sec = gdata.curtime;
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/* try to regain nick */
if (!gnetwork->user_nick || strcmp(get_config_nick(), gnetwork->user_nick))
{
writeserver(WRITESERVER_NORMAL, "NICK %s", get_config_nick());
}
} /* networks */
gnetwork = NULL;
updatecontext();
/* update status line */
if (!gdata.background && !gdata.noscreen) {
char tempstr[maxtextlength];
char tempstr2[maxtextlengthshort];
if (gdata.attop) gotobot();
tostdout(IRVT_SAVE_CURSOR);
getstatusline(tempstr,maxtextlength);
tempstr[min2(maxtextlength-2,gdata.termcols-4)] = '\0';
snprintf(tempstr2, maxtextlengthshort, IRVT_CURSOR_HOME1 "[ %%-%us ]", gdata.termlines - 1, gdata.termcols - 4);
tostdout(tempstr2,tempstr);
tostdout(IRVT_CURSOR_HOME2 IRVT_UNSAVE_CURSOR, gdata.termlines, gdata.termcols);
}
admin_jobs();
#ifdef USE_RUBY
rehash_myruby(1);
#endif /* USE_RUBY */
delayed_announce();
}
updatecontext();
if (changemin)
{
reverify_restrictsend();
update_hour_dinoex(lastmin);
check_idle_queue(0);
clean_uploadhost();
auto_rehash();
}
updatecontext();
if ((gdata.md5build.file_fd != FD_UNUSED) &&
FD_ISSET(gdata.md5build.file_fd, &gdata.readset))
{
ssize_t howmuch;
#if defined(_OS_CYGWIN)
int reads_per_loop = 32;
#else /* _OS_CYGWIN */
int reads_per_loop = 64;
#endif /* _OS_CYGWIN */
assert(gdata.md5build.xpack);
while (reads_per_loop--)
{
howmuch = read(gdata.md5build.file_fd, gdata.sendbuff, BUFFERSIZE);
if (gdata.debug >30)
{
ioutput(OUT_S, COLOR_YELLOW, "MD5: [Pack %u] read %ld",
number_of_pack(gdata.md5build.xpack), (long)howmuch);
}
if ((howmuch < 0) && (errno != EAGAIN))
{
outerror(OUTERROR_TYPE_WARN, "MD5: [Pack %u] Can't read data from file '%s': %s",
number_of_pack(gdata.md5build.xpack),
gdata.md5build.xpack->file, strerror(errno));
event_close(gdata.md5build.file_fd);
gdata.md5build.file_fd = FD_UNUSED;
gdata.md5build.xpack = NULL;
break;
}
else if (howmuch < 0)
{
break;
}
else if (howmuch == 0)
{
/* EOF */
outerror(OUTERROR_TYPE_WARN, "MD5: [Pack %u] Can't read data from file '%s': %s",
number_of_pack(gdata.md5build.xpack),
gdata.md5build.xpack->file, "truncated");
start_md5_hash(gdata.md5build.xpack, number_of_pack(gdata.md5build.xpack));
break;
}
/* else got data */
MD5Update(&gdata.md5build.md5sum, gdata.sendbuff, howmuch);
if (!gdata.nocrc32)
crc32_update((char *)gdata.sendbuff, howmuch);
gdata.md5build.bytes += howmuch;
if (gdata.md5build.bytes == gdata.md5build.xpack->st_size)
{
complete_md5_hash();
break;
}
}
}
if (!gdata.nomd5sum && changesec && (!gdata.md5build.xpack))
{
unsigned int packnum = 1;
/* see if any pack needs a md5sum calculated */
if (gdata.nomd5_start <= gdata.curtime)
for (xd = irlist_get_head(&gdata.xdccs); xd; xd = irlist_get_next(xd), packnum++)
{
if (!gdata.nocrc32)
{
if (!xd->has_crc32)
xd->has_md5sum = 0; /* force recheck with crc */
}
if (!xd->has_md5sum)
{
if (verifyshell(&gdata.md5sum_exclude, xd->file))
continue;
if (!gdata.attop) gototop();
start_md5_hash(xd, packnum);
break;
}
}
}
updatecontext();
if (gdata.exiting && has_closed_servers()) {
for (chat = irlist_get_head(&gdata.dccchats);
chat;
chat = irlist_delete(&gdata.dccchats,chat))
{
writedccchat(chat, 0, "iroffer exited, Closing DCC Chat\n");
shutdowndccchat(chat,1);
}
mylog("iroffer exited\n\n");
exit_iroffer(0);
}
updatecontext();
if (gdata.needsrehash) {
gdata.needsrehash = 0;
urehash = mycalloc(sizeof(userinput));
a_fillwith_msg2(urehash, NULL, "REHASH");
urehash->method = method_out_all; /* just OUT_S|OUT_L|OUT_D it */
urehash->net = 0;
urehash->level = ADMIN_LEVEL_FULL;
u_parseit(urehash);
mydelete(urehash);
}
updatecontext();
chat = irlist_get_head(&gdata.dccchats);
while (chat)
{
if (chat->status == DCCCHAT_UNUSED)
{
chat = irlist_delete(&gdata.dccchats,chat);
}
else
{
flushdccchat(chat);
chat = irlist_get_next(chat);
}
}
if (gdata.autoadd_time > 0)
{
if (changesec && ((unsigned)gdata.curtime > (lastautoadd + gdata.autoadd_time)))
{
lastautoadd = gdata.curtime;
autoadd_all();
}
}
/* END */
updatecontext();
if (gdata.needsclear) drawbot();
changehour=changemin=0;
}
