static gboolean
handle_empty_device (CockpitStorageVolumeGroup *object,
GDBusMethodInvocation *invocation,
const gchar *arg_objpath)
{
StorageVolumeGroup *group = STORAGE_VOLUME_GROUP(object);
GError *error = NULL;
const gchar *block_path = "/";
if (!auth_check_sender_role (invocation, COCKPIT_ROLE_STORAGE_ADMIN))
return TRUE;
StorageProvider *provider = storage_object_get_provider (group->object);
Daemon *daemon = storage_provider_get_daemon (provider);
GDBusObjectManagerServer *object_manager_server = daemon_get_object_manager (daemon);
GDBusObjectManager *object_manager = G_DBUS_OBJECT_MANAGER (object_manager_server);
StorageObject *block_object =
STORAGE_OBJECT (g_dbus_object_manager_get_object (object_manager, arg_objpath));
UDisksBlock *udisks_block = storage_object_get_udisks_block (block_object);
if (udisks_block)
block_path = g_dbus_proxy_get_object_path (G_DBUS_PROXY (udisks_block));
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),
G_MAXINT);
if (!lvm_volume_group_call_empty_device_sync (group->lvm_volume_group,
block_path,
null_asv (),
NULL,
&error))
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR,
COCKPIT_ERROR_FAILED,
"%s", error->message);
g_error_free (error);
}
else
cockpit_storage_volume_group_complete_empty_device (object, invocation);
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (group->lvm_volume_group),
-1);
return TRUE;
}
static void
init_interface_proxy (UDisksClient *client,
GDBusProxy *proxy)
{
/* disable method timeouts */
g_dbus_proxy_set_default_timeout (proxy, G_MAXINT);
}
static void
storage_manager_constructed (GObject *_object)
{
StorageManager *storage_manager = STORAGE_MANAGER (_object);
GError *error = NULL;
storage_manager->udisks = udisks_client_new_sync (NULL, &error);
if (storage_manager->udisks == NULL)
{
g_warning ("Error connecting to udisks: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
}
storage_manager->lvm_manager =
lvm_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
0,
"com.redhat.storaged",
"/org/freedesktop/UDisks2/Manager",
NULL,
&error);
if (storage_manager->lvm_manager == NULL)
{
g_warning ("Error connecting to storaged: %s (%s, %d)",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (storage_manager->lvm_manager), G_MAXINT);
if (G_OBJECT_CLASS (storage_manager_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storage_manager_parent_class)->constructed (_object);
}
static void
on_interface_added (GDBusObjectManager *manager,
GDBusObject *object,
GDBusInterface *interface)
{
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (interface), G_MAXINT);
}
static void
open_connection_async_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVfsDBusDaemon *proxy;
AsyncDBusCall *async_call = user_data;
GError *error = NULL;
proxy = gvfs_dbus_daemon_proxy_new_finish (res, &error);
if (proxy == NULL)
{
async_call->io_error = g_error_copy (error);
g_error_free (error);
async_call_finish (async_call);
return;
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (proxy), G_VFS_DBUS_TIMEOUT_MSECS);
gvfs_dbus_daemon_call_get_connection (proxy,
async_call->cancellable,
(GAsyncReadyCallback) async_get_connection_response,
async_call);
g_object_unref (proxy);
}
GDBusInterfaceSkeleton *
print_create (GDBusConnection *connection,
const char *dbus_name,
gpointer lockdown_proxy)
{
g_autoptr(GError) error = NULL;
lockdown = lockdown_proxy;
impl = xdp_impl_print_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
dbus_name,
DESKTOP_PORTAL_OBJECT_PATH,
NULL,
&error);
if (impl == NULL)
{
g_warning ("Failed to create print proxy: %s", error->message);
return NULL;
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (impl), G_MAXINT);
print = g_object_new (print_get_type (), NULL);
return G_DBUS_INTERFACE_SKELETON (print);
}
static void
storage_volume_group_constructed (GObject *object)
{
StorageVolumeGroup *volume_group = STORAGE_VOLUME_GROUP (object);
volume_group->lvm_volume_group = g_object_ref (storage_object_get_lvm_volume_group (volume_group->object));
g_signal_connect (volume_group->lvm_volume_group,
"notify",
G_CALLBACK (on_lvm_volume_group_notify),
volume_group);
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (volume_group->lvm_volume_group), G_MAXINT);
storage_volume_group_update (volume_group);
if (G_OBJECT_CLASS (storage_volume_group_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storage_volume_group_parent_class)->constructed (object);
}
static void
storage_logical_volume_constructed (GObject *object)
{
StorageLogicalVolume *logical_volume = STORAGE_LOGICAL_VOLUME(object);
logical_volume->lvm_logical_volume = g_object_ref (storage_object_get_lvm_logical_volume (logical_volume->object));
g_signal_connect (logical_volume->lvm_logical_volume,
"notify",
G_CALLBACK (on_lvm_logical_volume_notify),
logical_volume);
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (logical_volume->lvm_logical_volume), G_MAXINT);
storage_logical_volume_update (logical_volume);
if (G_OBJECT_CLASS (storage_logical_volume_parent_class)->constructed != NULL)
G_OBJECT_CLASS (storage_logical_volume_parent_class)->constructed (object);
}
connman_service_t *connman_service_new(GVariant *variant)
{
if(NULL == variant)
return NULL;
connman_service_t *service = g_new0(connman_service_t, 1);
if(service == NULL)
{
WCA_LOG_FATAL("Out of memory !!!");
return NULL;
}
GVariant *service_v = g_variant_get_child_value(variant, 0);
service->path = g_variant_dup_string(service_v, NULL);
GError *error = NULL;
service->remote = connman_interface_service_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
"net.connman",
service->path,
NULL,
&error);
if (error)
{
WCA_LOG_CRITICAL("%s", error->message);
g_error_free(error);
g_free(service);
return NULL;
}
g_dbus_proxy_set_default_timeout(service->remote, DBUS_CALL_TIMEOUT);
service->sighandler_id = g_signal_connect_data(G_OBJECT(service->remote), "property-changed",
G_CALLBACK(property_changed_cb), service, NULL, 0);
GVariant *properties = g_variant_get_child_value(variant, 1);
connman_service_update_properties(service, properties);
return service;
}
static void
on_provider_new (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *async = G_SIMPLE_ASYNC_RESULT (user_data);
NewClosure *closure = g_simple_async_result_get_op_res_gpointer (async);
GError *error = NULL;
UmRealmProvider *provider;
provider = um_realm_provider_proxy_new_finish (result, &error);
closure->manager->provider = provider;
if (error == NULL) {
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (closure->manager->provider), -1);
g_debug ("Created realm manager");
} else {
g_simple_async_result_take_error (async, error);
}
g_simple_async_result_complete (async);
g_object_unref (async);
}
static void
auth_session_get_object_path_reply (GObject *object, GAsyncResult *res,
gpointer userdata)
{
SsoAuthService *proxy = SSO_AUTH_SERVICE (object);
gchar *object_path = NULL;
GError *error = NULL;
sso_auth_service_call_get_auth_session_object_path_finish (proxy,
&object_path,
res,
&error);
SIGNON_RETURN_IF_CANCELLED (error);
g_return_if_fail (SIGNON_IS_AUTH_SESSION (userdata));
SignonAuthSession *self = SIGNON_AUTH_SESSION (userdata);
SignonAuthSessionPrivate *priv = self->priv;
g_return_if_fail (priv != NULL);
priv->registering = FALSE;
if (!g_strcmp0(object_path, "") || error)
{
if (error)
DEBUG ("Error message is %s", error->message);
else
error = g_error_new (signon_error_quark(),
SIGNON_ERROR_RUNTIME,
"Cannot create remote AuthSession object");
}
else
{
GDBusConnection *connection;
const gchar *bus_name;
GError *proxy_error = NULL;
connection = g_dbus_proxy_get_connection ((GDBusProxy *)proxy);
bus_name = g_dbus_proxy_get_name ((GDBusProxy *)proxy);
priv->proxy =
sso_auth_session_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
bus_name,
object_path,
priv->cancellable,
&proxy_error);
if (G_UNLIKELY (proxy_error != NULL))
{
g_warning ("Failed to initialize AuthSession proxy: %s",
proxy_error->message);
g_clear_error (&proxy_error);
}
g_dbus_proxy_set_default_timeout ((GDBusProxy *)priv->proxy,
G_MAXINT);
priv->signal_state_changed =
g_signal_connect (priv->proxy,
"state-changed",
G_CALLBACK (auth_session_state_changed_cb),
self);
priv->signal_unregistered =
g_signal_connect (priv->proxy,
"unregistered",
G_CALLBACK (auth_session_remote_object_destroyed_cb),
self);
}
DEBUG ("Object path received: %s", object_path);
_signon_object_ready (self, auth_session_object_quark (), error);
g_clear_error (&error);
}
gint
tracker_control_general_run (void)
{
GError *error = NULL;
GSList *pids;
GSList *l;
gchar *str;
gpointer verbosity_type_enum_class_pointer = NULL;
TrackerVerbosity set_log_verbosity_value = TRACKER_VERBOSITY_ERRORS;
/* Constraints */
if (kill_option != TERM_NONE && terminate_option != TERM_NONE) {
g_printerr ("%s\n",
_("You can not use the --kill and --terminate arguments together"));
return EXIT_FAILURE;
}
if ((hard_reset || soft_reset) && terminate_option != TERM_NONE) {
g_printerr ("%s\n",
_("You can not use the --terminate with --hard-reset or --soft-reset, --kill is implied"));
return EXIT_FAILURE;
}
if (hard_reset && soft_reset) {
g_printerr ("%s\n",
_("You can not use the --hard-reset and --soft-reset arguments together"));
return EXIT_FAILURE;
}
if (get_log_verbosity && set_log_verbosity) {
g_printerr ("%s\n",
_("You can not use the --get-logging and --set-logging arguments together"));
return EXIT_FAILURE;
}
if (set_log_verbosity) {
if (g_ascii_strcasecmp (set_log_verbosity, "debug") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_DEBUG;
} else if (g_ascii_strcasecmp (set_log_verbosity, "detailed") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_DETAILED;
} else if (g_ascii_strcasecmp (set_log_verbosity, "minimal") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_MINIMAL;
} else if (g_ascii_strcasecmp (set_log_verbosity, "errors") == 0) {
set_log_verbosity_value = TRACKER_VERBOSITY_ERRORS;
} else {
g_printerr ("%s\n",
_("Invalid log verbosity, try 'debug', 'detailed', 'minimal' or 'errors'"));
return EXIT_FAILURE;
}
}
if (hard_reset || soft_reset) {
/* Imply --kill */
kill_option = TERM_ALL;
}
if (get_log_verbosity || set_log_verbosity) {
GType etype;
/* Since we don't reference this enum anywhere, we do
* it here to make sure it exists when we call
* g_type_class_peek(). This wouldn't be necessary if
* it was a param in a GObject for example.
*
* This does mean that we are leaking by 1 reference
* here and should clean it up, but it doesn't grow so
* this is acceptable.
*/
etype = tracker_verbosity_get_type ();
verbosity_type_enum_class_pointer = g_type_class_ref (etype);
}
/* Unless we are stopping processes or listing processes,
* don't iterate them.
*/
if (kill_option != TERM_NONE ||
terminate_option != TERM_NONE ||
list_processes) {
guint32 own_pid;
guint32 own_uid;
gchar *own_pid_str;
pids = get_pids ();
str = g_strdup_printf (g_dngettext (NULL,
"Found %d PID…",
"Found %d PIDs…",
g_slist_length (pids)),
g_slist_length (pids));
g_print ("%s\n", str);
g_free (str);
/* Establish own uid/pid */
own_pid = (guint32) getpid ();
own_pid_str = g_strdup_printf ("%d", own_pid);
own_uid = get_uid_for_pid (own_pid_str, NULL);
g_free (own_pid_str);
for (l = pids; l; l = l->next) {
GError *error = NULL;
gchar *filename;
gchar *contents = NULL;
gchar **strv;
guint uid;
uid = get_uid_for_pid (l->data, &filename);
/* Stat the file and make sure current user == file owner */
if (uid != own_uid) {
continue;
}
/* Get contents to determine basename */
if (!g_file_get_contents (filename, &contents, NULL, &error)) {
str = g_strdup_printf (_("Could not open '%s'"), filename);
g_printerr ("%s, %s\n",
str,
error ? error->message : _("no error given"));
g_free (str);
g_clear_error (&error);
g_free (contents);
g_free (filename);
continue;
}
strv = g_strsplit (contents, "^@", 2);
if (strv && strv[0]) {
gchar *basename;
basename = g_path_get_basename (strv[0]);
if ((g_str_has_prefix (basename, "tracker") == TRUE ||
g_str_has_prefix (basename, "lt-tracker") == TRUE) &&
g_str_has_suffix (basename, "-control") == FALSE &&
g_str_has_suffix (basename, "-status-icon") == FALSE) {
pid_t pid;
pid = atoi (l->data);
str = g_strdup_printf (_("Found process ID %d for '%s'"), pid, basename);
g_print ("%s\n", str);
g_free (str);
if (terminate_option != TERM_NONE) {
if ((terminate_option == TERM_STORE &&
!g_str_has_suffix (basename, "tracker-store")) ||
(terminate_option == TERM_MINERS &&
!strstr (basename, "tracker-miner"))) {
continue;
}
if (kill (pid, SIGTERM) == -1) {
const gchar *errstr = g_strerror (errno);
str = g_strdup_printf (_("Could not terminate process %d"), pid);
g_printerr (" %s, %s\n",
str,
errstr ? errstr : _("no error given"));
g_free (str);
} else {
str = g_strdup_printf (_("Terminated process %d"), pid);
g_print (" %s\n", str);
g_free (str);
}
} else if (kill_option != TERM_NONE) {
if ((kill_option == TERM_STORE &&
!g_str_has_suffix (basename, "tracker-store")) ||
(kill_option == TERM_MINERS &&
!strstr (basename, "tracker-miner"))) {
continue;
}
if (kill (pid, SIGKILL) == -1) {
const gchar *errstr = g_strerror (errno);
str = g_strdup_printf (_("Could not kill process %d"), pid);
g_printerr (" %s, %s\n",
str,
errstr ? errstr : _("no error given"));
g_free (str);
} else {
str = g_strdup_printf (_("Killed process %d"), pid);
g_print (" %s\n", str);
g_free (str);
}
}
}
g_free (basename);
}
g_strfreev (strv);
g_free (contents);
g_free (filename);
}
g_slist_foreach (pids, (GFunc) g_free, NULL);
g_slist_free (pids);
/* If we just wanted to list processes, all done */
if (list_processes &&
terminate_option == TERM_NONE &&
kill_option == TERM_NONE) {
return EXIT_SUCCESS;
}
}
if (hard_reset || soft_reset) {
guint log_handler_id;
#ifndef DISABLE_JOURNAL
gchar *rotate_to;
TrackerDBConfig *db_config;
gsize chunk_size;
gint chunk_size_mb;
#endif /* DISABLE_JOURNAL */
/* Set log handler for library messages */
log_handler_id = g_log_set_handler (NULL,
G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL,
log_handler,
NULL);
g_log_set_default_handler (log_handler, NULL);
#ifndef DISABLE_JOURNAL
db_config = tracker_db_config_new ();
chunk_size_mb = tracker_db_config_get_journal_chunk_size (db_config);
chunk_size = (gsize) ((gsize) chunk_size_mb * (gsize) 1024 * (gsize) 1024);
rotate_to = tracker_db_config_get_journal_rotate_destination (db_config);
/* This call is needed to set the journal's filename */
tracker_db_journal_set_rotating ((chunk_size_mb != -1),
chunk_size, rotate_to);
g_free (rotate_to);
g_object_unref (db_config);
#endif /* DISABLE_JOURNAL */
/* Clean up (select_cache_size and update_cache_size don't matter here) */
if (!tracker_db_manager_init (TRACKER_DB_MANAGER_REMOVE_ALL,
NULL,
FALSE,
FALSE,
100,
100,
NULL,
NULL,
NULL,
&error)) {
g_message ("Error initializing database: %s", error->message);
g_free (error);
return EXIT_FAILURE;
}
#ifndef DISABLE_JOURNAL
tracker_db_journal_init (NULL, FALSE, NULL);
#endif /* DISABLE_JOURNAL */
tracker_db_manager_remove_all (hard_reset);
tracker_db_manager_shutdown ();
#ifndef DISABLE_JOURNAL
tracker_db_journal_shutdown (NULL);
#endif /* DISABLE_JOURNAL */
/* Unset log handler */
g_log_remove_handler (NULL, log_handler_id);
}
if (remove_config) {
GMainLoop *main_loop;
GFile *file;
TrackerCrawler *crawler;
const gchar *suffix = ".cfg";
const gchar *home_conf_dir;
gchar *path;
GSList *all, *l;
crawler = tracker_crawler_new ();
main_loop = g_main_loop_new (NULL, FALSE);
g_signal_connect (crawler, "check-file",
G_CALLBACK (crawler_check_file_cb),
&suffix);
g_signal_connect (crawler, "finished",
G_CALLBACK (crawler_finished_cb),
main_loop);
/* Go through service files */
/* Check the default XDG_DATA_HOME location */
home_conf_dir = g_getenv ("XDG_CONFIG_HOME");
if (home_conf_dir && tracker_path_has_write_access_or_was_created (home_conf_dir)) {
path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, "tracker", NULL);
} else {
home_conf_dir = g_getenv ("HOME");
if (!home_conf_dir || !tracker_path_has_write_access_or_was_created (home_conf_dir)) {
home_conf_dir = g_get_home_dir ();
}
path = g_build_path (G_DIR_SEPARATOR_S, home_conf_dir, ".config", "tracker", NULL);
}
file = g_file_new_for_path (path);
g_free (path);
g_print ("%s\n", _("Removing configuration files…"));
tracker_crawler_start (crawler, file, FALSE);
g_object_unref (file);
g_main_loop_run (main_loop);
g_object_unref (crawler);
g_print ("%s\n", _("Resetting existing configuration…"));
all = tracker_gsettings_get_all (NULL);
if (!all) {
return EXIT_FAILURE;
}
for (l = all; l; l = l->next) {
ComponentGSettings *c = l->data;
gchar **keys, **p;
if (!c) {
continue;
}
g_print (" %s\n", c->name);
keys = g_settings_list_keys (c->settings);
for (p = keys; p && *p; p++) {
g_print (" %s\n", *p);
g_settings_reset (c->settings, *p);
}
if (keys) {
g_strfreev (keys);
}
g_settings_apply (c->settings);
}
tracker_gsettings_free (all);
}
/* Deal with logging changes AFTER the config may have been
* reset, this way users can actually use --remove-config with
* the --set-logging switch.
*/
if (get_log_verbosity) {
GSList *all;
gint longest = 0;
all = tracker_gsettings_get_all (&longest);
if (!all) {
return EXIT_FAILURE;
}
g_print ("%s:\n", _("Components"));
tracker_gsettings_print_verbosity (all, longest, TRUE);
g_print ("\n");
/* Miners */
g_print ("%s (%s):\n",
_("Miners"),
_("Only those with config listed"));
tracker_gsettings_print_verbosity (all, longest, FALSE);
g_print ("\n");
tracker_gsettings_free (all);
}
if (set_log_verbosity) {
GSList *all;
gchar *str;
gint longest = 0;
all = tracker_gsettings_get_all (&longest);
if (!all) {
return EXIT_FAILURE;
}
str = g_strdup_printf (_("Setting log verbosity for all components to '%s'…"), set_log_verbosity);
g_print ("%s\n", str);
g_print ("\n");
g_free (str);
tracker_gsettings_set_all (all, set_log_verbosity_value);
tracker_gsettings_free (all);
/* We free to make sure we get new settings and that
* they're saved properly.
*/
all = tracker_gsettings_get_all (&longest);
if (!all) {
return EXIT_FAILURE;
}
g_print ("%s:\n", _("Components"));
tracker_gsettings_print_verbosity (all, longest, TRUE);
g_print ("\n");
/* Miners */
g_print ("%s (%s):\n",
_("Miners"),
_("Only those with config listed"));
tracker_gsettings_print_verbosity (all, longest, FALSE);
g_print ("\n");
tracker_gsettings_free (all);
}
if (verbosity_type_enum_class_pointer) {
g_type_class_unref (verbosity_type_enum_class_pointer);
}
if (start) {
TrackerMinerManager *manager;
GSList *miners, *l;
if (hard_reset || soft_reset) {
g_print ("%s\n", _("Waiting one second before starting miners…"));
/* Give a second's grace to avoid race conditions */
g_usleep (G_USEC_PER_SEC);
}
g_print ("%s\n", _("Starting miners…"));
/* Auto-start the miners here */
manager = tracker_miner_manager_new_full (TRUE, &error);
if (!manager) {
g_printerr (_("Could not start miners, manager could not be created, %s"),
error ? error->message : "unknown error");
g_printerr ("\n");
g_clear_error (&error);
return EXIT_FAILURE;
}
miners = tracker_miner_manager_get_available (manager);
/* Get the status of all miners, this will start all
* miners not already running.
*/
for (l = miners; l; l = l->next) {
const gchar *display_name;
gdouble progress = 0.0;
display_name = tracker_miner_manager_get_display_name (manager, l->data);
if (!tracker_miner_manager_get_status (manager,
l->data,
NULL,
&progress,
NULL)) {
g_printerr (" ✗ %s (%s)\n",
display_name,
_("perhaps a disabled plugin?"));
} else {
g_print (" ✓ %s\n",
display_name);
}
g_free (l->data);
}
g_slist_free (miners);
g_object_unref (manager);
}
if (backup) {
GDBusConnection *connection;
GDBusProxy *proxy;
GError *error = NULL;
GVariant *v;
gchar *uri;
uri = get_uri_from_arg (backup);
g_print ("%s\n", _("Backing up database"));
g_print (" %s\n", uri);
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (!connection) {
g_critical ("Could not connect to the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
proxy = g_dbus_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.Tracker1",
"/org/freedesktop/Tracker1/Backup",
"org.freedesktop.Tracker1.Backup",
NULL,
&error);
if (error) {
g_critical ("Could not create proxy on the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
/* Backup/Restore can take some time */
g_dbus_proxy_set_default_timeout (proxy, G_MAXINT);
v = g_dbus_proxy_call_sync (proxy,
"Save",
g_variant_new ("(s)", uri),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (proxy) {
g_object_unref (proxy);
}
if (error) {
g_critical ("Could not backup database, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
if (v) {
g_variant_unref (v);
}
g_free (uri);
}
if (restore) {
GDBusConnection *connection;
GDBusProxy *proxy;
GError *error = NULL;
GVariant *v;
gchar *uri;
uri = get_uri_from_arg (restore);
g_print ("%s\n", _("Restoring database from backup"));
g_print (" %s\n", uri);
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (!connection) {
g_critical ("Could not connect to the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
proxy = g_dbus_proxy_new_sync (connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.Tracker1",
"/org/freedesktop/Tracker1/Backup",
"org.freedesktop.Tracker1.Backup",
NULL,
&error);
if (error) {
g_critical ("Could not create proxy on the D-Bus session bus, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
/* Backup/Restore can take some time */
g_dbus_proxy_set_default_timeout (proxy, G_MAXINT);
v = g_dbus_proxy_call_sync (proxy,
"Restore",
g_variant_new ("(s)", uri),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (proxy) {
g_object_unref (proxy);
}
if (error) {
g_critical ("Could not restore database, %s",
error ? error->message : "no error given.");
g_clear_error (&error);
g_free (uri);
return EXIT_FAILURE;
}
if (v) {
g_variant_unref (v);
}
g_free (uri);
}
return EXIT_SUCCESS;
}
int
main (int argc,
char *argv[])
{
MetaTree *tree;
GError *error = NULL;
GOptionContext *context;
MetaLookupCache *lookup;
struct stat statbuf;
const char *path, *key;
const char *metatreefile;
char *tree_path;
GVfsMetadata *proxy;
g_type_init();
context = g_option_context_new ("<path> <key> <value> - set metadata");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("option parsing failed: %s\n", error->message);
return 1;
}
if (argc < 2)
{
g_printerr ("no path specified\n");
return 1;
}
path = argv[1];
if (argc < 3)
{
g_printerr ("no key specified\n");
return 1;
}
key = argv[2];
if (!list && !unset && argc != 4)
{
g_print ("No value specified\n");
return 1;
}
if (treename)
{
tree = meta_tree_lookup_by_name (treename, TRUE);
if (tree)
tree_path = g_strdup (path);
if (tree == NULL)
{
g_printerr ("can't open metadata tree %s\n", path);
return 1;
}
}
else
{
lookup = meta_lookup_cache_new ();
if (g_lstat (path, &statbuf) != 0)
{
g_printerr ("can't find file %s\n", path);
return 1;
}
tree = meta_lookup_cache_lookup_path (lookup,
path,
statbuf.st_dev,
TRUE,
&tree_path);
meta_lookup_cache_free (lookup);
if (tree == NULL)
{
g_printerr ("can't open metadata tree for file %s\n", path);
return 1;
}
}
proxy = NULL;
if (use_dbus)
{
proxy = gvfs_metadata_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
G_VFS_DBUS_METADATA_NAME,
G_VFS_DBUS_METADATA_PATH,
NULL,
&error);
if (proxy == NULL)
{
g_printerr ("Unable to connect to dbus: %s (%s, %d)\n",
error->message, g_quark_to_string (error->domain), error->code);
g_error_free (error);
return 1;
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (proxy), 1000*30);
}
if (unset)
{
if (use_dbus)
{
metatreefile = meta_tree_get_filename (tree);
if (! gvfs_metadata_call_unset_sync (proxy,
metatreefile,
tree_path,
key,
NULL,
&error))
{
g_printerr ("Unset error: %s (%s, %d)\n",
error->message, g_quark_to_string (error->domain), error->code);
return 1;
}
}
else
{
if (!meta_tree_unset (tree, tree_path, key))
{
g_printerr ("Unable to unset key\n");
return 1;
}
}
}
else if (list)
{
if (use_dbus)
{
char **strv;
GVariantBuilder *builder;
metatreefile = meta_tree_get_filename (tree);
strv = &argv[3];
builder = g_variant_builder_new (G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (builder, "{sv}", key, g_variant_new_strv ((const gchar * const *) strv, -1));
if (! gvfs_metadata_call_set_sync (proxy,
metatreefile,
tree_path,
g_variant_builder_end (builder),
NULL,
&error))
{
g_printerr ("SetStringv error: %s (%s, %d)\n",
error->message, g_quark_to_string (error->domain), error->code);
return 1;
}
g_variant_builder_unref (builder);
}
else
{
if (!meta_tree_set_stringv (tree, tree_path, key, &argv[3]))
{
g_printerr ("Unable to set key\n");
return 1;
}
}
}
else
{
if (use_dbus)
{
GVariantBuilder *builder;
metatreefile = meta_tree_get_filename (tree);
builder = g_variant_builder_new (G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (builder, "{sv}", key, g_variant_new_string (argv[3]));
if (! gvfs_metadata_call_set_sync (proxy,
metatreefile,
tree_path,
g_variant_builder_end (builder),
NULL,
&error))
{
g_printerr ("SetString error: %s (%s, %d)\n",
error->message, g_quark_to_string (error->domain), error->code);
return 1;
}
g_variant_builder_unref (builder);
}
else
{
if (!meta_tree_set_string (tree, tree_path, key, argv[3]))
{
g_printerr ("Unable to set key\n");
return 1;
}
}
}
if (proxy)
g_object_unref (proxy);
return 0;
}
int
main (int argc, char **argv)
{
g_autoptr(EosUpdater) proxy = NULL;
g_autoptr(GError) error = NULL;
guint update_interval_days, randomized_delay_days;
g_autoptr(GOptionContext) context = NULL;
GOptionEntry entries[] = {
{ "force-update", 0, 0, G_OPTION_ARG_NONE, &force_update, "Force an update", NULL },
{ "from-volume", 0, 0, G_OPTION_ARG_STRING, &volume_path, "Poll for updates from the volume", "PATH" },
{ NULL }
};
GBusType bus_type = G_BUS_TYPE_SYSTEM;
gint dbus_timeout;
setlocale (LC_ALL, "");
context = g_option_context_new ("— Endless OS Automatic Updater");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_summary (context,
"Automatically poll for, fetch and apply "
"updates in the background. This drives the "
"state changes in the eos-updater service.");
if (!g_option_context_parse (context, &argc, &argv, &error))
{
warning (EOS_UPDATER_INVALID_ARGS_MSGID,
"Error parsing command line arguments: %s",
error->message);
return EXIT_INVALID_ARGUMENTS;
}
if (!read_config_file (get_config_file_path (),
&update_interval_days, &randomized_delay_days))
return EXIT_BAD_CONFIGURATION;
if (volume_path == NULL && !is_online ())
return EXIT_OK;
/* Always force an update if running with --from-volume; it doesn’t make
* sense not to. */
if (volume_path != NULL)
force_update = TRUE;
if (!force_update) {
if (!is_time_to_update (update_interval_days, randomized_delay_days)) {
info (EOS_UPDATER_NOT_TIME_MSGID,
"Less than %s since last update. Exiting",
INTERVAL_KEY);
return EXIT_OK;
}
}
main_loop = g_main_loop_new (NULL, FALSE);
if (should_listen_on_session_bus ())
bus_type = G_BUS_TYPE_SESSION;
proxy = eos_updater_proxy_new_for_bus_sync (bus_type,
G_DBUS_PROXY_FLAGS_NONE,
"com.endlessm.Updater",
"/com/endlessm/Updater",
NULL,
&error);
if (error) {
warning (EOS_UPDATER_DAEMON_ERROR_MSGID,
"Error getting EOS updater object: %s",
error->message);
should_exit_failure = TRUE;
goto out;
}
dbus_timeout = get_dbus_timeout ();
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (proxy), dbus_timeout);
g_signal_connect (proxy, "notify::state",
G_CALLBACK (on_state_changed_notify), NULL);
g_signal_connect (proxy, "notify::g-name-owner",
(GCallback) on_name_owner_changed, NULL);
g_idle_add (initial_poll_idle_func, proxy);
g_main_loop_run (main_loop);
out:
g_main_loop_unref (main_loop);
g_free (volume_path);
if (should_exit_failure) /* All paths setting this print an error message */
return EXIT_FAILED;
/* Update the stamp file since all configured steps have succeeded. */
update_stamp_file ((guint64) g_get_real_time () / G_USEC_PER_SEC,
update_interval_days, randomized_delay_days);
info (EOS_UPDATER_SUCCESS_MSGID,
"Updater finished successfully");
return EXIT_OK;
}
