diff options
Diffstat (limited to 'src/nm-core-utils.c')
| -rw-r--r-- | src/nm-core-utils.c | 7577 |
1 files changed, 4037 insertions, 3540 deletions
diff --git a/src/nm-core-utils.c b/src/nm-core-utils.c index 3950c3c3..7adc011e 100644 --- a/src/nm-core-utils.c +++ b/src/nm-core-utils.c @@ -1,4 +1,4 @@ -// SPDX-License-Identifier: GPL-2.0+ +/* SPDX-License-Identifier: GPL-2.0+ */ /* * Copyright (C) 2004 - 2018 Red Hat, Inc. * Copyright (C) 2005 - 2008 Novell, Inc. @@ -36,10 +36,11 @@ #include "nm-setting-wireless-security.h" #ifdef __NM_SD_UTILS_H__ -#error "nm-core-utils.c should stay independent of systemd utils. Are you looking for NetworkMangerUtils.c? " + #error \ + "nm-core-utils.c should stay independent of systemd utils. Are you looking for NetworkMangerUtils.c? " #endif -G_STATIC_ASSERT (sizeof (NMUtilsTestFlags) <= sizeof (int)); +G_STATIC_ASSERT(sizeof(NMUtilsTestFlags) <= sizeof(int)); /* we read _nm_utils_testing without memory barrier. This is thread-safe, * because the static variable is initialized to zero, and only reset @@ -54,120 +55,120 @@ G_STATIC_ASSERT (sizeof (NMUtilsTestFlags) <= sizeof (int)); static int _nm_utils_testing = 0; gboolean -nm_utils_get_testing_initialized () +nm_utils_get_testing_initialized() { - NMUtilsTestFlags flags; + NMUtilsTestFlags flags; - flags = (NMUtilsTestFlags) _nm_utils_testing; - if (flags == NM_UTILS_TEST_NONE) - flags = (NMUtilsTestFlags) g_atomic_int_get (&_nm_utils_testing); - return flags != NM_UTILS_TEST_NONE; + flags = (NMUtilsTestFlags) _nm_utils_testing; + if (flags == NM_UTILS_TEST_NONE) + flags = (NMUtilsTestFlags) g_atomic_int_get(&_nm_utils_testing); + return flags != NM_UTILS_TEST_NONE; } NMUtilsTestFlags -nm_utils_get_testing () +nm_utils_get_testing() { - NMUtilsTestFlags flags; + NMUtilsTestFlags flags; again: - flags = (NMUtilsTestFlags) _nm_utils_testing; - if (flags != NM_UTILS_TEST_NONE) { - /* Flags already initialized. Return them. */ - return flags & NM_UTILS_TEST_ALL; - } - - /* Accessing nm_utils_get_testing() causes us to set the flags to initialized. - * Detecting running tests also based on g_test_initialized(). */ - flags = _NM_UTILS_TEST_INITIALIZED; - if (g_test_initialized ()) - flags |= _NM_UTILS_TEST_GENERAL; - - g_atomic_int_compare_and_exchange (&_nm_utils_testing, 0, (int) flags); - - /* regardless of whether we won the race of initializing _nm_utils_testing, - * go back and read the value again. It must be non-zero by now. */ - goto again; + flags = (NMUtilsTestFlags) _nm_utils_testing; + if (flags != NM_UTILS_TEST_NONE) { + /* Flags already initialized. Return them. */ + return flags & NM_UTILS_TEST_ALL; + } + + /* Accessing nm_utils_get_testing() causes us to set the flags to initialized. + * Detecting running tests also based on g_test_initialized(). */ + flags = _NM_UTILS_TEST_INITIALIZED; + if (g_test_initialized()) + flags |= _NM_UTILS_TEST_GENERAL; + + g_atomic_int_compare_and_exchange(&_nm_utils_testing, 0, (int) flags); + + /* regardless of whether we won the race of initializing _nm_utils_testing, + * go back and read the value again. It must be non-zero by now. */ + goto again; } void -_nm_utils_set_testing (NMUtilsTestFlags flags) +_nm_utils_set_testing(NMUtilsTestFlags flags) { - g_assert (!NM_FLAGS_ANY (flags, ~NM_UTILS_TEST_ALL)); + g_assert(!NM_FLAGS_ANY(flags, ~NM_UTILS_TEST_ALL)); - /* mask out everything except ALL, and always set GENERAL. */ - flags = (flags & NM_UTILS_TEST_ALL) | (_NM_UTILS_TEST_GENERAL | _NM_UTILS_TEST_INITIALIZED); + /* mask out everything except ALL, and always set GENERAL. */ + flags = (flags & NM_UTILS_TEST_ALL) | (_NM_UTILS_TEST_GENERAL | _NM_UTILS_TEST_INITIALIZED); - if (!g_atomic_int_compare_and_exchange (&_nm_utils_testing, 0, (int) flags)) { - /* We only allow setting _nm_utils_set_testing() once, before fetching the - * value with nm_utils_get_testing(). */ - g_return_if_reached (); - } + if (!g_atomic_int_compare_and_exchange(&_nm_utils_testing, 0, (int) flags)) { + /* We only allow setting _nm_utils_set_testing() once, before fetching the + * value with nm_utils_get_testing(). */ + g_return_if_reached(); + } } /*****************************************************************************/ -static GSList *_singletons = NULL; +static GSList * _singletons = NULL; static gboolean _singletons_shutdown = FALSE; static void -_nm_singleton_instance_weak_cb (gpointer data, - GObject *where_the_object_was) +_nm_singleton_instance_weak_cb(gpointer data, GObject *where_the_object_was) { - nm_assert (g_slist_find (_singletons, where_the_object_was)); + nm_assert(g_slist_find(_singletons, where_the_object_was)); - _singletons = g_slist_remove (_singletons, where_the_object_was); + _singletons = g_slist_remove(_singletons, where_the_object_was); } -static void __attribute__((destructor)) -_nm_singleton_instance_destroy (void) +static void __attribute__((destructor)) _nm_singleton_instance_destroy(void) { - _singletons_shutdown = TRUE; + _singletons_shutdown = TRUE; - while (_singletons) { - GObject *instance = _singletons->data; + while (_singletons) { + GObject *instance = _singletons->data; - _singletons = g_slist_delete_link (_singletons, _singletons); + _singletons = g_slist_delete_link(_singletons, _singletons); - g_object_weak_unref (instance, _nm_singleton_instance_weak_cb, NULL); + g_object_weak_unref(instance, _nm_singleton_instance_weak_cb, NULL); - if (instance->ref_count > 1) { - nm_log_dbg (LOGD_CORE, "disown %s singleton ("NM_HASH_OBFUSCATE_PTR_FMT")", - G_OBJECT_TYPE_NAME (instance), NM_HASH_OBFUSCATE_PTR (instance)); - } + if (instance->ref_count > 1) { + nm_log_dbg(LOGD_CORE, + "disown %s singleton (" NM_HASH_OBFUSCATE_PTR_FMT ")", + G_OBJECT_TYPE_NAME(instance), + NM_HASH_OBFUSCATE_PTR(instance)); + } - g_object_unref (instance); - } + g_object_unref(instance); + } } void -_nm_singleton_instance_register_destruction (GObject *instance) +_nm_singleton_instance_register_destruction(GObject *instance) { - g_return_if_fail (G_IS_OBJECT (instance)); + g_return_if_fail(G_IS_OBJECT(instance)); - /* Don't allow registration after shutdown. We only destroy the singletons - * once. */ - g_return_if_fail (!_singletons_shutdown); + /* Don't allow registration after shutdown. We only destroy the singletons + * once. */ + g_return_if_fail(!_singletons_shutdown); - g_object_weak_ref (instance, _nm_singleton_instance_weak_cb, NULL); + g_object_weak_ref(instance, _nm_singleton_instance_weak_cb, NULL); - _singletons = g_slist_prepend (_singletons, instance); + _singletons = g_slist_prepend(_singletons, instance); } /*****************************************************************************/ static double -_exp10 (guint16 ex) +_exp10(guint16 ex) { - double v; + double v; - if (ex == 0) - return 1.0; + if (ex == 0) + return 1.0; - v = _exp10 (ex / 2); - v = v * v; - if (ex % 2) - v *= 10; - return v; + v = _exp10(ex / 2); + v = v * v; + if (ex % 2) + v *= 10; + return v; } /* @@ -177,11 +178,11 @@ _exp10 (guint16 ex) * Returns: 10^ex, or pow(10, ex), or exp10(ex). */ double -nm_utils_exp10 (gint16 ex) +nm_utils_exp10(gint16 ex) { - if (ex >= 0) - return _exp10 (ex); - return 1.0 / _exp10 (- ((gint32) ex)); + if (ex >= 0) + return _exp10(ex); + return 1.0 / _exp10(-((gint32) ex)); } /*****************************************************************************/ @@ -196,324 +197,380 @@ nm_utils_exp10 (gint16 ex) * Returns: %TRUE if @addr is a valid Ethernet address, %FALSE if it is not. */ gboolean -nm_ethernet_address_is_valid (gconstpointer addr, gssize len) +nm_ethernet_address_is_valid(gconstpointer addr, gssize len) { - guint8 invalid_addr[4][ETH_ALEN] = { - {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x44, 0x44, 0x44, 0x44, 0x44, 0x44}, - {0x00, 0x30, 0xb4, 0x00, 0x00, 0x00}, /* prism54 dummy MAC */ - }; - guint8 addr_bin[ETH_ALEN]; - guint i; - - if (!addr) { - g_return_val_if_fail (len == -1 || len == ETH_ALEN, FALSE); - return FALSE; - } - - if (len == -1) { - if (!nm_utils_hwaddr_aton (addr, addr_bin, ETH_ALEN)) - return FALSE; - addr = addr_bin; - } else if (len != ETH_ALEN) - g_return_val_if_reached (FALSE); - - /* Check for multicast address */ - if ((((guint8 *) addr)[0]) & 0x01) - return FALSE; - - for (i = 0; i < G_N_ELEMENTS (invalid_addr); i++) { - if (nm_utils_hwaddr_matches (addr, ETH_ALEN, invalid_addr[i], ETH_ALEN)) - return FALSE; - } - - return TRUE; + guint8 invalid_addr[4][ETH_ALEN] = { + {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + {0x44, 0x44, 0x44, 0x44, 0x44, 0x44}, + {0x00, 0x30, 0xb4, 0x00, 0x00, 0x00}, /* prism54 dummy MAC */ + }; + guint8 addr_bin[ETH_ALEN]; + guint i; + + if (!addr) { + g_return_val_if_fail(len == -1 || len == ETH_ALEN, FALSE); + return FALSE; + } + + if (len == -1) { + if (!nm_utils_hwaddr_aton(addr, addr_bin, ETH_ALEN)) + return FALSE; + addr = addr_bin; + } else if (len != ETH_ALEN) + g_return_val_if_reached(FALSE); + + /* Check for multicast address */ + if ((((guint8 *) addr)[0]) & 0x01) + return FALSE; + + for (i = 0; i < G_N_ELEMENTS(invalid_addr); i++) { + if (nm_utils_hwaddr_matches(addr, ETH_ALEN, invalid_addr[i], ETH_ALEN)) + return FALSE; + } + + return TRUE; } /*****************************************************************************/ void -nm_utils_array_remove_at_indexes (GArray *array, const guint *indexes_to_delete, gsize len) +nm_utils_array_remove_at_indexes(GArray *array, const guint *indexes_to_delete, gsize len) { - gsize elt_size; - guint index_to_delete; - guint i_src; - guint mm_src, mm_dst, mm_len; - gsize i_itd; - guint res_length; - - g_return_if_fail (array); - if (!len) - return; - g_return_if_fail (indexes_to_delete); - - elt_size = g_array_get_element_size (array); - - i_itd = 0; - index_to_delete = indexes_to_delete[0]; - if (index_to_delete >= array->len) - g_return_if_reached (); - - res_length = array->len - 1; - - mm_dst = index_to_delete; - mm_src = index_to_delete; - mm_len = 0; - - for (i_src = index_to_delete; i_src < array->len; i_src++) { - if (i_src < index_to_delete) - mm_len++; - else { - /* we require indexes_to_delete to contain non-repeated, ascending - * indexes. Otherwise we would need to presort the indexes. */ - while (TRUE) { - guint dd; - - if (i_itd + 1 >= len) { - index_to_delete = G_MAXUINT; - break; - } - - dd = indexes_to_delete[++i_itd]; - if (dd > index_to_delete) { - if (dd >= array->len) - g_warn_if_reached (); - else { - g_assert (res_length > 0); - res_length--; - } - index_to_delete = dd; - break; - } - g_warn_if_reached (); - } - - if (mm_len) { - memmove (&array->data[mm_dst * elt_size], - &array->data[mm_src * elt_size], - mm_len * elt_size); - mm_dst += mm_len; - mm_src += mm_len + 1; - mm_len = 0; - } else - mm_src++; - } - } - if (mm_len) { - memmove (&array->data[mm_dst * elt_size], - &array->data[mm_src * elt_size], - mm_len * elt_size); - } - g_array_set_size (array, res_length); + gsize elt_size; + guint index_to_delete; + guint i_src; + guint mm_src, mm_dst, mm_len; + gsize i_itd; + guint res_length; + + g_return_if_fail(array); + if (!len) + return; + g_return_if_fail(indexes_to_delete); + + elt_size = g_array_get_element_size(array); + + i_itd = 0; + index_to_delete = indexes_to_delete[0]; + if (index_to_delete >= array->len) + g_return_if_reached(); + + res_length = array->len - 1; + + mm_dst = index_to_delete; + mm_src = index_to_delete; + mm_len = 0; + + for (i_src = index_to_delete; i_src < array->len; i_src++) { + if (i_src < index_to_delete) + mm_len++; + else { + /* we require indexes_to_delete to contain non-repeated, ascending + * indexes. Otherwise, we would need to presort the indexes. */ + while (TRUE) { + guint dd; + + if (i_itd + 1 >= len) { + index_to_delete = G_MAXUINT; + break; + } + + dd = indexes_to_delete[++i_itd]; + if (dd > index_to_delete) { + if (dd >= array->len) + g_warn_if_reached(); + else { + g_assert(res_length > 0); + res_length--; + } + index_to_delete = dd; + break; + } + g_warn_if_reached(); + } + + if (mm_len) { + memmove(&array->data[mm_dst * elt_size], + &array->data[mm_src * elt_size], + mm_len * elt_size); + mm_dst += mm_len; + mm_src += mm_len + 1; + mm_len = 0; + } else + mm_src++; + } + } + if (mm_len) { + memmove(&array->data[mm_dst * elt_size], + &array->data[mm_src * elt_size], + mm_len * elt_size); + } + g_array_set_size(array, res_length); } static const char * -_trunk_first_line (char *str) +_trunk_first_line(char *str) { - char *s; + char *s; - s = strchr (str, '\n'); - if (s) - s[0] = '\0'; - return str; + s = strchr(str, '\n'); + if (s) + s[0] = '\0'; + return str; } int -nm_utils_modprobe (GError **error, gboolean suppress_error_logging, const char *arg1, ...) +nm_utils_modprobe(GError **error, gboolean suppress_error_logging, const char *arg1, ...) { - gs_unref_ptrarray GPtrArray *argv = NULL; - int exit_status; - gs_free char *_log_str = NULL; -#define ARGV_TO_STR(argv) (_log_str ? _log_str : (_log_str = g_strjoinv (" ", (char **) argv->pdata))) - GError *local = NULL; - va_list ap; - NMLogLevel llevel = suppress_error_logging ? LOGL_DEBUG : LOGL_ERR; - gs_free char *std_out = NULL, *std_err = NULL; - - g_return_val_if_fail (!error || !*error, -1); - g_return_val_if_fail (arg1, -1); - - /* construct the argument list */ - argv = g_ptr_array_sized_new (4); - g_ptr_array_add (argv, "/sbin/modprobe"); - g_ptr_array_add (argv, "--use-blacklist"); - g_ptr_array_add (argv, (char *) arg1); - - va_start (ap, arg1); - while ((arg1 = va_arg (ap, const char *))) - g_ptr_array_add (argv, (char *) arg1); - va_end (ap); - - g_ptr_array_add (argv, NULL); - - nm_log_dbg (LOGD_CORE, "modprobe: '%s'", ARGV_TO_STR (argv)); - if (!g_spawn_sync (NULL, (char **) argv->pdata, NULL, 0, NULL, NULL, &std_out, &std_err, &exit_status, &local)) { - nm_log (llevel, LOGD_CORE, NULL, NULL, "modprobe: '%s' failed: %s", ARGV_TO_STR (argv), local->message); - g_propagate_error (error, local); - return -1; - } else if (exit_status != 0) { - nm_log (llevel, LOGD_CORE, NULL, NULL, "modprobe: '%s' exited with error %d%s%s%s%s%s%s", ARGV_TO_STR (argv), exit_status, - std_out&&*std_out ? " (" : "", std_out&&*std_out ? _trunk_first_line (std_out) : "", std_out&&*std_out ? ")" : "", - std_err&&*std_err ? " (" : "", std_err&&*std_err ? _trunk_first_line (std_err) : "", std_err&&*std_err ? ")" : ""); - } - - return exit_status; + gs_unref_ptrarray GPtrArray *argv = NULL; + int exit_status; + gs_free char * _log_str = NULL; +#define ARGV_TO_STR(argv) \ + (_log_str ? _log_str : (_log_str = g_strjoinv(" ", (char **) argv->pdata))) + GError * local = NULL; + va_list ap; + NMLogLevel llevel = suppress_error_logging ? LOGL_DEBUG : LOGL_ERR; + gs_free char *std_out = NULL, *std_err = NULL; + + g_return_val_if_fail(!error || !*error, -1); + g_return_val_if_fail(arg1, -1); + + /* construct the argument list */ + argv = g_ptr_array_sized_new(4); + g_ptr_array_add(argv, "/sbin/modprobe"); + g_ptr_array_add(argv, "--use-blacklist"); + g_ptr_array_add(argv, (char *) arg1); + + va_start(ap, arg1); + while ((arg1 = va_arg(ap, const char *))) + g_ptr_array_add(argv, (char *) arg1); + va_end(ap); + + g_ptr_array_add(argv, NULL); + + nm_log_dbg(LOGD_CORE, "modprobe: '%s'", ARGV_TO_STR(argv)); + if (!g_spawn_sync(NULL, + (char **) argv->pdata, + NULL, + 0, + NULL, + NULL, + &std_out, + &std_err, + &exit_status, + &local)) { + nm_log(llevel, + LOGD_CORE, + NULL, + NULL, + "modprobe: '%s' failed: %s", + ARGV_TO_STR(argv), + local->message); + g_propagate_error(error, local); + return -1; + } else if (exit_status != 0) { + nm_log(llevel, + LOGD_CORE, + NULL, + NULL, + "modprobe: '%s' exited with error %d%s%s%s%s%s%s", + ARGV_TO_STR(argv), + exit_status, + std_out && *std_out ? " (" : "", + std_out && *std_out ? _trunk_first_line(std_out) : "", + std_out && *std_out ? ")" : "", + std_err && *std_err ? " (" : "", + std_err && *std_err ? _trunk_first_line(std_err) : "", + std_err && *std_err ? ")" : ""); + } + + return exit_status; } /*****************************************************************************/ typedef struct { - pid_t pid; - NMLogDomain log_domain; - union { - struct { - gint64 wait_start_us; - guint source_timeout_kill_id; - } async; - struct { - gboolean success; - int child_status; - } sync; - }; - NMUtilsKillChildAsyncCb callback; - void *user_data; - - char log_name[1]; /* variable-length object, must be last element!! */ + pid_t pid; + NMLogDomain log_domain; + union { + struct { + gint64 wait_start_us; + guint source_timeout_kill_id; + } async; + struct { + gboolean success; + int child_status; + } sync; + }; + NMUtilsKillChildAsyncCb callback; + void * user_data; + + char log_name[1]; /* variable-length object, must be last element!! */ } KillChildAsyncData; -#define LOG_NAME_FMT "kill child process '%s' (%ld)" +#define LOG_NAME_FMT "kill child process '%s' (%ld)" #define LOG_NAME_PROCESS_FMT "kill process '%s' (%ld)" -#define LOG_NAME_ARGS log_name,(long)pid +#define LOG_NAME_ARGS log_name, (long) pid static KillChildAsyncData * -_kc_async_data_alloc (pid_t pid, NMLogDomain log_domain, const char *log_name, NMUtilsKillChildAsyncCb callback, void *user_data) +_kc_async_data_alloc(pid_t pid, + NMLogDomain log_domain, + const char * log_name, + NMUtilsKillChildAsyncCb callback, + void * user_data) { - KillChildAsyncData *data; - size_t log_name_len; + KillChildAsyncData *data; + size_t log_name_len; - /* append the name at the end of our KillChildAsyncData. */ - log_name_len = strlen (LOG_NAME_FMT) + 20 + strlen (log_name); - data = g_malloc (sizeof (KillChildAsyncData) - 1 + log_name_len); - g_snprintf (data->log_name, log_name_len, LOG_NAME_FMT, LOG_NAME_ARGS); + /* append the name at the end of our KillChildAsyncData. */ + log_name_len = strlen(LOG_NAME_FMT) + 20 + strlen(log_name); + data = g_malloc(sizeof(KillChildAsyncData) - 1 + log_name_len); + g_snprintf(data->log_name, log_name_len, LOG_NAME_FMT, LOG_NAME_ARGS); - data->pid = pid; - data->user_data = user_data; - data->callback = callback; - data->log_domain = log_domain; + data->pid = pid; + data->user_data = user_data; + data->callback = callback; + data->log_domain = log_domain; - return data; + return data; } #define KC_EXIT_TO_STRING_BUF_SIZE 128 static const char * -_kc_exit_to_string (char *buf, int exit) -#define _kc_exit_to_string(buf, exit) ( G_STATIC_ASSERT_EXPR(sizeof (buf) == KC_EXIT_TO_STRING_BUF_SIZE && sizeof ((buf)[0]) == 1), _kc_exit_to_string (buf, exit) ) +_kc_exit_to_string(char *buf, int exit) +#define _kc_exit_to_string(buf, exit) \ + (G_STATIC_ASSERT_EXPR(sizeof(buf) == KC_EXIT_TO_STRING_BUF_SIZE && sizeof((buf)[0]) == 1), \ + _kc_exit_to_string(buf, exit)) { - if (WIFEXITED (exit)) - g_snprintf (buf, KC_EXIT_TO_STRING_BUF_SIZE, "normally with status %d", WEXITSTATUS (exit)); - else if (WIFSIGNALED (exit)) - g_snprintf (buf, KC_EXIT_TO_STRING_BUF_SIZE, "by signal %d", WTERMSIG (exit)); - else - g_snprintf (buf, KC_EXIT_TO_STRING_BUF_SIZE, "with unexpected status %d", exit); - return buf; + if (WIFEXITED(exit)) + g_snprintf(buf, KC_EXIT_TO_STRING_BUF_SIZE, "normally with status %d", WEXITSTATUS(exit)); + else if (WIFSIGNALED(exit)) + g_snprintf(buf, KC_EXIT_TO_STRING_BUF_SIZE, "by signal %d", WTERMSIG(exit)); + else + g_snprintf(buf, KC_EXIT_TO_STRING_BUF_SIZE, "with unexpected status %d", exit); + return buf; } static const char * -_kc_signal_to_string (int sig) +_kc_signal_to_string(int sig) { - switch (sig) { - case 0: return "no signal (0)"; - case SIGKILL: return "SIGKILL (" G_STRINGIFY (SIGKILL) ")"; - case SIGTERM: return "SIGTERM (" G_STRINGIFY (SIGTERM) ")"; - default: - return "Unexpected signal"; - } + switch (sig) { + case 0: + return "no signal (0)"; + case SIGKILL: + return "SIGKILL (" G_STRINGIFY(SIGKILL) ")"; + case SIGTERM: + return "SIGTERM (" G_STRINGIFY(SIGTERM) ")"; + default: + return "Unexpected signal"; + } } #define KC_WAITED_TO_STRING 100 static const char * -_kc_waited_to_string (char *buf, gint64 wait_start_us) -#define _kc_waited_to_string(buf, wait_start_us) ( G_STATIC_ASSERT_EXPR(sizeof (buf) == KC_WAITED_TO_STRING && sizeof ((buf)[0]) == 1), _kc_waited_to_string (buf, wait_start_us) ) +_kc_waited_to_string(char *buf, gint64 wait_start_us) +#define _kc_waited_to_string(buf, wait_start_us) \ + (G_STATIC_ASSERT_EXPR(sizeof(buf) == KC_WAITED_TO_STRING && sizeof((buf)[0]) == 1), \ + _kc_waited_to_string(buf, wait_start_us)) { - g_snprintf (buf, KC_WAITED_TO_STRING, " (%ld usec elapsed)", (long) (nm_utils_get_monotonic_timestamp_usec () - wait_start_us)); - return buf; + g_snprintf(buf, + KC_WAITED_TO_STRING, + " (%ld usec elapsed)", + (long) (nm_utils_get_monotonic_timestamp_usec() - wait_start_us)); + return buf; } static void -_kc_cb_watch_child (GPid pid, int status, gpointer user_data) +_kc_cb_watch_child(GPid pid, int status, gpointer user_data) { - KillChildAsyncData *data = user_data; - char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE], buf_wait[KC_WAITED_TO_STRING]; + KillChildAsyncData *data = user_data; + char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE], buf_wait[KC_WAITED_TO_STRING]; - if (data->async.source_timeout_kill_id) - g_source_remove (data->async.source_timeout_kill_id); + if (data->async.source_timeout_kill_id) + g_source_remove(data->async.source_timeout_kill_id); - nm_log_dbg (data->log_domain, "%s: terminated %s%s", - data->log_name, _kc_exit_to_string (buf_exit, status), - _kc_waited_to_string (buf_wait, data->async.wait_start_us)); + nm_log_dbg(data->log_domain, + "%s: terminated %s%s", + data->log_name, + _kc_exit_to_string(buf_exit, status), + _kc_waited_to_string(buf_wait, data->async.wait_start_us)); - if (data->callback) - data->callback (pid, TRUE, status, data->user_data); + if (data->callback) + data->callback(pid, TRUE, status, data->user_data); - g_free (data); + g_free(data); } static gboolean -_kc_cb_timeout_grace_period (void *user_data) +_kc_cb_timeout_grace_period(void *user_data) { - KillChildAsyncData *data = user_data; - int ret, errsv; - - data->async.source_timeout_kill_id = 0; - - if ((ret = kill (data->pid, SIGKILL)) != 0) { - errsv = errno; - /* ESRCH means, process does not exist or is already a zombie. */ - if (errsv != ESRCH) { - nm_log_err (LOGD_CORE | data->log_domain, "%s: kill(SIGKILL) returned unexpected return value %d: (%s, %d)", - data->log_name, ret, nm_strerror_native (errsv), errsv); - } - } else { - nm_log_dbg (data->log_domain, "%s: process not terminated after %ld usec. Sending SIGKILL signal", - data->log_name, (long) (nm_utils_get_monotonic_timestamp_usec () - data->async.wait_start_us)); - } - - return G_SOURCE_REMOVE; + KillChildAsyncData *data = user_data; + int ret, errsv; + + data->async.source_timeout_kill_id = 0; + + if ((ret = kill(data->pid, SIGKILL)) != 0) { + errsv = errno; + /* ESRCH means, process does not exist or is already a zombie. */ + if (errsv != ESRCH) { + nm_log_err(LOGD_CORE | data->log_domain, + "%s: kill(SIGKILL) returned unexpected return value %d: (%s, %d)", + data->log_name, + ret, + nm_strerror_native(errsv), + errsv); + } + } else { + nm_log_dbg(data->log_domain, + "%s: process not terminated after %ld usec. Sending SIGKILL signal", + data->log_name, + (long) (nm_utils_get_monotonic_timestamp_usec() - data->async.wait_start_us)); + } + + return G_SOURCE_REMOVE; } static gboolean -_kc_invoke_callback_idle (gpointer user_data) +_kc_invoke_callback_idle(gpointer user_data) { - KillChildAsyncData *data = user_data; + KillChildAsyncData *data = user_data; - if (data->sync.success) { - char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE]; + if (data->sync.success) { + char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE]; - nm_log_dbg (data->log_domain, "%s: invoke callback: terminated %s", - data->log_name, _kc_exit_to_string (buf_exit, data->sync.child_status)); - } else - nm_log_dbg (data->log_domain, "%s: invoke callback: killing child failed", data->log_name); + nm_log_dbg(data->log_domain, + "%s: invoke callback: terminated %s", + data->log_name, + _kc_exit_to_string(buf_exit, data->sync.child_status)); + } else + nm_log_dbg(data->log_domain, "%s: invoke callback: killing child failed", data->log_name); - data->callback (data->pid, data->sync.success, data->sync.child_status, data->user_data); - g_free (data); + data->callback(data->pid, data->sync.success, data->sync.child_status, data->user_data); + g_free(data); - return G_SOURCE_REMOVE; + return G_SOURCE_REMOVE; } static void -_kc_invoke_callback (pid_t pid, NMLogDomain log_domain, const char *log_name, NMUtilsKillChildAsyncCb callback, void *user_data, gboolean success, int child_status) +_kc_invoke_callback(pid_t pid, + NMLogDomain log_domain, + const char * log_name, + NMUtilsKillChildAsyncCb callback, + void * user_data, + gboolean success, + int child_status) { - KillChildAsyncData *data; + KillChildAsyncData *data; - if (!callback) - return; + if (!callback) + return; - data = _kc_async_data_alloc (pid, log_domain, log_name, callback, user_data); - data->sync.success = success; - data->sync.child_status = child_status; + data = _kc_async_data_alloc(pid, log_domain, log_name, callback, user_data); + data->sync.success = success; + data->sync.child_status = child_status; - g_idle_add (_kc_invoke_callback_idle, data); + g_idle_add(_kc_invoke_callback_idle, data); } /* nm_utils_kill_child_async: @@ -534,87 +591,118 @@ _kc_invoke_callback (pid_t pid, NMLogDomain log_domain, const char *log_name, NM * supports only one watcher per child. **/ void -nm_utils_kill_child_async (pid_t pid, int sig, NMLogDomain log_domain, - const char *log_name, guint32 wait_before_kill_msec, - NMUtilsKillChildAsyncCb callback, void *user_data) +nm_utils_kill_child_async(pid_t pid, + int sig, + NMLogDomain log_domain, + const char * log_name, + guint32 wait_before_kill_msec, + NMUtilsKillChildAsyncCb callback, + void * user_data) { - int status = 0, errsv; - pid_t ret; - KillChildAsyncData *data; - char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE]; - - g_return_if_fail (pid > 0); - g_return_if_fail (log_name != NULL); - - /* let's see if the child already terminated... */ - ret = waitpid (pid, &status, WNOHANG); - if (ret > 0) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s", - LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status)); - _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, TRUE, status); - return; - } else if (ret != 0) { - errsv = errno; - /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */ - if (errsv != ECHILD) { - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": unexpected error while waitpid: %s (%d)", - LOG_NAME_ARGS, nm_strerror_native (errsv), errsv); - _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, FALSE, -1); - return; - } - } - - /* send the first signal. */ - if (kill (pid, sig) != 0) { - errsv = errno; - /* ESRCH means, process does not exist or is already a zombie. */ - if (errsv != ESRCH) { - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": unexpected error sending %s: %s (%d)", - LOG_NAME_ARGS, _kc_signal_to_string (sig), nm_strerror_native (errsv), errsv); - _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, FALSE, -1); - return; - } - - /* let's try again with waitpid, probably there was a race... */ - ret = waitpid (pid, &status, 0); - if (ret > 0) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s", - LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status)); - _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, TRUE, status); - } else { - errsv = errno; - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed due to unexpected return value %ld by waitpid (%s, %d) after sending %s", - LOG_NAME_ARGS, (long) ret, nm_strerror_native (errsv), errsv, _kc_signal_to_string (sig)); - _kc_invoke_callback (pid, log_domain, log_name, callback, user_data, FALSE, -1); - } - return; - } - - data = _kc_async_data_alloc (pid, log_domain, log_name, callback, user_data); - data->async.wait_start_us = nm_utils_get_monotonic_timestamp_usec (); - - if (sig != SIGKILL && wait_before_kill_msec > 0) { - data->async.source_timeout_kill_id = g_timeout_add (wait_before_kill_msec, _kc_cb_timeout_grace_period, data); - nm_log_dbg (log_domain, "%s: wait for process to terminate after sending %s (send SIGKILL in %ld milliseconds)...", - data->log_name, _kc_signal_to_string (sig), (long) wait_before_kill_msec); - } else { - data->async.source_timeout_kill_id = 0; - nm_log_dbg (log_domain, "%s: wait for process to terminate after sending %s...", - data->log_name, _kc_signal_to_string (sig)); - } - - g_child_watch_add (pid, _kc_cb_watch_child, data); + int status = 0, errsv; + pid_t ret; + KillChildAsyncData *data; + char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE]; + + g_return_if_fail(pid > 0); + g_return_if_fail(log_name != NULL); + + /* let's see if the child already terminated... */ + ret = waitpid(pid, &status, WNOHANG); + if (ret > 0) { + nm_log_dbg(log_domain, + LOG_NAME_FMT ": process %ld already terminated %s", + LOG_NAME_ARGS, + (long) ret, + _kc_exit_to_string(buf_exit, status)); + _kc_invoke_callback(pid, log_domain, log_name, callback, user_data, TRUE, status); + return; + } else if (ret != 0) { + errsv = errno; + /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */ + if (errsv != ECHILD) { + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": unexpected error while waitpid: %s (%d)", + LOG_NAME_ARGS, + nm_strerror_native(errsv), + errsv); + _kc_invoke_callback(pid, log_domain, log_name, callback, user_data, FALSE, -1); + return; + } + } + + /* send the first signal. */ + if (kill(pid, sig) != 0) { + errsv = errno; + /* ESRCH means, process does not exist or is already a zombie. */ + if (errsv != ESRCH) { + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": unexpected error sending %s: %s (%d)", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + nm_strerror_native(errsv), + errsv); + _kc_invoke_callback(pid, log_domain, log_name, callback, user_data, FALSE, -1); + return; + } + + /* let's try again with waitpid, probably there was a race... */ + ret = waitpid(pid, &status, 0); + if (ret > 0) { + nm_log_dbg(log_domain, + LOG_NAME_FMT ": process %ld already terminated %s", + LOG_NAME_ARGS, + (long) ret, + _kc_exit_to_string(buf_exit, status)); + _kc_invoke_callback(pid, log_domain, log_name, callback, user_data, TRUE, status); + } else { + errsv = errno; + nm_log_err( + LOGD_CORE | log_domain, + LOG_NAME_FMT + ": failed due to unexpected return value %ld by waitpid (%s, %d) after sending %s", + LOG_NAME_ARGS, + (long) ret, + nm_strerror_native(errsv), + errsv, + _kc_signal_to_string(sig)); + _kc_invoke_callback(pid, log_domain, log_name, callback, user_data, FALSE, -1); + } + return; + } + + data = _kc_async_data_alloc(pid, log_domain, log_name, callback, user_data); + data->async.wait_start_us = nm_utils_get_monotonic_timestamp_usec(); + + if (sig != SIGKILL && wait_before_kill_msec > 0) { + data->async.source_timeout_kill_id = + g_timeout_add(wait_before_kill_msec, _kc_cb_timeout_grace_period, data); + nm_log_dbg(log_domain, + "%s: wait for process to terminate after sending %s (send SIGKILL in %ld " + "milliseconds)...", + data->log_name, + _kc_signal_to_string(sig), + (long) wait_before_kill_msec); + } else { + data->async.source_timeout_kill_id = 0; + nm_log_dbg(log_domain, + "%s: wait for process to terminate after sending %s...", + data->log_name, + _kc_signal_to_string(sig)); + } + + g_child_watch_add(pid, _kc_cb_watch_child, data); } static gulong -_sleep_duration_convert_ms_to_us (guint32 sleep_duration_msec) +_sleep_duration_convert_ms_to_us(guint32 sleep_duration_msec) { - if (sleep_duration_msec > 0) { - guint64 x = (gint64) sleep_duration_msec * (guint64) 1000L; + if (sleep_duration_msec > 0) { + guint64 x = (gint64) sleep_duration_msec * (guint64) 1000L; - return x < G_MAXULONG ? (gulong) x : G_MAXULONG; - } - return G_USEC_PER_SEC / 20; + return x < G_MAXULONG ? (gulong) x : G_MAXULONG; + } + return G_USEC_PER_SEC / 20; } /* nm_utils_kill_child_sync: @@ -631,7 +719,7 @@ _sleep_duration_convert_ms_to_us (guint32 sleep_duration_msec) * Set to zero, to use the default (meaning 20 wakeups per seconds). * * Kill a child process synchronously and wait. The function first checks if the child already terminated - * and if it did, return the exit status. Otherwise send one @sig signal. @sig will always be + * and if it did, return the exit status. Otherwise, send one @sig signal. @sig will always be * sent unless the child already exited. If the child does not exit within @wait_before_kill_msec milliseconds, * the function will send %SIGKILL and waits for the child indefinitely. If @wait_before_kill_msec is zero, no * %SIGKILL signal will be sent. @@ -639,158 +727,212 @@ _sleep_duration_convert_ms_to_us (guint32 sleep_duration_msec) * In case of error, errno is preserved to contain the last reason of failure. **/ gboolean -nm_utils_kill_child_sync (pid_t pid, int sig, NMLogDomain log_domain, const char *log_name, - int *child_status, guint32 wait_before_kill_msec, - guint32 sleep_duration_msec) +nm_utils_kill_child_sync(pid_t pid, + int sig, + NMLogDomain log_domain, + const char *log_name, + int * child_status, + guint32 wait_before_kill_msec, + guint32 sleep_duration_msec) { - int status = 0, errsv = 0; - pid_t ret; - gboolean success = FALSE; - gboolean was_waiting = FALSE, send_kill = FALSE; - char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE]; - char buf_wait[KC_WAITED_TO_STRING]; - gint64 wait_start_us; - - g_return_val_if_fail (pid > 0, FALSE); - g_return_val_if_fail (log_name != NULL, FALSE); - - /* check if the child process already terminated... */ - ret = waitpid (pid, &status, WNOHANG); - if (ret > 0) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s", - LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status)); - success = TRUE; - goto out; - } else if (ret != 0) { - errsv = errno; - /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */ - if (errsv != ECHILD) { - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": unexpected error while waitpid: %s (%d)", - LOG_NAME_ARGS, nm_strerror_native (errsv), errsv); - goto out; - } - } - - /* send first signal @sig */ - if (kill (pid, sig) != 0) { - errsv = errno; - /* ESRCH means, process does not exist or is already a zombie. */ - if (errsv != ESRCH) { - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed to send %s: %s (%d)", - LOG_NAME_ARGS, _kc_signal_to_string (sig), nm_strerror_native (errsv), errsv); - } else { - /* let's try again with waitpid, probably there was a race... */ - ret = waitpid (pid, &status, 0); - if (ret > 0) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": process %ld already terminated %s", - LOG_NAME_ARGS, (long) ret, _kc_exit_to_string (buf_exit, status)); - success = TRUE; - } else { - errsv = errno; - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed due to unexpected return value %ld by waitpid (%s, %d) after sending %s", - LOG_NAME_ARGS, (long) ret, nm_strerror_native (errsv), errsv, _kc_signal_to_string (sig)); - } - } - goto out; - } - - wait_start_us = nm_utils_get_monotonic_timestamp_usec (); - - /* wait for the process to terminated... */ - if (sig != SIGKILL) { - gint64 wait_until, now; - gulong sleep_time, sleep_duration_usec; - int loop_count = 0; - - sleep_duration_usec = _sleep_duration_convert_ms_to_us (sleep_duration_msec); - wait_until = wait_before_kill_msec <= 0 ? 0 : wait_start_us + (((gint64) wait_before_kill_msec) * 1000L); - - while (TRUE) { - ret = waitpid (pid, &status, WNOHANG); - if (ret > 0) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": after sending %s, process %ld exited %s%s", - LOG_NAME_ARGS, _kc_signal_to_string (sig), (long) ret, _kc_exit_to_string (buf_exit, status), - was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : ""); - success = TRUE; - goto out; - } - if (ret == -1) { - errsv = errno; - /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */ - if (errsv != ECHILD) { - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": after sending %s, waitpid failed with %s (%d)%s", - LOG_NAME_ARGS, _kc_signal_to_string (sig), nm_strerror_native (errsv), errsv, - was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : ""); - goto out; - } - } - - if (!wait_until) - break; - - now = nm_utils_get_monotonic_timestamp_usec (); - if (now >= wait_until) - break; - - if (!was_waiting) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": waiting up to %ld milliseconds for process to terminate normally after sending %s...", - LOG_NAME_ARGS, (long) MAX (wait_before_kill_msec, 0), _kc_signal_to_string (sig)); - was_waiting = TRUE; - } - - sleep_time = MIN (wait_until - now, sleep_duration_usec); - if (loop_count < 20) { - /* At the beginning we expect the process to die fast. - * Limit the sleep time, the limit doubles with every iteration. */ - sleep_time = MIN (sleep_time, (((guint64) 1) << loop_count) * G_USEC_PER_SEC / 2000); - loop_count++; - } - g_usleep (sleep_time); - } - - /* send SIGKILL, if called with @wait_before_kill_msec > 0 */ - if (wait_until) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": sending SIGKILL...", LOG_NAME_ARGS); - - send_kill = TRUE; - if (kill (pid, SIGKILL) != 0) { - errsv = errno; - /* ESRCH means, process does not exist or is already a zombie. */ - if (errsv != ESRCH) { - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": failed to send SIGKILL (after sending %s), %s (%d)", - LOG_NAME_ARGS, _kc_signal_to_string (sig), nm_strerror_native (errsv), errsv); - goto out; - } - } - } - } - - if (!was_waiting) { - nm_log_dbg (log_domain, LOG_NAME_FMT ": waiting for process to terminate after sending %s%s...", - LOG_NAME_ARGS, _kc_signal_to_string (sig), send_kill ? " and SIGKILL" : ""); - } - - /* block until the child terminates. */ - while ((ret = waitpid (pid, &status, 0)) <= 0) { - errsv = errno; - - if (errsv != EINTR) { - nm_log_err (LOGD_CORE | log_domain, LOG_NAME_FMT ": after sending %s%s, waitpid failed with %s (%d)%s", - LOG_NAME_ARGS, _kc_signal_to_string (sig), send_kill ? " and SIGKILL" : "", nm_strerror_native (errsv), errsv, - _kc_waited_to_string (buf_wait, wait_start_us)); - goto out; - } - } - - nm_log_dbg (log_domain, LOG_NAME_FMT ": after sending %s%s, process %ld exited %s%s", - LOG_NAME_ARGS, _kc_signal_to_string (sig), send_kill ? " and SIGKILL" : "", (long) ret, - _kc_exit_to_string (buf_exit, status), _kc_waited_to_string (buf_wait, wait_start_us)); - success = TRUE; + int status = 0, errsv = 0; + pid_t ret; + gboolean success = FALSE; + gboolean was_waiting = FALSE, send_kill = FALSE; + char buf_exit[KC_EXIT_TO_STRING_BUF_SIZE]; + char buf_wait[KC_WAITED_TO_STRING]; + gint64 wait_start_us; + + g_return_val_if_fail(pid > 0, FALSE); + g_return_val_if_fail(log_name != NULL, FALSE); + + /* check if the child process already terminated... */ + ret = waitpid(pid, &status, WNOHANG); + if (ret > 0) { + nm_log_dbg(log_domain, + LOG_NAME_FMT ": process %ld already terminated %s", + LOG_NAME_ARGS, + (long) ret, + _kc_exit_to_string(buf_exit, status)); + success = TRUE; + goto out; + } else if (ret != 0) { + errsv = errno; + /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */ + if (errsv != ECHILD) { + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": unexpected error while waitpid: %s (%d)", + LOG_NAME_ARGS, + nm_strerror_native(errsv), + errsv); + goto out; + } + } + + /* send first signal @sig */ + if (kill(pid, sig) != 0) { + errsv = errno; + /* ESRCH means, process does not exist or is already a zombie. */ + if (errsv != ESRCH) { + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": failed to send %s: %s (%d)", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + nm_strerror_native(errsv), + errsv); + } else { + /* let's try again with waitpid, probably there was a race... */ + ret = waitpid(pid, &status, 0); + if (ret > 0) { + nm_log_dbg(log_domain, + LOG_NAME_FMT ": process %ld already terminated %s", + LOG_NAME_ARGS, + (long) ret, + _kc_exit_to_string(buf_exit, status)); + success = TRUE; + } else { + errsv = errno; + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": failed due to unexpected return value %ld by waitpid " + "(%s, %d) after sending %s", + LOG_NAME_ARGS, + (long) ret, + nm_strerror_native(errsv), + errsv, + _kc_signal_to_string(sig)); + } + } + goto out; + } + + wait_start_us = nm_utils_get_monotonic_timestamp_usec(); + + /* wait for the process to terminated... */ + if (sig != SIGKILL) { + gint64 wait_until, now; + gulong sleep_time, sleep_duration_usec; + int loop_count = 0; + + sleep_duration_usec = _sleep_duration_convert_ms_to_us(sleep_duration_msec); + wait_until = wait_before_kill_msec <= 0 + ? 0 + : wait_start_us + (((gint64) wait_before_kill_msec) * 1000L); + + while (TRUE) { + ret = waitpid(pid, &status, WNOHANG); + if (ret > 0) { + nm_log_dbg(log_domain, + LOG_NAME_FMT ": after sending %s, process %ld exited %s%s", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + (long) ret, + _kc_exit_to_string(buf_exit, status), + was_waiting ? _kc_waited_to_string(buf_wait, wait_start_us) : ""); + success = TRUE; + goto out; + } + if (ret == -1) { + errsv = errno; + /* ECHILD means, the process is not a child/does not exist or it has SIGCHILD blocked. */ + if (errsv != ECHILD) { + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": after sending %s, waitpid failed with %s (%d)%s", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + nm_strerror_native(errsv), + errsv, + was_waiting ? _kc_waited_to_string(buf_wait, wait_start_us) : ""); + goto out; + } + } + + if (!wait_until) + break; + + now = nm_utils_get_monotonic_timestamp_usec(); + if (now >= wait_until) + break; + + if (!was_waiting) { + nm_log_dbg(log_domain, + LOG_NAME_FMT ": waiting up to %ld milliseconds for process to terminate " + "normally after sending %s...", + LOG_NAME_ARGS, + (long) MAX(wait_before_kill_msec, 0), + _kc_signal_to_string(sig)); + was_waiting = TRUE; + } + + sleep_time = MIN(wait_until - now, sleep_duration_usec); + if (loop_count < 20) { + /* At the beginning we expect the process to die fast. + * Limit the sleep time, the limit doubles with every iteration. */ + sleep_time = MIN(sleep_time, (((guint64) 1) << loop_count) * G_USEC_PER_SEC / 2000); + loop_count++; + } + g_usleep(sleep_time); + } + + /* send SIGKILL, if called with @wait_before_kill_msec > 0 */ + if (wait_until) { + nm_log_dbg(log_domain, LOG_NAME_FMT ": sending SIGKILL...", LOG_NAME_ARGS); + + send_kill = TRUE; + if (kill(pid, SIGKILL) != 0) { + errsv = errno; + /* ESRCH means, process does not exist or is already a zombie. */ + if (errsv != ESRCH) { + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": failed to send SIGKILL (after sending %s), %s (%d)", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + nm_strerror_native(errsv), + errsv); + goto out; + } + } + } + } + + if (!was_waiting) { + nm_log_dbg(log_domain, + LOG_NAME_FMT ": waiting for process to terminate after sending %s%s...", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + send_kill ? " and SIGKILL" : ""); + } + + /* block until the child terminates. */ + while ((ret = waitpid(pid, &status, 0)) <= 0) { + errsv = errno; + + if (errsv != EINTR) { + nm_log_err(LOGD_CORE | log_domain, + LOG_NAME_FMT ": after sending %s%s, waitpid failed with %s (%d)%s", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + send_kill ? " and SIGKILL" : "", + nm_strerror_native(errsv), + errsv, + _kc_waited_to_string(buf_wait, wait_start_us)); + goto out; + } + } + + nm_log_dbg(log_domain, + LOG_NAME_FMT ": after sending %s%s, process %ld exited %s%s", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + send_kill ? " and SIGKILL" : "", + (long) ret, + _kc_exit_to_string(buf_exit, status), + _kc_waited_to_string(buf_wait, wait_start_us)); + success = TRUE; out: - if (child_status) - *child_status = success ? status : -1; - errno = success ? 0 : errsv; - return success; + if (child_status) + *child_status = success ? status : -1; + errno = success ? 0 : errsv; + return success; } /* nm_utils_kill_process_sync: @@ -817,195 +959,260 @@ out: * process with PID @pid is gone, the process is a zombie, or @max_wait_msec expires. **/ void -nm_utils_kill_process_sync (pid_t pid, guint64 start_time, int sig, NMLogDomain log_domain, - const char *log_name, guint32 wait_before_kill_msec, - guint32 sleep_duration_msec, guint32 max_wait_msec) +nm_utils_kill_process_sync(pid_t pid, + guint64 start_time, + int sig, + NMLogDomain log_domain, + const char *log_name, + guint32 wait_before_kill_msec, + guint32 sleep_duration_msec, + guint32 max_wait_msec) { - int errsv; - guint64 start_time0; - gint64 wait_until_sigkill, now, wait_start_us, max_wait_until; - gulong sleep_time, sleep_duration_usec; - int loop_count = 0; - gboolean was_waiting = FALSE; - char buf_wait[KC_WAITED_TO_STRING]; - char p_state; - - g_return_if_fail (pid > 0); - g_return_if_fail (log_name != NULL); - - start_time0 = nm_utils_get_start_time_for_pid (pid, &p_state, NULL); - if (start_time0 == 0) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": cannot kill process %ld because it seems already gone", - LOG_NAME_ARGS, (long int) pid); - return; - } - if (start_time != 0 && start_time != start_time0) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": don't kill process %ld because the start_time is unexpectedly %lu instead of %ld", - LOG_NAME_ARGS, (long int) pid, (unsigned long) start_time0, (unsigned long) start_time); - return; - } - - switch (p_state) { - case 'Z': - case 'x': - case 'X': - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": cannot kill process %ld because it is already a zombie (%c)", - LOG_NAME_ARGS, (long int) pid, p_state); - return; - default: - break; - } - - if (kill (pid, sig) != 0) { - errsv = errno; - /* ESRCH means, process does not exist or is already a zombie. */ - if (errsv == ESRCH) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": failed to send %s because process seems gone", - LOG_NAME_ARGS, _kc_signal_to_string (sig)); - } else { - nm_log_warn (LOGD_CORE | log_domain, LOG_NAME_PROCESS_FMT ": failed to send %s: %s (%d)", - LOG_NAME_ARGS, _kc_signal_to_string (sig), nm_strerror_native (errsv), errsv); - } - return; - } - - /* wait for the process to terminate... */ - - wait_start_us = nm_utils_get_monotonic_timestamp_usec (); - - sleep_duration_usec = _sleep_duration_convert_ms_to_us (sleep_duration_msec); - if (sig != SIGKILL && wait_before_kill_msec) - wait_until_sigkill = wait_start_us + (((gint64) wait_before_kill_msec) * 1000L); - else - wait_until_sigkill = 0; - if (max_wait_msec > 0) { - max_wait_until = wait_start_us + (((gint64) max_wait_msec) * 1000L); - if (wait_until_sigkill > 0 && wait_until_sigkill > max_wait_msec) - wait_until_sigkill = 0; - } else - max_wait_until = 0; - - while (TRUE) { - start_time = nm_utils_get_start_time_for_pid (pid, &p_state, NULL); - - if (start_time != start_time0) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is gone after sending signal %s%s", - LOG_NAME_ARGS, _kc_signal_to_string (sig), - was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : ""); - return; - } - switch (p_state) { - case 'Z': - case 'x': - case 'X': - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is a zombie (%c) after sending signal %s%s", - LOG_NAME_ARGS, p_state, _kc_signal_to_string (sig), - was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : ""); - return; - default: - break; - } - - if (kill (pid, 0) != 0) { - errsv = errno; - /* ESRCH means, process does not exist or is already a zombie. */ - if (errsv == ESRCH) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is gone or a zombie after sending signal %s%s", - LOG_NAME_ARGS, _kc_signal_to_string (sig), - was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : ""); - } else { - nm_log_warn (LOGD_CORE | log_domain, LOG_NAME_PROCESS_FMT ": failed to kill(%ld, 0): %s (%d)%s", - LOG_NAME_ARGS, (long int) pid, nm_strerror_native (errsv), errsv, - was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : ""); - } - return; - } - - sleep_time = sleep_duration_usec; - now = nm_utils_get_monotonic_timestamp_usec (); - - if ( max_wait_until != 0 - && now >= max_wait_until) { - if (wait_until_sigkill != 0) { - /* wait_before_kill_msec is not larger then max_wait_until but we did not yet send - * SIGKILL. Although we already reached our timeout, we don't want to skip sending - * the signal. Even if we don't wait for the process to disappear. */ - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": sending SIGKILL", LOG_NAME_ARGS); - kill (pid, SIGKILL); - } - nm_log_warn (log_domain, LOG_NAME_PROCESS_FMT ": timeout %u msec waiting for process to disappear (after sending %s)%s", - LOG_NAME_ARGS, (unsigned) max_wait_until, _kc_signal_to_string (sig), - was_waiting ? _kc_waited_to_string (buf_wait, wait_start_us) : ""); - return; - } - - if (wait_until_sigkill != 0) { - if (now >= wait_until_sigkill) { - /* Still not dead. SIGKILL now... */ - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": sending SIGKILL", LOG_NAME_ARGS); - if (kill (pid, SIGKILL) != 0) { - errsv = errno; - /* ESRCH means, process does not exist or is already a zombie. */ - if (errsv != ESRCH) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": process is gone or a zombie%s", - LOG_NAME_ARGS, _kc_waited_to_string (buf_wait, wait_start_us)); - } else { - nm_log_warn (LOGD_CORE | log_domain, LOG_NAME_PROCESS_FMT ": failed to send SIGKILL (after sending %s), %s (%d)%s", - LOG_NAME_ARGS, _kc_signal_to_string (sig), nm_strerror_native (errsv), errsv, - _kc_waited_to_string (buf_wait, wait_start_us)); - } - return; - } - sig = SIGKILL; - wait_until_sigkill = 0; - loop_count = 0; /* reset the loop_count. Now we really expect the process to die quickly. */ - } else - sleep_time = MIN (wait_until_sigkill - now, sleep_duration_usec); - } - - if (!was_waiting) { - if (wait_until_sigkill != 0) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": waiting up to %ld milliseconds for process to disappear before sending KILL signal after sending %s...", - LOG_NAME_ARGS, (long) wait_before_kill_msec, _kc_signal_to_string (sig)); - } else if (max_wait_until != 0) { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": waiting up to %ld milliseconds for process to disappear after sending %s...", - LOG_NAME_ARGS, (long) max_wait_msec, _kc_signal_to_string (sig)); - } else { - nm_log_dbg (log_domain, LOG_NAME_PROCESS_FMT ": waiting for process to disappear after sending %s...", - LOG_NAME_ARGS, _kc_signal_to_string (sig)); - } - was_waiting = TRUE; - } - - if (loop_count < 20) { - /* At the beginning we expect the process to die fast. - * Limit the sleep time, the limit doubles with every iteration. */ - sleep_time = MIN (sleep_time, (((guint64) 1) << loop_count) * G_USEC_PER_SEC / 2000); - loop_count++; - } - g_usleep (sleep_time); - } + int errsv; + guint64 start_time0; + gint64 wait_until_sigkill, now, wait_start_us, max_wait_until; + gulong sleep_time, sleep_duration_usec; + int loop_count = 0; + gboolean was_waiting = FALSE; + char buf_wait[KC_WAITED_TO_STRING]; + char p_state; + + g_return_if_fail(pid > 0); + g_return_if_fail(log_name != NULL); + + start_time0 = nm_utils_get_start_time_for_pid(pid, &p_state, NULL); + if (start_time0 == 0) { + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT ": cannot kill process %ld because it seems already gone", + LOG_NAME_ARGS, + (long int) pid); + return; + } + if (start_time != 0 && start_time != start_time0) { + nm_log_dbg( + log_domain, + LOG_NAME_PROCESS_FMT + ": don't kill process %ld because the start_time is unexpectedly %lu instead of %ld", + LOG_NAME_ARGS, + (long int) pid, + (unsigned long) start_time0, + (unsigned long) start_time); + return; + } + + switch (p_state) { + case 'Z': + case 'x': + case 'X': + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT + ": cannot kill process %ld because it is already a zombie (%c)", + LOG_NAME_ARGS, + (long int) pid, + p_state); + return; + default: + break; + } + + if (kill(pid, sig) != 0) { + errsv = errno; + /* ESRCH means, process does not exist or is already a zombie. */ + if (errsv == ESRCH) { + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT ": failed to send %s because process seems gone", + LOG_NAME_ARGS, + _kc_signal_to_string(sig)); + } else { + nm_log_warn(LOGD_CORE | log_domain, + LOG_NAME_PROCESS_FMT ": failed to send %s: %s (%d)", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + nm_strerror_native(errsv), + errsv); + } + return; + } + + /* wait for the process to terminate... */ + + wait_start_us = nm_utils_get_monotonic_timestamp_usec(); + + sleep_duration_usec = _sleep_duration_convert_ms_to_us(sleep_duration_msec); + if (sig != SIGKILL && wait_before_kill_msec) + wait_until_sigkill = wait_start_us + (((gint64) wait_before_kill_msec) * 1000L); + else + wait_until_sigkill = 0; + if (max_wait_msec > 0) { + max_wait_until = wait_start_us + (((gint64) max_wait_msec) * 1000L); + if (wait_until_sigkill > 0 && wait_until_sigkill > max_wait_msec) + wait_until_sigkill = 0; + } else + max_wait_until = 0; + + while (TRUE) { + start_time = nm_utils_get_start_time_for_pid(pid, &p_state, NULL); + + if (start_time != start_time0) { + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT ": process is gone after sending signal %s%s", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + was_waiting ? _kc_waited_to_string(buf_wait, wait_start_us) : ""); + return; + } + switch (p_state) { + case 'Z': + case 'x': + case 'X': + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT ": process is a zombie (%c) after sending signal %s%s", + LOG_NAME_ARGS, + p_state, + _kc_signal_to_string(sig), + was_waiting ? _kc_waited_to_string(buf_wait, wait_start_us) : ""); + return; + default: + break; + } + + if (kill(pid, 0) != 0) { + errsv = errno; + /* ESRCH means, process does not exist or is already a zombie. */ + if (errsv == ESRCH) { + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT + ": process is gone or a zombie after sending signal %s%s", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + was_waiting ? _kc_waited_to_string(buf_wait, wait_start_us) : ""); + } else { + nm_log_warn(LOGD_CORE | log_domain, + LOG_NAME_PROCESS_FMT ": failed to kill(%ld, 0): %s (%d)%s", + LOG_NAME_ARGS, + (long int) pid, + nm_strerror_native(errsv), + errsv, + was_waiting ? _kc_waited_to_string(buf_wait, wait_start_us) : ""); + } + return; + } + + sleep_time = sleep_duration_usec; + now = nm_utils_get_monotonic_timestamp_usec(); + + if (max_wait_until != 0 && now >= max_wait_until) { + if (wait_until_sigkill != 0) { + /* wait_before_kill_msec is not larger then max_wait_until but we did not yet send + * SIGKILL. Although we already reached our timeout, we don't want to skip sending + * the signal. Even if we don't wait for the process to disappear. */ + nm_log_dbg(log_domain, LOG_NAME_PROCESS_FMT ": sending SIGKILL", LOG_NAME_ARGS); + kill(pid, SIGKILL); + } + nm_log_warn(log_domain, + LOG_NAME_PROCESS_FMT + ": timeout %u msec waiting for process to disappear (after sending %s)%s", + LOG_NAME_ARGS, + (unsigned) max_wait_until, + _kc_signal_to_string(sig), + was_waiting ? _kc_waited_to_string(buf_wait, wait_start_us) : ""); + return; + } + + if (wait_until_sigkill != 0) { + if (now >= wait_until_sigkill) { + /* Still not dead. SIGKILL now... */ + nm_log_dbg(log_domain, LOG_NAME_PROCESS_FMT ": sending SIGKILL", LOG_NAME_ARGS); + if (kill(pid, SIGKILL) != 0) { + errsv = errno; + /* ESRCH means, process does not exist or is already a zombie. */ + if (errsv != ESRCH) { + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT ": process is gone or a zombie%s", + LOG_NAME_ARGS, + _kc_waited_to_string(buf_wait, wait_start_us)); + } else { + nm_log_warn(LOGD_CORE | log_domain, + LOG_NAME_PROCESS_FMT + ": failed to send SIGKILL (after sending %s), %s (%d)%s", + LOG_NAME_ARGS, + _kc_signal_to_string(sig), + nm_strerror_native(errsv), + errsv, + _kc_waited_to_string(buf_wait, wait_start_us)); + } + return; + } + sig = SIGKILL; + wait_until_sigkill = 0; + loop_count = + 0; /* reset the loop_count. Now we really expect the process to die quickly. */ + } else + sleep_time = MIN(wait_until_sigkill - now, sleep_duration_usec); + } + + if (!was_waiting) { + if (wait_until_sigkill != 0) { + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT + ": waiting up to %ld milliseconds for process to disappear before " + "sending KILL signal after sending %s...", + LOG_NAME_ARGS, + (long) wait_before_kill_msec, + _kc_signal_to_string(sig)); + } else if (max_wait_until != 0) { + nm_log_dbg( + log_domain, + LOG_NAME_PROCESS_FMT + ": waiting up to %ld milliseconds for process to disappear after sending %s...", + LOG_NAME_ARGS, + (long) max_wait_msec, + _kc_signal_to_string(sig)); + } else { + nm_log_dbg(log_domain, + LOG_NAME_PROCESS_FMT + ": waiting for process to disappear after sending %s...", + LOG_NAME_ARGS, + _kc_signal_to_string(sig)); + } + was_waiting = TRUE; + } + + if (loop_count < 20) { + /* At the beginning we expect the process to die fast. + * Limit the sleep time, the limit doubles with every iteration. */ + sleep_time = MIN(sleep_time, (((guint64) 1) << loop_count) * G_USEC_PER_SEC / 2000); + loop_count++; + } + g_usleep(sleep_time); + } } #undef LOG_NAME_FMT #undef LOG_NAME_PROCESS_FMT #undef LOG_NAME_ARGS const char *const NM_PATHS_DEFAULT[] = { - PREFIX "/sbin/", - PREFIX "/bin/", - "/usr/local/sbin/", - "/sbin/", - "/usr/sbin/", - "/usr/local/bin/", - "/bin/", - "/usr/bin/", - NULL, + PREFIX "/sbin/", + PREFIX "/bin/", + "/usr/local/sbin/", + "/sbin/", + "/usr/sbin/", + "/usr/local/bin/", + "/bin/", + "/usr/bin/", + NULL, }; const char * -nm_utils_find_helper (const char *progname, const char *try_first, GError **error) +nm_utils_find_helper(const char *progname, const char *try_first, GError **error) { - return nm_utils_file_search_in_paths (progname, try_first, NM_PATHS_DEFAULT, G_FILE_TEST_IS_EXECUTABLE, NULL, NULL, error); + return nm_utils_file_search_in_paths(progname, + try_first, + NM_PATHS_DEFAULT, + G_FILE_TEST_IS_EXECUTABLE, + NULL, + NULL, + error); } /*****************************************************************************/ @@ -1019,496 +1226,493 @@ nm_utils_find_helper (const char *progname, const char *try_first, GError **erro * and returns the result as absolute path. **/ char * -nm_utils_read_link_absolute (const char *link_file, GError **error) +nm_utils_read_link_absolute(const char *link_file, GError **error) { - char *ln, *dirname, *ln_abs; - - ln = g_file_read_link (link_file, error); - if (!ln) - return NULL; - if (g_path_is_absolute (ln)) - return ln; - - dirname = g_path_get_dirname (link_file); - if (!g_path_is_absolute (dirname)) { - gs_free char *current_dir = g_get_current_dir (); - - /* @link_file argument was not an absolute path in the first place. - * That actually may be a bug, because the CWD is not well defined - * in most cases. Anyway, apparently we were able to load the file - * even from a relative path. So, when making the link absolute, we - * also need to prepend the CWD. */ - ln_abs = g_build_filename (current_dir, dirname, ln, NULL); - } else - ln_abs = g_build_filename (dirname, ln, NULL); - g_free (dirname); - g_free (ln); - return ln_abs; + char *ln, *dirname, *ln_abs; + + ln = g_file_read_link(link_file, error); + if (!ln) + return NULL; + if (g_path_is_absolute(ln)) + return ln; + + dirname = g_path_get_dirname(link_file); + if (!g_path_is_absolute(dirname)) { + gs_free char *current_dir = g_get_current_dir(); + + /* @link_file argument was not an absolute path in the first place. + * That actually may be a bug, because the CWD is not well defined + * in most cases. Anyway, apparently we were able to load the file + * even from a relative path. So, when making the link absolute, we + * also need to prepend the CWD. */ + ln_abs = g_build_filename(current_dir, dirname, ln, NULL); + } else + ln_abs = g_build_filename(dirname, ln, NULL); + g_free(dirname); + g_free(ln); + return ln_abs; } /*****************************************************************************/ -#define DEVICE_TYPE_TAG "type:" -#define DRIVER_TAG "driver:" -#define DHCP_PLUGIN_TAG "dhcp-plugin:" -#define EXCEPT_TAG "except:" -#define MATCH_TAG_CONFIG_NM_VERSION "nm-version:" -#define MATCH_TAG_CONFIG_NM_VERSION_MIN "nm-version-min:" -#define MATCH_TAG_CONFIG_NM_VERSION_MAX "nm-version-max:" -#define MATCH_TAG_CONFIG_ENV "env:" +#define DEVICE_TYPE_TAG "type:" +#define DRIVER_TAG "driver:" +#define DHCP_PLUGIN_TAG "dhcp-plugin:" +#define EXCEPT_TAG "except:" +#define MATCH_TAG_CONFIG_NM_VERSION "nm-version:" +#define MATCH_TAG_CONFIG_NM_VERSION_MIN "nm-version-min:" +#define MATCH_TAG_CONFIG_NM_VERSION_MAX "nm-version-max:" +#define MATCH_TAG_CONFIG_ENV "env:" typedef struct { - const char *interface_name; - const char *device_type; - const char *driver; - const char *driver_version; - const char *dhcp_plugin; - struct { - const char *value; - gboolean is_parsed; - guint len; - guint8 bin[NM_UTILS_HWADDR_LEN_MAX]; - } hwaddr; - struct { - const char *value; - gboolean is_parsed; - guint32 a; - guint32 b; - guint32 c; - } s390_subchannels; + const char *interface_name; + const char *device_type; + const char *driver; + const char *driver_version; + const char *dhcp_plugin; + struct { + const char *value; + gboolean is_parsed; + guint len; + guint8 bin[NM_UTILS_HWADDR_LEN_MAX]; + } hwaddr; + struct { + const char *value; + gboolean is_parsed; + guint32 a; + guint32 b; + guint32 c; + } s390_subchannels; } MatchDeviceData; static gboolean -match_device_s390_subchannels_parse (const char *s390_subchannels, guint32 *out_a, guint32 *out_b, guint32 *out_c) +match_device_s390_subchannels_parse(const char *s390_subchannels, + guint32 * out_a, + guint32 * out_b, + guint32 * out_c) { - char buf[30 + 1]; - const int BUFSIZE = G_N_ELEMENTS (buf) - 1; - guint i = 0; - char *pa = NULL, *pb = NULL, *pc = NULL; - gint64 a, b, c; - - nm_assert (s390_subchannels); - nm_assert (out_a); - nm_assert (out_b); - nm_assert (out_c); - - if (!g_ascii_isxdigit (s390_subchannels[0])) - return FALSE; - - /* Get the first channel */ - for (i = 0; s390_subchannels[i]; i++) { - char ch = s390_subchannels[i]; - - if (!g_ascii_isxdigit (ch) && ch != '.') { - if (ch == ',') { - /* FIXME: currently we consider the first channel and ignore - * everything after the first ',' separator. Maybe we should - * validate all present channels? */ - break; - } - return FALSE; /* Invalid chars */ - } - if (i >= BUFSIZE) - return FALSE; /* Too long to be a subchannel */ - buf[i] = ch; - } - buf[i] = '\0'; - - /* and grab each of its elements, there should be 3 */ - pa = &buf[0]; - pb = strchr (pa, '.'); - if (pb) - pc = strchr (pb + 1, '.'); - if (!pb || !pc) - return FALSE; - *pb++ = '\0'; - *pc++ = '\0'; - - a = _nm_utils_ascii_str_to_int64 (pa, 16, 0, G_MAXUINT32, -1); - if (a == -1) - return FALSE; - b = _nm_utils_ascii_str_to_int64 (pb, 16, 0, G_MAXUINT32, -1); - if (b == -1) - return FALSE; - c = _nm_utils_ascii_str_to_int64 (pc, 16, 0, G_MAXUINT32, -1); - if (c == -1) - return FALSE; - - *out_a = (guint32) a; - *out_b = (guint32) b; - *out_c = (guint32) c; - return TRUE; + char buf[30 + 1]; + const int BUFSIZE = G_N_ELEMENTS(buf) - 1; + guint i = 0; + char * pa = NULL, *pb = NULL, *pc = NULL; + gint64 a, b, c; + + nm_assert(s390_subchannels); + nm_assert(out_a); + nm_assert(out_b); + nm_assert(out_c); + + if (!g_ascii_isxdigit(s390_subchannels[0])) + return FALSE; + + /* Get the first channel */ + for (i = 0; s390_subchannels[i]; i++) { + char ch = s390_subchannels[i]; + + if (!g_ascii_isxdigit(ch) && ch != '.') { + if (ch == ',') { + /* FIXME: currently we consider the first channel and ignore + * everything after the first ',' separator. Maybe we should + * validate all present channels? */ + break; + } + return FALSE; /* Invalid chars */ + } + if (i >= BUFSIZE) + return FALSE; /* Too long to be a subchannel */ + buf[i] = ch; + } + buf[i] = '\0'; + + /* and grab each of its elements, there should be 3 */ + pa = &buf[0]; + pb = strchr(pa, '.'); + if (pb) + pc = strchr(pb + 1, '.'); + if (!pb || !pc) + return FALSE; + *pb++ = '\0'; + *pc++ = '\0'; + + a = _nm_utils_ascii_str_to_int64(pa, 16, 0, G_MAXUINT32, -1); + if (a == -1) + return FALSE; + b = _nm_utils_ascii_str_to_int64(pb, 16, 0, G_MAXUINT32, -1); + if (b == -1) + return FALSE; + c = _nm_utils_ascii_str_to_int64(pc, 16, 0, G_MAXUINT32, -1); + if (c == -1) + return FALSE; + + *out_a = (guint32) a; + *out_b = (guint32) b; + *out_c = (guint32) c; + return TRUE; } static gboolean -match_data_s390_subchannels_eval (const char *spec_str, - MatchDeviceData *match_data) +match_data_s390_subchannels_eval(const char *spec_str, MatchDeviceData *match_data) { - guint32 a, b, c; - - if (G_UNLIKELY (!match_data->s390_subchannels.is_parsed)) { - match_data->s390_subchannels.is_parsed = TRUE; - - if ( !match_data->s390_subchannels.value - || !match_device_s390_subchannels_parse (match_data->s390_subchannels.value, - &match_data->s390_subchannels.a, - &match_data->s390_subchannels.b, - &match_data->s390_subchannels.c)) { - match_data->s390_subchannels.value = NULL; - return FALSE; - } - } else if (!match_data->s390_subchannels.value) - return FALSE; - - if (!match_device_s390_subchannels_parse (spec_str, &a, &b, &c)) - return FALSE; - return match_data->s390_subchannels.a == a - && match_data->s390_subchannels.b == b - && match_data->s390_subchannels.c == c; + guint32 a, b, c; + + if (G_UNLIKELY(!match_data->s390_subchannels.is_parsed)) { + match_data->s390_subchannels.is_parsed = TRUE; + + if (!match_data->s390_subchannels.value + || !match_device_s390_subchannels_parse(match_data->s390_subchannels.value, + &match_data->s390_subchannels.a, + &match_data->s390_subchannels.b, + &match_data->s390_subchannels.c)) { + match_data->s390_subchannels.value = NULL; + return FALSE; + } + } else if (!match_data->s390_subchannels.value) + return FALSE; + + if (!match_device_s390_subchannels_parse(spec_str, &a, &b, &c)) + return FALSE; + return match_data->s390_subchannels.a == a && match_data->s390_subchannels.b == b + && match_data->s390_subchannels.c == c; } static gboolean -match_device_hwaddr_eval (const char *spec_str, - MatchDeviceData *match_data) +match_device_hwaddr_eval(const char *spec_str, MatchDeviceData *match_data) { - if (G_UNLIKELY (!match_data->hwaddr.is_parsed)) { - match_data->hwaddr.is_parsed = TRUE; - - if (match_data->hwaddr.value) { - gsize l; - - if (!_nm_utils_hwaddr_aton (match_data->hwaddr.value, match_data->hwaddr.bin, sizeof (match_data->hwaddr.bin), &l)) - g_return_val_if_reached (FALSE); - match_data->hwaddr.len = l; - } else - return FALSE; - } else if (!match_data->hwaddr.len) - return FALSE; - - return nm_utils_hwaddr_matches (spec_str, -1, match_data->hwaddr.bin, match_data->hwaddr.len); + if (G_UNLIKELY(!match_data->hwaddr.is_parsed)) { + match_data->hwaddr.is_parsed = TRUE; + + if (match_data->hwaddr.value) { + gsize l; + + if (!_nm_utils_hwaddr_aton(match_data->hwaddr.value, + match_data->hwaddr.bin, + sizeof(match_data->hwaddr.bin), + &l)) + g_return_val_if_reached(FALSE); + match_data->hwaddr.len = l; + } else + return FALSE; + } else if (!match_data->hwaddr.len) + return FALSE; + + return nm_utils_hwaddr_matches(spec_str, -1, match_data->hwaddr.bin, match_data->hwaddr.len); } -#define _MATCH_CHECK(spec_str, tag) \ - ({ \ - gboolean _has = FALSE; \ - \ - if (!g_ascii_strncasecmp (spec_str, (""tag""), NM_STRLEN (tag))) { \ - spec_str += NM_STRLEN (tag); \ - _has = TRUE; \ - } \ - _has; \ - }) +#define _MATCH_CHECK(spec_str, tag) \ + ({ \ + gboolean _has = FALSE; \ + \ + if (!g_ascii_strncasecmp(spec_str, ("" tag ""), NM_STRLEN(tag))) { \ + spec_str += NM_STRLEN(tag); \ + _has = TRUE; \ + } \ + _has; \ + }) static NMMatchSpecMatchType -_match_result (gboolean has_except, - gboolean has_not_except, - gboolean has_match, - gboolean has_match_except) +_match_result(gboolean has_except, + gboolean has_not_except, + gboolean has_match, + gboolean has_match_except) { - if ( has_except - && !has_not_except) { - /* a match spec that only consists of a list of except matches is treated specially. */ - nm_assert (!has_match); - if (has_match_except) { - /* one of the "except:" matches matched. The result is an explicit - * negative match. */ - return NM_MATCH_SPEC_NEG_MATCH; - } else { - /* none of the "except:" matches matched. The result is a positive match, - * despite there being no positive match. */ - return NM_MATCH_SPEC_MATCH; - } - } - - if (has_match_except) - return NM_MATCH_SPEC_NEG_MATCH; - if (has_match) - return NM_MATCH_SPEC_MATCH; - return NM_MATCH_SPEC_NO_MATCH; + if (has_except && !has_not_except) { + /* a match spec that only consists of a list of except matches is treated specially. */ + nm_assert(!has_match); + if (has_match_except) { + /* one of the "except:" matches matched. The result is an explicit + * negative match. */ + return NM_MATCH_SPEC_NEG_MATCH; + } else { + /* none of the "except:" matches matched. The result is a positive match, + * despite there being no positive match. */ + return NM_MATCH_SPEC_MATCH; + } + } + + if (has_match_except) + return NM_MATCH_SPEC_NEG_MATCH; + if (has_match) + return NM_MATCH_SPEC_MATCH; + return NM_MATCH_SPEC_NO_MATCH; } static const char * -match_except (const char *spec_str, gboolean *out_except) +match_except(const char *spec_str, gboolean *out_except) { - if (_MATCH_CHECK (spec_str, EXCEPT_TAG)) - *out_except = TRUE; - else - *out_except = FALSE; - return spec_str; + if (_MATCH_CHECK(spec_str, EXCEPT_TAG)) + *out_except = TRUE; + else + *out_except = FALSE; + return spec_str; } static gboolean -match_device_eval (const char *spec_str, - gboolean allow_fuzzy, - MatchDeviceData *match_data) +match_device_eval(const char *spec_str, gboolean allow_fuzzy, MatchDeviceData *match_data) { - if (spec_str[0] == '*' && spec_str[1] == '\0') - return TRUE; - - if (_MATCH_CHECK (spec_str, DEVICE_TYPE_TAG)) { - return match_data->device_type - && nm_streq (spec_str, match_data->device_type); - } - - if (_MATCH_CHECK (spec_str, NM_MATCH_SPEC_MAC_TAG)) - return match_device_hwaddr_eval (spec_str, match_data); - - if (_MATCH_CHECK (spec_str, NM_MATCH_SPEC_INTERFACE_NAME_TAG)) { - gboolean use_pattern = FALSE; - - if (spec_str[0] == '=') - spec_str += 1; - else { - if (spec_str[0] == '~') - spec_str += 1; - use_pattern = TRUE; - } - - if (match_data->interface_name) { - if (nm_streq (spec_str, match_data->interface_name)) - return TRUE; - if (use_pattern && g_pattern_match_simple (spec_str, match_data->interface_name)) - return TRUE; - } - return FALSE; - } - - if (_MATCH_CHECK (spec_str, DRIVER_TAG)) { - const char *t; - - if (!match_data->driver) - return FALSE; - - /* support: - * 1) "${DRIVER}" - * In this case, DRIVER may not contain a '/' character. - * It matches any driver version. - * 2) "${DRIVER}/${DRIVER_VERSION}" - * In this case, DRIVER may contains '/' but DRIVER_VERSION - * may not. A '/' in DRIVER_VERSION may be replaced by '?'. - * - * It follows, that "${DRIVER}/""*" is like 1), but allows - * '/' inside DRIVER. - * - * The fields match to what `nmcli -f GENERAL.DRIVER,GENERAL.DRIVER-VERSION device show` - * gives. However, DRIVER matches literally, while DRIVER_VERSION is a glob - * supporting ? and *. - */ - - t = strrchr (spec_str, '/'); - - if (!t) - return nm_streq (spec_str, match_data->driver); - - return (strncmp (spec_str, match_data->driver, t - spec_str) == 0) - && g_pattern_match_simple (&t[1], - match_data->driver_version ?: ""); - } - - if (_MATCH_CHECK (spec_str, NM_MATCH_SPEC_S390_SUBCHANNELS_TAG)) - return match_data_s390_subchannels_eval (spec_str, match_data); - - if (_MATCH_CHECK (spec_str, DHCP_PLUGIN_TAG)) - return nm_streq0 (spec_str, match_data->dhcp_plugin); - - if (allow_fuzzy) { - if (match_device_hwaddr_eval (spec_str, match_data)) - return TRUE; - if ( match_data->interface_name - && nm_streq (spec_str, match_data->interface_name)) - return TRUE; - } - - return FALSE; + if (spec_str[0] == '*' && spec_str[1] == '\0') + return TRUE; + + if (_MATCH_CHECK(spec_str, DEVICE_TYPE_TAG)) { + return match_data->device_type && nm_streq(spec_str, match_data->device_type); + } + + if (_MATCH_CHECK(spec_str, NM_MATCH_SPEC_MAC_TAG)) + return match_device_hwaddr_eval(spec_str, match_data); + + if (_MATCH_CHECK(spec_str, NM_MATCH_SPEC_INTERFACE_NAME_TAG)) { + gboolean use_pattern = FALSE; + + if (spec_str[0] == '=') + spec_str += 1; + else { + if (spec_str[0] == '~') + spec_str += 1; + use_pattern = TRUE; + } + + if (match_data->interface_name) { + if (nm_streq(spec_str, match_data->interface_name)) + return TRUE; + if (use_pattern && g_pattern_match_simple(spec_str, match_data->interface_name)) + return TRUE; + } + return FALSE; + } + + if (_MATCH_CHECK(spec_str, DRIVER_TAG)) { + const char *t; + + if (!match_data->driver) + return FALSE; + + /* support: + * 1) "${DRIVER}" + * In this case, DRIVER may not contain a '/' character. + * It matches any driver version. + * 2) "${DRIVER}/${DRIVER_VERSION}" + * In this case, DRIVER may contains '/' but DRIVER_VERSION + * may not. A '/' in DRIVER_VERSION may be replaced by '?'. + * + * It follows, that "${DRIVER}/""*" is like 1), but allows + * '/' inside DRIVER. + * + * The fields match to what `nmcli -f GENERAL.DRIVER,GENERAL.DRIVER-VERSION device show` + * gives. However, DRIVER matches literally, while DRIVER_VERSION is a glob + * supporting ? and *. + */ + + t = strrchr(spec_str, '/'); + + if (!t) + return nm_streq(spec_str, match_data->driver); + + return (strncmp(spec_str, match_data->driver, t - spec_str) == 0) + && g_pattern_match_simple(&t[1], match_data->driver_version ?: ""); + } + + if (_MATCH_CHECK(spec_str, NM_MATCH_SPEC_S390_SUBCHANNELS_TAG)) + return match_data_s390_subchannels_eval(spec_str, match_data); + + if (_MATCH_CHECK(spec_str, DHCP_PLUGIN_TAG)) + return nm_streq0(spec_str, match_data->dhcp_plugin); + + if (allow_fuzzy) { + if (match_device_hwaddr_eval(spec_str, match_data)) + return TRUE; + if (match_data->interface_name && nm_streq(spec_str, match_data->interface_name)) + return TRUE; + } + + return FALSE; } NMMatchSpecMatchType -nm_match_spec_device (const GSList *specs, - const char *interface_name, - const char *device_type, - const char *driver, - const char *driver_version, - const char *hwaddr, - const char *s390_subchannels, - const char *dhcp_plugin) +nm_match_spec_device(const GSList *specs, + const char * interface_name, + const char * device_type, + const char * driver, + const char * driver_version, + const char * hwaddr, + const char * s390_subchannels, + const char * dhcp_plugin) { - const GSList *iter; - gboolean has_match = FALSE; - gboolean has_match_except = FALSE; - gboolean has_except = FALSE; - gboolean has_not_except = FALSE; - const char *spec_str; - MatchDeviceData match_data = { - .interface_name = interface_name, - .device_type = nm_str_not_empty (device_type), - .driver = nm_str_not_empty (driver), - .driver_version = nm_str_not_empty (driver_version), - .dhcp_plugin = nm_str_not_empty (dhcp_plugin), - .hwaddr = { - .value = hwaddr, - }, - .s390_subchannels = { - .value = s390_subchannels, - }, - }; - - nm_assert (!hwaddr || nm_utils_hwaddr_valid (hwaddr, -1)); - - if (!specs) - return NM_MATCH_SPEC_NO_MATCH; - - for (iter = specs; iter; iter = iter->next) { - gboolean except; - - spec_str = iter->data; - - if (!spec_str || !*spec_str) - continue; - - spec_str = match_except (spec_str, &except); - - if (except) - has_except = TRUE; - else - has_not_except = TRUE; - - if ( ( except && has_match_except) - || (!except && has_match)) { - /* evaluating the match does not give new information. Skip it. */ - continue; - } - - if (!match_device_eval (spec_str, - !except, - &match_data)) - continue; - - if (except) - has_match_except = TRUE; - else - has_match = TRUE; - } - - return _match_result (has_except, has_not_except, has_match, has_match_except); + const GSList * iter; + gboolean has_match = FALSE; + gboolean has_match_except = FALSE; + gboolean has_except = FALSE; + gboolean has_not_except = FALSE; + const char * spec_str; + MatchDeviceData match_data = { + .interface_name = interface_name, + .device_type = nm_str_not_empty(device_type), + .driver = nm_str_not_empty(driver), + .driver_version = nm_str_not_empty(driver_version), + .dhcp_plugin = nm_str_not_empty(dhcp_plugin), + .hwaddr = + { + .value = hwaddr, + }, + .s390_subchannels = + { + .value = s390_subchannels, + }, + }; + + nm_assert(!hwaddr || nm_utils_hwaddr_valid(hwaddr, -1)); + + if (!specs) + return NM_MATCH_SPEC_NO_MATCH; + + for (iter = specs; iter; iter = iter->next) { + gboolean except; + + spec_str = iter->data; + + if (!spec_str || !*spec_str) + continue; + + spec_str = match_except(spec_str, &except); + + if (except) + has_except = TRUE; + else + has_not_except = TRUE; + + if ((except && has_match_except) || (!except && has_match)) { + /* evaluating the match does not give new information. Skip it. */ + continue; + } + + if (!match_device_eval(spec_str, !except, &match_data)) + continue; + + if (except) + has_match_except = TRUE; + else + has_match = TRUE; + } + + return _match_result(has_except, has_not_except, has_match, has_match_except); } static gboolean -match_config_eval (const char *str, const char *tag, guint cur_nm_version) +match_config_eval(const char *str, const char *tag, guint cur_nm_version) { - gs_free char *s_ver = NULL; - gs_strfreev char **s_ver_tokens = NULL; - int v_maj = -1, v_min = -1, v_mic = -1; - guint c_maj = -1, c_min = -1, c_mic = -1; - guint n_tokens; - - s_ver = g_strdup (str); - g_strstrip (s_ver); - - /* Let's be strict with the accepted format here. No funny stuff!! */ - - if (s_ver[strspn (s_ver, ".0123456789")] != '\0') - return FALSE; - - s_ver_tokens = g_strsplit (s_ver, ".", -1); - n_tokens = g_strv_length (s_ver_tokens); - if (n_tokens == 0 || n_tokens > 3) - return FALSE; - - v_maj = _nm_utils_ascii_str_to_int64 (s_ver_tokens[0], 10, 0, 0xFFFF, -1); - if (v_maj < 0) - return FALSE; - if (n_tokens >= 2) { - v_min = _nm_utils_ascii_str_to_int64 (s_ver_tokens[1], 10, 0, 0xFF, -1); - if (v_min < 0) - return FALSE; - } - if (n_tokens >= 3) { - v_mic = _nm_utils_ascii_str_to_int64 (s_ver_tokens[2], 10, 0, 0xFF, -1); - if (v_mic < 0) - return FALSE; - } - - nm_decode_version (cur_nm_version, &c_maj, &c_min, &c_mic); - -#define CHECK_AND_RETURN_FALSE(cur, val, tag, is_last_digit) \ - G_STMT_START { \ - if (!strcmp (tag, MATCH_TAG_CONFIG_NM_VERSION_MIN)) { \ - if (cur < val) \ - return FALSE; \ - } else if (!strcmp (tag, MATCH_TAG_CONFIG_NM_VERSION_MAX)) { \ - if (cur > val) \ - return FALSE; \ - } else { \ - if (cur != val) \ - return FALSE; \ - } \ - if (!(is_last_digit)) { \ - if (cur != val) \ - return FALSE; \ - } \ - } G_STMT_END - if (v_mic >= 0) - CHECK_AND_RETURN_FALSE (c_mic, v_mic, tag, TRUE); - if (v_min >= 0) - CHECK_AND_RETURN_FALSE (c_min, v_min, tag, v_mic < 0); - CHECK_AND_RETURN_FALSE (c_maj, v_maj, tag, v_min < 0); - return TRUE; + gs_free char * s_ver = NULL; + gs_strfreev char **s_ver_tokens = NULL; + int v_maj = -1, v_min = -1, v_mic = -1; + guint c_maj = -1, c_min = -1, c_mic = -1; + guint n_tokens; + + s_ver = g_strdup(str); + g_strstrip(s_ver); + + /* Let's be strict with the accepted format here. No funny stuff!! */ + + if (s_ver[strspn(s_ver, ".0123456789")] != '\0') + return FALSE; + + s_ver_tokens = g_strsplit(s_ver, ".", -1); + n_tokens = g_strv_length(s_ver_tokens); + if (n_tokens == 0 || n_tokens > 3) + return FALSE; + + v_maj = _nm_utils_ascii_str_to_int64(s_ver_tokens[0], 10, 0, 0xFFFF, -1); + if (v_maj < 0) + return FALSE; + if (n_tokens >= 2) { + v_min = _nm_utils_ascii_str_to_int64(s_ver_tokens[1], 10, 0, 0xFF, -1); + if (v_min < 0) + return FALSE; + } + if (n_tokens >= 3) { + v_mic = _nm_utils_ascii_str_to_int64(s_ver_tokens[2], 10, 0, 0xFF, -1); + if (v_mic < 0) + return FALSE; + } + + nm_decode_version(cur_nm_version, &c_maj, &c_min, &c_mic); + +#define CHECK_AND_RETURN_FALSE(cur, val, tag, is_last_digit) \ + G_STMT_START \ + { \ + if (!strcmp(tag, MATCH_TAG_CONFIG_NM_VERSION_MIN)) { \ + if (cur < val) \ + return FALSE; \ + } else if (!strcmp(tag, MATCH_TAG_CONFIG_NM_VERSION_MAX)) { \ + if (cur > val) \ + return FALSE; \ + } else { \ + if (cur != val) \ + return FALSE; \ + } \ + if (!(is_last_digit)) { \ + if (cur != val) \ + return FALSE; \ + } \ + } \ + G_STMT_END + if (v_mic >= 0) + CHECK_AND_RETURN_FALSE(c_mic, v_mic, tag, TRUE); + if (v_min >= 0) + CHECK_AND_RETURN_FALSE(c_min, v_min, tag, v_mic < 0); + CHECK_AND_RETURN_FALSE(c_maj, v_maj, tag, v_min < 0); + return TRUE; } NMMatchSpecMatchType -nm_match_spec_config (const GSList *specs, guint cur_nm_version, const char *env) +nm_match_spec_config(const GSList *specs, guint cur_nm_version, const char *env) { - const GSList *iter; - gboolean has_match = FALSE; - gboolean has_match_except = FALSE; - gboolean has_except = FALSE; - gboolean has_not_except = FALSE; - - if (!specs) - return NM_MATCH_SPEC_NO_MATCH; - - for (iter = specs; iter; iter = g_slist_next (iter)) { - const char *spec_str = iter->data; - gboolean except; - gboolean v_match; - - if (!spec_str || !*spec_str) - continue; - - spec_str = match_except (spec_str, &except); - - if (except) - has_except = TRUE; - else - has_not_except = TRUE; - - if ( ( except && has_match_except) - || (!except && has_match)) { - /* evaluating the match does not give new information. Skip it. */ - continue; - } - - if (_MATCH_CHECK (spec_str, MATCH_TAG_CONFIG_NM_VERSION)) - v_match = match_config_eval (spec_str, MATCH_TAG_CONFIG_NM_VERSION, cur_nm_version); - else if (_MATCH_CHECK (spec_str, MATCH_TAG_CONFIG_NM_VERSION_MIN)) - v_match = match_config_eval (spec_str, MATCH_TAG_CONFIG_NM_VERSION_MIN, cur_nm_version); - else if (_MATCH_CHECK (spec_str, MATCH_TAG_CONFIG_NM_VERSION_MAX)) - v_match = match_config_eval (spec_str, MATCH_TAG_CONFIG_NM_VERSION_MAX, cur_nm_version); - else if (_MATCH_CHECK (spec_str, MATCH_TAG_CONFIG_ENV)) - v_match = env && env[0] && !strcmp (spec_str, env); - else - v_match = FALSE; - - if (!v_match) - continue; - - if (except) - has_match_except = TRUE; - else - has_match = TRUE; - } - - return _match_result (has_except, has_not_except, has_match, has_match_except); + const GSList *iter; + gboolean has_match = FALSE; + gboolean has_match_except = FALSE; + gboolean has_except = FALSE; + gboolean has_not_except = FALSE; + + if (!specs) + return NM_MATCH_SPEC_NO_MATCH; + + for (iter = specs; iter; iter = g_slist_next(iter)) { + const char *spec_str = iter->data; + gboolean except; + gboolean v_match; + + if (!spec_str || !*spec_str) + continue; + + spec_str = match_except(spec_str, &except); + + if (except) + has_except = TRUE; + else + has_not_except = TRUE; + + if ((except && has_match_except) || (!except && has_match)) { + /* evaluating the match does not give new information. Skip it. */ + continue; + } + + if (_MATCH_CHECK(spec_str, MATCH_TAG_CONFIG_NM_VERSION)) + v_match = match_config_eval(spec_str, MATCH_TAG_CONFIG_NM_VERSION, cur_nm_version); + else if (_MATCH_CHECK(spec_str, MATCH_TAG_CONFIG_NM_VERSION_MIN)) + v_match = match_config_eval(spec_str, MATCH_TAG_CONFIG_NM_VERSION_MIN, cur_nm_version); + else if (_MATCH_CHECK(spec_str, MATCH_TAG_CONFIG_NM_VERSION_MAX)) + v_match = match_config_eval(spec_str, MATCH_TAG_CONFIG_NM_VERSION_MAX, cur_nm_version); + else if (_MATCH_CHECK(spec_str, MATCH_TAG_CONFIG_ENV)) + v_match = env && env[0] && !strcmp(spec_str, env); + else + v_match = FALSE; + + if (!v_match) + continue; + + if (except) + has_match_except = TRUE; + else + has_match = TRUE; + } + + return _match_result(has_except, has_not_except, has_match, has_match_except); } #undef _MATCH_CHECK @@ -1534,89 +1738,89 @@ nm_match_spec_config (const GSList *specs, guint cur_nm_version, const char *env * Returns: (transfer full): the list of device specs. */ GSList * -nm_match_spec_split (const char *value) +nm_match_spec_split(const char *value) { - char *string_value, *p, *q0, *q; - GSList *pieces = NULL; - int trailing_ws; - - if (!value || !*value) - return NULL; - - /* Copied from glibs g_key_file_parse_value_as_string() function - * and adjusted. */ - - string_value = g_new (char, strlen (value) + 1); - - p = (char *) value; - - /* skip over leading whitespace */ - while (g_ascii_isspace (*p)) - p++; - - q0 = q = string_value; - trailing_ws = 0; - while (*p) { - if (*p == '\\') { - p++; - - switch (*p) { - case 's': - *q = ' '; - break; - case 'n': - *q = '\n'; - break; - case 't': - *q = '\t'; - break; - case 'r': - *q = '\r'; - break; - case '\\': - *q = '\\'; - break; - case '\0': - break; - default: - if (NM_IN_SET (*p, ',', ';')) - *q = *p; - else { - *q++ = '\\'; - *q = *p; - } - break; - } - if (*p == '\0') - break; - p++; - trailing_ws = 0; - } else { - *q = *p; - if (*p == '\0') - break; - if (g_ascii_isspace (*p)) { - trailing_ws++; - p++; - } else if (NM_IN_SET (*p, ',', ';')) { - if (q0 < q - trailing_ws) - pieces = g_slist_prepend (pieces, g_strndup (q0, (q - q0) - trailing_ws)); - q0 = q + 1; - p++; - trailing_ws = 0; - while (g_ascii_isspace (*p)) - p++; - } else - p++; - } - q++; - } - - *q = '\0'; - if (q0 < q - trailing_ws) - pieces = g_slist_prepend (pieces, g_strndup (q0, (q - q0) - trailing_ws)); - g_free (string_value); - return g_slist_reverse (pieces); + char * string_value, *p, *q0, *q; + GSList *pieces = NULL; + int trailing_ws; + + if (!value || !*value) + return NULL; + + /* Copied from glibs g_key_file_parse_value_as_string() function + * and adjusted. */ + + string_value = g_new(char, strlen(value) + 1); + + p = (char *) value; + + /* skip over leading whitespace */ + while (g_ascii_isspace(*p)) + p++; + + q0 = q = string_value; + trailing_ws = 0; + while (*p) { + if (*p == '\\') { + p++; + + switch (*p) { + case 's': + *q = ' '; + break; + case 'n': + *q = '\n'; + break; + case 't': + *q = '\t'; + break; + case 'r': + *q = '\r'; + break; + case '\\': + *q = '\\'; + break; + case '\0': + break; + default: + if (NM_IN_SET(*p, ',', ';')) + *q = *p; + else { + *q++ = '\\'; + *q = *p; + } + break; + } + if (*p == '\0') + break; + p++; + trailing_ws = 0; + } else { + *q = *p; + if (*p == '\0') + break; + if (g_ascii_isspace(*p)) { + trailing_ws++; + p++; + } else if (NM_IN_SET(*p, ',', ';')) { + if (q0 < q - trailing_ws) + pieces = g_slist_prepend(pieces, g_strndup(q0, (q - q0) - trailing_ws)); + q0 = q + 1; + p++; + trailing_ws = 0; + while (g_ascii_isspace(*p)) + p++; + } else + p++; + } + q++; + } + + *q = '\0'; + if (q0 < q - trailing_ws) + pieces = g_slist_prepend(pieces, g_strndup(q0, (q - q0) - trailing_ws)); + g_free(string_value); + return g_slist_reverse(pieces); } /** @@ -1633,258 +1837,253 @@ nm_match_spec_split (const char *value) * ways to encode the same joined specs string). */ char * -nm_match_spec_join (GSList *specs) +nm_match_spec_join(GSList *specs) { - const char *p; - GString *str; - - str = g_string_new (""); - - for (; specs; specs = specs->next) { - p = specs->data; - - if (!p || !*p) - continue; - - if (str->len > 0) - g_string_append_c (str, ','); - - /* escape leading whitespace */ - switch (*p) { - case ' ': - g_string_append (str, "\\s"); - p++; - break; - case '\t': - g_string_append (str, "\\t"); - p++; - break; - } - - for (; *p; p++) { - switch (*p) { - case '\n': - g_string_append (str, "\\n"); - break; - case '\r': - g_string_append (str, "\\r"); - break; - case '\\': - g_string_append (str, "\\\\"); - break; - case ',': - g_string_append (str, "\\,"); - break; - case ';': - g_string_append (str, "\\;"); - break; - default: - g_string_append_c (str, *p); - break; - } - } - - /* escape trailing whitespaces */ - switch (str->str[str->len - 1]) { - case ' ': - g_string_overwrite (str, str->len - 1, "\\s"); - break; - case '\t': - g_string_overwrite (str, str->len - 1, "\\t"); - break; - } - } - - return g_string_free (str, FALSE); + const char *p; + GString * str; + + str = g_string_new(""); + + for (; specs; specs = specs->next) { + p = specs->data; + + if (!p || !*p) + continue; + + if (str->len > 0) + g_string_append_c(str, ','); + + /* escape leading whitespace */ + switch (*p) { + case ' ': + g_string_append(str, "\\s"); + p++; + break; + case '\t': + g_string_append(str, "\\t"); + p++; + break; + } + + for (; *p; p++) { + switch (*p) { + case '\n': + g_string_append(str, "\\n"); + break; + case '\r': + g_string_append(str, "\\r"); + break; + case '\\': + g_string_append(str, "\\\\"); + break; + case ',': + g_string_append(str, "\\,"); + break; + case ';': + g_string_append(str, "\\;"); + break; + default: + g_string_append_c(str, *p); + break; + } + } + + /* escape trailing whitespaces */ + switch (str->str[str->len - 1]) { + case ' ': + g_string_overwrite(str, str->len - 1, "\\s"); + break; + case '\t': + g_string_overwrite(str, str->len - 1, "\\t"); + break; + } + } + + return g_string_free(str, FALSE); } static void -_pattern_parse (const char *input, - const char **out_pattern, - gboolean *out_is_inverted, - gboolean *out_is_mandatory) +_pattern_parse(const char * input, + const char **out_pattern, + gboolean * out_is_inverted, + gboolean * out_is_mandatory) { - gboolean is_inverted = FALSE; - gboolean is_mandatory = FALSE; - - if (input[0] == '&') { - input++; - is_mandatory = TRUE; - if (input[0] == '!') { - input++; - is_inverted = TRUE; - } - goto out; - } - - if (input[0] == '|') { - input++; - if (input[0] == '!') { - input++; - is_inverted = TRUE; - } - goto out; - } - - if (input[0] == '!') { - input++; - is_inverted = TRUE; - is_mandatory = TRUE; - goto out; - } + gboolean is_inverted = FALSE; + gboolean is_mandatory = FALSE; + + if (input[0] == '&') { + input++; + is_mandatory = TRUE; + if (input[0] == '!') { + input++; + is_inverted = TRUE; + } + goto out; + } + + if (input[0] == '|') { + input++; + if (input[0] == '!') { + input++; + is_inverted = TRUE; + } + goto out; + } + + if (input[0] == '!') { + input++; + is_inverted = TRUE; + is_mandatory = TRUE; + goto out; + } out: - if (input[0] == '\\') - input++; + if (input[0] == '\\') + input++; - *out_pattern = input; - *out_is_inverted = is_inverted; - *out_is_mandatory = is_mandatory; + *out_pattern = input; + *out_is_inverted = is_inverted; + *out_is_mandatory = is_mandatory; } gboolean -nm_wildcard_match_check (const char *str, - const char *const *patterns, - guint num_patterns) +nm_wildcard_match_check(const char *str, const char *const *patterns, guint num_patterns) { - gboolean has_optional = FALSE; - gboolean has_any_optional = FALSE; - guint i; - - for (i = 0; i < num_patterns; i++) { - gboolean is_inverted; - gboolean is_mandatory; - gboolean match; - const char *p; - - _pattern_parse (patterns[i], &p, &is_inverted, &is_mandatory); - - match = (fnmatch (p, str, 0) == 0); - if (is_inverted) - match = !match; - - if (is_mandatory) { - if (!match) - return FALSE; - } else { - has_any_optional = TRUE; - if (match) - has_optional = TRUE; - } - } - - return has_optional - || !has_any_optional; + gboolean has_optional = FALSE; + gboolean has_any_optional = FALSE; + guint i; + + for (i = 0; i < num_patterns; i++) { + gboolean is_inverted; + gboolean is_mandatory; + gboolean match; + const char *p; + + _pattern_parse(patterns[i], &p, &is_inverted, &is_mandatory); + + match = (fnmatch(p, str, 0) == 0); + if (is_inverted) + match = !match; + + if (is_mandatory) { + if (!match) + return FALSE; + } else { + has_any_optional = TRUE; + if (match) + has_optional = TRUE; + } + } + + return has_optional || !has_any_optional; } /*****************************************************************************/ static gboolean -_kernel_cmdline_match (const char *const*proc_cmdline, - const char *pattern) +_kernel_cmdline_match(const char *const *proc_cmdline, const char *pattern) { - - if (proc_cmdline) { - gboolean has_equal = (!!strchr (pattern, '=')); - gsize pattern_len = strlen (pattern); - - for (; proc_cmdline[0]; proc_cmdline++) { - const char *c = proc_cmdline[0]; - - if (has_equal) { - /* if pattern contains '=' compare full key=value */ - if (nm_streq (c, pattern)) - return TRUE; - continue; - } - - /* otherwise consider pattern as key only */ - if ( strncmp (c, pattern, pattern_len) == 0 - && NM_IN_SET (c[pattern_len], '\0', '=')) - return TRUE; - } - } - - return FALSE; + if (proc_cmdline) { + gboolean has_equal = (!!strchr(pattern, '=')); + gsize pattern_len = strlen(pattern); + + for (; proc_cmdline[0]; proc_cmdline++) { + const char *c = proc_cmdline[0]; + + if (has_equal) { + /* if pattern contains '=' compare full key=value */ + if (nm_streq(c, pattern)) + return TRUE; + continue; + } + + /* otherwise consider pattern as key only */ + if (strncmp(c, pattern, pattern_len) == 0 && NM_IN_SET(c[pattern_len], '\0', '=')) + return TRUE; + } + } + + return FALSE; } gboolean -nm_utils_kernel_cmdline_match_check (const char *const*proc_cmdline, - const char *const*patterns, - guint num_patterns, - GError **error) +nm_utils_kernel_cmdline_match_check(const char *const *proc_cmdline, + const char *const *patterns, + guint num_patterns, + GError ** error) { - gboolean has_optional = FALSE; - gboolean has_any_optional = FALSE; - guint i; - - for (i = 0; i < num_patterns; i++) { - const char *element = patterns[i]; - gboolean is_inverted = FALSE; - gboolean is_mandatory = FALSE; - gboolean match; - const char *p; - - _pattern_parse (element, &p, &is_inverted, &is_mandatory); - - match = _kernel_cmdline_match (proc_cmdline, p); - if (is_inverted) - match = !match; - - if (is_mandatory) { - if (!match) { - nm_utils_error_set (error, NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY, - "device does not satisfy match.kernel-command-line property %s", - patterns[i]); - return FALSE; - } - } else { - has_any_optional = TRUE; - if (match) - has_optional = TRUE; - } - } - - if ( !has_optional - && has_any_optional) { - nm_utils_error_set (error, NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY, - "device does not satisfy any match.kernel-command-line property"); - return FALSE; - } - - return TRUE; + gboolean has_optional = FALSE; + gboolean has_any_optional = FALSE; + guint i; + + for (i = 0; i < num_patterns; i++) { + const char *element = patterns[i]; + gboolean is_inverted = FALSE; + gboolean is_mandatory = FALSE; + gboolean match; + const char *p; + + _pattern_parse(element, &p, &is_inverted, &is_mandatory); + + match = _kernel_cmdline_match(proc_cmdline, p); + if (is_inverted) + match = !match; + + if (is_mandatory) { + if (!match) { + nm_utils_error_set(error, + NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY, + "device does not satisfy match.kernel-command-line property %s", + patterns[i]); + return FALSE; + } + } else { + has_any_optional = TRUE; + if (match) + has_optional = TRUE; + } + } + + if (!has_optional && has_any_optional) { + nm_utils_error_set(error, + NM_UTILS_ERROR_CONNECTION_AVAILABLE_TEMPORARY, + "device does not satisfy any match.kernel-command-line property"); + return FALSE; + } + + return TRUE; } /*****************************************************************************/ char * -nm_utils_new_vlan_name (const char *parent_iface, guint32 vlan_id) +nm_utils_new_vlan_name(const char *parent_iface, guint32 vlan_id) { - guint id_len; - gsize parent_len; - char *ifname; - - g_return_val_if_fail (parent_iface && *parent_iface, NULL); - - if (vlan_id < 10) - id_len = 2; - else if (vlan_id < 100) - id_len = 3; - else if (vlan_id < 1000) - id_len = 4; - else { - g_return_val_if_fail (vlan_id < 4095, NULL); - id_len = 5; - } - - ifname = g_new (char, IFNAMSIZ); - - parent_len = strlen (parent_iface); - parent_len = MIN (parent_len, IFNAMSIZ - 1 - id_len); - memcpy (ifname, parent_iface, parent_len); - g_snprintf (&ifname[parent_len], IFNAMSIZ - parent_len, ".%u", vlan_id); - - return ifname; + guint id_len; + gsize parent_len; + char *ifname; + + g_return_val_if_fail(parent_iface && *parent_iface, NULL); + + if (vlan_id < 10) + id_len = 2; + else if (vlan_id < 100) + id_len = 3; + else if (vlan_id < 1000) + id_len = 4; + else { + g_return_val_if_fail(vlan_id < 4095, NULL); + id_len = 5; + } + + ifname = g_new(char, IFNAMSIZ); + + parent_len = strlen(parent_iface); + parent_len = MIN(parent_len, IFNAMSIZ - 1 - id_len); + memcpy(ifname, parent_iface, parent_len); + g_snprintf(&ifname[parent_len], IFNAMSIZ - parent_len, ".%u", vlan_id); + + return ifname; } /* nm_utils_new_infiniband_name: @@ -1897,21 +2096,21 @@ nm_utils_new_vlan_name (const char *parent_iface, guint32 vlan_id) * is returned. */ const char * -nm_utils_new_infiniband_name (char *name, const char *parent_name, int p_key) +nm_utils_new_infiniband_name(char *name, const char *parent_name, int p_key) { - g_return_val_if_fail (name, NULL); - g_return_val_if_fail (parent_name && parent_name[0], NULL); - g_return_val_if_fail (strlen (parent_name) < IFNAMSIZ, NULL); - - /* technically, p_key of 0x0000 and 0x8000 is not allowed either. But we don't - * want to assert against that in nm_utils_new_infiniband_name(). So be more - * resilient here, and accept those. */ - g_return_val_if_fail (p_key >= 0 && p_key <= 0xffff, NULL); - - /* If parent+suffix is too long, kernel would just truncate - * the name. We do the same. See ipoib_vlan_add(). */ - g_snprintf (name, IFNAMSIZ, "%s.%04x", parent_name, p_key); - return name; + g_return_val_if_fail(name, NULL); + g_return_val_if_fail(parent_name && parent_name[0], NULL); + g_return_val_if_fail(strlen(parent_name) < IFNAMSIZ, NULL); + + /* technically, p_key of 0x0000 and 0x8000 is not allowed either. But we don't + * want to assert against that in nm_utils_new_infiniband_name(). So be more + * resilient here, and accept those. */ + g_return_val_if_fail(p_key >= 0 && p_key <= 0xffff, NULL); + + /* If parent+suffix is too long, kernel would just truncate + * the name. We do the same. See ipoib_vlan_add(). */ + g_snprintf(name, IFNAMSIZ, "%s.%04x", parent_name, p_key); + return name; } /*****************************************************************************/ @@ -1933,327 +2132,422 @@ nm_utils_new_infiniband_name (char *name, const char *parent_name, int p_key) * Returns: -1, 0, or 1 */ int -nm_utils_cmp_connection_by_autoconnect_priority (NMConnection *a, NMConnection *b) +nm_utils_cmp_connection_by_autoconnect_priority(NMConnection *a, NMConnection *b) { - NMSettingConnection *a_s_con; - NMSettingConnection *b_s_con; - int a_ap, b_ap; - gboolean can_autoconnect; - - if (a == b) - return 0; - if (!a) - return 1; - if (!b) - return -1; - - a_s_con = nm_connection_get_setting_connection (a); - b_s_con = nm_connection_get_setting_connection (b); - - if (!a_s_con) - return !b_s_con ? 0 : 1; - if (!b_s_con) - return -1; - - can_autoconnect = !!nm_setting_connection_get_autoconnect (a_s_con); - if (can_autoconnect != (!!nm_setting_connection_get_autoconnect (b_s_con))) - return can_autoconnect ? -1 : 1; - - if (can_autoconnect) { - a_ap = nm_setting_connection_get_autoconnect_priority (a_s_con); - b_ap = nm_setting_connection_get_autoconnect_priority (b_s_con); - if (a_ap != b_ap) - return (a_ap > b_ap) ? -1 : 1; - } - - return 0; + NMSettingConnection *a_s_con; + NMSettingConnection *b_s_con; + int a_ap, b_ap; + gboolean can_autoconnect; + + if (a == b) + return 0; + if (!a) + return 1; + if (!b) + return -1; + + a_s_con = nm_connection_get_setting_connection(a); + b_s_con = nm_connection_get_setting_connection(b); + + if (!a_s_con) + return !b_s_con ? 0 : 1; + if (!b_s_con) + return -1; + + can_autoconnect = !!nm_setting_connection_get_autoconnect(a_s_con); + if (can_autoconnect != (!!nm_setting_connection_get_autoconnect(b_s_con))) + return can_autoconnect ? -1 : 1; + + if (can_autoconnect) { + a_ap = nm_setting_connection_get_autoconnect_priority(a_s_con); + b_ap = nm_setting_connection_get_autoconnect_priority(b_s_con); + if (a_ap != b_ap) + return (a_ap > b_ap) ? -1 : 1; + } + + return 0; } /*****************************************************************************/ -typedef struct -{ - const char *name; - NMSetting *setting; - NMSetting *diff_base_setting; - GHashTable *setting_diff; +typedef struct { + const char *name; + NMSetting * setting; + NMSetting * diff_base_setting; + GHashTable *setting_diff; } LogConnectionSettingData; -typedef struct -{ - const char *item_name; - NMSettingDiffResult diff_result; +typedef struct { + const char * item_name; + NMSettingDiffResult diff_result; } LogConnectionSettingItem; static int -_log_connection_sort_hashes_fcn (gconstpointer a, gconstpointer b) +_log_connection_sort_hashes_fcn(gconstpointer a, gconstpointer b) { - const LogConnectionSettingData *v1 = a; - const LogConnectionSettingData *v2 = b; - NMSettingPriority p1, p2; - NMSetting *s1, *s2; + const LogConnectionSettingData *v1 = a; + const LogConnectionSettingData *v2 = b; + NMSettingPriority p1, p2; + NMSetting * s1, *s2; - s1 = v1->setting ?: v1->diff_base_setting; - s2 = v2->setting ?: v2->diff_base_setting; + s1 = v1->setting ?: v1->diff_base_setting; + s2 = v2->setting ?: v2->diff_base_setting; - g_assert (s1 && s2); + g_assert(s1 && s2); - p1 = _nm_setting_get_setting_priority (s1); - p2 = _nm_setting_get_setting_priority (s2); + p1 = _nm_setting_get_setting_priority(s1); + p2 = _nm_setting_get_setting_priority(s2); - if (p1 != p2) - return p1 > p2 ? 1 : -1; + if (p1 != p2) + return p1 > p2 ? 1 : -1; - return strcmp (v1->name, v2->name); + return strcmp(v1->name, v2->name); } static GArray * -_log_connection_sort_hashes (NMConnection *connection, NMConnection *diff_base, GHashTable *connection_diff) +_log_connection_sort_hashes(NMConnection *connection, + NMConnection *diff_base, + GHashTable * connection_diff) { - GHashTableIter iter; - GArray *sorted_hashes; - LogConnectionSettingData setting_data; - - sorted_hashes = g_array_sized_new (TRUE, FALSE, sizeof (LogConnectionSettingData), g_hash_table_size (connection_diff)); - - g_hash_table_iter_init (&iter, connection_diff); - while (g_hash_table_iter_next (&iter, (gpointer) &setting_data.name, (gpointer) &setting_data.setting_diff)) { - setting_data.setting = nm_connection_get_setting_by_name (connection, setting_data.name); - setting_data.diff_base_setting = diff_base ? nm_connection_get_setting_by_name (diff_base, setting_data.name) : NULL; - g_assert (setting_data.setting || setting_data.diff_base_setting); - g_array_append_val (sorted_hashes, setting_data); - } - - g_array_sort (sorted_hashes, _log_connection_sort_hashes_fcn); - return sorted_hashes; + GHashTableIter iter; + GArray * sorted_hashes; + LogConnectionSettingData setting_data; + + sorted_hashes = g_array_sized_new(TRUE, + FALSE, + sizeof(LogConnectionSettingData), + g_hash_table_size(connection_diff)); + + g_hash_table_iter_init(&iter, connection_diff); + while (g_hash_table_iter_next(&iter, + (gpointer) &setting_data.name, + (gpointer) &setting_data.setting_diff)) { + setting_data.setting = nm_connection_get_setting_by_name(connection, setting_data.name); + setting_data.diff_base_setting = + diff_base ? nm_connection_get_setting_by_name(diff_base, setting_data.name) : NULL; + g_assert(setting_data.setting || setting_data.diff_base_setting); + g_array_append_val(sorted_hashes, setting_data); + } + + g_array_sort(sorted_hashes, _log_connection_sort_hashes_fcn); + return sorted_hashes; } static int -_log_connection_sort_names_fcn (gconstpointer a, gconstpointer b) +_log_connection_sort_names_fcn(gconstpointer a, gconstpointer b) { - const LogConnectionSettingItem *v1 = a; - const LogConnectionSettingItem *v2 = b; - - /* we want to first show the items, that disappeared, then the one that changed and - * then the ones that were added. */ - - if ((v1->diff_result & NM_SETTING_DIFF_RESULT_IN_A) != (v2->diff_result & NM_SETTING_DIFF_RESULT_IN_A)) - return (v1->diff_result & NM_SETTING_DIFF_RESULT_IN_A) ? -1 : 1; - if ((v1->diff_result & NM_SETTING_DIFF_RESULT_IN_B) != (v2->diff_result & NM_SETTING_DIFF_RESULT_IN_B)) - return (v1->diff_result & NM_SETTING_DIFF_RESULT_IN_B) ? 1 : -1; - return strcmp (v1->item_name, v2->item_name); + const LogConnectionSettingItem *v1 = a; + const LogConnectionSettingItem *v2 = b; + + /* we want to first show the items, that disappeared, then the one that changed and + * then the ones that were added. */ + + if ((v1->diff_result & NM_SETTING_DIFF_RESULT_IN_A) + != (v2->diff_result & NM_SETTING_DIFF_RESULT_IN_A)) + return (v1->diff_result & NM_SETTING_DIFF_RESULT_IN_A) ? -1 : 1; + if ((v1->diff_result & NM_SETTING_DIFF_RESULT_IN_B) + != (v2->diff_result & NM_SETTING_DIFF_RESULT_IN_B)) + return (v1->diff_result & NM_SETTING_DIFF_RESULT_IN_B) ? 1 : -1; + return strcmp(v1->item_name, v2->item_name); } static char * -_log_connection_get_property (NMSetting *setting, const char *name) +_log_connection_get_property(NMSetting *setting, const char *name) { - GValue val = G_VALUE_INIT; - char *s; - - g_return_val_if_fail (setting, NULL); - - if ( !NM_IS_SETTING_VPN (setting) - && nm_setting_get_secret_flags (setting, name, NULL, NULL)) - return g_strdup ("****"); - - if (!_nm_setting_get_property (setting, name, &val)) - return g_strdup ("<unknown>"); - - if (G_VALUE_HOLDS_STRING (&val)) { - const char *val_s; - - val_s = g_value_get_string (&val); - if (!val_s) { - /* for NULL, we want to return the unquoted string "NULL". */ - s = g_strdup ("NULL"); - } else { - char *escaped = g_strescape (val_s, "'"); - - s = g_strdup_printf ("'%s'", escaped); - g_free (escaped); - } - } else { - s = g_strdup_value_contents (&val); - if (s == NULL) - s = g_strdup ("NULL"); - else { - char *escaped = g_strescape (s, "'"); - - g_free (s); - s = escaped; - } - } - g_value_unset(&val); - return s; + GValue val = G_VALUE_INIT; + char * s; + + g_return_val_if_fail(setting, NULL); + + if (!NM_IS_SETTING_VPN(setting) && nm_setting_get_secret_flags(setting, name, NULL, NULL)) + return g_strdup("****"); + + if (!_nm_setting_get_property(setting, name, &val)) + return g_strdup("<unknown>"); + + if (G_VALUE_HOLDS_STRING(&val)) { + const char *val_s; + + val_s = g_value_get_string(&val); + if (!val_s) { + /* for NULL, we want to return the unquoted string "NULL". */ + s = g_strdup("NULL"); + } else { + char *escaped = g_strescape(val_s, "'"); + + s = g_strdup_printf("'%s'", escaped); + g_free(escaped); + } + } else { + s = g_strdup_value_contents(&val); + if (s == NULL) + s = g_strdup("NULL"); + else { + char *escaped = g_strescape(s, "'"); + + g_free(s); + s = escaped; + } + } + g_value_unset(&val); + return s; } static void -_log_connection_sort_names (LogConnectionSettingData *setting_data, GArray *sorted_names) +_log_connection_sort_names(LogConnectionSettingData *setting_data, GArray *sorted_names) { - GHashTableIter iter; - LogConnectionSettingItem item; - gpointer p; + GHashTableIter iter; + LogConnectionSettingItem item; + gpointer p; - g_array_set_size (sorted_names, 0); + g_array_set_size(sorted_names, 0); - g_hash_table_iter_init (&iter, setting_data->setting_diff); - while (g_hash_table_iter_next (&iter, (gpointer) &item.item_name, &p)) { - item.diff_result = GPOINTER_TO_UINT (p); - g_array_append_val (sorted_names, item); - } + g_hash_table_iter_init(&iter, setting_data->setting_diff); + while (g_hash_table_iter_next(&iter, (gpointer) &item.item_name, &p)) { + item.diff_result = GPOINTER_TO_UINT(p); + g_array_append_val(sorted_names, item); + } - g_array_sort (sorted_names, _log_connection_sort_names_fcn); + g_array_sort(sorted_names, _log_connection_sort_names_fcn); } void -nm_utils_log_connection_diff (NMConnection *connection, - NMConnection *diff_base, - guint32 level, - guint64 domain, - const char *name, - const char *prefix, - const char *dbus_path) +nm_utils_log_connection_diff(NMConnection *connection, + NMConnection *diff_base, + guint32 level, + guint64 domain, + const char * name, + const char * prefix, + const char * dbus_path) { - GHashTable *connection_diff = NULL; - GArray *sorted_hashes; - GArray *sorted_names = NULL; - int i, j; - gboolean connection_diff_are_same; - gboolean print_header = TRUE; - gboolean print_setting_header; - GString *str1; - - g_return_if_fail (NM_IS_CONNECTION (connection)); - g_return_if_fail (!diff_base || (NM_IS_CONNECTION (diff_base) && diff_base != connection)); - - /* For VPN setting types, this is broken, because we cannot (generically) print the content of data/secrets. Bummer... */ - - if (!nm_logging_enabled (level, domain)) - return; - - if (!prefix) - prefix = ""; - if (!name) - name = ""; - - connection_diff_are_same = nm_connection_diff (connection, diff_base, - NM_SETTING_COMPARE_FLAG_EXACT | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT, - &connection_diff); - if (connection_diff_are_same) { - const char *t1, *t2; - - t1 = nm_connection_get_connection_type (connection); - if (diff_base) { - t2 = nm_connection_get_connection_type (diff_base); - nm_log (level, domain, NULL, NULL, - "%sconnection '%s' (%p/%s/%s%s%s and %p/%s/%s%s%s): no difference", - prefix, name, - connection, G_OBJECT_TYPE_NAME (connection), NM_PRINT_FMT_QUOTE_STRING (t1), - diff_base, G_OBJECT_TYPE_NAME (diff_base), NM_PRINT_FMT_QUOTE_STRING (t2)); - } else { - nm_log (level, domain, NULL, NULL, - "%sconnection '%s' (%p/%s/%s%s%s): no properties set", - prefix, name, - connection, G_OBJECT_TYPE_NAME (connection), NM_PRINT_FMT_QUOTE_STRING (t1)); - } - g_assert (!connection_diff); - return; - } - - /* FIXME: it doesn't nicely show the content of NMSettingVpn, because nm_connection_diff() does not - * expand the hash values. */ - - sorted_hashes = _log_connection_sort_hashes (connection, diff_base, connection_diff); - if (sorted_hashes->len <= 0) - goto out; - - sorted_names = g_array_new (FALSE, FALSE, sizeof (LogConnectionSettingItem)); - str1 = g_string_new (NULL); - - for (i = 0; i < sorted_hashes->len; i++) { - LogConnectionSettingData *setting_data = &g_array_index (sorted_hashes, LogConnectionSettingData, i); - - _log_connection_sort_names (setting_data, sorted_names); - print_setting_header = TRUE; - for (j = 0; j < sorted_names->len; j++) { - char *str_conn, *str_diff; - LogConnectionSettingItem *item = &g_array_index (sorted_names, LogConnectionSettingItem, j); - - str_conn = (item->diff_result & NM_SETTING_DIFF_RESULT_IN_A) - ? _log_connection_get_property (setting_data->setting, item->item_name) - : NULL; - str_diff = (item->diff_result & NM_SETTING_DIFF_RESULT_IN_B) - ? _log_connection_get_property (setting_data->diff_base_setting, item->item_name) - : NULL; - - if (print_header) { - GError *err_verify = NULL; - const char *t1, *t2; - - t1 = nm_connection_get_connection_type (connection); - if (diff_base) { - t2 = nm_connection_get_connection_type (diff_base); - nm_log (level, domain, NULL, NULL, "%sconnection '%s' (%p/%s/%s%s%s < %p/%s/%s%s%s)%s%s%s:", - prefix, name, - connection, G_OBJECT_TYPE_NAME (connection), NM_PRINT_FMT_QUOTE_STRING (t1), - diff_base, G_OBJECT_TYPE_NAME (diff_base), NM_PRINT_FMT_QUOTE_STRING (t2), - NM_PRINT_FMT_QUOTED (dbus_path, " [", dbus_path, "]", "")); - } else { - nm_log (level, domain, NULL, NULL, "%sconnection '%s' (%p/%s/%s%s%s):%s%s%s", - prefix, name, - connection, G_OBJECT_TYPE_NAME (connection), NM_PRINT_FMT_QUOTE_STRING (t1), - NM_PRINT_FMT_QUOTED (dbus_path, " [", dbus_path, "]", "")); - } - print_header = FALSE; - - if (!nm_connection_verify (connection, &err_verify)) { - nm_log (level, domain, NULL, NULL, "%sconnection %p does not verify: %s", prefix, connection, err_verify->message); - g_clear_error (&err_verify); - } - } + GHashTable *connection_diff = NULL; + GArray * sorted_hashes; + GArray * sorted_names = NULL; + int i, j; + gboolean connection_diff_are_same; + gboolean print_header = TRUE; + gboolean print_setting_header; + GString * str1; + + g_return_if_fail(NM_IS_CONNECTION(connection)); + g_return_if_fail(!diff_base || (NM_IS_CONNECTION(diff_base) && diff_base != connection)); + + /* For VPN setting types, this is broken, because we cannot (generically) print the content of data/secrets. Bummer... */ + + if (!nm_logging_enabled(level, domain)) + return; + + if (!prefix) + prefix = ""; + if (!name) + name = ""; + + connection_diff_are_same = nm_connection_diff( + connection, + diff_base, + NM_SETTING_COMPARE_FLAG_EXACT | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT, + &connection_diff); + if (connection_diff_are_same) { + const char *t1, *t2; + + t1 = nm_connection_get_connection_type(connection); + if (diff_base) { + t2 = nm_connection_get_connection_type(diff_base); + nm_log(level, + domain, + NULL, + NULL, + "%sconnection '%s' (%p/%s/%s%s%s and %p/%s/%s%s%s): no difference", + prefix, + name, + connection, + G_OBJECT_TYPE_NAME(connection), + NM_PRINT_FMT_QUOTE_STRING(t1), + diff_base, + G_OBJECT_TYPE_NAME(diff_base), + NM_PRINT_FMT_QUOTE_STRING(t2)); + } else { + nm_log(level, + domain, + NULL, + NULL, + "%sconnection '%s' (%p/%s/%s%s%s): no properties set", + prefix, + name, + connection, + G_OBJECT_TYPE_NAME(connection), + NM_PRINT_FMT_QUOTE_STRING(t1)); + } + g_assert(!connection_diff); + return; + } + + /* FIXME: it doesn't nicely show the content of NMSettingVpn, because nm_connection_diff() does not + * expand the hash values. */ + + sorted_hashes = _log_connection_sort_hashes(connection, diff_base, connection_diff); + if (sorted_hashes->len <= 0) + goto out; + + sorted_names = g_array_new(FALSE, FALSE, sizeof(LogConnectionSettingItem)); + str1 = g_string_new(NULL); + + for (i = 0; i < sorted_hashes->len; i++) { + LogConnectionSettingData *setting_data = + &g_array_index(sorted_hashes, LogConnectionSettingData, i); + + _log_connection_sort_names(setting_data, sorted_names); + print_setting_header = TRUE; + for (j = 0; j < sorted_names->len; j++) { + char * str_conn, *str_diff; + LogConnectionSettingItem *item = + &g_array_index(sorted_names, LogConnectionSettingItem, j); + + str_conn = (item->diff_result & NM_SETTING_DIFF_RESULT_IN_A) + ? _log_connection_get_property(setting_data->setting, item->item_name) + : NULL; + str_diff = + (item->diff_result & NM_SETTING_DIFF_RESULT_IN_B) + ? _log_connection_get_property(setting_data->diff_base_setting, item->item_name) + : NULL; + + if (print_header) { + GError * err_verify = NULL; + const char *t1, *t2; + + t1 = nm_connection_get_connection_type(connection); + if (diff_base) { + t2 = nm_connection_get_connection_type(diff_base); + nm_log(level, + domain, + NULL, + NULL, + "%sconnection '%s' (%p/%s/%s%s%s < %p/%s/%s%s%s)%s%s%s:", + prefix, + name, + connection, + G_OBJECT_TYPE_NAME(connection), + NM_PRINT_FMT_QUOTE_STRING(t1), + diff_base, + G_OBJECT_TYPE_NAME(diff_base), + NM_PRINT_FMT_QUOTE_STRING(t2), + NM_PRINT_FMT_QUOTED(dbus_path, " [", dbus_path, "]", "")); + } else { + nm_log(level, + domain, + NULL, + NULL, + "%sconnection '%s' (%p/%s/%s%s%s):%s%s%s", + prefix, + name, + connection, + G_OBJECT_TYPE_NAME(connection), + NM_PRINT_FMT_QUOTE_STRING(t1), + NM_PRINT_FMT_QUOTED(dbus_path, " [", dbus_path, "]", "")); + } + print_header = FALSE; + + if (!nm_connection_verify(connection, &err_verify)) { + nm_log(level, + domain, + NULL, + NULL, + "%sconnection %p does not verify: %s", + prefix, + connection, + err_verify->message); + g_clear_error(&err_verify); + } + } #define _NM_LOG_ALIGN "-25" - if (print_setting_header) { - if (diff_base) { - if (setting_data->setting && setting_data->diff_base_setting) - g_string_printf (str1, "%p < %p", setting_data->setting, setting_data->diff_base_setting); - else if (setting_data->diff_base_setting) - g_string_printf (str1, "*missing* < %p", setting_data->diff_base_setting); - else - g_string_printf (str1, "%p < *missing*", setting_data->setting); - nm_log (level, domain, NULL, NULL, "%s%"_NM_LOG_ALIGN"s [ %s ]", prefix, setting_data->name, str1->str); - } else - nm_log (level, domain, NULL, NULL, "%s%"_NM_LOG_ALIGN"s [ %p ]", prefix, setting_data->name, setting_data->setting); - print_setting_header = FALSE; - } - g_string_printf (str1, "%s.%s", setting_data->name, item->item_name); - switch (item->diff_result & (NM_SETTING_DIFF_RESULT_IN_A | NM_SETTING_DIFF_RESULT_IN_B)) { - case NM_SETTING_DIFF_RESULT_IN_B: - nm_log (level, domain, NULL, NULL, "%s%"_NM_LOG_ALIGN"s < %s", prefix, str1->str, str_diff ?: "NULL"); - break; - case NM_SETTING_DIFF_RESULT_IN_A: - nm_log (level, domain, NULL, NULL, "%s%"_NM_LOG_ALIGN"s = %s", prefix, str1->str, str_conn ?: "NULL"); - break; - default: - nm_log (level, domain, NULL, NULL, "%s%"_NM_LOG_ALIGN"s = %s < %s", prefix, str1->str, str_conn ?: "NULL", str_diff ?: "NULL"); - break; + if (print_setting_header) { + if (diff_base) { + if (setting_data->setting && setting_data->diff_base_setting) + g_string_printf(str1, + "%p < %p", + setting_data->setting, + setting_data->diff_base_setting); + else if (setting_data->diff_base_setting) + g_string_printf(str1, "*missing* < %p", setting_data->diff_base_setting); + else + g_string_printf(str1, "%p < *missing*", setting_data->setting); + nm_log(level, + domain, + NULL, + NULL, + "%s%"_NM_LOG_ALIGN + "s [ %s ]", + prefix, + setting_data->name, + str1->str); + } else + nm_log(level, + domain, + NULL, + NULL, + "%s%"_NM_LOG_ALIGN + "s [ %p ]", + prefix, + setting_data->name, + setting_data->setting); + print_setting_header = FALSE; + } + g_string_printf(str1, "%s.%s", setting_data->name, item->item_name); + switch (item->diff_result + & (NM_SETTING_DIFF_RESULT_IN_A | NM_SETTING_DIFF_RESULT_IN_B)) { + case NM_SETTING_DIFF_RESULT_IN_B: + nm_log(level, + domain, + NULL, + NULL, + "%s%"_NM_LOG_ALIGN + "s < %s", + prefix, + str1->str, + str_diff ?: "NULL"); + break; + case NM_SETTING_DIFF_RESULT_IN_A: + nm_log(level, + domain, + NULL, + NULL, + "%s%"_NM_LOG_ALIGN + "s = %s", + prefix, + str1->str, + str_conn ?: "NULL"); + break; + default: + nm_log(level, + domain, + NULL, + NULL, + "%s%"_NM_LOG_ALIGN + "s = %s < %s", + prefix, + str1->str, + str_conn ?: "NULL", + str_diff ?: "NULL"); + break; #undef _NM_LOG_ALIGN - } - g_free (str_conn); - g_free (str_diff); - } - } - - g_array_free (sorted_names, TRUE); - g_string_free (str1, TRUE); + } + g_free(str_conn); + g_free(str_diff); + } + } + + g_array_free(sorted_names, TRUE); + g_string_free(str1, TRUE); out: - g_hash_table_destroy (connection_diff); - g_array_free (sorted_hashes, TRUE); + g_hash_table_destroy(connection_diff); + g_array_free(sorted_hashes, TRUE); } #define IPV6_PROPERTY_DIR "/proc/sys/net/ipv6/conf/" #define IPV4_PROPERTY_DIR "/proc/sys/net/ipv4/conf/" -G_STATIC_ASSERT (sizeof (IPV4_PROPERTY_DIR) == sizeof (IPV6_PROPERTY_DIR)); -G_STATIC_ASSERT (NM_STRLEN (IPV6_PROPERTY_DIR) + IFNAMSIZ + 60 == NM_UTILS_SYSCTL_IP_CONF_PATH_BUFSIZE); +G_STATIC_ASSERT(sizeof(IPV4_PROPERTY_DIR) == sizeof(IPV6_PROPERTY_DIR)); +G_STATIC_ASSERT(NM_STRLEN(IPV6_PROPERTY_DIR) + IFNAMSIZ + 60 + == NM_UTILS_SYSCTL_IP_CONF_PATH_BUFSIZE); /** * nm_utils_sysctl_ip_conf_path: @@ -2268,517 +2562,538 @@ G_STATIC_ASSERT (NM_STRLEN (IPV6_PROPERTY_DIR) + IFNAMSIZ + 60 == NM_UTILS_SYSCT * this returns the input argument @buf. */ const char * -nm_utils_sysctl_ip_conf_path (int addr_family, char *buf, const char *ifname, const char *property) +nm_utils_sysctl_ip_conf_path(int addr_family, char *buf, const char *ifname, const char *property) { - int len; - - nm_assert (buf); - nm_assert_addr_family (addr_family); - - g_assert (nm_utils_ifname_valid_kernel (ifname, NULL)); - property = NM_ASSERT_VALID_PATH_COMPONENT (property); - - len = g_snprintf (buf, - NM_UTILS_SYSCTL_IP_CONF_PATH_BUFSIZE, - "%s%s/%s", - addr_family == AF_INET6 ? IPV6_PROPERTY_DIR : IPV4_PROPERTY_DIR, - ifname, - property); - g_assert (len < NM_UTILS_SYSCTL_IP_CONF_PATH_BUFSIZE - 1); - return buf; + int len; + + nm_assert(buf); + nm_assert_addr_family(addr_family); + + g_assert(nm_utils_ifname_valid_kernel(ifname, NULL)); + property = NM_ASSERT_VALID_PATH_COMPONENT(property); + + len = g_snprintf(buf, + NM_UTILS_SYSCTL_IP_CONF_PATH_BUFSIZE, + "%s%s/%s", + addr_family == AF_INET6 ? IPV6_PROPERTY_DIR : IPV4_PROPERTY_DIR, + ifname, + property); + g_assert(len < NM_UTILS_SYSCTL_IP_CONF_PATH_BUFSIZE - 1); + return buf; } gboolean -nm_utils_sysctl_ip_conf_is_path (int addr_family, const char *path, const char *ifname, const char *property) +nm_utils_sysctl_ip_conf_is_path(int addr_family, + const char *path, + const char *ifname, + const char *property) { - g_return_val_if_fail (path, FALSE); - NM_ASSERT_VALID_PATH_COMPONENT (property); - g_assert (!ifname || nm_utils_ifname_valid_kernel (ifname, NULL)); - - if (addr_family == AF_INET) { - if (!g_str_has_prefix (path, IPV4_PROPERTY_DIR)) - return FALSE; - path += NM_STRLEN (IPV4_PROPERTY_DIR); - } else if (addr_family == AF_INET6) { - if (!g_str_has_prefix (path, IPV6_PROPERTY_DIR)) - return FALSE; - path += NM_STRLEN (IPV6_PROPERTY_DIR); - } else - g_return_val_if_reached (FALSE); - - if (ifname) { - if (!g_str_has_prefix (path, ifname)) - return FALSE; - path += strlen (ifname); - if (path[0] != '/') - return FALSE; - path++; - } else { - const char *slash; - char buf[IFNAMSIZ]; - gsize l; - - slash = strchr (path, '/'); - if (!slash) - return FALSE; - l = slash - path; - if (l >= IFNAMSIZ) - return FALSE; - memcpy (buf, path, l); - buf[l] = '\0'; - if (!nm_utils_ifname_valid_kernel (buf, NULL)) - return FALSE; - path = slash + 1; - } - - if (!nm_streq (path, property)) - return FALSE; - - return TRUE; + g_return_val_if_fail(path, FALSE); + NM_ASSERT_VALID_PATH_COMPONENT(property); + g_assert(!ifname || nm_utils_ifname_valid_kernel(ifname, NULL)); + + if (addr_family == AF_INET) { + if (!g_str_has_prefix(path, IPV4_PROPERTY_DIR)) + return FALSE; + path += NM_STRLEN(IPV4_PROPERTY_DIR); + } else if (addr_family == AF_INET6) { + if (!g_str_has_prefix(path, IPV6_PROPERTY_DIR)) + return FALSE; + path += NM_STRLEN(IPV6_PROPERTY_DIR); + } else + g_return_val_if_reached(FALSE); + + if (ifname) { + if (!g_str_has_prefix(path, ifname)) + return FALSE; + path += strlen(ifname); + if (path[0] != '/') + return FALSE; + path++; + } else { + const char *slash; + char buf[IFNAMSIZ]; + gsize l; + + slash = strchr(path, '/'); + if (!slash) + return FALSE; + l = slash - path; + if (l >= IFNAMSIZ) + return FALSE; + memcpy(buf, path, l); + buf[l] = '\0'; + if (!nm_utils_ifname_valid_kernel(buf, NULL)) + return FALSE; + path = slash + 1; + } + + if (!nm_streq(path, property)) + return FALSE; + + return TRUE; } gboolean -nm_utils_is_valid_path_component (const char *name) +nm_utils_is_valid_path_component(const char *name) { - const char *n; - - if (name == NULL || name[0] == '\0') - return FALSE; - - if (name[0] == '.') { - if (name[1] == '\0') - return FALSE; - if (name[1] == '.' && name[2] == '\0') - return FALSE; - } - n = name; - do { - if (*n == '/') - return FALSE; - } while (*(++n) != '\0'); - - return TRUE; + const char *n; + + if (name == NULL || name[0] == '\0') + return FALSE; + + if (name[0] == '.') { + if (name[1] == '\0') + return FALSE; + if (name[1] == '.' && name[2] == '\0') + return FALSE; + } + n = name; + do { + if (*n == '/') + return FALSE; + } while (*(++n) != '\0'); + + return TRUE; } const char * -NM_ASSERT_VALID_PATH_COMPONENT (const char *name) -{ - if (G_LIKELY (nm_utils_is_valid_path_component (name))) - return name; - - nm_log_err (LOGD_CORE, "Failed asserting path component: %s%s%s", - NM_PRINT_FMT_QUOTED (name, "\"", name, "\"", "(null)")); - g_error ("FATAL: Failed asserting path component: %s%s%s", - NM_PRINT_FMT_QUOTED (name, "\"", name, "\"", "(null)")); - g_assert_not_reached (); -} - -gboolean -nm_utils_is_specific_hostname (const char *name) +NM_ASSERT_VALID_PATH_COMPONENT(const char *name) { - if (!name) - return FALSE; - if ( strcmp (name, "(none)") - && strcmp (name, "localhost") - && strcmp (name, "localhost6") - && strcmp (name, "localhost.localdomain") - && strcmp (name, "localhost6.localdomain6")) - return TRUE; - return FALSE; + if (G_LIKELY(nm_utils_is_valid_path_component(name))) + return name; + + nm_log_err(LOGD_CORE, + "Failed asserting path component: %s%s%s", + NM_PRINT_FMT_QUOTED(name, "\"", name, "\"", "(null)")); + g_error("FATAL: Failed asserting path component: %s%s%s", + NM_PRINT_FMT_QUOTED(name, "\"", name, "\"", "(null)")); + g_assert_not_reached(); } /*****************************************************************************/ typedef struct { - NMUuid bin; - char _nul_sentinel; /* just for safety, if somebody accidentally uses the binary in a string context. */ - - /* depending on whether the string is packed or not (with/without hyphens), - * it's 32 or 36 characters long (plus the trailing NUL). - * - * The difference is that boot-id is a valid RFC 4211 UUID and represented - * as a 36 ascii string (with hyphens). The machine-id technically is not - * a UUID, but just a 32 byte sequence of hexchars. */ - char str[37]; - bool is_fake; + NMUuid bin; + char + _nul_sentinel; /* just for safety, if somebody accidentally uses the binary in a string context. */ + + /* depending on whether the string is packed or not (with/without hyphens), + * it's 32 or 36 characters long (plus the trailing NUL). + * + * The difference is that boot-id is a valid RFC 4211 UUID and represented + * as a 36 ascii string (with hyphens). The machine-id technically is not + * a UUID, but just a 32 byte sequence of hexchars. */ + char str[37]; + bool is_fake; } UuidData; static UuidData * -_uuid_data_init (UuidData *uuid_data, - gboolean packed, - gboolean is_fake, - const NMUuid *uuid) +_uuid_data_init(UuidData *uuid_data, gboolean packed, gboolean is_fake, const NMUuid *uuid) { - nm_assert (uuid_data); - nm_assert (uuid); - - uuid_data->bin = *uuid; - uuid_data->_nul_sentinel = '\0'; - uuid_data->is_fake = is_fake; - if (packed) { - G_STATIC_ASSERT_EXPR (sizeof (uuid_data->str) >= (sizeof (*uuid) * 2 + 1)); - nm_utils_bin2hexstr_full (uuid, - sizeof (*uuid), - '\0', - FALSE, - uuid_data->str); - } else { - G_STATIC_ASSERT_EXPR (sizeof (uuid_data->str) >= 37); - _nm_utils_uuid_unparse (uuid, uuid_data->str); - } - return uuid_data; + nm_assert(uuid_data); + nm_assert(uuid); + + uuid_data->bin = *uuid; + uuid_data->_nul_sentinel = '\0'; + uuid_data->is_fake = is_fake; + if (packed) { + G_STATIC_ASSERT_EXPR(sizeof(uuid_data->str) >= (sizeof(*uuid) * 2 + 1)); + nm_utils_bin2hexstr_full(uuid, sizeof(*uuid), '\0', FALSE, uuid_data->str); + } else { + G_STATIC_ASSERT_EXPR(sizeof(uuid_data->str) >= 37); + _nm_utils_uuid_unparse(uuid, uuid_data->str); + } + return uuid_data; } /*****************************************************************************/ static const UuidData * -_machine_id_get (gboolean allow_fake) +_machine_id_get(gboolean allow_fake) { - static const UuidData *volatile p_uuid_data; - const UuidData *d; + static const UuidData *volatile p_uuid_data; + const UuidData *d; again: - d = g_atomic_pointer_get (&p_uuid_data); - if (G_UNLIKELY (!d)) { - static gsize lock; - static UuidData uuid_data; - gs_free char *content = NULL; - gboolean is_fake = TRUE; - const char *fake_type = NULL; - NMUuid uuid; - - /* Get the machine ID from /etc/machine-id; it's always in /etc no matter - * where our configured SYSCONFDIR is. Alternatively, it might be in - * LOCALSTATEDIR /lib/dbus/machine-id. - */ - if ( nm_utils_file_get_contents (-1, "/etc/machine-id", 100*1024, 0, &content, NULL, NULL, NULL) - || nm_utils_file_get_contents (-1, LOCALSTATEDIR"/lib/dbus/machine-id", 100*1024, 0, &content, NULL, NULL, NULL)) { - g_strstrip (content); - if (nm_utils_hexstr2bin_full (content, - FALSE, - FALSE, - NULL, - 16, - (guint8 *) &uuid, - sizeof (uuid), - NULL)) { - if (!nm_utils_uuid_is_null (&uuid)) { - /* an all-zero machine-id is not valid. */ - is_fake = FALSE; - } - } - } - - if (is_fake) { - const guint8 *seed_bin; - const char *hash_seed; - gsize seed_len; - - if (!allow_fake) { - /* we don't allow generating (and memoizing) a fake key. - * Signal that no valid machine-id exists. */ - return NULL; - } - - if (nm_utils_host_id_get (&seed_bin, &seed_len)) { - /* we have no valid machine-id. Generate a fake one by hashing - * the secret-key. This key is commonly persisted, so it should be - * stable across reboots (despite having a broken system without - * proper machine-id). */ - fake_type = "secret-key"; - hash_seed = "ab085f06-b629-46d1-a553-84eeba5683b6"; - } else { - /* the secret-key is not valid/persistent either. That happens when we fail - * to read/write the secret-key to disk. Fallback to boot-id. The boot-id - * itself may be fake and randomly generated ad-hoc, but that is as best - * as it gets. */ - seed_bin = (const guint8 *) nm_utils_boot_id_bin (); - seed_len = sizeof (NMUuid); - fake_type = "boot-id"; - hash_seed = "7ff0c8f5-5399-4901-ab63-61bf594abe8b"; - } - - /* the fake machine-id is based on secret-key/boot-id, but we hash it - * again, so that they are not literally the same. */ - nm_utils_uuid_generate_from_string_bin (&uuid, - (const char *) seed_bin, - seed_len, - NM_UTILS_UUID_TYPE_VERSION5, - (gpointer) hash_seed); - } - - if (!g_once_init_enter (&lock)) - goto again; - - d = _uuid_data_init (&uuid_data, TRUE, is_fake, &uuid); - g_atomic_pointer_set (&p_uuid_data, d); - g_once_init_leave (&lock, 1); - - if (is_fake) { - nm_log_err (LOGD_CORE, - "/etc/machine-id: no valid machine-id. Use fake one based on %s: %s", - fake_type, - d->str); - } else - nm_log_dbg (LOGD_CORE, "/etc/machine-id: %s", d->str); - } - - return d; + d = g_atomic_pointer_get(&p_uuid_data); + if (G_UNLIKELY(!d)) { + static gsize lock; + static UuidData uuid_data; + gs_free char * content = NULL; + gboolean is_fake = TRUE; + const char * fake_type = NULL; + NMUuid uuid; + + /* Get the machine ID from /etc/machine-id; it's always in /etc no matter + * where our configured SYSCONFDIR is. Alternatively, it might be in + * LOCALSTATEDIR /lib/dbus/machine-id. + */ + if (nm_utils_file_get_contents(-1, + "/etc/machine-id", + 100 * 1024, + 0, + &content, + NULL, + NULL, + NULL) + || nm_utils_file_get_contents(-1, + LOCALSTATEDIR "/lib/dbus/machine-id", + 100 * 1024, + 0, + &content, + NULL, + NULL, + NULL)) { + g_strstrip(content); + if (nm_utils_hexstr2bin_full(content, + FALSE, + FALSE, + FALSE, + NULL, + 16, + (guint8 *) &uuid, + sizeof(uuid), + NULL)) { + if (!nm_utils_uuid_is_null(&uuid)) { + /* an all-zero machine-id is not valid. */ + is_fake = FALSE; + } + } + } + + if (is_fake) { + const guint8 *seed_bin; + const char * hash_seed; + gsize seed_len; + + if (!allow_fake) { + /* we don't allow generating (and memorizing) a fake key. + * Signal that no valid machine-id exists. */ + return NULL; + } + + if (nm_utils_host_id_get(&seed_bin, &seed_len)) { + /* We have no valid machine-id but we have a valid secrey_key. + * Generate a fake machine ID by hashing the secret-key. The secret_key + * is commonly persisted, so it should be stable across reboots (despite + * having a broken system without proper machine-id). + * + * Note that we access the host-id here, which is based on secret_key. + * Also not that the secret_key may be generated based on the machine-id, + * so we have to be careful that they don't depend on each other (and + * no infinite recursion happens. This is done correctly, because the secret-key + * will call _machine_id_get(FALSE), so it won't allow accessing a fake + * machine-id, thus avoiding the problem. */ + fake_type = "secret-key"; + hash_seed = "ab085f06-b629-46d1-a553-84eeba5683b6"; + } else { + /* the secret-key is not valid/persistent either. That happens when we fail + * to read/write the secret-key to disk. Fallback to boot-id. The boot-id + * itself may be fake and randomly generated ad-hoc, but that is as best + * as it gets. */ + seed_bin = (const guint8 *) nm_utils_boot_id_bin(); + seed_len = sizeof(NMUuid); + fake_type = "boot-id"; + hash_seed = "7ff0c8f5-5399-4901-ab63-61bf594abe8b"; + } + + /* the fake machine-id is based on secret-key/boot-id, but we hash it + * again, so that they are not literally the same. */ + nm_utils_uuid_generate_from_string_bin(&uuid, + (const char *) seed_bin, + seed_len, + NM_UTILS_UUID_TYPE_VERSION5, + (gpointer) hash_seed); + } + + if (!g_once_init_enter(&lock)) + goto again; + + d = _uuid_data_init(&uuid_data, TRUE, is_fake, &uuid); + g_atomic_pointer_set(&p_uuid_data, d); + g_once_init_leave(&lock, 1); + + if (is_fake) { + nm_log_err(LOGD_CORE, + "/etc/machine-id: no valid machine-id. Use fake one based on %s: %s", + fake_type, + d->str); + } else + nm_log_dbg(LOGD_CORE, "/etc/machine-id: %s", d->str); + } + + return d; } const char * -nm_utils_machine_id_str (void) +nm_utils_machine_id_str(void) { - return _machine_id_get (TRUE)->str; + return _machine_id_get(TRUE)->str; } const NMUuid * -nm_utils_machine_id_bin (void) +nm_utils_machine_id_bin(void) { - return &_machine_id_get (TRUE)->bin; + return &_machine_id_get(TRUE)->bin; } gboolean -nm_utils_machine_id_is_fake (void) +nm_utils_machine_id_is_fake(void) { - return _machine_id_get (TRUE)->is_fake; + return _machine_id_get(TRUE)->is_fake; } /*****************************************************************************/ /* prefix for version2 secret key. The secret key is hashed with /etc/machine-id. */ #define SECRET_KEY_V2_PREFIX "nm-v2:" -#define SECRET_KEY_FILE NMSTATEDIR"/secret_key" +#define SECRET_KEY_FILE NMSTATEDIR "/secret_key" static gboolean -_host_id_read_timestamp (gboolean use_secret_key_file, - const guint8 *host_id, - gsize host_id_len, - gint64 *out_timestamp_ns) +_host_id_read_timestamp(gboolean use_secret_key_file, + const guint8 *host_id, + gsize host_id_len, + gint64 * out_timestamp_ns) { - struct stat st; - gint64 now; - guint64 v; - - if ( use_secret_key_file - && stat (SECRET_KEY_FILE, &st) == 0) { - /* don't check for overflow or timestamps in the future. We get whatever - * (bogus) date is on the file. */ - *out_timestamp_ns = nm_utils_timespec_to_nsec (&st.st_mtim); - return TRUE; - } - - /* generate a fake timestamp based on the host-id. - * - * This really should never happen under normal circumstances. We already - * are in a code path, where the system has a problem (unable to get good randomness - * and/or can't access the secret_key). In such a scenario, a fake timestamp is the - * least of our problems. - * - * At least, generate something sensible so we don't have to worry about the - * timestamp. It is wrong to worry about using a fake timestamp (which is tied to - * the secret_key) if we are unable to access the secret_key file in the first place. - * - * Pick a random timestamp from the past two years. Yes, this timestamp - * is not stable across restarts, but apparently neither is the host-id - * nor the secret_key itself. */ - -#define EPOCH_TWO_YEARS (G_GINT64_CONSTANT (2 * 365 * 24 * 3600) * NM_UTILS_NSEC_PER_SEC) - - v = nm_hash_siphash42 (1156657133u, host_id, host_id_len); - - now = time (NULL); - *out_timestamp_ns = NM_MAX ((gint64) 1, - (now * NM_UTILS_NSEC_PER_SEC) - ((gint64) (v % ((guint64) (EPOCH_TWO_YEARS))))); - return FALSE; + struct stat st; + gint64 now; + guint64 v; + + if (use_secret_key_file && stat(SECRET_KEY_FILE, &st) == 0) { + /* don't check for overflow or timestamps in the future. We get whatever + * (bogus) date is on the file. */ + *out_timestamp_ns = nm_utils_timespec_to_nsec(&st.st_mtim); + return TRUE; + } + + /* generate a fake timestamp based on the host-id. + * + * This really should never happen under normal circumstances. We already + * are in a code path, where the system has a problem (unable to get good randomness + * and/or can't access the secret_key). In such a scenario, a fake timestamp is the + * least of our problems. + * + * At least, generate something sensible so we don't have to worry about the + * timestamp. It is wrong to worry about using a fake timestamp (which is tied to + * the secret_key) if we are unable to access the secret_key file in the first place. + * + * Pick a random timestamp from the past two years. Yes, this timestamp + * is not stable across restarts, but apparently neither is the host-id + * nor the secret_key itself. */ + +#define EPOCH_TWO_YEARS (G_GINT64_CONSTANT(2 * 365 * 24 * 3600) * NM_UTILS_NSEC_PER_SEC) + + v = nm_hash_siphash42(1156657133u, host_id, host_id_len); + + now = time(NULL); + *out_timestamp_ns = + NM_MAX((gint64) 1, + (now * NM_UTILS_NSEC_PER_SEC) - ((gint64)(v % ((guint64)(EPOCH_TWO_YEARS))))); + return FALSE; } static const guint8 * -_host_id_hash_v2 (const guint8 *seed_arr, - gsize seed_len, - guint8 *out_digest /* 32 bytes (NM_UTILS_CHECKSUM_LENGTH_SHA256) */) +_host_id_hash_v2(const guint8 *seed_arr, + gsize seed_len, + guint8 * out_digest /* 32 bytes (NM_UTILS_CHECKSUM_LENGTH_SHA256) */) { - nm_auto_free_checksum GChecksum *sum = g_checksum_new (G_CHECKSUM_SHA256); - const UuidData *machine_id_data; - char slen[100]; + nm_auto_free_checksum GChecksum *sum = g_checksum_new(G_CHECKSUM_SHA256); + const UuidData * machine_id_data; + char slen[100]; - /* - (stat -c '%s' /var/lib/NetworkManager/secret_key; - echo -n ' '; - cat /var/lib/NetworkManager/secret_key; - cat /etc/machine-id | tr -d '\n' | sed -n 's/[a-f0-9-]/\0/pg') | sha256sum - */ + /* + (stat -c '%s' /var/lib/NetworkManager/secret_key; + echo -n ' '; + cat /var/lib/NetworkManager/secret_key; + cat /etc/machine-id | tr -d '\n' | sed -n 's/[a-f0-9-]/\0/pg') | sha256sum + */ - nm_sprintf_buf (slen, "%"G_GSIZE_FORMAT" ", seed_len); - g_checksum_update (sum, (const guchar *) slen, strlen (slen)); + nm_sprintf_buf(slen, "%" G_GSIZE_FORMAT " ", seed_len); + g_checksum_update(sum, (const guchar *) slen, strlen(slen)); - g_checksum_update (sum, (const guchar *) seed_arr, seed_len); + g_checksum_update(sum, (const guchar *) seed_arr, seed_len); - machine_id_data = _machine_id_get (FALSE); - if ( machine_id_data - && !machine_id_data->is_fake) - g_checksum_update (sum, (const guchar *) machine_id_data->str, strlen (machine_id_data->str)); + machine_id_data = _machine_id_get(FALSE); + if (machine_id_data && !machine_id_data->is_fake) + g_checksum_update(sum, (const guchar *) machine_id_data->str, strlen(machine_id_data->str)); - nm_utils_checksum_get_digest_len (sum, out_digest, NM_UTILS_CHECKSUM_LENGTH_SHA256); - return out_digest; + nm_utils_checksum_get_digest_len(sum, out_digest, NM_UTILS_CHECKSUM_LENGTH_SHA256); + return out_digest; } static gboolean -_host_id_read (guint8 **out_host_id, - gsize *out_host_id_len) +_host_id_read(guint8 **out_host_id, gsize *out_host_id_len) { #define SECRET_KEY_LEN 32u - guint8 sha256_digest[NM_UTILS_CHECKSUM_LENGTH_SHA256]; - nm_auto_clear_secret_ptr NMSecretPtr file_content = { 0 }; - const guint8 *secret_arr; - gsize secret_len; - GError *error = NULL; - gboolean success; - - if (!nm_utils_file_get_contents (-1, - SECRET_KEY_FILE, - 10*1024, - NM_UTILS_FILE_GET_CONTENTS_FLAG_SECRET, - &file_content.str, - &file_content.len, - NULL, - &error)) { - if (!nm_utils_error_is_notfound (error)) { - nm_log_warn (LOGD_CORE, "secret-key: failure reading secret key in \"%s\": %s (generate new key)", - SECRET_KEY_FILE, error->message); - } - g_clear_error (&error); - } else if ( file_content.len >= NM_STRLEN (SECRET_KEY_V2_PREFIX) + SECRET_KEY_LEN - && memcmp (file_content.bin, SECRET_KEY_V2_PREFIX, NM_STRLEN (SECRET_KEY_V2_PREFIX)) == 0) { - /* for this type of secret key, we require a prefix followed at least SECRET_KEY_LEN (32) bytes. We - * (also) do that, because older versions of NetworkManager wrote exactly 32 bytes without - * prefix, so we won't wrongly interpret such legacy keys as v2 (if they accidentally have - * a SECRET_KEY_V2_PREFIX prefix, they'll still have the wrong size). - * - * Note that below we generate the random seed in base64 encoding. But that is only done - * to write an ASCII file. There is no base64 decoding and the ASCII is hashed as-is. - * We would accept any binary data just as well (provided a suitable prefix and at least - * 32 bytes). - * - * Note that when hashing the v2 content, we also hash the prefix. There is no strong reason, - * except that it seems simpler not to distinguish between the v2 prefix and the content. - * It's all just part of the seed. */ - - secret_arr = _host_id_hash_v2 (file_content.bin, file_content.len, sha256_digest); - secret_len = NM_UTILS_CHECKSUM_LENGTH_SHA256; - success = TRUE; - goto out; - } else if (file_content.len >= 16) { - secret_arr = file_content.bin; - secret_len = file_content.len; - success = TRUE; - goto out; - } else { - /* the secret key is borked. Log a warning, but proceed below to generate - * a new one. */ - nm_log_warn (LOGD_CORE, "secret-key: too short secret key in \"%s\" (generate new key)", SECRET_KEY_FILE); - } - - /* generate and persist new key */ - { + guint8 sha256_digest[NM_UTILS_CHECKSUM_LENGTH_SHA256]; + nm_auto_clear_secret_ptr NMSecretPtr file_content = {0}; + const guint8 * secret_arr; + gsize secret_len; + GError * error = NULL; + gboolean success; + + if (!nm_utils_file_get_contents(-1, + SECRET_KEY_FILE, + 10 * 1024, + NM_UTILS_FILE_GET_CONTENTS_FLAG_SECRET, + &file_content.str, + &file_content.len, + NULL, + &error)) { + if (!nm_utils_error_is_notfound(error)) { + nm_log_warn(LOGD_CORE, + "secret-key: failure reading secret key in \"%s\": %s (generate new key)", + SECRET_KEY_FILE, + error->message); + } + g_clear_error(&error); + } else if (file_content.len >= NM_STRLEN(SECRET_KEY_V2_PREFIX) + SECRET_KEY_LEN + && memcmp(file_content.bin, SECRET_KEY_V2_PREFIX, NM_STRLEN(SECRET_KEY_V2_PREFIX)) + == 0) { + /* for this type of secret key, we require a prefix followed at least SECRET_KEY_LEN (32) bytes. We + * (also) do that, because older versions of NetworkManager wrote exactly 32 bytes without + * prefix, so we won't wrongly interpret such legacy keys as v2 (if they accidentally have + * a SECRET_KEY_V2_PREFIX prefix, they'll still have the wrong size). + * + * Note that below we generate the random seed in base64 encoding. But that is only done + * to write an ASCII file. There is no base64 decoding and the ASCII is hashed as-is. + * We would accept any binary data just as well (provided a suitable prefix and at least + * 32 bytes). + * + * Note that when hashing the v2 content, we also hash the prefix. There is no strong reason, + * except that it seems simpler not to distinguish between the v2 prefix and the content. + * It's all just part of the seed. */ + + secret_arr = _host_id_hash_v2(file_content.bin, file_content.len, sha256_digest); + secret_len = NM_UTILS_CHECKSUM_LENGTH_SHA256; + success = TRUE; + nm_log_dbg(LOGD_CORE, + "secret-key: v2 secret key loaded from \"%s\" (%zu bytes)", + SECRET_KEY_FILE, + file_content.len); + goto out; + } else if (file_content.len >= 16) { + secret_arr = file_content.bin; + secret_len = file_content.len; + success = TRUE; + nm_log_dbg(LOGD_CORE, + "secret-key: v1 secret key loaded from \"%s\" (%zu bytes)", + SECRET_KEY_FILE, + file_content.len); + goto out; + } else { + /* the secret key is borked. Log a warning, but proceed below to generate + * a new one. */ + nm_log_warn(LOGD_CORE, + "secret-key: too short secret key in \"%s\" (generate new key)", + SECRET_KEY_FILE); + } + + /* generate and persist new key */ + { #define SECRET_KEY_LEN_BASE64 ((((SECRET_KEY_LEN / 3) + 1) * 4) + 4) - guint8 rnd_buf[SECRET_KEY_LEN]; - guint8 new_content[NM_STRLEN (SECRET_KEY_V2_PREFIX) + SECRET_KEY_LEN_BASE64]; - int base64_state = 0; - int base64_save = 0; - gsize len; - - success = nm_utils_random_bytes (rnd_buf, sizeof (rnd_buf)); - - /* Our key is really binary data. But since we anyway generate a random seed - * (with 32 random bytes), don't write it in binary, but instead create - * an pure ASCII (base64) representation. Note that the ASCII will still be taken - * as-is (no base64 decoding is done). The sole purpose is to write a ASCII file - * instead of a binary. The content is gibberish either way. */ - memcpy (new_content, SECRET_KEY_V2_PREFIX, NM_STRLEN (SECRET_KEY_V2_PREFIX)); - len = NM_STRLEN (SECRET_KEY_V2_PREFIX); - len += g_base64_encode_step (rnd_buf, - sizeof (rnd_buf), - FALSE, - (char *) &new_content[len], - &base64_state, - &base64_save); - len += g_base64_encode_close (FALSE, - (char *) &new_content[len], - &base64_state, - &base64_save); - nm_assert (len <= sizeof (new_content)); - - secret_arr = _host_id_hash_v2 (new_content, len, sha256_digest); - secret_len = NM_UTILS_CHECKSUM_LENGTH_SHA256; - - if (!success) - nm_log_warn (LOGD_CORE, "secret-key: failure to generate good random data for secret-key (use non-persistent key)"); - else if (nm_utils_get_testing ()) { - /* for test code, we don't write the generated secret-key to disk. */ - } else if (!nm_utils_file_set_contents (SECRET_KEY_FILE, - (const char *) new_content, - len, - 0600, - NULL, - &error)) { - nm_log_warn (LOGD_CORE, "secret-key: failure to persist secret key in \"%s\" (%s) (use non-persistent key)", - SECRET_KEY_FILE, error->message); - g_clear_error (&error); - success = FALSE; - } else - nm_log_dbg (LOGD_CORE, "secret-key: persist new secret key to \"%s\"", SECRET_KEY_FILE); - - nm_explicit_bzero (rnd_buf, sizeof (rnd_buf)); - nm_explicit_bzero (new_content, sizeof (new_content)); - } + guint8 rnd_buf[SECRET_KEY_LEN]; + guint8 new_content[NM_STRLEN(SECRET_KEY_V2_PREFIX) + SECRET_KEY_LEN_BASE64]; + int base64_state = 0; + int base64_save = 0; + gsize len; + + success = nm_utils_random_bytes(rnd_buf, sizeof(rnd_buf)); + + /* Our key is really binary data. But since we anyway generate a random seed + * (with 32 random bytes), don't write it in binary, but instead create + * an pure ASCII (base64) representation. Note that the ASCII will still be taken + * as-is (no base64 decoding is done). The sole purpose is to write a ASCII file + * instead of a binary. The content is gibberish either way. */ + memcpy(new_content, SECRET_KEY_V2_PREFIX, NM_STRLEN(SECRET_KEY_V2_PREFIX)); + len = NM_STRLEN(SECRET_KEY_V2_PREFIX); + len += g_base64_encode_step(rnd_buf, + sizeof(rnd_buf), + FALSE, + (char *) &new_content[len], + &base64_state, + &base64_save); + len += + g_base64_encode_close(FALSE, (char *) &new_content[len], &base64_state, &base64_save); + nm_assert(len <= sizeof(new_content)); + + secret_arr = _host_id_hash_v2(new_content, len, sha256_digest); + secret_len = NM_UTILS_CHECKSUM_LENGTH_SHA256; + + if (!success) + nm_log_warn(LOGD_CORE, + "secret-key: failure to generate good random data for secret-key (use " + "non-persistent key)"); + else if (nm_utils_get_testing()) { + /* for test code, we don't write the generated secret-key to disk. */ + } else if (!nm_utils_file_set_contents(SECRET_KEY_FILE, + (const char *) new_content, + len, + 0600, + NULL, + &error)) { + nm_log_warn( + LOGD_CORE, + "secret-key: failure to persist secret key in \"%s\" (%s) (use non-persistent key)", + SECRET_KEY_FILE, + error->message); + g_clear_error(&error); + success = FALSE; + } else + nm_log_dbg(LOGD_CORE, + "secret-key: persist new v2 secret key to \"%s\" (%zu bytes)", + SECRET_KEY_FILE, + len); + + nm_explicit_bzero(rnd_buf, sizeof(rnd_buf)); + nm_explicit_bzero(new_content, sizeof(new_content)); + } out: - *out_host_id_len = secret_len; - *out_host_id = nm_memdup (secret_arr, secret_len); - return success; + *out_host_id_len = secret_len; + *out_host_id = nm_memdup(secret_arr, secret_len); + return success; } typedef struct { - guint8 *host_id; - gsize host_id_len; - gint64 timestamp_ns; - bool is_good:1; - bool timestamp_is_good:1; + guint8 *host_id; + gsize host_id_len; + gint64 timestamp_ns; + bool is_good : 1; + bool timestamp_is_good : 1; } HostIdData; static const HostIdData * -_host_id_get (void) +_host_id_get(void) { - static const HostIdData *volatile host_id_static; - const HostIdData *host_id; + static const HostIdData *volatile host_id_static; + const HostIdData *host_id; again: - host_id = g_atomic_pointer_get (&host_id_static); - if (G_UNLIKELY (!host_id)) { - static HostIdData host_id_data; - static gsize init_value = 0; - - if (!g_once_init_enter (&init_value)) - goto again; - - host_id_data.is_good = _host_id_read (&host_id_data.host_id, - &host_id_data.host_id_len); - - host_id_data.timestamp_is_good = _host_id_read_timestamp (host_id_data.is_good, - host_id_data.host_id, - host_id_data.host_id_len, - &host_id_data.timestamp_ns); - if ( !host_id_data.timestamp_is_good - && host_id_data.is_good) - nm_log_warn (LOGD_CORE, "secret-key: failure reading host timestamp (use fake one)"); - - host_id = &host_id_data; - g_atomic_pointer_set (&host_id_static, host_id); - g_once_init_leave (&init_value, 1); - } - - return host_id; + host_id = g_atomic_pointer_get(&host_id_static); + if (G_UNLIKELY(!host_id)) { + static HostIdData host_id_data; + static gsize init_value = 0; + + if (!g_once_init_enter(&init_value)) + goto again; + + host_id_data.is_good = _host_id_read(&host_id_data.host_id, &host_id_data.host_id_len); + + host_id_data.timestamp_is_good = _host_id_read_timestamp(host_id_data.is_good, + host_id_data.host_id, + host_id_data.host_id_len, + &host_id_data.timestamp_ns); + if (!host_id_data.timestamp_is_good && host_id_data.is_good) + nm_log_warn(LOGD_CORE, "secret-key: failure reading host timestamp (use fake one)"); + + host_id = &host_id_data; + g_atomic_pointer_set(&host_id_static, host_id); + g_once_init_leave(&init_value, 1); + } + + return host_id; } /** @@ -2797,123 +3112,121 @@ again: * to disk, and/or that it was generated with bad randomness. */ gboolean -nm_utils_host_id_get (const guint8 **out_host_id, - gsize *out_host_id_len) +nm_utils_host_id_get(const guint8 **out_host_id, gsize *out_host_id_len) { - const HostIdData *host_id; + const HostIdData *host_id; - host_id = _host_id_get (); - *out_host_id = host_id->host_id; - *out_host_id_len = host_id->host_id_len; - return host_id->is_good; + host_id = _host_id_get(); + *out_host_id = host_id->host_id; + *out_host_id_len = host_id->host_id_len; + return host_id->is_good; } gint64 -nm_utils_host_id_get_timestamp_ns (void) +nm_utils_host_id_get_timestamp_ns(void) { - return _host_id_get ()->timestamp_ns; + return _host_id_get()->timestamp_ns; } /*****************************************************************************/ static const UuidData * -_boot_id_get (void) +_boot_id_get(void) { - static const UuidData *volatile p_boot_id; - const UuidData *d; + static const UuidData *volatile p_boot_id; + const UuidData *d; again: - d = g_atomic_pointer_get (&p_boot_id); - if (G_UNLIKELY (!d)) { - static gsize lock; - static UuidData boot_id; - gs_free char *contents = NULL; - NMUuid uuid; - gboolean is_fake = FALSE; - - nm_utils_file_get_contents (-1, - "/proc/sys/kernel/random/boot_id", - 0, - NM_UTILS_FILE_GET_CONTENTS_FLAG_NONE, - &contents, - NULL, - NULL, - NULL); - if ( !contents - || !_nm_utils_uuid_parse (nm_strstrip (contents), &uuid)) { - /* generate a random UUID instead. */ - is_fake = TRUE; - _nm_utils_uuid_generate_random (&uuid); - } - - if (!g_once_init_enter (&lock)) - goto again; - - d = _uuid_data_init (&boot_id, FALSE, is_fake, &uuid); - g_atomic_pointer_set (&p_boot_id, d); - g_once_init_leave (&lock, 1); - } - - return d; + d = g_atomic_pointer_get(&p_boot_id); + if (G_UNLIKELY(!d)) { + static gsize lock; + static UuidData boot_id; + gs_free char * contents = NULL; + NMUuid uuid; + gboolean is_fake = FALSE; + + nm_utils_file_get_contents(-1, + "/proc/sys/kernel/random/boot_id", + 0, + NM_UTILS_FILE_GET_CONTENTS_FLAG_NONE, + &contents, + NULL, + NULL, + NULL); + if (!contents || !_nm_utils_uuid_parse(nm_strstrip(contents), &uuid)) { + /* generate a random UUID instead. */ + is_fake = TRUE; + _nm_utils_uuid_generate_random(&uuid); + } + + if (!g_once_init_enter(&lock)) + goto again; + + d = _uuid_data_init(&boot_id, FALSE, is_fake, &uuid); + g_atomic_pointer_set(&p_boot_id, d); + g_once_init_leave(&lock, 1); + } + + return d; } const char * -nm_utils_boot_id_str (void) +nm_utils_boot_id_str(void) { - return _boot_id_get ()->str; + return _boot_id_get()->str; } const NMUuid * -nm_utils_boot_id_bin (void) +nm_utils_boot_id_bin(void) { - return &_boot_id_get ()->bin; + return &_boot_id_get()->bin; } /*****************************************************************************/ const char * -nm_utils_proc_cmdline (void) +nm_utils_proc_cmdline(void) { - static const char *volatile proc_cmdline_cached = NULL; - const char *proc_cmdline; + static const char *volatile proc_cmdline_cached = NULL; + const char *proc_cmdline; again: - proc_cmdline = g_atomic_pointer_get (&proc_cmdline_cached); - if (G_UNLIKELY (!proc_cmdline)) { - gs_free char *str = NULL; + proc_cmdline = g_atomic_pointer_get(&proc_cmdline_cached); + if (G_UNLIKELY(!proc_cmdline)) { + gs_free char *str = NULL; - g_file_get_contents ("/proc/cmdline", &str, NULL, NULL); - str = nm_str_realloc (str); + g_file_get_contents("/proc/cmdline", &str, NULL, NULL); + str = nm_str_realloc(str); - proc_cmdline = str ?: ""; - if (!g_atomic_pointer_compare_and_exchange (&proc_cmdline_cached, NULL, proc_cmdline)) - goto again; + proc_cmdline = str ?: ""; + if (!g_atomic_pointer_compare_and_exchange(&proc_cmdline_cached, NULL, proc_cmdline)) + goto again; - g_steal_pointer (&str); - } + g_steal_pointer(&str); + } - return proc_cmdline; + return proc_cmdline; } -const char *const* -nm_utils_proc_cmdline_split (void) +const char *const * +nm_utils_proc_cmdline_split(void) { - static const char *const*volatile proc_cmdline_cached = NULL; - const char *const*proc_cmdline; + static const char *const *volatile proc_cmdline_cached = NULL; + const char *const *proc_cmdline; again: - proc_cmdline = g_atomic_pointer_get (&proc_cmdline_cached); - if (G_UNLIKELY (!proc_cmdline)) { - gs_strfreev char **split = NULL; + proc_cmdline = g_atomic_pointer_get(&proc_cmdline_cached); + if (G_UNLIKELY(!proc_cmdline)) { + gs_strfreev char **split = NULL; - split = nm_utils_strsplit_quoted (nm_utils_proc_cmdline ()); - if (!g_atomic_pointer_compare_and_exchange (&proc_cmdline_cached, NULL, (gpointer) split)) - goto again; + split = nm_utils_strsplit_quoted(nm_utils_proc_cmdline()); + if (!g_atomic_pointer_compare_and_exchange(&proc_cmdline_cached, NULL, (gpointer) split)) + goto again; - proc_cmdline = (const char *const*) g_steal_pointer (&split); - } + proc_cmdline = (const char *const *) g_steal_pointer(&split); + } - return proc_cmdline; + return proc_cmdline; } /*****************************************************************************/ @@ -2930,94 +3243,88 @@ again: * * Returns: the arp-type or negative value on error. */ int -nm_utils_arp_type_detect_from_hwaddrlen (gsize hwaddr_len) +nm_utils_arp_type_detect_from_hwaddrlen(gsize hwaddr_len) { - switch (hwaddr_len) { - case ETH_ALEN: - return ARPHRD_ETHER; - case INFINIBAND_ALEN: - return ARPHRD_INFINIBAND; - default: - /* Note: if you ever support anything but ethernet and infiniband, - * make sure to look at all callers. They assert that it's one of - * these two. */ - return -EINVAL; - } + switch (hwaddr_len) { + case ETH_ALEN: + return ARPHRD_ETHER; + case INFINIBAND_ALEN: + return ARPHRD_INFINIBAND; + default: + /* Note: if you ever support anything but ethernet and infiniband, + * make sure to look at all callers. They assert that it's one of + * these two. */ + return -EINVAL; + } } gboolean -nm_utils_arp_type_validate_hwaddr (int arp_type, - const guint8 *hwaddr, - gsize hwaddr_len) +nm_utils_arp_type_validate_hwaddr(int arp_type, const guint8 *hwaddr, gsize hwaddr_len) { - - if (!hwaddr) - return FALSE; - - if (arp_type == ARPHRD_ETHER) { - G_STATIC_ASSERT (ARPHRD_ETHER >= 0 && ARPHRD_ETHER <= 0xFF); - if (hwaddr_len != ETH_ALEN) - return FALSE; - } else if (arp_type == ARPHRD_INFINIBAND) { - G_STATIC_ASSERT (ARPHRD_INFINIBAND >= 0 && ARPHRD_INFINIBAND <= 0xFF); - if (hwaddr_len != INFINIBAND_ALEN) - return FALSE; - } else - return FALSE; - - nm_assert (arp_type == nm_utils_arp_type_detect_from_hwaddrlen (hwaddr_len)); - return TRUE; + if (!hwaddr) + return FALSE; + + if (arp_type == ARPHRD_ETHER) { + G_STATIC_ASSERT(ARPHRD_ETHER >= 0 && ARPHRD_ETHER <= 0xFF); + if (hwaddr_len != ETH_ALEN) + return FALSE; + } else if (arp_type == ARPHRD_INFINIBAND) { + G_STATIC_ASSERT(ARPHRD_INFINIBAND >= 0 && ARPHRD_INFINIBAND <= 0xFF); + if (hwaddr_len != INFINIBAND_ALEN) + return FALSE; + } else + return FALSE; + + nm_assert(arp_type == nm_utils_arp_type_detect_from_hwaddrlen(hwaddr_len)); + return TRUE; } gboolean -nm_utils_arp_type_get_hwaddr_relevant_part (int arp_type, - const guint8 **hwaddr, - gsize *hwaddr_len) +nm_utils_arp_type_get_hwaddr_relevant_part(int arp_type, const guint8 **hwaddr, gsize *hwaddr_len) { - g_return_val_if_fail ( hwaddr - && hwaddr_len - && nm_utils_arp_type_validate_hwaddr (arp_type, *hwaddr, *hwaddr_len), - FALSE); - - /* for infiniband, we only consider the last 8 bytes. */ - if (arp_type == ARPHRD_INFINIBAND) { - *hwaddr += (INFINIBAND_ALEN - 8); - *hwaddr_len = 8; - } - - return TRUE; + g_return_val_if_fail(hwaddr && hwaddr_len + && nm_utils_arp_type_validate_hwaddr(arp_type, *hwaddr, *hwaddr_len), + FALSE); + + /* for infiniband, we only consider the last 8 bytes. */ + if (arp_type == ARPHRD_INFINIBAND) { + *hwaddr += (INFINIBAND_ALEN - 8); + *hwaddr_len = 8; + } + + return TRUE; } /*****************************************************************************/ /* Returns the "u" (universal/local) bit value for a Modified EUI-64 */ static gboolean -get_gre_eui64_u_bit (guint32 addr) +get_gre_eui64_u_bit(guint32 addr) { - static const struct { - guint32 mask; - guint32 result; - } items[] = { - { 0xff000000 }, { 0x7f000000 }, /* IPv4 loopback */ - { 0xf0000000 }, { 0xe0000000 }, /* IPv4 multicast */ - { 0xffffff00 }, { 0xe0000000 }, /* IPv4 local multicast */ - { 0xffffffff }, { INADDR_BROADCAST }, /* limited broadcast */ - { 0xff000000 }, { 0x00000000 }, /* zero net */ - { 0xff000000 }, { 0x0a000000 }, /* private 10 (RFC3330) */ - { 0xfff00000 }, { 0xac100000 }, /* private 172 */ - { 0xffff0000 }, { 0xc0a80000 }, /* private 192 */ - { 0xffff0000 }, { 0xa9fe0000 }, /* IPv4 link-local */ - { 0xffffff00 }, { 0xc0586300 }, /* anycast 6-to-4 */ - { 0xffffff00 }, { 0xc0000200 }, /* test 192 */ - { 0xfffe0000 }, { 0xc6120000 }, /* test 198 */ - }; - guint i; - - for (i = 0; i < G_N_ELEMENTS (items); i++) { - if ((addr & htonl (items[i].mask)) == htonl (items[i].result)) - return 0x00; /* "local" scope */ - } - return 0x02; /* "universal" scope */ + static const struct { + guint32 mask; + guint32 result; + } items[] = { + {0xff000000}, {0x7f000000}, /* IPv4 loopback */ + {0xf0000000}, {0xe0000000}, /* IPv4 multicast */ + {0xffffff00}, {0xe0000000}, /* IPv4 local multicast */ + {0xffffffff}, {INADDR_BROADCAST}, /* limited broadcast */ + {0xff000000}, {0x00000000}, /* zero net */ + {0xff000000}, {0x0a000000}, /* private 10 (RFC3330) */ + {0xfff00000}, {0xac100000}, /* private 172 */ + {0xffff0000}, {0xc0a80000}, /* private 192 */ + {0xffff0000}, {0xa9fe0000}, /* IPv4 link-local */ + {0xffffff00}, {0xc0586300}, /* anycast 6-to-4 */ + {0xffffff00}, {0xc0000200}, /* test 192 */ + {0xfffe0000}, {0xc6120000}, /* test 198 */ + }; + guint i; + + for (i = 0; i < G_N_ELEMENTS(items); i++) { + if ((addr & htonl(items[i].mask)) == htonl(items[i].result)) + return 0x00; /* "local" scope */ + } + return 0x02; /* "universal" scope */ } /** @@ -3037,70 +3344,70 @@ get_gre_eui64_u_bit (guint32 addr) * if could not be constructed. */ gboolean -nm_utils_get_ipv6_interface_identifier (NMLinkType link_type, - const guint8 *hwaddr, - guint hwaddr_len, - guint dev_id, - NMUtilsIPv6IfaceId *out_iid) +nm_utils_get_ipv6_interface_identifier(NMLinkType link_type, + const guint8 * hwaddr, + guint hwaddr_len, + guint dev_id, + NMUtilsIPv6IfaceId *out_iid) { - guint32 addr; - - g_return_val_if_fail (hwaddr != NULL, FALSE); - g_return_val_if_fail (hwaddr_len > 0, FALSE); - g_return_val_if_fail (out_iid != NULL, FALSE); - - out_iid->id = 0; - - switch (link_type) { - case NM_LINK_TYPE_INFINIBAND: - /* Use the port GUID per http://tools.ietf.org/html/rfc4391#section-8, - * making sure to set the 'u' bit to 1. The GUID is the lower 64 bits - * of the IPoIB interface's hardware address. - */ - g_return_val_if_fail (hwaddr_len == INFINIBAND_ALEN, FALSE); - memcpy (out_iid->id_u8, hwaddr + INFINIBAND_ALEN - 8, 8); - out_iid->id_u8[0] |= 0x02; - return TRUE; - case NM_LINK_TYPE_GRE: - /* Hardware address is the network-endian IPv4 address */ - g_return_val_if_fail (hwaddr_len == 4, FALSE); - addr = * (guint32 *) hwaddr; - out_iid->id_u8[0] = get_gre_eui64_u_bit (addr); - out_iid->id_u8[1] = 0x00; - out_iid->id_u8[2] = 0x5E; - out_iid->id_u8[3] = 0xFE; - memcpy (out_iid->id_u8 + 4, &addr, 4); - return TRUE; - case NM_LINK_TYPE_6LOWPAN: - /* The hardware address is already 64-bit. This is the case for - * IEEE 802.15.4 networks. */ - memcpy (out_iid->id_u8, hwaddr, sizeof (out_iid->id_u8)); - return TRUE; - default: - if (hwaddr_len == ETH_ALEN) { - /* Translate 48-bit MAC address to a 64-bit Modified EUI-64. See - * http://tools.ietf.org/html/rfc4291#appendix-A and the Linux - * kernel's net/ipv6/addrconf.c::ipv6_generate_eui64() function. - */ - out_iid->id_u8[0] = hwaddr[0]; - out_iid->id_u8[1] = hwaddr[1]; - out_iid->id_u8[2] = hwaddr[2]; - if (dev_id) { - out_iid->id_u8[3] = (dev_id >> 8) & 0xff; - out_iid->id_u8[4] = dev_id & 0xff; - } else { - out_iid->id_u8[0] ^= 0x02; - out_iid->id_u8[3] = 0xff; - out_iid->id_u8[4] = 0xfe; - } - out_iid->id_u8[5] = hwaddr[3]; - out_iid->id_u8[6] = hwaddr[4]; - out_iid->id_u8[7] = hwaddr[5]; - return TRUE; - } - break; - } - return FALSE; + guint32 addr; + + g_return_val_if_fail(hwaddr != NULL, FALSE); + g_return_val_if_fail(hwaddr_len > 0, FALSE); + g_return_val_if_fail(out_iid != NULL, FALSE); + + out_iid->id = 0; + + switch (link_type) { + case NM_LINK_TYPE_INFINIBAND: + /* Use the port GUID per http://tools.ietf.org/html/rfc4391#section-8, + * making sure to set the 'u' bit to 1. The GUID is the lower 64 bits + * of the IPoIB interface's hardware address. + */ + g_return_val_if_fail(hwaddr_len == INFINIBAND_ALEN, FALSE); + memcpy(out_iid->id_u8, hwaddr + INFINIBAND_ALEN - 8, 8); + out_iid->id_u8[0] |= 0x02; + return TRUE; + case NM_LINK_TYPE_GRE: + /* Hardware address is the network-endian IPv4 address */ + g_return_val_if_fail(hwaddr_len == 4, FALSE); + addr = *(guint32 *) hwaddr; + out_iid->id_u8[0] = get_gre_eui64_u_bit(addr); + out_iid->id_u8[1] = 0x00; + out_iid->id_u8[2] = 0x5E; + out_iid->id_u8[3] = 0xFE; + memcpy(out_iid->id_u8 + 4, &addr, 4); + return TRUE; + case NM_LINK_TYPE_6LOWPAN: + /* The hardware address is already 64-bit. This is the case for + * IEEE 802.15.4 networks. */ + memcpy(out_iid->id_u8, hwaddr, sizeof(out_iid->id_u8)); + return TRUE; + default: + if (hwaddr_len == ETH_ALEN) { + /* Translate 48-bit MAC address to a 64-bit Modified EUI-64. See + * http://tools.ietf.org/html/rfc4291#appendix-A and the Linux + * kernel's net/ipv6/addrconf.c::ipv6_generate_eui64() function. + */ + out_iid->id_u8[0] = hwaddr[0]; + out_iid->id_u8[1] = hwaddr[1]; + out_iid->id_u8[2] = hwaddr[2]; + if (dev_id) { + out_iid->id_u8[3] = (dev_id >> 8) & 0xff; + out_iid->id_u8[4] = dev_id & 0xff; + } else { + out_iid->id_u8[0] ^= 0x02; + out_iid->id_u8[3] = 0xff; + out_iid->id_u8[4] = 0xfe; + } + out_iid->id_u8[5] = hwaddr[3]; + out_iid->id_u8[6] = hwaddr[4]; + out_iid->id_u8[7] = hwaddr[5]; + return TRUE; + } + break; + } + return FALSE; } /*****************************************************************************/ @@ -3116,10 +3423,9 @@ nm_utils_get_ipv6_interface_identifier (NMLinkType link_type, * token. */ void -nm_utils_ipv6_addr_set_interface_identifier (struct in6_addr *addr, - const NMUtilsIPv6IfaceId iid) +nm_utils_ipv6_addr_set_interface_identifier(struct in6_addr *addr, const NMUtilsIPv6IfaceId iid) { - memcpy (addr->s6_addr + 8, &iid.id_u8, 8); + memcpy(addr->s6_addr + 8, &iid.id_u8, 8); } /** @@ -3131,10 +3437,10 @@ nm_utils_ipv6_addr_set_interface_identifier (struct in6_addr *addr, * the interface identifier. */ void -nm_utils_ipv6_interface_identifier_get_from_addr (NMUtilsIPv6IfaceId *iid, +nm_utils_ipv6_interface_identifier_get_from_addr(NMUtilsIPv6IfaceId * iid, const struct in6_addr *addr) { - memcpy (iid, addr->s6_addr + 8, 8); + memcpy(iid, addr->s6_addr + 8, 8); } /** @@ -3148,21 +3454,20 @@ nm_utils_ipv6_interface_identifier_get_from_addr (NMUtilsIPv6IfaceId *iid, * Returns: %TRUE if the @token is a valid token, %FALSE otherwise */ gboolean -nm_utils_ipv6_interface_identifier_get_from_token (NMUtilsIPv6IfaceId *iid, - const char *token) +nm_utils_ipv6_interface_identifier_get_from_token(NMUtilsIPv6IfaceId *iid, const char *token) { - struct in6_addr i6_token; + struct in6_addr i6_token; - g_return_val_if_fail (token, FALSE); + g_return_val_if_fail(token, FALSE); - if (!inet_pton (AF_INET6, token, &i6_token)) - return FALSE; + if (!inet_pton(AF_INET6, token, &i6_token)) + return FALSE; - if (!_nm_utils_inet6_is_token (&i6_token)) - return FALSE; + if (!_nm_utils_inet6_is_token(&i6_token)) + return FALSE; - nm_utils_ipv6_interface_identifier_get_from_addr (iid, &i6_token); - return TRUE; + nm_utils_ipv6_interface_identifier_get_from_addr(iid, &i6_token); + return TRUE; } /** @@ -3176,291 +3481,299 @@ nm_utils_ipv6_interface_identifier_get_from_token (NMUtilsIPv6IfaceId *iid, * Returns: the input buffer filled with the id as string. */ const char * -nm_utils_inet6_interface_identifier_to_token (NMUtilsIPv6IfaceId iid, - char buf[static INET6_ADDRSTRLEN]) +nm_utils_inet6_interface_identifier_to_token(NMUtilsIPv6IfaceId iid, + char buf[static INET6_ADDRSTRLEN]) { - struct in6_addr i6_token = { .s6_addr = { 0, } }; + struct in6_addr i6_token = {.s6_addr = { + 0, + }}; - nm_assert (buf); - nm_utils_ipv6_addr_set_interface_identifier (&i6_token, iid); - return _nm_utils_inet6_ntop (&i6_token, buf); + nm_assert(buf); + nm_utils_ipv6_addr_set_interface_identifier(&i6_token, iid); + return _nm_utils_inet6_ntop(&i6_token, buf); } /*****************************************************************************/ char * -nm_utils_stable_id_random (void) +nm_utils_stable_id_random(void) { - char buf[15]; + char buf[15]; - nm_utils_random_bytes (buf, sizeof (buf)); - return g_base64_encode ((guchar *) buf, sizeof (buf)); + nm_utils_random_bytes(buf, sizeof(buf)); + return g_base64_encode((guchar *) buf, sizeof(buf)); } char * -nm_utils_stable_id_generated_complete (const char *stable_id_generated) +nm_utils_stable_id_generated_complete(const char *stable_id_generated) { - nm_auto_free_checksum GChecksum *sum = NULL; - guint8 buf[NM_UTILS_CHECKSUM_LENGTH_SHA1]; - char *base64; + nm_auto_free_checksum GChecksum *sum = NULL; + guint8 buf[NM_UTILS_CHECKSUM_LENGTH_SHA1]; + char * base64; - /* for NM_UTILS_STABLE_TYPE_GENERATED we generate a possibly long string - * by doing text-substitutions in nm_utils_stable_id_parse(). - * - * Let's shorten the (possibly) long stable_id to something more compact. */ + /* for NM_UTILS_STABLE_TYPE_GENERATED we generate a possibly long string + * by doing text-substitutions in nm_utils_stable_id_parse(). + * + * Let's shorten the (possibly) long stable_id to something more compact. */ - g_return_val_if_fail (stable_id_generated, NULL); + g_return_val_if_fail(stable_id_generated, NULL); - sum = g_checksum_new (G_CHECKSUM_SHA1); - g_checksum_update (sum, (guchar *) stable_id_generated, strlen (stable_id_generated)); - nm_utils_checksum_get_digest (sum, buf); + sum = g_checksum_new(G_CHECKSUM_SHA1); + g_checksum_update(sum, (guchar *) stable_id_generated, strlen(stable_id_generated)); + nm_utils_checksum_get_digest(sum, buf); - /* we don't care to use the sha1 sum in common hex representation. - * Use instead base64, it's 27 chars (stripping the padding) vs. - * 40. */ + /* we don't care to use the sha1 sum in common hex representation. + * Use instead base64, it's 27 chars (stripping the padding) vs. + * 40. */ - base64 = g_base64_encode ((guchar *) buf, sizeof (buf)); - nm_assert (strlen (base64) == 28); - nm_assert (base64[27] == '='); + base64 = g_base64_encode((guchar *) buf, sizeof(buf)); + nm_assert(strlen(base64) == 28); + nm_assert(base64[27] == '='); - base64[27] = '\0'; - return base64; + base64[27] = '\0'; + return base64; } static void -_stable_id_append (GString *str, - const char *substitution) +_stable_id_append(GString *str, const char *substitution) { - if (!substitution) - substitution = ""; - g_string_append_printf (str, "=%zu{%s}", strlen (substitution), substitution); + if (!substitution) + substitution = ""; + g_string_append_printf(str, "=%zu{%s}", strlen(substitution), substitution); } NMUtilsStableType -nm_utils_stable_id_parse (const char *stable_id, - const char *deviceid, - const char *hwaddr, - const char *bootid, - const char *uuid, - char **out_generated) +nm_utils_stable_id_parse(const char *stable_id, + const char *deviceid, + const char *hwaddr, + const char *bootid, + const char *uuid, + char ** out_generated) { - gsize i, idx_start; - GString *str = NULL; - - g_return_val_if_fail (out_generated, NM_UTILS_STABLE_TYPE_RANDOM); - - if (!stable_id) { - *out_generated = NULL; - return NM_UTILS_STABLE_TYPE_UUID; - } - - /* the stable-id allows for some dynamic by performing text-substitutions - * of ${...} patterns. - * - * At first, it looks a bit like bash parameter substitution. - * In contrast however, the process is unambiguous so that the resulting - * effective id differs if: - * - the original, untranslated stable-id differs - * - or any of the subsitutions differs. - * - * The reason for that is, for example if you specify "${CONNECTION}" in the - * stable-id, then the resulting ID should be always(!) unique for this connection. - * There should be no way another connection could specify any stable-id that results - * in the same addresses to be generated (aside hash collisions). - * - * - * For example: say you have a connection with UUID - * "123e4567-e89b-12d3-a456-426655440000" which happens also to be - * the current boot-id. - * Then: - * (1) connection.stable-id = <NULL> - * (2) connection.stable-id = "123e4567-e89b-12d3-a456-426655440000" - * (3) connection.stable-id = "${CONNECTION}" - * (3) connection.stable-id = "${BOOT}" - * will all generate different addresses, although in one way or the - * other, they all mangle the uuid "123e4567-e89b-12d3-a456-426655440000". - * - * For example, with stable-id="${FOO}${BAR}" the substitutions - * - FOO="ab", BAR="c" - * - FOO="a", BAR="bc" - * should give a different effective id. - * - * For example, with FOO="x" and BAR="x", the stable-ids - * - "${FOO}${BAR}" - * - "${BAR}${FOO}" - * should give a different effective id. - */ - - idx_start = 0; - for (i = 0; stable_id[i]; ) { - if (stable_id[i] != '$') { - i++; - continue; - } - -#define CHECK_PREFIX(prefix) \ - ({ \ - gboolean _match = FALSE; \ - \ - if (g_str_has_prefix (&stable_id[i], ""prefix"")) { \ - _match = TRUE; \ - if (!str) \ - str = g_string_sized_new (256); \ - i += NM_STRLEN (prefix); \ - g_string_append_len (str, &(stable_id)[idx_start], i - idx_start); \ - idx_start = i; \ - } \ - _match; \ - }) - if (CHECK_PREFIX ("${CONNECTION}")) - _stable_id_append (str, uuid); - else if (CHECK_PREFIX ("${BOOT}")) - _stable_id_append (str, bootid); - else if (CHECK_PREFIX ("${DEVICE}")) - _stable_id_append (str, deviceid); - else if (CHECK_PREFIX ("${MAC}")) - _stable_id_append (str, hwaddr); - else if (g_str_has_prefix (&stable_id[i], "${RANDOM}")) { - /* RANDOM makes not so much sense for cloned-mac-address - * as the result is similar to specyifing "cloned-mac-address=random". - * It makes however sense for RFC 7217 Stable Privacy IPv6 addresses - * where this is effectively the only way to generate a different - * (random) host identifier for each connect. - * - * With RANDOM, the user can switch the lifetime of the - * generated cloned-mac-address and IPv6 host identifier - * by toggeling only the stable-id property of the connection. - * With RANDOM being the most short-lived, ~non-stable~ variant. - */ - if (str) - g_string_free (str, TRUE); - *out_generated = NULL; - return NM_UTILS_STABLE_TYPE_RANDOM; - } else { - /* The text following the '$' is not recognized as valid - * substitution pattern. Treat it verbatim. */ - i++; - - /* Note that using unrecognized substitution patterns might - * yield different results with future versions. Avoid that, - * by not using '$' (except for actual substitutions) or escape - * it as "$$" (which is guaranteed to be treated verbatim - * in future). */ - if (stable_id[i] == '$') - i++; - } - } + gsize i, idx_start; + GString *str = NULL; + + g_return_val_if_fail(out_generated, NM_UTILS_STABLE_TYPE_RANDOM); + + if (!stable_id) { + *out_generated = NULL; + return NM_UTILS_STABLE_TYPE_UUID; + } + + /* the stable-id allows for some dynamic by performing text-substitutions + * of ${...} patterns. + * + * At first, it looks a bit like bash parameter substitution. + * In contrast however, the process is unambiguous so that the resulting + * effective id differs if: + * - the original, untranslated stable-id differs + * - or any of the subsitutions differs. + * + * The reason for that is, for example if you specify "${CONNECTION}" in the + * stable-id, then the resulting ID should be always(!) unique for this connection. + * There should be no way another connection could specify any stable-id that results + * in the same addresses to be generated (aside hash collisions). + * + * + * For example: say you have a connection with UUID + * "123e4567-e89b-12d3-a456-426655440000" which happens also to be + * the current boot-id. + * Then: + * (1) connection.stable-id = <NULL> + * (2) connection.stable-id = "123e4567-e89b-12d3-a456-426655440000" + * (3) connection.stable-id = "${CONNECTION}" + * (3) connection.stable-id = "${BOOT}" + * will all generate different addresses, although in one way or the + * other, they all mangle the uuid "123e4567-e89b-12d3-a456-426655440000". + * + * For example, with stable-id="${FOO}${BAR}" the substitutions + * - FOO="ab", BAR="c" + * - FOO="a", BAR="bc" + * should give a different effective id. + * + * For example, with FOO="x" and BAR="x", the stable-ids + * - "${FOO}${BAR}" + * - "${BAR}${FOO}" + * should give a different effective id. + */ + + idx_start = 0; + for (i = 0; stable_id[i];) { + if (stable_id[i] != '$') { + i++; + continue; + } + +#define CHECK_PREFIX(prefix) \ + ({ \ + gboolean _match = FALSE; \ + \ + if (g_str_has_prefix(&stable_id[i], "" prefix "")) { \ + _match = TRUE; \ + if (!str) \ + str = g_string_sized_new(256); \ + i += NM_STRLEN(prefix); \ + g_string_append_len(str, &(stable_id)[idx_start], i - idx_start); \ + idx_start = i; \ + } \ + _match; \ + }) + if (CHECK_PREFIX("${CONNECTION}")) + _stable_id_append(str, uuid); + else if (CHECK_PREFIX("${BOOT}")) + _stable_id_append(str, bootid); + else if (CHECK_PREFIX("${DEVICE}")) + _stable_id_append(str, deviceid); + else if (CHECK_PREFIX("${MAC}")) + _stable_id_append(str, hwaddr); + else if (g_str_has_prefix(&stable_id[i], "${RANDOM}")) { + /* RANDOM makes not so much sense for cloned-mac-address + * as the result is similar to specifying "cloned-mac-address=random". + * It makes however sense for RFC 7217 Stable Privacy IPv6 addresses + * where this is effectively the only way to generate a different + * (random) host identifier for each connect. + * + * With RANDOM, the user can switch the lifetime of the + * generated cloned-mac-address and IPv6 host identifier + * by toggling only the stable-id property of the connection. + * With RANDOM being the most short-lived, ~non-stable~ variant. + */ + if (str) + g_string_free(str, TRUE); + *out_generated = NULL; + return NM_UTILS_STABLE_TYPE_RANDOM; + } else { + /* The text following the '$' is not recognized as valid + * substitution pattern. Treat it verbatim. */ + i++; + + /* Note that using unrecognized substitution patterns might + * yield different results with future versions. Avoid that, + * by not using '$' (except for actual substitutions) or escape + * it as "$$" (which is guaranteed to be treated verbatim + * in future). */ + if (stable_id[i] == '$') + i++; + } + } #undef CHECK_PREFIX - if (!str) { - *out_generated = NULL; - return NM_UTILS_STABLE_TYPE_STABLE_ID; - } + if (!str) { + *out_generated = NULL; + return NM_UTILS_STABLE_TYPE_STABLE_ID; + } - if (idx_start < i) - g_string_append_len (str, &stable_id[idx_start], i - idx_start); - *out_generated = g_string_free (str, FALSE); - return NM_UTILS_STABLE_TYPE_GENERATED; + if (idx_start < i) + g_string_append_len(str, &stable_id[idx_start], i - idx_start); + *out_generated = g_string_free(str, FALSE); + return NM_UTILS_STABLE_TYPE_GENERATED; } /*****************************************************************************/ static gboolean -_is_reserved_ipv6_iid (const guint8 *iid) +_is_reserved_ipv6_iid(const guint8 *iid) { - /* https://tools.ietf.org/html/rfc5453 */ - /* https://www.iana.org/assignments/ipv6-interface-ids/ipv6-interface-ids.xml */ - - /* 0000:0000:0000:0000 (Subnet-Router Anycast [RFC4291]) */ - if (memcmp (iid, &nm_ip_addr_zero.addr6.s6_addr[8], 8) == 0) - return TRUE; - - /* 0200:5EFF:FE00:0000 - 0200:5EFF:FE00:5212 (Reserved IPv6 Interface Identifiers corresponding to the IANA Ethernet Block [RFC4291]) - * 0200:5EFF:FE00:5213 (Proxy Mobile IPv6 [RFC6543]) - * 0200:5EFF:FE00:5214 - 0200:5EFF:FEFF:FFFF (Reserved IPv6 Interface Identifiers corresponding to the IANA Ethernet Block [RFC4291]) */ - if (memcmp (iid, (const guint8[]) { 0x02, 0x00, 0x5E, 0xFF, 0xFE }, 5) == 0) - return TRUE; - - /* FDFF:FFFF:FFFF:FF80 - FDFF:FFFF:FFFF:FFFF (Reserved Subnet Anycast Addresses [RFC2526]) */ - if (memcmp (iid, (const guint8[]) { 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, 7) == 0) { - if (iid[7] & 0x80) - return TRUE; - } - - return FALSE; + /* https://tools.ietf.org/html/rfc5453 */ + /* https://www.iana.org/assignments/ipv6-interface-ids/ipv6-interface-ids.xml */ + + /* 0000:0000:0000:0000 (Subnet-Router Anycast [RFC4291]) */ + if (memcmp(iid, &nm_ip_addr_zero.addr6.s6_addr[8], 8) == 0) + return TRUE; + + /* 0200:5EFF:FE00:0000 - 0200:5EFF:FE00:5212 (Reserved IPv6 Interface Identifiers corresponding to the IANA Ethernet Block [RFC4291]) + * 0200:5EFF:FE00:5213 (Proxy Mobile IPv6 [RFC6543]) + * 0200:5EFF:FE00:5214 - 0200:5EFF:FEFF:FFFF (Reserved IPv6 Interface Identifiers corresponding to the IANA Ethernet Block [RFC4291]) */ + if (memcmp(iid, (const guint8[]){0x02, 0x00, 0x5E, 0xFF, 0xFE}, 5) == 0) + return TRUE; + + /* FDFF:FFFF:FFFF:FF80 - FDFF:FFFF:FFFF:FFFF (Reserved Subnet Anycast Addresses [RFC2526]) */ + if (memcmp(iid, (const guint8[]){0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 7) == 0) { + if (iid[7] & 0x80) + return TRUE; + } + + return FALSE; } static gboolean -_set_stable_privacy (NMUtilsStableType stable_type, - struct in6_addr *addr, - const char *ifname, - const char *network_id, - guint32 dad_counter, - const guint8 *host_id, - gsize host_id_len, - GError **error) +_set_stable_privacy(NMUtilsStableType stable_type, + struct in6_addr * addr, + const char * ifname, + const char * network_id, + guint32 dad_counter, + const guint8 * host_id, + gsize host_id_len, + GError ** error) { - nm_auto_free_checksum GChecksum *sum = NULL; - guint8 digest[NM_UTILS_CHECKSUM_LENGTH_SHA256]; - guint32 tmp[2]; - - nm_assert (host_id_len); - nm_assert (network_id); - - sum = g_checksum_new (G_CHECKSUM_SHA256); - - host_id_len = MIN (host_id_len, G_MAXUINT32); - - if (stable_type != NM_UTILS_STABLE_TYPE_UUID) { - guint8 stable_type_uint8; - - nm_assert (stable_type < (NMUtilsStableType) 255); - stable_type_uint8 = (guint8) stable_type; - - /* Preferably, we would always like to include the stable-type, - * but for backward compatibility reasons, we cannot for UUID. - * - * That is no real problem and it is still impossible to - * force a collision here, because of how the remaining - * fields are hashed. That is, as we also hash @host_id_len - * and the terminating '\0' of @network_id, it is unambigiously - * possible to revert the process and deduce the @stable_type. - */ - g_checksum_update (sum, &stable_type_uint8, sizeof (stable_type_uint8)); - } - - g_checksum_update (sum, addr->s6_addr, 8); - g_checksum_update (sum, (const guchar *) ifname, strlen (ifname) + 1); - g_checksum_update (sum, (const guchar *) network_id, strlen (network_id) + 1); - tmp[0] = htonl (dad_counter); - tmp[1] = htonl (host_id_len); - g_checksum_update (sum, (const guchar *) tmp, sizeof (tmp)); - g_checksum_update (sum, (const guchar *) host_id, host_id_len); - nm_utils_checksum_get_digest (sum, digest); - - while (_is_reserved_ipv6_iid (digest)) { - g_checksum_reset (sum); - tmp[0] = htonl (++dad_counter); - g_checksum_update (sum, digest, sizeof (digest)); - g_checksum_update (sum, (const guchar *) &tmp[0], sizeof (tmp[0])); - nm_utils_checksum_get_digest (sum, digest); - } - - memcpy (addr->s6_addr + 8, &digest[0], 8); - return TRUE; + nm_auto_free_checksum GChecksum *sum = NULL; + guint8 digest[NM_UTILS_CHECKSUM_LENGTH_SHA256]; + guint32 tmp[2]; + + nm_assert(host_id_len); + nm_assert(network_id); + + sum = g_checksum_new(G_CHECKSUM_SHA256); + + host_id_len = MIN(host_id_len, G_MAXUINT32); + + if (stable_type != NM_UTILS_STABLE_TYPE_UUID) { + guint8 stable_type_uint8; + + nm_assert(stable_type < (NMUtilsStableType) 255); + stable_type_uint8 = (guint8) stable_type; + + /* Preferably, we would always like to include the stable-type, + * but for backward compatibility reasons, we cannot for UUID. + * + * That is no real problem and it is still impossible to + * force a collision here, because of how the remaining + * fields are hashed. That is, as we also hash @host_id_len + * and the terminating '\0' of @network_id, it is unambiguously + * possible to revert the process and deduce the @stable_type. + */ + g_checksum_update(sum, &stable_type_uint8, sizeof(stable_type_uint8)); + } + + g_checksum_update(sum, addr->s6_addr, 8); + g_checksum_update(sum, (const guchar *) ifname, strlen(ifname) + 1); + g_checksum_update(sum, (const guchar *) network_id, strlen(network_id) + 1); + tmp[0] = htonl(dad_counter); + tmp[1] = htonl(host_id_len); + g_checksum_update(sum, (const guchar *) tmp, sizeof(tmp)); + g_checksum_update(sum, (const guchar *) host_id, host_id_len); + nm_utils_checksum_get_digest(sum, digest); + + while (_is_reserved_ipv6_iid(digest)) { + g_checksum_reset(sum); + tmp[0] = htonl(++dad_counter); + g_checksum_update(sum, digest, sizeof(digest)); + g_checksum_update(sum, (const guchar *) &tmp[0], sizeof(tmp[0])); + nm_utils_checksum_get_digest(sum, digest); + } + + memcpy(addr->s6_addr + 8, &digest[0], 8); + return TRUE; } gboolean -nm_utils_ipv6_addr_set_stable_privacy_impl (NMUtilsStableType stable_type, - struct in6_addr *addr, - const char *ifname, - const char *network_id, - guint32 dad_counter, - guint8 *host_id, - gsize host_id_len, - GError **error) +nm_utils_ipv6_addr_set_stable_privacy_impl(NMUtilsStableType stable_type, + struct in6_addr * addr, + const char * ifname, + const char * network_id, + guint32 dad_counter, + guint8 * host_id, + gsize host_id_len, + GError ** error) { - return _set_stable_privacy (stable_type, addr, ifname, network_id, dad_counter, host_id, host_id_len, error); + return _set_stable_privacy(stable_type, + addr, + ifname, + network_id, + dad_counter, + host_id, + host_id_len, + error); } #define RFC7217_IDGEN_RETRIES 3 @@ -3473,190 +3786,218 @@ nm_utils_ipv6_addr_set_stable_privacy_impl (NMUtilsStableType stable_type, * Returns: %TRUE on success, %FALSE if the address could not be generated. */ gboolean -nm_utils_ipv6_addr_set_stable_privacy (NMUtilsStableType stable_type, - struct in6_addr *addr, - const char *ifname, - const char *network_id, - guint32 dad_counter, - GError **error) +nm_utils_ipv6_addr_set_stable_privacy(NMUtilsStableType stable_type, + struct in6_addr * addr, + const char * ifname, + const char * network_id, + guint32 dad_counter, + GError ** error) { - const guint8 *host_id; - gsize host_id_len; - - g_return_val_if_fail (network_id, FALSE); - - if (dad_counter >= RFC7217_IDGEN_RETRIES) { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - "Too many DAD collisions"); - return FALSE; - } - - nm_utils_host_id_get (&host_id, &host_id_len); - - return _set_stable_privacy (stable_type, addr, ifname, network_id, dad_counter, - host_id, host_id_len, error); + const guint8 *host_id; + gsize host_id_len; + + g_return_val_if_fail(network_id, FALSE); + + if (dad_counter >= RFC7217_IDGEN_RETRIES) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "Too many DAD collisions"); + return FALSE; + } + + nm_utils_host_id_get(&host_id, &host_id_len); + + return _set_stable_privacy(stable_type, + addr, + ifname, + network_id, + dad_counter, + host_id, + host_id_len, + error); } /*****************************************************************************/ static void -_hw_addr_eth_complete (struct ether_addr *addr, - const char *current_mac_address, - const char *generate_mac_address_mask) +_hw_addr_eth_complete(struct ether_addr *addr, + const char * current_mac_address, + const char * generate_mac_address_mask) { - struct ether_addr mask; - struct ether_addr oui; - struct ether_addr *ouis; - gsize ouis_len; - guint i; - - /* the second LSB of the first octet means - * "globally unique, OUI enforced, BIA (burned-in-address)" - * vs. "locally-administered". By default, set it to - * generate locally-administered addresses. - * - * Maybe be overwritten by a mask below. */ - addr->ether_addr_octet[0] |= 2; - - if (!generate_mac_address_mask || !*generate_mac_address_mask) - goto out; - if (!_nm_utils_generate_mac_address_mask_parse (generate_mac_address_mask, - &mask, - &ouis, - &ouis_len, - NULL)) - goto out; - - nm_assert ((ouis == NULL) ^ (ouis_len != 0)); - if (ouis) { - /* g_random_int() is good enough here. It uses a static GRand instance - * that is seeded from /dev/urandom. */ - oui = ouis[g_random_int () % ouis_len]; - g_free (ouis); - } else { - if (!nm_utils_hwaddr_aton (current_mac_address, &oui, ETH_ALEN)) - goto out; - } - - for (i = 0; i < ETH_ALEN; i++) { - const guint8 a = addr->ether_addr_octet[i]; - const guint8 o = oui.ether_addr_octet[i]; - const guint8 m = mask.ether_addr_octet[i]; - - addr->ether_addr_octet[i] = (a & ~m) | (o & m); - } + struct ether_addr mask; + struct ether_addr oui; + struct ether_addr *ouis; + gsize ouis_len; + guint i; + + /* the second LSB of the first octet means + * "globally unique, OUI enforced, BIA (burned-in-address)" + * vs. "locally-administered". By default, set it to + * generate locally-administered addresses. + * + * Maybe be overwritten by a mask below. */ + addr->ether_addr_octet[0] |= 2; + + if (!generate_mac_address_mask || !*generate_mac_address_mask) + goto out; + if (!_nm_utils_generate_mac_address_mask_parse(generate_mac_address_mask, + &mask, + &ouis, + &ouis_len, + NULL)) + goto out; + + nm_assert((ouis == NULL) ^ (ouis_len != 0)); + if (ouis) { + /* g_random_int() is good enough here. It uses a static GRand instance + * that is seeded from /dev/urandom. */ + oui = ouis[g_random_int() % ouis_len]; + g_free(ouis); + } else { + if (!nm_utils_hwaddr_aton(current_mac_address, &oui, ETH_ALEN)) + goto out; + } + + for (i = 0; i < ETH_ALEN; i++) { + const guint8 a = addr->ether_addr_octet[i]; + const guint8 o = oui.ether_addr_octet[i]; + const guint8 m = mask.ether_addr_octet[i]; + + addr->ether_addr_octet[i] = (a & ~m) | (o & m); + } out: - /* The LSB of the first octet must always be cleared, - * it means Unicast vs. Multicast */ - addr->ether_addr_octet[0] &= ~1; + /* The LSB of the first octet must always be cleared, + * it means Unicast vs. Multicast */ + addr->ether_addr_octet[0] &= ~1; } char * -nm_utils_hw_addr_gen_random_eth (const char *current_mac_address, - const char *generate_mac_address_mask) +nm_utils_hw_addr_gen_random_eth(const char *current_mac_address, + const char *generate_mac_address_mask) { - struct ether_addr bin_addr; + struct ether_addr bin_addr; - nm_utils_random_bytes (&bin_addr, ETH_ALEN); - _hw_addr_eth_complete (&bin_addr, current_mac_address, generate_mac_address_mask); - return nm_utils_hwaddr_ntoa (&bin_addr, ETH_ALEN); + nm_utils_random_bytes(&bin_addr, ETH_ALEN); + _hw_addr_eth_complete(&bin_addr, current_mac_address, generate_mac_address_mask); + return nm_utils_hwaddr_ntoa(&bin_addr, ETH_ALEN); } static char * -_hw_addr_gen_stable_eth (NMUtilsStableType stable_type, - const char *stable_id, - const guint8 *host_id, - gsize host_id_len, - const char *ifname, - const char *current_mac_address, - const char *generate_mac_address_mask) +_hw_addr_gen_stable_eth(NMUtilsStableType stable_type, + const char * stable_id, + const guint8 * host_id, + gsize host_id_len, + const char * ifname, + const char * current_mac_address, + const char * generate_mac_address_mask) { - nm_auto_free_checksum GChecksum *sum = NULL; - guint32 tmp; - guint8 digest[NM_UTILS_CHECKSUM_LENGTH_SHA256]; - struct ether_addr bin_addr; - guint8 stable_type_uint8; + nm_auto_free_checksum GChecksum *sum = NULL; + guint32 tmp; + guint8 digest[NM_UTILS_CHECKSUM_LENGTH_SHA256]; + struct ether_addr bin_addr; + guint8 stable_type_uint8; - nm_assert (stable_id); - nm_assert (host_id); + nm_assert(stable_id); + nm_assert(host_id); - sum = g_checksum_new (G_CHECKSUM_SHA256); + sum = g_checksum_new(G_CHECKSUM_SHA256); - host_id_len = MIN (host_id_len, G_MAXUINT32); + host_id_len = MIN(host_id_len, G_MAXUINT32); - nm_assert (stable_type < (NMUtilsStableType) 255); - stable_type_uint8 = stable_type; - g_checksum_update (sum, (const guchar *) &stable_type_uint8, sizeof (stable_type_uint8)); + nm_assert(stable_type < (NMUtilsStableType) 255); + stable_type_uint8 = stable_type; + g_checksum_update(sum, (const guchar *) &stable_type_uint8, sizeof(stable_type_uint8)); - tmp = htonl ((guint32) host_id_len); - g_checksum_update (sum, (const guchar *) &tmp, sizeof (tmp)); - g_checksum_update (sum, (const guchar *) host_id, host_id_len); - g_checksum_update (sum, (const guchar *) (ifname ?: ""), ifname ? (strlen (ifname) + 1) : 1); - g_checksum_update (sum, (const guchar *) stable_id, strlen (stable_id) + 1); + tmp = htonl((guint32) host_id_len); + g_checksum_update(sum, (const guchar *) &tmp, sizeof(tmp)); + g_checksum_update(sum, (const guchar *) host_id, host_id_len); + g_checksum_update(sum, (const guchar *) (ifname ?: ""), ifname ? (strlen(ifname) + 1) : 1); + g_checksum_update(sum, (const guchar *) stable_id, strlen(stable_id) + 1); - nm_utils_checksum_get_digest (sum, digest); + nm_utils_checksum_get_digest(sum, digest); - memcpy (&bin_addr, digest, ETH_ALEN); - _hw_addr_eth_complete (&bin_addr, current_mac_address, generate_mac_address_mask); - return nm_utils_hwaddr_ntoa (&bin_addr, ETH_ALEN); + memcpy(&bin_addr, digest, ETH_ALEN); + _hw_addr_eth_complete(&bin_addr, current_mac_address, generate_mac_address_mask); + return nm_utils_hwaddr_ntoa(&bin_addr, ETH_ALEN); } char * -nm_utils_hw_addr_gen_stable_eth_impl (NMUtilsStableType stable_type, - const char *stable_id, - const guint8 *host_id, - gsize host_id_len, - const char *ifname, - const char *current_mac_address, - const char *generate_mac_address_mask) +nm_utils_hw_addr_gen_stable_eth_impl(NMUtilsStableType stable_type, + const char * stable_id, + const guint8 * host_id, + gsize host_id_len, + const char * ifname, + const char * current_mac_address, + const char * generate_mac_address_mask) { - return _hw_addr_gen_stable_eth (stable_type, stable_id, host_id, host_id_len, ifname, current_mac_address, generate_mac_address_mask); + return _hw_addr_gen_stable_eth(stable_type, + stable_id, + host_id, + host_id_len, + ifname, + current_mac_address, + generate_mac_address_mask); } char * -nm_utils_hw_addr_gen_stable_eth (NMUtilsStableType stable_type, - const char *stable_id, - const char *ifname, - const char *current_mac_address, - const char *generate_mac_address_mask) +nm_utils_hw_addr_gen_stable_eth(NMUtilsStableType stable_type, + const char * stable_id, + const char * ifname, + const char * current_mac_address, + const char * generate_mac_address_mask) { - const guint8 *host_id; - gsize host_id_len; + const guint8 *host_id; + gsize host_id_len; - g_return_val_if_fail (stable_id, NULL); + g_return_val_if_fail(stable_id, NULL); - nm_utils_host_id_get (&host_id, &host_id_len); + nm_utils_host_id_get(&host_id, &host_id_len); - return _hw_addr_gen_stable_eth (stable_type, - stable_id, - host_id, - host_id_len, - ifname, - current_mac_address, - generate_mac_address_mask); + return _hw_addr_gen_stable_eth(stable_type, + stable_id, + host_id, + host_id_len, + ifname, + current_mac_address, + generate_mac_address_mask); } /*****************************************************************************/ GBytes * -nm_utils_dhcp_client_id_mac (int arp_type, - const guint8 *hwaddr, - gsize hwaddr_len) +nm_utils_dhcp_client_id_mac(int arp_type, const guint8 *hwaddr, gsize hwaddr_len) { - guint8 *client_id_buf; - const guint8 hwaddr_type = arp_type; + guint8 * client_id_buf; + const guint8 hwaddr_type = arp_type; - if (!nm_utils_arp_type_get_hwaddr_relevant_part (arp_type, &hwaddr, &hwaddr_len)) - g_return_val_if_reached (NULL); + if (!nm_utils_arp_type_get_hwaddr_relevant_part(arp_type, &hwaddr, &hwaddr_len)) + g_return_val_if_reached(NULL); - client_id_buf = g_malloc (hwaddr_len + 1); - client_id_buf[0] = hwaddr_type; - memcpy (&client_id_buf[1], hwaddr, hwaddr_len); - return g_bytes_new_take (client_id_buf, hwaddr_len + 1); + client_id_buf = g_malloc(hwaddr_len + 1); + client_id_buf[0] = hwaddr_type; + memcpy(&client_id_buf[1], hwaddr, hwaddr_len); + return g_bytes_new_take(client_id_buf, hwaddr_len + 1); } -#define HASH_KEY ((const guint8[16]) { 0x80, 0x11, 0x8c, 0xc2, 0xfe, 0x4a, 0x03, 0xee, 0x3e, 0xd6, 0x0c, 0x6f, 0x36, 0x39, 0x14, 0x09 }) +#define HASH_KEY \ + ((const guint8[16]){0x80, \ + 0x11, \ + 0x8c, \ + 0xc2, \ + 0xfe, \ + 0x4a, \ + 0x03, \ + 0xee, \ + 0x3e, \ + 0xd6, \ + 0x0c, \ + 0x6f, \ + 0x36, \ + 0x39, \ + 0x14, \ + 0x09}) /** * nm_utils_create_dhcp_iaid: @@ -3673,30 +4014,30 @@ nm_utils_dhcp_client_id_mac (int arp_type, * * Returns: the IAID in host byte order. */ guint32 -nm_utils_create_dhcp_iaid (gboolean legacy_unstable_byteorder, - const guint8 *interface_id, - gsize interface_id_len) +nm_utils_create_dhcp_iaid(gboolean legacy_unstable_byteorder, + const guint8 *interface_id, + gsize interface_id_len) { - guint64 u64; - guint32 u32; - - u64 = c_siphash_hash (HASH_KEY, interface_id, interface_id_len); - u32 = (u64 & 0xffffffffu) ^ (u64 >> 32); - if (legacy_unstable_byteorder) { - /* legacy systemd code dhcp_identifier_set_iaid() generates the iaid - * dependent on the host endianness. Since this function returns the IAID - * in native-byte order, we need to account for that. - * - * On little endian systems, we want the legacy-behavior is identical to - * the endianness-agnostic behavior. So, we need to swap the bytes on - * big-endian systems. - * - * (https://github.com/systemd/systemd/pull/10614). */ - return htole32 (u32); - } else { - /* we return the value as-is, in native byte order. */ - return u32; - } + guint64 u64; + guint32 u32; + + u64 = c_siphash_hash(HASH_KEY, interface_id, interface_id_len); + u32 = (u64 & 0xffffffffu) ^ (u64 >> 32); + if (legacy_unstable_byteorder) { + /* legacy systemd code dhcp_identifier_set_iaid() generates the iaid + * dependent on the host endianness. Since this function returns the IAID + * in native-byte order, we need to account for that. + * + * On little endian systems, we want the legacy-behavior is identical to + * the endianness-agnostic behavior. So, we need to swap the bytes on + * big-endian systems. + * + * (https://github.com/systemd/systemd/pull/10614). */ + return htole32(u32); + } else { + /* we return the value as-is, in native byte order. */ + return u32; + } } /** @@ -3713,51 +4054,154 @@ nm_utils_create_dhcp_iaid (gboolean legacy_unstable_byteorder, * Returns: a %GBytes of generated client-id. This function cannot fail. */ GBytes * -nm_utils_dhcp_client_id_systemd_node_specific_full (guint32 iaid, - const guint8 *machine_id, - gsize machine_id_len) +nm_utils_dhcp_client_id_systemd_node_specific_full(guint32 iaid, + const guint8 *machine_id, + gsize machine_id_len) +{ + const guint16 DUID_TYPE_EN = 2; + const guint32 SYSTEMD_PEN = 43793; + struct _nm_packed { + guint8 type; + guint32 iaid; + struct _nm_packed { + guint16 type; + union { + struct _nm_packed { + /* DUID_TYPE_EN */ + guint32 pen; + uint8_t id[8]; + } en; + }; + } duid; + } * client_id; + guint64 u64; + + g_return_val_if_fail(machine_id, NULL); + g_return_val_if_fail(machine_id_len > 0, NULL); + + client_id = g_malloc(sizeof(*client_id)); + + client_id->type = 255; + unaligned_write_be32(&client_id->iaid, iaid); + unaligned_write_be16(&client_id->duid.type, DUID_TYPE_EN); + unaligned_write_be32(&client_id->duid.en.pen, SYSTEMD_PEN); + + u64 = htole64(c_siphash_hash(HASH_KEY, machine_id, machine_id_len)); + memcpy(client_id->duid.en.id, &u64, sizeof(client_id->duid.en.id)); + + G_STATIC_ASSERT_EXPR(sizeof(*client_id) == 19); + return g_bytes_new_take(client_id, 19); +} + +GBytes * +nm_utils_dhcp_client_id_systemd_node_specific(guint32 iaid) +{ + return nm_utils_dhcp_client_id_systemd_node_specific_full( + iaid, + (const guint8 *) nm_utils_machine_id_bin(), + sizeof(NMUuid)); +} + +/*****************************************************************************/ + +GBytes * +nm_utils_generate_duid_llt(int arp_type, const guint8 *hwaddr, gsize hwaddr_len, gint64 time) +{ + guint8 * arr; + const guint16 duid_type = htons(1); + const guint16 hw_type = htons(arp_type); + const guint32 duid_time = htonl(NM_MAX(0, time - NM_UTILS_EPOCH_DATETIME_200001010000)); + + if (!nm_utils_arp_type_get_hwaddr_relevant_part(arp_type, &hwaddr, &hwaddr_len)) + nm_assert_not_reached(); + + arr = g_new(guint8, (2u + 2u + 4u) + hwaddr_len); + + memcpy(&arr[0], &duid_type, 2); + memcpy(&arr[2], &hw_type, 2); + memcpy(&arr[4], &duid_time, 4); + memcpy(&arr[8], hwaddr, hwaddr_len); + + return g_bytes_new_take(arr, (2u + 2u + 4u) + hwaddr_len); +} + +GBytes * +nm_utils_generate_duid_ll(int arp_type, const guint8 *hwaddr, gsize hwaddr_len) { - const guint16 DUID_TYPE_EN = 2; - const guint32 SYSTEMD_PEN = 43793; - struct _nm_packed { - guint8 type; - guint32 iaid; - struct _nm_packed { - guint16 type; - union { - struct _nm_packed { - /* DUID_TYPE_EN */ - guint32 pen; - uint8_t id[8]; - } en; - }; - } duid; - } *client_id; - guint64 u64; - - g_return_val_if_fail (machine_id, NULL); - g_return_val_if_fail (machine_id_len > 0, NULL); - - client_id = g_malloc (sizeof (*client_id)); - - client_id->type = 255; - unaligned_write_be32 (&client_id->iaid, iaid); - unaligned_write_be16 (&client_id->duid.type, DUID_TYPE_EN); - unaligned_write_be32 (&client_id->duid.en.pen, SYSTEMD_PEN); - - u64 = htole64 (c_siphash_hash (HASH_KEY, machine_id, machine_id_len)); - memcpy(client_id->duid.en.id, &u64, sizeof (client_id->duid.en.id)); - - G_STATIC_ASSERT_EXPR (sizeof (*client_id) == 19); - return g_bytes_new_take (client_id, 19); + guint8 * arr; + const guint16 duid_type = htons(3); + const guint16 hw_type = htons(arp_type); + + if (!nm_utils_arp_type_get_hwaddr_relevant_part(arp_type, &hwaddr, &hwaddr_len)) + nm_assert_not_reached(); + + arr = g_new(guint8, (2u + 2u) + hwaddr_len); + + memcpy(&arr[0], &duid_type, 2); + memcpy(&arr[2], &hw_type, 2); + memcpy(&arr[4], hwaddr, hwaddr_len); + + return g_bytes_new_take(arr, (2u + 2u) + hwaddr_len); } GBytes * -nm_utils_dhcp_client_id_systemd_node_specific (guint32 iaid) +nm_utils_generate_duid_uuid(const NMUuid *uuid) { - return nm_utils_dhcp_client_id_systemd_node_specific_full (iaid, - (const guint8 *) nm_utils_machine_id_bin (), - sizeof (NMUuid)); + const guint16 duid_type = htons(4); + guint8 * duid_buffer; + + nm_assert(uuid); + + /* Generate a DHCP Unique Identifier for DHCPv6 using the + * DUID-UUID method (see RFC 6355 section 4). Format is: + * + * u16: type (DUID-UUID = 4) + * u8[16]: UUID bytes + */ + G_STATIC_ASSERT_EXPR(sizeof(duid_type) == 2); + G_STATIC_ASSERT_EXPR(sizeof(*uuid) == 16); + duid_buffer = g_malloc(18); + memcpy(&duid_buffer[0], &duid_type, 2); + memcpy(&duid_buffer[2], uuid, 16); + return g_bytes_new_take(duid_buffer, 18); +} + +GBytes * +nm_utils_generate_duid_from_machine_id(void) +{ + static GBytes *volatile global_duid = NULL; + GBytes *p; + +again: + p = g_atomic_pointer_get(&global_duid); + if (G_UNLIKELY(!p)) { + nm_auto_free_checksum GChecksum *sum = NULL; + const NMUuid * machine_id; + union { + guint8 sha256[NM_UTILS_CHECKSUM_LENGTH_SHA256]; + NMUuid uuid; + } digest; + + machine_id = nm_utils_machine_id_bin(); + + /* Hash the machine ID so it's not leaked to the network. + * + * Optimally, we would choose an use case specific seed, but for historic + * reasons we didn't. */ + sum = g_checksum_new(G_CHECKSUM_SHA256); + g_checksum_update(sum, (const guchar *) machine_id, sizeof(*machine_id)); + nm_utils_checksum_get_digest(sum, digest.sha256); + + G_STATIC_ASSERT_EXPR(sizeof(digest.sha256) > sizeof(digest.uuid)); + p = nm_utils_generate_duid_uuid(&digest.uuid); + + if (!g_atomic_pointer_compare_and_exchange(&global_duid, NULL, p)) { + g_bytes_unref(p); + goto again; + } + } + + return g_bytes_ref(p); } /*****************************************************************************/ @@ -3772,12 +4216,12 @@ nm_utils_dhcp_client_id_systemd_node_specific (guint32 iaid) * is killed). */ void -nm_utils_setpgid (gpointer unused G_GNUC_UNUSED) +nm_utils_setpgid(gpointer unused G_GNUC_UNUSED) { - pid_t pid; + pid_t pid; - pid = getpid (); - setpgid (pid, pid); + pid = getpid(); + setpgid(pid, pid); } /** @@ -3789,53 +4233,42 @@ nm_utils_setpgid (gpointer unused G_GNUC_UNUSED) * Converts @strings to a #GStrv and stores it in @value. */ void -nm_utils_g_value_set_strv (GValue *value, GPtrArray *strings) +nm_utils_g_value_set_strv(GValue *value, GPtrArray *strings) { - char **strv; - guint i; + char **strv; + guint i; - strv = g_new (char *, strings->len + 1); - for (i = 0; i < strings->len; i++) { - nm_assert (strings->pdata[i]); - strv[i] = g_strdup (strings->pdata[i]); - } - strv[i] = NULL; + strv = g_new(char *, strings->len + 1); + for (i = 0; i < strings->len; i++) { + nm_assert(strings->pdata[i]); + strv[i] = g_strdup(strings->pdata[i]); + } + strv[i] = NULL; - g_value_take_boxed (value, strv); + g_value_take_boxed(value, strv); } /*****************************************************************************/ void -nm_utils_ifname_cpy (char *dst, const char *name) +nm_utils_ifname_cpy(char *dst, const char *name) { - int i; + int i; - g_return_if_fail (dst); - g_return_if_fail (name && name[0]); + g_return_if_fail(dst); + g_return_if_fail(name && name[0]); - nm_assert (nm_utils_ifname_valid_kernel (name, NULL)); + nm_assert(nm_utils_ifname_valid_kernel(name, NULL)); - /* ensures NUL padding of the entire IFNAMSIZ buffer. */ + /* ensures NUL padding of the entire IFNAMSIZ buffer. */ - for (i = 0; i < (int) IFNAMSIZ && name[i] != '\0'; i++) - dst[i] = name[i]; + for (i = 0; i < (int) IFNAMSIZ && name[i] != '\0'; i++) + dst[i] = name[i]; - nm_assert (name[i] == '\0'); + nm_assert(name[i] == '\0'); - for (; i < (int) IFNAMSIZ; i++) - dst[i] = '\0'; -} - -/*****************************************************************************/ - -#define IPV4LL_NETWORK (htonl (0xA9FE0000L)) -#define IPV4LL_NETMASK (htonl (0xFFFF0000L)) - -gboolean -nm_utils_ip4_address_is_link_local (in_addr_t addr) -{ - return (addr & IPV4LL_NETMASK) == IPV4LL_NETWORK; + for (; i < (int) IFNAMSIZ; i++) + dst[i] = '\0'; } /*****************************************************************************/ @@ -3845,113 +4278,111 @@ nm_utils_ip4_address_is_link_local (in_addr_t addr) * on the new timestamp @now. */ guint32 -nm_utils_lifetime_rebase_relative_time_on_now (guint32 timestamp, - guint32 duration, - gint32 now) +nm_utils_lifetime_rebase_relative_time_on_now(guint32 timestamp, guint32 duration, gint32 now) { - gint64 t; - - nm_assert (now >= 0); - - if (duration == NM_PLATFORM_LIFETIME_PERMANENT) - return NM_PLATFORM_LIFETIME_PERMANENT; - - if (timestamp == 0) { - /* if the @timestamp is zero, assume it was just left unset and that the relative - * @duration starts counting from @now. This is convenient to construct an address - * and print it in nm_platform_ip4_address_to_string(). - * - * In general it does not make sense to set the @duration without anchoring at - * @timestamp because you don't know the absolute expiration time when looking - * at the address at a later moment. */ - timestamp = now; - } - - /* For timestamp > now, just accept it and calculate the expected(?) result. */ - t = (gint64) timestamp + (gint64) duration - (gint64) now; - - if (t <= 0) - return 0; - if (t >= NM_PLATFORM_LIFETIME_PERMANENT) - return NM_PLATFORM_LIFETIME_PERMANENT - 1; - return t; + gint64 t; + + nm_assert(now >= 0); + + if (duration == NM_PLATFORM_LIFETIME_PERMANENT) + return NM_PLATFORM_LIFETIME_PERMANENT; + + if (timestamp == 0) { + /* if the @timestamp is zero, assume it was just left unset and that the relative + * @duration starts counting from @now. This is convenient to construct an address + * and print it in nm_platform_ip4_address_to_string(). + * + * In general it does not make sense to set the @duration without anchoring at + * @timestamp because you don't know the absolute expiration time when looking + * at the address at a later moment. */ + timestamp = now; + } + + /* For timestamp > now, just accept it and calculate the expected(?) result. */ + t = (gint64) timestamp + (gint64) duration - (gint64) now; + + if (t <= 0) + return 0; + if (t >= NM_PLATFORM_LIFETIME_PERMANENT) + return NM_PLATFORM_LIFETIME_PERMANENT - 1; + return t; } guint32 -nm_utils_lifetime_get (guint32 timestamp, - guint32 lifetime, - guint32 preferred, - gint32 now, - guint32 *out_preferred) +nm_utils_lifetime_get(guint32 timestamp, + guint32 lifetime, + guint32 preferred, + gint32 now, + guint32 *out_preferred) { - guint32 t_lifetime, t_preferred; - - nm_assert (now >= 0); - - if (timestamp == 0 && lifetime == 0) { - /* We treat lifetime==0 && timestamp==0 addresses as permanent addresses to allow easy - * creation of such addresses (without requiring to set the lifetime fields to - * NM_PLATFORM_LIFETIME_PERMANENT). The real lifetime==0 addresses (E.g. DHCP6 telling us - * to drop an address will have timestamp set. - */ - NM_SET_OUT (out_preferred, NM_PLATFORM_LIFETIME_PERMANENT); - g_return_val_if_fail (preferred == 0, NM_PLATFORM_LIFETIME_PERMANENT); - return NM_PLATFORM_LIFETIME_PERMANENT; - } - - if (now <= 0) - now = nm_utils_get_monotonic_timestamp_sec (); - - t_lifetime = nm_utils_lifetime_rebase_relative_time_on_now (timestamp, lifetime, now); - if (!t_lifetime) { - NM_SET_OUT (out_preferred, 0); - return 0; - } - - t_preferred = nm_utils_lifetime_rebase_relative_time_on_now (timestamp, preferred, now); - - NM_SET_OUT (out_preferred, MIN (t_preferred, t_lifetime)); - - /* Assert that non-permanent addresses have a (positive) @timestamp. nm_utils_lifetime_rebase_relative_time_on_now() - * treats addresses with timestamp 0 as *now*. Addresses passed to _address_get_lifetime() always - * should have a valid @timestamp, otherwise on every re-sync, their lifetime will be extended anew. - */ - g_return_val_if_fail ( timestamp != 0 - || ( lifetime == NM_PLATFORM_LIFETIME_PERMANENT - && preferred == NM_PLATFORM_LIFETIME_PERMANENT), t_lifetime); - g_return_val_if_fail (t_preferred <= t_lifetime, t_lifetime); - - return t_lifetime; + guint32 t_lifetime, t_preferred; + + nm_assert(now >= 0); + + if (timestamp == 0 && lifetime == 0) { + /* We treat lifetime==0 && timestamp==0 addresses as permanent addresses to allow easy + * creation of such addresses (without requiring to set the lifetime fields to + * NM_PLATFORM_LIFETIME_PERMANENT). The real lifetime==0 addresses (E.g. DHCP6 telling us + * to drop an address will have timestamp set. + */ + NM_SET_OUT(out_preferred, NM_PLATFORM_LIFETIME_PERMANENT); + g_return_val_if_fail(preferred == 0, NM_PLATFORM_LIFETIME_PERMANENT); + return NM_PLATFORM_LIFETIME_PERMANENT; + } + + if (now <= 0) + now = nm_utils_get_monotonic_timestamp_sec(); + + t_lifetime = nm_utils_lifetime_rebase_relative_time_on_now(timestamp, lifetime, now); + if (!t_lifetime) { + NM_SET_OUT(out_preferred, 0); + return 0; + } + + t_preferred = nm_utils_lifetime_rebase_relative_time_on_now(timestamp, preferred, now); + + NM_SET_OUT(out_preferred, MIN(t_preferred, t_lifetime)); + + /* Assert that non-permanent addresses have a (positive) @timestamp. nm_utils_lifetime_rebase_relative_time_on_now() + * treats addresses with timestamp 0 as *now*. Addresses passed to _address_get_lifetime() always + * should have a valid @timestamp, otherwise on every re-sync, their lifetime will be extended anew. + */ + g_return_val_if_fail(timestamp != 0 + || (lifetime == NM_PLATFORM_LIFETIME_PERMANENT + && preferred == NM_PLATFORM_LIFETIME_PERMANENT), + t_lifetime); + g_return_val_if_fail(t_preferred <= t_lifetime, t_lifetime); + + return t_lifetime; } const char * -nm_utils_dnsmasq_status_to_string (int status, char *dest, gsize size) +nm_utils_dnsmasq_status_to_string(int status, char *dest, gsize size) { - const char *msg; - - nm_utils_to_string_buffer_init (&dest, &size); - - if (status == 0) - msg = "Success"; - else if (status == 1) - msg = "Configuration problem"; - else if (status == 2) - msg = "Network access problem (address in use, permissions)"; - else if (status == 3) - msg = "Filesystem problem (missing file/directory, permissions)"; - else if (status == 4) - msg = "Memory allocation failure"; - else if (status == 5) - msg = "Other problem"; - else if (status >= 11) { - g_snprintf (dest, size, "Lease script failed with error %d", status - 10); - return dest; - } - else - msg = "Unknown problem"; - - g_snprintf (dest, size, "%s (%d)", msg, status); - return dest; + const char *msg; + + nm_utils_to_string_buffer_init(&dest, &size); + + if (status == 0) + msg = "Success"; + else if (status == 1) + msg = "Configuration problem"; + else if (status == 2) + msg = "Network access problem (address in use, permissions)"; + else if (status == 3) + msg = "Filesystem problem (missing file/directory, permissions)"; + else if (status == 4) + msg = "Memory allocation failure"; + else if (status == 5) + msg = "Other problem"; + else if (status >= 11) { + g_snprintf(dest, size, "Lease script failed with error %d", status - 10); + return dest; + } else + msg = "Unknown problem"; + + g_snprintf(dest, size, "%s (%d)", msg, status); + return dest; } /** @@ -3964,42 +4395,42 @@ nm_utils_dnsmasq_status_to_string (int status, char *dest, gsize size) * append them to @domains. */ void -nm_utils_get_reverse_dns_domains_ip4 (guint32 addr, guint8 plen, GPtrArray *domains) +nm_utils_get_reverse_dns_domains_ip4(guint32 addr, guint8 plen, GPtrArray *domains) { - guint32 ip, ip2, mask; - guchar *p; - guint octets; - guint i; - gsize len0, len; - char *str, *s; - - g_return_if_fail (domains); - g_return_if_fail (plen <= 32); - - if (!plen) - return; - - octets = (plen - 1) / 8 + 1; - ip = ntohl (addr); - mask = 0xFFFFFFFF << (32 - plen); - ip &= mask; - ip2 = ip; - - len0 = NM_STRLEN ("in-addr.arpa") + (4 * octets) + 1; - while ((ip2 & mask) == ip) { - addr = htonl (ip2); - p = (guchar *) &addr; - - len = len0; - str = s = g_malloc (len); - for (i = octets; i > 0; i--) - nm_utils_strbuf_append (&s, &len, "%u.", p[i - 1] & 0xff); - nm_utils_strbuf_append_str (&s, &len, "in-addr.arpa"); - - g_ptr_array_add (domains, str); - - ip2 += 1 << ((32 - plen) & ~7); - } + guint32 ip, ip2, mask; + guchar *p; + guint octets; + guint i; + gsize len0, len; + char * str, *s; + + g_return_if_fail(domains); + g_return_if_fail(plen <= 32); + + if (!plen) + return; + + octets = (plen - 1) / 8 + 1; + ip = ntohl(addr); + mask = 0xFFFFFFFF << (32 - plen); + ip &= mask; + ip2 = ip; + + len0 = NM_STRLEN("in-addr.arpa") + (4 * octets) + 1; + while ((ip2 & mask) == ip) { + addr = htonl(ip2); + p = (guchar *) &addr; + + len = len0; + str = s = g_malloc(len); + for (i = octets; i > 0; i--) + nm_utils_strbuf_append(&s, &len, "%u.", p[i - 1] & 0xff); + nm_utils_strbuf_append_str(&s, &len, "in-addr.arpa"); + + g_ptr_array_add(domains, str); + + ip2 += 1 << ((32 - plen) & ~7); + } } /** @@ -4012,613 +4443,679 @@ nm_utils_get_reverse_dns_domains_ip4 (guint32 addr, guint8 plen, GPtrArray *doma * append them to @domains. */ void -nm_utils_get_reverse_dns_domains_ip6 (const struct in6_addr *ip, guint8 plen, GPtrArray *domains) +nm_utils_get_reverse_dns_domains_ip6(const struct in6_addr *ip, guint8 plen, GPtrArray *domains) { - struct in6_addr addr; - guint nibbles, bits, entries; - int i, j; - gsize len0, len; - char *str, *s; + struct in6_addr addr; + guint nibbles, bits, entries; + int i, j; + gsize len0, len; + char * str, *s; - g_return_if_fail (domains); - g_return_if_fail (plen <= 128); + g_return_if_fail(domains); + g_return_if_fail(plen <= 128); - if (!plen) - return; + if (!plen) + return; - memcpy (&addr, ip, sizeof (struct in6_addr)); - nm_utils_ip6_address_clear_host_address (&addr, NULL, plen); + memcpy(&addr, ip, sizeof(struct in6_addr)); + nm_utils_ip6_address_clear_host_address(&addr, NULL, plen); - /* Number of nibbles to include in domains */ - nibbles = (plen - 1) / 4 + 1; - /* Prefix length in nibble */ - bits = plen - ((plen - 1) / 4 * 4); - /* Number of domains */ - entries = 1 << (4 - bits); + /* Number of nibbles to include in domains */ + nibbles = (plen - 1) / 4 + 1; + /* Prefix length in nibble */ + bits = plen - ((plen - 1) / 4 * 4); + /* Number of domains */ + entries = 1 << (4 - bits); - len0 = NM_STRLEN ("ip6.arpa") + (2 * nibbles) + 1; + len0 = NM_STRLEN("ip6.arpa") + (2 * nibbles) + 1; #define N_SHIFT(x) ((x) % 2 ? 0 : 4) - for (i = 0; i < entries; i++) { - len = len0; - str = s = g_malloc (len); + for (i = 0; i < entries; i++) { + len = len0; + str = s = g_malloc(len); - for (j = nibbles - 1; j >= 0; j--) - nm_utils_strbuf_append (&s, - &len, - "%x.", - (addr.s6_addr[j / 2] >> N_SHIFT (j)) & 0xf); - nm_utils_strbuf_append_str (&s, &len, "ip6.arpa"); + for (j = nibbles - 1; j >= 0; j--) + nm_utils_strbuf_append(&s, &len, "%x.", (addr.s6_addr[j / 2] >> N_SHIFT(j)) & 0xf); + nm_utils_strbuf_append_str(&s, &len, "ip6.arpa"); - g_ptr_array_add (domains, str); + g_ptr_array_add(domains, str); - addr.s6_addr[(nibbles - 1) / 2] += 1 << N_SHIFT (nibbles - 1); - } + addr.s6_addr[(nibbles - 1) / 2] += 1 << N_SHIFT(nibbles - 1); + } #undef N_SHIFT } struct plugin_info { - char *path; - struct stat st; + char * path; + struct stat st; }; static int -read_device_factory_paths_sort_fcn (gconstpointer a, gconstpointer b) +read_device_factory_paths_sort_fcn(gconstpointer a, gconstpointer b) { - const struct plugin_info *da = a; - const struct plugin_info *db = b; - time_t ta, tb; - - ta = MAX (da->st.st_mtime, da->st.st_ctime); - tb = MAX (db->st.st_mtime, db->st.st_ctime); - - if (ta < tb) - return 1; - if (ta > tb) - return -1; - return 0; + const struct plugin_info *da = a; + const struct plugin_info *db = b; + time_t ta, tb; + + ta = MAX(da->st.st_mtime, da->st.st_ctime); + tb = MAX(db->st.st_mtime, db->st.st_ctime); + + if (ta < tb) + return 1; + if (ta > tb) + return -1; + return 0; } gboolean -nm_utils_validate_plugin (const char *path, struct stat *st, GError **error) +nm_utils_validate_plugin(const char *path, struct stat *st, GError **error) { - g_return_val_if_fail (path, FALSE); - g_return_val_if_fail (st, FALSE); - g_return_val_if_fail (!error || !*error, FALSE); - - if (!S_ISREG (st->st_mode)) { - g_set_error_literal (error, - NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - "not a regular file"); - return FALSE; - } - - if (st->st_uid != 0) { - g_set_error_literal (error, - NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - "file has invalid owner (should be root)"); - return FALSE; - } - - if (st->st_mode & (S_IWGRP | S_IWOTH | S_ISUID)) { - g_set_error_literal (error, - NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - "file has invalid permissions"); - return FALSE; - } - - return TRUE; + g_return_val_if_fail(path, FALSE); + g_return_val_if_fail(st, FALSE); + g_return_val_if_fail(!error || !*error, FALSE); + + if (!S_ISREG(st->st_mode)) { + g_set_error_literal(error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, "not a regular file"); + return FALSE; + } + + if (st->st_uid != 0) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "file has invalid owner (should be root)"); + return FALSE; + } + + if (st->st_mode & (S_IWGRP | S_IWOTH | S_ISUID)) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + "file has invalid permissions"); + return FALSE; + } + + return TRUE; } char ** -nm_utils_read_plugin_paths (const char *dirname, const char *prefix) +nm_utils_read_plugin_paths(const char *dirname, const char *prefix) { - GDir *dir; - GError *error = NULL; - const char *item; - GArray *paths; - char **result; - guint i; - - g_return_val_if_fail (dirname, NULL); - g_return_val_if_fail (prefix, NULL); - - dir = g_dir_open (dirname, 0, &error); - if (!dir) { - nm_log_warn (LOGD_CORE, "device plugin: failed to open directory %s: %s", - dirname, - error->message); - g_clear_error (&error); - return NULL; - } - - paths = g_array_new (FALSE, FALSE, sizeof (struct plugin_info)); - - while ((item = g_dir_read_name (dir))) { - int errsv; - struct plugin_info data; - - if (!g_str_has_prefix (item, prefix)) - continue; - if (!g_str_has_suffix (item, ".so")) - continue; - - data.path = g_build_filename (dirname, item, NULL); - - if (stat (data.path, &data.st) != 0) { - errsv = errno; - nm_log_warn (LOGD_CORE, - "plugin: skip invalid file %s (error during stat: %s)", - data.path, nm_strerror_native (errsv)); - goto skip; - } - - if (!nm_utils_validate_plugin (data.path, &data.st, &error)) { - nm_log_warn (LOGD_CORE, - "plugin: skip invalid file %s: %s", - data.path, error->message); - g_clear_error (&error); - goto skip; - } - - g_array_append_val (paths, data); - continue; + GDir * dir; + GError * error = NULL; + const char *item; + GArray * paths; + char ** result; + guint i; + + g_return_val_if_fail(dirname, NULL); + g_return_val_if_fail(prefix, NULL); + + dir = g_dir_open(dirname, 0, &error); + if (!dir) { + nm_log_warn(LOGD_CORE, + "device plugin: failed to open directory %s: %s", + dirname, + error->message); + g_clear_error(&error); + return NULL; + } + + paths = g_array_new(FALSE, FALSE, sizeof(struct plugin_info)); + + while ((item = g_dir_read_name(dir))) { + int errsv; + struct plugin_info data; + + if (!g_str_has_prefix(item, prefix)) + continue; + if (!g_str_has_suffix(item, ".so")) + continue; + + data.path = g_build_filename(dirname, item, NULL); + + if (stat(data.path, &data.st) != 0) { + errsv = errno; + nm_log_warn(LOGD_CORE, + "plugin: skip invalid file %s (error during stat: %s)", + data.path, + nm_strerror_native(errsv)); + goto skip; + } + + if (!nm_utils_validate_plugin(data.path, &data.st, &error)) { + nm_log_warn(LOGD_CORE, "plugin: skip invalid file %s: %s", data.path, error->message); + g_clear_error(&error); + goto skip; + } + + g_array_append_val(paths, data); + continue; skip: - g_free (data.path); - } - g_dir_close (dir); + g_free(data.path); + } + g_dir_close(dir); - /* sort filenames by modification time. */ - g_array_sort (paths, read_device_factory_paths_sort_fcn); + /* sort filenames by modification time. */ + g_array_sort(paths, read_device_factory_paths_sort_fcn); - result = g_new (char *, paths->len + 1); - for (i = 0; i < paths->len; i++) - result[i] = g_array_index (paths, struct plugin_info, i).path; - result[i] = NULL; + result = g_new(char *, paths->len + 1); + for (i = 0; i < paths->len; i++) + result[i] = g_array_index(paths, struct plugin_info, i).path; + result[i] = NULL; - g_array_free (paths, TRUE); - return result; + g_array_free(paths, TRUE); + return result; } char * -nm_utils_format_con_diff_for_audit (GHashTable *diff) +nm_utils_format_con_diff_for_audit(GHashTable *diff) { - GHashTable *setting_diff; - char *setting_name, *prop_name; - GHashTableIter iter, iter2; - GString *str; + GHashTable * setting_diff; + char * setting_name, *prop_name; + GHashTableIter iter, iter2; + GString * str; - str = g_string_sized_new (32); - g_hash_table_iter_init (&iter, diff); + str = g_string_sized_new(32); + g_hash_table_iter_init(&iter, diff); - while (g_hash_table_iter_next (&iter, - (gpointer *) &setting_name, - (gpointer *) &setting_diff)) { - if (!setting_diff) - continue; + while (g_hash_table_iter_next(&iter, (gpointer *) &setting_name, (gpointer *) &setting_diff)) { + if (!setting_diff) + continue; - g_hash_table_iter_init (&iter2, setting_diff); + g_hash_table_iter_init(&iter2, setting_diff); - while (g_hash_table_iter_next (&iter2, (gpointer *) &prop_name, NULL)) - g_string_append_printf (str, "%s.%s,", setting_name, prop_name); - } + while (g_hash_table_iter_next(&iter2, (gpointer *) &prop_name, NULL)) + g_string_append_printf(str, "%s.%s,", setting_name, prop_name); + } - if (str->len) - str->str[str->len - 1] = '\0'; + if (str->len) + str->str[str->len - 1] = '\0'; - return g_string_free (str, FALSE); + return g_string_free(str, FALSE); } const char * -nm_utils_parse_dns_domain (const char *domain, gboolean *is_routing) +nm_utils_parse_dns_domain(const char *domain, gboolean *is_routing) { - g_return_val_if_fail (domain, NULL); - g_return_val_if_fail (domain[0], NULL); - - if (domain[0] == '~') { - domain++; - NM_SET_OUT (is_routing, TRUE); - } else - NM_SET_OUT (is_routing, FALSE); + g_return_val_if_fail(domain, NULL); + g_return_val_if_fail(domain[0], NULL); - return domain; -} - -/*****************************************************************************/ + if (domain[0] == '~') { + domain++; + NM_SET_OUT(is_routing, TRUE); + } else + NM_SET_OUT(is_routing, FALSE); -GVariant * -nm_utils_strdict_to_variant (GHashTable *options) -{ - GVariantBuilder builder; - gs_free NMUtilsNamedValue *values = NULL; - guint i; - guint n; - - values = nm_utils_named_values_from_str_dict (options, &n); - - g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); - for (i = 0; i < n; i++) { - g_variant_builder_add (&builder, - "{sv}", - values[i].name, - g_variant_new_string (values[i].value_str)); - } - return g_variant_builder_end (&builder); + return domain; } /*****************************************************************************/ static guint32 -get_max_rate_ht_20 (int mcs) +get_max_rate_ht_20(int mcs) { - switch (mcs) { - case 0: return 6500000; - case 1: - case 8: return 13000000; - case 2: - case 16: return 19500000; - case 3: - case 9: - case 24: return 26000000; - case 4: - case 10: - case 17: return 39000000; - case 5: - case 11: - case 25: return 52000000; - case 6: - case 18: return 58500000; - case 7: return 65000000; - case 12: - case 19: - case 26: return 78000000; - case 13: - case 27: return 104000000; - case 14: - case 20: return 117000000; - case 15: return 130000000; - case 21: - case 28: return 156000000; - case 22: return 175500000; - case 23: return 195000000; - case 29: return 208000000; - case 30: return 234000000; - case 31: return 260000000; - } - return 0; + switch (mcs) { + case 0: + return 6500000; + case 1: + case 8: + return 13000000; + case 2: + case 16: + return 19500000; + case 3: + case 9: + case 24: + return 26000000; + case 4: + case 10: + case 17: + return 39000000; + case 5: + case 11: + case 25: + return 52000000; + case 6: + case 18: + return 58500000; + case 7: + return 65000000; + case 12: + case 19: + case 26: + return 78000000; + case 13: + case 27: + return 104000000; + case 14: + case 20: + return 117000000; + case 15: + return 130000000; + case 21: + case 28: + return 156000000; + case 22: + return 175500000; + case 23: + return 195000000; + case 29: + return 208000000; + case 30: + return 234000000; + case 31: + return 260000000; + } + return 0; } static guint32 -get_max_rate_ht_40 (int mcs) +get_max_rate_ht_40(int mcs) { - switch (mcs) { - case 0: return 13500000; - case 1: - case 8: return 27000000; - case 2: return 40500000; - case 3: - case 9: - case 24: return 54000000; - case 4: - case 10: - case 17: return 81000000; - case 5: - case 11: - case 25: return 108000000; - case 6: - case 18: return 121500000; - case 7: return 135000000; - case 12: - case 19: - case 26: return 162000000; - case 13: - case 27: return 216000000; - case 14: - case 20: return 243000000; - case 15: return 270000000; - case 16: return 40500000; - case 21: - case 28: return 324000000; - case 22: return 364500000; - case 23: return 405000000; - case 29: return 432000000; - case 30: return 486000000; - case 31: return 540000000; - } - return 0; + switch (mcs) { + case 0: + return 13500000; + case 1: + case 8: + return 27000000; + case 2: + return 40500000; + case 3: + case 9: + case 24: + return 54000000; + case 4: + case 10: + case 17: + return 81000000; + case 5: + case 11: + case 25: + return 108000000; + case 6: + case 18: + return 121500000; + case 7: + return 135000000; + case 12: + case 19: + case 26: + return 162000000; + case 13: + case 27: + return 216000000; + case 14: + case 20: + return 243000000; + case 15: + return 270000000; + case 16: + return 40500000; + case 21: + case 28: + return 324000000; + case 22: + return 364500000; + case 23: + return 405000000; + case 29: + return 432000000; + case 30: + return 486000000; + case 31: + return 540000000; + } + return 0; } static guint32 -get_max_rate_vht_80_ss1 (int mcs) +get_max_rate_vht_80_ss1(int mcs) { - switch (mcs) { - case 0: return 29300000; - case 1: return 58500000; - case 2: return 87800000; - case 3: return 117000000; - case 4: return 175500000; - case 5: return 234000000; - case 6: return 263300000; - case 7: return 292500000; - case 8: return 351000000; - case 9: return 390000000; - } - return 0; + switch (mcs) { + case 0: + return 29300000; + case 1: + return 58500000; + case 2: + return 87800000; + case 3: + return 117000000; + case 4: + return 175500000; + case 5: + return 234000000; + case 6: + return 263300000; + case 7: + return 292500000; + case 8: + return 351000000; + case 9: + return 390000000; + } + return 0; } static guint32 -get_max_rate_vht_80_ss2 (int mcs) +get_max_rate_vht_80_ss2(int mcs) { - switch (mcs) { - case 0: return 58500000; - case 1: return 117000000; - case 2: return 175500000; - case 3: return 234000000; - case 4: return 351000000; - case 5: return 468000000; - case 6: return 526500000; - case 7: return 585000000; - case 8: return 702000000; - case 9: return 780000000; - } - return 0; + switch (mcs) { + case 0: + return 58500000; + case 1: + return 117000000; + case 2: + return 175500000; + case 3: + return 234000000; + case 4: + return 351000000; + case 5: + return 468000000; + case 6: + return 526500000; + case 7: + return 585000000; + case 8: + return 702000000; + case 9: + return 780000000; + } + return 0; } static guint32 -get_max_rate_vht_80_ss3 (int mcs) +get_max_rate_vht_80_ss3(int mcs) { - switch (mcs) { - case 0: return 87800000; - case 1: return 175500000; - case 2: return 263300000; - case 3: return 351000000; - case 4: return 526500000; - case 5: return 702000000; - case 6: return 0; - case 7: return 877500000; - case 8: return 105300000; - case 9: return 117000000; - } - return 0; + switch (mcs) { + case 0: + return 87800000; + case 1: + return 175500000; + case 2: + return 263300000; + case 3: + return 351000000; + case 4: + return 526500000; + case 5: + return 702000000; + case 6: + return 0; + case 7: + return 877500000; + case 8: + return 105300000; + case 9: + return 117000000; + } + return 0; } static guint32 -get_max_rate_vht_160_ss1 (int mcs) +get_max_rate_vht_160_ss1(int mcs) { - switch (mcs) { - case 0: return 58500000; - case 1: return 117000000; - case 2: return 175500000; - case 3: return 234000000; - case 4: return 351000000; - case 5: return 468000000; - case 6: return 526500000; - case 7: return 585000000; - case 8: return 702000000; - case 9: return 780000000; - } - return 0; + switch (mcs) { + case 0: + return 58500000; + case 1: + return 117000000; + case 2: + return 175500000; + case 3: + return 234000000; + case 4: + return 351000000; + case 5: + return 468000000; + case 6: + return 526500000; + case 7: + return 585000000; + case 8: + return 702000000; + case 9: + return 780000000; + } + return 0; } static guint32 -get_max_rate_vht_160_ss2 (int mcs) +get_max_rate_vht_160_ss2(int mcs) { - switch (mcs) { - case 0: return 117000000; - case 1: return 234000000; - case 2: return 351000000; - case 3: return 468000000; - case 4: return 702000000; - case 5: return 936000000; - case 6: return 1053000000; - case 7: return 1170000000; - case 8: return 1404000000; - case 9: return 1560000000; - } - return 0; + switch (mcs) { + case 0: + return 117000000; + case 1: + return 234000000; + case 2: + return 351000000; + case 3: + return 468000000; + case 4: + return 702000000; + case 5: + return 936000000; + case 6: + return 1053000000; + case 7: + return 1170000000; + case 8: + return 1404000000; + case 9: + return 1560000000; + } + return 0; } static guint32 -get_max_rate_vht_160_ss3 (int mcs) +get_max_rate_vht_160_ss3(int mcs) { - switch (mcs) { - case 0: return 175500000; - case 1: return 351000000; - case 2: return 526500000; - case 3: return 702000000; - case 4: return 1053000000; - case 5: return 1404000000; - case 6: return 1579500000; - case 7: return 1755000000; - case 8: return 2106000000; - case 9: return 0; - } - return 0; + switch (mcs) { + case 0: + return 175500000; + case 1: + return 351000000; + case 2: + return 526500000; + case 3: + return 702000000; + case 4: + return 1053000000; + case 5: + return 1404000000; + case 6: + return 1579500000; + case 7: + return 1755000000; + case 8: + return 2106000000; + case 9: + return 0; + } + return 0; } static gboolean -get_max_rate_ht (const guint8 *bytes, guint len, guint32 *out_maxrate) +get_max_rate_ht(const guint8 *bytes, guint len, guint32 *out_maxrate) { - guint32 i; - guint8 ht_cap_info; - const guint8 *supported_mcs_set; - guint32 rate; - - /* http://standards.ieee.org/getieee802/download/802.11-2012.pdf - * https://mrncciew.com/2014/10/19/cwap-ht-capabilities-ie/ - */ - - if (len != 26) - return FALSE; - - ht_cap_info = bytes[0]; - supported_mcs_set = &bytes[3]; - *out_maxrate = 0; - - /* Find the maximum supported mcs rate */ - for (i = 0; i <= 76; i++) { - const unsigned mcs_octet = i / 8; - const unsigned MCS_RATE_BIT = 1 << i % 8; - - if (supported_mcs_set[mcs_octet] & MCS_RATE_BIT) { - /* Check for 40Mhz wide channel support */ - if (ht_cap_info & (1 << 1)) - rate = get_max_rate_ht_40 (i); - else - rate = get_max_rate_ht_20 (i); - - if (rate > *out_maxrate) - *out_maxrate = rate; - } - } - - return TRUE; + guint32 i; + guint8 ht_cap_info; + const guint8 *supported_mcs_set; + guint32 rate; + + /* http://standards.ieee.org/getieee802/download/802.11-2012.pdf + * https://mrncciew.com/2014/10/19/cwap-ht-capabilities-ie/ + */ + + if (len != 26) + return FALSE; + + ht_cap_info = bytes[0]; + supported_mcs_set = &bytes[3]; + *out_maxrate = 0; + + /* Find the maximum supported mcs rate */ + for (i = 0; i <= 76; i++) { + const unsigned mcs_octet = i / 8; + const unsigned MCS_RATE_BIT = 1 << i % 8; + + if (supported_mcs_set[mcs_octet] & MCS_RATE_BIT) { + /* Check for 40Mhz wide channel support */ + if (ht_cap_info & (1 << 1)) + rate = get_max_rate_ht_40(i); + else + rate = get_max_rate_ht_20(i); + + if (rate > *out_maxrate) + *out_maxrate = rate; + } + } + + return TRUE; } static gboolean -get_max_rate_vht (const guint8 *bytes, guint len, guint32 *out_maxrate) +get_max_rate_vht(const guint8 *bytes, guint len, guint32 *out_maxrate) { - guint32 mcs, m; - guint8 vht_cap, tx_map; - - /* https://tda802dot11.blogspot.it/2014/10/vht-capabilities-element-vht.html - * http://chimera.labs.oreilly.com/books/1234000001739/ch03.html#management_frames */ - - if (len != 12) - return FALSE; - - vht_cap = bytes[0]; - tx_map = bytes[8]; - - /* Check for mcs rates 8 and 9 support */ - if (tx_map & 0x2a) - mcs = 9; - else if (tx_map & 0x15) - mcs = 8; - else - mcs = 7; - - /* Check for 160Mhz wide channel support and - * spatial stream support */ - if (vht_cap & (1 << 2)) { - if (tx_map & 0x30) - m = get_max_rate_vht_160_ss3 (mcs); - else if (tx_map & 0x0C) - m = get_max_rate_vht_160_ss2 (mcs); - else - m = get_max_rate_vht_160_ss1 (mcs); - } else { - if (tx_map & 0x30) - m = get_max_rate_vht_80_ss3 (mcs); - else if (tx_map & 0x0C) - m = get_max_rate_vht_80_ss2 (mcs); - else - m = get_max_rate_vht_80_ss1 (mcs); - } - - *out_maxrate = m; - return TRUE; + guint32 mcs, m; + guint8 vht_cap, tx_map; + + /* https://tda802dot11.blogspot.it/2014/10/vht-capabilities-element-vht.html + * http://chimera.labs.oreilly.com/books/1234000001739/ch03.html#management_frames */ + + if (len != 12) + return FALSE; + + vht_cap = bytes[0]; + tx_map = bytes[8]; + + /* Check for mcs rates 8 and 9 support */ + if (tx_map & 0x2a) + mcs = 9; + else if (tx_map & 0x15) + mcs = 8; + else + mcs = 7; + + /* Check for 160Mhz wide channel support and + * spatial stream support */ + if (vht_cap & (1 << 2)) { + if (tx_map & 0x30) + m = get_max_rate_vht_160_ss3(mcs); + else if (tx_map & 0x0C) + m = get_max_rate_vht_160_ss2(mcs); + else + m = get_max_rate_vht_160_ss1(mcs); + } else { + if (tx_map & 0x30) + m = get_max_rate_vht_80_ss3(mcs); + else if (tx_map & 0x0C) + m = get_max_rate_vht_80_ss2(mcs); + else + m = get_max_rate_vht_80_ss1(mcs); + } + + *out_maxrate = m; + return TRUE; } /* Management Frame Information Element IDs, ieee80211_eid */ -#define WLAN_EID_HT_CAPABILITY 45 -#define WLAN_EID_VHT_CAPABILITY 191 -#define WLAN_EID_VENDOR_SPECIFIC 221 +#define WLAN_EID_HT_CAPABILITY 45 +#define WLAN_EID_VHT_CAPABILITY 191 +#define WLAN_EID_VENDOR_SPECIFIC 221 void -nm_wifi_utils_parse_ies (const guint8 *bytes, - gsize len, - guint32 *out_max_rate, - gboolean *out_metered, - gboolean *out_owe_transition_mode) +nm_wifi_utils_parse_ies(const guint8 *bytes, + gsize len, + guint32 * out_max_rate, + gboolean * out_metered, + gboolean * out_owe_transition_mode) { - guint8 id, elem_len; - guint32 m; - - NM_SET_OUT (out_max_rate, 0); - NM_SET_OUT (out_metered, FALSE); - NM_SET_OUT (out_owe_transition_mode, FALSE); - - while (len) { - if (len < 2) - break; - - id = *bytes++; - elem_len = *bytes++; - len -= 2; - - if (elem_len > len) - break; - - switch (id) { - case WLAN_EID_HT_CAPABILITY: - if (out_max_rate) { - if (get_max_rate_ht (bytes, elem_len, &m)) - *out_max_rate = NM_MAX (*out_max_rate, m); - } - break; - case WLAN_EID_VHT_CAPABILITY: - if (out_max_rate) { - if (get_max_rate_vht (bytes, elem_len, &m)) - *out_max_rate = NM_MAX (*out_max_rate, m); - } - break; - case WLAN_EID_VENDOR_SPECIFIC: - if ( len == 8 - && bytes[0] == 0x00 /* OUI: Microsoft */ - && bytes[1] == 0x50 - && bytes[2] == 0xf2 - && bytes[3] == 0x11) /* OUI type: Network cost */ - NM_SET_OUT (out_metered, (bytes[7] > 1)); /* Cost level > 1 */ - if ( elem_len >= 10 - && bytes[0] == 0x50 /* OUI: WiFi Alliance */ - && bytes[1] == 0x6f - && bytes[2] == 0x9a - && bytes[3] == 0x1c) /* OUI type: OWE Transition Mode */ - NM_SET_OUT (out_owe_transition_mode, TRUE); - break; - } - - len -= elem_len; - bytes += elem_len; - } + guint8 id, elem_len; + guint32 m; + + NM_SET_OUT(out_max_rate, 0); + NM_SET_OUT(out_metered, FALSE); + NM_SET_OUT(out_owe_transition_mode, FALSE); + + while (len) { + if (len < 2) + break; + + id = *bytes++; + elem_len = *bytes++; + len -= 2; + + if (elem_len > len) + break; + + switch (id) { + case WLAN_EID_HT_CAPABILITY: + if (out_max_rate) { + if (get_max_rate_ht(bytes, elem_len, &m)) + *out_max_rate = NM_MAX(*out_max_rate, m); + } + break; + case WLAN_EID_VHT_CAPABILITY: + if (out_max_rate) { + if (get_max_rate_vht(bytes, elem_len, &m)) + *out_max_rate = NM_MAX(*out_max_rate, m); + } + break; + case WLAN_EID_VENDOR_SPECIFIC: + if (len == 8 && bytes[0] == 0x00 /* OUI: Microsoft */ + && bytes[1] == 0x50 && bytes[2] == 0xf2 + && bytes[3] == 0x11) /* OUI type: Network cost */ + NM_SET_OUT(out_metered, (bytes[7] > 1)); /* Cost level > 1 */ + if (elem_len >= 10 && bytes[0] == 0x50 /* OUI: WiFi Alliance */ + && bytes[1] == 0x6f && bytes[2] == 0x9a + && bytes[3] == 0x1c) /* OUI type: OWE Transition Mode */ + NM_SET_OUT(out_owe_transition_mode, TRUE); + break; + } + + len -= elem_len; + bytes += elem_len; + } } /*****************************************************************************/ guint8 -nm_wifi_utils_level_to_quality (int val) +nm_wifi_utils_level_to_quality(int val) { - if (val < 0) { - /* Assume dBm already; rough conversion: best = -40, worst = -100 */ - val = abs (CLAMP (val, -100, -40) + 40); /* normalize to 0 */ - val = 100 - (int) ((100.0 * (double) val) / 60.0); - } else if (val > 110 && val < 256) { - /* assume old-style WEXT 8-bit unsigned signal level */ - val -= 256; /* subtract 256 to convert to dBm */ - val = abs (CLAMP (val, -100, -40) + 40); /* normalize to 0 */ - val = 100 - (int) ((100.0 * (double) val) / 60.0); - } else { - /* Assume signal is a "quality" percentage */ - } - - return CLAMP (val, 0, 100); + if (val < 0) { + /* Assume dBm already; rough conversion: best = -40, worst = -100 */ + val = abs(CLAMP(val, -100, -40) + 40); /* normalize to 0 */ + val = 100 - (int) ((100.0 * (double) val) / 60.0); + } else if (val > 110 && val < 256) { + /* assume old-style WEXT 8-bit unsigned signal level */ + val -= 256; /* subtract 256 to convert to dBm */ + val = abs(CLAMP(val, -100, -40) + 40); /* normalize to 0 */ + val = 100 - (int) ((100.0 * (double) val) / 60.0); + } else { + /* Assume signal is a "quality" percentage */ + } + + return CLAMP(val, 0, 100); } /*****************************************************************************/ -NM_UTILS_ENUM2STR_DEFINE (nm_icmpv6_router_pref_to_string, NMIcmpv6RouterPref, - NM_UTILS_ENUM2STR (NM_ICMPV6_ROUTER_PREF_LOW, "low"), - NM_UTILS_ENUM2STR (NM_ICMPV6_ROUTER_PREF_MEDIUM, "medium"), - NM_UTILS_ENUM2STR (NM_ICMPV6_ROUTER_PREF_HIGH, "high"), - NM_UTILS_ENUM2STR (NM_ICMPV6_ROUTER_PREF_INVALID, "invalid"), -); - -NM_UTILS_LOOKUP_STR_DEFINE (nm_activation_type_to_string, NMActivationType, - NM_UTILS_LOOKUP_DEFAULT_WARN ("(unknown)"), - NM_UTILS_LOOKUP_STR_ITEM (NM_ACTIVATION_TYPE_MANAGED, "managed"), - NM_UTILS_LOOKUP_STR_ITEM (NM_ACTIVATION_TYPE_ASSUME, "assume"), - NM_UTILS_LOOKUP_STR_ITEM (NM_ACTIVATION_TYPE_EXTERNAL, "external"), -) +NM_UTILS_ENUM2STR_DEFINE(nm_icmpv6_router_pref_to_string, + NMIcmpv6RouterPref, + NM_UTILS_ENUM2STR(NM_ICMPV6_ROUTER_PREF_LOW, "low"), + NM_UTILS_ENUM2STR(NM_ICMPV6_ROUTER_PREF_MEDIUM, "medium"), + NM_UTILS_ENUM2STR(NM_ICMPV6_ROUTER_PREF_HIGH, "high"), + NM_UTILS_ENUM2STR(NM_ICMPV6_ROUTER_PREF_INVALID, "invalid"), ); + +NM_UTILS_LOOKUP_STR_DEFINE(nm_activation_type_to_string, + NMActivationType, + NM_UTILS_LOOKUP_DEFAULT_WARN("(unknown)"), + NM_UTILS_LOOKUP_STR_ITEM(NM_ACTIVATION_TYPE_MANAGED, "managed"), + NM_UTILS_LOOKUP_STR_ITEM(NM_ACTIVATION_TYPE_ASSUME, "assume"), + NM_UTILS_LOOKUP_STR_ITEM(NM_ACTIVATION_TYPE_EXTERNAL, "external"), ); |