static gboolean
cdma_poll_cb (gpointer user_data)
{
	CdmaDeviceInfo *info = user_data;

	/* Kick off calls to get registration state and signal quality */
	if (!info->skip_reg_poll) {
		dbus_g_proxy_begin_call (info->cdma_proxy, "GetRegistrationState",
		                         reg_state_reply, info, NULL,
		                         G_TYPE_INVALID);
		info->skip_reg_poll = FALSE;
	}

	if (!info->skip_signal_poll) {
		dbus_g_proxy_begin_call (info->cdma_proxy, "GetSignalQuality",
		                         signal_reply, info, NULL,
		                         G_TYPE_INVALID);
		info->skip_signal_poll = FALSE;
	}

	dbus_g_proxy_begin_call (info->cdma_proxy, "GetServingSystem",
	                         serving_system_reply, info, NULL,
	                         G_TYPE_INVALID);

	return TRUE;  /* keep running until we're told to stop */
}
Esempio n. 2
0
static void
nm_supplicant_interface_add_to_supplicant (NMSupplicantInterface * self,
                                           gboolean get_only)
{
	NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
	NMSupplicantInfo *info;
	DBusGProxy *proxy;
	DBusGProxyCall *call;

	proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr),
	                                   WPAS_DBUS_SERVICE,
	                                   WPAS_DBUS_PATH,
	                                   WPAS_DBUS_INTERFACE);
	info = nm_supplicant_info_new (self, proxy, priv->other_pcalls);

	if (get_only) {
		call = dbus_g_proxy_begin_call (proxy, "getInterface",
		                                nm_supplicant_interface_add_cb,
		                                info,
		                                nm_supplicant_info_destroy,
		                                G_TYPE_STRING, priv->dev,
		                                G_TYPE_INVALID);
	} else {
		GHashTable *hash = g_hash_table_new (g_str_hash, g_str_equal);
		GValue *driver;

		driver = g_new0 (GValue, 1);
		g_value_init (driver, G_TYPE_STRING);
		g_value_set_string (driver, priv->is_wireless ? "wext" : "wired");
		g_hash_table_insert (hash, "driver", driver);

		call = dbus_g_proxy_begin_call (proxy, "addInterface",
		                                nm_supplicant_interface_add_cb,
		                                info,
		                                nm_supplicant_info_destroy,
		                                G_TYPE_STRING, priv->dev,
		                                DBUS_TYPE_G_MAP_OF_VARIANT, hash,
		                                G_TYPE_INVALID);

		g_value_unset (driver);
		g_free (driver);
		g_hash_table_destroy (hash);
	}

	g_object_unref (proxy);

	nm_supplicant_info_set_call (info, call);
}
Esempio n. 3
0
void
nm_supplicant_interface_disconnect (NMSupplicantInterface * self)
{
	NMSupplicantInterfacePrivate *priv;

	g_return_if_fail (NM_IS_SUPPLICANT_INTERFACE (self));

	priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);

	/* Clear and cancel all pending calls related to a prior
	 * connection attempt.
	 */
	cancel_all_callbacks (priv->assoc_pcalls);

	/* Don't do anything if there is no connection to the supplicant yet. */
	if (!priv->iface_proxy)
		return;

	/* Don't try to disconnect if the supplicant interface is already
	 * disconnected.
	 */
	if (priv->con_state == NM_SUPPLICANT_INTERFACE_CON_STATE_DISCONNECTED
	    || priv->con_state == NM_SUPPLICANT_INTERFACE_CON_STATE_INACTIVE) {
		if (priv->net_proxy) {
			g_object_unref (priv->net_proxy);
			priv->net_proxy = NULL;
		}

		return;
	}

	/* Remove any network that was added by NetworkManager */
	if (priv->net_proxy) {
		dbus_g_proxy_begin_call (priv->iface_proxy, "removeNetwork",
		                         remove_network_cb,
		                         NULL, NULL,
		                         DBUS_TYPE_G_OBJECT_PATH, dbus_g_proxy_get_path (priv->net_proxy),
		                         G_TYPE_INVALID);

		g_object_unref (priv->net_proxy);
		priv->net_proxy = NULL;
	}

	dbus_g_proxy_begin_call (priv->iface_proxy, "disconnect",
	                         disconnect_cb,
	                         NULL, NULL,
	                         G_TYPE_INVALID);
}
static void
set_ap_scan_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
{
	NMSupplicantInfo *info = (NMSupplicantInfo *) user_data;
	NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (info->interface);
	GError *err = NULL;
	DBusGProxyCall *call;
	GHashTable *config_hash;

	if (!dbus_g_proxy_end_call (proxy, call_id, &err, G_TYPE_INVALID)) {
		nm_log_warn (LOGD_SUPPLICANT, "Couldn't send AP scan mode to the supplicant interface: %s.",
		             err->message);
		emit_error_helper (info->interface, err);
		g_error_free (err);
		return;
	}

	nm_log_info (LOGD_SUPPLICANT, "Config: set interface ap_scan to %d",
	             nm_supplicant_config_get_ap_scan (priv->cfg));

	info = nm_supplicant_info_new (info->interface, priv->iface_proxy, info->store);
	config_hash = nm_supplicant_config_get_hash (priv->cfg);
	call = dbus_g_proxy_begin_call (priv->iface_proxy, "AddNetwork",
	                                add_network_cb,
	                                info,
	                                nm_supplicant_info_destroy,
	                                DBUS_TYPE_G_MAP_OF_VARIANT, config_hash,
	                                G_TYPE_INVALID);
	g_hash_table_destroy (config_hash);
	nm_supplicant_info_set_call (info, call);
}
static void
request_bss_properties (NMSupplicantInterface *self,
                        GPtrArray *paths)
{
	NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
	int i;

	/* Fire off a "properties" call for each returned BSSID */
	for (i = 0; i < paths->len; i++) {
		NMSupplicantInfo *info;
		DBusGProxy *proxy;
		DBusGProxyCall *call;

		proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr),
			                               WPAS_DBUS_SERVICE,
			                               g_ptr_array_index (paths, i),
			                               DBUS_INTERFACE_PROPERTIES);
		info = nm_supplicant_info_new (self, proxy, priv->other_pcalls);
		call = dbus_g_proxy_begin_call (proxy, "GetAll",
			                            bssid_properties_cb,
			                            info,
			                            nm_supplicant_info_destroy,
			                            G_TYPE_STRING, WPAS_DBUS_IFACE_BSS,
			                            G_TYPE_INVALID);
		nm_supplicant_info_set_call (info, call);
		g_object_unref (proxy);
	}
}
Esempio n. 6
0
static gboolean
request_scan_results (gpointer user_data)
{
	NMSupplicantInterface *self = NM_SUPPLICANT_INTERFACE (user_data);
	NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
	NMSupplicantInfo *info;
	DBusGProxyCall *call;
	GTimeVal cur_time;

	priv->scan_results_timeout = 0;

	g_return_val_if_fail (priv->iface_proxy != NULL, FALSE);

	info = nm_supplicant_info_new (self, priv->iface_proxy, priv->other_pcalls);
	call = dbus_g_proxy_begin_call (priv->iface_proxy, "scanResults",
	                                scan_results_cb, 
	                                info,
	                                nm_supplicant_info_destroy,
	                                G_TYPE_INVALID);
	nm_supplicant_info_set_call (info, call);

	g_get_current_time (&cur_time);
	priv->last_scan = cur_time.tv_sec;
	return FALSE;
}
Esempio n. 7
0
static void
call_set_blobs (NMSupplicantInfo *info, GHashTable *orig_blobs)
{
	NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (info->interface);
	DBusGProxyCall *call;
	GHashTable *blobs;

	blobs = g_hash_table_new_full (g_str_hash, g_str_equal,
	                               (GDestroyNotify) g_free,
	                               (GDestroyNotify) blob_free);
	if (!blobs) {
		const char *msg = "Not enough memory to create blob table.";

		nm_log_warn (LOGD_SUPPLICANT, "%s", msg);
		g_signal_emit (info->interface,
		               nm_supplicant_interface_signals[CONNECTION_ERROR],
		               0, "SendBlobError", msg);
		return;
	}

	g_hash_table_foreach (orig_blobs, (GHFunc) convert_blob, blobs);

	call = dbus_g_proxy_begin_call (priv->iface_proxy, "setBlobs",
	                                set_blobs_cb,
	                                info,
	                                nm_supplicant_info_destroy,
	                                DBUS_TYPE_G_MAP_OF_VARIANT, blobs,
	                                G_TYPE_INVALID);
	nm_supplicant_info_set_call (info, call);
	g_hash_table_destroy (blobs);
}
Esempio n. 8
0
static void
set_network_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
{
	NMSupplicantInfo *info = (NMSupplicantInfo *) user_data;
	NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (info->interface);
	GError *err = NULL;
	guint tmp;

	if (!dbus_g_proxy_end_call (proxy, call_id, &err, G_TYPE_UINT, &tmp, G_TYPE_INVALID)) {
		nm_log_warn (LOGD_SUPPLICANT, "Couldn't set network config: %s.", err->message);
		emit_error_helper (info->interface, err);
		g_error_free (err);
	} else {
		DBusGProxyCall *call;

		info = nm_supplicant_info_new (info->interface, priv->iface_proxy, priv->assoc_pcalls);
		call = dbus_g_proxy_begin_call (priv->iface_proxy, "selectNetwork",
		                                select_network_cb,
		                                info,
		                                nm_supplicant_info_destroy,
		                                DBUS_TYPE_G_OBJECT_PATH, dbus_g_proxy_get_path (proxy),
		                                G_TYPE_INVALID);
		nm_supplicant_info_set_call (info, call);
	}
}
gboolean
nm_supplicant_interface_request_scan (NMSupplicantInterface * self)
{
	NMSupplicantInterfacePrivate *priv;
	NMSupplicantInfo *info;
	DBusGProxyCall *call;
	GHashTable *hash;

	g_return_val_if_fail (NM_IS_SUPPLICANT_INTERFACE (self), FALSE);

	priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);

	/* Scan parameters */
	hash = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, destroy_gvalue);
	g_hash_table_insert (hash, "Type", string_to_gvalue ("active"));

	info = nm_supplicant_info_new (self, priv->iface_proxy, priv->other_pcalls);
	call = dbus_g_proxy_begin_call (priv->iface_proxy, "Scan",
	                                scan_request_cb,
	                                info,
	                                nm_supplicant_info_destroy,
	                                DBUS_TYPE_G_MAP_OF_VARIANT, hash,
	                                G_TYPE_INVALID);
	g_hash_table_destroy (hash);
	nm_supplicant_info_set_call (info, call);

	return call != NULL;
}
Esempio n. 10
0
/**
 * nm_device_wifi_request_scan_simple:
 * @device: a #NMDeviceWifi
 * @callback: (scope async) (allow-none): the function to call when the call is done
 * @user_data: (closure): user data to pass to the callback function
 *
 * Request NM to scan for access points on the #NMDeviceWifi. This function only
 * instructs NM to perform scanning. Use nm_device_wifi_get_access_points()
 * to get available access points.
 **/
