// SPDX-License-Identifier: LGPL-2.1+

/*

 * Copyright (C) 2016 Red Hat, Inc.

 */

#ifndef __NM_SHARED_UTILS_H__

#define __NM_SHARED_UTILS_H__

#include <netinet/in.h>

/*****************************************************************************/

pid_t nm_utils_gettid (void);

gboolean _nm_assert_on_main_thread (void);

#if NM_MORE_ASSERTS > 5

#define NM_ASSERT_ON_MAIN_THREAD() G_STMT_START { nm_assert (_nm_assert_on_main_thread ()); } G_STMT_END

#else

#define NM_ASSERT_ON_MAIN_THREAD() G_STMT_START {                                         ; } G_STMT_END

#endif

/*****************************************************************************/

static inline gboolean

_NM_INT_NOT_NEGATIVE (gssize val)

{

	/* whether an enum (without negative values) is a signed int, depends on compiler options

	 * and compiler implementation.

	 *

	 * When using such an enum for accessing an array, one naturally wants to check

	 * that the enum is not negative. However, the compiler doesn't like a plain

	 * comparison "enum_val >= 0", because (if the enum is unsigned), it will warn

	 * that the expression is always true *duh*. Not even a cast to a signed

	 * type helps to avoid the compiler warning in any case.

	 *

	 * The sole purpose of this function is to avoid a compiler warning, when checking

	 * that an enum is not negative. */

	return val >= 0;

}

/* check whether the integer value is smaller than G_MAXINT32. This macro exists

 * for the sole purpose, that a plain "((int) value <= G_MAXINT32)" comparison

 * may cause the compiler or coverity that this check is always TRUE. But the

 * check depends on compile time and the size of C type "int".  Of course, most

 * of the time in is gint32 and an int value is always <= G_MAXINT32.  The check

 * exists to catch cases where that is not true.

 *

 * Together with the G_STATIC_ASSERT(), we make sure that this is always satisfied. */

G_STATIC_ASSERT (sizeof (int) == sizeof (gint32));

#if _NM_CC_SUPPORT_GENERIC

#define _NM_INT_LE_MAXINT32(value) \

	({ \

		_nm_unused typeof (value) _value = (value); \

		\

		_Generic((value), \

		         int: TRUE \

		); \

	})

#else

#define _NM_INT_LE_MAXINT32(value) ({ \

		_nm_unused typeof (value) _value = (value); \

		_nm_unused const int *_p_value = &_value; \

		\

		TRUE; \

	})

#endif

/*****************************************************************************/

static inline char

nm_utils_addr_family_to_char (int addr_family)

{

	switch (addr_family) {

	case AF_UNSPEC: return 'X';

	case AF_INET:   return '4';

	case AF_INET6:  return '6';

	}

	g_return_val_if_reached ('?');

}

static inline gsize

nm_utils_addr_family_to_size (int addr_family)

{

	switch (addr_family) {

	case AF_INET:  return sizeof (in_addr_t);

	case AF_INET6: return sizeof (struct in6_addr);

	}

	g_return_val_if_reached (0);

}

static inline int

nm_utils_addr_family_from_size (gsize len)

{

	switch (len) {

	case sizeof (in_addr_t):       return AF_INET;

	case sizeof (struct in6_addr): return AF_INET6;

	}

	return AF_UNSPEC;

}

#define nm_assert_addr_family(addr_family) \

	nm_assert (NM_IN_SET ((addr_family), AF_INET, AF_INET6))

/*****************************************************************************/

typedef struct {

	union {

		guint8 addr_ptr[1];

		in_addr_t addr4;

		struct in_addr addr4_struct;

		struct in6_addr addr6;

		/* NMIPAddr is really a union for IP addresses.

		 * However, as ethernet addresses fit in here nicely, use

		 * it also for an ethernet MAC address. */

		guint8 addr_eth[6 /*ETH_ALEN*/];

		guint8 array[sizeof (struct in6_addr)];

	};

} NMIPAddr;

