[seahorse/wip/nielsdg/more-gtask: 1/2] pgp: LdapSource: Use GTask instead of GSimpleAsyncResult



commit d781d185b92454c239adecfa1a6fd9648417f05d
Author: Niels De Graef <nielsdegraef gmail com>
Date:   Wed Jan 8 08:42:02 2020 +0100

    pgp: LdapSource: Use GTask instead of GSimpleAsyncResult
    
    `GSimpleAsyncResult` is deprecated in favor or `GTask`, so use that
    instead.

 pgp/seahorse-ldap-source.c | 1791 +++++++++++++++++++++-----------------------
 pgp/seahorse-ldap-source.h |    6 +-
 2 files changed, 864 insertions(+), 933 deletions(-)
---
diff --git a/pgp/seahorse-ldap-source.c b/pgp/seahorse-ldap-source.c
index 034fcf8d..64537ae9 100644
--- a/pgp/seahorse-ldap-source.c
+++ b/pgp/seahorse-ldap-source.c
@@ -56,10 +56,10 @@ struct _SeahorseLDAPSource {
 /* -----------------------------------------------------------------------------
  * SERVER INFO
  */
- 
+
 typedef struct _LDAPServerInfo {
-    gchar *base_dn;             /* The base dn where PGP keys are found */
-    gchar *key_attr;            /* The attribute of PGP key data */
+    char *base_dn;              /* The base dn where PGP keys are found */
+    char *key_attr;             /* The attribute of PGP key data */
     guint version;              /* The version of the PGP server software */
 } LDAPServerInfo;
 
@@ -80,53 +80,59 @@ set_ldap_server_info (SeahorseLDAPSource *lsrc, LDAPServerInfo *sinfo)
                             (GDestroyNotify)free_ldap_server_info);
 }
 
-static LDAPServerInfo*         
+static LDAPServerInfo*
 get_ldap_server_info (SeahorseLDAPSource *lsrc, gboolean force)
 {
     LDAPServerInfo *sinfo;
-    
+
     sinfo = g_object_get_data (G_OBJECT (lsrc), "server-info");
- 
-    /* When we're asked to force getting the data, we fill in 
-     * some defaults */   
+
+    /* When we're asked to force getting the data, we fill in
+     * some defaults */
     if (!sinfo && force) {
         sinfo = g_new0 (LDAPServerInfo, 1);
         sinfo->base_dn = g_strdup ("OU=ACTIVE,O=PGP KEYSPACE,C=US");
         sinfo->key_attr = g_strdup ("pgpKey");
         sinfo->version = 0;
         set_ldap_server_info (lsrc, sinfo);
-    } 
-    
+    }
+
     return sinfo;
 }
-                                                 
+
+static void
+destroy_ldap (gpointer data)
+{
+    if (data)
+        ldap_unbind_ext ((LDAP *) data, NULL, NULL);
+}
 
 /* -----------------------------------------------------------------------------
  *  LDAP HELPERS
  */
- 
+
 #define LDAP_ERROR_DOMAIN (get_ldap_error_domain())
 
-static gchar**
+static char**
 get_ldap_values (LDAP *ld, LDAPMessage *entry, const char *attribute)
 {
     GArray *array;
     struct berval **bv;
-    gchar *value;
+    char *value;
     int num, i;
 
     bv = ldap_get_values_len (ld, entry, attribute);
     if (!bv)
         return NULL;
 
-    array = g_array_new (TRUE, TRUE, sizeof (gchar*));
+    array = g_array_new (TRUE, TRUE, sizeof (char*));
     num = ldap_count_values_len (bv);
     for(i = 0; i < num; i++) {
         value = g_strndup (bv[i]->bv_val, bv[i]->bv_len);
         g_array_append_val(array, value);
     }
 
-    return (gchar**)g_array_free (array, FALSE);
+    return (char**)g_array_free (array, FALSE);
 }
 
 #ifdef WITH_DEBUG
@@ -135,25 +141,24 @@ static void
 dump_ldap_entry (LDAP *ld, LDAPMessage *res)
 {
     BerElement *pos;
-    gchar **values;
-    gchar **v;
     char *t;
-    
+
     t = ldap_get_dn (ld, res);
     g_debug ("dn: %s\n", t);
     ldap_memfree (t);
-    
-    for (t = ldap_first_attribute (ld, res, &pos); t; 
+
+    for (t = ldap_first_attribute (ld, res, &pos); t;
          t = ldap_next_attribute (ld, res, pos)) {
-             
+        g_auto(GStrv) values = NULL;
+        char **v;
+
         values = get_ldap_values (ld, res, t);
-        for (v = values; *v; v++) 
+        for (v = values; *v; v++)
             g_debug ("%s: %s\n", t, *v);
 
-        g_strfreev (values);
         ldap_memfree (t);
     }
-    
+
     ber_free (pos, 0);
 }
 
@@ -168,65 +173,62 @@ get_ldap_error_domain ()
     return q;
 }
 
-static gchar*
+static char*
 get_string_attribute (LDAP *ld, LDAPMessage *res, const char *attribute)
 {
-    gchar **vals;
-    gchar *v;
-    
+    g_auto(GStrv) vals = NULL;
+    char *v;
+
     vals = get_ldap_values (ld, res, attribute);
     if (!vals)
-        return NULL; 
+        return NULL;
     v = vals[0] ? g_strdup (vals[0]) : NULL;
-    g_strfreev (vals);
     return v;
 }
 
 static gboolean
 get_boolean_attribute (LDAP* ld, LDAPMessage *res, const char *attribute)
 {
-    gchar **vals;
+    g_auto(GStrv) vals = NULL;
     gboolean b;
-    
+
     vals = get_ldap_values (ld, res, attribute);
     if (!vals)
         return FALSE;
     b = vals[0] && atoi (vals[0]) == 1;
-    g_strfreev (vals);
     return b;
 }
 
 static long int
 get_int_attribute (LDAP* ld, LDAPMessage *res, const char *attribute)
 {
-    gchar **vals;
+    g_auto(GStrv) vals = NULL;
     long int d;
-    
+
     vals = get_ldap_values (ld, res, attribute);
     if (!vals)
         return 0;
     d = vals[0] ? atoi (vals[0]) : 0;
-    g_strfreev (vals);
-    return d;         
+    return d;
 }
 
 static long int
 get_date_attribute (LDAP* ld, LDAPMessage *res, const char *attribute)
 {
+    g_auto(GStrv) vals = NULL;
     struct tm t;
-    gchar **vals;
     long int d = 0;
-    
+
     vals = get_ldap_values (ld, res, attribute);
     if (!vals)
         return 0;
-        
+
     if (vals[0]) {
         memset(&t, 0, sizeof (t));
 
         /* YYYYMMDDHHmmssZ */
         sscanf(vals[0], "%4d%2d%2d%2d%2d%2d",
-            &t.tm_year, &t.tm_mon, &t.tm_mday, 
+            &t.tm_year, &t.tm_mon, &t.tm_mday,
             &t.tm_hour, &t.tm_min, &t.tm_sec);
 
         t.tm_year -= 1900;
@@ -234,51 +236,49 @@ get_date_attribute (LDAP* ld, LDAPMessage *res, const char *attribute)
         t.tm_mon--;
 
         d = mktime (&t);
-    }        
+    }
 
-    g_strfreev (vals);
-    return d;         
+    return d;
 }
 
-static const gchar*
+static const char*
 get_algo_attribute (LDAP* ld, LDAPMessage *res, const char *attribute)
 {
-       const gchar *a = NULL;
-       gchar **vals;
-    
-       vals = get_ldap_values (ld, res, attribute);
-       if (!vals)
-               return 0;
-    
-       if (vals[0]) {
-               if (g_ascii_strcasecmp (vals[0], "DH/DSS") == 0 || 
-                   g_ascii_strcasecmp (vals[0], "Elg") == 0 ||
-                   g_ascii_strcasecmp (vals[0], "Elgamal") == 0 ||
-                   g_ascii_strcasecmp (vals[0], "DSS/DH") == 0)
-                       a = "Elgamal";
-               if (g_ascii_strcasecmp (vals[0], "RSA") == 0)
-                       a = "RSA";
-               if (g_ascii_strcasecmp (vals[0], "DSA") == 0)
-                       a = "DSA";     
-       }
-    
-       g_strfreev (vals);
-       return a;
+    g_auto(GStrv) vals = NULL;
+    const char *a = NULL;
+
+    vals = get_ldap_values (ld, res, attribute);
+    if (!vals)
+        return 0;
+
+    if (vals[0]) {
+        if (g_ascii_strcasecmp (vals[0], "DH/DSS") == 0 ||
+            g_ascii_strcasecmp (vals[0], "Elg") == 0 ||
+            g_ascii_strcasecmp (vals[0], "Elgamal") == 0 ||
+            g_ascii_strcasecmp (vals[0], "DSS/DH") == 0)
+            a = "Elgamal";
+        if (g_ascii_strcasecmp (vals[0], "RSA") == 0)
+            a = "RSA";
+        if (g_ascii_strcasecmp (vals[0], "DSA") == 0)
+            a = "DSA";
+    }
+
+    return a;
 }
 
-/* 
+/*
  * Escapes a value so it's safe to use in an LDAP filter. Also trims
  * any spaces which cause problems with some LDAP servers.
  */
-static gchar*
-escape_ldap_value (const gchar *v)
+static char*
+escape_ldap_value (const char *v)
 {
     GString *value;
-    gchar* result;
-    
+    char* result;
+
     g_assert (v);
     value = g_string_sized_new (strlen(v));
-    
+
     for ( ; *v; v++) {
         switch(*v) {
         case '#': case ',': case '+': case '\\':
@@ -286,16 +286,16 @@ escape_ldap_value (const gchar *v)
             value = g_string_append_c (value, '\\');
             value = g_string_append_c (value, *v);
             continue;
-        };  
+        };
 
         if(*v < 32 || *v > 126) {
             g_string_append_printf (value, "\\%02X", *v);
             continue;
         }
-        
+
         value = g_string_append_c (value, *v);
     }
