move fd duplication closer to the gz/bz2 open calls

[apt.git] / apt-pkg / contrib / fileutl.cc

diff --git a/apt-pkg/contrib/fileutl.cc b/apt-pkg/contrib/fileutl.cc
index 46661887a1173c959a45fa466bb5f689e9afc761..2188f616a43485871ca8e7549beabedd4cfa2358 100644 (file)
--- a/apt-pkg/contrib/fileutl.cc
+++ b/apt-pkg/contrib/fileutl.cc
@@ -26,21 +26,29 @@
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/configuration.h>

-
+#include <apt-pkg/macros.h>
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <sys/select.h>
+#include <time.h>
+#include <string>
+#include <vector>

 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>

-

 #include <iostream>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <iostream>
 #include <unistd.h>
 #include <fcntl.h>
 #include <sys/stat.h>

-#include <sys/types.h>

 #include <sys/time.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <signal.h>
 #include <errno.h>
 #include <sys/time.h>
 #include <sys/wait.h>
 #include <dirent.h>
 #include <signal.h>
 #include <errno.h>

+#include <glob.h>
+

 #include <set>
 #include <algorithm>
 
 #include <set>
 #include <algorithm>
 


@@ -184,7 +192,8 @@ bool RunScripts(const char *Cnf)
 /* The caller is expected to set things so that failure causes erasure */
 bool CopyFile(FileFd &From,FileFd &To)
 {
 /* The caller is expected to set things so that failure causes erasure */
 bool CopyFile(FileFd &From,FileFd &To)
 {

-   if (From.IsOpen() == false || To.IsOpen() == false)
+   if (From.IsOpen() == false || To.IsOpen() == false ||
+        From.Failed() == true || To.Failed() == true)

       return false;
    
    // Buffered copy between fds
       return false;
    
    // Buffered copy between fds


@@ -219,7 +228,7 @@ int GetLock(string File,bool Errors)
    int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
    if (FD < 0)
    {
    int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
    if (FD < 0)
    {

-      // Read only .. cant have locking problems there.
+      // Read only .. can't have locking problems there.

       if (errno == EROFS)
       {
         _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
       if (errno == EROFS)
       {
         _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());


@@ -235,7 +244,7 @@ int GetLock(string File,bool Errors)
    }
    SetCloseExec(FD,true);
       
    }
    SetCloseExec(FD,true);
       

-   // Aquire a write lock
+   // Acquire a write lock

    struct flock fl;
    fl.l_type = F_WRLCK;
    fl.l_whence = SEEK_SET;
    struct flock fl;
    fl.l_type = F_WRLCK;
    fl.l_whence = SEEK_SET;


@@ -243,17 +252,20 @@ int GetLock(string File,bool Errors)
    fl.l_len = 0;
    if (fcntl(FD,F_SETLK,&fl) == -1)
    {
    fl.l_len = 0;
    if (fcntl(FD,F_SETLK,&fl) == -1)
    {

+      // always close to not leak resources
+      int Tmp = errno;
+      close(FD);
+      errno = Tmp;
+

       if (errno == ENOLCK)
       {
         _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
         return dup(0);       // Need something for the caller to close  
       if (errno == ENOLCK)
       {
         _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
         return dup(0);       // Need something for the caller to close  

-      }      
+      }
+  

       if (Errors == true)
         _error->Errno("open",_("Could not get lock %s"),File.c_str());
       
       if (Errors == true)
         _error->Errno("open",_("Could not get lock %s"),File.c_str());
       

-      int Tmp = errno;
-      close(FD);
-      errno = Tmp;

       return -1;
    }
 
       return -1;
    }
 


@@ -313,7 +325,7 @@ bool CreateDirectory(string const &Parent, string const &Path)
       return false;
 
    // we are not going to create directories "into the blue"
       return false;
 
    // we are not going to create directories "into the blue"

-   if (Path.find(Parent, 0) != 0)
+   if (Path.compare(0, Parent.length(), Parent) != 0)

       return false;
 
    vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');
       return false;
 
    vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');


@@ -459,7 +471,7 @@ std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> c
       const char *C = Ent->d_name;
       for (; *C != 0; ++C)
         if (isalpha(*C) == 0 && isdigit(*C) == 0
       const char *C = Ent->d_name;
       for (; *C != 0; ++C)
         if (isalpha(*C) == 0 && isdigit(*C) == 0

-            && *C != '_' && *C != '-') {
+            && *C != '_' && *C != '-' && *C != ':') {

            // no required extension -> dot is a bad character
            if (*C == '.' && Ext.empty() == false)
               continue;
            // no required extension -> dot is a bad character
            if (*C == '.' && Ext.empty() == false)
               continue;


@@ -650,9 +662,9 @@ string flNoLink(string File)
    while (1)
    {
       // Read the link
    while (1)
    {
       // Read the link

-      int Res;
+      ssize_t Res;

       if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 || 
       if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 || 

-         (unsigned)Res >= sizeof(Buffer))
+         (size_t)Res >= sizeof(Buffer))

          return File;
       
       // Append or replace the previous path
          return File;
       
       // Append or replace the previous path


@@ -754,12 +766,42 @@ bool WaitFd(int Fd,bool write,unsigned long timeout)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+// MergeKeepFdsFromConfiguration - Merge APT::Keep-Fds configuration   /*{{{*/
+// ---------------------------------------------------------------------
+/* This is used to merge the APT::Keep-Fds with the provided KeepFDs
+ * set.
+ */
+void MergeKeepFdsFromConfiguration(std::set<int> &KeepFDs)
+{
+      Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
+      if (Opts != 0 && Opts->Child != 0)
+      {
+        Opts = Opts->Child;
+        for (; Opts != 0; Opts = Opts->Next)
+        {
+           if (Opts->Value.empty() == true)
+              continue;
+           int fd = atoi(Opts->Value.c_str());
+           KeepFDs.insert(fd);
+        }
+      }
+}
+                                                                       /*}}}*/

 // ExecFork - Magical fork that sanitizes the context before execing   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used if you want to cleanse the environment for the forked 
    child, it fixes up the important signals and nukes all of the fds,
    otherwise acts like normal fork. */
 pid_t ExecFork()
 // ExecFork - Magical fork that sanitizes the context before execing   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used if you want to cleanse the environment for the forked 
    child, it fixes up the important signals and nukes all of the fds,
    otherwise acts like normal fork. */
 pid_t ExecFork()

+{
+      set<int> KeepFDs;
+      // we need to merge the Keep-Fds as external tools like 
+      // debconf-apt-progress use it
+      MergeKeepFdsFromConfiguration(KeepFDs);
+      return ExecFork(KeepFDs);
+}
+
+pid_t ExecFork(std::set<int> KeepFDs)

 {
    // Fork off the process
    pid_t Process = fork();
 {
    // Fork off the process
    pid_t Process = fork();


@@ -780,22 +822,8 @@ pid_t ExecFork()
       signal(SIGCONT,SIG_DFL);
       signal(SIGTSTP,SIG_DFL);
 
       signal(SIGCONT,SIG_DFL);
       signal(SIGTSTP,SIG_DFL);
 

-      set<int> KeepFDs;
-      Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
-      if (Opts != 0 && Opts->Child != 0)
-      {
-        Opts = Opts->Child;
-        for (; Opts != 0; Opts = Opts->Next)
-        {
-           if (Opts->Value.empty() == true)
-              continue;
-           int fd = atoi(Opts->Value.c_str());
-           KeepFDs.insert(fd);
-        }
-      }
-

       // Close all of our FDs - just in case
       // Close all of our FDs - just in case

-      for (int K = 3; K != 40; K++)
+      for (int K = 3; K != sysconf(_SC_OPEN_MAX); K++)

       {
         if(KeepFDs.find(K) == KeepFDs.end())
            fcntl(K,F_SETFD,FD_CLOEXEC);
       {
         if(KeepFDs.find(K) == KeepFDs.end())
            fcntl(K,F_SETFD,FD_CLOEXEC);


@@ -861,7 +889,7 @@ bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress,
       return Open(FileName, ReadOnly, Gzip, Perms);
 
    if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)
       return Open(FileName, ReadOnly, Gzip, Perms);
 
    if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)

-      return _error->Error("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());
+      return FileFdError("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());

 
    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
 
    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();


@@ -869,7 +897,7 @@ bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress,
    {
       for (; compressor != compressors.end(); ++compressor)
       {
    {
       for (; compressor != compressors.end(); ++compressor)
       {

-        std::string file = std::string(FileName).append(compressor->Extension);
+        std::string file = FileName + compressor->Extension;

         if (FileExists(file) == false)
            continue;
         FileName = file;
         if (FileExists(file) == false)
            continue;
         FileName = file;


@@ -914,17 +942,17 @@ bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress,
       case Auto:
       case Extension:
         // Unreachable
       case Auto:
       case Extension:
         // Unreachable

-        return _error->Error("Opening File %s in None, Auto or Extension should be already handled?!?", FileName.c_str());
+        return FileFdError("Opening File %s in None, Auto or Extension should be already handled?!?", FileName.c_str());

       }
       for (; compressor != compressors.end(); ++compressor)
         if (compressor->Name == name)
            break;
       if (compressor == compressors.end())
       }
       for (; compressor != compressors.end(); ++compressor)
         if (compressor->Name == name)
            break;
       if (compressor == compressors.end())

-        return _error->Error("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
+        return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());

    }
 
    if (compressor == compressors.end())
    }
 
    if (compressor == compressors.end())

-      return _error->Error("Can't find a match for specified compressor mode for file %s", FileName.c_str());
+      return FileFdError("Can't find a match for specified compressor mode for file %s", FileName.c_str());

    return Open(FileName, Mode, *compressor, Perms);
 }
 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const Perms)
    return Open(FileName, Mode, *compressor, Perms);
 }
 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const Perms)


@@ -933,16 +961,13 @@ bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Co
    Flags = AutoClose;
 
    if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)
    Flags = AutoClose;
 
    if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)

-      return _error->Error("ReadOnly mode for %s doesn't accept additional flags!", FileName.c_str());
+      return FileFdError("ReadOnly mode for %s doesn't accept additional flags!", FileName.c_str());

    if ((Mode & ReadWrite) == 0)
    if ((Mode & ReadWrite) == 0)

-      return _error->Error("No openmode provided in FileFd::Open for %s", FileName.c_str());
+      return FileFdError("No openmode provided in FileFd::Open for %s", FileName.c_str());

 
    if ((Mode & Atomic) == Atomic)
    {
       Flags |= Replace;
 
    if ((Mode & Atomic) == Atomic)
    {
       Flags |= Replace;

-      char *name = strdup((FileName + ".XXXXXX").c_str());
-      TemporaryFileName = string(mktemp(name));
-      free(name);

    }
    else if ((Mode & (Exclusive | Create)) == (Exclusive | Create))
    {
    }
    else if ((Mode & (Exclusive | Create)) == (Exclusive | Create))
    {


@@ -965,11 +990,24 @@ bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Co
    if_FLAGGED_SET(Create, O_CREAT);
    if_FLAGGED_SET(Empty, O_TRUNC);
    if_FLAGGED_SET(Exclusive, O_EXCL);
    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
 
    #undef if_FLAGGED_SET
 

-   if (TemporaryFileName.empty() == false)
-      iFd = open(TemporaryFileName.c_str(), fileflags, Perms);
+   if ((Mode & Atomic) == Atomic)
+   {
+      char *name = strdup((FileName + ".XXXXXX").c_str());
+
+      if((iFd = mkstemp(name)) == -1)
+      {
+          free(name);
+          return FileFdErrno("mkstemp", "Could not create temporary file for %s", FileName.c_str());
+      }
+
+      TemporaryFileName = string(name);
+      free(name);
+
+      if(Perms != 600 && fchmod(iFd, Perms) == -1)
+          return FileFdErrno("fchmod", "Could not change permissions for temporary file %s", TemporaryFileName.c_str());
+   }

    else
       iFd = open(FileName.c_str(), fileflags, Perms);
 
    else
       iFd = open(FileName.c_str(), fileflags, Perms);
 


@@ -981,7 +1019,7 @@ bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Co
         close (iFd);
         iFd = -1;
       }
         close (iFd);
         iFd = -1;
       }

-      return _error->Errno("open",_("Could not open file %s"), FileName.c_str());
+      return FileFdErrno("open",_("Could not open file %s"), FileName.c_str());

    }
 
    SetCloseExec(iFd,true);
    }
 
    SetCloseExec(iFd,true);


@@ -1010,45 +1048,44 @@ bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compre
    case Xz: name = "xz"; break;
    case Auto:
    case Extension:
    case Xz: name = "xz"; break;
    case Auto:
    case Extension:

-      return _error->Error("Opening Fd %d in Auto or Extension compression mode is not supported", Fd);
+      if (AutoClose == true && Fd != -1)
+        close(Fd);
+      return FileFdError("Opening Fd %d in Auto or Extension compression mode is not supported", Fd);

    }
    for (; compressor != compressors.end(); ++compressor)
       if (compressor->Name == name)
         break;
    if (compressor == compressors.end())
    }
    for (; compressor != compressors.end(); ++compressor)
       if (compressor->Name == name)
         break;
    if (compressor == compressors.end())

