Use single-bit fields for global flags
[users/heiko/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)) != 0)
564   {
565   Ustrcpy(ptr, " for ");
566   return ptr + 5;
567   }
568
569 if ((flags & (LOG_CONFIG_IN & ~LOG_CONFIG)) != 0)
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 */