static void real_update_hw_address (NMDevice *dev) { NMDeviceOlpcMesh *self = NM_DEVICE_OLPC_MESH (dev); NMDeviceOlpcMeshPrivate *priv = NM_DEVICE_OLPC_MESH_GET_PRIVATE (self); struct ifreq req; int ret, fd; fd = socket (PF_INET, SOCK_DGRAM, 0); if (fd < 0) { nm_log_warn (LOGD_OLPC_MESH, "could not open control socket."); return; } memset (&req, 0, sizeof (struct ifreq)); strncpy (req.ifr_name, nm_device_get_iface (dev), IFNAMSIZ); ret = ioctl (fd, SIOCGIFHWADDR, &req); if (ret) { nm_log_warn (LOGD_OLPC_MESH, "(%s): error getting hardware address: %d", nm_device_get_iface (dev), errno); goto out; } if (memcmp (&priv->hw_addr, &req.ifr_hwaddr.sa_data, sizeof (struct ether_addr))) { memcpy (&priv->hw_addr, &req.ifr_hwaddr.sa_data, sizeof (struct ether_addr)); g_object_notify (G_OBJECT (dev), NM_DEVICE_OLPC_MESH_HW_ADDRESS); } out: close (fd); }
static NMActStageReturn real_act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason) { NMDeviceOlpcMeshPrivate *priv = NM_DEVICE_OLPC_MESH_GET_PRIVATE (dev); gboolean scanning; /* disconnect companion device, if it is connected */ if (nm_device_get_act_request (NM_DEVICE (priv->companion))) { nm_log_info (LOGD_OLPC_MESH, "(%s): disconnecting companion device %s", nm_device_get_iface (dev), nm_device_get_iface (priv->companion)); /* FIXME: VPN stuff here is a bug; but we can't really change API now... */ nm_device_state_changed (NM_DEVICE (priv->companion), NM_DEVICE_STATE_DISCONNECTED, NM_VPN_CONNECTION_STATE_REASON_USER_DISCONNECTED); nm_log_info (LOGD_OLPC_MESH, "(%s): companion %s disconnected", nm_device_get_iface (dev), nm_device_get_iface (priv->companion)); } /* wait with continuing configuration untill the companion device is done scanning */ g_object_get (priv->companion, "scanning", &scanning, NULL); if (scanning) { priv->stage1_waiting = TRUE; return NM_ACT_STAGE_RETURN_POSTPONE; } return NM_ACT_STAGE_RETURN_SUCCESS; }
static void real_update_hw_address (NMDevice *dev) { NMDeviceWimax *self = NM_DEVICE_WIMAX (dev); NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (self); struct ifreq req; int fd; const char *iface; iface = nm_device_get_iface (dev); fd = socket (PF_INET, SOCK_DGRAM, 0); if (fd < 0) { nm_log_warn (LOGD_HW, "(%s): couldn't open control socket.", iface); return; } memset (&req, 0, sizeof (struct ifreq)); strncpy (req.ifr_name, nm_device_get_iface (dev), IFNAMSIZ); errno = 0; if (ioctl (fd, SIOCGIFHWADDR, &req) < 0) { nm_log_err (LOGD_HW | LOGD_WIMAX, "(%s): failed to read hardware address (error %d)", iface, errno); } else { memcpy (&priv->hw_addr, &req.ifr_hwaddr.sa_data, ETH_ALEN); g_object_notify (G_OBJECT (self), NM_DEVICE_WIMAX_HW_ADDRESS); } close (fd); }
static void real_connection_secrets_updated (NMDevice *dev, NMConnection *connection, GSList *updated_settings, RequestSecretsCaller caller) { NMActRequest *req; gboolean found = FALSE; GSList *iter; if (caller == SECRETS_CALLER_PPP) { NMPPPManager *ppp_manager; NMSettingGsm *s_gsm = NULL; ppp_manager = nm_modem_get_ppp_manager (NM_MODEM (dev)); g_return_if_fail (ppp_manager != NULL); s_gsm = (NMSettingGsm *) nm_connection_get_setting (connection, NM_TYPE_SETTING_GSM); if (!s_gsm) { /* Shouldn't ever happen */ nm_ppp_manager_update_secrets (ppp_manager, nm_device_get_iface (dev), NULL, NULL, "missing GSM setting; no secrets could be found."); } else { const char *username = nm_setting_gsm_get_username (s_gsm); const char *password = nm_setting_gsm_get_password (s_gsm); nm_ppp_manager_update_secrets (ppp_manager, nm_device_get_iface (dev), username ? username : "", password ? password : "", NULL); } return; } g_return_if_fail (caller == SECRETS_CALLER_GSM); g_return_if_fail (nm_device_get_state (dev) == NM_DEVICE_STATE_NEED_AUTH); for (iter = updated_settings; iter; iter = g_slist_next (iter)) { const char *setting_name = (const char *) iter->data; if (!strcmp (setting_name, NM_SETTING_GSM_SETTING_NAME)) found = TRUE; else nm_warning ("Ignoring updated secrets for setting '%s'.", setting_name); } if (!found) return; req = nm_device_get_act_request (dev); g_assert (req); g_return_if_fail (nm_act_request_get_connection (req) == connection); nm_device_activate_schedule_stage1_device_prepare (dev); }
static void teamd_dbus_vanished (GDBusConnection *connection, const gchar *name, gpointer user_data) { NMDevice *dev = NM_DEVICE (user_data); NMDeviceTeamPrivate *priv = NM_DEVICE_TEAM_GET_PRIVATE (dev); g_return_if_fail (priv->teamd_dbus_watch); if (priv->teamd_timeout) { /* g_bus_watch_name will always raise an initial signal, to indicate whether the * name exists/not exists initially. Do not take this as a failure, until the * startup timeout is over. * * Note that g_bus_watch_name is guaranteed to alternate vanished/appeared signals, * so we won't hit this condition again (because the next signal is either 'appeared' * or 'timeout'). */ nm_log_dbg (LOGD_TEAM, "(%s): teamd vanished from D-Bus (ignored)", nm_device_get_iface (dev)); return; } nm_log_info (LOGD_TEAM, "(%s): teamd vanished from D-Bus", nm_device_get_iface (dev)); teamd_cleanup (dev, TRUE); }
static NMActStageReturn act_stage1_prepare (NMDevice *device, NMDeviceStateReason *reason) { NMDeviceOlpcMesh *self = NM_DEVICE_OLPC_MESH (device); NMDeviceOlpcMeshPrivate *priv = NM_DEVICE_OLPC_MESH_GET_PRIVATE (device); NMActStageReturn ret; gboolean scanning; ret = NM_DEVICE_CLASS (nm_device_olpc_mesh_parent_class)->act_stage1_prepare (device, reason); if (ret != NM_ACT_STAGE_RETURN_SUCCESS) return ret; /* disconnect companion device, if it is connected */ if (nm_device_get_act_request (NM_DEVICE (priv->companion))) { _LOGI (LOGD_OLPC, "disconnecting companion device %s", nm_device_get_iface (priv->companion)); /* FIXME: VPN stuff here is a bug; but we can't really change API now... */ nm_device_state_changed (NM_DEVICE (priv->companion), NM_DEVICE_STATE_DISCONNECTED, NM_DEVICE_STATE_REASON_USER_REQUESTED); _LOGI (LOGD_OLPC, "companion %s disconnected", nm_device_get_iface (priv->companion)); } /* wait with continuing configuration untill the companion device is done scanning */ g_object_get (priv->companion, "scanning", &scanning, NULL); if (scanning) { priv->stage1_waiting = TRUE; return NM_ACT_STAGE_RETURN_POSTPONE; } return NM_ACT_STAGE_RETURN_SUCCESS; }
static GObject* constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; NMDeviceAdslPrivate *priv; GError *error = NULL; object = G_OBJECT_CLASS (nm_device_adsl_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; priv = NM_DEVICE_ADSL_GET_PRIVATE (object); priv->atm_index = get_atm_index (nm_device_get_iface (NM_DEVICE (object)), &error); if (priv->atm_index < 0) { nm_log_dbg (LOGD_ADSL, "error reading ATM device index: (%d) %s", error ? error->code : -1, error && error->message ? error->message : "(unknown)"); g_clear_error (&error); g_object_unref (object); return NULL; } else { nm_log_dbg (LOGD_ADSL, "(%s): ATM device index %d", nm_device_get_iface (NM_DEVICE (object)), priv->atm_index); } /* Poll the carrier */ priv->carrier_poll_id = g_timeout_add_seconds (5, carrier_update_cb, object); return object; }
static void bluez_property_changed (DBusGProxy *proxy, const char *property, GValue *value, gpointer user_data) { NMDevice *device = NM_DEVICE (user_data); NMDeviceBt *self = NM_DEVICE_BT (user_data); NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE (self); gboolean connected; NMDeviceState state; const char *prop_str = "(unknown)"; if (G_VALUE_HOLDS_STRING (value)) prop_str = g_value_get_string (value); else if (G_VALUE_HOLDS_BOOLEAN (value)) prop_str = g_value_get_boolean (value) ? "true" : "false"; nm_log_dbg (LOGD_BT, "(%s): bluez property '%s' changed to '%s'", nm_device_get_iface (device), property, prop_str); if (strcmp (property, "Connected")) return; state = nm_device_get_state (device); connected = g_value_get_boolean (value); if (connected) { if (state == NM_DEVICE_STATE_CONFIG) { nm_log_dbg (LOGD_BT, "(%s): connected to the device", nm_device_get_iface (device)); priv->connected = TRUE; check_connect_continue (self); } } else { gboolean fail = FALSE; /* Bluez says we're disconnected from the device. Suck. */ if (nm_device_is_activating (device)) { nm_log_info (LOGD_BT, "Activation (%s/bluetooth): bluetooth link disconnected.", nm_device_get_iface (device)); fail = TRUE; } else if (state == NM_DEVICE_STATE_ACTIVATED) { nm_log_info (LOGD_BT, "(%s): bluetooth link disconnected.", nm_device_get_iface (device)); fail = TRUE; } if (fail) { nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_CARRIER); priv->connected = FALSE; } } }
gboolean nm_active_connection_set_device (NMActiveConnection *self, NMDevice *device) { NMActiveConnectionPrivate *priv; gs_unref_object NMDevice *old_device = NULL; g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (self), FALSE); g_return_val_if_fail (!device || NM_IS_DEVICE (device), FALSE); priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); if (device == priv->device) return TRUE; _LOGD ("set device %s%s%s [%p]", NM_PRINT_FMT_QUOTED (device && nm_device_get_iface (device), "\"", nm_device_get_iface (device), "\"", device ? "(unknown)" : "(null)"), device); old_device = priv->device ? g_object_ref (priv->device) : NULL; _device_cleanup (self); if (device) { /* Device obviously can't be its own master */ g_return_val_if_fail (!priv->master || device != nm_active_connection_get_device (priv->master), FALSE); priv->device = g_object_ref (device); g_signal_connect (device, NM_DEVICE_STATE_CHANGED, G_CALLBACK (device_state_changed), self); g_signal_connect (device, "notify::master", G_CALLBACK (device_master_changed), self); g_signal_connect (device, "notify::" NM_DEVICE_METERED, G_CALLBACK (device_metered_changed), self); if (!priv->assumed) { priv->pending_activation_id = g_strdup_printf ("activation::%p", (void *)self); nm_device_add_pending_action (device, priv->pending_activation_id, TRUE); } } else { /* The ActiveConnection's device can only be cleared after the * connection is activated. */ g_warn_if_fail (priv->state > NM_ACTIVE_CONNECTION_STATE_UNKNOWN); priv->device = NULL; } _notify (self, PROP_INT_DEVICE); g_signal_emit (self, signals[DEVICE_CHANGED], 0, priv->device, old_device); _notify (self, PROP_DEVICES); return TRUE; }
static NMActStageReturn act_stage2_config (NMDevice *device, NMDeviceStateReason *out_reason) { NMDeviceAdsl *self = NM_DEVICE_ADSL (device); NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE (self); NMActStageReturn ret = NM_ACT_STAGE_RETURN_FAILURE; NMSettingAdsl *s_adsl; const char *protocol; g_assert (out_reason); s_adsl = nm_connection_get_setting_adsl (nm_device_get_connection (device)); g_assert (s_adsl); protocol = nm_setting_adsl_get_protocol (s_adsl); nm_log_dbg (LOGD_ADSL, "(%s): using ADSL protocol '%s'", nm_device_get_iface (device), protocol); if (g_strcmp0 (protocol, NM_SETTING_ADSL_PROTOCOL_PPPOE) == 0) { /* PPPoE needs RFC2684 bridging before we can do PPP over it */ if (!br2684_create_iface (self, s_adsl)) { *out_reason = NM_DEVICE_STATE_REASON_BR2684_FAILED; goto done; } /* Set up the VCC */ if (!br2684_assign_vcc (self, s_adsl)) { *out_reason = NM_DEVICE_STATE_REASON_BR2684_FAILED; goto done; } /* Watch for the 'nas' interface going away */ priv->lost_link_id = g_signal_connect (nm_platform_get (), "link-removed", G_CALLBACK (lost_link), self); nm_log_dbg (LOGD_ADSL, "(%s): ATM setup successful", nm_device_get_iface (device)); /* otherwise we're good for stage3 */ nm_platform_link_set_up (priv->nas_ifindex); ret = NM_ACT_STAGE_RETURN_SUCCESS; } else if (g_strcmp0 (protocol, NM_SETTING_ADSL_PROTOCOL_PPPOA) == 0) { /* PPPoA doesn't need anything special */ ret = NM_ACT_STAGE_RETURN_SUCCESS; } else { nm_log_warn (LOGD_ADSL, "(%s): unhandled ADSL protocol '%s'", nm_device_get_iface (device), protocol); } done: return ret; }
static gboolean create_and_realize (NMDevice *device, NMConnection *connection, NMDevice *parent, NMPlatformLink *out_plink, GError **error) { NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (device); const char *iface = nm_device_get_iface (device); NMSettingVlan *s_vlan; int parent_ifindex, vlan_id; NMPlatformError plerr; g_assert (out_plink); s_vlan = nm_connection_get_setting_vlan (connection); g_assert (s_vlan); if (!nm_device_supports_vlans (parent)) { g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED, "no support for VLANs on interface %s of type %s", nm_device_get_iface (parent), nm_device_get_type_desc (parent)); return FALSE; } parent_ifindex = nm_device_get_ifindex (parent); g_warn_if_fail (parent_ifindex > 0); vlan_id = nm_setting_vlan_get_id (s_vlan); plerr = nm_platform_vlan_add (NM_PLATFORM_GET, iface, parent_ifindex, vlan_id, nm_setting_vlan_get_flags (s_vlan), out_plink); if (plerr != NM_PLATFORM_ERROR_SUCCESS && plerr != NM_PLATFORM_ERROR_EXISTS) { g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_CREATION_FAILED, "Failed to create VLAN interface '%s' for '%s': %s", iface, nm_connection_get_id (connection), nm_platform_error_to_string (plerr)); return FALSE; } g_warn_if_fail (priv->parent == NULL); nm_device_vlan_set_parent (NM_DEVICE_VLAN (device), parent); priv->vlan_id = vlan_id; return TRUE; }
static gboolean is_companion (NMDeviceOlpcMesh *self, NMDevice *other) { NMDeviceOlpcMeshPrivate *priv = NM_DEVICE_OLPC_MESH_GET_PRIVATE (self); struct ether_addr their_addr; NMManager *manager; if (!NM_IS_DEVICE_WIFI (other)) return FALSE; nm_device_wifi_get_address (NM_DEVICE_WIFI (other), &their_addr); if (memcmp (priv->hw_addr.ether_addr_octet, their_addr.ether_addr_octet, ETH_ALEN) != 0) { return FALSE; } /* FIXME detect when our companion leaves */ priv->companion = other; /* When we've found the companion, stop listening for other devices */ manager = nm_manager_get (); if (priv->device_added_id) { g_signal_handler_disconnect (manager, priv->device_added_id); priv->device_added_id = 0; } g_object_unref (manager); nm_device_state_changed (NM_DEVICE (self), NM_DEVICE_STATE_DISCONNECTED, NM_DEVICE_STATE_REASON_NONE); nm_log_info (LOGD_OLPC_MESH, "(%s): found companion WiFi device %s", nm_device_get_iface (NM_DEVICE (self)), nm_device_get_iface (other)); g_signal_connect (G_OBJECT (other), "state-changed", G_CALLBACK (companion_state_changed_cb), self); g_signal_connect (G_OBJECT (other), "notify::scanning", G_CALLBACK (companion_notify_cb), self); g_signal_connect (G_OBJECT (other), "scanning-allowed", G_CALLBACK (companion_scan_allowed_cb), self); g_signal_connect (G_OBJECT (other), "autoconnect-allowed", G_CALLBACK (companion_autoconnect_allowed_cb), self); g_object_notify (G_OBJECT (self), NM_DEVICE_OLPC_MESH_COMPANION); return TRUE; }
static void force_disconnect (NMDeviceWimax *self, struct wmxsdk *sdk) { WIMAX_API_DEVICE_STATUS status; int ret; const char *iface; g_return_if_fail (sdk != NULL); iface = nm_device_get_iface (NM_DEVICE (self)); status = iwmxsdk_status_get (sdk); if ((int) status < 0) { nm_log_err (LOGD_WIMAX, "(%s): failed to read WiMAX device status: %d", iface, status); return; } if ( status == WIMAX_API_DEVICE_STATUS_Connecting || status == WIMAX_API_DEVICE_STATUS_Data_Connected) { nm_log_dbg (LOGD_WIMAX, "(%s): requesting disconnect", iface); ret = iwmx_sdk_disconnect (sdk); if (ret < 0 && ret != -EINPROGRESS) { nm_log_err (LOGD_WIMAX, "(%s): failed to disconnect WiMAX device: %d", iface, ret); } } }
static gboolean is_available (NMDevice *device) { NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (device); const char *iface = nm_device_get_iface (device); if (!priv->enabled) { nm_log_dbg (LOGD_WIMAX, "(%s): not available because not enabled", iface); return FALSE; } if (!priv->wimaxd_enabled) { nm_log_dbg (LOGD_WIMAX, "(%s): not available because not enabled in wimaxd", iface); return FALSE; } if (!nm_wimax_util_sdk_is_initialized ()) { nm_log_dbg (LOGD_WIMAX, "(%s): not available because WiMAX SDK not initialized", iface); return FALSE; } if (!priv->sdk) { nm_log_dbg (LOGD_WIMAX, "(%s): not available because not known to WiMAX SDK", iface); return FALSE; } return iwmxsdk_status_get (priv->sdk) >= WIMAX_API_DEVICE_STATUS_Ready; }
static void set_enabled (NMDevice *device, gboolean enabled) { NMDeviceWimax *self = NM_DEVICE_WIMAX (device); NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (self); gboolean old_available; int ret; const char *iface; iface = nm_device_get_iface (NM_DEVICE (self)); nm_log_dbg (LOGD_WIMAX, "(%s): setting radio enabled %d -> %d", iface, priv->enabled, enabled); if (priv->enabled == enabled) return; old_available = nm_device_is_available (NM_DEVICE (device)); priv->enabled = enabled; nm_log_dbg (LOGD_WIMAX, "(%s): radio now %s", iface, priv->enabled ? "enabled" : "disabled"); /* Set the WiMAX device RF state to the current user-specified enabled state */ if (priv->sdk) { ret = iwmx_sdk_rf_state_set (priv->sdk, enabled ? WIMAX_API_RF_ON : WIMAX_API_RF_OFF); if (ret < 0 && ret != -EINPROGRESS) { nm_log_warn (LOGD_WIMAX, "(%s): failed to %s radio", iface, priv->enabled ? "enable" : "disable"); } } update_availability (self, old_available); }
static NMActStageReturn real_act_stage2_config (NMDevice *device, NMDeviceStateReason *reason) { NMDeviceWimaxPrivate *priv = NM_DEVICE_WIMAX_GET_PRIVATE (device); NMConnection *connection; NMSettingWimax *s_wimax; const char *nsp; int ret; connection = nm_act_request_get_connection (nm_device_get_act_request (device)); g_assert (connection); s_wimax = NM_SETTING_WIMAX (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIMAX)); g_assert (s_wimax); nsp = nm_setting_wimax_get_network_name (s_wimax); g_assert (nsp); priv->connect_failed = FALSE; ret = iwmx_sdk_connect (priv->sdk, nsp); if (ret < 0 && ret != -EINPROGRESS) { nm_log_err (LOGD_WIMAX, "(%s): failed to connect to NSP '%s'", nm_device_get_iface (device), nsp); *reason = NM_DEVICE_STATE_REASON_CONFIG_FAILED; return NM_ACT_STAGE_RETURN_FAILURE; } /* FIXME: Is 40 seconds good estimation? I have no idea */ priv->activation_timeout_id = g_timeout_add_seconds (40, activation_timed_out, device); return NM_ACT_STAGE_RETURN_POSTPONE; }
static void update_connection (NMDevice *device, NMConnection *connection) { NMSettingInfiniband *s_infiniband = nm_connection_get_setting_infiniband (connection); const char *mac = nm_device_get_hw_address (device); char *mode_path, *contents = NULL; const char *transport_mode = "datagram"; if (!s_infiniband) { s_infiniband = (NMSettingInfiniband *) nm_setting_infiniband_new (); nm_connection_add_setting (connection, (NMSetting *) s_infiniband); } if (mac && !nm_utils_hwaddr_matches (mac, -1, NULL, INFINIBAND_ALEN)) g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, mac, NULL); mode_path = g_strdup_printf ("/sys/class/net/%s/mode", ASSERT_VALID_PATH_COMPONENT (nm_device_get_iface (device))); contents = nm_platform_sysctl_get (mode_path); g_free (mode_path); if (contents) { if (strstr (contents, "datagram")) transport_mode = "datagram"; else if (strstr (contents, "connected")) transport_mode = "connected"; g_free (contents); } g_object_set (G_OBJECT (s_infiniband), NM_SETTING_INFINIBAND_TRANSPORT_MODE, transport_mode, NULL); }
static gboolean check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { const char *iface; NMSettingBridge *s_bridge; if (!NM_DEVICE_CLASS (nm_device_bridge_parent_class)->check_connection_compatible (device, connection, error)) return FALSE; s_bridge = nm_connection_get_setting_bridge (connection); if (!s_bridge || !nm_connection_is_type (connection, NM_SETTING_BRIDGE_SETTING_NAME)) { g_set_error (error, NM_BRIDGE_ERROR, NM_BRIDGE_ERROR_CONNECTION_NOT_BRIDGE, "The connection was not a bridge connection."); return FALSE; } /* Bridge connections must specify the virtual interface name */ iface = nm_connection_get_virtual_iface_name (connection); if (!iface || strcmp (nm_device_get_iface (device), iface)) { g_set_error (error, NM_BRIDGE_ERROR, NM_BRIDGE_ERROR_CONNECTION_INVALID, "The bridge connection virtual interface name did not match."); return FALSE; } return TRUE; }
static NMDevice * find_device_by_interface_name (NmtDeviceEntry *deventry, const char *interface_name) { NmtDeviceEntryPrivate *priv = NMT_DEVICE_ENTRY_GET_PRIVATE (deventry); const GPtrArray *devices; NMDevice *device = NULL; int i; devices = nm_client_get_devices (nm_client); for (i = 0; i < devices->len && !device; i++) { NMDevice *candidate = devices->pdata[i]; if ( priv->hardware_type != G_TYPE_NONE && !G_TYPE_CHECK_INSTANCE_TYPE (candidate, priv->hardware_type)) continue; if ( priv->device_filter && !priv->device_filter (deventry, candidate, priv->device_filter_data)) continue; if (!g_strcmp0 (interface_name, nm_device_get_iface (candidate))) device = candidate; } return device; }
static gboolean check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { const char *iface; NMSettingBond *s_bond; if (!NM_DEVICE_CLASS (nm_device_bond_parent_class)->check_connection_compatible (device, connection, error)) return FALSE; s_bond = nm_connection_get_setting_bond (connection); if (!s_bond || !nm_connection_is_type (connection, NM_SETTING_BOND_SETTING_NAME)) { g_set_error (error, NM_BOND_ERROR, NM_BOND_ERROR_CONNECTION_NOT_BOND, "The connection was not a bond connection."); return FALSE; } /* Bond connections must specify the virtual interface name */ iface = nm_connection_get_virtual_iface_name (connection); if (!iface || strcmp (nm_device_get_iface (device), iface)) { g_set_error (error, NM_BOND_ERROR, NM_BOND_ERROR_CONNECTION_NOT_BOND, "The bond connection virtual interface name did not match."); return FALSE; } /* FIXME: match bond properties like mode, etc? */ return TRUE; }
static gboolean release_slave (NMDevice *device, NMDevice *slave) { gboolean success, no_firmware = FALSE; success = nm_platform_link_release (nm_device_get_ip_ifindex (device), nm_device_get_ip_ifindex (slave)); nm_log_info (LOGD_BOND, "(%s): released bond slave %s (success %d)", nm_device_get_ip_iface (device), nm_device_get_ip_iface (slave), success); g_object_notify (G_OBJECT (device), "slaves"); /* Kernel bonding code "closes" the slave when releasing it, (which clears * IFF_UP), so we must bring it back up here to ensure carrier changes and * other state is noticed by the now-released slave. */ if (!nm_device_bring_up (slave, TRUE, &no_firmware)) { nm_log_warn (LOGD_BOND, "(%s): released bond slave could not be brought up.", nm_device_get_iface (slave)); } return success; }
void mobile_helper_get_icon (NMDevice *device, NMDeviceState state, NMConnection *connection, GdkPixbuf **out_pixbuf, char **out_indicator_icon, char **tip, NMApplet *applet, guint32 mb_state, guint32 mb_tech, guint32 quality, gboolean quality_valid) { NMSettingConnection *s_con; const char *id; id = nm_device_get_iface (NM_DEVICE (device)); if (connection) { s_con = nm_connection_get_setting_connection (connection); id = nm_setting_connection_get_id (s_con); } switch (state) { case NM_DEVICE_STATE_PREPARE: *tip = g_strdup_printf (_("Preparing mobile broadband connection '%s'..."), id); break; case NM_DEVICE_STATE_CONFIG: *tip = g_strdup_printf (_("Configuring mobile broadband connection '%s'..."), id); break; case NM_DEVICE_STATE_NEED_AUTH: *tip = g_strdup_printf (_("User authentication required for mobile broadband connection '%s'..."), id); break; case NM_DEVICE_STATE_IP_CONFIG: *tip = g_strdup_printf (_("Requesting a network address for '%s'..."), id); break; case NM_DEVICE_STATE_ACTIVATED: *out_pixbuf = mobile_helper_get_status_pixbuf (quality, quality_valid, mb_state, mb_tech, applet); *out_indicator_icon = mobile_helper_get_quality_icon (quality_valid ? quality : 0, applet); if ((mb_state != MB_STATE_UNKNOWN) && quality_valid) { gboolean roaming = (mb_state == MB_STATE_ROAMING); *tip = g_strdup_printf (_("Mobile broadband connection '%s' active: (%d%%%s%s)"), id, quality, roaming ? ", " : "", roaming ? _("roaming") : ""); } else *tip = g_strdup_printf (_("Mobile broadband connection '%s' active"), id); break; default: break; } }
static void update_connection (NMDevice *device, NMConnection *connection) { NMSettingTeam *s_team = nm_connection_get_setting_team (connection); const char *iface = nm_device_get_iface (device); if (!s_team) { s_team = (NMSettingTeam *) nm_setting_team_new (); nm_connection_add_setting (connection, (NMSetting *) s_team); g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_INTERFACE_NAME, iface, NULL); } g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, NULL, NULL); #if WITH_TEAMDCTL if (ensure_teamd_connection (device)) { const char *config = NULL; int err; err = teamdctl_config_get_raw_direct (NM_DEVICE_TEAM_GET_PRIVATE (device)->tdc, (char **)&config); if (err == 0) g_object_set (G_OBJECT (s_team), NM_SETTING_TEAM_CONFIG, config, NULL); else nm_log_err (LOGD_TEAM, "(%s): failed to read teamd config (err=%d)", iface, err); } #endif }
static gboolean carrier_update_cb (gpointer user_data) { NMDeviceAdsl *self = NM_DEVICE_ADSL (user_data); GError *error = NULL; gboolean carrier = FALSE; char *path, *contents; const char *iface; gboolean success; iface = nm_device_get_iface (NM_DEVICE (self)); path = g_strdup_printf ("/sys/class/atm/%s/carrier", iface); success = g_file_get_contents (path, &contents, NULL, &error); g_free (path); if (!success) { nm_log_dbg (LOGD_ADSL, "error reading %s: (%d) %s", path, error ? error->code : -1, error && error->message ? error->message : "(unknown)"); g_clear_error (&error); return TRUE; } carrier = (gboolean) atoi (contents); g_free (contents); nm_device_set_carrier (NM_DEVICE (self), carrier); return TRUE; }
static GObject* constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; NMDeviceAdsl *self; NMDeviceAdslPrivate *priv; object = G_OBJECT_CLASS (nm_device_adsl_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; self = NM_DEVICE_ADSL (object); priv = NM_DEVICE_ADSL_GET_PRIVATE (object); priv->atm_index = get_atm_index (nm_device_get_iface (NM_DEVICE (object))); if (priv->atm_index < 0) { _LOGE (LOGD_ADSL, "error reading ATM device index"); g_object_unref (object); return NULL; } else _LOGD (LOGD_ADSL, "ATM device index %d", priv->atm_index); /* Poll the carrier */ priv->carrier_poll_id = g_timeout_add_seconds (5, carrier_update_cb, object); return object; }
gboolean nm_team_update_slave_connection (NMDevice *slave, NMConnection *connection) { NMSettingTeamPort *s_port; const char *iface = nm_device_get_iface (slave); char *port_config = NULL; gboolean with_teamdctl = FALSE; int err = 0; #if WITH_TEAMDCTL const char *master_iface; int master_ifindex; struct teamdctl *tdc; const char *team_port_config = NULL; #endif g_return_val_if_fail (NM_IS_DEVICE (slave), FALSE); g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE); #if WITH_TEAMDCTL master_ifindex = nm_platform_link_get_master (nm_device_get_ifindex (slave)); g_assert (master_ifindex > 0); master_iface = nm_platform_link_get_name (master_ifindex); g_assert (master_iface); tdc = teamdctl_alloc (); g_assert (tdc); err = teamdctl_connect (tdc, master_iface, NULL, NULL); if (err) { nm_log_err (LOGD_TEAM, "(%s): failed to connect to teamd for master %s (err=%d)", iface, master_iface, err); teamdctl_free (tdc); return FALSE; } err = teamdctl_port_config_get_raw_direct (tdc, iface, (char **)&team_port_config); port_config = g_strdup (team_port_config); teamdctl_free (tdc); with_teamdctl = TRUE; #endif s_port = nm_connection_get_setting_team_port (connection); if (!s_port) { s_port = (NMSettingTeamPort *) nm_setting_team_port_new (); nm_connection_add_setting (connection, NM_SETTING (s_port)); } g_object_set (G_OBJECT (s_port), NM_SETTING_TEAM_PORT_CONFIG, port_config, NULL); g_free (port_config); if (!with_teamdctl || err != 0) { if (!with_teamdctl) nm_log_err (LOGD_TEAM, "(%s): failed to read teamd port configuration " " (compiled without libteamdctl support)", iface); else nm_log_err (LOGD_TEAM, "(%s): failed to read teamd port configuration (err=%d)", iface, err); return FALSE; } return TRUE; }
static void dump_device (NMDevice *device) { const char *str; NMDeviceState state; str = nm_device_get_iface (device); g_print ("Interface: %s\n", str); str = nm_device_get_udi (device); g_print ("Udi: %s\n", str); str = nm_device_get_driver (device); g_print ("Driver: %s\n", str); str = nm_device_get_vendor (device); g_print ("Vendor: %s\n", str); str = nm_device_get_product (device); g_print ("Product: %s\n", str); state = nm_device_get_state (device); g_print ("State: %d\n", state); if (state == NM_DEVICE_STATE_ACTIVATED) dump_ip4_config (nm_device_get_ip4_config (device)); if (NM_IS_DEVICE_ETHERNET (device)) dump_wired (NM_DEVICE_ETHERNET (device)); else if (NM_IS_DEVICE_WIFI (device)) dump_wireless (NM_DEVICE_WIFI (device)); dump_dhcp4_config (nm_device_get_dhcp4_config (device)); }
static void update_connection (NMDevice *device, NMConnection *connection) { NMSettingBridge *s_bridge = nm_connection_get_setting_bridge (connection); const char *ifname = nm_device_get_iface (device); int ifindex = nm_device_get_ifindex (device); const Option *option; if (!s_bridge) { s_bridge = (NMSettingBridge *) nm_setting_bridge_new (); nm_connection_add_setting (connection, (NMSetting *) s_bridge); g_object_set (s_bridge, NM_SETTING_BRIDGE_INTERFACE_NAME, ifname, NULL); } for (option = master_options; option->name; option++) { gs_free char *str = nm_platform_master_get_option (ifindex, option->sysname); int value = strtol (str, NULL, 10); /* See comments in set_sysfs_uint() about centiseconds. */ if (option->user_hz_compensate) value /= 100; g_object_set (s_bridge, option->name, value, NULL); } }
static void device_state_changed (NMDevice *device, GParamSpec *pspec, gpointer user_data) { g_print ("Device state changed: %s %d\n", nm_device_get_iface (device), nm_device_get_state (device)); }
static void handle_availability_change (NMDeviceBt *self, gboolean old_available, NMDeviceStateReason unavailable_reason) { NMDevice *device = NM_DEVICE (self); NMDeviceState state; gboolean available; state = nm_device_get_state (device); if (state < NM_DEVICE_STATE_UNAVAILABLE) { nm_log_dbg (LOGD_BT, "(%s): availability blocked by UNMANAGED state", nm_device_get_iface (device)); return; } available = nm_device_is_available (device); if (available == old_available) return; if (available) { if (state != NM_DEVICE_STATE_UNAVAILABLE) nm_log_warn (LOGD_CORE | LOGD_BT, "not in expected unavailable state!"); nm_device_state_changed (device, NM_DEVICE_STATE_DISCONNECTED, NM_DEVICE_STATE_REASON_NONE); } else { nm_device_state_changed (device, NM_DEVICE_STATE_UNAVAILABLE, unavailable_reason); } }