#define NM_IP_ADDR_INIT { .array = { 0 } }

extern const NMIPAddr nm_ip_addr_zero;

static inline int

nm_ip_addr_cmp (int addr_family, gconstpointer a, gconstpointer b)

{

	nm_assert_addr_family (addr_family);

	nm_assert (a);

	nm_assert (b);

	return memcmp (a, b, nm_utils_addr_family_to_size (addr_family));

}

static inline gboolean

nm_ip_addr_equal (int addr_family, gconstpointer a, gconstpointer b)

{

	return nm_ip_addr_cmp (addr_family, a, b) == 0;

}

static inline gboolean

nm_ip_addr_is_null (int addr_family, gconstpointer addr)

{

	nm_assert (addr);

	if (addr_family == AF_INET6)

		return IN6_IS_ADDR_UNSPECIFIED ((const struct in6_addr *) addr);

	nm_assert (addr_family == AF_INET);

	return ((const struct in_addr *) addr)->s_addr == 0;

}

static inline void

nm_ip_addr_set (int addr_family, gpointer dst, gconstpointer src)

{

	nm_assert_addr_family (addr_family);

	nm_assert (dst);

	nm_assert (src);

	memcpy (dst,

	        src,

	        (addr_family != AF_INET6)

	          ? sizeof (in_addr_t)

	          : sizeof (struct in6_addr));

}

gboolean nm_ip_addr_set_from_untrusted (int addr_family,

                                        gpointer dst,

                                        gconstpointer src,

                                        gsize src_len,

                                        int *out_addr_family);

static inline gboolean

nm_ip4_addr_is_localhost (in_addr_t addr4)

{

	return (addr4 & htonl (0xFF000000u)) == htonl (0x7F000000u);

}

/*****************************************************************************/

struct ether_addr;

static inline int

nm_utils_ether_addr_cmp (const struct ether_addr *a1, const struct ether_addr *a2)

{

	nm_assert (a1);

	nm_assert (a2);

	return memcmp (a1, a2, 6 /*ETH_ALEN*/);

}

static inline gboolean

nm_utils_ether_addr_equal (const struct ether_addr *a1, const struct ether_addr *a2)

{

	return nm_utils_ether_addr_cmp (a1, a2) == 0;

}

/*****************************************************************************/

#define NM_UTILS_INET_ADDRSTRLEN INET6_ADDRSTRLEN

static inline const char *

nm_utils_inet_ntop (int addr_family, gconstpointer addr, char *dst)

{

	const char *s;

	const char *inet_ntop (int af,

	                       const void *src,

	                       char *dst,

	                       socklen_t size);

	nm_assert_addr_family (addr_family);

	nm_assert (addr);

	nm_assert (dst);

	s = inet_ntop (addr_family,

	               addr,

	               dst,

	               addr_family == AF_INET6 ? INET6_ADDRSTRLEN : INET_ADDRSTRLEN);

	nm_assert (s);

	return s;

}

static inline const char *

_nm_utils_inet4_ntop (in_addr_t addr, char dst[static INET_ADDRSTRLEN])

{

	return nm_utils_inet_ntop (AF_INET, &addr, dst);

}

static inline const char *

_nm_utils_inet6_ntop (const struct in6_addr *addr, char dst[static INET6_ADDRSTRLEN])

{

	return nm_utils_inet_ntop (AF_INET6, addr, dst);

}

static inline char *

nm_utils_inet_ntop_dup (int addr_family, gconstpointer addr)

{

	char buf[NM_UTILS_INET_ADDRSTRLEN];

	return g_strdup (nm_utils_inet_ntop (addr_family, addr, buf));

}

static inline char *

nm_utils_inet4_ntop_dup (in_addr_t addr)

{

	return nm_utils_inet_ntop_dup (AF_INET, &addr);

}

static inline char *

nm_utils_inet6_ntop_dup (const struct in6_addr *addr)

{

	return nm_utils_inet_ntop_dup (AF_INET6, addr);

}

