nm_client_error_quark ()

GQuark
nm_client_error_quark (void);

Registers an error quark for NMClient if necessary.

nm_dns_entry_unref ()

void
nm_dns_entry_unref (NMDnsEntry *entry);

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

Since: 1.6

nm_dns_entry_get_interface ()

const char *
nm_dns_entry_get_interface (NMDnsEntry *entry);

Gets the interface on which name servers are contacted.

Since: 1.6

nm_dns_entry_get_nameservers ()

const char *const *
nm_dns_entry_get_nameservers (NMDnsEntry *entry);

Gets the list of name servers for this entry.

Since: 1.6

nm_dns_entry_get_domains ()

const char *const *
nm_dns_entry_get_domains (NMDnsEntry *entry);

Gets the list of DNS domains.

Since: 1.6

nm_dns_entry_get_priority ()

int
nm_dns_entry_get_priority (NMDnsEntry *entry);

Gets the priority of the entry

Since: 1.6

nm_dns_entry_get_vpn ()

gboolean
nm_dns_entry_get_vpn (NMDnsEntry *entry);

Gets whether the entry refers to VPN name servers.

Since: 1.6

nm_client_new ()

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

Creates a new NMClient synchronously.

Note that this will block until a NMClient instance is fully initialized. This does nothing beside calling g_initable_new(). You are free to call g_initable_new() or g_object_new()/g_initable_init() directly for more control, to set GObject properties or get access to the NMClient instance while it is still initializing.

Using the synchronous initialization creates an NMClient instance that uses an internal GMainContext. This context is invisible to the user. This introduces an additional overhead that is payed not only during object initialization, but for the entire lifetime of this object. Also, due to this internal GMainContext, the events are no longer in sync with other messages from GDBusConnection (but all events of the NMClient will themselves still be ordered). For a serious program, you should therefore avoid these problems by using g_async_initable_init_async() or nm_client_new_async() instead. The sync initialization is still useful for simple scripts or interactive testing for example via pygobject.

Creating an NMClient instance can only fail for two reasons. First, if you didn't provide a NM_CLIENT_DBUS_CONNECTION and the call to g_bus_get() fails. You can avoid that by using g_initable_new() directly and set a D-Bus connection. Second, if you cancelled the creation. If you do that, then note that after the failure there might still be idle actions pending which keep nm_client_get_main_context() alive. That means, in that case you must continue iterating the context to avoid leaks. See nm_client_get_context_busy_watcher().

Creating an NMClient instance when NetworkManager is not running does not cause a failure.

nm_client_new_async ()

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

Creates a new NMClient asynchronously. callback will be called when it is done. Use nm_client_new_finish() to get the result.

This does nothing beside calling g_async_initable_new_async(). You are free to call g_async_initable_new_async() or g_object_new()/g_async_initable_init_async() directly for more control, to set GObject properties or get access to the NMClient instance while it is still initializing.

Creating an NMClient instance can only fail for two reasons. First, if you didn't provide a NM_CLIENT_DBUS_CONNECTION and the call to g_bus_get() fails. You can avoid that by using g_async_initable_new_async() directly and set a D-Bus connection. Second, if you cancelled the creation. If you do that, then note that after the failure there might still be idle actions pending which keep nm_client_get_main_context() alive. That means, in that case you must continue iterating the context to avoid leaks. See nm_client_get_context_busy_watcher().

Creating an NMClient instance when NetworkManager is not running does not cause a failure.

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_instance_flags ()

NMClientInstanceFlags
nm_client_get_instance_flags (NMClient *self);

Since: 1.24

nm_client_get_dbus_connection ()

GDBusConnection *
nm_client_get_dbus_connection (NMClient *client);

Gets the GDBusConnection of the instance. This can be either passed when constructing the instance (as "dbus-connection" property), or it will be automatically initialized during async/sync init.

Since: 1.22

nm_client_get_main_context ()

GMainContext *
nm_client_get_main_context (NMClient *self);

The NMClient instance is permanently associated with the current thread default GMainContext, referenced the time when the instance was created. To receive events, the user must iterate this context and can use it to synchronize access to the client.

Note that even after NMClient instance got destroyed, there might still be pending sources registered in the context. That means, to fully clean up, the user must continue iterating the context as long as the nm_client_get_context_busy_watcher() object is alive.

Since: 1.22

nm_client_get_context_busy_watcher ()

GObject *
nm_client_get_context_busy_watcher (NMClient *self);

Since: 1.22

nm_client_get_dbus_name_owner ()

