2 Copyright (C) 2005 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.
20 In addition, as a special exception, the Free Software Foundation
21 gives permission to link the code of its release of Wget with the
22 OpenSSL project's "OpenSSL" library (or with modified versions of it
23 that use the same license as the "OpenSSL" library), and distribute
24 the linked executables. You must obey the GNU General Public License
25 in all respects for all of the code used other than "OpenSSL". If you
26 modify this file, you may extend this exception to your version of the
27 file, but you are not obligated to do so. If you do not wish to do
28 so, delete this exception statement from your version. */
39 #ifdef WGET_USE_STDARG
58 /* This file impplement support for "logging". Logging means printing
59 output, plus several additional features:
61 - Cataloguing output by importance. You can specify that a log
62 message is "verbose" or "debug", and it will not be printed unless
63 in verbose or debug mode, respectively.
65 - Redirecting the log to the file. When Wget's output goes to the
66 terminal, and Wget receives SIGHUP, all further output is
67 redirected to a log file. When this is the case, Wget can also
68 print the last several lines of "context" to the log file so that
69 it does not begin in the middle of a line. For this to work, the
70 logging code stores the last several lines of context. Callers may
71 request for certain output not to be stored.
73 - Inhibiting output. When Wget receives SIGHUP, but redirecting
74 the output fails, logging is inhibited. */
77 /* The file descriptor used for logging. This is NULL before log_init
78 is called; logging functions log to stderr then. log_init sets it
79 either to stderr or to a file pointer obtained from fopen(). If
80 logging is inhibited, logfp is set back to NULL. */
83 /* If non-zero, it means logging is inhibited, i.e. nothing is printed
85 static int inhibit_logging;
87 /* Whether the last output lines are stored for use as context. */
88 static int save_context_p;
90 /* Whether the log is flushed after each command. */
91 static int flush_log_p = 1;
93 /* Whether any output has been received while flush_log_p was 0. */
94 static int needs_flushing;
96 /* In the event of a hang-up, and if its output was on a TTY, Wget
97 redirects its output to `wget-log'.
99 For the convenience of reading this newly-created log, we store the
100 last several lines ("screenful", hence the choice of 24) of Wget
101 output, and dump them as context when the time comes. */
102 #define SAVED_LOG_LINES 24
104 /* log_lines is a circular buffer that stores SAVED_LOG_LINES lines of
105 output. log_line_current always points to the position in the
106 buffer that will be written to next. When log_line_current reaches
107 SAVED_LOG_LINES, it is reset to zero.
109 The problem here is that we'd have to either (re)allocate and free
110 strings all the time, or limit the lines to an arbitrary number of
111 characters. Instead of settling for either of these, we do both:
112 if the line is smaller than a certain "usual" line length (128
113 chars by default), a preallocated memory is used. The rare lines
114 that are longer than 128 characters are malloc'ed and freed
115 separately. This gives good performance with minimum memory
116 consumption and fragmentation. */
118 #define STATIC_LENGTH 128
120 static struct log_ln {
121 char static_line[STATIC_LENGTH + 1]; /* statically allocated
123 char *malloced_line; /* malloc'ed line, for lines of output
124 larger than 80 characters. */
125 char *content; /* this points either to malloced_line
126 or to the appropriate static_line.
127 If this is NULL, it means the line
128 has not yet been used. */
129 } log_lines[SAVED_LOG_LINES];
131 /* The current position in the ring. */
132 static int log_line_current = -1;
134 /* Whether the most recently written line was "trailing", i.e. did not
135 finish with \n. This is an important piece of information because
136 the code is always careful to append data to trailing lines, rather
137 than create new ones. */
138 static int trailing_line;
140 static void check_redirect_output PARAMS ((void));
142 #define ROT_ADVANCE(num) do { \
143 if (++num >= SAVED_LOG_LINES) \
147 /* Free the log line index with NUM. This calls free on
148 ln->malloced_line if it's non-NULL, and it also resets
149 ln->malloced_line and ln->content to NULL. */
152 free_log_line (int num)
154 struct log_ln *ln = log_lines + num;
155 if (ln->malloced_line)
157 xfree (ln->malloced_line);
158 ln->malloced_line = NULL;
163 /* Append bytes in the range [start, end) to one line in the log. The
164 region is not supposed to contain newlines, except for the last
165 character (at end[-1]). */
168 saved_append_1 (const char *start, const char *end)
170 int len = end - start;
174 /* First, check whether we need to append to an existing line or to
178 /* Create a new line. */
181 if (log_line_current == -1)
182 log_line_current = 0;
184 free_log_line (log_line_current);
185 ln = log_lines + log_line_current;
186 if (len > STATIC_LENGTH)
188 ln->malloced_line = strdupdelim (start, end);
189 ln->content = ln->malloced_line;
193 memcpy (ln->static_line, start, len);
194 ln->static_line[len] = '\0';
195 ln->content = ln->static_line;
200 /* Append to the last line. If the line is malloc'ed, we just
201 call realloc and append the new string. If the line is
202 static, we have to check whether appending the new string
203 would make it exceed STATIC_LENGTH characters, and if so,
204 convert it to malloc(). */
205 struct log_ln *ln = log_lines + log_line_current;
206 if (ln->malloced_line)
208 /* Resize malloc'ed line and append. */
209 int old_len = strlen (ln->malloced_line);
210 ln->malloced_line = xrealloc (ln->malloced_line, old_len + len + 1);
211 memcpy (ln->malloced_line + old_len, start, len);
212 ln->malloced_line[old_len + len] = '\0';
213 /* might have changed due to realloc */
214 ln->content = ln->malloced_line;
218 int old_len = strlen (ln->static_line);
219 if (old_len + len > STATIC_LENGTH)
221 /* Allocate memory and concatenate the old and the new
223 ln->malloced_line = (char *)xmalloc (old_len + len + 1);
224 memcpy (ln->malloced_line, ln->static_line,
226 memcpy (ln->malloced_line + old_len, start, len);
227 ln->malloced_line[old_len + len] = '\0';
228 ln->content = ln->malloced_line;
232 /* Just append to the old, statically allocated
234 memcpy (ln->static_line + old_len, start, len);
235 ln->static_line[old_len + len] = '\0';
236 ln->content = ln->static_line;
240 trailing_line = !(end[-1] == '\n');
242 ROT_ADVANCE (log_line_current);
245 /* Log the contents of S, as explained above. If S consists of
246 multiple lines, they are logged separately. If S does not end with
247 a newline, it will form a "trailing" line, to which things will get
248 appended the next time this function is called. */
251 saved_append (const char *s)
255 const char *end = strchr (s, '\n');
257 end = s + strlen (s);
260 saved_append_1 (s, end);
265 /* Check X against opt.verbose and opt.quiet. The semantics is as
268 * LOG_ALWAYS - print the message unconditionally;
270 * LOG_NOTQUIET - print the message if opt.quiet is non-zero;
272 * LOG_NONVERBOSE - print the message if opt.verbose is zero;
274 * LOG_VERBOSE - print the message if opt.verbose is non-zero. */
275 #define CHECK_VERBOSE(x) \
284 case LOG_NONVERBOSE: \
285 if (opt.verbose || opt.quiet) \
293 /* Returns the file descriptor for logging. This is LOGFP, except if
294 called before log_init, in which case it returns stderr. This is
295 useful in case someone calls a logging function before log_init.
297 If logging is inhibited, return NULL. */
309 /* Log a literal string S. The string is logged as-is, without a
313 logputs (enum log_options o, const char *s)
317 check_redirect_output ();
318 if ((fp = get_log_fp ()) == NULL)
331 struct logvprintf_state {
337 /* Print a message to the log. A copy of message will be saved to
338 saved_log, for later reusal by log_dump_context().
340 Normally we'd want this function to loop around vsnprintf until
341 sufficient room is allocated, as the Linux man page recommends.
342 However each call to vsnprintf() must be preceded by va_start and
343 followed by va_end. Since calling va_start/va_end is possible only
344 in the function that contains the `...' declaration, we cannot call
345 vsnprintf more than once. Therefore this function saves its state
346 to logvprintf_state and signals the parent to call it again.
348 (An alternative approach would be to use va_copy, but that's not
352 log_vprintf_internal (struct logvprintf_state *state, const char *fmt,
356 char *write_ptr = smallmsg;
357 int available_size = sizeof (smallmsg);
359 FILE *fp = get_log_fp ();
363 /* In the simple case just call vfprintf(), to avoid needless
364 allocation and games with vsnprintf(). */
365 vfprintf (fp, fmt, args);
369 if (state->allocated != 0)
371 write_ptr = state->bigmsg;
372 available_size = state->allocated;
375 /* The GNU coding standards advise not to rely on the return value
376 of sprintf(). However, vsnprintf() is a relatively new function
377 missing from legacy systems. Therefore I consider it safe to
378 assume that its return value is meaningful. On the systems where
379 vsnprintf() is not available, we use the implementation from
380 snprintf.c which does return the correct value. */
381 numwritten = vsnprintf (write_ptr, available_size, fmt, args);
383 /* vsnprintf() will not step over the limit given by available_size.
384 If it fails, it will return either -1 (POSIX?) or the number of
385 characters that *would have* been written, if there had been
386 enough room (C99). In the former case, we double the
387 available_size and malloc to get a larger buffer, and try again.
388 In the latter case, we use the returned information to build a
389 buffer of the correct size. */
391 if (numwritten == -1)
393 /* Writing failed, and we don't know the needed size. Try
394 again with doubled size. */
395 int newsize = available_size << 1;
396 state->bigmsg = xrealloc (state->bigmsg, newsize);
397 state->allocated = newsize;
400 else if (numwritten >= available_size)
402 /* Writing failed, but we know exactly how much space we
404 int newsize = numwritten + 1;
405 state->bigmsg = xrealloc (state->bigmsg, newsize);
406 state->allocated = newsize;
410 /* Writing succeeded. */
411 saved_append (write_ptr);
412 fputs (write_ptr, fp);
414 xfree (state->bigmsg);
425 /* Flush LOGFP. Useful while flushing is disabled. */
429 FILE *fp = get_log_fp ();
435 /* Enable or disable log flushing. */
437 log_set_flush (int flush)
439 if (flush == flush_log_p)
444 /* Disable flushing by setting flush_log_p to 0. */
449 /* Reenable flushing. If anything was printed in no-flush mode,
450 flush the log now. */
457 /* (Temporarily) disable storing log to memory. Returns the old
458 status of storing, with which this function can be called again to
459 reestablish storing. */
462 log_set_save_context (int savep)
464 int old = save_context_p;
465 save_context_p = savep;
469 /* Handle difference in va_start between pre-ANSI and ANSI C. Note
470 that we always use `...' in function definitions and let ansi2knr
471 convert it for us. */
473 #ifdef WGET_USE_STDARG
474 # define VA_START(args, arg1) va_start (args, arg1)
476 # define VA_START(args, ignored) va_start (args)
479 /* Print a message to the screen or to the log. The first argument
480 defines the verbosity of the message, and the rest are as in
484 logprintf (enum log_options o, const char *fmt, ...)
487 struct logvprintf_state lpstate;
490 check_redirect_output ();
498 VA_START (args, fmt);
499 done = log_vprintf_internal (&lpstate, fmt, args);
506 /* The same as logprintf(), but does anything only if opt.debug is
509 debug_logprintf (const char *fmt, ...)
514 struct logvprintf_state lpstate;
517 check_redirect_output ();
524 VA_START (args, fmt);
525 done = log_vprintf_internal (&lpstate, fmt, args);
531 #endif /* ENABLE_DEBUG */
533 /* Open FILE and set up a logging stream. If FILE cannot be opened,
534 exit with status of 1. */
536 log_init (const char *file, int appendp)
540 logfp = fopen (file, appendp ? "a" : "w");
543 fprintf (stderr, "%s: %s: %s\n", exec_name, file, strerror (errno));
549 /* The log goes to stderr to avoid collisions with the output if
550 the user specifies `-O -'. #### Francois Pinard suggests
551 that it's a better idea to print to stdout by default, and to
552 stderr only if the user actually specifies `-O -'. He says
553 this inconsistency is harder to document, but is overall
554 easier on the user. */
559 && isatty (fileno (logfp))
563 /* If the output is a TTY, enable save context, i.e. store
564 the most recent several messages ("context") and dump
565 them to a log file in case SIGHUP or SIGUSR1 is received
566 (or Ctrl+Break is pressed under Windows). */
572 /* Close LOGFP, inhibit further logging and free the memory associated
585 for (i = 0; i < SAVED_LOG_LINES; i++)
587 log_line_current = -1;
591 /* Dump saved lines to logfp. */
593 log_dump_context (void)
595 int num = log_line_current;
596 FILE *fp = get_log_fp ();
606 struct log_ln *ln = log_lines + num;
608 fputs (ln->content, fp);
611 while (num != log_line_current);
613 if (log_lines[log_line_current].content)
614 fputs (log_lines[log_line_current].content, fp);
618 /* String escape functions. */
620 /* Return the number of non-printable characters in SOURCE.
621 Non-printable characters are determined as per safe-ctype.c. */
624 count_nonprint (const char *source)
628 for (p = source, cnt = 0; *p; p++)
634 /* Copy SOURCE to DEST, escaping non-printable characters.
636 Non-printable refers to anything outside the non-control ASCII
637 range (32-126) which means that, for example, CR, LF, and TAB are
638 considered non-printable along with ESC, BS, and other control
639 chars. This is by design: it makes sure that messages from remote
640 servers cannot be easily used to deceive the users by mimicking
641 Wget's output. Disallowing non-ASCII characters is another
642 necessary security measure, which makes sure that remote servers
643 cannot garble the screen or guess the local charset and perform
646 Of course, the above mandates that escnonprint only be used in
647 contexts expected to be ASCII, such as when printing host names,
648 URL components, HTTP headers, FTP server messages, and the like.
650 ESCAPE is the leading character of the escape sequence. BASE
651 should be the base of the escape sequence, and must be either 8 for
654 DEST must point to a location with sufficient room to store an
655 encoded version of SOURCE. */
658 copy_and_escape (const char *source, char *dest, char escape, int base)
660 const char *from = source;
664 /* Copy chars from SOURCE to DEST, escaping non-printable ones. */
668 while ((c = *from++) != '\0')
674 *to++ = '0' + (c >> 6);
675 *to++ = '0' + ((c >> 3) & 7);
676 *to++ = '0' + (c & 7);
680 while ((c = *from++) != '\0')
686 *to++ = XNUM_TO_DIGIT (c >> 4);
687 *to++ = XNUM_TO_DIGIT (c & 0xf);
701 static struct ringel ring[RING_SIZE]; /* ring data */
704 escnonprint_internal (const char *str, char escape, int base)
706 static int ringpos; /* current ring position */
708 assert (base == 8 || base == 16);
710 int nprcnt = count_nonprint (str);
712 /* If there are no non-printable chars in STR, don't bother
713 copying anything, just return STR. */
717 /* Set up a pointer to the current ring position, so we can write
718 simply r->X instead of ring[ringpos].X. */
719 struct ringel *r = ring + ringpos;
721 /* Every non-printable character is replaced with the escape char
722 and three (or two, depending on BASE) *additional* chars. Size
723 must also include the length of the original string and one
724 additional char for the terminating \0. */
725 int needed_size = strlen (str) + 1 + (base == 8 ? 3 * nprcnt : 2 * nprcnt);
727 /* If the current buffer is uninitialized or too small,
729 if (r->buffer == NULL || r->size < needed_size)
731 r->buffer = xrealloc (r->buffer, needed_size);
732 r->size = needed_size;
735 copy_and_escape (str, r->buffer, escape, base);
736 ringpos = (ringpos + 1) % RING_SIZE;
741 /* Return a pointer to a static copy of STR with the non-printable
742 characters escaped as \ooo. If there are no non-printable
743 characters in STR, STR is returned. See copy_and_escape for more
744 information on which characters are considered non-printable.
746 NOTE: since this function can return a pointer to static data, be
747 careful to copy its result before calling it again. However, to be
748 more useful with printf, it maintains an internal ring of static
749 buffers to return. Currently the ring size is 3, which means you
750 can print up to three values in the same printf; if more is needed,
754 escnonprint (const char *str)
756 return escnonprint_internal (str, '\\', 8);
759 /* Return a pointer to a static copy of STR with the non-printable
760 characters escaped as %XX. If there are no non-printable
761 characters in STR, STR is returned. See copy_and_escape for more
762 information on which characters are considered non-printable.
764 This function returns a pointer to static data which will be
765 overwritten by subsequent calls -- see escnonprint for details. */
768 escnonprint_uri (const char *str)
770 return escnonprint_internal (str, '%', 16);
777 for (i = 0; i < countof (ring); i++)
778 xfree_null (ring[i].buffer);
781 /* When SIGHUP or SIGUSR1 are received, the output is redirected
782 elsewhere. Such redirection is only allowed once. */
783 enum { RR_NONE, RR_REQUESTED, RR_DONE } redirect_request = RR_NONE;
784 static const char *redirect_request_signal_name;
786 /* Redirect output to `wget-log'. */
789 redirect_output (void)
792 logfp = unique_create (DEFAULT_LOGFILE, 0, &logfile);
795 fprintf (stderr, _("\n%s received, redirecting output to `%s'.\n"),
796 redirect_request_signal_name, logfile);
798 /* Dump the context output to the newly opened log. */
803 /* Eek! Opening the alternate log file has failed. Nothing we
804 can do but disable printing completely. */
805 fprintf (stderr, _("\n%s received.\n"), redirect_request_signal_name);
806 fprintf (stderr, _("%s: %s; disabling logging.\n"),
807 logfile, strerror (errno));
813 /* Check whether a signal handler requested the output to be
817 check_redirect_output (void)
819 if (redirect_request == RR_REQUESTED)
821 redirect_request = RR_DONE;
826 /* Request redirection at a convenient time. This may be called from
830 log_request_redirect_output (const char *signal_name)
832 if (redirect_request == RR_NONE && save_context_p)
833 /* Request output redirection. The request will be processed by
834 check_redirect_output(), which is called from entry point log
836 redirect_request = RR_REQUESTED;
837 redirect_request_signal_name = signal_name;