GNOME.org
 

[gcr: 3/4] gck-call: Make the API more consistent, making it always handle GckCall pointers


commit 58e8419257be6b63b600196c78f35a903d50e57b
Author: Marco Trevisan (Treviño) <mail 3v1n0 net>
Date:   Mon Nov 16 17:51:54 2020 +0100

    gck-call: Make the API more consistent, making it always handle GckCall pointers
    
    Never return or expect arguments as paramter for gck_call_* functions,
    instead use gck_call_get_arguments to interact with them when needed

 gck/gck-call.c       |  21 +++++-----
 gck/gck-enumerator.c |   8 ++--
 gck/gck-module.c     |   6 ++-
 gck/gck-modules.c    |   8 ++--
 gck/gck-object.c     |  36 ++++++++++------
 gck/gck-private.h    |  10 ++---
 gck/gck-session.c    | 115 ++++++++++++++++++++++++++++++++++++---------------
 7 files changed, 133 insertions(+), 71 deletions(-)
---
diff --git a/gck/gck-call.c b/gck/gck-call.c
index 61ec603..842e5c2 100644
--- a/gck/gck-call.c
+++ b/gck/gck-call.c
@@ -154,7 +154,6 @@ _gck_call_finalize (GObject *obj)
        call->module = NULL;
 
        g_clear_object (&call->task);
-       g_clear_object (&call->args->call);
 
        if (call->destroy)
                (call->destroy) (call->args);
@@ -215,7 +214,7 @@ _gck_call_sync (gpointer object, gpointer perform, gpointer complete,
        return FALSE;
 }
 
-gpointer
+GckCall*
 _gck_call_async_prep (gpointer object, gpointer perform, gpointer complete,
                        gsize args_size, gpointer destroy)
 {
@@ -240,13 +239,12 @@ _gck_call_async_prep (gpointer object, gpointer perform, gpointer complete,
 
        /* Hook the two together */
        call->args = args;
-       call->args->call = call;
 
        /* Setup call object if available */
        if (object != NULL)
                _gck_call_async_object (call, object);
 
-       return args;
+       return call;
 }
 
 void
@@ -267,23 +265,24 @@ _gck_call_async_object (GckCall *call, gpointer object)
 }
 
 GckCall*
-_gck_call_async_ready (gpointer data, gpointer cb_object,
+_gck_call_async_ready (GckCall *call, gpointer cb_object,
                        GCancellable *cancellable, GAsyncReadyCallback callback,
                        gpointer user_data)
 {
-       GckArguments *args = (GckArguments*)data;
-       GckCall* call;
        GTask* task;
 
-       g_assert (GCK_IS_CALL (args->call));
+       g_assert (GCK_IS_CALL (call));
+       g_assert (call->args && "GckCall not prepared");
        g_assert (!cb_object || G_IS_OBJECT (cb_object));
 
-       call = g_steal_pointer (&args->call);
+       g_object_ref (call);
+
        task = g_task_new (cb_object, cancellable, callback, user_data);
        g_task_set_task_data (task, call, g_object_unref);
        g_set_object (&call->task, task);
 
        g_object_unref (task);
+       g_object_unref (call);
 
        return call;
 }
@@ -299,11 +298,11 @@ _gck_call_async_go (GckCall *call)
 }
 
 void