-    
+
     result = g_string_free (value, FALSE);
     g_strstrip (result);
     return result;
@@ -305,32 +305,32 @@ typedef gboolean (*SeahorseLdapCallback)   (LDAPMessage *result,
                                             gpointer user_data);
 
 typedef struct {
-       GSource source;
-       LDAP *ldap;
-       int ldap_op;
-       GCancellable *cancellable;
-       gboolean cancelled;
-       gint cancelled_sig;
+    GSource source;
+    LDAP *ldap;
+    int ldap_op;
+    GCancellable *cancellable;
+    gboolean cancelled;
+    int cancelled_sig;
 } SeahorseLdapGSource;
 
 static gboolean
 seahorse_ldap_gsource_prepare (GSource *gsource,
-                               gint *timeout)
+                               int *timeout)
 {
-       SeahorseLdapGSource *ldap_gsource = (SeahorseLdapGSource *)gsource;
+    SeahorseLdapGSource *ldap_gsource = (SeahorseLdapGSource *)gsource;
 
-       if (ldap_gsource->cancelled)
-               return TRUE;
+    if (ldap_gsource->cancelled)
+        return TRUE;
 
-       /* No other way, but to poll */
-       *timeout = 50;
-       return FALSE;
+    /* No other way, but to poll */
+    *timeout = 50;
+    return FALSE;
 }
 
 static gboolean
 seahorse_ldap_gsource_check (GSource *gsource)
 {
-       return TRUE;
+    return TRUE;
 }
 
 static gboolean
@@ -338,67 +338,67 @@ seahorse_ldap_gsource_dispatch (GSource *gsource,
                                 GSourceFunc callback,
                                 gpointer user_data)
 {
-       SeahorseLdapGSource *ldap_gsource = (SeahorseLdapGSource *)gsource;
-       struct timeval timeout;
-       LDAPMessage *result;
-       gboolean ret;
-       int rc, i;
-
-       if (ldap_gsource->cancelled) {
-               ((SeahorseLdapCallback)callback) (NULL, user_data);
-               return FALSE;
-       }
-
-       for (i = 0; i < DEFAULT_LOAD_BATCH; i++) {
-
-               /* This effects a poll */
-               timeout.tv_sec = 0;
-               timeout.tv_usec = 0;
-
-               rc = ldap_result (ldap_gsource->ldap, ldap_gsource->ldap_op,
-                                 0, &timeout, &result);
-               if (rc == -1) {
-                       g_warning ("ldap_result failed with rc = %d, errno = %s",
-                                  rc, g_strerror (errno));
-                       return FALSE;
-
-               /* Timeout */
-               } else if (rc == 0) {
-                       return TRUE;
-               }
-
-               ret = ((SeahorseLdapCallback)callback) (result, user_data);
-               ldap_msgfree (result);
-
-               if (!ret)
-                       return FALSE;
-       }
-
-       return TRUE;
+    SeahorseLdapGSource *ldap_gsource = (SeahorseLdapGSource *)gsource;
+    struct timeval timeout;
+    LDAPMessage *result;
+    gboolean ret;
+    int rc, i;
+
+    if (ldap_gsource->cancelled) {
+        ((SeahorseLdapCallback)callback) (NULL, user_data);
+        return FALSE;
+    }
+
+    for (i = 0; i < DEFAULT_LOAD_BATCH; i++) {
+
+        /* This effects a poll */
+        timeout.tv_sec = 0;
+        timeout.tv_usec = 0;
+
+        rc = ldap_result (ldap_gsource->ldap, ldap_gsource->ldap_op,
+                          0, &timeout, &result);
+        if (rc == -1) {
+            g_warning ("ldap_result failed with rc = %d, errno = %s",
+                       rc, g_strerror (errno));
+            return G_SOURCE_REMOVE;
+        }
+
+        /* Timeout */
+        if (rc == 0)
+            return G_SOURCE_CONTINUE;
+
+        ret = ((SeahorseLdapCallback)callback) (result, user_data);
+        ldap_msgfree (result);
+
+        if (!ret)
+            return G_SOURCE_REMOVE;
+    }
+
+    return G_SOURCE_CONTINUE;
 }
 
 static void
 seahorse_ldap_gsource_finalize (GSource *gsource)
 {
-       SeahorseLdapGSource *ldap_gsource = (SeahorseLdapGSource *)gsource;
-       g_cancellable_disconnect (ldap_gsource->cancellable,
-                                 ldap_gsource->cancelled_sig);
-       g_clear_object (&ldap_gsource->cancellable);
+    SeahorseLdapGSource *ldap_gsource = (SeahorseLdapGSource *)gsource;
+    g_cancellable_disconnect (ldap_gsource->cancellable,
+                              ldap_gsource->cancelled_sig);
+    g_clear_object (&ldap_gsource->cancellable);
 }
 
 static GSourceFuncs seahorse_ldap_gsource_funcs = {
-       seahorse_ldap_gsource_prepare,
-       seahorse_ldap_gsource_check,
-       seahorse_ldap_gsource_dispatch,
-       seahorse_ldap_gsource_finalize,
+    seahorse_ldap_gsource_prepare,
+    seahorse_ldap_gsource_check,
+    seahorse_ldap_gsource_dispatch,
+    seahorse_ldap_gsource_finalize,
 };
 
 static void
 on_ldap_gsource_cancelled (GCancellable *cancellable,
                            gpointer user_data)
 {
-       SeahorseLdapGSource *ldap_gsource = user_data;
-       ldap_gsource->cancelled = TRUE;
+    SeahorseLdapGSource *ldap_gsource = user_data;
+    ldap_gsource->cancelled = TRUE;
 }
 
 static GSource *
@@ -406,230 +406,223 @@ seahorse_ldap_gsource_new (LDAP *ldap,
                            int ldap_op,
                            GCancellable *cancellable)
 {
-       GSource *gsource;
-       SeahorseLdapGSource *ldap_gsource;
+    GSource *gsource;
+    SeahorseLdapGSource *ldap_gsource;
 
-       gsource = g_source_new (&seahorse_ldap_gsource_funcs,
-                               sizeof (SeahorseLdapGSource));
+    gsource = g_source_new (&seahorse_ldap_gsource_funcs,
+                            sizeof (SeahorseLdapGSource));
 
-       ldap_gsource = (SeahorseLdapGSource *)gsource;
-       ldap_gsource->ldap = ldap;
-       ldap_gsource->ldap_op = ldap_op;
+    ldap_gsource = (SeahorseLdapGSource *)gsource;
+    ldap_gsource->ldap = ldap;
+    ldap_gsource->ldap_op = ldap_op;
 
-       if (cancellable) {
-               ldap_gsource->cancellable = g_object_ref (cancellable);
-               ldap_gsource->cancelled_sig = g_cancellable_connect (cancellable,
-                                                                    G_CALLBACK (on_ldap_gsource_cancelled),
-                                                                    ldap_gsource, NULL);
-       }
+    if (cancellable) {
+        ldap_gsource->cancellable = g_object_ref (cancellable);
+        ldap_gsource->cancelled_sig = g_cancellable_connect (cancellable,
+                                                             G_CALLBACK (on_ldap_gsource_cancelled),
+                                                             ldap_gsource, NULL);
+    }
 
-       return gsource;
+    return gsource;
 }
 
 static gboolean
 seahorse_ldap_source_propagate_error (SeahorseLDAPSource *self,
                                       int rc, GError **error)
 {
-       gchar *server;
+    g_autofree char *server = NULL;
 
-       if (rc == LDAP_SUCCESS)
-               return FALSE;
+    if (rc == LDAP_SUCCESS)
+        return FALSE;
 
-       g_object_get (self, "key-server", &server, NULL);
-       g_set_error (error, LDAP_ERROR_DOMAIN, rc, _("Couldn’t communicate with %s: %s"),
-                    server, ldap_err2string (rc));
-       g_free (server);
+    g_object_get (self, "key-server", &server, NULL);
+    g_set_error (error, LDAP_ERROR_DOMAIN, rc, _("Couldn’t communicate with %s: %s"),
+                 server, ldap_err2string (rc));
 
-       return TRUE;
+    return TRUE;
 }
 
 typedef struct {
-       GCancellable *cancellable;
-       LDAP *ldap;
-} source_connect_closure;
+    LDAP *ldap;
+} ConnectClosure;
 
 static void
