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 if (conn->list->set.unix_client_connect_msecs == 0)
fd = net_connect_unix(conn->name);
else
fd = net_connect_unix_with_retries(conn->name, conn->list->set.unix_client_connect_msecs);
if (fd == -1)
return -1;
conn->fd_in = conn->fd_out = fd;
if (conn->port != 0 ||
conn->list->set.delayed_unix_client_connected_callback) {
conn->io = io_add(conn->fd_out, IO_WRITE,
connection_socket_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;
}
static int
master_service_open_config(struct master_service *service,
const struct master_service_settings_input *input,
const char **path_r, const char **error_r)
{
struct stat st;
const char *path;
int fd;
*path_r = path = input->config_path != NULL ? input->config_path :
master_service_get_config_path(service);
if (service->config_fd != -1 && input->config_path == NULL &&
!service->config_path_changed_with_param) {
/* use the already opened config socket */
fd = service->config_fd;
service->config_fd = -1;
return fd;
}
if (!service->config_path_from_master &&
!service->config_path_changed_with_param &&
input->config_path == NULL) {
/* first try to connect to the default config socket.
configuration may contain secrets, so in default config
this fails because the socket is 0600. it's useful for
developers though. :) */
fd = net_connect_unix(DOVECOT_CONFIG_SOCKET_PATH);
if (fd >= 0) {
*path_r = DOVECOT_CONFIG_SOCKET_PATH;
net_set_nonblock(fd, FALSE);
return fd;
}
/* fallback to executing doveconf */
}
if (stat(path, &st) < 0) {
*error_r = errno == EACCES ? eacces_error_get("stat", path) :
t_strdup_printf("stat(%s) failed: %m", path);
return -1;
}
if (!S_ISSOCK(st.st_mode) && !S_ISFIFO(st.st_mode)) {
/* it's not an UNIX socket, don't even try to connect */
fd = -1;
errno = ENOTSOCK;
} else {
fd = net_connect_unix_with_retries(path, 1000);
}
if (fd < 0) {
*error_r = t_strdup_printf("net_connect_unix(%s) failed: %m",
path);
config_exec_fallback(service, input);
return -1;
}
net_set_nonblock(fd, FALSE);
return fd;
}
int auth_server_connection_connect(struct auth_server_connection *conn)
{
const char *handshake;
int fd;
i_assert(!conn->connected);
i_assert(conn->fd == -1);
conn->last_connect = ioloop_time;
timeout_remove(&conn->to);
/* max. 1 second wait here. */
fd = net_connect_unix_with_retries(conn->client->auth_socket_path,
1000);
if (fd == -1) {
if (errno == EACCES) {
i_error("auth: %s",
eacces_error_get("connect",
conn->client->auth_socket_path));
} else {
i_error("auth: connect(%s) failed: %m",
conn->client->auth_socket_path);
}
return -1;
}
conn->fd = fd;
conn->io = io_add(fd, IO_READ, auth_server_connection_input, conn);
conn->input = i_stream_create_fd(fd, AUTH_SERVER_CONN_MAX_LINE_LENGTH);
conn->output = o_stream_create_fd(fd, (size_t)-1);
conn->connected = TRUE;
handshake = t_strdup_printf("VERSION\t%u\t%u\nCPID\t%u\n",
AUTH_CLIENT_PROTOCOL_MAJOR_VERSION,
AUTH_CLIENT_PROTOCOL_MINOR_VERSION,
conn->client->client_pid);
if (o_stream_send_str(conn->output, handshake) < 0) {
i_warning("Error sending handshake to auth server: %s",
o_stream_get_error(conn->output));
auth_server_connection_disconnect(conn,
o_stream_get_error(conn->output));
return -1;
}
conn->to = timeout_add(AUTH_HANDSHAKE_TIMEOUT,
auth_client_handshake_timeout, conn);
return 0;
}
static int
master_login_auth_connect(struct master_login_auth *auth)
{
int fd;
i_assert(auth->fd == -1);
fd = net_connect_unix_with_retries(auth->auth_socket_path, 1000);
if (fd == -1) {
i_error("net_connect_unix(%s) failed: %m",
auth->auth_socket_path);
return -1;
}
auth->fd = fd;
auth->input = i_stream_create_fd(fd, AUTH_MAX_INBUF_SIZE, FALSE);
auth->output = o_stream_create_fd(fd, (size_t)-1, FALSE);
o_stream_set_no_error_handling(auth->output, TRUE);
auth->io = io_add(fd, IO_READ, master_login_auth_input, auth);
return 0;
}
static int filter_connect(struct mail_filter_istream *mstream,
const char *socket_path, const char *args)
{
const char **argv;
string_t *str;
int fd;
argv = t_strsplit(args, " ");
if ((fd = net_connect_unix_with_retries(socket_path, 1000)) < 0) {
if (errno == EACCES) {
i_error("ext-filter: %s",
eacces_error_get("net_connect_unix",
socket_path));
} else {
i_error("ext-filter: net_connect_unix(%s) failed: %m",
socket_path);
}
return -1;
}
if (mstream->istream.istream.blocking)
net_set_nonblock(fd, FALSE);
mstream->fd = fd;
mstream->ext_in =
i_stream_create_fd(fd, mstream->istream.max_buffer_size, FALSE);
mstream->ext_out = o_stream_create_fd(fd, 0, FALSE);
str = t_str_new(256);
str_append(str, "VERSION\tscript\t3\t0\nnoreply\n");
for (; *argv != NULL; argv++) {
str_append(str, *argv);
str_append_c(str, '\n');
}
str_append_c(str, '\n');
o_stream_send(mstream->ext_out, str_data(str), str_len(str));
return 0;
}
int fts_indexer_cmd(struct mail_user *user, const char *cmd,
const char **path_r)
{
const char *path;
int fd;
path = t_strconcat(user->set->base_dir,
"/"INDEXER_SOCKET_NAME, NULL);
fd = net_connect_unix_with_retries(path, 1000);
if (fd == -1) {
i_error("net_connect_unix(%s) failed: %m", path);
return -1;
}
cmd = t_strconcat(INDEXER_HANDSHAKE, cmd, NULL);
if (write_full(fd, cmd, strlen(cmd)) < 0) {
i_error("write(%s) failed: %m", path);
i_close_fd(&fd);
return -1;
}
*path_r = path;
return fd;
}
static int
imap_hibernate_process_send(struct client *client,
const buffer_t *state, int fd_notify)
{
string_t *cmd = t_str_new(512);
const char *path;
ssize_t ret = 0;
int fd;
i_assert(state->used > 0);
path = t_strconcat(client->user->set->base_dir,
"/"IMAP_HIBERNATE_SOCKET_NAME, NULL);
fd = net_connect_unix_with_retries(path, 1000);
if (fd == -1) {
i_error("net_connect_unix(%s) failed: %m", path);
return -1;
}
net_set_nonblock(fd, FALSE);
imap_hibernate_write_cmd(client, cmd, state, fd_notify);
alarm(IMAP_HIBERNATE_SEND_TIMEOUT_SECS);
if (imap_hibernate_process_send_cmd(fd, path, cmd, client->fd_in) < 0 ||
imap_hibernate_process_read(fd, path) < 0)
ret = -1;
else if (fd_notify != -1) {
if ((ret = fd_send(fd, fd_notify, "\n", 1)) < 0)
i_error("fd_send(%s) failed: %m", path);
else
ret = imap_hibernate_process_read(fd, path);
}
alarm(0);
net_disconnect(fd);
return ret < 0 ? -1 : 0;
}