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); }