1 /* $Cambridge: exim/src/src/log.c,v 1.9 2006/02/13 11:28:56 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2006 */
8 /* See the file NOTICE for conditions of use and distribution. */
10 /* Functions for writing log files. The code for maintaining datestamped
11 log files was originally contributed by Tony Sheen. */
16 #define LOG_NAME_SIZE 256
17 #define MAX_SYSLOG_LEN 870
19 #define LOG_MODE_FILE 1
20 #define LOG_MODE_SYSLOG 2
22 enum { lt_main, lt_reject, lt_panic, lt_process };
24 static uschar *log_names[] = { US"main", US"reject", US"panic", US"process" };
28 /*************************************************
29 * Local static variables *
30 *************************************************/
32 static uschar mainlog_name[LOG_NAME_SIZE];
33 static uschar rejectlog_name[LOG_NAME_SIZE];
35 static uschar *mainlog_datestamp = NULL;
36 static uschar *rejectlog_datestamp = NULL;
38 static int mainlogfd = -1;
39 static int rejectlogfd = -1;
40 static ino_t mainlog_inode = 0;
41 static ino_t rejectlog_inode = 0;
43 static uschar *panic_save_buffer = NULL;
44 static BOOL panic_recurseflag = FALSE;
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"";
54 /*************************************************
56 *************************************************/
58 /* The given string is split into sections according to length, or at embedded
59 newlines, and syslogged as a numbered sequence if it is overlong or if there is
60 more than one line. However, if we are running in the test harness, do not do
61 anything. (The test harness doesn't use syslog - for obvious reasons - but we
62 can get here if there is a failure to open the panic log.)
65 priority syslog priority
66 s the string to be written
72 write_syslog(int priority, uschar *s)
77 if (running_in_test_harness) return;
79 if (!syslog_timestamp) s += log_timezone? 26 : 20;
87 openlog(CS syslog_processname, LOG_PID|LOG_CONS, syslog_facility);
89 openlog(CS syslog_processname, LOG_CONS, syslog_facility);
95 /* First do a scan through the message in order to determine how many lines
96 it is going to end up as. Then rescan to output it. */
98 for (pass = 0; pass < 2; pass++)
103 for (i = 1, tlen = len; tlen > 0; i++)
106 uschar *nlptr = Ustrchr(ss, '\n');
107 if (nlptr != NULL) plen = nlptr - ss;
108 #ifndef SYSLOG_LONG_LINES
109 if (plen > MAX_SYSLOG_LEN) plen = MAX_SYSLOG_LEN;
112 if (ss[plen] == '\n') tlen--; /* chars left */
114 if (pass == 0) linecount++; else
117 syslog(priority, "%.*s", plen, ss);
119 syslog(priority, "[%d%c%d] %.*s", i,
120 (ss[plen] == '\n' && tlen != 0)? '\\' : '/',
121 linecount, plen, ss);
124 if (*ss == '\n') ss++;
131 /*************************************************
133 *************************************************/
135 /* This is called when Exim is dying as a result of something going wrong in
136 the logging, or after a log call with LOG_PANIC_DIE set. Optionally write a
137 message to debug_file or a stderr file, if they exist. Then, if in the middle
138 of accepting a message, throw it away tidily; this will attempt to send an SMTP
139 response if appropriate. Otherwise, try to close down an outstanding SMTP call
143 s1 Error message to write to debug_file and/or stderr and syslog
144 s2 Error message for any SMTP call that is in progress
145 Returns: The function does not return
149 die(uschar *s1, uschar *s2)
153 write_syslog(LOG_CRIT, s1);
154 if (debug_file != NULL) debug_printf("%s\n", s1);
155 if (log_stderr != NULL && log_stderr != debug_file)
156 fprintf(log_stderr, "%s\n", s1);
158 if (receive_call_bombout) receive_bomb_out(s2); /* does not return */
159 if (smtp_input) smtp_closedown(s2);
160 exim_exit(EXIT_FAILURE);
165 /*************************************************
166 * Create a log file *
167 *************************************************/
169 /* This function is called to create and open a log file. It may be called in a
170 subprocess when the original process is root.
175 The file name has been build in a working buffer, so it is permissible to
176 overwrite it temporarily if it is necessary to create the directory.
178 Returns: a file descriptor, or < 0 on failure (errno set)
182 create_log(uschar *name)
184 int fd = Uopen(name, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
186 /* If creation failed, attempt to build a log directory in case that is the
189 if (fd < 0 && errno == ENOENT)
192 uschar *lastslash = Ustrrchr(name, '/');
194 created = directory_make(NULL, name, LOG_DIRECTORY_MODE, FALSE);
195 DEBUG(D_any) debug_printf("%s log directory %s\n",
196 created? "created" : "failed to create", name);
198 if (created) fd = Uopen(name, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
207 /*************************************************
209 *************************************************/
211 /* This function opens one of a number of logs, which all (except for the
212 "process log") reside in the same directory, creating the directory if it does
213 not exist. This may be called recursively on failure, in order to open the
216 The directory is in the static variable file_path. This is static so that it
217 the work of sorting out the path is done just once per Exim process.
219 Exim is normally configured to avoid running as root wherever possible, the log
220 files must be owned by the non-privileged exim user. To ensure this, first try
221 an open without O_CREAT - most of the time this will succeed. If it fails, try
222 to create the file; if running as root, this must be done in a subprocess to
226 fd where to return the resulting file descriptor
227 type lt_main, lt_reject, lt_panic, or lt_process
233 open_log(int *fd, int type)
237 uschar buffer[LOG_NAME_SIZE];
239 /* Sort out the file name. This depends on the type of log we are opening. The
240 process "log" is written in the spool directory by default, but a path name can
241 be specified in the configuration. */
243 if (type == lt_process)
245 if (process_log_path == NULL)
246 ok = string_format(buffer, sizeof(buffer), "%s/exim-process.info",
249 ok = string_format(buffer, sizeof(buffer), "%s", process_log_path);
252 /* The names of the other three logs are controlled by file_path. The panic log
253 is written to the same directory as the main and reject logs, but its name does
254 not have a datestamp. The use of datestamps is indicated by %D in file_path.
255 When opening the panic log, if %D is present, we remove the datestamp from the
256 generated name; if it is at the start, remove a following non-alphameric
257 character as well; otherwise, remove a preceding non-alphameric character. This
258 is definitely kludgy, but it sort of does what people want, I hope. */
262 ok = string_format(buffer, sizeof(buffer), CS file_path, log_names[type]);
264 /* Save the name of the mainlog for rollover processing. Without a datestamp,
265 it gets statted to see if it has been cycled. With a datestamp, the datestamp
266 will be compared. The static slot for saving it is the same size as buffer,
267 and the text has been checked above to fit, so this use of strcpy() is OK. */
271 Ustrcpy(mainlog_name, buffer);
272 mainlog_datestamp = mainlog_name + string_datestamp_offset;
275 /* Ditto for the reject log */
277 else if (type == lt_reject)
279 Ustrcpy(rejectlog_name, buffer);
280 rejectlog_datestamp = rejectlog_name + string_datestamp_offset;
283 /* Remove any datestamp if this is the panic log. This is rare, so there's no
284 need to optimize getting the datestamp length. We remove one non-alphanumeric
285 char afterwards if at the start, otherwise one before. */
287 else if (string_datestamp_offset >= 0)
289 uschar *from = buffer + string_datestamp_offset;
290 uschar *to = from + Ustrlen(tod_stamp(tod_log_datestamp));
291 if (from == buffer || from[-1] == '/')
293 if (!isalnum(*to)) to++;
297 if (!isalnum(from[-1])) from--;
300 /* This strcpy is ok, because we know that to is a substring of from. */
306 /* If the file name is too long, it is an unrecoverable disaster */
310 die(US"exim: log file path too long: aborting",
311 US"Logging failure; please try later");
314 /* We now have the file name. Try to open an existing file. After a successful
315 open, arrange for automatic closure on exec(), and then return. */
317 *fd = Uopen(buffer, O_APPEND|O_WRONLY, LOG_MODE);
321 (void)fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
325 /* Open was not successful: try creating the file. If this is a root process,
326 we must do the creating in a subprocess set to exim:exim in order to ensure
327 that the file is created with the right ownership. Otherwise, there can be a
328 race if another Exim process is trying to write to the log at the same time.
329 The use of SIGUSR1 by the exiwhat utility can provoke a lot of simultaneous
334 /* If we are already running as the Exim user (even if that user is root),
335 we can go ahead and create in the current process. */
337 if (euid == exim_uid) *fd = create_log(buffer);
339 /* Otherwise, if we are root, do the creation in an exim:exim subprocess. If we
340 are neither exim nor root, creation is not attempted. */
342 else if (euid == root_uid)
347 /* In the subprocess, change uid/gid and do the creation. Return 0 from the
348 subprocess on success. There doesn't seem much point in testing for setgid
349 and setuid errors. */
353 (void)setgid(exim_gid);
354 (void)setuid(exim_uid);
355 _exit((create_log(buffer) < 0)? 1 : 0);
358 /* If we created a subprocess, wait for it. If it succeeded retry the open. */
362 while (waitpid(pid, &status, 0) != pid);
363 if (status == 0) *fd = Uopen(buffer, O_APPEND|O_WRONLY, LOG_MODE);
366 /* If we failed to create a subprocess, we are in a bad way. We fall through
367 with *fd still < 0, and errno set, letting the code below handle the error. */
370 /* If we now have an open file, set the close-on-exec flag and return. */
374 (void)fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
378 /* Creation failed. There are some circumstances in which we get here when
379 the effective uid is not root or exim, which is the problem. (For example, a
380 non-setuid binary with log_arguments set, called in certain ways.) Rather than
381 just bombing out, force the log to stderr and carry on if stderr is available.
384 if (euid != root_uid && euid != exim_uid && log_stderr != NULL)
386 *fd = fileno(log_stderr);
390 /* Otherwise this is a disaster. This call is deliberately ONLY to the panic
391 log. If possible, save a copy of the original line that was being logged. If we
392 are recursing (can't open the panic log either), the pointer will already be
395 if (panic_save_buffer == NULL)
397 panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
398 if (panic_save_buffer != NULL)
399 memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
402 log_write(0, LOG_PANIC_DIE, "Cannot open %s log file \"%s\": %s: "
403 "euid=%d egid=%d", log_names[type], buffer, strerror(errno), euid, getegid());
409 /*************************************************
410 * Add configuration file info to log line *
411 *************************************************/
413 /* This is put in a function because it's needed twice (once for debugging,
417 ptr pointer to the end of the line we are building
420 Returns: updated pointer
424 log_config_info(uschar *ptr, int flags)
426 Ustrcpy(ptr, "Exim configuration error");
429 if ((flags & (LOG_CONFIG_FOR & ~LOG_CONFIG)) != 0)
431 Ustrcpy(ptr, " for ");
435 if ((flags & (LOG_CONFIG_IN & ~LOG_CONFIG)) != 0)
437 sprintf(CS ptr, " in line %d of %s", config_lineno, config_filename);
441 Ustrcpy(ptr, ":\n ");
446 /*************************************************
447 * A write() operation failed *
448 *************************************************/
450 /* This function is called when write() fails on anything other than the panic
451 log, which can happen if a disk gets full or a file gets too large or whatever.
452 We try to save the relevant message in the panic_save buffer before crashing
456 name the name of the log being written
457 length the string length being written
458 rc the return value from write()
460 Returns: does not return
464 log_write_failed(uschar *name, int length, int rc)
466 int save_errno = errno;
468 if (panic_save_buffer == NULL)
470 panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
471 if (panic_save_buffer != NULL)
472 memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
475 log_write(0, LOG_PANIC_DIE, "failed to write to %s: length=%d result=%d "
476 "errno=%d (%s)", name, length, rc, save_errno,
477 (save_errno == 0)? "write incomplete" : strerror(save_errno));
483 /*************************************************
484 * Write message to log file *
485 *************************************************/
487 /* Exim can be configured to log to local files, or use syslog, or both. This
488 is controlled by the setting of log_file_path. The following cases are
491 log_file_path = "" write files in the spool/log directory
492 log_file_path = "xxx" write files in the xxx directory
493 log_file_path = "syslog" write to syslog
494 log_file_path = "syslog : xxx" write to syslog and to files (any order)
496 The one exception to this is messages containing LOG_PROCESS. These are always
497 written to exim-process.info in the spool directory. They aren't really log
498 messages in the same sense as the others.
500 The message always gets '\n' added on the end of it, since more than one
501 process may be writing to the log at once and we don't want intermingling to
502 happen in the middle of lines. To be absolutely sure of this we write the data
503 into a private buffer and then put it out in a single write() call.
505 The flags determine which log(s) the message is written to, or for syslogging,
506 which priority to use, and in the case of the panic log, whether the process
507 should die afterwards.
509 The variable really_exim is TRUE only when exim is running in privileged state
510 (i.e. not with a changed configuration or with testing options such as -brw).
511 If it is not, don't try to write to the log because permission will probably be
514 Avoid actually writing to the logs when exim is called with -bv or -bt to
515 test an address, but take other actions, such as panicing.
517 In Exim proper, the buffer for building the message is got at start-up, so that
518 nothing gets done if it can't be got. However, some functions that are also
519 used in utilities occasionally obey log_write calls in error situations, and it
520 is simplest to put a single malloc() here rather than put one in each utility.
521 Malloc is used directly because the store functions may call log_write().
523 If a message_id exists, we include it after the timestamp.
526 selector write to main log or LOG_INFO only if this value is zero, or if
527 its bit is set in log_write_selector
528 flags each bit indicates some independent action:
529 LOG_SENDER add raw sender to the message
530 LOG_RECIPIENTS add raw recipients list to message
531 LOG_CONFIG add "Exim configuration error"
532 LOG_CONFIG_FOR add " for " instead of ":\n "
533 LOG_CONFIG_IN add " in line x[ of file y]"
534 LOG_MAIN write to main log or syslog LOG_INFO
535 LOG_REJECT write to reject log or syslog LOG_NOTICE
536 LOG_PANIC write to panic log or syslog LOG_ALERT
537 LOG_PANIC_DIE write to panic log or LOG_ALERT and then crash
538 LOG_PROCESS write to process log (always a file)
539 format a printf() format
540 ... arguments for format
546 log_write(unsigned int selector, int flags, char *format, ...)
553 /* If panic_recurseflag is set, we have failed to open the panic log. This is
554 the ultimate disaster. First try to write the message to a debug file and/or
555 stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
556 original log line that caused the problem. Afterwards, expire. */
558 if (panic_recurseflag)
560 uschar *extra = (panic_save_buffer == NULL)? US"" : panic_save_buffer;
561 if (debug_file != NULL) debug_printf("%s%s", extra, log_buffer);
562 if (log_stderr != NULL && log_stderr != debug_file)
563 fprintf(log_stderr, "%s%s", extra, log_buffer);
564 if (*extra != 0) write_syslog(LOG_CRIT, extra);
565 write_syslog(LOG_CRIT, log_buffer);
566 die(US"exim: could not open panic log - aborting: see message(s) above",
567 US"Unexpected log failure, please try later");
570 /* Ensure we have a buffer (see comment above); this should never be obeyed
571 when running Exim proper, only when running utilities. */
573 if (log_buffer == NULL)
575 log_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
576 if (log_buffer == NULL)
578 fprintf(stderr, "exim: failed to get store for log buffer\n");
579 exim_exit(EXIT_FAILURE);
583 /* If we haven't already done so, inspect the setting of log_file_path to
584 determine whether to log to files and/or to syslog. Bits in logging_mode
585 control this, and for file logging, the path must end up in file_path. This
586 variable must be in permanent store because it may be required again later in
591 BOOL multiple = FALSE;
592 int old_pool = store_pool;
594 store_pool = POOL_PERM;
596 /* If nothing has been set, don't waste effort... the default values for the
597 statics are file_path="" and logging_mode = LOG_MODE_FILE. */
599 if (log_file_path[0] != 0)
601 int sep = ':'; /* Fixed separator - outside use */
603 uschar *ss = log_file_path;
605 while ((s = string_nextinlist(&ss,&sep,log_buffer,LOG_BUFFER_SIZE)) != NULL)
607 if (Ustrcmp(s, "syslog") == 0)
608 logging_mode |= LOG_MODE_SYSLOG;
609 else if ((logging_mode & LOG_MODE_FILE) != 0) multiple = TRUE;
612 logging_mode |= LOG_MODE_FILE;
614 /* If a non-empty path is given, use it */
618 file_path = string_copy(s);
621 /* If the path is empty, we want to use the first non-empty, non-
622 syslog item in LOG_FILE_PATH, if there is one, since the value of
623 log_file_path may have been set at runtime. If there is no such item,
624 use the ultimate default in the spool directory. */
629 uschar *tt = US LOG_FILE_PATH;
630 while ((t = string_nextinlist(&tt,&sep,log_buffer,LOG_BUFFER_SIZE))
633 if (Ustrcmp(t, "syslog") == 0 || t[0] == 0) continue;
634 file_path = string_copy(t);
637 } /* Empty item in log_file_path */
638 } /* First non-syslog item in log_file_path */
639 } /* Scan of log_file_path */
642 /* If no modes have been selected, it is a major disaster */
644 if (logging_mode == 0)
645 die(US"Neither syslog nor file logging set in log_file_path",
646 US"Unexpected logging failure");
648 /* Set up the ultimate default if necessary. Then revert to the old store
649 pool, and record that we've sorted out the path. */
651 if ((logging_mode & LOG_MODE_FILE) != 0 && file_path[0] == 0)
652 file_path = string_sprintf("%s/log/%%slog", spool_directory);
653 store_pool = old_pool;
654 path_inspected = TRUE;
656 /* If more than one file path was given, log a complaint. This recursive call
657 should work since we have now set up the routing. */
661 log_write(0, LOG_MAIN|LOG_PANIC,
662 "More than one path given in log_file_path: using %s", file_path);
666 /* If debugging, show all log entries, but don't show headers. Do it all
667 in one go so that it doesn't get split when multi-processing. */
674 Ustrcpy(ptr, "LOG:");
677 /* Show the options that were passed into the call. These are those whose
678 flag values do not have the 0x80000000 bit in them. Note that this
679 automatically exclude the "all" setting. */
681 for (i = 0; i < log_options_count; i++)
683 unsigned int bit = log_options[i].bit;
684 if ((bit & 0x80000000) != 0) continue;
685 if ((selector & bit) != 0)
688 Ustrcpy(ptr, log_options[i].name);
693 sprintf(CS ptr, "%s%s%s%s%s\n ",
694 ((flags & LOG_MAIN) != 0)? " MAIN" : "",
695 ((flags & LOG_PANIC) != 0)? " PANIC" : "",
696 ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE)? " DIE" : "",
697 ((flags & LOG_PROCESS) != 0)? " PROCESS": "",
698 ((flags & LOG_REJECT) != 0)? " REJECT" : "");
701 if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
703 va_start(ap, format);
704 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
705 Ustrcpy(ptr, "**** log string overflowed log buffer ****");
710 debug_printf("%s", log_buffer);
713 /* If no log file is specified, we are in a mess. */
715 if ((flags & (LOG_MAIN|LOG_PANIC|LOG_REJECT|LOG_PROCESS)) == 0)
716 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_write called with no log "
719 /* There are some weird circumstances in which logging is disabled. */
723 DEBUG(D_any) debug_printf("log writing disabled\n");
727 /* Create the main message in the log buffer, including the message
728 id except for the process log and when called by a utility. */
731 if (really_exim && (flags & LOG_PROCESS) == 0 && message_id[0] != 0)
732 sprintf(CS ptr, "%s %s ", tod_stamp(tod_log), message_id);
733 else sprintf(CS ptr, "%s ", tod_stamp(tod_log));
736 if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
738 va_start(ap, format);
739 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
740 Ustrcpy(ptr, "**** log string overflowed log buffer ****\n");
744 /* Add the raw, unrewritten, sender to the message if required. This is done
745 this way because it kind of fits with LOG_RECIPIENTS. */
747 if ((flags & LOG_SENDER) != 0 &&
748 ptr < log_buffer + LOG_BUFFER_SIZE - 10 - Ustrlen(raw_sender))
750 sprintf(CS ptr, " from <%s>", raw_sender);
754 /* Add list of recipients to the message if required; the raw list,
755 before rewriting, was saved in raw_recipients. There may be none, if an ACL
756 discarded them all. */
758 if ((flags & LOG_RECIPIENTS) != 0 && ptr < log_buffer + LOG_BUFFER_SIZE - 6 &&
759 raw_recipients_count > 0)
762 sprintf(CS ptr, " for");
764 for (i = 0; i < raw_recipients_count; i++)
766 uschar *s = raw_recipients[i];
767 if (log_buffer + LOG_BUFFER_SIZE - ptr < Ustrlen(s) + 3) break;
768 sprintf(CS ptr, " %s", s);
773 sprintf(CS ptr, "\n");
775 length = ptr - log_buffer;
777 /* Handle loggable errors when running a utility, or when address testing.
778 Write to log_stderr unless debugging (when it will already have been written),
779 or unless there is no log_stderr (expn called from daemon, for example). */
781 if (!really_exim || log_testing_mode)
783 if (debug_selector == 0 && log_stderr != NULL &&
784 (selector == 0 || (selector & log_write_selector) != 0))
787 fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20)); /* no timestamp */
789 fprintf(log_stderr, "%s", CS log_buffer);
791 if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE);
795 /* Handle the main log. We know that either syslog or file logging (or both) is
796 set up. A real file gets left open during reception or delivery once it has
797 been opened, but we don't want to keep on writing to it for too long after it
798 has been renamed. Therefore, do a stat() and see if the inode has changed, and
801 if ((flags & LOG_MAIN) != 0 &&
802 (selector == 0 || (selector & log_write_selector) != 0))
804 if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
805 (syslog_duplication || (flags & (LOG_REJECT|LOG_PANIC)) == 0))
806 write_syslog(LOG_INFO, log_buffer);
808 if ((logging_mode & LOG_MODE_FILE) != 0)
812 /* Check for a change to the mainlog file name when datestamping is in
813 operation. This happens at midnight, at which point we want to roll over
814 the file. Closing it has the desired effect. */
816 if (mainlog_datestamp != NULL)
818 uschar *nowstamp = tod_stamp(tod_log_datestamp);
819 if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
821 (void)close(mainlogfd); /* Close the file */
822 mainlogfd = -1; /* Clear the file descriptor */
823 mainlog_inode = 0; /* Unset the inode */
824 mainlog_datestamp = NULL; /* Clear the datestamp */
828 /* Otherwise, we want to check whether the file has been renamed by a
829 cycling script. This could be "if else", but for safety's sake, leave it as
830 "if" so that renaming the log starts a new file even when datestamping is
835 if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
837 (void)close(mainlogfd);
843 /* If the log is closed, open it. Then write the line. */
847 open_log(&mainlogfd, lt_main); /* No return on error */
848 if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
851 /* Failing to write to the log is disastrous */
853 if ((rc = write(mainlogfd, log_buffer, length)) != length)
855 log_write_failed(US"main log", length, rc);
856 /* That function does not return */
861 /* Handle the log for rejected messages. This can be globally disabled. If
862 there are any header lines (i.e. if the rejection is happening after the DATA
863 phase), log the recipients and the headers. */
865 if (write_rejectlog && (flags & LOG_REJECT) != 0)
869 if (header_list != NULL && (log_extra_selector & LX_rejected_header) != 0)
871 if (recipients_count > 0)
875 /* List the sender */
877 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
878 "Envelope-from: <%s>\n", sender_address);
881 /* List up to 5 recipients */
883 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
884 "Envelope-to: <%s>\n", recipients_list[0].address);
887 for (i = 1; i < recipients_count && i < 5; i++)
889 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer), " <%s>\n",
890 recipients_list[i].address);
894 if (i < recipients_count)
896 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
902 /* A header with a NULL text is an unfilled in Received: header */
904 for (h = header_list; h != NULL; h = h->next)
907 if (h->text == NULL) continue;
908 fitted = string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
909 "%c %s", h->type, h->text);
911 if (!fitted) /* Buffer is full; truncate */
913 ptr -= 100; /* For message and separator */
914 if (ptr[-1] == '\n') ptr--;
915 Ustrcpy(ptr, "\n*** truncated ***\n");
921 length = ptr - log_buffer;
924 /* Write to syslog or to a log file */
926 if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
927 (syslog_duplication || (flags & LOG_PANIC) == 0))
928 write_syslog(LOG_NOTICE, log_buffer);
930 /* Check for a change to the rejectlog file name when datestamping is in
931 operation. This happens at midnight, at which point we want to roll over
932 the file. Closing it has the desired effect. */
934 if ((logging_mode & LOG_MODE_FILE) != 0)
938 if (rejectlog_datestamp != NULL)
940 uschar *nowstamp = tod_stamp(tod_log_datestamp);
941 if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
943 (void)close(rejectlogfd); /* Close the file */
944 rejectlogfd = -1; /* Clear the file descriptor */
945 rejectlog_inode = 0; /* Unset the inode */
946 rejectlog_datestamp = NULL; /* Clear the datestamp */
950 /* Otherwise, we want to check whether the file has been renamed by a
951 cycling script. This could be "if else", but for safety's sake, leave it as
952 "if" so that renaming the log starts a new file even when datestamping is
955 if (rejectlogfd >= 0)
957 if (Ustat(rejectlog_name, &statbuf) < 0 ||
958 statbuf.st_ino != rejectlog_inode)
960 (void)close(rejectlogfd);
966 /* Open the file if necessary, and write the data */
970 open_log(&rejectlogfd, lt_reject); /* No return on error */
971 if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
974 if ((rc = write(rejectlogfd, log_buffer, length)) != length)
976 log_write_failed(US"reject log", length, rc);
977 /* That function does not return */
983 /* Handle the process log file, where exim processes can be made to dump
984 details of what they are doing by sending them a USR1 signal. Note that
985 a message id is not automatically added above. This information is always
986 written to a file - never to syslog. */
988 if ((flags & LOG_PROCESS) != 0)
991 open_log(&processlogfd, lt_process); /* No return on error */
992 if ((rc = write(processlogfd, log_buffer, length)) != length)
994 log_write_failed(US"process log", length, rc);
995 /* That function does not return */
997 (void)close(processlogfd);
1001 /* Handle the panic log, which is not kept open like the others. If it fails to
1002 open, there will be a recursive call to log_write(). We detect this above and
1003 attempt to write to the system log as a last-ditch try at telling somebody. In
1004 all cases except mua_wrapper, try to write to log_stderr. */
1006 if ((flags & LOG_PANIC) != 0)
1008 if (log_stderr != NULL && log_stderr != debug_file && !mua_wrapper)
1009 fprintf(log_stderr, "%s", CS log_buffer);
1011 if ((logging_mode & LOG_MODE_SYSLOG) != 0)
1013 write_syslog(LOG_ALERT, log_buffer);
1016 /* If this panic logging was caused by a failure to open the main log,
1017 the original log line is in panic_save_buffer. Make an attempt to write it. */
1019 if ((logging_mode & LOG_MODE_FILE) != 0)
1021 panic_recurseflag = TRUE;
1022 open_log(&paniclogfd, lt_panic); /* Won't return on failure */
1023 panic_recurseflag = FALSE;
1025 if (panic_save_buffer != NULL)
1026 (void) write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1028 if ((rc = write(paniclogfd, log_buffer, length)) != length)
1030 int save_errno = errno;
1031 write_syslog(LOG_CRIT, log_buffer);
1032 sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
1033 "errno=%d (%s)", length, rc, save_errno, strerror(save_errno));
1034 write_syslog(LOG_CRIT, log_buffer);
1035 flags |= LOG_PANIC_DIE;
1038 (void)close(paniclogfd);
1041 /* Give up if the DIE flag is set */
1043 if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1044 die(NULL, US"Unexpected failure, please try later");
1050 /*************************************************
1051 * Close any open log files *
1052 *************************************************/
1058 { (void)close(mainlogfd); mainlogfd = -1; }
1059 if (rejectlogfd >= 0)
1060 { (void)close(rejectlogfd); rejectlogfd = -1; }
1062 syslog_open = FALSE;