void
nm_device_wifi_request_scan_simple (NMDeviceWifi *device,
                                    NMDeviceWifiRequestScanFn callback,
                                    gpointer user_data)
{
	RequestScanInfo *info;
	GHashTable *options;
	NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (device);

	g_return_if_fail (NM_IS_DEVICE_WIFI (device));

	/* If a scan is in progress, just return */
	if (priv->scan_call)
		return;

	options = g_hash_table_new (g_str_hash, g_str_equal);

	info = g_slice_new0 (RequestScanInfo);
	info->device = device;
	info->callback = callback;
	info->user_data = user_data;

	priv->scan_info = info;
	priv->scan_call = dbus_g_proxy_begin_call (NM_DEVICE_WIFI_GET_PRIVATE (device)->proxy, "RequestScan",
	                                           request_scan_cb, info, NULL,
	                                           DBUS_TYPE_G_MAP_OF_VARIANT, options,
	                                           G_TYPE_INVALID);

	g_hash_table_unref (options);
}
Esempio n. 11
0
static void
add_device_from_path (char                *device_path,
                      GUPnPNetworkManager *manager)
{
        NMDevice *nm_device;

        nm_device = nm_device_new (manager, device_path);

        manager->priv->nm_devices = g_list_append (manager->priv->nm_devices,
                                                   nm_device);

        dbus_g_proxy_add_signal (nm_device->device_proxy,
                                 "StateChanged",
                                 G_TYPE_UINT,
                                 G_TYPE_UINT,
                                 G_TYPE_UINT,
                                 G_TYPE_INVALID);

        dbus_g_proxy_connect_signal (nm_device->device_proxy,
                                     "StateChanged",
                                     G_CALLBACK (on_device_state_changed),
                                     nm_device,
                                     NULL);

        dbus_g_proxy_begin_call (nm_device->prop_proxy,
                                 "Get",
                                 get_device_state_cb,
                                 nm_device,
                                 NULL,
                                 G_TYPE_STRING, DEVICE_INTERFACE,
                                 G_TYPE_STRING, "State",
                                 G_TYPE_INVALID);
}
Esempio n. 12
0
static void method_call(DBusGProxy *proxy, const char *method, const char *path)
{
	if (proxy == NULL)
		return;

	g_print("%s ( %s, %s )\n", method, dbus_g_proxy_get_path(proxy), path);

	if (path == NULL) {
		if (dbus_g_proxy_begin_call_with_timeout(proxy,
					method, method_callback, NULL, NULL,
					120 * 1000, G_TYPE_INVALID) == FALSE) {
			g_print("Can't call method %s\n", method);
			g_object_unref(proxy);
			return;
		}
	} else {
		if (dbus_g_proxy_begin_call(proxy, method, method_callback,
				NULL, NULL, DBUS_TYPE_G_OBJECT_PATH, path,
						G_TYPE_INVALID) == FALSE) {
			g_print("Can't call method %s (%s)\n", method, path);
			g_object_unref(proxy);
			return;
		}
	}
}
static void
names_model_reload (NamesModel *names_model)
{
  GtkListStore *list_store;

  list_store = GTK_LIST_STORE (names_model);

  if (names_model->pending_list_names)
    {
      dbus_g_proxy_cancel_call (names_model->driver_proxy,
				names_model->pending_list_names);
      names_model->pending_list_names = NULL;
    }
  
  gtk_list_store_clear (list_store);
  
  if (names_model->connection == NULL)
    return;
  
  names_model->pending_list_names =
    dbus_g_proxy_begin_call (names_model->driver_proxy,
                             "ListNames",
			     have_names_notify, names_model, NULL,
                             G_TYPE_INVALID);
}
Esempio n. 14
0
void
nm_modem_set_mm_enabled (NMModem *self, gboolean enabled)
{
	NMModemPrivate *priv;

	g_return_if_fail (self != NULL);
	g_return_if_fail (NM_IS_MODEM (self));

	priv = NM_MODEM_GET_PRIVATE (self);

	/* FIXME: For now this just toggles the ModemManager enabled state.  In the
	 * future we want to tie this into rfkill state instead so that the user can
	 * toggle rfkill status of the WWAN modem.
	 */

	if (priv->mm_enabled != enabled) {
		DBusGProxy *proxy;

		proxy = nm_modem_get_proxy (self, MM_DBUS_INTERFACE_MODEM);
		dbus_g_proxy_begin_call (proxy,
		                         "Enable", set_mm_enabled_done,
		                         self, NULL,
		                         G_TYPE_BOOLEAN, enabled,
		                         G_TYPE_INVALID);
		/* If we are disabling the modem, stop saying that it's enabled. */
		if (!enabled)
			update_mm_enabled (self, enabled);
	}
}
Esempio n. 15
0
static void
modem_manager_appeared (NMModemManager *self, gboolean enumerate_devices)
{
	NMModemManagerPrivate *priv = NM_MODEM_MANAGER_GET_PRIVATE (self);

	if (priv->poke_id) {
		g_source_remove (priv->poke_id);
		priv->poke_id = 0;
	}

	nm_log_info (LOGD_MB, "modem-manager is now available");

	priv->proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr),
											 MM_DBUS_SERVICE, MM_DBUS_PATH, MM_DBUS_INTERFACE);

	dbus_g_proxy_add_signal (priv->proxy, "DeviceAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
	dbus_g_proxy_connect_signal (priv->proxy, "DeviceAdded",
								 G_CALLBACK (modem_added), self,
								 NULL);

	dbus_g_proxy_add_signal (priv->proxy, "DeviceRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
	dbus_g_proxy_connect_signal (priv->proxy, "DeviceRemoved",
								 G_CALLBACK (modem_removed), self,
								 NULL);

	if (enumerate_devices)
		dbus_g_proxy_begin_call (priv->proxy, "EnumerateDevices", enumerate_devices_done, self, NULL, G_TYPE_INVALID);
}
Esempio n. 16
0
void size_allocate(GtkWidget     *widget,
                   GtkAllocation *allocation,
                   gpointer       user_data)
{
  static int prev_width = -1;
  static int prev_height = -1;

  if (prev_height == -1 || prev_width == -1 ||
      allocation->width != prev_width ||
      allocation->height != prev_height)
    {
      prev_height = allocation->height;
      prev_width = allocation->width;

      if (g_applet->orientation == 1 ||
          g_applet->orientation == 3)
        {
          g_applet->size = allocation->width;
        }
      else
        {
          g_applet->size = allocation->height;
        }

      if (g_applet->support != NULL && workrave_is_running())
        {
          dbus_g_proxy_begin_call(g_applet->support, "SetSize", dbus_callback, NULL, NULL,
                                  G_TYPE_UINT, g_applet->size,
                                  G_TYPE_INVALID);
      
        }
    }
}
Esempio n. 17
0
int main(int argc, char *argv[])
{
    GError *error = NULL;
    DBusGConnection *connection;
    DBusGProxy *proxy;

    g_type_init();
    main_loop = g_main_loop_new(NULL, TRUE);

    connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
    if (connection == NULL) {
        g_printerr("Failed to open connection to bus: %s\n", error->message);
        g_error_free(error);
        error = NULL;
        exit(1);
    }

    proxy = dbus_g_proxy_new_for_name(connection, "org.freedesktop.Notifications",
                                      "/",
                                      DBUS_INTERFACE_INTROSPECTABLE);

    dbus_g_proxy_begin_call(proxy, "Introspect", my_callback_func, NULL, NULL,
                            G_TYPE_INVALID);
    g_main_loop_run(main_loop);

    return 0;
}
Esempio n. 18
0
static void
on_device_state_changed (DBusGProxy *proxy,
                         guint       new_state,
                         guint       old_state,
                         guint       reason,
                         void       *user_data)
{
        NMDevice *nm_device;

        nm_device = (NMDevice *) user_data;

        if (new_state == NM_DEVICE_STATE_ACTIVATED) {
                dbus_g_proxy_begin_call (nm_device->prop_proxy,
                                         "Get",
                                         get_device_interface_cb,
                                         nm_device,
                                         NULL,
                                         G_TYPE_STRING, DEVICE_INTERFACE,
                                         G_TYPE_STRING, "Interface",
                                         G_TYPE_INVALID);
        } else if (nm_device->context != NULL) {
                /* For all other states we just destroy the context */
                g_signal_emit_by_name (nm_device->manager,
                                       "context-unavailable",
                                       nm_device->context);

                g_object_unref (nm_device->context);
                nm_device->context = NULL;
        }
}
static void
modem_added (DBusGProxy *proxy, const char *path, gpointer user_data)
{
	NmaBtDevice *self = NMA_BT_DEVICE (user_data);
	NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self);
	DBusGProxy *props_proxy;

	g_return_if_fail (path != NULL);

	g_message ("%s: (%s) modem found", __func__, path);

	/* Create a proxy for the modem and get its properties */
	props_proxy = dbus_g_proxy_new_for_name (priv->bus,
	                                         MM_SERVICE,
	                                         path,
	                                         "org.freedesktop.DBus.Properties");
	g_assert (proxy);
	priv->modem_proxies = g_slist_append (priv->modem_proxies, props_proxy);

	g_message ("%s: (%s) calling GetAll...", __func__, path);

	dbus_g_proxy_begin_call (props_proxy, "GetAll",
	                         modem_get_all_cb,
	                         self,
	                         NULL,
	                         G_TYPE_STRING, MM_MODEM_INTERFACE,
	                         G_TYPE_INVALID);
}
Esempio n. 20
0
static void
get_device_state_cb (DBusGProxy     *proxy,
                     DBusGProxyCall *call,
                     void           *user_data)
{
        GValue value = {0,};
        GError *error = NULL;
        NMDevice *nm_device = (NMDevice *) user_data;

        if (!dbus_g_proxy_end_call (proxy,
                                    call,
                                    &error,
                                    G_TYPE_VALUE, &value,
                                    G_TYPE_INVALID)) {
                g_warning ("Error reading property: %s\n", error->message);

                g_error_free (error);
                return;
        }

        NMDeviceState state = g_value_get_uint (&value);

        if (state == NM_DEVICE_STATE_ACTIVATED) {
                dbus_g_proxy_begin_call (nm_device->prop_proxy,
                                         "Get",
                                         get_device_interface_cb,
                                         nm_device,
                                         NULL,
                                         G_TYPE_STRING, DEVICE_INTERFACE,
                                         G_TYPE_STRING, "Interface",
                                         G_TYPE_INVALID);
        }

        g_value_unset (&value);
}
void
nm_secret_agent_cancel_secrets (NMSecretAgent *self, gconstpointer call)
{
	NMSecretAgentPrivate *priv;
	Request *r;

	g_return_if_fail (self != NULL);
	priv = NM_SECRET_AGENT_GET_PRIVATE (self);
	g_return_if_fail (priv->proxy != NULL);

	r = g_hash_table_lookup (priv->requests, call);
	g_return_if_fail (r != NULL);

	dbus_g_proxy_cancel_call (priv->proxy, (gpointer) call);

	dbus_g_proxy_begin_call (priv->proxy,
	                         "CancelGetSecrets",
	                         cancel_done,
	                         g_strdup (nm_secret_agent_get_description (self)),
	                         g_free,
	                         DBUS_TYPE_G_OBJECT_PATH, r->path,
	                         G_TYPE_STRING, r->setting_name,
	                         G_TYPE_INVALID);
	g_hash_table_remove (priv->requests, call);
}
Esempio n. 22
0
static void
loc_props_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
	GError *error = NULL;
	GHashTable *props = NULL;
	Modem *modem = user_data;

	if (!dbus_g_proxy_end_call (proxy, call, &error,
	                            DBUS_TYPE_G_MAP_OF_VARIANT, &props,
	                            G_TYPE_INVALID)) {
		g_warning ("%s: failed to get location interface properties: (%d) %s",
		           __func__,
		           error ? error->code : -1,
		           error && error->message ? error->message : "(unknown)");
		g_clear_error (&error);
		return;
	}

	modem_properties_changed (modem->loc_proxy, MM_DBUS_LOC_INTERFACE, props, modem);
	g_hash_table_destroy (props);

	/* Now that we know the device supports location services, get basic
	 * modem properties and start grabbing location info.
	 */
	dbus_g_proxy_begin_call (modem->props_proxy, "GetAll",
	                         modem_props_cb, modem, NULL,
	                         G_TYPE_STRING, MM_DBUS_MODEM_INTERFACE, G_TYPE_INVALID);
}
static gboolean
online_init (void)
{
  DBusGConnection *conn;

  if (proxy)
    return TRUE;

  conn = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL);
  if (!conn) {
    g_warning ("Cannot get connection to system message bus");
    return FALSE;
  }

  proxy = dbus_g_proxy_new_for_name (conn,
                                     "net.connman",
                                     "/",
                                     "net.connman.Manager");

  dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__STRING,
                                     G_TYPE_NONE, G_TYPE_STRING,
				     G_TYPE_INVALID);
  dbus_g_proxy_add_signal (proxy, "StateChanged", G_TYPE_STRING, NULL);
  dbus_g_proxy_connect_signal (proxy, "StateChanged",
                               (GCallback)state_changed, NULL, NULL);

  current_state = FALSE;

  /* Get the current state */
  dbus_g_proxy_begin_call (proxy, "GetState", got_state_cb,
                           NULL, NULL, G_TYPE_INVALID);

  return TRUE;
}
static gboolean
inhibit (RBGPMPlugin *plugin)
{
	GtkWindow *window;
	plugin->timeout_id = 0;
	gulong xid = 0;

	if (plugin->cookie != 0) {
		rb_debug ("Was going to inhibit gnome-session, but we already have done");
		return FALSE;
	}

	if (create_dbus_proxy (plugin) == FALSE) {
		return FALSE;
	}

	rb_debug ("inhibiting");
	g_object_ref (plugin);
	g_object_get (plugin->shell, "window", &window, NULL);
	xid = GDK_WINDOW_XWINDOW (gtk_widget_get_window (GTK_WIDGET (window)));
	dbus_g_proxy_begin_call (plugin->proxy, "Inhibit",
				 (DBusGProxyCallNotify) inhibit_cb,
				 plugin,
				 NULL,
				 G_TYPE_STRING, "rhythmbox",
				 G_TYPE_UINT, xid,
				 G_TYPE_STRING, _("Playing"),
				 G_TYPE_UINT, 8, /* flags */
				 G_TYPE_INVALID);

	return FALSE;
}
Esempio n. 25
0
/**
 * nm_remote_settings_save_hostname:
 * @settings: the %NMRemoteSettings
 * @hostname: the new persistent hostname to set, or NULL to clear any existing
 *  persistent hostname
 * @callback: (scope async): callback to be called when the hostname operation completes
 * @user_data: caller-specific data passed to @callback
 *
 * Requests that the machine's persistent hostname be set to the specified value
 * or cleared.
 *
 * Returns: TRUE if the request was successful, FALSE if it failed
 **/
