24418c5e66ebf179b261acb0d90684d7123f8cc4
[exim.git] / src / src / log.c
1 /* $Cambridge: exim/src/src/log.c,v 1.7 2005/09/12 10:49:30 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   (void)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 another Exim process is trying to write to the log at the same time.
325 The use of SIGUSR1 by the exiwhat utility can provoke a lot of simultaneous
326 writing. */
327
328 euid = geteuid();
329
330 /* If we are already running as the Exim user (even if that user is root),
331 we can go ahead and create in the current process. */
332
333 if (euid == exim_uid) *fd = create_log(buffer);
334
335 /* Otherwise, if we are root, do the creation in an exim:exim subprocess. If we
336 are neither exim nor root, creation is not attempted. */
337
338 else 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
354   /* If we created a subprocess, wait for it. If it succeeded retry the open. */
355
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. */
364   }
365
366 /* If we now have an open file, set the close-on-exec flag and return. */
367
368 if (*fd >= 0)
369   {
370   (void)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
375 the effective uid is not root or exim, which is the problem. (For example, a
376 non-setuid binary with log_arguments set, called in certain ways.) Rather than
377 just bombing out, force the log to stderr and carry on if stderr is available.
378 */
379
380 if (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
387 log. If possible, save a copy of the original line that was being logged. If we
388 are recursing (can't open the panic log either), the pointer will already be
389 set. */
390
391 if (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
398 log_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,
410 once for real).
411
412 Arguments:
413   ptr         pointer to the end of the line we are building
414   flags       log flags
415
416 Returns:      updated pointer
417 */
418
419 static uschar *
420 log_config_info(uschar *ptr, int flags)
421 {
422 Ustrcpy(ptr, "Exim configuration error");
423 ptr += 24;
424
425 if ((flags & (LOG_CONFIG_FOR & ~LOG_CONFIG)) != 0)
426   {
427   Ustrcpy(ptr, " for ");
428   return ptr + 5;
429   }
430
431 if ((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
437 Ustrcpy(ptr, ":\n  ");
438 return 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
447 log, which can happen if a disk gets full or a file gets too large or whatever.
448 We try to save the relevant message in the panic_save buffer before crashing
449 out.
450
451 Arguments:
452   name      the name of the log being written
453   length    the string length being written
454   rc        the return value from write()
455
456 Returns:    does not return
457 */
458
459 static void
460 log_write_failed(uschar *name, int length, int rc)
461 {
462 int save_errno = errno;
463
464 if (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
471 log_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
484 is controlled by the setting of log_file_path. The following cases are
485 recognized:
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
492 The one exception to this is messages containing LOG_PROCESS. These are always
493 written to exim-process.info in the spool directory. They aren't really log
494 messages in the same sense as the others.
495
496 The message always gets '\n' added on the end of it, since more than one
497 process may be writing to the log at once and we don't want intermingling to
498 happen in the middle of lines. To be absolutely sure of this we write the data
499 into a private buffer and then put it out in a single write() call.
500
501 The flags determine which log(s) the message is written to, or for syslogging,
502 which priority to use, and in the case of the panic log, whether the process
503 should die afterwards.
504
505 The 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).
507 If it is not, don't try to write to the log because permission will probably be
508 denied.
509
510 Avoid actually writing to the logs when exim is called with -bv or -bt to
511 test an address, but take other actions, such as panicing.
512
513 In Exim proper, the buffer for building the message is got at start-up, so that
514 nothing gets done if it can't be got. However, some functions that are also
515 used in utilities occasionally obey log_write calls in error situations, and it
516 is simplest to put a single malloc() here rather than put one in each utility.
517 Malloc is used directly because the store functions may call log_write().
518
519 If a message_id exists, we include it after the timestamp.
520
521 Arguments:
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
538 Returns:    nothing
539 */
540
541 void
542 log_write(unsigned int selector, int flags, char *format, ...)
543 {
544 uschar *ptr;
545 int length, rc;
546 int paniclogfd;
547 va_list ap;
548
549 /* If panic_recurseflag is set, we have failed to open the panic log. This is
550 the ultimate disaster. First try to write the message to a debug file and/or
551 stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
552 original log line that caused the problem. Afterwards, expire. */
553
554 if (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
567 when running Exim proper, only when running utilities. */
568
569 if (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
580 determine whether to log to files and/or to syslog. Bits in logging_mode
581 control this, and for file logging, the path must end up in file_path. This
582 variable must be in permanent store because it may be required again later in
583 the process. */
584
585 if (!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
663 in one go so that it doesn't get split when multi-processing. */
664
665 DEBUG(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
711 if ((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
717 if (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
724 id except for the process log and when called by a utility. */
725
726 ptr = log_buffer;
727 if (really_exim && (flags & LOG_PROCESS) == 0 && message_id[0] != 0)
728   sprintf(CS ptr, "%s %s ", tod_stamp(tod_log), message_id);
729 else sprintf(CS ptr, "%s ", tod_stamp(tod_log));
730
731 while(*ptr) ptr++;
732 if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
733
734 va_start(ap, format);
735 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
736   Ustrcpy(ptr, "**** log string overflowed log buffer ****\n");
737 while(*ptr) ptr++;
738 va_end(ap);
739
740 /* Add the raw, unrewritten, sender to the message if required. This is done
741 this way because it kind of fits with LOG_RECIPIENTS. */
742
743 if ((flags & LOG_SENDER) != 0 &&
744     ptr < log_buffer + LOG_BUFFER_SIZE - 10 - 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,
751 before rewriting, was saved in raw_recipients. There may be none, if an ACL
752 discarded them all. */
753
754 if ((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
769 sprintf(CS  ptr, "\n");
770 while(*ptr) ptr++;
771 length = ptr - log_buffer;
772
773 /* Handle loggable errors when running a utility, or when address testing.
774 Write to log_stderr unless debugging (when it will already have been written),
775 or unless there is no log_stderr (expn called from daemon, for example). */
776
777 if (!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
792 set up. A real file gets left open during reception or delivery once it has
793 been opened, but we don't want to keep on writing to it for too long after it
794 has been renamed. Therefore, do a stat() and see if the inode has changed, and
795 if so, re-open. */
796
797 if ((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         (void)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         (void)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
858 there are any header lines (i.e. if the rejection is happening after the DATA
859 phase), log the recipients and the headers. */
860
861 if (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         (void)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         (void)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
980 details of what they are doing by sending them a USR1 signal. Note that
981 a message id is not automatically added above. This information is always
982 written to a file - never to syslog. */
983
984 if ((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
998 open, there will be a recursive call to log_write(). We detect this above and
999 attempt to write to the system log as a last-ditch try at telling somebody. In
1000 all cases except mua_wrapper, try to write to log_stderr. */
1001
1002 if ((flags & LOG_PANIC) != 0)
1003   {
1004   if (log_stderr != NULL && log_stderr != debug_file && !mua_wrapper)
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     (void)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
1050 void
1051 log_close_all(void)
1052 {
1053 if (mainlogfd >= 0)
1054   { (void)close(mainlogfd); mainlogfd = -1; }
1055 if (rejectlogfd >= 0)
1056   { (void)close(rejectlogfd); rejectlogfd = -1; }
1057 closelog();
1058 syslog_open = FALSE;
1059 }
1060
1061 /* End of log.c */