static void
acllist_clear(struct acl_backend_vfile *backend, uoff_t file_size)
{
if (backend->acllist_pool == NULL) {
backend->acllist_pool =
pool_alloconly_create("vfile acllist",
I_MAX(file_size / 2, 128));
i_array_init(&backend->acllist, I_MAX(16, file_size / 60));
} else {
p_clear(backend->acllist_pool);
array_clear(&backend->acllist);
}
}
int client_auth_read_line(struct client *client)
{
const unsigned char *data;
size_t i, size;
unsigned int len;
if (i_stream_read_data(client->input, &data, &size, 0) == -1) {
client_destroy(client, "Disconnected");
return -1;
}
/* see if we have a full line */
for (i = 0; i < size; i++) {
if (data[i] == '\n')
break;
}
if (client->auth_response == NULL)
client->auth_response = str_new(default_pool, I_MAX(i+1, 256));
if (str_len(client->auth_response) + i > LOGIN_MAX_AUTH_BUF_SIZE) {
client_destroy(client, "Authentication response too large");
return -1;
}
str_append_n(client->auth_response, data, i);
i_stream_skip(client->input, i == size ? size : i+1);
/* drop trailing \r */
len = str_len(client->auth_response);
if (len > 0 && str_c(client->auth_response)[len-1] == '\r')
str_truncate(client->auth_response, len-1);
return i < size;
}
static void test_link_alloc(void)
{
#define COMPONENT_COMPONENT "/component-component"
const char *o_tmpdir;
/* idea here is to make sure component-component
would optimally hit to the nearest_power value.
it has to be big enough to cause requirement for
allocation in t_realpath. */
string_t *basedir = t_str_new(256);
str_append(basedir, cwd);
str_append(basedir, "/"TEMP_DIRNAME);
size_t len = nearest_power(I_MAX(127, str_len(basedir) + strlen(COMPONENT_COMPONENT) + 1)) -
strlen(COMPONENT_COMPONENT);
while(str_len(basedir) < len) {
str_append(basedir, COMPONENT_COMPONENT);
(void)mkdir(str_c(basedir), 0700);
}
o_tmpdir = tmpdir;
tmpdir = str_c(basedir);
create_links(tmpdir);
test_link1();
test_link_loop();
tmpdir = o_tmpdir;
}
static int copy_to_temp_file(struct seekable_istream *sstream)
{
struct istream_private *stream = &sstream->istream;
const char *path;
const unsigned char *buffer;
size_t size;
int fd;
fd = sstream->fd_callback(&path, sstream->context);
if (fd == -1)
return -1;
/* copy our currently read buffer to it */
i_assert(stream->pos <= sstream->buffer_peak);
if (write_full(fd, stream->buffer, sstream->buffer_peak) < 0) {
if (!ENOSPACE(errno))
i_error("istream-seekable: write_full(%s) failed: %m", path);
i_close_fd(&fd);
return -1;
}
sstream->temp_path = i_strdup(path);
sstream->write_peak = sstream->buffer_peak;
sstream->fd = fd;
sstream->fd_input = i_stream_create_fd_autoclose(&fd,
I_MAX(stream->pos, sstream->istream.max_buffer_size));
i_stream_set_name(sstream->fd_input, t_strdup_printf(
"(seekable temp-istream for: %s)", i_stream_get_name(&stream->istream)));
/* read back the data we just had in our buffer */
for (;;) {
buffer = i_stream_get_data(sstream->fd_input, &size);
if (size >= stream->pos)
break;
ssize_t ret;
if ((ret = i_stream_read_memarea(sstream->fd_input)) <= 0) {
i_assert(ret != 0);
i_assert(ret != -2);
i_error("istream-seekable: Couldn't read back "
"in-memory input %s: %s",
i_stream_get_name(&stream->istream),
i_stream_get_error(sstream->fd_input));
i_stream_destroy(&sstream->fd_input);
i_close_fd(&sstream->fd);
return -1;
}
}
/* Set the max buffer size only after we've already read everything
into memory. For example with istream-data it's possible that
more data exists in buffer than max_buffer_size. */
i_stream_set_max_buffer_size(sstream->fd_input,
sstream->istream.max_buffer_size);
stream->buffer = buffer;
i_stream_free_buffer(&sstream->istream);
return 0;
}
static void client_send_sendalive_if_needed(struct client *client)
{
time_t now, last_io;
if (o_stream_get_buffer_used_size(client->output) != 0)
return;
now = time(NULL);
last_io = I_MAX(client->last_input, client->last_output);
if (now - last_io > MAIL_STORAGE_STAYALIVE_SECS) {
o_stream_nsend_str(client->output, "* OK Hang in there..\r\n");
o_stream_nflush(client->output);
client->last_output = now;
}
}
static const struct mail_index_record *
tview_apply_flag_updates(struct mail_index_view_transaction *tview,
struct mail_index_map *map,
const struct mail_index_record *rec, uint32_t seq)
{
struct mail_index_transaction *t = tview->t;
const struct mail_index_flag_update *updates;
struct mail_index_record *trec;
unsigned int idx, count;
/* see if there are any flag updates */
if (seq < t->min_flagupdate_seq || seq > t->max_flagupdate_seq ||
!array_is_created(&t->updates))
return rec;
updates = array_get(&t->updates, &count);
idx = mail_index_transaction_get_flag_update_pos(t, 0, count, seq);
if (seq < updates[idx].uid1 || seq > updates[idx].uid2)
return rec;
/* yes, we have flag updates. since we can't modify rec directly and
we want to be able to handle multiple mail_index_lookup() calls
without the second one overriding the first one's data, we'll
create a records array and return data from there.
it's also possible that the record size increases, so we potentially
have to create multiple arrays. they all get eventually freed when
the view gets freed. */
if (map->hdr.record_size > tview->record_size) {
if (!array_is_created(&tview->all_recs))
i_array_init(&tview->all_recs, 4);
tview->recs_count = t->first_new_seq;
tview->record_size = I_MAX(map->hdr.record_size,
tview->view.map->hdr.record_size);
tview->recs = i_malloc(tview->record_size *
tview->recs_count);
array_append(&tview->all_recs, &tview->recs, 1);
}
i_assert(tview->recs_count == t->first_new_seq);
i_assert(seq > 0 && seq <= tview->recs_count);
trec = PTR_OFFSET(tview->recs, (seq-1) * tview->record_size);
memcpy(trec, rec, map->hdr.record_size);
trec->flags |= updates[idx].add_flags;
trec->flags &= ~updates[idx].remove_flags;
return trec;
}
static int
i_stream_qp_try_decode_input(struct qp_decoder_istream *bstream, bool eof)
{
struct istream_private *stream = &bstream->istream;
const unsigned char *data;
size_t size, avail, buffer_avail, pos;
buffer_t buf;
int ret;
data = i_stream_get_data(stream->parent, &size);
if (size == 0)
return 0;
/* normally the decoded quoted-printable content can't be larger than
the encoded content, but because we always use CRLFs, it may use
twice as much space by only converting LFs to CRLFs. */
i_stream_try_alloc(stream, size, &avail);
buffer_avail = stream->buffer_size - stream->pos;
if (size > buffer_avail/2) {
/* can't fit everything to destination buffer.
write as much as we can. */
size = buffer_avail/2;
if (size == 0)
return -2;
}
buffer_create_from_data(&buf, stream->w_buffer + stream->pos,
buffer_avail);
ret = !eof ? quoted_printable_decode(data, size, &pos, &buf) :
quoted_printable_decode_final(data, size, &pos, &buf);
if (ret < 0) {
io_stream_set_error(&stream->iostream,
"Invalid quoted-printable data: 0x%s",
binary_to_hex(data+pos, I_MAX(size-pos, 8)));
stream->istream.stream_errno = EINVAL;
return -1;
}
stream->pos += buf.used;
i_stream_skip(stream->parent, pos);
return pos > 0 ? 1 : 0;
}
struct hash_table *
hash_table_create(pool_t table_pool, pool_t node_pool, unsigned int initial_size,
hash_callback_t *hash_cb, hash_cmp_callback_t *key_compare_cb)
{
struct hash_table *table;
table = p_new(table_pool, struct hash_table, 1);
table->table_pool = table_pool;
table->node_pool = node_pool;
table->initial_size =
I_MAX(primes_closest(initial_size), HASH_TABLE_MIN_SIZE);
table->hash_cb = hash_cb != NULL ? hash_cb : direct_hash;
table->key_compare_cb = key_compare_cb == NULL ?
direct_cmp : key_compare_cb;
table->size = table->initial_size;
table->nodes = p_new(table_pool, struct hash_node, table->size);
return table;
}
static void imap_die(void)
{
struct client *client, *next;
time_t last_io, now = time(NULL);
time_t stop_timestamp = now - IMAP_DIE_IDLE_SECS;
unsigned int stop_msecs;
for (client = imap_clients; client != NULL; client = next) {
next = client->next;
last_io = I_MAX(client->last_input, client->last_output);
if (last_io <= stop_timestamp)
client_kill_idle(client);
else {
timeout_remove(&client->to_idle);
stop_msecs = (last_io - stop_timestamp) * 1000;
client->to_idle = timeout_add(stop_msecs,
client_kill_idle, client);
}
}
}
static void test_istream_crlf_input(const char *input)
{
string_t *output;
const unsigned char *data;
size_t size = 0;
ssize_t ret1, ret2;
unsigned int i, j, pos, input_len = strlen(input);
struct istream *istream, *crlf_istream;
output = t_str_new(256);
for (j = 0; j < 4; j++) {
istream = i_stream_create_from_data(input, input_len);
str_truncate(output, 0);
if (j%2 == 0) {
/* drop CRs */
crlf_istream = i_stream_create_lf(istream);
for (i = 0; i < input_len; i++) {
if (input[i] == '\r' &&
(i == input_len || input[i+1] == '\n'))
;
else
str_append_c(output, input[i]);
}
} else {
/* add missing CRs */
crlf_istream = i_stream_create_crlf(istream);
for (i = 0; i < input_len; i++) {
if (input[i] == '\n' &&
(i == 0 || input[i-1] != '\r'))
str_append_c(output, '\r');
str_append_c(output, input[i]);
}
}
pos = 0;
for (i = 1; i <= input_len; i++) {
if (j >= 2) {
i_stream_unref(&istream);
i_stream_unref(&crlf_istream);
istream = i_stream_create_from_data(input,
input_len);
crlf_istream = j%2 == 0 ?
i_stream_create_lf(istream) :
i_stream_create_crlf(istream);
pos = 0;
}
istream->real_stream->pos = i;
ret1 = i_stream_read(crlf_istream);
if (crlf_istream->real_stream->buffer_size != 0) {
/* this is pretty evil */
crlf_istream->real_stream->buffer_size =
I_MAX(crlf_istream->real_stream->pos, i);
}
ret2 = i_stream_read(crlf_istream);
data = i_stream_get_data(crlf_istream, &size);
if (ret1 > 0 || ret2 > 0) {
ret1 = I_MAX(ret1, 0) + I_MAX(ret2, 0);
test_assert(pos + (unsigned int)ret1 == size);
pos += ret1;
}
test_assert(memcmp(data, str_data(output), size) == 0);
}
test_assert(size == str_len(output));
i_stream_unref(&crlf_istream);
i_stream_unref(&istream);
}
}
int mbox_sync_parse_next_mail(struct istream *input,
struct mbox_sync_mail_context *ctx)
{
struct mbox_sync_context *sync_ctx = ctx->sync_ctx;
struct message_header_parser_ctx *hdr_ctx;
struct message_header_line *hdr;
struct mbox_sync_header_func *func;
struct mbox_md5_context *mbox_md5_ctx;
size_t line_start_pos;
int i, ret;
ctx->hdr_offset = ctx->mail.offset;
ctx->mail.flags = MAIL_RECENT; /* default to having recent flag */
ctx->header_first_change = (size_t)-1;
ctx->header_last_change = 0;
for (i = 0; i < MBOX_HDR_COUNT; i++)
ctx->hdr_pos[i] = (size_t)-1;
ctx->content_length = (uoff_t)-1;
str_truncate(ctx->header, 0);
mbox_md5_ctx = ctx->sync_ctx->mbox->md5_v.init();
line_start_pos = 0;
hdr_ctx = message_parse_header_init(input, NULL, 0);
while ((ret = message_parse_header_next(hdr_ctx, &hdr)) > 0) {
if (hdr->eoh) {
ctx->have_eoh = TRUE;
break;
}
if (!hdr->continued) {
line_start_pos = str_len(ctx->header);
str_append(ctx->header, hdr->name);
str_append_n(ctx->header, hdr->middle, hdr->middle_len);
}
func = bsearch(hdr->name, header_funcs,
N_ELEMENTS(header_funcs), sizeof(*header_funcs),
mbox_sync_bsearch_header_func_cmp);
if (func != NULL) {
if (hdr->continues) {
hdr->use_full_value = TRUE;
continue;
}
if (!func->func(ctx, hdr)) {
/* this header is broken, remove it */
ctx->need_rewrite = TRUE;
str_truncate(ctx->header, line_start_pos);
if (ctx->header_first_change == (size_t)-1) {
ctx->header_first_change =
line_start_pos;
}
continue;
}
buffer_append(ctx->header, hdr->full_value,
hdr->full_value_len);
} else {
ctx->sync_ctx->mbox->md5_v.more(mbox_md5_ctx, hdr);
buffer_append(ctx->header, hdr->value,
hdr->value_len);
}
if (!hdr->no_newline) {
if (hdr->crlf_newline)
str_append_c(ctx->header, '\r');
str_append_c(ctx->header, '\n');
}
}
i_assert(ret != 0);
message_parse_header_deinit(&hdr_ctx);
ctx->sync_ctx->mbox->md5_v.finish(mbox_md5_ctx, ctx->hdr_md5_sum);
if ((ctx->seq == 1 && !ctx->seen_imapbase) ||
(ctx->seq > 1 && sync_ctx->dest_first_mail)) {
/* missing X-IMAPbase */
ctx->need_rewrite = TRUE;
if (sync_ctx->base_uid_validity == 0) {
/* figure out a new UIDVALIDITY for us. */
sync_ctx->base_uid_validity =
sync_ctx->hdr->uid_validity != 0 &&
!sync_ctx->renumber_uids ?
sync_ctx->hdr->uid_validity :
I_MAX((uint32_t)ioloop_time, 1);
}
}
ctx->body_offset = input->v_offset;
if (input->stream_errno != 0) {
mbox_sync_set_critical(ctx->sync_ctx, "read(%s) failed: %s",
i_stream_get_name(input), i_stream_get_error(input));
return -1;
}
return 0;
}
int maildir_sync_index(struct maildir_index_sync_context *ctx,
bool partial)
{
struct maildir_mailbox *mbox = ctx->mbox;
struct mail_index_view *view = ctx->view;
struct mail_index_view *view2;
struct maildir_uidlist_iter_ctx *iter;
struct mail_index_transaction *trans = ctx->trans;
const struct mail_index_header *hdr;
struct mail_index_header empty_hdr;
const struct mail_index_record *rec;
uint32_t seq, seq2, uid, prev_uid;
enum maildir_uidlist_rec_flag uflags;
const char *filename;
uint32_t uid_validity, next_uid, hdr_next_uid, first_recent_uid;
uint32_t first_uid;
unsigned int changes = 0;
int ret = 0;
time_t time_before_sync;
guid_128_t expunged_guid_128;
enum mail_flags private_flags_mask;
bool expunged, full_rescan = FALSE;
i_assert(!mbox->syncing_commit);
first_uid = 1;
hdr = mail_index_get_header(view);
uid_validity = maildir_uidlist_get_uid_validity(mbox->uidlist);
if (uid_validity != hdr->uid_validity &&
uid_validity != 0 && hdr->uid_validity != 0) {
/* uidvalidity changed and index isn't being synced for the
first time, reset the index so we can add all messages as
new */
i_warning("Maildir %s: UIDVALIDITY changed (%u -> %u)",
mailbox_get_path(&ctx->mbox->box),
hdr->uid_validity, uid_validity);
mail_index_reset(trans);
mailbox_recent_flags_reset(&mbox->box);
first_uid = hdr->messages_count + 1;
memset(&empty_hdr, 0, sizeof(empty_hdr));
empty_hdr.next_uid = 1;
hdr = &empty_hdr;
}
hdr_next_uid = hdr->next_uid;
ctx->mbox->box.tmp_sync_view = view;
private_flags_mask = mailbox_get_private_flags_mask(&mbox->box);
time_before_sync = time(NULL);
mbox->syncing_commit = TRUE;
seq = prev_uid = 0; first_recent_uid = I_MAX(hdr->first_recent_uid, 1);
i_array_init(&ctx->keywords, MAILDIR_MAX_KEYWORDS);
i_array_init(&ctx->idx_keywords, MAILDIR_MAX_KEYWORDS);
iter = maildir_uidlist_iter_init(mbox->uidlist);
while (maildir_uidlist_iter_next(iter, &uid, &uflags, &filename)) {
maildir_filename_flags_get(ctx->keywords_sync_ctx, filename,
&ctx->flags, &ctx->keywords);
i_assert(uid > prev_uid);
prev_uid = uid;
/* the private flags are kept only in indexes. don't use them
at all even for newly seen mails */
ctx->flags &= ~private_flags_mask;
again:
seq++;
ctx->uid = uid;
if (seq > hdr->messages_count) {
if (uid < hdr_next_uid) {
if (maildir_handle_uid_insertion(ctx, uflags,
filename,
uid) < 0)
ret = -1;
seq--;
continue;
}
/* Trust uidlist recent flags only for newly added
messages. When saving/copying messages with flags
they're stored to cur/ and uidlist treats them
as non-recent. */
if ((uflags & MAILDIR_UIDLIST_REC_FLAG_RECENT) == 0) {
if (uid >= first_recent_uid)
first_recent_uid = uid + 1;
}
hdr_next_uid = uid + 1;
mail_index_append(trans, uid, &seq);
mail_index_update_flags(trans, seq, MODIFY_REPLACE,
ctx->flags);
if (array_count(&ctx->keywords) > 0) {
struct mail_keywords *kw;
kw = mail_index_keywords_create_from_indexes(
mbox->box.index, &ctx->keywords);
mail_index_update_keywords(trans, seq,
MODIFY_REPLACE, kw);
mail_index_keywords_unref(&kw);
}
continue;
}
rec = mail_index_lookup(view, seq);
if (uid > rec->uid) {
/* already expunged (no point in showing guid in the
expunge record anymore) */
mail_index_expunge(ctx->trans, seq);
goto again;
}
if (uid < rec->uid) {
if (maildir_handle_uid_insertion(ctx, uflags,
filename, uid) < 0)
ret = -1;
seq--;
continue;
}
index_sync_changes_read(ctx->sync_changes, ctx->uid, &expunged,
expunged_guid_128);
if (expunged) {
if (!maildir_expunge_is_valid_guid(ctx, ctx->uid,
filename,
expunged_guid_128))
continue;
if (maildir_file_do(mbox, ctx->uid,
maildir_expunge, ctx) >= 0) {
/* successful expunge */
mail_index_expunge(ctx->trans, seq);
}
if ((++changes % MAILDIR_SLOW_MOVE_COUNT) == 0)
maildir_sync_notify(ctx->maildir_sync_ctx);
continue;
}
/* the private flags are stored only in indexes, keep them */
ctx->flags |= rec->flags & private_flags_mask;
if (index_sync_changes_have(ctx->sync_changes)) {
/* apply flag changes to maildir */
if (maildir_file_do(mbox, ctx->uid,
maildir_sync_flags, ctx) < 0)
ctx->flags |= MAIL_INDEX_MAIL_FLAG_DIRTY;
if ((++changes % MAILDIR_SLOW_MOVE_COUNT) == 0)
maildir_sync_notify(ctx->maildir_sync_ctx);
}
if ((uflags & MAILDIR_UIDLIST_REC_FLAG_NONSYNCED) != 0) {
/* partial syncing */
if ((uflags & MAILDIR_UIDLIST_REC_FLAG_NEW_DIR) != 0) {
/* we last saw this mail in new/, but it's
not there anymore. possibly expunged,
make sure. */
full_rescan = TRUE;
}
continue;
}
if ((rec->flags & MAIL_INDEX_MAIL_FLAG_DIRTY) != 0) {
/* we haven't been able to update maildir with this
record's flag changes. don't sync them. */
continue;
}
if (ctx->flags != (rec->flags & MAIL_FLAGS_NONRECENT)) {
mail_index_update_flags(trans, seq, MODIFY_REPLACE,
ctx->flags);
}
maildir_sync_mail_keywords(ctx, seq);
}
maildir_uidlist_iter_deinit(&iter);
if (!partial) {
/* expunge the rest */
for (seq++; seq <= hdr->messages_count; seq++)
mail_index_expunge(ctx->trans, seq);
}
/* add \Recent flags. use updated view so it contains newly
appended messages. */
view2 = mail_index_transaction_open_updated_view(trans);
if (mail_index_lookup_seq_range(view2, first_recent_uid, (uint32_t)-1,
&seq, &seq2) && seq2 >= first_uid) {
if (seq < first_uid) {
/* UIDVALIDITY changed, skip over the old messages */
seq = first_uid;
}
mailbox_recent_flags_set_seqs(&mbox->box, view2, seq, seq2);
}
mail_index_view_close(&view2);
if (ctx->uidlist_sync_ctx != NULL) {
if (maildir_uidlist_sync_deinit(&ctx->uidlist_sync_ctx,
TRUE) < 0)
ret = -1;
}
if (mbox->box.v.sync_notify != NULL)
mbox->box.v.sync_notify(&mbox->box, 0, 0);
ctx->mbox->box.tmp_sync_view = NULL;
/* check cur/ mtime later. if we came here from saving messages they
could still be moved to cur/ directory. */
ctx->update_maildir_hdr_cur = TRUE;
mbox->maildir_hdr.cur_check_time = time_before_sync;
if (uid_validity == 0) {
uid_validity = hdr->uid_validity != 0 ? hdr->uid_validity :
maildir_get_uidvalidity_next(mbox->box.list);
maildir_uidlist_set_uid_validity(mbox->uidlist, uid_validity);
}
maildir_uidlist_set_next_uid(mbox->uidlist, hdr_next_uid, FALSE);
if (uid_validity != hdr->uid_validity) {
mail_index_update_header(trans,
offsetof(struct mail_index_header, uid_validity),
&uid_validity, sizeof(uid_validity), TRUE);
}
void test_buffer(void)
{
#define BUF_TEST_SIZE (1024*2)
#define BUF_TEST_COUNT 1000
buffer_t *buf;
unsigned char *p, testdata[BUF_TEST_SIZE], shadowbuf[BUF_TEST_SIZE];
unsigned int i, shadowbuf_size;
size_t pos, pos2, size;
int test = -1;
bool zero;
buf = buffer_create_dynamic(default_pool, 1);
for (i = 0; i < BUF_TEST_SIZE; i++)
testdata[i] = random();
memset(shadowbuf, 0, sizeof(shadowbuf));
srand(1);
shadowbuf_size = 0;
for (i = 0; i < BUF_TEST_COUNT; i++) {
if (buf->used == BUF_TEST_SIZE) {
size = shadowbuf_size = rand() % (buf->used - 1);
buffer_set_used_size(buf, size);
memset(shadowbuf + shadowbuf_size, 0,
BUF_TEST_SIZE - shadowbuf_size);
i_assert(buf->used < BUF_TEST_SIZE);
}
test = rand() % 6;
zero = rand() % 10 == 0;
switch (test) {
case 0:
pos = rand() % (BUF_TEST_SIZE-1);
size = rand() % (BUF_TEST_SIZE - pos);
if (!zero) {
buffer_write(buf, pos, testdata, size);
memcpy(shadowbuf + pos, testdata, size);
} else {
buffer_write_zero(buf, pos, size);
memset(shadowbuf + pos, 0, size);
}
if (pos + size > shadowbuf_size)
shadowbuf_size = pos + size;
break;
case 1:
size = rand() % (BUF_TEST_SIZE - buf->used);
if (!zero) {
buffer_append(buf, testdata, size);
memcpy(shadowbuf + shadowbuf_size,
testdata, size);
} else {
buffer_append_zero(buf, size);
memset(shadowbuf + shadowbuf_size, 0, size);
}
shadowbuf_size += size;
break;
case 2:
pos = rand() % (BUF_TEST_SIZE-1);
size = rand() % (BUF_TEST_SIZE - I_MAX(buf->used, pos));
if (!zero) {
buffer_insert(buf, pos, testdata, size);
memmove(shadowbuf + pos + size,
shadowbuf + pos,
BUF_TEST_SIZE - (pos + size));
memcpy(shadowbuf + pos, testdata, size);
} else {
buffer_insert_zero(buf, pos, size);
memmove(shadowbuf + pos + size,
shadowbuf + pos,
BUF_TEST_SIZE - (pos + size));
memset(shadowbuf + pos, 0, size);
}
if (pos < shadowbuf_size)
shadowbuf_size += size;
else
shadowbuf_size = pos + size;
break;
case 3:
pos = rand() % (BUF_TEST_SIZE-1);
size = rand() % (BUF_TEST_SIZE - pos);
buffer_delete(buf, pos, size);
if (pos < shadowbuf_size) {
if (pos + size > shadowbuf_size)
size = shadowbuf_size - pos;
memmove(shadowbuf + pos,
shadowbuf + pos + size,
BUF_TEST_SIZE - (pos + size));
shadowbuf_size -= size;
memset(shadowbuf + shadowbuf_size, 0,
BUF_TEST_SIZE - shadowbuf_size);
}
break;
case 4:
if (shadowbuf_size == 0)
break;
pos = rand() % (shadowbuf_size-1); /* dest */
pos2 = rand() % (shadowbuf_size-1); /* source */
size = rand() % (shadowbuf_size - I_MAX(pos, pos2));
buffer_copy(buf, pos, buf, pos2, size);
memmove(shadowbuf + pos,
shadowbuf + pos2, size);
if (pos > pos2 && pos + size > shadowbuf_size)
shadowbuf_size = pos + size;
break;
case 5:
pos = rand() % (BUF_TEST_SIZE-1);
size = rand() % (BUF_TEST_SIZE - pos);
p = buffer_get_space_unsafe(buf, pos, size);
memcpy(p, testdata, size);
memcpy(shadowbuf + pos, testdata, size);
if (pos + size > shadowbuf_size)
shadowbuf_size = pos + size;
break;
}
i_assert(shadowbuf_size <= BUF_TEST_SIZE);
if (buf->used != shadowbuf_size ||
memcmp(buf->data, shadowbuf, buf->used) != 0)
break;
}
if (i == BUF_TEST_COUNT)
test_out("buffer", TRUE);
else {
test_out_reason("buffer", FALSE,
t_strdup_printf("round %u test %d failed", i, test));
}
buffer_free(&buf);
}
bool auth_request_handler_auth_begin(struct auth_request_handler *handler,
const char *args)
{
const struct mech_module *mech;
struct auth_request *request;
const char *const *list, *name, *arg, *initial_resp;
void *initial_resp_data;
unsigned int id;
buffer_t *buf;
i_assert(!handler->destroyed);
/* <id> <mechanism> [...] */
list = t_strsplit_tab(args);
if (list[0] == NULL || list[1] == NULL ||
str_to_uint(list[0], &id) < 0) {
i_error("BUG: Authentication client %u "
"sent broken AUTH request", handler->client_pid);
return FALSE;
}
if (handler->token_auth) {
mech = &mech_dovecot_token;
if (strcmp(list[1], mech->mech_name) != 0) {
/* unsupported mechanism */
i_error("BUG: Authentication client %u requested invalid "
"authentication mechanism %s (DOVECOT-TOKEN required)",
handler->client_pid, str_sanitize(list[1], MAX_MECH_NAME_LEN));
return FALSE;
}
} else {
mech = mech_module_find(list[1]);
if (mech == NULL) {
/* unsupported mechanism */
i_error("BUG: Authentication client %u requested unsupported "
"authentication mechanism %s", handler->client_pid,
str_sanitize(list[1], MAX_MECH_NAME_LEN));
return FALSE;
}
}
request = auth_request_new(mech);
request->handler = handler;
request->connect_uid = handler->connect_uid;
request->client_pid = handler->client_pid;
request->id = id;
request->auth_only = handler->master_callback == NULL;
/* parse optional parameters */
initial_resp = NULL;
for (list += 2; *list != NULL; list++) {
arg = strchr(*list, '=');
if (arg == NULL) {
name = *list;
arg = "";
} else {
name = t_strdup_until(*list, arg);
arg++;
}
if (auth_request_import_auth(request, name, arg))
;
else if (strcmp(name, "resp") == 0) {
initial_resp = arg;
/* this must be the last parameter */
list++;
break;
}
}
if (*list != NULL) {
i_error("BUG: Authentication client %u "
"sent AUTH parameters after 'resp'",
handler->client_pid);
auth_request_unref(&request);
return FALSE;
}
if (request->service == NULL) {
i_error("BUG: Authentication client %u "
"didn't specify service in request",
handler->client_pid);
auth_request_unref(&request);
return FALSE;
}
if (hash_table_lookup(handler->requests, POINTER_CAST(id)) != NULL) {
i_error("BUG: Authentication client %u "
"sent a duplicate ID %u", handler->client_pid, id);
auth_request_unref(&request);
return FALSE;
}
auth_request_init(request);
request->to_abort = timeout_add(MASTER_AUTH_SERVER_TIMEOUT_SECS * 1000,
auth_request_timeout, request);
hash_table_insert(handler->requests, POINTER_CAST(id), request);
if (request->set->ssl_require_client_cert &&
!request->valid_client_cert) {
/* we fail without valid certificate */
auth_request_handler_auth_fail(handler, request,
"Client didn't present valid SSL certificate");
return TRUE;
}
/* Empty initial response is a "=" base64 string. Completely empty
string shouldn't really be sent, but at least Exim does it,
so just allow it for backwards compatibility.. */
if (initial_resp != NULL && *initial_resp != '\0') {
size_t len = strlen(initial_resp);
buf = buffer_create_dynamic(pool_datastack_create(),
MAX_BASE64_DECODED_SIZE(len));
if (base64_decode(initial_resp, len, NULL, buf) < 0) {
auth_request_handler_auth_fail(handler, request,
"Invalid base64 data in initial response");
return TRUE;
}
initial_resp_data =
p_malloc(request->pool, I_MAX(buf->used, 1));
memcpy(initial_resp_data, buf->data, buf->used);
request->initial_response = initial_resp_data;
request->initial_response_len = buf->used;
}
/* handler is referenced until auth_request_handler_reply()
is called. */
handler->refcount++;
/* before we start authenticating, see if we need to wait first */
auth_penalty_lookup(auth_penalty, request, auth_penalty_callback);
return TRUE;
}
int mail_command_update_parse(const char *const *args, const char **error_r)
{
struct mail_session *session;
struct mail_command *cmd;
struct stats *new_stats, *diff_stats;
buffer_t *buf;
const char *error;
unsigned int i, cmd_id;
bool done = FALSE, continued = FALSE;
/* <session guid> <cmd id> [d] <name> <args> <stats>
<session guid> <cmd id> c[d] <stats> */
if (str_array_length(args) < 3) {
*error_r = "UPDATE-CMD: Too few parameters";
return -1;
}
if (mail_session_get(args[0], &session, error_r) < 0)
return -1;
if (str_to_uint(args[1], &cmd_id) < 0 || cmd_id == 0) {
*error_r = "UPDATE-CMD: Invalid command id";
return -1;
}
for (i = 0; args[2][i] != '\0'; i++) {
switch (args[2][i]) {
case 'd':
done = TRUE;
break;
case 'c':
continued = TRUE;
break;
default:
*error_r = "UPDATE-CMD: Invalid flags parameter";
return -1;
}
}
cmd = mail_command_find(session, cmd_id);
if (!continued) {
/* new command */
if (cmd != NULL) {
*error_r = "UPDATE-CMD: Duplicate new command id";
return -1;
}
if (str_array_length(args) < 5) {
*error_r = "UPDATE-CMD: Too few parameters";
return -1;
}
cmd = mail_command_add(session, args[3], args[4]);
cmd->id = cmd_id;
session->highest_cmd_id =
I_MAX(session->highest_cmd_id, cmd_id);
session->num_cmds++;
session->user->num_cmds++;
session->user->domain->num_cmds++;
if (session->ip != NULL)
session->ip->num_cmds++;
mail_global_stats.num_cmds++;
args += 5;
} else {
if (cmd == NULL) {
/* already expired command, ignore */
i_warning("UPDATE-CMD: Already expired");
return 0;
}
args += 3;
cmd->last_update = ioloop_timeval;
}
buf = t_buffer_create(256);
if (args[0] == NULL ||
base64_decode(args[0], strlen(args[0]), NULL, buf) < 0) {
*error_r = t_strdup_printf("UPDATE-CMD: Invalid base64 input");
return -1;
}
new_stats = stats_alloc(pool_datastack_create());
diff_stats = stats_alloc(pool_datastack_create());
if (!stats_import(buf->data, buf->used, cmd->stats, new_stats, &error)) {
*error_r = t_strdup_printf("UPDATE-CMD: %s", error);
return -1;
}
if (!stats_diff(cmd->stats, new_stats, diff_stats, &error)) {
*error_r = t_strdup_printf("UPDATE-CMD: stats shrank: %s", error);
return -1;
}
stats_add(cmd->stats, diff_stats);
if (done) {
cmd->id = 0;
mail_command_unref(&cmd);
}
mail_session_refresh(session, NULL);
return 0;
}