fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2025-12-20 23:20:06 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/libnm-glib/nm-remote-connection.c

524 lines
17 KiB
C
Raw Normal View History

libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/*
* libnm_glib -- Access network status & information from glib applications
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301 USA.
*
* Copyright (C) 2007 - 2008 Novell, Inc.
secrets: simplify GetSecrets call flow The Settings.Connection interface is now only provided by NetworkManager itself since there is only one settings service. NM can validate requests for secrets internally and thus there's no need to lock down GetSecrets using a separate D-Bus interface, since PolicyKit provides that functionality on systems where this is desirable (ie multi-user). Single-user systems that do not have PolicyKit will inherently trust the user already, or if not D-Bus auth is flexible enough to lock down the GetSecrets method individually even if it's not on a separate D-Bus interface. Second, since only clients like connection editors or applets will be calling the GetSecrets method, there's no need for 'hints' or 'request_new' arguments here since this method should never trigger an interactive secrets request. Only NM should send those requests when it knows it needs to ask the user, either during connection or after validating the incoming GetSecrets request. A connection editor type application should never be able to trigger the normal "What's your passphrase" dialog thats provided by the secret agent for that user's session.
2011-01-26 10:17:07 -06:00
* Copyright (C) 2007 - 2011 Red Hat, Inc.
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
*/
#include <string.h>
#include <NetworkManager.h>
#include <nm-utils.h>
#include <nm-setting-connection.h>
#include "nm-remote-connection.h"
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
#include "nm-remote-connection-private.h"
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
#include "nm-dbus-glib-types.h"
core: rename NMSysconfigConnection -> NMSettingsConnection
2011-01-26 11:38:12 -06:00
#include "nm-settings-connection-bindings.h"
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
#define NM_REMOTE_CONNECTION_BUS "bus"
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
G_DEFINE_TYPE (NMRemoteConnection, nm_remote_connection, NM_TYPE_CONNECTION)
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
enum {
PROP_0,
PROP_BUS,
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
PROP_INIT_RESULT,
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
LAST_PROP
};
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
enum {
UPDATED,
REMOVED,
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
VISIBLE,
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
typedef struct {
NMRemoteConnection *self;
DBusGProxyCall *call;
GFunc callback;
gpointer user_data;
} RemoteCall;
typedef struct {
DBusGConnection *bus;
DBusGProxy *proxy;
GSList *calls;
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
NMRemoteConnectionInitResult init_result;
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
gboolean visible;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
gboolean disposed;
} NMRemoteConnectionPrivate;
#define NM_REMOTE_CONNECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_REMOTE_CONNECTION, NMRemoteConnectionPrivate))
/****************************************************************/
static void
remote_call_complete (NMRemoteConnection *self, RemoteCall *call)
{
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
priv->calls = g_slist_remove (priv->calls, call);
/* Don't need to cancel it since this function should only be called from
* the dispose handler (where the proxy will be destroyed immediately after)
* or from the call's completion callback.
*/
memset (call, 0, sizeof (RemoteCall));
g_free (call);
}
static void
update_cb (DBusGProxy *proxy, GError *error, gpointer user_data)
{
RemoteCall *call = user_data;
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
NMRemoteConnectionCommitFunc func = (NMRemoteConnectionCommitFunc) call->callback;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
(*func)(call->self, error, call->user_data);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
remote_call_complete (call->self, call);
}
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
/**
* nm_remote_connection_commit_changes:
* @connection: the #NMRemoteConnection
introspection: add GObject introspection support (bgo #637032) Add the necessary annotations (the mininum required, that is those on return values. NULL parameters or container types may require more), and the Autotools stuff to get a NetworkManager GIR for libnm-util and a NMClient for libnm-glib.
2011-01-21 14:46:09 -06:00
* @callback: (scope async): a function to be called when the commit completes
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
* @user_data: caller-specific data to be passed to @callback
*
* Save any local changes to the settings and properties of this connection and
* save them in the settings service.
**/
void
nm_remote_connection_commit_changes (NMRemoteConnection *self,
NMRemoteConnectionCommitFunc callback,
gpointer user_data)
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
{
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
NMRemoteConnectionPrivate *priv;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
GHashTable *settings = NULL;
RemoteCall *call;
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
g_return_if_fail (self != NULL);
g_return_if_fail (NM_IS_REMOTE_CONNECTION (self));
g_return_if_fail (callback != NULL);
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
call = g_malloc0 (sizeof (RemoteCall));
call->self = self;
call->callback = (GFunc) callback;
call->user_data = user_data;
libnm-util: add 'flags' argument to nm_connection_to_hash() and nm_setting_to_hash() Simplifies code internally, and makes it easier for clients as well in some cases where they want to control what ends up in the resulting hash and what does not.
2011-01-26 14:14:37 -06:00
settings = nm_connection_to_hash (NM_CONNECTION (self), NM_SETTING_HASH_FLAG_ALL);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
NetworkMangerSettings -> NetworkManager.Settings Just for consistency, make settings related stuff live under the org.freedesktop.NetworkManager namespace, rather than its own org.freedesktop.NetworkManagerSettings namespace. Renames are done for DBus interface names, DBus object paths, and polkit actions.
2010-08-07 01:07:44 -04:00
call->call = org_freedesktop_NetworkManager_Settings_Connection_update_async (priv->proxy,
settings,
update_cb,
call);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
g_assert (call->call);
priv->calls = g_slist_append (priv->calls, call);
g_hash_table_destroy (settings);
}
static void
delete_cb (DBusGProxy *proxy, GError *error, gpointer user_data)
{
RemoteCall *call = user_data;
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
NMRemoteConnectionDeleteFunc func = (NMRemoteConnectionDeleteFunc) call->callback;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
libnm-glib: allow calling nm_remote_connection_delete() without a callback
2011-03-16 15:36:36 -05:00
if (func != NULL)
(*func)(call->self, error, call->user_data);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
remote_call_complete (call->self, call);
}
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
/**
* nm_remote_connection_delete:
* @connection: the #NMRemoteConnection
libnm-glib: allow calling nm_remote_connection_delete() without a callback
2011-03-16 15:36:36 -05:00
* @callback: (scope async allow-none): a function to be called when the delete completes
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
* @user_data: caller-specific data to be passed to @callback
*
* Delete the connection.
**/
void
nm_remote_connection_delete (NMRemoteConnection *self,
NMRemoteConnectionDeleteFunc callback,
gpointer user_data)
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
{
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
NMRemoteConnectionPrivate *priv;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
RemoteCall *call;
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
g_return_if_fail (self != NULL);
g_return_if_fail (NM_IS_REMOTE_CONNECTION (self));
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
call = g_malloc0 (sizeof (RemoteCall));
call->self = self;
call->callback = (GFunc) callback;
call->user_data = user_data;
NetworkMangerSettings -> NetworkManager.Settings Just for consistency, make settings related stuff live under the org.freedesktop.NetworkManager namespace, rather than its own org.freedesktop.NetworkManagerSettings namespace. Renames are done for DBus interface names, DBus object paths, and polkit actions.
2010-08-07 01:07:44 -04:00
call->call = org_freedesktop_NetworkManager_Settings_Connection_delete_async (priv->proxy,
delete_cb,
call);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
g_assert (call->call);
priv->calls = g_slist_append (priv->calls, call);
}
static void
get_secrets_cb (DBusGProxy *proxy, GHashTable *secrets, GError *error, gpointer user_data)
{
RemoteCall *call = user_data;
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
NMRemoteConnectionGetSecretsFunc func = (NMRemoteConnectionGetSecretsFunc) call->callback;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
(*func)(call->self, error ? NULL : secrets, error, call->user_data);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
remote_call_complete (call->self, call);
}
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
/**
* nm_remote_connection_get_secrets:
* @connection: the #NMRemoteConnection
* @setting_name: the #NMSetting object name to get secrets for
introspection: add GObject introspection support (bgo #637032) Add the necessary annotations (the mininum required, that is those on return values. NULL parameters or container types may require more), and the Autotools stuff to get a NetworkManager GIR for libnm-util and a NMClient for libnm-glib.
2011-01-21 14:46:09 -06:00
* @callback: (scope async): a function to be called when the update completes
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
* @user_data: caller-specific data to be passed to @callback
*
* Request the connection's secrets.
**/
void
nm_remote_connection_get_secrets (NMRemoteConnection *self,
const char *setting_name,
NMRemoteConnectionGetSecretsFunc callback,
gpointer user_data)
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
{
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
NMRemoteConnectionPrivate *priv;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
RemoteCall *call;
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
g_return_if_fail (self != NULL);
g_return_if_fail (NM_IS_REMOTE_CONNECTION (self));
g_return_if_fail (callback != NULL);
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
call = g_malloc0 (sizeof (RemoteCall));
call->self = self;
call->callback = (GFunc) callback;
call->user_data = user_data;
secrets: simplify GetSecrets call flow The Settings.Connection interface is now only provided by NetworkManager itself since there is only one settings service. NM can validate requests for secrets internally and thus there's no need to lock down GetSecrets using a separate D-Bus interface, since PolicyKit provides that functionality on systems where this is desirable (ie multi-user). Single-user systems that do not have PolicyKit will inherently trust the user already, or if not D-Bus auth is flexible enough to lock down the GetSecrets method individually even if it's not on a separate D-Bus interface. Second, since only clients like connection editors or applets will be calling the GetSecrets method, there's no need for 'hints' or 'request_new' arguments here since this method should never trigger an interactive secrets request. Only NM should send those requests when it knows it needs to ask the user, either during connection or after validating the incoming GetSecrets request. A connection editor type application should never be able to trigger the normal "What's your passphrase" dialog thats provided by the secret agent for that user's session.
2011-01-26 10:17:07 -06:00
call->call = org_freedesktop_NetworkManager_Settings_Connection_get_secrets_async (priv->proxy,
setting_name,
get_secrets_cb,
call);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
g_assert (call->call);
priv->calls = g_slist_append (priv->calls, call);
}
/****************************************************************/
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
static void
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
replace_settings (NMRemoteConnection *self, GHashTable *new_settings)
{
GError *error = NULL;
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
if (nm_connection_replace_settings (NM_CONNECTION (self), new_settings, &error))
g_signal_emit (self, signals[UPDATED], 0, new_settings);
else {
libnm-*: remove user settings support Remove code related to "connection scope" and such. Later, we will also do lots of code flattening and simplification that's possible now that user settings are gone.
2010-07-28 02:07:53 -04:00
g_warning ("%s: error updating connection %s settings: (%d) %s",
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
__func__,
nm_connection_get_path (NM_CONNECTION (self)),
error ? error->code : -1,
(error && error->message) ? error->message : "(unknown)");
g_clear_error (&error);
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
g_signal_emit (self, signals[REMOVED], 0);
}
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
}
static void
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
init_get_settings_cb (DBusGProxy *proxy,
GHashTable *new_settings,
GError *error,
gpointer user_data)
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
{
NMRemoteConnection *self = user_data;
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
if (error) {
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
/* Connection doesn't exist, or isn't visible to this user */
libnm-glib: handle initially invisible connections correctly Don't delete them if we don't have permission for them, since we may get permission for them later via Update. But to listen for Update we need the connection around.
2011-02-12 22:00:30 -06:00
if (dbus_g_error_has_name (error, "org.freedesktop.NetworkManager.Settings.PermissionDenied"))
priv->init_result = NM_REMOTE_CONNECTION_INIT_RESULT_INVISIBLE;
else
priv->init_result = NM_REMOTE_CONNECTION_INIT_RESULT_ERROR;
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
g_object_notify (G_OBJECT (self), NM_REMOTE_CONNECTION_INIT_RESULT);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
} else {
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
priv->visible = TRUE;
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
replace_settings (self, new_settings);
g_hash_table_destroy (new_settings);
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
priv->init_result = NM_REMOTE_CONNECTION_INIT_RESULT_SUCCESS;
g_object_notify (G_OBJECT (self), NM_REMOTE_CONNECTION_INIT_RESULT);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
}
}
static void
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
updated_get_settings_cb (DBusGProxy *proxy,
GHashTable *new_settings,
GError *error,
gpointer user_data)
{
NMRemoteConnection *self = user_data;
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
if (error) {
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
GHashTable *hash;
/* Connection is no longer visible to this user. Let the settings
* service handle this via 'visible'. The settings service will emit
* the "removed" signal for us since it handles the lifetime of this
* object.
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
*/
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
hash = g_hash_table_new (g_str_hash, g_str_equal);
nm_connection_replace_settings (NM_CONNECTION (self), hash, NULL);
g_hash_table_destroy (hash);
priv->visible = FALSE;
g_signal_emit (self, signals[VISIBLE], 0, FALSE);
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
} else {
replace_settings (self, new_settings);
g_hash_table_destroy (new_settings);
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
/* Settings service will handle announcing the connection to clients */
if (priv->visible == FALSE) {
priv->visible = TRUE;
g_signal_emit (self, signals[VISIBLE], 0, TRUE);
}
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
}
}
static void
updated_cb (DBusGProxy *proxy, gpointer user_data)
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
{
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
NMRemoteConnection *self = NM_REMOTE_CONNECTION (user_data);
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
/* The connection got updated; request the replacement settings */
org_freedesktop_NetworkManager_Settings_Connection_get_settings_async (priv->proxy,
updated_get_settings_cb,
self);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
}
static void
removed_cb (DBusGProxy *proxy, gpointer user_data)
{
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
g_signal_emit (G_OBJECT (user_data), signals[REMOVED], 0);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
}
/****************************************************************/
/**
* nm_remote_connection_new:
* @bus: a valid and connected D-Bus connection
* @path: the D-Bus path of the connection as exported by the settings service
*
* Creates a new object representing the remote connection.
*
* Returns: the new remote connection object on success, or %NULL on failure
**/
NMRemoteConnection *
nm_remote_connection_new (DBusGConnection *bus,
const char *path)
{
g_return_val_if_fail (bus != NULL, NULL);
g_return_val_if_fail (path != NULL, NULL);
return (NMRemoteConnection *) g_object_new (NM_TYPE_REMOTE_CONNECTION,
NM_REMOTE_CONNECTION_BUS, bus,
NM_CONNECTION_PATH, path,
NULL);
}
static GObject *
constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
NMRemoteConnectionPrivate *priv;
object = G_OBJECT_CLASS (nm_remote_connection_parent_class)->constructor (type, n_construct_params, construct_params);
if (!object)
return NULL;
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (object);
g_assert (priv->bus);
g_assert (nm_connection_get_path (NM_CONNECTION (object)));
priv->proxy = dbus_g_proxy_new_for_name (priv->bus,
DBus: merge NetworkManger{,SystemSettings} Remove the org.freedesktop.NetworkManagerSystemSettings bus name and have everybody talk to org.freedesktop.NetworkManager. Now that we have a single settings service that's embedded in the main daemon, we don't need separate names anymore.
2010-08-06 21:21:24 -04:00
NM_DBUS_SERVICE,
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
nm_connection_get_path (NM_CONNECTION (object)),
NM_DBUS_IFACE_SETTINGS_CONNECTION);
g_assert (priv->proxy);
libnm-glib: use max timeout for settings dbus calls These calls may require authentication, and thus could be in-progress for much longer than the default D-Bus timeout, which is pretty short.
2010-04-25 22:48:10 -07:00
dbus_g_proxy_set_default_timeout (priv->proxy, G_MAXINT);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
dbus_g_proxy_add_signal (priv->proxy, "Updated", G_TYPE_INVALID);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
dbus_g_proxy_connect_signal (priv->proxy, "Updated", G_CALLBACK (updated_cb), object, 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);
NetworkMangerSettings -> NetworkManager.Settings Just for consistency, make settings related stuff live under the org.freedesktop.NetworkManager namespace, rather than its own org.freedesktop.NetworkManagerSettings namespace. Renames are done for DBus interface names, DBus object paths, and polkit actions.
2010-08-07 01:07:44 -04:00
org_freedesktop_NetworkManager_Settings_Connection_get_settings_async (priv->proxy,
libnm-glib: handle visibility changes for updated connections
2010-12-23 09:59:57 -06:00
init_get_settings_cb,
NetworkMangerSettings -> NetworkManager.Settings Just for consistency, make settings related stuff live under the org.freedesktop.NetworkManager namespace, rather than its own org.freedesktop.NetworkManagerSettings namespace. Renames are done for DBus interface names, DBus object paths, and polkit actions.
2010-08-07 01:07:44 -04:00
object);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
return object;
}
static void
nm_remote_connection_init (NMRemoteConnection *self)
{
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (object);
switch (prop_id) {
case PROP_BUS:
/* Construct only */
priv->bus = dbus_g_connection_ref ((DBusGConnection *) g_value_get_boxed (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMRemoteConnection *self = NM_REMOTE_CONNECTION (object);
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
switch (prop_id) {
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
case PROP_INIT_RESULT:
g_value_set_uint (value, priv->init_result);
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
dispose (GObject *object)
{
NMRemoteConnection *self = NM_REMOTE_CONNECTION (object);
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (object);
if (!priv->disposed) {
priv->disposed = TRUE;
while (g_slist_length (priv->calls))
remote_call_complete (self, priv->calls->data);
g_object_unref (priv->proxy);
dbus_g_connection_unref (priv->bus);
}
G_OBJECT_CLASS (nm_remote_connection_parent_class)->dispose (object);
}
static void
nm_remote_connection_class_init (NMRemoteConnectionClass *remote_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (remote_class);
g_type_class_add_private (object_class, sizeof (NMRemoteConnectionPrivate));
/* virtual methods */
object_class->set_property = set_property;
object_class->get_property = get_property;
object_class->dispose = dispose;
object_class->constructor = constructor;
/* Properties */
g_object_class_install_property
(object_class, PROP_BUS,
g_param_spec_boxed (NM_REMOTE_CONNECTION_BUS,
"DBusGConnection",
"DBusGConnection",
DBUS_TYPE_G_CONNECTION,
libnm-glib: don't expose NMRemoteConnetions until they are valid Give them time to get their settings from the remote settings service first, then let subclasses/users/whatever know about them.
2009-08-11 10:33:13 -05:00
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
g_object_class_install_property
(object_class, PROP_INIT_RESULT,
g_param_spec_uint (NM_REMOTE_CONNECTION_INIT_RESULT,
"Initialization result (PRIVATE)",
"Initialization result (PRIVATE)",
NM_REMOTE_CONNECTION_INIT_RESULT_UNKNOWN,
NM_REMOTE_CONNECTION_INIT_RESULT_ERROR,
NM_REMOTE_CONNECTION_INIT_RESULT_UNKNOWN,
G_PARAM_READABLE));
libnm-glib: implement new settings interfaces The old NMExportedConnection was used for both client and server-side classes, which was a mistake and made the code very complicated to follow. Additionally, all PolicyKit operations were synchronous, and PK operations can block for a long time (ie for user input) before returning, so they need to be async. But NMExportedConnection and NMSysconfigConnection didn't allow for async PK ops at all. Use this opportunity to clean up the mess and create GInterfaces that both server and client objects implement, so that the connection editor and applet can operate on generic objects like they did before (using the interfaces) but can perform specific operations (like async PK verification of callers) depending on whether they are local or remote or whatever.
2009-07-23 09:20:52 -04:00
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
/* Signals */
libnm-glib: add signal documentation for NMRemoteConnection
2011-02-21 18:08:41 -06:00
/**
* NMRemoteConnection::updated:
* @connection: a #NMConnection
*
* This signal is emitted when a connection changes, and it is
* still visible to the user.
*/
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
signals[UPDATED] =
g_signal_new (NM_REMOTE_CONNECTION_UPDATED,
G_TYPE_FROM_CLASS (remote_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMRemoteConnectionClass, updated),
NULL, NULL,
introspection: add GObject introspection support (bgo #637032) Add the necessary annotations (the mininum required, that is those on return values. NULL parameters or container types may require more), and the Autotools stuff to get a NetworkManager GIR for libnm-util and a NMClient for libnm-glib.
2011-01-21 14:46:09 -06:00
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
libnm-glib: add signal documentation for NMRemoteConnection
2011-02-21 18:08:41 -06:00
/**
* NMRemoteConnection::removed:
* @connection: a #NMConnection
*
* This signal is emitted when a connection is either deleted or becomes
* invisible to the current user.
*/
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
signals[REMOVED] =
g_signal_new (NM_REMOTE_CONNECTION_REMOVED,
G_TYPE_FROM_CLASS (remote_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMRemoteConnectionClass, removed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
libnm-glib: add signal documentation for NMRemoteConnection
2011-02-21 18:08:41 -06:00
/* Private signal */
libnm-glib: fix connection visibility handling When the connection becomes invisible to a user (ie, the permissions of the connection no longer allow that user to view the connection) then we have to hid the connection from clients. But we can't just dispose of it, because visibility changes are signaled with Update signals on the connection itself, and thus we need to keep the connection around just in case it becomes visible to the user again. But if it's invisible, make sure we clear out the settings since they may have changed.
2011-02-12 21:48:30 -06:00
signals[VISIBLE] =
g_signal_new ("visible",
G_TYPE_FROM_CLASS (remote_class),
G_SIGNAL_RUN_FIRST,
0, NULL, NULL,
g_cclosure_marshal_VOID__BOOLEAN,
G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
remove nm-settings-connection-interface NMSettingsConnectionInterface was created to allow the daemon and NM clients to have common code that handled both system and user connections. It's no longer needed now that user settings services are gone. This concludes the flattening of libnm-glib.
2010-08-05 18:25:15 -04:00
}
Reference in a new issue Copy permalink