b085e9ee2ab39553ab4e9762386356e27439a4ce
[exim.git] / src / src / log.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2020 - 2021 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Functions for writing log files. The code for maintaining datestamped
10 log files was originally contributed by Tony Sheen. */
11
12
13 #include "exim.h"
14
15 #define LOG_NAME_SIZE 256
16 #define MAX_SYSLOG_LEN 870
17
18 #define LOG_MODE_FILE   1
19 #define LOG_MODE_SYSLOG 2
20
21 enum { lt_main, lt_reject, lt_panic, lt_debug };
22
23 static uschar *log_names[] = { US"main", US"reject", US"panic", US"debug" };
24
25
26
27 /*************************************************
28 *           Local static variables               *
29 *************************************************/
30
31 static uschar mainlog_name[LOG_NAME_SIZE];
32 static uschar rejectlog_name[LOG_NAME_SIZE];
33 static uschar debuglog_name[LOG_NAME_SIZE];
34
35 static uschar *mainlog_datestamp = NULL;
36 static uschar *rejectlog_datestamp = NULL;
37
38 static int    mainlogfd = -1;
39 static int    rejectlogfd = -1;
40 static ino_t  mainlog_inode = 0;
41 static ino_t  rejectlog_inode = 0;
42
43 static uschar *panic_save_buffer = NULL;
44 static BOOL   panic_recurseflag = FALSE;
45
46 static BOOL   syslog_open = FALSE;
47 static BOOL   path_inspected = FALSE;
48 static int    logging_mode = LOG_MODE_FILE;
49 static uschar *file_path = US"";
50
51 static size_t pid_position[2];
52
53
54 /* These should be kept in-step with the private delivery error
55 number definitions in macros.h */
56
57 static const uschar * exim_errstrings[] = {
58   US"",
59   US"unknown error",
60   US"user slash",
61   US"exist race",
62   US"not regular",
63   US"not directory",
64   US"bad ugid",
65   US"bad mode",
66   US"inode changed",
67   US"lock failed",
68   US"bad address2",
69   US"forbid pipe",
70   US"forbid file",
71   US"forbid reply",
72   US"missing pipe",
73   US"missing file",
74   US"missing reply",
75   US"bad redirect",
76   US"smtp closed",
77   US"smtp format",
78   US"spool format",
79   US"not absolute",
80   US"Exim-imposed quota",
81   US"held",
82   US"Delivery filter process failure",
83   US"Delivery add/remove header failure",
84   US"Delivery write incomplete error",
85   US"Some expansion failed",
86   US"Failed to get gid",
87   US"Failed to get uid",
88   US"Unset or non-existent transport",
89   US"MBX length mismatch",
90   US"Lookup failed routing or in smtp tpt",
91   US"Can't match format in appendfile",
92   US"Creation outside home in appendfile",
93   US"Can't check a list; lookup defer",
94   US"DNS lookup defer",
95   US"Failed to start TLS session",
96   US"Mandatory TLS session not started",
97   US"Failed to chown a file",
98   US"Failed to create a pipe",
99   US"When verifying",
100   US"When required by client",
101   US"Used internally in smtp transport",
102   US"RCPT gave 4xx error",
103   US"MAIL gave 4xx error",
104   US"DATA gave 4xx error",
105   US"Negotiation failed for proxy configured host",
106   US"Authenticator 'other' failure",
107   US"target not supporting SMTPUTF8",
108   US"host is local",
109   US"tainted filename",
110
111   US"Not time for routing",
112   US"Not time for local delivery",
113   US"Not time for any remote host",
114   US"Local-only delivery",
115   US"Domain in queue_domains",
116   US"Transport concurrency limit",
117   US"Event requests alternate response",
118 };
119
120
121 /************************************************/
122 const uschar *
123 exim_errstr(int err)
124 {
125 return err < 0 ? exim_errstrings[-err] : CUS strerror(err);
126 }
127
128 /*************************************************
129 *              Write to syslog                   *
130 *************************************************/
131
132 /* The given string is split into sections according to length, or at embedded
133 newlines, and syslogged as a numbered sequence if it is overlong or if there is
134 more than one line. However, if we are running in the test harness, do not do
135 anything. (The test harness doesn't use syslog - for obvious reasons - but we
136 can get here if there is a failure to open the panic log.)
137
138 Arguments:
139   priority       syslog priority
140   s              the string to be written
141
142 Returns:         nothing
143 */
144
145 static void
146 write_syslog(int priority, const uschar *s)
147 {
148 int len;
149 int linecount = 0;
150
151 if (!syslog_pid && LOGGING(pid))
152   s = string_sprintf("%.*s%s", (int)pid_position[0], s, s + pid_position[1]);
153 if (!syslog_timestamp)
154   {
155   len = log_timezone ? 26 : 20;
156   if (LOGGING(millisec)) len += 4;
157   s += len;
158   }
159
160 len = Ustrlen(s);
161
162 #ifndef NO_OPENLOG
163 if (!syslog_open && !f.running_in_test_harness)
164   {
165 # ifdef SYSLOG_LOG_PID
166   openlog(CS syslog_processname, LOG_PID|LOG_CONS, syslog_facility);
167 # else
168   openlog(CS syslog_processname, LOG_CONS, syslog_facility);
169 # endif
170   syslog_open = TRUE;
171   }
172 #endif
173
174 /* First do a scan through the message in order to determine how many lines
175 it is going to end up as. Then rescan to output it. */
176
177 for (int pass = 0; pass < 2; pass++)
178   {
179   const uschar * ss = s;
180   for (int i = 1, tlen = len; tlen > 0; i++)
181     {
182     int plen = tlen;
183     uschar *nlptr = Ustrchr(ss, '\n');
184     if (nlptr != NULL) plen = nlptr - ss;
185 #ifndef SYSLOG_LONG_LINES
186     if (plen > MAX_SYSLOG_LEN) plen = MAX_SYSLOG_LEN;
187 #endif
188     tlen -= plen;
189     if (ss[plen] == '\n') tlen--;    /* chars left */
190
191     if (pass == 0)
192       linecount++;
193     else if (f.running_in_test_harness)
194       if (linecount == 1)
195         fprintf(stderr, "SYSLOG: '%.*s'\n", plen, ss);
196       else
197         fprintf(stderr, "SYSLOG: '[%d%c%d] %.*s'\n", i,
198           ss[plen] == '\n' && tlen != 0 ? '\\' : '/',
199           linecount, plen, ss);
200     else
201       if (linecount == 1)
202         syslog(priority, "%.*s", plen, ss);
203       else
204         syslog(priority, "[%d%c%d] %.*s", i,
205           ss[plen] == '\n' && tlen != 0 ? '\\' : '/',
206           linecount, plen, ss);
207
208     ss += plen;
209     if (*ss == '\n') ss++;
210     }
211   }
212 }
213
214
215
216 /*************************************************
217 *             Die tidily                         *
218 *************************************************/
219
220 /* This is called when Exim is dying as a result of something going wrong in
221 the logging, or after a log call with LOG_PANIC_DIE set. Optionally write a
222 message to debug_file or a stderr file, if they exist. Then, if in the middle
223 of accepting a message, throw it away tidily by calling receive_bomb_out();
224 this will attempt to send an SMTP response if appropriate. Passing NULL as the
225 first argument stops it trying to run the NOTQUIT ACL (which might try further
226 logging and thus cause problems). Otherwise, try to close down an outstanding
227 SMTP call tidily.
228
229 Arguments:
230   s1         Error message to write to debug_file and/or stderr and syslog
231   s2         Error message for any SMTP call that is in progress
232 Returns:     The function does not return
233 */
234
235 static void
236 die(uschar *s1, uschar *s2)
237 {
238 if (s1)
239   {
240   write_syslog(LOG_CRIT, s1);
241   if (debug_file) debug_printf("%s\n", s1);
242   if (log_stderr && log_stderr != debug_file)
243     fprintf(log_stderr, "%s\n", s1);
244   }
245 if (f.receive_call_bombout) receive_bomb_out(NULL, s2);  /* does not return */
246 if (smtp_input) smtp_closedown(s2);
247 exim_exit(EXIT_FAILURE);
248 }
249
250
251
252 /*************************************************
253 *             Create a log file                  *
254 *************************************************/
255
256 /* This function is called to create and open a log file. It may be called in a
257 subprocess when the original process is root.
258
259 Arguments:
260   name         the file name
261
262 The file name has been build in a working buffer, so it is permissible to
263 overwrite it temporarily if it is necessary to create the directory.
264
265 Returns:       a file descriptor, or < 0 on failure (errno set)
266 */
267
268 static int
269 log_open_already_exim(uschar * const name)
270 {
271 int fd = -1;
272 const int flags = O_WRONLY | O_APPEND | O_CREAT | O_NONBLOCK;
273
274 if (geteuid() != exim_uid)
275   {
276   errno = EACCES;
277   return -1;
278   }
279
280 fd = Uopen(name, flags, LOG_MODE);
281
282 /* If creation failed, attempt to build a log directory in case that is the
283 problem. */
284
285 if (fd < 0 && errno == ENOENT)
286   {
287   BOOL created;
288   uschar *lastslash = Ustrrchr(name, '/');
289   *lastslash = 0;
290   created = directory_make(NULL, name, LOG_DIRECTORY_MODE, FALSE);
291   DEBUG(D_any)
292     if (created)
293       debug_printf("created log directory %s\n", name);
294     else
295       debug_printf("failed to create log directory %s: %s\n", name, strerror(errno));
296   *lastslash = '/';
297   if (created) fd = Uopen(name, flags, LOG_MODE);
298   }
299
300 return fd;
301 }
302
303
304
305 /* Inspired by OpenSSH's mm_send_fd(). Thanks!
306 Send fd over socketpair.
307 Return: true iff good.
308 */
309
310 static BOOL
311 log_send_fd(const int sock, const int fd)
312 {
313 struct msghdr msg;
314 union {
315   struct cmsghdr hdr;
316   char buf[CMSG_SPACE(sizeof(int))];
317 } cmsgbuf;
318 struct cmsghdr *cmsg;
319 char ch = 'A';
320 struct iovec vec = {.iov_base = &ch, .iov_len = 1};
321 ssize_t n;
322
323 memset(&msg, 0, sizeof(msg));
324 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
325 msg.msg_control = &cmsgbuf.buf;
326 msg.msg_controllen = sizeof(cmsgbuf.buf);
327
328 cmsg = CMSG_FIRSTHDR(&msg);
329 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
330 cmsg->cmsg_level = SOL_SOCKET;
331 cmsg->cmsg_type = SCM_RIGHTS;
332 *(int *)CMSG_DATA(cmsg) = fd;
333
334 msg.msg_iov = &vec;
335 msg.msg_iovlen = 1;
336
337 while ((n = sendmsg(sock, &msg, 0)) == -1 && errno == EINTR);
338 return n == 1;
339 }
340
341 /* Inspired by OpenSSH's mm_receive_fd(). Thanks!
342 Return fd passed over socketpair, or -1 on error.
343 */
344
345 static int
346 log_recv_fd(const int sock)
347 {
348 struct msghdr msg;
349 union {
350   struct cmsghdr hdr;
351   char buf[CMSG_SPACE(sizeof(int))];
352 } cmsgbuf;
353 struct cmsghdr *cmsg;
354 char ch = '\0';
355 struct iovec vec = {.iov_base = &ch, .iov_len = 1};
356 ssize_t n;
357 int fd;
358
359 memset(&msg, 0, sizeof(msg));
360 msg.msg_iov = &vec;
361 msg.msg_iovlen = 1;
362
363 memset(&cmsgbuf, 0, sizeof(cmsgbuf));
364 msg.msg_control = &cmsgbuf.buf;
365 msg.msg_controllen = sizeof(cmsgbuf.buf);
366
367 while ((n = recvmsg(sock, &msg, 0)) == -1 && errno == EINTR) ;
368 if (n != 1 || ch != 'A') return -1;
369
370 if (!(cmsg = CMSG_FIRSTHDR(&msg))) return -1;
371 if (cmsg->cmsg_type != SCM_RIGHTS) return -1;
372 if ((fd = *(const int *)CMSG_DATA(cmsg)) < 0) return -1;
373 return fd;
374 }
375
376
377
378 /*************************************************
379 *     Create a log file as the exim user         *
380 *************************************************/
381
382 /* This function is called when we are root to spawn an exim:exim subprocess
383 in which we can create a log file. It must be signal-safe since it is called
384 by the usr1_handler().
385
386 Arguments:
387   name         the file name
388
389 Returns:       a file descriptor, or < 0 on failure (errno set)
390 */
391
392 int
393 log_open_as_exim(uschar * const name)
394 {
395 int fd = -1;
396 const uid_t euid = geteuid();
397
398 if (euid == exim_uid)
399   fd = log_open_already_exim(name);
400 else if (euid == root_uid)
401   {
402   int sock[2];
403   if (socketpair(AF_UNIX, SOCK_STREAM, 0, sock) == 0)
404     {
405     const pid_t pid = fork();
406     if (pid == 0)
407       {
408       (void)close(sock[0]);
409       if (  setgroups(1, &exim_gid) != 0
410          || setgid(exim_gid) != 0
411          || setuid(exim_uid) != 0
412
413          || getuid() != exim_uid || geteuid() != exim_uid
414          || getgid() != exim_gid || getegid() != exim_gid
415
416          || (fd = log_open_already_exim(name)) < 0
417          || !log_send_fd(sock[1], fd)
418          ) _exit(EXIT_FAILURE);
419       (void)close(sock[1]);
420       _exit(EXIT_SUCCESS);
421       }
422
423     (void)close(sock[1]);
424     if (pid > 0)
425       {
426       fd = log_recv_fd(sock[0]);
427       while (waitpid(pid, NULL, 0) == -1 && errno == EINTR);
428       }
429     (void)close(sock[0]);
430     }
431   }
432
433 if (fd >= 0)
434   {
435   int flags;
436   flags = fcntl(fd, F_GETFD);
437   if (flags != -1) (void)fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
438   flags = fcntl(fd, F_GETFL);
439   if (flags != -1) (void)fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
440   }
441 else
442   errno = EACCES;
443
444 return fd;
445 }
446
447
448
449
450 /*************************************************
451 *                Open a log file                 *
452 *************************************************/
453
454 /* This function opens one of a number of logs, creating the log directory if
455 it does not exist. This may be called recursively on failure, in order to open
456 the panic log.
457
458 The directory is in the static variable file_path. This is static so that
459 the work of sorting out the path is done just once per Exim process.
460
461 Exim is normally configured to avoid running as root wherever possible, the log
462 files must be owned by the non-privileged exim user. To ensure this, first try
463 an open without O_CREAT - most of the time this will succeed. If it fails, try
464 to create the file; if running as root, this must be done in a subprocess to
465 avoid races.
466
467 Arguments:
468   fd         where to return the resulting file descriptor
469   type       lt_main, lt_reject, lt_panic, or lt_debug
470   tag        optional tag to include in the name (only hooked up for debug)
471
472 Returns:   nothing
473 */
474
475 static void
476 open_log(int *fd, int type, uschar *tag)
477 {
478 uid_t euid;
479 BOOL ok, ok2;
480 uschar buffer[LOG_NAME_SIZE];
481
482 /* The names of the log files are controlled by file_path. The panic log is
483 written to the same directory as the main and reject logs, but its name does
484 not have a datestamp. The use of datestamps is indicated by %D/%M in file_path.
485 When opening the panic log, if %D or %M is present, we remove the datestamp
486 from the generated name; if it is at the start, remove a following
487 non-alphanumeric character as well; otherwise, remove a preceding
488 non-alphanumeric character. This is definitely kludgy, but it sort of does what
489 people want, I hope. */
490
491 ok = string_format(buffer, sizeof(buffer), CS file_path, log_names[type]);
492
493 switch (type)
494   {
495   case lt_main:
496     /* Save the name of the mainlog for rollover processing. Without a datestamp,
497     it gets statted to see if it has been cycled. With a datestamp, the datestamp
498     will be compared. The static slot for saving it is the same size as buffer,
499     and the text has been checked above to fit, so this use of strcpy() is OK. */
500
501     Ustrcpy(mainlog_name, buffer);
502     if (string_datestamp_offset > 0)
503       mainlog_datestamp = mainlog_name + string_datestamp_offset;
504     break;
505
506   case lt_reject:
507     /* Ditto for the reject log */
508
509     Ustrcpy(rejectlog_name, buffer);
510     if (string_datestamp_offset > 0)
511       rejectlog_datestamp = rejectlog_name + string_datestamp_offset;
512     break;
513
514   case lt_debug:
515     /* and deal with the debug log (which keeps the datestamp, but does not
516     update it) */
517
518     Ustrcpy(debuglog_name, buffer);
519     if (tag)
520       {
521       if (is_tainted(tag))
522         die(US"exim: tainted tag for debug log filename",
523               US"Logging failure; please try later");
524
525       /* this won't change the offset of the datestamp */
526       ok2 = string_format(buffer, sizeof(buffer), "%s%s",
527         debuglog_name, tag);
528       if (ok2)
529         Ustrcpy(debuglog_name, buffer);
530       }
531     break;
532
533   default:
534     /* Remove any datestamp if this is the panic log. This is rare, so there's no
535   need to optimize getting the datestamp length. We remove one non-alphanumeric
536   char afterwards if at the start, otherwise one before. */
537
538     if (string_datestamp_offset >= 0)
539       {
540       uschar * from = buffer + string_datestamp_offset;
541       uschar * to = from + string_datestamp_length;
542
543       if (from == buffer || from[-1] == '/')
544         {
545         if (!isalnum(*to)) to++;
546         }
547       else
548         if (!isalnum(from[-1])) from--;
549
550       /* This copy is ok, because we know that to is a substring of from. But
551       due to overlap we must use memmove() not Ustrcpy(). */
552       memmove(from, to, Ustrlen(to)+1);
553       }
554     break;
555   }
556
557 /* If the file name is too long, it is an unrecoverable disaster */
558
559 if (!ok)
560   die(US"exim: log file path too long: aborting",
561       US"Logging failure; please try later");
562
563 /* We now have the file name. After a successful open, return. */
564
565 if ((*fd = log_open_as_exim(buffer)) >= 0)
566   return;
567
568 euid = geteuid();
569
570 /* Creation failed. There are some circumstances in which we get here when
571 the effective uid is not root or exim, which is the problem. (For example, a
572 non-setuid binary with log_arguments set, called in certain ways.) Rather than
573 just bombing out, force the log to stderr and carry on if stderr is available.
574 */
575
576 if (euid != root_uid && euid != exim_uid && log_stderr)
577   {
578   *fd = fileno(log_stderr);
579   return;
580   }
581
582 /* Otherwise this is a disaster. This call is deliberately ONLY to the panic
583 log. If possible, save a copy of the original line that was being logged. If we
584 are recursing (can't open the panic log either), the pointer will already be
585 set.  Also, when we had to use a subprocess for the create we didn't retrieve
586 errno from it, so get the error from the open attempt above (which is often
587 meaningful enough, so leave it). */
588
589 if (!panic_save_buffer)
590   if ((panic_save_buffer = US malloc(LOG_BUFFER_SIZE)))
591     memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
592
593 log_write(0, LOG_PANIC_DIE, "Cannot open %s log file \"%s\": %s: "
594   "euid=%d egid=%d", log_names[type], buffer, strerror(errno), euid, getegid());
595 /* Never returns */
596 }
597
598
599 static void
600 unlink_log(int type)
601 {
602 if (type == lt_debug) unlink(CS debuglog_name);
603 }
604
605
606
607 /*************************************************
608 *     Add configuration file info to log line    *
609 *************************************************/
610
611 /* This is put in a function because it's needed twice (once for debugging,
612 once for real).
613
614 Arguments:
615   ptr         pointer to the end of the line we are building
616   flags       log flags
617
618 Returns:      updated pointer
619 */
620
621 static gstring *
622 log_config_info(gstring * g, int flags)
623 {
624 g = string_cat(g, US"Exim configuration error");
625
626 if (flags & (LOG_CONFIG_FOR & ~LOG_CONFIG))
627   return string_cat(g, US" for ");
628
629 if (flags & (LOG_CONFIG_IN & ~LOG_CONFIG))
630   g = string_fmt_append(g, " in line %d of %s", config_lineno, config_filename);
631
632 return string_catn(g, US":\n  ", 4);
633 }
634
635
636 /*************************************************
637 *           A write() operation failed           *
638 *************************************************/
639
640 /* This function is called when write() fails on anything other than the panic
641 log, which can happen if a disk gets full or a file gets too large or whatever.
642 We try to save the relevant message in the panic_save buffer before crashing
643 out.
644
645 The potential invoker should probably not call us for EINTR -1 writes.  But
646 otherwise, short writes are bad as we don't do non-blocking writes to fds
647 subject to flow control.  (If we do, that's new and the logic of this should
648 be reconsidered).
649
650 Arguments:
651   name      the name of the log being written
652   length    the string length being written
653   rc        the return value from write()
654
655 Returns:    does not return
656 */
657
658 static void
659 log_write_failed(uschar *name, int length, int rc)
660 {
661 int save_errno = errno;
662
663 if (!panic_save_buffer)
664   if ((panic_save_buffer = US malloc(LOG_BUFFER_SIZE)))
665     memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
666
667 log_write(0, LOG_PANIC_DIE, "failed to write to %s: length=%d result=%d "
668   "errno=%d (%s)", name, length, rc, save_errno,
669   (save_errno == 0)? "write incomplete" : strerror(save_errno));
670 /* Never returns */
671 }
672
673
674
675 /*************************************************
676 *     Write to an fd, retrying after signals     *
677 *************************************************/
678
679 /* Basic write to fd for logs, handling EINTR.
680
681 Arguments:
682   fd        the fd to write to
683   buf       the string to write
684   length    the string length being written
685
686 Returns:
687   length actually written, persisting an errno from write()
688 */
689 ssize_t
690 write_to_fd_buf(int fd, const uschar *buf, size_t length)
691 {
692 ssize_t wrote;
693 size_t total_written = 0;
694 const uschar *p = buf;
695 size_t left = length;
696
697 while (1)
698   {
699   wrote = write(fd, p, left);
700   if (wrote == (ssize_t)-1)
701     {
702     if (errno == EINTR) continue;
703     return wrote;
704     }
705   total_written += wrote;
706   if (wrote == left)
707     break;
708   else
709     {
710     p += wrote;
711     left -= wrote;
712     }
713   }
714 return total_written;
715 }
716
717
718 /* Pull the file out of the configured or the compiled-in list.
719 Called for an empty log_file_path element, for debug logging activation
720 when file_path has not previously been set, and from the appenfile transport setup. */
721
722 void
723 set_file_path(BOOL *multiple)
724 {
725 uschar *s;
726 int sep = ':';              /* Fixed separator - outside use */
727 const uschar *ss = *log_file_path ? log_file_path : US LOG_FILE_PATH;
728
729 if (*ss)
730   for (logging_mode = 0;
731        s = string_nextinlist(&ss, &sep, log_buffer, LOG_BUFFER_SIZE); )
732     {
733     if (Ustrcmp(s, "syslog") == 0)
734       logging_mode |= LOG_MODE_SYSLOG;
735     else if (!(logging_mode & LOG_MODE_FILE))  /* no file yet */
736       {
737       logging_mode |= LOG_MODE_FILE;
738       if (*s) file_path = string_copy(s);     /* If a non-empty path is given, use it */
739       }
740     else if (multiple) *multiple = TRUE;
741     }
742 else
743   logging_mode = LOG_MODE_FILE;
744
745 /* Set up the ultimate default if necessary. */
746
747 if (logging_mode & LOG_MODE_FILE  &&  !*file_path)
748   if (LOG_FILE_PATH[0])
749     {
750       /* If we still do not have a file_path, we take
751       the first non-empty, non-syslog item in LOG_FILE_PATH, if there is
752       one.  If there is no such item, use the ultimate default in the
753       spool directory. */
754
755        for (ss = US LOG_FILE_PATH;
756             s = string_nextinlist(&ss, &sep, log_buffer, LOG_BUFFER_SIZE);)
757           {
758             if (*s != '/') continue;
759             file_path = string_copy(s);
760           }
761     }
762   else file_path = string_sprintf("%s/log/%%slog", spool_directory);
763 }
764
765
766 void
767 mainlog_close(void)
768 {
769 /* avoid closing it if it is closed already or if we do not see a chance
770 to open the file mainlog later again */
771 if (mainlogfd < 0 /* already closed */
772    || !(geteuid() == 0 || geteuid() == exim_uid))
773   return;
774 (void)close(mainlogfd);
775 mainlogfd = -1;
776 mainlog_inode = 0;
777 }
778
779 /*************************************************
780 *            Write message to log file           *
781 *************************************************/
782
783 /* Exim can be configured to log to local files, or use syslog, or both. This
784 is controlled by the setting of log_file_path. The following cases are
785 recognized:
786
787   log_file_path = ""               write files in the spool/log directory
788   log_file_path = "xxx"            write files in the xxx directory
789   log_file_path = "syslog"         write to syslog
790   log_file_path = "syslog : xxx"   write to syslog and to files (any order)
791
792 The message always gets '\n' added on the end of it, since more than one
793 process may be writing to the log at once and we don't want intermingling to
794 happen in the middle of lines. To be absolutely sure of this we write the data
795 into a private buffer and then put it out in a single write() call.
796
797 The flags determine which log(s) the message is written to, or for syslogging,
798 which priority to use, and in the case of the panic log, whether the process
799 should die afterwards.
800
801 The variable really_exim is TRUE only when exim is running in privileged state
802 (i.e. not with a changed configuration or with testing options such as -brw).
803 If it is not, don't try to write to the log because permission will probably be
804 denied.
805
806 Avoid actually writing to the logs when exim is called with -bv or -bt to
807 test an address, but take other actions, such as panicking.
808
809 In Exim proper, the buffer for building the message is got at start-up, so that
810 nothing gets done if it can't be got. However, some functions that are also
811 used in utilities occasionally obey log_write calls in error situations, and it
812 is simplest to put a single malloc() here rather than put one in each utility.
813 Malloc is used directly because the store functions may call log_write().
814
815 If a message_id exists, we include it after the timestamp.
816
817 Arguments:
818   selector  write to main log or LOG_INFO only if this value is zero, or if
819               its bit is set in log_selector[0]
820   flags     each bit indicates some independent action:
821               LOG_SENDER      add raw sender to the message
822               LOG_RECIPIENTS  add raw recipients list to message
823               LOG_CONFIG      add "Exim configuration error"
824               LOG_CONFIG_FOR  add " for " instead of ":\n  "
825               LOG_CONFIG_IN   add " in line x[ of file y]"
826               LOG_MAIN        write to main log or syslog LOG_INFO
827               LOG_REJECT      write to reject log or syslog LOG_NOTICE
828               LOG_PANIC       write to panic log or syslog LOG_ALERT
829               LOG_PANIC_DIE   write to panic log or LOG_ALERT and then crash
830   format    a printf() format
831   ...       arguments for format
832
833 Returns:    nothing
834 */
835
836 void
837 log_write(unsigned int selector, int flags, const char *format, ...)
838 {
839 int paniclogfd;
840 ssize_t written_len;
841 gstring gs = { .size = LOG_BUFFER_SIZE-1, .ptr = 0, .s = log_buffer };
842 gstring * g;
843 va_list ap;
844
845 /* If panic_recurseflag is set, we have failed to open the panic log. This is
846 the ultimate disaster. First try to write the message to a debug file and/or
847 stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
848 original log line that caused the problem. Afterwards, expire. */
849
850 if (panic_recurseflag)
851   {
852   uschar *extra = panic_save_buffer ? panic_save_buffer : US"";
853   if (debug_file) debug_printf("%s%s", extra, log_buffer);
854   if (log_stderr && log_stderr != debug_file)
855     fprintf(log_stderr, "%s%s", extra, log_buffer);
856   if (*extra) write_syslog(LOG_CRIT, extra);
857   write_syslog(LOG_CRIT, log_buffer);
858   die(US"exim: could not open panic log - aborting: see message(s) above",
859     US"Unexpected log failure, please try later");
860   }
861
862 /* Ensure we have a buffer (see comment above); this should never be obeyed
863 when running Exim proper, only when running utilities. */
864
865 if (!log_buffer)
866   if (!(log_buffer = US malloc(LOG_BUFFER_SIZE)))
867     {
868     fprintf(stderr, "exim: failed to get store for log buffer\n");
869     exim_exit(EXIT_FAILURE);
870     }
871
872 /* If we haven't already done so, inspect the setting of log_file_path to
873 determine whether to log to files and/or to syslog. Bits in logging_mode
874 control this, and for file logging, the path must end up in file_path. This
875 variable must be in permanent store because it may be required again later in
876 the process. */
877
878 if (!path_inspected)
879   {
880   BOOL multiple = FALSE;
881   int old_pool = store_pool;
882
883   store_pool = POOL_PERM;
884
885   /* make sure that we have a valid log file path in "file_path",
886   the open_log() later relies on it */
887   set_file_path(&multiple);
888
889   /* If no modes have been selected, it is a major disaster */
890
891   if (logging_mode == 0)
892     die(US"Neither syslog nor file logging set in log_file_path",
893         US"Unexpected logging failure");
894
895   /* Revert to the old store pool, and record that we've sorted out the path. */
896
897   store_pool = old_pool;
898   path_inspected = TRUE;
899
900   /* If more than one file path was given, log a complaint. This recursive call
901   should work since we have now set up the routing. */
902
903   if (multiple)
904     log_write(0, LOG_MAIN|LOG_PANIC,
905       "More than one path given in log_file_path: using %s", file_path);
906   }
907
908 /* If debugging, show all log entries, but don't show headers. Do it all
909 in one go so that it doesn't get split when multi-processing. */
910
911 DEBUG(D_any|D_v)
912   {
913   int i;
914
915   g = string_catn(&gs, US"LOG:", 4);
916
917   /* Show the selector that was passed into the call. */
918
919   for (i = 0; i < log_options_count; i++)
920     {
921     unsigned int bitnum = log_options[i].bit;
922     if (bitnum < BITWORDSIZE && selector == BIT(bitnum))
923       g = string_fmt_append(g, " %s", log_options[i].name);
924     }
925
926   g = string_fmt_append(g, "%s%s%s%s\n  ",
927     flags & LOG_MAIN ?    " MAIN"   : "",
928     flags & LOG_PANIC ?   " PANIC"  : "",
929     (flags & LOG_PANIC_DIE) == LOG_PANIC_DIE ? " DIE" : "",
930     flags & LOG_REJECT ?  " REJECT" : "");
931
932   if (flags & LOG_CONFIG) g = log_config_info(g, flags);
933
934   /* We want to be able to log tainted info, but log_buffer is directly
935   malloc'd.  So use deliberately taint-nonchecking routines to build into
936   it, trusting that we will never expand the results. */
937
938   va_start(ap, format);
939   i = g->ptr;
940   if (!string_vformat(g, SVFMT_TAINT_NOCHK, format, ap))
941     {
942     g->ptr = i;
943     g = string_cat(g, US"**** log string overflowed log buffer ****");
944     }
945   va_end(ap);
946
947   g->size = LOG_BUFFER_SIZE;
948   g = string_catn(g, US"\n", 1);
949   debug_printf("%s", string_from_gstring(g));
950
951   gs.size = LOG_BUFFER_SIZE-1;  /* Having used the buffer for debug output, */
952   gs.ptr = 0;                   /* reset it for the real use. */
953   gs.s = log_buffer;
954   }
955 /* If no log file is specified, we are in a mess. */
956
957 if (!(flags & (LOG_MAIN|LOG_PANIC|LOG_REJECT)))
958   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_write called with no log "
959     "flags set");
960
961 /* There are some weird circumstances in which logging is disabled. */
962
963 if (f.disable_logging)
964   {
965   DEBUG(D_any) debug_printf("log writing disabled\n");
966   if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE);
967   return;
968   }
969
970 /* Handle disabled reject log */
971
972 if (!write_rejectlog) flags &= ~LOG_REJECT;
973
974 /* Create the main message in the log buffer. Do not include the message id
975 when called by a utility. */
976
977 g = string_fmt_append(&gs, "%s ", tod_stamp(tod_log));
978
979 if (LOGGING(pid))
980   {
981   if (!syslog_pid) pid_position[0] = g->ptr;            /* remember begin â€¦ */
982   g = string_fmt_append(g, "[%d] ", (int)getpid());
983   if (!syslog_pid) pid_position[1] = g->ptr;            /*  â€¦ and end+1 of the PID */
984   }
985
986 if (f.really_exim && message_id[0] != 0)
987   g = string_fmt_append(g, "%s ", message_id);
988
989 if (flags & LOG_CONFIG)
990   g = log_config_info(g, flags);
991
992 va_start(ap, format);
993   {
994   int i = g->ptr;
995
996   /* We want to be able to log tainted info, but log_buffer is directly
997   malloc'd.  So use deliberately taint-nonchecking routines to build into
998   it, trusting that we will never expand the results. */
999
1000   if (!string_vformat(g, SVFMT_TAINT_NOCHK, format, ap))
1001     {
1002     g->ptr = i;
1003     g = string_cat(g, US"**** log string overflowed log buffer ****\n");
1004     }
1005   }
1006 va_end(ap);
1007
1008 /* Add the raw, unrewritten, sender to the message if required. This is done
1009 this way because it kind of fits with LOG_RECIPIENTS. */
1010
1011 if (   flags & LOG_SENDER
1012    && g->ptr < LOG_BUFFER_SIZE - 10 - Ustrlen(raw_sender))
1013   g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " from <%s>", raw_sender);
1014
1015 /* Add list of recipients to the message if required; the raw list,
1016 before rewriting, was saved in raw_recipients. There may be none, if an ACL
1017 discarded them all. */
1018
1019 if (  flags & LOG_RECIPIENTS
1020    && g->ptr < LOG_BUFFER_SIZE - 6
1021    && raw_recipients_count > 0)
1022   {
1023   int i;
1024   g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " for", NULL);
1025   for (i = 0; i < raw_recipients_count; i++)
1026     {
1027     uschar * s = raw_recipients[i];
1028     if (LOG_BUFFER_SIZE - g->ptr < Ustrlen(s) + 3) break;
1029     g = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, " %s", s);
1030     }
1031   }
1032
1033 g = string_catn(g, US"\n", 1);
1034 string_from_gstring(g);
1035
1036 /* Handle loggable errors when running a utility, or when address testing.
1037 Write to log_stderr unless debugging (when it will already have been written),
1038 or unless there is no log_stderr (expn called from daemon, for example). */
1039
1040 if (!f.really_exim || f.log_testing_mode)
1041   {
1042   if (  !debug_selector
1043      && log_stderr
1044      && (selector == 0 || (selector & log_selector[0]) != 0)
1045     )
1046     if (host_checking)
1047       fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20));  /* no timestamp */
1048     else
1049       fprintf(log_stderr, "%s", CS log_buffer);
1050
1051   if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE);
1052   return;
1053   }
1054
1055 /* Handle the main log. We know that either syslog or file logging (or both) is
1056 set up. A real file gets left open during reception or delivery once it has
1057 been opened, but we don't want to keep on writing to it for too long after it
1058 has been renamed. Therefore, do a stat() and see if the inode has changed, and
1059 if so, re-open. */
1060
1061 if (  flags & LOG_MAIN
1062    && (!selector ||  selector & log_selector[0]))
1063   {
1064   if (  logging_mode & LOG_MODE_SYSLOG
1065      && (syslog_duplication || !(flags & (LOG_REJECT|LOG_PANIC))))
1066     write_syslog(LOG_INFO, log_buffer);
1067
1068   if (logging_mode & LOG_MODE_FILE)
1069     {
1070     struct stat statbuf;
1071
1072     /* Check for a change to the mainlog file name when datestamping is in
1073     operation. This happens at midnight, at which point we want to roll over
1074     the file. Closing it has the desired effect. */
1075
1076     if (mainlog_datestamp)
1077       {
1078       uschar *nowstamp = tod_stamp(string_datestamp_type);
1079       if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
1080         {
1081         (void)close(mainlogfd);       /* Close the file */
1082         mainlogfd = -1;               /* Clear the file descriptor */
1083         mainlog_inode = 0;            /* Unset the inode */
1084         mainlog_datestamp = NULL;     /* Clear the datestamp */
1085         }
1086       }
1087
1088     /* Otherwise, we want to check whether the file has been renamed by a
1089     cycling script. This could be "if else", but for safety's sake, leave it as
1090     "if" so that renaming the log starts a new file even when datestamping is
1091     happening. */
1092
1093     if (mainlogfd >= 0)
1094       if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
1095         mainlog_close();
1096
1097     /* If the log is closed, open it. Then write the line. */
1098
1099     if (mainlogfd < 0)
1100       {
1101       open_log(&mainlogfd, lt_main, NULL);     /* No return on error */
1102       if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
1103       }
1104
1105     /* Failing to write to the log is disastrous */
1106
1107     written_len = write_to_fd_buf(mainlogfd, g->s, g->ptr);
1108     if (written_len != g->ptr)
1109       {
1110       log_write_failed(US"main log", g->ptr, written_len);
1111       /* That function does not return */
1112       }
1113     }
1114   }
1115
1116 /* Handle the log for rejected messages. This can be globally disabled, in
1117 which case the flags are altered above. If there are any header lines (i.e. if
1118 the rejection is happening after the DATA phase), log the recipients and the
1119 headers. */
1120
1121 if (flags & LOG_REJECT)
1122   {
1123   if (header_list && LOGGING(rejected_header))
1124     {
1125     gstring * g2;
1126     int i;
1127
1128     if (recipients_count > 0)
1129       {
1130       /* List the sender */
1131
1132       g2 = string_fmt_append_f(g, SVFMT_TAINT_NOCHK,
1133                         "Envelope-from: <%s>\n", sender_address);
1134       if (g2) g = g2;
1135
1136       /* List up to 5 recipients */
1137
1138       g2 = string_fmt_append_f(g, SVFMT_TAINT_NOCHK,
1139                         "Envelope-to: <%s>\n", recipients_list[0].address);
1140       if (g2) g = g2;
1141
1142       for (i = 1; i < recipients_count && i < 5; i++)
1143         {
1144         g2 = string_fmt_append_f(g, SVFMT_TAINT_NOCHK,
1145                         "    <%s>\n", recipients_list[i].address);
1146         if (g2) g = g2;
1147         }
1148
1149       if (i < recipients_count)
1150         {
1151         g2 = string_fmt_append_f(g, SVFMT_TAINT_NOCHK, "    ...\n", NULL);
1152         if (g2) g = g2;
1153         }
1154       }
1155
1156     /* A header with a NULL text is an unfilled in Received: header */
1157
1158     for (header_line * h = header_list; h; h = h->next) if (h->text)
1159       {
1160       g2 = string_fmt_append_f(g, SVFMT_TAINT_NOCHK,
1161                         "%c %s", h->type, h->text);
1162       if (g2)
1163         g = g2;
1164       else              /* Buffer is full; truncate */
1165         {
1166         g->ptr -= 100;        /* For message and separator */
1167         if (g->s[g->ptr-1] == '\n') g->ptr--;
1168         g = string_cat(g, US"\n*** truncated ***\n");
1169         break;
1170         }
1171       }
1172     }
1173
1174   /* Write to syslog or to a log file */
1175
1176   if (  logging_mode & LOG_MODE_SYSLOG
1177      && (syslog_duplication || !(flags & LOG_PANIC)))
1178     write_syslog(LOG_NOTICE, string_from_gstring(g));
1179
1180   /* Check for a change to the rejectlog file name when datestamping is in
1181   operation. This happens at midnight, at which point we want to roll over
1182   the file. Closing it has the desired effect. */
1183
1184   if (logging_mode & LOG_MODE_FILE)
1185     {
1186     struct stat statbuf;
1187
1188     if (rejectlog_datestamp)
1189       {
1190       uschar *nowstamp = tod_stamp(string_datestamp_type);
1191       if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
1192         {
1193         (void)close(rejectlogfd);       /* Close the file */
1194         rejectlogfd = -1;               /* Clear the file descriptor */
1195         rejectlog_inode = 0;            /* Unset the inode */
1196         rejectlog_datestamp = NULL;     /* Clear the datestamp */
1197         }
1198       }
1199
1200     /* Otherwise, we want to check whether the file has been renamed by a
1201     cycling script. This could be "if else", but for safety's sake, leave it as
1202     "if" so that renaming the log starts a new file even when datestamping is
1203     happening. */
1204
1205     if (rejectlogfd >= 0)
1206       if (Ustat(rejectlog_name, &statbuf) < 0 ||
1207            statbuf.st_ino != rejectlog_inode)
1208         {
1209         (void)close(rejectlogfd);
1210         rejectlogfd = -1;
1211         rejectlog_inode = 0;
1212         }
1213
1214     /* Open the file if necessary, and write the data */
1215
1216     if (rejectlogfd < 0)
1217       {
1218       open_log(&rejectlogfd, lt_reject, NULL); /* No return on error */
1219       if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
1220       }
1221
1222     written_len = write_to_fd_buf(rejectlogfd, g->s, g->ptr);
1223     if (written_len != g->ptr)
1224       {
1225       log_write_failed(US"reject log", g->ptr, written_len);
1226       /* That function does not return */
1227       }
1228     }
1229   }
1230
1231
1232 /* Handle the panic log, which is not kept open like the others. If it fails to
1233 open, there will be a recursive call to log_write(). We detect this above and
1234 attempt to write to the system log as a last-ditch try at telling somebody. In
1235 all cases except mua_wrapper, try to write to log_stderr. */
1236
1237 if (flags & LOG_PANIC)
1238   {
1239   if (log_stderr && log_stderr != debug_file && !mua_wrapper)
1240     fprintf(log_stderr, "%s", CS string_from_gstring(g));
1241
1242   if (logging_mode & LOG_MODE_SYSLOG)
1243     write_syslog(LOG_ALERT, log_buffer);
1244
1245   /* If this panic logging was caused by a failure to open the main log,
1246   the original log line is in panic_save_buffer. Make an attempt to write it. */
1247
1248   if (logging_mode & LOG_MODE_FILE)
1249     {
1250     if (!*file_path) set_file_path(NULL);
1251     panic_recurseflag = TRUE;
1252     open_log(&paniclogfd, lt_panic, NULL);  /* Won't return on failure */
1253     panic_recurseflag = FALSE;
1254
1255     if (panic_save_buffer)
1256       (void) write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1257
1258     written_len = write_to_fd_buf(paniclogfd, g->s, g->ptr);
1259     if (written_len != g->ptr)
1260       {
1261       int save_errno = errno;
1262       write_syslog(LOG_CRIT, log_buffer);
1263       sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
1264         "errno=%d (%s)", g->ptr, (int)written_len, save_errno, strerror(save_errno));
1265       write_syslog(LOG_CRIT, string_from_gstring(g));
1266       flags |= LOG_PANIC_DIE;
1267       }
1268
1269     (void)close(paniclogfd);
1270     }
1271
1272   /* Give up if the DIE flag is set */
1273
1274   if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1275     die(NULL, US"Unexpected failure, please try later");
1276   }
1277 }
1278
1279
1280
1281 /*************************************************
1282 *            Close any open log files            *
1283 *************************************************/
1284
1285 void
1286 log_close_all(void)
1287 {
1288 if (mainlogfd >= 0)
1289   { (void)close(mainlogfd); mainlogfd = -1; }
1290 if (rejectlogfd >= 0)
1291   { (void)close(rejectlogfd); rejectlogfd = -1; }
1292 closelog();
1293 syslog_open = FALSE;
1294 }
1295
1296
1297
1298 /*************************************************
1299 *             Multi-bit set or clear             *
1300 *************************************************/
1301
1302 /* These functions take a list of bit indexes (terminated by -1) and
1303 clear or set the corresponding bits in the selector.
1304
1305 Arguments:
1306   selector       address of the bit string
1307   selsize        number of words in the bit string
1308   bits           list of bits to set
1309 */
1310
1311 void
1312 bits_clear(unsigned int *selector, size_t selsize, int *bits)
1313 {
1314 for(; *bits != -1; ++bits)
1315   BIT_CLEAR(selector, selsize, *bits);
1316 }
1317
1318 void
1319 bits_set(unsigned int *selector, size_t selsize, int *bits)
1320 {
1321 for(; *bits != -1; ++bits)
1322   BIT_SET(selector, selsize, *bits);
1323 }
1324
1325
1326
1327 /*************************************************
1328 *         Decode bit settings for log/debug      *
1329 *************************************************/
1330
1331 /* This function decodes a string containing bit settings in the form of +name
1332 and/or -name sequences, and sets/unsets bits in a bit string accordingly. It
1333 also recognizes a numeric setting of the form =<number>, but this is not
1334 intended for user use. It's an easy way for Exim to pass the debug settings
1335 when it is re-exec'ed.
1336
1337 The option table is a list of names and bit indexes. The index -1
1338 means "set all bits, except for those listed in notall". The notall
1339 list is terminated by -1.
1340
1341 The action taken for bad values varies depending upon why we're here.
1342 For log messages, or if the debugging is triggered from config, then we write
1343 to the log on the way out.  For debug setting triggered from the command-line,
1344 we treat it as an unknown option: error message to stderr and die.
1345
1346 Arguments:
1347   selector       address of the bit string
1348   selsize        number of words in the bit string
1349   notall         list of bits to exclude from "all"
1350   string         the configured string
1351   options        the table of option names
1352   count          size of table
1353   which          "log" or "debug"
1354   flags          DEBUG_FROM_CONFIG
1355
1356 Returns:         nothing on success - bomb out on failure
1357 */
1358
1359 void
1360 decode_bits(unsigned int *selector, size_t selsize, int *notall,
1361   uschar *string, bit_table *options, int count, uschar *which, int flags)
1362 {
1363 uschar *errmsg;
1364 if (!string) return;
1365
1366 if (*string == '=')
1367   {
1368   char *end;    /* Not uschar */
1369   memset(selector, 0, sizeof(*selector)*selsize);
1370   *selector = strtoul(CS string+1, &end, 0);
1371   if (!*end) return;
1372   errmsg = string_sprintf("malformed numeric %s_selector setting: %s", which,
1373     string);
1374   goto ERROR_RETURN;
1375   }
1376
1377 /* Handle symbolic setting */
1378
1379 else for(;;)
1380   {
1381   BOOL adding;
1382   uschar *s;
1383   int len;
1384   bit_table *start, *end;
1385
1386   Uskip_whitespace(&string);
1387   if (!*string) return;
1388
1389   if (*string != '+' && *string != '-')
1390     {
1391     errmsg = string_sprintf("malformed %s_selector setting: "
1392       "+ or - expected but found \"%s\"", which, string);
1393     goto ERROR_RETURN;
1394     }
1395
1396   adding = *string++ == '+';
1397   s = string;
1398   while (isalnum(*string) || *string == '_') string++;
1399   len = string - s;
1400
1401   start = options;
1402   end = options + count;
1403
1404   while (start < end)
1405     {
1406     bit_table *middle = start + (end - start)/2;
1407     int c = Ustrncmp(s, middle->name, len);
1408     if (c == 0)
1409       if (middle->name[len] != 0) c = -1; else
1410         {
1411         unsigned int bit = middle->bit;
1412
1413         if (bit == -1)
1414           {
1415           if (adding)
1416             {
1417             memset(selector, -1, sizeof(*selector)*selsize);
1418             bits_clear(selector, selsize, notall);
1419             }
1420           else
1421             memset(selector, 0, sizeof(*selector)*selsize);
1422           }
1423         else if (adding)
1424           BIT_SET(selector, selsize, bit);
1425         else
1426           BIT_CLEAR(selector, selsize, bit);
1427
1428         break;  /* Out of loop to match selector name */
1429         }
1430     if (c < 0) end = middle; else start = middle + 1;
1431     }  /* Loop to match selector name */
1432
1433   if (start >= end)
1434     {
1435     errmsg = string_sprintf("unknown %s_selector setting: %c%.*s", which,
1436       adding? '+' : '-', len, s);
1437     goto ERROR_RETURN;
1438     }
1439   }    /* Loop for selector names */
1440
1441 /* Handle disasters */
1442
1443 ERROR_RETURN:
1444 if (Ustrcmp(which, "debug") == 0)
1445   {
1446   if (flags & DEBUG_FROM_CONFIG)
1447     {
1448     log_write(0, LOG_CONFIG|LOG_PANIC, "%s", errmsg);
1449     return;
1450     }
1451   fprintf(stderr, "exim: %s\n", errmsg);
1452   exit(EXIT_FAILURE);
1453   }
1454 else log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "%s", errmsg);
1455 }
1456
1457
1458
1459 /*************************************************
1460 *        Activate a debug logfile (late)         *
1461 *************************************************/
1462
1463 /* Normally, debugging is activated from the command-line; it may be useful
1464 within the configuration to activate debugging later, based on certain
1465 conditions.  If debugging is already in progress, we return early, no action
1466 taken (besides debug-logging that we wanted debug-logging).
1467
1468 Failures in options are not fatal but will result in paniclog entries for the
1469 misconfiguration.
1470
1471 The first use of this is in ACL logic, "control = debug/tag=foo/opts=+expand"
1472 which can be combined with conditions, etc, to activate extra logging only
1473 for certain sources. The second use is inetd wait mode debug preservation. */
1474
1475 void
1476 debug_logging_activate(uschar *tag_name, uschar *opts)
1477 {
1478 int fd = -1;
1479
1480 if (debug_file)
1481   {
1482   debug_printf("DEBUGGING ACTIVATED FROM WITHIN CONFIG.\n"
1483       "DEBUG: Tag=\"%s\" opts=\"%s\"\n", tag_name, opts ? opts : US"");
1484   return;
1485   }
1486
1487 if (tag_name != NULL && (Ustrchr(tag_name, '/') != NULL))
1488   {
1489   log_write(0, LOG_MAIN|LOG_PANIC, "debug tag may not contain a '/' in: %s",
1490       tag_name);
1491   return;
1492   }
1493
1494 debug_selector = D_default;
1495 if (opts)
1496   decode_bits(&debug_selector, 1, debug_notall, opts,
1497       debug_options, debug_options_count, US"debug", DEBUG_FROM_CONFIG);
1498
1499 /* When activating from a transport process we may never have logged at all
1500 resulting in certain setup not having been done.  Hack this for now so we
1501 do not segfault; note that nondefault log locations will not work */
1502
1503 if (!*file_path) set_file_path(NULL);
1504
1505 open_log(&fd, lt_debug, tag_name);
1506
1507 if (fd != -1)
1508   debug_file = fdopen(fd, "w");
1509 else
1510   log_write(0, LOG_MAIN|LOG_PANIC, "unable to open debug log");
1511 }
1512
1513
1514 void
1515 debug_logging_stop(void)
1516 {
1517 if (!debug_file || !debuglog_name[0]) return;
1518
1519 debug_selector = 0;
1520 fclose(debug_file);
1521 debug_file = NULL;
1522 unlink_log(lt_debug);
1523 }
1524
1525 /* Called from the appendfile transport setup. */
1526 void
1527 open_logs(void)
1528 {
1529 set_file_path(NULL);
1530 if (!(logging_mode & LOG_MODE_FILE)) return;
1531 open_log(&mainlogfd, lt_main, 0);
1532 open_log(&rejectlogfd, lt_reject, 0);
1533 }
1534
1535 /* End of log.c */