int main(int argc, char *argv[])
{
context_t c;
mrp_clear(&c);
if (!parse_cmdline(&c, argc, argv))
exit(1);
mrp_log_set_mask(c.log_mask);
mrp_log_set_target(c.log_target);
if (c.server)
mrp_log_info("Running as server, using D-BUS '%s'...", c.busaddr);
else
mrp_log_info("Running as client, using D-BUS '%s'...", c.busaddr);
c.ml = mrp_mainloop_create();
mrp_add_sighandler(c.ml, SIGINT , signal_handler, &c);
if (c.server)
server_setup(&c);
else
client_setup(&c);
mrp_mainloop_run(c.ml);
if (c.server)
server_cleanup(&c);
else
client_cleanup(&c);
return 0;
}
static void config_set_defaults(void)
{
mrp_clear(&ctx);
ctx.log_mask = MRP_LOG_UPTO(MRP_LOG_INFO);
ctx.log_target = MRP_LOG_TO_STDOUT;
ctx.framed = TRUE;
}
static void config_set_defaults(context_t *ctx)
{
mrp_clear(ctx);
ctx->busaddr = "session";
ctx->server = FALSE;
ctx->log_mask = MRP_LOG_UPTO(MRP_LOG_DEBUG);
ctx->log_target = MRP_LOG_TO_STDERR;
}
static int msg_send_ack(pep_proxy_t *proxy, uint32_t seq)
{
ack_msg_t ack;
mrp_clear(&ack);
ack.type = MSG_TYPE_ACK;
ack.seq = seq;
return proxy->ops->send_msg(proxy, (msg_t *)&ack);
}
static void config_set_defaults(ripncode_t *r, const char *argv0)
{
mrp_clear(r);
r->argv0 = argv0;
r->device = "/dev/cdrom";
r->driver = "linux";
r->log_mask = MRP_LOG_UPTO(MRP_LOG_WARNING);
r->log_target = "stdout";
mrp_log_set_mask(r->log_mask);
mrp_log_set_target(r->log_target);
}
static int msg_send_nak(pep_proxy_t *proxy, uint32_t seq,
int32_t error, const char *msg)
{
nak_msg_t nak;
mrp_clear(&nak);
nak.type = MSG_TYPE_NAK;
nak.seq = seq;
nak.error = error;
nak.msg = msg;
return proxy->ops->send_msg(proxy, (msg_t *)&nak);
}
static void setup_dbus_client(mrp_mainloop_t *ml)
{
DBusConnection *conn;
int i, nmethod, nsignal;
size_t size;
ssize_t amount_read;
nmethod = cfg.ndbus_method;
nsignal = cfg.ndbus_signal;
mrp_clear(&cfg);
cfg.ndbus_method = nmethod;
cfg.ndbus_signal = nsignal;
mrp_mainloop_quit(ml, 0);
#ifdef GLIB_ENABLED
glib_pump_cleanup();
#endif
mrp_mainloop_destroy(ml);
for (i = 3; i < 1024; i++)
if (i != dbus_test.pipe[0])
close(i);
size = sizeof(dbus_test.address) - 1;
amount_read = read(dbus_test.pipe[0], dbus_test.address, size);
if (amount_read > 0) {
dbus_test.address[amount_read] = '\0';
info("DBUS test: got address '%s'", dbus_test.address);
}
/*sleep(5);*/
if ((ml = dbus_test.ml = mrp_mainloop_create()) == NULL)
fatal("failed to create mainloop");
cfg.ml = ml;
if ((conn = dbus_test.conn = connect_to_dbus(NULL)) == NULL)
fatal("failed to connect to DBUS");
if (!mrp_setup_dbus_connection(ml, conn))
fatal("failed to setup DBUS connection with mainloop");
if (mrp_add_timer(ml, 1000, client_send_msg, NULL) == NULL)
fatal("failed to create DBUS message sending timer");
if (mrp_add_timer(ml, 1000, check_quit, NULL) == NULL)
fatal("failed to create quit-check timer");
cfg.nrunning++;
}
static int init_rules(void)
{
mrp_htbl_config_t hcfg;
mrp_clear(&hcfg);
hcfg.comp = mrp_string_comp;
hcfg.hash = mrp_string_hash;
hcfg.free = free_rule_cb;
rules_on = mrp_htbl_create(&hcfg);
rules_off = mrp_htbl_create(&hcfg);
if (rules_on == NULL || rules_off == NULL)
return FALSE;
else
return TRUE;
}
static int create_loader(srs_plugin_t *plugin)
{
const char *failed;
MRP_UNUSED(plugin);
mrp_clear(&loader);
if (check_config(&loader) != 0) {
mrp_log_error("Failed to get configuration (%d: %s).", errno,
strerror(errno));
return FALSE;
}
if ((failed = load_libs(&loader)) != NULL) {
mrp_log_error("Failed to preload library '%s'.", failed);
return FALSE;
}
else
return TRUE;
}
static void config_set_defaults(test_config_t *cfg)
{
mrp_clear(cfg);
cfg->nio = 5;
cfg->ntimer = 10;
cfg->nsignal = 5;
cfg->ngio = 5;
cfg->ngtimer = 10;
cfg->ndbus_method = 10;
cfg->ndbus_signal = 10;
cfg->log_mask = MRP_LOG_UPTO(MRP_LOG_DEBUG);
cfg->log_target = MRP_LOG_TO_STDERR;
cfg->wlpf = 1750;
cfg->wfrc = 5000;
cfg->runtime = DEFAULT_RUNTIME;
}
int main(int argc, char *argv[])
{
mrp_mainloop_t *ml;
mrp_clear(&cfg);
parse_cmdline(&cfg, argc, argv);
mrp_log_set_mask(cfg.log_mask);
mrp_log_set_target(cfg.log_target);
ml = mainloop_create(&cfg);
if (ml == NULL)
fatal("failed to create main loop.");
dbus_test.ml = ml;
setup_dbus_tests(ml);
ml = dbus_test.ml;
setup_timers(ml);
setup_io(ml);
setup_signals(ml);
MRP_UNUSED(setup_deferred); /* XXX TODO: add deferred tests... */
#ifdef GLIB_ENABLED
if (cfg.mainloop_type != MAINLOOP_GLIB && cfg.mainloop_type != MAINLOOP_QT) {
if (cfg.ngio > 0 || cfg.ngtimer > 0)
glib_pump_setup(ml);
}
setup_glib_io();
setup_glib_timers();
#endif
if (mrp_add_timer(ml, 1000, check_quit, NULL) == NULL)
fatal("failed to create quit-check timer");
setup_wakeup(ml);
mainloop_run(&cfg);
check_io();
check_timers();
check_signals();
#ifdef GLIB_ENABLED
check_glib_io();
check_glib_timers();
#endif
if (dbus_test.client != 0)
close(dbus_test.pipe[1]); /* let the client continue */
check_dbus();
#ifdef GLIB_ENABLED
if (cfg.mainloop_type != MAINLOOP_GLIB) {
if (cfg.ngio > 0 || cfg.ngtimer > 0)
glib_pump_cleanup();
}
#endif
cleanup_wakeup();
mainloop_cleanup(&cfg);
}