/*****************************************************************************/

gboolean nm_utils_ipaddr_is_valid (int addr_family,

                                   const char *str_addr);

gboolean nm_utils_ipaddr_is_normalized (int addr_family,

                                        const char *str_addr);

/*****************************************************************************/

#define NM_CMP_RETURN(c) \

    G_STMT_START { \

        const int _cc = (c); \

        if (_cc) \

            return _cc < 0 ? -1 : 1; \

    } G_STMT_END

#define NM_CMP_RETURN_DIRECT(c) \

    G_STMT_START { \

        const int _cc = (c); \

        if (_cc) \

            return _cc; \

    } G_STMT_END

#define NM_CMP_SELF(a, b) \

    G_STMT_START { \

        typeof (a) _a = (a); \

        typeof (b) _b = (b); \

        \

        if (_a == _b) \

            return 0; \

        if (!_a) \

            return -1; \

        if (!_b) \

            return 1; \

    } G_STMT_END

#define NM_CMP_DIRECT(a, b) \

    G_STMT_START { \

        typeof (a) _a = (a); \

        typeof (b) _b = (b); \

        \

        if (_a != _b) \

            return (_a < _b) ? -1 : 1; \

    } G_STMT_END

/* In the general case, direct pointer comparison is undefined behavior in C.

 * Avoid that by casting pointers to void* and then to uintptr_t. This comparison

 * is not really meaningful, except that it provides some kind of stable sort order

 * between pointers (that can otherwise not be compared). */

#define NM_CMP_DIRECT_PTR(a, b) \

	NM_CMP_DIRECT ((uintptr_t) ((void *) (a)), \

	               (uintptr_t) ((void *) (b)))

#define NM_CMP_DIRECT_MEMCMP(a, b, size) \

    NM_CMP_RETURN (memcmp ((a), (b), (size)))

#define NM_CMP_DIRECT_STRCMP(a, b) \

    NM_CMP_RETURN_DIRECT (strcmp ((a), (b)))

#define NM_CMP_DIRECT_STRCMP0(a, b) \

    NM_CMP_RETURN_DIRECT (nm_strcmp0 ((a), (b)))

#define NM_CMP_DIRECT_IN6ADDR(a, b) \

    G_STMT_START { \

        const struct in6_addr *const _a = (a); \

        const struct in6_addr *const _b = (b); \

        NM_CMP_RETURN (memcmp (_a, _b, sizeof (struct in6_addr))); \

    } G_STMT_END

#define NM_CMP_FIELD(a, b, field) \

    NM_CMP_DIRECT (((a)->field), ((b)->field))

#define NM_CMP_FIELD_UNSAFE(a, b, field) \

    G_STMT_START { \

        /* it's unsafe, because it evaluates the arguments more then once.

         * This is necessary for bitfields, for which typeof() doesn't work. */ \

        if (((a)->field) != ((b)->field)) \

            return ((a)->field < ((b)->field)) ? -1 : 1; \

    } G_STMT_END

#define NM_CMP_FIELD_BOOL(a, b, field) \

    NM_CMP_DIRECT (!!((a)->field), !!((b)->field))

#define NM_CMP_FIELD_STR(a, b, field) \

    NM_CMP_RETURN (strcmp (((a)->field), ((b)->field)))

#define NM_CMP_FIELD_STR_INTERNED(a, b, field) \

    G_STMT_START { \

        const char *_a = ((a)->field); \

        const char *_b = ((b)->field); \

        \

        if (_a != _b) { \

            NM_CMP_RETURN_DIRECT (nm_strcmp0 (_a, _b)); \

        } \

    } G_STMT_END

#define NM_CMP_FIELD_STR0(a, b, field) \

    NM_CMP_RETURN_DIRECT (nm_strcmp0 (((a)->field), ((b)->field)))

#define NM_CMP_FIELD_MEMCMP_LEN(a, b, field, len) \

    NM_CMP_RETURN (memcmp (&((a)->field), &((b)->field), \

                           NM_MIN (len, sizeof ((a)->field))))

