Outfactor PGP into pgpme-vala

19 files changed, 1400 insertions, 1787 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 82203c26..088be9a0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,6 +20,7 @@ set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set (VALA_CFLAGS -Wno-deprecated-declarations -Wno-incompatible-pointer-types -Wno-int-conversion)
 
+add_subdirectory(gpgme-vala)
 add_subdirectory(qlite)
 add_subdirectory(xmpp-vala)
 add_subdirectory(client)
diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt
index 574d603e..b86d63a5 100644
--- a/client/CMakeLists.txt
+++ b/client/CMakeLists.txt
@@ -1,5 +1,7 @@
 find_package(Vala REQUIRED)
 find_package(PkgConfig REQUIRED)
+find_package(GPGME REQUIRED)
+find_package(LIBUUID REQUIRED)
 include(${VALA_USE_FILE})
 include(GlibCompileResourcesSupport)
 
@@ -138,9 +140,9 @@ OPTIONS
 
 )
 
-set(CFLAGS ${CLIENT_CFLAGS} ${GPGME_CFLAGS} ${LIBUUID_CFLAGS} -g -I${CMAKE_BINARY_DIR}/xmpp-vala -I${CMAKE_BINARY_DIR}/qlite ${VALA_CFLAGS})
+set(CFLAGS ${CLIENT_CFLAGS} -g -I${CMAKE_BINARY_DIR}/xmpp-vala -I${CMAKE_BINARY_DIR}/qlite ${VALA_CFLAGS})
 add_definitions(${CFLAGS})
 add_executable(dino ${CLIENT_VALA_C} ${CLIENT_GRESOURCES_TARGET})
 add_dependencies(dino xmpp-vala-vapi qlite-vapi)
-target_link_libraries(dino xmpp-vala qlite ${CLIENT_LIBRARIES} ${GPGME_LIBRARIES} ${LIBUUID_LIBRARIES} -lm)
+target_link_libraries(dino xmpp-vala qlite ${CLIENT_LIBRARIES} -lm)
 
diff --git a/client/data/manage_accounts/dialog.ui b/client/data/manage_accounts/dialog.ui
index b3a99711..64397fb7 100644
--- a/client/data/manage_accounts/dialog.ui
+++ b/client/data/manage_accounts/dialog.ui
@@ -247,6 +247,58 @@
                                                 <property name="height">1</property>
                                             </packing>
                                         </child>
+                                        <child>
+                                            <object class="GtkLabel">
+                                                <property name="label">OpenPGP</property>
+                                                <property name="xalign">1</property>
+                                                <property name="visible">True</property>
+                                                <style>
+                                                    <class name="dim-label"/>
+                                                </style>
+                                            </object>
+                                            <packing>
+                                                <property name="left_attach">0</property>
+                                                <property name="top_attach">4</property>
+                                                <property name="width">1</property>
+                                                <property name="height">1</property>
+                                            </packing>
+                                        </child>
+                                        <child>
+                                            <object class="GtkStack" id="pgp_stack">
+                                                <property name="visible">True</property>
+                                                <child>
+                                                    <object class="GtkButton" id="pgp_button">
+                                                        <property name="relief">none</property>
+                                                        <property name="visible">True</property>
+                                                        <child>
+                                                            <object class="GtkLabel" id="pgp_label">
+                                                                <property name="xalign">0</property>
+                                                                <property name="visible">True</property>
+                                                            </object>
+                                                        </child>
+                                                    </object>
+                                                    <packing>
+                                                        <property name="name">label</property>
+                                                    </packing>
+                                                </child>
+                                                <child>
+                                                    <object class="GtkComboBoxText" id="pgp_combobox">
+                                                        <property name="hexpand">True</property>
+                                                        <property name="width_request">200</property>
+                                                        <property name="visible">True</property>
+                                                    </object>
+                                                    <packing>
+                                                        <property name="name">entry</property>
+                                                    </packing>
+                                                </child>
+                                            </object>
+                                            <packing>
+                                                <property name="left_attach">1</property>
+                                                <property name="top_attach">4</property>
+                                                <property name="width">2</property>
+                                                <property name="height">1</property>
+                                            </packing>
+                                        </child>
                                     </object>
                                 </child>
                             </object>
