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