From 7bd72e4deca3cbf757dd1ea298486d9f3bc24226 Mon Sep 17 00:00:00 2001
From: Timo Sirainen <tss@iki.fi>
Date: Wed, 2 Dec 2009 15:35:51 -0600
Subject: [PATCH] Use array_foreach() more.

--HG--
branch : HEAD
---
 src/auth/auth-client-connection.c | 31 ++++++++--------
 src/auth/auth-master-connection.c | 11 +++---
 src/auth/auth-worker-server.c     | 22 ++++++------
 src/auth/passdb.c                 | 20 +++++------
 src/auth/password-scheme.c        | 34 +++++++++---------
 src/auth/userdb.c                 | 20 +++++------
 src/config/config-parser.c        | 10 +++---
 src/imap/cmd-list.c               |  7 ++--
 src/imap/imap-commands-util.c     | 22 ++++++------
 src/imap/imap-search.c            |  6 ++--
 src/imap/imap-sync.c              | 18 ++++------
 src/lib-dict/dict-file.c          | 17 +++++----
 src/lib-dict/dict.c               | 23 ++++++------
 src/lib-index/mail-index-map.c    | 46 ++++++++++++------------
 src/lmtp/lmtp-proxy.c             | 40 ++++++++++-----------
 src/master/master-settings.c      | 55 ++++++++++++++--------------
 src/master/service-listen.c       | 23 ++++++------
 src/master/service-log.c          | 13 +++----
 src/master/service-monitor.c      | 60 ++++++++++++++-----------------
 src/master/service.c              | 42 +++++++++++-----------
 src/ssl-params/main.c             |  6 ++--
 21 files changed, 255 insertions(+), 271 deletions(-)