-      return _error->Error("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
-
+   {
+      if (AutoClose == true && Fd != -1)
+        close(Fd);
+      return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
+   }

    return OpenDescriptor(Fd, Mode, *compressor, AutoClose);
 }
 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
 {
    Close();
    Flags = (AutoClose) ? FileFd::AutoClose : 0;
    return OpenDescriptor(Fd, Mode, *compressor, AutoClose);
 }
 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
 {
    Close();
    Flags = (AutoClose) ? FileFd::AutoClose : 0;

-   if (AutoClose == false && (
-#ifdef HAVE_ZLIB
-       compressor.Name == "gzip" ||
-#endif
-#ifdef HAVE_BZ2
-       compressor.Name == "bzip2" ||
-#endif
-       false))
-   {
-      // Need to duplicate fd here or gzclose for cleanup will close the fd as well
-      iFd = dup(Fd);
-   }
-   else
-      iFd = Fd;
+   iFd = Fd;

    this->FileName = "";
    if (OpenInternDescriptor(Mode, compressor) == false)
    {
    this->FileName = "";
    if (OpenInternDescriptor(Mode, compressor) == false)
    {

-      if (AutoClose)
+      if (iFd != -1 && (
+       (Flags & Compressed) == Compressed ||
+       AutoClose == true))
+      {

         close (iFd);
         close (iFd);

-      return _error->Errno("gzdopen",_("Could not open file descriptor %d"), Fd);
+        iFd = -1;
+      }
+      return FileFdError(_("Could not open file descriptor %d"), Fd);

    }
    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 (iFd == -1)
+      return false;

    if (compressor.Name == "." || compressor.Binary.empty() == true)
       return true;
 
    if (compressor.Name == "." || compressor.Binary.empty() == true)
       return true;
 


@@ -1057,6 +1094,21 @@ bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::C
       d = new FileFdPrivate();
       d->openmode = Mode;
       d->compressor = compressor;
       d = new FileFdPrivate();
       d->openmode = Mode;
       d->compressor = compressor;

+      if (AutoClose == false && (
+#ifdef HAVE_ZLIB
+              compressor.Name == "gzip" ||
+#endif
+#ifdef HAVE_BZ2
+              compressor.Name == "bzip2" ||
+#endif
+              false))
+      {
+        // Need to duplicate fd here or gz/bz2 close for cleanup will close the fd as well
+        int const internFd = dup(iFd);
+        if (internFd == -1)
+           return FileFdErrno("OpenInternDescriptor", _("Could not open file descriptor %d"), iFd);
+        iFd = internFd;
+      }

    }
 
 #ifdef HAVE_ZLIB
    }
 
 #ifdef HAVE_ZLIB


