Example #1
0
static void pk_backend_search_files_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
	gchar **vals, *search;
	gchar *query;
	sqlite3_stmt *stmt;
	PkInfoEnum ret;
	PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);

	pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
	pk_backend_job_set_percentage(job, 0);

	g_variant_get(params, "(t^a&s)", NULL, &vals);
	search = g_strjoinv("%", vals);

	query = sqlite3_mprintf("SELECT (p.name || ';' || p.ver || ';' || p.arch || ';' || r.repo), p.summary, "
							"p.full_name FROM filelist AS f NATURAL JOIN pkglist AS p NATURAL JOIN repos AS r "
							"WHERE f.filename LIKE '%%%q%%' GROUP BY f.full_name", search);

	if ((sqlite3_prepare_v2(job_data->db, query, -1, &stmt, NULL) == SQLITE_OK)) {
		/* Now we're ready to output all packages */
		while (sqlite3_step(stmt) == SQLITE_ROW) {
			ret = katja_pkg_is_installed((gchar *) sqlite3_column_text(stmt, 2));
			if ((ret == PK_INFO_ENUM_INSTALLED) || (ret == PK_INFO_ENUM_UPDATING)) {
				pk_backend_job_package(job, PK_INFO_ENUM_INSTALLED,
										(gchar *) sqlite3_column_text(stmt, 0),
										(gchar *) sqlite3_column_text(stmt, 1));
			} else if (ret == PK_INFO_ENUM_INSTALLING) {
				pk_backend_job_package(job, PK_INFO_ENUM_AVAILABLE,
										(gchar *) sqlite3_column_text(stmt, 0),
										(gchar *) sqlite3_column_text(stmt, 1));
			}
		}
		sqlite3_finalize(stmt);
	} else {
		pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
	}
	sqlite3_free(query);
	g_free(search);

	pk_backend_job_set_percentage(job, 100);
}
Example #2
0
FCITX_EXPORT_API
GPtrArray* fcitx_kbd_get_layouts(FcitxKbd* kbd)
{
    GError* error = NULL;
    GVariant* variant = g_dbus_proxy_call_sync(G_DBUS_PROXY(kbd),
                                               "GetLayouts",
                                               NULL,
                                               G_DBUS_CALL_FLAGS_NO_AUTO_START,
                                               -1,
                                               NULL,
                                               &error
                                              );

    GPtrArray* array = NULL;

    if (error) {
        g_warning("%s", error->message);
        g_error_free(error);
    } else if (variant) {
        array = g_ptr_array_new_with_free_func(fcitx_layout_item_free);
        GVariantIter *iter;
        gchar *layout, *kbdvariant, *name, *langcode;
        g_variant_get(variant, "(a(ssss))", &iter);
        while (g_variant_iter_next(iter, "(ssss)", &layout, &kbdvariant, &name, &langcode, NULL)) {
            FcitxLayoutItem* item = g_malloc0(sizeof(FcitxLayoutItem));
            item->layout = g_strdup(layout);
            item->variant = g_strdup(kbdvariant);
            item->name = g_strdup(name);
            item->langcode = g_strdup(langcode);
            g_ptr_array_add(array, item);
            g_free(name);
            g_free(kbdvariant);
            g_free(layout);
            g_free(langcode);
        }
        g_variant_iter_free(iter);
    }

    return array;
}
Example #3
0
static void
g_dbus_menu_group_start_ready (GObject      *source_object,
                               GAsyncResult *result,
                               gpointer      user_data)
{
  GDBusConnection *connection = G_DBUS_CONNECTION (source_object);
  GDBusMenuGroup *group = user_data;
  GVariant *reply;

  g_assert (group->state == GROUP_PENDING);

  reply = g_dbus_connection_call_finish (connection, result, NULL);

  if (group->active)
    {
      group->state = GROUP_ONLINE;

      /* If we receive no reply, just act like we got an empty reply. */
      if (reply)
        {
          GVariantIter *iter;
          GVariant *items;
          guint group_id;
          guint menu_id;

          g_variant_get (reply, "(a(uuaa{sv}))", &iter);
          while (g_variant_iter_loop (iter, "([email protected]{sv})", &group_id, &menu_id, &items))
            if (group_id == group->id)
              g_dbus_menu_group_changed (group, menu_id, 0, 0, items);
          g_variant_iter_free (iter);
        }
    }
  else
    g_dbus_menu_group_go_offline (group);

  if (reply)
    g_variant_unref (reply);

  g_dbus_menu_group_unref (group);
}
static void
cc_sharing_panel_get_host_name_fqdn_done (GDBusConnection *connection,
                                          GAsyncResult    *res,
                                          GetHostNameData *data)
{
  GError *error = NULL;
  GVariant *variant;
  const gchar *fqdn;

  variant = g_dbus_connection_call_finish (connection, res, &error);

  if (variant == NULL)
    {
      /* Avahi service may not be available */
      g_debug ("Error calling GetHostNameFqdn: %s", error->message);

      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        {
          gchar *hostname;

          hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->priv->hostname_entry));

          cc_sharing_panel_setup_label (data->panel, data->label, hostname);

          g_free (hostname);
        }

      g_free (data);
      g_error_free (error);
      return;
    }

  g_variant_get (variant, "(&s)", &fqdn);

  cc_sharing_panel_setup_label (data->panel, data->label, fqdn);

  g_variant_unref (variant);
  g_object_unref (connection);
  g_free (data);
}
Example #5
0
static void pk_backend_remove_packages_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
	gchar **pkg_tokens, **pkg_ids, *cmd_line;
	guint i;
	gdouble percent_step;
    gboolean allow_deps, autoremove;
	GError *err = NULL;
    PkBitfield transaction_flags = 0;

	g_variant_get(params, "(t^a&sbb)", &transaction_flags, &pkg_ids, &allow_deps, &autoremove);
 
	if (pk_bitfield_contain(transaction_flags, PK_TRANSACTION_FLAG_ENUM_SIMULATE)) {
		pk_backend_job_set_status(job, PK_STATUS_ENUM_DEP_RESOLVE);
	} else {
		pk_backend_job_set_status(job, PK_STATUS_ENUM_REMOVE);

		/* Add percent_step percents per removed package */
		percent_step = 100.0 / g_strv_length(pkg_ids);
		for (i = 0; pkg_ids[i]; i++) {
			pk_backend_job_set_percentage(job, percent_step * i);
			pkg_tokens = pk_package_id_split(pkg_ids[i]);
			cmd_line = g_strconcat("/sbin/removepkg ", pkg_tokens[PK_PACKAGE_ID_NAME], NULL);

			/* Pkgtools return always 0 */
			g_spawn_command_line_sync(cmd_line, NULL, NULL, NULL, &err);

			g_free(cmd_line);
			g_strfreev(pkg_tokens);

			if (err) {
				pk_backend_job_error_code(job, PK_ERROR_ENUM_PACKAGE_FAILED_TO_REMOVE, "%s", err->message);
				g_error_free(err);

				return;
			}

			pk_backend_job_set_percentage(job, 100);
		}
	}
}
Example #6
0
/* Called when a dbus method is called */
static void service_method_call (GDBusConnection *connection, const gchar *sender,
	const gchar *object_path, const gchar *interface_name, const gchar *method_name,
	GVariant *parameters, GDBusMethodInvocation *invocation, gpointer user_data)
{
	START_FUNC
	guint x, y;
	struct service *service=(struct service *)user_data;
	if (g_strcmp0(method_name, "show")==0) {
#ifdef AT_SPI
		view_show(service->view, NULL);
#else
		view_show(service->view);
#endif
	} else if (g_strcmp0(method_name, "move")==0) {
		g_variant_get(parameters, "(uu)", &x, &y);
		gtk_window_move(GTK_WINDOW(view_window_get(service->view)), x, y);
	} else if (g_strcmp0(method_name, "hide")==0) view_hide(service->view);
	else if (g_strcmp0(method_name, "terminate")==0) service->quit();
	else flo_error(_("Unknown dbus method called: <%s>"), method_name);
	g_dbus_method_invocation_return_value(invocation, NULL);
	END_FUNC
}
static void
service_name_owner_changed (GDBusConnection *connection,
			    const gchar *sender_name,
			    const gchar *object_path,
			    const gchar *interface_name,
			    const gchar *signal_name,
			    GVariant *parameters,
			    gpointer user_data)
{
	const gchar *object_name;
	const gchar *old_owner;
	const gchar *new_owner;
	GkdSecretService *self = user_data;

	/* A peer is connecting or disconnecting from the bus,
	 * remove any client info, when client gone.
	 */
	g_variant_get (parameters, "(&s&s&s)", &object_name, &old_owner, &new_owner);

	if (g_str_equal (new_owner, "") && object_name[0] == ':')
		g_hash_table_remove (self->clients, object_name);
}
Example #8
0
static guint
gtk_application_impl_dbus_inhibit (GtkApplicationImpl         *impl,
                                   GtkWindow                  *window,
                                   GtkApplicationInhibitFlags  flags,
                                   const gchar                *reason)
{
  GtkApplicationImplDBus *dbus = (GtkApplicationImplDBus *) impl;
  GVariant *res;
  GError *error = NULL;
  guint cookie;

  if (dbus->sm_proxy == NULL)
    return 0;

  res = g_dbus_proxy_call_sync (dbus->sm_proxy,
                                "Inhibit",
                                g_variant_new ("([email protected])",
                                               dbus->app_id,
                                               gtk_application_impl_dbus_get_window_system_id (dbus, window),
                                               reason,
                                               flags),
                                G_DBUS_CALL_FLAGS_NONE,
                                G_MAXINT,
                                NULL,
                                &error);

 if (error)
    {
      g_warning ("Calling Inhibit failed: %s", error->message);
      g_error_free (error);
      return 0;
    }

  g_variant_get (res, "(u)", &cookie);
  g_variant_unref (res);

  return cookie;

}
Example #9
0
static void set_time(GVariant *parameters, GDBusMethodInvocation *invocation, const gchar *caller) {
	gboolean user_interaction;
	struct method_call_data data;
	GVariant *variant;
	gboolean ntp_active;

	data.set_time.request_time = g_get_monotonic_time();
	g_variant_get(parameters, "(xbb)", &data.set_time.requested_time, &data.set_time.relative,
		      &user_interaction);

	variant = get_ntp_active();
	ntp_active = g_variant_get_boolean(variant);
	g_variant_unref(variant);

	if (ntp_active) {
		return_error(invocation, G_DBUS_ERROR_FAILED, "NTP unit is active");
		return;
	}

	start_auth_check(caller, POLKIT_ACTION_SET_TIME, user_interaction, invocation,
			 finish_set_time, &data);
}
Example #10
0
static void
_method_cb (GDBusConnection       *connection,
            const gchar           *sender,
            const gchar           *object_path,
            const gchar           *interface_name,
            const gchar           *method_name,
            GVariant              *parameters,
            GDBusMethodInvocation *invocation,
            DbusInput             *self)
{

  if (g_strcmp0 (method_name, "ControlKey") == 0)
    {
      guint keyflag;
      ClutterEvent *event;
      ClutterKeyEvent *kevent;

      g_variant_get (parameters, "(u)", &keyflag);

      event = clutter_event_new (CLUTTER_KEY_PRESS);
      kevent = (ClutterKeyEvent *)event;

      kevent->flags = 0;
      kevent->source = NULL;
      kevent->stage = CLUTTER_STAGE (self->stage);
      kevent->keyval = keyflag;
      kevent->time = time (NULL);

      /* KEY PRESS */
      clutter_event_put (event);
      /* KEY RELEASE */
      kevent->type = CLUTTER_KEY_RELEASE;
      clutter_event_put (event);

      clutter_event_free (event);
    }

  g_dbus_method_invocation_return_value (invocation, NULL);
}
Example #11
0
}