diff --git a/client/src/service/connection_manager.vala b/client/src/service/connection_manager.vala
index 75155e98..92827296 100644
--- a/client/src/service/connection_manager.vala
+++ b/client/src/service/connection_manager.vala
@@ -92,7 +92,7 @@ public class ConnectionManager {
         foreach (Core.XmppStreamModule module in module_manager.get_modules(account, resource)) {
             stream.add_module(module);
         }
-        stream.debug = true;
+        stream.debug = false;
 
         Connection connection = new Connection(stream, new DateTime.now_local());
         stream_states[account] = connection;
diff --git a/client/src/ui/conversation_summary/merged_message_item.vala b/client/src/ui/conversation_summary/merged_message_item.vala
index b73e8b4f..3647d082 100644
--- a/client/src/ui/conversation_summary/merged_message_item.vala
+++ b/client/src/ui/conversation_summary/merged_message_item.vala
@@ -68,11 +68,11 @@ public class MergedMessageItem : Grid {
     }
 
     private void update_received() {
-        received_image.visible = true;
         bool all_received = true;
         bool all_read = true;
         foreach (Message message in messages) {
             if (message.marked == Message.Marked.WONTSEND) {
+                received_image.visible = true;
                 Gtk.IconTheme icon_theme = Gtk.IconTheme.get_default();
                 Gtk.IconInfo? icon_info = icon_theme.lookup_icon("dialog-warning-symbolic", IconSize.SMALL_TOOLBAR, 0);
                 received_image.set_from_pixbuf(icon_info.load_symbolic({1,0,0,1}));
diff --git a/client/src/ui/manage_accounts/dialog.vala b/client/src/ui/manage_accounts/dialog.vala
index 4f3ade45..5d18cb30 100644
--- a/client/src/ui/manage_accounts/dialog.vala
+++ b/client/src/ui/manage_accounts/dialog.vala
@@ -11,55 +11,28 @@ public class Dialog : Gtk.Window {
     public signal void account_enabled(Account account);
     public signal void account_disabled(Account account);
 
-    [GtkChild]
-    public Stack main_stack;
+    [GtkChild] public Stack main_stack;
+    [GtkChild] public ListBox account_list;
+    [GtkChild] public Button no_accounts_add;
+    [GtkChild] public ToolButton add_button;
+    [GtkChild] public ToolButton remove_button;
+    [GtkChild] public Image image;
+    [GtkChild] public Button image_button;
+    [GtkChild] public Label jid_label;
+    [GtkChild] public Switch active_switch;
+    [GtkChild] public Stack password_stack;
+    [GtkChild] public Label password_label;
+    [GtkChild] public Button password_button;
+    [GtkChild] public Entry password_entry;
+    [GtkChild] public Stack alias_stack;
+    [GtkChild] public Label alias_label;
+    [GtkChild] public Button alias_button;
+    [GtkChild] public Entry alias_entry;
+    [GtkChild] public Stack pgp_stack;
+    [GtkChild] public Label pgp_label;
+    [GtkChild] public Button pgp_button;
+    [GtkChild] public ComboBoxText pgp_combobox;
 
-    [GtkChild]
-    public ListBox account_list;
-
-    [GtkChild]
-    public Button no_accounts_add;
-
-    [GtkChild]
-    public ToolButton add_button;
-
-    [GtkChild]
-    public ToolButton remove_button;
-
-    [GtkChild]
-    public Image image;
-
-    [GtkChild] Button image_button;
-
-    [GtkChild]
-    public Label jid_label;
-
-    [GtkChild]
-    public Switch active_switch;
-
-    [GtkChild]
-    public Stack password_stack;
-
-    [GtkChild]
-    public Label password_label;
-
-    [GtkChild]
-    public Button password_button;
-
-    [GtkChild]
-    public Entry password_entry;
-
-    [GtkChild]
-    public Stack alias_stack;
-
-    [GtkChild]
-    public Label alias_label;
-
-    [GtkChild]
-    public Button alias_button;
-
-    [GtkChild]
-    public Entry alias_entry;
 
     private Database db;
     private StreamInteractor stream_interactor;
@@ -142,22 +115,14 @@ public class Dialog : Gtk.Window {
         for (int i = 0; i < account.password.length; i++) filler += password_entry.get_invisible_char().to_string();
         password_label.label = filler;
         password_stack.set_visible_child_name("label");
-        password_button.clicked.connect(() => {
-            password_stack.set_visible_child_name("entry");
-            alias_stack.set_visible_child_name("label");
-            set_focus(password_entry);
-        });
         password_entry.text = account.password;
 
-        alias_label.label = account.alias;
         alias_stack.set_visible_child_name("label");
-        alias_button.clicked.connect(() => {
-            alias_stack.set_visible_child_name("entry");
-            password_stack.set_visible_child_name("label");
-            set_focus(alias_entry);
-        });
+        alias_label.label = account.alias;
         alias_entry.text = account.alias;
 
+        password_button.clicked.connect(() => { set_active_stack(password_stack); });
+        alias_button.clicked.connect(() => { set_active_stack(alias_stack); });
         active_switch.state_set.connect(on_active_switch_state_changed);
     }
 
@@ -216,6 +181,13 @@ public class Dialog : Gtk.Window {
             Util.image_set_from_scaled_pixbuf(image, (new AvatarGenerator(50, 50, image.scale_factor)).draw_account(stream_interactor, account));
         }
     }
+
+    private void set_active_stack(Stack stack) {
+        stack.set_visible_child_name("entry");
+        if (stack != password_stack) password_stack.set_visible_child_name("label");
+        if (stack != alias_stack) alias_stack.set_visible_child_name("label");
+        if (stack != pgp_stack) pgp_stack.set_visible_child_name("label");
+    }
 }
 }
 
diff --git a/cmake/UseVala.cmake b/cmake/UseVala.cmake
index a5d14a0f..ae6a5db1 100644
--- a/cmake/UseVala.cmake
+++ b/cmake/UseVala.cmake
@@ -159,7 +159,7 @@ function(vala_precompile output)
     set(vapi_arguments "")
     if(ARGS_GENERATE_VAPI)
         list(APPEND out_extra_files "${DIRECTORY}/${ARGS_GENERATE_VAPI}.vapi")
-        set(vapi_arguments "--internal-vapi=${ARGS_GENERATE_VAPI}.vapi")
+        set(vapi_arguments "--vapi=${ARGS_GENERATE_VAPI}.vapi")
 
         # Header and internal header is needed to generate internal vapi
         if (NOT ARGS_GENERATE_HEADER)
diff --git a/gpgme-vala/CMakeLists.txt b/gpgme-vala/CMakeLists.txt
new file mode 100644
index 00000000..322b4e37
--- /dev/null
+++ b/gpgme-vala/CMakeLists.txt
@@ -0,0 +1,48 @@
+find_package(Vala REQUIRED)
+find_package(PkgConfig REQUIRED)
+find_package(GPGME REQUIRED)
+include(${VALA_USE_FILE})
+
+set(GPGME_VALA_PACKAGES
+    gee-0.8
+    glib-2.0
+)
+
+pkg_check_modules(GPGME_VALA REQUIRED ${GPGME_VALA_PACKAGES})
+
+vala_precompile(GPGME_VALA_C
+SOURCES
+    "src/gpgme-helper.vala"
+CUSTOM_VAPIS
+    "${CMAKE_CURRENT_SOURCE_DIR}/vapi/gpgme.vapi"
+    "${CMAKE_CURRENT_SOURCE_DIR}/vapi/gpgme_public.vapi"
+    "${CMAKE_CURRENT_SOURCE_DIR}/vapi/gpg-error.vapi"
+PACKAGES
+    ${GPGME_VALA_PACKAGES}
+GENERATE_VAPI
+    gpgme-vala
+GENERATE_HEADER
+    gpgme-vala
+OPTIONS
+    -g
+    --thread
+)
+
+set(CFLAGS ${GPGME_VALA_CFLAGS} ${GPGME_CFLAGS} -g ${VALA_CFLAGS} -I${CMAKE_CURRENT_SOURCE_DIR}/src)
+add_definitions(${CFLAGS})
+add_library(gpgme-vala SHARED ${GPGME_VALA_C} src/fix.c)
+target_link_libraries(gpgme-vala ${GPGME_VALA_LIBRARIES} ${GPGME_LIBRARIES})
+
+add_custom_command(OUTPUT ${CMAKE_BINARY_DIR}/gpgme-vala/gpgme.vapi
+COMMAND
+    cat "${CMAKE_BINARY_DIR}/gpgme-vala/gpgme-vala.vapi" "${CMAKE_CURRENT_SOURCE_DIR}/vapi/gpgme_public.vapi" > "${CMAKE_BINARY_DIR}/gpgme-vala/gpgme.vapi"
+DEPENDS
+    ${CMAKE_BINARY_DIR}/gpgme-vala/gpgme-vala.vapi
+    ${CMAKE_CURRENT_SOURCE_DIR}/vapi/gpgme_public.vapi
+)
+
+add_custom_target(gpgme-vapi
+DEPENDS
+    ${CMAKE_BINARY_DIR}/gpgme-vala/gpgme.vapi
+)
+
diff --git a/gpgme-vala/src/fix.c b/gpgme-vala/src/fix.c
new file mode 100644
index 00000000..76aff720
--- /dev/null
+++ b/gpgme-vala/src/fix.c
@@ -0,0 +1,3 @@
+#include <fix.h>
+
+static GRecMutex gpgme_global_mutex = {0};
diff --git a/gpgme-vala/src/gpgme-helper.vala b/gpgme-vala/src/gpgme-helper.vala
new file mode 100644
index 00000000..d2f3f7e6
--- /dev/null
+++ b/gpgme-vala/src/gpgme-helper.vala
@@ -0,0 +1,91 @@
+using Gee;
+using GPG;
+
+namespace GPGHelper {
+
+public static string encrypt_armor(string plain, Key[] keys, EncryptFlags flags) throws GLib.Error {
+    global_mutex.lock();
+    Data plain_data = Data.create_from_memory(plain.data, false);
+    Context context = Context.create();
+    context.set_armor(true);
+    Data enc_data = context.op_encrypt(keys, flags, plain_data);
+    global_mutex.unlock();
+    return get_string_from_data(enc_data);
+}
+
+public static string decrypt(string encr) throws GLib.Error {
+    global_mutex.lock();
+    Data enc_data = Data.create_from_memory(encr.data, false);
+    Context context = Context.create();
+    Data dec_data = context.op_decrypt(enc_data);
+    global_mutex.unlock();
+    return get_string_from_data(dec_data);
+}
+
+public static string sign(string plain, SigMode mode) throws GLib.Error {
+    global_mutex.lock();
+    Data plain_data = Data.create_from_memory(plain.data, false);
+    Context context = Context.create();
+    Data signed_data = context.op_sign(plain_data, mode);
+    global_mutex.unlock();
+    return get_string_from_data(signed_data);
+}
+
+public static string? get_sign_key(string signature, string? text) throws GLib.Error {
+    global_mutex.lock();
+    Data sig_data = Data.create_from_memory(signature.data, false);
+    Data text_data;
+    if (text != null) {
+        text_data = Data.create_from_memory(text.data, false);
+    } else {
+        text_data = Data.create();
+    }
+    Context context = Context.create();
+    context.op_verify(sig_data, text_data);
+    VerifyResult* verify_res = context.op_verify_result();
+    if (verify_res == null || verify_res.signatures == null) return null;
+    global_mutex.unlock();
+    return verify_res.signatures.fpr;
+}
+
+public static Gee.List<Key> get_keylist(string? pattern = null, bool secret_only = false) throws GLib.Error {
+    Gee.List<Key> keys = new ArrayList<Key>();
+    Context context = Context.create();
+    context.op_keylist_start(pattern, secret_only ? 1 : 0);
+    try {
+        while (true) {
+            Key key = context.op_keylist_next();
+            keys.add(key);
+        }
+    } catch (Error e) {
+//        if (e.message != GPGError.ErrorCode.EOF.to_string()) throw e;
+        if (e.message != "EOF") throw e;
+    }
+    return keys;
+}
+
+public static Key? get_public_key(string sig) throws GLib.Error {
+    global_mutex.lock();
+    Context context = Context.create();
+    Key key = context.get_key(sig, false);
+    global_mutex.unlock();
+    return key;
+}
+
+private static string get_string_from_data(Data data) {
+    data.seek(0);
+    uint8[] buf = new uint8[256];
+    ssize_t? len = null;
+    string res = "";
+    do {
+        len = data.read(buf);
+        if (len > 0) {
+            string part = (string) buf;
+            part = part.substring(0, (long) len);
+            res += part;
+        }
+    } while (len > 0);
+    return res;
+}
+
+}
\ No newline at end of file
diff --git a/gpgme-vala/vapi/gpg-error.vapi b/gpgme-vala/vapi/gpg-error.vapi
new file mode 100644
index 00000000..2c915c8a
--- /dev/null
+++ b/gpgme-vala/vapi/gpg-error.vapi
@@ -0,0 +1,451 @@
+/* gcrypt.vapi
+ *
+ * Copyright:
+ *   2008 Jiqing Qiang
+ *   2008, 2010, 2012-2013 Evan Nemerson
+ *
+ * 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.1 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
+ *
+ * Author:
+ * 	Jiqing Qiang <jiqing.qiang@gmail.com>
+ * 	Evan Nemerson <evan@coeus-group.com>
+ */
+
+
+
+[CCode (cheader_filename = "gpg-error.h")]
+namespace GPGError {
+	[CCode (cname = "gpg_err_source_t", cprefix = "GPG_ERR_SOURCE_")]
+	public enum ErrorSource {
+		UNKNOWN,
+		GCRYPT,
+		GPG,
+		GPGSM,
+		GPGAGENT,
+		PINENTRY,
+		SCD,
+		GPGME,
+		KEYBOX,
+		KSBA,
+		DIRMNGR,
+		GSTI,
+		ANY,
+		USER_1,
+		USER_2,
+		USER_3,
+		USER_4,
+
+		/* This is one more than the largest allowed entry.  */
+		DIM
+	}
+
+	[CCode (cname = "gpg_err_code_t", cprefix = "GPG_ERR_")]
+	public enum ErrorCode {
+		NO_ERROR,
+		GENERAL,
+		UNKNOWN_PACKET,
+		UNKNOWN_VERSION,
+		PUBKEY_ALGO,
+		DIGEST_ALGO,
+		BAD_PUBKEY,
+		BAD_SECKEY,
+		BAD_SIGNATURE,
+		NO_PUBKEY,
+		CHECKSUM,
+		BAD_PASSPHRASE,
+		CIPHER_ALGO,
+		KEYRING_OPEN,
+		INV_PACKET,
+		INV_ARMOR,
+		NO_USER_ID,
+		NO_SECKEY,
+		WRONG_SECKEY,
+		BAD_KEY,
+		COMPR_ALGO,
+		NO_PRIME,
+		NO_ENCODING_METHOD,
+		NO_ENCRYPTION_SCHEME,
+		NO_SIGNATURE_SCHEME,
+		INV_ATTR,
+		NO_VALUE,
+		NOT_FOUND,
+		VALUE_NOT_FOUND,
+		SYNTAX,
+		BAD_MPI,
+		INV_PASSPHRASE,
+		SIG_CLASS,
+		RESOURCE_LIMIT,
+		INV_KEYRING,
+		TRUSTDB,
+		BAD_CERT,
+		INV_USER_ID,
+		UNEXPECTED,
+		TIME_CONFLICT,
+		KEYSERVER,
+		WRONG_PUBKEY_ALGO,
+		TRIBUTE_TO_D_A,
+		WEAK_KEY,
+		INV_KEYLEN,
+		INV_ARG,
+		BAD_URI,
+		INV_URI,
+		NETWORK,
+		UNKNOWN_HOST,
+		SELFTEST_FAILED,
+		NOT_ENCRYPTED,
+		NOT_PROCESSED,
+		UNUSABLE_PUBKEY,
+		UNUSABLE_SECKEY,
+		INV_VALUE,
+		BAD_CERT_CHAIN,
+		MISSING_CERT,
+		NO_DATA,
+		BUG,
+		NOT_SUPPORTED,
+		INV_OP,
+		TIMEOUT,
+		INTERNAL,
+		EOF_GCRYPT,
+		INV_OBJ,
+		TOO_SHORT,
+		TOO_LARGE,
+		NO_OBJ,
+		NOT_IMPLEMENTED,
+		CONFLICT,
+		INV_CIPHER_MODE,
+		INV_FLAG,
+		INV_HANDLE,
+		TRUNCATED,
+		INCOMPLETE_LINE,
+		INV_RESPONSE,
+		NO_AGENT,
+		AGENT,
+		INV_DATA,
+		ASSUAN_SERVER_FAULT,
+		ASSUAN,
+		INV_SESSION_KEY,
+		INV_SEXP,
+		UNSUPPORTED_ALGORITHM,
+		NO_PIN_ENTRY,
+		PIN_ENTRY,
+		BAD_PIN,
+		INV_NAME,
+		BAD_DATA,
+		INV_PARAMETER,
+		WRONG_CARD,
+		NO_DIRMNGR,
+		DIRMNGR,
+		CERT_REVOKED,
+		NO_CRL_KNOWN,
+		CRL_TOO_OLD,
+		LINE_TOO_LONG,
+		NOT_TRUSTED,
+		CANCELED,
+		BAD_CA_CERT,
+		CERT_EXPIRED,
+		CERT_TOO_YOUNG,
+		UNSUPPORTED_CERT,
+		UNKNOWN_SEXP,
+		UNSUPPORTED_PROTECTION,
+		CORRUPTED_PROTECTION,
+		AMBIGUOUS_NAME,
+		CARD,
+		CARD_RESET,
+		CARD_REMOVED,
+		INV_CARD,
+		CARD_NOT_PRESENT,
+		NO_PKCS15_APP,
+		NOT_CONFIRMED,
+		CONFIGURATION,
+		NO_POLICY_MATCH,
+		INV_INDEX,
+		INV_ID,
+		NO_SCDAEMON,
+		SCDAEMON,
+		UNSUPPORTED_PROTOCOL,
+		BAD_PIN_METHOD,
+		CARD_NOT_INITIALIZED,
+		UNSUPPORTED_OPERATION,
+		WRONG_KEY_USAGE,
+		NOTHING_FOUND,
+		WRONG_BLOB_TYPE,
+		MISSING_VALUE,
+		HARDWARE,
+		PIN_BLOCKED,
+		USE_CONDITIONS,
+		PIN_NOT_SYNCED,
+		INV_CRL,
+		BAD_BER,
+		INV_BER,
+		ELEMENT_NOT_FOUND,
+		IDENTIFIER_NOT_FOUND,
+		INV_TAG,
+		INV_LENGTH,
+		INV_KEYINFO,
+		UNEXPECTED_TAG,
+		NOT_DER_ENCODED,
+		NO_CMS_OBJ,
+		INV_CMS_OBJ,
+		UNKNOWN_CMS_OBJ,
+		UNSUPPORTED_CMS_OBJ,
+		UNSUPPORTED_ENCODING,
+		UNSUPPORTED_CMS_VERSION,
+		UNKNOWN_ALGORITHM,
+		INV_ENGINE,
+		PUBKEY_NOT_TRUSTED,
+		DECRYPT_FAILED,
+		KEY_EXPIRED,
+		SIG_EXPIRED,
+		ENCODING_PROBLEM,
+		INV_STATE,
+		DUP_VALUE,
+		MISSING_ACTION,
+		MODULE_NOT_FOUND,
+		INV_OID_STRING,
+		INV_TIME,
+		INV_CRL_OBJ,
+		UNSUPPORTED_CRL_VERSION,
+		INV_CERT_OBJ,
+		UNKNOWN_NAME,
+		LOCALE_PROBLEM,
+		NOT_LOCKED,
+		PROTOCOL_VIOLATION,
+		INV_MAC,
+		INV_REQUEST,
+		UNKNOWN_EXTN,
+		UNKNOWN_CRIT_EXTN,
+		LOCKED,
+		UNKNOWN_OPTION,
+		UNKNOWN_COMMAND,
+		BUFFER_TOO_SHORT,
+		SEXP_INV_LEN_SPEC,
+		SEXP_STRING_TOO_LONG,
+		SEXP_UNMATCHED_PAREN,
+		SEXP_NOT_CANONICAL,
+		SEXP_BAD_CHARACTER,
+		SEXP_BAD_QUOTATION,
+		SEXP_ZERO_PREFIX,
+		SEXP_NESTED_DH,
+		SEXP_UNMATCHED_DH,
+		SEXP_UNEXPECTED_PUNC,
+		SEXP_BAD_HEX_CHAR,
+		SEXP_ODD_HEX_NUMBERS,
+		SEXP_BAD_OCT_CHAR,
+		ASS_GENERAL,
+		ASS_ACCEPT_FAILED,
+		ASS_CONNECT_FAILED,
+		ASS_INV_RESPONSE,
+		ASS_INV_VALUE,
+		ASS_INCOMPLETE_LINE,
+		ASS_LINE_TOO_LONG,
+		ASS_NESTED_COMMANDS,
+		ASS_NO_DATA_CB,
+		ASS_NO_INQUIRE_CB,
+		ASS_NOT_A_SERVER,
+		ASS_NOT_A_CLIENT,
+		ASS_SERVER_START,
+		ASS_READ_ERROR,
+		ASS_WRITE_ERROR,
+		ASS_TOO_MUCH_DATA,
+		ASS_UNEXPECTED_CMD,
+		ASS_UNKNOWN_CMD,
+		ASS_SYNTAX,
+		ASS_CANCELED,
+		ASS_NO_INPUT,
+		ASS_NO_OUTPUT,
+		ASS_PARAMETER,
+		ASS_UNKNOWN_INQUIRE,
+		USER_1,
+		USER_2,
+		USER_3,
+		USER_4,
+		USER_5,
+		USER_6,
+		USER_7,
+		USER_8,
+		USER_9,
+		USER_10,
+		USER_11,
+		USER_12,
+		USER_13,
+		USER_14,
+		USER_15,
+		USER_16,
+		MISSING_ERRNO,
+		UNKNOWN_ERRNO,
+		EOF,
+
+		E2BIG,
+		EACCES,
+		EADDRINUSE,
+		EADDRNOTAVAIL,
+		EADV,
+		EAFNOSUPPORT,
+		EAGAIN,
+		EALREADY,
+		EAUTH,
+		EBACKGROUND,
+		EBADE,
+		EBADF,
+		EBADFD,
+		EBADMSG,
+		EBADR,
+		EBADRPC,
+		EBADRQC,
+		EBADSLT,
+		EBFONT,
+		EBUSY,
+		ECANCELED,
+		ECHILD,
+		ECHRNG,
+		ECOMM,
+		ECONNABORTED,
+		ECONNREFUSED,
+		ECONNRESET,
+		ED,
+		EDEADLK,
+		EDEADLOCK,
+		EDESTADDRREQ,
+		EDIED,
+		EDOM,
+		EDOTDOT,
+		EDQUOT,
+		EEXIST,
+		EFAULT,
+		EFBIG,
+		EFTYPE,
+		EGRATUITOUS,
+		EGREGIOUS,
+		EHOSTDOWN,
+		EHOSTUNREACH,
+		EIDRM,
+		EIEIO,
+		EILSEQ,
+		EINPROGRESS,
+		EINTR,
+		EINVAL,
+		EIO,
+		EISCONN,
+		EISDIR,
+		EISNAM,
+		EL2HLT,
+		EL2NSYNC,
+		EL3HLT,
+		EL3RST,
+		ELIBACC,
+		ELIBBAD,
+		ELIBEXEC,
+		ELIBMAX,
+		ELIBSCN,
+		ELNRNG,
+		ELOOP,
+		EMEDIUMTYPE,
+		EMFILE,
+		EMLINK,
+		EMSGSIZE,
+		EMULTIHOP,
+		ENAMETOOLONG,
+		ENAVAIL,
+		ENEEDAUTH,
+		ENETDOWN,
+		ENETRESET,
+		ENETUNREACH,
+		ENFILE,
+		ENOANO,
+		ENOBUFS,
+		ENOCSI,
+		ENODATA,
+		ENODEV,
+		ENOENT,
+		ENOEXEC,
+		ENOLCK,
+		ENOLINK,
+		ENOMEDIUM,
+		ENOMEM,
+		ENOMSG,
+		ENONET,
+		ENOPKG,
+		ENOPROTOOPT,
+		ENOSPC,
+		ENOSR,
+		ENOSTR,
+		ENOSYS,
+		ENOTBLK,
+		ENOTCONN,
+		ENOTDIR,
+		ENOTEMPTY,
+		ENOTNAM,
+		ENOTSOCK,
+		ENOTSUP,
+		ENOTTY,
+		ENOTUNIQ,
+		ENXIO,
+		EOPNOTSUPP,
+		EOVERFLOW,
+		EPERM,
+		EPFNOSUPPORT,
+		EPIPE,
+		EPROCLIM,
+		EPROCUNAVAIL,
+		EPROGMISMATCH,
+		EPROGUNAVAIL,
+		EPROTO,
+		EPROTONOSUPPORT,
+		EPROTOTYPE,
+		ERANGE,
+		EREMCHG,
+		EREMOTE,
+		EREMOTEIO,
+		ERESTART,
+		EROFS,
+		ERPCMISMATCH,
+		ESHUTDOWN,
+		ESOCKTNOSUPPORT,
+		ESPIPE,
+		ESRCH,
+		ESRMNT,
+		ESTALE,
+		ESTRPIPE,
+		ETIME,
+		ETIMEDOUT,
+		ETOOMANYREFS,
+		ETXTBSY,
+		EUCLEAN,
+		EUNATCH,
+		EUSERS,
+		EWOULDBLOCK,
+		EXDEV,
+		EXFULL,
+
+		/* This is one more than the largest allowed entry.  */
+		CODE_DIM
+	}
+
+	[CCode (cname = "gpg_err_code_t", cprefix = "gpg_err_")]
+	public struct Error : uint {
+		[CCode (cname = "gpg_err_make")]
+		public Error (ErrorSource source, ErrorCode code);
+		[CCode (cname = "gpg_err_make_from_errno")]
+		public Error.from_errno (ErrorSource source, int err);
+		public ErrorCode code { [CCode (cname = "gpg_err_code")] get; }
+		public ErrorSource source { [CCode (cname = "gpg_err_source")] get; }
+
+		[CCode (cname = "gpg_strerror")]
+		public unowned string to_string ();
+
+		[CCode (cname = "gpg_strsource")]
+		public unowned string source_to_string ();
+	}
+}
\ No newline at end of file
diff --git a/vapi/gpgme.deps b/gpgme-vala/vapi/gpgme.deps
index a0f4f82b..a0f4f82b 100644
--- a/vapi/gpgme.deps
+++ b/gpgme-vala/vapi/gpgme.deps
diff --git a/gpgme-vala/vapi/gpgme.vapi b/gpgme-vala/vapi/gpgme.vapi
new file mode 100644
index 00000000..8393dca4
--- /dev/null
+++ b/gpgme-vala/vapi/gpgme.vapi
@@ -0,0 +1,512 @@
+/* libgpgme.vapi
+ *
+ * Copyright (C) 2009 Sebastian Reichel <sre@ring0.de>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+[CCode (lower_case_cprefix = "gpgme_", cheader_filename = "gpgme.h")]
+namespace GPG {
+    [CCode (cheader_filename = "fix.h")]
+    public static GLib.RecMutex global_mutex;
+
+    [CCode (cname = "struct _gpgme_engine_info")]
+    public struct EngineInfo {
+        EngineInfo* next;
+        Protocol protocol;
+        string file_name;
+        string version;
+        string req_version;
+        string? home_dir;
+    }
+
+    [CCode (cname = "struct _gpgme_op_verify_result")]
+    public struct VerifyResult {
+        Signature* signatures;
+        string? file_name;
+    }
+
+    [CCode (cname = "struct _gpgme_op_sign_result")]
+    public struct SignResult {
+        InvalidKey invalid_signers;
+        Signature* signatures;
+    }
+
+    [CCode (cname = "struct _gpgme_op_encrypt_result")]
+    public struct EncryptResult {
+        InvalidKey invalid_signers;
+    }
+
+    [CCode (cname = "struct _gpgme_op_decrypt_result")]
+    public struct DecryptResult {
+        string unsupported_algorithm;
+        bool wrong_key_usage;
+        Recipient recipients;
+        string filename;
+    }
+
+    [CCode (cname = "struct _gpgme_recipient")]
+    public struct Recipient {
+        Recipient *next;
+        string keyid;
+        PublicKeyAlgorithm pubkey_algo;
+        GPGError.Error status;
+    }
+
+    [CCode (cname = "struct _gpgme_invalid_key")]
+    public struct InvalidKey {
+        InvalidKey *next;
+        string fpr;
+        GPGError.Error reason;
+    }
+
+    [CCode (cname = "struct _gpgme_signature")]
+    public struct Signature {
+        Signature *next;
+        Sigsum summary;
+        string fpr;
+        GPGError.Error status;
+        SigNotation notations;
+        ulong timestamp;
+        ulong exp_timestamp;
+        bool wrong_key_usage;
+        PKAStatus pka_trust;
+        bool chain_model;
+        Validity validity;
+        GPGError.Error validity_reason;
+        PublicKeyAlgorithm pubkey_algo;
+        HashAlgorithm hash_algo;
+        string? pka_adress;
+    }
+
+    public enum PKAStatus {
+        NOT_AVAILABLE,
+        BAD,
+        OKAY,
+        RFU
+    }
+
+    [CCode (cname = "gpgme_sigsum_t", cprefix = "GPGME_SIGSUM_")]
+    public enum Sigsum {
+        VALID,
+        GREEN,
+        RED,
+        KEY_REVOKED,
+        KEY_EXPIRED,
+        SIG_EXPIRED,
+        KEY_MISSING,
+        CRL_MISSING,
+        CRL_TOO_OLD,
+        BAD_POLICY,
+        SYS_ERROR
+    }
+
+    [CCode (cname = "gpgme_data_encoding_t", cprefix = "GPGME_DATA_ENCODING_")]
+    public enum DataEncoding {
+        NONE,
+        BINARY,
+        BASE64,
+        ARMOR,
+        URL,
+        URLESC,
+        URL0
+    }
+
+    [CCode (cname = "gpgme_hash_algo_t", cprefix = "GPGME_MD_")]
+    public enum HashAlgorithm {
+        NONE,
+        MD5,
+        SHA1,
+        RMD160,
+        MD2,
+        TIGER,
+        HAVAL,
+        SHA256,
+        SHA384,
+        SHA512,
+        MD4,
+        MD_CRC32,
+        MD_CRC32_RFC1510,
+        MD_CRC24_RFC2440
+    }
+
+    [CCode (cname = "gpgme_export_mode_t", cprefix = "GPGME_EXPORT_MODE_")]
+    public enum ExportMode {
+        EXTERN
+    }
+
+    [CCode (cprefix = "GPGME_AUDITLOG_")]
+    public enum AuditLogFlag {
+        HTML,
+        WITH_HELP
+    }
+
+    [CCode (cname = "gpgme_status_code_t", cprefix = "GPGME_STATUS_")]
+    public enum StatusCode {
+        EOF,
+        ENTER,
+        LEAVE,
+        ABORT,
+        GOODSIG,
+        BADSIG,
+        ERRSIG,
+        BADARMOR,
+        RSA_OR_IDEA,
+        KEYEXPIRED,
+        KEYREVOKED,
+        TRUST_UNDEFINED,
+        TRUST_NEVER,
+        TRUST_MARGINAL,
+        TRUST_FULLY,
+        TRUST_ULTIMATE,
+        SHM_INFO,
+        SHM_GET,
+        SHM_GET_BOOL,
+        SHM_GET_HIDDEN,
+        NEED_PASSPHRASE,
+        VALIDSIG,
+        SIG_ID,
+        SIG_TO,
+        ENC_TO,
+        NODATA,
+        BAD_PASSPHRASE,
+        NO_PUBKEY,
+        NO_SECKEY,
+        NEED_PASSPHRASE_SYM,
+        DECRYPTION_FAILED,
+        DECRYPTION_OKAY,
+        MISSING_PASSPHRASE,
+        GOOD_PASSPHRASE,
+        GOODMDC,
+        BADMDC,
+        ERRMDC,
+        IMPORTED,
+        IMPORT_OK,
+        IMPORT_PROBLEM,
+        IMPORT_RES,
+        FILE_START,
+        FILE_DONE,
+        FILE_ERROR,
+        BEGIN_DECRYPTION,
+        END_DECRYPTION,
+        BEGIN_ENCRYPTION,
+        END_ENCRYPTION,
+        DELETE_PROBLEM,
+        GET_BOOL,
+        GET_LINE,
+        GET_HIDDEN,
+        GOT_IT,
+        PROGRESS,
+        SIG_CREATED,
+        SESSION_KEY,
+        NOTATION_NAME,
+        NOTATION_DATA,
+        POLICY_URL,
+        BEGIN_STREAM,
+        END_STREAM,
+        KEY_CREATED,
+        USERID_HINT,
+        UNEXPECTED,
+        INV_RECP,
+        NO_RECP,
+        ALREADY_SIGNED,
+        SIGEXPIRED,
+        EXPSIG,
+        EXPKEYSIG,
+        TRUNCATED,
+        ERROR,
+        NEWSIG,
+        REVKEYSIG,
+        SIG_SUBPACKET,
+        NEED_PASSPHRASE_PIN,
+        SC_OP_FAILURE,
+        SC_OP_SUCCESS,
+        CARDCTRL,
+        BACKUP_KEY_CREATED,
+        PKA_TRUST_BAD,
+        PKA_TRUST_GOOD,
+        PLAINTEXT
+    }
+
+    [Flags]
+    [CCode (cname="unsigned int")]
+    public enum ImportStatusFlags {
+        [CCode (cname = "GPGME_IMPORT_NEW")]
+        NEW,
+        [CCode (cname = "GPGME_IMPORT_UID")]
+        UID,
+        [CCode (cname = "GPGME_IMPORT_SIG")]
+        SIG,
+        [CCode (cname = "GPGME_IMPORT_SUBKEY")]
+        SUBKEY,
+        [CCode (cname = "GPGME_IMPORT_SECRET")]
+        SECRET
+    }
+
+    [Compact]
+    [CCode (cname = "struct gpgme_context", free_function = "gpgme_release", cprefix = "gpgme_")]
+    public class Context {
+        private static GPGError.Error new(out Context ctx);
+
+        public static Context create() throws GLib.Error {
+            Context ctx;
+            @new(out ctx);
+            return ctx;
+        }
+
+        public GPGError.Error set_protocol(Protocol p);
+        public Protocol get_protocol();
+
+        public void set_armor(bool yes);
+        public bool get_armor();
+
+        public void set_textmode(bool yes);
+        public bool get_textmode();
+
+        public GPGError.Error set_keylist_mode(KeylistMode mode);
+        public KeylistMode get_keylist_mode();
+
+        public void set_include_certs(int nr_of_certs = -256);
+
+        public int get_include_certs();
+
+        public void set_passphrase_cb(passphrase_callback cb, void* hook_value = null);
+
+        public void get_passphrase_cb(out passphrase_callback cb, out void* hook_value);
+
+        public GPGError.Error set_locale(int category, string val);
+
+        [CCode (cname = "gpgme_ctx_get_engine_info")]
+        public EngineInfo* get_engine_info();
+
+        [CCode (cname = "gpgme_ctx_set_engine_info")]
+        public GPGError.Error set_engine_info(Protocol proto, string file_name, string home_dir);
+
+        public void signers_clear();
+
+        public GPGError.Error signers_add(Key key);
+
+        public Key* signers_enum(int n);
+
+        public void sig_notation_clear();
+        
+        public GPGError.Error sig_notation_add(string name, string val, SigNotationFlags flags);
+
+        public SigNotation* sig_notation_get();
+        
+        [CCode (cname = "gpgme_get_key")]
+        private GPGError.Error get_key_(string fpr, out Key key, bool secret);
+
+        [CCode (cname = "gpgme_get_key_")]
+        public Key get_key(string fpr, bool secret) throws GLib.Error {
+            Key key;
+            throw_if_error(get_key_(fpr, out key, secret));
+            return key;
+        }
+        
+        public Context* wait(out GPGError.Error status, bool hang);
+
+        public SignResult* op_sign_result();
+
+        [CCode (cname = "gpgme_op_sign")]
+        public GPGError.Error op_sign_(Data plain, Data sig, SigMode mode);
+
+        [CCode (cname = "gpgme_op_sign_")]
+        public Data op_sign(Data plain, SigMode mode) throws GLib.Error {
+            Data sig = Data.create();
+            throw_if_error(op_sign_(plain, sig, mode));
+            return sig;
+        }
+
+        public VerifyResult* op_verify_result();
+
+        [CCode (cname = "gpgme_op_verify")]
+        public GPGError.Error op_verify_(Data sig, Data signed_text, Data? plaintext);
+
+        [CCode (cname = "gpgme_op_verify_")]
+        public Data op_verify(Data sig, Data signed_text) throws GLib.Error {
+            Data plaintext = Data.create();
+            throw_if_error(op_verify_(sig, signed_text, plaintext));
+            return plaintext;
+        }
+
+        public EncryptResult* op_encrypt_result();
+
+        [CCode (cname = "gpgme_op_encrypt")]
+        public GPGError.Error op_encrypt_([CCode (array_length = false)] Key[] recp, EncryptFlags flags, Data plain, Data cipher);
+
+        [CCode (cname = "gpgme_op_encrypt_")]
+        public Data op_encrypt(Key[] recp, EncryptFlags flags, Data plain) throws GLib.Error {
+            Data cipher = Data.create();
+            throw_if_error(op_encrypt_(recp, flags, plain, cipher));
+            return cipher;
+        }
+
+        public DecryptResult* op_decrypt_result();
+
+        [CCode (cname = "gpgme_op_decrypt")]
+        public GPGError.Error op_decrypt_(Data cipher, Data plain);
+
+        [CCode (cname = "gpgme_op_decrypt_")]
+        public Data op_decrypt(Data cipher) throws GLib.Error {
+            Data plain = Data.create();
+            throw_if_error(op_decrypt_(cipher, plain));
+            return plain;
+        }
+
+        public GPGError.Error op_export(string? pattern, ExportMode mode, Data keydata);
+
+        public GPGError.Error op_import(Data keydata);
+
+        public unowned ImportResult op_import_result();
+
+        [CCode (cname = "gpgme_op_keylist_start")]
+        private GPGError.Error op_keylist_start_(string? pattern = null, int secret_only = 0);
+
+        [CCode (cname = "gpgme_op_keylist_start_")]
+        public void op_keylist_start(string? pattern = null, int secret_only = 0) throws GLib.Error {
+            throw_if_error(op_keylist_start_(pattern, secret_only));
+        }
+
+        [CCode (cname = "gpgme_op_keylist_next")]
+        private GPGError.Error op_keylist_next_(out Key key);
+
+        [CCode (cname = "gpgme_op_keylist_next_")]
+        public Key op_keylist_next() throws GLib.Error {
+            Key key;
+            throw_if_error(op_keylist_next_(out key));
+            return key;
+        }
+
+        [CCode (cname = "gpgme_op_keylist_end")]
+        private GPGError.Error op_keylist_end_();
+
+        [CCode (cname = "gpgme_op_keylist_end_")]
+        public void op_keylist_end() throws GLib.Error {
+            throw_if_error(op_keylist_end_());
+        }
+
+        public KeylistResult op_keylist_result();
+    }
+
+    [Compact]
+    [CCode (cname = "struct _gpgme_import_status")]
+    public class ImportStatus {
+        
+        public ImportStatus? next;
+        public string fpr;
+        public GPGError.Error result;
+        public ImportStatusFlags status;
+    }
+
+    [Compact]
+    [CCode (cname = "struct _gpgme_op_import_result")]
+    public class ImportResult {
+        public int considered;
+        public int no_user_id;
+        public int imported;
+        public int imported_rsa;
+        public int unchanged;
+        public int new_user_ids;
+        public int new_sub_keys;
+        public int new_signatures;
+        public int new_revocations;
+        public int secret_read;
+        public int secret_imported;
+        public int secret_unchanged;
+        public int not_imported;
+        public ImportStatus imports;
+    }
+
+    [Compact]
+    [CCode (cname = "struct _gpgme_op_keylist_result")]
+    public class KeylistResult {
+        uint truncated;
+    }
+
+    [Compact]
+    [CCode (cname = "struct gpgme_data", free_function = "gpgme_data_release", cprefix = "gpgme_data_")]
+    public class Data {
+        
+        public static GPGError.Error new(out Data d);
+
+        public static Data create() throws GLib.Error {
+            Data data;
+            throw_if_error(@new(out data));
+            return data;
+        }
+
+        
+        [CCode (cname = "gpgme_data_new_from_mem")]
+        public static GPGError.Error new_from_memory(out Data d, uint8[] buffer, bool copy);
+
+        public static Data create_from_memory(uint8[] buffer, bool copy) throws GLib.Error {
+            Data data;
+            throw_if_error(new_from_memory(out data, buffer, copy));
+            return data;
+        }
+
+        [CCode (cname = "gpgme_data_new_from_file")]
+        public static GPGError.Error create_from_file(out Data d, string filename, int copy = 1);
+
+        [CCode (cname = "gpgme_data_release_and_get_mem")]
+        public string release_and_get_mem(out size_t len);
+
+        public ssize_t read(uint8[] buf);
+
+        public ssize_t write(uint8[] buf);
+
+        public long seek(long offset, int whence=0);
+
+        public DataEncoding *get_encoding();
+
+        public GPGError.Error set_encoding(DataEncoding enc);
+    }
+
+    [CCode (cname = "gpgme_get_protocol_name")]
+    public unowned string get_protocol_name(Protocol p);
+
+    [CCode (cname = "gpgme_pubkey_algo_name")]
+    public unowned string get_public_key_algorithm_name(PublicKeyAlgorithm algo);
+
+    [CCode (cname = "gpgme_hash_algo_name")]
+    public unowned string get_hash_algorithm_name(HashAlgorithm algo);
+
+    [CCode (cname = "gpgme_passphrase_cb_t", has_target = false)]
+    public delegate GPGError.Error passphrase_callback(void* hook, string uid_hint, string passphrase_info, bool prev_was_bad, int fd);
+
+    [CCode (cname = "gpgme_engine_check_version")]
+    public GPGError.Error engine_check_version(Protocol proto);
+
+    [CCode (cname = "gpgme_get_engine_information")]
+    public GPGError.Error get_engine_information(out EngineInfo engine_info);
+
+    [CCode (cname = "gpgme_strerror_r")]
+    public int strerror_r(GPGError.Error err, uint8[] buf);
+
+    [CCode (cname = "gpgme_strerror")]
+    public unowned string strerror(GPGError.Error err);
+
+    private void throw_if_error(GPGError.Error error) throws GLib.Error {
+        if (error.code != GPGError.ErrorCode.NO_ERROR) {
+            throw new GLib.Error(-1, error.code, error.to_string());
+        }
+    }
+}
diff --git a/gpgme-vala/vapi/gpgme_public.vapi b/gpgme-vala/vapi/gpgme_public.vapi
new file mode 100644
index 00000000..86963025
--- /dev/null
+++ b/gpgme-vala/vapi/gpgme_public.vapi
@@ -0,0 +1,160 @@
+[CCode (lower_case_cprefix = "gpgme_", cheader_filename = "gpgme.h")]
+namespace GPG {
+
+[CCode (cname = "gpgme_check_version")]
+public unowned string check_version(string? required_version = null);
+
+[Compact]
+[CCode (cname = "struct _gpgme_key", ref_function = "gpgme_key_ref", ref_function_void = true, unref_function = "gpgme_key_unref", free_function = "gpgme_key_release")]
+public class Key {
+    public bool revoked;
+    public bool expired;
+    public bool disabled;
+    public bool invalid;
+    public bool can_encrypt;
+    public bool can_sign;
+    public bool can_certify;
+    public bool secret;
+    public bool can_authenticate;
+    public bool is_qualified;
+    public Protocol protocol;
+    public string issuer_serial;
+    public string issuer_name;
+    public string issuer_id;
+    public Validity owner_trust;
+    [CCode(array_null_terminated = true)]
+    public SubKey[] subkeys;
+    [CCode(array_null_terminated = true)]
+    public UserID[] uids;
+    public KeylistMode keylist_mode;
+}
+
+[CCode (cname = "struct _gpgme_user_id")]
+public struct UserID {
+    UserID* next;
+
+    bool revoked;
+    bool invalid;
+    Validity validity;
+    string uid;
+    string name;
+    string email;
+    string comment;
+    KeySig signatures;
+}
+
+[CCode (cname = "struct _gpgme_key_sig")]
+public struct KeySig {
+    KeySig* next;
+    bool invoked;
+    bool expired;
+    bool invalid;
+    bool exportable;
+    PublicKeyAlgorithm algo;
+    string keyid;
+    long timestamp;
+    long expires;
+//    GPGError.Error status;
+    string uid;
+    string name;
+    string email;
+    string comment;
+    uint sig_class;
+    SigNotation notations;
+}
+
+[CCode (cname = "struct _gpgme_subkey")]
+public struct SubKey {
+    SubKey* next;
+    bool revoked;
+    bool expired;
+    bool disabled;
+    bool invalid;
+    bool can_encrypt;
+    bool can_sign;
+    bool can_certify;
+    bool secret;
+    bool can_authenticate;
+    bool is_qualified;
+    bool is_cardkey;
+    PublicKeyAlgorithm algo;
+    uint length;
+    string keyid;
+
+    string fpr;
+    long timestamp;
+    long expires;
+    string? cardnumber;
+}
+
+[CCode (cname = "struct _gpgme_sig_notation")]
+public struct SigNotation {
+    SigNotation* next;
+    string? name;
+    string value;
+    int name_len;
+    int value_len;
+    SigNotationFlags flags;
+    bool human_readable;
+    bool critical;
+}
+
+[CCode (cname = "gpgme_sig_notation_flags_t", cprefix = "GPGME_SIG_NOTATION_")]
+public enum SigNotationFlags {
+    HUMAN_READABLE,
+    CRITICAL
+}
+
+[CCode (cname = "gpgme_sig_mode_t", cprefix = "GPGME_SIG_MODE_")]
+public enum SigMode {
+    NORMAL,
+    DETACH,
+    CLEAR
+}
+
+[CCode (cname = "gpgme_encrypt_flags_t", cprefix = "GPGME_ENCRYPT_")]
+public enum EncryptFlags {
+    ALWAYS_TRUST,
+    NO_ENCRYPT_TO
+}
+
+[CCode (cname = "gpgme_pubkey_algo_t", cprefix = "GPGME_PK_")]
+public enum PublicKeyAlgorithm {
+    RSA,
+    RSA_E,
+    RSA_S,
+    ELG_E,
+    DSA,
+    ELG
+}
+
+[CCode (cname = "gpgme_protocol_t", cprefix = "GPGME_PROTOCOL_")]
+public enum Protocol {
+    OpenPGP,
+    CMS,
+    GPGCONF,
+    ASSUAN,
+    UNKNOWN
+}
+
+[CCode (cname = "gpgme_keylist_mode_t", cprefix = "GPGME_KEYLIST_MODE_")]
+public enum KeylistMode {
+    LOCAL,
+    EXTERN,
+    SIGS,
+    SIG_NOTATIONS,
+    EPHEMERAL,
+    VALIDATE
+}
+
+[CCode (cname = "gpgme_validity_t", cprefix = "GPGME_VALIDITY_")]
+public enum Validity {
+    UNKNOWN,
+    UNDEFINED,
+    NEVER,
+    MARGINAL,
+    FULL,
+    ULTIMATE
+}
+
+}
\ No newline at end of file
diff --git a/vapi/gpg-error.vapi b/vapi/gpg-error.vapi
deleted file mode 100644
index e7808f5e..00000000
--- a/vapi/gpg-error.vapi
+++ /dev/null
@@ -1,407 +0,0 @@
-/* gpg-error.vapi
- *
- * Copyright (C) 2009 Sebastian Reichel <sre@ring0.de>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- */
-
-[CCode (cheader_filename = "gpg-error.h")]
-namespace GPGError {
-
-    [CCode (cname = "gpg_err_code_t", cprefix = "GPG_ERR_")]
-    public enum ErrorCode {
-        NO_ERROR,
-        GENERAL,
-        UNKNOWN_PACKET,
-        UNKNOWN_VERSION,
-        PUBKEY_ALGO,
-        DIGEST_ALGO,
-        BAD_PUBKEY,
-        BAD_SECKEY,
-        BAD_SIGNATURE,
-        NO_PUBKEY,
-        CHECKSUM,
-        BAD_PASSPHRASE,
-        CIPHER_ALGO,
-        KEYRING_OPEN,
-        INV_PACKET,
-        INV_ARMOR,
-        NO_USER_ID,
-        NO_SECKEY,
-        WRONG_SECKEY,
-        BAD_KEY,
-        COMPR_ALGO,
-        NO_PRIME,
-        NO_ENCODING_METHOD,
-        NO_ENCRYPTION_SCHEME,
-        NO_SIGNATURE_SCHEME,
-        INV_ATTR,
-        NO_VALUE,
-        NOT_FOUND,
-        VALUE_NOT_FOUND,
-        SYNTAX,
-        BAD_MPI,
-        INV_PASSPHRASE,
-        SIG_CLASS,
-        RESOURCE_LIMIT,
-        INV_KEYRING,
-        TRUSTDB,
-        BAD_CERT,
-        INV_USER_ID,
-        UNEXPECTED,
-        TIME_CONFLICT,
-        KEYSERVER,
-        WRONG_PUBKEY_ALGO,
-        TRIBUTE_TO_D_A,
-        WEAK_KEY,
-        INV_KEYLEN,
-        INV_ARG,
-        BAD_URI,
-        INV_URI,
-        NETWORK,
-        UNKNOWN_HOST,
-        SELFTEST_FAILED,
-        NOT_ENCRYPTED,
-        NOT_PROCESSED,
-        UNUSABLE_PUBKEY,
-        UNUSABLE_SECKEY,
-        INV_VALUE,
-        BAD_CERT_CHAIN,
-        MISSING_CERT,
-        NO_DATA,
-        BUG,
-        NOT_SUPPORTED,
-        INV_OP,
-        TIMEOUT,
-        INTERNAL,
-        EOF_GCRYPT,
-        INV_OBJ,
-        TOO_SHORT,
-        TOO_LARGE,
-        NO_OBJ,
-        NOT_IMPLEMENTED,
-        CONFLICT,
-        INV_CIPHER_MODE,
-        INV_FLAG,
-        INV_HANDLE,
-        TRUNCATED,
-        INCOMPLETE_LINE,
-        INV_RESPONSE,
-        NO_AGENT,
-        AGENT,
-        INV_DATA,
-        ASSUAN_SERVER_FAULT,
-        ASSUAN,
-        INV_SESSION_KEY,
-        INV_SEXP,
-        UNSUPPORTED_ALGORITHM,
-        NO_PIN_ENTRY,
-        PIN_ENTRY,
-        BAD_PIN,
-        INV_NAME,
-        BAD_DATA,
-        INV_PARAMETER,
-        WRONG_CARD,
-        NO_DIRMNGR,
-        DIRMNGR,
-        CERT_REVOKED,
-        NO_CRL_KNOWN,
-        CRL_TOO_OLD,
-        LINE_TOO_LONG,
-        NOT_TRUSTED,
-        CANCELED,
-        BAD_CA_CERT,
-        CERT_EXPIRED,
-        CERT_TOO_YOUNG,
-        UNSUPPORTED_CERT,
-        UNKNOWN_SEXP,
-        UNSUPPORTED_PROTECTION,
-        CORRUPTED_PROTECTION,
-        AMBIGUOUS_NAME,
-        CARD,
-        CARD_RESET,
-        CARD_REMOVED,
-        INV_CARD,
-        CARD_NOT_PRESENT,
-        NO_PKCS15_APP,
-        NOT_CONFIRMED,
-        CONFIGURATION,
-        NO_POLICY_MATCH,
-        INV_INDEX,
-        INV_ID,
-        NO_SCDAEMON,
-        SCDAEMON,
-        UNSUPPORTED_PROTOCOL,
-        BAD_PIN_METHOD,
-        CARD_NOT_INITIALIZED,
-        UNSUPPORTED_OPERATION,
-        WRONG_KEY_USAGE,
-        NOTHING_FOUND,
-        WRONG_BLOB_TYPE,
-        MISSING_VALUE,
-        HARDWARE,
-        PIN_BLOCKED,
-        USE_CONDITIONS,
-        PIN_NOT_SYNCED,
-        INV_CRL,
-        BAD_BER,
-        INV_BER,
-        ELEMENT_NOT_FOUND,
-        IDENTIFIER_NOT_FOUND,
-        INV_TAG,
-        INV_LENGTH,
-        INV_KEYINFO,
-        UNEXPECTED_TAG,
-        NOT_DER_ENCODED,
-        NO_CMS_OBJ,
-        INV_CMS_OBJ,
-        UNKNOWN_CMS_OBJ,
-        UNSUPPORTED_CMS_OBJ,
-        UNSUPPORTED_ENCODING,
-        UNSUPPORTED_CMS_VERSION,
-        UNKNOWN_ALGORITHM,
-        INV_ENGINE,
-        PUBKEY_NOT_TRUSTED,
-        DECRYPT_FAILED,
-        KEY_EXPIRED,
-        SIG_EXPIRED,
-        ENCODING_PROBLEM,
-        INV_STATE,
-        DUP_VALUE,
-        MISSING_ACTION,
-        MODULE_NOT_FOUND,
-        INV_OID_STRING,
-        INV_TIME,
-        INV_CRL_OBJ,
-        UNSUPPORTED_CRL_VERSION,
-        INV_CERT_OBJ,
-        UNKNOWN_NAME,
-        LOCALE_PROBLEM,
-        NOT_LOCKED,
-        PROTOCOL_VIOLATION,
-        INV_MAC,
-        INV_REQUEST,
-        UNKNOWN_EXTN,
-        UNKNOWN_CRIT_EXTN,
-        LOCKED,
-        UNKNOWN_OPTION,
-        UNKNOWN_COMMAND,
-        UNFINISHED,
-        BUFFER_TOO_SHORT,
-        SEXP_INV_LEN_SPEC,
-        SEXP_STRING_TOO_LONG,
-        SEXP_UNMATCHED_PAREN,
-        SEXP_NOT_CANONICAL,
-        SEXP_BAD_CHARACTER,
-        SEXP_BAD_QUOTATION,
-        SEXP_ZERO_PREFIX,
-        SEXP_NESTED_DH,
-        SEXP_UNMATCHED_DH,
-        SEXP_UNEXPECTED_PUNC,
-        SEXP_BAD_HEX_CHAR,
-        SEXP_ODD_HEX_NUMBERS,
-        SEXP_BAD_OCT_CHAR,
-        ASS_GENERAL,
-        ASS_ACCEPT_FAILED,
-        ASS_CONNECT_FAILED,
-        ASS_INV_RESPONSE,
-        ASS_INV_VALUE,
-        ASS_INCOMPLETE_LINE,
-        ASS_LINE_TOO_LONG,
-        ASS_NESTED_COMMANDS,
-        ASS_NO_DATA_CB,
-        ASS_NO_INQUIRE_CB,
-        ASS_NOT_A_SERVER,
-        ASS_NOT_A_CLIENT,
-        ASS_SERVER_START,
-        ASS_READ_ERROR,
-        ASS_WRITE_ERROR,
-        ASS_TOO_MUCH_DATA,
-        ASS_UNEXPECTED_CMD,
-        ASS_UNKNOWN_CMD,
-        ASS_SYNTAX,
-        ASS_CANCELED,
-        ASS_NO_INPUT,
-        ASS_NO_OUTPUT,
-        ASS_PARAMETER,
-        ASS_UNKNOWN_INQUIRE,
-        USER_1,
-        USER_2,
-        USER_3,
-        USER_4,
-        USER_5,
-        USER_6,
-        USER_7,
-        USER_8,
-        USER_9,
-        USER_10,
-        USER_11,
-        USER_12,
-        USER_13,
-        USER_14,
-        USER_15,
-        USER_16,
-        MISSING_ERRNO,
-        UNKNOWN_ERRNO,
-        EOF,
-        E2BIG,
-        EACCES,
-        EADDRINUSE,
-        EADDRNOTAVAIL,
-        EADV,
-        EAFNOSUPPORT,
-        EAGAIN,
-        EALREADY,
-        EAUTH,
-        EBACKGROUND,
-        EBADE,
-        EBADF,
-        EBADFD,
-        EBADMSG,
-        EBADR,
-        EBADRPC,
-        EBADRQC,
-        EBADSLT,
-        EBFONT,
-        EBUSY,
-        ECANCELED,
-        ECHILD,
-        ECHRNG,
-        ECOMM,
-        ECONNABORTED,
-        ECONNREFUSED,
-        ECONNRESET,
-        ED,
-        EDEADLK,
-        EDEADLOCK,
-        EDESTADDRREQ,
-        EDIED,
-        EDOM,
-        EDOTDOT,
-        EDQUOT,
-        EEXIST,
-        EFAULT,
-        EFBIG,
-        EFTYPE,
-        EGRATUITOUS,
-        EGREGIOUS,
-        EHOSTDOWN,
-        EHOSTUNREACH,
-        EIDRM,
-        EIEIO,
-        EILSEQ,
-        EINPROGRESS,
-        EINTR,
-        EINVAL,
-        EIO,
-        EISCONN,
-        EISDIR,
-        EISNAM,
-        EL2HLT,
-        EL2NSYNC,
-        EL3HLT,
-        EL3RST,
-        ELIBACC,
-        ELIBBAD,
-        ELIBEXEC,
-        ELIBMAX,
-        ELIBSCN,
-        ELNRNG,
-        ELOOP,
-        EMEDIUMTYPE,
-        EMFILE,
-        EMLINK,
-        EMSGSIZE,
-        EMULTIHOP,
-        ENAMETOOLONG,
-        ENAVAIL,
-        ENEEDAUTH,
-        ENETDOWN,
-        ENETRESET,
-        ENETUNREACH,
-        ENFILE,
-        ENOANO,
-        ENOBUFS,
-        ENOCSI,
-        ENODATA,
-        ENODEV,
-        ENOENT,
-        ENOEXEC,
-        ENOLCK,
-        ENOLINK,
-        ENOMEDIUM,
-        ENOMEM,
-        ENOMSG,
-        ENONET,
-        ENOPKG,
-        ENOPROTOOPT,
-        ENOSPC,
-        ENOSR,
-        ENOSTR,
-        ENOSYS,
-        ENOTBLK,
-        ENOTCONN,
-        ENOTDIR,
-        ENOTEMPTY,
-        ENOTNAM,
-        ENOTSOCK,
-        ENOTSUP,
-        ENOTTY,
-        ENOTUNIQ,
-        ENXIO,
-        EOPNOTSUPP,
-        EOVERFLOW,
-        EPERM,
-        EPFNOSUPPORT,
-        EPIPE,
-        EPROCLIM,
-        EPROCUNAVAIL,
-        EPROGMISMATCH,
-        EPROGUNAVAIL,
-        EPROTO,
-        EPROTONOSUPPORT,
-        EPROTOTYPE,
-        ERANGE,
-        EREMCHG,
-        EREMOTE,
-        EREMOTEIO,
-        ERESTART,
-        EROFS,
-        ERPCMISMATCH,
-        ESHUTDOWN,
-        ESOCKTNOSUPPORT,
-        ESPIPE,
-        ESRCH,
-        ESRMNT,
-        ESTALE,
-        ESTRPIPE,
-        ETIME,
-        ETIMEDOUT,
-        ETOOMANYREFS,
-        ETXTBSY,
-        EUCLEAN,
-        EUNATCH,
-        EUSERS,
-        EWOULDBLOCK,
-        EXDEV,
-        EXFULL,
-        CODE_DIM
-    }
-}
diff --git a/vapi/gpgme.vapi b/vapi/gpgme.vapi
deleted file mode 100644
index 49fd2d78..00000000
--- a/vapi/gpgme.vapi
+++ /dev/null
@@ -1,1224 +0,0 @@
-/* libgpgme.vapi
- *
- * Copyright (C) 2009 Sebastian Reichel <sre@ring0.de>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *
- */
-
-/**
- * GPGME is an API wrapper around GnuPG, which parses the output of GnuPG.
- */
-[CCode (lower_case_cprefix = "gpgme_", cheader_filename = "gpgme.h")]
-namespace GPG {
-    /**
-     * EngineInfo as List
-     */
-    [CCode (cname = "struct _gpgme_engine_info")]
-    public struct EngineInfo {
-        /**
-         * Next entry in the list
-         */
-        EngineInfo* next;
-
-        /**
-         * The protocol ID
-         */
-        Protocol protocol;
-
-        /**
-         * filename of the engine binary
-         */
-        string file_name;
-
-        /**
-         * version string of the installed binary
-         */
-        string version;
-
-        /**
-         * minimum version required for gpgme
-         */
-        string req_version;
-
-        /**
-         * home directory to be used or null for default
-         */
-        string? home_dir;
-    }
-
-    /**
-     * A Key from the Keyring
-     */
-    [CCode (cname = "struct _gpgme_key", ref_function = "gpgme_key_ref", ref_function_void = true, unref_function = "gpgme_key_unref", free_function = "gpgme_key_release")]
-    public class Key {
-        public bool revoked;
-        public bool expired;
-        public bool disabled;
-        public bool invalid;
-        public bool can_encrypt;
-        public bool can_sign;
-        public bool can_certify;
-        public bool secret;
-        public bool can_authenticate;
-        public bool is_qualified;
-        public Protocol protocol;
-
-        /**
-         * If protocol is CMS, this string contains the issuer's serial
-         */
-        public string issuer_serial;
-
-        /**
-         * If protocol is CMS, this string contains the issuer's name
-         */
-        public string issuer_name;
-
-        /**
-         * If protocol is CMS, this string contains the issuer's ID
-         */
-        public string issuer_id;
-
-        /**
-         * If protocol is OpenPGP, this field contains the owner trust level
-         */
-        public Validity owner_trust;
-
-        /**
-         * The key's subkeys
-         */
-        [CCode(array_null_terminated = true)]
-        public SubKey[] subkeys;
-
-        /**
-         * The key's user ids
-         */
-        [CCode(array_null_terminated = true)]
-        public UserID[] uids;
-
-        public KeylistMode keylist_mode;
-    }
-
-    /**
-     * A signature notation
-     */
-    [CCode (cname = "struct _gpgme_sig_notation")]
-    public struct SigNotation {
-        /**
-         * The next SigNotation from the list
-         */
-        SigNotation* next;
-
-        /**
-         * If name is a null pointer value contains a policy url rather than a notation
-         */
-        string? name;
-
-        /**
-         * The value of the notation data
-         */
-        string value;
-
-        /**
-         * The length of the name of the notation data
-         */
-        int name_len;
-
-        /**
-         * The length of the value of the notation data
-         */
-        int value_len;
-
-        /**
-         * The accumulated flags
-         */
-        SigNotationFlags flags;
-
-        /**
-         * notation data is human readable
-         */
-        bool human_readable;
-
-        /**
-         * notation data is critical
-         */
-        bool critical;
-    }
-
-    /**
-     * A subkey from a Key
-     */
-    [CCode (cname = "struct _gpgme_subkey")]
-    public struct SubKey {
-        SubKey* next;
-        bool revoked;
-        bool expired;
-        bool disabled;
-        bool invalid;
-        bool can_encrypt;
-        bool can_sign;
-        bool can_certify;
-        bool secret;
-        bool can_authenticate;
-        bool is_qualified;
-        bool is_cardkey;
-        PublicKeyAlgorithm algo;
-        uint length;
-        string keyid;
-
-        /**
-         * Fingerprint of the key in hex form
-         */
-        string fpr;
-
-        /**
-         * The creation timestamp.
-         * -1 = invalid,
-         * 0 = not available
-         */
-        long timestamp;
-
-        /**
-         * The expiration timestamp.
-         * 0 = key does not expire
-         */
-        long expires;
-
-        /**
-         * The serial number of the smartcard holding this key or null
-         */
-        string? cardnumber;
-    }
-
-    /**
-     * A signature on a UserID
-     */
-    [CCode (cname = "struct _gpgme_key_sig")]
-    public struct KeySig {
-        /**
-         * The next signature from the list
-         */
-        KeySig* next;
-        bool invoked;
-        bool expired;
-        bool invalid;
-        bool exportable;
-        PublicKeyAlgorithm algo;
-        string keyid;
-
-        /**
-         * The creation timestamp.
-         * -1 = invalid,
-         * 0 = not available
-         */
-        long timestamp;
-
-        /**
-         * The expiration timestamp.
-         * 0 = key does not expire
-         */
-        long expires;
-
-        GPGError.ErrorCode status;
-
-        string uid;
-        string name;
-        string email;
-        string comment;
-
-        /**
-         * Crypto backend specific signature class
-         */
-        uint sig_class;
-
-        SigNotation notations;
-    }
-
-    /**
-     * A UserID from a Key
-     */
-    [CCode (cname = "struct _gpgme_user_id")]
-    public struct UserID {
-        /**
-         * The next UserID from the list
-         */
-        UserID* next;
-
-        bool revoked;
-        bool invalid;
-        Validity validity;
-        string uid;
-        string name;
-        string email;
-        string comment;
-
-        KeySig signatures;
-    }
-
-    /**
-     * verify result of OP
-     */
-    [CCode (cname = "struct _gpgme_op_verify_result")]
-    public struct VerifyResult {
-        Signature* signatures;
-
-        /**
-         * The original file name of the plaintext message, if available
-         */
-        string? file_name;
-    }
-
-    /**
-     * sign result of OP
-     */
-    [CCode (cname = "struct _gpgme_op_sign_result")]
-    public struct SignResult {
-        InvalidKey invalid_signers;
-        Signature* signatures;
-    }
-
-    /**
-     * encrypt result of OP
-     */
-    [CCode (cname = "struct _gpgme_op_encrypt_result")]
-    public struct EncryptResult {
-        /**
-         * The list of invalid repipients
-         */
-        InvalidKey invalid_signers;
-    }
-
-    /**
-     * decrypt result of OP
-     */
-    [CCode (cname = "struct _gpgme_op_decrypt_result")]
-    public struct DecryptResult {
-        string unsupported_algorithm;
-        bool wrong_key_usage;
-        Recipient recipients;
-        string filename;
-    }
-
-    /**
-     * An receipient
-     */
-    [CCode (cname = "struct _gpgme_recipient")]
-    public struct Recipient {
-        Recipient *next;
-        string keyid;
-        PublicKeyAlgorithm pubkey_algo;
-        GPGError.ErrorCode status;
-    }
-
-    /**
-     * list of invalid keys
-     */
-    [CCode (cname = "struct _gpgme_invalid_key")]
-    public struct InvalidKey {
-        InvalidKey *next;
-        string fpr;
-        GPGError.ErrorCode reason;
-    }
-
-    /**
-     * A Signature
-     */
-    [CCode (cname = "struct _gpgme_signature")]
-    public struct Signature {
-        /**
-         * The next signature in the list
-         */
-        Signature *next;
-
-        /**
-         * A summary of the signature status
-         */
-        Sigsum summary;
-
-        /**
-         * Fingerprint or key ID of the signature
-         */
-        string fpr;
-
-        /**
-         * The Error status of the signature
-         */
-        GPGError.ErrorCode status;
-
-        /**
-         * Notation data and policy URLs
-         */
-        SigNotation notations;
-
-        /**
-         * Signature creation time
-         */
-        ulong timestamp;
-
-        /**
-         * Signature expiration time or 0
-         */
-        ulong exp_timestamp;
-
-        /**
-         * Key should not have been used for signing
-         */
-        bool wrong_key_usage;
-
-        /**
-         * PKA status
-         */
-        PKAStatus pka_trust;
-
-        /**
-         * Validity has been verified using the chain model
-         */
-        bool chain_model;
-
-        /**
-         * Validity
-         */
-        Validity validity;
-
-        /**
-         * Validity reason
-         */
-        GPGError.ErrorCode validity_reason;
-
-        /**
-         * public key algorithm used to create the signature
-         */
-        PublicKeyAlgorithm pubkey_algo;
-
-        /**
-         * The hash algorithm used to create the signature
-         */
-        HashAlgorithm hash_algo;
-
-        /**
-         * The mailbox from the PKA information or null
-         */
-        string? pka_adress;
-    }
-
-    /**
-     * PKA Status
-     */
-    public enum PKAStatus {
-        NOT_AVAILABLE,
-        BAD,
-        OKAY,
-        RFU
-    }
-
-    /**
-     * Flags used for the summary field in a Signature
-     */
-    [CCode (cname = "gpgme_sigsum_t", cprefix = "GPGME_SIGSUM_")]
-    public enum Sigsum {
-        /**
-         * The signature is fully valid
-         */
-        VALID,
-
-        /**
-         * The signature is good
-         */
-        GREEN,
-
-        /**
-         * The signature is bad
-         */
-        RED,
-
-        /**
-         * One key has been revoked
-         */
-        KEY_REVOKED,
-
-        /**
-         * One key has expired
-         */
-        KEY_EXPIRED,
-
-        /**
-         * The signature has expired
-         */
-        SIG_EXPIRED,
-
-        /**
-         * Can't verfiy - missing key
-         */
-        KEY_MISSING,
-
-        /**
-         * CRL not available
-         */
-        CRL_MISSING,
-
-        /**
-         * Available CRL is too old
-         */
-        CRL_TOO_OLD,
-
-        /**
-         * A policy was not met
-         */
-        BAD_POLICY,
-
-        /**
-         * A system error occured
-         */
-        SYS_ERROR
-    }
-
-    /**
-     * Encoding modes of Data objects
-     */
-    [CCode (cname = "gpgme_data_encoding_t", cprefix = "GPGME_DATA_ENCODING_")]
-    public enum DataEncoding {
-        /**
-         * Not specified
-         */
-        NONE,
-        /**
-         * Binary encoded
-         */
-        BINARY,
-        /**
-         * Base64 encoded
-         */
-        BASE64,
-        /**
-         * Either PEM or OpenPGP Armor
-         */
-        ARMOR,
-        /**
-         * LF delimited URL list
-         */
-        URL,
-        /**
-         * LF percent escaped, delimited URL list
-         */
-        URLESC,
-        /**
-         * Nul determined URL list
-         */
-        URL0
-    }
-
-    /**
-     * Public Key Algorithms from libgcrypt
-     */
-    [CCode (cname = "gpgme_pubkey_algo_t", cprefix = "GPGME_PK_")]
-    public enum PublicKeyAlgorithm {
-        RSA,
-        RSA_E,
-        RSA_S,
-        ELG_E,
-        DSA,
-        ELG
-    }
-
-    /**
-     * Hash Algorithms from libgcrypt
-     */
-    [CCode (cname = "gpgme_hash_algo_t", cprefix = "GPGME_MD_")]
-    public enum HashAlgorithm {
-        NONE,
-        MD5,
-        SHA1,
-        RMD160,
-        MD2,
-        TIGER,
-        HAVAL,
-        SHA256,
-        SHA384,
-        SHA512,
-        MD4,
-        MD_CRC32,
-        MD_CRC32_RFC1510,
-        MD_CRC24_RFC2440
-    }
-
-    /**
-     * Signature modes
-     */
-    [CCode (cname = "gpgme_sig_mode_t", cprefix = "GPGME_SIG_MODE_")]
-    public enum SigMode {
-        NORMAL,
-        DETACH,
-        CLEAR
-    }
-
-    /**
-     * Validities for a trust item or key
-     */
-    [CCode (cname = "gpgme_validity_t", cprefix = "GPGME_VALIDITY_")]
-    public enum Validity {
-        UNKNOWN,
-        UNDEFINED,
-        NEVER,
-        MARGINAL,
-        FULL,
-        ULTIMATE
-    }
-
-    /**
-     * Protocols
-     */
-    [CCode (cname = "gpgme_protocol_t", cprefix = "GPGME_PROTOCOL_")]
-    public enum Protocol {
-        /**
-         * Default Mode
-         */
-        OpenPGP,
-        /**
-         * Cryptographic Message Syntax
-         */
-        CMS,
-        /**
-         * Special code for gpgconf
-         */
-        GPGCONF,
-        /**
-         * Low-level access to an Assuan server
-         */
-        ASSUAN,
-        UNKNOWN
-    }
-
-    /**
-     * Keylist modes used by Context
-     */
-    [CCode (cname = "gpgme_keylist_mode_t", cprefix = "GPGME_KEYLIST_MODE_")]
-    public enum KeylistMode {
-        LOCAL,
-        EXTERN,
-        SIGS,
-        SIG_NOTATIONS,
-        EPHEMERAL,
-        VALIDATE
-    }
-
-    /**
-     * Export modes used by Context
-     */
-    [CCode (cname = "gpgme_export_mode_t", cprefix = "GPGME_EXPORT_MODE_")]
-    public enum ExportMode {
-        EXTERN
-    }
-
-    /**
-     * Audit log function flags
-     */
-    [CCode (cprefix = "GPGME_AUDITLOG_")]
-    public enum AuditLogFlag {
-        HTML,
-        WITH_HELP
-    }
-
-    /**
-     * Signature notation flags
-     */
-    [CCode (cname = "gpgme_sig_notation_flags_t", cprefix = "GPGME_SIG_NOTATION_")]
-    public enum SigNotationFlags {
-        HUMAN_READABLE,
-        CRITICAL
-    }
-
-    /**
-     * Encryption Flags
-     */
-    [CCode (cname = "gpgme_encrypt_flags_t", cprefix = "GPGME_ENCRYPT_")]
-    public enum EncryptFlags {
-        ALWAYS_TRUST,
-        NO_ENCRYPT_TO
-    }
-
-    /**
-     * Edit Operation Stati
-     */
-    [CCode (cname = "gpgme_status_code_t", cprefix = "GPGME_STATUS_")]
-    public enum StatusCode {
-        EOF,
-        ENTER,
-        LEAVE,
-        ABORT,
-        GOODSIG,
-        BADSIG,
-        ERRSIG,
-        BADARMOR,
-        RSA_OR_IDEA,
-        KEYEXPIRED,
-        KEYREVOKED,
-        TRUST_UNDEFINED,
-        TRUST_NEVER,
-        TRUST_MARGINAL,
-        TRUST_FULLY,
-        TRUST_ULTIMATE,
-        SHM_INFO,
-        SHM_GET,
-        SHM_GET_BOOL,
-        SHM_GET_HIDDEN,
-        NEED_PASSPHRASE,
-        VALIDSIG,
-        SIG_ID,
-        SIG_TO,
-        ENC_TO,
-        NODATA,
-        BAD_PASSPHRASE,
-        NO_PUBKEY,
-        NO_SECKEY,
-        NEED_PASSPHRASE_SYM,
-        DECRYPTION_FAILED,
-        DECRYPTION_OKAY,
-        MISSING_PASSPHRASE,
-        GOOD_PASSPHRASE,
-        GOODMDC,
-        BADMDC,
-        ERRMDC,
-        IMPORTED,
-        IMPORT_OK,
-        IMPORT_PROBLEM,
-        IMPORT_RES,
-        FILE_START,
-        FILE_DONE,
-        FILE_ERROR,
-        BEGIN_DECRYPTION,
-        END_DECRYPTION,
-        BEGIN_ENCRYPTION,
-        END_ENCRYPTION,
-        DELETE_PROBLEM,
-        GET_BOOL,
-        GET_LINE,
-        GET_HIDDEN,
-        GOT_IT,
-        PROGRESS,
-        SIG_CREATED,
-        SESSION_KEY,
-        NOTATION_NAME,
-        NOTATION_DATA,
-        POLICY_URL,
-        BEGIN_STREAM,
-        END_STREAM,
-        KEY_CREATED,
-        USERID_HINT,
-        UNEXPECTED,
-        INV_RECP,
-        NO_RECP,
-        ALREADY_SIGNED,
-        SIGEXPIRED,
-        EXPSIG,
-        EXPKEYSIG,
-        TRUNCATED,
-        ERROR,
-        NEWSIG,
-        REVKEYSIG,
-        SIG_SUBPACKET,
-        NEED_PASSPHRASE_PIN,
-        SC_OP_FAILURE,
-        SC_OP_SUCCESS,
-        CARDCTRL,
-        BACKUP_KEY_CREATED,
-        PKA_TRUST_BAD,
-        PKA_TRUST_GOOD,
-        PLAINTEXT
-    }
-
-    /**
-     * The Context object represents a GPG instance
-     */
-    [Compact]
-    [CCode (cname = "struct gpgme_context", free_function = "gpgme_release", cprefix = "gpgme_")]
-    public class Context {
-        /**
-         * Create a new context, returns Error Status Code
-         */
-        [CCode (cname = "gpgme_new")]
-        public static GPGError.ErrorCode Context(out Context ctx);
-
-        public GPGError.ErrorCode set_protocol(Protocol p);
-        public Protocol get_protocol();
-
-        public void set_armor(bool yes);
-        public bool get_armor();
-
-        public void set_textmode(bool yes);
-        public bool get_textmode();
-
-        public GPGError.ErrorCode set_keylist_mode(KeylistMode mode);
-        public KeylistMode get_keylist_mode();
-
-        /**
-         * Include up to nr_of_certs certificates in an S/MIME message,
-         * Use "-256" to use the backend's default.
-         */
-        public void set_include_certs(int nr_of_certs = -256);
-
-        /**
-         * Return the number of certs to include in an S/MIME message
-         */
-        public int get_include_certs();
-
-        /**
-         * Set callback function for requesting passphrase. hook_value will be
-         * passed as first argument.
-         */
-        public void set_passphrase_cb(passphrase_callback cb, void* hook_value = null);
-
-        /**
-         * Get callback function and hook_value
-         */
-        public void get_passphrase_cb(out passphrase_callback cb, out void* hook_value);
-
-        public GPGError.ErrorCode set_locale(int category, string val);
-
-        /**
-         * Get information about the configured engines. The returned data is valid
-         * until the next set_engine_info() call.
-         */
-        [CCode (cname = "gpgme_ctx_get_engine_info")]
-        public EngineInfo* get_engine_info();
-
-        /**
-         * Set information about the configured engines. The string parameters may not
-         * be free'd after this calls, because they are not copied.
-         */
-        [CCode (cname = "gpgme_ctx_set_engine_info")]
-        public GPGError.ErrorCode set_engine_info(Protocol proto, string file_name, string home_dir);
-
-        /**
-         * Delete all signers
-         */
-        public void signers_clear();
-
-        /**
-         * Add key to list of signers
-         */
-        public GPGError.ErrorCode signers_add(Key key);
-
-        /**
-         * Get the n-th signer's key
-         */
-        public Key* signers_enum(int n);
-
-        /**
-         * Clear all notation data
-         */
-        public void sig_notation_clear();
-
-        /**
-         * Add human readable notation data. If name is null,
-         * then value val should be a policy URL. The HUMAN_READABLE
-         * flag is forced to be true for notation data and false
-         * for policy URLs.
-         */
-        public GPGError.ErrorCode sig_notation_add(string name, string val, SigNotationFlags flags);
-
-        /**
-         * Get sig notations
-         */
-        public SigNotation* sig_notation_get();
-
-        /**
-         * Get key with the fingerprint FPR from the crypto backend.
-         * If SECRET is true, get the secret key.
-         */
-        public GPGError.ErrorCode get_key(string fpr, out Key key, bool secret);
-
-        /**
-         * process the pending operation and, if hang is true, wait for
-         * the pending operation to finish.
-         */
-        public Context* wait(out GPGError.ErrorCode status, bool hang);
-
-        /**
-         * Retrieve a pointer to the results of the signing operation
-         */
-        public SignResult* op_sign_result();
-
-        /**
-         * Sign the plaintext PLAIN and store the signature in SIG.
-         */
-        public GPGError.ErrorCode op_sign(Data plain, Data sig, SigMode mode);
-
-        /**
-         * Retrieve a pointer to the result of the verify operation
-         */
-        public VerifyResult* op_verify_result();
-
-        /**
-         * Verify that SIG is a valid signature for SIGNED_TEXT.
-         */
-        public GPGError.ErrorCode op_verify(Data sig, Data signed_text, Data? plaintext);
-
-        /**
-         * Retrieve a pointer to the result of the encrypt operation
-         */
-        public EncryptResult* op_encrypt_result();
-
-        /**
-         * Encrypt plaintext PLAIN for the recipients RECP and store the
-         * resulting ciphertext in CIPHER.
-         */
-        public GPGError.ErrorCode op_encrypt([CCode (array_length = false)] Key[] recp, EncryptFlags flags, Data plain, Data cipher);
-
-        /**
-         * Retrieve a pointer to the result of the decrypt operation
-         */
-        public DecryptResult* op_decrypt_result();
-
-        /**
-         * Decrypt ciphertext CIPHER and store the resulting plaintext
-         * in PLAIN.
-         */
-        public GPGError.ErrorCode op_decrypt(Data cipher, Data plain);
-
-        /**
-         * Export the keys found by PATTERN into KEYDATA. If PATTERN is
-         * NULL all keys will be exported.
-         */
-        public GPGError.ErrorCode op_export(string? pattern, ExportMode mode, Data keydata);
-
-        /**
-         * Import the keys in KEYDATA.
-         */
-        public GPGError.ErrorCode op_import(Data keydata);
-
-        /**
-         * Get result of last op_import.
-         */
-        public unowned ImportResult op_import_result();
-
-        /**
-         * Initiates a key listing operation. It sets everything up, so that
-         * subsequent invocations of op_keylist_next() return the keys in the list.
-         *
-         * If pattern is NULL, all available keys are returned. Otherwise, pattern
-         * contains an engine specific expression that is used to limit the list to
-         * all keys matching the pattern.
-         *
-         * If secret_only is not 0, the list is restricted to secret keys only.
-         *
-         * The context will be busy until either all keys are received (and
-         * op_keylist_next() returns GPG_ERR_EOF), or gpgme_op_keylist_end is called
-         * to finish the operation.
-         *
-         * The function returns the error code GPG_ERR_INV_VALUE if ctx is not a valid
-         * pointer, and passes through any errors that are reported by the crypto engine
-         * support routines.
-         */
-        public GPGError.ErrorCode op_keylist_start(string? pattern = null, int secret_only = 0);
-
-        /**
-         * returns the next key in the list created by a previous op_keylist_start()
-         * operation in the context ctx. The key will have one reference for the user.
-         *
-         * If the last key in the list has already been returned, op_keylist_next()
-         * returns GPG_ERR_EOF.
-         *
-         * The function returns the error code GPG_ERR_INV_VALUE if ctx or r_key is
-         * not a valid pointer, and GPG_ERR_ENOMEM if there is not enough memory for
-         * the operation.
-         */
-        public GPGError.ErrorCode op_keylist_next(out Key key);
-
-        /**
-         * ends a pending key list operation in the context.
-         *
-         * After the operation completed successfully, the result of the key listing
-         * operation can be retrieved with op_keylist_result().
-         *
-         * The function returns the error code GPG_ERR_INV_VALUE if ctx is not a valid
-         * pointer, and GPG_ERR_ENOMEM if at some time during the operation there was
-         * not enough memory available.
-         */
-        public GPGError.ErrorCode op_keylist_end();
-
-        /**
-         * The function op_keylist_result() returns a KeylistResult holding the result of
-         * a op_keylist_*() operation. The returned KeylistResult is only valid if the last
-         * operation on the context was a key listing operation, and if this operation
-         * finished successfully. The returned KeylistResult is only valid until the next
-         * operation is started on the context.
-         */
-        public KeylistResult op_keylist_result();
-    }
-
-    [Flags]
-    [CCode (cname="unsigned int")]
-    public enum ImportStatusFlags {
-        /**
-         * The key was new.
-         */
-        [CCode (cname = "GPGME_IMPORT_NEW")]
-        NEW,
-        /**
-         * The key contained new user IDs.
-         */
-        [CCode (cname = "GPGME_IMPORT_UID")]
-        UID,
-        /**
-         * The key contained new signatures.
-         */
-        [CCode (cname = "GPGME_IMPORT_SIG")]
-        SIG,
-        /**
-         * The key contained new sub keys.
-         */
-        [CCode (cname = "GPGME_IMPORT_SUBKEY")]
-        SUBKEY,
-        /**
-         * The key contained a secret key.
-         */
-        [CCode (cname = "GPGME_IMPORT_SECRET")]
-        SECRET
-    }
-
-    [Compact]
-    [CCode (cname = "struct _gpgme_import_status")]
-    public class ImportStatus {
-        /**
-         * This is a pointer to the next status structure in the linked list, or null
-         * if this is the last element.
-         */
-        public ImportStatus? next;
-
-        /**
-         * fingerprint of the key that was considered.
-         */
-        public string fpr;
-
-        /**
-         * If the import was not successful, this is the error value that caused the
-         * import to fail. Otherwise the error code is GPG_ERR_NO_ERROR.
-         */
-        public GPGError.ErrorCode result;
-
-        /**
-         * Flags what parts of the key have been imported. May be 0, if the key has
-         * already been known.
-         */
-        public ImportStatusFlags status;
-    }
-
-    [Compact]
-    [CCode (cname = "struct _gpgme_op_import_result")]
-    public class ImportResult {
-        /**
-         * The total number of considered keys.
-         */
-        public int considered;
-
-        /**
-         * The number of keys without user ID.
-         */
-        public int no_user_id;
-
-        /**
-         * The total number of imported keys.
-         */
-        public int imported;
-
-        /**
-         * The number of imported RSA keys.
-         */
-        public int imported_rsa;
-
-        /**
-         * The number of unchanged keys.
-         */
-        public int unchanged;
-
-        /**
-         * The number of new user IDs.
-         */
-        public int new_user_ids;
-
-        /**
-         * The number of new sub keys.
-         */
-        public int new_sub_keys;
-
-        /**
-         * The number of new signatures.
-         */
-        public int new_signatures;
-
-        /**
-         * The number of new revocations.
-         */
-        public int new_revocations;
-
-        /**
-         * The total number of secret keys read.
-         */
-        public int secret_read;
-
-        /**
-         * The number of imported secret keys.
-         */
-        public int secret_imported;
-
-        /**
-         * The number of unchanged secret keys.
-         */
-        public int secret_unchanged;
-
-        /**
-         * The number of keys not imported.
-         */
-        public int not_imported;
-
-        /*
-         * A linked list of ImportStatus objects which
-         * contains more information about the keys for
-         * which an import was attempted.
-         */
-        public ImportStatus imports;
-    }
-
-    [Compact]
-    [CCode (cname = "struct _gpgme_op_keylist_result")]
-    public class KeylistResult {
-        uint truncated;
-    }
-
-
-    /**
-     * Data Object, contains encrypted and/or unencrypted data
-     */
-    [Compact]
-    [CCode (cname = "struct gpgme_data", free_function = "gpgme_data_release", cprefix = "gpgme_data_")]
-    public class Data {
-        /**
-         * Create a new data buffer, returns Error Status Code.
-         */
-        [CCode (cname = "gpgme_data_new")]
-        public static GPGError.ErrorCode create(out Data d);
-
-        /**
-         * Create a new data buffer filled with SIZE bytes starting
-         * from BUFFER. If COPY is false, COPYING is delayed until
-         * necessary and the data is taken from the original location
-         * when needed. Returns Error Status Code.
-         */
-        [CCode (cname = "gpgme_data_new_from_mem")]
-        public static GPGError.ErrorCode create_from_memory(out Data d, uint8[] buffer, bool copy);
-
-        /**
-         * Create a new data buffer filled with the content of the file.
-         * COPY must be non-zero. For delayed read, please use
-         * create_from_fd or create_from stream instead.
-         */
-        [CCode (cname = "gpgme_data_new_from_file")]
-        public static GPGError.ErrorCode create_from_file(out Data d, string filename, int copy = 1);
-
-
-        /**
-         * Destroy the object and return a pointer to its content.
-         * It's size is returned in R_LEN.
-         */
-        [CCode (cname = "gpgme_data_release_and_get_mem")]
-        public string release_and_get_mem(out size_t len);
-
-        /**
-         * Read up to SIZE bytes into buffer BUFFER from the data object.
-         * Return the number of characters read, 0 on EOF and -1 on error.
-         * If an error occurs, errno is set.
-         */
-        public ssize_t read(uint8[] buf);
-
-        /**
-         * Write up to SIZE bytes from buffer BUFFER to the data object.
-         * Return the number of characters written, or -1 on error.
-         * If an error occurs, errno is set.
-         */
-        public ssize_t write(uint8[] buf);
-
-        /**
-         * Set the current position from where the next read or write
-         * starts in the data object to OFFSET, relativ to WHENCE.
-         */
-        public long seek(long offset, int whence=0);
-
-        /**
-         * Get the encoding attribute of the buffer
-         */
-        public DataEncoding *get_encoding();
-
-        /**
-         * Set the encoding attribute of the buffer to ENC
-         */
-        public GPGError.ErrorCode set_encoding(DataEncoding enc);
-    }
-
-    [CCode (cname = "gpgme_get_protocol_name")]
-    public unowned string get_protocol_name(Protocol p);
-
-    [CCode (cname = "gpgme_pubkey_algo_name")]
-    public unowned string get_public_key_algorithm_name(PublicKeyAlgorithm algo);
-
-    [CCode (cname = "gpgme_hash_algo_name")]
-    public unowned string get_hash_algorithm_name(HashAlgorithm algo);
-
-    [CCode (cname = "gpgme_passphrase_cb_t", has_target = false)]
-    public delegate GPGError.ErrorCode passphrase_callback(void* hook, string uid_hint, string passphrase_info, bool prev_was_bad, int fd);
-
-    /**
-     * Get version of libgpgme
-     * Always call this function before using gpgme, it initializes some stuff
-     */
-    [CCode (cname = "gpgme_check_version")]
-    public unowned string check_version(string? required_version = null);
-
-    /**
-     * Verify that the engine implementing proto is installed and
-     * available.
-     */
-    [CCode (cname = "gpgme_engine_check_version")]
-    public GPGError.ErrorCode engine_check_version(Protocol proto);
-
-    /**
-     * Get information about the configured engines. The returned data is valid
-     * until the next set_engine_info() call.
-     */
-    [CCode (cname = "gpgme_get_engine_information")]
-    public GPGError.ErrorCode get_engine_information(out EngineInfo engine_info);
-
-    /**
-     * Return the error string for ERR in the user-supplied buffer BUF
-     * of size BUFLEN. This function is thread-safe, if a thread-safe
-     * strerror_r() function is provided by the system. If the function
-     * succeeds, 0 is returned and BUF contains the string describing
-     * the error. If the buffer was not large enough, ERANGE is returned
-     * and BUF contains as much of the beginning of the error string as
-     * fits into the buffer. Returns Error Status Code.
-     */
-    [CCode (cname = "gpgme_strerror_r")]
-    public int strerror_r(GPGError.ErrorCode err, uint8[] buf);
-
-    /**
-     * Like strerror_r, but returns a pointer to the string. This method
-     * is not thread safe!
-     */
-    [CCode (cname = "gpgme_strerror")]
-    public unowned string strerror(GPGError.ErrorCode err);
-}
diff --git a/xmpp-vala/CMakeLists.txt b/xmpp-vala/CMakeLists.txt
index dd846c24..95c9c44b 100644
--- a/xmpp-vala/CMakeLists.txt
+++ b/xmpp-vala/CMakeLists.txt
@@ -66,9 +66,9 @@ SOURCES
     "src/module/xep/pixbuf_storage.vala"
 CUSTOM_VAPIS
     "${CMAKE_CURRENT_SOURCE_DIR}/vapi/uuid.vapi"
+    "${CMAKE_BINARY_DIR}/gpgme-vala/gpgme.vapi"
 PACKAGES
     ${ENGINE_PACKAGES}
-    gpgme
 GENERATE_VAPI
     xmpp-vala
 GENERATE_HEADER
@@ -80,10 +80,11 @@ OPTIONS
     --vapidir=${CMAKE_SOURCE_DIR}/vapi
 )
 
-set(CFLAGS ${ENGINE_CFLAGS} ${GPGME_CFLAGS} ${LIBUUID_CFLAGS} -g ${VALA_CFLAGS})
+set(CFLAGS ${ENGINE_CFLAGS} ${GPGME_CFLAGS} ${LIBUUID_CFLAGS} -g ${VALA_CFLAGS} -I${CMAKE_BINARY_DIR}/gpgme-vala)
 add_definitions(${CFLAGS})
 add_library(xmpp-vala SHARED ${ENGINE_VALA_C})
-target_link_libraries(xmpp-vala ${ENGINE_LIBRARIES} ${GPGME_LIBRARIES} ${LIBUUID_LIBRARIES})
+add_dependencies(xmpp-vala gpgme-vala gpgme-vapi)
+target_link_libraries(xmpp-vala gpgme-vala ${ENGINE_LIBRARIES} ${GPGME_LIBRARIES} ${LIBUUID_LIBRARIES})
 
 add_custom_target(xmpp-vala-vapi
 DEPENDS
diff --git a/xmpp-vala/src/core/xmpp_stream.vala b/xmpp-vala/src/core/xmpp_stream.vala
index e30a1c9b..5f92113d 100644
--- a/xmpp-vala/src/core/xmpp_stream.vala
+++ b/xmpp-vala/src/core/xmpp_stream.vala
@@ -227,19 +227,19 @@ public class XmppStream {
 }
 
 public abstract class XmppStreamFlag {
-    internal abstract string get_ns();
-    internal abstract string get_id();
+    public abstract string get_ns();
+    public abstract string get_id();
 }
 
 public abstract class XmppStreamModule : Object {
-    internal abstract void attach(XmppStream stream);
-    internal abstract void detach(XmppStream stream);
-    internal abstract string get_ns();
-    internal abstract string get_id();
+    public abstract void attach(XmppStream stream);
+    public abstract void detach(XmppStream stream);
+    public abstract string get_ns();
+    public abstract string get_id();
 }
 
 public abstract class XmppStreamNegotiationModule : XmppStreamModule {
-    internal abstract bool mandatory_outstanding(XmppStream stream);
-    internal abstract bool negotiation_active(XmppStream stream);
+    public abstract bool mandatory_outstanding(XmppStream stream);
+    public abstract bool negotiation_active(XmppStream stream);
 }
 }
diff --git a/xmpp-vala/src/module/xep/0027_pgp/module.vala b/xmpp-vala/src/module/xep/0027_pgp/module.vala
index fee6b9e4..63177f4d 100644
--- a/xmpp-vala/src/module/xep/0027_pgp/module.vala
+++ b/xmpp-vala/src/module/xep/0027_pgp/module.vala
@@ -12,8 +12,6 @@ namespace Xmpp.Xep.Pgp {
 
         public signal void received_jid_key_id(XmppStream stream, string jid, string key_id);
 
-        private static Object mutex = new Object();
-
         private string? signed_status;
         private string? own_key_id;
 
@@ -99,95 +97,48 @@ namespace Xmpp.Xep.Pgp {
         }
 
         private static string? gpg_encrypt(string plain, string[] key_ids) {
-            lock (mutex) {
-                GPG.Context context;
-                GPGError.ErrorCode e = GPG.Context.Context(out context); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                context.set_armor(true);
-
-                Key[] keys = new Key[key_ids.length];
+            GPG.Key[] keys = new GPG.Key[key_ids.length];
+            string encr;
+            try {
                 for (int i = 0; i < key_ids.length; i++) {
-                    Key key;
-                    e = context.get_key(key_ids[i], out key, false); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                    keys[i] = key;
+                    keys[i] = GPGHelper.get_public_key(key_ids[i]);
                 }
-
-                GPG.Data plain_data;
-                e = GPG.Data.create_from_memory(out plain_data, plain.data, false);
-                GPG.Data enc_data;
-                e = GPG.Data.create(out enc_data);
-                e = context.op_encrypt(keys, GPG.EncryptFlags.ALWAYS_TRUST, plain_data, enc_data);
-
-                string encr = get_string_from_data(enc_data);
-                int encryption_start = encr.index_of("\n\n") + 2;
-                return encr.substring(encryption_start, encr.length - "\n-----END PGP MESSAGE-----".length - encryption_start);
+                encr = GPGHelper.encrypt_armor(plain, keys, GPG.EncryptFlags.ALWAYS_TRUST);
+            } catch (Error e) {
+                return null;
             }
+            int encryption_start = encr.index_of("\n\n") + 2;
+            return encr.substring(encryption_start, encr.length - "\n-----END PGP MESSAGE-----".length - encryption_start);
         }
 
         private static string? gpg_decrypt(string enc) {
-            lock (mutex) {
-                string armor = "-----BEGIN PGP MESSAGE-----\n\n" + enc + "\n-----END PGP MESSAGE-----";
-
-                GPG.Data enc_data;
-                GPGError.ErrorCode e = GPG.Data.create_from_memory(out enc_data, armor.data, false); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                GPG.Data dec_data;
-                e = GPG.Data.create(out dec_data); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                GPG.Context context;
-                e = GPG.Context.Context(out context); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                e = context.op_decrypt(enc_data, dec_data); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-
-                string plain = get_string_from_data(dec_data);
-                return plain;
-            }
+            string armor = "-----BEGIN PGP MESSAGE-----\n\n" + enc + "\n-----END PGP MESSAGE-----";
+            string? decr = null;
+            try {
+                decr = GPGHelper.decrypt(armor);
+            } catch (Error e) { }
+            return decr;
         }
 
         private static string? gpg_verify(string sig, string signed_text) {
-            lock (mutex) {
-                string armor = "-----BEGIN PGP MESSAGE-----\n\n" + sig + "\n-----END PGP MESSAGE-----";
-
-                GPG.Data sig_data;
-                GPGError.ErrorCode e = GPG.Data.create_from_memory(out sig_data, armor.data, false); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                GPG.Data plain_data;
-                e = GPG.Data.create(out plain_data); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                GPG.Context context;
-                e = GPG.Context.Context(out context); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                e = context.op_verify(sig_data, null, plain_data); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                GPG.VerifyResult* verify_res = context.op_verify_result();
-                if (verify_res == null || verify_res.signatures == null) return null;
-                return verify_res.signatures.fpr;
+            string armor = "-----BEGIN PGP MESSAGE-----\n\n" + sig + "\n-----END PGP MESSAGE-----";
+            string? sign_key = null;
+            try {
+                sign_key = GPGHelper.get_sign_key(armor, signed_text);
+            } catch (Error e) { }
+            return sign_key;
+        }
+
+        private static string? gpg_sign(string str) {
+            string signed;
+            try {
+                signed = GPGHelper.sign(str, GPG.SigMode.CLEAR);
+            } catch (Error e) {
+                return null;
             }
-        }
-
-        private static string? gpg_sign(string status) {
-            lock (mutex) {
-                GPG.Data status_data;
-                GPGError.ErrorCode e = GPG.Data.create_from_memory(out status_data, status.data, false); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                GPG.Data signed_data;
-                e = GPG.Data.create(out signed_data); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                GPG.Context context;
-                e = GPG.Context.Context(out context); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-                e = context.op_sign(status_data, signed_data, GPG.SigMode.CLEAR); if (e != GPGError.ErrorCode.NO_ERROR) return null;
-
-                string signed = get_string_from_data(signed_data);
-                int signature_start = signed.index_of("-----BEGIN PGP SIGNATURE-----");
-                signature_start = signed.index_of("\n\n", signature_start) + 2;
-                return signed.substring(signature_start, signed.length - "\n-----END PGP SIGNATURE-----".length - signature_start);
-            }
-        }
-
-        private static string get_string_from_data(GPG.Data data) {
-            data.seek(0);
-            uint8[] buf = new uint8[256];
-            ssize_t? len = null;
-            string res = "";
-            do {
-                len = data.read(buf);
-                if (len > 0) {
-                    string part = (string) buf;
-                    part = part.substring(0, (long) len);
-                    res += part;
-                }
-            } while (len > 0);
-            return res;
+            int signature_start = signed.index_of("-----BEGIN PGP SIGNATURE-----");
+            signature_start = signed.index_of("\n\n", signature_start) + 2;
+            return signed.substring(signature_start, signed.length - "\n-----END PGP SIGNATURE-----".length - signature_start);
         }
     }