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