17bba9d75b7adbe08251c9f7da301f43b5e1f81f
[exim.git] / src / src / dmarc.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4 /* DMARC support.
5    Copyright (c) The Exim Maintainers 2019 - 2022
6    Copyright (c) Todd Lyons <tlyons@exim.org> 2012 - 2014
7    License: GPL */
8
9 /* Portions Copyright (c) 2012, 2013, The Trusted Domain Project;
10    All rights reserved, licensed for use per LICENSE.opendmarc. */
11
12 /* Code for calling dmarc checks via libopendmarc. Called from acl.c. */
13
14 #include "exim.h"
15 #ifdef SUPPORT_DMARC
16 # if !defined SUPPORT_SPF
17 #  error SPF must also be enabled for DMARC
18 # elif defined DISABLE_DKIM
19 #  error DKIM must also be enabled for DMARC
20 # else
21
22 #  include "functions.h"
23 #  include "dmarc.h"
24 #  include "pdkim/pdkim.h"
25
26 OPENDMARC_LIB_T     dmarc_ctx;
27 DMARC_POLICY_T     *dmarc_pctx = NULL;
28 OPENDMARC_STATUS_T  libdm_status, action, dmarc_policy;
29 OPENDMARC_STATUS_T  da, sa, action;
30 BOOL dmarc_abort  = FALSE;
31 uschar *dmarc_pass_fail = US"skipped";
32 header_line *from_header   = NULL;
33 extern SPF_response_t   *spf_response;
34 int dmarc_spf_ares_result  = 0;
35 uschar *spf_sender_domain  = NULL;
36 uschar *spf_human_readable = NULL;
37 u_char *header_from_sender = NULL;
38 int history_file_status    = DMARC_HIST_OK;
39 uschar *dkim_history_buffer= NULL;
40
41 typedef struct dmarc_exim_p {
42   uschar *name;
43   int    value;
44 } dmarc_exim_p;
45
46 static dmarc_exim_p dmarc_policy_description[] = {
47   /* name               value */
48   { US"",           DMARC_RECORD_P_UNSPECIFIED },
49   { US"none",       DMARC_RECORD_P_NONE },
50   { US"quarantine", DMARC_RECORD_P_QUARANTINE },
51   { US"reject",     DMARC_RECORD_P_REJECT },
52   { NULL,           0 }
53 };
54
55
56 gstring *
57 dmarc_version_report(gstring * g)
58 {
59 return string_fmt_append(g, "Library version: dmarc: Compile: %d.%d.%d.%d\n",
60     (OPENDMARC_LIB_VERSION & 0xff000000) >> 24, (OPENDMARC_LIB_VERSION & 0x00ff0000) >> 16,
61     (OPENDMARC_LIB_VERSION & 0x0000ff00) >> 8, OPENDMARC_LIB_VERSION & 0x000000ff);
62 }
63
64
65 /* Accept an error_block struct, initialize if empty, parse to the
66 end, and append the two strings passed to it.  Used for adding
67 variable amounts of value:pair data to the forensic emails. */
68
69 static error_block *
70 add_to_eblock(error_block *eblock, uschar *t1, uschar *t2)
71 {
72 error_block *eb = store_malloc(sizeof(error_block));
73 if (!eblock)
74   eblock = eb;
75 else
76   {
77   /* Find the end of the eblock struct and point it at eb */
78   error_block *tmp = eblock;
79   while(tmp->next)
80     tmp = tmp->next;
81   tmp->next = eb;
82   }
83 eb->text1 = t1;
84 eb->text2 = t2;
85 eb->next  = NULL;
86 return eblock;
87 }
88
89 /* dmarc_init sets up a context that can be re-used for several
90 messages on the same SMTP connection (that come from the
91 same host with the same HELO string) */
92
93 int
94 dmarc_init()
95 {
96 int *netmask   = NULL;   /* Ignored */
97 int is_ipv6    = 0;
98
99 /* Set some sane defaults.  Also clears previous results when
100  * multiple messages in one connection. */
101 dmarc_pctx         = NULL;
102 dmarc_status       = US"none";
103 dmarc_abort        = FALSE;
104 dmarc_pass_fail    = US"skipped";
105 dmarc_used_domain  = US"";
106 f.dmarc_has_been_checked = FALSE;
107 header_from_sender = NULL;
108 spf_sender_domain  = NULL;
109 spf_human_readable = NULL;
110
111 /* ACLs have "control=dmarc_disable_verify" */
112 if (f.dmarc_disable_verify == TRUE)
113   return OK;
114
115 (void) memset(&dmarc_ctx, '\0', sizeof dmarc_ctx);
116 dmarc_ctx.nscount = 0;
117 libdm_status = opendmarc_policy_library_init(&dmarc_ctx);
118 if (libdm_status != DMARC_PARSE_OKAY)
119   {
120   log_write(0, LOG_MAIN|LOG_PANIC, "DMARC failure to init library: %s",
121                        opendmarc_policy_status_to_str(libdm_status));
122   dmarc_abort = TRUE;
123   }
124 if (!dmarc_tld_file || !*dmarc_tld_file)
125   {
126   DEBUG(D_receive) debug_printf("DMARC: no dmarc_tld_file\n");
127   dmarc_abort = TRUE;
128   }
129 else if (opendmarc_tld_read_file(CS dmarc_tld_file, NULL, NULL, NULL))
130   {
131   log_write(0, LOG_MAIN|LOG_PANIC, "DMARC failure to load tld list '%s': %s",
132                        dmarc_tld_file, strerror(errno));
133   dmarc_abort = TRUE;
134   }
135 if (!sender_host_address)
136   {
137   DEBUG(D_receive) debug_printf("DMARC: no sender_host_address\n");
138   dmarc_abort = TRUE;
139   }
140 /* This catches locally originated email and startup errors above. */
141 if (!dmarc_abort)
142   {
143   is_ipv6 = string_is_ip_address(sender_host_address, netmask) == 6;
144   if (!(dmarc_pctx = opendmarc_policy_connect_init(sender_host_address, is_ipv6)))
145     {
146     log_write(0, LOG_MAIN|LOG_PANIC,
147       "DMARC failure creating policy context: ip=%s", sender_host_address);
148     dmarc_abort = TRUE;
149     }
150   }
151
152 return OK;
153 }
154
155
156 /* dmarc_store_data stores the header data so that subsequent
157 dmarc_process can access the data */
158
159 int
160 dmarc_store_data(header_line *hdr)
161 {
162 /* No debug output because would change every test debug output */
163 if (!f.dmarc_disable_verify)
164   from_header = hdr;
165 return OK;
166 }
167
168
169 static void
170 dmarc_send_forensic_report(u_char **ruf)
171 {
172 uschar *recipient, *save_sender;
173 BOOL  send_status = FALSE;
174 error_block *eblock = NULL;
175 FILE *message_file = NULL;
176
177 /* Earlier ACL does not have *required* control=dmarc_enable_forensic */
178 if (!f.dmarc_enable_forensic)
179   return;
180
181 if (  dmarc_policy == DMARC_POLICY_REJECT     && action == DMARC_RESULT_REJECT
182    || dmarc_policy == DMARC_POLICY_QUARANTINE && action == DMARC_RESULT_QUARANTINE
183    || dmarc_policy == DMARC_POLICY_NONE       && action == DMARC_RESULT_REJECT
184    || dmarc_policy == DMARC_POLICY_NONE       && action == DMARC_RESULT_QUARANTINE
185    )
186   if (ruf)
187     {
188     eblock = add_to_eblock(eblock, US"Sender Domain", dmarc_used_domain);
189     eblock = add_to_eblock(eblock, US"Sender IP Address", sender_host_address);
190     eblock = add_to_eblock(eblock, US"Received Date", tod_stamp(tod_full));
191     eblock = add_to_eblock(eblock, US"SPF Alignment",
192                      sa == DMARC_POLICY_SPF_ALIGNMENT_PASS ? US"yes" : US"no");
193     eblock = add_to_eblock(eblock, US"DKIM Alignment",
194                      da == DMARC_POLICY_DKIM_ALIGNMENT_PASS ? US"yes" : US"no");
195     eblock = add_to_eblock(eblock, US"DMARC Results", dmarc_status_text);
196
197     for (int c = 0; ruf[c]; c++)
198       {
199       recipient = string_copylc(ruf[c]);
200       if (Ustrncmp(recipient, "mailto:",7))
201         continue;
202       /* Move to first character past the colon */
203       recipient += 7;
204       DEBUG(D_receive)
205         debug_printf("DMARC forensic report to %s%s\n", recipient,
206              (host_checking || f.running_in_test_harness) ? " (not really)" : "");
207       if (host_checking || f.running_in_test_harness)
208         continue;
209
210       if (!moan_send_message(recipient, ERRMESS_DMARC_FORENSIC, eblock,
211                             header_list, message_file, NULL))
212         log_write(0, LOG_MAIN|LOG_PANIC,
213           "failure to send DMARC forensic report to %s", recipient);
214       }
215     }
216 }
217
218
219 /* Look up a DNS dmarc record for the given domain.  Return it or NULL */
220
221 static uschar *
222 dmarc_dns_lookup(uschar * dom)
223 {
224 dns_answer * dnsa = store_get_dns_answer();
225 dns_scan dnss;
226 int rc = dns_lookup(dnsa, string_sprintf("_dmarc.%s", dom), T_TXT, NULL);
227
228 if (rc == DNS_SUCCEED)
229   for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
230        rr = dns_next_rr(dnsa, &dnss, RESET_NEXT))
231     if (rr->type == T_TXT && rr->size > 3)
232       {
233       store_free_dns_answer(dnsa);
234       return string_copyn_taint(US rr->data, rr->size, GET_TAINTED);
235       }
236 store_free_dns_answer(dnsa);
237 return NULL;
238 }
239
240
241 static int
242 dmarc_write_history_file()
243 {
244 int history_file_fd;
245 ssize_t written_len;
246 int tmp_ans;
247 u_char **rua; /* aggregate report addressees */
248 uschar *history_buffer = NULL;
249
250 if (!dmarc_history_file)
251   {
252   DEBUG(D_receive) debug_printf("DMARC history file not set\n");
253   return DMARC_HIST_DISABLED;
254   }
255 history_file_fd = log_open_as_exim(dmarc_history_file);
256
257 if (history_file_fd < 0)
258   {
259   log_write(0, LOG_MAIN|LOG_PANIC, "failure to create DMARC history file: %s",
260                            dmarc_history_file);
261   return DMARC_HIST_FILE_ERR;
262   }
263
264 /* Generate the contents of the history file */
265 history_buffer = string_sprintf(
266   "job %s\nreporter %s\nreceived %ld\nipaddr %s\nfrom %s\nmfrom %s\n",
267   message_id, primary_hostname, time(NULL), sender_host_address,
268   header_from_sender, expand_string(US"$sender_address_domain"));
269
270 if (spf_response)
271   history_buffer = string_sprintf("%sspf %d\n", history_buffer, dmarc_spf_ares_result);
272   /* history_buffer = string_sprintf("%sspf -1\n", history_buffer); */
273
274 history_buffer = string_sprintf(
275   "%s%spdomain %s\npolicy %d\n",
276   history_buffer, dkim_history_buffer, dmarc_used_domain, dmarc_policy);
277
278 if ((rua = opendmarc_policy_fetch_rua(dmarc_pctx, NULL, 0, 1)))
279   for (tmp_ans = 0; rua[tmp_ans]; tmp_ans++)
280     history_buffer = string_sprintf("%srua %s\n", history_buffer, rua[tmp_ans]);
281 else
282   history_buffer = string_sprintf("%srua -\n", history_buffer);
283
284 opendmarc_policy_fetch_pct(dmarc_pctx, &tmp_ans);
285 history_buffer = string_sprintf("%spct %d\n", history_buffer, tmp_ans);
286
287 opendmarc_policy_fetch_adkim(dmarc_pctx, &tmp_ans);
288 history_buffer = string_sprintf("%sadkim %d\n", history_buffer, tmp_ans);
289
290 opendmarc_policy_fetch_aspf(dmarc_pctx, &tmp_ans);
291 history_buffer = string_sprintf("%saspf %d\n", history_buffer, tmp_ans);
292
293 opendmarc_policy_fetch_p(dmarc_pctx, &tmp_ans);
294 history_buffer = string_sprintf("%sp %d\n", history_buffer, tmp_ans);
295
296 opendmarc_policy_fetch_sp(dmarc_pctx, &tmp_ans);
297 history_buffer = string_sprintf("%ssp %d\n", history_buffer, tmp_ans);
298
299 history_buffer = string_sprintf(
300   "%salign_dkim %d\nalign_spf %d\naction %d\n",
301   history_buffer, da, sa, action);
302
303 /* Write the contents to the history file */
304 DEBUG(D_receive)
305   debug_printf("DMARC logging history data for opendmarc reporting%s\n",
306              (host_checking || f.running_in_test_harness) ? " (not really)" : "");
307 if (host_checking || f.running_in_test_harness)
308   {
309   DEBUG(D_receive)
310     debug_printf("DMARC history data for debugging:\n%s", history_buffer);
311   }
312 else
313   {
314   written_len = write_to_fd_buf(history_file_fd,
315                                 history_buffer,
316                                 Ustrlen(history_buffer));
317   if (written_len == 0)
318     {
319     log_write(0, LOG_MAIN|LOG_PANIC, "failure to write to DMARC history file: %s",
320                            dmarc_history_file);
321     return DMARC_HIST_WRITE_ERR;
322     }
323   (void)close(history_file_fd);
324   }
325 return DMARC_HIST_OK;
326 }
327
328
329 /* dmarc_process adds the envelope sender address to the existing
330 context (if any), retrieves the result, sets up expansion
331 strings and evaluates the condition outcome. */
332
333 int
334 dmarc_process()
335 {
336 int sr, origin;             /* used in SPF section */
337 int dmarc_spf_result  = 0;  /* stores spf into dmarc conn ctx */
338 int tmp_ans, c;
339 pdkim_signature * sig = dkim_signatures;
340 uschar * rr;
341 BOOL has_dmarc_record = TRUE;
342 u_char **ruf; /* forensic report addressees, if called for */
343
344 /* ACLs have "control=dmarc_disable_verify" */
345 if (f.dmarc_disable_verify)
346   return OK;
347
348 /* Store the header From: sender domain for this part of DMARC.
349  * If there is no from_header struct, then it's likely this message
350  * is locally generated and relying on fixups to add it.  Just skip
351  * the entire DMARC system if we can't find a From: header....or if
352  * there was a previous error.
353  */
354 if (!from_header)
355   {
356   DEBUG(D_receive) debug_printf("DMARC: no From: header\n");
357   dmarc_abort = TRUE;
358   }
359 else if (!dmarc_abort)
360   {
361   uschar * errormsg;
362   int dummy, domain;
363   uschar * p;
364   uschar saveend;
365
366   f.parse_allow_group = TRUE;
367   p = parse_find_address_end(from_header->text, FALSE);
368   saveend = *p; *p = '\0';
369   if ((header_from_sender = parse_extract_address(from_header->text, &errormsg,
370                               &dummy, &dummy, &domain, FALSE)))
371     header_from_sender += domain;
372   *p = saveend;
373
374   /* The opendmarc library extracts the domain from the email address, but
375    * only try to store it if it's not empty.  Otherwise, skip out of DMARC. */
376   if (!header_from_sender || (strcmp( CCS header_from_sender, "") == 0))
377     dmarc_abort = TRUE;
378   libdm_status = dmarc_abort
379     ? DMARC_PARSE_OKAY
380     : opendmarc_policy_store_from_domain(dmarc_pctx, header_from_sender);
381   if (libdm_status != DMARC_PARSE_OKAY)
382     {
383     log_write(0, LOG_MAIN|LOG_PANIC,
384               "failure to store header From: in DMARC: %s, header was '%s'",
385               opendmarc_policy_status_to_str(libdm_status), from_header->text);
386     dmarc_abort = TRUE;
387     }
388   }
389
390 /* Skip DMARC if connection is SMTP Auth. Temporarily, admin should
391  * instead do this in the ACLs.  */
392 if (!dmarc_abort && !sender_host_authenticated)
393   {
394   uschar * dmarc_domain;
395
396   /* Use the envelope sender domain for this part of DMARC */
397   spf_sender_domain = expand_string(US"$sender_address_domain");
398   if (!spf_response)
399     {
400     /* No spf data means null envelope sender so generate a domain name
401      * from the sender_helo_name  */
402     if (!spf_sender_domain)
403       {
404       spf_sender_domain = sender_helo_name;
405       log_write(0, LOG_MAIN, "DMARC using synthesized SPF sender domain = %s\n",
406                              spf_sender_domain);
407       DEBUG(D_receive)
408         debug_printf("DMARC using synthesized SPF sender domain = %s\n",
409           spf_sender_domain);
410       }
411     dmarc_spf_result = DMARC_POLICY_SPF_OUTCOME_NONE;
412     dmarc_spf_ares_result = ARES_RESULT_UNKNOWN;
413     origin = DMARC_POLICY_SPF_ORIGIN_HELO;
414     spf_human_readable = US"";
415     }
416   else
417     {
418     sr = spf_response->result;
419     dmarc_spf_result = sr == SPF_RESULT_NEUTRAL  ? DMARC_POLICY_SPF_OUTCOME_NONE :
420                        sr == SPF_RESULT_PASS     ? DMARC_POLICY_SPF_OUTCOME_PASS :
421                        sr == SPF_RESULT_FAIL     ? DMARC_POLICY_SPF_OUTCOME_FAIL :
422                        sr == SPF_RESULT_SOFTFAIL ? DMARC_POLICY_SPF_OUTCOME_TMPFAIL :
423                        DMARC_POLICY_SPF_OUTCOME_NONE;
424     dmarc_spf_ares_result = sr == SPF_RESULT_NEUTRAL   ? ARES_RESULT_NEUTRAL :
425                             sr == SPF_RESULT_PASS      ? ARES_RESULT_PASS :
426                             sr == SPF_RESULT_FAIL      ? ARES_RESULT_FAIL :
427                             sr == SPF_RESULT_SOFTFAIL  ? ARES_RESULT_SOFTFAIL :
428                             sr == SPF_RESULT_NONE      ? ARES_RESULT_NONE :
429                             sr == SPF_RESULT_TEMPERROR ? ARES_RESULT_TEMPERROR :
430                             sr == SPF_RESULT_PERMERROR ? ARES_RESULT_PERMERROR :
431                             ARES_RESULT_UNKNOWN;
432     origin = DMARC_POLICY_SPF_ORIGIN_MAILFROM;
433     spf_human_readable = US spf_response->header_comment;
434     DEBUG(D_receive)
435       debug_printf("DMARC using SPF sender domain = %s\n", spf_sender_domain);
436     }
437   if (strcmp( CCS spf_sender_domain, "") == 0)
438     dmarc_abort = TRUE;
439   if (!dmarc_abort)
440     {
441     libdm_status = opendmarc_policy_store_spf(dmarc_pctx, spf_sender_domain,
442                                 dmarc_spf_result, origin, spf_human_readable);
443     if (libdm_status != DMARC_PARSE_OKAY)
444       log_write(0, LOG_MAIN|LOG_PANIC, "failure to store spf for DMARC: %s",
445                            opendmarc_policy_status_to_str(libdm_status));
446     }
447
448   /* Now we cycle through the dkim signature results and put into
449    * the opendmarc context, further building the DMARC reply.  */
450   dkim_history_buffer = US"";
451   while (sig)
452     {
453     int dkim_result, dkim_ares_result, vs, ves;
454
455     vs  = sig->verify_status & ~PDKIM_VERIFY_POLICY;
456     ves = sig->verify_ext_status;
457     dkim_result = vs == PDKIM_VERIFY_PASS ? DMARC_POLICY_DKIM_OUTCOME_PASS :
458                   vs == PDKIM_VERIFY_FAIL ? DMARC_POLICY_DKIM_OUTCOME_FAIL :
459                   vs == PDKIM_VERIFY_INVALID ? DMARC_POLICY_DKIM_OUTCOME_TMPFAIL :
460                   DMARC_POLICY_DKIM_OUTCOME_NONE;
461     libdm_status = opendmarc_policy_store_dkim(dmarc_pctx, US sig->domain,
462                                                dkim_result, US"");
463     DEBUG(D_receive)
464       debug_printf("DMARC adding DKIM sender domain = %s\n", sig->domain);
465     if (libdm_status != DMARC_PARSE_OKAY)
466       log_write(0, LOG_MAIN|LOG_PANIC,
467                 "failure to store dkim (%s) for DMARC: %s",
468                 sig->domain, opendmarc_policy_status_to_str(libdm_status));
469
470     dkim_ares_result =
471       vs == PDKIM_VERIFY_PASS    ? ARES_RESULT_PASS :
472       vs == PDKIM_VERIFY_FAIL    ? ARES_RESULT_FAIL :
473       vs == PDKIM_VERIFY_NONE    ? ARES_RESULT_NONE :
474       vs == PDKIM_VERIFY_INVALID ?
475        ves == PDKIM_VERIFY_INVALID_PUBKEY_UNAVAILABLE ? ARES_RESULT_PERMERROR :
476        ves == PDKIM_VERIFY_INVALID_BUFFER_SIZE        ? ARES_RESULT_PERMERROR :
477        ves == PDKIM_VERIFY_INVALID_PUBKEY_DNSRECORD   ? ARES_RESULT_PERMERROR :
478        ves == PDKIM_VERIFY_INVALID_PUBKEY_IMPORT      ? ARES_RESULT_PERMERROR :
479        ARES_RESULT_UNKNOWN :
480       ARES_RESULT_UNKNOWN;
481     dkim_history_buffer = string_sprintf("%sdkim %s %d\n", dkim_history_buffer,
482                                          sig->domain, dkim_ares_result);
483     sig = sig->next;
484     }
485
486   /* Look up DMARC policy record in DNS.  We do this explicitly, rather than
487   letting the dmarc library do it with opendmarc_policy_query_dmarc(), so that
488   our dns access path is used for debug tracing and for the testsuite
489   diversion. */
490
491   libdm_status = (rr = dmarc_dns_lookup(header_from_sender))
492     ? opendmarc_policy_store_dmarc(dmarc_pctx, rr, header_from_sender, NULL)
493     : DMARC_DNS_ERROR_NO_RECORD;
494   switch (libdm_status)
495     {
496     case DMARC_DNS_ERROR_NXDOMAIN:
497     case DMARC_DNS_ERROR_NO_RECORD:
498       DEBUG(D_receive)
499         debug_printf("DMARC no record found for %s\n", header_from_sender);
500       has_dmarc_record = FALSE;
501       break;
502     case DMARC_PARSE_OKAY:
503       DEBUG(D_receive)
504         debug_printf("DMARC record found for %s\n", header_from_sender);
505       break;
506     case DMARC_PARSE_ERROR_BAD_VALUE:
507       DEBUG(D_receive)
508         debug_printf("DMARC record parse error for %s\n", header_from_sender);
509       has_dmarc_record = FALSE;
510       break;
511     default:
512       /* everything else, skip dmarc */
513       DEBUG(D_receive)
514         debug_printf("DMARC skipping (%d), unsure what to do with %s",
515                       libdm_status, from_header->text);
516       has_dmarc_record = FALSE;
517       break;
518     }
519
520 /* Store the policy string in an expandable variable. */
521
522   libdm_status = opendmarc_policy_fetch_p(dmarc_pctx, &tmp_ans);
523   for (c = 0; dmarc_policy_description[c].name; c++)
524     if (tmp_ans == dmarc_policy_description[c].value)
525       {
526       dmarc_domain_policy = string_sprintf("%s",dmarc_policy_description[c].name);
527       break;
528       }
529
530   /* Can't use exim's string manipulation functions so allocate memory
531   for libopendmarc using its max hostname length definition. */
532
533   dmarc_domain = store_get(DMARC_MAXHOSTNAMELEN, GET_TAINTED);
534   libdm_status = opendmarc_policy_fetch_utilized_domain(dmarc_pctx,
535     dmarc_domain, DMARC_MAXHOSTNAMELEN-1);
536   store_release_above(dmarc_domain + Ustrlen(dmarc_domain)+1);
537   dmarc_used_domain = dmarc_domain;
538
539   if (libdm_status != DMARC_PARSE_OKAY)
540     log_write(0, LOG_MAIN|LOG_PANIC,
541       "failure to read domainname used for DMARC lookup: %s",
542       opendmarc_policy_status_to_str(libdm_status));
543
544   dmarc_policy = libdm_status = opendmarc_get_policy_to_enforce(dmarc_pctx);
545   switch(libdm_status)
546     {
547     case DMARC_POLICY_ABSENT:     /* No DMARC record found */
548       dmarc_status = US"norecord";
549       dmarc_pass_fail = US"none";
550       dmarc_status_text = US"No DMARC record";
551       action = DMARC_RESULT_ACCEPT;
552       break;
553     case DMARC_FROM_DOMAIN_ABSENT:    /* No From: domain */
554       dmarc_status = US"nofrom";
555       dmarc_pass_fail = US"temperror";
556       dmarc_status_text = US"No From: domain found";
557       action = DMARC_RESULT_ACCEPT;
558       break;
559     case DMARC_POLICY_NONE:       /* Accept and report */
560       dmarc_status = US"none";
561       dmarc_pass_fail = US"none";
562       dmarc_status_text = US"None, Accept";
563       action = DMARC_RESULT_ACCEPT;
564       break;
565     case DMARC_POLICY_PASS:       /* Explicit accept */
566       dmarc_status = US"accept";
567       dmarc_pass_fail = US"pass";
568       dmarc_status_text = US"Accept";
569       action = DMARC_RESULT_ACCEPT;
570       break;
571     case DMARC_POLICY_REJECT:       /* Explicit reject */
572       dmarc_status = US"reject";
573       dmarc_pass_fail = US"fail";
574       dmarc_status_text = US"Reject";
575       action = DMARC_RESULT_REJECT;
576       break;
577     case DMARC_POLICY_QUARANTINE:       /* Explicit quarantine */
578       dmarc_status = US"quarantine";
579       dmarc_pass_fail = US"fail";
580       dmarc_status_text = US"Quarantine";
581       action = DMARC_RESULT_QUARANTINE;
582       break;
583     default:
584       dmarc_status = US"temperror";
585       dmarc_pass_fail = US"temperror";
586       dmarc_status_text = US"Internal Policy Error";
587       action = DMARC_RESULT_TEMPFAIL;
588       break;
589     }
590
591   libdm_status = opendmarc_policy_fetch_alignment(dmarc_pctx, &da, &sa);
592   if (libdm_status != DMARC_PARSE_OKAY)
593     log_write(0, LOG_MAIN|LOG_PANIC, "failure to read DMARC alignment: %s",
594                              opendmarc_policy_status_to_str(libdm_status));
595
596   if (has_dmarc_record)
597     {
598     log_write(0, LOG_MAIN, "DMARC results: spf_domain=%s dmarc_domain=%s "
599                            "spf_align=%s dkim_align=%s enforcement='%s'",
600                            spf_sender_domain, dmarc_used_domain,
601                            sa==DMARC_POLICY_SPF_ALIGNMENT_PASS  ?"yes":"no",
602                            da==DMARC_POLICY_DKIM_ALIGNMENT_PASS ?"yes":"no",
603                            dmarc_status_text);
604     history_file_status = dmarc_write_history_file();
605     /* Now get the forensic reporting addresses, if any */
606     ruf = opendmarc_policy_fetch_ruf(dmarc_pctx, NULL, 0, 1);
607     dmarc_send_forensic_report(ruf);
608     }
609   }
610
611 /* shut down libopendmarc */
612 if (dmarc_pctx)
613   (void) opendmarc_policy_connect_shutdown(dmarc_pctx);
614 if (!f.dmarc_disable_verify)
615   (void) opendmarc_policy_library_shutdown(&dmarc_ctx);
616
617 return OK;
618 }
619
620 uschar *
621 dmarc_exim_expand_query(int what)
622 {
623 if (f.dmarc_disable_verify || !dmarc_pctx)
624   return dmarc_exim_expand_defaults(what);
625
626 if (what == DMARC_VERIFY_STATUS)
627   return dmarc_status;
628 return US"";
629 }
630
631 uschar *
632 dmarc_exim_expand_defaults(int what)
633 {
634 if (what == DMARC_VERIFY_STATUS)
635   return f.dmarc_disable_verify ?  US"off" : US"none";
636 return US"";
637 }
638
639
640 gstring *
641 authres_dmarc(gstring * g)
642 {
643 if (f.dmarc_has_been_checked)
644   {
645   g = string_append(g, 2, US";\n\tdmarc=", dmarc_pass_fail);
646   if (header_from_sender)
647     g = string_append(g, 2, US" header.from=", header_from_sender);
648   }
649 return g;
650 }
651
652 # endif /* SUPPORT_SPF */
653 #endif /* SUPPORT_DMARC */
654 /* vi: aw ai sw=2
655  */