dict: Use connection struct

Prepares for moving into connection API

diff --git a/src/dict/dict-commands.c b/src/dict/dict-commands.c
index e79aa8bf6f377853c086ff63c437640a43fc998d..77e8f0e5b32d6e8d34571216b87ba6b6696e1cf0 100644 (file)
--- a/src/dict/dict-commands.c
+++ b/src/dict/dict-commands.c
@@ -76,7 +76,7 @@ static void dict_connection_cmds_flush(struct dict_connection *conn)
 {
        struct dict_connection_cmd *cmd, *const *first_cmdp;
 
-       i_assert(conn->minor_version < DICT_CLIENT_PROTOCOL_UNORDERED_MIN_VERSION);
+       i_assert(conn->conn.minor_version < DICT_CLIENT_PROTOCOL_UNORDERED_MIN_VERSION);
 
        dict_connection_ref(conn);
        while (array_count(&conn->cmds) > 0) {
@@ -94,7 +94,7 @@ static void dict_connection_cmds_flush(struct dict_connection *conn)
                        break;
                }
 
-               o_stream_nsend_str(conn->output, cmd->reply);
+               o_stream_nsend_str(conn->conn.output, cmd->reply);
                dict_connection_cmd_remove(cmd);
        }
        dict_connection_unref_safe(conn);
@@ -105,29 +105,30 @@ static void dict_connection_cmd_try_flush(struct dict_connection_cmd **_cmd)
        struct dict_connection_cmd *cmd = *_cmd;
 
        *_cmd = NULL;