@@ -1105,10 +1157,7 @@ bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::C
       ExecWait(d->compressor_pid, "FileFdCompressor", true);
 
    if ((Mode & ReadWrite) == ReadWrite)
       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());
-   }
+      return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());

 
    bool const Comp = (Mode & WriteOnly) == WriteOnly;
    if (Comp == false)
 
    bool const Comp = (Mode & WriteOnly) == WriteOnly;
    if (Comp == false)


@@ -1131,10 +1180,7 @@ bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::C
    // Create a data pipe
    int Pipe[2] = {-1,-1};
    if (pipe(Pipe) != 0)
    // Create a data pipe
    int Pipe[2] = {-1,-1};
    if (pipe(Pipe) != 0)

-   {
-      Flags |= Fail;
-      return _error->Errno("pipe",_("Failed to create subprocess IPC"));
-   }
+      return FileFdErrno("pipe",_("Failed to create subprocess IPC"));

    for (int J = 0; J != 2; J++)
       SetCloseExec(Pipe[J],true);
 
    for (int J = 0; J != 2; J++)
       SetCloseExec(Pipe[J],true);
 


@@ -1208,20 +1254,18 @@ FileFd::~FileFd()
 {
    Close();
    if (d != NULL)
 {
    Close();
    if (d != NULL)

-   {

       d->CloseDown(FileName);
       d->CloseDown(FileName);

-      delete d;
-      d = NULL;
-   }
+   delete d;
+   d = NULL;

 }
                                                                        /*}}}*/
 // FileFd::Read - Read a bit of the file                               /*{{{*/
 // ---------------------------------------------------------------------
 }
                                                                        /*}}}*/
 // FileFd::Read - Read a bit of the file                               /*{{{*/
 // ---------------------------------------------------------------------

