X-Git-Url: http://erislabs.net/gitweb/?a=blobdiff_plain;f=lib%2Fcloseout.c;h=674db787eab6404eb129baf099ad57fc88b64761;hb=cd56634a4a8179fd5a4419fbb3e27211b042ab1c;hp=71151b84ea64d0b36911f1da336a68085dc4f8de;hpb=b6c5ffd21355e4fb7f9f61ca206f57fa08bd7678;p=gnulib.git diff --git a/lib/closeout.c b/lib/closeout.c index 71151b84e..674db787e 100644 --- a/lib/closeout.c +++ b/lib/closeout.c @@ -1,10 +1,12 @@ -/* closeout.c - close standard output - Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. +/* Close standard output and standard error, exiting with a diagnostic on error. - This program is free software; you can redistribute it and/or modify + Copyright (C) 1998-2002, 2004, 2006, 2008-2014 Free Software Foundation, + Inc. + + This program 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, or (at your option) - any later version. + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -12,101 +14,111 @@ 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ - -#if HAVE_CONFIG_H -# include -#endif - -#if ENABLE_NLS -# include -# define _(Text) gettext (Text) -#else -# define _(Text) Text -#endif - -#if HAVE_STDLIB_H -# include -#endif -#ifndef EXIT_FAILURE -# define EXIT_FAILURE 1 -#endif + along with this program. If not, see . */ -#include +#include + +#include "closeout.h" #include -#ifndef errno -extern int errno; -#endif +#include +#include +#include -#include "closeout.h" +#include "gettext.h" +#define _(msgid) gettext (msgid) + +#include "close-stream.h" #include "error.h" +#include "exitfail.h" #include "quotearg.h" -static int default_exit_status = EXIT_FAILURE; static const char *file_name; -/* Set the value to be used for the exit status when close_stdout is called. - This is useful when it is not convenient to call close_stdout_status, - e.g., when close_stdout is called via atexit. */ +/* Set the file name to be reported in the event an error is detected + by close_stdout. */ void -close_stdout_set_status (int status) +close_stdout_set_file_name (const char *file) { - default_exit_status = status; + file_name = file; } -/* Set the file name to be reported in the event an error is detected - by close_stdout_status. */ +static bool ignore_EPIPE /* = false */; + +/* Specify the reaction to an EPIPE error during the closing of stdout: + - If ignore = true, it shall be ignored. + - If ignore = false, it shall evoke a diagnostic, along with a nonzero + exit status. + The default is ignore = false. + + This setting matters only if the SIGPIPE signal is ignored (i.e. its + handler set to SIG_IGN) or blocked. Only particular programs need to + temporarily ignore SIGPIPE. If SIGPIPE is ignored or blocked because + it was ignored or blocked in the parent process when it created the + child process, it usually is a bug in the parent process: It is bad + practice to have SIGPIPE ignored or blocked while creating a child + process. + + EPIPE occurs when writing to a pipe or socket that has no readers now, + when SIGPIPE is ignored or blocked. + + The ignore = false setting is suitable for a scenario where it is normally + guaranteed that the pipe writer terminates before the pipe reader. In + this case, an EPIPE is an indication of a premature termination of the + pipe reader and should lead to a diagnostic and a nonzero exit status. + + The ignore = true setting is suitable for a scenario where you don't know + ahead of time whether the pipe writer or the pipe reader will terminate + first. In this case, an EPIPE is an indication that the pipe writer can + stop doing useless write() calls; this is what close_stdout does anyway. + EPIPE is part of the normal pipe/socket shutdown protocol in this case, + and should not lead to a diagnostic message. */ + void -close_stdout_set_file_name (const char *file) +close_stdout_set_ignore_EPIPE (bool ignore) { - file_name = file; + ignore_EPIPE = ignore; } -/* Close standard output, exiting with status STATUS on failure. - If a program writes *anything* to stdout, that program should `fflush' - stdout and make sure that it succeeds before exiting. Otherwise, - suppose that you go to the extreme of checking the return status - of every function that does an explicit write to stdout. The last - printf can succeed in writing to the internal stream buffer, and yet - the fclose(stdout) could still fail (due e.g., to a disk full error) - when it tries to write out that buffered data. Thus, you would be - left with an incomplete output file and the offending program would - exit successfully. - - FIXME: note the fflush suggested above is implicit in the fclose - we actually do below. Consider doing only the fflush and/or using - setvbuf to inhibit buffering. - - Besides, it's wasteful to check the return value from every call - that writes to stdout -- just let the internal stream state record - the failure. That's what the ferror test is checking below. +/* Close standard output. On error, issue a diagnostic and _exit + with status 'exit_failure'. + + Also close standard error. On error, _exit with status 'exit_failure'. + + Since close_stdout is commonly registered via 'atexit', POSIX + and the C standard both say that it should not call 'exit', + because the behavior is undefined if 'exit' is called more than + once. So it calls '_exit' instead of 'exit'. If close_stdout + is registered via atexit before other functions are registered, + the other functions can act before this _exit is invoked. + + Applications that use close_stdout should flush any streams + other than stdout and stderr before exiting, since the call to + _exit will bypass other buffer flushing. Applications should + be flushing and closing other streams anyway, to check for I/O + errors. Also, applications should not use tmpfile, since _exit + can bypass the removal of these files. It's important to detect such failures and exit nonzero because many - tools (most notably `make' and other build-management systems) depend + tools (most notably 'make' and other build-management systems) depend on being able to detect failure in other tools via their exit status. */ + void -close_stdout_status (int status) +close_stdout (void) { - int e = ferror (stdout) ? 0 : -1; - - if (fclose (stdout) != 0) - e = errno; - - if (0 <= e) + if (close_stream (stdout) != 0 + && !(ignore_EPIPE && errno == EPIPE)) { char const *write_error = _("write error"); if (file_name) - error (status, e, "%s: %s", quotearg_colon (file_name), write_error); + error (0, errno, "%s: %s", quotearg_colon (file_name), + write_error); else - error (status, e, "%s", write_error); + error (0, errno, "%s", write_error); + + _exit (exit_failure); } -} -/* Close standard output, exiting with status EXIT_FAILURE on failure. */ -void -close_stdout (void) -{ - close_stdout_status (default_exit_status); + if (close_stream (stderr) != 0) + _exit (exit_failure); }