]> git.saurik.com Git - apt.git/blobdiff - apt-pkg/contrib/fileutl.cc
* apt-pkg/contrib/fileutl.cc:
[apt.git] / apt-pkg / contrib / fileutl.cc
index 60396fc3dd771f54a5e93baf41ffd2f89bfc682e..c7f78cdfba787fecd21251c3fd3f7672c69cba05 100644 (file)
 #include <set>
 #include <algorithm>
 
 #include <set>
 #include <algorithm>
 
-// FIXME: Compressor Fds have some speed disadvantages and are a bit buggy currently,
-// so while the current implementation satisfies the testcases it is not a real option
-// to disable it for now
-#define APT_USE_ZLIB 1
-#if APT_USE_ZLIB
-#include <zlib.h>
-#else
-#warning "Usage of zlib is DISABLED!"
+#ifdef HAVE_ZLIB
+       #include <zlib.h>
+#endif
+#ifdef HAVE_BZ2
+       #include <bzlib.h>
 #endif
 
 #ifdef WORDS_BIGENDIAN
 #endif
 
 #ifdef WORDS_BIGENDIAN
@@ -65,16 +62,50 @@ using namespace std;
 
 class FileFdPrivate {
        public:
 
 class FileFdPrivate {
        public:
-#if APT_USE_ZLIB
+#ifdef HAVE_ZLIB
        gzFile gz;
 #else
        void* gz;
 #endif
        gzFile gz;
 #else
        void* gz;
 #endif
+#ifdef HAVE_BZ2
+       BZFILE* bz2;
+#else
+       void* bz2;
+#endif
+       int compressed_fd;
        pid_t compressor_pid;
        bool pipe;
        APT::Configuration::Compressor compressor;
        unsigned int openmode;
        pid_t compressor_pid;
        bool pipe;
        APT::Configuration::Compressor compressor;
        unsigned int openmode;
-       FileFdPrivate() : gz(NULL), compressor_pid(-1), pipe(false) {};
+       unsigned long long seekpos;
+       FileFdPrivate() : gz(NULL), bz2(NULL),
+                         compressed_fd(-1), compressor_pid(-1), pipe(false),
+                         openmode(0), seekpos(0) {};
+       bool CloseDown(std::string const &FileName)
+       {
+          bool Res = true;
+#ifdef HAVE_ZLIB
+          if (gz != NULL) {
+             int const e = gzclose(gz);
+             gz = NULL;
+             // gzdclose() on empty files always fails with "buffer error" here, ignore that
+             if (e != 0 && e != Z_BUF_ERROR)
+                Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
+          }
+#endif
+#ifdef HAVE_BZ2
+          if (bz2 != NULL) {
+             BZ2_bzclose(bz2);
+             bz2 = NULL;
+          }
+#endif
+          if (compressor_pid > 0)
+             ExecWait(compressor_pid, "FileFdCompressor", true);
+          compressor_pid = -1;
+
+          return Res;
+       }
+       ~FileFdPrivate() { CloseDown(""); }
 };
 
 // RunScripts - Run a set of scripts from a configuration subtree      /*{{{*/
 };
 
 // RunScripts - Run a set of scripts from a configuration subtree      /*{{{*/
@@ -384,6 +415,13 @@ std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> c
       {
         if (RealFileExists(File.c_str()) == false)
         {
       {
         if (RealFileExists(File.c_str()) == false)
         {
+           // do not show ignoration warnings for directories
+           if (
+#ifdef _DIRENT_HAVE_D_TYPE
+               Ent->d_type == DT_DIR ||
+#endif
+               DirectoryExists(File.c_str()) == true)
+              continue;
            if (SilentIgnore.Match(Ent->d_name) == false)
               _error->Notice(_("Ignoring '%s' in directory '%s' as it is not a regular file"), Ent->d_name, Dir.c_str());
            continue;
            if (SilentIgnore.Match(Ent->d_name) == false)
               _error->Notice(_("Ignoring '%s' in directory '%s' as it is not a regular file"), Ent->d_name, Dir.c_str());
            continue;
@@ -451,6 +489,80 @@ std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> c
    }
    closedir(D);
 
    }
    closedir(D);
 
+   if (SortList == true)
+      std::sort(List.begin(),List.end());
+   return List;
+}
+std::vector<string> GetListOfFilesInDir(string const &Dir, bool SortList)
+{
+   bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
+   if (Debug == true)
+      std::clog << "Accept in " << Dir << " all regular files" << std::endl;
+
+   std::vector<string> List;
+
+   if (DirectoryExists(Dir.c_str()) == false)
+   {
+      _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
+      return List;
+   }
+
+   DIR *D = opendir(Dir.c_str());
+   if (D == 0)
+   {
+      _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
+      return List;
+   }
+
+   for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D)) 
+   {
+      // skip "hidden" files
+      if (Ent->d_name[0] == '.')
+        continue;
+
+      // Make sure it is a file and not something else
+      string const File = flCombine(Dir,Ent->d_name);
+#ifdef _DIRENT_HAVE_D_TYPE
+      if (Ent->d_type != DT_REG)
+#endif
+      {
+        if (RealFileExists(File.c_str()) == false)
+        {
+           if (Debug == true)
+              std::clog << "Bad file: " << Ent->d_name << " → it is not a real file" << std::endl;
+           continue;
+        }
+      }
+
+      // Skip bad filenames ala run-parts
+      const char *C = Ent->d_name;
+      for (; *C != 0; ++C)
+        if (isalpha(*C) == 0 && isdigit(*C) == 0
+            && *C != '_' && *C != '-' && *C != '.')
+           break;
+
+      // we don't reach the end of the name -> bad character included
+      if (*C != 0)
+      {
+        if (Debug == true)
+           std::clog << "Bad file: " << Ent->d_name << " → bad character »" << *C << "« in filename" << std::endl;
+        continue;
+      }
+
+      // skip filenames which end with a period. These are never valid
+      if (*(C - 1) == '.')
+      {
+        if (Debug == true)
+           std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
+        continue;
+      }
+
+      if (Debug == true)
+        std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
+      List.push_back(File);
+   }
+   closedir(D);
+
    if (SortList == true)
       std::sort(List.begin(),List.end());
    return List;
    if (SortList == true)
       std::sort(List.begin(),List.end());
    return List;
