Coding: use specified-initialisers

17 files changed, 790 insertions, 703 deletions

diff --git a/src/src/acl.c b/src/src/acl.c
index cf7e42aa4..42292eb82 100644
--- a/src/src/acl.c
+++ b/src/src/acl.c
@@ -22,13 +22,14 @@ enum { ACL_ACCEPT, ACL_DEFER, ACL_DENY, ACL_DISCARD, ACL_DROP, ACL_REQUIRE,
 /* ACL verbs */
 
 static uschar *verbs[] = {
-    US"accept",
-    US"defer",
-    US"deny",
-    US"discard",
-    US"drop",
-    US"require",
-    US"warn" };
+    [ACL_ACCEPT] =	US"accept",
+    [ACL_DEFER] =	US"defer",
+    [ACL_DENY] =	US"deny",
+    [ACL_DISCARD] =	US"discard",
+    [ACL_DROP] =	US"drop",
+    [ACL_REQUIRE] =	US"require",
+    [ACL_WARN] =	US"warn"
+};
 
 /* For each verb, the conditions for which "message" or "log_message" are used
 are held as a bitmap. This is to avoid expanding the strings unnecessarily. For
@@ -36,13 +37,13 @@ are held as a bitmap. This is to avoid expanding the strings unnecessarily. For
 the code. */
 
 static int msgcond[] = {
-  (1<<OK) | (1<<FAIL) | (1<<FAIL_DROP),  /* accept */
-  (1<<OK),                               /* defer */
-  (1<<OK),                               /* deny */
-  (1<<OK) | (1<<FAIL) | (1<<FAIL_DROP),  /* discard */
-  (1<<OK),                               /* drop */
-  (1<<FAIL) | (1<<FAIL_DROP),            /* require */
-  (1<<OK)                                /* warn */
+  [ACL_ACCEPT] =	(1<<OK) | (1<<FAIL) | (1<<FAIL_DROP),
+  [ACL_DEFER] =		(1<<OK),
+  [ACL_DENY] =		(1<<OK),
+  [ACL_DISCARD] =	(1<<OK) | (1<<FAIL) | (1<<FAIL_DROP),
+  [ACL_DROP] =		(1<<OK),
+  [ACL_REQUIRE] =	(1<<FAIL) | (1<<FAIL_DROP),
+  [ACL_WARN] =		(1<<OK)
   };
 
 /* ACL condition and modifier codes - keep in step with the table that
@@ -132,213 +133,210 @@ times. */
 } condition_def;
 
 static condition_def conditions[] = {
-  { US"acl",		FALSE, FALSE,	0 },
+  [ACLC_ACL] =			{ US"acl",		FALSE, FALSE,	0 },
 
-  { US"add_header",	TRUE, TRUE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
-      (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
+  [ACLC_ADD_HEADER] =		{ US"add_header",	TRUE, TRUE,
+				  (unsigned int)
+				  ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
+				    (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 #ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				    (1<<ACL_WHERE_PRDR)|
 #endif
-      (1<<ACL_WHERE_MIME)|(1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_DKIM)|
-      (1<<ACL_WHERE_NOTSMTP_START)),
+				    (1<<ACL_WHERE_MIME)|(1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_DKIM)|
+				    (1<<ACL_WHERE_NOTSMTP_START)),
   },
 
-  { US"authenticated",	FALSE, FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_NOTSMTP_START)|
-      (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO),
+  [ACLC_AUTHENTICATED] =	{ US"authenticated",	FALSE, FALSE,
+				  (1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_NOTSMTP_START)|
+				    (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO),
   },
 #ifdef EXPERIMENTAL_BRIGHTMAIL
-  { US"bmi_optin",	TRUE, TRUE,
-    (1<<ACL_WHERE_AUTH)|
-      (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
-      (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_MIME)|
+  [ACLC_BMI_OPTIN] =		{ US"bmi_optin",	TRUE, TRUE,
+				  (1<<ACL_WHERE_AUTH)|
+				    (1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO)|
+				    (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_MIME)|
 # ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				    (1<<ACL_WHERE_PRDR)|
 # endif
-      (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
-      (1<<ACL_WHERE_MAILAUTH)|
-      (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
-      (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_PREDATA)|
-      (1<<ACL_WHERE_NOTSMTP_START),
+				    (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
+				    (1<<ACL_WHERE_MAILAUTH)|
+				    (1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_STARTTLS)|
+				    (1<<ACL_WHERE_VRFY)|(1<<ACL_WHERE_PREDATA)|
+				    (1<<ACL_WHERE_NOTSMTP_START),
   },
 #endif
-  { US"condition",	TRUE, FALSE,	0 },
-  { US"continue",	TRUE, TRUE,	0 },
+  [ACLC_CONDITION] =		{ US"condition",	TRUE, FALSE,	0 },
+  [ACLC_CONTINUE] =		{ US"continue",	TRUE, TRUE,	0 },
 
   /* Certain types of control are always allowed, so we let it through
   always and check in the control processing itself. */
-  { US"control",	TRUE, TRUE,	0 },
+  [ACLC_CONTROL] =		{ US"control",	TRUE, TRUE,	0 },
 
 #ifdef EXPERIMENTAL_DCC
-  { US"dcc",		TRUE, FALSE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_DATA)|
+  [ACLC_DCC] =			{ US"dcc",		TRUE, FALSE,
+				  (unsigned int)
+				  ~((1<<ACL_WHERE_DATA)|
 # ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				  (1<<ACL_WHERE_PRDR)|
 # endif
-      (1<<ACL_WHERE_NOTSMTP)),
+				  (1<<ACL_WHERE_NOTSMTP)),
   },
 #endif
 #ifdef WITH_CONTENT_SCAN
-  { US"decode",		TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_MIME) },
+  [ACLC_DECODE] =		{ US"decode",		TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_MIME) },
 
 #endif
-  { US"delay",		TRUE, TRUE, (1<<ACL_WHERE_NOTQUIT) },
+  [ACLC_DELAY] =		{ US"delay",		TRUE, TRUE, (1<<ACL_WHERE_NOTQUIT) },
 #ifndef DISABLE_DKIM
-  { US"dkim_signers",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_DKIM) },
-  { US"dkim_status",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_DKIM) },
+  [ACLC_DKIM_SIGNER] =		{ US"dkim_signers",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_DKIM) },
+  [ACLC_DKIM_STATUS] =		{ US"dkim_status",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_DKIM) },
 #endif
 #ifdef EXPERIMENTAL_DMARC
-  { US"dmarc_status",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_DATA) },
+  [ACLC_DMARC_STATUS] =		{ US"dmarc_status",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_DATA) },
 #endif
 
   /* Explicit key lookups can be made in non-smtp ACLs so pass
   always and check in the verify processing itself. */
-  { US"dnslists",	TRUE, FALSE,	0 },
+  [ACLC_DNSLISTS] =		{ US"dnslists",	TRUE, FALSE,	0 },
 
-  { US"domains",	FALSE, FALSE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_RCPT)
-      |(1<<ACL_WHERE_VRFY)
+  [ACLC_DOMAINS] =		{ US"domains",	FALSE, FALSE,
+				  (unsigned int)
+				  ~((1<<ACL_WHERE_RCPT)
+				    |(1<<ACL_WHERE_VRFY)
 #ifndef DISABLE_PRDR
-      |(1<<ACL_WHERE_PRDR)
+				  |(1<<ACL_WHERE_PRDR)
 #endif
       ),
   },
-  { US"encrypted",	FALSE, FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_CONNECT)|
-      (1<<ACL_WHERE_NOTSMTP_START)|
-      (1<<ACL_WHERE_HELO),
+  [ACLC_ENCRYPTED] =		{ US"encrypted",	FALSE, FALSE,
+				  (1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_CONNECT)|
+				    (1<<ACL_WHERE_NOTSMTP_START)|
+				    (1<<ACL_WHERE_HELO),
   },
 
-  { US"endpass",	TRUE, TRUE,	0 },
+  [ACLC_ENDPASS] =		{ US"endpass",	TRUE, TRUE,	0 },
 
-  { US"hosts",		FALSE, FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_NOTSMTP_START),
+  [ACLC_HOSTS] =		{ US"hosts",		FALSE, FALSE,
+				  (1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_NOTSMTP_START),
   },
-  { US"local_parts",	FALSE, FALSE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_RCPT)
-      |(1<<ACL_WHERE_VRFY)
-    #ifndef DISABLE_PRDR
-      |(1<<ACL_WHERE_PRDR)
-    #endif
+  [ACLC_LOCAL_PARTS] =		{ US"local_parts",	FALSE, FALSE,
+				  (unsigned int)
+				  ~((1<<ACL_WHERE_RCPT)
+				    |(1<<ACL_WHERE_VRFY)
+#ifndef DISABLE_PRDR
+				  |(1<<ACL_WHERE_PRDR)
+#endif
       ),
   },
 
-  { US"log_message",	TRUE, TRUE,	0 },
-  { US"log_reject_target", TRUE, TRUE,	0 },
-  { US"logwrite",	TRUE, TRUE,	0 },
+  [ACLC_LOG_MESSAGE] =		{ US"log_message",	TRUE, TRUE,	0 },
+  [ACLC_LOG_REJECT_TARGET] =		{ US"log_reject_target", TRUE, TRUE,	0 },
+  [ACLC_LOGWRITE] =		{ US"logwrite",	TRUE, TRUE,	0 },
 
 #ifdef WITH_CONTENT_SCAN
-  { US"malware",	TRUE, FALSE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_DATA)|
+  [ACLC_MALWARE] =		{ US"malware",	TRUE, FALSE,
+				  (unsigned int)
+				    ~((1<<ACL_WHERE_DATA)|
 # ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				    (1<<ACL_WHERE_PRDR)|
 # endif
-      (1<<ACL_WHERE_NOTSMTP)),
+				    (1<<ACL_WHERE_NOTSMTP)),
   },
 #endif
 
-  { US"message",	TRUE, TRUE,	0 },
+  [ACLC_MESSAGE] =		{ US"message",	TRUE, TRUE,	0 },
 #ifdef WITH_CONTENT_SCAN
-  { US"mime_regex",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_MIME) },
+  [ACLC_MIME_REGEX] =		{ US"mime_regex",	TRUE, FALSE, (unsigned int) ~(1<<ACL_WHERE_MIME) },
 #endif
 
