int
main (int argc, char **argv)
{
g_test_init (&argc, &argv, NULL);
/* only critical and error are fatal */
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
/* log everything */
g_setenv ("G_MESSAGES_DEBUG", "all", FALSE);
/* tests go here */
g_test_add_func ("/wac/firmware{parse}", fu_wac_firmware_parse_func);
return g_test_run ();
}
int
main(int argc, char *argv[])
{
g_test_init(&argc, &argv, NULL);
g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
g_log_set_fatal_mask ("LunaService", G_LOG_LEVEL_ERROR);
g_test_add_func("/luna-service2/g_timer_source_new", test_timer_source_new);
g_test_add_func("/luna-service2/g_timer_source_new_seconds", test_timer_source_new_seconds);
g_test_add_func("/luna-service2/g_timer_source_set_interval", test_timer_source_set_interval);
g_test_add_func("/luna-service2/g_timer_source_set_interval_seconds", test_timer_source_set_interval_seconds);
return g_test_run();
}
/**
* pk_debug_add_log_domain:
*/
void
pk_debug_add_log_domain (const gchar *log_domain)
{
if (_verbose) {
g_log_set_fatal_mask (log_domain, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler (log_domain,
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
pk_debug_handler_cb, NULL);
} else {
/* hide all debugging */
g_log_set_handler (log_domain,
G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_WARNING,
pk_debug_ignore_cb, NULL);
}
}
int main (int argc,char *argv[])
{
#ifdef SYMBIAN
g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
g_set_print_handler(mrtPrintHandler);
#endif /*SYMBIAN*/
printf("The following test case will abort\n when u press the enter key\n");
printf("If you see any other message after \nthis message, consider the test\ncase as failed\n");
getchar();
g_log_set_fatal_mask(NULL,G_LOG_LEVEL_MESSAGE);
g_log(NULL,G_LOG_LEVEL_MESSAGE,"test message");
g_print("log_manual1 failed");
getchar();
}
/**
* cd_debug_setup:
*/
void
cd_debug_setup (gboolean enabled)
{
if (enabled) {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL);
g_log_set_handler (G_LOG_DOMAIN,
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
cd_debug_handler_cb, NULL);
} else {
/* hide all debugging */
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
cd_debug_ignore_cb, NULL);
}
#ifdef HAVE_SYSLOG_H
openlog ("colord", LOG_CONS, LOG_DAEMON);
#endif
/* are we on an actual TTY? */
_console = (isatty (fileno (stdout)) == 1);
}
int
main (int arg,
char *argv[])
{
GModule *module_self, *module_a, *module_b;
gchar *string;
gchar *plugin_a, *plugin_b;
SimpleFunc f_a, f_b, f_self;
GModuleFunc gmod_f;
string = g_get_current_dir ();
g_print ("testgmodule (%s):\n", string);
#if (G_MODULE_IMPL == G_MODULE_IMPL_WIN32)
plugin_a = g_strconcat (string, "\\libgplugin_a.dll", NULL);
plugin_b = g_strconcat (string, "\\libgplugin_b.dll", NULL);
#elif (G_MODULE_IMPL == G_MODULE_IMPL_DLD)
plugin_a = g_strconcat (string, "/.libs/", "libgplugin_a.sl", NULL);
plugin_b = g_strconcat (string, "/.libs/", "libgplugin_b.sl", NULL);
#else /* neither DLD nor WIN32 */
plugin_a = g_strconcat (string, "/.libs/", "libgplugin_a.so", NULL);
plugin_b = g_strconcat (string, "/.libs/", "libgplugin_b.so", NULL);
#endif
g_free (string);
/* module handles
*/
g_print ("get main module handle\n");
module_self = g_module_open (NULL, G_MODULE_BIND_LAZY);
if (!module_self)
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("check that not yet bound symbols in shared libraries of main module are retrievable:\n");
string = "g_module_close";
g_print ("retrive symbol `%s' from \"%s\":\n", string, g_basename (g_module_name (module_self)));
if (!g_module_symbol (module_self, string, (gpointer) &f_self))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("retrived symbol `%s' as %p\n", string, f_self);
g_print ("load plugin from \"%s\"\n", plugin_a);
module_a = g_module_open (plugin_a, G_MODULE_BIND_LAZY);
if (!module_a)
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("load plugin from \"%s\"\n", plugin_b);
module_b = g_module_open (plugin_b, G_MODULE_BIND_LAZY);
if (!module_b)
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
/* get plugin specific symbols and call them
*/
string = "gplugin_a_func";
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_a)));
if (!g_module_symbol (module_a, string, (gpointer) &f_a))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
string = "gplugin_b_func";
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_b)));
if (!g_module_symbol (module_b, string, (gpointer) &f_b))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("call plugin function(%p) A: ", f_a);
f_a ();
g_print ("call plugin function(%p) B: ", f_b);
f_b ();
/* get and call globally clashing functions
*/
string = "g_clash_func";
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_self)));
if (!g_module_symbol (module_self, string, (gpointer) &f_self))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_a)));
if (!g_module_symbol (module_a, string, (gpointer) &f_a))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_b)));
if (!g_module_symbol (module_b, string, (gpointer) &f_b))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("call plugin function(%p) self: ", f_self);
f_self ();
g_print ("call plugin function(%p) A: ", f_a);
f_a ();
g_print ("call plugin function(%p) B: ", f_b);
f_b ();
/* get and call clashing plugin functions
*/
string = "gplugin_clash_func";
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_self)));
if (!g_module_symbol (module_self, string, (gpointer) &f_self))
f_self = NULL;
g_print ("retrived function `%s' from self: %p\n", string, f_self);
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_a)));
if (!g_module_symbol (module_a, string, (gpointer) &f_a))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_b)));
if (!g_module_symbol (module_b, string, (gpointer) &f_b))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("call plugin function(%p) A: ", f_a);
plugin_clash_func = f_a;
plugin_clash_func ();
g_print ("call plugin function(%p) B: ", f_b);
plugin_clash_func = f_b;
plugin_clash_func ();
/* call gmodule function form A
*/
string = "gplugin_a_module_func";
g_print ("retrive symbol `%s' from \"%s\"\n", string, g_basename (g_module_name (module_a)));
if (!g_module_symbol (module_a, string, (gpointer) &gmod_f))
{
g_print ("error: %s\n", g_module_error ());
return 1;
}
g_print ("call plugin A's module function(%p):\n{\n", gmod_f);
gmod_f (module_b);
g_print ("}\n");
/* unload plugins
*/
g_print ("unload plugin A:\n");
if (!g_module_close (module_a))
g_print ("error: %s\n", g_module_error ());
g_print ("unload plugin B:\n");
if (!g_module_close (module_b))
g_print ("error: %s\n", g_module_error ());
#if 0
g_log_set_fatal_mask ("GModule", G_LOG_FATAL_MASK|G_LOG_LEVEL_WARNING);
g_module_symbol (0, 0, 0);
g_warning("jahooo");
g_on_error_query (".libs/testgmodule");
#endif
return 0;
}
void
jb_main (int argc,
char **argv,
const char *package,
const char *version,
const char *human_package,
const JBFeature **features,
int num_features)
{
setlocale(LC_ALL, "");
g_log_set_fatal_mask(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL);
g_type_init();
jb_topsrcdir = g_get_current_dir();
jb_set_log_file("build/jb.log");
jb_variable_init();
jb_compile_options = jb_compile_options_new("package");
jb_feature_set_list(features, num_features);
/* these flags are needed by the JB GOB2 build mechanism */
jb_compile_options_add_gob2flags(jb_compile_options, "--always-private-header --no-touch");
jb_variable_set_string("package", package);
jb_variable_set_string("version", version);
jb_variable_set_string("human-package", human_package);
jb_variable_add_string("cc",
"C compiler command",
jb_variable_group_compiler_options,
0,
"cc");
jb_variable_add_string("cflags",
"C compiler flags",
jb_variable_group_compiler_options,
0,
"-O2");
jb_variable_add_string("cppflags",
"C preprocessor flags",
jb_variable_group_compiler_options,
0,
NULL);
jb_variable_add_string("ldflags",
"C linker flags",
jb_variable_group_compiler_options,
0,
NULL);
jb_variable_add_string("libs",
"C -l flags",
jb_variable_group_compiler_options,
0,
NULL);
jb_variable_add_bool("cc-dependency-tracking",
"enable C compiler dependency tracking",
jb_variable_group_compiler_options,
0,
TRUE);
jb_variable_add_string("destdir",
"destination directory",
jb_variable_group_installation_options,
0,
NULL);
jb_variable_add_string("prefix",
"installation prefix",
jb_variable_group_installation_options,
0,
"/usr/local");
jb_variable_add_string("bindir",
"user executables directory",
jb_variable_group_installation_options,
0,
"$prefix/bin");
jb_variable_add_string("libdir",
"shared libraries directory",
jb_variable_group_installation_options,
0,
"$prefix/lib");
jb_variable_add_string("libexecdir",
"private executables directory",
jb_variable_group_installation_options,
0,
"$prefix/libexec");
jb_variable_add_string("datadir",
"read-only architecture-independent data directory",
jb_variable_group_installation_options,
0,
"$prefix/share");
jb_variable_add_string("sysconfdir",
"per-machine configuration directory",
jb_variable_group_installation_options,
0,
"$prefix/etc");
jb_variable_add_string("localstatedir",
"per-machine state directory",
jb_variable_group_installation_options,
0,
"$prefix/var");
jb_variable_set_string("pkglibdir", "$libdir/$package");
jb_variable_set_string("pkgdatadir", "$datadir/$package");
jb_variable_set_string("pkgsysconfdir", "$sysconfdir/$package");
jb_variable_add_mode("data-mode",
"data file permissions (octal)",
jb_variable_group_installation_options,
0,
0644);
jb_variable_add_string("data-owner",
"data file owner",
jb_variable_group_installation_options,
0,
NULL);
jb_variable_add_string("data-group",
"data file group",
jb_variable_group_installation_options,
0,
NULL);
jb_variable_add_mode("program-mode",
"program file permissions (octal)",
jb_variable_group_installation_options,
0,
0755);
jb_variable_add_string("program-owner",
"program file owner",
jb_variable_group_installation_options,
0,
NULL);
jb_variable_add_string("program-group",
"program file group",
jb_variable_group_installation_options,
0,
NULL);
jb_variable_add_mode("library-mode",
"library file permissions (octal)",
jb_variable_group_installation_options,
0,
0644);
jb_variable_add_string("library-owner",
"library file owner",
jb_variable_group_installation_options,
0,
NULL);
jb_variable_add_string("library-group",
"library file group",
jb_variable_group_installation_options,
0,
NULL);
jb_feature_init();
jb_package_init();
parse_args(argc, argv);
}
static void
test_LSHubPermissionMapLookup(void *fixture, gconstpointer user_data)
{
ConfigSetDefaults();
char const *dirs[] = { TEST_STEADY_ROLES_DIRECTORY, NULL };
LSError error;
LSErrorInit(&error);
g_assert(ProcessRoleDirectories(dirs, NULL, &error));
g_assert(!LSErrorIsSet(&error));
_LSTransportCred *cred = _LSTransportCredNew();
g_assert(cred);
pid_t pid = getpid();
_LSTransportCredSetPid(cred, pid);
struct LSTransportHandlers test_handlers = {};
_LSTransport *transport = NULL;
g_assert(_LSTransportInit(&transport, "com.webos.foo", &test_handlers, NULL));
_LSTransportSetTransportType(transport, _LSTransportTypeLocal);
g_assert(transport);
_LSTransportClient test_client =
{
.service_name = "com.webos.foo",
.cred = cred,
.transport = transport,
};
_LSTransportCredSetExePath(cred, "/bin/foo");
test_client.service_name = "com.webos.foo";
g_assert(LSHubIsClientAllowedToRequestName(&test_client, "com.webos.foo"));
LSHubActiveRoleMapUnref(pid);
g_assert(!LSHubIsClientAllowedToRequestName(&test_client, "com.webos.foo2"));
LSHubActiveRoleMapUnref(pid);
_LSTransportCredSetExePath(cred, "/bin/bar");
test_client.service_name = "com.webos.bar";
g_assert(LSHubIsClientAllowedToRequestName(&test_client, "com.webos.bar"));
LSHubActiveRoleMapUnref(pid);
g_assert(LSHubIsClientAllowedToRequestName(&test_client, "com.webos.bar2"));
LSHubActiveRoleMapUnref(pid);
_LSTransportCredSetExePath(cred, "/bin/foo");
test_client.service_name = "com.webos.foo";
g_assert(LSHubIsClientAllowedToQueryName(&test_client, "com.webos.bar", "asdf"));
_LSTransportCredSetExePath(cred, "/bin/bar");
test_client.service_name = "com.webos.bar";
g_assert(LSHubIsClientAllowedToQueryName(&test_client, "com.webos.foo", "asdf"));
_LSTransportCredSetExePath(cred, "/bin/bar");
test_client.service_name = "com.webos.bar2";
g_assert(LSHubIsClientAllowedToQueryName(&test_client, "com.webos.foo", "asdf"));
_LSTransportDeinit(transport);
_LSTransportCredFree(cred);
_ConfigFreeSettings();
}
int
main(int argc, char *argv[])
{
g_test_init(&argc, &argv, NULL);
g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
g_log_set_fatal_mask ("LunaServiceHub", G_LOG_LEVEL_ERROR);
g_test_add("/hub/LSHubPermissionMapLookup", void, NULL, NULL, test_LSHubPermissionMapLookup, NULL);
return g_test_run();
}
int
main (int argc, char **argv)
{
GError *error = NULL;
gint ret = 1;
GOptionContext *opt_context = NULL;
guint name_owner_id = 0;
guint sigint_id = 0;
gboolean verbose = FALSE;
GOptionEntry opt_entries[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
_("Show extra debugging information"), NULL },
{ "replace", 'r', 0, G_OPTION_ARG_NONE, &opt_replace,
"Replace existing daemon", NULL},
{ "no-sigint", 's', 0, G_OPTION_ARG_NONE, &opt_no_sigint,
"Do not handle SIGINT for controlled shutdown", NULL},
{ "session", 'S', 0, G_OPTION_ARG_NONE, &opt_session,
_("Use the session D-Bus (for testing)"), NULL},
{NULL }
};
#if !GLIB_CHECK_VERSION(2,36,0)
g_type_init ();
#endif /* glib < 2.36 */
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
if (!g_setenv ("GIO_USE_VFS", "local", TRUE)) {
g_printerr ("Error setting GIO_USE_GVFS\n");
goto out;
}
opt_context = g_option_context_new ("printer daemon");
g_option_context_add_main_entries (opt_context, opt_entries, NULL);
if (!g_option_context_parse (opt_context, &argc, &argv, &error)) {
g_printerr ("Error parsing options: %s\n", error->message);
g_error_free (error);
goto out;
}
/* verbose? */
if (verbose) {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("printerd",
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
pd_log_handler_cb, NULL);
} else {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("printerd", G_LOG_LEVEL_DEBUG,
pd_log_ignore_cb, NULL);
}
loop = g_main_loop_new (NULL, FALSE);
if (!opt_no_sigint) {
sigint_id = g_unix_signal_add_full (G_PRIORITY_DEFAULT,
SIGINT,
on_sigint,
NULL, /* user_data */
NULL); /* GDestroyNotify */
}
name_owner_id = g_bus_own_name (opt_session ?
G_BUS_TYPE_SESSION : G_BUS_TYPE_SYSTEM,
"org.freedesktop.printerd",
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
(opt_replace ? G_BUS_NAME_OWNER_FLAGS_REPLACE : 0),
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL,
NULL);
g_debug ("Entering main event loop");
g_main_loop_run (loop);
/* success */
ret = 0;
out:
if (sigint_id > 0)
g_source_remove (sigint_id);
if (the_daemon != NULL)
g_object_unref (the_daemon);
if (name_owner_id != 0)
g_bus_unown_name (name_owner_id);
if (loop != NULL)
g_main_loop_unref (loop);
if (opt_context != NULL)
g_option_context_free (opt_context);
g_debug ("printerd daemon version %s exiting", PACKAGE_VERSION);
return ret;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
AsAppValidateFlags validate_flags = 0;
gboolean nonet = FALSE;
gboolean relax = FALSE;
gboolean ret;
gboolean strict = FALSE;
gboolean verbose = FALSE;
gboolean version = FALSE;
gchar *filename = NULL;
gchar *output_format = NULL;
GError *error = NULL;
gint i;
gint retval = EXIT_CODE_SUCCESS;
gint retval_tmp;
GOptionContext *context;
const GOptionEntry options[] = {
{ "relax", 'r', 0, G_OPTION_ARG_NONE, &relax,
/* TRANSLATORS: this is the --relax argument */
_("Be less strict when checking files"), NULL },
{ "strict", 's', 0, G_OPTION_ARG_NONE, &strict,
/* TRANSLATORS: this is the --relax argument */
_("Be more strict when checking files"), NULL },
{ "nonet", '\0', 0, G_OPTION_ARG_NONE, &nonet,
/* TRANSLATORS: this is the --nonet argument */
_("Do not use network access"), NULL },
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
/* TRANSLATORS: this is the --verbose argument */
_("Show extra debugging information"), NULL },
{ "version", '\0', 0, G_OPTION_ARG_NONE, &version,
/* TRANSLATORS: this is the --version argument */
_("Show the version number and then quit"), NULL },
{ "filename", '\0', 0, G_OPTION_ARG_STRING, &filename,
/* TRANSLATORS: this is the --filename argument */
_("The source filename when using a temporary file"), NULL },
{ "output-format", '\0', 0, G_OPTION_ARG_STRING, &output_format,
/* TRANSLATORS: this is the --output-format argument */
_("The output format [text|html|xml]"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#if !GLIB_CHECK_VERSION(2,36,0)
g_type_init ();
#endif
context = g_option_context_new ("AppData Validation Program");
g_option_context_add_main_entries (context, options, NULL);
ret = g_option_context_parse (context, &argc, &argv, &error);
if (!ret) {
/* TRANSLATORS: this is where the user used unknown command
* line switches -- the exact error follows */
g_print ("%s %s\n", _("Failed to parse command line:"), error->message);
g_error_free (error);
goto out;
}
/* big fat warning */
g_print ("THIS TOOL IS *DEPRECATED* AND WILL BE REMOVED SOON.\n");
g_print ("Please use 'apstream-util validate' in appstream-glib.\n\n");
/* just show the version */
if (version) {
g_print ("%s\n", PACKAGE_VERSION);
goto out;
}
/* verbose? */
if (verbose) {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("AppDataTools",
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
appdata_validate_log_handler_cb, NULL);
} else {
/* hide all debugging */
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("AppDataTools",
G_LOG_LEVEL_DEBUG,
appdata_validate_log_ignore_cb, NULL);
}
if (argc < 2) {
retval = EXIT_CODE_USAGE;
/* TRANSLATORS: this is explaining how to use the tool */
g_print ("%s %s %s\n", _("Usage:"), argv[0], _("<file>"));
goto out;
}
/* make more strict or relaxed */
if (strict)
validate_flags |= AS_APP_VALIDATE_FLAG_STRICT;
else if (relax)
validate_flags |= AS_APP_VALIDATE_FLAG_RELAX;
/* the user has forced no network mode */
if (nonet)
validate_flags |= AS_APP_VALIDATE_FLAG_NO_NETWORK;
/* validate each file */
for (i = 1; i < argc; i++) {
retval_tmp = appdata_validate_and_show_results (filename,
argv[i],
output_format,
validate_flags);
if (retval_tmp != EXIT_CODE_SUCCESS)
retval = retval_tmp;
}
out:
g_free (filename);
g_free (output_format);
g_option_context_free (context);
return retval;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
gboolean ret;
gboolean verbose = FALSE;
gchar *cmd_descriptions = NULL;
gchar *options_help = NULL;
GError *error = NULL;
gint retval = 0;
GUsbCmdPrivate *priv;
const GOptionEntry options[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"Show extra debugging information", NULL },
{ NULL}
};
setlocale (LC_ALL, "");
/* create helper object */
priv = g_slice_new0 (GUsbCmdPrivate);
priv->context = g_option_context_new ("GUSB Console Program");
g_option_context_add_main_entries (priv->context, options, NULL);
g_option_context_parse (priv->context, &argc, &argv, NULL);
/* verbose? */
if (verbose) {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("GUsb", G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
gusb_log_handler_cb, NULL);
} else {
/* hide all debugging */
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("GUsb", G_LOG_LEVEL_DEBUG,
gusb_log_ignore_cb, NULL);
}
/* GUsbContext */
priv->usb_ctx = g_usb_context_new (NULL);
g_usb_context_set_flags (priv->usb_ctx, G_USB_CONTEXT_FLAGS_AUTO_OPEN_DEVICES);
/* add commands */
priv->cmd_array = g_ptr_array_new_with_free_func ((GDestroyNotify) gusb_cmd_item_free);
gusb_cmd_add (priv->cmd_array,
"show",
"Show currently connected devices",
gusb_cmd_show);
gusb_cmd_add (priv->cmd_array,
"watch",
"Watch devices as they come and go",
gusb_cmd_watch);
gusb_cmd_add (priv->cmd_array,
"replug",
"Watch a device as it reconnects",
gusb_cmd_replug);
/* sort by command name */
g_ptr_array_sort (priv->cmd_array,
(GCompareFunc) gusb_sort_command_name_cb);
/* get a list of the commands */
cmd_descriptions = gusb_cmd_get_descriptions (priv->cmd_array);
g_option_context_set_summary (priv->context, cmd_descriptions);
/* nothing specified */
if (argc < 2) {
options_help = g_option_context_get_help (priv->context, TRUE, NULL);
g_print ("%s", options_help);
goto out;
}
/* run the specified command */
ret = gusb_cmd_run (priv, argv[1], (gchar**) &argv[2], &error);
if (!ret) {
g_print ("%s\n", error->message);
g_error_free (error);
retval = 1;
goto out;
}
out:
if (priv != NULL) {
if (priv->cmd_array != NULL)
g_ptr_array_unref (priv->cmd_array);
if (priv->usb_ctx != NULL)
g_object_unref (priv->usb_ctx);
g_option_context_free (priv->context);
g_slice_free (GUsbCmdPrivate, priv);
}
/* free state */
g_free (options_help);
g_free (cmd_descriptions);
return retval;
}
void
mono_init_virt ()
{
const char *error;
#ifndef MONO_AGENT
char * cfg_mono_root_path;
char * cfg_mono_cfg_dir;
char * cfg_mono_path;
char * cfg_mono_trace;
/*g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
g_log_set_fatal_mask (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR);*/
#ifndef VIRT_MINT
if (virtuoso_cfg_getstring ("Mono", "MONO_TRACE", &cfg_mono_trace) != -1)
mono_jit_trace_calls = strcmp (cfg_mono_trace, "On") ? FALSE : TRUE;
#endif
if (virtuoso_cfg_getstring ("Mono", "MONO_PATH", &cfg_mono_path) != -1)
setenv ("MONO_PATH", cfg_mono_path, 1);
if (virtuoso_cfg_getstring ("Mono", "MONO_ROOT", &cfg_mono_root_path) != -1)
setenv ("MONO_ROOT", cfg_mono_root_path, 1);
if (virtuoso_cfg_getstring ("Mono", "MONO_CFG_DIR", &cfg_mono_cfg_dir) != -1)
setenv ("MONO_CFG_DIR", cfg_mono_cfg_dir, 1);
if (virtuoso_cfg_getstring ("Mono", "virtclr.dll", &VIRTCLR_NAME) == -1)
VIRTCLR_NAME = "virtclr.dll";
#endif
#ifdef WIN32
/* mono initialization on win32 has to be done sooner than later */
#ifdef VIRT_MINT
virtuoso_domain = mono_interp_init ("virtuoso");
#else
virtuoso_domain = mono_jit_init ("virtuoso");
#endif
if (cfg_mono_root_path)
mono_assembly_setrootdir (cfg_mono_root_path);
#endif
#ifndef VIRT_MINT
mono_jit_trace_calls = FALSE;
#endif
{
char *path = getenv ("MONO_ROOT");
if (path)
mono_assembly_setrootdir (path);
}
/* mono_debug_init (1); */
#ifndef WIN32
setlocale(LC_ALL, "");
#endif
g_log_set_always_fatal (G_LOG_LEVEL_ERROR);
g_log_set_fatal_mask (G_LOG_DOMAIN, G_LOG_LEVEL_ERROR);
g_set_printerr_handler (dummy_print);
#ifndef WIN32
#ifdef VIRT_MINT
virtuoso_domain = mono_interp_init ("virtuoso");
#else
virtuoso_domain = mono_jit_init ("virtuoso");
#endif
mono_config_parse (NULL);
#ifdef OLD_KIT
if (NULL != (error = mono_verify_corlib ()))
#elif !defined (OLD_KIT_1_1_5)
if (NULL != (error = mono_check_corlib_version ()))
#endif
{
log_error ("Mono Corlib not in sync with this runtime: %s", error);
exit (-1);
}
#ifndef VIRT_MINT
#ifdef OLD_KIT_1_1_5
mono_thread_attach_aborted_cb = virt_mono_throw_unhandled_exception;
#else
mono_thread_set_attach_aborted_cb (virt_mono_throw_unhandled_exception);
#endif
#endif
#endif
mono_add_internal_call ("VInvoke::LoadAssemblyFromVirtuoso(string)", ves_icall_VInvoke_LoadAssemblyFromVirtuoso);
#ifndef MONO_AGENT
mono_set_port ();
#endif
#ifndef MONO_AGENT
#ifdef OLD_KIT_1_1_4
log_debug ("Mono config path [%s]", mono_cfg_dir);
#else
log_debug ("Mono config path [%s]", mono_get_config_dir ());
#endif
#endif
#ifndef WIN32
setlocale (LC_ALL, "C");
#endif
#ifndef OLD_KIT_1_1_5
mono_thread_manage ();
mono_thread_set_main (mono_thread_current());
#endif
}
/**
* Test program looping and reading LLDP/CDP packets and exercising most of the packet
* send/receive mechanism and a good bit of nanoprobe and CMA basic infrastructure.
*
* It plays both sides of the game - the CMA and the nanoprobe.
*
* It leaves most of the work of starting up the nanoprobe code to nano_start_full()
*/
int
main(int argc, char **argv)
{
const guint8 loopback[] = CONST_IPV6_LOOPBACK;
//const guint8 mcastaddrstring[] = CONST_ASSIM_DEFAULT_V4_MCAST;
//NetAddr* mcastaddr;
const guint8 otheradstring[] = {127,0,0,1};
const guint8 otheradstring2[] = {10,10,10,4};
const guint8 anyadstring[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
guint16 testport = TESTPORT;
SignFrame* signature = signframe_glib_new(G_CHECKSUM_SHA256, 0);
Listener* otherlistener;
ConfigContext* config = configcontext_new(0);
PacketDecoder* decoder = nano_packet_decoder();
AuthListener* listentonanoprobes;
ReliableUDP* rtransport;
#if 0
# ifdef HAVE_MCHECK_PEDANTIC
g_assert(mcheck_pedantic(NULL) == 0);
# else
# ifdef HAVE_MCHECK
g_assert(mcheck(NULL) == 0);
# endif
# endif
#endif
g_setenv("G_MESSAGES_DEBUG", "all", TRUE);
#if 0
proj_class_incr_debug(NULL);
proj_class_incr_debug(NULL);
proj_class_incr_debug(NULL);
proj_class_incr_debug(NULL);
#endif
g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR);
if (argc > 1) {
maxpkts = atol(argv[1]);
g_debug("Max packet count is "FMT_64BIT"d", maxpkts);
}
if (netio_is_dual_ipv4v6_stack()) {
g_message("Our OS supports dual ipv4/v6 sockets. Hurray!");
}else{
g_warning("Our OS DOES NOT support dual ipv4/v6 sockets - this may not work!!");
}
config->setframe(config, CONFIGNAME_OUTSIG, &signature->baseclass);
// Create a network transport object for normal UDP packets
rtransport = reliableudp_new(0, config, decoder, 0);
rtransport->_protocol->window_size = 8;
nettransport = &(rtransport->baseclass.baseclass);
g_return_val_if_fail(NULL != nettransport, 2);
// Set up the parameters the 'CMA' is going to send to our 'nanoprobe'
// in response to their request for configuration data.
nanoconfig = configcontext_new(0);
nanoconfig->setint(nanoconfig, CONFIGNAME_INTERVAL, 1);
nanoconfig->setint(nanoconfig, CONFIGNAME_TIMEOUT, 3);
nanoconfig->setint(nanoconfig, CONFIGNAME_CMAPORT, testport);
// Construct the NetAddr we'll talk to (i.e., ourselves) and listen from
destaddr = netaddr_ipv6_new(loopback, testport);
g_return_val_if_fail(NULL != destaddr, 3);
config->setaddr(config, CONFIGNAME_CMAINIT, destaddr);
nanoconfig->setaddr(nanoconfig, CONFIGNAME_CMAADDR, destaddr);
nanoconfig->setaddr(nanoconfig, CONFIGNAME_CMAFAIL, destaddr);
nanoconfig->setaddr(nanoconfig, CONFIGNAME_CMADISCOVER, destaddr);
// Construct another couple of NetAddrs to talk to and listen from
// for good measure...
otheraddr = netaddr_ipv4_new(otheradstring, testport);
g_return_val_if_fail(NULL != otheraddr, 4);
otheraddr2 = netaddr_ipv4_new(otheradstring2, testport);
g_return_val_if_fail(NULL != otheraddr2, 4);
// Construct another NetAddr to bind to (anything)
anyaddr = netaddr_ipv6_new(anyadstring, testport);
g_return_val_if_fail(NULL != destaddr, 5);
// Bind to ANY address (as noted above)
g_return_val_if_fail(nettransport->bindaddr(nettransport, anyaddr, FALSE),16);
//g_return_val_if_fail(nettransport->bindaddr(nettransport, destaddr),16);
g_message("NOT Joining multicast address.");
#if 0
// We can't do this because of encryption and we will likely screw up
// others on our network even if that weren't a problem...
mcastaddr = netaddr_ipv4_new(mcastaddrstring, testport);
g_return_val_if_fail(nettransport->mcastjoin(nettransport, mcastaddr, NULL), 17);
UNREF(mcastaddr);
g_message("multicast join succeeded.");
#endif
// Connect up our network transport into the g_main_loop paradigm
// so we get dispatched when packets arrive
netpkt = netgsource_new(nettransport, NULL, G_PRIORITY_HIGH, FALSE, NULL, 0, NULL);
// Set up so that we can observe all unclaimed packets
otherlistener = listener_new(config, 0);
otherlistener->got_frameset = gotnetpkt;
netpkt->addListener(netpkt, 0, otherlistener);
otherlistener->associate(otherlistener,netpkt);
// Unref the "other" listener - we hold other references to it
UNREF(otherlistener);
// Pretend to be the CMA...
// Listen for packets from our nanoprobes - scattered throughout space...
listentonanoprobes = authlistener_new(0, cmalist, config, TRUE, NULL);
listentonanoprobes->baseclass.associate(&listentonanoprobes->baseclass, netpkt);
nano_start_full("netconfig", 900, netpkt, config, test_cma_authentication);
g_timeout_add_seconds(1, timeout_agent, NULL);
mainloop = g_main_loop_new(g_main_context_default(), TRUE);
/********************************************************************
* Start up the main loop - run our test program...
* (the one pretending to be both the nanoprobe and the CMA)
********************************************************************/
g_main_loop_run(mainloop);
/********************************************************************
* We exited the main loop. Shut things down.
********************************************************************/
nano_shutdown(TRUE); // Tell it to shutdown and print stats
g_message("Count of 'other' pkts received:\t%d", wirepktcount);
UNREF(nettransport);
// Main loop is over - shut everything down, free everything...
g_main_loop_unref(mainloop); mainloop=NULL;
// Unlink misc dispatcher - this should NOT be necessary...
netpkt->addListener(netpkt, 0, NULL);
// Dissociate packet actions from the packet source.
listentonanoprobes->baseclass.dissociate(&listentonanoprobes->baseclass);
// Unref the AuthListener object
UNREF2(listentonanoprobes);
g_source_destroy(&netpkt->baseclass);
g_source_unref(&netpkt->baseclass);
//g_main_context_unref(g_main_context_default());
// Free signature frame
UNREF2(signature);
// Free misc addresses
UNREF(destaddr);
UNREF(otheraddr);
UNREF(otheraddr2);
UNREF(anyaddr);
// Free config object
UNREF(config);
UNREF(nanoconfig);
// At this point - nothing should show up - we should have freed everything
if (proj_class_live_object_count() > 0) {
g_warning("Too many objects (%d) alive at end of test.",
proj_class_live_object_count());
proj_class_dump_live_objects();
++errcount;
}else{
g_message("No objects left alive. Awesome!");
}
proj_class_finalize_sys(); // Shut down object system to make valgrind happy :-D
return(errcount <= 127 ? errcount : 127);
}
int
main (int argc, char **argv)
{
pid_t pid;
int i, fd, max_fd;
int pipefd[2];
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_CRITICAL | G_LOG_FATAL_MASK);
g_log_set_default_handler (simple_log_handler, NULL);
get_options (&argc, &argv);
if (pipe (&pipefd[0]) == -1) {
g_critical ("pipe: %s", g_strerror (errno));
}
g_message ("Log output will be stored in %s.", logfile);
pid = fork ();
if (pid) {
char t;
int res;
close (pipefd[1]);
for (;;) {
res = read (pipefd[0], &t, 1);
if (res != -1 || errno == EINTR)
break;
}
if (res == -1)
g_warning ("read: %s", g_strerror (errno));
if (res == 0) {
g_critical ("startup of xmms2d failed!");
}
g_message ("xmms2d started.");
exit(0);
}
/* Change stdin/out/err */
fd = open ("/dev/null", O_RDONLY);
dup2 (fd, STDIN_FILENO);
fd = open (logfile, O_WRONLY|O_CREAT|O_APPEND, 0644);
write(fd, startup_msg, sizeof (startup_msg) - 1);
dup2 (fd, STDOUT_FILENO);
dup2 (fd, STDERR_FILENO);
/* Close all unused file descriptors */
max_fd = sysconf (_SC_OPEN_MAX);
for (i = 3; i <= max_fd; i++) {
if (pipefd[1] != i)
close (i);
}
/* make us process group leader */
setsid ();
/* fork again to reparent to init */
pid = fork();
if (pid && pidfile) {
FILE *pfile = NULL;
pfile = g_fopen (pidfile, "w");
if (pfile) {
g_fprintf (pfile, "%d", (int) pid);
}
}
if (!pid) {
char *args[32];
char buf[32];
int i, j = 0;
args[j++] = (char *) BINDIR "/xmms2d";
snprintf (buf, 32, "--status-fd=%d", pipefd[1]);
args[j++] = buf;
for (i = 1; i < argc && j < 31; i++) {
args[j++] = argv[i];
}
args[j] = NULL;
execvp (args[0], args);
exit (1);
}
exit (0);
}
int main(int argc, char **argv)
{
const char *sopt = "hVvdm:p:l:f:b:s:t:";
const char *method = NULL, *path = NULL;
const char *log_filepath = NULL;
const char *pid_filepath = QGA_PIDFILE_DEFAULT;
const char *state_dir = QGA_STATEDIR_DEFAULT;
#ifdef _WIN32
const char *service = NULL;
#endif
const struct option lopt[] = {
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'V' },
{ "logfile", 1, NULL, 'l' },
{ "pidfile", 1, NULL, 'f' },
{ "verbose", 0, NULL, 'v' },
{ "method", 1, NULL, 'm' },
{ "path", 1, NULL, 'p' },
{ "daemonize", 0, NULL, 'd' },
{ "blacklist", 1, NULL, 'b' },
#ifdef _WIN32
{ "service", 1, NULL, 's' },
#endif
{ "statedir", 1, NULL, 't' },
{ NULL, 0, NULL, 0 }
};
int opt_ind = 0, ch, daemonize = 0, i, j, len;
GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
GList *blacklist = NULL;
GAState *s;
module_call_init(MODULE_INIT_QAPI);
while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
switch (ch) {
case 'm':
method = optarg;
break;
case 'p':
path = optarg;
break;
case 'l':
log_filepath = optarg;
break;
case 'f':
pid_filepath = optarg;
break;
case 't':
state_dir = optarg;
break;
case 'v':
/* enable all log levels */
log_level = G_LOG_LEVEL_MASK;
break;
case 'V':
printf("QEMU Guest Agent %s\n", QEMU_VERSION);
return 0;
case 'd':
daemonize = 1;
break;
case 'b': {
char **list_head, **list;
if (is_help_option(optarg)) {
list_head = list = qmp_get_command_list();
while (*list != NULL) {
printf("%s\n", *list);
g_free(*list);
list++;
}
g_free(list_head);
return 0;
}
for (j = 0, i = 0, len = strlen(optarg); i < len; i++) {
if (optarg[i] == ',') {
optarg[i] = 0;
blacklist = g_list_append(blacklist, &optarg[j]);
j = i + 1;
}
}
if (j < i) {
blacklist = g_list_append(blacklist, &optarg[j]);
}
break;
}
#ifdef _WIN32
case 's':
service = optarg;
if (strcmp(service, "install") == 0) {
return ga_install_service(path, log_filepath);
} else if (strcmp(service, "uninstall") == 0) {
return ga_uninstall_service();
} else {
printf("Unknown service command.\n");
return EXIT_FAILURE;
}
break;
#endif
case 'h':
usage(argv[0]);
return 0;
case '?':
g_print("Unknown option, try '%s --help' for more information.\n",
argv[0]);
return EXIT_FAILURE;
}
}
s = g_malloc0(sizeof(GAState));
s->log_level = log_level;
s->log_file = stderr;
g_log_set_default_handler(ga_log, s);
g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR);
ga_enable_logging(s);
s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen",
state_dir);
s->frozen = false;
#ifndef _WIN32
/* check if a previous instance of qemu-ga exited with filesystems' state
* marked as frozen. this could be a stale value (a non-qemu-ga process
* or reboot may have since unfrozen them), but better to require an
* uneeded unfreeze than to risk hanging on start-up
*/
struct stat st;
if (stat(s->state_filepath_isfrozen, &st) == -1) {
/* it's okay if the file doesn't exist, but if we can't access for
* some other reason, such as permissions, there's a configuration
* that needs to be addressed. so just bail now before we get into
* more trouble later
*/
if (errno != ENOENT) {
g_critical("unable to access state file at path %s: %s",
s->state_filepath_isfrozen, strerror(errno));
return EXIT_FAILURE;
}
} else {
g_warning("previous instance appears to have exited with frozen"
" filesystems. deferring logging/pidfile creation and"
" disabling non-fsfreeze-safe commands until"
" guest-fsfreeze-thaw is issued, or filesystems are"
" manually unfrozen and the file %s is removed",
s->state_filepath_isfrozen);
s->frozen = true;
}
#endif
if (ga_is_frozen(s)) {
if (daemonize) {
/* delay opening/locking of pidfile till filesystem are unfrozen */
s->deferred_options.pid_filepath = pid_filepath;
become_daemon(NULL);
}
if (log_filepath) {
/* delay opening the log file till filesystems are unfrozen */
s->deferred_options.log_filepath = log_filepath;
}
ga_disable_logging(s);
ga_disable_non_whitelisted();
} else {
if (daemonize) {
become_daemon(pid_filepath);
}
if (log_filepath) {
FILE *log_file = fopen(log_filepath, "a");
if (!log_file) {
g_critical("unable to open specified log file: %s",
strerror(errno));
goto out_bad;
}
s->log_file = log_file;
}
}
if (blacklist) {
s->blacklist = blacklist;
do {
g_debug("disabling command: %s", (char *)blacklist->data);
qmp_disable_command(blacklist->data);
blacklist = g_list_next(blacklist);
} while (blacklist);
}
s->command_state = ga_command_state_new();
ga_command_state_init(s, s->command_state);
ga_command_state_init_all(s->command_state);
json_message_parser_init(&s->parser, process_event);
ga_state = s;
#ifndef _WIN32
if (!register_signal_handlers()) {
g_critical("failed to register signal handlers");
goto out_bad;
}
#endif
s->main_loop = g_main_loop_new(NULL, false);
if (!channel_init(ga_state, method, path)) {
g_critical("failed to initialize guest agent channel");
goto out_bad;
}
#ifndef _WIN32
g_main_loop_run(ga_state->main_loop);
#else
if (daemonize) {
SERVICE_TABLE_ENTRY service_table[] = {
{ (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } };
StartServiceCtrlDispatcher(service_table);
} else {
g_main_loop_run(ga_state->main_loop);
}
#endif
ga_command_state_cleanup_all(ga_state->command_state);
ga_channel_free(ga_state->channel);
if (daemonize) {
unlink(pid_filepath);
}
return 0;
out_bad:
if (daemonize) {
unlink(pid_filepath);
}
return EXIT_FAILURE;
}
int
main (int argc, char **argv)
{
gboolean arg_version = FALSE;
gboolean arg_display_properties = FALSE;
gboolean arg_display_about = FALSE;
gboolean arg_consider_new_mail_as_read = FALSE;
gboolean arg_update = FALSE;
gboolean arg_print_summary = FALSE;
gboolean arg_unset_obsolete_configuration = FALSE;
gboolean arg_quit = FALSE;
const GOptionEntry options[] = {
{
"version",
'v',
0,
G_OPTION_ARG_NONE,
&arg_version,
N_("Show version information"),
NULL
},
{
"enable-info",
'i',
0,
G_OPTION_ARG_NONE,
&arg_enable_info,
N_("Enable informational output"),
NULL
},
{
"display-properties",
'p',
0,
G_OPTION_ARG_NONE,
&arg_display_properties,
N_("Display the properties dialog"),
NULL
},
{
"display-about",
'a',
0,
G_OPTION_ARG_NONE,
&arg_display_about,
N_("Display the about dialog"),
NULL
},
{
"consider-new-mail-as-read",
'r',
0,
G_OPTION_ARG_NONE,
&arg_consider_new_mail_as_read,
N_("Consider new mail as read"),
NULL
},
{
"update",
'u',
0,
G_OPTION_ARG_NONE,
&arg_update,
N_("Update the mail status"),
NULL
},
{
"print-summary",
's',
0,
G_OPTION_ARG_NONE,
&arg_print_summary,
N_("Print a XML mail summary"),
NULL
},
{
"unset-obsolete-configuration",
'\0',
0,
G_OPTION_ARG_NONE,
&arg_unset_obsolete_configuration,
N_("Unset obsolete GConf configuration"),
NULL
},
{
"quit",
'q',
0,
G_OPTION_ARG_NONE,
&arg_quit,
N_("Quit Mail Notification"),
NULL
},
{ NULL }
};
GOptionContext *option_context;
DBusGConnection *bus;
DBusGProxy *bus_proxy;
g_log_set_fatal_mask(NULL, G_LOG_LEVEL_CRITICAL);
g_log_set_handler(NULL, G_LOG_LEVEL_INFO, info_log_cb, NULL);
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
g_set_application_name(_("Mail Notification"));
g_thread_init(NULL);
if (! g_thread_supported())
/*
* We cannot use mn_fatal_error_dialog() because gtk_init() has
* not been called yet.
*/
g_critical(_("multi-threading is not available"));
gdk_threads_init();
GDK_THREADS_ENTER();
option_context = g_option_context_new(NULL);
g_option_context_add_main_entries(option_context, options, GETTEXT_PACKAGE);
gnome_program_init(PACKAGE,
VERSION,
LIBGNOME_MODULE,
argc,
argv,
GNOME_PARAM_HUMAN_READABLE_NAME, _("Mail Notification"),
GNOME_PROGRAM_STANDARD_PROPERTIES,
GNOME_PARAM_GOPTION_CONTEXT, option_context,
NULL);
gtk_init(&argc, &argv);
if (arg_version)
{
print_version();
goto end;
}
if (arg_unset_obsolete_configuration)
{
mn_conf_unset_obsolete();
goto end;
}
ensure_icon_path();
gtk_window_set_default_icon_name("mail-notification");
mn_stock_init();
bus = connect_to_session_bus();
bus_proxy = get_bus_proxy(bus);
if (mn_server_start(bus, bus_proxy)) /* not already running */
{
if (arg_quit)
g_message(_("Mail Notification is not running"));
else
{
mn_mailbox_init_types();
#if WITH_MBOX || WITH_MOZILLA || WITH_MH || WITH_MAILDIR || WITH_SYLPHEED
mn_vfs_mailbox_init_types();
#endif
/* mn-client-session uses sockets, we don't want to die on SIGPIPE */
signal(SIGPIPE, SIG_IGN);
if (! gnome_vfs_init())
mn_show_fatal_error_dialog(NULL, _("Unable to initialize the GnomeVFS library."));
#if !GTK_CHECK_VERSION(3,0,0)
gnome_authentication_manager_init();
#endif
/* must be called before init_gmime() */
mn_conf_init();
#if WITH_GMIME
init_gmime();
#endif
if (! notify_init(_("Mail Notification")))
mn_show_error_dialog(NULL,
_("An initialization error has occurred in Mail Notification"),
_("Unable to initialize the notification library. Message popups will not be displayed."));
/*
* Work around
* http://bugzilla.gnome.org/show_bug.cgi?id=64764:
* initialize the classes we will be using concurrently
* before any thread is created.
*/
init_classes();
mn_shell_new(bus, bus_proxy);
/* also display the properties dialog if there are no mailboxes */
if (! mn_shell->mailboxes->list)
arg_display_properties = TRUE;
if (arg_display_properties)
mn_shell_show_properties_dialog(mn_shell, 0);
if (arg_display_about)
mn_shell_show_about_dialog(mn_shell, 0);
if (arg_consider_new_mail_as_read)
report_option_ignored("--consider-new-mail-as-read");
if (arg_update)
report_option_ignored("--update");
if (arg_print_summary)
report_option_ignored("--print-summary");
/* in case no window has been displayed */
gdk_notify_startup_complete();
gtk_main();
}
}
else /* already running */
{
DBusGProxy *proxy;
GError *err = NULL;
proxy = dbus_g_proxy_new_for_name(bus,
MN_SERVER_SERVICE,
MN_SERVER_PATH,
MN_SERVER_INTERFACE);
if (arg_quit)
{
g_message(_("quitting Mail Notification"));
CALL_SERVER(org_gnome_MailNotification_quit(proxy, &err));
}
else
{
/* also display the properties dialog if there are no mailboxes */
if (! arg_display_properties)
{
gboolean has;
CALL_SERVER(org_gnome_MailNotification_has_mailboxes(proxy, &has, &err));
arg_display_properties = ! has;
}
if (arg_display_properties)
CALL_SERVER(org_gnome_MailNotification_display_properties(proxy, &err));
if (arg_display_about)
CALL_SERVER(org_gnome_MailNotification_display_about(proxy, &err));
if (arg_consider_new_mail_as_read)
{
g_message(_("considering new mail as read"));
CALL_SERVER(org_gnome_MailNotification_consider_new_mail_as_read(proxy, &err));
}
if (arg_update)
{
g_message(_("updating the mail status"));
CALL_SERVER(org_gnome_MailNotification_update(proxy, &err));
}
if (arg_print_summary)
{
char *summary;
CALL_SERVER(org_gnome_MailNotification_get_summary(proxy, &summary, &err));
g_print("%s", summary);
g_free(summary);
}
if (! (arg_display_properties
|| arg_display_about
|| arg_consider_new_mail_as_read
|| arg_update
|| arg_print_summary))
g_message(_("Mail Notification is already running"));
}
/*
* Do not unref the proxy, since it might break when the
* DBusGProxy memory management issue is fixed
* (https://bugs.freedesktop.org/show_bug.cgi?id=14030).
*/
/* no window has been displayed by this process */
gdk_notify_startup_complete();
}
end:
GDK_THREADS_LEAVE();
return 0;
}
int main(int argc, char **argv)
{
const char *sopt = "hVvdm:p:l:f:F::b:s:t:";
const char *method = NULL, *path = NULL;
const char *log_filepath = NULL;
const char *pid_filepath;
#ifdef CONFIG_FSFREEZE
const char *fsfreeze_hook = NULL;
#endif
const char *state_dir;
#ifdef _WIN32
const char *service = NULL;
#endif
const struct option lopt[] = {
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'V' },
{ "logfile", 1, NULL, 'l' },
{ "pidfile", 1, NULL, 'f' },
#ifdef CONFIG_FSFREEZE
{ "fsfreeze-hook", 2, NULL, 'F' },
#endif
{ "verbose", 0, NULL, 'v' },
{ "method", 1, NULL, 'm' },
{ "path", 1, NULL, 'p' },
{ "daemonize", 0, NULL, 'd' },
{ "blacklist", 1, NULL, 'b' },
#ifdef _WIN32
{ "service", 1, NULL, 's' },
#endif
{ "statedir", 1, NULL, 't' },
{ NULL, 0, NULL, 0 }
};
int opt_ind = 0, ch, daemonize = 0, i, j, len;
GLogLevelFlags log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
GList *blacklist = NULL;
GAState *s;
module_call_init(MODULE_INIT_QAPI);
init_dfl_pathnames();
pid_filepath = dfl_pathnames.pidfile;
state_dir = dfl_pathnames.state_dir;
while ((ch = getopt_long(argc, argv, sopt, lopt, &opt_ind)) != -1) {
switch (ch) {
case 'm':
method = optarg;
break;
case 'p':
path = optarg;
break;
case 'l':
log_filepath = optarg;
break;
case 'f':
pid_filepath = optarg;
break;
#ifdef CONFIG_FSFREEZE
case 'F':
fsfreeze_hook = optarg ? optarg : QGA_FSFREEZE_HOOK_DEFAULT;
break;
#endif
case 't':
state_dir = optarg;
break;
case 'v':
/* enable all log levels */
log_level = G_LOG_LEVEL_MASK;
break;
case 'V':
printf("QEMU Guest Agent %s\n", QEMU_VERSION);
return 0;
case 'd':
daemonize = 1;
break;
case 'b': {
if (is_help_option(optarg)) {
qmp_for_each_command(ga_print_cmd, NULL);
return 0;
}
for (j = 0, i = 0, len = strlen(optarg); i < len; i++) {
if (optarg[i] == ',') {
optarg[i] = 0;
blacklist = g_list_append(blacklist, &optarg[j]);
j = i + 1;
}
}
if (j < i) {
blacklist = g_list_append(blacklist, &optarg[j]);
}
break;
}
#ifdef _WIN32
case 's':
service = optarg;
if (strcmp(service, "install") == 0) {
const char *fixed_state_dir;
/* If the user passed the "-t" option, we save that state dir
* in the service. Otherwise we let the service fetch the state
* dir from the environment when it starts.
*/
fixed_state_dir = (state_dir == dfl_pathnames.state_dir) ?
NULL :
state_dir;
if (ga_install_vss_provider()) {
return EXIT_FAILURE;
}
if (ga_install_service(path, log_filepath, fixed_state_dir)) {
return EXIT_FAILURE;
}
return 0;
} else if (strcmp(service, "uninstall") == 0) {
ga_uninstall_vss_provider();
return ga_uninstall_service();
} else {
printf("Unknown service command.\n");
return EXIT_FAILURE;
}
break;
#endif
case 'h':
usage(argv[0]);
return 0;
case '?':
g_print("Unknown option, try '%s --help' for more information.\n",
argv[0]);
return EXIT_FAILURE;
}
}
#ifdef _WIN32
/* On win32 the state directory is application specific (be it the default
* or a user override). We got past the command line parsing; let's create
* the directory (with any intermediate directories). If we run into an
* error later on, we won't try to clean up the directory, it is considered
* persistent.
*/
if (g_mkdir_with_parents(state_dir, S_IRWXU) == -1) {
g_critical("unable to create (an ancestor of) the state directory"
" '%s': %s", state_dir, strerror(errno));
return EXIT_FAILURE;
}
#endif
s = g_malloc0(sizeof(GAState));
s->log_level = log_level;
s->log_file = stderr;
#ifdef CONFIG_FSFREEZE
s->fsfreeze_hook = fsfreeze_hook;
#endif
g_log_set_default_handler(ga_log, s);
g_log_set_fatal_mask(NULL, G_LOG_LEVEL_ERROR);
ga_enable_logging(s);
s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen",
state_dir);
s->pstate_filepath = g_strdup_printf("%s/qga.state", state_dir);
s->frozen = false;
#ifndef _WIN32
/* check if a previous instance of qemu-ga exited with filesystems' state
* marked as frozen. this could be a stale value (a non-qemu-ga process
* or reboot may have since unfrozen them), but better to require an
* uneeded unfreeze than to risk hanging on start-up
*/
struct stat st;
if (stat(s->state_filepath_isfrozen, &st) == -1) {
/* it's okay if the file doesn't exist, but if we can't access for
* some other reason, such as permissions, there's a configuration
* that needs to be addressed. so just bail now before we get into
* more trouble later
*/
if (errno != ENOENT) {
g_critical("unable to access state file at path %s: %s",
s->state_filepath_isfrozen, strerror(errno));
return EXIT_FAILURE;
}
} else {
g_warning("previous instance appears to have exited with frozen"
" filesystems. deferring logging/pidfile creation and"
" disabling non-fsfreeze-safe commands until"
" guest-fsfreeze-thaw is issued, or filesystems are"
" manually unfrozen and the file %s is removed",
s->state_filepath_isfrozen);
s->frozen = true;
}
#endif
if (ga_is_frozen(s)) {
if (daemonize) {
/* delay opening/locking of pidfile till filesystems are unfrozen */
s->deferred_options.pid_filepath = pid_filepath;
become_daemon(NULL);
}
if (log_filepath) {
/* delay opening the log file till filesystems are unfrozen */
s->deferred_options.log_filepath = log_filepath;
}
ga_disable_logging(s);
qmp_for_each_command(ga_disable_non_whitelisted, NULL);
} else {
if (daemonize) {
become_daemon(pid_filepath);
}
if (log_filepath) {
FILE *log_file = ga_open_logfile(log_filepath);
if (!log_file) {
g_critical("unable to open specified log file: %s",
strerror(errno));
goto out_bad;
}
s->log_file = log_file;
}
}
/* load persistent state from disk */
if (!read_persistent_state(&s->pstate,
s->pstate_filepath,
ga_is_frozen(s))) {
g_critical("failed to load persistent state");
goto out_bad;
}
blacklist = ga_command_blacklist_init(blacklist);
if (blacklist) {
s->blacklist = blacklist;
do {
g_debug("disabling command: %s", (char *)blacklist->data);
qmp_disable_command(blacklist->data);
blacklist = g_list_next(blacklist);
} while (blacklist);
}
s->command_state = ga_command_state_new();
ga_command_state_init(s, s->command_state);
ga_command_state_init_all(s->command_state);
json_message_parser_init(&s->parser, process_event);
ga_state = s;
#ifndef _WIN32
if (!register_signal_handlers()) {
g_critical("failed to register signal handlers");
goto out_bad;
}
#endif
s->main_loop = g_main_loop_new(NULL, false);
if (!channel_init(ga_state, method, path)) {
g_critical("failed to initialize guest agent channel");
goto out_bad;
}
#ifndef _WIN32
g_main_loop_run(ga_state->main_loop);
#else
if (daemonize) {
SERVICE_TABLE_ENTRY service_table[] = {
{ (char *)QGA_SERVICE_NAME, service_main }, { NULL, NULL } };
StartServiceCtrlDispatcher(service_table);
} else {
g_main_loop_run(ga_state->main_loop);
}
#endif
ga_command_state_cleanup_all(ga_state->command_state);
ga_channel_free(ga_state->channel);
if (daemonize) {
unlink(pid_filepath);
}
return 0;
out_bad:
if (daemonize) {
unlink(pid_filepath);
}
return EXIT_FAILURE;
}
int
main (int argc, char **argv)
{
GError *error = NULL;
GDBusConnection *gdbus = NULL;
GDBusConnection *gdbus_system = NULL;
DBusConnection *connection = NULL;
int ret = 1;
GMainLoop *teardown_loop;
guint linger_time = 5;
g_type_init ();
g_set_application_name ("Mission Control regression tests");
mcd_debug_init ();
tp_debug_set_flags (g_getenv ("MC_TP_DEBUG"));
/* Not all warnings are fatal due to MC spamming warnings (fd.o #23486),
* but GLib and GObject warnings are pretty serious */
g_log_set_fatal_mask ("GLib",
G_LOG_FATAL_MASK | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);
g_log_set_fatal_mask ("GLib-GObject",
G_LOG_FATAL_MASK | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING);
gdbus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
g_assert_no_error (error);
g_assert (gdbus != NULL);
g_dbus_connection_set_exit_on_close (gdbus, FALSE);
gdbus_system = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
g_assert_no_error (error);
g_assert (gdbus_system != NULL);
g_dbus_connection_set_exit_on_close (gdbus_system, FALSE);
bus_daemon = tp_dbus_daemon_dup (&error);
g_assert_no_error (error);
g_assert (bus_daemon != NULL);
/* It appears that dbus-glib registers a filter that wrongly returns
* DBUS_HANDLER_RESULT_HANDLED for signals, so for *our* filter to have any
* effect, we need to install it as soon as possible */
connection = dbus_g_connection_get_connection (
tp_proxy_get_dbus_connection (bus_daemon));
dbus_connection_add_filter (connection, dbus_filter_function, NULL, NULL);
mcd = mcd_service_new ();
/* Listen for suicide notification */
g_signal_connect_after (mcd, "abort", G_CALLBACK (on_abort), NULL);
/* connect */
mcd_mission_connect (MCD_MISSION (mcd));
dbus_connection_set_exit_on_disconnect (connection, FALSE);
mcd_service_run (MCD_OBJECT (mcd));
ret = 0;
teardown_loop = g_main_loop_new (NULL, FALSE);
if (g_getenv ("MC_LINGER_TIME") != NULL)
{
linger_time = g_ascii_strtoull (g_getenv ("MC_LINGER_TIME"), NULL, 10);
}
/* Keep running in the background until it's all over. This means valgrind
* and refdbg can get complete information. */
g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, linger_time, the_end,
teardown_loop, (GDestroyNotify) g_main_loop_unref);
g_main_loop_run (teardown_loop);
if (connection != NULL)
{
dbus_connection_flush (connection);
}
tp_clear_object (&gdbus);
tp_clear_object (&gdbus_system);
tp_clear_object (&bus_daemon);
dbus_shutdown ();
g_message ("Exiting with %d", ret);
return ret;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
gboolean relax = FALSE;
gboolean ret;
gboolean verbose = FALSE;
gboolean version = FALSE;
gchar *config_dump = NULL;
GError *error = NULL;
gint retval = EXIT_CODE_SUCCESS;
gint retval_tmp;
GKeyFile *config = NULL;
GOptionContext *context;
guint i;
const GOptionEntry options[] = {
{ "relax", 'r', 0, G_OPTION_ARG_NONE, &relax,
/* TRANSLATORS: this is the --relax argument */
_("Be less strict when checking files"), NULL },
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
/* TRANSLATORS: this is the --verbose argument */
_("Show extra debugging information"), NULL },
{ "version", '\0', 0, G_OPTION_ARG_NONE, &version,
/* TRANSLATORS: this is the --version argument */
_("Show the version number and then quit"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_type_init ();
context = g_option_context_new ("AppData Validation Program");
g_option_context_add_main_entries (context, options, NULL);
ret = g_option_context_parse (context, &argc, &argv, &error);
if (!ret) {
/* TRANSLATORS: this is where the user used unknown command
* line switches -- the exact error follows */
g_print ("%s %s\n", _("Failed to parse command line:"), error->message);
g_error_free (error);
goto out;
}
/* just show the version */
if (version) {
g_print ("%s\n", PACKAGE_VERSION);
goto out;
}
/* verbose? */
if (verbose) {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("AppDataTools",
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
appdata_validate_log_handler_cb, NULL);
} else {
/* hide all debugging */
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL);
g_log_set_handler ("AppDataTools",
G_LOG_LEVEL_DEBUG,
appdata_validate_log_ignore_cb, NULL);
}
if (argc < 2) {
retval = EXIT_CODE_USAGE;
/* TRANSLATORS: this is explaining how to use the tool */
g_print ("%s %s %s\n", _("Usage:"), argv[0], _("<file>"));
goto out;
}
/* set some config values */
config = g_key_file_new ();
if (relax || g_getenv ("RELAX") != NULL) {
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthUpdatecontactMin", 6);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthNameMin", 4);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthNameMax", 100);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthSummaryMin", 8);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthSummaryMax", 200);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthParaMin", 10);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthParaMax", 1000);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthListItemMin", 4);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthListItemMax", 1000);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberParaMin", 1);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberParaMax", 10);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberScreenshotsMin", 0);
g_key_file_set_boolean (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"RequireContactdetails", FALSE);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberScreenshotsMax", 10);
g_key_file_set_boolean (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"RequireUrl", FALSE);
} else {
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthUpdatecontactMin", 6);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthNameMin", 4);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthNameMax", 30);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthSummaryMin", 8);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthSummaryMax", 100);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthParaMin", 50);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthParaMax", 600);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthListItemMin", 20);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"LengthListItemMax", 100);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberParaMin", 2);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberParaMax", 4);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberScreenshotsMin", 1);
g_key_file_set_integer (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"NumberScreenshotsMax", 5);
g_key_file_set_boolean (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"RequireContactdetails", TRUE);
g_key_file_set_boolean (config, APPDATA_TOOLS_VALIDATE_GROUP_NAME,
"RequireUrl", TRUE);
}
config_dump = g_key_file_to_data (config, NULL, &error);
g_debug ("%s", config_dump);
/* validate each file */
for (i = 1; i < argc; i++) {
retval_tmp = appdata_validate_and_show_results (config, argv[i]);
if (retval_tmp != EXIT_CODE_SUCCESS)
retval = retval_tmp;
}
out:
if (config != NULL)
g_key_file_free (config);
g_free (config_dump);
g_option_context_free (context);
return retval;
}
/**
* main:
**/
gint
main (gint argc, gchar **argv)
{
GError *error = NULL;
UpDaemon *daemon = NULL;
UpQos *qos = NULL;
UpKbdBacklight *kbd_backlight = NULL;
UpWakeups *wakeups = NULL;
GOptionContext *context;
DBusGProxy *bus_proxy;
DBusGConnection *bus;
gboolean ret;
gint retval = 1;
gboolean timed_exit = FALSE;
gboolean immediate_exit = FALSE;
guint timer_id = 0;
gboolean verbose = FALSE;
const GOptionEntry options[] = {
{ "timed-exit", '\0', 0, G_OPTION_ARG_NONE, &timed_exit,
/* TRANSLATORS: exit after we've started up, used for user profiling */
_("Exit after a small delay"), NULL },
{ "immediate-exit", '\0', 0, G_OPTION_ARG_NONE, &immediate_exit,
/* TRANSLATORS: exit straight away, used for automatic profiling */
_("Exit after the engine has loaded"), NULL },
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
_("Show extra debugging information"), NULL },
{ NULL}
};
#if !defined(GLIB_VERSION_2_36)
g_type_init ();
#endif
setlocale(LC_ALL, "");
context = g_option_context_new ("upower daemon");
g_option_context_add_main_entries (context, options, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_warning ("Failed to parse command-line options: %s", error->message);
g_error_free (error);
return 1;
}
g_option_context_free (context);
/* verbose? */
if (verbose) {
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL);
g_log_set_handler (G_LOG_DOMAIN,
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
up_main_log_handler_cb, NULL);
g_log_set_handler ("UPower-Linux",
G_LOG_LEVEL_ERROR |
G_LOG_LEVEL_CRITICAL |
G_LOG_LEVEL_DEBUG |
G_LOG_LEVEL_WARNING,
up_main_log_handler_cb, NULL);
} else {
/* hide all debugging */
g_log_set_fatal_mask (NULL, G_LOG_LEVEL_ERROR);
g_log_set_handler (G_LOG_DOMAIN,
G_LOG_LEVEL_DEBUG,
up_main_log_ignore_cb,
NULL);
g_log_set_handler ("UPower-Linux",
G_LOG_LEVEL_DEBUG,
up_main_log_ignore_cb,
NULL);
}
/* get bus connection */
bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (bus == NULL) {
g_warning ("Couldn't connect to system bus: %s", error->message);
g_error_free (error);
goto out;
}
/* get proxy */
bus_proxy = dbus_g_proxy_new_for_name (bus, DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
if (bus_proxy == NULL) {
g_warning ("Could not construct bus_proxy object; bailing out");
goto out;
}
/* aquire name */
ret = up_main_acquire_name_on_proxy (bus_proxy, DEVKIT_POWER_SERVICE_NAME);
if (!ret) {
g_warning ("Could not acquire name; bailing out");
goto out;
}
#if GLIB_CHECK_VERSION(2,29,19)
/* do stuff on ctrl-c */
g_unix_signal_add_full (G_PRIORITY_DEFAULT,
SIGINT,
up_main_sigint_cb,
loop,
NULL);
#else
signal (SIGINT, up_main_sigint_handler);
#endif
g_debug ("Starting upowerd version %s", PACKAGE_VERSION);
/* no need to bother with keyboard backlight
or wake-up tracking (especially since it only partly works on arm
qos = up_qos_new ();
kbd_backlight = up_kbd_backlight_new ();
wakeups = up_wakeups_new (); */
daemon = up_daemon_new ();
loop = g_main_loop_new (NULL, FALSE);
ret = up_daemon_startup (daemon);
if (!ret) {
g_warning ("Could not startup; bailing out");
goto out;
}
/* only timeout and close the mainloop if we have specified it on the command line */
if (timed_exit) {
timer_id = g_timeout_add_seconds (30, (GSourceFunc) up_main_timed_exit_cb, loop);
#if GLIB_CHECK_VERSION(2,25,8)
g_source_set_name_by_id (timer_id, "[UpMain] idle");
#endif
}
/* immediatly exit */
if (immediate_exit)
g_timeout_add (50, (GSourceFunc) up_main_timed_exit_cb, loop);
/* wait for input or timeout */
g_main_loop_run (loop);
retval = 0;
out:
if (qos != NULL)
g_object_unref (qos);
if (kbd_backlight != NULL)
g_object_unref (kbd_backlight);
if (wakeups != NULL)
g_object_unref (wakeups);
if (daemon != NULL)
g_object_unref (daemon);
if (loop != NULL)
g_main_loop_unref (loop);
return retval;
}
