void lmtp_client_add_rcpt_params(struct lmtp_client *client, const char *address,
const struct lmtp_recipient_params *params,
lmtp_callback_t *rcpt_to_callback,
lmtp_callback_t *data_callback, void *context)
{
struct lmtp_rcpt *rcpt;
enum lmtp_client_result result;
rcpt = array_append_space(&client->recipients);
rcpt->address = p_strdup(client->pool, address);
rcpt->params.dsn_orcpt = p_strdup(client->pool, params->dsn_orcpt);
rcpt->rcpt_to_callback = rcpt_to_callback;
rcpt->data_callback = data_callback;
rcpt->context = context;
if (client->global_fail_string != NULL) {
/* we've already failed */
client->rcpt_next_receive_idx++;
i_assert(client->rcpt_next_receive_idx ==
array_count(&client->recipients));
result = client->global_remote_failure ?
LMTP_CLIENT_RESULT_REMOTE_ERROR :
LMTP_CLIENT_RESULT_INTERNAL_ERROR;
rcpt->failed = TRUE;
rcpt_to_callback(result, client->global_fail_string, context);
} else if (client->input_state == LMTP_INPUT_STATE_RCPT_TO)
lmtp_client_send_rcpts(client);
}
static int finish_line(struct imap_parser *parser, unsigned int count,
const struct imap_arg **args_r)
{
struct imap_arg *arg;
int ret = array_count(&parser->root_list);
parser->line_size += parser->cur_pos;
i_stream_skip(parser->input, parser->cur_pos);
parser->cur_pos = 0;
parser->cur_resp_text = FALSE;
if (parser->list_arg != NULL && !parser->literal_size_return &&
(parser->flags & IMAP_PARSE_FLAG_STOP_AT_LIST) == 0) {
parser->error = "Missing ')'";
*args_r = NULL;
return -1;
}
arg = array_append_space(&parser->root_list);
arg->type = IMAP_ARG_EOL;
parser->args_added_extra_eol = TRUE;
*args_r = array_get(&parser->root_list, &count);
return ret;
}
int sieve_stringlist_read_all
(struct sieve_stringlist *strlist, pool_t pool,
const char * const **list_r)
{
if ( strlist->read_all == NULL ) {
ARRAY(const char *) items;
string_t *item;
int ret;
sieve_stringlist_reset(strlist);
p_array_init(&items, pool, 4);
item = NULL;
while ( (ret=sieve_stringlist_next_item(strlist, &item)) > 0 ) {
const char *stritem = p_strdup(pool, str_c(item));
array_append(&items, &stritem, 1);
}
(void)array_append_space(&items);
*list_r = array_idx(&items, 0);
return ( ret < 0 ? -1 : 1 );
}
return strlist->read_all(strlist, pool, list_r);
}
void program_client_set_extra_fd
(struct program_client *pclient, int fd,
program_client_fd_callback_t *callback, void *context)
{
struct program_client_extra_fd *efds;
struct program_client_extra_fd *efd = NULL;
unsigned int i, count;
i_assert(fd > 1);
if ( !array_is_created(&pclient->extra_fds) )
p_array_init(&pclient->extra_fds, pclient->pool, 2);
efds = array_get_modifiable(&pclient->extra_fds, &count);
for ( i = 0; i < count; i++ ) {
if ( efds[i].child_fd == fd ) {
efd = &efds[i];
break;
}
}
if ( efd == NULL ) {
efd = array_append_space(&pclient->extra_fds);
efd->pclient = pclient;
efd->child_fd = fd;
efd->parent_fd = -1;
}
efd->callback = callback;
efd->context = context;
}
static void log_append_flag_updates(struct mail_index_export_context *ctx,
struct mail_index_transaction *t)
{
ARRAY(struct mail_transaction_flag_update) log_updates;
const struct mail_index_flag_update *updates;
struct mail_transaction_flag_update *log_update;
unsigned int i, count;
updates = array_get(&t->updates, &count);
if (count == 0)
return;
i_array_init(&log_updates, count);
for (i = 0; i < count; i++) {
log_update = array_append_space(&log_updates);
log_update->uid1 = updates[i].uid1;
log_update->uid2 = updates[i].uid2;
log_update->add_flags = updates[i].add_flags & 0xff;
log_update->remove_flags = updates[i].remove_flags & 0xff;
if ((updates[i].add_flags & MAIL_INDEX_MAIL_FLAG_UPDATE_MODSEQ) != 0)
log_update->modseq_inc_flag = 1;
}
log_append_buffer(ctx, log_updates.arr.buffer,
MAIL_TRANSACTION_FLAG_UPDATE);
array_free(&log_updates);
}
static void
test_parse_imap_arg_dup(pool_t pool, const struct imap_arg *args,
struct imap_arg *dup)
{
const struct imap_arg *subargs;
struct imap_arg *subdub;
unsigned int i, count;
dup->type = args->type;
switch (dup->type) {
case IMAP_ARG_EOL:
break;
case IMAP_ARG_NIL:
case IMAP_ARG_ATOM:
case IMAP_ARG_STRING:
case IMAP_ARG_LITERAL:
dup->_data.str = p_strdup(pool, args->_data.str);
break;
case IMAP_ARG_LIST:
subargs = array_get(&args->_data.list, &count);
p_array_init(&dup->_data.list, pool, count);
for (i = 0; i < count; i++) {
subdub = array_append_space(&dup->_data.list);
test_parse_imap_arg_dup(pool, &subargs[i], subdub);
}
break;
default:
i_unreached();
}
}
static void
get_metadata_cache_fields(struct mailbox *box,
struct mailbox_metadata *metadata_r)
{
const struct mail_cache_field *fields;
enum mail_cache_decision_type dec;
ARRAY_TYPE(mailbox_cache_field) *cache_fields;
struct mailbox_cache_field *cf;
unsigned int i, count;
if (box->metadata_pool == NULL) {
box->metadata_pool =
pool_alloconly_create("mailbox metadata", 1024*3);
}
fields = mail_cache_register_get_list(box->cache,
box->metadata_pool, &count);
cache_fields = p_new(box->metadata_pool,
ARRAY_TYPE(mailbox_cache_field), 1);
p_array_init(cache_fields, box->metadata_pool, count);
for (i = 0; i < count; i++) {
dec = fields[i].decision & ~MAIL_CACHE_DECISION_FORCED;
if (dec != MAIL_CACHE_DECISION_NO) {
cf = array_append_space(cache_fields);
cf->name = fields[i].name;
cf->decision = fields[i].decision;
cf->last_used = fields[i].last_used;
}
}
metadata_r->cache_fields = cache_fields;
}
static struct sieve_extension *_sieve_extension_register
(struct sieve_instance *svinst, const struct sieve_extension_def *extdef,
bool load, bool required)
{
struct sieve_extension_registry *ext_reg = svinst->ext_reg;
struct sieve_extension *ext =
hash_table_lookup(ext_reg->extension_index, extdef->name);
/* Register extension if it is not registered already */
if ( ext == NULL ) {
struct sieve_extension **extr;
int ext_id = (int)array_count(&ext_reg->extensions);
/* Add extension to the registry */
extr = array_append_space(&ext_reg->extensions);
*extr = ext = p_new(svinst->pool, struct sieve_extension, 1);
ext->id = ext_id;
ext->def = extdef;
ext->svinst = svinst;
hash_table_insert(ext_reg->extension_index, extdef->name, ext);
/* Re-register it if it were previously unregistered
* (not going to happen)
*/
} else if ( ext->def == NULL ) {
static void solr_lookup_add_doc(struct solr_lookup_xml_context *ctx)
{
struct fts_score_map *score;
struct solr_result *result;
const char *box_id;
if (ctx->uid == 0) {
i_error("fts_solr: Query didn't return uid");
return;
}
if (ctx->mailbox == NULL) {
/* looking up from a single mailbox only */
box_id = "";
} else if (ctx->uidvalidity != 0) {
/* old style lookup */
string_t *str = t_str_new(64);
str_printfa(str, "%u\001", ctx->uidvalidity);
str_append(str, ctx->mailbox);
if (ctx->ns != NULL)
str_printfa(str, "\001%s", ctx->ns);
box_id = str_c(str);
} else {
/* new style lookup */
box_id = ctx->mailbox;
}
result = solr_result_get(ctx, box_id);
seq_range_array_add(&result->uids, ctx->uid);
if (ctx->score != 0) {
score = array_append_space(&result->scores);
score->uid = ctx->uid;
score->score = ctx->score;
}
}
static struct imap_arg *imap_arg_create(struct imap_parser *parser)
{
struct imap_arg *arg;
arg = array_append_space(parser->cur_list);
arg->parent = parser->list_arg;
return arg;
}
static void
doveadm_print_flow_header(const struct doveadm_print_header *hdr)
{
struct doveadm_print_flow_header *fhdr;
fhdr = array_append_space(&ctx->headers);
fhdr->title = p_strdup(ctx->pool, hdr->title);
fhdr->flags = hdr->flags;
}
static struct managesieve_arg *managesieve_arg_create
(struct managesieve_parser *parser)
{
struct managesieve_arg *arg;
arg = array_append_space(parser->cur_list);
arg->parent = parser->list_arg;
return arg;
}
void
oauth2_parse_json(struct oauth2_request *req)
{
bool success;
enum json_type type;
const char *token, *error;
int ret;
req->field_name = NULL;
while((ret = json_parse_next(req->parser, &type, &token)) > 0) {
if (req->field_name == NULL) {
if (type != JSON_TYPE_OBJECT_KEY) break;
/* cannot use t_strdup because we might
have to read more */
req->field_name = p_strdup(req->pool, token);
} else if (type < JSON_TYPE_STRING) {
/* this should be last allocation */
p_free(req->pool, req->field_name);
json_parse_skip_next(req->parser);
} else {
if (!array_is_created(&req->fields))
p_array_init(&req->fields, req->pool, 4);
struct oauth2_field *field =
array_append_space(&req->fields);
field->name = req->field_name;
req->field_name = NULL;
field->value = p_strdup(req->pool, token);
}
}
/* read more */
if (ret == 0) return;
io_remove(&req->io);
if (ret > 0) {
(void)json_parser_deinit(&req->parser, &error);
error = "Invalid response data";
success = FALSE;
} else if (i_stream_read_eof(req->is) &&
req->is->v_offset == 0 && req->is->stream_errno == 0) {
/* discard error, empty response is OK. */
(void)json_parser_deinit(&req->parser, &error);
error = NULL;
success = TRUE;
} else {
ret = json_parser_deinit(&req->parser, &error);
success = (ret == 0);
}
i_stream_unref(&req->is);
req->json_parsed_cb(req, success, error);
}
static void
index_sort_list_add_pop3_order(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_size) *nodes = program->context;
struct mail_sort_node_size *node;
node = array_append_space(nodes);
node->seq = mail->seq;
node->size = index_sort_get_pop3_order(mail);
}
static void
index_sort_list_add_relevancy(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_float) *nodes = program->context;
struct mail_sort_node_float *node;
node = array_append_space(nodes);
node->seq = mail->seq;
node->num = index_sort_get_relevancy(mail);
}
void io_stream_add_destroy_callback(struct iostream_private *stream,
void (*callback)(void *), void *context)
{
struct iostream_destroy_callback *dc;
if (!array_is_created(&stream->destroy_callbacks))
i_array_init(&stream->destroy_callbacks, 2);
dc = array_append_space(&stream->destroy_callbacks);
dc->callback = callback;
dc->context = context;
}
void dict_transaction_memory_unset(struct dict_transaction_context *_ctx,
const char *key)
{
struct dict_transaction_memory_context *ctx =
(struct dict_transaction_memory_context *)_ctx;
struct dict_transaction_memory_change *change;
change = array_append_space(&ctx->changes);
change->type = DICT_CHANGE_TYPE_UNSET;
change->key = p_strdup(ctx->pool, key);
}
void dict_transaction_memory_append(struct dict_transaction_context *_ctx,
const char *key, const char *value)
{
struct dict_transaction_memory_context *ctx =
(struct dict_transaction_memory_context *)_ctx;
struct dict_transaction_memory_change *change;
change = array_append_space(&ctx->changes);
change->type = DICT_CHANGE_TYPE_APPEND;
change->key = p_strdup(ctx->pool, key);
change->value.str = p_strdup(ctx->pool, value);
}
static void
index_sort_list_add_arrival(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_date) *nodes = program->context;
struct mail_sort_node_date *node;
node = array_append_space(nodes);
node->seq = mail->seq;
if (mail_get_received_date(mail, &node->date) < 0)
node->date = 0;
}
void dict_transaction_memory_atomic_inc(struct dict_transaction_context *_ctx,
const char *key, long long diff)
{
struct dict_transaction_memory_context *ctx =
(struct dict_transaction_memory_context *)_ctx;
struct dict_transaction_memory_change *change;
change = array_append_space(&ctx->changes);
change->type = DICT_CHANGE_TYPE_INC;
change->key = p_strdup(ctx->pool, key);
change->value.diff = diff;
}
static void
index_sort_list_add_size(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_size) *nodes = program->context;
struct mail_sort_node_size *node;
node = array_append_space(nodes);
node->seq = mail->seq;
if (mail_get_virtual_size(mail, &node->size) < 0)
node->size = 0;
}
static int finish_line
(struct managesieve_parser *parser, unsigned int count,
const struct managesieve_arg **args_r)
{
struct managesieve_arg *arg;
int ret = array_count(&parser->root_list);
parser->line_size += parser->cur_pos;
i_stream_skip(parser->input, parser->cur_pos);
parser->cur_pos = 0;
/* fill the missing parameters with NILs */
while (count > array_count(&parser->root_list)) {
arg = array_append_space(&parser->root_list);
arg->type = MANAGESIEVE_ARG_NONE;
}
arg = array_append_space(&parser->root_list);
arg->type = MANAGESIEVE_ARG_EOL;
*args_r = array_get(&parser->root_list, &count);
return ret;
}
static void
sync_add_create_change(struct dsync_mailbox_tree_sync_ctx *ctx,
const struct dsync_mailbox_node *node, const char *name)
{
struct dsync_mailbox_tree_sync_change *change;
i_assert(ctx->sync_type != DSYNC_MAILBOX_TREES_SYNC_TYPE_PRESERVE_LOCAL);
change = array_append_space(&ctx->changes);
change->type = DSYNC_MAILBOX_TREE_SYNC_TYPE_CREATE_BOX;
change->ns = node->ns;
change->full_name = p_strdup(ctx->pool, name);
memcpy(change->mailbox_guid, node->mailbox_guid,
sizeof(change->mailbox_guid));
change->uid_validity = node->uid_validity;
}
static ARRAY_TYPE(imap_arg_list) *
test_parse_imap_args_dup(pool_t pool, const struct imap_arg *args)
{
ARRAY_TYPE(imap_arg_list) *list;
struct imap_arg *dub;
unsigned int i, count = 0;
while (args[count++].type != IMAP_ARG_EOL) ;
list = p_new(pool, ARRAY_TYPE(imap_arg_list), 1);
p_array_init(list, pool, count);
for (i = 0; i < count; i++) {
dub = array_append_space(list);
test_parse_imap_arg_dup(pool, &args[i], dub);
}
return list;
}
static void
sync_add_dir_change(struct dsync_mailbox_tree_sync_ctx *ctx,
const struct dsync_mailbox_node *node,
enum dsync_mailbox_tree_sync_type type)
{
struct dsync_mailbox_tree_sync_change *change;
const char *name;
i_assert(ctx->sync_type != DSYNC_MAILBOX_TREES_SYNC_TYPE_PRESERVE_LOCAL);
name = dsync_mailbox_node_get_full_name(ctx->local_tree, node);
change = array_append_space(&ctx->changes);
change->type = type;
change->ns = node->ns;
change->full_name = p_strdup(ctx->pool, name);
}
static void
index_sort_list_add_date(struct mail_search_sort_program *program,
struct mail *mail)
{
ARRAY_TYPE(mail_sort_node_date) *nodes = program->context;
struct mail_sort_node_date *node;
int tz;
node = array_append_space(nodes);
node->seq = mail->seq;
if (mail_get_date(mail, &node->date, &tz) < 0)
node->date = index_sort_program_set_date_failed(program, mail);
else if (node->date == 0) {
if (mail_get_received_date(mail, &node->date) < 0)
node->date = index_sort_program_set_date_failed(program, mail);
}
}
static const struct sieve_enotify_method *ext_enotify_method_register
(struct sieve_instance *svinst, struct ext_enotify_context *ectx,
const struct sieve_enotify_method_def *nmth_def)
{
struct sieve_enotify_method *nmth;
int nmth_id = (int) array_count(&ectx->notify_methods);
nmth = array_append_space(&ectx->notify_methods);
nmth->def = nmth_def;
nmth->id = nmth_id;
nmth->svinst = svinst;
if ( nmth_def->load != NULL )
nmth_def->load(nmth, &nmth->context);
return nmth;
}
void elasticsearch_connection_select_json(struct elasticsearch_connection *conn,
char *key, struct json_object *val)
{
json_object *jvalue;
struct elasticsearch_result *result = NULL;
struct fts_score_map *tmp_score = NULL;
if (conn != NULL) {
/* ensure a key and val exist before trying to process them */
if (key != NULL && val != NULL) {
if (strcmp(key, "uid") == 0) {
jvalue = json_object_array_get_idx(val, 0);
conn->ctx->uid = json_object_get_int(jvalue);
}
if (strcmp(key, "_score") == 0)
conn->ctx->score = json_object_get_double(val);
if (strcmp(key, "box") == 0) {
jvalue = json_object_array_get_idx(val, 0);
conn->ctx->box_guid = json_object_get_string(jvalue);
}
}
/* this is all we need for an e-mail result */
if (conn->ctx->uid != -1 && conn->ctx->score != -1 && conn->ctx->box_guid != NULL) {
result = elasticsearch_result_get(conn, conn->ctx->box_guid);
tmp_score = array_append_space(&result->scores);
seq_range_array_add(&result->uids, conn->ctx->uid);
tmp_score->uid = conn->ctx->uid;
tmp_score->score = conn->ctx->score;
/* clean-up */
conn->ctx->uid = -1;
conn->ctx->score = -1;
conn->ctx->box_guid = NULL;
conn->ctx->results_found = TRUE;
}
} else { /* conn != NULL && key != NULL && val != NULL */
i_error("fts_elasticsearch: select_json: critical error while processing result JSON");
}
}
static int imap_map_read(struct mailbox *box)
{
struct pop3_migration_mailbox *mbox = POP3_MIGRATION_CONTEXT(box);
struct mailbox_status status;
struct mailbox_transaction_context *t;
struct mail_search_args *search_args;
struct mail_search_context *ctx;
struct mail *mail;
struct imap_msg_map *map;
uoff_t psize;
int ret = 0;
mailbox_get_open_status(box, STATUS_MESSAGES, &status);
i_assert(!array_is_created(&mbox->imap_msg_map));
p_array_init(&mbox->imap_msg_map, box->pool, status.messages);
t = mailbox_transaction_begin(box, 0);
search_args = mail_search_build_init();
mail_search_build_add_all(search_args);
ctx = mailbox_search_init(t, search_args, NULL,
MAIL_FETCH_PHYSICAL_SIZE, NULL);
mail_search_args_unref(&search_args);
while (mailbox_search_next(ctx, &mail)) {
if (mail_get_physical_size(mail, &psize) < 0) {
i_error("pop3_migration: Failed to get psize for imap uid %u: %s",
mail->uid,
mailbox_get_last_error(box, NULL));
ret = -1;
break;
}
map = array_append_space(&mbox->imap_msg_map);
map->uid = mail->uid;
map->psize = psize;
}
if (mailbox_search_deinit(&ctx) < 0)
ret = -1;
(void)mailbox_transaction_commit(&t);
return ret;
}
void lmtp_client_add_rcpt(struct lmtp_client *client, const char *address,
lmtp_callback_t *rcpt_to_callback,
lmtp_callback_t *data_callback, void *context)
{
struct lmtp_rcpt *rcpt;
rcpt = array_append_space(&client->recipients);
rcpt->address = p_strdup(client->pool, address);
rcpt->rcpt_to_callback = rcpt_to_callback;
rcpt->data_callback = data_callback;
rcpt->context = context;
if (client->global_fail_string != NULL) {
client->rcpt_next_receive_idx++;
i_assert(client->rcpt_next_receive_idx ==
array_count(&client->recipients));
rcpt->failed = TRUE;
rcpt_to_callback(FALSE, client->global_fail_string, context);
} else if (client->input_state == LMTP_INPUT_STATE_RCPT_TO)
lmtp_client_send_rcpts(client);
}