#define NM_CMP_FIELD_MEMCMP(a, b, field) \

    NM_CMP_RETURN (memcmp (&((a)->field), \

                           &((b)->field), \

                           sizeof ((a)->field)))

#define NM_CMP_FIELD_IN6ADDR(a, b, field) \

    G_STMT_START { \

        const struct in6_addr *const _a = &((a)->field); \

        const struct in6_addr *const _b = &((b)->field); \

        NM_CMP_RETURN (memcmp (_a, _b, sizeof (struct in6_addr))); \

    } G_STMT_END

/*****************************************************************************/

gboolean nm_utils_memeqzero (gconstpointer data, gsize length);

/*****************************************************************************/

extern const void *const _NM_PTRARRAY_EMPTY[1];

#define NM_PTRARRAY_EMPTY(type) ((type const*) _NM_PTRARRAY_EMPTY)

static inline void

_nm_utils_strbuf_init (char *buf, gsize len, char **p_buf_ptr, gsize *p_buf_len)

{

	NM_SET_OUT (p_buf_len, len);

	NM_SET_OUT (p_buf_ptr, buf);

	buf[0] = '\0';

}

#define nm_utils_strbuf_init(buf, p_buf_ptr, p_buf_len) \

	G_STMT_START { \

		G_STATIC_ASSERT (G_N_ELEMENTS (buf) == sizeof (buf) && sizeof (buf) > sizeof (char *)); \

		_nm_utils_strbuf_init ((buf), sizeof (buf), (p_buf_ptr), (p_buf_len)); \

	} G_STMT_END

void nm_utils_strbuf_append (char **buf, gsize *len, const char *format, ...) _nm_printf (3, 4);

void nm_utils_strbuf_append_c (char **buf, gsize *len, char c);

void nm_utils_strbuf_append_str (char **buf, gsize *len, const char *str);

void nm_utils_strbuf_append_bin (char **buf, gsize *len, gconstpointer str, gsize str_len);

void nm_utils_strbuf_seek_end (char **buf, gsize *len);

const char *nm_strquote (char *buf, gsize buf_len, const char *str);

static inline gboolean

nm_utils_is_separator (const char c)

{

	return NM_IN_SET (c, ' ', '\t');

}

/*****************************************************************************/

GBytes *nm_gbytes_get_empty (void);

static inline gboolean

nm_gbytes_equal0 (GBytes *a, GBytes *b)

{

	return a == b || (a && b && g_bytes_equal (a, b));

}

gboolean nm_utils_gbytes_equal_mem (GBytes *bytes,

                                    gconstpointer mem_data,

                                    gsize mem_len);

GVariant *nm_utils_gbytes_to_variant_ay (GBytes *bytes);

GVariant *nm_utils_strdict_to_variant_ass (GHashTable *strdict);

/*****************************************************************************/

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);

GVariant *

nm_utils_gvariant_vardict_filter_drop_one (GVariant *src,

                                           const char *key);

/*****************************************************************************/

static inline int

nm_utils_hexchar_to_int (char ch)

{

	G_STATIC_ASSERT_EXPR ('0' < 'A');

	G_STATIC_ASSERT_EXPR ('A' < 'a');

	if (ch >= '0') {

		if (ch <= '9')

			return ch - '0';

		if (ch >= 'A') {

			if (ch <= 'F')

				return ((int) ch) + (10 - (int) 'A');

			if (ch >= 'a' && ch <= 'f')

				return ((int) ch) + (10 - (int) 'a');

		}

	}

	return -1;

}

/*****************************************************************************/

const char *nm_utils_dbus_path_get_last_component (const char *dbus_path);

int nm_utils_dbus_path_cmp (const char *dbus_path_a, const char *dbus_path_b);

/*****************************************************************************/

