678c02be79d948b8f082af0d2625d904da3fc627
[exim.git] / src / src / log.c
1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* Functions for writing log files. The code for maintaining datestamped
9 log files was originally contributed by Tony Sheen. */
10
11
12 #include "exim.h"
13
14 #define LOG_NAME_SIZE 256
15 #define MAX_SYSLOG_LEN 870
16
17 #define LOG_MODE_FILE 1
18 #define LOG_MODE_SYSLOG 2
19
20 enum { lt_main, lt_reject, lt_panic, lt_debug };
21
22 static uschar *log_names[] = { US"main", US"reject", US"panic", US"debug" };
23
24
25
26 /*************************************************
27 * Local static variables *
28 *************************************************/
29
30 static uschar mainlog_name[LOG_NAME_SIZE];
31 static uschar rejectlog_name[LOG_NAME_SIZE];
32 static uschar debuglog_name[LOG_NAME_SIZE];
33
34 static uschar *mainlog_datestamp = NULL;
35 static uschar *rejectlog_datestamp = NULL;
36
37 static int mainlogfd = -1;
38 static int rejectlogfd = -1;
39 static ino_t mainlog_inode = 0;
40 static ino_t rejectlog_inode = 0;
41
42 static uschar *panic_save_buffer = NULL;
43 static BOOL panic_recurseflag = FALSE;
44
45 static BOOL syslog_open = FALSE;
46 static BOOL path_inspected = FALSE;
47 static int logging_mode = LOG_MODE_FILE;
48 static uschar *file_path = US"";
49
50 static size_t pid_position[2];
51
52
53 /* These should be kept in-step with the private delivery error
54 number definitions in macros.h */
55
56 static const uschar * exim_errstrings[] = {
57 US"",
58 US"unknown error",
59 US"user slash",
60 US"exist race",
61 US"not regular",
62 US"not directory",
63 US"bad ugid",
64 US"bad mode",
65 US"inode changed",
66 US"lock failed",
67 US"bad address2",
68 US"forbid pipe",
69 US"forbid file",
70 US"forbid reply",
71 US"missing pipe",
72 US"missing file",
73 US"missing reply",
74 US"bad redirect",
75 US"smtp closed",
76 US"smtp format",
77 US"spool format",
78 US"not absolute",
79 US"Exim-imposed quota",
80 US"held",
81 US"Delivery filter process failure",
82 US"Delivery add/remove header failure",
83 US"Delivery write incomplete error",
84 US"Some expansion failed",
85 US"Failed to get gid",
86 US"Failed to get uid",
87 US"Unset or non-existent transport",
88 US"MBX length mismatch",
89 US"Lookup failed routing or in smtp tpt",
90 US"Can't match format in appendfile",
91 US"Creation outside home in appendfile",
92 US"Can't check a list; lookup defer",
93 US"DNS lookup defer",
94 US"Failed to start TLS session",
95 US"Mandatory TLS session not started",
96 US"Failed to chown a file",
97 US"Failed to create a pipe",
98 US"When verifying",
99 US"When required by client",
100 US"Used internally in smtp transport",
101 US"RCPT gave 4xx error",
102 US"MAIL gave 4xx error",
103 US"DATA gave 4xx error",
104 US"Negotiation failed for proxy configured host",
105 US"Authenticator 'other' failure",
106 US"target not supporting SMTPUTF8",
107 US"",
108
109 US"Not time for routing",
110 US"Not time for local delivery",
111 US"Not time for any remote host",
112 US"Local-only delivery",
113 US"Domain in queue_domains",
114 US"Transport concurrency limit",
115 };
116
117
118 /************************************************/
119 const uschar *
120 exim_errstr(int err)
121 {
122 return err < 0 ? exim_errstrings[-err] : CUS strerror(err);
123 }
124
125 /*************************************************
126 * Write to syslog *
127 *************************************************/
128
129 /* The given string is split into sections according to length, or at embedded
130 newlines, and syslogged as a numbered sequence if it is overlong or if there is
131 more than one line. However, if we are running in the test harness, do not do
132 anything. (The test harness doesn't use syslog - for obvious reasons - but we
133 can get here if there is a failure to open the panic log.)
134
135 Arguments:
136 priority syslog priority
137 s the string to be written
138
139 Returns: nothing
140 */
141
142 static void
143 write_syslog(int priority, const uschar *s)
144 {
145 int len, pass;
146 int linecount = 0;
147
148 if (!syslog_pid && LOGGING(pid))
149 s = string_sprintf("%.*s%s", (int)pid_position[0], s, s + pid_position[1]);
150 if (!syslog_timestamp)
151 {
152 len = log_timezone ? 26 : 20;
153 if (LOGGING(millisec)) len += 4;
154 s += len;
155 }
156
157 len = Ustrlen(s);
158
159 #ifndef NO_OPENLOG
160 if (!syslog_open && !f.running_in_test_harness)
161 {
162 # ifdef SYSLOG_LOG_PID
163 openlog(CS syslog_processname, LOG_PID|LOG_CONS, syslog_facility);
164 # else
165 openlog(CS syslog_processname, LOG_CONS, syslog_facility);
166 # endif
167 syslog_open = TRUE;
168 }
169 #endif
170
171 /* First do a scan through the message in order to determine how many lines
172 it is going to end up as. Then rescan to output it. */
173
174 for (pass = 0; pass < 2; pass++)
175 {
176 int i;
177 int tlen;
178 const uschar * ss = s;
179 for (i = 1, tlen = len; tlen > 0; i++)
180 {
181 int plen = tlen;
182 uschar *nlptr = Ustrchr(ss, '\n');
183 if (nlptr != NULL) plen = nlptr - ss;
184 #ifndef SYSLOG_LONG_LINES
185 if (plen > MAX_SYSLOG_LEN) plen = MAX_SYSLOG_LEN;
186 #endif
187 tlen -= plen;
188 if (ss[plen] == '\n') tlen--; /* chars left */
189
190 if (pass == 0)
191 linecount++;
192 else if (f.running_in_test_harness)
193 if (linecount == 1)
194 fprintf(stderr, "SYSLOG: '%.*s'\n", plen, ss);
195 else
196 fprintf(stderr, "SYSLOG: '[%d%c%d] %.*s'\n", i,
197 ss[plen] == '\n' && tlen != 0 ? '\\' : '/',
198 linecount, plen, ss);
199 else
200 if (linecount == 1)
201 syslog(priority, "%.*s", plen, ss);
202 else
203 syslog(priority, "[%d%c%d] %.*s", i,
204 ss[plen] == '\n' && tlen != 0 ? '\\' : '/',
205 linecount, plen, ss);
206
207 ss += plen;
208 if (*ss == '\n') ss++;
209 }
210 }
211 }
212
213
214
215 /*************************************************
216 * Die tidily *
217 *************************************************/
218
219 /* This is called when Exim is dying as a result of something going wrong in
220 the logging, or after a log call with LOG_PANIC_DIE set. Optionally write a
221 message to debug_file or a stderr file, if they exist. Then, if in the middle
222 of accepting a message, throw it away tidily by calling receive_bomb_out();
223 this will attempt to send an SMTP response if appropriate. Passing NULL as the
224 first argument stops it trying to run the NOTQUIT ACL (which might try further
225 logging and thus cause problems). Otherwise, try to close down an outstanding
226 SMTP call tidily.
227
228 Arguments:
229 s1 Error message to write to debug_file and/or stderr and syslog
230 s2 Error message for any SMTP call that is in progress
231 Returns: The function does not return
232 */
233
234 static void
235 die(uschar *s1, uschar *s2)
236 {
237 if (s1)
238 {
239 write_syslog(LOG_CRIT, s1);
240 if (debug_file) debug_printf("%s\n", s1);
241 if (log_stderr && log_stderr != debug_file)
242 fprintf(log_stderr, "%s\n", s1);
243 }
244 if (f.receive_call_bombout) receive_bomb_out(NULL, s2); /* does not return */
245 if (smtp_input) smtp_closedown(s2);
246 exim_exit(EXIT_FAILURE, NULL);
247 }
248
249
250
251 /*************************************************
252 * Create a log file *
253 *************************************************/
254
255 /* This function is called to create and open a log file. It may be called in a
256 subprocess when the original process is root.
257
258 Arguments:
259 name the file name
260
261 The file name has been build in a working buffer, so it is permissible to
262 overwrite it temporarily if it is necessary to create the directory.
263
264 Returns: a file descriptor, or < 0 on failure (errno set)
265 */
266
267 int
268 log_create(uschar *name)
269 {
270 int fd = Uopen(name,
271 #ifdef O_CLOEXEC
272 O_CLOEXEC |
273 #endif
274 O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
275
276 /* If creation failed, attempt to build a log directory in case that is the
277 problem. */
278
279 if (fd < 0 && errno == ENOENT)
280 {
281 BOOL created;
282 uschar *lastslash = Ustrrchr(name, '/');
283 *lastslash = 0;
284 created = directory_make(NULL, name, LOG_DIRECTORY_MODE, FALSE);
285 DEBUG(D_any) debug_printf("%s log directory %s\n",
286 created ? "created" : "failed to create", name);
287 *lastslash = '/';
288 if (created) fd = Uopen(name,
289 #ifdef O_CLOEXEC
290 O_CLOEXEC |
291 #endif
292 O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
293 }
294
295 return fd;
296 }
297
298
299
300 /*************************************************
301 * Create a log file as the exim user *
302 *************************************************/
303
304 /* This function is called when we are root to spawn an exim:exim subprocess
305 in which we can create a log file. It must be signal-safe since it is called
306 by the usr1_handler().
307
308 Arguments:
309 name the file name
310
311 Returns: a file descriptor, or < 0 on failure (errno set)
312 */
313
314 int
315 log_create_as_exim(uschar *name)
316 {
317 pid_t pid = fork();
318 int status = 1;
319 int fd = -1;
320
321 /* In the subprocess, change uid/gid and do the creation. Return 0 from the
322 subprocess on success. If we don't check for setuid failures, then the file
323 can be created as root, so vulnerabilities which cause setuid to fail mean
324 that the Exim user can use symlinks to cause a file to be opened/created as
325 root. We always open for append, so can't nuke existing content but it would
326 still be Rather Bad. */
327
328 if (pid == 0)
329 {
330 if (setgid(exim_gid) < 0)
331 die(US"exim: setgid for log-file creation failed, aborting",
332 US"Unexpected log failure, please try later");
333 if (setuid(exim_uid) < 0)
334 die(US"exim: setuid for log-file creation failed, aborting",
335 US"Unexpected log failure, please try later");
336 _exit((log_create(name) < 0)? 1 : 0);
337 }
338
339 /* If we created a subprocess, wait for it. If it succeeded, try the open. */
340
341 while (pid > 0 && waitpid(pid, &status, 0) != pid);
342 if (status == 0) fd = Uopen(name,
343 #ifdef O_CLOEXEC
344 O_CLOEXEC |
345 #endif
346 O_APPEND|O_WRONLY, LOG_MODE);
347
348 /* If we failed to create a subprocess, we are in a bad way. We return
349 with fd still < 0, and errno set, letting the caller handle the error. */
350
351 return fd;
352 }
353
354
355
356
357 /*************************************************
358 * Open a log file *
359 *************************************************/
360
361 /* This function opens one of a number of logs, creating the log directory if
362 it does not exist. This may be called recursively on failure, in order to open
363 the panic log.
364
365 The directory is in the static variable file_path. This is static so that it
366 the work of sorting out the path is done just once per Exim process.
367
368 Exim is normally configured to avoid running as root wherever possible, the log
369 files must be owned by the non-privileged exim user. To ensure this, first try
370 an open without O_CREAT - most of the time this will succeed. If it fails, try
371 to create the file; if running as root, this must be done in a subprocess to
372 avoid races.
373
374 Arguments:
375 fd where to return the resulting file descriptor
376 type lt_main, lt_reject, lt_panic, or lt_debug
377 tag optional tag to include in the name (only hooked up for debug)
378
379 Returns: nothing
380 */
381
382 static void
383 open_log(int *fd, int type, uschar *tag)
384 {
385 uid_t euid;
386 BOOL ok, ok2;
387 uschar buffer[LOG_NAME_SIZE];
388
389 /* The names of the log files are controlled by file_path. The panic log is
390 written to the same directory as the main and reject logs, but its name does
391 not have a datestamp. The use of datestamps is indicated by %D/%M in file_path.
392 When opening the panic log, if %D or %M is present, we remove the datestamp
393 from the generated name; if it is at the start, remove a following
394 non-alphanumeric character as well; otherwise, remove a preceding
395 non-alphanumeric character. This is definitely kludgy, but it sort of does what
396 people want, I hope. */
397
398 ok = string_format(buffer, sizeof(buffer), CS file_path, log_names[type]);
399
400 /* Save the name of the mainlog for rollover processing. Without a datestamp,
401 it gets statted to see if it has been cycled. With a datestamp, the datestamp
402 will be compared. The static slot for saving it is the same size as buffer,
403 and the text has been checked above to fit, so this use of strcpy() is OK. */
404
405 if (type == lt_main && string_datestamp_offset >= 0)
406 {
407 Ustrcpy(mainlog_name, buffer);
408 mainlog_datestamp = mainlog_name + string_datestamp_offset;
409 }
410
411 /* Ditto for the reject log */
412
413 else if (type == lt_reject && string_datestamp_offset >= 0)
414 {
415 Ustrcpy(rejectlog_name, buffer);
416 rejectlog_datestamp = rejectlog_name + string_datestamp_offset;
417 }
418
419 /* and deal with the debug log (which keeps the datestamp, but does not
420 update it) */
421
422 else if (type == lt_debug)
423 {
424 Ustrcpy(debuglog_name, buffer);
425 if (tag)
426 {
427 /* this won't change the offset of the datestamp */
428 ok2 = string_format(buffer, sizeof(buffer), "%s%s",
429 debuglog_name, tag);
430 if (ok2)
431 Ustrcpy(debuglog_name, buffer);
432 }
433 }
434
435 /* Remove any datestamp if this is the panic log. This is rare, so there's no
436 need to optimize getting the datestamp length. We remove one non-alphanumeric
437 char afterwards if at the start, otherwise one before. */
438
439 else if (string_datestamp_offset >= 0)
440 {
441 uschar * from = buffer + string_datestamp_offset;
442 uschar * to = from + string_datestamp_length;
443
444 if (from == buffer || from[-1] == '/')
445 {
446 if (!isalnum(*to)) to++;
447 }
448 else
449 if (!isalnum(from[-1])) from--;
450
451 /* This copy is ok, because we know that to is a substring of from. But
452 due to overlap we must use memmove() not Ustrcpy(). */
453 memmove(from, to, Ustrlen(to)+1);
454 }
455
456 /* If the file name is too long, it is an unrecoverable disaster */
457
458 if (!ok)
459 die(US"exim: log file path too long: aborting",
460 US"Logging failure; please try later");
461
462 /* We now have the file name. Try to open an existing file. After a successful
463 open, arrange for automatic closure on exec(), and then return. */
464
465 *fd = Uopen(buffer,
466 #ifdef O_CLOEXEC
467 O_CLOEXEC |
468 #endif
469 O_APPEND|O_WRONLY, LOG_MODE);
470
471 if (*fd >= 0)
472 {
473 #ifndef O_CLOEXEC
474 (void)fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
475 #endif
476 return;
477 }
478
479 /* Open was not successful: try creating the file. If this is a root process,
480 we must do the creating in a subprocess set to exim:exim in order to ensure
481 that the file is created with the right ownership. Otherwise, there can be a
482 race if another Exim process is trying to write to the log at the same time.
483 The use of SIGUSR1 by the exiwhat utility can provoke a lot of simultaneous
484 writing. */
485
486 euid = geteuid();
487
488 /* If we are already running as the Exim user (even if that user is root),
489 we can go ahead and create in the current process. */
490
491 if (euid == exim_uid) *fd = log_create(buffer);
492
493 /* Otherwise, if we are root, do the creation in an exim:exim subprocess. If we
494 are neither exim nor root, creation is not attempted. */
495
496 else if (euid == root_uid) *fd = log_create_as_exim(buffer);
497
498 /* If we now have an open file, set the close-on-exec flag and return. */
499
500 if (*fd >= 0)
501 {
502 #ifndef O_CLOEXEC
503 (void)fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
504 #endif
505 return;
506 }
507
508 /* Creation failed. There are some circumstances in which we get here when
509 the effective uid is not root or exim, which is the problem. (For example, a
510 non-setuid binary with log_arguments set, called in certain ways.) Rather than
511 just bombing out, force the log to stderr and carry on if stderr is available.
512 */
513
514 if (euid != root_uid && euid != exim_uid && log_stderr != NULL)
515 {
516 *fd = fileno(log_stderr);
517 return;
518 }
519
520 /* Otherwise this is a disaster. This call is deliberately ONLY to the panic
521 log. If possible, save a copy of the original line that was being logged. If we
522 are recursing (can't open the panic log either), the pointer will already be
523 set. */
524
525 if (!panic_save_buffer)
526 if ((panic_save_buffer = US malloc(LOG_BUFFER_SIZE)))
527 memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
528
529 log_write(0, LOG_PANIC_DIE, "Cannot open %s log file \"%s\": %s: "
530 "euid=%d egid=%d", log_names[type], buffer, strerror(errno), euid, getegid());
531 /* Never returns */
532 }
533
534
535 static void
536 unlink_log(int type)
537 {
538 if (type == lt_debug) unlink(CS debuglog_name);
539 }
540
541
542
543 /*************************************************
544 * Add configuration file info to log line *
545 *************************************************/
546
547 /* This is put in a function because it's needed twice (once for debugging,
548 once for real).
549
550 Arguments:
551 ptr pointer to the end of the line we are building
552 flags log flags
553
554 Returns: updated pointer
555 */
556
557 static uschar *
558 log_config_info(uschar *ptr, int flags)
559 {
560 Ustrcpy(ptr, "Exim configuration error");
561 ptr += 24;
562
563 if (flags & (LOG_CONFIG_FOR & ~LOG_CONFIG))
564 {
565 Ustrcpy(ptr, " for ");
566 return ptr + 5;
567 }
568
569 if (flags & (LOG_CONFIG_IN & ~LOG_CONFIG))
570 ptr += sprintf(CS ptr, " in line %d of %s", config_lineno, config_filename);
571
572 Ustrcpy(ptr, ":\n ");
573 return ptr + 4;
574 }
575
576
577 /*************************************************
578 * A write() operation failed *
579 *************************************************/
580
581 /* This function is called when write() fails on anything other than the panic
582 log, which can happen if a disk gets full or a file gets too large or whatever.
583 We try to save the relevant message in the panic_save buffer before crashing
584 out.
585
586 The potential invoker should probably not call us for EINTR -1 writes. But
587 otherwise, short writes are bad as we don't do non-blocking writes to fds
588 subject to flow control. (If we do, that's new and the logic of this should
589 be reconsidered).
590
591 Arguments:
592 name the name of the log being written
593 length the string length being written
594 rc the return value from write()
595
596 Returns: does not return
597 */
598
599 static void
600 log_write_failed(uschar *name, int length, int rc)
601 {
602 int save_errno = errno;
603
604 if (!panic_save_buffer)
605 if ((panic_save_buffer = US malloc(LOG_BUFFER_SIZE)))
606 memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
607
608 log_write(0, LOG_PANIC_DIE, "failed to write to %s: length=%d result=%d "
609 "errno=%d (%s)", name, length, rc, save_errno,
610 (save_errno == 0)? "write incomplete" : strerror(save_errno));
611 /* Never returns */
612 }
613
614
615
616 /*************************************************
617 * Write to an fd, retrying after signals *
618 *************************************************/
619
620 /* Basic write to fd for logs, handling EINTR.
621
622 Arguments:
623 fd the fd to write to
624 buf the string to write
625 length the string length being written
626
627 Returns:
628 length actually written, persisting an errno from write()
629 */
630 ssize_t
631 write_to_fd_buf(int fd, const uschar *buf, size_t length)
632 {
633 ssize_t wrote;
634 size_t total_written = 0;
635 const uschar *p = buf;
636 size_t left = length;
637
638 while (1)
639 {
640 wrote = write(fd, p, left);
641 if (wrote == (ssize_t)-1)
642 {
643 if (errno == EINTR) continue;
644 return wrote;
645 }
646 total_written += wrote;
647 if (wrote == left)
648 break;
649 else
650 {
651 p += wrote;
652 left -= wrote;
653 }
654 }
655 return total_written;
656 }
657
658
659
660 static void
661 set_file_path(void)
662 {
663 int sep = ':'; /* Fixed separator - outside use */
664 uschar *t;
665 const uschar *tt = US LOG_FILE_PATH;
666 while ((t = string_nextinlist(&tt, &sep, log_buffer, LOG_BUFFER_SIZE)))
667 {
668 if (Ustrcmp(t, "syslog") == 0 || t[0] == 0) continue;
669 file_path = string_copy(t);
670 break;
671 }
672 }
673
674
675 void
676 mainlog_close(void)
677 {
678 if (mainlogfd < 0) return;
679 (void)close(mainlogfd);
680 mainlogfd = -1;
681 mainlog_inode = 0;
682 }
683
684 /*************************************************
685 * Write message to log file *
686 *************************************************/
687
688 /* Exim can be configured to log to local files, or use syslog, or both. This
689 is controlled by the setting of log_file_path. The following cases are
690 recognized:
691
692 log_file_path = "" write files in the spool/log directory
693 log_file_path = "xxx" write files in the xxx directory
694 log_file_path = "syslog" write to syslog
695 log_file_path = "syslog : xxx" write to syslog and to files (any order)
696
697 The message always gets '\n' added on the end of it, since more than one
698 process may be writing to the log at once and we don't want intermingling to
699 happen in the middle of lines. To be absolutely sure of this we write the data
700 into a private buffer and then put it out in a single write() call.
701
702 The flags determine which log(s) the message is written to, or for syslogging,
703 which priority to use, and in the case of the panic log, whether the process
704 should die afterwards.
705
706 The variable really_exim is TRUE only when exim is running in privileged state
707 (i.e. not with a changed configuration or with testing options such as -brw).
708 If it is not, don't try to write to the log because permission will probably be
709 denied.
710
711 Avoid actually writing to the logs when exim is called with -bv or -bt to
712 test an address, but take other actions, such as panicking.
713
714 In Exim proper, the buffer for building the message is got at start-up, so that
715 nothing gets done if it can't be got. However, some functions that are also
716 used in utilities occasionally obey log_write calls in error situations, and it
717 is simplest to put a single malloc() here rather than put one in each utility.
718 Malloc is used directly because the store functions may call log_write().
719
720 If a message_id exists, we include it after the timestamp.
721
722 Arguments:
723 selector write to main log or LOG_INFO only if this value is zero, or if
724 its bit is set in log_selector[0]
725 flags each bit indicates some independent action:
726 LOG_SENDER add raw sender to the message
727 LOG_RECIPIENTS add raw recipients list to message
728 LOG_CONFIG add "Exim configuration error"
729 LOG_CONFIG_FOR add " for " instead of ":\n "
730 LOG_CONFIG_IN add " in line x[ of file y]"
731 LOG_MAIN write to main log or syslog LOG_INFO
732 LOG_REJECT write to reject log or syslog LOG_NOTICE
733 LOG_PANIC write to panic log or syslog LOG_ALERT
734 LOG_PANIC_DIE write to panic log or LOG_ALERT and then crash
735 format a printf() format
736 ... arguments for format
737
738 Returns: nothing
739 */
740
741 void
742 log_write(unsigned int selector, int flags, const char *format, ...)
743 {
744 uschar * ptr;
745 int length;
746 int paniclogfd;
747 ssize_t written_len;
748 va_list ap;
749
750 /* If panic_recurseflag is set, we have failed to open the panic log. This is
751 the ultimate disaster. First try to write the message to a debug file and/or
752 stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
753 original log line that caused the problem. Afterwards, expire. */
754
755 if (panic_recurseflag)
756 {
757 uschar *extra = panic_save_buffer ? panic_save_buffer : US"";
758 if (debug_file) debug_printf("%s%s", extra, log_buffer);
759 if (log_stderr && log_stderr != debug_file)
760 fprintf(log_stderr, "%s%s", extra, log_buffer);
761 if (*extra) write_syslog(LOG_CRIT, extra);
762 write_syslog(LOG_CRIT, log_buffer);
763 die(US"exim: could not open panic log - aborting: see message(s) above",
764 US"Unexpected log failure, please try later");
765 }
766
767 /* Ensure we have a buffer (see comment above); this should never be obeyed
768 when running Exim proper, only when running utilities. */
769
770 if (!log_buffer)
771 if (!(log_buffer = US malloc(LOG_BUFFER_SIZE)))
772 {
773 fprintf(stderr, "exim: failed to get store for log buffer\n");
774 exim_exit(EXIT_FAILURE, NULL);
775 }
776
777 /* If we haven't already done so, inspect the setting of log_file_path to
778 determine whether to log to files and/or to syslog. Bits in logging_mode
779 control this, and for file logging, the path must end up in file_path. This
780 variable must be in permanent store because it may be required again later in
781 the process. */
782
783 if (!path_inspected)
784 {
785 BOOL multiple = FALSE;
786 int old_pool = store_pool;
787
788 store_pool = POOL_PERM;
789
790 /* If nothing has been set, don't waste effort... the default values for the
791 statics are file_path="" and logging_mode = LOG_MODE_FILE. */
792
793 if (*log_file_path)
794 {
795 int sep = ':'; /* Fixed separator - outside use */
796 uschar *s;
797 const uschar *ss = log_file_path;
798
799 logging_mode = 0;
800 while ((s = string_nextinlist(&ss, &sep, log_buffer, LOG_BUFFER_SIZE)))
801 {
802 if (Ustrcmp(s, "syslog") == 0)
803 logging_mode |= LOG_MODE_SYSLOG;
804 else if (logging_mode & LOG_MODE_FILE)
805 multiple = TRUE;
806 else
807 {
808 logging_mode |= LOG_MODE_FILE;
809
810 /* If a non-empty path is given, use it */
811
812 if (*s)
813 file_path = string_copy(s);
814
815 /* If the path is empty, we want to use the first non-empty, non-
816 syslog item in LOG_FILE_PATH, if there is one, since the value of
817 log_file_path may have been set at runtime. If there is no such item,
818 use the ultimate default in the spool directory. */
819
820 else
821 set_file_path(); /* Empty item in log_file_path */
822 } /* First non-syslog item in log_file_path */
823 } /* Scan of log_file_path */
824 }
825
826 /* If no modes have been selected, it is a major disaster */
827
828 if (logging_mode == 0)
829 die(US"Neither syslog nor file logging set in log_file_path",
830 US"Unexpected logging failure");
831
832 /* Set up the ultimate default if necessary. Then revert to the old store
833 pool, and record that we've sorted out the path. */
834
835 if (logging_mode & LOG_MODE_FILE && !file_path[0])
836 file_path = string_sprintf("%s/log/%%slog", spool_directory);
837 store_pool = old_pool;
838 path_inspected = TRUE;
839
840 /* If more than one file path was given, log a complaint. This recursive call
841 should work since we have now set up the routing. */
842
843 if (multiple)
844 log_write(0, LOG_MAIN|LOG_PANIC,
845 "More than one path given in log_file_path: using %s", file_path);
846 }
847
848 /* If debugging, show all log entries, but don't show headers. Do it all
849 in one go so that it doesn't get split when multi-processing. */
850
851 DEBUG(D_any|D_v)
852 {
853 int i;
854 ptr = log_buffer;
855
856 Ustrcpy(ptr, "LOG:");
857 ptr += 4;
858
859 /* Show the selector that was passed into the call. */
860
861 for (i = 0; i < log_options_count; i++)
862 {
863 unsigned int bitnum = log_options[i].bit;
864 if (bitnum < BITWORDSIZE && selector == BIT(bitnum))
865 {
866 *ptr++ = ' ';
867 Ustrcpy(ptr, log_options[i].name);
868 while (*ptr) ptr++;
869 }
870 }
871
872 ptr += sprintf(CS ptr, "%s%s%s%s\n ",
873 flags & LOG_MAIN ? " MAIN" : "",
874 flags & LOG_PANIC ? " PANIC" : "",
875 (flags & LOG_PANIC_DIE) == LOG_PANIC_DIE ? " DIE" : "",
876 flags & LOG_REJECT ? " REJECT" : "");
877
878 if (flags & LOG_CONFIG) ptr = log_config_info(ptr, flags);
879
880 va_start(ap, format);
881 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
882 Ustrcpy(ptr, "**** log string overflowed log buffer ****");
883 va_end(ap);
884
885 while(*ptr) ptr++;
886 Ustrcat(ptr, "\n");
887 debug_printf("%s", log_buffer);
888 }
889
890 /* If no log file is specified, we are in a mess. */
891
892 if (!(flags & (LOG_MAIN|LOG_PANIC|LOG_REJECT)))
893 log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_write called with no log "
894 "flags set");
895
896 /* There are some weird circumstances in which logging is disabled. */
897
898 if (f.disable_logging)
899 {
900 DEBUG(D_any) debug_printf("log writing disabled\n");
901 return;
902 }
903
904 /* Handle disabled reject log */
905
906 if (!write_rejectlog) flags &= ~LOG_REJECT;
907
908 /* Create the main message in the log buffer. Do not include the message id
909 when called by a utility. */
910
911 ptr = log_buffer;
912 ptr += sprintf(CS ptr, "%s ", tod_stamp(tod_log));
913
914 if (LOGGING(pid))
915 {
916 if (!syslog_pid) pid_position[0] = ptr - log_buffer; /* remember begin … */
917 ptr += sprintf(CS ptr, "[%d] ", (int)getpid());
918 if (!syslog_pid) pid_position[1] = ptr - log_buffer; /* … and end+1 of the PID */
919 }
920
921 if (f.really_exim && message_id[0] != 0)
922 ptr += sprintf(CS ptr, "%s ", message_id);
923
924 if (flags & LOG_CONFIG) ptr = log_config_info(ptr, flags);
925
926 va_start(ap, format);
927 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
928 Ustrcpy(ptr, "**** log string overflowed log buffer ****\n");
929 while(*ptr) ptr++;
930 va_end(ap);
931
932 /* Add the raw, unrewritten, sender to the message if required. This is done
933 this way because it kind of fits with LOG_RECIPIENTS. */
934
935 if ( flags & LOG_SENDER
936 && ptr < log_buffer + LOG_BUFFER_SIZE - 10 - Ustrlen(raw_sender))
937 ptr += sprintf(CS ptr, " from <%s>", raw_sender);
938
939 /* Add list of recipients to the message if required; the raw list,
940 before rewriting, was saved in raw_recipients. There may be none, if an ACL
941 discarded them all. */
942
943 if ( flags & LOG_RECIPIENTS
944 && ptr < log_buffer + LOG_BUFFER_SIZE - 6
945 && raw_recipients_count > 0)
946 {
947 int i;
948 ptr += sprintf(CS ptr, " for");
949 for (i = 0; i < raw_recipients_count; i++)
950 {
951 uschar * s = raw_recipients[i];
952 if (log_buffer + LOG_BUFFER_SIZE - ptr < Ustrlen(s) + 3) break;
953 ptr += sprintf(CS ptr, " %s", s);
954 }
955 }
956
957 ptr += sprintf(CS ptr, "\n");
958 length = ptr - log_buffer;
959
960 /* Handle loggable errors when running a utility, or when address testing.
961 Write to log_stderr unless debugging (when it will already have been written),
962 or unless there is no log_stderr (expn called from daemon, for example). */
963
964 if (!f.really_exim || f.log_testing_mode)
965 {
966 if ( !debug_selector
967 && log_stderr
968 && (selector == 0 || (selector & log_selector[0]) != 0)
969 )
970 if (host_checking)
971 fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20)); /* no timestamp */
972 else
973 fprintf(log_stderr, "%s", CS log_buffer);
974
975 if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE, US"");
976 return;
977 }
978
979 /* Handle the main log. We know that either syslog or file logging (or both) is
980 set up. A real file gets left open during reception or delivery once it has
981 been opened, but we don't want to keep on writing to it for too long after it
982 has been renamed. Therefore, do a stat() and see if the inode has changed, and
983 if so, re-open. */
984
985 if ( flags & LOG_MAIN
986 && (!selector || selector & log_selector[0]))
987 {
988 if ( logging_mode & LOG_MODE_SYSLOG
989 && (syslog_duplication || !(flags & (LOG_REJECT|LOG_PANIC))))
990 write_syslog(LOG_INFO, log_buffer);
991
992 if (logging_mode & LOG_MODE_FILE)
993 {
994 struct stat statbuf;
995
996 /* Check for a change to the mainlog file name when datestamping is in
997 operation. This happens at midnight, at which point we want to roll over
998 the file. Closing it has the desired effect. */
999
1000 if (mainlog_datestamp)
1001 {
1002 uschar *nowstamp = tod_stamp(string_datestamp_type);
1003 if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
1004 {
1005 (void)close(mainlogfd); /* Close the file */
1006 mainlogfd = -1; /* Clear the file descriptor */
1007 mainlog_inode = 0; /* Unset the inode */
1008 mainlog_datestamp = NULL; /* Clear the datestamp */
1009 }
1010 }
1011
1012 /* Otherwise, we want to check whether the file has been renamed by a
1013 cycling script. This could be "if else", but for safety's sake, leave it as
1014 "if" so that renaming the log starts a new file even when datestamping is
1015 happening. */
1016
1017 if (mainlogfd >= 0)
1018 if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
1019 mainlog_close();
1020
1021 /* If the log is closed, open it. Then write the line. */
1022
1023 if (mainlogfd < 0)
1024 {
1025 open_log(&mainlogfd, lt_main, NULL); /* No return on error */
1026 if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
1027 }
1028
1029 /* Failing to write to the log is disastrous */
1030
1031 written_len = write_to_fd_buf(mainlogfd, log_buffer, length);
1032 if (written_len != length)
1033 {
1034 log_write_failed(US"main log", length, written_len);
1035 /* That function does not return */
1036 }
1037 }
1038 }
1039
1040 /* Handle the log for rejected messages. This can be globally disabled, in
1041 which case the flags are altered above. If there are any header lines (i.e. if
1042 the rejection is happening after the DATA phase), log the recipients and the
1043 headers. */
1044
1045 if (flags & LOG_REJECT)
1046 {
1047 header_line *h;
1048
1049 if (header_list && LOGGING(rejected_header))
1050 {
1051 if (recipients_count > 0)
1052 {
1053 int i;
1054
1055 /* List the sender */
1056
1057 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
1058 "Envelope-from: <%s>\n", sender_address);
1059 while (*ptr) ptr++;
1060
1061 /* List up to 5 recipients */
1062
1063 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
1064 "Envelope-to: <%s>\n", recipients_list[0].address);
1065 while (*ptr) ptr++;
1066
1067 for (i = 1; i < recipients_count && i < 5; i++)
1068 {
1069 string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer), " <%s>\n",
1070 recipients_list[i].address);
1071 while (*ptr) ptr++;
1072 }
1073
1074 if (i < recipients_count)
1075 {
1076 (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
1077 " ...\n");
1078 while (*ptr) ptr++;
1079 }
1080 }
1081
1082 /* A header with a NULL text is an unfilled in Received: header */
1083
1084 for (h = header_list; h; h = h->next) if (h->text)
1085 {
1086 BOOL fitted = string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
1087 "%c %s", h->type, h->text);
1088 while(*ptr) ptr++;
1089 if (!fitted) /* Buffer is full; truncate */
1090 {
1091 ptr -= 100; /* For message and separator */
1092 if (ptr[-1] == '\n') ptr--;
1093 Ustrcpy(ptr, "\n*** truncated ***\n");
1094 while (*ptr) ptr++;
1095 break;
1096 }
1097 }
1098
1099 length = ptr - log_buffer;
1100 }
1101
1102 /* Write to syslog or to a log file */
1103
1104 if ( logging_mode & LOG_MODE_SYSLOG
1105 && (syslog_duplication || !(flags & LOG_PANIC)))
1106 write_syslog(LOG_NOTICE, log_buffer);
1107
1108 /* Check for a change to the rejectlog file name when datestamping is in
1109 operation. This happens at midnight, at which point we want to roll over
1110 the file. Closing it has the desired effect. */
1111
1112 if (logging_mode & LOG_MODE_FILE)
1113 {
1114 struct stat statbuf;
1115
1116 if (rejectlog_datestamp)
1117 {
1118 uschar *nowstamp = tod_stamp(string_datestamp_type);
1119 if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
1120 {
1121 (void)close(rejectlogfd); /* Close the file */
1122 rejectlogfd = -1; /* Clear the file descriptor */
1123 rejectlog_inode = 0; /* Unset the inode */
1124 rejectlog_datestamp = NULL; /* Clear the datestamp */
1125 }
1126 }
1127
1128 /* Otherwise, we want to check whether the file has been renamed by a
1129 cycling script. This could be "if else", but for safety's sake, leave it as
1130 "if" so that renaming the log starts a new file even when datestamping is
1131 happening. */
1132
1133 if (rejectlogfd >= 0)
1134 if (Ustat(rejectlog_name, &statbuf) < 0 ||
1135 statbuf.st_ino != rejectlog_inode)
1136 {
1137 (void)close(rejectlogfd);
1138 rejectlogfd = -1;
1139 rejectlog_inode = 0;
1140 }
1141
1142 /* Open the file if necessary, and write the data */
1143
1144 if (rejectlogfd < 0)
1145 {
1146 open_log(&rejectlogfd, lt_reject, NULL); /* No return on error */
1147 if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
1148 }
1149
1150 written_len = write_to_fd_buf(rejectlogfd, log_buffer, length);
1151 if (written_len != length)
1152 {
1153 log_write_failed(US"reject log", length, written_len);
1154 /* That function does not return */
1155 }
1156 }
1157 }
1158
1159
1160 /* Handle the panic log, which is not kept open like the others. If it fails to
1161 open, there will be a recursive call to log_write(). We detect this above and
1162 attempt to write to the system log as a last-ditch try at telling somebody. In
1163 all cases except mua_wrapper, try to write to log_stderr. */
1164
1165 if (flags & LOG_PANIC)
1166 {
1167 if (log_stderr && log_stderr != debug_file && !mua_wrapper)
1168 fprintf(log_stderr, "%s", CS log_buffer);
1169
1170 if (logging_mode & LOG_MODE_SYSLOG)
1171 write_syslog(LOG_ALERT, log_buffer);
1172
1173 /* If this panic logging was caused by a failure to open the main log,
1174 the original log line is in panic_save_buffer. Make an attempt to write it. */
1175
1176 if (logging_mode & LOG_MODE_FILE)
1177 {
1178 panic_recurseflag = TRUE;
1179 open_log(&paniclogfd, lt_panic, NULL); /* Won't return on failure */
1180 panic_recurseflag = FALSE;
1181
1182 if (panic_save_buffer)
1183 {
1184 int i = write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1185 i = i; /* compiler quietening */
1186 }
1187
1188 written_len = write_to_fd_buf(paniclogfd, log_buffer, length);
1189 if (written_len != length)
1190 {
1191 int save_errno = errno;
1192 write_syslog(LOG_CRIT, log_buffer);
1193 sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
1194 "errno=%d (%s)", length, (int)written_len, save_errno, strerror(save_errno));
1195 write_syslog(LOG_CRIT, log_buffer);
1196 flags |= LOG_PANIC_DIE;
1197 }
1198
1199 (void)close(paniclogfd);
1200 }
1201
1202 /* Give up if the DIE flag is set */
1203
1204 if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1205 die(NULL, US"Unexpected failure, please try later");
1206 }
1207 }
1208
1209
1210
1211 /*************************************************
1212 * Close any open log files *
1213 *************************************************/
1214
1215 void
1216 log_close_all(void)
1217 {
1218 if (mainlogfd >= 0)
1219 { (void)close(mainlogfd); mainlogfd = -1; }
1220 if (rejectlogfd >= 0)
1221 { (void)close(rejectlogfd); rejectlogfd = -1; }
1222 closelog();
1223 syslog_open = FALSE;
1224 }
1225
1226
1227
1228 /*************************************************
1229 * Multi-bit set or clear *
1230 *************************************************/
1231
1232 /* These functions take a list of bit indexes (terminated by -1) and
1233 clear or set the corresponding bits in the selector.
1234
1235 Arguments:
1236 selector address of the bit string
1237 selsize number of words in the bit string
1238 bits list of bits to set
1239 */
1240
1241 void
1242 bits_clear(unsigned int *selector, size_t selsize, int *bits)
1243 {
1244 for(; *bits != -1; ++bits)
1245 BIT_CLEAR(selector, selsize, *bits);
1246 }
1247
1248 void
1249 bits_set(unsigned int *selector, size_t selsize, int *bits)
1250 {
1251 for(; *bits != -1; ++bits)
1252 BIT_SET(selector, selsize, *bits);
1253 }
1254
1255
1256
1257 /*************************************************
1258 * Decode bit settings for log/debug *
1259 *************************************************/
1260
1261 /* This function decodes a string containing bit settings in the form of +name
1262 and/or -name sequences, and sets/unsets bits in a bit string accordingly. It
1263 also recognizes a numeric setting of the form =<number>, but this is not
1264 intended for user use. It's an easy way for Exim to pass the debug settings
1265 when it is re-exec'ed.
1266
1267 The option table is a list of names and bit indexes. The index -1
1268 means "set all bits, except for those listed in notall". The notall
1269 list is terminated by -1.
1270
1271 The action taken for bad values varies depending upon why we're here.
1272 For log messages, or if the debugging is triggered from config, then we write
1273 to the log on the way out. For debug setting triggered from the command-line,
1274 we treat it as an unknown option: error message to stderr and die.
1275
1276 Arguments:
1277 selector address of the bit string
1278 selsize number of words in the bit string
1279 notall list of bits to exclude from "all"
1280 string the configured string
1281 options the table of option names
1282 count size of table
1283 which "log" or "debug"
1284 flags DEBUG_FROM_CONFIG
1285
1286 Returns: nothing on success - bomb out on failure
1287 */
1288
1289 void
1290 decode_bits(unsigned int *selector, size_t selsize, int *notall,
1291 uschar *string, bit_table *options, int count, uschar *which, int flags)
1292 {
1293 uschar *errmsg;
1294 if (string == NULL) return;
1295
1296 if (*string == '=')
1297 {
1298 char *end; /* Not uschar */
1299 memset(selector, 0, sizeof(*selector)*selsize);
1300 *selector = strtoul(CS string+1, &end, 0);
1301 if (*end == 0) return;
1302 errmsg = string_sprintf("malformed numeric %s_selector setting: %s", which,
1303 string);
1304 goto ERROR_RETURN;
1305 }
1306
1307 /* Handle symbolic setting */
1308
1309 else for(;;)
1310 {
1311 BOOL adding;
1312 uschar *s;
1313 int len;
1314 bit_table *start, *end;
1315
1316 while (isspace(*string)) string++;
1317 if (*string == 0) return;
1318
1319 if (*string != '+' && *string != '-')
1320 {
1321 errmsg = string_sprintf("malformed %s_selector setting: "
1322 "+ or - expected but found \"%s\"", which, string);
1323 goto ERROR_RETURN;
1324 }
1325
1326 adding = *string++ == '+';
1327 s = string;
1328 while (isalnum(*string) || *string == '_') string++;
1329 len = string - s;
1330
1331 start = options;
1332 end = options + count;
1333
1334 while (start < end)
1335 {
1336 bit_table *middle = start + (end - start)/2;
1337 int c = Ustrncmp(s, middle->name, len);
1338 if (c == 0)
1339 {
1340 if (middle->name[len] != 0) c = -1; else
1341 {
1342 unsigned int bit = middle->bit;
1343
1344 if (bit == -1)
1345 {
1346 if (adding)
1347 {
1348 memset(selector, -1, sizeof(*selector)*selsize);
1349 bits_clear(selector, selsize, notall);
1350 }
1351 else
1352 memset(selector, 0, sizeof(*selector)*selsize);
1353 }
1354 else if (adding)
1355 BIT_SET(selector, selsize, bit);
1356 else
1357 BIT_CLEAR(selector, selsize, bit);
1358
1359 break; /* Out of loop to match selector name */
1360 }
1361 }
1362 if (c < 0) end = middle; else start = middle + 1;
1363 } /* Loop to match selector name */
1364
1365 if (start >= end)
1366 {
1367 errmsg = string_sprintf("unknown %s_selector setting: %c%.*s", which,
1368 adding? '+' : '-', len, s);
1369 goto ERROR_RETURN;
1370 }
1371 } /* Loop for selector names */
1372
1373 /* Handle disasters */
1374
1375 ERROR_RETURN:
1376 if (Ustrcmp(which, "debug") == 0)
1377 {
1378 if (flags & DEBUG_FROM_CONFIG)
1379 {
1380 log_write(0, LOG_CONFIG|LOG_PANIC, "%s", errmsg);
1381 return;
1382 }
1383 fprintf(stderr, "exim: %s\n", errmsg);
1384 exit(EXIT_FAILURE);
1385 }
1386 else log_write(0, LOG_CONFIG|LOG_PANIC_DIE, "%s", errmsg);
1387 }
1388
1389
1390
1391 /*************************************************
1392 * Activate a debug logfile (late) *
1393 *************************************************/
1394
1395 /* Normally, debugging is activated from the command-line; it may be useful
1396 within the configuration to activate debugging later, based on certain
1397 conditions. If debugging is already in progress, we return early, no action
1398 taken (besides debug-logging that we wanted debug-logging).
1399
1400 Failures in options are not fatal but will result in paniclog entries for the
1401 misconfiguration.
1402
1403 The first use of this is in ACL logic, "control = debug/tag=foo/opts=+expand"
1404 which can be combined with conditions, etc, to activate extra logging only
1405 for certain sources. The second use is inetd wait mode debug preservation. */
1406
1407 void
1408 debug_logging_activate(uschar *tag_name, uschar *opts)
1409 {
1410 int fd = -1;
1411
1412 if (debug_file)
1413 {
1414 debug_printf("DEBUGGING ACTIVATED FROM WITHIN CONFIG.\n"
1415 "DEBUG: Tag=\"%s\" opts=\"%s\"\n", tag_name, opts ? opts : US"");
1416 return;
1417 }
1418
1419 if (tag_name != NULL && (Ustrchr(tag_name, '/') != NULL))
1420 {
1421 log_write(0, LOG_MAIN|LOG_PANIC, "debug tag may not contain a '/' in: %s",
1422 tag_name);
1423 return;
1424 }
1425
1426 debug_selector = D_default;
1427 if (opts)
1428 decode_bits(&debug_selector, 1, debug_notall, opts,
1429 debug_options, debug_options_count, US"debug", DEBUG_FROM_CONFIG);
1430
1431 /* When activating from a transport process we may never have logged at all
1432 resulting in certain setup not having been done. Hack this for now so we
1433 do not segfault; note that nondefault log locations will not work */
1434
1435 if (!*file_path) set_file_path();
1436
1437 open_log(&fd, lt_debug, tag_name);
1438
1439 if (fd != -1)
1440 debug_file = fdopen(fd, "w");
1441 else
1442 log_write(0, LOG_MAIN|LOG_PANIC, "unable to open debug log");
1443 }
1444
1445
1446 void
1447 debug_logging_stop(void)
1448 {
1449 if (!debug_file || !debuglog_name[0]) return;
1450
1451 debug_selector = 0;
1452 fclose(debug_file);
1453 debug_file = NULL;
1454 unlink_log(lt_debug);
1455 }
1456
1457
1458 /* End of log.c */