/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */ /* NetworkManager -- Network link manager * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Copyright (C) 2005 - 2011 Red Hat, Inc. * Copyright (C) 2006 - 2008 Novell, Inc. */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "nm-glib-compat.h" #include "nm-device-ethernet.h" #include "nm-device-interface.h" #include "nm-device-private.h" #include "nm-activation-request.h" #include "NetworkManagerUtils.h" #include "nm-supplicant-manager.h" #include "nm-supplicant-interface.h" #include "nm-supplicant-config.h" #include "nm-netlink-monitor.h" #include "nm-system.h" #include "nm-setting-connection.h" #include "nm-setting-wired.h" #include "nm-setting-8021x.h" #include "nm-setting-pppoe.h" #include "ppp-manager/nm-ppp-manager.h" #include "nm-logging.h" #include "nm-properties-changed-signal.h" #include "nm-dhcp-manager.h" #include "nm-device-ethernet-glue.h" G_DEFINE_TYPE (NMDeviceEthernet, nm_device_ethernet, NM_TYPE_DEVICE) #define NM_DEVICE_ETHERNET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_DEVICE_ETHERNET, NMDeviceEthernetPrivate)) #define WIRED_SECRETS_TRIES "wired-secrets-tries" typedef enum { NM_ETHERNET_ERROR_CONNECTION_NOT_WIRED = 0, NM_ETHERNET_ERROR_CONNECTION_INVALID, NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE, } NMEthernetError; #define NM_ETHERNET_ERROR (nm_ethernet_error_quark ()) #define NM_TYPE_ETHERNET_ERROR (nm_ethernet_error_get_type ()) typedef struct Supplicant { NMSupplicantManager *mgr; NMSupplicantInterface *iface; /* signal handler ids */ guint iface_error_id; guint iface_state_id; /* Timeouts and idles */ guint iface_con_error_cb_id; guint con_timeout_id; } Supplicant; typedef struct { gboolean disposed; guint8 hw_addr[ETH_ALEN]; /* Currently set MAC address */ guint8 perm_hw_addr[ETH_ALEN]; /* Permanent MAC address */ guint8 initial_hw_addr[ETH_ALEN]; /* Initial MAC address (as seen when NM starts) */ gboolean carrier; NMNetlinkMonitor * monitor; gulong link_connected_id; gulong link_disconnected_id; guint carrier_action_defer_id; Supplicant supplicant; guint supplicant_timeout_id; /* s390 */ char * subchan1; char * subchan2; char * subchan3; char * subchannels; /* Composite used for checking unmanaged specs */ /* PPPoE */ NMPPPManager *ppp_manager; NMIP4Config *pending_ip4_config; } NMDeviceEthernetPrivate; enum { PROPERTIES_CHANGED, LAST_SIGNAL }; static guint signals[LAST_SIGNAL] = { 0 }; enum { PROP_0, PROP_HW_ADDRESS, PROP_PERM_HW_ADDRESS, PROP_SPEED, PROP_CARRIER, LAST_PROP }; static gboolean supports_mii_carrier_detect (NMDeviceEthernet *dev); static gboolean supports_ethtool_carrier_detect (NMDeviceEthernet *dev); static GQuark nm_ethernet_error_quark (void) { static GQuark quark = 0; if (!quark) quark = g_quark_from_static_string ("nm-ethernet-error"); return quark; } /* This should really be standard. */ #define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC } static GType nm_ethernet_error_get_type (void) { static GType etype = 0; if (etype == 0) { static const GEnumValue values[] = { /* Connection was not a wired connection. */ ENUM_ENTRY (NM_ETHERNET_ERROR_CONNECTION_NOT_WIRED, "ConnectionNotWired"), /* Connection was not a valid wired connection. */ ENUM_ENTRY (NM_ETHERNET_ERROR_CONNECTION_INVALID, "ConnectionInvalid"), /* Connection does not apply to this device. */ ENUM_ENTRY (NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE, "ConnectionIncompatible"), { 0, 0, 0 } }; etype = g_enum_register_static ("NMEthernetError", values); } return etype; } static void carrier_action_defer_clear (NMDeviceEthernet *self) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); if (priv->carrier_action_defer_id) { g_source_remove (priv->carrier_action_defer_id); priv->carrier_action_defer_id = 0; } } static gboolean carrier_action_defer_cb (gpointer user_data) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (user_data); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMDeviceState state; priv->carrier_action_defer_id = 0; state = nm_device_interface_get_state (NM_DEVICE_INTERFACE (self)); if (state == NM_DEVICE_STATE_UNAVAILABLE) { if (priv->carrier) nm_device_state_changed (NM_DEVICE (self), NM_DEVICE_STATE_DISCONNECTED, NM_DEVICE_STATE_REASON_CARRIER); } else if (state >= NM_DEVICE_STATE_DISCONNECTED) { if (!priv->carrier) nm_device_state_changed (NM_DEVICE (self), NM_DEVICE_STATE_UNAVAILABLE, NM_DEVICE_STATE_REASON_CARRIER); } return FALSE; } static void set_carrier (NMDeviceEthernet *self, const gboolean carrier, const gboolean defer_action) { NMDeviceEthernetPrivate *priv; NMDeviceState state; g_return_if_fail (NM_IS_DEVICE (self)); priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); if (priv->carrier == carrier) return; /* Clear any previous deferred action */ carrier_action_defer_clear (self); priv->carrier = carrier; g_object_notify (G_OBJECT (self), NM_DEVICE_ETHERNET_CARRIER); state = nm_device_interface_get_state (NM_DEVICE_INTERFACE (self)); nm_log_info (LOGD_HW | LOGD_ETHER, "(%s): carrier now %s (device state %d%s)", nm_device_get_iface (NM_DEVICE (self)), carrier ? "ON" : "OFF", state, defer_action ? ", deferring action for 4 seconds" : ""); if (defer_action) priv->carrier_action_defer_id = g_timeout_add_seconds (4, carrier_action_defer_cb, self); else carrier_action_defer_cb (self); } static void carrier_on (NMNetlinkMonitor *monitor, int idx, gpointer user_data) { NMDevice *device = NM_DEVICE (user_data); NMDeviceEthernet *self = NM_DEVICE_ETHERNET (device); guint32 caps; /* Make sure signal is for us */ if (idx == nm_device_get_ifindex (device)) { /* Ignore spurious netlink messages */ caps = nm_device_get_capabilities (device); if (!(caps & NM_DEVICE_CAP_CARRIER_DETECT)) return; set_carrier (self, TRUE, FALSE); } } static void carrier_off (NMNetlinkMonitor *monitor, int idx, gpointer user_data) { NMDevice *device = NM_DEVICE (user_data); NMDeviceEthernet *self = NM_DEVICE_ETHERNET (device); guint32 caps; /* Make sure signal is for us */ if (idx == nm_device_get_ifindex (device)) { NMDeviceState state; gboolean defer = FALSE; /* Ignore spurious netlink messages */ caps = nm_device_get_capabilities (device); if (!(caps & NM_DEVICE_CAP_CARRIER_DETECT)) return; /* Defer carrier-off event actions while connected by a few seconds * so that tripping over a cable, power-cycling a switch, or breaking * off the RJ45 locking tab isn't so catastrophic. */ state = nm_device_interface_get_state (NM_DEVICE_INTERFACE (self)); if (state > NM_DEVICE_STATE_DISCONNECTED) defer = TRUE; set_carrier (self, FALSE, defer); } } static void _update_s390_subchannels (NMDeviceEthernet *self) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); const char *iface; GUdevClient *client; GUdevDevice *dev; GUdevDevice *parent = NULL; const char *parent_path, *item, *driver; const char *subsystems[] = { "net", NULL }; GDir *dir; GError *error = NULL; iface = nm_device_get_iface (NM_DEVICE (self)); client = g_udev_client_new (subsystems); if (!client) { nm_log_warn (LOGD_DEVICE | LOGD_HW, "(%s): failed to initialize GUdev client", iface); return; } dev = g_udev_client_query_by_subsystem_and_name (client, "net", iface); if (!dev) { nm_log_warn (LOGD_DEVICE | LOGD_HW, "(%s): failed to find device with udev", iface); goto out; } /* Try for the "ccwgroup" parent */ parent = g_udev_device_get_parent_with_subsystem (dev, "ccwgroup", NULL); if (!parent) { /* FIXME: whatever 'lcs' devices' subsystem is here... */ if (!parent) { /* Not an s390 device */ goto out; } } parent_path = g_udev_device_get_sysfs_path (parent); dir = g_dir_open (parent_path, 0, &error); if (!dir) { nm_log_warn (LOGD_DEVICE | LOGD_HW, "(%s): failed to open directory '%s': %s", iface, parent_path, error && error->message ? error->message : "(unknown)"); g_clear_error (&error); goto out; } /* FIXME: we probably care about ordering here to ensure that we map * cdev0 -> subchan1, cdev1 -> subchan2, etc. */ while ((item = g_dir_read_name (dir))) { char buf[50]; char *cdev_path; if (strncmp (item, "cdev", 4)) continue; /* Not a subchannel link */ cdev_path = g_strdup_printf ("%s/%s", parent_path, item); memset (buf, 0, sizeof (buf)); errno = 0; if (readlink (cdev_path, &buf[0], sizeof (buf) - 1) >= 0) { if (!priv->subchan1) priv->subchan1 = g_path_get_basename (buf); else if (!priv->subchan2) priv->subchan2 = g_path_get_basename (buf); else if (!priv->subchan3) priv->subchan3 = g_path_get_basename (buf); } else { nm_log_warn (LOGD_DEVICE | LOGD_HW, "(%s): failed to read cdev link '%s': %d", iface, cdev_path, errno); } g_free (cdev_path); }; g_dir_close (dir); if (priv->subchan3) { priv->subchannels = g_strdup_printf ("%s,%s,%s", priv->subchan1, priv->subchan2, priv->subchan3); } else if (priv->subchan2) { priv->subchannels = g_strdup_printf ("%s,%s", priv->subchan1, priv->subchan2); } else priv->subchannels = g_strdup (priv->subchan1); driver = nm_device_get_driver (NM_DEVICE (self)); nm_log_info (LOGD_DEVICE | LOGD_HW, "(%s): found s390 '%s' subchannels [%s]", iface, driver ? driver : "(unknown driver)", priv->subchannels); out: if (parent) g_object_unref (parent); if (dev) g_object_unref (dev); g_object_unref (client); } static GObject* constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; NMDeviceEthernetPrivate *priv; NMDevice *self; guint32 caps; object = G_OBJECT_CLASS (nm_device_ethernet_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; self = NM_DEVICE (object); priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); nm_log_dbg (LOGD_HW | LOGD_OLPC_MESH, "(%s): kernel ifindex %d", nm_device_get_iface (NM_DEVICE (self)), nm_device_get_ifindex (NM_DEVICE (self))); /* s390 stuff */ _update_s390_subchannels (NM_DEVICE_ETHERNET (self)); caps = nm_device_get_capabilities (self); if (caps & NM_DEVICE_CAP_CARRIER_DETECT) { GError *error = NULL; guint32 ifflags = 0; /* Only listen to netlink for cards that support carrier detect */ priv->monitor = nm_netlink_monitor_get (); priv->link_connected_id = g_signal_connect (priv->monitor, "carrier-on", G_CALLBACK (carrier_on), self); priv->link_disconnected_id = g_signal_connect (priv->monitor, "carrier-off", G_CALLBACK (carrier_off), self); /* Get initial link state */ if (!nm_netlink_monitor_get_flags_sync (priv->monitor, nm_device_get_ifindex (NM_DEVICE (self)), &ifflags, &error)) { nm_log_warn (LOGD_HW | LOGD_ETHER, "(%s): couldn't get initial carrier state: (%d) %s", nm_device_get_iface (NM_DEVICE (self)), error ? error->code : -1, (error && error->message) ? error->message : "unknown"); g_clear_error (&error); } else priv->carrier = !!(ifflags & IFF_LOWER_UP); nm_log_info (LOGD_HW | LOGD_ETHER, "(%s): carrier is %s", nm_device_get_iface (NM_DEVICE (self)), priv->carrier ? "ON" : "OFF"); /* Request link state again just in case an error occurred getting the * initial link state. */ if (!nm_netlink_monitor_request_status (priv->monitor, &error)) { nm_log_warn (LOGD_HW | LOGD_ETHER, "(%s): couldn't request carrier state: (%d) %s", nm_device_get_iface (NM_DEVICE (self)), error ? error->code : -1, (error && error->message) ? error->message : "unknown"); g_clear_error (&error); } } else { nm_log_info (LOGD_HW | LOGD_ETHER, "(%s): driver '%s' does not support carrier detection.", nm_device_get_iface (self), nm_device_get_driver (self)); priv->carrier = TRUE; } return object; } static void clear_secrets_tries (NMDevice *device) { NMActRequest *req; NMConnection *connection; req = nm_device_get_act_request (device); if (req) { connection = nm_act_request_get_connection (req); /* Clear wired secrets tries on success, failure, or when deactivating */ g_object_set_data (G_OBJECT (connection), WIRED_SECRETS_TRIES, NULL); } } static void device_state_changed (NMDevice *device, NMDeviceState new_state, NMDeviceState old_state, NMDeviceStateReason reason, gpointer user_data) { switch (new_state) { case NM_DEVICE_STATE_ACTIVATED: case NM_DEVICE_STATE_FAILED: case NM_DEVICE_STATE_DISCONNECTED: clear_secrets_tries (device); break; default: break; } } static void nm_device_ethernet_init (NMDeviceEthernet * self) { g_signal_connect (self, "state-changed", G_CALLBACK (device_state_changed), NULL); } static gboolean real_is_up (NMDevice *device) { if (!NM_DEVICE_ETHERNET_GET_PRIVATE (device)->supplicant.mgr) return FALSE; return TRUE; } static gboolean real_bring_up (NMDevice *dev) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (dev); priv->supplicant.mgr = nm_supplicant_manager_get (); return priv->supplicant.mgr ? TRUE : FALSE; } static void real_take_down (NMDevice *dev) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (dev); if (priv->supplicant.mgr) { g_object_unref (priv->supplicant.mgr); priv->supplicant.mgr = NULL; } } static gboolean real_hw_is_up (NMDevice *device) { return nm_system_device_is_up (device); } static gboolean real_hw_bring_up (NMDevice *dev, gboolean *no_firmware) { return nm_system_device_set_up_down (dev, TRUE, no_firmware); } static void real_hw_take_down (NMDevice *dev) { nm_system_device_set_up_down (dev, FALSE, NULL); } NMDevice * nm_device_ethernet_new (const char *udi, const char *iface, const char *driver) { g_return_val_if_fail (udi != NULL, NULL); g_return_val_if_fail (iface != NULL, NULL); g_return_val_if_fail (driver != NULL, NULL); return (NMDevice *) g_object_new (NM_TYPE_DEVICE_ETHERNET, NM_DEVICE_INTERFACE_UDI, udi, NM_DEVICE_INTERFACE_IFACE, iface, NM_DEVICE_INTERFACE_DRIVER, driver, NM_DEVICE_INTERFACE_TYPE_DESC, "Ethernet", NM_DEVICE_INTERFACE_DEVICE_TYPE, NM_DEVICE_TYPE_ETHERNET, NULL); } /* * nm_device_ethernet_get_address * * Get a device's hardware address * */ void nm_device_ethernet_get_address (NMDeviceEthernet *self, struct ether_addr *addr) { NMDeviceEthernetPrivate *priv; g_return_if_fail (self != NULL); g_return_if_fail (addr != NULL); priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); memcpy (addr, &priv->hw_addr, sizeof (priv->hw_addr)); } /* Returns speed in Mb/s */ static guint32 nm_device_ethernet_get_speed (NMDeviceEthernet *self) { int fd; struct ifreq ifr; struct ethtool_cmd edata = { .cmd = ETHTOOL_GSET, }; guint32 speed = 0; g_return_val_if_fail (self != NULL, 0); fd = socket (PF_INET, SOCK_DGRAM, 0); if (fd < 0) { nm_log_warn (LOGD_HW, "couldn't open control socket."); return 0; } memset (&ifr, 0, sizeof (struct ifreq)); strncpy (ifr.ifr_name, nm_device_get_iface (NM_DEVICE (self)), IFNAMSIZ); ifr.ifr_data = (char *) &edata; if (ioctl (fd, SIOCETHTOOL, &ifr) < 0) goto out; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) speed = edata.speed; #else speed = ethtool_cmd_speed (&edata); #endif if (speed == G_MAXUINT16 || speed == G_MAXUINT32) speed = 0; out: close (fd); return speed; } static void _update_hw_addr (NMDeviceEthernet *self, const guint8 *addr) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); g_return_if_fail (addr != NULL); if (memcmp (&priv->hw_addr, addr, ETH_ALEN)) { memcpy (&priv->hw_addr, addr, ETH_ALEN); g_object_notify (G_OBJECT (self), NM_DEVICE_ETHERNET_HW_ADDRESS); } } static gboolean _set_hw_addr (NMDeviceEthernet *self, const guint8 *addr, const char *detail) { NMDevice *dev = NM_DEVICE (self); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); const char *iface; char *mac_str = NULL; gboolean success = FALSE; g_return_val_if_fail (addr != NULL, FALSE); iface = nm_device_get_iface (dev); mac_str = g_strdup_printf ("%02X:%02X:%02X:%02X:%02X:%02X", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); /* Do nothing if current MAC is same */ if (!memcmp (&priv->hw_addr, addr, ETH_ALEN)) { nm_log_dbg (LOGD_DEVICE | LOGD_ETHER, "(%s): no MAC address change needed", iface); g_free (mac_str); return TRUE; } /* Can't change MAC address while device is up */ real_hw_take_down (dev); success = nm_system_device_set_mac (iface, (struct ether_addr *) addr); if (success) { /* MAC address succesfully changed; update the current MAC to match */ _update_hw_addr (self, addr); nm_log_info (LOGD_DEVICE | LOGD_ETHER, "(%s): %s MAC address to %s", iface, detail, mac_str); } else { nm_log_warn (LOGD_DEVICE | LOGD_ETHER, "(%s): failed to %s MAC address to %s", iface, detail, mac_str); } real_hw_bring_up (dev, NULL); g_free (mac_str); return success; } static void real_update_hw_address (NMDevice *dev) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); struct ifreq req; int fd; fd = socket (PF_INET, SOCK_DGRAM, 0); if (fd < 0) { nm_log_warn (LOGD_HW, "couldn't open control socket."); 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_ETHER, "(%s) failed to read hardware address (error %d)", nm_device_get_iface (dev), errno); } else _update_hw_addr (self, (const guint8 *) &req.ifr_hwaddr.sa_data); close (fd); } static void real_update_permanent_hw_address (NMDevice *dev) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); struct ifreq req; struct ethtool_perm_addr *epaddr = NULL; int fd, ret; fd = socket (PF_INET, SOCK_DGRAM, 0); if (fd < 0) { nm_log_warn (LOGD_HW, "couldn't open control socket."); return; } /* Get permanent MAC address */ memset (&req, 0, sizeof (struct ifreq)); strncpy (req.ifr_name, nm_device_get_iface (dev), IFNAMSIZ); epaddr = g_malloc0 (sizeof (struct ethtool_perm_addr) + ETH_ALEN); epaddr->cmd = ETHTOOL_GPERMADDR; epaddr->size = ETH_ALEN; req.ifr_data = (void *) epaddr; errno = 0; ret = ioctl (fd, SIOCETHTOOL, &req); if ((ret < 0) || !nm_ethernet_address_is_valid ((struct ether_addr *) epaddr->data)) { nm_log_err (LOGD_HW | LOGD_ETHER, "(%s): unable to read permanent MAC address (error %d)", nm_device_get_iface (dev), errno); /* Fall back to current address */ memcpy (epaddr->data, &priv->hw_addr, ETH_ALEN); } if (memcmp (&priv->perm_hw_addr, epaddr->data, ETH_ALEN)) { memcpy (&priv->perm_hw_addr, epaddr->data, ETH_ALEN); g_object_notify (G_OBJECT (dev), NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS); } close (fd); } static void real_update_initial_hw_address (NMDevice *dev) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); char *mac_str = NULL; guint8 *addr = priv->initial_hw_addr; guint8 zero[ETH_ALEN] = {0,0,0,0,0,0}; /* This sets initial MAC address from current MAC address. It should only * be called from NMDevice constructor() to really get the initial address. */ if (!memcmp (&priv->hw_addr, &zero, ETH_ALEN)) real_update_hw_address (dev); if (memcmp (&priv->initial_hw_addr, &priv->hw_addr, ETH_ALEN)) memcpy (&priv->initial_hw_addr, &priv->hw_addr, ETH_ALEN); mac_str = g_strdup_printf ("%02X:%02X:%02X:%02X:%02X:%02X", addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]); nm_log_dbg (LOGD_DEVICE | LOGD_ETHER, "(%s): read initial MAC address %s", nm_device_get_iface (dev), mac_str); g_free (mac_str); } static guint32 real_get_generic_capabilities (NMDevice *dev) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); guint32 caps = NM_DEVICE_CAP_NONE; /* cipsec devices are also explicitly unsupported at this time */ if (strstr (nm_device_get_iface (dev), "cipsec")) return NM_DEVICE_CAP_NONE; if (supports_ethtool_carrier_detect (self) || supports_mii_carrier_detect (self)) caps |= NM_DEVICE_CAP_CARRIER_DETECT; caps |= NM_DEVICE_CAP_NM_SUPPORTED; return caps; } static gboolean real_can_interrupt_activation (NMDevice *dev) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); gboolean interrupt = FALSE; /* Devices that support carrier detect can interrupt activation * if the link becomes inactive. */ if (nm_device_get_capabilities (dev) & NM_DEVICE_CAP_CARRIER_DETECT) { if (NM_DEVICE_ETHERNET_GET_PRIVATE (self)->carrier == FALSE) interrupt = TRUE; } return interrupt; } static gboolean real_is_available (NMDevice *dev) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); /* Can't do anything if there isn't a carrier */ if (!NM_DEVICE_ETHERNET_GET_PRIVATE (self)->carrier) return FALSE; return TRUE; } static gboolean match_subchans (NMDeviceEthernet *self, NMSettingWired *s_wired, gboolean *try_mac) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); const GPtrArray *subchans; int i; *try_mac = TRUE; subchans = nm_setting_wired_get_s390_subchannels (s_wired); if (!subchans) return TRUE; /* connection requires subchannels but the device has none */ if (!priv->subchannels) return FALSE; /* Make sure each subchannel in the connection is a subchannel of this device */ for (i = 0; i < subchans->len; i++) { const char *candidate = g_ptr_array_index (subchans, i); if ( (priv->subchan1 && !strcmp (priv->subchan1, candidate)) || (priv->subchan2 && !strcmp (priv->subchan2, candidate)) || (priv->subchan3 && !strcmp (priv->subchan3, candidate))) continue; return FALSE; /* a subchannel was not found */ } *try_mac = FALSE; return TRUE; } static NMConnection * real_get_best_auto_connection (NMDevice *dev, GSList *connections, char **specific_object) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); GSList *iter; for (iter = connections; iter; iter = g_slist_next (iter)) { NMConnection *connection = NM_CONNECTION (iter->data); NMSettingConnection *s_con; NMSettingWired *s_wired; const char *connection_type; gboolean is_pppoe = FALSE; const GSList *mac_blacklist, *mac_blacklist_iter; gboolean mac_blacklist_found = FALSE; s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION); g_assert (s_con); connection_type = nm_setting_connection_get_connection_type (s_con); if (!strcmp (connection_type, NM_SETTING_PPPOE_SETTING_NAME)) is_pppoe = TRUE; if (!is_pppoe && strcmp (connection_type, NM_SETTING_WIRED_SETTING_NAME)) continue; if (!nm_setting_connection_get_autoconnect (s_con)) continue; s_wired = (NMSettingWired *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRED); /* Wired setting optional for PPPoE */ if (!is_pppoe && !s_wired) continue; if (s_wired) { const GByteArray *mac; gboolean try_mac = TRUE; if (!match_subchans (self, s_wired, &try_mac)) continue; mac = nm_setting_wired_get_mac_address (s_wired); if (try_mac && mac && memcmp (mac->data, &priv->perm_hw_addr, ETH_ALEN)) continue; /* Check for MAC address blacklist */ mac_blacklist = nm_setting_wired_get_mac_address_blacklist (s_wired); for (mac_blacklist_iter = mac_blacklist; mac_blacklist_iter; mac_blacklist_iter = g_slist_next (mac_blacklist_iter)) { struct ether_addr addr; if (!ether_aton_r (mac_blacklist_iter->data, &addr)) { g_warn_if_reached (); continue; } if (memcmp (&addr, &priv->perm_hw_addr, ETH_ALEN) == 0) { mac_blacklist_found = TRUE; break; } } /* Found device MAC address in the blacklist - do not use this connection */ if (mac_blacklist_found) continue; } return connection; } return NULL; } /* FIXME: Move it to nm-device.c and then get rid of all foo_device_get_setting() all around. It's here now to keep the patch short. */ static NMSetting * device_get_setting (NMDevice *device, GType setting_type) { NMActRequest *req; NMSetting *setting = NULL; req = nm_device_get_act_request (device); if (req) { NMConnection *connection; connection = nm_act_request_get_connection (req); if (connection) setting = nm_connection_get_setting (connection, setting_type); } return setting; } /*****************************************************************************/ /* 802.1X */ static void remove_supplicant_timeouts (NMDeviceEthernet *self) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); if (priv->supplicant.con_timeout_id) { g_source_remove (priv->supplicant.con_timeout_id); priv->supplicant.con_timeout_id = 0; } if (priv->supplicant_timeout_id) { g_source_remove (priv->supplicant_timeout_id); priv->supplicant_timeout_id = 0; } } static void remove_supplicant_interface_error_handler (NMDeviceEthernet *self) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); if (priv->supplicant.iface_error_id != 0) { g_signal_handler_disconnect (priv->supplicant.iface, priv->supplicant.iface_error_id); priv->supplicant.iface_error_id = 0; } if (priv->supplicant.iface_con_error_cb_id > 0) { g_source_remove (priv->supplicant.iface_con_error_cb_id); priv->supplicant.iface_con_error_cb_id = 0; } } static void supplicant_interface_release (NMDeviceEthernet *self) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); remove_supplicant_timeouts (self); remove_supplicant_interface_error_handler (self); if (priv->supplicant.iface_state_id > 0) { g_signal_handler_disconnect (priv->supplicant.iface, priv->supplicant.iface_state_id); priv->supplicant.iface_state_id = 0; } if (priv->supplicant.iface) { nm_supplicant_interface_disconnect (priv->supplicant.iface); nm_supplicant_manager_iface_release (priv->supplicant.mgr, priv->supplicant.iface); priv->supplicant.iface = NULL; } } static void wired_secrets_cb (NMActRequest *req, guint32 call_id, NMConnection *connection, GError *error, gpointer user_data) { NMDevice *dev = NM_DEVICE (user_data); g_return_if_fail (req == nm_device_get_act_request (dev)); g_return_if_fail (nm_device_get_state (dev) == NM_DEVICE_STATE_NEED_AUTH); g_return_if_fail (nm_act_request_get_connection (req) == connection); if (error) { nm_log_warn (LOGD_ETHER, "%s", error->message); nm_device_state_changed (dev, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_NO_SECRETS); } else nm_device_activate_schedule_stage1_device_prepare (dev); } static gboolean link_timeout_cb (gpointer user_data) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (user_data); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMDevice *dev = NM_DEVICE (self); NMActRequest *req; NMConnection *connection; const char *setting_name; priv->supplicant_timeout_id = 0; req = nm_device_get_act_request (dev); if (nm_device_get_state (dev) == NM_DEVICE_STATE_ACTIVATED) { nm_device_state_changed (dev, NM_DEVICE_STATE_DISCONNECTED, NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT); return FALSE; } /* Disconnect event during initial authentication and credentials * ARE checked - we are likely to have wrong key. Ask the user for * another one. */ if (nm_device_get_state (dev) != NM_DEVICE_STATE_CONFIG) goto time_out; connection = nm_act_request_get_connection (req); nm_connection_clear_secrets (connection); setting_name = nm_connection_need_secrets (connection, NULL); if (!setting_name) goto time_out; nm_log_info (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): disconnected during authentication," " asking for new key.", nm_device_get_iface (dev)); supplicant_interface_release (self); nm_device_state_changed (dev, NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT); nm_act_request_get_secrets (req, setting_name, NM_SETTINGS_GET_SECRETS_FLAG_REQUEST_NEW, NULL, wired_secrets_cb, self); return FALSE; time_out: nm_log_warn (LOGD_DEVICE | LOGD_ETHER, "(%s): link timed out.", nm_device_get_iface (dev)); nm_device_state_changed (dev, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT); return FALSE; } static NMSupplicantConfig * build_supplicant_config (NMDeviceEthernet *self) { const char *con_path; NMSupplicantConfig *config = NULL; NMSetting8021x *security; NMConnection *connection; connection = nm_act_request_get_connection (nm_device_get_act_request (NM_DEVICE (self))); g_return_val_if_fail (connection, NULL); con_path = nm_connection_get_path (connection); config = nm_supplicant_config_new (); if (!config) return NULL; security = NM_SETTING_802_1X (nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X)); if (!nm_supplicant_config_add_setting_8021x (config, security, con_path, TRUE)) { nm_log_warn (LOGD_DEVICE, "Couldn't add 802.1X security setting to supplicant config."); g_object_unref (config); config = NULL; } return config; } static void supplicant_iface_state_cb (NMSupplicantInterface *iface, guint32 new_state, guint32 old_state, gpointer user_data) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (user_data); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMDevice *device = NM_DEVICE (self); NMSupplicantConfig *config; gboolean success = FALSE; NMDeviceState devstate; if (new_state == old_state) return; nm_log_info (LOGD_DEVICE | LOGD_ETHER, "(%s): supplicant interface state: %s -> %s", nm_device_get_iface (device), nm_supplicant_interface_state_to_string (old_state), nm_supplicant_interface_state_to_string (new_state)); devstate = nm_device_get_state (device); switch (new_state) { case NM_SUPPLICANT_INTERFACE_STATE_READY: config = build_supplicant_config (self); if (config) { success = nm_supplicant_interface_set_config (priv->supplicant.iface, config); g_object_unref (config); if (!success) { nm_log_err (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): couldn't send security " "configuration to the supplicant.", nm_device_get_iface (device)); } } else { nm_log_warn (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): couldn't build security configuration.", nm_device_get_iface (device)); } if (!success) { nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED); } break; case NM_SUPPLICANT_INTERFACE_STATE_COMPLETED: remove_supplicant_interface_error_handler (self); remove_supplicant_timeouts (self); /* If this is the initial association during device activation, * schedule the next activation stage. */ if (devstate == NM_DEVICE_STATE_CONFIG) { nm_log_info (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired) Stage 2 of 5 (Device Configure) successful.", nm_device_get_iface (device)); nm_device_activate_schedule_stage3_ip_config_start (device); } break; case NM_SUPPLICANT_INTERFACE_STATE_DISCONNECTED: if ((devstate == NM_DEVICE_STATE_ACTIVATED) || nm_device_is_activating (device)) { /* Start the link timeout so we allow some time for reauthentication */ if (!priv->supplicant_timeout_id) priv->supplicant_timeout_id = g_timeout_add_seconds (15, link_timeout_cb, device); } break; case NM_SUPPLICANT_INTERFACE_STATE_DOWN: supplicant_interface_release (self); remove_supplicant_timeouts (self); if ((devstate == NM_DEVICE_STATE_ACTIVATED) || nm_device_is_activating (device)) { nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_SUPPLICANT_FAILED); } break; default: break; } } static gboolean supplicant_iface_connection_error_cb_handler (gpointer user_data) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (user_data); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); supplicant_interface_release (self); nm_device_state_changed (NM_DEVICE (self), NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_SUPPLICANT_CONFIG_FAILED); priv->supplicant.iface_con_error_cb_id = 0; return FALSE; } static void supplicant_iface_connection_error_cb (NMSupplicantInterface *iface, const char *name, const char *message, gpointer user_data) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (user_data); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); guint id; nm_log_warn (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): association request to the supplicant failed: %s - %s", nm_device_get_iface (NM_DEVICE (self)), name, message); if (priv->supplicant.iface_con_error_cb_id) g_source_remove (priv->supplicant.iface_con_error_cb_id); id = g_idle_add (supplicant_iface_connection_error_cb_handler, self); priv->supplicant.iface_con_error_cb_id = id; } static NMActStageReturn handle_auth_or_fail (NMDeviceEthernet *self, NMActRequest *req, gboolean new_secrets) { const char *setting_name; guint32 tries; NMConnection *connection; connection = nm_act_request_get_connection (req); g_assert (connection); tries = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (connection), WIRED_SECRETS_TRIES)); if (tries > 3) return NM_ACT_STAGE_RETURN_FAILURE; nm_device_state_changed (NM_DEVICE (self), NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_REASON_NONE); nm_connection_clear_secrets (connection); setting_name = nm_connection_need_secrets (connection, NULL); if (setting_name) { NMSettingsGetSecretsFlags flags = NM_SETTINGS_GET_SECRETS_FLAG_ALLOW_INTERACTION; /* If the caller doesn't necessarily want completely new secrets, * only ask for new secrets after the first failure. */ if (new_secrets || tries) flags |= NM_SETTINGS_GET_SECRETS_FLAG_REQUEST_NEW; nm_act_request_get_secrets (req, setting_name, flags, NULL, wired_secrets_cb, self); g_object_set_data (G_OBJECT (connection), WIRED_SECRETS_TRIES, GUINT_TO_POINTER (++tries)); } else { nm_log_info (LOGD_DEVICE, "Cleared secrets, but setting didn't need any secrets."); } return NM_ACT_STAGE_RETURN_POSTPONE; } static gboolean supplicant_connection_timeout_cb (gpointer user_data) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (user_data); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMDevice *device = NM_DEVICE (self); NMActRequest *req; const char *iface; priv->supplicant.con_timeout_id = 0; iface = nm_device_get_iface (device); /* Authentication failed, encryption key is probably bad */ nm_log_warn (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): association took too long.", iface); supplicant_interface_release (self); req = nm_device_get_act_request (device); g_assert (req); if (handle_auth_or_fail (self, req, TRUE) == NM_ACT_STAGE_RETURN_POSTPONE) { nm_log_info (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): asking for new secrets", iface); } else nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_NO_SECRETS); return FALSE; } static gboolean supplicant_interface_init (NMDeviceEthernet *self) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); const char *iface; iface = nm_device_get_iface (NM_DEVICE (self)); /* Create supplicant interface */ priv->supplicant.iface = nm_supplicant_manager_iface_get (priv->supplicant.mgr, iface, FALSE); if (!priv->supplicant.iface) { nm_log_err (LOGD_DEVICE | LOGD_ETHER, "Couldn't initialize supplicant interface for %s.", iface); supplicant_interface_release (self); return FALSE; } /* Listen for it's state signals */ priv->supplicant.iface_state_id = g_signal_connect (priv->supplicant.iface, "state", G_CALLBACK (supplicant_iface_state_cb), self); /* Hook up error signal handler to capture association errors */ priv->supplicant.iface_error_id = g_signal_connect (priv->supplicant.iface, "connection-error", G_CALLBACK (supplicant_iface_connection_error_cb), self); /* Set up a timeout on the connection attempt to fail it after 25 seconds */ priv->supplicant.con_timeout_id = g_timeout_add_seconds (25, supplicant_connection_timeout_cb, self); return TRUE; } static NMActStageReturn real_act_stage1_prepare (NMDevice *dev, NMDeviceStateReason *reason) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (dev); NMActRequest *req; NMSettingWired *s_wired; const GByteArray *cloned_mac; NMActStageReturn ret = NM_ACT_STAGE_RETURN_SUCCESS; g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE); req = nm_device_get_act_request (NM_DEVICE (self)); g_return_val_if_fail (req != NULL, NM_ACT_STAGE_RETURN_FAILURE); s_wired = NM_SETTING_WIRED (device_get_setting (dev, NM_TYPE_SETTING_WIRED)); g_assert (s_wired); /* Set device MAC address if the connection wants to change it */ cloned_mac = nm_setting_wired_get_cloned_mac_address (s_wired); if (cloned_mac && (cloned_mac->len == ETH_ALEN)) _set_hw_addr (self, (const guint8 *) cloned_mac->data, "set"); return ret; } static NMActStageReturn nm_8021x_stage2_config (NMDeviceEthernet *self, NMDeviceStateReason *reason) { NMConnection *connection; NMSetting8021x *security; const char *setting_name; const char *iface; NMActStageReturn ret = NM_ACT_STAGE_RETURN_FAILURE; connection = nm_act_request_get_connection (nm_device_get_act_request (NM_DEVICE (self))); security = NM_SETTING_802_1X (nm_connection_get_setting (connection, NM_TYPE_SETTING_802_1X)); if (!security) { nm_log_err (LOGD_DEVICE, "Invalid or missing 802.1X security"); *reason = NM_DEVICE_STATE_REASON_CONFIG_FAILED; return ret; } iface = nm_device_get_iface (NM_DEVICE (self)); /* If we need secrets, get them */ setting_name = nm_connection_need_secrets (connection, NULL); if (setting_name) { NMActRequest *req = nm_device_get_act_request (NM_DEVICE (self)); nm_log_info (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): connection '%s' has security, but secrets are required.", iface, nm_connection_get_id (connection)); ret = handle_auth_or_fail (self, req, FALSE); if (ret != NM_ACT_STAGE_RETURN_POSTPONE) *reason = NM_DEVICE_STATE_REASON_NO_SECRETS; } else { nm_log_info (LOGD_DEVICE | LOGD_ETHER, "Activation (%s/wired): connection '%s' requires no security. No secrets needed.", iface, nm_connection_get_id (connection)); if (supplicant_interface_init (self)) ret = NM_ACT_STAGE_RETURN_POSTPONE; else *reason = NM_DEVICE_STATE_REASON_CONFIG_FAILED; } return ret; } /*****************************************************************************/ /* PPPoE */ static void ppp_state_changed (NMPPPManager *ppp_manager, NMPPPStatus status, gpointer user_data) { NMDevice *device = NM_DEVICE (user_data); switch (status) { case NM_PPP_STATUS_DISCONNECT: nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_PPP_DISCONNECT); break; case NM_PPP_STATUS_DEAD: nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_PPP_FAILED); break; default: break; } } static void ppp_ip4_config (NMPPPManager *ppp_manager, const char *iface, NMIP4Config *config, gpointer user_data) { NMDevice *device = NM_DEVICE (user_data); /* Ignore PPP IP4 events that come in after initial configuration */ if (nm_device_get_state (device) != NM_DEVICE_STATE_IP_CONFIG) return; nm_device_set_ip_iface (device, iface); NM_DEVICE_ETHERNET_GET_PRIVATE (device)->pending_ip4_config = g_object_ref (config); nm_device_activate_schedule_stage4_ip4_config_get (device); } static NMActStageReturn pppoe_stage3_ip4_config_start (NMDeviceEthernet *self, NMDeviceStateReason *reason) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMConnection *connection; NMSettingPPPOE *s_pppoe; NMActRequest *req; GError *err = NULL; NMActStageReturn ret = NM_ACT_STAGE_RETURN_FAILURE; req = nm_device_get_act_request (NM_DEVICE (self)); g_assert (req); connection = nm_act_request_get_connection (req); g_assert (req); s_pppoe = (NMSettingPPPOE *) nm_connection_get_setting (connection, NM_TYPE_SETTING_PPPOE); g_assert (s_pppoe); priv->ppp_manager = nm_ppp_manager_new (nm_device_get_iface (NM_DEVICE (self))); if (nm_ppp_manager_start (priv->ppp_manager, req, nm_setting_pppoe_get_username (s_pppoe), 30, &err)) { g_signal_connect (priv->ppp_manager, "state-changed", G_CALLBACK (ppp_state_changed), self); g_signal_connect (priv->ppp_manager, "ip4-config", G_CALLBACK (ppp_ip4_config), self); ret = NM_ACT_STAGE_RETURN_POSTPONE; } else { nm_log_warn (LOGD_DEVICE, "(%s): PPPoE failed to start: %s", nm_device_get_iface (NM_DEVICE (self)), err->message); g_error_free (err); g_object_unref (priv->ppp_manager); priv->ppp_manager = NULL; *reason = NM_DEVICE_STATE_REASON_PPP_START_FAILED; } return ret; } static NMActStageReturn real_act_stage2_config (NMDevice *device, NMDeviceStateReason *reason) { NMSettingConnection *s_con; const char *connection_type; NMActStageReturn ret = NM_ACT_STAGE_RETURN_SUCCESS; g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE); s_con = NM_SETTING_CONNECTION (device_get_setting (device, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); /* 802.1x has to run before any IP configuration since the 802.1x auth * process opens the port up for normal traffic. */ connection_type = nm_setting_connection_get_connection_type (s_con); if (!strcmp (connection_type, NM_SETTING_WIRED_SETTING_NAME)) { NMSetting8021x *security; security = (NMSetting8021x *) device_get_setting (device, NM_TYPE_SETTING_802_1X); if (security) ret = nm_8021x_stage2_config (NM_DEVICE_ETHERNET (device), reason); } return ret; } static NMActStageReturn real_act_stage3_ip4_config_start (NMDevice *device, NMDeviceStateReason *reason) { NMSettingConnection *s_con; const char *connection_type; g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE); s_con = NM_SETTING_CONNECTION (device_get_setting (device, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); connection_type = nm_setting_connection_get_connection_type (s_con); if (!strcmp (connection_type, NM_SETTING_PPPOE_SETTING_NAME)) return pppoe_stage3_ip4_config_start (NM_DEVICE_ETHERNET (device), reason); return NM_DEVICE_CLASS (nm_device_ethernet_parent_class)->act_stage3_ip4_config_start (device, reason); } static NMActStageReturn real_act_stage4_get_ip4_config (NMDevice *device, NMIP4Config **config, NMDeviceStateReason *reason) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (device); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMActStageReturn ret; g_return_val_if_fail (config != NULL, NM_ACT_STAGE_RETURN_FAILURE); g_return_val_if_fail (*config == NULL, NM_ACT_STAGE_RETURN_FAILURE); g_return_val_if_fail (reason != NULL, NM_ACT_STAGE_RETURN_FAILURE); if (!priv->ppp_manager) { /* Regular ethernet connection. */ /* Chain up to parent */ ret = NM_DEVICE_CLASS (nm_device_ethernet_parent_class)->act_stage4_get_ip4_config (device, config, reason); if (ret == NM_ACT_STAGE_RETURN_SUCCESS) { NMConnection *connection; NMSettingWired *s_wired; guint32 mtu; connection = nm_act_request_get_connection (nm_device_get_act_request (device)); g_assert (connection); s_wired = NM_SETTING_WIRED (nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRED)); g_assert (s_wired); /* MTU override */ mtu = nm_setting_wired_get_mtu (s_wired); if (mtu) nm_ip4_config_set_mtu (*config, mtu); } } else { NMConnection *connection; NMSettingIP4Config *s_ip4; /* PPPoE */ *config = priv->pending_ip4_config; priv->pending_ip4_config = NULL; /* Merge user-defined overrides into the IP4Config to be applied */ connection = nm_act_request_get_connection (nm_device_get_act_request (device)); g_assert (connection); s_ip4 = (NMSettingIP4Config *) nm_connection_get_setting (connection, NM_TYPE_SETTING_IP4_CONFIG); nm_utils_merge_ip4_config (*config, s_ip4); ret = NM_ACT_STAGE_RETURN_SUCCESS; } return ret; } static void real_deactivate (NMDevice *device) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (device); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); /* Clear wired secrets tries when deactivating */ clear_secrets_tries (device); if (priv->pending_ip4_config) { g_object_unref (priv->pending_ip4_config); priv->pending_ip4_config = NULL; } if (priv->ppp_manager) { g_object_unref (priv->ppp_manager); priv->ppp_manager = NULL; } supplicant_interface_release (self); /* Reset MAC address back to initial address */ _set_hw_addr (self, priv->initial_hw_addr, "reset"); } static gboolean real_check_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (device); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMSettingConnection *s_con; NMSettingWired *s_wired; const char *connection_type; gboolean is_pppoe = FALSE; const GByteArray *mac; gboolean try_mac = TRUE; const GSList *mac_blacklist, *mac_blacklist_iter; s_con = NM_SETTING_CONNECTION (nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION)); g_assert (s_con); connection_type = nm_setting_connection_get_connection_type (s_con); if ( strcmp (connection_type, NM_SETTING_WIRED_SETTING_NAME) && strcmp (connection_type, NM_SETTING_PPPOE_SETTING_NAME)) { g_set_error (error, NM_ETHERNET_ERROR, NM_ETHERNET_ERROR_CONNECTION_NOT_WIRED, "The connection was not a wired or PPPoE connection."); return FALSE; } if (!strcmp (connection_type, NM_SETTING_PPPOE_SETTING_NAME)) is_pppoe = TRUE; s_wired = (NMSettingWired *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRED); /* Wired setting is optional for PPPoE */ if (!is_pppoe && !s_wired) { g_set_error (error, NM_ETHERNET_ERROR, NM_ETHERNET_ERROR_CONNECTION_INVALID, "The connection was not a valid wired connection."); return FALSE; } if (s_wired) { if (!match_subchans (self, s_wired, &try_mac)) { g_set_error (error, NM_ETHERNET_ERROR, NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE, "The connection's s390 subchannels did not match this device."); return FALSE; } mac = nm_setting_wired_get_mac_address (s_wired); if (try_mac && mac && memcmp (mac->data, &priv->perm_hw_addr, ETH_ALEN)) { g_set_error (error, NM_ETHERNET_ERROR, NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE, "The connection's MAC address did not match this device."); return FALSE; } /* Check for MAC address blacklist */ mac_blacklist = nm_setting_wired_get_mac_address_blacklist (s_wired); for (mac_blacklist_iter = mac_blacklist; mac_blacklist_iter; mac_blacklist_iter = g_slist_next (mac_blacklist_iter)) { struct ether_addr addr; if (!ether_aton_r (mac_blacklist_iter->data, &addr)) { g_warn_if_reached (); continue; } if (memcmp (&addr, &priv->perm_hw_addr, ETH_ALEN) == 0) { g_set_error (error, NM_ETHERNET_ERROR, NM_ETHERNET_ERROR_CONNECTION_INCOMPATIBLE, "The connection's MAC address (%s) is blacklisted in %s.", (char *) mac_blacklist_iter->data, NM_SETTING_WIRED_MAC_ADDRESS_BLACKLIST); return FALSE; } } } // FIXME: check bitrate against device capabilities return TRUE; } static gboolean real_complete_connection (NMDevice *device, NMConnection *connection, const char *specific_object, const GSList *existing_connections, GError **error) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device); NMSettingWired *s_wired; NMSettingPPPOE *s_pppoe; const GByteArray *setting_mac; s_pppoe = (NMSettingPPPOE *) nm_connection_get_setting (connection, NM_TYPE_SETTING_PPPOE); /* We can't telepathically figure out the service name or username, so if * those weren't given, we can't complete the connection. */ if (s_pppoe && !nm_setting_verify (NM_SETTING (s_pppoe), NULL, error)) return FALSE; /* Default to an ethernet-only connection, but if a PPPoE setting was given * then PPPoE should be our connection type. */ nm_utils_complete_generic (connection, s_pppoe ? NM_SETTING_PPPOE_SETTING_NAME : NM_SETTING_WIRED_SETTING_NAME, existing_connections, s_pppoe ? _("PPPoE connection %d") : _("Wired connection %d"), NULL, s_pppoe ? FALSE : TRUE); /* No IPv6 by default yet for PPPoE */ s_wired = (NMSettingWired *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRED); if (!s_wired) { s_wired = (NMSettingWired *) nm_setting_wired_new (); nm_connection_add_setting (connection, NM_SETTING (s_wired)); } setting_mac = nm_setting_wired_get_mac_address (s_wired); if (setting_mac) { /* Make sure the setting MAC (if any) matches the device's permanent MAC */ if (memcmp (setting_mac->data, priv->perm_hw_addr, ETH_ALEN)) { g_set_error_literal (error, NM_SETTING_WIRED_ERROR, NM_SETTING_WIRED_ERROR_INVALID_PROPERTY, NM_SETTING_WIRED_MAC_ADDRESS); return FALSE; } } else { GByteArray *mac; const guint8 null_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 }; /* Lock the connection to this device by default */ if (memcmp (priv->perm_hw_addr, null_mac, ETH_ALEN)) { mac = g_byte_array_sized_new (ETH_ALEN); g_byte_array_append (mac, priv->perm_hw_addr, ETH_ALEN); g_object_set (G_OBJECT (s_wired), NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL); g_byte_array_free (mac, TRUE); } } return TRUE; } static gboolean spec_match_list (NMDevice *device, const GSList *specs) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device); char *hwaddr; gboolean matched; hwaddr = nm_ether_ntop ((struct ether_addr *) &priv->perm_hw_addr); matched = nm_match_spec_hwaddr (specs, hwaddr); g_free (hwaddr); if (!matched && priv->subchannels) matched = nm_match_spec_s390_subchannels (specs, priv->subchannels); return matched; } static gboolean wired_match_config (NMDevice *self, NMConnection *connection) { NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); NMSettingWired *s_wired; const GByteArray *s_ether; gboolean try_mac = TRUE; s_wired = (NMSettingWired *) nm_connection_get_setting (connection, NM_TYPE_SETTING_WIRED); if (!s_wired) return FALSE; if (!match_subchans (NM_DEVICE_ETHERNET (self), s_wired, &try_mac)) return FALSE; /* MAC address check */ s_ether = nm_setting_wired_get_mac_address (s_wired); if (try_mac && s_ether && memcmp (s_ether->data, priv->perm_hw_addr, ETH_ALEN)) return FALSE; return TRUE; } typedef struct { int ifindex; NMIP4Address *addr; gboolean found; } AddrData; static void check_one_address (struct nl_object *object, void *user_data) { AddrData *data = user_data; struct rtnl_addr *addr = (struct rtnl_addr *) object; struct nl_addr *local; struct in_addr tmp; if (rtnl_addr_get_ifindex (addr) != data->ifindex) return; if (rtnl_addr_get_family (addr) != AF_INET) return; if (nm_ip4_address_get_prefix (data->addr) != rtnl_addr_get_prefixlen (addr)) return; local = rtnl_addr_get_local (addr); if (nl_addr_get_family (local) != AF_INET) return; if (nl_addr_get_len (local) != sizeof (struct in_addr)) return; if (!nl_addr_get_binary_addr (local)) return; memcpy (&tmp, nl_addr_get_binary_addr (local), nl_addr_get_len (local)); if (tmp.s_addr != nm_ip4_address_get_address (data->addr)) return; /* Yay, found it */ data->found = TRUE; } static gboolean ip4_match_config (NMDevice *self, NMConnection *connection) { NMSettingIP4Config *s_ip4; struct nl_handle *nlh = NULL; struct nl_cache *addr_cache = NULL; int i, num; GSList *leases, *iter; NMDHCPManager *dhcp_mgr; const char *method; int ifindex; AddrData check_data; ifindex = nm_device_get_ifindex (self); s_ip4 = (NMSettingIP4Config *) nm_connection_get_setting (connection, NM_TYPE_SETTING_IP4_CONFIG); if (!s_ip4) return FALSE; /* Read all the device's IP addresses */ nlh = nm_netlink_get_default_handle (); if (!nlh) return FALSE; addr_cache = rtnl_addr_alloc_cache (nlh); if (!addr_cache) return FALSE; nl_cache_mngt_provide (addr_cache); /* Get any saved leases that apply to this connection */ dhcp_mgr = nm_dhcp_manager_get (); leases = nm_dhcp_manager_get_lease_config (dhcp_mgr, nm_device_get_iface (self), nm_connection_get_uuid (connection)); g_object_unref (dhcp_mgr); method = nm_setting_ip4_config_get_method (s_ip4); if (!strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO)) { gboolean found = FALSE; /* Find at least one lease's address on the device */ for (iter = leases; iter; iter = g_slist_next (iter)) { NMIP4Config *addr = iter->data; memset (&check_data, 0, sizeof (check_data)); check_data.ifindex = ifindex; check_data.found = FALSE; check_data.addr = nm_ip4_config_get_address (addr, 0); nl_cache_foreach (addr_cache, check_one_address, &check_data); if (check_data.found) { found = TRUE; /* Yay, device has same address as a lease */ break; } } g_slist_foreach (leases, (GFunc) g_object_unref, NULL); g_slist_free (leases); return found; } else { /* Maybe the connection used to be DHCP and there are stale leases; ignore them */ g_slist_foreach (leases, (GFunc) g_object_unref, NULL); g_slist_free (leases); } /* 'shared' and 'link-local' aren't supported methods because 'shared' * requires too much iptables and dnsmasq state to be reclaimed, and * avahi-autoipd isn't smart enough to allow the link-local address to be * determined at any point other than when it was first assigned. */ if (strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_MANUAL)) return FALSE; /* Everything below for static addressing */ /* Find all IP4 addresses of this connection in the device's address list */ num = nm_setting_ip4_config_get_num_addresses (s_ip4); for (i = 0; i < num; i++) { memset (&check_data, 0, sizeof (check_data)); check_data.ifindex = ifindex; check_data.found = FALSE; check_data.addr = nm_setting_ip4_config_get_address (s_ip4, i); nl_cache_foreach (addr_cache, check_one_address, &check_data); if (!check_data.found) return FALSE; } /* Success; all the connection's static IP addresses are assigned to the device */ return TRUE; } static NMConnection * connection_match_config (NMDevice *self, const GSList *connections) { GSList *iter; NMSettingConnection *s_con; for (iter = (GSList *) connections; iter; iter = g_slist_next (iter)) { NMConnection *candidate = NM_CONNECTION (iter->data); s_con = (NMSettingConnection *) nm_connection_get_setting (candidate, NM_TYPE_SETTING_CONNECTION); g_assert (s_con); if (strcmp (nm_setting_connection_get_connection_type (s_con), NM_SETTING_WIRED_SETTING_NAME)) continue; /* Can't assume 802.1x or PPPoE connections; they have too much state * that's impossible to get on-the-fly from PPPoE or the supplicant. */ if ( nm_connection_get_setting (candidate, NM_TYPE_SETTING_802_1X) || nm_connection_get_setting (candidate, NM_TYPE_SETTING_PPPOE)) continue; if (!wired_match_config (self, candidate)) continue; if (!ip4_match_config (self, candidate)) continue; return candidate; } return NULL; } static void dispose (GObject *object) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (object); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); if (priv->disposed) { G_OBJECT_CLASS (nm_device_ethernet_parent_class)->dispose (object); return; } priv->disposed = TRUE; if (priv->link_connected_id) { g_signal_handler_disconnect (priv->monitor, priv->link_connected_id); priv->link_connected_id = 0; } if (priv->link_disconnected_id) { g_signal_handler_disconnect (priv->monitor, priv->link_disconnected_id); priv->link_disconnected_id = 0; } carrier_action_defer_clear (self); if (priv->monitor) { g_object_unref (priv->monitor); priv->monitor = NULL; } g_free (priv->subchan1); g_free (priv->subchan2); g_free (priv->subchan3); g_free (priv->subchannels); G_OBJECT_CLASS (nm_device_ethernet_parent_class)->dispose (object); } static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMDeviceEthernet *self = NM_DEVICE_ETHERNET (object); NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (self); switch (prop_id) { case PROP_HW_ADDRESS: g_value_take_string (value, nm_ether_ntop ((struct ether_addr *) &priv->hw_addr)); break; case PROP_PERM_HW_ADDRESS: g_value_take_string (value, nm_ether_ntop ((struct ether_addr *) &priv->perm_hw_addr)); break; case PROP_SPEED: g_value_set_uint (value, nm_device_ethernet_get_speed (self)); break; case PROP_CARRIER: g_value_set_boolean (value, priv->carrier); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { switch (prop_id) { default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void nm_device_ethernet_class_init (NMDeviceEthernetClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); NMDeviceClass *parent_class = NM_DEVICE_CLASS (klass); g_type_class_add_private (object_class, sizeof (NMDeviceEthernetPrivate)); /* virtual methods */ object_class->constructor = constructor; object_class->dispose = dispose; object_class->get_property = get_property; object_class->set_property = set_property; parent_class->get_generic_capabilities = real_get_generic_capabilities; parent_class->hw_is_up = real_hw_is_up; parent_class->hw_bring_up = real_hw_bring_up; parent_class->hw_take_down = real_hw_take_down; parent_class->is_up = real_is_up; parent_class->bring_up = real_bring_up; parent_class->take_down = real_take_down; parent_class->can_interrupt_activation = real_can_interrupt_activation; parent_class->update_hw_address = real_update_hw_address; parent_class->update_permanent_hw_address = real_update_permanent_hw_address; parent_class->update_initial_hw_address = real_update_initial_hw_address; parent_class->get_best_auto_connection = real_get_best_auto_connection; parent_class->is_available = real_is_available; parent_class->check_connection_compatible = real_check_connection_compatible; parent_class->complete_connection = real_complete_connection; parent_class->act_stage1_prepare = real_act_stage1_prepare; parent_class->act_stage2_config = real_act_stage2_config; parent_class->act_stage3_ip4_config_start = real_act_stage3_ip4_config_start; parent_class->act_stage4_get_ip4_config = real_act_stage4_get_ip4_config; parent_class->deactivate = real_deactivate; parent_class->spec_match_list = spec_match_list; parent_class->connection_match_config = connection_match_config; /* properties */ g_object_class_install_property (object_class, PROP_HW_ADDRESS, g_param_spec_string (NM_DEVICE_ETHERNET_HW_ADDRESS, "Active MAC Address", "Currently set hardware MAC address", NULL, G_PARAM_READABLE)); g_object_class_install_property (object_class, PROP_PERM_HW_ADDRESS, g_param_spec_string (NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS, "Permanent MAC Address", "Permanent hardware MAC address", NULL, G_PARAM_READABLE)); g_object_class_install_property (object_class, PROP_SPEED, g_param_spec_uint (NM_DEVICE_ETHERNET_SPEED, "Speed", "Speed", 0, G_MAXUINT32, 0, G_PARAM_READABLE)); g_object_class_install_property (object_class, PROP_CARRIER, g_param_spec_boolean (NM_DEVICE_ETHERNET_CARRIER, "Carrier", "Carrier", FALSE, G_PARAM_READABLE)); /* Signals */ signals[PROPERTIES_CHANGED] = nm_properties_changed_signal_new (object_class, G_STRUCT_OFFSET (NMDeviceEthernetClass, properties_changed)); dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (klass), &dbus_glib_nm_device_ethernet_object_info); dbus_g_error_domain_register (NM_ETHERNET_ERROR, NULL, NM_TYPE_ETHERNET_ERROR); } /**************************************/ /* Ethtool capability detection */ /**************************************/ static gboolean supports_ethtool_carrier_detect (NMDeviceEthernet *self) { int fd; struct ifreq ifr; gboolean supports_ethtool = FALSE; struct ethtool_cmd edata; g_return_val_if_fail (self != NULL, FALSE); fd = socket (PF_INET, SOCK_DGRAM, 0); if (fd < 0) { nm_log_err (LOGD_HW, "couldn't open control socket."); return FALSE; } memset (&ifr, 0, sizeof (struct ifreq)); strncpy (ifr.ifr_name, nm_device_get_iface (NM_DEVICE (self)), IFNAMSIZ); edata.cmd = ETHTOOL_GLINK; ifr.ifr_data = (char *) &edata; errno = 0; if (ioctl (fd, SIOCETHTOOL, &ifr) < 0) { nm_log_dbg (LOGD_HW | LOGD_ETHER, "SIOCETHTOOL failed: %d", errno); goto out; } supports_ethtool = TRUE; out: close (fd); nm_log_dbg (LOGD_HW | LOGD_ETHER, "ethtool %s supported", supports_ethtool ? "is" : "not"); return supports_ethtool; } /**************************************/ /* MII capability detection */ /**************************************/ #define _LINUX_IF_H #include #undef _LINUX_IF_H static int mdio_read (NMDeviceEthernet *self, int fd, struct ifreq *ifr, int location) { struct mii_ioctl_data *mii; int val = -1; g_return_val_if_fail (fd >= 0, -1); g_return_val_if_fail (ifr != NULL, -1); mii = (struct mii_ioctl_data *) &ifr->ifr_ifru; mii->reg_num = location; errno = 0; if (ioctl (fd, SIOCGMIIREG, ifr) == 0) { nm_log_dbg (LOGD_HW | LOGD_ETHER, "SIOCGMIIREG result 0x%X", mii->val_out); val = mii->val_out; } else { nm_log_dbg (LOGD_HW | LOGD_ETHER, "SIOCGMIIREG failed: %d", errno); } return val; } static gboolean supports_mii_carrier_detect (NMDeviceEthernet *self) { int fd, bmsr; struct ifreq ifr; gboolean supports_mii = FALSE; g_return_val_if_fail (self != NULL, FALSE); fd = socket (PF_INET, SOCK_DGRAM, 0); if (fd < 0) { nm_log_err (LOGD_HW, "couldn't open control socket."); return FALSE; } memset (&ifr, 0, sizeof (struct ifreq)); strncpy (ifr.ifr_name, nm_device_get_iface (NM_DEVICE (self)), IFNAMSIZ); errno = 0; if (ioctl (fd, SIOCGMIIPHY, &ifr) < 0) { nm_log_dbg (LOGD_HW | LOGD_ETHER, "SIOCGMIIPHY failed: %d", errno); goto out; } /* If we can read the BMSR register, we assume that the card supports MII link detection */ bmsr = mdio_read (self, fd, &ifr, MII_BMSR); supports_mii = (bmsr != -1) ? TRUE : FALSE; nm_log_dbg (LOGD_HW | LOGD_ETHER, "MII %s supported", supports_mii ? "is" : "not"); out: close (fd); return supports_mii; }