[network-manager-openconnect/th/vpn-service-info-bgo767197: 3/3] fixup! change multiprotocol support to use a new "protocol" option



commit 166866d2d798c1585ae3532f06fa78868d9fd5ef
Author: Thomas Haller <thaller redhat com>
Date:   Sun Jun 12 16:07:03 2016 +0200

    fixup! change multiprotocol support to use a new "protocol" option

 Makefile.am                        |    2 +-
 configure.ac                       |    1 +
 properties/Makefile.am             |    1 +
 properties/nm-openconnect.c        |  145 +++------
 shared/Makefile.am                 |    4 +
 shared/gsystem-local-alloc.h       |  208 +++++++++++++
 shared/nm-macros-internal.h        |  604 ++++++++++++++++++++++++++++++++++++
 shared/nm-vpn-editor-plugin-call.h |  407 ++++++++++++++++++++++++
 8 files changed, 1277 insertions(+), 95 deletions(-)
---
diff --git a/Makefile.am b/Makefile.am
index 6227b7e..2fbcf84 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,6 +1,6 @@
 AUTOMAKE_OPTIONS = foreign
 
-SUBDIRS = src
+SUBDIRS = shared src
 
 if WITH_GNOME
 SUBDIRS += properties po
diff --git a/configure.ac b/configure.ac
index 2a244f6..56f23f6 100644
--- a/configure.ac
+++ b/configure.ac
@@ -109,5 +109,6 @@ src/Makefile
 auth-dialog/Makefile
 properties/Makefile
 po/Makefile.in
+shared/Makefile
 ])
 AC_OUTPUT
diff --git a/properties/Makefile.am b/properties/Makefile.am
index f79c5ad..90269f5 100644
--- a/properties/Makefile.am
+++ b/properties/Makefile.am
@@ -20,6 +20,7 @@ common_CFLAGS =                                         \
        $(GLIB_CFLAGS)                                  \
        $(GTK_CFLAGS)                                   \
        $(OPENCONNECT_CFLAGS)                           \
+       -I$(top_srcdir)/shared                          \
        -I$(top_srcdir)/src                             \
        -DICONDIR=\""$(datadir)/pixmaps"\"              \
        -DUIDIR=\""$(uidir)"\"                          \
diff --git a/properties/nm-openconnect.c b/properties/nm-openconnect.c
index 09815ce..5ff5954 100644
--- a/properties/nm-openconnect.c
+++ b/properties/nm-openconnect.c
@@ -76,6 +76,10 @@
 #include "nm-openconnect.h"
 #include "auth-helpers.h"
 
+#ifndef NM_OPENCONNECT_OLD
+#include "nm-vpn-editor-plugin-call.h"
+#endif
+
 #define OPENCONNECT_PLUGIN_NAME    _("Cisco AnyConnect Compatible VPN (openconnect)")
 #define OPENCONNECT_PLUGIN_DESC    _("Compatible with Cisco AnyConnect SSL VPN.")
 
@@ -837,110 +841,64 @@ notify_plugin_info_set (NMVpnEditorPlugin *plugin,
 }
 
 static gboolean
-call_get_signature (NMVpnEditorPlugin *plugin,
-                    const char *request,
-                    gboolean *free_types,
-                    GType **types_in,
-                    GType **types_out)
+_impl_get_service_add_details (NMVpnEditorPlugin *plugin,
+                               const char *service_type,
+                               char ***out_add_details)
 {
-       if (!strcmp (request, "get-service-add-details")) {
-               static GType t_in[] = { G_TYPE_STRING, 0 };
-               static GType t_out[] = { 0, 0 };
-
-               if (G_UNLIKELY (t_out[0] == 0))
-                       t_out[0] = G_TYPE_STRV;
-
-               *types_in = t_in;
-               *types_out = t_out;
-               return TRUE;
-       }
-       if (!strcmp (request, "get-service-add-detail")) {
-               static GType t_in[] = { G_TYPE_STRING, G_TYPE_STRING, 0 };
-               static GType t_out[] = { G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, 0 };
-
-               *types_in = t_in;
-               *types_out = t_out;
-               return TRUE;
-       }
-       return FALSE;
+       *out_add_details = g_strdupv (OPENCONNECT_EDITOR_PLUGIN_GET_PRIVATE (plugin)->supported_protocols);
+       return TRUE;
 }
