NMDevice

NMDevice

Functions

const char * nm_device_get_iface ()
const char * nm_device_get_ip_iface ()
NMDeviceType nm_device_get_device_type ()
const char * nm_device_get_udi ()
const char * nm_device_get_path ()
const char * nm_device_get_driver ()
const char * nm_device_get_driver_version ()
const char * nm_device_get_firmware_version ()
const char * nm_device_get_type_description ()
const char * nm_device_get_hw_address ()
NMDeviceCapabilities nm_device_get_capabilities ()
gboolean nm_device_get_managed ()
const GPtrArray * nm_device_get_ports ()
void nm_device_set_managed ()
gboolean nm_device_get_autoconnect ()
void nm_device_set_autoconnect ()
gboolean nm_device_get_firmware_missing ()
gboolean nm_device_get_nm_plugin_missing ()
NMIPConfig * nm_device_get_ip4_config ()
NMDhcpConfig * nm_device_get_dhcp4_config ()
NMIPConfig * nm_device_get_ip6_config ()
NMDhcpConfig * nm_device_get_dhcp6_config ()
NMConnectivityState nm_device_get_connectivity ()
NMDeviceState nm_device_get_state ()
NMDeviceStateReason nm_device_get_state_reason ()
NMActiveConnection * nm_device_get_active_connection ()
const GPtrArray * nm_device_get_available_connections ()
const char * nm_device_get_physical_port_id ()
guint32 nm_device_get_mtu ()
gboolean nm_device_is_real ()
gboolean nm_device_is_software ()
const char * nm_device_get_product ()
const char * nm_device_get_vendor ()
const char * nm_device_get_description ()
NMMetered nm_device_get_metered ()
GPtrArray * nm_device_get_lldp_neighbors ()
NMDeviceInterfaceFlags nm_device_get_interface_flags ()
char ** nm_device_disambiguate_names ()
gboolean nm_device_reapply ()
void nm_device_reapply_async ()
gboolean nm_device_reapply_finish ()
NMConnection * nm_device_get_applied_connection ()
void nm_device_get_applied_connection_async ()
NMConnection * nm_device_get_applied_connection_finish ()
gboolean nm_device_disconnect ()
void nm_device_disconnect_async ()
gboolean nm_device_disconnect_finish ()
gboolean nm_device_delete ()
void nm_device_delete_async ()
gboolean nm_device_delete_finish ()
GPtrArray * nm_device_filter_connections ()
gboolean nm_device_connection_valid ()
gboolean nm_device_connection_compatible ()
GType nm_device_get_setting_type ()
void nm_lldp_neighbor_ref ()
void nm_lldp_neighbor_unref ()
char ** nm_lldp_neighbor_get_attr_names ()
GVariant * nm_lldp_neighbor_get_attr_value ()
NMLldpNeighbor * nm_lldp_neighbor_new ()
gboolean nm_lldp_neighbor_get_attr_string_value ()
gboolean nm_lldp_neighbor_get_attr_uint_value ()
const GVariantType * nm_lldp_neighbor_get_attr_type ()

Types and Values

Object Hierarchy

    GBoxed
    ╰── NMLldpNeighbor

Description

Functions

nm_device_get_iface ()

const char *
nm_device_get_iface (NMDevice *device);

nm_device_get_ip_iface ()

const char *
nm_device_get_ip_iface (NMDevice *device);

nm_device_get_device_type ()

NMDeviceType
nm_device_get_device_type (NMDevice *device);

nm_device_get_udi ()

const char *
nm_device_get_udi (NMDevice *device);

nm_device_get_path ()

const char *
nm_device_get_path (NMDevice *device);

nm_device_get_driver ()

const char *
nm_device_get_driver (NMDevice *device);

nm_device_get_driver_version ()

const char *
nm_device_get_driver_version (NMDevice *device);

nm_device_get_firmware_version ()

const char *
nm_device_get_firmware_version (NMDevice *device);

nm_device_get_type_description ()

const char *
nm_device_get_type_description (NMDevice *device);

nm_device_get_hw_address ()

const char *
nm_device_get_hw_address (NMDevice *device);

nm_device_get_capabilities ()

NMDeviceCapabilities
nm_device_get_capabilities (NMDevice *device);

nm_device_get_managed ()

gboolean
nm_device_get_managed (NMDevice *device);

nm_device_get_ports ()

const GPtrArray *
nm_device_get_ports (NMDevice *device);

nm_device_set_managed ()

void
nm_device_set_managed (NMDevice *device,
                       gboolean managed);

nm_device_set_managed is deprecated and should not be used in newly-written code.

nm_device_get_autoconnect ()

gboolean
nm_device_get_autoconnect (NMDevice *device);

nm_device_set_autoconnect ()

void
nm_device_set_autoconnect (NMDevice *device,
                           gboolean autoconnect);

nm_device_set_autoconnect is deprecated and should not be used in newly-written code.

nm_device_get_firmware_missing ()

gboolean
nm_device_get_firmware_missing (NMDevice *device);

nm_device_get_nm_plugin_missing ()

