2 Copyright (C) 1998-2006 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 3 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, see <http://www.gnu.org/licenses/>.
19 In addition, as a special exception, the Free Software Foundation
20 gives permission to link the code of its release of Wget with the
21 OpenSSL project's "OpenSSL" library (or with modified versions of it
22 that use the same license as the "OpenSSL" library), and distribute
23 the linked executables. You must obey the GNU General Public License
24 in all respects for all of the code used other than "OpenSSL". If you
25 modify this file, you may extend this exception to your version of the
26 file, but you are not obligated to do so. If you do not wish to do
27 so, delete this exception statement from your version. */
45 /* This file impplement support for "logging". Logging means printing
46 output, plus several additional features:
48 - Cataloguing output by importance. You can specify that a log
49 message is "verbose" or "debug", and it will not be printed unless
50 in verbose or debug mode, respectively.
52 - Redirecting the log to the file. When Wget's output goes to the
53 terminal, and Wget receives SIGHUP, all further output is
54 redirected to a log file. When this is the case, Wget can also
55 print the last several lines of "context" to the log file so that
56 it does not begin in the middle of a line. For this to work, the
57 logging code stores the last several lines of context. Callers may
58 request for certain output not to be stored.
60 - Inhibiting output. When Wget receives SIGHUP, but redirecting
61 the output fails, logging is inhibited. */
64 /* The file descriptor used for logging. This is NULL before log_init
65 is called; logging functions log to stderr then. log_init sets it
66 either to stderr or to a file pointer obtained from fopen(). If
67 logging is inhibited, logfp is set back to NULL. */
70 /* If true, it means logging is inhibited, i.e. nothing is printed or
72 static bool inhibit_logging;
74 /* Whether the last output lines are stored for use as context. */
75 static bool save_context_p;
77 /* Whether the log is flushed after each command. */
78 static bool flush_log_p = true;
80 /* Whether any output has been received while flush_log_p was 0. */
81 static bool needs_flushing;
83 /* In the event of a hang-up, and if its output was on a TTY, Wget
84 redirects its output to `wget-log'.
86 For the convenience of reading this newly-created log, we store the
87 last several lines ("screenful", hence the choice of 24) of Wget
88 output, and dump them as context when the time comes. */
89 #define SAVED_LOG_LINES 24
91 /* log_lines is a circular buffer that stores SAVED_LOG_LINES lines of
92 output. log_line_current always points to the position in the
93 buffer that will be written to next. When log_line_current reaches
94 SAVED_LOG_LINES, it is reset to zero.
96 The problem here is that we'd have to either (re)allocate and free
97 strings all the time, or limit the lines to an arbitrary number of
98 characters. Instead of settling for either of these, we do both:
99 if the line is smaller than a certain "usual" line length (128
100 chars by default), a preallocated memory is used. The rare lines
101 that are longer than 128 characters are malloc'ed and freed
102 separately. This gives good performance with minimum memory
103 consumption and fragmentation. */
105 #define STATIC_LENGTH 128
107 static struct log_ln {
108 char static_line[STATIC_LENGTH + 1]; /* statically allocated
110 char *malloced_line; /* malloc'ed line, for lines of output
111 larger than 80 characters. */
112 char *content; /* this points either to malloced_line
113 or to the appropriate static_line.
114 If this is NULL, it means the line
115 has not yet been used. */
116 } log_lines[SAVED_LOG_LINES];
118 /* The current position in the ring. */
119 static int log_line_current = -1;
121 /* Whether the most recently written line was "trailing", i.e. did not
122 finish with \n. This is an important piece of information because
123 the code is always careful to append data to trailing lines, rather
124 than create new ones. */
125 static bool trailing_line;
127 static void check_redirect_output (void);
129 #define ROT_ADVANCE(num) do { \
130 if (++num >= SAVED_LOG_LINES) \
134 /* Free the log line index with NUM. This calls free on
135 ln->malloced_line if it's non-NULL, and it also resets
136 ln->malloced_line and ln->content to NULL. */
139 free_log_line (int num)
141 struct log_ln *ln = log_lines + num;
142 if (ln->malloced_line)
144 xfree (ln->malloced_line);
145 ln->malloced_line = NULL;
150 /* Append bytes in the range [start, end) to one line in the log. The
151 region is not supposed to contain newlines, except for the last
152 character (at end[-1]). */
155 saved_append_1 (const char *start, const char *end)
157 int len = end - start;
161 /* First, check whether we need to append to an existing line or to
165 /* Create a new line. */
168 if (log_line_current == -1)
169 log_line_current = 0;
171 free_log_line (log_line_current);
172 ln = log_lines + log_line_current;
173 if (len > STATIC_LENGTH)
175 ln->malloced_line = strdupdelim (start, end);
176 ln->content = ln->malloced_line;
180 memcpy (ln->static_line, start, len);
181 ln->static_line[len] = '\0';
182 ln->content = ln->static_line;
187 /* Append to the last line. If the line is malloc'ed, we just
188 call realloc and append the new string. If the line is
189 static, we have to check whether appending the new string
190 would make it exceed STATIC_LENGTH characters, and if so,
191 convert it to malloc(). */
192 struct log_ln *ln = log_lines + log_line_current;
193 if (ln->malloced_line)
195 /* Resize malloc'ed line and append. */
196 int old_len = strlen (ln->malloced_line);
197 ln->malloced_line = xrealloc (ln->malloced_line, old_len + len + 1);
198 memcpy (ln->malloced_line + old_len, start, len);
199 ln->malloced_line[old_len + len] = '\0';
200 /* might have changed due to realloc */
201 ln->content = ln->malloced_line;
205 int old_len = strlen (ln->static_line);
206 if (old_len + len > STATIC_LENGTH)
208 /* Allocate memory and concatenate the old and the new
210 ln->malloced_line = xmalloc (old_len + len + 1);
211 memcpy (ln->malloced_line, ln->static_line,
213 memcpy (ln->malloced_line + old_len, start, len);
214 ln->malloced_line[old_len + len] = '\0';
215 ln->content = ln->malloced_line;
219 /* Just append to the old, statically allocated
221 memcpy (ln->static_line + old_len, start, len);
222 ln->static_line[old_len + len] = '\0';
223 ln->content = ln->static_line;
227 trailing_line = !(end[-1] == '\n');
229 ROT_ADVANCE (log_line_current);
232 /* Log the contents of S, as explained above. If S consists of
233 multiple lines, they are logged separately. If S does not end with
234 a newline, it will form a "trailing" line, to which things will get
235 appended the next time this function is called. */
238 saved_append (const char *s)
242 const char *end = strchr (s, '\n');
244 end = s + strlen (s);
247 saved_append_1 (s, end);
252 /* Check X against opt.verbose and opt.quiet. The semantics is as
255 * LOG_ALWAYS - print the message unconditionally;
257 * LOG_NOTQUIET - print the message if opt.quiet is non-zero;
259 * LOG_NONVERBOSE - print the message if opt.verbose is zero;
261 * LOG_VERBOSE - print the message if opt.verbose is non-zero. */
262 #define CHECK_VERBOSE(x) \
271 case LOG_NONVERBOSE: \
272 if (opt.verbose || opt.quiet) \
280 /* Returns the file descriptor for logging. This is LOGFP, except if
281 called before log_init, in which case it returns stderr. This is
282 useful in case someone calls a logging function before log_init.
284 If logging is inhibited, return NULL. */
296 /* Log a literal string S. The string is logged as-is, without a
300 logputs (enum log_options o, const char *s)
304 check_redirect_output ();
305 if ((fp = get_log_fp ()) == NULL)
315 needs_flushing = true;
318 struct logvprintf_state {
324 /* Print a message to the log. A copy of message will be saved to
325 saved_log, for later reusal by log_dump_context().
327 Normally we'd want this function to loop around vsnprintf until
328 sufficient room is allocated, as the Linux man page recommends.
329 However each call to vsnprintf() must be preceded by va_start and
330 followed by va_end. Since calling va_start/va_end is possible only
331 in the function that contains the `...' declaration, we cannot call
332 vsnprintf more than once. Therefore this function saves its state
333 to logvprintf_state and signals the parent to call it again.
335 (An alternative approach would be to use va_copy, but that's not
339 log_vprintf_internal (struct logvprintf_state *state, const char *fmt,
343 char *write_ptr = smallmsg;
344 int available_size = sizeof (smallmsg);
346 FILE *fp = get_log_fp ();
350 /* In the simple case just call vfprintf(), to avoid needless
351 allocation and games with vsnprintf(). */
352 vfprintf (fp, fmt, args);
356 if (state->allocated != 0)
358 write_ptr = state->bigmsg;
359 available_size = state->allocated;
362 /* The GNU coding standards advise not to rely on the return value
363 of sprintf(). However, vsnprintf() is a relatively new function
364 missing from legacy systems. Therefore I consider it safe to
365 assume that its return value is meaningful. On the systems where
366 vsnprintf() is not available, we use the implementation from
367 snprintf.c which does return the correct value. */
368 numwritten = vsnprintf (write_ptr, available_size, fmt, args);
370 /* vsnprintf() will not step over the limit given by available_size.
371 If it fails, it returns either -1 (older implementations) or the
372 number of characters (not counting the terminating \0) that
373 *would have* been written if there had been enough room (C99).
374 In the former case, we double available_size and malloc to get a
375 larger buffer, and try again. In the latter case, we use the
376 returned information to build a buffer of the correct size. */
378 if (numwritten == -1)
380 /* Writing failed, and we don't know the needed size. Try
381 again with doubled size. */
382 int newsize = available_size << 1;
383 state->bigmsg = xrealloc (state->bigmsg, newsize);
384 state->allocated = newsize;
387 else if (numwritten >= available_size)
389 /* Writing failed, but we know exactly how much space we
391 int newsize = numwritten + 1;
392 state->bigmsg = xrealloc (state->bigmsg, newsize);
393 state->allocated = newsize;
397 /* Writing succeeded. */
398 saved_append (write_ptr);
399 fputs (write_ptr, fp);
401 xfree (state->bigmsg);
407 needs_flushing = true;
412 /* Flush LOGFP. Useful while flushing is disabled. */
416 FILE *fp = get_log_fp ();
419 needs_flushing = false;
422 /* Enable or disable log flushing. */
424 log_set_flush (bool flush)
426 if (flush == flush_log_p)
431 /* Disable flushing by setting flush_log_p to 0. */
436 /* Reenable flushing. If anything was printed in no-flush mode,
437 flush the log now. */
444 /* (Temporarily) disable storing log to memory. Returns the old
445 status of storing, with which this function can be called again to
446 reestablish storing. */
449 log_set_save_context (bool savep)
451 bool old = save_context_p;
452 save_context_p = savep;
456 /* Print a message to the screen or to the log. The first argument
457 defines the verbosity of the message, and the rest are as in
461 logprintf (enum log_options o, const char *fmt, ...)
464 struct logvprintf_state lpstate;
467 check_redirect_output ();
475 va_start (args, fmt);
476 done = log_vprintf_internal (&lpstate, fmt, args);
483 /* The same as logprintf(), but does anything only if opt.debug is
486 debug_logprintf (const char *fmt, ...)
491 struct logvprintf_state lpstate;
494 check_redirect_output ();
501 va_start (args, fmt);
502 done = log_vprintf_internal (&lpstate, fmt, args);
508 #endif /* ENABLE_DEBUG */
510 /* Open FILE and set up a logging stream. If FILE cannot be opened,
511 exit with status of 1. */
513 log_init (const char *file, bool appendp)
517 logfp = fopen (file, appendp ? "a" : "w");
520 fprintf (stderr, "%s: %s: %s\n", exec_name, file, strerror (errno));
526 /* The log goes to stderr to avoid collisions with the output if
527 the user specifies `-O -'. #### Francois Pinard suggests
528 that it's a better idea to print to stdout by default, and to
529 stderr only if the user actually specifies `-O -'. He says
530 this inconsistency is harder to document, but is overall
531 easier on the user. */
536 && isatty (fileno (logfp))
540 /* If the output is a TTY, enable save context, i.e. store
541 the most recent several messages ("context") and dump
542 them to a log file in case SIGHUP or SIGUSR1 is received
543 (or Ctrl+Break is pressed under Windows). */
544 save_context_p = true;
549 /* Close LOGFP, inhibit further logging and free the memory associated
559 inhibit_logging = true;
560 save_context_p = false;
562 for (i = 0; i < SAVED_LOG_LINES; i++)
564 log_line_current = -1;
565 trailing_line = false;
568 /* Dump saved lines to logfp. */
570 log_dump_context (void)
572 int num = log_line_current;
573 FILE *fp = get_log_fp ();
583 struct log_ln *ln = log_lines + num;
585 fputs (ln->content, fp);
588 while (num != log_line_current);
590 if (log_lines[log_line_current].content)
591 fputs (log_lines[log_line_current].content, fp);
595 /* String escape functions. */
597 /* Return the number of non-printable characters in SOURCE.
598 Non-printable characters are determined as per safe-ctype.c. */
601 count_nonprint (const char *source)
605 for (p = source, cnt = 0; *p; p++)
611 /* Copy SOURCE to DEST, escaping non-printable characters.
613 Non-printable refers to anything outside the non-control ASCII
614 range (32-126) which means that, for example, CR, LF, and TAB are
615 considered non-printable along with ESC, BS, and other control
616 chars. This is by design: it makes sure that messages from remote
617 servers cannot be easily used to deceive the users by mimicking
618 Wget's output. Disallowing non-ASCII characters is another
619 necessary security measure, which makes sure that remote servers
620 cannot garble the screen or guess the local charset and perform
623 Of course, the above mandates that escnonprint only be used in
624 contexts expected to be ASCII, such as when printing host names,
625 URL components, HTTP headers, FTP server messages, and the like.
627 ESCAPE is the leading character of the escape sequence. BASE
628 should be the base of the escape sequence, and must be either 8 for
631 DEST must point to a location with sufficient room to store an
632 encoded version of SOURCE. */
635 copy_and_escape (const char *source, char *dest, char escape, int base)
637 const char *from = source;
641 /* Copy chars from SOURCE to DEST, escaping non-printable ones. */
645 while ((c = *from++) != '\0')
651 *to++ = '0' + (c >> 6);
652 *to++ = '0' + ((c >> 3) & 7);
653 *to++ = '0' + (c & 7);
657 while ((c = *from++) != '\0')
663 *to++ = XNUM_TO_DIGIT (c >> 4);
664 *to++ = XNUM_TO_DIGIT (c & 0xf);
678 static struct ringel ring[RING_SIZE]; /* ring data */
681 escnonprint_internal (const char *str, char escape, int base)
683 static int ringpos; /* current ring position */
686 assert (base == 8 || base == 16);
688 nprcnt = count_nonprint (str);
690 /* If there are no non-printable chars in STR, don't bother
691 copying anything, just return STR. */
695 /* Set up a pointer to the current ring position, so we can write
696 simply r->X instead of ring[ringpos].X. */
697 struct ringel *r = ring + ringpos;
699 /* Every non-printable character is replaced with the escape char
700 and three (or two, depending on BASE) *additional* chars. Size
701 must also include the length of the original string and one
702 additional char for the terminating \0. */
703 int needed_size = strlen (str) + 1 + (base == 8 ? 3 * nprcnt : 2 * nprcnt);
705 /* If the current buffer is uninitialized or too small,
707 if (r->buffer == NULL || r->size < needed_size)
709 r->buffer = xrealloc (r->buffer, needed_size);
710 r->size = needed_size;
713 copy_and_escape (str, r->buffer, escape, base);
714 ringpos = (ringpos + 1) % RING_SIZE;
719 /* Return a pointer to a static copy of STR with the non-printable
720 characters escaped as \ooo. If there are no non-printable
721 characters in STR, STR is returned. See copy_and_escape for more
722 information on which characters are considered non-printable.
724 DON'T call this function on translated strings because escaping
725 will break them. Don't call it on literal strings from the source,
726 which are by definition trusted. If newlines are allowed in the
727 string, escape and print it line by line because escaping the whole
728 string will convert newlines to \012. (This is so that expectedly
729 single-line messages cannot use embedded newlines to mimic Wget's
730 output and deceive the user.)
732 escnonprint doesn't quote its escape character because it is notf
733 meant as a general and reversible quoting mechanism, but as a quick
734 way to defang binary junk sent by malicious or buggy servers.
736 NOTE: since this function can return a pointer to static data, be
737 careful to copy its result before calling it again. However, to be
738 more useful with printf, it maintains an internal ring of static
739 buffers to return. Currently the ring size is 3, which means you
740 can print up to three values in the same printf; if more is needed,
744 escnonprint (const char *str)
746 return escnonprint_internal (str, '\\', 8);
749 /* Return a pointer to a static copy of STR with the non-printable
750 characters escaped as %XX. If there are no non-printable
751 characters in STR, STR is returned.
753 See escnonprint for usage details. */
756 escnonprint_uri (const char *str)
758 return escnonprint_internal (str, '%', 16);
765 for (i = 0; i < countof (ring); i++)
766 xfree_null (ring[i].buffer);
769 /* When SIGHUP or SIGUSR1 are received, the output is redirected
770 elsewhere. Such redirection is only allowed once. */
771 static enum { RR_NONE, RR_REQUESTED, RR_DONE } redirect_request = RR_NONE;
772 static const char *redirect_request_signal_name;
774 /* Redirect output to `wget-log'. */
777 redirect_output (void)
780 logfp = unique_create (DEFAULT_LOGFILE, false, &logfile);
783 fprintf (stderr, _("\n%s received, redirecting output to `%s'.\n"),
784 redirect_request_signal_name, logfile);
786 /* Dump the context output to the newly opened log. */
791 /* Eek! Opening the alternate log file has failed. Nothing we
792 can do but disable printing completely. */
793 fprintf (stderr, _("\n%s received.\n"), redirect_request_signal_name);
794 fprintf (stderr, _("%s: %s; disabling logging.\n"),
795 logfile, strerror (errno));
796 inhibit_logging = true;
798 save_context_p = false;
801 /* Check whether a signal handler requested the output to be
805 check_redirect_output (void)
807 if (redirect_request == RR_REQUESTED)
809 redirect_request = RR_DONE;
814 /* Request redirection at a convenient time. This may be called from
818 log_request_redirect_output (const char *signal_name)
820 if (redirect_request == RR_NONE && save_context_p)
821 /* Request output redirection. The request will be processed by
822 check_redirect_output(), which is called from entry point log
824 redirect_request = RR_REQUESTED;
825 redirect_request_signal_name = signal_name;