-/* We are carefull to handle interruption by a signal while reading 
+/* We are careful to handle interruption by a signal while reading

    gracefully. */
 bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
 {
    gracefully. */
 bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
 {

-   int Res;
+   ssize_t Res;

    errno = 0;
    if (Actual != 0)
       *Actual = 0;
    errno = 0;
    if (Actual != 0)
       *Actual = 0;


@@ -1244,14 +1288,13 @@ bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
       {
         if (errno == EINTR)
            continue;
       {
         if (errno == EINTR)
            continue;

-        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)
 #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);
+              return FileFdError("gzread: %s (%d: %s)", _("Read error"), err, errmsg);

         }
 #endif
 #ifdef HAVE_BZ2
         }
 #endif
 #ifdef HAVE_BZ2


@@ -1260,10 +1303,10 @@ bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
            int err;
            char const * const errmsg = BZ2_bzerror(d->bz2, &err);
            if (err != BZ_IO_ERROR)
            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);
+              return FileFdError("BZ2_bzread: %s (%d: %s)", _("Read error"), err, errmsg);

         }
 #endif
         }
 #endif

-        return _error->Errno("read",_("Read error"));
+        return FileFdErrno("read",_("Read error"));

       }
       
       To = (char *)To + Res;
       }
       
       To = (char *)To + Res;


