static void
rspamadm_confighelp (gint argc, gchar **argv)
{
struct rspamd_config *cfg;
ucl_object_t *doc_obj;
const ucl_object_t *elt;
GOptionContext *context;
GError *error = NULL;
module_t *mod, **pmod;
worker_t **pworker;
struct module_ctx *mod_ctx;
gint i = 1, ret = 0, processed_args = 0;
context = g_option_context_new (
"confighelp - displays help for the configuration options");
g_option_context_set_summary (context,
"Summary:\n Rspamd administration utility version "
RVERSION
"\n Release id: "
RID);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
rspamd_fprintf (stderr, "option parsing failed: %s\n", error->message);
g_error_free (error);
exit (1);
}
pworker = &workers[0];
while (*pworker) {
/* Init string quarks */
(void) g_quark_from_static_string ((*pworker)->name);
pworker++;
}
cfg = rspamd_config_new ();
cfg->compiled_modules = modules;
cfg->compiled_workers = workers;
rspamd_rcl_config_init (cfg);
/* Init modules to get documentation strings */
for (pmod = cfg->compiled_modules; pmod != NULL && *pmod != NULL; pmod++) {
mod = *pmod;
mod_ctx = g_slice_alloc0 (sizeof (struct module_ctx));
if (mod->module_init_func (cfg, &mod_ctx) == 0) {
g_hash_table_insert (cfg->c_modules,
(gpointer) mod->name,
mod_ctx);
mod_ctx->mod = mod;
}
}
/* Also init all workers */
for (pworker = cfg->compiled_workers; *pworker != NULL; pworker ++) {
(*pworker)->worker_init_func (cfg);
}
if (argc > 1) {
for (i = 1; i < argc; i ++) {
if (argv[i][0] != '-') {
if (keyword) {
doc_obj = rspamadm_confighelp_search_word (cfg->doc_strings,
argv[i]);
}
else {
doc_obj = ucl_object_typed_new (UCL_OBJECT);
elt = ucl_object_lookup_path (cfg->doc_strings, argv[i]);
if (elt) {
ucl_object_insert_key (doc_obj, ucl_object_ref (elt),
argv[i], 0, false);
}
}
if (doc_obj != NULL) {
rspamadm_confighelp_show (cfg, argc, argv, argv[i], doc_obj);
ucl_object_unref (doc_obj);
}
else {
rspamd_fprintf (stderr,
"Cannot find help for %s\n",
argv[i]);
ret = EXIT_FAILURE;
}
processed_args ++;
}
}
}
if (processed_args == 0) {
/* Show all documentation strings */
rspamadm_confighelp_show (cfg, argc, argv, NULL, cfg->doc_strings);
}
rspamd_config_free (cfg);
exit (ret);
}
static void parse_args(gint argc, gchar **argv, FileInfo *fi)
{
EncArray *encarray;
gint i;
GError *error = NULL;
GOptionContext *context;
gchar *opt_codeset = NULL;
gint opt_tab_width = 0;
gboolean opt_jump = 0;
gboolean opt_version = FALSE;
GOptionEntry entries[] =
{
{ "codeset", 0, 0, G_OPTION_ARG_STRING, &opt_codeset, "Set codeset to open file", "CODESET" },
{ "tab-width", 0, 0, G_OPTION_ARG_INT, &opt_tab_width, "Set tab width", "WIDTH" },
{ "jump", 0, 0, G_OPTION_ARG_INT, &opt_jump, "Jump to specified line", "LINENUM" },
{ "version", 0, 0, G_OPTION_ARG_NONE, &opt_version, "Show version number", NULL },
{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
context = g_option_context_new("[filename]");
g_option_context_add_main_entries(context, entries, PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
g_option_context_set_ignore_unknown_options(context, FALSE);
g_option_context_parse(context, &argc, &argv, &error);
g_option_context_free(context);
if (error) {
g_print("%s: %s\n", PACKAGE, error->message);
g_error_free(error);
exit(-1);
}
if (opt_version) {
g_print("%s\n", PACKAGE_STRING);
exit(0);
}
if (opt_codeset) {
g_convert("TEST", -1, "UTF-8", opt_codeset, NULL, NULL, &error);
if (error) {
g_error_free(error);
error = NULL;
} else {
g_free(fi->charset);
fi->charset = g_strdup(opt_codeset);
}
}
if (opt_tab_width)
indent_set_default_tab_width(opt_tab_width);
if (opt_jump)
jump_linenum = opt_jump;
if (fi->charset
&& (g_ascii_strcasecmp(fi->charset, get_default_charset()) != 0)
&& (g_ascii_strcasecmp(fi->charset, "UTF-8") != 0)) {
encarray = get_encoding_items(get_encoding_code());
for (i = 0; i < ENCODING_MAX_ITEM_NUM; i++)
if (encarray->item[i])
if (g_ascii_strcasecmp(fi->charset, encarray->item[i]) == 0)
break;
if (i == ENCODING_MAX_ITEM_NUM)
fi->charset_flag = TRUE;
}
if (argc >= 2)
fi->filename = parse_file_uri(argv[1]);
}
gboolean
mc_args_parse (int *argc, char ***argv, const char *translation_domain, GError ** error)
{
const gchar *_system_codepage;
gboolean ok = TRUE;
_system_codepage = str_detect_termencoding ();
#ifdef ENABLE_NLS
if (!str_isutf8 (_system_codepage))
bind_textdomain_codeset ("mc", "UTF-8");
#endif
context = g_option_context_new (mc_args_add_usage_info ());
g_option_context_set_ignore_unknown_options (context, FALSE);
mc_args_add_extended_info_to_help ();
main_group = g_option_group_new ("main", _("Main options"), _("Main options"), NULL, NULL);
g_option_group_add_entries (main_group, argument_main_table);
g_option_context_set_main_group (context, main_group);
g_option_group_set_translation_domain (main_group, translation_domain);
terminal_group = g_option_group_new ("terminal", _("Terminal options"),
_("Terminal options"), NULL, NULL);
g_option_group_add_entries (terminal_group, argument_terminal_table);
g_option_context_add_group (context, terminal_group);
g_option_group_set_translation_domain (terminal_group, translation_domain);
color_group = mc_args_new_color_group ();
g_option_group_add_entries (color_group, argument_color_table);
g_option_context_add_group (context, color_group);
g_option_group_set_translation_domain (color_group, translation_domain);
if (!g_option_context_parse (context, argc, argv, error))
{
GError *error2 = NULL;
if (*error == NULL)
*error = g_error_new (MC_ERROR, 0, "%s\n", _("Arguments parse error!"));
else
{
gchar *help_str;
#if GLIB_CHECK_VERSION(2,14,0)
help_str = g_option_context_get_help (context, TRUE, NULL);
#else
help_str = g_strdup ("");
#endif
if (str_isutf8 (_system_codepage))
error2 = g_error_new ((*error)->domain, (*error)->code, "%s\n\n%s\n",
(*error)->message, help_str);
else
{
gchar *full_help_str;
full_help_str =
mc_args__convert_help_to_syscharset (_system_codepage, (*error)->message,
help_str);
error2 = g_error_new ((*error)->domain, (*error)->code, "%s", full_help_str);
g_free (full_help_str);
}
g_free (help_str);
g_error_free (*error);
*error = error2;
}
ok = FALSE;
}
g_option_context_free (context);
mc_args_clean_temp_help_strings ();
#ifdef ENABLE_NLS
if (!str_isutf8 (_system_codepage))
bind_textdomain_codeset ("mc", _system_codepage);
#endif
return ok;
}
int main(int argc, char *argv[])
{
struct cmd *c;
#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init ();
#endif
config_dir = DEFAULT_CONFIG_DIR;
if (argc == 1) {
usage();
exit(1);
}
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_print ("option parsing failed: %s\n", error->message);
exit (1);
}
if (print_version) {
show_version();
exit(0);
}
if (argc <= 1) {
usage();
exit(1);
}
c = getcmd (argv[1]);
if (c == NULL) {
usage();
exit(1);
}
g_log_set_default_handler (ccnet_servtool_log, NULL);
client = ccnet_client_new ();
if ( (ccnet_client_load_confdir(client, central_config_dir, config_dir)) < 0 ) {
fprintf (stderr, "Read config dir error\n");
exit(1);
}
if (ccnet_client_connect_daemon (client, CCNET_CLIENT_SYNC) < 0)
{
fprintf(stderr, "Connect to server fail: %s\n", strerror(errno));
exit(1);
}
argc -= 2;
argv += 2;
c->handler (argc, argv);
ccnet_client_disconnect_daemon (client);
return 0;
}
int main (int argc, char *argv[])
{
NMOPENCONNECTPlugin *plugin;
gboolean persist = FALSE;
GOptionContext *opt_ctx = NULL;
GOptionEntry options[] = {
{ "persist", 0, 0, G_OPTION_ARG_NONE, &persist, N_("Don't quit when VPN connection terminates"), NULL },
{ "debug", 0, 0, G_OPTION_ARG_NONE, &debug, N_("Enable verbose debug logging (may expose passwords)"), NULL },
{NULL}
};
#if !GLIB_CHECK_VERSION (2, 35, 0)
g_type_init ();
#endif
/* locale will be set according to environment LC_* variables */
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, NM_OPENCONNECT_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* Parse options */
opt_ctx = g_option_context_new (NULL);
g_option_context_set_translation_domain (opt_ctx, GETTEXT_PACKAGE);
g_option_context_set_ignore_unknown_options (opt_ctx, FALSE);
g_option_context_set_help_enabled (opt_ctx, TRUE);
g_option_context_add_main_entries (opt_ctx, options, NULL);
g_option_context_set_summary (opt_ctx,
_("nm-openconnect-service provides integrated Cisco AnyConnect SSL VPN capability to NetworkManager."));
g_option_context_parse (opt_ctx, &argc, &argv, NULL);
g_option_context_free (opt_ctx);
if (getenv ("OPENCONNECT_DEBUG"))
debug = TRUE;
if (debug)
g_message ("nm-openconnect-service (version " DIST_VERSION ") starting...");
if (system ("/sbin/modprobe tun") == -1)
exit (EXIT_FAILURE);
plugin = nm_openconnect_plugin_new ();
if (!plugin)
exit (EXIT_FAILURE);
loop = g_main_loop_new (NULL, FALSE);
if (!persist)
g_signal_connect (plugin, "quit", G_CALLBACK (quit_mainloop), loop);
setup_signals ();
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (plugin);
exit (EXIT_SUCCESS);
}
int
main (int argc,
char *argv[])
{
GTestDBus *bus;
GError *error = NULL;
GOptionContext *context;
guint sig_term;
guint sig_int;
int i;
gchar *guid = NULL;
GDBusServer *direct_dbus_server = NULL;
GOptionEntry entries[] = {
{ NULL }
};
signal (SIGPIPE, SIG_IGN);
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_setenv ("XDG_DATA_HOME", SRCDIR "/src/bridge/mock-resource/home", TRUE);
g_setenv ("XDG_DATA_DIRS", SRCDIR "/src/bridge/mock-resource/system", TRUE);
setup_path (argv[0]);
g_type_init ();
g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR);
sig_term = g_unix_signal_add (SIGTERM, on_signal_done, NULL);
sig_int = g_unix_signal_add (SIGINT, on_signal_done, NULL);
// System cockpit configuration file should not be loaded
cockpit_config_file = NULL;
context = g_option_context_new ("- test dbus json server");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("test-server: %s\n", error->message);
exit (2);
}
/* This isolates us from affecting other processes during tests */
bus = g_test_dbus_new (G_TEST_DBUS_NONE);
g_test_dbus_up (bus);
bus_address = g_test_dbus_get_bus_address (bus);
guid = g_dbus_generate_guid ();
direct_dbus_server = g_dbus_server_new_sync ("unix:tmpdir=/tmp/dbus-tests",
G_DBUS_SERVER_FLAGS_NONE,
guid,
NULL,
NULL,
&error);
if (direct_dbus_server == NULL)
{
g_printerr ("test-server: %s\n", error->message);
exit (3);
}
/* Skip the program name */
argc--;
argv++;
/* Null terminate the bridge command line */
bridge_argv = g_new0 (char *, argc + 2);
for (i = 0; i < argc; i++)
bridge_argv[i] = argv[i];
bridge_argv[i] = "cockpit-bridge";
loop = g_main_loop_new (NULL, FALSE);
g_bus_own_name (G_BUS_TYPE_SESSION,
"com.redhat.Cockpit.DBusTests.Test",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE,
on_bus_acquired,
on_name_acquired,
on_name_lost,
loop,
NULL);
g_bus_own_name (G_BUS_TYPE_SESSION,
"com.redhat.Cockpit.DBusTests.Second",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE,
NULL,
on_second_acquired,
on_name_lost,
loop,
NULL);
g_signal_connect_object (direct_dbus_server,
"new-connection",
G_CALLBACK (on_new_direct_connection),
NULL, 0);
g_dbus_server_start (direct_dbus_server);
direct_address = g_dbus_server_get_client_address (direct_dbus_server);
g_main_loop_run (loop);
g_source_remove (sig_term);
g_source_remove (sig_int);
g_clear_object (&bridge);
g_clear_object (&exported);
g_clear_object (&exported_b);
g_clear_object (&direct_dbus_server);
g_clear_object (&direct);
g_clear_object (&direct_b);
g_main_loop_unref (loop);
g_test_dbus_down (bus);
g_object_unref (bus);
g_free (bridge_argv);
g_free (guid);
return exit_code;
}
/* main */
int
main (int argc, char *argv[])
{
GOptionContext *context;
GOptionGroup *group;
gboolean window_arg = FALSE;
gboolean area_arg = FALSE;
gboolean include_border_arg = FALSE;
gboolean disable_border_arg = FALSE;
gboolean interactive_arg = FALSE;
gchar *border_effect_arg = NULL;
guint delay_arg = 0;
GError *error = NULL;
const GOptionEntry entries[] = {
{ "window", 'w', 0, G_OPTION_ARG_NONE, &window_arg, N_("Grab a window instead of the entire screen"), NULL },
{ "area", 'a', 0, G_OPTION_ARG_NONE, &area_arg, N_("Grab an area of the screen instead of the entire screen"), NULL },
{ "include-border", 'b', 0, G_OPTION_ARG_NONE, &include_border_arg, N_("Include the window border with the screenshot"), NULL },
{ "remove-border", 'B', 0, G_OPTION_ARG_NONE, &disable_border_arg, N_("Remove the window border from the screenshot"), NULL },
{ "delay", 'd', 0, G_OPTION_ARG_INT, &delay_arg, N_("Take screenshot after specified delay [in seconds]"), N_("seconds") },
{ "border-effect", 'e', 0, G_OPTION_ARG_STRING, &border_effect_arg, N_("Effect to add to the border (shadow, border or none)"), N_("effect") },
{ "interactive", 'i', 0, G_OPTION_ARG_NONE, &interactive_arg, N_("Interactively set options"), NULL },
{ NULL },
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_thread_init (NULL);
context = g_option_context_new (_("Take a picture of the screen"));
g_option_context_set_ignore_unknown_options (context, FALSE);
g_option_context_set_help_enabled (context, TRUE);
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, &error);
if (error) {
g_critical ("Unable to parse arguments: %s", error->message);
g_error_free (error);
g_option_context_free (context);
exit (1);
}
g_option_context_free (context);
if (window_arg && area_arg) {
g_printerr (_("Conflicting options: --window and --area should not be "
"used at the same time.\n"));
exit (1);
}
gtk_window_set_default_icon_name (SCREENSHOOTER_ICON);
screenshooter_init_stock_icons ();
load_options ();
/* allow the command line to override options */
if (window_arg)
take_window_shot = TRUE;
if (area_arg)
take_area_shot = TRUE;
if (include_border_arg)
include_border = TRUE;
if (disable_border_arg)
include_border = FALSE;
if (border_effect_arg)
{
g_free (border_effect);
border_effect = border_effect_arg;
}
if (delay_arg > 0)
delay = delay_arg;
/* interactive mode overrides everything */
if (interactive_arg)
{
GtkWidget *dialog;
gint response;
dialog = create_interactive_dialog ();
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
switch (response)
{
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CANCEL:
return EXIT_SUCCESS;
case GTK_RESPONSE_OK:
break;
default:
g_assert_not_reached ();
break;
}
}
if (((delay > 0 && interactive_arg) || delay_arg > 0) &&
!take_area_shot)
{
g_timeout_add (delay * 1000,
prepare_screenshot_timeout,
NULL);
}
else
{
/* start this in an idle anyway and fire up the mainloop */
g_idle_add (prepare_screenshot_timeout, NULL);
}
gtk_main ();
return EXIT_SUCCESS;
}
int
main (int argc,
char *argv[])
{
GTestDBus *bus;
GError *error = NULL;
GOptionContext *context;
guint id = -1;
guint id_b = -1;
GOptionEntry entries[] = {
{ "tap", 0, 0, G_OPTION_ARG_NONE, &tap_mode, "Automatically run tests in terminal", NULL },
{ NULL }
};
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_type_init ();
g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR);
/* This is how tap-gtester runs us */
if (g_getenv ("HARNESS_ACTIVE"))
{
/* We don't run phantomjs under valgrind */
if (RUNNING_ON_VALGRIND)
{
g_print ("Bail out! - not running phantomjs under valgrind\n");
return 0;
}
tap_mode = TRUE;
}
/* This isolates us from affecting other processes during tests */
bus = g_test_dbus_new (G_TEST_DBUS_NONE);
g_test_dbus_up (bus);
context = g_option_context_new ("- test dbus json server");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("test-server: %s\n", error->message);
exit (2);
}
cd_srcdir (argv[0]);
/* Just execute the agent, no session necessary */
cockpit_ws_session_program = "./test-agent";
loop = g_main_loop_new (NULL, FALSE);
id = g_bus_own_name (G_BUS_TYPE_SESSION,
"com.redhat.Cockpit.DBusTests.Test",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE,
on_bus_acquired,
on_name_acquired,
on_name_lost,
loop,
NULL);
id_b = g_bus_own_name (G_BUS_TYPE_SESSION,
"com.redhat.Cockpit.DBusTests.Second",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE,
NULL,
on_second_acquired,
on_name_lost,
loop,
NULL);
g_main_loop_run (loop);
g_clear_object (&exported);
g_clear_object (&exported_b);
g_bus_unown_name (id);
g_bus_unown_name (id_b);
g_main_loop_unref (loop);
g_test_dbus_down (bus);
g_object_unref (bus);
return exit_code;
}
int
main(int argc, char **argv)
{
GOptionContext *context;
ClutterActor *stage;
GError *error = NULL;
CinnamonGlobal *global;
GjsContext *js_context;
char *script;
const char *filename;
char *title;
gsize len;
int code;
gtk_init (&argc, &argv);
clutter_x11_set_display (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
clutter_x11_disable_event_retrieval ();
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
gdk_window_add_filter (NULL, event_filter, NULL);
context = g_option_context_new (NULL);
/* pass unknown through to the JS script */
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_add_main_entries (context, entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
g_error ("option parsing failed: %s", error->message);
setlocale (LC_ALL, "");
_cinnamon_global_init (NULL);
global = cinnamon_global_get ();
js_context = _cinnamon_global_get_gjs_context (global);
/* prepare command line arguments */
if (!gjs_context_define_string_array (js_context, "ARGV",
argc - 2, (const char**)argv + 2,
&error)) {
g_printerr ("Failed to defined ARGV: %s", error->message);
exit (1);
}
if (command != NULL) {
script = command;
len = strlen (script);
filename = "<command line>";
} else if (argc <= 1) {
script = g_strdup ("const Console = imports.console; Console.interact();");
len = strlen (script);
filename = "<stdin>";
} else /*if (argc >= 2)*/ {
error = NULL;
if (!g_file_get_contents (argv[1], &script, &len, &error)) {
g_printerr ("%s\n", error->message);
exit (1);
}
filename = argv[1];
}
stage = clutter_stage_get_default ();
title = g_filename_display_basename (filename);
clutter_stage_set_title (CLUTTER_STAGE (stage), title);
g_free (title);
#if HAVE_BLUETOOTH
/* The module imports are all so intertwined that if the test
* imports anything in js/ui, it will probably eventually end up
* pulling in ui/status/bluetooth.js. So we need this.
*/
g_irepository_prepend_search_path (BLUETOOTH_DIR);
#endif
/* evaluate the script */
error = NULL;
if (!gjs_context_eval (js_context, script, len,
filename, &code, &error)) {
g_free (script);
g_printerr ("%s\n", error->message);
exit (1);
}
g_free (script);
exit (code);
}
int
main (int argc, char *argv[])
{
GError* error = NULL;
GOptionContext *context;
GOptionGroup* groupMain;
GOptionGroup* groupSearch;
GOptionGroup* groupPoll;
g_type_init();
context = g_option_context_new("\nArchive, Download, Parse, and render NEXRAD data");
groupMain = g_option_group_new("Main", "", "", NULL, NULL);
g_option_group_add_entries(groupMain, entriesMain);
g_option_context_add_group(context, groupMain);
g_option_context_set_ignore_unknown_options(context, TRUE);
if (!g_option_context_parse(context, &argc, &argv, &error))
{
g_error("Failed to parse cli options (phase 1): %s", error->message);
return 1;
}
if (!chrOp)
{
g_error("Operation required");
return 1;
}
g_option_context_set_ignore_unknown_options(context, FALSE);
groupSearch = g_option_group_new("Search", "Search through archived data", "Search through archived data", NULL, NULL);
g_option_group_add_entries(groupSearch, entriesSearch);
groupPoll = g_option_group_new("Poll", "Poll data from darxend", "Continually polls for data, archiving it in the process", NULL, NULL);
g_option_group_add_entries(groupPoll, entriesPoll);
if (!strcasecmp(chrOp, "search"))
{
g_option_context_add_group(context, groupSearch);
}
else if (!strcasecmp(chrOp, "poll"))
{
g_option_context_add_group(context, groupPoll);
}
// else if (!strcasecmp(chrOp, "render"))
// {
//
// }
// else if (!strcasecmp(chrOp, "disp"))
// {
//
// }
else
{
printf("Invalid operation: %s\n", chrOp);
}
if (!g_option_context_parse(context, &argc, &argv, &error))
{
g_error("Failed to parse cli options(phase 2): %s", error->message);
return 1;
}
int res;
if (!strcasecmp(chrOp, "search"))
{
res = main_search();
}
else if (!strcasecmp(chrOp, "poll"))
{
res = main_poll();
}
// else if (!strcasecmp(chrOp, "render"))
// {
//
// }
// else if (!strcasecmp(chrOp, "disp"))
// {
//
// }
//g_option_context_add_main_entries(context, entries, NULL);
//g_option_context_set_ignore_unknown_options(context, TRUE);
g_option_group_free(groupSearch);
g_option_group_free(groupPoll);
g_option_context_free(context);
return res;
}
/* Parse the argv array with GOptionContext, using the given argument
* definitions, and return a command context structure containing
* argument values.
* Note: The lib doesn't like argv starting with a flag, so keep a
* token before that to avoid problems.
*
* The passed argv should be an array of length argc+1. (So that a terminating
* NULL-pointer can be added in argv[argc].)
*/
static command_context_t *
init_context_from_args (argument_t *argdefs, gint argc, gchar **argv)
{
command_context_t *ctx;
GOptionContext *context;
GError *error = NULL;
gint i;
ctx = command_context_init (argc, argv);
for (i = 0; argdefs && argdefs[i].long_name; ++i) {
command_argument_t *arg = g_new (command_argument_t, 1);
switch (argdefs[i].arg) {
case G_OPTION_ARG_NONE:
arg->type = COMMAND_ARGUMENT_TYPE_BOOLEAN;
arg->value.vbool = FALSE;
argdefs[i].arg_data = &arg->value.vbool;
break;
case G_OPTION_ARG_INT:
arg->type = COMMAND_ARGUMENT_TYPE_INT;
arg->value.vint = -1;
argdefs[i].arg_data = &arg->value.vint;
break;
case G_OPTION_ARG_STRING:
arg->type = COMMAND_ARGUMENT_TYPE_STRING;
arg->value.vstring = NULL;
argdefs[i].arg_data = &arg->value.vstring;
break;
case G_OPTION_ARG_STRING_ARRAY:
arg->type = COMMAND_ARGUMENT_TYPE_STRING_ARRAY;
arg->value.vstringv = NULL;
argdefs[i].arg_data = &arg->value.vstringv;
break;
default:
g_printf (_("Trying to register a flag '%s' of invalid type!"),
argdefs[i].long_name);
break;
}
g_hash_table_insert (ctx->flags,
g_strdup (argdefs[i].long_name), arg);
}
context = g_option_context_new (NULL);
g_option_context_set_help_enabled (context, FALSE); /* runs exit(0)! */
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_add_main_entries (context, argdefs, NULL);
g_option_context_parse (context, &ctx->argc, &ctx->argv, &error);
g_option_context_free (context);
if (error) {
g_printf (_("Error: %s\n"), error->message);
g_error_free (error);
command_context_free (ctx);
return NULL;
}
/* strip --, check for unknown options before it */
/* FIXME: We do not parse options elsewhere, do we? */
for (i = 0; i < ctx->argc; i++) {
if (strcmp (ctx->argv[i], "--") == 0) {
break;
}
if (ctx->argv[i][0] == '-' && ctx->argv[i][1] != '\0' &&
!(ctx->argv[i][1] >= '0' && ctx->argv[i][1] <= '9')) {
g_printf (_("Error: Unknown option '%s'\n"), ctx->argv[i]);
command_context_free (ctx);
return NULL;
}
}
if (i != ctx->argc) {
for (i++; i < ctx->argc; i++) {
argv[i-1] = argv[i];
}
ctx->argc--;
}
/* Some functions rely on NULL-termination. */
ctx->argv[ctx->argc] = NULL;
return ctx;
}
// main function
int main(int argc, char *argv[])
{
gboolean show_version = FALSE;
gboolean log_info = FALSE;
gboolean log_debug = FALSE;
gboolean no_daemon = FALSE;
gboolean test_mode = FALSE;
gint poll_interval = -1;
gboolean success;
GOptionContext *opt_ctx;
thd_daemonize = TRUE;
dbus_enable = FALSE;
GOptionEntry options[] =
{
{
"version", 0, 0, G_OPTION_ARG_NONE, &show_version, N_(
"Print thermald version and exit"), NULL
}
,
{
"no-daemon", 0, 0, G_OPTION_ARG_NONE, &no_daemon, N_(
"Don't become a daemon: Default is daemon mode"), NULL
}
,
{
"loglevel=info", 0, 0, G_OPTION_ARG_NONE, &log_info, N_(
"log severity: info level and up"), NULL
}
,
{
"loglevel=debug", 0, 0, G_OPTION_ARG_NONE, &log_debug, N_(
"log severity: debug level and up: Max logging"), NULL
}
,
{
"test-mode", 0, 0, G_OPTION_ARG_NONE, &test_mode, N_(
"Test Mode only: Allow non root user"), NULL
}
,
{
"poll-interval", 0, 0, G_OPTION_ARG_INT, &poll_interval, N_(
"Poll interval in seconds: Poll for zone temperature changes. "
"If want to disable polling set to zero."), NULL
}
,
{
"dbus-enable", 0, 0, G_OPTION_ARG_NONE, &dbus_enable, N_(
"Enable Dbus."), NULL
}
,
{
"use-thermal-sysfs", 0, 0, G_OPTION_ARG_NONE, &use_thermal_sys_fs, N_(
"Use thermal sysfs instead of DTS sensors, default use dts."), NULL
}
,
{
NULL
}
};
if(!g_module_supported())
{
fprintf(stderr, _("GModules are not supported on your platform!\n"));
exit(1);
}
/* Set locale to be able to use environment variables */
setlocale(LC_ALL, "");
bindtextdomain(GETTEXT_PACKAGE, TDLOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
/* Parse options */
opt_ctx = g_option_context_new(NULL);
g_option_context_set_translation_domain(opt_ctx, GETTEXT_PACKAGE);
g_option_context_set_ignore_unknown_options(opt_ctx, FALSE);
g_option_context_set_help_enabled(opt_ctx, TRUE);
g_option_context_add_main_entries(opt_ctx, options, NULL);
g_option_context_set_summary(opt_ctx, _(
"Thermal daemon monitors temperature sensors and decides the best action "
"based on the temperature readings and user preferences."));
success = g_option_context_parse(opt_ctx, &argc, &argv, NULL);
g_option_context_free(opt_ctx);
if(!success)
{
fprintf(stderr, _(
"Invalid option. Please use --help to see a list of valid options.\n"));
exit(1);
}
if(show_version)
{
fprintf(stdout, TD_DIST_VERSION "\n");
exit(0);
}
if(getuid() != 0 && !test_mode)
{
fprintf(stderr, _("You must be root to run thermald!\n"));
exit(1);
}
if(g_mkdir_with_parents(TDRUNDIR, 0755) != 0)
{
fprintf(stderr, "Cannot create '%s': %s", TDRUNDIR, strerror(errno));
exit(1);
}
g_mkdir_with_parents(TDCONFDIR, 0755); // Don't care return value as directory
// may already exist
if(log_info)
{
thd_log_level |= G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO;
}
if(log_debug)
{
thd_log_level |= G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG;
}
if(poll_interval >= 0)
{
fprintf(stdout, "Polling enabled: %d\n", poll_interval);
thd_poll_interval = poll_interval;
}
openlog("thermald", LOG_PID, LOG_USER | LOG_DAEMON | LOG_SYSLOG);
// Don't care return val
//setlogmask(LOG_CRIT | LOG_ERR | LOG_WARNING | LOG_NOTICE | LOG_DEBUG | LOG_INFO);
thd_daemonize = !no_daemon;
g_log_set_handler(NULL, G_LOG_LEVEL_MASK, thd_logger, NULL);
if(no_daemon)
signal(SIGINT, sig_int_handler);
// dbus glib processing begin
thd_dbus_server_proc(no_daemon);
fprintf(stdout, "Exiting ..\n");
closelog();
exit(success ? 0 : 1);
}
void tool_init(gint* ac, gchar*** av, const gchar* tool_name, GOptionEntry* tool_entries)
{
GError *local_err = NULL;
init();
opt_context = g_option_context_new(tool_name);
if (tool_allow_unknown_options)
g_option_context_set_ignore_unknown_options(opt_context, TRUE);
if (tool_entries)
g_option_context_add_main_entries(opt_context, tool_entries, NULL);
g_option_context_add_main_entries(opt_context, auth_options, NULL);
g_option_context_add_main_entries(opt_context, basic_options, NULL);
if (!g_option_context_parse(opt_context, ac, av, &local_err))
{
g_printerr("ERROR: Option parsing failed: %s\n", local_err->message);
g_clear_error(&local_err);
exit(1);
}
print_version();
// load username/password from ini file
if (!opt_no_config || opt_config)
{
gboolean status;
gc_key_file_unref GKeyFile* kf = g_key_file_new();
if (opt_config)
status = g_key_file_load_from_file(kf, opt_config, 0, NULL);
else
{
status = g_key_file_load_from_file(kf, MEGA_RC_FILENAME, 0, NULL);
if (!status)
{
gc_free gchar* tmp = g_build_filename(g_get_home_dir(), MEGA_RC_FILENAME, NULL);
status = g_key_file_load_from_file(kf, tmp, 0, NULL);
}
}
if (status)
{
if (!opt_username)
opt_username = g_key_file_get_string(kf, "Login", "Username", NULL);
if(!opt_password)
opt_password = g_key_file_get_string(kf, "Login", "Password", NULL);
gint to = g_key_file_get_integer(kf, "Cache", "Timeout", &local_err);
if (local_err == NULL)
opt_cache_timout = to;
else
g_clear_error(&local_err);
}
}
if (!opt_username)
{
g_printerr("ERROR: You must specify your mega.nz username (email)\n");
exit(1);
}
if (!opt_password && opt_no_ask_password)
{
g_printerr("ERROR: You must specify your mega.nz password\n");
exit(1);
}
if (!opt_password)
opt_password = input_password();
}
int
main (int argc,
char *argv[])
{
const gchar *command = NULL;
GOptionContext *context;
RealmClient *client;
GError *error = NULL;
gint ret;
gint i;
setlocale (LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init ();
#endif
/* Parse the global options, don't display help or failure here */
context = g_option_context_new ("realm");
g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
g_option_context_add_main_entries (context, realm_global_options, NULL);
g_option_context_set_help_enabled (context, FALSE);
g_option_context_set_ignore_unknown_options (context, TRUE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_warning ("Unexpected error: %s", error->message);
g_error_free (error);
}
g_option_context_free (context);
/* Find/remove the first non-flag argument: the command */
for (i = 1; i < argc; i++) {
if (command == NULL) {
if (argv[i][0] != '-') {
command = argv[i];
argc--;
}
}
if (command != NULL)
argv[i] = argv[i + 1];
}
if (command == NULL)
return usage (2);
ret = 2;
for (i = 0; i < G_N_ELEMENTS (realm_commands); i++) {
if (g_str_equal (realm_commands[i].name, command)) {
client = realm_client_new (realm_verbose, arg_install);
if (!client) {
ret = 1;
break;
}
ret = (realm_commands[i].function) (client, argc, argv);
g_object_unref (client);
break;
}
}
if (ret == 2 && i == G_N_ELEMENTS (realm_commands))
usage(2);
g_free (realm_operation_id);
g_free (arg_install);
return ret;
}
static void cmdline_handler(int argc, char **argv)
{
gboolean help = FALSE, version = FALSE;
gchar *confpath = NULL, *certpath = NULL, *keypath = NULL, *mount = NULL,
*handlerextra = NULL;
char *cmdarg = NULL;
GOptionContext *context = NULL;
GOptionEntry entries[] = {
{"conf", 'c', 0, G_OPTION_ARG_FILENAME, &confpath, "config file", "FILENAME"},
{"cert", '\0', 0, G_OPTION_ARG_FILENAME, &certpath, "cert file", "PEMFILE"},
{"key", '\0', 0, G_OPTION_ARG_FILENAME, &keypath, "key file", "PEMFILE"},
{"mount", '\0', 0, G_OPTION_ARG_FILENAME, &mount, "mount prefix", "PATH"},
{"handler-args", '\0', 0, G_OPTION_ARG_STRING, &handlerextra, "extra handler arguments", "ARGS"},
{"version", '\0', 0, G_OPTION_ARG_NONE, &version, "display version", NULL},
{"help", 'h', 0, G_OPTION_ARG_NONE, &help, NULL, NULL},
{0}
};
GOptionGroup *info_group = g_option_group_new("info", "Info options:", "help dummy", NULL, NULL);
GError *error = NULL;
gchar *text;
RaucCommand rcommands[] = {
{UNKNOWN, "help", "<COMMAND>", unknown_start, NULL, TRUE},
{INSTALL, "install", "install <BUNDLE>", install_start, NULL, FALSE},
{BUNDLE, "bundle", "bundle <FILE>", bundle_start, NULL, FALSE},
{CHECKSUM, "checksum", "checksum <DIRECTORY>", checksum_start, NULL, FALSE},
{INFO, "info", "info <FILE>", info_start, info_group, FALSE},
{STATUS, "status", "status", status_start, NULL, TRUE},
#if ENABLE_SERVICE == 1
{SERVICE, "service", "service", service_start, NULL, TRUE},
#endif
{0}
};
RaucCommand *rc;
RaucCommand *rcommand = NULL;
g_option_group_add_entries(info_group, entries_info);
context = g_option_context_new("<COMMAND>");
g_option_context_set_help_enabled(context, FALSE);
g_option_context_set_ignore_unknown_options(context, TRUE);
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_description(context,
"List of rauc commands:\n" \
" bundle\tCreate a bundle\n" \
" checksum\tUpdate a manifest with checksums (and optionally sign it)\n" \
" resign\tResign a bundle\n" \
" install\tInstall a bundle\n" \
" info\t\tShow file information\n" \
" status\tShow status");
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_printerr("%s\n", error->message);
g_error_free(error);
r_exit_status = 1;
goto done;
}
/* get first parameter wihtout dashes */
for (gint i = 1; i <= argc; i++) {
if (argv[i] && !g_str_has_prefix (argv[i], "-")) {
cmdarg = argv[i];
break;
}
}
if (cmdarg == NULL) {
if (version) {
g_print(PACKAGE_STRING"\n");
goto done;
}
/* NO COMMAND given */
if (!help) {
r_exit_status = 1;
}
goto print_help;
}
/* try to get known command */
rc = rcommands;
while (rc->name) {
if (g_strcmp0(rc->name, cmdarg) == 0) {
rcommand = rc;
break;
}
rc++;
}
if (rcommand == NULL) {
/* INVALID COMMAND given */
g_message("Invalid command '%s' given\n", cmdarg);
r_exit_status = 1;
goto print_help;
}
/* re-setup option context for showing command-specific help */
g_clear_pointer(&context, g_option_context_free);
context = g_option_context_new(rcommand->usage);
g_option_context_set_help_enabled(context, FALSE);
g_option_context_add_main_entries(context, entries, NULL);
if (rcommand->options)
g_option_context_add_group(context, rcommand->options);
/* parse command-specific options */
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_printerr("%s\n", error->message);
g_error_free(error);
r_exit_status = 1;
goto print_help;
}
if (help) {
goto print_help;
}
/* configuration updates are handled here */
if (!r_context_get_busy()) {
r_context_conf();
if (confpath)
r_context_conf()->configpath = confpath;
if (certpath)
r_context_conf()->certpath = certpath;
if (keypath)
r_context_conf()->keypath = keypath;
if (mount)
r_context_conf()->mountprefix = mount;
if (handlerextra)
r_context_conf()->handlerextra = handlerextra;
} else {
if (confpath != NULL ||
certpath != NULL ||
keypath != NULL) {
g_error("rauc busy, cannot reconfigure");
r_exit_status = 1;
goto done;
}
}
if (r_context_get_busy() && !rcommand->while_busy) {
g_error("rauc busy: cannot run %s", rcommand->name);
r_exit_status = 1;
goto done;
}
/* real commands are handled here */
if (rcommand->cmd_handler) {
rcommand->cmd_handler(argc, argv);
}
goto done;
print_help:
text = g_option_context_get_help(context, FALSE, NULL);
g_print("%s", text);
g_free(text);
done:
g_clear_pointer(&context, g_option_context_free);;
}