gboolean
nm_remote_settings_save_hostname (NMRemoteSettings *settings,
                                  const char *hostname,
                                  NMRemoteSettingsSaveHostnameFunc callback,
                                  gpointer user_data)
{
	NMRemoteSettingsPrivate *priv;
	SaveHostnameInfo *info;

	g_return_val_if_fail (settings != NULL, FALSE);
	g_return_val_if_fail (NM_IS_REMOTE_SETTINGS (settings), FALSE);
	g_return_val_if_fail (hostname != NULL, FALSE);
	g_return_val_if_fail (callback != NULL, FALSE);
	
	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);

	info = g_malloc0 (sizeof (SaveHostnameInfo));
	info->settings = settings;
	info->callback = callback;
	info->callback_data = user_data;

	dbus_g_proxy_begin_call (priv->proxy, "SaveHostname",
	                         save_hostname_cb,
	                         info,
	                         g_free,
	                         G_TYPE_STRING, hostname ? hostname : "",
	                         G_TYPE_INVALID);
	return TRUE;
}
Esempio n. 26
0
static void
showlog_callback(BonoboUIComponent *ui, const char *path, Bonobo_UIComponent_EventType type,
                 const char *state, gpointer user_data)
{
  gboolean new_state;

  if (state == NULL || strcmp(state, "") == 0)
    {
      /* State goes blank when component is removed; ignore this. */
      return;
    }

  new_state = strcmp(state, "0") != 0;

  if (1)
    {
      g_applet->last_showlog_state = new_state;

      if (g_applet->ui != NULL && workrave_is_running())
        {
          dbus_g_proxy_begin_call(g_applet->ui, "NetworkLog", dbus_callback, NULL, NULL,
                                 G_TYPE_BOOLEAN, new_state, G_TYPE_INVALID);
        }
    }
}
Esempio n. 27
0
static void
change_orient(PanelApplet *applet, PanelAppletOrient o, gpointer data)
{
  switch (o)
    {
    case PANEL_APPLET_ORIENT_UP:
      g_applet->orientation = 0;
      break;
    case PANEL_APPLET_ORIENT_RIGHT:
      g_applet->orientation = 1;
      break;
    case PANEL_APPLET_ORIENT_DOWN:
      g_applet->orientation = 2;
      break;
    case PANEL_APPLET_ORIENT_LEFT:
      g_applet->orientation = 3;
      break;
    }

  if (g_applet->support != NULL && workrave_is_running())
    {
      dbus_g_proxy_begin_call(g_applet->support, "SetOrientation", dbus_callback, NULL, NULL,
                             G_TYPE_UINT, g_applet->orientation, G_TYPE_INVALID);


    }
}
Esempio n. 28
0
/**
 * Take the initiative of a connection. Actual connection establishment
 * is reported via "peer_connected" callback, as happens with accepted
 * (passive) connections.
 *
 * @param *btaddr The Bluetooth address
 * @param data_type The data type
 * @param reliability The reliability of the HDP channel
 * @return success in initiating connection procedure
 *         (not necessarily connection will happen)
 */