-  { US"queue",		TRUE, TRUE,
-    (1<<ACL_WHERE_NOTSMTP)|
+  [ACLC_QUEUE] =		{ US"queue",		TRUE, TRUE,
+				  (1<<ACL_WHERE_NOTSMTP)|
 #ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				  (1<<ACL_WHERE_PRDR)|
 #endif
-      (1<<ACL_WHERE_DATA),
+				  (1<<ACL_WHERE_DATA),
   },
 
-  { US"ratelimit",	TRUE, FALSE,	0 },
-  { US"recipients",	FALSE, FALSE, (unsigned int) ~(1<<ACL_WHERE_RCPT) },
+  [ACLC_RATELIMIT] =		{ US"ratelimit",	TRUE, FALSE,	0 },
+  [ACLC_RECIPIENTS] =		{ US"recipients",	FALSE, FALSE, (unsigned int) ~(1<<ACL_WHERE_RCPT) },
 
 #ifdef WITH_CONTENT_SCAN
-  { US"regex",		TRUE, FALSE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_DATA)|
+  [ACLC_REGEX] =		{ US"regex",		TRUE, FALSE,
+				  (unsigned int)
+				  ~((1<<ACL_WHERE_DATA)|
 # ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				    (1<<ACL_WHERE_PRDR)|
 # endif
-      (1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_MIME)),
+				    (1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_MIME)),
   },
 
 #endif
