static void
solr_lookup_xml_start(void *context, const char *name, const char **attrs)
{
struct solr_lookup_xml_context *ctx = context;
const char *name_attr;
i_assert(ctx->depth >= (int)ctx->state);
ctx->depth++;
if (ctx->depth - 1 > (int)ctx->state) {
/* skipping over unwanted elements */
return;
}
/* response -> result -> doc */
switch (ctx->state) {
case SOLR_XML_RESPONSE_STATE_ROOT:
if (strcmp(name, "response") == 0)
ctx->state++;
break;
case SOLR_XML_RESPONSE_STATE_RESPONSE:
if (strcmp(name, "result") == 0)
ctx->state++;
break;
case SOLR_XML_RESPONSE_STATE_RESULT:
if (strcmp(name, "doc") == 0) {
ctx->state++;
ctx->uid = 0;
ctx->score = 0;
i_free_and_null(ctx->mailbox);
i_free_and_null(ctx->ns);
ctx->uidvalidity = 0;
}
break;
case SOLR_XML_RESPONSE_STATE_DOC:
name_attr = attrs_get_name(attrs);
if (strcmp(name_attr, "uid") == 0)
ctx->content_state = SOLR_XML_CONTENT_STATE_UID;
else if (strcmp(name_attr, "score") == 0)
ctx->content_state = SOLR_XML_CONTENT_STATE_SCORE;
else if (strcmp(name_attr, "box") == 0)
ctx->content_state = SOLR_XML_CONTENT_STATE_MAILBOX;
else if (strcmp(name_attr, "ns") == 0)
ctx->content_state = SOLR_XML_CONTENT_STATE_NAMESPACE;
else if (strcmp(name_attr, "uidv") == 0)
ctx->content_state = SOLR_XML_CONTENT_STATE_UIDVALIDITY;
else
break;
ctx->state++;
break;
case SOLR_XML_RESPONSE_STATE_CONTENT:
break;
}
}
void client_proxy_failed(struct client *client, bool send_line)
{
if (send_line) {
client_proxy_error(client, PROXY_FAILURE_MSG);
}
login_proxy_free(&client->login_proxy);
proxy_free_password(client);
i_free_and_null(client->proxy_user);
i_free_and_null(client->proxy_master_user);
/* call this last - it may destroy the client */
client_auth_failed(client);
}
void message_decoder_decode_reset(struct message_decoder_context *ctx)
{
i_free_and_null(ctx->content_charset);
ctx->message_cte = MESSAGE_CTE_78BIT;
ctx->charset_utf8 = TRUE;
buffer_set_used_size(ctx->encoding_buf, 0);
}
void index_storage_mailbox_close(struct mailbox *box)
{
struct index_mailbox_context *ibox = INDEX_STORAGE_CONTEXT(box);
index_mailbox_check_remove_all(box);
if (box->input != NULL)
i_stream_unref(&box->input);
if (box->view_pvt != NULL)
mail_index_view_close(&box->view_pvt);
if (box->index_pvt != NULL)
mail_index_close(box->index_pvt);
mail_index_view_close(&box->view);
mail_index_close(box->index);
box->cache = NULL;
ibox->keyword_names = NULL;
i_free_and_null(ibox->cache_fields);
if (array_is_created(&ibox->recent_flags))
array_free(&ibox->recent_flags);
ibox->recent_flags_prev_uid = 0;
ibox->recent_flags_count = 0;
ibox->sync_last_check = 0;
}
static int
worker_connection_input_line(struct worker_connection *conn, const char *line)
{
void *const *contextp, *context;
int percentage;
if (aqueue_count(conn->request_queue) == 0) {
i_error("Input from worker without pending requests: %s", line);
return -1;
}
if (str_to_int(line, &percentage) < 0 ||
percentage < -1 || percentage > 100) {
i_error("Invalid input from worker: %s", line);
return -1;
}
contextp = array_idx(&conn->request_contexts,
aqueue_idx(conn->request_queue, 0));
context = *contextp;
if (percentage < 0 || percentage == 100) {
/* the request is finished */
aqueue_delete_tail(conn->request_queue);
if (aqueue_count(conn->request_queue) == 0)
i_free_and_null(conn->request_username);
}
conn->callback(percentage, context);
return 0;
}
static void
message_decode_body_init_charset(struct message_decoder_context *ctx,
struct message_part *part)
{
ctx->binary_input = ctx->content_charset == NULL &&
(ctx->flags & MESSAGE_DECODER_FLAG_RETURN_BINARY) != 0 &&
(part->flags & (MESSAGE_PART_FLAG_TEXT |
MESSAGE_PART_FLAG_MESSAGE_RFC822)) == 0;
if (ctx->binary_input)
return;
if (ctx->charset_trans != NULL && ctx->content_charset != NULL &&
strcasecmp(ctx->content_charset, ctx->charset_trans_charset) == 0) {
/* already have the correct translation selected */
charset_to_utf8_reset(ctx->charset_trans);
return;
}
if (ctx->charset_trans != NULL)
charset_to_utf8_end(&ctx->charset_trans);
i_free_and_null(ctx->charset_trans_charset);
ctx->charset_trans_charset = i_strdup(ctx->content_charset != NULL ?
ctx->content_charset : "UTF-8");
if (charset_to_utf8_begin(ctx->charset_trans_charset, ctx->normalizer,
&ctx->charset_trans) < 0)
ctx->charset_trans = charset_utf8_to_utf8_begin(ctx->normalizer);
}
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
int o_stream_encrypt_send_header_v2(struct encrypt_ostream *stream)
{
unsigned char c;
unsigned int i;
i_assert(!stream->prefix_written);
stream->prefix_written = TRUE;
buffer_t *values = buffer_create_dynamic(pool_datastack_create(), 256);
buffer_append(values, IOSTREAM_CRYPT_MAGIC, sizeof(IOSTREAM_CRYPT_MAGIC));
c = 2;
buffer_append(values, &c, 1);
i = htonl(stream->flags);
buffer_append(values, &i, 4);
/* store total length of header
9 = version + flags + length
8 = rounds + key data length
*/
i = htonl(sizeof(IOSTREAM_CRYPT_MAGIC) + 9 + stream->cipher_oid->used + stream->mac_oid->used + 8 + stream->key_data_len);
buffer_append(values, &i, 4);
buffer_append_buf(values, stream->cipher_oid, 0, (size_t)-1);
buffer_append_buf(values, stream->mac_oid, 0, (size_t)-1);
i = htonl(IO_STREAM_ENCRYPT_ROUNDS);
buffer_append(values, &i, 4);
i = htonl(stream->key_data_len);
buffer_append(values, &i, 4);
buffer_append(values, stream->key_data, stream->key_data_len);
i_free_and_null(stream->key_data);
return o_stream_encrypt_send(stream, values->data, values->used);
}
void i_stream_skip(struct istream *stream, uoff_t count)
{
struct istream_private *_stream = stream->real_stream;
size_t data_size;
data_size = _stream->pos - _stream->skip;
if (count <= data_size) {
/* within buffer */
stream->v_offset += count;
_stream->skip += count;
if (_stream->nonpersistent_buffers &&
_stream->skip == _stream->pos) {
_stream->skip = _stream->pos = 0;
_stream->buffer_size = 0;
i_free_and_null(_stream->w_buffer);
}
return;
}
/* have to seek forward */
count -= data_size;
_stream->skip = _stream->pos;
stream->v_offset += data_size;
if (unlikely(stream->closed || stream->stream_errno != 0))
return;
_stream->seek(_stream, stream->v_offset + count, FALSE);
}
static void
fts_backend_solr_update_set_mailbox(struct fts_backend_update_context *_ctx,
struct mailbox *box)
{
struct solr_fts_backend_update_context *ctx =
(struct solr_fts_backend_update_context *)_ctx;
struct mailbox_status status;
struct mail_namespace *ns;
if (ctx->prev_uid != 0) {
fts_index_set_last_uid(ctx->cur_box, ctx->prev_uid);
ctx->prev_uid = 0;
}
ctx->cur_box = box;
ctx->uid_validity = 0;
i_free_and_null(ctx->id_box_name);
if (box != NULL) {
ctx->id_box_name = i_strdup(fts_box_get_root(box, &ns));
mailbox_get_open_status(box, STATUS_UIDVALIDITY, &status);
ctx->uid_validity = status.uidvalidity;
}
}
static void proxy_free_password(struct client *client)
{
if (client->proxy_password == NULL)
return;
safe_memset(client->proxy_password, 0, strlen(client->proxy_password));
i_free_and_null(client->proxy_password);
}
void test_end(void)
{
i_assert(test_prefix != NULL);
test_out("", test_success);
i_free_and_null(test_prefix);
test_success = FALSE;
}
int pop3c_sync_get_sizes(struct pop3c_mailbox *mbox)
{
struct istream *input;
const char *error;
char *line, *p;
unsigned int seq, line_seq;
i_assert(mbox->msg_sizes == NULL);
if (mbox->msg_uidls == NULL) {
if (pop3c_sync_get_uidls(mbox) < 0)
return -1;
}
if (mbox->msg_count == 0) {
mbox->msg_sizes = i_new(uoff_t, 1);
return 0;
}
if (pop3c_client_cmd_stream(mbox->client, "LIST\r\n",
&input, &error) < 0) {
mail_storage_set_critical(mbox->box.storage,
"LIST failed: %s", error);
return -1;
}
mbox->msg_sizes = i_new(uoff_t, mbox->msg_count); seq = 0;
while ((line = i_stream_read_next_line(input)) != NULL) {
if (++seq > mbox->msg_count) {
mail_storage_set_critical(mbox->box.storage,
"Too much data in LIST: %s", line);
break;
}
p = strchr(line, ' ');
if (p == NULL) {
mail_storage_set_critical(mbox->box.storage,
"Invalid LIST line: %s", line);
break;
}
*p++ = '\0';
if (str_to_uint(line, &line_seq) < 0 || line_seq != seq) {
mail_storage_set_critical(mbox->box.storage,
"Unexpected LIST seq: %s != %u", line, seq);
break;
}
if (str_to_uoff(p, &mbox->msg_sizes[seq-1]) < 0) {
mail_storage_set_critical(mbox->box.storage,
"Invalid LIST size: %s", p);
break;
}
}
i_stream_destroy(&input);
if (line != NULL) {
i_free_and_null(mbox->msg_sizes);
return -1;
}
return 0;
}
static void astream_part_reset(struct attachment_istream *astream)
{
struct attachment_istream_part *part = &astream->part;
if (part->temp_output != NULL)
o_stream_destroy(&part->temp_output);
if (part->temp_fd != -1)
i_close_fd(&part->temp_fd);
i_free_and_null(part->content_type);
i_free_and_null(part->content_disposition);
if (part->part_buf != NULL)
buffer_free(&part->part_buf);
memset(part, 0, sizeof(*part));
part->temp_fd = -1;
hash_format_reset(astream->set.hash_format);
}
static void cmd_id_free(struct imap_client *client)
{
struct imap_client_cmd_id *id = client->cmd_id;
if (id->log_reply != NULL)
str_free(&id->log_reply);
if (id->log_keys != NULL)
p_strsplit_free(default_pool, id->log_keys);
imap_parser_unref(&id->parser);
i_free_and_null(client->cmd_id);
client->skip_line = TRUE;
}
int istream_raw_mbox_seek(struct istream *stream, uoff_t offset)
{
struct raw_mbox_istream *rstream =
(struct raw_mbox_istream *)stream->real_stream;
bool check;
i_assert(rstream->locked);
/* reset any (corruption) errors */
stream->stream_errno = 0;
i_free_and_null(stream->real_stream->iostream.error);
rstream->corrupted = FALSE;
rstream->eof = FALSE;
rstream->istream.istream.eof = FALSE;
/* if seeked is FALSE, we unlocked in the middle. don't try to use
any cached state then. */
if (rstream->mail_size != (uoff_t)-1 && rstream->seeked &&
rstream->hdr_offset + rstream->mail_size == offset)
return istream_raw_mbox_next(stream, (uoff_t)-1);
if (offset == rstream->from_offset && rstream->seeked) {
/* back to beginning of current message */
offset = rstream->hdr_offset;
check = offset == 0;
} else {
rstream->body_offset = (uoff_t)-1;
rstream->mail_size = (uoff_t)-1;
rstream->received_time = (time_t)-1;
rstream->next_received_time = (time_t)-1;
rstream->header_missing_eoh = FALSE;
i_free(rstream->sender);
rstream->sender = NULL;
i_free(rstream->next_sender);
rstream->next_sender = NULL;
rstream->from_offset = offset;
rstream->hdr_offset = offset;
check = TRUE;
}
rstream->seeked = TRUE;
i_stream_seek_mark(stream, offset);
i_stream_seek_mark(rstream->istream.parent, offset);
if (check)
(void)i_stream_read(stream);
return rstream->corrupted ? -1 : 0;
}
static bool stats_top_round(struct top_context *ctx)
{
#define TOP_CMD "EXPORT\tsession\tconnected\n"
const char *const *args;
pool_t tmp_pool;
if (write_full(ctx->fd, TOP_CMD, strlen(TOP_CMD)) < 0)
i_fatal("write(%s) failed: %m", ctx->path);
/* read header */
if (ctx->headers != NULL) {
args = read_next_line(ctx->input);
if (args == NULL)
i_fatal("read(%s) unexpectedly disconnected", ctx->path);
if (*args == NULL)
return TRUE;
if (str_array_length(args) != ctx->headers_count)
i_fatal("headers changed");
} else {
ctx->headers = p_read_next_line(default_pool, ctx->input);
if (ctx->headers == NULL)
i_fatal("read(%s) unexpectedly disconnected", ctx->path);
if (*ctx->headers == NULL) {
i_free_and_null(ctx->headers);
return FALSE;
}
ctx->headers_count = str_array_length((void *)ctx->headers);
if (!stats_header_find(ctx, "last_update", &ctx->last_update_idx))
i_fatal("last_update header missing");
if (!stats_header_find(ctx, "user", &ctx->user_idx))
i_fatal("user header missing");
stats_top_get_sorting(ctx);
}
array_clear(&ctx->lines);
p_clear(ctx->prev_pool);
tmp_pool = ctx->prev_pool;
ctx->prev_pool = ctx->cur_pool;
ctx->cur_pool = tmp_pool;
ctx->flip = !ctx->flip;
stats_read(ctx);
stats_drop_stale(ctx);
sort_ctx = ctx;
array_sort(&ctx->lines, *ctx->lines_sort);
sort_ctx = NULL;
return TRUE;
}
static void imap_urlauth_fetch_abort_local(struct imap_urlauth_fetch *ufetch)
{
struct imap_urlauth_fetch_url *url, *url_next;
if (ufetch->local_url != NULL) {
ufetch->pending_requests--;
imap_msgpart_url_free(&ufetch->local_url);
}
i_free_and_null(ufetch->pending_reply.url);
i_free_and_null(ufetch->pending_reply.bodypartstruct);
i_free_and_null(ufetch->pending_reply.error);
if (ufetch->pending_reply.input != NULL)
i_stream_unref(&ufetch->pending_reply.input);
url = ufetch->local_urls_head;
for (; url != NULL; url = url_next) {
url_next = url->next;
i_free(url->url);
i_free(url);
ufetch->pending_requests--;
}
ufetch->local_urls_head = ufetch->local_urls_tail = NULL;
}
static void client_auth_failed(struct client *client)
{
i_free_and_null(client->master_data_prefix);
if (client->auth_response != NULL)
str_truncate(client->auth_response, 0);
if (client->auth_initializing || client->destroyed)
return;
if (client->io != NULL)
io_remove(&client->io);
client->io = io_add(client->fd, IO_READ, client_input, client);
client_input(client);
}
void hostpid_init(void)
{
static char hostname[256], pid[MAX_INT_STRLEN];
if (gethostname(hostname, sizeof(hostname)-1) == -1)
i_strocpy(hostname, "unknown", sizeof(hostname));
hostname[sizeof(hostname)-1] = '\0';
my_hostname = hostname;
if (strchr(hostname, '/') != NULL)
i_fatal("Invalid system hostname: %s", hostname);
/* allow calling hostpid_init() multiple times to reset hostname */
i_free_and_null(my_domain);
i_strocpy(pid, dec2str(getpid()), sizeof(pid));
my_pid = pid;
}
static
void i_stream_decrypt_destroy(struct iostream_private *stream)
{
struct decrypt_istream *dstream =
(struct decrypt_istream *)stream;
if (dstream->buf != NULL)
buffer_free(&dstream->buf);
if (dstream->iv != NULL)
i_free_and_null(dstream->iv);
if (dstream->ctx_sym != NULL)
dcrypt_ctx_sym_destroy(&(dstream->ctx_sym));
if (dstream->ctx_mac != NULL)
dcrypt_ctx_hmac_destroy(&(dstream->ctx_mac));
if (dstream->priv_key != NULL)
dcrypt_key_unref_private(&(dstream->priv_key));
i_stream_unref(&(dstream->istream.parent));
}
static int openssl_iostream_handshake(struct ssl_iostream *ssl_io)
{
const char *error = NULL;
int ret;
i_assert(!ssl_io->handshaked);
if (ssl_io->ctx->client_ctx) {
while ((ret = SSL_connect(ssl_io->ssl)) <= 0) {
ret = openssl_iostream_handle_error(ssl_io, ret,
"SSL_connect()");
if (ret <= 0)
return ret;
}
} else {
while ((ret = SSL_accept(ssl_io->ssl)) <= 0) {
ret = openssl_iostream_handle_error(ssl_io, ret,
"SSL_accept()");
if (ret <= 0)
return ret;
}
}
/* handshake finished */
(void)openssl_iostream_bio_sync(ssl_io);
if (ssl_io->handshake_callback != NULL) {
if (ssl_io->handshake_callback(&error, ssl_io->handshake_context) < 0) {
i_assert(error != NULL);
i_stream_close(ssl_io->plain_input);
o_stream_close(ssl_io->plain_output);
openssl_iostream_set_error(ssl_io, error);
ssl_io->handshake_failed = TRUE;
errno = EINVAL;
return -1;
}
}
i_free_and_null(ssl_io->last_error);
ssl_io->handshaked = TRUE;
if (ssl_io->ssl_output != NULL)
(void)o_stream_flush(ssl_io->ssl_output);
return 1;
}
static int i_stream_seekable_write_failed(struct seekable_istream *sstream)
{
struct istream_private *stream = &sstream->istream;
void *data;
i_assert(sstream->fd != -1);
stream->max_buffer_size = (size_t)-1;
data = i_stream_alloc(stream, sstream->write_peak);
if (pread_full(sstream->fd, data, sstream->write_peak, 0) < 0) {
i_error("istream-seekable: read(%s) failed: %m", sstream->temp_path);
memarea_unref(&stream->memarea);
return -1;
}
i_stream_destroy(&sstream->fd_input);
i_close_fd(&sstream->fd);
i_free_and_null(sstream->temp_path);
return 0;
}
void index_storage_mailbox_close(struct mailbox *box)
{
struct index_mailbox_context *ibox = INDEX_STORAGE_CONTEXT(box);
mailbox_watch_remove_all(box);
if (box->input != NULL)
i_stream_unref(&box->input);
if (box->view_pvt != NULL)
mail_index_view_close(&box->view_pvt);
if (box->index_pvt != NULL)
mail_index_close(box->index_pvt);
if (box->view != NULL) {
mail_index_view_close(&box->view);
mail_index_close(box->index);
}
box->cache = NULL;
ibox->keyword_names = NULL;
i_free_and_null(ibox->cache_fields);
ibox->sync_last_check = 0;
}
static int i_stream_seekable_write_failed(struct seekable_istream *sstream)
{
struct istream_private *stream = &sstream->istream;
void *data;
i_assert(sstream->membuf == NULL);
sstream->membuf =
buffer_create_dynamic(default_pool, sstream->write_peak);
data = buffer_append_space_unsafe(sstream->membuf, sstream->write_peak);
if (pread_full(sstream->fd, data, sstream->write_peak, 0) < 0) {
i_error("istream-seekable: read(%s) failed: %m", sstream->temp_path);
buffer_free(&sstream->membuf);
return -1;
}
i_stream_destroy(&sstream->fd_input);
i_close_fd(&sstream->fd);
stream->max_buffer_size = (size_t)-1;
i_free_and_null(sstream->temp_path);
return 0;
}
static
int o_stream_encrypt_send_header_v1(struct encrypt_ostream *stream)
{
unsigned char c;
unsigned short s;
i_assert(!stream->prefix_written);
stream->prefix_written = TRUE;
buffer_t *values = buffer_create_dynamic(pool_datastack_create(), 256);
buffer_append(values, IOSTREAM_CRYPT_MAGIC, sizeof(IOSTREAM_CRYPT_MAGIC));
/* version */
c = 1;
buffer_append(values, &c, 1);
/* key data length */
s = htons(stream->key_data_len);
buffer_append(values, &s, 2);
/* then write key data */
buffer_append(values, stream->key_data, stream->key_data_len);
i_free_and_null(stream->key_data);
/* then send it to stream */
return o_stream_encrypt_send(stream, values->data, values->used);
}
void client_destroy(struct client *client, const char *reason)
{
if (client->destroyed)
return;
client->destroyed = TRUE;
if (!client->login_success && reason != NULL) {
reason = t_strconcat(reason, " ",
client_get_extra_disconnect_reason(client), NULL);
}
if (reason != NULL)
client_log(client, reason);
if (last_client == client)
last_client = client->prev;
DLLIST_REMOVE(&clients, client);
if (client->input != NULL)
i_stream_close(client->input);
if (client->output != NULL)
o_stream_close(client->output);
if (client->master_tag != 0) {
i_assert(client->auth_request == NULL);
i_assert(client->authenticating);
i_assert(client->refcount > 1);
client->authenticating = FALSE;
master_auth_request_abort(master_auth, client->master_tag);
client->refcount--;
} else if (client->auth_request != NULL) {
i_assert(client->authenticating);
sasl_server_auth_abort(client);
} else {
i_assert(!client->authenticating);
}
if (client->io != NULL)
io_remove(&client->io);
if (client->to_disconnect != NULL)
timeout_remove(&client->to_disconnect);
if (client->to_auth_waiting != NULL)
timeout_remove(&client->to_auth_waiting);
if (client->auth_response != NULL)
str_free(&client->auth_response);
if (client->fd != -1) {
net_disconnect(client->fd);
client->fd = -1;
}
if (client->proxy_password != NULL) {
safe_memset(client->proxy_password, 0,
strlen(client->proxy_password));
i_free_and_null(client->proxy_password);
}
if (client->proxy_sasl_client != NULL)
dsasl_client_free(&client->proxy_sasl_client);
if (client->login_proxy != NULL)
login_proxy_free(&client->login_proxy);
if (client->v.destroy != NULL)
client->v.destroy(client);
if (client_unref(&client) && initial_service_count == 1) {
/* as soon as this connection is done with proxying
(or whatever), the process will die. there's no need for
authentication anymore, so close the connection.
do this only with initial service_count=1, in case there
are other clients with pending authentications */
auth_client_disconnect(auth_client, "unnecessary connection");
}
login_client_destroyed();
login_refresh_proctitle();
}
int mdbox_sync_begin(struct mdbox_mailbox *mbox, enum mdbox_sync_flags flags,
struct mdbox_map_atomic_context *atomic,
struct mdbox_sync_context **ctx_r)
{
struct mail_storage *storage = mbox->box.storage;
struct mdbox_sync_context *ctx;
enum mail_index_sync_flags sync_flags;
int ret;
bool rebuild, storage_rebuilt = FALSE;
*ctx_r = NULL;
/* avoid race conditions with mailbox creation, don't check for dbox
headers until syncing has locked the mailbox */
rebuild = mbox->storage->corrupted ||
(flags & MDBOX_SYNC_FLAG_FORCE_REBUILD) != 0;
if (rebuild && (flags & MDBOX_SYNC_FLAG_NO_REBUILD) == 0) {
if (mdbox_storage_rebuild_in_context(mbox->storage, atomic) < 0)
return -1;
index_mailbox_reset_uidvalidity(&mbox->box);
storage_rebuilt = TRUE;
}
ctx = i_new(struct mdbox_sync_context, 1);
ctx->mbox = mbox;
ctx->flags = flags;
ctx->atomic = atomic;
sync_flags = index_storage_get_sync_flags(&mbox->box);
if (!rebuild && (flags & MDBOX_SYNC_FLAG_FORCE) == 0)
sync_flags |= MAIL_INDEX_SYNC_FLAG_REQUIRE_CHANGES;
if ((flags & MDBOX_SYNC_FLAG_FSYNC) != 0)
sync_flags |= MAIL_INDEX_SYNC_FLAG_FSYNC;
/* don't write unnecessary dirty flag updates */
sync_flags |= MAIL_INDEX_SYNC_FLAG_AVOID_FLAG_UPDATES;
ret = mdbox_sync_try_begin(ctx, sync_flags);
if (ret <= 0) {
/* failed / nothing to do */
i_free(ctx);
return ret;
}
if ((ret = mdbox_sync_index(ctx)) <= 0) {
mail_index_sync_rollback(&ctx->index_sync_ctx);
i_free_and_null(ctx);
if (ret < 0)
return -1;
/* corrupted */
if (storage_rebuilt) {
mail_storage_set_critical(storage,
"mdbox %s: Storage keeps breaking",
mailbox_get_path(&mbox->box));
return -1;
}
/* we'll need to rebuild storage.
try again from the beginning. */
mdbox_storage_set_corrupted(mbox->storage);
if ((flags & MDBOX_SYNC_FLAG_NO_REBUILD) != 0) {
mail_storage_set_critical(storage,
"mdbox %s: Can't rebuild storage",
mailbox_get_path(&mbox->box));
return -1;
}
return mdbox_sync_begin(mbox, flags, atomic, ctx_r);
}
*ctx_r = ctx;
return 0;
}
void ipwd_deinit(void)
{
i_free_and_null(pwbuf);
i_free_and_null(grbuf);
}
static int
openssl_iostream_handle_error_full(struct ssl_iostream *ssl_io, int ret,
const char *func_name, bool write_error)
{
const char *errstr = NULL;
int err;
err = SSL_get_error(ssl_io->ssl, ret);
switch (err) {
case SSL_ERROR_WANT_WRITE:
if (!openssl_iostream_bio_sync(ssl_io)) {
if (!write_error)
i_panic("SSL ostream buffer size not unlimited");
return 0;
}
if (ssl_io->closed) {
if (ssl_io->plain_stream_errstr != NULL)
openssl_iostream_set_error(ssl_io, ssl_io->plain_stream_errstr);
errno = ssl_io->plain_stream_errno != 0 ?
ssl_io->plain_stream_errno : EPIPE;
return -1;
}
return 1;
case SSL_ERROR_WANT_READ:
ssl_io->want_read = TRUE;
(void)openssl_iostream_bio_sync(ssl_io);
if (ssl_io->closed) {
if (ssl_io->plain_stream_errstr != NULL)
openssl_iostream_set_error(ssl_io, ssl_io->plain_stream_errstr);
errno = ssl_io->plain_stream_errno != 0 ?
ssl_io->plain_stream_errno : EPIPE;
return -1;
}
return ssl_io->want_read ? 0 : 1;
case SSL_ERROR_SYSCALL:
/* eat up the error queue */
if (ERR_peek_error() != 0) {
errstr = openssl_iostream_error();
errno = EINVAL;
} else if (ret != 0) {
i_assert(errno != 0);
errstr = strerror(errno);
} else {
/* EOF. */
errno = EPIPE;
errstr = "Disconnected";
break;
}
errstr = t_strdup_printf("%s syscall failed: %s",
func_name, errstr);
break;
case SSL_ERROR_ZERO_RETURN:
/* clean connection closing */
errno = EPIPE;
i_free_and_null(ssl_io->last_error);
return -1;
case SSL_ERROR_SSL:
errstr = t_strdup_printf("%s failed: %s",
func_name, openssl_iostream_error());
errno = EINVAL;
break;
default:
errstr = t_strdup_printf("%s failed: unknown failure %d (%s)",
func_name, err,
openssl_iostream_error());
errno = EINVAL;
break;
}
openssl_iostream_set_error(ssl_io, errstr);
return -1;
}
