int ns_write_chksum_flush(NetStream_t *ns)
{
char chksum_value[CHKSUM_MAX_SIZE];
int err, n;
tbuffer_t buf;
log_printf(15, "ns_write_chksum_flush: injecting chksum! ns=%d type=%d bytesleft=" I64T " bsize=" I64T "\n",
ns_getid(ns), chksum_type(&(ns->write_chksum.chksum)), ns->write_chksum.bytesleft, ns->write_chksum.blocksize);
flush_log();
if (ns_write_chksum_state(ns) == 0) return(0);
if (ns->write_chksum.bytesleft == ns->write_chksum.blocksize) return(0); //** Nothing to do
n = chksum_size(&(ns->write_chksum.chksum), CHKSUM_DIGEST_HEX);
chksum_get(&(ns->write_chksum.chksum), CHKSUM_DIGEST_HEX, chksum_value);
ns->write_chksum.is_running = 0; //** Don't want to get in an endless loop
tbuffer_single(&buf, n, chksum_value);
err = _write_netstream_block(ns, apr_time_now() + apr_time_make(5,0), &buf, 0, n, 0);
ns->write_chksum.is_running = 1;
if (err != 0) {
log_printf(10, "ns_write_chksum_flush: ns=%d Error writing chksum! error=%d\n", ns_getid(ns), err);
return(err);
}
chksum_value[n] = '\0';
log_printf(15, "ns_write_chksum_flush: ns=%d chksum_value=%s\n", ns_getid(ns), chksum_value);
log_printf(15, "ns_write_chksum_flush: end of routine! ns=%d\n err=%d", ns_getid(ns), err);
flush_log();
return(err);
}
void close_server_port(ns_monitor_t *nm)
{
apr_status_t dummy;
//** Trigger a port shutdown
apr_thread_mutex_lock(nm->lock);
nm->shutdown_request = 1;
log_printf(15, "close_server_port: port=%d Before cond_signal\n", nm->port);
flush_log();
apr_thread_cond_signal(nm->cond);
log_printf(15, "close_server_port: port=%d After cond_signal\n", nm->port);
flush_log();
apr_thread_mutex_unlock(nm->lock);
log_printf(15, "close_server_port: port=%d After unlock\n", nm->port);
flush_log();
//** Wait until the thread closes
apr_thread_join(&dummy, nm->thread);
log_printf(15, "close_server_port: port=%d After join\n", nm->port);
flush_log();
//** Free the actual struct
free(nm->address);
apr_thread_mutex_destroy(nm->lock);
apr_thread_cond_destroy(nm->cond);
apr_pool_destroy(nm->mpool);
nm->port = -1;
}
void lock_tc(ibp_task_t *task)
{
log_printf(15, "lock_tc: Locking....ns=%d\n", task->ns->id); flush_log();
pthread_mutex_lock(&(task->tc->lock));
log_printf(15, "lock_tc: ....got it ns=%d\n", task->ns->id); flush_log();
}
op_generic_t *gop_waitany(op_generic_t *g)
{
op_generic_t *gop = g;
callback_t *cb;
lock_gop(g);
if (gop_get_type(g) == Q_TYPE_QUE) {
log_printf(15, "sync_exec_que_check gid=%d stack_size=%d started_exec=%d\n", gop_id(g), stack_size(g->q->opque->qd.list), g->base.started_execution);
if ((stack_size(g->q->opque->qd.list) == 1) && (g->base.started_execution == 0)) { //** See if we can directly exec
g->base.started_execution = 1;
cb = (callback_t *)pop(g->q->opque->qd.list);
gop = (op_generic_t *)cb->priv;
log_printf(15, "sync_exec_que -- waiting for pgid=%d cgid=%d to complete\n", gop_id(g), gop_id(gop));
unlock_gop(g);
gop_waitany(gop);
pop(g->q->finished); //** Remove it from the finished list.
return(gop);
} else {
_gop_start_execution(g); //** Make sure things have been submitted
while (((gop = (op_generic_t *)pop(g->q->finished)) == NULL) && (g->q->nleft > 0)) {
apr_thread_cond_wait(g->base.ctl->cond, g->base.ctl->lock); //** Sleep until something completes
}
}
if (gop != NULL) log_printf(15, "POP finished qid=%d gid=%d\n", gop_id(g), gop_id(gop));
//log_printf(15, "Printing qid=%d finished stack\n", gop_id(g));
//_opque_print_stack(g->q->finished);
} else {
log_printf(15, "gop_waitany: BEFORE (type=op) While gid=%d state=%d\n", gop_id(g), g->base.state);
flush_log();
if ((g->base.pc->fn->sync_exec != NULL) && (g->base.started_execution == 0)) { //** See if we can directly exec
unlock_gop(g); //** Don't need this for a direct exec
log_printf(15, "sync_exec -- waiting for gid=%d to complete\n", gop_id(g));
g->base.pc->fn->sync_exec(g->base.pc, g);
log_printf(15, "sync_exec -- gid=%d completed with err=%d\n", gop_id(g), g->base.state);
return(g);
} else { //** Got to submit it normally
unlock_gop(g); //** It's a single task so no need to hold the lock. Otherwise we can deadlock
_gop_start_execution(g); //** Make sure things have been submitted
lock_gop(g); //** but we do need it for detecting when we're finished.
while (g->base.state == 0) {
apr_thread_cond_wait(g->base.ctl->cond, g->base.ctl->lock); //** Sleep until something completes
}
}
log_printf(15, "gop_waitany: AFTER (type=op) While gid=%d state=%d\n", gop_id(g), g->base.state);
flush_log();
}
unlock_gop(g);
return(gop);
}
int ns_read_chksum_flush(NetStream_t *ns)
{
char ns_value[CHKSUM_MAX_SIZE], chksum_value[CHKSUM_MAX_SIZE];
int err, n;
tbuffer_t buf;
log_printf(15, "ns_read_chksum_flush: Reading chksum! ns=%d type=%d bleft=" I64T " bsize=" I64T " state=%d\n",
ns_getid(ns), chksum_type(&(ns->read_chksum.chksum)), ns->read_chksum.bytesleft, ns->read_chksum.blocksize, ns_read_chksum_state(ns));
flush_log();
if (ns_read_chksum_state(ns) == 0) return(0);
if (ns->read_chksum.bytesleft == ns->read_chksum.blocksize) return(0); //** Nothing to do
n = chksum_size(&(ns->read_chksum.chksum), CHKSUM_DIGEST_HEX);
ns->read_chksum.is_running = 0; //** Don't want to get in an endless loop
tbuffer_single(&buf, n, ns_value);
err = _read_netstream_block(ns, apr_time_now() + apr_time_make(5,0), &buf, 0, n, 0);
ns_value[n] = '\0';
ns->read_chksum.is_running = 1;
log_printf(15, "ns_read_chksum_flush: Finished reading chksum! ns=%d\n", ns_getid(ns));
flush_log();
if (err != 0) {
log_printf(10, "ns_read_chksum_flush: ns=%d Error reading chksum! error=%d\n", ns_getid(ns), err);
return(err);
}
chksum_get(&(ns->read_chksum.chksum), CHKSUM_DIGEST_HEX, chksum_value);
log_printf(15, "ns_read_chksum_flush: after chksum_get! ns=%d\n", ns_getid(ns));
flush_log();
err = (strncmp(chksum_value, ns_value, n) == 0) ? 0 : 1;
log_printf(15, "ns_read_chksum_flush: ns=%d ns_value=%s cmp=%d\n", ns_getid(ns), ns_value, err);
log_printf(15, "ns_read_chksum_flush: ns=%d chksum_value=%s\n", ns_getid(ns), chksum_value);
if (err != 0) {
log_printf(1, "ns_read_chksum_flush: ns=%d chksum error!\n", ns_getid(ns));
log_printf(1, "ns_read_chksum_flush: ns=%d ns_value=%s cmp=%d\n", ns_getid(ns), ns_value, err);
log_printf(1, "ns_read_chksum_flush: ns=%d chksum_value=%s\n", ns_getid(ns), chksum_value);
}
log_printf(15, "ns_read_chksum_flush: end of routine! ns=%d\n err=%d", ns_getid(ns), err);
flush_log();
return(err);
}
static apr_status_t flush_all_logs(void *data)
{
server_rec *s = data;
multi_log_state *mls;
apr_array_header_t *log_list;
config_log_state *clsarray;
buffered_log *buf;
int i;
if (!buffered_logs)
return APR_SUCCESS;
for (; s; s = s->next) {
mls = ap_get_module_config(s->module_config, &log_config_module);
log_list = NULL;
if (mls->config_logs->nelts) {
log_list = mls->config_logs;
}
else if (mls->server_config_logs) {
log_list = mls->server_config_logs;
}
if (log_list) {
clsarray = (config_log_state *) log_list->elts;
for (i = 0; i < log_list->nelts; ++i) {
buf = clsarray[i].log_writer;
flush_log(buf);
}
}
}
return APR_SUCCESS;
}
/*
* Test the target system's sleep routine to decide whether we should busy wait
* by default for sleeps shorter in duration than SLEEP_BUSY_THRESHOLD
*/
void sleep_test (void)
{
int result;
currprefs.dont_busy_wait = 1;
#ifndef SLEEP_DONT_BUSY_WAIT
if (rpt_available) {
uae_u64 total = 0;
int result;
int num_tests;
int i;
write_log ("Testing system sleep function"); flush_log ();
/* Do a few tests to get a rough idea how fast we can do it */
num_tests = 16;
for (i=0; i < num_tests; i++)
total += do_sleep_test (1);
/* How many for 2 seconds worth of tests . . . */
num_tests = 2 * syncbase * num_tests / total;
total = 0;
/* Now the test proper */
for (i = 0; i < num_tests; i++) {
total += do_sleep_test (1);
if (i - (i % 100) == i) {
write_log (".");
flush_log ();
}
}
result = (1000 * total / syncbase) / num_tests;
write_log ("\nAverage duration of a 1ms sleep: %d ms\n", result);
if (result > SLEEP_BUSY_THRESHOLD) {
currprefs.dont_busy_wait = 0;
write_log ("Enabling busy-waiting for sub-%dms sleeps\n", SLEEP_BUSY_THRESHOLD);
}
}
#endif
}
CScriptEngine::~CScriptEngine ()
{
while (!m_script_processes.empty())
remove_script_process(m_script_processes.begin()->first);
flush_log ();
#ifdef USE_DEBUGGER
xr_delete (m_scriptDebugger);
#endif
}
inline void update_log_cnt()
{
log_cnt++;
if (log_cnt == MAX_LOG_CNT)
{
printk("CUBIC: ram log buffer overflow\n");
flush_log();
}
}
void write_log (const TCHAR *format, ...)
{
int count;
TCHAR buffer[WRITE_LOG_BUF_SIZE], *ts;
int bufsize = WRITE_LOG_BUF_SIZE;
TCHAR *bufp;
va_list parms;
if (!cs_init)
return;
premsg ();
if (!_tcsicmp (format, _T("*")))
count = 0;
EnterCriticalSection (&cs);
va_start (parms, format);
bufp = buffer;
for (;;) {
count = _vsntprintf (bufp, bufsize - 1, format, parms);
if (count < 0) {
bufsize *= 10;
if (bufp != buffer)
xfree (bufp);
bufp = xmalloc (TCHAR, bufsize);
continue;
}
break;
}
bufp[bufsize - 1] = 0;
if (!_tcsncmp (bufp, _T("write "), 6))
bufsize--;
ts = writets ();
if (bufp[0] == '*')
count++;
if (SHOW_CONSOLE || console_logging) {
if (lfdetected && ts)
writeconsole (ts);
writeconsole (bufp);
}
if (debugfile) {
if (lfdetected && ts)
_ftprintf (debugfile, _T("%s"), ts);
_ftprintf (debugfile, _T("%s"), bufp);
}
lfdetected = 0;
if (_tcslen (bufp) > 0 && bufp[_tcslen (bufp) - 1] == '\n')
lfdetected = 1;
va_end (parms);
if (bufp != buffer)
xfree (bufp);
if (always_flush_log)
flush_log ();
LeaveCriticalSection (&cs);
}
CScriptEngine::~CScriptEngine()
{
while (!m_script_processes.empty())
remove_script_process(m_script_processes.begin()->first);
#ifdef DEBUG
flush_log();
#else
# ifdef LUA_DEBUG_PRINT
flush_log();
# endif //-LUA_DEBUG_PRINT
#endif //-DEBUG
#ifdef USE_DEBUGGER
# ifndef USE_LUA_STUDIO
xr_delete (m_scriptDebugger);
# else // #ifndef USE_LUA_STUDIO
disconnect_from_debugger();
# endif // #ifndef USE_LUA_STUDIO
#endif
}
int compare_buffers_print(char *b1, char *b2, int len, ex_off_t offset)
{
int i, k, mode, last, ok, err, last_byte;
ex_off_t start, end;
err = 0;
mode = (b1[0] == b2[0]) ? 0 : 1;
start = offset;
last = len - 1;
log_printf(0, "Printing comparision breakdown -- Single byte matches are suppressed (len=%d)\n", len);
b1[len] = 0;
b2[len]=0;
log_printf(15, "b1=%s\n", b1);
log_printf(15, "b2=%s\n", b2);
for (i=0; i<len; i++) {
if (mode == 0) { //** Matching range
if ((b1[i] != b2[i]) || (last == i)) {
last_byte = ((last == i) && (b1[i] == b2[i])) ? 1 : 0;
end = offset + i-1 + last_byte;
k = end - start + 1;
log_printf(0, " MATCH : %d -> %d (%d bytes)\n", start, end, k);
start = offset + i;
mode = 1;
}
} else {
if ((b1[i] == b2[i]) || (last == i)) {
ok = 0; //** Suppress single byte matches
if (last != i) {
if (b1[i+1] == b2[i+1]) ok = 1;
}
if ((ok == 1) || (last == i)) {
last_byte = ((last == i) && (b1[i] != b2[i])) ? 1 : 0;
end = offset + i-1 + last_byte;
k = end - start + 1;
log_printf(0, " DIFFER: %d -> %d (%d bytes)\n", start, end, k);
start = offset + i;
mode = 0;
err = 1;
}
}
}
}
//i=(b1[last] == b2[last]) ? 0 : 1;
//log_printf(0, "last compare=%d lst=%d\n", i, last);
flush_log();
return(err);
}
Resource_t *resource_list_iterator_next(Resource_list_t *rl, resource_list_iterator_t *it)
{
int i;
Resource_t *r;
log_printf(15, "resource_list_iterator_next: start it=%d max=%d n=%d\n", *it, rl->max_res, rl->n); flush_log();
apr_thread_mutex_lock(rl->lock);
for (i=*it; i<rl->max_res; i++) {
if (rl->res[i].used == 1) {
*it = i + 1;
r = rl->res[i].r;
apr_thread_mutex_unlock(rl->lock);
log_printf(15, "resource_list_iterator_next: i=%d r=%s\n", i, r->name); flush_log();
return(r);
}
}
log_printf(15, "resource_list_iterator_next: r=NULL\n"); flush_log();
apr_thread_mutex_unlock(rl->lock);
return(NULL);
}
int select_console(ioType t) {
static ioType curType = CONSOLE_VACUUM;
switch (t) {
case CONSOLE_VACUUM : curIo = (console_io*)&vacuum_console_functions; break;
case CONSOLE_LOG : curIo = (console_io*)&log_console_functions; break;
case CONSOLE_SERIAL : curIo = (console_io*)&serial_console_functions; break;
#if defined(USE_KBD_SUPPORT) && defined(USE_VGA_SUPPORT)
case CONSOLE_VGA : curIo = (console_io*)&vga_console_functions; break;
#endif
default : curIo = (console_io*)&vacuum_console_functions;break;
}
if (curType == CONSOLE_LOG) flush_log();
curType = t;
return 0;
}
void die(char *message, char *arg1, int exit_code)
{
char *errmess = strerror(errno);
if (!arg1)
arg1 = errmess;
log_stderr = 1; /* print as well as log when we die.... */
fputc('\n', stderr); /* prettyfy startup-script message */
my_syslog(LOG_CRIT, message, arg1, errmess);
log_stderr = 0;
my_syslog(LOG_CRIT, _("FAILED to start up"));
flush_log();
exit(exit_code);
}
void _close_ns(NetStream_t *ns)
{
log_printf(10, "close_netstream: Closing stream ns=%d type=%d\n", ns->id, ns->sock_type);
flush_log();
ns->cuid = -1;
if (ns->sock == NULL) return;
if (ns->sock_status(ns->sock) != 1) return;
ns->close(ns->sock);
ns->sock = NULL;
return;
}
static apr_status_t ap_buffered_log_writer(request_rec *r,
void *handle,
const char **strs,
int *strl,
int nelts,
apr_size_t len)
{
char *str;
char *s;
int i;
apr_status_t rv;
buffered_log *buf = (buffered_log*)handle;
if ((rv = APR_ANYLOCK_LOCK(&buf->mutex)) != APR_SUCCESS) {
return rv;
}
if (len + buf->outcnt > LOG_BUFSIZE) {
flush_log(buf);
}
if (len >= LOG_BUFSIZE) {
apr_size_t w;
str = apr_palloc(r->pool, len + 1);
for (i = 0, s = str; i < nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
w = len;
rv = apr_file_write(buf->handle, str, &w);
}
else {
for (i = 0, s = &buf->outbuf[buf->outcnt]; i < nelts; ++i) {
memcpy(s, strs[i], strl[i]);
s += strl[i];
}
buf->outcnt += len;
rv = APR_SUCCESS;
}
APR_ANYLOCK_UNLOCK(&buf->mutex);
return rv;
}
/*
* Calibrate PPC timebase frequency the hard way...
* This is still dumb and horribly inefficient.
*/
static frame_time_t machdep_calibrate_timebase (void)
{
const int num_loops = 5;
frame_time_t last_time;
frame_time_t best_time;
int i;
write_log ("Calibrating timebase...\n");
flush_log ();
sync ();
last_time = read_processor_time ();
for (i = 0; i < num_loops; i++)
uae_msleep (1000);
best_time = read_processor_time () - last_time;
return best_time / num_loops;
}
void KSYkt_Log_Writer::writelog(const char *fmt,...)
{
int pos = 0;
char msg[4096] = "";
char time_str[15] = "";
get_current_time(time_str);
if(open_current_log_file())
return;
pos = sprintf(msg,"%s - : ",time_str);
va_list args;
va_start(args,fmt);
pos += vsprintf(msg+pos,fmt,args);
va_end(args);
msg[pos] = '\n';
msg[pos+1] = 0;
fprintf(log_file_fp_,msg);
flush_log();
}
op_generic_t *gop_dummy(op_status_t state)
{
op_generic_t *gop;
type_malloc_clear(gop, op_generic_t, 1);
log_printf(15, " state=%d\n", state.op_status);
flush_log();
gop_init(gop);
gop->base.pc = &_gop_dummy_pc;
gop->type = Q_TYPE_OPERATION;
// gop->base.started_execution = 1;
gop->base.free = _gop_dummy_free;
gop->base.status = state;
// gop_mark_completed(gop, state);
return(gop);
}
static int finish_log(struct thread_data *td, struct io_log *log, int trylock)
{
if (td->tp_data)
iolog_flush(log, 1);
if (trylock) {
if (fio_trylock_file(log->filename))
return 1;
} else
fio_lock_file(log->filename);
if (td->client_type == FIO_CLIENT_TYPE_GUI)
fio_send_iolog(td, log, log->filename);
else
flush_log(log);
fio_unlock_file(log->filename);
free_log(log);
return 0;
}
void _fail_unless(
int result,
const char *file,
int line,
const char *expr,
...)
{
if(unlikely(!result)) {
va_list ap;
char buf[512];
va_start(ap, expr);
const char *msg = va_arg(ap, char *);
if(msg == NULL) msg = expr;
vsnprintf(buf, sizeof(buf), msg, ap);
va_end(ap);
printf("Bail out! %s (`%s' in %s:%d)\n", buf, expr, file, line);
flush_log(true);
exit_on_fail();
}
static int sysmon_toggle_write(struct file *sp_file, const char __user *buf,
size_t size, loff_t *offset)
{
if (size == 2) // 2 includes the number and \0
{
const char number = buf[0];
if (number == '0')
{
is_logging_toggled = 0;
printk(KERN_INFO "Sysmon log disabled.\n");
return size;
}
else if (number == '1')
{
is_logging_toggled = 1;
printk(KERN_INFO "Sysmon log enabled.\n");
return size;
}
}
if (size == 6)
{
char *str = kmalloc(size, GFP_KERNEL);
if (copy_from_user(str, buf, size)) {
kfree(str);
return -EFAULT;
}
sscanf(buf, "%6s", str);
if (strcmp(str, "flush") == 0)
{
printk(KERN_INFO "Flushing log\n");
flush_log();
}
kfree(str);
return size;
}
return -EINVAL;
}
int main(int argc, char *argv[]){
//Option Switch
if (argc > 1){
char select = *++argv[1];
switch(select){
case 'd':
printf("Command Executed:\t%s\n",command);
printf("Parameter: %c\n",select);
break;
case 'f':
flush_log();
printf("Parameter: %c\n",select);
break;
case 'p':
messageBx("Ping Network!");
int limit = 10;
if (argc == 3){
limit = atoi(argv[2]);
}
sprintf(command,"date /T >> %s",filename);
system(command);
sprintf(command,"ping -n %i %s >> %s",limit,dest_a,filename);
system(command);
sprintf(command,"ping -n %i %s >> %s",limit,dest_b,filename);
system(command);
break;
case 'v':
messageBx("Display Log::");
sprintf(command,"type %s",filename);
system(command);
break;
default:
printf("");
break;
}
}
return 0;
}
void ns_config_sock(NetStream_t *ns, int tcpsize)
{
log_printf(10, "ns_config_sock: ns=%d, \n", ns->id);
_ns_init(ns, 0);
ns->sock_type = NS_TYPE_SOCK;
network_sock_t *sock = (network_sock_t *)malloc(sizeof(network_sock_t));
assert(sock != NULL);
memset(sock, 0, sizeof(network_sock_t));
ns->sock = (net_sock_t *)sock;
// assert_result_not(apr_pool_create(&(sock->mpool), NULL), APR_SUCCESS);
int err = apr_pool_create(&(sock->mpool), NULL);
if (err != APR_SUCCESS) {
log_printf(0, "ns_config_sock: apr_pool_crete error = %d\n", err);
flush_log();
assert(err == APR_SUCCESS);
}
//**QWERT
apr_thread_mutex_create(&(sock->lock), APR_THREAD_MUTEX_DEFAULT,sock->mpool);
//**QWERTY
sock->tcpsize = tcpsize;
ns->native_fd = sock_native_fd;
ns->connect = sock_connect;
ns->sock_status = sock_status;
ns->set_peer = sock_set_peer;
ns->close = sock_close;
// ns->read = sock_read;
// ns->write = sock_write;
ns->read = sock_apr_read;
ns->write = sock_apr_write;
ns->accept = sock_accept;
ns->bind = sock_bind;
ns->listen = sock_listen;
ns->connection_request = sock_connection_request;
}
Task_que_t *create_task_que()
{
Task_que_t *tq;
// if ((tq = g_slice_new(Task_que_t)) == NULL) {
if ((tq = (Task_que_t *)malloc(sizeof(Task_que_t))) == NULL) {
log_printf(0, "create_task_que: Unable to allocate new struct!\n");
flush_log();
return(NULL);
}
tq->cid = NULL;
tq->refcount = 0;
tq->op = -1;
tq->owner = -1;
tq->lock_inuse = 0;
tq->io_que[TASK_READ_QUE] = new_stack();
tq->io_que[TASK_WRITE_QUE] = new_stack();
pthread_mutex_init(&(tq->qlock), NULL);
return(tq);
}
static void flush_all_logs(server_rec *s, pool *p)
{
multi_log_state *mls;
array_header *log_list;
config_log_state *clsarray;
int i;
for (; s; s = s->next) {
mls = ap_get_module_config(s->module_config, &config_log_module);
log_list = NULL;
if (mls->config_logs->nelts) {
log_list = mls->config_logs;
}
else if (mls->server_config_logs) {
log_list = mls->server_config_logs;
}
if (log_list) {
clsarray = (config_log_state *) log_list->elts;
for (i = 0; i < log_list->nelts; ++i) {
flush_log(&clsarray[i]);
}
}
}
}
void machdep_init (void)
{
static int done = 0;
if (!done) {
rpt_available = 1;
write_log ("Calibrating timebase: ");
flush_log ();
loops_to_go = 5;
sync ();
last_time = read_processor_time ();
uae_msleep (loops_to_go * 1000);
best_time = read_processor_time () - last_time;
syncbase = best_time / loops_to_go;
write_log ("%.6f MHz\n", (double) syncbase / 1000000);
sleep_test();
done = 1;
}
}
/** To integrate without any bookkeeping
*
* This function just executes the integration implementation
* The callee has to take care of systems running and
* stop conditions and memory management
*
*/
virtual void core_integrate() {
launch_integrator();
flush_log();
}
int main(int argc, const char **argv)
{
vector<const char*> args;
Config_t config;
char *config_file;
int i;
global_config = &config; //** Make the global point to what's loaded
memset(global_config, 0, sizeof(Config_t)); //** init the data
global_network = NULL;
if (argc < 2) {
printf("ibp_server [-d] config_file\n\n");
printf("-d - Run as a daemon\n");
printf("config_file - Configuration file\n");
return(0);
}
int astart = 1;
int daemon = 0;
if (strcmp(argv[astart], "-d") == 0) {
daemon = 1;
argv[astart] = "";
astart++;
}
config_file = (char *)argv[astart];
argv_to_vec(argc, argv, args);
parse_config_options(args); // These are for EBOFS
//*** Open the config file *****
printf("Config file: %s\n\n", config_file);
GKeyFile *keyfile;
GKeyFileFlags flags;
GError *error = NULL;
keyfile = g_key_file_new();
flags = G_KEY_FILE_NONE;
/* Load the GKeyFile from disk or return. */
if (!g_key_file_load_from_file (keyfile, config_file, flags, &error)) {
g_error (error->message);
return(-1);
}
//** Parse the global options first ***
parse_config(keyfile, &config);
init_thread_slots(2*config.server.max_threads); //** Make pigeon holes
dns_cache_init(1000);
init_subnet_list(config.server.iface[0].hostname);
//*** Install the commands: loads Vectable info and parses config options only ****
install_commands(keyfile);
g_key_file_free(keyfile); //Free the keyfile context
set_starttime();
log_preamble(&config);
configure_signals(); //** Setup the signal handlers
//*** Set up the shutdown variables
pthread_mutex_init(&shutdown_lock, NULL);
pthread_mutex_unlock(&shutdown_lock);
shutdown_now = 0;
//*** Make the searchable version of the resources ***
config.rl = create_resource_list(config.res, config.n_resources);
// log_printf(0, "Looking up resource 2 and printing info.....\n")
// print_resource(resource_lookup(config.rl, "2"), log_fd());
init_stats(config.server.stats_size);
lock_alloc_init();
//***Launch as a daemon if needed***
if (args.size() == 2) { //*** Launch as a daemon ***
if ((strcmp(config.server.logfile, "stdout") == 0) ||
(strcmp(config.server.logfile, "stderr") == 0)) {
log_printf(0, "Can't launch as a daemom because log_file is either stdout or stderr\n");
log_printf(0, "Running in normal mode\n");
} else if (fork() == 0) { //** This is the daemon
log_printf(0, "Running as a daemon.\n");
flush_log();
fclose(stdin); //** Need to close all the std* devices **
fclose(stdout);
fclose(stderr);
char fname[1024];
fname[1023] = '\0';
snprintf(fname, 1023, "%s.stdout", config.server.logfile);
assert((stdout = fopen(fname, "w")) != NULL);
snprintf(fname, 1023, "%s.stderr", config.server.logfile);
assert((stderr = fopen(fname, "w")) != NULL);
// stdout = stderr = log_fd(); //** and reassign them to the log device
printf("ibp_server.c: STDOUT=STDERR=LOG_FD() dnoes not work!!!!!!!!!!!!!!!!!!!!!!!!\n");
} else { //** Parent exits
exit(0);
}
}
// test_alloc(); //** Used for testing allocation speed only
//*** Initialize all command data structures. This is mainly 3rd party commands ***
initialize_commands();
//** Launch the garbage collection threads
for (i=0; i<config.n_resources; i++) launch_resource_cleanup_thread(&(config.res[i]));
//*** Start the activity log ***
alog_open();
server_loop(&config); //***** Main processing loop ******
//*** Shutdown the activity log ***
alog_close();
//*** Destroy all the 3rd party structures ***
destroy_commands();
lock_alloc_destroy();
destroy_thread_slots();
shutdown(&config);
free_resource_list(config.rl);
free_stats();
log_printf(0, "main: Completed shutdown. Exiting\n");
// close_log();
// close_debug();
}
