NM_CLIENT_VERSION

#define NM_CLIENT_VERSION "version"

NM_CLIENT_STATE

#define NM_CLIENT_STATE "state"

NM_CLIENT_STARTUP

#define NM_CLIENT_STARTUP "startup"

NM_CLIENT_NM_RUNNING

#define NM_CLIENT_NM_RUNNING "nm-running"

NM_CLIENT_NETWORKING_ENABLED

#define NM_CLIENT_NETWORKING_ENABLED "networking-enabled"

NM_CLIENT_WIRELESS_ENABLED

#define NM_CLIENT_WIRELESS_ENABLED "wireless-enabled"

NM_CLIENT_WIRELESS_HARDWARE_ENABLED

#define NM_CLIENT_WIRELESS_HARDWARE_ENABLED "wireless-hardware-enabled"

NM_CLIENT_WWAN_ENABLED

#define NM_CLIENT_WWAN_ENABLED "wwan-enabled"

NM_CLIENT_WWAN_HARDWARE_ENABLED

#define NM_CLIENT_WWAN_HARDWARE_ENABLED "wwan-hardware-enabled"

NM_CLIENT_WIMAX_ENABLED

#define NM_CLIENT_WIMAX_ENABLED "wimax-enabled"

NM_CLIENT_WIMAX_HARDWARE_ENABLED

#define NM_CLIENT_WIMAX_HARDWARE_ENABLED "wimax-hardware-enabled"

NM_CLIENT_ACTIVE_CONNECTIONS

#define NM_CLIENT_ACTIVE_CONNECTIONS "active-connections"

NM_CLIENT_CONNECTIVITY

#define NM_CLIENT_CONNECTIVITY "connectivity"

NM_CLIENT_PRIMARY_CONNECTION

#define NM_CLIENT_PRIMARY_CONNECTION "primary-connection"

NM_CLIENT_ACTIVATING_CONNECTION

#define NM_CLIENT_ACTIVATING_CONNECTION "activating-connection"

NM_CLIENT_DEVICES

#define NM_CLIENT_DEVICES "devices"

NM_CLIENT_CONNECTIONS

#define NM_CLIENT_CONNECTIONS "connections"

NM_CLIENT_HOSTNAME

#define NM_CLIENT_HOSTNAME "hostname"

NM_CLIENT_CAN_MODIFY

#define NM_CLIENT_CAN_MODIFY "can-modify"

NM_CLIENT_DEVICE_ADDED

#define NM_CLIENT_DEVICE_ADDED "device-added"

NM_CLIENT_DEVICE_REMOVED

#define NM_CLIENT_DEVICE_REMOVED "device-removed"

NM_CLIENT_PERMISSION_CHANGED

#define NM_CLIENT_PERMISSION_CHANGED "permission-changed"

NM_CLIENT_CONNECTION_ADDED

#define NM_CLIENT_CONNECTION_ADDED "connection-added"

NM_CLIENT_CONNECTION_REMOVED

#define NM_CLIENT_CONNECTION_REMOVED "connection-removed"

enum NMClientPermission

typedef enum {
	NM_CLIENT_PERMISSION_NONE = 0,
	NM_CLIENT_PERMISSION_ENABLE_DISABLE_NETWORK = 1,
	NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIFI = 2,
	NM_CLIENT_PERMISSION_ENABLE_DISABLE_WWAN = 3,
	NM_CLIENT_PERMISSION_ENABLE_DISABLE_WIMAX = 4,
	NM_CLIENT_PERMISSION_SLEEP_WAKE = 5,
	NM_CLIENT_PERMISSION_NETWORK_CONTROL = 6,
	NM_CLIENT_PERMISSION_WIFI_SHARE_PROTECTED = 7,
	NM_CLIENT_PERMISSION_WIFI_SHARE_OPEN = 8,
	NM_CLIENT_PERMISSION_SETTINGS_MODIFY_SYSTEM = 9,
	NM_CLIENT_PERMISSION_SETTINGS_MODIFY_OWN = 10,
	NM_CLIENT_PERMISSION_SETTINGS_MODIFY_HOSTNAME = 11,

	NM_CLIENT_PERMISSION_LAST = NM_CLIENT_PERMISSION_SETTINGS_MODIFY_HOSTNAME
} NMClientPermission;

NMClientPermission values indicate various permissions that NetworkManager clients can obtain to perform certain tasks on behalf of the current user.

enum NMClientPermissionResult

typedef enum {
	NM_CLIENT_PERMISSION_RESULT_UNKNOWN = 0,
	NM_CLIENT_PERMISSION_RESULT_YES,
	NM_CLIENT_PERMISSION_RESULT_AUTH,
	NM_CLIENT_PERMISSION_RESULT_NO
} NMClientPermissionResult;