-  { US"remove_header",	TRUE, TRUE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
-      (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
+  [ACLC_REMOVE_HEADER] =	{ US"remove_header",	TRUE, TRUE,
+				  (unsigned int)
+				  ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
+				    (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 #ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				    (1<<ACL_WHERE_PRDR)|
 #endif
-      (1<<ACL_WHERE_MIME)|(1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_NOTSMTP_START)),
+				    (1<<ACL_WHERE_MIME)|(1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_NOTSMTP_START)),
   },
-  { US"sender_domains",	FALSE, FALSE,
-    (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
-      (1<<ACL_WHERE_HELO)|
-      (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
-      (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
-      (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
+  [ACLC_SENDER_DOMAINS] =	{ US"sender_domains",	FALSE, FALSE,
+				  (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
+				    (1<<ACL_WHERE_HELO)|
+				    (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
+				    (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
+				    (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
   },
-  { US"senders",	FALSE, FALSE,
-    (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
-      (1<<ACL_WHERE_HELO)|
-      (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
-      (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
-      (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
+  [ACLC_SENDERS] =		{ US"senders",	FALSE, FALSE,
+				  (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
+				    (1<<ACL_WHERE_HELO)|
+				    (1<<ACL_WHERE_MAILAUTH)|(1<<ACL_WHERE_QUIT)|
+				    (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
+				    (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY),
   },
 
-  { US"set",		TRUE, TRUE,	0 },
+  [ACLC_SET] =			{ US"set",		TRUE, TRUE,	0 },
 
 #ifdef WITH_CONTENT_SCAN
-  { US"spam",		TRUE, FALSE,
-    (unsigned int)
-    ~((1<<ACL_WHERE_DATA)|
+  [ACLC_SPAM] =			{ US"spam",		TRUE, FALSE,
+				  (unsigned int) ~((1<<ACL_WHERE_DATA)|
 # ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				  (1<<ACL_WHERE_PRDR)|
 # endif
-      (1<<ACL_WHERE_NOTSMTP)),
+				  (1<<ACL_WHERE_NOTSMTP)),
   },
 #endif
 #ifdef EXPERIMENTAL_SPF
-  { US"spf",		TRUE, FALSE,
-    (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
-      (1<<ACL_WHERE_HELO)|
-      (1<<ACL_WHERE_MAILAUTH)|
-      (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
-      (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY)|
-      (1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_NOTSMTP_START),
+  [ACLC_SPF] =			{ US"spf",		TRUE, FALSE,
+				  (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
+				    (1<<ACL_WHERE_HELO)|
+				    (1<<ACL_WHERE_MAILAUTH)|
+				    (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
+				    (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY)|
+				    (1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_NOTSMTP_START),
   },
-  { US"spf_guess",	TRUE, FALSE,
-    (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
-      (1<<ACL_WHERE_HELO)|
-      (1<<ACL_WHERE_MAILAUTH)|
-      (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
-      (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY)|
-      (1<<ACL_WHERE_NOTSMTP)|
-      (1<<ACL_WHERE_NOTSMTP_START),
+  [ACLC_SPF_GEUSS] =		{ US"spf_guess",	TRUE, FALSE,
+				  (1<<ACL_WHERE_AUTH)|(1<<ACL_WHERE_CONNECT)|
+				    (1<<ACL_WHERE_HELO)|
+				    (1<<ACL_WHERE_MAILAUTH)|
+				    (1<<ACL_WHERE_ETRN)|(1<<ACL_WHERE_EXPN)|
+				    (1<<ACL_WHERE_STARTTLS)|(1<<ACL_WHERE_VRFY)|
+				    (1<<ACL_WHERE_NOTSMTP)|
+				    (1<<ACL_WHERE_NOTSMTP_START),
   },
 #endif
-  { US"udpsend",	TRUE, TRUE,	0 },
+  [ACLC_UDPSEND] =		{ US"udpsend",		TRUE, TRUE,	0 },
 
   /* Certain types of verify are always allowed, so we let it through
   always and check in the verify function itself */
-  { US"verify",		TRUE, FALSE,
-    0
-  },
+  [ACLC_VERIFY] =		{ US"verify",		TRUE, FALSE, 0 },
 };
 
 
@@ -399,116 +397,142 @@ typedef struct control_def {
 } control_def;
 
 static control_def controls_list[] = {
+  /*	name			has_option	forbids */
+[CONTROL_AUTH_UNADVERTISED] =
   { US"allow_auth_unadvertised", FALSE,
-    (unsigned)
-    ~((1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO))
+				  (unsigned)
+				  ~((1<<ACL_WHERE_CONNECT)|(1<<ACL_WHERE_HELO))
   },
 #ifdef EXPERIMENTAL_BRIGHTMAIL
-  { US"bmi_run",                 FALSE, 0 },
+[CONTROL_BMI_RUN] =
+  { US"bmi_run",                 FALSE,		0 },
 #endif
+[CONTROL_CASEFUL_LOCAL_PART] =
   { US"caseful_local_part",      FALSE, (unsigned) ~(1<<ACL_WHERE_RCPT) },
+[CONTROL_CASELOWER_LOCAL_PART] =
   { US"caselower_local_part",    FALSE, (unsigned) ~(1<<ACL_WHERE_RCPT) },
-  { US"cutthrough_delivery",     TRUE, 0 },
-  { US"debug",                   TRUE, 0 },
+[CONTROL_CUTTHROUGH_DELIVERY] =
+  { US"cutthrough_delivery",     TRUE,		0 },
+[CONTROL_DEBUG] =
+  { US"debug",                   TRUE,		0 },
 
 #ifndef DISABLE_DKIM
+[CONTROL_DKIM_VERIFY] =
   { US"dkim_disable_verify",     FALSE,
-    (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|
+				  (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|
 # ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+				  (1<<ACL_WHERE_PRDR)|
 # endif
-      (1<<ACL_WHERE_NOTSMTP_START)
+				  (1<<ACL_WHERE_NOTSMTP_START)
   },
 #endif
 
 #ifdef EXPERIMENTAL_DMARC
+[CONTROL_DMARC_DISABLE_VERIFY] =
   { US"dmarc_disable_verify",    FALSE,
-    (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
   },
+[CONTROL_ENABLE_FORENSIC] =
   { US"dmarc_enable_forensic",   FALSE,
-    (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_DATA)|(1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
   },
 #endif
 
+[CONTROL_DSCP] =
   { US"dscp",                    TRUE,
-    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)|(1<<ACL_WHERE_NOTQUIT)
+	  (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)|(1<<ACL_WHERE_NOTQUIT)
   },
+[CONTROL_ENFORCE_SYNC] =
   { US"enforce_sync",            FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
   },
 
   /* Pseudo-value for decode errors */
+[CONTROL_ERROR] =
   { US"error",                   FALSE, 0 },
 
+[CONTROL_FAKEDEFER] =
   { US"fakedefer",               TRUE,
-    (unsigned)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
-      (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
+	  (unsigned)
+	  ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
+	    (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 #ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+	    (1<<ACL_WHERE_PRDR)|
 #endif
-      (1<<ACL_WHERE_MIME))
+	    (1<<ACL_WHERE_MIME))
   },
+[CONTROL_FAKEREJECT] =
   { US"fakereject",              TRUE,
-    (unsigned)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
-      (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
+	  (unsigned)
+	  ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
+	    (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
 #ifndef DISABLE_PRDR
-      (1<<ACL_WHERE_PRDR)|
+	  (1<<ACL_WHERE_PRDR)|
 #endif
-      (1<<ACL_WHERE_MIME))
+	  (1<<ACL_WHERE_MIME))
   },
+[CONTROL_FREEZE] =
   { US"freeze",                  TRUE,
-    (unsigned)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
-      (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
-      // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
-      (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_MIME))
+	  (unsigned)
+	  ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
+	    (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
+	    // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
+	    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_MIME))
   },
 
+[CONTROL_NO_CALLOUT_FLUSH] =
   { US"no_callout_flush",        FALSE,
-    (1<<ACL_WHERE_NOTSMTP)| (1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_NOTSMTP)| (1<<ACL_WHERE_NOTSMTP_START)
   },
+[CONTROL_NO_DELAY_FLUSH] =
   { US"no_delay_flush",          FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
   },
   
+[CONTROL_NO_ENFORCE_SYNC] =
   { US"no_enforce_sync",         FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
   },
 #ifdef WITH_CONTENT_SCAN
+[CONTROL_NO_MBOX_UNSPOOL] =
   { US"no_mbox_unspool",         FALSE,
-    (unsigned)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
-      (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
-      // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
-      (1<<ACL_WHERE_MIME))
+	(unsigned)
+	~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
+	  (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
+	  // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
+	  (1<<ACL_WHERE_MIME))
   },
 #endif
+[CONTROL_NO_MULTILINE] =
   { US"no_multiline_responses",  FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
   },
+[CONTROL_NO_PIPELINING] =
   { US"no_pipelining",           FALSE,
-    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
+	  (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_NOTSMTP_START)
   },
 
+[CONTROL_QUEUE_ONLY] =
   { US"queue_only",              FALSE,
-    (unsigned)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
-      (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
-      // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
-      (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_MIME))
+	  (unsigned)
+	  ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|
+	    (1<<ACL_WHERE_PREDATA)|(1<<ACL_WHERE_DATA)|
+	    // (1<<ACL_WHERE_PRDR)|    /* Not allow one user to freeze for all */
+	    (1<<ACL_WHERE_NOTSMTP)|(1<<ACL_WHERE_MIME))
   },
+[CONTROL_SUBMISSION] =
   { US"submission",              TRUE,
-    (unsigned)
-    ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|(1<<ACL_WHERE_PREDATA))
+	  (unsigned)
+	  ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|(1<<ACL_WHERE_PREDATA))
   },
+[CONTROL_SUPPRESS_LOCAL_FIXUPS] =
   { US"suppress_local_fixups",   FALSE,
     (unsigned)
     ~((1<<ACL_WHERE_MAIL)|(1<<ACL_WHERE_RCPT)|(1<<ACL_WHERE_PREDATA)|
       (1<<ACL_WHERE_NOTSMTP_START))
   },
 #ifdef SUPPORT_I18N
+[CONTROL_UTF8_DOWNCONVERT] =
   { US"utf8_downconvert",        TRUE, 0 }
 #endif
 };
@@ -532,24 +556,36 @@ further ACL conditions to distinguish ok, unknown, and defer if required, but
 the aim is to make the usual configuration simple. */
 
 static int csa_return_code[] = {
-  OK, OK, OK, OK,
-  FAIL, FAIL, FAIL, FAIL
+  [CSA_UNKNOWN] =	OK,
+  [CSA_OK] =		OK,
+  [CSA_DEFER_SRV] =	OK,
+  [CSA_DEFER_ADDR] =	OK,
+  [CSA_FAIL_EXPLICIT] =	FAIL,
+  [CSA_FAIL_DOMAIN] =	FAIL,
+  [CSA_FAIL_NOADDR] =	FAIL,
+  [CSA_FAIL_MISMATCH] =	FAIL
 };
 
 static uschar *csa_status_string[] = {
-  US"unknown", US"ok", US"defer", US"defer",
-  US"fail", US"fail", US"fail", US"fail"
+  [CSA_UNKNOWN] =	US"unknown",
+  [CSA_OK] =		US"ok",
+  [CSA_DEFER_SRV] =	US"defer",
+  [CSA_DEFER_ADDR] =	US"defer",
+  [CSA_FAIL_EXPLICIT] =	US"fail",
+  [CSA_FAIL_DOMAIN] =	US"fail",
+  [CSA_FAIL_NOADDR] =	US"fail",
+  [CSA_FAIL_MISMATCH] =	US"fail"
 };
 
 static uschar *csa_reason_string[] = {
-  US"unknown",
-  US"ok",
-  US"deferred (SRV lookup failed)",
-  US"deferred (target address lookup failed)",
-  US"failed (explicit authorization required)",
-  US"failed (host name not authorized)",
-  US"failed (no authorized addresses)",
-  US"failed (client address mismatch)"
+  [CSA_UNKNOWN] =	US"unknown",
+  [CSA_OK] =		US"ok",
+  [CSA_DEFER_SRV] =	US"deferred (SRV lookup failed)",
+  [CSA_DEFER_ADDR] =	US"deferred (target address lookup failed)",
+  [CSA_FAIL_EXPLICIT] =	US"failed (explicit authorization required)",
+  [CSA_FAIL_DOMAIN] =	US"failed (host name not authorized)",
+  [CSA_FAIL_NOADDR] =	US"failed (no authorized addresses)",
+  [CSA_FAIL_MISMATCH] =	US"failed (client address mismatch)"
 };
 
 /* Options for the ratelimit condition. Note that there are two variants of
@@ -567,8 +603,15 @@ enum {
   (((var) == RATE_PER_WHAT) ? ((var) = RATE_##new) : ((var) = RATE_PER_CLASH))
 
 static uschar *ratelimit_option_string[] = {
-  US"?", US"!", US"per_addr", US"per_byte", US"per_cmd",
-  US"per_conn", US"per_mail", US"per_rcpt", US"per_rcpt"
+  [RATE_PER_WHAT] =	US"?",
+  [RATE_PER_CLASH] =	US"!",
+  [RATE_PER_ADDR] =	US"per_addr",
+  [RATE_PER_BYTE] =	US"per_byte",
+  [RATE_PER_CMD] =	US"per_cmd",
+  [RATE_PER_CONN] =	US"per_conn",
+  [RATE_PER_MAIL] =	US"per_mail",
+  [RATE_PER_RCPT] =	US"per_rcpt",
+  [RATE_PER_ALLRCPTS] =	US"per_rcpt"
 };
 
 /* Enable recursion between acl_check_internal() and acl_check_condition() */
@@ -1482,6 +1525,7 @@ typedef struct {
   unsigned alt_opt_sep;		/* >0 Non-/ option separator (custom parser) */
   } verify_type_t;
 static verify_type_t verify_type_list[] = {
+    /*	name			value			where	no-opt opt-sep */
     { US"reverse_host_lookup",	VERIFY_REV_HOST_LKUP,	~0,	FALSE, 0 },
     { US"certificate",	  	VERIFY_CERT,	 	~0,	TRUE, 0 },
     { US"helo",	  		VERIFY_HELO,	 	~0,	TRUE, 0 },
@@ -1510,6 +1554,7 @@ typedef struct {
   BOOL     timeval;	/* Has a time value */
   } callout_opt_t;
 static callout_opt_t callout_opt_list[] = {
+    /*	name			value			flag		has-opt		has-time */
     { US"defer_ok",   	  CALLOUT_DEFER_OK,	 0,				FALSE, FALSE },
     { US"no_cache",   	  CALLOUT_NOCACHE,	 vopt_callout_no_cache,		FALSE, FALSE },
     { US"random",	  CALLOUT_RANDOM,	 vopt_callout_random,		FALSE, FALSE },
diff --git a/src/src/daemon.c b/src/src/daemon.c
index a05b79723..16e8bbacb 100644
--- a/src/src/daemon.c
+++ b/src/src/daemon.c
@@ -21,7 +21,7 @@ typedef struct smtp_slot {
 /* An empty slot for initializing (Standard C does not allow constructor
 expressions in assignments except as initializers in declarations). */
 
-static smtp_slot empty_smtp_slot = { 0, NULL };
+static smtp_slot empty_smtp_slot = { .pid = 0, .host_address = NULL };
 
 
 
diff --git a/src/src/dane-openssl.c b/src/src/dane-openssl.c
index 97acccb5a..8db73d086 100644
--- a/src/src/dane-openssl.c
+++ b/src/src/dane-openssl.c
@@ -84,6 +84,7 @@ typedef int CRYPTO_ONCE;
 #ifndef OPENSSL_NO_ERR
 #define	DANESSL_F_PLACEHOLDER		0		/* FIRST! Value TBD */
 static ERR_STRING_DATA dane_str_functs[] = {
+    /*	error				string */
     {DANESSL_F_PLACEHOLDER,		"DANE library"},	/* FIRST!!! */
     {DANESSL_F_ADD_SKID,		"add_skid"},
     {DANESSL_F_ADD_TLSA,		"DANESSL_add_tlsa"},
@@ -101,6 +102,7 @@ static ERR_STRING_DATA dane_str_functs[] = {
     {0,					NULL}
 };
 static ERR_STRING_DATA dane_str_reasons[] = {
+    /*	error				string */
     {DANESSL_R_BAD_CERT,	"Bad TLSA record certificate"},
     {DANESSL_R_BAD_CERT_PKEY,	"Bad TLSA record certificate public key"},
     {DANESSL_R_BAD_DATA_LENGTH,	"Bad TLSA record digest length"},
diff --git a/src/src/deliver.c b/src/src/deliver.c
index 0f2efbecf..b4f7ad54d 100644
--- a/src/src/deliver.c
+++ b/src/src/deliver.c
@@ -1233,7 +1233,7 @@ if (LOGGING(queue_time))
 
 if (LOGGING(deliver_time))
   {
-  struct timeval diff = {addr->more_errno, addr->delivery_usec};
+  struct timeval diff = {.tv_sec = addr->more_errno, .tv_usec = addr->delivery_usec};
   s = string_append(s, &size, &ptr, 2, US" DT=", string_timediff(&diff));
   }
 
diff --git a/src/src/dmarc.c b/src/src/dmarc.c
index 275ad46c7..a0eccac3a 100644
--- a/src/src/dmarc.c
+++ b/src/src/dmarc.c
@@ -44,6 +44,7 @@ typedef struct dmarc_exim_p {
 } dmarc_exim_p;
 
 static dmarc_exim_p dmarc_policy_description[] = {
+  /* name		value */
   { US"",           DMARC_RECORD_P_UNSPECIFIED },
   { US"none",       DMARC_RECORD_P_NONE },
   { US"quarantine", DMARC_RECORD_P_QUARANTINE },
diff --git a/src/src/drtables.c b/src/src/drtables.c
index c2419726e..10b4ae8e0 100644
--- a/src/src/drtables.c
+++ b/src/src/drtables.c
@@ -61,117 +61,117 @@ auth_info auths_available[] = {
 
 #ifdef AUTH_CRAM_MD5
   {
-  US"cram_md5",                              /* lookup name */
-  auth_cram_md5_options,
-  &auth_cram_md5_options_count,
-  &auth_cram_md5_option_defaults,
-  sizeof(auth_cram_md5_options_block),
-  auth_cram_md5_init,                        /* init function */
-  auth_cram_md5_server,                      /* server function */
-  auth_cram_md5_client,                      /* client function */
-  NULL                                       /* diagnostic function */
+  .driver_name =	US"cram_md5",                              /* lookup name */
+  .options =		auth_cram_md5_options,
+  .options_count =	&auth_cram_md5_options_count,
+  .options_block =	&auth_cram_md5_option_defaults,
+  .options_len =	sizeof(auth_cram_md5_options_block),
+  .init =		auth_cram_md5_init,
+  .servercode =		auth_cram_md5_server,
+  .clientcode =		auth_cram_md5_client,
+  .version_report =	NULL
   },
 #endif
 
 #ifdef AUTH_CYRUS_SASL
   {
-  US"cyrus_sasl",           /* lookup name */
-  auth_cyrus_sasl_options,
-  &auth_cyrus_sasl_options_count,
-  &auth_cyrus_sasl_option_defaults,
-  sizeof(auth_cyrus_sasl_options_block),
-  auth_cyrus_sasl_init,                      /* init function */
-  auth_cyrus_sasl_server,                    /* server function */
-  NULL,                                      /* client function */
-  auth_cyrus_sasl_version_report             /* diagnostic function */
+  .driver_name =	US"cyrus_sasl",
+  .options =		auth_cyrus_sasl_options,
+  .options_count =	&auth_cyrus_sasl_options_count,
+  .options_block =	&auth_cyrus_sasl_option_defaults,
+  .options_len =	sizeof(auth_cyrus_sasl_options_block),
+  .init =		auth_cyrus_sasl_init,
+  .servercode =		auth_cyrus_sasl_server,
+  .clientcode =		NULL,
+  .version_report =	auth_cyrus_sasl_version_report
   },
 #endif
 
 #ifdef AUTH_DOVECOT
   {
-  US"dovecot",                                /* lookup name */
-  auth_dovecot_options,
-  &auth_dovecot_options_count,
-  &auth_dovecot_option_defaults,
-  sizeof(auth_dovecot_options_block),
-  auth_dovecot_init,                          /* init function */
-  auth_dovecot_server,                        /* server function */
-  NULL,                                       /* client function */
-  NULL                                        /* diagnostic function */
+  .driver_name =	US"dovecot",
+  .options =		auth_dovecot_options,
+  .options_count =	&auth_dovecot_options_count,
+  .options_block =	&auth_dovecot_option_defaults,
+  .options_len =	sizeof(auth_dovecot_options_block),
+  .init =		auth_dovecot_init,
+  .servercode =		auth_dovecot_server,
+  .clientcode =		NULL,
+  .version_report =	NULL
   },
 #endif
 
 #ifdef AUTH_GSASL
   {
-  US"gsasl",                                  /* lookup name */
-  auth_gsasl_options,
-  &auth_gsasl_options_count,
-  &auth_gsasl_option_defaults,
-  sizeof(auth_gsasl_options_block),
-  auth_gsasl_init,                            /* init function */
-  auth_gsasl_server,                          /* server function */
-  NULL,                                       /* client function */
-  auth_gsasl_version_report                   /* diagnostic function */
+  .driver_name =	US"gsasl",
+  .options =		auth_gsasl_options,
+  .options_count =	&auth_gsasl_options_count,
+  .options_block =	&auth_gsasl_option_defaults,
+  .options_len =	sizeof(auth_gsasl_options_block),
+  .init =		auth_gsasl_init,
+  .servercode =		auth_gsasl_server,
+  .clientcode =		NULL,
+  .version_report =	auth_gsasl_version_report
   },
 #endif
 
 #ifdef AUTH_HEIMDAL_GSSAPI
   {
-  US"heimdal_gssapi",                         /* lookup name */
-  auth_heimdal_gssapi_options,
-  &auth_heimdal_gssapi_options_count,
-  &auth_heimdal_gssapi_option_defaults,
-  sizeof(auth_heimdal_gssapi_options_block),
-  auth_heimdal_gssapi_init,                   /* init function */
-  auth_heimdal_gssapi_server,                 /* server function */
-  NULL,                                       /* client function */
-  auth_heimdal_gssapi_version_report          /* diagnostic function */
+  .driver_name =	US"heimdal_gssapi",
+  .options =		auth_heimdal_gssapi_options,
+  .options_count 	 &auth_heimdal_gssapi_options_count,
+  .options_block =	&auth_heimdal_gssapi_option_defaults,
+  .options_len =	sizeof(auth_heimdal_gssapi_options_block),
+  .init =		auth_heimdal_gssapi_init,
+  .servercode =		auth_heimdal_gssapi_server,
+  .clientcode =		NULL,
+  .version_report =	auth_heimdal_gssapi_version_report
   },
 #endif
 
 #ifdef AUTH_PLAINTEXT
   {
-  US"plaintext",                             /* lookup name */
-  auth_plaintext_options,
-  &auth_plaintext_options_count,
-  &auth_plaintext_option_defaults,
-  sizeof(auth_plaintext_options_block),
-  auth_plaintext_init,                       /* init function */
-  auth_plaintext_server,                     /* server function */
-  auth_plaintext_client,                     /* client function */
-  NULL                                       /* diagnostic function */
+  .driver_name =	US"plaintext",
+  .options =		auth_plaintext_options,
+  .options_count =	&auth_plaintext_options_count,
+  .options_block =	&auth_plaintext_option_defaults,
+  .options_len =	sizeof(auth_plaintext_options_block),
+  .init =		auth_plaintext_init,
+  .servercode =		auth_plaintext_server,
+  .clientcode =		auth_plaintext_client,
+  .version_report =	NULL
   },
 #endif
 
 #ifdef AUTH_SPA
   {
-  US"spa",                                   /* lookup name */
-  auth_spa_options,
-  &auth_spa_options_count,
-  &auth_spa_option_defaults,
-  sizeof(auth_spa_options_block),
-  auth_spa_init,                             /* init function */
-  auth_spa_server,                           /* server function */
-  auth_spa_client,                           /* client function */
-  NULL                                       /* diagnostic function */
+  .driver_name =	US"spa",
+  .options =		auth_spa_options,
+  .options_count =	&auth_spa_options_count,
+  .options_block =	&auth_spa_option_defaults,
+  .options_len =	sizeof(auth_spa_options_block),
+  .init =		auth_spa_init,
+  .servercode =		auth_spa_server,
+  .clientcode =		auth_spa_client,
+  .version_report =	NULL
   },
 #endif
 
 #ifdef AUTH_TLS
   {
-  US"tls",                                   /* lookup name */
-  auth_tls_options,
-  &auth_tls_options_count,
-  &auth_tls_option_defaults,
-  sizeof(auth_tls_options_block),
-  auth_tls_init,                             /* init function */
-  auth_tls_server,                           /* server function */
-  NULL,                                      /* client function */
-  NULL                                       /* diagnostic function */
+  .driver_name =	US"tls",
+  .options =		auth_tls_options,
+  .options_count =	&auth_tls_options_count,
+  .options_block =	&auth_tls_option_defaults,
+  .options_len =	sizeof(auth_tls_options_block),
+  .init =		auth_tls_init,
+  .servercode =		auth_tls_server,
+  .clientcode =		NULL,
+  .version_report =	NULL
   },
 #endif
 
-{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL  }
+{ .driver_name = US"" }		/* end marker */
 };
 
 
@@ -240,96 +240,96 @@ exim binary. */
 router_info routers_available[] = {
 #ifdef ROUTER_ACCEPT
   {
-  US"accept",
-  accept_router_options,
-  &accept_router_options_count,
-  &accept_router_option_defaults,
-  sizeof(accept_router_options_block),
-  accept_router_init,
-  accept_router_entry,
-  NULL,     /* no tidyup entry */
-  ri_yestransport
+  .driver_name =	US"accept",
+  .options =		accept_router_options,
+  .options_count =	&accept_router_options_count,
+  .options_block =	&accept_router_option_defaults,
+  .options_len =	sizeof(accept_router_options_block),
+  .init =		accept_router_init,
+  .code =		accept_router_entry,
+  .tidyup =		NULL,     /* no tidyup entry */
+  .ri_flags =		ri_yestransport
   },
 #endif
 #ifdef ROUTER_DNSLOOKUP
   {
-  US"dnslookup",
-  dnslookup_router_options,
-  &dnslookup_router_options_count,
-  &dnslookup_router_option_defaults,
-  sizeof(dnslookup_router_options_block),
-  dnslookup_router_init,
-  dnslookup_router_entry,
-  NULL,     /* no tidyup entry */
-  ri_yestransport
+  .driver_name =	US"dnslookup",
+  .options =		dnslookup_router_options,
+  .options_count =	&dnslookup_router_options_count,
+  .options_block =	&dnslookup_router_option_defaults,
+  .options_len =	sizeof(dnslookup_router_options_block),
+  .init =		dnslookup_router_init,
+  .code =		dnslookup_router_entry,
+  .tidyup =		NULL,     /* no tidyup entry */
+  .ri_flags =		ri_yestransport
   },
 #endif
 #ifdef ROUTER_IPLITERAL
   {
-  US"ipliteral",
-  ipliteral_router_options,
-  &ipliteral_router_options_count,
-  &ipliteral_router_option_defaults,
-  sizeof(ipliteral_router_options_block),
-  ipliteral_router_init,
-  ipliteral_router_entry,
-  NULL,     /* no tidyup entry */
-  ri_yestransport
+  .driver_name =	US"ipliteral",
+  .options =		ipliteral_router_options,
+  .options_count =	&ipliteral_router_options_count,
+  .options_block =	&ipliteral_router_option_defaults,
+  .options_len =	sizeof(ipliteral_router_options_block),
+  .init =		ipliteral_router_init,
+  .code =		ipliteral_router_entry,
+  .tidyup =		NULL,     /* no tidyup entry */
+  .ri_flags =		ri_yestransport
   },
 #endif
 #ifdef ROUTER_IPLOOKUP
   {
-  US"iplookup",
-  iplookup_router_options,
-  &iplookup_router_options_count,
-  &iplookup_router_option_defaults,
-  sizeof(iplookup_router_options_block),
-  iplookup_router_init,
-  iplookup_router_entry,
-  NULL,     /* no tidyup entry */
-  ri_notransport
+  .driver_name =	US"iplookup",
+  .options =		iplookup_router_options,
+  .options_count =	&iplookup_router_options_count,
+  .options_block =	&iplookup_router_option_defaults,
+  .options_len =	sizeof(iplookup_router_options_block),
+  .init =		iplookup_router_init,
+  .code =		iplookup_router_entry,
+  .tidyup =		NULL,     /* no tidyup entry */
+  .ri_flags =		ri_notransport
   },
 #endif
 #ifdef ROUTER_MANUALROUTE
   {
-  US"manualroute",
-  manualroute_router_options,
-  &manualroute_router_options_count,
-  &manualroute_router_option_defaults,
-  sizeof(manualroute_router_options_block),
-  manualroute_router_init,
-  manualroute_router_entry,
-  NULL,     /* no tidyup entry */
-  0
+  .driver_name =	US"manualroute",
+  .options =		manualroute_router_options,
+  .options_count =	&manualroute_router_options_count,
+  .options_block =	&manualroute_router_option_defaults,
+  .options_len =	sizeof(manualroute_router_options_block),
+  .init =		manualroute_router_init,
+  .code =		manualroute_router_entry,
+  .tidyup =		NULL,     /* no tidyup entry */
+  .ri_flags =		0
   },
 #endif
 #ifdef ROUTER_QUERYPROGRAM
   {
-  US"queryprogram",
-  queryprogram_router_options,
-  &queryprogram_router_options_count,
-  &queryprogram_router_option_defaults,
-  sizeof(queryprogram_router_options_block),
-  queryprogram_router_init,
-  queryprogram_router_entry,
-  NULL,     /* no tidyup entry */
-  0
+  .driver_name =	US"queryprogram",
+  .options =		queryprogram_router_options,
+  .options_count =	&queryprogram_router_options_count,
+  .options_block =	&queryprogram_router_option_defaults,
+  .options_len =	sizeof(queryprogram_router_options_block),
+  .init =		queryprogram_router_init,
+  .code =		queryprogram_router_entry,
+  .tidyup =		NULL,     /* no tidyup entry */
+  .ri_flags =		0
   },
 #endif
 #ifdef ROUTER_REDIRECT
   {
-  US"redirect",
-  redirect_router_options,
-  &redirect_router_options_count,
-  &redirect_router_option_defaults,
-  sizeof(redirect_router_options_block),
-  redirect_router_init,
-  redirect_router_entry,
-  NULL,     /* no tidyup entry */
-  ri_notransport
+  .driver_name =	US"redirect",
+  .options =		redirect_router_options,
+  .options_count =	&redirect_router_options_count,
+  .options_block =	&redirect_router_option_defaults,
+  .options_len =	sizeof(redirect_router_options_block),
+  .init =		redirect_router_init,
+  .code =		redirect_router_entry,
+  .tidyup =		NULL,     /* no tidyup entry */
+  .ri_flags =		ri_notransport
   },
 #endif
-{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL, 0 }
+{ US"" }
 };
 
 
@@ -337,89 +337,89 @@ router_info routers_available[] = {
 transport_info transports_available[] = {
 #ifdef TRANSPORT_APPENDFILE
   {
-  US"appendfile",                              /* driver name */
-  appendfile_transport_options,                /* local options table */
-  &appendfile_transport_options_count,         /* number of entries */
-  &appendfile_transport_option_defaults,       /* private options defaults */
-  sizeof(appendfile_transport_options_block),  /* size of private block */
-  appendfile_transport_init,                   /* init entry point */
-  appendfile_transport_entry,                  /* main entry point */
-  NULL,                                        /* no tidyup entry */
-  NULL,                                        /* no closedown entry */
-  TRUE,                                        /* local flag */
+  .driver_name =	US"appendfile",
+  .options =		appendfile_transport_options,
+  .options_count =	&appendfile_transport_options_count,
+  .options_block =	&appendfile_transport_option_defaults,       /* private options defaults */
+  .options_len =	sizeof(appendfile_transport_options_block),
+  .init =		appendfile_transport_init,
+  .code =		appendfile_transport_entry,
+  .tidyup =		NULL,
+  .closedown =		NULL,
+  .local =		TRUE
   },
 #endif
 #ifdef TRANSPORT_AUTOREPLY
   {
-  US"autoreply",                               /* driver name */
-  autoreply_transport_options,                 /* local options table */
-  &autoreply_transport_options_count,          /* number of entries */
-  &autoreply_transport_option_defaults,        /* private options defaults */
-  sizeof(autoreply_transport_options_block),   /* size of private block */
-  autoreply_transport_init,                    /* init entry point */
-  autoreply_transport_entry,                   /* main entry point */
-  NULL,                                        /* no tidyup entry */
-  NULL,                                        /* no closedown entry */
-  TRUE                                         /* local flag */
+  .driver_name =	US"autoreply",
+  .options =		autoreply_transport_options,
+  .options_count =	&autoreply_transport_options_count,
+  .options_block =	&autoreply_transport_option_defaults,
+  .options_len =	sizeof(autoreply_transport_options_block),
+  .init =		autoreply_transport_init,
+  .code =		autoreply_transport_entry,
+  .tidyup =		NULL,
+  .closedown =		NULL,
+  .local =		TRUE
   },
 #endif
 #ifdef TRANSPORT_LMTP
   {
-  US"lmtp",                                    /* driver name */
-  lmtp_transport_options,                      /* local options table */
-  &lmtp_transport_options_count,               /* number of entries */
-  &lmtp_transport_option_defaults,             /* private options defaults */
-  sizeof(lmtp_transport_options_block),        /* size of private block */
-  lmtp_transport_init,                         /* init entry point */
-  lmtp_transport_entry,                        /* main entry point */
-  NULL,                                        /* no tidyup entry */
-  NULL,                                        /* no closedown entry */
-  TRUE                                         /* local flag */
+  .driver_name =	US"lmtp",
+  .options =		lmtp_transport_options,
+  .options_count =	&lmtp_transport_options_count,
+  .options_block =	&lmtp_transport_option_defaults,
+  .options_len =	sizeof(lmtp_transport_options_block),
+  .init =		lmtp_transport_init,
+  .code =		lmtp_transport_entry,
+  .tidyup =		NULL,
+  .closedown =		NULL,
+  .local =		TRUE
   },
 #endif
 #ifdef TRANSPORT_PIPE
   {
-  US"pipe",                                    /* driver name */
-  pipe_transport_options,                      /* local options table */
-  &pipe_transport_options_count,               /* number of entries */
-  &pipe_transport_option_defaults,             /* private options defaults */
-  sizeof(pipe_transport_options_block),        /* size of private block */
-  pipe_transport_init,                         /* init entry point */
-  pipe_transport_entry,                        /* main entry point */
-  NULL,                                        /* no tidyup entry */
-  NULL,                                        /* no closedown entry */
-  TRUE                                         /* local flag */
+  .driver_name =	US"pipe",
+  .options =		pipe_transport_options,
+  .options_count =	&pipe_transport_options_count,
+  .options_block =	&pipe_transport_option_defaults,
+  .options_len =	sizeof(pipe_transport_options_block),
+  .init =		pipe_transport_init,
+  .code =		pipe_transport_entry,
+  .tidyup =		NULL,
+  .closedown =		NULL,
+  .local =		TRUE
   },
 #endif
 #ifdef EXPERIMENTAL_QUEUEFILE
   {
-  US"queuefile",                               /* driver name */
-  queuefile_transport_options,                 /* local options table */
-  &queuefile_transport_options_count,          /* number of entries */
-  &queuefile_transport_option_defaults,        /* private options defaults */
-  sizeof(queuefile_transport_options_block),   /* size of private block */
-  queuefile_transport_init,                    /* init entry point */
-  queuefile_transport_entry,                   /* main entry point */
-  NULL,                                        /* no tidyup entry */
-  NULL,                                        /* no closedown entry */
-  TRUE                                         /* local flag */
+  .driver_name =	US"queuefile",
+  .options =		queuefile_transport_options,
+  .options_count =	&queuefile_transport_options_count,
+  .options_block =	&queuefile_transport_option_defaults,
+  .options_len =	sizeof(queuefile_transport_options_block),
+  .init =		queuefile_transport_init,
+  .code =		queuefile_transport_entry,
+  .tidyup =		NULL,
+  .closedown =		NULL,
+  .local =		TRUE
   },
 #endif
 #ifdef TRANSPORT_SMTP
   {
-  US"smtp",                                    /* driver name */
-  smtp_transport_options,                      /* local options table */
-  &smtp_transport_options_count,               /* number of entries */
-  &smtp_transport_option_defaults,             /* private options defaults */
-  sizeof(smtp_transport_options_block),        /* size of private block */
-  smtp_transport_init,                         /* init entry point */
-  smtp_transport_entry,                        /* main entry point */
-  NULL,                                        /* no tidyup entry */
-  smtp_transport_closedown,                    /* close down passed channel */
-  FALSE                                        /* local flag */
+  .driver_name =	US"smtp",
+  .options =		smtp_transport_options,
+  .options_count =	&smtp_transport_options_count,
+  .options_block =	&smtp_transport_option_defaults,
+  .options_len =	sizeof(smtp_transport_options_block),
+  .init =		smtp_transport_init,
+  .code =		smtp_transport_entry,
+  .tidyup =		NULL,
+  .closedown =		smtp_transport_closedown,
+  .local =		FALSE
   },
 #endif
-{ US"", NULL, NULL, NULL, 0, NULL, NULL, NULL, NULL, FALSE }
+{ US"" }
 };
 
 
diff --git a/src/src/exim.c b/src/src/exim.c
index 725d4d4f5..419561c85 100644
--- a/src/src/exim.c
+++ b/src/src/exim.c
@@ -5592,7 +5592,7 @@ while (more)
 
     if (!receive_timeout)
       {
-      struct timeval t = { 30*60, 0 };	/* 30 minutes */
+      struct timeval t = { .tv_sec = 30*60, .tv_usec = 0 };	/* 30 minutes */
       fd_set r;
 
       FD_ZERO(&r); FD_SET(0, &r);
diff --git a/src/src/globals.c b/src/src/globals.c
index 9abacff8c..b9cdb88d4 100644
--- a/src/src/globals.c
+++ b/src/src/globals.c
@@ -101,38 +101,38 @@ cluttered in several places (e.g. during logging) if we can always refer to
 them. Also, the tls_ variables are now always visible. */
 
 tls_support tls_in = {
- -1,   /* tls_active */
- 0,    /* tls_bits */
- FALSE,/* tls_certificate_verified */
+ .active =		-1,
+ .bits =		0,
+ .certificate_verified = FALSE,
 #ifdef EXPERIMENTAL_DANE
- FALSE,/* dane_verified */
- 0,    /* tlsa_usage */
+ .dane_verified =	FALSE,
+ .tlsa_usage =		0,
 #endif
- NULL, /* tls_cipher */
- FALSE,/* tls_on_connect */
- NULL, /* tls_on_connect_ports */
- NULL, /* tls_ourcert */
- NULL, /* tls_peercert */
- NULL, /* tls_peerdn */
- NULL, /* tls_sni */
- 0     /* tls_ocsp */
+ .cipher =		NULL,
+ .on_connect =		FALSE,
+ .on_connect_ports =	NULL,
+ .ourcert =		NULL,
+ .peercert =		NULL,
+ .peerdn =		NULL,
+ .sni =			NULL,
+ .ocsp =		OCSP_NOT_REQ
 };
 tls_support tls_out = {
- -1,   /* tls_active */
- 0,    /* tls_bits */
- FALSE,/* tls_certificate_verified */
+ .active =		-1,
+ .bits =		0,
+ .certificate_verified = FALSE,
 #ifdef EXPERIMENTAL_DANE
- FALSE,/* dane_verified */
- 0,    /* tlsa_usage */
+ .dane_verified =	FALSE,
+ .tlsa_usage =		0,
 #endif
- NULL, /* tls_cipher */
- FALSE,/* tls_on_connect */
- NULL, /* tls_on_connect_ports */
- NULL, /* tls_ourcert */
- NULL, /* tls_peercert */
- NULL, /* tls_peerdn */
- NULL, /* tls_sni */
- 0     /* tls_ocsp */
+ .cipher =		NULL,
+ .on_connect =		FALSE,
+ .on_connect_ports =	NULL,
+ .ourcert =		NULL,
+ .peercert =		NULL,
+ .peerdn =		NULL,
+ .sni =			NULL,
+ .ocsp =		OCSP_NOT_REQ
 };
 
 uschar *dsn_envid              = NULL;
@@ -328,79 +328,81 @@ uschar *add_environment        = NULL;
 address_item  *addr_duplicate  = NULL;
 
 address_item address_defaults = {
-  NULL,                 /* next */
-  NULL,                 /* parent */
-  NULL,                 /* first */
-  NULL,                 /* dupof */
-  NULL,                 /* start_router */
-  NULL,                 /* router */
-  NULL,                 /* transport */
-  NULL,                 /* host_list */
-  NULL,                 /* host_used */
-  NULL,                 /* fallback_hosts */
-  NULL,                 /* reply */
-  NULL,                 /* retries */
-  NULL,                 /* address */
-  NULL,                 /* unique */
-  NULL,                 /* cc_local_part */
-  NULL,                 /* lc_local_part */
-  NULL,                 /* local_part */
-  NULL,                 /* prefix */
-  NULL,                 /* suffix */
-  NULL,                 /* domain */
-  NULL,                 /* address_retry_key */
-  NULL,                 /* domain_retry_key */
-  NULL,                 /* current_dir */
-  NULL,                 /* home_dir */
-  NULL,                 /* message */
-  NULL,                 /* user_message */
-  NULL,                 /* onetime_parent */
-  NULL,                 /* pipe_expandn */
-  NULL,                 /* return_filename */
-  NULL,                 /* self_hostname */
-  NULL,                 /* shadow_message */
+  .next =		NULL,
+  .parent =		NULL,
+  .first =		NULL,
+  .dupof =		NULL,
+  .start_router =	NULL,
+  .router =		NULL,
+  .transport =		NULL,
+  .host_list =		NULL,
+  .host_used =		NULL,
+  .fallback_hosts =	NULL,
+  .reply =		NULL,
+  .retries =		NULL,
+  .address =		NULL,
+  .unique =		NULL,
+  .cc_local_part =	NULL,
+  .lc_local_part =	NULL,
+  .local_part =		NULL,
+  .prefix =		NULL,
+  .suffix =		NULL,
+  .domain =		NULL,
+  .address_retry_key =	NULL,
+  .domain_retry_key =	NULL,
+  .current_dir =	NULL,
+  .home_dir =		NULL,
+  .message =		NULL,
+  .user_message =	NULL,
+  .onetime_parent =	NULL,
+  .pipe_expandn =	NULL,
+  .return_filename =	NULL,
+  .self_hostname =	NULL,
+  .shadow_message =	NULL,
 #ifdef SUPPORT_TLS
-  NULL,                 /* cipher */
-  NULL,			/* ourcert */
-  NULL,			/* peercert */
-  NULL,                 /* peerdn */
-  OCSP_NOT_REQ,         /* ocsp */
+  .cipher =		NULL,
+  .ourcert =		NULL,
+  .peercert =		NULL,
+  .peerdn =		NULL,
+  .ocsp =		OCSP_NOT_REQ,
 #endif
 #ifdef EXPERIMENTAL_DSN_INFO
-  NULL,			/* smtp_greeting */
-  NULL,			/* helo_response */
+  .smtp_greeting =	NULL,
+  .helo_response =	NULL,
 #endif
-  NULL,			/* authenticator */
-  NULL,			/* auth_id */
-  NULL,			/* auth_sndr */
-  NULL,                 /* dsn_orcpt */
-  0,                    /* dsn_flags */
-  0,                    /* dsn_aware */
-  (uid_t)(-1),          /* uid */
-  (gid_t)(-1),          /* gid */
-  0,                    /* flags */
-  { 0 },                /* domain_cache - any larger array should be zeroed */
-  { 0 },                /* localpart_cache - ditto */
-  -1,                   /* mode */
-  0,                    /* more_errno */
-  0,			/* delivery_usec */
-  ERRNO_UNKNOWNERROR,   /* basic_errno */
-  0,                    /* child_count */
-  -1,                   /* return_file */
-  SPECIAL_NONE,         /* special_action */
-  DEFER,                /* transport_return */
-  {                     /* fields that are propagated to children */
-    NULL,               /* address_data */
-    NULL,               /* domain_data */
-    NULL,               /* localpart_data */
-    NULL,               /* errors_address */
-    NULL,               /* extra_headers */
-    NULL,               /* remove_headers */
+  .authenticator =	NULL,
+  .auth_id =		NULL,
+  .auth_sndr =		NULL,
+  .dsn_orcpt =		NULL,
+  .dsn_flags =		0,
+  .dsn_aware =		0,
+  .uid =		(uid_t)(-1),
+  .gid =		(gid_t)(-1),
+  .flags =		0,
+  .domain_cache =	{ 0 },                /* domain_cache - any larger array should be zeroed */
+  .localpart_cache =	{ 0 },                /* localpart_cache - ditto */
+  .mode =		-1,
+  .more_errno =		0,
+  .delivery_usec =	0,
+  .basic_errno =	ERRNO_UNKNOWNERROR,
+  .child_count =	0,
+  .return_file =	-1,
+  .special_action =	SPECIAL_NONE,
+  .transport_return =	DEFER,
+  .prop = {					/* fields that are propagated to children */
+    .address_data =	NULL,
+    .domain_data =	NULL,
+    .localpart_data =	NULL,
+    .errors_address =	NULL,
+    .extra_headers =	NULL,
+    .remove_headers =	NULL,
 #ifdef EXPERIMENTAL_SRS
-    NULL,               /* srs_sender */
+    .srs_sender =	NULL,
 #endif
 #ifdef SUPPORT_I18N
-    FALSE,		/* utf8 */
+    .utf8_msg =		FALSE,
+    .utf8_downcvt =	FALSE,
+    .utf8_downcvt_maybe = FALSE
 #endif
   }
 };
@@ -425,22 +427,22 @@ BOOL    authentication_failed  = FALSE;
 auth_instance  *auths          = NULL;
 uschar *auth_advertise_hosts   = US"*";
 auth_instance auth_defaults    = {
-    NULL,                      /* chain pointer */
-    NULL,                      /* name */
-    NULL,                      /* info */
-    NULL,                      /* private options block pointer */
-    NULL,                      /* driver_name */
-    NULL,                      /* advertise_condition */
-    NULL,                      /* client_condition */
-    NULL,                      /* public_name */
-    NULL,                      /* set_id */
-    NULL,                      /* set_client_id */
-    NULL,                      /* server_mail_auth_condition */
-    NULL,                      /* server_debug_string */
-    NULL,                      /* server_condition */
-    FALSE,                     /* client */
-    FALSE,                     /* server */
-    FALSE                      /* advertised */
+    .next =		NULL,
+    .name =		NULL,
+    .info =		NULL,
+    .options_block =	NULL,
+    .driver_name =	NULL,
+    .advertise_condition = NULL,
+    .client_condition =	NULL,
+    .public_name =	NULL,
+    .set_id =		NULL,
+    .set_client_id =	NULL,
+    .mail_auth_condition = NULL,
+    .server_debug_string = NULL,
+    .server_condition =	NULL,
+    .client =		FALSE,
+    .server =		FALSE,
+    .advertised =	FALSE
 };
 
 uschar *auth_defer_msg         = US"reason not recorded";
@@ -543,12 +545,12 @@ uschar *continue_transport     = NULL;
 
 uschar *csa_status             = NULL;
 cut_t   cutthrough = {
-  FALSE,				/* verify-only: normal delivery */
-  FALSE,				/* delivery: when to attempt */
-  FALSE,				/* on defer: spool locally */
-  FALSE,				/* not a TLS conn yet */
-  -1,					/* fd: open connection */
-  0,					/* nrcpt: number of addresses */
+  .callout_hold_only =	FALSE,				/* verify-only: normal delivery */
+  .delivery =		FALSE,				/* when to attempt */
+  .defer_pass =		FALSE,				/* on defer: spool locally */
+  .is_tls =		FALSE,				/* not a TLS conn yet */
+  .fd =			-1,				/* open connection */
+  .nrcpt =		0,				/* number of addresses */
 };
 
 BOOL    daemon_listen          = FALSE;
@@ -764,19 +766,20 @@ int     header_maxsize         = HEADER_MAXSIZE;
 int     header_line_maxsize    = 0;
 
 header_name header_names[] = {
-  { US"bcc",            3, TRUE,  htype_bcc },
-  { US"cc",             2, TRUE,  htype_cc },
-  { US"date",           4, TRUE,  htype_date },
-  { US"delivery-date", 13, FALSE, htype_delivery_date },
-  { US"envelope-to",   11, FALSE, htype_envelope_to },
-  { US"from",           4, TRUE,  htype_from },
-  { US"message-id",    10, TRUE,  htype_id },
-  { US"received",       8, FALSE, htype_received },
-  { US"reply-to",       8, FALSE, htype_reply_to },
-  { US"return-path",   11, FALSE, htype_return_path },
-  { US"sender",         6, TRUE,  htype_sender },
-  { US"subject",        7, FALSE, htype_subject },
-  { US"to",             2, TRUE,  htype_to }
+  /* name		len	allow_resent	htype */
+  { US"bcc",            3,	TRUE,		htype_bcc },
+  { US"cc",             2,	TRUE,		htype_cc },
+  { US"date",           4,	TRUE,		htype_date },
+  { US"delivery-date", 13,	FALSE,		htype_delivery_date },
+  { US"envelope-to",   11,	FALSE,		htype_envelope_to },
+  { US"from",           4,	TRUE,		htype_from },
+  { US"message-id",    10,	TRUE,		htype_id },
+  { US"received",       8,	FALSE,		htype_received },
+  { US"reply-to",       8,	FALSE,		htype_reply_to },
+  { US"return-path",   11,	FALSE,		htype_return_path },
+  { US"sender",         6,	TRUE,		htype_sender },
+  { US"subject",        7,	FALSE,		htype_subject },
+  { US"to",             2,	TRUE,		htype_to }
 };
 
 int header_names_size          = sizeof(header_names)/sizeof(header_name);
@@ -1151,83 +1154,83 @@ uid_t   root_uid               = ROOT_UID;
 
 router_instance  *routers  = NULL;
 router_instance  router_defaults = {
-    NULL,                      /* chain pointer */
-    NULL,                      /* name */
-    NULL,                      /* info */
-    NULL,                      /* private options block pointer */
-    NULL,                      /* driver name */
+    .next =			NULL,
+    .name =			NULL,
+    .info =			NULL,
+    .options_block =		NULL,
+    .driver_name =		NULL,
 
-    NULL,                      /* address_data */
+    .address_data =		NULL,
 #ifdef EXPERIMENTAL_BRIGHTMAIL
-    NULL,                      /* bmi_rule */
+    .bmi_rule =			NULL,
 #endif
-    NULL,                      /* cannot_route_message */
-    NULL,                      /* condition */
-    NULL,                      /* current_directory */
-    NULL,                      /* debug_string */
-    NULL,                      /* domains */
-    NULL,                      /* errors_to */
-    NULL,                      /* expand_gid */
-    NULL,                      /* expand_uid */
-    NULL,                      /* expand_more */
-    NULL,                      /* expand_unseen */
-    NULL,                      /* extra_headers */
-    NULL,                      /* fallback_hosts */
-    NULL,                      /* home_directory */
-    NULL,                      /* ignore_target_hosts */
-    NULL,                      /* local_parts */
-    NULL,                      /* pass_router_name */
-    NULL,                      /* prefix */
-    NULL,                      /* redirect_router_name */
-    NULL,                      /* remove_headers */
-    NULL,                      /* require_files */
-    NULL,                      /* router_home_directory */
-    US"freeze",                /* self */
-    NULL,                      /* senders */
-    NULL,                      /* suffix */
-    NULL,                      /* translate_ip_address */
-    NULL,                      /* transport_name */
-
-    TRUE,                      /* address_test */
+    .cannot_route_message =	NULL,
+    .condition =		NULL,
+    .current_directory =	NULL,
+    .debug_string =		NULL,
+    .domains =			NULL,
+    .errors_to =		NULL,
+    .expand_gid =		NULL,
+    .expand_uid =		NULL,
+    .expand_more =		NULL,
+    .expand_unseen =		NULL,
+    .extra_headers =		NULL,
+    .fallback_hosts =		NULL,
+    .home_directory =		NULL,
+    .ignore_target_hosts =	NULL,
+    .local_parts =		NULL,
+    .pass_router_name =		NULL,
+    .prefix =			NULL,
+    .redirect_router_name =	NULL,
+    .remove_headers =		NULL,
+    .require_files =		NULL,
+    .router_home_directory =	NULL,
+    .self =			US"freeze",
+    .senders =			NULL,
+    .suffix =			NULL,
+    .translate_ip_address =	NULL,
+    .transport_name =		NULL,
+
+    .address_test =		TRUE,
 #ifdef EXPERIMENTAL_BRIGHTMAIL
-    FALSE,                     /* bmi_deliver_alternate */
-    FALSE,                     /* bmi_deliver_default */
-    FALSE,                     /* bmi_dont_deliver */
+    .bmi_deliver_alternate =	FALSE,
+    .bmi_deliver_default =	FALSE,
+    .bmi_dont_deliver =		FALSE,
 #endif
-    TRUE,                      /* expn */
-    FALSE,                     /* caseful_local_part */
-    FALSE,                     /* check_local_user */
-    FALSE,                     /* disable_logging */
-    FALSE,                     /* fail_verify_recipient */
-    FALSE,                     /* fail_verify_sender */
-    FALSE,                     /* gid_set */
-    FALSE,                     /* initgroups */
-    TRUE_UNSET,                /* log_as_local */
-    TRUE,                      /* more */
-    FALSE,                     /* pass_on_timeout */
-    FALSE,                     /* prefix_optional */
-    TRUE,                      /* repeat_use */
-    TRUE_UNSET,                /* retry_use_local_part - fudge "unset" */
-    FALSE,                     /* same_domain_copy_routing */
-    FALSE,                     /* self_rewrite */
-    FALSE,                     /* suffix_optional */
-    FALSE,                     /* verify_only */
-    TRUE,                      /* verify_recipient */
-    TRUE,                      /* verify_sender */
-    FALSE,                     /* uid_set */
-    FALSE,                     /* unseen */
-    FALSE,                     /* dsn_lasthop */
-
-    self_freeze,               /* self_code */
-    (uid_t)(-1),               /* uid */
-    (gid_t)(-1),               /* gid */
-
-    NULL,                      /* fallback_hostlist */
-    NULL,                      /* transport instance */
-    NULL,                      /* pass_router */
-    NULL,                      /* redirect_router */
-
-    { NULL, NULL },            /* dnssec_domains {require,request} */
+    .expn =			TRUE,
+    .caseful_local_part =	FALSE,
+    .check_local_user =		FALSE,
+    .disable_logging =		FALSE,
+    .fail_verify_recipient =	FALSE,
+    .fail_verify_sender =	FALSE,
+    .gid_set =			FALSE,
+    .initgroups =		FALSE,
+    .log_as_local =		TRUE_UNSET,
+    .more =			TRUE,
+    .pass_on_timeout =		FALSE,
+    .prefix_optional =		FALSE,
+    .repeat_use =		TRUE,
+    .retry_use_local_part =	TRUE_UNSET,
+    .same_domain_copy_routing =	FALSE,
+    .self_rewrite =		FALSE,
+    .suffix_optional =		FALSE,
+    .verify_only =		FALSE,
+    .verify_recipient =		TRUE,
+    .verify_sender =		TRUE,
+    .uid_set =			FALSE,
+    .unseen =			FALSE,
+    .dsn_lasthop =		FALSE,
+
+    .self_code =		self_freeze,
+    .uid =			(uid_t)(-1),
+    .gid =			(gid_t)(-1),
+
+    .fallback_hostlist =	NULL,
+    .transport =		NULL,
+    .pass_router =		NULL,
+    .redirect_router =		NULL,
+
+    .dnssec =			{ NULL, NULL },            /* dnssec_domains {require,request} */
 };
 
 uschar *router_name            = NULL;
@@ -1425,59 +1428,59 @@ BOOL    timestamps_utc         = FALSE;
 transport_instance  *transports = NULL;
 
 transport_instance  transport_defaults = {
-    NULL,                     /* chain pointer */
-    NULL,                     /* name */
-    NULL,                     /* info */
-    NULL,                     /* private options block pointer */
-    NULL,                     /* driver name */
-    NULL,                     /* setup entry point */
-    1,                        /* batch_max */
-    NULL,                     /* batch_id */
-    NULL,                     /* home_dir */
-    NULL,                     /* current_dir */
-    NULL,                     /* expand-multi-domain */
-    TRUE,                     /* multi-domain */
-    FALSE,                    /* overrides_hosts */
-    100,                      /* max_addresses */
-    500,                      /* connection_max_messages */
-    FALSE,                    /* deliver_as_creator */
-    FALSE,                    /* disable_logging */
-    FALSE,                    /* initgroups */
-    FALSE,                    /* uid_set */
-    FALSE,                    /* gid_set */
-    (uid_t)(-1),              /* uid */
-    (gid_t)(-1),              /* gid */
-    NULL,                     /* expand_uid */
-    NULL,                     /* expand_gid */
-    NULL,                     /* warn_message */
-    NULL,                     /* shadow */
-    NULL,                     /* shadow_condition */
-    NULL,                     /* filter_command */
-    NULL,                     /* add_headers */
-    NULL,                     /* remove_headers */
-    NULL,                     /* return_path */
-    NULL,                     /* debug_string */
-    NULL,                     /* max_parallel */
-    NULL,                     /* message_size_limit */
-    NULL,                     /* headers_rewrite */
-    NULL,                     /* rewrite_rules */
-    0,                        /* rewrite_existflags */
-    300,                      /* filter_timeout */
-    FALSE,                    /* body_only */
-    FALSE,                    /* delivery_date_add */
-    FALSE,                    /* envelope_to_add */
-    FALSE,                    /* headers_only */
-    FALSE,                    /* rcpt_include_affixes */
-    FALSE,                    /* return_path_add */
-    FALSE,                    /* return_output */
-    FALSE,                    /* return_fail_output */
-    FALSE,                    /* log_output */
-    FALSE,                    /* log_fail_output */
-    FALSE,                    /* log_defer_output */
-    TRUE_UNSET                /* retry_use_local_part: BOOL, but set neither
-                                 1 nor 0 so can detect unset */
+    .next =			NULL,
+    .name =			NULL,
+    .info =			NULL,
+    .options_block =		NULL,
+    .driver_name =		NULL,
+    .setup =			NULL,
+    .batch_max =		1,
+    .batch_id =			NULL,
+    .home_dir =			NULL,
+    .current_dir =		NULL,
+    .expand_multi_domain =	NULL,
+    .multi_domain =		TRUE,
+    .overrides_hosts =		FALSE,
+    .max_addresses =		100,
+    .connection_max_messages =	500,
+    .deliver_as_creator =	FALSE,
+    .disable_logging =		FALSE,
+    .initgroups =		FALSE,
+    .uid_set =			FALSE,
+    .gid_set =			FALSE,
+    .uid =			(uid_t)(-1),
+    .gid =			(gid_t)(-1),
+    .expand_uid =		NULL,
+    .expand_gid =		NULL,
+    .warn_message =		NULL,
+    .shadow =			NULL,
+    .shadow_condition =		NULL,
+    .filter_command =		NULL,
+    .add_headers =		NULL,
+    .remove_headers =		NULL,
+    .return_path =		NULL,
+    .debug_string =		NULL,
+    .max_parallel =		NULL,
+    .message_size_limit =	NULL,
+    .headers_rewrite =		NULL,
+    .rewrite_rules =		NULL,
+    .rewrite_existflags =	0,
+    .filter_timeout =		300,
+    .body_only =		FALSE,
+    .delivery_date_add =	FALSE,
+    .envelope_to_add =		FALSE,
+    .headers_only =		FALSE,
+    .rcpt_include_affixes =	FALSE,
+    .return_path_add =		FALSE,
+    .return_output =		FALSE,
+    .return_fail_output =	FALSE,
+    .log_output =		FALSE,
+    .log_fail_output =		FALSE,
+    .log_defer_output =		FALSE,
+    .retry_use_local_part =	TRUE_UNSET,	/* retry_use_local_part: BOOL, but set neither
+						 1 nor 0 so can detect unset */
 #ifndef DISABLE_EVENT
-   ,NULL		      /* event_action */
+   .event_action =		NULL
 #endif
 };
 
diff --git a/src/src/ip.c b/src/src/ip.c
index bf564662d..18a60d5f8 100644
--- a/src/src/ip.c
+++ b/src/src/ip.c
@@ -492,7 +492,7 @@ if (time_left <= 0)
 
 do
   {
-  struct timeval tv = { time_left, 0 };
+  struct timeval tv = { .tv_sec = time_left, .tv_usec = 0 };
   FD_ZERO (&select_inset);
   FD_SET (fd, &select_inset);
 
diff --git a/src/src/macro_predef.c b/src/src/macro_predef.c
index 502bfc7ee..6b3157fbe 100644
--- a/src/src/macro_predef.c
+++ b/src/src/macro_predef.c
@@ -25,11 +25,13 @@ builtin_macro_create(const uschar * name)
 {
 printf ("static macro_item p%d = { ", mp_index);
 if (mp_index == 0)
-  printf("NULL,");
+  printf(".next=NULL,");
 else
-  printf("&p%d,", mp_index-1);
+  printf(".next=&p%d,", mp_index-1);
 
-printf(" FALSE, %d, 1, US\"%s\", US\"y\" };\n", Ustrlen(name), CS name);
+printf(" .command_line=FALSE, .namelen=%d, .replen=1,"
+	" .name=US\"%s\", .replacement=US\"y\" };\n",
+	Ustrlen(name), CS name);
 mp_index++;
 }
 
diff --git a/src/src/mime.c b/src/src/mime.c
index 80e820b2b..61dabd2ac 100644
--- a/src/src/mime.c
+++ b/src/src/mime.c
@@ -16,6 +16,7 @@ FILE *mime_stream = NULL;
 uschar *mime_current_boundary = NULL;
 
 static mime_header mime_header_list[] = {
+  /*	name			namelen		value */
   { US"content-type:",              13, &mime_content_type },
   { US"content-disposition:",       20, &mime_content_disposition },
   { US"content-transfer-encoding:", 26, &mime_content_transfer_encoding },
@@ -26,6 +27,7 @@ static mime_header mime_header_list[] = {
 static int mime_header_list_size = nelem(mime_header_list);
 
 static mime_parameter mime_parameter_list[] = {
+  /*	name	namelen	 value */
   { US"name=",     5, &mime_filename },
   { US"filename=", 9, &mime_filename },
   { US"charset=",  8, &mime_charset  },
diff --git a/src/src/sieve.c b/src/src/sieve.c
index 96344c416..033cbce52 100644
--- a/src/src/sieve.c
+++ b/src/src/sieve.c
@@ -414,7 +414,7 @@ static int parse_mailto_uri(struct Sieve *filter, const uschar *uri, string_item
 {
 const uschar *start;
 struct String to, hname;
-struct String hvalue = {NULL, 0};
+struct String hvalue = {.character = NULL, .length = 0};
 int capacity;
 string_item *new;
 
@@ -3390,7 +3390,7 @@ while (*filter->pc)
             }
           else
             {
-            struct String qp = { NULL, 0 };  /* Keep compiler happy (PH) */
+            struct String qp = { .character = NULL, .length = 0 };  /* Keep compiler happy (PH) */
 
             capacity = 0;
             start = reason.length;
diff --git a/src/src/spf.c b/src/src/spf.c
index 9ab56af23..7b2b832b2 100644
--- a/src/src/spf.c
+++ b/src/src/spf.c
@@ -15,16 +15,17 @@
 
 /* must be kept in numeric order */
 static spf_result_id spf_result_id_list[] = {
-  { US"invalid", 0},
-  { US"neutral", 1 },
-  { US"pass", 2 },
-  { US"fail", 3 },
-  { US"softfail", 4 },
-  { US"none", 5 },
-  { US"err_temp", 6 },  /* Deprecated Apr 2014 */
-  { US"err_perm", 7 },  /* Deprecated Apr 2014 */
-  { US"temperror", 6 }, /* RFC 4408 defined */
-  { US"permerror", 7 }  /* RFC 4408 defined */
+  /* name		value */
+  { US"invalid",	0},
+  { US"neutral",	1 },
+  { US"pass",		2 },
+  { US"fail",		3 },
+  { US"softfail",	4 },
+  { US"none",		5 },
+  { US"err_temp",	6 },  /* Deprecated Apr 2014 */
+  { US"err_perm",	7 },  /* Deprecated Apr 2014 */
+  { US"temperror",	6 }, /* RFC 4408 defined */
+  { US"permerror",	7 }  /* RFC 4408 defined */
 };
 
 SPF_server_t    *spf_server = NULL;
diff --git a/src/src/std-crypto.c b/src/src/std-crypto.c
index 8ccef122b..d41e2a195 100644
--- a/src/src/std-crypto.c
+++ b/src/src/std-crypto.c
@@ -961,26 +961,27 @@ struct dh_constant {
 /* KEEP SORTED ALPHABETICALLY;
  * duplicate PEM are okay, if we want aliases, but names must be alphabetical */
 static struct dh_constant dh_constants[] = {
-    { "default", dh_exim_20160529_3 },
-    { "exim.dev.20160529.1", dh_exim_20160529_1 },
-    { "exim.dev.20160529.2", dh_exim_20160529_2 },
-    { "exim.dev.20160529.3", dh_exim_20160529_3 },
-    { "ffdhe2048", dh_ffdhe2048_pem },
-    { "ffdhe3072", dh_ffdhe3072_pem },
-    { "ffdhe4096", dh_ffdhe4096_pem },
-    { "ffdhe6144", dh_ffdhe6144_pem },
-    { "ffdhe8192", dh_ffdhe8192_pem },
-    { "ike1", dh_ike_1_pem },
-    { "ike14", dh_ike_14_pem },
-    { "ike15", dh_ike_15_pem },
-    { "ike16", dh_ike_16_pem },
-    { "ike17", dh_ike_17_pem },
-    { "ike18", dh_ike_18_pem },
-    { "ike2", dh_ike_2_pem },
-    { "ike22", dh_ike_22_pem },
-    { "ike23", dh_ike_23_pem },
-    { "ike24", dh_ike_24_pem },
-    { "ike5", dh_ike_5_pem },
+    /*  label			pem */
+    { "default",		dh_exim_20160529_3 },
+    { "exim.dev.20160529.1",	dh_exim_20160529_1 },
+    { "exim.dev.20160529.2",	dh_exim_20160529_2 },
+    { "exim.dev.20160529.3",	dh_exim_20160529_3 },
+    { "ffdhe2048",		dh_ffdhe2048_pem },
+    { "ffdhe3072",		dh_ffdhe3072_pem },
+    { "ffdhe4096",		dh_ffdhe4096_pem },
+    { "ffdhe6144",		dh_ffdhe6144_pem },
+    { "ffdhe8192",		dh_ffdhe8192_pem },
+    { "ike1",			dh_ike_1_pem },
+    { "ike14",			dh_ike_14_pem },
+    { "ike15",			dh_ike_15_pem },
+    { "ike16",			dh_ike_16_pem },
+    { "ike17",			dh_ike_17_pem },
+    { "ike18",			dh_ike_18_pem },
+    { "ike2",			dh_ike_2_pem },
+    { "ike22",			dh_ike_22_pem },
+    { "ike23",			dh_ike_23_pem },
+    { "ike24",			dh_ike_24_pem },
+    { "ike5",			dh_ike_5_pem },
 };
 static const int dh_constants_count =
   sizeof(dh_constants) / sizeof(struct dh_constant);
diff --git a/src/src/tls-gnu.c b/src/src/tls-gnu.c
index c68d11d72..8d8108640 100644
--- a/src/src/tls-gnu.c
+++ b/src/src/tls-gnu.c
@@ -139,16 +139,45 @@ typedef struct exim_gnutls_state {
 } exim_gnutls_state_st;
 
 static const exim_gnutls_state_st exim_gnutls_state_init = {
-  NULL, NULL, NULL, VERIFY_NONE, -1, -1, FALSE, FALSE, FALSE,
-  NULL, NULL, NULL, NULL,
-  NULL, NULL, NULL, NULL, NULL, NULL,
-  NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-  NULL,
+  .session =		NULL,
+  .x509_cred =		NULL,
+  .priority_cache =	NULL,
+  .verify_requirement =	VERIFY_NONE,
+  .fd_in =		-1,
+  .fd_out =		-1,
+  .peer_cert_verified =	FALSE,
+  .trigger_sni_changes =FALSE,
+  .have_set_peerdn =	FALSE,
+  .host =		NULL,
+  .peercert =		NULL,
+  .peerdn =		NULL,
+  .ciphersuite =	NULL,
+  .received_sni =	NULL,
+
+  .tls_certificate =	NULL,
+  .tls_privatekey =	NULL,
+  .tls_sni =		NULL,
+  .tls_verify_certificates = NULL,
+  .tls_crl =		NULL,
+  .tls_require_ciphers =NULL,
+
+  .exp_tls_certificate = NULL,
+  .exp_tls_privatekey =	NULL,
+  .exp_tls_verify_certificates = NULL,
+  .exp_tls_crl =	NULL,
+  .exp_tls_require_ciphers = NULL,
+  .exp_tls_ocsp_file =	NULL,
+  .exp_tls_verify_cert_hostnames = NULL,
 #ifndef DISABLE_EVENT
-                                            NULL,
+  .event_action =	NULL,
 #endif
-  NULL,
-  NULL, 0, 0, 0, 0,
+  .tlsp =		NULL,
+
+  .xfer_buffer =	NULL,
+  .xfer_buffer_lwm =	0,
+  .xfer_buffer_hwm =	0,
+  .xfer_eof =		0,
+  .xfer_error =		0,
 };
 
 /* Not only do we have our own APIs which don't pass around state, assuming
diff --git a/src/src/transport.c b/src/src/transport.c
index 6dcc0c7d4..65d84e353 100644
--- a/src/src/transport.c
+++ b/src/src/transport.c
@@ -17,6 +17,7 @@ are other options living inside this structure which can be set only from
 certain transports. */
 
 optionlist optionlist_transports[] = {
+  /*	name		type					value */
   { "*expand_group",    opt_stringptr|opt_hidden|opt_public,
                  (void *)offsetof(transport_instance, expand_gid) },
   { "*expand_user",     opt_stringptr|opt_hidden|opt_public,
diff --git a/src/src/verify.c b/src/src/verify.c
index 4f7d9380d..a9ec730d1 100644
--- a/src/src/verify.c
+++ b/src/src/verify.c
@@ -1789,16 +1789,16 @@ while (addr_new)
       transport. */
 
       transport_feedback tf = {
-        NULL,                       /* interface (=> any) */
-        US"smtp",                   /* port */
-        US"smtp",                   /* protocol */
-        NULL,                       /* hosts */
-        US"$smtp_active_hostname",  /* helo_data */
-        FALSE,                      /* hosts_override */
-        FALSE,                      /* hosts_randomize */
-        FALSE,                      /* gethostbyname */
-        TRUE,                       /* qualify_single */
-        FALSE                       /* search_parents */
+        .interface =		NULL,                       /* interface (=> any) */
+        .port =			US"smtp",
+        .protocol =		US"smtp",
+        .hosts =		NULL,
+        .helo_data =		US"$smtp_active_hostname",
+        .hosts_override =	FALSE,
+        .hosts_randomize =	FALSE,
+        .gethostbyname =	FALSE,
+        .qualify_single =	TRUE,
+        .search_parents =	FALSE
         };
 
       /* If verification yielded a remote transport, we want to use that