NMDevice

NMDevice

Synopsis

#define             NM_DEVICE_DEVICE_TYPE
#define             NM_DEVICE_UDI
#define             NM_DEVICE_INTERFACE
#define             NM_DEVICE_IP_INTERFACE
#define             NM_DEVICE_DRIVER
#define             NM_DEVICE_DRIVER_VERSION
#define             NM_DEVICE_FIRMWARE_VERSION
#define             NM_DEVICE_CAPABILITIES
#define             NM_DEVICE_REAL
#define             NM_DEVICE_MANAGED
#define             NM_DEVICE_AUTOCONNECT
#define             NM_DEVICE_FIRMWARE_MISSING
#define             NM_DEVICE_NM_PLUGIN_MISSING
#define             NM_DEVICE_IP4_CONFIG
#define             NM_DEVICE_DHCP4_CONFIG
#define             NM_DEVICE_IP6_CONFIG
#define             NM_DEVICE_DHCP6_CONFIG
#define             NM_DEVICE_STATE
#define             NM_DEVICE_STATE_REASON
#define             NM_DEVICE_ACTIVE_CONNECTION
#define             NM_DEVICE_AVAILABLE_CONNECTIONS
#define             NM_DEVICE_VENDOR
#define             NM_DEVICE_PRODUCT
#define             NM_DEVICE_PHYSICAL_PORT_ID
#define             NM_DEVICE_MTU
#define             NM_DEVICE_METERED
#define             NM_DEVICE_LLDP_NEIGHBORS
                    NMDevice;
                    NMDeviceClass;
const char *        nm_device_get_iface                 (NMDevice *device);
const char *        nm_device_get_ip_iface              (NMDevice *device);
NMDeviceType        nm_device_get_device_type           (NMDevice *device);
const char *        nm_device_get_udi                   (NMDevice *device);
const char *        nm_device_get_driver                (NMDevice *device);
const char *        nm_device_get_driver_version        (NMDevice *device);
const char *        nm_device_get_firmware_version      (NMDevice *device);
const char *        nm_device_get_type_description      (NMDevice *device);
const char *        nm_device_get_hw_address            (NMDevice *device);
NMDeviceCapabilities nm_device_get_capabilities         (NMDevice *device);
gboolean            nm_device_get_managed               (NMDevice *device);
void                nm_device_set_managed               (NMDevice *device,
                                                         gboolean managed);
gboolean            nm_device_get_autoconnect           (NMDevice *device);
void                nm_device_set_autoconnect           (NMDevice *device,
                                                         gboolean autoconnect);
gboolean            nm_device_get_firmware_missing      (NMDevice *device);
gboolean            nm_device_get_nm_plugin_missing     (NMDevice *device);
NMIPConfig *        nm_device_get_ip4_config            (NMDevice *device);
NMDhcpConfig *      nm_device_get_dhcp4_config          (NMDevice *device);
NMIPConfig *        nm_device_get_ip6_config            (NMDevice *device);
NMDhcpConfig *      nm_device_get_dhcp6_config          (NMDevice *device);
NMDeviceState       nm_device_get_state                 (NMDevice *device);
NMDeviceStateReason nm_device_get_state_reason          (NMDevice *device);
NMActiveConnection * nm_device_get_active_connection    (NMDevice *device);
const GPtrArray *   nm_device_get_available_connections (NMDevice *device);
const char *        nm_device_get_physical_port_id      (NMDevice *device);
guint32             nm_device_get_mtu                   (NMDevice *device);
gboolean            nm_device_is_real                   (NMDevice *device);
gboolean            nm_device_is_software               (NMDevice *device);
const char *        nm_device_get_product               (NMDevice *device);
const char *        nm_device_get_vendor                (NMDevice *device);
const char *        nm_device_get_description           (NMDevice *device);
NMMetered           nm_device_get_metered               (NMDevice *device);
GPtrArray *         nm_device_get_lldp_neighbors        (NMDevice *device);
char **             nm_device_disambiguate_names        (NMDevice **devices,
                                                         int num_devices);
