pair.key = key;
pair.value = *ptr;
key = NULL;
- array_append(&attribute_pairs, &pair, 1);
+ array_push_back(&attribute_pairs, &pair);
}
}
if (key != NULL) {
t_array_init(&var_funcs_table, 8);
for(ptr = auth_request_var_funcs_table; ptr->key != NULL; ptr++) {
- array_append(&var_funcs_table, ptr, 1);
+ array_push_back(&var_funcs_table, ptr);
}
ftable = array_append_space(&var_funcs_table);
ftable->key = "ldap";
strcmp(p+1, named_res->field->name) == 0) {
name = p_strdup_until(unsafe_data_stack_pool,
field->ldap_attr_name, p);
- array_append(&ctx.attr_names, &name, 1);
+ array_push_back(&ctx.attr_names, &name);
}
}
}
if (*ldap_attr != '\0' &&
strchr(ldap_attr, '@') == NULL) {
/* root request's attribute */
- array_append(&ctx.attr_names, &ldap_attr, 1);
+ array_push_back(&ctx.attr_names, &ldap_attr);
}
}
}
const struct password_scheme *scheme;
ctx = hash_table_iterate_init(password_schemes);
while(hash_table_iterate(ctx, password_schemes, &key, &scheme)) {
- array_append(schemes_r, &scheme, 1);
+ array_push_back(schemes_r, &scheme);
}
hash_table_iterate_deinit(&ctx);
}
module = *args + 7;
if (strcmp(module, "master") == 0)
is_master = TRUE;
- array_append(&modules, &module, 1);
+ array_push_back(&modules, &module);
} else if (str_begins(*args, "lname="))
filter.local_name = *args + 6;
else if (str_begins(*args, "lip=")) {
if (!config_filter_match_service(mask, filter)) {
if (!str_array_contains(&service_names, mask->service) &&
have_changed_settings(ctx->parsers[i], modules))
- array_append(&service_names, &mask->service, 1);
+ array_push_back(&service_names,
+ &mask->service);
continue;
}
output_r->used_local = TRUE;
if (mask->remote_bits > 0)
output_r->used_remote = TRUE;
- array_append(&matches, &ctx->parsers[i], 1);
+ array_push_back(&matches, &ctx->parsers[i]);
}
}
if (filter->service == NULL) {
t_array_init(&filters, 8);
for (i = 0; ctx->parsers[i] != NULL; i++) {
- array_append(&filters, &ctx->parsers[i], 1);
+ array_push_back(&filters, &ctx->parsers[i]);
}
array_sort(&filters, config_filter_parser_cmp_rev);
array_append_zero(&filters);
tmp_mask.remote_bits = 0;
if (config_filter_match_rest(&tmp_mask, filter))
- array_append(&matches, &ctx->parsers[i], 1);
+ array_push_back(&matches, &ctx->parsers[i]);
}
array_sort(&matches, config_filter_parser_cmp_rev);
array_append_zero(&matches);
t_strdup_printf("%s_set_roots", m->name));
if (roots != NULL) {
for (i = 0; roots[i] != NULL; i++)
- array_append(&new_roots, &roots[i], 1);
+ array_push_back(&new_roots, &roots[i]);
}
services = module_get_symbol_quiet(m,
service_set = module_get_symbol_quiet(m,
t_strdup_printf("%s_service_settings", m->name));
if (service_set != NULL)
- array_append(&new_services, &service_set, 1);
+ array_push_back(&new_services, &service_set);
}
}
if (array_count(&new_roots) > 0) {
/* modules added new settings. add the defaults and start
using the new list. */
for (i = 0; all_roots[i] != NULL; i++)
- array_append(&new_roots, &all_roots[i], 1);
+ array_push_back(&new_roots, &all_roots[i]);
array_append_zero(&new_roots);
all_roots = array_first(&new_roots);
roots_free_at_deinit = new_roots;
/* module added new services. update the defaults. */
services = array_get(default_services, &count);
for (i = 0; i < count; i++)
- array_append(&new_services, &services[i], 1);
+ array_push_back(&new_services, &services[i]);
*default_services = new_services;
services_free_at_deinit = new_services;
} else {
/* "strlist=" */
str = p_strdup_printf(ctx->pool, "%s/",
t_strcut(strings[i]+1, '='));
- array_append(&prefixes_arr, &str, 1);
+ array_push_back(&prefixes_arr, &str);
} else {
/* string is in format: "list=0 1 2" */
for (args = t_strsplit(p + 1, " "); *args != NULL; args++) {
str = p_strdup_printf(ctx->pool, "%s/%s/",
t_strcut(strings[i]+1, '='),
*args);
- array_append(&prefixes_arr, &str, 1);
+ array_push_back(&prefixes_arr, &str);
}
}
} T_END;
str_len(ctx->list_prefix);
prefix_idx = j;
prefix.prefix_idx = prefix_idx;
- array_append(&prefix_stack, &prefix, 1);
+ array_push_back(&prefix_stack, &prefix);
str_append_max(ctx->list_prefix, indent_str, indent*2);
p = strchr(key2, '/');
break;
case 'm':
module = t_strdup(optarg);
- array_append(&module_names, &module, 1);
+ array_push_back(&module_names, &module);
break;
case 'n':
scope = CONFIG_DUMP_SCOPE_CHANGED;
str_to_uint(args[1], &host->vhost_count) < 0)
i_fatal("host list broken");
hash_table_insert(hosts, &host->ip, host);
- array_append(&hosts_array, &host, 1);
+ array_push_back(&hosts_array, &host);
} T_END;
}
if (line == NULL)
if (!ret) {
/* a) request for a user being killed
b) user is weak */
- array_append(&new_requests, requestp, 1);
+ array_push_back(&new_requests, requestp);
}
}
array_clear(&dir->pending_requests);
i_array_init(&users, users_count);
user = dir->head;
for (i = 0; i < users_count; i++, user = user->next)
- array_append(&users, &user, 1);
+ array_push_back(&users, &user);
i_assert(user == NULL);
array_sort(&users, user_timestamp_cmp);
o_stream_nsend_str(client->output, "0\t");
for (i = 0; i < ips_count; i++) {
const char *ip = net_ip2addr(&ips[i]);
- array_append(&tmp, &ip, 1);
+ array_push_back(&tmp, &ip);
}
array_append_zero(&tmp);
e_debug(e->event(), "Resolve success: %s",
int i;
const char * const * cptr;
i_assert(array_count(argv) == 0);
- array_append(argv, &name, 1);
+ array_push_back(argv, &name);
ARRAY_TYPE(const_string) pargv;
t_array_init(&pargv, 8);
array_add_opt = TRUE;
} else {
optarg = t_strdup_printf("-%c", params[i].short_opt);
- array_append(argv, &optarg, 1);
+ array_push_back(argv, &optarg);
}
}
/* CMD_PARAM_BOOL is implicitly handled above */
if (params[i].type == CMD_PARAM_STR) {
- array_append(target, ¶ms[i].value.v_string,1);
+ array_push_back(target,
+ ¶ms[i].value.v_string);
} else if (params[i].type == CMD_PARAM_INT64) {
const char *tmp = t_strdup_printf("%lld",
(long long)params[i].value.v_int64);
- array_append(target, &tmp, 1);
+ array_push_back(target, &tmp);
} else if (params[i].type == CMD_PARAM_IP) {
const char *tmp = net_ip2addr(¶ms[i].value.v_ip);
- array_append(target, &tmp, 1);
+ array_push_back(target, &tmp);
} else if (params[i].type == CMD_PARAM_ARRAY) {
array_foreach(¶ms[i].value.v_array, cptr) {
if (array_add_opt)
- array_append(argv, &optarg, 1);
- array_append(target, cptr, 1);
+ array_push_back(argv, &optarg);
+ array_push_back(target, cptr);
}
}
}
if (array_count(&pargv) > 0) {
const char *dashdash = "--";
- array_append(argv, &dashdash, 1);
+ array_push_back(argv, &dashdash);
array_append_array(argv, &pargv);
}
array_append_zero(argv);
}
if (par[i].type != CMD_PARAM_BOOL)
longopt.has_arg = 1;
- array_append(longopts, &longopt, 1);
+ array_push_back(longopts, &longopt);
}
array_append_zero(longopts);
}
t_array_init(&cmd_args, 16);
for (i = 0; argv[i] != NULL; i++) {
p = argv[i];
- array_append(&cmd_args, &p, 1);
+ array_push_back(&cmd_args, &p);
}
if (legacy_dsync) {
/* we're executing doveadm */
p = "dsync-server";
}
- array_append(&cmd_args, &p, 1);
+ array_push_back(&cmd_args, &p);
array_append_zero(&cmd_args);
*cmd_args_r = array_first(&cmd_args);
}
continue;
value = t_strdup(str_c(str));
}
- array_append(&cmd_args, &value, 1);
+ array_push_back(&cmd_args, &value);
}
array_append_zero(&cmd_args);
return array_first(&cmd_args);
we'll include the "/" suffix in the filename when deleting
it. */
fname = t_strconcat(fname, "/", NULL);
- array_append(&fnames, &fname, 1);
+ array_push_back(&fnames, &fname);
}
if (fs_iter_deinit(&iter) < 0) {
i_error("fs_iter_deinit(%s) failed: %s",
iter = fs_iter_init(fs, path_prefix, 0);
while ((fname = fs_iter_next(iter)) != NULL) {
fname = t_strdup(fname);
- array_append(&fnames, &fname, 1);
+ array_push_back(&fnames, &fname);
}
if (fs_iter_deinit(&iter) < 0) {
i_error("fs_iter_deinit(%s) failed: %s",
if (prev_storage != NULL) {
if (ns_purge(_ctx, prev_ns, prev_storage) < 0)
ret = -1;
- array_append(&purged_storages,
- &prev_storage, 1);
+ array_push_back(&purged_storages,
+ &prev_storage);
}
prev_storage = ns_storage;
prev_ns = info->ns;
if (prev_storage != NULL) {
if (ns_purge(_ctx, prev_ns, prev_storage) < 0)
ret = -1;
- array_append(&purged_storages, &prev_storage, 1);
+ array_push_back(&purged_storages, &prev_storage);
}
/* make sure all private storages have been purged */
if (i == count) {
if (ns_purge(_ctx, ns, ns_storage) < 0)
ret = -1;
- array_append(&purged_storages, &ns_storage, 1);
+ array_push_back(&purged_storages, &ns_storage);
storages = array_get(&purged_storages, &count);
}
}
p_array_init(&sep_args, _ctx->pool, 16);
for (i = start = 0;; i++) {
if (args[i] != NULL && strcmp(args[i], sep) != 0) {
- array_append(&sep_args, &args[i], 1);
+ array_push_back(&sep_args, &args[i]);
continue;
}
if (i > start) {
ctx->flags |= flag;
} else {
str = p_strdup(_ctx->pool, str);
- array_append(&keywords, &str, 1);
+ array_push_back(&keywords, &str);
}
}
if (array_count(&keywords) > 0 || ctx->modify_type == MODIFY_REPLACE) {
MAILBOX_LIST_ITER_RETURN_NO_FLAGS);
while ((info = mailbox_list_iter_next(iter)) != NULL) {
child_name = t_strdup(info->vname);
- array_append(mailboxes, &child_name, 1);
+ array_push_back(mailboxes, &child_name);
}
return mailbox_list_iter_deinit(&iter);
}
ret = -1;
}
if ((*namep)[0] != '\0')
- array_append(&recursive_mailboxes, namep, 1);
+ array_push_back(&recursive_mailboxes, namep);
}
array_sort(&recursive_mailboxes, i_strcmp_reverse_p);
mailboxes = &recursive_mailboxes;
else
mctx->iterate_all_users = arg->value.v_bool;
fieldstr = "-A";
- array_append(&full_args, &fieldstr, 1);
+ array_push_back(&full_args, &fieldstr);
} else if (strcmp(arg->name, "socket-path") == 0) {
doveadm_settings->doveadm_socket_path = arg->value.v_string;
if (doveadm_settings->doveadm_worker_count == 0)
cctx->username = arg->value.v_string;
fieldstr = "-u";
- array_append(&full_args, &fieldstr, 1);
- array_append(&full_args, &arg->value.v_string, 1);
+ array_push_back(&full_args, &fieldstr);
+ array_push_back(&full_args, &arg->value.v_string);
if (strchr(arg->value.v_string, '*') != NULL ||
strchr(arg->value.v_string, '?') != NULL) {
if (tcp_server)
wildcard_user = "*";
mctx->users_list_input = arg->value.v_istream;
fieldstr = "-F";
- array_append(&full_args, &fieldstr, 1);
+ array_push_back(&full_args, &fieldstr);
fieldstr = ""; /* value doesn't really matter */
- array_append(&full_args, &fieldstr, 1);
+ array_push_back(&full_args, &fieldstr);
i_stream_ref(mctx->users_list_input);
} else if (strcmp(arg->name, "field") == 0 ||
strcmp(arg->name, "flag") == 0) {
fieldstr) */
fieldstr = p_array_const_string_join(mctx->pool,
&arg->value.v_array, " ");
- array_append(&pargv, &fieldstr, 1);
+ array_push_back(&pargv, &fieldstr);
} else if (strcmp(arg->name, "file") == 0) {
/* input for doveadm_mail_get_input(),
used by e.g. save */
return;
}
- array_append(&full_args, &short_opt_str, 1);
+ array_push_back(&full_args, &short_opt_str);
if (arg->type == CMD_PARAM_STR)
- array_append(&full_args, &arg->value.v_string, 1);
+ array_push_back(&full_args,
+ &arg->value.v_string);
} else if ((arg->flags & CMD_PARAM_FLAG_POSITIONAL) != 0) {
/* feed this into pargv */
if (arg->type == CMD_PARAM_ARRAY)
array_append_array(&pargv, &arg->value.v_array);
else if (arg->type == CMD_PARAM_STR)
- array_append(&pargv, &arg->value.v_string, 1);
+ array_push_back(&pargv, &arg->value.v_string);
} else {
doveadm_exit_code = EX_USAGE;
i_error("invalid parameter: %s", arg->name);
}
const char *dashdash = "--";
- array_append(&full_args, &dashdash, 1);
+ array_push_back(&full_args, &dashdash);
array_append_zero(&pargv);
/* All the -parameters need to be included in full_args so that
array_clear(patterns);
return FALSE;
}
- array_append(patterns, &args->value.str, 1);
+ array_push_back(patterns, &args->value.str);
break;
case SEARCH_MAILBOX_GUID:
*have_guid = TRUE;
lf->decision > rf->decision)) {
/* use local decision and timestamp */
} else {
- array_append(&changes, rf, 1);
+ array_push_back(&changes, rf);
}
li++; ri++;
} else if (ret < 0) {
/* field hasn't be used for a long time, remote
will probably drop this soon as well */
} else {
- array_append(&changes, &remote_fields[ri], 1);
+ array_push_back(&changes, &remote_fields[ri]);
}
ri++;
}
p_array_init(dest, pool, count);
for (i = 0; i < count; i++) {
str = p_strdup(pool, strings[i]);
- array_append(dest, &str, 1);
+ array_push_back(dest, &str);
}
}
continue;
namep = array_idx(keywords, start_idx+i);
- array_append(dest, namep, 1);
+ array_push_back(dest, namep);
}
}
for (i = 0; i < count; i++) {
name = changes[i]+1;
name_idx = array_count(&all_keywords);
- array_append(&all_keywords, &name, 1);
+ array_push_back(&all_keywords, &name);
switch (changes[i][0]) {
case KEYWORD_CHANGE_ADD:
name = changes[i]+1;
if (!keyword_find(&all_keywords, name, &name_idx)) {
name_idx = array_count(&all_keywords);
- array_append(&all_keywords, &name, 1);
+ array_push_back(&all_keywords, &name);
}
switch (changes[i][0]) {
name = local_keywords[i];
if (!keyword_find(&all_keywords, name, &name_idx)) {
name_idx = array_count(&all_keywords);
- array_append(&all_keywords, &name, 1);
+ array_push_back(&all_keywords, &name);
}
local_final[name_idx/32] |= 1U << (name_idx%32);
}
case KEYWORD_CHANGE_FINAL:
case KEYWORD_CHANGE_ADD_AND_FINAL:
name = changes[i]+1;
- array_append(&keywords, &name, 1);
+ array_push_back(&keywords, &name);
break;
case KEYWORD_CHANGE_REMOVE:
break;
changes[i][0] == KEYWORD_CHANGE_ADD_AND_FINAL) {
const char *name = changes[i]+1;
- array_append(&keywords, &name, 1);
+ array_push_back(&keywords, &name);
}
}
if (array_count(&keywords) == 0)
} T_END;
seq_range_array_iter_init(&iter, &changes.saved_uids); n = 0;
while (seq_range_array_iter_nth(&iter, n++, &uid))
- array_append(&importer->saved_uids, &uid, 1);
+ array_push_back(&importer->saved_uids, &uid);
pool_unref(&changes.pool);
/* commit flag changes and expunges */
}
}
ctx->combined_mailboxes_count++;
- array_append(&siblings, &node, 1);
+ array_push_back(&siblings, &node);
}
sort_siblings(&siblings);
dsync_mailbox_tree_bfs_iter_deinit(&iter);
case 'a': {
const char *app = t_strdup(optarg);
- array_append(&access_apps, &app, 1);
+ array_push_back(&access_apps, &app);
break;
}
default:
t_array_init(&full_patterns, 16);
for (pat = patterns; *pat != NULL; pat++) {
pattern = mailbox_list_join_refpattern(ns->list, ref, *pat);
- array_append(&full_patterns, &pattern, 1);
+ array_push_back(&full_patterns, &pattern);
}
array_append_zero(&full_patterns); /* NULL-terminate */
return array_first(&full_patterns);
}
if (imap_utf7_to_utf8(pattern, str) == 0)
pattern = p_strdup(cmd->pool, str_c(str));
- array_append(&patterns, &pattern, 1);
+ array_push_back(&patterns, &pattern);
str_truncate(str, 0);
}
args += 2;
pattern = p_strdup(cmd->pool, str_c(str));
p_array_init(&patterns, cmd->pool, 1);
- array_append(&patterns, &pattern, 1);
+ array_push_back(&patterns, &pattern);
args += 2;
if (lsub) {
for (i = 0; i < uid_count; i++) {
if (!seq_range_array_iter_nth(&seq_iter, n++, &seq))
return -1;
- array_append(&ctx->qresync_sample_uidset,
- &uid_range[i].seq1, 1);
- array_append(&ctx->qresync_sample_seqset, &seq, 1);
+ array_push_back(&ctx->qresync_sample_uidset,
+ &uid_range[i].seq1);
+ array_push_back(&ctx->qresync_sample_seqset, &seq);
diff = uid_range[i].seq2 - uid_range[i].seq1;
if (diff > 0) {
if (!seq_range_array_iter_nth(&seq_iter, n++, &seq))
return -1;
- array_append(&ctx->qresync_sample_uidset,
- &uid_range[i].seq2, 1);
- array_append(&ctx->qresync_sample_seqset, &seq, 1);
+ array_push_back(&ctx->qresync_sample_uidset,
+ &uid_range[i].seq2);
+ array_push_back(&ctx->qresync_sample_seqset, &seq);
}
}
if (seq_range_array_iter_nth(&seq_iter, n, &seq))
p_array_init(&cur_thread->msgs, pool, 4);
}
num = cmd->uid ? mail->uid : mail->seq;
- array_append(&cur_thread->msgs, &num, 1);
+ array_push_back(&cur_thread->msgs, &num);
}
str_free(&prev_subject);
ret = mailbox_search_deinit(&search_ctx);
for (unsigned int idx = 0; idx < count; idx++) {
if (client_enabled[idx]) {
feature = imap_feature_idx(idx);
- array_append(&feature_strings, &feature->feature, 1);
+ array_push_back(&feature_strings, &feature->feature);
}
}
array_append_zero(&feature_strings);
}
} else {
/* keyword validity checks are done by lib-storage */
- array_append(&keywords, &atom, 1);
+ array_push_back(&keywords, &atom);
}
args++;
unsigned int kw_index = *kw_indexes;
i_assert(kw_index < all_count);
- array_append(dest, &all_names[kw_index], 1);
+ array_push_back(dest, &all_names[kw_index]);
}
array_append_zero(dest);
while (seq_range_array_iter_nth(&iter, n, &expunged_uid) &&
expunged_uid < mail->uid && seq < state->messages) {
seq++; n++;
- array_append(&expunged_seqs, &seq, 1);
+ array_push_back(&expunged_seqs, &seq);
crc = crc32_data_more(crc, &expunged_uid,
sizeof(expunged_uid));
}
while (seq_range_array_iter_nth(&iter, n, &expunged_uid) &&
seq < state->messages) {
seq++; n++;
- array_append(&expunged_seqs, &seq, 1);
+ array_push_back(&expunged_seqs, &seq);
crc = crc32_data_more(crc, &expunged_uid,
sizeof(expunged_uid));
}
ipc_cmd->conn = conn;
ipc_cmd->callback = callback;
ipc_cmd->context = context;
- array_append(&conn->cmds, &ipc_cmd, 1);
+ array_push_back(&conn->cmds, &ipc_cmd);
T_BEGIN {
o_stream_nsend_str(conn->output,
if (p != NULL && p < p2) {
p = t_strconcat(t_strdup_until(args[i], p2),
"=<hidden>", NULL);
- array_append(&new_args, &p, 1);
+ array_push_back(&new_args, &p);
} else {
- array_append(&new_args, &args[i], 1);
+ array_push_back(&new_args, &args[i]);
}
}
array_append_zero(&new_args);
pat--;
if (path[len-1] == '/') {
attribute = t_strndup(path, len-1);
- array_append(values, &attribute, 1);
+ array_push_back(values,
+ &attribute);
} else {
- array_append(values, &path, 1);
+ array_push_back(values, &path);
}
} else {
- array_append(values, &path, 1);
+ array_push_back(values, &path);
path += len;
}
*path_len_r = path - path_start;
p = strchr(path, '/');
if (p != NULL) {
attribute = t_strdup_until(path, p);
- array_append(values, &attribute, 1);
+ array_push_back(values, &attribute);
path = p;
} else {
/* no '/' anymore, but it'll still match a
partial */
- array_append(values, &path, 1);
+ array_push_back(values, &path);
path += strlen(path);
pat++;
}
entry.key = '\0';
entry.value = ldap_escape(dict->username);
entry.long_key = "username";
- array_append(&exp, &entry, 1);
+ array_push_back(&exp, &entry);
if (priv) {
template = t_strdup_printf("(&(%s=%s)%s)", map->username_attribute, "%{username}", map->filter);
entry.value = ldap_escape(*valuep);
entry.long_key = *long_keyp;
- array_append(&exp, &entry, 1);
+ array_push_back(&exp, &entry);
}
array_append_zero(&exp);
pat--;
if (path[len-1] == '/') {
field = t_strndup(path, len-1);
- array_append(values, &field, 1);
+ array_push_back(values,
+ &field);
} else {
- array_append(values, &path, 1);
+ array_push_back(values, &path);
}
} else {
- array_append(values, &path, 1);
+ array_push_back(values, &path);
path += len;
}
*path_len_r = path - path_start;
p = strchr(path, '/');
if (p != NULL) {
field = t_strdup_until(path, p);
- array_append(values, &field, 1);
+ array_push_back(values, &field);
path = p;
} else {
/* no '/' anymore, but it'll still match a
partial */
- array_append(values, &path, 1);
+ array_push_back(values, &path);
path += strlen(path);
pat++;
}
i_zero(&build);
build.dict = dict;
t_array_init(&build.fields, 1);
- array_append(&build.fields, &field, 1);
+ array_push_back(&build.fields, &field);
build.extra_values = &values;
build.key1 = key[0];
i_zero(&build);
build.dict = dict;
t_array_init(&build.fields, 1);
- array_append(&build.fields, &field, 1);
+ array_push_back(&build.fields, &field);
build.extra_values = &values;
build.key1 = key[0];
duplicates. */
i++;
} else {
- array_append(&retry_cmds, cmdp, 1);
+ array_push_back(&retry_cmds, cmdp);
array_delete(&dict->cmds, i, 1);
}
}
array_foreach(&file->metadata, md) {
if (strncmp(md->key, FS_METADATA_INTERNAL_PREFIX,
strlen(FS_METADATA_INTERNAL_PREFIX)) == 0)
- array_append(&internal_metadata, md, 1);
+ array_push_back(&internal_metadata, md);
}
array_clear(&file->metadata);
array_append_array(&file->metadata, &internal_metadata);
(parser, ¶m.name, ¶m.value)) > 0) {
if (!array_is_created(params))
t_array_init(params, 4);
- array_append(params, ¶m, 1);
+ array_push_back(params, ¶m);
count++;
last = parser->cur;
if (!array_is_created(chlngs))
t_array_init(chlngs, 4);
- array_append(chlngs, &chlng, 1);
+ array_push_back(chlngs, &chlng);
/* OWS "," OWS
--> also allow empty elements
nparam.name = p_strdup(pool, sparam->name);
nparam.value = p_strdup(pool, sparam->value);
- array_append(dst, &nparam, 1);
+ array_push_back(dst, &nparam);
}
}
&ioloop_timeval, TIMEOUT_CMP_MARGIN_USECS) > 0) {
break;
}
- array_append(&failed_requests, &reqs[i], 1);
+ array_push_back(&failed_requests, &reqs[i]);
}
/* update timeout */
i++;
} else {
array_delete(cmd_array, i, 1);
- array_append(dest_array, &cmd, 1);
+ array_push_back(dest_array, &cmd);
}
}
}
}
value = p_strdup(pool, t_str_ucase(value));
- array_append(fields, &value, 1);
+ array_push_back(fields, &value);
}
/* istream-header-filter requires headers to be sorted */
array_sort(fields, i_strcasecmp_p);
return;
for (i = 0; msgpart->headers[i] != NULL; i++)
- array_append(headers, &msgpart->headers[i], 1);
+ array_push_back(headers, &msgpart->headers[i]);
}
static int
for (p = glob->patterns; p->pattern != NULL; p++) {
if (p->inboxcase)
inboxcase = TRUE;
- array_append(&patterns, &p->pattern, 1);
+ array_push_back(&patterns, &p->pattern);
}
array_append_zero(&patterns);
return imap_match_init_multiple_real(pool, array_first(&patterns),
record_count++;
}
- array_append(ext_offsets, &ext_offset, 1);
+ array_push_back(ext_offsets, &ext_offset);
}
i_assert(orig_fields_count == cache->fields_count);
/* duplicate */
name = "";
}
- array_append(&names, &name, 1);
+ array_push_back(&names, &name);
}
/* give new names to invalid keywords */
ext_hdr, offset,
&next_offset);
}
- array_append(&names, &name, 1);
+ array_push_back(&names, &name);
offset = next_offset;
continue;
}
return FALSE;
}
- array_append(keywords, &idx, 1);
+ array_push_back(keywords, &idx);
return TRUE;
case MAIL_INDEX_SYNC_TYPE_KEYWORD_REMOVE:
for (i = 0; i < count; i++) {
if (range[i].seq1 < first_new_seq) {
temp_range.seq1 = first_new_seq;
temp_range.seq2 = range[i].seq2;
- array_append(&old_seqs, &temp_range, 1);
+ array_push_back(&old_seqs, &temp_range);
range[i].seq2 = first_new_seq - 1;
i++;
}
really care about performance that much here, */
keywords_count = array_count(&t->view->index->keywords);
for (i = 0; i < keywords_count; i++)
- array_append(&keywords, &i, 1);
+ array_push_back(&keywords, &i);
} else {
mail_index_transaction_lookup_latest_keywords(t, seq, &keywords);
}
if (indexes[i] == idx)
return;
}
- array_append(keywords, &idx, 1);
+ array_push_back(keywords, &idx);
}
static void keyword_index_remove(ARRAY_TYPE(keyword_indexes) *keywords,
}
index_idx = keyword_idx_map[idx];
- array_append(keyword_idx, &index_idx, 1);
+ array_push_back(keyword_idx, &index_idx);
}
}
}
while(tmp != NULL) {
struct ldap_attribute *attr = p_new(result->pool, struct ldap_attribute, 1);
attr->name = p_strdup(result->pool, tmp);
- array_append(&attr_names, &attr->name, 1);
+ array_push_back(&attr_names, &attr->name);
values = ldap_get_values_len(result->conn->conn, message, tmp);
if (values != NULL) {
count = ldap_count_values_len(values);
p_array_init(&attr->values, result->pool, count);
for(int i = 0; i < count; i++) {
const char *ptr = p_strndup(result->pool, values[i]->bv_val, values[i]->bv_len);
- array_append(&attr->values, &ptr, 1);
+ array_push_back(&attr->values, &ptr);
}
ldap_value_free_len(values);
}
array_append_zero(&attr->values);
ldap_memfree(tmp);
- array_append(&obj->attributes, attr, 1);
+ array_push_back(&obj->attributes, attr);
tmp = ldap_next_attribute(result->conn->conn, message, bptr);
}
p_array_init(&arr, req->pool, 8);
for(const char **ptr = (const char**)input->attributes; *ptr != NULL; ptr++) {
const char *tmp = p_strdup(req->pool, *ptr);
- array_append(&arr, &tmp, 1);
+ array_push_back(&arr, &tmp);
}
array_append_zero(&arr);
req->input.search.attributes = array_first_modifiable(&arr);
while (rfc822_parse_atom(&parser, str) >= 0) {
const char *lang = p_strdup(pool, str_c(str));
- array_append(&langs, &lang, 1);
+ array_push_back(&langs, &lang);
str_truncate(str, 0);
if (parser.data >= parser.end || *parser.data != ',')
/* forward chunk to new iovec */
iovn.iov_base = data;
iovn.iov_len = chunk;
- array_append(&iov_arr, &iovn, 1);
+ array_push_back(&iov_arr, &iovn);
data = p;
i_assert(max_bytes >= chunk);
max_bytes -= chunk;
data++;
iovn.iov_base = (add == '\r' ? "\r\n" : "..");
iovn.iov_len = 2;
- array_append(&iov_arr, &iovn, 1);
+ array_push_back(&iov_arr, &iovn);
i_assert(max_bytes >= 2);
max_bytes -= 2;
added++;
if (chunk > 0) {
iovn.iov_base = data;
iovn.iov_len = chunk;
- array_append(&iov_arr, &iovn, 1);
+ array_push_back(&iov_arr, &iovn);
i_assert(max_bytes >= chunk);
max_bytes -= chunk;
sent += chunk;
else {
rfc2231_param.key = t_strdup_until(key, p2);
rfc2231_param.value = t_strdup(str_c(str));
- array_append(&rfc2231_params_arr,
- &rfc2231_param, 1);
+ array_push_back(&rfc2231_params_arr,
+ &rfc2231_param);
}
}
if (p == NULL) {
const char *value = t_strdup(str_c(str));
- array_append(&result, &key, 1);
- array_append(&result, &value, 1);
+ array_push_back(&result, &key);
+ array_push_back(&result, &value);
}
}
ctx->nul_replacement_str = prev_replacement_str;
"%s*%u*" : "%s*%u",
rfc2231_params[j].key,
rfc2231_params[j].idx);
- array_append(&result, &key, 1);
- array_append(&result,
- &rfc2231_params[j].value, 1);
+ array_push_back(&result, &key);
+ array_push_back(&result,
+ &rfc2231_params[j].value);
}
} else {
/* everything was successful */
if (have_extended)
key = t_strconcat(key, "*", NULL);
const char *value = t_strdup(str_c(str));
- array_append(&result, &key, 1);
- array_append(&result, &value, 1);
+ array_push_back(&result, &key);
+ array_push_back(&result, &value);
}
}
array_append_zero(&result); /* NULL-terminate */
str = strchr(str, ':');
i_assert(str != NULL);
str++;
- array_append(&categories, &str, 1);
+ array_push_back(&categories, &str);
} else {
*error_r = t_strdup_printf("Unknown event '%s'", str);
return -1;
output_r->used_remote = TRUE;
else if (str_begins(*arg, "service=")) {
const char *name = p_strdup(pool, *arg + 8);
- array_append(&services, &name, 1);
+ array_push_back(&services, &name);
}
}
if (input->service == NULL) {
break;
if (str_begins(line, "FILTER\t")) {
line = t_strdup(line+7);
- array_append(&filters_tmp, &line, 1);
+ array_push_back(&filters_tmp, &line);
}
}
i_stream_unref(&is);
p_array_init(&all_roots, service->set_pool, 8);
tmp_root = &master_service_setting_parser_info;
- array_append(&all_roots, &tmp_root, 1);
+ array_push_back(&all_roots, &tmp_root);
if (service->want_ssl_settings) {
tmp_root = &master_service_ssl_setting_parser_info;
- array_append(&all_roots, &tmp_root, 1);
+ array_push_back(&all_roots, &tmp_root);
}
if (input->roots != NULL) {
for (i = 0; input->roots[i] != NULL; i++)
- array_append(&all_roots, &input->roots[i], 1);
+ array_push_back(&all_roots, &input->roots[i]);
}
parser = settings_parser_init_list(service->set_pool,
/* preserve existing DOVECOT_PRESERVE_ENVS */
value = getenv(DOVECOT_PRESERVE_ENVS_ENV);
if (value != NULL)
- array_append(&keys, &value, 1);
+ array_push_back(&keys, &value);
/* add new environments */
envs = t_strsplit_spaces(import_environment, " ");
for (; *envs != NULL; envs++) {
key = t_strdup_until(*envs, value);
env_put(*envs);
}
- array_append(&keys, &key, 1);
+ array_push_back(&keys, &key);
}
array_append_zero(&keys);
/* Compose argv */
t_array_init(&exec_args, 16);
- array_append(&exec_args, &bin_path, 1);
+ array_push_back(&exec_args, &bin_path);
if (args != NULL) {
for(; *args != NULL; args++)
- array_append(&exec_args, args, 1);
+ array_push_back(&exec_args, args);
}
(void) array_append_space(&exec_args);
for (i = 0; i < count; i++) T_BEGIN {
new_set = p_malloc(ctx->set_pool, info.struct_size);
- array_append(arr, &new_set, 1);
+ array_push_back(arr, &new_set);
if (link->change_struct != NULL) {
i_assert(carr != NULL);
new_changes = p_malloc(ctx->set_pool, info.struct_size);
- array_append(carr, &new_changes, 1);
+ array_push_back(carr, &new_changes);
}
keyp = CONST_PTR_OFFSET(children[i], info.type_offset);
in environ[] */
i_array_init(&sorted_envs_arr, 128);
for (i = 0; environ[i] != NULL; i++)
- array_append(&sorted_envs_arr, &environ[i], 1);
+ array_push_back(&sorted_envs_arr, &environ[i]);
array_sort(&sorted_envs_arr, environ_cmp);
sorted_envs = array_get(&sorted_envs_arr, &count);
continue;
}
dup = keep_values ? strings[i] : p_strdup(pool, strings[i]);
- array_append(dest_arr, &dup, 1);
+ array_push_back(dest_arr, &dup);
dup = keep_values ? strings[i+1] : p_strdup(pool, strings[i+1]);
- array_append(dest_arr, &dup, 1);
+ array_push_back(dest_arr, &dup);
}
break;
}
child_set = settings_dup_full(def->list_info,
children[i], pool,
keep_values);
- array_append(dest_arr, &child_set, 1);
+ array_push_back(dest_arr, &child_set);
settings_set_parent(def->list_info, child_set,
dest_set);
}
child_set = settings_changes_dup(def->list_info,
children[i],
pool);
- array_append(dest_arr, &child_set, 1);
+ array_push_back(dest_arr, &child_set);
}
break;
}
t_array_init(&defines, 128);
/* add existing defines */
for (j = 0; parent->defines[j].key != NULL; j++)
- array_append(&defines, &parent->defines[j], 1);
+ array_push_back(&defines, &parent->defines[j]);
new_struct_size = MEM_ALIGN(parent->struct_size);
/* add new dynamic defines */
for (j = 0; cur_defines[j].key != NULL; j++) {
new_define = cur_defines[j];
new_define.offset += new_struct_size;
- array_append(&defines, &new_define, 1);
+ array_push_back(&defines, &new_define);
}
new_struct_size += MEM_ALIGN(parsers[i].info->struct_size);
}
t_array_init(&dynamic_parsers, 32);
if (parent->dynamic_parsers != NULL) {
for (i = 0; parent->dynamic_parsers[i].name != NULL; i++) {
- array_append(&dynamic_parsers,
- &parent->dynamic_parsers[i], 1);
+ array_push_back(&dynamic_parsers,
+ &parent->dynamic_parsers[i]);
}
}
offset = MEM_ALIGN(parent->struct_size);
new_parser = parsers[i];
new_parser.name = p_strdup(pool, new_parser.name);
new_parser.struct_offset = offset;
- array_append(&dynamic_parsers, &new_parser, 1);
+ array_push_back(&dynamic_parsers, &new_parser);
offset += MEM_ALIGN(parsers[i].info->struct_size);
}
parent->dynamic_parsers =
for (i = 0; i < count; i++) {
set = settings_changes_init(def->list_info,
children[i], pool);
- array_append(dest_arr, &set, 1);
+ array_push_back(dest_arr, &set);
}
}
}
p_array_init(dest_arr, pool, count);
for (i = 0; i < count; i++) {
child_set = settings_dup(def->list_info, children[i], pool);
- array_append(dest_arr, &child_set, 1);
+ array_push_back(dest_arr, &child_set);
settings_set_parent(def->list_info, child_set,
dest_link->set_struct);
}
for (i = 0; i < count; i++) {
child_set = settings_changes_init(def->list_info,
children[i], pool);
- array_append(dest_arr, &child_set, 1);
+ array_push_back(dest_arr, &child_set);
}
}
/* append */
child_set = settings_dup(def->list_info,
src_children[i], pool);
- array_append(dest_arr, &child_set, 1);
+ array_push_back(dest_arr, &child_set);
settings_set_parent(def->list_info, child_set,
dest_link->set_struct);
child_set = settings_changes_init(def->list_info,
src_cchildren[i],
pool);
- array_append(dest_carr, &child_set, 1);
+ array_push_back(dest_carr, &child_set);
}
}
return 0;
t_array_init(&cmds_arr, cmds_list_count);
for (cmd = cmds_list; cmd != NULL; cmd = cmd->next) {
smtp_client_command_ref(cmd);
- array_append(&cmds_arr, &cmd, 1);
+ array_push_back(&cmds_arr, &cmd);
}
cmds = array_get_modifiable(&cmds_arr, &count);
t_array_init(&cmds_arr, cmds_list_count);
for (cmd = cmds_list; cmd != NULL; cmd = cmd->next) {
smtp_client_command_ref(cmd);
- array_append(&cmds_arr, &cmd, 1);
+ array_push_back(&cmds_arr, &cmd);
}
cmds = array_get_modifiable(&cmds_arr, &count);
str_array_length(set->mail_param_extensions) + 8);
for (extp = set->mail_param_extensions; *extp != NULL; extp++) {
const char *ext = p_strdup(pool, *extp);
- array_append(&conn->mail_param_extensions, &ext, 1);
+ array_push_back(&conn->mail_param_extensions, &ext);
}
array_append_zero(&conn->mail_param_extensions);
}
str_array_length(set->rcpt_param_extensions) + 8);
for (extp = set->rcpt_param_extensions; *extp != NULL; extp++) {
const char *ext = p_strdup(pool, *extp);
- array_append(&conn->rcpt_param_extensions, &ext, 1);
+ array_push_back(&conn->rcpt_param_extensions, &ext);
}
array_append_zero(&conn->rcpt_param_extensions);
}
i_assert(sendmail_args[0] != NULL);
sendmail_bin = sendmail_args[0];
for (i = 1; sendmail_args[i] != NULL; i++)
- array_append(&args, &sendmail_args[i], 1);
+ array_push_back(&args, &sendmail_args[i]);
- str = "-i"; array_append(&args, &str, 1); /* ignore dots */
- str = "-f"; array_append(&args, &str, 1);
+ str = "-i"; array_push_back(&args, &str); /* ignore dots */
+ str = "-f"; array_push_back(&args, &str);
str = !smtp_address_isnull(subm->mail_from) ?
smtp_address_encode(subm->mail_from) : "<>";
- array_append(&args, &str, 1);
+ array_push_back(&args, &str);
- str = "--"; array_append(&args, &str, 1);
+ str = "--"; array_push_back(&args, &str);
array_foreach(&subm->rcpt_to, rcptp) {
const char *rcpt = smtp_address_encode(*rcptp);
- array_append(&args, &rcpt, 1);
+ array_push_back(&args, &rcpt);
}
array_append_zero(&args);
}
if (params_r != NULL) {
param = p_strdup_until(parser->pool, pbegin, parser->cur);
- array_append(¶ms, ¶m, 1);
+ array_push_back(¶ms, ¶m);
}
pbegin = parser->cur + 1;
} else if (!smtp_char_is_ehlo_param(*parser->cur)) {
if (params_r != NULL) {
param = p_strdup_until(parser->pool, pbegin, parser->cur);
- array_append(¶ms, ¶m, 1);
+ array_push_back(¶ms, ¶m);
array_append_zero(¶ms);
*params_r = array_first(¶ms);
}
return -1;
}
} else if (strcmp(key, "host") == 0) {
- array_append(&hostnames, &value, 1);
+ array_push_back(&hostnames, &value);
} else {
- array_append(&connect_args, args, 1);
+ array_push_back(&connect_args, args);
}
}
msg.map_uid = rec.map_uid;
msg.offset = rec.rec.offset;
msg.refcount = rec.refcount;
- array_append(recs, &msg, 1);
+ array_push_back(recs, &msg);
}
}
return 0;
ret = mdbox_purge_save_msg(ctx, file, &msgs[i]);
if (ret <= 0)
break;
- array_append(&copied_map_uids, &msgs[i].map_uid, 1);
+ array_push_back(&copied_map_uids, &msgs[i].map_uid);
}
offset = file->input->v_offset;
}
fs_last_error(dest_storage->attachment_fs));
ret = -1;
} else {
- array_append(&dest_file->attachment_paths,
- &dest_relpath, 1);
+ array_push_back(&dest_file->attachment_paths,
+ &dest_relpath);
}
fs_file_deinit(&src_fsfile);
fs_file_deinit(&dest_fsfile);
for (i = 0; i < count; i++) {
const char *path = p_strdup(sfile->attachment_pool,
extrefs[i].path);
- array_append(&sfile->attachment_paths, &path, 1);
+ array_push_back(&sfile->attachment_paths, &path);
}
}
return 0;
if (h1 != NULL) {
for (i = 0; h1[i] != NULL; i++) {
value = p_strdup(pool, h1[i]);
- array_append(&headers, &value, 1);
+ array_push_back(&headers, &value);
}
}
if (h2 != NULL) {
for (i = 0; h2[i] != NULL; i++) {
if (h1 == NULL || !str_array_icase_find(h1, h2[i])) {
value = p_strdup(pool, h2[i]);
- array_append(&headers, &value, 1);
+ array_push_back(&headers, &value);
}
}
}
(parse it even if it's not) */
t_array_init(&hdr_arr, 16);
while (imap_arg_get_astring(hdr_list, &value)) {
- array_append(&hdr_arr, &value, 1);
+ array_push_back(&hdr_arr, &value);
hdr_list++;
}
if (hdr_list->type != IMAP_ARG_EOL)
flags |= imap_parse_system_flag(atom);
else {
/* keyword */
- array_append(&keywords, &atom, 1);
+ array_push_back(&keywords, &atom);
}
}
} else if (strcasecmp(atom, "MODSEQ") == 0 &&
this can be used for "All Mail" mailbox migrations
with dsync */
atom = "$GMailHaveLabels";
- array_append(&keywords, &atom, 1);
+ array_push_back(&keywords, &atom);
}
array_append_zero(&keywords);
mbox->storage->set->pop3_deleted_flag, &pop3_deleted_kw_idx);
t_array_init(&keywords, 1);
- array_append(&keywords, &pop3_deleted_kw_idx, 1);
+ array_push_back(&keywords, &pop3_deleted_kw_idx);
kw = mail_index_keywords_create_from_indexes(mbox->box.index, &keywords);
msgmap = imapc_client_mailbox_get_msgmap(mbox->client_box);
(extref.start_offset - last_voffset);
extref.path = p_strdup(pool, path);
- array_append(extrefs, &extref, 1);
+ array_push_back(extrefs, &extref);
}
return TRUE;
}
str_append(mail->header_data, "\n");
if (!hdr->continues) {
data->parse_line.end_pos = str_len(mail->header_data);
- array_append(&mail->header_lines, &data->parse_line, 1);
+ array_push_back(&mail->header_lines, &data->parse_line);
}
}
value = message_header_strdup(mail->mail.data_pool,
value_start,
value_end - value_start);
- array_append(&header_values, &value, 1);
+ array_push_back(&header_values, &value);
}
}
data + i, len2);
i += len2 + 1;
- array_append(&header_values, &value, 1);
+ array_push_back(&header_values, &value);
}
}
/* merge headers */
t_array_init(&names, 32);
for (i = 0; i < data->wanted_headers->count; i++)
- array_append(&names, &data->wanted_headers->name[i], 1);
+ array_push_back(&names,
+ &data->wanted_headers->name[i]);
for (i = 0; i < headers->count; i++)
- array_append(&names, &headers->name[i], 1);
+ array_push_back(&names, &headers->name[i]);
array_append_zero(&names);
new_wanted_headers =
mailbox_header_lookup_init(_mail->box,
break;
}
if (header != NULL)
- array_append(&headers, &header, 1);
+ array_push_back(&headers, &header);
}
if (wanted_headers != NULL) {
for (i = 0; wanted_headers->name[i] != NULL; i++)
- array_append(&headers, &wanted_headers->name[i], 1);
+ array_push_back(&headers, &wanted_headers->name[i]);
}
if (array_count(&headers) > 0) {
*mail_r = mails[0];
if (--ctx->unused_mail_idx > 0) {
array_delete(&ctx->mails, 0, 1);
- array_append(&ctx->mails, mail_r, 1);
+ array_push_back(&ctx->mails, mail_r);
}
index_mail_update_access_parts_post(*mail_r);
return 1;
field.decision = updates[i].decision;
if (updates[i].last_used != (time_t)-1)
field.last_used = updates[i].last_used;
- array_append(&new_fields, &field, 1);
+ array_push_back(&new_fields, &field);
}
if (array_count(&new_fields) > 0) {
mail_cache_register_fields(box->cache,
/* only child - don't bother setting sort date */
child.uid = thread_lookup_existing(ctx, child.idx);
- array_append(sorted_children, &child, 1);
+ array_push_back(sorted_children, &child);
return;
}
while (child.idx != 0) {
thread_child_node_fill(ctx, &child);
- array_append(sorted_children, &child, 1);
+ array_push_back(sorted_children, &child);
child.idx = shadows[child.idx].next_sibling_idx;
}
break;
}
- array_append(keywords_r,
- (unsigned int *)&idx, 1);
+ array_push_back(keywords_r,
+ (unsigned int *)&idx);
break;
}
filenames within this transaction. */
t_array_init(&files, ctx->files_count);
for (mf = ctx->files; mf != NULL; mf = mf->next)
- array_append(&files, &mf, 1);
+ array_push_back(&files, &mf);
array_sort(&files, maildir_filename_dest_basename_cmp);
new_changed = cur_changed = FALSE;
rec->filename = p_strdup(uidlist->record_pool, line);
hash_table_update(uidlist->files, rec->filename, rec);
- array_append(&uidlist->records, &rec, 1);
+ array_push_back(&uidlist->records, &rec);
return TRUE;
}
syncing it here. ignore this entry. */
seq++;
} else {
- array_append(&new_records, &recs[i], 1);
+ array_push_back(&new_records, &recs[i]);
seq++; i++;
}
}
/* view might not be completely up-to-date, so preserve any
messages left */
for (; i < count; i++)
- array_append(&new_records, &recs[i], 1);
+ array_push_back(&new_records, &recs[i]);
array_free(&uidlist->records);
uidlist->records = new_records;
}
if (i == count)
- array_append(&keyword_list, &idx, 1);
+ array_push_back(&keyword_list, &idx);
}
/* once we know how many keywords there are, we can allocate the array
array_append_array(&keywords_copy, &mail_ctx->mail.keywords);
mail_ctx->mail.keywords = keywords_copy;
}
- array_append(&sync_ctx->mails, &mail_ctx->mail, 1);
+ array_push_back(&sync_ctx->mails, &mail_ctx->mail);
sync_ctx->space_diff += mail_ctx->mail.space;
if (sync_ctx->space_diff < 0) {
}
cline = p_strdup(mbox->uidl_pool, p);
- array_append(&uidls, &cline, 1);
+ array_push_back(&uidls, &cline);
}
i_stream_destroy(&input);
if (line != NULL) {
if (mailbox_list_is_valid_name(_list, test_pattern, &error) &&
mailbox_list_is_valid_name(_list, real_pattern, &error)) {
pattern = p_strdup(ctx->ctx.pool, *patterns);
- array_append(&valid_patterns, &pattern, 1);
+ array_push_back(&valid_patterns, &pattern);
}
}
array_append_zero(&valid_patterns); /* NULL-terminate */
for (; node != NULL; node = node->next) {
if (node->children != NULL)
get_existing_name_ids(ids, node->children);
- array_append(ids, &node->name_id, 1);
+ array_push_back(ids, &node->name_id);
}
}
if (strncmp(info->vname, old_vname, old_vnamelen) == 0 &&
info->vname[old_vnamelen] == old_ns_sep) {
name = p_strdup(pool, info->vname + old_vnamelen);
- array_append(&names_arr, &name, 1);
+ array_push_back(&names_arr, &name);
}
}
if (mailbox_list_iter_deinit(&iter) < 0) {
for (i = j = 0; i < imap_count && j < human_count; ) {
ret = strcmp(imap_args[i].key, human_args[j].key);
if (ret < 0) {
- array_append(©_args, &imap_args[i], 1);
+ array_push_back(©_args, &imap_args[i]);
i++;
} else if (ret > 0) {
j++;
}
}
for (; i < imap_count; i++)
- array_append(©_args, &imap_args[i], 1);
+ array_push_back(©_args, &imap_args[i]);
imap_args = array_get(©_args, &imap_count);
mail_search_register_add(reg, imap_args, imap_count);
if (!str_array_find(plugins, name))
continue;
}
- array_append(&tmp_hooks, module_hook, 1);
+ array_push_back(&tmp_hooks, module_hook);
}
/* next we have to sort them by the modules' priority (based on name) */
p_array_init(&user->hooks, user->pool,
array_count(&tmp_hooks) + array_count(&internal_hooks));
array_foreach(&tmp_hooks, module_hook)
- array_append(&user->hooks, &module_hook->hooks, 1);
+ array_push_back(&user->hooks, &module_hook->hooks);
array_append_array(&user->hooks, &internal_hooks);
}
set->parsed_mail_attachment_exclude_inlined = TRUE;
} else if (str_begins(opt, "content-type=")) {
const char *value = p_strdup(pool, opt+13);
- array_append(&content_types, &value, 1);
+ array_push_back(&content_types, &value);
} else {
*error_r = t_strdup_printf("mail_attachment_detection_options: "
"Unknown option: %s", opt);
}
}
if (have_dict || regs[i].rank == MAIL_ATTRIBUTE_INTERNAL_RANK_AUTHORITY)
- array_append(attrs, &key, 1);
+ array_push_back(attrs, &key);
}
}
strncmp(*attr, MAILBOX_ATTRIBUTE_PREFIX_DOVECOT_PVT_SERVER,
strlen(MAILBOX_ATTRIBUTE_PREFIX_DOVECOT_PVT_SERVER)) == 0)
continue;
- array_append(&intiter->extra_attrs, attr, 1);
+ array_push_back(&intiter->extra_attrs, attr);
}
return &intiter->iter;
}
t_array_init(&valid_keywords, 32);
for (; *keywords != NULL; keywords++) {
if (mailbox_keyword_is_valid(box, *keywords, &error))
- array_append(&valid_keywords, keywords, 1);
+ array_push_back(&valid_keywords, keywords);
}
array_append_zero(&valid_keywords); /* NULL-terminate */
kw = mail_index_keywords_create(box->index, keywords);
/* first put the nodes into an array and sort it */
array_clear(tmparr);
for (node = *nodes; node != NULL; node = node->next)
- array_append(tmparr, &node, 1);
+ array_push_back(tmparr, &node);
array_sort(tmparr, mailbox_node_name_cmp);
/* update the node pointers */
for (file = box->notify_files; file != NULL && !failed; file = file->next) {
switch (io_add_notify(file->path, notify_extract_callback, box, &io)) {
case IO_NOTIFY_ADDED:
- array_append(&temp_ios, &io, 1);
+ array_push_back(&temp_ios, &io);
break;
case IO_NOTIFY_NOTFOUND:
*reason_r = t_strdup_printf(
value = getenv(key);
if (value != NULL) {
value = t_strconcat(key, "=", value, NULL);
- array_append(©, &value, 1);
+ array_push_back(©, &value);
}
}
t_array_init(&categories, int_query->categories_count);
for (i = 0; i < int_query->categories_count; i++) {
- array_append(&categories,
- &int_query->categories[i].name, 1);
+ array_push_back(&categories,
+ &int_query->categories[i].name);
}
for (i = 0; i < N_ELEMENTS(event_filter_log_type_names); i++) {
if ((int_query->log_type_mask & (1 << i)) == 0)
continue;
- array_append(&categories,
- &event_filter_log_type_names[i], 1);
+ array_push_back(&categories,
+ &event_filter_log_type_names[i]);
}
array_append_zero(&categories);
query.categories = array_first(&categories);
}
break;
case EVENT_FILTER_CODE_CATEGORY:
- array_append(&categories, &arg, 1);
+ array_push_back(&categories, &arg);
break;
case EVENT_FILTER_CODE_FIELD: {
struct event_filter_field *field;
Event filtering uses pointer comparisons for efficiency. */
i_assert(event_category_find_registered(category->name) == NULL);
category->registered = TRUE;
- array_append(&event_registered_categories, &category, 1);
+ array_push_back(&event_registered_categories, &category);
array_foreach(&event_category_callbacks, callbackp) T_BEGIN {
(*callbackp)(category);
} T_END;
name = p_strdup(pool, d->d_name);
- array_append(&names, &name, 1);
+ array_push_back(&names, &name);
}
if (errno != 0)
*error_r = i_strdup_printf("readdir(%s) failed: %m", dir);
data = array_get_modifiable(array, &count);
if (count == 0) {
- array_append(array, &value, 1);
+ array_push_back(array, &value);
return FALSE;
}
/* grow last range */
data[count-1].seq2 = seq;
} else {
- array_append(array, &value, 1);
+ array_push_back(array, &value);
}
return FALSE;
}
i_array_init(array, 4);
value.seq1 = min_seq;
value.seq2 = max_seq;
- array_append(array, &value, 1);
+ array_push_back(array, &value);
return;
}
i_assert(range[0].seq1 >= min_seq);
if (min_seq <= max_seq) {
value.seq1 = min_seq;
value.seq2 = max_seq;
- array_append(array, &value, 1);
+ array_push_back(array, &value);
}
}
test_assert(array_is_empty(&foos));
test_assert(!array_not_empty(&foos));
nfoo.a = nfoo.b = nfoo.c = 9;
- array_append(&foos, &nfoo, 1);
+ array_push_back(&foos, &nfoo);
test_assert(array_count(&foos) == 1);
test_assert(!array_is_empty(&foos));
test_assert(array_not_empty(&foos));
t_array_init(&foos, 32);
for (i = 0; i < 10; i++) {
nfoo.a = nfoo.b = nfoo.c = i;
- array_append(&foos, &nfoo, 1);
+ array_push_back(&foos, &nfoo);
}
array_foreach(&foos, foo) {
t_array_init(&foos, 32);
for (i = 0; i < 10; i++) {
foo.a = foo.b = foo.c = i;
- array_append(&foos, &foo, 1);
+ array_push_back(&foos, &foo);
}
i = 0;
for (i = 0; i < 10; i++) {
cstring = t_strdup_printf("x%iy", i);
string = (char *)cstring;
- array_append(&blurbs, &string, 1);
- array_append(&cblurbs, &cstring, 1);
+ array_push_back(&blurbs, &string);
+ array_push_back(&cblurbs, &cstring);
}
i = 0;
t_array_init(&foos[i-1], i);
for (j = 1; j <= 2*i+1; j++) {
nfoo.a = nfoo.b = nfoo.c = j;
- array_append(&foos[i-1], &nfoo, 1);
+ array_push_back(&foos[i - 1], &nfoo);
}
}
for (i = 0; i < 1000; i++)
t_array_init(&arr2, NELEMS);
for (i = 0; i < NELEMS; i++) {
elems[i] = i_rand();
- array_append(&arr2, &elems[i], 1);
+ array_push_back(&arr2, &elems[i]);
}
array_append(&arr1, elems, NELEMS);
test_assert(array_cmp(&arr1, &arr2) == TRUE);
test_assert_idx(array_equal_fn_ctx(&arr1, &arr2, test_compare_ushort_fuzz, &fuzz) == TRUE, i);
}
elems[NELEMS] = 0;
- array_append(&arr2, &elems[NELEMS], 1);
+ array_push_back(&arr2, &elems[NELEMS]);
test_assert(array_cmp(&arr1, &arr2) == FALSE);
test_assert(array_equal_fn(&arr1, &arr2, test_compare_ushort) == FALSE);
test_assert_idx(array_equal_fn_ctx(&arr1, &arr2, test_compare_ushort_fuzz, &fuzz) == FALSE, i);
t_array_init(&arr2, NELEMS);
for (i = 0; i < NELEMS; i++) {
elemstrs[i] = t_strdup_printf("%x", i_rand()); /* never 0-length */
- array_append(&arr2, &elemstrs[i], 1);
+ array_push_back(&arr2, &elemstrs[i]);
}
array_append(&arr1, elemstrs, NELEMS);
test_assert(array_cmp(&arr1, &arr2) == TRUE); /* pointers shared, so identical */
}
input += len;
- array_append(output, &chr, 1);
+ array_push_back(output, &chr);
}
return 0;
}
return -1; /* invalid input */
input += len; size -= len;
- array_append(output, &chr, 1);
+ array_push_back(output, &chr);
}
return 0;
}
if (segment != NULL) {
if (path_r != NULL)
- array_append(&segments, &segment, 1);
+ array_push_back(&segments, &segment);
count++;
}
/* special treatment for a trailing '..' or '.' */
if (segment == NULL) {
segment = "";
- array_append(&segments, &segment, 1);
+ array_push_back(&segments, &segment);
}
array_append_zero(&segments);
*path_r = array_get(&segments, &count);
depth--;
} else if (depth == 0 && *par_end == ';') {
const char *par = str_c(parbuf);
- array_append(¶ms, &par, 1);
+ array_push_back(¶ms, &par);
parbuf = t_str_new(64);
continue;
/* if there is a unescaped : at top level it means
if (str_len(parbuf) > 0) {
const char *par = str_c(parbuf);
- array_append(¶ms, &par, 1);
+ array_push_back(¶ms, &par);
}
if (array_count(¶ms) != 5) {
if (array_count(¶ms) == 4) {
const char *empty = "";
- array_append(¶ms, &empty, 1);
+ array_push_back(¶ms, &empty);
} else {
*error_r = t_strdup_printf("if: requires four or five parameters, got %u",
array_count(¶ms));
return ret;
}
const char *p = str_c(param);
- array_append(¶ms, &p, 1);
+ array_push_back(¶ms, &p);
}
i_assert(array_count(¶ms) == 5);
}
if (i == count) {
char *new_key = i_strdup(key);
- array_append(&global_alt_usernames, &new_key, 1);
+ array_push_back(&global_alt_usernames, &new_key);
}
value = p_strdup(pool, value);
the middle set them as "" */
while (array_count(alt_usernames) < i) {
const char *empty_str = "";
- array_append(alt_usernames, &empty_str, 1);
+ array_push_back(alt_usernames, &empty_str);
}
- array_append(alt_usernames, &value, 1);
+ array_push_back(alt_usernames, &value);
}
static void client_auth_parse_args(struct client *client, bool success,
for (i = 0; i < tmp_ips_count; i++) {
if (skip_nonworking && net_try_bind(&tmp_ips[i]) < 0)
continue;
- array_append(&ips, &tmp_ips[i], 1);
+ array_push_back(&ips, &tmp_ips[i]);
}
}
return array_get(&ips, count_r);
d.fd_src = fd_src;
d.fd_dest = fd_dest;
- array_append(dups, &d, 1);
+ array_push_back(dups, &d);
}
int dup2_array(ARRAY_TYPE(dup2) *dups_arr)
"unix_listener: %s", set->path);
}
if (set->mode != 0)
- array_append(all_listeners, &set->path, 1);
+ array_push_back(all_listeners, &set->path);
}
return TRUE;
}
if (set->port != 0) {
str = t_strdup_printf("%u:%s", set->port, set->address);
- array_append(all_listeners, &str, 1);
+ array_push_back(all_listeners, &str);
}
}
}
service_status_input, service);
}
service_monitor_listen_start(service);
- array_append(&listener_services, &service, 1);
+ array_push_back(&listener_services, &service);
}
/* create processes only after adding all listeners */
if (*right == ':') {
/* non-standard right */
right++;
- array_append(dest, &right, 1);
+ array_push_back(dest, &right);
} else if (is_standard_right(right)) {
- array_append(dest, &right, 1);
+ array_push_back(dest, &right);
} else {
*error_r = t_strdup_printf("Invalid right '%s'",
right);
}
} else {
for (j = 0; all_mailbox_rights[j] != NULL; j++)
- array_append(dest, &all_mailbox_rights[j], 1);
+ array_push_back(dest, &all_mailbox_rights[j]);
}
}
if (array_count(&dest_rights) > 0) {
return NULL;
}
- array_append(&rights, &acl_letter_map[i].name, 1);
+ array_push_back(&rights, &acl_letter_map[i].name);
acl++;
}
while (*acl == ' ' || *acl == '\t') acl++;
names = t_strsplit_spaces(acl + 1, ", \t");
for (; *names != NULL; names++) {
const char *name = p_strdup(pool, *names);
- array_append(&rights, &name, 1);
+ array_push_back(&rights, &name);
}
}
t_array_init(&rights, 64);
if (dest != NULL) {
for (i = 0; dest[i] != NULL; i++)
- array_append(&rights, &dest[i], 1);
+ array_push_back(&rights, &dest[i]);
}
if (src != NULL) {
for (i = 0; src[i] != NULL; i++)
- array_append(&rights, &src[i], 1);
+ array_push_back(&rights, &src[i]);
}
*destp = acl_right_names_alloc(pool, &rights, dup_strings);
break;
}
if (modify_rights[j] == NULL)
- array_append(&rights, &old_rights[i], 1);
+ array_push_back(&rights, &old_rights[i]);
}
new_rights = &null;
modify_rights = array_count(&rights) == 0 ? NULL :
if (ret > 0) {
acllist.name = p_strdup(backend->acllist_pool, name);
- array_append(&backend->acllist, &acllist, 1);
+ array_push_back(&backend->acllist, &acllist);
T_BEGIN {
const char *line;
i_error("ACL file %s line %u: %s",
path, linenum, error);
} else {
- array_append(&aclobj->rights, &rights, 1);
+ array_push_back(&aclobj->rights, &rights);
}
} T_END;
if (ret < 0)
right->vpattern = pright->vpattern;
p_array_init(&right->rights, file->rights_pool, 4);
}
- array_append(&right->rights, &pright->rights, 1);
+ array_push_back(&right->rights, &pright->rights);
}
array_free(&ctx.parse_rights);
str_append_c(id, '/');
str_append(id, ns->owner->username);
id_dup = t_strdup(str_c(id));
- array_append(ids, &id_dup, 1);
+ array_push_back(ids, &id_dup);
}
}
if (acl_object_list_deinit(&iter) < 0) ret = -1;
p = strrchr(key, '/');
if (p != NULL && strcmp(p + 1, username) == 0) {
key = t_strdup_until(key, p);
- array_append(&old_ids_arr, &key, 1);
+ array_push_back(&old_ids_arr, &key);
}
}
if (dict_iterate_deinit(&iter, &error) < 0) {
return;
t_array_init(&hats, 8);
- array_append(&hats, &hat, 1);
+ array_push_back(&hats, &hat);
for(unsigned int i = 2;; i++) {
hat = mail_user_plugin_getenv(user, t_strdup_printf("%s%u",
APPARMOR_PLUGIN_SETTING_HAT_PREFIX, i));
if (hat == NULL) break;
- array_append(&hats, &hat, 1);
+ array_push_back(&hats, &hat);
}
array_append_zero(&hats);
t_array_init(&patterns, 16);
str = doveadm_plugin_getenv("expire");
for (i = 2; str != NULL; i++) {
- array_append(&patterns, &str, 1);
+ array_push_back(&patterns, &str);
if (i_snprintf(set_name, sizeof(set_name), "expire%u", i) < 0)
i_unreached();
t_array_init(&patterns, 16);
str = mail_user_set_plugin_getenv(user->set, "expire");
for (i = 2; str != NULL; i++) {
- array_append(&patterns, &str, 1);
+ array_push_back(&patterns, &str);
if (i_snprintf(set_name, sizeof(set_name), "expire%u", i) < 0)
i_unreached();
return squat_trie_iterate_next(ctx, shifts_r);
}
}
- array_append(&ctx->parents, &ctx->cur, 1);
+ array_push_back(&ctx->parents, &ctx->cur);
ctx->cur.node = &children[ctx->cur.idx-1];
ctx->cur.idx = 0;
if (shift_count != 0)
if (next_seq == new_range.seq2 + 1) {
/* we can continue the previous range */
} else {
- array_append(dest, &new_range, 1);
+ array_push_back(dest, &new_range);
new_range.seq1 = src_range[i].seq1 / 2;
}
new_range.seq2 = src_range[i].seq2 / 2;
}
- array_append(dest, &new_range, 1);
+ array_push_back(dest, &new_range);
return;
}
} else {
new_range.seq1 = last_uid + 1;
new_range.seq2 = (uint32_t)-1;
- array_append(maybe_uids, &new_range, 1);
+ array_push_back(maybe_uids, &new_range);
}
}
i_array_init(&tmp_uids, 128);
for (i = 0; i < count; i++) {
if (range[i].seq1 == range[i].seq2)
- array_append(&tmp_uids, &range[i].seq1, 1);
+ array_push_back(&tmp_uids, &range[i].seq1);
else {
uid1 = range[i].seq1 | UID_LIST_MASK_RANGE;
- array_append(&tmp_uids, &uid1, 1);
- array_append(&tmp_uids, &range[i].seq2, 1);
+ array_push_back(&tmp_uids, &uid1);
+ array_push_back(&tmp_uids, &range[i].seq2);
}
}
ret = squat_uidlist_rebuild_next(ctx, &tmp_uids);
uidlist = array_get_modifiable(uids, &count);
if (count == 0) {
- array_append(uids, &uid, 1);
+ array_push_back(uids, &uid);
return;
}
if (uidlist[count-1] + 1 == uid) {
}
uidlist[count-1] |= UID_LIST_MASK_RANGE;
}
- array_append(uids, &uid, 1);
+ array_push_back(uids, &uid);
}
static void uidlist_array_append_range(ARRAY_TYPE(uint32_t) *uids,
uidlist = array_get_modifiable(uids, &count);
if (count == 0) {
uid1 |= UID_LIST_MASK_RANGE;
- array_append(uids, &uid1, 1);
- array_append(uids, &uid2, 1);
+ array_push_back(uids, &uid1);
+ array_push_back(uids, &uid2);
return;
}
if (uidlist[count-1] + 1 == uid1) {
uidlist[count-1] |= UID_LIST_MASK_RANGE;
} else {
uid1 |= UID_LIST_MASK_RANGE;
- array_append(uids, &uid1, 1);
+ array_push_back(uids, &uid1);
}
- array_append(uids, &uid2, 1);
+ array_push_back(uids, &uid2);
}
static int
range.seq1 = tmp_uids[i] & ~UID_LIST_MASK_RANGE;
range.seq2 = tmp_uids[++i];
}
- array_append(seq_range_arr, &range, 1);
+ array_push_back(seq_range_arr, &range);
}
}
array_free(&tmp_uid_arr);
/* create unwanted sequences list from both sources */
t_array_init(&src_unwanted, 128);
new_range.seq1 = 0; new_range.seq2 = (uint32_t)-1;
- array_append(&src_unwanted, &new_range, 1);
+ array_push_back(&src_unwanted, &new_range);
seq_range_array_remove_seq_range(&src_unwanted, src_maybe);
seq_range_array_remove_seq_range(&src_unwanted, src_definite);
t_array_init(&tokens, 4);
/* first add the word exactly as it without any tokenization */
- array_append(&tokens, &orig_token, 1);
+ array_push_back(&tokens, &orig_token);
/* then add it tokenized, but without filtering */
- array_append(&tokens, &token, 1);
+ array_push_back(&tokens, &token);
/* add the word filtered */
if (filter != NULL) {
ret = fts_filter_filter(filter, &token2, &error);
if (ret > 0) {
token2 = t_strdup(token2);
- array_append(&tokens, &token2, 1);
+ array_push_back(&tokens, &token2);
} else if (ret < 0) {
*error_r = t_strdup_printf("Couldn't filter search token: %s", error);
return -1;
t_array_init(&tmp_mailboxes, mailbox_count);
for (i = 0; i < mailbox_count; i = j) {
array_clear(&tmp_mailboxes);
- array_append(&tmp_mailboxes, &mailboxes[i], 1);
+ array_push_back(&tmp_mailboxes, &mailboxes[i]);
backend = fts_mailbox_backend(mailboxes[i]);
for (j = i + 1; j < mailbox_count; j++) {
if (fts_mailbox_backend(mailboxes[j]) != backend)
break;
- array_append(&tmp_mailboxes, &mailboxes[j], 1);
+ array_push_back(&tmp_mailboxes, &mailboxes[j]);
}
array_append_zero(&tmp_mailboxes);
for (srci = src2i = 0; srci < src_count || src2i < src2_count;) {
if (src2i == src2_count ||
src_map[srci].uid < src2_map[src2i].uid) {
- array_append(dest, &src_map[srci], 1);
+ array_push_back(dest, &src_map[srci]);
srci++;
} else if (srci == src_count ||
src_map[srci].uid > src2_map[src2i].uid) {
- array_append(dest, &src2_map[src2i], 1);
+ array_push_back(dest, &src2_map[src2i]);
src2i++;
} else {
i_assert(src_map[srci].uid == src2_map[src2i].uid);
if (src_map[srci].score > src2_map[src2i].score)
- array_append(dest, &src_map[srci], 1);
+ array_push_back(dest, &src_map[srci]);
else
- array_append(dest, &src2_map[src2i], 1);
+ array_push_back(dest, &src2_map[src2i]);
srci++; src2i++;
}
}
t_array_init(&patterns, 16);
for (i = 2; str != NULL; i++) {
- array_append(&patterns, &str, 1);
+ array_push_back(&patterns, &str);
if (i_snprintf(set_name, sizeof(set_name),
"fts_autoindex_exclude%u", i) < 0)
key = keyvalues[i];
value = "";
}
- array_append(&arr, &key, 1);
- array_append(&arr, &value, 1);
+ array_push_back(&arr, &key);
+ array_push_back(&arr, &value);
}
array_append_zero(&arr);
return array_first(&arr);
for (; *letters != '\0'; letters++) {
for (i = 0; imap_acl_letter_map[i].name != NULL; i++) {
if (imap_acl_letter_map[i].letter == *letters) {
- array_append(&rights,
- &imap_acl_letter_map[i].name, 1);
+ array_push_back(&rights,
+ &imap_acl_letter_map[i].name);
break;
}
}
rights according to RFC 4314 */
switch (*letters) {
case 'c':
- array_append(&rights, &acl_k, 1);
- array_append(&rights, &acl_x, 1);
+ array_push_back(&rights, &acl_k);
+ array_push_back(&rights, &acl_x);
break;
case 'd':
- array_append(&rights, &acl_e, 1);
- array_append(&rights, &acl_t, 1);
+ array_push_back(&rights, &acl_e);
+ array_push_back(&rights, &acl_t);
break;
default:
*client_error_r = t_strdup_printf(
for (i = 0; rights[i] != NULL; i++) {
if (strcmp(rights[i], MAIL_ACL_ADMIN) == 0)
break;
- array_append(&new_rights, &rights[i], 1);
+ array_push_back(&new_rights, &rights[i]);
}
switch (update->modify_mode) {
/* adding initial rights for a user. we need to add
the defaults also. don't worry about duplicates. */
for (; rights[i] != NULL; i++)
- array_append(&new_rights, &rights[i], 1);
+ array_push_back(&new_rights, &rights[i]);
default_rights = acl_object_get_default_rights(aclobj);
for (i = 0; default_rights[i] != NULL; i++)
- array_append(&new_rights, &default_rights[i], 1);
+ array_push_back(&new_rights, &default_rights[i]);
break;
case ACL_MODIFY_MODE_REMOVE:
if (rights[i] == NULL)
/* skip over the ADMIN removal and add the rest */
for (i++; rights[i] != NULL; i++)
- array_append(&new_rights, &rights[i], 1);
+ array_push_back(&new_rights, &rights[i]);
break;
case ACL_MODIFY_MODE_REPLACE:
if (rights[i] != NULL)
return;
/* add the missing ADMIN right */
- array_append(&new_rights, &acl_admin, 1);
+ array_push_back(&new_rights, &acl_admin);
break;
default:
return;
if (ret == 1) {
ARRAY_TYPE(dcrypt_private_key) keys;
t_array_init(&keys, 1);
- array_append(&keys, &key, 1);
+ array_push_back(&keys, &key);
ret = mail_crypt_box_share_private_keys(t, pkey,
dest_username,
&keys, error_r);
BOX_CRYPT_PREFIX PRIVKEYS_PREFIX);
while ((key = mailbox_attribute_iter_next(iter)) != NULL) {
key = p_strdup(pool, key);
- array_append(digests, &key, 1);
+ array_push_back(digests, &key);
}
ret = mailbox_attribute_iter_deinit(&iter);
if (ret < 0)
(void)mailbox_attribute_iter_deinit(&iter);
return -1;
} else if (ret > 0)
- array_append(keys_r, &key, 1);
+ array_push_back(keys_r, &key);
}
ret = mailbox_attribute_iter_deinit(&iter);
ret = -1;
}
else if (!ctx->sync_transaction)
- array_append(&warn_roots, &roots[i], 1);
+ array_push_back(&warn_roots, &roots[i]);
}
/* execute quota warnings after all updates. this makes it
work correctly regardless of whether backend.get_resource()
}
if (dest != NULL) {
- array_append(dest, &bboxes[i], 1);
+ array_push_back(dest, &bboxes[i]);
array_delete(&mbox->backend_boxes, i, 1);
bboxes = array_get_modifiable(&mbox->backend_boxes,
&count);
for (i = 0; i < src_keywords->count; i++) {
kwp = array_idx(status.keywords, src_keywords->idx[i]);
- array_append(&kw_strings, kwp, 1);
+ array_push_back(&kw_strings, kwp);
}
array_append_zero(&kw_strings);
return mailbox_keywords_create_valid(dest_box,
if (i == count || uids[i].real_uid > uid) {
uint32_t zero = 0;
- array_append(virtual_uids_r, &zero, 1);
+ array_push_back(virtual_uids_r, &zero);
} else {
i_assert(uids[i].virtual_uid > 0);
- array_append(virtual_uids_r, &uids[i].virtual_uid, 1);
+ array_push_back(virtual_uids_r, &uids[i].virtual_uid);
i++;
}
}
bboxes = array_get(&mbox->backend_boxes, &count);
for (i = 0; i < count; i++) {
if (!only_with_msgs || array_count(&bboxes[i]->uids) > 0)
- array_append(mailboxes, &bboxes[i]->box, 1);
+ array_push_back(mailboxes, &bboxes[i]->box);
}
}
if (ctx->mbox->uids_mapped) {
rec.rec.real_uid = add_uid;
- array_append(&ctx->all_adds, &rec, 1);
+ array_push_back(&ctx->all_adds, &rec);
}
}
}
a POP3 order defined */
seq = array_count(msgnum_to_seq_map) + 1;
for (; seq <= msgnum; seq++)
- array_append(msgnum_to_seq_map, &seq, 1);
- array_append(msgnum_to_seq_map, &mail->seq, 1);
+ array_push_back(msgnum_to_seq_map, &seq);
+ array_push_back(msgnum_to_seq_map, &mail->seq);
}
static int read_mailbox(struct client *client, uint32_t *failed_uid_r)
if (client->highest_seq < mail->seq)
client->highest_seq = mail->seq;
- array_append(&message_sizes, &size, 1);
+ array_push_back(&message_sizes, &size);
msgnum++;
}
lookups[i].wait_for_next_push = FALSE;
i++;
} else {
- array_append(&callbacks, &lookups[i], 1);
+ array_push_back(&callbacks, &lookups[i]);
array_delete(&queue->sync_lookups, i, 1);
}
}
envname = t_strdup_until(*args+4, p);
if (str_array_find(accepted_envs, envname))
- array_append(&envs, &env, 1);
+ array_push_back(&envs, &env);
args++;
}
if (strcmp(*args, "noreply") == 0) {
case 'e':
envs = t_strsplit_spaces(optarg,", \t");
while (*envs != NULL) {
- array_append(&aenvs, envs, 1);
+ array_push_back(&aenvs, envs);
envs++;
}
break;
binary = t_strconcat(PKG_LIBEXECDIR"/", argv[0], NULL);
i_array_init(&exec_args, argc + 16);
- array_append(&exec_args, &binary, 1);
+ array_push_back(&exec_args, &binary);
for (i = 1; i < argc; i++) {
const char *arg = argv[i];
- array_append(&exec_args, &arg, 1);
+ array_push_back(&exec_args, &arg);
}
master_service_run(master_service, client_connected);
projects / thirdparty / dovecot / core.git / commitdiff
