/* Messages logging.
- Copyright (C) 1998 Free Software Foundation, Inc.
+ Copyright (C) 1998, 2000, 2001 Free Software Foundation, Inc.
-This file is part of Wget.
+This file is part of GNU Wget.
-This program is free software; you can redistribute it and/or modify
+GNU Wget is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
-This program is distributed in the hope that it will be useful,
+GNU Wget is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with Wget; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+In addition, as a special exception, the Free Software Foundation
+gives permission to link the code of its release of Wget with the
+OpenSSL project's "OpenSSL" library (or with modified versions of it
+that use the same license as the "OpenSSL" library), and distribute
+the linked executables. You must obey the GNU General Public License
+in all respects for all of the code used other than "OpenSSL". If you
+modify this file, you may extend this exception to your version of the
+file, but you are not obligated to do so. If you do not wish to do
+so, delete this exception statement from your version. */
#include <config.h>
+/* This allows the architecture-specific .h files to specify the use
+ of stdargs regardless of __STDC__. */
+#ifndef WGET_USE_STDARG
+/* Use stdarg only if the compiler supports ANSI C and stdarg.h is
+ present. We check for both because there are configurations where
+ stdarg.h exists, but doesn't work. */
+# ifdef __STDC__
+# ifdef HAVE_STDARG_H
+# define WGET_USE_STDARG
+# endif
+# endif
+#endif /* not WGET_USE_STDARG */
+
#include <stdio.h>
#ifdef HAVE_STRING_H
# include <string.h>
# include <strings.h>
#endif
#include <stdlib.h>
-#ifdef HAVE_STDARG_H
-# define WGET_USE_STDARG
+#ifdef WGET_USE_STDARG
# include <stdarg.h>
#else
# include <varargs.h>
#include "wget.h"
#include "utils.h"
+#include "log.h"
#ifndef errno
extern int errno;
#endif
-\f
-/* The file descriptor used for logging. */
+/* This file impplement support for "logging". Logging means printing
+ output, plus several additional features:
+
+ - Cataloguing output by importance. You can specify that a log
+ message is "verbose" or "debug", and it will not be printed unless
+ in verbose or debug mode, respectively.
+
+ - Redirecting the log to the file. When Wget's output goes to the
+ terminal, and Wget receives SIGHUP, all further output is
+ redirected to a log file. When this is the case, Wget can also
+ print the last several lines of "context" to the log file so that
+ it does not begin in the middle of a line. For this to work, the
+ logging code stores the last several lines of context. Callers may
+ request for certain output not to be stored.
+
+ - Inhibiting output. When Wget receives SIGHUP, but redirecting
+ the output fails, logging is inhibited. */
+
+\f
+/* The file descriptor used for logging. This is NULL before log_init
+ is called; logging functions log to stderr then. log_init sets it
+ either to stderr or to a file pointer obtained from fopen(). If
+ logging is inhibited, logfp is set back to NULL. */
static FILE *logfp;
-/* Whether logging is saved at all. */
-int save_log_p;
+/* If non-zero, it means logging is inhibited, i.e. nothing is printed
+ or stored. */
+static int inhibit_logging;
+
+/* Whether the last output lines are stored for use as context. */
+static int save_context_p;
+
+/* Whether the log is flushed after each command. */
+static int flush_log_p = 1;
+
+/* Whether any output has been received while flush_log_p was 0. */
+static int needs_flushing;
/* In the event of a hang-up, and if its output was on a TTY, Wget
redirects its output to `wget-log'.
The problem here is that we'd have to either (re)allocate and free
strings all the time, or limit the lines to an arbitrary number of
characters. Instead of settling for either of these, we do both:
- if the line is smaller than a certain "usual" line length (80 chars
- by default), a preallocated memory is used. The rare lines that
- are longer than 80 characters are malloc'ed and freed separately.
- This gives good performance with minimum memory consumption and
- fragmentation. */
+ if the line is smaller than a certain "usual" line length (128
+ chars by default), a preallocated memory is used. The rare lines
+ that are longer than 128 characters are malloc'ed and freed
+ separately. This gives good performance with minimum memory
+ consumption and fragmentation. */
-#define STATIC_LENGTH 80
+#define STATIC_LENGTH 128
static struct log_ln {
char static_line[STATIC_LENGTH + 1]; /* statically allocated
than create new ones. */
static int trailing_line;
+static void check_redirect_output PARAMS ((void));
\f
#define ROT_ADVANCE(num) do { \
if (++num >= SAVED_LOG_LINES) \
struct log_ln *ln = log_lines + num;
if (ln->malloced_line)
{
- free (ln->malloced_line);
+ xfree (ln->malloced_line);
ln->malloced_line = NULL;
}
ln->content = NULL;
{
/* Allocate memory and concatenate the old and the new
contents. */
- ln->malloced_line = xmalloc (old_len + len + 1);
+ ln->malloced_line = (char *)xmalloc (old_len + len + 1);
memcpy (ln->malloced_line, ln->static_line,
old_len);
memcpy (ln->malloced_line + old_len, start, len);
return; \
}
-#define CANONICALIZE_LOGFP_OR_RETURN do { \
- if (logfp == stdin) \
- return; \
- else if (!logfp) \
- /* This might happen if somebody calls a */ \
- /* log* function before log_init(). */ \
- logfp = stderr; \
-} while (0)
+/* Returns the file descriptor for logging. This is LOGFP, except if
+ called before log_init, in which case it returns stderr. This is
+ useful in case someone calls a logging function before log_init.
+ If logging is inhibited, return NULL. */
+
+static FILE *
+get_log_fp (void)
+{
+ if (inhibit_logging)
+ return NULL;
+ if (logfp)
+ return logfp;
+ return stderr;
+}
\f
/* Log a literal string S. The string is logged as-is, without a
newline appended. */
void
logputs (enum log_options o, const char *s)
{
+ FILE *fp;
+
+ check_redirect_output ();
+ if (!(fp = get_log_fp ()))
+ return;
CHECK_VERBOSE (o);
- CANONICALIZE_LOGFP_OR_RETURN;
- fputs (s, logfp);
- if (!opt.no_flush)
- fflush (logfp);
- if (save_log_p)
+ fputs (s, fp);
+ if (save_context_p)
saved_append (s);
+ if (flush_log_p)
+ logflush ();
+ else
+ needs_flushing = 1;
}
+struct logvprintf_state {
+ char *bigmsg;
+ int expected_size;
+ int allocated;
+};
+
/* Print a message to the log. A copy of message will be saved to
- saved_log, for later reusal by log_dump(). */
+ saved_log, for later reusal by log_dump_context().
-static void
-logvprintf (enum log_options o, const char *fmt, va_list args)
-{
- CHECK_VERBOSE (o);
- CANONICALIZE_LOGFP_OR_RETURN;
+ It is not possible to code this function in a "natural" way, using
+ a loop, because of the braindeadness of the varargs API.
+ Specifically, each call to vsnprintf() must be preceded by va_start
+ and followed by va_end. And this is possible only in the function
+ that contains the `...' declaration. The alternative would be to
+ use va_copy, but that's not portable. */
- /* Originally, we first used vfprintf(), and then checked whether
- the message needs to be stored with vsprintf(). However, Watcom
- C didn't like ARGS being used twice, so now we first vsprintf()
- the message, and then fwrite() it to LOGFP. */
+static int
+logvprintf (struct logvprintf_state *state, const char *fmt, va_list args)
+{
+ char smallmsg[128];
+ char *write_ptr = smallmsg;
+ int available_size = sizeof (smallmsg);
+ int numwritten;
+ FILE *fp = get_log_fp ();
- if (!save_log_p)
+ if (!save_context_p)
{
/* In the simple case just call vfprintf(), to avoid needless
allocation and games with vsnprintf(). */
- vfprintf (logfp, fmt, args);
+ vfprintf (fp, fmt, args);
+ goto flush;
}
- else
+
+ if (state->allocated != 0)
{
- char smallmsg[128];
- char *bigmsg = NULL;
- int available_size = sizeof (smallmsg);
- char *write_ptr = smallmsg;
+ write_ptr = state->bigmsg;
+ available_size = state->allocated;
+ }
- while (1)
- {
- /* The GNU coding standards advise not to rely on the return
- value of sprintf(). However, vsnprintf() is a relatively
- new function missing from legacy systems. Therefore it's
- safe to assume that its return value is meaningful. On
- the systems where vsnprintf() is not available, we use
- the implementation from snprintf.c which does return the
- correct value. */
- int numwritten = vsnprintf (write_ptr, available_size, fmt, args);
-
- /* vsnprintf() will not step over the limit given by
- available_size. If it fails, it will return either -1
- (POSIX?) or the number of characters that *would have*
- been written, if there had been enough room. In the
- former case, we double the available_size and malloc() to
- get a larger buffer, and try again. In the latter case,
- we use the returned information to build a buffer of the
- correct size. */
-
- if (numwritten == -1)
- {
- /* Writing failed, and we don't know the needed size.
- Try again with doubled size. */
- available_size <<= 1;
- bigmsg = xrealloc (bigmsg, available_size);
- write_ptr = bigmsg;
- }
- else if (numwritten >= available_size)
- {
- /* Writing failed, but we know exactly how much space we
- need. */
- available_size = numwritten + 1;
- bigmsg = xrealloc (bigmsg, available_size);
- write_ptr = bigmsg;
- }
- else
- {
- /* Writing succeeded. */
- break;
- }
- }
- saved_append (write_ptr);
- fputs (write_ptr, logfp);
- if (bigmsg)
- free (bigmsg);
+ /* The GNU coding standards advise not to rely on the return value
+ of sprintf(). However, vsnprintf() is a relatively new function
+ missing from legacy systems. Therefore I consider it safe to
+ assume that its return value is meaningful. On the systems where
+ vsnprintf() is not available, we use the implementation from
+ snprintf.c which does return the correct value. */
+ numwritten = vsnprintf (write_ptr, available_size, fmt, args);
+
+ /* vsnprintf() will not step over the limit given by available_size.
+ If it fails, it will return either -1 (POSIX?) or the number of
+ characters that *would have* been written, if there had been
+ enough room (C99). In the former case, we double the
+ available_size and malloc to get a larger buffer, and try again.
+ In the latter case, we use the returned information to build a
+ buffer of the correct size. */
+
+ if (numwritten == -1)
+ {
+ /* Writing failed, and we don't know the needed size. Try
+ again with doubled size. */
+ int newsize = available_size << 1;
+ state->bigmsg = xrealloc (state->bigmsg, newsize);
+ state->allocated = newsize;
+ return 0;
}
- if (!opt.no_flush)
- fflush (logfp);
+ else if (numwritten >= available_size)
+ {
+ /* Writing failed, but we know exactly how much space we
+ need. */
+ int newsize = numwritten + 1;
+ state->bigmsg = xrealloc (state->bigmsg, newsize);
+ state->allocated = newsize;
+ return 0;
+ }
+
+ /* Writing succeeded. */
+ saved_append (write_ptr);
+ fputs (write_ptr, fp);
+ if (state->bigmsg)
+ xfree (state->bigmsg);
+
+ flush:
+ if (flush_log_p)
+ logflush ();
+ else
+ needs_flushing = 1;
+
+ return 1;
}
-/* Flush LOGFP. */
+/* Flush LOGFP. Useful while flushing is disabled. */
void
logflush (void)
{
- CANONICALIZE_LOGFP_OR_RETURN;
- fflush (logfp);
+ FILE *fp = get_log_fp ();
+ if (fp)
+ fflush (fp);
+ needs_flushing = 0;
+}
+
+/* Enable or disable log flushing. */
+void
+log_set_flush (int flush)
+{
+ if (flush == flush_log_p)
+ return;
+
+ if (flush == 0)
+ {
+ /* Disable flushing by setting flush_log_p to 0. */
+ flush_log_p = 0;
+ }
+ else
+ {
+ /* Reenable flushing. If anything was printed in no-flush mode,
+ flush the log now. */
+ if (needs_flushing)
+ logflush ();
+ flush_log_p = 1;
+ }
+}
+
+/* (Temporarily) disable storing log to memory. Returns the old
+ status of storing, with which this function can be called again to
+ reestablish storing. */
+
+int
+log_set_save_context (int savep)
+{
+ int old = save_context_p;
+ save_context_p = savep;
+ return old;
}
-/* Portability with pre-ANSI compilers makes these two functions look
- like @#%#@$@#$. */
+/* Handle difference in va_start between pre-ANSI and ANSI C. Note
+ that we always use `...' in function definitions and let ansi2knr
+ convert it for us. */
#ifdef WGET_USE_STDARG
+# define VA_START(args, arg1) va_start (args, arg1)
+#else
+# define VA_START(args, ignored) va_start (args)
+#endif
+
+/* Print a message to the screen or to the log. The first argument
+ defines the verbosity of the message, and the rest are as in
+ printf(3). */
+
void
logprintf (enum log_options o, const char *fmt, ...)
-#else /* not WGET_USE_STDARG */
-void
-logprintf (va_alist)
- va_dcl
-#endif /* not WGET_USE_STDARG */
{
va_list args;
-#ifndef WGET_USE_STDARG
- enum log_options o;
- const char *fmt;
-#endif
+ struct logvprintf_state lpstate;
+ int done;
-#ifdef WGET_USE_STDARG
- va_start (args, fmt);
-#else
- va_start (args);
- o = va_arg (args, enum log_options);
- fmt = va_arg (args, char *);
-#endif
- logvprintf (o, fmt, args);
- va_end (args);
+ check_redirect_output ();
+ if (inhibit_logging)
+ return;
+ CHECK_VERBOSE (o);
+
+ xzero (lpstate);
+ do
+ {
+ VA_START (args, fmt);
+ done = logvprintf (&lpstate, fmt, args);
+ va_end (args);
+ }
+ while (!done);
}
-#ifdef DEBUG
+#ifdef ENABLE_DEBUG
/* The same as logprintf(), but does anything only if opt.debug is
non-zero. */
-#ifdef WGET_USE_STDARG
void
debug_logprintf (const char *fmt, ...)
-#else /* not WGET_USE_STDARG */
-void
-debug_logprintf (va_alist)
- va_dcl
-#endif /* not WGET_USE_STDARG */
{
if (opt.debug)
{
va_list args;
-#ifndef WGET_USE_STDARG
- const char *fmt;
-#endif
+ struct logvprintf_state lpstate;
+ int done;
-#ifdef WGET_USE_STDARG
- va_start (args, fmt);
-#else
- va_start (args);
- fmt = va_arg (args, char *);
-#endif
- logvprintf (LOG_ALWAYS, fmt, args);
- va_end (args);
+ check_redirect_output ();
+ if (inhibit_logging)
+ return;
+
+ xzero (lpstate);
+ do
+ {
+ VA_START (args, fmt);
+ done = logvprintf (&lpstate, fmt, args);
+ va_end (args);
+ }
+ while (!done);
}
}
-#endif /* DEBUG */
+#endif /* ENABLE_DEBUG */
\f
/* Open FILE and set up a logging stream. If FILE cannot be opened,
exit with status of 1. */
easier on the user. */
logfp = stderr;
- /* If the output is a TTY, enable logging, which will make Wget
- remember all the printed messages, to be able to dump them to
- a log file in case SIGHUP or SIGUSR1 is received (or
- Ctrl+Break is pressed under Windows). */
+ /* If the output is a TTY, enable storing, which will make Wget
+ remember the last several printed messages, to be able to
+ dump them to a log file in case SIGHUP or SIGUSR1 is received
+ (or Ctrl+Break is pressed under Windows). */
if (1
#ifdef HAVE_ISATTY
&& isatty (fileno (logfp))
#endif
)
{
- save_log_p = 1;
+ save_context_p = 1;
}
}
}
{
int i;
- if (logfp != stdin)
+ if (logfp)
fclose (logfp);
- save_log_p = 0;
+ logfp = NULL;
+ inhibit_logging = 1;
+ save_context_p = 0;
+
for (i = 0; i < SAVED_LOG_LINES; i++)
free_log_line (i);
log_line_current = -1;
/* Dump saved lines to logfp. */
static void
-log_dump (void)
+log_dump_context (void)
{
int num = log_line_current;
- FILE *fp = logfp;
+ FILE *fp = get_log_fp ();
+ if (!fp)
+ return;
if (num == -1)
return;
fputs (log_lines[log_line_current].content, fp);
fflush (fp);
}
+\f
+/* When SIGHUP or SIGUSR1 are received, the output is redirected
+ elsewhere. Such redirection is only allowed once. */
+enum { RR_NONE, RR_REQUESTED, RR_DONE } redirect_request = RR_NONE;
+static const char *redirect_request_signal_name;
-/* Redirect output to `wget-log'. MESSIJ is printed on stdout, and
- should contain *exactly one* `%s', which will be replaced by the
- log file name.
+/* Redirect output to `wget-log'. */
- If logging was not enabled, MESSIJ will not be printed. */
-void
-redirect_output (const char *messij)
+static void
+redirect_output (void)
{
- char *logfile;
-
- if (!save_log_p)
- return;
-
- logfile = unique_name (DEFAULT_LOGFILE);
+ char *logfile = unique_name (DEFAULT_LOGFILE, 0);
+ fprintf (stderr, _("\n%s received, redirecting output to `%s'.\n"),
+ redirect_request_signal_name, logfile);
logfp = fopen (logfile, "w");
if (!logfp)
{
/* Eek! Opening the alternate log file has failed. Nothing we
can do but disable printing completely. */
- fprintf (stderr, "%s: %s: %s\n", exec_name, logfile, strerror (errno));
- /* `stdin' is magic to not print anything, ever. */
- logfp = stdin;
+ fprintf (stderr, _("%s: %s; disabling logging.\n"),
+ logfile, strerror (errno));
+ inhibit_logging = 1;
+ }
+ else
+ {
+ /* Dump the context output to the newly opened log. */
+ log_dump_context ();
+ }
+ xfree (logfile);
+ save_context_p = 0;
+}
+
+/* Check whether a signal handler requested the output to be
+ redirected. */
+
+static void
+check_redirect_output (void)
+{
+ if (redirect_request == RR_REQUESTED)
+ {
+ redirect_request = RR_DONE;
+ redirect_output ();
}
- fprintf (stderr, messij, logfile);
- free (logfile);
- /* Dump the previous screenful of output to LOGFILE. */
- log_dump ();
- save_log_p = 0;
+}
+
+/* Request redirection at a convenient time. This may be called from
+ a signal handler. */
+
+void
+log_request_redirect_output (const char *signal_name)
+{
+ if (redirect_request == RR_NONE && save_context_p)
+ /* Request output redirection. The request will be processed by
+ check_redirect_output(), which is called from entry point log
+ functions. */
+ redirect_request = RR_REQUESTED;
+ redirect_request_signal_name = signal_name;
}
projects / wget / blobdiff