X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/88749b5dc18eb5708af20185e4339e76bda6fb72..dae197476f1831269d13f4e990276ce25c483842:/apt-pkg/contrib/fileutl.cc diff --git a/apt-pkg/contrib/fileutl.cc b/apt-pkg/contrib/fileutl.cc index 71dfc83a2..94d1432cf 100644 --- a/apt-pkg/contrib/fileutl.cc +++ b/apt-pkg/contrib/fileutl.cc @@ -63,6 +63,9 @@ #ifdef HAVE_LZMA #include #endif +#ifdef HAVE_LZ4 + #include +#endif #include #include @@ -75,6 +78,9 @@ using namespace std; +/* Should be a multiple of the common page size (4096) */ +static constexpr unsigned long long APT_BUFFER_SIZE = 64 * 1024; + // RunScripts - Run a set of scripts from a configuration subtree /*{{{*/ // --------------------------------------------------------------------- /* */ @@ -160,7 +166,7 @@ bool CopyFile(FileFd &From,FileFd &To) return false; // Buffered copy between fds - constexpr size_t BufSize = 64000; + constexpr size_t BufSize = APT_BUFFER_SIZE; std::unique_ptr Buf(new unsigned char[BufSize]); unsigned long long ToRead = 0; do { @@ -920,16 +926,35 @@ bool ChangeOwnerAndPermissionOfFile(char const * const requester, char const * c /*}}}*/ struct APT_HIDDEN simple_buffer { /*{{{*/ - static constexpr size_t buffersize_max = 4096; + size_t buffersize_max = 0; unsigned long long bufferstart = 0; unsigned long long bufferend = 0; - char buffer[buffersize_max]; + char *buffer = nullptr; + + simple_buffer() { + reset(4096); + } + ~simple_buffer() { + delete[] buffer; + } const char *get() const { return buffer + bufferstart; } char *get() { return buffer + bufferstart; } + const char *getend() const { return buffer + bufferend; } + char *getend() { return buffer + bufferend; } bool empty() const { return bufferend <= bufferstart; } bool full() const { return bufferend == buffersize_max; } + unsigned long long free() const { return buffersize_max - bufferend; } unsigned long long size() const { return bufferend-bufferstart; } + void reset(size_t size) + { + if (size > buffersize_max) { + delete[] buffer; + buffersize_max = size; + buffer = new char[size]; + } + reset(); + } void reset() { bufferend = bufferstart = 0; } ssize_t read(void *to, unsigned long long requested_size) APT_MUSTCHECK { @@ -943,9 +968,9 @@ struct APT_HIDDEN simple_buffer { /*{{{*/ } ssize_t write(const void *from, unsigned long long requested_size) APT_MUSTCHECK { - if (buffersize_max - size() < requested_size) - requested_size = buffersize_max - size(); - memcpy(buffer + bufferend, from, requested_size); + if (free() < requested_size) + requested_size = free(); + memcpy(getend(), from, requested_size); bufferend += requested_size; if (bufferstart == bufferend) bufferstart = bufferend = 0; @@ -1029,7 +1054,7 @@ public: { buffer.reset(); unsigned long long actualread = 0; - if (filefd->Read(buffer.get(), buffer.buffersize_max, &actualread) == false) + if (filefd->Read(buffer.getend(), buffer.free(), &actualread) == false) return nullptr; buffer.bufferend = actualread; if (buffer.size() == 0) @@ -1094,6 +1119,7 @@ public: return filefd->FileFdError("Seek on file %s because it couldn't be reopened", filefd->FileName.c_str()); buffer.reset(); + set_seekpos(0); if (To != 0) return filefd->Skip(To); @@ -1150,7 +1176,7 @@ public: virtual ~FileFdPrivate() {} }; /*}}}*/ -class APT_HIDDEN BufferedWriteFileFdPrivate : public FileFdPrivate { /*{{{*/ +class APT_HIDDEN BufferedWriteFileFdPrivate : public FileFdPrivate { /*{{{*/ protected: FileFdPrivate *wrapped; simple_buffer writebuffer; @@ -1160,135 +1186,133 @@ public: explicit BufferedWriteFileFdPrivate(FileFdPrivate *Priv) : FileFdPrivate(Priv->filefd), wrapped(Priv) {}; - virtual APT::Configuration::Compressor get_compressor() const override + virtual APT::Configuration::Compressor get_compressor() const APT_OVERRIDE { return wrapped->get_compressor(); } - virtual void set_compressor(APT::Configuration::Compressor const &compressor) override + virtual void set_compressor(APT::Configuration::Compressor const &compressor) APT_OVERRIDE { return wrapped->set_compressor(compressor); } - virtual unsigned int get_openmode() const override + virtual unsigned int get_openmode() const APT_OVERRIDE { return wrapped->get_openmode(); } - virtual void set_openmode(unsigned int openmode) override + virtual void set_openmode(unsigned int openmode) APT_OVERRIDE { return wrapped->set_openmode(openmode); } - virtual bool get_is_pipe() const override + virtual bool get_is_pipe() const APT_OVERRIDE { return wrapped->get_is_pipe(); } - virtual void set_is_pipe(bool is_pipe) override + virtual void set_is_pipe(bool is_pipe) APT_OVERRIDE { FileFdPrivate::set_is_pipe(is_pipe); wrapped->set_is_pipe(is_pipe); } - virtual unsigned long long get_seekpos() const override + virtual unsigned long long get_seekpos() const APT_OVERRIDE { return wrapped->get_seekpos(); } - virtual void set_seekpos(unsigned long long seekpos) override + virtual void set_seekpos(unsigned long long seekpos) APT_OVERRIDE { return wrapped->set_seekpos(seekpos); } - virtual bool InternalOpen(int const iFd, unsigned int const Mode) override + virtual bool InternalOpen(int const iFd, unsigned int const Mode) APT_OVERRIDE { if (InternalFlush() == false) return false; return wrapped->InternalOpen(iFd, Mode); } - virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) override + virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) APT_OVERRIDE { if (InternalFlush() == false) return -1; return wrapped->InternalUnbufferedRead(To, Size); } - virtual bool InternalReadError() override + virtual bool InternalReadError() APT_OVERRIDE { return wrapped->InternalReadError(); } - virtual char * InternalReadLine(char * To, unsigned long long Size) override + virtual char * InternalReadLine(char * To, unsigned long long Size) APT_OVERRIDE { if (InternalFlush() == false) return nullptr; return wrapped->InternalReadLine(To, Size); } - virtual bool InternalFlush() override + virtual bool InternalFlush() APT_OVERRIDE { - size_t written = 0; - char *data = writebuffer.get(); - auto size = writebuffer.size(); - - while (written <= size) { - auto written_this_time = wrapped->InternalWrite(data + written, size - written); - if (written_this_time < 0) - return false; - if (written_this_time == 0) - break; + while (writebuffer.empty() == false) { + auto written = wrapped->InternalWrite(writebuffer.get(), + writebuffer.size()); + // Ignore interrupted syscalls + if (written < 0 && errno == EINTR) + continue; + if (written < 0) + return wrapped->InternalWriteError(); - written += written_this_time; + writebuffer.bufferstart += written; } writebuffer.reset(); return true; } - virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) override + virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) APT_OVERRIDE { - size_t written = 0; + // Optimisation: If the buffer is empty and we have more to write than + // would fit in the buffer (or equal number of bytes), write directly. + if (writebuffer.empty() == true && Size >= writebuffer.free()) + return wrapped->InternalWrite(From, Size); - while (written < Size) { - auto buffered = writebuffer.write(static_cast(From) + written, Size - written); + // Write as much into the buffer as possible and then flush if needed + auto written = writebuffer.write(From, Size); - written += buffered; - - if (writebuffer.full() && InternalFlush() == false) - return -1; - } + if (writebuffer.full() && InternalFlush() == false) + return -1; return written; } - virtual bool InternalWriteError() + virtual bool InternalWriteError() APT_OVERRIDE { return wrapped->InternalWriteError(); } - virtual bool InternalSeek(unsigned long long const To) + virtual bool InternalSeek(unsigned long long const To) APT_OVERRIDE { if (InternalFlush() == false) return false; return wrapped->InternalSeek(To); } - virtual bool InternalSkip(unsigned long long Over) + virtual bool InternalSkip(unsigned long long Over) APT_OVERRIDE { if (InternalFlush() == false) return false; return wrapped->InternalSkip(Over); } - virtual bool InternalTruncate(unsigned long long const Size) + virtual bool InternalTruncate(unsigned long long const Size) APT_OVERRIDE { if (InternalFlush() == false) return false; return wrapped->InternalTruncate(Size); } - virtual unsigned long long InternalTell() + virtual unsigned long long InternalTell() APT_OVERRIDE { if (InternalFlush() == false) return -1; return wrapped->InternalTell(); } - virtual unsigned long long InternalSize() + virtual unsigned long long InternalSize() APT_OVERRIDE { if (InternalFlush() == false) return -1; return wrapped->InternalSize(); } - virtual bool InternalClose(std::string const &FileName) + virtual bool InternalClose(std::string const &FileName) APT_OVERRIDE { return wrapped->InternalClose(FileName); } - virtual bool InternalAlwaysAutoClose() const + virtual bool InternalAlwaysAutoClose() const APT_OVERRIDE { return wrapped->InternalAlwaysAutoClose(); } @@ -1302,7 +1326,7 @@ class APT_HIDDEN GzipFileFdPrivate: public FileFdPrivate { /*{{{*/ #ifdef HAVE_ZLIB public: gzFile gz; - virtual bool InternalOpen(int const iFd, unsigned int const Mode) override + virtual bool InternalOpen(int const iFd, unsigned int const Mode) APT_OVERRIDE { if ((Mode & FileFd::ReadWrite) == FileFd::ReadWrite) gz = gzdopen(iFd, "r+"); @@ -1313,11 +1337,11 @@ public: filefd->Flags |= FileFd::Compressed; return gz != nullptr; } - virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) override + virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) APT_OVERRIDE { return gzread(gz, To, Size); } - virtual bool InternalReadError() override + virtual bool InternalReadError() APT_OVERRIDE { int err; char const * const errmsg = gzerror(gz, &err); @@ -1325,15 +1349,15 @@ public: return filefd->FileFdError("gzread: %s (%d: %s)", _("Read error"), err, errmsg); return FileFdPrivate::InternalReadError(); } - virtual char * InternalReadLine(char * To, unsigned long long Size) override + virtual char * InternalReadLine(char * To, unsigned long long Size) APT_OVERRIDE { return gzgets(gz, To, Size); } - virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) override + virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) APT_OVERRIDE { return gzwrite(gz,From,Size); } - virtual bool InternalWriteError() override + virtual bool InternalWriteError() APT_OVERRIDE { int err; char const * const errmsg = gzerror(gz, &err); @@ -1341,7 +1365,7 @@ public: return filefd->FileFdError("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg); return FileFdPrivate::InternalWriteError(); } - virtual bool InternalSeek(unsigned long long const To) override + virtual bool InternalSeek(unsigned long long const To) APT_OVERRIDE { off_t const res = gzseek(gz, To, SEEK_SET); if (res != (off_t)To) @@ -1350,7 +1374,7 @@ public: buffer.reset(); return true; } - virtual bool InternalSkip(unsigned long long Over) override + virtual bool InternalSkip(unsigned long long Over) APT_OVERRIDE { if (Over >= buffer.size()) { @@ -1370,11 +1394,11 @@ public: seekpos = res; return true; } - virtual unsigned long long InternalTell() override + virtual unsigned long long InternalTell() APT_OVERRIDE { return gztell(gz) - buffer.size(); } - virtual unsigned long long InternalSize() override + virtual unsigned long long InternalSize() APT_OVERRIDE { unsigned long long filesize = FileFdPrivate::InternalSize(); // only check gzsize if we are actually a gzip file, just checking for @@ -1408,7 +1432,7 @@ public: } return size; } - virtual bool InternalClose(std::string const &FileName) override + virtual bool InternalClose(std::string const &FileName) APT_OVERRIDE { if (gz == nullptr) return true; @@ -1429,7 +1453,7 @@ class APT_HIDDEN Bz2FileFdPrivate: public FileFdPrivate { /*{{{*/ #ifdef HAVE_BZ2 BZFILE* bz2; public: - virtual bool InternalOpen(int const iFd, unsigned int const Mode) override + virtual bool InternalOpen(int const iFd, unsigned int const Mode) APT_OVERRIDE { if ((Mode & FileFd::ReadWrite) == FileFd::ReadWrite) bz2 = BZ2_bzdopen(iFd, "r+"); @@ -1440,11 +1464,11 @@ public: filefd->Flags |= FileFd::Compressed; return bz2 != nullptr; } - virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) override + virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) APT_OVERRIDE { return BZ2_bzread(bz2, To, Size); } - virtual bool InternalReadError() override + virtual bool InternalReadError() APT_OVERRIDE { int err; char const * const errmsg = BZ2_bzerror(bz2, &err); @@ -1452,11 +1476,11 @@ public: return filefd->FileFdError("BZ2_bzread: %s %s (%d: %s)", filefd->FileName.c_str(), _("Read error"), err, errmsg); return FileFdPrivate::InternalReadError(); } - virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) override + virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) APT_OVERRIDE { return BZ2_bzwrite(bz2, (void*)From, Size); } - virtual bool InternalWriteError() override + virtual bool InternalWriteError() APT_OVERRIDE { int err; char const * const errmsg = BZ2_bzerror(bz2, &err); @@ -1464,8 +1488,8 @@ public: return filefd->FileFdError("BZ2_bzwrite: %s %s (%d: %s)", filefd->FileName.c_str(), _("Write error"), err, errmsg); return FileFdPrivate::InternalWriteError(); } - virtual bool InternalStream() const override { return true; } - virtual bool InternalClose(std::string const &) override + virtual bool InternalStream() const APT_OVERRIDE { return true; } + virtual bool InternalClose(std::string const &) APT_OVERRIDE { if (bz2 == nullptr) return true; @@ -1477,22 +1501,182 @@ public: explicit Bz2FileFdPrivate(FileFd * const filefd) : FileFdPrivate(filefd), bz2(nullptr) {} virtual ~Bz2FileFdPrivate() { InternalClose(""); } #endif +}; + /*}}}*/ +class APT_HIDDEN Lz4FileFdPrivate: public FileFdPrivate { /*{{{*/ + static constexpr unsigned long long LZ4_HEADER_SIZE = 19; + static constexpr unsigned long long LZ4_FOOTER_SIZE = 4; +#ifdef HAVE_LZ4 + LZ4F_decompressionContext_t dctx; + LZ4F_compressionContext_t cctx; + LZ4F_errorCode_t res; + FileFd backend; + simple_buffer lz4_buffer; + // Count of bytes that the decompressor expects to read next, or buffer size. + size_t next_to_load = APT_BUFFER_SIZE; +public: + virtual bool InternalOpen(int const iFd, unsigned int const Mode) APT_OVERRIDE + { + if ((Mode & FileFd::ReadWrite) == FileFd::ReadWrite) + return _error->Error("lz4 only supports write or read mode"); + + if ((Mode & FileFd::WriteOnly) == FileFd::WriteOnly) { + res = LZ4F_createCompressionContext(&cctx, LZ4F_VERSION); + lz4_buffer.reset(LZ4F_compressBound(APT_BUFFER_SIZE, nullptr) + + LZ4_HEADER_SIZE + LZ4_FOOTER_SIZE); + } else { + res = LZ4F_createDecompressionContext(&dctx, LZ4F_VERSION); + lz4_buffer.reset(APT_BUFFER_SIZE); + } + + filefd->Flags |= FileFd::Compressed; + + if (LZ4F_isError(res)) + return false; + + unsigned int flags = (Mode & (FileFd::WriteOnly|FileFd::ReadOnly)); + if (backend.OpenDescriptor(iFd, flags, FileFd::None, true) == false) + return false; + + // Write the file header + if ((Mode & FileFd::WriteOnly) == FileFd::WriteOnly) + { + res = LZ4F_compressBegin(cctx, lz4_buffer.buffer, lz4_buffer.buffersize_max, nullptr); + if (LZ4F_isError(res) || backend.Write(lz4_buffer.buffer, res) == false) + return false; + } + + return true; + } + virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) APT_OVERRIDE + { + /* Keep reading as long as the compressor still wants to read */ + while (next_to_load) { + // Fill compressed buffer; + if (lz4_buffer.empty()) { + unsigned long long read; + /* Reset - if LZ4 decompressor wants to read more, allocate more */ + lz4_buffer.reset(next_to_load); + if (backend.Read(lz4_buffer.getend(), lz4_buffer.free(), &read) == false) + return -1; + lz4_buffer.bufferend += read; + + /* Expected EOF */ + if (read == 0) { + res = -1; + return filefd->FileFdError("LZ4F: %s %s", + filefd->FileName.c_str(), + _("Unexpected end of file")), -1; + } + } + // Drain compressed buffer as far as possible. + size_t in = lz4_buffer.size(); + size_t out = Size; + + res = LZ4F_decompress(dctx, To, &out, lz4_buffer.get(), &in, nullptr); + if (LZ4F_isError(res)) + return -1; + + next_to_load = res; + lz4_buffer.bufferstart += in; + + if (out != 0) + return out; + } + + return 0; + } + virtual bool InternalReadError() APT_OVERRIDE + { + char const * const errmsg = LZ4F_getErrorName(res); + + return filefd->FileFdError("LZ4F: %s %s (%zu: %s)", filefd->FileName.c_str(), _("Read error"), res, errmsg); + } + virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) APT_OVERRIDE + { + unsigned long long const towrite = std::min(APT_BUFFER_SIZE, Size); + + res = LZ4F_compressUpdate(cctx, + lz4_buffer.buffer, lz4_buffer.buffersize_max, + From, towrite, nullptr); + + if (LZ4F_isError(res) || backend.Write(lz4_buffer.buffer, res) == false) + return -1; + + return towrite; + } + virtual bool InternalWriteError() APT_OVERRIDE + { + char const * const errmsg = LZ4F_getErrorName(res); + + return filefd->FileFdError("LZ4F: %s %s (%zu: %s)", filefd->FileName.c_str(), _("Write error"), res, errmsg); + } + virtual bool InternalStream() const APT_OVERRIDE { return true; } + + virtual bool InternalFlush() APT_OVERRIDE + { + return backend.Flush(); + } + + virtual bool InternalClose(std::string const &) APT_OVERRIDE + { + /* Reset variables */ + res = 0; + next_to_load = APT_BUFFER_SIZE; + + if (cctx != nullptr) + { + if (filefd->Failed() == false) + { + res = LZ4F_compressEnd(cctx, lz4_buffer.buffer, lz4_buffer.buffersize_max, nullptr); + if (LZ4F_isError(res) || backend.Write(lz4_buffer.buffer, res) == false) + return false; + if (!backend.Flush()) + return false; + } + if (!backend.Close()) + return false; + + res = LZ4F_freeCompressionContext(cctx); + cctx = nullptr; + } + + if (dctx != nullptr) + { + res = LZ4F_freeDecompressionContext(dctx); + dctx = nullptr; + } + if (backend.IsOpen()) + { + backend.Close(); + filefd->iFd = -1; + } + + return LZ4F_isError(res) == false; + } + + explicit Lz4FileFdPrivate(FileFd * const filefd) : FileFdPrivate(filefd), dctx(nullptr), cctx(nullptr) {} + virtual ~Lz4FileFdPrivate() { + InternalClose(""); + } +#endif }; /*}}}*/ class APT_HIDDEN LzmaFileFdPrivate: public FileFdPrivate { /*{{{*/ #ifdef HAVE_LZMA struct LZMAFILE { FILE* file; + FileFd * const filefd; uint8_t buffer[4096]; lzma_stream stream; lzma_ret err; bool eof; bool compressing; - LZMAFILE() : file(nullptr), eof(false), compressing(false) { buffer[0] = '\0'; } + LZMAFILE(FileFd * const fd) : file(nullptr), filefd(fd), eof(false), compressing(false) { buffer[0] = '\0'; } ~LZMAFILE() { - if (compressing == true) + if (compressing == true && filefd->Failed() == false) { size_t constexpr buffersize = sizeof(buffer)/sizeof(buffer[0]); while(true) @@ -1547,13 +1731,13 @@ class APT_HIDDEN LzmaFileFdPrivate: public FileFdPrivate { /*{{{*/ return 6; } public: - virtual bool InternalOpen(int const iFd, unsigned int const Mode) override + virtual bool InternalOpen(int const iFd, unsigned int const Mode) APT_OVERRIDE { if ((Mode & FileFd::ReadWrite) == FileFd::ReadWrite) return filefd->FileFdError("ReadWrite mode is not supported for lzma/xz files %s", filefd->FileName.c_str()); if (lzma == nullptr) - lzma = new LzmaFileFdPrivate::LZMAFILE; + lzma = new LzmaFileFdPrivate::LZMAFILE(filefd); if ((Mode & FileFd::WriteOnly) == FileFd::WriteOnly) lzma->file = fdopen(iFd, "w"); else @@ -1599,7 +1783,7 @@ public: } return true; } - virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) override + virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) APT_OVERRIDE { ssize_t Res; if (lzma->eof == true) @@ -1635,12 +1819,13 @@ public: } return Res; } - virtual bool InternalReadError() override + virtual bool InternalReadError() APT_OVERRIDE { return filefd->FileFdError("lzma_read: %s (%d)", _("Read error"), lzma->err); } - virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) override + virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) APT_OVERRIDE { + ssize_t Res; lzma->stream.next_in = (uint8_t *)From; lzma->stream.avail_in = Size; lzma->stream.next_out = lzma->buffer; @@ -1651,16 +1836,28 @@ public: size_t const n = sizeof(lzma->buffer)/sizeof(lzma->buffer[0]) - lzma->stream.avail_out; size_t const m = (n == 0) ? 0 : fwrite(lzma->buffer, 1, n, lzma->file); if (m != n) - return -1; + { + Res = -1; + errno = 0; + } else - return Size - lzma->stream.avail_in; + { + Res = Size - lzma->stream.avail_in; + if (Res == 0) + { + // lzma run was okay, but produced no output… + Res = -1; + errno = EINTR; + } + } + return Res; } - virtual bool InternalWriteError() override + virtual bool InternalWriteError() APT_OVERRIDE { return filefd->FileFdError("lzma_write: %s (%d)", _("Write error"), lzma->err); } - virtual bool InternalStream() const override { return true; } - virtual bool InternalClose(std::string const &) override + virtual bool InternalStream() const APT_OVERRIDE { return true; } + virtual bool InternalClose(std::string const &) APT_OVERRIDE { delete lzma; lzma = nullptr; @@ -1677,7 +1874,7 @@ class APT_HIDDEN PipedFileFdPrivate: public FileFdPrivate /*{{{*/ by executing a specified binary and pipe in/out what we need */ { public: - virtual bool InternalOpen(int const, unsigned int const Mode) override + virtual bool InternalOpen(int const, unsigned int const Mode) APT_OVERRIDE { // collect zombies here in case we reopen if (compressor_pid > 0) @@ -1775,17 +1972,22 @@ public: return true; } - virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) override + virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) APT_OVERRIDE { return read(filefd->iFd, To, Size); } - virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) override + virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) APT_OVERRIDE { return write(filefd->iFd, From, Size); } - virtual bool InternalClose(std::string const &) override + virtual bool InternalClose(std::string const &) APT_OVERRIDE { bool Ret = true; + if (filefd->iFd != -1) + { + close(filefd->iFd); + filefd->iFd = -1; + } if (compressor_pid > 0) Ret &= ExecWait(compressor_pid, "FileFdCompressor", true); compressor_pid = -1; @@ -1798,12 +2000,12 @@ public: class APT_HIDDEN DirectFileFdPrivate: public FileFdPrivate /*{{{*/ { public: - virtual bool InternalOpen(int const, unsigned int const) override { return true; } - virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) override + virtual bool InternalOpen(int const, unsigned int const) APT_OVERRIDE { return true; } + virtual ssize_t InternalUnbufferedRead(void * const To, unsigned long long const Size) APT_OVERRIDE { return read(filefd->iFd, To, Size); } - virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) override + virtual ssize_t InternalWrite(void const * const From, unsigned long long const Size) APT_OVERRIDE { // files opened read+write are strange and only really "supported" for direct files if (buffer.size() != 0) @@ -1813,7 +2015,7 @@ public: } return write(filefd->iFd, From, Size); } - virtual bool InternalSeek(unsigned long long const To) override + virtual bool InternalSeek(unsigned long long const To) APT_OVERRIDE { off_t const res = lseek(filefd->iFd, To, SEEK_SET); if (res != (off_t)To) @@ -1822,7 +2024,7 @@ public: buffer.reset(); return true; } - virtual bool InternalSkip(unsigned long long Over) override + virtual bool InternalSkip(unsigned long long Over) APT_OVERRIDE { if (Over >= buffer.size()) { @@ -1842,7 +2044,7 @@ public: seekpos = res; return true; } - virtual bool InternalTruncate(unsigned long long const To) override + virtual bool InternalTruncate(unsigned long long const To) APT_OVERRIDE { if (buffer.size() != 0) { @@ -1858,16 +2060,16 @@ public: return filefd->FileFdError("Unable to truncate to %llu",To); return true; } - virtual unsigned long long InternalTell() override + virtual unsigned long long InternalTell() APT_OVERRIDE { return lseek(filefd->iFd,0,SEEK_CUR) - buffer.size(); } - virtual unsigned long long InternalSize() override + virtual unsigned long long InternalSize() APT_OVERRIDE { return filefd->FileSize(); } - virtual bool InternalClose(std::string const &) override { return true; } - virtual bool InternalAlwaysAutoClose() const override { return false; } + virtual bool InternalClose(std::string const &) APT_OVERRIDE { return true; } + virtual bool InternalAlwaysAutoClose() const APT_OVERRIDE { return false; } explicit DirectFileFdPrivate(FileFd * const filefd) : FileFdPrivate(filefd) {} virtual ~DirectFileFdPrivate() { InternalClose(""); } @@ -1951,6 +2153,7 @@ bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress, case Bzip2: name = "bzip2"; break; case Lzma: name = "lzma"; break; case Xz: name = "xz"; break; + case Lz4: name = "lz4"; break; case Auto: case Extension: // Unreachable @@ -2067,6 +2270,7 @@ bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compre case Bzip2: name = "bzip2"; break; case Lzma: name = "lzma"; break; case Xz: name = "xz"; break; + case Lz4: name = "lz4"; break; case Auto: case Extension: if (AutoClose == true && Fd != -1) @@ -2128,6 +2332,9 @@ bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::C APT_COMPRESS_INIT("xz", LzmaFileFdPrivate); APT_COMPRESS_INIT("lzma", LzmaFileFdPrivate); #endif +#ifdef HAVE_LZ4 + APT_COMPRESS_INIT("lz4", Lz4FileFdPrivate); +#endif #undef APT_COMPRESS_INIT else if (compressor.Name == "." || compressor.Binary.empty() == true) d = new DirectFileFdPrivate(this); @@ -2245,10 +2452,18 @@ bool FileFd::Write(const void *From,unsigned long long Size) while (Res > 0 && Size > 0) { Res = d->InternalWrite(From, Size); - if (Res < 0 && errno == EINTR) - continue; + if (Res < 0) + { + if (errno == EINTR) + { + // trick the while-loop into running again + Res = 1; + errno = 0; + continue; + } return d->InternalWriteError(); + } From = (char const *)From + Res; Size -= Res; @@ -2388,7 +2603,7 @@ unsigned long long FileFd::Size() /* */ bool FileFd::Close() { - if (Flush() == false) + if (Failed() == false && Flush() == false) return false; if (iFd == -1) return true;