@@ -1284,9 +1327,8 @@ bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
       Flags |= HitEof;
       return true;
    }
       Flags |= HitEof;
       return true;
    }

-   
-   Flags |= Fail;
-   return _error->Error(_("read, still have %llu to read but none left"), Size);
+
+   return FileFdError(_("read, still have %llu to read but none left"), Size);

 }
                                                                        /*}}}*/
 // FileFd::ReadLine - Read a complete line from the file               /*{{{*/
 }
                                                                        /*}}}*/
 // FileFd::ReadLine - Read a complete line from the file               /*{{{*/


@@ -1323,7 +1365,7 @@ char* FileFd::ReadLine(char *To, unsigned long long const Size)
 /* */
 bool FileFd::Write(const void *From,unsigned long long Size)
 {
 /* */
 bool FileFd::Write(const void *From,unsigned long long Size)
 {

-   int Res;
+   ssize_t Res;

    errno = 0;
    do
    {
    errno = 0;
    do
    {


@@ -1342,14 +1384,13 @@ bool FileFd::Write(const void *From,unsigned long long Size)
         continue;
       if (Res < 0)
       {
         continue;
       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)
 #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);
+              return FileFdError("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);

         }
 #endif
 #ifdef HAVE_BZ2
         }
 #endif
 #ifdef HAVE_BZ2


@@ -1358,13 +1399,13 @@ bool FileFd::Write(const void *From,unsigned long long Size)
            int err;
            char const * const errmsg = BZ2_bzerror(d->bz2, &err);
            if (err != BZ_IO_ERROR)
            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);
+              return FileFdError("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);

         }
 #endif
         }
 #endif

-        return _error->Errno("write",_("Write error"));
+        return FileFdErrno("write",_("Write error"));

       }
       
       }
       

-      From = (char *)From + Res;
+      From = (char const *)From + Res;

       Size -= Res;
       if (d != NULL)
         d->seekpos += Res;
       Size -= Res;
       if (d != NULL)
         d->seekpos += Res;


@@ -1373,13 +1414,12 @@ bool FileFd::Write(const void *From,unsigned long long Size)
    
    if (Size == 0)
       return true;
    
    if (Size == 0)
       return true;

-   
-   Flags |= Fail;
-   return _error->Error(_("write, still have %llu to write but couldn't"), Size);
+
+   return FileFdError(_("write, still have %llu to write but couldn't"), Size);

 }
 bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
 {
 }
 bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
 {

-   int Res;
+   ssize_t Res;

    errno = 0;
    do
    {
    errno = 0;
    do
    {


@@ -1389,7 +1429,7 @@ bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
       if (Res < 0)
         return _error->Errno("write",_("Write error"));
 
       if (Res < 0)
         return _error->Errno("write",_("Write error"));
 

-      From = (char *)From + Res;
+      From = (char const *)From + Res;

       Size -= Res;
    }
    while (Res > 0 && Size > 0);
       Size -= Res;
    }
    while (Res > 0 && Size > 0);


@@ -1419,10 +1459,7 @@ bool FileFd::Seek(unsigned long long To)
         return Skip(To - seekpos);
 
       if ((d->openmode & ReadOnly) != ReadOnly)
         return Skip(To - seekpos);
 
       if ((d->openmode & ReadOnly) != ReadOnly)

-      {
-        Flags |= Fail;
-        return _error->Error("Reopen is only implemented for read-only files!");
-      }
+        return FileFdError("Reopen is only implemented for read-only files!");

 #ifdef HAVE_BZ2
      if (d->bz2 != NULL) 
      {
 #ifdef HAVE_BZ2
      if (d->bz2 != NULL) 
      {


@@ -1443,17 +1480,11 @@ bool FileFd::Seek(unsigned long long To)
            if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
               iFd = d->compressed_fd;
         if (iFd < 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()!");
-        }
+           return FileFdError("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");

       }
 
       if (OpenInternDescriptor(d->openmode, d->compressor) == false)
       }
 
       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());
