apt-pkg/contrib/fileutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: fileutl.cc,v 1.42 2002/09/14 05:29:22 jgg Exp $
   4 /* ######################################################################
   5
   6    File Utilities
   7
   8    CopyFile - Buffered copy of a single file
   9    GetLock - dpkg compatible lock file manipulation (fcntl)
  10
  11    Most of this source is placed in the Public Domain, do with it what
  12    you will
  13    It was originally written by Jason Gunthorpe <jgg@debian.org>.
  14    FileFd gzip support added by Martin Pitt <martin.pitt@canonical.com>
  15
  16    The exception is RunScripts() it is under the GPLv2
  17
  18    ##################################################################### */
  19                                                                         /*}}}*/
  20 // Include Files                                                        /*{{{*/
  21 #include <config.h>
  22
  23 #include <apt-pkg/fileutl.h>
  24 #include <apt-pkg/strutl.h>
  25 #include <apt-pkg/error.h>
  26 #include <apt-pkg/sptr.h>
  27 #include <apt-pkg/aptconfiguration.h>
  28 #include <apt-pkg/configuration.h>
  29
  30 #include <cstdlib>
  31 #include <cstring>
  32 #include <cstdio>
  33
  34 #include <iostream>
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <sys/stat.h>
  38 #include <sys/types.h>
  39 #include <sys/time.h>
  40 #include <sys/wait.h>
  41 #include <dirent.h>
  42 #include <signal.h>
  43 #include <errno.h>
  44 #include <set>
  45 #include <algorithm>
  46
  47 #ifdef HAVE_ZLIB
  48         #include <zlib.h>
  49 #endif
  50 #ifdef HAVE_BZ2
  51         #include <bzlib.h>
  52 #endif
  53
  54 #ifdef WORDS_BIGENDIAN
  55 #include <inttypes.h>
  56 #endif
  57
  58 #include <apti18n.h>
  59                                                                         /*}}}*/
  60
  61 using namespace std;
  62
  63 class FileFdPrivate {
  64         public:
  65 #ifdef HAVE_ZLIB
  66         gzFile gz;
  67 #else
  68         void* gz;
  69 #endif
  70 #ifdef HAVE_BZ2
  71         BZFILE* bz2;
  72 #else
  73         void* bz2;
  74 #endif
  75         int compressed_fd;
  76         pid_t compressor_pid;
  77         bool pipe;
  78         APT::Configuration::Compressor compressor;
  79         unsigned int openmode;
  80         unsigned long long seekpos;
  81         FileFdPrivate() : gz(NULL), bz2(NULL),
  82                           compressed_fd(-1), compressor_pid(-1), pipe(false),
  83                           openmode(0), seekpos(0) {};
  84 };
  85
  86 // RunScripts - Run a set of scripts from a configuration subtree       /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* */
  89 bool RunScripts(const char *Cnf)
  90 {
  91    Configuration::Item const *Opts = _config->Tree(Cnf);
  92    if (Opts == 0 || Opts->Child == 0)
  93       return true;
  94    Opts = Opts->Child;
  95
  96    // Fork for running the system calls
  97    pid_t Child = ExecFork();
  98
  99    // This is the child
 100    if (Child == 0)
 101    {
 102       if (_config->FindDir("DPkg::Chroot-Directory","/") != "/")
 103       {
 104          std::cerr << "Chrooting into "
 105                    << _config->FindDir("DPkg::Chroot-Directory")
 106                    << std::endl;
 107          if (chroot(_config->FindDir("DPkg::Chroot-Directory","/").c_str()) != 0)
 108             _exit(100);
 109       }
 110
 111       if (chdir("/tmp/") != 0)
 112          _exit(100);
 113
 114       unsigned int Count = 1;
 115       for (; Opts != 0; Opts = Opts->Next, Count++)
 116       {
 117          if (Opts->Value.empty() == true)
 118             continue;
 119
 120          if (system(Opts->Value.c_str()) != 0)
 121             _exit(100+Count);
 122       }
 123       _exit(0);
 124    }
 125
 126    // Wait for the child
 127    int Status = 0;
 128    while (waitpid(Child,&Status,0) != Child)
 129    {
 130       if (errno == EINTR)
 131          continue;
 132       return _error->Errno("waitpid","Couldn't wait for subprocess");
 133    }
 134
 135    // Restore sig int/quit
 136    signal(SIGQUIT,SIG_DFL);
 137    signal(SIGINT,SIG_DFL);
 138
 139    // Check for an error code.
 140    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 141    {
 142       unsigned int Count = WEXITSTATUS(Status);
 143       if (Count > 100)
 144       {
 145          Count -= 100;
 146          for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
 147          _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
 148       }
 149
 150       return _error->Error("Sub-process returned an error code");
 151    }
 152
 153    return true;
 154 }
 155                                                                         /*}}}*/
 156
 157 // CopyFile - Buffered copy of a file                                   /*{{{*/
 158 // ---------------------------------------------------------------------
 159 /* The caller is expected to set things so that failure causes erasure */
 160 bool CopyFile(FileFd &From,FileFd &To)
 161 {
 162    if (From.IsOpen() == false || To.IsOpen() == false)
 163       return false;
 164
 165    // Buffered copy between fds
 166    SPtrArray<unsigned char> Buf = new unsigned char[64000];
 167    unsigned long long Size = From.Size();
 168    while (Size != 0)
 169    {
 170       unsigned long long ToRead = Size;
 171       if (Size > 64000)
 172          ToRead = 64000;
 173
 174       if (From.Read(Buf,ToRead) == false ||
 175           To.Write(Buf,ToRead) == false)
 176          return false;
 177
 178       Size -= ToRead;
 179    }
 180
 181    return true;
 182 }
 183                                                                         /*}}}*/
 184 // GetLock - Gets a lock file                                           /*{{{*/
 185 // ---------------------------------------------------------------------
 186 /* This will create an empty file of the given name and lock it. Once this
 187    is done all other calls to GetLock in any other process will fail with
 188    -1. The return result is the fd of the file, the call should call
 189    close at some time. */
 190 int GetLock(string File,bool Errors)
 191 {
 192    // GetLock() is used in aptitude on directories with public-write access
 193    // Use O_NOFOLLOW here to prevent symlink traversal attacks
 194    int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
 195    if (FD < 0)
 196    {
 197       // Read only .. cant have locking problems there.
 198       if (errno == EROFS)
 199       {
 200          _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
 201          return dup(0);       // Need something for the caller to close
 202       }
 203
 204       if (Errors == true)
 205          _error->Errno("open",_("Could not open lock file %s"),File.c_str());
 206
 207       // Feh.. We do this to distinguish the lock vs open case..
 208       errno = EPERM;
 209       return -1;
 210    }
 211    SetCloseExec(FD,true);
 212
 213    // Aquire a write lock
 214    struct flock fl;
 215    fl.l_type = F_WRLCK;
 216    fl.l_whence = SEEK_SET;
 217    fl.l_start = 0;
 218    fl.l_len = 0;
 219    if (fcntl(FD,F_SETLK,&fl) == -1)
 220    {
 221       if (errno == ENOLCK)
 222       {
 223          _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
 224          return dup(0);       // Need something for the caller to close
 225       }
 226       if (Errors == true)
 227          _error->Errno("open",_("Could not get lock %s"),File.c_str());
 228
 229       int Tmp = errno;
 230       close(FD);
 231       errno = Tmp;
 232       return -1;
 233    }
 234
 235    return FD;
 236 }
 237                                                                         /*}}}*/
 238 // FileExists - Check if a file exists                                  /*{{{*/
 239 // ---------------------------------------------------------------------
 240 /* Beware: Directories are also files! */
 241 bool FileExists(string File)
 242 {
 243    struct stat Buf;
 244    if (stat(File.c_str(),&Buf) != 0)
 245       return false;
 246    return true;
 247 }
 248                                                                         /*}}}*/
 249 // RealFileExists - Check if a file exists and if it is really a file   /*{{{*/
 250 // ---------------------------------------------------------------------
 251 /* */
 252 bool RealFileExists(string File)
 253 {
 254    struct stat Buf;
 255    if (stat(File.c_str(),&Buf) != 0)
 256       return false;
 257    return ((Buf.st_mode & S_IFREG) != 0);
 258 }
 259                                                                         /*}}}*/
 260 // DirectoryExists - Check if a directory exists and is really one      /*{{{*/
 261 // ---------------------------------------------------------------------
 262 /* */
 263 bool DirectoryExists(string const &Path)
 264 {
 265    struct stat Buf;
 266    if (stat(Path.c_str(),&Buf) != 0)
 267       return false;
 268    return ((Buf.st_mode & S_IFDIR) != 0);
 269 }
 270                                                                         /*}}}*/
 271 // CreateDirectory - poor man's mkdir -p guarded by a parent directory  /*{{{*/
 272 // ---------------------------------------------------------------------
 273 /* This method will create all directories needed for path in good old
 274    mkdir -p style but refuses to do this if Parent is not a prefix of
 275    this Path. Example: /var/cache/ and /var/cache/apt/archives are given,
 276    so it will create apt/archives if /var/cache exists - on the other
 277    hand if the parent is /var/lib the creation will fail as this path
 278    is not a parent of the path to be generated. */
 279 bool CreateDirectory(string const &Parent, string const &Path)
 280 {
 281    if (Parent.empty() == true || Path.empty() == true)
 282       return false;
 283
 284    if (DirectoryExists(Path) == true)
 285       return true;
 286
 287    if (DirectoryExists(Parent) == false)
 288       return false;
 289
 290    // we are not going to create directories "into the blue"
 291    if (Path.find(Parent, 0) != 0)
 292       return false;
 293
 294    vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');
 295    string progress = Parent;
 296    for (vector<string>::const_iterator d = dirs.begin(); d != dirs.end(); ++d)
 297    {
 298       if (d->empty() == true)
 299          continue;
 300
 301       progress.append("/").append(*d);
 302       if (DirectoryExists(progress) == true)
 303          continue;
 304
 305       if (mkdir(progress.c_str(), 0755) != 0)
 306          return false;
 307    }
 308    return true;
 309 }
 310                                                                         /*}}}*/
 311 // CreateAPTDirectoryIfNeeded - ensure that the given directory exists          /*{{{*/
 312 // ---------------------------------------------------------------------
 313 /* a small wrapper around CreateDirectory to check if it exists and to
 314    remove the trailing "/apt/" from the parent directory if needed */
 315 bool CreateAPTDirectoryIfNeeded(string const &Parent, string const &Path)
 316 {
 317    if (DirectoryExists(Path) == true)
 318       return true;
 319
 320    size_t const len = Parent.size();
 321    if (len > 5 && Parent.find("/apt/", len - 6, 5) == len - 5)
 322    {
 323       if (CreateDirectory(Parent.substr(0,len-5), Path) == true)
 324          return true;
 325    }
 326    else if (CreateDirectory(Parent, Path) == true)
 327       return true;
 328
 329    return false;
 330 }
 331                                                                         /*}}}*/
 332 // GetListOfFilesInDir - returns a vector of files in the given dir     /*{{{*/
 333 // ---------------------------------------------------------------------
 334 /* If an extension is given only files with this extension are included
 335    in the returned vector, otherwise every "normal" file is included. */
 336 std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
 337                                         bool const &SortList, bool const &AllowNoExt)
 338 {
 339    std::vector<string> ext;
 340    ext.reserve(2);
 341    if (Ext.empty() == false)
 342       ext.push_back(Ext);
 343    if (AllowNoExt == true && ext.empty() == false)
 344       ext.push_back("");
 345    return GetListOfFilesInDir(Dir, ext, SortList);
 346 }
 347 std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> const &Ext,
 348                                         bool const &SortList)
 349 {
 350    // Attention debuggers: need to be set with the environment config file!
 351    bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
 352    if (Debug == true)
 353    {
 354       std::clog << "Accept in " << Dir << " only files with the following " << Ext.size() << " extensions:" << std::endl;
 355       if (Ext.empty() == true)
 356          std::clog << "\tNO extension" << std::endl;
 357       else
 358          for (std::vector<string>::const_iterator e = Ext.begin();
 359               e != Ext.end(); ++e)
 360             std::clog << '\t' << (e->empty() == true ? "NO" : *e) << " extension" << std::endl;
 361    }
 362
 363    std::vector<string> List;
 364
 365    if (DirectoryExists(Dir.c_str()) == false)
 366    {
 367       _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
 368       return List;
 369    }
 370
 371    Configuration::MatchAgainstConfig SilentIgnore("Dir::Ignore-Files-Silently");
 372    DIR *D = opendir(Dir.c_str());
 373    if (D == 0)
 374    {
 375       _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 376       return List;
 377    }
 378
 379    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 380    {
 381       // skip "hidden" files
 382       if (Ent->d_name[0] == '.')
 383          continue;
 384
 385       // Make sure it is a file and not something else
 386       string const File = flCombine(Dir,Ent->d_name);
 387 #ifdef _DIRENT_HAVE_D_TYPE
 388       if (Ent->d_type != DT_REG)
 389 #endif
 390       {
 391          if (RealFileExists(File.c_str()) == false)
 392          {
 393             // do not show ignoration warnings for directories
 394             if (
 395 #ifdef _DIRENT_HAVE_D_TYPE
 396                 Ent->d_type == DT_DIR ||
 397 #endif
 398                 DirectoryExists(File.c_str()) == true)
 399                continue;
 400             if (SilentIgnore.Match(Ent->d_name) == false)
 401                _error->Notice(_("Ignoring '%s' in directory '%s' as it is not a regular file"), Ent->d_name, Dir.c_str());
 402             continue;
 403          }
 404       }
 405
 406       // check for accepted extension:
 407       // no extension given -> periods are bad as hell!
 408       // extensions given -> "" extension allows no extension
 409       if (Ext.empty() == false)
 410       {
 411          string d_ext = flExtension(Ent->d_name);
 412          if (d_ext == Ent->d_name) // no extension
 413          {
 414             if (std::find(Ext.begin(), Ext.end(), "") == Ext.end())
 415             {
 416                if (Debug == true)
 417                   std::clog << "Bad file: " << Ent->d_name << " → no extension" << std::endl;
 418                if (SilentIgnore.Match(Ent->d_name) == false)
 419                   _error->Notice(_("Ignoring file '%s' in directory '%s' as it has no filename extension"), Ent->d_name, Dir.c_str());
 420                continue;
 421             }
 422          }
 423          else if (std::find(Ext.begin(), Ext.end(), d_ext) == Ext.end())
 424          {
 425             if (Debug == true)
 426                std::clog << "Bad file: " << Ent->d_name << " → bad extension »" << flExtension(Ent->d_name) << "«" << std::endl;
 427             if (SilentIgnore.Match(Ent->d_name) == false)
 428                _error->Notice(_("Ignoring file '%s' in directory '%s' as it has an invalid filename extension"), Ent->d_name, Dir.c_str());
 429             continue;
 430          }
 431       }
 432
 433       // Skip bad filenames ala run-parts
 434       const char *C = Ent->d_name;
 435       for (; *C != 0; ++C)
 436          if (isalpha(*C) == 0 && isdigit(*C) == 0
 437              && *C != '_' && *C != '-') {
 438             // no required extension -> dot is a bad character
 439             if (*C == '.' && Ext.empty() == false)
 440                continue;
 441             break;
 442          }
 443
 444       // we don't reach the end of the name -> bad character included
 445       if (*C != 0)
 446       {
 447          if (Debug == true)
 448             std::clog << "Bad file: " << Ent->d_name << " → bad character »"
 449                << *C << "« in filename (period allowed: " << (Ext.empty() ? "no" : "yes") << ")" << std::endl;
 450          continue;
 451       }
 452
 453       // skip filenames which end with a period. These are never valid
 454       if (*(C - 1) == '.')
 455       {
 456          if (Debug == true)
 457             std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
 458          continue;
 459       }
 460
 461       if (Debug == true)
 462          std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
 463       List.push_back(File);
 464    }
 465    closedir(D);
 466
 467    if (SortList == true)
 468       std::sort(List.begin(),List.end());
 469    return List;
 470 }
 471 std::vector<string> GetListOfFilesInDir(string const &Dir, bool SortList)
 472 {
 473    bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
 474    if (Debug == true)
 475       std::clog << "Accept in " << Dir << " all regular files" << std::endl;
 476
 477    std::vector<string> List;
 478
 479    if (DirectoryExists(Dir.c_str()) == false)
 480    {
 481       _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
 482       return List;
 483    }
 484
 485    DIR *D = opendir(Dir.c_str());
 486    if (D == 0)
 487    {
 488       _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 489       return List;
 490    }
 491
 492    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 493    {
 494       // skip "hidden" files
 495       if (Ent->d_name[0] == '.')
 496          continue;
 497
 498       // Make sure it is a file and not something else
 499       string const File = flCombine(Dir,Ent->d_name);
 500 #ifdef _DIRENT_HAVE_D_TYPE
 501       if (Ent->d_type != DT_REG)
 502 #endif
 503       {
 504          if (RealFileExists(File.c_str()) == false)
 505          {
 506             if (Debug == true)
 507                std::clog << "Bad file: " << Ent->d_name << " → it is not a real file" << std::endl;
 508             continue;
 509          }
 510       }
 511
 512       // Skip bad filenames ala run-parts
 513       const char *C = Ent->d_name;
 514       for (; *C != 0; ++C)
 515          if (isalpha(*C) == 0 && isdigit(*C) == 0
 516              && *C != '_' && *C != '-' && *C != '.')
 517             break;
 518
 519       // we don't reach the end of the name -> bad character included
 520       if (*C != 0)
 521       {
 522          if (Debug == true)
 523             std::clog << "Bad file: " << Ent->d_name << " → bad character »" << *C << "« in filename" << std::endl;
 524          continue;
 525       }
 526
 527       // skip filenames which end with a period. These are never valid
 528       if (*(C - 1) == '.')
 529       {
 530          if (Debug == true)
 531             std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
 532          continue;
 533       }
 534
 535       if (Debug == true)
 536          std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
 537       List.push_back(File);
 538    }
 539    closedir(D);
 540
 541    if (SortList == true)
 542       std::sort(List.begin(),List.end());
 543    return List;
 544 }
 545                                                                         /*}}}*/
 546 // SafeGetCWD - This is a safer getcwd that returns a dynamic string    /*{{{*/
 547 // ---------------------------------------------------------------------
 548 /* We return / on failure. */
 549 string SafeGetCWD()
 550 {
 551    // Stash the current dir.
 552    char S[300];
 553    S[0] = 0;
 554    if (getcwd(S,sizeof(S)-2) == 0)
 555       return "/";
 556    unsigned int Len = strlen(S);
 557    S[Len] = '/';
 558    S[Len+1] = 0;
 559    return S;
 560 }
 561                                                                         /*}}}*/
 562 // GetModificationTime - Get the mtime of the given file or -1 on error /*{{{*/
 563 // ---------------------------------------------------------------------
 564 /* We return / on failure. */
 565 time_t GetModificationTime(string const &Path)
 566 {
 567    struct stat St;
 568    if (stat(Path.c_str(), &St) < 0)
 569       return -1;
 570    return  St.st_mtime;
 571 }
 572                                                                         /*}}}*/
 573 // flNotDir - Strip the directory from the filename                     /*{{{*/
 574 // ---------------------------------------------------------------------
 575 /* */
 576 string flNotDir(string File)
 577 {
 578    string::size_type Res = File.rfind('/');
 579    if (Res == string::npos)
 580       return File;
 581    Res++;
 582    return string(File,Res,Res - File.length());
 583 }
 584                                                                         /*}}}*/
 585 // flNotFile - Strip the file from the directory name                   /*{{{*/
 586 // ---------------------------------------------------------------------
 587 /* Result ends in a / */
 588 string flNotFile(string File)
 589 {
 590    string::size_type Res = File.rfind('/');
 591    if (Res == string::npos)
 592       return "./";
 593    Res++;
 594    return string(File,0,Res);
 595 }
 596                                                                         /*}}}*/
 597 // flExtension - Return the extension for the file                      /*{{{*/
 598 // ---------------------------------------------------------------------
 599 /* */
 600 string flExtension(string File)
 601 {
 602    string::size_type Res = File.rfind('.');
 603    if (Res == string::npos)
 604       return File;
 605    Res++;
 606    return string(File,Res,Res - File.length());
 607 }
 608                                                                         /*}}}*/
 609 // flNoLink - If file is a symlink then deref it                        /*{{{*/
 610 // ---------------------------------------------------------------------
 611 /* If the name is not a link then the returned path is the input. */
 612 string flNoLink(string File)
 613 {
 614    struct stat St;
 615    if (lstat(File.c_str(),&St) != 0 || S_ISLNK(St.st_mode) == 0)
 616       return File;
 617    if (stat(File.c_str(),&St) != 0)
 618       return File;
 619
 620    /* Loop resolving the link. There is no need to limit the number of
 621       loops because the stat call above ensures that the symlink is not
 622       circular */
 623    char Buffer[1024];
 624    string NFile = File;
 625    while (1)
 626    {
 627       // Read the link
 628       int Res;
 629       if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 ||
 630           (unsigned)Res >= sizeof(Buffer))
 631           return File;
 632
 633       // Append or replace the previous path
 634       Buffer[Res] = 0;
 635       if (Buffer[0] == '/')
 636          NFile = Buffer;
 637       else
 638          NFile = flNotFile(NFile) + Buffer;
 639
 640       // See if we are done
 641       if (lstat(NFile.c_str(),&St) != 0)
 642          return File;
 643       if (S_ISLNK(St.st_mode) == 0)
 644          return NFile;
 645    }
 646 }
 647                                                                         /*}}}*/
 648 // flCombine - Combine a file and a directory                           /*{{{*/
 649 // ---------------------------------------------------------------------
 650 /* If the file is an absolute path then it is just returned, otherwise
 651    the directory is pre-pended to it. */
 652 string flCombine(string Dir,string File)
 653 {
 654    if (File.empty() == true)
 655       return string();
 656
 657    if (File[0] == '/' || Dir.empty() == true)
 658       return File;
 659    if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
 660       return File;
 661    if (Dir[Dir.length()-1] == '/')
 662       return Dir + File;
 663    return Dir + '/' + File;
 664 }
 665                                                                         /*}}}*/
 666 // SetCloseExec - Set the close on exec flag                            /*{{{*/
 667 // ---------------------------------------------------------------------
 668 /* */
 669 void SetCloseExec(int Fd,bool Close)
 670 {
 671    if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
 672    {
 673       cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
 674       exit(100);
 675    }
 676 }
 677                                                                         /*}}}*/
 678 // SetNonBlock - Set the nonblocking flag                               /*{{{*/
 679 // ---------------------------------------------------------------------
 680 /* */
 681 void SetNonBlock(int Fd,bool Block)
 682 {
 683    int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
 684    if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
 685    {
 686       cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
 687       exit(100);
 688    }
 689 }
 690                                                                         /*}}}*/
 691 // WaitFd - Wait for a FD to become readable                            /*{{{*/
 692 // ---------------------------------------------------------------------
 693 /* This waits for a FD to become readable using select. It is useful for
 694    applications making use of non-blocking sockets. The timeout is
 695    in seconds. */
 696 bool WaitFd(int Fd,bool write,unsigned long timeout)
 697 {
 698    fd_set Set;
 699    struct timeval tv;
 700    FD_ZERO(&Set);
 701    FD_SET(Fd,&Set);
 702    tv.tv_sec = timeout;
 703    tv.tv_usec = 0;
 704    if (write == true)
 705    {
 706       int Res;
 707       do
 708       {
 709          Res = select(Fd+1,0,&Set,0,(timeout != 0?&tv:0));
 710       }
 711       while (Res < 0 && errno == EINTR);
 712
 713       if (Res <= 0)
 714          return false;
 715    }
 716    else
 717    {
 718       int Res;
 719       do
 720       {
 721          Res = select(Fd+1,&Set,0,0,(timeout != 0?&tv:0));
 722       }
 723       while (Res < 0 && errno == EINTR);
 724
 725       if (Res <= 0)
 726          return false;
 727    }
 728
 729    return true;
 730 }
 731                                                                         /*}}}*/
 732 // ExecFork - Magical fork that sanitizes the context before execing    /*{{{*/
 733 // ---------------------------------------------------------------------
 734 /* This is used if you want to cleanse the environment for the forked
 735    child, it fixes up the important signals and nukes all of the fds,
 736    otherwise acts like normal fork. */
 737 pid_t ExecFork()
 738 {
 739    // Fork off the process
 740    pid_t Process = fork();
 741    if (Process < 0)
 742    {
 743       cerr << "FATAL -> Failed to fork." << endl;
 744       exit(100);
 745    }
 746
 747    // Spawn the subprocess
 748    if (Process == 0)
 749    {
 750       // Setup the signals
 751       signal(SIGPIPE,SIG_DFL);
 752       signal(SIGQUIT,SIG_DFL);
 753       signal(SIGINT,SIG_DFL);
 754       signal(SIGWINCH,SIG_DFL);
 755       signal(SIGCONT,SIG_DFL);
 756       signal(SIGTSTP,SIG_DFL);
 757
 758       set<int> KeepFDs;
 759       Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
 760       if (Opts != 0 && Opts->Child != 0)
 761       {
 762          Opts = Opts->Child;
 763          for (; Opts != 0; Opts = Opts->Next)
 764          {
 765             if (Opts->Value.empty() == true)
 766                continue;
 767             int fd = atoi(Opts->Value.c_str());
 768             KeepFDs.insert(fd);
 769          }
 770       }
 771
 772       // Close all of our FDs - just in case
 773       for (int K = 3; K != 40; K++)
 774       {
 775          if(KeepFDs.find(K) == KeepFDs.end())
 776             fcntl(K,F_SETFD,FD_CLOEXEC);
 777       }
 778    }
 779
 780    return Process;
 781 }
 782                                                                         /*}}}*/
 783 // ExecWait - Fancy waitpid                                             /*{{{*/
 784 // ---------------------------------------------------------------------
 785 /* Waits for the given sub process. If Reap is set then no errors are
 786    generated. Otherwise a failed subprocess will generate a proper descriptive
 787    message */
 788 bool ExecWait(pid_t Pid,const char *Name,bool Reap)
 789 {
 790    if (Pid <= 1)
 791       return true;
 792
 793    // Wait and collect the error code
 794    int Status;
 795    while (waitpid(Pid,&Status,0) != Pid)
 796    {
 797       if (errno == EINTR)
 798          continue;
 799
 800       if (Reap == true)
 801          return false;
 802
 803       return _error->Error(_("Waited for %s but it wasn't there"),Name);
 804    }
 805
 806
 807    // Check for an error code.
 808    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 809    {
 810       if (Reap == true)
 811          return false;
 812       if (WIFSIGNALED(Status) != 0)
 813       {
 814          if( WTERMSIG(Status) == SIGSEGV)
 815             return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
 816          else
 817             return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));
 818       }
 819
 820       if (WIFEXITED(Status) != 0)
 821          return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
 822
 823       return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
 824    }
 825
 826    return true;
 827 }
 828                                                                         /*}}}*/
 829
 830 // FileFd::Open - Open a file                                           /*{{{*/
 831 // ---------------------------------------------------------------------
 832 /* The most commonly used open mode combinations are given with Mode */
 833 bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress, unsigned long const Perms)
 834 {
 835    if (Mode == ReadOnlyGzip)
 836       return Open(FileName, ReadOnly, Gzip, Perms);
 837
 838    if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)
 839       return _error->Error("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());
 840
 841    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
 842    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
 843    if (Compress == Auto)
 844    {
 845       for (; compressor != compressors.end(); ++compressor)
 846       {
 847          std::string file = std::string(FileName).append(compressor->Extension);
 848          if (FileExists(file) == false)
 849             continue;
 850          FileName = file;
 851          break;
 852       }
 853    }
 854    else if (Compress == Extension)
 855    {
 856       std::string::size_type const found = FileName.find_last_of('.');
 857       std::string ext;
 858       if (found != std::string::npos)
 859       {
 860          ext = FileName.substr(found);
 861          if (ext == ".new" || ext == ".bak")
 862          {
 863             std::string::size_type const found2 = FileName.find_last_of('.', found - 1);
 864             if (found2 != std::string::npos)
 865                ext = FileName.substr(found2, found - found2);
 866             else
 867                ext.clear();
 868          }
 869       }
 870       for (; compressor != compressors.end(); ++compressor)
 871          if (ext == compressor->Extension)
 872             break;
 873       // no matching extension - assume uncompressed (imagine files like 'example.org_Packages')
 874       if (compressor == compressors.end())
 875          for (compressor = compressors.begin(); compressor != compressors.end(); ++compressor)
 876             if (compressor->Name == ".")
 877                break;
 878    }
 879    else
 880    {
 881       std::string name;
 882       switch (Compress)
 883       {
 884       case None: name = "."; break;
 885       case Gzip: name = "gzip"; break;
 886       case Bzip2: name = "bzip2"; break;
 887       case Lzma: name = "lzma"; break;
 888       case Xz: name = "xz"; break;
 889       case Auto:
 890       case Extension:
 891          // Unreachable
 892          return _error->Error("Opening File %s in None, Auto or Extension should be already handled?!?", FileName.c_str());
 893       }
 894       for (; compressor != compressors.end(); ++compressor)
 895          if (compressor->Name == name)
 896             break;
 897       if (compressor == compressors.end())
 898          return _error->Error("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
 899    }
 900
 901    if (compressor == compressors.end())
 902       return _error->Error("Can't find a match for specified compressor mode for file %s", FileName.c_str());
 903    return Open(FileName, Mode, *compressor, Perms);
 904 }
 905 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const Perms)
 906 {
 907    Close();
 908    Flags = AutoClose;
 909
 910    if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)
 911       return _error->Error("ReadOnly mode for %s doesn't accept additional flags!", FileName.c_str());
 912    if ((Mode & ReadWrite) == 0)
 913       return _error->Error("No openmode provided in FileFd::Open for %s", FileName.c_str());
 914
 915    if ((Mode & Atomic) == Atomic)
 916    {
 917       Flags |= Replace;
 918       char *name = strdup((FileName + ".XXXXXX").c_str());
 919       TemporaryFileName = string(mktemp(name));
 920       free(name);
 921    }
 922    else if ((Mode & (Exclusive | Create)) == (Exclusive | Create))
 923    {
 924       // for atomic, this will be done by rename in Close()
 925       unlink(FileName.c_str());
 926    }
 927    if ((Mode & Empty) == Empty)
 928    {
 929       struct stat Buf;
 930       if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
 931          unlink(FileName.c_str());
 932    }
 933
 934    int fileflags = 0;
 935    #define if_FLAGGED_SET(FLAG, MODE) if ((Mode & FLAG) == FLAG) fileflags |= MODE
 936    if_FLAGGED_SET(ReadWrite, O_RDWR);
 937    else if_FLAGGED_SET(ReadOnly, O_RDONLY);
 938    else if_FLAGGED_SET(WriteOnly, O_WRONLY);
 939
 940    if_FLAGGED_SET(Create, O_CREAT);
 941    if_FLAGGED_SET(Empty, O_TRUNC);
 942    if_FLAGGED_SET(Exclusive, O_EXCL);
 943    else if_FLAGGED_SET(Atomic, O_EXCL);
 944    #undef if_FLAGGED_SET
 945
 946    if (TemporaryFileName.empty() == false)
 947       iFd = open(TemporaryFileName.c_str(), fileflags, Perms);
 948    else
 949       iFd = open(FileName.c_str(), fileflags, Perms);
 950
 951    this->FileName = FileName;
 952    if (iFd == -1 || OpenInternDescriptor(Mode, compressor) == false)
 953    {
 954       if (iFd != -1)
 955       {
 956          close (iFd);
 957          iFd = -1;
 958       }
 959       return _error->Errno("open",_("Could not open file %s"), FileName.c_str());
 960    }
 961
 962    SetCloseExec(iFd,true);
 963    return true;
 964 }
 965                                                                         /*}}}*/
 966 // FileFd::OpenDescriptor - Open a filedescriptor                       /*{{{*/
 967 // ---------------------------------------------------------------------
 968 /* */
 969 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose)
 970 {
 971    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
 972    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
 973    std::string name;
 974
 975    // compat with the old API
 976    if (Mode == ReadOnlyGzip && Compress == None)
 977       Compress = Gzip;
 978
 979    switch (Compress)
 980    {
 981    case None: name = "."; break;
 982    case Gzip: name = "gzip"; break;
 983    case Bzip2: name = "bzip2"; break;
 984    case Lzma: name = "lzma"; break;
 985    case Xz: name = "xz"; break;
 986    case Auto:
 987    case Extension:
 988       return _error->Error("Opening Fd %d in Auto or Extension compression mode is not supported", Fd);
 989    }
 990    for (; compressor != compressors.end(); ++compressor)
 991       if (compressor->Name == name)
 992          break;
 993    if (compressor == compressors.end())
 994       return _error->Error("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
 995
 996    return OpenDescriptor(Fd, Mode, *compressor, AutoClose);
 997 }
 998 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
 999 {
1000    Close();
1001    Flags = (AutoClose) ? FileFd::AutoClose : 0;
1002    iFd = Fd;
1003    this->FileName = "";
1004    if (OpenInternDescriptor(Mode, compressor) == false)
1005    {
1006       if (AutoClose)
1007          close (iFd);
1008       return _error->Errno("gzdopen",_("Could not open file descriptor %d"), Fd);
1009    }
1010    return true;
1011 }
1012 bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor)
1013 {
1014    if (d == NULL)
1015    {
1016       d = new FileFdPrivate();
1017       d->openmode = Mode;
1018       d->compressor = compressor;
1019    }
1020    if (compressor.Name == "." || compressor.Binary.empty() == true)
1021       return true;
1022 #ifdef HAVE_ZLIB
1023    else if (compressor.Name == "gzip")
1024    {
1025       if ((Mode & ReadWrite) == ReadWrite)
1026          d->gz = gzdopen(iFd, "r+");
1027       else if ((Mode & WriteOnly) == WriteOnly)
1028          d->gz = gzdopen(iFd, "w");
1029       else
1030          d->gz = gzdopen(iFd, "r");
1031       if (d->gz == NULL)
1032          return false;
1033       Flags |= Compressed;
1034       return true;
1035    }
1036 #endif
1037 #ifdef HAVE_BZ2
1038    else if (compressor.Name == "bzip2")
1039    {
1040       if ((Mode & ReadWrite) == ReadWrite)
1041          d->bz2 = BZ2_bzdopen(iFd, "r+");
1042       else if ((Mode & WriteOnly) == WriteOnly)
1043          d->bz2 = BZ2_bzdopen(iFd, "w");
1044       else
1045          d->bz2 = BZ2_bzdopen(iFd, "r");
1046       if (d->bz2 == NULL)
1047          return false;
1048       Flags |= Compressed;
1049       return true;
1050    }
1051 #endif
1052
1053
1054    if ((Mode & ReadWrite) == ReadWrite)
1055       return _error->Error("ReadWrite mode is not supported for file %s", FileName.c_str());
1056
1057    bool const Comp = (Mode & WriteOnly) == WriteOnly;
1058    // Handle 'decompression' of empty files
1059    if (Comp == false)
1060    {
1061       struct stat Buf;
1062       fstat(iFd, &Buf);
1063       if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
1064          return true;
1065
1066       // We don't need the file open - instead let the compressor open it
1067       // as he properly knows better how to efficiently read from 'his' file
1068       if (FileName.empty() == false)
1069       {
1070          close(iFd);
1071          iFd = -1;
1072       }
1073    }
1074
1075    // Create a data pipe
1076    int Pipe[2] = {-1,-1};
1077    if (pipe(Pipe) != 0)
1078       return _error->Errno("pipe",_("Failed to create subprocess IPC"));
1079    for (int J = 0; J != 2; J++)
1080       SetCloseExec(Pipe[J],true);
1081
1082    d->compressed_fd = iFd;
1083    d->pipe = true;
1084
1085    if (Comp == true)
1086       iFd = Pipe[1];
1087    else
1088       iFd = Pipe[0];
1089
1090    // The child..
1091    d->compressor_pid = ExecFork();
1092    if (d->compressor_pid == 0)
1093    {
1094       if (Comp == true)
1095       {
1096          dup2(d->compressed_fd,STDOUT_FILENO);
1097          dup2(Pipe[0],STDIN_FILENO);
1098       }
1099       else
1100       {
1101          if (FileName.empty() == true)
1102             dup2(d->compressed_fd,STDIN_FILENO);
1103          dup2(Pipe[1],STDOUT_FILENO);
1104       }
1105       int const nullfd = open("/dev/null", O_WRONLY);
1106       if (nullfd != -1)
1107       {
1108          dup2(nullfd,STDERR_FILENO);
1109          close(nullfd);
1110       }
1111
1112       SetCloseExec(STDOUT_FILENO,false);
1113       SetCloseExec(STDIN_FILENO,false);
1114
1115       std::vector<char const*> Args;
1116       Args.push_back(compressor.Binary.c_str());
1117       std::vector<std::string> const * const addArgs =
1118                 (Comp == true) ? &(compressor.CompressArgs) : &(compressor.UncompressArgs);
1119       for (std::vector<std::string>::const_iterator a = addArgs->begin();
1120            a != addArgs->end(); ++a)
1121          Args.push_back(a->c_str());
1122       if (Comp == false && FileName.empty() == false)
1123       {
1124          Args.push_back("--stdout");
1125          if (TemporaryFileName.empty() == false)
1126             Args.push_back(TemporaryFileName.c_str());
1127          else
1128             Args.push_back(FileName.c_str());
1129       }
1130       Args.push_back(NULL);
1131
1132       execvp(Args[0],(char **)&Args[0]);
1133       cerr << _("Failed to exec compressor ") << Args[0] << endl;
1134       _exit(100);
1135    }
1136    if (Comp == true)
1137       close(Pipe[0]);
1138    else
1139       close(Pipe[1]);
1140    if ((Comp == true || FileName.empty() == true) && d->compressed_fd != -1)
1141       close(d->compressed_fd);
1142
1143    return true;
1144 }
1145                                                                         /*}}}*/
1146 // FileFd::~File - Closes the file                                      /*{{{*/
1147 // ---------------------------------------------------------------------
1148 /* If the proper modes are selected then we close the Fd and possibly
1149    unlink the file on error. */
1150 FileFd::~FileFd()
1151 {
1152    Close();
1153 }
1154                                                                         /*}}}*/
1155 // FileFd::Read - Read a bit of the file                                /*{{{*/
1156 // ---------------------------------------------------------------------
1157 /* We are carefull to handle interruption by a signal while reading
1158    gracefully. */
1159 bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
1160 {
1161    int Res;
1162    errno = 0;
1163    if (Actual != 0)
1164       *Actual = 0;
1165    *((char *)To) = '\0';
1166    do
1167    {
1168 #ifdef HAVE_ZLIB
1169       if (d->gz != NULL)
1170          Res = gzread(d->gz,To,Size);
1171       else
1172 #endif
1173 #ifdef HAVE_BZ2
1174       if (d->bz2 != NULL)
1175          Res = BZ2_bzread(d->bz2,To,Size);
1176       else
1177 #endif
1178          Res = read(iFd,To,Size);
1179
1180       if (Res < 0)
1181       {
1182          if (errno == EINTR)
1183             continue;
1184          Flags |= Fail;
1185 #ifdef HAVE_ZLIB
1186          if (d->gz != NULL)
1187          {
1188             int err;
1189             char const * const errmsg = gzerror(d->gz, &err);
1190             if (err != Z_ERRNO)
1191                return _error->Error("gzread: %s (%d: %s)", _("Read error"), err, errmsg);
1192          }
1193 #endif
1194 #ifdef HAVE_BZ2
1195          if (d->bz2 != NULL)
1196          {
1197             int err;
1198             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1199             if (err != BZ_IO_ERROR)
1200                return _error->Error("BZ2_bzread: %s (%d: %s)", _("Read error"), err, errmsg);
1201          }
1202 #endif
1203          return _error->Errno("read",_("Read error"));
1204       }
1205
1206       To = (char *)To + Res;
1207       Size -= Res;
1208       d->seekpos += Res;
1209       if (Actual != 0)
1210          *Actual += Res;
1211    }
1212    while (Res > 0 && Size > 0);
1213
1214    if (Size == 0)
1215       return true;
1216
1217    // Eof handling
1218    if (Actual != 0)
1219    {
1220       Flags |= HitEof;
1221       return true;
1222    }
1223
1224    Flags |= Fail;
1225    return _error->Error(_("read, still have %llu to read but none left"), Size);
1226 }
1227                                                                         /*}}}*/
1228 // FileFd::ReadLine - Read a complete line from the file                /*{{{*/
1229 // ---------------------------------------------------------------------
1230 /* Beware: This method can be quiet slow for big buffers on UNcompressed
1231    files because of the naive implementation! */
1232 char* FileFd::ReadLine(char *To, unsigned long long const Size)
1233 {
1234    *To = '\0';
1235 #ifdef HAVE_ZLIB
1236    if (d->gz != NULL)
1237       return gzgets(d->gz, To, Size);
1238 #endif
1239
1240    unsigned long long read = 0;
1241    while ((Size - 1) != read)
1242    {
1243       unsigned long long done = 0;
1244       if (Read(To + read, 1, &done) == false)
1245          return NULL;
1246       if (done == 0)
1247          break;
1248       if (To[read++] == '\n')
1249          break;
1250    }
1251    if (read == 0)
1252       return NULL;
1253    To[read] = '\0';
1254    return To;
1255 }
1256                                                                         /*}}}*/
1257 // FileFd::Write - Write to the file                                    /*{{{*/
1258 // ---------------------------------------------------------------------
1259 /* */
1260 bool FileFd::Write(const void *From,unsigned long long Size)
1261 {
1262    int Res;
1263    errno = 0;
1264    do
1265    {
1266 #ifdef HAVE_ZLIB
1267       if (d->gz != NULL)
1268          Res = gzwrite(d->gz,From,Size);
1269       else
1270 #endif
1271 #ifdef HAVE_BZ2
1272       if (d->bz2 != NULL)
1273          Res = BZ2_bzwrite(d->bz2,(void*)From,Size);
1274       else
1275 #endif
1276          Res = write(iFd,From,Size);
1277       if (Res < 0 && errno == EINTR)
1278          continue;
1279       if (Res < 0)
1280       {
1281          Flags |= Fail;
1282 #ifdef HAVE_ZLIB
1283          if (d->gz != NULL)
1284          {
1285             int err;
1286             char const * const errmsg = gzerror(d->gz, &err);
1287             if (err != Z_ERRNO)
1288                return _error->Error("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1289          }
1290 #endif
1291 #ifdef HAVE_BZ2
1292          if (d->bz2 != NULL)
1293          {
1294             int err;
1295             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1296             if (err != BZ_IO_ERROR)
1297                return _error->Error("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1298          }
1299 #endif
1300          return _error->Errno("write",_("Write error"));
1301       }
1302
1303       From = (char *)From + Res;
1304       Size -= Res;
1305       d->seekpos += Res;
1306    }
1307    while (Res > 0 && Size > 0);
1308
1309    if (Size == 0)
1310       return true;
1311
1312    Flags |= Fail;
1313    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
1314 }
1315 bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
1316 {
1317    int Res;
1318    errno = 0;
1319    do
1320    {
1321       Res = write(Fd,From,Size);
1322       if (Res < 0 && errno == EINTR)
1323          continue;
1324       if (Res < 0)
1325          return _error->Errno("write",_("Write error"));
1326
1327       From = (char *)From + Res;
1328       Size -= Res;
1329    }
1330    while (Res > 0 && Size > 0);
1331
1332    if (Size == 0)
1333       return true;
1334
1335    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
1336 }
1337                                                                         /*}}}*/
1338 // FileFd::Seek - Seek in the file                                      /*{{{*/
1339 // ---------------------------------------------------------------------
1340 /* */
1341 bool FileFd::Seek(unsigned long long To)
1342 {
1343    if (d->pipe == true
1344 #ifdef HAVE_BZ2
1345         || d->bz2 != NULL
1346 #endif
1347         )
1348    {
1349       // Our poor man seeking in pipes is costly, so try to avoid it
1350       unsigned long long seekpos = Tell();
1351       if (seekpos == To)
1352          return true;
1353       else if (seekpos < To)
1354          return Skip(To - seekpos);
1355
1356       if ((d->openmode & ReadOnly) != ReadOnly)
1357          return _error->Error("Reopen is only implemented for read-only files!");
1358 #ifdef HAVE_BZ2
1359       if (d->bz2 != NULL)
1360          BZ2_bzclose(d->bz2);
1361 #endif
1362       if (iFd != -1)
1363          close(iFd);
1364       iFd = -1;
1365       if (TemporaryFileName.empty() == false)
1366          iFd = open(TemporaryFileName.c_str(), O_RDONLY);
1367       else if (FileName.empty() == false)
1368          iFd = open(FileName.c_str(), O_RDONLY);
1369       else
1370       {
1371          if (d->compressed_fd > 0)
1372             if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
1373                iFd = d->compressed_fd;
1374          if (iFd <= 0)
1375             return _error->Error("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");
1376       }
1377
1378       if (OpenInternDescriptor(d->openmode, d->compressor) == false)
1379          return _error->Error("Seek on file %s because it couldn't be reopened", FileName.c_str());
1380
1381       if (To != 0)
1382          return Skip(To);
1383
1384       d->seekpos = To;
1385       return true;
1386    }
1387    int res;
1388 #ifdef HAVE_ZLIB
1389    if (d->gz)
1390       res = gzseek(d->gz,To,SEEK_SET);
1391    else
1392 #endif
1393       res = lseek(iFd,To,SEEK_SET);
1394    if (res != (signed)To)
1395    {
1396       Flags |= Fail;
1397       return _error->Error("Unable to seek to %llu", To);
1398    }
1399
1400    d->seekpos = To;
1401    return true;
1402 }
1403                                                                         /*}}}*/
1404 // FileFd::Skip - Seek in the file                                      /*{{{*/
1405 // ---------------------------------------------------------------------
1406 /* */
1407 bool FileFd::Skip(unsigned long long Over)
1408 {
1409    if (d->pipe == true
1410 #ifdef HAVE_BZ2
1411         || d->bz2 != NULL
1412 #endif
1413         )
1414    {
1415       d->seekpos += Over;
1416       char buffer[1024];
1417       while (Over != 0)
1418       {
1419          unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
1420          if (Read(buffer, toread) == false)
1421             return _error->Error("Unable to seek ahead %llu",Over);
1422          Over -= toread;
1423       }
1424       return true;
1425    }
1426
1427    int res;
1428 #ifdef HAVE_ZLIB
1429    if (d->gz != NULL)
1430       res = gzseek(d->gz,Over,SEEK_CUR);
1431    else
1432 #endif
1433       res = lseek(iFd,Over,SEEK_CUR);
1434    if (res < 0)
1435    {
1436       Flags |= Fail;
1437       return _error->Error("Unable to seek ahead %llu",Over);
1438    }
1439    d->seekpos = res;
1440
1441    return true;
1442 }
1443                                                                         /*}}}*/
1444 // FileFd::Truncate - Truncate the file                                 /*{{{*/
1445 // ---------------------------------------------------------------------
1446 /* */
1447 bool FileFd::Truncate(unsigned long long To)
1448 {
1449 #if defined HAVE_ZLIB || defined HAVE_BZ2
1450    if (d->gz != NULL || d->bz2 != NULL)
1451    {
1452       Flags |= Fail;
1453       return _error->Error("Truncating compressed files is not implemented (%s)", FileName.c_str());
1454    }
1455 #endif
1456    if (ftruncate(iFd,To) != 0)
1457    {
1458       Flags |= Fail;
1459       return _error->Error("Unable to truncate to %llu",To);
1460    }
1461
1462    return true;
1463 }
1464                                                                         /*}}}*/
1465 // FileFd::Tell - Current seek position                                 /*{{{*/
1466 // ---------------------------------------------------------------------
1467 /* */
1468 unsigned long long FileFd::Tell()
1469 {
1470    // In theory, we could just return seekpos here always instead of
1471    // seeking around, but not all users of FileFd use always Seek() and co
1472    // so d->seekpos isn't always true and we can just use it as a hint if
1473    // we have nothing else, but not always as an authority…
1474    if (d->pipe == true
1475 #ifdef HAVE_BZ2
1476         || d->bz2 != NULL
1477 #endif
1478         )
1479       return d->seekpos;
1480
1481    off_t Res;
1482 #ifdef HAVE_ZLIB
1483    if (d->gz != NULL)
1484      Res = gztell(d->gz);
1485    else
1486 #endif
1487      Res = lseek(iFd,0,SEEK_CUR);
1488    if (Res == (off_t)-1)
1489       _error->Errno("lseek","Failed to determine the current file position");
1490    d->seekpos = Res;
1491    return Res;
1492 }
1493                                                                         /*}}}*/
1494 // FileFd::FileSize - Return the size of the file                       /*{{{*/
1495 // ---------------------------------------------------------------------
1496 /* */
1497 unsigned long long FileFd::FileSize()
1498 {
1499    struct stat Buf;
1500    if (d->pipe == false && fstat(iFd,&Buf) != 0)
1501       return _error->Errno("fstat","Unable to determine the file size");
1502
1503    // for compressor pipes st_size is undefined and at 'best' zero
1504    if (d->pipe == true || S_ISFIFO(Buf.st_mode))
1505    {
1506       // we set it here, too, as we get the info here for free
1507       // in theory the Open-methods should take care of it already
1508       d->pipe = true;
1509       if (stat(FileName.c_str(), &Buf) != 0)
1510          return _error->Errno("stat","Unable to determine the file size");
1511    }
1512
1513    return Buf.st_size;
1514 }
1515                                                                         /*}}}*/
1516 // FileFd::Size - Return the size of the content in the file            /*{{{*/
1517 // ---------------------------------------------------------------------
1518 /* */
1519 unsigned long long FileFd::Size()
1520 {
1521    unsigned long long size = FileSize();
1522
1523    // for compressor pipes st_size is undefined and at 'best' zero,
1524    // so we 'read' the content and 'seek' back - see there
1525    if (d->pipe == true
1526 #ifdef HAVE_BZ2
1527         || (d->bz2 && size > 0)
1528 #endif
1529         )
1530    {
1531       unsigned long long const oldSeek = Tell();
1532       char ignore[1000];
1533       unsigned long long read = 0;
1534       do {
1535          Read(ignore, sizeof(ignore), &read);
1536       } while(read != 0);
1537       size = Tell();
1538       Seek(oldSeek);
1539    }
1540 #ifdef HAVE_ZLIB
1541    // only check gzsize if we are actually a gzip file, just checking for
1542    // "gz" is not sufficient as uncompressed files could be opened with
1543    // gzopen in "direct" mode as well
1544    else if (d->gz && !gzdirect(d->gz) && size > 0)
1545    {
1546        off_t const oldPos = lseek(iFd,0,SEEK_CUR);
1547        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
1548         * this ourselves; the original (uncompressed) file size is the last 32
1549         * bits of the file */
1550        // FIXME: Size for gz-files is limited by 32bit… no largefile support
1551        if (lseek(iFd, -4, SEEK_END) < 0)
1552            return _error->Errno("lseek","Unable to seek to end of gzipped file");
1553        size = 0L;
1554        if (read(iFd, &size, 4) != 4)
1555            return _error->Errno("read","Unable to read original size of gzipped file");
1556
1557 #ifdef WORDS_BIGENDIAN
1558        uint32_t tmp_size = size;
1559        uint8_t const * const p = (uint8_t const * const) &tmp_size;
1560        tmp_size = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
1561        size = tmp_size;
1562 #endif
1563
1564        if (lseek(iFd, oldPos, SEEK_SET) < 0)
1565            return _error->Errno("lseek","Unable to seek in gzipped file");
1566
1567        return size;
1568    }
1569 #endif
1570
1571    return size;
1572 }
1573                                                                         /*}}}*/
1574 // FileFd::ModificationTime - Return the time of last touch             /*{{{*/
1575 // ---------------------------------------------------------------------
1576 /* */
1577 time_t FileFd::ModificationTime()
1578 {
1579    struct stat Buf;
1580    if (d->pipe == false && fstat(iFd,&Buf) != 0)
1581    {
1582       _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
1583       return 0;
1584    }
1585
1586    // for compressor pipes st_size is undefined and at 'best' zero
1587    if (d->pipe == true || S_ISFIFO(Buf.st_mode))
1588    {
1589       // we set it here, too, as we get the info here for free
1590       // in theory the Open-methods should take care of it already
1591       d->pipe = true;
1592       if (stat(FileName.c_str(), &Buf) != 0)
1593       {
1594          _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
1595          return 0;
1596       }
1597    }
1598
1599    return Buf.st_mtime;
1600 }
1601                                                                         /*}}}*/
1602 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
1603 // ---------------------------------------------------------------------
1604 /* */
1605 bool FileFd::Close()
1606 {
1607    if (iFd == -1)
1608       return true;
1609
1610    bool Res = true;
1611    if ((Flags & AutoClose) == AutoClose)
1612    {
1613 #ifdef HAVE_ZLIB
1614       if (d != NULL && d->gz != NULL) {
1615          int const e = gzclose(d->gz);
1616          // gzdclose() on empty files always fails with "buffer error" here, ignore that
1617          if (e != 0 && e != Z_BUF_ERROR)
1618             Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
1619       } else
1620 #endif
1621 #ifdef HAVE_BZ2
1622       if (d != NULL && d->bz2 != NULL)
1623          BZ2_bzclose(d->bz2);
1624       else
1625 #endif
1626          if (iFd > 0 && close(iFd) != 0)
1627             Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
1628    }
1629
1630    if ((Flags & Replace) == Replace && iFd >= 0) {
1631       if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
1632          Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
1633
1634       FileName = TemporaryFileName; // for the unlink() below.
1635       TemporaryFileName.clear();
1636    }
1637
1638    iFd = -1;
1639
1640    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
1641        FileName.empty() == false)
1642       if (unlink(FileName.c_str()) != 0)
1643          Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
1644
1645    if (d != NULL)
1646    {
1647       if (d->compressor_pid > 0)
1648          ExecWait(d->compressor_pid, "FileFdCompressor", true);
1649       delete d;
1650       d = NULL;
1651    }
1652
1653    return Res;
1654 }
1655                                                                         /*}}}*/
1656 // FileFd::Sync - Sync the file                                         /*{{{*/
1657 // ---------------------------------------------------------------------
1658 /* */
1659 bool FileFd::Sync()
1660 {
1661 #ifdef _POSIX_SYNCHRONIZED_IO
1662    if (fsync(iFd) != 0)
1663       return _error->Errno("sync",_("Problem syncing the file"));
1664 #endif
1665    return true;
1666 }
1667                                                                         /*}}}*/
1668
1669 gzFile FileFd::gzFd() { return (gzFile) d->gz; }