diff --git a/src/auth/auth-client-connection.c b/src/auth/auth-client-connection.c
index 7166637287..44e3cda46c 100644
--- a/src/auth/auth-client-connection.c
+++ b/src/auth/auth-client-connection.c
@@ -304,16 +304,17 @@ void auth_client_connection_destroy(struct auth_client_connection **_conn)
 {
         struct auth_client_connection *conn = *_conn;
 	struct auth_client_connection *const *clients;
-	unsigned int i, count;
+	unsigned int idx;
 
 	*_conn = NULL;
 	if (conn->fd == -1)
 		return;
 
-	clients = array_get(&auth_client_connections, &count);
-	for (i = 0; i < count; i++) {
-		if (clients[i] == conn) {
-			array_delete(&auth_client_connections, i, 1);
+	array_foreach(&auth_client_connections, clients) {
+		if (*clients == conn) {
+			idx = array_foreach_idx(&auth_client_connections,
+						clients);
+			array_delete(&auth_client_connections, idx, 1);
 			break;
 		}
 	}
@@ -351,12 +352,12 @@ struct auth_client_connection *
 auth_client_connection_lookup(unsigned int pid)
 {
 	struct auth_client_connection *const *clients;
-	unsigned int i, count;
 
-	clients = array_get(&auth_client_connections, &count);
-	for (i = 0; i < count; i++) {
-		if (clients[i]->pid == pid)
-			return clients[i];
+	array_foreach(&auth_client_connections, clients) {
+		struct auth_client_connection *client = *clients;
+
+		if (client->pid == pid)
+			return client;
 	}
 
 	return NULL;
@@ -365,13 +366,13 @@ auth_client_connection_lookup(unsigned int pid)
 static void request_timeout(void *context ATTR_UNUSED)
 {
 	struct auth_client_connection *const *clients;
-	unsigned int i, count;
 
-	clients = array_get(&auth_client_connections, &count);
-	for (i = 0; i < count; i++) {
-		if (clients[i]->request_handler != NULL) {
+	array_foreach(&auth_client_connections, clients) {
+		struct auth_client_connection *client = *clients;
+
+		if (client->request_handler != NULL) {
 			auth_request_handler_check_timeouts(
-				clients[i]->request_handler);
+				client->request_handler);
 		}
 	}
 }
diff --git a/src/auth/auth-master-connection.c b/src/auth/auth-master-connection.c
index 44c3f1a500..a0a90bd80e 100644
--- a/src/auth/auth-master-connection.c
+++ b/src/auth/auth-master-connection.c
@@ -501,17 +501,18 @@ void auth_master_connection_destroy(struct auth_master_connection **_conn)
 {
         struct auth_master_connection *conn = *_conn;
         struct auth_master_connection *const *masters;
-	unsigned int i, count;
+	unsigned int idx;
 
 	*_conn = NULL;
 	if (conn->destroyed)
 		return;
 	conn->destroyed = TRUE;
 
-	masters = array_get(&auth_master_connections, &count);
-	for (i = 0; i < count; i++) {
-		if (masters[i] == conn) {
-			array_delete(&auth_master_connections, i, 1);
+	array_foreach(&auth_master_connections, masters) {
+		if (*masters == conn) {
+			idx = array_foreach_idx(&auth_master_connections,
+						masters);
+			array_delete(&auth_master_connections, idx, 1);
 			break;
 		}
 	}
diff --git a/src/auth/auth-worker-server.c b/src/auth/auth-worker-server.c
index d4ed508820..bb656ee760 100644
--- a/src/auth/auth-worker-server.c
+++ b/src/auth/auth-worker-server.c
@@ -155,15 +155,15 @@ static void auth_worker_destroy(struct auth_worker_connection **_conn,
 {
 	struct auth_worker_connection *conn = *_conn;
 	struct auth *auth = conn->auth;
-	struct auth_worker_connection **connp;
-	unsigned int i, count;
+	struct auth_worker_connection *const *conns;
+	unsigned int idx;
 
 	*_conn = NULL;
 
-	connp = array_get_modifiable(&connections, &count);
-	for (i = 0; i < count; i++) {
-		if (connp[i] == conn) {
-			array_delete(&connections, i, 1);
+	array_foreach(&connections, conns) {
+		if (*conns == conn) {
+			idx = array_foreach_idx(&connections, conns);
+			array_delete(&connections, idx, 1);
 			break;
 		}
 	}
@@ -196,15 +196,15 @@ static void auth_worker_destroy(struct auth_worker_connection **_conn,
 static struct auth_worker_connection *auth_worker_find_free(void)
 {
 	struct auth_worker_connection **conns;
-	unsigned int i, count;
 
 	if (idle_count == 0)
 		return NULL;
 
-	conns = array_get_modifiable(&connections, &count);
-	for (i = 0; i < count; i++) {
-		if (conns[i]->request == NULL)
-			return conns[i];
+	array_foreach_modifiable(&connections, conns) {
+		struct auth_worker_connection *conn = *conns;
+
+		if (conn->request == NULL)
+			return conn;
 	}
 	i_unreached();
 	return NULL;
diff --git a/src/auth/passdb.c b/src/auth/passdb.c
index b4d93ceda8..f3a6b2bc89 100644
--- a/src/auth/passdb.c
+++ b/src/auth/passdb.c
@@ -13,12 +13,12 @@ static ARRAY_DEFINE(passdb_interfaces, struct passdb_module_interface *);
 static struct passdb_module_interface *passdb_interface_find(const char *name)
 {
 	struct passdb_module_interface *const *ifaces;
-	unsigned int i, count;
 
-	ifaces = array_get(&passdb_interfaces, &count);
-	for (i = 0; i < count; i++) {
-		if (strcmp(ifaces[i]->name, name) == 0)
-			return ifaces[i];
+	array_foreach(&passdb_interfaces, ifaces) {
+		struct passdb_module_interface *iface = *ifaces;
+
+		if (strcmp(iface->name, name) == 0)
+			return iface;
 	}
 	return NULL;
 }
@@ -41,12 +41,12 @@ void passdb_register_module(struct passdb_module_interface *iface)
 void passdb_unregister_module(struct passdb_module_interface *iface)
 {
 	struct passdb_module_interface *const *ifaces;
-	unsigned int i, count;
+	unsigned int idx;
 
-	ifaces = array_get(&passdb_interfaces, &count);
-	for (i = 0; i < count; i++) {
-		if (ifaces[i] == iface) {
-			array_delete(&passdb_interfaces, i, 1);
+	array_foreach(&passdb_interfaces, ifaces) {
+		if (*ifaces == iface) {
+			idx = array_foreach_idx(&passdb_interfaces, ifaces);
+			array_delete(&passdb_interfaces, idx, 1);
 			return;
 		}
 	}
diff --git a/src/auth/password-scheme.c b/src/auth/password-scheme.c
index 5895c2e3e3..30f6a02e0f 100644
--- a/src/auth/password-scheme.c
+++ b/src/auth/password-scheme.c
@@ -25,12 +25,12 @@ static const struct password_scheme *
 password_scheme_lookup_name(const char *name)
 {
 	const struct password_scheme *const *schemes;
-	unsigned int i, count;
 
-	schemes = array_get(&password_schemes, &count);
-	for (i = 0; i < count; i++) {
-		if (strcasecmp(schemes[i]->name, name) == 0)
-			return schemes[i];
+	array_foreach(&password_schemes, schemes) {
+		const struct password_scheme *scheme = *schemes;
+
+		if (strcasecmp(scheme->name, name) == 0)
+			return scheme;
 	}
 	return NULL;
 }
@@ -230,7 +230,6 @@ bool password_generate_encoded(const char *plaintext, const char *user,
 bool password_scheme_is_alias(const char *scheme1, const char *scheme2)
 {
 	const struct password_scheme *const *schemes, *s1 = NULL, *s2 = NULL;
-	unsigned int i, count;
 
 	scheme1 = t_strcut(scheme1, '.');
 	scheme2 = t_strcut(scheme2, '.');
@@ -238,12 +237,13 @@ bool password_scheme_is_alias(const char *scheme1, const char *scheme2)
 	if (strcasecmp(scheme1, scheme2) == 0)
 		return TRUE;
 
-	schemes = array_get(&password_schemes, &count);
-	for (i = 0; i < count; i++) {
-		if (strcasecmp(schemes[i]->name, scheme1) == 0)
-			s1 = schemes[i];
-		else if (strcasecmp(schemes[i]->name, scheme2) == 0)
-			s2 = schemes[i];
+	array_foreach(&password_schemes, schemes) {
+		const struct password_scheme *scheme = *schemes;
+
+		if (strcasecmp(scheme->name, scheme1) == 0)
+			s1 = scheme;
+		else if (strcasecmp(scheme->name, scheme2) == 0)
+			s2 = scheme;
 	}
 
 	/* if they've the same generate function, they're equivalent */
@@ -686,12 +686,12 @@ void password_scheme_register(const struct password_scheme *scheme)
 void password_scheme_unregister(const struct password_scheme *scheme)
 {
 	const struct password_scheme *const *schemes;
-	unsigned int i, count;
+	unsigned int idx;
 
-	schemes = array_get(&password_schemes, &count);
-	for (i = 0; i < count; i++) {
-		if (strcasecmp(schemes[i]->name, scheme->name) == 0) {
-			array_delete(&password_schemes, i, 1);
+	array_foreach(&password_schemes, schemes) {
+		if (strcasecmp((*schemes)->name, scheme->name) == 0) {
+			idx = array_foreach_idx(&password_schemes, schemes);
+			array_delete(&password_schemes, idx, 1);
 			return;
 		}
 	}
diff --git a/src/auth/userdb.c b/src/auth/userdb.c
index 82bb4d4da2..c1bbf3b187 100644
--- a/src/auth/userdb.c
+++ b/src/auth/userdb.c
@@ -14,12 +14,12 @@ static ARRAY_DEFINE(userdb_interfaces, struct userdb_module_interface *);
 static struct userdb_module_interface *userdb_interface_find(const char *name)
 {
 	struct userdb_module_interface *const *ifaces;
-	unsigned int i, count;
 
-	ifaces = array_get(&userdb_interfaces, &count);
-	for (i = 0; i < count; i++) {
-		if (strcmp(ifaces[i]->name, name) == 0)
-			return ifaces[i];
+	array_foreach(&userdb_interfaces, ifaces) {
+		struct userdb_module_interface *iface = *ifaces;
+
+		if (strcmp(iface->name, name) == 0)
+			return iface;
 	}
 	return NULL;
 }
@@ -42,12 +42,12 @@ void userdb_register_module(struct userdb_module_interface *iface)
 void userdb_unregister_module(struct userdb_module_interface *iface)
 {
 	struct userdb_module_interface *const *ifaces;
-	unsigned int i, count;
+	unsigned int idx;
 
-	ifaces = array_get(&userdb_interfaces, &count);
-	for (i = 0; i < count; i++) {
-		if (ifaces[i] == iface) {
-			array_delete(&userdb_interfaces, i, 1);
+	array_foreach(&userdb_interfaces, ifaces) {
+		if (*ifaces == iface) {
+			idx = array_foreach_idx(&userdb_interfaces, ifaces);
+			array_delete(&userdb_interfaces, idx, 1);
 			return;
 		}
 	}
diff --git a/src/config/config-parser.c b/src/config/config-parser.c
index 0af9499efc..784af21794 100644
--- a/src/config/config-parser.c
+++ b/src/config/config-parser.c
@@ -201,12 +201,12 @@ config_filter_parser_find(struct parser_context *ctx,
 			  const struct config_filter *filter)
 {
 	struct config_filter_parser *const *parsers;
-	unsigned int i, count;
 
-	parsers = array_get(&ctx->all_parsers, &count);
-	for (i = 0; i < count; i++) {
-		if (config_filters_equal(&parsers[i]->filter, filter))
-			return parsers[i];
+	array_foreach(&ctx->all_parsers, parsers) {
+		struct config_filter_parser *parser = *parsers;
+
+		if (config_filters_equal(&parser->filter, filter))
+			return parser;
 	}
 	return NULL;
 }
diff --git a/src/imap/cmd-list.c b/src/imap/cmd-list.c
index 393388577c..6ae387588a 100644
--- a/src/imap/cmd-list.c
+++ b/src/imap/cmd-list.c
@@ -247,7 +247,7 @@ static void
 list_namespace_send_prefix(struct cmd_list_context *ctx, bool have_children)
 {
 	struct mail_namespace *const *listed;
-	unsigned int i, count, len;
+	unsigned int len;
 	enum mailbox_info_flags flags;
 	const char *name;
 	string_t *str;
@@ -256,9 +256,8 @@ list_namespace_send_prefix(struct cmd_list_context *ctx, bool have_children)
 
 	/* see if we already listed this as a valid mailbox in another
 	   namespace */
-	listed = array_get(&ctx->ns_prefixes_listed, &count);
-	for (i = 0; i < count; i++) {
-		if (listed[i] == ctx->ns)
+	array_foreach(&ctx->ns_prefixes_listed, listed) {
+		if (*listed == ctx->ns)
 			return;
 	}
 
diff --git a/src/imap/imap-commands-util.c b/src/imap/imap-commands-util.c
index ff6bea47ac..f79c8ce551 100644
--- a/src/imap/imap-commands-util.c
+++ b/src/imap/imap-commands-util.c
@@ -307,13 +307,13 @@ static const char *get_keywords_string(const ARRAY_TYPE(keywords) *keywords)
 {
 	string_t *str;
 	const char *const *names;
-	unsigned int i, count;
 
 	str = t_str_new(256);
-	names = array_get(keywords, &count);
-	for (i = 0; i < count; i++) {
+	array_foreach(keywords, names) {
+		const char *name = *names;
+
 		str_append_c(str, ' ');
-		str_append(str, names[i]);
+		str_append(str, name);
 	}
 	return str_c(str);
 }
@@ -361,18 +361,18 @@ client_get_keyword_names(struct client *client, ARRAY_TYPE(keywords) *dest,
 {
 	const unsigned int *kw_indexes;
 	const char *const *all_names;
-	unsigned int i, kw_count, all_count;
+	unsigned int all_count;
 
 	client_send_mailbox_flags(client, FALSE);
 
-	all_names = array_get(client->keywords.names, &all_count);
-	kw_indexes = array_get(src, &kw_count);
-
 	/* convert indexes to names */
+	all_names = array_get(client->keywords.names, &all_count);
 	array_clear(dest);
-	for (i = 0; i < kw_count; i++) {
-		i_assert(kw_indexes[i] < all_count);
-		array_append(dest, &all_names[kw_indexes[i]], 1);
+	array_foreach(src, kw_indexes) {
+		unsigned int kw_index = *kw_indexes;
+
+		i_assert(kw_index < all_count);
+		array_append(dest, &all_names[kw_index], 1);
 	}
 
 	(void)array_append_space(dest);
diff --git a/src/imap/imap-search.c b/src/imap/imap-search.c
index 5d95ab8e9a..4b3aa17da9 100644
--- a/src/imap/imap-search.c
+++ b/src/imap/imap-search.c
@@ -163,15 +163,13 @@ static void imap_search_result_save(struct imap_search_context *ctx)
 static void imap_search_send_result_standard(struct imap_search_context *ctx)
 {
 	const struct seq_range *range;
-	unsigned int i, count;
 	string_t *str;
 	uint32_t seq;
 
 	str = t_str_new(1024);
-	range = array_get(&ctx->result, &count);
 	str_append(str, ctx->sorting ? "* SORT" : "* SEARCH");
-	for (i = 0; i < count; i++) {
-		for (seq = range[i].seq1; seq <= range[i].seq2; seq++)
+	array_foreach(&ctx->result, range) {
+		for (seq = range->seq1; seq <= range->seq2; seq++)
 			str_printfa(str, " %u", seq);
 		if (str_len(str) >= 1024-32) {
 			o_stream_send(ctx->cmd->client->output,
diff --git a/src/imap/imap-sync.c b/src/imap/imap-sync.c
index e749a4fc1c..de743926b0 100644
--- a/src/imap/imap-sync.c
+++ b/src/imap/imap-sync.c
@@ -47,18 +47,16 @@ static void uids_to_seqs(struct mailbox *box, ARRAY_TYPE(seq_range) *uids)
 	T_BEGIN {
 		ARRAY_TYPE(seq_range) seqs;
 		const struct seq_range *range;
-		unsigned int i, count;
 		uint32_t seq1, seq2;
 
-		range = array_get(uids, &count);
-		t_array_init(&seqs, count);
-		for (i = 0; i < count; i++) {
-			mailbox_get_seq_range(box, range[i].seq1, range[i].seq2,
+		t_array_init(&seqs, array_count(uids));
+		array_foreach(uids, range) {
+			mailbox_get_seq_range(box, range->seq1, range->seq2,
 					      &seq1, &seq2);
 			/* since we have to notify about expunged messages,
 			   we expect that all the referenced UIDs exist */
 			i_assert(seq1 != 0);
-			i_assert(seq2 - seq1 == range[i].seq2 - range[i].seq1);
+			i_assert(seq2 - seq1 == range->seq2 - range->seq1);
 
 			seq_range_array_add_range(&seqs, seq1, seq2);
 		}
@@ -109,8 +107,7 @@ imap_sync_send_search_update(struct imap_sync_context *ctx,
 
 static void imap_sync_send_search_updates(struct imap_sync_context *ctx)
 {
-	const struct imap_search_update *updates;
-	unsigned int i, count;
+	const struct imap_search_update *update;
 
 	if (!array_is_created(&ctx->client->search_updates))
 		return;
@@ -120,9 +117,8 @@ static void imap_sync_send_search_updates(struct imap_sync_context *ctx)
 		i_array_init(&ctx->search_adds, 128);
 	}
 
-	updates = array_get(&ctx->client->search_updates, &count);
-	for (i = 0; i < count; i++) T_BEGIN {
-		imap_sync_send_search_update(ctx, &updates[i]);
+	array_foreach(&ctx->client->search_updates, update) T_BEGIN {
+		imap_sync_send_search_update(ctx, update);
 	} T_END;
 }
 
diff --git a/src/lib-dict/dict-file.c b/src/lib-dict/dict-file.c
index 84e04ddd36..6c4e8bbb52 100644
--- a/src/lib-dict/dict-file.c
+++ b/src/lib-dict/dict-file.c
@@ -236,13 +236,12 @@ static void file_dict_apply_changes(struct file_dict_transaction_context *ctx)
 	const char *tmp;
 	char *key, *value, *old_value;
 	void *orig_key, *orig_value;
-	const struct file_dict_change *changes;
-	unsigned int i, count, new_len;
+	const struct file_dict_change *change;
+	unsigned int new_len;
 	long long diff;
 
-	changes = array_get(&ctx->changes, &count);
-	for (i = 0; i < count; i++) {
-		if (hash_table_lookup_full(dict->hash, changes[i].key,
+	array_foreach(&ctx->changes, change) {
+		if (hash_table_lookup_full(dict->hash, change->key,
 					   &orig_key, &orig_value)) {
 			key = orig_key;
 			old_value = orig_value;
@@ -252,14 +251,14 @@ static void file_dict_apply_changes(struct file_dict_transaction_context *ctx)
 		}
 		value = NULL;
 
-		switch (changes[i].type) {
+		switch (change->type) {
 		case FILE_DICT_CHANGE_TYPE_INC:
 			if (old_value == NULL) {
 				ctx->atomic_inc_not_found = TRUE;
 				break;
 			}
 			diff = strtoll(old_value, NULL, 10) +
-				changes[i].value.diff;
+				change->value.diff;
 			tmp = t_strdup_printf("%lld", diff);
 			new_len = strlen(tmp);
 			if (old_value == NULL || new_len > strlen(old_value))
@@ -271,10 +270,10 @@ static void file_dict_apply_changes(struct file_dict_transaction_context *ctx)
 			/* fall through */
 		case FILE_DICT_CHANGE_TYPE_SET:
 			if (key == NULL)
-				key = p_strdup(dict->hash_pool, changes[i].key);
+				key = p_strdup(dict->hash_pool, change->key);
 			if (value == NULL) {
 				value = p_strdup(dict->hash_pool,
-						 changes[i].value.str);
+						 change->value.str);
 			}
 			hash_table_update(dict->hash, key, value);
 			break;
diff --git a/src/lib-dict/dict.c b/src/lib-dict/dict.c
index 6d7d9435b0..0a5c1c30e9 100644
--- a/src/lib-dict/dict.c
+++ b/src/lib-dict/dict.c
@@ -10,12 +10,12 @@ static ARRAY_DEFINE(dict_drivers, struct dict *);
 static struct dict *dict_driver_lookup(const char *name)
 {
 	struct dict *const *dicts;
-	unsigned int i, count;
 
-	dicts = array_get(&dict_drivers, &count);
-	for (i = 0; i < count; i++) {
-		if (strcmp(dicts[i]->name, name) == 0)
-			return dicts[i];
+	array_foreach(&dict_drivers, dicts) {
+		struct dict *dict = *dicts;
+
+		if (strcmp(dict->name, name) == 0)
+			return dict;
 	}
 	return NULL;
 }
@@ -35,17 +35,16 @@ void dict_driver_register(struct dict *driver)
 void dict_driver_unregister(struct dict *driver)
 {
 	struct dict *const *dicts;
-	unsigned int i, count;
+	unsigned int idx = -1U;
 
-	dicts = array_get(&dict_drivers, &count);
-	for (i = 0; i < count; i++) {
-		if (dicts[i] == driver) {
-			array_delete(&dict_drivers, i, 1);
+	array_foreach(&dict_drivers, dicts) {
+		if (*dicts == driver) {
+			idx = array_foreach_idx(&dict_drivers, dicts);
 			break;
 		}
 	}
-
-	i_assert(i < count);
+	i_assert(idx != -1U);
+	array_delete(&dict_drivers, idx, 1);
 
 	if (array_count(&dict_drivers) == 0)
 		array_free(&dict_drivers);
diff --git a/src/lib-index/mail-index-map.c b/src/lib-index/mail-index-map.c
index 9519d20a8a..59af0ca89a 100644
--- a/src/lib-index/mail-index-map.c
+++ b/src/lib-index/mail-index-map.c
@@ -43,17 +43,18 @@ void mail_index_map_init_extbufs(struct mail_index_map *map,
 bool mail_index_map_lookup_ext(struct mail_index_map *map, const char *name,
 			       uint32_t *idx_r)
 {
-	const struct mail_index_ext *extensions;
-	unsigned int i, size;
-
-	if (array_is_created(&map->extensions)) {
-		extensions = array_get(&map->extensions, &size);
-		for (i = 0; i < size; i++) {
-			if (strcmp(extensions[i].name, name) == 0) {
-				if (idx_r != NULL)
-					*idx_r = i;
-				return TRUE;
+	const struct mail_index_ext *ext;
+
+	if (!array_is_created(&map->extensions))
+		return FALSE;
+
+	array_foreach(&map->extensions, ext) {
+		if (strcmp(ext->name, name) == 0) {
+			if (idx_r != NULL) {
+				*idx_r = array_foreach_idx(&map->extensions,
+							   ext);
 			}
+			return TRUE;
 		}
 	}
 	return FALSE;
@@ -259,20 +260,21 @@ static void mail_index_record_map_free(struct mail_index_map *map,
 static void mail_index_record_map_unlink(struct mail_index_map *map)
 {
 	struct mail_index_map *const *maps;
-	unsigned int i, count;
-
-	maps = array_get(&map->rec_map->maps, &count);
-	for (i = 0; i < count; i++) {
-		if (maps[i] == map) {
-			array_delete(&map->rec_map->maps, i, 1);
-			if (i == 0 && count == 1) {
-				mail_index_record_map_free(map, map->rec_map);
-				map->rec_map = NULL;
-			}
-			return;
+	unsigned int idx = -1U;
+
+	array_foreach(&map->rec_map->maps, maps) {
+		if (*maps == map) {
+			idx = array_foreach_idx(&map->rec_map->maps, maps);
+			break;
 		}
 	}
-	i_unreached();
+	i_assert(idx != -1U);
+
+	array_delete(&map->rec_map->maps, idx, 1);
+	if (array_count(&map->rec_map->maps) == 0) {
+		mail_index_record_map_free(map, map->rec_map);
+		map->rec_map = NULL;
+	}
 }
 
 void mail_index_unmap(struct mail_index_map **_map)
diff --git a/src/lmtp/lmtp-proxy.c b/src/lmtp/lmtp-proxy.c
index e3a274087c..27315f349f 100644
--- a/src/lmtp/lmtp-proxy.c
+++ b/src/lmtp/lmtp-proxy.c
@@ -76,12 +76,12 @@ lmtp_proxy_init(const char *my_hostname, struct ostream *client_output)
 static void lmtp_proxy_connections_deinit(struct lmtp_proxy *proxy)
 {
 	struct lmtp_proxy_connection *const *conns;
-	unsigned int i, count;
 
-	conns = array_get(&proxy->connections, &count);
-	for (i = 0; i < count; i++) {
-		lmtp_client_fail(conns[i]->client, "451 4.3.0 Aborting");
-		lmtp_client_deinit(&conns[i]->client);
+	array_foreach(&proxy->connections, conns) {
+		struct lmtp_proxy_connection *conn = *conns;
+
+		lmtp_client_fail(conn->client, "451 4.3.0 Aborting");
+		lmtp_client_deinit(&conn->client);
 	}
 }
 
@@ -117,15 +117,15 @@ lmtp_proxy_get_connection(struct lmtp_proxy *proxy,
 			  const struct lmtp_proxy_settings *set)
 {
 	struct lmtp_proxy_connection *const *conns, *conn;
-	unsigned int i, count;
 
 	i_assert(set->timeout_msecs > 0);
 
-	conns = array_get(&proxy->connections, &count);
-	for (i = 0; i < count; i++) {
-		if (conns[i]->set.port == set->port &&
-		    strcmp(conns[i]->set.host, set->host) == 0)
-			return conns[i];
+	array_foreach(&proxy->connections, conns) {
+		conn = *conns;
+
+		if (conn->set.port == set->port &&
+		    strcmp(conn->set.host, set->host) == 0)
+			return conn;
 	}
 
 	conn = p_new(proxy->pool, struct lmtp_proxy_connection, 1);
@@ -389,12 +389,10 @@ static bool lmtp_proxy_data_read(struct lmtp_proxy *proxy)
 static void lmtp_proxy_data_input(struct lmtp_proxy *proxy)
 {
 	struct lmtp_proxy_connection *const *conns;
-	unsigned int i, count;
 
 	do {
-		conns = array_get(&proxy->connections, &count);
-		for (i = 0; i < count; i++)
-			lmtp_client_send_more(conns[i]->client);
+		array_foreach(&proxy->connections, conns);
+			lmtp_client_send_more((*conns)->client);
 	} while (lmtp_proxy_data_read(proxy));
 }
 
@@ -403,7 +401,6 @@ void lmtp_proxy_start(struct lmtp_proxy *proxy, struct istream *data_input,
 		      lmtp_proxy_finish_callback_t *callback, void *context)
 {
 	struct lmtp_proxy_connection *const *conns;
-	unsigned int i, count;
 
 	proxy->finish_callback = callback;
 	proxy->finish_context = context;
@@ -413,12 +410,13 @@ void lmtp_proxy_start(struct lmtp_proxy *proxy, struct istream *data_input,
 	proxy->to_data_idle = timeout_add(LMTP_PROXY_DATA_INPUT_TIMEOUT_MSECS,
 					  lmtp_proxy_data_input_timeout, proxy);
 
-	conns = array_get(&proxy->connections, &count);
-	for (i = 0; i < count; i++) {
-		conns[i]->data_input =
+	array_foreach(&proxy->connections, conns) {
+		struct lmtp_proxy_connection *conn = *conns;
+
+		conn->data_input =
 			tee_i_stream_create_child(proxy->tee_data_input);
-		lmtp_client_set_data_header(conns[i]->client, header);
-		lmtp_client_send(conns[i]->client, conns[i]->data_input);
+		lmtp_client_set_data_header(conn->client, header);
+		lmtp_client_send(conn->client, conn->data_input);
 	}
 
 	lmtp_proxy_data_input(proxy);
diff --git a/src/master/master-settings.c b/src/master/master-settings.c
index 1bff028011..21b760d986 100644
--- a/src/master/master-settings.c
+++ b/src/master/master-settings.c
@@ -237,18 +237,18 @@ static void fix_file_listener_paths(ARRAY_TYPE(file_listener_settings) *l,
 				    ARRAY_TYPE(const_string) *all_listeners)
 {
 	struct file_listener_settings *const *sets;
-	unsigned int i, count;
 
 	if (!array_is_created(l))
 		return;
 
-	sets = array_get(l, &count);
-	for (i = 0; i < count; i++) {
-		if (*sets[i]->path != '/') {
-			sets[i]->path = p_strconcat(pool, base_dir, "/",
-						    sets[i]->path, NULL);
+	array_foreach(l, sets) {
+		struct file_listener_settings *set = *sets;
+
+		if (*set->path != '/') {
+			set->path = p_strconcat(pool, base_dir, "/",
+						set->path, NULL);
 		}
-		array_append(all_listeners, &sets[i]->path, 1);
+		array_append(all_listeners, &set->path, 1);
 	}
 }
 
@@ -256,15 +256,15 @@ static void add_inet_listeners(ARRAY_TYPE(inet_listener_settings) *l,
 			       ARRAY_TYPE(const_string) *all_listeners)
 {
 	struct inet_listener_settings *const *sets;
-	unsigned int i, count;
 	const char *str;
 
 	if (!array_is_created(l))
 		return;
 
-	sets = array_get(l, &count);
-	for (i = 0; i < count; i++) {
-		str = t_strdup_printf("%d:%s", sets[i]->port, sets[i]->address);
+	array_foreach(l, sets) {
+		struct inet_listener_settings *set = *sets;
+
+		str = t_strdup_printf("%d:%s", set->port, set->address);
 		array_append(all_listeners, &str, 1);
 	}
 }
@@ -405,21 +405,21 @@ static bool
 login_want_core_dumps(const struct master_settings *set, gid_t *gid_r)
 {
 	struct service_settings *const *services;
-	unsigned int i, count;
 	const char *error;
 	bool cores = FALSE;
 	uid_t uid;
 
 	*gid_r = (gid_t)-1;
 
-	services = array_get(&set->services, &count);
-	for (i = 0; i < count; i++) {
-		if (services[i]->parsed_type == SERVICE_TYPE_LOGIN) {
-			if (services[i]->login_dump_core)
+	array_foreach(&set->services, services) {
+		struct service_settings *service = *services;
+
+		if (service->parsed_type == SERVICE_TYPE_LOGIN) {
+			if (service->login_dump_core)
 				cores = TRUE;
-			(void)get_uidgid(services[i]->user, &uid, gid_r, &error);
-			if (*services[i]->group != '\0')
-				(void)get_gid(services[i]->group, gid_r, &error);
+			(void)get_uidgid(service->user, &uid, gid_r, &error);
+			if (*service->group != '\0')
+				(void)get_gid(service->group, gid_r, &error);
 		}
 	}
 	return cores;
@@ -430,15 +430,16 @@ settings_have_auth_unix_listeners_in(const struct master_settings *set,
 				     const char *dir)
 {
 	struct service_settings *const *services;
-	struct file_listener_settings *const *u;
-	unsigned int i, j, count, count2;
+	struct file_listener_settings *const *uls;
 
-	services = array_get(&set->services, &count);
-	for (i = 0; i < count; i++) {
-		if (array_is_created(&services[i]->unix_listeners)) {
-			u = array_get(&services[i]->unix_listeners, &count2);
-			for (j = 0; j < count2; j++) {
-				if (strncmp(u[j]->path, dir, strlen(dir)) == 0)
+	array_foreach(&set->services, services) {
+		struct service_settings *service = *services;
+
+		if (array_is_created(&service->unix_listeners)) {
+			array_foreach(&service->unix_listeners, uls) {
+				struct file_listener_settings *u = *uls;
+
+				if (strncmp(u->path, dir, strlen(dir)) == 0)
 					return TRUE;
 			}
 		}
diff --git a/src/master/service-listen.c b/src/master/service-listen.c
index fc91f58ede..4b84d0ae42 100644
--- a/src/master/service-listen.c
+++ b/src/master/service-listen.c
@@ -143,42 +143,39 @@ static int service_inet_listener_listen(struct service_listener *l)
 static int service_listen(struct service *service)
 {
 	struct service_listener *const *listeners;
-	unsigned int i, count;
 	int ret = 1, ret2 = 0;
 
-	listeners = array_get(&service->listeners, &count);
-	for (i = 0; i < count; i++) {
-		if (listeners[i]->fd != -1)
+	array_foreach(&service->listeners, listeners) {
+		struct service_listener *l = *listeners;
+
+		if (l->fd != -1)
 			continue;
 
-		switch (listeners[i]->type) {
+		switch (l->type) {
 		case SERVICE_LISTENER_UNIX:
-			ret2 = service_unix_listener_listen(listeners[i]);
+			ret2 = service_unix_listener_listen(l);
 			break;
 		case SERVICE_LISTENER_FIFO:
-			ret2 = service_fifo_listener_listen(listeners[i]);
+			ret2 = service_fifo_listener_listen(l);
 			break;
 		case SERVICE_LISTENER_INET:
-			ret2 = service_inet_listener_listen(listeners[i]);
+			ret2 = service_inet_listener_listen(l);
 			break;
 		}
 
 		if (ret2 < ret)
 			ret = ret2;
 	}
-
 	return ret;
 }
 
 int services_listen(struct service_list *service_list)
 {
 	struct service *const *services;
-	unsigned int i, count;
 	int ret = 1, ret2;
 
-	services = array_get(&service_list->services, &count);
-	for (i = 0; i < count; i++) {
-		ret2 = service_listen(services[i]);
+	array_foreach(&service_list->services, services) {
+		ret2 = service_listen(*services);
 		if (ret2 < ret)
 			ret = ret2;
 	}
diff --git a/src/master/service-log.c b/src/master/service-log.c
index 3742179d73..54be49bf18 100644
--- a/src/master/service-log.c
+++ b/src/master/service-log.c
@@ -150,19 +150,20 @@ void services_log_dup2(ARRAY_TYPE(dup2) *dups,
 		       unsigned int first_fd, unsigned int *fd_count)
 {
 	struct service *const *services;
-	unsigned int i, n = 0, count;
+	unsigned int n = 0;
 
 	/* master log fd is always the first one */
 	dup2_append(dups, service_list->master_log_fd[0], first_fd);
 	n++; *fd_count += 1;
 
-	services = array_get(&service_list->services, &count);
-	for (i = 0; i < count; i++) {
-		if (services[i]->log_fd[1] == -1)
+	array_foreach(&service_list->services, services) {
+		struct service *service = *services;
+
+		if (service->log_fd[1] == -1)
 			continue;
 
-		i_assert((int)(first_fd + n) == services[i]->log_process_internal_fd);
-		dup2_append(dups, services[i]->log_fd[0], first_fd + n);
+		i_assert((int)(first_fd + n) == service->log_process_internal_fd);
+		dup2_append(dups, service->log_fd[0], first_fd + n);
 		n++; *fd_count += 1;
 	}
 }
diff --git a/src/master/service-monitor.c b/src/master/service-monitor.c
index c0b072e7b8..646aae9869 100644
--- a/src/master/service-monitor.c
+++ b/src/master/service-monitor.c
@@ -238,7 +238,6 @@ static void service_monitor_start_extra_avail(struct service *service)
 void service_monitor_listen_start(struct service *service)
 {
 	struct service_listener *const *listeners;
-	unsigned int i, count;
 
 	if (service->process_avail > 0 ||
 	    (service->process_count == service->process_limit &&
@@ -248,23 +247,20 @@ void service_monitor_listen_start(struct service *service)
 	service->listening = TRUE;
 	service->listen_pending = FALSE;
 
-	listeners = array_get(&service->listeners, &count);
-	for (i = 0; i < count; i++) {
-		if (listeners[i]->io == NULL && listeners[i]->fd != -1) {
-			listeners[i]->io = io_add(listeners[i]->fd, IO_READ,
-						  service_accept, service);
-		}
+	array_foreach(&service->listeners, listeners) {
+		struct service_listener *l = *listeners;
+
+		if (l->io == NULL && l->fd != -1)
+			l->io = io_add(l->fd, IO_READ, service_accept, service);
 	}
 }
 
 void service_monitor_listen_stop(struct service *service)
 {
 	struct service_listener *const *listeners;
-	unsigned int i, count;
 
-	listeners = array_get(&service->listeners, &count);
-	for (i = 0; i < count; i++) {
-		struct service_listener *l = listeners[i];
+	array_foreach(&service->listeners, listeners) {
+		struct service_listener *l = *listeners;
 
 		if (l->io != NULL)
 			io_remove(&l->io);
@@ -307,36 +303,36 @@ static int service_login_create_notify_fd(struct service *service)
 void services_monitor_start(struct service_list *service_list)
 {
 	struct service *const *services;
-	unsigned int i, count;
 
 	services_log_init(service_list);
 	service_anvil_monitor_start(service_list);
 
-	services = array_get(&service_list->services, &count);
-	for (i = 0; i < count; i++) {
-		if (services[i]->type == SERVICE_TYPE_LOGIN) {
-			if (service_login_create_notify_fd(services[i]) < 0)
+	array_foreach(&service_list->services, services) {
+		struct service *service = *services;
+
+		if (service->type == SERVICE_TYPE_LOGIN) {
+			if (service_login_create_notify_fd(service) < 0)
 				continue;
 		}
-		if (services[i]->status_fd[0] == -1) {
+		if (service->status_fd[0] == -1) {
 			/* we haven't yet created status pipe */
-			if (pipe(services[i]->status_fd) < 0) {
-				service_error(services[i], "pipe() failed: %m");
+			if (pipe(service->status_fd) < 0) {
+				service_error(service, "pipe() failed: %m");
 				continue;
 			}
 
-			net_set_nonblock(services[i]->status_fd[0], TRUE);
-			fd_close_on_exec(services[i]->status_fd[0], TRUE);
-			net_set_nonblock(services[i]->status_fd[1], TRUE);
-			fd_close_on_exec(services[i]->status_fd[1], TRUE);
+			net_set_nonblock(service->status_fd[0], TRUE);
+			fd_close_on_exec(service->status_fd[0], TRUE);
+			net_set_nonblock(service->status_fd[1], TRUE);
+			fd_close_on_exec(service->status_fd[1], TRUE);
 		}
-		if (services[i]->io_status == NULL) {
-			services[i]->io_status =
-				io_add(services[i]->status_fd[0], IO_READ,
-				       service_status_input, services[i]);
+		if (service->io_status == NULL) {
+			service->io_status =
+				io_add(service->status_fd[0], IO_READ,
+				       service_status_input, service);
 		}
-		service_monitor_start_extra_avail(services[i]);
-		service_monitor_listen_start(services[i]);
+		service_monitor_start_extra_avail(service);
+		service_monitor_listen_start(service);
 	}
 
 	if (service_process_create(service_list->log) != NULL)
@@ -378,11 +374,9 @@ void service_monitor_stop(struct service *service)
 void services_monitor_stop(struct service_list *service_list)
 {
 	struct service *const *services;
-	unsigned int i, count;
 
-	services = array_get(&service_list->services, &count);
-	for (i = 0; i < count; i++)
-		service_monitor_stop(services[i]);
+	array_foreach(&service_list->services, services)
+		service_monitor_stop(*services);
 
 	services_log_deinit(service_list);
 }
diff --git a/src/master/service.c b/src/master/service.c
index a70c716a94..6508040c93 100644
--- a/src/master/service.c
+++ b/src/master/service.c
@@ -320,12 +320,12 @@ struct service *
 service_lookup(struct service_list *service_list, const char *name)
 {
 	struct service *const *services;
-	unsigned int i, count;
 
-	services = array_get(&service_list->services, &count);
-	for (i = 0; i < count; i++) {
-		if (strcmp(services[i]->set->name, name) == 0)
-			return services[i];
+	array_foreach(&service_list->services, services) {
+		struct service *service = *services;
+
+		if (strcmp(service->set->name, name) == 0)
+			return service;
 	}
 	return NULL;
 }
@@ -334,12 +334,12 @@ struct service *
 service_lookup_type(struct service_list *service_list, enum service_type type)
 {
 	struct service *const *services;
-	unsigned int i, count;
 
-	services = array_get(&service_list->services, &count);
-	for (i = 0; i < count; i++) {
-		if (services[i]->type == type)
-			return services[i];
+	array_foreach(&service_list->services, services) {
+		struct service *service = *services;
+
+		if (service->type == type)
+			return service;
 	}
 	return NULL;
 }
@@ -498,7 +498,6 @@ void service_login_notify(struct service *service, bool all_processes_full)
 static void services_kill_timeout(struct service_list *service_list)
 {
 	struct service *const *services, *log_service;
-	unsigned int i, count;
 	bool sigterm_log;
 	int sig;
 
@@ -513,12 +512,13 @@ static void services_kill_timeout(struct service_list *service_list)
 		  sig == SIGTERM ? "SIGTERM" : "SIGKILL");
 
 	log_service = NULL;
-	services = array_get(&service_list->services, &count);
-	for (i = 0; i < count; i++) {
-		if (services[i]->type == SERVICE_TYPE_LOG)
-			log_service = services[i];
+	array_foreach(&service_list->services, services) {
+		struct service *service = *services;
+
+		if (service->type == SERVICE_TYPE_LOG)
+			log_service = service;
 		else
-			service_signal(services[i], sig);
+			service_signal(service, sig);
 	}
 	/* kill log service later so it could still have a chance of logging
 	   something */
@@ -594,12 +594,12 @@ void services_throttle_time_sensitives(struct service_list *list,
 				       unsigned int secs)
 {
 	struct service *const *services;
-	unsigned int i, count;
 
-	services = array_get(&list->services, &count);
-	for (i = 0; i < count; i++) {
-		if (services[i]->type == SERVICE_TYPE_UNKNOWN)
-			service_throttle(services[i], secs);
+	array_foreach(&list->services, services) {
+		struct service *service = *services;
+
+		if (service->type == SERVICE_TYPE_UNKNOWN)
+			service_throttle(service, secs);
 	}
 }
 
diff --git a/src/ssl-params/main.c b/src/ssl-params/main.c
index 37b3abeb20..a275e188c2 100644
--- a/src/ssl-params/main.c
+++ b/src/ssl-params/main.c
@@ -69,7 +69,6 @@ static void client_connected(const struct master_service_connection *conn)
 static void ssl_params_callback(const unsigned char *data, size_t size)
 {
 	const int *fds;
-	unsigned int i, count;
 
 	buffer_set_used_size(ssl_params, 0);
 	buffer_append(ssl_params, data, size);
@@ -77,9 +76,8 @@ static void ssl_params_callback(const unsigned char *data, size_t size)
 	if (!array_is_created(&delayed_fds))
 		return;
 
-	fds = array_get(&delayed_fds, &count);
-	for (i = 0; i < count; i++)
-		client_handle(fds[i]);
+	array_foreach(&delayed_fds, fds)
+		client_handle(*fds);
 	array_free(&delayed_fds);
 }
 
-- 
2.47.3