NMClientPermissionResult values indicate what authorizations and permissions the user requires to obtain a given NMClientPermission

enum NMClientError

typedef enum {
	NM_CLIENT_ERROR_FAILED = 0,
	NM_CLIENT_ERROR_MANAGER_NOT_RUNNING,
	NM_CLIENT_ERROR_OBJECT_CREATION_FAILED,
} NMClientError;

Describes errors that may result from operations involving a NMClient.

D-Bus operations may also return errors from other domains, including NMManagerError, NMSettingsError, NMAgentManagerError, and NMConnectionError.

NM_CLIENT_ERROR

#define NM_CLIENT_ERROR nm_client_error_quark ()

nm_client_error_quark ()

GQuark              nm_client_error_quark               (void);

Registers an error quark for NMClient if necessary.

struct NMClient

struct NMClient;

NMClientClass

typedef struct {
	GObjectClass parent;

	/* Signals */
	void (*device_added) (NMClient *client, NMDevice *device);
	void (*device_removed) (NMClient *client, NMDevice *device);
	void (*permission_changed) (NMClient *client,
	                            NMClientPermission permission,
	                            NMClientPermissionResult result);
	void (*connection_added)   (NMClient *client, NMRemoteConnection *connection);
	void (*connection_removed) (NMClient *client, NMRemoteConnection *connection);
} NMClientClass;

nm_client_new ()

NMClient *          nm_client_new                       (GCancellable *cancellable,
                                                         GError **error);

Creates a new NMClient.

Note that this will do blocking D-Bus calls to initialize the client. You can use nm_client_new_async() if you want to avoid that.

nm_client_new_async ()

