fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-01-10 00:00:21 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/src/core/nm-keep-alive.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

502 lines
15 KiB
C
Raw Normal View History

all: update deprecated SPDX license identifiers These SPDX license identifiers are deprecated ([1]). Update them. [1] https://spdx.org/licenses/ sed \ -e '1 s%^/\* SPDX-License-Identifier: \(GPL-2.0\|LGPL-2.1\)+ \*/$%/* SPDX-License-Identifier: \1-or-later */%' \ -e '1,2 s%^\(--\|#\|//\) SPDX-License-Identifier: \(GPL-2.0\|LGPL-2.1\)+$%\1 SPDX-License-Identifier: \2-or-later%' \ -i \ $(git grep -l SPDX-License-Identifier -- \ ':(exclude)shared/c-*/' \ ':(exclude)shared/n-*/' \ ':(exclude)shared/systemd/src' \ ':(exclude)src/systemd/src')
2020-12-23 22:21:36 +01:00
/* SPDX-License-Identifier: LGPL-2.1-or-later */
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
/*
all: unify format of our Copyright source code comments ```bash readarray -d '' FILES < <( git ls-files -z \ ':(exclude)po' \ ':(exclude)shared/c-rbtree' \ ':(exclude)shared/c-list' \ ':(exclude)shared/c-siphash' \ ':(exclude)shared/c-stdaux' \ ':(exclude)shared/n-acd' \ ':(exclude)shared/n-dhcp4' \ ':(exclude)src/systemd/src' \ ':(exclude)shared/systemd/src' \ ':(exclude)m4' \ ':(exclude)COPYING*' ) sed \ -e 's/^\(--\|#\| \*\) *\(([cC]) *\)\?Copyright \+\(\(([cC])\) \+\)\?\(\(20\|19\)[0-9][0-9]\) *[-–] *\(\(20\|19\)[0-9][0-9]\) \+\([^ ].*\)$/\1 C1pyright#\5 - \7#\9/' \ -e 's/^\(--\|#\| \*\) *\(([cC]) *\)\?Copyright \+\(\(([cC])\) \+\)\?\(\(20\|19\)[0-9][0-9]\) *[,] *\(\(20\|19\)[0-9][0-9]\) \+\([^ ].*\)$/\1 C2pyright#\5, \7#\9/' \ -e 's/^\(--\|#\| \*\) *\(([cC]) *\)\?Copyright \+\(\(([cC])\) \+\)\?\(\(20\|19\)[0-9][0-9]\) \+\([^ ].*\)$/\1 C3pyright#\5#\7/' \ -e 's/^Copyright \(\(20\|19\)[0-9][0-9]\) \+\([^ ].*\)$/C4pyright#\1#\3/' \ -i \ "${FILES[@]}" echo ">>> untouched Copyright lines" git grep Copyright "${FILES[@]}" echo ">>> Copyright lines with unusual extra" git grep '\<C[0-9]pyright#' "${FILES[@]}" | grep -i reserved sed \ -e 's/\<C[0-9]pyright#\([^#]*\)#\(.*\)$/Copyright (C) \1 \2/' \ -i \ "${FILES[@]}" ``` https://gitlab.freedesktop.org/NetworkManager/NetworkManager/merge_requests/298
2019-10-01 09:20:35 +02:00
* Copyright (C) 2018 Red Hat, Inc.
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
*/
all: add "src/core/nm-default-daemon.h" as replacement for "nm-default.h"
2021-02-04 18:04:13 +01:00
#include "src/core/nm-default-daemon.h"
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
#include "nm-keep-alive.h"
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
#include "settings/nm-settings-connection.h"
build: move "shared/nm-{glib-aux,log-null,log-core}" to "src/libnm-{glib-aux,log-null,log-core}"
2021-02-18 17:37:47 +01:00
#include "libnm-glib-aux/nm-dbus-aux.h"
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
/*****************************************************************************/
NM_GOBJECT_PROPERTIES_DEFINE(NMKeepAlive, PROP_ALIVE, );
typedef struct {
keep-alive: let NMKeepAlive instance access the owner object that it is keeping alive NMKeepAlive is a full API independent of NMActiveConnection. For good reasons: - it moves complexity away from nm-active-connection.c - in the future, we can use NMKeepAlive also for NMSettingsConnection As such, the user should also directly interact with NMKeepAlive, instead of going through NMActiveConnection. For that to work, it must be possible to get the owner of the NMKeepAlive instance, which is kept alive.
2018-11-20 15:31:59 +01:00
GObject *owner;
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
NMSettingsConnection *connection;
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
GDBusConnection *dbus_connection;
char *dbus_client;
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
GCancellable *dbus_client_confirm_cancellable;
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
guint subscription_id;
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
keep-alive: rename nm_keep_alive_sink() to nm_keep_alive_arm() The names "floating" and "sink()" are well known and good. However, "disarm()" seems the best name for the counterpart operation, better than "float()", "unsink()", or "freeze()". Since we have "nm_keep_alive_disarm()", for consitency rename - "floating" -> (not) "armed" - "sink()" -> "arm()"
2018-11-20 13:24:30 +01:00
bool armed : 1;
keep-alive: add nm_keep_alive_disarm() to silence notifications once we disconnect The NMKeepAlive instance is useful to find out when we should disconnect. The moment when we start disconnecting, we don't care about it anymore. Add a nm_keep_alive_disarm() function to suppress property change events about the alive state, after that point. Emitting further events from that point on is only confusing. Yes, this means, a NMKeepAlive instance shall not be re-used for multiple purposes. Create a separate keep-alive instace for each target that should be guarded. Also, once disarmed, we can release all resources that the NMKeepAlive instance was holding until now.
2018-11-20 11:28:33 +01:00
bool disarmed : 1;
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
bool alive : 1;
keep-alive: check GetNameOwner lazy and only when we rely on the information Upside: - it may avoid a D-Bus call altogether. - currently there is no API to bind/unbind an existing NMActiveConnection, it can only be bound initially with AddAndActivate2. That makes sense when the calling applicatiion only wants to keep the profile active for as long as it lives. It never intends to extend the lifetime beyond that. In such a case, it is expected that eventually we need to be sure whether the D-Bus client is still alive, as we make a decision based on that. In that case, we eventually will call GetNameOwner and nothing is saved. A future feature could add D-Bus API to bind/unbind existing active connections after creation. That would allow an application to activate profiles and -- if anything goes wrong -- to be sure that the profile gets deactivted. Only in the success case, it would unbind the lifetime in a last step and terminate. Un such a case, binding to a D-Bus client is more of a fail-safe mechanism and commonly not expected to come into action. This is an interesting feature, because ActivateConnection D-Bus call may take a long time, while perfroming interactive polkit authentication. That means, `nmcli connection up $PROFILE` can fail with timeout before the active connection path is even created, but afterwards the profile may still succeed to activate. That seems wrong. nmcli could avoid that, by binding the active connection to itself, and when nmcli exits with failure, it would make sure that the active connection gets disconnected as well. Downside: - the code is slightly more complicated(?). - if the D-Bus name is indeed gone (but the NMKeepAlive is still alive for other reasons), we will not unregister the D-Bus signal, because we never learn that it's gone. It's not a leak, but an unnecessary signal subscription. - during nm_keep_alive_set_dbus_client_watch() we don't notice right away that the D-Bus client is already gone. That is unavoidable as we confirm the state asynchronously. If the NMKeepAlive is kept alive for other reasons but only later depends on presence of the D-Bus client, then in the non-lazy approach we would have noticed already that the client is gone, and would disconnect right away. With the lazy approach, this takes another async D-Bus call to notice.
2018-11-19 14:41:56 +01:00
bool dbus_client_confirmed : 1;
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
bool dbus_client_watching : 1;
keep-alive: only declare keep-alive dead when connection becomes invisible A user can always manually activate his/her own profile, even if the profile is currently is invisible. -- it could be invisible, because the profile has "connection.permissions" set but the user has no active session. Now, if the user should be able to activate such a profile, then it cannot fail simply because being invisible all along. Instead, the alive check must only fail, if a connection becomes invisible that was visible in the time since it is monitored.
2018-11-28 13:17:07 +01:00
bool connection_was_visible : 1;
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
} NMKeepAlivePrivate;
struct _NMKeepAlive {
GObject parent;
NMKeepAlivePrivate _priv;
};
struct _NMKeepAliveClass {
GObjectClass parent;
};
G_DEFINE_TYPE(NMKeepAlive, nm_keep_alive, G_TYPE_OBJECT)
#define NM_KEEP_ALIVE_GET_PRIVATE(self) _NM_GET_PRIVATE(self, NMKeepAlive, NM_IS_KEEP_ALIVE)
/*****************************************************************************/
#define _NMLOG_DOMAIN LOGD_CORE
#define _NMLOG(level, ...) __NMLOG_DEFAULT(level, _NMLOG_DOMAIN, "keep-alive", __VA_ARGS__)
/*****************************************************************************/
keep-alive: check GetNameOwner lazy and only when we rely on the information Upside: - it may avoid a D-Bus call altogether. - currently there is no API to bind/unbind an existing NMActiveConnection, it can only be bound initially with AddAndActivate2. That makes sense when the calling applicatiion only wants to keep the profile active for as long as it lives. It never intends to extend the lifetime beyond that. In such a case, it is expected that eventually we need to be sure whether the D-Bus client is still alive, as we make a decision based on that. In that case, we eventually will call GetNameOwner and nothing is saved. A future feature could add D-Bus API to bind/unbind existing active connections after creation. That would allow an application to activate profiles and -- if anything goes wrong -- to be sure that the profile gets deactivted. Only in the success case, it would unbind the lifetime in a last step and terminate. Un such a case, binding to a D-Bus client is more of a fail-safe mechanism and commonly not expected to come into action. This is an interesting feature, because ActivateConnection D-Bus call may take a long time, while perfroming interactive polkit authentication. That means, `nmcli connection up $PROFILE` can fail with timeout before the active connection path is even created, but afterwards the profile may still succeed to activate. That seems wrong. nmcli could avoid that, by binding the active connection to itself, and when nmcli exits with failure, it would make sure that the active connection gets disconnected as well. Downside: - the code is slightly more complicated(?). - if the D-Bus name is indeed gone (but the NMKeepAlive is still alive for other reasons), we will not unregister the D-Bus signal, because we never learn that it's gone. It's not a leak, but an unnecessary signal subscription. - during nm_keep_alive_set_dbus_client_watch() we don't notice right away that the D-Bus client is already gone. That is unavoidable as we confirm the state asynchronously. If the NMKeepAlive is kept alive for other reasons but only later depends on presence of the D-Bus client, then in the non-lazy approach we would have noticed already that the client is gone, and would disconnect right away. With the lazy approach, this takes another async D-Bus call to notice.
2018-11-19 14:41:56 +01:00
static gboolean _is_alive_dbus_client(NMKeepAlive *self);
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
static void cleanup_dbus_watch(NMKeepAlive *self);
/*****************************************************************************/
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
static gboolean
_is_alive(NMKeepAlive *self)
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
keep-alive: rename nm_keep_alive_sink() to nm_keep_alive_arm() The names "floating" and "sink()" are well known and good. However, "disarm()" seems the best name for the counterpart operation, better than "float()", "unsink()", or "freeze()". Since we have "nm_keep_alive_disarm()", for consitency rename - "floating" -> (not) "armed" - "sink()" -> "arm()"
2018-11-20 13:24:30 +01:00
nm_assert(!priv->disarmed);
if (!priv->armed) {
/* before arming, the instance is always alive. */
return TRUE;
}
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
if (priv->dbus_client_watching) {
if (_is_alive_dbus_client(self)) {
/* no matter what, the keep-alive is alive, because there is a D-Bus client
* still around keeping it alive. */
return TRUE;
}
/* the D-Bus client is gone. The only other binding (below) for the connection's
* visibility cannot keep the instance alive.
*
all: fix misspellings https://gitlab.freedesktop.org/NetworkManager/NetworkManager/merge_requests/64
2019-01-11 17:07:03 -02:00
* As such, a D-Bus client watch is authoritative and overrules other conditions (that
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
* we have so far). */
return FALSE;
}
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: only declare keep-alive dead when connection becomes invisible A user can always manually activate his/her own profile, even if the profile is currently is invisible. -- it could be invisible, because the profile has "connection.permissions" set but the user has no active session. Now, if the user should be able to activate such a profile, then it cannot fail simply because being invisible all along. Instead, the alive check must only fail, if a connection becomes invisible that was visible in the time since it is monitored.
2018-11-28 13:17:07 +01:00
if (priv->connection && priv->connection_was_visible
&& !NM_FLAGS_HAS(nm_settings_connection_get_flags(priv->connection),
NM_SETTINGS_CONNECTION_INT_FLAGS_VISIBLE)) {
/* note that we only declare the keep-alive as dead due to invisible
* connection, if
* (1) we monitor a connection, obviously
* (2) the connection was visible earlier and is no longer. It was
* was invisible all the time, it does not suffice.
*/
return FALSE;
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
}
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
/* by default, the instance is alive. */
return TRUE;
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
static void
_notify_alive(NMKeepAlive *self)
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: add nm_keep_alive_disarm() to silence notifications once we disconnect The NMKeepAlive instance is useful to find out when we should disconnect. The moment when we start disconnecting, we don't care about it anymore. Add a nm_keep_alive_disarm() function to suppress property change events about the alive state, after that point. Emitting further events from that point on is only confusing. Yes, this means, a NMKeepAlive instance shall not be re-used for multiple purposes. Create a separate keep-alive instace for each target that should be guarded. Also, once disarmed, we can release all resources that the NMKeepAlive instance was holding until now.
2018-11-20 11:28:33 +01:00
if (priv->disarmed) {
/* once disarmed, the alive state is frozen. */
return;
}
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
if (priv->alive == _is_alive(self))
return;
priv->alive = !priv->alive;
keep-alive: log alive/dead status of keep-alive instance
2018-11-21 12:52:31 +01:00
_LOGD("instance is now %s", priv->alive ? "alive" : "dead");
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
_notify(self, PROP_ALIVE);
}
gboolean
nm_keep_alive_is_alive(NMKeepAlive *self)
{
return NM_KEEP_ALIVE_GET_PRIVATE(self)->alive;
}
/*****************************************************************************/
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
static void
connection_flags_changed(NMSettingsConnection *connection, NMKeepAlive *self)
{
keep-alive: only declare keep-alive dead when connection becomes invisible A user can always manually activate his/her own profile, even if the profile is currently is invisible. -- it could be invisible, because the profile has "connection.permissions" set but the user has no active session. Now, if the user should be able to activate such a profile, then it cannot fail simply because being invisible all along. Instead, the alive check must only fail, if a connection becomes invisible that was visible in the time since it is monitored.
2018-11-28 13:17:07 +01:00
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
if (!priv->connection_was_visible
&& NM_FLAGS_HAS(nm_settings_connection_get_flags(priv->connection),
NM_SETTINGS_CONNECTION_INT_FLAGS_VISIBLE)) {
/* the profile was never visible but now it becomes visible.
* Remember that.
*
* Before this happens (that is, if the device was invisible all along),
* the keep alive instance is considered alive (w.r.t. watching the connection).
*
* The reason is to allow a user to manually activate an invisible profile and keep
* it alive. At least, as long until the user logs out the first time (which is the
* first time, the profiles changes from visible to invisible).
*
* Yes, that is odd. How to improve? */
priv->connection_was_visible = TRUE;
}
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
_notify_alive(self);
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
static void
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
_set_settings_connection_watch_visible(NMKeepAlive *self,
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
NMSettingsConnection *connection,
gboolean emit_signal)
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
{
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
gs_unref_object NMSettingsConnection *old_connection = NULL;
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
if (priv->connection == connection)
return;
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
if (priv->connection) {
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
g_signal_handlers_disconnect_by_func(priv->connection,
G_CALLBACK(connection_flags_changed),
self);
old_connection = g_steal_pointer(&priv->connection);
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: add nm_keep_alive_disarm() to silence notifications once we disconnect The NMKeepAlive instance is useful to find out when we should disconnect. The moment when we start disconnecting, we don't care about it anymore. Add a nm_keep_alive_disarm() function to suppress property change events about the alive state, after that point. Emitting further events from that point on is only confusing. Yes, this means, a NMKeepAlive instance shall not be re-used for multiple purposes. Create a separate keep-alive instace for each target that should be guarded. Also, once disarmed, we can release all resources that the NMKeepAlive instance was holding until now.
2018-11-20 11:28:33 +01:00
if (connection && !priv->disarmed) {
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
priv->connection = g_object_ref(connection);
keep-alive: only declare keep-alive dead when connection becomes invisible A user can always manually activate his/her own profile, even if the profile is currently is invisible. -- it could be invisible, because the profile has "connection.permissions" set but the user has no active session. Now, if the user should be able to activate such a profile, then it cannot fail simply because being invisible all along. Instead, the alive check must only fail, if a connection becomes invisible that was visible in the time since it is monitored.
2018-11-28 13:17:07 +01:00
priv->connection_was_visible =
NM_FLAGS_HAS(nm_settings_connection_get_flags(priv->connection),
NM_SETTINGS_CONNECTION_INT_FLAGS_VISIBLE);
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
g_signal_connect(priv->connection,
NM_SETTINGS_CONNECTION_FLAGS_CHANGED,
G_CALLBACK(connection_flags_changed),
self);
}
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
if (emit_signal)
_notify_alive(self);
}
void
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
nm_keep_alive_set_settings_connection_watch_visible(NMKeepAlive *self,
keep-alive: cleanup tracking visible state of connection - in nm_keep_alive_set_settings_connection_watch_visible(), abort early when setting the same connection again (or %NULL again). - nm_keep_alive_set_settings_connection_watch_visible() would (already before) correctly disconnect the signal handler from the previous connection. As we anyway do explict disconnects, avoid the overhead of a weak pointer with g_signal_connect_object(). Just reuse the same setter to disconnect the signal in dispose(). - fix leaking priv->connection in nm_keep_alive_set_settings_connection_watch_visible(). - use g_signal_handlers_disconnect_by_func(), to be more specific about which signal we want to disconnect.
2018-11-17 12:56:14 +01:00
NMSettingsConnection *connection)
{
_set_settings_connection_watch_visible(self, connection, TRUE);
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
/*****************************************************************************/
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
static void
all: use nm_dbus_connection_signal_subscribe_name_owner_changed() ... and nm_dbus_connection_call_get_name_owner().
2019-05-04 11:30:29 +02:00
get_name_owner_cb(const char *name_owner, GError *error, gpointer user_data)
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
{
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
NMKeepAlive *self;
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
NMKeepAlivePrivate *priv;
all: use nm_dbus_connection_signal_subscribe_name_owner_changed() ... and nm_dbus_connection_call_get_name_owner().
2019-05-04 11:30:29 +02:00
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
if (!name_owner && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
all: use nm_dbus_connection_signal_subscribe_name_owner_changed() ... and nm_dbus_connection_call_get_name_owner().
2019-05-04 11:30:29 +02:00
self = user_data;
priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
all: use nm_dbus_connection_signal_subscribe_name_owner_changed() ... and nm_dbus_connection_call_get_name_owner().
2019-05-04 11:30:29 +02:00
if (name_owner && nm_streq(name_owner, priv->dbus_client)) {
/* all good, the name is confirmed. */
return;
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
}
_LOGD("DBus client for keep alive is not on the bus");
cleanup_dbus_watch(self);
_notify_alive(self);
}
keep-alive: check GetNameOwner lazy and only when we rely on the information Upside: - it may avoid a D-Bus call altogether. - currently there is no API to bind/unbind an existing NMActiveConnection, it can only be bound initially with AddAndActivate2. That makes sense when the calling applicatiion only wants to keep the profile active for as long as it lives. It never intends to extend the lifetime beyond that. In such a case, it is expected that eventually we need to be sure whether the D-Bus client is still alive, as we make a decision based on that. In that case, we eventually will call GetNameOwner and nothing is saved. A future feature could add D-Bus API to bind/unbind existing active connections after creation. That would allow an application to activate profiles and -- if anything goes wrong -- to be sure that the profile gets deactivted. Only in the success case, it would unbind the lifetime in a last step and terminate. Un such a case, binding to a D-Bus client is more of a fail-safe mechanism and commonly not expected to come into action. This is an interesting feature, because ActivateConnection D-Bus call may take a long time, while perfroming interactive polkit authentication. That means, `nmcli connection up $PROFILE` can fail with timeout before the active connection path is even created, but afterwards the profile may still succeed to activate. That seems wrong. nmcli could avoid that, by binding the active connection to itself, and when nmcli exits with failure, it would make sure that the active connection gets disconnected as well. Downside: - the code is slightly more complicated(?). - if the D-Bus name is indeed gone (but the NMKeepAlive is still alive for other reasons), we will not unregister the D-Bus signal, because we never learn that it's gone. It's not a leak, but an unnecessary signal subscription. - during nm_keep_alive_set_dbus_client_watch() we don't notice right away that the D-Bus client is already gone. That is unavoidable as we confirm the state asynchronously. If the NMKeepAlive is kept alive for other reasons but only later depends on presence of the D-Bus client, then in the non-lazy approach we would have noticed already that the client is gone, and would disconnect right away. With the lazy approach, this takes another async D-Bus call to notice.
2018-11-19 14:41:56 +01:00
static gboolean
_is_alive_dbus_client(NMKeepAlive *self)
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
if (!priv->dbus_client)
return FALSE;
if (!priv->dbus_client_confirmed) {
/* it's unconfirmed that the D-Bus client is really alive.
* It looks like it is, but as we are claiming that to be
* the case, issue an async GetNameOwner call to make sure. */
priv->dbus_client_confirmed = TRUE;
priv->dbus_client_confirm_cancellable = g_cancellable_new();
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
all: use nm_dbus_connection_signal_subscribe_name_owner_changed() ... and nm_dbus_connection_call_get_name_owner().
2019-05-04 11:30:29 +02:00
nm_dbus_connection_call_get_name_owner(priv->dbus_connection,
priv->dbus_client,
-1,
priv->dbus_client_confirm_cancellable,
get_name_owner_cb,
self);
keep-alive: check GetNameOwner lazy and only when we rely on the information Upside: - it may avoid a D-Bus call altogether. - currently there is no API to bind/unbind an existing NMActiveConnection, it can only be bound initially with AddAndActivate2. That makes sense when the calling applicatiion only wants to keep the profile active for as long as it lives. It never intends to extend the lifetime beyond that. In such a case, it is expected that eventually we need to be sure whether the D-Bus client is still alive, as we make a decision based on that. In that case, we eventually will call GetNameOwner and nothing is saved. A future feature could add D-Bus API to bind/unbind existing active connections after creation. That would allow an application to activate profiles and -- if anything goes wrong -- to be sure that the profile gets deactivted. Only in the success case, it would unbind the lifetime in a last step and terminate. Un such a case, binding to a D-Bus client is more of a fail-safe mechanism and commonly not expected to come into action. This is an interesting feature, because ActivateConnection D-Bus call may take a long time, while perfroming interactive polkit authentication. That means, `nmcli connection up $PROFILE` can fail with timeout before the active connection path is even created, but afterwards the profile may still succeed to activate. That seems wrong. nmcli could avoid that, by binding the active connection to itself, and when nmcli exits with failure, it would make sure that the active connection gets disconnected as well. Downside: - the code is slightly more complicated(?). - if the D-Bus name is indeed gone (but the NMKeepAlive is still alive for other reasons), we will not unregister the D-Bus signal, because we never learn that it's gone. It's not a leak, but an unnecessary signal subscription. - during nm_keep_alive_set_dbus_client_watch() we don't notice right away that the D-Bus client is already gone. That is unavoidable as we confirm the state asynchronously. If the NMKeepAlive is kept alive for other reasons but only later depends on presence of the D-Bus client, then in the non-lazy approach we would have noticed already that the client is gone, and would disconnect right away. With the lazy approach, this takes another async D-Bus call to notice.
2018-11-19 14:41:56 +01:00
}
return TRUE;
}
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
static void
cleanup_dbus_watch(NMKeepAlive *self)
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
if (!priv->dbus_client)
return;
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
_LOGD("Cleanup DBus client watch");
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
keep-alive: avoid race with with D-Bus client disconnecting early When we subscribe the signal fo NameOwnerChanged, we are not sure that the name-owner is currently alive. Issue a GetNameOwner call to make sure. Co-authored-by: Thomas Haller <thaller@redhat.com> Fixes: 37e8c53eeed579fe34a68819cd12f3295d581394
2018-11-19 14:18:44 +01:00
nm_clear_g_cancellable(&priv->dbus_client_confirm_cancellable);
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
nm_clear_g_free(&priv->dbus_client);
if (priv->dbus_connection) {
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
g_dbus_connection_signal_unsubscribe(priv->dbus_connection,
all: use nm_clear_g_dbus_connection_signal() helper I also like this because it's non-obvious that subscription IDs from GDBusConnection are "guint" (contrary to signal handler IDs which are "gulong"). So, by using this API you get a compiler error when using the wrong type. In the past, when switching to nm_clear_g_signal_handler() this uncovered multiple bugs where the wrong type was used to hold the ID.
2019-05-04 11:53:55 +02:00
nm_steal_int(&priv->subscription_id));
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
g_clear_object(&priv->dbus_connection);
}
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
static void
name_owner_changed_cb(GDBusConnection *connection,
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
const char *sender_name,
const char *object_path,
const char *interface_name,
const char *signal_name,
GVariant *parameters,
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
gpointer user_data)
{
NMKeepAlive *self = NM_KEEP_ALIVE(user_data);
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
const char *old_owner;
const char *new_owner;
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
g_variant_get(parameters, "(&s&s&s)", NULL, &old_owner, &new_owner);
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
if (!nm_streq0(new_owner, ""))
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
return;
_LOGD("DBus client for keep alive disappeared from bus");
cleanup_dbus_watch(self);
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
_notify_alive(self);
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
void
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
nm_keep_alive_set_dbus_client_watch(NMKeepAlive *self,
keep-alive: drop unused error argument
2018-11-17 12:43:25 +01:00
GDBusConnection *connection,
format: reformat source tree with clang-format 13.0 We use clang-format for automatic formatting of our source files. Since clang-format is actively maintained software, the actual formatting depends on the used version of clang-format. That is unfortunate and painful, but really unavoidable unless clang-format would be strictly bug-compatible. So the version that we must use is from the current Fedora release, which is also tested by our gitlab-ci. Previously, we were using Fedora 34 with clang-tools-extra-12.0.1-1.fc34.x86_64. As Fedora 35 comes along, we need to update our formatting as Fedora 35 comes with version "13.0.0~rc1-1.fc35". An alternative would be to freeze on version 12, but that has different problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it would be cumbersome for our developers which are on Fedora 35 to use a clang that they cannot easily install). The (differently painful) solution is to reformat from time to time, as we switch to a new Fedora (and thus clang) version. Usually we would expect that such a reformatting brings minor changes. But this time, the changes are huge. That is mentioned in the release notes [1] as Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353) [1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-09 13:28:54 +01:00
const char *client_address)
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
if (priv->disarmed)
return;
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
cleanup_dbus_watch(self);
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
if (client_address) {
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
_LOGD("Registering dbus client watch for keep alive");
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
priv->dbus_client = g_strdup(client_address);
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
priv->dbus_client_watching = TRUE;
keep-alive: check GetNameOwner lazy and only when we rely on the information Upside: - it may avoid a D-Bus call altogether. - currently there is no API to bind/unbind an existing NMActiveConnection, it can only be bound initially with AddAndActivate2. That makes sense when the calling applicatiion only wants to keep the profile active for as long as it lives. It never intends to extend the lifetime beyond that. In such a case, it is expected that eventually we need to be sure whether the D-Bus client is still alive, as we make a decision based on that. In that case, we eventually will call GetNameOwner and nothing is saved. A future feature could add D-Bus API to bind/unbind existing active connections after creation. That would allow an application to activate profiles and -- if anything goes wrong -- to be sure that the profile gets deactivted. Only in the success case, it would unbind the lifetime in a last step and terminate. Un such a case, binding to a D-Bus client is more of a fail-safe mechanism and commonly not expected to come into action. This is an interesting feature, because ActivateConnection D-Bus call may take a long time, while perfroming interactive polkit authentication. That means, `nmcli connection up $PROFILE` can fail with timeout before the active connection path is even created, but afterwards the profile may still succeed to activate. That seems wrong. nmcli could avoid that, by binding the active connection to itself, and when nmcli exits with failure, it would make sure that the active connection gets disconnected as well. Downside: - the code is slightly more complicated(?). - if the D-Bus name is indeed gone (but the NMKeepAlive is still alive for other reasons), we will not unregister the D-Bus signal, because we never learn that it's gone. It's not a leak, but an unnecessary signal subscription. - during nm_keep_alive_set_dbus_client_watch() we don't notice right away that the D-Bus client is already gone. That is unavoidable as we confirm the state asynchronously. If the NMKeepAlive is kept alive for other reasons but only later depends on presence of the D-Bus client, then in the non-lazy approach we would have noticed already that the client is gone, and would disconnect right away. With the lazy approach, this takes another async D-Bus call to notice.
2018-11-19 14:41:56 +01:00
priv->dbus_client_confirmed = FALSE;
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
priv->dbus_connection = g_object_ref(connection);
all: use nm_dbus_connection_signal_subscribe_name_owner_changed() ... and nm_dbus_connection_call_get_name_owner().
2019-05-04 11:30:29 +02:00
priv->subscription_id =
nm_dbus_connection_signal_subscribe_name_owner_changed(priv->dbus_connection,
priv->dbus_client,
name_owner_changed_cb,
self,
NULL);
keep-alive: default keep-alive instance to alive NMKeepAlive supports conditions (watches, bindings) that determine whether the instance signals alive state. Currently, there are two conditions: watch a VISIBLE state of a connection and watch whether a D-Bus client is registered. Anyway, if none of these conditions are enabled, then the default should be that the instance is alive. If one or more conditions are enabled, then they cooprate in a particular way, depending on whether the condition is enabled and whether it is satisfied. Previously, the code couldn't differenciate whether a D-Bus watch was not enabled or whether the D-Bus client already disconnected. It would just check whether priv->dbus_client was set, but that alone was not sufficient to differentiate. That means, we couldn't determine whether the keep-alive instance is alive (by default, as no D-Bus watch is enabled) or whether the keep-alive instance is dead (because the D-Bus client disconnected). Fix that, by tracking explicitly whether to watch based on a priv->dbus_client_watching flag. Note, that problems by this were avoided earlier, by only arming the instance when enabling a condition. But I think the concept of arming the keep-alive instance merely means that the instance is ready to fire events. It should not mean that the user only arms the instance after registering a condition. Also, without this, we couldn't unbind the NMKeepAlive instance from all conditions, without making it dead right away. Unbinding/disabling all conditions should render the instance alive, not dead.
2018-11-21 12:41:57 +01:00
} else
priv->dbus_client_watching = FALSE;
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
keep-alive: minor cleanup of nm_keep_alive_set_dbus_client_watch() - always issue a _notify_alive(), just to be sure. At least in case where we clear a dbus-client watch, the alive state could change. - avoid the logging in cleanup_dbus_watch(), if there is nothing to cleanup.
2018-11-17 13:29:40 +01:00
_notify_alive(self);
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
/*****************************************************************************/
keep-alive: rename nm_keep_alive_sink() to nm_keep_alive_arm() The names "floating" and "sink()" are well known and good. However, "disarm()" seems the best name for the counterpart operation, better than "float()", "unsink()", or "freeze()". Since we have "nm_keep_alive_disarm()", for consitency rename - "floating" -> (not) "armed" - "sink()" -> "arm()"
2018-11-20 13:24:30 +01:00
/**
* nm_keep_alive_arm:
* @self: the #NMKeepAlive
*
* A #NMKeepAlive instance is unarmed by default. That means, it's
* alive and stays alive until being armed. Arming means, that the conditions
* start to be actively evaluated, that the alive state may change, and
* that property changed signals are emitted.
*
* The opposite is nm_keep_alive_disarm() which freezes the alive state
* for good. Once disarmed, the instance cannot be armed again. Arming an
* instance multiple times has no effect. Arming an already disarmed instance
* also has no effect. */
void
nm_keep_alive_arm(NMKeepAlive *self)
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
if (!priv->armed) {
priv->armed = TRUE;
_notify_alive(self);
}
}
keep-alive: add nm_keep_alive_disarm() to silence notifications once we disconnect The NMKeepAlive instance is useful to find out when we should disconnect. The moment when we start disconnecting, we don't care about it anymore. Add a nm_keep_alive_disarm() function to suppress property change events about the alive state, after that point. Emitting further events from that point on is only confusing. Yes, this means, a NMKeepAlive instance shall not be re-used for multiple purposes. Create a separate keep-alive instace for each target that should be guarded. Also, once disarmed, we can release all resources that the NMKeepAlive instance was holding until now.
2018-11-20 11:28:33 +01:00
/**
* nm_keep_alive_disarm:
* @self: the #NMKeepAlive instance
*
* Once the instance is disarmed, it will not change its alive state
* anymore and will not emit anymore property changed signals about
* alive state changed.
*
* As such, it will also free internal resources (since they no longer
* affect the externally visible state).
*
* Once disarmed, the instance is frozen and cannot change anymore.
*/
void
nm_keep_alive_disarm(NMKeepAlive *self)
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
priv->disarmed = TRUE;
/* release internal data. */
_set_settings_connection_watch_visible(self, NULL, FALSE);
cleanup_dbus_watch(self);
}
core: add and use nm_keep_alive_destroy() When we are done with a NMKeepAlive instance, we always should do three things: - unset the owner - disarm (freeze) the keep-alive - give up our reference. Add and use nm_keep_alive_destroy() that does this.
2019-06-27 12:38:45 +02:00
/**
* nm_keep_alive_destroy:
* @self: (allow-none): the #NMKeepAlive instance to destroy.
*
* This does 3 things in one:
*
* - set owner to %NULL
* - disarm the instance.
* - unref @self.
*/
void
nm_keep_alive_destroy(NMKeepAlive *self)
{
if (!self)
return;
_nm_keep_alive_set_owner(self, NULL);
nm_keep_alive_disarm(self);
g_object_unref(self);
}
keep-alive: add nm_keep_alive_disarm() to silence notifications once we disconnect The NMKeepAlive instance is useful to find out when we should disconnect. The moment when we start disconnecting, we don't care about it anymore. Add a nm_keep_alive_disarm() function to suppress property change events about the alive state, after that point. Emitting further events from that point on is only confusing. Yes, this means, a NMKeepAlive instance shall not be re-used for multiple purposes. Create a separate keep-alive instace for each target that should be guarded. Also, once disarmed, we can release all resources that the NMKeepAlive instance was holding until now.
2018-11-20 11:28:33 +01:00
/*****************************************************************************/
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
NMKeepAlive *self = NM_KEEP_ALIVE(object);
all: reformat all with new clang-format style Run: ./contrib/scripts/nm-code-format.sh -i ./contrib/scripts/nm-code-format.sh -i Yes, it needs to run twice because the first run doesn't yet produce the final result. Signed-off-by: Antonio Cardace <acardace@redhat.com>
2020-09-28 16:03:33 +02:00
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
switch (prop_id) {
case PROP_ALIVE:
g_value_set_boolean(value, nm_keep_alive_is_alive(self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
/*****************************************************************************/
keep-alive: let NMKeepAlive instance access the owner object that it is keeping alive NMKeepAlive is a full API independent of NMActiveConnection. For good reasons: - it moves complexity away from nm-active-connection.c - in the future, we can use NMKeepAlive also for NMSettingsConnection As such, the user should also directly interact with NMKeepAlive, instead of going through NMActiveConnection. For that to work, it must be possible to get the owner of the NMKeepAlive instance, which is kept alive.
2018-11-20 15:31:59 +01:00
/**
* nm_keep_alive_get_owner:
* @self: the #NMKeepAlive
*
* Returns: the owner instance associated with this @self. This commonly
* is set to be the target instance, which @self guards for being alive.
* Returns a gpointer, but of course it's some GObject instance. */
gpointer /* GObject * */
nm_keep_alive_get_owner(NMKeepAlive *self)
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
nm_assert(!priv->owner || G_IS_OBJECT(priv->owner));
return priv->owner;
}
/**
* _nm_keep_alive_set_owner:
* @self: the #NMKeepAlive
* @owner: the owner to set or unset.
*
* Sets or unsets the owner instance. Think of the owner the target
* instance that is guarded by @self. It's the responsibility of the
* owner to set and properly unset this pointer. As the owner also
* controls the lifetime of the NMKeepAlive instance.
*
* This API is not to be called by everybody, but only the owner of
* @self.
*/
void
_nm_keep_alive_set_owner(NMKeepAlive *self, GObject *owner)
{
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
nm_assert(!owner || G_IS_OBJECT(owner));
/* it's bad style to reset the owner object. You are supposed to
* set it once, and clear it once. That's it. */
nm_assert(!owner || !priv->owner);
/* optimally, we would take a reference to @owner. But the
all: fix misspellings https://gitlab.freedesktop.org/NetworkManager/NetworkManager/merge_requests/64
2019-01-11 17:07:03 -02:00
* owner already owns a reference to the keep-alive, so we cannot
keep-alive: let NMKeepAlive instance access the owner object that it is keeping alive NMKeepAlive is a full API independent of NMActiveConnection. For good reasons: - it moves complexity away from nm-active-connection.c - in the future, we can use NMKeepAlive also for NMSettingsConnection As such, the user should also directly interact with NMKeepAlive, instead of going through NMActiveConnection. For that to work, it must be possible to get the owner of the NMKeepAlive instance, which is kept alive.
2018-11-20 15:31:59 +01:00
* just own a reference back.
*
* We could register a weak-pointer here. But instead, declare that
* owner is required to set itself as owner when creating the
* keep-alive instance, and unset itself when it lets go of the
* keep-alive instance (at latest, when the owner itself gets destroyed).
*/
priv->owner = owner;
}
/*****************************************************************************/
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
static void
nm_keep_alive_init(NMKeepAlive *self)
{
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);
keep-alive: various style fixes Some trivial changes: - move nm_keep_alive_new() after nm_keep_alive_init(), so that the functions that initialize the instance are beside each other. - prefer nm_streq*() over strcmp(). - wrap some lines. - remove some empty lines.
2018-11-17 12:46:14 +01:00
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
priv->alive = TRUE;
keep-alive: drop "floating" argument from nm_keep_alive_new() All callers only want to create floating instances at first. Also, it seems to make generally more sense this way: you create a floating instance, set it up, and then arm it. This simplifies nm_keep_alive_new(), which previously was adding additional code that wasn't accessible via plain g_object_new().
2018-11-20 13:16:54 +01:00
keep-alive: cache the alive-state and only emit the signal when it changed The alive state is composed from various parts, let's only emit a _notify (self, PROP_ALIVE) when it actually changes. For that, cache the alive state and let _notify_alive() determine whether it changed and possibly emit the signal.
2018-11-17 13:07:22 +01:00
nm_assert(priv->alive == _is_alive(self));
keep-alive: drop "floating" argument from nm_keep_alive_new() All callers only want to create floating instances at first. Also, it seems to make generally more sense this way: you create a floating instance, set it up, and then arm it. This simplifies nm_keep_alive_new(), which previously was adding additional code that wasn't accessible via plain g_object_new().
2018-11-20 13:16:54 +01:00
}
NMKeepAlive *
nm_keep_alive_new(void)
{
return g_object_new(NM_TYPE_KEEP_ALIVE, NULL);
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
static void
dispose(GObject *object)
{
NMKeepAlive *self = NM_KEEP_ALIVE(object);
keep-alive: let NMKeepAlive instance access the owner object that it is keeping alive NMKeepAlive is a full API independent of NMActiveConnection. For good reasons: - it moves complexity away from nm-active-connection.c - in the future, we can use NMKeepAlive also for NMSettingsConnection As such, the user should also directly interact with NMKeepAlive, instead of going through NMActiveConnection. For that to work, it must be possible to get the owner of the NMKeepAlive instance, which is kept alive.
2018-11-20 15:31:59 +01:00
nm_assert(!NM_KEEP_ALIVE_GET_PRIVATE(self)->owner);
keep-alive: add nm_keep_alive_disarm() to silence notifications once we disconnect The NMKeepAlive instance is useful to find out when we should disconnect. The moment when we start disconnecting, we don't care about it anymore. Add a nm_keep_alive_disarm() function to suppress property change events about the alive state, after that point. Emitting further events from that point on is only confusing. Yes, this means, a NMKeepAlive instance shall not be re-used for multiple purposes. Create a separate keep-alive instace for each target that should be guarded. Also, once disarmed, we can release all resources that the NMKeepAlive instance was holding until now.
2018-11-20 11:28:33 +01:00
/* disarm also happens to free all resources. */
nm_keep_alive_disarm(self);
core: Introduce helper class to track connection keep alive For P2P connections it makes sense to bind the connection to the status of the operation that is being done. One example is that a wifi display (miracast) P2P connection should be shut down when streaming fails for some reason. This new helper class allows binding a connection to the presence of a DBus path meaning that it will be torn down if the process disappears.
2018-10-10 17:10:01 +02:00
}
static void
nm_keep_alive_class_init(NMKeepAliveClass *keep_alive_class)
{
GObjectClass *object_class = G_OBJECT_CLASS(keep_alive_class);
object_class->get_property = get_property;
object_class->dispose = dispose;
obj_properties[PROP_ALIVE] = g_param_spec_string(NM_KEEP_ALIVE_ALIVE,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
}
Reference in a new issue Copy permalink