-source_connect_free (gpointer data)
+connect_closure_free (gpointer data)
 {
-       source_connect_closure *closure = data;
-       g_clear_object (&closure->cancellable);
-       if (closure->ldap)
-               ldap_unbind_ext (closure->ldap, NULL, NULL);
-       g_free (closure);
+    ConnectClosure *closure = data;
+    if (closure->ldap)
+        ldap_unbind_ext (closure->ldap, NULL, NULL);
+    g_free (closure);
 }
 
 static gboolean
 on_connect_server_info_completed (LDAPMessage *result,
                                   gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
-       LDAPServerInfo *sinfo;
-       char *message;
-       int code;
-       int type;
-       int rc;
-
-       type = ldap_msgtype (result);
-       g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
-
-       /* If we have results then fill in the server info */
-       if (type == LDAP_RES_SEARCH_ENTRY) {
-
-               g_debug ("Server Info Result");
+    GTask *task = G_TASK (user_data);
+    ConnectClosure *closure = g_task_get_task_data (task);
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_task_get_source_object (task));
+    char *message;
+    int code;
+    int type;
+    int rc;
+
+    type = ldap_msgtype (result);
+    g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
+
+    /* If we have results then fill in the server info */
+    if (type == LDAP_RES_SEARCH_ENTRY) {
+        LDAPServerInfo *sinfo;
+
+        g_debug ("Server Info Result");
 #ifdef WITH_DEBUG
-               dump_ldap_entry (closure->ldap, result);
+        dump_ldap_entry (closure->ldap, result);
 #endif
 
-               /* NOTE: When adding attributes here make sure to add them to kServerAttributes */
-               sinfo = g_new0 (LDAPServerInfo, 1);
-               sinfo->version = get_int_attribute (closure->ldap, result, "version");
-               sinfo->base_dn = get_string_attribute (closure->ldap, result, "basekeyspacedn");
-               if (!sinfo->base_dn)
-                       sinfo->base_dn = get_string_attribute (closure->ldap, result, "pgpbasekeyspacedn");
-               sinfo->key_attr = g_strdup (sinfo->version > 1 ? "pgpkeyv2" : "pgpkey");
-               set_ldap_server_info (self, sinfo);
-
-               return TRUE; /* callback again */
+        /* NOTE: When adding attributes here make sure to add them to kServerAttributes */
+        sinfo = g_new0 (LDAPServerInfo, 1);
+        sinfo->version = get_int_attribute (closure->ldap, result, "version");
+        sinfo->base_dn = get_string_attribute (closure->ldap, result, "basekeyspacedn");
+        if (!sinfo->base_dn)
+            sinfo->base_dn = get_string_attribute (closure->ldap, result, "pgpbasekeyspacedn");
+        sinfo->key_attr = g_strdup (sinfo->version > 1 ? "pgpkeyv2" : "pgpkey");
+        set_ldap_server_info (self, sinfo);
+
+        return G_SOURCE_CONTINUE;
+    }
 
-       } else {
-               rc = ldap_parse_result (closure->ldap, result, &code, NULL,
-                                       &message, NULL, NULL, 0);
-               g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
+    rc = ldap_parse_result (closure->ldap, result, &code, NULL, &message,
+                            NULL, NULL, 0);
+    g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
 
-               if (code != LDAP_SUCCESS)
-                       g_warning ("operation to get LDAP server info failed: %s", message);
+    if (code != LDAP_SUCCESS)
+        g_warning ("operation to get LDAP server info failed: %s", message);
 
-               ldap_memfree (message);
+    ldap_memfree (message);
 
-               g_simple_async_result_complete_in_idle (res);
-               seahorse_progress_end (closure->cancellable, res);
-               return FALSE; /* don't callback again */
-       }
+    g_task_return_pointer (task, g_steal_pointer (&closure->ldap), destroy_ldap);
+    seahorse_progress_end (cancellable, task);
+    return G_SOURCE_REMOVE;
 }
 
 static const char *SERVER_ATTRIBUTES[] = {
-       "basekeyspacedn",
-       "pgpbasekeyspacedn",
-       "version",
-       NULL
+    "basekeyspacedn",
+    "pgpbasekeyspacedn",
+    "version",
+    NULL
 };
 
 static gboolean
 on_connect_bind_completed (LDAPMessage *result,
                            gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
-       LDAPServerInfo *sinfo;
-       GError *error = NULL;
-       char *message;
-       int ldap_op;
-       int code;
-       int rc;
-
-       g_return_val_if_fail (ldap_msgtype (result) == LDAP_RES_BIND, FALSE);
-
-       /* The result of the bind operation */
-       rc = ldap_parse_result (closure->ldap, result, &code, NULL, &message, NULL, NULL, 0);
-       g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
-       ldap_memfree (message);
-
-       if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete_in_idle (res);
-               return FALSE; /* don't call this callback again */
-       }
-
-       /* Check if we need server info */
-       sinfo = get_ldap_server_info (self, FALSE);
-       if (sinfo != NULL) {
-               g_simple_async_result_complete_in_idle (res);
-               seahorse_progress_end (closure->cancellable, res);
-               return FALSE; /* don't call this callback again */
-       }
-
-       /* Retrieve the server info */
-       rc = ldap_search_ext (closure->ldap, "cn=PGPServerInfo", LDAP_SCOPE_BASE,
-                             "(objectclass=*)", (char **)SERVER_ATTRIBUTES, 0,
-                             NULL, NULL, NULL, 0, &ldap_op);
-
-       if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete_in_idle (res);
-               return FALSE; /* don't call this callback again */
-
-       } else {
-               GSource *gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
-                                                             closure->cancellable);
-               g_source_set_callback (gsource, (GSourceFunc)on_connect_server_info_completed,
-                                      g_object_ref (res), g_object_unref);
-               g_source_attach (gsource, g_main_context_default ());
-               g_source_unref (gsource);
-       }
-
-       return FALSE; /* don't call this callback again */
+    GTask *task = G_TASK (user_data);
+    ConnectClosure *closure = g_task_get_task_data (task);
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_task_get_source_object (task));
+    LDAPServerInfo *sinfo;
+    g_autoptr(GError) error = NULL;
+    char *message;
+    int ldap_op;
+    int code;
+    int rc;
+    g_autoptr(GSource) gsource = NULL;
+
+    g_return_val_if_fail (ldap_msgtype (result) == LDAP_RES_BIND, FALSE);
+
+    /* The result of the bind operation */
+    rc = ldap_parse_result (closure->ldap, result, &code, NULL, &message,
+                            NULL, NULL, 0);
+    g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
+    ldap_memfree (message);
+
+    if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return G_SOURCE_REMOVE;
+    }
+
+    /* Check if we need server info */
+    sinfo = get_ldap_server_info (self, FALSE);
+    if (sinfo != NULL) {
+        g_task_return_pointer (task, g_steal_pointer (&closure->ldap), destroy_ldap);
+        seahorse_progress_end (cancellable, task);
+        return G_SOURCE_REMOVE;
+    }
+
+    /* Retrieve the server info */
+    rc = ldap_search_ext (closure->ldap, "cn=PGPServerInfo", LDAP_SCOPE_BASE,
+                          "(objectclass=*)", (char **)SERVER_ATTRIBUTES, 0,
+                          NULL, NULL, NULL, 0, &ldap_op);
+
+    if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return G_SOURCE_REMOVE;
+    }
+
+    gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op, cancellable);
+    g_source_set_callback (gsource,
+                           G_SOURCE_FUNC (on_connect_server_info_completed),
+                           g_object_ref (task), g_object_unref);
+    g_source_attach (gsource, g_main_context_default ());
+
+    return G_SOURCE_REMOVE;
 }
 
 static void
 once_resolved_start_connect (SeahorseLDAPSource *self,
-                             GSimpleAsyncResult *res,
-                             const gchar *address)
+                             GTask *task,
+                             const char *address)
 {
-       source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       gchar *server = NULL;
-       GError *error = NULL;
-       gint port = LDAP_PORT;
-       struct berval cred;
-       int ldap_op;
-       gchar *url;
-       gchar *text;
-       int rc;
-
-       /* Now that we've resolved our address, connect via IP */
-       g_object_get (self, "key-server", &server, NULL);
-       g_return_if_fail (server && server[0]);
-
-       if ((text = strchr (server, ':')) != NULL) {
-               *text = 0;
-               text++;
-               port = atoi (text);
-               if (port <= 0 || port >= G_MAXUINT16) {
-                       g_warning ("invalid port number: %s (using default)", text);
-                       port = LDAP_PORT;
-               }
-       }
-
-       url = g_strdup_printf ("ldap://%s:%u";, address, port);
-       rc = ldap_initialize (&closure->ldap, url);
-       g_free (url);
-
-       if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete_in_idle (res);
-
-       /* Start the bind operation */
-       } else {
-               cred.bv_val = "";
-               cred.bv_len = 0;
-
-               rc = ldap_sasl_bind (closure->ldap, NULL, LDAP_SASL_SIMPLE, &cred,
-                                    NULL, NULL, &ldap_op);
-               if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
-                       g_simple_async_result_take_error (res, error);
-                       g_simple_async_result_complete_in_idle (res);
-
-               } else {
-                       GSource *gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
-                                                            closure->cancellable);
-                       g_source_set_callback (gsource, (GSourceFunc)on_connect_bind_completed,
-                                              g_object_ref (res), g_object_unref);
-                       g_source_attach (gsource, g_main_context_default ());
-                       g_source_unref (gsource);
-               }
-       }
+    ConnectClosure *closure = g_task_get_task_data (task);
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    g_autofree char *server = NULL;
+    char *text;
+    g_autoptr(GError) error = NULL;
+    int port = LDAP_PORT;
+    g_autofree char *url = NULL;
+    int rc;
+    struct berval cred;
+    int ldap_op;
+    g_autoptr(GSource) gsource = NULL;
+
+    /* Now that we've resolved our address, connect via IP */
+    g_object_get (self, "key-server", &server, NULL);
+    g_return_if_fail (server && server[0]);
+
+    if ((text = strchr (server, ':')) != NULL) {
+        *text = 0;
+        text++;
+        port = atoi (text);
+        if (port <= 0 || port >= G_MAXUINT16) {
+            g_warning ("invalid port number: %s (using default)", text);
+            port = LDAP_PORT;
+        }
+    }
+
+    url = g_strdup_printf ("ldap://%s:%u";, address, port);
+    rc = ldap_initialize (&closure->ldap, url);
+
+    if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    /* Start the bind operation */
+    cred.bv_val = "";
+    cred.bv_len = 0;
+
+    rc = ldap_sasl_bind (closure->ldap, NULL, LDAP_SASL_SIMPLE, &cred, NULL,
+                         NULL, &ldap_op);
+    if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op, cancellable);
+    g_source_set_callback (gsource, G_SOURCE_FUNC (on_connect_bind_completed),
+                           g_object_ref (task), g_object_unref);
+    g_source_attach (gsource, g_main_context_default ());
 }
 
 #ifdef WITH_SOUP
