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