diff options
Diffstat (limited to 'src/core/devices/adsl')
| -rw-r--r-- | src/core/devices/adsl/meson.build | 26 | ||||
| -rw-r--r-- | src/core/devices/adsl/nm-atm-manager.c | 271 | ||||
| -rw-r--r-- | src/core/devices/adsl/nm-device-adsl.c | 720 | ||||
| -rw-r--r-- | src/core/devices/adsl/nm-device-adsl.h | 30 |
4 files changed, 1047 insertions, 0 deletions
diff --git a/src/core/devices/adsl/meson.build b/src/core/devices/adsl/meson.build new file mode 100644 index 00000000..95f61d95 --- /dev/null +++ b/src/core/devices/adsl/meson.build @@ -0,0 +1,26 @@ +# SPDX-License-Identifier: LGPL-2.1-or-later + +libnm_device_plugin_adsl = shared_module( + 'nm-device-plugin-adsl', + sources: files( + 'nm-atm-manager.c', + 'nm-device-adsl.c', + ), + dependencies: core_plugin_dep, + c_args: daemon_c_flags, + link_args: ldflags_linker_script_devices, + link_depends: linker_script_devices, + install: true, + install_dir: nm_plugindir, +) + +core_plugins += libnm_device_plugin_adsl + +test( + 'check-local-devices-adsl', + check_exports, + args: [ + libnm_device_plugin_adsl.full_path(), + linker_script_devices, + ], +) diff --git a/src/core/devices/adsl/nm-atm-manager.c b/src/core/devices/adsl/nm-atm-manager.c new file mode 100644 index 00000000..9be9b5ce --- /dev/null +++ b/src/core/devices/adsl/nm-atm-manager.c @@ -0,0 +1,271 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2009 - 2013 Red Hat, Inc. + */ + +#include "src/core/nm-default-daemon.h" + +#include <gmodule.h> +#include <libudev.h> + +#include "nm-setting-adsl.h" +#include "nm-device-adsl.h" +#include "devices/nm-device-factory.h" +#include "platform/nm-platform.h" +#include "nm-udev-aux/nm-udev-utils.h" + +/*****************************************************************************/ + +#define NM_TYPE_ATM_MANAGER (nm_atm_manager_get_type()) +#define NM_ATM_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_ATM_MANAGER, NMAtmManager)) +#define NM_ATM_MANAGER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_ATM_MANAGER, NMAtmManagerClass)) +#define NM_IS_ATM_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_ATM_MANAGER)) +#define NM_IS_ATM_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_ATM_MANAGER)) +#define NM_ATM_MANAGER_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_ATM_MANAGER, NMAtmManagerClass)) + +typedef struct { + NMUdevClient *udev_client; + GSList * devices; +} NMAtmManagerPrivate; + +typedef struct { + NMDeviceFactory parent; + NMAtmManagerPrivate _priv; +} NMAtmManager; + +typedef struct { + NMDeviceFactoryClass parent; +} NMAtmManagerClass; + +static GType nm_atm_manager_get_type(void); + +G_DEFINE_TYPE(NMAtmManager, nm_atm_manager, NM_TYPE_DEVICE_FACTORY); + +#define NM_ATM_MANAGER_GET_PRIVATE(self) _NM_GET_PRIVATE(self, NMAtmManager, NM_IS_ATM_MANAGER) + +/*****************************************************************************/ + +NM_DEVICE_FACTORY_DECLARE_TYPES( + NM_DEVICE_FACTORY_DECLARE_SETTING_TYPES(NM_SETTING_ADSL_SETTING_NAME)); + +G_MODULE_EXPORT NMDeviceFactory * + nm_device_factory_create(GError **error) +{ + return g_object_new(NM_TYPE_ATM_MANAGER, NULL); +} + +/*****************************************************************************/ + +static gboolean +dev_get_attrs(struct udev_device *udev_device, const char **out_path, char **out_driver) +{ + struct udev_device *parent = NULL; + const char * driver, *path; + + g_return_val_if_fail(udev_device != NULL, FALSE); + g_return_val_if_fail(out_path != NULL, FALSE); + g_return_val_if_fail(out_driver != NULL, FALSE); + + path = udev_device_get_syspath(udev_device); + if (!path) { + nm_log_warn(LOGD_PLATFORM, "couldn't determine device path; ignoring..."); + return FALSE; + } + + driver = udev_device_get_driver(udev_device); + if (!driver) { + /* Try the parent */ + parent = udev_device_get_parent(udev_device); + if (parent) + driver = udev_device_get_driver(parent); + } + + *out_path = path; + *out_driver = g_strdup(driver); + + return TRUE; +} + +static void +device_destroyed(gpointer user_data, GObject *dead) +{ + NMAtmManager * self = NM_ATM_MANAGER(user_data); + NMAtmManagerPrivate *priv = NM_ATM_MANAGER_GET_PRIVATE(self); + + priv->devices = g_slist_remove(priv->devices, dead); +} + +static void +adsl_add(NMAtmManager *self, struct udev_device *udev_device) +{ + NMAtmManagerPrivate *priv = NM_ATM_MANAGER_GET_PRIVATE(self); + const char * ifname, *sysfs_path = NULL; + char * driver = NULL; + gs_free char * atm_index_path = NULL; + int atm_index; + NMDevice * device; + + g_return_if_fail(udev_device != NULL); + + ifname = udev_device_get_sysname(udev_device); + if (!ifname) { + nm_log_warn(LOGD_PLATFORM, "failed to get device's interface name"); + return; + } + + nm_log_dbg(LOGD_PLATFORM, "(%s): found ATM device", ifname); + + atm_index_path = + g_strdup_printf("/sys/class/atm/%s/atmindex", NM_ASSERT_VALID_PATH_COMPONENT(ifname)); + atm_index = (int) nm_platform_sysctl_get_int_checked(NM_PLATFORM_GET, + NMP_SYSCTL_PATHID_ABSOLUTE(atm_index_path), + 10, + 0, + G_MAXINT, + -1); + if (atm_index < 0) { + nm_log_warn(LOGD_PLATFORM, "(%s): failed to get ATM index", ifname); + return; + } + + if (!dev_get_attrs(udev_device, &sysfs_path, &driver)) { + nm_log_warn(LOGD_PLATFORM, "(%s): failed to get ATM attributes", ifname); + return; + } + + g_assert(sysfs_path); + + device = nm_device_adsl_new(sysfs_path, ifname, driver, atm_index); + g_assert(device); + + priv->devices = g_slist_prepend(priv->devices, device); + g_object_weak_ref(G_OBJECT(device), device_destroyed, self); + + g_signal_emit_by_name(self, NM_DEVICE_FACTORY_DEVICE_ADDED, device); + g_object_unref(device); + + g_free(driver); +} + +static void +adsl_remove(NMAtmManager *self, struct udev_device *udev_device) +{ + NMAtmManagerPrivate *priv = NM_ATM_MANAGER_GET_PRIVATE(self); + const char * iface = udev_device_get_sysname(udev_device); + GSList * iter; + + nm_log_dbg(LOGD_PLATFORM, "(%s): removing ATM device", iface); + + for (iter = priv->devices; iter; iter = iter->next) { + NMDevice *device = iter->data; + + /* Match 'iface' not 'ip_iface' to the ATM device instead of the + * NAS bridge interface or PPPoE interface. + */ + if (g_strcmp0(nm_device_get_iface(device), iface) != 0) + continue; + + g_object_weak_unref(G_OBJECT(iter->data), device_destroyed, self); + priv->devices = g_slist_remove(priv->devices, device); + g_signal_emit_by_name(device, NM_DEVICE_REMOVED); + break; + } +} + +static void +start(NMDeviceFactory *factory) +{ + NMAtmManager * self = NM_ATM_MANAGER(factory); + NMAtmManagerPrivate * priv = NM_ATM_MANAGER_GET_PRIVATE(self); + struct udev_enumerate * enumerate; + struct udev_list_entry *devices; + + enumerate = nm_udev_client_enumerate_new(priv->udev_client); + udev_enumerate_add_match_is_initialized(enumerate); + udev_enumerate_scan_devices(enumerate); + devices = udev_enumerate_get_list_entry(enumerate); + for (; devices; devices = udev_list_entry_get_next(devices)) { + struct udev_device *udevice; + + udevice = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate), + udev_list_entry_get_name(devices)); + if (udevice) { + adsl_add(self, udevice); + udev_device_unref(udevice); + } + } + udev_enumerate_unref(enumerate); +} + +static void +handle_uevent(NMUdevClient *client, struct udev_device *device, gpointer user_data) +{ + NMAtmManager *self = NM_ATM_MANAGER(user_data); + const char * subsys; + const char * ifindex; + guint64 seqnum; + const char * action; + + action = udev_device_get_action(device); + + g_return_if_fail(action != NULL); + + /* A bit paranoid */ + subsys = udev_device_get_subsystem(device); + g_return_if_fail(!g_strcmp0(subsys, "atm")); + + ifindex = udev_device_get_property_value(device, "IFINDEX"); + seqnum = udev_device_get_seqnum(device); + nm_log_dbg(LOGD_PLATFORM, + "UDEV event: action '%s' subsys '%s' device '%s' (%s); seqnum=%" G_GUINT64_FORMAT, + action, + subsys, + udev_device_get_sysname(device), + ifindex ?: "unknown", + seqnum); + + if (!strcmp(action, "add")) + adsl_add(self, device); + else if (!strcmp(action, "remove")) + adsl_remove(self, device); +} + +/*****************************************************************************/ + +static void +nm_atm_manager_init(NMAtmManager *self) +{ + NMAtmManagerPrivate *priv = NM_ATM_MANAGER_GET_PRIVATE(self); + + priv->udev_client = nm_udev_client_new(NM_MAKE_STRV("atm"), handle_uevent, self); +} + +static void +dispose(GObject *object) +{ + NMAtmManager * self = NM_ATM_MANAGER(object); + NMAtmManagerPrivate *priv = NM_ATM_MANAGER_GET_PRIVATE(self); + GSList * iter; + + for (iter = priv->devices; iter; iter = iter->next) + g_object_weak_unref(G_OBJECT(iter->data), device_destroyed, self); + nm_clear_pointer(&priv->devices, g_slist_free); + + priv->udev_client = nm_udev_client_destroy(priv->udev_client); + + G_OBJECT_CLASS(nm_atm_manager_parent_class)->dispose(object); +} + +static void +nm_atm_manager_class_init(NMAtmManagerClass *klass) +{ + GObjectClass * object_class = G_OBJECT_CLASS(klass); + NMDeviceFactoryClass *factory_class = NM_DEVICE_FACTORY_CLASS(klass); + + object_class->dispose = dispose; + + factory_class->get_supported_types = get_supported_types; + factory_class->start = start; +} diff --git a/src/core/devices/adsl/nm-device-adsl.c b/src/core/devices/adsl/nm-device-adsl.c new file mode 100644 index 00000000..34c062a8 --- /dev/null +++ b/src/core/devices/adsl/nm-device-adsl.c @@ -0,0 +1,720 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Pantelis Koukousoulas <pktoss@gmail.com> + */ + +#include "src/core/nm-default-daemon.h" + +#include "nm-device-adsl.h" + +#include <sys/socket.h> +#include <linux/atmdev.h> +#include <linux/atmbr2684.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <unistd.h> +#include <stdlib.h> + +#include "nm-ip4-config.h" +#include "devices/nm-device-private.h" +#include "platform/nm-platform.h" +#include "ppp/nm-ppp-manager-call.h" +#include "ppp/nm-ppp-status.h" +#include "nm-setting-adsl.h" +#include "nm-utils.h" + +#define _NMLOG_DEVICE_TYPE NMDeviceAdsl +#include "devices/nm-device-logging.h" + +/*****************************************************************************/ + +NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_ATM_INDEX, ); + +typedef struct { + guint carrier_poll_id; + int atm_index; + + /* PPP */ + NMPPPManager *ppp_manager; + + /* RFC 2684 bridging (PPPoE over ATM) */ + int brfd; + int nas_ifindex; + char *nas_ifname; + guint nas_update_id; + guint nas_update_count; +} NMDeviceAdslPrivate; + +struct _NMDeviceAdsl { + NMDevice parent; + NMDeviceAdslPrivate _priv; +}; + +struct _NMDeviceAdslClass { + NMDeviceClass parent; +}; + +G_DEFINE_TYPE(NMDeviceAdsl, nm_device_adsl, NM_TYPE_DEVICE) + +#define NM_DEVICE_ADSL_GET_PRIVATE(self) \ + _NM_GET_PRIVATE(self, NMDeviceAdsl, NM_IS_DEVICE_ADSL, NMDevice) + +/*****************************************************************************/ + +static NMDeviceCapabilities +get_generic_capabilities(NMDevice *dev) +{ + return (NM_DEVICE_CAP_CARRIER_DETECT | NM_DEVICE_CAP_NONSTANDARD_CARRIER + | NM_DEVICE_CAP_IS_NON_KERNEL); +} + +static gboolean +check_connection_compatible(NMDevice *device, NMConnection *connection, GError **error) +{ + NMSettingAdsl *s_adsl; + const char * protocol; + + if (!NM_DEVICE_CLASS(nm_device_adsl_parent_class) + ->check_connection_compatible(device, connection, error)) + return FALSE; + + s_adsl = nm_connection_get_setting_adsl(connection); + + protocol = nm_setting_adsl_get_protocol(s_adsl); + if (nm_streq0(protocol, NM_SETTING_ADSL_PROTOCOL_IPOATM)) { + /* FIXME: we don't yet support IPoATM */ + nm_utils_error_set_literal(error, + NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY, + "IPoATM protocol is not yet supported"); + return FALSE; + } + + return TRUE; +} + +static gboolean +complete_connection(NMDevice * device, + NMConnection * connection, + const char * specific_object, + NMConnection *const *existing_connections, + GError ** error) +{ + NMSettingAdsl *s_adsl; + + /* + * We can't telepathically figure out the username, so if + * it wasn't given, we can't complete the connection. + */ + s_adsl = nm_connection_get_setting_adsl(connection); + if (s_adsl && !nm_setting_verify(NM_SETTING(s_adsl), NULL, error)) + return FALSE; + + nm_utils_complete_generic(nm_device_get_platform(device), + connection, + NM_SETTING_ADSL_SETTING_NAME, + existing_connections, + NULL, + _("ADSL connection"), + NULL, + NULL, + FALSE); /* No IPv6 yet by default */ + return TRUE; +} + +/*****************************************************************************/ + +static gboolean +br2684_assign_vcc(NMDeviceAdsl *self, NMSettingAdsl *s_adsl) +{ + NMDeviceAdslPrivate * priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + struct sockaddr_atmpvc addr; + struct atm_backend_br2684 be; + struct atm_qos qos; + int errsv, err, bufsize = 8192; + const char * encapsulation; + gboolean is_llc; + + g_return_val_if_fail(priv->brfd == -1, FALSE); + g_return_val_if_fail(priv->nas_ifname != NULL, FALSE); + + priv->brfd = socket(PF_ATMPVC, SOCK_DGRAM | SOCK_CLOEXEC, ATM_AAL5); + if (priv->brfd < 0) { + errsv = errno; + _LOGE(LOGD_ADSL, "failed to open ATM control socket (%d)", errsv); + priv->brfd = -1; + return FALSE; + } + + err = setsockopt(priv->brfd, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize)); + if (err != 0) { + errsv = errno; + _LOGE(LOGD_ADSL, "failed to set SNDBUF option (%d)", errsv); + goto error; + } + + /* QoS */ + memset(&qos, 0, sizeof(qos)); + qos.aal = ATM_AAL5; + qos.txtp.traffic_class = ATM_UBR; + qos.txtp.max_sdu = 1524; + qos.txtp.pcr = ATM_MAX_PCR; + qos.rxtp = qos.txtp; + + err = setsockopt(priv->brfd, SOL_ATM, SO_ATMQOS, &qos, sizeof(qos)); + if (err != 0) { + errsv = errno; + _LOGE(LOGD_ADSL, "failed to set QoS (%d)", errsv); + goto error; + } + + encapsulation = nm_setting_adsl_get_encapsulation(s_adsl); + + /* VPI/VCI */ + memset(&addr, 0, sizeof(addr)); + addr.sap_family = AF_ATMPVC; + addr.sap_addr.itf = priv->atm_index; + addr.sap_addr.vpi = (guint16) nm_setting_adsl_get_vpi(s_adsl); + addr.sap_addr.vci = (int) nm_setting_adsl_get_vci(s_adsl); + + _LOGD(LOGD_ADSL, + "assigning address %d.%d.%d encapsulation %s", + priv->atm_index, + addr.sap_addr.vpi, + addr.sap_addr.vci, + encapsulation ?: "(none)"); + + err = connect(priv->brfd, (struct sockaddr *) &addr, sizeof(addr)); + if (err != 0) { + errsv = errno; + _LOGE(LOGD_ADSL, "failed to set VPI/VCI (%d)", errsv); + goto error; + } + + /* And last attach the VCC to the interface */ + is_llc = (g_strcmp0(encapsulation, "llc") == 0); + + memset(&be, 0, sizeof(be)); + be.backend_num = ATM_BACKEND_BR2684; + be.ifspec.method = BR2684_FIND_BYIFNAME; + nm_utils_ifname_cpy(be.ifspec.spec.ifname, priv->nas_ifname); + be.fcs_in = BR2684_FCSIN_NO; + be.fcs_out = BR2684_FCSOUT_NO; + be.encaps = is_llc ? BR2684_ENCAPS_LLC : BR2684_ENCAPS_VC; + err = ioctl(priv->brfd, ATM_SETBACKEND, &be); + if (err != 0) { + errsv = errno; + _LOGE(LOGD_ADSL, "failed to attach VCC (%d)", errsv); + goto error; + } + + return TRUE; + +error: + nm_close(priv->brfd); + priv->brfd = -1; + return FALSE; +} + +static void +link_changed_cb(NMPlatform * platform, + int obj_type_i, + int ifindex, + NMPlatformLink *info, + int change_type_i, + NMDeviceAdsl * self) +{ + const NMPlatformSignalChangeType change_type = change_type_i; + + if (change_type == NM_PLATFORM_SIGNAL_REMOVED) { + NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + NMDevice * device = NM_DEVICE(self); + + /* This only gets called for PPPoE connections and "nas" interfaces */ + + if (priv->nas_ifindex > 0 && ifindex == priv->nas_ifindex) { + /* NAS device went away for some reason; kill the connection */ + _LOGD(LOGD_ADSL, "br2684 interface disappeared"); + nm_device_state_changed(device, + NM_DEVICE_STATE_FAILED, + NM_DEVICE_STATE_REASON_BR2684_FAILED); + } + } +} + +static gboolean +pppoe_vcc_config(NMDeviceAdsl *self) +{ + NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + NMDevice * device = NM_DEVICE(self); + NMSettingAdsl * s_adsl; + + s_adsl = nm_device_get_applied_setting(device, NM_TYPE_SETTING_ADSL); + + g_return_val_if_fail(s_adsl, FALSE); + + /* Set up the VCC */ + if (!br2684_assign_vcc(self, s_adsl)) + return FALSE; + + /* Watch for the 'nas' interface going away */ + g_signal_connect(nm_device_get_platform(device), + NM_PLATFORM_SIGNAL_LINK_CHANGED, + G_CALLBACK(link_changed_cb), + self); + + _LOGD(LOGD_ADSL, "ATM setup successful"); + + /* otherwise we're good for stage3 */ + nm_platform_link_set_up(nm_device_get_platform(device), priv->nas_ifindex, NULL); + + return TRUE; +} + +static gboolean +nas_update_cb(gpointer user_data) +{ + NMDeviceAdsl * self = NM_DEVICE_ADSL(user_data); + NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + NMDevice * device = NM_DEVICE(self); + + nm_assert(priv->nas_ifname); + + priv->nas_update_count++; + + nm_assert(priv->nas_ifindex <= 0); + priv->nas_ifindex = + nm_platform_link_get_ifindex(nm_device_get_platform(device), priv->nas_ifname); + if (priv->nas_ifindex <= 0) { + if (priv->nas_update_count <= 10) { + /* Keep waiting for it to appear */ + return G_SOURCE_CONTINUE; + } + priv->nas_update_id = 0; + _LOGW(LOGD_ADSL, + "failed to find br2684 interface %s ifindex after timeout", + priv->nas_ifname); + nm_device_state_changed(device, + NM_DEVICE_STATE_FAILED, + NM_DEVICE_STATE_REASON_BR2684_FAILED); + return G_SOURCE_REMOVE; + } + + priv->nas_update_id = 0; + _LOGD(LOGD_ADSL, "using br2684 iface '%s' index %d", priv->nas_ifname, priv->nas_ifindex); + + if (!pppoe_vcc_config(self)) { + nm_device_state_changed(device, + NM_DEVICE_STATE_FAILED, + NM_DEVICE_STATE_REASON_BR2684_FAILED); + return G_SOURCE_REMOVE; + } + + nm_device_activate_schedule_stage2_device_config(device, TRUE); + return G_SOURCE_REMOVE; +} + +static gboolean +br2684_create_iface(NMDeviceAdsl *self) +{ + NMDeviceAdslPrivate * priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + struct atm_newif_br2684 ni; + nm_auto_close int fd = -1; + int err, errsv; + guint num = 0; + + if (nm_clear_g_source(&priv->nas_update_id)) + nm_assert_not_reached(); + + fd = socket(PF_ATMPVC, SOCK_DGRAM | SOCK_CLOEXEC, ATM_AAL5); + if (fd < 0) { + errsv = errno; + _LOGE(LOGD_ADSL, "failed to open ATM control socket (%d)", errsv); + return FALSE; + } + + memset(&ni, 0, sizeof(ni)); + ni.backend_num = ATM_BACKEND_BR2684; + ni.media = BR2684_MEDIA_ETHERNET; + ni.mtu = 1500; + + /* Loop attempting to create an interface that doesn't exist yet. The + * kernel can create one for us automatically, but due to API issues it + * cannot return that name to us. Since we want to know the name right + * away, just brute-force it. + */ + while (TRUE) { + memset(&ni.ifname, 0, sizeof(ni.ifname)); + g_snprintf(ni.ifname, sizeof(ni.ifname), "nas%u", num++); + + err = ioctl(fd, ATM_NEWBACKENDIF, &ni); + if (err != 0) { + errsv = errno; + if (errsv == EEXIST) + continue; + + _LOGW(LOGD_ADSL, "failed to create br2684 interface (%d)", errsv); + return FALSE; + } + + nm_utils_strdup_reset(&priv->nas_ifname, ni.ifname); + _LOGD(LOGD_ADSL, "waiting for br2684 iface '%s' to appear", priv->nas_ifname); + priv->nas_update_count = 0; + priv->nas_update_id = g_timeout_add(100, nas_update_cb, self); + return TRUE; + } +} + +static NMActStageReturn +act_stage2_config(NMDevice *device, NMDeviceStateReason *out_failure_reason) +{ + NMDeviceAdsl * self = NM_DEVICE_ADSL(device); + NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + NMSettingAdsl * s_adsl; + const char * protocol; + + s_adsl = nm_device_get_applied_setting(device, NM_TYPE_SETTING_ADSL); + + g_return_val_if_fail(s_adsl, NM_ACT_STAGE_RETURN_FAILURE); + + protocol = nm_setting_adsl_get_protocol(s_adsl); + _LOGD(LOGD_ADSL, "using ADSL protocol '%s'", protocol); + + if (nm_streq0(protocol, NM_SETTING_ADSL_PROTOCOL_PPPOA)) { + /* PPPoA doesn't need anything special */ + return NM_ACT_STAGE_RETURN_SUCCESS; + } + + if (nm_streq0(protocol, NM_SETTING_ADSL_PROTOCOL_PPPOE)) { + /* PPPoE needs RFC2684 bridging before we can do PPP over it */ + if (priv->nas_ifindex <= 0) { + if (priv->nas_update_id == 0) { + if (!br2684_create_iface(self)) { + NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_BR2684_FAILED); + return NM_ACT_STAGE_RETURN_FAILURE; + } + } + return NM_ACT_STAGE_RETURN_POSTPONE; + } + return NM_ACT_STAGE_RETURN_SUCCESS; + } + + _LOGW(LOGD_ADSL, "unhandled ADSL protocol '%s'", protocol); + return NM_ACT_STAGE_RETURN_SUCCESS; +} + +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_ifindex_set(NMPPPManager *ppp_manager, int ifindex, const char *iface, gpointer user_data) +{ + NMDevice *device = NM_DEVICE(user_data); + + if (!nm_device_set_ip_ifindex(device, ifindex)) { + nm_device_state_changed(device, + NM_DEVICE_STATE_FAILED, + NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE); + } +} + +static void +ppp_ip4_config(NMPPPManager *ppp_manager, NMIP4Config *config, gpointer user_data) +{ + NMDevice *device = NM_DEVICE(user_data); + + /* Ignore PPP IP4 events that come in after initial configuration */ + if (nm_device_activate_ip4_state_in_conf(device)) + nm_device_activate_schedule_ip_config_result(device, AF_INET, NM_IP_CONFIG_CAST(config)); +} + +static NMActStageReturn +act_stage3_ip4_config_start(NMDevice * device, + NMIP4Config ** out_config, + NMDeviceStateReason *out_failure_reason) +{ + NMDeviceAdsl * self = NM_DEVICE_ADSL(device); + NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + NMSettingAdsl * s_adsl; + NMActRequest * req; + GError * err = NULL; + const char * ppp_iface; + + req = nm_device_get_act_request(device); + + g_return_val_if_fail(req, NM_ACT_STAGE_RETURN_FAILURE); + + s_adsl = nm_device_get_applied_setting(device, NM_TYPE_SETTING_ADSL); + + g_return_val_if_fail(s_adsl, NM_ACT_STAGE_RETURN_FAILURE); + + /* PPPoE uses the NAS interface, not the ATM interface */ + if (nm_streq0(nm_setting_adsl_get_protocol(s_adsl), NM_SETTING_ADSL_PROTOCOL_PPPOE)) { + nm_assert(priv->nas_ifname); + ppp_iface = priv->nas_ifname; + + _LOGD(LOGD_ADSL, "starting PPPoE on br2684 interface %s", priv->nas_ifname); + } else { + ppp_iface = nm_device_get_iface(device); + _LOGD(LOGD_ADSL, "starting PPPoA"); + } + + priv->ppp_manager = nm_ppp_manager_create(ppp_iface, &err); + + if (priv->ppp_manager) { + nm_ppp_manager_set_route_parameters(priv->ppp_manager, + nm_device_get_route_table(device, AF_INET), + nm_device_get_route_metric(device, AF_INET), + nm_device_get_route_table(device, AF_INET6), + nm_device_get_route_metric(device, AF_INET6)); + } + + if (!priv->ppp_manager + || !nm_ppp_manager_start(priv->ppp_manager, + req, + nm_setting_adsl_get_username(s_adsl), + 30, + 0, + &err)) { + _LOGW(LOGD_ADSL, "PPP failed to start: %s", err->message); + g_error_free(err); + + g_clear_object(&priv->ppp_manager); + + NM_SET_OUT(out_failure_reason, NM_DEVICE_STATE_REASON_PPP_START_FAILED); + return NM_ACT_STAGE_RETURN_FAILURE; + } + + g_signal_connect(priv->ppp_manager, + NM_PPP_MANAGER_SIGNAL_STATE_CHANGED, + G_CALLBACK(ppp_state_changed), + self); + g_signal_connect(priv->ppp_manager, + NM_PPP_MANAGER_SIGNAL_IFINDEX_SET, + G_CALLBACK(ppp_ifindex_set), + self); + g_signal_connect(priv->ppp_manager, + NM_PPP_MANAGER_SIGNAL_IP4_CONFIG, + G_CALLBACK(ppp_ip4_config), + self); + return NM_ACT_STAGE_RETURN_POSTPONE; +} + +static NMActStageReturn +act_stage3_ip_config_start(NMDevice * device, + int addr_family, + gpointer * out_config, + NMDeviceStateReason *out_failure_reason) +{ + if (addr_family == AF_INET) + return act_stage3_ip4_config_start(device, (NMIP4Config **) out_config, out_failure_reason); + + return NM_DEVICE_CLASS(nm_device_adsl_parent_class) + ->act_stage3_ip_config_start(device, addr_family, out_config, out_failure_reason); +} + +static void +adsl_cleanup(NMDeviceAdsl *self) +{ + NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + + if (priv->ppp_manager) { + g_signal_handlers_disconnect_by_func(priv->ppp_manager, + G_CALLBACK(ppp_state_changed), + self); + g_signal_handlers_disconnect_by_func(priv->ppp_manager, G_CALLBACK(ppp_ip4_config), self); + nm_ppp_manager_stop(priv->ppp_manager, NULL, NULL, NULL); + g_clear_object(&priv->ppp_manager); + } + + g_signal_handlers_disconnect_by_func(nm_device_get_platform(NM_DEVICE(self)), + G_CALLBACK(link_changed_cb), + self); + + nm_close(priv->brfd); + priv->brfd = -1; + + nm_clear_g_source(&priv->nas_update_id); + + /* FIXME: kernel has no way of explicitly deleting the 'nasX' interface yet, + * so it gets leaked. It does get destroyed when it's no longer in use, + * but we have no control over that. + */ + priv->nas_ifindex = 0; + nm_clear_g_free(&priv->nas_ifname); +} + +static void +deactivate(NMDevice *device) +{ + adsl_cleanup(NM_DEVICE_ADSL(device)); +} + +/*****************************************************************************/ + +static gboolean +carrier_update_cb(gpointer user_data) +{ + NMDeviceAdsl *self = NM_DEVICE_ADSL(user_data); + int carrier; + char * path; + + path = g_strdup_printf("/sys/class/atm/%s/carrier", + NM_ASSERT_VALID_PATH_COMPONENT(nm_device_get_iface(NM_DEVICE(self)))); + carrier = (int) nm_platform_sysctl_get_int_checked(nm_device_get_platform(NM_DEVICE(self)), + NMP_SYSCTL_PATHID_ABSOLUTE(path), + 10, + 0, + 1, + -1); + g_free(path); + + if (carrier != -1) + nm_device_set_carrier(NM_DEVICE(self), carrier); + return TRUE; +} + +/*****************************************************************************/ + +static void +get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) +{ + switch (prop_id) { + case PROP_ATM_INDEX: + g_value_set_int(value, NM_DEVICE_ADSL_GET_PRIVATE(object)->atm_index); + 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) { + case PROP_ATM_INDEX: + /* construct-only */ + NM_DEVICE_ADSL_GET_PRIVATE(object)->atm_index = g_value_get_int(value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + break; + } +} + +/*****************************************************************************/ + +static void +nm_device_adsl_init(NMDeviceAdsl *self) +{} + +static void +constructed(GObject *object) +{ + NMDeviceAdsl * self = NM_DEVICE_ADSL(object); + NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); + + G_OBJECT_CLASS(nm_device_adsl_parent_class)->constructed(object); + + priv->carrier_poll_id = g_timeout_add_seconds(5, carrier_update_cb, self); + + _LOGD(LOGD_ADSL, "ATM device index %d", priv->atm_index); + + g_return_if_fail(priv->atm_index >= 0); +} + +NMDevice * +nm_device_adsl_new(const char *udi, const char *iface, const char *driver, int atm_index) +{ + g_return_val_if_fail(udi != NULL, NULL); + g_return_val_if_fail(atm_index >= 0, NULL); + + return g_object_new(NM_TYPE_DEVICE_ADSL, + NM_DEVICE_UDI, + udi, + NM_DEVICE_IFACE, + iface, + NM_DEVICE_DRIVER, + driver, + NM_DEVICE_ADSL_ATM_INDEX, + atm_index, + NM_DEVICE_TYPE_DESC, + "ADSL", + NM_DEVICE_DEVICE_TYPE, + NM_DEVICE_TYPE_ADSL, + NULL); +} + +static void +dispose(GObject *object) +{ + adsl_cleanup(NM_DEVICE_ADSL(object)); + + nm_clear_g_source(&NM_DEVICE_ADSL_GET_PRIVATE(object)->carrier_poll_id); + + G_OBJECT_CLASS(nm_device_adsl_parent_class)->dispose(object); +} + +static const NMDBusInterfaceInfoExtended interface_info_device_adsl = { + .parent = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT( + NM_DBUS_INTERFACE_DEVICE_ADSL, + .signals = NM_DEFINE_GDBUS_SIGNAL_INFOS(&nm_signal_info_property_changed_legacy, ), + .properties = NM_DEFINE_GDBUS_PROPERTY_INFOS( + NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE_L("Carrier", + "b", + NM_DEVICE_CARRIER), ), ), + .legacy_property_changed = TRUE, +}; + +static void +nm_device_adsl_class_init(NMDeviceAdslClass *klass) +{ + GObjectClass * object_class = G_OBJECT_CLASS(klass); + NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS(klass); + NMDeviceClass * device_class = NM_DEVICE_CLASS(klass); + + object_class->constructed = constructed; + object_class->dispose = dispose; + object_class->get_property = get_property; + object_class->set_property = set_property; + + dbus_object_class->interface_infos = NM_DBUS_INTERFACE_INFOS(&interface_info_device_adsl); + + device_class->connection_type_check_compatible = NM_SETTING_ADSL_SETTING_NAME; + + device_class->get_generic_capabilities = get_generic_capabilities; + + device_class->check_connection_compatible = check_connection_compatible; + device_class->complete_connection = complete_connection; + + device_class->act_stage2_config = act_stage2_config; + device_class->act_stage3_ip_config_start = act_stage3_ip_config_start; + device_class->deactivate = deactivate; + + obj_properties[PROP_ATM_INDEX] = + g_param_spec_int(NM_DEVICE_ADSL_ATM_INDEX, + "", + "", + -1, + G_MAXINT, + -1, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties); +} diff --git a/src/core/devices/adsl/nm-device-adsl.h b/src/core/devices/adsl/nm-device-adsl.h new file mode 100644 index 00000000..c5c18901 --- /dev/null +++ b/src/core/devices/adsl/nm-device-adsl.h @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Author: Pantelis Koukousoulas <pktoss@gmail.com> + * Copyright (C) 2009 - 2011 Red Hat Inc. + */ + +#ifndef __NETWORKMANAGER_DEVICE_ADSL_H__ +#define __NETWORKMANAGER_DEVICE_ADSL_H__ + +#include "devices/nm-device.h" + +#define NM_TYPE_DEVICE_ADSL (nm_device_adsl_get_type()) +#define NM_DEVICE_ADSL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), NM_TYPE_DEVICE_ADSL, NMDeviceAdsl)) +#define NM_DEVICE_ADSL_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass), NM_TYPE_DEVICE_ADSL, NMDeviceAdslClass)) +#define NM_IS_DEVICE_ADSL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), NM_TYPE_DEVICE_ADSL)) +#define NM_IS_DEVICE_ADSL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), NM_TYPE_DEVICE_ADSL)) +#define NM_DEVICE_ADSL_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS((obj), NM_TYPE_DEVICE_ADSL, NMDeviceAdslClass)) + +#define NM_DEVICE_ADSL_ATM_INDEX "atm-index" + +typedef struct _NMDeviceAdsl NMDeviceAdsl; +typedef struct _NMDeviceAdslClass NMDeviceAdslClass; + +GType nm_device_adsl_get_type(void); + +NMDevice *nm_device_adsl_new(const char *udi, const char *iface, const char *driver, int atm_index); + +#endif /* NM_DEVICE_ADSL_H */ |