@@ -740,187 +852,6 @@ bool ExecWait(pid_t Pid,const char *Name,bool Reap)
 }
                                                                        /*}}}*/
 
 }
                                                                        /*}}}*/
 
-// ExecCompressor - Open a de/compressor pipe                          /*{{{*/
-// ---------------------------------------------------------------------
-/* This opens the compressor, either in compress mode or decompress
-   mode. FileFd is always the compressor input/output file,
-   OutFd is the created pipe, Input for Compress, Output for Decompress. */
-bool ExecCompressor(APT::Configuration::Compressor const &Prog,
-                   pid_t *Pid, int const FileFd, int &OutFd, bool const Comp)
-{
-   if (Pid != NULL)
-      *Pid = -1;
-
-   // No compression
-   if (Prog.Binary.empty() == true)
-   {
-      OutFd = dup(FileFd);
-      return true;
-   }
-
-   // Handle 'decompression' of empty files
-   if (Comp == false)
-   {
-      struct stat Buf;
-      fstat(FileFd, &Buf);
-      if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
-      {
-        OutFd = FileFd;
-        return true;
-      }
-   }
-
-   // Create a data pipe
-   int Pipe[2] = {-1,-1};
-   if (pipe(Pipe) != 0)
-      return _error->Errno("pipe",_("Failed to create subprocess IPC"));
-   for (int J = 0; J != 2; J++)
-      SetCloseExec(Pipe[J],true);
-
-   if (Comp == true)
-      OutFd = Pipe[1];
-   else
-      OutFd = Pipe[0];
-
-   // The child..
-   pid_t child = ExecFork();
-   if (Pid != NULL)
-      *Pid = child;
-   if (child == 0)
-   {
-      if (Comp == true)
-      {
-        dup2(FileFd,STDOUT_FILENO);
-        dup2(Pipe[0],STDIN_FILENO);
-      }
-      else
-      {
-        dup2(FileFd,STDIN_FILENO);
-        dup2(Pipe[1],STDOUT_FILENO);
-      }
-
-      SetCloseExec(STDOUT_FILENO,false);
-      SetCloseExec(STDIN_FILENO,false);
-
-      std::vector<char const*> Args;
-      Args.push_back(Prog.Binary.c_str());
-      std::vector<std::string> const * const addArgs =
-               (Comp == true) ? &(Prog.CompressArgs) : &(Prog.UncompressArgs);
-      for (std::vector<std::string>::const_iterator a = addArgs->begin();
-          a != addArgs->end(); ++a)
-        Args.push_back(a->c_str());
-      Args.push_back(NULL);
-
-      execvp(Args[0],(char **)&Args[0]);
-      cerr << _("Failed to exec compressor ") << Args[0] << endl;
-      _exit(100);
-   }
-   if (Comp == true)
-      close(Pipe[0]);
-   else
-      close(Pipe[1]);
-
-   if (Pid == NULL)
-      ExecWait(child, Prog.Binary.c_str(), true);
-
-   return true;
-}
-bool ExecCompressor(APT::Configuration::Compressor const &Prog,
-                   pid_t *Pid, std::string const &FileName, int &OutFd, bool const Comp)
-{
-   if (Pid != NULL)
-      *Pid = -1;
-
-   // No compression
-   if (Prog.Binary.empty() == true)
-   {
-      if (Comp == true)
-        OutFd = open(FileName.c_str(), O_WRONLY, 0666);
-      else
-        OutFd = open(FileName.c_str(), O_RDONLY);
-      return true;
-   }
-
-   // Handle 'decompression' of empty files
-   if (Comp == false)
-   {
-      struct stat Buf;
-      stat(FileName.c_str(), &Buf);
-      if (Buf.st_size == 0)
-      {
-        OutFd = open(FileName.c_str(), O_RDONLY);
-        return true;
-      }
-   }
-
-   // Create a data pipe
-   int Pipe[2] = {-1,-1};
-   if (pipe(Pipe) != 0)
-      return _error->Errno("pipe",_("Failed to create subprocess IPC"));
-   for (int J = 0; J != 2; J++)
-      SetCloseExec(Pipe[J],true);
-
-   int FileFd = -1;
-   if (Comp == true)
-   {
-      OutFd = Pipe[1];
-      // FIXME: we should handle openmode and permission from Open() here
-      FileFd = open(FileName.c_str(), O_WRONLY, 0666);
-   }
-   else
-      OutFd = Pipe[0];
-
-   // The child..
-   pid_t child = ExecFork();
-   if (Pid != NULL)
-      *Pid = child;
-   if (child == 0)
-   {
-      if (Comp == true)
-      {
-        dup2(Pipe[0],STDIN_FILENO);
-        dup2(FileFd,STDOUT_FILENO);
-        SetCloseExec(STDIN_FILENO,false);
-      }
-      else
-      {
-        dup2(Pipe[1],STDOUT_FILENO);
-      }
-      SetCloseExec(STDOUT_FILENO,false);
-
-      std::vector<char const*> Args;
-      Args.push_back(Prog.Binary.c_str());
-      std::vector<std::string> const * const addArgs =
-               (Comp == true) ? &(Prog.CompressArgs) : &(Prog.UncompressArgs);
-      for (std::vector<std::string>::const_iterator a = addArgs->begin();
-          a != addArgs->end(); ++a)
-        Args.push_back(a->c_str());
-      if (Comp == false)
-      {
-        Args.push_back("--stdout");
-        Args.push_back(FileName.c_str());
-      }
-      Args.push_back(NULL);
-
-      execvp(Args[0],(char **)&Args[0]);
-      cerr << _("Failed to exec compressor ") << Args[0] << endl;
-      _exit(100);
-   }
-   if (Comp == true)
-   {
-      close(Pipe[0]);
-      close(FileFd);
-   }
-   else
-      close(Pipe[1]);
-
-   if (Pid == NULL)
-      ExecWait(child, Prog.Binary.c_str(), false);
-
-   return true;
-}
-                                                                       /*}}}*/
-
 // FileFd::Open - Open a file                                          /*{{{*/
 // ---------------------------------------------------------------------
 /* The most commonly used open mode combinations are given with Mode */
 // FileFd::Open - Open a file                                          /*{{{*/
 // ---------------------------------------------------------------------
 /* The most commonly used open mode combinations are given with Mode */