gboolean
nm_device_get_nm_plugin_missing (NMDevice *device);

nm_device_get_ip4_config ()

NMIPConfig *
nm_device_get_ip4_config (NMDevice *device);

nm_device_get_dhcp4_config ()

NMDhcpConfig *
nm_device_get_dhcp4_config (NMDevice *device);

nm_device_get_ip6_config ()

NMIPConfig *
nm_device_get_ip6_config (NMDevice *device);

nm_device_get_dhcp6_config ()

NMDhcpConfig *
nm_device_get_dhcp6_config (NMDevice *device);

nm_device_get_connectivity ()

NMConnectivityState
nm_device_get_connectivity (NMDevice *device,
                            int addr_family);

nm_device_get_state ()

NMDeviceState
nm_device_get_state (NMDevice *device);

nm_device_get_state_reason ()

NMDeviceStateReason
nm_device_get_state_reason (NMDevice *device);

nm_device_get_active_connection ()

NMActiveConnection *
nm_device_get_active_connection (NMDevice *device);

nm_device_get_available_connections ()

const GPtrArray *
nm_device_get_available_connections (NMDevice *device);

nm_device_get_physical_port_id ()

const char *
nm_device_get_physical_port_id (NMDevice *device);

nm_device_get_mtu ()

guint32
nm_device_get_mtu (NMDevice *device);

nm_device_is_real ()

gboolean
nm_device_is_real (NMDevice *device);

nm_device_is_software ()

gboolean
nm_device_is_software (NMDevice *device);

nm_device_get_product ()

const char *
nm_device_get_product (NMDevice *device);

nm_device_get_vendor ()

const char *
nm_device_get_vendor (NMDevice *device);

nm_device_get_description ()

const char *
nm_device_get_description (NMDevice *device);

nm_device_get_metered ()

NMMetered
nm_device_get_metered (NMDevice *device);

nm_device_get_lldp_neighbors ()

GPtrArray *
nm_device_get_lldp_neighbors (NMDevice *device);

nm_device_get_interface_flags ()

NMDeviceInterfaceFlags
nm_device_get_interface_flags (NMDevice *device);

nm_device_disambiguate_names ()

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

nm_device_reapply ()

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

nm_device_reapply is deprecated and should not be used in newly-written code.

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);

nm_device_reapply_finish ()

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

nm_device_get_applied_connection ()

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

nm_device_get_applied_connection is deprecated and should not be used in newly-written code.

nm_device_get_applied_connection_async ()

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

nm_device_get_applied_connection_finish ()

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

nm_device_disconnect ()

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

nm_device_disconnect is deprecated and should not be used in newly-written code.

nm_device_disconnect_async ()

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

nm_device_disconnect_finish ()

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

nm_device_delete ()

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

nm_device_delete is deprecated and should not be used in newly-written code.

nm_device_delete_async ()

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

nm_device_delete_finish ()

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

nm_device_filter_connections ()

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

nm_device_connection_valid ()

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

nm_device_connection_compatible ()

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

nm_device_get_setting_type ()

GType
nm_device_get_setting_type (NMDevice *device);

nm_lldp_neighbor_ref ()

void
nm_lldp_neighbor_ref (NMLldpNeighbor *neighbor);

nm_lldp_neighbor_unref ()

void
nm_lldp_neighbor_unref (NMLldpNeighbor *neighbor);

nm_lldp_neighbor_get_attr_names ()

char **
nm_lldp_neighbor_get_attr_names (NMLldpNeighbor *neighbor);

nm_lldp_neighbor_get_attr_value ()

GVariant *
nm_lldp_neighbor_get_attr_value (NMLldpNeighbor *neighbor,
                                 const char *name);

nm_lldp_neighbor_new ()

NMLldpNeighbor *
nm_lldp_neighbor_new (void);

nm_lldp_neighbor_get_attr_string_value ()

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

nm_lldp_neighbor_get_attr_uint_value ()

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

nm_lldp_neighbor_get_attr_type ()

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

Types and Values

NM_DEVICE_DEVICE_TYPE

#define NM_DEVICE_DEVICE_TYPE      "device-type"

NM_DEVICE_UDI

#define NM_DEVICE_UDI              "udi"

NM_DEVICE_PATH

#define NM_DEVICE_PATH             "path"

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_AUTOCONNECT is deprecated and should not be used in newly-written code.

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"

NM_DEVICE_IP4_CONNECTIVITY

#define NM_DEVICE_IP4_CONNECTIVITY      "ip4-connectivity"

NM_DEVICE_IP6_CONNECTIVITY

#define NM_DEVICE_IP6_CONNECTIVITY      "ip6-connectivity"

NM_DEVICE_INTERFACE_FLAGS

#define NM_DEVICE_INTERFACE_FLAGS       "interface-flags"

NM_DEVICE_HW_ADDRESS

#define NM_DEVICE_HW_ADDRESS            "hw-address"

NM_DEVICE_PORTS

#define NM_DEVICE_PORTS                 "ports"

NMLldpNeighbor

typedef struct _NMLldpNeighbor NMLldpNeighbor;

Supported attributes are: