[network-manager-fortisslvpn/th/update: 3/7] shared: add shared files



commit 0c3b37bdf61001a78c651741e4ecbad4bd498ec8
Author: Thomas Haller <thaller redhat com>
Date:   Thu Sep 15 09:32:04 2016 +0200

    shared: add shared files
    
    Will be used later.

 po/POTFILES.in                         |    2 +
 shared/Makefile.am                     |    9 +
 shared/README                          |    9 +
 shared/nm-utils/gsystem-local-alloc.h  |  208 ++++
 shared/nm-utils/nm-glib.h              |  452 ++++++++
 shared/nm-utils/nm-macros-internal.h   |  721 +++++++++++++
 shared/nm-utils/nm-shared-utils.c      |  239 +++++
 shared/nm-utils/nm-shared-utils.h      |   66 ++
 shared/nm-utils/nm-test-utils.h        | 1753 ++++++++++++++++++++++++++++++++
 shared/nm-utils/nm-vpn-plugin-macros.h |   61 ++
 shared/nm-utils/nm-vpn-plugin-utils.c  |  130 +++
 shared/nm-utils/nm-vpn-plugin-utils.h  |   42 +
 12 files changed, 3692 insertions(+), 0 deletions(-)
---
diff --git a/po/POTFILES.in b/po/POTFILES.in
index c074a0a..3a93bce 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -3,5 +3,7 @@
 appdata/network-manager-fortisslvpn.metainfo.xml.in
 auth-dialog/main.c
 properties/nm-fortisslvpn.c
+shared/nm-utils/nm-shared-utils.c
+shared/nm-utils/nm-vpn-plugin-utils.c
 src/nm-fortisslvpn-service.c
 [type: gettext/glade]properties/nm-fortisslvpn-dialog.ui
diff --git a/shared/Makefile.am b/shared/Makefile.am
new file mode 100644
index 0000000..ea4a764
--- /dev/null
+++ b/shared/Makefile.am
@@ -0,0 +1,9 @@
+EXTRA_DIST = \
+    README \
+    nm-utils/gsystem-local-alloc.h \
+    nm-utils/nm-glib.h \
+    nm-utils/nm-macros-internal.h \
+    nm-utils/nm-test-utils.h \
+    nm-utils/nm-shared-utils.c \
+    nm-utils/nm-shared-utils.h \
+    $(NULL)
diff --git a/shared/README b/shared/README
new file mode 100644
index 0000000..3fe41ef
--- /dev/null
+++ b/shared/README
@@ -0,0 +1,9 @@
+The files in the "shared/" directory are used by all components
+inside the VPN plugin repository (src, properties, auth-dialog).
+
+The files in shared/nm-utils are copied from NetworkManager
+repository and used as is:
+Do *not* modify these files locally so that they don't diverge
+from their original. Fix/extend them in their respective origin
+first, and re-import the files as a whole.
+
diff --git a/shared/nm-utils/gsystem-local-alloc.h b/shared/nm-utils/gsystem-local-alloc.h
new file mode 100644
index 0000000..51b6251
--- /dev/null
+++ b/shared/nm-utils/gsystem-local-alloc.h
@@ -0,0 +1,208 @@
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
+ *
+ * Copyright (C) 2012 Colin Walters <walters verbum org>.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GSYSTEM_LOCAL_ALLOC_H__
+#define __GSYSTEM_LOCAL_ALLOC_H__
+
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+#define GS_DEFINE_CLEANUP_FUNCTION(Type, name, func) \
+  static inline void name (void *v) \
+  { \
+    func (*(Type*)v); \
+  }
+
+#define GS_DEFINE_CLEANUP_FUNCTION0(Type, name, func) \
+  static inline void name (void *v) \
+  { \
+    if (*(Type*)v) \
+      func (*(Type*)v); \
+  }
+
+/* These functions shouldn't be invoked directly;
+ * they are stubs that:
+ * 1) Take a pointer to the location (typically itself a pointer).
+ * 2) Provide %NULL-safety where it doesn't exist already (e.g. g_object_unref)
+ */
+
+/**
+ * gs_free:
+ *
+ * Call g_free() on a variable location when it goes out of scope.
+ */
+#define gs_free __attribute__ ((cleanup(gs_local_free)))
+GS_DEFINE_CLEANUP_FUNCTION(void*, gs_local_free, g_free)
+
+/**
+ * gs_unref_object:
+ *
+ * Call g_object_unref() on a variable location when it goes out of
+ * scope.  Note that unlike g_object_unref(), the variable may be
+ * %NULL.
+ */
+#define gs_unref_object __attribute__ ((cleanup(gs_local_obj_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GObject*, gs_local_obj_unref, g_object_unref)
+
+/**
+ * gs_unref_variant:
+ *
+ * Call g_variant_unref() on a variable location when it goes out of
+ * scope.  Note that unlike g_variant_unref(), the variable may be
+ * %NULL.
+ */
+#define gs_unref_variant __attribute__ ((cleanup(gs_local_variant_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GVariant*, gs_local_variant_unref, g_variant_unref)
+
+/**
+ * gs_free_variant_iter:
+ *
+ * Call g_variant_iter_free() on a variable location when it goes out of
+ * scope.
+ */
+#define gs_free_variant_iter __attribute__ ((cleanup(gs_local_variant_iter_free)))
+GS_DEFINE_CLEANUP_FUNCTION0(GVariantIter*, gs_local_variant_iter_free, g_variant_iter_free)
+
+/**
+ * gs_free_variant_builder:
+ *
+ * Call g_variant_builder_unref() on a variable location when it goes out of
+ * scope.
+ */
+#define gs_unref_variant_builder __attribute__ ((cleanup(gs_local_variant_builder_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GVariantBuilder*, gs_local_variant_builder_unref, g_variant_builder_unref)
+
+/**
+ * gs_unref_array:
+ *
+ * Call g_array_unref() on a variable location when it goes out of
+ * scope.  Note that unlike g_array_unref(), the variable may be
+ * %NULL.
+
+ */
+#define gs_unref_array __attribute__ ((cleanup(gs_local_array_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GArray*, gs_local_array_unref, g_array_unref)
+
+/**
+ * gs_unref_ptrarray:
+ *
+ * Call g_ptr_array_unref() on a variable location when it goes out of
+ * scope.  Note that unlike g_ptr_array_unref(), the variable may be
+ * %NULL.
+
+ */
+#define gs_unref_ptrarray __attribute__ ((cleanup(gs_local_ptrarray_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GPtrArray*, gs_local_ptrarray_unref, g_ptr_array_unref)
+
+/**
+ * gs_unref_hashtable:
+ *
+ * Call g_hash_table_unref() on a variable location when it goes out
+ * of scope.  Note that unlike g_hash_table_unref(), the variable may
+ * be %NULL.
+ */
+#define gs_unref_hashtable __attribute__ ((cleanup(gs_local_hashtable_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GHashTable*, gs_local_hashtable_unref, g_hash_table_unref)
+
+/**
+ * gs_free_list:
+ *
+ * Call g_list_free() on a variable location when it goes out
+ * of scope.
+ */
+#define gs_free_list __attribute__ ((cleanup(gs_local_free_list)))
+GS_DEFINE_CLEANUP_FUNCTION(GList*, gs_local_free_list, g_list_free)
+
+/**
+ * gs_free_slist:
+ *
+ * Call g_slist_free() on a variable location when it goes out
+ * of scope.
+ */
+#define gs_free_slist __attribute__ ((cleanup(gs_local_free_slist)))
+GS_DEFINE_CLEANUP_FUNCTION(GSList*, gs_local_free_slist, g_slist_free)
+
+/**
+ * gs_free_checksum:
+ *
+ * Call g_checksum_free() on a variable location when it goes out
+ * of scope.  Note that unlike g_checksum_free(), the variable may
+ * be %NULL.
+ */
+#define gs_free_checksum __attribute__ ((cleanup(gs_local_checksum_free)))
+GS_DEFINE_CLEANUP_FUNCTION0(GChecksum*, gs_local_checksum_free, g_checksum_free)
+
+/**
+ * gs_unref_bytes:
+ *
+ * Call g_bytes_unref() on a variable location when it goes out
+ * of scope.  Note that unlike g_bytes_unref(), the variable may
+ * be %NULL.
+ */
+#define gs_unref_bytes __attribute__ ((cleanup(gs_local_bytes_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GBytes*, gs_local_bytes_unref, g_bytes_unref)
+
+/**
+ * gs_strfreev:
+ *
+ * Call g_strfreev() on a variable location when it goes out of scope.
+ */
+#define gs_strfreev __attribute__ ((cleanup(gs_local_strfreev)))
+GS_DEFINE_CLEANUP_FUNCTION(char**, gs_local_strfreev, g_strfreev)
+
+/**
+ * gs_free_error:
+ *
+ * Call g_error_free() on a variable location when it goes out of scope.
+ */
+#define gs_free_error __attribute__ ((cleanup(gs_local_free_error)))
+GS_DEFINE_CLEANUP_FUNCTION0(GError*, gs_local_free_error, g_error_free)
+
+/**
+ * gs_unref_keyfile:
+ *
+ * Call g_key_file_unref() on a variable location when it goes out of scope.
+ */
+#define gs_unref_keyfile __attribute__ ((cleanup(gs_local_keyfile_unref)))
+GS_DEFINE_CLEANUP_FUNCTION0(GKeyFile*, gs_local_keyfile_unref, g_key_file_unref)
+
+static inline void
+gs_cleanup_close_fdp (int *fdp)
+{
+  int fd;
+
+  g_assert (fdp);
+  
+  fd = *fdp;
+  if (fd != -1)
+    (void) close (fd);
+}
+
+/**
+ * gs_fd_close:
+ *
+ * Call close() on a variable location when it goes out of scope.
+ */
+#define gs_fd_close __attribute__((cleanup(gs_cleanup_close_fdp)))
+
+G_END_DECLS
+
+#endif
diff --git a/shared/nm-utils/nm-glib.h b/shared/nm-utils/nm-glib.h
new file mode 100644
index 0000000..824a08c
--- /dev/null
+++ b/shared/nm-utils/nm-glib.h
@@ -0,0 +1,452 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Copyright 2008 - 2011 Red Hat, Inc.
+ */
+
+#ifndef __NM_GLIB_H__
+#define __NM_GLIB_H__
+
+
+#include <gio/gio.h>
+#include <string.h>
+
+#include "gsystem-local-alloc.h"
+
+#ifdef __clang__
+
+#undef G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+#undef G_GNUC_END_IGNORE_DEPRECATIONS
+
+#define G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+    _Pragma("clang diagnostic push") \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+
+#define G_GNUC_END_IGNORE_DEPRECATIONS \
+    _Pragma("clang diagnostic pop")
+
+#endif
+
+static inline void
+__g_type_ensure (GType type)
+{
+#if !GLIB_CHECK_VERSION(2,34,0)
+       if (G_UNLIKELY (type == (GType)-1))
+               g_error ("can't happen");
+#else
+       G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
+       g_type_ensure (type);
+       G_GNUC_END_IGNORE_DEPRECATIONS;
+#endif
+}
+#define g_type_ensure __g_type_ensure
+
+#if !GLIB_CHECK_VERSION(2,34,0)
+
+#define g_clear_pointer(pp, destroy) \
+    G_STMT_START {                                                                 \
+        G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer));                       \
+        /* Only one access, please */                                              \
+        gpointer *_pp = (gpointer *) (pp);                                         \
+        gpointer _p;                                                               \
+        /* This assignment is needed to avoid a gcc warning */                     \
+        GDestroyNotify _destroy = (GDestroyNotify) (destroy);                      \
+                                                                                   \
+        _p = *_pp;                                                                 \
+        if (_p)                                                                    \
+        {                                                                          \
+            *_pp = NULL;                                                           \
+            _destroy (_p);                                                         \
+        }                                                                          \
+    } G_STMT_END
+
+/* These are used to clean up the output of test programs; we can just let
+ * them no-op in older glib.
+ */
+#define g_test_expect_message(log_domain, log_level, pattern)
+#define g_test_assert_expected_messages()
+
+#else
+
+/* We build with -DGLIB_MAX_ALLOWED_VERSION set to 2.32 to make sure we don't
+ * accidentally use new API that we shouldn't. But we don't want warnings for
+ * the APIs that we emulate above.
+ */
+
+#define g_test_expect_message(domain, level, format...) \
+       G_STMT_START { \
+               G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+               g_test_expect_message (domain, level, format); \
+               G_GNUC_END_IGNORE_DEPRECATIONS \
+       } G_STMT_END
+
+#define g_test_assert_expected_messages_internal(domain, file, line, func) \
+       G_STMT_START { \
+               G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+               g_test_assert_expected_messages_internal (domain, file, line, func); \
+               G_GNUC_END_IGNORE_DEPRECATIONS \
+       } G_STMT_END
+
+#endif
+
+
+#if GLIB_CHECK_VERSION (2, 35, 0)
+/* For glib >= 2.36, g_type_init() is deprecated.
+ * But since 2.35.1 (7c42ab23b55c43ab96d0ac2124b550bf1f49c1ec) this function
+ * does nothing. Replace the call with empty statement. */
+#define nm_g_type_init()     G_STMT_START { (void) 0; } G_STMT_END
+#else
+#define nm_g_type_init()     G_STMT_START { g_type_init (); } G_STMT_END
+#endif
+
+
+/* g_test_initialized() is only available since glib 2.36. */
+#if !GLIB_CHECK_VERSION (2, 36, 0)
+#define g_test_initialized() (g_test_config_vars->test_initialized)
+#endif
+
+/* g_assert_cmpmem() is only available since glib 2.46. */
+#if !GLIB_CHECK_VERSION (2, 45, 7)
+#define g_assert_cmpmem(m1, l1, m2, l2) G_STMT_START {\
+                                             gconstpointer __m1 = m1, __m2 = m2; \
+                                             int __l1 = l1, __l2 = l2; \
+                                             if (__l1 != __l2) \
+                                               g_assertion_message_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, 
G_STRFUNC, \
+                                                                           #l1 " (len(" #m1 ")) == " #l2 " 
(len(" #m2 "))", __l1, "==", __l2, 'i'); \
+                                             else if (memcmp (__m1, __m2, __l1) != 0) \
+                                               g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, 
G_STRFUNC, \
+                                                                    "assertion failed (" #m1 " == " #m2 
")"); \
+                                        } G_STMT_END
+#endif
+
+/* Rumtime check for glib version. First do a compile time check which
+ * (if satisfied) shortcuts the runtime check. */
+#define nm_glib_check_version(major, minor, micro) \
+    (   GLIB_CHECK_VERSION ((major), (minor), (micro)) \
+     || (   (   glib_major_version > (major)) \
+         || (   glib_major_version == (major) \
+             && glib_minor_version > (minor)) \
+         || (   glib_major_version == (major) \
+             && glib_minor_version == (minor) \
+             && glib_micro_version >= (micro))))
+
+/* g_test_skip() is only available since glib 2.38. Add a compatibility wrapper. */
+inline static void
+__nmtst_g_test_skip (const gchar *msg)
+{
+#if GLIB_CHECK_VERSION (2, 38, 0)
+       G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+       g_test_skip (msg);
+       G_GNUC_END_IGNORE_DEPRECATIONS
+#else
+       g_debug ("%s", msg);
+#endif
+}
+#define g_test_skip __nmtst_g_test_skip
+
+
+/* g_test_add_data_func_full() is only available since glib 2.34. Add a compatibility wrapper. */
+inline static void
+__g_test_add_data_func_full (const char     *testpath,
+                             gpointer        test_data,
+                             GTestDataFunc   test_func,
+                             GDestroyNotify  data_free_func)
+{
+#if GLIB_CHECK_VERSION (2, 34, 0)
+       G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+       g_test_add_data_func_full (testpath, test_data, test_func, data_free_func);
+       G_GNUC_END_IGNORE_DEPRECATIONS
+#else
+       g_return_if_fail (testpath != NULL);
+       g_return_if_fail (testpath[0] == '/');
+       g_return_if_fail (test_func != NULL);
+
+       g_test_add_vtable (testpath, 0, test_data, NULL,
+                          (GTestFixtureFunc) test_func,
+                          (GTestFixtureFunc) data_free_func);
+#endif
+}
+#define g_test_add_data_func_full __g_test_add_data_func_full
+
+
+#if !GLIB_CHECK_VERSION (2, 34, 0)
+#define G_DEFINE_QUARK(QN, q_n)               \
+GQuark                                        \
+q_n##_quark (void)                            \
+{                                             \
+       static GQuark q;                          \
+                                              \
+       if G_UNLIKELY (q == 0)                    \
+               q = g_quark_from_static_string (#QN); \
+                                              \
+       return q;                                 \
+}
+#endif
+
+
+static inline gboolean
+nm_g_hash_table_replace (GHashTable *hash, gpointer key, gpointer value)
+{
+       /* glib 2.40 added a return value indicating whether the key already existed
+        * (910191597a6c2e5d5d460e9ce9efb4f47d9cc63c). */
+#if GLIB_CHECK_VERSION(2, 40, 0)
+       return g_hash_table_replace (hash, key, value);
+#else
+       gboolean contained = g_hash_table_contains (hash, key);
+
+       g_hash_table_replace (hash, key, value);
+       return !contained;
+#endif
+}
+
+static inline gboolean
+nm_g_hash_table_insert (GHashTable *hash, gpointer key, gpointer value)
+{
+       /* glib 2.40 added a return value indicating whether the key already existed
+        * (910191597a6c2e5d5d460e9ce9efb4f47d9cc63c). */
+#if GLIB_CHECK_VERSION(2, 40, 0)
+       return g_hash_table_insert (hash, key, value);
+#else
+       gboolean contained = g_hash_table_contains (hash, key);
+
+       g_hash_table_insert (hash, key, value);
+       return !contained;
+#endif
+}
+
+static inline gboolean
+nm_g_hash_table_add (GHashTable *hash, gpointer key)
+{
+       /* glib 2.40 added a return value indicating whether the key already existed
+        * (910191597a6c2e5d5d460e9ce9efb4f47d9cc63c). */
+#if GLIB_CHECK_VERSION(2, 40, 0)
+       return g_hash_table_add (hash, key);
+#else
+       gboolean contained = g_hash_table_contains (hash, key);
+
+       g_hash_table_add (hash, key);
+       return !contained;
+#endif
+}
+
+#if !GLIB_CHECK_VERSION(2, 40, 0) || defined (NM_GLIB_COMPAT_H_TEST)
+static inline void
+_nm_g_ptr_array_insert (GPtrArray *array,
+                        gint       index_,
+                        gpointer   data)
+{
+       g_return_if_fail (array);
+       g_return_if_fail (index_ >= -1);
+       g_return_if_fail (index_ <= (gint) array->len);
+
+       g_ptr_array_add (array, data);
+
+       if (index_ != -1 && index_ != (gint) (array->len - 1)) {
+               memmove (&(array->pdata[index_ + 1]),
+                        &(array->pdata[index_]),
+                        (array->len - index_ - 1) * sizeof (gpointer));
+               array->pdata[index_] = data;
+       }
+}
+#endif
+#if !GLIB_CHECK_VERSION(2, 40, 0)
+#define g_ptr_array_insert(array, index, data) G_STMT_START { _nm_g_ptr_array_insert (array, index, data); } 
G_STMT_END
+#else
+#define g_ptr_array_insert(array, index, data) \
+       G_STMT_START { \
+               G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+               g_ptr_array_insert (array, index, data); \
+               G_GNUC_END_IGNORE_DEPRECATIONS \
+       } G_STMT_END
+#endif
+
+
+#if !GLIB_CHECK_VERSION (2, 40, 0)
+inline static gboolean
+_g_key_file_save_to_file (GKeyFile     *key_file,
+                          const gchar  *filename,
+                          GError      **error)
+{
+       gchar *contents;
+       gboolean success;
+       gsize length;
+
+       g_return_val_if_fail (key_file != NULL, FALSE);
+       g_return_val_if_fail (filename != NULL, FALSE);
+       g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+       contents = g_key_file_to_data (key_file, &length, NULL);
+       g_assert (contents != NULL);
+
+       success = g_file_set_contents (filename, contents, length, error);
+       g_free (contents);
+
+       return success;
+}
+#define g_key_file_save_to_file(key_file, filename, error) \
+       _g_key_file_save_to_file (key_file, filename, error)
+#else
+#define g_key_file_save_to_file(key_file, filename, error) \
+       ({ \
+               gboolean _success; \
+               \
+               G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+               _success = g_key_file_save_to_file (key_file, filename, error); \
+               G_GNUC_END_IGNORE_DEPRECATIONS \
+               _success; \
+       })
+#endif
+
+
+#if GLIB_CHECK_VERSION (2, 36, 0)
+#define g_credentials_get_unix_pid(creds, error) \
+       ({ \
+               G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+                       (g_credentials_get_unix_pid) ((creds), (error)); \
+               G_GNUC_END_IGNORE_DEPRECATIONS \
+       })
+#else
+#define g_credentials_get_unix_pid(creds, error) \
+       ({ \
+               struct ucred *native_creds; \
+                \
+               native_creds = g_credentials_get_native ((creds), G_CREDENTIALS_TYPE_LINUX_UCRED); \
+               g_assert (native_creds); \
+               native_creds->pid; \
+       })
+#endif
+
+
+#if !GLIB_CHECK_VERSION(2, 40, 0) || defined (NM_GLIB_COMPAT_H_TEST)
+static inline gpointer *
+_nm_g_hash_table_get_keys_as_array (GHashTable *hash_table,
+                                    guint      *length)
+{
+       GHashTableIter iter;
+       gpointer key, *ret;
+       guint i = 0;
+
+       g_return_val_if_fail (hash_table, NULL);
+
+       ret = g_new0 (gpointer, g_hash_table_size (hash_table) + 1);
+       g_hash_table_iter_init (&iter, hash_table);
+
+       while (g_hash_table_iter_next (&iter, &key, NULL))
+               ret[i++] = key;
+
+       ret[i] = NULL;
+
+       if (length)
+               *length = i;
+
+       return ret;
+}
+#endif
+#if !GLIB_CHECK_VERSION(2, 40, 0)
+#define g_hash_table_get_keys_as_array(hash_table, length) \
+       ({ \
+               _nm_g_hash_table_get_keys_as_array (hash_table, length); \
+       })
+#else
+#define g_hash_table_get_keys_as_array(hash_table, length) \
+       ({ \
+               G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+                       (g_hash_table_get_keys_as_array) ((hash_table), (length)); \
+               G_GNUC_END_IGNORE_DEPRECATIONS \
+       })
+#endif
+
+#ifndef g_info
+/* g_info was only added with 2.39.2 */
+#define g_info(...)     g_log (G_LOG_DOMAIN,         \
+                               G_LOG_LEVEL_INFO,     \
+                               __VA_ARGS__)
+#endif
+
+#if !GLIB_CHECK_VERSION(2, 44, 0)
+static inline gpointer
+g_steal_pointer (gpointer pp)
+{
+       gpointer *ptr = (gpointer *) pp;
+       gpointer ref;
+
+       ref = *ptr;
+       *ptr = NULL;
+
+       return ref;
+}
+
+/* type safety */
+#define g_steal_pointer(pp) \
+  (0 ? (*(pp)) : (g_steal_pointer) (pp))
+#endif
+
+
+static inline gboolean
+_nm_g_strv_contains (const gchar * const *strv,
+                     const gchar         *str)
+{
+#if !GLIB_CHECK_VERSION(2, 44, 0)
+       g_return_val_if_fail (strv != NULL, FALSE);
+       g_return_val_if_fail (str != NULL, FALSE);
+
+       for (; *strv != NULL; strv++) {
+               if (g_str_equal (str, *strv))
+                       return TRUE;
+       }
+
+       return FALSE;
+#else
+       G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+       return g_strv_contains (strv, str);
+       G_GNUC_END_IGNORE_DEPRECATIONS
+#endif
+}
+#define g_strv_contains _nm_g_strv_contains
+
+static inline GVariant *
+_nm_g_variant_new_take_string (gchar *string)
+{
+#if !GLIB_CHECK_VERSION(2, 36, 0)
+       GVariant *value;
+
+       g_return_val_if_fail (string != NULL, NULL);
+       g_return_val_if_fail (g_utf8_validate (string, -1, NULL), NULL);
+
+       value = g_variant_new_string (string);
+       g_free (string);
+       return value;
+#elif !GLIB_CHECK_VERSION(2, 38, 0)
+       GVariant *value;
+       GBytes *bytes;
+
+       g_return_val_if_fail (string != NULL, NULL);
+       g_return_val_if_fail (g_utf8_validate (string, -1, NULL), NULL);
+
+       bytes = g_bytes_new_take (string, strlen (string) + 1);
+       value = g_variant_new_from_bytes (G_VARIANT_TYPE_STRING, bytes, TRUE);
+       g_bytes_unref (bytes);
+
+       return value;
+#else
+       G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+       return g_variant_new_take_string (string);
+       G_GNUC_END_IGNORE_DEPRECATIONS
+#endif
+}
+#define g_variant_new_take_string _nm_g_variant_new_take_string
+
+#endif  /* __NM_GLIB_H__ */
diff --git a/shared/nm-utils/nm-macros-internal.h b/shared/nm-utils/nm-macros-internal.h
new file mode 100644
index 0000000..91970c3
--- /dev/null
+++ b/shared/nm-utils/nm-macros-internal.h
@@ -0,0 +1,721 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/* NetworkManager -- Network link manager
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * (C) Copyright 2014 Red Hat, Inc.
+ */
+
+#ifndef __NM_MACROS_INTERNAL_H__
+#define __NM_MACROS_INTERNAL_H__
+
+#include <stdlib.h>
+
+#include "nm-glib.h"
+
+/********************************************************/
+
+#define _nm_packed __attribute__ ((packed))
+#define _nm_unused __attribute__ ((unused))
+#define _nm_pure   __attribute__ ((pure))
+#define _nm_const  __attribute__ ((const))
+#define _nm_printf(a,b) __attribute__ ((__format__ (__printf__, a, b)))
+
+#define nm_auto(fcn) __attribute__ ((cleanup(fcn)))
+
+/**
+ * nm_auto_free:
+ *
+ * Call free() on a variable location when it goes out of scope.
+ */
+#define nm_auto_free nm_auto(_nm_auto_free_impl)
+GS_DEFINE_CLEANUP_FUNCTION(void*, _nm_auto_free_impl, free)
+
+static inline void
+_nm_auto_unset_gvalue_impl (GValue *v)
+{
+       g_value_unset (v);
+}
+#define nm_auto_unset_gvalue nm_auto(_nm_auto_unset_gvalue_impl)
+
+static inline void
+_nm_auto_free_gstring_impl (GString **str)
+{
+       if (*str)
+               g_string_free (*str, TRUE);
+}
+#define nm_auto_free_gstring nm_auto(_nm_auto_free_gstring_impl)
+
+/********************************************************/
+
+/* http://stackoverflow.com/a/11172679 */
+#define  _NM_UTILS_MACRO_FIRST(...)                           __NM_UTILS_MACRO_FIRST_HELPER(__VA_ARGS__, 
throwaway)
+#define __NM_UTILS_MACRO_FIRST_HELPER(first, ...)             first
+
+#define  _NM_UTILS_MACRO_REST(...)                            
__NM_UTILS_MACRO_REST_HELPER(__NM_UTILS_MACRO_REST_NUM(__VA_ARGS__), __VA_ARGS__)
+#define __NM_UTILS_MACRO_REST_HELPER(qty, ...)                __NM_UTILS_MACRO_REST_HELPER2(qty, __VA_ARGS__)
+#define __NM_UTILS_MACRO_REST_HELPER2(qty, ...)               __NM_UTILS_MACRO_REST_HELPER_##qty(__VA_ARGS__)
+#define __NM_UTILS_MACRO_REST_HELPER_ONE(first)
+#define __NM_UTILS_MACRO_REST_HELPER_TWOORMORE(first, ...)    , __VA_ARGS__
+#define __NM_UTILS_MACRO_REST_NUM(...) \
+    __NM_UTILS_MACRO_REST_SELECT_20TH(__VA_ARGS__, \
+                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
+                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
+                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
+                TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
+#define __NM_UTILS_MACRO_REST_SELECT_20TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, 
a16, a17, a18, a19, a20, ...) a20
+
+/********************************************************/
+
+/* http://stackoverflow.com/a/2124385/354393 */
+
+#define NM_NARG(...) \
+         _NM_NARG(__VA_ARGS__,_NM_NARG_RSEQ_N())
+#define _NM_NARG(...) \
+         _NM_NARG_ARG_N(__VA_ARGS__)
+#define _NM_NARG_ARG_N( \
+          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
+         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
+         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
+         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
+         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
+         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
+         _61,_62,_63,N,...) N
+#define _NM_NARG_RSEQ_N() \
+         63,62,61,60,                   \
+         59,58,57,56,55,54,53,52,51,50, \
+         49,48,47,46,45,44,43,42,41,40, \
+         39,38,37,36,35,34,33,32,31,30, \
+         29,28,27,26,25,24,23,22,21,20, \
+         19,18,17,16,15,14,13,12,11,10, \
+         9,8,7,6,5,4,3,2,1,0
+
+/********************************************************/
+
+#if defined (__GNUC__)
+#define _NM_PRAGMA_WARNING_DO(warning)       G_STRINGIFY(GCC diagnostic ignored warning)
+#elif defined (__clang__)
+#define _NM_PRAGMA_WARNING_DO(warning)       G_STRINGIFY(clang diagnostic ignored warning)
+#endif
+
+/* you can only suppress a specific warning that the compiler
+ * understands. Otherwise you will get another compiler warning
+ * about invalid pragma option.
+ * It's not that bad however, because gcc and clang often have the
+ * same name for the same warning. */
+
+#if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#define NM_PRAGMA_WARNING_DISABLE(warning) \
+        _Pragma("GCC diagnostic push") \
+        _Pragma(_NM_PRAGMA_WARNING_DO(warning))
+#elif defined (__clang__)
+#define NM_PRAGMA_WARNING_DISABLE(warning) \
+        _Pragma("clang diagnostic push") \
+        _Pragma(_NM_PRAGMA_WARNING_DO(warning))
+#else
+#define NM_PRAGMA_WARNING_DISABLE(warning)
+#endif
+
+#if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#define NM_PRAGMA_WARNING_REENABLE \
+    _Pragma("GCC diagnostic pop")
+#elif defined (__clang__)
+#define NM_PRAGMA_WARNING_REENABLE \
+    _Pragma("clang diagnostic pop")
+#else
+#define NM_PRAGMA_WARNING_REENABLE
+#endif
+
+/********************************************************/
+
+/**
+ * NM_G_ERROR_MSG:
+ * @error: (allow none): the #GError instance
+ *
+ * All functions must follow the convention that when they
+ * return a failure, they must also set the GError to a valid
+ * message. For external API however, we want to be extra
+ * careful before accessing the error instance. Use NM_G_ERROR_MSG()
+ * which is safe to use on NULL.
+ *
+ * Returns: the error message.
+ **/
+static inline const char *
+NM_G_ERROR_MSG (GError *error)
+{
+       return error ? (error->message ? : "(null)") : "(no-error)"; \
+}
+
+/********************************************************/
+
+/* macro to return strlen() of a compile time string. */
+#define NM_STRLEN(str)     ( sizeof ("" str) - 1 )
+
+#define NM_SET_OUT(out_val, value) \
+       G_STMT_START { \
+               typeof(*(out_val)) *_out_val = (out_val); \
+               \
+               if (_out_val) { \
+                       *_out_val = (value); \
+               } \
+       } G_STMT_END
+
+/********************************************************/
+
+#define _NM_IN_SET_EVAL_1(op, _x, y1)                               \
+    (_x == (y1))
+
+#define _NM_IN_SET_EVAL_2(op, _x, y1, y2)                           \
+    (   (_x == (y1))                                                \
+     op (_x == (y2))                                                \
+    )
+
+#define _NM_IN_SET_EVAL_3(op, _x, y1, y2, y3)                       \
+    (   (_x == (y1))                                                \
+     op (_x == (y2))                                                \
+     op (_x == (y3))                                                \
+    )
+
+#define _NM_IN_SET_EVAL_4(op, _x, y1, y2, y3, y4)                   \
+    (   (_x == (y1))                                                \
+     op (_x == (y2))                                                \
+     op (_x == (y3))                                                \
+     op (_x == (y4))                                                \
+    )
+
+#define _NM_IN_SET_EVAL_5(op, _x, y1, y2, y3, y4, y5)               \
+    (   (_x == (y1))                                                \
+     op (_x == (y2))                                                \
+     op (_x == (y3))                                                \
+     op (_x == (y4))                                                \
+     op (_x == (y5))                                                \
+    )
+
+#define _NM_IN_SET_EVAL_6(op, _x, y1, y2, y3, y4, y5, y6)           \
+    (   (_x == (y1))                                                \
+     op (_x == (y2))                                                \
+     op (_x == (y3))                                                \
+     op (_x == (y4))                                                \
+     op (_x == (y5))                                                \
+     op (_x == (y6))                                                \
+    )
+
+#define _NM_IN_SET_EVAL_N2(op, _x, n, ...)        _NM_IN_SET_EVAL_##n(op, _x, __VA_ARGS__)
+#define _NM_IN_SET_EVAL_N(op, x, n, ...)                            \
+    ({                                                              \
+        typeof(x) _x = (x);                                         \
+        !!_NM_IN_SET_EVAL_N2(op, _x, n, __VA_ARGS__);               \
+    })
+
+/* Beware that this does short-circuit evaluation (use "||" instead of "|")
+ * which has a possibly unexpected non-function-like behavior.
+ * Use NM_IN_SET_SE if you need all arguments to be evaluted. */
+#define NM_IN_SET(x, ...)               _NM_IN_SET_EVAL_N(||, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
+
+/* "SE" stands for "side-effect". Contrary to NM_IN_SET(), this does not do
+ * short-circuit evaluation, which can make a difference if the arguments have
+ * side-effects. */
+#define NM_IN_SET_SE(x, ...)            _NM_IN_SET_EVAL_N(|, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
+
+/********************************************************/
+
+static inline gboolean
+_NM_IN_STRSET_streq (const char *x, const char *s)
+{
+       return s && strcmp (x, s) == 0;
+}
+
+#define _NM_IN_STRSET_EVAL_1(op, _x, y1)                            \
+    _NM_IN_STRSET_streq (_x, y1)
+
+#define _NM_IN_STRSET_EVAL_2(op, _x, y1, y2)                        \
+    (   _NM_IN_STRSET_streq (_x, y1)                                \
+     op _NM_IN_STRSET_streq (_x, y2)                                \
+    )
+
+#define _NM_IN_STRSET_EVAL_3(op, _x, y1, y2, y3)                    \
+    (   _NM_IN_STRSET_streq (_x, y1)                                \
+     op _NM_IN_STRSET_streq (_x, y2)                                \
+     op _NM_IN_STRSET_streq (_x, y3)                                \
+    )
+
+#define _NM_IN_STRSET_EVAL_4(op, _x, y1, y2, y3, y4)                \
+    (   _NM_IN_STRSET_streq (_x, y1)                                \
+     op _NM_IN_STRSET_streq (_x, y2)                                \
+     op _NM_IN_STRSET_streq (_x, y3)                                \
+     op _NM_IN_STRSET_streq (_x, y4)                                \
+    )
+
+#define _NM_IN_STRSET_EVAL_5(op, _x, y1, y2, y3, y4, y5)            \
+    (   _NM_IN_STRSET_streq (_x, y1)                                \
+     op _NM_IN_STRSET_streq (_x, y2)                                \
+     op _NM_IN_STRSET_streq (_x, y3)                                \
+     op _NM_IN_STRSET_streq (_x, y4)                                \
+     op _NM_IN_STRSET_streq (_x, y5)                                \
+    )
+
+#define _NM_IN_STRSET_EVAL_6(op, _x, y1, y2, y3, y4, y5, y6)        \
+    (   _NM_IN_STRSET_streq (_x, y1)                                \
+     op _NM_IN_STRSET_streq (_x, y2)                                \
+     op _NM_IN_STRSET_streq (_x, y3)                                \
+     op _NM_IN_STRSET_streq (_x, y4)                                \
+     op _NM_IN_STRSET_streq (_x, y5)                                \
+     op _NM_IN_STRSET_streq (_x, y6)                                \
+    )
+
+#define _NM_IN_STRSET_EVAL_N2(op, _x, n, ...) _NM_IN_STRSET_EVAL_##n(op, _x, __VA_ARGS__)
+#define _NM_IN_STRSET_EVAL_N(op, x, n, ...)                       \
+    ({                                                            \
+        const char *_x = (x);                                     \
+        (   ((_x == NULL) && _NM_IN_SET_EVAL_N2    (op, (const char *) NULL, n, __VA_ARGS__)) \
+         || ((_x != NULL) && _NM_IN_STRSET_EVAL_N2 (op, _x,                  n, __VA_ARGS__)) \
+        ); \
+    })
+
+/* Beware that this does short-circuit evaluation (use "||" instead of "|")
+ * which has a possibly unexpected non-function-like behavior.
+ * Use NM_IN_STRSET_SE if you need all arguments to be evaluted. */
+#define NM_IN_STRSET(x, ...)               _NM_IN_STRSET_EVAL_N(||, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
+
+/* "SE" stands for "side-effect". Contrary to NM_IN_STRSET(), this does not do
+ * short-circuit evaluation, which can make a difference if the arguments have
+ * side-effects. */
+#define NM_IN_STRSET_SE(x, ...)            _NM_IN_STRSET_EVAL_N(|, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
+
+/*****************************************************************************/
+
+#define nm_streq(s1, s2)  (strcmp (s1, s2) == 0)
+#define nm_streq0(s1, s2) (g_strcmp0 (s1, s2) == 0)
+
+/*****************************************************************************/
+
+#define nm_str_not_empty(str) \
+       ({ \
+               /* implemented as macro to preserve constness */ \
+               typeof (str) __str = (str); \
+               _nm_unused const char *__str_type_check = __str; \
+               ((__str && __str[0]) ? __str : ((char *) NULL)); \
+       })
+
+static inline char *
+nm_strdup_not_empty (const char *str)
+{
+       return str && str[0] ? g_strdup (str) : NULL;
+}
+
+/*****************************************************************************/
+
+#define NM_PRINT_FMT_QUOTED(cond, prefix, str, suffix, str_else) \
+       (cond) ? (prefix) : "", \
+       (cond) ? (str) : (str_else), \
+       (cond) ? (suffix) : ""
+#define NM_PRINT_FMT_QUOTE_STRING(arg) NM_PRINT_FMT_QUOTED((arg), "\"", (arg), "\"", "(null)")
+
+/*****************************************************************************/
+
+/* glib/C provides the following kind of assertions:
+ *   - assert() -- disable with NDEBUG
+ *   - g_return_if_fail() -- disable with G_DISABLE_CHECKS
+ *   - g_assert() -- disable with G_DISABLE_ASSERT
+ * but they are all enabled by default and usually even production builds have
+ * these kind of assertions enabled. It also means, that disabling assertions
+ * is an untested configuration, and might have bugs.
+ *
+ * Add our own assertion macro nm_assert(), which is disabled by default and must
+ * be explicitly enabled. They are useful for more expensive checks or checks that
+ * depend less on runtime conditions (that is, are generally expected to be true). */
+
+#ifndef NM_MORE_ASSERTS
+#define NM_MORE_ASSERTS 0
+#endif
+
+#if NM_MORE_ASSERTS
+#define nm_assert(cond) G_STMT_START { g_assert (cond); } G_STMT_END
+#define nm_assert_not_reached() G_STMT_START { g_assert_not_reached (); } G_STMT_END
+#else
+#define nm_assert(cond) G_STMT_START { if (FALSE) { if (cond) { } } } G_STMT_END
+#define nm_assert_not_reached() G_STMT_START { ; } G_STMT_END
+#endif
+
+/*****************************************************************************/
+
+#define NM_GOBJECT_PROPERTIES_DEFINE_BASE(...) \
+typedef enum { \
+       _PROPERTY_ENUMS_0, \
+       __VA_ARGS__ \
+       _PROPERTY_ENUMS_LAST, \
+} _PropertyEnums; \
+static GParamSpec *obj_properties[_PROPERTY_ENUMS_LAST] = { NULL, }
+
+#define NM_GOBJECT_PROPERTIES_DEFINE(obj_type, ...) \
+NM_GOBJECT_PROPERTIES_DEFINE_BASE (__VA_ARGS__); \
+static inline void \
+_notify (obj_type *obj, _PropertyEnums prop) \
+{ \
+       nm_assert (G_IS_OBJECT (obj)); \
+       nm_assert ((gsize) prop < G_N_ELEMENTS (obj_properties)); \
+       g_object_notify_by_pspec ((GObject *) obj, obj_properties[prop]); \
+}
+
+/*****************************************************************************/
+
+#define __NM_GET_PRIVATE(self, type, is_check, result_cmd) \
+       ({ \
+               /* preserve the const-ness of self. Unfortunately, that
+                * way, @self cannot be a void pointer */ \
+               typeof (self) _self = (self); \
+               \
+               /* Get compiler error if variable is of wrong type */ \
+               _nm_unused const type *_self2 = (_self); \
+               \
+               nm_assert (is_check (_self)); \
+               ( result_cmd ); \
+       })
+
+#define _NM_GET_PRIVATE(self, type, is_check)     __NM_GET_PRIVATE(self, type, is_check, &_self->_priv)
+#define _NM_GET_PRIVATE_PTR(self, type, is_check) __NM_GET_PRIVATE(self, type, is_check,  _self->_priv)
+
+/*****************************************************************************/
+
+static inline gpointer
+nm_g_object_ref (gpointer obj)
+{
+       /* g_object_ref() doesn't accept NULL. */
+       if (obj)
+               g_object_ref (obj);
+       return obj;
+}
+
+static inline void
+nm_g_object_unref (gpointer obj)
+{
+       /* g_object_unref() doesn't accept NULL. Usully, we workaround that
+        * by using g_clear_object(), but sometimes that is not convinient
+        * (for example as as destroy function for a hash table that can contain
+        * NULL values). */
+       if (obj)
+               g_object_unref (obj);
+}
+
+static inline gboolean
+nm_clear_g_source (guint *id)
+{
+       if (id && *id) {
+               g_source_remove (*id);
+               *id = 0;
+               return TRUE;
+       }
+       return FALSE;
+}
+
+static inline gboolean
+nm_clear_g_signal_handler (gpointer self, gulong *id)
+{
+       if (id && *id) {
+               g_signal_handler_disconnect (self, *id);
+               *id = 0;
+               return TRUE;
+       }
+       return FALSE;
+}
+
+static inline gboolean
+nm_clear_g_variant (GVariant **variant)
+{
+       if (variant && *variant) {
+               g_variant_unref (*variant);
+               *variant = NULL;
+               return TRUE;
+       }
+       return FALSE;
+}
+
+static inline gboolean
+nm_clear_g_cancellable (GCancellable **cancellable)
+{
+       if (cancellable && *cancellable) {
+               g_cancellable_cancel (*cancellable);
+               g_object_unref (*cancellable);
+               *cancellable = NULL;
+               return TRUE;
+       }
+       return FALSE;
+}
+
+/*****************************************************************************/
+
+/* Determine whether @x is a power of two (@x being an integer type).
+ * For the special cases @x equals zero or one, it also returns true.
+ * For negative @x, always returns FALSE. That only applies, if the data
+ * type of @x is signed. */
+#define nm_utils_is_power_of_two(x) ({ \
+               typeof(x) __x = (x); \
+               \
+               /* Check if the value is negative. In that case, return FALSE.
+                * The first expression is a compile time constant, depending on whether
+                * the type is signed. The second expression is a clumsy way for (__x >= 0),
+                * which causes a compiler warning for unsigned types. */ \
+                   ( ( ((typeof(__x)) -1) > ((typeof(__x)) 0) ) || (__x > 0) || (__x == 0) ) \
+                && ((__x & (__x - 1)) == 0); \
+       })
+
+/*****************************************************************************/
+
+/* check if @flags has exactly one flag (@check) set. You should call this
+ * only with @check being a compile time constant and a power of two. */
+#define NM_FLAGS_HAS(flags, check)  \
+    ( (G_STATIC_ASSERT_EXPR ( ((check) != 0) && ((check) & ((check)-1)) == 0 )), (NM_FLAGS_ANY ((flags), 
(check))) )
+
+#define NM_FLAGS_ANY(flags, check)  ( ( ((flags) & (check)) != 0       ) ? TRUE : FALSE )
+#define NM_FLAGS_ALL(flags, check)  ( ( ((flags) & (check)) == (check) ) ? TRUE : FALSE )
+
+#define NM_FLAGS_SET(flags, val)  ({ \
+               const typeof(flags) _flags = (flags); \
+               const typeof(flags) _val = (val); \
+               \
+               _flags | _val; \
+       })
+
+#define NM_FLAGS_UNSET(flags, val)  ({ \
+               const typeof(flags) _flags = (flags); \
+               const typeof(flags) _val = (val); \
+               \
+               _flags & (~_val); \
+       })
+
+#define NM_FLAGS_ASSIGN(flags, val, assign)  ({ \
+               const typeof(flags) _flags = (flags); \
+               const typeof(flags) _val = (val); \
+               \
+               (assign) \
+                       ? _flags | (_val) \
+                       : _flags & (~_val); \
+       })
+
+/*****************************************************************************/
+
+#define _NM_BACKPORT_SYMBOL_IMPL(VERSION, RETURN_TYPE, ORIG_FUNC, VERSIONED_FUNC, ARGS_TYPED, ARGS) \
+RETURN_TYPE VERSIONED_FUNC ARGS_TYPED; \
+RETURN_TYPE VERSIONED_FUNC ARGS_TYPED \
+{ \
+    return ORIG_FUNC ARGS; \
+} \
+RETURN_TYPE ORIG_FUNC ARGS_TYPED; \
+__asm__(".symver "G_STRINGIFY(VERSIONED_FUNC)", "G_STRINGIFY(ORIG_FUNC)"@"G_STRINGIFY(VERSION))
+
+#define NM_BACKPORT_SYMBOL(VERSION, RETURN_TYPE, FUNC, ARGS_TYPED, ARGS) \
+_NM_BACKPORT_SYMBOL_IMPL(VERSION, RETURN_TYPE, FUNC, _##FUNC##_##VERSION, ARGS_TYPED, ARGS)
+
+/*****************************************************************************/
+
+static inline char *
+nm_strstrip (char *str)
+{
+       /* g_strstrip doesn't like NULL. */
+       return str ? g_strstrip (str) : NULL;
+}
+
+/* g_ptr_array_sort()'s compare function takes pointers to the
+ * value. Thus, you cannot use strcmp directly. You can use
+ * nm_strcmp_p().
+ *
+ * Like strcmp(), this function is not forgiving to accept %NULL. */
+static inline int
+nm_strcmp_p (gconstpointer a, gconstpointer b)
+{
+       const char *s1 = *((const char **) a);
+       const char *s2 = *((const char **) b);
+
+       return strcmp (s1, s2);
+}
+
+/* like nm_strcmp_p(), suitable for g_ptr_array_sort_with_data().
+ * g_ptr_array_sort() just casts nm_strcmp_p() to a function of different
+ * signature. I guess, in glib there are knowledgeable people that ensure
+ * that this additional argument doesn't cause problems due to different ABI
+ * for every architecture that glib supports.
+ * For NetworkManager, we'd rather avoid such stunts.
+ **/
+static inline int
+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);
+}
+
+/*****************************************************************************/
+
+/* Taken from systemd's UNIQ_T and UNIQ macros. */
+
+#define NM_UNIQ_T(x, uniq) G_PASTE(__unique_prefix_, G_PASTE(x, uniq))
+#define NM_UNIQ __COUNTER__
+
+/*****************************************************************************/
+
+/* glib's MIN()/MAX() macros don't have function-like behavior, in that they evaluate
+ * the argument possibly twice.
+ *
+ * Taken from systemd's MIN()/MAX() macros. */
+
+#define NM_MIN(a, b) __NM_MIN(NM_UNIQ, a, NM_UNIQ, b)
+#define __NM_MIN(aq, a, bq, b) \
+       ({ \
+               typeof (a) NM_UNIQ_T(A, aq) = (a); \
+               typeof (b) NM_UNIQ_T(B, bq) = (b); \
+               ((NM_UNIQ_T(A, aq) < NM_UNIQ_T(B, bq)) ? NM_UNIQ_T(A, aq) : NM_UNIQ_T(B, bq)); \
+       })
+
+#define NM_MAX(a, b) __NM_MAX(NM_UNIQ, a, NM_UNIQ, b)
+#define __NM_MAX(aq, a, bq, b) \
+       ({ \
+               typeof (a) NM_UNIQ_T(A, aq) = (a); \
+               typeof (b) NM_UNIQ_T(B, bq) = (b); \
+               ((NM_UNIQ_T(A, aq) > NM_UNIQ_T(B, bq)) ? NM_UNIQ_T(A, aq) : NM_UNIQ_T(B, bq)); \
+       })
+
+#define NM_CLAMP(x, low, high) __NM_CLAMP(NM_UNIQ, x, NM_UNIQ, low, NM_UNIQ, high)
+#define __NM_CLAMP(xq, x, lowq, low, highq, high) \
+       ({ \
+               typeof(x)NM_UNIQ_T(X,xq) = (x); \
+               typeof(low) NM_UNIQ_T(LOW,lowq) = (low); \
+               typeof(high) NM_UNIQ_T(HIGH,highq) = (high); \
+               \
+               ( (NM_UNIQ_T(X,xq) > NM_UNIQ_T(HIGH,highq)) \
+                 ? NM_UNIQ_T(HIGH,highq) \
+                 : (NM_UNIQ_T(X,xq) < NM_UNIQ_T(LOW,lowq)) \
+                    ? NM_UNIQ_T(LOW,lowq) \
+                    : NM_UNIQ_T(X,xq)); \
+       })
+
+/*****************************************************************************/
+
+static inline guint
+nm_encode_version (guint major, guint minor, guint micro) {
+       /* analog to the preprocessor macro NM_ENCODE_VERSION(). */
+       return (major << 16) | (minor << 8) | micro;
+}
+
+static inline void
+nm_decode_version (guint version, guint *major, guint *minor, guint *micro) {
+       *major = (version & 0xFFFF0000u) >> 16;
+       *minor = (version & 0x0000FF00u) >>  8;
+       *micro = (version & 0x000000FFu);
+}
+/*****************************************************************************/
+
+/* if @str is NULL, return "(null)". Otherwise, allocate a buffer using
+ * alloca() of size @bufsize and fill it with @str. @str will be quoted with
+ * single quote, and in case @str is too long, the final quote will be '^'. */
+#define nm_strquote_a(bufsize, str) \
+       ({ \
+               G_STATIC_ASSERT ((bufsize) >= 6); \
+               const gsize _BUFSIZE = (bufsize); \
+               const char *const _s = (str); \
+               char *_r; \
+               gsize _l; \
+               gboolean _truncated; \
+               \
+               nm_assert (_BUFSIZE >= 6); \
+               \
+               if (_s) { \
+                       _l = strlen (_s) + 3; \
+                       if ((_truncated = (_BUFSIZE < _l))) \
+                               _l = _BUFSIZE; \
+                       \
+                       _r = g_alloca (_l); \
+                       _r[0] = '\''; \
+                       memcpy (&_r[1], _s, _l - 3); \
+                       _r[_l - 2] = _truncated ? '^' : '\''; \
+                       _r[_l - 1] = '\0'; \
+               } else \
+                       _r = "(null)"; \
+               _r; \
+       })
+
+#define nm_sprintf_buf(buf, format, ...) ({ \
+               char * _buf = (buf); \
+               \
+               /* some static assert trying to ensure that the buffer is statically allocated.
+                * It disallows a buffer size of sizeof(gpointer) to catch that. */ \
+               G_STATIC_ASSERT (G_N_ELEMENTS (buf) == sizeof (buf) && sizeof (buf) != sizeof (char *)); \
+               g_snprintf (_buf, sizeof (buf), \
+                           ""format"", ##__VA_ARGS__); \
+               _buf; \
+       })
+
+#define nm_sprintf_bufa(n_elements, format, ...) \
+       ({ \
+               char *_buf; \
+               \
+               G_STATIC_ASSERT (sizeof (char[MAX ((n_elements), 1)]) == (n_elements)); \
+               _buf = g_alloca (n_elements); \
+               g_snprintf (_buf, n_elements, \
+                           ""format"", ##__VA_ARGS__); \
+               _buf; \
+       })
+
+/*****************************************************************************/
+
+/**
+ * The boolean type _Bool is C99 while we mostly stick to C89. However, _Bool is too
+ * convinient to miss and is effectively available in gcc and clang. So, just use it.
+ *
+ * Usually, one would include "stdbool.h" to get the "bool" define which aliases
+ * _Bool. We provide this define here, because we want to make use of it anywhere.
+ * (also, stdbool.h is again C99).
+ *
+ * Using _Bool has advantages over gboolean:
+ *
+ * - commonly _Bool is one byte large, instead of gboolean's 4 bytes (because gboolean
+ *   is a typedef for gint). Especially when having boolean fields in a struct, we can
+ *   thereby easily save some space.
+ *
+ * - _Bool type guarantees that two "true" expressions compare equal. E.g. the follwing
+ *   will not work:
+ *        gboolean v1 = 1;
+ *        gboolean v2 = 2;
+ *        g_assert_cmpint (v1, ==, v2); // will fail
+ *   For that, we often to use !! to coerce gboolean values to 0 or 1:
+ *        g_assert_cmpint (!!v2, ==, TRUE);
+ *   With _Bool type, this will be handled properly by the compiler.
+ *
+ * - For structs, we might want to safe even more space and use bitfields:
+ *       struct s1 {
+ *           gboolean v1:1;
+ *       };
+ *   But the problem here is that gboolean is signed, so that
+ *   v1 will be either 0 or -1 (not 1, TRUE). Thus, the following
+ *   fails:
+ *      struct s1 s = { .v1 = TRUE, };
+ *      g_assert_cmpint (s1.v1, ==, TRUE);
+ *   It will however work just fine with bool/_Bool while retaining the
+ *   notion of having a boolean value.
+ *
+ * Also, add the defines for "true" and "false". Those are nicely highlighted by the editor
+ * as special types, contrary to glib's "TRUE"/"FALSE".
+ */
+
+#ifndef bool
+#define bool _Bool
+#define true    1
+#define false   0
+#endif
+
+/*****************************************************************************/
+
+#endif /* __NM_MACROS_INTERNAL_H__ */
diff --git a/shared/nm-utils/nm-shared-utils.c b/shared/nm-utils/nm-shared-utils.c
new file mode 100644
index 0000000..38f6529
--- /dev/null
+++ b/shared/nm-utils/nm-shared-utils.c
@@ -0,0 +1,239 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/* NetworkManager -- Network link manager
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * (C) Copyright 2016 Red Hat, Inc.
+ */
+
+#include "nm-default.h"
+
+#include "nm-shared-utils.h"
+
+#include <errno.h>
+
+/*****************************************************************************/
+
+/* _nm_utils_ascii_str_to_int64:
+ *
+ * A wrapper for g_ascii_strtoll, that checks whether the whole string
+ * can be successfully converted to a number and is within a given
+ * range. On any error, @fallback will be returned and %errno will be set
+ * to a non-zero value. On success, %errno will be set to zero, check %errno
+ * for errors. Any trailing or leading (ascii) white space is ignored and the
+ * functions is locale independent.
+ *
+ * The function is guaranteed to return a value between @min and @max
+ * (inclusive) or @fallback. Also, the parsing is rather strict, it does
+ * not allow for any unrecognized characters, except leading and trailing
+ * white space.
+ **/
+gint64
+_nm_utils_ascii_str_to_int64 (const char *str, guint base, gint64 min, gint64 max, gint64 fallback)
+{
+       gint64 v;
+       char *s = NULL;
+
+       if (str) {
+               while (g_ascii_isspace (str[0]))
+                       str++;
+       }
+       if (!str || !str[0]) {
+               errno = EINVAL;
+               return fallback;
+       }
+
+       errno = 0;
+       v = g_ascii_strtoll (str, &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;
+       }
+
+       return v;
+}
+
+/*****************************************************************************/
+
+gint
+_nm_utils_ascii_str_to_bool (const char *str,
+                             gint default_value)
+{
+       gsize len;
+       char *s = NULL;
+
+       if (!str)
+               return default_value;
+
+       while (str[0] && g_ascii_isspace (str[0]))
+               str++;
+
+       if (!str[0])
+               return default_value;
+
+       len = strlen (str);
+       if (g_ascii_isspace (str[len - 1])) {
+               s = g_strdup (str);
+               g_strchomp (s);
+               str = s;
+       }
+
+       if (!g_ascii_strcasecmp (str, "true") || !g_ascii_strcasecmp (str, "yes") || !g_ascii_strcasecmp 
(str, "on") || !g_ascii_strcasecmp (str, "1"))
+               default_value = TRUE;
+       else if (!g_ascii_strcasecmp (str, "false") || !g_ascii_strcasecmp (str, "no") || !g_ascii_strcasecmp 
(str, "off") || !g_ascii_strcasecmp (str, "0"))
+               default_value = FALSE;
+       if (s)
+               g_free (s);
+       return default_value;
+}
+
+/*****************************************************************************/
+
+G_DEFINE_QUARK (nm-utils-error-quark, nm_utils_error)
+
+void
+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");
+       }
+}
+
+gboolean
+nm_utils_error_is_cancelled (GError *error,
+                             gboolean consider_is_disposing)
+{
+       if (error) {
+               if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+                       return TRUE;
+               if (   consider_is_disposing
+                   && g_error_matches (error, NM_UTILS_ERROR, NM_UTILS_ERROR_CANCELLED_DISPOSING))
+                       return TRUE;
+       }
+       return FALSE;
+}
+
+/*****************************************************************************/
+
+/**
+ * nm_g_object_set_property:
+ * @object: the target object
+ * @property_name: the property name
+ * @value: the #GValue to set
+ * @error: (allow-none): optional error argument
+ *
+ * A reimplementation of g_object_set_property(), but instead
+ * returning an error instead of logging a warning. All g_object_set*()
+ * versions in glib require you to not pass invalid types or they will
+ * log a g_warning() -- without reporting an error. We don't want that,
+ * so we need to hack error checking around it.
+ *
+ * Returns: whether the value was successfully set.
+ */
+gboolean
+nm_g_object_set_property (GObject *object,
+                          const gchar  *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;
+}
+
+/*****************************************************************************/
diff --git a/shared/nm-utils/nm-shared-utils.h b/shared/nm-utils/nm-shared-utils.h
new file mode 100644
index 0000000..cfa8f99
--- /dev/null
+++ b/shared/nm-utils/nm-shared-utils.h
@@ -0,0 +1,66 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/* NetworkManager -- Network link manager
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * (C) Copyright 2016 Red Hat, Inc.
+ */
+
+#ifndef __NM_SHARED_UTILS_H__
+#define __NM_SHARED_UTILS_H__
+
+/******************************************************************************/
+
+gint64 _nm_utils_ascii_str_to_int64 (const char *str, guint base, gint64 min, gint64 max, gint64 fallback);
+
+gint _nm_utils_ascii_str_to_bool (const char *str,
+                                  gint default_value);
+
+/******************************************************************************/
+
+/**
+ * NMUtilsError:
+ * @NM_UTILS_ERROR_UNKNOWN: unknown or unclassified error
+ * @NM_UTILS_ERROR_CANCELLED_DISPOSING: when disposing an object that has
+ *   pending aynchronous operations, the operation is cancelled with this
+ *   error reason. Depending on the usage, this might indicate a bug because
+ *   usually the target object should stay alive as long as there are pending
+ *   operations.
+ */
+typedef enum {
+       NM_UTILS_ERROR_UNKNOWN = 0,                 /*< nick=Unknown >*/
+       NM_UTILS_ERROR_CANCELLED_DISPOSING,         /*< nick=CancelledDisposing >*/
+} NMUtilsError;
+
+#define NM_UTILS_ERROR (nm_utils_error_quark ())
+GQuark nm_utils_error_quark (void);
+
+void nm_utils_error_set_cancelled (GError **error,
+                                   gboolean is_disposing,
+                                   const char *instance_name);
+gboolean nm_utils_error_is_cancelled (GError *error,
+                                      gboolean consider_is_disposing);
+
+/******************************************************************************/
+
+gboolean nm_g_object_set_property (GObject *object,
+                                   const gchar  *property_name,
+                                   const GValue *value,
+                                   GError **error);
+
+/******************************************************************************/
+
+#endif /* __NM_SHARED_UTILS_H__ */
diff --git a/shared/nm-utils/nm-test-utils.h b/shared/nm-utils/nm-test-utils.h
new file mode 100644
index 0000000..dba41c4
--- /dev/null
+++ b/shared/nm-utils/nm-test-utils.h
@@ -0,0 +1,1753 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright 2014 Red Hat, Inc.
+ */
+
+#ifndef __NM_TEST_UTILS_H__
+#define __NM_TEST_UTILS_H__
+
+/*******************************************************************************
+ * HOWTO run tests.
+ *
+ * Our tests (make check) include this header-only file nm-test-utils.h.
+ *
+ * Logging:
+ *   In tests, nm-logging redirects to glib logging. By default, glib suppresses all debug
+ *   messages unless you set G_MESSAGES_DEBUG. To enable debug logging, you can explicitly set
+ *   G_MESSAGES_DEBUG. Otherwise, nm-test will set G_MESSAGES_DEBUG=all in debug mode (see below).
+ *   For nm-logging, you can configure the log-level and domains via NMTST_DEBUG environment
+ *   variable.
+ *
+ * Assert-logging:
+ *   Some tests assert against logged messages (g_test_expect_message()).
+ *   By specifying no-expect-message in NMTST_DEBUG, you can disable assert logging
+ *   and g_test_assert_expected_messages() will not fail.
+ *
+ * NMTST_SEED_RAND environment variable:
+ *   Tests that use random numbers from nmtst_get_rand() get seeded randomly at each start.
+ *   You can specify the seed by setting NMTST_SEED_RAND. Also, tests will print the seed
+ *   to stdout, so that you know the choosen seed.
+ *
+ *
+ * NMTST_DEBUG environment variable:
+ *
+ * "debug", "no-debug": when at test is run in debug mode, it might behave differently,
+ *   depending on the test. See nmtst_is_debug().
+ *   Known differences:
+ *    - a test might leave the logging level unspecified. In this case, running in
+ *      debug mode, will turn on DEBUG logging, otherwise WARN logging only.
+ *    - if G_MESSAGES_DEBUG is unset, nm-test will set G_MESSAGES_DEBUG=all
+ *      for tests that don't do assert-logging.
+ *   Debug mode is determined as follows (highest priority first):
+ *    - command line option --debug/--no-debug
+ *    - NMTST_DEBUG=debug/no-debug
+ *    - setting NMTST_DEBUG implies debugging turned on
+ *    - g_test_verbose()
+ *
+ * "no-expect-message": for tests that would assert against log messages, disable
+ *   those asserts.
+ *
+ * "log-level=LEVEL", "log-domains=DOMAIN": reset the log level and domain for tests.
+ *    It only has an effect for nm-logging messages.
+ *    This has no effect if the test asserts against logging (unless no-expect-message),
+ *    otherwise, changing the logging would break tests.
+ *    If you set the level to DEBUG or TRACE, it also sets G_MESSAGES_DEBUG=all (unless
+ *    in assert-logging mode and unless G_MESSAGES_DEBUG is already defined).
+ *
+ * "TRACE", this is shorthand for "log-level=TRACE".
+ *
+ * "D", this is shorthand for "log-level=TRACE,no-expect-message".
+ *
+ * "sudo-cmd=PATH": when running root tests as normal user, the test will execute
+ *   itself by invoking sudo at PATH.
+ *   For example
+ *     NMTST_DEBUG="sudo-cmd=$PWD/tools/test-sudo-wrapper.sh" make -C src/platform/tests/ check
+ *
+ * "slow|quick|thorough": enable/disable long-running tests. This sets nmtst_test_quick().
+ *   Whether long-running tests are enabled is determined as follows (highest priority first):
+ *     - specifying the value in NMTST_DEBUG has highest priority
+ *     - respect g_test_quick(), if the command line contains '-mslow', '-mquick', '-mthorough'.
+ *     - use compile time default
+ *
+ * "p=PATH"|"s=PATH": passes the path to g_test_init() as "-p" and "-s", respectively.
+ *   Unfortunately, these options conflict with "--tap" which our makefile passes to the
+ *   tests, thus it's only useful outside of `make check`.
+ *
+ *******************************************************************************/
+
+#include "nm-default.h"
+
+#if defined(NM_ASSERT_NO_MSG) && NM_ASSERT_NO_MSG
+#undef g_return_if_fail_warning
+#undef g_assertion_message_expr
+#endif
+
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "nm-utils.h"
+
+/*******************************************************************************/
+
+#define NMTST_G_RETURN_MSG_S(expr) "*: assertion '"NM_ASSERT_G_RETURN_EXPR(expr)"' failed"
+#define NMTST_G_RETURN_MSG(expr)   NMTST_G_RETURN_MSG_S(#expr)
+
+/*******************************************************************************/
+
+/* general purpose functions that have no dependency on other nmtst functions */
+
+#define nmtst_assert_error(error, expect_error_domain, expect_error_code, expect_error_pattern) \
+       G_STMT_START { \
+               GError *_error = (error); \
+               GQuark _expect_error_domain = (expect_error_domain); \
+               const char *_expect_error_pattern = (expect_error_pattern); \
+               \
+               if (_expect_error_domain) \
+                       g_assert_error (_error, _expect_error_domain, (expect_error_code)); \
+               else \
+                       g_assert (_error); \
+               g_assert (_error->message); \
+               if (   _expect_error_pattern \
+                   && !g_pattern_match_simple (_expect_error_pattern, _error->message)) { \
+                       g_error ("%s:%d: error message does not have expected pattern '%s'. Instead it is 
'%s' (%s, %d)", \
+                                __FILE__, __LINE__, \
+                                _expect_error_pattern, _error->message, g_quark_to_string (_error->domain), 
_error->code); \
+               } \
+       } G_STMT_END
+
+#define NMTST_WAIT(max_wait_ms, wait) \
+       ({ \
+               gboolean _not_expired = TRUE; \
+               gint64 _nmtst_end, _nmtst_max_wait_us = (max_wait_ms) * 1000L; \
+               \
+               _nmtst_end = g_get_monotonic_time () + _nmtst_max_wait_us; \
+               while (TRUE) { \
+                       { wait }; \
+                       if (g_get_monotonic_time () > _nmtst_end) { \
+                               _not_expired = FALSE; \
+                               break; \
+                       } \
+               } \
+               _not_expired; \
+       })
+
+#define NMTST_WAIT_ASSERT(max_wait_ms, wait) \
+       G_STMT_START { \
+               if (!(NMTST_WAIT (max_wait_ms, wait))) \
+                       g_assert_not_reached (); \
+       } G_STMT_END
+
+#define nmtst_assert_success(success, error) \
+       G_STMT_START { \
+               g_assert_no_error (error); \
+               g_assert ((success)); \
+       } G_STMT_END
+
+#define nmtst_assert_no_success(success, error) \
+       G_STMT_START { \
+               g_assert (error); \
+               g_assert (!(success)); \
+       } G_STMT_END
+
+/*******************************************************************************/
+
+struct __nmtst_internal
+{
+       GRand *rand0;
+       guint32 rand_seed;
+       GRand *rand;
+       gboolean is_debug;
+       gboolean assert_logging;
+       gboolean no_expect_message;
+       gboolean test_quick;
+       gboolean test_tap_log;
+       char *sudo_cmd;
+       char **orig_argv;
+};
+
+extern struct __nmtst_internal __nmtst_internal;
+
+#define NMTST_DEFINE() \
+struct __nmtst_internal __nmtst_internal = { 0 }; \
+\
+__attribute__ ((destructor)) static void \
+_nmtst_exit (void) \
+{ \
+       __nmtst_internal.assert_logging = FALSE; \
+       g_test_assert_expected_messages (); \
+       nmtst_free (); \
+}
+
+
+inline static gboolean
+nmtst_initialized (void)
+{
+       return !!__nmtst_internal.rand0;
+}
+
+#define __NMTST_LOG(cmd, ...) \
+       G_STMT_START { \
+               g_assert (nmtst_initialized ()); \
+               if (!__nmtst_internal.assert_logging || __nmtst_internal.no_expect_message) { \
+                       cmd (__VA_ARGS__); \
+               } else { \
+                       printf (_NM_UTILS_MACRO_FIRST (__VA_ARGS__) "\n" _NM_UTILS_MACRO_REST (__VA_ARGS__)); 
\
+               } \
+       } G_STMT_END
+
+/* split the string inplace at specific delimiters, allowing escaping with '\\'.
+ * Returns a zero terminated array of pointers into @str.
+ *
+ * The caller must g_free() the returned argv array.
+ **/
+inline static char **
+nmtst_str_split (char *str, const char *delimiters)
+{
+       const char *d;
+       GArray *result = g_array_sized_new (TRUE, FALSE, sizeof (char *), 3);
+
+       g_assert (str);
+       g_assert (delimiters && !strchr (delimiters, '\\'));
+
+       while (*str) {
+               gsize i = 0, j = 0;
+
+               while (TRUE) {
+                       char c = str[i];
+
+                       if (c == '\0') {
+                               str[j++] = 0;
+                               break;
+                       } else if (c == '\\') {
+                               str[j++] = str[++i];
+                               if (!str[i])
+                                       break;
+                       } else {
+                               for (d = delimiters; *d; d++) {
+                                       if (c == *d) {
+                                               str[j++] = 0;
+                                               i++;
+                                               goto BREAK_INNER_LOOPS;
+                                       }
+                               }
+                               str[j++] = c;
+                       }
+                       i++;
+               }
+
+BREAK_INNER_LOOPS:
+               g_array_append_val (result, str);
+               str = &str[i];
+       }
+
+       return (char **) g_array_free (result, FALSE);
+}
+
+
+/* free instances allocated by nmtst (especially nmtst_init()) on shutdown
+ * to release memory. After nmtst_free(), the test is uninitialized again. */
+inline static void
+nmtst_free (void)
+{
+       if (!nmtst_initialized ())
+               return;
+
+       g_rand_free (__nmtst_internal.rand0);
+       if (__nmtst_internal.rand)
+               g_rand_free (__nmtst_internal.rand);
+       g_free (__nmtst_internal.sudo_cmd);
+       g_strfreev (__nmtst_internal.orig_argv);
+
+       memset (&__nmtst_internal, 0, sizeof (__nmtst_internal));
+}
+
+inline static void
+__nmtst_init (int *argc, char ***argv, gboolean assert_logging, const char *log_level, const char 
*log_domains, gboolean *out_set_logging)
+{
+       const char *nmtst_debug;
+       gboolean is_debug = FALSE;
+       char *c_log_level = NULL, *c_log_domains = NULL;
+       char *sudo_cmd = NULL;
+       GArray *debug_messages = g_array_new (TRUE, FALSE, sizeof (char *));
+       int i;
+       gboolean no_expect_message = FALSE;
+       gboolean _out_set_logging;
+       gboolean test_quick = FALSE;
+       gboolean test_quick_set = FALSE;
+       gboolean test_quick_argv = FALSE;
+       gs_unref_ptrarray GPtrArray *p_tests = NULL;
+       gs_unref_ptrarray GPtrArray *s_tests = NULL;
+
+       if (!out_set_logging)
+               out_set_logging = &_out_set_logging;
+       *out_set_logging = FALSE;
+
+       g_assert (!nmtst_initialized ());
+
+       g_assert (!((!!argc) ^ (!!argv)));
+       g_assert (!argc || (g_strv_length (*argv) == *argc));
+       g_assert (!assert_logging || (!log_level && !log_domains));
+
+#ifdef __NETWORKMANAGER_UTILS_H__
+       if (!nm_utils_get_testing_initialized ())
+               _nm_utils_set_testing (_NM_UTILS_TEST_GENERAL);
+#endif
+
+       if (argc)
+               __nmtst_internal.orig_argv = g_strdupv (*argv);
+
+       __nmtst_internal.assert_logging = !!assert_logging;
+
+       nm_g_type_init ();
+
+       is_debug = g_test_verbose ();
+
+       nmtst_debug = g_getenv ("NMTST_DEBUG");
+       if (nmtst_debug) {
+               char **d_argv, **i_argv, *nmtst_debug_copy;
+
+               /* By setting then NMTST_DEBUG variable, @is_debug is set automatically.
+                * This can be reverted with no-debug (on command line or environment variable). */
+               is_debug = TRUE;
+
+               nmtst_debug_copy = g_strdup (nmtst_debug);
+               d_argv = nmtst_str_split (nmtst_debug_copy, ",; \t\r\n");
+
+               for (i_argv = d_argv; *i_argv; i_argv++) {
+                       const char *debug = *i_argv;
+
+                       if (!g_ascii_strcasecmp (debug, "debug"))
+                               is_debug = TRUE;
+                       else if (!g_ascii_strcasecmp (debug, "no-debug")) {
+                               /* when specifying the NMTST_DEBUG variable, we set is_debug to true. Use 
this flag to disable this
+                                * (e.g. for only setting the log-level, but not is_debug). */
+                               is_debug = FALSE;
+                       } else if (!g_ascii_strncasecmp (debug, "log-level=", strlen ("log-level="))) {
+                               g_free (c_log_level);
+                               log_level = c_log_level = g_strdup (&debug[strlen ("log-level=")]);
+                       } else if (!g_ascii_strcasecmp (debug, "D")) {
+                               /* shorthand for "log-level=TRACE,no-expect-message" */
+                               g_free (c_log_level);
+                               log_level = c_log_level = g_strdup ("TRACE");
+                               no_expect_message = TRUE;
+                       } else if (!g_ascii_strcasecmp (debug, "TRACE")) {
+                               g_free (c_log_level);
+                               log_level = c_log_level = g_strdup ("TRACE");
+                       } else if (!g_ascii_strncasecmp (debug, "log-domains=", strlen ("log-domains="))) {
+                               g_free (c_log_domains);
+                               log_domains = c_log_domains = g_strdup (&debug[strlen ("log-domains=")]);
+                       } else if (!g_ascii_strncasecmp (debug, "sudo-cmd=", strlen ("sudo-cmd="))) {
+                               g_free (sudo_cmd);
+                               sudo_cmd = g_strdup (&debug[strlen ("sudo-cmd=")]);
+                       } else if (!g_ascii_strcasecmp (debug, "no-expect-message")) {
+                               no_expect_message = TRUE;
+                       } else if (!g_ascii_strncasecmp (debug, "p=", strlen ("p="))) {
+                               if (!p_tests)
+                                       p_tests = g_ptr_array_new_with_free_func (g_free);
+                               g_ptr_array_add (p_tests, g_strdup (&debug[strlen ("p=")]));
+                       } else if (!g_ascii_strncasecmp (debug, "s=", strlen ("s="))) {
+                               if (!s_tests)
+                                       s_tests = g_ptr_array_new_with_free_func (g_free);
+                               g_ptr_array_add (s_tests, g_strdup (&debug[strlen ("s=")]));
+                       } else if (!g_ascii_strcasecmp (debug, "slow") || !g_ascii_strcasecmp (debug, 
"thorough")) {
+                               test_quick = FALSE;
+                               test_quick_set = TRUE;
+                       } else if (!g_ascii_strcasecmp (debug, "quick")) {
+                               test_quick = TRUE;
+                               test_quick_set = TRUE;
+                       } else {
+                               char *msg = g_strdup_printf (">>> nmtst: ignore unrecognized NMTST_DEBUG 
option \"%s\"", debug);
+
+                               g_array_append_val (debug_messages, msg);
+                       }
+               }
+
+               g_free (d_argv);
+               g_free (nmtst_debug_copy);
+       }
+
+       if (__nmtst_internal.orig_argv) {
+               char **a = __nmtst_internal.orig_argv;
+
+               for (; *a; a++) {
+                       if (!g_ascii_strcasecmp (*a, "--debug"))
+                               is_debug = TRUE;
+                       else if (!g_ascii_strcasecmp (*a, "--no-debug"))
+                               is_debug = FALSE;
+                       else if (   !strcmp (*a, "-m=slow")
+                                || !strcmp (*a, "-m=thorough")
+                                || !strcmp (*a, "-m=quick")
+                                || (!strcmp (*a, "-m") && *(a+1)
+                                                       && (   !strcmp (*(a+1), "quick")
+                                                           || !strcmp (*(a+1), "slow")
+                                                           || !strcmp (*(a+1), "thorough"))))
+                               test_quick_argv = TRUE;
+                       else if (strcmp (*a, "--tap") == 0)
+                               __nmtst_internal.test_tap_log = TRUE;
+               }
+       }
+
+       if (!argc || g_test_initialized ()) {
+               if (p_tests || s_tests) {
+                       char *msg = g_strdup_printf (">>> nmtst: ignore -p and -s options for test which 
calls g_test_init() itself");
+
+                       g_array_append_val (debug_messages, msg);
+               }
+       } else {
+               /* g_test_init() is a variadic function, so we cannot pass it
+                * (variadic) arguments. If you need to pass additional parameters,
+                * call nmtst_init() with argc==NULL and call g_test_init() yourself. */
+
+               /* g_test_init() sets g_log_set_always_fatal() for G_LOG_LEVEL_WARNING
+                * and G_LOG_LEVEL_CRITICAL. So, beware that the test will fail if you
+                * have any WARN or ERR log messages -- unless you g_test_expect_message(). */
+               GPtrArray *arg_array = g_ptr_array_new ();
+               gs_free char **arg_array_c = NULL;
+               int arg_array_n, j;
+               static char **s_tests_x, **p_tests_x;
+
+               if (*argc) {
+                       for (i = 0; i < *argc; i++)
+                               g_ptr_array_add (arg_array, (*argv)[i]);
+               } else
+                       g_ptr_array_add (arg_array, "./test");
+
+               if (test_quick_set && !test_quick_argv)
+                       g_ptr_array_add (arg_array, "-m=quick");
+
+               if (!__nmtst_internal.test_tap_log) {
+                       for (i = 0; p_tests && i < p_tests->len; i++) {
+                               g_ptr_array_add (arg_array, "-p");
+                               g_ptr_array_add (arg_array, p_tests->pdata[i]);
+                       }
+                       for (i = 0; s_tests && i < s_tests->len; i++) {
+                               g_ptr_array_add (arg_array, "-s");
+                               g_ptr_array_add (arg_array, s_tests->pdata[i]);
+                       }
+               } else if (p_tests || s_tests) {
+                       char *msg = g_strdup_printf (">>> nmtst: ignore -p and -s options for tap-tests");
+
+                       g_array_append_val (debug_messages, msg);
+               }
+
+               g_ptr_array_add (arg_array, NULL);
+
+               arg_array_n = arg_array->len - 1;
+               arg_array_c = (char **) g_ptr_array_free (arg_array, FALSE);
+
+               g_test_init (&arg_array_n, &arg_array_c, NULL);
+
+               if (*argc > 1) {
+                       /* collaps argc/argv by removing the arguments detected
+                        * by g_test_init(). */
+                       for (i = 1, j = 1; i < *argc; i++) {
+                               if ((*argv)[i] == arg_array_c[j])
+                                       j++;
+                               else
+                                       (*argv)[i] = NULL;
+                       }
+                       for (i = 1, j = 1; i < *argc; i++) {
+                               if ((*argv)[i]) {
+                                       (*argv)[j++] = (*argv)[i];
+                                       if (i >= j)
+                                               (*argv)[i] = NULL;
+                               }
+                       }
+                       *argc = j;
+               }
+
+               /* we must "leak" the test paths because they are not cloned by g_test_init(). */
+               if (!__nmtst_internal.test_tap_log) {
+                       if (p_tests) {
+                               p_tests_x = (char **) g_ptr_array_free (p_tests, FALSE);
+                               p_tests = NULL;
+                       }
+                       if (s_tests) {
+                               s_tests_x = (char **) g_ptr_array_free (s_tests, FALSE);
+                               s_tests = NULL;
+                       }
+               }
+       }
+
+       if (test_quick_set)
+               __nmtst_internal.test_quick = test_quick;
+       else if (test_quick_argv)
+               __nmtst_internal.test_quick = g_test_quick ();
+       else {
+#ifdef NMTST_TEST_QUICK
+               __nmtst_internal.test_quick = NMTST_TEST_QUICK;
+#else
+               __nmtst_internal.test_quick = FALSE;
+#endif
+       }
+
+       __nmtst_internal.is_debug = is_debug;
+       __nmtst_internal.rand0 = g_rand_new_with_seed (0);
+       __nmtst_internal.sudo_cmd = sudo_cmd;
+       __nmtst_internal.no_expect_message = no_expect_message;
+
+       if (!log_level && log_domains) {
+               /* if the log level is not specified (but the domain is), we assume
+                * the caller wants to set it depending on is_debug */
+               log_level = is_debug ? "DEBUG" : "WARN";
+       }
+
+       if (!__nmtst_internal.assert_logging) {
+               gboolean success = TRUE;
+#ifdef _NMTST_INSIDE_CORE
+               success = nm_logging_setup (log_level, log_domains, NULL, NULL);
+               *out_set_logging = TRUE;
+#endif
+               g_assert (success);
+#if GLIB_CHECK_VERSION(2,34,0)
+               if (__nmtst_internal.no_expect_message)
+                       g_log_set_always_fatal (G_LOG_FATAL_MASK);
+#else
+               /* g_test_expect_message() is a NOP, so allow any messages */
+               g_log_set_always_fatal (G_LOG_FATAL_MASK);
+#endif
+       } else if (__nmtst_internal.no_expect_message) {
+               /* We have a test that would be assert_logging, but the user specified no_expect_message.
+                * This transforms g_test_expect_message() into a NOP, but we also have to relax
+                * g_log_set_always_fatal(), which was set by g_test_init(). */
+               g_log_set_always_fatal (G_LOG_FATAL_MASK);
+#ifdef _NMTST_INSIDE_CORE
+               if (c_log_domains || c_log_level) {
+                       /* Normally, tests with assert_logging do not overwrite the logging level/domains 
because
+                        * the logging statements are part of the assertions. But if the test is run with
+                        * no-expect-message *and* the logging is set explicitly via environment variables,
+                        * we still reset the logging. */
+                       gboolean success;
+
+                       success = nm_logging_setup (log_level, log_domains, NULL, NULL);
+                       *out_set_logging = TRUE;
+                       g_assert (success);
+               }
+#endif
+       } else {
+#if GLIB_CHECK_VERSION(2,34,0)
+               /* We were called not to set logging levels. This means, that the user
+                * expects to assert against (all) messages. Any uncought message is fatal. */
+               g_log_set_always_fatal (G_LOG_LEVEL_MASK);
+#else
+               /* g_test_expect_message() is a NOP, so allow any messages */
+               g_log_set_always_fatal (G_LOG_FATAL_MASK);
+#endif
+       }
+
+       if ((!__nmtst_internal.assert_logging || (__nmtst_internal.assert_logging && 
__nmtst_internal.no_expect_message)) &&
+           (is_debug || (c_log_level && (!g_ascii_strcasecmp (c_log_level, "DEBUG") || !g_ascii_strcasecmp 
(c_log_level, "TRACE")))) &&
+           !g_getenv ("G_MESSAGES_DEBUG"))
+       {
+               /* if we are @is_debug or @log_level=="DEBUG" and
+                * G_MESSAGES_DEBUG is unset, we set G_MESSAGES_DEBUG=all.
+                * To disable this default behaviour, set G_MESSAGES_DEBUG='' */
+
+               /* Note that g_setenv is not thread safe, but you should anyway call
+                * nmtst_init() at the very start. */
+               g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
+       }
+
+       /* Delay messages until we setup logging. */
+       for (i = 0; i < debug_messages->len; i++)
+               __NMTST_LOG (g_message, "%s", g_array_index (debug_messages, const char *, i));
+
+       g_strfreev ((char **) g_array_free (debug_messages, FALSE));
+       g_free (c_log_level);
+       g_free (c_log_domains);
+
+#ifdef __NETWORKMANAGER_UTILS_H__
+       /* ensure that monotonic timestamp is called (because it initially logs a line) */
+       nm_utils_get_monotonic_timestamp_s ();
+#endif
+
+#ifdef NM_UTILS_H
+       {
+               gs_free_error GError *error = NULL;
+
+               if (!nm_utils_init (&error))
+                       g_assert_not_reached ();
+               g_assert_no_error (error);
+       }
+#endif
+}
+
+#ifndef _NMTST_INSIDE_CORE
+inline static void
+nmtst_init (int *argc, char ***argv, gboolean assert_logging)
+{
+       __nmtst_init (argc, argv, assert_logging, NULL, NULL, NULL);
+}
+#endif
+
+inline static gboolean
+nmtst_is_debug (void)
+{
+       g_assert (nmtst_initialized ());
+       return __nmtst_internal.is_debug;
+}
+
+inline static gboolean
+nmtst_test_quick (void)
+{
+       g_assert (nmtst_initialized ());
+       return __nmtst_internal.test_quick;
+}
+
+#if GLIB_CHECK_VERSION(2,34,0)
+#undef g_test_expect_message
+#define g_test_expect_message(...) \
+       G_STMT_START { \
+               g_assert (nmtst_initialized ()); \
+               if (__nmtst_internal.assert_logging && __nmtst_internal.no_expect_message) { \
+                       g_debug ("nmtst: assert-logging: g_test_expect_message %s", G_STRINGIFY 
((__VA_ARGS__))); \
+               } else { \
+                       G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+                       g_test_expect_message (__VA_ARGS__); \
+                       G_GNUC_END_IGNORE_DEPRECATIONS \
+               } \
+       } G_STMT_END
+#undef g_test_assert_expected_messages_internal
+#define g_test_assert_expected_messages_internal(domain, file, line, func) \
+       G_STMT_START { \
+               const char *_domain = (domain); \
+               const char *_file = (file); \
+               const char *_func = (func); \
+               int _line = (line); \
+               \
+               if (__nmtst_internal.assert_logging && __nmtst_internal.no_expect_message) \
+                       g_debug ("nmtst: assert-logging: g_test_assert_expected_messages(%s, %s:%d, %s)", 
_domain?:"", _file?:"", _line, _func?:""); \
+               \
+               G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+               g_test_assert_expected_messages_internal (_domain, _file, _line, _func); \
+               G_GNUC_END_IGNORE_DEPRECATIONS \
+       } G_STMT_END
+#endif
+
+/*****************************************************************************/
+
+typedef struct _NmtstTestData NmtstTestData;
+
+typedef void (*NmtstTestDataRelease) (const NmtstTestData *test_data);
+
+struct _NmtstTestData {
+       const char *testpath;
+       NmtstTestDataRelease fcn_release;
+       gsize n_args;
+       gpointer args[1];
+};
+
+inline static void
+_nmtst_test_data_unpack (const NmtstTestData *test_data, gsize n_args, ...)
+{
+       gsize i;
+       va_list ap;
+       gpointer *p;
+
+       g_assert (test_data);
+       g_assert_cmpint (n_args, ==, test_data->n_args);
+
+       va_start (ap, n_args);
+       for (i = 0; i < n_args; i++) {
+               p = va_arg (ap, gpointer *);
+
+               g_assert (p);
+               *p = test_data->args[i];
+       }
+       va_end (ap);
+}
+#define nmtst_test_data_unpack(test_data, ...) _nmtst_test_data_unpack(test_data, NM_NARG (__VA_ARGS__), 
##__VA_ARGS__)
+
+inline static void
+_nmtst_test_data_free (gpointer data)
+{
+       NmtstTestData *test_data = data;
+
+       g_assert (test_data);
+
+       if (test_data->fcn_release)
+               test_data->fcn_release (test_data);
+
+       g_free ((gpointer) test_data->testpath);
+       g_free (test_data);
+}
+
+inline static void
+_nmtst_add_test_func_full (const char *testpath, GTestDataFunc test_func, NmtstTestDataRelease fcn_release, 
gsize n_args, ...)
+{
+       gsize i;
+       NmtstTestData *data;
+       va_list ap;
+
+       data = g_malloc (G_STRUCT_OFFSET (NmtstTestData, args) + sizeof (gpointer) * (n_args + 1));
+
+       data->testpath = g_strdup (testpath);
+       data->fcn_release = fcn_release;
+       data->n_args = n_args;
+       va_start (ap, n_args);
+       for (i = 0; i < n_args; i++)
+               data->args[i] = va_arg (ap, gpointer);
+       data->args[i] = NULL;
+       va_end (ap);
+
+       g_test_add_data_func_full (testpath,
+                                  data,
+                                  test_func,
+                                  _nmtst_test_data_free);
+}
+#define nmtst_add_test_func_full(testpath, test_func, fcn_release, ...) _nmtst_add_test_func_full(testpath, 
test_func, fcn_release, NM_NARG (__VA_ARGS__), ##__VA_ARGS__)
+#define nmtst_add_test_func(testpath, test_func, ...) nmtst_add_test_func_full(testpath, test_func, NULL, 
##__VA_ARGS__)
+
+/*****************************************************************************/
+
+inline static GRand *
+nmtst_get_rand0 (void)
+{
+       g_assert (nmtst_initialized ());
+       return __nmtst_internal.rand0;
+}
+
+inline static GRand *
+nmtst_get_rand (void)
+{
+       g_assert (nmtst_initialized ());
+
+       if (G_UNLIKELY (!__nmtst_internal.rand)) {
+               guint32 seed;
+               const char *str;
+
+               if ((str = g_getenv ("NMTST_SEED_RAND"))) {
+                       gchar *s;
+                       gint64 i;
+
+                       i = g_ascii_strtoll (str, &s, 0);
+                       g_assert (s[0] == '\0' && i >= 0 && i < G_MAXUINT32);
+
+                       seed = i;
+                       __nmtst_internal.rand = g_rand_new_with_seed (seed);
+               } else {
+                       __nmtst_internal.rand = g_rand_new ();
+
+                       seed = g_rand_int (__nmtst_internal.rand);
+                       g_rand_set_seed (__nmtst_internal.rand, seed);
+               }
+               __nmtst_internal.rand_seed = seed;
+
+               g_print ("\nnmtst: initialize nmtst_get_rand() with NMTST_SEED_RAND=%u\n", seed);
+       }
+       return __nmtst_internal.rand;
+}
+
+inline static guint32
+nmtst_get_rand_int (void)
+{
+       return g_rand_int (nmtst_get_rand ());
+}
+
+inline static gpointer
+nmtst_rand_buf (GRand *rand, gpointer buffer, gsize buffer_length)
+{
+       guint32 v;
+       guint8 *b = buffer;
+
+       if (!buffer_length)
+               return buffer;
+
+       g_assert (buffer);
+
+       if (!rand)
+               rand = nmtst_get_rand ();
+
+       for (; buffer_length >= sizeof (guint32); buffer_length -= sizeof (guint32), b += sizeof (guint32)) {
+               v = g_rand_int (rand);
+               memcpy (b, &v, sizeof (guint32));
+       }
+       if (buffer_length > 0) {
+               v = g_rand_int (rand);
+               do {
+                       *(b++) = v & 0xFF;
+                       v >>= 8;
+               } while (--buffer_length > 0);
+       }
+       return buffer;
+}
+
+inline static void *
+nmtst_rand_perm (GRand *rand, void *dst, const void *src, gsize elmt_size, gsize n_elmt)
+{
+       gsize i, j;
+       char *p_, *pj;
+       char *bu;
+
+       g_assert (dst);
+       g_assert (elmt_size > 0);
+       g_assert (n_elmt < G_MAXINT32);
+
+       if (n_elmt == 0)
+               return dst;
+
+       if (src && dst != src)
+               memcpy (dst, src, elmt_size * n_elmt);
+
+       if (!rand)
+               rand = nmtst_get_rand ();
+
+       bu = g_slice_alloc (elmt_size);
+
+       p_ = dst;
+       for (i = n_elmt; i > 1; i--) {
+               j = g_rand_int_range (rand, 0, i);
+
+               if (j != 0) {
+                       pj = &p_[j * elmt_size];
+
+                       /* swap */
+                       memcpy (bu, p_, elmt_size);
+                       memcpy (p_, pj, elmt_size);
+                       memcpy (pj, bu, elmt_size);
+               }
+               p_ += elmt_size;
+       }
+
+       g_slice_free1 (elmt_size, bu);
+       return dst;
+}
+
+/*****************************************************************************/
+
+inline static gboolean
+_nmtst_main_loop_run_timeout (gpointer user_data)
+{
+       GMainLoop **p_loop = user_data;
+
+       g_assert (p_loop);
+       g_assert (*p_loop);
+
+       g_main_loop_quit (*p_loop);
+       *p_loop = NULL;
+
+       return G_SOURCE_REMOVE;
+}
+
+inline static gboolean
+nmtst_main_loop_run (GMainLoop *loop, int timeout_ms)
+{
+       GSource *source = NULL;
+       guint id = 0;
+       GMainLoop *loopx = loop;
+
+       if (timeout_ms > 0) {
+               source = g_timeout_source_new (timeout_ms);
+               g_source_set_callback (source, _nmtst_main_loop_run_timeout, &loopx, NULL);
+               id = g_source_attach (source, g_main_loop_get_context (loop));
+               g_assert (id);
+               g_source_unref (source);
+       }
+
+       g_main_loop_run (loop);
+
+       /* if the timeout was reached, return FALSE. */
+       return loopx != NULL;
+}
+
+inline static void
+_nmtst_main_loop_quit_on_notify (GObject *object, GParamSpec *pspec, gpointer user_data)
+{
+       GMainLoop *loop = user_data;
+
+       g_assert (G_IS_OBJECT (object));
+       g_assert (loop);
+
+       g_main_loop_quit (loop);
+}
+#define nmtst_main_loop_quit_on_notify ((GCallback) _nmtst_main_loop_quit_on_notify)
+
+/*****************************************************************************/
+
+inline static const char *
+nmtst_get_sudo_cmd (void)
+{
+       g_assert (nmtst_initialized ());
+       return __nmtst_internal.sudo_cmd;
+}
+
+inline static void
+nmtst_reexec_sudo (void)
+{
+       char *str;
+       char **argv;
+       int i;
+       int errsv;
+
+       g_assert (nmtst_initialized ());
+       g_assert (__nmtst_internal.orig_argv);
+
+       if (!__nmtst_internal.sudo_cmd)
+               return;
+
+       str = g_strjoinv (" ", __nmtst_internal.orig_argv);
+       __NMTST_LOG (g_message, ">> exec %s %s", __nmtst_internal.sudo_cmd, str);
+
+       argv = g_new0 (char *, 1 + g_strv_length (__nmtst_internal.orig_argv) + 1);
+       argv[0] = __nmtst_internal.sudo_cmd;
+       for (i = 0; __nmtst_internal.orig_argv[i]; i++)
+               argv[i+1] = __nmtst_internal.orig_argv[i];
+
+       execvp (__nmtst_internal.sudo_cmd, argv);
+
+       errsv = errno;
+       g_error (">> exec %s failed: %d - %s", __nmtst_internal.sudo_cmd, errsv, strerror (errsv));
+}
+
+/*****************************************************************************/
+
+inline static gsize
+nmtst_find_all_indexes (gpointer *elements,
+                        gsize n_elements,
+                        gpointer *needles,
+                        gsize n_needles,
+                        gboolean (*equal_fcn) (gpointer element, gpointer needle, gpointer user_data),
+                        gpointer user_data,
+                        gssize *out_idx)
+{
+       gsize i, j, k;
+       gsize found = 0;
+
+       for (i = 0; i < n_needles; i++) {
+               gssize idx = -1;
+
+               for (j = 0; j < n_elements; j++) {
+
+                       /* no duplicates */
+                       for (k = 0; k < i; k++) {
+                               if (out_idx[k] == j)
+                                       goto next;
+                       }
+
+                       if (equal_fcn (elements[j], needles[i], user_data)) {
+                               idx = j;
+                               break;
+                       }
+next:
+                       ;
+               }
+
+               out_idx[i] = idx;
+               if (idx >= 0)
+                       found++;
+       }
+
+       return found;
+}
+
+/*****************************************************************************/
+
+#define __define_nmtst_static(NUM,SIZE) \
+inline static const char * \
+nmtst_static_##SIZE##_##NUM (const char *str) \
+{ \
+       gsize l; \
+       static char buf[SIZE]; \
+\
+       if (!str) \
+               return NULL; \
+       l = g_strlcpy (buf, str, sizeof (buf)); \
+       g_assert (l < sizeof (buf)); \
+       return buf; \
+}
+__define_nmtst_static(01, 1024)
+__define_nmtst_static(02, 1024)
+__define_nmtst_static(03, 1024)
+#undef __define_nmtst_static
+
+inline static const char *
+nmtst_uuid_generate (void)
+{
+       static char u[37];
+       gs_free char *m = NULL;
+
+       m = nm_utils_uuid_generate ();
+       g_assert (m && strlen (m) == sizeof (u) - 1);
+       memcpy (u, m, sizeof (u));
+       return u;
+}
+
+#define NMTST_SWAP(x,y) \
+       G_STMT_START { \
+               char __nmtst_swap_temp[sizeof(x) == sizeof(y) ? (signed) sizeof(x) : -1]; \
+               memcpy(__nmtst_swap_temp, &y, sizeof(x)); \
+               memcpy(&y,                &x, sizeof(x)); \
+               memcpy(&x, __nmtst_swap_temp, sizeof(x)); \
+       } G_STMT_END
+
+#define nmtst_assert_str_has_substr(str, substr) \
+       G_STMT_START { \
+               const char *__str = (str); \
+               const char *__substr = (substr); \
+               \
+               g_assert (__str); \
+               g_assert (__substr); \
+               if (strstr (__str, __substr) == NULL) \
+                       g_error ("%s:%d: Expects \"%s\" but got \"%s\"", __FILE__, __LINE__, __substr, 
__str); \
+       } G_STMT_END
+
+inline static guint32
+nmtst_inet4_from_string (const char *str)
+{
+       guint32 addr;
+       int success;
+
+       if (!str)
+               return 0;
+
+       success = inet_pton (AF_INET, str, &addr);
+
+       g_assert (success == 1);
+
+       return addr;
+}
+
+inline static const struct in6_addr *
+nmtst_inet6_from_string (const char *str)
+{
+       static struct in6_addr addr;
+       int success;
+
+       if (!str)
+               addr = in6addr_any;
+       else {
+               success = inet_pton (AF_INET6, str, &addr);
+               g_assert (success == 1);
+       }
+
+       return &addr;
+}
+
+inline static void
+_nmtst_assert_ip4_address (const char *file, int line, in_addr_t addr, const char *str_expected)
+{
+       if (nmtst_inet4_from_string (str_expected) != addr) {
+               char buf[100];
+
+               g_error ("%s:%d: Unexpected IPv4 address: expected %s, got %s",
+                        file, line, str_expected ? str_expected : "0.0.0.0",
+                        inet_ntop (AF_INET, &addr, buf, sizeof (buf)));
+       }
+}
+#define nmtst_assert_ip4_address(addr, str_expected) _nmtst_assert_ip4_address (__FILE__, __LINE__, addr, 
str_expected)
+
+inline static void
+_nmtst_assert_ip6_address (const char *file, int line, const struct in6_addr *addr, const char *str_expected)
+{
+       struct in6_addr any = in6addr_any;
+
+       if (!addr)
+               addr = &any;
+
+       if (memcmp (nmtst_inet6_from_string (str_expected), addr, sizeof (*addr)) != 0) {
+               char buf[100];
+
+               g_error ("%s:%d: Unexpected IPv6 address: expected %s, got %s",
+                        file, line, str_expected ? str_expected : "::",
+                        inet_ntop (AF_INET6, addr, buf, sizeof (buf)));
+       }
+}
+#define nmtst_assert_ip6_address(addr, str_expected) _nmtst_assert_ip6_address (__FILE__, __LINE__, addr, 
str_expected)
+
+#define nmtst_spawn_sync(working_directory, standard_out, standard_err, assert_exit_status, ...) \
+       __nmtst_spawn_sync (working_directory, standard_out, standard_err, assert_exit_status, ##__VA_ARGS__, 
NULL)
+inline static gint
+__nmtst_spawn_sync (const char *working_directory, char **standard_out, char **standard_err, int 
assert_exit_status, ...) G_GNUC_NULL_TERMINATED;
+inline static gint
+__nmtst_spawn_sync (const char *working_directory, char **standard_out, char **standard_err, int 
assert_exit_status, ...)
+{
+       gint exit_status = 0;
+       GError *error = NULL;
+       char *arg;
+       va_list va_args;
+       GPtrArray *argv = g_ptr_array_new ();
+       gboolean success;
+
+       va_start (va_args, assert_exit_status);
+       while ((arg = va_arg (va_args, char *)))
+               g_ptr_array_add (argv, arg);
+       va_end (va_args);
+
+       g_assert (argv->len >= 1);
+       g_ptr_array_add (argv, NULL);
+
+       success = g_spawn_sync (working_directory,
+                               (char**) argv->pdata,
+                               NULL,
+                               0 /*G_SPAWN_DEFAULT*/,
+                               NULL,
+                               NULL,
+                               standard_out,
+                               standard_err,
+                               &exit_status,
+                               &error);
+       if (!success)
+               g_error ("nmtst_spawn_sync(%s): %s", ((char **) argv->pdata)[0], error->message);
+       g_assert (!error);
+
+       g_assert (!standard_out || *standard_out);
+       g_assert (!standard_err || *standard_err);
+
+       if (assert_exit_status != -1) {
+               /* exit status is a guint8 on success. Set @assert_exit_status to -1
+                * not to check for the exit status. */
+               g_assert (WIFEXITED (exit_status));
+               g_assert_cmpint (WEXITSTATUS (exit_status), ==, assert_exit_status);
+       }
+
+       g_ptr_array_free (argv, TRUE);
+       return exit_status;
+}
+
+/*******************************************************************************/
+
+inline static char *
+nmtst_file_resolve_relative_path (const char *rel, const char *cwd)
+{
+       gs_free char *cwd_free = NULL;
+
+       g_assert (rel && *rel);
+
+       if (g_path_is_absolute (rel))
+               return g_strdup (rel);
+
+       if (!cwd)
+               cwd = cwd_free = g_get_current_dir ();
+       return g_build_filename (cwd, rel, NULL);
+}
+
+inline static void
+_nmtst_assert_resolve_relative_path_equals (const char *f1, const char *f2, const char *file, int line)
+{
+       gs_free char *p1 = NULL, *p2 = NULL;
+
+       p1 = nmtst_file_resolve_relative_path (f1, NULL);
+       p2 = nmtst_file_resolve_relative_path (f2, NULL);
+       g_assert (p1 && *p1);
+
+       /* Fixme: later we might need to coalesce repeated '/', "./", and "../".
+        * For now, it's good enough. */
+       if (g_strcmp0 (p1, p2) != 0)
+               g_error ("%s:%d : filenames don't match \"%s\" vs. \"%s\" // \"%s\" - \"%s\"", file, line, 
f1, f2, p1, p2);
+}
+#define nmtst_assert_resolve_relative_path_equals(f1, f2) _nmtst_assert_resolve_relative_path_equals (f1, 
f2, __FILE__, __LINE__);
+
+/*******************************************************************************/
+
+#ifdef NM_SETTING_IP_CONFIG_H
+inline static void
+nmtst_setting_ip_config_add_address (NMSettingIPConfig *s_ip,
+                                     const char *address,
+                                     guint prefix)
+{
+       NMIPAddress *addr;
+       int family;
+
+       g_assert (s_ip);
+
+       if (nm_utils_ipaddr_valid (AF_INET, address))
+               family = AF_INET;
+       else if (nm_utils_ipaddr_valid (AF_INET6, address))
+               family = AF_INET6;
+       else
+               g_assert_not_reached ();
+
+       addr = nm_ip_address_new (family, address, prefix, NULL);
+       g_assert (addr);
+       g_assert (nm_setting_ip_config_add_address (s_ip, addr));
+       nm_ip_address_unref (addr);
+}
+
+inline static void
+nmtst_setting_ip_config_add_route (NMSettingIPConfig *s_ip,
+                                   const char *dest,
+                                   guint prefix,
+                                   const char *next_hop,
+                                   gint64 metric)
+{
+       NMIPRoute *route;
+       int family;
+
+       g_assert (s_ip);
+
+       if (nm_utils_ipaddr_valid (AF_INET, dest))
+               family = AF_INET;
+       else if (nm_utils_ipaddr_valid (AF_INET6, dest))
+               family = AF_INET6;
+       else
+               g_assert_not_reached ();
+
+       route = nm_ip_route_new (family, dest, prefix, next_hop, metric, NULL);
+       g_assert (route);
+       g_assert (nm_setting_ip_config_add_route (s_ip, route));
+       nm_ip_route_unref (route);
+}
+#endif /* NM_SETTING_IP_CONFIG_H */
+
+#if (defined(__NM_SIMPLE_CONNECTION_H__) && defined(__NM_SETTING_CONNECTION_H__)) || 
(defined(NM_CONNECTION_H))
+
+inline static NMConnection *
+nmtst_clone_connection (NMConnection *connection)
+{
+       g_assert (NM_IS_CONNECTION (connection));
+
+#if defined(__NM_SIMPLE_CONNECTION_H__)
+       return nm_simple_connection_new_clone (connection);
+#else
+       return nm_connection_duplicate (connection);
+#endif
+}
+
+inline static NMConnection *
+nmtst_create_minimal_connection (const char *id, const char *uuid, const char *type, NMSettingConnection 
**out_s_con)
+{
+       NMConnection *con;
+       NMSetting *s_base = NULL;
+       NMSettingConnection *s_con;
+       gs_free char *uuid_free = NULL;
+
+       g_assert (id);
+
+       if (uuid)
+               g_assert (nm_utils_is_uuid (uuid));
+       else
+               uuid = uuid_free = nm_utils_uuid_generate ();
+
+       if (type) {
+               GType type_g;
+
+#if defined(__NM_SIMPLE_CONNECTION_H__)
+               type_g = nm_setting_lookup_type (type);
+#else
+               type_g = nm_connection_lookup_setting_type (type);
+#endif
+
+               g_assert (type_g != G_TYPE_INVALID);
+
+               s_base = g_object_new (type_g, NULL);
+               g_assert (NM_IS_SETTING (s_base));
+       }
+
+#if defined(__NM_SIMPLE_CONNECTION_H__)
+       con = nm_simple_connection_new ();
+#else
+       con = nm_connection_new ();
+#endif
+
+       s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ());
+
+       g_object_set (s_con,
+                     NM_SETTING_CONNECTION_ID, id,
+                     NM_SETTING_CONNECTION_UUID, uuid,
+                     NM_SETTING_CONNECTION_TYPE, type,
+                     NULL);
+       nm_connection_add_setting (con, NM_SETTING (s_con));
+
+       if (s_base)
+               nm_connection_add_setting (con, s_base);
+
+       if (out_s_con)
+               *out_s_con = s_con;
+       return con;
+}
+
+inline static gboolean
+_nmtst_connection_normalize_v (NMConnection *connection, va_list args)
+{
+       GError *error = NULL;
+       gboolean success;
+       gboolean was_modified = FALSE;
+       GHashTable *parameters = NULL;
+       const char *p_name;
+
+       g_assert (NM_IS_CONNECTION (connection));
+
+       while ((p_name = va_arg (args, const char *))) {
+               if (!parameters)
+                       parameters =  g_hash_table_new (g_str_hash, g_str_equal);
+               g_hash_table_insert (parameters, (gpointer *) p_name, va_arg (args, gpointer));
+       }
+
+       success = nm_connection_normalize (connection,
+                                          parameters,
+                                          &was_modified,
+                                          &error);
+       g_assert_no_error (error);
+       g_assert (success);
+
+       if (parameters)
+               g_hash_table_destroy (parameters);
+
+       return was_modified;
+}
+
+inline static gboolean
+_nmtst_connection_normalize (NMConnection *connection, ...)
+{
+       gboolean was_modified;
+       va_list args;
+
+       va_start (args, connection);
+       was_modified = _nmtst_connection_normalize_v (connection, args);
+       va_end (args);
+
+       return was_modified;
+}
+#define nmtst_connection_normalize(connection, ...) \
+    _nmtst_connection_normalize(connection, ##__VA_ARGS__, NULL)
+
+inline static NMConnection *
+_nmtst_connection_duplicate_and_normalize (NMConnection *connection, ...)
+{
+       gboolean was_modified;
+       va_list args;
+
+       connection = nmtst_clone_connection (connection);
+
+       va_start (args, connection);
+       was_modified = _nmtst_connection_normalize_v (connection, args);
+       va_end (args);
+
+       return connection;
+}
+#define nmtst_connection_duplicate_and_normalize(connection, ...) \
+    _nmtst_connection_duplicate_and_normalize(connection, ##__VA_ARGS__, NULL)
+
+inline static void
+nmtst_assert_connection_equals (NMConnection *a, gboolean normalize_a, NMConnection *b, gboolean normalize_b)
+{
+       gboolean compare;
+       gs_unref_object NMConnection *a2 = NULL;
+       gs_unref_object NMConnection *b2 = NULL;
+       GHashTable *out_settings = NULL;
+
+       g_assert (NM_IS_CONNECTION (a));
+       g_assert (NM_IS_CONNECTION (b));
+
+       if (normalize_a)
+               a = a2 = nmtst_connection_duplicate_and_normalize (a);
+       if (normalize_b)
+               b = b2 = nmtst_connection_duplicate_and_normalize (b);
+
+       compare = nm_connection_diff (a, b, NM_SETTING_COMPARE_FLAG_EXACT, &out_settings);
+       if (!compare || out_settings) {
+               const char *name, *pname;
+               GHashTable *setting;
+               GHashTableIter iter, iter2;
+
+               __NMTST_LOG (g_message, ">>> ASSERTION nmtst_assert_connection_equals() fails");
+               if (out_settings) {
+                       g_hash_table_iter_init (&iter, out_settings);
+                       while (g_hash_table_iter_next (&iter, (gpointer *) &name, (gpointer *) &setting)) {
+                               __NMTST_LOG (g_message, ">>> differences in setting '%s':", name);
+
+                               g_hash_table_iter_init (&iter2, setting);
+                               while (g_hash_table_iter_next (&iter2, (gpointer *) &pname, NULL))
+                                       __NMTST_LOG (g_message, ">>> differences in setting '%s.%s'", name, 
pname);
+                       }
+               }
+
+#ifdef __NM_KEYFILE_INTERNAL_H__
+               {
+                       gs_unref_keyfile GKeyFile *kf_a = NULL, *kf_b = NULL;
+                       gs_free char *str_a = NULL, *str_b = NULL;
+
+                       kf_a = nm_keyfile_write (a, NULL, NULL, NULL);
+                       kf_b = nm_keyfile_write (b, NULL, NULL, NULL);
+
+                       if (kf_a)
+                               str_a = g_key_file_to_data (kf_a, NULL, NULL);
+                       if (kf_b)
+                               str_b = g_key_file_to_data (kf_b, NULL, NULL);
+
+                       __NMTST_LOG (g_message, ">>> Connection A as kf (*WARNING: keyfile representation 
might not show the difference*):\n%s", str_a);
+                       __NMTST_LOG (g_message, ">>> Connection B as kf (*WARNING: keyfile representation 
might not show the difference*):\n%s", str_b);
+               }
+#endif
+       }
+       g_assert (compare);
+       g_assert (!out_settings);
+
+       compare = nm_connection_compare (a, b, NM_SETTING_COMPARE_FLAG_EXACT);
+       g_assert (compare);
+}
+
+inline static void
+nmtst_assert_connection_verifies (NMConnection *con)
+{
+       /* assert that the connection does verify, it might be normaliziable or not */
+       GError *error = NULL;
+       gboolean success;
+
+       g_assert (NM_IS_CONNECTION (con));
+
+       success = nm_connection_verify (con, &error);
+       g_assert_no_error (error);
+       g_assert (success);
+}
+
+inline static void
+nmtst_assert_connection_verifies_without_normalization (NMConnection *con)
+{
+       /* assert that the connection verifies and does not need any normalization */
+       GError *error = NULL;
+       gboolean success;
+       gboolean was_modified = FALSE;
+       gs_unref_object NMConnection *clone = NULL;
+
+       clone = nmtst_clone_connection (con);
+
+       nmtst_assert_connection_verifies (con);
+
+       success = nm_connection_normalize (clone, NULL, &was_modified, &error);
+       g_assert_no_error (error);
+       g_assert (success);
+       nmtst_assert_connection_equals (con, FALSE, clone, FALSE);
+       g_assert (!was_modified);
+}
+
+inline static void
+nmtst_assert_connection_verifies_and_normalizable (NMConnection *con)
+{
+       /* assert that the connection does verify, but normalization still modifies it */
+       GError *error = NULL;
+       gboolean success;
+       gboolean was_modified = FALSE;
+       gs_unref_object NMConnection *clone = NULL;
+
+       clone = nmtst_clone_connection (con);
+
+       nmtst_assert_connection_verifies (con);
+
+       success = nm_connection_normalize (clone, NULL, &was_modified, &error);
+       g_assert_no_error (error);
+       g_assert (success);
+       g_assert (was_modified);
+
+       /* again! */
+       nmtst_assert_connection_verifies_without_normalization (clone);
+}
+
+inline static void
+nmtst_assert_connection_verifies_after_normalization (NMConnection *con,
+                                                      GQuark expect_error_domain,
+                                                      gint expect_error_code)
+{
+       /* assert that the connection does not verify, but normalization does fix it */
+       GError *error = NULL;
+       gboolean success;
+       gboolean was_modified = FALSE;
+       gs_unref_object NMConnection *clone = NULL;
+
+       clone = nmtst_clone_connection (con);
+
+       success = nm_connection_verify (con, &error);
+       nmtst_assert_error (error, expect_error_domain, expect_error_code, NULL);
+       g_assert (!success);
+       g_clear_error (&error);
+
+       success = nm_connection_normalize (clone, NULL, &was_modified, &error);
+       g_assert_no_error (error);
+       g_assert (success);
+       g_assert (was_modified);
+
+       /* again! */
+       nmtst_assert_connection_verifies_without_normalization (clone);
+}
+
+inline static void
+nmtst_assert_connection_unnormalizable (NMConnection *con,
+                                        GQuark expect_error_domain,
+                                        gint expect_error_code)
+{
+       /* assert that the connection does not verify, and it cannot be fixed by normalization */
+
+       GError *error = NULL;
+       gboolean success;
+       gboolean was_modified = FALSE;
+       gs_unref_object NMConnection *clone = NULL;
+
+       clone = nmtst_clone_connection (con);
+
+       success = nm_connection_verify (con, &error);
+       nmtst_assert_error (error, expect_error_domain, expect_error_code, NULL);
+       g_assert (!success);
+       g_clear_error (&error);
+
+       success = nm_connection_normalize (clone, NULL, &was_modified, &error);
+       nmtst_assert_error (error, expect_error_domain, expect_error_code, NULL);
+       g_assert (!success);
+       g_assert (!was_modified);
+       nmtst_assert_connection_equals (con, FALSE, clone, FALSE);
+       g_clear_error (&error);
+}
+
+inline static void
+nmtst_assert_setting_verifies (NMSetting *setting)
+{
+       /* assert that the setting verifies without an error */
+
+       GError *error = NULL;
+       gboolean success;
+
+       g_assert (NM_IS_SETTING (setting));
+
+       success = nm_setting_verify (setting, NULL, &error);
+       g_assert_no_error (error);
+       g_assert (success);
+}
+
+inline static void
+nmtst_assert_setting_verify_fails (NMSetting *setting,
+                                   GQuark expect_error_domain,
+                                   gint expect_error_code)
+{
+       /* assert that the setting verification fails */
+
+       GError *error = NULL;
+       gboolean success;
+
+       g_assert (NM_IS_SETTING (setting));
+
+       success = nm_setting_verify (setting, NULL, &error);
+       nmtst_assert_error (error, expect_error_domain, expect_error_code, NULL);
+       g_assert (!success);
+       g_clear_error (&error);
+}
+
+#endif
+
+#ifdef __NM_UTILS_H__
+static inline void
+nmtst_assert_hwaddr_equals (gconstpointer hwaddr1, gssize hwaddr1_len, const char *expected, const char 
*file, int line)
+{
+       guint8 buf2[NM_UTILS_HWADDR_LEN_MAX];
+       gsize hwaddr2_len = 1;
+       const char *p;
+       gboolean success;
+
+       g_assert (hwaddr1_len > 0 && hwaddr1_len <= NM_UTILS_HWADDR_LEN_MAX);
+
+       g_assert (expected);
+       for (p = expected; *p; p++) {
+               if (*p == ':' || *p == '-')
+                       hwaddr2_len++;
+       }
+       g_assert (hwaddr2_len <= NM_UTILS_HWADDR_LEN_MAX);
+       g_assert (nm_utils_hwaddr_aton (expected, buf2, hwaddr2_len));
+
+       /* Manually check the entire hardware address instead of using
+        * nm_utils_hwaddr_matches() because that function doesn't compare
+        * entire InfiniBand addresses for various (legitimate) reasons.
+        */
+       success = (hwaddr1_len == hwaddr2_len);
+       if (success)
+               success = !memcmp (hwaddr1, buf2, hwaddr1_len);
+       if (!success) {
+               g_error ("assert: %s:%d: hwaddr '%s' (%zd) expected, but got %s (%zd)",
+                        file, line, expected, hwaddr2_len, nm_utils_hwaddr_ntoa (hwaddr1, hwaddr1_len), 
hwaddr1_len);
+       }
+}
+#define nmtst_assert_hwaddr_equals(hwaddr1, hwaddr1_len, expected) \
+    nmtst_assert_hwaddr_equals (hwaddr1, hwaddr1_len, expected, __FILE__, __LINE__)
+#endif
+
+#if defined(__NM_SIMPLE_CONNECTION_H__) && defined(__NM_SETTING_CONNECTION_H__) && 
defined(__NM_KEYFILE_INTERNAL_H__)
+
+inline static NMConnection *
+nmtst_create_connection_from_keyfile (const char *keyfile_str, const char *keyfile_name, const char 
*base_dir)
+{
+       GKeyFile *keyfile;
+       GError *error = NULL;
+       gboolean success;
+       NMConnection *con;
+
+       g_assert (keyfile_str);
+
+       keyfile =  g_key_file_new ();
+       success = g_key_file_load_from_data (keyfile, keyfile_str, strlen (keyfile_str), G_KEY_FILE_NONE, 
&error);
+       g_assert_no_error (error);
+       g_assert (success);
+
+       con = nm_keyfile_read (keyfile, keyfile_name, base_dir, NULL, NULL, &error);
+       g_assert_no_error (error);
+       g_assert (NM_IS_CONNECTION (con));
+
+       g_key_file_unref (keyfile);
+
+       nmtst_connection_normalize (con);
+
+       return con;
+}
+
+#endif
+
+#ifdef __NM_CONNECTION_H__
+
+inline static GVariant *
+_nmtst_variant_new_vardict (int dummy, ...)
+{
+       GVariantBuilder builder;
+       va_list ap;
+       const char *name;
+       GVariant *variant;
+
+       g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
+
+       va_start (ap, dummy);
+       while ((name = va_arg (ap, const char *))) {
+               variant = va_arg (ap, GVariant *);
+               g_variant_builder_add (&builder, "{sv}", name, variant);
+       }
+       va_end (ap);
+
+       return g_variant_builder_end (&builder);
+}
+#define nmtst_variant_new_vardict(...) _nmtst_variant_new_vardict (0, __VA_ARGS__, NULL)
+
+#define nmtst_assert_variant_is_of_type(variant, type) \
+       G_STMT_START { \
+               GVariant *_variantx = (variant); \
+               \
+               g_assert (_variantx); \
+               g_assert (g_variant_is_of_type (_variantx, (type))); \
+       } G_STMT_END
+
+#define nmtst_assert_variant_uint32(variant, val) \
+       G_STMT_START { \
+               GVariant *_variant = (variant); \
+               \
+               nmtst_assert_variant_is_of_type (_variant, G_VARIANT_TYPE_UINT32); \
+               g_assert_cmpint (g_variant_get_uint32 (_variant), ==, (val)); \
+       } G_STMT_END
+
+#define nmtst_assert_variant_string(variant, str) \
+       G_STMT_START { \
+               gsize _l; \
+               GVariant *_variant = (variant); \
+               const char *_str = (str); \
+               \
+               nmtst_assert_variant_is_of_type (_variant, G_VARIANT_TYPE_STRING); \
+               g_assert (_str); \
+               g_assert_cmpstr (g_variant_get_string (_variant, &_l), ==, _str); \
+               g_assert_cmpint (_l, ==, strlen (_str)); \
+       } G_STMT_END
+
+typedef enum {
+       NMTST_VARIANT_EDITOR_CONNECTION,
+       NMTST_VARIANT_EDITOR_SETTING,
+       NMTST_VARIANT_EDITOR_PROPERTY
+} NmtstVariantEditorPhase;
+
+#define NMTST_VARIANT_EDITOR(__connection_variant, __code) \
+       G_STMT_START { \
+               GVariantIter __connection_iter, *__setting_iter; \
+               GVariantBuilder __connection_builder, __setting_builder; \
+               const char *__cur_setting_name, *__cur_property_name; \
+               GVariant *__property_val; \
+               NmtstVariantEditorPhase __phase; \
+                                                                        \
+               g_variant_builder_init (&__connection_builder, NM_VARIANT_TYPE_CONNECTION); \
+               g_variant_iter_init (&__connection_iter, __connection_variant); \
+                \
+               __phase = NMTST_VARIANT_EDITOR_CONNECTION; \
+               __cur_setting_name = NULL; \
+               __cur_property_name = NULL; \
+               __code; \
+               while (g_variant_iter_next (&__connection_iter, "{&sa{sv}}", &__cur_setting_name, 
&__setting_iter)) { \
+                       g_variant_builder_init (&__setting_builder, NM_VARIANT_TYPE_SETTING); \
+                       __phase = NMTST_VARIANT_EDITOR_SETTING; \
+                       __cur_property_name = NULL; \
+                       __code; \
+                        \
+                       while (   __cur_setting_name \
+                              && g_variant_iter_next (__setting_iter, "{&sv}", &__cur_property_name, 
&__property_val)) { \
+                               __phase = NMTST_VARIANT_EDITOR_PROPERTY; \
+                               __code; \
+                                \
+                               if (__cur_property_name) { \
+                                       g_variant_builder_add (&__setting_builder, "{sv}", \
+                                                              __cur_property_name, \
+                                                              __property_val); \
+                               } \
+                               g_variant_unref (__property_val); \
+                       } \
+                        \
+                       if (__cur_setting_name) \
+                               g_variant_builder_add (&__connection_builder, "{sa{sv}}", __cur_setting_name, 
&__setting_builder); \
+                       else \
+                               g_variant_builder_clear (&__setting_builder); \
+                       g_variant_iter_free (__setting_iter); \
+               } \
+                \
+               g_variant_unref (__connection_variant); \
+                \
+               __connection_variant = g_variant_builder_end (&__connection_builder); \
+       } G_STMT_END;
+
+#define NMTST_VARIANT_ADD_SETTING(__setting_name, __setting_variant) \
+       G_STMT_START { \
+               if (__phase == NMTST_VARIANT_EDITOR_CONNECTION) \
+                       g_variant_builder_add (&__connection_builder, "{s@a{sv}}", __setting_name, 
__setting_variant); \
+       } G_STMT_END
+
+#define NMTST_VARIANT_DROP_SETTING(__setting_name) \
+       G_STMT_START { \
+               if (__phase == NMTST_VARIANT_EDITOR_SETTING && __cur_setting_name) { \
+                       if (!strcmp (__cur_setting_name, __setting_name)) \
+                               __cur_setting_name = NULL; \
+               } \
+       } G_STMT_END
+
+#define NMTST_VARIANT_ADD_PROPERTY(__setting_name, __property_name, __format_string, __value) \
+       G_STMT_START { \
+               if (__phase == NMTST_VARIANT_EDITOR_SETTING) { \
+                       if (!strcmp (__cur_setting_name, __setting_name)) { \
+                               g_variant_builder_add (&__setting_builder, "{sv}", __property_name, \
+                                                      g_variant_new (__format_string, __value)); \
+                       } \
+               } \
+       } G_STMT_END
+
+#define NMTST_VARIANT_DROP_PROPERTY(__setting_name, __property_name) \
+       G_STMT_START { \
+               if (__phase == NMTST_VARIANT_EDITOR_PROPERTY && __cur_property_name) { \
+                       if (   !strcmp (__cur_setting_name, __setting_name) \
+                           && !strcmp (__cur_property_name, __property_name)) \
+                               __cur_property_name = NULL; \
+               } \
+       } G_STMT_END
+
+#define NMTST_VARIANT_CHANGE_PROPERTY(__setting_name, __property_name, __format_string, __value) \
+       G_STMT_START { \
+               NMTST_VARIANT_DROP_PROPERTY (__setting_name, __property_name); \
+               NMTST_VARIANT_ADD_PROPERTY (__setting_name, __property_name, __format_string, __value); \
+       } G_STMT_END
+
+#endif /* __NM_CONNECTION_H__ */
+
+#endif /* __NM_TEST_UTILS_H__ */
diff --git a/shared/nm-utils/nm-vpn-plugin-macros.h b/shared/nm-utils/nm-vpn-plugin-macros.h
new file mode 100644
index 0000000..06f5b28
--- /dev/null
+++ b/shared/nm-utils/nm-vpn-plugin-macros.h
@@ -0,0 +1,61 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright 2016 Red Hat, Inc.
+ */
+
+#ifndef __NM_VPN_PLUGIN_MACROS_H__
+#define __NM_VPN_PLUGIN_MACROS_H__
+
+#include <syslog.h>
+
+static inline const char *
+nm_utils_syslog_to_str (int syslog_level)
+{
+       /* Maps the levels the same way as NetworkManager's nm-logging.c does */
+       if (syslog_level >= LOG_DEBUG)
+               return "<trace>";
+       if (syslog_level >= LOG_INFO)
+               return "<debug>";
+       if (syslog_level >= LOG_NOTICE)
+               return "<info>";
+       if (syslog_level >= LOG_WARNING)
+               return "<warn>";
+       return "<error>";
+}
+
+/*****************************************************************************/
+
+/* possibly missing defines from newer libnm API. */
+
+#ifndef NM_VPN_PLUGIN_CONFIG_PROXY_PAC
+#define NM_VPN_PLUGIN_CONFIG_PROXY_PAC "pac"
+#endif
+
+#ifndef NM_VPN_PLUGIN_IP4_CONFIG_PRESERVE_ROUTES
+#define NM_VPN_PLUGIN_IP4_CONFIG_PRESERVE_ROUTES "preserve-routes"
+#endif
+
+#ifndef NM_VPN_PLUGIN_IP6_CONFIG_PRESERVE_ROUTES
+#define NM_VPN_PLUGIN_IP6_CONFIG_PRESERVE_ROUTES "preserve-routes"
+#endif
+
+/*****************************************************************************/
+
+#endif /* __NM_VPN_PLUGIN_MACROS_H__ */
+
diff --git a/shared/nm-utils/nm-vpn-plugin-utils.c b/shared/nm-utils/nm-vpn-plugin-utils.c
new file mode 100644
index 0000000..772aa39
--- /dev/null
+++ b/shared/nm-utils/nm-vpn-plugin-utils.c
@@ -0,0 +1,130 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright 2016 Red Hat, Inc.
+ */
+
+#include "nm-default.h"
+
+#include "nm-vpn-plugin-utils.h"
+
+#include <dlfcn.h>
+
+/*****************************************************************************/
+
+NMVpnEditor *
+nm_vpn_plugin_utils_load_editor (const char *module_name,
+                                 const char *factory_name,
+                                 NMVpnPluginUtilsEditorFactory editor_factory,
+                                 NMVpnEditorPlugin *editor_plugin,
+                                 NMConnection *connection,
+                                 gpointer user_data,
+                                 GError **error)
+
+{
+       static struct {
+               gpointer factory;
+               void *dl_module;
+               char *module_name;
+               char *factory_name;
+       } cached = { 0 };
+       NMVpnEditor *editor;
+
+       g_return_val_if_fail (module_name && g_path_is_absolute (module_name), NULL);
+       g_return_val_if_fail (factory_name && factory_name[0], NULL);
+       g_return_val_if_fail (editor_factory, NULL);
+       g_return_val_if_fail (NM_IS_VPN_EDITOR_PLUGIN (editor_plugin), NULL);
+       g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
+       g_return_val_if_fail (!error || !*error, NULL);
+
+       /* we really expect this function to be called with unchanging @module_name
+        * and @factory_name. And we only want to load the module once, hence it would
+        * be more complicated to accept changing @module_name/@factory_name arguments.
+        *
+        * The reason for only loading once is that due to glib types, we cannot create a
+        * certain type-name more then once, so loading the same module or another version
+        * of the same module will fail horribly as both try to create a GType with the same
+        * name.
+        *
+        * Only support loading once, any future calls will reuse the handle. To simplify
+        * that, we enforce that the @factory_name and @module_name is the same. */
+       if (cached.factory) {
+               g_return_val_if_fail (cached.dl_module, NULL);
+               g_return_val_if_fail (cached.factory_name && nm_streq0 (cached.factory_name, factory_name), 
NULL);
+               g_return_val_if_fail (cached.module_name && nm_streq0 (cached.module_name, module_name), 
NULL);
+       } else {
+               gpointer factory;
+               void *dl_module;
+
+               dl_module = dlopen (module_name, RTLD_LAZY | RTLD_LOCAL);
+               if (!dl_module) {
+                       if (!g_file_test (module_name, G_FILE_TEST_EXISTS)) {
+                               g_set_error (error,
+                                            G_FILE_ERROR,
+                                            G_FILE_ERROR_NOENT,
+                                            _("missing plugin file \"%s\""), module_name);
+                               return NULL;
+                       }
+                       g_set_error (error,
+                                    NM_CONNECTION_ERROR,
+                                    NM_CONNECTION_ERROR_FAILED,
+                                    _("cannot load editor plugin: %s"), dlerror ());
+                       return NULL;
+               }
+
+               factory = dlsym (dl_module, factory_name);
+               if (!factory) {
+                       g_set_error (error,
+                                    NM_CONNECTION_ERROR,
+                                    NM_CONNECTION_ERROR_FAILED,
+                                    _("cannot load factory %s from plugin: %s"),
+                                    factory_name, dlerror ());
+                       dlclose (dl_module);
+                       return NULL;
+               }
+
+               /* we cannot ever unload the module because it creates glib types, which
+                * cannot be unregistered.
+                *
+                * Thus we just leak the dl_module handle indefinitely. */
+               cached.factory = factory;
+               cached.dl_module = dl_module;
+               cached.module_name = g_strdup (module_name);
+               cached.factory_name = g_strdup (factory_name);
+       }
+
+       editor = editor_factory (cached.factory,
+                                editor_plugin,
+                                connection,
+                                user_data,
+                                error);
+       if (!editor) {
+               if (error && !*error ) {
+                       g_set_error_literal (error,
+                                            NM_CONNECTION_ERROR,
+                                            NM_CONNECTION_ERROR_FAILED,
+                                            _("unknown error creating editor instance"));
+                       g_return_val_if_reached (NULL);
+               }
+               return NULL;
+       }
+
+       g_return_val_if_fail (NM_IS_VPN_EDITOR (editor), NULL);
+       return editor;
+}
+
diff --git a/shared/nm-utils/nm-vpn-plugin-utils.h b/shared/nm-utils/nm-vpn-plugin-utils.h
new file mode 100644
index 0000000..f3928d1
--- /dev/null
+++ b/shared/nm-utils/nm-vpn-plugin-utils.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright 2016 Red Hat, Inc.
+ */
+
+#ifndef __NM_VPN_PLUGIN_UTILS_H__
+#define __NM_VPN_PLUGIN_UTILS_H__
+
+#include <NetworkManager.h>
+
+typedef NMVpnEditor *(NMVpnPluginUtilsEditorFactory) (gpointer factory,
+                                                      NMVpnEditorPlugin *editor_plugin,
+                                                      NMConnection *connection,
+                                                      gpointer user_data,
+                                                      GError **error);
+
+NMVpnEditor *nm_vpn_plugin_utils_load_editor (const char *module_name,
+                                              const char *factory_name,
+                                              NMVpnPluginUtilsEditorFactory editor_factory,
+                                              NMVpnEditorPlugin *editor_plugin,
+                                              NMConnection *connection,
+                                              gpointer user_data,
+                                              GError **error);
+
+#endif /* __NM_VPN_PLUGIN_UTILS_H__ */
+


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]