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