auth: Removed unnecessary auth_request callback and context uses.

--HG--
branch : HEAD

diff --git a/src/auth/auth-request-handler.c b/src/auth/auth-request-handler.c
index 1298b34384f87fde6ed88220775690cb332d4022..8cf62d115a8a8036f258872ee3acb32eaed9e607 100644 (file)
--- a/src/auth/auth-request-handler.c
+++ b/src/auth/auth-request-handler.c
@@ -185,7 +185,7 @@ static void
 auth_request_handle_failure(struct auth_request *request,
                            struct auth_stream_reply *reply)
 {
-        struct auth_request_handler *handler = request->context;
+        struct auth_request_handler *handler = request->handler;
 
        if (request->delayed_failure) {
                /* we came here from flush_failures() */
@@ -222,11 +222,11 @@ auth_request_handle_failure(struct auth_request *request,
        }
 }
 
-static void auth_callback(struct auth_request *request,
-                         enum auth_client_result result,
-                         const void *auth_reply, size_t reply_size)
+void auth_request_handler_reply(struct auth_request *request,
+                               enum auth_client_result result,
+                               const void *auth_reply, size_t reply_size)
 {
-        struct auth_request_handler *handler = request->context;
+        struct auth_request_handler *handler = request->handler;
        struct auth_stream_reply *reply;
        string_t *str;
 
@@ -294,6 +294,13 @@ static void auth_callback(struct auth_request *request,
         auth_request_handler_unref(&handler);
 }
 
+void auth_request_handler_reply_continue(struct auth_request *request,
+                                        const void *reply, size_t reply_size)
+{
+       auth_request_handler_reply(request, AUTH_CLIENT_RESULT_CONTINUE,
+                                  reply, reply_size);
+}
+
 static void auth_request_handler_auth_fail(struct auth_request_handler *handler,
                                           struct auth_request *request,
                                           const char *reason)
@@ -381,7 +388,7 @@ bool auth_request_handler_auth_begin(struct auth_request_handler *handler,
                return FALSE;
        }
 
-       request = auth_request_new(mech, auth_callback, handler);
+       request = auth_request_new(mech);
        request->handler = handler;
        request->connect_uid = handler->connect_uid;
        request->client_pid = handler->client_pid;
@@ -458,7 +465,8 @@ bool auth_request_handler_auth_begin(struct auth_request_handler *handler,
                request->initial_response_len = buf->used;
        }
 
-       /* handler is referenced until auth_callback is called. */
+       /* handler is referenced until auth_request_handler_reply()
+          is called. */
        handler->refcount++;
 
        /* before we start authenticating, see if we need to wait first */
@@ -513,7 +521,8 @@ bool auth_request_handler_auth_continue(struct auth_request_handler *handler,
                return TRUE;
        }
 
-       /* handler is referenced until auth_callback is called. */
+       /* handler is referenced until auth_request_handler_reply()
+          is called. */
        handler->refcount++;
        auth_request_continue(request, buf->data, buf->used);
        return TRUE;
@@ -522,7 +531,7 @@ bool auth_request_handler_auth_continue(struct auth_request_handler *handler,
 static void userdb_callback(enum userdb_result result,
                            struct auth_request *request)
 {
-        struct auth_request_handler *handler = request->context;
+        struct auth_request_handler *handler = request->handler;
        struct auth_stream_reply *reply;
        const char *value;
 
@@ -607,7 +616,6 @@ bool auth_request_handler_master_request(struct auth_request_handler *handler,
                   old client_id with master's id. */
                auth_request_set_state(request, AUTH_REQUEST_STATE_USERDB);
                request->id = id;
-               request->context = handler;
                request->master = master;
 
                /* master and handler are referenced until userdb_callback i
@@ -655,8 +663,8 @@ void auth_request_handler_flush_failures(bool flush_all)
                aqueue_delete_tail(auth_failures);
 
                i_assert(auth_request->state == AUTH_REQUEST_STATE_FINISHED);
-               auth_request->callback(auth_request,
-                                      AUTH_CLIENT_RESULT_FAILURE, NULL, 0);
+               auth_request_handler_reply(auth_request,
+                                          AUTH_CLIENT_RESULT_FAILURE, NULL, 0);
                auth_request_unref(&auth_request);
        }
 }

diff --git a/src/auth/auth-request-handler.h b/src/auth/auth-request-handler.h
index 515b3a8267a7e750864364e16f2c0921e3e07d92..834c311fad940d23644be52542cb6ed6779ad97b 100644 (file)
--- a/src/auth/auth-request-handler.h
+++ b/src/auth/auth-request-handler.h
@@ -5,6 +5,12 @@ struct auth_request;
 struct auth_master_connection;
 struct auth_stream_reply;
 
+enum auth_client_result {
+       AUTH_CLIENT_RESULT_CONTINUE = 1,
+       AUTH_CLIENT_RESULT_SUCCESS,
+       AUTH_CLIENT_RESULT_FAILURE
+};
+
 typedef void
 auth_request_callback_t(struct auth_stream_reply *reply, void *context);
 
@@ -33,6 +39,11 @@ bool auth_request_handler_auth_begin(struct auth_request_handler *handler,
                                     const char *args);
 bool auth_request_handler_auth_continue(struct auth_request_handler *handler,
                                        const char *args);
+void auth_request_handler_reply(struct auth_request *request,
+                               enum auth_client_result result,
+                               const void *reply, size_t reply_size);
+void auth_request_handler_reply_continue(struct auth_request *request,
+                                        const void *reply, size_t reply_size);
 bool auth_request_handler_master_request(struct auth_request_handler *handler,
                                         struct auth_master_connection *master,
                                         unsigned int id,

diff --git a/src/auth/auth-request.c b/src/auth/auth-request.c
index 67ff3b8070869fcd6dea2ee1a576c796866aac90..7c922da0ca9b9ed9e5bc7061a56cb87a5c7d0e75 100644 (file)
--- a/src/auth/auth-request.c
+++ b/src/auth/auth-request.c
@@ -34,8 +34,7 @@ static void get_log_prefix(string_t *str, struct auth_request *auth_request,
 static void auth_request_userdb_reply_update_user(struct auth_request *request);
 
 struct auth_request *
-auth_request_new(const struct mech_module *mech,
-                mech_callback_t *callback, void *context)
+auth_request_new(const struct mech_module *mech)
 {
        struct auth_request *request;
 
@@ -50,8 +49,6 @@ auth_request_new(const struct mech_module *mech,
        request->set = global_auth_settings;
        request->mech = mech;
        request->mech_name = mech == NULL ? NULL : mech->mech_name;
-       request->callback = callback;
-       request->context = context;
        return request;
 }
 
@@ -116,8 +113,8 @@ void auth_request_success(struct auth_request *request,
        auth_request_set_state(request, AUTH_REQUEST_STATE_FINISHED);
        request->successful = TRUE;
        auth_request_refresh_last_access(request);
-       request->callback(request, AUTH_CLIENT_RESULT_SUCCESS,
-                         data, data_size);
+       auth_request_handler_reply(request, AUTH_CLIENT_RESULT_SUCCESS,
+                                  data, data_size);
 }
 
 void auth_request_fail(struct auth_request *request)
@@ -126,7 +123,8 @@ void auth_request_fail(struct auth_request *request)
 
        auth_request_set_state(request, AUTH_REQUEST_STATE_FINISHED);
        auth_request_refresh_last_access(request);
-       request->callback(request, AUTH_CLIENT_RESULT_FAILURE, NULL, 0);
+       auth_request_handler_reply(request, AUTH_CLIENT_RESULT_FAILURE,
+                                  NULL, 0);
 }
 
 void auth_request_internal_failure(struct auth_request *request)

diff --git a/src/auth/auth-request.h b/src/auth/auth-request.h
index db23030273752127663cbb28642f1ddbf5797fef..a08708e11a9173c8611964d4055ec0fa6cf4dbc7 100644 (file)
--- a/src/auth/auth-request.h
+++ b/src/auth/auth-request.h
@@ -57,11 +57,14 @@ struct auth_request {
        struct auth_stream_reply *userdb_reply;
 
        const struct mech_module *mech;
-       struct auth_request_handler *handler;
        const struct auth_settings *set;
         struct auth_passdb *passdb;
         struct auth_userdb *userdb;
 
+       /* passdb lookups have a handler, userdb lookups don't */
+       struct auth_request_handler *handler;
+        struct auth_master_connection *master;
+
        unsigned int connect_uid;
        unsigned int client_pid;
        unsigned int id;
@@ -84,9 +87,7 @@ struct auth_request {
        } private_callback;
         const char *credentials_scheme;
 
-       mech_callback_t *callback;
        void *context;
-        struct auth_master_connection *master;
 
        unsigned int successful:1;
        unsigned int passdb_failure:1;
@@ -116,8 +117,7 @@ struct auth_request {
 extern unsigned int auth_request_state_count[AUTH_REQUEST_STATE_MAX];
 
 struct auth_request *
-auth_request_new(const struct mech_module *mech,
-                mech_callback_t *callback, void *context);
+auth_request_new(const struct mech_module *mech);
 struct auth_request *auth_request_new_dummy(void);
 void auth_request_init(struct auth_request *request);
 struct auth *auth_request_get_auth(struct auth_request *request);

diff --git a/src/auth/mech-cram-md5.c b/src/auth/mech-cram-md5.c
index da9900530eb0f11db23a2a22480cdb4800ffb57c..b91b1dafd1f0446218a4ab19b1a66bbddb006306 100644 (file)
--- a/src/auth/mech-cram-md5.c
+++ b/src/auth/mech-cram-md5.c
@@ -161,8 +161,8 @@ mech_cram_md5_auth_initial(struct auth_request *auth_request,
                (struct cram_auth_request *)auth_request;
 
        request->challenge = p_strdup(request->pool, get_cram_challenge());
-       auth_request->callback(auth_request, AUTH_CLIENT_RESULT_CONTINUE,
-                              request->challenge, strlen(request->challenge));
+       auth_request_handler_reply_continue(auth_request,  request->challenge,
+                                           strlen(request->challenge));
 }
 
 static struct auth_request *mech_cram_md5_auth_new(void)

diff --git a/src/auth/mech-digest-md5.c b/src/auth/mech-digest-md5.c
index 5e3ae3a7af31f5850bf27c123bccecb526fd3903..db1bec4abb6c2cbc4f0848ce4c8ab57e6970cf6c 100644 (file)
--- a/src/auth/mech-digest-md5.c
+++ b/src/auth/mech-digest-md5.c
@@ -506,10 +506,9 @@ static void credentials_callback(enum passdb_result result,
                }
 
                request->authenticated = TRUE;
-               auth_request->callback(auth_request,
-                                      AUTH_CLIENT_RESULT_CONTINUE,
-                                      request->rspauth,
-                                      strlen(request->rspauth));
+               auth_request_handler_reply_continue(auth_request,
+                                                   request->rspauth,
+                                                   strlen(request->rspauth));
                break;
        case PASSDB_RESULT_INTERNAL_FAILURE:
                auth_request_internal_failure(auth_request);
@@ -570,8 +569,8 @@ mech_digest_md5_auth_initial(struct auth_request *auth_request,
        /* FIXME: there's no support for subsequent authentication */
 
        challenge = get_digest_challenge(request);
-       auth_request->callback(auth_request, AUTH_CLIENT_RESULT_CONTINUE,
-                              str_data(challenge), str_len(challenge));
+       auth_request_handler_reply_continue(auth_request, str_data(challenge),
+                                           str_len(challenge));
 }
 
 static struct auth_request *mech_digest_md5_auth_new(void)

diff --git a/src/auth/mech-gssapi.c b/src/auth/mech-gssapi.c
index e68ca7bb8d089ffb4a0ad70a6123b562625312ff..e10fd6eb256ad28cfa4648f5acb8cb21d47cff0d 100644 (file)
--- a/src/auth/mech-gssapi.c
+++ b/src/auth/mech-gssapi.c
@@ -328,9 +328,9 @@ mech_gssapi_sec_context(struct gssapi_auth_request *request,
        }
 
        if (ret == 0) {
-               auth_request->callback(auth_request,
-                                      AUTH_CLIENT_RESULT_CONTINUE,
-                                      output_token.value, output_token.length);
+               auth_request_handler_reply_continue(auth_request,
+                                                   output_token.value,
+                                                   output_token.length);
        }
        (void)gss_release_buffer(&minor_status, &output_token);
        return ret;
@@ -370,9 +370,8 @@ mech_gssapi_wrap(struct gssapi_auth_request *request, gss_buffer_desc inbuf)
        auth_request_log_debug(&request->auth_request, "gssapi",
                               "Negotiated security layer");
 
-       request->auth_request.callback(&request->auth_request,
-                                      AUTH_CLIENT_RESULT_CONTINUE,
-                                      outbuf.value, outbuf.length);
+       auth_request_handler_reply_continue(&request->auth_request,
+                                           outbuf.value, outbuf.length);
 
        (void)gss_release_buffer(&minor_status, &outbuf);
        request->sasl_gssapi_state = GSS_STATE_UNWRAP;
@@ -597,8 +596,7 @@ mech_gssapi_auth_initial(struct auth_request *request,
 
        if (data_size == 0) {
                /* The client should go first */
-               request->callback(request, AUTH_CLIENT_RESULT_CONTINUE,
-                                 NULL, 0);
+               auth_request_handler_reply_continue(request, NULL, 0);
        } else {
                mech_gssapi_auth_continue(request, data, data_size);
        }

diff --git a/src/auth/mech-login.c b/src/auth/mech-login.c
index 225c942bca4aaa7d4c280acf600a9717e7a8fbbd..4d9573029c13902eab0ddb9be9cc584edc1fa64a 100644 (file)
--- a/src/auth/mech-login.c
+++ b/src/auth/mech-login.c
@@ -29,8 +29,8 @@ mech_login_auth_continue(struct auth_request *request,
                        return;
                }
 
-               request->callback(request, AUTH_CLIENT_RESULT_CONTINUE,
-                                 prompt2, strlen(prompt2));
+               auth_request_handler_reply_continue(request, prompt2,
+                                                   strlen(prompt2));
        } else {
                char *pass = p_strndup(unsafe_data_stack_pool, data, data_size);
                auth_request_verify_plain(request, pass, plain_verify_callback);
@@ -45,8 +45,8 @@ mech_login_auth_initial(struct auth_request *request,
        static const char prompt1[] = "Username:";
 
        if (data_size == 0) {
-               request->callback(request, AUTH_CLIENT_RESULT_CONTINUE,
-                                 prompt1, strlen(prompt1));
+               auth_request_handler_reply_continue(request, prompt1,
+                                                   strlen(prompt1));
        } else {
                mech_login_auth_continue(request, data, data_size);
        }

diff --git a/src/auth/mech-ntlm.c b/src/auth/mech-ntlm.c
index 87e8fac155af0536ed3f26b8905ab3b630a9cd73..e4c4b4b6525c6a6760c82aefef96ed66375ddd0a 100644 (file)
--- a/src/auth/mech-ntlm.c
+++ b/src/auth/mech-ntlm.c
@@ -201,9 +201,8 @@ mech_ntlm_auth_continue(struct auth_request *auth_request,
                request->unicode_negotiated = flags & NTLMSSP_NEGOTIATE_UNICODE;
                request->challenge = message->challenge;
 
-               auth_request->callback(auth_request,
-                                      AUTH_CLIENT_RESULT_CONTINUE,
-                                      message, message_size);
+               auth_request_handler_reply_continue(auth_request, message,
+                                                   message_size);
        } else {
                const struct ntlmssp_response *response =
                        (const struct ntlmssp_response *)data;

diff --git a/src/auth/mech-otp.c b/src/auth/mech-otp.c
index b94807f032384ec59227f4b67e8164547c323149..0a4bfd4a60e701b62157f0d2b740dc03ae75a19f 100644 (file)
--- a/src/auth/mech-otp.c
+++ b/src/auth/mech-otp.c
@@ -50,9 +50,8 @@ otp_send_challenge(struct auth_request *auth_request,
                                 digest_name(request->state.algo),
                                 request->state.seq, request->state.seed);
 
-       auth_request->callback(auth_request,
-                              AUTH_CLIENT_RESULT_CONTINUE,
-                              answer, strlen(answer));
+       auth_request_handler_reply_continue(auth_request, answer,
+                                           strlen(answer));
 }
 
 static void

diff --git a/src/auth/mech-rpa.c b/src/auth/mech-rpa.c
index cbe70705483039af7666ede09772db58dbca8b71..c66f83d8f5c11363e4c35ad6c9c37384fcf7e7ae 100644 (file)
--- a/src/auth/mech-rpa.c
+++ b/src/auth/mech-rpa.c
@@ -450,9 +450,9 @@ rpa_credentials_callback(enum passdb_result result,
                        auth_request_fail(auth_request);
                else {
                        token4 = mech_rpa_build_token4(request, &token4_size);
-                       auth_request->callback(auth_request,
-                                              AUTH_CLIENT_RESULT_CONTINUE,
-                                              token4, token4_size);
+                       auth_request_handler_reply_continue(auth_request,
+                                                           token4,
+                                                           token4_size);
                        request->phase = 2;
                }
                break;
@@ -489,8 +489,7 @@ mech_rpa_auth_phase1(struct auth_request *auth_request,
        request->service_ucs2be = ucs2be_str(request->pool, service,
                                             &request->service_len);
 
-       auth_request->callback(auth_request, AUTH_CLIENT_RESULT_CONTINUE,
-                              token2, token2_size);
+       auth_request_handler_reply_continue(auth_request, token2, token2_size);
        request->phase = 1;
 }
 

diff --git a/src/auth/mech-skey.c b/src/auth/mech-skey.c
index d6632e40bf7b03da602ac1badcb82bf33aa8428b..b6a0f9dc773cd0d1488d53d0592b11e5e020fa39 100644 (file)
--- a/src/auth/mech-skey.c
+++ b/src/auth/mech-skey.c
@@ -56,9 +56,8 @@ skey_send_challenge(struct auth_request *auth_request,
        answer = p_strdup_printf(request->pool, "%u %s",
                                 request->state.seq, request->state.seed);
 
-       auth_request->callback(auth_request,
-                              AUTH_CLIENT_RESULT_CONTINUE,
-                              answer, strlen(answer));
+       auth_request_handler_reply_continue(auth_request, answer,
+                                           strlen(answer));
 }
 
 static void

diff --git a/src/auth/mech-winbind.c b/src/auth/mech-winbind.c
index 26a45b0c35db87e6cc70fe55d90803cc0c187ea6..6009918ce02b954cbb8ef6873a41525f6a822cc9 100644 (file)
--- a/src/auth/mech-winbind.c
+++ b/src/auth/mech-winbind.c
@@ -226,9 +226,8 @@ do_auth_continue(struct auth_request *auth_request,
                buffer_t *buf;
 
                buf = t_base64_decode_str(token[1]);
-               auth_request->callback(auth_request,
-                                      AUTH_CLIENT_RESULT_CONTINUE,
-                                      buf->data, buf->used);
+               auth_request_handler_reply_continue(auth_request, buf->data,
+                                                   buf->used);
                request->continued = TRUE;
                return HR_OK;
        } else if (strcmp(token[0], "NA") == 0) {

diff --git a/src/auth/mech.c b/src/auth/mech.c
index bbcff3bd68c19677d7562d610322a21273de5c6f..76b3cd080604f7a7fba7a84f339568555f73c339 100644 (file)
--- a/src/auth/mech.c
+++ b/src/auth/mech.c
@@ -50,8 +50,7 @@ void mech_generic_auth_initial(struct auth_request *request,
                               const unsigned char *data, size_t data_size)
 {
        if (data == NULL) {
-               request->callback(request, AUTH_CLIENT_RESULT_CONTINUE,
-                                 NULL, 0);
+               auth_request_handler_reply_continue(request, NULL, 0);
        } else {
                /* initial reply given, even if it was 0 bytes */
                request->mech->auth_continue(request, data, data_size);

diff --git a/src/auth/mech.h b/src/auth/mech.h
index b8bb41629103b31d4bce2c4db51df08dcbf343dc..ac0bb7faf2e584f5778346bd6ac6fec793167174 100644 (file)
--- a/src/auth/mech.h
+++ b/src/auth/mech.h
@@ -3,20 +3,11 @@
 
 #include "auth-client-interface.h"
 
-enum auth_client_result {
-       AUTH_CLIENT_RESULT_CONTINUE = 1,
-       AUTH_CLIENT_RESULT_SUCCESS,
-       AUTH_CLIENT_RESULT_FAILURE
-};
-
 struct auth_settings;
 struct auth_request;
 
-typedef void mech_callback_t(struct auth_request *request,
-                            enum auth_client_result result,
-                            const void *reply, size_t reply_size);
-
 #include "auth-request.h"
+#include "auth-request-handler.h"
 
 /* Used only for string sanitization. */
 #define MAX_MECH_NAME_LEN 64