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

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);
 }
 
 /**