{
int i = 0;
gboolean real_cmd = FALSE;
+ GError *error = NULL;
if (argc == 0)
real_cmd = TRUE;
args_info.argv = argv;
/* get system settings */
- if (!(nmc->system_settings = nm_remote_settings_new (NULL))) {
- g_string_printf (nmc->return_text, _("Error: Could not get system settings."));
+ if (!(nmc->system_settings = nm_remote_settings_new (NULL, &error))) {
+ g_string_printf (nmc->return_text, _("Error: Could not get system settings: %s."), error->message);
+ g_error_free (error);
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
nmc->should_wait = FALSE;
return nmc->return_value;
}
/* get system settings */
- if (!(rem_settings = nm_remote_settings_new (NULL))) {
- g_string_printf (nmc->return_text, _("Error: Could not get system settings."));
+ if (!(rem_settings = nm_remote_settings_new (NULL, &error))) {
+ g_string_printf (nmc->return_text, _("Error: Could not get system settings: %s."), error->message);
+ g_clear_error (&error);
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
goto finish;
}
static NMClient *
nmc_get_client (NmCli *nmc)
{
+ GError *error = NULL;
+
if (!nmc->client) {
- nmc->client = nm_client_new ();
+ nmc->client = nm_client_new (NULL, &error);
if (!nmc->client) {
- g_critical (_("Error: Could not create NMClient object."));
+ g_critical (_("Error: Could not create NMClient object: %s."), error->message);
+ g_clear_error (&error);
exit (NMC_RESULT_ERROR_UNKNOWN);
}
}
NMState state = NM_STATE_UNKNOWN;
GMainLoop *loop;
gint64 remaining_ms;
+ GError *error = NULL;
GOptionEntry options[] = {
{"timeout", 't', 0, G_OPTION_ARG_INT, &t_secs, N_("Time to wait for a connection, in seconds (without the option, default value is 30)"), "<timeout>"},
g_type_init ();
#endif
- client = nm_client_new ();
+ client = nm_client_new (NULL, &error);
if (!client) {
- g_printerr (_("Error: Could not create NMClient object."));
+ g_printerr (_("Error: Could not create NMClient object: %s."), error->message);
+ g_error_free (error);
return 2;
}
nm_editor_bindings_init ();
- nm_client = nm_client_new ();
+ nm_client = nm_client_new (NULL, &error);
+ if (!nm_client) {
+ g_printerr (_("Could not contact NetworkManager: %s.\n"), error->message);
+ g_error_free (error);
+ exit (1);
+ }
if (!nm_client_get_manager_running (nm_client)) {
g_printerr ("%s\n", _("NetworkManager is not running."));
exit (1);
}
- nm_settings = nm_remote_settings_new (NULL);
+ nm_settings = nm_remote_settings_new (NULL, &error);
+ if (!nm_settings) {
+ g_printerr (_("Could not contact NetworkManager: %s.\n"), error->message);
+ g_error_free (error);
+ exit (1);
+ }
g_signal_connect (nm_settings, NM_REMOTE_SETTINGS_CONNECTIONS_READ,
G_CALLBACK (connections_read), &got_connections);
/* coverity[loop_condition] */
* because libnm handles much of the low-level stuff for you.
*
* Compile with:
- * gcc -Wall `pkg-config --libs --cflags glib-2.0 dbus-glib-1 libnm` add-connection-libnm.c -o add-connection-libnm
+ * gcc -Wall `pkg-config --libs --cflags glib-2.0 libnm` add-connection-libnm.c -o add-connection-libnm
*/
#include <glib.h>
int main (int argc, char *argv[])
{
- DBusGConnection *bus;
NMRemoteSettings *settings;
GMainLoop *loop;
+ GError *error = NULL;
#if !GLIB_CHECK_VERSION (2, 35, 0)
/* Initialize GType system */
loop = g_main_loop_new (NULL, FALSE);
- /* Get system bus */
- bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL);
-
/* Create our proxy for NetworkManager's settings service */
- settings = nm_remote_settings_new (bus);
+ settings = nm_remote_settings_new (NULL, &error);
+ if (!settings) {
+ g_message ("Error: Could not get system settings: %s.", error->message);
+ g_error_free (error);
+ return 1;
+ }
/* Ask the settings service to add the new connection */
if (add_connection (settings, loop, "__Test connection__")) {
/* Clean up */
g_object_unref (settings);
- dbus_g_connection_unref (bus);
return 0;
}
NMClient *client;
const GPtrArray *devices;
int i;
+ GError *error = NULL;
#if !GLIB_CHECK_VERSION (2, 35, 0)
/* Initialize GType system */
#endif
/* Get NMClient object */
- client = nm_client_new ();
+ client = nm_client_new (NULL, &error);
if (!client) {
- g_message ("Error: Could not create NMClient.");
+ g_message ("Error: Could not create NMClient: %s.", error->message);
+ g_error_free (error);
return EXIT_FAILURE;
}
* (that wraps direct D-Bus calls).
*
* Compile with:
- * gcc -Wall `pkg-config --libs --cflags glib-2.0 dbus-glib-1 libnm` list-connections-libnm.c -o list-connections-libnm
+ * gcc -Wall `pkg-config --libs --cflags glib-2.0 libnm` list-connections-libnm.c -o list-connections-libnm
*/
#include <glib.h>
-#include <dbus/dbus-glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
static gboolean
list_connections (gpointer data)
{
- DBusGConnection *bus = (DBusGConnection *) data;
NMRemoteSettings *settings;
gboolean settings_running;
+ GError *error = NULL;
/* Get system settings */
- if (!(settings = nm_remote_settings_new (bus))) {
- g_message ("Error: Could not get system settings.");
+ if (!(settings = nm_remote_settings_new (NULL, &error))) {
+ g_message ("Error: Could not get system settings: %s.", error->message);
+ g_error_free (error);
result = EXIT_FAILURE;
g_main_loop_quit (loop);
return FALSE;
sys.exit('Usage: %s <interface>' % sys.argv[0])
dev_iface = sys.argv[1]
- c = NM.Client.new()
+ c = NM.Client.new(None)
dev = c.get_device_by_iface(dev_iface)
if dev is None:
sys.exit('Device \'%s\' not found' % dev_iface)
from gi.repository import GLib, NM
if __name__ == "__main__":
- client = NM.Client.new()
+ client = NM.Client.new(None)
acons = client.get_active_connections()
for ac in acons:
print "%s (%s) - %s" % (ac.get_id(), ac.get_uuid(), ac.get_connection_type())
sys.exit('Usage: %s <interface>' % sys.argv[0])
dev_iface = sys.argv[1]
- c = NM.Client.new()
+ c = NM.Client.new(None)
dev = c.get_device_by_iface(dev_iface)
if dev is None:
sys.exit('Device \'%s\' not found' % dev_iface)
print
if __name__ == "__main__":
- nmc = NM.Client.new()
+ nmc = NM.Client.new(None)
devs = nmc.get_devices()
for dev in devs:
{
}
-static GObject*
-constructor (GType type,
- guint n_construct_params,
- GObjectConstructParam *construct_params)
+static void
+constructed (GObject *object)
{
- GObject *object;
-
- object = G_OBJECT_CLASS (nm_setting_parent_class)->constructor (type,
- n_construct_params,
- construct_params);
-
_ensure_setting_info (object, NM_SETTING_GET_PRIVATE (object));
- return object;
+
+ G_OBJECT_CLASS (nm_setting_parent_class)->constructed (object);
}
static void
g_type_class_add_private (setting_class, sizeof (NMSettingPrivate));
/* virtual methods */
- object_class->constructor = constructor;
+ object_class->constructed = constructed;
object_class->get_property = get_property;
setting_class->update_one_secret = update_one_secret;
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NM_802_11_AP_FLAGS_NONE);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->flags;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NM_802_11_AP_SEC_NONE);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->wpa_flags;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NM_802_11_AP_SEC_NONE);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->rsn_flags;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->ssid;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->frequency;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->bssid;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->mode;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->max_bitrate;
}
{
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
- _nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->strength;
}
{
NMAccessPoint *ap = NM_ACCESS_POINT (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_FLAGS:
g_value_set_uint (value, nm_access_point_get_flags (ap));
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->connection;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->id;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->uuid;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->type;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->specific_object;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return handle_ptr_array_return (NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->devices);
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NM_ACTIVE_CONNECTION_STATE_UNKNOWN);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->state;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->is_default;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->ip4_config;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->dhcp4_config;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->is_default6;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->ip6_config;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->dhcp6_config;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->is_vpn;
}
{
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
- _nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->master;
}
{
NMActiveConnection *self = NM_ACTIVE_CONNECTION (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_CONNECTION:
g_value_set_string (value, nm_active_connection_get_connection (self));
{
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
- _nm_object_ensure_inited (NM_OBJECT (client));
-
return handle_ptr_array_return (NM_CLIENT_GET_PRIVATE (client)->devices);
}
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
- _nm_object_ensure_inited (NM_OBJECT (client));
-
priv = NM_CLIENT_GET_PRIVATE (client);
if (!priv->manager_running)
return NULL;
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wireless_enabled;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wireless_hw_enabled;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wwan_enabled;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wwan_hw_enabled;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wimax_enabled;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wimax_hw_enabled;
}
priv = NM_CLIENT_GET_PRIVATE (client);
- _nm_object_ensure_inited (NM_OBJECT (client));
-
return priv->manager_running ? priv->version : NULL;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), NM_STATE_UNKNOWN);
- _nm_object_ensure_inited (NM_OBJECT (client));
-
return NM_CLIENT_GET_PRIVATE (client)->state;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), NM_STATE_UNKNOWN);
- _nm_object_ensure_inited (NM_OBJECT (client));
-
return NM_CLIENT_GET_PRIVATE (client)->startup;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->networking_enabled;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->primary_connection;
}
{
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
- _nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->activating_connection;
}
NMConnectivityState
nm_client_get_connectivity (NMClient *client)
{
- NMClientPrivate *priv;
-
g_return_val_if_fail (NM_IS_CLIENT (client), NM_STATE_UNKNOWN);
- priv = NM_CLIENT_GET_PRIVATE (client);
- _nm_object_ensure_inited (NM_OBJECT (client));
-
- return priv->connectivity;
+ return NM_CLIENT_GET_PRIVATE (client)->connectivity;
}
/**
/**
* nm_client_new:
+ * @cancellable: a #GCancellable, or %NULL
+ * @error: location for a #GError, or %NULL
*
* Creates a new #NMClient.
*
* Returns: a new #NMClient or NULL on an error
**/
NMClient *
-nm_client_new (void)
+nm_client_new (GCancellable *cancellable,
+ GError **error)
{
- NMClient *client;
-
- client = g_object_new (NM_TYPE_CLIENT, NM_OBJECT_DBUS_PATH, NM_DBUS_PATH, NULL);
-
- /* NMObject's constructor() can fail on a D-Bus connection error. So we can
- * get NULL here instead of a valid NMClient object.
- */
- if (client)
- _nm_object_ensure_inited (NM_OBJECT (client));
-
- return client;
+ return g_initable_new (NM_TYPE_CLIENT, cancellable, error,
+ NULL);
}
static void
GSimpleAsyncResult *simple = user_data;
GError *error = NULL;
- if (!g_async_initable_init_finish (G_ASYNC_INITABLE (source), result, &error))
+ if (!g_async_initable_new_finish (G_ASYNC_INITABLE (source), result, &error))
g_simple_async_result_take_error (simple, error);
else
g_simple_async_result_set_op_res_gpointer (simple, source, g_object_unref);
GAsyncReadyCallback callback,
gpointer user_data)
{
- NMClient *client;
GSimpleAsyncResult *simple;
- client = g_object_new (NM_TYPE_CLIENT, NM_OBJECT_DBUS_PATH, NM_DBUS_PATH, NULL);
- /* When client is NULL, do no continue with initialization and run callback
- * directly with result == NULL indicating NMClient creation failure.
- */
- if (!client) {
- callback (NULL, NULL, user_data);
- return;
- }
-
simple = g_simple_async_result_new (NULL, callback, user_data, nm_client_new_async);
- g_async_initable_init_async (G_ASYNC_INITABLE (client), G_PRIORITY_DEFAULT,
- cancellable, client_inited, simple);
+
+ g_async_initable_new_async (NM_TYPE_CLIENT, G_PRIORITY_DEFAULT,
+ cancellable, client_inited, simple,
+ NULL);
}
/**
guint n_construct_params,
GObjectConstructParam *construct_params)
{
- GObject *object;
guint i;
const char *dbus_path;
}
}
- object = G_OBJECT_CLASS (nm_client_parent_class)->constructor (type,
- n_construct_params,
- construct_params);
-
- return object;
+ return G_OBJECT_CLASS (nm_client_parent_class)->constructor (type,
+ n_construct_params,
+ construct_params);
}
static void
constructed (GObject *object)
{
- GError *error = NULL;
-
- if (!nm_utils_init (&error)) {
- g_warning ("Couldn't initilize nm-utils/crypto system: %d %s",
- error->code, error->message);
- g_clear_error (&error);
- }
-
G_OBJECT_CLASS (nm_client_parent_class)->constructed (object);
g_signal_connect (object, "notify::" NM_CLIENT_WIRELESS_ENABLED,
NMClient *client = NM_CLIENT (initable);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
+ if (!nm_utils_init (error))
+ return FALSE;
+
if (!nm_client_parent_initable_iface->init (initable, cancellable, error))
return FALSE;
{
NMClientInitData *init_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (initable);
+ GError *error = NULL;
+
+ if (!nm_utils_init (&error)) {
+ g_simple_async_report_take_gerror_in_idle (G_OBJECT (initable),
+ callback, user_data, error);
+ return;
+ }
init_data = g_slice_new0 (NMClientInitData);
init_data->client = NM_CLIENT (initable);
NMClient *self = NM_CLIENT (object);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (self);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_VERSION:
g_value_set_string (value, nm_client_get_version (self));
GType nm_client_get_type (void);
-NMClient *nm_client_new (void);
+NMClient *nm_client_new (GCancellable *cancellable,
+ GError **error);
void nm_client_new_async (GCancellable *cancellable,
GAsyncReadyCallback callback,
{
g_return_val_if_fail (NM_IS_DEVICE_ADSL (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ADSL_GET_PRIVATE (device)->carrier;
}
{
g_return_val_if_fail (NM_IS_DEVICE_BOND (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BOND_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_BOND (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BOND_GET_PRIVATE (device)->carrier;
}
{
g_return_val_if_fail (NM_IS_DEVICE_BOND (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return handle_ptr_array_return (NM_DEVICE_BOND_GET_PRIVATE (device)->slaves);
}
{
NMDeviceBond *device = NM_DEVICE_BOND (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_bond_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_BRIDGE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BRIDGE_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_BRIDGE (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BRIDGE_GET_PRIVATE (device)->carrier;
}
{
g_return_val_if_fail (NM_IS_DEVICE_BRIDGE (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return handle_ptr_array_return (NM_DEVICE_BRIDGE_GET_PRIVATE (device)->slaves);
}
{
NMDeviceBridge *device = NM_DEVICE_BRIDGE (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_bridge_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_BT (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BT_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_BT (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BT_GET_PRIVATE (device)->name;
}
{
g_return_val_if_fail (NM_IS_DEVICE_BT (device), NM_BT_CAPABILITY_NONE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BT_GET_PRIVATE (device)->bt_capabilities;
}
{
NMDeviceBt *device = NM_DEVICE_BT (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_bt_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->perm_hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->speed;
}
{
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->carrier;
}
{
NMDeviceEthernet *device = NM_DEVICE_ETHERNET (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_ethernet_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_GENERIC (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GENERIC_GET_PRIVATE (device)->hw_address;
}
{
NMDeviceGenericPrivate *priv = NM_DEVICE_GENERIC_GET_PRIVATE (device);
- _nm_object_ensure_inited (NM_OBJECT (device));
return priv->type_description;
}
{
NMDeviceGenericPrivate *priv = NM_DEVICE_GENERIC_GET_PRIVATE (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, priv->hw_address);
{
g_return_val_if_fail (NM_IS_DEVICE_INFINIBAND (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_INFINIBAND_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_INFINIBAND (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_INFINIBAND_GET_PRIVATE (device)->carrier;
}
{
NMDeviceInfiniband *device = NM_DEVICE_INFINIBAND (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_infiniband_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_MODEM (self), NM_DEVICE_MODEM_CAPABILITY_NONE);
- _nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_MODEM_GET_PRIVATE (self)->caps;
}
{
g_return_val_if_fail (NM_IS_DEVICE_MODEM (self), NM_DEVICE_MODEM_CAPABILITY_NONE);
- _nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_MODEM_GET_PRIVATE (self)->current_caps;
}
{
NMDeviceModem *self = NM_DEVICE_MODEM (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_MODEM_CAPS:
g_value_set_uint (value, nm_device_modem_get_modem_capabilities (self));
{
g_return_val_if_fail (NM_IS_DEVICE_OLPC_MESH (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_OLPC_MESH_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_OLPC_MESH (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_OLPC_MESH_GET_PRIVATE (device)->companion;
}
{
g_return_val_if_fail (NM_IS_DEVICE_OLPC_MESH (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_OLPC_MESH_GET_PRIVATE (device)->active_channel;
}
{
NMDeviceOlpcMesh *device = NM_DEVICE_OLPC_MESH (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_olpc_mesh_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_TEAM (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_TEAM_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_TEAM (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_TEAM_GET_PRIVATE (device)->carrier;
}
{
g_return_val_if_fail (NM_IS_DEVICE_TEAM (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return handle_ptr_array_return (NM_DEVICE_TEAM_GET_PRIVATE (device)->slaves);
}
{
NMDeviceTeam *device = NM_DEVICE_TEAM (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_team_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_VLAN_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_VLAN_GET_PRIVATE (device)->carrier;
}
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_VLAN_GET_PRIVATE (device)->vlan_id;
}
{
NMDeviceVlan *device = NM_DEVICE_VLAN (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_vlan_get_hw_address (device));
{
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->perm_hw_address;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->mode;
}
return 0;
}
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->rate;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->wireless_caps;
}
break;
}
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->active_ap;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return handle_ptr_array_return (NM_DEVICE_WIFI_GET_PRIVATE (device)->aps);
}
{
NMDeviceWifi *self = NM_DEVICE_WIFI (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_wifi_get_hw_address (self));
{
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (wimax), NULL);
- _nm_object_ensure_inited (NM_OBJECT (wimax));
return NM_DEVICE_WIMAX_GET_PRIVATE (wimax)->hw_address;
}
break;
}
- _nm_object_ensure_inited (NM_OBJECT (wimax));
return NM_DEVICE_WIMAX_GET_PRIVATE (wimax)->active_nsp;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (wimax), NULL);
- _nm_object_ensure_inited (NM_OBJECT (wimax));
return handle_ptr_array_return (NM_DEVICE_WIMAX_GET_PRIVATE (wimax)->nsps);
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
- _nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->center_freq;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
- _nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->rssi;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
- _nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->cinr;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
- _nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->tx_power;
}
{
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), NULL);
- _nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->bsid;
}
{
NMDeviceWimax *self = NM_DEVICE_WIMAX (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, nm_device_wimax_get_hw_address (self));
NMDevice *device = NM_DEVICE (object);
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_DEVICE_TYPE:
g_value_set_uint (value, nm_device_get_device_type (device));
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->iface;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->ip_iface;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->udi;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->driver;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->driver_version;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->firmware_version;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->capabilities;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->managed;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->autoconnect;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->firmware_missing;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->ip4_config;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->dhcp4_config;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->ip6_config;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->dhcp6_config;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NM_DEVICE_STATE_UNKNOWN);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->state;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NM_DEVICE_STATE_UNKNOWN);
- _nm_object_ensure_inited (NM_OBJECT (device));
if (reason)
*reason = NM_DEVICE_GET_PRIVATE (device)->reason;
return NM_DEVICE_GET_PRIVATE (device)->state;
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->active_connection;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
- _nm_object_ensure_inited (NM_OBJECT (device));
return handle_ptr_array_return (NM_DEVICE_GET_PRIVATE (device)->available_connections);
}
priv = NM_DEVICE_GET_PRIVATE (device);
- _nm_object_ensure_inited (NM_OBJECT (device));
if (priv->physical_port_id && *priv->physical_port_id)
return priv->physical_port_id;
else
{
g_return_val_if_fail (NM_IS_DEVICE (device), 0);
- _nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->mtu;
}
{
g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
- _nm_object_ensure_inited (NM_OBJECT (device));
return !!(NM_DEVICE_GET_PRIVATE (device)->capabilities & NM_DEVICE_CAP_IS_SOFTWARE);
}
static void
nm_dhcp4_config_init (NMDhcp4Config *config)
{
+ NMDhcp4ConfigPrivate *priv = NM_DHCP4_CONFIG_GET_PRIVATE (config);
+
+ priv->options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
}
static gboolean
property_info);
}
-static void
-constructed (GObject *object)
-{
- NMDhcp4ConfigPrivate *priv = NM_DHCP4_CONFIG_GET_PRIVATE (object);
-
- G_OBJECT_CLASS (nm_dhcp4_config_parent_class)->constructed (object);
-
- priv->options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
-
-}
-
static void
finalize (GObject *object)
{
{
NMDhcp4Config *self = NM_DHCP4_CONFIG (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_OPTIONS:
g_value_set_boxed (value, nm_dhcp4_config_get_options (self));
g_type_class_add_private (config_class, sizeof (NMDhcp4ConfigPrivate));
/* virtual methods */
- object_class->constructed = constructed;
object_class->get_property = get_property;
object_class->finalize = finalize;
{
g_return_val_if_fail (NM_IS_DHCP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_DHCP4_CONFIG_GET_PRIVATE (config)->options;
}
static void
nm_dhcp6_config_init (NMDhcp6Config *config)
{
+ NMDhcp6ConfigPrivate *priv = NM_DHCP6_CONFIG_GET_PRIVATE (config);
+
+ priv->options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
}
static gboolean
property_info);
}
-static void
-constructed (GObject *object)
-{
- NMDhcp6ConfigPrivate *priv = NM_DHCP6_CONFIG_GET_PRIVATE (object);
-
- G_OBJECT_CLASS (nm_dhcp6_config_parent_class)->constructed (object);
-
- priv->options = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
-
-}
-
static void
finalize (GObject *object)
{
{
NMDhcp6Config *self = NM_DHCP6_CONFIG (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_OPTIONS:
g_value_set_boxed (value, nm_dhcp6_config_get_options (self));
g_type_class_add_private (config_class, sizeof (NMDhcp6ConfigPrivate));
/* virtual methods */
- object_class->constructed = constructed;
object_class->get_property = get_property;
object_class->finalize = finalize;
{
g_return_val_if_fail (NM_IS_DHCP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_DHCP6_CONFIG_GET_PRIVATE (config)->options;
}
NMIP4Config *self = NM_IP4_CONFIG (object);
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_GATEWAY:
g_value_set_string (value, nm_ip4_config_get_gateway (self));
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->gateway;
}
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->addresses;
}
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->nameservers;
}
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return handle_ptr_array_return (NM_IP4_CONFIG_GET_PRIVATE (config)->domains);
}
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return handle_ptr_array_return (NM_IP4_CONFIG_GET_PRIVATE (config)->searches);
}
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->wins;
}
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->routes;
}
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP6_CONFIG_GET_PRIVATE (config)->gateway;
}
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP6_CONFIG_GET_PRIVATE (config)->addresses;
}
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), 0);
- _nm_object_ensure_inited (NM_OBJECT (config));
return g_slist_length (NM_IP6_CONFIG_GET_PRIVATE (config)->nameservers);
}
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
priv = NM_IP6_CONFIG_GET_PRIVATE (config);
for (item = priv->nameservers; item && i < idx; i++)
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP6_CONFIG_GET_PRIVATE (config)->nameservers;
}
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return handle_ptr_array_return (NM_IP6_CONFIG_GET_PRIVATE (config)->domains);
}
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return handle_ptr_array_return (NM_IP6_CONFIG_GET_PRIVATE (config)->searches);
}
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
- _nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP6_CONFIG_GET_PRIVATE (config)->routes;
}
NMIP6Config *self = NM_IP6_CONFIG (object);
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_GATEWAY:
g_value_set_string (value, nm_ip6_config_get_gateway (self));
#include <gio/gio.h>
#include "nm-object.h"
-void _nm_object_ensure_inited (NMObject *object);
-
typedef gboolean (*PropertyMarshalFunc) (NMObject *, GParamSpec *, GValue *, gpointer);
typedef GObject * (*NMObjectCreatorFunc) (DBusGConnection *, const char *);
#include <string.h>
#include <gio/gio.h>
+#include <glib/gi18n.h>
#include <stdlib.h>
#include <stdio.h>
#include <nm-utils.h>
GSList *notify_props;
guint32 notify_id;
- gboolean inited;
GSList *reload_results;
guint reload_remaining;
{
}
-static GObject*
-constructor (GType type,
- guint n_construct_params,
- GObjectConstructParam *construct_params)
+static gboolean
+init_common (NMObject *self, GError **error)
{
- GObject *object;
- NMObjectPrivate *priv;
-
- object = G_OBJECT_CLASS (nm_object_parent_class)->constructor (type,
- n_construct_params,
- construct_params);
-
- priv = NM_OBJECT_GET_PRIVATE (object);
+ NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
- if (priv->connection == NULL || priv->path == NULL) {
- g_warn_if_reached ();
- g_object_unref (object);
- return NULL;
+ if (!priv->path) {
+ g_set_error_literal (error, NM_OBJECT_ERROR, NM_OBJECT_ERROR_OBJECT_CREATION_FAILURE,
+ _("Caller did not specify D-Bus path for object"));
+ return FALSE;
}
- return object;
-}
-
-static void
-constructed (GObject *object)
-{
- NMObject *self = NM_OBJECT (object);
-
- if (G_OBJECT_CLASS (nm_object_parent_class)->constructed)
- G_OBJECT_CLASS (nm_object_parent_class)->constructed (object);
-
NM_OBJECT_GET_CLASS (self)->init_dbus (self);
+
+ return TRUE;
}
static void
static gboolean
init_sync (GInitable *initable, GCancellable *cancellable, GError **error)
{
- NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (initable);
+ NMObject *self = NM_OBJECT (initable);
+ NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
+
+ if (!priv->connection) {
+ priv->connection = _nm_dbus_new_connection (error);
+ if (!priv->connection)
+ return FALSE;
+ }
+ if (!init_common (self, error))
+ return FALSE;
if (priv->bus_proxy) {
if (!dbus_g_proxy_call (priv->bus_proxy,
return FALSE;
}
- priv->inited = TRUE;
- return _nm_object_reload_properties (NM_OBJECT (initable), error);
+ return _nm_object_reload_properties (self, error);
}
/* Takes ownership of @error */
GSimpleAsyncResult *simple = user_data;
GError *error = NULL;
- NM_OBJECT_GET_PRIVATE (object)->inited = TRUE;
if (!_nm_object_reload_properties_finish (NM_OBJECT (object), result, &error))
g_assert (error);
init_async_complete (simple, error);
G_TYPE_BOOLEAN, &priv->nm_running,
G_TYPE_INVALID)) {
init_async_complete (simple, error);
- } else if (!priv->nm_running) {
- priv->inited = TRUE;
+ } else if (!priv->nm_running)
init_async_complete (simple, NULL);
- } else
+ else
_nm_object_reload_properties_async (self, init_async_got_properties, simple);
/* g_async_result_get_source_object() adds a ref */
GCancellable *cancellable, GAsyncReadyCallback callback,
gpointer user_data)
{
- NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (initable);
+ NMObject *self = NM_OBJECT (initable);
+ NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
GSimpleAsyncResult *simple;
+ GError *error = NULL;
simple = g_simple_async_result_new (G_OBJECT (initable), callback, user_data, init_async);
- if (_nm_object_is_connection_private (NM_OBJECT (initable)))
- _nm_object_reload_properties_async (NM_OBJECT (initable), init_async_got_properties, simple);
+ if (!priv->connection) {
+ priv->connection = _nm_dbus_new_connection (&error);
+ if (!priv->connection) {
+ g_simple_async_result_take_error (simple, error);
+ g_simple_async_result_complete_in_idle (simple);
+ g_object_unref (simple);
+ return;
+ }
+ }
+ if (!init_common (self, &error)) {
+ g_simple_async_result_take_error (simple, error);
+ g_simple_async_result_complete_in_idle (simple);
+ g_object_unref (simple);
+ return;
+ }
+
+ if (_nm_object_is_connection_private (self))
+ _nm_object_reload_properties_async (self, init_async_got_properties, simple);
else {
/* Check if NM is running */
dbus_g_proxy_begin_call (priv->bus_proxy, "NameHasOwner",
case PROP_DBUS_CONNECTION:
/* Construct only */
priv->connection = g_value_dup_boxed (value);
- if (!priv->connection)
- priv->connection = _nm_dbus_new_connection (NULL);
break;
case PROP_DBUS_PATH:
/* Construct only */
g_type_class_add_private (nm_object_class, sizeof (NMObjectPrivate));
/* virtual methods */
- object_class->constructor = constructor;
- object_class->constructed = constructed;
object_class->set_property = set_property;
object_class->get_property = get_property;
object_class->dispose = dispose;
if (!g_initable_init (G_INITABLE (object), NULL, &error)) {
dbgmsg ("Could not create object for %s: %s", path, error->message);
g_error_free (error);
- g_clear_object (&object);
}
return object;
}
static void
-async_inited (GObject *source, GAsyncResult *result, gpointer user_data)
+async_inited (GObject *object, GAsyncResult *result, gpointer user_data)
{
NMObjectTypeAsyncData *async_data = user_data;
- GObject *object = G_OBJECT (source);
GError *error = NULL;
if (!g_async_initable_init_finish (G_ASYNC_INITABLE (object), result, &error)) {
nm_object_or_connection_get_path (object),
error->message);
g_error_free (error);
- g_clear_object (&object);
+ object = NULL;
}
create_async_complete (object, async_data);
NM_OBJECT_DBUS_CONNECTION, async_data->connection,
NM_OBJECT_DBUS_PATH, async_data->path,
NULL);
- g_warn_if_fail (object != NULL);
if (NM_IS_OBJECT (object))
_nm_object_cache_add (NM_OBJECT (object));
g_async_initable_init_async (G_ASYNC_INITABLE (object), G_PRIORITY_DEFAULT,
}
-void
-_nm_object_ensure_inited (NMObject *object)
-{
- NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (object);
- GError *error = NULL;
-
- if (!priv->inited) {
- if (!g_initable_init (G_INITABLE (object), NULL, &error)) {
- dbgmsg ("Could not initialize %s %s: %s",
- G_OBJECT_TYPE_NAME (object),
- priv->path,
- error->message);
- g_error_free (error);
-
- /* Only warn once */
- priv->inited = TRUE;
- }
- }
-}
-
void
_nm_object_reload_property (NMObject *object,
const char *interface,
gboolean proxy_is_destroyed;
GSList *calls;
- gboolean inited;
gboolean unsaved;
gboolean visible;
/****************************************************************/
-static void
-_nm_remote_connection_ensure_inited (NMRemoteConnection *self)
-{
- NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
- GError *error = NULL;
-
- if (!priv->inited) {
- if (!g_initable_init (G_INITABLE (self), NULL, &error)) {
- /* Don't warn when the call times out because the settings service can't
- * be activated or whatever.
- */
- if (!g_error_matches (error, DBUS_GERROR, DBUS_GERROR_NO_REPLY)) {
- g_warning ("%s: (NMRemoteConnection) error initializing: %s\n",
- __func__, error->message);
- }
- g_error_free (error);
- }
- priv->inited = TRUE;
- }
-}
-
-/****************************************************************/
-
static void
remote_call_dbus_cb (DBusGProxy *proxy, DBusGProxyCall *proxy_call, gpointer user_data)
{
{
g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), FALSE);
- _nm_remote_connection_ensure_inited (connection);
return NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->unsaved;
}
/****************************************************************/
static void
-constructed (GObject *object)
+init_common (NMRemoteConnection *self)
{
- NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (object);
-
- G_OBJECT_CLASS (nm_remote_connection_parent_class)->constructed (object);
+ NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
g_assert (priv->bus);
- g_assert (nm_connection_get_path (NM_CONNECTION (object)));
+ g_assert (nm_connection_get_path (NM_CONNECTION (self)));
priv->proxy = _nm_dbus_new_proxy_for_connection (priv->bus,
- nm_connection_get_path (NM_CONNECTION (object)),
+ nm_connection_get_path (NM_CONNECTION (self)),
NM_DBUS_INTERFACE_SETTINGS_CONNECTION);
g_assert (priv->proxy);
dbus_g_proxy_set_default_timeout (priv->proxy, G_MAXINT);
dbus_g_proxy_add_signal (priv->proxy, "Updated", G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (priv->proxy, "Updated", G_CALLBACK (updated_cb), object, NULL);
+ dbus_g_proxy_connect_signal (priv->proxy, "Updated", G_CALLBACK (updated_cb), self, NULL);
dbus_g_proxy_add_signal (priv->proxy, "Removed", G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (priv->proxy, "Removed", G_CALLBACK (removed_cb), object, NULL);
+ dbus_g_proxy_connect_signal (priv->proxy, "Removed", G_CALLBACK (removed_cb), self, NULL);
- g_signal_connect (priv->proxy, "destroy", G_CALLBACK (proxy_destroy_cb), object);
+ g_signal_connect (priv->proxy, "destroy", G_CALLBACK (proxy_destroy_cb), self);
/* Monitor properties */
dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__BOXED,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->proxy, "PropertiesChanged",
G_CALLBACK (properties_changed_cb),
- object,
+ self,
NULL);
priv->props_proxy = _nm_dbus_new_proxy_for_connection (priv->bus,
- nm_connection_get_path (NM_CONNECTION (object)),
+ nm_connection_get_path (NM_CONNECTION (self)),
DBUS_INTERFACE_PROPERTIES);
g_assert (priv->props_proxy);
}
static gboolean
init_sync (GInitable *initable, GCancellable *cancellable, GError **error)
{
+ NMRemoteConnection *self = NM_REMOTE_CONNECTION (initable);
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (initable);
GHashTable *hash;
+ init_common (self);
+
if (!dbus_g_proxy_call (priv->proxy, "GetSettings", error,
G_TYPE_INVALID,
DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, &hash,
G_TYPE_INVALID))
return FALSE;
priv->visible = TRUE;
- replace_settings (NM_REMOTE_CONNECTION (initable), hash);
+ replace_settings (self, hash);
g_hash_table_destroy (hash);
/* Get properties */
DBUS_TYPE_G_MAP_OF_VARIANT, &hash,
G_TYPE_INVALID))
return FALSE;
- properties_changed_cb (priv->props_proxy, hash, NM_REMOTE_CONNECTION (initable));
+ properties_changed_cb (priv->props_proxy, hash, self);
g_hash_table_destroy (hash);
return TRUE;
{
if (error)
g_simple_async_result_take_error (init_data->result, error);
- else {
+ else
g_simple_async_result_set_op_res_gboolean (init_data->result, TRUE);
- NM_REMOTE_CONNECTION_GET_PRIVATE (init_data->connection)->inited = TRUE;
- }
g_simple_async_result_complete (init_data->result);
g_object_unref (init_data->result);
NMRemoteConnectionInitData *init_data;
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (initable);
-
init_data = g_slice_new0 (NMRemoteConnectionInitData);
init_data->connection = NM_REMOTE_CONNECTION (initable);
init_data->result = g_simple_async_result_new (G_OBJECT (initable), callback,
user_data, init_async);
+ init_common (init_data->connection);
+
dbus_g_proxy_begin_call (priv->proxy, "GetSettings",
init_get_settings_cb, init_data, NULL,
G_TYPE_INVALID);
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
- _nm_remote_connection_ensure_inited (NM_REMOTE_CONNECTION (object));
-
switch (prop_id) {
case PROP_UNSAVED:
g_value_set_boolean (value, NM_REMOTE_CONNECTION_GET_PRIVATE (object)->unsaved);
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->dispose = dispose;
- object_class->constructed = constructed;
/* Properties */
/**
typedef struct {
DBusGConnection *bus;
gboolean private_bus;
- gboolean inited;
DBusGProxy *proxy;
GHashTable *connections;
/**********************************************************************/
-static void
-_nm_remote_settings_ensure_inited (NMRemoteSettings *self)
-{
- NMRemoteSettingsPrivate *priv = NM_REMOTE_SETTINGS_GET_PRIVATE (self);
- GError *error = NULL;
-
- if (!priv->inited) {
- if (!g_initable_init (G_INITABLE (self), NULL, &error)) {
- /* Don't warn when the call times out because the settings service can't
- * be activated or whatever.
- */
- if (!g_error_matches (error, DBUS_GERROR, DBUS_GERROR_NO_REPLY)) {
- g_warning ("%s: (NMRemoteSettings) error initializing: %s\n",
- __func__, error->message);
- }
- g_error_free (error);
- }
- priv->inited = TRUE;
- }
-}
-
-/**********************************************************************/
-
typedef struct {
NMRemoteSettings *self;
NMRemoteSettingsAddConnectionFunc callback;
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (priv->service_running) {
GHashTableIter iter;
NMConnection *candidate;
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
return priv->service_running ? g_hash_table_lookup (priv->connections, path) : NULL;
}
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (priv->service_running) {
g_hash_table_iter_init (&iter, priv->connections);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &candidate)) {
NM_REMOTE_CONNECTION_BUS, priv->bus,
NM_CONNECTION_PATH, path,
NULL);
- if (connection) {
- g_async_initable_init_async (G_ASYNC_INITABLE (connection),
- G_PRIORITY_DEFAULT, NULL,
- connection_inited, self);
-
- /* Add the connection to the pending table to wait for it to retrieve
- * it's settings asynchronously over D-Bus. The connection isn't
- * really valid until it has all its settings, so hide it until it does.
- */
- move_connection (self, connection, NULL, priv->pending);
- g_object_unref (connection); /* move_connection() takes a ref */
- }
+ g_async_initable_init_async (G_ASYNC_INITABLE (connection),
+ G_PRIORITY_DEFAULT, NULL,
+ connection_inited, self);
+
+ /* Add the connection to the pending table to wait for it to retrieve
+ * it's settings asynchronously over D-Bus. The connection isn't
+ * really valid until it has all its settings, so hide it until it does.
+ */
+ move_connection (self, connection, NULL, priv->pending);
+ g_object_unref (connection); /* move_connection() takes a ref */
+
return connection;
}
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (priv->service_running) {
g_hash_table_iter_init (&iter, priv->connections);
while (g_hash_table_iter_next (&iter, NULL, &value))
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (!priv->service_running)
return FALSE;
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (!priv->service_running)
return FALSE;
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (!priv->service_running) {
g_set_error_literal (error, NM_REMOTE_SETTINGS_ERROR,
NM_REMOTE_SETTINGS_ERROR_SERVICE_UNAVAILABLE,
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (!priv->service_running) {
g_set_error_literal (error, NM_REMOTE_SETTINGS_ERROR,
NM_REMOTE_SETTINGS_ERROR_SERVICE_UNAVAILABLE,
priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
- _nm_remote_settings_ensure_inited (settings);
-
if (!priv->service_running)
return FALSE;
/**
* nm_remote_settings_new:
- * @bus: (allow-none): a valid and connected D-Bus connection
+ * @cancellable: a #GCancellable, or %NULL
+ * @error: location for a #GError, or %NULL
*
* Creates a new object representing the remote settings service.
*
* Returns: the new remote settings object on success, or %NULL on failure
**/
NMRemoteSettings *
-nm_remote_settings_new (DBusGConnection *bus)
+nm_remote_settings_new (GCancellable *cancellable,
+ GError **error)
{
- NMRemoteSettings *self;
-
- self = g_object_new (NM_TYPE_REMOTE_SETTINGS, NM_REMOTE_SETTINGS_BUS, bus, NULL);
- _nm_remote_settings_ensure_inited (self);
- return self;
+ return g_initable_new (NM_TYPE_REMOTE_SETTINGS, cancellable, error,
+ NULL);
}
static void
GSimpleAsyncResult *simple = user_data;
GError *error = NULL;
- if (!g_async_initable_init_finish (G_ASYNC_INITABLE (source), result, &error))
+ if (!g_async_initable_new_finish (G_ASYNC_INITABLE (source), result, &error))
g_simple_async_result_take_error (simple, error);
else
g_simple_async_result_set_op_res_gpointer (simple, source, g_object_unref);
/**
* nm_remote_settings_new_async:
- * @bus: (allow-none): a valid and connected D-Bus connection
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to call when the settings object is created
* @user_data: data for @callback
* result.
**/
void
-nm_remote_settings_new_async (DBusGConnection *bus, GCancellable *cancellable,
+nm_remote_settings_new_async (GCancellable *cancellable,
GAsyncReadyCallback callback, gpointer user_data)
{
- NMRemoteSettings *self;
GSimpleAsyncResult *simple;
simple = g_simple_async_result_new (NULL, callback, user_data, nm_remote_settings_new_async);
- self = g_object_new (NM_TYPE_REMOTE_SETTINGS,
- NM_REMOTE_SETTINGS_BUS, bus,
- NULL);
- g_async_initable_init_async (G_ASYNC_INITABLE (self), G_PRIORITY_DEFAULT,
- cancellable, remote_settings_inited, simple);
+ g_async_initable_new_async (NM_TYPE_REMOTE_SETTINGS, G_PRIORITY_DEFAULT, cancellable,
+ remote_settings_inited, simple,
+ NULL);
}
/**
}
static void
-constructed (GObject *object)
+init_common (NMRemoteSettings *self)
{
- NMRemoteSettingsPrivate *priv;
-
- priv = NM_REMOTE_SETTINGS_GET_PRIVATE (object);
+ NMRemoteSettingsPrivate *priv = NM_REMOTE_SETTINGS_GET_PRIVATE (self);
if (priv->private_bus == FALSE) {
/* D-Bus proxy for clearing connections on NameOwnerChanged */
dbus_g_proxy_connect_signal (priv->dbus_proxy,
"NameOwnerChanged",
G_CALLBACK (name_owner_changed),
- object, NULL);
+ self, NULL);
}
priv->proxy = _nm_dbus_new_proxy_for_connection (priv->bus,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->proxy, "NewConnection",
G_CALLBACK (new_connection_cb),
- object,
+ self,
NULL);
/* D-Bus properties proxy */
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->proxy, "PropertiesChanged",
G_CALLBACK (properties_changed_cb),
- object,
+ self,
NULL);
}
NMRemoteSettingsPrivate *priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
GHashTable *props;
+ init_common (settings);
+
if (priv->private_bus == FALSE) {
if (!dbus_g_proxy_call (priv->dbus_proxy, "NameHasOwner", error,
G_TYPE_STRING, NM_DBUS_SERVICE,
static void
init_async_complete (NMRemoteSettingsInitData *init_data)
{
- NMRemoteSettingsPrivate *priv = NM_REMOTE_SETTINGS_GET_PRIVATE (init_data->settings);
-
- priv->inited = TRUE;
-
g_simple_async_result_complete (init_data->result);
g_object_unref (init_data->result);
g_slice_free (NMRemoteSettingsInitData, init_data);
init_data->result = g_simple_async_result_new (G_OBJECT (initable), callback,
user_data, init_async);
+ init_common (init_data->settings);
+
if (priv->private_bus)
init_get_properties (init_data);
else {
{
NMRemoteSettingsPrivate *priv = NM_REMOTE_SETTINGS_GET_PRIVATE (object);
- _nm_remote_settings_ensure_inited (NM_REMOTE_SETTINGS (object));
-
switch (prop_id) {
case PROP_BUS:
g_value_set_boxed (value, priv->bus);
g_type_class_add_private (class, sizeof (NMRemoteSettingsPrivate));
/* Virtual methods */
- object_class->constructed = constructed;
object_class->set_property = set_property;
object_class->get_property = get_property;
object_class->dispose = dispose;
#define NM_REMOTE_SETTINGS_H
#include <gio/gio.h>
-#include <dbus/dbus-glib.h>
#include <nm-connection.h>
#include <nm-remote-connection.h>
GType nm_remote_settings_get_type (void);
-NMRemoteSettings *nm_remote_settings_new (DBusGConnection *bus);
+NMRemoteSettings *nm_remote_settings_new (GCancellable *cancellable,
+ GError **error);
-void nm_remote_settings_new_async (DBusGConnection *bus,
- GCancellable *cancellable,
+void nm_remote_settings_new_async (GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
NMRemoteSettings *nm_remote_settings_new_finish (GAsyncResult *result,
priv = NM_VPN_CONNECTION_GET_PRIVATE (vpn);
- /* We need to update vpn_state first in case it's unknown. */
- _nm_object_ensure_inited (NM_OBJECT (vpn));
-
if (priv->vpn_state != NM_VPN_CONNECTION_STATE_ACTIVATED)
return NULL;
{
g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), NM_VPN_CONNECTION_STATE_UNKNOWN);
- _nm_object_ensure_inited (NM_OBJECT (vpn));
return NM_VPN_CONNECTION_GET_PRIVATE (vpn)->vpn_state;
}
{
NMVpnConnection *self = NM_VPN_CONNECTION (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_VPN_STATE:
g_value_set_uint (value, nm_vpn_connection_get_vpn_state (self));
*/
#include <signal.h>
+
+#include <glib/gi18n.h>
+#include <gio/gio.h>
+
#include "nm-glib-compat.h"
#include "nm-vpn-plugin.h"
#include "nm-vpn-enum-types.h"
#define NM_VPN_PLUGIN_QUIT_TIMER 20
-G_DEFINE_ABSTRACT_TYPE (NMVpnPlugin, nm_vpn_plugin, G_TYPE_OBJECT)
+static void nm_vpn_plugin_initable_iface_init (GInitableIface *iface);
+
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (NMVpnPlugin, nm_vpn_plugin, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE, nm_vpn_plugin_initable_iface_init);
+ )
typedef struct {
NMVpnServiceState state;
NULL);
}
-static GObject *
-constructor (GType type,
- guint n_construct_params,
- GObjectConstructParam *construct_params)
+static gboolean
+init_sync (GInitable *initable, GCancellable *cancellable, GError **error)
{
- GObject *object;
+ NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (initable);
NMVpnPlugin *plugin;
- NMVpnPluginPrivate *priv;
DBusGConnection *connection;
DBusGProxy *proxy;
guint request_name_result;
- GError *err = NULL;
- object = G_OBJECT_CLASS (nm_vpn_plugin_parent_class)->constructor (type,
- n_construct_params,
- construct_params);
- if (!object)
- return NULL;
-
- priv = NM_VPN_PLUGIN_GET_PRIVATE (object);
- if (!priv->dbus_service_name)
- goto err;
+ if (!priv->dbus_service_name) {
+ g_set_error_literal (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
+ _("No service name specified"));
+ return FALSE;
+ }
- connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err);
+ connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, error);
if (!connection)
- goto err;
+ return FALSE;
proxy = dbus_g_proxy_new_for_name (connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus");
- if (!dbus_g_proxy_call (proxy, "RequestName", &err,
+ if (!dbus_g_proxy_call (proxy, "RequestName", error,
G_TYPE_STRING, priv->dbus_service_name,
G_TYPE_UINT, 0,
G_TYPE_INVALID,
G_TYPE_UINT, &request_name_result,
G_TYPE_INVALID)) {
g_object_unref (proxy);
- goto err;
+ return FALSE;
}
-
g_object_unref (proxy);
dbus_g_connection_register_g_object (connection,
NM_VPN_DBUS_PLUGIN_PATH,
- object);
+ G_OBJECT (initable));
- plugin = NM_VPN_PLUGIN (object);
+ plugin = NM_VPN_PLUGIN (initable);
nm_vpn_plugin_set_connection (plugin, connection);
nm_vpn_plugin_set_state (plugin, NM_VPN_SERVICE_STATE_INIT);
- return object;
-
- err:
- if (err) {
- g_warning ("Failed to initialize VPN plugin: %s", err->message);
- g_error_free (err);
- }
-
- if (object)
- g_object_unref (object);
-
- return NULL;
+ return TRUE;
}
static void
switch (prop_id) {
case PROP_DBUS_SERVICE_NAME:
/* Construct-only */
- priv->dbus_service_name = g_strdup (g_value_get_string (value));
+ priv->dbus_service_name = g_value_dup_string (value);
break;
case PROP_STATE:
nm_vpn_plugin_set_state (NM_VPN_PLUGIN (object),
&dbus_glib_nm_vpn_plugin_object_info);
/* virtual methods */
- object_class->constructor = constructor;
object_class->set_property = set_property;
object_class->get_property = get_property;
object_class->dispose = dispose;
setup_unix_signal_handler ();
}
+
+static void
+nm_vpn_plugin_initable_iface_init (GInitableIface *iface)
+{
+ iface->init = init_sync;
+}
{
g_return_val_if_fail (NM_IS_WIMAX_NSP (nsp), NULL);
- _nm_object_ensure_inited (NM_OBJECT (nsp));
return NM_WIMAX_NSP_GET_PRIVATE (nsp)->name;
}
{
g_return_val_if_fail (NM_IS_WIMAX_NSP (nsp), 0);
- _nm_object_ensure_inited (NM_OBJECT (nsp));
return NM_WIMAX_NSP_GET_PRIVATE (nsp)->signal_quality;
}
{
g_return_val_if_fail (NM_IS_WIMAX_NSP (nsp), NM_WIMAX_NSP_NETWORK_TYPE_UNKNOWN);
- _nm_object_ensure_inited (NM_OBJECT (nsp));
return NM_WIMAX_NSP_GET_PRIVATE (nsp)->network_type;
}
{
NMWimaxNsp *nsp = NM_WIMAX_NSP (object);
- _nm_object_ensure_inited (NM_OBJECT (object));
-
switch (prop_id) {
case PROP_NAME:
g_value_set_string (value, nm_wimax_nsp_get_name (nsp));
guint quit_id;
int running_changed = 0;
gboolean running;
+ GError *error = NULL;
loop = g_main_loop_new (NULL, FALSE);
/* Now kill the test service. */
nm_test_service_cleanup (sinfo);
- settings2 = nm_remote_settings_new (bus);
+ settings2 = g_initable_new (NM_TYPE_REMOTE_SETTINGS, NULL, &error,
+ NM_REMOTE_SETTINGS_BUS, bus,
+ NULL);
+ g_assert_no_error (error);
+ g_assert (settings != NULL);
/* settings2 should know that NM is running, but the previously-created
* settings hasn't gotten the news yet.
sinfo = nm_test_service_init ();
- settings = nm_remote_settings_new (bus);
+ settings = g_initable_new (NM_TYPE_REMOTE_SETTINGS, NULL, &error,
+ NM_REMOTE_SETTINGS_BUS, bus,
+ NULL);
+ g_assert_no_error (error);
g_assert (settings != NULL);
/* FIXME: these tests assume that they get run in order, but g_test_run()
projects / NetworkManager.git / commitdiff