gboolean plugin_bluez_connect(const char *btaddr, guint16 data_type, int reliability)
{
	const char *channel_type;
	const app_object *app;
	gboolean ok = FALSE;
	char *addr = g_ascii_strdown(btaddr, -1);
	struct device_object *dev = get_device_object_by_addr(addr);

	if (!dev) {
		DEBUG("Device %s unknown by BlueZ", btaddr);
		goto finally;
	}

	app = find_application_by_type(data_type);
	if (!app) {
		DEBUG("Data type %d could not be matched to any application",
			data_type);
		DEBUG("Make sure you had configured the plug-in with all"
			"possible data types you need to use");
		goto finally;
	}

	if (app->is_sink) {
		if (reliability != HDP_CHANNEL_ANY) {
			reliability = HDP_CHANNEL_ANY;
			DEBUG("HDP sinks can't choose channel type")
			DEBUG("Defaulting channel type to Any");
		}
	} else {
		if (reliability == HDP_CHANNEL_ANY) {
			reliability = HDP_CHANNEL_RELIABLE;
			DEBUG("HDP sources must define channel type, cannot use Any")
			DEBUG("Defaulting channel type to Reliable");
		}
	}

	if (reliability == HDP_CHANNEL_RELIABLE) {
		channel_type = "Reliable";
	} else if (reliability == HDP_CHANNEL_STREAMING) {
		channel_type = "Streaming";
	} else if (reliability == HDP_CHANNEL_ANY) {
		channel_type = "Any";
	} else {
		DEBUG("Invalid channel type, defaulting to Reliable");
		// safest choice
		channel_type = "Reliable";
	}

	if (dbus_g_proxy_begin_call(dev->proxy, "CreateChannel",
			plugin_bluez_connect_cb, NULL, NULL,
			DBUS_TYPE_G_OBJECT_PATH, app->path,
			G_TYPE_STRING, channel_type,
			G_TYPE_INVALID))
		ok = TRUE;

finally:
	g_free(addr);
	return ok;
}
Esempio n. 29
0
static int wrappee_enum_trackers(DBusGConnection *conn, DBusGProxy *proxy, void *user)
{
    enum_trackers_state_t *state = user;

    dbus_g_proxy_begin_call(proxy, "GetDevices", done_enum_trackers, state, g_free, G_TYPE_INVALID);

    return 0;
}
static void
init_network_manager (GUPnPNetworkManager *manager)
{
        GUPnPNetworkManagerPrivate *priv;
        DBusError derror;
        GMainContext *main_context;

        priv = manager->priv;

        g_object_get (manager, "main-context", &main_context, NULL);

        /* Do fake open to initialize types */
        dbus_g_connection_open ("", NULL);
        dbus_error_init (&derror);
        priv->dbus_connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &derror);
        if (priv->dbus_connection == NULL) {
                g_message ("Failed to connect to System Bus: %s",
                           derror.message);
                return;
        }

        dbus_connection_setup_with_g_main (priv->dbus_connection, main_context);

        priv->connection =
            dbus_connection_get_g_connection (priv->dbus_connection);

        priv->manager_proxy = dbus_g_proxy_new_for_name (priv->connection,
                                                         DBUS_SERVICE_NM,
                                                         MANAGER_PATH,
                                                         MANAGER_INTERFACE);

        dbus_g_proxy_add_signal (priv->manager_proxy,
                                 "DeviceAdded",
                                 DBUS_TYPE_G_OBJECT_PATH,
                                 G_TYPE_INVALID);
        dbus_g_proxy_connect_signal (priv->manager_proxy,
                                     "DeviceAdded",
                                     G_CALLBACK (on_device_added),
                                     manager,
                                     NULL);

        dbus_g_proxy_add_signal (priv->manager_proxy,
                                 "DeviceRemoved",
                                 DBUS_TYPE_G_OBJECT_PATH,
                                 G_TYPE_INVALID);
        dbus_g_proxy_connect_signal (priv->manager_proxy,
                                     "DeviceRemoved",
                                     G_CALLBACK (on_device_removed),
                                     manager,
                                     NULL);

        dbus_g_proxy_begin_call (priv->manager_proxy,
                                 "GetDevices",
                                 get_devices_cb,
                                 manager,
                                 NULL,
                                 G_TYPE_INVALID);
}