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