typedef enum {

	NM_UTILS_STRSPLIT_SET_FLAGS_NONE           = 0,

	/* by default, strsplit will coalesce consecutive delimiters and remove

	 * them from the result. If this flag is present, empty values are preserved

	 * and returned.

	 *

	 * When combined with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP, if a value gets

	 * empty after strstrip(), it also gets removed. */

	NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY = (1u << 0),

	/* %NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING means that delimiters prefixed

	 * by a backslash are not treated as a separator. Such delimiters and their escape

	 * character are copied to the current word without unescaping them. In general,

	 * nm_utils_strsplit_set_full() does not remove any backslash escape characters

	 * and does no unescaping. It only considers them for skipping to split at

	 * an escaped delimiter.

	 *

	 * If this is combined with (or implied by %NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED), then

	 * the backslash escapes are removed from the result.

	 */

	NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING = (1u << 1),

	/* If flag is set, does the same as g_strstrip() on the returned tokens.

	 * This will remove leading and trailing ascii whitespaces (g_ascii_isspace()

	 * and NM_ASCII_SPACES).

	 *

	 * - when combined with !%NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY,

	 *   empty tokens will be removed (and %NULL will be returned if that

	 *   results in an empty string array).

	 * - when combined with %NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING,

	 *   trailing whitespace escaped by backslash are not stripped. */

	NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP       = (1u << 2),

	/* This implies %NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING.

	 *

	 * This will do a final run over all tokens and remove all backslash

	 * escape characters that

	 *   - precede a delimiter.

	 *   - precede a backslash.

	 *   - preceed a whitespace (with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP).

	 *

	 *  Note that with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP, it is only

	 *  necessary to escape the very last whitespace (if the delimiters

	 *  are not whitespace themself). So, technically, it would be sufficient

	 *  to only unescape a backslash before the last whitespace and the user

	 *  still could express everything. However, such a rule would be complicated

	 *  to understand, so when using backslash escaping with nm_utils_strsplit_set_full(),

	 *  then all characters (including backslash) are treated verbatim, except:

	 *

	 *    - "\\$DELIMITER" (escaped delimiter)

	 *    - "\\\\" (escaped backslash)

	 *    - "\\$SPACE" (escaped space) (with %NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP).

	 *

	 * Note that all other escapes like "\\n" or "\\001" are left alone.

	 * That makes the escaping/unescaping rules simple. Also, for the most part

	 * a text is just taken as-is, with little additional rules. Only backslashes

	 * need extra care, and then only if they proceed one of the relevant characters.

	 */

	NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED        = (1u << 3),

} NMUtilsStrsplitSetFlags;

const char **nm_utils_strsplit_set_full (const char *str,

                                         const char *delimiter,

                                         NMUtilsStrsplitSetFlags flags);

static inline const char **

nm_utils_strsplit_set_with_empty (const char *str,

                                  const char *delimiters)

{

	/* this returns the same result as g_strsplit_set(str, delimiters, -1), except

	 * it does not deep-clone the strv array.

	 * Also, for @str == "", this returns %NULL while g_strsplit_set() would return

	 * an empty strv array. */

	return nm_utils_strsplit_set_full (str, delimiters, NM_UTILS_STRSPLIT_SET_FLAGS_PRESERVE_EMPTY);

}

static inline const char **

nm_utils_strsplit_set (const char *str,

                       const char *delimiters)

{

	return nm_utils_strsplit_set_full (str, delimiters, NM_UTILS_STRSPLIT_SET_FLAGS_NONE);

}

gssize nm_utils_strv_find_first (char **list, gssize len, const char *needle);

char **_nm_utils_strv_cleanup (char **strv,

                               gboolean strip_whitespace,

                               gboolean skip_empty,

                               gboolean skip_repeated);

/*****************************************************************************/

static inline const char **

nm_utils_escaped_tokens_split (const char *str,

                               const char *delimiters)

{

	return nm_utils_strsplit_set_full (str,

	                                   delimiters,

	                                     NM_UTILS_STRSPLIT_SET_FLAGS_ESCAPED

	                                   | NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP);

}