const char *
nm_client_get_dbus_name_owner (NMClient *client);

Since: 1.22

nm_client_get_version ()

const char *
nm_client_get_version (NMClient *client);

Gets NetworkManager version.

nm_client_get_version_info ()

const guint32 *
nm_client_get_version_info (NMClient *client,
                            gsize *length);

If available, the first element in the array is NM_VERSION which encodes the daemon version as "(major << 16 | minor << 8 | micro)". The following elements are a bitfield of NMVersionInfoCapabilities that indicate that the daemon supports a certain capability.

Since: 1.42

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_get_object_by_path ()

NMObject *
nm_client_get_object_by_path (NMClient *client,
                              const char *dbus_path);

Since: 1.24

nm_client_get_metered ()

NMMetered
nm_client_get_metered (NMClient *client);

Since: 1.22

nm_client_networking_get_enabled ()

gboolean
nm_client_networking_get_enabled (NMClient *client);

Whether networking is enabled or disabled.

nm_client_get_capabilities ()

const guint32 *
nm_client_get_capabilities (NMClient *client,
                            gsize *length);

Since: 1.24

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_radio_flags ()

NMRadioFlags
nm_client_get_radio_flags (NMClient *client);

Get radio flags.

Since: 1.38

nm_client_connectivity_check_get_available ()

gboolean
nm_client_connectivity_check_get_available
                               (NMClient *client);

Determine whether connectivity checking is available. This requires that the URI of a connectivity service has been set in the configuration file.

Since: 1.10

nm_client_connectivity_check_get_enabled ()

gboolean
nm_client_connectivity_check_get_enabled
                               (NMClient *client);

Determine whether connectivity checking is enabled.

Since: 1.10

nm_client_connectivity_check_set_enabled ()

void
nm_client_connectivity_check_set_enabled
                               (NMClient *client,
                                gboolean enabled);

Enable or disable connectivity checking. Note that if a connectivity checking URI has not been configured, this will not have any effect.

Since: 1.10

nm_client_connectivity_check_get_uri ()

const char *
nm_client_connectivity_check_get_uri (NMClient *client);

Get the URI that will be queried to determine if there is internet connectivity.

Since: 1.20

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_permissions_state ()

NMTernary
nm_client_get_permissions_state (NMClient *self);

Since: 1.24

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_all_devices ()

const GPtrArray *
nm_client_get_all_devices (NMClient *client);

Gets both real devices and device placeholders (eg, software devices which do not currently exist, but could be created automatically by NetworkManager if one of their NMDevice::ActivatableConnections was activated). Use nm_device_is_real() to determine whether each device is a real device or a placeholder.

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

Since: 1.2

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 use 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_add_and_activate_connection2 ()

