daemon: AuthSession process-* signals changed to Callbacks

diff --git a/src/daemon/dbus/gsignond-dbus-auth-session-adapter.c b/src/daemon/dbus/gsignond-dbus-auth-session-adapter.c
index f048a50..bfa5623 100644 (file)
--- a/src/daemon/dbus/gsignond-dbus-auth-session-adapter.c
+++ b/src/daemon/dbus/gsignond-dbus-auth-session-adapter.c
@@ -45,11 +45,8 @@ struct _GSignondDbusAuthSessionAdapterPrivate
     GSignondDbusAuthSession *dbus_auth_session;
     GSignondAuthSession *session;
     gchar *app_context;
+    gboolean is_process_active;
     GSignondSecurityContext ctx;
-    /* signal handlers */
-    guint state_changed_handler_id;
-    guint process_result_handler_id;
-    guint process_erroror_handler_id;
 };
 
 G_DEFINE_TYPE (GSignondDbusAuthSessionAdapter, gsignond_dbus_auth_session_adapter, GSIGNOND_TYPE_DISPOSABLE)
@@ -80,9 +77,6 @@ static gboolean _handle_query_available_mechanisms (GSignondDbusAuthSessionAdapt
 static gboolean _handle_process (GSignondDbusAuthSessionAdapter *, GDBusMethodInvocation *, const GVariant *, const gchar *, gpointer);
 static gboolean _handle_cancel (GSignondDbusAuthSessionAdapter *, GDBusMethodInvocation *, gpointer);
 
-/* signals */
-static void _emit_state_changed (GSignondDbusAuthSessionAdapter *self, gint state, const gchar *message, gpointer user_data);
-
 static void
 gsignond_dbus_auth_session_adapter_set_property (GObject *object,
         guint property_id,
@@ -93,15 +87,7 @@ gsignond_dbus_auth_session_adapter_set_property (GObject *object,
     switch (property_id) {
         case PROP_SESSION: {
             gpointer object = g_value_get_object (value);
-            if (object) {
-                if (self->priv->session) {
-                    g_signal_handler_disconnect (self->priv->session, self->priv->state_changed_handler_id);
-                }
-                self->priv->session = GSIGNOND_AUTH_SESSION ((object));
-                self->priv->state_changed_handler_id = 
-                       g_signal_connect_swapped (self->priv->session, "state-changed", 
-                                         G_CALLBACK (_emit_state_changed), self);
-            }
+            self->priv->session = GSIGNOND_AUTH_SESSION ((object));
             break;
         }
         case PROP_CONNECTION: {
@@ -149,19 +135,9 @@ gsignond_dbus_auth_session_adapter_dispose (GObject *object)
     GSignondDbusAuthSessionAdapter *self = GSIGNOND_DBUS_AUTH_SESSION_ADAPTER (object);
 
     if (self->priv->session) {
-        if (self->priv->state_changed_handler_id) {
-            g_signal_handler_disconnect (self->priv->session, self->priv->state_changed_handler_id);
-            self->priv->state_changed_handler_id = 0;
-        }
-        if (self->priv->process_erroror_handler_id) {
-            g_signal_handler_disconnect (self->priv->session, self->priv->process_erroror_handler_id);
-            self->priv->process_erroror_handler_id = 0;
-        }
-        if (self->priv->process_result_handler_id) {
-            g_signal_handler_disconnect (self->priv->session, self->priv->process_result_handler_id);
-            self->priv->process_result_handler_id = 0;
-
+        if (self->priv->is_process_active) {
             gsignond_auth_session_abort_process (self->priv->session);
+            self->priv->is_process_active = FALSE;
         }
 
         g_object_unref (self->priv->session);
@@ -243,9 +219,7 @@ gsignond_dbus_auth_session_adapter_init (GSignondDbusAuthSessionAdapter *self)
     self->priv->connection = 0;
     self->priv->session = 0;
     self->priv->app_context = 0;
-    self->priv->state_changed_handler_id = 0;
-    self->priv->process_result_handler_id = 0;
-    self->priv->process_erroror_handler_id = 0;
+    self->priv->is_process_active = FALSE;
     self->priv->dbus_auth_session = gsignond_dbus_auth_session_skeleton_new ();
 
     g_signal_connect_swapped (self->priv->dbus_auth_session,
@@ -293,7 +267,7 @@ typedef struct {
 static _AuthSessionDbusInfo*
 _auth_session_dbus_info_new (GSignondDbusAuthSessionAdapter *self, GDBusMethodInvocation *invocation)
 {
-    _AuthSessionDbusInfo *info = g_new0 (_AuthSessionDbusInfo, 1);
+    _AuthSessionDbusInfo *info = g_slice_new0(_AuthSessionDbusInfo);
 
     info->adapter = g_object_ref (self);
     info->invocation = g_object_ref (invocation);
@@ -309,47 +283,39 @@ _auth_session_dbus_info_free (_AuthSessionDbusInfo *info)
     g_object_unref (info->adapter);
     g_object_unref (info->invocation);
 
-    g_free (info);
+    g_slice_free (_AuthSessionDbusInfo, info);
 }
 
 static void
-_on_process_result (_AuthSessionDbusInfo *info, const GSignondSessionData *data, gpointer user_data)
+_emit_state_changed (gint state, const gchar *message, gpointer user_data)
 {
     GSignondDbusAuthSessionAdapter *self = NULL;
-    GVariant *result = NULL;
-    
+    _AuthSessionDbusInfo *info = (_AuthSessionDbusInfo*) user_data;
+
     if (!info) return ;
 
     self = info->adapter;
-    result = gsignond_dictionary_to_variant ((GSignondDictionary *)data);
-
-    g_signal_handler_disconnect (self->priv->session, self->priv->process_erroror_handler_id);
-    g_signal_handler_disconnect (self->priv->session, self->priv->process_result_handler_id);
-    self->priv->process_erroror_handler_id = self->priv->process_result_handler_id = 0;
-
-    gsignond_dbus_auth_session_complete_process (
-        self->priv->dbus_auth_session, info->invocation, result);
-
-    gsignond_disposable_set_auto_dispose (GSIGNOND_DISPOSABLE (self), TRUE);
-
-    _auth_session_dbus_info_free (info);
+    gsignond_dbus_auth_session_emit_state_changed (
+            self->priv->dbus_auth_session, state, message);
 }
-
 static void
-_on_process_error (_AuthSessionDbusInfo *info, const GError *error, gpointer user_data)
+_on_process_done (GSignondSessionData *reply, const GError *error, gpointer user_data)
 {
     GSignondDbusAuthSessionAdapter *self = NULL;
+    _AuthSessionDbusInfo *info = (_AuthSessionDbusInfo*) user_data;
 
     if (!info) return ;
 
     self = info->adapter;
+    self->priv->is_process_active = FALSE;
 
-    g_signal_handler_disconnect (self->priv->session, self->priv->process_erroror_handler_id);
-    g_signal_handler_disconnect (self->priv->session, self->priv->process_result_handler_id);
-    self->priv->process_erroror_handler_id = self->priv->process_result_handler_id = 0;
-
-    g_dbus_method_invocation_return_gerror (info->invocation, error);
-
+    if (error)
+        g_dbus_method_invocation_return_gerror (info->invocation, error);
+    else {
+        GVariant *result = gsignond_dictionary_to_variant ((GSignondDictionary *)reply); 
+        gsignond_dbus_auth_session_complete_process (
+                self->priv->dbus_auth_session, info->invocation, result);
+    }
     gsignond_disposable_set_auto_dispose (GSIGNOND_DISPOSABLE (self), TRUE);
 
     _auth_session_dbus_info_free (info);
@@ -368,26 +334,20 @@ _handle_process (GSignondDbusAuthSessionAdapter *self,
 
     g_return_val_if_fail (self && GSIGNOND_IS_DBUS_AUTH_SESSION_ADAPTER (self), FALSE);
 
-    info = _auth_session_dbus_info_new (self, invocation);
-
-    self->priv->process_erroror_handler_id = 
-        g_signal_connect_swapped (self->priv->session, "process-error", G_CALLBACK(_on_process_error), info);
-    self->priv->process_result_handler_id = 
-        g_signal_connect_swapped (self->priv->session, "process-result", G_CALLBACK (_on_process_result), info);
-
     PREPARE_SECURITY_CONTEXT (self, invocation);
 
     data = (GSignondSessionData *)gsignond_dictionary_new_from_variant ((GVariant *)session_data);
-    if (!gsignond_auth_session_process (self->priv->session, data, mechanisms, &self->priv->ctx, &error)) {
+    info = _auth_session_dbus_info_new (self, invocation);
+    self->priv->is_process_active = TRUE;
+    if (!gsignond_auth_session_process (self->priv->session, data, mechanisms, 
+                &self->priv->ctx, _on_process_done, 
+                _emit_state_changed, info, &error)) {
         g_dbus_method_invocation_return_gerror (invocation, error);
         g_error_free (error);
  
-        g_signal_handler_disconnect (self->priv->session, self->priv->process_erroror_handler_id);
-        g_signal_handler_disconnect (self->priv->session, self->priv->process_result_handler_id);
-
-        self->priv->process_erroror_handler_id = self->priv->process_result_handler_id = 0;
-
         _auth_session_dbus_info_free (info);
+        
+        self->priv->is_process_active = FALSE;
 
         gsignond_disposable_set_keep_in_use (GSIGNOND_DISPOSABLE(self));
     }
@@ -423,12 +383,6 @@ _handle_cancel (GSignondDbusAuthSessionAdapter *self,
     return TRUE;
 }
 
-static void
-_emit_state_changed (GSignondDbusAuthSessionAdapter *self, gint state, const gchar *message, gpointer user_data)
-{
-    gsignond_dbus_auth_session_emit_state_changed (self->priv->dbus_auth_session, state, message);
-}
-
 const gchar *
 gsignond_dbus_auth_session_adapter_get_object_path (GSignondDbusAuthSessionAdapter *self)
 {

diff --git a/src/daemon/gsignond-auth-session.c b/src/daemon/gsignond-auth-session.c
index 87451a4..c1d80e6 100644 (file)
--- a/src/daemon/gsignond-auth-session.c
+++ b/src/daemon/gsignond-auth-session.c
@@ -41,18 +41,22 @@ enum
 static GParamSpec *properties[N_PROPERTIES];
 
 enum {
-    SIG_PROCESS_RESULT,
-    SIG_PROCESS_ERROR,
     SIG_PROCESS_STORE,
     SIG_PROCESS_USER_ACTION_REQUIRED,
     SIG_PROCESS_REFRESHED,
-    SIG_PROCESS_STATE_CHANGED,
-    
+ 
     SIG_MAX
 };
 
 static guint signals[SIG_MAX] = { 0 };
 
+typedef struct {
+    GSignondAuthSession *self;
+    ProcessReadyCb ready_cb;
+    StateChangeCb state_change_cb;
+    gpointer userdata;
+} _ProcessData;
+
 struct _GSignondAuthSessionPrivate
 {
     gchar *method;
@@ -194,6 +198,9 @@ gsignond_auth_session_process (GSignondAuthSession *self,
                                GSignondSessionData *session_data,
                                const gchar *mechanism,
                                const GSignondSecurityContext *ctx,
+                               ProcessReadyCb ready_cb,
+                               StateChangeCb state_change_cb,
+                               gpointer userdata,
                                GError **error)
 {
     if (!self || !GSIGNOND_IS_AUTH_SESSION (self)) {
@@ -223,8 +230,13 @@ gsignond_auth_session_process (GSignondAuthSession *self,
         }
     }
 
+    _ProcessData * data = g_slice_new0 (_ProcessData);
+    data->self = self;
+    data->ready_cb = ready_cb;
+    data->state_change_cb = state_change_cb;
+    data->userdata = userdata;
     gsignond_plugin_proxy_process(self->priv->proxy, self, session_data,
-                                  mechanism);
+                                  mechanism, data);
 
     return TRUE;
 }
@@ -375,28 +387,6 @@ gsignond_auth_session_class_init (GSignondAuthSessionClass *klass)
 
     g_object_class_install_properties (object_class, N_PROPERTIES, properties);
 
-    signals[SIG_PROCESS_RESULT] =  g_signal_new ("process-result",
-            GSIGNOND_TYPE_AUTH_SESSION,
-            G_SIGNAL_RUN_LAST,
-            0,
-            NULL,
-            NULL,
-            NULL,
-            G_TYPE_NONE,
-            1,
-            GSIGNOND_TYPE_SESSION_DATA);
-
-    signals[SIG_PROCESS_ERROR] = g_signal_new ("process-error",
-            GSIGNOND_TYPE_AUTH_SESSION,
-            G_SIGNAL_RUN_LAST,
-            0,
-            NULL,
-            NULL,
-            NULL,
-            G_TYPE_NONE,
-            1,
-            G_TYPE_ERROR);
-
     signals[SIG_PROCESS_STORE] =  g_signal_new ("process-store",
             GSIGNOND_TYPE_AUTH_SESSION,
             G_SIGNAL_RUN_LAST,
@@ -429,19 +419,6 @@ gsignond_auth_session_class_init (GSignondAuthSessionClass *klass)
             G_TYPE_NONE,
             1,
             GSIGNOND_TYPE_SIGNONUI_DATA);
-
-    signals[SIG_PROCESS_STATE_CHANGED] =  g_signal_new (
-            "state-changed",
-            GSIGNOND_TYPE_AUTH_SESSION,
-            G_SIGNAL_RUN_LAST,
-            0,
-            NULL,
-            NULL,
-            NULL,
-            G_TYPE_NONE,
-            2,
-            G_TYPE_INT, G_TYPE_STRING);
-
 }
 
 /**
@@ -462,16 +439,49 @@ gsignond_auth_session_get_method (GSignondAuthSession *session)
 
 void
 gsignond_auth_session_notify_process_result (GSignondAuthSession *iface,
-                                             GSignondSessionData *result)
+                                             GSignondSessionData *result,
+                                             gpointer userdata)
 {
-    g_signal_emit (iface, signals[SIG_PROCESS_RESULT], 0, result);
+    if (!userdata) {
+        WARN("assert (userdata)");
+        return ;
+    }
+    _ProcessData *data = (_ProcessData *)userdata;
+
+    if (data->ready_cb) data->ready_cb (result, NULL, data->userdata);
+
+    g_slice_free (_ProcessData, data);
 }
 
 void
 gsignond_auth_session_notify_process_error (GSignondAuthSession *iface,
-                                            const GError *error)
+                                            const GError *error,
+                                            gpointer userdata)
+{
+    if (!userdata) {
+        WARN("assert (userdata)");
+        return ;
+    }
+    _ProcessData *data = (_ProcessData *)userdata;
+
+    if (data->ready_cb) data->ready_cb (NULL, error, data->userdata);
+
+    g_slice_free (_ProcessData, data);
+}
+
+void 
+gsignond_auth_session_notify_state_changed (GSignondAuthSession *self,
+                                            gint state,
+                                            const gchar *message,
+                                            gpointer userdata)
 {
-    g_signal_emit (iface, signals[SIG_PROCESS_ERROR], 0, error);
+    if (!userdata) {
+        WARN("assert (userdata)");
+        return ;
+    }
+    _ProcessData *data = (_ProcessData *)userdata;
+
+    if (data->state_change_cb) data->state_change_cb (state, message, data->userdata);
 }
 
 void 
@@ -495,13 +505,6 @@ gsignond_auth_session_notify_refreshed (GSignondAuthSession *self,
     g_signal_emit (self, signals[SIG_PROCESS_REFRESHED], 0, ui_data);
 }
 
-void 
-gsignond_auth_session_notify_state_changed (GSignondAuthSession *self,
-                                            gint state,
-                                            const gchar *message)
-{
-    g_signal_emit (self, signals[SIG_PROCESS_STATE_CHANGED], 0, state, message);
-}
 
 /**
  * gsignond_auth_session_new:

diff --git a/src/daemon/gsignond-auth-session.h b/src/daemon/gsignond-auth-session.h
index 1f10ccb..45710c5 100644 (file)
--- a/src/daemon/gsignond-auth-session.h
+++ b/src/daemon/gsignond-auth-session.h
@@ -54,6 +54,8 @@ G_BEGIN_DECLS
 typedef struct _GSignondAuthSession GSignondAuthSession;
 typedef struct _GSignondAuthSessionClass GSignondAuthSessionClass;
 typedef struct _GSignondAuthSessionPrivate GSignondAuthSessionPrivate;
+typedef void (*ProcessReadyCb) (GSignondSessionData *results, const GError *error, gpointer user_data);
+typedef void (*StateChangeCb) (gint state, const gchar *message, gpointer userdata);
 
 struct _GSignondAuthSession
 {
@@ -81,6 +83,9 @@ gsignond_auth_session_process (GSignondAuthSession *self,
                                GSignondSessionData *session_data,
                                const gchar *mechanism,
                                const GSignondSecurityContext *ctx,
+                               ProcessReadyCb ready_cb,
+                               StateChangeCb state_change_cb,
+                               gpointer userdata,
                                GError **error);
 gboolean
 gsignond_auth_session_cancel (GSignondAuthSession *self,
@@ -109,11 +114,18 @@ gsignond_auth_session_set_id(GSignondAuthSession *session, gint id);
 
 void
 gsignond_auth_session_notify_process_result (GSignondAuthSession *iface,
-                                             GSignondSessionData *result);
+                                             GSignondSessionData *result,
+                                             gpointer userdata);
 
 void
 gsignond_auth_session_notify_process_error (GSignondAuthSession *iface,
-                                            const GError *error);
+                                            const GError *error,
+                                            gpointer userdata);
+void 
+gsignond_auth_session_notify_state_changed (GSignondAuthSession *self, 
+                                            gint state,
+                                            const gchar *message,
+                                            gpointer userdata);
 
 void 
 gsignond_auth_session_notify_store (GSignondAuthSession *self, 
@@ -127,16 +139,11 @@ void
 gsignond_auth_session_notify_refreshed (GSignondAuthSession *self, 
                                         GSignondSignonuiData *ui_data);
 
-void 
-gsignond_auth_session_notify_state_changed (GSignondAuthSession *self, 
-                                            gint state,
-                                            const gchar *message);
-
 GSignondAuthSession * 
 gsignond_auth_session_new (GSignondIdentityInfo *info,
                            const gchar *method);
 
 G_END_DECLS
 
-#endif  /* _GSGINOND_AUTH_SESSION_H_ */
+#endif  /* _GSIGNOND_AUTH_SESSION_H_ */
 

diff --git a/src/daemon/plugins/gsignond-plugin-proxy.c b/src/daemon/plugins/gsignond-plugin-proxy.c
index ab668fb..a4b8b0f 100644 (file)
--- a/src/daemon/plugins/gsignond-plugin-proxy.c
+++ b/src/daemon/plugins/gsignond-plugin-proxy.c
@@ -52,6 +52,7 @@ struct _GSignondPluginProxyPrivate
     GSignondPlugin* plugin;
     GQueue* session_queue;
     GSignondAuthSession* active_session;
+    gpointer active_process_userdata;
     gboolean expecting_request;
 };
 
@@ -59,6 +60,7 @@ typedef struct {
     GSignondAuthSession* auth_session;
     GSignondSessionData* session_data;
     gchar* mechanism;
+    gpointer userdata;
 } GSignondProcessData;
 
 static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
@@ -92,13 +94,15 @@ static void gsignond_plugin_proxy_status_changed_callback(GSignondPlugin* plugin
 static GSignondProcessData* 
 gsignond_process_data_new (GSignondAuthSession* auth_session,
                            GSignondSessionData *session_data,
-                           const gchar* mechanism) 
+                           const gchar* mechanism,
+                           gpointer userdata) 
 {
     GSignondProcessData* data = g_slice_new0 (GSignondProcessData);
     g_object_ref (auth_session);
     data->auth_session = auth_session;
     data->session_data = gsignond_dictionary_copy (session_data);
     data->mechanism = g_strdup (mechanism);
+    data->userdata = userdata;
     return data;
 }
 
@@ -307,6 +311,7 @@ gsignond_plugin_proxy_init (GSignondPluginProxy *self)
     priv->plugin = NULL;
     priv->session_queue = g_queue_new ();
     priv->active_session = NULL;
+    priv->active_process_userdata = NULL;
     priv->expecting_request = FALSE;
 }
 
@@ -342,12 +347,14 @@ gsignond_plugin_proxy_process_queue (GSignondPluginProxy *self)
     GSignondProcessData* next_data = g_queue_pop_head (priv->session_queue);
     if (next_data) {
         priv->expecting_request = FALSE;
+        priv->active_process_userdata = next_data->userdata;
         priv->active_session = next_data->auth_session;
         g_object_ref (priv->active_session);
         gsignond_auth_session_notify_state_changed (
                                             priv->active_session,
                                             GSIGNOND_PLUGIN_STATE_STARTED,
-                                            "The request is being processed.");
+                                            "The request is being processed.",
+                                            priv->active_process_userdata);
         gsignond_plugin_request_initial (priv->plugin,
                                          next_data->session_data, 
                                          next_data->mechanism);
@@ -358,7 +365,8 @@ gsignond_plugin_proxy_process_queue (GSignondPluginProxy *self)
 void gsignond_plugin_proxy_process (GSignondPluginProxy *self, 
                                     GSignondAuthSession *session,
                                     GSignondSessionData *session_data, 
-                                    const gchar *mechanism)
+                                    const gchar *mechanism,
+                                    gpointer userdata)
 {
     g_assert (GSIGNOND_IS_PLUGIN_PROXY (self));
     g_assert (GSIGNOND_IS_AUTH_SESSION (session));
@@ -375,11 +383,11 @@ void gsignond_plugin_proxy_process (GSignondPluginProxy *self,
     g_queue_push_tail (priv->session_queue,
                        gsignond_process_data_new (session,
                                                   session_data,
-                                                  mechanism));
+                                                  mechanism, userdata));
     gsignond_auth_session_notify_state_changed (
                                          session,
                                          GSIGNOND_PLUGIN_STATE_PROCESS_PENDING,
-                                         "The request has been queued.");
+                                         "The request has been queued.", userdata);
     if (priv->active_session == NULL) {
         gsignond_plugin_proxy_process_queue (self);
     }
@@ -423,6 +431,7 @@ gsignond_plugin_proxy_cancel (GSignondPluginProxy *self,
         gsignond_plugin_cancel (priv->plugin);
         g_object_unref (priv->active_session);
         priv->active_session = NULL;
+        priv->active_process_userdata = NULL;
         gsignond_plugin_proxy_process_queue (self);
     } else { /* cancel by de-queue */
         GSignondProcessData* data =
@@ -431,7 +440,7 @@ gsignond_plugin_proxy_cancel (GSignondPluginProxy *self,
             GError* error = g_error_new (GSIGNOND_ERROR, 
                                          GSIGNOND_ERROR_WRONG_STATE,
                                          "Canceling an unknown session");
-            gsignond_auth_session_notify_process_error (session, error);
+            gsignond_auth_session_notify_process_error (session, error, NULL);
             g_error_free (error);
             return;
         }
@@ -484,7 +493,7 @@ gsignond_plugin_proxy_response_final_callback (GSignondPlugin *plugin,
     // This avoids problems if cancel() is called from AuthSession handler
     GSignondAuthSession* active_session = priv->active_session;
     priv->active_session = NULL;
-    gsignond_auth_session_notify_process_result (active_session, result);
+    gsignond_auth_session_notify_process_result (active_session, result, priv->active_process_userdata);
     g_object_unref (active_session);
     gsignond_plugin_proxy_process_queue (self);
 }
@@ -504,7 +513,7 @@ gsignond_plugin_proxy_response_callback(GSignondPlugin *plugin,
     }
     priv->expecting_request = TRUE;
     gsignond_auth_session_notify_process_result (priv->active_session,
-                                                       result);
+                                                       result, priv->active_process_userdata);
 }
 
 static void
@@ -573,7 +582,7 @@ gsignond_plugin_proxy_error_callback (GSignondPlugin* plugin,
     // This avoids problems if cancel() is called from AuthSession handler
     GSignondAuthSession *active_session = priv->active_session;
     priv->active_session = NULL;
-    gsignond_auth_session_notify_process_error (active_session, error);
+    gsignond_auth_session_notify_process_error (active_session, error, priv->active_process_userdata);
     g_object_unref (active_session);
     gsignond_plugin_proxy_process_queue (self);
 }
@@ -594,6 +603,7 @@ gsignond_plugin_proxy_status_changed_callback (GSignondPlugin *plugin,
         return;
     }
     gsignond_auth_session_notify_state_changed (priv->active_session,
-                                                      (gint) state, message);
+                                                (gint) state, message,
+                                                priv->active_process_userdata);
 }
 

diff --git a/src/daemon/plugins/gsignond-plugin-proxy.h b/src/daemon/plugins/gsignond-plugin-proxy.h
index 6e39ffd..a72d892 100644 (file)
--- a/src/daemon/plugins/gsignond-plugin-proxy.h
+++ b/src/daemon/plugins/gsignond-plugin-proxy.h
@@ -68,7 +68,8 @@ gsignond_plugin_proxy_cancel (GSignondPluginProxy *self,
 void gsignond_plugin_proxy_process (GSignondPluginProxy *self, 
                               GSignondAuthSession* session,
                               GSignondSessionData *session_data, 
-                              const gchar *mechanism);
+                              const gchar *mechanism,
+                              gpointer userdata);
 void gsignond_plugin_proxy_user_action_finished (GSignondPluginProxy *self, 
                                            GSignondSignonuiData *ui_data);
 void gsignond_plugin_proxy_refresh (GSignondPluginProxy *self,