2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
3 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5 This file is part of GNU Wget.
7 GNU Wget is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 GNU Wget is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Wget. If not, see <http://www.gnu.org/licenses/>.
20 Additional permission under GNU GPL version 3 section 7
22 If you modify this program, or any covered work, by linking or
23 combining it with the OpenSSL project's OpenSSL library (or a
24 modified version of that library), containing parts covered by the
25 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
26 grants you additional permission to convey the resulting work.
27 Corresponding Source for a non-source form of such a combination
28 shall include the source code for the parts of OpenSSL used as well
29 as that of the covered work. */
45 VMS log files are often VFC record format, not stream, so fputs() can
46 produce multiple records, even when there's no newline terminator in
47 the buffer. The result is unsightly output with spurious newlines.
48 Using fprintf() instead of fputs(), along with inhibiting some
49 fflush() activity below, seems to solve the problem.
52 # define FPUTS( s, f) fprintf( (f), "%s", (s))
54 # define FPUTS( s, f) fputs( (s), (f))
55 #endif /* def __VMS [else] */
57 /* This file implements 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 /* A second file descriptor pointing to the temporary log file for the
83 WARC writer. If WARC writing is disabled, this is NULL. */
84 static FILE *warclogfp;
86 /* If true, it means logging is inhibited, i.e. nothing is printed or
88 static bool inhibit_logging;
90 /* Whether the last output lines are stored for use as context. */
91 static bool save_context_p;
93 /* Whether the log is flushed after each command. */
94 static bool flush_log_p = true;
96 /* Whether any output has been received while flush_log_p was 0. */
97 static bool needs_flushing;
99 /* In the event of a hang-up, and if its output was on a TTY, Wget
100 redirects its output to `wget-log'.
102 For the convenience of reading this newly-created log, we store the
103 last several lines ("screenful", hence the choice of 24) of Wget
104 output, and dump them as context when the time comes. */
105 #define SAVED_LOG_LINES 24
107 /* log_lines is a circular buffer that stores SAVED_LOG_LINES lines of
108 output. log_line_current always points to the position in the
109 buffer that will be written to next. When log_line_current reaches
110 SAVED_LOG_LINES, it is reset to zero.
112 The problem here is that we'd have to either (re)allocate and free
113 strings all the time, or limit the lines to an arbitrary number of
114 characters. Instead of settling for either of these, we do both:
115 if the line is smaller than a certain "usual" line length (128
116 chars by default), a preallocated memory is used. The rare lines
117 that are longer than 128 characters are malloc'ed and freed
118 separately. This gives good performance with minimum memory
119 consumption and fragmentation. */
121 #define STATIC_LENGTH 128
123 static struct log_ln {
124 char static_line[STATIC_LENGTH + 1]; /* statically allocated
126 char *malloced_line; /* malloc'ed line, for lines of output
127 larger than 80 characters. */
128 char *content; /* this points either to malloced_line
129 or to the appropriate static_line.
130 If this is NULL, it means the line
131 has not yet been used. */
132 } log_lines[SAVED_LOG_LINES];
134 /* The current position in the ring. */
135 static int log_line_current = -1;
137 /* Whether the most recently written line was "trailing", i.e. did not
138 finish with \n. This is an important piece of information because
139 the code is always careful to append data to trailing lines, rather
140 than create new ones. */
141 static bool trailing_line;
143 static void check_redirect_output (void);
145 #define ROT_ADVANCE(num) do { \
146 if (++num >= SAVED_LOG_LINES) \
150 /* Free the log line index with NUM. This calls free on
151 ln->malloced_line if it's non-NULL, and it also resets
152 ln->malloced_line and ln->content to NULL. */
155 free_log_line (int num)
157 struct log_ln *ln = log_lines + num;
158 if (ln->malloced_line)
160 xfree (ln->malloced_line);
161 ln->malloced_line = NULL;
166 /* Append bytes in the range [start, end) to one line in the log. The
167 region is not supposed to contain newlines, except for the last
168 character (at end[-1]). */
171 saved_append_1 (const char *start, const char *end)
173 int len = end - start;
177 /* First, check whether we need to append to an existing line or to
181 /* Create a new line. */
184 if (log_line_current == -1)
185 log_line_current = 0;
187 free_log_line (log_line_current);
188 ln = log_lines + log_line_current;
189 if (len > STATIC_LENGTH)
191 ln->malloced_line = strdupdelim (start, end);
192 ln->content = ln->malloced_line;
196 memcpy (ln->static_line, start, len);
197 ln->static_line[len] = '\0';
198 ln->content = ln->static_line;
203 /* Append to the last line. If the line is malloc'ed, we just
204 call realloc and append the new string. If the line is
205 static, we have to check whether appending the new string
206 would make it exceed STATIC_LENGTH characters, and if so,
207 convert it to malloc(). */
208 struct log_ln *ln = log_lines + log_line_current;
209 if (ln->malloced_line)
211 /* Resize malloc'ed line and append. */
212 int old_len = strlen (ln->malloced_line);
213 ln->malloced_line = xrealloc (ln->malloced_line, old_len + len + 1);
214 memcpy (ln->malloced_line + old_len, start, len);
215 ln->malloced_line[old_len + len] = '\0';
216 /* might have changed due to realloc */
217 ln->content = ln->malloced_line;
221 int old_len = strlen (ln->static_line);
222 if (old_len + len > STATIC_LENGTH)
224 /* Allocate memory and concatenate the old and the new
226 ln->malloced_line = xmalloc (old_len + len + 1);
227 memcpy (ln->malloced_line, ln->static_line,
229 memcpy (ln->malloced_line + old_len, start, len);
230 ln->malloced_line[old_len + len] = '\0';
231 ln->content = ln->malloced_line;
235 /* Just append to the old, statically allocated
237 memcpy (ln->static_line + old_len, start, len);
238 ln->static_line[old_len + len] = '\0';
239 ln->content = ln->static_line;
243 trailing_line = !(end[-1] == '\n');
245 ROT_ADVANCE (log_line_current);
248 /* Log the contents of S, as explained above. If S consists of
249 multiple lines, they are logged separately. If S does not end with
250 a newline, it will form a "trailing" line, to which things will get
251 appended the next time this function is called. */
254 saved_append (const char *s)
258 const char *end = strchr (s, '\n');
260 end = s + strlen (s);
263 saved_append_1 (s, end);
268 /* Check X against opt.verbose and opt.quiet. The semantics is as
271 * LOG_ALWAYS - print the message unconditionally;
273 * LOG_NOTQUIET - print the message if opt.quiet is non-zero;
275 * LOG_NONVERBOSE - print the message if opt.verbose is zero;
277 * LOG_VERBOSE - print the message if opt.verbose is non-zero. */
278 #define CHECK_VERBOSE(x) \
282 if (!opt.show_progress) \
291 case LOG_NONVERBOSE: \
292 if (opt.verbose || opt.quiet) \
300 /* Returns the file descriptor for logging. This is LOGFP, except if
301 called before log_init, in which case it returns stderr. This is
302 useful in case someone calls a logging function before log_init.
304 If logging is inhibited, return NULL. */
316 /* Returns the file descriptor for the secondary log file. This is
317 WARCLOGFP, except if called before log_init, in which case it
318 returns stderr. This is useful in case someone calls a logging
319 function before log_init.
321 If logging is inhibited, return NULL. */
324 get_warc_log_fp (void)
333 /* Sets the file descriptor for the secondary log file. */
336 log_set_warc_log_fp (FILE * fp)
341 /* Log a literal string S. The string is logged as-is, without a
345 logputs (enum log_options o, const char *s)
350 check_redirect_output ();
351 if ((fp = get_log_fp ()) == NULL)
353 warcfp = get_warc_log_fp ();
364 needs_flushing = true;
367 struct logvprintf_state {
373 /* Print a message to the log. A copy of message will be saved to
374 saved_log, for later reusal by log_dump_context().
376 Normally we'd want this function to loop around vsnprintf until
377 sufficient room is allocated, as the Linux man page recommends.
378 However each call to vsnprintf() must be preceded by va_start and
379 followed by va_end. Since calling va_start/va_end is possible only
380 in the function that contains the `...' declaration, we cannot call
381 vsnprintf more than once. Therefore this function saves its state
382 to logvprintf_state and signals the parent to call it again.
384 (An alternative approach would be to use va_copy, but that's not
388 log_vprintf_internal (struct logvprintf_state *state, const char *fmt,
392 char *write_ptr = smallmsg;
393 int available_size = sizeof (smallmsg);
395 FILE *fp = get_log_fp ();
396 FILE *warcfp = get_warc_log_fp ();
398 if (!save_context_p && warcfp == NULL)
400 /* In the simple case just call vfprintf(), to avoid needless
401 allocation and games with vsnprintf(). */
402 vfprintf (fp, fmt, args);
406 if (state->allocated != 0)
408 write_ptr = state->bigmsg;
409 available_size = state->allocated;
412 /* The GNU coding standards advise not to rely on the return value
413 of sprintf(). However, vsnprintf() is a relatively new function
414 missing from legacy systems. Therefore I consider it safe to
415 assume that its return value is meaningful. On the systems where
416 vsnprintf() is not available, we use the implementation from
417 snprintf.c which does return the correct value. */
418 numwritten = vsnprintf (write_ptr, available_size, fmt, args);
420 /* vsnprintf() will not step over the limit given by available_size.
421 If it fails, it returns either -1 (older implementations) or the
422 number of characters (not counting the terminating \0) that
423 *would have* been written if there had been enough room (C99).
424 In the former case, we double available_size and malloc to get a
425 larger buffer, and try again. In the latter case, we use the
426 returned information to build a buffer of the correct size. */
428 if (numwritten == -1)
430 /* Writing failed, and we don't know the needed size. Try
431 again with doubled size. */
432 int newsize = available_size << 1;
433 state->bigmsg = xrealloc (state->bigmsg, newsize);
434 state->allocated = newsize;
437 else if (numwritten >= available_size)
439 /* Writing failed, but we know exactly how much space we
441 int newsize = numwritten + 1;
442 state->bigmsg = xrealloc (state->bigmsg, newsize);
443 state->allocated = newsize;
447 /* Writing succeeded. */
449 saved_append (write_ptr);
450 FPUTS (write_ptr, fp);
452 FPUTS (write_ptr, warcfp);
454 xfree (state->bigmsg);
460 needs_flushing = true;
465 /* Flush LOGFP. Useful while flushing is disabled. */
469 FILE *fp = get_log_fp ();
470 FILE *warcfp = get_warc_log_fp ();
474 On VMS, flush only for a terminal. See note at FPUTS macro, above.
477 if (isatty( fileno( fp)))
481 #else /* def __VMS */
483 #endif /* def __VMS [else] */
489 needs_flushing = false;
492 /* Enable or disable log flushing. */
494 log_set_flush (bool flush)
496 if (flush == flush_log_p)
501 /* Disable flushing by setting flush_log_p to 0. */
506 /* Reenable flushing. If anything was printed in no-flush mode,
507 flush the log now. */
514 /* (Temporarily) disable storing log to memory. Returns the old
515 status of storing, with which this function can be called again to
516 reestablish storing. */
519 log_set_save_context (bool savep)
521 bool old = save_context_p;
522 save_context_p = savep;
526 /* Print a message to the screen or to the log. The first argument
527 defines the verbosity of the message, and the rest are as in
531 logprintf (enum log_options o, const char *fmt, ...)
534 struct logvprintf_state lpstate;
537 check_redirect_output ();
545 va_start (args, fmt);
546 done = log_vprintf_internal (&lpstate, fmt, args);
549 if (done && errno == EPIPE)
556 /* The same as logprintf(), but does anything only if opt.debug is
559 debug_logprintf (const char *fmt, ...)
564 struct logvprintf_state lpstate;
567 check_redirect_output ();
574 va_start (args, fmt);
575 done = log_vprintf_internal (&lpstate, fmt, args);
581 #endif /* ENABLE_DEBUG */
583 /* Open FILE and set up a logging stream. If FILE cannot be opened,
584 exit with status of 1. */
586 log_init (const char *file, bool appendp)
590 logfp = fopen (file, appendp ? "a" : "w");
593 fprintf (stderr, "%s: %s: %s\n", exec_name, file, strerror (errno));
599 /* The log goes to stderr to avoid collisions with the output if
600 the user specifies `-O -'. #### Francois Pinard suggests
601 that it's a better idea to print to stdout by default, and to
602 stderr only if the user actually specifies `-O -'. He says
603 this inconsistency is harder to document, but is overall
604 easier on the user. */
609 && isatty (fileno (logfp))
613 /* If the output is a TTY, enable save context, i.e. store
614 the most recent several messages ("context") and dump
615 them to a log file in case SIGHUP or SIGUSR1 is received
616 (or Ctrl+Break is pressed under Windows). */
617 save_context_p = true;
622 /* Close LOGFP (only if we opened it, not if it's stderr), inhibit
623 further logging and free the memory associated with it. */
629 if (logfp && (logfp != stderr))
632 inhibit_logging = true;
633 save_context_p = false;
635 for (i = 0; i < SAVED_LOG_LINES; i++)
637 log_line_current = -1;
638 trailing_line = false;
641 /* Dump saved lines to logfp. */
643 log_dump_context (void)
645 int num = log_line_current;
646 FILE *fp = get_log_fp ();
647 FILE *warcfp = get_warc_log_fp ();
657 struct log_ln *ln = log_lines + num;
660 FPUTS (ln->content, fp);
662 FPUTS (ln->content, warcfp);
666 while (num != log_line_current);
668 if (log_lines[log_line_current].content)
670 FPUTS (log_lines[log_line_current].content, fp);
672 FPUTS (log_lines[log_line_current].content, warcfp);
678 /* String escape functions. */
680 /* Return the number of non-printable characters in SOURCE.
681 Non-printable characters are determined as per c-ctype.c. */
684 count_nonprint (const char *source)
688 for (p = source, cnt = 0; *p; p++)
694 /* Copy SOURCE to DEST, escaping non-printable characters.
696 Non-printable refers to anything outside the non-control ASCII
697 range (32-126) which means that, for example, CR, LF, and TAB are
698 considered non-printable along with ESC, BS, and other control
699 chars. This is by design: it makes sure that messages from remote
700 servers cannot be easily used to deceive the users by mimicking
701 Wget's output. Disallowing non-ASCII characters is another
702 necessary security measure, which makes sure that remote servers
703 cannot garble the screen or guess the local charset and perform
706 Of course, the above mandates that escnonprint only be used in
707 contexts expected to be ASCII, such as when printing host names,
708 URL components, HTTP headers, FTP server messages, and the like.
710 ESCAPE is the leading character of the escape sequence. BASE
711 should be the base of the escape sequence, and must be either 8 for
714 DEST must point to a location with sufficient room to store an
715 encoded version of SOURCE. */
718 copy_and_escape (const char *source, char *dest, char escape, int base)
720 const char *from = source;
724 /* Copy chars from SOURCE to DEST, escaping non-printable ones. */
728 while ((c = *from++) != '\0')
734 *to++ = '0' + (c >> 6);
735 *to++ = '0' + ((c >> 3) & 7);
736 *to++ = '0' + (c & 7);
740 while ((c = *from++) != '\0')
746 *to++ = XNUM_TO_DIGIT (c >> 4);
747 *to++ = XNUM_TO_DIGIT (c & 0xf);
761 static struct ringel ring[RING_SIZE]; /* ring data */
764 escnonprint_internal (const char *str, char escape, int base)
766 static int ringpos; /* current ring position */
769 assert (base == 8 || base == 16);
771 nprcnt = count_nonprint (str);
773 /* If there are no non-printable chars in STR, don't bother
774 copying anything, just return STR. */
778 /* Set up a pointer to the current ring position, so we can write
779 simply r->X instead of ring[ringpos].X. */
780 struct ringel *r = ring + ringpos;
782 /* Every non-printable character is replaced with the escape char
783 and three (or two, depending on BASE) *additional* chars. Size
784 must also include the length of the original string and one
785 additional char for the terminating \0. */
786 int needed_size = strlen (str) + 1 + (base == 8 ? 3 * nprcnt : 2 * nprcnt);
788 /* If the current buffer is uninitialized or too small,
790 if (r->buffer == NULL || r->size < needed_size)
792 r->buffer = xrealloc (r->buffer, needed_size);
793 r->size = needed_size;
796 copy_and_escape (str, r->buffer, escape, base);
797 ringpos = (ringpos + 1) % RING_SIZE;
802 /* Return a pointer to a static copy of STR with the non-printable
803 characters escaped as \ooo. If there are no non-printable
804 characters in STR, STR is returned. See copy_and_escape for more
805 information on which characters are considered non-printable.
807 DON'T call this function on translated strings because escaping
808 will break them. Don't call it on literal strings from the source,
809 which are by definition trusted. If newlines are allowed in the
810 string, escape and print it line by line because escaping the whole
811 string will convert newlines to \012. (This is so that expectedly
812 single-line messages cannot use embedded newlines to mimic Wget's
813 output and deceive the user.)
815 escnonprint doesn't quote its escape character because it is notf
816 meant as a general and reversible quoting mechanism, but as a quick
817 way to defang binary junk sent by malicious or buggy servers.
819 NOTE: since this function can return a pointer to static data, be
820 careful to copy its result before calling it again. However, to be
821 more useful with printf, it maintains an internal ring of static
822 buffers to return. Currently the ring size is 3, which means you
823 can print up to three values in the same printf; if more is needed,
827 escnonprint (const char *str)
829 return escnonprint_internal (str, '\\', 8);
832 /* Return a pointer to a static copy of STR with the non-printable
833 characters escaped as %XX. If there are no non-printable
834 characters in STR, STR is returned.
836 See escnonprint for usage details. */
839 escnonprint_uri (const char *str)
841 return escnonprint_internal (str, '%', 16);
848 for (i = 0; i < countof (ring); i++)
849 xfree_null (ring[i].buffer);
852 /* When SIGHUP or SIGUSR1 are received, the output is redirected
853 elsewhere. Such redirection is only allowed once. */
854 static enum { RR_NONE, RR_REQUESTED, RR_DONE } redirect_request = RR_NONE;
855 static const char *redirect_request_signal_name;
857 /* Redirect output to `wget-log'. */
860 redirect_output (void)
863 logfp = unique_create (DEFAULT_LOGFILE, false, &logfile);
866 fprintf (stderr, _("\n%s received, redirecting output to %s.\n"),
867 redirect_request_signal_name, quote (logfile));
869 /* Dump the context output to the newly opened log. */
874 /* Eek! Opening the alternate log file has failed. Nothing we
875 can do but disable printing completely. */
876 fprintf (stderr, _("\n%s received.\n"), redirect_request_signal_name);
877 fprintf (stderr, _("%s: %s; disabling logging.\n"),
878 (logfile) ? logfile : DEFAULT_LOGFILE, strerror (errno));
879 inhibit_logging = true;
881 save_context_p = false;
884 /* Check whether a signal handler requested the output to be
888 check_redirect_output (void)
890 if (redirect_request == RR_REQUESTED)
892 redirect_request = RR_DONE;
897 /* Request redirection at a convenient time. This may be called from
901 log_request_redirect_output (const char *signal_name)
903 if (redirect_request == RR_NONE && save_context_p)
904 /* Request output redirection. The request will be processed by
905 check_redirect_output(), which is called from entry point log
907 redirect_request = RR_REQUESTED;
908 redirect_request_signal_name = signal_name;