static void interface_add_done (NMSupplicantInterface *self, char *path) { NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); nm_log_dbg (LOGD_SUPPLICANT, "(%s): interface added to supplicant", priv->dev); priv->object_path = path; priv->iface_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, WPAS_DBUS_IFACE_INTERFACE); dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->iface_proxy, "PropertiesChanged", DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "PropertiesChanged", G_CALLBACK (wpas_iface_properties_changed), self, NULL); dbus_g_proxy_add_signal (priv->iface_proxy, "ScanDone", G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "ScanDone", G_CALLBACK (wpas_iface_scan_done), self, NULL); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, DBUS_TYPE_G_OBJECT_PATH, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->iface_proxy, "BSSAdded", DBUS_TYPE_G_OBJECT_PATH, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "BSSAdded", G_CALLBACK (wpas_iface_bss_added), self, NULL); priv->props_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, DBUS_INTERFACE_PROPERTIES); /* Get initial properties */ wpas_iface_get_props (self); set_state (self, NM_SUPPLICANT_INTERFACE_STATE_READY); }
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); }
void nm_wimax_nsp_export_to_dbus (NMWimaxNsp *self) { NMWimaxNspPrivate *priv; NMDBusManager *mgr; DBusGConnection *g_connection; static guint32 counter = 0; g_return_if_fail (NM_IS_WIMAX_NSP (self)); priv = GET_PRIVATE (self); g_return_if_fail (priv->dbus_path == NULL); mgr = nm_dbus_manager_get (); g_assert (mgr); g_connection = nm_dbus_manager_get_connection (mgr); g_assert (g_connection); priv->dbus_path = g_strdup_printf (NM_DBUS_PATH_WIMAX_NSP "/%d", counter++); dbus_g_connection_register_g_object (g_connection, priv->dbus_path, G_OBJECT (self)); g_object_unref (mgr); }
static void bluez_connect (NMBluezManager *self) { NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self); DBusGConnection *connection; g_return_if_fail (priv->proxy == NULL); connection = nm_dbus_manager_get_connection (priv->dbus_mgr); if (!connection) return; priv->proxy = dbus_g_proxy_new_for_name (connection, BLUEZ_SERVICE, BLUEZ_MANAGER_PATH, BLUEZ_MANAGER_INTERFACE); dbus_g_proxy_add_signal (priv->proxy, "AdapterRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "AdapterRemoved", G_CALLBACK (adapter_removed), self, NULL); dbus_g_proxy_add_signal (priv->proxy, "DefaultAdapterChanged", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "DefaultAdapterChanged", G_CALLBACK (default_adapter_changed), self, NULL); query_default_adapter (self); }
static GObject * constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; NMPPPManagerPrivate *priv; DBusGConnection *connection; static guint32 counter = 0; object = G_OBJECT_CLASS (nm_ppp_manager_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; priv = NM_PPP_MANAGER_GET_PRIVATE (object); priv->dbus_manager = nm_dbus_manager_get (); if (!priv->dbus_manager) { g_object_unref (object); return NULL; } connection = nm_dbus_manager_get_connection (priv->dbus_manager); priv->dbus_path = g_strdup_printf (NM_DBUS_PATH "/PPP/%d", counter++); dbus_g_connection_register_g_object (connection, priv->dbus_path, object); return object; }
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); } }
void nm_ap_export_to_dbus (NMAccessPoint *ap) { NMAccessPointPrivate *priv; NMDBusManager *mgr; DBusGConnection *g_connection; static guint32 counter = 0; g_return_if_fail (NM_IS_AP (ap)); priv = NM_AP_GET_PRIVATE (ap); if (priv->dbus_path) { nm_warning ("Tried to export AP %s twice.", priv->dbus_path); return; } mgr = nm_dbus_manager_get (); g_assert (mgr); g_connection = nm_dbus_manager_get_connection (mgr); g_assert (g_connection); priv->dbus_path = g_strdup_printf (NM_DBUS_PATH_ACCESS_POINT "/%d", counter++); dbus_g_connection_register_g_object (g_connection, priv->dbus_path, G_OBJECT (ap)); g_object_unref (mgr); }
static void nm_supplicant_interface_dispose (GObject *object) { NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (object); guint32 sm_state; if (priv->dispose_has_run) { G_OBJECT_CLASS (nm_supplicant_interface_parent_class)->dispose (object); return; } priv->dispose_has_run = TRUE; /* Ask wpa_supplicant to remove this interface */ sm_state = nm_supplicant_manager_get_state (priv->smgr); if (sm_state == NM_SUPPLICANT_MANAGER_STATE_IDLE) { if (priv->object_path) { try_remove_iface (nm_dbus_manager_get_connection (priv->dbus_mgr), priv->object_path); } } if (priv->iface_proxy) g_object_unref (priv->iface_proxy); if (priv->net_proxy) g_object_unref (priv->net_proxy); if (priv->scan_results_timeout) g_source_remove (priv->scan_results_timeout); if (priv->smgr) { g_signal_handler_disconnect (priv->smgr, priv->smgr_state_sig_handler); g_object_unref (priv->smgr); } g_free (priv->dev); /* Cancel pending calls before unrefing the dbus manager */ cancel_all_callbacks (priv->other_pcalls); nm_call_store_destroy (priv->other_pcalls); cancel_all_callbacks (priv->assoc_pcalls); nm_call_store_destroy (priv->assoc_pcalls); if (priv->dbus_mgr) g_object_unref (priv->dbus_mgr); if (priv->cfg) g_object_unref (priv->cfg); g_free (priv->object_path); /* Chain up to the parent class */ G_OBJECT_CLASS (nm_supplicant_interface_parent_class)->dispose (object); }
static void create_modem (NMModemManager *manager, const char *path) { NMModemManagerPrivate *priv = NM_MODEM_MANAGER_GET_PRIVATE (manager); NMModem *modem = NULL; char *data_device = NULL, *driver = NULL, *master_device = NULL; uint modem_type = MM_MODEM_TYPE_UNKNOWN; uint ip_method = MM_MODEM_IP_METHOD_PPP; if (g_hash_table_lookup (priv->modems, path)) { nm_log_warn (LOGD_MB, "modem with path %s already exists, ignoring", path); return; } if (!get_modem_properties (nm_dbus_manager_get_connection (priv->dbus_mgr), path, &master_device, &data_device, &driver, &modem_type, &ip_method)) return; if (modem_type == MM_MODEM_TYPE_UNKNOWN) { nm_log_warn (LOGD_MB, "modem with path %s has unknown type, ignoring", path); return; } if (!master_device || !strlen (master_device)) { nm_log_warn (LOGD_MB, "modem with path %s has unknown device, ignoring", path); return; } if (!driver || !strlen (driver)) { nm_log_warn (LOGD_MB, "modem with path %s has unknown driver, ignoring", path); return; } if (!data_device || !strlen (data_device)) { nm_log_warn (LOGD_MB, "modem with path %s has unknown data device, ignoring", path); return; } if (modem_type == MM_MODEM_TYPE_GSM) modem = nm_modem_gsm_new (path, master_device, data_device, ip_method); else if (modem_type == MM_MODEM_TYPE_CDMA) modem = nm_modem_cdma_new (path, master_device, data_device, ip_method); else nm_log_warn (LOGD_MB, "unknown modem type '%d'", modem_type); g_free (data_device); if (modem) { g_hash_table_insert (priv->modems, g_strdup (path), modem); g_signal_emit (manager, signals[MODEM_ADDED], 0, modem, driver); } g_free (driver); }
static void nm_act_request_init (NMActRequest *req) { NMActRequestPrivate *priv = NM_ACT_REQUEST_GET_PRIVATE (req); NMDBusManager *dbus_mgr; priv->ac_path = nm_active_connection_get_next_object_path (); priv->state = NM_ACTIVE_CONNECTION_STATE_UNKNOWN; dbus_mgr = nm_dbus_manager_get (); dbus_g_connection_register_g_object (nm_dbus_manager_get_connection (dbus_mgr), priv->ac_path, G_OBJECT (req)); g_object_unref (dbus_mgr); }
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); }
static void nm_dhcp4_config_init (NMDHCP4Config *self) { NMDHCP4ConfigPrivate *priv = NM_DHCP4_CONFIG_GET_PRIVATE (self); static guint32 counter = 0; DBusGConnection *connection; NMDBusManager *dbus_mgr; dbus_mgr = nm_dbus_manager_get (); connection = nm_dbus_manager_get_connection (dbus_mgr); priv->dbus_path = g_strdup_printf (NM_DBUS_PATH "/DHCP4Config/%d", counter++); dbus_g_connection_register_g_object (connection, priv->dbus_path, G_OBJECT (self)); g_object_unref (dbus_mgr); priv->options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, nm_gvalue_destroy); }
NMDHCPManager * nm_dhcp_manager_new (const char *client, GError **error) { NMDHCPManagerPrivate *priv; DBusGConnection *g_connection; g_warn_if_fail (singleton == NULL); singleton = g_object_new (NM_TYPE_DHCP_MANAGER, NULL); priv = NM_DHCP_MANAGER_GET_PRIVATE (singleton); /* Client-specific setup */ priv->client_type = get_client_type (client, error); if (priv->client_type == NM_TYPE_DHCP_DHCLIENT) priv->get_lease_config_func = nm_dhcp_dhclient_get_lease_config; else if (priv->client_type == NM_TYPE_DHCP_DHCPCD) priv->get_lease_config_func = nm_dhcp_dhcpcd_get_lease_config; else { nm_log_warn (LOGD_DHCP, "No usable DHCP client found! DHCP configurations will fail."); } priv->clients = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, (GDestroyNotify) g_object_unref); g_assert (priv->clients); priv->dbus_mgr = nm_dbus_manager_get (); g_connection = nm_dbus_manager_get_connection (priv->dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (g_connection, NM_DHCP_CLIENT_DBUS_SERVICE, "/", NM_DHCP_CLIENT_DBUS_IFACE); g_assert (priv->proxy); dbus_g_proxy_add_signal (priv->proxy, "Event", DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "Event", G_CALLBACK (nm_dhcp_manager_handle_event), singleton, NULL); return singleton; }
static void nm_supplicant_interface_init (NMSupplicantInterface * self) { NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); DBusGConnection *bus; priv->state = NM_SUPPLICANT_INTERFACE_STATE_INIT; priv->assoc_pcalls = nm_call_store_new (); priv->other_pcalls = nm_call_store_new (); priv->dbus_mgr = nm_dbus_manager_get (); bus = nm_dbus_manager_get_connection (priv->dbus_mgr); priv->wpas_proxy = dbus_g_proxy_new_for_name (bus, WPAS_DBUS_SERVICE, WPAS_DBUS_PATH, WPAS_DBUS_INTERFACE); }
NMSecretAgent * nm_secret_agent_new (NMDBusManager *dbus_mgr, const char *owner, const char *identifier, uid_t owner_uid) { NMSecretAgent *self; NMSecretAgentPrivate *priv; DBusGConnection *bus; char *hash_str, *username; struct passwd *pw; g_return_val_if_fail (owner != NULL, NULL); g_return_val_if_fail (identifier != NULL, NULL); pw = getpwuid (owner_uid); g_return_val_if_fail (pw != NULL, NULL); g_return_val_if_fail (pw->pw_name[0] != '\0', NULL); username = g_strdup (pw->pw_name); self = (NMSecretAgent *) g_object_new (NM_TYPE_SECRET_AGENT, NULL); if (self) { priv = NM_SECRET_AGENT_GET_PRIVATE (self); priv->owner = g_strdup (owner); priv->identifier = g_strdup (identifier); priv->owner_uid = owner_uid; priv->owner_username = g_strdup (username); hash_str = g_strdup_printf ("%08u%s", owner_uid, identifier); priv->hash = g_str_hash (hash_str); g_free (hash_str); priv->dbus_mgr = g_object_ref (dbus_mgr); bus = nm_dbus_manager_get_connection (priv->dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (bus, owner, NM_DBUS_PATH_SECRET_AGENT, NM_DBUS_INTERFACE_SECRET_AGENT); g_assert (priv->proxy); } g_free (username); return self; }
static gboolean poke_modem_cb (gpointer user_data) { NMModemManager *self = NM_MODEM_MANAGER (user_data); NMModemManagerPrivate *priv = NM_MODEM_MANAGER_GET_PRIVATE (self); DBusGConnection *g_connection; DBusGProxy *proxy; g_connection = nm_dbus_manager_get_connection (priv->dbus_mgr); proxy = dbus_g_proxy_new_for_name (g_connection, MM_DBUS_SERVICE, MM_DBUS_PATH, MM_DBUS_INTERFACE); dbus_g_proxy_call_no_reply (proxy, "EnumerateDevices", G_TYPE_INVALID); g_object_unref (proxy); return TRUE; }
static void nm_firewall_manager_init (NMFirewallManager * self) { NMFirewallManagerPrivate *priv = NM_FIREWALL_MANAGER_GET_PRIVATE (self); DBusGConnection *bus; priv->dbus_mgr = g_object_ref (nm_dbus_manager_get ()); priv->name_owner_id = g_signal_connect (priv->dbus_mgr, NM_DBUS_MANAGER_NAME_OWNER_CHANGED, G_CALLBACK (name_owner_changed), self); priv->running = nm_dbus_manager_name_has_owner (priv->dbus_mgr, FIREWALL_DBUS_SERVICE); nm_log_dbg (LOGD_FIREWALL, "firewall %s running", priv->running ? "is" : "is not" ); bus = nm_dbus_manager_get_connection (priv->dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (bus, FIREWALL_DBUS_SERVICE, FIREWALL_DBUS_PATH, FIREWALL_DBUS_INTERFACE_ZONE); }
void nm_ip4_config_export (NMIP4Config *config) { NMIP4ConfigPrivate *priv; NMDBusManager *dbus_mgr; DBusGConnection *connection; static guint32 counter = 0; g_return_if_fail (NM_IS_IP4_CONFIG (config)); priv = NM_IP4_CONFIG_GET_PRIVATE (config); g_return_if_fail (priv->path == NULL); dbus_mgr = nm_dbus_manager_get (); connection = nm_dbus_manager_get_connection (dbus_mgr); priv->path = g_strdup_printf (NM_DBUS_PATH "/IP4Config/%d", counter++); dbus_g_connection_register_g_object (connection, priv->path, G_OBJECT (config)); g_object_unref (dbus_mgr); }
static void nm_supplicant_manager_init (NMSupplicantManager * self) { NMSupplicantManagerPrivate *priv = NM_SUPPLICANT_MANAGER_GET_PRIVATE (self); DBusGConnection *bus; priv->dbus_mgr = nm_dbus_manager_get (); priv->name_owner_id = g_signal_connect (priv->dbus_mgr, NM_DBUS_MANAGER_NAME_OWNER_CHANGED, G_CALLBACK (name_owner_changed), self); priv->running = nm_dbus_manager_name_has_owner (priv->dbus_mgr, WPAS_DBUS_SERVICE); bus = nm_dbus_manager_get_connection (priv->dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (bus, WPAS_DBUS_SERVICE, WPAS_DBUS_PATH, WPAS_DBUS_INTERFACE); priv->ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); }
gboolean nm_active_connection_export (NMActiveConnection *self, NMConnection *connection, const char *devpath) { NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); NMDBusManager *dbus_mgr; static guint32 counter = 0; g_return_val_if_fail (connection != NULL, FALSE); g_return_val_if_fail (devpath != NULL, FALSE); priv->connection = g_object_ref (connection); priv->path = g_strdup_printf (NM_DBUS_PATH "/ActiveConnection/%d", counter++); priv->device_path = g_strdup (devpath); dbus_mgr = nm_dbus_manager_get (); dbus_g_connection_register_g_object (nm_dbus_manager_get_connection (dbus_mgr), priv->path, G_OBJECT (self)); g_object_unref (dbus_mgr); return TRUE; }
static void request_bssid_properties (NMSupplicantInterface * self, const char * op) { 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, op, WPAS_DBUS_IFACE_BSSID); info = nm_supplicant_info_new (self, proxy, priv->other_pcalls); call = dbus_g_proxy_begin_call (proxy, "properties", bssid_properties_cb, info, nm_supplicant_info_destroy, G_TYPE_INVALID); nm_supplicant_info_set_call (info, call); g_object_unref (proxy); }
NMBluezAdapter * nm_bluez_adapter_new (const char *path, NMConnectionProvider *provider) { NMBluezAdapter *self; NMBluezAdapterPrivate *priv; DBusGConnection *connection; self = (NMBluezAdapter *) g_object_new (NM_TYPE_BLUEZ_ADAPTER, NM_BLUEZ_ADAPTER_PATH, path, NULL); if (!self) return NULL; priv = NM_BLUEZ_ADAPTER_GET_PRIVATE (self); priv->provider = provider; connection = nm_dbus_manager_get_connection (nm_dbus_manager_get ()); priv->proxy = dbus_g_proxy_new_for_name (connection, BLUEZ_SERVICE, priv->path, BLUEZ_ADAPTER_INTERFACE); dbus_g_proxy_add_signal (priv->proxy, "DeviceCreated", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "DeviceCreated", G_CALLBACK (device_created), 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 (device_removed), self, NULL); query_properties (self); return self; }
NMBluezDevice * nm_bluez_device_new (const char *path) { NMBluezDevice *self; NMBluezDevicePrivate *priv; NMDBusManager *dbus_mgr; DBusGConnection *connection; self = (NMBluezDevice *) g_object_new (NM_TYPE_BLUEZ_DEVICE, NM_BLUEZ_DEVICE_PATH, path, NULL); if (!self) return NULL; priv = NM_BLUEZ_DEVICE_GET_PRIVATE (self); dbus_mgr = nm_dbus_manager_get (); connection = nm_dbus_manager_get_connection (dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (connection, BLUEZ_SERVICE, priv->path, BLUEZ_DEVICE_INTERFACE); g_object_unref (dbus_mgr); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->proxy, "PropertyChanged", G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "PropertyChanged", G_CALLBACK (property_changed), self, NULL); query_properties (self); return self; }
static void add_network_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data) { NMSupplicantInfo *info = (NMSupplicantInfo *) user_data; GError *err = NULL; char *path = NULL; if (!dbus_g_proxy_end_call (proxy, call_id, &err, DBUS_TYPE_G_OBJECT_PATH, &path, G_TYPE_INVALID)) { nm_log_warn (LOGD_SUPPLICANT, "Couldn't add a network to the supplicant interface: %s.", err->message); emit_error_helper (info->interface, err); g_error_free (err); } else { NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (info->interface); GHashTable *blobs; priv->net_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, WPAS_DBUS_IFACE_NETWORK); g_free (path); info = nm_supplicant_info_new (info->interface, priv->net_proxy, priv->assoc_pcalls); /* Send any blobs first; if there aren't any jump to sending the * config settings. */ blobs = nm_supplicant_config_get_blobs (priv->cfg); if (g_hash_table_size (blobs) > 0) call_set_blobs (info, blobs); else call_set_network (info); } }
static GObject* constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; NMModemPrivate *priv; DBusGConnection *bus; object = G_OBJECT_CLASS (nm_modem_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; priv = NM_MODEM_GET_PRIVATE (object); if (!priv->device) { nm_log_err (LOGD_HW, "modem parent device not provided"); goto err; } if (!priv->device) { nm_log_err (LOGD_HW, "modem command interface not provided"); goto err; } if (!priv->path) { nm_log_err (LOGD_HW, "D-Bus path not provided"); goto err; } bus = nm_dbus_manager_get_connection (priv->dbus_mgr); priv->proxy = dbus_g_proxy_new_for_name (bus, MM_DBUS_SERVICE, priv->path, MM_DBUS_INTERFACE_MODEM); priv->props_proxy = dbus_g_proxy_new_for_name (bus, MM_DBUS_SERVICE, priv->path, DBUS_INTERFACE_PROPERTIES); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->props_proxy, "MmPropertiesChanged", G_TYPE_STRING, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->props_proxy, "MmPropertiesChanged", G_CALLBACK (modem_properties_changed), object, NULL); query_mm_enabled (NM_MODEM (object)); return object; err: g_object_unref (object); return NULL; }
static NMActStageReturn real_act_stage2_config (NMDevice *device, NMDeviceStateReason *reason) { NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (device); NMActRequest *req; NMDBusManager *dbus_mgr; DBusGConnection *g_connection; gboolean dun = FALSE; req = nm_device_get_act_request (device); g_assert (req); priv->bt_type = get_connection_bt_type (nm_act_request_get_connection (req)); if (priv->bt_type == NM_BT_CAPABILITY_NONE) { // FIXME: set a reason code return NM_ACT_STAGE_RETURN_FAILURE; } dbus_mgr = nm_dbus_manager_get (); g_connection = nm_dbus_manager_get_connection (dbus_mgr); g_object_unref (dbus_mgr); if (priv->bt_type == NM_BT_CAPABILITY_DUN) dun = TRUE; else if (priv->bt_type == NM_BT_CAPABILITY_NAP) dun = FALSE; else g_assert_not_reached (); priv->dev_proxy = dbus_g_proxy_new_for_name (g_connection, BLUEZ_SERVICE, nm_device_get_udi (device), BLUEZ_DEVICE_INTERFACE); if (!priv->dev_proxy) { // FIXME: set a reason code return NM_ACT_STAGE_RETURN_FAILURE; } /* Watch for BT device property changes */ dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->dev_proxy, "PropertyChanged", G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->dev_proxy, "PropertyChanged", G_CALLBACK (bluez_property_changed), device, NULL); priv->type_proxy = dbus_g_proxy_new_for_name (g_connection, BLUEZ_SERVICE, nm_device_get_udi (device), dun ? BLUEZ_SERIAL_INTERFACE : BLUEZ_NETWORK_INTERFACE); if (!priv->type_proxy) { // FIXME: set a reason code return NM_ACT_STAGE_RETURN_FAILURE; } nm_log_dbg (LOGD_BT, "(%s): requesting connection to the device", nm_device_get_iface (device)); /* Connect to the BT device */ dbus_g_proxy_begin_call_with_timeout (priv->type_proxy, "Connect", bluez_connect_cb, device, NULL, 20000, G_TYPE_STRING, dun ? BLUETOOTH_DUN_UUID : BLUETOOTH_NAP_UUID, G_TYPE_INVALID); if (priv->timeout_id) g_source_remove (priv->timeout_id); priv->timeout_id = g_timeout_add_seconds (30, bt_connect_timeout, device); return NM_ACT_STAGE_RETURN_POSTPONE; }
static void nm_supplicant_interface_add_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; char *path = NULL; if (!dbus_g_proxy_end_call (proxy, call_id, &err, DBUS_TYPE_G_OBJECT_PATH, &path, G_TYPE_INVALID)) { if (dbus_g_error_has_name (err, WPAS_ERROR_INVALID_IFACE)) { /* Interface not added, try to add it */ nm_supplicant_interface_add_to_supplicant (info->interface, FALSE); } else if (dbus_g_error_has_name (err, WPAS_ERROR_EXISTS_ERROR)) { /* Interface already added, just try to get the interface */ nm_supplicant_interface_add_to_supplicant (info->interface, TRUE); } else { nm_log_err (LOGD_SUPPLICANT, "(%s): error getting interface: %s", priv->dev, err->message); } g_error_free (err); } else { nm_log_dbg (LOGD_SUPPLICANT, "(%s): interface added to supplicant", priv->dev); priv->object_path = path; priv->iface_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, WPAS_DBUS_IFACE_INTERFACE); dbus_g_proxy_add_signal (priv->iface_proxy, "ScanResultsAvailable", G_TYPE_INVALID); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->iface_proxy, "StateChange", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "ScanResultsAvailable", G_CALLBACK (wpas_iface_query_scan_results), info->interface, NULL); dbus_g_proxy_connect_signal (priv->iface_proxy, "StateChange", G_CALLBACK (wpas_iface_handle_state_change), info->interface, NULL); dbus_g_proxy_add_signal (priv->iface_proxy, "Scanning", G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "Scanning", G_CALLBACK (wpas_iface_handle_scanning), info->interface, NULL); /* Interface added to the supplicant; get its initial state. */ wpas_iface_get_state (info->interface); wpas_iface_get_scanning (info->interface); } }