@@ -639,29 +632,25 @@ on_address_resolved_complete (SoupAddress *address,
                               guint status,
                               gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
-       source_connect_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       gchar *server;
-
-       g_object_get (self, "key-server", &server, NULL);
-       g_return_if_fail (server && server[0]);
-       seahorse_progress_update (closure->cancellable, res, _("Connecting to: %s"), server);
-       g_free (server);
-
-       /* DNS failed */
-       if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
-               g_simple_async_result_set_error (res, SEAHORSE_ERROR, -1,
-                                                _("Couldn’t resolve address: %s"),
-                                                soup_address_get_name (address));
-               g_simple_async_result_complete_in_idle (res);
-
-       /* Yay resolved */
-       } else {
-               once_resolved_start_connect (self, res, soup_address_get_physical (address));
-       }
-
-       g_object_unref (res);
+    g_autoptr(GTask) task = user_data;
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_task_get_source_object (task));
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    g_autofree char *server = NULL;
+
+    g_object_get (self, "key-server", &server, NULL);
+    g_return_if_fail (server && server[0]);
+    seahorse_progress_update (cancellable, task, _("Connecting to: %s"), server);
+
+    /* DNS failed */
+    if (!SOUP_STATUS_IS_SUCCESSFUL (status)) {
+        g_task_return_new_error (task, SEAHORSE_ERROR, -1,
+                                 _("Couldn’t resolve address: %s"),
+                                 soup_address_get_name (address));
+        return;
+    }
+
+    /* Yay resolved */
+    once_resolved_start_connect (self, task, soup_address_get_physical (address));
 }
 
 #endif /* WITH_SOUP */
@@ -672,45 +661,42 @@ seahorse_ldap_source_connect_async (SeahorseLDAPSource *source,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data)
 {
-       GSimpleAsyncResult *res;
-       source_connect_closure *closure;
-       gchar *server = NULL;
-       gchar *pos;
+    g_autoptr(GTask) task = NULL;
+    ConnectClosure *closure;
+    g_autofree char *server = NULL;
+    char *pos;
 #ifdef WITH_SOUP
-       SoupAddress *address;
+    SoupAddress *address = NULL;
 #endif
 
-       res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
-                                        seahorse_ldap_source_connect_async);
-       closure = g_new0 (source_connect_closure, 1);
-       closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
-       g_simple_async_result_set_op_res_gpointer (res, closure, source_connect_free);
+    task = g_task_new (source, cancellable, callback, user_data);
+    g_task_set_source_tag (task, seahorse_ldap_source_connect_async);
 
-       g_object_get (source, "key-server", &server, NULL);
-       g_return_if_fail (server && server[0]);
-       if ((pos = strchr (server, ':')) != NULL)
-               *pos = 0;
+    closure = g_new0 (ConnectClosure, 1);
+    g_task_set_task_data (task, closure, connect_closure_free);
 
-       seahorse_progress_prep_and_begin (cancellable, res, NULL);
+    g_object_get (source, "key-server", &server, NULL);
+    g_return_if_fail (server && server[0]);
+    if ((pos = strchr (server, ':')) != NULL)
+        *pos = 0;
 
-       /* If we have libsoup, try and resolve asynchronously */
-#ifdef WITH_SOUP
-       address = soup_address_new (server, LDAP_PORT);
-       seahorse_progress_update (cancellable, res, _("Resolving server address: %s"), server);
-
-       soup_address_resolve_async (address, NULL, cancellable,
-                                   on_address_resolved_complete,
-                                   g_object_ref (res));
-       g_object_unref (address);
+    seahorse_progress_prep_and_begin (cancellable, task, NULL);
 
+    /* If we have libsoup, try and resolve asynchronously */
+#ifdef WITH_SOUP
+    address = soup_address_new (server, LDAP_PORT);
+    seahorse_progress_update (cancellable, task,
+                              _("Resolving server address: %s"), server);
+
+    soup_address_resolve_async (address, NULL, cancellable,
+                                on_address_resolved_complete,
+                                g_steal_pointer (&task));
+    g_object_unref (address);
 #else /* !WITH_SOUP */
 
-       once_resolved_start_connect (source, res, server);
+    once_resolved_start_connect (source, task, server);
 
 #endif
-
-       g_free (server);
-       g_object_unref (res);
 }
 
 static LDAP *
@@ -718,58 +704,47 @@ seahorse_ldap_source_connect_finish (SeahorseLDAPSource *source,
                                      GAsyncResult *result,
                                      GError **error)
 {
-       source_connect_closure *closure;
-       LDAP *ldap;
-
-       g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (source),
-                             seahorse_ldap_source_connect_async), NULL);
+    g_return_val_if_fail (g_task_is_valid (result, source), NULL);
+    g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) ==
+                          seahorse_ldap_source_connect_async, NULL);
 
-       if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
-               return NULL;
-
-       closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
-       ldap = closure->ldap;
-       closure->ldap = NULL;
-       return ldap;
+    return g_task_propagate_pointer (G_TASK (result), error);
 }
 
 G_DEFINE_TYPE (SeahorseLDAPSource, seahorse_ldap_source, SEAHORSE_TYPE_SERVER_SOURCE);
 
-static void 
+static void
 seahorse_ldap_source_init (SeahorseLDAPSource *self)
 {
-
 }
 
 typedef struct {
-       GCancellable *cancellable;
-       gchar *filter;
-       LDAP *ldap;
-       GcrSimpleCollection *results;
-} source_search_closure;
+    char *filter;
+    LDAP *ldap;
+    GcrSimpleCollection *results;
+} SearchClosure;
 
 static void
-source_search_free (gpointer data)
+search_closure_free (gpointer data)
 {
-       source_search_closure *closure = data;
-       g_clear_object (&closure->cancellable);
-       g_clear_object (&closure->results);
-       g_free (closure->filter);
-       if (closure->ldap)
-               ldap_unbind_ext (closure->ldap, NULL, NULL);
-       g_free (closure);
+    SearchClosure *closure = data;
+    g_clear_object (&closure->results);
+    g_free (closure->filter);
+    if (closure->ldap)
+        ldap_unbind_ext (closure->ldap, NULL, NULL);
+    g_free (closure);
 }
 
 static const char *PGP_ATTRIBUTES[] = {
-       "pgpcertid",
-       "pgpuserid",
-       "pgprevoked",
-       "pgpdisabled",
-       "pgpkeycreatetime",
-       "pgpkeyexpiretime"
-       "pgpkeysize",
-       "pgpkeytype",
-       NULL
+    "pgpcertid",
+    "pgpuserid",
+    "pgprevoked",
+    "pgpdisabled",
+    "pgpkeycreatetime",
+    "pgpkeyexpiretime"
+    "pgpkeysize",
+    "pgpkeytype",
+    NULL
 };
 
 /* Add a key to the key source from an LDAP entry */
