diff options
Diffstat (limited to 'shared/nm-glib-aux/nm-shared-utils.c')
| -rw-r--r-- | shared/nm-glib-aux/nm-shared-utils.c | 7727 |
1 files changed, 4100 insertions, 3627 deletions
diff --git a/shared/nm-glib-aux/nm-shared-utils.c b/shared/nm-glib-aux/nm-shared-utils.c index 3d1b0098..b0e02381 100644 --- a/shared/nm-glib-aux/nm-shared-utils.c +++ b/shared/nm-glib-aux/nm-shared-utils.c @@ -1,4 +1,4 @@ -// SPDX-License-Identifier: LGPL-2.1+ +/* SPDX-License-Identifier: LGPL-2.1+ */ /* * Copyright (C) 2016 Red Hat, Inc. */ @@ -7,6 +7,7 @@ #include "nm-shared-utils.h" +#include <pwd.h> #include <arpa/inet.h> #include <poll.h> #include <fcntl.h> @@ -18,16 +19,19 @@ #include "nm-errno.h" #include "nm-str-buf.h" -G_STATIC_ASSERT (sizeof (NMUtilsNamedEntry) == sizeof (const char *)); -G_STATIC_ASSERT (G_STRUCT_OFFSET (NMUtilsNamedValue, value_ptr) == sizeof (const char *)); +G_STATIC_ASSERT(sizeof(NMUtilsNamedEntry) == sizeof(const char *)); +G_STATIC_ASSERT(G_STRUCT_OFFSET(NMUtilsNamedValue, value_ptr) == sizeof(const char *)); /*****************************************************************************/ -const void *const _NM_PTRARRAY_EMPTY[1] = { NULL }; +const char _nm_hexchar_table_lower[16] = "0123456789abcdef"; +const char _nm_hexchar_table_upper[16] = "0123456789ABCDEF"; + +const void *const _NM_PTRARRAY_EMPTY[1] = {NULL}; /*****************************************************************************/ -const NMIPAddr nm_ip_addr_zero = { }; +const NMIPAddr nm_ip_addr_zero = {}; /* this initializes a struct in_addr/in6_addr and allows for untrusted * arguments (like unsuitable @addr_family or @src_len). It's almost safe @@ -42,131 +46,66 @@ const NMIPAddr nm_ip_addr_zero = { }; * Meaning, if @dst is an NMIPAddr union, only the first bytes will be set. * If that matter to you, clear @dst before. */ gboolean -nm_ip_addr_set_from_untrusted (int addr_family, - gpointer dst, - gconstpointer src, - gsize src_len, - int *out_addr_family) -{ - nm_assert (dst); - - switch (addr_family) { - case AF_UNSPEC: - if (!out_addr_family) { - /* when the callers allow undefined @addr_family, they must provide - * an @out_addr_family argument. */ - nm_assert_not_reached (); - return FALSE; - } - switch (src_len) { - case sizeof (struct in_addr): addr_family = AF_INET; break; - case sizeof (struct in6_addr): addr_family = AF_INET6; break; - default: - return FALSE; - } - break; - case AF_INET: - if (src_len != sizeof (struct in_addr)) - return FALSE; - break; - case AF_INET6: - if (src_len != sizeof (struct in6_addr)) - return FALSE; - break; - default: - /* when the callers allow undefined @addr_family, they must provide - * an @out_addr_family argument. */ - nm_assert (out_addr_family); - return FALSE; - } - - nm_assert (src); - - memcpy (dst, src, src_len); - NM_SET_OUT (out_addr_family, addr_family); - return TRUE; +nm_ip_addr_set_from_untrusted(int addr_family, + gpointer dst, + gconstpointer src, + gsize src_len, + int * out_addr_family) +{ + nm_assert(dst); + + switch (addr_family) { + case AF_UNSPEC: + if (!out_addr_family) { + /* when the callers allow undefined @addr_family, they must provide + * an @out_addr_family argument. */ + nm_assert_not_reached(); + return FALSE; + } + switch (src_len) { + case sizeof(struct in_addr): + addr_family = AF_INET; + break; + case sizeof(struct in6_addr): + addr_family = AF_INET6; + break; + default: + return FALSE; + } + break; + case AF_INET: + if (src_len != sizeof(struct in_addr)) + return FALSE; + break; + case AF_INET6: + if (src_len != sizeof(struct in6_addr)) + return FALSE; + break; + default: + /* when the callers allow undefined @addr_family, they must provide + * an @out_addr_family argument. */ + nm_assert(out_addr_family); + return FALSE; + } + + nm_assert(src); + + memcpy(dst, src, src_len); + NM_SET_OUT(out_addr_family, addr_family); + return TRUE; } /*****************************************************************************/ -G_STATIC_ASSERT (ETH_ALEN == sizeof (struct ether_addr)); -G_STATIC_ASSERT (ETH_ALEN == 6); - -/*****************************************************************************/ - -gsize -nm_utils_get_next_realloc_size (gboolean true_realloc, gsize requested) -{ - gsize n, x; - - /* https://doc.qt.io/qt-5/containers.html#growth-strategies */ - - if (requested <= 40) { - /* small allocations. Increase in small steps of 8 bytes. - * - * We get thus sizes of 8, 16, 32, 40. */ - if (requested <= 8) - return 8; - if (requested <= 16) - return 16; - if (requested <= 32) - return 32; - - /* The return values for < 104 are essentially hard-coded, and the choice here is - * made without very strong reasons. - * - * We want to stay 24 bytes below the power-of-two border 64. Hence, return 40 here. - * However, the next step then is already 104 (128 - 24). It's a larger gap than in - * the steps before. - * - * It's not clear whether some of the steps should be adjusted (or how exactly). */ - return 40; - } - - if ( requested <= 0x2000u - 24u - || G_UNLIKELY (!true_realloc)) { - /* mid sized allocations. Return next power of two, minus 24 bytes extra space - * at the beginning. - * That means, we double the size as we grow. - * - * With !true_realloc, it means that the caller does not intend to call - * realloc() but instead clone the buffer. This is for example the case, when we - * want to nm_explicit_bzero() the old buffer. In that case we really want to grow - * the buffer exponentially every time and not increment in page sizes of 4K (below). - * - * We get thus sizes of 104, 232, 488, 1000, 2024, 4072, 8168... */ - - if (G_UNLIKELY (requested > G_MAXSIZE / 2u - 24u)) - return G_MAXSIZE; - - x = requested + 24u; - n = 128u; - while (n < x) { - n <<= 1; - nm_assert (n > 128u); - } - - nm_assert (n > 24u && n - 24u >= requested); - return n - 24u; - } - - if (G_UNLIKELY (requested > G_MAXSIZE - 0x1000u - 24u)) - return G_MAXSIZE; - - /* For large allocations (with !true_realloc) we allocate memory in chunks of - * 4K (- 24 bytes extra), assuming that the memory gets mmapped and thus - * realloc() is efficient by just reordering pages. */ - n = ((requested + (0x0FFFu + 24u)) & ~((gsize) 0x0FFFu)) - 24u; - nm_assert (n >= requested); - return n; -} +G_STATIC_ASSERT(ETH_ALEN == sizeof(struct ether_addr)); +G_STATIC_ASSERT(ETH_ALEN == 6); /*****************************************************************************/ pid_t -nm_utils_gettid (void) +nm_utils_gettid(void) { - return (pid_t) syscall (SYS_gettid); + return (pid_t) syscall(SYS_gettid); } /* Used for asserting that this function is called on the main-thread. @@ -175,155 +114,154 @@ nm_utils_gettid (void) * * When forking, the thread-id is again reset upon first call. */ gboolean -_nm_assert_on_main_thread (void) +_nm_assert_on_main_thread(void) { - G_LOCK_DEFINE_STATIC (lock); - static pid_t seen_tid; - static pid_t seen_pid; - pid_t tid; - pid_t pid; - gboolean success = FALSE; + G_LOCK_DEFINE_STATIC(lock); + static pid_t seen_tid; + static pid_t seen_pid; + pid_t tid; + pid_t pid; + gboolean success = FALSE; - tid = nm_utils_gettid (); - nm_assert (tid != 0); + tid = nm_utils_gettid(); + nm_assert(tid != 0); - G_LOCK (lock); + G_LOCK(lock); - if (G_LIKELY (tid == seen_tid)) { - /* we don't care about false positives (when the process forked, and the thread-id - * is accidentally re-used) . It's for assertions only. */ - success = TRUE; - } else { - pid = getpid (); - nm_assert (pid != 0); + if (G_LIKELY(tid == seen_tid)) { + /* we don't care about false positives (when the process forked, and the thread-id + * is accidentally re-used) . It's for assertions only. */ + success = TRUE; + } else { + pid = getpid(); + nm_assert(pid != 0); - if ( seen_tid == 0 - || seen_pid != pid) { - /* either this is the first time we call the function, or the process - * forked. In both cases, remember the thread-id. */ - seen_tid = tid; - seen_pid = pid; - success = TRUE; - } - } + if (seen_tid == 0 || seen_pid != pid) { + /* either this is the first time we call the function, or the process + * forked. In both cases, remember the thread-id. */ + seen_tid = tid; + seen_pid = pid; + success = TRUE; + } + } - G_UNLOCK (lock); + G_UNLOCK(lock); - return success; + return success; } /*****************************************************************************/ void -nm_utils_strbuf_append_c (char **buf, gsize *len, char c) -{ - switch (*len) { - case 0: - return; - case 1: - (*buf)[0] = '\0'; - *len = 0; - (*buf)++; - return; - default: - (*buf)[0] = c; - (*buf)[1] = '\0'; - (*len)--; - (*buf)++; - return; - } +nm_utils_strbuf_append_c(char **buf, gsize *len, char c) +{ + switch (*len) { + case 0: + return; + case 1: + (*buf)[0] = '\0'; + *len = 0; + (*buf)++; + return; + default: + (*buf)[0] = c; + (*buf)[1] = '\0'; + (*len)--; + (*buf)++; + return; + } } void -nm_utils_strbuf_append_bin (char **buf, gsize *len, gconstpointer str, gsize str_len) -{ - switch (*len) { - case 0: - return; - case 1: - if (str_len == 0) { - (*buf)[0] = '\0'; - return; - } - (*buf)[0] = '\0'; - *len = 0; - (*buf)++; - return; - default: - if (str_len == 0) { - (*buf)[0] = '\0'; - return; - } - if (str_len >= *len) { - memcpy (*buf, str, *len - 1); - (*buf)[*len - 1] = '\0'; - *buf = &(*buf)[*len]; - *len = 0; - } else { - memcpy (*buf, str, str_len); - *buf = &(*buf)[str_len]; - (*buf)[0] = '\0'; - *len -= str_len; - } - return; - } +nm_utils_strbuf_append_bin(char **buf, gsize *len, gconstpointer str, gsize str_len) +{ + switch (*len) { + case 0: + return; + case 1: + if (str_len == 0) { + (*buf)[0] = '\0'; + return; + } + (*buf)[0] = '\0'; + *len = 0; + (*buf)++; + return; + default: + if (str_len == 0) { + (*buf)[0] = '\0'; + return; + } + if (str_len >= *len) { + memcpy(*buf, str, *len - 1); + (*buf)[*len - 1] = '\0'; + *buf = &(*buf)[*len]; + *len = 0; + } else { + memcpy(*buf, str, str_len); + *buf = &(*buf)[str_len]; + (*buf)[0] = '\0'; + *len -= str_len; + } + return; + } } void -nm_utils_strbuf_append_str (char **buf, gsize *len, const char *str) -{ - gsize src_len; - - switch (*len) { - case 0: - return; - case 1: - if (!str || !*str) { - (*buf)[0] = '\0'; - return; - } - (*buf)[0] = '\0'; - *len = 0; - (*buf)++; - return; - default: - if (!str || !*str) { - (*buf)[0] = '\0'; - return; - } - src_len = g_strlcpy (*buf, str, *len); - if (src_len >= *len) { - *buf = &(*buf)[*len]; - *len = 0; - } else { - *buf = &(*buf)[src_len]; - *len -= src_len; - } - return; - } +nm_utils_strbuf_append_str(char **buf, gsize *len, const char *str) +{ + gsize src_len; + + switch (*len) { + case 0: + return; + case 1: + if (!str || !*str) { + (*buf)[0] = '\0'; + return; + } + (*buf)[0] = '\0'; + *len = 0; + (*buf)++; + return; + default: + if (!str || !*str) { + (*buf)[0] = '\0'; + return; + } + src_len = g_strlcpy(*buf, str, *len); + if (src_len >= *len) { + *buf = &(*buf)[*len]; + *len = 0; + } else { + *buf = &(*buf)[src_len]; + *len -= src_len; + } + return; + } } void -nm_utils_strbuf_append (char **buf, gsize *len, const char *format, ...) +nm_utils_strbuf_append(char **buf, gsize *len, const char *format, ...) { - char *p = *buf; - va_list args; - int retval; + char * p = *buf; + va_list args; + int retval; - if (*len == 0) - return; + if (*len == 0) + return; - va_start (args, format); - retval = g_vsnprintf (p, *len, format, args); - va_end (args); + va_start(args, format); + retval = g_vsnprintf(p, *len, format, args); + va_end(args); - if ((gsize) retval >= *len) { - *buf = &p[*len]; - *len = 0; - } else { - *buf = &p[retval]; - *len -= retval; - } + if ((gsize) retval >= *len) { + *buf = &p[*len]; + *len = 0; + } else { + *buf = &p[retval]; + *len -= retval; + } } /** @@ -369,59 +307,58 @@ nm_utils_strbuf_append (char **buf, gsize *len, const char *format, ...) * nm_utils_strbuf_seek_end() would then NUL terminate it. */ void -nm_utils_strbuf_seek_end (char **buf, gsize *len) +nm_utils_strbuf_seek_end(char **buf, gsize *len) { - gsize l; - char *end; + gsize l; + char *end; - nm_assert (len); - nm_assert (buf && *buf); + nm_assert(len); + nm_assert(buf && *buf); - if (*len <= 1) { - if ( *len == 1 - && (*buf)[0]) - goto truncate; - return; - } + if (*len <= 1) { + if (*len == 1 && (*buf)[0]) + goto truncate; + return; + } - end = memchr (*buf, 0, *len); - if (end) { - l = end - *buf; - nm_assert (l < *len); + end = memchr(*buf, 0, *len); + if (end) { + l = end - *buf; + nm_assert(l < *len); - *buf = end; - *len -= l; - return; - } + *buf = end; + *len -= l; + return; + } truncate: - /* hm, no NUL character within len bytes. - * Just NUL terminate the array and consume them - * all. */ - *buf += *len; - (*buf)[-1] = '\0'; - *len = 0; - return; + /* hm, no NUL character within len bytes. + * Just NUL terminate the array and consume them + * all. */ + *buf += *len; + (*buf)[-1] = '\0'; + *len = 0; + return; } /*****************************************************************************/ GBytes * -nm_gbytes_get_empty (void) +nm_gbytes_get_empty(void) { - static GBytes *bytes = NULL; - GBytes *b; + static GBytes *bytes = NULL; + GBytes * b; again: - b = g_atomic_pointer_get (&bytes); - if (G_UNLIKELY (!b)) { - b = g_bytes_new_static ("", 0); - if (!g_atomic_pointer_compare_and_exchange (&bytes, NULL, b)) { - g_bytes_unref (b); - goto again; - } - } - return b; + b = g_atomic_pointer_get(&bytes); + if (G_UNLIKELY(!b)) { + b = g_bytes_new_static("", 0); + if (!g_atomic_pointer_compare_and_exchange(&bytes, NULL, b)) { + g_bytes_unref(b); + goto again; + } + } + return b; } /** @@ -435,38 +372,64 @@ again: * special case, a %NULL @bytes is treated like an empty array. */ gboolean -nm_utils_gbytes_equal_mem (GBytes *bytes, - gconstpointer mem_data, - gsize mem_len) +nm_utils_gbytes_equal_mem(GBytes *bytes, gconstpointer mem_data, gsize mem_len) { - gconstpointer p; - gsize l; + gconstpointer p; + gsize l; - if (!bytes) { - /* as a special case, let %NULL GBytes compare idential - * to an empty array. */ - return (mem_len == 0); - } + if (!bytes) { + /* as a special case, let %NULL GBytes compare identical + * to an empty array. */ + return (mem_len == 0); + } - p = g_bytes_get_data (bytes, &l); - return l == mem_len - && ( mem_len == 0 /* allow @mem_data to be %NULL */ - || memcmp (p, mem_data, mem_len) == 0); + p = g_bytes_get_data(bytes, &l); + return l == mem_len + && (mem_len == 0 /* allow @mem_data to be %NULL */ + || memcmp(p, mem_data, mem_len) == 0); } GVariant * -nm_utils_gbytes_to_variant_ay (GBytes *bytes) +nm_utils_gbytes_to_variant_ay(GBytes *bytes) { - const guint8 *p; - gsize l; + const guint8 *p; + gsize l; + + if (!bytes) { + /* for convenience, accept NULL to return an empty variant */ + return g_variant_new_array(G_VARIANT_TYPE_BYTE, NULL, 0); + } - if (!bytes) { - /* for convenience, accept NULL to return an empty variant */ - return g_variant_new_array (G_VARIANT_TYPE_BYTE, NULL, 0); - } + p = g_bytes_get_data(bytes, &l); + return g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, p, l, 1); +} + +/*****************************************************************************/ - p = g_bytes_get_data (bytes, &l); - return g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, p, l, 1); +#define _variant_singleton_get(create_variant) \ + ({ \ + static GVariant *_singleton = NULL; \ + GVariant * _v; \ + \ +again: \ + _v = g_atomic_pointer_get(&_singleton); \ + if (G_UNLIKELY(!_v)) { \ + _v = (create_variant); \ + nm_assert(_v); \ + nm_assert(g_variant_is_floating(_v)); \ + g_variant_ref_sink(_v); \ + if (!g_atomic_pointer_compare_and_exchange(&_singleton, NULL, _v)) { \ + g_variant_unref(_v); \ + goto again; \ + } \ + } \ + _v; \ + }) + +GVariant * +nm_g_variant_singleton_u_0(void) +{ + return _variant_singleton_get(g_variant_new_uint32(0)); } /*****************************************************************************/ @@ -476,53 +439,46 @@ nm_utils_gbytes_to_variant_ay (GBytes *bytes) * Returns a floating reference. */ GVariant * -nm_utils_strdict_to_variant_ass (GHashTable *strdict) -{ - GHashTableIter iter; - const char *key, *value; - GVariantBuilder builder; - guint i, len; - - g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{ss}")); - - if (!strdict) - goto out; - len = g_hash_table_size (strdict); - if (!len) - goto out; - - g_hash_table_iter_init (&iter, strdict); - if (!g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value)) - nm_assert_not_reached (); - - if (len == 1) - g_variant_builder_add (&builder, "{ss}", key, value); - else { - gs_free NMUtilsNamedValue *idx_free = NULL; - NMUtilsNamedValue *idx; - - if (len > 300 / sizeof (NMUtilsNamedValue)) { - idx_free = g_new (NMUtilsNamedValue, len); - idx = idx_free; - } else - idx = g_alloca (sizeof (NMUtilsNamedValue) * len); - - i = 0; - do { - idx[i].name = key; - idx[i].value_str = value; - i++; - } while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value)); - nm_assert (i == len); - - nm_utils_named_value_list_sort (idx, len, NULL, NULL); - - for (i = 0; i < len; i++) - g_variant_builder_add (&builder, "{ss}", idx[i].name, idx[i].value_str); - } +nm_utils_strdict_to_variant_ass(GHashTable *strdict) +{ + gs_free NMUtilsNamedValue *values_free = NULL; + NMUtilsNamedValue values_prepared[20]; + const NMUtilsNamedValue * values; + GVariantBuilder builder; + guint i; + guint n; -out: - return g_variant_builder_end (&builder); + values = nm_utils_named_values_from_strdict(strdict, &n, values_prepared, &values_free); + + g_variant_builder_init(&builder, G_VARIANT_TYPE("a{ss}")); + for (i = 0; i < n; i++) { + g_variant_builder_add(&builder, "{ss}", values[i].name, values[i].value_str); + } + return g_variant_builder_end(&builder); +} + +/*****************************************************************************/ + +GVariant * +nm_utils_strdict_to_variant_asv(GHashTable *strdict) +{ + gs_free NMUtilsNamedValue *values_free = NULL; + NMUtilsNamedValue values_prepared[20]; + const NMUtilsNamedValue * values; + GVariantBuilder builder; + guint i; + guint n; + + values = nm_utils_named_values_from_strdict(strdict, &n, values_prepared, &values_free); + + 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); } /*****************************************************************************/ @@ -548,54 +504,54 @@ out: * Returns: the input buffer with the quoted string. */ const char * -nm_strquote (char *buf, gsize buf_len, const char *str) -{ - const char *const buf0 = buf; - - if (!str) { - nm_utils_strbuf_append_str (&buf, &buf_len, "(null)"); - goto out; - } - - if (G_UNLIKELY (buf_len <= 2)) { - switch (buf_len) { - case 2: - *(buf++) = '^'; - /* fall-through */ - case 1: - *(buf++) = '\0'; - break; - } - goto out; - } - - *(buf++) = '"'; - buf_len--; - - nm_utils_strbuf_append_str (&buf, &buf_len, str); - - /* if the string was too long we indicate truncation with a - * '^' instead of a closing quote. */ - if (G_UNLIKELY (buf_len <= 1)) { - switch (buf_len) { - case 1: - buf[-1] = '^'; - break; - case 0: - buf[-2] = '^'; - break; - default: - nm_assert_not_reached (); - break; - } - } else { - nm_assert (buf_len >= 2); - *(buf++) = '"'; - *(buf++) = '\0'; - } +nm_strquote(char *buf, gsize buf_len, const char *str) +{ + const char *const buf0 = buf; + + if (!str) { + nm_utils_strbuf_append_str(&buf, &buf_len, "(null)"); + goto out; + } + + if (G_UNLIKELY(buf_len <= 2)) { + switch (buf_len) { + case 2: + *(buf++) = '^'; + /* fall-through */ + case 1: + *(buf++) = '\0'; + break; + } + goto out; + } + + *(buf++) = '"'; + buf_len--; + + nm_utils_strbuf_append_str(&buf, &buf_len, str); + + /* if the string was too long we indicate truncation with a + * '^' instead of a closing quote. */ + if (G_UNLIKELY(buf_len <= 1)) { + switch (buf_len) { + case 1: + buf[-1] = '^'; + break; + case 0: + buf[-2] = '^'; + break; + default: + nm_assert_not_reached(); + break; + } + } else { + nm_assert(buf_len >= 2); + *(buf++) = '"'; + *(buf++) = '\0'; + } out: - return buf0; + return buf0; } /*****************************************************************************/ @@ -603,82 +559,81 @@ out: char _nm_utils_to_string_buffer[]; void -nm_utils_to_string_buffer_init (char **buf, gsize *len) +nm_utils_to_string_buffer_init(char **buf, gsize *len) { - if (!*buf) { - *buf = _nm_utils_to_string_buffer; - *len = sizeof (_nm_utils_to_string_buffer); - } + if (!*buf) { + *buf = _nm_utils_to_string_buffer; + *len = sizeof(_nm_utils_to_string_buffer); + } } gboolean -nm_utils_to_string_buffer_init_null (gconstpointer obj, char **buf, gsize *len) +nm_utils_to_string_buffer_init_null(gconstpointer obj, char **buf, gsize *len) { - nm_utils_to_string_buffer_init (buf, len); - if (!obj) { - g_strlcpy (*buf, "(null)", *len); - return FALSE; - } - return TRUE; + nm_utils_to_string_buffer_init(buf, len); + if (!obj) { + g_strlcpy(*buf, "(null)", *len); + return FALSE; + } + return TRUE; } /*****************************************************************************/ const char * -nm_utils_flags2str (const NMUtilsFlags2StrDesc *descs, - gsize n_descs, - unsigned flags, - char *buf, - gsize len) +nm_utils_flags2str(const NMUtilsFlags2StrDesc *descs, + gsize n_descs, + unsigned flags, + char * buf, + gsize len) { - gsize i; - char *p; + gsize i; + char *p; #if NM_MORE_ASSERTS > 10 - nm_assert (descs); - nm_assert (n_descs > 0); - for (i = 0; i < n_descs; i++) { - gsize j; - - nm_assert (descs[i].name && descs[i].name[0]); - for (j = 0; j < i; j++) - nm_assert (descs[j].flag != descs[i].flag); - } + nm_assert(descs); + nm_assert(n_descs > 0); + for (i = 0; i < n_descs; i++) { + gsize j; + + nm_assert(descs[i].name && descs[i].name[0]); + for (j = 0; j < i; j++) + nm_assert(descs[j].flag != descs[i].flag); + } #endif - nm_utils_to_string_buffer_init (&buf, &len); - - if (!len) - return buf; - - buf[0] = '\0'; - p = buf; - if (!flags) { - for (i = 0; i < n_descs; i++) { - if (!descs[i].flag) { - nm_utils_strbuf_append_str (&p, &len, descs[i].name); - break; - } - } - return buf; - } - - for (i = 0; flags && i < n_descs; i++) { - if ( descs[i].flag - && NM_FLAGS_ALL (flags, descs[i].flag)) { - flags &= ~descs[i].flag; - - if (buf[0] != '\0') - nm_utils_strbuf_append_c (&p, &len, ','); - nm_utils_strbuf_append_str (&p, &len, descs[i].name); - } - } - if (flags) { - if (buf[0] != '\0') - nm_utils_strbuf_append_c (&p, &len, ','); - nm_utils_strbuf_append (&p, &len, "0x%x", flags); - } - return buf; + nm_utils_to_string_buffer_init(&buf, &len); + + if (!len) + return buf; + + buf[0] = '\0'; + p = buf; + if (!flags) { + for (i = 0; i < n_descs; i++) { + if (!descs[i].flag) { + nm_utils_strbuf_append_str(&p, &len, descs[i].name); + break; + } + } + return buf; + } + + for (i = 0; flags && i < n_descs; i++) { + if (descs[i].flag && NM_FLAGS_ALL(flags, descs[i].flag)) { + flags &= ~descs[i].flag; + + if (buf[0] != '\0') + nm_utils_strbuf_append_c(&p, &len, ','); + nm_utils_strbuf_append_str(&p, &len, descs[i].name); + } + } + if (flags) { + if (buf[0] != '\0') + nm_utils_strbuf_append_c(&p, &len, ','); + nm_utils_strbuf_append(&p, &len, "0x%x", flags); + } + return buf; }; /*****************************************************************************/ @@ -690,34 +645,34 @@ nm_utils_flags2str (const NMUtilsFlags2StrDesc *descs, * Returns: the netmask represented by the prefix, in network byte order **/ guint32 -_nm_utils_ip4_prefix_to_netmask (guint32 prefix) +_nm_utils_ip4_prefix_to_netmask(guint32 prefix) { - return prefix < 32 ? ~htonl(0xFFFFFFFF >> prefix) : 0xFFFFFFFF; + return prefix < 32 ? ~htonl(0xFFFFFFFFu >> prefix) : 0xFFFFFFFFu; } gconstpointer -nm_utils_ipx_address_clear_host_address (int family, gpointer dst, gconstpointer src, guint8 plen) +nm_utils_ipx_address_clear_host_address(int family, gpointer dst, gconstpointer src, guint8 plen) { - g_return_val_if_fail (dst, NULL); + g_return_val_if_fail(dst, NULL); - switch (family) { - case AF_INET: - g_return_val_if_fail (plen <= 32, NULL); + switch (family) { + case AF_INET: + g_return_val_if_fail(plen <= 32, NULL); - if (!src) { - /* allow "self-assignment", by specifying %NULL as source. */ - src = dst; - } + if (!src) { + /* allow "self-assignment", by specifying %NULL as source. */ + src = dst; + } - *((guint32 *) dst) = nm_utils_ip4_address_clear_host_address (*((guint32 *) src), plen); - break; - case AF_INET6: - nm_utils_ip6_address_clear_host_address (dst, src, plen); - break; - default: - g_return_val_if_reached (NULL); - } - return dst; + *((guint32 *) dst) = nm_utils_ip4_address_clear_host_address(*((guint32 *) src), plen); + break; + case AF_INET6: + nm_utils_ip6_address_clear_host_address(dst, src, plen); + break; + default: + g_return_val_if_reached(NULL); + } + return dst; } /* nm_utils_ip4_address_clear_host_address: @@ -727,9 +682,9 @@ nm_utils_ipx_address_clear_host_address (int family, gpointer dst, gconstpointer * returns: the input address, with the host address set to 0. */ in_addr_t -nm_utils_ip4_address_clear_host_address (in_addr_t addr, guint8 plen) +nm_utils_ip4_address_clear_host_address(in_addr_t addr, guint8 plen) { - return addr & _nm_utils_ip4_prefix_to_netmask (plen); + return addr & _nm_utils_ip4_prefix_to_netmask(plen); } /* nm_utils_ip6_address_clear_host_address: @@ -741,54 +696,58 @@ nm_utils_ip4_address_clear_host_address (in_addr_t addr, guint8 plen) * @dst and @src to the same destination or set @src NULL. */ const struct in6_addr * -nm_utils_ip6_address_clear_host_address (struct in6_addr *dst, const struct in6_addr *src, guint8 plen) +nm_utils_ip6_address_clear_host_address(struct in6_addr * dst, + const struct in6_addr *src, + guint8 plen) { - g_return_val_if_fail (plen <= 128, NULL); - g_return_val_if_fail (dst, NULL); + g_return_val_if_fail(plen <= 128, NULL); + g_return_val_if_fail(dst, NULL); - if (!src) - src = dst; + if (!src) + src = dst; - if (plen < 128) { - guint nbytes = plen / 8; - guint nbits = plen % 8; + if (plen < 128) { + guint nbytes = plen / 8; + guint nbits = plen % 8; - if (nbytes && dst != src) - memcpy (dst, src, nbytes); - if (nbits) { - dst->s6_addr[nbytes] = (src->s6_addr[nbytes] & (0xFF << (8 - nbits))); - nbytes++; - } - if (nbytes <= 15) - memset (&dst->s6_addr[nbytes], 0, 16 - nbytes); - } else if (src != dst) - *dst = *src; + if (nbytes && dst != src) + memcpy(dst, src, nbytes); + if (nbits) { + dst->s6_addr[nbytes] = (src->s6_addr[nbytes] & (0xFF << (8 - nbits))); + nbytes++; + } + if (nbytes <= 15) + memset(&dst->s6_addr[nbytes], 0, 16 - nbytes); + } else if (src != dst) + *dst = *src; - return dst; + return dst; } int -nm_utils_ip6_address_same_prefix_cmp (const struct in6_addr *addr_a, const struct in6_addr *addr_b, guint8 plen) -{ - int nbytes; - guint8 va, vb, m; - - if (plen >= 128) - NM_CMP_DIRECT_MEMCMP (addr_a, addr_b, sizeof (struct in6_addr)); - else { - nbytes = plen / 8; - if (nbytes) - NM_CMP_DIRECT_MEMCMP (addr_a, addr_b, nbytes); - - plen = plen % 8; - if (plen != 0) { - m = ~((1 << (8 - plen)) - 1); - va = ((((const guint8 *) addr_a))[nbytes]) & m; - vb = ((((const guint8 *) addr_b))[nbytes]) & m; - NM_CMP_DIRECT (va, vb); - } - } - return 0; +nm_utils_ip6_address_same_prefix_cmp(const struct in6_addr *addr_a, + const struct in6_addr *addr_b, + guint8 plen) +{ + int nbytes; + guint8 va, vb, m; + + if (plen >= 128) + NM_CMP_DIRECT_MEMCMP(addr_a, addr_b, sizeof(struct in6_addr)); + else { + nbytes = plen / 8; + if (nbytes) + NM_CMP_DIRECT_MEMCMP(addr_a, addr_b, nbytes); + + plen = plen % 8; + if (plen != 0) { + m = ~((1 << (8 - plen)) - 1); + va = ((((const guint8 *) addr_a))[nbytes]) & m; + vb = ((((const guint8 *) addr_b))[nbytes]) & m; + NM_CMP_DIRECT(va, vb); + } + } + return 0; } /** @@ -804,347 +763,349 @@ nm_utils_ip6_address_same_prefix_cmp (const struct in6_addr *addr_a, const struc **/ /* The function is originally from ipcalc.c of Red Hat's initscripts. */ guint32 -_nm_utils_ip4_get_default_prefix (guint32 ip) +_nm_utils_ip4_get_default_prefix(guint32 ip) { - if (((ntohl (ip) & 0xFF000000) >> 24) <= 127) - return 8; /* Class A - 255.0.0.0 */ - else if (((ntohl (ip) & 0xFF000000) >> 24) <= 191) - return 16; /* Class B - 255.255.0.0 */ + if (((ntohl(ip) & 0xFF000000) >> 24) <= 127) + return 8; /* Class A - 255.0.0.0 */ + else if (((ntohl(ip) & 0xFF000000) >> 24) <= 191) + return 16; /* Class B - 255.255.0.0 */ - return 24; /* Class C - 255.255.255.0 */ + return 24; /* Class C - 255.255.255.0 */ } gboolean -nm_utils_ip_is_site_local (int addr_family, - const void *address) -{ - in_addr_t addr4; - - switch (addr_family) { - case AF_INET: - /* RFC1918 private addresses - * 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 */ - addr4 = ntohl (*((const in_addr_t *) address)); - return (addr4 & 0xff000000) == 0x0a000000 - || (addr4 & 0xfff00000) == 0xac100000 - || (addr4 & 0xffff0000) == 0xc0a80000; - case AF_INET6: - return IN6_IS_ADDR_SITELOCAL (address); - default: - g_return_val_if_reached (FALSE); - } +nm_utils_ip_is_site_local(int addr_family, const void *address) +{ + in_addr_t addr4; + + switch (addr_family) { + case AF_INET: + /* RFC1918 private addresses + * 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 */ + addr4 = ntohl(*((const in_addr_t *) address)); + return (addr4 & 0xff000000) == 0x0a000000 || (addr4 & 0xfff00000) == 0xac100000 + || (addr4 & 0xffff0000) == 0xc0a80000; + case AF_INET6: + return IN6_IS_ADDR_SITELOCAL(address); + default: + g_return_val_if_reached(FALSE); + } } /*****************************************************************************/ static gboolean -_parse_legacy_addr4 (const char *text, in_addr_t *out_addr, GError **error) -{ - gs_free char *s_free = NULL; - struct in_addr a1; - guint8 bin[sizeof (a1)]; - char *s; - int i; - - if (inet_aton (text, &a1) != 1) { - g_set_error_literal (error, - NM_UTILS_ERROR, - NM_UTILS_ERROR_INVALID_ARGUMENT, - "address invalid according to inet_aton()"); - return FALSE; - } - - /* OK, inet_aton() accepted the format. That's good, because we want - * to accept IPv4 addresses in octal format, like 255.255.000.000. - * That's what "legacy" means here. inet_pton() doesn't accept those. - * - * But inet_aton() also ignores trailing garbage and formats with fewer than - * 4 digits. That is just too crazy and we don't do that. Perform additional checks - * and reject some forms that inet_aton() accepted. - * - * Note that we still should (of course) accept everything that inet_pton() - * accepts. However this code never gets called if inet_pton() succeeds - * (see below, aside the assertion code). */ - - if (NM_STRCHAR_ANY (text, ch, ( !(ch >= '0' && ch <= '9') - && !NM_IN_SET (ch, '.', 'x')))) { - /* We only accepts '.', digits, and 'x' for "0x". */ - g_set_error_literal (error, - NM_UTILS_ERROR, - NM_UTILS_ERROR_INVALID_ARGUMENT, - "contains an invalid character"); - return FALSE; - } - - s = nm_memdup_maybe_a (300, text, strlen (text) + 1, &s_free); - - for (i = 0; i < G_N_ELEMENTS (bin); i++) { - char *current_token = s; - gint32 v; - - s = strchr (s, '.'); - if (s) { - s[0] = '\0'; - s++; - } - - if ((i == G_N_ELEMENTS (bin) - 1) != (s == NULL)) { - /* Exactly for the last digit, we expect to have no more following token. - * But this isn't the case. Abort. */ - g_set_error (error, - NM_UTILS_ERROR, - NM_UTILS_ERROR_INVALID_ARGUMENT, - "wrong number of tokens (index %d, token '%s')", - i, s); - return FALSE; - } - - v = _nm_utils_ascii_str_to_int64 (current_token, 0, 0, 0xFF, -1); - if (v == -1) { - int errsv = errno; - - /* we do accept octal and hex (even with leading "0x"). But something - * about this token is wrong. */ - g_set_error (error, - NM_UTILS_ERROR, - NM_UTILS_ERROR_INVALID_ARGUMENT, - "invalid token '%s': %s (%d)", - current_token, - nm_strerror_native (errsv), - errsv); - return FALSE; - } - - bin[i] = v; - } - - if (memcmp (bin, &a1, sizeof (bin)) != 0) { - /* our parsing did not agree with what inet_aton() gave. Something - * is wrong. Abort. */ - g_set_error (error, - NM_UTILS_ERROR, - NM_UTILS_ERROR_INVALID_ARGUMENT, - "inet_aton() result 0x%08x differs from computed value 0x%02hhx%02hhx%02hhx%02hhx", - a1.s_addr, - bin[0], bin[1], bin[2], bin[3]); - return FALSE; - } - - *out_addr = a1.s_addr; - return TRUE; +_parse_legacy_addr4(const char *text, in_addr_t *out_addr, GError **error) +{ + gs_free char * s_free = NULL; + struct in_addr a1; + guint8 bin[sizeof(a1)]; + char * s; + int i; + + if (inet_aton(text, &a1) != 1) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_INVALID_ARGUMENT, + "address invalid according to inet_aton()"); + return FALSE; + } + + /* OK, inet_aton() accepted the format. That's good, because we want + * to accept IPv4 addresses in octal format, like 255.255.000.000. + * That's what "legacy" means here. inet_pton() doesn't accept those. + * + * But inet_aton() also ignores trailing garbage and formats with fewer than + * 4 digits. That is just too crazy and we don't do that. Perform additional checks + * and reject some forms that inet_aton() accepted. + * + * Note that we still should (of course) accept everything that inet_pton() + * accepts. However this code never gets called if inet_pton() succeeds + * (see below, aside the assertion code). */ + + if (NM_STRCHAR_ANY(text, ch, (!(ch >= '0' && ch <= '9') && !NM_IN_SET(ch, '.', 'x')))) { + /* We only accepts '.', digits, and 'x' for "0x". */ + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_INVALID_ARGUMENT, + "contains an invalid character"); + return FALSE; + } + + s = nm_memdup_maybe_a(300, text, strlen(text) + 1, &s_free); + + for (i = 0; i < G_N_ELEMENTS(bin); i++) { + char * current_token = s; + gint32 v; + + s = strchr(s, '.'); + if (s) { + s[0] = '\0'; + s++; + } + + if ((i == G_N_ELEMENTS(bin) - 1) != (s == NULL)) { + /* Exactly for the last digit, we expect to have no more following token. + * But this isn't the case. Abort. */ + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_INVALID_ARGUMENT, + "wrong number of tokens (index %d, token '%s')", + i, + s); + return FALSE; + } + + v = _nm_utils_ascii_str_to_int64(current_token, 0, 0, 0xFF, -1); + if (v == -1) { + int errsv = errno; + + /* we do accept octal and hex (even with leading "0x"). But something + * about this token is wrong. */ + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_INVALID_ARGUMENT, + "invalid token '%s': %s (%d)", + current_token, + nm_strerror_native(errsv), + errsv); + return FALSE; + } + + bin[i] = v; + } + + if (memcmp(bin, &a1, sizeof(bin)) != 0) { + /* our parsing did not agree with what inet_aton() gave. Something + * is wrong. Abort. */ + g_set_error( + error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_INVALID_ARGUMENT, + "inet_aton() result 0x%08x differs from computed value 0x%02hhx%02hhx%02hhx%02hhx", + a1.s_addr, + bin[0], + bin[1], + bin[2], + bin[3]); + return FALSE; + } + + *out_addr = a1.s_addr; + return TRUE; } gboolean -nm_utils_parse_inaddr_bin_full (int addr_family, - gboolean accept_legacy, - const char *text, - int *out_addr_family, - gpointer out_addr) -{ - NMIPAddr addrbin; - - g_return_val_if_fail (text, FALSE); - - if (addr_family == AF_UNSPEC) { - g_return_val_if_fail (!out_addr || out_addr_family, FALSE); - addr_family = strchr (text, ':') ? AF_INET6 : AF_INET; - } else - g_return_val_if_fail (NM_IN_SET (addr_family, AF_INET, AF_INET6), FALSE); - - if (inet_pton (addr_family, text, &addrbin) != 1) { - if ( accept_legacy - && addr_family == AF_INET - && _parse_legacy_addr4 (text, &addrbin.addr4, NULL)) { - /* The address is in some legacy format which inet_aton() accepts, but not inet_pton(). - * Most likely octal digits (leading zeros). We accept the address. */ - } else - return FALSE; - } +nm_utils_parse_inaddr_bin_full(int addr_family, + gboolean accept_legacy, + const char *text, + int * out_addr_family, + gpointer out_addr) +{ + NMIPAddr addrbin; + + g_return_val_if_fail(text, FALSE); + + if (addr_family == AF_UNSPEC) { + g_return_val_if_fail(!out_addr || out_addr_family, FALSE); + addr_family = strchr(text, ':') ? AF_INET6 : AF_INET; + } else + g_return_val_if_fail(NM_IN_SET(addr_family, AF_INET, AF_INET6), FALSE); + + if (inet_pton(addr_family, text, &addrbin) != 1) { + if (accept_legacy && addr_family == AF_INET + && _parse_legacy_addr4(text, &addrbin.addr4, NULL)) { + /* The address is in some legacy format which inet_aton() accepts, but not inet_pton(). + * Most likely octal digits (leading zeros). We accept the address. */ + } else + return FALSE; + } #if NM_MORE_ASSERTS > 10 - if (addr_family == AF_INET) { - gs_free_error GError *error = NULL; - in_addr_t a; - - /* The legacy parser should accept everything that inet_pton() accepts too. Meaning, - * it should strictly parse *more* formats. And of course, parse it the same way. */ - if (!_parse_legacy_addr4 (text, &a, &error)) { - char buf[INET_ADDRSTRLEN]; - - g_error ("unexpected assertion failure: could parse \"%s\" as %s, but not accepted by legacy parser: %s", - text, _nm_utils_inet4_ntop (addrbin.addr4, buf), error->message); - } - nm_assert (addrbin.addr4 == a); - } + if (addr_family == AF_INET) { + gs_free_error GError *error = NULL; + in_addr_t a; + + /* The legacy parser should accept everything that inet_pton() accepts too. Meaning, + * it should strictly parse *more* formats. And of course, parse it the same way. */ + if (!_parse_legacy_addr4(text, &a, &error)) { + char buf[INET_ADDRSTRLEN]; + + g_error("unexpected assertion failure: could parse \"%s\" as %s, but not accepted by " + "legacy parser: %s", + text, + _nm_utils_inet4_ntop(addrbin.addr4, buf), + error->message); + } + nm_assert(addrbin.addr4 == a); + } #endif - NM_SET_OUT (out_addr_family, addr_family); - if (out_addr) - nm_ip_addr_set (addr_family, out_addr, &addrbin); - return TRUE; + NM_SET_OUT(out_addr_family, addr_family); + if (out_addr) + nm_ip_addr_set(addr_family, out_addr, &addrbin); + return TRUE; } gboolean -nm_utils_parse_inaddr (int addr_family, - const char *text, - char **out_addr) +nm_utils_parse_inaddr(int addr_family, const char *text, char **out_addr) { - NMIPAddr addrbin; - char addrstr_buf[MAX (INET_ADDRSTRLEN, INET6_ADDRSTRLEN)]; + NMIPAddr addrbin; + char addrstr_buf[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)]; - g_return_val_if_fail (text, FALSE); + g_return_val_if_fail(text, FALSE); - if (addr_family == AF_UNSPEC) - addr_family = strchr (text, ':') ? AF_INET6 : AF_INET; - else - g_return_val_if_fail (NM_IN_SET (addr_family, AF_INET, AF_INET6), FALSE); + if (addr_family == AF_UNSPEC) + addr_family = strchr(text, ':') ? AF_INET6 : AF_INET; + else + g_return_val_if_fail(NM_IN_SET(addr_family, AF_INET, AF_INET6), FALSE); - if (inet_pton (addr_family, text, &addrbin) != 1) - return FALSE; + if (inet_pton(addr_family, text, &addrbin) != 1) + return FALSE; - NM_SET_OUT (out_addr, g_strdup (inet_ntop (addr_family, &addrbin, addrstr_buf, sizeof (addrstr_buf)))); - return TRUE; + NM_SET_OUT(out_addr, + g_strdup(inet_ntop(addr_family, &addrbin, addrstr_buf, sizeof(addrstr_buf)))); + return TRUE; } gboolean -nm_utils_parse_inaddr_prefix_bin (int addr_family, - const char *text, - int *out_addr_family, - gpointer out_addr, - int *out_prefix) -{ - gs_free char *addrstr_free = NULL; - int prefix = -1; - const char *slash; - const char *addrstr; - NMIPAddr addrbin; - - g_return_val_if_fail (text, FALSE); - - if (addr_family == AF_UNSPEC) { - g_return_val_if_fail (!out_addr || out_addr_family, FALSE); - addr_family = strchr (text, ':') ? AF_INET6 : AF_INET; - } else - g_return_val_if_fail (NM_IN_SET (addr_family, AF_INET, AF_INET6), FALSE); - - slash = strchr (text, '/'); - if (slash) - addrstr = addrstr_free = g_strndup (text, slash - text); - else - addrstr = text; - - if (inet_pton (addr_family, addrstr, &addrbin) != 1) - return FALSE; - - if (slash) { - /* For IPv4, `ip addr add` supports the prefix-length as a netmask. We don't - * do that. */ - prefix = _nm_utils_ascii_str_to_int64 (slash + 1, 10, - 0, - addr_family == AF_INET ? 32 : 128, - -1); - if (prefix == -1) - return FALSE; - } - - NM_SET_OUT (out_addr_family, addr_family); - if (out_addr) - nm_ip_addr_set (addr_family, out_addr, &addrbin); - NM_SET_OUT (out_prefix, prefix); - return TRUE; +nm_utils_parse_inaddr_prefix_bin(int addr_family, + const char *text, + int * out_addr_family, + gpointer out_addr, + int * out_prefix) +{ + gs_free char *addrstr_free = NULL; + int prefix = -1; + const char * slash; + const char * addrstr; + NMIPAddr addrbin; + + g_return_val_if_fail(text, FALSE); + + if (addr_family == AF_UNSPEC) { + g_return_val_if_fail(!out_addr || out_addr_family, FALSE); + addr_family = strchr(text, ':') ? AF_INET6 : AF_INET; + } else + g_return_val_if_fail(NM_IN_SET(addr_family, AF_INET, AF_INET6), FALSE); + + slash = strchr(text, '/'); + if (slash) + addrstr = nm_strndup_a(300, text, slash - text, &addrstr_free); + else + addrstr = text; + + if (inet_pton(addr_family, addrstr, &addrbin) != 1) + return FALSE; + + if (slash) { + /* For IPv4, `ip addr add` supports the prefix-length as a netmask. We don't + * do that. */ + prefix = + _nm_utils_ascii_str_to_int64(&slash[1], 10, 0, addr_family == AF_INET ? 32 : 128, -1); + if (prefix == -1) + return FALSE; + } + + NM_SET_OUT(out_addr_family, addr_family); + if (out_addr) + nm_ip_addr_set(addr_family, out_addr, &addrbin); + NM_SET_OUT(out_prefix, prefix); + return TRUE; } gboolean -nm_utils_parse_inaddr_prefix (int addr_family, - const char *text, - char **out_addr, - int *out_prefix) +nm_utils_parse_inaddr_prefix(int addr_family, const char *text, char **out_addr, int *out_prefix) { - NMIPAddr addrbin; - char addrstr_buf[MAX (INET_ADDRSTRLEN, INET6_ADDRSTRLEN)]; + NMIPAddr addrbin; + char addrstr_buf[MAX(INET_ADDRSTRLEN, INET6_ADDRSTRLEN)]; - if (!nm_utils_parse_inaddr_prefix_bin (addr_family, text, &addr_family, &addrbin, out_prefix)) - return FALSE; - NM_SET_OUT (out_addr, g_strdup (inet_ntop (addr_family, &addrbin, addrstr_buf, sizeof (addrstr_buf)))); - return TRUE; + if (!nm_utils_parse_inaddr_prefix_bin(addr_family, text, &addr_family, &addrbin, out_prefix)) + return FALSE; + NM_SET_OUT(out_addr, + g_strdup(inet_ntop(addr_family, &addrbin, addrstr_buf, sizeof(addrstr_buf)))); + return TRUE; } gboolean -nm_utils_parse_next_line (const char **inout_ptr, - gsize *inout_len, - const char **out_line, - gsize *out_line_len) -{ - const char *line_start; - const char *line_end; - - g_return_val_if_fail (inout_ptr, FALSE); - g_return_val_if_fail (inout_len, FALSE); - g_return_val_if_fail (out_line, FALSE); - - if (*inout_len <= 0) - goto error; - - line_start = *inout_ptr; - line_end = memchr (line_start, '\n', *inout_len); - if (!line_end) - line_end = memchr (line_start, '\0', *inout_len); - if (!line_end) { - line_end = line_start + *inout_len; - NM_SET_OUT (inout_len, 0); - } else - NM_SET_OUT (inout_len, *inout_len - (line_end - line_start) - 1); - - NM_SET_OUT (out_line, line_start); - NM_SET_OUT (out_line_len, (gsize) (line_end - line_start)); - - if (*inout_len > 0) - NM_SET_OUT (inout_ptr, line_end + 1); - else - NM_SET_OUT (inout_ptr, NULL); - return TRUE; - -error: - NM_SET_OUT (out_line, NULL); - NM_SET_OUT (out_line_len, 0); - return FALSE; +nm_utils_parse_next_line(const char **inout_ptr, + gsize * inout_len, + const char **out_line, + gsize * out_line_len) +{ + gboolean eol_is_carriage_return; + const char *line_start; + gsize line_len; + + nm_assert(inout_ptr); + nm_assert(inout_len); + nm_assert(*inout_len == 0 || *inout_ptr); + nm_assert(out_line); + nm_assert(out_line_len); + + if (G_UNLIKELY(*inout_len == 0)) + return FALSE; + + line_start = *inout_ptr; + + eol_is_carriage_return = FALSE; + for (line_len = 0;; line_len++) { + if (line_len >= *inout_len) { + /* if we consumed the entire line, we place the pointer at + * one character after the end. */ + *inout_ptr = &line_start[line_len]; + *inout_len = 0; + goto done; + } + switch (line_start[line_len]) { + case '\r': + eol_is_carriage_return = TRUE; + /* fall-through*/ + case '\0': + case '\n': + *inout_ptr = &line_start[line_len + 1]; + *inout_len = *inout_len - line_len - 1u; + if (eol_is_carriage_return && *inout_len > 0 && (*inout_ptr)[0] == '\n') { + /* also consume "\r\n" as one. */ + (*inout_len)--; + (*inout_ptr)++; + } + goto done; + } + } + +done: + *out_line = line_start; + *out_line_len = line_len; + return TRUE; } /*****************************************************************************/ gboolean -nm_utils_ipaddr_is_valid (int addr_family, - const char *str_addr) +nm_utils_ipaddr_is_valid(int addr_family, const char *str_addr) { - nm_assert (NM_IN_SET (addr_family, AF_UNSPEC, AF_INET, AF_INET6)); + nm_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6)); - return str_addr - && nm_utils_parse_inaddr_bin (addr_family, - str_addr, - NULL, - NULL); + return str_addr && nm_utils_parse_inaddr_bin(addr_family, str_addr, NULL, NULL); } gboolean -nm_utils_ipaddr_is_normalized (int addr_family, - const char *str_addr) +nm_utils_ipaddr_is_normalized(int addr_family, const char *str_addr) { - NMIPAddr addr; - char sbuf[NM_UTILS_INET_ADDRSTRLEN]; + NMIPAddr addr; + char sbuf[NM_UTILS_INET_ADDRSTRLEN]; - nm_assert (NM_IN_SET (addr_family, AF_UNSPEC, AF_INET, AF_INET6)); + nm_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6)); - if (!str_addr) - return FALSE; + if (!str_addr) + return FALSE; - if (!nm_utils_parse_inaddr_bin (addr_family, - str_addr, - &addr_family, - &addr)) - return FALSE; + if (!nm_utils_parse_inaddr_bin(addr_family, str_addr, &addr_family, &addr)) + return FALSE; - nm_utils_inet_ntop (addr_family, &addr, sbuf); - return nm_streq (sbuf, str_addr); + nm_utils_inet_ntop(addr_family, &addr, sbuf); + return nm_streq(sbuf, str_addr); } /*****************************************************************************/ @@ -1168,137 +1129,124 @@ nm_utils_ipaddr_is_normalized (int addr_family, * This wrapper tries to workaround that condition. */ gint64 -nm_g_ascii_strtoll (const char *nptr, - char **endptr, - guint base) +nm_g_ascii_strtoll(const char *nptr, char **endptr, guint base) { - int try_count = 2; - gint64 v; - const int errsv_orig = errno; - int errsv; + int try_count = 2; + gint64 v; + const int errsv_orig = errno; + int errsv; - nm_assert (nptr); - nm_assert (base == 0u || (base >= 2u && base <= 36u)); + nm_assert(nptr); + nm_assert(base == 0u || (base >= 2u && base <= 36u)); again: - errno = 0; - v = g_ascii_strtoll (nptr, endptr, base); - errsv = errno; + errno = 0; + v = g_ascii_strtoll(nptr, endptr, base); + errsv = errno; - if (errsv == 0) { - if (errsv_orig != 0) - errno = errsv_orig; - return v; - } + if (errsv == 0) { + if (errsv_orig != 0) + errno = errsv_orig; + return v; + } - if ( errsv == ERANGE - && NM_IN_SET (v, G_MININT64, G_MAXINT64)) - return v; + if (errsv == ERANGE && NM_IN_SET(v, G_MININT64, G_MAXINT64)) + return v; - if ( errsv == EINVAL - && v == 0 - && nptr - && nptr[0] == '\0') - return v; + if (errsv == EINVAL && v == 0 && nptr && nptr[0] == '\0') + return v; - if (try_count-- > 0) - goto again; + if (try_count-- > 0) + goto again; #if NM_MORE_ASSERTS - g_critical ("g_ascii_strtoll() for \"%s\" failed with errno=%d (%s) and v=%"G_GINT64_FORMAT, - nptr, - errsv, - nm_strerror_native (errsv), - v); + g_critical("g_ascii_strtoll() for \"%s\" failed with errno=%d (%s) and v=%" G_GINT64_FORMAT, + nptr, + errsv, + nm_strerror_native(errsv), + v); #endif - return v; + return v; } /* See nm_g_ascii_strtoll() */ guint64 -nm_g_ascii_strtoull (const char *nptr, - char **endptr, - guint base) +nm_g_ascii_strtoull(const char *nptr, char **endptr, guint base) { - int try_count = 2; - guint64 v; - const int errsv_orig = errno; - int errsv; + int try_count = 2; + guint64 v; + const int errsv_orig = errno; + int errsv; - nm_assert (nptr); - nm_assert (base == 0u || (base >= 2u && base <= 36u)); + nm_assert(nptr); + nm_assert(base == 0u || (base >= 2u && base <= 36u)); again: - errno = 0; - v = g_ascii_strtoull (nptr, endptr, base); - errsv = errno; + errno = 0; + v = g_ascii_strtoull(nptr, endptr, base); + errsv = errno; - if (errsv == 0) { - if (errsv_orig != 0) - errno = errsv_orig; - return v; - } + if (errsv == 0) { + if (errsv_orig != 0) + errno = errsv_orig; + return v; + } - if ( errsv == ERANGE - && NM_IN_SET (v, G_MAXUINT64)) - return v; + if (errsv == ERANGE && NM_IN_SET(v, G_MAXUINT64)) + return v; - if ( errsv == EINVAL - && v == 0 - && nptr - && nptr[0] == '\0') - return v; + if (errsv == EINVAL && v == 0 && nptr && nptr[0] == '\0') + return v; - if (try_count-- > 0) - goto again; + if (try_count-- > 0) + goto again; #if NM_MORE_ASSERTS - g_critical ("g_ascii_strtoull() for \"%s\" failed with errno=%d (%s) and v=%"G_GUINT64_FORMAT, - nptr, - errsv, - nm_strerror_native (errsv), - v); + g_critical("g_ascii_strtoull() for \"%s\" failed with errno=%d (%s) and v=%" G_GUINT64_FORMAT, + nptr, + errsv, + nm_strerror_native(errsv), + v); #endif - return v; + return v; } /* see nm_g_ascii_strtoll(). */ double -nm_g_ascii_strtod (const char *nptr, - char **endptr) +nm_g_ascii_strtod(const char *nptr, char **endptr) { - int try_count = 2; - double v; - int errsv; + int try_count = 2; + double v; + int errsv; - nm_assert (nptr); + nm_assert(nptr); again: - v = g_ascii_strtod (nptr, endptr); - errsv = errno; + v = g_ascii_strtod(nptr, endptr); + errsv = errno; - if (errsv == 0) - return v; + if (errsv == 0) + return v; - if (errsv == ERANGE) - return v; + if (errsv == ERANGE) + return v; - if (try_count-- > 0) - goto again; + if (try_count-- > 0) + goto again; #if NM_MORE_ASSERTS - g_critical ("g_ascii_strtod() for \"%s\" failed with errno=%d (%s) and v=%f", - nptr, - errsv, - nm_strerror_native (errsv), - v); + g_critical("g_ascii_strtod() for \"%s\" failed with errno=%d (%s) and v=%f", + nptr, + errsv, + nm_strerror_native(errsv), + v); #endif - /* Not really much else to do. Return the parsed value and leave errno set - * to the unexpected value. */ - return v; + /* Not really much else to do. Return the parsed value and leave errno set + * to the unexpected value. */ + return v; } /* _nm_utils_ascii_str_to_int64: @@ -1316,91 +1264,94 @@ again: * white space. **/ gint64 -_nm_utils_ascii_str_to_int64 (const char *str, guint base, gint64 min, gint64 max, gint64 fallback) +_nm_utils_ascii_str_to_int64(const char *str, guint base, gint64 min, gint64 max, gint64 fallback) { - gint64 v; - const char *s = NULL; + gint64 v; + const char *s = NULL; - str = nm_str_skip_leading_spaces (str); - if (!str || !str[0]) { - errno = EINVAL; - return fallback; - } + str = nm_str_skip_leading_spaces(str); + if (!str || !str[0]) { + errno = EINVAL; + return fallback; + } - errno = 0; - v = nm_g_ascii_strtoll (str, (char **) &s, base); + errno = 0; + v = nm_g_ascii_strtoll(str, (char **) &s, base); - if (errno != 0) - return fallback; + if (errno != 0) + return fallback; - if (s[0] != '\0') { - s = nm_str_skip_leading_spaces (s); - if (s[0] != '\0') { - errno = EINVAL; - return fallback; - } - } - if (v > max || v < min) { - errno = ERANGE; - return fallback; - } + if (s[0] != '\0') { + s = nm_str_skip_leading_spaces(s); + if (s[0] != '\0') { + errno = EINVAL; + return fallback; + } + } + if (v > max || v < min) { + errno = ERANGE; + return fallback; + } - return v; + return v; } guint64 -_nm_utils_ascii_str_to_uint64 (const char *str, guint base, guint64 min, guint64 max, guint64 fallback) -{ - guint64 v; - const char *s = NULL; - - if (str) { - while (g_ascii_isspace (str[0])) - str++; - } - if (!str || !str[0]) { - errno = EINVAL; - return fallback; - } - - errno = 0; - v = nm_g_ascii_strtoull (str, (char **) &s, base); - - if (errno != 0) - return fallback; - if (s[0] != '\0') { - while (g_ascii_isspace (s[0])) - s++; - if (s[0] != '\0') { - errno = EINVAL; - return fallback; - } - } - if (v > max || v < min) { - errno = ERANGE; - return fallback; - } - - if ( v != 0 - && str[0] == '-') { - /* As documented, g_ascii_strtoull() accepts negative values, and returns their - * absolute value. We don't. */ - errno = ERANGE; - return fallback; - } - - return v; +_nm_utils_ascii_str_to_uint64(const char *str, + guint base, + guint64 min, + guint64 max, + guint64 fallback) +{ + guint64 v; + const char *s = NULL; + + if (str) { + while (g_ascii_isspace(str[0])) + str++; + } + if (!str || !str[0]) { + errno = EINVAL; + return fallback; + } + + errno = 0; + v = nm_g_ascii_strtoull(str, (char **) &s, base); + + if (errno != 0) + return fallback; + if (s[0] != '\0') { + while (g_ascii_isspace(s[0])) + s++; + if (s[0] != '\0') { + errno = EINVAL; + return fallback; + } + } + if (v > max || v < min) { + errno = ERANGE; + return fallback; + } + + if (v != 0 && str[0] == '-') { + /* As documented, g_ascii_strtoull() accepts negative values, and returns their + * absolute value. We don't. */ + errno = ERANGE; + return fallback; + } + + return v; } /*****************************************************************************/ int -nm_strcmp_with_data (gconstpointer a, gconstpointer b, gpointer user_data) +nm_strcmp_with_data(gconstpointer a, gconstpointer b, gpointer user_data) { - const char *s1 = a; - const char *s2 = b; + const char *s1 = a; + const char *s2 = b; - return strcmp (s1, s2); + return strcmp(s1, s2); } /* like nm_strcmp_p(), suitable for g_ptr_array_sort_with_data(). @@ -1411,202 +1362,220 @@ nm_strcmp_with_data (gconstpointer a, gconstpointer b, gpointer user_data) * For NetworkManager, we'd rather avoid such stunts. **/ int -nm_strcmp_p_with_data (gconstpointer a, gconstpointer b, gpointer user_data) +nm_strcmp_p_with_data(gconstpointer a, gconstpointer b, gpointer user_data) +{ + const char *s1 = *((const char **) a); + const char *s2 = *((const char **) b); + + return strcmp(s1, s2); +} + +int +nm_strcmp0_p_with_data(gconstpointer a, gconstpointer b, gpointer user_data) { - const char *s1 = *((const char **) a); - const char *s2 = *((const char **) b); + const char *s1 = *((const char **) a); + const char *s2 = *((const char **) b); - return strcmp (s1, s2); + return nm_strcmp0(s1, s2); } int -nm_strcmp0_p_with_data (gconstpointer a, gconstpointer b, gpointer user_data) +nm_strcmp_ascii_case_with_data(gconstpointer a, gconstpointer b, gpointer user_data) { - const char *s1 = *((const char **) a); - const char *s2 = *((const char **) b); + const char *s1 = a; + const char *s2 = b; - return nm_strcmp0 (s1, s2); + return g_ascii_strcasecmp(s1, s2); } int -nm_cmp_uint32_p_with_data (gconstpointer p_a, gconstpointer p_b, gpointer user_data) +nm_cmp_uint32_p_with_data(gconstpointer p_a, gconstpointer p_b, gpointer user_data) { - const guint32 a = *((const guint32 *) p_a); - const guint32 b = *((const guint32 *) p_b); + const guint32 a = *((const guint32 *) p_a); + const guint32 b = *((const guint32 *) p_b); - if (a < b) - return -1; - if (a > b) - return 1; - return 0; + if (a < b) + return -1; + if (a > b) + return 1; + return 0; } int -nm_cmp_int2ptr_p_with_data (gconstpointer p_a, gconstpointer p_b, gpointer user_data) +nm_cmp_int2ptr_p_with_data(gconstpointer p_a, gconstpointer p_b, gpointer user_data) { - /* p_a and p_b are two pointers to a pointer, where the pointer is - * interpreted as a integer using GPOINTER_TO_INT(). - * - * That is the case of a hash-table that uses GINT_TO_POINTER() to - * convert integers as pointers, and the resulting keys-as-array - * array. */ - const int a = GPOINTER_TO_INT (*((gconstpointer *) p_a)); - const int b = GPOINTER_TO_INT (*((gconstpointer *) p_b)); + /* p_a and p_b are two pointers to a pointer, where the pointer is + * interpreted as a integer using GPOINTER_TO_INT(). + * + * That is the case of a hash-table that uses GINT_TO_POINTER() to + * convert integers as pointers, and the resulting keys-as-array + * array. */ + const int a = GPOINTER_TO_INT(*((gconstpointer *) p_a)); + const int b = GPOINTER_TO_INT(*((gconstpointer *) p_b)); - if (a < b) - return -1; - if (a > b) - return 1; - return 0; + if (a < b) + return -1; + if (a > b) + return 1; + return 0; } /*****************************************************************************/ const char * -nm_utils_dbus_path_get_last_component (const char *dbus_path) +nm_utils_dbus_path_get_last_component(const char *dbus_path) { - if (dbus_path) { - dbus_path = strrchr (dbus_path, '/'); - if (dbus_path) - return dbus_path + 1; - } - return NULL; + if (dbus_path) { + dbus_path = strrchr(dbus_path, '/'); + if (dbus_path) + return dbus_path + 1; + } + return NULL; } static gint64 -_dbus_path_component_as_num (const char *p) -{ - gint64 n; - - /* no odd stuff. No leading zeros, only a non-negative, decimal integer. - * - * Otherwise, there would be multiple ways to encode the same number "10" - * and "010". That is just confusing. A number has no leading zeros, - * if it has, it's not a number (as far as we are concerned here). */ - if (p[0] == '0') { - if (p[1] != '\0') - return -1; - else - return 0; - } - if (!(p[0] >= '1' && p[0] <= '9')) - return -1; - if (!NM_STRCHAR_ALL (&p[1], ch, (ch >= '0' && ch <= '9'))) - return -1; - n = _nm_utils_ascii_str_to_int64 (p, 10, 0, G_MAXINT64, -1); - nm_assert (n == -1 || nm_streq0 (p, nm_sprintf_bufa (100, "%"G_GINT64_FORMAT, n))); - return n; +_dbus_path_component_as_num(const char *p) +{ + gint64 n; + + /* no odd stuff. No leading zeros, only a non-negative, decimal integer. + * + * Otherwise, there would be multiple ways to encode the same number "10" + * and "010". That is just confusing. A number has no leading zeros, + * if it has, it's not a number (as far as we are concerned here). */ + if (p[0] == '0') { + if (p[1] != '\0') + return -1; + else + return 0; + } + if (!(p[0] >= '1' && p[0] <= '9')) + return -1; + if (!NM_STRCHAR_ALL(&p[1], ch, (ch >= '0' && ch <= '9'))) + return -1; + n = _nm_utils_ascii_str_to_int64(p, 10, 0, G_MAXINT64, -1); + nm_assert(n == -1 || nm_streq0(p, nm_sprintf_bufa(100, "%" G_GINT64_FORMAT, n))); + return n; } int -nm_utils_dbus_path_cmp (const char *dbus_path_a, const char *dbus_path_b) -{ - const char *l_a, *l_b; - gsize plen; - gint64 n_a, n_b; - - /* compare function for two D-Bus paths. It behaves like - * strcmp(), except, if both paths have the same prefix, - * and both end in a (positive) number, then the paths - * will be sorted by number. */ - - NM_CMP_SELF (dbus_path_a, dbus_path_b); - - /* if one or both paths have no slash (and no last component) - * compare the full paths directly. */ - if ( !(l_a = nm_utils_dbus_path_get_last_component (dbus_path_a)) - || !(l_b = nm_utils_dbus_path_get_last_component (dbus_path_b))) - goto comp_full; - - /* check if both paths have the same prefix (up to the last-component). */ - plen = l_a - dbus_path_a; - if (plen != (l_b - dbus_path_b)) - goto comp_full; - NM_CMP_RETURN (strncmp (dbus_path_a, dbus_path_b, plen)); - - n_a = _dbus_path_component_as_num (l_a); - n_b = _dbus_path_component_as_num (l_b); - if (n_a == -1 && n_b == -1) - goto comp_l; - - /* both components must be convertiable to a number. If they are not, - * (and only one of them is), then we must always strictly sort numeric parts - * after non-numeric components. If we wouldn't, we wouldn't have - * a total order. - * - * An example of a not total ordering would be: - * "8" < "010" (numeric) - * "0x" < "8" (lexical) - * "0x" > "010" (lexical) - * We avoid this, by forcing that a non-numeric entry "0x" always sorts - * before numeric entries. - * - * Additionally, _dbus_path_component_as_num() would also reject "010" as - * not a valid number. - */ - if (n_a == -1) - return -1; - if (n_b == -1) - return 1; - - NM_CMP_DIRECT (n_a, n_b); - nm_assert (nm_streq (dbus_path_a, dbus_path_b)); - return 0; +nm_utils_dbus_path_cmp(const char *dbus_path_a, const char *dbus_path_b) +{ + const char *l_a, *l_b; + gsize plen; + gint64 n_a, n_b; + + /* compare function for two D-Bus paths. It behaves like + * strcmp(), except, if both paths have the same prefix, + * and both end in a (positive) number, then the paths + * will be sorted by number. */ + + NM_CMP_SELF(dbus_path_a, dbus_path_b); + + /* if one or both paths have no slash (and no last component) + * compare the full paths directly. */ + if (!(l_a = nm_utils_dbus_path_get_last_component(dbus_path_a)) + || !(l_b = nm_utils_dbus_path_get_last_component(dbus_path_b))) + goto comp_full; + + /* check if both paths have the same prefix (up to the last-component). */ + plen = l_a - dbus_path_a; + if (plen != (l_b - dbus_path_b)) + goto comp_full; + NM_CMP_RETURN(strncmp(dbus_path_a, dbus_path_b, plen)); + + n_a = _dbus_path_component_as_num(l_a); + n_b = _dbus_path_component_as_num(l_b); + if (n_a == -1 && n_b == -1) + goto comp_l; + + /* both components must be convertible to a number. If they are not, + * (and only one of them is), then we must always strictly sort numeric parts + * after non-numeric components. If we wouldn't, we wouldn't have + * a total order. + * + * An example of a not total ordering would be: + * "8" < "010" (numeric) + * "0x" < "8" (lexical) + * "0x" > "010" (lexical) + * We avoid this, by forcing that a non-numeric entry "0x" always sorts + * before numeric entries. + * + * Additionally, _dbus_path_component_as_num() would also reject "010" as + * not a valid number. + */ + if (n_a == -1) + return -1; + if (n_b == -1) + return 1; + + NM_CMP_DIRECT(n_a, n_b); + nm_assert(nm_streq(dbus_path_a, dbus_path_b)); + return 0; comp_full: - NM_CMP_DIRECT_STRCMP0 (dbus_path_a, dbus_path_b); - return 0; + NM_CMP_DIRECT_STRCMP0(dbus_path_a, dbus_path_b); + return 0; comp_l: - NM_CMP_DIRECT_STRCMP0 (l_a, l_b); - nm_assert (nm_streq (dbus_path_a, dbus_path_b)); - return 0; + NM_CMP_DIRECT_STRCMP0(l_a, l_b); + nm_assert(nm_streq(dbus_path_a, dbus_path_b)); + return 0; } /*****************************************************************************/ +typedef struct { + union { + guint8 table[256]; + guint64 _dummy_for_alignment; + }; +} CharLookupTable; + static void -_char_lookup_table_set_one (guint8 lookup[static 256], - char ch) +_char_lookup_table_set_one(CharLookupTable *lookup, char ch) { - lookup[(guint8) ch] = 1; + lookup->table[(guint8) ch] = 1; } static void -_char_lookup_table_set_all (guint8 lookup[static 256], - const char *candidates) +_char_lookup_table_set_all(CharLookupTable *lookup, const char *candidates) { - while (candidates[0] != '\0') - _char_lookup_table_set_one (lookup, (candidates++)[0]); + while (candidates[0] != '\0') + _char_lookup_table_set_one(lookup, (candidates++)[0]); } static void -_char_lookup_table_init (guint8 lookup[static 256], - const char *candidates) +_char_lookup_table_init(CharLookupTable *lookup, const char *candidates) { - memset (lookup, 0, 256); - if (candidates) - _char_lookup_table_set_all (lookup, candidates); + *lookup = (CharLookupTable){ + .table = {0}, + }; + if (candidates) + _char_lookup_table_set_all(lookup, candidates); } static gboolean -_char_lookup_has (const guint8 lookup[static 256], - char ch) +_char_lookup_has(const CharLookupTable *lookup, char ch) { - nm_assert (lookup[(guint8) '\0'] == 0); - return lookup[(guint8) ch] != 0; + /* with some optimization levels, the compiler thinks this code + * might access uninitialized @lookup. It is not -- when you look at the + * callers of this function. */ + NM_PRAGMA_WARNING_DISABLE("-Wmaybe-uninitialized") + nm_assert(lookup->table[(guint8) '\0'] == 0); + return lookup->table[(guint8) ch] != 0; + NM_PRAGMA_WARNING_REENABLE } static gboolean -_char_lookup_has_all (const guint8 lookup[static 256], - const char *candidates) +_char_lookup_has_all(const CharLookupTable *lookup, const char *candidates) { - if (candidates) { - while (candidates[0] != '\0') { - if (!_char_lookup_has (lookup, (candidates++)[0])) - return FALSE; - } - } - return TRUE; + if (candidates) { + while (candidates[0] != '\0') { + if (!_char_lookup_has(lookup, (candidates++)[0])) + return FALSE; + } + } + return TRUE; } /** @@ -1635,344 +1604,329 @@ _char_lookup_has_all (const guint8 lookup[static 256], * like "g_strstrip((char *) iter[0])". */ const char ** -nm_utils_strsplit_set_full (const char *str, - const char *delimiters, - NMUtilsStrsplitSetFlags flags) -{ - const char **ptr; - gsize num_tokens; - gsize i_token; - gsize str_len_p1; - const char *c_str; - char *s; - guint8 ch_lookup[256]; - const gboolean f_escaped = NM_FLAGS_HAS (flags, NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED); - const gboolean f_allow_escaping = f_escaped || NM_FLAGS_HAS (flags, NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING); - const gboolean f_preserve_empty = NM_FLAGS_HAS (flags, NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY); - const gboolean f_strstrip = NM_FLAGS_HAS (flags, NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP); - - if (!str) - return NULL; - - if (!delimiters) { - nm_assert_not_reached (); - delimiters = " \t\n"; - } - _char_lookup_table_init (ch_lookup, delimiters); - - nm_assert ( !f_allow_escaping - || !_char_lookup_has (ch_lookup, '\\')); - - if (!f_preserve_empty) { - while (_char_lookup_has (ch_lookup, str[0])) - str++; - } - - if (!str[0]) { - /* We return %NULL here, also with NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY. - * That makes nm_utils_strsplit_set_full() with NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY - * different from g_strsplit_set(), which would in this case return an empty array. - * If you need to handle %NULL, and "" specially, then check the input string first. */ - return NULL; - } - -#define _char_is_escaped(str_start, str_cur) \ - ({ \ - const char *const _str_start = (str_start); \ - const char *const _str_cur = (str_cur); \ - const char *_str_i = (_str_cur); \ - \ - while ( _str_i > _str_start \ - && _str_i[-1] == '\\') \ - _str_i--; \ - (((_str_cur - _str_i) % 2) != 0); \ - }) - - num_tokens = 1; - c_str = str; - while (TRUE) { - - while (G_LIKELY (!_char_lookup_has (ch_lookup, c_str[0]))) { - if (c_str[0] == '\0') - goto done1; - c_str++; - } - - /* we assume escapings are not frequent. After we found - * this delimiter, check whether it was escaped by counting - * the backslashed before. */ - if ( f_allow_escaping - && _char_is_escaped (str, c_str)) { - /* the delimiter is escaped. This was not an accepted delimiter. */ - c_str++; - continue; - } - - c_str++; - - /* if we drop empty tokens, then we now skip over all consecutive delimiters. */ - if (!f_preserve_empty) { - while (_char_lookup_has (ch_lookup, c_str[0])) - c_str++; - if (c_str[0] == '\0') - break; - } - - num_tokens++; - } +nm_utils_strsplit_set_full(const char *str, const char *delimiters, NMUtilsStrsplitSetFlags flags) +{ + const char ** ptr; + gsize num_tokens; + gsize i_token; + gsize str_len_p1; + const char * c_str; + char * s; + CharLookupTable ch_lookup; + const gboolean f_escaped = NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED); + const gboolean f_allow_escaping = + f_escaped || NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING); + const gboolean f_preserve_empty = + NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY); + const gboolean f_strstrip = NM_FLAGS_HAS(flags, NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP); + + if (!str) + return NULL; + + if (!delimiters) { + nm_assert_not_reached(); + delimiters = " \t\n"; + } + _char_lookup_table_init(&ch_lookup, delimiters); + + nm_assert(!f_allow_escaping || !_char_lookup_has(&ch_lookup, '\\')); + + if (!f_preserve_empty) { + while (_char_lookup_has(&ch_lookup, str[0])) + str++; + } + + if (!str[0]) { + /* We return %NULL here, also with NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY. + * That makes nm_utils_strsplit_set_full() with NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY + * different from g_strsplit_set(), which would in this case return an empty array. + * If you need to handle %NULL, and "" specially, then check the input string first. */ + return NULL; + } + +#define _char_is_escaped(str_start, str_cur) \ + ({ \ + const char *const _str_start = (str_start); \ + const char *const _str_cur = (str_cur); \ + const char * _str_i = (_str_cur); \ + \ + while (_str_i > _str_start && _str_i[-1] == '\\') \ + _str_i--; \ + (((_str_cur - _str_i) % 2) != 0); \ + }) + + num_tokens = 1; + c_str = str; + while (TRUE) { + while (G_LIKELY(!_char_lookup_has(&ch_lookup, c_str[0]))) { + if (c_str[0] == '\0') + goto done1; + c_str++; + } + + /* we assume escapings are not frequent. After we found + * this delimiter, check whether it was escaped by counting + * the backslashed before. */ + if (f_allow_escaping && _char_is_escaped(str, c_str)) { + /* the delimiter is escaped. This was not an accepted delimiter. */ + c_str++; + continue; + } + + c_str++; + + /* if we drop empty tokens, then we now skip over all consecutive delimiters. */ + if (!f_preserve_empty) { + while (_char_lookup_has(&ch_lookup, c_str[0])) + c_str++; + if (c_str[0] == '\0') + break; + } + + num_tokens++; + } done1: - nm_assert (c_str[0] == '\0'); + nm_assert(c_str[0] == '\0'); - str_len_p1 = (c_str - str) + 1; + str_len_p1 = (c_str - str) + 1; - nm_assert (str[str_len_p1 - 1] == '\0'); + nm_assert(str[str_len_p1 - 1] == '\0'); - ptr = g_malloc ((sizeof (const char *) * (num_tokens + 1)) + str_len_p1); - s = (char *) &ptr[num_tokens + 1]; - memcpy (s, str, str_len_p1); + ptr = g_malloc((sizeof(const char *) * (num_tokens + 1)) + str_len_p1); + s = (char *) &ptr[num_tokens + 1]; + memcpy(s, str, str_len_p1); - i_token = 0; + i_token = 0; - while (TRUE) { + while (TRUE) { + nm_assert(i_token < num_tokens); + ptr[i_token++] = s; - nm_assert (i_token < num_tokens); - ptr[i_token++] = s; + if (s[0] == '\0') { + nm_assert(f_preserve_empty); + goto done2; + } + nm_assert(f_preserve_empty || !_char_lookup_has(&ch_lookup, s[0])); - if (s[0] == '\0') { - nm_assert (f_preserve_empty); - goto done2; - } - nm_assert ( f_preserve_empty - || !_char_lookup_has (ch_lookup, s[0])); + while (!_char_lookup_has(&ch_lookup, s[0])) { + if (G_UNLIKELY(s[0] == '\\' && f_allow_escaping)) { + s++; + if (s[0] == '\0') + goto done2; + s++; + } else if (s[0] == '\0') + goto done2; + else + s++; + } - while (!_char_lookup_has (ch_lookup, s[0])) { - if (G_UNLIKELY ( s[0] == '\\' - && f_allow_escaping)) { - s++; - if (s[0] == '\0') - goto done2; - s++; - } else if (s[0] == '\0') - goto done2; - else - s++; - } + nm_assert(_char_lookup_has(&ch_lookup, s[0])); + s[0] = '\0'; + s++; - nm_assert (_char_lookup_has (ch_lookup, s[0])); - s[0] = '\0'; - s++; - - if (!f_preserve_empty) { - while (_char_lookup_has (ch_lookup, s[0])) - s++; - if (s[0] == '\0') - goto done2; - } - } + if (!f_preserve_empty) { + while (_char_lookup_has(&ch_lookup, s[0])) + s++; + if (s[0] == '\0') + goto done2; + } + } done2: - nm_assert (i_token == num_tokens); - ptr[i_token] = NULL; - - if (f_strstrip) { - gsize i; - - i_token = 0; - for (i = 0; ptr[i]; i++) { - - s = (char *) nm_str_skip_leading_spaces (ptr[i]); - if (s[0] != '\0') { - char *s_last; - - s_last = &s[strlen (s) - 1]; - while ( s_last > s - && g_ascii_isspace (s_last[0]) - && ( ! f_allow_escaping - || !_char_is_escaped (s, s_last))) - (s_last--)[0] = '\0'; - } - - if ( !f_preserve_empty - && s[0] == '\0') - continue; - - ptr[i_token++] = s; - } - - if (i_token == 0) { - g_free (ptr); - return NULL; - } - ptr[i_token] = NULL; - } - - if (f_escaped) { - gsize i, j; - - /* We no longer need ch_lookup for its original purpose. Modify it, so it - * can detect the delimiters, '\\', and (optionally) whitespaces. */ - _char_lookup_table_set_one (ch_lookup, '\\'); - if (f_strstrip) - _char_lookup_table_set_all (ch_lookup, NM_ASCII_SPACES); - - for (i_token = 0; ptr[i_token]; i_token++) { - s = (char *) ptr[i_token]; - j = 0; - for (i = 0; s[i] != '\0'; ) { - if ( s[i] == '\\' - && _char_lookup_has (ch_lookup, s[i + 1])) - i++; - s[j++] = s[i++]; - } - s[j] = '\0'; - } - } - - nm_assert (ptr && ptr[0]); - return ptr; + nm_assert(i_token == num_tokens); + ptr[i_token] = NULL; + + if (f_strstrip) { + gsize i; + + i_token = 0; + for (i = 0; ptr[i]; i++) { + s = (char *) nm_str_skip_leading_spaces(ptr[i]); + if (s[0] != '\0') { + char *s_last; + + s_last = &s[strlen(s) - 1]; + while (s_last > s && g_ascii_isspace(s_last[0]) + && (!f_allow_escaping || !_char_is_escaped(s, s_last))) + (s_last--)[0] = '\0'; + } + + if (!f_preserve_empty && s[0] == '\0') + continue; + + ptr[i_token++] = s; + } + + if (i_token == 0) { + g_free(ptr); + return NULL; + } + ptr[i_token] = NULL; + } + + if (f_escaped) { + gsize i, j; + + /* We no longer need ch_lookup for its original purpose. Modify it, so it + * can detect the delimiters, '\\', and (optionally) whitespaces. */ + _char_lookup_table_set_one(&ch_lookup, '\\'); + if (f_strstrip) + _char_lookup_table_set_all(&ch_lookup, NM_ASCII_SPACES); + + for (i_token = 0; ptr[i_token]; i_token++) { + s = (char *) ptr[i_token]; + j = 0; + for (i = 0; s[i] != '\0';) { + if (s[i] == '\\' && _char_lookup_has(&ch_lookup, s[i + 1])) + i++; + s[j++] = s[i++]; + } + s[j] = '\0'; + } + } + + nm_assert(ptr && ptr[0]); + return ptr; } /*****************************************************************************/ const char * -nm_utils_escaped_tokens_escape_full (const char *str, - const char *delimiters, - const char *delimiters_as_needed, - NMUtilsEscapedTokensEscapeFlags flags, - char **out_to_free) -{ - guint8 ch_lookup[256]; - guint8 ch_lookup_as_needed[256]; - gboolean has_ch_lookup_as_needed = FALSE; - char *ret; - gsize str_len; - gsize alloc_len; - gsize n_escapes; - gsize i, j; - gboolean escape_leading_space; - gboolean escape_trailing_space; - gboolean escape_backslash_as_needed; - - nm_assert ( !delimiters_as_needed - || ( delimiters_as_needed[0] - && NM_FLAGS_HAS (flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_AS_NEEDED))); - - if (!str || str[0] == '\0') { - *out_to_free = NULL; - return str; - } - - str_len = strlen (str); - - _char_lookup_table_init (ch_lookup, delimiters); - if ( !delimiters - || NM_FLAGS_HAS (flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_SPACES)) { - flags &= ~( NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE - | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE); - _char_lookup_table_set_all (ch_lookup, NM_ASCII_SPACES); - } - - if (NM_FLAGS_HAS (flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_ALWAYS)) { - _char_lookup_table_set_one (ch_lookup, '\\'); - escape_backslash_as_needed = FALSE; - } else if (_char_lookup_has (ch_lookup, '\\')) - escape_backslash_as_needed = FALSE; - else { - escape_backslash_as_needed = NM_FLAGS_HAS (flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_AS_NEEDED); - if (escape_backslash_as_needed) { - if ( NM_FLAGS_ANY (flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE - | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE) - && !_char_lookup_has_all (ch_lookup, NM_ASCII_SPACES)) { - /* ESCAPE_LEADING_SPACE and ESCAPE_TRAILING_SPACE implies that we escape backslash - * before whitespaces. */ - if (!has_ch_lookup_as_needed) { - has_ch_lookup_as_needed = TRUE; - _char_lookup_table_init (ch_lookup_as_needed, NULL); - } - _char_lookup_table_set_all (ch_lookup_as_needed, NM_ASCII_SPACES); - } - if ( delimiters_as_needed - && !_char_lookup_has_all (ch_lookup, delimiters_as_needed)) { - if (!has_ch_lookup_as_needed) { - has_ch_lookup_as_needed = TRUE; - _char_lookup_table_init (ch_lookup_as_needed, NULL); - } - _char_lookup_table_set_all (ch_lookup_as_needed, delimiters_as_needed); - } - } - } - - escape_leading_space = NM_FLAGS_HAS (flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE) - && g_ascii_isspace (str[0]) - && !_char_lookup_has (ch_lookup, str[0]); - if (str_len == 1) - escape_trailing_space = FALSE; - else { - escape_trailing_space = NM_FLAGS_HAS (flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE) - && g_ascii_isspace (str[str_len - 1]) - && !_char_lookup_has (ch_lookup, str[str_len - 1]); - } - - n_escapes = 0; - for (i = 0; str[i] != '\0'; i++) { - if (_char_lookup_has (ch_lookup, str[i])) - n_escapes++; - else if ( str[i] == '\\' - && escape_backslash_as_needed - && ( _char_lookup_has (ch_lookup, str[i + 1]) - || NM_IN_SET (str[i + 1], '\0', '\\') - || ( has_ch_lookup_as_needed - && _char_lookup_has (ch_lookup_as_needed, str[i + 1])))) - n_escapes++; - } - if (escape_leading_space) - n_escapes++; - if (escape_trailing_space) - n_escapes++; - - if (n_escapes == 0u) { - *out_to_free = NULL; - return str; - } - - alloc_len = str_len + n_escapes + 1u; - ret = g_new (char, alloc_len); - - j = 0; - i = 0; - - if (escape_leading_space) { - ret[j++] = '\\'; - ret[j++] = str[i++]; - } - for (; str[i] != '\0'; i++) { - if (_char_lookup_has (ch_lookup, str[i])) - ret[j++] = '\\'; - else if ( str[i] == '\\' - && escape_backslash_as_needed - && ( _char_lookup_has (ch_lookup, str[i + 1]) - || NM_IN_SET (str[i + 1], '\0', '\\') - || ( has_ch_lookup_as_needed - && _char_lookup_has (ch_lookup_as_needed, str[i + 1])))) - ret[j++] = '\\'; - ret[j++] = str[i]; - } - if (escape_trailing_space) { - nm_assert ( !_char_lookup_has (ch_lookup, ret[j - 1]) - && g_ascii_isspace (ret[j - 1])); - ret[j] = ret[j - 1]; - ret[j - 1] = '\\'; - j++; - } - - nm_assert (j == alloc_len - 1); - ret[j] = '\0'; - nm_assert (strlen (ret) == j); - - *out_to_free = ret; - return ret; +nm_utils_escaped_tokens_escape_full(const char * str, + const char * delimiters, + const char * delimiters_as_needed, + NMUtilsEscapedTokensEscapeFlags flags, + char ** out_to_free) +{ + CharLookupTable ch_lookup; + CharLookupTable ch_lookup_as_needed; + gboolean has_ch_lookup_as_needed = FALSE; + char * ret; + gsize str_len; + gsize alloc_len; + gsize n_escapes; + gsize i, j; + gboolean escape_leading_space; + gboolean escape_trailing_space; + gboolean escape_backslash_as_needed; + + nm_assert( + !delimiters_as_needed + || (delimiters_as_needed[0] + && NM_FLAGS_HAS(flags, + NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_AS_NEEDED))); + + if (!str || str[0] == '\0') { + *out_to_free = NULL; + return str; + } + + str_len = strlen(str); + + _char_lookup_table_init(&ch_lookup, delimiters); + if (!delimiters || NM_FLAGS_HAS(flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_SPACES)) { + flags &= ~(NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE + | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE); + _char_lookup_table_set_all(&ch_lookup, NM_ASCII_SPACES); + } + + if (NM_FLAGS_HAS(flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_ALWAYS)) { + _char_lookup_table_set_one(&ch_lookup, '\\'); + escape_backslash_as_needed = FALSE; + } else if (_char_lookup_has(&ch_lookup, '\\')) + escape_backslash_as_needed = FALSE; + else { + escape_backslash_as_needed = + NM_FLAGS_HAS(flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_AS_NEEDED); + if (escape_backslash_as_needed) { + if (NM_FLAGS_ANY(flags, + NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE + | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE) + && !_char_lookup_has_all(&ch_lookup, NM_ASCII_SPACES)) { + /* ESCAPE_LEADING_SPACE and ESCAPE_TRAILING_SPACE implies that we escape backslash + * before whitespaces. */ + if (!has_ch_lookup_as_needed) { + has_ch_lookup_as_needed = TRUE; + _char_lookup_table_init(&ch_lookup_as_needed, NULL); + } + _char_lookup_table_set_all(&ch_lookup_as_needed, NM_ASCII_SPACES); + } + if (delimiters_as_needed && !_char_lookup_has_all(&ch_lookup, delimiters_as_needed)) { + if (!has_ch_lookup_as_needed) { + has_ch_lookup_as_needed = TRUE; + _char_lookup_table_init(&ch_lookup_as_needed, NULL); + } + _char_lookup_table_set_all(&ch_lookup_as_needed, delimiters_as_needed); + } + } + } + + escape_leading_space = + NM_FLAGS_HAS(flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE) + && g_ascii_isspace(str[0]) && !_char_lookup_has(&ch_lookup, str[0]); + if (str_len == 1) + escape_trailing_space = FALSE; + else { + escape_trailing_space = + NM_FLAGS_HAS(flags, NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE) + && g_ascii_isspace(str[str_len - 1]) && !_char_lookup_has(&ch_lookup, str[str_len - 1]); + } + + n_escapes = 0; + for (i = 0; str[i] != '\0'; i++) { + if (_char_lookup_has(&ch_lookup, str[i])) + n_escapes++; + else if (str[i] == '\\' && escape_backslash_as_needed + && (_char_lookup_has(&ch_lookup, str[i + 1]) || NM_IN_SET(str[i + 1], '\0', '\\') + || (has_ch_lookup_as_needed + && _char_lookup_has(&ch_lookup_as_needed, str[i + 1])))) + n_escapes++; + } + if (escape_leading_space) + n_escapes++; + if (escape_trailing_space) + n_escapes++; + + if (n_escapes == 0u) { + *out_to_free = NULL; + return str; + } + + alloc_len = str_len + n_escapes + 1u; + ret = g_new(char, alloc_len); + + j = 0; + i = 0; + + if (escape_leading_space) { + ret[j++] = '\\'; + ret[j++] = str[i++]; + } + for (; str[i] != '\0'; i++) { + if (_char_lookup_has(&ch_lookup, str[i])) + ret[j++] = '\\'; + else if (str[i] == '\\' && escape_backslash_as_needed + && (_char_lookup_has(&ch_lookup, str[i + 1]) || NM_IN_SET(str[i + 1], '\0', '\\') + || (has_ch_lookup_as_needed + && _char_lookup_has(&ch_lookup_as_needed, str[i + 1])))) + ret[j++] = '\\'; + ret[j++] = str[i]; + } + if (escape_trailing_space) { + nm_assert(!_char_lookup_has(&ch_lookup, ret[j - 1]) && g_ascii_isspace(ret[j - 1])); + ret[j] = ret[j - 1]; + ret[j - 1] = '\\'; + j++; + } + + nm_assert(j == alloc_len - 1); + ret[j] = '\0'; + nm_assert(strlen(ret) == j); + + *out_to_free = ret; + return ret; } /** @@ -1998,66 +1952,63 @@ nm_utils_escaped_tokens_escape_full (const char *str, * not be escaped, unless they are at the beginning or the end of key/value. */ void -nm_utils_escaped_tokens_options_split (char *str, - const char **out_key, - const char **out_val) -{ - const char *val = NULL; - gsize i; - gsize j; - gsize last_space_idx; - gboolean last_space_has; - - nm_assert (str); - - i = 0; - while (g_ascii_isspace (str[i])) - i++; - - j = 0; - last_space_idx = 0; - last_space_has = FALSE; - while (str[i] != '\0') { - if (g_ascii_isspace (str[i])) { - if (!last_space_has) { - last_space_has = TRUE; - last_space_idx = j; - } - } else { - if (str[i] == '\\') { - if ( NM_IN_SET (str[i + 1u], '\\', ',', '=') - || g_ascii_isspace (str[i + 1u])) - i++; - } else if (str[i] == '=') { - /* Encounter an unescaped '=' character. When we still parse the key, this - * is the separator we were waiting for. If we are parsing the value, - * we take the character verbatim. */ - if (!val) { - if (last_space_has) { - str[last_space_idx] = '\0'; - j = last_space_idx + 1; - last_space_has = FALSE; - } else - str[j++] = '\0'; - val = &str[j]; - i++; - while (g_ascii_isspace (str[i])) - i++; - continue; - } - } - last_space_has = FALSE; - } - str[j++] = str[i++]; - } - - if (last_space_has) - str[last_space_idx] = '\0'; - else - str[j] = '\0'; - - *out_key = str; - *out_val = val; +nm_utils_escaped_tokens_options_split(char *str, const char **out_key, const char **out_val) +{ + const char *val = NULL; + gsize i; + gsize j; + gsize last_space_idx; + gboolean last_space_has; + + nm_assert(str); + + i = 0; + while (g_ascii_isspace(str[i])) + i++; + + j = 0; + last_space_idx = 0; + last_space_has = FALSE; + while (str[i] != '\0') { + if (g_ascii_isspace(str[i])) { + if (!last_space_has) { + last_space_has = TRUE; + last_space_idx = j; + } + } else { + if (str[i] == '\\') { + if (NM_IN_SET(str[i + 1u], '\\', ',', '=') || g_ascii_isspace(str[i + 1u])) + i++; + } else if (str[i] == '=') { + /* Encounter an unescaped '=' character. When we still parse the key, this + * is the separator we were waiting for. If we are parsing the value, + * we take the character verbatim. */ + if (!val) { + if (last_space_has) { + str[last_space_idx] = '\0'; + j = last_space_idx + 1; + last_space_has = FALSE; + } else + str[j++] = '\0'; + val = &str[j]; + i++; + while (g_ascii_isspace(str[i])) + i++; + continue; + } + } + last_space_has = FALSE; + } + str[j++] = str[i++]; + } + + if (last_space_has) + str[last_space_idx] = '\0'; + else + str[j] = '\0'; + + *out_key = str; + *out_val = val; } /*****************************************************************************/ @@ -2078,80 +2029,80 @@ nm_utils_escaped_tokens_options_split (char *str, * Returns: (transfer full): the split string. */ char ** -nm_utils_strsplit_quoted (const char *str) -{ - gs_unref_ptrarray GPtrArray *arr = NULL; - gs_free char *str_out = NULL; - guint8 ch_lookup[256]; - - nm_assert (str); - - _char_lookup_table_init (ch_lookup, NM_ASCII_WHITESPACES); - - for (;;) { - char quote; - gsize j; - - while (_char_lookup_has (ch_lookup, str[0])) - str++; - - if (str[0] == '\0') - break; - - if (!str_out) - str_out = g_new (char, strlen (str) + 1); - - quote = '\0'; - j = 0; - for (;;) { - if (str[0] == '\\') { - str++; - if (str[0] == '\0') - break; - str_out[j++] = str[0]; - str++; - continue; - } - if (quote) { - if (str[0] == '\0') - break; - if (str[0] == quote) { - quote = '\0'; - str++; - continue; - } - str_out[j++] = str[0]; - str++; - continue; - } - if (str[0] == '\0') - break; - if (NM_IN_SET (str[0], '\'', '"')) { - quote = str[0]; - str++; - continue; - } - if (_char_lookup_has (ch_lookup, str[0])) { - str++; - break; - } - str_out[j++] = str[0]; - str++; - } - - if (!arr) - arr = g_ptr_array_new (); - g_ptr_array_add (arr, g_strndup (str_out, j)); - } - - if (!arr) - return g_new0 (char *, 1); - - g_ptr_array_add (arr, NULL); - - /* We want to return an optimally sized strv array, with no excess - * memory allocated. Hence, clone once more. */ - return nm_memdup (arr->pdata, sizeof (char *) * arr->len); +nm_utils_strsplit_quoted(const char *str) +{ + gs_unref_ptrarray GPtrArray *arr = NULL; + gs_free char * str_out = NULL; + CharLookupTable ch_lookup; + + nm_assert(str); + + _char_lookup_table_init(&ch_lookup, NM_ASCII_WHITESPACES); + + for (;;) { + char quote; + gsize j; + + while (_char_lookup_has(&ch_lookup, str[0])) + str++; + + if (str[0] == '\0') + break; + + if (!str_out) + str_out = g_new(char, strlen(str) + 1); + + quote = '\0'; + j = 0; + for (;;) { + if (str[0] == '\\') { + str++; + if (str[0] == '\0') + break; + str_out[j++] = str[0]; + str++; + continue; + } + if (quote) { + if (str[0] == '\0') + break; + if (str[0] == quote) { + quote = '\0'; + str++; + continue; + } + str_out[j++] = str[0]; + str++; + continue; + } + if (str[0] == '\0') + break; + if (NM_IN_SET(str[0], '\'', '"')) { + quote = str[0]; + str++; + continue; + } + if (_char_lookup_has(&ch_lookup, str[0])) { + str++; + break; + } + str_out[j++] = str[0]; + str++; + } + + if (!arr) + arr = g_ptr_array_new(); + g_ptr_array_add(arr, g_strndup(str_out, j)); + } + + if (!arr) + return g_new0(char *, 1); + + g_ptr_array_add(arr, NULL); + + /* We want to return an optimally sized strv array, with no excess + * memory allocated. Hence, clone once more. */ + return nm_memdup(arr->pdata, sizeof(char *) * arr->len); } /*****************************************************************************/ @@ -2170,140 +2121,154 @@ nm_utils_strsplit_quoted (const char *str) * Returns: index of first occurrence or -1 if @needle is not found in @list. */ gssize -nm_utils_strv_find_first (char **list, gssize len, const char *needle) -{ - gssize i; - - if (len > 0) { - g_return_val_if_fail (list, -1); - - if (!needle) { - /* if we search a list with known length, %NULL is a valid @needle. */ - for (i = 0; i < len; i++) { - if (!list[i]) - return i; - } - } else { - for (i = 0; i < len; i++) { - if (list[i] && !strcmp (needle, list[i])) - return i; - } - } - } else if (len < 0) { - g_return_val_if_fail (needle, -1); - - if (list) { - for (i = 0; list[i]; i++) { - if (strcmp (needle, list[i]) == 0) - return i; - } - } - } - return -1; +nm_utils_strv_find_first(char **list, gssize len, const char *needle) +{ + gssize i; + + if (len > 0) { + g_return_val_if_fail(list, -1); + + if (!needle) { + /* if we search a list with known length, %NULL is a valid @needle. */ + for (i = 0; i < len; i++) { + if (!list[i]) + return i; + } + } else { + for (i = 0; i < len; i++) { + if (list[i] && !strcmp(needle, list[i])) + return i; + } + } + } else if (len < 0) { + g_return_val_if_fail(needle, -1); + + if (list) { + for (i = 0; list[i]; i++) { + if (strcmp(needle, list[i]) == 0) + return i; + } + } + } + return -1; } char ** -_nm_utils_strv_cleanup (char **strv, - gboolean strip_whitespace, - gboolean skip_empty, - gboolean skip_repeated) -{ - guint i, j; - - if (!strv || !*strv) - return strv; - - if (strip_whitespace) { - /* we only modify the strings pointed to by @strv if @strip_whitespace is - * requested. Otherwise, the strings themselves are untouched. */ - for (i = 0; strv[i]; i++) - g_strstrip (strv[i]); - } - if (!skip_empty && !skip_repeated) - return strv; - j = 0; - for (i = 0; strv[i]; i++) { - if ( (skip_empty && !*strv[i]) - || (skip_repeated && nm_utils_strv_find_first (strv, j, strv[i]) >= 0)) - g_free (strv[i]); - else - strv[j++] = strv[i]; - } - strv[j] = NULL; - return strv; +_nm_utils_strv_cleanup(char ** strv, + gboolean strip_whitespace, + gboolean skip_empty, + gboolean skip_repeated) +{ + guint i, j; + + if (!strv || !*strv) + return strv; + + if (strip_whitespace) { + /* we only modify the strings pointed to by @strv if @strip_whitespace is + * requested. Otherwise, the strings themselves are untouched. */ + for (i = 0; strv[i]; i++) + g_strstrip(strv[i]); + } + if (!skip_empty && !skip_repeated) + return strv; + j = 0; + for (i = 0; strv[i]; i++) { + if ((skip_empty && !*strv[i]) + || (skip_repeated && nm_utils_strv_find_first(strv, j, strv[i]) >= 0)) + g_free(strv[i]); + else + strv[j++] = strv[i]; + } + strv[j] = NULL; + return strv; +} + +/*****************************************************************************/ + +GPtrArray * +_nm_g_ptr_array_copy(GPtrArray * array, + GCopyFunc func, + gpointer user_data, + GDestroyNotify element_free_func) +{ + GPtrArray *new_array; + guint i; + + g_return_val_if_fail(array, NULL); + + new_array = g_ptr_array_new_full(array->len, element_free_func); + for (i = 0; i < array->len; i++) { + g_ptr_array_add(new_array, func ? func(array->pdata[i], user_data) : array->pdata[i]); + } + return new_array; } /*****************************************************************************/ int -_nm_utils_ascii_str_to_bool (const char *str, - int default_value) +_nm_utils_ascii_str_to_bool(const char *str, int default_value) { - gs_free char *str_free = NULL; + gs_free char *str_free = NULL; - if (!str) - return default_value; + if (!str) + return default_value; - str = nm_strstrip_avoid_copy_a (300, str, &str_free); - if (str[0] == '\0') - return default_value; + str = nm_strstrip_avoid_copy_a(300, str, &str_free); + if (str[0] == '\0') + return default_value; - if ( !g_ascii_strcasecmp (str, "true") - || !g_ascii_strcasecmp (str, "yes") - || !g_ascii_strcasecmp (str, "on") - || !g_ascii_strcasecmp (str, "1")) - return TRUE; + if (!g_ascii_strcasecmp(str, "true") || !g_ascii_strcasecmp(str, "yes") + || !g_ascii_strcasecmp(str, "on") || !g_ascii_strcasecmp(str, "1")) + return TRUE; - if ( !g_ascii_strcasecmp (str, "false") - || !g_ascii_strcasecmp (str, "no") - || !g_ascii_strcasecmp (str, "off") - || !g_ascii_strcasecmp (str, "0")) - return FALSE; + if (!g_ascii_strcasecmp(str, "false") || !g_ascii_strcasecmp(str, "no") + || !g_ascii_strcasecmp(str, "off") || !g_ascii_strcasecmp(str, "0")) + return FALSE; - return default_value; + return default_value; } /*****************************************************************************/ -NM_CACHED_QUARK_FCN ("nm-utils-error-quark", nm_utils_error_quark) +NM_CACHED_QUARK_FCN("nm-utils-error-quark", nm_utils_error_quark); void -nm_utils_error_set_cancelled (GError **error, - gboolean is_disposing, - const char *instance_name) +nm_utils_error_set_cancelled(GError **error, gboolean is_disposing, const char *instance_name) { - if (is_disposing) { - g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_CANCELLED_DISPOSING, - "Disposing %s instance", - instance_name && *instance_name ? instance_name : "source"); - } else { - g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CANCELLED, - "Request cancelled"); - } + if (is_disposing) { + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_CANCELLED_DISPOSING, + "Disposing %s instance", + instance_name && *instance_name ? instance_name : "source"); + } else { + g_set_error_literal(error, G_IO_ERROR, G_IO_ERROR_CANCELLED, "Request cancelled"); + } } gboolean -nm_utils_error_is_cancelled_or_disposing (GError *error) +nm_utils_error_is_cancelled_or_disposing(GError *error) { - if (error) { - if (error->domain == G_IO_ERROR) - return NM_IN_SET (error->code, G_IO_ERROR_CANCELLED); - if (error->domain == NM_UTILS_ERROR) - return NM_IN_SET (error->code, NM_UTILS_ERROR_CANCELLED_DISPOSING); - } - return FALSE; + if (error) { + if (error->domain == G_IO_ERROR) + return NM_IN_SET(error->code, G_IO_ERROR_CANCELLED); + if (error->domain == NM_UTILS_ERROR) + return NM_IN_SET(error->code, NM_UTILS_ERROR_CANCELLED_DISPOSING); + } + return FALSE; } gboolean -nm_utils_error_is_notfound (GError *error) +nm_utils_error_is_notfound(GError *error) { - if (error) { - if (error->domain == G_IO_ERROR) - return NM_IN_SET (error->code, G_IO_ERROR_NOT_FOUND); - if (error->domain == G_FILE_ERROR) - return NM_IN_SET (error->code, G_FILE_ERROR_NOENT); - } - return FALSE; + if (error) { + if (error->domain == G_IO_ERROR) + return NM_IN_SET(error->code, G_IO_ERROR_NOT_FOUND); + if (error->domain == G_FILE_ERROR) + return NM_IN_SET(error->code, G_FILE_ERROR_NOENT); + } + return FALSE; } /*****************************************************************************/ @@ -2324,220 +2289,233 @@ nm_utils_error_is_notfound (GError *error) * Returns: whether the value was successfully set. */ gboolean -nm_g_object_set_property (GObject *object, - const char *property_name, - const GValue *value, - GError **error) -{ - GParamSpec *pspec; - nm_auto_unset_gvalue GValue tmp_value = G_VALUE_INIT; - GObjectClass *klass; - - g_return_val_if_fail (G_IS_OBJECT (object), FALSE); - g_return_val_if_fail (property_name != NULL, FALSE); - g_return_val_if_fail (G_IS_VALUE (value), FALSE); - g_return_val_if_fail (!error || !*error, FALSE); - - /* g_object_class_find_property() does g_param_spec_get_redirect_target(), - * where we differ from a plain g_object_set_property(). */ - pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (object), property_name); - - if (!pspec) { - g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("object class '%s' has no property named '%s'"), - G_OBJECT_TYPE_NAME (object), - property_name); - return FALSE; - } - if (!(pspec->flags & G_PARAM_WRITABLE)) { - g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("property '%s' of object class '%s' is not writable"), - pspec->name, - G_OBJECT_TYPE_NAME (object)); - return FALSE; - } - if ((pspec->flags & G_PARAM_CONSTRUCT_ONLY)) { - g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("construct property \"%s\" for object '%s' can't be set after construction"), - pspec->name, G_OBJECT_TYPE_NAME (object)); - return FALSE; - } - - klass = g_type_class_peek (pspec->owner_type); - if (klass == NULL) { - g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("'%s::%s' is not a valid property name; '%s' is not a GObject subtype"), - g_type_name (pspec->owner_type), pspec->name, g_type_name (pspec->owner_type)); - return FALSE; - } - - /* provide a copy to work from, convert (if necessary) and validate */ - g_value_init (&tmp_value, pspec->value_type); - if (!g_value_transform (value, &tmp_value)) { - g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("unable to set property '%s' of type '%s' from value of type '%s'"), - pspec->name, - g_type_name (pspec->value_type), - G_VALUE_TYPE_NAME (value)); - return FALSE; - } - if ( g_param_value_validate (pspec, &tmp_value) - && !(pspec->flags & G_PARAM_LAX_VALIDATION)) { - gs_free char *contents = g_strdup_value_contents (value); - - g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("value \"%s\" of type '%s' is invalid or out of range for property '%s' of type '%s'"), - contents, - G_VALUE_TYPE_NAME (value), - pspec->name, - g_type_name (pspec->value_type)); - return FALSE; - } - - g_object_set_property (object, property_name, &tmp_value); - return TRUE; -} - -#define _set_property(object, property_name, gtype, gtype_set, value, error) \ - G_STMT_START { \ - nm_auto_unset_gvalue GValue gvalue = { 0 }; \ - \ - g_value_init (&gvalue, gtype); \ - gtype_set (&gvalue, (value)); \ - return nm_g_object_set_property ((object), (property_name), &gvalue, (error)); \ - } G_STMT_END +nm_g_object_set_property(GObject * object, + const char * property_name, + const GValue *value, + GError ** error) +{ + GParamSpec * pspec; + nm_auto_unset_gvalue GValue tmp_value = G_VALUE_INIT; + GObjectClass * klass; + + g_return_val_if_fail(G_IS_OBJECT(object), FALSE); + g_return_val_if_fail(property_name != NULL, FALSE); + g_return_val_if_fail(G_IS_VALUE(value), FALSE); + g_return_val_if_fail(!error || !*error, FALSE); + + /* g_object_class_find_property() does g_param_spec_get_redirect_target(), + * where we differ from a plain g_object_set_property(). */ + pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object), property_name); + + if (!pspec) { + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("object class '%s' has no property named '%s'"), + G_OBJECT_TYPE_NAME(object), + property_name); + return FALSE; + } + if (!(pspec->flags & G_PARAM_WRITABLE)) { + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("property '%s' of object class '%s' is not writable"), + pspec->name, + G_OBJECT_TYPE_NAME(object)); + return FALSE; + } + if ((pspec->flags & G_PARAM_CONSTRUCT_ONLY)) { + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("construct property \"%s\" for object '%s' can't be set after construction"), + pspec->name, + G_OBJECT_TYPE_NAME(object)); + return FALSE; + } + + klass = g_type_class_peek(pspec->owner_type); + if (klass == NULL) { + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("'%s::%s' is not a valid property name; '%s' is not a GObject subtype"), + g_type_name(pspec->owner_type), + pspec->name, + g_type_name(pspec->owner_type)); + return FALSE; + } + + /* provide a copy to work from, convert (if necessary) and validate */ + g_value_init(&tmp_value, pspec->value_type); + if (!g_value_transform(value, &tmp_value)) { + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("unable to set property '%s' of type '%s' from value of type '%s'"), + pspec->name, + g_type_name(pspec->value_type), + G_VALUE_TYPE_NAME(value)); + return FALSE; + } + if (g_param_value_validate(pspec, &tmp_value) && !(pspec->flags & G_PARAM_LAX_VALIDATION)) { + gs_free char *contents = g_strdup_value_contents(value); + + g_set_error(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("value \"%s\" of type '%s' is invalid or out of range for property '%s' of " + "type '%s'"), + contents, + G_VALUE_TYPE_NAME(value), + pspec->name, + g_type_name(pspec->value_type)); + return FALSE; + } + + g_object_set_property(object, property_name, &tmp_value); + return TRUE; +} + +#define _set_property(object, property_name, gtype, gtype_set, value, error) \ + G_STMT_START \ + { \ + nm_auto_unset_gvalue GValue gvalue = {0}; \ + \ + g_value_init(&gvalue, gtype); \ + gtype_set(&gvalue, (value)); \ + return nm_g_object_set_property((object), (property_name), &gvalue, (error)); \ + } \ + G_STMT_END gboolean -nm_g_object_set_property_string (GObject *object, - const char *property_name, - const char *value, - GError **error) +nm_g_object_set_property_string(GObject * object, + const char *property_name, + const char *value, + GError ** error) { - _set_property (object, property_name, G_TYPE_STRING, g_value_set_string, value, error); + _set_property(object, property_name, G_TYPE_STRING, g_value_set_string, value, error); } gboolean -nm_g_object_set_property_string_static (GObject *object, - const char *property_name, - const char *value, - GError **error) +nm_g_object_set_property_string_static(GObject * object, + const char *property_name, + const char *value, + GError ** error) { - _set_property (object, property_name, G_TYPE_STRING, g_value_set_static_string, value, error); + _set_property(object, property_name, G_TYPE_STRING, g_value_set_static_string, value, error); } gboolean -nm_g_object_set_property_string_take (GObject *object, - const char *property_name, - char *value, - GError **error) +nm_g_object_set_property_string_take(GObject * object, + const char *property_name, + char * value, + GError ** error) { - _set_property (object, property_name, G_TYPE_STRING, g_value_take_string, value, error); + _set_property(object, property_name, G_TYPE_STRING, g_value_take_string, value, error); } gboolean -nm_g_object_set_property_boolean (GObject *object, - const char *property_name, - gboolean value, - GError **error) +nm_g_object_set_property_boolean(GObject * object, + const char *property_name, + gboolean value, + GError ** error) { - _set_property (object, property_name, G_TYPE_BOOLEAN, g_value_set_boolean, !!value, error); + _set_property(object, property_name, G_TYPE_BOOLEAN, g_value_set_boolean, !!value, error); } gboolean -nm_g_object_set_property_char (GObject *object, - const char *property_name, - gint8 value, - GError **error) +nm_g_object_set_property_char(GObject * object, + const char *property_name, + gint8 value, + GError ** error) { - /* glib says about G_TYPE_CHAR: - * - * The type designated by G_TYPE_CHAR is unconditionally an 8-bit signed integer. - * - * This is always a (signed!) char. */ - _set_property (object, property_name, G_TYPE_CHAR, g_value_set_schar, value, error); + /* glib says about G_TYPE_CHAR: + * + * The type designated by G_TYPE_CHAR is unconditionally an 8-bit signed integer. + * + * This is always a (signed!) char. */ + _set_property(object, property_name, G_TYPE_CHAR, g_value_set_schar, value, error); } gboolean -nm_g_object_set_property_uchar (GObject *object, - const char *property_name, - guint8 value, - GError **error) +nm_g_object_set_property_uchar(GObject * object, + const char *property_name, + guint8 value, + GError ** error) { - _set_property (object, property_name, G_TYPE_UCHAR, g_value_set_uchar, value, error); + _set_property(object, property_name, G_TYPE_UCHAR, g_value_set_uchar, value, error); } gboolean -nm_g_object_set_property_int (GObject *object, - const char *property_name, - int value, - GError **error) +nm_g_object_set_property_int(GObject *object, const char *property_name, int value, GError **error) { - _set_property (object, property_name, G_TYPE_INT, g_value_set_int, value, error); + _set_property(object, property_name, G_TYPE_INT, g_value_set_int, value, error); } gboolean -nm_g_object_set_property_int64 (GObject *object, - const char *property_name, - gint64 value, - GError **error) +nm_g_object_set_property_int64(GObject * object, + const char *property_name, + gint64 value, + GError ** error) { - _set_property (object, property_name, G_TYPE_INT64, g_value_set_int64, value, error); + _set_property(object, property_name, G_TYPE_INT64, g_value_set_int64, value, error); } gboolean -nm_g_object_set_property_uint (GObject *object, - const char *property_name, - guint value, - GError **error) +nm_g_object_set_property_uint(GObject * object, + const char *property_name, + guint value, + GError ** error) { - _set_property (object, property_name, G_TYPE_UINT, g_value_set_uint, value, error); + _set_property(object, property_name, G_TYPE_UINT, g_value_set_uint, value, error); } gboolean -nm_g_object_set_property_uint64 (GObject *object, - const char *property_name, - guint64 value, - GError **error) +nm_g_object_set_property_uint64(GObject * object, + const char *property_name, + guint64 value, + GError ** error) { - _set_property (object, property_name, G_TYPE_UINT64, g_value_set_uint64, value, error); + _set_property(object, property_name, G_TYPE_UINT64, g_value_set_uint64, value, error); } gboolean -nm_g_object_set_property_flags (GObject *object, - const char *property_name, - GType gtype, - guint value, - GError **error) +nm_g_object_set_property_flags(GObject * object, + const char *property_name, + GType gtype, + guint value, + GError ** error) { - nm_assert (({ - nm_auto_unref_gtypeclass GTypeClass *gtypeclass = g_type_class_ref (gtype); - G_IS_FLAGS_CLASS (gtypeclass); - })); - _set_property (object, property_name, gtype, g_value_set_flags, value, error); + nm_assert(({ + nm_auto_unref_gtypeclass GTypeClass *gtypeclass = g_type_class_ref(gtype); + G_IS_FLAGS_CLASS(gtypeclass); + })); + _set_property(object, property_name, gtype, g_value_set_flags, value, error); } gboolean -nm_g_object_set_property_enum (GObject *object, - const char *property_name, - GType gtype, - int value, - GError **error) +nm_g_object_set_property_enum(GObject * object, + const char *property_name, + GType gtype, + int value, + GError ** error) { - nm_assert (({ - nm_auto_unref_gtypeclass GTypeClass *gtypeclass = g_type_class_ref (gtype); - G_IS_ENUM_CLASS (gtypeclass); - })); - _set_property (object, property_name, gtype, g_value_set_enum, value, error); + nm_assert(({ + nm_auto_unref_gtypeclass GTypeClass *gtypeclass = g_type_class_ref(gtype); + G_IS_ENUM_CLASS(gtypeclass); + })); + _set_property(object, property_name, gtype, g_value_set_enum, value, error); } GParamSpec * -nm_g_object_class_find_property_from_gtype (GType gtype, - const char *property_name) +nm_g_object_class_find_property_from_gtype(GType gtype, const char *property_name) { - nm_auto_unref_gtypeclass GObjectClass *gclass = NULL; + nm_auto_unref_gtypeclass GObjectClass *gclass = NULL; - gclass = g_type_class_ref (gtype); - return g_object_class_find_property (gclass, property_name); + gclass = g_type_class_ref(gtype); + return g_object_class_find_property(gclass, property_name); } /*****************************************************************************/ @@ -2557,163 +2535,208 @@ nm_g_object_class_find_property_from_gtype (GType gtype, * that added @pname. */ GType -nm_g_type_find_implementing_class_for_property (GType gtype, - const char *pname) +nm_g_type_find_implementing_class_for_property(GType gtype, const char *pname) { - nm_auto_unref_gtypeclass GObjectClass *klass = NULL; - GParamSpec *pspec; + nm_auto_unref_gtypeclass GObjectClass *klass = NULL; + GParamSpec * pspec; - g_return_val_if_fail (pname, G_TYPE_INVALID); + g_return_val_if_fail(pname, G_TYPE_INVALID); - klass = g_type_class_ref (gtype); - g_return_val_if_fail (G_IS_OBJECT_CLASS (klass), G_TYPE_INVALID); + klass = g_type_class_ref(gtype); + g_return_val_if_fail(G_IS_OBJECT_CLASS(klass), G_TYPE_INVALID); - pspec = g_object_class_find_property (klass, pname); - g_return_val_if_fail (pspec, G_TYPE_INVALID); + pspec = g_object_class_find_property(klass, pname); + g_return_val_if_fail(pspec, G_TYPE_INVALID); - gtype = G_TYPE_FROM_CLASS (klass); + gtype = G_TYPE_FROM_CLASS(klass); - while (TRUE) { - nm_auto_unref_gtypeclass GObjectClass *k = NULL; + while (TRUE) { + nm_auto_unref_gtypeclass GObjectClass *k = NULL; - k = g_type_class_ref (g_type_parent (gtype)); + k = g_type_class_ref(g_type_parent(gtype)); - g_return_val_if_fail (G_IS_OBJECT_CLASS (k), G_TYPE_INVALID); + g_return_val_if_fail(G_IS_OBJECT_CLASS(k), G_TYPE_INVALID); - if (g_object_class_find_property (k, pname) != pspec) - return gtype; + if (g_object_class_find_property(k, pname) != pspec) + return gtype; - gtype = G_TYPE_FROM_CLASS (k); - } + gtype = G_TYPE_FROM_CLASS(k); + } } /*****************************************************************************/ static void -_str_buf_append_c_escape_octal (NMStrBuf *strbuf, - char ch) +_str_buf_append_c_escape_octal(NMStrBuf *strbuf, char ch) { - nm_str_buf_append_c4 (strbuf, - '\\', - '0' + ((char) ((((guchar) ch) >> 6) & 07)), - '0' + ((char) ((((guchar) ch) >> 3) & 07)), - '0' + ((char) ((((guchar) ch) ) & 07))); + nm_str_buf_append_c4(strbuf, + '\\', + '0' + ((char) ((((guchar) ch) >> 6) & 07)), + '0' + ((char) ((((guchar) ch) >> 3) & 07)), + '0' + ((char) ((((guchar) ch)) & 07))); } +/** + * nm_utils_buf_utf8safe_unescape: + * @str: (allow-none): the string to unescape. The string itself is a NUL terminated + * ASCII string, that can have C-style backslash escape sequences (which + * are to be unescaped). Non-ASCII characters (e.g. UTF-8) are taken verbatim, so + * it doesn't care that this string is UTF-8. However, usually this is a UTF-8 encoded + * string. + * @flags: flags for unescaping. The following flags are supported. + * %NM_UTILS_STR_UTF8_SAFE_UNESCAPE_STRIP_SPACES performs a g_strstrip() on the input string, + * but preserving escaped spaces. For example, "a\\t " gives "a\t" (that is, the escaped space does + * not get stripped). Likewise, the invalid escape sequence "a\\ " results in "a " (stripping + * the unescaped space, but preserving the escaped one). + * @out_len: (out): the length of the parsed string. + * @to_free: (out): if @str requires unescaping, the function will clone the string. In + * that case, the allocated buffer will be returned here. + * + * See C-style escapes at https://en.wikipedia.org/wiki/Escape_sequences_in_C#Table_of_escape_sequences. + * Note that hex escapes ("\\xhh") and unicode escapes ("\\uhhhh", "\\Uhhhhhhhh") are not supported. + * + * Also, this function is very similar to g_strcompress() but without issuing g_warning() + * assertions and proper handling of "\\000" escape sequences. + * + * Invalid escape sequences (or non-UTF-8 input) are gracefully accepted. For example "\\ " + * is an invalid escape sequence, in this case the backslash is removed and " " gets returned. + * + * The function never leaks secrets in memory. + * + * Returns: the unescaped buffer of length @out_len. If @str is %NULL, this returns %NULL + * and sets @out_len to 0. Otherwise, a non-%NULL binary buffer is returned with + * @out_len bytes. Note that the binary buffer is guaranteed to be NUL terminated. That + * is @result[@out_len] is NUL. + * Note that the result is binary, and may have embedded NUL characters and non-UTF-8. + * If the function can avoid cloning the input string, it will return a pointer inside + * the input @str. For example, if there is no backslash, no cloning is necessary. In that + * case, @to_free will be %NULL. Otherwise, @to_free is set to a newly allocated buffer + * containing the unescaped string and returned. + */ gconstpointer -nm_utils_buf_utf8safe_unescape (const char *str, NMUtilsStrUtf8SafeFlags flags, gsize *out_len, gpointer *to_free) -{ - gboolean strip_spaces = NM_FLAGS_HAS (flags, NM_UTILS_STR_UTF8_SAFE_UNESCAPE_STRIP_SPACES); - NMStrBuf strbuf; - const char *s; - gsize len; - - g_return_val_if_fail (to_free, NULL); - g_return_val_if_fail (out_len, NULL); - - if (!str) { - *out_len = 0; - *to_free = NULL; - return NULL; - } - - if (strip_spaces) - str = nm_str_skip_leading_spaces (str); - - len = strlen (str); - - s = memchr (str, '\\', len); - if (!s) { - if ( strip_spaces - && len > 0 - && g_ascii_isspace (str[len - 1])) { - len--; - while ( len > 0 - && g_ascii_isspace (str[len - 1])) - len--; - *out_len = len; - return (*to_free = g_strndup (str, len)); - } - *out_len = len; - *to_free = NULL; - return str; - } - - nm_str_buf_init (&strbuf, len + 1u, FALSE); - - nm_str_buf_append_len (&strbuf, str, s - str); - str = s; - - for (;;) { - char ch; - guint v; - - nm_assert (str[0] == '\\'); - - ch = (++str)[0]; - - if (ch == '\0') { - /* error. Trailing '\\' */ - break; - } - - if (ch >= '0' && ch <= '9') { - v = ch - '0'; - ch = (++str)[0]; - if (ch >= '0' && ch <= '7') { - v = v * 8 + (ch - '0'); - ch = (++str)[0]; - if (ch >= '0' && ch <= '7') { - /* technically, escape sequences larger than \3FF are out of range - * and invalid. We don't check for that, and do the same as - * g_strcompress(): silently clip the value with & 0xFF. */ - v = v * 8 + (ch - '0'); - ++str; - } - } - ch = v; - } else { - switch (ch) { - case 'b': ch = '\b'; break; - case 'f': ch = '\f'; break; - case 'n': ch = '\n'; break; - case 'r': ch = '\r'; break; - case 't': ch = '\t'; break; - case 'v': ch = '\v'; break; - default: - /* Here we handle "\\\\", but all other unexpected escape sequences are really a bug. - * Take them literally, after removing the escape character */ - break; - } - str++; - } - - nm_str_buf_append_c (&strbuf, ch); - - s = strchr (str, '\\'); - if (!s) { - gsize l = strlen (str); - - if (strip_spaces) { - while ( l > 0 - && g_ascii_isspace (str[l - 1])) - l--; - } - nm_str_buf_append_len (&strbuf, str, l); - break; - } - - nm_str_buf_append_len (&strbuf, str, s - str); - str = s; - } - - /* assert that no reallocation was necessary. For one, unescaping should - * never result in a longer string than the input. Also, when unescaping - * secrets, we want to ensure that we don't leak secrets in memory. */ - nm_assert (strbuf.allocated == len + 1u); - - return (*to_free = nm_str_buf_finalize (&strbuf, - out_len)); +nm_utils_buf_utf8safe_unescape(const char * str, + NMUtilsStrUtf8SafeFlags flags, + gsize * out_len, + gpointer * to_free) +{ + gboolean strip_spaces = NM_FLAGS_HAS(flags, NM_UTILS_STR_UTF8_SAFE_UNESCAPE_STRIP_SPACES); + NMStrBuf strbuf; + const char *s; + gsize len; + + g_return_val_if_fail(to_free, NULL); + g_return_val_if_fail(out_len, NULL); + + if (!str) { + *out_len = 0; + *to_free = NULL; + return NULL; + } + + if (strip_spaces) + str = nm_str_skip_leading_spaces(str); + + len = strlen(str); + + s = memchr(str, '\\', len); + if (!s) { + if (strip_spaces && len > 0 && g_ascii_isspace(str[len - 1])) { + len--; + while (len > 0 && g_ascii_isspace(str[len - 1])) + len--; + *out_len = len; + return (*to_free = g_strndup(str, len)); + } + *out_len = len; + *to_free = NULL; + return str; + } + + nm_str_buf_init(&strbuf, len + 1u, FALSE); + + nm_str_buf_append_len(&strbuf, str, s - str); + str = s; + + for (;;) { + char ch; + guint v; + + nm_assert(str[0] == '\\'); + + ch = (++str)[0]; + + if (ch == '\0') { + /* error. Trailing '\\' */ + break; + } + + if (ch >= '0' && ch <= '9') { + v = ch - '0'; + ch = (++str)[0]; + if (ch >= '0' && ch <= '7') { + v = v * 8 + (ch - '0'); + ch = (++str)[0]; + if (ch >= '0' && ch <= '7') { + /* technically, escape sequences larger than \3FF are out of range + * and invalid. We don't check for that, and do the same as + * g_strcompress(): silently clip the value with & 0xFF. */ + v = v * 8 + (ch - '0'); + ++str; + } + } + ch = v; + } else { + switch (ch) { + case 'b': + ch = '\b'; + break; + case 'f': + ch = '\f'; + break; + case 'n': + ch = '\n'; + break; + case 'r': + ch = '\r'; + break; + case 't': + ch = '\t'; + break; + case 'v': + ch = '\v'; + break; + default: + /* Here we handle "\\\\", but all other unexpected escape sequences are really a bug. + * Take them literally, after removing the escape character */ + break; + } + str++; + } + + nm_str_buf_append_c(&strbuf, ch); + + s = strchr(str, '\\'); + if (!s) { + gsize l = strlen(str); + + if (strip_spaces) { + while (l > 0 && g_ascii_isspace(str[l - 1])) + l--; + } + nm_str_buf_append_len(&strbuf, str, l); + break; + } + + nm_str_buf_append_len(&strbuf, str, s - str); + str = s; + } + + /* assert that no reallocation was necessary. For one, unescaping should + * never result in a longer string than the input. Also, when unescaping + * secrets, we want to ensure that we don't leak secrets in memory. */ + nm_assert(strbuf.allocated == len + 1u); + + return (*to_free = nm_str_buf_finalize(&strbuf, out_len)); } /** @@ -2748,126 +2771,125 @@ nm_utils_buf_utf8safe_unescape (const char *str, NMUtilsStrUtf8SafeFlags flags, * with g_free. The escaping can be reverted by g_strcompress(). **/ const char * -nm_utils_buf_utf8safe_escape (gconstpointer buf, gssize buflen, NMUtilsStrUtf8SafeFlags flags, char **to_free) -{ - const char *const str = buf; - const char *p = NULL; - const char *s; - gboolean nul_terminated = FALSE; - NMStrBuf strbuf; - - g_return_val_if_fail (to_free, NULL); - - *to_free = NULL; - - if (buflen == 0) - return NULL; - - if (buflen < 0) { - if (!str) - return NULL; - buflen = strlen (str); - if (buflen == 0) - return str; - nul_terminated = TRUE; - } - - if ( g_utf8_validate (str, buflen, &p) - && nul_terminated) { - /* note that g_utf8_validate() does not allow NUL character inside @str. Good. - * We can treat @str like a NUL terminated string. */ - if (!NM_STRCHAR_ANY (str, ch, - ( ch == '\\' \ - || ( NM_FLAGS_HAS (flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_CTRL) \ - && ch < ' ') \ - || ( NM_FLAGS_HAS (flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_NON_ASCII) \ - && ((guchar) ch) >= 127)))) - return str; - } - - nm_str_buf_init (&strbuf, - buflen + 5, - NM_FLAGS_HAS (flags, NM_UTILS_STR_UTF8_SAFE_FLAG_SECRET)); - - s = str; - do { - buflen -= p - s; - nm_assert (buflen >= 0); - - for (; s < p; s++) { - char ch = s[0]; - - nm_assert (ch); - if (ch == '\\') - nm_str_buf_append_c2 (&strbuf, '\\', '\\'); - else if ( ( NM_FLAGS_HAS (flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_CTRL) \ - && ch < ' ') \ - || ( NM_FLAGS_HAS (flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_NON_ASCII) \ - && ((guchar) ch) >= 127)) - _str_buf_append_c_escape_octal (&strbuf, ch); - else - nm_str_buf_append_c (&strbuf, ch); - } - - if (buflen <= 0) - break; - - _str_buf_append_c_escape_octal (&strbuf, p[0]); - - buflen--; - if (buflen == 0) - break; - - s = &p[1]; - (void) g_utf8_validate (s, buflen, &p); - } while (TRUE); - - return (*to_free = nm_str_buf_finalize (&strbuf, NULL)); +nm_utils_buf_utf8safe_escape(gconstpointer buf, + gssize buflen, + NMUtilsStrUtf8SafeFlags flags, + char ** to_free) +{ + const char *const str = buf; + const char * p = NULL; + const char * s; + gboolean nul_terminated = FALSE; + NMStrBuf strbuf; + + g_return_val_if_fail(to_free, NULL); + + *to_free = NULL; + + if (buflen == 0) + return NULL; + + if (buflen < 0) { + if (!str) + return NULL; + buflen = strlen(str); + if (buflen == 0) + return str; + nul_terminated = TRUE; + } + + if (g_utf8_validate(str, buflen, &p) && nul_terminated) { + /* note that g_utf8_validate() does not allow NUL character inside @str. Good. + * We can treat @str like a NUL terminated string. */ + if (!NM_STRCHAR_ANY( + str, + ch, + (ch == '\\' + || (NM_FLAGS_HAS(flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_CTRL) && ch < ' ') + || (NM_FLAGS_HAS(flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_NON_ASCII) + && ((guchar) ch) >= 127)))) + return str; + } + + nm_str_buf_init(&strbuf, buflen + 5, NM_FLAGS_HAS(flags, NM_UTILS_STR_UTF8_SAFE_FLAG_SECRET)); + + s = str; + do { + buflen -= p - s; + nm_assert(buflen >= 0); + + for (; s < p; s++) { + char ch = s[0]; + + nm_assert(ch); + if (ch == '\\') + nm_str_buf_append_c2(&strbuf, '\\', '\\'); + else if ((NM_FLAGS_HAS(flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_CTRL) && ch < ' ') + || (NM_FLAGS_HAS(flags, NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_NON_ASCII) + && ((guchar) ch) >= 127)) + _str_buf_append_c_escape_octal(&strbuf, ch); + else + nm_str_buf_append_c(&strbuf, ch); + } + + if (buflen <= 0) + break; + + _str_buf_append_c_escape_octal(&strbuf, p[0]); + + buflen--; + if (buflen == 0) + break; + + s = &p[1]; + (void) g_utf8_validate(s, buflen, &p); + } while (TRUE); + + return (*to_free = nm_str_buf_finalize(&strbuf, NULL)); } const char * -nm_utils_buf_utf8safe_escape_bytes (GBytes *bytes, NMUtilsStrUtf8SafeFlags flags, char **to_free) +nm_utils_buf_utf8safe_escape_bytes(GBytes *bytes, NMUtilsStrUtf8SafeFlags flags, char **to_free) { - gconstpointer p; - gsize l; + gconstpointer p; + gsize l; - if (bytes) - p = g_bytes_get_data (bytes, &l); - else { - p = NULL; - l = 0; - } + if (bytes) + p = g_bytes_get_data(bytes, &l); + else { + p = NULL; + l = 0; + } - return nm_utils_buf_utf8safe_escape (p, l, flags, to_free); + return nm_utils_buf_utf8safe_escape(p, l, flags, to_free); } char * -nm_utils_buf_utf8safe_escape_cp (gconstpointer buf, gssize buflen, NMUtilsStrUtf8SafeFlags flags) +nm_utils_buf_utf8safe_escape_cp(gconstpointer buf, gssize buflen, NMUtilsStrUtf8SafeFlags flags) { - const char *s_const; - char *s; + const char *s_const; + char * s; - s_const = nm_utils_buf_utf8safe_escape (buf, buflen, flags, &s); - nm_assert (!s || s == s_const); - return s ?: g_strdup (s_const); + s_const = nm_utils_buf_utf8safe_escape(buf, buflen, flags, &s); + nm_assert(!s || s == s_const); + return s ?: g_strdup(s_const); } /*****************************************************************************/ const char * -nm_utils_str_utf8safe_unescape (const char *str, NMUtilsStrUtf8SafeFlags flags, char **to_free) +nm_utils_str_utf8safe_unescape(const char *str, NMUtilsStrUtf8SafeFlags flags, char **to_free) { - const char *res; - gsize len; + const char *res; + gsize len; - g_return_val_if_fail (to_free, NULL); + g_return_val_if_fail(to_free, NULL); - res = nm_utils_buf_utf8safe_unescape (str, flags, &len, (gpointer *) to_free); + res = nm_utils_buf_utf8safe_unescape(str, flags, &len, (gpointer *) to_free); - nm_assert ( (!res && len == 0) - || (strlen (res) <= len)); + nm_assert((!res && len == 0) || (strlen(res) <= len)); - return res; + return res; } /** @@ -2898,9 +2920,9 @@ nm_utils_str_utf8safe_unescape (const char *str, NMUtilsStrUtf8SafeFlags flags, * with g_free. The escaping can be reverted by g_strcompress(). **/ const char * -nm_utils_str_utf8safe_escape (const char *str, NMUtilsStrUtf8SafeFlags flags, char **to_free) +nm_utils_str_utf8safe_escape(const char *str, NMUtilsStrUtf8SafeFlags flags, char **to_free) { - return nm_utils_buf_utf8safe_escape (str, -1, flags, to_free); + return nm_utils_buf_utf8safe_escape(str, -1, flags, to_free); } /** @@ -2916,34 +2938,34 @@ nm_utils_str_utf8safe_escape (const char *str, NMUtilsStrUtf8SafeFlags flags, ch * The escaping can be reverted by g_strcompress(). **/ char * -nm_utils_str_utf8safe_escape_cp (const char *str, NMUtilsStrUtf8SafeFlags flags) +nm_utils_str_utf8safe_escape_cp(const char *str, NMUtilsStrUtf8SafeFlags flags) { - char *s; + char *s; - nm_utils_str_utf8safe_escape (str, flags, &s); - return s ?: g_strdup (str); + nm_utils_str_utf8safe_escape(str, flags, &s); + return s ?: g_strdup(str); } char * -nm_utils_str_utf8safe_unescape_cp (const char *str, NMUtilsStrUtf8SafeFlags flags) +nm_utils_str_utf8safe_unescape_cp(const char *str, NMUtilsStrUtf8SafeFlags flags) { - char *s; + char *s; - str = nm_utils_str_utf8safe_unescape (str, flags, &s); - return s ?: g_strdup (str); + str = nm_utils_str_utf8safe_unescape(str, flags, &s); + return s ?: g_strdup(str); } char * -nm_utils_str_utf8safe_escape_take (char *str, NMUtilsStrUtf8SafeFlags flags) +nm_utils_str_utf8safe_escape_take(char *str, NMUtilsStrUtf8SafeFlags flags) { - char *str_to_free; + char *str_to_free; - nm_utils_str_utf8safe_escape (str, flags, &str_to_free); - if (str_to_free) { - g_free (str); - return str_to_free; - } - return str; + nm_utils_str_utf8safe_escape(str, flags, &str_to_free); + if (str_to_free) { + g_free(str); + return str_to_free; + } + return str; } /*****************************************************************************/ @@ -2951,358 +2973,569 @@ nm_utils_str_utf8safe_escape_take (char *str, NMUtilsStrUtf8SafeFlags flags) /* taken from systemd's fd_wait_for_event(). Note that the timeout * is here in nano-seconds, not micro-seconds. */ int -nm_utils_fd_wait_for_event (int fd, int event, gint64 timeout_nsec) -{ - struct pollfd pollfd = { - .fd = fd, - .events = event, - }; - struct timespec ts, *pts; - int r; - - if (timeout_nsec < 0) - pts = NULL; - else { - ts.tv_sec = (time_t) (timeout_nsec / NM_UTILS_NSEC_PER_SEC); - ts.tv_nsec = (long int) (timeout_nsec % NM_UTILS_NSEC_PER_SEC); - pts = &ts; - } - - r = ppoll (&pollfd, 1, pts, NULL); - if (r < 0) - return -NM_ERRNO_NATIVE (errno); - if (r == 0) - return 0; - return pollfd.revents; +nm_utils_fd_wait_for_event(int fd, int event, gint64 timeout_nsec) +{ + struct pollfd pollfd = { + .fd = fd, + .events = event, + }; + struct timespec ts, *pts; + int r; + + if (timeout_nsec < 0) + pts = NULL; + else { + ts.tv_sec = (time_t)(timeout_nsec / NM_UTILS_NSEC_PER_SEC); + ts.tv_nsec = (long int) (timeout_nsec % NM_UTILS_NSEC_PER_SEC); + pts = &ts; + } + + r = ppoll(&pollfd, 1, pts, NULL); + if (r < 0) + return -NM_ERRNO_NATIVE(errno); + if (r == 0) + return 0; + return pollfd.revents; } /* taken from systemd's loop_read() */ ssize_t -nm_utils_fd_read_loop (int fd, void *buf, size_t nbytes, bool do_poll) +nm_utils_fd_read_loop(int fd, void *buf, size_t nbytes, bool do_poll) { - uint8_t *p = buf; - ssize_t n = 0; + uint8_t *p = buf; + ssize_t n = 0; - g_return_val_if_fail (fd >= 0, -EINVAL); - g_return_val_if_fail (buf, -EINVAL); + g_return_val_if_fail(fd >= 0, -EINVAL); + g_return_val_if_fail(buf, -EINVAL); - /* If called with nbytes == 0, let's call read() at least - * once, to validate the operation */ + /* If called with nbytes == 0, let's call read() at least + * once, to validate the operation */ - if (nbytes > (size_t) SSIZE_MAX) - return -EINVAL; + if (nbytes > (size_t) SSIZE_MAX) + return -EINVAL; - do { - ssize_t k; + do { + ssize_t k; - k = read (fd, p, nbytes); - if (k < 0) { - int errsv = errno; + k = read(fd, p, nbytes); + if (k < 0) { + int errsv = errno; - if (errsv == EINTR) - continue; + if (errsv == EINTR) + continue; - if (errsv == EAGAIN && do_poll) { + if (errsv == EAGAIN && do_poll) { + /* We knowingly ignore any return value here, + * and expect that any error/EOF is reported + * via read() */ - /* We knowingly ignore any return value here, - * and expect that any error/EOF is reported - * via read() */ + (void) nm_utils_fd_wait_for_event(fd, POLLIN, -1); + continue; + } - (void) nm_utils_fd_wait_for_event (fd, POLLIN, -1); - continue; - } + return n > 0 ? n : -NM_ERRNO_NATIVE(errsv); + } - return n > 0 ? n : -NM_ERRNO_NATIVE (errsv); - } + if (k == 0) + return n; - if (k == 0) - return n; + g_assert((size_t) k <= nbytes); - g_assert ((size_t) k <= nbytes); + p += k; + nbytes -= k; + n += k; + } while (nbytes > 0); - p += k; - nbytes -= k; - n += k; - } while (nbytes > 0); - - return n; + return n; } /* taken from systemd's loop_read_exact() */ int -nm_utils_fd_read_loop_exact (int fd, void *buf, size_t nbytes, bool do_poll) +nm_utils_fd_read_loop_exact(int fd, void *buf, size_t nbytes, bool do_poll) { - ssize_t n; + ssize_t n; - n = nm_utils_fd_read_loop (fd, buf, nbytes, do_poll); - if (n < 0) - return (int) n; - if ((size_t) n != nbytes) - return -EIO; + n = nm_utils_fd_read_loop(fd, buf, nbytes, do_poll); + if (n < 0) + return (int) n; + if ((size_t) n != nbytes) + return -EIO; - return 0; + return 0; } /*****************************************************************************/ +G_STATIC_ASSERT(G_STRUCT_OFFSET(NMUtilsNamedValue, name) == 0); + NMUtilsNamedValue * -nm_utils_named_values_from_str_dict_with_sort (GHashTable *hash, - guint *out_len, - GCompareDataFunc compare_func, - gpointer user_data) -{ - GHashTableIter iter; - NMUtilsNamedValue *values; - guint i, len; - - if ( !hash - || !(len = g_hash_table_size (hash))) { - NM_SET_OUT (out_len, 0); - return NULL; - } - - i = 0; - values = g_new (NMUtilsNamedValue, len + 1); - g_hash_table_iter_init (&iter, hash); - while (g_hash_table_iter_next (&iter, - (gpointer *) &values[i].name, - (gpointer *) &values[i].value_ptr)) - i++; - nm_assert (i == len); - values[i].name = NULL; - values[i].value_ptr = NULL; - - if (compare_func) - nm_utils_named_value_list_sort (values, len, compare_func, user_data); - - NM_SET_OUT (out_len, len); - return values; +nm_utils_named_values_from_strdict_full(GHashTable * hash, + guint * out_len, + GCompareDataFunc compare_func, + gpointer user_data, + NMUtilsNamedValue * provided_buffer, + guint provided_buffer_len, + NMUtilsNamedValue **out_allocated_buffer) +{ + GHashTableIter iter; + NMUtilsNamedValue *values; + guint i, len; + + nm_assert(provided_buffer_len == 0 || provided_buffer); + nm_assert(!out_allocated_buffer || !*out_allocated_buffer); + + if (!hash || !(len = g_hash_table_size(hash))) { + NM_SET_OUT(out_len, 0); + return NULL; + } + + if (provided_buffer_len >= len + 1) { + /* the buffer provided by the caller is large enough. Use it. */ + values = provided_buffer; + } else { + /* allocate a new buffer. */ + values = g_new(NMUtilsNamedValue, len + 1); + NM_SET_OUT(out_allocated_buffer, values); + } + + i = 0; + g_hash_table_iter_init(&iter, hash); + while (g_hash_table_iter_next(&iter, (gpointer *) &values[i].name, &values[i].value_ptr)) + i++; + nm_assert(i == len); + values[i].name = NULL; + values[i].value_ptr = NULL; + + if (compare_func) + nm_utils_named_value_list_sort(values, len, compare_func, user_data); + + NM_SET_OUT(out_len, len); + return values; } gssize -nm_utils_named_value_list_find (const NMUtilsNamedValue *arr, - gsize len, - const char *name, - gboolean sorted) +nm_utils_named_value_list_find(const NMUtilsNamedValue *arr, + gsize len, + const char * name, + gboolean sorted) { - gsize i; + gsize i; - nm_assert (name); + nm_assert(name); #if NM_MORE_ASSERTS > 5 - { - for (i = 0; i < len; i++) { - const NMUtilsNamedValue *v = &arr[i]; - - nm_assert (v->name); - if ( sorted - && i > 0) - nm_assert (strcmp (arr[i - 1].name, v->name) < 0); - } - } - - nm_assert ( !sorted - || nm_utils_named_value_list_is_sorted (arr, len, FALSE, NULL, NULL)); + { + for (i = 0; i < len; i++) { + const NMUtilsNamedValue *v = &arr[i]; + + nm_assert(v->name); + if (sorted && i > 0) + nm_assert(strcmp(arr[i - 1].name, v->name) < 0); + } + } + + nm_assert(!sorted || nm_utils_named_value_list_is_sorted(arr, len, FALSE, NULL, NULL)); #endif - if (sorted) { - return nm_utils_array_find_binary_search (arr, - sizeof (NMUtilsNamedValue), - len, - &name, - nm_strcmp_p_with_data, - NULL); - } - for (i = 0; i < len; i++) { - if (nm_streq (arr[i].name, name)) - return i; - } - return ~((gssize) len); + if (sorted) { + return nm_utils_array_find_binary_search(arr, + sizeof(NMUtilsNamedValue), + len, + &name, + nm_strcmp_p_with_data, + NULL); + } + for (i = 0; i < len; i++) { + if (nm_streq(arr[i].name, name)) + return i; + } + return ~((gssize) len); } gboolean -nm_utils_named_value_list_is_sorted (const NMUtilsNamedValue *arr, - gsize len, - gboolean accept_duplicates, - GCompareDataFunc compare_func, - gpointer user_data) +nm_utils_named_value_list_is_sorted(const NMUtilsNamedValue *arr, + gsize len, + gboolean accept_duplicates, + GCompareDataFunc compare_func, + gpointer user_data) { - gsize i; - int c_limit; + gsize i; + int c_limit; - if (len == 0) - return TRUE; + if (len == 0) + return TRUE; - g_return_val_if_fail (arr, FALSE); + g_return_val_if_fail(arr, FALSE); - if (!compare_func) - compare_func = nm_strcmp_p_with_data; + if (!compare_func) + compare_func = nm_strcmp_p_with_data; - c_limit = accept_duplicates ? 0 : -1; + c_limit = accept_duplicates ? 0 : -1; - for (i = 1; i < len; i++) { - int c; + for (i = 1; i < len; i++) { + int c; - c = compare_func (&arr[i - 1], &arr[i], user_data); - if (c > c_limit) - return FALSE; - } - return TRUE; + c = compare_func(&arr[i - 1], &arr[i], user_data); + if (c > c_limit) + return FALSE; + } + return TRUE; } void -nm_utils_named_value_list_sort (NMUtilsNamedValue *arr, - gsize len, - GCompareDataFunc compare_func, - gpointer user_data) +nm_utils_named_value_list_sort(NMUtilsNamedValue *arr, + gsize len, + GCompareDataFunc compare_func, + gpointer user_data) { - if (len == 0) - return; + if (len == 0) + return; - g_return_if_fail (arr); + g_return_if_fail(arr); - if (len == 1) - return; + if (len == 1) + return; - g_qsort_with_data (arr, - len, - sizeof (NMUtilsNamedValue), - compare_func ?: nm_strcmp_p_with_data, - user_data); + g_qsort_with_data(arr, + len, + sizeof(NMUtilsNamedValue), + compare_func ?: nm_strcmp_p_with_data, + user_data); } /*****************************************************************************/ gpointer * -nm_utils_hash_keys_to_array (GHashTable *hash, - GCompareDataFunc compare_func, - gpointer user_data, - guint *out_len) -{ - guint len; - gpointer *keys; - - /* by convention, we never return an empty array. In that - * case, always %NULL. */ - if ( !hash - || g_hash_table_size (hash) == 0) { - NM_SET_OUT (out_len, 0); - return NULL; - } - - keys = g_hash_table_get_keys_as_array (hash, &len); - if ( len > 1 - && compare_func) { - g_qsort_with_data (keys, - len, - sizeof (gpointer), - compare_func, - user_data); - } - NM_SET_OUT (out_len, len); - return keys; +nm_utils_hash_keys_to_array(GHashTable * hash, + GCompareDataFunc compare_func, + gpointer user_data, + guint * out_len) +{ + guint len; + gpointer *keys; + + /* by convention, we never return an empty array. In that + * case, always %NULL. */ + if (!hash || g_hash_table_size(hash) == 0) { + NM_SET_OUT(out_len, 0); + return NULL; + } + + keys = g_hash_table_get_keys_as_array(hash, &len); + if (len > 1 && compare_func) { + g_qsort_with_data(keys, len, sizeof(gpointer), compare_func, user_data); + } + NM_SET_OUT(out_len, len); + return keys; } gpointer * -nm_utils_hash_values_to_array (GHashTable *hash, - GCompareDataFunc compare_func, - gpointer user_data, - guint *out_len) -{ - GHashTableIter iter; - gpointer value; - gpointer *arr; - guint i, len; - - if ( !hash - || (len = g_hash_table_size (hash)) == 0u) { - NM_SET_OUT (out_len, 0); - return NULL; - } - - arr = g_new (gpointer, ((gsize) len) + 1); - i = 0; - g_hash_table_iter_init (&iter, hash); - while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &value)) - arr[i++] = value; - - nm_assert (i == len); - arr[len] = NULL; - - if ( len > 1 - && compare_func) { - g_qsort_with_data (arr, - len, - sizeof (gpointer), - compare_func, - user_data); - } - - NM_SET_OUT (out_len, len); - return arr; +nm_utils_hash_values_to_array(GHashTable * hash, + GCompareDataFunc compare_func, + gpointer user_data, + guint * out_len) +{ + GHashTableIter iter; + gpointer value; + gpointer * arr; + guint i, len; + + if (!hash || (len = g_hash_table_size(hash)) == 0u) { + NM_SET_OUT(out_len, 0); + return NULL; + } + + arr = g_new(gpointer, ((gsize) len) + 1); + i = 0; + g_hash_table_iter_init(&iter, hash); + while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &value)) + arr[i++] = value; + + nm_assert(i == len); + arr[len] = NULL; + + if (len > 1 && compare_func) { + g_qsort_with_data(arr, len, sizeof(gpointer), compare_func, user_data); + } + + NM_SET_OUT(out_len, len); + return arr; +} + +static gboolean +_utils_hashtable_equal(GHashTable * hash_a, + GHashTable * hash_b, + GCompareDataFunc cmp_values, + gpointer user_data) +{ + GHashTableIter h; + gpointer a_key; + gpointer a_val; + gpointer b_val; + + nm_assert(hash_a); + nm_assert(hash_b); + nm_assert(hash_a != hash_b); + nm_assert(g_hash_table_size(hash_a) == g_hash_table_size(hash_b)); + + /* We rely on both hashes to have the same hash/equal function. Otherwise, we would have to iterate + * both hashes and check whether all keys/values are present in the respective other hash (which + * would be O(n^2), since we couldn't use the plain lookup function. That is not a useful thing + * for this function. */ + + g_hash_table_iter_init(&h, hash_a); + while (g_hash_table_iter_next(&h, &a_key, &a_val)) { + if (!g_hash_table_lookup_extended(hash_b, a_key, NULL, &b_val)) + return FALSE; + + if (!cmp_values) { + /* we accept %NULL compare function to indicate that we don't care about the key. */ + continue; + } + + if (cmp_values(a_val, b_val, user_data) != 0) + return FALSE; + } + + return TRUE; } +/** + * nm_utils_hashtable_equal: + * @a: (allow-none): the hash table or %NULL + * @b: (allow-none): the other hash table or %NULL + * @cmp_values: (allow-none): if %NULL, only the keys + * will be compared. Otherwise, this function is used to + * check whether all keys are equal. + * @user_data: the argument for @cmp_values. + * + * It is required that both @a and @b have the same hash and equals + * function. + * + * Returns: %TRUE, if both keys have the same keys and (if + * @cmp_values is given) all values are the same. + */ gboolean -nm_utils_hashtable_same_keys (const GHashTable *a, - const GHashTable *b) +nm_utils_hashtable_equal(const GHashTable *a, + const GHashTable *b, + GCompareDataFunc cmp_values, + gpointer user_data) { - GHashTableIter h; - const char *k; + GHashTable *hash_a = (GHashTable *) a; + GHashTable *hash_b = (GHashTable *) b; + gboolean same; + guint size; + + if (hash_a == hash_b) + return TRUE; - if (a == b) - return TRUE; - if (!a || !b) - return FALSE; - if (g_hash_table_size ((GHashTable *) a) != g_hash_table_size ((GHashTable *) b)) - return FALSE; + if (!hash_a || !hash_b) + return FALSE; - g_hash_table_iter_init (&h, (GHashTable *) a); - while (g_hash_table_iter_next (&h, (gpointer) &k, NULL)) { - if (!g_hash_table_contains ((GHashTable *) b, k)) - return FALSE; - } + size = g_hash_table_size(hash_a); + if (size != g_hash_table_size(hash_b)) + return FALSE; + + if (size == 0) + return TRUE; + + same = _utils_hashtable_equal(hash_a, hash_b, cmp_values, user_data); #if NM_MORE_ASSERTS > 5 - g_hash_table_iter_init (&h, (GHashTable *) b); - while (g_hash_table_iter_next (&h, (gpointer) &k, NULL)) - nm_assert (g_hash_table_contains ((GHashTable *) a, k)); + nm_assert(same == _utils_hashtable_equal(hash_b, hash_a, cmp_values, user_data)); #endif - return TRUE; + return same; +} + +typedef struct { + gpointer key; + gpointer val; +} HashTableCmpData; + +typedef struct { + GCompareDataFunc cmp_keys; + gpointer user_data; +} HashTableUserData; + +static int +_hashtable_cmp_func(gconstpointer a, gconstpointer b, gpointer user_data) +{ + const HashTableUserData *d = user_data; + const HashTableCmpData * d_a = *((const HashTableCmpData *const *) a); + const HashTableCmpData * d_b = *((const HashTableCmpData *const *) b); + + NM_CMP_RETURN(d->cmp_keys(d_a, d_b, d->user_data)); + return 0; +} + +/** + * nm_utils_hashtable_cmp: + * @a: (allow-none): the hash to compare. May be %NULL. + * @b: (allow-none): the other hash to compare. May be %NULL. + * @do_fast_precheck: if %TRUE, assume that the hashes are equal + * and that it is worth calling nm_utils_hashtable_equal() first. + * That requires, that both hashes have the same equals function + * which is compatible with the @cmp_keys function. + * @cmp_keys: the compare function for keys. Usually, the hash/equal function + * of both hashes corresponds to this function. If you set @do_fast_precheck + * to false, then this is not a requirement. + * @cmp_values: (allow-none): if %NULL, only the keys are compared. + * Otherwise, the values must are also compared with this function. + * + * Both hashes must have keys/values of the same domain, so that + * they can be effectively compared with @cmp_keys and @cmp_values. + * + * %NULL hashes compare equal to %NULL, but not to empty hashes. + * + * Returns: 0 if both hashes are equal, or -1 or 1 if one of the hashes + * sorts before/after. + */ +int +nm_utils_hashtable_cmp(const GHashTable *a, + const GHashTable *b, + gboolean do_fast_precheck, + GCompareDataFunc cmp_keys, + GCompareDataFunc cmp_values, + gpointer user_data) +{ + GHashTable *hash_a = (GHashTable *) a; + GHashTable *hash_b = (GHashTable *) b; + gs_free HashTableCmpData *cmp_array_free = NULL; + HashTableCmpData * cmp_array_a; + HashTableCmpData * cmp_array_b; + GHashTableIter h; + gpointer i_key; + gpointer i_val; + gsize size2; + guint size; + guint i; + + nm_assert(cmp_keys); + + NM_CMP_SELF(hash_a, hash_b); + + size = g_hash_table_size(hash_a); + + NM_CMP_DIRECT(size, g_hash_table_size(hash_b)); + + if (size == 0) + return 0; + + if (do_fast_precheck) { + gboolean same; + + /* we expect that the hashes are equal and the caller ensures us that they + * use the same hash/equal functions. Do a fast path check first... + * + * It's unclear whether this is worth it. The full comparison is O(n*ln(n)), + * while the fast check (using the hash lookup) is O(n). But then, the pre-check + * makes additional requirements on the hash's hash/equal functions -- the + * full comparison does not make such requirements. */ + same = _utils_hashtable_equal(hash_a, hash_b, cmp_values, user_data); +#if NM_MORE_ASSERTS > 5 + nm_assert(same == _utils_hashtable_equal(hash_b, hash_a, cmp_values, user_data)); +#endif + if (same) + return 0; + } + + size2 = ((gsize) size) * 2u; + if (size2 > 600u / sizeof(HashTableCmpData)) { + cmp_array_free = g_new(HashTableCmpData, size2); + cmp_array_a = cmp_array_free; + } else + cmp_array_a = g_newa(HashTableCmpData, size2); + cmp_array_b = &cmp_array_a[size]; + + i = 0; + g_hash_table_iter_init(&h, hash_a); + while (g_hash_table_iter_next(&h, &i_key, &i_val)) { + nm_assert(i < size); + cmp_array_a[i++] = (HashTableCmpData){ + .key = i_key, + .val = i_val, + }; + } + nm_assert(i == size); + + i = 0; + g_hash_table_iter_init(&h, hash_b); + while (g_hash_table_iter_next(&h, &i_key, &i_val)) { + nm_assert(i < size); + cmp_array_b[i++] = (HashTableCmpData){ + .key = i_key, + .val = i_val, + }; + } + nm_assert(i == size); + + g_qsort_with_data(cmp_array_a, + size, + sizeof(HashTableCmpData), + _hashtable_cmp_func, + &((HashTableUserData){ + .cmp_keys = cmp_keys, + .user_data = user_data, + })); + + g_qsort_with_data(cmp_array_b, + size, + sizeof(HashTableCmpData), + _hashtable_cmp_func, + &((HashTableUserData){ + .cmp_keys = cmp_keys, + .user_data = user_data, + })); + + for (i = 0; i < size; i++) { + NM_CMP_RETURN(cmp_keys(cmp_array_a[i].key, cmp_array_b[i].key, user_data)); + } + + if (cmp_values) { + for (i = 0; i < size; i++) { + NM_CMP_RETURN(cmp_values(cmp_array_a[i].val, cmp_array_b[i].val, user_data)); + } + } + + /* the fast-precheck should have already told that the arrays are equal. */ + nm_assert(!do_fast_precheck); + + return 0; } char ** -nm_utils_strv_make_deep_copied (const char **strv) +nm_utils_strv_make_deep_copied(const char **strv) { - gsize i; + gsize i; - /* it takes a strv list, and copies each - * strings. Note that this updates @strv *in-place* - * and returns it. */ + /* it takes a strv list, and copies each + * strings. Note that this updates @strv *in-place* + * and returns it. */ - if (!strv) - return NULL; - for (i = 0; strv[i]; i++) - strv[i] = g_strdup (strv[i]); + if (!strv) + return NULL; + for (i = 0; strv[i]; i++) + strv[i] = g_strdup(strv[i]); - return (char **) strv; + return (char **) strv; } char ** -nm_utils_strv_make_deep_copied_n (const char **strv, gsize len) +nm_utils_strv_make_deep_copied_n(const char **strv, gsize len) { - gsize i; + gsize i; - /* it takes a strv array with len elements, and copies each - * strings. Note that this updates @strv *in-place* - * and returns it. */ + /* it takes a strv array with len elements, and copies each + * strings. Note that this updates @strv *in-place* + * and returns it. */ - if (!strv) - return NULL; - for (i = 0; i < len; i++) - strv[i] = g_strdup (strv[i]); + if (!strv) + return NULL; + for (i = 0; i < len; i++) + strv[i] = g_strdup(strv[i]); - return (char **) strv; + return (char **) strv; } /** @@ -3324,7 +3557,7 @@ nm_utils_strv_make_deep_copied_n (const char **strv, gsize len) * * Note that if @len is non-negative, then it still must not * contain any %NULL pointers within the first @len elements. - * Otherwise you would leak elements if you try to free the + * Otherwise, you would leak elements if you try to free the * array with g_strfreev(). Allowing that would be error prone. * * Returns: (transfer full): a clone of the strv array. Always @@ -3332,124 +3565,198 @@ nm_utils_strv_make_deep_copied_n (const char **strv, gsize len) * cloned or not. */ char ** -nm_utils_strv_dup (gpointer strv, - gssize len, - gboolean deep_copied) -{ - gsize i, l; - char **v; - const char *const *const src = strv; - - if (len < 0) - l = NM_PTRARRAY_LEN (src); - else - l = len; - if (l == 0) { - /* this function never returns an empty strv array. If you - * need that, handle it yourself. */ - return NULL; - } - - v = g_new (char *, l + 1); - for (i = 0; i < l; i++) { - - if (G_UNLIKELY (!src[i])) { - /* NULL strings are not allowed. Clear the remainder of the array - * and return it (with assertion failure). */ - l++; - for (; i < l; i++) - v[i] = NULL; - g_return_val_if_reached (v); - } - - if (deep_copied) - v[i] = g_strdup (src[i]); - else - v[i] = (char *) src[i]; - } - v[l] = NULL; - return v; +_nm_utils_strv_dup(const char *const *strv, gssize len, gboolean deep_copied) +{ + gsize i, l; + char **v; + + if (len < 0) + l = NM_PTRARRAY_LEN(strv); + else + l = len; + if (l == 0) { + /* this function never returns an empty strv array. If you + * need that, handle it yourself. */ + return NULL; + } + + v = g_new(char *, l + 1); + for (i = 0; i < l; i++) { + if (G_UNLIKELY(!strv[i])) { + /* NULL strings are not allowed. Clear the remainder of the array + * and return it (with assertion failure). */ + l++; + for (; i < l; i++) + v[i] = NULL; + g_return_val_if_reached(v); + } + + if (deep_copied) + v[i] = g_strdup(strv[i]); + else + v[i] = (char *) strv[i]; + } + v[l] = NULL; + return v; +} + +const char ** +_nm_utils_strv_dup_packed(const char *const *strv, gssize len) + +{ + gs_free gsize *str_len_free = NULL; + gsize * str_len; + const char ** result; + gsize mem_len; + gsize pre_len; + gsize len2; + char * sbuf; + gsize i; + + nm_assert(len >= -1); + + if (G_LIKELY(len < 0)) { + if (!strv || !strv[0]) { + /* This function never returns an empty strv array. If you need that, handle it + * yourself. */ + return NULL; + } + len2 = NM_PTRARRAY_LEN(strv); + } else { + if (len == 0) + return NULL; + len2 = len; + } + + if (len2 > 300u / sizeof(gsize)) { + str_len_free = g_new(gsize, len2); + str_len = str_len_free; + } else + str_len = g_newa(gsize, len2); + + mem_len = 0; + for (i = 0; i < len2; i++) { + gsize l; + + if (G_LIKELY(strv[i])) + l = strlen(strv[i]) + 1u; + else + l = 0; + str_len[i] = l; + mem_len += l; + } + + pre_len = sizeof(const char *) * (len2 + 1u); + + result = g_malloc(pre_len + mem_len); + sbuf = &(((char *) result)[pre_len]); + for (i = 0; i < len2; i++) { + gsize l; + + if (G_UNLIKELY(!strv[i])) { + /* Technically there is no problem with accepting NULL strings. But that + * does not really result in a strv array, and likely this only happens due + * to a bug. We want to catch such bugs by asserting. + * + * We clear the remainder of the buffer and fail with an assertion. */ + len2++; + for (; i < len2; i++) + result[i] = NULL; + g_return_val_if_reached(result); + } + + result[i] = sbuf; + + l = str_len[i]; + memcpy(sbuf, strv[i], l); + sbuf += l; + } + result[i] = NULL; + nm_assert(i == len2); + nm_assert(sbuf == (&((const char *) result)[pre_len]) + mem_len); + + return result; } /*****************************************************************************/ gssize -nm_utils_ptrarray_find_binary_search (gconstpointer *list, - gsize len, - gconstpointer needle, - GCompareDataFunc cmpfcn, - gpointer user_data, - gssize *out_idx_first, - gssize *out_idx_last) -{ - gssize imin, imax, imid, i2min, i2max, i2mid; - int cmp; - - g_return_val_if_fail (list || !len, ~((gssize) 0)); - g_return_val_if_fail (cmpfcn, ~((gssize) 0)); - - imin = 0; - if (len > 0) { - imax = len - 1; - - while (imin <= imax) { - imid = imin + (imax - imin) / 2; - - cmp = cmpfcn (list[imid], needle, user_data); - if (cmp == 0) { - /* we found a matching entry at index imid. - * - * Does the caller request the first/last index as well (in case that - * there are multiple entries which compare equal). */ - - if (out_idx_first) { - i2min = imin; - i2max = imid + 1; - while (i2min <= i2max) { - i2mid = i2min + (i2max - i2min) / 2; - - cmp = cmpfcn (list[i2mid], needle, user_data); - if (cmp == 0) - i2max = i2mid -1; - else { - nm_assert (cmp < 0); - i2min = i2mid + 1; - } - } - *out_idx_first = i2min; - } - if (out_idx_last) { - i2min = imid + 1; - i2max = imax; - while (i2min <= i2max) { - i2mid = i2min + (i2max - i2min) / 2; - - cmp = cmpfcn (list[i2mid], needle, user_data); - if (cmp == 0) - i2min = i2mid + 1; - else { - nm_assert (cmp > 0); - i2max = i2mid - 1; - } - } - *out_idx_last = i2min - 1; - } - return imid; - } - - if (cmp < 0) - imin = imid + 1; - else - imax = imid - 1; - } - } - - /* return the inverse of @imin. This is a negative number, but - * also is ~imin the position where the value should be inserted. */ - imin = ~imin; - NM_SET_OUT (out_idx_first, imin); - NM_SET_OUT (out_idx_last, imin); - return imin; +nm_utils_ptrarray_find_binary_search(gconstpointer * list, + gsize len, + gconstpointer needle, + GCompareDataFunc cmpfcn, + gpointer user_data, + gssize * out_idx_first, + gssize * out_idx_last) +{ + gssize imin, imax, imid, i2min, i2max, i2mid; + int cmp; + + g_return_val_if_fail(list || !len, ~((gssize) 0)); + g_return_val_if_fail(cmpfcn, ~((gssize) 0)); + + imin = 0; + if (len > 0) { + imax = len - 1; + + while (imin <= imax) { + imid = imin + (imax - imin) / 2; + + cmp = cmpfcn(list[imid], needle, user_data); + if (cmp == 0) { + /* we found a matching entry at index imid. + * + * Does the caller request the first/last index as well (in case that + * there are multiple entries which compare equal). */ + + if (out_idx_first) { + i2min = imin; + i2max = imid + 1; + while (i2min <= i2max) { + i2mid = i2min + (i2max - i2min) / 2; + + cmp = cmpfcn(list[i2mid], needle, user_data); + if (cmp == 0) + i2max = i2mid - 1; + else { + nm_assert(cmp < 0); + i2min = i2mid + 1; + } + } + *out_idx_first = i2min; + } + if (out_idx_last) { + i2min = imid + 1; + i2max = imax; + while (i2min <= i2max) { + i2mid = i2min + (i2max - i2min) / 2; + + cmp = cmpfcn(list[i2mid], needle, user_data); + if (cmp == 0) + i2min = i2mid + 1; + else { + nm_assert(cmp > 0); + i2max = i2mid - 1; + } + } + *out_idx_last = i2min - 1; + } + return imid; + } + + if (cmp < 0) + imin = imid + 1; + else + imax = imid - 1; + } + } + + /* return the inverse of @imin. This is a negative number, but + * also is ~imin the position where the value should be inserted. */ + imin = ~imin; + NM_SET_OUT(out_idx_first, imin); + NM_SET_OUT(out_idx_last, imin); + return imin; } /*****************************************************************************/ @@ -3479,42 +3786,42 @@ nm_utils_ptrarray_find_binary_search (gconstpointer *list, * position where it should be. */ gssize -nm_utils_array_find_binary_search (gconstpointer list, - gsize elem_size, - gsize len, - gconstpointer needle, - GCompareDataFunc cmpfcn, - gpointer user_data) +nm_utils_array_find_binary_search(gconstpointer list, + gsize elem_size, + gsize len, + gconstpointer needle, + GCompareDataFunc cmpfcn, + gpointer user_data) { - gssize imin, imax, imid; - int cmp; + gssize imin, imax, imid; + int cmp; - g_return_val_if_fail (list || !len, ~((gssize) 0)); - g_return_val_if_fail (cmpfcn, ~((gssize) 0)); - g_return_val_if_fail (elem_size > 0, ~((gssize) 0)); + g_return_val_if_fail(list || !len, ~((gssize) 0)); + g_return_val_if_fail(cmpfcn, ~((gssize) 0)); + g_return_val_if_fail(elem_size > 0, ~((gssize) 0)); - imin = 0; - if (len == 0) - return ~imin; + imin = 0; + if (len == 0) + return ~imin; - imax = len - 1; + imax = len - 1; - while (imin <= imax) { - imid = imin + (imax - imin) / 2; + while (imin <= imax) { + imid = imin + (imax - imin) / 2; - cmp = cmpfcn (&((const char *) list)[elem_size * imid], needle, user_data); - if (cmp == 0) - return imid; + cmp = cmpfcn(&((const char *) list)[elem_size * imid], needle, user_data); + if (cmp == 0) + return imid; - if (cmp < 0) - imin = imid + 1; - else - imax = imid - 1; - } + if (cmp < 0) + imin = imid + 1; + else + imax = imid - 1; + } - /* return the inverse of @imin. This is a negative number, but - * also is ~imin the position where the value should be inserted. */ - return ~imin; + /* return the inverse of @imin. This is a negative number, but + * also is ~imin the position where the value should be inserted. */ + return ~imin; } /*****************************************************************************/ @@ -3540,38 +3847,37 @@ nm_utils_array_find_binary_search (gconstpointer list, * Returns: %TRUE, if both dictionaries have the same content. */ gboolean -nm_utils_hash_table_equal (const GHashTable *a, - const GHashTable *b, - gboolean treat_null_as_empty, - NMUtilsHashTableEqualFunc equal_func) -{ - guint n; - GHashTableIter iter; - gconstpointer key, v_a, v_b; - - if (a == b) - return TRUE; - if (!treat_null_as_empty) { - if (!a || !b) - return FALSE; - } - - n = a ? g_hash_table_size ((GHashTable *) a) : 0; - if (n != (b ? g_hash_table_size ((GHashTable *) b) : 0)) - return FALSE; - - if (n > 0) { - g_hash_table_iter_init (&iter, (GHashTable *) a); - while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &v_a)) { - if (!g_hash_table_lookup_extended ((GHashTable *) b, key, NULL, (gpointer *) &v_b)) - return FALSE; - if ( equal_func - && !equal_func (v_a, v_b)) - return FALSE; - } - } - - return TRUE; +nm_utils_hash_table_equal(const GHashTable * a, + const GHashTable * b, + gboolean treat_null_as_empty, + NMUtilsHashTableEqualFunc equal_func) +{ + guint n; + GHashTableIter iter; + gconstpointer key, v_a, v_b; + + if (a == b) + return TRUE; + if (!treat_null_as_empty) { + if (!a || !b) + return FALSE; + } + + n = a ? g_hash_table_size((GHashTable *) a) : 0; + if (n != (b ? g_hash_table_size((GHashTable *) b) : 0)) + return FALSE; + + if (n > 0) { + g_hash_table_iter_init(&iter, (GHashTable *) a); + while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &v_a)) { + if (!g_hash_table_lookup_extended((GHashTable *) b, key, NULL, (gpointer *) &v_b)) + return FALSE; + if (equal_func && !equal_func(v_a, v_b)) + return FALSE; + } + } + + return TRUE; } /*****************************************************************************/ @@ -3591,65 +3897,65 @@ nm_utils_hash_table_equal (const GHashTable *a, * The returned start time counts since boot, in the unit HZ (with HZ usually being (1/100) seconds) **/ guint64 -nm_utils_get_start_time_for_pid (pid_t pid, char *out_state, pid_t *out_ppid) +nm_utils_get_start_time_for_pid(pid_t pid, char *out_state, pid_t *out_ppid) { - guint64 start_time; - char filename[256]; - gs_free char *contents = NULL; - size_t length; - gs_free const char **tokens = NULL; - char *p; - char state = ' '; - gint64 ppid = 0; + guint64 start_time; + char filename[256]; + gs_free char * contents = NULL; + size_t length; + gs_free const char **tokens = NULL; + char * p; + char state = ' '; + gint64 ppid = 0; - start_time = 0; - contents = NULL; + start_time = 0; + contents = NULL; - g_return_val_if_fail (pid > 0, 0); + g_return_val_if_fail(pid > 0, 0); - G_STATIC_ASSERT_EXPR (sizeof (GPid) >= sizeof (pid_t)); + G_STATIC_ASSERT_EXPR(sizeof(GPid) >= sizeof(pid_t)); - nm_sprintf_buf (filename, "/proc/%"G_PID_FORMAT"/stat", (GPid) pid); + nm_sprintf_buf(filename, "/proc/%" G_PID_FORMAT "/stat", (GPid) pid); - if (!g_file_get_contents (filename, &contents, &length, NULL)) - goto fail; + if (!g_file_get_contents(filename, &contents, &length, NULL)) + goto fail; - /* start time is the token at index 19 after the '(process name)' entry - since only this - * field can contain the ')' character, search backwards for this to avoid malicious - * processes trying to fool us - */ - p = strrchr (contents, ')'); - if (!p) - goto fail; - p += 2; /* skip ') ' */ - if (p - contents >= (int) length) - goto fail; + /* start time is the token at index 19 after the '(process name)' entry - since only this + * field can contain the ')' character, search backwards for this to avoid malicious + * processes trying to fool us + */ + p = strrchr(contents, ')'); + if (!p) + goto fail; + p += 2; /* skip ') ' */ + if (p - contents >= (int) length) + goto fail; - state = p[0]; + state = p[0]; - tokens = nm_utils_strsplit_set (p, " "); + tokens = nm_utils_strsplit_set(p, " "); - if (NM_PTRARRAY_LEN (tokens) < 20) - goto fail; + if (NM_PTRARRAY_LEN(tokens) < 20) + goto fail; - if (out_ppid) { - ppid = _nm_utils_ascii_str_to_int64 (tokens[1], 10, 1, G_MAXINT, 0); - if (ppid == 0) - goto fail; - } + if (out_ppid) { + ppid = _nm_utils_ascii_str_to_int64(tokens[1], 10, 1, G_MAXINT, 0); + if (ppid == 0) + goto fail; + } - start_time = _nm_utils_ascii_str_to_int64 (tokens[19], 10, 1, G_MAXINT64, 0); - if (start_time == 0) - goto fail; + start_time = _nm_utils_ascii_str_to_int64(tokens[19], 10, 1, G_MAXINT64, 0); + if (start_time == 0) + goto fail; - NM_SET_OUT (out_state, state); - NM_SET_OUT (out_ppid, ppid); - return start_time; + NM_SET_OUT(out_state, state); + NM_SET_OUT(out_ppid, ppid); + return start_time; fail: - NM_SET_OUT (out_state, ' '); - NM_SET_OUT (out_ppid, 0); - return 0; + NM_SET_OUT(out_state, ' '); + NM_SET_OUT(out_ppid, 0); + return 0; } /*****************************************************************************/ @@ -3669,29 +3975,25 @@ fail: * comparison. */ void -_nm_utils_strv_sort (const char **strv, gssize len) +_nm_utils_strv_sort(const char **strv, gssize len) { - GCompareDataFunc cmp; - gsize l; + GCompareDataFunc cmp; + gsize l; - if (len < 0) { - l = NM_PTRARRAY_LEN (strv); - cmp = nm_strcmp_p_with_data; - } else { - l = len; - cmp = nm_strcmp0_p_with_data; - } + if (len < 0) { + l = NM_PTRARRAY_LEN(strv); + cmp = nm_strcmp_p_with_data; + } else { + l = len; + cmp = nm_strcmp0_p_with_data; + } - if (l <= 1) - return; + if (l <= 1) + return; - nm_assert (l <= (gsize) G_MAXINT); + nm_assert(l <= (gsize) G_MAXINT); - g_qsort_with_data (strv, - l, - sizeof (const char *), - cmp, - NULL); + g_qsort_with_data(strv, l, sizeof(const char *), cmp, NULL); } /** @@ -3718,31 +4020,28 @@ _nm_utils_strv_sort (const char **strv, gssize len) * Returns: 0 if the arrays are equal (using strcmp). **/ int -_nm_utils_strv_cmp_n (const char *const*strv1, - gssize len1, - const char *const*strv2, - gssize len2) +_nm_utils_strv_cmp_n(const char *const *strv1, gssize len1, const char *const *strv2, gssize len2) { - gsize n, n2; + gsize n, n2; - if (len1 < 0) { - if (!strv1) - return (len2 < 0 && !strv2) ? 0 : -1; - n = NM_PTRARRAY_LEN (strv1); - } else - n = len1; + if (len1 < 0) { + if (!strv1) + return (len2 < 0 && !strv2) ? 0 : -1; + n = NM_PTRARRAY_LEN(strv1); + } else + n = len1; - if (len2 < 0) { - if (!strv2) - return 1; - n2 = NM_PTRARRAY_LEN (strv2); - } else - n2 = len2; + if (len2 < 0) { + if (!strv2) + return 1; + n2 = NM_PTRARRAY_LEN(strv2); + } else + n2 = len2; - NM_CMP_DIRECT (n, n2); - for (; n > 0; n--, strv1++, strv2++) - NM_CMP_DIRECT_STRCMP0 (*strv1, *strv2); - return 0; + NM_CMP_DIRECT(n, n2); + for (; n > 0; n--, strv1++, strv2++) + NM_CMP_DIRECT_STRCMP0(*strv1, *strv2); + return 0; } /*****************************************************************************/ @@ -3760,17 +4059,16 @@ _nm_utils_strv_cmp_n (const char *const*strv1, * %NULL if not found. */ GSList * -nm_utils_g_slist_find_str (const GSList *list, - const char *needle) +nm_utils_g_slist_find_str(const GSList *list, const char *needle) { - nm_assert (needle); + nm_assert(needle); - for (; list; list = list->next) { - nm_assert (list->data); - if (nm_streq (list->data, needle)) - return (GSList *) list; - } - return NULL; + for (; list; list = list->next) { + nm_assert(list->data); + if (nm_streq(list->data, needle)) + return (GSList *) list; + } + return NULL; } /** @@ -3779,250 +4077,246 @@ nm_utils_g_slist_find_str (const GSList *list, * @b: the right #GSList of strings to compare. * * Compares two string lists. The data elements are compared with - * strcmp(), alloing %NULL elements. + * strcmp(), allowing %NULL elements. * * Returns: 0, 1, or -1, depending on how the lists compare. */ int -nm_utils_g_slist_strlist_cmp (const GSList *a, const GSList *b) +nm_utils_g_slist_strlist_cmp(const GSList *a, const GSList *b) { - while (TRUE) { - if (!a) - return !b ? 0 : -1; - if (!b) - return 1; - NM_CMP_DIRECT_STRCMP0 (a->data, b->data); - a = a->next; - b = b->next; - } + while (TRUE) { + if (!a) + return !b ? 0 : -1; + if (!b) + return 1; + NM_CMP_DIRECT_STRCMP0(a->data, b->data); + a = a->next; + b = b->next; + } } char * -nm_utils_g_slist_strlist_join (const GSList *a, const char *separator) +nm_utils_g_slist_strlist_join(const GSList *a, const char *separator) { - GString *str = NULL; + GString *str = NULL; - if (!a) - return NULL; + if (!a) + return NULL; - for (; a; a = a->next) { - if (!str) - str = g_string_new (NULL); - else - g_string_append (str, separator); - g_string_append (str, a->data); - } - return g_string_free (str, FALSE); + for (; a; a = a->next) { + if (!str) + str = g_string_new(NULL); + else + g_string_append(str, separator); + g_string_append(str, a->data); + } + return g_string_free(str, FALSE); } /*****************************************************************************/ gpointer -_nm_utils_user_data_pack (int nargs, gconstpointer *args) +_nm_utils_user_data_pack(int nargs, gconstpointer *args) { - int i; - gpointer *data; + int i; + gpointer *data; - nm_assert (nargs > 0); - nm_assert (args); + nm_assert(nargs > 0); + nm_assert(args); - data = g_slice_alloc (((gsize) nargs) * sizeof (gconstpointer)); - for (i = 0; i < nargs; i++) - data[i] = (gpointer) args[i]; - return data; + data = g_slice_alloc(((gsize) nargs) * sizeof(gconstpointer)); + for (i = 0; i < nargs; i++) + data[i] = (gpointer) args[i]; + return data; } void -_nm_utils_user_data_unpack (gpointer user_data, int nargs, ...) +_nm_utils_user_data_unpack(gpointer user_data, int nargs, ...) { - gpointer *data = user_data; - va_list ap; - int i; + gpointer *data = user_data; + va_list ap; + int i; - nm_assert (data); - nm_assert (nargs > 0); + nm_assert(data); + nm_assert(nargs > 0); - va_start (ap, nargs); - for (i = 0; i < nargs; i++) { - gpointer *dst; + va_start(ap, nargs); + for (i = 0; i < nargs; i++) { + gpointer *dst; - dst = va_arg (ap, gpointer *); - nm_assert (dst); + dst = va_arg(ap, gpointer *); + nm_assert(dst); - *dst = data[i]; - } - va_end (ap); + *dst = data[i]; + } + va_end(ap); - g_slice_free1 (((gsize) nargs) * sizeof (gconstpointer), data); + g_slice_free1(((gsize) nargs) * sizeof(gconstpointer), data); } /*****************************************************************************/ typedef struct { - gpointer callback_user_data; - GCancellable *cancellable; - GSource *source; - NMUtilsInvokeOnIdleCallback callback; - gulong cancelled_id; + gpointer callback_user_data; + GCancellable * cancellable; + GSource * source; + NMUtilsInvokeOnIdleCallback callback; + gulong cancelled_id; } InvokeOnIdleData; static gboolean -_nm_utils_invoke_on_idle_cb_idle (gpointer user_data) +_nm_utils_invoke_on_idle_cb_idle(gpointer user_data) { - InvokeOnIdleData *data = user_data; + InvokeOnIdleData *data = user_data; - nm_clear_g_signal_handler (data->cancellable, &data->cancelled_id); + nm_clear_g_signal_handler(data->cancellable, &data->cancelled_id); - data->callback (data->callback_user_data, data->cancellable); + data->callback(data->callback_user_data, data->cancellable); - nm_g_object_unref (data->cancellable); - g_source_destroy (data->source); - nm_g_slice_free (data); - return G_SOURCE_REMOVE; + nm_g_object_unref(data->cancellable); + g_source_destroy(data->source); + nm_g_slice_free(data); + return G_SOURCE_REMOVE; } static void -_nm_utils_invoke_on_idle_cb_cancelled (GCancellable *cancellable, - InvokeOnIdleData *data) +_nm_utils_invoke_on_idle_cb_cancelled(GCancellable *cancellable, InvokeOnIdleData *data) { - /* on cancellation, we invoke the callback synchronously. */ - nm_clear_g_signal_handler (data->cancellable, &data->cancelled_id); - nm_clear_g_source_inst (&data->source); - data->callback (data->callback_user_data, data->cancellable); - nm_g_object_unref (data->cancellable); - nm_g_slice_free (data); + /* on cancellation, we invoke the callback synchronously. */ + nm_clear_g_signal_handler(data->cancellable, &data->cancelled_id); + nm_clear_g_source_inst(&data->source); + data->callback(data->callback_user_data, data->cancellable); + nm_g_object_unref(data->cancellable); + nm_g_slice_free(data); } static void -_nm_utils_invoke_on_idle_start (gboolean use_timeout, - guint timeout_msec, - GCancellable *cancellable, - NMUtilsInvokeOnIdleCallback callback, - gpointer callback_user_data) -{ - InvokeOnIdleData *data; - GSource *source; - - g_return_if_fail (callback); - - data = g_slice_new (InvokeOnIdleData); - *data = (InvokeOnIdleData) { - .callback = callback, - .callback_user_data = callback_user_data, - .cancellable = nm_g_object_ref (cancellable), - .cancelled_id = 0, - }; - - if (cancellable) { - if (g_cancellable_is_cancelled (cancellable)) { - /* the cancellable is already cancelled. We ignore the timeout - * and always schedule an idle action. */ - use_timeout = FALSE; - } else { - /* if we are passed a non-cancelled cancellable, we register to the "cancelled" - * signal an invoke the callback synchronously (from the signal handler). - * - * We don't do that, - * - if the cancellable is already cancelled (because we don't want to invoke - * the callback synchronously from the caller). - * - if we have no cancellable at hand. */ - data->cancelled_id = g_signal_connect (cancellable, - "cancelled", - G_CALLBACK (_nm_utils_invoke_on_idle_cb_cancelled), - data); - } - } - - if (use_timeout) { - source = nm_g_timeout_source_new (timeout_msec, - G_PRIORITY_DEFAULT, - _nm_utils_invoke_on_idle_cb_idle, - data, - NULL); - } else { - source = nm_g_idle_source_new (G_PRIORITY_DEFAULT, - _nm_utils_invoke_on_idle_cb_idle, - data, - NULL); - } - - /* use the current thread default context. */ - g_source_attach (source, - g_main_context_get_thread_default ()); - - data->source = source; +_nm_utils_invoke_on_idle_start(gboolean use_timeout, + guint timeout_msec, + GCancellable * cancellable, + NMUtilsInvokeOnIdleCallback callback, + gpointer callback_user_data) +{ + InvokeOnIdleData *data; + GSource * source; + + g_return_if_fail(callback); + + data = g_slice_new(InvokeOnIdleData); + *data = (InvokeOnIdleData){ + .callback = callback, + .callback_user_data = callback_user_data, + .cancellable = nm_g_object_ref(cancellable), + .cancelled_id = 0, + }; + + if (cancellable) { + if (g_cancellable_is_cancelled(cancellable)) { + /* the cancellable is already cancelled. We ignore the timeout + * and always schedule an idle action. */ + use_timeout = FALSE; + } else { + /* if we are passed a non-cancelled cancellable, we register to the "cancelled" + * signal an invoke the callback synchronously (from the signal handler). + * + * We don't do that, + * - if the cancellable is already cancelled (because we don't want to invoke + * the callback synchronously from the caller). + * - if we have no cancellable at hand. */ + data->cancelled_id = g_signal_connect(cancellable, + "cancelled", + G_CALLBACK(_nm_utils_invoke_on_idle_cb_cancelled), + data); + } + } + + if (use_timeout) { + source = nm_g_timeout_source_new(timeout_msec, + G_PRIORITY_DEFAULT, + _nm_utils_invoke_on_idle_cb_idle, + data, + NULL); + } else { + source = + nm_g_idle_source_new(G_PRIORITY_DEFAULT, _nm_utils_invoke_on_idle_cb_idle, data, NULL); + } + + /* use the current thread default context. */ + g_source_attach(source, g_main_context_get_thread_default()); + + data->source = source; } void -nm_utils_invoke_on_idle (GCancellable *cancellable, - NMUtilsInvokeOnIdleCallback callback, - gpointer callback_user_data) +nm_utils_invoke_on_idle(GCancellable * cancellable, + NMUtilsInvokeOnIdleCallback callback, + gpointer callback_user_data) { - _nm_utils_invoke_on_idle_start (FALSE, 0, cancellable, callback, callback_user_data); + _nm_utils_invoke_on_idle_start(FALSE, 0, cancellable, callback, callback_user_data); } void -nm_utils_invoke_on_timeout (guint timeout_msec, - GCancellable *cancellable, - NMUtilsInvokeOnIdleCallback callback, - gpointer callback_user_data) +nm_utils_invoke_on_timeout(guint timeout_msec, + GCancellable * cancellable, + NMUtilsInvokeOnIdleCallback callback, + gpointer callback_user_data) { - _nm_utils_invoke_on_idle_start (TRUE, timeout_msec, cancellable, callback, callback_user_data); + _nm_utils_invoke_on_idle_start(TRUE, timeout_msec, cancellable, callback, callback_user_data); } /*****************************************************************************/ int -nm_utils_getpagesize (void) +nm_utils_getpagesize(void) { - static volatile int val = 0; - long l; - int v; + static volatile int val = 0; + long l; + int v; - v = g_atomic_int_get (&val); + v = g_atomic_int_get(&val); - if (G_UNLIKELY (v == 0)) { - l = sysconf (_SC_PAGESIZE); + if (G_UNLIKELY(v == 0)) { + l = sysconf(_SC_PAGESIZE); - g_return_val_if_fail (l > 0 && l < G_MAXINT, 4*1024); + g_return_val_if_fail(l > 0 && l < G_MAXINT, 4 * 1024); - v = (int) l; - if (!g_atomic_int_compare_and_exchange (&val, 0, v)) { - v = g_atomic_int_get (&val); - g_return_val_if_fail (v > 0, 4*1024); - } - } + v = (int) l; + if (!g_atomic_int_compare_and_exchange(&val, 0, v)) { + v = g_atomic_int_get(&val); + g_return_val_if_fail(v > 0, 4 * 1024); + } + } - nm_assert (v > 0); + nm_assert(v > 0); #if NM_MORE_ASSERTS > 5 - nm_assert (v == getpagesize ()); - nm_assert (v == sysconf (_SC_PAGESIZE)); + nm_assert(v == getpagesize()); + nm_assert(v == sysconf(_SC_PAGESIZE)); #endif - return v; + return v; } gboolean -nm_utils_memeqzero (gconstpointer data, gsize length) +nm_utils_memeqzero(gconstpointer data, gsize length) { - const unsigned char *p = data; - int len; + const unsigned char *p = data; + int len; - /* Taken from https://github.com/rustyrussell/ccan/blob/9d2d2c49f053018724bcc6e37029da10b7c3d60d/ccan/mem/mem.c#L92, - * CC-0 licensed. */ + /* Taken from https://github.com/rustyrussell/ccan/blob/9d2d2c49f053018724bcc6e37029da10b7c3d60d/ccan/mem/mem.c#L92, + * CC-0 licensed. */ - /* Check first 16 bytes manually */ - for (len = 0; len < 16; len++) { - if (!length) - return TRUE; - if (*p) - return FALSE; - p++; - length--; - } + /* Check first 16 bytes manually */ + for (len = 0; len < 16; len++) { + if (!length) + return TRUE; + if (*p) + return FALSE; + p++; + length--; + } - /* Now we know that's zero, memcmp with self. */ - return memcmp (data, p, length) == 0; + /* Now we know that's zero, memcmp with self. */ + return memcmp(data, p, length) == 0; } /** @@ -4046,273 +4340,255 @@ nm_utils_memeqzero (gconstpointer data, gsize length) * Returns: the binary value converted to a hex string. If @out is given, * this always returns @out. If @out is %NULL, a newly allocated string * is returned. This never returns %NULL, for buffers of length zero - * an empty string is returend. + * an empty string is returned. */ char * -nm_utils_bin2hexstr_full (gconstpointer addr, - gsize length, - char delimiter, - gboolean upper_case, - char *out) -{ - const guint8 *in = addr; - const char *LOOKUP = upper_case ? "0123456789ABCDEF" : "0123456789abcdef"; - char *out0; - - if (out) - out0 = out; - else { - out0 = out = g_new (char, length == 0 - ? 1u - : ( delimiter == '\0' - ? length * 2u + 1u - : length * 3u)); - } - - /* @out must contain at least @length*3 bytes if @delimiter is set, - * otherwise, @length*2+1. */ - - if (length > 0) { - nm_assert (in); - for (;;) { - const guint8 v = *in++; - - *out++ = LOOKUP[v >> 4]; - *out++ = LOOKUP[v & 0x0F]; - length--; - if (!length) - break; - if (delimiter) - *out++ = delimiter; - } - } - - *out = '\0'; - return out0; +nm_utils_bin2hexstr_full(gconstpointer addr, + gsize length, + char delimiter, + gboolean upper_case, + char * out) +{ + const guint8 *in = addr; + const char * LOOKUP = upper_case ? "0123456789ABCDEF" : "0123456789abcdef"; + char * out0; + + if (out) + out0 = out; + else { + out0 = out = + g_new(char, length == 0 ? 1u : (delimiter == '\0' ? length * 2u + 1u : length * 3u)); + } + + /* @out must contain at least @length*3 bytes if @delimiter is set, + * otherwise, @length*2+1. */ + + if (length > 0) { + nm_assert(in); + for (;;) { + const guint8 v = *in++; + + *out++ = LOOKUP[v >> 4]; + *out++ = LOOKUP[v & 0x0F]; + length--; + if (!length) + break; + if (delimiter) + *out++ = delimiter; + } + } + + *out = '\0'; + return out0; } guint8 * -nm_utils_hexstr2bin_full (const char *hexstr, - gboolean allow_0x_prefix, - gboolean delimiter_required, - const char *delimiter_candidates, - gsize required_len, - guint8 *buffer, - gsize buffer_len, - gsize *out_len) -{ - const char *in = hexstr; - guint8 *out = buffer; - gboolean delimiter_has = TRUE; - guint8 delimiter = '\0'; - gsize len; - - nm_assert (hexstr); - nm_assert (buffer); - nm_assert (required_len > 0 || out_len); - - if ( allow_0x_prefix - && in[0] == '0' - && in[1] == 'x') - in += 2; - - while (TRUE) { - const guint8 d1 = in[0]; - guint8 d2; - int i1, i2; - - i1 = nm_utils_hexchar_to_int (d1); - if (i1 < 0) - goto fail; - - /* If there's no leading zero (ie "aa:b:cc") then fake it */ - d2 = in[1]; - if ( d2 - && (i2 = nm_utils_hexchar_to_int (d2)) >= 0) { - *out++ = (i1 << 4) + i2; - d2 = in[2]; - if (!d2) - break; - in += 2; - } else { - /* Fake leading zero */ - *out++ = i1; - if (!d2) { - if (!delimiter_has) { - /* when using no delimiter, there must be pairs of hex chars */ - goto fail; - } - break; - } - in += 1; - } - - if (--buffer_len == 0) - goto fail; - - if (delimiter_has) { - if (d2 != delimiter) { - if (delimiter) - goto fail; - if (delimiter_candidates) { - while (delimiter_candidates[0]) { - if (delimiter_candidates++[0] == d2) - delimiter = d2; - } - } - if (!delimiter) { - if (delimiter_required) - goto fail; - delimiter_has = FALSE; - continue; - } - } - in++; - } - } - - len = out - buffer; - if ( required_len == 0 - || len == required_len) { - NM_SET_OUT (out_len, len); - return buffer; - } +nm_utils_hexstr2bin_full(const char *hexstr, + gboolean allow_0x_prefix, + gboolean delimiter_required, + gboolean hexdigit_pairs_required, + const char *delimiter_candidates, + gsize required_len, + guint8 * buffer, + gsize buffer_len, + gsize * out_len) +{ + const char *in = hexstr; + guint8 * out = buffer; + gboolean delimiter_has = TRUE; + guint8 delimiter = '\0'; + gsize len; + + nm_assert(hexstr); + nm_assert(buffer); + nm_assert(required_len > 0 || out_len); + + if (allow_0x_prefix && in[0] == '0' && in[1] == 'x') + in += 2; + + while (TRUE) { + const guint8 d1 = in[0]; + guint8 d2; + int i1, i2; + + i1 = nm_utils_hexchar_to_int(d1); + if (i1 < 0) + goto fail; + + /* If there's no leading zero (ie "aa:b:cc") then fake it */ + d2 = in[1]; + if (d2 && (i2 = nm_utils_hexchar_to_int(d2)) >= 0) { + *out++ = (i1 << 4) + i2; + d2 = in[2]; + if (!d2) + break; + in += 2; + } else { + /* Fake leading zero */ + *out++ = i1; + if (!d2) { + if (!delimiter_has || hexdigit_pairs_required) { + /* when using no delimiter, there must be pairs of hex chars */ + goto fail; + } + break; + } else if (hexdigit_pairs_required) + goto fail; + in += 1; + } + + if (--buffer_len == 0) + goto fail; + + if (delimiter_has) { + if (d2 != delimiter) { + if (delimiter) + goto fail; + if (delimiter_candidates) { + while (delimiter_candidates[0]) { + if (delimiter_candidates++[0] == d2) + delimiter = d2; + } + } + if (!delimiter) { + if (delimiter_required) + goto fail; + delimiter_has = FALSE; + continue; + } + } + in++; + } + } + + len = out - buffer; + if (required_len == 0 || len == required_len) { + NM_SET_OUT(out_len, len); + return buffer; + } fail: - NM_SET_OUT (out_len, 0); - return NULL; + NM_SET_OUT(out_len, 0); + return NULL; } guint8 * -nm_utils_hexstr2bin_alloc (const char *hexstr, - gboolean allow_0x_prefix, - gboolean delimiter_required, - const char *delimiter_candidates, - gsize required_len, - gsize *out_len) -{ - guint8 *buffer; - gsize buffer_len, len; - - if (G_UNLIKELY (!hexstr)) { - NM_SET_OUT (out_len, 0); - g_return_val_if_fail (hexstr, NULL); - } - - nm_assert (required_len > 0 || out_len); - - if ( allow_0x_prefix - && hexstr[0] == '0' - && hexstr[1] == 'x') - hexstr += 2; - - if (!hexstr[0]) - goto fail; - - if (required_len > 0) - buffer_len = required_len; - else - buffer_len = strlen (hexstr) / 2 + 3; - - buffer = g_malloc (buffer_len); - - if (nm_utils_hexstr2bin_full (hexstr, - FALSE, - delimiter_required, - delimiter_candidates, - required_len, - buffer, - buffer_len, - &len)) { - NM_SET_OUT (out_len, len); - return buffer; - } - - g_free (buffer); +nm_utils_hexstr2bin_alloc(const char *hexstr, + gboolean allow_0x_prefix, + gboolean delimiter_required, + const char *delimiter_candidates, + gsize required_len, + gsize * out_len) +{ + guint8 *buffer; + gsize buffer_len, len; + + if (G_UNLIKELY(!hexstr)) { + NM_SET_OUT(out_len, 0); + g_return_val_if_fail(hexstr, NULL); + } + + nm_assert(required_len > 0 || out_len); + + if (allow_0x_prefix && hexstr[0] == '0' && hexstr[1] == 'x') + hexstr += 2; + + if (!hexstr[0]) + goto fail; + + if (required_len > 0) + buffer_len = required_len; + else + buffer_len = strlen(hexstr) / 2 + 3; + + buffer = g_malloc(buffer_len); + + if (nm_utils_hexstr2bin_full(hexstr, + FALSE, + delimiter_required, + FALSE, + delimiter_candidates, + required_len, + buffer, + buffer_len, + &len)) { + NM_SET_OUT(out_len, len); + return buffer; + } + + g_free(buffer); fail: - NM_SET_OUT (out_len, 0); - return NULL; + NM_SET_OUT(out_len, 0); + return NULL; } /*****************************************************************************/ GVariant * -nm_utils_gvariant_vardict_filter (GVariant *src, - gboolean (*filter_fcn) (const char *key, - GVariant *val, - char **out_key, - GVariant **out_val, - gpointer user_data), - gpointer user_data) -{ - GVariantIter iter; - GVariantBuilder builder; - const char *key; - GVariant *val; - - g_return_val_if_fail (src && g_variant_is_of_type (src, G_VARIANT_TYPE_VARDICT), NULL); - g_return_val_if_fail (filter_fcn, NULL); - - g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); - - g_variant_iter_init (&iter, src); - while (g_variant_iter_next (&iter, "{&sv}", &key, &val)) { - _nm_unused gs_unref_variant GVariant *val_free = val; - gs_free char *key2 = NULL; - gs_unref_variant GVariant *val2 = NULL; - - if (filter_fcn (key, - val, - &key2, - &val2, - user_data)) { - g_variant_builder_add (&builder, - "{sv}", - key2 ?: key, - val2 ?: val); - } - } - - return g_variant_builder_end (&builder); +nm_utils_gvariant_vardict_filter(GVariant *src, + gboolean (*filter_fcn)(const char *key, + GVariant * val, + char ** out_key, + GVariant ** out_val, + gpointer user_data), + gpointer user_data) +{ + GVariantIter iter; + GVariantBuilder builder; + const char * key; + GVariant * val; + + g_return_val_if_fail(src && g_variant_is_of_type(src, G_VARIANT_TYPE_VARDICT), NULL); + g_return_val_if_fail(filter_fcn, NULL); + + g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); + + g_variant_iter_init(&iter, src); + while (g_variant_iter_next(&iter, "{&sv}", &key, &val)) { + _nm_unused gs_unref_variant GVariant *val_free = val; + gs_free char * key2 = NULL; + gs_unref_variant GVariant *val2 = NULL; + + if (filter_fcn(key, val, &key2, &val2, user_data)) { + g_variant_builder_add(&builder, "{sv}", key2 ?: key, val2 ?: val); + } + } + + return g_variant_builder_end(&builder); } static gboolean -_gvariant_vardict_filter_drop_one (const char *key, - GVariant *val, - char **out_key, - GVariant **out_val, - gpointer user_data) +_gvariant_vardict_filter_drop_one(const char *key, + GVariant * val, + char ** out_key, + GVariant ** out_val, + gpointer user_data) { - return !nm_streq (key, user_data); + return !nm_streq(key, user_data); } GVariant * -nm_utils_gvariant_vardict_filter_drop_one (GVariant *src, - const char *key) +nm_utils_gvariant_vardict_filter_drop_one(GVariant *src, const char *key) { - return nm_utils_gvariant_vardict_filter (src, - _gvariant_vardict_filter_drop_one, - (gpointer) key); + return nm_utils_gvariant_vardict_filter(src, _gvariant_vardict_filter_drop_one, (gpointer) key); } /*****************************************************************************/ static gboolean -debug_key_matches (const char *key, - const char *token, - guint length) +debug_key_matches(const char *key, const char *token, guint length) { - /* may not call GLib functions: see note in g_parse_debug_string() */ - for (; length; length--, key++, token++) { - char k = (*key == '_') ? '-' : g_ascii_tolower (*key ); - char t = (*token == '_') ? '-' : g_ascii_tolower (*token); + /* may not call GLib functions: see note in g_parse_debug_string() */ + for (; length; length--, key++, token++) { + char k = (*key == '_') ? '-' : g_ascii_tolower(*key); + char t = (*token == '_') ? '-' : g_ascii_tolower(*token); - if (k != t) - return FALSE; - } + if (k != t) + return FALSE; + } - return *key == '\0'; + return *key == '\0'; } /** @@ -4327,415 +4603,436 @@ debug_key_matches (const char *key, * Returns: the flags */ guint -nm_utils_parse_debug_string (const char *string, - const GDebugKey *keys, - guint nkeys) +nm_utils_parse_debug_string(const char *string, const GDebugKey *keys, guint nkeys) { - guint i; - guint result = 0; - const char *q; + guint i; + guint result = 0; + const char *q; - if (string == NULL) - return 0; + if (string == NULL) + return 0; - while (*string) { - q = strpbrk (string, ":;, \t"); - if (!q) - q = string + strlen (string); + while (*string) { + q = strpbrk(string, ":;, \t"); + if (!q) + q = string + strlen(string); - for (i = 0; i < nkeys; i++) { - if (debug_key_matches (keys[i].key, string, q - string)) - result |= keys[i].value; - } + for (i = 0; i < nkeys; i++) { + if (debug_key_matches(keys[i].key, string, q - string)) + result |= keys[i].value; + } - string = q; - if (*string) - string++; - } + string = q; + if (*string) + string++; + } - return result; + return result; } /*****************************************************************************/ GSource * -nm_g_idle_source_new (int priority, - GSourceFunc func, - gpointer user_data, - GDestroyNotify destroy_notify) +nm_g_idle_source_new(int priority, + GSourceFunc func, + gpointer user_data, + GDestroyNotify destroy_notify) { - GSource *source; + GSource *source; - source = g_idle_source_new (); - if (priority != G_PRIORITY_DEFAULT) - g_source_set_priority (source, priority); - g_source_set_callback (source, func, user_data, destroy_notify); - return source; + source = g_idle_source_new(); + if (priority != G_PRIORITY_DEFAULT) + g_source_set_priority(source, priority); + g_source_set_callback(source, func, user_data, destroy_notify); + return source; } GSource * -nm_g_timeout_source_new (guint timeout_msec, - int priority, - GSourceFunc func, - gpointer user_data, - GDestroyNotify destroy_notify) +nm_g_timeout_source_new(guint timeout_msec, + int priority, + GSourceFunc func, + gpointer user_data, + GDestroyNotify destroy_notify) { - GSource *source; + GSource *source; - source = g_timeout_source_new (timeout_msec); - if (priority != G_PRIORITY_DEFAULT) - g_source_set_priority (source, priority); - g_source_set_callback (source, func, user_data, destroy_notify); - return source; + source = g_timeout_source_new(timeout_msec); + if (priority != G_PRIORITY_DEFAULT) + g_source_set_priority(source, priority); + g_source_set_callback(source, func, user_data, destroy_notify); + return source; } GSource * -nm_g_unix_signal_source_new (int signum, - int priority, - GSourceFunc handler, - gpointer user_data, - GDestroyNotify notify) +nm_g_timeout_source_new_seconds(guint timeout_sec, + int priority, + GSourceFunc func, + gpointer user_data, + GDestroyNotify destroy_notify) { - GSource *source; + GSource *source; - source = g_unix_signal_source_new (signum); + source = g_timeout_source_new_seconds(timeout_sec); + if (priority != G_PRIORITY_DEFAULT) + g_source_set_priority(source, priority); + g_source_set_callback(source, func, user_data, destroy_notify); + return source; +} + +GSource * +nm_g_unix_signal_source_new(int signum, + int priority, + GSourceFunc handler, + gpointer user_data, + GDestroyNotify notify) +{ + GSource *source; + + source = g_unix_signal_source_new(signum); - if (priority != G_PRIORITY_DEFAULT) - g_source_set_priority (source, priority); - g_source_set_callback (source, handler, user_data, notify); - return source; + if (priority != G_PRIORITY_DEFAULT) + g_source_set_priority(source, priority); + g_source_set_callback(source, handler, user_data, notify); + return source; } GSource * -nm_g_unix_fd_source_new (int fd, - GIOCondition io_condition, - int priority, - gboolean (*source_func) (int fd, - GIOCondition condition, - gpointer user_data), - gpointer user_data, - GDestroyNotify destroy_notify) +nm_g_unix_fd_source_new(int fd, + GIOCondition io_condition, + int priority, + gboolean (*source_func)(int fd, GIOCondition condition, gpointer user_data), + gpointer user_data, + GDestroyNotify destroy_notify) { - GSource *source; + GSource *source; - source = g_unix_fd_source_new (fd, io_condition); + source = g_unix_fd_source_new(fd, io_condition); - if (priority != G_PRIORITY_DEFAULT) - g_source_set_priority (source, priority); - g_source_set_callback (source, G_SOURCE_FUNC (source_func), user_data, destroy_notify); - return source; + if (priority != G_PRIORITY_DEFAULT) + g_source_set_priority(source, priority); + g_source_set_callback(source, G_SOURCE_FUNC(source_func), user_data, destroy_notify); + return source; } /*****************************************************************************/ -#define _CTX_LOG(fmt, ...) \ - G_STMT_START { \ - if (FALSE) { \ - gint64 _ts = g_get_monotonic_time () / 100; \ - \ - g_printerr (">>>> [%"G_GINT64_FORMAT".%05"G_GINT64_FORMAT"] [src:%p]: " fmt "\n", \ - _ts / 10000, \ - _ts % 10000, \ - (ctx_src), \ - ##__VA_ARGS__); \ - } \ - } G_STMT_END +#define _CTX_LOG(fmt, ...) \ + G_STMT_START \ + { \ + if (FALSE) { \ + gint64 _ts = g_get_monotonic_time() / 100; \ + \ + g_printerr(">>>> [%" G_GINT64_FORMAT ".%05" G_GINT64_FORMAT "] [src:%p]: " fmt "\n", \ + _ts / 10000, \ + _ts % 10000, \ + (ctx_src), \ + ##__VA_ARGS__); \ + } \ + } \ + G_STMT_END typedef struct { - int fd; - guint events; - guint registered_events; - union { - int one; - int *many; - } idx; - gpointer tag; - bool stale:1; - bool has_many_idx:1; + int fd; + guint events; + guint registered_events; + union { + int one; + int *many; + } idx; + gpointer tag; + bool stale : 1; + bool has_many_idx : 1; } PollData; typedef struct { - GSource source; - GMainContext *context; - GHashTable *fds; - GPollFD *fds_arr; - int fds_len; - int max_priority; - bool acquired:1; + GSource source; + GMainContext *context; + GHashTable * fds; + GPollFD * fds_arr; + int fds_len; + int max_priority; + bool acquired : 1; } CtxIntegSource; static void -_poll_data_free (gpointer user_data) +_poll_data_free(gpointer user_data) { - PollData *poll_data = user_data; + PollData *poll_data = user_data; - if (poll_data->has_many_idx) - g_free (poll_data->idx.many); - nm_g_slice_free (poll_data); + if (poll_data->has_many_idx) + g_free(poll_data->idx.many); + nm_g_slice_free(poll_data); } static void -_ctx_integ_source_reacquire (CtxIntegSource *ctx_src) +_ctx_integ_source_reacquire(CtxIntegSource *ctx_src) { - if (G_LIKELY ( ctx_src->acquired - && g_main_context_is_owner (ctx_src->context))) - return; + if (G_LIKELY(ctx_src->acquired && g_main_context_is_owner(ctx_src->context))) + return; - /* the parent context now iterates on a different thread. - * We need to release and reacquire the inner context. */ + /* the parent context now iterates on a different thread. + * We need to release and reacquire the inner context. */ - if (ctx_src->acquired) - g_main_context_release (ctx_src->context); + if (ctx_src->acquired) + g_main_context_release(ctx_src->context); - if (G_UNLIKELY (!g_main_context_acquire (ctx_src->context))) { - /* Nobody is supposed to reacquire the context while we use it. This is a bug - * of the user. */ - ctx_src->acquired = FALSE; - g_return_if_reached (); - } - ctx_src->acquired = TRUE; + if (G_UNLIKELY(!g_main_context_acquire(ctx_src->context))) { + /* Nobody is supposed to reacquire the context while we use it. This is a bug + * of the user. */ + ctx_src->acquired = FALSE; + g_return_if_reached(); + } + ctx_src->acquired = TRUE; } static gboolean -_ctx_integ_source_prepare (GSource *source, - int *out_timeout) -{ - CtxIntegSource *ctx_src = ((CtxIntegSource *) source); - int max_priority; - int timeout = -1; - gboolean any_ready; - int fds_allocated; - int fds_len_old; - gs_free GPollFD *fds_arr_old = NULL; - GHashTableIter h_iter; - PollData *poll_data; - gboolean fds_changed; - int i; - - _CTX_LOG ("prepare..."); - - _ctx_integ_source_reacquire (ctx_src); - - any_ready = g_main_context_prepare (ctx_src->context, &max_priority); - - fds_arr_old = g_steal_pointer (&ctx_src->fds_arr); - fds_len_old = ctx_src->fds_len; - - fds_allocated = NM_MAX (1, fds_len_old); /* there is at least the wakeup's FD */ - ctx_src->fds_arr = g_new (GPollFD, fds_allocated); - - while ((ctx_src->fds_len = g_main_context_query (ctx_src->context, - max_priority, - &timeout, - ctx_src->fds_arr, - fds_allocated)) > fds_allocated) { - fds_allocated = ctx_src->fds_len; - g_free (ctx_src->fds_arr); - ctx_src->fds_arr = g_new (GPollFD, fds_allocated); - } - - fds_changed = FALSE; - if (fds_len_old != ctx_src->fds_len) - fds_changed = TRUE; - else { - for (i = 0; i < ctx_src->fds_len; i++) { - if ( fds_arr_old[i].fd != ctx_src->fds_arr[i].fd - || fds_arr_old[i].events != ctx_src->fds_arr[i].events) { - fds_changed = TRUE; - break; - } - } - } - - if (G_UNLIKELY (fds_changed)) { - - g_hash_table_iter_init (&h_iter, ctx_src->fds); - while (g_hash_table_iter_next (&h_iter, (gpointer *) &poll_data, NULL)) - poll_data->stale = TRUE; - - for (i = 0; i < ctx_src->fds_len; i++) { - const GPollFD *fd = &ctx_src->fds_arr[i]; - - poll_data = g_hash_table_lookup (ctx_src->fds, &fd->fd); - - if (G_UNLIKELY (!poll_data)) { - poll_data = g_slice_new (PollData); - *poll_data = (PollData) { - .fd = fd->fd, - .idx.one = i, - .has_many_idx = FALSE, - .events = fd->events, - .registered_events = 0, - .tag = NULL, - .stale = FALSE, - }; - g_hash_table_add (ctx_src->fds, poll_data); - nm_assert (poll_data == g_hash_table_lookup (ctx_src->fds, &fd->fd)); - continue; - } - - if (G_LIKELY (poll_data->stale)) { - if (poll_data->has_many_idx) { - g_free (poll_data->idx.many); - poll_data->has_many_idx = FALSE; - } - poll_data->events = fd->events; - poll_data->idx.one = i; - poll_data->stale = FALSE; - continue; - } - - /* How odd. We have duplicate FDs. In fact, currently g_main_context_query() always - * coalesces the FDs and this cannot happen. However, that is not documented behavior, - * so we should not rely on that. So we need to keep a list of indexes... */ - poll_data->events |= fd->events; - if (!poll_data->has_many_idx) { - int idx0; - - idx0 = poll_data->idx.one; - poll_data->has_many_idx = TRUE; - poll_data->idx.many = g_new (int, 4); - poll_data->idx.many[0] = 2; /* number allocated */ - poll_data->idx.many[1] = 2; /* number used */ - poll_data->idx.many[2] = idx0; - poll_data->idx.many[3] = i; - } else { - if (poll_data->idx.many[0] == poll_data->idx.many[1]) { - poll_data->idx.many[0] *= 2; - poll_data->idx.many = g_realloc (poll_data->idx.many, sizeof (int) * (2 + poll_data->idx.many[0])); - } - poll_data->idx.many[2 + poll_data->idx.many[1]] = i; - poll_data->idx.many[1]++; - } - - } - - g_hash_table_iter_init (&h_iter, ctx_src->fds); - while (g_hash_table_iter_next (&h_iter, (gpointer *) &poll_data, NULL)) { - if (poll_data->stale) { - nm_assert (poll_data->tag); - nm_assert (poll_data->events == poll_data->registered_events); - _CTX_LOG ("prepare: remove poll fd=%d, events=0x%x", poll_data->fd, poll_data->events); - g_source_remove_unix_fd (&ctx_src->source, poll_data->tag); - g_hash_table_iter_remove (&h_iter); - continue; - } - if (!poll_data->tag) { - _CTX_LOG ("prepare: add poll fd=%d, events=0x%x", poll_data->fd, poll_data->events); - poll_data->registered_events = poll_data->events; - poll_data->tag = g_source_add_unix_fd (&ctx_src->source, poll_data->fd, poll_data->registered_events); - continue; - } - if (poll_data->registered_events != poll_data->events) { - _CTX_LOG ("prepare: update poll fd=%d, events=0x%x", poll_data->fd, poll_data->events); - poll_data->registered_events = poll_data->events; - g_source_modify_unix_fd (&ctx_src->source, poll_data->tag, poll_data->registered_events); - } - } - } - - NM_SET_OUT (out_timeout, timeout); - ctx_src->max_priority = max_priority; - - _CTX_LOG ("prepare: done, any-ready=%d, timeout=%d, max-priority=%d", any_ready, timeout, max_priority); - - /* we always need to poll, because we have some file descriptors. */ - return FALSE; +_ctx_integ_source_prepare(GSource *source, int *out_timeout) +{ + CtxIntegSource *ctx_src = ((CtxIntegSource *) source); + int max_priority; + int timeout = -1; + gboolean any_ready; + int fds_allocated; + int fds_len_old; + gs_free GPollFD *fds_arr_old = NULL; + GHashTableIter h_iter; + PollData * poll_data; + gboolean fds_changed; + int i; + + _CTX_LOG("prepare..."); + + _ctx_integ_source_reacquire(ctx_src); + + any_ready = g_main_context_prepare(ctx_src->context, &max_priority); + + fds_arr_old = g_steal_pointer(&ctx_src->fds_arr); + fds_len_old = ctx_src->fds_len; + + fds_allocated = NM_MAX(1, fds_len_old); /* there is at least the wakeup's FD */ + ctx_src->fds_arr = g_new(GPollFD, fds_allocated); + + while ((ctx_src->fds_len = g_main_context_query(ctx_src->context, + max_priority, + &timeout, + ctx_src->fds_arr, + fds_allocated)) + > fds_allocated) { + fds_allocated = ctx_src->fds_len; + g_free(ctx_src->fds_arr); + ctx_src->fds_arr = g_new(GPollFD, fds_allocated); + } + + fds_changed = FALSE; + if (fds_len_old != ctx_src->fds_len) + fds_changed = TRUE; + else { + for (i = 0; i < ctx_src->fds_len; i++) { + if (fds_arr_old[i].fd != ctx_src->fds_arr[i].fd + || fds_arr_old[i].events != ctx_src->fds_arr[i].events) { + fds_changed = TRUE; + break; + } + } + } + + if (G_UNLIKELY(fds_changed)) { + g_hash_table_iter_init(&h_iter, ctx_src->fds); + while (g_hash_table_iter_next(&h_iter, (gpointer *) &poll_data, NULL)) + poll_data->stale = TRUE; + + for (i = 0; i < ctx_src->fds_len; i++) { + const GPollFD *fd = &ctx_src->fds_arr[i]; + + poll_data = g_hash_table_lookup(ctx_src->fds, &fd->fd); + + if (G_UNLIKELY(!poll_data)) { + poll_data = g_slice_new(PollData); + *poll_data = (PollData){ + .fd = fd->fd, + .idx.one = i, + .has_many_idx = FALSE, + .events = fd->events, + .registered_events = 0, + .tag = NULL, + .stale = FALSE, + }; + g_hash_table_add(ctx_src->fds, poll_data); + nm_assert(poll_data == g_hash_table_lookup(ctx_src->fds, &fd->fd)); + continue; + } + + if (G_LIKELY(poll_data->stale)) { + if (poll_data->has_many_idx) { + g_free(poll_data->idx.many); + poll_data->has_many_idx = FALSE; + } + poll_data->events = fd->events; + poll_data->idx.one = i; + poll_data->stale = FALSE; + continue; + } + + /* How odd. We have duplicate FDs. In fact, currently g_main_context_query() always + * coalesces the FDs and this cannot happen. However, that is not documented behavior, + * so we should not rely on that. So we need to keep a list of indexes... */ + poll_data->events |= fd->events; + if (!poll_data->has_many_idx) { + int idx0; + + idx0 = poll_data->idx.one; + poll_data->has_many_idx = TRUE; + poll_data->idx.many = g_new(int, 4); + poll_data->idx.many[0] = 2; /* number allocated */ + poll_data->idx.many[1] = 2; /* number used */ + poll_data->idx.many[2] = idx0; + poll_data->idx.many[3] = i; + } else { + if (poll_data->idx.many[0] == poll_data->idx.many[1]) { + poll_data->idx.many[0] *= 2; + poll_data->idx.many = + g_realloc(poll_data->idx.many, sizeof(int) * (2 + poll_data->idx.many[0])); + } + poll_data->idx.many[2 + poll_data->idx.many[1]] = i; + poll_data->idx.many[1]++; + } + } + + g_hash_table_iter_init(&h_iter, ctx_src->fds); + while (g_hash_table_iter_next(&h_iter, (gpointer *) &poll_data, NULL)) { + if (poll_data->stale) { + nm_assert(poll_data->tag); + nm_assert(poll_data->events == poll_data->registered_events); + _CTX_LOG("prepare: remove poll fd=%d, events=0x%x", + poll_data->fd, + poll_data->events); + g_source_remove_unix_fd(&ctx_src->source, poll_data->tag); + g_hash_table_iter_remove(&h_iter); + continue; + } + if (!poll_data->tag) { + _CTX_LOG("prepare: add poll fd=%d, events=0x%x", poll_data->fd, poll_data->events); + poll_data->registered_events = poll_data->events; + poll_data->tag = g_source_add_unix_fd(&ctx_src->source, + poll_data->fd, + poll_data->registered_events); + continue; + } + if (poll_data->registered_events != poll_data->events) { + _CTX_LOG("prepare: update poll fd=%d, events=0x%x", + poll_data->fd, + poll_data->events); + poll_data->registered_events = poll_data->events; + g_source_modify_unix_fd(&ctx_src->source, + poll_data->tag, + poll_data->registered_events); + } + } + } + + NM_SET_OUT(out_timeout, timeout); + ctx_src->max_priority = max_priority; + + _CTX_LOG("prepare: done, any-ready=%d, timeout=%d, max-priority=%d", + any_ready, + timeout, + max_priority); + + /* we always need to poll, because we have some file descriptors. */ + return FALSE; } static gboolean -_ctx_integ_source_check (GSource *source) +_ctx_integ_source_check(GSource *source) { - CtxIntegSource *ctx_src = ((CtxIntegSource *) source); - GHashTableIter h_iter; - gboolean some_ready; - PollData *poll_data; + CtxIntegSource *ctx_src = ((CtxIntegSource *) source); + GHashTableIter h_iter; + gboolean some_ready; + PollData * poll_data; - nm_assert (ctx_src->context); + nm_assert(ctx_src->context); - _CTX_LOG ("check"); + _CTX_LOG("check"); - _ctx_integ_source_reacquire (ctx_src); + _ctx_integ_source_reacquire(ctx_src); - g_hash_table_iter_init (&h_iter, ctx_src->fds); - while (g_hash_table_iter_next (&h_iter, (gpointer *) &poll_data, NULL)) { - guint revents; + g_hash_table_iter_init(&h_iter, ctx_src->fds); + while (g_hash_table_iter_next(&h_iter, (gpointer *) &poll_data, NULL)) { + guint revents; - revents = g_source_query_unix_fd (&ctx_src->source, poll_data->tag); - if (G_UNLIKELY (poll_data->has_many_idx)) { - int num = poll_data->idx.many[1]; - int *p_idx = &poll_data->idx.many[2]; + revents = g_source_query_unix_fd(&ctx_src->source, poll_data->tag); + if (G_UNLIKELY(poll_data->has_many_idx)) { + int num = poll_data->idx.many[1]; + int *p_idx = &poll_data->idx.many[2]; - for (; num > 0; num--, p_idx++) - ctx_src->fds_arr[*p_idx].revents = revents; - } else - ctx_src->fds_arr[poll_data->idx.one].revents = revents; - } + for (; num > 0; num--, p_idx++) + ctx_src->fds_arr[*p_idx].revents = revents; + } else + ctx_src->fds_arr[poll_data->idx.one].revents = revents; + } - some_ready = g_main_context_check (ctx_src->context, - ctx_src->max_priority, - ctx_src->fds_arr, - ctx_src->fds_len); + some_ready = g_main_context_check(ctx_src->context, + ctx_src->max_priority, + ctx_src->fds_arr, + ctx_src->fds_len); - _CTX_LOG ("check (some-ready=%d)...", some_ready); + _CTX_LOG("check (some-ready=%d)...", some_ready); - return some_ready; + return some_ready; } static gboolean -_ctx_integ_source_dispatch (GSource *source, - GSourceFunc callback, - gpointer user_data) +_ctx_integ_source_dispatch(GSource *source, GSourceFunc callback, gpointer user_data) { - CtxIntegSource *ctx_src = ((CtxIntegSource *) source); + CtxIntegSource *ctx_src = ((CtxIntegSource *) source); - nm_assert (ctx_src->context); + nm_assert(ctx_src->context); - _ctx_integ_source_reacquire (ctx_src); + _ctx_integ_source_reacquire(ctx_src); - _CTX_LOG ("dispatch"); + _CTX_LOG("dispatch"); - g_main_context_dispatch (ctx_src->context); + g_main_context_dispatch(ctx_src->context); - return G_SOURCE_CONTINUE; + return G_SOURCE_CONTINUE; } static void -_ctx_integ_source_finalize (GSource *source) +_ctx_integ_source_finalize(GSource *source) { - CtxIntegSource *ctx_src = ((CtxIntegSource *) source); - GHashTableIter h_iter; - PollData *poll_data; + CtxIntegSource *ctx_src = ((CtxIntegSource *) source); + GHashTableIter h_iter; + PollData * poll_data; - g_return_if_fail (ctx_src->context); + g_return_if_fail(ctx_src->context); - _CTX_LOG ("finalize..."); + _CTX_LOG("finalize..."); - g_hash_table_iter_init (&h_iter, ctx_src->fds); - while (g_hash_table_iter_next (&h_iter, (gpointer *) &poll_data, NULL)) { - nm_assert (poll_data->tag); - _CTX_LOG ("prepare: remove poll fd=%d, events=0x%x", poll_data->fd, poll_data->events); - g_source_remove_unix_fd (&ctx_src->source, poll_data->tag); - g_hash_table_iter_remove (&h_iter); - } + g_hash_table_iter_init(&h_iter, ctx_src->fds); + while (g_hash_table_iter_next(&h_iter, (gpointer *) &poll_data, NULL)) { + nm_assert(poll_data->tag); + _CTX_LOG("prepare: remove poll fd=%d, events=0x%x", poll_data->fd, poll_data->events); + g_source_remove_unix_fd(&ctx_src->source, poll_data->tag); + g_hash_table_iter_remove(&h_iter); + } - nm_clear_pointer (&ctx_src->fds, g_hash_table_unref); - nm_clear_g_free (&ctx_src->fds_arr); - ctx_src->fds_len = 0; + nm_clear_pointer(&ctx_src->fds, g_hash_table_unref); + nm_clear_g_free(&ctx_src->fds_arr); + ctx_src->fds_len = 0; - if (ctx_src->acquired) { - ctx_src->acquired = FALSE; - g_main_context_release (ctx_src->context); - } + if (ctx_src->acquired) { + ctx_src->acquired = FALSE; + g_main_context_release(ctx_src->context); + } - nm_clear_pointer (&ctx_src->context, g_main_context_unref); + nm_clear_pointer(&ctx_src->context, g_main_context_unref); } static GSourceFuncs ctx_integ_source_funcs = { - .prepare = _ctx_integ_source_prepare, - .check = _ctx_integ_source_check, - .dispatch = _ctx_integ_source_dispatch, - .finalize = _ctx_integ_source_finalize, + .prepare = _ctx_integ_source_prepare, + .check = _ctx_integ_source_check, + .dispatch = _ctx_integ_source_dispatch, + .finalize = _ctx_integ_source_finalize, }; /** @@ -4760,260 +5057,260 @@ static GSourceFuncs ctx_integ_source_funcs = { * outer context. */ GSource * -nm_utils_g_main_context_create_integrate_source (GMainContext *inner_context) +nm_utils_g_main_context_create_integrate_source(GMainContext *inner_context) { - CtxIntegSource *ctx_src; + CtxIntegSource *ctx_src; - g_return_val_if_fail (inner_context, NULL); + g_return_val_if_fail(inner_context, NULL); - if (!g_main_context_acquire (inner_context)) { - /* We require to acquire the context while it's integrated. We need to keep it acquired - * for the entire duration. - * - * This is also necessary because g_source_attach() only wakes up the context, if - * the context is currently acquired. */ - g_return_val_if_reached (NULL); - } + if (!g_main_context_acquire(inner_context)) { + /* We require to acquire the context while it's integrated. We need to keep it acquired + * for the entire duration. + * + * This is also necessary because g_source_attach() only wakes up the context, if + * the context is currently acquired. */ + g_return_val_if_reached(NULL); + } - ctx_src = (CtxIntegSource *) g_source_new (&ctx_integ_source_funcs, sizeof (CtxIntegSource)); + ctx_src = (CtxIntegSource *) g_source_new(&ctx_integ_source_funcs, sizeof(CtxIntegSource)); - g_source_set_name (&ctx_src->source, "ContextIntegrateSource"); + g_source_set_name(&ctx_src->source, "ContextIntegrateSource"); - ctx_src->context = g_main_context_ref (inner_context); - ctx_src->fds = g_hash_table_new_full (nm_pint_hash, nm_pint_equals, _poll_data_free, NULL); - ctx_src->fds_len = 0; - ctx_src->fds_arr = NULL; - ctx_src->acquired = TRUE; - ctx_src->max_priority = G_MAXINT; + ctx_src->context = g_main_context_ref(inner_context); + ctx_src->fds = g_hash_table_new_full(nm_pint_hash, nm_pint_equals, _poll_data_free, NULL); + ctx_src->fds_len = 0; + ctx_src->fds_arr = NULL; + ctx_src->acquired = TRUE; + ctx_src->max_priority = G_MAXINT; - _CTX_LOG ("create new integ-source for %p", inner_context); + _CTX_LOG("create new integ-source for %p", inner_context); - return &ctx_src->source; + return &ctx_src->source; } gboolean -nm_utils_ifname_valid_kernel (const char *name, GError **error) -{ - int i; - - /* This function follows kernel's interface validation - * function dev_valid_name() in net/core/dev.c. - */ - - if (!name) { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name is missing")); - return FALSE; - } - - if (name[0] == '\0') { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name is too short")); - return FALSE; - } - - if ( name[0] == '.' - && ( name[1] == '\0' - || ( name[1] == '.' - && name[2] == '\0'))) { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name is reserved")); - return FALSE; - } - - for (i = 0; i < IFNAMSIZ; i++) { - char ch = name[i]; - - if (ch == '\0') - return TRUE; - if ( NM_IN_SET (ch, '/', ':') - || g_ascii_isspace (ch)) { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name contains an invalid character")); - return FALSE; - } - } - - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name is longer than 15 characters")); - return FALSE; +nm_utils_ifname_valid_kernel(const char *name, GError **error) +{ + int i; + + /* This function follows kernel's interface validation + * function dev_valid_name() in net/core/dev.c. + */ + + if (!name) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name is missing")); + return FALSE; + } + + if (name[0] == '\0') { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name is too short")); + return FALSE; + } + + if (name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0'))) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name is reserved")); + return FALSE; + } + + for (i = 0; i < IFNAMSIZ; i++) { + char ch = name[i]; + + if (ch == '\0') + return TRUE; + if (NM_IN_SET(ch, '/', ':') || g_ascii_isspace(ch)) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name contains an invalid character")); + return FALSE; + } + } + + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name is longer than 15 characters")); + return FALSE; } /*****************************************************************************/ static gboolean -_nm_utils_ifname_valid_kernel (const char *name, GError **error) -{ - if (!nm_utils_ifname_valid_kernel (name, error)) - return FALSE; - - if (strchr (name, '%')) { - /* Kernel's dev_valid_name() accepts (almost) any binary up to 15 chars. - * However, '%' is treated special as a format specifier. Try - * - * ip link add 'dummy%dx' type dummy - * - * Don't allow that for "connection.interface-name", which either - * matches an existing netdev name (thus, it cannot have a '%') or - * is used to configure a name (in which case we don't want kernel - * to replace the format specifier). */ - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("'%%' is not allowed in interface names")); - return FALSE; - } - - if (NM_IN_STRSET (name, "all", - "default", - "bonding_masters")) { - /* Certain names are not allowed. The "all" and "default" names are reserved - * due to their directories in "/proc/sys/net/ipv4/conf/" and "/proc/sys/net/ipv6/conf/". - * - * Also, there is "/sys/class/net/bonding_masters" file. - */ - nm_utils_error_set (error, NM_UTILS_ERROR_UNKNOWN, - _("'%s' is not allowed as interface name"), name); - return FALSE; - } - - return TRUE; +_nm_utils_ifname_valid_kernel(const char *name, GError **error) +{ + if (!nm_utils_ifname_valid_kernel(name, error)) + return FALSE; + + if (strchr(name, '%')) { + /* Kernel's dev_valid_name() accepts (almost) any binary up to 15 chars. + * However, '%' is treated special as a format specifier. Try + * + * ip link add 'dummy%dx' type dummy + * + * Don't allow that for "connection.interface-name", which either + * matches an existing netdev name (thus, it cannot have a '%') or + * is used to configure a name (in which case we don't want kernel + * to replace the format specifier). */ + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("'%%' is not allowed in interface names")); + return FALSE; + } + + if (NM_IN_STRSET(name, "all", "default", "bonding_masters")) { + /* Certain names are not allowed. The "all" and "default" names are reserved + * due to their directories in "/proc/sys/net/ipv4/conf/" and "/proc/sys/net/ipv6/conf/". + * + * Also, there is "/sys/class/net/bonding_masters" file. + */ + nm_utils_error_set(error, + NM_UTILS_ERROR_UNKNOWN, + _("'%s' is not allowed as interface name"), + name); + return FALSE; + } + + return TRUE; } static gboolean -_nm_utils_ifname_valid_ovs (const char *name, GError **error) -{ - const char *ch; - - /* OVS actually accepts a wider range of chars (all printable UTF-8 chars), - NetworkManager restricts this to ASCII char as it's a safer option for - now since OVS is not well documented on this matter. - */ - for (ch = name; *ch; ++ch) { - if ( *ch == '\\' - || *ch == '/' - || !g_ascii_isgraph (*ch)) { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name must be alphanumerical with " - "no forward or backward slashes")); - return FALSE; - } - }; - return TRUE; +_nm_utils_ifname_valid_ovs(const char *name, GError **error) +{ + const char *ch; + + /* OVS actually accepts a wider range of chars (all printable UTF-8 chars), + * NetworkManager restricts this to ASCII char as it's a safer option for + * now since OVS is not well documented on this matter. + **/ + for (ch = name; *ch; ++ch) { + if (*ch == '\\' || *ch == '/' || !g_ascii_isgraph(*ch)) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name must be alphanumerical with " + "no forward or backward slashes")); + return FALSE; + } + }; + return TRUE; } gboolean -nm_utils_ifname_valid (const char* name, - NMUtilsIfaceType type, - GError **error) -{ - g_return_val_if_fail (!error || !(*error), FALSE); - - if (!name || !(name[0])) { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name must not be empty")); - return FALSE; - } - - if (!g_utf8_validate (name, -1, NULL)) { - g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN, - _("interface name must be UTF-8 encoded")); - return FALSE; - } - - switch (type) { - case NMU_IFACE_KERNEL: - return _nm_utils_ifname_valid_kernel (name, error); - case NMU_IFACE_OVS: - return _nm_utils_ifname_valid_ovs (name, error); - case NMU_IFACE_OVS_AND_KERNEL: - return _nm_utils_ifname_valid_kernel (name, error) - && _nm_utils_ifname_valid_ovs (name, error); - case NMU_IFACE_ANY: { - gs_free_error GError *local = NULL; - - if (_nm_utils_ifname_valid_kernel (name, error ? &local : NULL)) - return TRUE; - if (_nm_utils_ifname_valid_ovs (name, NULL)) - return TRUE; - if (error) - g_propagate_error (error, g_steal_pointer (&local)); - return FALSE; - } - } - - g_return_val_if_reached (FALSE); +nm_utils_ifname_valid(const char *name, NMUtilsIfaceType type, GError **error) +{ + g_return_val_if_fail(!error || !(*error), FALSE); + + if (!name || !(name[0])) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name must not be empty")); + return FALSE; + } + + if (!g_utf8_validate(name, -1, NULL)) { + g_set_error_literal(error, + NM_UTILS_ERROR, + NM_UTILS_ERROR_UNKNOWN, + _("interface name must be UTF-8 encoded")); + return FALSE; + } + + switch (type) { + case NMU_IFACE_KERNEL: + return _nm_utils_ifname_valid_kernel(name, error); + case NMU_IFACE_OVS: + return _nm_utils_ifname_valid_ovs(name, error); + case NMU_IFACE_OVS_AND_KERNEL: + return _nm_utils_ifname_valid_kernel(name, error) + && _nm_utils_ifname_valid_ovs(name, error); + case NMU_IFACE_ANY: + { + gs_free_error GError *local = NULL; + + if (_nm_utils_ifname_valid_kernel(name, error ? &local : NULL)) + return TRUE; + if (_nm_utils_ifname_valid_ovs(name, NULL)) + return TRUE; + if (error) + g_propagate_error(error, g_steal_pointer(&local)); + return FALSE; + } + } + + g_return_val_if_reached(FALSE); } /*****************************************************************************/ void -_nm_str_buf_ensure_size (NMStrBuf *strbuf, - gsize new_size, - gboolean reserve_exact) +_nm_str_buf_ensure_size(NMStrBuf *strbuf, gsize new_size, gboolean reserve_exact) { - _nm_str_buf_assert (strbuf); + _nm_str_buf_assert(strbuf); - /* Currently this only supports strictly growing the buffer. */ - nm_assert (new_size > strbuf->_priv_allocated); + /* Currently, this only supports strictly growing the buffer. */ + nm_assert(new_size > strbuf->_priv_allocated); - if (!reserve_exact) { - new_size = nm_utils_get_next_realloc_size (!strbuf->_priv_do_bzero_mem, - new_size); - } + if (!reserve_exact) { + new_size = nm_utils_get_next_realloc_size(!strbuf->_priv_do_bzero_mem, new_size); + } - strbuf->_priv_str = nm_secret_mem_realloc (strbuf->_priv_str, - strbuf->_priv_do_bzero_mem, - strbuf->_priv_allocated, - new_size); - strbuf->_priv_allocated = new_size; + strbuf->_priv_str = nm_secret_mem_realloc(strbuf->_priv_str, + strbuf->_priv_do_bzero_mem, + strbuf->_priv_allocated, + new_size); + strbuf->_priv_allocated = new_size; } void -nm_str_buf_append_printf (NMStrBuf *strbuf, - const char *format, - ...) +nm_str_buf_append_printf(NMStrBuf *strbuf, const char *format, ...) { - va_list args; - gsize available; - int l; + va_list args; + gsize available; + int l; - _nm_str_buf_assert (strbuf); + _nm_str_buf_assert(strbuf); - available = strbuf->_priv_allocated - strbuf->_priv_len; + available = strbuf->_priv_allocated - strbuf->_priv_len; - nm_assert (available < G_MAXULONG); + nm_assert(available < G_MAXULONG); - va_start (args, format); - l = g_vsnprintf (&strbuf->_priv_str[strbuf->_priv_len], - available, - format, - args); - va_end (args); + va_start(args, format); + l = g_vsnprintf(&strbuf->_priv_str[strbuf->_priv_len], available, format, args); + va_end(args); - nm_assert (l >= 0); - nm_assert (l < G_MAXINT); + nm_assert(l >= 0); + nm_assert(l < G_MAXINT); - if ((gsize) l >= available) { - gsize l2; + if ((gsize) l >= available) { + gsize l2; - if (l == 0) - return; + if (l == 0) + return; - l2 = ((gsize) l) + 1u; + l2 = ((gsize) l) + 1u; - nm_str_buf_maybe_expand (strbuf, l2, FALSE); + nm_str_buf_maybe_expand(strbuf, l2, FALSE); - va_start (args, format); - l = g_vsnprintf (&strbuf->_priv_str[strbuf->_priv_len], - l2, - format, - args); - va_end (args); + va_start(args, format); + l = g_vsnprintf(&strbuf->_priv_str[strbuf->_priv_len], l2, format, args); + va_end(args); - nm_assert (l >= 0); - nm_assert ((gsize) l == l2 - 1u); - } + nm_assert(l >= 0); + nm_assert((gsize) l == l2 - 1u); + } - strbuf->_priv_len += (gsize) l; + strbuf->_priv_len += (gsize) l; } /*****************************************************************************/ @@ -5029,109 +5326,285 @@ nm_str_buf_append_printf (NMStrBuf *strbuf, * the first pointer. */ void -nm_indirect_g_free (gpointer arg) +nm_indirect_g_free(gpointer arg) { - gpointer *p = arg; + gpointer *p = arg; - nm_clear_g_free (p); + nm_clear_g_free(p); } /*****************************************************************************/ static char * -attribute_escape (const char *src, char c1, char c2) +attribute_escape(const char *src, char c1, char c2) { - char *ret, *dest; + char *ret, *dest; - dest = ret = g_malloc (strlen (src) * 2 + 1); + dest = ret = g_malloc(strlen(src) * 2 + 1); - while (*src) { - if (*src == c1 || *src == c2 || *src == '\\') - *dest++ = '\\'; - *dest++ = *src++; - } - *dest++ = '\0'; + while (*src) { + if (*src == c1 || *src == c2 || *src == '\\') + *dest++ = '\\'; + *dest++ = *src++; + } + *dest++ = '\0'; - return ret; + return ret; } void -_nm_utils_format_variant_attributes_full (GString *str, - const NMUtilsNamedValue *values, - guint num_values, - char attr_separator, - char key_value_separator) -{ - const char *name, *value; - GVariant *variant; - char *escaped; - char buf[64]; - char sep = 0; - guint i; - - for (i = 0; i < num_values; i++) { - name = values[i].name; - variant = (GVariant *) values[i].value_ptr; - value = NULL; - - if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32)) - value = nm_sprintf_buf (buf, "%u", g_variant_get_uint32 (variant)); - else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32)) - value = nm_sprintf_buf (buf, "%d", (int) g_variant_get_int32 (variant)); - else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64)) - value = nm_sprintf_buf (buf, "%"G_GUINT64_FORMAT, g_variant_get_uint64 (variant)); - else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE)) - value = nm_sprintf_buf (buf, "%hhu", g_variant_get_byte (variant)); - else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN)) - value = g_variant_get_boolean (variant) ? "true" : "false"; - else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING)) - value = g_variant_get_string (variant, NULL); - else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTESTRING)) { - /* FIXME: there is no guarantee that the byte array - * is valid UTF-8.*/ - value = g_variant_get_bytestring (variant); - } else - continue; - - if (sep) - g_string_append_c (str, sep); - - escaped = attribute_escape (name, attr_separator, key_value_separator); - g_string_append (str, escaped); - g_free (escaped); - - g_string_append_c (str, key_value_separator); - - escaped = attribute_escape (value, attr_separator, key_value_separator); - g_string_append (str, escaped); - g_free (escaped); - - sep = attr_separator; - } +_nm_utils_format_variant_attributes_full(GString * str, + const NMUtilsNamedValue * values, + guint num_values, + const NMVariantAttributeSpec *const *spec, + char attr_separator, + char key_value_separator) +{ + const NMVariantAttributeSpec *const *s; + const char * name, *value; + GVariant * variant; + char * escaped; + char buf[64]; + char sep = 0; + guint i; + + for (i = 0; i < num_values; i++) { + name = values[i].name; + variant = values[i].value_ptr; + value = NULL; + s = NULL; + + if (spec) { + for (s = spec; *s; s++) { + if (nm_streq0((*s)->name, name)) + break; + } + + if (!*s) + continue; + } + + if (g_variant_is_of_type(variant, G_VARIANT_TYPE_UINT32)) + value = nm_sprintf_buf(buf, "%u", g_variant_get_uint32(variant)); + else if (g_variant_is_of_type(variant, G_VARIANT_TYPE_INT32)) + value = nm_sprintf_buf(buf, "%d", (int) g_variant_get_int32(variant)); + else if (g_variant_is_of_type(variant, G_VARIANT_TYPE_UINT64)) + value = nm_sprintf_buf(buf, "%" G_GUINT64_FORMAT, g_variant_get_uint64(variant)); + else if (g_variant_is_of_type(variant, G_VARIANT_TYPE_BYTE)) + value = nm_sprintf_buf(buf, "%hhu", g_variant_get_byte(variant)); + else if (g_variant_is_of_type(variant, G_VARIANT_TYPE_BOOLEAN)) + value = g_variant_get_boolean(variant) ? "true" : "false"; + else if (g_variant_is_of_type(variant, G_VARIANT_TYPE_STRING)) + value = g_variant_get_string(variant, NULL); + else if (g_variant_is_of_type(variant, G_VARIANT_TYPE_BYTESTRING)) { + /* FIXME: there is no guarantee that the byte array + * is valid UTF-8.*/ + value = g_variant_get_bytestring(variant); + } else + continue; + + if (sep) + g_string_append_c(str, sep); + + escaped = attribute_escape(name, attr_separator, key_value_separator); + g_string_append(str, escaped); + g_free(escaped); + + if (!s || !*s || !(*s)->no_value) { + g_string_append_c(str, key_value_separator); + + escaped = attribute_escape(value, attr_separator, key_value_separator); + g_string_append(str, escaped); + g_free(escaped); + } + + sep = attr_separator; + } } char * -_nm_utils_format_variant_attributes (GHashTable *attributes, - char attr_separator, - char key_value_separator) +_nm_utils_format_variant_attributes(GHashTable * attributes, + const NMVariantAttributeSpec *const *spec, + char attr_separator, + char key_value_separator) { - GString *str = NULL; - gs_free NMUtilsNamedValue *values = NULL; - guint len; + gs_free NMUtilsNamedValue *values_free = NULL; + NMUtilsNamedValue values_prepared[20]; + const NMUtilsNamedValue * values; + GString * str = NULL; + guint len; + + g_return_val_if_fail(attr_separator, NULL); + g_return_val_if_fail(key_value_separator, NULL); - g_return_val_if_fail (attr_separator, NULL); - g_return_val_if_fail (key_value_separator, NULL); + if (!attributes) + return NULL; - if (!attributes || !g_hash_table_size (attributes)) - return NULL; + values = nm_utils_named_values_from_strdict(attributes, &len, values_prepared, &values_free); + if (len == 0) + return NULL; - values = nm_utils_named_values_from_str_dict (attributes, &len); + str = g_string_new(""); + _nm_utils_format_variant_attributes_full(str, + values, + len, + spec, + attr_separator, + key_value_separator); + return g_string_free(str, FALSE); +} + +/*****************************************************************************/ + +gboolean +nm_utils_is_localhost(const char *name) +{ + static const char *const NAMES[] = { + "localhost", + "localhost4", + "localhost6", + "localhost.localdomain", + "localhost4.localdomain4", + "localhost6.localdomain6", + }; + gsize name_len; + int i; - str = g_string_new (""); - _nm_utils_format_variant_attributes_full (str, - values, - len, - attr_separator, - key_value_separator); - return g_string_free (str, FALSE); + if (!name) + return FALSE; + + /* This tries to identify local host and domain names + * described in RFC6761 plus the redhatism of localdomain. + * + * Similar to systemd's is_localhost(). */ + + name_len = strlen(name); + + if (name_len == 0) + return FALSE; + + if (name[name_len - 1] == '.') { + /* one trailing dot is fine. Hide it. */ + name_len--; + } + + for (i = 0; i < (int) G_N_ELEMENTS(NAMES); i++) { + const char *n = NAMES[i]; + gsize l = strlen(n); + gsize s; + + if (name_len < l) + continue; + + s = name_len - l; + + if (g_ascii_strncasecmp(&name[s], n, l) != 0) + continue; + + /* we accept the name if it is equal to one of the well-known names, + * or if it is some prefix, a '.' and the well-known name. */ + if (s == 0) + return TRUE; + if (name[s - 1] == '.') + return TRUE; + } + + return FALSE; +} + +gboolean +nm_utils_is_specific_hostname(const char *name) +{ + if (nm_str_is_empty(name)) + return FALSE; + + if (nm_streq(name, "(none)")) { + /* This is not a special hostname. Probably an artefact by somebody wrongly + * printing NULL. */ + return FALSE; + } + + if (nm_utils_is_localhost(name)) + return FALSE; + + /* FIXME: properly validate the hostname, like systemd's hostname_is_valid() */ + + return TRUE; +} + +/*****************************************************************************/ + +/* taken from systemd's uid_to_name(). */ +char * +nm_utils_uid_to_name(uid_t uid) +{ + gs_free char *buf_heap = NULL; + char buf_stack[4096]; + gsize bufsize; + char * buf; + + bufsize = sizeof(buf_stack); + buf = buf_stack; + + for (;;) { + struct passwd pwbuf; + struct passwd *pw = NULL; + int r; + + r = getpwuid_r(uid, &pwbuf, buf, bufsize, &pw); + if (r == 0 && pw) + return nm_strdup_not_empty(pw->pw_name); + + if (r != ERANGE) + return NULL; + + if (bufsize > G_MAXSIZE / 2u) + return NULL; + + bufsize *= 2u; + g_free(buf_heap); + buf_heap = g_malloc(bufsize); + buf = buf_heap; + } +} + +/* taken from systemd's nss_user_record_by_name() */ +gboolean +nm_utils_name_to_uid(const char *name, uid_t *out_uid) +{ + gs_free char *buf_heap = NULL; + char buf_stack[4096]; + gsize bufsize; + char * buf; + + if (!name) + return nm_assert_unreachable_val(FALSE); + + bufsize = sizeof(buf_stack); + buf = buf_stack; + + for (;;) { + struct passwd *result; + struct passwd pwd; + int r; + + r = getpwnam_r(name, &pwd, buf, bufsize, &result); + if (r == 0) { + if (!result) + return FALSE; + NM_SET_OUT(out_uid, pwd.pw_uid); + return TRUE; + } + + if (r != ERANGE) + return FALSE; + + if (bufsize > G_MAXSIZE / 2u) + return FALSE; + + bufsize *= 2u; + g_free(buf_heap); + buf_heap = g_malloc(bufsize); + buf = buf_heap; + } } |