void                nm_client_new_async                 (GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Creates a new NMClient and begins asynchronously initializing it. callback will be called when it is done; use nm_client_new_finish() to get the result. Note that on an error, the callback can be invoked with two first parameters as NULL.

nm_client_new_finish ()

NMClient *          nm_client_new_finish                (GAsyncResult *result,
                                                         GError **error);

Gets the result of an nm_client_new_async() call.

nm_client_get_version ()

const char *        nm_client_get_version               (NMClient *client);

Gets NetworkManager version.

nm_client_get_state ()

NMState             nm_client_get_state                 (NMClient *client);

Gets the current daemon state.

nm_client_get_startup ()

gboolean            nm_client_get_startup               (NMClient *client);

Tests whether the daemon is still in the process of activating connections at startup.

nm_client_get_nm_running ()

gboolean            nm_client_get_nm_running            (NMClient *client);

Determines whether the daemon is running.

nm_client_networking_get_enabled ()

gboolean            nm_client_networking_get_enabled    (NMClient *client);

Whether networking is enabled or disabled.

nm_client_networking_set_enabled ()

gboolean            nm_client_networking_set_enabled    (NMClient *client,
                                                         gboolean enabled,
                                                         GError **error);

Enables or disables networking. When networking is disabled, all controlled interfaces are disconnected and deactivated. When networking is enabled, all controlled interfaces are available for activation.

nm_client_wireless_get_enabled ()

gboolean            nm_client_wireless_get_enabled      (NMClient *client);

Determines whether the wireless is enabled.

nm_client_wireless_set_enabled ()

void                nm_client_wireless_set_enabled      (NMClient *client,
                                                         gboolean enabled);

Enables or disables wireless devices.

nm_client_wireless_hardware_get_enabled ()

gboolean            nm_client_wireless_hardware_get_enabled
                                                        (NMClient *client);

Determines whether the wireless hardware is enabled.

nm_client_wwan_get_enabled ()

gboolean            nm_client_wwan_get_enabled          (NMClient *client);

Determines whether WWAN is enabled.

nm_client_wwan_set_enabled ()

void                nm_client_wwan_set_enabled          (NMClient *client,
                                                         gboolean enabled);

Enables or disables WWAN devices.

nm_client_wwan_hardware_get_enabled ()

gboolean            nm_client_wwan_hardware_get_enabled (NMClient *client);

Determines whether the WWAN hardware is enabled.

nm_client_wimax_get_enabled ()

gboolean            nm_client_wimax_get_enabled         (NMClient *client);

Determines whether WiMAX is enabled.

nm_client_wimax_set_enabled ()

void                nm_client_wimax_set_enabled         (NMClient *client,
                                                         gboolean enabled);

Enables or disables WiMAX devices.

nm_client_wimax_hardware_get_enabled ()

gboolean            nm_client_wimax_hardware_get_enabled
                                                        (NMClient *client);

Determines whether the WiMAX hardware is enabled.

nm_client_get_logging ()

gboolean            nm_client_get_logging               (NMClient *client,
                                                         char **level,
                                                         char **domains,
                                                         GError **error);

Gets NetworkManager current logging level and domains.

nm_client_set_logging ()

gboolean            nm_client_set_logging               (NMClient *client,
                                                         const char *level,
                                                         const char *domains,
                                                         GError **error);

Sets NetworkManager logging level and/or domains.

nm_client_get_permission_result ()

NMClientPermissionResult nm_client_get_permission_result
                                                        (NMClient *client,
                                                         NMClientPermission permission);

Requests the result of a specific permission, which indicates whether the client can or cannot perform the action the permission represents

nm_client_get_connectivity ()

NMConnectivityState nm_client_get_connectivity          (NMClient *client);

Gets the current network connectivity state. Contrast nm_client_check_connectivity() and nm_client_check_connectivity_async(), which re-check the connectivity state first before returning any information.

nm_client_check_connectivity ()

NMConnectivityState nm_client_check_connectivity        (NMClient *client,
                                                         GCancellable *cancellable,
                                                         GError **error);

Updates the network connectivity state and returns the (new) current state. Contrast nm_client_get_connectivity(), which returns the most recent known state without re-checking.

This is a blocking call; use nm_client_check_connectivity_async() if you do not want to block.

nm_client_check_connectivity_async ()

void                nm_client_check_connectivity_async  (NMClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously updates the network connectivity state and invokes callback when complete. Contrast nm_client_get_connectivity(), which (immediately) returns the most recent known state without re-checking, and nm_client_check_connectivity(), which blocks.

nm_client_check_connectivity_finish ()

NMConnectivityState nm_client_check_connectivity_finish (NMClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Retrieves the result of an nm_client_check_connectivity_async() call.

nm_client_save_hostname ()

gboolean            nm_client_save_hostname             (NMClient *client,
                                                         const char *hostname,
                                                         GCancellable *cancellable,
                                                         GError **error);

Requests that the machine's persistent hostname be set to the specified value or cleared.

nm_client_save_hostname_async ()

void                nm_client_save_hostname_async       (NMClient *client,
                                                         const char *hostname,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Requests that the machine's persistent hostname be set to the specified value or cleared.

nm_client_save_hostname_finish ()

gboolean            nm_client_save_hostname_finish      (NMClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of an nm_client_save_hostname_async() call.

nm_client_get_devices ()

const GPtrArray *   nm_client_get_devices               (NMClient *client);

Gets all the known network devices. Use nm_device_get_type() or the NM_IS_DEVICE_XXXX functions to determine what kind of device member of the returned array is, and then you may use device-specific methods such as nm_device_ethernet_get_hw_address().

nm_client_get_device_by_path ()

NMDevice *          nm_client_get_device_by_path        (NMClient *client,
                                                         const char *object_path);

Gets a NMDevice from a NMClient.

nm_client_get_device_by_iface ()

NMDevice *          nm_client_get_device_by_iface       (NMClient *client,
                                                         const char *iface);

Gets a NMDevice from a NMClient.

nm_client_get_active_connections ()

const GPtrArray *   nm_client_get_active_connections    (NMClient *client);

Gets the active connections.

nm_client_get_primary_connection ()

NMActiveConnection * nm_client_get_primary_connection   (NMClient *client);

Gets the NMActiveConnection corresponding to the primary active network device.

In particular, when there is no VPN active, or the VPN does not have the default route, this returns the active connection that has the default route. If there is a VPN active with the default route, then this function returns the active connection that contains the route to the VPN endpoint.

If there is no default route, or the default route is over a non-NetworkManager-recognized device, this will return NULL.

nm_client_get_activating_connection ()

NMActiveConnection * nm_client_get_activating_connection
                                                        (NMClient *client);

Gets the NMActiveConnection corresponding to a currently-activating connection that is expected to become the new "primary-connection" upon successful activation.

nm_client_activate_connection_async ()

void                nm_client_activate_connection_async (NMClient *client,
                                                         NMConnection *connection,
                                                         NMDevice *device,
                                                         const char *specific_object,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously starts a connection to a particular network using the configuration settings from connection and the network device device. Certain connection types also take a "specific object" which is the object path of a connection- specific object, like an NMAccessPoint for Wi-Fi connections, or an NMWimaxNsp for WiMAX connections, to which you wish to connect. If the specific object is not given, NetworkManager can, in some cases, automatically determine which network to connect to given the settings in connection.

If connection is not given for a device-based activation, NetworkManager picks the best available connection for the device and activates it.

Note that the callback is invoked when NetworkManager has started activating the new connection, not when it finishes. You can used the returned NMActiveConnection object (in particular, "state") to track the activation to its completion.

nm_client_activate_connection_finish ()

NMActiveConnection * nm_client_activate_connection_finish
                                                        (NMClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of a call to nm_client_activate_connection_async().

nm_client_add_and_activate_connection_async ()

void                nm_client_add_and_activate_connection_async
                                                        (NMClient *client,
                                                         NMConnection *partial,
                                                         NMDevice *device,
                                                         const char *specific_object,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Adds a new connection using the given details (if any) as a template, automatically filling in missing settings with the capabilities of the given device and specific object. The new connection is then asynchronously activated as with nm_client_activate_connection_async(). Cannot be used for VPN connections at this time.

Note that the callback is invoked when NetworkManager has started activating the new connection, not when it finishes. You can used the returned NMActiveConnection object (in particular, "state") to track the activation to its completion.

nm_client_add_and_activate_connection_finish ()

NMActiveConnection * nm_client_add_and_activate_connection_finish
                                                        (NMClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of a call to nm_client_add_and_activate_connection_async().

You can call nm_active_connection_get_connection() on the returned NMActiveConnection to find the path of the created NMConnection.

nm_client_deactivate_connection ()

gboolean            nm_client_deactivate_connection     (NMClient *client,
                                                         NMActiveConnection *active,
                                                         GCancellable *cancellable,
                                                         GError **error);

Deactivates an active NMActiveConnection.

nm_client_deactivate_connection_async ()

void                nm_client_deactivate_connection_async
                                                        (NMClient *client,
                                                         NMActiveConnection *active,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Asynchronously deactivates an active NMActiveConnection.

nm_client_deactivate_connection_finish ()

gboolean            nm_client_deactivate_connection_finish
                                                        (NMClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of a call to nm_client_deactivate_connection_async().

nm_client_get_connections ()

const GPtrArray *   nm_client_get_connections           (NMClient *client);

nm_client_get_connection_by_id ()

NMRemoteConnection * nm_client_get_connection_by_id     (NMClient *client,
                                                         const char *id);

Returns the first matching NMRemoteConnection matching a given id.

nm_client_get_connection_by_path ()

NMRemoteConnection * nm_client_get_connection_by_path   (NMClient *client,
                                                         const char *path);

Returns the NMRemoteConnection representing the connection at path.

nm_client_get_connection_by_uuid ()

NMRemoteConnection * nm_client_get_connection_by_uuid   (NMClient *client,
                                                         const char *uuid);

Returns the NMRemoteConnection identified by uuid.

nm_client_add_connection_async ()

void                nm_client_add_connection_async      (NMClient *client,
                                                         NMConnection *connection,
                                                         gboolean save_to_disk,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Requests that the remote settings service add the given settings to a new connection. If save_to_disk is TRUE, the connection is immediately written to disk; otherwise it is initially only stored in memory, but may be saved later by calling the connection's nm_remote_connection_commit_changes() method.

connection is untouched by this function and only serves as a template of the settings to add. The NMRemoteConnection object that represents what NetworkManager actually added is returned to callback when the addition operation is complete.

Note that the NMRemoteConnection returned in callback may not contain identical settings to connection as NetworkManager may perform automatic completion and/or normalization of connection properties.

nm_client_add_connection_finish ()

NMRemoteConnection * nm_client_add_connection_finish    (NMClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of a call to nm_client_add_connection_async().

nm_client_load_connections ()

gboolean            nm_client_load_connections          (NMClient *client,
                                                         char **filenames,
                                                         char ***failures,
                                                         GCancellable *cancellable,
                                                         GError **error);

Requests that the remote settings service load or reload the given files, adding or updating the connections described within.

The changes to the indicated files will not yet be reflected in client's connections array when the function returns.

If all of the indicated files were successfully loaded, the function will return TRUE, and failures will be set to NULL. If NetworkManager tried to load the files, but some (or all) failed, then failures will be set to a NULL-terminated array of the filenames that failed to load.

nm_client_load_connections_async ()

void                nm_client_load_connections_async    (NMClient *client,
                                                         char **filenames,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Requests that the remote settings service asynchronously load or reload the given files, adding or updating the connections described within.

See nm_client_load_connections() for more details.

nm_client_load_connections_finish ()

gboolean            nm_client_load_connections_finish   (NMClient *client,
                                                         char ***failures,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of an nm_client_load_connections_async() call.

See nm_client_load_connections() for more details.

nm_client_reload_connections ()

gboolean            nm_client_reload_connections        (NMClient *client,
                                                         GCancellable *cancellable,
                                                         GError **error);

Requests that the remote settings service reload all connection files from disk, adding, updating, and removing connections until the in-memory state matches the on-disk state.

nm_client_reload_connections_async ()

void                nm_client_reload_connections_async  (NMClient *client,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

Requests that the remote settings service begin reloading all connection files from disk, adding, updating, and removing connections until the in-memory state matches the on-disk state.

nm_client_reload_connections_finish ()

gboolean            nm_client_reload_connections_finish (NMClient *client,
                                                         GAsyncResult *result,
                                                         GError **error);

Gets the result of an nm_client_reload_connections_async() call.

The "activating-connection" property

  "activating-connection"    NMActiveConnection*   : Read

The NMActiveConnection of the activating connection that is likely to become the new "primary-connection".

The "active-connections" property

  "active-connections"       GPtrArray*            : Read

The active connections.

Element-type: NMActiveConnection

The "can-modify" property

  "can-modify"               gboolean              : Read

If TRUE, adding and modifying connections is supported.

Default value: FALSE

The "connections" property

  "connections"              GPtrArray*            : Read

The list of configured connections that are available to the user. (Note that this differs from the underlying D-Bus property, which may also contain the object paths of connections that the user does not have permission to read the details of.)

Element-type: NMRemoteConnection

The "connectivity" property

  "connectivity"             NMConnectivityState   : Read

The network connectivity state.

Default value: NM_CONNECTIVITY_UNKNOWN

The "devices" property

  "devices"                  GPtrArray*            : Read

List of known network devices.

Element-type: NMDevice

The "hostname" property

  "hostname"                 gchar*                : Read

The machine hostname stored in persistent configuration. This can be modified by calling nm_client_save_hostname().

Default value: NULL

The "networking-enabled" property

  "networking-enabled"       gboolean              : Read / Write

Whether networking is enabled.

Default value: TRUE

The "nm-running" property

  "nm-running"               gboolean              : Read

Whether the daemon is running.

Default value: FALSE

The "primary-connection" property

  "primary-connection"       NMActiveConnection*   : Read

The NMActiveConnection of the device with the default route; see nm_client_get_primary_connection() for more details.

The "startup" property

  "startup"                  gboolean              : Read

Whether the daemon is still starting up.

Default value: FALSE

The "state" property

  "state"                    NMState               : Read

The current daemon state.

Default value: NM_STATE_UNKNOWN

The "version" property

  "version"                  gchar*                : Read

The NetworkManager version.

Default value: NULL

The "wimax-enabled" property

  "wimax-enabled"            gboolean              : Read / Write

Whether WiMAX functionality is enabled.

Default value: FALSE

The "wimax-hardware-enabled" property

  "wimax-hardware-enabled"   gboolean              : Read

Whether the WiMAX hardware is enabled.

Default value: FALSE

The "wireless-enabled" property

  "wireless-enabled"         gboolean              : Read / Write

Whether wireless is enabled.

Default value: FALSE

The "wireless-hardware-enabled" property

  "wireless-hardware-enabled" gboolean              : Read

Whether the wireless hardware is enabled.

Default value: TRUE

The "wwan-enabled" property

  "wwan-enabled"             gboolean              : Read / Write

Whether WWAN functionality is enabled.

Default value: FALSE

The "wwan-hardware-enabled" property

  "wwan-hardware-enabled"    gboolean              : Read

Whether the WWAN hardware is enabled.

Default value: FALSE

The "connection-added" signal

void                user_function                      (NMClient           *client,
                                                        NMRemoteConnection *connection,
                                                        gpointer            user_data)       : Run First

Notifies that a NMConnection has been added.

The "connection-removed" signal

void                user_function                      (NMClient           *client,
                                                        NMRemoteConnection *connection,
                                                        gpointer            user_data)       : Run First

Notifies that a NMConnection has been removed.

The "device-added" signal

void                user_function                      (NMClient *client,
                                                        GObject  *device,
                                                        gpointer  user_data)      : Run First

Notifies that a NMDevice is added.

The "device-removed" signal

void                user_function                      (NMClient *client,
                                                        GObject  *device,
                                                        gpointer  user_data)      : Run First

Notifies that a NMDevice is removed.

The "permission-changed" signal

void                user_function                      (NMClient *client,
                                                        guint     permission,
                                                        guint     result,
                                                        gpointer  user_data)       : Run First

Notifies that a permission has changed