Test for failure of the fork() when a root process creates a log file.
[exim.git] / src / src / log.c
CommitLineData
901f42cb 1/* $Cambridge: exim/src/src/log.c,v 1.3 2005/03/29 15:19:25 ph10 Exp $ */
059ec3d9
PH
2
3/*************************************************
4* Exim - an Internet mail transport agent *
5*************************************************/
6
c988f1f4 7/* Copyright (c) University of Cambridge 1995 - 2005 */
059ec3d9
PH
8/* See the file NOTICE for conditions of use and distribution. */
9
10/* Functions for writing log files. The code for maintaining datestamped
11log files was originally contributed by Tony Sheen. */
12
13
14#include "exim.h"
15
16#define LOG_NAME_SIZE 256
17#define MAX_SYSLOG_LEN 870
18
19#define LOG_MODE_FILE 1
20#define LOG_MODE_SYSLOG 2
21
22enum { lt_main, lt_reject, lt_panic, lt_process };
23
24static uschar *log_names[] = { US"main", US"reject", US"panic", US"process" };
25
26
27
28/*************************************************
29* Local static variables *
30*************************************************/
31
32static uschar mainlog_name[LOG_NAME_SIZE];
33static uschar rejectlog_name[LOG_NAME_SIZE];
34
35static uschar *mainlog_datestamp = NULL;
36static uschar *rejectlog_datestamp = NULL;
37
38static int mainlogfd = -1;
39static int rejectlogfd = -1;
40static ino_t mainlog_inode = 0;
41static ino_t rejectlog_inode = 0;
42
43static uschar *panic_save_buffer = NULL;
44static BOOL panic_recurseflag = FALSE;
45
46static BOOL syslog_open = FALSE;
47static BOOL path_inspected = FALSE;
48static int logging_mode = LOG_MODE_FILE;
49static uschar *file_path = US"";
50
51
52
53
54/*************************************************
55* Write to syslog *
56*************************************************/
57
58/* The given string is split into sections according to length, or at embedded
59newlines, and syslogged as a numbered sequence if it is overlong or if there is
60more than one line.
61
62Arguments:
63 priority syslog priority
64 s the string to be written
65
66Returns: nothing
67*/
68
69static void
70write_syslog(int priority, uschar *s)
71{
72int len, pass;
73int linecount = 0;
74
75if (!syslog_timestamp) s += log_timezone? 26 : 20;
76
77len = Ustrlen(s);
78
79#ifndef NO_OPENLOG
80if (!syslog_open)
81 {
82 #ifdef SYSLOG_LOG_PID
83 openlog(CS syslog_processname, LOG_PID|LOG_CONS, syslog_facility);
84 #else
85 openlog(CS syslog_processname, LOG_CONS, syslog_facility);
86 #endif
87 syslog_open = TRUE;
88 }
89#endif
90
91/* First do a scan through the message in order to determine how many lines
92it is going to end up as. Then rescan to output it. */
93
94for (pass = 0; pass < 2; pass++)
95 {
96 int i;
97 int tlen;
98 uschar *ss = s;
99 for (i = 1, tlen = len; tlen > 0; i++)
100 {
101 int plen = tlen;
102 uschar *nlptr = Ustrchr(ss, '\n');
103 if (nlptr != NULL) plen = nlptr - ss;
104 #ifndef SYSLOG_LONG_LINES
105 if (plen > MAX_SYSLOG_LEN) plen = MAX_SYSLOG_LEN;
106 #endif
107 tlen -= plen;
108 if (ss[plen] == '\n') tlen--; /* chars left */
109
110 if (pass == 0) linecount++; else
111 {
112 if (linecount == 1)
113 syslog(priority, "%.*s", plen, ss);
114 else
115 syslog(priority, "[%d%c%d] %.*s", i,
116 (ss[plen] == '\n' && tlen != 0)? '\\' : '/',
117 linecount, plen, ss);
118 }
119 ss += plen;
120 if (*ss == '\n') ss++;
121 }
122 }
123}
124
125
126
127/*************************************************
128* Die tidily *
129*************************************************/
130
131/* This is called when Exim is dying as a result of something going wrong in
132the logging, or after a log call with LOG_PANIC_DIE set. Optionally write a
133message to debug_file or a stderr file, if they exist. Then, if in the middle
134of accepting a message, throw it away tidily; this will attempt to send an SMTP
135response if appropriate. Otherwise, try to close down an outstanding SMTP call
136tidily.
137
138Arguments:
139 s1 Error message to write to debug_file and/or stderr and syslog
140 s2 Error message for any SMTP call that is in progress
141Returns: The function does not return
142*/
143
144static void
145die(uschar *s1, uschar *s2)
146{
147if (s1 != NULL)
148 {
149 write_syslog(LOG_CRIT, s1);
150 if (debug_file != NULL) debug_printf("%s\n", s1);
151 if (log_stderr != NULL && log_stderr != debug_file)
152 fprintf(log_stderr, "%s\n", s1);
153 }
154if (receive_call_bombout) receive_bomb_out(s2); /* does not return */
155if (smtp_input) smtp_closedown(s2);
156exim_exit(EXIT_FAILURE);
157}
158
159
160
161/*************************************************
162* Create a log file *
163*************************************************/
164
165/* This function is called to create and open a log file. It may be called in a
166subprocess when the original process is root.
167
168Arguments:
169 name the file name
170
171The file name has been build in a working buffer, so it is permissible to
172overwrite it temporarily if it is necessary to create the directory.
173
174Returns: a file descriptor, or < 0 on failure (errno set)
175*/
176
177static int
178create_log(uschar *name)
179{
180int fd = Uopen(name, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
181
182/* If creation failed, attempt to build a log directory in case that is the
183problem. */
184
185if (fd < 0 && errno == ENOENT)
186 {
187 BOOL created;
188 uschar *lastslash = Ustrrchr(name, '/');
189 *lastslash = 0;
190 created = directory_make(NULL, name, LOG_DIRECTORY_MODE, FALSE);
191 DEBUG(D_any) debug_printf("%s log directory %s\n",
192 created? "created" : "failed to create", name);
193 *lastslash = '/';
194 if (created) fd = Uopen(name, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
195 }
196
197return fd;
198}
199
200
201
202
203/*************************************************
204* Open a log file *
205*************************************************/
206
207/* This function opens one of a number of logs, which all (except for the
208"process log") reside in the same directory, creating the directory if it does
209not exist. This may be called recursively on failure, in order to open the
210panic log.
211
212The directory is in the static variable file_path. This is static so that it
213the work of sorting out the path is done just once per Exim process.
214
215Exim is normally configured to avoid running as root wherever possible, the log
216files must be owned by the non-privileged exim user. To ensure this, first try
217an open without O_CREAT - most of the time this will succeed. If it fails, try
218to create the file; if running as root, this must be done in a subprocess to
219avoid races.
220
221Arguments:
222 fd where to return the resulting file descriptor
223 type lt_main, lt_reject, lt_panic, or lt_process
224
225Returns: nothing
226*/
227
228static void
229open_log(int *fd, int type)
230{
231uid_t euid;
232BOOL ok;
233uschar buffer[LOG_NAME_SIZE];
234
235/* Sort out the file name. This depends on the type of log we are opening. The
236process "log" is written in the spool directory by default, but a path name can
237be specified in the configuration. */
238
239if (type == lt_process)
240 {
241 if (process_log_path == NULL)
242 ok = string_format(buffer, sizeof(buffer), "%s/exim-process.info",
243 spool_directory);
244 else
245 ok = string_format(buffer, sizeof(buffer), "%s", process_log_path);
246 }
247
248/* The names of the other three logs are controlled by file_path. The panic log
249is written to the same directory as the main and reject logs, but its name does
250not have a datestamp. The use of datestamps is indicated by %D in file_path.
251When opening the panic log, if %D is present, we remove the datestamp from the
252generated name; if it is at the start, remove a following non-alphameric
253character as well; otherwise, remove a preceding non-alphameric character. This
254is definitely kludgy, but it sort of does what people want, I hope. */
255
256else
257 {
258 ok = string_format(buffer, sizeof(buffer), CS file_path, log_names[type]);
259
260 /* Save the name of the mainlog for rollover processing. Without a datestamp,
261 it gets statted to see if it has been cycled. With a datestamp, the datestamp
262 will be compared. The static slot for saving it is the same size as buffer,
263 and the text has been checked above to fit, so this use of strcpy() is OK. */
264
265 if (type == lt_main)
266 {
267 Ustrcpy(mainlog_name, buffer);
268 mainlog_datestamp = mainlog_name + string_datestamp_offset;
269 }
270
271 /* Ditto for the reject log */
272
273 else if (type == lt_reject)
274 {
275 Ustrcpy(rejectlog_name, buffer);
276 rejectlog_datestamp = rejectlog_name + string_datestamp_offset;
277 }
278
279 /* Remove any datestamp if this is the panic log. This is rare, so there's no
280 need to optimize getting the datestamp length. We remove one non-alphanumeric
281 char afterwards if at the start, otherwise one before. */
282
283 else if (string_datestamp_offset >= 0)
284 {
285 uschar *from = buffer + string_datestamp_offset;
286 uschar *to = from + Ustrlen(tod_stamp(tod_log_datestamp));
287 if (from == buffer || from[-1] == '/')
288 {
289 if (!isalnum(*to)) to++;
290 }
291 else
292 {
293 if (!isalnum(from[-1])) from--;
294 }
295
296 /* This strcpy is ok, because we know that to is a substring of from. */
297
298 Ustrcpy(from, to);
299 }
300 }
301
302/* If the file name is too long, it is an unrecoverable disaster */
303
304if (!ok)
305 {
306 die(US"exim: log file path too long: aborting",
307 US"Logging failure; please try later");
308 }
309
310/* We now have the file name. Try to open an existing file. After a successful
311open, arrange for automatic closure on exec(), and then return. */
312
313*fd = Uopen(buffer, O_APPEND|O_WRONLY, LOG_MODE);
314
315if (*fd >= 0)
316 {
317 fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
318 return;
319 }
320
321/* Open was not successful: try creating the file. If this is a root process,
322we must do the creating in a subprocess set to exim:exim in order to ensure
323that the file is created with the right ownership. Otherwise, there can be a
901f42cb
PH
324race if another Exim process is trying to write to the log at the same time.
325The use of SIGUSR1 by the exiwhat utility can provoke a lot of simultaneous
326writing. */
059ec3d9
PH
327
328euid = geteuid();
329
330/* If we are already running as the Exim user (even if that user is root),
331we can go ahead and create in the current process. */
332
333if (euid == exim_uid) *fd = create_log(buffer);
334
335/* Otherwise, if we are root, do the creation in an exim:exim subprocess. If we
336are neither exim nor root, creation is not attempted. */
337
338else if (euid == root_uid)
339 {
340 int status;
341 pid_t pid = fork();
342
343 /* In the subprocess, change uid/gid and do the creation. Return 0 from the
344 subprocess on success. There doesn't seem much point in testing for setgid
345 and setuid errors. */
346
347 if (pid == 0)
348 {
349 (void)setgid(exim_gid);
350 (void)setuid(exim_uid);
351 _exit((create_log(buffer) < 0)? 1 : 0);
352 }
353
901f42cb 354 /* If we created a subprocess, wait for it. If it succeeded retry the open. */
059ec3d9 355
901f42cb
PH
356 if (pid > 0)
357 {
358 while (waitpid(pid, &status, 0) != pid);
359 if (status == 0) *fd = Uopen(buffer, O_APPEND|O_WRONLY, LOG_MODE);
360 }
361
362 /* If we failed to create a subprocess, we are in a bad way. We fall through
363 with *fd still < 0, and errno set, letting the code below handle the error. */
059ec3d9
PH
364 }
365
366/* If we now have an open file, set the close-on-exec flag and return. */
367
368if (*fd >= 0)
369 {
370 fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
371 return;
372 }
373
374/* Creation failed. There are some circumstances in which we get here when
375the effective uid is not root or exim, which is the problem. (For example, a
376non-setuid binary with log_arguments set, called in certain ways.) Rather than
377just bombing out, force the log to stderr and carry on if stderr is available.
378*/
379
380if (euid != root_uid && euid != exim_uid && log_stderr != NULL)
381 {
382 *fd = fileno(log_stderr);
383 return;
384 }
385
386/* Otherwise this is a disaster. This call is deliberately ONLY to the panic
387log. If possible, save a copy of the original line that was being logged. If we
388are recursing (can't open the panic log either), the pointer will already be
389set. */
390
391if (panic_save_buffer == NULL)
392 {
393 panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
394 if (panic_save_buffer != NULL)
395 memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
396 }
397
398log_write(0, LOG_PANIC_DIE, "Cannot open %s log file \"%s\": %s: "
399 "euid=%d egid=%d", log_names[type], buffer, strerror(errno), euid, getegid());
400/* Never returns */
401}
402
403
404
405/*************************************************
406* Add configuration file info to log line *
407*************************************************/
408
409/* This is put in a function because it's needed twice (once for debugging,
410once for real).
411
412Arguments:
413 ptr pointer to the end of the line we are building
414 flags log flags
415
416Returns: updated pointer
417*/
418
419static uschar *
420log_config_info(uschar *ptr, int flags)
421{
422Ustrcpy(ptr, "Exim configuration error");
423ptr += 24;
424
425if ((flags & (LOG_CONFIG_FOR & ~LOG_CONFIG)) != 0)
426 {
427 Ustrcpy(ptr, " for ");
428 return ptr + 5;
429 }
430
431if ((flags & (LOG_CONFIG_IN & ~LOG_CONFIG)) != 0)
432 {
433 sprintf(CS ptr, " in line %d of %s", config_lineno, config_filename);
434 while (*ptr) ptr++;
435 }
436
437Ustrcpy(ptr, ":\n ");
438return ptr + 4;
439}
440
441
442/*************************************************
443* A write() operation failed *
444*************************************************/
445
446/* This function is called when write() fails on anything other than the panic
447log, which can happen if a disk gets full or a file gets too large or whatever.
448We try to save the relevant message in the panic_save buffer before crashing
449out.
450
451Arguments:
452 name the name of the log being written
453 length the string length being written
454 rc the return value from write()
455
456Returns: does not return
457*/
458
459static void
460log_write_failed(uschar *name, int length, int rc)
461{
462int save_errno = errno;
463
464if (panic_save_buffer == NULL)
465 {
466 panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
467 if (panic_save_buffer != NULL)
468 memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
469 }
470
471log_write(0, LOG_PANIC_DIE, "failed to write to %s: length=%d result=%d "
472 "errno=%d (%s)", name, length, rc, save_errno,
473 (save_errno == 0)? "write incomplete" : strerror(save_errno));
474/* Never returns */
475}
476
477
478
479/*************************************************
480* Write message to log file *
481*************************************************/
482
483/* Exim can be configured to log to local files, or use syslog, or both. This
484is controlled by the setting of log_file_path. The following cases are
485recognized:
486
487 log_file_path = "" write files in the spool/log directory
488 log_file_path = "xxx" write files in the xxx directory
489 log_file_path = "syslog" write to syslog
490 log_file_path = "syslog : xxx" write to syslog and to files (any order)
491
492The one exception to this is messages containing LOG_PROCESS. These are always
493written to exim-process.info in the spool directory. They aren't really log
494messages in the same sense as the others.
495
496The message always gets '\n' added on the end of it, since more than one
497process may be writing to the log at once and we don't want intermingling to
498happen in the middle of lines. To be absolutely sure of this we write the data
499into a private buffer and then put it out in a single write() call.
500
501The flags determine which log(s) the message is written to, or for syslogging,
502which priority to use, and in the case of the panic log, whether the process
503should die afterwards.
504
505The variable really_exim is TRUE only when exim is running in privileged state
506(i.e. not with a changed configuration or with testing options such as -brw).
507If it is not, don't try to write to the log because permission will probably be
508denied.
509
510Avoid actually writing to the logs when exim is called with -bv or -bt to
511test an address, but take other actions, such as panicing.
512
513In Exim proper, the buffer for building the message is got at start-up, so that
514nothing gets done if it can't be got. However, some functions that are also
515used in utilities occasionally obey log_write calls in error situations, and it
516is simplest to put a single malloc() here rather than put one in each utility.
517Malloc is used directly because the store functions may call log_write().
518
519If a message_id exists, we include it after the timestamp.
520
521Arguments:
522 selector write to main log or LOG_INFO only if this value is zero, or if
523 its bit is set in log_write_selector
524 flags each bit indicates some independent action:
525 LOG_SENDER add raw sender to the message
526 LOG_RECIPIENTS add raw recipients list to message
527 LOG_CONFIG add "Exim configuration error"
528 LOG_CONFIG_FOR add " for " instead of ":\n "
529 LOG_CONFIG_IN add " in line x[ of file y]"
530 LOG_MAIN write to main log or syslog LOG_INFO
531 LOG_REJECT write to reject log or syslog LOG_NOTICE
532 LOG_PANIC write to panic log or syslog LOG_ALERT
533 LOG_PANIC_DIE write to panic log or LOG_ALERT and then crash
534 LOG_PROCESS write to process log (always a file)
535 format a printf() format
536 ... arguments for format
537
538Returns: nothing
539*/
540
541void
542log_write(unsigned int selector, int flags, char *format, ...)
543{
544uschar *ptr;
545int length, rc;
546int paniclogfd;
547va_list ap;
548
549/* If panic_recurseflag is set, we have failed to open the panic log. This is
550the ultimate disaster. First try to write the message to a debug file and/or
551stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
552original log line that caused the problem. Afterwards, expire. */
553
554if (panic_recurseflag)
555 {
556 uschar *extra = (panic_save_buffer == NULL)? US"" : panic_save_buffer;
557 if (debug_file != NULL) debug_printf("%s%s", extra, log_buffer);
558 if (log_stderr != NULL && log_stderr != debug_file)
559 fprintf(log_stderr, "%s%s", extra, log_buffer);
560 if (*extra != 0) write_syslog(LOG_CRIT, extra);
561 write_syslog(LOG_CRIT, log_buffer);
562 die(US"exim: could not open panic log - aborting: see message(s) above",
563 US"Unexpected log failure, please try later");
564 }
565
566/* Ensure we have a buffer (see comment above); this should never be obeyed
567when running Exim proper, only when running utilities. */
568
569if (log_buffer == NULL)
570 {
571 log_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
572 if (log_buffer == NULL)
573 {
574 fprintf(stderr, "exim: failed to get store for log buffer\n");
575 exim_exit(EXIT_FAILURE);
576 }
577 }
578
579/* If we haven't already done so, inspect the setting of log_file_path to
580determine whether to log to files and/or to syslog. Bits in logging_mode
581control this, and for file logging, the path must end up in file_path. This
582variable must be in permanent store because it may be required again later in
583the process. */
584
585if (!path_inspected)
586 {
587 BOOL multiple = FALSE;
588 int old_pool = store_pool;
589
590 store_pool = POOL_PERM;
591
592 /* If nothing has been set, don't waste effort... the default values for the
593 statics are file_path="" and logging_mode = LOG_MODE_FILE. */
594
595 if (log_file_path[0] != 0)
596 {
597 int sep = ':'; /* Fixed separator - outside use */
598 uschar *s;
599 uschar *ss = log_file_path;
600 logging_mode = 0;
601 while ((s = string_nextinlist(&ss,&sep,log_buffer,LOG_BUFFER_SIZE)) != NULL)
602 {
603 if (Ustrcmp(s, "syslog") == 0)
604 logging_mode |= LOG_MODE_SYSLOG;
605 else if ((logging_mode & LOG_MODE_FILE) != 0) multiple = TRUE;
606 else
607 {
608 logging_mode |= LOG_MODE_FILE;
609
610 /* If a non-empty path is given, use it */
611
612 if (s[0] != 0)
613 {
614 file_path = string_copy(s);
615 }
616
617 /* If the path is empty, we want to use the first non-empty, non-
618 syslog item in LOG_FILE_PATH, if there is one, since the value of
619 log_file_path may have been set at runtime. If there is no such item,
620 use the ultimate default in the spool directory. */
621
622 else
623 {
624 uschar *t;
625 uschar *tt = US LOG_FILE_PATH;
626 while ((t = string_nextinlist(&tt,&sep,log_buffer,LOG_BUFFER_SIZE))
627 != NULL)
628 {
629 if (Ustrcmp(t, "syslog") == 0 || t[0] == 0) continue;
630 file_path = string_copy(t);
631 break;
632 }
633 } /* Empty item in log_file_path */
634 } /* First non-syslog item in log_file_path */
635 } /* Scan of log_file_path */
636 }
637
638 /* If no modes have been selected, it is a major disaster */
639
640 if (logging_mode == 0)
641 die(US"Neither syslog nor file logging set in log_file_path",
642 US"Unexpected logging failure");
643
644 /* Set up the ultimate default if necessary. Then revert to the old store
645 pool, and record that we've sorted out the path. */
646
647 if ((logging_mode & LOG_MODE_FILE) != 0 && file_path[0] == 0)
648 file_path = string_sprintf("%s/log/%%slog", spool_directory);
649 store_pool = old_pool;
650 path_inspected = TRUE;
651
652 /* If more than one file path was given, log a complaint. This recursive call
653 should work since we have now set up the routing. */
654
655 if (multiple)
656 {
657 log_write(0, LOG_MAIN|LOG_PANIC,
658 "More than one path given in log_file_path: using %s", file_path);
659 }
660 }
661
662/* If debugging, show all log entries, but don't show headers. Do it all
663in one go so that it doesn't get split when multi-processing. */
664
665DEBUG(D_any|D_v)
666 {
667 int i;
668 ptr = log_buffer;
669
670 Ustrcpy(ptr, "LOG:");
671 ptr += 4;
672
673 /* Show the options that were passed into the call. These are those whose
674 flag values do not have the 0x80000000 bit in them. Note that this
675 automatically exclude the "all" setting. */
676
677 for (i = 0; i < log_options_count; i++)
678 {
679 unsigned int bit = log_options[i].bit;
680 if ((bit & 0x80000000) != 0) continue;
681 if ((selector & bit) != 0)
682 {
683 *ptr++ = ' ';
684 Ustrcpy(ptr, log_options[i].name);
685 while (*ptr) ptr++;
686 }
687 }
688
689 sprintf(CS ptr, "%s%s%s%s%s\n ",
690 ((flags & LOG_MAIN) != 0)? " MAIN" : "",
691 ((flags & LOG_PANIC) != 0)? " PANIC" : "",
692 ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE)? " DIE" : "",
693 ((flags & LOG_PROCESS) != 0)? " PROCESS": "",
694 ((flags & LOG_REJECT) != 0)? " REJECT" : "");
695
696 while(*ptr) ptr++;
697 if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
698
699 va_start(ap, format);
700 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
701 Ustrcpy(ptr, "**** log string overflowed log buffer ****");
702 va_end(ap);
703
704 while(*ptr) ptr++;
705 Ustrcat(ptr, "\n");
706 debug_printf("%s", log_buffer);
707 }
708
709/* If no log file is specified, we are in a mess. */
710
711if ((flags & (LOG_MAIN|LOG_PANIC|LOG_REJECT|LOG_PROCESS)) == 0)
712 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_write called with no log "
713 "flags set");
714
715/* There are some weird circumstances in which logging is disabled. */
716
717if (disable_logging)
718 {
719 DEBUG(D_any) debug_printf("log writing disabled\n");
720 return;
721 }
722
723/* Create the main message in the log buffer, including the message
724id except for the process log and when called by a utility. */
725
726ptr = log_buffer;
727if (really_exim && (flags & LOG_PROCESS) == 0 && message_id[0] != 0)
728 sprintf(CS ptr, "%s %s ", tod_stamp(tod_log), message_id);
729else sprintf(CS ptr, "%s ", tod_stamp(tod_log));
730
731while(*ptr) ptr++;
732if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
733
734va_start(ap, format);
735if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
736 Ustrcpy(ptr, "**** log string overflowed log buffer ****\n");
737while(*ptr) ptr++;
738va_end(ap);
739
740/* Add the raw, unrewritten, sender to the message if required. This is done
741this way because it kind of fits with LOG_RECIPIENTS. */
742
743if ((flags & LOG_SENDER) != 0 &&
744 ptr < log_buffer + LOG_BUFFER_SIZE - 8 - Ustrlen(raw_sender))
745 {
746 sprintf(CS ptr, " from <%s>", raw_sender);
747 while (*ptr) ptr++;
748 }
749
750/* Add list of recipients to the message if required; the raw list,
751before rewriting, was saved in raw_recipients. There may be none, if an ACL
752discarded them all. */
753
754if ((flags & LOG_RECIPIENTS) != 0 && ptr < log_buffer + LOG_BUFFER_SIZE - 6 &&
755 raw_recipients_count > 0)
756 {
757 int i;
758 sprintf(CS ptr, " for");
759 while (*ptr) ptr++;
760 for (i = 0; i < raw_recipients_count; i++)
761 {
762 uschar *s = raw_recipients[i];
763 if (log_buffer + LOG_BUFFER_SIZE - ptr < Ustrlen(s) + 3) break;
764 sprintf(CS ptr, " %s", s);
765 while (*ptr) ptr++;
766 }
767 }
768
769sprintf(CS ptr, "\n");
770while(*ptr) ptr++;
771length = ptr - log_buffer;
772
773/* Handle loggable errors when running a utility, or when address testing.
774Write to log_stderr unless debugging (when it will already have been written),
775or unless there is no log_stderr (expn called from daemon, for example). */
776
777if (!really_exim || log_testing_mode)
778 {
779 if (debug_selector == 0 && log_stderr != NULL &&
780 (selector == 0 || (selector & log_write_selector) != 0))
781 {
782 if (host_checking)
783 fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20)); /* no timestamp */
784 else
785 fprintf(log_stderr, "%s", CS log_buffer);
786 }
787 if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE);
788 return;
789 }
790
791/* Handle the main log. We know that either syslog or file logging (or both) is
792set up. A real file gets left open during reception or delivery once it has
793been opened, but we don't want to keep on writing to it for too long after it
794has been renamed. Therefore, do a stat() and see if the inode has changed, and
795if so, re-open. */
796
797if ((flags & LOG_MAIN) != 0 &&
798 (selector == 0 || (selector & log_write_selector) != 0))
799 {
800 if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
801 (syslog_duplication || (flags & (LOG_REJECT|LOG_PANIC)) == 0))
802 write_syslog(LOG_INFO, log_buffer);
803
804 if ((logging_mode & LOG_MODE_FILE) != 0)
805 {
806 struct stat statbuf;
807
808 /* Check for a change to the mainlog file name when datestamping is in
809 operation. This happens at midnight, at which point we want to roll over
810 the file. Closing it has the desired effect. */
811
812 if (mainlog_datestamp != NULL)
813 {
814 uschar *nowstamp = tod_stamp(tod_log_datestamp);
815 if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
816 {
817 close(mainlogfd); /* Close the file */
818 mainlogfd = -1; /* Clear the file descriptor */
819 mainlog_inode = 0; /* Unset the inode */
820 mainlog_datestamp = NULL; /* Clear the datestamp */
821 }
822 }
823
824 /* Otherwise, we want to check whether the file has been renamed by a
825 cycling script. This could be "if else", but for safety's sake, leave it as
826 "if" so that renaming the log starts a new file even when datestamping is
827 happening. */
828
829 if (mainlogfd >= 0)
830 {
831 if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
832 {
833 close(mainlogfd);
834 mainlogfd = -1;
835 mainlog_inode = 0;
836 }
837 }
838
839 /* If the log is closed, open it. Then write the line. */
840
841 if (mainlogfd < 0)
842 {
843 open_log(&mainlogfd, lt_main); /* No return on error */
844 if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
845 }
846
847 /* Failing to write to the log is disastrous */
848
849 if ((rc = write(mainlogfd, log_buffer, length)) != length)
850 {
851 log_write_failed(US"main log", length, rc);
852 /* That function does not return */
853 }
854 }
855 }
856
857/* Handle the log for rejected messages. This can be globally disabled. If
858there are any header lines (i.e. if the rejection is happening after the DATA
859phase), log the recipients and the headers. */
860
861if (write_rejectlog && (flags & LOG_REJECT) != 0)
862 {
863 header_line *h;
864
865 if (header_list != NULL && (log_extra_selector & LX_rejected_header) != 0)
866 {
867 if (recipients_count > 0)
868 {
869 int i;
870
871 /* List the sender */
872
873 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
874 "Envelope-from: <%s>\n", sender_address);
875 while (*ptr) ptr++;
876
877 /* List up to 5 recipients */
878
879 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
880 "Envelope-to: <%s>\n", recipients_list[0].address);
881 while (*ptr) ptr++;
882
883 for (i = 1; i < recipients_count && i < 5; i++)
884 {
885 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer), " <%s>\n",
886 recipients_list[i].address);
887 while (*ptr) ptr++;
888 }
889
890 if (i < recipients_count)
891 {
892 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
893 " ...\n");
894 while (*ptr) ptr++;
895 }
896 }
897
898 /* A header with a NULL text is an unfilled in Received: header */
899
900 for (h = header_list; h != NULL; h = h->next)
901 {
902 BOOL fitted;
903 if (h->text == NULL) continue;
904 fitted = string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
905 "%c %s", h->type, h->text);
906 while(*ptr) ptr++;
907 if (!fitted) /* Buffer is full; truncate */
908 {
909 ptr -= 100; /* For message and separator */
910 if (ptr[-1] == '\n') ptr--;
911 Ustrcpy(ptr, "\n*** truncated ***\n");
912 while (*ptr) ptr++;
913 break;
914 }
915 }
916
917 length = ptr - log_buffer;
918 }
919
920 /* Write to syslog or to a log file */
921
922 if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
923 (syslog_duplication || (flags & LOG_PANIC) == 0))
924 write_syslog(LOG_NOTICE, log_buffer);
925
926 /* Check for a change to the rejectlog file name when datestamping is in
927 operation. This happens at midnight, at which point we want to roll over
928 the file. Closing it has the desired effect. */
929
930 if ((logging_mode & LOG_MODE_FILE) != 0)
931 {
932 struct stat statbuf;
933
934 if (rejectlog_datestamp != NULL)
935 {
936 uschar *nowstamp = tod_stamp(tod_log_datestamp);
937 if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
938 {
939 close(rejectlogfd); /* Close the file */
940 rejectlogfd = -1; /* Clear the file descriptor */
941 rejectlog_inode = 0; /* Unset the inode */
942 rejectlog_datestamp = NULL; /* Clear the datestamp */
943 }
944 }
945
946 /* Otherwise, we want to check whether the file has been renamed by a
947 cycling script. This could be "if else", but for safety's sake, leave it as
948 "if" so that renaming the log starts a new file even when datestamping is
949 happening. */
950
951 if (rejectlogfd >= 0)
952 {
953 if (Ustat(rejectlog_name, &statbuf) < 0 ||
954 statbuf.st_ino != rejectlog_inode)
955 {
956 close(rejectlogfd);
957 rejectlogfd = -1;
958 rejectlog_inode = 0;
959 }
960 }
961
962 /* Open the file if necessary, and write the data */
963
964 if (rejectlogfd < 0)
965 {
966 open_log(&rejectlogfd, lt_reject); /* No return on error */
967 if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
968 }
969
970 if ((rc = write(rejectlogfd, log_buffer, length)) != length)
971 {
972 log_write_failed(US"reject log", length, rc);
973 /* That function does not return */
974 }
975 }
976 }
977
978
979/* Handle the process log file, where exim processes can be made to dump
980details of what they are doing by sending them a USR1 signal. Note that
981a message id is not automatically added above. This information is always
982written to a file - never to syslog. */
983
984if ((flags & LOG_PROCESS) != 0)
985 {
986 int processlogfd;
987 open_log(&processlogfd, lt_process); /* No return on error */
988 if ((rc = write(processlogfd, log_buffer, length)) != length)
989 {
990 log_write_failed(US"process log", length, rc);
991 /* That function does not return */
992 }
993 (void)close(processlogfd);
994 }
995
996
997/* Handle the panic log, which is not kept open like the others. If it fails to
998open, there will be a recursive call to log_write(). We detect this above and
999attempt to write to the system log as a last-ditch try at telling somebody. In
1000all cases, try to write to log_stderr. */
1001
1002if ((flags & LOG_PANIC) != 0)
1003 {
1004 if (log_stderr != NULL && log_stderr != debug_file)
1005 fprintf(log_stderr, "%s", CS log_buffer);
1006
1007 if ((logging_mode & LOG_MODE_SYSLOG) != 0)
1008 {
1009 write_syslog(LOG_ALERT, log_buffer);
1010 }
1011
1012 /* If this panic logging was caused by a failure to open the main log,
1013 the original log line is in panic_save_buffer. Make an attempt to write it. */
1014
1015 if ((logging_mode & LOG_MODE_FILE) != 0)
1016 {
1017 panic_recurseflag = TRUE;
1018 open_log(&paniclogfd, lt_panic); /* Won't return on failure */
1019 panic_recurseflag = FALSE;
1020
1021 if (panic_save_buffer != NULL)
1022 (void) write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1023
1024 if ((rc = write(paniclogfd, log_buffer, length)) != length)
1025 {
1026 int save_errno = errno;
1027 write_syslog(LOG_CRIT, log_buffer);
1028 sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
1029 "errno=%d (%s)", length, rc, save_errno, strerror(save_errno));
1030 write_syslog(LOG_CRIT, log_buffer);
1031 flags |= LOG_PANIC_DIE;
1032 }
1033
1034 close(paniclogfd);
1035 }
1036
1037 /* Give up if the DIE flag is set */
1038
1039 if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1040 die(NULL, US"Unexpected failure, please try later");
1041 }
1042}
1043
1044
1045
1046/*************************************************
1047* Close any open log files *
1048*************************************************/
1049
1050void
1051log_close_all(void)
1052{
1053if (mainlogfd >= 0)
1054 { close(mainlogfd); mainlogfd = -1; }
1055if (rejectlogfd >= 0)
1056 { close(rejectlogfd); rejectlogfd = -1; }
1057closelog();
1058syslog_open = FALSE;
1059}
1060
1061/* End of log.c */