+NM_VPN_EDITOR_PLUGIN_CALL_SET_GET_SERVICE_ADD_DETAILS (_impl_get_service_add_details);
 
 static gboolean
-call (NMVpnEditorPlugin *plugin,
-      const char *request,
-      GError **error,
-      const GValue *const*args_in,
-      GValue *const*args_out)
+_impl_get_service_add_detail (NMVpnEditorPlugin *plugin,
+                              const char *service_type,
+                              const char *add_detail,
+                              char **out_pretty_name,
+                              char **out_description,
+                              char **out_add_detail_key,
+                              guint *out_flags,
+                              GError **error)
 {
        OpenconnectEditorPluginPrivate *priv;
-       const char *service_type;
-       const char *add_detail;
+       guint i;
 
-       if (!strcmp (request, "get-service-add-details")) {
-               service_type = g_value_get_string (args_in[0]);
+       if (!nm_streq (service_type, NM_VPN_SERVICE_TYPE_OPENCONNECT))
+               return FALSE;
 
-               if (service_type) {
-                       if (!strcmp (service_type, NM_VPN_SERVICE_TYPE_OPENCONNECT)) {
-                               priv = OPENCONNECT_EDITOR_PLUGIN_GET_PRIVATE (plugin);
-                               g_value_set_boxed (args_out[0], priv->supported_protocols);
-                               return TRUE;
-                       }
-               }
-               goto out_unknown_service_type;
+       priv = OPENCONNECT_EDITOR_PLUGIN_GET_PRIVATE (plugin);
+
+       if (   nm_streq (add_detail, "anyconnect")
+           && g_strv_contains ((const char *const*) priv->supported_protocols, add_detail)) {
+               *out_pretty_name = g_strdup (OPENCONNECT_PLUGIN_NAME);
+               *out_description = g_strdup (OPENCONNECT_PLUGIN_DESC);
+               *out_add_detail_key = g_strdup (NM_OPENCONNECT_KEY_PROTOCOL);
+               return TRUE;
        }
-       if (!strcmp (request, "get-service-add-detail")) {
-               service_type = g_value_get_string (args_in[0]);
-               add_detail = g_value_get_string (args_in[1]);
-
-               if (service_type) {
-                       if (!add_detail) {
-                               g_set_error (error, NM_VPN_PLUGIN_ERROR, 
NM_VPN_PLUGIN_ERROR_CALL_INVALID_ARGUMENT,
-                                             _("missing add_detail argument"));
-                               return FALSE;
-                       }
-                       if (!strcmp (service_type, NM_VPN_SERVICE_TYPE_OPENCONNECT)) {
-                               guint i;
-
-                               if (!strcmp (add_detail, "anyconnect")) {
-                                       g_value_set_string (args_out[0], OPENCONNECT_PLUGIN_NAME);
-                                       g_value_set_string (args_out[1], OPENCONNECT_PLUGIN_DESC);
-                                       g_value_set_string (args_out[2], NM_OPENCONNECT_KEY_PROTOCOL);
-                                       g_value_set_uint (args_out[3], 0);
-                                       return TRUE;
-                               }
-                               if (!strcmp (add_detail, "nc")) {
-                                       g_value_set_string (args_out[0], _("Juniper Network Connect 
(openconnect)"));
-                                       g_value_set_string (args_out[1], _("Compatible with Juniper Network 
Connect / Pulse Secure SSL VPN"));
-                                       g_value_set_string (args_out[2], NM_OPENCONNECT_KEY_PROTOCOL);
-                                       g_value_set_uint (args_out[3], 0);
-                                       return TRUE;
-                               }
-                               priv = OPENCONNECT_EDITOR_PLUGIN_GET_PRIVATE (plugin);
-                               for (i = 0; priv->supported_protocols[i]; i++) {
-                                       if (strcmp (add_detail, priv->supported_protocols[i]))
-                                               continue;
-                                       /* we don't know this protocol by name, but it's configured in the 
.name file,
-                                        * so just take it. */
-                                       g_value_take_string (args_out[0], g_strdup_printf (_("Openconnect VPN 
(%s)"), add_detail));
-                                       g_value_take_string (args_out[1], g_strdup_printf (_("Openconnect SSL 
VPN with %s protocol"), add_detail));
-                                       g_value_set_string (args_out[2], NM_OPENCONNECT_KEY_PROTOCOL);
-                                       g_value_set_uint (args_out[3], 0);
-                                       return TRUE;
-                               }
-
-                               g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
-                                             _("add-detail '%s' for '%s' does not support add-details"), 
add_detail, service_type);
-                               return FALSE;
-                       }
-               }
-               goto out_unknown_service_type;
+       if (   nm_streq (add_detail, "nc")
+           && g_strv_contains ((const char*const*) priv->supported_protocols, add_detail)) {
+               *out_pretty_name = g_strdup (_("Juniper Network Connect (openconnect)"));
+               *out_description = g_strdup (_("Compatible with Juniper Network Connect / Pulse Secure SSL 
VPN"));
+               *out_add_detail_key = g_strdup (NM_OPENCONNECT_KEY_PROTOCOL);
+               return TRUE;
        }
-       return FALSE;
-out_unknown_service_type:
-       g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_CALL_INVALID_ARGUMENT,
-                    _("Unknown service-type '%s'"), service_type);
+       for (i = 0; priv->supported_protocols[i]; i++) {
+               if (strcmp (add_detail, priv->supported_protocols[i]))
+                       continue;
+               /* we don't know this protocol by name, but it's configured in the .name file,
+                * so just take it. */
+               *out_pretty_name = g_strdup_printf (_("Openconnect VPN (%s)"), add_detail);
+               *out_description = g_strdup_printf (_("Openconnect SSL VPN with %s protocol"), add_detail);
+               *out_add_detail_key = g_strdup (NM_OPENCONNECT_KEY_PROTOCOL);
+               return TRUE;
+       }
+
+       g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
+                    _("add-detail '%s' for '%s' does not support add-details"), add_detail, service_type);
        return FALSE;
 }
+NM_VPN_EDITOR_PLUGIN_CALL_SET_GET_SERVICE_ADD_DETAIL (_impl_get_service_add_detail);
+
 #endif
 
 static NMVpnEditor *
@@ -1026,9 +984,8 @@ openconnect_editor_plugin_interface_init (NMVpnEditorPluginInterface *iface_clas
        iface_class->import_from_file = import;
        iface_class->export_to_file = export;
 #ifndef NM_OPENCONNECT_OLD
-       iface_class->call_get_signature = call_get_signature;
-       iface_class->call = call;
        iface_class->notify_plugin_info_set = notify_plugin_info_set;
+       NM_VPN_EDITOR_PLUGIN_CALL_SETUP (iface_class);
 #endif
 }
 
diff --git a/shared/Makefile.am b/shared/Makefile.am
new file mode 100644
index 0000000..ff2c8bc
--- /dev/null
+++ b/shared/Makefile.am
@@ -0,0 +1,4 @@
+EXTRA_DIST = \
+    gsystem-local-alloc.h \
+    nm-macros-internal.h \
+    nm-vpn-editor-plugin-call.h
diff --git a/shared/gsystem-local-alloc.h b/shared/gsystem-local-alloc.h
new file mode 100644
index 0000000..51b6251
--- /dev/null
+++ b/shared/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-macros-internal.h b/shared/nm-macros-internal.h
new file mode 100644
index 0000000..a8000ac
--- /dev/null
+++ b/shared/nm-macros-internal.h
@@ -0,0 +1,604 @@
+/* -*- 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>
+
+/********************************************************/
+
+#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)
+
+/********************************************************/
+
+/* 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_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]); \
+}
+
+/*****************************************************************************/
+
+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
+ * contentaining 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 knowledgeble people that ensure
+ * that this additinal 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);
+}
+
+/*****************************************************************************/
+
+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);
+}
+/*****************************************************************************/
+
+#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-vpn-editor-plugin-call.h b/shared/nm-vpn-editor-plugin-call.h
new file mode 100644
index 0000000..764d349
--- /dev/null
+++ b/shared/nm-vpn-editor-plugin-call.h
@@ -0,0 +1,407 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/* NetworkManager -- Network link manager
+ *
+ * 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 (C) 2015 Red Hat, Inc.
+ */
+
+#ifndef __NM_VPN_EDITOR_PLUGIN_CALL_H__
+#define __NM_VPN_EDITOR_PLUGIN_CALL_H__
+
+/* This header is an internal, header-only file that can be copied to
+ * other projects to call well-known service functions on VPN plugins. */
+
+#include <NetworkManager.h>
+
+/* we make use of otherinternal header files, you need those too. */
+#include "gsystem-local-alloc.h"
+#include "nm-macros-internal.h"
+
+/*****************************************************************************/
+
+/**
+ * NMVpnEditorPluginServiceFlags:
+ * @NM_VPN_EDITOR_PLUGIN_SERVICE_FLAGS_NONE: no flags
+ * @NM_VPN_EDITOR_PLUGIN_SERVICE_FLAGS_CAN_ADD: whether the plugin can
+ *   add a new connection for the given service-type.
+ **/
+typedef enum { /*< skip >*/
+       NM_VPN_EDITOR_PLUGIN_SERVICE_FLAGS_NONE     = 0x00,
+       NM_VPN_EDITOR_PLUGIN_SERVICE_FLAGS_CAN_ADD  = 0x01,
+} NMVpnEditorPluginServiceFlags;
+
+/*****************************************************************************/
+
+/**
+ * NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_INFO: name of call "get-service-info".
+ *   This call has 1 input argument:
+ *     service-type (string): analog to NM_VPN_EDITOR_PLUGIN_SERVICE
+ *     it specifies for which service-type the information is requested.
+ *     This can either be the main service-type or an alias.
+ *   This call has 3 output arguments:
+ *     short-name (string): for the main service-type, this shall return [VPN Connection].name.
+ *        Otherwise, it is a short-name to refer to service-type.
+ *     pretty-name (string): for the main service-type, this shall return NM_VPN_EDITOR_PLUGIN_NAME.
+ *        It's a localized, pretty name of the service-type.
+ *     description (string): for the main service-type, this shall return NM_VPN_EDITOR_PLUGIN_DESCRIPTION
+ *        It's a localized, description for the service-type.
+ *     service flags (uint): flags for the service-type.
+ */
+#define NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_INFO "get-service-info"
+
+/**
+ * NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAILS: name of call "get-service-add-details".
+ *   For one particular service-type, the UI might want to show multiple "Add new connection"
+ *   entires. That is controlled by passing around "add-details".
+ *   The "get-service-add-details" returns optionally a list of "add-details" if it wishes
+ *   to generate multiple add entries.
+ *   This call has 1 input argument:
+ *     service-type: string: analog to NM_VPN_EDITOR_PLUGIN_SERVICE or an service-type
+ *        alias.
+ *   This call has 1 output argument:
+ *     add-details: strv: a list of details that can be passed to "get-service-add-detail"
+ *        call.
+ */
+#define NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAILS "get-service-add-details"
+
+/**
+ * NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAIL: if the plugin supports "add-details"
+ *   as indicated by "get-service-add-details", return more information.
+ *   This call has 2 input arguments:
+ *     service-name: string: analog to NM_VPN_EDITOR_PLUGIN_SERVICE or an service-type
+ *        alias. This was passed to "get-service-add-details" call.
+ *     add-detail: a detail for which the information is requested.
+ *   This call has 1 output argument:
+ *     pretty-name: (string), a localized name for what is to be added. Similar to
+ *       NM_VPN_EDITOR_PLUGIN_NAME.
+ *     description: (string), a localized descirption, similar to NM_VPN_EDITOR_PLUGIN_DESCRIPTION.
+ *     add-detail-key: (string), when creating such a connection of type "service-type","add-detail",
+ *       the user shall create a NMConnection with setting "service-type". It also sets the VPN
+ *       key "add-detail-key" to the value "add-detail", so that the plugin knows which connection
+ *       is to be created.
+ *     flags: (uint), additional flags, currently unused.
+ */
+#define NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAIL "get-service-add-detail"
+
+/*****************************************************************************
+ * Call
+ *
+ * The following wrap the calling of generic functions for a VPN plugin.
+ * They are used by callers (for example nm-connection-editor).
+ *****************************************************************************/
+
+static inline gboolean
+nm_vpn_editor_plugin_get_service_info (NMVpnEditorPlugin *plugin,
+                                       const char *service_type,
+                                       char **out_short_name,
+                                       char **out_pretty_name,
+                                       char **out_description,
+                                       NMVpnEditorPluginServiceFlags *out_flags)
+{
+       gs_free char *short_name_local = NULL;
+       gs_free char *pretty_name_local = NULL;
+       gs_free char *description_local = NULL;
+       guint flags_local = 0;
+
+       g_return_val_if_fail (NM_IS_VPN_EDITOR_PLUGIN (plugin), FALSE);
+       g_return_val_if_fail (service_type, FALSE);
+
+       if (!nm_vpn_editor_plugin_call (plugin,
+                                       NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_INFO,
+                                       NULL,
+                                       G_TYPE_STRING, &service_type,
+                                       G_TYPE_INVALID,
+                                       G_TYPE_STRING, &short_name_local,
+                                       G_TYPE_STRING, &pretty_name_local,
+                                       G_TYPE_STRING, &description_local,
+                                       G_TYPE_UINT,   &flags_local,
+                                       G_TYPE_INVALID))
+               return FALSE;
+       NM_SET_OUT (out_short_name, g_steal_pointer (&short_name_local));
+       NM_SET_OUT (out_pretty_name, g_steal_pointer (&pretty_name_local));
+       NM_SET_OUT (out_description, g_steal_pointer (&description_local));
+       NM_SET_OUT (out_flags, flags_local);
+       return TRUE;
+}
+
+static inline char **
+nm_vpn_editor_plugin_get_service_add_details (NMVpnEditorPlugin *plugin,
+                                              const char *service_name)
+{
+       char **details = NULL;
+
+       g_return_val_if_fail (NM_IS_VPN_EDITOR_PLUGIN (plugin), FALSE);
+       g_return_val_if_fail (service_name, FALSE);
+
+       if (!nm_vpn_editor_plugin_call (plugin,
+                                       NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAILS,
+                                       NULL,
+                                       G_TYPE_STRING, service_name,
+                                       G_TYPE_INVALID,
+                                       G_TYPE_STRV,   &details,
+                                       G_TYPE_INVALID))
+               g_clear_pointer (&details, g_strfreev);
+       else if (!details)
+               return g_new0 (char *, 1);
+       return details;
+}
+
+static inline gboolean
+nm_vpn_editor_plugin_get_service_add_detail (NMVpnEditorPlugin *plugin,
+                                             const char *service_type,
+                                             const char *add_detail,
+                                             char **out_pretty_name,
+                                             char **out_description,
+                                             char **out_add_detail_key,
+                                             guint *out_flags)
+{
+       gs_free char *pretty_name_local = NULL;
+       gs_free char *description_local = NULL;
+       gs_free char *add_detail_key_local = NULL;
+       guint flags_local = 0;
+
+       g_return_val_if_fail (NM_IS_VPN_EDITOR_PLUGIN (plugin), FALSE);
+       g_return_val_if_fail (service_type, FALSE);
+       g_return_val_if_fail (add_detail, FALSE);
+
+       if (!nm_vpn_editor_plugin_call (plugin,
+                                       NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAIL,
+                                       NULL,
+                                       G_TYPE_STRING, service_type,
+                                       G_TYPE_STRING, add_detail,
+                                       G_TYPE_INVALID,
+                                       G_TYPE_STRING, &pretty_name_local,
+                                       G_TYPE_STRING, &description_local,
+                                       G_TYPE_STRING, &add_detail_key_local,
+                                       G_TYPE_UINT,   out_flags ?: &flags_local,
+                                       G_TYPE_INVALID))
+               return FALSE;
+       NM_SET_OUT (out_pretty_name, g_steal_pointer (&pretty_name_local));
+       NM_SET_OUT (out_description, g_steal_pointer (&description_local));
+       NM_SET_OUT (out_add_detail_key, g_steal_pointer (&add_detail_key_local));
+       return TRUE;
+}
+
+/*****************************************************************************
+ * Implementation
+ *
+ * The following glue code can be used to implement calls in a VPN plugin.
+ * Register your hocks via NM_VPN_EDITOR_PLUGIN_CALL_SET_*() and
+ * NM_VPN_EDITOR_PLUGIN_CALL_SETUP().
+ *****************************************************************************/
+
+static gboolean (*const _nm_vpn_editor_plugin_call_impl_get_service_info) (NMVpnEditorPlugin *plugin,
+                                                                           const char *service_type,
+                                                                           char **out_short_name,
+                                                                           char **out_pretty_name,
+                                                                           char **out_description,
+                                                                           NMVpnEditorPluginServiceFlags 
*out_flags,
+                                                                           GError **error);
+
+#define NM_VPN_EDITOR_PLUGIN_CALL_SET_GET_SERVICE_INFO(fcn) \
+static gboolean (*const _nm_vpn_editor_plugin_call_impl_get_service_info) (NMVpnEditorPlugin *plugin, \
+                                                                           const char *service_type, \
+                                                                           char **out_short_name, \
+                                                                           char **out_pretty_name, \
+                                                                           char **out_description, \
+                                                                           NMVpnEditorPluginServiceFlags 
*out_flags, \
+                                                                           GError **error) = (fcn)
+
+static gboolean (*const _nm_vpn_editor_plugin_call_impl_get_service_add_details) (NMVpnEditorPlugin *plugin,
+                                                                                  const char *service_type,
+                                                                                  char ***out_add_details,
+                                                                                  GError **error);
+
+#define NM_VPN_EDITOR_PLUGIN_CALL_SET_GET_SERVICE_ADD_DETAILS(fcn) \
+static gboolean (*const _nm_vpn_editor_plugin_call_impl_get_service_add_details) (NMVpnEditorPlugin *plugin, 
\
+                                                                                  const char *service_type, \
+                                                                                  char ***out_add_details, \
+                                                                                  GError **error) = (fcn)
+
+static gboolean (*const _nm_vpn_editor_plugin_call_impl_get_service_add_detail) (NMVpnEditorPlugin *plugin,
+                                                                                 const char *service_type,
+                                                                                 const char *add_detail,
+                                                                                 char **out_pretty_name,
+                                                                                 char **out_description,
+                                                                                 char **out_add_detail_key,
+                                                                                 guint *out_flags,
+                                                                                 GError **error);
+
+#define NM_VPN_EDITOR_PLUGIN_CALL_SET_GET_SERVICE_ADD_DETAIL(fcn) \
+static gboolean (*const _nm_vpn_editor_plugin_call_impl_get_service_add_detail) (NMVpnEditorPlugin *plugin, \
+                                                                                 const char *service_type, \
+                                                                                 const char *add_detail, \
+                                                                                 char **out_pretty_name, \
+                                                                                 char **out_description, \
+                                                                                 char **out_add_detail_key, \
+                                                                                 guint *out_flags, \
+                                                                                 GError **error) = (fcn)
+
+static inline gboolean
+_nm_vpn_editor_plugin_call_get_signature (NMVpnEditorPlugin *plugin,
+                                          const char *request,
+                                          gboolean *free_types,
+                                          GType **types_in,
+                                          GType **types_out)
+{
+       if (   _nm_vpn_editor_plugin_call_impl_get_service_info
+           && nm_streq (request, NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_INFO)) {
+               static GType t_in[] = { G_TYPE_STRING, 0 };
+               static GType t_out[] = { G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, 0 };
+
+               *types_in = t_in;
+               *types_out = t_out;
+               return TRUE;
+       }
+       if (   _nm_vpn_editor_plugin_call_impl_get_service_add_details
+           && nm_streq (request, NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAILS)) {
+               static GType t_in[] = { G_TYPE_STRING, 0 };
+               static GType t_out[] = { 0, 0 };
+
+               if (G_UNLIKELY (t_out[0] == 0))
+                       t_out[0] = G_TYPE_STRV;
+
+               *types_in = t_in;
+               *types_out = t_out;
+               return TRUE;
+       }
+       if (   _nm_vpn_editor_plugin_call_impl_get_service_add_detail
+           && nm_streq (request, NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAIL)) {
+               static GType t_in[] = { G_TYPE_STRING, G_TYPE_STRING, 0 };
+               static GType t_out[] = { G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, 0 };
+
+               *types_in = t_in;
+               *types_out = t_out;
+               return TRUE;
+       }
+       return FALSE;
+}
+
+static inline gboolean
+_nm_vpn_editor_plugin_call_fail_unknown_service_type (GError **error, const char *service_type)
+{
+       if (error && !*error) {
+               g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_CALL_INVALID_ARGUMENT,
+                            _("Unknown service-type %s%s%s"), NM_PRINT_FMT_QUOTE_STRING (service_type));
+       }
+       return FALSE;
+}
+
+static inline gboolean
+_nm_vpn_editor_plugin_call (NMVpnEditorPlugin *plugin,
+                            const char *request,
+                            GError **error,
+                            const GValue *const*args_in,
+                            GValue *const*args_out)
+{
+       if (   _nm_vpn_editor_plugin_call_impl_get_service_info
+           && nm_streq (request, NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_INFO)) {
+               const char *service_type;
+               gs_free char *short_name = NULL;
+               gs_free char *pretty_name = NULL;
+               gs_free char *description = NULL;
+               NMVpnEditorPluginServiceFlags flags = 0;
+
+               service_type = g_value_get_string (args_in[0]);
+
+               if (!service_type)
+                       return _nm_vpn_editor_plugin_call_fail_unknown_service_type (error, service_type);
+
+               if (_nm_vpn_editor_plugin_call_impl_get_service_info (plugin,
+                                                                     service_type,
+                                                                     &short_name,
+                                                                     &pretty_name,
+                                                                     &description,
+                                                                     &flags,
+                                                                        error)) {
+                       g_value_take_string (args_out[0], g_steal_pointer (&short_name));
+                       g_value_take_string (args_out[1], g_steal_pointer (&pretty_name));
+                       g_value_take_string (args_out[2], g_steal_pointer (&description));
+                       g_value_set_uint (args_out[3], flags);
+                       return TRUE;
+               }
+               return _nm_vpn_editor_plugin_call_fail_unknown_service_type (error, service_type);
+       }
+
+       if (   _nm_vpn_editor_plugin_call_impl_get_service_add_details
+           && nm_streq (request, NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAILS)) {
+               const char *service_type;
+
+               service_type = g_value_get_string (args_in[0]);
+               if (service_type) {
+                       gs_strfreev char **add_details = NULL;
+
+                       if (_nm_vpn_editor_plugin_call_impl_get_service_add_details (plugin,
+                                                                                    service_type,
+                                                                                    &add_details,
+                                                                                    error)) {
+                               g_value_take_boxed (args_out[0], g_steal_pointer (&add_details));
+                               return TRUE;
+                       }
+               }
+               return _nm_vpn_editor_plugin_call_fail_unknown_service_type (error, service_type);
+       }
+
+       if (   _nm_vpn_editor_plugin_call_impl_get_service_add_detail
+           && nm_streq (request, NM_VPN_EDITOR_PLUGIN_CALL_GET_SERVICE_ADD_DETAIL)) {
+               const char *service_type;
+               const char *add_detail;
+               gs_free char *pretty_name = NULL;
+               gs_free char *description = NULL;
+               gs_free char *add_detail_key = NULL;
+               guint flags = 0;
+
+               service_type = g_value_get_string (args_in[0]);
+               add_detail = g_value_get_string (args_in[1]);
+
+               if (!service_type)
+                       return _nm_vpn_editor_plugin_call_fail_unknown_service_type (error, service_type);
+
+               if (!add_detail) {
+                       g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_CALL_INVALID_ARGUMENT,
+                                    _("missing add_detail argument"));
+                       return FALSE;
+               }
+               if (_nm_vpn_editor_plugin_call_impl_get_service_add_detail (plugin,
+                                                                           service_type,
+                                                                           add_detail,
+                                                                           &pretty_name,
+                                                                           &description,
+                                                                           &add_detail_key,
+                                                                           &flags,
+                                                                           error)) {
+                       g_value_take_string (args_out[0], g_steal_pointer (&pretty_name));
+                       g_value_take_string (args_out[1], g_steal_pointer (&description));
+                       g_value_take_string (args_out[2], g_steal_pointer (&add_detail_key));
+                       g_value_set_uint (args_out[3], flags);
+                       return TRUE;
+               }
+               return _nm_vpn_editor_plugin_call_fail_unknown_service_type (error, service_type);
+       }
+
+       g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_CALL_INVALID_ARGUMENT,
+                    _("Unknown request %s"), request);
+       return FALSE;
+}
+
+static inline void
+NM_VPN_EDITOR_PLUGIN_CALL_SETUP (NMVpnEditorPluginInterface *iface_class)
+{
+       iface_class->call_get_signature = _nm_vpn_editor_plugin_call_get_signature;
+       iface_class->call = _nm_vpn_editor_plugin_call;
+}
+
+#endif /* __NM_VPN_EDITOR_PLUGIN_CALL_H__ */


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