int CtSgwGetAppStatus(CtSgwAppStatus_t *app_status)
{
	GDBusConnection *connection;
	GDBusProxy *proxy;
	GError *error = NULL;
	GVariant *result;
	gchar *str;
	gint ret = 0;

	connection = g_bus_get_sync (DBUS_TYPE, NULL, &error);
	g_assert_no_error(error);

	proxy = g_dbus_proxy_new_sync(connection,
								  G_DBUS_PROXY_FLAGS_NONE,
								  NULL,					  /* GDBusInterfaceInfo */
								  "com.ctc.appframework1", /* name */
								  "/com/ctc/appframework1", /* object path */
								  "com.ctc.appframework1.AppAgent",		  /* interface */
								  NULL, /* GCancellable */
								  &error);
	g_assert_no_error(error);

	result = g_dbus_proxy_call_sync(proxy,
								"GetStatus",
								g_variant_new("(s)", app_status->name),
								G_DBUS_CALL_FLAGS_NONE,
								-1,
								NULL,
								&error);
	g_assert(result != NULL);
	g_variant_get(result, "(s)", &str);
	g_strlcpy(app_status->state, str, BUFLEN_16);

	g_variant_unref (result);
	g_object_unref (proxy);
	g_object_unref (connection);
static void backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
    PkBitfield filters;
    g_variant_get(params, "(t)", &filters);

    pk_backend_job_set_allow_cancel(job, true);

    AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
    if (!apt->init()) {
        g_debug("Failed to create apt cache");
        return;
    }

    pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);

    PkgList updates;
    PkgList blocked;
    updates = apt->getUpdates(blocked);

    apt->emitUpdates(updates, filters);
    apt->emitPackages(blocked, filters, PK_INFO_ENUM_BLOCKED);
}
static void
name_owner_changed (GDBusConnection *connection,
                    const gchar     *sender_name,
                    const gchar     *object_path,
                    const gchar     *interface_name,
                    const gchar     *signal_name,
                    GVariant        *parameters,
                    gpointer         user_data)
{
  NamespaceWatcher *watcher = user_data;
  const gchar *name;
  const gchar *old_owner;
  const gchar *new_owner;

  g_variant_get (parameters, "(&s&s&s)", &name, &old_owner, &new_owner);

  if (old_owner[0] != '\0')
    namespace_watcher_name_vanished (watcher, name);

  if (new_owner[0] != '\0')
    namespace_watcher_name_appeared (watcher, name, new_owner);
}
static void backend_search_groups_thread(PkBackendJob *job, GVariant *params, gpointer user_data)
{
    gchar **search;
    PkBitfield filters;

    g_variant_get(params, "(t^a&s)",
                  &filters,
                  &search);

    AptIntf *apt = static_cast<AptIntf*>(pk_backend_job_get_user_data(job));
    if (!apt->init()) {
        g_debug("Failed to create apt cache");
        return;
    }

    // It's faster to emit the packages here rather than in the matching part
    PkgList output;
    output = apt->getPackagesFromGroup(search);
    apt->emitPackages(output, filters);

    pk_backend_job_set_percentage(job, 100);
}
Example #15
0
static void
ol_lyric_source_download_complete_cb (OlLyricSource *source,
                                      GVariant *parameters)
{
  OlLyricSourceTask *task;
  int taskid;
  int status;
  GVariantIter *iter;
  gchar *content = NULL;
  gsize len = 0;
  g_variant_get (parameters, "(iiay)", &taskid, &status, &iter);
  task = ol_lyric_source_get_download_task (source, taskid);
  if (task == NULL)
  {
    ol_errorf ("Download task %d not exist\n", taskid);
  }
  else if (status < 0 || status > OL_LYRIC_SOURCE_STATUS_FALIURE)
  {
    ol_errorf ("Invalid download status %d\n", status);
  }
  else
  {
    len = g_variant_iter_n_children (iter);
    content = g_new (gchar, len + 1);
    gsize i = 0;
    while (g_variant_iter_loop (iter, "y", &content[i]))
      i++;
    content[len] = '\0';
    g_signal_emit (G_OBJECT (task),
                   _download_signals[DOWNLOAD_SIGNAL_COMPLETE],
                   0,
                   status,
                   content,
                   (guint) len);
    g_free (content);
  }
  g_variant_iter_free (iter);
  ol_lyric_source_remove_download_task (source, taskid);
}
Example #16
0
static gboolean
ephy_history_service_execute_set_url_zoom_level (EphyHistoryService *self,
                                                 GVariant *variant,
                                                 gpointer *result)
{
  char *url_string;
  double zoom_level;
  EphyHistoryHost *host;

  g_variant_get (variant, "(sd)", &url_string, &zoom_level);

  host = ephy_history_service_get_host_row_from_url (self, url_string);
  g_free (url_string);

  g_return_val_if_fail (host != NULL, FALSE);

  host->zoom_level = zoom_level;
  ephy_history_service_update_host_row (self, host);
  ephy_history_service_schedule_commit (self);

  return TRUE;
}
Example #17
0
static gboolean
method_confplayer(GdbusMedia     *object,
                               GDBusMethodInvocation *invocation,
                               GVariant              *in_arg,
                               gpointer               user_data)
{
  gchar out_buf[BUF_LEN];
  guint in_arg1, in_arg2, in_arg3;

  /** Get the input parameters */
  g_variant_get(in_arg, "(uuu)", &in_arg1, &in_arg2, &in_arg3);

  DBG_LOG ("method confplayer, in arg: %d, %d, %d.\n",in_arg1, in_arg2, in_arg3);
  if (NULL != method_cb.conf_cb)
    method_cb.conf_cb (in_arg1, in_arg2, in_arg3, out_buf, user_data);
  else
    g_strlcpy (out_buf, "err no cb", BUF_LEN);

  gdbus_media_complete_open_player(object, invocation, out_buf);

  return TRUE;
}
Example #18
0
GIcon *
g_vfs_icon_deserialize (GVariant *value)
{
  const gchar *mount_spec_str;
  const gchar *id_str;
  GMountSpec *mount_spec;
  GIcon *icon;

  if (!g_variant_is_of_type (value, G_VARIANT_TYPE ("(ss)")))
    return NULL;

  g_variant_get (value, "(&s&s)", &mount_spec_str, &id_str);

  mount_spec = g_mount_spec_new_from_string (mount_spec_str, NULL);
  if (mount_spec == NULL)
    return NULL;

  icon = g_vfs_icon_new (mount_spec, id_str);
  g_mount_spec_unref (mount_spec);

  return icon;
}
Example #19
0
  static void Service(cDBusObject *Object, GVariant *Parameters, GDBusMethodInvocation *Invocation)
  {
    gboolean reply = FALSE;
    const char *pluginName = Object->Path();
    const char *id = NULL;
    const char *data = NULL;
    g_variant_get(Parameters, "(&s&s)", &id, &data);

    if ((pluginName != NULL) && (id != NULL)) {
       if ((strlen(pluginName) > 9) && (strncmp(pluginName, "/Plugins/", 9) == 0)) {
          cPlugin *plugin = cPluginManager::GetPlugin(pluginName + 9);
          if (plugin != NULL) {
             if (data == NULL)
                data = "";
             if (plugin->Service(id, (void*)data))
                reply = TRUE;
             }
          }
       }

    g_dbus_method_invocation_return_value(Invocation, g_variant_new("(b)", reply));
  }