typedef enum {

	NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_NONE                       = 0,

	NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_SPACES              = (1ull << 0),

	NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE       = (1ull << 1),

	NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE      = (1ull << 2),

	/* Backslash characters will be escaped as "\\\\" if they precede another

	 * character that makes it necessary. Such characters are:

	 *

	 *  1) before another '\\' backslash.

	 *  2) before any delimiter in @delimiters.

	 *  3) before any delimiter in @delimiters_as_needed.

	 *  4) before a white space, if ESCAPE_LEADING_SPACE or ESCAPE_TRAILING_SPACE is set.

	 *  5) before the end of the word

	 *

	 * Rule 4) is an extension. It's not immediately clear why with ESCAPE_LEADING_SPACE

	 * and ESCAPE_TRAILING_SPACE we want *all* backslashes before a white space escaped.

	 * The reason is, that we obviously want to use ESCAPE_LEADING_SPACE and ESCAPE_TRAILING_SPACE

	 * in cases, where we later parse the backslash escaped strings back, but allowing to strip

	 * unescaped white spaces. That means, we want that " a " gets escaped as "\\ a\\ ".

	 * On the other hand, we also want that " a\\ b " gets escaped as "\\ a\\\\ b\\ ",

	 * and not "\\ a\\ b\\ ". Because otherwise, the parser would need to treat "\\ "

	 * differently depending on whether the sequence is at the beginning, end or middle

	 * of the word.

	 *

	 * Rule 5) is also not immediately obvious. When used with ESCAPE_TRAILING_SPACE,

	 * we clearly want to allow that an escaped word can have arbitrary

	 * whitespace suffixes. That's why this mode exists. So we must escape "a\\" as

	 * "a\\\\", so that appending " " does not change the meaning.

	 * Also without ESCAPE_TRAILING_SPACE, we want in general that we can concatenate

	 * two escaped words without changing their meaning. If the words would be "a\\"

	 * and "," (with ',' being a delimiter), then the result must be "a\\\\" and "\\,"

	 * so that the concatenated word ("a\\\\\\,") is still the same. If we would escape

	 * them instead as "a\\" + "\\,", then the concatenated word would be "a\\\\," and

	 * different.

	 * */

	NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_AS_NEEDED = (1ull << 3),

	NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_ALWAYS    = (1ull << 4),

} NMUtilsEscapedTokensEscapeFlags;

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);

static inline const char *

nm_utils_escaped_tokens_escape (const char *str,

                                const char *delimiters,

                                char **out_to_free)

{

	return nm_utils_escaped_tokens_escape_full (str,

	                                            delimiters,

	                                            NULL,

	                                              NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_ALWAYS

	                                            | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE,

	                                            out_to_free);

}

static inline GString *

nm_utils_escaped_tokens_escape_gstr_assert (const char *str,

                                            const char *delimiters,

                                            GString *gstring)

{

#if NM_MORE_ASSERTS > 0

	/* Just appends @str to @gstring, but also assert that

	 * no escaping is necessary.

	 *

	 * Use nm_utils_escaped_tokens_escape_gstr_assert() instead

	 * of nm_utils_escaped_tokens_escape_gstr(), if you *know* that

	 * @str contains no delimiters, no backslashes, and no trailing

	 * whitespace that requires escaping. */

	nm_assert (str);

	nm_assert (gstring);

	nm_assert (delimiters);

	{

		gs_free char *str_to_free = NULL;

		const char *str0;

		str0 = nm_utils_escaped_tokens_escape (str, delimiters, &str_to_free);

		nm_assert (str0 == str);

		nm_assert (!str_to_free);

	}

#endif

	g_string_append (gstring, str);

	return gstring;

}

static inline GString *

nm_utils_escaped_tokens_escape_gstr (const char *str,

                                     const char *delimiters,

                                     GString *gstring)

