/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Pantelis Koukousoulas */ #include "src/core/nm-default-daemon.h" #include "nm-device-adsl.h" #include #include #include #include #include #include #include #include "devices/nm-device-private.h" #include "libnm-platform/nm-platform.h" #include "nm-manager.h" #include "nm-setting-adsl.h" #include "nm-utils.h" #include "ppp/nm-ppp-mgr.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; NMPppMgr *ppp_mgr; /* RFC 2684 bridging (PPPoE over ATM) */ int brfd; int nas_ifindex; char *nas_ifname; GSource *nas_update_source; 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, gboolean check_properties, GError **error) { NMSettingAdsl *s_adsl; const char *protocol; if (!NM_DEVICE_CLASS(nm_device_adsl_parent_class) ->check_connection_compatible(device, connection, check_properties, 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); 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, const 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_change_flags(nm_device_get_platform(device), priv->nas_ifindex, IFF_UP, TRUE); return TRUE; } static gboolean nas_update_timeout_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 && priv->nas_update_count <= 10) { /* Keep waiting for it to appear */ return G_SOURCE_CONTINUE; } nm_clear_g_source_inst(&priv->nas_update_source); if (priv->nas_ifindex <= 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_CONTINUE; } _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_CONTINUE; } nm_device_activate_schedule_stage2_device_config(device, TRUE); return G_SOURCE_CONTINUE; } 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; int errsv; guint num = 0; nm_assert(!priv->nas_update_source); 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_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_source = nm_g_timeout_add_source(100, nas_update_timeout_cb, self); return TRUE; } } /*****************************************************************************/ static void _ppp_mgr_cleanup(NMDeviceAdsl *self) { NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); nm_clear_pointer(&priv->ppp_mgr, nm_ppp_mgr_destroy); } static void _ppp_mgr_stage3_maybe_ready(NMDeviceAdsl *self) { NMDevice *device = NM_DEVICE(self); NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); int IS_IPv4; for (IS_IPv4 = 1; IS_IPv4 >= 0; IS_IPv4--) { const int addr_family = IS_IPv4 ? AF_INET : AF_INET6; const NMPppMgrIPData *ip_data; ip_data = nm_ppp_mgr_get_ip_data(priv->ppp_mgr, addr_family); if (ip_data->ip_received) nm_device_devip_set_state(device, addr_family, NM_DEVICE_IP_STATE_READY, ip_data->l3cd); } if (nm_ppp_mgr_get_state(priv->ppp_mgr) >= NM_PPP_MGR_STATE_HAVE_IP_CONFIG) nm_device_devip_set_state(device, AF_UNSPEC, NM_DEVICE_IP_STATE_READY, NULL); } static void _ppp_mgr_callback(NMPppMgr *ppp_mgr, const NMPppMgrCallbackData *callback_data, gpointer user_data) { NMDeviceAdsl *self = NM_DEVICE_ADSL(user_data); NMDevice *device = NM_DEVICE(self); NMDeviceState device_state; if (callback_data->callback_type != NM_PPP_MGR_CALLBACK_TYPE_STATE_CHANGED) return; device_state = nm_device_get_state(device); if (callback_data->data.state >= _NM_PPP_MGR_STATE_FAILED_START) { if (device_state <= NM_DEVICE_STATE_ACTIVATED) nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, callback_data->data.reason); return; } if (device_state < NM_DEVICE_STATE_IP_CONFIG) { if (callback_data->data.state >= NM_PPP_MGR_STATE_HAVE_IFINDEX) { gs_free char *old_name = NULL; gs_free_error GError *error = NULL; if (!nm_device_take_over_link(device, callback_data->data.ifindex, &old_name, &error)) { _LOGW(LOGD_DEVICE | LOGD_PPP, "could not take control of link %d: %s", callback_data->data.ifindex, error->message); _ppp_mgr_cleanup(self); nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, NM_DEVICE_STATE_REASON_CONFIG_FAILED); return; } if (old_name) nm_manager_remove_device(NM_MANAGER_GET, old_name, NM_DEVICE_TYPE_ADSL); nm_device_activate_schedule_stage2_device_config(device, FALSE); } return; } _ppp_mgr_stage3_maybe_ready(self); } /*****************************************************************************/ 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); if (!priv->ppp_mgr) { gs_free_error GError *error = NULL; NMSettingAdsl *s_adsl; const char *protocol; NMActRequest *req; 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); 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 */ } else 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_source) { 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; } } else nm_assert(nm_streq0(protocol, NM_SETTING_ADSL_PROTOCOL_IPOATM)); /* PPPoE uses the NAS interface, not the ATM interface */ if (nm_streq0(protocol, 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_mgr = nm_ppp_mgr_start(&((const NMPppMgrConfig) { .netns = nm_device_get_netns(device), .parent_iface = ppp_iface, .callback = _ppp_mgr_callback, .user_data = self, .act_req = req, .ppp_username = nm_setting_adsl_get_username(s_adsl), .timeout_secs = 30, .baud_override = 0, }), &error); if (!priv->ppp_mgr) { _LOGW(LOGD_DEVICE | LOGD_PPP, "PPPoE failed to start: %s", error->message); *out_failure_reason = NM_DEVICE_STATE_REASON_PPP_START_FAILED; return NM_ACT_STAGE_RETURN_FAILURE; } return NM_ACT_STAGE_RETURN_POSTPONE; } if (nm_ppp_mgr_get_state(priv->ppp_mgr) < NM_PPP_MGR_STATE_HAVE_IFINDEX) return NM_ACT_STAGE_RETURN_POSTPONE; return NM_ACT_STAGE_RETURN_SUCCESS; } static void act_stage3_ip_config(NMDevice *device, int addr_family) { NMDeviceAdsl *self = NM_DEVICE_ADSL(device); NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); NMPppMgrState ppp_state; if (!priv->ppp_mgr) { nm_assert_not_reached(); return; } ppp_state = nm_ppp_mgr_get_state(priv->ppp_mgr); nm_assert(NM_IN_SET(ppp_state, NM_PPP_MGR_STATE_HAVE_IFINDEX, NM_PPP_MGR_STATE_HAVE_IP_CONFIG)); if (ppp_state < NM_PPP_MGR_STATE_HAVE_IP_CONFIG) { nm_device_devip_set_state(device, AF_UNSPEC, NM_DEVICE_IP_STATE_PENDING, NULL); return; } _ppp_mgr_stage3_maybe_ready(self); } static void adsl_cleanup(NMDeviceAdsl *self) { NMDeviceAdslPrivate *priv = NM_DEVICE_ADSL_GET_PRIVATE(self); _ppp_mgr_cleanup(self); g_signal_handlers_disconnect_by_func(nm_device_get_platform(NM_DEVICE(self)), G_CALLBACK(link_changed_cb), self); nm_clear_fd(&priv->brfd); nm_clear_g_source_inst(&priv->nas_update_source); /* 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, .properties = NM_DEFINE_GDBUS_PROPERTY_INFOS( NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE( "Carrier", "b", NM_DEVICE_CARRIER, .annotations = NM_GDBUS_ANNOTATION_INFO_LIST_DEPRECATED(), ), ), ), }; 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 = act_stage3_ip_config; 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); }