-      }
+        return FileFdError("Seek on file %s because it couldn't be reopened", FileName.c_str());

 
       if (To != 0)
         return Skip(To);
 
       if (To != 0)
         return Skip(To);


@@ -1461,18 +1492,15 @@ bool FileFd::Seek(unsigned long long To)
       d->seekpos = To;
       return true;
    }
       d->seekpos = To;
       return true;
    }

-   int res;
+   off_t res;

 #ifdef HAVE_ZLIB
    if (d != NULL && d->gz)
       res = gzseek(d->gz,To,SEEK_SET);
    else
 #endif
       res = lseek(iFd,To,SEEK_SET);
 #ifdef HAVE_ZLIB
    if (d != NULL && d->gz)
       res = gzseek(d->gz,To,SEEK_SET);
    else
 #endif
       res = lseek(iFd,To,SEEK_SET);

-   if (res != (signed)To)
-   {
-      Flags |= Fail;
-      return _error->Error("Unable to seek to %llu", To);
-   }
+   if (res != (off_t)To)
+      return FileFdError("Unable to seek to %llu", To);

 
    if (d != NULL)
       d->seekpos = To;
 
    if (d != NULL)
       d->seekpos = To;


@@ -1496,16 +1524,13 @@ bool FileFd::Skip(unsigned long long Over)
       {
         unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
         if (Read(buffer, toread) == false)
       {
         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);
-        }
+           return FileFdError("Unable to seek ahead %llu",Over);

         Over -= toread;
       }
       return true;
    }
 
         Over -= toread;
       }
       return true;
    }
 

-   int res;
+   off_t res;

 #ifdef HAVE_ZLIB
    if (d != NULL && d->gz != NULL)
       res = gzseek(d->gz,Over,SEEK_CUR);
 #ifdef HAVE_ZLIB
    if (d != NULL && d->gz != NULL)
       res = gzseek(d->gz,Over,SEEK_CUR);


@@ -1513,10 +1538,7 @@ bool FileFd::Skip(unsigned long long Over)
 #endif
       res = lseek(iFd,Over,SEEK_CUR);
    if (res < 0)
 #endif
       res = lseek(iFd,Over,SEEK_CUR);
    if (res < 0)

-   {
-      Flags |= Fail;
-      return _error->Error("Unable to seek ahead %llu",Over);
-   }
+      return FileFdError("Unable to seek ahead %llu",Over);

    if (d != NULL)
       d->seekpos = res;
 
    if (d != NULL)
       d->seekpos = res;
 


@@ -1528,19 +1550,16 @@ bool FileFd::Skip(unsigned long long Over)
 /* */
 bool FileFd::Truncate(unsigned long long To)
 {
 /* */
 bool FileFd::Truncate(unsigned long long To)
 {

+   // truncating /dev/null is always successful - as we get an error otherwise
+   if (To == 0 && FileName == "/dev/null")
+      return true;

 #if defined HAVE_ZLIB || defined HAVE_BZ2
    if (d != NULL && (d->gz != NULL || d->bz2 != NULL))
 #if defined HAVE_ZLIB || defined HAVE_BZ2
    if (d != NULL && (d->gz != NULL || d->bz2 != NULL))

-   {
-      Flags |= Fail;
-      return _error->Error("Truncating compressed files is not implemented (%s)", FileName.c_str());
-   }
+      return FileFdError("Truncating compressed files is not implemented (%s)", FileName.c_str());

 #endif
    if (ftruncate(iFd,To) != 0)
 #endif
    if (ftruncate(iFd,To) != 0)

-   {
-      Flags |= Fail;
-      return _error->Error("Unable to truncate to %llu",To);
-   }
-   
+      return FileFdError("Unable to truncate to %llu",To);
+

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -1568,44 +1587,61 @@ unsigned long long FileFd::Tell()
 #endif
      Res = lseek(iFd,0,SEEK_CUR);
    if (Res == (off_t)-1)
 #endif
      Res = lseek(iFd,0,SEEK_CUR);
    if (Res == (off_t)-1)

-   {
-      Flags |= Fail;
-      _error->Errno("lseek","Failed to determine the current file position");
-   }
+      FileFdErrno("lseek","Failed to determine the current file position");

    if (d != NULL)
       d->seekpos = Res;
    return Res;
 }
                                                                        /*}}}*/
    if (d != NULL)
       d->seekpos = Res;
    return Res;
 }
                                                                        /*}}}*/