static void on_response_sap_disconnect(GObject *source_object, GAsyncResult *res, gpointer user_data)
{
	GError *error = NULL;
	GDBusConnection *conn = NULL;
	GVariant *dbus_result;

	struct tapi_resp_data *evt_cb_data = user_data;
	TelSimSapResultCode_t result = TAPI_SIM_SAP_RESULT_CODE_OK;

	dbg("Func Entrance");

	conn = G_DBUS_CONNECTION (source_object);
	dbus_result = g_dbus_connection_call_finish(conn, res, &error);

	g_variant_get(dbus_result, "(i)", &result);

	if (evt_cb_data->cb_fn) {
		evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
	}

	free(evt_cb_data);
}
Example #21
0
static gboolean
authorize_method (Daemon *daemon,
                  GDBusMethodInvocation *invocation,
                  gboolean *out_is_authorized,
                  GCancellable *cancellable,
                  GError **error)
{
  const char *sender = g_dbus_method_invocation_get_sender (invocation);
  gs_unref_variant GVariant *reply = NULL;
  guint32 uid = 42;

  reply = g_dbus_proxy_call_sync (daemon->system_bus_proxy, "org.freedesktop.DBus.GetConnectionUnixUser",
                                  g_variant_new ("(s)", sender), 0, -1,
                                  cancellable, error);
  if (reply == NULL)
    return FALSE;

  g_variant_get (reply, "(u)", &uid);

  *out_is_authorized = (uid == 0 || auth_uid_is_wheel (uid));
  return TRUE;
}
static gboolean
get_caller_pid (GDBusMethodInvocation *context,
                GPid                  *pid)
{
        GVariant      *reply;
        GError        *error;
        guint32        pid_as_int;

        error = NULL;
        reply = g_dbus_connection_call_sync (g_dbus_method_invocation_get_connection (context),
                                             "org.freedesktop.DBus",
                                             "/org/freedesktop/DBus",
                                             "org.freedesktop.DBus",
                                             "GetConnectionUnixProcessID",
                                             g_variant_new ("(s)",
                                                            g_dbus_method_invocation_get_sender (context)),
                                             G_VARIANT_TYPE ("(u)"),
                                             G_DBUS_CALL_FLAGS_NONE,
                                             -1,
                                             NULL,
                                             &error);

        if (reply == NULL) {
                g_warning ("Could not talk to message bus to find uid of sender %s: %s",
                           g_dbus_method_invocation_get_sender (context),
                           error->message);
                g_error_free (error);

                return FALSE;
        }

        g_variant_get (reply, "(u)", &pid_as_int);
        *pid = pid_as_int;

        g_variant_unref (reply);

        return TRUE;
}
void
LauncherEntryRemoteModel::OnDBusNameOwnerChanged(GDBusConnection* connection,
                                                 const gchar* sender_name,
                                                 const gchar* object_path,
                                                 const gchar* interface_name,
                                                 const gchar* signal_name,
                                                 GVariant* parameters,
                                                 gpointer user_data)
{
  auto self = static_cast<LauncherEntryRemoteModel*>(user_data);

  if (!parameters || self->_entries_by_uri.empty())
    return;

  glib::String name, before, after;
  g_variant_get(parameters, "(sss)", &name, &before, &after);

  if (!after || after.Str().empty())
  {
    // Name gone, find and destroy LauncherEntryRemote
    std::vector<LauncherEntryRemote::Ptr> to_rm;

    for (auto it = self->_entries_by_uri.begin(); it != self->_entries_by_uri.end(); ++it)
    {
      auto entry = it->second;

      if (entry->DBusName() == name.Str())
      {
        to_rm.push_back(entry);
      }
    }

    for (auto entry : to_rm)
    {
      self->RemoveEntry(entry);
    }
  }
}
Example #24
0
static void
media_player_key_pressed(GDBusProxy *proxy,
			  const gchar *sender,
			  const gchar *signal,
			  GVariant *parameters,
			  XmrMMKeysPlugin *plugin)
{
	gchar *key;
	gchar *application;

	g_variant_get(parameters, "(ss)", &application, &key);

	if (g_strcmp0(application, PACKAGE))
	{
		xmr_debug("got media player key signal for unexpected application '%s'", application);
		return;
	}

	if (g_strcmp0(key, "Play") == 0 ||
		g_strcmp0(key, "Pause") == 0)
	{
		if (xmr_window_playing(plugin->window))
			xmr_window_pause(plugin->window);
		else
			xmr_window_play(plugin->window);
	}
	else if (g_strcmp0(key, "Stop") == 0)
	{
		xmr_window_pause(plugin->window);
	}
	else if (g_strcmp0(key, "Next") == 0)
	{
		xmr_window_play_next(plugin->window);
	}

	g_free(key);
	g_free(application);
}
Example #25
0
QVariantList QGSettings::choices(const QString &key) const
{
    Q_D(const QGSettings);

    QVariantList choices;

    if (!d->valid)
        return choices;

    gchar *keyName = Utils::fromCamelCase(key);
    GSettingsSchemaKey *schemaKey = g_settings_schema_get_key(d->schema, keyName);
    GVariant *range = g_settings_schema_key_get_range(schemaKey);
    g_settings_schema_key_unref(schemaKey);
    g_free(keyName);

    if (!range)
        return choices;

    const gchar *type;
    GVariant *value;
    g_variant_get(range, "(&sv)", &type, &value);

    if (g_str_equal(type, "enum")) {
        GVariantIter iter;
        g_variant_iter_init(&iter, value);

        GVariant *child;
        while ((child = g_variant_iter_next_value(&iter))) {
            choices.append(Utils::toQVariant(child));
            g_variant_unref(child);
        }
    }

    g_variant_unref(value);
    g_variant_unref(range);

    return choices;
}
Example #26
0
/**
 * Get information on the proxy.
 */