@@ -779,131 +754,127 @@ search_parse_key_from_ldap_entry (SeahorseLDAPSource *self,
                                   LDAP *ldap,
                                   LDAPMessage *res)
 {
-       const gchar *algo;
-       long int timestamp;
-       long int expires;
-       gchar *fpr, *fingerprint;
-       gchar *uidstr;
-       gboolean revoked;
-       gboolean disabled;
-       int length;
-
-       g_return_if_fail (ldap_msgtype (res) == LDAP_RES_SEARCH_ENTRY);
-
-       fpr = get_string_attribute (ldap, res, "pgpcertid");
-       uidstr = get_string_attribute (ldap, res, "pgpuserid");
-       revoked = get_boolean_attribute (ldap, res, "pgprevoked");
-       disabled = get_boolean_attribute (ldap, res, "pgpdisabled");
-       timestamp = get_date_attribute (ldap, res, "pgpkeycreatetime");
-       expires = get_date_attribute (ldap, res, "pgpkeyexpiretime");
-       algo = get_algo_attribute (ldap, res, "pgpkeytype");
-       length = get_int_attribute (ldap, res, "pgpkeysize");
-
-       if (fpr && uidstr) {
-               SeahorsePgpSubkey *subkey;
-               SeahorsePgpKey *key;
-               SeahorsePgpUid *uid;
-               GList *list;
-               guint flags;
-
-               /* Build up a subkey */
-               subkey = seahorse_pgp_subkey_new ();
-               seahorse_pgp_subkey_set_keyid (subkey, fpr);
-               fingerprint = seahorse_pgp_subkey_calc_fingerprint (fpr);
-               seahorse_pgp_subkey_set_fingerprint (subkey, fingerprint);
-               g_free (fingerprint);
-               seahorse_pgp_subkey_set_created (subkey, timestamp);
-               seahorse_pgp_subkey_set_expires (subkey, expires);
-               seahorse_pgp_subkey_set_algorithm (subkey, algo);
-               seahorse_pgp_subkey_set_length (subkey, length);
-
-               flags = SEAHORSE_FLAG_EXPORTABLE;
-               if (revoked)
-                       flags |= SEAHORSE_FLAG_REVOKED;
-               if (disabled)
-                       flags |= SEAHORSE_FLAG_DISABLED;
-               seahorse_pgp_subkey_set_flags (subkey, flags);
-
-               key = seahorse_pgp_key_new ();
-
-               /* Build up a uid */
-               uid = seahorse_pgp_uid_new (key, uidstr);
-               if (revoked)
-                       seahorse_pgp_uid_set_validity (uid, SEAHORSE_VALIDITY_REVOKED);
-
-               /* Now build them into a key */
-               list = g_list_prepend (NULL, uid);
-               seahorse_pgp_key_set_uids (key, list);
-               seahorse_object_list_free (list);
-               list = g_list_prepend (NULL, subkey);
-               seahorse_pgp_key_set_subkeys (key, list);
-               seahorse_object_list_free (list);
-               g_object_set (key,
-                             "object-flags", flags,
-                             "place", self,
-                             NULL);
-
-               seahorse_pgp_key_realize (key);
-               gcr_simple_collection_add (results, G_OBJECT (key));
-               g_object_unref (key);
-       }
-
-       g_free (fpr);
-       g_free (uidstr);
+    const char *algo;
+    long int timestamp;
+    long int expires;
+    g_autofree char *fpr = NULL;
+    g_autofree char *uidstr = NULL;
+    gboolean revoked;
+    gboolean disabled;
+    int length;
+
+    g_return_if_fail (ldap_msgtype (res) == LDAP_RES_SEARCH_ENTRY);
+
+    fpr = get_string_attribute (ldap, res, "pgpcertid");
+    uidstr = get_string_attribute (ldap, res, "pgpuserid");
+    revoked = get_boolean_attribute (ldap, res, "pgprevoked");
+    disabled = get_boolean_attribute (ldap, res, "pgpdisabled");
+    timestamp = get_date_attribute (ldap, res, "pgpkeycreatetime");
+    expires = get_date_attribute (ldap, res, "pgpkeyexpiretime");
+    algo = get_algo_attribute (ldap, res, "pgpkeytype");
+    length = get_int_attribute (ldap, res, "pgpkeysize");
+
+    if (fpr && uidstr) {
+        SeahorsePgpSubkey *subkey;
+        g_autoptr(SeahorsePgpKey) key = NULL;
+        g_autofree char *fingerprint = NULL;
+        SeahorsePgpUid *uid;
+        GList *list;
+        guint flags;
+
+        /* Build up a subkey */
+        subkey = seahorse_pgp_subkey_new ();
+        seahorse_pgp_subkey_set_keyid (subkey, fpr);
+        fingerprint = seahorse_pgp_subkey_calc_fingerprint (fpr);
+        seahorse_pgp_subkey_set_fingerprint (subkey, fingerprint);
+        seahorse_pgp_subkey_set_created (subkey, timestamp);
+        seahorse_pgp_subkey_set_expires (subkey, expires);
+        seahorse_pgp_subkey_set_algorithm (subkey, algo);
+        seahorse_pgp_subkey_set_length (subkey, length);
+
+        flags = SEAHORSE_FLAG_EXPORTABLE;
+        if (revoked)
+            flags |= SEAHORSE_FLAG_REVOKED;
+        if (disabled)
+            flags |= SEAHORSE_FLAG_DISABLED;
+        seahorse_pgp_subkey_set_flags (subkey, flags);
+
+        key = seahorse_pgp_key_new ();
+
+        /* Build up a uid */
+        uid = seahorse_pgp_uid_new (key, uidstr);
+        if (revoked)
+            seahorse_pgp_uid_set_validity (uid, SEAHORSE_VALIDITY_REVOKED);
+
+        /* Now build them into a key */
+        list = g_list_prepend (NULL, uid);
+        seahorse_pgp_key_set_uids (key, list);
+        seahorse_object_list_free (list);
+        list = g_list_prepend (NULL, subkey);
+        seahorse_pgp_key_set_subkeys (key, list);
+        seahorse_object_list_free (list);
+        g_object_set (key,
+                      "object-flags", flags,
+                      "place", self,
+                      NULL);
+
+        seahorse_pgp_key_realize (key);
+        gcr_simple_collection_add (results, G_OBJECT (key));
+    }
 }
 
 static gboolean
 on_search_search_completed (LDAPMessage *result,
                             gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       source_search_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
-       GError *error = NULL;
-       char *message;
-       int code;
-       int type;
-       int rc;
-
-       type = ldap_msgtype (result);
-       g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
-
-       /* An LDAP entry */
-       if (type == LDAP_RES_SEARCH_ENTRY) {
-               g_debug ("Retrieved Key Entry");
+    GTask *task = G_TASK (user_data);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_task_get_source_object (task));
+    SearchClosure *closure = g_task_get_task_data (task);
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    g_autoptr(GError) error = NULL;
+    int type;
+    int rc;
+    int code;
+    char *message;
+
+    type = ldap_msgtype (result);
+    g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
+
+    /* An LDAP entry */
+    if (type == LDAP_RES_SEARCH_ENTRY) {
+        g_debug ("Retrieved Key Entry");
 #ifdef WITH_DEBUG
-               dump_ldap_entry (closure->ldap, result);
+        dump_ldap_entry (closure->ldap, result);
 #endif
 
-               search_parse_key_from_ldap_entry (self, closure->results,
-                                                 closure->ldap, result);
-               return TRUE; /* keep calling this callback */
-
-       /* All entries done */
-       } else {
-               rc = ldap_parse_result (closure->ldap, result, &code, NULL,
-                                       &message, NULL, NULL, 0);
-               g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
-
-               /* Error codes that we ignore */
-               switch (code) {
-               case LDAP_SIZELIMIT_EXCEEDED:
-                       code = LDAP_SUCCESS;
-                       break;
-               };
-
-               /* Failure */
-               if (code != LDAP_SUCCESS)
-                       g_simple_async_result_set_error (res, LDAP_ERROR_DOMAIN,
-                                                        code, "%s", message);
-               else if (seahorse_ldap_source_propagate_error (self, code, &error))
-                       g_simple_async_result_take_error (res, error);
-
-               ldap_memfree (message);
-               seahorse_progress_end (closure->cancellable, res);
-               g_simple_async_result_complete (res);
-               return FALSE;
-       }
+        search_parse_key_from_ldap_entry (self, closure->results,
+                                          closure->ldap, result);
+        return G_SOURCE_CONTINUE;
+    }
+
+    /* All entries done */
+    rc = ldap_parse_result (closure->ldap, result, &code, NULL,
+                            &message, NULL, NULL, 0);
+    g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
+
+    /* Error codes that we ignore */
+    switch (code) {
+    case LDAP_SIZELIMIT_EXCEEDED:
+        code = LDAP_SUCCESS;
+        break;
+    };
+
+    if (code != LDAP_SUCCESS)
+        g_task_return_new_error (task, LDAP_ERROR_DOMAIN, code, "%s", message);
+    else if (seahorse_ldap_source_propagate_error (self, code, &error))
+        g_task_return_error (task, g_steal_pointer (&error));
+    else
+        g_task_return_boolean (task, TRUE);
+
+    ldap_memfree (message);
+    seahorse_progress_end (cancellable, task);
+
+    return G_SOURCE_REMOVE;
 }
 
 static void
@@ -911,79 +882,69 @@ on_search_connect_completed (GObject *source,
                              GAsyncResult *result,
                              gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       source_search_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
-       GError *error = NULL;
-       LDAPServerInfo *sinfo;
-       int ldap_op;
-       int rc;
-
-       closure->ldap = seahorse_ldap_source_connect_finish (SEAHORSE_LDAP_SOURCE (source),
-                                                            result, &error);
-       if (error != NULL) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete (res);
-               g_object_unref (res);
-               return;
-       }
-
-       sinfo = get_ldap_server_info (self, TRUE);
-
-       g_debug ("Searching Server ... base: %s, filter: %s",
-                sinfo->base_dn, closure->filter);
-
-       rc = ldap_search_ext (closure->ldap, sinfo->base_dn, LDAP_SCOPE_SUBTREE,
-                             closure->filter, (char **)PGP_ATTRIBUTES, 0,
-                             NULL, NULL, NULL, 0, &ldap_op);
-
-       if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete (res);
-
-       } else {
-               GSource *gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
-                                                    closure->cancellable);
-               g_source_set_callback (gsource, (GSourceFunc)on_search_search_completed,
-                                      g_object_ref (res), g_object_unref);
-               g_source_attach (gsource, g_main_context_default ());
-               g_source_unref (gsource);
-       }
-
-       g_object_unref (res);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
+    g_autoptr(GTask) task = G_TASK (user_data);
+    SearchClosure *closure = g_task_get_task_data (task);
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    g_autoptr(GError) error = NULL;
+    LDAPServerInfo *sinfo;
+    int ldap_op;
+    int rc;
+    g_autoptr(GSource) gsource = NULL;
+
+    closure->ldap = seahorse_ldap_source_connect_finish (self, result, &error);
+    if (error != NULL) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    sinfo = get_ldap_server_info (self, TRUE);
+
+    g_debug ("Searching Server ... base: %s, filter: %s",
+             sinfo->base_dn, closure->filter);
+
+    rc = ldap_search_ext (closure->ldap, sinfo->base_dn, LDAP_SCOPE_SUBTREE,
+                          closure->filter, (char **)PGP_ATTRIBUTES, 0,
+                          NULL, NULL, NULL, 0, &ldap_op);
+
+    if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op, cancellable);
+    g_source_set_callback (gsource, G_SOURCE_FUNC (on_search_search_completed),
+                           g_steal_pointer (&task), g_object_unref);
+    g_source_attach (gsource, g_main_context_default ());
 }
 
 
 static void
 seahorse_ldap_source_search_async (SeahorseServerSource *source,
-                                   const gchar *match,
+                                   const char *match,
                                    GcrSimpleCollection *results,
                                    GCancellable *cancellable,
                                    GAsyncReadyCallback callback,
                                    gpointer user_data)
 {
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
-       source_search_closure *closure;
-       GSimpleAsyncResult *res;
-       gchar *text;
-
-       res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
-                                        seahorse_ldap_source_search_async);
-       closure = g_new0 (source_search_closure, 1);
-       closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
-       closure->results = g_object_ref (results);
-       text = escape_ldap_value (match);
-       closure->filter = g_strdup_printf ("(pgpuserid=*%s*)", text);
-       g_free (text);
-       g_simple_async_result_set_op_res_gpointer (res, closure, source_search_free);
-
-       seahorse_progress_prep_and_begin (closure->cancellable, res, NULL);
-
-       seahorse_ldap_source_connect_async (self, cancellable,
-                                           on_search_connect_completed,
-                                           g_object_ref (res));
-
-       g_object_unref (res);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
+    SearchClosure *closure;
+    g_autoptr(GTask) task = NULL;
+    g_autofree char *text = NULL;
+
+    task = g_task_new (source, cancellable, callback, user_data);
+    g_task_set_source_tag (task, seahorse_ldap_source_search_async);
+    closure = g_new0 (SearchClosure, 1);
+    closure->results = g_object_ref (results);
+    text = escape_ldap_value (match);
+    closure->filter = g_strdup_printf ("(pgpuserid=*%s*)", text);
+    g_task_set_task_data (task, closure, search_closure_free);
+
+    seahorse_progress_prep_and_begin (cancellable, task, NULL);
+
+    seahorse_ldap_source_connect_async (self, cancellable,
+                                        on_search_connect_completed,
+                                        g_steal_pointer (&task));
 }
 
 static gboolean
