{
struct auth_request_var_expand_ctx ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.auth_request = auth_request;
ctx.escape_func = escape_func == NULL ? escape_none : escape_func;
return var_expand_with_funcs(dest, str, table,
unsigned int secs;
/* need to do dns lookup for the host */
- memset(&dns_set, 0, sizeof(dns_set));
+ i_zero(&dns_set);
dns_set.dns_client_socket_path = AUTH_DNS_SOCKET_PATH;
dns_set.timeout_msecs = AUTH_DNS_DEFAULT_TIMEOUT_MSECS;
value = auth_fields_find(request->extra_fields, "proxy_timeout");
const char *error;
void **sets;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.module = "auth";
input.service = service;
p_array_init(&conn->set.parsed_passdb_objects, pool, 2);
p_array_init(&conn->set.parsed_userdb_objects, pool, 2);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.conn = conn;
if (!settings_read(config_path, NULL, parse_setting,
parse_section, &ctx, &error))
if (conn->set.uri == NULL)
i_fatal("dict %s: Empty uri setting", config_path);
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.username = "";
dict_set.base_dir = global_auth_settings->base_dir;
if (dict_init(conn->set.uri, &dict_set, &conn->dict, &error) < 0)
struct ldap_field_find_subquery_context ctx;
string_t *tmp_str = t_str_new(64);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
t_array_init(&ctx.attr_names, 8);
ctx.name = named_res->field->name;
if (conn->ld == NULL)
return;
- memset(&timeout, 0, sizeof(timeout));
+ i_zero(&timeout);
ret = ldap_result(conn->ld, LDAP_RES_ANY, 0, &timeout, &msg);
#ifdef OPENLDAP_ASYNC_WORKAROUND
if (ret == 0) {
struct db_ldap_sasl_bind_context context;
int ret;
- memset(&context, 0, sizeof(context));
+ i_zero(&context);
context.authcid = conn->set.dn;
context.passwd = conn->set.dnpass;
context.realm = conn->set.sasl_realm;
if (debug) {
if (gettimeofday(&start, NULL) < 0)
- memset(&start, 0, sizeof(start));
+ i_zero(&start);
}
i_assert(conn->pending_count == 0);
services = read_global_settings();
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
mod_set.debug = global_auth_settings->debug;
{
struct module_dir_load_settings mod_set;
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
mod_set.debug = global_auth_settings->debug;
conv.conv = pam_userpass_conv;
conv.appdata_ptr = &ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.request = request;
ctx.pass = password;
/* [<args>] */
t_array_init(&modules, 4);
- memset(&filter, 0, sizeof(filter));
+ i_zero(&filter);
for (; *args != NULL; args++) {
if (strncmp(*args, "service=", 8) == 0)
filter.service = *args + 8;
ARRAY_TYPE(const_string) service_names;
unsigned int i;
- memset(output_r, 0, sizeof(*output_r));
+ i_zero(output_r);
p_array_init(&matches, pool, 8);
p_array_init(&service_names, pool, 8);
}
}
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.pool = pool_alloconly_create(MEMPOOL_GROWING"config file parser", 1024*256);
ctx.path = path;
ctx.hide_errors = fd == -1;
settings_parser_flags);
}
- memset(&root, 0, sizeof(root));
+ i_zero(&root);
root.path = path;
ctx.cur_input = &root;
ctx.expand_values = expand_values;
struct service_settings *const *services, *service_set;
unsigned int i, count;
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
modules = module_dir_load(CONFIG_MODULE_DIR, NULL, &mod_set);
module_dir_init(modules);
const char *host2;
bool duplicates = FALSE;
- memset(&fmt, 0, sizeof(fmt));
+ i_zero(&fmt);
if (arg != NULL) {
/* host%d, host%2d, host%02d */
p = strchr(arg, '%');
i_set_failure_exit_callback(failure_exit_callback);
}
- memset(&filter, 0, sizeof(filter));
+ i_zero(&filter);
master_service = master_service_init("config", master_service_flags,
&argc, &argv, "adf:hHm:nNpPexS");
orig_config_path = master_service_get_config_path(master_service);
return FALSE;
}
ctx->old->seen_auth_section = TRUE;
- memset(&ctx->old->socket_set, 0, sizeof(ctx->old->socket_set));
+ i_zero(&ctx->old->socket_set);
ctx->old->auth_section++;
if ((strcmp(key, "passdb") == 0 || strcmp(key, "userdb") == 0) &&
config_apply_line(ctx, "group",
t_strdup_printf("%s/group=%s", prefix, set->group), NULL);
}
- memset(&ctx->old->socket_set, 0, sizeof(ctx->old->socket_set));
+ i_zero(&ctx->old->socket_set);
}
bool old_settings_handle(struct config_parser_context *ctx,
}
uri = strlist[i+1];
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.value_type = conn->value_type;
dict_set.username = conn->username;
dict_set.base_dir = dict_settings->base_dir;
NULL));
}
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
args++;
}
- memset(&temp_request, 0, sizeof(temp_request));
+ i_zero(&temp_request);
for (; *args != NULL; args++) {
if (strncmp(*args, "proxy", 5) == 0 &&
((*args)[5] == '=' || (*args)[5] == '\0'))
struct istream *is;
const char *user;
struct ioloop *ioloop,*prev_ioloop = current_ioloop;
- memset(&cctx, 0, sizeof(cctx));
+ i_zero(&cctx);
// create iostream
doveadm_print_ostream = iostream_temp_create("/tmp/doveadm.", 0);
i_error("doveadm client: No command given");
return FALSE;
}
- memset(&cctx, 0, sizeof(cctx));
+ i_zero(&cctx);
cctx.cli = FALSE;
cctx.tcp_server = TRUE;
const char *error;
void *set;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.service = "doveadm";
input.local_ip = conn->local_ip;
pool_t pool;
int ret;
- memset(&service_input, 0, sizeof(service_input));
+ i_zero(&service_input);
service_input.module = "mail";
service_input.service = input->info.service;
service_input.username = input->username;
(void)doveadm_cmd_param_str(cctx, "field", &show_field);
(void)doveadm_cmd_param_bool(cctx, "userdb-only", &userdb_only);
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
if (doveadm_cmd_param_array(cctx, "auth-info", &optval))
for(;*optval != NULL; optval++)
auth_user_info_parse(&input.info, *optval);
base64_resp = t_str_new(128);
base64_encode(str_data(init_resp), str_len(init_resp), base64_resp);
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info.mech = "PLAIN";
info.service = input->info.service;
info.local_ip = input->info.local_ip;
static void authtest_input_init(struct authtest_input *input)
{
- memset(input, 0, sizeof(*input));
+ i_zero(input);
input->info.service = "doveadm";
input->info.debug = doveadm_settings->auth_debug;
}
struct master_auth_request master_auth_req;
buffer_t buf;
- memset(&master_auth_req, 0, sizeof(master_auth_req));
+ i_zero(&master_auth_req);
master_auth_req.tag = 1;
master_auth_req.auth_pid = input->auth_pid;
master_auth_req.auth_id = input->auth_id;
pool_t pool;
int ret;
- memset(&service_input, 0, sizeof(service_input));
+ i_zero(&service_input);
service_input.module = "mail";
service_input.service = input->info.service;
service_input.username = input->username;
for(size_t i=0; par[i].name != NULL; i++) {
struct option longopt;
- memset(&longopt, 0, sizeof(longopt));
+ i_zero(&longopt);
longopt.name = par[i].name;
if (par[i].short_opt != '\0') {
longopt.val = par[i].short_opt;
}
dict_drivers_register_builtin();
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.username = username;
dict_set.base_dir = doveadm_settings->base_dir;
if (dict_init(dict_uri, &dict_set, &dict, &error) < 0) {
bool remote_only_changes;
int ret = 0;
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
if (_ctx->cur_client_ip.family != 0) {
/* include the doveadm client's IP address in the ps output */
set.process_title_prefix = t_strdup_printf(
if (ctx->ssl_ctx != NULL)
return 0;
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.ca_dir = mail_set->ssl_client_ca_dir;
ssl_set.ca_file = mail_set->ssl_client_ca_file;
ssl_set.verify_remote_cert = TRUE;
fs_cmd_help(cmd);
}
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.ca_dir = doveadm_settings->ssl_client_ca_dir;
ssl_set.ca_file = doveadm_settings->ssl_client_ca_file;
ssl_set.verbose = doveadm_debug;
- memset(&fs_set, 0, sizeof(fs_set));
+ i_zero(&fs_set);
fs_set.ssl_client_set = &ssl_set;
fs_set.temp_dir = "/tmp";
fs_set.base_dir = doveadm_settings->base_dir;
const char *fname, *const *fnamep;
int ret;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.fs = fs;
ctx.path_prefix = path_prefix;
ctx.files_count = I_MAX(async_count, 1);
fs = cmd_fs_init(&argc, &argv, 0, cmd_fs_delete);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.fs = fs;
ctx.path_prefix = "";
ctx.files_count = I_MAX(async_count, 1);
struct kick_pid *k_pid;
struct kick_user new_user, *user;
- memset(&new_user, 0, sizeof(new_user));
+ i_zero(&new_user);
k_pid = hash_table_lookup(ctx->pids, POINTER_CAST(line->pid));
if (k_pid == NULL) {
const char *const *masks;
struct kick_context ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
if (!doveadm_cmd_param_str(cctx, "socket-path", &(ctx.who.anvil_path)))
ctx.who.anvil_path = t_strconcat(doveadm_settings->base_dir, "/anvil", NULL);
(void)doveadm_cmd_param_bool(cctx, "force", &(ctx.force_kick));
master_service->flags |= MASTER_SERVICE_FLAG_DONT_LOG_TO_STDERR;
master_service_init_log(master_service, "doveadm: ");
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
for (i = 0; i < LAST_LOG_TYPE; i++) {
const char *prefix = failure_log_type_prefixes[i];
struct log_find_context ctx;
unsigned int i;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.pool = pool_alloconly_create("log file", 1024*32);
hash_table_create(&ctx.files, ctx.pool, 0, str_hash, strcmp);
if (cmd_ver2 == NULL)
cmd = doveadm_mail_cmd_find_from_argv(argv[0], &argc, &argv);
else {
- memset(&tmpcmd, 0, sizeof(tmpcmd));
+ i_zero(&tmpcmd);
tmpcmd.usage_args = cmd_ver2->usage;
tmpcmd.name = cmd_ver2->name;
tmpcmd.alloc = cmd_ver2->mail_cmd;
struct fetch_field hdr_field, body_field;
struct imap_msgpart *msgpart;
- memset(&hdr_field, 0, sizeof(hdr_field));
+ i_zero(&hdr_field);
hdr_field.print = fetch_hdr_field;
- memset(&body_field, 0, sizeof(body_field));
+ i_zero(&body_field);
body_field.print = fetch_body_field;
t_array_init(&ctx->fields, 32);
const char *error;
/* create a user for accessing the source storage */
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = "mail";
input.username = ctx->src_username != NULL ?
ctx->src_username :
const struct mailbox_info *info;
int ret = 0;
- memset(&ctx->total_status, 0, sizeof(ctx->total_status));
- memset(&ctx->total_metadata, 0, sizeof(ctx->total_metadata));
+ i_zero(&ctx->total_status);
+ i_zero(&ctx->total_metadata);
iter = doveadm_mailbox_list_iter_init(_ctx, user, ctx->search_args,
iter_flags);
/* make sure we have an auth connection */
mail_storage_service_init_settings(ctx->storage_service, input);
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info.service = master_service_get_name(master_service);
info.local_ip = input->local_ip;
info.remote_ip = input->remote_ip;
doveadm_cctx_to_storage_service_input(const struct doveadm_cmd_context *cctx,
struct mail_storage_service_input *input_r)
{
- memset(input_r, 0, sizeof(*input_r));
+ i_zero(input_r);
input_r->service = "doveadm";
input_r->remote_ip = cctx->remote_ip;
input_r->remote_port = cctx->remote_port;
ctx->cli = TRUE;
ctx->cur_username = getenv("USER");
- memset(&cctx, 0, sizeof(cctx));
+ i_zero(&cctx);
getopt_args = "AF:S:u:";
/* keep context's getopt_args first in case it contains '+' */
for (i = 0; i < N_ELEMENTS(mail_commands_ver2); i++)
doveadm_cmd_register_ver2(mail_commands_ver2[i]);
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
mod_set.debug = doveadm_debug;
const char *last_penalty_str = args[2];
const char *last_update_str = args[3];
- memset(line_r, 0, sizeof(*line_r));
+ i_zero(line_r);
(void)net_addr2ip(ident, &line_r->ip);
if (str_to_uint(penalty_str, &line_r->penalty) < 0 ||
struct penalty_context ctx;
const char *netmask;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
if (!doveadm_cmd_param_str(cctx, "socket-path", &(ctx.anvil_path)))
ctx.anvil_path = t_strconcat(doveadm_settings->base_dir, "/anvil", NULL);
static void doveadm_print_formatted_init(void)
{
- memset(&ctx,0,sizeof(ctx));
+ i_zero(&ctx);
ctx.pool = pool_alloconly_create("doveadm formatted print", 1024);
ctx.buf = str_new(ctx.pool, 256);
p_array_init(&ctx.headers, ctx.pool, 8);
doveadm_print_formatted_header(const struct doveadm_print_header *hdr)
{
struct var_expand_table entry;
- memset(&entry, 0, sizeof(entry));
+ i_zero(&entry);
entry.key = '\0';
entry.long_key = p_strdup(ctx.pool, hdr->key);
entry.value = NULL;
static void doveadm_print_json_init(void)
{
- memset(&ctx,0,sizeof(ctx));
+ i_zero(&ctx);
ctx.pool = pool_alloconly_create("doveadm json print", 1024);
ctx.str = str_new(ctx.pool, 256);
p_array_init(&ctx.headers, ctx.pool, 1);
i_assert(title != NULL);
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.key = key;
hdr.title = title;
hdr.flags = flags;
random_init();
password_schemes_init();
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
mod_set.ignore_dlopen_errors = TRUE;
{
struct top_context ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.path = path;
ctx.fd = doveadm_connect(path);
ctx.prev_pool = pool_alloconly_create("stats top", 1024*16);
/* some doveadm plugins have dependencies to mail plugins. we can load
only those whose dependencies have been loaded earlier, the rest are
ignored. */
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
mod_set.debug = doveadm_debug;
const char *refcount_str = args[2];
const char *p, *ip_str;
- memset(line_r, 0, sizeof(*line_r));
+ i_zero(line_r);
/* ident = service/ip/username (imap, pop3)
or service/username (lmtp) */
struct who_context ctx;
bool separate_connections = FALSE;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
if (!doveadm_cmd_param_str(cctx, "socket-path", &(ctx.anvil_path)))
ctx.anvil_path = t_strconcat(doveadm_settings->base_dir, "/anvil", NULL);
(void)doveadm_cmd_param_bool(cctx, "separate-connections", &separate_connections);
i_info("Connected to %s port %u. Ctrl-D starts compression",
net_ip2addr(&ips[0]), port);
- memset(&client, 0, sizeof(client));
+ i_zero(&client);
client.fd = fd;
client.input = i_stream_create_fd(fd, (size_t)-1);
client.output = o_stream_create_fd(fd, 0);
const struct doveadm_settings *set;
const char *error;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.module = "doveadm";
input.service = "doveadm";
bool quick_init = FALSE;
int c;
- memset(&cctx,0,sizeof(cctx));
+ i_zero(&cctx);
cctx.cli = TRUE;
i_set_failure_exit_callback(failure_exit_callback);
const char *errstr;
int ret;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
memcpy(update.mailbox_guid, mailbox_guid, sizeof(update.mailbox_guid));
update.uid_validity = uid_validity;
guid_128_to_string(metadata.guid),
guid_128_to_string(mailbox_guid));
}
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
memcpy(update.mailbox_guid, mailbox_guid,
sizeof(update.mailbox_guid));
if (mailbox_update(box, &update) < 0) {
dsync_mailbox_cache_field_dup(&brain->local_dsync_box.cache_fields,
&local_dsync_box->cache_fields,
brain->dsync_box_pool);
- memset(&brain->remote_dsync_box, 0, sizeof(brain->remote_dsync_box));
+ i_zero(&brain->remote_dsync_box);
state = dsync_mailbox_state_find(brain, local_dsync_box->mailbox_guid);
if (state != NULL)
brain->mailbox_state = *state;
else {
- memset(&brain->mailbox_state, 0, sizeof(brain->mailbox_state));
+ i_zero(&brain->mailbox_state);
memcpy(brain->mailbox_state.mailbox_guid,
local_dsync_box->mailbox_guid,
sizeof(brain->mailbox_state.mailbox_guid));
i_assert(status.uidvalidity != 0 || status.messages == 0);
- memset(dsync_box_r, 0, sizeof(*dsync_box_r));
+ i_zero(dsync_box_r);
memcpy(dsync_box_r->mailbox_guid, metadata.guid,
sizeof(dsync_box_r->mailbox_guid));
dsync_box_r->uid_validity = status.uidvalidity;
bool ret = TRUE;
*reason_r = NULL;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
if (local_box->uid_validity != remote_box->uid_validity) {
/* Keep the UIDVALIDITY for the mailbox that has more
brain->master_brain ? 'M' : 'S',
guid_128_to_string(dsync_box->mailbox_guid));
}
- memset(&delete_box, 0, sizeof(delete_box));
+ i_zero(&delete_box);
memcpy(delete_box.mailbox_guid, dsync_box->mailbox_guid,
sizeof(delete_box.mailbox_guid));
t_array_init(&delete_box.cache_fields, 0);
return;
/* finished with this mailbox */
- memset(&state, 0, sizeof(state));
+ i_zero(&state);
memcpy(state.mailbox_guid, brain->local_dsync_box.mailbox_guid,
sizeof(state.mailbox_guid));
state.last_uidvalidity = brain->local_dsync_box.uid_validity;
}
dsync_brain_mailbox_trees_init(brain);
- memset(&ibc_set, 0, sizeof(ibc_set));
+ i_zero(&ibc_set);
ibc_set.hostname = my_hostdomain();
ibc_set.sync_ns_prefixes = sync_ns_str == NULL ?
NULL : str_c(sync_ns_str);
brain->verbose_proctitle = FALSE;
}
- memset(&ibc_set, 0, sizeof(ibc_set));
+ i_zero(&ibc_set);
ibc_set.hdr_hash_v2 = TRUE;
ibc_set.hostname = my_hostdomain();
dsync_ibc_send_handshake(ibc, &ibc_set);
const char *value;
enum dsync_ibc_recv_ret ret;
- memset(state_r, 0, sizeof(*state_r));
+ i_zero(state_r);
ret = dsync_ibc_stream_input_next(ibc, ITEM_MAILBOX_STATE, &decoder);
if (ret != DSYNC_IBC_RECV_RET_OK)
return -1;
}
- memset(&field, 0, sizeof(field));
+ i_zero(&field);
value = dsync_deserializer_decode_get(decoder, "name");
field.name = p_strdup(ibc->ret_pool, value);
input = i_stream_create_lf(hdr_input);
md5_init(&md5_ctx);
- memset(&hash_ctx, 0, sizeof(hash_ctx));
+ i_zero(&hash_ctx);
while ((sret = i_stream_read_more(input, &data, &size)) > 0) {
message_header_hash_more(&hash_ctx, &hash_method_md5, &md5_ctx,
version, data, size);
{
const char *guid;
- memset(dmail_r, 0, sizeof(*dmail_r));
+ i_zero(dmail_r);
if (mail_get_special(mail, MAIL_FETCH_GUID, &guid) < 0) {
*error_field_r = "GUID";
return -1;
if (ret == 0) {
/* the message was expunged during export */
- memset(change, 0, sizeof(*change));
+ i_zero(change);
change->type = DSYNC_MAIL_CHANGE_TYPE_EXPUNGE;
change->uid = mail->uid;
}
attr = &exporter->attr;
- memset(attr, 0, sizeof(*attr));
+ i_zero(attr);
attr->type = exporter->attr_type;
attr->value = p_strdup(exporter->pool, value.value);
attr->value_stream = value.value_stream;
return them */
guids = array_get(&exporter->expunged_guids, &count);
if (exporter->expunged_guid_idx < count) {
- memset(&exporter->dsync_mail, 0, sizeof(exporter->dsync_mail));
+ i_zero(&exporter->dsync_mail);
exporter->dsync_mail.guid =
guids[exporter->expunged_guid_idx++];
*mail_r = &exporter->dsync_mail;
if (ignore)
return 0;
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
value.value = attr->value;
value.value_stream = attr->value_stream;
value.last_change = attr->last_change;
int diff;
bool remote_saved;
- memset(&m1, 0, sizeof(m1));
+ i_zero(&m1);
if (importer->cur_mail != NULL) {
m1.guid = importer->mails_have_guids ?
importer->cur_guid : importer->cur_hdr_hash;
m1.uid = importer->cur_mail->uid;
}
- memset(&m2, 0, sizeof(m2));
+ i_zero(&m2);
if (save_change != NULL) {
m2.guid = importer->mails_have_guids ?
save_change->guid : save_change->hdr_hash;
if (ret == 0) {
/* update mailbox metadata if we successfully saved
everything. */
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
update.min_next_uid = importer->remote_uid_next;
update.min_first_recent_uid =
I_MIN(importer->last_common_uid+1,
const char *change_vname;
int ret = 0;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
guid_128_generate(update.mailbox_guid);
/* just in case the duplication exists in both sides,
} else if (type == DSYNC_MAIL_CHANGE_TYPE_EXPUNGE) {
/* expunge overrides flag changes */
orig_guid = change->guid;
- memset(change, 0, sizeof(*change));
+ i_zero(change);
change->type = type;
change->uid = uid;
change->guid = orig_guid;
}
}
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.module = "doveadm";
input.service = "doveadm";
in_port_t port;
void *set;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.service = "doveadm";
if (conn->server->ssl_ctx == NULL)
return 0;
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.verify_remote_cert = TRUE;
ssl_set.verbose_invalid_cert = TRUE;
const char *key, *value;
unsigned int peer_dev_major = 0, peer_dev_minor = 0;
- memset(state_r, 0, sizeof(*state_r));
+ i_zero(state_r);
if (args[0] == NULL) {
*error_r = "Missing username in input";
return -1;
*/
referral = t_str_new(128);
- memset(&url, 0, sizeof(url));
+ i_zero(&url);
url.userid = reply->destuser;
url.auth_type = client->auth_mech_name;
url.host.name = reply->host;
}
i_assert(client->common.proxy_sasl_client == NULL);
- memset(&sasl_set, 0, sizeof(sasl_set));
+ i_zero(&sasl_set);
sasl_set.authid = client->common.proxy_master_user != NULL ?
client->common.proxy_master_user : client->common.proxy_user;
sasl_set.authzid = client->common.proxy_user;
}
/* lookup user */
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = "imap-urlauth-worker";
input.service = "imap-urlauth-worker";
input.username = args[0];
return 0;
}
- memset(&config, 0, sizeof(config));
+ i_zero(&config);
config.url_host = set->imap_urlauth_host;
config.url_port = set->imap_urlauth_port;
config.access_user = client->access_user;
const char *auth_socket_path = "auth-master";
int c;
- memset(&login_set, 0, sizeof(login_set));
+ i_zero(&login_set);
login_set.postlogin_timeout_secs = MASTER_POSTLOGIN_TIMEOUT_DEFAULT;
if (IS_STANDALONE() && getuid() == 0 &&
}
master_service_init_log(master_service, "imap-urlauth: ");
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.module = "imap-urlauth";
input.service = "imap-urlauth";
{
struct imap_fetch_init_context init_ctx;
- memset(&init_ctx, 0, sizeof(init_ctx));
+ i_zero(&init_ctx);
init_ctx.fetch_ctx = ctx;
init_ctx.pool = ctx->ctx_pool;
init_ctx.name = name;
}
if (send_vanished) {
- memset(&qresync_args, 0, sizeof(qresync_args));
+ i_zero(&qresync_args);
if (imap_fetch_send_vanished(client, client->mailbox,
search_args, &qresync_args) < 0) {
mail_search_args_unref(&search_args);
mailbox_equals(cmd->client->mailbox, info->ns, info->vname))
return;
- memset(&items, 0, sizeof(items));
- memset(&result, 0, sizeof(result));
+ i_zero(&items);
+ i_zero(&result);
items.status = STATUS_UIDVALIDITY | STATUS_UIDNEXT |
STATUS_MESSAGES | STATUS_UNSEEN;
search_args->args->value.seqset = ctx->qresync_known_uids;
imap_search_add_changed_since(search_args, ctx->qresync_modseq);
- memset(&qresync_args, 0, sizeof(qresync_args));
+ i_zero(&qresync_args);
qresync_args.qresync_sample_seqset = &ctx->qresync_sample_seqset;
qresync_args.qresync_sample_uidset = &ctx->qresync_sample_uidset;
return 1;
}
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
value.value_stream = ctx->input;
if (imap_metadata_set(ctx->trans, ctx->entry_name, &value) < 0) {
/* delay reporting the failure so we'll finish
/* we have the value already */
if (ctx->failed)
return 1;
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
value.value = imap_arg_as_nstring(entry_value);
ret = imap_metadata_set(ctx->trans, entry_name, &value);
if (ret < 0) {
if (ret <= 0)
return ret < 0;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.cmd = cmd;
if (!store_parse_args(&ctx, ++args)) {
mail_search_args_unref(&search_args);
{
struct imap_urlauth_config config;
- memset(&config, 0, sizeof(config));
+ i_zero(&config);
config.url_host = client->set->imap_urlauth_host;
config.url_port = client->set->imap_urlauth_port;
config.socket_path = t_strconcat(client->user->set->base_dir,
void msgset_generator_init(struct msgset_generator_context *ctx, string_t *str)
{
- memset(ctx, 0, sizeof(*ctx));
+ i_zero(ctx);
ctx->str = str;
ctx->last_uid = (uint32_t)-1;
}
{
struct command cmd;
- memset(&cmd, 0, sizeof(cmd));
+ i_zero(&cmd);
cmd.name = name;
cmd.func = func;
cmd.flags = flags;
{
struct imap_fetch_init_context init_ctx;
- memset(&init_ctx, 0, sizeof(init_ctx));
+ i_zero(&init_ctx);
init_ctx.fetch_ctx = ctx;
init_ctx.pool = ctx->ctx_pool;
struct imap_fetch_init_context init_ctx;
const char *str;
- memset(&init_ctx, 0, sizeof(init_ctx));
+ i_zero(&init_ctx);
init_ctx.fetch_ctx = imap_fetch_alloc(client, pool);
init_ctx.pool = pool;
init_ctx.args = list;
}
}
- memset(&h, 0, sizeof(h));
+ i_zero(&h);
h.handler = handler;
h.context = context;
h.buffered = (flags & IMAP_FETCH_HANDLER_FLAG_BUFFERED) != 0;
i_assert(!ctx->state.fetching);
imap_fetch_init(ctx);
- memset(&ctx->state, 0, sizeof(ctx->state));
+ i_zero(&ctx->state);
if (array_count(&ctx->all_headers) > 0 &&
((ctx->fetch_data & (MAIL_FETCH_STREAM_HEADER |
const char *key, *value;
unsigned int peer_dev_major = 0, peer_dev_minor = 0;
- memset(input_r, 0, sizeof(*input_r));
- memset(master_input_r, 0, sizeof(*master_input_r));
+ i_zero(input_r);
+ i_zero(master_input_r);
master_input_r->client_input = buffer_create_dynamic(pool, 64);
master_input_r->client_output = buffer_create_dynamic(pool, 16);
master_input_r->state = buffer_create_dynamic(pool, 512);
enum mail_error error;
int ret = 1;
- memset(&items, 0, sizeof(items));
+ i_zero(&items);
if ((client->enabled_features & MAILBOX_FEATURE_CONDSTORE) != 0)
items.status |= STATUS_HIGHESTMODSEQ;
{
const unsigned char *p = data, *end = data + size;
- memset(state_r, 0, sizeof(*state_r));
+ i_zero(state_r);
t_array_init(&state_r->recent_uids, 8);
/* vname */
return -1;
}
- memset(items_r, 0, sizeof(*items_r));
+ i_zero(items_r);
for (; !IMAP_ARG_IS_EOL(args); args++) {
if (!imap_arg_get_atom(args, &item)) {
/* list may contain only atoms */
i_assert(len > 0);
- memset(input_r, 0, sizeof(*input_r));
+ i_zero(input_r);
if (data[0] == '1')
input_r->send_untagged_capability = TRUE;
i_panic("Couldn't add client input to stream");
} else {
/* IMAPLOGINTAG environment is compatible with mailfront */
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.tag = getenv("IMAPLOGINTAG");
}
struct mail_storage_service_input input;
const char *value, *error, *input_base64;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = input.service = "imap";
input.username = username != NULL ? username : getenv("USER");
if (input.username == NULL && IS_STANDALONE())
enum mail_auth_request_flags flags;
const char *error;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = input.service = "imap";
input.local_ip = login_client->auth_req.local_ip;
input.remote_ip = login_client->auth_req.remote_ip;
const char *username = NULL, *auth_socket_path = "auth-master";
int c;
- memset(&login_set, 0, sizeof(login_set));
+ i_zero(&login_set);
login_set.postlogin_timeout_secs = MASTER_POSTLOGIN_TIMEOUT_DEFAULT;
login_set.request_auth_token = TRUE;
struct master_service_settings_input input;
struct master_service_settings_output output;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = "mail";
input.service = "indexer-worker";
(void)master_service_settings_read(master_service,
return -1;
}
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = "mail";
input.service = "indexer-worker";
input.username = args[0];
MASTER_SERVICE_FLAG_NO_INIT_DATASTACK_FRAME,
&argc, &argv, "a:d:ef:m:p:r:");
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.session = mail_deliver_session_init();
ctx.pool = ctx.session->pool;
ctx.dest_mailbox_name = "INBOX";
}
master_service_init_finish(master_service);
- memset(&service_input, 0, sizeof(service_input));
+ i_zero(&service_input);
service_input.module = "lda";
service_input.service = "lda";
service_input.username = user;
return 0;
}
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.conn = conn;
ctx.return_value = -1;
ctx.pool = pool;
void auth_user_fields_parse(const char *const *fields, pool_t pool,
struct auth_user_reply *reply_r)
{
- memset(reply_r, 0, sizeof(*reply_r));
+ i_zero(reply_r);
reply_r->uid = (uid_t)-1;
reply_r->gid = (gid_t)-1;
p_array_init(&reply_r->extra_fields, pool, 64);
return 0;
}
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.conn = conn;
ctx.return_value = -1;
ctx.pool = pool;
struct auth_master_cache_ctx ctx;
string_t *str;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.conn = conn;
conn->reply_callback = auth_cache_flush_reply_callback;
return -1;
}
- memset(&mech_desc, 0, sizeof(mech_desc));
+ i_zero(&mech_desc);
mech_desc.name = p_strdup(conn->pool, args[0]);
if (strcmp(mech_desc.name, "PLAIN") == 0)
struct hmac_sha512_ctx ctx;
hmac_sha512_set_key(&ctx, password_len, password);
PBKDF2(&ctx, hmac_sha512_update, hmac_sha512_digest, 64, rounds, salt_len, salt, result_len, buf);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
} else {
*error_r = "Unsupported algorithm";
return -1;
bool dcrypt_openssl_generate_keypair(struct dcrypt_keypair *pair_r, enum dcrypt_key_type kind, unsigned int bits, const char *curve, const char **error_r)
{
EVP_PKEY *pkey = NULL;
- memset(pair_r, 0, sizeof(*pair_r));
+ i_zero(pair_r);
if (kind == DCRYPT_KEY_RSA) {
if (dcrypt_openssl_generate_rsa_key(bits, &pkey, error_r)) {
pair_r->priv = i_new(struct dcrypt_private_key, 1);
const char *implementation = t_strconcat("dcrypt_",backend,NULL);
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
if (module_dir_try_load_missing(&dcrypt_module, set->module_dir,
bool dcrypt_keypair_generate(struct dcrypt_keypair *pair_r, enum dcrypt_key_type kind, unsigned int bits, const char *curve, const char **error_r)
{
i_assert(dcrypt_vfs != NULL);
- memset(pair_r, 0, sizeof(*pair_r));
+ i_zero(pair_r);
return dcrypt_vfs->generate_keypair(pair_r, kind, bits, curve, error_r);
}
test_begin("test_get_info_pw_encrypted");
struct dcrypt_keypair p1;
- memset(&p1, 0, sizeof(p1));
+ i_zero(&p1);
const char *error;
bool ret = dcrypt_keypair_generate(&p1, DCRYPT_KEY_EC, 0, "secp521r1", &error);
test_assert(ret == TRUE);
fs_args = p+1;
}
- memset(&fs_set, 0, sizeof(fs_set));
+ i_zero(&fs_set);
fs_set.username = set->username;
fs_set.base_dir = set->base_dir;
if (fs_init(fs_driver, fs_args, &fs_set, &fs, error_r) < 0)
dict->flag = CDB_WITH_NULL | CDB_WITHOUT_NULL;
/* initialize cdb to 0 (unallocated) */
- memset(&dict->cdb, 0, sizeof(dict->cdb));
+ i_zero(&dict->cdb);
dict->fd = open(dict->path, O_RDONLY);
if (dict->fd == -1) {
struct client_dict *dict = cmd->dict;
struct dict_lookup_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
if (error != NULL) {
result.ret = -1;
result.error = error;
{
struct client_dict_sync_lookup lookup;
- memset(&lookup, 0, sizeof(lookup));
+ i_zero(&lookup);
lookup.ret = -2;
client_dict_lookup_async(_dict, key, client_dict_lookup_callback, &lookup);
const DBT *pkey ATTR_UNUSED,
const DBT *pdata, DBT *skey)
{
- memset(skey, 0, sizeof(*skey));
+ i_zero(skey);
skey->data = pdata->data;
skey->size = pdata->size;
return 0;
uint32_t value;
int ret;
- memset(&pkey, 0, sizeof(pkey));
- memset(&pdata, 0, sizeof(pdata));
+ i_zero(&pkey);
+ i_zero(&pdata);
pkey.data = (char *)key;
pkey.size = strlen(key);
DBT pkey, pdata, skey;
int ret;
- memset(&pkey, 0, sizeof(pkey));
- memset(&pdata, 0, sizeof(pdata));
- memset(&skey, 0, sizeof(skey));
+ i_zero(&pkey);
+ i_zero(&pdata);
+ i_zero(&skey);
if ((ctx->flags & DICT_ITERATE_FLAG_SORT_BY_VALUE) != 0) {
while ((ret = ctx->cursor->c_pget(ctx->cursor, &skey,
struct db_dict *dict = (struct db_dict *)_ctx->dict;
DBT dkey, ddata;
- memset(&dkey, 0, sizeof(dkey));
- memset(&ddata, 0, sizeof(ddata));
+ i_zero(&dkey);
+ i_zero(&ddata);
dkey.data = (char *)key;
dkey.size = strlen(key);
struct db_dict *dict = (struct db_dict *)_ctx->dict;
DBT dkey;
- memset(&dkey, 0, sizeof(dkey));
+ i_zero(&dkey);
dkey.data = (char *)key;
dkey.size = strlen(key);
struct dict_commit_result result;
bool atomic_inc_not_found;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
if (file_dict_write_changes(ctx, &atomic_inc_not_found, &result.error) < 0)
result.ret = DICT_COMMIT_RET_FAILED;
else if (atomic_inc_not_found)
struct dict_commit_result result = { DICT_COMMIT_RET_OK, NULL };
if (_ctx->changed) {
- memset(&commit_ctx, 0, sizeof(commit_ctx));
+ i_zero(&commit_ctx);
commit_ctx.dict = dict;
commit_ctx.memctx = ctx;
commit_ctx.callback = callback;
dict->conn.cmd->data,
dict->conn.cmd->used);
- memset(&dict->conn.reply, 0, sizeof(dict->conn.reply));
+ i_zero(&dict->conn.reply);
io_loop_run(dict->ioloop);
}
timeout_remove(&to);
return "Missing fields for pattern variables";
}
array_append(&ctx->set->maps, &ctx->cur_map, 1);
- memset(&ctx->cur_map, 0, sizeof(ctx->cur_map));
+ i_zero(&ctx->cur_map);
return NULL;
}
if (cache != NULL)
return cache->set;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
pool = pool_alloconly_create("dict sql settings", 1024);
ctx.pool = pool;
ctx.set = p_new(pool, struct dict_sql_settings, 1);
{
struct dict_lookup_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
result.ret = sql_result_next_row(sql_result);
if (result.ret < 0)
result.error = sql_result_get_error(sql_result);
if (sql_lookup_get_query(dict, key, query, &map, &error) < 0) {
struct dict_lookup_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
result.ret = -1;
result.error = error;
callback(&result, context);
{
struct dict_commit_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
if (sql_result->error == NULL)
result.ret = sql_dict_transaction_has_nonexistent(ctx) ?
DICT_COMMIT_RET_NOTFOUND : DICT_COMMIT_RET_OK;
const char *error;
struct dict_commit_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
result.ret = DICT_COMMIT_RET_FAILED;
result.error = t_strdup(ctx->error);
field.map = map;
field.value = value;
- memset(&build, 0, sizeof(build));
+ i_zero(&build);
build.dict = dict;
t_array_init(&build.fields, 1);
array_append(&build.fields, &field, 1);
field.map = map;
field.value = t_strdup_printf("%lld", diff);
- memset(&build, 0, sizeof(build));
+ i_zero(&build);
build.dict = dict;
t_array_init(&build.fields, 1);
array_append(&build.fields, &field, 1);
struct dict_sql_build_query_field *field;
const char *query, *error;
- memset(&build, 0, sizeof(build));
+ i_zero(&build);
build.dict = dict;
t_array_init(&build.fields, 1);
build.extra_values = &values;
if (dict->v.lookup_async == NULL) {
struct dict_lookup_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
result.ret = dict_lookup(dict, pool_datastack_create(),
key, &result.value, &result.error);
callback(&result, context);
*_ctx = NULL;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
ctx->dict->v.transaction_commit(ctx, FALSE,
dict_transaction_commit_sync_callback, &result);
*error_r = t_strdup(result.error);
prefix = argv[1];
uri = argv[2];
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.base_dir = "/var/run/dovecot";
set.username = "testuser";
client->fd = -1;
}
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
result.ret = EAI_FAIL;
result.error = error;
struct dns_lookup_result result;
int ret;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
result.ret = EAI_FAIL;
if ((ret = dns_client_send_request(client, cmd, &result.error)) <= 0) {
struct module_dir_load_settings mod_set;
const struct fs *fs_class;
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.ignore_missing = TRUE;
return -1;
}
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.username = set->username;
dict_set.base_dir = set->base_dir;
{
struct dict_fs_file *file = (struct dict_fs_file *)_file;
- memset(st_r, 0, sizeof(*st_r));
+ i_zero(st_r);
if (fs_dict_lookup(file) < 0)
return -1;
struct posix_fs_lock fs_lock, *ret_lock;
int ret = -1;
- memset(&fs_lock, 0, sizeof(fs_lock));
+ i_zero(&fs_lock);
fs_lock.lock.file = _file;
switch (fs->lock_method) {
#endif
break;
case FS_POSIX_LOCK_METHOD_DOTLOCK:
- memset(&dotlock_set, 0, sizeof(dotlock_set));
+ i_zero(&dotlock_set);
dotlock_set.stale_timeout = FS_POSIX_DOTLOCK_STALE_TIMEOUT_SECS;
dotlock_set.use_excl_lock = TRUE;
dotlock_set.timeout = secs;
struct test_fs *test_fs;
const char *error;
- memset(&fs_set, 0, sizeof(fs_set));
+ i_zero(&fs_set);
if (fs_init(driver, args, &fs_set, &fs, &error) < 0)
i_fatal("fs_init() failed: %s", error);
errno = ENOENT;
return -1;
}
- memset(st_r, 0, sizeof(*st_r));
+ i_zero(st_r);
st_r->st_size = file->contents->used;
return 0;
}
UErrorCode err = U_ZERO_ERROR;
UParseError perr;
ARRAY_TYPE(icu_utf16) id_utf16;
- memset(&perr, 0, sizeof(perr));
+ i_zero(&perr);
t_array_init(&id_utf16, strlen(id));
fts_icu_utf8_to_utf16(&id_utf16, id);
unsigned int count = 0;
int ret;
- memset(¶m, 0, sizeof(param));
+ i_zero(¶m);
while ((ret=http_parse_auth_param
(parser, ¶m.name, ¶m.value)) > 0) {
if (!array_is_created(params))
for (;;) {
struct http_auth_challenge chlng;
- memset(&chlng, 0, sizeof(chlng));
+ i_zero(&chlng);
/* auth-scheme */
if ((ret=http_parse_token(&parser, &chlng.scheme)) <= 0) {
auth-scheme = token
*/
- memset(crdts, 0, sizeof(*crdts));
+ i_zero(crdts);
/* auth-scheme */
if (http_parse_token(&parser, &crdts->scheme) <= 0)
array_foreach(src, sparam) {
struct http_auth_param nparam;
- memset(&nparam, 0, sizeof(nparam));
+ i_zero(&nparam);
nparam.name = p_strdup(pool, sparam->name);
nparam.value = p_strdup(pool, sparam->value);
void http_auth_basic_challenge_init(struct http_auth_challenge *chlng,
const char *realm)
{
- memset(chlng, 0, sizeof(*chlng));
+ i_zero(chlng);
chlng->scheme = "Basic";
if (realm != NULL) {
struct http_auth_param param;
- memset(¶m, 0, sizeof(param));
+ i_zero(¶m);
param.name = "realm";
param.value = t_strdup(realm);
auth = t_strconcat(username, ":", password, NULL);
base64_encode(auth, strlen(auth), data);
- memset(crdts, 0, sizeof(*crdts));
+ i_zero(crdts);
crdts->scheme = "Basic";
crdts->data = str_c(data);
}
i_assert(conn->tunneling);
/* claim connection streams */
- memset(tunnel, 0, sizeof(*tunnel));
+ i_zero(tunnel);
tunnel->input = conn->conn.input;
tunnel->output = conn->conn.output;
tunnel->fd_in = conn->conn.fd_in;
http_client_request_ref(req);
conn->tunneling = TRUE;
- memset(&response, 0, sizeof(response));
+ i_zero(&response);
response.status = 200;
response.reason = "OK";
i_assert(conn->client->ssl_ctx != NULL);
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
if (!conn->client->set.ssl->allow_invalid_cert) {
ssl_set.verbose_invalid_cert = TRUE;
ssl_set.verify_remote_cert = TRUE;
} else if (client->set.dns_client_socket_path != NULL) {
http_client_host_debug(host,
"Performing asynchronous DNS lookup");
- memset(&dns_set, 0, sizeof(dns_set));
+ i_zero(&dns_set);
dns_set.dns_client_socket_path =
client->set.dns_client_socket_path;
if (client->set.connect_timeout_msecs > 0)
/* the IP address may be unassigned in the returned peer address, since
that is only available at this stage when the target URL has an
explicit IP address. */
- memset(addr, 0, sizeof(*addr));
+ i_zero(addr);
if (host_socket != NULL) {
addr->type = HTTP_CLIENT_PEER_ADDR_UNIX;
addr->a.un.path = host_socket;
struct http_date_parser parser;
time_t timestamp;
- memset(&parser, 0, sizeof(parser));
+ i_zero(&parser);
parser.cur = data;
parser.end = data + size;
struct istream *input, const struct http_header_limits *hdr_limits,
uoff_t max_payload_size, bool lenient)
{
- memset(parser, 0, sizeof(*parser));
+ i_zero(parser);
parser->input = input;
i_stream_ref(parser->input);
if (hdr_limits != NULL)
if (parser->msg.pool != NULL)
pool_unref(&parser->msg.pool);
- memset(&parser->msg, 0, sizeof(parser->msg));
+ i_zero(&parser->msg);
if (pool == NULL) {
parser->msg.pool = pool_alloconly_create("http_message", 4096);
} else {
void http_parser_init(struct http_parser *parser,
const unsigned char *data, size_t size)
{
- memset(parser, 0, sizeof(*parser));
+ i_zero(parser);
parser->begin = data;
parser->cur = data;
parser->end = data + size;
hdr_limits = limits->header;
max_payload_size = limits->max_payload_size;
} else {
- memset(&hdr_limits, 0, sizeof(hdr_limits));
+ i_zero(&hdr_limits);
max_payload_size = 0;
}
return -1;
}
- memset(request, 0, sizeof(*request));
+ i_zero(request);
if (http_url_request_target_parse(parser->request_target, hdr->value,
parser->parser.msg.pool, &request->target, &error) < 0) {
parser->state = HTTP_RESPONSE_PARSE_STATE_INIT;
- memset(response, 0, sizeof(*response));
+ i_zero(response);
response->status = parser->response_status;
response->reason = parser->response_reason;
response->version_major = parser->parser.msg.version_major;
http_response_init(struct http_response *resp,
unsigned int status, const char *reason)
{
- memset(resp, 0, sizeof(*resp));
+ i_zero(resp);
resp->version_major = 1;
resp->version_minor = 1;
resp->date = ioloop_time;
/* preserve statistics */
http_server_connection_update_stats(conn);
- memset(&tunnel, 0, sizeof(tunnel));
+ i_zero(&tunnel);
tunnel.input = conn->conn.input;
tunnel.output = conn->conn.output;
tunnel.fd_in = conn->conn.fd_in;
resp = req->response;
i_assert(!resp->submitted);
http_server_response_free(resp);
- memset(resp, 0, sizeof(*resp));
+ i_zero(resp);
}
resp->request = req;
http_server_request_ref(req);
resp->payload_blocking = TRUE;
- memset(&rpay, 0, sizeof(rpay));
+ i_zero(&rpay);
rpay.resp = resp;
if (iov == NULL) {
i_assert(data != NULL);
- memset(&iov, 0, sizeof(iov));
+ i_zero(&iov);
iov.iov_base = data;
iov.iov_len = size;
ret = http_server_response_output_payload(&resp, &iov, 1);
flags may also dictate whether relative URLs are allowed/required. */
i_assert((flags & HTTP_URL_PARSE_SCHEME_EXTERNAL) == 0 || base == NULL);
- memset(&url_parser, 0, sizeof(url_parser));
+ i_zero(&url_parser);
uri_parser_init(&url_parser.parser, pool, url);
url_parser.url = p_new(pool, struct http_url, 1);
struct uri_authority auth;
struct http_url base;
- memset(&url_parser, 0, sizeof(url_parser));
+ i_zero(&url_parser);
parser = &url_parser.parser;
uri_parser_init(parser, pool, host_header);
return 0;
}
- memset(&base, 0, sizeof(base));
+ i_zero(&base);
base.host = auth.host;
base.port = auth.port;
- memset(parser, 0, sizeof(*parser));
+ i_zero(parser);
uri_parser_init(parser, pool, request_target);
url_parser.url = p_new(pool, struct http_url, 1);
void http_url_copy_authority(pool_t pool, struct http_url *dest,
const struct http_url *src)
{
- memset(dest, 0, sizeof(*dest));
+ i_zero(dest);
uri_host_copy(pool, &dest->host, &src->host);
dest->port = src->port;
dest->have_ssl = src->have_ssl;
test_begin(t_strdup_printf("http auth challenges valid [%d]", i));
- memset(&out, 0, sizeof(out));
+ i_zero(&out);
result = (http_auth_parse_challenges
((const unsigned char *)challenges_in, strlen(challenges_in),
&out) > 0);
test_client_defaults(struct http_client_settings *http_set)
{
/* client settings */
- memset(http_set, 0, sizeof(*http_set));
+ i_zero(http_set);
http_set->max_idle_time_msecs = 5*1000;
http_set->max_parallel_connections = 1;
http_set->max_pipelined_requests = 1;
}
/* listen on localhost */
- memset(&bind_ip, 0, sizeof(bind_ip));
+ i_zero(&bind_ip);
bind_ip.family = AF_INET;
bind_ip.u.ip4.s_addr = htonl(INADDR_LOOPBACK);
the binary in all systems (but is in others! so linking
safe-memset.lo directly causes them to fail.) If safe_memset() isn't
included, libssl-iostream plugin loading fails. */
- safe_memset(&dns_set, 0, sizeof(dns_set));
+ i_zero_safe(&dns_set);
dns_set.dns_client_socket_path = "/var/run/dovecot/dns-client";
dns_set.timeout_msecs = 30*1000;
dns_set.idle_timeout_msecs = UINT_MAX;
if (dns_client_connect(dns_client, &error) < 0)
i_fatal("Couldn't initialize DNS client: %s", error);
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.allow_invalid_cert = TRUE;
ssl_set.ca_dir = "/etc/ssl/certs"; /* debian */
ssl_set.ca_file = "/etc/pki/tls/cert.pem"; /* redhat */
- memset(&http_set, 0, sizeof(http_set));
+ i_zero(&http_set);
http_set.ssl = &ssl_set;
http_set.dns_client = dns_client;
http_set.max_idle_time_msecs = 5*1000;
/* download files from blocking server */
/* server settings */
- memset(&http_server_set, 0, sizeof(http_server_set));
+ i_zero(&http_server_set);
http_server_set.max_pipelined_requests = 0;
http_server_set.debug = debug;
http_server_set.request_limits.max_payload_size = (uoff_t)-1;
/* client settings */
- memset(&http_client_set, 0, sizeof(http_client_set));
+ i_zero(&http_client_set);
http_client_set.max_idle_time_msecs = 5*1000;
http_client_set.max_parallel_connections = 1;
http_client_set.max_pipelined_requests = 1;
/* download files from blocking server */
/* server settings */
- memset(&http_server_set, 0, sizeof(http_server_set));
+ i_zero(&http_server_set);
http_server_set.max_pipelined_requests = 4;
http_server_set.debug = debug;
http_server_set.request_limits.max_payload_size = (uoff_t)-1;
/* client settings */
- memset(&http_client_set, 0, sizeof(http_client_set));
+ i_zero(&http_client_set);
http_client_set.max_idle_time_msecs = 5*1000;
http_client_set.max_parallel_connections = 1;
http_client_set.max_pipelined_requests = 8;
/* download files from blocking server */
/* server settings */
- memset(&http_server_set, 0, sizeof(http_server_set));
+ i_zero(&http_server_set);
http_server_set.max_pipelined_requests = 4;
http_server_set.debug = debug;
http_server_set.request_limits.max_payload_size = (uoff_t)-1;
/* client settings */
- memset(&http_client_set, 0, sizeof(http_client_set));
+ i_zero(&http_client_set);
http_client_set.max_idle_time_msecs = 5*1000;
http_client_set.max_parallel_connections = 40;
http_client_set.max_pipelined_requests = 8;
}
/* listen on localhost */
- memset(&bind_ip, 0, sizeof(bind_ip));
+ i_zero(&bind_ip);
bind_ip.family = AF_INET;
bind_ip.u.ip4.s_addr = htonl(INADDR_LOOPBACK);
unsigned int pos, response_text_len;
int ret = 0;
- memset(&response, 0, sizeof(response));
+ i_zero(&response);
test = &valid_response_parse_tests[i];
response_text = test->response;
response_text_len = strlen(response_text);
test_server_defaults(struct http_server_settings *http_set)
{
/* server settings */
- memset(http_set, 0, sizeof(*http_set));
+ i_zero(http_set);
http_set->max_client_idle_time_msecs = 5*1000;
http_set->max_pipelined_requests = 1;
http_set->debug = debug;
}
/* listen on localhost */
- memset(&bind_ip, 0, sizeof(bind_ip));
+ i_zero(&bind_ip);
bind_ip.family = AF_INET;
bind_ip.u.ip4.s_addr = htonl(INADDR_LOOPBACK);
struct client *client;
struct http_request_limits req_limits;
- memset(&req_limits, 0, sizeof(req_limits));
+ i_zero(&req_limits);
req_limits.max_target_length = 4096;
client = i_new(struct client, 1);
client->set.ssl_ca_file = p_strdup(pool, set->ssl_ca_file);
client->set.ssl_verify = set->ssl_verify;
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.ca_dir = set->ssl_ca_dir;
ssl_set.ca_file = set->ssl_ca_file;
ssl_set.verify_remote_cert = set->ssl_verify;
/* abort the commands. we'll do it here later so that if the
callback recurses us back here we don't crash */
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
reply.text_without_resp = reply.text_full =
"Disconnected from server";
switch (state) {
case IMAPC_CONNECTION_STATE_DISCONNECTED:
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
reply.text_full = "Disconnected from server";
if (conn->disconnect_reason != NULL) {
}
i_free_and_null(literal->temp_path);
- memset(literal, 0, sizeof(*literal));
+ i_zero(literal);
literal->fd = -1;
}
return;
}
- memset(&sasl_set, 0, sizeof(sasl_set));
+ i_zero(&sasl_set);
if (set->master_user == NULL)
sasl_set.authid = set->username;
else {
}
imap_args++;
}
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
if (strcasecmp(name, "OK") == 0) {
if (imapc_connection_handle_imap_resp_text(conn, imap_args,
/* continue AUTHENTICATE */
struct imapc_command_reply reply;
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.state = (enum imapc_command_state)IMAPC_COMMAND_STATE_AUTHENTICATE_CONTINUE;
reply.text_full = line;
cmds[0]->callback(&reply, cmds[0]->context);
/* make sure reply texts stays valid if input stream gets freed */
line = t_strdup_noconst(line);
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
linep = strchr(line, ' ');
if (linep == NULL)
return -1;
}
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
if (conn->client->set.ssl_verify) {
ssl_set.verbose_invalid_cert = TRUE;
ssl_set.verify_remote_cert = TRUE;
(long)conn->last_connect);
}
- memset(&dns_set, 0, sizeof(dns_set));
+ i_zero(&dns_set);
dns_set.dns_client_socket_path =
conn->client->set.dns_client_socket_path;
dns_set.timeout_msecs = conn->client->set.connect_timeout_msecs;
return;
}
/* shouldn't normally happen */
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.text_without_resp = reply.text_full = "Mailbox not open";
reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
if ((ret = imapc_command_try_send_stream(conn, cmd)) == 0)
return;
if (ret == -1) {
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.text_without_resp = reply.text_full = "Mailbox not open";
reply.state = IMAPC_COMMAND_STATE_DISCONNECTED;
{
struct mail_attribute_value value;
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
return imap_metadata_set(imtrans, entry, &value);
}
enum mail_attribute_type type;
const char *key;
- memset(value_r, 0, sizeof(*value_r));
+ i_zero(value_r);
if (!imap_metadata_entry2key(imtrans, entry, &type, &key))
return 0;
return mailbox_attribute_get(imtrans->box, type, key, value_r);
enum mail_attribute_type type;
const char *key;
- memset(value_r, 0, sizeof(*value_r));
+ i_zero(value_r);
if (!imap_metadata_entry2key(imtrans, entry, &type, &key))
return 0;
return mailbox_attribute_get_stream(imtrans->box, type, key, value_r);
const char *error;
/* build base url */
- memset(&base_url, 0, sizeof(base_url));
+ i_zero(&base_url);
if (selected_box != NULL) {
mailbox_get_open_status(selected_box, STATUS_UIDVALIDITY,
&box_status);
struct istream *input = NULL;
bool unknown_crlfs = FALSE;
- memset(&hdr_size, 0, sizeof(hdr_size));
- memset(&body_size, 0, sizeof(body_size));
- memset(&part_size, 0, sizeof(part_size));
+ i_zero(&hdr_size);
+ i_zero(&body_size);
+ i_zero(&part_size);
if (*msgpart->section_number != '\0') {
/* find the MIME part */
bool include_hdr, binary, use_partial_cache, have_crlfs;
int ret;
- memset(result_r, 0, sizeof(*result_r));
+ i_zero(result_r);
if ((ret = imap_msgpart_find_part(mail, msgpart, &part)) < 0)
return -1;
random_fill(mailbox_key_r, IMAP_URLAUTH_KEY_LEN);
mailbox_key_hex = binary_to_hex(mailbox_key_r,
IMAP_URLAUTH_KEY_LEN);
- memset(&urlauth_key, 0, sizeof(urlauth_key));
+ i_zero(&urlauth_key);
urlauth_key.value = mailbox_key_hex;
ret = mailbox_attribute_set(t, MAIL_ATTRIBUTE_TYPE_PRIVATE,
IMAP_URLAUTH_KEY, &urlauth_key);
callback = urlreq->callback;
urlreq->callback = NULL;
if (callback != NULL) {
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.url = urlreq->url;
reply.flags = urlreq->flags;
reply.succeeded = FALSE;
i_assert(conn->literal_bytes_left == 0);
/* reply */
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.url = urlreq->url;
reply.flags = urlreq->flags;
reply.bodypartstruct = urlreq->bodypartstruct;
ufetch->pending_requests--;
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.url = url;
reply.flags = url_flags;
reply.succeeded = FALSE;
}
/* if requested, read the message part the URL points to */
- memset(&mpresult, 0, sizeof(mpresult));
+ i_zero(&mpresult);
if (success && ((url_flags & IMAP_URLAUTH_FETCH_FLAG_BODY) != 0 ||
(url_flags & IMAP_URLAUTH_FETCH_FLAG_BINARY) != 0)) {
ret = imap_msgpart_url_read_part(mpurl, &mpresult, &error);
return;
}
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.url = url;
reply.flags = url_flags;
reply.error = errormsg;
ufetch->pending_requests--;
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.url = ufetch->pending_reply.url;
reply.flags = ufetch->pending_reply.flags;
reply.bodypartstruct = ufetch->pending_reply.bodypartstruct;
part_data = part->context;
envelope = part_data->envelope;
- memset(part_data, 0, sizeof(*part_data));
+ i_zero(part_data);
part_data->pool = pool;
part_data->envelope = envelope;
}
if (str == NULL || *str == '\0')
return NULL;
- memset(tm, 0, sizeof(*tm));
+ i_zero(tm);
/* "dd-mon-yyyy [hh:mi:ss +|-zone]"
dd is 1-2 digits and may be prefixed with space or zero. */
utsname_set = TRUE;
if (uname(&utsname_result) < 0) {
i_error("uname() failed: %m");
- memset(&utsname_result, 0, sizeof(utsname_result));
+ i_zero(&utsname_result);
}
}
i_assert((flags & IMAP_URL_PARSE_REQUIRE_RELATIVE) == 0 || base != NULL);
i_assert((flags & IMAP_URL_PARSE_SCHEME_EXTERNAL) == 0 || base == NULL);
- memset(&url_parser, 0, sizeof(url_parser));
+ i_zero(&url_parser);
uri_parser_init(&url_parser.parser, pool_datastack_create(), url);
url_parser.url = t_new(struct imap_url, 1);
cache_view = mail_cache_view_open(cache, view);
output = o_stream_create_fd_file(fd, 0, FALSE);
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.major_version = MAIL_CACHE_MAJOR_VERSION;
hdr.minor_version = MAIL_CACHE_MINOR_VERSION;
hdr.compat_sizeof_uoff_t = sizeof(uoff_t);
hdr.file_seq = get_next_file_seq(cache);
o_stream_nsend(output, &hdr, sizeof(hdr));
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.cache = cache;
ctx.buffer = buffer_create_dynamic(default_pool, 4096);
ctx.field_seen = buffer_create_dynamic(default_pool, 64);
ctx.field_seen_value++;
}
- memset(&cache_rec, 0, sizeof(cache_rec));
+ i_zero(&cache_rec);
buffer_append(ctx.buffer, &cache_rec, sizeof(cache_rec));
mail_cache_lookup_iter_init(cache_view, seq, &iter);
max_drop_time = cache->index->map->hdr.day_stamp == 0 ? 0 :
cache->index->map->hdr.day_stamp - MAIL_CACHE_FIELD_DROP_SECS;
- memset(&field, 0, sizeof(field));
+ i_zero(&field);
for (i = 0; i < field_hdr->fields_count; i++) {
for (p = names; p != end && *p != '\0'; p++) ;
if (p == end || *names == '\0') {
const char *name;
uint32_t i;
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.fields_count = cache->file_fields_count;
for (i = 0; i < cache->fields_count; i++) {
if (CACHE_FIELD_IS_NEWLY_WANTED(cache, i))
if (!view->cache->opened)
(void)mail_cache_open_and_verify(view->cache);
- memset(ctx, 0, sizeof(*ctx));
+ i_zero(ctx);
ctx->view = view;
ctx->seq = seq;
}
ctx->remap_counter = view->cache->remap_counter;
- memset(&view->loop_track, 0, sizeof(view->loop_track));
+ i_zero(&view->loop_track);
}
static bool
ctx->disk_appends_checked = TRUE;
ctx->remap_counter = view->cache->remap_counter;
- memset(&view->loop_track, 0, sizeof(view->loop_track));
+ i_zero(&view->loop_track);
}
if (ctx->stop)
field_state = buffer_get_modifiable_data(buf, NULL);
/* lookup the fields */
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.view = view;
ctx.pool = *pool_r = pool_alloconly_create(MEMPOOL_GROWING"mail cache headers", 1024);
t_array_init(&ctx.lines, 32);
i_array_init(&ctx->cache_data_seq, 64);
}
- memset(&new_rec, 0, sizeof(new_rec));
+ i_zero(&new_rec);
buffer_append(ctx->cache_data, &new_rec, sizeof(new_rec));
ctx->prev_seq = 0;
/* compare index_dir inodes so we don't break even with symlinks.
if index_dir doesn't exist yet or if using in-memory indexes, just
compare mailbox paths */
- memset(&st, 0, sizeof(st));
+ i_zero(&st);
if (index_dir == NULL) {
/* in-memory indexes */
} else if (stat(index_dir, &st) < 0) {
/* add keyword records so we can start appending names directly */
rec_pos = dest->used;
- memset(&new_kw_rec, 0, sizeof(new_kw_rec));
+ i_zero(&new_kw_rec);
(void)buffer_append_space_unsafe(dest, keywords_count * sizeof(*kw_rec));
/* write the actual records and names */
if (hdr->base_header_size < sizeof(map->hdr)) {
/* header smaller than ours, make a copy so our newer headers
won't have garbage in them */
- memset(&map->hdr, 0, sizeof(map->hdr));
+ i_zero(&map->hdr);
memcpy(&map->hdr, hdr, hdr->base_header_size);
} else {
map->hdr = *hdr;
{
i_assert((sizeof(*hdr) % sizeof(uint64_t)) == 0);
- memset(hdr, 0, sizeof(*hdr));
+ i_zero(hdr);
hdr->major_version = MAIL_INDEX_MAJOR_VERSION;
hdr->minor_version = MAIL_INDEX_MINOR_VERSION;
{
struct mail_index_map tmp_map;
- memset(&tmp_map, 0, sizeof(tmp_map));
+ i_zero(&tmp_map);
mail_index_header_init(index, &tmp_map.hdr);
tmp_map.index = index;
tmp_map.hdr_base = &tmp_map.hdr;
view = mail_index_view_open(index);
trans = mail_index_transaction_begin(view, 0);
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.highest_modseq = mail_index_modseq_get_head(index);
mail_index_update_header_ext(trans, index->modseq_ext_id,
0, &hdr, sizeof(hdr));
if (old_modseq_hdr->log_seq < log_seq ||
(old_modseq_hdr->log_seq == log_seq &&
old_modseq_hdr->log_offset < log_offset)) {
- memset(&new_modseq_hdr, 0, sizeof(new_modseq_hdr));
+ i_zero(&new_modseq_hdr);
new_modseq_hdr.highest_modseq = highest_modseq;
new_modseq_hdr.log_seq = log_seq;
new_modseq_hdr.log_offset = log_offset;
return 0;
}
- memset(ctx, 0, sizeof(*ctx));
+ i_zero(ctx);
ret = i_stream_read_bytes(strmap->input, &data, &size,
sizeof(block_size));
if (ret <= 0) {
if we detect such a conflict, we can't continue using the
strmap index until X has been expunged. */
- memset(&iter, 0, sizeof(iter));
+ i_zero(&iter);
while ((hash_rec = hash2_iterate(ctx->view->hash,
crc32, &iter)) != NULL &&
hash_rec->str_idx != ctx->rec.str_idx) {
(uid == view->last_added_uid &&
ref_index > view->last_ref_index));
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
rec.uid = uid;
rec.ref_index = ref_index;
rec.str_idx = view->next_str_idx++;
unsigned int i, dest, count, count2;
int ret;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.view = view;
ctx.uid_lookup_seq = 1;
idx_hdr = mail_index_get_header(view->view);
/* write header */
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.version = MAIL_INDEX_STRMAP_VERSION;
hdr.uid_validity = idx_hdr->uid_validity;
o_stream_nsend(output, &hdr, sizeof(hdr));
if (!array_is_created(&ctx->view->map->extensions))
return;
- memset(&eh, 0, sizeof(eh));
+ i_zero(&eh);
if (array_is_created(&ctx->expunge_handlers))
array_clear(&ctx->expunge_handlers);
else
return;
/* make sure it's the expected size */
- memset(&u, 0, sizeof(u));
+ i_zero(&u);
u.hdr_size = rext->hdr_size;
u.record_size = rext->record_size;
u.record_align = rext->record_align;
sync_ext_resize(&u, *ext_map_idx_r, ctx, FALSE);
} else {
- memset(&ext_hdr, 0, sizeof(ext_hdr));
+ i_zero(&ext_hdr);
ext_hdr.name_size = strlen(name);
ext_hdr.hdr_size = rext->hdr_size;
ext_hdr.record_size = rext->record_size;
return -1;
}
- memset(&ext_hdr, 0, sizeof(ext_hdr));
+ i_zero(&ext_hdr);
ext_hdr.name_size = strlen(name);
ext_hdr.reset_id = u->reset_id;
ext_hdr.hdr_size = u->hdr_size;
}
/* add the keyword */
- memset(&kw_rec, 0, sizeof(kw_rec));
+ i_zero(&kw_rec);
kw_rec.name_offset = name_offset;
keyword_len = strlen(keyword_name) + 1;
ret = -1;
break;
}
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
memcpy(&rec, data, I_MIN(hdr->size, sizeof(rec)));
ret = mail_index_sync_ext_reset(ctx, &rec);
break;
struct mail_index_view *view,
enum mail_index_sync_handler_type type)
{
- memset(sync_map_ctx, 0, sizeof(*sync_map_ctx));
+ i_zero(sync_map_ctx);
sync_map_ctx->view = view;
sync_map_ctx->cur_ext_map_idx = (uint32_t)-1;
sync_map_ctx->type = type;
const struct mail_index_record *rec;
uint32_t seq, messages_count;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
messages_count = mail_index_view_get_messages_count(ctx->view);
for (seq = 1; seq <= messages_count; seq++) {
uint16_t offset;
int state = 0;
- memset(&u, 0, sizeof(u));
+ i_zero(&u);
data = prepend ? t->pre_hdr_change : t->post_hdr_change;
mask = prepend ? t->pre_hdr_mask : t->post_hdr_mask;
size_t offset;
bool started = FALSE, use_32 = hdr->alloc_size >= 65536;
- memset(&u, 0, sizeof(u));
- memset(&u32, 0, sizeof(u32));
+ i_zero(&u);
+ i_zero(&u32);
data = hdr->data;
mask = hdr->mask;
ext_count = hdrs_count;
}
- memset(&ext_reset, 0, sizeof(ext_reset));
+ i_zero(&ext_reset);
buffer_create_from_data(&reset_buf, &ext_reset, sizeof(ext_reset));
buffer_set_used_size(&reset_buf, sizeof(ext_reset));
i_assert(uid_buffer->used > 0);
- memset(&kt_hdr, 0, sizeof(kt_hdr));
+ i_zero(&kt_hdr);
kt_hdr.modify_type = modify_type;
kt_hdr.name_size = strlen(keyword);
enum mail_index_fsync_mask change_mask = 0;
struct mail_index_export_context ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.trans = t;
ctx.append_ctx = append_ctx;
if ((t->flags & MAIL_INDEX_TRANSACTION_FLAG_AVOID_FLAG_UPDATES) != 0)
t->drop_unnecessary_flag_updates = TRUE;
- memset(&u, 0, sizeof(u));
+ i_zero(&u);
u.uid1 = seq1;
u.uid2 = seq2;
return;
old_array = *array;
- memset(array, 0, sizeof(*array));
+ i_zero(array);
mail_index_seq_array_alloc(array, new_record_size);
/* copy the records' beginnings. leave the end zero-filled. */
struct mail_transaction_ext_intro intro;
uint32_t old_record_size = 0, old_record_align, old_header_size;
- memset(&intro, 0, sizeof(intro));
+ i_zero(&intro);
rext = array_idx(&t->view->index->extensions, ext_id);
/* get ext_id from transaction's map if it's there */
i_assert(reset_id != 0);
- memset(&reset, 0, sizeof(reset));
+ i_zero(&reset);
reset.new_reset_id = reset_id;
reset.preserve_data = clear_data ? 0 : 1;
array_idx(&tview->view.index->extensions, ext_id);
struct mail_index_ext_header ext_hdr;
- memset(&ext_hdr, 0, sizeof(ext_hdr));
+ i_zero(&ext_hdr);
ext_hdr.hdr_size = rext->hdr_size;
ext_hdr.record_size = ext_buf->arr.element_size - sizeof(uint32_t);
ext_hdr.record_align = rext->record_align;
}
*_t = NULL;
- memset(result_r, 0, sizeof(*result_r));
+ i_zero(result_r);
if (t->v.commit(t, result_r) < 0)
return -1;
return 0;
kw_names = array_idx(&ctx->view->index->keywords, 0);
- memset(&thdr, 0, sizeof(thdr));
+ i_zero(&thdr);
thdr.type = MAIL_TRANSACTION_KEYWORD_UPDATE | MAIL_TRANSACTION_EXTERNAL;
- memset(&kw_up, 0, sizeof(kw_up));
+ i_zero(&kw_up);
kw_up.modify_type = MODIFY_ADD;
/* add new flags one by one */
for (i = 0; i < count; i++) {
old_rec = MAIL_INDEX_REC_AT_SEQ(old_map, old_seq);
new_rec = MAIL_INDEX_REC_AT_SEQ(new_map, new_seq);
- memset(&thdr, 0, sizeof(thdr));
+ i_zero(&thdr);
if (old_rec->flags != new_rec->flags) {
struct mail_transaction_flag_update flag_update;
MAIL_TRANSACTION_EXTERNAL;
thdr.size = sizeof(flag_update);
- memset(&flag_update, 0, sizeof(flag_update));
+ i_zero(&flag_update);
flag_update.uid1 = flag_update.uid2 = new_rec->uid;
flag_update.add_flags = new_rec->flags;
flag_update.remove_flags = ~new_rec->flags & 0xff;
thdr.size = sizeof(kw_reset);
/* remove all old flags by resetting them */
- memset(&kw_reset, 0, sizeof(kw_reset));
+ i_zero(&kw_reset);
kw_reset.uid1 = kw_reset.uid2 = new_rec->uid;
if (mail_index_sync_record(&ctx->sync_map_ctx, &thdr,
&kw_reset) < 0)
void mail_index_view_clone(struct mail_index_view *dest,
const struct mail_index_view *src)
{
- memset(dest, 0, sizeof(*dest));
+ i_zero(dest);
dest->refcount = 1;
dest->v = src->v;
dest->index = src->index;
if (mail_index_ext_lookup(index, name, &ext_id))
return ext_id;
- memset(&rext, 0, sizeof(rext));
+ i_zero(&rext);
rext.name = p_strdup(index->extension_pool, name);
rext.index_idx = array_count(&index->extensions);
rext.hdr_size = default_hdr_size;
if (size == 0)
return;
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.type = type | ctx->trans_flags;
if (type == MAIL_TRANSACTION_EXPUNGE ||
type == MAIL_TRANSACTION_EXPUNGE_GUID)
ctx->output = buffer_create_dynamic(default_pool, 1024);
ctx->trans_flags = flags;
- memset(&boundary, 0, sizeof(boundary));
+ i_zero(&boundary);
mail_transaction_log_append_add(ctx, MAIL_TRANSACTION_BOUNDARY,
&boundary, sizeof(boundary));
i_assert(index->indexid != 0);
- memset(hdr, 0, sizeof(*hdr));
+ i_zero(hdr);
hdr->major_version = MAIL_TRANSACTION_LOG_MAJOR_VERSION;
hdr->minor_version = MAIL_TRANSACTION_LOG_MINOR_VERSION;
hdr->hdr_size = sizeof(struct mail_transaction_log_header);
i_assert(file->buffer == NULL && file->mmap_base == NULL);
- memset(&file->hdr, 0, sizeof(file->hdr));
+ i_zero(&file->hdr);
if (file->last_size < mmap_get_page_size() && file->last_size > 0) {
/* just read the entire transaction log to memory.
note that if some of the data hasn't been fully committed
{
struct mail_index *index = log->index;
- memset(set_r, 0, sizeof(*set_r));
+ i_zero(set_r);
set_r->timeout = I_MIN(MAIL_TRANSACTION_LOG_LOCK_TIMEOUT,
index->max_lock_timeout_secs);
set_r->stale_timeout = MAIL_TRANSACTION_LOG_LOCK_CHANGE_TIMEOUT;
struct mail_index_map map;
uint32_t seq, first_uid, last_uid, first_seq, last_seq, max_uid;
- memset(&map, 0, sizeof(map));
- memset(&rec_map, 0, sizeof(rec_map));
+ i_zero(&map);
+ i_zero(&rec_map);
map.rec_map = &rec_map;
map.hdr.messages_count = messages_count;
map.hdr.record_size = sizeof(struct mail_index_record);
test_begin("mail index sync ext atomic inc");
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.view = t_new(struct mail_index_view, 1);
ctx.view->map = t_new(struct mail_index_map, 1);
ctx.view->map->hdr.next_uid = 2;
ext->record_offset = sizeof(struct mail_index_record);
ptr = PTR_OFFSET(ctx.view->map->rec_map->records, ext->record_offset);
- memset(&u, 0, sizeof(u));
+ i_zero(&u);
test_assert(mail_index_sync_ext_atomic_inc(&ctx, &u) == -1);
u.uid = 2;
t = t_new(struct mail_index_transaction, 1);
t->drop_unnecessary_flag_updates = TRUE;
- memset(&u, 0, sizeof(u));
+ i_zero(&u);
u.add_flags = MAIL_SEEN; u.remove_flags = MAIL_DRAFT;
test_begin(t_strdup_printf("mail index transaction finish flag updates n_so_far=%u", n_so_far));
struct mail_transaction_header hdr;
size_t size;
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.type = MAIL_TRANSACTION_APPEND | MAIL_TRANSACTION_EXTERNAL;
hdr.size = mail_index_uint32_to_offset(sizeof(hdr) + sizeof(*rec));
test_transaction_log_file_add(3);
/* add an append record to the 3rd log file */
- memset(&append_rec, 0, sizeof(append_rec));
+ i_zero(&append_rec);
append_rec.uid = 1;
last_log_size = sizeof(struct mail_transaction_log_header) +
return;
}
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.version = DUPLICATE_VERSION;
output = o_stream_create_fd_file(file->new_fd, 0, FALSE);
o_stream_cork(output);
o_stream_nsend(output, &hdr, sizeof(hdr));
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
iter = hash_table_iterate_init(file->hash);
while (hash_table_iterate(iter, file->hash, &d, &d)) {
rec.stamp = d->time;
return -1;
}
- memset(&dns_lookup_set, 0, sizeof(dns_lookup_set));
+ i_zero(&dns_lookup_set);
dns_lookup_set.dns_client_socket_path =
client->set.dns_client_socket_path;
dns_lookup_set.timeout_msecs = LMTP_CLIENT_DNS_LOOKUP_TIMEOUT_MSECS;
{
struct lmtp_recipient_params params;
- memset(¶ms, 0, sizeof(params));
+ i_zero(¶ms);
lmtp_client_add_rcpt_params(client, address, ¶ms, rcpt_to_callback,
data_callback, context);
}
if (default_save)
ctx->tried_default_save = TRUE;
- memset(&open_ctx, 0, sizeof(open_ctx));
+ i_zero(&open_ctx);
open_ctx.user = ctx->dest_user;
open_ctx.lda_mailbox_autocreate = ctx->set->lda_mailbox_autocreate;
open_ctx.lda_mailbox_autosubscribe = ctx->set->lda_mailbox_autosubscribe;
return -1;
}
- memset(&client_set, 0, sizeof(client_set));
+ i_zero(&client_set);
client_set.mail_from = client->return_path == NULL ? "<>" :
t_strconcat("<", client->return_path, ">", NULL);
client_set.my_hostname = client->set->hostname;
array_append_array(&args, &client->destinations);
array_append_zero(&args);
- memset(&pc_set, 0, sizeof(pc_set));
+ i_zero(&pc_set);
pc_set.client_connect_timeout_msecs = timeout_secs * 1000;
pc_set.input_idle_timeout_msecs = timeout_secs * 1000;
restrict_access_init(&pc_set.restrict_set);
ret = ldap_parse_result(conn->conn, message,
&result_err, NULL,
&result_errmsg, NULL, NULL, 0);
- memset(&res, 0, sizeof(res));
+ i_zero(&res);
res.openldap_ret = ret;
if (ret != LDAP_SUCCESS) {
res.error_string = t_strdup_printf(
int ret, const char *error)
{
struct ldap_result res;
- memset(&res, 0, sizeof(res));
+ i_zero(&res);
res.conn = conn;
res.openldap_ret = ret;
res.error_string = error;
struct ldap_op_queue_entry *req)
{
struct ldap_result res;
- memset(&res, 0, sizeof(res));
+ i_zero(&res);
res.conn = conn;
res.openldap_ret = LDAP_SUCCESS;
if (req->result_callback != NULL)
/* did not succeed */
struct ldap_result res;
- memset(&res, 0, sizeof(res));
+ i_zero(&res);
res.openldap_ret = ret;
if (req->result_callback != NULL)
req->result_callback(&res, req->result_callback_ctx);
if (req->msgid > -1)
ldap_abandon_ext(req->conn->conn, req->msgid, NULL, NULL);
- memset(&res, 0, sizeof(res));
+ i_zero(&res);
res.openldap_ret = LDAP_TIMEOUT;
res.error_string = "Aborting LDAP request after timeout";
if (req->result_callback != NULL)
void ldap_connection_abort_all_requests(struct ldap_connection *conn)
{
struct ldap_result res;
- memset(&res, 0, sizeof(res));
+ i_zero(&res);
res.openldap_ret = LDAP_TIMEOUT;
res.error_string = "Aborting LDAP requests due to failure";
if (astream->set.want_attachment == NULL)
return TRUE;
- memset(&ahdr, 0, sizeof(ahdr));
+ i_zero(&ahdr);
ahdr.part = part;
ahdr.content_type = astream->part.content_type;
ahdr.content_disposition = astream->part.content_disposition;
return -1;
}
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info.start_offset = astream->part.start_offset;
/* base64_bytes contains how many valid base64 bytes there are so far.
if the base64 ends properly, it'll specify how much of the MIME part
if (part->part_buf != NULL)
buffer_free(&part->part_buf);
- memset(part, 0, sizeof(*part));
+ i_zero(part);
part->temp_fd = -1;
hash_format_reset(astream->set.hash_format);
}
if (msg+29-3-5 > msg_end)
return -1;
- memset(&tm, 0, sizeof(tm));
+ i_zero(&tm);
/* skip weekday */
msg += 4;
addr = p_new(ctx->pool, struct message_address, 1);
memcpy(addr, &ctx->addr, sizeof(ctx->addr));
- memset(&ctx->addr, 0, sizeof(ctx->addr));
+ i_zero(&ctx->addr);
if (ctx->first_addr == NULL)
ctx->first_addr = addr;
{
struct message_address_parser_context ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
rfc822_parser_init(&ctx.parser, data, size, t_str_new(128));
ctx.pool = pool;
int ret;
/* [weekday_name "," ] dd month_name [yy]yy hh:mi[:ss] timezone */
- memset(&tm, 0, sizeof(tm));
+ i_zero(&tm);
rfc822_skip_lwsp(&ctx->parser);
{
struct decode_utf8_context ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.dest = dest;
ctx.normalizer = normalizer;
message_header_decode(data, size, decode_utf8_callback, &ctx);
i_stream_ref(input);
if (hdr_size != NULL)
- memset(hdr_size, 0, sizeof(*hdr_size));
+ i_zero(hdr_size);
return ctx;
}
int ret;
bool eof = FALSE, full;
- memset(block_r, 0, sizeof(*block_r));
+ i_zero(block_r);
while ((ret = ctx->parse_next_block(ctx, block_r)) == 0) {
ret = message_parser_read_more(ctx, block_r, &full);
struct deserialize_context ctx;
struct message_part *part;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.pool = pool;
ctx.data = data;
ctx.end = ctx.data + size;
struct message_header_line *hdr = raw_block->hdr;
struct message_block decoded_block;
- memset(decoded_block_r, 0, sizeof(*decoded_block_r));
+ i_zero(decoded_block_r);
decoded_block_r->part = raw_block->part;
if (raw_block->part != ctx->prev_part) {
pool_t pool;
int ret;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
pool = pool_alloconly_create("message snippet", 1024);
ctx.snippet = snippet;
ctx.chars_left = max_snippet_chars;
/* Get a list of all parameters. RFC 2231 uses key*<n>[*]=value pairs,
which we want to merge to a key[*]=value pair. Save them to a
separate array. */
- memset(&rfc2231_param, 0, sizeof(rfc2231_param));
+ i_zero(&rfc2231_param);
t_array_init(&result, 8);
t_array_init(&rfc2231_params_arr, 8);
while ((ret = rfc822_parse_content_param(ctx, &key, &value)) != 0) {
const unsigned char *data, size_t size,
string_t *last_comment)
{
- memset(ctx, 0, sizeof(*ctx));
+ i_zero(ctx);
ctx->data = data;
ctx->end = data + size;
ctx->last_comment = last_comment;
{
const char *error;
- memset(set_r, 0, sizeof(*set_r));
+ i_zero(set_r);
set_r->min_size = 1;
set_r->drain_parent_input = TRUE;
set_r->open_temp_fd = test_open_temp_fd;
test_begin("message decoder");
- memset(&part, 0, sizeof(part));
- memset(&input, 0, sizeof(input));
+ i_zero(&part);
+ i_zero(&input);
memset(&output, 0xff, sizeof(output));
input.part = ∂
ctx = message_decoder_init(NULL, 0);
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.name = "Content-Transfer-Encoding";
hdr.name_len = strlen(hdr.name);
hdr.full_value = (const void *)"quoted-printable";
test_begin("message_decoder_current_content_type()");
- memset(&part, 0, sizeof(part));
+ i_zero(&part);
part2 = part3 = part;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
memset(&output, 0xff, sizeof(output));
input.part = ∂
test_assert(message_decoder_current_content_type(ctx) == NULL);
/* multipart/mixed */
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.name = "Content-Type";
hdr.name_len = strlen(hdr.name);
hdr.full_value = (const void *)"multipart/mixed; boundary=x";
test_begin("dsync_mail_hash_more v2");
md5_init(&md5_ctx);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
message_header_hash_more(&ctx, &hash_method_md5, &md5_ctx, 2,
test_input, sizeof(test_input)-1);
md5_final(&md5_ctx, md5_input);
/* single byte at a time */
md5_init(&md5_ctx);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
for (unsigned int i = 0; i < sizeof(test_input)-1; i++) {
message_header_hash_more(&ctx, &hash_method_md5, &md5_ctx, 2,
test_input + i, 1);
ctx1 = message_search_init("p\xC3\xA4\xC3\xA4", NULL, 0);
ctx2 = message_search_init("p\xC3\xB6\xC3\xB6", NULL, 0);
- memset(&raw_block, 0, sizeof(raw_block));
+ i_zero(&raw_block);
raw_block.part = ∂
/* feed the Content-Type header */
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.name = "Content-Type"; hdr.name_len = strlen(hdr.name);
hdr.value = hdr.full_value = text_plain;
hdr.value_len = hdr.full_value_len = sizeof(text_plain)-1;
{
struct master_auth_request_params params;
- memset(¶ms, 0, sizeof(params));
+ i_zero(¶ms);
params.client_fd = fd;
params.request = *request;
params.data = data;
struct master_login_connection *conn = client->conn;
struct master_auth_reply reply;
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
reply.tag = client->auth_req.tag;
reply.status = errormsg == NULL ? MASTER_AUTH_STATUS_OK :
MASTER_AUTH_STATUS_INTERNAL_ERROR;
(service->flags & MASTER_SERVICE_FLAG_NO_CONFIG_SETTINGS) != 0)
return;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.never_exec = TRUE;
fd = master_service_open_config(service, &input, &path, &error);
if (fd != -1)
time_t now, timeout;
bool use_environment, retry;
- memset(output_r, 0, sizeof(*output_r));
+ i_zero(output_r);
if (getenv("DOVECONF_ENV") == NULL &&
(service->flags & MASTER_SERVICE_FLAG_NO_CONFIG_SETTINGS) == 0) {
struct master_service_settings_input input;
struct master_service_settings_output output;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = roots;
input.module = service->name;
return master_service_settings_read(service, &input, &output, error_r);
set = master_service_ssl_settings_get(service);
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.verbose = set->verbose_ssl;
ssl_set.verify_remote_cert = set->ssl_verify_client_cert;
return io_stream_create_ssl_server(service->ssl_ctx, &ssl_set,
return;
}
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.protocols = set->ssl_protocols;
ssl_set.cipher_list = set->ssl_cipher_list;
ssl_set.ca = set->ssl_ca;
}
}
- memset(&conn, 0, sizeof(conn));
+ i_zero(&conn);
conn.listen_fd = l->fd;
conn.fd = net_accept(l->fd, &conn.remote_ip, &conn.remote_port);
if (conn.fd < 0) {
pool_t pool;
int ret;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = "module";
input.service = "service_name";
const char *data;
type = va_arg(args, int);
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
write_le16(&info.type, type);
switch (type) {
buf = buffer_create_dynamic(pool, sizeof(struct ntlmssp_challenge));
- memset(&c, 0, sizeof(c));
+ i_zero(&c);
write_le64(&c.magic, NTLMSSP_MAGIC);
write_le32(&c.type, NTLMSSP_MSG_TYPE2);
write_le32(&c.flags, flags);
}
p_array_init(arr, ctx->set_pool, count + 4);
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info = *def->list_info;
for (i = 0; i < count; i++) T_BEGIN {
if (change_result != NULL && !array_is_created(change_result))
p_array_init(change_result, ctx->set_pool, 5);
- memset(&new_link, 0, sizeof(new_link));
+ i_zero(&new_link);
new_link.parent = parent;
new_link.info = info;
new_link.array = result;
return 0;
type_offset = def->list_info->type_offset;
- memset(&child_dest_link, 0, sizeof(child_dest_link));
- memset(&child_src_link, 0, sizeof(child_src_link));
+ i_zero(&child_dest_link);
+ i_zero(&child_src_link);
child_dest_link.info = child_src_link.info = def->list_info;
next_section = t_strcut(section, '/');
}
- memset(&root, 0, sizeof(root));
+ i_zero(&root);
root.path = path;
input = &root;
struct cassandra_transaction_context *ctx = context;
struct sql_commit_result commit_result;
- memset(&commit_result, 0, sizeof(commit_result));
+ i_zero(&commit_result);
if (sql_result_next_row(result) < 0) {
commit_result.error = sql_result_get_error(result);
commit_result.error_type = sql_result_get_error_type(result);
enum cassandra_query_type query_type;
struct sql_commit_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
ctx->callback = callback;
ctx->context = context;
struct sql_commit_result result;
const char *error;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
if (sql_transaction_commit_s(&ctx, &error) < 0)
result.error = error;
callback(&result, context);
{
struct sql_commit_result commit_result;
- memset(&commit_result, 0, sizeof(commit_result));
+ i_zero(&commit_result);
if (sql_result_next_row(result) < 0) {
commit_result.error = sql_result_get_error(result);
commit_result.error_type = sql_result_get_error_type(result);
{
struct sql_commit_result commit_result;
- memset(&commit_result, 0, sizeof(commit_result));
+ i_zero(&commit_result);
commit_result.error = sql_result_get_error(result);
commit_result.error_type = sql_result_get_error_type(result);
query->affected_rows) < 0)
i_unreached();
}
- memset(&commit_result, 0, sizeof(commit_result));
+ i_zero(&commit_result);
ctx->callback(&commit_result, ctx->context);
driver_pgsql_transaction_free(ctx);
}
(struct pgsql_transaction_context *)_ctx;
struct sql_commit_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
ctx->callback = callback;
ctx->context = context;
ctx->failed = TRUE;
}
- memset(&commit_result, 0, sizeof(commit_result));
+ i_zero(&commit_result);
if (ctx->failed) {
commit_result.error = sqlite3_errmsg(db->sqlite);
callback(&commit_result, context);
const char *plugin_name = "ssl_iostream_openssl";
struct module_dir_load_settings mod_set;
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.setting_name = "<built-in lib-ssl-iostream lookup>";
mod_set.require_init_funcs = TRUE;
i_stream_unref(&crlf_input);
/* write a dummy header. it'll get rewritten when we're finished */
- memset(&dbox_msg_hdr, 0, sizeof(dbox_msg_hdr));
+ i_zero(&dbox_msg_hdr);
o_stream_cork(ctx->dbox_output);
if (o_stream_send(ctx->dbox_output, &dbox_msg_hdr,
sizeof(dbox_msg_hdr)) < 0) {
string_t *str;
uoff_t vsize;
- memset(&metadata_hdr, 0, sizeof(metadata_hdr));
+ i_zero(&metadata_hdr);
memcpy(metadata_hdr.magic_post, DBOX_MAGIC_POST,
sizeof(metadata_hdr.magic_post));
o_stream_nsend(output, &metadata_hdr, sizeof(metadata_hdr));
if (mdbox_deleted_mailbox_create_indexes(&mbox->box, NULL, NULL) < 0)
return -1;
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
rec.save_date = ioloop_time;
sync_flags = index_storage_get_sync_flags(&mbox->box);
size_t data_size;
mail_index_get_header_ext(view, map->map_ext_id, &data, &data_size);
- memset(hdr_r, 0, sizeof(*hdr_r));
+ i_zero(hdr_r);
memcpy(hdr_r, data, I_MIN(data_size, sizeof(*hdr_r)));
}
const uint16_t *ref16_p;
const void *data;
- memset(rec_r, 0, sizeof(*rec_r));
+ i_zero(rec_r);
mail_index_lookup_uid(view, seq, &rec_r->map_uid);
mail_index_lookup_ext(view, seq, map->map_ext_id, &data, NULL);
return -1;
hdr = mail_index_get_header(map->view);
- memset(&msg, 0, sizeof(msg));
+ i_zero(&msg);
for (seq = 1; seq <= hdr->messages_count; seq++) {
if (mdbox_map_view_lookup_rec(map, map->view, seq, &rec) < 0)
return -1;
return -1;
/* append map records to index */
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
ref16 = 1;
appends = array_get(&ctx->appends, &count);
for (i = 0; i < count; i++) {
if (mdbox_map_assign_file_ids(ctx, FALSE, "purging - update uids") < 0)
return -1;
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
appends = array_get(&ctx->appends, &appends_count);
next_uid = mail_index_get_header(ctx->atomic->sync_view)->next_uid;
mdbox_update_header(mbox, ctx->ctx.trans, NULL);
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
rec.save_date = ioloop_time;
mails = array_get(&ctx->mails, &count);
for (i = 0; i < count; i++) {
return mail_storage_copy(_ctx, mail);
src_mbox = (struct mdbox_mailbox *)mail->box;
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
rec.save_date = ioloop_time;
if (mdbox_mail_lookup(src_mbox, mail->transaction->view, mail->seq,
&rec.map_uid) < 0) {
unsigned int i, count;
uint32_t seq;
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
msgs = array_get_modifiable(&ctx->msgs, &count);
for (i = 0; i < count; i++) {
if (msgs[i]->map_uid != 0)
mail_index_lookup_ext(view, old_seq, mbox->ext_id,
&data, NULL);
if (data == NULL) {
- memset(&new_dbox_rec, 0, sizeof(new_dbox_rec));
+ i_zero(&new_dbox_rec);
map_uid = 0;
} else {
memcpy(&new_dbox_rec, data, sizeof(new_dbox_rec));
size_t data_size;
mail_index_get_header_ext(view, hdr_ext_id, &data, &data_size);
- memset(hdr_r, 0, sizeof(*hdr_r));
+ i_zero(hdr_r);
memcpy(hdr_r, data, I_MIN(data_size, sizeof(*hdr_r)));
*need_resize_r = data_size < sizeof(*hdr_r);
}
mdbox_rebuild_get_header(rebuild_ctx->view, mbox->hdr_ext_id,
&hdr, &need_resize);
if (rebuild_ctx->backup_view == NULL) {
- memset(&backup_hdr, 0, sizeof(backup_hdr));
+ i_zero(&backup_hdr);
need_resize = TRUE;
} else {
mdbox_rebuild_get_header(rebuild_ctx->backup_view,
if (mail_index_sync_commit(&msg->sync_ctx) < 0)
return -1;
mailbox_free(&msg->box);
- memset(msg, 0, sizeof(*msg));
+ i_zero(msg);
return 0;
}
}
/* add the new message */
- memset(&dbox_rec, 0, sizeof(dbox_rec));
+ i_zero(&dbox_rec);
dbox_rec.map_uid = msg->map_uid;
dbox_rec.save_date = ioloop_time;
mail_index_append(ctx->prev_msg.trans, ctx->prev_msg.next_uid++, &seq);
mail_index_get_header_ext(ctx->atomic->sync_view,
ctx->storage->map->map_ext_id,
&data, &data_size);
- memset(&ctx->orig_map_hdr, 0, sizeof(ctx->orig_map_hdr));
+ i_zero(&ctx->orig_map_hdr);
memcpy(&ctx->orig_map_hdr, data,
I_MIN(data_size, sizeof(ctx->orig_map_hdr)));
ctx->highest_file_id = ctx->orig_map_hdr.highest_file_id;
mdbox_storage_set_corrupted(mbox->storage);
return -1;
}
- memset(hdr, 0, sizeof(*hdr));
+ i_zero(hdr);
if (data_size > 0)
memcpy(hdr, data, I_MIN(data_size, sizeof(*hdr)));
*need_resize_r = data_size < sizeof(*hdr);
bool need_resize;
if (mdbox_read_header(mbox, &hdr, &need_resize) < 0) {
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
need_resize = TRUE;
}
}
if (mdbox_read_header(mbox, &hdr, &need_resize) < 0)
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
if (guid_128_is_empty(hdr.mailbox_guid)) {
/* regenerate it */
}
ret = -1;
} else {
- memset(hdr, 0, sizeof(*hdr));
+ i_zero(hdr);
memcpy(hdr, data, I_MIN(data_size, sizeof(*hdr)));
if (guid_128_is_empty(hdr->mailbox_guid))
ret = -1;
bool need_resize;
if (sdbox_read_header(mbox, &hdr, TRUE, &need_resize) < 0) {
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
need_resize = TRUE;
}
mail_index_ext_register(mbox->box.index, "dbox-hdr",
sizeof(struct sdbox_index_header), 0, 0);
/* set the initialization data in case the mailbox is created */
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
guid_128_generate(hdr.mailbox_guid);
mail_index_set_ext_init_data(mbox->box.index, mbox->hdr_ext_id,
&hdr, sizeof(hdr));
/* looks like the mailbox is corrupted */
(void)sdbox_sync(mbox, SDBOX_SYNC_FLAG_FORCE);
if (sdbox_read_header(mbox, &hdr, TRUE, &need_resize) < 0)
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
}
if (guid_128_is_empty(hdr.mailbox_guid)) {
bool need_resize;
if (sdbox_read_header(mbox, &hdr, FALSE, &need_resize) < 0)
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
if (guid_128_is_empty(hdr.mailbox_guid))
guid_128_generate(hdr.mailbox_guid);
if (++hdr.rebuild_count == 0)
struct mailbox_node *node;
const char *name;
- memset(&update_ctx, 0, sizeof(update_ctx));
+ i_zero(&update_ctx);
update_ctx.iter_ctx = &ctx->ctx;
update_ctx.tree_ctx = ctx->tree;
update_ctx.glob = ctx->ctx.glob;
void imapc_simple_context_init(struct imapc_simple_context *sctx,
struct imapc_storage_client *client)
{
- memset(sctx, 0, sizeof(*sctx));
+ i_zero(sctx);
sctx->client = client;
sctx->ret = -2;
}
struct imapc_client_settings set;
string_t *str;
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.host = imapc_set->imapc_host;
if (*set.host == '\0') {
*error_r = "missing imapc_host";
struct mail_save_context *ctx = context;
struct mail_attachment_part apart;
- memset(&apart, 0, sizeof(apart));
+ i_zero(&apart);
apart.part = hdr->part;
apart.content_type = hdr->content_type;
apart.content_disposition = hdr->content_disposition;
if (*storage->set->mail_attachment_dir == '\0')
return;
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.min_size = storage->set->mail_attachment_min_size;
if (hash_format_init(storage->set->mail_attachment_hash,
&set.hash_format, &error) < 0) {
const char *decode_options = args[i+2];
const char *path = args[i+3];
- memset(&extref, 0, sizeof(extref));
+ i_zero(&extref);
if (str_to_uoff(start_offset_str, &extref.start_offset) < 0 ||
str_to_uoff(size_str, &extref.size) < 0 ||
extref.start_offset < last_voffset ||
return -1;
}
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.username = user->username;
dict_set.base_dir = user->set->base_dir;
if (dict_init(attr_storage->set->mail_attribute_dict, &dict_set,
return -1;
}
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.username = storage->user->username;
set.base_dir = storage->user->set->base_dir;
if (mail_user_get_home(storage->user, &set.home_dir) <= 0)
const char *mailbox_prefix, *error;
int ret;
- memset(value_r, 0, sizeof(*value_r));
+ i_zero(value_r);
if (index_storage_get_dict(box, type, &dict, &mailbox_prefix) < 0)
return -1;
for (; part != NULL; part = part->next) {
binary_parts_update(ctx, part->children, msg_bin_parts);
- memset(&bin_part, 0, sizeof(bin_part));
+ i_zero(&bin_part);
/* default to unchanged header */
bin_part.binary_hdr_size = part->header_size.virtual_size;
bin_part.physical_pos = part->physical_pos;
struct binary_ctx ctx;
struct istream *is;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.mail = _mail;
t_array_init(&ctx.blocks, 8);
{
struct mail_cache_field header_field;
- memset(&header_field, 0, sizeof(header_field));
+ i_zero(&header_field);
header_field.type = MAIL_CACHE_FIELD_HEADER;
header_field.decision = decision;
T_BEGIN {
}
mail->data.header_parser_initialized = TRUE;
mail->data.parse_line_num = 0;
- memset(&mail->data.parse_line, 0, sizeof(mail->data.parse_line));
+ i_zero(&mail->data.parse_line);
}
static void index_mail_parse_finish_imap_envelope(struct index_mail *mail)
{
struct index_mail_data *data = &mail->data;
- memset(data, 0, sizeof(*data));
+ i_zero(data);
p_clear(mail->mail.data_pool);
data->virtual_size = (uoff_t)-1;
size);
}
update->rebuild = TRUE;
- memset(&update->vsize_hdr, 0, sizeof(update->vsize_hdr));
+ i_zero(&update->vsize_hdr);
}
}
} else {
/* some messages have been expunged, rescan */
}
- memset(&update->vsize_hdr, 0, sizeof(update->vsize_hdr));
+ i_zero(&update->vsize_hdr);
update->rebuild = TRUE;
}
}
return FALSE;
perm = mailbox_get_permissions(box);
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.lock_timeout_secs =
mail_storage_get_lock_timeout(box->storage, lock_secs);
set.lock_method = box->storage->set->parsed_lock_method;
if (update->vsize_hdr.message_count == 0) {
mail_storage_set_critical(update->box->storage,
"vsize-hdr's message_count shrank below 0");
- memset(&update->vsize_hdr, 0, sizeof(update->vsize_hdr));
+ i_zero(&update->vsize_hdr);
return;
}
update->vsize_hdr.message_count--;
if (update->vsize_hdr.vsize < vsize) {
mail_storage_set_critical(update->box->storage,
"vsize-hdr's vsize shrank below 0");
- memset(&update->vsize_hdr, 0, sizeof(update->vsize_hdr));
+ i_zero(&update->vsize_hdr);
return;
}
update->vsize_hdr.vsize -= vsize;
{
struct mailbox_index_pop3_uidl uidl;
- memset(&uidl, 0, sizeof(uidl));
+ i_zero(&uidl);
uidl.max_uid_with_pop3_uidl = uid;
mail_index_update_header_ext(trans, box->pop3_uidl_hdr_ext_id,
}
/* set highest-modseq */
- memset(&modseq_hdr, 0, sizeof(modseq_hdr));
+ i_zero(&modseq_hdr);
modseq_hdr.highest_modseq = mail_index_modseq_get_highest(ctx->view);
if (ctx->backup_view != NULL) {
modseq = mail_index_modseq_get_highest(ctx->backup_view);
/* add a temporary search parameter to limit the search only to
the changed messages */
- memset(&search_arg, 0, sizeof(search_arg));
+ i_zero(&search_arg);
search_arg.type = SEARCH_UIDSET;
search_arg.value.seqset = *uids;
search_arg.next = result->search_args->args;
/* add a temporary search parameter to limit the search only to
the new messages */
- memset(&search_arg, 0, sizeof(search_arg));
+ i_zero(&search_arg);
search_arg.type = SEARCH_SEQSET;
t_array_init(&search_arg.value.seqset, 1);
seq_range_array_add_range(&search_arg.value.seqset,
return;
}
- memset(&block, 0, sizeof(block));
+ i_zero(&block);
/* We're searching only for values, so drop header name and middle
parts. We use header searching so that MIME words will be decoded. */
if (!have_headers && !have_body)
return -1;
- memset(&hdr_ctx, 0, sizeof(hdr_ctx));
+ i_zero(&hdr_ctx);
hdr_ctx.index_ctx = ctx;
/* hdr_ctx.imail is different from imail for mails in
virtual mailboxes */
i_stream_seek(input, hdr_size.physical_size);
}
- memset(&body_ctx, 0, sizeof(body_ctx));
+ i_zero(&body_ctx);
body_ctx.index_ctx = ctx;
body_ctx.input = input;
(void)mail_get_parts(ctx->cur_mail, &body_ctx.part);
array_clear(&ctx->zero_nodes);
array_clear(&ctx->nonzero_nodes);
- memset(&node, 0, sizeof(node));
+ i_zero(&node);
node.wanted = TRUE;
seqs = array_get(&ctx->program->seqs, &count);
for (i = 0; i < count; i++) {
struct sort_string_context *ctx = program->context;
struct mail_sort_node node;
- memset(&node, 0, sizeof(node));
+ i_zero(&node);
node.seq = mail->seq;
node.wanted = TRUE;
else {
i_assert(next_seq < seqs[i]);
for (seq = next_seq; seq < seqs[i]; seq++) {
- memset(&node, 0, sizeof(node));
+ i_zero(&node);
node.seq = seq;
index_sort_node_add(ctx, &node);
}
void index_sort_list_finish(struct mail_search_sort_program *program)
{
- memset(&static_node_cmp_context, 0, sizeof(static_node_cmp_context));
+ i_zero(&static_node_cmp_context);
static_node_cmp_context.program = program;
static_node_cmp_context.mail = program->temp_mail;
static_node_cmp_context.reverse =
if (idx != UINT_MAX) {
field = *mail_cache_register_get_field(cache, idx);
} else if (strncasecmp(name, "hdr.", 4) == 0) {
- memset(&field, 0, sizeof(field));
+ i_zero(&field);
field.name = name;
field.type = MAIL_CACHE_FIELD_HEADER;
} else {
field = old_fields[j];
} else if (strncmp(updates[i].name, "hdr.", 4) == 0) {
/* new header */
- memset(&field, 0, sizeof(field));
+ i_zero(&field);
field.name = updates[i].name;
field.type = MAIL_CACHE_FIELD_HEADER;
} else {
i_free_and_null(ctx->data.guid);
i_free_and_null(ctx->data.pop3_uidl);
index_attachment_save_free(ctx);
- memset(&ctx->data, 0, sizeof(ctx->data));
+ i_zero(&ctx->data);
ctx->unfinished = FALSE;
}
void index_sync_changes_reset(struct index_sync_changes_context *ctx)
{
array_clear(&ctx->syncs);
- memset(&ctx->sync_rec, 0, sizeof(ctx->sync_rec));
+ i_zero(&ctx->sync_rec);
}
void index_sync_changes_delete_to(struct index_sync_changes_context *ctx,
}
if (!mail_index_sync_next(ctx->index_sync_ctx, sync_rec)) {
- memset(sync_rec, 0, sizeof(*sync_rec));
+ i_zero(sync_rec);
break;
}
sync_rec->uid1,
sync_rec->uid2,
&seq1, &seq2);
- memset(sync_rec, 0, sizeof(*sync_rec));
+ i_zero(sync_rec);
if (seq1 == 0)
break;
return;
}
- memset(&new_rec, 0, sizeof(new_rec));
+ i_zero(&new_rec);
new_rec.size = st.st_size & 0xffffffffU;
new_rec.mtime = st.st_mtime & 0xffffffffU;
struct mail_thread_child_node child;
unsigned int count;
- memset(&child, 0, sizeof(child));
+ i_zero(&child);
array_clear(sorted_children);
/* add all child indexes to the array */
const struct mail_thread_child_node *children;
uint32_t idx, uid;
- memset(&gather_ctx, 0, sizeof(gather_ctx));
+ i_zero(&gather_ctx);
gather_ctx.ctx = ctx;
roots = array_get_modifiable(&ctx->roots, &count);
the current message and the message in the subject
table children of the dummy. Then replace the message
in the subject table with the dummy message. */
- memset(&new_root, 0, sizeof(new_root));
+ i_zero(&new_root);
new_root.root_idx1 = array_count(&ctx->roots) + 1;
new_root.node.idx = ctx->next_new_root_idx++;
new_root.dummy = TRUE;
ctx->use_sent_date = FALSE;
- memset(&root, 0, sizeof(root));
- memset(&child, 0, sizeof(child));
+ i_zero(&root);
+ i_zero(&child);
/* We may see dummy messages without parents or children. We can't
free them since the nodes are in an array, but they may get reused
mail_thread_deinit(&ctx);
return -1;
} else {
- memset(&ctx->added_uids, 0, sizeof(ctx->added_uids));
+ i_zero(&ctx->added_uids);
*ctx_r = ctx;
return 0;
}
struct mail_index_transaction_commit_result result;
int ret = 0;
- memset(changes_r, 0, sizeof(*changes_r));
+ i_zero(changes_r);
changes_r->pool = pool_alloconly_create(MEMPOOL_GROWING
"transaction changes", 512);
p_array_init(&changes_r->saved_uids, changes_r->pool, 32);
/* hard link to tmp/ with a newly generated filename and later when we
have uidlist locked, move it to new/cur. */
dest_fname = maildir_filename_generate();
- memset(&do_ctx, 0, sizeof(do_ctx));
+ i_zero(&do_ctx);
do_ctx.dest_path =
t_strdup_printf("%s/tmp/%s", mailbox_get_path(&dest_mbox->box),
dest_fname);
if (strchr(fname, MAILDIR_EXTRA_SEP) == NULL)
return;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.physical_size = (uoff_t)-1;
if (field == MAIL_FETCH_VIRTUAL_SIZE &&
maildir_filename_get_size(fname, MAILDIR_EXTRA_VIRTUAL_SIZE,
mailbox_recent_flags_reset(&mbox->box);
first_uid = hdr->messages_count + 1;
- memset(&empty_hdr, 0, sizeof(empty_hdr));
+ i_zero(&empty_hdr);
empty_hdr.next_uid = 1;
hdr = &empty_hdr;
}
return;
old_rec = data;
- memset(&new_rec, 0, sizeof(new_rec));
+ i_zero(&new_rec);
if (mhdr->new_check_time <= mhdr->new_mtime + MAILDIR_SYNC_SECS ||
mhdr->cur_check_time <= mhdr->cur_mtime + MAILDIR_SYNC_SECS) {
/* dirty, we need a refresh next time */
hash_table_destroy(&uidlist->files);
uidlist->files = ctx->files;
- memset(&ctx->files, 0, sizeof(ctx->files));
+ i_zero(&ctx->files);
if (uidlist->record_pool != NULL)
pool_unref(&uidlist->record_pool);
ctx->dotlock_last_stale = TRUE;
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.use_excl_lock = mbox->storage->storage.set->dotlock_use_excl;
set.nfs_flush = mbox->storage->storage.set->mail_nfs_storage;
set.timeout = mail_storage_get_lock_timeout(&mbox->storage->storage,
if (lock_type == F_UNLCK && ctx->mbox->mbox_fd == -1)
return 1;
- memset(&fl, 0, sizeof(fl));
+ i_zero(&fl);
fl.l_type = lock_type;
fl.l_whence = SEEK_SET;
fl.l_start = 0;
mail_storage_get_lock_timeout(&mbox->storage->storage,
mbox->storage->set->mbox_lock_timeout);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.mbox = mbox;
if (mbox->mbox_lock_type == F_WRLCK) {
if (mbox->mbox_stream != NULL)
istream_raw_mbox_set_unlocked(mbox->mbox_stream);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.mbox = mbox;
for (i = 0; i < MBOX_LOCK_COUNT; i++)
if (ctx->x_delivery_id_header != NULL) {
struct message_header_line hdr;
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.name = ctx->x_delivery_id_header;
hdr.name_len = sizeof("X-Delivery-ID")-1;
hdr.middle = (const unsigned char *)hdr.name +
return;
old_rec = data;
- memset(&new_rec, 0, sizeof(new_rec));
+ i_zero(&new_rec);
new_rec.mtime = mhdr->sync_mtime;
new_rec.size = mhdr->sync_size & 0xffffffffU;
exists. */
mail_index_lookup_uid(view, seq, &uid);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
mbox_md5_ctx = mbox->md5_v.init();
hdr_ctx = message_parse_header_init(mbox->mbox_stream, NULL, 0);
unsigned int first_mail_expunge_extra;
uint32_t orig_next_uid;
- memset(mail_ctx, 0, sizeof(*mail_ctx));
+ i_zero(mail_ctx);
mail_ctx->sync_ctx = sync_ctx;
mail_ctx->seq = seq;
mail_ctx->header = sync_ctx->header;
return 0;
p_clear(sync_ctx->mail_keyword_pool);
- memset(mail_ctx, 0, sizeof(*mail_ctx));
+ i_zero(mail_ctx);
mail_ctx->sync_ctx = sync_ctx;
mail_ctx->seq = ++sync_ctx->seq;
mail_ctx->header = sync_ctx->header;
i_assert(postlf_from_offset != (uoff_t)-1);
mail_ctx->mail.from_offset = postlf_from_offset;
- memset(&mail, 0, sizeof(mail));
+ i_zero(&mail);
mail.expunged = TRUE;
mail.offset = mail.from_offset =
mail_ctx->mail.from_offset -
/* mail_ctx may contain wrong data after rewrite, so make sure we
don't try to access it */
- memset(mail_ctx, 0, sizeof(*mail_ctx));
+ i_zero(mail_ctx);
sync_ctx->need_space_seq = 0;
sync_ctx->space_diff = 0;
&data, &data_size);
if (data_size == 0) {
/* doesn't exist yet. */
- memset(&mbox->mbox_hdr, 0, sizeof(mbox->mbox_hdr));
+ i_zero(&mbox->mbox_hdr);
return 0;
}
return 0;
}
- memset(&sync_ctx, 0, sizeof(sync_ctx));
+ i_zero(&sync_ctx);
sync_ctx.mbox = mbox;
sync_ctx.keep_recent =
(mbox->box.flags & MAILBOX_FLAG_DROP_RECENT) == 0;
client->set.ssl_ca_file = p_strdup(pool, set->ssl_ca_file);
client->set.ssl_verify = set->ssl_verify;
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
ssl_set.ca_dir = set->ssl_ca_dir;
ssl_set.ca_file = set->ssl_ca_file;
ssl_set.verify_remote_cert = set->ssl_verify;
client->ip = ips[0];
pop3c_client_connect_ip(client);
} else {
- memset(&dns_set, 0, sizeof(dns_set));
+ i_zero(&dns_set);
dns_set.dns_client_socket_path =
client->set.dns_client_socket_path;
dns_set.timeout_msecs = POP3C_DNS_LOOKUP_TIMEOUT_MSECS;
return -1;
}
- memset(&ssl_set, 0, sizeof(ssl_set));
+ i_zero(&ssl_set);
if (client->set.ssl_verify) {
ssl_set.verbose_invalid_cert = TRUE;
ssl_set.verify_remote_cert = TRUE;
{
struct pop3c_client_sync_cmd_ctx ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
pop3c_client_cmd_line_async(client, cmdline, pop3c_client_cmd_reply, &ctx);
while (ctx.reply == NULL)
pop3c_client_wait_one(client);
return -1;
}
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
*input_r = pop3c_client_cmd_stream_async(client, cmdline,
pop3c_client_cmd_reply, &ctx);
while (ctx.reply == NULL)
struct pop3c_client_settings client_set;
string_t *str;
- memset(&client_set, 0, sizeof(client_set));
+ i_zero(&client_set);
client_set.host = set->pop3c_host;
client_set.port = set->pop3c_port;
client_set.username = set->pop3c_user;
struct pop3c_sync_msg msg;
uint32_t seq;
- memset(&msg, 0, sizeof(msg));
+ i_zero(&msg);
for (seq = 1; seq <= messages_count; seq++) {
str_truncate(str, 0);
if (mail_cache_lookup_field(cache_view, str, seq,
/* if no GUID is requested, generate it ourself. set
UIDVALIDITY to index sometimes later. */
if (update == NULL)
- memset(&new_update, 0, sizeof(new_update));
+ i_zero(&new_update);
else
new_update = *update;
if (guid_128_is_empty(new_update.mailbox_guid))
}
/* get GUID */
- memset(status_r, 0, sizeof(*status_r));
+ i_zero(status_r);
memset(guid_r, 0, GUID_128_SIZE);
(void)mailbox_list_index_status(inotify->notify.list, view, seq,
items, status_r, guid_r, NULL);
const char *storage_name;
char ns_sep = mailbox_list_get_hierarchy_sep(inotify->notify.list);
- memset(rec, 0, sizeof(*rec));
+ i_zero(rec);
index_node = notify_lookup_guid(inotify, view, uid,
items, status_r, rec->guid);
if (index_node == NULL)
struct mailbox_list_notify_rec *rec = &inotify->notify_rec;
const char *const *vnamep;
- memset(rec, 0, sizeof(*rec));
+ i_zero(rec);
vnamep = array_idx(&inotify->new_subscriptions, idx);
rec->vname = *vnamep;
rec->storage_name = mailbox_list_get_storage_name(inotify->notify.list,
struct mailbox_list_notify_rec *rec = &inotify->notify_rec;
const char *const *vnamep;
- memset(rec, 0, sizeof(*rec));
+ i_zero(rec);
vnamep = array_idx(&inotify->new_unsubscriptions, idx);
rec->vname = *vnamep;
rec->storage_name = mailbox_list_get_storage_name(inotify->notify.list,
rec->storage_name);
if (nnode == NULL) {
/* mailbox didn't exist earlier - report all events as new */
- memset(&empty_node, 0, sizeof(empty_node));
+ i_zero(&empty_node);
nnode = &empty_node;
}
if (nnode->uidvalidity != status.uidvalidity)
}
if (inotify->inbox_event_pending) {
inotify->inbox_event_pending = FALSE;
- memset(&inotify->notify_rec, 0, sizeof(inotify->notify_rec));
+ i_zero(&inotify->notify_rec);
inotify->notify_rec.vname = "INBOX";
inotify->notify_rec.storage_name = "INBOX";
/* Don't bother trying to figure out which event exactly this
uint32_t seq;
int ret;
- memset(first_saved_r, 0, sizeof(*first_saved_r));
+ i_zero(first_saved_r);
if ((ret = index_list_open_view(box, TRUE, &view, &seq)) <= 0)
return ret;
struct mailbox_metadata metadata;
uint32_t seq1, seq2;
- memset(changes_r, 0, sizeof(*changes_r));
+ i_zero(changes_r);
node = mailbox_list_index_lookup(box->list, box->name);
if (node == NULL)
mail_index_lookup_ext(list_view, changes->seq,
ilist->first_saved_ext_id, &data, &expunged);
if (data == NULL)
- memset(&first_saved, 0, sizeof(first_saved));
+ i_zero(&first_saved);
else
memcpy(&first_saved, data, sizeof(first_saved));
if (mail_index_view_get_messages_count(box->view) > 0)
struct mailbox_index_vsize old_vsize;
guid_128_t old_guid;
- memset(&old_status, 0, sizeof(old_status));
- memset(&old_vsize, 0, sizeof(old_vsize));
+ i_zero(&old_status);
+ i_zero(&old_vsize);
memset(old_guid, 0, sizeof(old_guid));
(void)mailbox_list_index_status(box->list, list_view, changes->seq,
CACHED_STATUS_ITEMS,
time_t save_date;
int ret = 0;
- memset(&first_saved, 0, sizeof(first_saved));
+ i_zero(&first_saved);
first_saved.timestamp = (uint32_t)-1;
if (changes->first_uid != 0) {
if (changes->msgs_changed) {
struct mailbox_list_index_msgs_record msgs;
- memset(&msgs, 0, sizeof(msgs));
+ i_zero(&msgs);
msgs.messages = changes->status.messages;
msgs.unseen = changes->status.unseen;
msgs.recent = changes->status.recent;
bool guid_changed = FALSE;
int ret;
- memset(&changes, 0, sizeof(changes));
+ i_zero(&changes);
if ((ret = index_list_open_view(box, TRUE, &list_view, &changes.seq)) <= 0)
return;
struct mailbox_list_index_record irec;
uint32_t seq;
- memset(&irec, 0, sizeof(irec));
+ i_zero(&irec);
irec.name_id = node->name_id;
if (node->parent != NULL)
irec.parent_uid = node->parent->uid;
i_assert(data != NULL && !expunged);
memcpy(&rec, data, sizeof(rec));
rec.uid_validity = 0;
- memset(&rec.guid, 0, sizeof(rec.guid));
+ i_zero(&rec.guid);
mail_index_update_ext(sync_ctx->trans, seq,
sync_ctx->ilist->ext_id, &rec, NULL);
}
if (ns->prefix_len == 0 || !mailbox_list_ns_prefix_match(ctx, ns))
return FALSE;
- memset(&ctx->ns_info, 0, sizeof(ctx->ns_info));
+ i_zero(&ctx->ns_info);
ctx->ns_info.ns = ns;
ctx->ns_info.vname = p_strndup(ctx->pool, ns->prefix,
ns->prefix_len-1);
ctx->autocreate_ctx;
enum imap_match_result match;
- memset(&actx->new_info, 0, sizeof(actx->new_info));
+ i_zero(&actx->new_info);
actx->new_info.ns = ctx->list->ns;
actx->new_info.vname = autobox->name;
actx->new_info.flags = autobox->flags;
if (!mail_index_lookup_seq(tree->view, nnode->index_uid, &seq))
return;
- memset(&status, 0, sizeof(status));
+ i_zero(&status);
(void)mailbox_list_index_status(tree->list, tree->view, seq,
STATUS_UIDVALIDITY | STATUS_UIDNEXT | STATUS_MESSAGES |
STATUS_UNSEEN | STATUS_HIGHESTMODSEQ, &status, nnode->guid, NULL);
struct mailbox_tree_iterate_context *iter;
const char *name;
- memset(&update_ctx, 0, sizeof(update_ctx));
+ i_zero(&update_ctx);
update_ctx.iter_ctx = ctx;
update_ctx.tree_ctx = tree;
update_ctx.glob = ctx->glob;
if (strcasecmp(name, "INBOX") == 0)
name = "INBOX";
- memset(&dotlock_set, 0, sizeof(dotlock_set));
+ i_zero(&dotlock_set);
dotlock_set.use_excl_lock = mail_set->dotlock_use_excl;
dotlock_set.nfs_flush = mail_set->mail_nfs_storage;
dotlock_set.temp_prefix = temp_prefix;
static void mail_search_arg_get_base_mask(const struct mail_search_arg *arg,
struct mail_search_simplify_prev_arg *mask_r)
{
- memset(mask_r, 0, sizeof(*mask_r));
+ i_zero(mask_r);
mask_r->bin_mask.type = arg->type;
mask_r->bin_mask.match_not = arg->match_not;
mask_r->bin_mask.fuzzy = arg->fuzzy;
struct mail_search_arg *sub, **all_argsp = argsp;
bool merged;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.parent_and = parent_and;
ctx.pool = pool_alloconly_create("mail search args simplify", 1024);
hash_table_create(&ctx.prev_args, ctx.pool, 0,
*args_r = NULL;
*error_r = NULL;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.args = args = mail_search_build_init();
ctx.pool = args->pool;
ctx.reg = reg;
{
struct mail_storage_module_hooks new_hook;
- memset(&new_hook, 0, sizeof(new_hook));
+ i_zero(&new_hook);
new_hook.module = module;
new_hook.hooks = hooks;
const char *new_username;
int ret;
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info.service = input->service != NULL ? input->service :
ctx->service->name;
info.local_ip = input->local_ip;
{
struct mail_storage_service_privileges priv;
- memset(&priv, 0, sizeof(priv));
+ i_zero(&priv);
priv.uid = (uid_t)-1;
priv.gid = (gid_t)-1;
return get_var_expand_table(ctx->service, NULL, input, &priv);
gid_t gid = (gid_t)-1;
const char *error;
- memset(priv_r, 0, sizeof(*priv_r));
+ i_zero(priv_r);
if (*set->mail_uid != '\0') {
if (!parse_uid(set->mail_uid, &uid, error_r)) {
*error_r = t_strdup_printf("%s (from %s)", *error_r,
flags = input == NULL ? ctx->flags :
mail_storage_service_input_get_flags(ctx, input);
- memset(&set_input, 0, sizeof(set_input));
+ i_zero(&set_input);
set_input.roots = ctx->set_roots;
set_input.preserve_user = TRUE;
/* settings reader may exec doveconf, which is going to clear
if ((ctx->flags & MAIL_STORAGE_SERVICE_FLAG_NO_PLUGINS) != 0)
return 0;
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.binary_name = master_service_get_name(ctx->service);
mod_set.setting_name = "mail_plugins";
timeout_remove(&storage->binary_cache.to);
i_stream_destroy(&storage->binary_cache.input);
- memset(&storage->binary_cache, 0, sizeof(storage->binary_cache));
+ i_zero(&storage->binary_cache);
}
void mailbox_close(struct mailbox *box)
static void mailbox_close_reset_path(struct mailbox *box)
{
- memset(&box->_perm, 0, sizeof(box->_perm));
+ i_zero(&box->_perm);
box->_path = NULL;
box->_index_path = NULL;
}
mailbox_get_status_set_defaults(struct mailbox *box,
struct mailbox_status *status_r)
{
- memset(status_r, 0, sizeof(*status_r));
+ i_zero(status_r);
if ((box->storage->class_flags & MAIL_STORAGE_CLASS_FLAG_HAVE_MAIL_GUIDS) != 0)
status_r->have_guids = TRUE;
if ((box->storage->class_flags & MAIL_STORAGE_CLASS_FLAG_HAVE_MAIL_SAVE_GUIDS) != 0)
int mailbox_get_metadata(struct mailbox *box, enum mailbox_metadata_items items,
struct mailbox_metadata *metadata_r)
{
- memset(metadata_r, 0, sizeof(*metadata_r));
+ i_zero(metadata_r);
if (mailbox_verify_existing_name(box) < 0)
return -1;
*_ctx = NULL;
- memset(status_r, 0, sizeof(*status_r));
+ i_zero(status_r);
ret = box->v.sync_deinit(ctx, status_r);
if (ret < 0 && box->inbox_user &&
!box->storage->user->inbox_open_error_logged) {
void mailbox_refresh_permissions(struct mailbox *box)
{
- memset(&box->_perm, 0, sizeof(box->_perm));
+ i_zero(&box->_perm);
(void)mailbox_get_permissions(box);
}
i_isdigit(str[5]) && i_isdigit(str[6]) && str[7] == '-' &&
i_isdigit(str[8]) && i_isdigit(str[9]) && str[10] == '\0') {
/* yyyy-mm-dd */
- memset(&tm, 0, sizeof(tm));
+ i_zero(&tm);
tm.tm_year = (str[0]-'0') * 1000 + (str[1]-'0') * 100 +
(str[2]-'0') * 10 + (str[3]-'0') - 1900;
tm.tm_mon = (str[5]-'0') * 10 + (str[6]-'0') - 1;
i_assert(!user->home_looked_up);
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info.service = user->service;
if (user->local_ip != NULL)
info.local_ip = *user->local_ip;
struct module *module;
size_t name_len = strlen(name);
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.binary_name = master_service_get_name(master_service);
mod_set.setting_name = "<built-in storage lookup>";
struct mailbox_attribute_internal dreg;
unsigned int insert_idx;
- memset(&dreg, 0, sizeof(dreg));
+ i_zero(&dreg);
dreg.type = type;
dreg.key = key;
plen--;
}
- memset(&dreg, 0, sizeof(dreg));
+ i_zero(&dreg);
dreg.type = type;
dreg.key = bare_prefix;
{
struct mail_attribute_value value;
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
return mailbox_attribute_set_common(t, type, key, &value);
}
struct mail_attribute_value *value_r)
{
int ret;
- memset(value_r, 0, sizeof(*value_r));
+ i_zero(value_r);
if ((ret = mailbox_attribute_get_common(box, type, key,
value_r)) <= 0)
return ret;
{
int ret;
- memset(value_r, 0, sizeof(*value_r));
+ i_zero(value_r);
value_r->flags |= MAIL_ATTRIBUTE_VALUE_FLAG_INT_STREAMS;
if ((ret = mailbox_attribute_get_common(box, type, key,
value_r)) <= 0)
void mailbox_list_settings_init_defaults(struct mailbox_list_settings *set_r)
{
- memset(set_r, 0, sizeof(*set_r));
+ i_zero(set_r);
set_r->mailbox_dir_name = "";
set_r->maildir_name = "";
set_r->list_index_fname = MAILBOX_LIST_INDEX_DEFAULT_PREFIX;
const char *path, *parent_name, *parent_path, *p;
struct stat st;
- memset(permissions_r, 0, sizeof(*permissions_r));
+ i_zero(permissions_r);
/* use safe defaults */
permissions_r->file_uid = (uid_t)-1;
stamp = list->changelog_timestamp != (time_t)-1 ?
list->changelog_timestamp : ioloop_time;
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
rec.type = type;
memcpy(rec.mailbox_guid, mailbox_guid, sizeof(rec.mailbox_guid));
mailbox_log_record_set_timestamp(&rec, stamp);
struct mailbox_list_fs_context *ctx;
struct fs *parent_fs;
- memset(&ssl_set, 0, sizeof(ssl_set));
- memset(&fs_set, 0, sizeof(fs_set));
+ i_zero(&ssl_set);
+ i_zero(&fs_set);
mail_user_init_fs_settings(list->ns->user, &fs_set, &ssl_set);
fs_set.root_path = root_dir;
fs_set.temp_file_prefix = mailbox_list_get_global_temp_prefix(list);
i_assert(sizeof(*buffer) >= sizeof(struct real_buffer));
buf = (struct real_buffer *)buffer;
- memset(buf, 0, sizeof(*buf));
+ i_zero(buf);
buf->alloc = size;
buf->r_buffer = buf->w_buffer = data;
/* clear the whole memory area. unnecessary usually, but if the
i_assert(sizeof(*buffer) >= sizeof(struct real_buffer));
buf = (struct real_buffer *)buffer;
- memset(buf, 0, sizeof(*buf));
+ i_zero(buf);
buf->used = buf->alloc = size;
buf->r_buffer = data;
void connection_disconnect(struct connection *conn)
{
conn->last_input = 0;
- memset(&conn->last_input_tv, 0, sizeof(conn->last_input_tv));
+ i_zero(&conn->last_input_tv);
if (conn->to != NULL)
timeout_remove(&conn->to);
if (conn->io != NULL)
struct failure_context ctx;
va_list args;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.type = LOG_TYPE_PANIC;
va_start(args, format);
struct failure_context ctx;
va_list args;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.type = LOG_TYPE_FATAL;
ctx.exit_status = FATAL_DEFAULT;
struct failure_context ctx;
va_list args;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.type = LOG_TYPE_FATAL;
ctx.exit_status = status;
void i_failure_parse_line(const char *line, struct failure_line *failure)
{
- memset(failure, 0, sizeof(*failure));
+ i_zero(failure);
if (!line_is_ok(line)) {
failure->log_type = LOG_TYPE_ERROR;
failure->text = line;
}
if (net_getpeername(fd, &raddr, &rport) < 0) {
- memset(&raddr, 0, sizeof(raddr));
+ i_zero(&raddr);
rport = 0;
}
i_error("Leaked socket fd %d: %s:%u -> %s:%u",
now + set->timeout;
tmp_path = t_str_new(256);
- memset(&lock_info, 0, sizeof(lock_info));
+ i_zero(&lock_info);
lock_info.path = dotlock->path;
lock_info.set = set;
lock_info.lock_path = lock_path;
{
struct flock fl;
- memset(&fl, 0, sizeof(fl));
+ i_zero(&fl);
fl.l_type = lock_type;
fl.l_whence = SEEK_SET;
fl.l_start = 0;
/* OSX */
fstore_t fs;
- memset(&fs, 0, sizeof(fs));
+ i_zero(&fs);
fs.fst_flags = F_ALLOCATECONTIG;
fs.fst_posmode = F_PEOFPOSMODE;
fs.fst_offset = 0;
first = ioloop_iolist_add(*list, io);
- memset(&event, 0, sizeof(event));
+ i_zero(&event);
event.data.ptr = *list;
event.events = epoll_event_mask(*list);
last = ioloop_iolist_del(*list, io);
if (!closed) {
- memset(&event, 0, sizeof(event));
+ i_zero(&event);
event.data.ptr = *list;
event.events = epoll_event_mask(*list);
{
struct ioloop_context_callback cb;
- memset(&cb, 0, sizeof(cb));
+ i_zero(&cb);
cb.activate = activate;
cb.deactivate = deactivate;
cb.context = context;
struct iso8601_date_parser parser;
time_t timestamp;
- memset(&parser, 0, sizeof(parser));
+ i_zero(&parser);
parser.cur = data;
parser.end = data + size;
ret = i_stream_sized_parent_read(stream, &pos);
}
- memset(&data, 0, sizeof(data));
+ i_zero(&data);
data.v_offset = stream->istream.v_offset;
data.new_bytes = pos;
data.wanted_size = sstream->size;
if (_stream->init_buffer_size == 0)
_stream->init_buffer_size = I_STREAM_MIN_SIZE;
- memset(&_stream->statbuf, 0, sizeof(_stream->statbuf));
+ i_zero(&_stream->statbuf);
_stream->statbuf.st_size = -1;
_stream->statbuf.st_atime =
_stream->statbuf.st_mtime =
if (si == NULL) {
/* Solaris can leave this to NULL */
- memset(&tmp_si, 0, sizeof(tmp_si));
+ i_zero(&tmp_si);
tmp_si.si_signo = signo;
tmp_si.si_code = SI_NOINFO;
si = &tmp_si;
result[14] = ctx->d >> 16;
result[15] = ctx->d >> 24;
- safe_memset(ctx, 0, sizeof(*ctx));
+ i_zero_safe(ctx);
}
void md4_get_digest(const void *data, size_t size,
result[14] = ctx->d >> 16;
result[15] = ctx->d >> 24;
- safe_memset(ctx, 0, sizeof(*ctx));
+ i_zero_safe(ctx);
}
void md5_get_digest(const void *data, size_t size,
#endif
/* create a fake alloconly_pool so we can call block_alloc() */
- memset(&apool, 0, sizeof(apool));
+ i_zero(&apool);
apool.pool = static_alloconly_pool;
apool.refcount = 1;
{
struct statvfs buf;
- memset(point_r, 0, sizeof(*point_r));
+ i_zero(point_r);
if (statvfs(path, &buf) < 0) {
if (errno == ENOENT)
return 0;
int mountpoint_get(const char *path, pool_t pool, struct mountpoint *point_r)
{
#ifdef MOUNTPOINT_UNKNOWN
- memset(point_r, 0, sizeof(*point_r));
+ i_zero(point_r);
errno = ENOSYS;
return -1;
#elif defined (MOUNTPOINT_STATVFS)
const struct mountpoint *mnt;
struct stat st;
- memset(point_r, 0, sizeof(*point_r));
+ i_zero(point_r);
if (stat(path, &st) < 0) {
if (errno == ENOENT)
return 0;
vmt_object = vmt_base + vmt->vmt_data[VMT_OBJECT].vmt_off;
vmt_stub = vmt_base + vmt->vmt_data[VMT_STUB].vmt_off;
- memset(&iter->mnt, 0, sizeof(iter->mnt));
+ i_zero(&iter->mnt);
switch (vmt->vmt_gfstype) {
case MNT_NFS:
case MNT_NFS3:
if (iter->f == NULL)
return NULL;
- memset(&iter->mnt, 0, sizeof(iter->mnt));
+ i_zero(&iter->mnt);
while ((getextmntent(iter->f, &ent.ext, sizeof(ent.ext))) == 0) {
if (hasmntopt(&ent.ent, MNTOPT_IGNORE) != NULL)
continue;
if (iter->f == NULL)
return NULL;
- memset(&iter->mnt, 0, sizeof(iter->mnt));
+ i_zero(&iter->mnt);
while ((ent = getmntent(iter->f)) != NULL) {
if (strcmp(ent->mnt_type, MNTTYPE_SWAP) == 0 ||
strcmp(ent->mnt_type, MNTTYPE_IGNORE) == 0 ||
{
/* IP structs may be sent across processes. Clear the whole struct
first to make sure it won't leak any data across processes. */
- memset(ip, 0, sizeof(*ip));
+ i_zero(ip);
ip->family = so->sin.sin_family;
if (ip->family == AF_INET)
memcpy(&ip->u.ip4, &so->sin.sin_addr, sizeof(ip->u.ip4));
else
- memset(&ip->u, 0, sizeof(ip->u));
+ i_zero(&ip->u);
}
static inline void sin_set_port(union sockaddr_union *so, in_port_t port)
}
/* create the socket */
- memset(&so, 0, sizeof(so));
+ i_zero(&so);
so.sin.sin_family = ip->family;
fd = socket(ip->family, sock_type, 0);
int fd;
/* create the socket */
- memset(&so, 0, sizeof(so));
+ i_zero(&so);
so.sin.sin_family = ip->family;
fd = socket(ip->family, SOCK_STREAM, 0);
if (fd == -1) {
union sockaddr_union_unix sa;
int fd, ret;
- memset(&sa, 0, sizeof(sa));
+ i_zero(&sa);
sa.un.sun_family = AF_UNIX;
if (i_strocpy(sa.un.sun_path, path, sizeof(sa.un.sun_path)) < 0) {
/* too long path */
int ret, fd, opt = 1;
socklen_t len;
- memset(&so, 0, sizeof(so));
+ i_zero(&so);
sin_set_port(&so, *port);
sin_set_ip(&so, my_ip);
} sa;
int fd;
- memset(&sa, 0, sizeof(sa));
+ i_zero(&sa);
sa.un.sun_family = AF_UNIX;
if (i_strocpy(sa.un.sun_path, path, sizeof(sa.un.sun_path)) < 0) {
/* too long path */
}
if (so.sin.sin_family == AF_UNIX) {
if (addr_r != NULL)
- memset(addr_r, 0, sizeof(*addr_r));
+ i_zero(addr_r);
if (port_r != NULL) *port_r = 0;
} else {
if (addr_r != NULL) sin_get_ip(&so, addr_r);
return 0;
}
- memset(&hints, 0, sizeof(hints));
+ i_zero(&hints);
hints.ai_socktype = SOCK_STREAM;
/* save error to host_error for later use */
char hbuf[NI_MAXHOST];
int ret;
- memset(&so, 0, sizeof(so));
+ i_zero(&so);
sin_set_ip(&so, ip);
ret = getnameinfo(&so.sa, addrlen, hbuf, sizeof(hbuf), NULL, 0,
NI_NAMEREQD);
return -1;
if (so.sin.sin_family == AF_UNIX) {
if (addr != NULL)
- memset(addr, 0, sizeof(*addr));
+ i_zero(addr);
if (port != NULL) *port = 0;
} else {
if (addr != NULL) sin_get_ip(&so, addr);
return -1;
if (so.sin.sin_family == AF_UNIX) {
if (addr != NULL)
- memset(addr, 0, sizeof(*addr));
+ i_zero(addr);
if (port != NULL) *port = 0;
} else {
if (addr != NULL) sin_get_ip(&so, addr);
sc = (struct sockcred *)cdata.buf;
sc->sc_uid = sc->sc_euid = sc->sc_gid = sc->sc_egid = -1;
- memset(&cdata.ch, 0, sizeof(cdata.ch));
+ i_zero(&cdata.ch);
- memset(&msg, 0, sizeof(msg));
+ i_zero(&msg);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
{
struct const_iovec iov;
- memset(&iov, 0, sizeof(iov));
+ i_zero(&iov);
iov.iov_base = data;
iov.iov_len = size;
{
struct const_iovec iov;
- memset(&iov, 0, sizeof(iov));
+ i_zero(&iov);
iov.iov_base = data;
iov.iov_len = size;
void restrict_access_init(struct restrict_access_settings *set)
{
- memset(set, 0, sizeof(*set));
+ i_zero(set);
set->uid = (uid_t)-1;
set->gid = (gid_t)-1;
return 0;
}
- memset(&hdtr, 0, sizeof(hdtr));
+ i_zero(&hdtr);
ret = sendfile(in_fd, out_fd, *offset, count, &hdtr, &sbytes, 0);
*offset += sbytes;
void seq_range_array_iter_init(struct seq_range_iter *iter_r,
const ARRAY_TYPE(seq_range) *array)
{
- memset(iter_r, 0, sizeof(*iter_r));
+ i_zero(iter_r);
iter_r->array = array;
}
void sha3_256_init(void *context)
{
struct sha3_ctx *ctx = context;
- memset(ctx, 0, sizeof(*ctx));
+ i_zero(ctx);
ctx->capacityWords = 2 * 256 / (8 * sizeof(uint64_t));
}
void sha3_512_init(void *context)
{
struct sha3_ctx *ctx = context;
- memset(ctx, 0, sizeof(*ctx));
+ i_zero(ctx);
ctx->capacityWords = 2 * 512 / (8 * sizeof(uint64_t));
}
return;
}
- memset(&test_ctx, 0, sizeof(test_ctx));
+ i_zero(&test_ctx);
struct ioloop *ioloop = io_loop_create();
bool success;
for (i = 0; i < N_ELEMENTS(input); i++) {
- memset(&tm, 0, sizeof(tm));
+ i_zero(&tm);
tm.tm_year = input[i].year - 1900;
tm.tm_mon = input[i].month - 1;
tm.tm_mday = input[i].day;
void timing_reset(struct timing *timing)
{
- memset(timing, 0, sizeof(*timing));
+ i_zero(timing);
}
void timing_add_usecs(struct timing *timing, uint64_t usecs)
*/
if (host != NULL)
- memset(host, 0, sizeof(*host));
+ i_zero(host);
literal = uri_parser_get_tmpbuf(parser, 256);
*/
if (auth != NULL)
- memset(auth, 0, sizeof(*auth));
+ i_zero(auth);
/* Scan ahead to check whether there is a [userinfo "@"] uri component */
for (p = parser->cur; p < parser->end; p++){
if (path_r != NULL)
p_array_init(&segments, parser->pool, 16);
else
- memset(&segments, 0, sizeof(segments));
+ i_zero(&segments);
/* check for a leading '/' and indicate absolute path
when it is present
struct uri_parser parser;
int ret;
- memset(&parser, 0, sizeof(parser));
+ i_zero(&parser);
parser.pool = pool_datastack_create();
parser.begin = parser.cur = data;
parser.end = data + size;
*error_r = NULL;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
for (; *str != '\0'; str++) {
if (*str != '%')
str_append_c(dest, *str);
int sign = 1;
str++;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
/* [<offset>.]<width>[<modifiers>]<variable> */
if (*str == '-') {
struct lda_settings *lda_set;
const char *error;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = input.service = "lmtp";
input.local_ip = client->local_ip;
input.remote_ip = client->remote_ip;
i_error("close(mail data fd) failed: %m");
}
- memset(&client->state, 0, sizeof(client->state));
+ i_zero(&client->state);
p_clear(client->state_pool);
client->state.mail_data_fd = -1;
pool_t pool;
int ret;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = input.service = "lmtp";
mail_storage_service_init_settings(storage_service, &input);
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info.service = master_service_get_name(master_service);
info.local_ip = client->local_ip;
info.remote_ip = client->remote_ip;
}
}
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.port = client->local_port;
set.protocol = LMTP_CLIENT_PROTOCOL_LMTP;
set.timeout_msecs = LMTP_PROXY_DEFAULT_TIMEOUT_MSECS;
if (client->proxy == NULL) {
struct lmtp_proxy_settings proxy_set;
- memset(&proxy_set, 0, sizeof(proxy_set));
+ i_zero(&proxy_set);
proxy_set.my_hostname = client->my_domain;
proxy_set.dns_client_socket_path = dns_client_socket_path;
proxy_set.session_id = client->state.session_id;
array_count(&client->state.rcpt_to)+1);
}
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = input.service = "lmtp";
input.username = username;
input.local_ip = client->local_ip;
}
i_set_failure_prefix("%s", str_c(str));
- memset(&dctx, 0, sizeof(dctx));
+ i_zero(&dctx);
dctx.session = session;
dctx.pool = session->pool;
dctx.set = lda_set;
return conn;
}
- memset(&client_set, 0, sizeof(client_set));
+ i_zero(&client_set);
client_set.mail_from = proxy->mail_from;
client_set.my_hostname = proxy->set.my_hostname;
client_set.dns_client_socket_path = proxy->set.dns_client_socket_path;
struct master_service_settings_input input;
struct master_service_settings_output output;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = "lmtp";
input.service = "lmtp";
(void)master_service_settings_read(master_service,
struct master_service_connection conn;
if (IS_STANDALONE()) {
- memset(&conn, 0, sizeof(conn));
+ i_zero(&conn);
(void)client_create(STDIN_FILENO, STDOUT_FILENO, &conn);
}
dns_client_socket_path = i_strdup(t_abspath(DNS_CLIENT_SOCKET_PATH));
case LOG_TYPE_ERROR:
case LOG_TYPE_FATAL:
case LOG_TYPE_PANIC:
- memset(&err, 0, sizeof(err));
+ i_zero(&err);
err.type = ctx->type;
err.timestamp = log_time->tv_sec;
err.prefix = prefix;
struct failure_context failure_ctx;
const char *prefix = log->default_prefix;
- memset(&failure_ctx, 0, sizeof(failure_ctx));
+ i_zero(&failure_ctx);
failure_ctx.type = LOG_TYPE_FATAL;
failure_ctx.timestamp = tm;
failure_ctx.timestamp_usecs = log_time->tv_usec;
}
i_assert(failure.log_type < LOG_TYPE_COUNT);
- memset(&failure_ctx, 0, sizeof(failure_ctx));
+ i_zero(&failure_ctx);
failure_ctx.type = failure.log_type;
failure_ctx.timestamp = tm;
failure_ctx.timestamp_usecs = log_time->tv_usec;
ARRAY_TYPE(const_string) alt_usernames;
t_array_init(&alt_usernames, 4);
- memset(reply_r, 0, sizeof(*reply_r));
+ i_zero(reply_r);
for (; *args != NULL; args++) {
p = strchr(*args, '=');
return -1;
}
- memset(&proxy_set, 0, sizeof(proxy_set));
+ i_zero(&proxy_set);
proxy_set.host = reply->host;
if (reply->hostip != NULL &&
net_addr2ip(reply->hostip, &proxy_set.ip) < 0)
sasl_reply == SASL_SERVER_REPLY_MASTER_FAILED);
client->last_auth_fail = CLIENT_AUTH_FAIL_CODE_NONE;
- memset(&reply, 0, sizeof(reply));
+ i_zero(&reply);
switch (sasl_reply) {
case SASL_SERVER_REPLY_SUCCESS:
if (client->to_auth_waiting != NULL)
{
struct login_proxy_record *rec, key;
- memset(&key, 0, sizeof(key));
+ i_zero(&key);
key.ip = *ip;
key.port = port;
void **sets;
unsigned int i, count;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = login_set_roots;
input.module = login_binary->process_name;
input.service = login_binary->protocol;
if (global_login_settings->login_plugins[0] == '\0')
return;
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.binary_name = login_binary->process_name;
mod_set.setting_name = "login_plugins";
buffer_t *buf;
const char *session_id = client_get_session_id(client);
- memset(&req, 0, sizeof(req));
+ i_zero(&req);
req.auth_pid = anvil_request->auth_pid;
req.auth_id = anvil_request->auth_id;
req.local_ip = client->local_ip;
client->auth_finished = ioloop_time;
client->master_auth_id = req.auth_id;
- memset(¶ms, 0, sizeof(params));
+ i_zero(¶ms);
params.client_fd = client->fd;
params.socket_path = client->postlogin_socket_path;
params.request = req;
return;
}
- memset(&info, 0, sizeof(info));
+ i_zero(&info);
info.mech = mech->name;
info.service = service;
info.session_id = client_get_session_id(client);
{
struct ssl_server_context *ctx, lookup_ctx;
- memset(&lookup_ctx, 0, sizeof(lookup_ctx));
+ i_zero(&lookup_ctx);
lookup_ctx.cert = set->ssl_cert;
lookup_ctx.key = set->ssl_key;
lookup_ctx.ca = set->ssl_ca;
initialized though. */
(void)RAND_bytes(&buf, 1);
- memset(&ssl_params, 0, sizeof(ssl_params));
+ i_zero(&ssl_params);
ssl_proxy_count = 0;
ssl_proxies = NULL;
}
}
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.module = MASTER_SERVICE_NAME;
input.config_path = services_get_config_socket_path(services);
struct master_service_settings_output output;
const char *error;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.module = "master";
input.parse_full_config = TRUE;
if (fd < 0)
return -EINVAL;
- memset(&st_fd, 0, sizeof(st_fd));
+ i_zero(&st_fd);
if (fstat(fd, &st_fd) < 0)
return -errno;
if (path) {
struct stat st_path;
- memset(&st_path, 0, sizeof(st_path));
+ i_zero(&st_path);
if (stat(path, &st_path) < 0) {
if (errno == ENOENT || errno == ENOTDIR)
union sockaddr_union sockaddr;
socklen_t l;
- memset(&sockaddr, 0, sizeof(sockaddr));
+ i_zero(&sockaddr);
l = sizeof(sockaddr);
if (getsockname(fd, &sockaddr.sa, &l) < 0)
if ((r = sd_is_socket_internal(fd, type, listening)) <= 0)
return r;
- memset(&sockaddr, 0, sizeof(sockaddr));
+ i_zero(&sockaddr);
l = sizeof(sockaddr);
if (getsockname(fd, &sockaddr.sa, &l) < 0)
if ((r = sd_is_socket_internal(fd, type, listening)) <= 0)
return r;
- memset(&sockaddr, 0, sizeof(sockaddr));
+ i_zero(&sockaddr);
l = sizeof(sockaddr);
if (getsockname(fd, &sockaddr.sa, &l) < 0)
goto finish;
}
- memset(&sockaddr, 0, sizeof(sockaddr));
+ i_zero(&sockaddr);
sockaddr.sa.sa_family = AF_UNIX;
strncpy(sockaddr.un.sun_path, e, sizeof(sockaddr.un.sun_path));
if (sockaddr.un.sun_path[0] == '@')
sockaddr.un.sun_path[0] = 0;
- memset(&iovec, 0, sizeof(iovec));
+ i_zero(&iovec);
iovec.iov_base = (char*) state;
iovec.iov_len = strlen(state);
- memset(&msghdr, 0, sizeof(msghdr));
+ i_zero(&msghdr);
msghdr.msg_name = &sockaddr;
msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + strlen(e);
if (port) *port = -1;
if (family) *family = -1;
- memset(&sockaddr, 0, sizeof(sockaddr));
+ i_zero(&sockaddr);
l = sizeof(sockaddr);
if (getsockname(fd, &sockaddr.sa, &l) < 0)
fd_close_on_exec(log_fd[0], TRUE);
fd_close_on_exec(log_fd[1], TRUE);
- memset(&handshake, 0, sizeof(handshake));
+ i_zero(&handshake);
handshake.log_magic = MASTER_LOG_MAGIC;
handshake.prefix_len = strlen(log_prefix);
dec2str(process->pid));
/* assume this process is busy */
- memset(&status, 0, sizeof(status));
+ i_zero(&status);
service_status_more(process, &status);
process->available_count = 0;
} else {
id_str = t_strdup_until(id_str, line++);
}
- memset(rights_r, 0, sizeof(*rights_r));
+ i_zero(rights_r);
right_names = acl_right_names_parse(pool, line, &error);
if (*id_str != '-')
void acl_rights_dup(const struct acl_rights *src,
pool_t pool, struct acl_rights *dest_r)
{
- memset(dest_r, 0, sizeof(*dest_r));
+ i_zero(dest_r);
dest_r->id_type = src->id_type;
dest_r->identifier = p_strdup(pool, src->identifier);
dest_r->rights = src->rights == NULL ? NULL :
struct acl_rights_update ru;
const char *null = NULL;
- memset(&ru, 0, sizeof(ru));
+ i_zero(&ru);
ru.modify_mode = ACL_MODIFY_MODE_REPLACE;
ru.neg_modify_mode = ACL_MODIFY_MODE_REPLACE;
ru.rights.id_type = ACL_ID_OWNER;
ACLs are merged. In all other situations the ACLs are replaced
(because there aren't duplicate rights entries and a user can't
match multiple usernames). */
- memset(&ru, 0, sizeof(ru));
+ i_zero(&ru);
rights = array_get(&aclobj->rights, &count);
if (!acl_backend_user_is_owner(aclobj->backend))
i = 0;
static const char *null = NULL;
struct acl_rights rights;
- memset(&rights, 0, sizeof(rights));
+ i_zero(&rights);
rights.id_type = ACL_ID_ANYONE;
rights.rights = &null;
array_append(&aclobj->rights, &rights, 1);
&value_str) < 0)
return -1;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
update.modify_mode = ACL_MODIFY_MODE_REPLACE;
update.neg_modify_mode = ACL_MODIFY_MODE_REPLACE;
update.last_change = value->last_change;
const char *id;
int ret;
- memset(value_r, 0, sizeof(*value_r));
+ i_zero(value_r);
if (!box->storage->user->dsyncing) {
mail_storage_set_error(box->storage, MAIL_ERROR_PERM,
can use this information) */
(void)acl_object_last_changed(aclobj, &value_r->last_change);
- memset(&wanted_rights, 0, sizeof(wanted_rights));
+ i_zero(&wanted_rights);
id = key + strlen(MAILBOX_ATTRIBUTE_PREFIX_ACL);
if (acl_identifier_parse(id, &wanted_rights) < 0) {
mail_storage_set_error(box->storage, MAIL_ERROR_PARAMS,
return FALSE;
}
- memset(&right, 0, sizeof(right));
+ i_zero(&right);
right.id_type = update->rights.id_type;
right.identifier = p_strdup(aclobj->rights_pool,
update->rights.identifier);
if (old_validity != NULL)
new_validity = *old_validity;
else
- memset(&new_validity, 0, sizeof(new_validity));
+ i_zero(&new_validity);
/* See if the mailbox exists. If we wanted recursive lookups we could
skip this, but at least for now we assume that if an existing
p_clear(_aclobj->rights_pool);
}
- memset(&validity, 0, sizeof(validity));
+ i_zero(&validity);
if (_aclobj->backend->global_file != NULL)
acl_object_add_global_acls(_aclobj);
else {
array_clear(&file->rights);
p_clear(file->rights_pool);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.file = file;
i_array_init(&ctx.parse_rights, 32);
if (uri != NULL) {
struct dict_settings dict_set;
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.username = "";
dict_set.base_dir = user->set->base_dir;
if (dict_init(uri, &dict_set, &dict->dict, &error) < 0)
return;
/* no LOOKUP right by default, we can optimize this */
- memset(&update_ctx, 0, sizeof(update_ctx));
+ i_zero(&update_ctx);
update_ctx.iter_ctx = &ctx->ctx;
update_ctx.glob =
imap_match_init(pool_datastack_create(), "*",
struct acl_object_list_iter *iter;
struct acl_rights_update update;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
update.modify_mode = ACL_MODIFY_MODE_REPLACE;
update.neg_modify_mode = ACL_MODIFY_MODE_REPLACE;
if (cmd_acl_mailbox_open(_ctx, user, mailbox, &box) < 0)
return -1;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
update.modify_mode = ctx->modify_mode;
update.neg_modify_mode = ctx->modify_mode;
if (acl_rights_update_import(&update, id, rights, &error) < 0)
if (cmd_acl_mailbox_open(ctx, user, mailbox, &box) < 0)
return -1;
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
if (acl_rights_update_import(&update, id, NULL, &error) < 0)
i_fatal_status(EX_USAGE, "%s", error);
if ((ret = cmd_acl_mailbox_update(box, &update)) < 0) {
return "Missing attributes for pattern variables";
}
array_append(&ctx->set->maps, &ctx->cur_map, 1);
- memset(&ctx->cur_map, 0, sizeof(ctx->cur_map));
+ i_zero(&ctx->cur_map);
return NULL;
}
{
struct setting_parser_ctx ctx;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.pool = pool;
ctx.set = p_new(pool, struct dict_ldap_settings, 1);
t_array_init(&ctx.cur_attributes, 16);
int dict_ldap_connect(struct ldap_dict *dict, const char **error_r)
{
struct ldap_client_settings set;
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.uri = dict->set->uri;
set.bind_dn = dict->set->bind_dn;
set.password = dict->set->password;
op->map = map;
attributes[0] = map->value_attribute;
/* build lookup */
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.base_dn = map->base_dn;
input.scope = map->scope_val;
if (!ldap_dict_build_query(ctx, map, &values, strncmp(key, DICT_PATH_PRIVATE, strlen(DICT_PATH_PRIVATE))==0, query, &error)) {
struct expire_query query;
bool have_or = FALSE;
- memset(&query, 0, sizeof(query));
+ i_zero(&query);
query.before_time = (time_t)-1;
for (arg = args; arg != NULL; arg = arg->next) {
if (doveadm_debug)
i_debug("expire: Searching only users listed in expire database");
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.value_type = DICT_DATA_TYPE_UINT32;
dict_set.username = "";
dict_set.base_dir = doveadm_settings->base_dir;
if (dict_transaction_commit(&dctx, &error) < 0)
i_error("expire: dict commit failed: %s", error);
else if (euser->expire_cache) {
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
hdr.timestamp = timestamp;
trans = mail_index_transaction_begin(box->view,
return;
}
/* we're using only shared dictionary, the username doesn't matter. */
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.value_type = DICT_DATA_TYPE_UINT32;
dict_set.username = "";
dict_set.base_dir = user->set->base_dir;
const struct lucene_index_record *rec;
bool first = TRUE;
- memset(&prev_guid, 0, sizeof(prev_guid));
+ i_zero(&prev_guid);
index = lucene_index_init(argv[1], NULL, NULL);
iter = lucene_index_iter_init(index);
while ((rec = lucene_index_iter_next(iter)) != NULL) {
return field->value;
}
- memset(&new_field, 0, sizeof(new_field));
+ i_zero(&new_field);
new_field.key = str_lcase(i_strdup(key));
new_field.value = str_new(default_pool, 128);
array_append(&ctx->fields, &new_field, 1);
conn->debug = debug;
if (solr_http_client == NULL) {
- memset(&http_set, 0, sizeof(http_set));
+ i_zero(&http_set);
http_set.max_idle_time_msecs = 5*1000;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
const char *url;
int parse_ret;
- memset(&solr_lookup_context, 0, sizeof(solr_lookup_context));
+ i_zero(&solr_lookup_context);
solr_lookup_context.result_pool = pool;
hash_table_create(&solr_lookup_context.mailboxes, default_pool, 0,
str_hash, strcmp);
{
trie->corrupted = FALSE;
node_free(trie, &trie->root);
- memset(&trie->root, 0, sizeof(trie->root));
- memset(&trie->hdr, 0, sizeof(trie->hdr));
+ i_zero(&trie->root);
+ i_zero(&trie->hdr);
squat_trie_close_fd(trie);
if (trie->file_cache != NULL)
static void squat_trie_header_init(struct squat_trie *trie)
{
- memset(&trie->hdr, 0, sizeof(trie->hdr));
+ i_zero(&trie->hdr);
trie->hdr.version = SQUAT_TRIE_VERSION;
trie->hdr.indexid = time(NULL);
trie->hdr.uidvalidity = trie->uidvalidity;
if (shift_count != 0)
i_array_init(&ctx->cur.shifts, shift_count);
else
- memset(&ctx->cur.shifts, 0, sizeof(ctx->cur.shifts));
+ i_zero(&ctx->cur.shifts);
return squat_trie_iterate_first(ctx);
}
if (changed || trie->hdr.root_offset == 0) {
node_free(trie, &trie->root);
- memset(&trie->root, 0, sizeof(trie->root));
+ i_zero(&trie->root);
trie->root.want_sequential = TRUE;
trie->root.unused_uids = trie->hdr.root_unused_uids;
trie->root.next_uid = trie->hdr.root_next_uid;
array_clear(definite_uids);
array_clear(maybe_uids);
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.trie = trie;
ctx.type = type;
ctx.definite_uids = definite_uids;
uidlist->fd = open(uidlist->path, O_RDWR);
if (uidlist->fd == -1) {
if (errno == ENOENT) {
- memset(&uidlist->hdr, 0, sizeof(uidlist->hdr));
+ i_zero(&uidlist->hdr);
return 0;
}
i_error("open(%s) failed: %m", uidlist->path);
}
if (uidlist->locked_file_size == 0) {
/* write using 0 until we're finished */
- memset(&uidlist->hdr, 0, sizeof(uidlist->hdr));
+ i_zero(&uidlist->hdr);
if (write_full(uidlist->fd, &uidlist->hdr,
sizeof(uidlist->hdr)) < 0) {
i_error("write(%s) failed: %m", uidlist->path);
if (ctx->output->offset == 0) {
struct squat_uidlist_file_header hdr;
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
o_stream_nsend(ctx->output, &hdr, sizeof(hdr));
}
o_stream_cork(ctx->output);
ctx->next_uid_list_idx = 0x100;
o_stream_cork(ctx->output);
- memset(&hdr, 0, sizeof(hdr));
+ i_zero(&hdr);
o_stream_nsend(ctx->output, &hdr, sizeof(hdr));
ctx->cur_block_start_offset = ctx->output->offset;
return -1;
}
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
i_array_init(&result.definite_uids, 16);
i_array_init(&result.maybe_uids, 16);
i_array_init(&result.scores, 16);
mail_index_get_header_ext(view, fts_index_get_ext_id(box),
&data, &data_size);
if (data_size < sizeof(*hdr_r)) {
- memset(hdr_r, 0, sizeof(*hdr_r));
+ i_zero(hdr_r);
ret = FALSE;
} else {
memcpy(hdr_r, data, data_size);
/* hdr->full_value is always set because we get the block from
message_decoder */
- memset(&key, 0, sizeof(key));
+ i_zero(&key);
key.uid = ctx->mail->uid;
key.type = block->part->physical_pos == 0 ?
FTS_BACKEND_BUILD_KEY_HDR : FTS_BACKEND_BUILD_KEY_MIME_HDR;
i_assert(ctx->body_parser == NULL);
*binary_body_r = FALSE;
- memset(&key, 0, sizeof(key));
+ i_zero(&key);
key.uid = ctx->mail->uid;
key.part = part;
int ret = 0;
do {
- memset(&block, 0, sizeof(block));
+ i_zero(&block);
fts_parser_more(ctx->body_parser, &block);
if (fts_build_body_block(ctx, &block, FALSE) < 0) {
ret = -1;
return -1;
}
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.update_ctx = update_ctx;
ctx.mail = mail;
if ((update_ctx->backend->flags & FTS_BACKEND_FLAG_TOKENIZED_INPUT) != 0)
}
if (tika_http_client == NULL) {
- memset(&http_set, 0, sizeof(http_set));
+ i_zero(&http_set);
http_set.max_idle_time_msecs = 100;
http_set.max_parallel_connections = 1;
http_set.max_pipelined_requests = 1;
struct fts_search_level *level;
struct fts_result result;
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
p_array_init(&result.definite_uids, fctx->result_pool, 32);
p_array_init(&result.maybe_uids, fctx->result_pool, 32);
p_array_init(&result.scores, fctx->result_pool, 32);
&mailboxes_arr, TRUE);
array_sort(&mailboxes_arr, mailbox_cmp_fts_backend);
- memset(&result, 0, sizeof(result));
+ i_zero(&result);
result.pool = fctx->result_pool;
level = array_append_space(&fctx->levels);
parser = fts_parser_html.try_init(NULL, "text/html", NULL);
i_assert(parser != NULL);
- memset(&block, 0, sizeof(block));
+ i_zero(&block);
while ((ret = read(STDIN_FILENO, buf, sizeof(buf))) > 0) {
block.data = buf;
block.size = ret;
if (!seen_positive_owner && username != NULL && add_default) {
/* no positive owner rights returned, write default ACLs */
- memset(&rights, 0, sizeof(rights));
+ i_zero(&rights);
if (!convert_owner) {
rights.id_type = ACL_ID_OWNER;
} else {
return TRUE;
}
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
if (*identifier == '-') {
negative = TRUE;
identifier++;
return TRUE;
}
- memset(&update, 0, sizeof(update));
+ i_zero(&update);
if (*identifier != '-')
update.modify_mode = ACL_MODIFY_MODE_CLEAR;
else {
if (dict_value == NULL || dict_value[0] == '\0')
return;
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.username = user->username;
set.base_dir = user->set->base_dir;
if (mail_user_get_home(user, &set.home_dir) <= 0)
if ((cur_ioloop_ctx = io_loop_get_current_context(current_ioloop)) != NULL)
io_loop_context_deactivate(cur_ioloop_ctx);
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = old_input->module;
input.service = old_input->service;
input.username = dest_username;
struct mailbox *box =
mailbox_alloc(ns->list, "INBOX", MAILBOX_FLAG_READONLY);
struct mail_attribute_value value;
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
if ((ret = mailbox_attribute_get(box, MAIL_ATTRIBUTE_TYPE_SHARED,
USER_CRYPT_PREFIX
mailbox_alloc(info->ns->list,
info->vname, MAILBOX_FLAG_READONLY);
struct mail_attribute_value value;
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
array_clear(&ids);
/* get active ID */
struct mcp_cmd_context *ctx =
(struct mcp_cmd_context *)_ctx;
struct mcp_key_iter_ctx iter_ctx;
- memset(&iter_ctx, 0, sizeof(iter_ctx));
+ i_zero(&iter_ctx);
iter_ctx.pool = _ctx->pool;
p_array_init(&iter_ctx.keys, _ctx->pool, 8);
dcrypt_key_unref_private(&key);
if (ret == -1) break;
- memset(&value, 0, sizeof(value));
+ i_zero(&value);
value.value = str_c(newkey);
/* and store it */
if ((cur_ioloop_ctx = io_loop_get_current_context(current_ioloop)) != NULL)
io_loop_context_deactivate(cur_ioloop_ctx);
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = old_input->module;
input.service = old_input->service;
input.username = dest_username;
void mail_crypt_global_keys_init(struct mail_crypt_global_keys *global_keys_r)
{
- memset(global_keys_r, 0, sizeof(*global_keys_r));
+ i_zero(global_keys_r);
i_array_init(&global_keys_r->private_keys, 4);
}
timeout_remove(&cache->to);
if (cache->input != NULL)
i_stream_unref(&cache->input);
- memset(cache, 0, sizeof(*cache));
+ i_zero(cache);
}
static struct istream *
struct master_service_settings_output output;
const char *error;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.roots = set_roots;
input.module = "fs-crypt";
input.service = "fs-crypt";
test_begin("try_load_keys");
struct mail_crypt_global_keys keys;
- memset(&keys, 0, sizeof(keys));
+ i_zero(&keys);
mail_crypt_global_keys_init(&keys);
const char *set_prefix = "mail_crypt_global";
/* this should not crash */
struct mail_crypt_global_keys keys;
- memset(&keys, 0, sizeof(keys));
+ i_zero(&keys);
test_assert(mail_crypt_global_key_find(&keys, "423423423423") == NULL);
test_end();
int ret;
- memset(&attr_value, 0, sizeof(attr_value));
+ i_zero(&attr_value);
attr_value.value = value;
if ((ret = mailbox_attribute_set(t, attr_type,
struct sha1_ctxt sha1_ctx;
struct pop3_hdr_context hdr_ctx;
- memset(&hdr_ctx, 0, sizeof(hdr_ctx));
+ i_zero(&hdr_ctx);
/* hide headers that might change or be different in IMAP vs. POP3 */
input = i_stream_create_header_filter(input, HEADER_FILTER_HIDE_BODY |
HEADER_FILTER_EXCLUDE | HEADER_FILTER_NO_CR,
pop3_header_filter_callback, &hdr_ctx);
sha1_init(&sha1_ctx);
- memset(&hash_ctx, 0, sizeof(hash_ctx));
+ i_zero(&hash_ctx);
while (i_stream_read_more(input, &data, &size) > 0) {
message_header_hash_more(&hash_ctx, &hash_method_sha1, &sha1_ctx, 2,
data, size);
if (pop3_migration_uidl_sync_if_needed(_mail->box) < 0)
return -1;
- memset(&map_key, 0, sizeof(map_key));
+ i_zero(&map_key);
map_key.uid = _mail->uid;
map = array_bsearch(&mbox->imap_msg_map, &map_key,
imap_msg_map_uid_cmp);
if (ox_global->http_client == NULL) {
/* this is going to use the first user's settings, but these are
unlikely to change between users so it shouldn't matter much. */
- memset(&http_set, 0, sizeof(http_set));
+ i_zero(&http_set);
http_set.debug = user->mail_debug;
http_set.max_attempts = config->http_max_retries+1;
http_set.request_timeout_msecs = config->http_timeout_msecs;
static void *push_notification_event_flagsclear_default_config(void)
{
- memset(&default_config, 0, sizeof(default_config));
+ i_zero(&default_config);
return &default_config;
}
static void *push_notification_event_flagsset_default_config(void)
{
- memset(&default_config, 0, sizeof(default_config));
+ i_zero(&default_config);
return &default_config;
}
static void *push_notification_event_messageappend_default_config(void)
{
- memset(&default_config, 0, sizeof(default_config));
+ i_zero(&default_config);
return &default_config;
}
static void *push_notification_event_messagenew_default_config(void)
{
- memset(&default_config, 0, sizeof(default_config));
+ i_zero(&default_config);
return &default_config;
}
return;
}
- memset(&dict_set, 0, sizeof(dict_set));
+ i_zero(&dict_set);
dict_set.username = user->username;
dict_set.base_dir = user->set->base_dir;
(void)mail_user_get_home(user, &dict_set.home_dir);
return -1;
}
- memset(&trans, 0, sizeof(trans));
+ i_zero(&trans);
trans.quota = quser->quota;
trans.recalculate = QUOTA_RECALCULATE_FORCED;
/* reset the vsize header first */
trans = mail_index_transaction_begin(box->view,
MAIL_INDEX_TRANSACTION_FLAG_EXTERNAL);
- memset(&vsize_hdr, 0, sizeof(vsize_hdr));
+ i_zero(&vsize_hdr);
mail_index_update_header_ext(trans, box->vsize_hdr_ext_id,
0, &vsize_hdr, sizeof(vsize_hdr));
if (mail_index_transaction_commit(&trans) < 0)
/* FIXME: we should use 64bit integer as datatype instead but before
it can actually be used don't bother */
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.username = username;
set.base_dir = _root->quota->user->set->base_dir;
if (mail_user_get_home(_root->quota->user, &set.home_dir) <= 0)
return;
}
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.username = client->recipient;
ret = mail_storage_service_lookup_next(storage_service, &input,
MAIL_STORAGE_SERVICE_FLAG_ENABLE_CORE_DUMPS |
MAIL_STORAGE_SERVICE_FLAG_NO_CHDIR);
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.service = "quota-status";
input.module = "mail";
input.username = "";
q = rule_def;
}
- memset(&rule, 0, sizeof(rule));
+ i_zero(&rule);
ret = quota_rule_parse_limits(root_set, &rule, t_strdup_until(q, p),
rule_def, FALSE, error_r);
if (ret < 0)
if (root->limit_set_dict == NULL) {
struct dict_settings set;
- memset(&set, 0, sizeof(set));
+ i_zero(&set);
set.username = root->quota->user->username;
set.base_dir = root->quota->user->set->base_dir;
if (mail_user_get_home(root->quota->user, &set.home_dir) <= 0)
if (tests[i].new_size != 1)
continue;
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.count_used = tests[i].transaction_diff;
if (tests[i].initial_size > tests[i].limit)
ctx.count_over = tests[i].initial_size - tests[i].limit;
test_begin("quota transcation is over (bytes)");
for (i = 0; i < N_ELEMENTS(tests); i++) {
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.count_ceil = 1;
ctx.bytes_used = tests[i].transaction_diff;
if (tests[i].initial_size > tests[i].limit)
static struct rusage prev_usage;
struct rusage usage;
- memset(stats_r, 0, sizeof(*stats_r));
+ i_zero(stats_r);
/* cputime */
if (getrusage(RUSAGE_SELF, &usage) < 0) {
if (!getrusage_broken) {
struct virtual_backend_box *const *bboxes;
unsigned int i, count;
- memset(&pattern, 0, sizeof(pattern));
+ i_zero(&pattern);
bboxes = array_get_modifiable(&mbox->backend_boxes, &count);
p_array_init(&mbox->list_include_patterns, ctx->pool, count);
p_array_init(&mbox->list_exclude_patterns, ctx->pool, count);
return -1;
}
- memset(&ctx, 0, sizeof(ctx));
+ i_zero(&ctx);
ctx.sep = mail_namespaces_get_root_sep(storage->user->namespaces);
ctx.mbox = mbox;
ctx.pool = mbox->box.pool;
mbox->virtual_ext_id, &data, NULL);
memcpy(&vmail->cur_vrec, data, sizeof(vmail->cur_vrec));
- memset(&vmail->imail.data, 0, sizeof(vmail->imail.data));
+ i_zero(&vmail->imail.data);
p_clear(vmail->imail.mail.data_pool);
vmail->imail.data.seq = seq;
const void *data;
int result;
- memset(&srec, 0, sizeof(srec));
+ i_zero(&srec);
while (index_storage_search_next_update_seq(ctx)) {
result = mail_search_get_result(ctx);
i_assert(result != 0);
mailbox_pos = sizeof(ext_hdr);
name_pos = mailbox_pos + sizeof(mailbox) * count;
- memset(&ext_hdr, 0, sizeof(ext_hdr));
- memset(&mailbox, 0, sizeof(mailbox));
+ i_zero(&ext_hdr);
+ i_zero(&mailbox);
ext_hdr.change_counter = ++ctx->mbox->prev_change_counter;
ext_hdr.mailbox_count = count;
mailbox_search_result_save(search_ctx, result_flags);
/* add the found UIDs to uidmap. virtual_uid gets assigned later. */
- memset(&uidmap, 0, sizeof(uidmap));
+ i_zero(&uidmap);
array_clear(&bbox->uids);
while (mailbox_search_next(search_ctx, &mail)) {
uidmap.real_uid = mail->uid;
src = dest + add_count;
/* add/move the UIDs to their correct positions */
- memset(&rec, 0, sizeof(rec));
+ i_zero(&rec);
rec.rec.mailbox_id = bbox->mailbox_id;
for (i = 0; i < uid_count; i++) {
add_uid = added_uids[i].seq1;
mail_index_lookup_uid(ctx->sync_view, vseq, &vuid);
- memset(&uidmap, 0, sizeof(uidmap));
+ i_zero(&uidmap);
uidmap.real_uid = real_uid;
uidmap.virtual_uid = vuid;
array_append(&bbox->uids, &uidmap, 1);
return;
}
- memset(&mailbox, 0, sizeof(mailbox));
+ i_zero(&mailbox);
mailbox.uid_validity = bbox->sync_uid_validity;
mailbox.highest_modseq = bbox->ondisk_highest_modseq;
mailbox.next_uid = bbox->sync_next_uid;
/* create real mailbox uid -> virtual uid mapping and expunge
messages no longer matching the search rule */
- memset(&add_rec, 0, sizeof(add_rec));
+ i_zero(&add_rec);
bbox = NULL;
for (i = 0; i < messages; i++) {
vseq = vmails[i].vseq;
/* if there are any mailboxes we didn't yet sync, add new messages in
them */
- memset(&add_rec, 0, sizeof(add_rec));
+ i_zero(&add_rec);
bboxes = array_get(&ctx->mbox->backend_boxes, &count);
for (i = 0; i < count; i++) {
if (bboxes[i]->sync_seen)
(uint32_t)-1, &seq, &seq2))
return 0;
- memset(&uidmap, 0, sizeof(uidmap));
+ i_zero(&uidmap);
for (; seq <= seq2; seq++) {
mail_index_lookup_ext(ctx->sync_view, seq, virtual_ext_id,
&data, NULL);
timeout_remove(&cache->to);
if (cache->input != NULL)
i_stream_unref(&cache->input);
- memset(cache, 0, sizeof(*cache));
+ i_zero(cache);
}
static struct istream *
}
i_assert(client->common.proxy_sasl_client == NULL);
- memset(&sasl_set, 0, sizeof(sasl_set));
+ i_zero(&sasl_set);
sasl_set.authid = client->common.proxy_master_user != NULL ?
client->common.proxy_master_user : client->common.proxy_user;
sasl_set.authzid = client->common.proxy_user;
buffer_t *input_buf;
const char *value, *error, *input_base64;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = input.service = "pop3";
input.username = username != NULL ? username : getenv("USER");
if (input.username == NULL && IS_STANDALONE())
const char *error;
buffer_t input_buf;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = input.service = "pop3";
input.local_ip = client->auth_req.local_ip;
input.remote_ip = client->auth_req.remote_ip;
const char *username = NULL, *auth_socket_path = "auth-master";
int c;
- memset(&login_set, 0, sizeof(login_set));
+ i_zero(&login_set);
login_set.postlogin_timeout_secs = MASTER_POSTLOGIN_TIMEOUT_DEFAULT;
if (IS_STANDALONE() && getuid() == 0 &&
auth_conn = auth_master_init(auth_socket_path,
AUTH_MASTER_FLAG_NO_IDLE_TIMEOUT);
- memset(&user_info, 0, sizeof(user_info));
+ i_zero(&user_info);
user_info.service = REPLICATOR_AUTH_SERVICE_NAME;
/* add all users into replication queue, so that we can start doing
if (str_array_length(args) < 7)
return -1;
- memset(&tmp_user, 0, sizeof(tmp_user));
+ i_zero(&tmp_user);
username = args[0];
state = t_strdup_noconst(args[6]);
if (username[0] == '\0' ||
since=<timestamp>
connected
*/
- memset(filter_r, 0, sizeof(*filter_r));
+ i_zero(filter_r);
for (; *args != NULL; args++) {
if (strncmp(*args, "user=", 5) == 0)
filter_r->user = p_strdup(pool, *args + 5);
g->num_logins = 0;
g->num_cmds = 0;
g->reset_timestamp = ioloop_time;
- memset(&(g->last_update), 0, sizeof(g->last_update));
+ i_zero(&g->last_update);
o_stream_nsend_str(client->output, "OK\n");
return 0;
}
{
struct module_dir_load_settings mod_set;
- memset(&mod_set, 0, sizeof(mod_set));
+ i_zero(&mod_set);
mod_set.abi_version = DOVECOT_ABI_VERSION;
mod_set.require_init_funcs = TRUE;
i_fatal("Missing input fields");
i = 0;
- memset(&input, 0, sizeof(input));
+ i_zero(&input);
input.module = "mail"; /* need to get mail_uid, mail_gid */
input.service = "script-login";
(void)net_addr2ip(args[i++], &input.local_ip);
projects / thirdparty / dovecot / core.git / commitdiff
