connection.c revision 88df77efd9ffdfd9a62bca0a9c8f403ecdbea3ff
0N/A/* Copyright (c) 2013 Dovecot authors, see the included COPYING file */
3983N/A
0N/A#include "lib.h"
0N/A#include "ioloop.h"
0N/A#include "istream.h"
0N/A#include "ostream.h"
0N/A#include "net.h"
0N/A#include "strescape.h"
0N/A#include "llist.h"
0N/A#include "connection.h"
0N/A
0N/A#include <unistd.h>
0N/A
0N/Astatic void connection_idle_timeout(struct connection *conn)
0N/A{
0N/A conn->disconnect_reason = CONNECTION_DISCONNECT_IDLE_TIMEOUT;
0N/A conn->list->v.destroy(conn);
0N/A}
1472N/A
1472N/Astatic void connection_connect_timeout(struct connection *conn)
1472N/A{
0N/A conn->disconnect_reason = CONNECTION_DISCONNECT_CONNECT_TIMEOUT;
0N/A conn->list->v.destroy(conn);
0N/A}
1879N/A
1879N/Avoid connection_input_default(struct connection *conn)
1879N/A{
1879N/A const char *line;
1879N/A struct istream *input;
1879N/A int ret = 0;
0N/A
0N/A switch (connection_input_read(conn)) {
0N/A case -1:
1064N/A return;
1064N/A case 0: /* allow calling this function for buffered input */
1064N/A case 1:
1064N/A break;
0N/A default:
1064N/A i_unreached();
1064N/A }
0N/A
0N/A input = conn->input;
0N/A i_stream_ref(input);
0N/A while (!input->closed && (line = i_stream_next_line(input)) != NULL) {
0N/A T_BEGIN {
0N/A ret = conn->list->v.input_line(conn, line);
0N/A } T_END;
0N/A if (ret <= 0)
0N/A break;
1064N/A }
0N/A if (ret < 0 && !input->closed) {
1064N/A conn->disconnect_reason = CONNECTION_DISCONNECT_DEINIT;
0N/A conn->list->v.destroy(conn);
1365N/A }
1064N/A i_stream_unref(&input);
1064N/A}
0N/A
1064N/Aint connection_verify_version(struct connection *conn,
1064N/A const char *const *args)
0N/A{
0N/A unsigned int recv_major_version;
0N/A
3210N/A /* VERSION <tab> service_name <tab> major version <tab> minor version */
0N/A if (str_array_length(args) != 4 ||
3231N/A strcmp(args[0], "VERSION") != 0 ||
0N/A str_to_uint(args[2], &recv_major_version) < 0 ||
0N/A str_to_uint(args[3], &conn->minor_version) < 0) {
1064N/A i_error("%s didn't reply with a valid VERSION line",
0N/A conn->name);
0N/A return -1;
0N/A }
1788N/A
2796N/A if (strcmp(args[1], conn->list->set.service_name_in) != 0) {
2796N/A i_error("%s: Connected to wrong socket type. "
2796N/A "We want '%s', but received '%s'", conn->name,
1788N/A conn->list->set.service_name_in, args[1]);
2796N/A return -1;
1879N/A }
2215N/A
2215N/A if (recv_major_version != conn->list->set.major_version) {
3983N/A i_error("%s: Socket supports major version %u, "
3983N/A "but we support only %u (mixed old and new binaries?)",
3983N/A conn->name, recv_major_version,
3983N/A conn->list->set.major_version);
3983N/A return -1;
3983N/A }
3983N/A return 0;
3983N/A}
3983N/A
3983N/Aint connection_input_line_default(struct connection *conn, const char *line)
3983N/A{
3983N/A const char *const *args;
3983N/A
3983N/A args = t_strsplit_tabescaped(line);
3983N/A if (!conn->version_received) {
3983N/A if (connection_verify_version(conn, args) < 0)
3983N/A return -1;
3983N/A conn->version_received = TRUE;
3983N/A return 1;
3983N/A }
3983N/A
3983N/A return conn->list->v.input_args(conn, args);
3983N/A}
3983N/A
3983N/Astatic void connection_init_streams(struct connection *conn)
3983N/A{
3983N/A const struct connection_settings *set = &conn->list->set;
3983N/A
3983N/A i_assert(conn->io == NULL);
3983N/A i_assert(conn->input == NULL);
3983N/A i_assert(conn->output == NULL);
3983N/A i_assert(conn->to == NULL);
3983N/A
3983N/A conn->version_received = set->major_version == 0;
3983N/A
3983N/A if (set->input_max_size != 0) {
3983N/A conn->input = i_stream_create_fd(conn->fd_in,
3983N/A set->input_max_size, FALSE);
3983N/A i_stream_set_name(conn->input, conn->name);
3983N/A }
3983N/A if (set->output_max_size != 0) {
3983N/A conn->output = o_stream_create_fd(conn->fd_out,
4133N/A set->output_max_size, FALSE);
4133N/A o_stream_set_no_error_handling(conn->output, TRUE);
4133N/A o_stream_set_name(conn->output, conn->name);
3983N/A }
3983N/A conn->io = io_add(conn->fd_in, IO_READ, *conn->list->v.input, conn);
3983N/A if (set->input_idle_timeout_secs != 0) {
3983N/A conn->to = timeout_add(set->input_idle_timeout_secs*1000,
3983N/A connection_idle_timeout, conn);
3983N/A }
3983N/A if (set->major_version != 0 && !set->dont_send_version) {
1879N/A o_stream_nsend_str(conn->output, t_strdup_printf(
"VERSION\t%s\t%u\t%u\n", set->service_name_out,
set->major_version, set->minor_version));
}
}
static void connection_client_connected(struct connection *conn, bool success)
{
i_assert(conn->list->set.client);
if (success)
connection_init_streams(conn);
if (conn->list->v.client_connected != NULL)
conn->list->v.client_connected(conn, success);
if (!success) {
conn->disconnect_reason =
CONNECTION_DISCONNECT_CONN_CLOSED;
conn->list->v.destroy(conn);
}
}
void connection_init_server(struct connection_list *list,
struct connection *conn, const char *name,
int fd_in, int fd_out)
{
i_assert(name != NULL);
i_assert(!list->set.client);
conn->list = list;
conn->name = i_strdup(name);
conn->fd_in = fd_in;
conn->fd_out = fd_out;
connection_init_streams(conn);
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
}
void connection_init_client_ip(struct connection_list *list,
struct connection *conn,
const struct ip_addr *ip, unsigned int port)
{
i_assert(list->set.client);
conn->fd_in = conn->fd_out = -1;
conn->list = list;
conn->name = i_strdup_printf("%s:%u", net_ip2addr(ip), port);
conn->ip = *ip;
conn->port = port;
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
}
void connection_init_client_unix(struct connection_list *list,
struct connection *conn, const char *path)
{
i_assert(list->set.client);
conn->fd_in = conn->fd_out = -1;
conn->list = list;
conn->name = i_strdup(path);
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
}
static void connection_ip_connected(struct connection *conn)
{
io_remove(&conn->io);
if (conn->to != NULL)
timeout_remove(&conn->to);
errno = net_geterror(conn->fd_in);
connection_client_connected(conn, errno == 0);
}
int connection_client_connect(struct connection *conn)
{
const struct connection_settings *set = &conn->list->set;
int fd;
i_assert(conn->list->set.client);
i_assert(conn->fd_in == -1);
if (conn->port != 0)
fd = net_connect_ip(&conn->ip, conn->port, NULL);
else
fd = net_connect_unix(conn->name);
if (fd == -1)
return -1;
conn->fd_in = conn->fd_out = fd;
if (conn->port != 0) {
conn->io = io_add(conn->fd_out, IO_WRITE,
connection_ip_connected, conn);
if (set->client_connect_timeout_msecs != 0) {
conn->to = timeout_add(set->client_connect_timeout_msecs,
connection_connect_timeout, conn);
}
} else {
connection_client_connected(conn, TRUE);
}
return 0;
}
void connection_disconnect(struct connection *conn)
{
if (conn->to != NULL)
timeout_remove(&conn->to);
if (conn->io != NULL)
io_remove(&conn->io);
if (conn->input != NULL) {
i_stream_close(conn->input);
i_stream_destroy(&conn->input);
}
if (conn->output != NULL) {
o_stream_close(conn->output);
o_stream_destroy(&conn->output);
}
if (conn->fd_in != -1) {
if (close(conn->fd_in) < 0)
i_error("close(%s) failed: %m", conn->name);
if (conn->fd_in != conn->fd_out && close(conn->fd_out) < 0)
i_error("close(%s/out) failed: %m", conn->name);
conn->fd_in = conn->fd_out = -1;
}
}
void connection_deinit(struct connection *conn)
{
i_assert(conn->list->connections_count > 0);
conn->list->connections_count--;
DLLIST_REMOVE(&conn->list->connections, conn);
connection_disconnect(conn);
i_free(conn->name);
}
int connection_input_read(struct connection *conn)
{
conn->last_input = ioloop_time;
if (conn->to != NULL)
timeout_reset(conn->to);
switch (i_stream_read(conn->input)) {
case -2:
/* buffer full */
switch (conn->list->set.input_full_behavior) {
case CONNECTION_BEHAVIOR_DESTROY:
conn->disconnect_reason =
CONNECTION_DISCONNECT_BUFFER_FULL;
conn->list->v.destroy(conn);
return -1;
case CONNECTION_BEHAVIOR_ALLOW:
return -2;
}
case -1:
/* disconnected */
conn->disconnect_reason =
CONNECTION_DISCONNECT_CONN_CLOSED;
conn->list->v.destroy(conn);
return -1;
case 0:
/* nothing new read */
return 0;
default:
/* something was read */
return 1;
}
}
const char *connection_disconnect_reason(struct connection *conn)
{
if (conn->input != NULL && conn->input->stream_errno != 0)
errno = conn->input->stream_errno;
else if (conn->output != NULL && conn->output->stream_errno != 0)
errno = conn->output->stream_errno;
else
errno = 0;
return errno == 0 || errno == EPIPE ? "Connection closed" :
t_strdup_printf("Connection closed: %m");
}
void connection_switch_ioloop(struct connection *conn)
{
if (conn->io != NULL)
conn->io = io_loop_move_io(&conn->io);
if (conn->to != NULL)
conn->to = io_loop_move_timeout(&conn->to);
if (conn->output != NULL)
o_stream_switch_ioloop(conn->output);
}
struct connection_list *
connection_list_init(const struct connection_settings *set,
const struct connection_vfuncs *vfuncs)
{
struct connection_list *list;
i_assert(vfuncs->input != NULL ||
set->input_full_behavior != CONNECTION_BEHAVIOR_ALLOW);
i_assert(set->major_version == 0 ||
(set->service_name_in != NULL &&
set->service_name_out != NULL));
list = i_new(struct connection_list, 1);
list->set = *set;
list->v = *vfuncs;
if (list->v.input == NULL)
list->v.input = connection_input_default;
if (list->v.input_line == NULL)
list->v.input_line = connection_input_line_default;
return list;
}
void connection_list_deinit(struct connection_list **_list)
{
struct connection_list *list = *_list;
struct connection *conn;
*_list = NULL;
while (list->connections != NULL) {
conn = list->connections;
conn->disconnect_reason = CONNECTION_DISCONNECT_DEINIT;
list->v.destroy(conn);
i_assert(conn != list->connections);
}
i_free(list);
}