#ifndef errno
extern int errno;
#endif
+\f
+/* The file descriptor used for logging. */
-/* We expect no message passed to logprintf() to be bigger than this.
- Before a message is printed, we make sure that at least this much
- room is left for printing it. */
-#define SAVED_LOG_MAXMSG 32768
-
-/* Maximum allowed growing size. */
-#define SAVED_LOG_MAXSIZE (10 * 1L << 20)
+static FILE *logfp;
-static char *saved_log;
-/* Size of the current log. */
-static long saved_log_size;
-/* Offset into the log where we are about to print (size of the
- used-up part of SAVED_LOG). */
-static long saved_log_offset;
/* Whether logging is saved at all. */
int save_log_p;
-static FILE *logfp;
+/* In the event of a hang-up, and if its output was on a TTY, Wget
+ redirects its output to `wget-log'.
+
+ For the convenience of reading this newly-created log, we store the
+ last several lines ("screenful", hence the choice of 24) of Wget
+ output, and dump them as context when the time comes. */
+#define SAVED_LOG_LINES 24
+
+/* log_lines is a circular buffer that stores SAVED_LOG_LINES lines of
+ output. log_line_current always points to the position in the
+ buffer that will be written to next. When log_line_current reaches
+ SAVED_LOG_LINES, it is reset to zero.
+
+ 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. */
+
+#define STATIC_LENGTH 80
+
+static struct log_ln {
+ char static_line[STATIC_LENGTH + 1]; /* statically allocated
+ line. */
+ char *malloced_line; /* malloc'ed line, for lines of output
+ larger than 80 characters. */
+ char *content; /* this points either to malloced_line
+ or to the appropriate static_line.
+ If this is NULL, it means the line
+ has not yet been used. */
+} log_lines[SAVED_LOG_LINES];
+
+/* The current position in the ring. */
+static int log_line_current = -1;
+
+/* Whether the most recently written line was "trailing", i.e. did not
+ finish with \n. This is an important piece of information because
+ the code is always careful to append data to trailing lines, rather
+ than create new ones. */
+static int trailing_line;
+
+\f
+#define ROT_ADVANCE(num) do { \
+ if (++num >= SAVED_LOG_LINES) \
+ num = 0; \
+} while (0)
+
+/* Free the log line index with NUM. This calls free on
+ ln->malloced_line if it's non-NULL, and it also resets
+ ln->malloced_line and ln->content to NULL. */
+
+static void
+free_log_line (int num)
+{
+ struct log_ln *ln = log_lines + num;
+ if (ln->malloced_line)
+ {
+ free (ln->malloced_line);
+ ln->malloced_line = NULL;
+ }
+ ln->content = NULL;
+}
+
+/* Append bytes in the range [start, end) to one line in the log. The
+ region is not supposed to contain newlines, except for the last
+ character (at end[-1]). */
+
+static void
+saved_append_1 (const char *start, const char *end)
+{
+ int len = end - start;
+ if (!len)
+ return;
+
+ /* First, check whether we need to append to an existing line or to
+ create a new one. */
+ if (!trailing_line)
+ {
+ /* Create a new line. */
+ struct log_ln *ln;
+
+ if (log_line_current == -1)
+ log_line_current = 0;
+ else
+ free_log_line (log_line_current);
+ ln = log_lines + log_line_current;
+ if (len > STATIC_LENGTH)
+ {
+ ln->malloced_line = strdupdelim (start, end);
+ ln->content = ln->malloced_line;
+ }
+ else
+ {
+ memcpy (ln->static_line, start, len);
+ ln->static_line[len] = '\0';
+ ln->content = ln->static_line;
+ }
+ }
+ else
+ {
+ /* Append to the last line. If the line is malloc'ed, we just
+ call realloc and append the new string. If the line is
+ static, we have to check whether appending the new string
+ would make it exceed STATIC_LENGTH characters, and if so,
+ convert it to malloc(). */
+ struct log_ln *ln = log_lines + log_line_current;
+ if (ln->malloced_line)
+ {
+ /* Resize malloc'ed line and append. */
+ int old_len = strlen (ln->malloced_line);
+ ln->malloced_line = xrealloc (ln->malloced_line, old_len + len + 1);
+ memcpy (ln->malloced_line + old_len, start, len);
+ ln->malloced_line[old_len + len] = '\0';
+ /* might have changed due to realloc */
+ ln->content = ln->malloced_line;
+ }
+ else
+ {
+ int old_len = strlen (ln->static_line);
+ if (old_len + len > STATIC_LENGTH)
+ {
+ /* Allocate memory and concatenate the old and the new
+ contents. */
+ ln->malloced_line = xmalloc (old_len + len + 1);
+ memcpy (ln->malloced_line, ln->static_line,
+ old_len);
+ memcpy (ln->malloced_line + old_len, start, len);
+ ln->malloced_line[old_len + len] = '\0';
+ ln->content = ln->malloced_line;
+ }
+ else
+ {
+ /* Just append to the old, statically allocated
+ contents. */
+ memcpy (ln->static_line + old_len, start, len);
+ ln->static_line[old_len + len] = '\0';
+ ln->content = ln->static_line;
+ }
+ }
+ }
+ trailing_line = !(end[-1] == '\n');
+ if (!trailing_line)
+ ROT_ADVANCE (log_line_current);
+}
+/* Log the contents of S, as explained above. If S consists of
+ multiple lines, they are logged separately. If S does not end with
+ a newline, it will form a "trailing" line, to which things will get
+ appended the next time this function is called. */
+
+static void
+saved_append (const char *s)
+{
+ while (*s)
+ {
+ const char *end = strchr (s, '\n');
+ if (!end)
+ end = s + strlen (s);
+ else
+ ++end;
+ saved_append_1 (s, end);
+ s = end;
+ }
+}
+\f
/* Check X against opt.verbose and opt.quiet. The semantics is as
follows:
if (logfp == stdin) \
return; \
else if (!logfp) \
- /* #### Should this ever happen? */ \
+ /* This might happen if somebody calls a */ \
+ /* log* function before log_init(). */ \
logfp = stderr; \
} while (0)
\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)
{
fputs (s, logfp);
if (!opt.no_flush)
fflush (logfp);
-
- if (save_log_p && saved_log_size < SAVED_LOG_MAXSIZE)
- {
- int len = strlen (s);
-
- /* Increase size of SAVED_LOG exponentially. */
- DO_REALLOC (saved_log, saved_log_size,
- saved_log_offset + len + 1, char);
- memcpy (saved_log + saved_log_offset, s, len + 1);
- saved_log_offset += len;
- }
+ if (save_log_p)
+ saved_append (s);
}
-/* Print a message to the log file logfp. If logfp is NULL, print to
- stderr. If logfp is stdin, don't print at all. A copy of message
- will be saved to saved_log, for later reusal by dump_log(). */
+/* Print a message to the log. A copy of message will be saved to
+ saved_log, for later reusal by log_dump(). */
+
static void
logvprintf (enum log_options o, const char *fmt, va_list args)
{
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. */
- if (save_log_p && saved_log_size < SAVED_LOG_MAXSIZE)
+
+ if (!save_log_p)
{
- int len;
- /* Increase size of `saved_log' exponentially. */
- DO_REALLOC (saved_log, saved_log_size,
- saved_log_offset + SAVED_LOG_MAXMSG, char);
- /* Print the message to the log saver... */
- vsnprintf (saved_log + saved_log_offset, SAVED_LOG_MAXMSG, fmt, args);
- /* ...and then dump it to LOGFP. */
- len = strlen (saved_log + saved_log_offset);
- fwrite (saved_log + saved_log_offset, len, 1, logfp);
- saved_log_offset += len;
- /* If we ran off the limits and corrupted something, bail out
- immediately. */
- assert (saved_log_size >= saved_log_offset);
+ /* In the simple case just call vfprintf(), to avoid needless
+ allocation and games with vsnprintf(). */
+ vfprintf (logfp, fmt, args);
}
else
- vfprintf (logfp, fmt, args);
+ {
+ char smallmsg[128];
+ char *bigmsg = NULL;
+ int available_size = sizeof (smallmsg);
+ char *write_ptr = smallmsg;
+ 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);
+ }
if (!opt.no_flush)
fflush (logfp);
}
fflush (logfp);
}
-/* Portability makes these two functions look like @#%#@$@#$. */
+/* Portability with pre-ANSI compilers makes these two functions look
+ like @#%#@$@#$. */
#ifdef WGET_USE_STDARG
void
}
else
{
+ /* The log goes to stderr to avoid collisions with the output if
+ the user specifies `-O -'. #### Francois Pinard suggests
+ that it's a better idea to print to stdout by default, and to
+ stderr only if the user actually specifies `-O -'. He says
+ this inconsistency is harder to document, but is overall
+ 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
void
log_close (void)
{
- fclose (logfp);
+ int i;
+
+ if (logfp != stdin)
+ fclose (logfp);
save_log_p = 0;
- FREE_MAYBE (saved_log);
- saved_log = NULL;
- saved_log_size = saved_log_offset = 0;
+ for (i = 0; i < SAVED_LOG_LINES; i++)
+ free_log_line (i);
+ log_line_current = -1;
+ trailing_line = 0;
}
-/* Dump SAVED_LOG using logprintf(), but quit further logging to memory.
- Also, free the memory occupied by saved_log. */
+/* Dump saved lines to logfp. */
static void
log_dump (void)
{
- save_log_p = 0;
- if (!saved_log)
+ int num = log_line_current;
+ FILE *fp = logfp;
+
+ if (num == -1)
return;
- logputs (LOG_ALWAYS, saved_log);
- free (saved_log);
- saved_log = NULL;
- saved_log_size = saved_log_offset = 0;
+ if (trailing_line)
+ ROT_ADVANCE (num);
+ do
+ {
+ struct log_ln *ln = log_lines + num;
+ if (ln->content)
+ fputs (ln->content, fp);
+ ROT_ADVANCE (num);
+ }
+ while (num != log_line_current);
+ if (trailing_line)
+ if (log_lines[log_line_current].content)
+ fputs (log_lines[log_line_current].content, fp);
+ fflush (fp);
}
-/* Redirect output to `wget-log' if opt.lfile is stdout. 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'. MESSIJ is printed on stdout, and
+ should contain *exactly one* `%s', which will be replaced by the
+ log file name.
If logging was not enabled, MESSIJ will not be printed. */
void
logfp = fopen (logfile, "w");
if (!logfp)
{
- printf ("%s: %s: %s\n", exec_name, logfile, strerror (errno));
- /* `stdin' is magic to not print anything. */
+ /* 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;
}
- printf (messij, logfile);
+ fprintf (stderr, messij, logfile);
free (logfile);
- /* Dump all the previous messages to LOGFILE. */
+ /* Dump the previous screenful of output to LOGFILE. */
log_dump ();
+ save_log_p = 0;
}
projects / wget / commitdiff