static GDBusNodeInfo *
g_dbus_proxy_get_node_info (GDBusProxy *proxy)
{
  GError *error;                // Error returned by various functions.
  GVariant *response;           // The response from the proxy call.
  GDBusNodeInfo *info;          // Information on the node.
  const gchar *xml;             // XML code for the proxy interface.

  // Get the introspection data
  error = NULL;
  response = 
    g_dbus_proxy_call_sync (proxy, 
                            "org.freedesktop.DBus.Introspectable.Introspect",
                            NULL, 
                            G_DBUS_CALL_FLAGS_NONE,
                            -1,
                            NULL,
                            &error);
  if (response == NULL)
    {
      return NULL;
    } // if (response == NULL)

  // Get the XML from the introspection data
  g_variant_get (response, "(&s)", &xml);

  // Build an object that lets us explore the introspection data.
  error = NULL;
  info = g_dbus_node_info_new_for_xml (xml, &error);
  g_variant_unref (response);
  if (info == NULL)
    {
      return NULL;
    } // if (info == NULL)

  // And return that object
  return info;
} // g_dbus_proxy_get_node_info
static void
rb_metadata_dbus_load (GVariant *parameters,
		       GDBusMethodInvocation *invocation,
		       ServiceData *svc)
{
	const char *uri;
	GError *error = NULL;
	GVariant *response;
	const char *nothing[] = { NULL };
	char **missing_plugins = NULL;
	char **plugin_descriptions = NULL;
	const char *mediatype;

	g_variant_get (parameters, "(&s)", &uri);

	rb_debug ("loading metadata from %s", uri);
	rb_metadata_load (svc->metadata, uri, &error);
	mediatype = rb_metadata_get_media_type (svc->metadata);
	rb_debug ("metadata load finished (type %s)", mediatype);

	rb_metadata_get_missing_plugins (svc->metadata, &missing_plugins, &plugin_descriptions);

	response = g_variant_new ("(^as^asbbbsbisa{iv})",
				  missing_plugins ? missing_plugins : (char **)nothing,
				  plugin_descriptions ? plugin_descriptions : (char **)nothing,
				  rb_metadata_has_audio (svc->metadata),
				  rb_metadata_has_video (svc->metadata),
				  rb_metadata_has_other_data (svc->metadata),
				  mediatype ? mediatype : "",
				  (error == NULL),
				  (error != NULL ? error->code : 0),
				  (error != NULL ? error->message : ""),
				  rb_metadata_dbus_get_variant_builder (svc->metadata));
	g_strfreev (missing_plugins);
	g_strfreev (plugin_descriptions);

	g_dbus_method_invocation_return_value (invocation, response);
}
static void
on_properties_changed_check_lock(GDBusProxy *proxy, GVariant *changed, const char *const *invalidated, gpointer user_data)
{
    struct app *app = user_data;
    gboolean lost_lock = FALSE;

    if (g_variant_n_children(changed) > 0) {
        GVariantIter *itr;
        const char *prop;
        GVariant *value;

        g_variant_get(changed, "a{sv}", &itr);
        while (g_variant_iter_loop(itr, "{&sv}", &prop, &value)) {
            if (strcmp(prop, "WriteLocked") == 0) {
                if (!g_variant_get_boolean(value))
                    lost_lock = TRUE;
                break;
            }
        }
        g_variant_iter_free(itr);
    }

    if (invalidated[0] != NULL) {
        const char * const *itr;
        for (itr = invalidated; *itr != NULL; itr++) {
            if (strcmp(*itr, "WriteLocked") == 0) {
                lost_lock = TRUE;
                break;
            }
        }
    }

    if (lost_lock) {
        fputs("Lost lock, exit.\n", stderr);
        app->ret = EXIT_FAILURE;
        g_main_loop_quit(app->loop);
    }
}
/**
 * tracker_miner_manager_is_active:
 * @manager: a #TrackerMinerManager
 * @miner: miner reference
 *
 * Returns the miner's current activity.
 *
 * Returns: %TRUE if the @miner is active, otherwise %FALSE.
 *
 * Since: 0.8
 **/
