fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-20 04:28:12 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/src/core/nm-audit-manager.c

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

488 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: GPL-2.0-or-later */
all: manually drop code comments with file description
2019-09-25 13:13:40 +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) 2015 Red Hat, Inc.
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +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"
all: cleanup includes and let "nm-default.h" include "config.h" - All internal source files (except "examples", which are not internal) should include "config.h" first. As also all internal source files should include "nm-default.h", let "config.h" be included by "nm-default.h" and include "nm-default.h" as first in every source file. We already wanted to include "nm-default.h" before other headers because it might contains some fixes (like "nm-glib.h" compatibility) that is required first. - After including "nm-default.h", we optinally allow for including the corresponding header file for the source file at hand. The idea is to ensure that each header file is self contained. - Don't include "config.h" or "nm-default.h" in any header file (except "nm-sd-adapt.h"). Public headers anyway must not include these headers, and internal headers are never included after "nm-default.h", as of the first previous point. - Include all internal headers with quotes instead of angle brackets. In practice it doesn't matter, because in our public headers we must include other headers with angle brackets. As we use our public headers also to compile our interal source files, effectively the result must be the same. Still do it for consistency. - Except for <config.h> itself. Include it with angle brackets as suggested by https://www.gnu.org/software/autoconf/manual/autoconf.html#Configuration-Headers
2016-02-19 14:57:48 +01:00
build: cleanup default includes - "gsystem-local-alloc.h" and <gio/gio.h> are already included via "nm-default.h". No need to include them separately. - include "nm-macros-internal.h" via "nm-default.h" and drop all explict includes. - in the modified files, ensure that we always include "config.h" and "nm-default.h" first. As second, include the header file for the current source file (if applicable). Then follow external includes and finally internal nm includes. - include nm headers inside source code files with quotes - internal header files don't need to include default headers. They can savely assume that "nm-default.h" is already included and with it glib, nm-glib.h, nm-macros-internal.h, etc.
2016-02-12 14:44:52 +01:00
#include "nm-audit-manager.h"
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
#if HAVE_LIBAUDIT
clang-format: use "IndentPPDirectives:None" instead of "BeforeHash" Subjectively, I think this looks better.
2021-07-09 08:48:48 +02:00
#include <libaudit.h>
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
#endif
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
#define NM_VALUE_TYPE_DEFINE_FUNCTIONS
build: move "libnm-core/" to "src/" and split it "libnm-core/" is rather complicated. It provides a static library that is linked into libnm.so and NetworkManager. It also contains public headers (like "nm-setting.h") which are part of public libnm API. Then we have helper libraries ("libnm-core/nm-libnm-core-*/") which only rely on public API of libnm-core, but are themself static libraries that can be used by anybody who uses libnm-core. And "libnm-core/nm-libnm-core-intern" is used by libnm-core itself. Move "libnm-core/" to "src/". But also split it in different directories so that they have a clearer purpose. The goal is to have a flat directory hierarchy. The "src/libnm-core*/" directories correspond to the different modules (static libraries and set of headers that we have). We have different kinds of such modules because of how we combine various code together. The directory layout now reflects this.
2021-02-12 15:01:09 +01:00
#include "libnm-core-aux-intern/nm-auth-subject.h"
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
#include "libnm-glib-aux/nm-str-buf.h"
#include "libnm-glib-aux/nm-value-type.h"
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
#include "nm-config.h"
shared: move nm-dbus-auth-subject to shared/nm-libnm-core-intern Move it to shared as it's useful for clients as well. Move and rename nm_dbus_manager_new_auth_subject_from_context() and nm_dbus_manager_new_auth_subject_from_message() in nm-dbus-manager.c as they're needed there.
2019-12-19 11:30:38 +01:00
#include "nm-dbus-manager.h"
build: don't add subdirectories to include search path but require qualified include Keep the include paths clean and separate. We use directories to group source files together. That makes sense (I guess), but then we should use this grouping also when including files. Thus require to #include files with their path relative to "src/". Also, we build various artifacts from the "src/" tree. Instead of having individual CFLAGS for each artifact in Makefile.am, the CFLAGS should be unified. Previously, the CFLAGS for each artifact differ and are inconsistent in which paths they add to the search path. Fix the inconsistency by just don't add the paths at all.
2016-11-21 00:43:52 +01:00
#include "settings/nm-settings-connection.h"
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
/*****************************************************************************/
audit: use logging helpers
2016-03-03 09:20:23 +01:00
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
typedef enum _nm_packed {
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
BACKEND_LOG = (1 << 0),
BACKEND_AUDITD = (1 << 1),
_BACKEND_LAST,
BACKEND_ALL = ((_BACKEND_LAST - 1) << 1) - 1,
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
} AuditBackend;
typedef struct {
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
const char * name;
AuditBackend backends;
bool need_encoding;
NMValueType value_type;
NMValueTypUnion value;
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
} AuditField;
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
/*****************************************************************************/
core: fix runtime warning when building without libaudit If !HAVE_LIBAUDIT then sizeof(NMAuditManagerPrivate) was 0, which upset g_type_class_add_private(). (It's also not valid C.) Fix things up so that NMAuditManagerPrivate as a whole only exists if HAVE_LIBAUDIT.
2015-08-07 16:43:11 -04:00
typedef struct {
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
NMConfig *config;
int auditd_fd;
} NMAuditManagerPrivate;
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
struct _NMAuditManager {
GObject parent;
#if HAVE_LIBAUDIT
NMAuditManagerPrivate _priv;
core: fix runtime warning when building without libaudit If !HAVE_LIBAUDIT then sizeof(NMAuditManagerPrivate) was 0, which upset g_type_class_add_private(). (It's also not valid C.) Fix things up so that NMAuditManagerPrivate as a whole only exists if HAVE_LIBAUDIT.
2015-08-07 16:43:11 -04:00
#endif
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
};
struct _NMAuditManagerClass {
GObjectClass parent;
};
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
G_DEFINE_TYPE(NMAuditManager, nm_audit_manager, G_TYPE_OBJECT)
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
#define NM_AUDIT_MANAGER_GET_PRIVATE(self) \
_NM_GET_PRIVATE(self, NMAuditManager, NM_IS_AUDIT_MANAGER)
/*****************************************************************************/
#define AUDIT_LOG_LEVEL LOGL_INFO
#define _NMLOG_PREFIX_NAME "audit"
#define _NMLOG(level, domain, ...) \
G_STMT_START \
{ \
logging: log device and connection along with the message
2017-03-01 10:20:01 +00:00
nm_log((level), \
(domain), \
NULL, \
NULL, \
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
"%s" _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \
_NMLOG_PREFIX_NAME ": " _NM_UTILS_MACRO_REST(__VA_ARGS__)); \
} \
G_STMT_END
/*****************************************************************************/
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
NM_DEFINE_SINGLETON_GETTER(NMAuditManager, nm_audit_manager_get, NM_TYPE_AUDIT_MANAGER);
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
/*****************************************************************************/
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
static void
_audit_field_init_string(AuditField * field,
const char * name,
const char * str,
gboolean need_encoding,
AuditBackend backends)
{
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
*field = (AuditField){
.name = name,
.need_encoding = need_encoding,
.backends = backends,
.value_type = NM_VALUE_TYPE_STRING,
.value.v_string = str,
};
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
static void
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
_audit_field_init_uint64(AuditField *field, const char *name, guint64 val, AuditBackend backends)
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
{
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
*field = (AuditField){
.name = name,
.backends = backends,
.value_type = NM_VALUE_TYPE_UINT64,
.value.v_uint64 = val,
};
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
static const char *
build_message(NMStrBuf *strbuf, AuditBackend backend, GPtrArray *fields)
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
{
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
guint i;
if (strbuf->len == 0) {
/* preallocate a large buffer... */
nm_str_buf_maybe_expand(strbuf, NM_UTILS_GET_NEXT_REALLOC_SIZE_232, FALSE);
} else
nm_str_buf_reset(strbuf);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
for (i = 0; i < fields->len; i++) {
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
const AuditField *field = fields->pdata[i];
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
all: don't use NM_FLAGS_HAS() with non-constant argument NM_FLAGS_HAS() uses a static-assert that the second argument is a single flag (power of two). With a single flag, NM_FLAGS_HAS(), NM_FLAGS_ANY() and NM_FLAGS_ALL() are all identical. The second argument must be a compile time constant, and if that is not the case, one must not use NM_FLAGS_HAS(). Use NM_FLAGS_ANY() in these cases.
2017-12-11 16:38:42 +01:00
if (!NM_FLAGS_ANY(field->backends, backend))
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
continue;
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
nm_str_buf_append_required_delimiter(strbuf, ' ');
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
if (field->value_type == NM_VALUE_TYPE_STRING) {
const char *str = field->value.v_string;
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
#if HAVE_LIBAUDIT
if (backend == BACKEND_AUDITD) {
if (field->need_encoding) {
audit: use NMStrBuf in audit's build_message()
2021-04-09 13:44:49 +02:00
gs_free char *value = 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
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
value = audit_encode_nv_string(field->name, str, 0);
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
nm_str_buf_append(strbuf, value);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
} else
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
nm_str_buf_append_printf(strbuf, "%s=%s", field->name, str);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
continue;
}
#endif /* HAVE_LIBAUDIT */
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
nm_str_buf_append_printf(strbuf, "%s=\"%s\"", field->name, str);
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
continue;
}
if (field->value_type == NM_VALUE_TYPE_UINT64) {
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
nm_str_buf_append_printf(strbuf,
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
"%s=%" G_GUINT64_FORMAT,
audit: use NMStrBuf in audit's build_message()
2021-04-09 13:44:49 +02:00
field->name,
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
field->value.v_uint64);
continue;
}
g_return_val_if_reached(NULL);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
return nm_str_buf_get_str(strbuf);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
static void
nm_audit_log(NMAuditManager *self,
GPtrArray * fields,
const char * file,
guint line,
const char * func,
gboolean success)
{
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
nm_auto_str_buf NMStrBuf strbuf = NM_STR_BUF_INIT(0, FALSE);
core: fix runtime warning when building without libaudit If !HAVE_LIBAUDIT then sizeof(NMAuditManagerPrivate) was 0, which upset g_type_class_add_private(). (It's also not valid C.) Fix things up so that NMAuditManagerPrivate as a whole only exists if HAVE_LIBAUDIT.
2015-08-07 16:43:11 -04:00
#if HAVE_LIBAUDIT
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
NMAuditManagerPrivate *priv;
core: fix runtime warning when building without libaudit If !HAVE_LIBAUDIT then sizeof(NMAuditManagerPrivate) was 0, which upset g_type_class_add_private(). (It's also not valid C.) Fix things up so that NMAuditManagerPrivate as a whole only exists if HAVE_LIBAUDIT.
2015-08-07 16:43:11 -04:00
#endif
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
g_return_if_fail(NM_IS_AUDIT_MANAGER(self));
#if HAVE_LIBAUDIT
core: fix runtime warning when building without libaudit If !HAVE_LIBAUDIT then sizeof(NMAuditManagerPrivate) was 0, which upset g_type_class_add_private(). (It's also not valid C.) Fix things up so that NMAuditManagerPrivate as a whole only exists if HAVE_LIBAUDIT.
2015-08-07 16:43:11 -04:00
priv = NM_AUDIT_MANAGER_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
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
if (priv->auditd_fd >= 0) {
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
audit_log_user_message(priv->auditd_fd,
AUDIT_USYS_CONFIG,
build_message(&strbuf, BACKEND_AUDITD, fields),
NULL,
NULL,
NULL,
success);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
#endif
if (nm_logging_enabled(AUDIT_LOG_LEVEL, LOGD_AUDIT)) {
audit: fix using original file:line information for audit logging With structured logging (journald), the file, line and func information is relevant. Propagate the right value to the audit logging line.
2021-04-09 13:05:07 +02:00
_nm_log_full(file,
line,
func,
!(NM_THREAD_SAFE_ON_MAIN_THREAD),
AUDIT_LOG_LEVEL,
LOGD_AUDIT,
0,
NULL,
NULL,
"%s%s",
_NMLOG_PREFIX_NAME ": ",
audit: pass and reuse NMStrBuf for build_message() build_message() is an internal helper function with a very specific purpose. Let's change it to take an NMStrBuf argument for generating the string. The advantage is that we don't need to allocate and free the buffers in between, but can just reuse it.
2021-04-09 16:54:05 +02:00
build_message(&strbuf, BACKEND_LOG, fields));
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
}
static void
settings: add audit-logging for connection load and reload
2019-07-15 09:56:44 +02:00
_audit_log_helper(NMAuditManager *self,
GPtrArray * fields,
const char * file,
guint line,
const char * func,
const char * op,
gboolean result,
gpointer subject_context,
const char * reason)
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
{
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
AuditField op_field;
AuditField pid_field;
AuditField uid_field;
AuditField result_field;
AuditField reason_field;
gulong pid;
gulong uid;
audit: allow passing GDBusMethodInvocation context to audit methods
2016-01-07 16:31:19 +01:00
NMAuthSubject * subject = NULL;
gs_unref_object NMAuthSubject *subject_free = 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
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
_audit_field_init_string(&op_field, "op", op, FALSE, BACKEND_ALL);
g_ptr_array_insert(fields, 0, &op_field);
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
audit: allow passing GDBusMethodInvocation context to audit methods
2016-01-07 16:31:19 +01:00
if (subject_context) {
if (NM_IS_AUTH_SUBJECT(subject_context))
subject = subject_context;
else if (G_IS_DBUS_METHOD_INVOCATION(subject_context)) {
GDBusMethodInvocation *context = subject_context;
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
shared: move nm-dbus-auth-subject to shared/nm-libnm-core-intern Move it to shared as it's useful for clients as well. Move and rename nm_dbus_manager_new_auth_subject_from_context() and nm_dbus_manager_new_auth_subject_from_message() in nm-dbus-manager.c as they're needed there.
2019-12-19 11:30:38 +01:00
subject = subject_free = nm_dbus_manager_new_auth_subject_from_context(context);
audit: allow passing GDBusMethodInvocation context to audit methods
2016-01-07 16:31:19 +01:00
} else
g_warn_if_reached();
}
shared: nm-auth-subject: add unix-session type
2019-12-17 20:36:18 +01:00
if (subject && nm_auth_subject_get_subject_type(subject) == NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS) {
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
pid = nm_auth_subject_get_unix_process_pid(subject);
uid = nm_auth_subject_get_unix_process_uid(subject);
if (pid != G_MAXULONG) {
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
_audit_field_init_uint64(&pid_field, "pid", pid, BACKEND_ALL);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
g_ptr_array_add(fields, &pid_field);
}
if (uid != G_MAXULONG) {
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
_audit_field_init_uint64(&uid_field, "uid", uid, BACKEND_ALL);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
g_ptr_array_add(fields, &uid_field);
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +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
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
_audit_field_init_string(&result_field,
"result",
result ? "success" : "fail",
FALSE,
BACKEND_ALL);
g_ptr_array_add(fields, &result_field);
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
if (reason) {
_audit_field_init_string(&reason_field, "reason", reason, FALSE, BACKEND_LOG);
g_ptr_array_add(fields, &reason_field);
}
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
nm_audit_log(self, fields, file, line, func, result);
}
gboolean
nm_audit_manager_audit_enabled(NMAuditManager *self)
{
#if HAVE_LIBAUDIT
NMAuditManagerPrivate *priv = NM_AUDIT_MANAGER_GET_PRIVATE(self);
if (priv->auditd_fd >= 0)
return TRUE;
#endif
return nm_logging_enabled(AUDIT_LOG_LEVEL, LOGD_AUDIT);
}
void
settings: add audit-logging for connection load and reload
2019-07-15 09:56:44 +02:00
_nm_audit_manager_log_connection_op(NMAuditManager * self,
const char * file,
guint line,
const char * func,
const char * op,
NMSettingsConnection *connection,
gboolean result,
const char * args,
gpointer subject_context,
const char * reason)
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
{
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
gs_unref_ptrarray GPtrArray *fields = NULL;
AuditField uuid_field;
AuditField name_field;
AuditField args_field;
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
g_return_if_fail(op);
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
fields = g_ptr_array_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
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
if (connection) {
core: separate active and applied connection Clone the connection upon activation. This makes it safe for the user to modify the original connection while it is activated. This involves several changes: - NMActiveConnection gets @settings_connection and @applied_connection. To support add-and-activate, we constructing a NMActiveConnection with no connection set. Previously, we would set the "connection" field to a temporary NMConnection. Now NMManager piggybacks this temporary connection as object-data (TAG_ACTIVE_CONNETION_ADD_AND_ACTIVATE). - get rid of the functions nm_active_connection_get_connection_type() and nm_active_connection_get_connection_uuid(). From their names it is unclear whether this returns the settings or applied connection. The (few) callers should figure that out themselves. - rename nm_active_connection_get_id() to nm_active_connection_get_settings_connection_id(). This function is only used internally for logging. - dispatcher calls now get two connections as well. The applied-connection is used for the connection data, while the settings-connection is used for the connection path. - needs special handling for properties that apply immediately when changed (nm_device_reapply_settings_immediately()). Co-Authored-By: Thomas Haller <thaller@redhat.com> https://bugzilla.gnome.org/show_bug.cgi?id=724041
2015-07-14 16:53:24 +02:00
_audit_field_init_string(&uuid_field,
"uuid",
nm_settings_connection_get_uuid(connection),
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
FALSE,
BACKEND_ALL);
g_ptr_array_add(fields, &uuid_field);
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: separate active and applied connection Clone the connection upon activation. This makes it safe for the user to modify the original connection while it is activated. This involves several changes: - NMActiveConnection gets @settings_connection and @applied_connection. To support add-and-activate, we constructing a NMActiveConnection with no connection set. Previously, we would set the "connection" field to a temporary NMConnection. Now NMManager piggybacks this temporary connection as object-data (TAG_ACTIVE_CONNETION_ADD_AND_ACTIVATE). - get rid of the functions nm_active_connection_get_connection_type() and nm_active_connection_get_connection_uuid(). From their names it is unclear whether this returns the settings or applied connection. The (few) callers should figure that out themselves. - rename nm_active_connection_get_id() to nm_active_connection_get_settings_connection_id(). This function is only used internally for logging. - dispatcher calls now get two connections as well. The applied-connection is used for the connection data, while the settings-connection is used for the connection path. - needs special handling for properties that apply immediately when changed (nm_device_reapply_settings_immediately()). Co-Authored-By: Thomas Haller <thaller@redhat.com> https://bugzilla.gnome.org/show_bug.cgi?id=724041
2015-07-14 16:53:24 +02:00
_audit_field_init_string(&name_field,
"name",
nm_settings_connection_get_id(connection),
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
TRUE,
BACKEND_ALL);
g_ptr_array_add(fields, &name_field);
}
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
audit: log changed properties when updating a connection The main purpose of audit logging is to understand who did what to the system configuration, so it is useful to log also the list of changed properties when a connection is updated: op="connection-update" uuid="2f3e48fc-5f47-41d9-9278-d2871378df43" name="pppoe1" args="pppoe.username,pppoe.password" <======== pid=9523 uid=1001 result="success"
2016-04-20 12:10:55 +02:00
if (args) {
_audit_field_init_string(&args_field, "args", args, FALSE, BACKEND_ALL);
g_ptr_array_add(fields, &args_field);
}
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
audit: allow passing GDBusMethodInvocation context to audit methods
2016-01-07 16:31:19 +01:00
_audit_log_helper(self, fields, file, line, func, op, result, subject_context, reason);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
void
checkpoint: add audit support
2016-08-01 17:19:14 +02:00
_nm_audit_manager_log_generic_op(NMAuditManager *self,
const char * file,
guint line,
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
const char * func,
const char * op,
const char * arg,
audit: allow passing GDBusMethodInvocation context to audit methods
2016-01-07 16:31:19 +01:00
gboolean result,
gpointer subject_context,
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
const char * reason)
{
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
gs_unref_ptrarray GPtrArray *fields = NULL;
AuditField arg_field;
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
g_return_if_fail(op);
g_return_if_fail(arg);
fields = g_ptr_array_new();
_audit_field_init_string(&arg_field, "arg", arg, TRUE, BACKEND_ALL);
g_ptr_array_add(fields, &arg_field);
audit: allow passing GDBusMethodInvocation context to audit methods
2016-01-07 16:31:19 +01:00
_audit_log_helper(self, fields, file, line, func, op, result, subject_context, reason);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
void
_nm_audit_manager_log_device_op(NMAuditManager *self,
const char * file,
guint line,
const char * func,
const char * op,
NMDevice * device,
audit: add @args to device logging functions
2017-03-04 00:06:59 +01:00
gboolean result,
const char * args,
gpointer subject_context,
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
const char * reason)
{
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
gs_unref_ptrarray GPtrArray *fields = NULL;
AuditField interface_field;
AuditField ifindex_field;
AuditField args_field;
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
int ifindex;
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
g_return_if_fail(op);
g_return_if_fail(device);
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
fields = g_ptr_array_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
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
_audit_field_init_string(&interface_field,
"interface",
nm_device_get_ip_iface(device),
TRUE,
BACKEND_ALL);
g_ptr_array_add(fields, &interface_field);
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
ifindex = nm_device_get_ip_ifindex(device);
if (ifindex > 0) {
audit: don't use GValue for tracking values in AuditField struct When using a GValue, we really should call g_value_unset(). Otherwise it is a code smell, even if we technically only created GValue with static strings and integers. But changing that is not easy, because the AuditField structs are allocated on the stack, and in different functions. So we cannot just pass a GDestroyNotify to GPtrArray to cleanup all those fields, because by then they will be out of scope. The proper solution would be to heap allocate the AuditField struct, add them to the GPtrArray, and free them with the free function. But that seams really unnecessary overhead, for something that is correct in practice. Let's accept the fact that by the time the fields array gets destroyed, it contains dangling pointers. If we already embrace the dangling pointers and that stuff is allocated on the stack and that we don't need to free, also get rid of GValue and use our plain NMValueType and NMValueTypUnion. GValue really doesn't give us much here. And it only makes us wonder: is it OK to not call g_value_unset()? With the plain tracking of the values, we know that it is OK.
2021-04-09 14:08:00 +02:00
_audit_field_init_uint64(&ifindex_field, "ifindex", ifindex, BACKEND_ALL);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
g_ptr_array_add(fields, &ifindex_field);
}
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
audit: add @args to device logging functions
2017-03-04 00:06:59 +01:00
if (args) {
_audit_field_init_string(&args_field, "args", args, FALSE, BACKEND_ALL);
g_ptr_array_add(fields, &args_field);
}
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
audit: allow passing GDBusMethodInvocation context to audit methods
2016-01-07 16:31:19 +01:00
_audit_log_helper(self, fields, file, line, func, op, result, subject_context, reason);
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
#if HAVE_LIBAUDIT
static void
init_auditd(NMAuditManager *self)
{
NMAuditManagerPrivate *priv = NM_AUDIT_MANAGER_GET_PRIVATE(self);
NMConfigData * data = nm_config_get_data(priv->config);
all: cache errno in local variable before using it
2019-01-31 13:29:21 +01:00
int errsv;
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
if (nm_config_data_get_value_boolean(data,
NM_CONFIG_KEYFILE_GROUP_LOGGING,
config: use macros for config keys Every configuration option should be listed in the header file.
2018-11-09 18:05:04 +01:00
NM_CONFIG_KEYFILE_KEY_LOGGING_AUDIT,
config: print default value for logging.audit
2016-10-06 22:14:01 +02:00
NM_CONFIG_DEFAULT_LOGGING_AUDIT_BOOL)) {
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
if (priv->auditd_fd < 0) {
priv->auditd_fd = audit_open();
all: cache errno in local variable before using it
2019-01-31 13:29:21 +01:00
if (priv->auditd_fd < 0) {
errsv = errno;
all: replace strerror() calls with nm_strerror_native()
2019-01-31 17:22:18 +01:00
_LOGE(LOGD_CORE, "failed to open auditd socket: %s", nm_strerror_native(errsv));
all: cache errno in local variable before using it
2019-01-31 13:29:21 +01:00
} else
audit: use logging helpers
2016-03-03 09:20:23 +01:00
_LOGD(LOGD_CORE, "socket created");
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
} else {
if (priv->auditd_fd >= 0) {
audit_close(priv->auditd_fd);
priv->auditd_fd = -1;
audit: use logging helpers
2016-03-03 09:20:23 +01:00
_LOGD(LOGD_CORE, "socket closed");
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
}
}
}
static void
config_changed_cb(NMConfig * config,
NMConfigData * config_data,
NMConfigChangeFlags changes,
NMConfigData * old_data,
NMAuditManager * self)
{
if (NM_FLAGS_HAS(changes, NM_CONFIG_CHANGE_VALUES))
init_auditd(self);
}
#endif
core: refactor private data in "src" - use _NM_GET_PRIVATE() and _NM_GET_PRIVATE_PTR() everywhere. - reorder statements, to have GObject related functions (init, dispose, constructed) at the bottom of each file and in a consistent order w.r.t. each other. - unify whitespaces in signal and properties declarations. - use NM_GOBJECT_PROPERTIES_DEFINE() and _notify() - drop unused signal slots in class structures - drop unused header files for device factories
2016-09-29 13:49:01 +02:00
/*****************************************************************************/
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
static void
nm_audit_manager_init(NMAuditManager *self)
{
#if HAVE_LIBAUDIT
NMAuditManagerPrivate *priv = NM_AUDIT_MANAGER_GET_PRIVATE(self);
priv->config = g_object_ref(nm_config_get());
g_signal_connect(G_OBJECT(priv->config),
NM_CONFIG_SIGNAL_CONFIG_CHANGED,
G_CALLBACK(config_changed_cb),
self);
priv->auditd_fd = -1;
init_auditd(self);
#endif
}
static void
dispose(GObject *object)
{
#if HAVE_LIBAUDIT
NMAuditManager * self = NM_AUDIT_MANAGER(object);
NMAuditManagerPrivate *priv = NM_AUDIT_MANAGER_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
core: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
if (priv->config) {
g_signal_handlers_disconnect_by_func(priv->config, config_changed_cb, self);
g_clear_object(&priv->config);
}
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: add audit support Introduce some primitives to deliver messages about relevant configuration changes to the Linux audit subsystem through libaudit (if enabled at build time) and to the logging system.
2015-07-20 18:33:35 +02:00
if (priv->auditd_fd >= 0) {
audit_close(priv->auditd_fd);
priv->auditd_fd = -1;
}
#endif
G_OBJECT_CLASS(nm_audit_manager_parent_class)->dispose(object);
}
static void
nm_audit_manager_class_init(NMAuditManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->dispose = dispose;
}
Reference in a new issue Copy permalink