static void log_target(mrp_console_t *c, void *user_data,
int argc, char **argv)
{
const char *target;
const char *targets[32];
int i, n;
MRP_UNUSED(c);
MRP_UNUSED(user_data);
if (argc == 2) {
target = mrp_log_get_target();
n = mrp_log_get_targets(targets, MRP_ARRAY_SIZE(targets));
printf("available log targets:\n");
for (i = 0; i < n; i++)
printf(" %s%s\n", targets[i],
!strcmp(targets[i], target) ? " (active)" : "");
}
else if (argc == 3) {
target = argv[2];
if (!mrp_log_set_target(target))
printf("failed to change logging target to %s", target);
else {
printf("changed log target to %s\n", target);
mrp_log_info("changed log target to %s", target);
}
}
else {
printf("%s/%s invoked with wrong number of arguments\n",
argv[0], argv[1]);
}
}
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 setup_logging(mrp_context_t *ctx)
{
const char *target;
target = mrp_log_parse_target(ctx->log_target);
if (!target)
mrp_log_error("invalid log target '%s'", ctx->log_target);
else
mrp_log_set_target(target);
}
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);
}
int main(int argc, char *argv[])
{
mrp_fragbuf_t *buf;
size_t chunkstbl[][8] = {
{ 3, 1, 2, 3, 5, 0, 0, 0 },
{ 1, 2, 3, 4, 3, 2, 1, 0 },
{ 1, 5, 3, 4, 2, 1, 1, 0 },
{ 4, 3, 2, 1, 2, 3, 4, 0 },
};
size_t *chunks;
size_t single[] = { 1, 0 };
int intervals[] = { 1, 2, 3, 4, 5, 0, -1 };
int i, j, interval;
parse_cmdline(argc, argv);
mrp_log_set_mask(ctx.log_mask);
mrp_log_set_target(ctx.log_target);
buf = mrp_fragbuf_create(ctx.framed, 0);
if (buf == NULL)
fatal("failed to create data collecting buffer");
for (i = 0; i < (int)MRP_ARRAY_SIZE(intervals); i++) {
interval = intervals[i];
for (j = 0; j < (int)MRP_ARRAY_SIZE(chunkstbl); j++) {
chunks = &chunkstbl[j][0];
mrp_log_info("testing with interval %d, chunks #%d", interval, j);
test(buf, chunks, interval);
test(buf, single, interval);
mrp_log_info("testing with interval %d, chunks #%d", -i -2, j);
test(buf, chunks, -i - 2);
test(buf, single, -i - 2);
}
}
mrp_fragbuf_destroy(buf);
return 0;
}
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);
}
static void parse_cmdline(ripncode_t *r, int argc, char **argv, char **envp)
{
# define OPTIONS "d:c:t:f:m:L:T:v::d:nh"
struct option options[] = {
{ "device" , required_argument, NULL, 'd' },
{ "driver" , required_argument, NULL, 'c' },
{ "tracks" , required_argument, NULL, 't' },
{ "format" , required_argument, NULL, 'f' },
{ "metadata" , required_argument, NULL, 'm' },
{ "log-level" , required_argument, NULL, 'L' },
{ "log-target" , required_argument, NULL, 'T' },
{ "verbose" , optional_argument, NULL, 'v' },
{ "debug" , required_argument, NULL, 'd' },
{ "dry-run" , no_argument , NULL, 'n' },
{ "help" , no_argument , NULL, 'h' },
{ NULL , 0, NULL, 0 }
};
int opt, help;
MRP_UNUSED(envp);
help = FALSE;
while ((opt = getopt_long(argc, argv, OPTIONS, options, NULL)) != -1) {
switch (opt) {
case 'D':
r->device = optarg;
if (access(r->device, R_OK) < 0)
ripncode_fatal(r, "can't access '%s' (%d: %s).", r->device,
errno, strerror(errno));
break;
case 'c':
r->driver = optarg;
break;
case 't':
r->rip = optarg;
parse_tracks(r);
break;
case 'f':
r->format = optarg;
break;
case 'm':
r->metadata = optarg;
if (access(r->metadata, R_OK) < 0)
ripncode_fatal(r, "can't access '%s' (%d: %s).", r->metadata,
errno, strerror(errno));
break;
case 'L':
r->log_mask = mrp_log_parse_levels(optarg);
mrp_log_set_mask(r->log_mask);
break;
case 'v':
r->log_mask <<= 1;
r->log_mask |= 1;
mrp_log_set_mask(r->log_mask);
break;
case 'T':
r->log_target = optarg;
mrp_log_set_target(r->log_target);
break;
case 'd':
r->log_mask |= MRP_LOG_MASK_DEBUG;
mrp_log_set_mask(r->log_mask);
mrp_debug_set_config(optarg);
mrp_debug_enable(TRUE);
break;
case 'n':
r->dryrun = 1;
break;
case 'h':
help++;
break;
default:
print_usage(r, EINVAL, "invalid option '%c'", opt);
}
}
if (help) {
print_usage(r, -1, "");
exit(0);
}
}