@@ -991,130 +952,119 @@ seahorse_ldap_source_search_finish (SeahorseServerSource *source,
                                     GAsyncResult *result,
                                     GError **error)
 {
-       g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (source),
-                             seahorse_ldap_source_search_async), FALSE);
-
-       if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
-               return FALSE;
+    g_return_val_if_fail (SEAHORSE_IS_LDAP_SOURCE (source), FALSE);
+    g_return_val_if_fail (g_task_is_valid (result, source), FALSE);
 
-       return TRUE;
+    return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 typedef struct {
-       GPtrArray *keydata;
-       gint current_index;
-       GCancellable *cancellable;
-       LDAP *ldap;
-} source_import_closure;
+    GPtrArray *keydatas;
+    int current_index;
+    LDAP *ldap;
+} ImportClosure;
 
 static void
-source_import_free (gpointer data)
+import_closure_free (gpointer data)
 {
-       source_import_closure *closure = data;
-       g_ptr_array_free (closure->keydata, TRUE);
-       g_clear_object (&closure->cancellable);
-       if (closure->ldap)
-               ldap_unbind_ext (closure->ldap, NULL, NULL);
-       g_free (closure);
+    ImportClosure *closure = data;
+    g_ptr_array_free (closure->keydatas, TRUE);
+    if (closure->ldap)
+        ldap_unbind_ext (closure->ldap, NULL, NULL);
+    g_free (closure);
 }
 
-static void       import_send_key       (SeahorseLDAPSource *self,
-                                         GSimpleAsyncResult *res);
+static void import_send_key (SeahorseLDAPSource *self, GTask *task);
 
 /* Called when results come in for a key send */
 static gboolean
 on_import_add_completed (LDAPMessage *result,
                          gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       source_import_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (user_data));
-       GError *error = NULL;
-       char *message;
-       int code;
-       int rc;
-
-       g_return_val_if_fail (ldap_msgtype (result) == LDAP_RES_ADD, FALSE);
-
-       rc = ldap_parse_result (closure->ldap, result, &code, NULL,
-                               &message, NULL, NULL, 0);
-       g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
-
-       /* TODO: Somehow communicate this to the user */
-       if (code == LDAP_ALREADY_EXISTS)
-               code = LDAP_SUCCESS;
-
-       ldap_memfree (message);
-
-       if (seahorse_ldap_source_propagate_error (self, code, &error)) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete (res);
-               return FALSE; /* don't call for this source again */
-       }
-
-       import_send_key (self, res);
-       return FALSE; /* don't call for this source again */
+    GTask *task = G_TASK (user_data);
+    ImportClosure *closure = g_task_get_task_data (task);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_task_get_source_object (task));
+    GError *error = NULL;
+    char *message;
+    int code;
+    int rc;
+
+    g_return_val_if_fail (ldap_msgtype (result) == LDAP_RES_ADD, FALSE);
+
+    rc = ldap_parse_result (closure->ldap, result, &code, NULL,
+                            &message, NULL, NULL, 0);
+    g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
+
+    /* TODO: Somehow communicate this to the user */
+    if (code == LDAP_ALREADY_EXISTS)
+        code = LDAP_SUCCESS;
+
+    ldap_memfree (message);
+
+    if (seahorse_ldap_source_propagate_error (self, code, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return G_SOURCE_REMOVE;
+    }
+
+    import_send_key (self, task);
+    return G_SOURCE_REMOVE;
 }
 
 static void
-import_send_key (SeahorseLDAPSource *self,
-                 GSimpleAsyncResult *res)
+import_send_key (SeahorseLDAPSource *self, GTask *task)
 {
-       source_import_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       LDAPServerInfo *sinfo;
-       gchar *base;
-       LDAPMod mod;
-       LDAPMod *attrs[2];
-       char *values[2];
-       GSource *gsource;
-       GError *error = NULL;
-       gchar *keydata;
-       int ldap_op;
-       int rc;
-
-       if (closure->current_index >= 0) {
-               keydata = closure->keydata->pdata[closure->current_index];
-               seahorse_progress_end (closure->cancellable, keydata);
-       }
-
-       closure->current_index++;
-
-       /* All done, complete operation */
-       if (closure->current_index == (gint)closure->keydata->len) {
-               g_simple_async_result_complete (res);
-               return;
-       }
-
-       keydata = closure->keydata->pdata[closure->current_index];
-       seahorse_progress_begin (closure->cancellable, keydata);
-       values[0] = keydata;
-       values[1] = NULL;
-
-       sinfo = get_ldap_server_info (self, TRUE);
-       memset (&mod, 0, sizeof (mod));
-       mod.mod_op = LDAP_MOD_ADD;
-       mod.mod_type = sinfo->key_attr;
-       mod.mod_values = values;
-
-       attrs[0] = &mod;
-       attrs[1] = NULL;
-
-       base = g_strdup_printf ("pgpCertid=virtual,%s", sinfo->base_dn);
-       rc = ldap_add_ext (closure->ldap, base, attrs, NULL, NULL, &ldap_op);
-
-       g_free (base);
-
-       if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
-               g_simple_async_result_complete (res);
-               return;
-       }
-
-       gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
-                                            closure->cancellable);
-       g_source_set_callback (gsource, (GSourceFunc)on_import_add_completed,
-                              g_object_ref (res), g_object_unref);
-       g_source_attach (gsource, g_main_context_default ());
-       g_source_unref (gsource);
+    ImportClosure *closure = g_task_get_task_data (task);
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    LDAPServerInfo *sinfo;
+    g_autofree char *base = NULL;
+    LDAPMod mod;
+    LDAPMod *attrs[2];
+    char *values[2];
+    g_autoptr(GSource) gsource = NULL;
+    GError *error = NULL;
+    const char *keydata;
+    int ldap_op;
+    int rc;
+
+    if (closure->current_index >= 0) {
+        keydata = closure->keydatas->pdata[closure->current_index];
+        seahorse_progress_end (cancellable, keydata);
+    }
+
+    closure->current_index++;
+
+    /* All done, complete operation */
+    if (closure->current_index == (int)closure->keydatas->len) {
+        g_task_return_boolean (task, TRUE);
+        return;
+    }
+
+    keydata = closure->keydatas->pdata[closure->current_index];
+    seahorse_progress_begin (cancellable, keydata);
+    values[0] = keydata;
+    values[1] = NULL;
+
+    sinfo = get_ldap_server_info (self, TRUE);
+    memset (&mod, 0, sizeof (mod));
+    mod.mod_op = LDAP_MOD_ADD;
+    mod.mod_type = sinfo->key_attr;
+    mod.mod_values = values;
+
+    attrs[0] = &mod;
+    attrs[1] = NULL;
+
+    base = g_strdup_printf ("pgpCertid=virtual,%s", sinfo->base_dn);
+    rc = ldap_add_ext (closure->ldap, base, attrs, NULL, NULL, &ldap_op);
+
+    if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op, cancellable);
+    g_source_set_callback (gsource, G_SOURCE_FUNC (on_import_add_completed),
+                           g_object_ref (task), g_object_unref);
+    g_source_attach (gsource, g_main_context_default ());
 }
 
 static void
@@ -1122,20 +1072,18 @@ on_import_connect_completed (GObject *source,
                              GAsyncResult *result,
                              gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       source_import_closure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       GError *error = NULL;
-
-       closure->ldap = seahorse_ldap_source_connect_finish (SEAHORSE_LDAP_SOURCE (source),
-                                                            result, &error);
-       if (error != NULL) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete (res);
-       } else {
-               import_send_key (SEAHORSE_LDAP_SOURCE (source), res);
-       }
-
-       g_object_unref (res);
+    g_autoptr(GTask) task = G_TASK (user_data);
+    ImportClosure *closure = g_task_get_task_data (task);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
+    g_autoptr(GError) error = NULL;
+
+    closure->ldap = seahorse_ldap_source_connect_finish (self, result, &error);
+    if (error != NULL) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    import_send_key (self, task);
 }
 
 static void
