2 Copyright (C) 1998, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GNU Wget.
6 GNU Wget is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 GNU Wget is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with Wget; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* Use stdarg only if the compiler supports ANSI C and stdarg.h is
23 present. We check for both because there are configurations where
24 stdarg.h exists, but doesn't work. */
25 #undef WGET_USE_STDARG
28 # define WGET_USE_STDARG
39 #ifdef WGET_USE_STDARG
57 /* This file impplement support for "logging". Logging means printing
58 output, plus several additional features:
60 - Cataloguing output by importance. You can specify that a log
61 message is "verbose" or "debug", and it will not be printed unless
62 in verbose or debug mode, respectively.
64 - Redirecting the log to the file. When Wget's output goes to the
65 terminal, and Wget receives SIGHUP, all further output is
66 redirected to a log file. When this is the case, Wget can also
67 print the last several lines of "context" to the log file so that
68 it does not begin in the middle of a line. For this to work, the
69 logging code stores the last several lines of context. Callers may
70 request for certain output not to be stored.
72 - Inhibiting output. When Wget receives SIGHUP, but redirecting
73 the output fails, logging is inhibited. */
76 /* The file descriptor used for logging. This is NULL before log_init
77 is called; logging functions log to stderr then. log_init sets it
78 either to stderr or to a file pointer obtained from fopen(). If
79 logging is inhibited, logfp is set back to NULL. */
82 /* If non-zero, it means logging is inhibited, i.e. nothing is printed
84 static int inhibit_logging;
86 /* Whether the last output lines are stored for use as context. */
87 static int save_context_p;
89 /* Whether the log is flushed after each command. */
90 static int flush_log_p = 1;
92 /* Whether any output has been received while flush_log_p was 0. */
93 static int needs_flushing;
95 /* In the event of a hang-up, and if its output was on a TTY, Wget
96 redirects its output to `wget-log'.
98 For the convenience of reading this newly-created log, we store the
99 last several lines ("screenful", hence the choice of 24) of Wget
100 output, and dump them as context when the time comes. */
101 #define SAVED_LOG_LINES 24
103 /* log_lines is a circular buffer that stores SAVED_LOG_LINES lines of
104 output. log_line_current always points to the position in the
105 buffer that will be written to next. When log_line_current reaches
106 SAVED_LOG_LINES, it is reset to zero.
108 The problem here is that we'd have to either (re)allocate and free
109 strings all the time, or limit the lines to an arbitrary number of
110 characters. Instead of settling for either of these, we do both:
111 if the line is smaller than a certain "usual" line length (128
112 chars by default), a preallocated memory is used. The rare lines
113 that are longer than 128 characters are malloc'ed and freed
114 separately. This gives good performance with minimum memory
115 consumption and fragmentation. */
117 #define STATIC_LENGTH 128
119 static struct log_ln {
120 char static_line[STATIC_LENGTH + 1]; /* statically allocated
122 char *malloced_line; /* malloc'ed line, for lines of output
123 larger than 80 characters. */
124 char *content; /* this points either to malloced_line
125 or to the appropriate static_line.
126 If this is NULL, it means the line
127 has not yet been used. */
128 } log_lines[SAVED_LOG_LINES];
130 /* The current position in the ring. */
131 static int log_line_current = -1;
133 /* Whether the most recently written line was "trailing", i.e. did not
134 finish with \n. This is an important piece of information because
135 the code is always careful to append data to trailing lines, rather
136 than create new ones. */
137 static int trailing_line;
139 static void check_redirect_output PARAMS ((void));
141 #define ROT_ADVANCE(num) do { \
142 if (++num >= SAVED_LOG_LINES) \
146 /* Free the log line index with NUM. This calls free on
147 ln->malloced_line if it's non-NULL, and it also resets
148 ln->malloced_line and ln->content to NULL. */
151 free_log_line (int num)
153 struct log_ln *ln = log_lines + num;
154 if (ln->malloced_line)
156 xfree (ln->malloced_line);
157 ln->malloced_line = NULL;
162 /* Append bytes in the range [start, end) to one line in the log. The
163 region is not supposed to contain newlines, except for the last
164 character (at end[-1]). */
167 saved_append_1 (const char *start, const char *end)
169 int len = end - start;
173 /* First, check whether we need to append to an existing line or to
177 /* Create a new line. */
180 if (log_line_current == -1)
181 log_line_current = 0;
183 free_log_line (log_line_current);
184 ln = log_lines + log_line_current;
185 if (len > STATIC_LENGTH)
187 ln->malloced_line = strdupdelim (start, end);
188 ln->content = ln->malloced_line;
192 memcpy (ln->static_line, start, len);
193 ln->static_line[len] = '\0';
194 ln->content = ln->static_line;
199 /* Append to the last line. If the line is malloc'ed, we just
200 call realloc and append the new string. If the line is
201 static, we have to check whether appending the new string
202 would make it exceed STATIC_LENGTH characters, and if so,
203 convert it to malloc(). */
204 struct log_ln *ln = log_lines + log_line_current;
205 if (ln->malloced_line)
207 /* Resize malloc'ed line and append. */
208 int old_len = strlen (ln->malloced_line);
209 ln->malloced_line = xrealloc (ln->malloced_line, old_len + len + 1);
210 memcpy (ln->malloced_line + old_len, start, len);
211 ln->malloced_line[old_len + len] = '\0';
212 /* might have changed due to realloc */
213 ln->content = ln->malloced_line;
217 int old_len = strlen (ln->static_line);
218 if (old_len + len > STATIC_LENGTH)
220 /* Allocate memory and concatenate the old and the new
222 ln->malloced_line = xmalloc (old_len + len + 1);
223 memcpy (ln->malloced_line, ln->static_line,
225 memcpy (ln->malloced_line + old_len, start, len);
226 ln->malloced_line[old_len + len] = '\0';
227 ln->content = ln->malloced_line;
231 /* Just append to the old, statically allocated
233 memcpy (ln->static_line + old_len, start, len);
234 ln->static_line[old_len + len] = '\0';
235 ln->content = ln->static_line;
239 trailing_line = !(end[-1] == '\n');
241 ROT_ADVANCE (log_line_current);
244 /* Log the contents of S, as explained above. If S consists of
245 multiple lines, they are logged separately. If S does not end with
246 a newline, it will form a "trailing" line, to which things will get
247 appended the next time this function is called. */
250 saved_append (const char *s)
254 const char *end = strchr (s, '\n');
256 end = s + strlen (s);
259 saved_append_1 (s, end);
264 /* Check X against opt.verbose and opt.quiet. The semantics is as
267 * LOG_ALWAYS - print the message unconditionally;
269 * LOG_NOTQUIET - print the message if opt.quiet is non-zero;
271 * LOG_NONVERBOSE - print the message if opt.verbose is zero;
273 * LOG_VERBOSE - print the message if opt.verbose is non-zero. */
274 #define CHECK_VERBOSE(x) \
283 case LOG_NONVERBOSE: \
284 if (opt.verbose || opt.quiet) \
292 /* Returns the file descriptor for logging. This is LOGFP, except if
293 called before log_init, in which case it returns stderr. This is
294 useful in case someone calls a logging function before log_init.
296 If logging is inhibited, return NULL. */
308 /* Log a literal string S. The string is logged as-is, without a
312 logputs (enum log_options o, const char *s)
316 check_redirect_output ();
317 if (!(fp = get_log_fp ()))
330 struct logvprintf_state {
336 /* Print a message to the log. A copy of message will be saved to
337 saved_log, for later reusal by log_dump_context().
339 It is not possible to code this function in a "natural" way, using
340 a loop, because of the braindeadness of the varargs API.
341 Specifically, each call to vsnprintf() must be preceded by va_start
342 and followed by va_end. And this is possible only in the function
343 that contains the `...' declaration. The alternative would be to
344 use va_copy, but that's not portable. */
347 logvprintf (struct logvprintf_state *state, const char *fmt, va_list args)
350 char *write_ptr = smallmsg;
351 int available_size = sizeof (smallmsg);
353 FILE *fp = get_log_fp ();
357 /* In the simple case just call vfprintf(), to avoid needless
358 allocation and games with vsnprintf(). */
359 vfprintf (fp, fmt, args);
363 if (state->allocated != 0)
365 write_ptr = state->bigmsg;
366 available_size = state->allocated;
369 /* The GNU coding standards advise not to rely on the return value
370 of sprintf(). However, vsnprintf() is a relatively new function
371 missing from legacy systems. Therefore I consider it safe to
372 assume that its return value is meaningful. On the systems where
373 vsnprintf() is not available, we use the implementation from
374 snprintf.c which does return the correct value. */
375 numwritten = vsnprintf (write_ptr, available_size, fmt, args);
377 /* vsnprintf() will not step over the limit given by available_size.
378 If it fails, it will return either -1 (POSIX?) or the number of
379 characters that *would have* been written, if there had been
380 enough room. In the former case, we double the available_size
381 and malloc() to get a larger buffer, and try again. In the
382 latter case, we use the returned information to build a buffer of
385 if (numwritten == -1)
387 /* Writing failed, and we don't know the needed size. Try
388 again with doubled size. */
389 int newsize = available_size << 1;
390 state->bigmsg = xrealloc (state->bigmsg, newsize);
391 state->allocated = newsize;
394 else if (numwritten >= available_size)
396 /* Writing failed, but we know exactly how much space we
398 int newsize = numwritten + 1;
399 state->bigmsg = xrealloc (state->bigmsg, newsize);
400 state->allocated = newsize;
404 /* Writing succeeded. */
405 saved_append (write_ptr);
406 fputs (write_ptr, fp);
408 xfree (state->bigmsg);
419 /* Flush LOGFP. Useful while flushing is disabled. */
423 FILE *fp = get_log_fp ();
429 /* Enable or disable log flushing. */
431 log_set_flush (int flush)
433 if (flush == flush_log_p)
438 /* Disable flushing by setting flush_log_p to 0. */
443 /* Reenable flushing. If anything was printed in no-flush mode,
444 flush the log now. */
451 /* (Temporarily) disable storing log to memory. Returns the old
452 status of storing, with which this function can be called again to
453 reestablish storing. */
456 log_set_save_context (int savep)
458 int old = save_context_p;
459 save_context_p = savep;
463 #ifdef WGET_USE_STDARG
464 # define VA_START_1(arg1_type, arg1, args) va_start(args, arg1)
465 # define VA_START_2(arg1_type, arg1, arg2_type, arg2, args) va_start(args, arg2)
466 #else /* not WGET_USE_STDARG */
467 # define VA_START_1(arg1_type, arg1, args) do { \
469 arg1 = va_arg (args, arg1_type); \
471 # define VA_START_2(arg1_type, arg1, arg2_type, arg2, args) do { \
473 arg1 = va_arg (args, arg1_type); \
474 arg2 = va_arg (args, arg2_type); \
476 #endif /* not WGET_USE_STDARG */
478 /* Portability with pre-ANSI compilers makes these two functions look
481 #ifdef WGET_USE_STDARG
483 logprintf (enum log_options o, const char *fmt, ...)
484 #else /* not WGET_USE_STDARG */
488 #endif /* not WGET_USE_STDARG */
491 struct logvprintf_state lpstate;
494 #ifndef WGET_USE_STDARG
498 /* Perform a "dry run" of VA_START_2 to get the value of O. */
499 VA_START_2 (enum log_options, o, char *, fmt, args);
503 check_redirect_output ();
508 memset (&lpstate, '\0', sizeof (lpstate));
511 VA_START_2 (enum log_options, o, char *, fmt, args);
512 done = logvprintf (&lpstate, fmt, args);
519 /* The same as logprintf(), but does anything only if opt.debug is
521 #ifdef WGET_USE_STDARG
523 debug_logprintf (const char *fmt, ...)
524 #else /* not WGET_USE_STDARG */
526 debug_logprintf (va_alist)
528 #endif /* not WGET_USE_STDARG */
533 #ifndef WGET_USE_STDARG
536 struct logvprintf_state lpstate;
539 check_redirect_output ();
543 memset (&lpstate, '\0', sizeof (lpstate));
546 VA_START_1 (char *, fmt, args);
547 done = logvprintf (&lpstate, fmt, args);
555 /* Open FILE and set up a logging stream. If FILE cannot be opened,
556 exit with status of 1. */
558 log_init (const char *file, int appendp)
562 logfp = fopen (file, appendp ? "a" : "w");
565 perror (opt.lfilename);
571 /* The log goes to stderr to avoid collisions with the output if
572 the user specifies `-O -'. #### Francois Pinard suggests
573 that it's a better idea to print to stdout by default, and to
574 stderr only if the user actually specifies `-O -'. He says
575 this inconsistency is harder to document, but is overall
576 easier on the user. */
579 /* If the output is a TTY, enable storing, which will make Wget
580 remember all the printed messages, to be able to dump them to
581 a log file in case SIGHUP or SIGUSR1 is received (or
582 Ctrl+Break is pressed under Windows). */
585 && isatty (fileno (logfp))
594 /* Close LOGFP, inhibit further logging and free the memory associated
607 for (i = 0; i < SAVED_LOG_LINES; i++)
609 log_line_current = -1;
613 /* Dump saved lines to logfp. */
615 log_dump_context (void)
617 int num = log_line_current;
618 FILE *fp = get_log_fp ();
628 struct log_ln *ln = log_lines + num;
630 fputs (ln->content, fp);
633 while (num != log_line_current);
635 if (log_lines[log_line_current].content)
636 fputs (log_lines[log_line_current].content, fp);
640 /* When SIGHUP or SIGUSR1 are received, the output is redirected
641 elsewhere. Such redirection is only allowed once. */
642 enum { RR_NONE, RR_REQUESTED, RR_DONE } redirect_request = RR_NONE;
643 static const char *redirect_request_signal_name;
645 /* Redirect output to `wget-log'. */
648 redirect_output (void)
650 char *logfile = unique_name (DEFAULT_LOGFILE);
651 fprintf (stderr, _("\n%s received, redirecting output to `%s'.\n"),
652 redirect_request_signal_name, logfile);
653 logfp = fopen (logfile, "w");
656 /* Eek! Opening the alternate log file has failed. Nothing we
657 can do but disable printing completely. */
658 fprintf (stderr, _("%s: %s; disabling logging.\n"),
659 logfile, strerror (errno));
664 /* Dump the context output to the newly opened log. */
671 /* Check whether a signal handler requested the output to be
675 check_redirect_output (void)
677 if (redirect_request == RR_REQUESTED)
679 redirect_request = RR_DONE;
684 /* Request redirection at a convenient time. This may be called from
688 log_request_redirect_output (const char *signal_name)
690 if (redirect_request == RR_NONE && save_context_p)
691 /* Request output redirection. The request will be processed by
692 check_redirect_output(), which is called from entry point log
694 redirect_request = RR_REQUESTED;
695 redirect_request_signal_name = signal_name;