{

	gs_free char *str_to_free = NULL;

	nm_assert (str);

	nm_assert (gstring);

	g_string_append (gstring,

	                 nm_utils_escaped_tokens_escape (str, delimiters, &str_to_free));

	return gstring;

}

/*****************************************************************************/

char **nm_utils_strsplit_quoted (const char *str);

/*****************************************************************************/

static inline const char **

nm_utils_escaped_tokens_options_split_list (const char *str)

{

	return nm_utils_strsplit_set_full (str,

	                                   ",",

	                                     NM_UTILS_STRSPLIT_SET_FLAGS_STRSTRIP

	                                   | NM_UTILS_STRSPLIT_SET_FLAGS_ALLOW_ESCAPING);

}

void nm_utils_escaped_tokens_options_split (char *str,

                                            const char **out_key,

                                            const char **out_val);

static inline const char *

nm_utils_escaped_tokens_options_escape_key (const char *key,

                                            char **out_to_free)

{

	return nm_utils_escaped_tokens_escape_full (key,

	                                            ",=",

	                                            NULL,

	                                              NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_AS_NEEDED

	                                            | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE

	                                            | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE,

	                                            out_to_free);

}

static inline const char *

nm_utils_escaped_tokens_options_escape_val (const char *val,

                                            char **out_to_free)

{

	return nm_utils_escaped_tokens_escape_full (val,

	                                            ",",

	                                            "=",

	                                              NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_BACKSLASH_AS_NEEDED

	                                            | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_LEADING_SPACE

	                                            | NM_UTILS_ESCAPED_TOKENS_ESCAPE_FLAGS_ESCAPE_TRAILING_SPACE,

	                                            out_to_free);

}

/*****************************************************************************/

#define NM_UTILS_CHECKSUM_LENGTH_MD5          16

#define NM_UTILS_CHECKSUM_LENGTH_SHA1         20

#define NM_UTILS_CHECKSUM_LENGTH_SHA256       32

#define nm_utils_checksum_get_digest(sum, arr) \

	G_STMT_START { \

		GChecksum *const _sum = (sum); \

		gsize _len; \

		\

		G_STATIC_ASSERT_EXPR (   sizeof (arr) == NM_UTILS_CHECKSUM_LENGTH_MD5 \

		                      || sizeof (arr) == NM_UTILS_CHECKSUM_LENGTH_SHA1 \

		                      || sizeof (arr) == NM_UTILS_CHECKSUM_LENGTH_SHA256); \

		G_STATIC_ASSERT_EXPR (sizeof (arr) == G_N_ELEMENTS (arr)); \

		\

		nm_assert (_sum); \

		\

		_len = G_N_ELEMENTS (arr); \

		\

		g_checksum_get_digest (_sum, (arr), &_len); \

		nm_assert (_len == G_N_ELEMENTS (arr)); \

	} G_STMT_END

#define nm_utils_checksum_get_digest_len(sum, buf, len) \

	G_STMT_START { \

		GChecksum *const _sum = (sum); \

		const gsize _len0 = (len); \

		gsize _len; \

		\

		nm_assert (NM_IN_SET (_len0, NM_UTILS_CHECKSUM_LENGTH_MD5, \

		                             NM_UTILS_CHECKSUM_LENGTH_SHA1, \

		                             NM_UTILS_CHECKSUM_LENGTH_SHA256)); \

		nm_assert (_sum); \

		\

		_len = _len0; \

		g_checksum_get_digest (_sum, (buf), &_len); \

		nm_assert (_len == _len0); \

	} G_STMT_END

/*****************************************************************************/

guint32 _nm_utils_ip4_prefix_to_netmask (guint32 prefix);

guint32 _nm_utils_ip4_get_default_prefix (guint32 ip);

gconstpointer          nm_utils_ipx_address_clear_host_address (int family, gpointer dst, gconstpointer src, guint8 plen);

in_addr_t              nm_utils_ip4_address_clear_host_address (in_addr_t addr, guint8 plen);

const struct in6_addr *nm_utils_ip6_address_clear_host_address (struct in6_addr *dst, const struct in6_addr *src, guint8 plen);