@@ -1145,39 +1093,36 @@ seahorse_ldap_source_import_async (SeahorseServerSource *source,
                                    GAsyncReadyCallback callback,
                                    gpointer user_data)
 {
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
-       source_import_closure *closure;
-       GSimpleAsyncResult *res;
-       gchar *keydata;
-       guint len;
-
-       res = g_simple_async_result_new (G_OBJECT (source), callback, user_data,
-                                        seahorse_ldap_source_import_async);
-       closure = g_new0 (source_import_closure, 1);
-       closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
-       closure->current_index = -1;
-       g_simple_async_result_set_op_res_gpointer (res, closure, source_import_free);
-
-       closure->keydata =g_ptr_array_new_with_free_func (g_free);
-       for (;;) {
-               GString *buf = g_string_sized_new (2048);
-               len = seahorse_util_read_data_block (buf, input, "-----BEGIN PGP PUBLIC KEY BLOCK-----",
-                                                    "-----END PGP PUBLIC KEY BLOCK-----");
-               if (len > 0) {
-                       keydata = g_string_free (buf, FALSE);
-                       g_ptr_array_add (closure->keydata, keydata);
-                       seahorse_progress_prep (closure->cancellable, keydata, NULL);
-               } else {
-                       g_string_free (buf, TRUE);
-                       break;
-               }
-       }
-
-       seahorse_ldap_source_connect_async (self, cancellable,
-                                           on_import_connect_completed,
-                                           g_object_ref (res));
-
-       g_object_unref (res);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
+    g_autoptr(GTask) task = NULL;
+    ImportClosure *closure;
+
+    task = g_task_new (source, cancellable, callback, user_data);
+    g_task_set_source_tag (task, seahorse_ldap_source_import_async);
+
+    closure = g_new0 (ImportClosure, 1);
+    closure->current_index = -1;
+    g_task_set_task_data (task, closure, import_closure_free);
+
+    closure->keydatas = g_ptr_array_new_with_free_func (g_free);
+    for (;;) {
+        g_autoptr(GString) buf = g_string_sized_new (2048);
+        guint len;
+        g_autofree char *keydata = NULL;
+
+        len = seahorse_util_read_data_block (buf, input, "-----BEGIN PGP PUBLIC KEY BLOCK-----",
+                                             "-----END PGP PUBLIC KEY BLOCK-----");
+        if (len <= 0)
+            break;
+
+        keydata = g_string_free (g_steal_pointer (&buf), FALSE);
+        seahorse_progress_prep (cancellable, keydata, NULL);
+        g_ptr_array_add (closure->keydatas, g_steal_pointer (&keydata));
+    }
+
+    seahorse_ldap_source_connect_async (self, cancellable,
+                                        on_import_connect_completed,
+                                        g_steal_pointer (&task));
 }
 
 static GList *
@@ -1185,159 +1130,152 @@ seahorse_ldap_source_import_finish (SeahorseServerSource *source,
                                     GAsyncResult *result,
                                     GError **error)
 {
-       g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (source),
-                             seahorse_ldap_source_import_async), NULL);
+    g_return_val_if_fail (g_task_is_valid (result, source), NULL);
+    g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) ==
+                          seahorse_ldap_source_import_async, NULL);
 
-       if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
-               return NULL;
+    if (!g_task_propagate_boolean (G_TASK (result), error))
+        return NULL;
 
-       /* We don't know the keys that were imported, since this is a server */
-       return NULL;
+    /* We don't know the keys that were imported, since this is a server */
+    return NULL;
 }
 
 typedef struct {
-       GPtrArray *fingerprints;
-       gint current_index;
-       GString *data;
-       GCancellable *cancellable;
-       LDAP *ldap;
+    GPtrArray *fingerprints;
+    int current_index;
+    GString *data;
+    LDAP *ldap;
 } ExportClosure;
 
 static void
 export_closure_free (gpointer data)
 {
-       ExportClosure *closure = data;
-       g_ptr_array_free (closure->fingerprints, TRUE);
-       if (closure->data)
-               g_string_free (closure->data, TRUE);
-       g_clear_object (&closure->cancellable);
-       if (closure->ldap)
-               ldap_unbind_ext (closure->ldap, NULL, NULL);
-       g_free (closure);
+    ExportClosure *closure = data;
+    g_ptr_array_free (closure->fingerprints, TRUE);
+    if (closure->data)
+        g_string_free (closure->data, TRUE);
+    if (closure->ldap)
+        ldap_unbind_ext (closure->ldap, NULL, NULL);
+    g_free (closure);
 }
 
 static void     export_retrieve_key     (SeahorseLDAPSource *self,
-                                         GSimpleAsyncResult *res);
+                                         GTask *task);
 
 static gboolean
 on_export_search_completed (LDAPMessage *result,
                             gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       ExportClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_async_result_get_source_object (G_ASYNC_RESULT 
(res)));
-       LDAPServerInfo *sinfo;
-       char *message;
-       GError *error = NULL;
-       gchar *key;
-       int code;
-       int type;
-       int rc;
-
-       type = ldap_msgtype (result);
-       g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
-       sinfo = get_ldap_server_info (self, TRUE);
-
-       /* An LDAP Entry */
-       if (type == LDAP_RES_SEARCH_ENTRY) {
-
-               g_debug ("Server Info Result");
+    GTask *task = G_TASK (user_data);
+    ExportClosure *closure = g_task_get_task_data (task);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (g_task_get_source_object (task));
+    LDAPServerInfo *sinfo;
+    char *message;
+    GError *error = NULL;
+    int code;
+    int type;
+    int rc;
+
+    type = ldap_msgtype (result);
+    g_return_val_if_fail (type == LDAP_RES_SEARCH_ENTRY || type == LDAP_RES_SEARCH_RESULT, FALSE);
+    sinfo = get_ldap_server_info (self, TRUE);
+
+    /* An LDAP Entry */
+    if (type == LDAP_RES_SEARCH_ENTRY) {
+        g_autofree char *key = NULL;
+
+        g_debug ("Server Info Result");
 #ifdef WITH_DEBUG
-               dump_ldap_entry (closure->ldap, result);
+        dump_ldap_entry (closure->ldap, result);
 #endif
 
-               key = get_string_attribute (closure->ldap, result, sinfo->key_attr);
-
-               if (key == NULL) {
-                       g_warning ("key server missing pgp key data");
-                       seahorse_ldap_source_propagate_error (self, LDAP_NO_SUCH_OBJECT, &error);
-                       g_simple_async_result_take_error (res, error);
-                       g_simple_async_result_complete (res);
-                       return FALSE;
-               }
+        key = get_string_attribute (closure->ldap, result, sinfo->key_attr);
+        if (key == NULL) {
+            g_warning ("key server missing pgp key data");
+            seahorse_ldap_source_propagate_error (self, LDAP_NO_SUCH_OBJECT, &error);
+            g_task_return_error (task, g_steal_pointer (&error));
+            return G_SOURCE_REMOVE;
+        }
 
-               g_string_append (closure->data, key);
-               g_string_append_c (closure->data, '\n');
+        g_string_append (closure->data, key);
+        g_string_append_c (closure->data, '\n');
 
-               g_free (key);
-               return TRUE;
+        return G_SOURCE_CONTINUE;
+    }
 
-       /* No more entries, result */
-       } else {
-               rc = ldap_parse_result (closure->ldap, result, &code, NULL,
-                                       &message, NULL, NULL, 0);
-               g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
+    /* No more entries, result */
+    rc = ldap_parse_result (closure->ldap, result, &code, NULL,
+                            &message, NULL, NULL, 0);
+    g_return_val_if_fail (rc == LDAP_SUCCESS, FALSE);
 
-               if (seahorse_ldap_source_propagate_error (self, code, &error)) {
-                       g_simple_async_result_take_error (res, error);
-                       g_simple_async_result_complete (res);
-                       return FALSE;
-               }
+    if (seahorse_ldap_source_propagate_error (self, code, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return G_SOURCE_REMOVE;
+    }
 
-               ldap_memfree (message);
+    ldap_memfree (message);
 
-               /* Process more keys if possible */
-               export_retrieve_key (self, res);
-               return FALSE;
-       }
+    /* Process more keys if possible */
+    export_retrieve_key (self, task);
+    return G_SOURCE_REMOVE;
 }
 
 static void
 export_retrieve_key (SeahorseLDAPSource *self,
-                     GSimpleAsyncResult *res)
+                     GTask *task)
 {
-       ExportClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       LDAPServerInfo *sinfo;
-       gchar *filter;
-       char *attrs[2];
-       GSource *gsource;
-       const gchar *fingerprint;
-       GError *error = NULL;
-       int length, rc;
-       int ldap_op;
-
-       if (closure->current_index > 0) {
-               fingerprint = closure->fingerprints->pdata[closure->current_index];
-               seahorse_progress_end (closure->cancellable, fingerprint);
-       }
-
-       closure->current_index++;
-
-       /* All done, complete operation */
-       if (closure->current_index == (gint)closure->fingerprints->len) {
-               g_simple_async_result_complete (res);
-               return;
-       }
-
-       fingerprint = closure->fingerprints->pdata[closure->current_index];
-       seahorse_progress_begin (closure->cancellable, fingerprint);
-       length = strlen (fingerprint);
-       if (length > 16)
-               fingerprint += (length - 16);
-
-       filter = g_strdup_printf ("(pgpcertid=%.16s)", fingerprint);
-       sinfo = get_ldap_server_info (self, TRUE);
-
-       attrs[0] = sinfo->key_attr;
-       attrs[1] = NULL;
-
-       rc = ldap_search_ext (closure->ldap, sinfo->base_dn, LDAP_SCOPE_SUBTREE,
-                             filter, attrs, 0,
-                             NULL, NULL, NULL, 0, &ldap_op);
-       g_free (filter);
-
-       if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete (res);
-               return;
-       }
-
-       gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op,
-                                            closure->cancellable);
-       g_source_set_callback (gsource, (GSourceFunc)on_export_search_completed,
-                              g_object_ref (res), g_object_unref);
-       g_source_attach (gsource, g_main_context_default ());
-       g_source_unref (gsource);
+    ExportClosure *closure = g_task_get_task_data (task);
+    GCancellable *cancellable = g_task_get_cancellable (task);
+    LDAPServerInfo *sinfo;
+    g_autofree char *filter = NULL;
+    char *attrs[2];
+    g_autoptr(GSource) gsource = NULL;
+    const char *fingerprint;
+    g_autoptr(GError) error = NULL;
+    int length, rc;
+    int ldap_op;
+
+    if (closure->current_index > 0) {
+        fingerprint = g_ptr_array_index (closure->fingerprints,
+                                         closure->current_index);
+        seahorse_progress_end (cancellable, fingerprint);
+    }
+
+    closure->current_index++;
+
+    /* All done, complete operation */
+    if (closure->current_index == (int) closure->fingerprints->len) {
+        g_task_return_boolean (task, TRUE);
+        return;
+    }
+
+    fingerprint = g_ptr_array_index (closure->fingerprints,
+                                     closure->current_index);
+    seahorse_progress_begin (cancellable, fingerprint);
+    length = strlen (fingerprint);
+    if (length > 16)
+        fingerprint += (length - 16);
+
+    filter = g_strdup_printf ("(pgpcertid=%.16s)", fingerprint);
+    sinfo = get_ldap_server_info (self, TRUE);
+
+    attrs[0] = sinfo->key_attr;
+    attrs[1] = NULL;
+
+    rc = ldap_search_ext (closure->ldap, sinfo->base_dn, LDAP_SCOPE_SUBTREE,
+                          filter, attrs, 0,
+                          NULL, NULL, NULL, 0, &ldap_op);
+
+    if (seahorse_ldap_source_propagate_error (self, rc, &error)) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    gsource = seahorse_ldap_gsource_new (closure->ldap, ldap_op, cancellable);
+    g_source_set_callback (gsource, (GSourceFunc)on_export_search_completed,
+                           g_object_ref (task), g_object_unref);
+    g_source_attach (gsource, g_main_context_default ());
 }
 
 static void
