/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Pantelis Koukousoulas <pktoss@gmail.com>
*/
#include "nm-default.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);
}