static void
parse_command_line (int *argc,
char ***argv)
{
GOptionContext *context = g_option_context_new ("STRING FILE...");
GError *error = NULL;
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_summary (context, "Perform binary search of sorted text file(s).");
g_option_context_set_description (context, "Input file MUST have specified column in normal \"sort\" order, or may be in \"sort -r\" order when using \"-r\" option."
"\n\nStrings are compared according to their native byte values, so the files need to have been sorted with LC_COLLATE=C (or LC_ALL=C)."
"\n\nAssumes lines are terminated by a single newline character '\\n'."
"\n\nProgram will binary search the file, looking for a(ny) line that begins with the string.\n");
if (!g_option_context_parse (context, argc, argv, &error))
{
g_printerr ("bin-search: %s\n\n", error->message);
g_printerr ("%s", g_option_context_get_help (context, TRUE, NULL));
exit (1);
}
if (*argc < 3)
{
g_printerr ("bin-search: error: You must specify a search string and at least one file to search\n\n");
g_printerr ("%s", g_option_context_get_help (context, TRUE, NULL));
exit (2);
}
g_option_context_free (context);
}
gboolean
flatpak_builtin_ps (int argc,
char **argv,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GOptionContext) context = NULL;
g_autofree char *col_help = NULL;
g_autofree Column *columns = NULL;
context = g_option_context_new (_(" - Enumerate running sandboxes"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
col_help = column_help (all_columns);
g_option_context_set_description (context, col_help);
if (!flatpak_option_context_parse (context, options, &argc, &argv, FLATPAK_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))
return FALSE;
if (argc > 1)
{
usage_error (context, _("Extra arguments given"), error);
return FALSE;
}
columns = handle_column_args (all_columns, FALSE, opt_cols, error);
if (columns == NULL)
return FALSE;
return enumerate_instances (columns, error);
}
int
main(int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
ENTER;
gtk_set_locale();
context = g_option_context_new("- X11 keyboard switcher");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
g_option_context_set_description(context, desription);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print ("%s\n", error->message);
exit(1);
}
gtk_init(&argc, &argv);
if (argc > 1) {
g_print("Unknown option %s.\nRun '%s --help' for description\n",
argv[1], g_get_prgname());
exit(1);
}
if (display_version) {
printf("%s %s\n", g_get_prgname(), VERSION);
exit(0);
}
init();
create_all();
gtk_main();
RET(0);
}
gint main(gint argc, gchar* argv[]){
char* hw = "`r```````````.H.e.l.l.o. .w.o.r.l.di";
char* fib = "```s``s``sii`ki\n"
"`k.*``s``s`ks\n"
"``s`k`s`ks``s``s`ks``s`k`s`kr``s`k`sikk\n"
"`k``s`ksk";
/*
* http://www.madore.org/~david/programs/unlambda/
*/
World* world;
UnlambdaEval* ue;
GOptionContext *context;
GError *error = NULL;
context = g_option_context_new("This line is appeared after Uagese's command line");
g_option_context_set_summary(context, "This line is appeared before options");
g_option_context_set_description(context, "This line is appeared after options");
if(!g_option_context_parse(context, &argc, &argv, &error)){
g_printerr("option parsing failed: %s\n", error->message);
return 1;
}
world = CreateWorld(MAXOBJECTS);
setWorld(world);
ue = NewUnlambdaEval(world);
printf("%s\n", fib);
//eval(hw);
UnlambdaEval_eval(ue, fib);
DeleteWorld(world);
return 0;
}
/*
* init options context
*/
static GOptionContext *
init_options( void )
{
GOptionContext *context;
gchar* description;
GOptionGroup *misc_group;
context = g_option_context_new( program_summary );
g_option_context_set_translation_domain( context, GETTEXT_PACKAGE );
#ifdef ENABLE_NLS
bindtextdomain( GETTEXT_PACKAGE, GNOMELOCALEDIR );
# ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset( GETTEXT_PACKAGE, "UTF-8" );
# endif
textdomain( GETTEXT_PACKAGE );
g_option_context_add_main_entries( context, entries, GETTEXT_PACKAGE );
#else
g_option_context_add_main_entries( context, entries, NULL );
#endif
description = console_cmdline_get_description();
g_option_context_set_description( context, description );
g_free( description );
misc_group = g_option_group_new(
"misc", _( "Miscellaneous options" ), _( "Miscellaneous options" ), NULL, NULL );
g_option_group_add_entries( misc_group, misc_entries );
g_option_group_set_translation_domain( misc_group, GETTEXT_PACKAGE );
g_option_context_add_group( context, misc_group );
return( context );
}
static GOptionContext *
init_options( void )
{
GOptionContext *context;
gchar* description;
GOptionGroup *misc_group;
context = g_option_context_new( _( "Import a file." ));
#ifdef ENABLE_NLS
bindtextdomain( GETTEXT_PACKAGE, GNOMELOCALEDIR );
# ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset( GETTEXT_PACKAGE, "UTF-8" );
# endif
textdomain( GETTEXT_PACKAGE );
g_option_context_add_main_entries( context, entries, GETTEXT_PACKAGE );
#else
g_option_context_add_main_entries( context, entries, NULL );
#endif
description = g_strdup_printf( "%s.\n%s", PACKAGE_STRING,
_( "Bug reports are welcomed at http://bugzilla.gnome.org,"
" or you may prefer to mail to <*****@*****.**>.\n" ));
g_option_context_set_description( context, description );
g_free( description );
misc_group = g_option_group_new(
"misc", _( "Miscellaneous options" ), _( "Miscellaneous options" ), NULL, NULL );
g_option_group_add_entries( misc_group, misc_entries );
g_option_context_add_group( context, misc_group );
return( context );
}
gboolean
flatpak_builtin_document_list (int argc, char **argv,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GOptionContext) context = NULL;
const char *app_id = NULL;
g_autofree char *col_help = NULL;
g_autofree Column *columns = NULL;
context = g_option_context_new (_("[APPID] - List exported files"));
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
col_help = column_help (all_columns);
g_option_context_set_description (context, col_help);
if (!flatpak_option_context_parse (context, options, &argc, &argv,
FLATPAK_BUILTIN_FLAG_NO_DIR,
NULL, cancellable, error))
return FALSE;
if (argc > 2)
return usage_error (context, _("Too many arguments"), error);
if (argc == 2)
app_id = argv[1];
columns = handle_column_args (all_columns, FALSE, opt_cols, error);
if (columns == NULL)
return FALSE;
return print_documents (app_id, columns, cancellable, error);
}
void
mu_config_show_help (MuConfigCmd cmd)
{
GOptionContext *ctx;
GOptionGroup *group;
char *cleanhelp;
g_return_if_fail (mu_config_cmd_is_valid(cmd));
ctx = g_option_context_new ("");
g_option_context_set_main_group (ctx, config_options_group_mu());
group = get_option_group (cmd);
if (group)
g_option_context_add_group (ctx, group);
g_option_context_set_description (ctx,
get_help_string (cmd, TRUE));
cleanhelp = massage_help
(g_option_context_get_help (ctx, TRUE, group));
g_print ("usage:\n\t%s\n%s",
get_help_string (cmd, FALSE), cleanhelp);
g_free (cleanhelp);
}
/* Option Parser */
static void parse_cmd_options(int *argc, char ***argv)
{
GError *error = NULL;
GOptionContext *context = g_option_context_new("");
g_option_context_set_description(context, "Converts program output (and colors) to HTML");
g_option_context_set_summary(context, "A simple program to convert program output (f.e. from git diff) to a html file.");
g_option_context_add_main_entries(context, entries,NULL);
g_option_context_parse(context, argc, argv, &error);
g_option_context_free(context);
EXCEPTION(error != NULL, "Failed to parse commandline options: %s\n", error->message);
}
int main(int argc, char *argv[])
{
GError *error = NULL;
GOptionContext *context;
signal(SIGINT, signal_handler);
/* parse opts */
context = g_option_context_new(NULL);
g_option_context_set_summary(context, "A Spice client used for testing and measurements.");
g_option_context_set_description(context, "Report bugs to " PACKAGE_BUGREPORT ".");
g_option_context_set_main_group(context, spice_cmdline_get_option_group());
g_option_context_add_main_entries(context, app_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print("option parsing failed: %s\n", error->message);
exit(1);
}
if (version) {
g_print("spicy-stats " PACKAGE_VERSION "\n");
exit(0);
}
mainloop = g_main_loop_new(NULL, false);
session = spice_session_new();
g_signal_connect(session, "channel-new",
G_CALLBACK(channel_new), NULL);
spice_cmdline_session_setup(session);
if (!spice_session_connect(session)) {
fprintf(stderr, "spice_session_connect failed\n");
exit(1);
}
g_main_loop_run(mainloop);
{
GList *iter, *list = spice_session_get_channels(session);
gulong total_read_bytes;
gint channel_type;
printf("total bytes read:\n");
for (iter = list ; iter ; iter = iter->next) {
g_object_get(iter->data,
"total-read-bytes", &total_read_bytes,
"channel-type", &channel_type,
NULL);
printf("%s: %lu\n",
spice_channel_type_to_string(channel_type),
total_read_bytes);
}
g_list_free(list);
}
return 0;
}
static void
mc_args_add_extended_info_to_help (void)
{
mc_args__loc__footer_string = g_strdup_printf ("%s",
_
("\n"
"Please send any bug reports (including the output of 'mc -V')\n"
"as tickets at www.midnight-commander.org\n"));
mc_args__loc__header_string = g_strdup_printf (_("GNU Midnight Commander %s\n"), VERSION);
g_option_context_set_description (context, mc_args__loc__footer_string);
g_option_context_set_summary (context, mc_args__loc__header_string);
}
/*
* init options context
*/
static GOptionContext *
init_options( void )
{
GOptionContext *context;
gchar* description;
GOptionGroup *output_group;
GOptionGroup *misc_group;
GOptionEntry *entries;
context = g_option_context_new( _( "Define a new action." ));
g_option_context_set_summary( context, _(
"The created action defaults to be written to stdout.\n"
"It can also be written to an output folder, in a file later suitable for an import in CACT.\n"
"Or you may choose to directly write the action into your Caja-Actions configuration." ));
g_option_context_set_translation_domain( context, GETTEXT_PACKAGE );
entries = build_option_entries( st_arg_from_data_def, G_N_ELEMENTS( st_arg_from_data_def ), st_added_entries, G_N_ELEMENTS( st_added_entries ) );
#ifdef ENABLE_NLS
bindtextdomain( GETTEXT_PACKAGE, MATELOCALEDIR );
# ifdef HAVE_BIND_TEXTDOMAIN_CODESET
bind_textdomain_codeset( GETTEXT_PACKAGE, "UTF-8" );
# endif
textdomain( GETTEXT_PACKAGE );
g_option_context_add_main_entries( context, entries, GETTEXT_PACKAGE );
#else
g_option_context_add_main_entries( context, entries, NULL );
#endif
g_free( entries );
description = console_cmdline_get_description();
g_option_context_set_description( context, description );
g_free( description );
output_group = g_option_group_new(
"output", _( "Output of the program" ), _( "Choose where the program creates the action" ), NULL, NULL );
g_option_group_add_entries( output_group, output_entries );
g_option_group_set_translation_domain( output_group, GETTEXT_PACKAGE );
g_option_context_add_group( context, output_group );
misc_group = g_option_group_new(
"misc", _( "Miscellaneous options" ), _( "Miscellaneous options" ), NULL, NULL );
g_option_group_add_entries( misc_group, misc_entries );
g_option_group_set_translation_domain( misc_group, GETTEXT_PACKAGE );
g_option_context_add_group( context, misc_group );
return( context );
}
void args_register(void)
{
static GOptionEntry entries[] = {
{ "model", 'm', 0, G_OPTION_ARG_STRING, &model, "Printer model", "FAMILY" },
{ "definition", 'd', 0, G_OPTION_ARG_FILENAME, &definition, "Printer Postscript Description file", "PPDFILE" },
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose, "Verbose output for debugging purpose", NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &remaining, "Command line for brprintconf", NULL },
{ NULL }
};
context = g_option_context_new("-- BRPRINTCONF COMMAND LINE");
g_option_context_set_description(context, "Report any bugs at <https://github.com/ork/bcw-ng>.");
g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE);
}
int
cmd_count(int argc, char **argv)
{
int opta = 0, optA = 0, optg = 0, ret;
GError *error = NULL;
GOptionEntry options[] = {
{"artist", 'a', 0, G_OPTION_ARG_NONE, &opta,
"Change play count of artists instead of songs", NULL},
{"album", 'A', 0, G_OPTION_ARG_NONE, &optA,
"Change play count of albums instead of songs", NULL},
{"genre", 'g', 0, G_OPTION_ARG_NONE, &optg,
"Change play count of genres instead of songs", NULL},
{ NULL, 0, 0, 0, NULL, NULL, NULL },
};
GOptionContext *ctx;
ctx = g_option_context_new("COUNT [EXPRESSION]");
g_option_context_add_main_entries(ctx, options, "eugene-count");
g_option_context_set_summary(ctx, "eugene-count-"VERSION GITHEAD
" - Change play count of song/artist/album/genre");
g_option_context_set_description(ctx, ""
"By default this command works on the current playing song.\n"
"For more information about the expression syntax, see:\n"
"http://www.sqlite.org/lang_expr.html");
/* Ignore unknown options so that the user can pass negative numbers.
*/
g_option_context_set_ignore_unknown_options(ctx, TRUE);
if (!g_option_context_parse(ctx, &argc, &argv, &error)) {
g_printerr("Option parsing failed: %s\n", error->message);
g_error_free(error);
g_option_context_free(ctx);
return 1;
}
g_option_context_free(ctx);
if (argc <= 1) {
g_printerr("No count given\n");
ret = 1;
}
else if (argc > 2)
ret = cmd_count_internal(argv[2], argv[1], opta, optA, optg);
else
ret = cmd_count_internal(NULL, argv[1], opta, optA, optg);
return ret;
}
int
cmd_rmtag(int argc, char **argv)
{
int opta = 0, optA = 0, optg = 0, ret;
GError *error = NULL;
GOptionEntry options[] = {
{"artist", 'a', 0, G_OPTION_ARG_NONE, &opta,
"Remove tag from artists instead of songs", NULL},
{"album", 'A', 0, G_OPTION_ARG_NONE, &optA,
"Remove tag from albums instead of songs", NULL},
{"genre", 'g', 0, G_OPTION_ARG_NONE, &optg,
"Remove tag from genres instead of songs", NULL},
{ NULL, 0, 0, 0, NULL, NULL, NULL },
};
GOptionContext *ctx;
ctx = g_option_context_new("TAG [EXPRESSION]");
g_option_context_add_main_entries(ctx, options, "eugene-rmtag");
g_option_context_set_summary(ctx, "eugene-rmtag-"VERSION GITHEAD" - Remove tag from song/artist/album/genre");
g_option_context_set_description(ctx, ""
"By default this command works on the current playing song.\n"
"For more information about the expression syntax, see:\n"
"http://www.sqlite.org/lang_expr.html");
if (!g_option_context_parse(ctx, &argc, &argv, &error)) {
g_printerr("Option parsing failed: %s\n", error->message);
g_error_free(error);
g_option_context_free(ctx);
return 1;
}
g_option_context_free(ctx);
if (argc <= 1) {
g_printerr("No tag given\n");
return 1;
}
if (argc > 2)
ret = cmd_rmtag_internal(argv[1], argv[2], opta, optA, optg);
else
ret = cmd_rmtag_internal(argv[1], NULL, opta, optA, optg);
return ret;
}
static gboolean
init_cmd_help (GError **err)
{
MuConfigCmd cmd;
GOptionContext *ctx;
GOptionGroup *group;
char *cleanhelp;
if (!MU_CONFIG.params ||
!MU_CONFIG.params[0] || !MU_CONFIG.params[1] ||
MU_CONFIG.params[2])
goto errexit;
cmd = cmd_from_string (MU_CONFIG.params[1]);
if (cmd == MU_CONFIG_CMD_UNKNOWN)
goto errexit;
ctx = g_option_context_new ("");
g_option_context_set_main_group
(ctx, config_options_group_mu());
group = get_option_group (cmd);
if (group)
g_option_context_add_group (ctx, group);
g_option_context_set_description (ctx, cmd_help (cmd, TRUE));
cleanhelp = massage_help
(g_option_context_get_help (ctx, TRUE, group));
g_print ("Usage:\n\t%s\n%s",
cmd_help (cmd, FALSE), cleanhelp);
g_free (cleanhelp);
return TRUE;
errexit:
mu_util_g_set_error (err, MU_ERROR_IN_PARAMETERS,
"usage: mu help <command>");
return FALSE;
}
Configuration* configuration_new(gint argc, gchar* argv[]) {
/* get memory */
Configuration* c = g_new0(Configuration, 1);
MAGIC_INIT(c);
c->argstr = g_strjoinv(" ", argv);
const gchar* required_parameters = "shadow.config.xml";
gint nRequiredXMLFiles = 1;
c->context = g_option_context_new(required_parameters);
g_option_context_set_summary(c->context, "Shadow - run real applications over simulated networks");
g_option_context_set_description(c->context,
"Shadow is a unique discrete-event network simulator that runs real "
"applications like Tor, and distributed systems of thousands of nodes "
"on a single machine. Shadow combines the accuracy of emulation with the "
"efficiency and control of simulation, achieving the best of both approaches.");
/* set defaults */
c->initialTCPWindow = 10;
c->interfaceBufferSize = 1024000;
c->interfaceBatchTime = 10;
c->randomSeed = 1;
c->cpuThreshold = -1;
c->cpuPrecision = 200;
c->heartbeatInterval = 60;
/* set options to change defaults for the main group */
c->mainOptionGroup = g_option_group_new("main", "Main Options", "Primary simulator options", NULL, NULL);
const GOptionEntry mainEntries[] = {
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &(c->debug), "Pause at startup for debugger attachment", NULL },
{ "heartbeat-frequency", 'h', 0, G_OPTION_ARG_INT, &(c->heartbeatInterval), "Log node statistics every N seconds [60]", "N" },
{ "heartbeat-log-level", 'j', 0, G_OPTION_ARG_STRING, &(c->heartbeatLogLevelInput), "Log LEVEL at which to print node statistics ['message']", "LEVEL" },
{ "heartbeat-log-info", 'i', 0, G_OPTION_ARG_STRING, &(c->heartbeatLogInfo), "Comma separated list of information contained in heartbeat ('node','socket','ram') ['node']", "LIST"},
{ "log-level", 'l', 0, G_OPTION_ARG_STRING, &(c->logLevelInput), "Log LEVEL above which to filter messages ('error' < 'critical' < 'warning' < 'message' < 'info' < 'debug') ['message']", "LEVEL" },
{ "preload", 'p', 0, G_OPTION_ARG_STRING, &(c->preloads), "LD_PRELOAD environment VALUE to use for function interposition (/path/to/lib:...) [None]", "VALUE" },
{ "runahead", 'r', 0, G_OPTION_ARG_INT, &(c->minRunAhead), "If set, overrides the automatically calculated minimum TIME workers may run ahead when sending events between nodes, in milliseconds [0]", "TIME" },
{ "seed", 's', 0, G_OPTION_ARG_INT, &(c->randomSeed), "Initialize randomness for each thread using seed N [1]", "N" },
{ "workers", 'w', 0, G_OPTION_ARG_INT, &(c->nWorkerThreads), "Run concurrently with N worker threads [0]", "N" },
{ "valgrind", 'x', 0, G_OPTION_ARG_NONE, &(c->runValgrind), "Run through valgrind for debugging", NULL },
{ "version", 'v', 0, G_OPTION_ARG_NONE, &(c->printSoftwareVersion), "Print software version and exit", NULL },
{ NULL },
};
g_option_group_add_entries(c->mainOptionGroup, mainEntries);
g_option_context_set_main_group(c->context, c->mainOptionGroup);
/* now fill in the default plug-in examples option group */
c->pluginsOptionGroup = g_option_group_new("sim", "Simulation Examples", "Built-in simulation examples", NULL, NULL);
const GOptionEntry pluginEntries[] =
{
{ "file", 0, 0, G_OPTION_ARG_NONE, &(c->runFileExample), "Run basic HTTP file transfer simulation", NULL },
{ NULL },
};
g_option_group_add_entries(c->pluginsOptionGroup, pluginEntries);
g_option_context_add_group(c->context, c->pluginsOptionGroup);
/* now fill in the network option group */
GString* sockrecv = g_string_new("");
g_string_printf(sockrecv, "Initialize the socket receive buffer to N bytes [%i]", (gint)CONFIG_RECV_BUFFER_SIZE);
GString* socksend = g_string_new("");
g_string_printf(socksend, "Initialize the socket send buffer to N bytes [%i]", (gint)CONFIG_SEND_BUFFER_SIZE);
c->networkOptionGroup = g_option_group_new("sys", "System Options", "Simulated system/network behavior", NULL, NULL);
const GOptionEntry networkEntries[] =
{
{ "cpu-precision", 0, 0, G_OPTION_ARG_INT, &(c->cpuPrecision), "round measured CPU delays to the nearest TIME, in microseconds (negative value to disable fuzzy CPU delays) [200]", "TIME" },
{ "cpu-threshold", 0, 0, G_OPTION_ARG_INT, &(c->cpuThreshold), "TIME delay threshold after which the CPU becomes blocked, in microseconds (negative value to disable CPU delays) (experimental!) [-1]", "TIME" },
{ "interface-batch", 0, 0, G_OPTION_ARG_INT, &(c->interfaceBatchTime), "Batch TIME for network interface sends and receives, in milliseconds [10]", "TIME" },
{ "interface-buffer", 0, 0, G_OPTION_ARG_INT, &(c->interfaceBufferSize), "Size of the network interface receive buffer, in bytes [1024000]", "N" },
{ "interface-qdisc", 0, 0, G_OPTION_ARG_STRING, &(c->interfaceQueuingDiscipline), "The interface queuing discipline QDISC used to select the next sendable socket ('fifo' or 'rr') ['fifo']", "QDISC" },
{ "socket-recv-buffer", 0, 0, G_OPTION_ARG_INT, &(c->initialSocketReceiveBufferSize), sockrecv->str, "N" },
{ "socket-send-buffer", 0, 0, G_OPTION_ARG_INT, &(c->initialSocketSendBufferSize), socksend->str, "N" },
{ "tcp-congestion-control", 0, 0, G_OPTION_ARG_STRING, &(c->tcpCongestionControl), "Congestion control algorithm to use for TCP ('aimd', 'reno', 'cubic') ['cubic']", "TCPCC" },
{ "tcp-ssthresh", 0, 0, G_OPTION_ARG_INT, &(c->tcpSlowStartThreshold), "Set TCP ssthresh value instead of discovering it via packet loss or hystart [0]", "N" },
{ "tcp-windows", 0, 0, G_OPTION_ARG_INT, &(c->initialTCPWindow), "Initialize the TCP send, receive, and congestion windows to N packets [10]", "N" },
{ NULL },
};
g_option_group_add_entries(c->networkOptionGroup, networkEntries);
g_option_context_add_group(c->context, c->networkOptionGroup);
/* parse args */
GError *error = NULL;
if (!g_option_context_parse(c->context, &argc, &argv, &error)) {
g_printerr("** %s **\n", error->message);
gchar* helpString = g_option_context_get_help(c->context, TRUE, NULL);
g_printerr("%s", helpString);
g_free(helpString);
configuration_free(c);
return NULL;
}
/* make sure we have the required arguments. program name is first arg.
* printing the software version requires no other args. running a
* plug-in example also requires no other args. */
if(!(c->printSoftwareVersion) && !(c->runFileExample) && (argc < nRequiredXMLFiles + 1)) {
g_printerr("** Please provide the required parameters **\n");
gchar* helpString = g_option_context_get_help(c->context, TRUE, NULL);
g_printerr("%s", helpString);
g_free(helpString);
configuration_free(c);
return NULL;
}
if(c->nWorkerThreads < 0) {
c->nWorkerThreads = 0;
}
if(c->logLevelInput == NULL) {
c->logLevelInput = g_strdup("message");
}
if(c->heartbeatLogLevelInput == NULL) {
c->heartbeatLogLevelInput = g_strdup("message");
}
if(c->heartbeatLogInfo == NULL) {
c->heartbeatLogInfo = g_strdup("node");
}
if(c->heartbeatInterval < 1) {
c->heartbeatInterval = 1;
}
if(c->initialTCPWindow < 1) {
c->initialTCPWindow = 1;
}
if(c->interfaceBufferSize < CONFIG_MTU) {
c->interfaceBufferSize = CONFIG_MTU;
}
c->interfaceBatchTime *= SIMTIME_ONE_MILLISECOND;
if(c->interfaceBatchTime == 0) {
/* we require at least 1 nanosecond b/c of time granularity */
c->interfaceBatchTime = 1;
}
if(c->interfaceQueuingDiscipline == NULL) {
c->interfaceQueuingDiscipline = g_strdup("fifo");
}
if(!c->initialSocketReceiveBufferSize) {
c->initialSocketReceiveBufferSize = CONFIG_RECV_BUFFER_SIZE;
c->autotuneSocketReceiveBuffer = TRUE;
}
if(!c->initialSocketSendBufferSize) {
c->initialSocketSendBufferSize = CONFIG_SEND_BUFFER_SIZE;
c->autotuneSocketSendBuffer = TRUE;
}
if(c->tcpCongestionControl == NULL) {
c->tcpCongestionControl = g_strdup("cubic");
}
c->inputXMLFilenames = g_queue_new();
for(gint i = 1; i < argc; i++) {
GString* filename = g_string_new(argv[i]);
g_queue_push_tail(c->inputXMLFilenames, filename);
}
if(socksend) {
g_string_free(socksend, TRUE);
}
if(sockrecv) {
g_string_free(sockrecv, TRUE);
}
return c;
}
int
main (int argc, char *argv[])
{
gboolean action_enable = FALSE;
gboolean action_info = FALSE;
gboolean action_list = FALSE;
gboolean action_log = FALSE;
gboolean action_set_debug = FALSE;
gboolean action_supported = FALSE;
gboolean action_unset_debug = FALSE;
gboolean action_version = FALSE;
gboolean ret;
gboolean verbose = FALSE;
g_autofree gchar *apply = FALSE;
g_autofree gchar *esp_path = NULL;
g_autoptr(FuUtilPrivate) priv = g_new0 (FuUtilPrivate, 1);
g_autoptr(GError) error = NULL;
g_autoptr(GPtrArray) devices = NULL;
const GOptionEntry options[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
/* TRANSLATORS: command line option */
_("Show extra debugging information"), NULL },
{ "version", '\0', 0, G_OPTION_ARG_NONE, &action_version,
/* TRANSLATORS: command line option */
_("Display version"), NULL },
{ "log", 'L', 0, G_OPTION_ARG_NONE, &action_log,
/* TRANSLATORS: command line option */
_("Show the debug log from the last attempted update"), NULL },
{ "list", 'l', 0, G_OPTION_ARG_NONE, &action_list,
/* TRANSLATORS: command line option */
_("List supported firmware updates"), NULL },
{ "supported", 's', 0, G_OPTION_ARG_NONE, &action_supported,
/* TRANSLATORS: command line option */
_("Query for firmware update support"), NULL },
{ "info", 'i', 0, G_OPTION_ARG_NONE, &action_info,
/* TRANSLATORS: command line option */
_("Show the information of firmware update status"), NULL },
{ "enable", 'e', 0, G_OPTION_ARG_NONE, &action_enable,
/* TRANSLATORS: command line option */
_("Enable firmware update support on supported systems"), NULL },
{ "esp-path", 'p', 0, G_OPTION_ARG_STRING, &esp_path,
/* TRANSLATORS: command line option */
_("Override the default ESP path"), "PATH" },
{ "set-debug", 'd', 0, G_OPTION_ARG_NONE, &action_set_debug,
/* TRANSLATORS: command line option */
_("Set the debugging flag during update"), NULL },
{ "unset-debug", 'D', 0, G_OPTION_ARG_NONE, &action_unset_debug,
/* TRANSLATORS: command line option */
_("Unset the debugging flag during update"), NULL },
{ "apply", 'a', 0, G_OPTION_ARG_STRING, &apply,
/* TRANSLATORS: command line option */
_("Apply firmware updates"), "GUID" },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* ensure root user */
if (getuid () != 0 || geteuid () != 0)
/* TRANSLATORS: we're poking around as a power user */
g_printerr ("%s\n", _("This program may only work correctly as root"));
/* get a action_list of the commands */
priv->context = g_option_context_new (NULL);
g_option_context_set_description (priv->context,
"This tool allows an administrator to debug UpdateCapsule operation.");
/* TRANSLATORS: program name */
g_set_application_name (_("UEFI Firmware Utility"));
g_option_context_add_main_entries (priv->context, options, NULL);
ret = g_option_context_parse (priv->context, &argc, &argv, &error);
if (!ret) {
/* TRANSLATORS: the user didn't read the man page */
g_print ("%s: %s\n", _("Failed to parse arguments"),
error->message);
return EXIT_FAILURE;
}
/* set verbose? */
if (verbose) {
g_setenv ("G_MESSAGES_DEBUG", "all", FALSE);
} else {
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
fu_util_ignore_cb, NULL);
}
/* nothing specified */
if (!action_enable && !action_info && !action_list && !action_log &&
!action_set_debug && !action_supported && !action_unset_debug &&
!action_version) {
g_autofree gchar *tmp = NULL;
tmp = g_option_context_get_help (priv->context, TRUE, NULL);
g_printerr ("%s\n\n%s", _("No action specified!"), tmp);
return EXIT_FAILURE;
}
/* action_version first */
if (action_version)
g_print ("fwupd version: %s\n", PACKAGE_VERSION);
/* override the default ESP path */
if (esp_path != NULL) {
if (!fu_uefi_check_esp_path (esp_path, &error)) {
/* TRANSLATORS: ESP is EFI System Partition */
g_print ("%s: %s\n", _("ESP specified was not valid"),
error->message);
return EXIT_FAILURE;
}
} else {
esp_path = fu_uefi_guess_esp_path ();
if (esp_path == NULL) {
g_printerr ("Unable to determine EFI system partition "
"location, override using --esp-path\n");
return EXIT_FAILURE;
}
}
/* check free space */
if (!fu_uefi_check_esp_free_space (esp_path,
FU_UEFI_COMMON_REQUIRED_ESP_FREE_SPACE,
&error)) {
g_printerr ("Unable to use EFI system partition: %s\n", error->message);
return EXIT_FAILURE;
}
g_debug ("ESP mountpoint set as %s", esp_path);
/* show the debug action_log from the last attempted update */
if (action_log) {
gsize sz = 0;
g_autofree guint8 *buf = NULL;
g_autofree guint16 *buf_ucs2 = NULL;
g_autofree gchar *str = NULL;
g_autoptr(GError) error_local = NULL;
if (!fu_uefi_vars_get_data (FU_UEFI_VARS_GUID_FWUPDATE,
"FWUPDATE_DEBUG_LOG",
&buf, &sz, NULL,
&error_local)) {
g_printerr ("failed: %s\n", error_local->message);
return EXIT_FAILURE;
}
buf_ucs2 = g_new0 (guint16, (sz / 2) + 1);
memcpy (buf_ucs2, buf, sz);
str = fu_ucs2_to_uft8 (buf_ucs2, sz / 2);
g_print ("%s", str);
}
if (action_list || action_supported || action_info) {
g_autoptr(GPtrArray) entries = NULL;
g_autofree gchar *esrt_path = NULL;
g_autofree gchar *sysfsfwdir = NULL;
g_autoptr(GError) error_local = NULL;
/* get the directory of ESRT entries */
sysfsfwdir = fu_common_get_path (FU_PATH_KIND_SYSFSDIR_FW);
esrt_path = g_build_filename (sysfsfwdir, "efi", "esrt", NULL);
entries = fu_uefi_get_esrt_entry_paths (esrt_path, &error_local);
if (entries == NULL) {
g_printerr ("failed: %s\n", error_local->message);
return EXIT_FAILURE;
}
/* add each device */
devices = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
for (guint i = 0; i < entries->len; i++) {
const gchar *path = g_ptr_array_index (entries, i);
g_autoptr(GError) error_parse = NULL;
g_autoptr(FuUefiDevice) dev = fu_uefi_device_new_from_entry (path, &error_parse);
if (dev == NULL) {
g_warning ("failed to parse %s: %s",
path, error_parse->message);
continue;
}
fu_device_set_metadata (FU_DEVICE (dev), "EspPath", esp_path);
g_ptr_array_add (devices, g_object_ref (dev));
}
}
/* action_list action_supported firmware updates */
if (action_list) {
for (guint i = 0; i < devices->len; i++) {
FuUefiDevice *dev = g_ptr_array_index (devices, i);
g_print ("%s type, {%s} action_version %" G_GUINT32_FORMAT " can be updated "
"to any action_version above %" G_GUINT32_FORMAT "\n",
fu_uefi_device_kind_to_string (fu_uefi_device_get_kind (dev)),
fu_uefi_device_get_guid (dev),
fu_uefi_device_get_version (dev),
fu_uefi_device_get_version_lowest (dev) - 1);
}
}
/* query for firmware update support */
if (action_supported) {
if (devices->len > 0) {
g_print ("%s\n", _("Firmware updates are supported on this machine."));
} else {
g_print ("%s\n", _("Firmware updates are not supported on this machine."));
}
}
/* show the information of firmware update status */
if (action_info) {
for (guint i = 0; i < devices->len; i++) {
FuUefiDevice *dev = g_ptr_array_index (devices, i);
g_autoptr(FuUefiUpdateInfo) info = NULL;
g_autoptr(GError) error_local = NULL;
/* load any existing update info */
info = fu_uefi_device_load_update_info (dev, &error_local);
if (info == NULL) {
g_printerr ("failed: %s\n", error_local->message);
continue;
}
g_print ("Information for the update status entry %u:\n", i);
g_print (" Information Version: %" G_GUINT32_FORMAT "\n",
fu_uefi_update_info_get_version (info));
g_print (" Firmware GUID: {%s}\n",
fu_uefi_update_info_get_guid (info));
g_print (" Capsule Flags: 0x%08" G_GUINT32_FORMAT "x\n",
fu_uefi_update_info_get_capsule_flags (info));
g_print (" Hardware Instance: %" G_GUINT64_FORMAT "\n",
fu_uefi_update_info_get_hw_inst (info));
g_print (" Update Status: %s\n",
fu_uefi_update_info_status_to_string (fu_uefi_update_info_get_status (info)));
g_print (" Capsule File Path: %s\n\n",
fu_uefi_update_info_get_capsule_fn (info));
}
}
/* action_enable firmware update support on action_supported systems */
if (action_enable) {
g_printerr ("Unsupported, use `fwupdmgr unlock`\n");
return EXIT_FAILURE;
}
/* set the debugging flag during update */
if (action_set_debug) {
const guint8 data = 1;
g_autoptr(GError) error_local = NULL;
if (!fu_uefi_vars_set_data (FU_UEFI_VARS_GUID_FWUPDATE,
"FWUPDATE_VERBOSE",
&data, sizeof(data),
EFI_VARIABLE_NON_VOLATILE |
EFI_VARIABLE_BOOTSERVICE_ACCESS |
EFI_VARIABLE_RUNTIME_ACCESS,
&error_local)) {
g_printerr ("failed: %s\n", error_local->message);
return EXIT_FAILURE;
}
g_print ("%s\n", _("Enabled fwupdate debugging"));
}
/* unset the debugging flag during update */
if (action_unset_debug) {
g_autoptr(GError) error_local = NULL;
if (!fu_uefi_vars_delete (FU_UEFI_VARS_GUID_FWUPDATE,
"FWUPDATE_VERBOSE",
&error_local)) {
g_printerr ("failed: %s\n", error_local->message);
return EXIT_FAILURE;
}
g_print ("%s\n", _("Disabled fwupdate debugging"));
}
/* apply firmware updates */
if (apply != NULL) {
g_autoptr(FuUefiDevice) dev = fu_uefi_device_new_from_guid (apply);
g_autoptr(GError) error_local = NULL;
g_autoptr(GBytes) fw = fu_common_get_contents_bytes (argv[1], &error_local);
if (fw == NULL) {
g_printerr ("failed: %s\n", error_local->message);
return EXIT_FAILURE;
}
if (!fu_device_write_firmware (FU_DEVICE (dev), fw, &error_local)) {
g_printerr ("failed: %s\n", error_local->message);
return EXIT_FAILURE;
}
}
/* success */
return EXIT_SUCCESS;
}
gint _vala_main (gchar** args, int args_length1) {
gint result = 0;
gboolean _tmp12_;
GBusType _tmp16_ = 0;
gboolean _tmp17_;
GBusType _tmp18_;
GBusType bus_type;
GBusType _tmp19_;
FsoFrameworkDBusSubsystem* _tmp20_;
FsoFrameworkSubsystem* _tmp21_;
FsoFrameworkSubsystem* _tmp22_;
guint _tmp23_ = 0U;
guint count;
FsoFrameworkLogger* _tmp24_;
guint _tmp25_;
gchar* _tmp26_ = NULL;
gchar* _tmp27_;
guint _tmp28_;
FsoFrameworkLogger* _tmp33_;
GError * _inner_error_ = NULL;
{
GOptionContext* _tmp0_;
GOptionContext* opt_context;
GOptionContext* _tmp1_;
GOptionContext* _tmp2_;
GOptionContext* _tmp3_;
GOptionContext* _tmp4_;
GOptionContext* _tmp5_;
_tmp0_ = g_option_context_new ("");
opt_context = _tmp0_;
_tmp1_ = opt_context;
g_option_context_set_summary (_tmp1_, "FreeSmartphone.org Usage daemon");
_tmp2_ = opt_context;
g_option_context_set_description (_tmp2_, "This daemon implements the freesmartphone.org Usage API");
_tmp3_ = opt_context;
g_option_context_set_help_enabled (_tmp3_, TRUE);
_tmp4_ = opt_context;
g_option_context_add_main_entries (_tmp4_, options, NULL);
_tmp5_ = opt_context;
g_option_context_parse (_tmp5_, &args_length1, &args, &_inner_error_);
if (_inner_error_ != NULL) {
_g_option_context_free0 (opt_context);
if (_inner_error_->domain == G_OPTION_ERROR) {
goto __catch0_g_option_error;
}
_g_option_context_free0 (opt_context);
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0;
}
_g_option_context_free0 (opt_context);
}
goto __finally0;
__catch0_g_option_error:
{
GError* e = NULL;
FILE* _tmp6_;
GError* _tmp7_;
const gchar* _tmp8_;
FILE* _tmp9_;
gchar** _tmp10_;
gint _tmp10__length1;
const gchar* _tmp11_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp6_ = stdout;
_tmp7_ = e;
_tmp8_ = _tmp7_->message;
fprintf (_tmp6_, "%s\n", _tmp8_);
_tmp9_ = stdout;
_tmp10_ = args;
_tmp10__length1 = args_length1;
_tmp11_ = _tmp10_[0];
fprintf (_tmp9_, "Run '%s --help' to see a full list of available command line options.\n", _tmp11_);
result = 1;
_g_error_free0 (e);
return result;
}
__finally0:
if (_inner_error_ != NULL) {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0;
}
_tmp12_ = show_version;
if (_tmp12_) {
FILE* _tmp13_;
gchar* _tmp14_ = NULL;
gchar* _tmp15_;
_tmp13_ = stdout;
_tmp14_ = g_strdup_printf ("fsousaged %s\n", PACKAGE_VERSION);
_tmp15_ = _tmp14_;
fprintf (_tmp13_, "%s", _tmp15_);
_g_free0 (_tmp15_);
result = 1;
return result;
}
_tmp17_ = use_session_bus;
if (_tmp17_) {
_tmp16_ = G_BUS_TYPE_SESSION;
} else {
_tmp16_ = G_BUS_TYPE_SYSTEM;
}
_tmp18_ = _tmp16_;
bus_type = _tmp18_;
_tmp19_ = bus_type;
_tmp20_ = fso_framework_dbus_subsystem_new ("fsousage", _tmp19_);
_g_object_unref0 (subsystem);
subsystem = (FsoFrameworkSubsystem*) _tmp20_;
_tmp21_ = subsystem;
fso_framework_subsystem_registerPlugins (_tmp21_);
_tmp22_ = subsystem;
_tmp23_ = fso_framework_subsystem_loadPlugins (_tmp22_);
count = _tmp23_;
_tmp24_ = fso_framework_theLogger;
_tmp25_ = count;
_tmp26_ = g_strdup_printf ("loaded %u plugins", _tmp25_);
_tmp27_ = _tmp26_;
fso_framework_logger_info (_tmp24_, _tmp27_);
_g_free0 (_tmp27_);
_tmp28_ = count;
if (_tmp28_ > ((guint) 0)) {
GMainLoop* _tmp29_;
FsoFrameworkLogger* _tmp30_;
GMainLoop* _tmp31_;
FsoFrameworkLogger* _tmp32_;
_tmp29_ = g_main_loop_new (NULL, FALSE);
_g_main_loop_unref0 (mainloop);
mainloop = _tmp29_;
_tmp30_ = fso_framework_theLogger;
fso_framework_logger_info (_tmp30_, "fsousaged => mainloop");
signal (SIGINT, _sighandler_sighandler_t);
signal (SIGTERM, _sighandler_sighandler_t);
signal (SIGBUS, _sighandler_sighandler_t);
signal (SIGSEGV, _sighandler_sighandler_t);
_tmp31_ = mainloop;
g_main_loop_run (_tmp31_);
_tmp32_ = fso_framework_theLogger;
fso_framework_logger_info (_tmp32_, "mainloop => fsousaged");
}
_tmp33_ = fso_framework_theLogger;
fso_framework_logger_info (_tmp33_, "fsousaged exit");
result = 0;
return result;
}
int
main (int argc,
char **argv)
{
GOptionContext *context;
GError *error = NULL;
int ret;
static gboolean opt_packages = FALSE;
static gboolean opt_privileged = FALSE;
static gboolean opt_version = FALSE;
static gchar *opt_interactive = NULL;
static GOptionEntry entries[] = {
{ "interact", 0, 0, G_OPTION_ARG_STRING, &opt_interactive, "Interact with the raw protocol", "boundary" },
{ "privileged", 0, 0, G_OPTION_ARG_NONE, &opt_privileged, "Privileged copy of bridge", NULL },
{ "packages", 0, 0, G_OPTION_ARG_NONE, &opt_packages, "Show Cockpit package information", NULL },
{ "version", 0, 0, G_OPTION_ARG_NONE, &opt_version, "Show Cockpit version information", NULL },
{ NULL }
};
signal (SIGPIPE, SIG_IGN);
/* Debugging issues during testing */
#if WITH_DEBUG
signal (SIGABRT, cockpit_test_signal_backtrace);
signal (SIGSEGV, cockpit_test_signal_backtrace);
#endif
/*
* We have to tell GLib about an alternate default location for XDG_DATA_DIRS
* if we've been compiled with a different prefix. GLib caches that, so need
* to do this very early.
*/
if (!g_getenv ("XDG_DATA_DIRS") && !g_str_equal (DATADIR, "/usr/share"))
g_setenv ("XDG_DATA_DIRS", DATADIR, TRUE);
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
g_setenv ("GIO_USE_PROXY_RESOLVER", "dummy", TRUE);
g_setenv ("GIO_USE_VFS", "local", TRUE);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_description (context,
"cockpit-bridge is run automatically inside of a Cockpit session. When\n"
"run from the command line one of the options above must be specified.\n");
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error)
{
g_printerr ("cockpit-bridge: %s\n", error->message);
g_error_free (error);
return 1;
}
if (opt_packages)
{
cockpit_packages_dump ();
return 0;
}
else if (opt_version)
{
print_version ();
return 0;
}
if (!opt_interactive && isatty (1))
{
g_printerr ("cockpit-bridge: no option specified\n");
return 2;
}
ret = run_bridge (opt_interactive, opt_privileged);
g_free (opt_interactive);
return ret;
}
int
main (int argc,
char *argv[])
{
GOptionContext *context;
JsonObject *request = NULL;
JsonObject *reply = NULL;
GError *error = NULL;
const gchar *env;
const gchar *command = NULL;
const gchar *field = NULL;
const gchar *response = NULL;
gchar *user = NULL;
gchar *cookie = NULL;
gchar *challenge = NULL;
gint ret = 1;
static GOptionEntry entries[] = {
{ NULL }
};
/* Debugging issues during testing */
#if WITH_DEBUG
signal (SIGABRT, cockpit_test_signal_backtrace);
signal (SIGSEGV, cockpit_test_signal_backtrace);
#endif
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_description (context, "cockpit-bridge uses cockpit-askpass during password prompts.\n");
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error)
{
g_printerr ("cockpit-askpass: %s\n", error->message);
g_error_free (error);
return 1;
}
if (isatty (0))
{
g_printerr ("cockpit-askpass: this command is not meant to be run directly\n");
return 2;
}
/*
* We don't send an init message. This is meant to be used either after an
* "init" message has been sent, or with a caller that makes an exception for
* the "authorize" command message.
*/
env = g_getenv ("USER");
user = cockpit_hex_encode (env ? env : "", -1);
challenge = g_strdup_printf ("plain1:%s:", user);
cookie = g_strdup_printf ("askpass%u%u", (unsigned int)getpid (), (unsigned int)time (NULL));
request = cockpit_transport_build_json ("command", "authorize",
"challenge", challenge,
"cookie", cookie,
NULL);
/* Yes, we write to stdin which we expect to be a socketpair() */
if (write_control_message (STDIN_FILENO, request))
{
reply = read_control_message (STDIN_FILENO);
if (reply)
{
if (cockpit_json_get_string (reply, "command", "", &command) &&
cockpit_json_get_string (reply, "cookie", "", &field) &&
cockpit_json_get_string (reply, "response", "", &response))
{
if (g_str_equal (field, cookie) && g_str_equal (command, "authorize"))
{
/* The password is written back on stdout */
if (write_all (STDOUT_FILENO, response, -1) && write_all (STDOUT_FILENO, "\n", 1))
ret = 0;
}
else
{
g_message ("askpass received unexpected %s control message", command);
}
}
else
{
g_message ("askpass response has invalid control message authorize fields");
}
}
}
g_free (cookie);
g_free (challenge);
g_free (user);
/* Clear the password memory owned by JsonObject */
if (response)
cockpit_memory_clear ((gchar *)response, -1);
if (request)
json_object_unref (request);
if (reply)
json_object_unref (reply);
return ret;
}
void usage (gchar** args, int args_length1, FILE* output) {
GOptionContext* o = NULL;
const gchar* _tmp0_ = NULL;
GOptionContext* _tmp1_ = NULL;
const gchar* _tmp2_ = NULL;
gchar** _tmp3_ = NULL;
gint _tmp3__length1 = 0;
const gchar* _tmp4_ = NULL;
gchar* _tmp5_ = NULL;
gchar* _tmp6_ = NULL;
gchar* _tmp7_ = NULL;
gchar* _tmp8_ = NULL;
gchar* s = NULL;
gchar* _tmp9_ = NULL;
FILE* _tmp10_ = NULL;
GError * _inner_error_ = NULL;
g_return_if_fail (output != NULL);
_tmp0_ = _ ("COMMAND");
_tmp1_ = g_option_context_new (_tmp0_);
o = _tmp1_;
g_option_context_set_help_enabled (o, FALSE);
{
g_option_context_parse (o, &args_length1, &args, &_inner_error_);
if (G_UNLIKELY (_inner_error_ != NULL)) {
goto __catch0_g_error;
}
}
goto __finally0;
__catch0_g_error:
{
GError* e = NULL;
e = _inner_error_;
_inner_error_ = NULL;
_g_error_free0 (e);
}
__finally0:
if (G_UNLIKELY (_inner_error_ != NULL)) {
_g_option_context_free0 (o);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
_tmp2_ = _ ("Commands:\n" \
" help Shows this information\n" \
" decoder Run decoder\n" \
" context Run context\n" \
"\n" \
" Use \"%s COMMAND --help\" to get help on each command.\n");
_tmp3_ = args;
_tmp3__length1 = args_length1;
_tmp4_ = _tmp3_[0];
_tmp5_ = g_path_get_basename (_tmp4_);
_tmp6_ = _tmp5_;
_tmp7_ = g_strdup_printf (_tmp2_, _tmp6_);
_tmp8_ = _tmp7_;
g_option_context_set_description (o, _tmp8_);
_g_free0 (_tmp8_);
_g_free0 (_tmp6_);
_tmp9_ = g_option_context_get_help (o, FALSE, NULL);
s = _tmp9_;
_tmp10_ = output;
fprintf (_tmp10_, "%s", s);
_g_free0 (s);
_g_option_context_free0 (o);
}
int
main (int argc,
char **argv)
{
CockpitTransport *transport;
gboolean terminated = FALSE;
gboolean interupted = FALSE;
gboolean closed = FALSE;
GOptionContext *context;
GError *error = NULL;
guint sig_term;
guint sig_int;
int outfd;
static GOptionEntry entries[] = {
{ "lower", 0, 0, G_OPTION_ARG_NONE, &opt_lower, "Lower case channel type", NULL },
{ "upper", 0, 0, G_OPTION_ARG_NONE, &opt_upper, "Upper case channel type", NULL },
{ NULL }
};
signal (SIGPIPE, SIG_IGN);
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
g_setenv ("GIO_USE_PROXY_RESOLVER", "dummy", TRUE);
g_setenv ("GIO_USE_VFS", "local", TRUE);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_description (context, "mock-bridge as used in tests\n");
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error)
{
g_printerr ("mock-bridge: %s\n", error->message);
g_error_free (error);
return 1;
}
outfd = dup (1);
if (outfd < 0 || dup2 (2, 1) < 1)
{
g_warning ("bridge couldn't redirect stdout to stderr");
outfd = 1;
}
sig_term = g_unix_signal_add (SIGTERM, on_signal_done, &terminated);
sig_int = g_unix_signal_add (SIGINT, on_signal_done, &interupted);
g_type_init ();
transport = cockpit_pipe_transport_new_fds ("stdio", 0, outfd);
g_signal_connect (transport, "control", G_CALLBACK (on_transport_control), NULL);
g_signal_connect (transport, "closed", G_CALLBACK (on_closed_set_flag), &closed);
send_init_command (transport);
/* Owns the channels */
channels = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
while (!terminated && !closed && !interupted)
g_main_context_iteration (NULL, TRUE);
g_object_unref (transport);
g_hash_table_destroy (channels);
g_source_remove (sig_term);
g_source_remove (sig_int);
/* So the caller gets the right signal */
if (terminated)
raise (SIGTERM);
return 0;
}
int
handle_mkdir (int argc, char *argv[], gboolean do_help)
{
GOptionContext *context;
gchar *param;
GError *error = NULL;
GFile *file;
int retval = 0;
int i;
g_set_prgname ("gio mkdir");
/* Translators: commandline placeholder */
param = g_strdup_printf ("%s...", _("LOCATION"));
context = g_option_context_new (param);
g_free (param);
g_option_context_set_help_enabled (context, FALSE);
g_option_context_set_summary (context, _("Create directories."));
g_option_context_set_description (context,
_("gio mkdir is similar to the traditional mkdir utility, but using GIO\n"
"locations instead of local files: for example, you can use something\n"
"like smb://server/resource/mydir as location."));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
if (do_help)
{
show_help (context, NULL);
return 0;
}
if (!g_option_context_parse (context, &argc, &argv, &error))
{
show_help (context, error->message);
g_error_free (error);
return 1;
}
if (argc < 2)
{
show_help (context, _("No locations gives"));
return 1;
}
g_option_context_free (context);
for (i = 1; i < argc; i++)
{
file = g_file_new_for_commandline_arg (argv[i]);
error = NULL;
if (parent)
{
if (!g_file_make_directory_with_parents (file, NULL, &error))
{
print_file_error (file, error->message);
g_error_free (error);
retval = 1;
}
}
else
{
if (!g_file_make_directory (file, NULL, &error))
{
print_file_error (file, error->message);
g_error_free (error);
retval = 1;
}
g_object_unref (file);
}
}
return retval;
}
/* Parses the program arguments. Returns TRUE if program needs
* to exit after parsing is complete
*/
gboolean parse_options(int argc, char* argv[])
{
/* Declare argument options and argument variables */
gboolean icon = FALSE, daemon = FALSE,
clipboard = FALSE, primary = FALSE,
exit = FALSE;
GOptionEntry main_entries[] =
{
{
"daemon", 'd',
0,
G_OPTION_ARG_NONE,
&daemon, _("Run as daemon"),
NULL
},
{
"no-icon", 'n',
0,
G_OPTION_ARG_NONE,
&icon, _("Do not use status icon (Ctrl-Alt-P for menu)"),
NULL
},
{
"clipboard", 'c',
0,
G_OPTION_ARG_NONE,
&clipboard, _("Print clipboard contents"),
NULL
},
{
"primary", 'p',
0,
G_OPTION_ARG_NONE,
&primary, _("Print primary contents"),
NULL
},
{
NULL
}
};
/* Option parsing */
GOptionContext *context = g_option_context_new(NULL);
/* Set summary */
g_option_context_set_summary(context,
_("Clipboard CLI usage examples:\n\n"
" echo \"copied to clipboard\" | clipit\n"
" clipit \"copied to clipboard\"\n"
" echo \"copied to clipboard\" | clipit -c"));
/* Set description */
g_option_context_set_description(context,
_("Written by Cristian Henzel.\n"
"Report bugs to <*****@*****.**>."));
/* Add entries and parse options */
g_option_context_add_main_entries(context, main_entries, NULL);
g_option_context_parse(context, &argc, &argv, NULL);
g_option_context_free(context);
/* Check which options were parseed */
/* Do not display icon option */
if (icon)
{
prefs.no_icon = TRUE;
}
/* Run as daemon option */
else if (daemon)
{
init_daemon_mode();
exit = TRUE;
}
/* Print clipboard option */
else if (clipboard)
{
/* Grab clipboard */
GtkClipboard *clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
/* Check if stdin has text to copy */
if (!isatty(fileno(stdin)))
{
GString *piped_string = g_string_new(NULL);
/* Append stdin to string */
while (1)
{
gchar *buffer = (gchar*)g_malloc(256);
if (fgets(buffer, 256, stdin) == NULL)
{
g_free(buffer);
break;
}
g_string_append(piped_string, buffer);
g_free(buffer);
}
/* Check if anything was piped in */
if (piped_string->len > 0)
{
/* Copy to clipboard */
gtk_clipboard_set_text(clip, piped_string->str, -1);
gtk_clipboard_store(clip);
}
g_string_free(piped_string, TRUE);
}
/* Print clipboard text (if any) */
gchar *clip_text = gtk_clipboard_wait_for_text(clip);
if (clip_text)
g_print("%s", clip_text);
g_free(clip_text);
/* Return true so program exits when finished parsing */
exit = TRUE;
}
else if (primary)
{
/* Grab primary */
GtkClipboard *prim = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
/* Print primary text (if any) */
gchar *prim_text = gtk_clipboard_wait_for_text(prim);
if (prim_text)
g_print("%s", prim_text);
g_free(prim_text);
/* Return true so program exits when finished parsing */
exit = TRUE;
}
else
{
/* Copy from unrecognized options */
gchar *argv_string = g_strjoinv(" ", argv + 1);
GtkClipboard *clip = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text(clip, argv_string, -1);
gtk_clipboard_store(clip);
g_free(argv_string);
/* Return true so program exits when finished parsing */
exit = TRUE;
}
return exit;
}
int
main (int argc,
char **argv)
{
GOptionContext *context;
GError *error = NULL;
int ret;
static gboolean opt_packages = FALSE;
static gboolean opt_version = FALSE;
static gchar *opt_interactive = NULL;
static GOptionEntry entries[] = {
{ "interact", 0, 0, G_OPTION_ARG_STRING, &opt_interactive, "Interact with the raw protocol", "boundary" },
{ "packages", 0, 0, G_OPTION_ARG_NONE, &opt_packages, "Show Cockpit package information", NULL },
{ "version", 0, 0, G_OPTION_ARG_NONE, &opt_version, "Show Cockpit version information", NULL },
{ NULL }
};
signal (SIGPIPE, SIG_IGN);
/* Debugging issues during testing */
#if WITH_DEBUG
signal (SIGABRT, cockpit_test_signal_backtrace);
signal (SIGSEGV, cockpit_test_signal_backtrace);
#endif
g_setenv ("GSETTINGS_BACKEND", "memory", TRUE);
g_setenv ("GIO_USE_PROXY_RESOLVER", "dummy", TRUE);
g_setenv ("GIO_USE_VFS", "local", TRUE);
/*
* All channels that are added here should
* not rely on running as a real user, however
* they may lookup paths, such as run dir or
* home directory. Glib has problems if
* g_get_user_database_entry is called without
* a real user, which it's path functions
* do as a last resort when no environment vars
* are set. So set HOME if it isn't set..
*/
g_setenv("HOME", "/", FALSE);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_description (context,
"cockpit-stub provides a limited number of channels and is meant to be"
"used in place of cockpit-bridge in non-system setting. When\n"
"run from the command line one of the options above must be specified.\n");
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error)
{
g_printerr ("cockpit-stub: %s\n", error->message);
g_error_free (error);
return 1;
}
if (opt_packages)
{
cockpit_packages_dump ();
return 0;
}
else if (opt_version)
{
print_version ();
return 0;
}
if (!opt_interactive && isatty (1))
{
g_printerr ("cockpit-stub: no option specified\n");
return 2;
}
ret = run_bridge (opt_interactive);
g_free (opt_interactive);
return ret;
}
int
main (int argc,
char **argv)
{
GtkWidget *window = NULL;
GError *error = NULL;
GOptionContext *context;
char *dir, *description;
int result = EXIT_SUCCESS;
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
setlocale (LC_ALL, "");
g_thread_init (NULL);
gdk_threads_init ();
gdk_threads_enter ();
context = g_option_context_new (NULL);
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
description = g_strdup_printf (_("Report errors (in English, with LC_ALL=C) to <%s>."), PACKAGE_BUGREPORT);
g_option_context_set_summary (context, N_("Giggle is a graphical frontend for the git content tracker."));
g_option_context_set_description (context, description);
g_free (description);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
gchar *the_basename = g_filename_display_basename (argv[0]);
g_printerr ("%s: %s\n", the_basename, error->message);
g_printerr (_("Try `%s --help' for more information.\n"), the_basename);
result = EXIT_FAILURE;
g_free (the_basename);
goto end;
}
/* Freing memory */
g_option_context_free (context);
gtk_icon_theme_prepend_search_path (gtk_icon_theme_get_default (), ICONDIR);
if (g_file_test ("pixmaps", G_FILE_TEST_IS_DIR))
gtk_icon_theme_prepend_search_path (gtk_icon_theme_get_default (), "pixmaps");
if (version) {
g_print ("%s %s, "
"Copyright (C) 2007-2008 Imendio AB, "
"Copyright (C) 2008 Mathias Hasselmann\n",
PACKAGE_NAME, PACKAGE_VERSION);
goto end;
}
gtk_window_set_default_icon_name (PACKAGE);
g_set_application_name ("Giggle");
window = giggle_window_new ();
/* Set dir to:
- the first remaining arg, or
- the value of GIT_DIR, or
- the current working dir */
if (dirs && *dirs) {
dir = g_strdup (*dirs);
g_strfreev (dirs);
} else {
dir = g_strdup (g_getenv ("GIT_DIR"));
if (dir == NULL) {
dir = g_get_current_dir ();
}
}
g_unsetenv ("GIT_DIR");
if (clone_uri) {
GtkWidget *clone_dialog;
GtkResponseType response;
gchar *clone_dir;
clone_dir = g_strdup (dir);
clone_dialog = giggle_clone_dialog_new (clone_uri, clone_dir);
g_free (clone_dir);
response = gtk_dialog_run (GTK_DIALOG (clone_dialog));
if (response == GTK_RESPONSE_ACCEPT) {
/* replace dir with the the newly cloned repo's one */
g_free (dir);
dir = g_strdup (giggle_clone_dialog_get_directory (GIGGLE_CLONE_DIALOG (clone_dialog)));
}
gtk_widget_destroy (clone_dialog);
}
if (giggle_git_test_dir (dir)) {
giggle_window_set_directory (GIGGLE_WINDOW (window), dir);
} else {
gtk_widget_show (window);
}
g_free (dir);
/* window will show itself when it reads its initial size configuration */
if (diff_window)
giggle_window_show_diff_window (GIGGLE_WINDOW (window));
gtk_main ();
end:
if (window)
gtk_widget_destroy (window);
gdk_threads_leave ();
return result;
}
//!
//! @brief Loads the arguments from the command line into the app instance
//!
static void
w_application_parse_args (WApplication *application, int *argc, char** argv[])
{
WApplicationPrivate *priv;
const gchar *summary_text;
const gchar *description_text;
GError *error;
priv = application->priv;
//Reset the switches to their default state
if (priv->arg_dictionary_switch_data != NULL) g_free (priv->arg_dictionary_switch_data); priv->arg_dictionary_switch_data = NULL;
if (priv->arg_query_text_data != NULL) g_free (priv->arg_query_text_data); priv->arg_query_text_data = NULL;
priv->arg_version_switch = FALSE;
error = NULL;
if (priv->context != NULL) g_option_context_free (priv->context); priv->context = NULL;
priv->context = g_option_context_new (gettext("- A dictionary program for Japanese-English translation."));
summary_text = gettext("waei generally outputs directly to the console.");
description_text = g_strdup_printf(
gettext(
"Examples:\n"
" waei English Search for the english word English\n"
" waei \"cats&dogs\" Search for results containing cats and dogs\n"
" waei \"cats|dogs\" Search for results containing cats or dogs\n"
" waei cats dogs Search for results containing \"cats dogs\"\n"
" waei %s Search for the Japanese word %s\n"
" waei -e %s Search for %s and ignore similar results\n"
" waei %s When you don't know a kanji character\n"
" waei -d Kanji %s Find a kanji character in the kanji dictionary\n"
" waei -d Names %s Look up a name in the names dictionary\n"
" waei -d Places %s Look up a place in the places dictionary"
)
, "にほん", "にほん", "日本", "日本", "日.語", "魚", "Miyabe", "Tokyo"
);
GOptionEntry entries[] = {
{ "exact", 'e', 0, G_OPTION_ARG_NONE, &(priv->arg_exact_switch), gettext("Do not display less relevant results"), NULL },
{ "quiet", 'q', 0, G_OPTION_ARG_NONE, &(priv->arg_quiet_switch), gettext("Display less information"), NULL },
{ "color", 'c', 0, G_OPTION_ARG_NONE, &(priv->arg_color_switch), gettext("Display results with color"), NULL },
{ "dictionary", 'd', 0, G_OPTION_ARG_STRING, &(priv->arg_dictionary_switch_data), gettext("Search using a chosen dictionary"), NULL },
{ "list", 'l', 0, G_OPTION_ARG_NONE, &(priv->arg_list_switch), gettext("Show available dictionaries for searches"), NULL },
{ "install", 'i', 0, G_OPTION_ARG_STRING, &(priv->arg_install_switch_data), gettext("Install dictionary"), NULL },
{ "uninstall", 'u', 0, G_OPTION_ARG_STRING, &(priv->arg_uninstall_switch_data), gettext("Uninstall dictionary"), NULL },
{ "version", 'v', 0, G_OPTION_ARG_NONE, &(priv->arg_version_switch), gettext("Check the waei version information"), NULL },
{ NULL }
};
g_option_context_set_description (priv->context, description_text);
g_option_context_set_summary (priv->context, summary_text);
g_option_context_add_main_entries (priv->context, entries, PACKAGE);
g_option_context_set_ignore_unknown_options (priv->context, TRUE);
g_option_context_parse (priv->context, argc, argv, &error);
if (error != NULL)
{
w_application_handle_error (application, &error);
exit(1);
}
//Get the query after the flags have been parsed out
priv->arg_query_text_data = lw_util_get_query_from_args (*argc, *argv);
}
int
main (int argc, char *argv[])
{
GtkApplication *app;
GError *error = NULL;
GOptionContext *context;
GOptionGroup *debug;
gulong debug_flags = 0;
LifereaDBus *dbus = NULL;
gchar *feedUri = NULL;
gint status;
GOptionEntry entries[] = {
{ "mainwindow-state", 'w', 0, G_OPTION_ARG_STRING, &initialStateOption, N_("Start Liferea with its main window in STATE. STATE may be `shown', `iconified', or `hidden'"), N_("STATE") },
{ "version", 'v', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version, N_("Show version information and exit"), NULL },
{ "add-feed", 'a', 0, G_OPTION_ARG_STRING, &feedUri, N_("Add a new subscription"), N_("uri") },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
GOptionEntry debug_entries[] = {
{ "debug-all", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all types"), NULL },
{ "debug-cache", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the cache handling"), NULL },
{ "debug-conf", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages for the configuration handling"), NULL },
{ "debug-db", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the database handling"), NULL },
{ "debug-gui", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all GUI functions"), NULL },
{ "debug-html", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Enables HTML rendering debugging. Each time Liferea renders HTML output it will also dump the generated HTML into ~/.cache/liferea/output.xhtml"), NULL },
{ "debug-net", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all network activity"), NULL },
{ "debug-parsing", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of all parsing functions"), NULL },
{ "debug-performance", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when a function takes too long to process"), NULL },
{ "debug-trace", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages when entering/leaving functions"), NULL },
{ "debug-update", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the feed update processing"), NULL },
{ "debug-vfolder", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print debugging messages of the search folder matching"), NULL },
{ "debug-verbose", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, debug_entries_parse_callback, N_("Print verbose debugging messages"), NULL },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
debug = g_option_group_new ("debug",
_("Print debugging messages for the given topic"),
_("Print debugging messages for the given topic"),
&debug_flags,
NULL);
g_option_group_set_translation_domain(debug, GETTEXT_PACKAGE);
g_option_group_add_entries (debug, debug_entries);
context = g_option_context_new (NULL);
g_option_context_set_summary (context, N_("Liferea, the Linux Feed Reader"));
g_option_context_set_description (context, N_("For more information, please visit http://lzone.de/liferea/"));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_set_translation_domain(context, GETTEXT_PACKAGE);
g_option_context_add_group (context, debug);
g_option_context_add_group (context, gtk_get_option_group (FALSE));
g_option_context_add_group (context, g_irepository_get_option_group ());
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error) {
g_print ("Error parsing options: %s\n", error->message);
}
set_debug_level (debug_flags);
/* Configuration necessary for network options, so it
has to be initialized before update_init() */
conf_init ();
/* We need to do the network initialization here to allow
network-manager to be setup before gtk_init() */
update_init ();
gtk_init (&argc, &argv);
/* Single instance checks, also note that we pass or only RPC (add-feed)
as activate signal payload as it is simply an URI string. */
app = gtk_application_new ("net.sourceforge.liferea", G_APPLICATION_HANDLES_OPEN);
g_signal_connect (app, "activate", G_CALLBACK (on_app_activate), feedUri);
g_signal_connect (app, "open", G_CALLBACK (on_feed_add), NULL);
g_set_prgname ("liferea");
g_set_application_name (_("Liferea"));
gtk_window_set_default_icon_name ("liferea"); /* GTK theme support */
debug_start_measurement (DEBUG_DB);
/* order is important! */
db_init (); /* initialize sqlite */
xml_init (); /* initialize libxml2 */
#ifdef HAVE_LIBNOTIFY
notification_plugin_register (&libnotify_plugin);
#endif
social_init (); /* initialize social bookmarking */
dbus = liferea_dbus_new ();
signal (SIGTERM, signal_handler);
signal (SIGINT, signal_handler);
signal (SIGHUP, signal_handler);
/* Note: we explicitely do not use the gdk_thread_*
locking in Liferea because it freezes the program
when running Flash applets */
runState = STATE_STARTING;
debug_end_measurement (DEBUG_DB, "startup");
status = g_application_run (G_APPLICATION (app), 0, NULL);
/* Trigger RPCs if we are not primary instance (currently only feed-add) */
if (feedUri && g_application_get_is_remote (G_APPLICATION (app))) {
GFile *uris[2];
uris[0] = g_file_new_for_uri (feedUri);
uris[1] = NULL;
g_application_open (G_APPLICATION (app), uris, 1, "feed-add");
g_object_unref (uris[0]);
}
g_object_unref (G_OBJECT (dbus));
g_object_unref (app);
return status;
}
int
main (int argc, char *argv[])
{
GError *error = NULL;
init ("xpstotiff");
GOptionContext *context = g_option_context_new ("- convert a xps document to tiff");
g_option_context_set_description (context, "Report bugs to <" PACKAGE_BUGREPORT ">");
g_option_context_add_main_entries (context, options, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
rerror ("%s", error->message);
if (in_filename == NULL)
rerror ("no input file specified");
out_filename = get_output_filename (in_filename[0], out_filename, ".tiff");
TIFF *tif = TIFFOpen (out_filename, "w");
if (tif == NULL)
rerror ("Unable to open %s", out_filename);
foreach_gxps_page (in_filename[0], xps_page_cb, tif);
TIFFClose (tif);
return EXIT_SUCCESS;
}