@@ -1345,54 +1283,49 @@ on_export_connect_completed (GObject *source,
                              GAsyncResult *result,
                              gpointer user_data)
 {
-       GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
-       ExportClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
-       GError *error = NULL;
-
-       closure->ldap = seahorse_ldap_source_connect_finish (SEAHORSE_LDAP_SOURCE (source),
-                                                            result, &error);
-       if (error != NULL) {
-               g_simple_async_result_take_error (res, error);
-               g_simple_async_result_complete (res);
-       } else {
-               export_retrieve_key (SEAHORSE_LDAP_SOURCE (source), res);
-       }
-
-       g_object_unref (res);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
+    g_autoptr(GTask) task = G_TASK (user_data);
+    ExportClosure *closure = g_task_get_task_data (task);
+    g_autoptr(GError) error = NULL;
+
+    closure->ldap = seahorse_ldap_source_connect_finish (self, result, &error);
+    if (error != NULL) {
+        g_task_return_error (task, g_steal_pointer (&error));
+        return;
+    }
+
+    export_retrieve_key (self, task);
 }
 
 static void
 seahorse_ldap_source_export_async (SeahorseServerSource *source,
-                                   const gchar **keyids,
+                                   const char **keyids,
                                    GCancellable *cancellable,
                                    GAsyncReadyCallback callback,
                                    gpointer user_data)
 {
-       SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
-       ExportClosure *closure;
-       GSimpleAsyncResult *res;
-       gchar *fingerprint;
-       gint i;
-
-       res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
-                                        seahorse_ldap_source_export_async);
-       closure = g_new0 (ExportClosure, 1);
-       closure->data = g_string_sized_new (1024);
-       closure->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
-       closure->fingerprints = g_ptr_array_new_with_free_func (g_free);
-       for (i = 0; keyids[i] != NULL; i++) {
-               fingerprint = g_strdup (keyids[i]);
-               g_ptr_array_add (closure->fingerprints, fingerprint);
-               seahorse_progress_prep (closure->cancellable, fingerprint, NULL);
-       }
-       closure->current_index = -1;
-       g_simple_async_result_set_op_res_gpointer (res, closure, export_closure_free);
-
-       seahorse_ldap_source_connect_async (self, cancellable,
-                                           on_export_connect_completed,
-                                           g_object_ref (res));
-
-       g_object_unref (res);
+    SeahorseLDAPSource *self = SEAHORSE_LDAP_SOURCE (source);
+    ExportClosure *closure;
+    g_autoptr(GTask) task = NULL;
+
+    task = g_task_new (self, cancellable, callback, user_data);
+    g_task_set_source_tag (task, seahorse_ldap_source_export_async);
+
+    closure = g_new0 (ExportClosure, 1);
+    closure->data = g_string_sized_new (1024);
+    closure->fingerprints = g_ptr_array_new_with_free_func (g_free);
+    for (int i = 0; keyids[i] != NULL; i++) {
+        char *fingerprint = g_strdup (keyids[i]);
+
+        g_ptr_array_add (closure->fingerprints, fingerprint);
+        seahorse_progress_prep (cancellable, fingerprint, NULL);
+    }
+    closure->current_index = -1;
+    g_task_set_task_data (task, closure, export_closure_free);
+
+    seahorse_ldap_source_connect_async (self, cancellable,
+                                        on_export_connect_completed,
+                                        g_steal_pointer (&task));
 }
 
 static gpointer
@@ -1401,82 +1334,80 @@ seahorse_ldap_source_export_finish (SeahorseServerSource *source,
                                     gsize *size,
                                     GError **error)
 {
-       ExportClosure *closure;
-       gpointer output;
+    ExportClosure *closure;
+    gpointer output;
 
-       g_return_val_if_fail (size != NULL, NULL);
-       g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (source),
-                             seahorse_ldap_source_export_async), NULL);
+    g_return_val_if_fail (size != NULL, NULL);
+    g_return_val_if_fail (g_task_is_valid (result, source), NULL);
 
-       if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error))
-               return NULL;
+    if (!g_task_propagate_boolean (G_TASK (result), error))
+        return NULL;
 
-       closure = g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (result));
-       *size = closure->data->len;
-       output = g_string_free (closure->data, FALSE);
-       closure->data = NULL;
-       return output;
+    closure = g_task_get_task_data (G_TASK (result));
+    *size = closure->data->len;
+    output = g_string_free (closure->data, FALSE);
+    closure->data = NULL;
+    return output;
 }
 
 /* Initialize the basic class stuff */
 static void
 seahorse_ldap_source_class_init (SeahorseLDAPSourceClass *klass)
 {
-       SeahorseServerSourceClass *server_class = SEAHORSE_SERVER_SOURCE_CLASS (klass);
+    SeahorseServerSourceClass *server_class = SEAHORSE_SERVER_SOURCE_CLASS (klass);
 
-       server_class->search_async = seahorse_ldap_source_search_async;
-       server_class->search_finish = seahorse_ldap_source_search_finish;
-       server_class->export_async = seahorse_ldap_source_export_async;
-       server_class->export_finish = seahorse_ldap_source_export_finish;
-       server_class->import_async = seahorse_ldap_source_import_async;
-       server_class->import_finish = seahorse_ldap_source_import_finish;
+    server_class->search_async = seahorse_ldap_source_search_async;
+    server_class->search_finish = seahorse_ldap_source_search_finish;
+    server_class->export_async = seahorse_ldap_source_export_async;
+    server_class->export_finish = seahorse_ldap_source_export_finish;
+    server_class->import_async = seahorse_ldap_source_import_async;
+    server_class->import_finish = seahorse_ldap_source_import_finish;
 
-       seahorse_servers_register_type ("ldap", _("LDAP Key Server"), seahorse_ldap_is_valid_uri);
+    seahorse_servers_register_type ("ldap", _("LDAP Key Server"), seahorse_ldap_is_valid_uri);
 }
 
 /**
  * seahorse_ldap_source_new
- * @uri: The server to connect to 
- * 
+ * @uri: The server to connect to
+ *
  * Creates a new key source for an LDAP PGP server.
- * 
+ *
  * Returns: A new LDAP Key Source
  */
-SeahorseLDAPSource*   
-seahorse_ldap_source_new (const gchar* uri, const gchar *host)
+SeahorseLDAPSource*
+seahorse_ldap_source_new (const char* uri, const char *host)
 {
     g_return_val_if_fail (seahorse_ldap_is_valid_uri (uri), NULL);
     g_return_val_if_fail (host && *host, NULL);
-    return g_object_new (SEAHORSE_TYPE_LDAP_SOURCE, "key-server", host, 
+    return g_object_new (SEAHORSE_TYPE_LDAP_SOURCE, "key-server", host,
                          "uri", uri, NULL);
 }
 
 /**
  * seahorse_ldap_is_valid_uri
  * @uri: The uri to check
- * 
+ *
  * Returns: Whether the passed uri is valid for an ldap key source
  */
-gboolean              
-seahorse_ldap_is_valid_uri (const gchar *uri)
+gboolean
+seahorse_ldap_is_valid_uri (const char *uri)
 {
     LDAPURLDesc *url;
     int r;
-    
+
     g_return_val_if_fail (uri && *uri, FALSE);
-    
+
     r = ldap_url_parse (uri, &url);
     if (r == LDAP_URL_SUCCESS) {
-        
         /* Some checks to make sure it's a simple URI */
-        if (!(url->lud_host && url->lud_host[0]) || 
-            (url->lud_dn && url->lud_dn[0]) || 
+        if (!(url->lud_host && url->lud_host[0]) ||
+            (url->lud_dn && url->lud_dn[0]) ||
             (url->lud_attrs || url->lud_attrs))
             r = LDAP_URL_ERR_PARAM;
-        
+
         ldap_free_urldesc (url);
     }
-        
+
     return r == LDAP_URL_SUCCESS;
 }
 
diff --git a/pgp/seahorse-ldap-source.h b/pgp/seahorse-ldap-source.h
index 0fdad48e..f338c67a 100644
--- a/pgp/seahorse-ldap-source.h
+++ b/pgp/seahorse-ldap-source.h
@@ -35,9 +35,9 @@ G_DECLARE_FINAL_TYPE (SeahorseLDAPSource, seahorse_ldap_source,
                       SEAHORSE, LDAP_SOURCE,
                       SeahorseServerSource)
 
-SeahorseLDAPSource*   seahorse_ldap_source_new     (const gchar *uri,
-                                                    const gchar *host);
+SeahorseLDAPSource*   seahorse_ldap_source_new     (const char *uri,
+                                                    const char *host);
 
-gboolean              seahorse_ldap_is_valid_uri   (const gchar *uri);
+gboolean              seahorse_ldap_is_valid_uri   (const char *uri);
 
 #endif /* WITH_LDAP */


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