gboolean            nm_device_reapply                   (NMDevice *device,
                                                         NMConnection *connection,
                                                         guint64 version_id,
                                                         guint32 flags,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                nm_device_reapply_async             (NMDevice *device,
                                                         NMConnection *connection,
                                                         guint64 version_id,
                                                         guint32 flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            nm_device_reapply_finish            (NMDevice *device,
                                                         GAsyncResult *result,
                                                         GError **error);
NMConnection *      nm_device_get_applied_connection    (NMDevice *device,
                                                         guint32 flags,
                                                         guint64 *version_id,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                nm_device_get_applied_connection_async
                                                        (NMDevice *device,
                                                         guint32 flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
NMConnection *      nm_device_get_applied_connection_finish
                                                        (NMDevice *device,
                                                         GAsyncResult *result,
                                                         guint64 *version_id,
                                                         GError **error);
gboolean            nm_device_disconnect                (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                nm_device_disconnect_async          (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            nm_device_disconnect_finish         (NMDevice *device,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            nm_device_delete                    (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                nm_device_delete_async              (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            nm_device_delete_finish             (NMDevice *device,
                                                         GAsyncResult *result,
                                                         GError **error);
GPtrArray *         nm_device_filter_connections        (NMDevice *device,
                                                         const GPtrArray *connections);
gboolean            nm_device_connection_valid          (NMDevice *device,
                                                         NMConnection *connection);
gboolean            nm_device_connection_compatible     (NMDevice *device,
                                                         NMConnection *connection,
                                                         GError **error);
GType               nm_device_get_setting_type          (NMDevice *device);
NMLldpNeighbor *    nm_lldp_neighbor_new                (void);
void                nm_lldp_neighbor_ref                (NMLldpNeighbor *neighbor);
void                nm_lldp_neighbor_unref              (NMLldpNeighbor *neighbor);
char **             nm_lldp_neighbor_get_attr_names     (NMLldpNeighbor *neighbor);
gboolean            nm_lldp_neighbor_get_attr_string_value
                                                        (NMLldpNeighbor *neighbor,
                                                         char *name,
                                                         const char **out_value);
gboolean            nm_lldp_neighbor_get_attr_uint_value
                                                        (NMLldpNeighbor *neighbor,
                                                         char *name,
                                                         guint *out_value);
const GVariantType * nm_lldp_neighbor_get_attr_type     (NMLldpNeighbor *neighbor,
                                                         char *name);
                    NMLldpNeighbor;

Object Hierarchy

  GObject
   +----NMObject
         +----NMDevice
               +----NMDeviceAdsl
               +----NMDeviceBond
               +----NMDeviceBridge
               +----NMDeviceBt
               +----NMDeviceEthernet
               +----NMDeviceGeneric
               +----NMDeviceInfiniband
               +----NMDeviceIPTunnel
               +----NMDeviceMacvlan
               +----NMDeviceModem
               +----NMDeviceOlpcMesh
               +----NMDeviceTeam
               +----NMDeviceTun
               +----NMDeviceVlan
               +----NMDeviceVxlan
               +----NMDeviceWifi
               +----NMDeviceWimax
  GBoxed
   +----NMLldpNeighbor

Implemented Interfaces

NMDevice implements GInitable and GAsyncInitable.

Properties

  "active-connection"        NMActiveConnection*   : Read
  "autoconnect"              gboolean              : Read / Write
  "available-connections"    GPtrArray*            : Read
  "capabilities"             NMDeviceCapabilities  : Read
  "device-type"              NMDeviceType          : Read
  "dhcp4-config"             NMDhcpConfig*         : Read
  "dhcp6-config"             NMDhcpConfig*         : Read
  "driver"                   gchar*                : Read
  "driver-version"           gchar*                : Read
  "firmware-missing"         gboolean              : Read
  "firmware-version"         gchar*                : Read
  "interface"                gchar*                : Read
  "ip-interface"             gchar*                : Read
  "ip4-config"               NMIPConfig*           : Read
  "ip6-config"               NMIPConfig*           : Read
  "lldp-neighbors"           GPtrArray*            : Read
  "managed"                  gboolean              : Read
  "metered"                  guint                 : Read
  "mtu"                      guint                 : Read
  "nm-plugin-missing"        gboolean              : Read
  "physical-port-id"         gchar*                : Read
  "product"                  gchar*                : Read
  "real"                     gboolean              : Read
  "state"                    NMDeviceState         : Read
  "state-reason"             guint                 : Read
  "udi"                      gchar*                : Read
  "vendor"                   gchar*                : Read

Signals

  "state-changed"                                  : Run First

Description

Details

NM_DEVICE_DEVICE_TYPE

#define NM_DEVICE_DEVICE_TYPE "device-type"


NM_DEVICE_UDI

#define NM_DEVICE_UDI "udi"


NM_DEVICE_INTERFACE

#define NM_DEVICE_INTERFACE "interface"


NM_DEVICE_IP_INTERFACE

#define NM_DEVICE_IP_INTERFACE "ip-interface"


NM_DEVICE_DRIVER

#define NM_DEVICE_DRIVER "driver"


NM_DEVICE_DRIVER_VERSION

#define NM_DEVICE_DRIVER_VERSION "driver-version"


NM_DEVICE_FIRMWARE_VERSION

#define NM_DEVICE_FIRMWARE_VERSION "firmware-version"


NM_DEVICE_CAPABILITIES

#define NM_DEVICE_CAPABILITIES "capabilities"


NM_DEVICE_REAL

#define NM_DEVICE_REAL "real"


NM_DEVICE_MANAGED

#define NM_DEVICE_MANAGED "managed"


NM_DEVICE_AUTOCONNECT

#define NM_DEVICE_AUTOCONNECT "autoconnect"


NM_DEVICE_FIRMWARE_MISSING

#define NM_DEVICE_FIRMWARE_MISSING "firmware-missing"


NM_DEVICE_NM_PLUGIN_MISSING

#define NM_DEVICE_NM_PLUGIN_MISSING "nm-plugin-missing"


NM_DEVICE_IP4_CONFIG

#define NM_DEVICE_IP4_CONFIG "ip4-config"


NM_DEVICE_DHCP4_CONFIG

#define NM_DEVICE_DHCP4_CONFIG "dhcp4-config"


NM_DEVICE_IP6_CONFIG

#define NM_DEVICE_IP6_CONFIG "ip6-config"


NM_DEVICE_DHCP6_CONFIG

#define NM_DEVICE_DHCP6_CONFIG "dhcp6-config"


NM_DEVICE_STATE

#define NM_DEVICE_STATE "state"


NM_DEVICE_STATE_REASON

#define NM_DEVICE_STATE_REASON "state-reason"


NM_DEVICE_ACTIVE_CONNECTION

#define NM_DEVICE_ACTIVE_CONNECTION "active-connection"


NM_DEVICE_AVAILABLE_CONNECTIONS

#define NM_DEVICE_AVAILABLE_CONNECTIONS "available-connections"


NM_DEVICE_VENDOR

#define NM_DEVICE_VENDOR "vendor"


NM_DEVICE_PRODUCT

#define NM_DEVICE_PRODUCT "product"


NM_DEVICE_PHYSICAL_PORT_ID

#define NM_DEVICE_PHYSICAL_PORT_ID "physical-port-id"


NM_DEVICE_MTU

#define NM_DEVICE_MTU "mtu"


NM_DEVICE_METERED

#define NM_DEVICE_METERED "metered"


NM_DEVICE_LLDP_NEIGHBORS

#define NM_DEVICE_LLDP_NEIGHBORS "lldp-neighbors"


NMDevice

typedef struct _NMDevice NMDevice;

NMDeviceClass

typedef struct {
	NMObjectClass parent;

	/* Signals */
	void (*state_changed) (NMDevice *device,
	                       NMDeviceState new_state,
	                       NMDeviceState old_state,
	                       NMDeviceStateReason reason);

	/* Methods */
	gboolean (*connection_compatible) (NMDevice *device,
	                                   NMConnection *connection,
	                                   GError **error);

	const char * (*get_type_description) (NMDevice *device);
	const char * (*get_hw_address) (NMDevice *device);

	GType (*get_setting_type) (NMDevice *device);
} NMDeviceClass;


nm_device_get_iface ()

const char *        nm_device_get_iface                 (NMDevice *device);

Gets the interface name of the NMDevice.

device :

a NMDevice

Returns :

the interface of the device. This is the internal string used by the device, and must not be modified.

nm_device_get_ip_iface ()

const char *        nm_device_get_ip_iface              (NMDevice *device);

Gets the IP interface name of the NMDevice over which IP traffic flows when the device is in the ACTIVATED state.

device :

a NMDevice

Returns :

the IP traffic interface of the device. This is the internal string used by the device, and must not be modified.

nm_device_get_device_type ()

NMDeviceType        nm_device_get_device_type           (NMDevice *device);

Returns the numeric type of the NMDevice, ie Ethernet, Wi-Fi, etc.

device :

a NMDevice

Returns :

the device type

nm_device_get_udi ()

const char *        nm_device_get_udi                   (NMDevice *device);

Gets the Unique Device Identifier of the NMDevice.

device :

a NMDevice

Returns :

the Unique Device Identifier of the device. This identifier may be used to gather more information about the device from various operating system services like udev or sysfs.

nm_device_get_driver ()

const char *        nm_device_get_driver                (NMDevice *device);

Gets the driver of the NMDevice.

device :

a NMDevice

Returns :

the driver of the device. This is the internal string used by the device, and must not be modified.

nm_device_get_driver_version ()

const char *        nm_device_get_driver_version        (NMDevice *device);

Gets the driver version of the NMDevice.

device :

a NMDevice

Returns :

the version of the device driver. This is the internal string used by the device, and must not be modified.

nm_device_get_firmware_version ()

const char *        nm_device_get_firmware_version      (NMDevice *device);

Gets the firmware version of the NMDevice.

device :

a NMDevice

Returns :

the firmware version of the device. This is the internal string used by the device, and must not be modified.

nm_device_get_type_description ()

const char *        nm_device_get_type_description      (NMDevice *device);

Gets a (non-localized) description of the type of device that device is.

device :

a NMDevice

Returns :

the type description of the device. This is the internal string used by the device, and must not be modified.

nm_device_get_hw_address ()

const char *        nm_device_get_hw_address            (NMDevice *device);

Gets the current a hardware address (MAC) for the device.

device :

a NMDevice

Returns :

the current MAC of the device, or NULL. This is the internal string used by the device, and must not be modified.

nm_device_get_capabilities ()

NMDeviceCapabilities nm_device_get_capabilities         (NMDevice *device);

Gets the device' capabilities.

device :

a NMDevice

Returns :

the capabilities

nm_device_get_managed ()

gboolean            nm_device_get_managed               (NMDevice *device);

Whether the NMDevice is managed by NetworkManager.

device :

a NMDevice

Returns :

TRUE if the device is managed by NetworkManager

nm_device_set_managed ()

void                nm_device_set_managed               (NMDevice *device,
                                                         gboolean managed);

Enables or disables management of NMDevice by NetworkManager.

device :

a NMDevice

managed :

TRUE to make the device managed by NetworkManager.

Since 1.2


nm_device_get_autoconnect ()

gboolean            nm_device_get_autoconnect           (NMDevice *device);

Whether the NMDevice can be autoconnected.

device :

a NMDevice

Returns :

TRUE if the device is allowed to be autoconnected

nm_device_set_autoconnect ()

void                nm_device_set_autoconnect           (NMDevice *device,
                                                         gboolean autoconnect);

Enables or disables automatic activation of the NMDevice.

device :

a NMDevice

autoconnect :

TRUE to enable autoconnecting

nm_device_get_firmware_missing ()

gboolean            nm_device_get_firmware_missing      (NMDevice *device);

Indicates that firmware required for the device's operation is likely to be missing.

device :

a NMDevice

Returns :

TRUE if firmware required for the device's operation is likely to be missing.

nm_device_get_nm_plugin_missing ()

gboolean            nm_device_get_nm_plugin_missing     (NMDevice *device);

Indicates that the NetworkManager plugin for the device is not installed.

device :

a NMDevice

Returns :

TRUE if the device plugin not installed.

Since 1.2


nm_device_get_ip4_config ()

NMIPConfig *        nm_device_get_ip4_config            (NMDevice *device);

Gets the current IPv4 NMIPConfig associated with the NMDevice.

You can alternatively use nm_active_connection_get_ip4_config(), which also works with VPN connections.

device :

a NMDevice

Returns :

the IPv4 NMIPConfig, or NULL if the device is not activated. [transfer none]

nm_device_get_dhcp4_config ()

NMDhcpConfig *      nm_device_get_dhcp4_config          (NMDevice *device);

Gets the current IPv4 NMDhcpConfig associated with the NMDevice.

You can alternatively use nm_active_connection_get_dhcp4_config(), which also works with VPN connections.

device :

a NMDevice

Returns :

the IPv4 NMDhcpConfig, or NULL if the device is not activated or not using DHCP. [transfer none]

nm_device_get_ip6_config ()

NMIPConfig *        nm_device_get_ip6_config            (NMDevice *device);

Gets the current IPv6 NMIPConfig associated with the NMDevice.

You can alternatively use nm_active_connection_get_ip6_config(), which also works with VPN connections.

device :

a NMDevice

Returns :

the IPv6 NMIPConfig or NULL if the device is not activated. [transfer none]

nm_device_get_dhcp6_config ()

NMDhcpConfig *      nm_device_get_dhcp6_config          (NMDevice *device);

Gets the current IPv6 NMDhcpConfig associated with the NMDevice.

You can alternatively use nm_active_connection_get_dhcp6_config(), which also works with VPN connections.

device :

a NMDevice

Returns :

the IPv6 NMDhcpConfig, or NULL if the device is not activated or not using DHCPv6. [transfer none]

nm_device_get_state ()

NMDeviceState       nm_device_get_state                 (NMDevice *device);

Gets the current NMDevice state.

device :

a NMDevice

Returns :

the current device state

nm_device_get_state_reason ()

NMDeviceStateReason nm_device_get_state_reason          (NMDevice *device);

Gets the reason for entering the current NMDevice state.

device :

a NMDevice

Returns :

the reason for entering the current device state

nm_device_get_active_connection ()

NMActiveConnection * nm_device_get_active_connection    (NMDevice *device);

Gets the NMActiveConnection object which owns this device during activation.

device :

a NMDevice

Returns :

the NMActiveConnection or NULL if the device is not part of an active connection. [transfer none]

nm_device_get_available_connections ()

const GPtrArray *   nm_device_get_available_connections (NMDevice *device);

Gets the NMRemoteConnections currently known to the daemon that could be activated on device.

device :

a NMDevice

Returns :

the GPtrArray containing NMRemoteConnections. This is the internal copy used by the connection, and must not be modified. [element-type NMRemoteConnection]

nm_device_get_physical_port_id ()

const char *        nm_device_get_physical_port_id      (NMDevice *device);

Gets the physical port ID of the NMDevice. If non-NULL, this is an opaque string that can be used to recognize when seemingly-unrelated NMDevices are actually just different virtual ports on a single physical port. (Eg, NPAR / SR-IOV.)

device :

a NMDevice

Returns :

the physical port ID of the device, or NULL if the port ID is unknown. This is the internal string used by the device and must not be modified.

nm_device_get_mtu ()

guint32             nm_device_get_mtu                   (NMDevice *device);

Gets the MTU of the NMDevice.

device :

a NMDevice

Returns :

the MTU of the device.

nm_device_is_real ()

gboolean            nm_device_is_real                   (NMDevice *device);

device :

a NMDevice

Returns :

TRUE if the device exists, or FALSE if it is a placeholder device that could be automatically created by NetworkManager if one of its "available-connections" was activated.

Since 1.2


nm_device_is_software ()

gboolean            nm_device_is_software               (NMDevice *device);

Whether the device is a software device.

device :

a NMDevice

Returns :

TRUE if device is a software device, FALSE if it is a hardware device.

nm_device_get_product ()

const char *        nm_device_get_product               (NMDevice *device);

Gets the product string of the NMDevice.

device :

a NMDevice

Returns :

the product name of the device. This is the internal string used by the device, and must not be modified.

nm_device_get_vendor ()

const char *        nm_device_get_vendor                (NMDevice *device);

Gets the vendor string of the NMDevice.

device :

a NMDevice

Returns :

the vendor name of the device. This is the internal string used by the device, and must not be modified.

nm_device_get_description ()

const char *        nm_device_get_description           (NMDevice *device);

Gets a description of device, based on its vendor and product names.

device :

an NMDevice

Returns :

a description of device. If either the vendor or the product name is unknown, this returns the interface name.

nm_device_get_metered ()

NMMetered           nm_device_get_metered               (NMDevice *device);

Gets the metered setting of a NMDevice.

device :

a NMDevice

Returns :

the metered setting.

Since 1.2


nm_device_get_lldp_neighbors ()

GPtrArray *         nm_device_get_lldp_neighbors        (NMDevice *device);

Gets the list of neighbors discovered through LLDP.

device :

a NMDevice

Returns :

the GPtrArray containing NMLldpNeighbors. This is the internal copy used by the device and must not be modified. The library never modifies the returned array and thus it is safe for callers to reference and keep using it. [element-type NMLldpNeighbor][transfer none]

Since 1.2


nm_device_disambiguate_names ()

char **             nm_device_disambiguate_names        (NMDevice **devices,
                                                         int num_devices);

Generates a list of short-ish unique presentation names for the devices in devices.

devices :

an array of NMDevice. [array length=num_devices]

num_devices :

length of devices

Returns :

the device names. [transfer full][array zero-terminated=1]

nm_device_reapply ()

gboolean            nm_device_reapply                   (NMDevice *device,
                                                         NMConnection *connection,
                                                         guint64 version_id,
                                                         guint32 flags,
                                                         GCancellable *cancellable,
                                                         GError **error);

Attempts to update device with changes to the currently active connection made since it was last applied.

device :

a NMDevice

connection :

the NMConnection to replace the applied settings with or NULL to reuse existing

version_id :

zero or the expected version id of the applied connection. If specified and the version id mismatches, the call fails without modification. This allows to catch concurrent accesses.

flags :

always set this to zero

cancellable :

a GCancellable, or NULL

error :

location for a GError, or NULL

Returns :

TRUE on success, FALSE on error, in which case error will be set.

Since 1.2


nm_device_reapply_async ()

void                nm_device_reapply_async             (NMDevice *device,
                                                         NMConnection *connection,
                                                         guint64 version_id,
                                                         guint32 flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously begins an attempt to update device with changes to the currently active connection made since it was last applied.

device :

a NMDevice

connection :

the NMConnection to replace the applied settings with or NULL to reuse existing

version_id :

zero or the expected version id of the applied connection. If specified and the version id mismatches, the call fails without modification. This allows to catch concurrent accesses.

flags :

always set this to zero

cancellable :

a GCancellable, or NULL

callback :

callback to be called when the reapply operation completes

user_data :

caller-specific data passed to callback

Since 1.2


nm_device_reapply_finish ()

gboolean            nm_device_reapply_finish            (NMDevice *device,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of a call to nm_device_reapply_async().

device :

a NMDevice

result :

the result passed to the GAsyncReadyCallback

error :

location for a GError, or NULL

Returns :

TRUE on success, FALSE on error, in which case error will be set.

Since 1.2


nm_device_get_applied_connection ()

NMConnection *      nm_device_get_applied_connection    (NMDevice *device,
                                                         guint32 flags,
                                                         guint64 *version_id,
                                                         GCancellable *cancellable,
                                                         GError **error);

Fetch the currently applied connection on the device.

device :

a NMDevice

flags :

the flags argument. Currently this value must always be zero.

version_id :

(allow-none): returns the current version id of the applied connection. [out]

cancellable :

a GCancellable, or NULL

error :

location for a GError, or NULL

Returns :

a NMConnection with the currently applied settings or NULL on error. The connection is as received from D-Bus and might not validate according to nm_connection_verify(). [transfer full]

Since 1.2


nm_device_get_applied_connection_async ()

void                nm_device_get_applied_connection_async
                                                        (NMDevice *device,
                                                         guint32 flags,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously begins an get the a currently applied connection.

device :

a NMDevice

flags :

the flags argument. Currently this value must always be zero.

cancellable :

a GCancellable, or NULL

callback :

callback to be called when the reapply operation completes

user_data :

caller-specific data passed to callback

Since 1.2


nm_device_get_applied_connection_finish ()

NMConnection *      nm_device_get_applied_connection_finish
                                                        (NMDevice *device,
                                                         GAsyncResult *result,
                                                         guint64 *version_id,
                                                         GError **error);

Gets the result of a call to nm_device_get_applied_connection_async().

device :

a NMDevice

result :

the result passed to the GAsyncReadyCallback

version_id :

(allow-none): the current version id of the applied connection. [out]

error :

location for a GError, or NULL

Returns :

a currently applied NMConnection or NULL in case of error. The connection is as received from D-Bus and might not validate according to nm_connection_verify(). [transfer full]

Since 1.2


nm_device_disconnect ()

gboolean            nm_device_disconnect                (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GError **error);

Disconnects the device if currently connected, and prevents the device from automatically connecting to networks until the next manual network connection request.

device :

a NMDevice

cancellable :

a GCancellable, or NULL

error :

location for a GError, or NULL

Returns :

TRUE on success, FALSE on error, in which case error will be set.

nm_device_disconnect_async ()

void                nm_device_disconnect_async          (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously begins disconnecting the device if currently connected, and prevents the device from automatically connecting to networks until the next manual network connection request.

device :

a NMDevice

cancellable :

a GCancellable, or NULL

callback :

callback to be called when the disconnect operation completes

user_data :

caller-specific data passed to callback

nm_device_disconnect_finish ()

gboolean            nm_device_disconnect_finish         (NMDevice *device,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of a call to nm_device_disconnect_async().

device :

a NMDevice

result :

the result passed to the GAsyncReadyCallback

error :

location for a GError, or NULL

Returns :

TRUE on success, FALSE on error, in which case error will be set.

nm_device_delete ()

gboolean            nm_device_delete                    (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GError **error);

Deletes the software device. Hardware devices can't be deleted.

device :

a NMDevice

cancellable :

a GCancellable, or NULL

error :

location for a GError, or NULL

Returns :

TRUE on success, FALSE on error, in which case error will be set.

nm_device_delete_async ()

void                nm_device_delete_async              (NMDevice *device,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously begins deleteing the software device. Hardware devices can't be deleted.

device :

a NMDevice

cancellable :

a GCancellable, or NULL

callback :

callback to be called when delete operation completes

user_data :

caller-specific data passed to callback

nm_device_delete_finish ()

gboolean            nm_device_delete_finish             (NMDevice *device,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of a call to nm_device_delete_async().

device :

a NMDevice

result :

the result passed to the GAsyncReadyCallback

error :

location for a GError, or NULL

Returns :

TRUE on success, FALSE on error, in which case error will be set.

nm_device_filter_connections ()

GPtrArray *         nm_device_filter_connections        (NMDevice *device,
                                                         const GPtrArray *connections);

Filters a given array of connections for a given NMDevice object and returns connections which may be activated with the device. For example if device is a Wi-Fi device that supports only WEP encryption, the returned array will contain any Wi-Fi connections in connections that allow connection to unencrypted or WEP-enabled SSIDs. The returned array will not contain Ethernet, Bluetooth, Wi-Fi WPA connections, or any other connection that is incompatible with the device. To get the full list of connections see nm_client_get_connections().

device :

an NMDevice to filter connections for

connections :

an array of NMConnections to filter. [element-type NMConnection]

Returns :

an array of NMConnections that could be activated with the given device. The array should be freed with g_ptr_array_unref() when it is no longer required. [transfer container][element-type NMConnection]

nm_device_connection_valid ()

gboolean            nm_device_connection_valid          (NMDevice *device,
                                                         NMConnection *connection);

Validates a given connection for a given NMDevice object and returns whether the connection may be activated with the device. For example if device is a Wi-Fi device that supports only WEP encryption, the connection will only be valid if it is a Wi-Fi connection which describes a WEP or open network, and will not be valid if it describes a WPA network, or if it is an Ethernet, Bluetooth, WWAN, etc connection that is incompatible with the device.

device :

an NMDevice to validate connection against

connection :

an NMConnection to validate against device

Returns :

TRUE if the connection may be activated with this device, FALSE if is incompatible with the device's capabilities and characteristics.

nm_device_connection_compatible ()

gboolean            nm_device_connection_compatible     (NMDevice *device,
                                                         NMConnection *connection,
                                                         GError **error);

Validates a given connection for a given NMDevice object and returns whether the connection may be activated with the device. For example if device is a Wi-Fi device that supports only WEP encryption, the connection will only be valid if it is a Wi-Fi connection which describes a WEP or open network, and will not be valid if it describes a WPA network, or if it is an Ethernet, Bluetooth, WWAN, etc connection that is incompatible with the device.

This function does the same as nm_device_connection_valid(), i.e. checking compatibility of the given device and connection. But, in addition, it sets GError when FALSE is returned.

device :

an NMDevice to validate connection against

connection :

an NMConnection to validate against device

error :

return location for a GError, or NULL

Returns :

TRUE if the connection may be activated with this device, FALSE if is incompatible with the device's capabilities and characteristics.

nm_device_get_setting_type ()

GType               nm_device_get_setting_type          (NMDevice *device);

Gets the (primary) NMSetting subtype associated with connections that can be used on device.

device :

an NMDevice

Returns :

device's associated NMSetting type

nm_lldp_neighbor_new ()

NMLldpNeighbor *    nm_lldp_neighbor_new                (void);

Creates a new NMLldpNeighbor object.

Returns :

the new NMLldpNeighbor object. [transfer full]

Since 1.2


nm_lldp_neighbor_ref ()

void                nm_lldp_neighbor_ref                (NMLldpNeighbor *neighbor);

Increases the reference count of the object.

neighbor :

the NMLldpNeighbor

Since 1.2


nm_lldp_neighbor_unref ()

void                nm_lldp_neighbor_unref              (NMLldpNeighbor *neighbor);

Decreases the reference count of the object. If the reference count reaches zero, the object will be destroyed.

neighbor :

the NMLldpNeighbor

Since 1.2


nm_lldp_neighbor_get_attr_names ()

char **             nm_lldp_neighbor_get_attr_names     (NMLldpNeighbor *neighbor);

Gets an array of attribute names available for neighbor.

neighbor :

the NMLldpNeighbor

Returns :

a NULL-terminated array of attribute names. [transfer full]

Since 1.2


nm_lldp_neighbor_get_attr_string_value ()

gboolean            nm_lldp_neighbor_get_attr_string_value
                                                        (NMLldpNeighbor *neighbor,
                                                         char *name,
                                                         const char **out_value);

Gets the string value of attribute with name name on neighbor

neighbor :

the NMLldpNeighbor

name :

the attribute name

out_value :

on return, the attribute value. [out][allow-none][transfer none]

Returns :

TRUE if a string attribute with name name was found, FALSE otherwise

Since 1.2


nm_lldp_neighbor_get_attr_uint_value ()

gboolean            nm_lldp_neighbor_get_attr_uint_value
                                                        (NMLldpNeighbor *neighbor,
                                                         char *name,
                                                         guint *out_value);

Gets the uint value of attribute with name name on neighbor

neighbor :

the NMLldpNeighbor

name :

the attribute name

out_value :

on return, the attribute value. [out][allow-none]

Returns :

TRUE if a uint attribute with name name was found, FALSE otherwise

Since 1.2


nm_lldp_neighbor_get_attr_type ()

const GVariantType * nm_lldp_neighbor_get_attr_type     (NMLldpNeighbor *neighbor,
                                                         char *name);

Get the type of an attribute.

neighbor :

the NMLldpNeighbor

name :

the attribute name

Returns :

the GVariantType of the attribute with name name

Since 1.2


NMLldpNeighbor

typedef struct _NMLldpNeighbor NMLldpNeighbor;

Property Details

The "active-connection" property

  "active-connection"        NMActiveConnection*   : Read

The NMActiveConnection object that "owns" this device during activation.


The "autoconnect" property

  "autoconnect"              gboolean              : Read / Write

Whether the device can auto-activate a connection.

Default value: TRUE


The "available-connections" property

  "available-connections"    GPtrArray*            : Read

The available connections of the device

Element-type: NMRemoteConnection


The "capabilities" property

  "capabilities"             NMDeviceCapabilities  : Read

The capabilities of the device.


The "device-type" property

  "device-type"              NMDeviceType          : Read

The numeric type of the device.

Default value: NM_DEVICE_TYPE_UNKNOWN


The "dhcp4-config" property

  "dhcp4-config"             NMDhcpConfig*         : Read

The IPv4 NMDhcpConfig of the device.


The "dhcp6-config" property

  "dhcp6-config"             NMDhcpConfig*         : Read

The IPv6 NMDhcpConfig of the device.


The "driver" property

  "driver"                   gchar*                : Read

The driver of the device.

Default value: NULL


The "driver-version" property

  "driver-version"           gchar*                : Read

The version of the device driver.

Default value: NULL


The "firmware-missing" property

  "firmware-missing"         gboolean              : Read

When TRUE indicates the device is likely missing firmware required for its operation.

Default value: FALSE


The "firmware-version" property

  "firmware-version"         gchar*                : Read

The firmware version of the device.

Default value: NULL


The "interface" property

  "interface"                gchar*                : Read

The interface of the device.

Default value: NULL


The "ip-interface" property

  "ip-interface"             gchar*                : Read

The IP interface of the device which should be used for all IP-related operations like addressing and routing.

Default value: NULL


The "ip4-config" property

  "ip4-config"               NMIPConfig*           : Read

The NMIP4Config of the device.


The "ip6-config" property

  "ip6-config"               NMIPConfig*           : Read

The IPv6 NMIPConfig of the device.


The "lldp-neighbors" property

  "lldp-neighbors"           GPtrArray*            : Read

The LLDP neighbors.


The "managed" property

  "managed"                  gboolean              : Read

Whether the device is managed by NetworkManager.

Default value: FALSE


The "metered" property

  "metered"                  guint                 : Read

Whether the device is metered.

Default value: 0

Since 1.2


The "mtu" property

  "mtu"                      guint                 : Read

The MTU of the device.

Default value: 1500


The "nm-plugin-missing" property

  "nm-plugin-missing"        gboolean              : Read

When TRUE indicates that the NetworkManager plugin for the device is not installed.

Default value: FALSE

Since 1.2


The "physical-port-id" property

  "physical-port-id"         gchar*                : Read

The physical port ID of the device. (See nm_device_get_physical_port_id().)

Default value: NULL


The "product" property

  "product"                  gchar*                : Read

The product string of the device.

Default value: NULL


The "real" property

  "real"                     gboolean              : Read

Whether the device is real or is a placeholder device that could be created automatically by NetworkManager if one of its "available-connections" was activated.

Default value: FALSE

Since 1.2


The "state" property

  "state"                    NMDeviceState         : Read

The state of the device.

Default value: NM_DEVICE_STATE_UNKNOWN


The "state-reason" property

  "state-reason"             guint                 : Read

The reason for the device state.

Default value: 0


The "udi" property

  "udi"                      gchar*                : Read

An operating-system specific device hardware identifier; this is not unique to a specific hardware device across reboots or hotplugs. It is an opaque string which for some device types (Bluetooth, Modem) contains an identifier provided by the underlying hardware service daemon such as Bluez or ModemManager, and clients can use this property to request more information about the device from those services.

Default value: NULL


The "vendor" property

  "vendor"                   gchar*                : Read

The vendor string of the device.

Default value: NULL

Signal Details

The "state-changed" signal

void                user_function                      (NMDevice *device,
                                                        guint     new_state,
                                                        guint     old_state,
                                                        guint     reason,
                                                        gpointer  user_data)      : Run First

Notifies the state change of a NMDevice.

device :

the device object that received the signal

new_state :

the new state of the device

old_state :

the previous state of the device

reason :

the reason describing the state change

user_data :

user data set when the signal handler was connected.