d5e89f2cfabdeeb42f714e626e9ec7921201e9a5
[users/heiko/exim.git] / src / src / log.c
1 /* $Cambridge: exim/src/src/log.c,v 1.9 2006/02/13 11:28:56 ph10 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2006 */
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 /* Create the main message in the log buffer, including the message
728 id except for the process log and when called by a utility. */
729
730 ptr = log_buffer;
731 if (really_exim && (flags & LOG_PROCESS) == 0 && message_id[0] != 0)
732   sprintf(CS ptr, "%s %s ", tod_stamp(tod_log), message_id);
733 else sprintf(CS ptr, "%s ", tod_stamp(tod_log));
734
735 while(*ptr) ptr++;
736 if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
737
738 va_start(ap, format);
739 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
740   Ustrcpy(ptr, "**** log string overflowed log buffer ****\n");
741 while(*ptr) ptr++;
742 va_end(ap);
743
744 /* Add the raw, unrewritten, sender to the message if required. This is done
745 this way because it kind of fits with LOG_RECIPIENTS. */
746
747 if ((flags & LOG_SENDER) != 0 &&
748     ptr < log_buffer + LOG_BUFFER_SIZE - 10 - Ustrlen(raw_sender))
749   {
750   sprintf(CS ptr, " from <%s>", raw_sender);
751   while (*ptr) ptr++;
752   }
753
754 /* Add list of recipients to the message if required; the raw list,
755 before rewriting, was saved in raw_recipients. There may be none, if an ACL
756 discarded them all. */
757
758 if ((flags & LOG_RECIPIENTS) != 0 && ptr < log_buffer + LOG_BUFFER_SIZE - 6 &&
759      raw_recipients_count > 0)
760   {
761   int i;
762   sprintf(CS ptr, " for");
763   while (*ptr) ptr++;
764   for (i = 0; i < raw_recipients_count; i++)
765     {
766     uschar *s = raw_recipients[i];
767     if (log_buffer + LOG_BUFFER_SIZE - ptr < Ustrlen(s) + 3) break;
768     sprintf(CS ptr, " %s", s);
769     while (*ptr) ptr++;
770     }
771   }
772
773 sprintf(CS  ptr, "\n");
774 while(*ptr) ptr++;
775 length = ptr - log_buffer;
776
777 /* Handle loggable errors when running a utility, or when address testing.
778 Write to log_stderr unless debugging (when it will already have been written),
779 or unless there is no log_stderr (expn called from daemon, for example). */
780
781 if (!really_exim || log_testing_mode)
782   {
783   if (debug_selector == 0 && log_stderr != NULL &&
784       (selector == 0 || (selector & log_write_selector) != 0))
785     {
786     if (host_checking)
787       fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20));  /* no timestamp */
788     else
789       fprintf(log_stderr, "%s", CS log_buffer);
790     }
791   if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE);
792   return;
793   }
794
795 /* Handle the main log. We know that either syslog or file logging (or both) is
796 set up. A real file gets left open during reception or delivery once it has
797 been opened, but we don't want to keep on writing to it for too long after it
798 has been renamed. Therefore, do a stat() and see if the inode has changed, and
799 if so, re-open. */
800
801 if ((flags & LOG_MAIN) != 0 &&
802     (selector == 0 || (selector & log_write_selector) != 0))
803   {
804   if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
805       (syslog_duplication || (flags & (LOG_REJECT|LOG_PANIC)) == 0))
806     write_syslog(LOG_INFO, log_buffer);
807
808   if ((logging_mode & LOG_MODE_FILE) != 0)
809     {
810     struct stat statbuf;
811
812     /* Check for a change to the mainlog file name when datestamping is in
813     operation. This happens at midnight, at which point we want to roll over
814     the file. Closing it has the desired effect. */
815
816     if (mainlog_datestamp != NULL)
817       {
818       uschar *nowstamp = tod_stamp(tod_log_datestamp);
819       if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
820         {
821         (void)close(mainlogfd);       /* Close the file */
822         mainlogfd = -1;               /* Clear the file descriptor */
823         mainlog_inode = 0;            /* Unset the inode */
824         mainlog_datestamp = NULL;     /* Clear the datestamp */
825         }
826       }
827
828     /* Otherwise, we want to check whether the file has been renamed by a
829     cycling script. This could be "if else", but for safety's sake, leave it as
830     "if" so that renaming the log starts a new file even when datestamping is
831     happening. */
832
833     if (mainlogfd >= 0)
834       {
835       if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
836         {
837         (void)close(mainlogfd);
838         mainlogfd = -1;
839         mainlog_inode = 0;
840         }
841       }
842
843     /* If the log is closed, open it. Then write the line. */
844
845     if (mainlogfd < 0)
846       {
847       open_log(&mainlogfd, lt_main);     /* No return on error */
848       if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
849       }
850
851     /* Failing to write to the log is disastrous */
852
853     if ((rc = write(mainlogfd, log_buffer, length)) != length)
854       {
855       log_write_failed(US"main log", length, rc);
856       /* That function does not return */
857       }
858     }
859   }
860
861 /* Handle the log for rejected messages. This can be globally disabled. If
862 there are any header lines (i.e. if the rejection is happening after the DATA
863 phase), log the recipients and the headers. */
864
865 if (write_rejectlog && (flags & LOG_REJECT) != 0)
866   {
867   header_line *h;
868
869   if (header_list != NULL && (log_extra_selector & LX_rejected_header) != 0)
870     {
871     if (recipients_count > 0)
872       {
873       int i;
874
875       /* List the sender */
876
877       string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
878         "Envelope-from: <%s>\n", sender_address);
879       while (*ptr) ptr++;
880
881       /* List up to 5 recipients */
882
883       string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
884         "Envelope-to: <%s>\n", recipients_list[0].address);
885       while (*ptr) ptr++;
886
887       for (i = 1; i < recipients_count && i < 5; i++)
888         {
889         string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer), "    <%s>\n",
890           recipients_list[i].address);
891         while (*ptr) ptr++;
892         }
893
894       if (i < recipients_count)
895         {
896         (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
897           "    ...\n");
898         while (*ptr) ptr++;
899         }
900       }
901
902     /* A header with a NULL text is an unfilled in Received: header */
903
904     for (h = header_list; h != NULL; h = h->next)
905       {
906       BOOL fitted;
907       if (h->text == NULL) continue;
908       fitted = string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
909         "%c %s", h->type, h->text);
910       while(*ptr) ptr++;
911       if (!fitted)         /* Buffer is full; truncate */
912         {
913         ptr -= 100;        /* For message and separator */
914         if (ptr[-1] == '\n') ptr--;
915         Ustrcpy(ptr, "\n*** truncated ***\n");
916         while (*ptr) ptr++;
917         break;
918         }
919       }
920
921     length = ptr - log_buffer;
922     }
923
924   /* Write to syslog or to a log file */
925
926   if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
927       (syslog_duplication || (flags & LOG_PANIC) == 0))
928     write_syslog(LOG_NOTICE, log_buffer);
929
930   /* Check for a change to the rejectlog file name when datestamping is in
931   operation. This happens at midnight, at which point we want to roll over
932   the file. Closing it has the desired effect. */
933
934   if ((logging_mode & LOG_MODE_FILE) != 0)
935     {
936     struct stat statbuf;
937
938     if (rejectlog_datestamp != NULL)
939       {
940       uschar *nowstamp = tod_stamp(tod_log_datestamp);
941       if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
942         {
943         (void)close(rejectlogfd);       /* Close the file */
944         rejectlogfd = -1;               /* Clear the file descriptor */
945         rejectlog_inode = 0;            /* Unset the inode */
946         rejectlog_datestamp = NULL;     /* Clear the datestamp */
947         }
948       }
949
950     /* Otherwise, we want to check whether the file has been renamed by a
951     cycling script. This could be "if else", but for safety's sake, leave it as
952     "if" so that renaming the log starts a new file even when datestamping is
953     happening. */
954
955     if (rejectlogfd >= 0)
956       {
957       if (Ustat(rejectlog_name, &statbuf) < 0 ||
958            statbuf.st_ino != rejectlog_inode)
959         {
960         (void)close(rejectlogfd);
961         rejectlogfd = -1;
962         rejectlog_inode = 0;
963         }
964       }
965
966     /* Open the file if necessary, and write the data */
967
968     if (rejectlogfd < 0)
969       {
970       open_log(&rejectlogfd, lt_reject); /* No return on error */
971       if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
972       }
973
974     if ((rc = write(rejectlogfd, log_buffer, length)) != length)
975       {
976       log_write_failed(US"reject log", length, rc);
977       /* That function does not return */
978       }
979     }
980   }
981
982
983 /* Handle the process log file, where exim processes can be made to dump
984 details of what they are doing by sending them a USR1 signal. Note that
985 a message id is not automatically added above. This information is always
986 written to a file - never to syslog. */
987
988 if ((flags & LOG_PROCESS) != 0)
989   {
990   int processlogfd;
991   open_log(&processlogfd, lt_process);  /* No return on error */
992   if ((rc = write(processlogfd, log_buffer, length)) != length)
993     {
994     log_write_failed(US"process log", length, rc);
995     /* That function does not return */
996     }
997   (void)close(processlogfd);
998   }
999
1000
1001 /* Handle the panic log, which is not kept open like the others. If it fails to
1002 open, there will be a recursive call to log_write(). We detect this above and
1003 attempt to write to the system log as a last-ditch try at telling somebody. In
1004 all cases except mua_wrapper, try to write to log_stderr. */
1005
1006 if ((flags & LOG_PANIC) != 0)
1007   {
1008   if (log_stderr != NULL && log_stderr != debug_file && !mua_wrapper)
1009     fprintf(log_stderr, "%s", CS log_buffer);
1010
1011   if ((logging_mode & LOG_MODE_SYSLOG) != 0)
1012     {
1013     write_syslog(LOG_ALERT, log_buffer);
1014     }
1015
1016   /* If this panic logging was caused by a failure to open the main log,
1017   the original log line is in panic_save_buffer. Make an attempt to write it. */
1018
1019   if ((logging_mode & LOG_MODE_FILE) != 0)
1020     {
1021     panic_recurseflag = TRUE;
1022     open_log(&paniclogfd, lt_panic);  /* Won't return on failure */
1023     panic_recurseflag = FALSE;
1024
1025     if (panic_save_buffer != NULL)
1026       (void) write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1027
1028     if ((rc = write(paniclogfd, log_buffer, length)) != length)
1029       {
1030       int save_errno = errno;
1031       write_syslog(LOG_CRIT, log_buffer);
1032       sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
1033         "errno=%d (%s)", length, rc, save_errno, strerror(save_errno));
1034       write_syslog(LOG_CRIT, log_buffer);
1035       flags |= LOG_PANIC_DIE;
1036       }
1037
1038     (void)close(paniclogfd);
1039     }
1040
1041   /* Give up if the DIE flag is set */
1042
1043   if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1044     die(NULL, US"Unexpected failure, please try later");
1045   }
1046 }
1047
1048
1049
1050 /*************************************************
1051 *            Close any open log files            *
1052 *************************************************/
1053
1054 void
1055 log_close_all(void)
1056 {
1057 if (mainlogfd >= 0)
1058   { (void)close(mainlogfd); mainlogfd = -1; }
1059 if (rejectlogfd >= 0)
1060   { (void)close(rejectlogfd); rejectlogfd = -1; }
1061 closelog();
1062 syslog_open = FALSE;
1063 }
1064
1065 /* End of log.c */