@@ -932,7 +863,6 @@ bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress,
    if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)
       return _error->Error("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());
 
    if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)
       return _error->Error("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());
 
-   // FIXME: Denote inbuilt compressors somehow - as we don't need to have the binaries for them
    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
    if (Compress == Auto)
    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
    if (Compress == Auto)
@@ -1000,8 +930,6 @@ bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress,
 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const Perms)
 {
    Close();
 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const Perms)
 {
    Close();
-   d = new FileFdPrivate;
-   d->openmode = Mode;
    Flags = AutoClose;
 
    if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)
    Flags = AutoClose;
 
    if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)
@@ -1028,81 +956,34 @@ bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Co
         unlink(FileName.c_str());
    }
 
         unlink(FileName.c_str());
    }
 
-   // if we have them, use inbuilt compressors instead of forking
-   if (compressor.Name != "."
-#if APT_USE_ZLIB
-       && compressor.Name != "gzip"
-#endif
-      )
-   {
-      if ((Mode & ReadWrite) == ReadWrite)
-        return _error->Error("External compressors like %s do not support readwrite mode for file %s", compressor.Name.c_str(), FileName.c_str());
+   int fileflags = 0;
+   #define if_FLAGGED_SET(FLAG, MODE) if ((Mode & FLAG) == FLAG) fileflags |= MODE
+   if_FLAGGED_SET(ReadWrite, O_RDWR);
+   else if_FLAGGED_SET(ReadOnly, O_RDONLY);
+   else if_FLAGGED_SET(WriteOnly, O_WRONLY);
 
 
-      if ((Mode & (WriteOnly | Create)) == (WriteOnly | Create))
-      {
-        if (TemporaryFileName.empty() == false)
-        {
-           if (RealFileExists(TemporaryFileName) == false)
-           {
-              iFd = open(TemporaryFileName.c_str(), O_WRONLY | O_CREAT, Perms);
-              close(iFd);
-              iFd = -1;
-           }
-        }
-        else if (RealFileExists(FileName) == false)
-        {
-           iFd = open(FileName.c_str(), O_WRONLY | O_CREAT, Perms);
-           close(iFd);
-           iFd = -1;
-        }
-      }
+   if_FLAGGED_SET(Create, O_CREAT);
+   if_FLAGGED_SET(Empty, O_TRUNC);
+   if_FLAGGED_SET(Exclusive, O_EXCL);
+   else if_FLAGGED_SET(Atomic, O_EXCL);
+   #undef if_FLAGGED_SET
 
 
-      if (TemporaryFileName.empty() == false)
-      {
-        if (ExecCompressor(compressor, &(d->compressor_pid), TemporaryFileName, iFd, ((Mode & ReadOnly) != ReadOnly)) == false)
-           return _error->Error("Forking external compressor %s is not implemented for %s", compressor.Name.c_str(), TemporaryFileName.c_str());
-      }
-      else
-      {
-        if (ExecCompressor(compressor, &(d->compressor_pid), FileName, iFd, ((Mode & ReadOnly) != ReadOnly)) == false)
-           return _error->Error("Forking external compressor %s is not implemented for %s", compressor.Name.c_str(), FileName.c_str());
-      }
-      d->pipe = true;
-      d->compressor = compressor;
-   }
+   if (TemporaryFileName.empty() == false)
+      iFd = open(TemporaryFileName.c_str(), fileflags, Perms);
    else
    else
-   {
-      int fileflags = 0;
-      #define if_FLAGGED_SET(FLAG, MODE) if ((Mode & FLAG) == FLAG) fileflags |= MODE
-      if_FLAGGED_SET(ReadWrite, O_RDWR);
-      else if_FLAGGED_SET(ReadOnly, O_RDONLY);
-      else if_FLAGGED_SET(WriteOnly, O_WRONLY);
-
-      if_FLAGGED_SET(Create, O_CREAT);
-      if_FLAGGED_SET(Exclusive, O_EXCL);
-      else if_FLAGGED_SET(Atomic, O_EXCL);
-      if_FLAGGED_SET(Empty, O_TRUNC);
-      #undef if_FLAGGED_SET
-
-      if (TemporaryFileName.empty() == false)
-        iFd = open(TemporaryFileName.c_str(), fileflags, Perms);
-      else
-        iFd = open(FileName.c_str(), fileflags, Perms);
+      iFd = open(FileName.c_str(), fileflags, Perms);
 
 
+   this->FileName = FileName;
+   if (iFd == -1 || OpenInternDescriptor(Mode, compressor) == false)
+   {
       if (iFd != -1)
       {
       if (iFd != -1)
       {
-        if (OpenInternDescriptor(Mode, compressor) == false)
-        {
-           close (iFd);
-           iFd = -1;
-        }
+        close (iFd);
+        iFd = -1;
       }
       }
+      return _error->Errno("open",_("Could not open file %s"), FileName.c_str());
    }
 
    }
 