-_gck_call_async_ready_go (gpointer data, gpointer cb_object,
+_gck_call_async_ready_go (GckCall *call, gpointer cb_object,
                            GCancellable *cancellable,
                           GAsyncReadyCallback callback, gpointer user_data)
 {
-       GckCall *call = _gck_call_async_ready (data, cb_object, cancellable, callback, user_data);
+       _gck_call_async_ready (call, cb_object, cancellable, callback, user_data);
        _gck_call_async_go (call);
 }
 
diff --git a/gck/gck-enumerator.c b/gck/gck-enumerator.c
index 7db066b..16a8923 100644
--- a/gck/gck-enumerator.c
+++ b/gck/gck-enumerator.c
@@ -1296,6 +1296,7 @@ gck_enumerator_next_async (GckEnumerator *self, gint max_objects, GCancellable *
 {
        GckEnumeratorState *state;
        EnumerateNext *args;
+       GckCall *call;
 
        g_return_if_fail (GCK_IS_ENUMERATOR (self));
        g_return_if_fail (max_objects == -1 || max_objects > 0);
@@ -1306,12 +1307,13 @@ gck_enumerator_next_async (GckEnumerator *self, gint max_objects, GCancellable *
        state = check_out_enumerator_state (self);
        g_return_if_fail (state != NULL);
 
-       args =  _gck_call_async_prep (NULL, perform_enumerate_next, NULL,
-                                      sizeof (*args), free_enumerate_next);
+       call = _gck_call_async_prep (NULL, perform_enumerate_next, NULL,
+                                    sizeof (*args), free_enumerate_next);
+       args = _gck_call_get_arguments (call);
        args->want_objects = max_objects <= 0 ? G_MAXINT : max_objects;
 
        args->state = state;
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
        g_object_unref (self);
 }
 
diff --git a/gck/gck-module.c b/gck/gck-module.c
index d9e872a..1fa7584 100644
--- a/gck/gck-module.c
+++ b/gck/gck-module.c
@@ -417,14 +417,16 @@ gck_module_initialize_async (const gchar *path,
                              gpointer user_data)
 {
        Initialize *args;
+       GckCall *call;
 
        g_return_if_fail (path != NULL);
 
-       args =  _gck_call_async_prep (NULL, perform_initialize, NULL,
+       call =  _gck_call_async_prep (NULL, perform_initialize, NULL,
                                      sizeof (*args), free_initialize);
+       args = _gck_call_get_arguments (call);
        args->path = g_strdup (path);
 
-       _gck_call_async_ready_go (args, NULL, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, NULL, cancellable, callback, user_data);
 }
 
 /**
diff --git a/gck/gck-modules.c b/gck/gck-modules.c
index 13fab9b..63a2e07 100644
--- a/gck/gck-modules.c
+++ b/gck/gck-modules.c
@@ -121,12 +121,12 @@ gck_modules_initialize_registered_async (GCancellable *cancellable,
                                          GAsyncReadyCallback callback,
                                          gpointer user_data)
 {
-       InitializeRegistered *args;
+       GckCall *call;
 
-       args =  _gck_call_async_prep (NULL, perform_initialize_registered, NULL,
-                                     sizeof (*args), free_initialize_registered);
+       call =  _gck_call_async_prep (NULL, perform_initialize_registered, NULL,
+                                     sizeof (InitializeRegistered), free_initialize_registered);
 
-       _gck_call_async_ready_go (args, NULL, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, NULL, cancellable, callback, user_data);
 }
 
 /**
diff --git a/gck/gck-object.c b/gck/gck-object.c
index f9516ba..1521626 100644
--- a/gck/gck-object.c
+++ b/gck/gck-object.c
@@ -438,15 +438,17 @@ void
 gck_object_destroy_async (GckObject *self, GCancellable *cancellable,
                            GAsyncReadyCallback callback, gpointer user_data)
 {
+       GckCall *call;
        Destroy* args;
 
        g_return_if_fail (GCK_IS_OBJECT (self));
        g_return_if_fail (GCK_IS_SESSION (self->pv->session));
 
-       args = _gck_call_async_prep (self->pv->session, perform_destroy, NULL, sizeof (*args), NULL);
+       call = _gck_call_async_prep (self->pv->session, perform_destroy, NULL, sizeof (*args), NULL);
+       args = _gck_call_get_arguments (call);
        args->object = self->pv->handle;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -553,18 +555,20 @@ void
 gck_object_set_async (GckObject *self, GckAttributes *attrs, GCancellable *cancellable,
                        GAsyncReadyCallback callback, gpointer user_data)
 {
+       GckCall *call;
        SetAttributes *args;
 
        g_return_if_fail (GCK_IS_OBJECT (self));
        g_return_if_fail (attrs != NULL);
 
-       args = _gck_call_async_prep (self->pv->session, perform_set_attributes,
+       call = _gck_call_async_prep (self->pv->session, perform_set_attributes,
                                     NULL, sizeof (*args), free_set_attributes);
 
+       args = _gck_call_get_arguments (call);
        args->attrs = gck_attributes_ref_sink (attrs);
        args->object = self->pv->handle;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -758,21 +762,23 @@ gck_object_get_async (GckObject *self,
                       GAsyncReadyCallback callback,
                       gpointer user_data)
 {
+       GckCall *call;
        GetAttributes *args;
        guint i;
 
        g_return_if_fail (GCK_IS_OBJECT (self));
 
-       args = _gck_call_async_prep (self->pv->session, perform_get_attributes,
+       call = _gck_call_async_prep (self->pv->session, perform_get_attributes,
                                     NULL, sizeof (*args), free_get_attributes);
 
+       args = _gck_call_get_arguments (call);
        gck_builder_init (&args->builder);
        for (i = 0; i < n_attr_types; ++i)
                gck_builder_add_empty (&args->builder, attr_types[i]);
 
        args->object = self->pv->handle;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -960,6 +966,7 @@ gck_object_get_data_async (GckObject *self, gulong attr_type, GckAllocator alloc
                             GCancellable *cancellable, GAsyncReadyCallback callback,
                             gpointer user_data)
 {
+       GckCall *call;
        GetAttributeData *args;
 
        g_return_if_fail (GCK_IS_OBJECT (self));
@@ -967,14 +974,15 @@ gck_object_get_data_async (GckObject *self, gulong attr_type, GckAllocator alloc
        if (!allocator)
                allocator = g_realloc;
 
-       args = _gck_call_async_prep (self->pv->session, perform_get_attribute_data,
+       call = _gck_call_async_prep (self->pv->session, perform_get_attribute_data,
                                     NULL, sizeof (*args), free_get_attribute_data);
 
+       args = _gck_call_get_arguments (call);
        args->allocator = allocator;
        args->object = self->pv->handle;
        args->type = attr_type;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1114,19 +1122,21 @@ gck_object_set_template_async (GckObject *self, gulong attr_type, GckAttributes
                                 GCancellable *cancellable, GAsyncReadyCallback callback,
                                 gpointer user_data)
 {
+       GckCall *call;
        set_template_args *args;
 
        g_return_if_fail (GCK_IS_OBJECT (self));
        g_return_if_fail (attrs);
 
-       args = _gck_call_async_prep (self->pv->session, perform_set_template,
+       call = _gck_call_async_prep (self->pv->session, perform_set_template,
                                     NULL, sizeof (*args), free_set_template);
 
+       args = _gck_call_get_arguments (call);
        args->attrs = gck_attributes_ref_sink (attrs);
        args->type = attr_type;
        args->object = self->pv->handle;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1272,17 +1282,19 @@ gck_object_get_template_async (GckObject *self, gulong attr_type,
                                 GCancellable *cancellable, GAsyncReadyCallback callback,
                                 gpointer user_data)
 {
+       GckCall *call;
        get_template_args *args;
 
        g_return_if_fail (GCK_IS_OBJECT (self));
 
-       args = _gck_call_async_prep (self->pv->session, perform_get_template,
+       call = _gck_call_async_prep (self->pv->session, perform_get_template,
                                     NULL, sizeof (*args), free_get_template);
 
+       args = _gck_call_get_arguments (call);
        args->object = self->pv->handle;
        args->type = attr_type;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
diff --git a/gck/gck-private.h b/gck/gck-private.h
index c841e6a..6c4117c 100644
--- a/gck/gck-private.h
+++ b/gck/gck-private.h
@@ -145,8 +145,6 @@ typedef gboolean (*GckCompleteFunc) (gpointer call_data, CK_RV result);
 typedef struct _GckCall GckCall;
 
 typedef struct _GckArguments {
-       GckCall *call;
-
        /* For the call function to use */
        CK_FUNCTION_LIST_PTR pkcs11;
        CK_ULONG handle;
@@ -155,7 +153,7 @@ typedef struct _GckArguments {
 
 #define GCK_MECHANISM_EMPTY        { 0UL, NULL, 0 }
 
-#define GCK_ARGUMENTS_INIT        { NULL, NULL, 0 }
+#define GCK_ARGUMENTS_INIT        { NULL, 0 }
 
 G_DECLARE_FINAL_TYPE (GckCall, _gck_call, GCK, CALL, GObject)
 
@@ -178,13 +176,13 @@ gboolean           _gck_call_sync                        (gpointer object,
                                                            GCancellable *cancellable,
                                                            GError **err);
 
-gpointer           _gck_call_async_prep                  (gpointer object,
+GckCall*           _gck_call_async_prep                  (gpointer object,
                                                            gpointer perform,
                                                            gpointer complete,
                                                            gsize args_size,
                                                            gpointer destroy_func);
 
-GckCall*          _gck_call_async_ready                 (gpointer args,
+GckCall*           _gck_call_async_ready                 (GckCall* call,
                                                            gpointer cb_object,
                                                            GCancellable *cancellable,
                                                            GAsyncReadyCallback callback,
@@ -192,7 +190,7 @@ GckCall*          _gck_call_async_ready                 (gpointer args,
 
 void               _gck_call_async_go                    (GckCall *call);
 
-void               _gck_call_async_ready_go              (gpointer args,
+void               _gck_call_async_ready_go              (GckCall *call,
                                                            gpointer cb_object,
                                                            GCancellable *cancellable,
                                                            GAsyncReadyCallback callback,
diff --git a/gck/gck-session.c b/gck/gck-session.c
index 65e30d3..99f7cdd 100644
--- a/gck/gck-session.c
+++ b/gck/gck-session.c
@@ -478,13 +478,14 @@ gck_session_initable_init_async (GAsyncInitable *initable,
 
        g_object_ref (self);
 
-       args =  _gck_call_async_prep (self->pv->slot, perform_open_session, NULL,
+       call =  _gck_call_async_prep (self->pv->slot, perform_open_session, NULL,
                                      sizeof (*args), free_open_session);
 
+       args = _gck_call_get_arguments (call);
        want_login = (self->pv->options & GCK_SESSION_LOGIN_USER) == GCK_SESSION_LOGIN_USER;
        args->session = self->pv->handle;
 
-       call =  _gck_call_async_ready (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready (call, self, cancellable, callback, user_data);
 
        /* Already have a session setup? */
        if (self->pv->handle && !want_login) {
@@ -954,12 +955,16 @@ gck_session_init_pin_async (GckSession *self, const guchar *pin, gsize n_pin,
                              GCancellable *cancellable, GAsyncReadyCallback callback,
                              gpointer user_data)
 {
-       InitPin* args = _gck_call_async_prep (self, perform_init_pin, NULL, sizeof (*args), free_init_pin);
+       GckCall *call;
+       InitPin* args;
+
+       call = _gck_call_async_prep (self, perform_init_pin, NULL, sizeof (*args), free_init_pin);
+       args = _gck_call_get_arguments (call);
 
        args->pin = pin && n_pin ? g_memdup (pin, n_pin) : NULL;
        args->n_pin = n_pin;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1055,14 +1060,18 @@ gck_session_set_pin_async (GckSession *self, const guchar *old_pin, gsize n_old_
                             const guchar *new_pin, gsize n_new_pin, GCancellable *cancellable,
                             GAsyncReadyCallback callback, gpointer user_data)
 {
-       SetPin* args = _gck_call_async_prep (self, perform_set_pin, NULL, sizeof (*args), free_set_pin);
+       SetPin* args;
+       GckCall *call;
+
+       call = _gck_call_async_prep (self, perform_set_pin, NULL, sizeof (*args), free_set_pin);
+       args = _gck_call_get_arguments (call);
 
        args->old_pin = old_pin && n_old_pin ? g_memdup (old_pin, n_old_pin) : NULL;
        args->n_old_pin = n_old_pin;
        args->new_pin = new_pin && n_new_pin ? g_memdup (new_pin, n_new_pin) : NULL;
        args->n_new_pin = n_new_pin;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1150,13 +1159,17 @@ gck_session_login_async (GckSession *self, gulong user_type, const guchar *pin,
                           gsize n_pin, GCancellable *cancellable, GAsyncReadyCallback callback,
                           gpointer user_data)
 {
-       Login* args = _gck_call_async_prep (self, perform_login, NULL, sizeof (*args), free_login);
+       Login* args;
+       GckCall *call;
+
+       call = _gck_call_async_prep (self, perform_login, NULL, sizeof (*args), free_login);
+       args = _gck_call_get_arguments (call);
 
        args->user_type = user_type;
        args->pin = pin && n_pin ? g_memdup (pin, n_pin) : NULL;
        args->n_pin = n_pin;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1253,7 +1266,11 @@ gck_session_login_interactive_async (GckSession *self,
                                      GAsyncReadyCallback callback,
                                      gpointer user_data)
 {
-       Interactive* args = _gck_call_async_prep (self, perform_interactive, NULL, sizeof (*args), 
free_interactive);
+       Interactive* args;
+       GckCall *call;
+
+       call = _gck_call_async_prep (self, perform_interactive, NULL, sizeof (*args), free_interactive);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (GCK_IS_SESSION (self));
        g_return_if_fail (interaction == NULL || G_IS_TLS_INTERACTION (interaction));
@@ -1266,7 +1283,7 @@ gck_session_login_interactive_async (GckSession *self,
        args->interaction = interaction ? g_object_ref (interaction) : NULL;
        args->token = g_object_ref (self->pv->slot);
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1328,8 +1345,10 @@ void
 gck_session_logout_async (GckSession *self, GCancellable *cancellable,
                            GAsyncReadyCallback callback, gpointer user_data)
 {
-       GckArguments *args = _gck_call_async_prep (self, perform_logout, NULL, 0, NULL);
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       GckCall *call;
+
+       call = _gck_call_async_prep (self, perform_logout, NULL, 0, NULL);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1442,14 +1461,18 @@ gck_session_create_object_async (GckSession *self, GckAttributes *attrs,
                                   GCancellable *cancellable, GAsyncReadyCallback callback,
                                   gpointer user_data)
 {
-       CreateObject *args = _gck_call_async_prep (self, perform_create_object,
-                                                   NULL, sizeof (*args), free_create_object);
+       GckCall *call;
+       CreateObject *args;
+
+       call = _gck_call_async_prep (self, perform_create_object,
+                                     NULL, sizeof (*args), free_create_object);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (attrs);
 
        args->attrs = gck_attributes_ref_sink (attrs);
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1618,16 +1641,18 @@ gck_session_find_handles_async (GckSession *self,
                                 GAsyncReadyCallback callback,
                                 gpointer user_data)
 {
+       GckCall *call;
        FindObjects *args;
 
        g_return_if_fail (GCK_IS_SESSION (self));
        g_return_if_fail (match != NULL);
        g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
 
-       args = _gck_call_async_prep (self, perform_find_objects,
+       call = _gck_call_async_prep (self, perform_find_objects,
                                     NULL, sizeof (*args), free_find_objects);
+       args = _gck_call_get_arguments (call);
        args->attrs = gck_attributes_ref_sink (match);
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -1940,8 +1965,12 @@ gck_session_generate_key_pair_async (GckSession *self, GckMechanism *mechanism,
                                       GCancellable *cancellable, GAsyncReadyCallback callback,
                                       gpointer user_data)
 {
-       GenerateKeyPair *args = _gck_call_async_prep (self, perform_generate_key_pair,
-                                                      NULL, sizeof (*args), free_generate_key_pair);
+       GckCall *call;
+       GenerateKeyPair *args;
+
+       call  = _gck_call_async_prep (self, perform_generate_key_pair,
+                                     NULL, sizeof (*args), free_generate_key_pair);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (GCK_IS_SESSION (self));
        g_return_if_fail (mechanism);
@@ -1954,7 +1983,7 @@ gck_session_generate_key_pair_async (GckSession *self, GckMechanism *mechanism,
        args->public_attrs = gck_attributes_ref_sink (public_attrs);
        args->private_attrs = gck_attributes_ref_sink (private_attrs);
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -2126,8 +2155,12 @@ gck_session_wrap_key_async (GckSession *self, GckObject *key, GckMechanism *mech
                              GckObject *wrapped, GCancellable *cancellable,
                              GAsyncReadyCallback callback, gpointer user_data)
 {
-       WrapKey *args = _gck_call_async_prep (self, perform_wrap_key,
-                                              NULL, sizeof (*args), free_wrap_key);
+       GckCall *call;
+       WrapKey *args;
+
+       call = _gck_call_async_prep (self, perform_wrap_key,
+                                     NULL, sizeof (*args), free_wrap_key);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (GCK_IS_SESSION (self));
        g_return_if_fail (mechanism);
@@ -2142,7 +2175,7 @@ gck_session_wrap_key_async (GckSession *self, GckObject *key, GckMechanism *mech
        g_object_get (wrapped, "handle", &args->wrapped, NULL);
        g_return_if_fail (args->wrapped != 0);
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -2334,8 +2367,12 @@ gck_session_unwrap_key_async (GckSession *self,
                               GAsyncReadyCallback callback,
                               gpointer user_data)
 {
-       UnwrapKey *args = _gck_call_async_prep (self, perform_unwrap_key,
-                                                NULL, sizeof (*args), free_unwrap_key);
+       GckCall *call;
+       UnwrapKey *args;
+
+       call = _gck_call_async_prep (self, perform_unwrap_key,
+                                    NULL, sizeof (*args), free_unwrap_key);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (GCK_IS_SESSION (self));
        g_return_if_fail (GCK_IS_OBJECT (wrapper));
@@ -2351,7 +2388,7 @@ gck_session_unwrap_key_async (GckSession *self,
        args->input = input;
        args->n_input = n_input;
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -2506,8 +2543,12 @@ gck_session_derive_key_async (GckSession *self, GckObject *base, GckMechanism *m
                                GckAttributes *attrs, GCancellable *cancellable,
                                GAsyncReadyCallback callback, gpointer user_data)
 {
-       DeriveKey *args = _gck_call_async_prep (self, perform_derive_key,
-                                                NULL, sizeof (*args), free_derive_key);
+       GckCall *call;
+       DeriveKey *args;
+
+       call = _gck_call_async_prep (self, perform_derive_key,
+                                    NULL, sizeof (*args), free_derive_key);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (GCK_IS_SESSION (self));
        g_return_if_fail (GCK_IS_OBJECT (base));
@@ -2521,7 +2562,7 @@ gck_session_derive_key_async (GckSession *self, GckObject *base, GckMechanism *m
 
        args->attrs = gck_attributes_ref_sink (attrs);
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
@@ -2674,7 +2715,11 @@ crypt_async (GckSession *self, GckObject *key, GckMechanism *mechanism, const gu
              gsize n_input, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data,
              CK_C_EncryptInit init_func, CK_C_Encrypt complete_func)
 {
-       Crypt *args = _gck_call_async_prep (self, perform_crypt, NULL, sizeof (*args), free_crypt);
+       GckCall *call;
+       Crypt *args;
+
+       call = _gck_call_async_prep (self, perform_crypt, NULL, sizeof (*args), free_crypt);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (GCK_IS_OBJECT (key));
        g_return_if_fail (mechanism);
@@ -2696,7 +2741,7 @@ crypt_async (GckSession *self, GckObject *key, GckMechanism *mechanism, const gu
        args->key_object = g_object_ref (key);
        args->interaction = gck_session_get_interaction (self);
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 static guchar*
@@ -3238,7 +3283,11 @@ gck_session_verify_async (GckSession *self, GckObject *key, GckMechanism *mechan
                            gsize n_signature, GCancellable *cancellable,
                            GAsyncReadyCallback callback, gpointer user_data)
 {
-       Verify *args = _gck_call_async_prep (self, perform_verify, NULL, sizeof (*args), free_verify);
+       GckCall *call;
+       Verify *args;
+
+       call = _gck_call_async_prep (self, perform_verify, NULL, sizeof (*args), free_verify);
+       args = _gck_call_get_arguments (call);
 
        g_return_if_fail (GCK_IS_OBJECT (key));
        g_return_if_fail (mechanism);
@@ -3257,7 +3306,7 @@ gck_session_verify_async (GckSession *self, GckObject *key, GckMechanism *mechan
        args->key_object = g_object_ref (key);
        args->interaction = gck_session_get_interaction (self);
 
-       _gck_call_async_ready_go (args, self, cancellable, callback, user_data);
+       _gck_call_async_ready_go (call, self, cancellable, callback, user_data);
 }
 
 /**
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]