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