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