int nm_utils_ip6_address_same_prefix_cmp (const struct in6_addr *addr_a, const struct in6_addr *addr_b, guint8 plen);

gboolean nm_utils_ip_is_site_local (int addr_family,

                                    const void *address);

/*****************************************************************************/

gboolean nm_utils_parse_inaddr_bin_full (int addr_family,

                                         gboolean accept_legacy,

                                         const char *text,

                                         int *out_addr_family,

                                         gpointer out_addr);

static inline gboolean

nm_utils_parse_inaddr_bin (int addr_family,

                           const char *text,

                           int *out_addr_family,

                           gpointer out_addr)

{

	return nm_utils_parse_inaddr_bin_full (addr_family, FALSE, text, out_addr_family, out_addr);

}

gboolean nm_utils_parse_inaddr (int addr_family,

                                const char *text,

                                char **out_addr);

gboolean nm_utils_parse_inaddr_prefix_bin (int addr_family,

                                           const char *text,

                                           int *out_addr_family,

                                           gpointer out_addr,

                                           int *out_prefix);

gboolean nm_utils_parse_inaddr_prefix (int addr_family,

                                       const char *text,

                                       char **out_addr,

                                       int *out_prefix);

gboolean nm_utils_parse_next_line (const char **inout_ptr,

                                   gsize *inout_len,

                                   const char **out_line,

                                   gsize *out_line_len);

gint64 nm_g_ascii_strtoll (const char *nptr,

                           char **endptr,

                           guint base);

guint64 nm_g_ascii_strtoull (const char *nptr,

                             char **endptr,

                             guint base);

double nm_g_ascii_strtod (const char *nptr,

                          char **endptr);

gint64  _nm_utils_ascii_str_to_int64  (const char *str, guint base, gint64  min, gint64  max, gint64  fallback);

guint64 _nm_utils_ascii_str_to_uint64 (const char *str, guint base, guint64 min, guint64 max, guint64 fallback);

int _nm_utils_ascii_str_to_bool (const char *str,

                                  int default_value);

/*****************************************************************************/

extern char _nm_utils_to_string_buffer[2096];

void     nm_utils_to_string_buffer_init (char **buf, gsize *len);

gboolean nm_utils_to_string_buffer_init_null (gconstpointer obj, char **buf, gsize *len);

/*****************************************************************************/

typedef struct {

	unsigned flag;

	const char *name;

} NMUtilsFlags2StrDesc;

#define NM_UTILS_FLAGS2STR(f, n) { .flag = f, .name = ""n, }

#define NM_UTILS_FLAGS2STR_DEFINE(fcn_name, flags_type, ...) \

const char * \

fcn_name (flags_type flags, char *buf, gsize len) \

{ \

	static const NMUtilsFlags2StrDesc descs[] = { \

		__VA_ARGS__ \

	}; \

	G_STATIC_ASSERT (sizeof (flags_type) <= sizeof (unsigned)); \

	return nm_utils_flags2str (descs, G_N_ELEMENTS (descs), flags, buf, len); \

};

const char *nm_utils_flags2str (const NMUtilsFlags2StrDesc *descs,

                                gsize n_descs,

                                unsigned flags,

                                char *buf,

                                gsize len);

/*****************************************************************************/

#define NM_UTILS_ENUM2STR(v, n)     (void) 0; case v: s = ""n""; break; (void) 0

#define NM_UTILS_ENUM2STR_IGNORE(v) (void) 0; case v: break; (void) 0

#define NM_UTILS_ENUM2STR_DEFINE_FULL(fcn_name, lookup_type, int_fmt, ...) \

const char * \

fcn_name (lookup_type val, char *buf, gsize len) \

{ \

	nm_utils_to_string_buffer_init (&buf, &len;; \

	if (len) { \

		const char *s = NULL; \

		switch (val) { \

			(void) 0, \

			__VA_ARGS__ \

			(void) 0; \