Recast more internal string routines to use growable-strings
[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{
571b2715 739uschar * ptr;
059ec3d9 740int paniclogfd;
23ecb73d 741ssize_t written_len;
d12746bc
JH
742gstring gs = { .size = LOG_BUFFER_SIZE-1, .ptr = 0, .s = log_buffer };
743gstring * g;
059ec3d9
PH
744va_list ap;
745
746/* If panic_recurseflag is set, we have failed to open the panic log. This is
747the ultimate disaster. First try to write the message to a debug file and/or
748stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
749original log line that caused the problem. Afterwards, expire. */
750
751if (panic_recurseflag)
752 {
30f962e0
JH
753 uschar *extra = panic_save_buffer ? panic_save_buffer : US"";
754 if (debug_file) debug_printf("%s%s", extra, log_buffer);
755 if (log_stderr && log_stderr != debug_file)
059ec3d9 756 fprintf(log_stderr, "%s%s", extra, log_buffer);
30f962e0 757 if (*extra) write_syslog(LOG_CRIT, extra);
059ec3d9
PH
758 write_syslog(LOG_CRIT, log_buffer);
759 die(US"exim: could not open panic log - aborting: see message(s) above",
760 US"Unexpected log failure, please try later");
761 }
762
763/* Ensure we have a buffer (see comment above); this should never be obeyed
764when running Exim proper, only when running utilities. */
765
40c90bca
JH
766if (!log_buffer)
767 if (!(log_buffer = US malloc(LOG_BUFFER_SIZE)))
059ec3d9
PH
768 {
769 fprintf(stderr, "exim: failed to get store for log buffer\n");
9bfb7e1b 770 exim_exit(EXIT_FAILURE, NULL);
059ec3d9 771 }
059ec3d9
PH
772
773/* If we haven't already done so, inspect the setting of log_file_path to
774determine whether to log to files and/or to syslog. Bits in logging_mode
775control this, and for file logging, the path must end up in file_path. This
776variable must be in permanent store because it may be required again later in
777the process. */
778
779if (!path_inspected)
780 {
781 BOOL multiple = FALSE;
782 int old_pool = store_pool;
783
784 store_pool = POOL_PERM;
785
786 /* If nothing has been set, don't waste effort... the default values for the
787 statics are file_path="" and logging_mode = LOG_MODE_FILE. */
788
e4a6fb35 789 if (*log_file_path)
059ec3d9
PH
790 {
791 int sep = ':'; /* Fixed separator - outside use */
792 uschar *s;
55414b25 793 const uschar *ss = log_file_path;
30f962e0 794
059ec3d9 795 logging_mode = 0;
55414b25 796 while ((s = string_nextinlist(&ss, &sep, log_buffer, LOG_BUFFER_SIZE)))
059ec3d9
PH
797 {
798 if (Ustrcmp(s, "syslog") == 0)
799 logging_mode |= LOG_MODE_SYSLOG;
30f962e0
JH
800 else if (logging_mode & LOG_MODE_FILE)
801 multiple = TRUE;
059ec3d9
PH
802 else
803 {
804 logging_mode |= LOG_MODE_FILE;
805
806 /* If a non-empty path is given, use it */
807
e4a6fb35 808 if (*s)
059ec3d9 809 file_path = string_copy(s);
059ec3d9
PH
810
811 /* If the path is empty, we want to use the first non-empty, non-
812 syslog item in LOG_FILE_PATH, if there is one, since the value of
813 log_file_path may have been set at runtime. If there is no such item,
814 use the ultimate default in the spool directory. */
815
816 else
e4a6fb35 817 set_file_path(); /* Empty item in log_file_path */
059ec3d9
PH
818 } /* First non-syslog item in log_file_path */
819 } /* Scan of log_file_path */
820 }
821
822 /* If no modes have been selected, it is a major disaster */
823
824 if (logging_mode == 0)
825 die(US"Neither syslog nor file logging set in log_file_path",
826 US"Unexpected logging failure");
827
828 /* Set up the ultimate default if necessary. Then revert to the old store
829 pool, and record that we've sorted out the path. */
830
30f962e0 831 if (logging_mode & LOG_MODE_FILE && !file_path[0])
059ec3d9
PH
832 file_path = string_sprintf("%s/log/%%slog", spool_directory);
833 store_pool = old_pool;
834 path_inspected = TRUE;
835
836 /* If more than one file path was given, log a complaint. This recursive call
837 should work since we have now set up the routing. */
838
839 if (multiple)
059ec3d9
PH
840 log_write(0, LOG_MAIN|LOG_PANIC,
841 "More than one path given in log_file_path: using %s", file_path);
059ec3d9
PH
842 }
843
844/* If debugging, show all log entries, but don't show headers. Do it all
845in one go so that it doesn't get split when multi-processing. */
846
847DEBUG(D_any|D_v)
848 {
849 int i;
059ec3d9 850
d12746bc 851 g = string_catn(&gs, US"LOG:", 4);
059ec3d9 852
6c6d6e48 853 /* Show the selector that was passed into the call. */
059ec3d9
PH
854
855 for (i = 0; i < log_options_count; i++)
856 {
ac881e27
TF
857 unsigned int bitnum = log_options[i].bit;
858 if (bitnum < BITWORDSIZE && selector == BIT(bitnum))
d12746bc 859 g = string_fmt_append(g, " %s", log_options[i].name);
059ec3d9
PH
860 }
861
d12746bc 862 g = string_fmt_append(g, "%s%s%s%s\n ",
30f962e0
JH
863 flags & LOG_MAIN ? " MAIN" : "",
864 flags & LOG_PANIC ? " PANIC" : "",
865 (flags & LOG_PANIC_DIE) == LOG_PANIC_DIE ? " DIE" : "",
866 flags & LOG_REJECT ? " REJECT" : "");
059ec3d9 867
d12746bc 868 if (flags & LOG_CONFIG) g = log_config_info(g, flags);
059ec3d9
PH
869
870 va_start(ap, format);
d12746bc
JH
871 i = g->ptr;
872 if (!string_vformat(g, FALSE, format, ap))
873 {
874 g->ptr = i;
875 g = string_cat(g, US"**** log string overflowed log buffer ****");
876 }
059ec3d9
PH
877 va_end(ap);
878
d12746bc
JH
879 g->size = LOG_BUFFER_SIZE;
880 g = string_catn(g, US"\n", 1);
881 debug_printf("%s", string_from_gstring(g));
059ec3d9 882
d12746bc
JH
883 gs.size = LOG_BUFFER_SIZE-1; /* Having used the buffer for debug output, */
884 gs.ptr = 0; /* reset it for the real use. */
885 gs.s = log_buffer;
886 }
059ec3d9
PH
887/* If no log file is specified, we are in a mess. */
888
30f962e0 889if (!(flags & (LOG_MAIN|LOG_PANIC|LOG_REJECT)))
059ec3d9
PH
890 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_write called with no log "
891 "flags set");
892
893/* There are some weird circumstances in which logging is disabled. */
894
8768d548 895if (f.disable_logging)
059ec3d9
PH
896 {
897 DEBUG(D_any) debug_printf("log writing disabled\n");
898 return;
899 }
900
a7d7aa58
PH
901/* Handle disabled reject log */
902
903if (!write_rejectlog) flags &= ~LOG_REJECT;
904
921b12ca
TF
905/* Create the main message in the log buffer. Do not include the message id
906when called by a utility. */
059ec3d9 907
d12746bc 908g = string_fmt_append(&gs, "%s ", tod_stamp(tod_log));
f3f065bb 909
6c6d6e48 910if (LOGGING(pid))
f3f065bb 911 {
d12746bc
JH
912 if (!syslog_pid) pid_position[0] = g->ptr; /* remember begin … */
913 g = string_fmt_append(g, "[%d] ", (int)getpid());
914 if (!syslog_pid) pid_position[1] = g->ptr; /* … and end+1 of the PID */
f3f065bb
PH
915 }
916
8768d548 917if (f.really_exim && message_id[0] != 0)
d12746bc 918 g = string_fmt_append(g, "%s ", message_id);
059ec3d9 919
d12746bc
JH
920if (flags & LOG_CONFIG)
921 g = log_config_info(g, flags);
059ec3d9
PH
922
923va_start(ap, format);
d12746bc
JH
924 {
925 int i = g->ptr;
926 if (!string_vformat(g, FALSE, format, ap))
927 {
928 g->ptr = i;
929 g = string_cat(g, US"**** log string overflowed log buffer ****\n");
930 }
931 }
059ec3d9
PH
932va_end(ap);
933
934/* Add the raw, unrewritten, sender to the message if required. This is done
935this way because it kind of fits with LOG_RECIPIENTS. */
936
30f962e0 937if ( flags & LOG_SENDER
d12746bc
JH
938 && g->ptr < LOG_BUFFER_SIZE - 10 - Ustrlen(raw_sender))
939 g = string_fmt_append(g, " from <%s>", raw_sender);
059ec3d9
PH
940
941/* Add list of recipients to the message if required; the raw list,
942before rewriting, was saved in raw_recipients. There may be none, if an ACL
943discarded them all. */
944
30f962e0 945if ( flags & LOG_RECIPIENTS
d12746bc 946 && g->ptr < LOG_BUFFER_SIZE - 6
30f962e0 947 && raw_recipients_count > 0)
059ec3d9
PH
948 {
949 int i;
d12746bc 950 g = string_fmt_append(g, " for");
059ec3d9
PH
951 for (i = 0; i < raw_recipients_count; i++)
952 {
571b2715 953 uschar * s = raw_recipients[i];
d12746bc
JH
954 if (LOG_BUFFER_SIZE - g->ptr < Ustrlen(s) + 3) break;
955 g = string_fmt_append(g, " %s", s);
059ec3d9
PH
956 }
957 }
958
d12746bc
JH
959g = string_catn(g, US"\n", 1);
960string_from_gstring(g);
059ec3d9
PH
961
962/* Handle loggable errors when running a utility, or when address testing.
963Write to log_stderr unless debugging (when it will already have been written),
964or unless there is no log_stderr (expn called from daemon, for example). */
965
8768d548 966if (!f.really_exim || f.log_testing_mode)
059ec3d9 967 {
30f962e0
JH
968 if ( !debug_selector
969 && log_stderr
970 && (selector == 0 || (selector & log_selector[0]) != 0)
971 )
059ec3d9
PH
972 if (host_checking)
973 fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20)); /* no timestamp */
974 else
975 fprintf(log_stderr, "%s", CS log_buffer);
30f962e0 976
9bfb7e1b 977 if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE, US"");
059ec3d9
PH
978 return;
979 }
980
981/* Handle the main log. We know that either syslog or file logging (or both) is
982set up. A real file gets left open during reception or delivery once it has
983been opened, but we don't want to keep on writing to it for too long after it
984has been renamed. Therefore, do a stat() and see if the inode has changed, and
985if so, re-open. */
986
3cc3f762
JH
987if ( flags & LOG_MAIN
988 && (!selector || selector & log_selector[0]))
059ec3d9 989 {
3cc3f762
JH
990 if ( logging_mode & LOG_MODE_SYSLOG
991 && (syslog_duplication || !(flags & (LOG_REJECT|LOG_PANIC))))
059ec3d9
PH
992 write_syslog(LOG_INFO, log_buffer);
993
3cc3f762 994 if (logging_mode & LOG_MODE_FILE)
059ec3d9
PH
995 {
996 struct stat statbuf;
997
998 /* Check for a change to the mainlog file name when datestamping is in
999 operation. This happens at midnight, at which point we want to roll over
1000 the file. Closing it has the desired effect. */
1001
cd2e3fd0 1002 if (mainlog_datestamp)
059ec3d9 1003 {
f1e5fef5 1004 uschar *nowstamp = tod_stamp(string_datestamp_type);
059ec3d9
PH
1005 if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
1006 {
f1e894f3 1007 (void)close(mainlogfd); /* Close the file */
059ec3d9
PH
1008 mainlogfd = -1; /* Clear the file descriptor */
1009 mainlog_inode = 0; /* Unset the inode */
1010 mainlog_datestamp = NULL; /* Clear the datestamp */
1011 }
1012 }
1013
1014 /* Otherwise, we want to check whether the file has been renamed by a
1015 cycling script. This could be "if else", but for safety's sake, leave it as
1016 "if" so that renaming the log starts a new file even when datestamping is
1017 happening. */
1018
1019 if (mainlogfd >= 0)
059ec3d9 1020 if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
9cd319d9 1021 mainlog_close();
059ec3d9
PH
1022
1023 /* If the log is closed, open it. Then write the line. */
1024
1025 if (mainlogfd < 0)
1026 {
ed7f7860 1027 open_log(&mainlogfd, lt_main, NULL); /* No return on error */
059ec3d9
PH
1028 if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
1029 }
1030
1031 /* Failing to write to the log is disastrous */
1032
d12746bc
JH
1033 written_len = write_to_fd_buf(mainlogfd, g->s, g->ptr);
1034 if (written_len != g->ptr)
059ec3d9 1035 {
d12746bc 1036 log_write_failed(US"main log", g->ptr, written_len);
059ec3d9
PH
1037 /* That function does not return */
1038 }
1039 }
1040 }
1041
a7d7aa58
PH
1042/* Handle the log for rejected messages. This can be globally disabled, in
1043which case the flags are altered above. If there are any header lines (i.e. if
1044the rejection is happening after the DATA phase), log the recipients and the
1045headers. */
059ec3d9 1046
30f962e0 1047if (flags & LOG_REJECT)
059ec3d9
PH
1048 {
1049 header_line *h;
1050
30f962e0 1051 if (header_list && LOGGING(rejected_header))
059ec3d9 1052 {
d12746bc
JH
1053 uschar * p = g->s + g->ptr;
1054 int i;
1055
059ec3d9
PH
1056 if (recipients_count > 0)
1057 {
059ec3d9
PH
1058 /* List the sender */
1059
d12746bc 1060 string_format(p, LOG_BUFFER_SIZE - g->ptr,
059ec3d9 1061 "Envelope-from: <%s>\n", sender_address);
d12746bc
JH
1062 while (*p) p++;
1063 g->ptr = p - g->s;
059ec3d9
PH
1064
1065 /* List up to 5 recipients */
1066
d12746bc 1067 string_format(p, LOG_BUFFER_SIZE - g->ptr,
059ec3d9 1068 "Envelope-to: <%s>\n", recipients_list[0].address);
d12746bc
JH
1069 while (*p) p++;
1070 g->ptr = p - g->s;
059ec3d9
PH
1071
1072 for (i = 1; i < recipients_count && i < 5; i++)
1073 {
d12746bc 1074 string_format(p, LOG_BUFFER_SIZE - g->ptr, " <%s>\n",
059ec3d9 1075 recipients_list[i].address);
d12746bc
JH
1076 while (*p) p++;
1077 g->ptr = p - g->s;
059ec3d9
PH
1078 }
1079
1080 if (i < recipients_count)
1081 {
d12746bc 1082 string_format(p, LOG_BUFFER_SIZE - g->ptr,
059ec3d9 1083 " ...\n");
d12746bc
JH
1084 while (*p) p++;
1085 g->ptr = p - g->s;
059ec3d9
PH
1086 }
1087 }
1088
1089 /* A header with a NULL text is an unfilled in Received: header */
1090
571b2715 1091 for (h = header_list; h; h = h->next) if (h->text)
059ec3d9 1092 {
d12746bc 1093 BOOL fitted = string_format(p, LOG_BUFFER_SIZE - g->ptr,
059ec3d9 1094 "%c %s", h->type, h->text);
d12746bc
JH
1095 while (*p) p++;
1096 g->ptr = p - g->s;
059ec3d9
PH
1097 if (!fitted) /* Buffer is full; truncate */
1098 {
d12746bc
JH
1099 g->ptr -= 100; /* For message and separator */
1100 if (g->s[g->ptr-1] == '\n') g->ptr--;
1101 g = string_cat(g, US"\n*** truncated ***\n");
059ec3d9
PH
1102 break;
1103 }
1104 }
059ec3d9
PH
1105 }
1106
1107 /* Write to syslog or to a log file */
1108
30f962e0
JH
1109 if ( logging_mode & LOG_MODE_SYSLOG
1110 && (syslog_duplication || !(flags & LOG_PANIC)))
d12746bc 1111 write_syslog(LOG_NOTICE, string_from_gstring(g));
059ec3d9
PH
1112
1113 /* Check for a change to the rejectlog file name when datestamping is in
1114 operation. This happens at midnight, at which point we want to roll over
1115 the file. Closing it has the desired effect. */
1116
30f962e0 1117 if (logging_mode & LOG_MODE_FILE)
059ec3d9
PH
1118 {
1119 struct stat statbuf;
1120
571b2715 1121 if (rejectlog_datestamp)
059ec3d9 1122 {
f1e5fef5 1123 uschar *nowstamp = tod_stamp(string_datestamp_type);
059ec3d9
PH
1124 if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
1125 {
f1e894f3 1126 (void)close(rejectlogfd); /* Close the file */
059ec3d9
PH
1127 rejectlogfd = -1; /* Clear the file descriptor */
1128 rejectlog_inode = 0; /* Unset the inode */
1129 rejectlog_datestamp = NULL; /* Clear the datestamp */
1130 }
1131 }
1132
1133 /* Otherwise, we want to check whether the file has been renamed by a
1134 cycling script. This could be "if else", but for safety's sake, leave it as
1135 "if" so that renaming the log starts a new file even when datestamping is
1136 happening. */
1137
1138 if (rejectlogfd >= 0)
059ec3d9
PH
1139 if (Ustat(rejectlog_name, &statbuf) < 0 ||
1140 statbuf.st_ino != rejectlog_inode)
1141 {
f1e894f3 1142 (void)close(rejectlogfd);
059ec3d9
PH
1143 rejectlogfd = -1;
1144 rejectlog_inode = 0;
1145 }
059ec3d9
PH
1146
1147 /* Open the file if necessary, and write the data */
1148
1149 if (rejectlogfd < 0)
1150 {
ed7f7860 1151 open_log(&rejectlogfd, lt_reject, NULL); /* No return on error */
059ec3d9
PH
1152 if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
1153 }
1154
d12746bc
JH
1155 written_len = write_to_fd_buf(rejectlogfd, g->s, g->ptr);
1156 if (written_len != g->ptr)
059ec3d9 1157 {
d12746bc 1158 log_write_failed(US"reject log", g->ptr, written_len);
059ec3d9
PH
1159 /* That function does not return */
1160 }
1161 }
1162 }
1163
1164
059ec3d9
PH
1165/* Handle the panic log, which is not kept open like the others. If it fails to
1166open, there will be a recursive call to log_write(). We detect this above and
1167attempt to write to the system log as a last-ditch try at telling somebody. In
47c7a64a 1168all cases except mua_wrapper, try to write to log_stderr. */
059ec3d9 1169
30f962e0 1170if (flags & LOG_PANIC)
059ec3d9 1171 {
30f962e0 1172 if (log_stderr && log_stderr != debug_file && !mua_wrapper)
d12746bc 1173 fprintf(log_stderr, "%s", CS string_from_gstring(g));
059ec3d9 1174
30f962e0 1175 if (logging_mode & LOG_MODE_SYSLOG)
059ec3d9 1176 write_syslog(LOG_ALERT, log_buffer);
059ec3d9
PH
1177
1178 /* If this panic logging was caused by a failure to open the main log,
1179 the original log line is in panic_save_buffer. Make an attempt to write it. */
1180
30f962e0 1181 if (logging_mode & LOG_MODE_FILE)
059ec3d9
PH
1182 {
1183 panic_recurseflag = TRUE;
ed7f7860 1184 open_log(&paniclogfd, lt_panic, NULL); /* Won't return on failure */
059ec3d9
PH
1185 panic_recurseflag = FALSE;
1186
30f962e0 1187 if (panic_save_buffer)
1ac6b2e7
JH
1188 {
1189 int i = write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1190 i = i; /* compiler quietening */
1191 }
059ec3d9 1192
d12746bc
JH
1193 written_len = write_to_fd_buf(paniclogfd, g->s, g->ptr);
1194 if (written_len != g->ptr)
059ec3d9
PH
1195 {
1196 int save_errno = errno;
1197 write_syslog(LOG_CRIT, log_buffer);
1198 sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
d12746bc
JH
1199 "errno=%d (%s)", g->ptr, (int)written_len, save_errno, strerror(save_errno));
1200 write_syslog(LOG_CRIT, string_from_gstring(g));
059ec3d9
PH
1201 flags |= LOG_PANIC_DIE;
1202 }
1203
f1e894f3 1204 (void)close(paniclogfd);
059ec3d9
PH
1205 }
1206
1207 /* Give up if the DIE flag is set */
1208
1209 if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1210 die(NULL, US"Unexpected failure, please try later");
1211 }
1212}
1213
1214
1215
1216/*************************************************
1217* Close any open log files *
1218*************************************************/
1219
1220void
1221log_close_all(void)
1222{
1223if (mainlogfd >= 0)
f1e894f3 1224 { (void)close(mainlogfd); mainlogfd = -1; }
059ec3d9 1225if (rejectlogfd >= 0)
f1e894f3 1226 { (void)close(rejectlogfd); rejectlogfd = -1; }
059ec3d9
PH
1227closelog();
1228syslog_open = FALSE;
1229}
1230
ed7f7860
PP
1231
1232
1233/*************************************************
6c6d6e48
TF
1234* Multi-bit set or clear *
1235*************************************************/
1236
1237/* These functions take a list of bit indexes (terminated by -1) and
1238clear or set the corresponding bits in the selector.
1239
1240Arguments:
1241 selector address of the bit string
1242 selsize number of words in the bit string
1243 bits list of bits to set
1244*/
1245
1246void
1247bits_clear(unsigned int *selector, size_t selsize, int *bits)
1248{
1249for(; *bits != -1; ++bits)
1250 BIT_CLEAR(selector, selsize, *bits);
1251}
1252
1253void
1254bits_set(unsigned int *selector, size_t selsize, int *bits)
1255{
1256for(; *bits != -1; ++bits)
1257 BIT_SET(selector, selsize, *bits);
1258}
1259
1260
1261
1262/*************************************************
ed7f7860
PP
1263* Decode bit settings for log/debug *
1264*************************************************/
1265
1266/* This function decodes a string containing bit settings in the form of +name
1267and/or -name sequences, and sets/unsets bits in a bit string accordingly. It
1268also recognizes a numeric setting of the form =<number>, but this is not
1269intended for user use. It's an easy way for Exim to pass the debug settings
1270when it is re-exec'ed.
1271
6c6d6e48
TF
1272The option table is a list of names and bit indexes. The index -1
1273means "set all bits, except for those listed in notall". The notall
1274list is terminated by -1.
ed7f7860
PP
1275
1276The action taken for bad values varies depending upon why we're here.
1277For log messages, or if the debugging is triggered from config, then we write
1278to the log on the way out. For debug setting triggered from the command-line,
1279we treat it as an unknown option: error message to stderr and die.
1280
1281Arguments:
6c6d6e48
TF
1282 selector address of the bit string
1283 selsize number of words in the bit string
1284 notall list of bits to exclude from "all"
ed7f7860
PP
1285 string the configured string
1286 options the table of option names
1287 count size of table
1288 which "log" or "debug"
1289 flags DEBUG_FROM_CONFIG
1290
1291Returns: nothing on success - bomb out on failure
1292*/
1293
1294void
6c6d6e48
TF
1295decode_bits(unsigned int *selector, size_t selsize, int *notall,
1296 uschar *string, bit_table *options, int count, uschar *which, int flags)
ed7f7860
PP
1297{
1298uschar *errmsg;
1299if (string == NULL) return;
1300
1301if (*string == '=')
1302 {
1303 char *end; /* Not uschar */
6c6d6e48
TF
1304 memset(selector, 0, sizeof(*selector)*selsize);
1305 *selector = strtoul(CS string+1, &end, 0);
ed7f7860
PP
1306 if (*end == 0) return;
1307 errmsg = string_sprintf("malformed numeric %s_selector setting: %s", which,
1308 string);
1309 goto ERROR_RETURN;
1310 }
1311
1312/* Handle symbolic setting */
1313
1314else for(;;)
1315 {
1316 BOOL adding;
1317 uschar *s;
1318 int len;
1319 bit_table *start, *end;
1320
1321 while (isspace(*string)) string++;
1322 if (*string == 0) return;
1323
1324 if (*string != '+' && *string != '-')
1325 {
1326 errmsg = string_sprintf("malformed %s_selector setting: "
1327 "+ or - expected but found \"%s\"", which, string);
1328 goto ERROR_RETURN;
1329 }
1330
1331 adding = *string++ == '+';
1332 s = string;
1333 while (isalnum(*string) || *string == '_') string++;
1334 len = string - s;
1335
1336 start = options;
1337 end = options + count;
1338
1339 while (start < end)
1340 {
1341 bit_table *middle = start + (end - start)/2;
1342 int c = Ustrncmp(s, middle->name, len);
1343 if (c == 0)
1344 {
1345 if (middle->name[len] != 0) c = -1; else
1346 {
1347 unsigned int bit = middle->bit;
ed7f7860 1348
6c6d6e48
TF
1349 if (bit == -1)
1350 {
1351 if (adding)
1352 {
1353 memset(selector, -1, sizeof(*selector)*selsize);
1354 bits_clear(selector, selsize, notall);
1355 }
1356 else
1357 memset(selector, 0, sizeof(*selector)*selsize);
1358 }
1359 else if (adding)
1360 BIT_SET(selector, selsize, bit);
1361 else
1362 BIT_CLEAR(selector, selsize, bit);
1363
ed7f7860
PP
1364 break; /* Out of loop to match selector name */
1365 }
1366 }
1367 if (c < 0) end = middle; else start = middle + 1;
1368 } /* Loop to match selector name */
1369
1370 if (start >= end)
1371 {
1372 errmsg = string_sprintf("unknown %s_selector setting: %c%.*s", which,
1373 adding? '+' : '-', len, s);
1374 goto ERROR_RETURN;
1375 }
1376 } /* Loop for selector names */
1377
1378/* Handle disasters */
1379
1380ERROR_RETURN:
1381if (Ustrcmp(which, "debug") == 0)
1382 {
1383 if (flags & DEBUG_FROM_CONFIG)
1384 {
1385 log_write(0, LOG_CONFIG|LOG_PANIC, "%s", errmsg);
1386 return;
1387 }
1388 fprintf(stderr, "exim: %s\n", errmsg);
1389 exit(EXIT_FAILURE);
1390 }
1391else log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "%s", errmsg);
1392}
1393
1394
1395
1396/*************************************************
1397* Activate a debug logfile (late) *
1398*************************************************/
1399
1400/* Normally, debugging is activated from the command-line; it may be useful
1401within the configuration to activate debugging later, based on certain
1402conditions. If debugging is already in progress, we return early, no action
1403taken (besides debug-logging that we wanted debug-logging).
1404
1405Failures in options are not fatal but will result in paniclog entries for the
1406misconfiguration.
1407
1408The first use of this is in ACL logic, "control = debug/tag=foo/opts=+expand"
1409which can be combined with conditions, etc, to activate extra logging only
9ee44efb 1410for certain sources. The second use is inetd wait mode debug preservation. */
ed7f7860
PP
1411
1412void
1413debug_logging_activate(uschar *tag_name, uschar *opts)
1414{
1415int fd = -1;
1416
1417if (debug_file)
1418 {
1419 debug_printf("DEBUGGING ACTIVATED FROM WITHIN CONFIG.\n"
b0d68adc 1420 "DEBUG: Tag=\"%s\" opts=\"%s\"\n", tag_name, opts ? opts : US"");
ed7f7860
PP
1421 return;
1422 }
1423
1424if (tag_name != NULL && (Ustrchr(tag_name, '/') != NULL))
1425 {
1426 log_write(0, LOG_MAIN|LOG_PANIC, "debug tag may not contain a '/' in: %s",
1427 tag_name);
1428 return;
1429 }
1430
1431debug_selector = D_default;
1432if (opts)
6c6d6e48 1433 decode_bits(&debug_selector, 1, debug_notall, opts,
ed7f7860 1434 debug_options, debug_options_count, US"debug", DEBUG_FROM_CONFIG);
ed7f7860 1435
e4a6fb35
JH
1436/* When activating from a transport process we may never have logged at all
1437resulting in certain setup not having been done. Hack this for now so we
1438do not segfault; note that nondefault log locations will not work */
1439
1440if (!*file_path) set_file_path();
1441
ed7f7860
PP
1442open_log(&fd, lt_debug, tag_name);
1443
1444if (fd != -1)
1445 debug_file = fdopen(fd, "w");
1446else
1447 log_write(0, LOG_MAIN|LOG_PANIC, "unable to open debug log");
1448}
1449
1450
b0d68adc
JH
1451void
1452debug_logging_stop(void)
1453{
1454if (!debug_file || !debuglog_name[0]) return;
1455
1456debug_selector = 0;
1457fclose(debug_file);
1458debug_file = NULL;
1459unlink_log(lt_debug);
1460}
1461
1462
059ec3d9 1463/* End of log.c */