static void test_compress_file(const char *in_path, const char *out_path)
{
const struct compression_handler *handler;
struct istream *input, *file_input;
struct ostream *output, *file_output;
int fd_in, fd_out;
struct sha1_ctxt sha1;
unsigned char output_sha1[SHA1_RESULTLEN], input_sha1[SHA1_RESULTLEN];
const unsigned char *data;
size_t size;
ssize_t ret;
handler = compression_lookup_handler_from_ext(out_path);
if (handler == NULL)
i_fatal("Can't detect compression algorithm from path %s", out_path);
if (handler->create_ostream == NULL)
i_fatal("Support not compiled in for %s", handler->name);
/* write the compressed output file */
fd_in = open(in_path, O_RDONLY);
if (fd_in == -1)
i_fatal("open(%s) failed: %m", in_path);
fd_out = open(out_path, O_TRUNC | O_CREAT | O_RDWR, 0600);
if (fd_out == -1)
i_fatal("creat(%s) failed: %m", out_path);
sha1_init(&sha1);
file_output = o_stream_create_fd_file(fd_out, 0, FALSE);
output = handler->create_ostream(file_output, 1);
input = i_stream_create_fd_autoclose(&fd_in, IO_BLOCK_SIZE);
while (i_stream_read_data(input, &data, &size, 0) > 0) {
sha1_loop(&sha1, data, size);
o_stream_nsend(output, data, size);
i_stream_skip(input, size);
}
if (o_stream_nfinish(output) < 0) {
i_fatal("write(%s) failed: %s",
out_path, o_stream_get_error(output));
}
i_stream_destroy(&input);
o_stream_destroy(&output);
o_stream_destroy(&file_output);
sha1_result(&sha1, output_sha1);
/* verify that we can read the compressed file */
sha1_init(&sha1);
file_input = i_stream_create_fd(fd_out, IO_BLOCK_SIZE, FALSE);
input = handler->create_istream(file_input, FALSE);
while ((ret = i_stream_read_data(input, &data, &size, 0)) > 0) {
sha1_loop(&sha1, data, size);
i_stream_skip(input, size);
}
i_stream_destroy(&input);
i_stream_destroy(&file_input);
sha1_result(&sha1, input_sha1);
if (memcmp(input_sha1, output_sha1, sizeof(input_sha1)) != 0)
i_fatal("Decompression couldn't get the original input");
i_close_fd(&fd_out);
}
static void client_destroy(struct client *client)
{
char **app;
i_set_failure_prefix("imap-urlauth[%s](%s): ",
my_pid, client->access_user);
if (client->url != NULL) {
/* deinitialize url */
i_stream_close(client->input);
o_stream_close(client->output);
(void)client_run_url(client);
i_assert(client->url == NULL);
}
imap_urlauth_worker_client_count--;
DLLIST_REMOVE(&imap_urlauth_worker_clients, client);
if (client->urlauth_ctx != NULL)
imap_urlauth_deinit(&client->urlauth_ctx);
if (client->mail_user != NULL)
mail_user_unref(&client->mail_user);
if (client->io != NULL)
io_remove(&client->io);
if (client->ctrl_io != NULL)
io_remove(&client->ctrl_io);
if (client->to_idle != NULL)
timeout_remove(&client->to_idle);
if (client->input != NULL)
i_stream_destroy(&client->input);
if (client->output != NULL)
o_stream_destroy(&client->output);
if (client->ctrl_input != NULL)
i_stream_destroy(&client->ctrl_input);
if (client->ctrl_output != NULL)
o_stream_destroy(&client->ctrl_output);
if (client->fd_in >= 0)
net_disconnect(client->fd_in);
if (client->fd_out >= 0 && client->fd_in != client->fd_out)
net_disconnect(client->fd_out);
if (client->fd_ctrl >= 0)
net_disconnect(client->fd_ctrl);
if (client->service_user != NULL)
mail_storage_service_user_free(&client->service_user);
i_free(client->access_user);
array_foreach_modifiable(&client->access_apps, app)
i_free(*app);
array_free(&client->access_apps);
i_free(client);
imap_urlauth_worker_refresh_proctitle();
master_service_client_connection_destroyed(master_service);
}
void server_connection_destroy(struct server_connection **_conn)
{
struct server_connection *conn = *_conn;
struct server_connection *const *conns;
const char *error;
unsigned int i, count;
*_conn = NULL;
conns = array_get(&conn->server->connections, &count);
for (i = 0; i < count; i++) {
if (conns[i] == conn) {
array_delete(&conn->server->connections, i, 1);
break;
}
}
if (conn->callback != NULL) {
error = conn->ssl_iostream == NULL ? NULL :
ssl_iostream_get_last_error(conn->ssl_iostream);
if (error == NULL) {
error = conn->input->stream_errno == 0 ? "EOF" :
strerror(conn->input->stream_errno);
}
server_connection_callback(conn, SERVER_EXIT_CODE_DISCONNECTED,
error);
}
if (printing_conn == conn)
print_connection_released();
if (conn->input != NULL)
i_stream_destroy(&conn->input);
if (conn->output != NULL)
o_stream_destroy(&conn->output);
if (conn->cmd_input != NULL)
i_stream_destroy(&conn->cmd_input);
/* close cmd_output after its parent, so the "." isn't sent */
if (conn->cmd_output != NULL)
o_stream_destroy(&conn->cmd_output);
if (conn->ssl_iostream != NULL)
ssl_iostream_unref(&conn->ssl_iostream);
if (conn->io != NULL)
io_remove(&conn->io);
if (conn->fd != -1) {
if (close(conn->fd) < 0)
i_error("close(server) failed: %m");
}
pool_unref(&conn->pool);
}
static ssize_t
i_stream_mail_filter_read_once(struct mail_filter_istream *mstream)
{
struct istream_private *stream = &mstream->istream;
ssize_t ret;
if (mstream->ext_out != NULL) {
/* we haven't sent everything yet */
(void)o_stream_send_istream(mstream->ext_out, stream->parent);
if (mstream->ext_out->stream_errno != 0) {
stream->istream.stream_errno =
mstream->ext_out->stream_errno;
return -1;
}
if (i_stream_is_eof(stream->parent)) {
o_stream_destroy(&mstream->ext_out);
/* if we wanted to be a blocking stream,
from now on the rest of the reads are */
if (stream->istream.blocking)
net_set_nonblock(mstream->fd, FALSE);
if (shutdown(mstream->fd, SHUT_WR) < 0)
i_error("ext-filter: shutdown() failed: %m");
}
}
i_stream_skip(mstream->ext_in, mstream->prev_ret);
ret = i_stream_read_copy_from(&stream->istream, mstream->ext_in);
mstream->prev_ret = ret < 0 ? 0 : ret;
return ret;
}
void auth_server_connection_disconnect(struct auth_server_connection *conn,
const char *reason)
{
conn->handshake_received = FALSE;
conn->version_received = FALSE;
conn->has_plain_mech = FALSE;
conn->server_pid = 0;
conn->connect_uid = 0;
conn->cookie = NULL;
array_clear(&conn->available_auth_mechs);
if (conn->to != NULL)
timeout_remove(&conn->to);
if (conn->io != NULL)
io_remove(&conn->io);
if (conn->fd != -1) {
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
if (close(conn->fd) < 0)
i_error("close(auth server connection) failed: %m");
conn->fd = -1;
}
auth_server_connection_remove_requests(conn, reason);
if (conn->client->connect_notify_callback != NULL) {
conn->client->connect_notify_callback(conn->client, FALSE,
conn->client->connect_notify_context);
}
}
void login_connection_deinit(struct login_connection **_conn)
{
struct login_connection *conn = *_conn;
*_conn = NULL;
if (conn->destroyed)
return;
conn->destroyed = TRUE;
DLLIST_REMOVE(&login_connections, conn);
io_remove(&conn->io);
if (conn->input != NULL)
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
if (close(conn->fd) < 0)
i_error("close(login connection) failed: %m");
conn->fd = -1;
if (conn->auth != NULL)
auth_connection_deinit(&conn->auth);
login_connection_unref(&conn);
master_service_client_connection_destroyed(master_service);
}
static int server_connection_send_cmd_input_more(struct server_connection *conn)
{
off_t ret;
/* ostream-dot writes only up to max buffer size, so keep it non-zero */
o_stream_set_max_buffer_size(conn->cmd_output, IO_BLOCK_SIZE);
ret = o_stream_send_istream(conn->cmd_output, conn->cmd_input);
o_stream_set_max_buffer_size(conn->cmd_output, (size_t)-1);
if (ret >= 0 && i_stream_have_bytes_left(conn->cmd_input)) {
o_stream_set_flush_pending(conn->cmd_output, TRUE);
return 0;
}
if (conn->cmd_input->stream_errno != 0) {
i_error("read(%s) failed: %s",
i_stream_get_name(conn->cmd_input),
i_stream_get_error(conn->cmd_input));
} else if (conn->cmd_output->stream_errno != 0 ||
o_stream_flush(conn->cmd_output) < 0) {
i_error("write(%s) failed: %s",
o_stream_get_name(conn->cmd_output),
o_stream_get_error(conn->cmd_output));
}
i_stream_destroy(&conn->cmd_input);
o_stream_destroy(&conn->cmd_output);
return ret < 0 ? -1 : 1;
}
static void login_proxy_disconnect(struct login_proxy *proxy)
{
if (proxy->to != NULL)
timeout_remove(&proxy->to);
if (proxy->to_notify != NULL)
timeout_remove(&proxy->to_notify);
if (!proxy->num_waiting_connections_updated) {
i_assert(proxy->state_rec->num_waiting_connections > 0);
proxy->state_rec->num_waiting_connections--;
}
if (proxy->connected) {
i_assert(proxy->state_rec->num_proxying_connections > 0);
proxy->state_rec->num_proxying_connections--;
}
if (proxy->server_io != NULL)
io_remove(&proxy->server_io);
if (proxy->server_input != NULL)
i_stream_destroy(&proxy->server_input);
if (proxy->server_output != NULL)
o_stream_destroy(&proxy->server_output);
if (proxy->server_fd != -1)
net_disconnect(proxy->server_fd);
}
int login_proxy_starttls(struct login_proxy *proxy)
{
int fd;
if (proxy->server_input != NULL)
i_stream_destroy(&proxy->server_input);
if (proxy->server_output != NULL)
o_stream_destroy(&proxy->server_output);
io_remove(&proxy->server_io);
fd = ssl_proxy_client_alloc(proxy->server_fd, &proxy->client->ip,
proxy->client->pool, proxy->client->set,
proxy->client->ssl_set,
login_proxy_ssl_handshaked, proxy,
&proxy->ssl_server_proxy);
if (fd < 0) {
client_log_err(proxy->client, t_strdup_printf(
"proxy: SSL handshake failed to %s:%u",
proxy->host, proxy->port));
return -1;
}
ssl_proxy_set_client(proxy->ssl_server_proxy, proxy->client);
ssl_proxy_start(proxy->ssl_server_proxy);
proxy->server_fd = fd;
proxy_plain_connected(proxy);
return 0;
}
static void pop3c_client_disconnect(struct pop3c_client *client)
{
client->state = POP3C_CLIENT_STATE_DISCONNECTED;
client->async_commands = 0;
if (client->running)
io_loop_stop(current_ioloop);
if (client->dns_lookup != NULL)
dns_lookup_abort(&client->dns_lookup);
if (client->to != NULL)
timeout_remove(&client->to);
if (client->io != NULL)
io_remove(&client->io);
if (client->input != NULL)
i_stream_destroy(&client->input);
if (client->output != NULL)
o_stream_destroy(&client->output);
if (client->ssl_iostream != NULL)
ssl_iostream_unref(&client->ssl_iostream);
if (client->fd != -1) {
if (close(client->fd) < 0)
i_error("close(pop3c) failed: %m");
client->fd = -1;
}
client_login_callback(client, POP3C_COMMAND_STATE_DISCONNECTED,
"Disconnected");
}
static void worker_connection_disconnect(struct worker_connection *conn)
{
unsigned int i, count = aqueue_count(conn->request_queue);
if (conn->fd != -1) {
io_remove(&conn->io);
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
if (close(conn->fd) < 0)
i_error("close(%s) failed: %m", conn->socket_path);
conn->fd = -1;
}
/* cancel any pending requests */
if (count > 0) {
i_error("Indexer worker disconnected, "
"discarding %u requests for %s",
count, conn->request_username);
}
/* conn->callback() can try to destroy us */
conn->refcount++;
for (i = 0; i < count; i++) {
void *const *contextp =
array_idx(&conn->request_contexts,
aqueue_idx(conn->request_queue, 0));
void *context = *contextp;
aqueue_delete_tail(conn->request_queue);
conn->callback(-1, context);
}
i_free_and_null(conn->request_username);
worker_connection_unref(conn);
}
static void login_proxy_free_final(struct login_proxy *proxy)
{
if (proxy->delayed_disconnect) {
DLLIST_REMOVE(&login_proxies_disconnecting, proxy);
i_assert(proxy->state_rec->num_delayed_client_disconnects > 0);
if (--proxy->state_rec->num_delayed_client_disconnects == 0)
proxy->state_rec->num_disconnects_since_ts = 0;
timeout_remove(&proxy->to);
}
if (proxy->client_io != NULL)
io_remove(&proxy->client_io);
if (proxy->client_input != NULL)
i_stream_destroy(&proxy->client_input);
if (proxy->client_output != NULL)
o_stream_destroy(&proxy->client_output);
if (proxy->client_fd != -1)
net_disconnect(proxy->client_fd);
if (proxy->ssl_server_proxy != NULL) {
ssl_proxy_destroy(proxy->ssl_server_proxy);
ssl_proxy_free(&proxy->ssl_server_proxy);
}
i_free(proxy->host);
i_free(proxy);
}
static void winbind_helper_disconnect(struct winbind_helper *winbind)
{
if (winbind->in_pipe != NULL)
i_stream_destroy(&winbind->in_pipe);
if (winbind->out_pipe != NULL)
o_stream_destroy(&winbind->out_pipe);
}
void dbox_save_end(struct dbox_save_context *ctx)
{
struct mail_save_data *mdata = &ctx->ctx.data;
struct ostream *dbox_output = ctx->dbox_output;
if (mdata->attach != NULL && !ctx->failed) {
if (index_attachment_save_finish(&ctx->ctx) < 0)
ctx->failed = TRUE;
}
if (o_stream_nfinish(mdata->output) < 0) {
mail_storage_set_critical(ctx->ctx.transaction->box->storage,
"write(%s) failed: %m",
o_stream_get_name(mdata->output));
ctx->failed = TRUE;
}
if (mdata->output != dbox_output) {
if (mdata->output != NULL) {
/* e.g. zlib plugin had changed this */
o_stream_ref(dbox_output);
o_stream_destroy(&mdata->output);
mdata->output = dbox_output;
} else {
i_assert(ctx->failed);
}
}
index_mail_cache_parse_deinit(ctx->ctx.dest_mail,
ctx->ctx.data.received_date,
!ctx->failed);
}
void master_login_auth_disconnect(struct master_login_auth *auth)
{
struct master_login_auth_request *request;
while (auth->request_head != NULL) {
request = auth->request_head;
DLLIST2_REMOVE(&auth->request_head,
&auth->request_tail, request);
request_internal_failure(request,
"Disconnected from auth server, aborting");
i_free(request);
}
hash_table_clear(auth->requests, FALSE);
if (auth->to != NULL)
timeout_remove(&auth->to);
if (auth->io != NULL)
io_remove(&auth->io);
if (auth->fd != -1) {
i_stream_destroy(&auth->input);
o_stream_destroy(&auth->output);
net_disconnect(auth->fd);
auth->fd = -1;
}
auth->version_received = FALSE;
}
static int mail_index_recreate(struct mail_index *index)
{
struct mail_index_map *map = index->map;
struct ostream *output;
unsigned int base_size;
const char *path;
int ret = 0, fd;
i_assert(!MAIL_INDEX_IS_IN_MEMORY(index));
i_assert(map->hdr.indexid == index->indexid);
i_assert((map->hdr.flags & MAIL_INDEX_HDR_FLAG_CORRUPTED) == 0);
i_assert(index->indexid != 0);
fd = mail_index_create_tmp_file(index, index->filepath, &path);
if (fd == -1)
return -1;
output = o_stream_create_fd_file(fd, 0, FALSE);
o_stream_cork(output);
base_size = I_MIN(map->hdr.base_header_size, sizeof(map->hdr));
o_stream_nsend(output, &map->hdr, base_size);
o_stream_nsend(output, CONST_PTR_OFFSET(map->hdr_base, base_size),
map->hdr.header_size - base_size);
o_stream_nsend(output, map->rec_map->records,
map->rec_map->records_count * map->hdr.record_size);
o_stream_nflush(output);
if (o_stream_nfinish(output) < 0) {
mail_index_file_set_syscall_error(index, path, "write()");
ret = -1;
}
o_stream_destroy(&output);
if (ret == 0 && index->fsync_mode != FSYNC_MODE_NEVER) {
if (fdatasync(fd) < 0) {
mail_index_file_set_syscall_error(index, path,
"fdatasync()");
ret = -1;
}
}
if (close(fd) < 0) {
mail_index_file_set_syscall_error(index, path, "close()");
ret = -1;
}
if ((index->flags & MAIL_INDEX_OPEN_FLAG_KEEP_BACKUPS) != 0)
(void)mail_index_create_backup(index);
if (ret == 0 && rename(path, index->filepath) < 0) {
mail_index_set_error(index, "rename(%s, %s) failed: %m",
path, index->filepath);
ret = -1;
}
if (ret < 0)
i_unlink(path);
return ret;
}
struct istream *iostream_temp_finish(struct ostream **output,
size_t max_buffer_size)
{
struct temp_ostream *tstream =
(struct temp_ostream *)(*output)->real_stream;
struct istream *input, *input2;
uoff_t abs_offset, size;
const char *for_path;
int fd;
if (tstream->name[0] == '\0')
for_path = "";
else
for_path = t_strdup_printf(" for %s", tstream->name);
if (tstream->dupstream != NULL && !tstream->dupstream->closed) {
abs_offset = i_stream_get_absolute_offset(tstream->dupstream) -
tstream->dupstream->v_offset +
tstream->dupstream_start_offset;
size = tstream->dupstream_offset -
tstream->dupstream_start_offset;
fd = dup(i_stream_get_fd(tstream->dupstream));
if (fd == -1)
input = i_stream_create_error_str(errno, "dup() failed: %m");
else {
input2 = i_stream_create_fd_autoclose(&fd, max_buffer_size);
i_stream_seek(input2, abs_offset);
input = i_stream_create_limit(input2, size);
i_stream_unref(&input2);
}
i_stream_set_name(input, t_strdup_printf(
"(Temp file in %s%s, from %s)", tstream->temp_path_prefix,
for_path, i_stream_get_name(tstream->dupstream)));
i_stream_unref(&tstream->dupstream);
} else if (tstream->dupstream != NULL) {
/* return the original failed stream. */
input = tstream->dupstream;
} else if (tstream->fd != -1) {
int fd = tstream->fd;
input = i_stream_create_fd_autoclose(&tstream->fd, max_buffer_size);
i_stream_set_name(input, t_strdup_printf(
"(Temp file fd %d in %s%s, %"PRIuUOFF_T" bytes)",
fd, tstream->temp_path_prefix, for_path, tstream->fd_size));
} else {
input = i_stream_create_from_data(tstream->buf->data,
tstream->buf->used);
i_stream_set_name(input, t_strdup_printf(
"(Temp buffer in %s%s, %"PRIuSIZE_T" bytes)",
tstream->temp_path_prefix, for_path, tstream->buf->used));
i_stream_add_destroy_callback(input, iostream_temp_buf_destroyed,
tstream->buf);
tstream->buf = NULL;
}
o_stream_destroy(output);
return input;
}
static void notify_connection_unref(struct notify_connection *conn)
{
i_assert(conn->refcount > 0);
if (--conn->refcount > 0)
return;
i_stream_destroy(&conn->input);
if (conn->output != NULL)
o_stream_destroy(&conn->output);
i_free(conn);
}
static int pop3c_client_ssl_init(struct pop3c_client *client)
{
struct ssl_iostream_settings ssl_set;
struct stat st;
const char *error;
if (client->ssl_ctx == NULL) {
i_error("pop3c(%s): No SSL context", client->set.host);
return -1;
}
memset(&ssl_set, 0, sizeof(ssl_set));
if (client->set.ssl_verify) {
ssl_set.verbose_invalid_cert = TRUE;
ssl_set.verify_remote_cert = TRUE;
ssl_set.require_valid_cert = TRUE;
}
if (client->set.debug)
i_debug("pop3c(%s): Starting SSL handshake", client->set.host);
if (client->raw_input != client->input) {
/* recreate rawlog after STARTTLS */
i_stream_ref(client->raw_input);
o_stream_ref(client->raw_output);
i_stream_destroy(&client->input);
o_stream_destroy(&client->output);
client->input = client->raw_input;
client->output = client->raw_output;
}
if (io_stream_create_ssl_client(client->ssl_ctx, client->set.host,
&ssl_set, &client->input, &client->output,
&client->ssl_iostream, &error) < 0) {
i_error("pop3c(%s): Couldn't initialize SSL client: %s",
client->set.host, error);
return -1;
}
ssl_iostream_set_handshake_callback(client->ssl_iostream,
pop3c_client_ssl_handshaked,
client);
if (ssl_iostream_handshake(client->ssl_iostream) < 0) {
i_error("pop3c(%s): SSL handshake failed: %s", client->set.host,
ssl_iostream_get_last_error(client->ssl_iostream));
return -1;
}
if (*client->set.rawlog_dir != '\0' &&
stat(client->set.rawlog_dir, &st) == 0) {
iostream_rawlog_create(client->set.rawlog_dir,
&client->input, &client->output);
}
return 0;
}
static void replicator_connection_disconnect(struct replicator_connection *conn)
{
if (conn->fd == -1)
return;
replicator_abort_all_requests(conn);
io_remove(&conn->io);
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
net_disconnect(conn->fd);
conn->fd = -1;
}
static int program_client_close_output(struct program_client *pclient)
{
int ret;
if ( pclient->program_output != NULL )
o_stream_destroy(&pclient->program_output);
if ( (ret=pclient->close_output(pclient)) < 0 )
return -1;
pclient->program_output = NULL;
return ret;
}
int sieve_file_storage_save_finish
(struct sieve_storage_save_context *sctx)
{
struct sieve_file_save_context *fsctx =
(struct sieve_file_save_context *)sctx;
struct sieve_storage *storage = sctx->storage;
int output_errno;
if ( sctx->failed && fsctx->fd == -1 ) {
/* tmp file creation failed */
return -1;
}
T_BEGIN {
output_errno = fsctx->output->stream_errno;
o_stream_destroy(&fsctx->output);
if ( fsync(fsctx->fd) < 0 ) {
sieve_storage_set_critical(storage, "save: "
"fsync(%s) failed: %m", fsctx->tmp_path);
sctx->failed = TRUE;
}
if ( close(fsctx->fd) < 0 ) {
sieve_storage_set_critical(storage, "save: "
"close(%s) failed: %m", fsctx->tmp_path);
sctx->failed = TRUE;
}
fsctx->fd = -1;
if ( sctx->failed ) {
/* delete the tmp file */
if (unlink(fsctx->tmp_path) < 0 && errno != ENOENT) {
sieve_storage_sys_warning(storage, "save: "
"unlink(%s) failed: %m", fsctx->tmp_path);
}
fsctx->tmp_path = NULL;
errno = output_errno;
if ( ENOQUOTA(errno) ) {
sieve_storage_set_error(storage,
SIEVE_ERROR_NO_QUOTA,
"Not enough disk quota");
} else if ( errno != 0 ) {
sieve_storage_set_critical(storage, "save: "
"write(%s) failed: %m", fsctx->tmp_path);
}
}
} T_END;
return ( sctx->failed ? -1 : 0 );
}
void config_connection_destroy(struct config_connection *conn)
{
DLLIST_REMOVE(&config_connections, conn);
io_remove(&conn->io);
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
if (close(conn->fd) < 0)
i_error("close(config conn) failed: %m");
i_free(conn);
master_service_client_connection_destroyed(master_service);
}
void testsuite_result_print
(const struct sieve_runtime_env *renv)
{
struct ostream *out;
out = o_stream_create_fd(1, 0, FALSE);
o_stream_send_str(out, "\n--");
sieve_result_print(_testsuite_result, renv->scriptenv, out, NULL);
o_stream_send_str(out, "--\n\n");
o_stream_destroy(&out);
}
static void rawlog_proxy_destroy(struct rawlog_proxy *proxy)
{
if (proxy->in_output != NULL) {
o_stream_uncork(proxy->in_output);
if (o_stream_nfinish(proxy->in_output) < 0) {
i_error("write(in) failed: %s",
o_stream_get_error(proxy->in_output));
}
o_stream_destroy(&proxy->in_output);
}
if (proxy->out_output != NULL) {
o_stream_uncork(proxy->out_output);
if (o_stream_nfinish(proxy->out_output) < 0) {
i_error("write(out) failed: %s",
o_stream_get_error(proxy->out_output));
}
o_stream_destroy(&proxy->out_output);
}
if (proxy->client_io != NULL)
io_remove(&proxy->client_io);
if (proxy->server_io != NULL)
io_remove(&proxy->server_io);
if (proxy->to_flush != NULL)
timeout_remove(&proxy->to_flush);
o_stream_destroy(&proxy->client_output);
o_stream_destroy(&proxy->server_output);
if (close(proxy->client_in_fd) < 0)
i_error("close(client_in_fd) failed: %m");
if (close(proxy->client_out_fd) < 0)
i_error("close(client_out_fd) failed: %m");
if (close(proxy->server_fd) < 0)
i_error("close(server_fd) failed: %m");
i_free(proxy);
io_loop_stop(ioloop);
}
static void dns_client_destroy(struct dns_client **_client)
{
struct dns_client *client = *_client;
*_client = NULL;
io_remove(&client->io);
i_stream_destroy(&client->input);
o_stream_destroy(&client->output);
if (close(client->fd) < 0)
i_error("close() failed: %m");
i_free(client);
dns_client = NULL;
master_service_client_connection_destroyed(master_service);
}
static void test_iostream_temp_create_sized_disk(void)
{
struct ostream *output;
test_begin("iostream_temp_create_sized() disk");
output = iostream_temp_create_sized(".", 0, "test", 4);
test_assert(o_stream_send(output, "123", 3) == 3);
test_assert(output->offset == 3);
test_assert(o_stream_send(output, "4", 1) == 1);
test_assert(output->offset == 4);
test_assert(o_stream_get_fd(output) == -1);
test_assert(o_stream_send(output, "5", 1) == 1);
test_assert(output->offset == 5);
test_assert(o_stream_get_fd(output) != -1);
o_stream_destroy(&output);
test_end();
}
int mbox_move(struct mbox_sync_context *sync_ctx,
uoff_t dest, uoff_t source, uoff_t size)
{
struct istream *input;
struct ostream *output;
off_t ret;
i_assert(size < OFF_T_MAX);
if (size == 0 || source == dest)
return 0;
i_stream_sync(sync_ctx->input);
output = o_stream_create_fd_file(sync_ctx->write_fd, (uoff_t)-1, FALSE);
i_stream_seek(sync_ctx->file_input, source);
if (o_stream_seek(output, dest) < 0) {
mbox_set_syscall_error(sync_ctx->mbox,
"o_stream_seek()");
o_stream_unref(&output);
return -1;
}
input = i_stream_create_limit(sync_ctx->file_input, size);
ret = o_stream_send_istream(output, input);
i_stream_unref(&input);
if (ret == (off_t)size)
ret = 0;
else if (ret >= 0) {
mbox_sync_set_critical(sync_ctx,
"mbox_move(%"PRIuUOFF_T", %"PRIuUOFF_T", %"PRIuUOFF_T
") moved only %"PRIuUOFF_T" bytes",
dest, source, size, (uoff_t)ret);
ret = -1;
} else if (ret < 0) {
errno = output->stream_errno;
mbox_set_syscall_error(sync_ctx->mbox,
"o_stream_send_istream()");
}
mbox_sync_file_updated(sync_ctx, FALSE);
o_stream_destroy(&output);
return (int)ret;
}
static int fs_crypt_write_stream_finish(struct fs_file *_file, bool success)
{
struct crypt_fs_file *file = (struct crypt_fs_file *)_file;
struct istream *input;
int ret;
if (_file->output != NULL) {
if (_file->output == file->super_output)
_file->output = NULL;
else
o_stream_unref(&_file->output);
}
if (!success) {
if (file->super_output != NULL) {
/* no encryption */
i_assert(file->temp_output == NULL);
fs_write_stream_abort_error(_file->parent, &file->super_output,
"write(%s) failed: %s",
o_stream_get_name(file->super_output),
o_stream_get_error(file->super_output));
} else if (file->temp_output != NULL) {
o_stream_destroy(&file->temp_output);
}
return -1;
}
if (file->super_output != NULL) {
/* no encrypt */
i_assert(file->temp_output == NULL);
return fs_write_stream_finish(_file->parent, &file->super_output);
}
if (file->temp_output == NULL) {
/* finishing up */
i_assert(file->super_output == NULL);
return fs_write_stream_finish_async(_file->parent);
}
/* finish writing the temporary file */
input = iostream_temp_finish(&file->temp_output, IO_BLOCK_SIZE);
file->super_output = fs_write_stream(_file->parent);
o_stream_nsend_istream(file->super_output, input);
ret = fs_write_stream_finish(_file->parent, &file->super_output);
i_stream_unref(&input);
return ret;
}
void client_connection_destroy(struct client_connection **_conn)
{
struct client_connection *conn = *_conn;
*_conn = NULL;
if (conn->ssl_iostream != NULL)
ssl_iostream_destroy(&conn->ssl_iostream);
i_stream_destroy(&conn->input);
o_stream_destroy(&conn->output);
io_remove(&conn->io);
if (close(conn->fd) < 0)
i_error("close(client) failed: %m");
pool_unref(&conn->pool);
doveadm_client = NULL;
master_service_client_connection_destroyed(master_service);
}