-// FileFd::FileSize - Return the size of the file                      /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-unsigned long long FileFd::FileSize()
+static bool StatFileFd(char const * const msg, int const iFd, std::string const &FileName, struct stat &Buf, FileFdPrivate * const d) /*{{{*/

 {
 {

-   struct stat Buf;
-   if ((d == NULL || d->pipe == false) && fstat(iFd,&Buf) != 0)
+   bool ispipe = (d != NULL && d->pipe == true);
+   if (ispipe == false)

    {
    {

-      Flags |= Fail;
-      return _error->Errno("fstat","Unable to determine the file size");
+      if (fstat(iFd,&Buf) != 0)
+        // higher-level code will generate more meaningful messages,
+        // even translated this would be meaningless for users
+        return _error->Errno("fstat", "Unable to determine %s for fd %i", msg, iFd);
+      ispipe = S_ISFIFO(Buf.st_mode);

    }
 
    // for compressor pipes st_size is undefined and at 'best' zero
    }
 
    // for compressor pipes st_size is undefined and at 'best' zero

-   if ((d != NULL && d->pipe == true) || S_ISFIFO(Buf.st_mode))
+   if (ispipe == true)

    {
       // we set it here, too, as we get the info here for free
       // in theory the Open-methods should take care of it already
       if (d != NULL)
         d->pipe = true;
       if (stat(FileName.c_str(), &Buf) != 0)
    {
       // we set it here, too, as we get the info here for free
       // in theory the Open-methods should take care of it already
       if (d != NULL)
         d->pipe = true;
       if (stat(FileName.c_str(), &Buf) != 0)

-      {
-        Flags |= Fail;
-        return _error->Errno("stat","Unable to determine the file size");
-      }
+        return _error->Errno("fstat", "Unable to determine %s for file %s", msg, FileName.c_str());
+   }
+   return true;
+}
+                                                                       /*}}}*/
+// FileFd::FileSize - Return the size of the file                      /*{{{*/
+unsigned long long FileFd::FileSize()
+{
+   struct stat Buf;
+   if (StatFileFd("file size", iFd, FileName, Buf, d) == false)
+   {
+      Flags |= Fail;
+      return 0;

    }
    }

-

    return Buf.st_size;
 }
                                                                        /*}}}*/
    return Buf.st_size;
 }
                                                                        /*}}}*/

+// FileFd::ModificationTime - Return the time of last touch            /*{{{*/
+time_t FileFd::ModificationTime()
+{
+   struct stat Buf;
+   if (StatFileFd("modification time", iFd, FileName, Buf, d) == false)
+   {
+      Flags |= Fail;
+      return 0;
+   }
+   return Buf.st_mtime;
+}
+                                                                       /*}}}*/

 // FileFd::Size - Return the size of the content in the file           /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FileFd::Size - Return the size of the content in the file           /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -1625,7 +1661,11 @@ unsigned long long FileFd::Size()
       char ignore[1000];
       unsigned long long read = 0;
       do {
       char ignore[1000];
       unsigned long long read = 0;
       do {

-        Read(ignore, sizeof(ignore), &read);
+        if (Read(ignore, sizeof(ignore), &read) == false)
+        {
+           Seek(oldSeek);
+           return 0;
+        }

       } while(read != 0);
       size = Tell();
       Seek(oldSeek);
       } while(read != 0);
       size = Tell();
       Seek(oldSeek);


@@ -1643,14 +1683,14 @@ unsigned long long FileFd::Size()
        // FIXME: Size for gz-files is limited by 32bit… no largefile support
        if (lseek(iFd, -4, SEEK_END) < 0)
        {
        // FIXME: Size for gz-files is limited by 32bit… no largefile support
        if (lseek(iFd, -4, SEEK_END) < 0)
        {

-         Flags |= Fail;
-         return _error->Errno("lseek","Unable to seek to end of gzipped file");
+         FileFdErrno("lseek","Unable to seek to end of gzipped file");
+         return 0;

        }
        }

