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