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 (compressor.Name == "." || compressor.Binary.empty() == true)
1015       return true;
1016
1017    if (d == NULL)
1018    {
1019       d = new FileFdPrivate();
1020       d->openmode = Mode;
1021       d->compressor = compressor;
1022    }
1023
1024 #ifdef HAVE_ZLIB
1025    if (compressor.Name == "gzip")
1026    {
1027       if (d->gz != NULL)
1028       {
1029          gzclose(d->gz);
1030          d->gz = NULL;
1031       }
1032       if ((Mode & ReadWrite) == ReadWrite)
1033          d->gz = gzdopen(iFd, "r+");
1034       else if ((Mode & WriteOnly) == WriteOnly)
1035          d->gz = gzdopen(iFd, "w");
1036       else
1037          d->gz = gzdopen(iFd, "r");
1038       if (d->gz == NULL)
1039          return false;
1040       Flags |= Compressed;
1041       return true;
1042    }
1043 #endif
1044 #ifdef HAVE_BZ2
1045    if (compressor.Name == "bzip2")
1046    {
1047       if (d->bz2 != NULL)
1048       {
1049          BZ2_bzclose(d->bz2);
1050          d->bz2 = NULL;
1051       }
1052       if ((Mode & ReadWrite) == ReadWrite)
1053          d->bz2 = BZ2_bzdopen(iFd, "r+");
1054       else if ((Mode & WriteOnly) == WriteOnly)
1055          d->bz2 = BZ2_bzdopen(iFd, "w");
1056       else
1057          d->bz2 = BZ2_bzdopen(iFd, "r");
1058       if (d->bz2 == NULL)
1059          return false;
1060       Flags |= Compressed;
1061       return true;
1062    }
1063 #endif
1064
1065    // collect zombies here in case we reopen
1066    if (d->compressor_pid > 0)
1067       ExecWait(d->compressor_pid, "FileFdCompressor", true);
1068
1069    if ((Mode & ReadWrite) == ReadWrite)
1070    {
1071       Flags |= Fail;
1072       return _error->Error("ReadWrite mode is not supported for file %s", FileName.c_str());
1073    }
1074
1075    bool const Comp = (Mode & WriteOnly) == WriteOnly;
1076    if (Comp == false)
1077    {
1078       // Handle 'decompression' of empty files
1079       struct stat Buf;
1080       fstat(iFd, &Buf);
1081       if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
1082          return true;
1083
1084       // We don't need the file open - instead let the compressor open it
1085       // as he properly knows better how to efficiently read from 'his' file
1086       if (FileName.empty() == false)
1087       {
1088          close(iFd);
1089          iFd = -1;
1090       }
1091    }
1092
1093    // Create a data pipe
1094    int Pipe[2] = {-1,-1};
1095    if (pipe(Pipe) != 0)
1096    {
1097       Flags |= Fail;
1098       return _error->Errno("pipe",_("Failed to create subprocess IPC"));
1099    }
1100    for (int J = 0; J != 2; J++)
1101       SetCloseExec(Pipe[J],true);
1102
1103    d->compressed_fd = iFd;
1104    d->pipe = true;
1105
1106    if (Comp == true)
1107       iFd = Pipe[1];
1108    else
1109       iFd = Pipe[0];
1110
1111    // The child..
1112    d->compressor_pid = ExecFork();
1113    if (d->compressor_pid == 0)
1114    {
1115       if (Comp == true)
1116       {
1117          dup2(d->compressed_fd,STDOUT_FILENO);
1118          dup2(Pipe[0],STDIN_FILENO);
1119       }
1120       else
1121       {
1122          if (FileName.empty() == true)
1123             dup2(d->compressed_fd,STDIN_FILENO);
1124          dup2(Pipe[1],STDOUT_FILENO);
1125       }
1126       int const nullfd = open("/dev/null", O_WRONLY);
1127       if (nullfd != -1)
1128       {
1129          dup2(nullfd,STDERR_FILENO);
1130          close(nullfd);
1131       }
1132
1133       SetCloseExec(STDOUT_FILENO,false);
1134       SetCloseExec(STDIN_FILENO,false);
1135
1136       std::vector<char const*> Args;
1137       Args.push_back(compressor.Binary.c_str());
1138       std::vector<std::string> const * const addArgs =
1139                 (Comp == true) ? &(compressor.CompressArgs) : &(compressor.UncompressArgs);
1140       for (std::vector<std::string>::const_iterator a = addArgs->begin();
1141            a != addArgs->end(); ++a)
1142          Args.push_back(a->c_str());
1143       if (Comp == false && FileName.empty() == false)
1144       {
1145          Args.push_back("--stdout");
1146          if (TemporaryFileName.empty() == false)
1147             Args.push_back(TemporaryFileName.c_str());
1148          else
1149             Args.push_back(FileName.c_str());
1150       }
1151       Args.push_back(NULL);
1152
1153       execvp(Args[0],(char **)&Args[0]);
1154       cerr << _("Failed to exec compressor ") << Args[0] << endl;
1155       _exit(100);
1156    }
1157    if (Comp == true)
1158       close(Pipe[0]);
1159    else
1160       close(Pipe[1]);
1161    if ((Comp == true || FileName.empty() == true) && d->compressed_fd != -1)
1162       close(d->compressed_fd);
1163
1164    return true;
1165 }
1166                                                                         /*}}}*/
1167 // FileFd::~File - Closes the file                                      /*{{{*/
1168 // ---------------------------------------------------------------------
1169 /* If the proper modes are selected then we close the Fd and possibly
1170    unlink the file on error. */
1171 FileFd::~FileFd()
1172 {
1173    Close();
1174 }
1175                                                                         /*}}}*/
1176 // FileFd::Read - Read a bit of the file                                /*{{{*/
1177 // ---------------------------------------------------------------------
1178 /* We are carefull to handle interruption by a signal while reading
1179    gracefully. */
1180 bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
1181 {
1182    int Res;
1183    errno = 0;
1184    if (Actual != 0)
1185       *Actual = 0;
1186    *((char *)To) = '\0';
1187    do
1188    {
1189 #ifdef HAVE_ZLIB
1190       if (d != NULL && d->gz != NULL)
1191          Res = gzread(d->gz,To,Size);
1192       else
1193 #endif
1194 #ifdef HAVE_BZ2
1195       if (d != NULL && d->bz2 != NULL)
1196          Res = BZ2_bzread(d->bz2,To,Size);
1197       else
1198 #endif
1199          Res = read(iFd,To,Size);
1200
1201       if (Res < 0)
1202       {
1203          if (errno == EINTR)
1204             continue;
1205          Flags |= Fail;
1206 #ifdef HAVE_ZLIB
1207          if (d != NULL && d->gz != NULL)
1208          {
1209             int err;
1210             char const * const errmsg = gzerror(d->gz, &err);
1211             if (err != Z_ERRNO)
1212                return _error->Error("gzread: %s (%d: %s)", _("Read error"), err, errmsg);
1213          }
1214 #endif
1215 #ifdef HAVE_BZ2
1216          if (d != NULL && d->bz2 != NULL)
1217          {
1218             int err;
1219             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1220             if (err != BZ_IO_ERROR)
1221                return _error->Error("BZ2_bzread: %s (%d: %s)", _("Read error"), err, errmsg);
1222          }
1223 #endif
1224          return _error->Errno("read",_("Read error"));
1225       }
1226
1227       To = (char *)To + Res;
1228       Size -= Res;
1229       if (d != NULL)
1230          d->seekpos += Res;
1231       if (Actual != 0)
1232          *Actual += Res;
1233    }
1234    while (Res > 0 && Size > 0);
1235
1236    if (Size == 0)
1237       return true;
1238
1239    // Eof handling
1240    if (Actual != 0)
1241    {
1242       Flags |= HitEof;
1243       return true;
1244    }
1245
1246    Flags |= Fail;
1247    return _error->Error(_("read, still have %llu to read but none left"), Size);
1248 }
1249                                                                         /*}}}*/
1250 // FileFd::ReadLine - Read a complete line from the file                /*{{{*/
1251 // ---------------------------------------------------------------------
1252 /* Beware: This method can be quiet slow for big buffers on UNcompressed
1253    files because of the naive implementation! */
1254 char* FileFd::ReadLine(char *To, unsigned long long const Size)
1255 {
1256    *To = '\0';
1257 #ifdef HAVE_ZLIB
1258    if (d != NULL && d->gz != NULL)
1259       return gzgets(d->gz, To, Size);
1260 #endif
1261
1262    unsigned long long read = 0;
1263    while ((Size - 1) != read)
1264    {
1265       unsigned long long done = 0;
1266       if (Read(To + read, 1, &done) == false)
1267          return NULL;
1268       if (done == 0)
1269          break;
1270       if (To[read++] == '\n')
1271          break;
1272    }
1273    if (read == 0)
1274       return NULL;
1275    To[read] = '\0';
1276    return To;
1277 }
1278                                                                         /*}}}*/
1279 // FileFd::Write - Write to the file                                    /*{{{*/
1280 // ---------------------------------------------------------------------
1281 /* */
1282 bool FileFd::Write(const void *From,unsigned long long Size)
1283 {
1284    int Res;
1285    errno = 0;
1286    do
1287    {
1288 #ifdef HAVE_ZLIB
1289       if (d != NULL && d->gz != NULL)
1290          Res = gzwrite(d->gz,From,Size);
1291       else
1292 #endif
1293 #ifdef HAVE_BZ2
1294       if (d != NULL && d->bz2 != NULL)
1295          Res = BZ2_bzwrite(d->bz2,(void*)From,Size);
1296       else
1297 #endif
1298          Res = write(iFd,From,Size);
1299       if (Res < 0 && errno == EINTR)
1300          continue;
1301       if (Res < 0)
1302       {
1303          Flags |= Fail;
1304 #ifdef HAVE_ZLIB
1305          if (d != NULL && d->gz != NULL)
1306          {
1307             int err;
1308             char const * const errmsg = gzerror(d->gz, &err);
1309             if (err != Z_ERRNO)
1310                return _error->Error("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1311          }
1312 #endif
1313 #ifdef HAVE_BZ2
1314          if (d != NULL && d->bz2 != NULL)
1315          {
1316             int err;
1317             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1318             if (err != BZ_IO_ERROR)
1319                return _error->Error("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1320          }
1321 #endif
1322          return _error->Errno("write",_("Write error"));
1323       }
1324
1325       From = (char *)From + Res;
1326       Size -= Res;
1327       if (d != NULL)
1328          d->seekpos += Res;
1329    }
1330    while (Res > 0 && Size > 0);
1331
1332    if (Size == 0)
1333       return true;
1334
1335    Flags |= Fail;
1336    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
1337 }
1338 bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
1339 {
1340    int Res;
1341    errno = 0;
1342    do
1343    {
1344       Res = write(Fd,From,Size);
1345       if (Res < 0 && errno == EINTR)
1346          continue;
1347       if (Res < 0)
1348          return _error->Errno("write",_("Write error"));
1349
1350       From = (char *)From + Res;
1351       Size -= Res;
1352    }
1353    while (Res > 0 && Size > 0);
1354
1355    if (Size == 0)
1356       return true;
1357
1358    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
1359 }
1360                                                                         /*}}}*/
1361 // FileFd::Seek - Seek in the file                                      /*{{{*/
1362 // ---------------------------------------------------------------------
1363 /* */
1364 bool FileFd::Seek(unsigned long long To)
1365 {
1366    if (d != NULL && (d->pipe == true
1367 #ifdef HAVE_BZ2
1368                         || d->bz2 != NULL
1369 #endif
1370         ))
1371    {
1372       // Our poor man seeking in pipes is costly, so try to avoid it
1373       unsigned long long seekpos = Tell();
1374       if (seekpos == To)
1375          return true;
1376       else if (seekpos < To)
1377          return Skip(To - seekpos);
1378
1379       if ((d->openmode & ReadOnly) != ReadOnly)
1380       {
1381          Flags |= Fail;
1382          return _error->Error("Reopen is only implemented for read-only files!");
1383       }
1384 #ifdef HAVE_BZ2
1385       if (d->bz2 != NULL)
1386          BZ2_bzclose(d->bz2);
1387 #endif
1388       if (iFd != -1)
1389          close(iFd);
1390       iFd = -1;
1391       if (TemporaryFileName.empty() == false)
1392          iFd = open(TemporaryFileName.c_str(), O_RDONLY);
1393       else if (FileName.empty() == false)
1394          iFd = open(FileName.c_str(), O_RDONLY);
1395       else
1396       {
1397          if (d->compressed_fd > 0)
1398             if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
1399                iFd = d->compressed_fd;
1400          if (iFd <= 0)
1401          {
1402             Flags |= Fail;
1403             return _error->Error("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");
1404          }
1405       }
1406
1407       if (OpenInternDescriptor(d->openmode, d->compressor) == false)
1408       {
1409          Flags |= Fail;
1410          return _error->Error("Seek on file %s because it couldn't be reopened", FileName.c_str());
1411       }
1412
1413       if (To != 0)
1414          return Skip(To);
1415
1416       d->seekpos = To;
1417       return true;
1418    }
1419    int res;
1420 #ifdef HAVE_ZLIB
1421    if (d != NULL && d->gz)
1422       res = gzseek(d->gz,To,SEEK_SET);
1423    else
1424 #endif
1425       res = lseek(iFd,To,SEEK_SET);
1426    if (res != (signed)To)
1427    {
1428       Flags |= Fail;
1429       return _error->Error("Unable to seek to %llu", To);
1430    }
1431
1432    if (d != NULL)
1433       d->seekpos = To;
1434    return true;
1435 }
1436                                                                         /*}}}*/
1437 // FileFd::Skip - Seek in the file                                      /*{{{*/
1438 // ---------------------------------------------------------------------
1439 /* */
1440 bool FileFd::Skip(unsigned long long Over)
1441 {
1442    if (d != NULL && (d->pipe == true
1443 #ifdef HAVE_BZ2
1444                         || d->bz2 != NULL
1445 #endif
1446         ))
1447    {
1448       d->seekpos += Over;
1449       char buffer[1024];
1450       while (Over != 0)
1451       {
1452          unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
1453          if (Read(buffer, toread) == false)
1454          {
1455             Flags |= Fail;
1456             return _error->Error("Unable to seek ahead %llu",Over);
1457          }
1458          Over -= toread;
1459       }
1460       return true;
1461    }
1462
1463    int res;
1464 #ifdef HAVE_ZLIB
1465    if (d != NULL && d->gz != NULL)
1466       res = gzseek(d->gz,Over,SEEK_CUR);
1467    else
1468 #endif
1469       res = lseek(iFd,Over,SEEK_CUR);
1470    if (res < 0)
1471    {
1472       Flags |= Fail;
1473       return _error->Error("Unable to seek ahead %llu",Over);
1474    }
1475    if (d != NULL)
1476       d->seekpos = res;
1477
1478    return true;
1479 }
1480                                                                         /*}}}*/
1481 // FileFd::Truncate - Truncate the file                                 /*{{{*/
1482 // ---------------------------------------------------------------------
1483 /* */
1484 bool FileFd::Truncate(unsigned long long To)
1485 {
1486 #if defined HAVE_ZLIB || defined HAVE_BZ2
1487    if (d != NULL && (d->gz != NULL || d->bz2 != NULL))
1488    {
1489       Flags |= Fail;
1490       return _error->Error("Truncating compressed files is not implemented (%s)", FileName.c_str());
1491    }
1492 #endif
1493    if (ftruncate(iFd,To) != 0)
1494    {
1495       Flags |= Fail;
1496       return _error->Error("Unable to truncate to %llu",To);
1497    }
1498
1499    return true;
1500 }
1501                                                                         /*}}}*/
1502 // FileFd::Tell - Current seek position                                 /*{{{*/
1503 // ---------------------------------------------------------------------
1504 /* */
1505 unsigned long long FileFd::Tell()
1506 {
1507    // In theory, we could just return seekpos here always instead of
1508    // seeking around, but not all users of FileFd use always Seek() and co
1509    // so d->seekpos isn't always true and we can just use it as a hint if
1510    // we have nothing else, but not always as an authority…
1511    if (d != NULL && (d->pipe == true
1512 #ifdef HAVE_BZ2
1513                         || d->bz2 != NULL
1514 #endif
1515         ))
1516       return d->seekpos;
1517
1518    off_t Res;
1519 #ifdef HAVE_ZLIB
1520    if (d != NULL && d->gz != NULL)
1521      Res = gztell(d->gz);
1522    else
1523 #endif
1524      Res = lseek(iFd,0,SEEK_CUR);
1525    if (Res == (off_t)-1)
1526    {
1527       Flags |= Fail;
1528       _error->Errno("lseek","Failed to determine the current file position");
1529    }
1530    if (d != NULL)
1531       d->seekpos = Res;
1532    return Res;
1533 }
1534                                                                         /*}}}*/
1535 // FileFd::FileSize - Return the size of the file                       /*{{{*/
1536 // ---------------------------------------------------------------------
1537 /* */
1538 unsigned long long FileFd::FileSize()
1539 {
1540    struct stat Buf;
1541    if ((d == NULL || d->pipe == false) && fstat(iFd,&Buf) != 0)
1542    {
1543       Flags |= Fail;
1544       return _error->Errno("fstat","Unable to determine the file size");
1545    }
1546
1547    // for compressor pipes st_size is undefined and at 'best' zero
1548    if ((d != NULL && d->pipe == true) || S_ISFIFO(Buf.st_mode))
1549    {
1550       // we set it here, too, as we get the info here for free
1551       // in theory the Open-methods should take care of it already
1552       if (d != NULL)
1553          d->pipe = true;
1554       if (stat(FileName.c_str(), &Buf) != 0)
1555       {
1556          Flags |= Fail;
1557          return _error->Errno("stat","Unable to determine the file size");
1558       }
1559    }
1560
1561    return Buf.st_size;
1562 }
1563                                                                         /*}}}*/
1564 // FileFd::Size - Return the size of the content in the file            /*{{{*/
1565 // ---------------------------------------------------------------------
1566 /* */
1567 unsigned long long FileFd::Size()
1568 {
1569    unsigned long long size = FileSize();
1570
1571    // for compressor pipes st_size is undefined and at 'best' zero,
1572    // so we 'read' the content and 'seek' back - see there
1573    if (d != NULL && (d->pipe == true
1574 #ifdef HAVE_BZ2
1575                         || (d->bz2 && size > 0)
1576 #endif
1577         ))
1578    {
1579       unsigned long long const oldSeek = Tell();
1580       char ignore[1000];
1581       unsigned long long read = 0;
1582       do {
1583          Read(ignore, sizeof(ignore), &read);
1584       } while(read != 0);
1585       size = Tell();
1586       Seek(oldSeek);
1587    }
1588 #ifdef HAVE_ZLIB
1589    // only check gzsize if we are actually a gzip file, just checking for
1590    // "gz" is not sufficient as uncompressed files could be opened with
1591    // gzopen in "direct" mode as well
1592    else if (d != NULL && d->gz && !gzdirect(d->gz) && size > 0)
1593    {
1594        off_t const oldPos = lseek(iFd,0,SEEK_CUR);
1595        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
1596         * this ourselves; the original (uncompressed) file size is the last 32
1597         * bits of the file */
1598        // FIXME: Size for gz-files is limited by 32bit… no largefile support
1599        if (lseek(iFd, -4, SEEK_END) < 0)
1600        {
1601           Flags |= Fail;
1602           return _error->Errno("lseek","Unable to seek to end of gzipped file");
1603        }
1604        size = 0L;
1605        if (read(iFd, &size, 4) != 4)
1606        {
1607           Flags |= Fail;
1608           return _error->Errno("read","Unable to read original size of gzipped file");
1609        }
1610
1611 #ifdef WORDS_BIGENDIAN
1612        uint32_t tmp_size = size;
1613        uint8_t const * const p = (uint8_t const * const) &tmp_size;
1614        tmp_size = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
1615        size = tmp_size;
1616 #endif
1617
1618        if (lseek(iFd, oldPos, SEEK_SET) < 0)
1619        {
1620           Flags |= Fail;
1621           return _error->Errno("lseek","Unable to seek in gzipped file");
1622        }
1623
1624        return size;
1625    }
1626 #endif
1627
1628    return size;
1629 }
1630                                                                         /*}}}*/
1631 // FileFd::ModificationTime - Return the time of last touch             /*{{{*/
1632 // ---------------------------------------------------------------------
1633 /* */
1634 time_t FileFd::ModificationTime()
1635 {
1636    struct stat Buf;
1637    if ((d == NULL || d->pipe == false) && fstat(iFd,&Buf) != 0)
1638    {
1639       Flags |= Fail;
1640       _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
1641       return 0;
1642    }
1643
1644    // for compressor pipes st_size is undefined and at 'best' zero
1645    if ((d != NULL && d->pipe == true) || S_ISFIFO(Buf.st_mode))
1646    {
1647       // we set it here, too, as we get the info here for free
1648       // in theory the Open-methods should take care of it already
1649       if (d != NULL)
1650          d->pipe = true;
1651       if (stat(FileName.c_str(), &Buf) != 0)
1652       {
1653          Flags |= Fail;
1654          _error->Errno("fstat","Unable to determine the modification time of file %s", FileName.c_str());
1655          return 0;
1656       }
1657    }
1658
1659    return Buf.st_mtime;
1660 }
1661                                                                         /*}}}*/
1662 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
1663 // ---------------------------------------------------------------------
1664 /* */
1665 bool FileFd::Close()
1666 {
1667    if (iFd == -1)
1668       return true;
1669
1670    bool Res = true;
1671    if ((Flags & AutoClose) == AutoClose)
1672    {
1673 #ifdef HAVE_ZLIB
1674       if (d != NULL && d->gz != NULL) {
1675          int const e = gzclose(d->gz);
1676          // gzdclose() on empty files always fails with "buffer error" here, ignore that
1677          if (e != 0 && e != Z_BUF_ERROR)
1678             Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
1679       } else
1680 #endif
1681 #ifdef HAVE_BZ2
1682       if (d != NULL && d->bz2 != NULL)
1683          BZ2_bzclose(d->bz2);
1684       else
1685 #endif
1686          if (iFd > 0 && close(iFd) != 0)
1687             Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
1688    }
1689
1690    if ((Flags & Replace) == Replace && iFd >= 0) {
1691       if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
1692          Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
1693
1694       FileName = TemporaryFileName; // for the unlink() below.
1695       TemporaryFileName.clear();
1696    }
1697
1698    iFd = -1;
1699
1700    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
1701        FileName.empty() == false)
1702       if (unlink(FileName.c_str()) != 0)
1703          Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
1704
1705    if (d != NULL)
1706    {
1707       if (d->compressor_pid > 0)
1708          ExecWait(d->compressor_pid, "FileFdCompressor", true);
1709       delete d;
1710       d = NULL;
1711    }
1712
1713    if (Res == false)
1714       Flags |= Fail;
1715    return Res;
1716 }
1717                                                                         /*}}}*/
1718 // FileFd::Sync - Sync the file                                         /*{{{*/
1719 // ---------------------------------------------------------------------
1720 /* */
1721 bool FileFd::Sync()
1722 {
1723 #ifdef _POSIX_SYNCHRONIZED_IO
1724    if (fsync(iFd) != 0)
1725    {
1726       Flags |= Fail;
1727       return _error->Errno("sync",_("Problem syncing the file"));
1728    }
1729 #endif
1730    return true;
1731 }
1732                                                                         /*}}}*/
1733
1734 gzFile FileFd::gzFd() { return (gzFile) d->gz; }