gboolean
tracker_miner_manager_is_active (TrackerMinerManager *manager,
                                 const gchar         *miner)
{
	TrackerMinerManagerPrivate *priv;
	GError *error = NULL;
	gboolean active = FALSE;
	GVariant *v;

	g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE);
	g_return_val_if_fail (miner != NULL, FALSE);

	priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);

	v = g_dbus_connection_call_sync (priv->connection,
	                                 "org.freedesktop.DBus",
	                                 "/org/freedesktop/DBus",
	                                 "org.freedesktop.DBus",
	                                 "NameHasOwner",
	                                 g_variant_new ("(s)", miner),
	                                 (GVariantType *) "(b)",
	                                 G_DBUS_CALL_FLAGS_NONE,
	                                 -1,
	                                 NULL,
	                                 &error);

	if (error) {
		g_critical ("Could not check whether miner '%s' is currently active: %s",
		            miner, error ? error->message : "no error given");
		g_error_free (error);
		return FALSE;
	}

	g_variant_get (v, "(b)", &active);
	g_variant_unref (v);

	return active;
}
Example #30
0
static gboolean
polkit_system_bus_name_exists_sync (PolkitSubject   *subject,
                                    GCancellable    *cancellable,
                                    GError         **error)
{
  PolkitSystemBusName *name = POLKIT_SYSTEM_BUS_NAME (subject);
  GDBusConnection *connection;
  GVariant *result;
  gboolean ret;

  ret = FALSE;

  connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, cancellable, error);
  if (connection == NULL)
    goto out;

  result = g_dbus_connection_call_sync (connection,
                                        "org.freedesktop.DBus",   /* name */
                                        "/org/freedesktop/DBus",  /* object path */
                                        "org.freedesktop.DBus",   /* interface name */
                                        "NameHasOwner",           /* method */
                                        g_variant_new ("(s)", name->name),
                                        G_VARIANT_TYPE ("(b)"),
                                        G_DBUS_CALL_FLAGS_NONE,
                                        -1,
                                        cancellable,
                                        error);
  if (result == NULL)
    goto out;

  g_variant_get (result, "(b)", &ret);
  g_variant_unref (result);

 out:
  if (connection != NULL)
    g_object_unref (connection);
  return ret;
}