void
nm_client_add_and_activate_connection2
                               (NMClient *client,
                                NMConnection *partial,
                                NMDevice *device,
                                const char *specific_object,
                                GVariant *options,
                                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.

This is identical to nm_client_add_and_activate_connection_async() but takes a further options parameter. Currently, the following options are supported by the daemon:

Since: 1.16

nm_client_add_and_activate_connection2_finish ()

NMActiveConnection *
nm_client_add_and_activate_connection2_finish
                               (NMClient *client,
                                GAsyncResult *result,
                                GVariant **out_result,
                                GError **error);

Gets the result of a call to nm_client_add_and_activate_connection2().

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

Since: 1.16

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_add_connection2 ()

void
nm_client_add_connection2 (NMClient *client,
                           GVariant *settings,
                           NMSettingsAddConnection2Flags flags,
                           GVariant *args,
                           gboolean ignore_out_result,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

Call AddConnection2() D-Bus API asynchronously.

Since: 1.20

nm_client_add_connection2_finish ()

NMRemoteConnection *
nm_client_add_connection2_finish (NMClient *client,
                                  GAsyncResult *result,
                                  GVariant **out_result,
                                  GError **error);

Since: 1.20

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.

nm_client_get_dns_mode ()

const char *
nm_client_get_dns_mode (NMClient *client);

Gets the current DNS processing mode.

Since: 1.6

nm_client_get_dns_rc_manager ()

const char *
nm_client_get_dns_rc_manager (NMClient *client);

Gets the current DNS resolv.conf manager.

Since: 1.6

nm_client_get_dns_configuration ()

const GPtrArray *
nm_client_get_dns_configuration (NMClient *client);

Gets the current DNS configuration

Since: 1.6

nm_client_get_checkpoints ()

const GPtrArray *
nm_client_get_checkpoints (NMClient *client);

Gets all the active checkpoints.

Since: 1.12

nm_client_checkpoint_create ()

void
nm_client_checkpoint_create (NMClient *client,
                             const GPtrArray *devices,
                             guint32 rollback_timeout,
                             NMCheckpointCreateFlags flags,
                             GCancellable *cancellable,
                             GAsyncReadyCallback callback,
                             gpointer user_data);

Creates a checkpoint of the current networking configuration for given interfaces. An empty devices argument means all devices. If rollback_timeout is not zero, a rollback is automatically performed after the given timeout.

Since: 1.12

nm_client_checkpoint_create_finish ()

NMCheckpoint *
nm_client_checkpoint_create_finish (NMClient *client,
                                    GAsyncResult *result,
                                    GError **error);

Gets the result of a call to nm_client_checkpoint_create().

Since: 1.12

nm_client_checkpoint_destroy ()

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

Destroys an existing checkpoint without performing a rollback.

Since: 1.12

nm_client_checkpoint_destroy_finish ()

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

Gets the result of a call to nm_client_checkpoint_destroy().

Since: 1.12

nm_client_checkpoint_rollback ()

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

Performs the rollback of a checkpoint before the timeout is reached.

Since: 1.12

nm_client_checkpoint_rollback_finish ()

GHashTable *
nm_client_checkpoint_rollback_finish (NMClient *client,
                                      GAsyncResult *result,
                                      GError **error);

Gets the result of a call to nm_client_checkpoint_rollback().

Since: 1.12

nm_client_checkpoint_adjust_rollback_timeout ()

void
nm_client_checkpoint_adjust_rollback_timeout
                               (NMClient *client,
                                const char *checkpoint_path,
                                guint32 add_timeout,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

Resets the timeout for the checkpoint with path checkpoint_path to timeout_add .

Since: 1.12

nm_client_checkpoint_adjust_rollback_timeout_finish ()

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

Gets the result of a call to nm_client_checkpoint_adjust_rollback_timeout().

Since: 1.12

nm_client_reload ()

void
nm_client_reload (NMClient *client,
                  NMManagerReloadFlags flags,
                  GCancellable *cancellable,
                  GAsyncReadyCallback callback,
                  gpointer user_data);

Reload NetworkManager's configuration and perform certain updates, like flushing caches or rewriting external state to disk. This is similar to sending SIGHUP to NetworkManager but it allows for more fine-grained control over what to reload (see flags ). It also allows non-root access via PolicyKit and contrary to signals it is synchronous.

Since: 1.22

nm_client_reload_finish ()

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

Gets the result of a call to nm_client_reload().

Since: 1.22

nm_client_dbus_call ()

void
nm_client_dbus_call (NMClient *client,
                     const char *object_path,
                     const char *interface_name,
                     const char *method_name,
                     GVariant *parameters,
                     const GVariantType *reply_type,
                     int timeout_msec,
                     GCancellable *cancellable,
                     GAsyncReadyCallback callback,
                     gpointer user_data);

Call g_dbus_connection_call() on the current name owner with the specified arguments. Most importantly, this invokes g_dbus_connection_call() with the client's GMainContext, so that the response is always in order with other events D-Bus events. Of course, the call uses GTask and will invoke the callback on the current g_main_context_get_thread_default().

This API is merely a convenient wrapper for g_dbus_connection_call(). You can also use g_dbus_connection_call() directly, with the same effect.

Since: 1.24

nm_client_dbus_call_finish ()

GVariant *
nm_client_dbus_call_finish (NMClient *client,
                            GAsyncResult *result,
                            GError **error);

Gets the result of a call to nm_client_dbus_call().

Since: 1.24

nm_client_dbus_set_property ()

void
nm_client_dbus_set_property (NMClient *client,
                             const char *object_path,
                             const char *interface_name,
                             const char *property_name,
                             GVariant *value,
                             int timeout_msec,
                             GCancellable *cancellable,
                             GAsyncReadyCallback callback,
                             gpointer user_data);

Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties" D-Bus interface.

Since: 1.24

nm_client_dbus_set_property_finish ()

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

Gets the result of a call to nm_client_dbus_set_property().

Since: 1.24

nm_utils_print ()

void
nm_utils_print (int output_mode,
                const char *msg);

The only purpose of this function is to give access to g_print() or g_printerr() from pygobject. libnm can do debug logging by setting LIBNM_CLIENT_DEBUG and uses thereby g_printerr() or g_print(). A plain "print()" function in python is not in sync with these functions (it implements additional buffering). By using nm_utils_print(), the same logging mechanisms can be used.

LIBNM_CLIENT_DEBUG is a list of keywords separated by commas. The keyword "trace" enables printing messages of the lowest up to the highest severity. Likewise, the severities "debug", "warn" ("warning") and "error" are honored in similar way. Setting the flags "ERROR" or "WARN" ("WARNING") implies that respective levels are enabled, but also are ERROR messages printed with g_critical() and WARN messages with g_warning(). Together with G_DEBUG="fatal-warnings" or G_DEBUG="fatal-critical" this can be used to abort the program on errors. Note that all <error> messages imply an unexpected data on the D-Bus API (due to a bug). <warn> also implies unexepected data, but that can happen when using different versions of libnm and daemon. For testing, it is good to turn these into assertions.

By default, messages are printed to stderr, unless LIBNM_CLIENT_DEBUG contains "stdout" flag. Also, libnm honors LIBNM_CLIENT_DEBUG_FILE environment. If this is set to a filename pattern (accepting "%p" for the process ID), then the debug log is written to that file instead of stderr/stdout. With output_mode zero, the same location will be written.

LIBNM_CLIENT_DEBUG_FILE is supported since 1.44. "ERROR", "WARN" and "WARNING" are supported since 1.46.

Since: 1.30

nm_utils_file_is_certificate ()

gboolean
nm_utils_file_is_certificate (const char *filename);

Tests if filename has a valid extension for an X.509 certificate file (".cer", ".crt", ".der", or ".pem"), and contains a certificate in a format recognized by NetworkManager.

nm_utils_file_is_private_key ()

gboolean
nm_utils_file_is_private_key (const char *filename,
                              gboolean *out_encrypted);

Tests if filename has a valid extension for an X.509 private key file (".der", ".key", ".pem", or ".p12"), and contains a private key in a format recognized by NetworkManager.

nm_utils_file_is_pkcs12 ()

gboolean
nm_utils_file_is_pkcs12 (const char *filename);

Tests if filename is a PKCS#12 file.

nm_client_wait_shutdown ()

void
nm_client_wait_shutdown (NMClient *client,
                         gboolean integrate_maincontext,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

The way to stop NMClient is by unrefing it. That will cancel all internally pending async operations. However, as async operations in NMClient use GTask, hence they cannot complete right away. Instead, their (internal) result callback still needs to be dispatched by iterating the client's main context.

You thus cannot stop iterating the client's main context until everything is wrapped up. nm_client_get_context_busy_watcher() helps to watch how long that will be.

This function automates that waiting. Like all glib async operations this honors the current g_main_context_get_thread_default().

In any case, to complete the shutdown, nm_client_get_main_context() must be iterated. If the current g_main_context_get_thread_default() is the same as nm_client_get_main_context(), then integrate_maincontext is ignored. In that case, the caller is required to iterate the context for shutdown to complete. Otherwise, if g_main_context_get_thread_default() differs from nm_client_get_main_context() and integrate_maincontext is FALSE, the caller must make sure that both contexts are iterated until completion. Otherwise, if integrate_maincontext is TRUE, then nm_client_get_main_context() will be integrated in g_main_context_get_thread_default(). This means, the caller gives nm_client_get_main_context() up until the waiting completes, the function will acquire the context and hook it into g_main_context_get_thread_default(). It is a bug to request integrate_maincontext while having nm_client_get_main_context() acquired or iterated otherwise because a context can only be acquired once at a time.

Shutdown can only complete after all references to client were released.

It is possible to call this function multiple times for the same client. But note that with integrate_maincontext the client's context is acquired, which can only be done once at a time.

It is permissible to start waiting before the objects is fully initialized.

The function really allows two separate things. To get a notification (callback) when shutdown is complete, and to integrate the client's context in another context. The latter case is useful if the client has a separate context and you hand it over to another GMainContext to wrap up.

The main use is to have a NMClient and a separate GMainContext on a worker thread. When being done, you can hand over the cleanup of the context to g_main_context_default(), assuming that the main thread iterates the default context. In that case, you don't need to care about passing a callback to know when shutdown completed.

Since: 1.42

nm_client_wait_shutdown_finish ()

gboolean
nm_client_wait_shutdown_finish (GAsyncResult *result,
                                GError **error);

Since: 1.42

enum NMClientInstanceFlags

Since: 1.24

NM_CLIENT_VERSION

#define NM_CLIENT_VERSION         "version"

NM_CLIENT_VERSION_INFO

#define NM_CLIENT_VERSION_INFO    "version-info"

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_DBUS_CONNECTION

#define NM_CLIENT_DBUS_CONNECTION "dbus-connection"

NM_CLIENT_DBUS_NAME_OWNER

#define NM_CLIENT_DBUS_NAME_OWNER "dbus-name-owner"

NM_CLIENT_INSTANCE_FLAGS

#define NM_CLIENT_INSTANCE_FLAGS  "instance-flags"

NM_CLIENT_NETWORKING_ENABLED

#define NM_CLIENT_NETWORKING_ENABLED "networking-enabled"

NM_CLIENT_WIRELESS_ENABLED

#define NM_CLIENT_WIRELESS_ENABLED "wireless-enabled"

NM_CLIENT_WWAN_ENABLED

#define NM_CLIENT_WWAN_ENABLED "wwan-enabled"

NM_CLIENT_WIMAX_ENABLED

#define NM_CLIENT_WIMAX_ENABLED "wimax-enabled"

NM_CLIENT_WIRELESS_HARDWARE_ENABLED

#define NM_CLIENT_WIRELESS_HARDWARE_ENABLED "wireless-hardware-enabled"

NM_CLIENT_WWAN_HARDWARE_ENABLED

#define NM_CLIENT_WWAN_HARDWARE_ENABLED     "wwan-hardware-enabled"

NM_CLIENT_WIMAX_HARDWARE_ENABLED

#define NM_CLIENT_WIMAX_HARDWARE_ENABLED    "wimax-hardware-enabled"

NM_CLIENT_RADIO_FLAGS

#define NM_CLIENT_RADIO_FLAGS "radio-flags"

NM_CLIENT_ACTIVE_CONNECTIONS

#define NM_CLIENT_ACTIVE_CONNECTIONS           "active-connections"

NM_CLIENT_CONNECTIVITY

#define NM_CLIENT_CONNECTIVITY                 "connectivity"

NM_CLIENT_CONNECTIVITY_CHECK_URI

#define NM_CLIENT_CONNECTIVITY_CHECK_URI       "connectivity-check-uri"

NM_CLIENT_CONNECTIVITY_CHECK_AVAILABLE

#define NM_CLIENT_CONNECTIVITY_CHECK_AVAILABLE "connectivity-check-available"

NM_CLIENT_CONNECTIVITY_CHECK_ENABLED

#define NM_CLIENT_CONNECTIVITY_CHECK_ENABLED "connectivity-check-enabled"

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_ALL_DEVICES

#define NM_CLIENT_ALL_DEVICES           "all-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_METERED

#define NM_CLIENT_METERED               "metered"

NM_CLIENT_DNS_MODE

#define NM_CLIENT_DNS_MODE              "dns-mode"

NM_CLIENT_DNS_RC_MANAGER

#define NM_CLIENT_DNS_RC_MANAGER        "dns-rc-manager"

NM_CLIENT_DNS_CONFIGURATION

#define NM_CLIENT_DNS_CONFIGURATION     "dns-configuration"

NM_CLIENT_CHECKPOINTS

#define NM_CLIENT_CHECKPOINTS           "checkpoints"

NM_CLIENT_CAPABILITIES

#define NM_CLIENT_CAPABILITIES          "capabilities"

NM_CLIENT_PERMISSIONS_STATE

#define NM_CLIENT_PERMISSIONS_STATE     "permissions-state"

NM_CLIENT_DEVICE_ADDED

#define NM_CLIENT_DEVICE_ADDED              "device-added"

NM_CLIENT_DEVICE_REMOVED

#define NM_CLIENT_DEVICE_REMOVED            "device-removed"

NM_CLIENT_ANY_DEVICE_ADDED

#define NM_CLIENT_ANY_DEVICE_ADDED          "any-device-added"

NM_CLIENT_ANY_DEVICE_REMOVED

#define NM_CLIENT_ANY_DEVICE_REMOVED        "any-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"

NM_CLIENT_ACTIVE_CONNECTION_ADDED

#define NM_CLIENT_ACTIVE_CONNECTION_ADDED   "active-connection-added"

NM_CLIENT_ACTIVE_CONNECTION_REMOVED

#define NM_CLIENT_ACTIVE_CONNECTION_REMOVED "active-connection-removed"

enum 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()

NMClient

typedef struct _NMClient NMClient;

NMClient contains a cache of the objects of NetworkManager's D-Bus API. It uses GMainContext and GDBusConnection for that and registers to D-Bus signals. That means, when iterating the associated GMainContext, D-Bus signals gets processed and the NMClient instance updates and emits GObject signals.

NMDnsEntry

typedef struct _NMDnsEntry NMDnsEntry;

Since: 1.6

The “activating-connection” property

  “activating-connection”    NMActiveConnection *

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

Owner: NMClient

Flags: Read

The “active-connections” property

  “active-connections”       GPtrArray *

The active connections.

[type GPtrArray(NMActiveConnection)]

Owner: NMClient

Flags: Read

The “all-devices” property

  “all-devices”              GPtrArray *

List of both real devices and device placeholders.

[type GPtrArray(NMDevice)]

Owner: NMClient

Flags: Read

Since: 1.2

The “can-modify” property

  “can-modify”               gboolean

If TRUE, adding and modifying connections is supported.

Owner: NMClient

Flags: Read

Default value: FALSE

The “capabilities” property

  “capabilities”             GArray *

The list of capabilities numbers as guint32 or NULL if there are no capabilities. The numeric value correspond to NMCapability enum.

[type GArray(guint32)]

Owner: NMClient

Flags: Read

Since: 1.24

The “checkpoints” property

  “checkpoints”              GPtrArray *

The list of active checkpoints.

[type GPtrArray(NMCheckpoint)]

Owner: NMClient

Flags: Read

Since: 1.12

The “connections” property

  “connections”              GPtrArray *

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

[type GPtrArray(NMRemoteConnection)]

Owner: NMClient

Flags: Read

The “connectivity” property

  “connectivity”             NMConnectivityState

The network connectivity state.

Owner: NMClient

Flags: Read

Default value: NM_CONNECTIVITY_UNKNOWN

The “connectivity-check-available” property

  “connectivity-check-available” gboolean

Owner: NMClient

Flags: Read

Default value: FALSE

The “connectivity-check-enabled” property

  “connectivity-check-enabled” gboolean

Owner: NMClient

Flags: Read / Write

Default value: FALSE

The “connectivity-check-uri” property

  “connectivity-check-uri”   char *

The used URI for connectivity checking.

Owner: NMClient

Flags: Read

Default value: NULL

Since: 1.22

The “dbus-connection” property

  “dbus-connection”          GDBusConnection *

The GDBusConnection to use.

If this is not set during object construction, the D-Bus connection will automatically be chosen during async/sync initalization via g_bus_get().

Owner: NMClient

Flags: Read / Write / Construct Only

Since: 1.22

The “dbus-name-owner” property

  “dbus-name-owner”          char *

The name owner of the NetworkManager D-Bus service.

Owner: NMClient

Flags: Read

Default value: NULL

Since: 1.22

The “devices” property

  “devices”                  GPtrArray *

List of real network devices. Does not include placeholder devices.

[type GPtrArray(NMDevice)]

Owner: NMClient

Flags: Read

The “dns-configuration” property

  “dns-configuration”        GPtrArray *

The current DNS configuration, represented as an array of NMDnsEntry objects.

[type GPtrArray(NMDnsEntry)]

Owner: NMClient

Flags: Read

Since: 1.6

The “dns-mode” property

  “dns-mode”                 char *

The current DNS processing mode.

Owner: NMClient

Flags: Read

Default value: NULL

Since: 1.6

The “dns-rc-manager” property

  “dns-rc-manager”           char *

The current resolv.conf management mode.

Owner: NMClient

Flags: Read

Default value: NULL

Since: 1.6

The “hostname” property

  “hostname”                 char *

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

Owner: NMClient

Flags: Read

Default value: NULL

The “instance-flags” property

  “instance-flags”           guint

NMClientInstanceFlags for the instance. These affect behavior of NMClient. This is a construct property and you may only set most flags only during construction.

The flag NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS can be toggled any time, even after constructing the instance. Note that you may want to watch NMClient:permissions-state property to know whether permissions are ready. Note that permissions are only fetched when NMClient has a D-Bus name owner.

The flags NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD and NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD cannot be set, however they will be returned by the getter after initialization completes.

Owner: NMClient

Flags: Read / Write / Construct

Default value: 0

Since: 1.24

The “metered” property

  “metered”                  guint

Whether the connectivity is metered.

Owner: NMClient

Flags: Read

Default value: 0

Since: 1.2

The “networking-enabled” property

  “networking-enabled”       gboolean

Whether networking is enabled.

The property setter is a synchronous D-Bus call. This is deprecated since 1.22.

Owner: NMClient

Flags: Read / Write

Default value: FALSE