-       if (cmd->conn->minor_version < DICT_CLIENT_PROTOCOL_UNORDERED_MIN_VERSION) {
+       if (cmd->conn->conn.minor_version < DICT_CLIENT_PROTOCOL_UNORDERED_MIN_VERSION) {
                dict_connection_cmds_flush(cmd->conn);
                return;
        }
        i_assert(cmd->async_reply_id != 0);
        i_assert(cmd->reply != NULL);
 
-       o_stream_nsend_str(cmd->conn->output, t_strdup_printf("%c%u\t%s",
+       o_stream_nsend_str(cmd->conn->conn.output, t_strdup_printf("%c%u\t%s",
                DICT_PROTOCOL_REPLY_ASYNC_REPLY,
                cmd->async_reply_id, cmd->reply));
+       o_stream_flush(cmd->conn->conn.output);
        dict_connection_cmd_remove(cmd);
 }
 
 static void dict_connection_cmd_async(struct dict_connection_cmd *cmd)
 {
-       if (cmd->conn->minor_version < DICT_CLIENT_PROTOCOL_UNORDERED_MIN_VERSION)
+       if (cmd->conn->conn.minor_version < DICT_CLIENT_PROTOCOL_UNORDERED_MIN_VERSION)
                return;
 
        i_assert(cmd->async_reply_id == 0);
        cmd->async_reply_id = ++cmd->conn->async_id_counter;
        if (cmd->async_reply_id == 0)
                cmd->async_reply_id = ++cmd->conn->async_id_counter;
-       o_stream_nsend_str(cmd->conn->output, t_strdup_printf("%c%u\n",
+       o_stream_nsend_str(cmd->conn->conn.output, t_strdup_printf("%c%u\n",
                DICT_PROTOCOL_REPLY_ASYNC_ID, cmd->async_reply_id));
 }
 
@@ -153,7 +154,7 @@ dict_cmd_reply_handle_stats(struct dict_connection_cmd *cmd,
        io_loop_time_refresh();
        cmd_stats_update(cmd, stats);
 
-       if (cmd->conn->minor_version < DICT_CLIENT_PROTOCOL_TIMINGS_MIN_VERSION)
+       if (cmd->conn->conn.minor_version < DICT_CLIENT_PROTOCOL_TIMINGS_MIN_VERSION)
                return;
        str_printfa(str, "\t%ld\t%u\t%ld\t%u",
                    (long)cmd->start_timeval.tv_sec,
@@ -170,7 +171,7 @@ cmd_lookup_write_reply(struct dict_connection_cmd *cmd,
 
        i_assert(values[0] != NULL);
 
-       if (cmd->conn->minor_version < DICT_CLIENT_PROTOCOL_VERSION_MIN_MULTI_OK ||
+       if (cmd->conn->conn.minor_version < DICT_CLIENT_PROTOCOL_VERSION_MIN_MULTI_OK ||
            values[1] == NULL) {
                str_append_c(str, DICT_PROTOCOL_REPLY_OK);
                str_append_tabescaped(str, values[0]);
@@ -219,12 +220,12 @@ static int cmd_lookup(struct dict_connection_cmd *cmd, const char *line)
 
 static bool dict_connection_flush_if_full(struct dict_connection *conn)
 {
-       if (o_stream_get_buffer_used_size(conn->output) >
+       if (o_stream_get_buffer_used_size(conn->conn.output) >
            DICT_OUTPUT_OPTIMAL_SIZE) {
-               if (o_stream_flush(conn->output) <= 0) {
+               if (o_stream_flush(conn->conn.output) <= 0) {
                        /* continue later when there's more space
                           in output buffer */
-                       o_stream_set_flush_pending(conn->output, TRUE);
+                       o_stream_set_flush_pending(conn->conn.output, TRUE);
                        return FALSE;
                }
                /* flushed everything, continue */
@@ -253,7 +254,7 @@ static int cmd_iterate_flush(struct dict_connection_cmd *cmd)
                if ((cmd->iter_flags & DICT_ITERATE_FLAG_NO_VALUE) == 0)
                        str_append_tabescaped(str, value);
                str_append_c(str, '\n');
-               o_stream_nsend(cmd->conn->output, str_data(str), str_len(str));
+               o_stream_nsend(cmd->conn->conn.output, str_data(str), str_len(str));
 
                if (!dict_connection_flush_if_full(cmd->conn))
                        return 0;
@@ -281,9 +282,9 @@ static void cmd_iterate_callback(void *context)
        struct dict_connection *conn = cmd->conn;
 
        dict_connection_ref(conn);
-       o_stream_cork(conn->output);
+       o_stream_cork(conn->conn.output);
        dict_connection_cmd_output_more(cmd);
-       o_stream_uncork(conn->output);
+       o_stream_uncork(conn->conn.output);
        dict_connection_unref_safe(conn);
 }
 
@@ -639,7 +640,7 @@ static bool dict_connection_cmds_try_output_more(struct dict_connection *conn)
                        /* cmd should be freed now, restart output */
                        return TRUE;
                }
-               if (conn->minor_version < DICT_CLIENT_PROTOCOL_TIMINGS_MIN_VERSION)
+               if (conn->conn.minor_version < DICT_CLIENT_PROTOCOL_TIMINGS_MIN_VERSION)
                        break;
                /* try to flush the rest */
        }
@@ -658,7 +659,7 @@ static void dict_connection_cmd_output_more(struct dict_connection_cmd *cmd)
 {
        struct dict_connection_cmd *const *first_cmdp;
 
-       if (cmd->conn->minor_version < DICT_CLIENT_PROTOCOL_TIMINGS_MIN_VERSION) {
+       if (cmd->conn->conn.minor_version < DICT_CLIENT_PROTOCOL_TIMINGS_MIN_VERSION) {
                first_cmdp = array_front(&cmd->conn->cmds);
                if (*first_cmdp != cmd)
                        return;

diff --git a/src/dict/dict-connection.c b/src/dict/dict-connection.c
index a96581bdce4515522318e066d2d43e663e43e14f..4545d91ead383761186be69725d503f102ca1426 100644 (file)
--- a/src/dict/dict-connection.c
+++ b/src/dict/dict-connection.c
@@ -34,7 +34,7 @@ static int dict_connection_parse_handshake(struct dict_connection *conn,
                return -1;
 
        /* read minor version */
-       if (str_parse_uint(line, &conn->minor_version, &line) < 0)
+       if (str_parse_uint(line, &conn->conn.minor_version, &line) < 0)
                return -1;
        if (*line++ != '\t')
                return -1;
@@ -108,14 +108,15 @@ static int dict_connection_dict_init(struct dict_connection *conn)
        return 0;
 }
 
-static void dict_connection_input_more(struct dict_connection *conn)
+static void dict_connection_input_more(struct connection *_conn)
 {
+       struct dict_connection *conn = container_of(_conn, struct dict_connection, conn);
        const char *line;
        int ret;
 
        timeout_remove(&conn->to_input);
 
-       while ((line = i_stream_next_line(conn->input)) != NULL) {
+       while ((line = i_stream_next_line(conn->conn.input)) != NULL) {
                T_BEGIN {
                        ret = dict_command_input(conn, line);
                } T_END;
@@ -124,18 +125,19 @@ static void dict_connection_input_more(struct dict_connection *conn)
                        break;
                }
                if (array_count(&conn->cmds) >= DICT_CONN_MAX_PENDING_COMMANDS) {
-                       io_remove(&conn->io);
+                       io_remove(&conn->conn.io);
                        timeout_remove(&conn->to_input);
                        break;
                }
        }
 }
 
-static void dict_connection_input(struct dict_connection *conn)
+static void dict_connection_input(struct connection *_conn)
 {
+       struct dict_connection *conn = container_of(_conn, struct dict_connection, conn);
        const char *line;
 
-       switch (i_stream_read(conn->input)) {
+       switch (i_stream_read(conn->conn.input)) {
        case 0:
                return;
        case -1:
@@ -152,7 +154,7 @@ static void dict_connection_input(struct dict_connection *conn)
 
        if (conn->username == NULL) {
                /* handshake not received yet */
-               if ((line = i_stream_next_line(conn->input)) == NULL)
+               if ((line = i_stream_next_line(conn->conn.input)) == NULL)
                        return;
 
                if (dict_connection_parse_handshake(conn, line) < 0) {
@@ -166,24 +168,25 @@ static void dict_connection_input(struct dict_connection *conn)
                }
        }
 
-       dict_connection_input_more(conn);
+       dict_connection_input_more(&conn->conn);
 }
 
 void dict_connection_continue_input(struct dict_connection *conn)
 {
-       if (conn->io != NULL || conn->destroyed)
+       if (conn->conn.io != NULL || conn->destroyed)
                return;
 
-       conn->io = io_add(conn->fd, IO_READ, dict_connection_input, conn);
+       conn->conn.io = io_add(conn->conn.fd_in, IO_READ, dict_connection_input, &conn->conn);
        if (conn->to_input == NULL)
-               conn->to_input = timeout_add_short(0, dict_connection_input_more, conn);
+               conn->to_input = timeout_add_short(0, dict_connection_input_more, &conn->conn);
 }
 
-static int dict_connection_output(struct dict_connection *conn)
+static int dict_connection_output(struct connection *_conn)
 {
+       struct dict_connection *conn = container_of(_conn, struct dict_connection, conn);
        int ret;
 
-       if ((ret = o_stream_flush(conn->output)) < 0) {
+       if ((ret = o_stream_flush(conn->conn.output)) < 0) {
                dict_connection_destroy(conn);
                return 1;
        }
@@ -199,12 +202,12 @@ dict_connection_create(struct master_service_connection *master_conn)
 
        conn = i_new(struct dict_connection, 1);
        conn->refcount = 1;
-       conn->fd = master_conn->fd;
-       conn->input = i_stream_create_fd(master_conn->fd, DICT_CLIENT_MAX_LINE_LENGTH);
-       conn->output = o_stream_create_fd(master_conn->fd, 128*1024);
-       o_stream_set_no_error_handling(conn->output, TRUE);
-       o_stream_set_flush_callback(conn->output, dict_connection_output, conn);
-       conn->io = io_add(master_conn->fd, IO_READ, dict_connection_input, conn);
+       conn->conn.fd_in = conn->conn.fd_out = master_conn->fd;
+       conn->conn.input = i_stream_create_fd(conn->conn.fd_in, DICT_CLIENT_MAX_LINE_LENGTH);
+       conn->conn.output = o_stream_create_fd(conn->conn.fd_out, 128*1024);
+       o_stream_set_no_error_handling(conn->conn.output, TRUE);
+       o_stream_set_flush_callback(conn->conn.output, dict_connection_output, &conn->conn);
+       conn->conn.io = io_add(conn->conn.fd_in, IO_READ, dict_connection_input, &conn->conn);
        i_array_init(&conn->cmds, DICT_CONN_MAX_PENDING_COMMANDS);
 
        dict_connections_count++;
@@ -243,8 +246,8 @@ bool dict_connection_unref(struct dict_connection *conn)
        if (array_is_created(&conn->transactions))
                array_free(&conn->transactions);
 
-       i_stream_destroy(&conn->input);
-       o_stream_destroy(&conn->output);
+       i_stream_destroy(&conn->conn.input);
+       o_stream_destroy(&conn->conn.output);
 
        array_free(&conn->cmds);
        i_free(conn->name);
@@ -288,12 +291,11 @@ void dict_connection_destroy(struct dict_connection *conn)
        DLLIST_REMOVE(&dict_connections, conn);
 
        timeout_remove(&conn->to_input);
-       io_remove(&conn->io);
-       i_stream_close(conn->input);
-       o_stream_close(conn->output);
-       if (close(conn->fd) < 0)
-               i_error("close(dict client) failed: %m");
-       conn->fd = -1;
+       io_remove(&conn->conn.io);
+       i_stream_close(conn->conn.input);
+       o_stream_close(conn->conn.output);
+       i_close_fd(&conn->conn.fd_in);
+       conn->conn.fd_out = -1;
 
        /* the connection is closed, but there may still be commands left
           running. finish them, even if the calling client can't be notified

diff --git a/src/dict/dict-connection.h b/src/dict/dict-connection.h
index 512ec10443d7a842da8a4015839e211a4b7a76bd..39ad421bb03db2c24478fbdadbf23ef3c01fea55 100644 (file)
--- a/src/dict/dict-connection.h
+++ b/src/dict/dict-connection.h
@@ -2,6 +2,7 @@
 #define DICT_CONNECTION_H
 
 #include "dict.h"
+#include "connection.h"
 
 struct dict_connection_transaction {
        unsigned int id;
@@ -10,6 +11,7 @@ struct dict_connection_transaction {
 };
 
 struct dict_connection {
+       struct connection conn;
        struct dict_connection *prev, *next;
        struct dict_server *server;
        int refcount;
@@ -18,12 +20,7 @@ struct dict_connection {
        char *name;
        struct dict *dict;
        enum dict_data_type value_type;
-       unsigned int minor_version;
 
-       int fd;
-       struct io *io;
-       struct istream *input;
-       struct ostream *output;
        struct timeout *to_input;
        struct timeout *to_unref;