-   if (iFd == -1)
-      return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
-
-   this->FileName = FileName;
    SetCloseExec(iFd,true);
    return true;
 }
    SetCloseExec(iFd,true);
    return true;
 }
@@ -1115,6 +996,11 @@ bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compre
    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
    std::string name;
    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
    std::string name;
+
+   // compat with the old API
+   if (Mode == ReadOnlyGzip && Compress == None)
+      Compress = Gzip;
+
    switch (Compress)
    {
    case None: name = "."; break;
    switch (Compress)
    {
    case None: name = "."; break;
@@ -1137,39 +1023,169 @@ bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compre
 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
 {
    Close();
 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
 {
    Close();
-   d = new FileFdPrivate;
-   d->openmode = Mode;
    Flags = (AutoClose) ? FileFd::AutoClose : 0;
    iFd = Fd;
    Flags = (AutoClose) ? FileFd::AutoClose : 0;
    iFd = Fd;
+   this->FileName = "";
    if (OpenInternDescriptor(Mode, compressor) == false)
    {
       if (AutoClose)
         close (iFd);
       return _error->Errno("gzdopen",_("Could not open file descriptor %d"), Fd);
    }
    if (OpenInternDescriptor(Mode, compressor) == false)
    {
       if (AutoClose)
         close (iFd);
       return _error->Errno("gzdopen",_("Could not open file descriptor %d"), Fd);
    }
-   this->FileName = "";
    return true;
 }
 bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor)
 {
    return true;
 }
 bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor)
 {
-   if (compressor.Name == ".")
+   if (compressor.Name == "." || compressor.Binary.empty() == true)
       return true;
       return true;
-#if APT_USE_ZLIB
-   else if (compressor.Name == "gzip")
+
+   if (d == NULL)
+   {
+      d = new FileFdPrivate();
+      d->openmode = Mode;
+      d->compressor = compressor;
+   }
+
+#ifdef HAVE_ZLIB
+   if (compressor.Name == "gzip")
    {
    {
+      if (d->gz != NULL)
+      {
+        gzclose(d->gz);
+        d->gz = NULL;
+      }
       if ((Mode & ReadWrite) == ReadWrite)
         d->gz = gzdopen(iFd, "r+");
       else if ((Mode & WriteOnly) == WriteOnly)
         d->gz = gzdopen(iFd, "w");
       else
       if ((Mode & ReadWrite) == ReadWrite)
         d->gz = gzdopen(iFd, "r+");
       else if ((Mode & WriteOnly) == WriteOnly)
         d->gz = gzdopen(iFd, "w");
       else
-        d->gz = gzdopen (iFd, "r");
+        d->gz = gzdopen(iFd, "r");
       if (d->gz == NULL)
         return false;
       Flags |= Compressed;
       if (d->gz == NULL)
         return false;
       Flags |= Compressed;
+      return true;
+   }
+#endif
+#ifdef HAVE_BZ2
+   if (compressor.Name == "bzip2")
+   {
+      if (d->bz2 != NULL)
+      {
+        BZ2_bzclose(d->bz2);
+        d->bz2 = NULL;
+      }
+      if ((Mode & ReadWrite) == ReadWrite)
+        d->bz2 = BZ2_bzdopen(iFd, "r+");
+      else if ((Mode & WriteOnly) == WriteOnly)
+        d->bz2 = BZ2_bzdopen(iFd, "w");
+      else
+        d->bz2 = BZ2_bzdopen(iFd, "r");
+      if (d->bz2 == NULL)
+        return false;
+      Flags |= Compressed;
+      return true;
    }
 #endif
    }
 #endif
+
+   // collect zombies here in case we reopen
+   if (d->compressor_pid > 0)
+      ExecWait(d->compressor_pid, "FileFdCompressor", true);
+
+   if ((Mode & ReadWrite) == ReadWrite)
+   {
+      Flags |= Fail;
+      return _error->Error("ReadWrite mode is not supported for file %s", FileName.c_str());
+   }
+
+   bool const Comp = (Mode & WriteOnly) == WriteOnly;
+   if (Comp == false)
+   {
+      // Handle 'decompression' of empty files
+      struct stat Buf;
+      fstat(iFd, &Buf);
+      if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
+        return true;
+
+      // We don't need the file open - instead let the compressor open it
+      // as he properly knows better how to efficiently read from 'his' file
+      if (FileName.empty() == false)
+      {
+        close(iFd);
+        iFd = -1;
+      }
+   }
+
+   // Create a data pipe
+   int Pipe[2] = {-1,-1};
+   if (pipe(Pipe) != 0)
+   {
+      Flags |= Fail;
+      return _error->Errno("pipe",_("Failed to create subprocess IPC"));
+   }
+   for (int J = 0; J != 2; J++)
+      SetCloseExec(Pipe[J],true);
+
+   d->compressed_fd = iFd;
+   d->pipe = true;
+
+   if (Comp == true)
+      iFd = Pipe[1];
    else
    else
-      return _error->Error("Can't find a match for specified compressor %s for file %s", compressor.Name.c_str(), FileName.c_str());
+      iFd = Pipe[0];
+
+   // The child..
+   d->compressor_pid = ExecFork();
+   if (d->compressor_pid == 0)
+   {
+      if (Comp == true)
+      {
+        dup2(d->compressed_fd,STDOUT_FILENO);
+        dup2(Pipe[0],STDIN_FILENO);
+      }
+      else
+      {
+        if (FileName.empty() == true)
+           dup2(d->compressed_fd,STDIN_FILENO);
+        dup2(Pipe[1],STDOUT_FILENO);
+      }
+      int const nullfd = open("/dev/null", O_WRONLY);
+      if (nullfd != -1)
+      {
+        dup2(nullfd,STDERR_FILENO);
+        close(nullfd);
+      }
+
+      SetCloseExec(STDOUT_FILENO,false);
+      SetCloseExec(STDIN_FILENO,false);
+
+      std::vector<char const*> Args;
+      Args.push_back(compressor.Binary.c_str());
+      std::vector<std::string> const * const addArgs =
+               (Comp == true) ? &(compressor.CompressArgs) : &(compressor.UncompressArgs);
+      for (std::vector<std::string>::const_iterator a = addArgs->begin();
+          a != addArgs->end(); ++a)
+        Args.push_back(a->c_str());
+      if (Comp == false && FileName.empty() == false)
+      {
+        Args.push_back("--stdout");
+        if (TemporaryFileName.empty() == false)
+           Args.push_back(TemporaryFileName.c_str());
+        else
+           Args.push_back(FileName.c_str());
+      }
+      Args.push_back(NULL);
+
+      execvp(Args[0],(char **)&Args[0]);
+      cerr << _("Failed to exec compressor ") << Args[0] << endl;
+      _exit(100);
+   }
+   if (Comp == true)
+      close(Pipe[0]);
+   else
+      close(Pipe[1]);
+   if ((Comp == true || FileName.empty() == true) && d->compressed_fd != -1)
+      close(d->compressed_fd);
+
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
@@ -1180,6 +1196,12 @@ bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::C
 FileFd::~FileFd()
 {
    Close();
 FileFd::~FileFd()
 {
    Close();
+   if (d != NULL)
+   {
+      d->CloseDown(FileName);
+      delete d;
+      d = NULL;
+   }
 }
                                                                        /*}}}*/
 // FileFd::Read - Read a bit of the file                               /*{{{*/
 }
                                                                        /*}}}*/
 // FileFd::Read - Read a bit of the file                               /*{{{*/
@@ -1195,22 +1217,48 @@ bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
    *((char *)To) = '\0';
    do
    {
    *((char *)To) = '\0';
    do
    {
-#if APT_USE_ZLIB
-      if (d->gz != NULL)
-         Res = gzread(d->gz,To,Size);
+#ifdef HAVE_ZLIB
+      if (d != NULL && d->gz != NULL)
+        Res = gzread(d->gz,To,Size);
+      else
+#endif
+#ifdef HAVE_BZ2
+      if (d != NULL && d->bz2 != NULL)
+        Res = BZ2_bzread(d->bz2,To,Size);
       else
 #endif
          Res = read(iFd,To,Size);
       else
 #endif
          Res = read(iFd,To,Size);
-      if (Res < 0 && errno == EINTR)
-        continue;
+
       if (Res < 0)
       {
       if (Res < 0)
       {
+        if (errno == EINTR)
+           continue;
         Flags |= Fail;
         Flags |= Fail;
+#ifdef HAVE_ZLIB
+        if (d != NULL && d->gz != NULL)
+        {
+           int err;
+           char const * const errmsg = gzerror(d->gz, &err);
+           if (err != Z_ERRNO)
+              return _error->Error("gzread: %s (%d: %s)", _("Read error"), err, errmsg);
+        }
+#endif
+#ifdef HAVE_BZ2
+        if (d != NULL && d->bz2 != NULL)
+        {
+           int err;
+           char const * const errmsg = BZ2_bzerror(d->bz2, &err);
+           if (err != BZ_IO_ERROR)
+              return _error->Error("BZ2_bzread: %s (%d: %s)", _("Read error"), err, errmsg);
+        }
+#endif
         return _error->Errno("read",_("Read error"));
       }
       
       To = (char *)To + Res;
       Size -= Res;
         return _error->Errno("read",_("Read error"));
       }
       
       To = (char *)To + Res;
       Size -= Res;
+      if (d != NULL)
+        d->seekpos += Res;
       if (Actual != 0)
         *Actual += Res;
    }
       if (Actual != 0)
         *Actual += Res;
    }
@@ -1237,21 +1285,25 @@ bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
 char* FileFd::ReadLine(char *To, unsigned long long const Size)
 {
    *To = '\0';
 char* FileFd::ReadLine(char *To, unsigned long long const Size)
 {
    *To = '\0';
-#if APT_USE_ZLIB
-   if (d->gz != NULL)
+#ifdef HAVE_ZLIB
+   if (d != NULL && d->gz != NULL)
       return gzgets(d->gz, To, Size);
 #endif
 
    unsigned long long read = 0;
       return gzgets(d->gz, To, Size);
 #endif
 
    unsigned long long read = 0;
-   if (Read(To, Size, &read) == false)
+   while ((Size - 1) != read)
+   {
+      unsigned long long done = 0;
+      if (Read(To + read, 1, &done) == false)
+        return NULL;
+      if (done == 0)
+        break;
+      if (To[read++] == '\n')
+        break;
+   }
+   if (read == 0)
       return NULL;
       return NULL;
-   char* c = To;
-   for (; *c != '\n' && *c != '\0' && read != 0; --read, ++c)
-      ; // find the end of the line
-   if (*c != '\0')
-      *c = '\0';
-   if (read != 0)
-      Seek(Tell() - read);
+   To[read] = '\0';
    return To;
 }
                                                                        /*}}}*/
    return To;
 }
                                                                        /*}}}*/
@@ -1264,10 +1316,15 @@ bool FileFd::Write(const void *From,unsigned long long Size)
    errno = 0;
    do
    {
    errno = 0;
    do
    {
-#if APT_USE_ZLIB
-      if (d->gz != NULL)
+#ifdef HAVE_ZLIB
+      if (d != NULL && d->gz != NULL)
          Res = gzwrite(d->gz,From,Size);
       else
          Res = gzwrite(d->gz,From,Size);
       else
+#endif
+#ifdef HAVE_BZ2
+      if (d != NULL && d->bz2 != NULL)
+         Res = BZ2_bzwrite(d->bz2,(void*)From,Size);
+      else
 #endif
          Res = write(iFd,From,Size);
       if (Res < 0 && errno == EINTR)
 #endif
          Res = write(iFd,From,Size);
       if (Res < 0 && errno == EINTR)
@@ -1275,11 +1332,31 @@ bool FileFd::Write(const void *From,unsigned long long Size)
       if (Res < 0)
       {
         Flags |= Fail;
       if (Res < 0)
       {
         Flags |= Fail;
+#ifdef HAVE_ZLIB
+        if (d != NULL && d->gz != NULL)
+        {
+           int err;
+           char const * const errmsg = gzerror(d->gz, &err);
+           if (err != Z_ERRNO)
+              return _error->Error("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
+        }
+#endif
+#ifdef HAVE_BZ2
+        if (d != NULL && d->bz2 != NULL)
+        {
+           int err;
+           char const * const errmsg = BZ2_bzerror(d->bz2, &err);
+           if (err != BZ_IO_ERROR)
+              return _error->Error("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
+        }
+#endif
         return _error->Errno("write",_("Write error"));
       }
       
       From = (char *)From + Res;
       Size -= Res;
         return _error->Errno("write",_("Write error"));
       }
       
       From = (char *)From + Res;
       Size -= Res;
+      if (d != NULL)
+        d->seekpos += Res;
    }
    while (Res > 0 && Size > 0);
    
    }
    while (Res > 0 && Size > 0);
    
@@ -1288,6 +1365,28 @@ bool FileFd::Write(const void *From,unsigned long long Size)
    
    Flags |= Fail;
    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
    
    Flags |= Fail;
    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
+}
+bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
+{
+   int Res;
+   errno = 0;
+   do
+   {
+      Res = write(Fd,From,Size);
+      if (Res < 0 && errno == EINTR)
+        continue;
+      if (Res < 0)
+        return _error->Errno("write",_("Write error"));
+
+      From = (char *)From + Res;
+      Size -= Res;
+   }
+   while (Res > 0 && Size > 0);
+
+   if (Size == 0)
+      return true;
+
+   return _error->Error(_("write, still have %llu to write but couldn't"), Size);
 }
                                                                        /*}}}*/
 // FileFd::Seek - Seek in the file                                     /*{{{*/
 }
                                                                        /*}}}*/
 // FileFd::Seek - Seek in the file                                     /*{{{*/
@@ -1295,18 +1394,62 @@ bool FileFd::Write(const void *From,unsigned long long Size)
 /* */
 bool FileFd::Seek(unsigned long long To)
 {
 /* */
 bool FileFd::Seek(unsigned long long To)
 {
-   if (d->pipe == true)
+   if (d != NULL && (d->pipe == true
+#ifdef HAVE_BZ2
+                       || d->bz2 != NULL
+#endif
+       ))
    {
    {
-      // FIXME: What about OpenDescriptor() stuff here?
-      close(iFd);
-      bool result = ExecCompressor(d->compressor, NULL, FileName, iFd, (d->openmode & ReadOnly) != ReadOnly);
-      if (result == true && To != 0)
-        result &= Skip(To);
-      return result;
+      // Our poor man seeking in pipes is costly, so try to avoid it
+      unsigned long long seekpos = Tell();
+      if (seekpos == To)
+        return true;
+      else if (seekpos < To)
+        return Skip(To - seekpos);
+
+      if ((d->openmode & ReadOnly) != ReadOnly)
+      {
+        Flags |= Fail;
+        return _error->Error("Reopen is only implemented for read-only files!");
+      }
+#ifdef HAVE_BZ2
+      if (d->bz2 != NULL)
+        BZ2_bzclose(d->bz2);
+#endif
+      if (iFd != -1)
+        close(iFd);
+      iFd = -1;
+      if (TemporaryFileName.empty() == false)
+        iFd = open(TemporaryFileName.c_str(), O_RDONLY);
+      else if (FileName.empty() == false)
+        iFd = open(FileName.c_str(), O_RDONLY);
+      else
+      {
+        if (d->compressed_fd > 0)
+           if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
+              iFd = d->compressed_fd;
+        if (iFd < 0)
+        {
+           Flags |= Fail;
+           return _error->Error("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");
+        }
+      }
+
+      if (OpenInternDescriptor(d->openmode, d->compressor) == false)
+      {
+        Flags |= Fail;
+        return _error->Error("Seek on file %s because it couldn't be reopened", FileName.c_str());
+      }
+
+      if (To != 0)
+        return Skip(To);
+
+      d->seekpos = To;
+      return true;
    }
    int res;
    }
    int res;
-#if APT_USE_ZLIB
-   if (d->gz)
+#ifdef HAVE_ZLIB
+   if (d != NULL && d->gz)
       res = gzseek(d->gz,To,SEEK_SET);
    else
 #endif
       res = gzseek(d->gz,To,SEEK_SET);
    else
 #endif
@@ -1316,7 +1459,9 @@ bool FileFd::Seek(unsigned long long To)
       Flags |= Fail;
       return _error->Error("Unable to seek to %llu", To);
    }
       Flags |= Fail;
       return _error->Error("Unable to seek to %llu", To);
    }
-   
+
+   if (d != NULL)
+      d->seekpos = To;
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
@@ -1325,9 +1470,30 @@ bool FileFd::Seek(unsigned long long To)
 /* */
 bool FileFd::Skip(unsigned long long Over)
 {
 /* */
 bool FileFd::Skip(unsigned long long Over)
 {
+   if (d != NULL && (d->pipe == true
+#ifdef HAVE_BZ2
+                       || d->bz2 != NULL
+#endif
+       ))
+   {
+      d->seekpos += Over;
+      char buffer[1024];
+      while (Over != 0)
+      {
+        unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
+        if (Read(buffer, toread) == false)
+        {
+           Flags |= Fail;
+           return _error->Error("Unable to seek ahead %llu",Over);
+        }
+        Over -= toread;
+      }
+      return true;
+   }
+
    int res;
    int res;
-#if APT_USE_ZLIB
-   if (d->gz != NULL)
+#ifdef HAVE_ZLIB
+   if (d != NULL && d->gz != NULL)
       res = gzseek(d->gz,Over,SEEK_CUR);
    else
 #endif
       res = gzseek(d->gz,Over,SEEK_CUR);
    else
 #endif
@@ -1337,7 +1503,9 @@ bool FileFd::Skip(unsigned long long Over)
       Flags |= Fail;
       return _error->Error("Unable to seek ahead %llu",Over);
    }
       Flags |= Fail;
       return _error->Error("Unable to seek ahead %llu",Over);
    }
-   
+   if (d != NULL)
+      d->seekpos = res;
+
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
@@ -1346,11 +1514,13 @@ bool FileFd::Skip(unsigned long long Over)
 /* */
 bool FileFd::Truncate(unsigned long long To)
 {
 /* */
 bool FileFd::Truncate(unsigned long long To)
 {
-   if (d->gz != NULL)
+#if defined HAVE_ZLIB || defined HAVE_BZ2
+   if (d != NULL && (d->gz != NULL || d->bz2 != NULL))
    {
       Flags |= Fail;
    {
       Flags |= Fail;
-      return _error->Error("Truncating gzipped files is not implemented (%s)", FileName.c_str());
+      return _error->Error("Truncating compressed files is not implemented (%s)", FileName.c_str());
    }
    }
+#endif
    if (ftruncate(iFd,To) != 0)
    {
       Flags |= Fail;
    if (ftruncate(iFd,To) != 0)
    {
       Flags |= Fail;
@@ -1365,15 +1535,31 @@ bool FileFd::Truncate(unsigned long long To)
 /* */
 unsigned long long FileFd::Tell()
 {
 /* */
 unsigned long long FileFd::Tell()
 {
+   // In theory, we could just return seekpos here always instead of
+   // seeking around, but not all users of FileFd use always Seek() and co
+   // so d->seekpos isn't always true and we can just use it as a hint if
+   // we have nothing else, but not always as an authority…
+   if (d != NULL && (d->pipe == true
+#ifdef HAVE_BZ2
+                       || d->bz2 != NULL
+#endif
+       ))
+      return d->seekpos;
+
    off_t Res;
    off_t Res;
-#if APT_USE_ZLIB
-   if (d->gz != NULL)
+#ifdef HAVE_ZLIB
+   if (d != NULL && d->gz != NULL)
      Res = gztell(d->gz);
    else
 #endif
      Res = lseek(iFd,0,SEEK_CUR);
    if (Res == (off_t)-1)
      Res = gztell(d->gz);
    else
 #endif
      Res = lseek(iFd,0,SEEK_CUR);
    if (Res == (off_t)-1)
+   {
+      Flags |= Fail;
       _error->Errno("lseek","Failed to determine the current file position");
       _error->Errno("lseek","Failed to determine the current file position");
+   }
+   if (d != NULL)
+      d->seekpos = Res;
    return Res;
 }
                                                                        /*}}}*/
    return Res;
 }
                                                                        /*}}}*/
@@ -1383,17 +1569,24 @@ unsigned long long FileFd::Tell()
 unsigned long long FileFd::FileSize()
 {
    struct stat Buf;
 unsigned long long FileFd::FileSize()
 {
    struct stat Buf;
-   if (d->pipe == false && fstat(iFd,&Buf) != 0)
+   if ((d == NULL || d->pipe == false) && fstat(iFd,&Buf) != 0)
+   {
+      Flags |= Fail;
       return _error->Errno("fstat","Unable to determine the file size");
       return _error->Errno("fstat","Unable to determine the file size");
+   }
 
    // for compressor pipes st_size is undefined and at 'best' zero
 
    // for compressor pipes st_size is undefined and at 'best' zero
-   if (d->pipe == true || S_ISFIFO(Buf.st_mode))
+   if ((d != NULL && d->pipe == true) || S_ISFIFO(Buf.st_mode))
    {
       // we set it here, too, as we get the info here for free
       // in theory the Open-methods should take care of it already
    {
       // we set it here, too, as we get the info here for free
       // in theory the Open-methods should take care of it already
-      d->pipe = true;
+      if (d != NULL)
+        d->pipe = true;
       if (stat(FileName.c_str(), &Buf) != 0)
       if (stat(FileName.c_str(), &Buf) != 0)
+      {
+        Flags |= Fail;
         return _error->Errno("stat","Unable to determine the file size");
         return _error->Errno("stat","Unable to determine the file size");
+      }
    }
 
    return Buf.st_size;
    }
 
    return Buf.st_size;
@@ -1408,34 +1601,43 @@ unsigned long long FileFd::Size()
 
    // for compressor pipes st_size is undefined and at 'best' zero,
    // so we 'read' the content and 'seek' back - see there
 
    // for compressor pipes st_size is undefined and at 'best' zero,
    // so we 'read' the content and 'seek' back - see there
-   if (d->pipe == true)
+   if (d != NULL && (d->pipe == true
+#ifdef HAVE_BZ2
+                       || (d->bz2 && size > 0)
+#endif
+       ))
    {
    {
-      // FIXME: If we have read first and then FileSize() the report is wrong
-      size = 0;
+      unsigned long long const oldSeek = Tell();
       char ignore[1000];
       unsigned long long read = 0;
       do {
         Read(ignore, sizeof(ignore), &read);
       char ignore[1000];
       unsigned long long read = 0;
       do {
         Read(ignore, sizeof(ignore), &read);
-        size += read;
       } while(read != 0);
       } while(read != 0);
-      Seek(0);
+      size = Tell();
+      Seek(oldSeek);
    }
    }
-#if APT_USE_ZLIB
+#ifdef HAVE_ZLIB
    // only check gzsize if we are actually a gzip file, just checking for
    // "gz" is not sufficient as uncompressed files could be opened with
    // gzopen in "direct" mode as well
    // only check gzsize if we are actually a gzip file, just checking for
    // "gz" is not sufficient as uncompressed files could be opened with
    // gzopen in "direct" mode as well
-   else if (d->gz && !gzdirect(d->gz) && size > 0)
+   else if (d != NULL && d->gz && !gzdirect(d->gz) && size > 0)
    {
    {
+       off_t const oldPos = lseek(iFd,0,SEEK_CUR);
        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
        * this ourselves; the original (uncompressed) file size is the last 32
        * bits of the file */
        // FIXME: Size for gz-files is limited by 32bit… no largefile support
        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
        * this ourselves; the original (uncompressed) file size is the last 32
        * bits of the file */
        // FIXME: Size for gz-files is limited by 32bit… no largefile support
-       off_t orig_pos = lseek(iFd, 0, SEEK_CUR);
        if (lseek(iFd, -4, SEEK_END) < 0)
        if (lseek(iFd, -4, SEEK_END) < 0)
-          return _error->Errno("lseek","Unable to seek to end of gzipped file");
+       {
+         Flags |= Fail;
+         return _error->Errno("lseek","Unable to seek to end of gzipped file");
+       }
        size = 0L;
        if (read(iFd, &size, 4) != 4)
        size = 0L;
        if (read(iFd, &size, 4) != 4)
-          return _error->Errno("read","Unable to read original size of gzipped file");
+       {
+         Flags |= Fail;
+         return _error->Errno("read","Unable to read original size of gzipped file");
+       }
 
 #ifdef WORDS_BIGENDIAN
        uint32_t tmp_size = size;
 
 #ifdef WORDS_BIGENDIAN
        uint32_t tmp_size = size;
@@ -1444,8 +1646,12 @@ unsigned long long FileFd::Size()
        size = tmp_size;
 #endif
 
        size = tmp_size;
 #endif
 
-       if (lseek(iFd, orig_pos, SEEK_SET) < 0)
-          return _error->Errno("lseek","Unable to seek in gzipped file");
+       if (lseek(iFd, oldPos, SEEK_SET) < 0)
+       {
+         Flags |= Fail;
+         return _error->Errno("lseek","Unable to seek in gzipped file");
+       }
+
        return size;
    }
 #endif
        return size;
    }
 #endif
@@ -1459,20 +1665,23 @@ unsigned long long FileFd::Size()
 time_t FileFd::ModificationTime()
 {
    struct stat Buf;
 time_t FileFd::ModificationTime()
 {
    struct stat Buf;
-   if (d->pipe == false && fstat(iFd,&Buf) != 0)
+   if ((d == NULL || d->pipe == false) && fstat(iFd,&Buf) != 0)
    {
    {
+      Flags |= Fail;
       _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
       return 0;
    }
 
    // for compressor pipes st_size is undefined and at 'best' zero
       _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
       return 0;
    }
 
    // for compressor pipes st_size is undefined and at 'best' zero
-   if (d->pipe == true || S_ISFIFO(Buf.st_mode))
+   if ((d != NULL && d->pipe == true) || S_ISFIFO(Buf.st_mode))
    {
       // we set it here, too, as we get the info here for free
       // in theory the Open-methods should take care of it already
    {
       // we set it here, too, as we get the info here for free
       // in theory the Open-methods should take care of it already
-      d->pipe = true;
+      if (d != NULL)
+        d->pipe = true;
       if (stat(FileName.c_str(), &Buf) != 0)
       {
       if (stat(FileName.c_str(), &Buf) != 0)
       {
+        Flags |= Fail;
         _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
         return 0;
       }
         _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
         return 0;
       }
@@ -1492,16 +1701,15 @@ bool FileFd::Close()
    bool Res = true;
    if ((Flags & AutoClose) == AutoClose)
    {
    bool Res = true;
    if ((Flags & AutoClose) == AutoClose)
    {
-#if APT_USE_ZLIB
-      if (d != NULL && d->gz != NULL) {
-        int const e = gzclose(d->gz);
-        // gzdopen() on empty files always fails with "buffer error" here, ignore that
-        if (e != 0 && e != Z_BUF_ERROR)
-           Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
-      } else
-#endif
-        if (iFd > 0 && close(iFd) != 0)
-           Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
+      if ((Flags & Compressed) != Compressed && iFd > 0 && close(iFd) != 0)
+        Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
+
+      if (d != NULL)
+      {
+        Res &= d->CloseDown(FileName);
+        delete d;
+        d = NULL;
+      }
    }
 
    if ((Flags & Replace) == Replace && iFd >= 0) {
    }
 
    if ((Flags & Replace) == Replace && iFd >= 0) {
@@ -1519,14 +1727,8 @@ bool FileFd::Close()
       if (unlink(FileName.c_str()) != 0)
         Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
 
       if (unlink(FileName.c_str()) != 0)
         Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
 
-   if (d != NULL)
-   {
-      if (d->compressor_pid != -1)
-        ExecWait(d->compressor_pid, "FileFdCompressor", true);
-      delete d;
-      d = NULL;
-   }
-
+   if (Res == false)
+      Flags |= Fail;
    return Res;
 }
                                                                        /*}}}*/
    return Res;
 }
                                                                        /*}}}*/
@@ -1537,7 +1739,10 @@ bool FileFd::Sync()
 {
 #ifdef _POSIX_SYNCHRONIZED_IO
    if (fsync(iFd) != 0)
 {
 #ifdef _POSIX_SYNCHRONIZED_IO
    if (fsync(iFd) != 0)
+   {
+      Flags |= Fail;
       return _error->Errno("sync",_("Problem syncing the file"));
       return _error->Errno("sync",_("Problem syncing the file"));
+   }
 #endif
    return true;
 }
 #endif
    return true;
 }