auth: auth-worker-client - Use connection structure

Simplifies following commits

diff --git a/src/auth/auth-worker-client.c b/src/auth/auth-worker-client.c
index dd5c3753a5af2d852cde6a1daec6c3d5ff6a9b05..da42e03a819e7a1d7045a7163423fd593130e960 100644 (file)
--- a/src/auth/auth-worker-client.c
+++ b/src/auth/auth-worker-client.c
@@ -2,6 +2,7 @@
 
 #include "auth-common.h"
 #include "base64.h"
+#include "connection.h"
 #include "ioloop.h"
 #include "net.h"
 #include "istream.h"
@@ -24,13 +25,10 @@
 #define CLIENT_STATE_STOP "waiting for shutdown"
 
 struct auth_worker_client {
+       struct connection conn;
        int refcount;
 
         struct auth *auth;
-       int fd;
-       struct io *io;
-       struct istream *input;
-       struct ostream *output;
        struct timeout *to_idle;
        time_t cmd_start;
 
@@ -69,11 +67,11 @@ void auth_worker_refresh_proctitle(const char *state)
 static void
 auth_worker_client_check_throttle(struct auth_worker_client *client)
 {
-       if (o_stream_get_buffer_used_size(client->output) >=
+       if (o_stream_get_buffer_used_size(client->conn.output) >=
            OUTBUF_THROTTLE_SIZE) {
                /* stop reading new requests until client has read the pending
                   replies. */
-               io_remove(&client->io);
+               io_remove(&client->conn.io);
        }
 }
 
@@ -123,9 +121,9 @@ static void auth_worker_send_reply(struct auth_worker_client *client,
        const char *p;
 
        if (worker_restart_request)
-               o_stream_nsend_str(client->output, "RESTART\n");
-       o_stream_nsend(client->output, str_data(str), str_len(str));
-       if (o_stream_flush(client->output) < 0 && request != NULL &&
+               o_stream_nsend_str(client->conn.output, "RESTART\n");
+       o_stream_nsend(client->conn.output, str_data(str), str_len(str));
+       if (o_stream_flush(client->conn.output) < 0 && request != NULL &&
            cmd_duration > AUTH_WORKER_WARN_DISCONNECTED_LONG_CMD_SECS) {
                p = i_strchr_to_next(str_c(str), '\t');
                p = p == NULL ? "BUG" : t_strcut(p, '\t');
@@ -535,7 +533,7 @@ static void list_iter_deinit(struct auth_worker_list_context *ctx)
        struct auth_worker_client *client = ctx->client;
        string_t *str;
 
-       i_assert(client->io == NULL);
+       i_assert(client->conn.io == NULL);
 
        str = t_str_new(32);
        if (ctx->auth_request->userdb->userdb->iface->
@@ -545,10 +543,12 @@ static void list_iter_deinit(struct auth_worker_list_context *ctx)
                str_printfa(str, "%u\tOK\n", ctx->auth_request->id);
        auth_worker_send_reply(client, NULL, str);
 
-       client->io = io_add(client->fd, IO_READ, auth_worker_input, client);
+       client->conn.io = io_add(client->conn.fd_in, IO_READ,
+                                auth_worker_input, client);
        auth_worker_client_set_idle_timeout(client);
 
-       o_stream_set_flush_callback(client->output, auth_worker_output, client);
+       o_stream_set_flush_callback(client->conn.output, auth_worker_output,
+                                   client);
        auth_request_unref(&ctx->auth_request);
        auth_worker_client_unref(&client);
        i_free(ctx);
@@ -570,11 +570,11 @@ static void list_iter_callback(const char *user, void *context)
        }
 
        if (!ctx->sending)
-               o_stream_cork(ctx->client->output);
+               o_stream_cork(ctx->client->conn.output);
        T_BEGIN {
                str = t_str_new(128);
                str_printfa(str, "%u\t*\t%s\n", ctx->auth_request->id, user);
-               o_stream_nsend(ctx->client->output, str_data(str), str_len(str));
+               o_stream_nsend(ctx->client->conn.output, str_data(str), str_len(str));
        } T_END;
 
        if (ctx->sending) {
@@ -590,27 +590,27 @@ static void list_iter_callback(const char *user, void *context)
                        ctx->auth_request->userdb->userdb->iface->
                                iterate_next(ctx->iter);
                } T_END;
-               if (o_stream_get_buffer_used_size(ctx->client->output) > OUTBUF_THROTTLE_SIZE) {
-                       if (o_stream_flush(ctx->client->output) < 0) {
+               if (o_stream_get_buffer_used_size(ctx->client->conn.output) > OUTBUF_THROTTLE_SIZE) {
+                       if (o_stream_flush(ctx->client->conn.output) < 0) {
                                ctx->done = TRUE;
                                break;
                        }
                }
        } while (ctx->sent &&
-                o_stream_get_buffer_used_size(ctx->client->output) <= OUTBUF_THROTTLE_SIZE);
-       o_stream_uncork(ctx->client->output);
+                o_stream_get_buffer_used_size(ctx->client->conn.output) <= OUTBUF_THROTTLE_SIZE);
+       o_stream_uncork(ctx->client->conn.output);
        ctx->sending = FALSE;
        if (ctx->done)
                list_iter_deinit(ctx);
        else
-               o_stream_set_flush_pending(ctx->client->output, TRUE);
+               o_stream_set_flush_pending(ctx->client->conn.output, TRUE);
 }
 
 static int auth_worker_list_output(struct auth_worker_list_context *ctx)
 {
        int ret;
 
-       if ((ret = o_stream_flush(ctx->client->output)) < 0) {
+       if ((ret = o_stream_flush(ctx->client->conn.output)) < 0) {
                list_iter_deinit(ctx);
                return 1;
        }
@@ -649,10 +649,10 @@ auth_worker_handle_list(struct auth_worker_client *client,
        }
        ctx->auth_request->userdb = userdb;
 
-       io_remove(&ctx->client->io);
+       io_remove(&ctx->client->conn.io);
        timeout_remove(&ctx->client->to_idle);
 
-       o_stream_set_flush_callback(ctx->client->output,
+       o_stream_set_flush_callback(ctx->client->conn.output,
                                    auth_worker_list_output, ctx);
        ctx->iter = ctx->auth_request->userdb->userdb->iface->
                iterate_init(ctx->auth_request, list_iter_callback, ctx);
@@ -694,7 +694,7 @@ auth_worker_handle_line(struct auth_worker_client *client, const char *line)
                i_error("BUG: Auth-worker received unknown command: %s",
                        args[1]);
        }
-       if (client->io != NULL)
+       if (client->conn.io != NULL)
                auth_worker_refresh_proctitle(CLIENT_STATE_IDLE);
         return ret;
 }
@@ -722,7 +722,7 @@ static void auth_worker_input(struct auth_worker_client *client)
        char *line;
        bool ret;
 
-       switch (i_stream_read(client->input)) {
+       switch (i_stream_read(client->conn.input)) {
        case 0:
                return;
        case -1:
@@ -738,7 +738,7 @@ static void auth_worker_input(struct auth_worker_client *client)
        }
 
        if (!client->version_received) {
-               line = i_stream_next_line(client->input);
+               line = i_stream_next_line(client->conn.input);
                if (line == NULL)
                        return;
 
@@ -752,7 +752,7 @@ static void auth_worker_input(struct auth_worker_client *client)
                client->version_received = TRUE;
        }
        if (!client->dbhash_received) {
-               line = i_stream_next_line(client->input);
+               line = i_stream_next_line(client->conn.input);
                if (line == NULL)
                        return;
 
@@ -768,7 +768,7 @@ static void auth_worker_input(struct auth_worker_client *client)
        }
 
         client->refcount++;
-       while ((line = i_stream_next_line(client->input)) != NULL) {
+       while ((line = i_stream_next_line(client->conn.input)) != NULL) {
                T_BEGIN {
                        ret = auth_worker_handle_line(client, line);
                } T_END;
@@ -786,15 +786,15 @@ static void auth_worker_input(struct auth_worker_client *client)
 
 static int auth_worker_output(struct auth_worker_client *client)
 {
-       if (o_stream_flush(client->output) < 0) {
+       if (o_stream_flush(client->conn.output) < 0) {
                auth_worker_client_destroy(&client);
                return 1;
        }
 
-       if (o_stream_get_buffer_used_size(client->output) <=
-           OUTBUF_THROTTLE_SIZE/3 && client->io == NULL) {
+       if (o_stream_get_buffer_used_size(client->conn.output) <=
+           OUTBUF_THROTTLE_SIZE/3 && client->conn.io == NULL) {
                /* allow input again */
-               client->io = io_add(client->fd, IO_READ,
+               client->conn.io = io_add(client->conn.fd_in, IO_READ,
                                    auth_worker_input, client);
        }
        return 1;
@@ -811,12 +811,13 @@ auth_worker_client_create(struct auth *auth,
        client->refcount = 1;
 
        client->auth = auth;
-       client->fd = fd;
-       client->input = i_stream_create_fd(fd, AUTH_WORKER_MAX_LINE_LENGTH);
-       client->output = o_stream_create_fd(fd, (size_t)-1);
-       o_stream_set_no_error_handling(client->output, TRUE);
-       o_stream_set_flush_callback(client->output, auth_worker_output, client);
-       client->io = io_add(fd, IO_READ, auth_worker_input, client);
+       client->conn.fd_in = fd;
+       client->conn.input = i_stream_create_fd(fd, AUTH_WORKER_MAX_LINE_LENGTH);
+       client->conn.output = o_stream_create_fd(fd, (size_t)-1);
+       o_stream_set_no_error_handling(client->conn.output, TRUE);
+       o_stream_set_flush_callback(client->conn.output, auth_worker_output,
+                                   client);
+       client->conn.io = io_add(fd, IO_READ, auth_worker_input, client);
        auth_worker_client_set_idle_timeout(client);
        auth_worker_refresh_proctitle(CLIENT_STATE_HANDSHAKE);
 
@@ -831,17 +832,17 @@ static void auth_worker_client_destroy(struct auth_worker_client **_client)
        struct auth_worker_client *client = *_client;
 
        *_client = NULL;
-       if (client->fd == -1)
+       if (client->conn.fd_in == -1)
                return;
 
-       i_stream_close(client->input);
-       o_stream_close(client->output);
+       i_stream_close(client->conn.input);
+       o_stream_close(client->conn.output);
 
        timeout_remove(&client->to_idle);
-       io_remove(&client->io);
+       io_remove(&client->conn.io);
 
-       net_disconnect(client->fd);
-       client->fd = -1;
+       net_disconnect(client->conn.fd_in);
+       client->conn.fd_in = -1;
        auth_worker_client_unref(&client);
 
        auth_worker_client = NULL;
@@ -858,8 +859,8 @@ static void auth_worker_client_unref(struct auth_worker_client **_client)
        if (--client->refcount > 0)
                return;
 
-       i_stream_unref(&client->input);
-       o_stream_unref(&client->output);
+       i_stream_unref(&client->conn.input);
+       o_stream_unref(&client->conn.output);
        i_free(client);
 }
 
@@ -868,7 +869,7 @@ void auth_worker_client_send_error(void)
        auth_worker_client_error = TRUE;
        if (auth_worker_client != NULL &&
            !auth_worker_client->error_sent) {
-               o_stream_nsend_str(auth_worker_client->output, "ERROR\n");
+               o_stream_nsend_str(auth_worker_client->conn.output, "ERROR\n");
                auth_worker_client->error_sent = TRUE;
        }
        auth_worker_refresh_proctitle("");
@@ -880,17 +881,19 @@ void auth_worker_client_send_success(void)
        if (auth_worker_client == NULL)
                return;
        if (auth_worker_client->error_sent) {
-               o_stream_nsend_str(auth_worker_client->output, "SUCCESS\n");
+               o_stream_nsend_str(auth_worker_client->conn.output,
+                                  "SUCCESS\n");
                auth_worker_client->error_sent = FALSE;
        }
-       if (auth_worker_client->io != NULL)
+       if (auth_worker_client->conn.io != NULL)
                auth_worker_refresh_proctitle(CLIENT_STATE_IDLE);
 }
 
 void auth_worker_client_send_shutdown(void)
 {
        if (auth_worker_client != NULL)
-               o_stream_nsend_str(auth_worker_client->output, "SHUTDOWN\n");
+               o_stream_nsend_str(auth_worker_client->conn.output,
+                                  "SHUTDOWN\n");
        auth_worker_refresh_proctitle(CLIENT_STATE_STOP);
 }