diff options
Diffstat (limited to 'butl')
| -rw-r--r-- | butl/fdstream | 310 | ||||
| -rw-r--r-- | butl/fdstream.cxx | 331 | ||||
| -rw-r--r-- | butl/fdstream.ixx | 196 | ||||
| -rw-r--r-- | butl/filesystem.cxx | 37 | ||||
| -rw-r--r-- | butl/pager | 4 | ||||
| -rw-r--r-- | butl/pager.cxx | 22 | ||||
| -rw-r--r-- | butl/process | 15 | ||||
| -rw-r--r-- | butl/process.cxx | 30 |
8 files changed, 793 insertions, 152 deletions
diff --git a/butl/fdstream b/butl/fdstream index 23cc58c..bb14f25 100644 --- a/butl/fdstream +++ b/butl/fdstream @@ -5,24 +5,37 @@ #ifndef BUTL_FDSTREAM #define BUTL_FDSTREAM +#include <string> #include <istream> #include <ostream> #include <cstdint> // uint16_t #include <butl/path> -#include <butl/filesystem> // permissions +#include <butl/filesystem> // permissions namespace butl { - // An iostream that is initialized with a file descriptor rather than - // a file name. + // An [io]fstream that can be initialized with a file descriptor in addition + // to a file name and that also by default enables exceptions on badbit and + // failbit. So instead of a dance like this: + // + // ifstream ifs; + // ifs.exceptions (ifstream::badbit | ifstream::failbit); + // ifs.open (path.string ()); + // + // You can simply do: + // + // ifdstream ifs (path); // // Notes and limitations: // // - char only // - input or output but not both // - no support for put back - // - throws std::system_error in case of a read()/write() error + // - throws ios::failure in case of open()/read()/write()/close() errors + // - exception mask has at least badbit + // - after catching an exception caused by badbit the stream is no longer + // used // - not movable, though can be easily supported // class fdbuf: public std::basic_streambuf<char> @@ -80,81 +93,262 @@ namespace butl char buf_[4096]; }; - // File descriptor translation mode. It has the same semantics as the - // binary/text opening modes in std::fstream. Specifically, this is a - // noop for POSIX systems where the two modes are the same. + // File stream mode. + // + // The text/binary flags have the same semantics as those in std::fstream. + // Specifically, this is a noop for POSIX systems where the two modes are + // the same. // - enum class fdtranslate + // The skip flag instructs the stream to skip to the end before closing the + // file descriptor. This is primarily useful when working with pipes where + // you may want not to "offend" the other end by closing your end before + // reading all the data. + // + enum class fdstream_mode: std::uint16_t { - text, - binary + text = 0x01, + binary = 0x02, + skip = 0x04 }; + fdstream_mode operator& (fdstream_mode, fdstream_mode); + fdstream_mode operator| (fdstream_mode, fdstream_mode); + fdstream_mode operator&= (fdstream_mode&, fdstream_mode); + fdstream_mode operator|= (fdstream_mode&, fdstream_mode); + + // Extended (compared to ios::openmode) file open flags. + // + enum class fdopen_mode: std::uint16_t + { + in = 0x01, // Open for reading. + out = 0x02, // Open for writing. + append = 0x04, // Seek to the end of file before each write. + truncate = 0x08, // Discard the file contents on open. + create = 0x10, // Create a file if not exists. + exclusive = 0x20, // Fail if the file exists and the create flag is set. + binary = 0x40, // Set binary translation mode. + at_end = 0x80, // Seek to the end of stream immediately after open. + + none = 0 // Usefull when build the mode incrementally. + }; + + fdopen_mode operator& (fdopen_mode, fdopen_mode); + fdopen_mode operator| (fdopen_mode, fdopen_mode); + fdopen_mode operator&= (fdopen_mode&, fdopen_mode); + fdopen_mode operator|= (fdopen_mode&, fdopen_mode); + class fdstream_base { protected: fdstream_base () = default; fdstream_base (int fd): buf_ (fd) {} - fdstream_base (int, fdtranslate); + fdstream_base (int, fdstream_mode); protected: fdbuf buf_; }; - // Note that the destructor may throw. + // iofdstream constructors and open() functions that take openmode as an + // argument mimic the corresponding iofstream functions in terms of the + // openmode mask interpretation. They throw std::invalid_argument for an + // invalid combination of flags (as per the standard). Note that the in and + // out flags are always added implicitly for ifdstream and ofdstream, + // respectively. + // + // iofdstream constructors and open() functions that take fdopen_mode as an + // argument interpret the mask literally just ignoring some flags which are + // meaningless in the absense of others (read more on that in the comment + // for fdopen()). Note that the in and out flags are always added implicitly + // for ifdstream and ofdstream, respectively. + // + // iofdstream constructors and open() functions that take file path as a + // const std::string& or const char* may throw the invalid_path exception. + // + // Passing -1 as a file descriptor is valid and results in the creation of + // an unopened object. + // + // Also note that open() and close() functions can be successfully called + // for an opened and unopened objects respectively. That is in contrast with + // iofstream that sets failbit in such cases. + // + // @@ Need to make sure performance is on par with fstream on both + // Linux and Windows. + // + // @@ Do we need to increase default buffer size? Make it customizable? + // Wonder what it is in libstdc++ and MSVC? + + // Note that ifdstream destructor will close an open file descriptor but + // will ignore any errors. To detect such errors, call close() explicitly. // class ifdstream: fdstream_base, public std::istream { public: - ifdstream (): std::istream (&buf_) {} - ifdstream (int fd): fdstream_base (fd), std::istream (&buf_) {} - ifdstream (int fd, fdtranslate m) - : fdstream_base (fd, m), std::istream (&buf_) {} + // Create an unopened object with iostate = badbit | failbit (we cannot + // have the iostate as an argument since it clashes with int fd) To create + // an unopened object with non-default exception mask one can do: + // + // ifdstream (-1, ...); + // + ifdstream (); + + explicit + ifdstream (int fd, iostate e = badbit | failbit); + ifdstream (int fd, fdstream_mode m, iostate e = badbit | failbit); + + explicit + ifdstream (const char*, + openmode = in, + iostate e = badbit | failbit); + + explicit + ifdstream (const std::string&, + openmode = in, + iostate e = badbit | failbit); + + explicit + ifdstream (const path&, + openmode = in, + iostate e = badbit | failbit); + + ifdstream (const char*, + fdopen_mode, + iostate e = badbit | failbit); + + ifdstream (const std::string&, + fdopen_mode, + iostate e = badbit | failbit); + + ifdstream (const path&, + fdopen_mode, + iostate e = badbit | failbit); + + ~ifdstream () override; + + void + open (const char*, openmode = in); + + void + open (const std::string&, openmode = in); + + void + open (const path&, openmode = in); + + void + open (const char*, fdopen_mode); - void close () {buf_.close ();} - void open (int fd) {buf_.open (fd);} + void + open (const std::string&, fdopen_mode); + + void + open (const path&, fdopen_mode); + + void + open (int fd) {buf_.open (fd); clear();} + + void close (); bool is_open () const {return buf_.is_open ();} + + private: + bool skip_ = false; }; - // Note that the destructor flushes the stream and may throw. + // Note that ofdstream requires that you explicitly call close() before + // destroying it. Or, more specifically, the ofdstream object should not be + // in the opened state by the time its destructor is called, unless it is in + // the "not good" state (good() == false) or the destructor is being called + // during the stack unwinding due to an exception being thrown + // (std::uncaught_exception() == true). This is enforced with assert() in + // the ofdstream destructor. // class ofdstream: fdstream_base, public std::ostream { public: - ofdstream (): std::ostream (&buf_) {} - ofdstream (int fd): fdstream_base (fd), std::ostream (&buf_) {} - ofdstream (int fd, fdtranslate m) - : fdstream_base (fd, m), std::ostream (&buf_) {} + // Create an unopened object with iostate = badbit | failbit (we cannot + // have the iostate as an argument since it clashes with int fd). To create + // an unopened object with non-default exception mask one can do: + // + // ofdstream (-1, ...); + // + ofdstream (); - ~ofdstream () override {if (is_open () && good ()) buf_.sync ();} + explicit + ofdstream (int fd, iostate e = badbit | failbit); + ofdstream (int fd, fdstream_mode m, iostate e = badbit | failbit); - void close () {flush (); buf_.close ();} - void open (int fd) {buf_.open (fd);} - bool is_open () const {return buf_.is_open ();} - }; + explicit + ofdstream (const char*, + openmode = out, + iostate e = badbit | failbit); - // File open flags. - // - enum class fdopen_mode: std::uint16_t - { - in = 0x01, // Open for reading. - out = 0x02, // Open for writing. - append = 0x04, // Seek to the end of file before each write. - truncate = 0x08, // Discard the file contents on open. - create = 0x10, // Create a file if not exists. - exclusive = 0x20, // Fail if the file exists and the create flag is set. - binary = 0x40, // Set binary translation mode. + explicit + ofdstream (const std::string&, + openmode = out, + iostate e = badbit | failbit); - none = 0 // Usefull when build the mode incrementally. + explicit + ofdstream (const path&, + openmode = out, + iostate e = badbit | failbit); + + ofdstream (const char*, + fdopen_mode, + iostate e = badbit | failbit); + + ofdstream (const std::string&, + fdopen_mode, + iostate e = badbit | failbit); + + ofdstream (const path&, + fdopen_mode, + iostate e = badbit | failbit); + + ~ofdstream () override; + + void + open (const char*, openmode = out); + + void + open (const std::string&, openmode = out); + + void + open (const path&, openmode = out); + + void + open (const char*, fdopen_mode); + + void + open (const std::string&, fdopen_mode); + + void + open (const path&, fdopen_mode); + + void + open (int fd) {buf_.open (fd); clear ();} + + void close () {if (is_open ()) flush (); buf_.close ();} + bool is_open () const {return buf_.is_open ();} }; - fdopen_mode operator& (fdopen_mode, fdopen_mode); - fdopen_mode operator| (fdopen_mode, fdopen_mode); - fdopen_mode operator&= (fdopen_mode&, fdopen_mode); - fdopen_mode operator|= (fdopen_mode&, fdopen_mode); + // The std::getline() replacement that provides a workaround for libstdc++'s + // ios::failure ABI fiasco (#66145) by throwing ios::failure, as it is + // defined at libbutl build time (new ABI on recent distributions) rather + // than libstdc++ build time (still old ABI on most distributions). + // + // Notes: + // + // - This relies of ADL so if the stream is used via the std::istream + // interface, then std::getline() will still be used. To put it another + // way, this is "the best we can do" until GCC folks get their act + // together. + // + // - The fail and eof bits may be left cleared in the stream exception mask + // when the function throws because of badbit. + // + ifdstream& + getline (ifdstream&, std::string&, char delim = '\n'); // Open a file returning the file descriptor on success and throwing - // std::system_error otherwise. + // ios:failure otherwise. // // The mode argument should have at least one of the in or out flags set. // The append and truncate flags are meaningless in the absense of the out @@ -170,6 +364,20 @@ namespace butl // Windows permissions other than ru and wu are unlikelly to have effect. // int + fdopen (const char*, + fdopen_mode, + permissions = permissions::ru | permissions::wu | + permissions::rg | permissions::wg | + permissions::ro | permissions::wo); + + int + fdopen (const std::string&, + fdopen_mode, + permissions = permissions::ru | permissions::wu | + permissions::rg | permissions::wg | + permissions::ro | permissions::wo); + + int fdopen (const path&, fdopen_mode, permissions = permissions::ru | permissions::wu | @@ -177,17 +385,17 @@ namespace butl permissions::ro | permissions::wo); // Set the translation mode for the file descriptor. Return the previous - // mode on success, throw std::system_error otherwise. + // mode on success, throw ios::failure otherwise. // - fdtranslate - fdmode (int, fdtranslate); + fdstream_mode + fdmode (int, fdstream_mode); // Convenience functions for setting the translation mode for standard // streams. // - fdtranslate stdin_fdmode (fdtranslate); - fdtranslate stdout_fdmode (fdtranslate); - fdtranslate stderr_fdmode (fdtranslate); + fdstream_mode stdin_fdmode (fdstream_mode); + fdstream_mode stdout_fdmode (fdstream_mode); + fdstream_mode stderr_fdmode (fdstream_mode); // Low-level, nothrow file descriptor API. // diff --git a/butl/fdstream.cxx b/butl/fdstream.cxx index e4d11ba..e2095ba 100644 --- a/butl/fdstream.cxx +++ b/butl/fdstream.cxx @@ -5,27 +5,69 @@ #include <butl/fdstream> #ifndef _WIN32 -# include <fcntl.h> // open(), O_* -# include <unistd.h> // close(), read(), write() -# include <sys/stat.h> // S_I* +# include <fcntl.h> // open(), O_* +# include <unistd.h> // close(), read(), write(), lseek() +# include <sys/stat.h> // S_I* +# include <sys/types.h> // off_t #else -# include <io.h> // _close(), _read(), _write(), _setmode(), _sopen() +# include <io.h> // _close(), _read(), _write(), _setmode(), _sopen(), + // _lseek() # include <share.h> // _SH_DENYNO # include <stdio.h> // _fileno(), stdin, stdout, stderr # include <fcntl.h> // _O_* # include <sys/stat.h> // S_I* #endif +#include <errno.h> // errno, E* + +#include <ios> // ios_base::openmode, ios_base::failure +#include <limits> // numeric_limits +#include <cassert> +#include <exception> // uncaught_exception() +#include <stdexcept> // invalid_argument +#include <type_traits> #include <system_error> using namespace std; namespace butl { + // throw_ios_failure + // + template <bool = is_base_of<system_error, ios_base::failure>::value> + struct throw_ios + { + static void impl (error_code e, const char* m) { + throw ios_base::failure (m, e);} + }; + + template <> + struct throw_ios<false> + { + static void impl (error_code, const char* m) {throw ios_base::failure (m);} + }; + + inline void + throw_ios_failure (int ev) + { + error_code ec (ev, system_category ()); + throw_ios<>::impl (ec, ec.message ().c_str ()); + } + + inline void + throw_ios_failure (int ev, const char* m) + { + throw_ios<>::impl (error_code (ev, system_category ()), m); + } + // fdbuf // fdbuf:: - ~fdbuf () {close ();} + ~fdbuf () + { + if (is_open ()) + fdclose (fd_); // Don't check for an error as not much we can do here. + } void fdbuf:: open (int fd) @@ -42,7 +84,7 @@ namespace butl if (is_open ()) { if (!fdclose (fd_)) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); fd_ = -1; } @@ -78,7 +120,7 @@ namespace butl #endif if (n == -1) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); setg (buf_, buf_, buf_ + n); return n != 0; @@ -117,6 +159,10 @@ namespace butl if (n != 0) { + // Note that for MinGW GCC (5.2.0) _write() returns 0 for a file + // descriptor opened for read-only access (while -1 with errno EBADF is + // expected). This is in contrast with VC's _write() and POSIX's write(). + // #ifndef _WIN32 ssize_t m (write (fd_, buf_, n)); #else @@ -124,7 +170,7 @@ namespace butl #endif if (m == -1) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); if (n != static_cast<size_t> (m)) return false; @@ -138,19 +184,188 @@ namespace butl // fdstream_base // fdstream_base:: - fdstream_base (int fd, fdtranslate m) + fdstream_base (int fd, fdstream_mode m) : fdstream_base (fd) // Delegate. { // Note that here we rely on fdstream_base() (and fdbuf() which it calls) - // to note read from the file. + // to not read from the file. + // + if (fd != -1 && + ((m & fdstream_mode::text) == fdstream_mode::text || + (m & fdstream_mode::binary) == fdstream_mode::binary)) + fdmode (fd, m); + } + + static fdopen_mode + translate_mode (ios_base::openmode m) + { + enum + { + in = ios_base::in, + out = ios_base::out, + app = ios_base::app, + bin = ios_base::binary, + trunc = ios_base::trunc, + ate = ios_base::ate + }; + + const fdopen_mode fd_in (fdopen_mode::in); + const fdopen_mode fd_out (fdopen_mode::out); + const fdopen_mode fd_inout (fdopen_mode::in | fdopen_mode::out); + const fdopen_mode fd_app (fdopen_mode::append); + const fdopen_mode fd_trunc (fdopen_mode::truncate); + const fdopen_mode fd_create (fdopen_mode::create); + const fdopen_mode fd_bin (fdopen_mode::binary); + const fdopen_mode fd_ate (fdopen_mode::at_end); + + fdopen_mode r; + switch (m & ~(ate | bin)) + { + case in : r = fd_in ; break; + case out : + case out | trunc : r = fd_out | fd_trunc | fd_create ; break; + case app : + case out | app : r = fd_out | fd_app | fd_create ; break; + case out | in : r = fd_inout ; break; + case out | in | trunc : r = fd_inout | fd_trunc | fd_create ; break; + case out | in | app : + case in | app : r = fd_inout | fd_app | fd_create ; break; + + default: throw invalid_argument ("invalid open mode"); + } + + if (m & ate) + r |= fd_ate; + + if (m & bin) + r |= fd_bin; + + return r; + } + + // ifdstream + // + ifdstream:: + ifdstream (const char* f, openmode m, iostate e) + : ifdstream (f, translate_mode (m | in), e) // Delegate. + { + } + + ifdstream:: + ifdstream (const char* f, fdopen_mode m, iostate e) + : ifdstream (fdopen (f, m | fdopen_mode::in), e) // Delegate. + { + } + + ifdstream:: + ~ifdstream () + { + if (skip_ && is_open () && good ()) + { + // Clear the exception mask to prevent ignore() from throwing. + // + exceptions (goodbit); + ignore (numeric_limits<streamsize>::max ()); + } + + // Underlying file descriptor is closed by fdbuf dtor with errors (if any) + // being ignored. + // + } + + void ifdstream:: + open (const char* f, openmode m) + { + open (f, translate_mode (m | in)); + } + + void ifdstream:: + open (const char* f, fdopen_mode m) + { + open (fdopen (f, m | fdopen_mode::in)); + } + + void ifdstream:: + close () + { + if (skip_ && is_open () && good ()) + ignore (numeric_limits<streamsize>::max ()); + + buf_.close (); + } + + ifdstream& + getline (ifdstream& is, string& s, char delim) + { + ifdstream::iostate eb (is.exceptions ()); + assert (eb & ifdstream::badbit); + + // Amend the exception mask to prevent exceptions being thrown by the C++ + // IO runtime to avoid incompatibility issues due to ios_base::failure ABI + // fiasco (#66145). We will not restore the mask when ios_base::failure is + // thrown by fdbuf since there is no way to "silently" restore it if the + // corresponding bits are in the error state without the exceptions() call + // throwing ios_base::failure. Not restoring exception mask on throwing + // because of badbit should probably be ok since the stream is no longer + // usable. // - fdmode (fd, m); + if (eb != ifdstream::badbit) + is.exceptions (ifdstream::badbit); + + std::getline (is, s, delim); + + // Throw if any of the newly set bits are present in the exception mask. + // + if ((is.rdstate () & eb) != ifdstream::goodbit) + throw_ios_failure (EIO, "getline failure"); + + if (eb != ifdstream::badbit) + is.exceptions (eb); // Restore exception mask. + + return is; + } + + // ofdstream + // + ofdstream:: + ofdstream (const char* f, openmode m, iostate e) + : ofdstream (f, translate_mode (m | out), e) // Delegate. + { + } + + ofdstream:: + ofdstream (const char* f, fdopen_mode m, iostate e) + : ofdstream (fdopen (f, m | fdopen_mode::out), e) // Delegate. + { + } + + ofdstream:: + ~ofdstream () + { + // Enforce explicit close(). Note that we may have false negatives but not + // false positives. Specifically, we will fail to enforce if someone is + // using ofdstream in a dtor being called while unwinding the stack due to + // an exception. + // + assert (!is_open () || !good () || uncaught_exception ()); + } + + void ofdstream:: + open (const char* f, openmode m) + { + open (f, translate_mode (m | out)); + } + + void ofdstream:: + open (const char* f, fdopen_mode m) + { + open (fdopen (f, m | fdopen_mode::out)); } // Utility functions // int - fdopen (const path& f, fdopen_mode m, permissions p) + fdopen (const char* f, fdopen_mode m, permissions p) { mode_t pf (S_IREAD | S_IWRITE | S_IEXEC); @@ -202,7 +417,7 @@ namespace butl of |= O_LARGEFILE; #endif - int fd (open (f.string ().c_str (), of, pf)); + int fd (open (f, of, pf)); #else @@ -240,27 +455,46 @@ namespace butl // bool pass_perm (of & _O_CREAT); - if (pass_perm && file_exists (f)) + if (pass_perm && file_exists (path (f))) { // If the _O_CREAT flag is set then we need to clear it so that we can // omit the permissions. But if the _O_EXCL flag is set as well we can't // do that as fdopen() wouldn't fail as expected. // if (of & _O_EXCL) - throw system_error (EEXIST, system_category ()); + throw_ios_failure (EEXIST); of &= ~_O_CREAT; pass_perm = false; } int fd (pass_perm - ? _sopen (f.string ().c_str (), of, _SH_DENYNO, pf) - : _sopen (f.string ().c_str (), of, _SH_DENYNO)); + ? _sopen (f, of, _SH_DENYNO, pf) + : _sopen (f, of, _SH_DENYNO)); #endif if (fd == -1) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); + + if (mode (fdopen_mode::at_end)) + { +#ifndef _WIN32 + bool r (lseek(fd, 0, SEEK_END) != static_cast<off_t>(-1)); +#else + bool r (_lseek(fd, 0, SEEK_END) != -1); +#endif + + // Note that in the case of an error we don't delete the newly created + // file as we have no indication if it is a new one. + // + if (!r) + { + int e (errno); + fdclose (fd); // Doesn't throw, but can change errno. + throw_ios_failure (e); + } + } return fd; } @@ -279,28 +513,28 @@ namespace butl return open ("/dev/null", O_RDWR); } - fdtranslate - fdmode (int, fdtranslate) + fdstream_mode + fdmode (int, fdstream_mode) { - return fdtranslate::binary; + return fdstream_mode::binary; } - fdtranslate - stdin_fdmode (fdtranslate) + fdstream_mode + stdin_fdmode (fdstream_mode) { - return fdtranslate::binary; + return fdstream_mode::binary; } - fdtranslate - stdout_fdmode (fdtranslate) + fdstream_mode + stdout_fdmode (fdstream_mode) { - return fdtranslate::binary; + return fdstream_mode::binary; } - fdtranslate - stderr_fdmode (fdtranslate) + fdstream_mode + stderr_fdmode (fdstream_mode) { - return fdtranslate::binary; + return fdstream_mode::binary; } #else @@ -317,44 +551,51 @@ namespace butl return _sopen ("nul", _O_RDWR, _SH_DENYNO); } - fdtranslate - fdmode (int fd, fdtranslate m) + fdstream_mode + fdmode (int fd, fdstream_mode m) { - int r (_setmode (fd, m == fdtranslate::binary ? _O_BINARY : _O_TEXT)); + m &= fdstream_mode::text | fdstream_mode::binary; + + // Should be exactly one translation flag specified. + // + if (m != fdstream_mode::binary && m != fdstream_mode::text) + throw invalid_argument ("invalid translation mode"); + + int r (_setmode (fd, m == fdstream_mode::binary ? _O_BINARY : _O_TEXT)); if (r == -1) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); return (r & _O_BINARY) == _O_BINARY - ? fdtranslate::binary - : fdtranslate::text; + ? fdstream_mode::binary + : fdstream_mode::text; } - fdtranslate - stdin_fdmode (fdtranslate m) + fdstream_mode + stdin_fdmode (fdstream_mode m) { int fd (_fileno (stdin)); if (fd == -1) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); return fdmode (fd, m); } - fdtranslate - stdout_fdmode (fdtranslate m) + fdstream_mode + stdout_fdmode (fdstream_mode m) { int fd (_fileno (stdout)); if (fd == -1) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); return fdmode (fd, m); } - fdtranslate - stderr_fdmode (fdtranslate m) + fdstream_mode + stderr_fdmode (fdstream_mode m) { int fd (_fileno (stderr)); if (fd == -1) - throw system_error (errno, system_category ()); + throw_ios_failure (errno); return fdmode (fd, m); } diff --git a/butl/fdstream.ixx b/butl/fdstream.ixx index a3ea83c..c7c329b 100644 --- a/butl/fdstream.ixx +++ b/butl/fdstream.ixx @@ -2,8 +2,204 @@ // copyright : Copyright (c) 2014-2016 Code Synthesis Ltd // license : MIT; see accompanying LICENSE file +#include <cassert> + namespace butl { + // ifdstream + // + inline ifdstream:: + ifdstream () + : std::istream (&buf_) + { + exceptions (badbit | failbit); + } + + inline ifdstream:: + ifdstream (int fd, iostate e) + : fdstream_base (fd), std::istream (&buf_) + { + assert (e & badbit); + exceptions (e); + } + + inline ifdstream:: + ifdstream (int fd, fdstream_mode m, iostate e) + : fdstream_base (fd, m), + std::istream (&buf_), + skip_ ((m & fdstream_mode::skip) == fdstream_mode::skip) + { + assert (e & badbit); + exceptions (e); + } + + inline ifdstream:: + ifdstream (const std::string& f, openmode m, iostate e) + : ifdstream (f.c_str (), m, e) // Delegate. + { + } + + inline ifdstream:: + ifdstream (const path& f, openmode m, iostate e) + : ifdstream (f.string (), m, e) // Delegate. + { + } + + inline ifdstream:: + ifdstream (const std::string& f, fdopen_mode m, iostate e) + : ifdstream (f.c_str (), m, e) // Delegate. + { + } + + inline ifdstream:: + ifdstream (const path& f, fdopen_mode m, iostate e) + : ifdstream (f.string (), m, e) // Delegate. + { + } + + inline void ifdstream:: + open (const std::string& f, openmode m) + { + open (f.c_str (), m); + } + + inline void ifdstream:: + open (const path& f, openmode m) + { + open (f.string (), m); + } + + inline void ifdstream:: + open (const std::string& f, fdopen_mode m) + { + open (f.c_str (), m); + } + + inline void ifdstream:: + open (const path& f, fdopen_mode m) + { + open (f.string (), m); + } + + // ofdstream + // + inline ofdstream:: + ofdstream () + : std::ostream (&buf_) + { + exceptions (badbit | failbit); + } + + inline ofdstream:: + ofdstream (int fd, iostate e) + : fdstream_base (fd), std::ostream (&buf_) + { + assert (e & badbit); + exceptions (e); + } + + inline ofdstream:: + ofdstream (int fd, fdstream_mode m, iostate e) + : fdstream_base (fd, m), std::ostream (&buf_) + { + assert (e & badbit); + exceptions (e); + } + + inline ofdstream:: + ofdstream (const std::string& f, openmode m, iostate e) + : ofdstream (f.c_str (), m, e) // Delegate. + { + } + + inline ofdstream:: + ofdstream (const path& f, openmode m, iostate e) + : ofdstream (f.string (), m, e) // Delegate. + { + } + + inline ofdstream:: + ofdstream (const std::string& f, fdopen_mode m, iostate e) + : ofdstream (f.c_str (), m, e) // Delegate. + { + } + + inline ofdstream:: + ofdstream (const path& f, fdopen_mode m, iostate e) + : ofdstream (f.string (), m, e) // Delegate. + { + } + + inline void ofdstream:: + open (const std::string& f, openmode m) + { + open (f.c_str (), m); + } + + inline void ofdstream:: + open (const path& f, openmode m) + { + open (f.string (), m); + } + + inline void ofdstream:: + open (const std::string& f, fdopen_mode m) + { + open (f.c_str (), m); + } + + inline void ofdstream:: + open (const path& f, fdopen_mode m) + { + open (f.string (), m); + } + + // fdopen() + // + inline int + fdopen (const std::string& f, fdopen_mode m, permissions p) + { + return fdopen (f.c_str (), m, p); + } + + inline int + fdopen (const path& f, fdopen_mode m, permissions p) + { + return fdopen (f.string (), m, p); + } + + // fdstream_mode + // + inline fdstream_mode + operator& (fdstream_mode x, fdstream_mode y) + { + return x &= y; + } + + inline fdstream_mode + operator| (fdstream_mode x, fdstream_mode y) + { + return x |= y; + } + + inline fdstream_mode + operator&= (fdstream_mode& x, fdstream_mode y) + { + return x = static_cast<fdstream_mode> ( + static_cast<std::uint16_t> (x) & + static_cast<std::uint16_t> (y)); + } + + inline fdstream_mode + operator|= (fdstream_mode& x, fdstream_mode y) + { + return x = static_cast<fdstream_mode> ( + static_cast<std::uint16_t> (x) | + static_cast<std::uint16_t> (y)); + } + + // fdopen_mode + // inline fdopen_mode operator& (fdopen_mode x, fdopen_mode y) {return x &= y;} inline fdopen_mode operator| (fdopen_mode x, fdopen_mode y) {return x |= y;} diff --git a/butl/filesystem.cxx b/butl/filesystem.cxx index eab62dc..cabe306 100644 --- a/butl/filesystem.cxx +++ b/butl/filesystem.cxx @@ -227,13 +227,7 @@ namespace butl cpfile (const path& from, const path& to, cpflags fl) { permissions perm (path_permissions (from)); - - // We do not enable exceptions to be thrown when badbit/failbit are set for - // the ifs stream nor check the bits manually down the road as there is no - // input functions being called for the stream. Input functions are called - // directly for the input stream buffer, which is our fdbuf that throws. - // - ifdstream ifs (fdopen (from, fdopen_mode::in | fdopen_mode::binary)); + ifdstream ifs (from, fdopen_mode::binary); fdopen_mode om (fdopen_mode::out | fdopen_mode::truncate | @@ -249,34 +243,15 @@ namespace butl auto_rmfile rm; ofdstream ofs (fdopen (to, om, perm)); - rm = auto_rmfile (to); - // Setting badbit for the ofs stream is the only way to make sure the - // original std::system_error, that is thrown on the output operation - // failure, is retrown by the output stream's operator<<() and flush() - // calls (the latter is called from close()). Note that both of the - // functions behave as UnformattedOutputFunction. - // - ofs.exceptions (ofdstream::badbit); + rm = auto_rmfile (to); - // If the output operation ends up with the badbit set for a reason other - // than std::system_error being thrown (by fdbuf), then ofdstream::failure - // will be thrown instead. We need to convert it to std::system_error to - // comply with the cpfile() interface specification. + // Throws ios::failure on fdbuf read/write failures. // - try - { - // Throws std::system_error on fdbuf read/write failures. - // - ofs << ifs.rdbuf (); + ofs << ifs.rdbuf (); - ifs.close (); - ofs.close (); // Throws std::system_error on flush failure. - } - catch (const ofdstream::failure& e) - { - throw system_error (EIO, system_category (), e.what ()); - } + ifs.close (); // Throws ios::failure on failure. + ofs.close (); // Throws ios::failure on flush/close failure. if ((fl & cpflags::overwrite_permissions) == cpflags::overwrite_permissions) @@ -45,7 +45,7 @@ namespace butl class pager: protected std::streambuf { public: - ~pager () {wait ();} + ~pager () {wait (true);} // If verbose is true, then print (to STDERR) the pager command line. // @@ -58,7 +58,7 @@ namespace butl stream () {return os_.is_open () ? os_ : std::cout;} bool - wait (); + wait (bool ignore_errors = false); // The streambuf output interface that implements indentation. You can // override it to implement custom output pre-processing. diff --git a/butl/pager.cxx b/butl/pager.cxx index 0f29bb4..3d429f5 100644 --- a/butl/pager.cxx +++ b/butl/pager.cxx @@ -5,20 +5,20 @@ #include <butl/pager> #ifndef _WIN32 -# include <unistd.h> // close(), STDOUT_FILENO +# include <unistd.h> // STDOUT_FILENO # include <sys/ioctl.h> // ioctl() # include <chrono> # include <thread> // this_thread::sleep_for() #else # include <butl/win32-utility> - -# include <io.h> // _close() #endif #include <cstring> // strchr() #include <system_error> +#include <butl/fdstream> // fdclose() + using namespace std; namespace butl @@ -130,11 +130,8 @@ namespace butl bool r; if (p_.try_wait (r)) { -#ifndef _WIN32 - close (p_.out_fd); -#else - _close (p_.out_fd); -#endif + fdclose (p_.out_fd); + if (pager != nullptr) throw system_error (ECHILD, system_category ()); } @@ -162,7 +159,7 @@ namespace butl } bool pager:: - wait () + wait (bool ie) { // Teardown the indentation machinery. // @@ -172,8 +169,13 @@ namespace butl buf_ = nullptr; } + // Prevent ofdstream::close() from throwing in the ignore errors mode. + // + if (ie) + os_.exceptions (ofdstream::goodbit); + os_.close (); - return p_.wait (); + return p_.wait (ie); } pager::int_type pager:: diff --git a/butl/process b/butl/process index 54a8dae..e864b53 100644 --- a/butl/process +++ b/butl/process @@ -88,13 +88,13 @@ namespace butl process (const char* cwd, char const* const[], process&, int = 1, int = 2); // Wait for the process to terminate. Return true if the process - // terminated normally and with the zero exit status. Throw - // process_error if anything goes wrong. This function can be - // called multiple times with subsequent calls simply returning - // the status. + // terminated normally and with the zero exit status. Unless ignore_error + // is true, throw process_error if anything goes wrong. This function can + // be called multiple times with subsequent calls simply returning the + // status. // bool - wait (); + wait (bool ignore_errors = false); // Return true if the process has already terminated in which case // the argument is set to the result of wait(). @@ -102,7 +102,10 @@ namespace butl bool try_wait (bool&); - ~process () {if (handle != 0) wait ();} + // Note that the destructor will wait for the process but will ignore + // any errors and the exit status. + // + ~process () {if (handle != 0) wait (true);} // Moveable-only type. // diff --git a/butl/process.cxx b/butl/process.cxx index e67e12e..9bb0ea2 100644 --- a/butl/process.cxx +++ b/butl/process.cxx @@ -196,7 +196,7 @@ namespace butl } bool process:: - wait () + wait (bool ie) { if (handle != 0) { @@ -204,7 +204,18 @@ namespace butl handle = 0; // We have tried. if (r == -1) - throw process_error (errno, false); + { + if (!ie) + throw process_error (errno, false); + else + // Fold into status, so this and subsequent wait() calls return + // false. There is no portable way to update the status bits + // representing a process exit code specifically. So we set all bits + // to 1 and recon on getting non-zero exit status wherever the exact + // bits are. + // + status = ~0; + } } return WIFEXITED (status) && WEXITSTATUS (status) == 0; @@ -571,7 +582,7 @@ namespace butl } bool process:: - wait () + wait (bool ie) { if (handle != 0) { @@ -584,10 +595,15 @@ namespace butl auto_handle h (handle); // Auto-deleter. handle = 0; // We have tried. - if (e != NO_ERROR) - throw process_error (error_msg (e)); - - status = s; + if (e == NO_ERROR) + status = s; + else + { + if (!ie) + throw process_error (error_msg (e)); + else + status = 1; // Fold into status. + } } return status == 0; |