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