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