-       size = 0L;
+       size = 0;

        if (read(iFd, &size, 4) != 4)
        {
        if (read(iFd, &size, 4) != 4)
        {

-         Flags |= Fail;
-         return _error->Errno("read","Unable to read original size of gzipped file");
+         FileFdErrno("read","Unable to read original size of gzipped file");
+         return 0;

        }
 
 #ifdef WORDS_BIGENDIAN
        }
 
 #ifdef WORDS_BIGENDIAN


@@ -1662,8 +1702,8 @@ unsigned long long FileFd::Size()
 
        if (lseek(iFd, oldPos, SEEK_SET) < 0)
        {
 
        if (lseek(iFd, oldPos, SEEK_SET) < 0)
        {

-         Flags |= Fail;
-         return _error->Errno("lseek","Unable to seek in gzipped file");
+         FileFdErrno("lseek","Unable to seek in gzipped file");
+         return 0;

        }
 
        return size;
        }
 
        return size;


@@ -1673,37 +1713,6 @@ unsigned long long FileFd::Size()
    return size;
 }
                                                                        /*}}}*/
    return size;
 }
                                                                        /*}}}*/

-// FileFd::ModificationTime - Return the time of last touch            /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-time_t FileFd::ModificationTime()
-{
-   struct stat Buf;
-   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
-   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
-      if (d != NULL)
-        d->pipe = true;
-      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;
-      }
-   }
-
-   return Buf.st_mtime;
-}
-                                                                       /*}}}*/

 // FileFd::Close - Close the file if the close flag is set             /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // FileFd::Close - Close the file if the close flag is set             /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -1752,12 +1761,88 @@ bool FileFd::Close()
 bool FileFd::Sync()
 {
    if (fsync(iFd) != 0)
 bool FileFd::Sync()
 {
    if (fsync(iFd) != 0)

+      return FileFdErrno("sync",_("Problem syncing the file"));
+   return true;
+}
+                                                                       /*}}}*/
+// FileFd::FileFdErrno - set Fail and call _error->Errno               *{{{*/
+bool FileFd::FileFdErrno(const char *Function, const char *Description,...)
+{
+   Flags |= Fail;
+   va_list args;
+   size_t msgSize = 400;
+   int const errsv = errno;
+   while (true)

    {
    {

-      Flags |= Fail;
-      return _error->Errno("sync",_("Problem syncing the file"));
+      va_start(args,Description);
+      if (_error->InsertErrno(GlobalError::ERROR, Function, Description, args, errsv, msgSize) == false)
+        break;
+      va_end(args);

    }
    }

-   return true;
+   return false;
+}
+                                                                       /*}}}*/
+// FileFd::FileFdError - set Fail and call _error->Error               *{{{*/
+bool FileFd::FileFdError(const char *Description,...) {
+   Flags |= Fail;
+   va_list args;
+   size_t msgSize = 400;
+   while (true)
+   {
+      va_start(args,Description);
+      if (_error->Insert(GlobalError::ERROR, Description, args, msgSize) == false)
+        break;
+      va_end(args);
+   }
+   return false;

 }
                                                                        /*}}}*/
 
 }
                                                                        /*}}}*/
 

-gzFile FileFd::gzFd() { return (gzFile) d->gz; }
+gzFile FileFd::gzFd() { return d->gz; }
+
+
+// Glob - wrapper around "glob()"                                      /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+std::vector<std::string> Glob(std::string const &pattern, int flags)
+{
+   std::vector<std::string> result;
+   glob_t globbuf;
+   int glob_res;
+   unsigned int i;
+
+   glob_res = glob(pattern.c_str(),  flags, NULL, &globbuf);
+
+   if (glob_res != 0)
+   {
+      if(glob_res != GLOB_NOMATCH) {
+         _error->Errno("glob", "Problem with glob");
+         return result;
+      }
+   }
+
+   // append results
+   for(i=0;i<globbuf.gl_pathc;i++)
+      result.push_back(string(globbuf.gl_pathv[i]));
+
+   globfree(&globbuf);
+   return result;
+}
+                                                                       /*}}}*/
+
+std::string GetTempDir()
+{
+   const char *tmpdir = getenv("TMPDIR");
+
+#ifdef P_tmpdir
+   if (!tmpdir)
+      tmpdir = P_tmpdir;
+#endif
+
+   // check that tmpdir is set and exists
+   struct stat st;
+   if (!tmpdir || strlen(tmpdir) == 0 || stat(tmpdir, &st) != 0)
+      tmpdir = "/tmp";
+
+   return string(tmpdir);
+}