apt-pkg/contrib/fileutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4
   5    File Utilities
   6
   7    CopyFile - Buffered copy of a single file
   8    GetLock - dpkg compatible lock file manipulation (fcntl)
   9
  10    Most of this source is placed in the Public Domain, do with it what
  11    you will
  12    It was originally written by Jason Gunthorpe <jgg@debian.org>.
  13    FileFd gzip support added by Martin Pitt <martin.pitt@canonical.com>
  14
  15    The exception is RunScripts() it is under the GPLv2
  16
  17    ##################################################################### */
  18                                                                         /*}}}*/
  19 // Include Files                                                        /*{{{*/
  20 #include <config.h>
  21
  22 #include <apt-pkg/fileutl.h>
  23 #include <apt-pkg/strutl.h>
  24 #include <apt-pkg/error.h>
  25 #include <apt-pkg/sptr.h>
  26 #include <apt-pkg/aptconfiguration.h>
  27 #include <apt-pkg/configuration.h>
  28 #include <apt-pkg/macros.h>
  29
  30 #include <ctype.h>
  31 #include <stdarg.h>
  32 #include <stddef.h>
  33 #include <sys/select.h>
  34 #include <time.h>
  35 #include <string>
  36 #include <vector>
  37 #include <cstdlib>
  38 #include <cstring>
  39 #include <cstdio>
  40 #include <iostream>
  41 #include <unistd.h>
  42 #include <fcntl.h>
  43 #include <sys/stat.h>
  44 #include <sys/time.h>
  45 #include <sys/wait.h>
  46 #include <dirent.h>
  47 #include <signal.h>
  48 #include <errno.h>
  49 #include <glob.h>
  50 #include <pwd.h>
  51 #include <grp.h>
  52
  53 #include <set>
  54 #include <algorithm>
  55
  56 #ifdef HAVE_ZLIB
  57         #include <zlib.h>
  58 #endif
  59 #ifdef HAVE_BZ2
  60         #include <bzlib.h>
  61 #endif
  62 #ifdef HAVE_LZMA
  63         #include <lzma.h>
  64 #endif
  65 #include <endian.h>
  66 #include <stdint.h>
  67
  68 #if __gnu_linux__
  69 #include <sys/prctl.h>
  70 #endif
  71
  72 #include <apti18n.h>
  73                                                                         /*}}}*/
  74
  75 using namespace std;
  76
  77 // RunScripts - Run a set of scripts from a configuration subtree       /*{{{*/
  78 // ---------------------------------------------------------------------
  79 /* */
  80 bool RunScripts(const char *Cnf)
  81 {
  82    Configuration::Item const *Opts = _config->Tree(Cnf);
  83    if (Opts == 0 || Opts->Child == 0)
  84       return true;
  85    Opts = Opts->Child;
  86
  87    // Fork for running the system calls
  88    pid_t Child = ExecFork();
  89
  90    // This is the child
  91    if (Child == 0)
  92    {
  93       if (_config->FindDir("DPkg::Chroot-Directory","/") != "/")
  94       {
  95          std::cerr << "Chrooting into "
  96                    << _config->FindDir("DPkg::Chroot-Directory")
  97                    << std::endl;
  98          if (chroot(_config->FindDir("DPkg::Chroot-Directory","/").c_str()) != 0)
  99             _exit(100);
 100       }
 101
 102       if (chdir("/tmp/") != 0)
 103          _exit(100);
 104
 105       unsigned int Count = 1;
 106       for (; Opts != 0; Opts = Opts->Next, Count++)
 107       {
 108          if (Opts->Value.empty() == true)
 109             continue;
 110
 111          if(_config->FindB("Debug::RunScripts", false) == true)
 112             std::clog << "Running external script: '"
 113                       << Opts->Value << "'" << std::endl;
 114
 115          if (system(Opts->Value.c_str()) != 0)
 116             _exit(100+Count);
 117       }
 118       _exit(0);
 119    }
 120
 121    // Wait for the child
 122    int Status = 0;
 123    while (waitpid(Child,&Status,0) != Child)
 124    {
 125       if (errno == EINTR)
 126          continue;
 127       return _error->Errno("waitpid","Couldn't wait for subprocess");
 128    }
 129
 130    // Restore sig int/quit
 131    signal(SIGQUIT,SIG_DFL);
 132    signal(SIGINT,SIG_DFL);
 133
 134    // Check for an error code.
 135    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 136    {
 137       unsigned int Count = WEXITSTATUS(Status);
 138       if (Count > 100)
 139       {
 140          Count -= 100;
 141          for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
 142          _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
 143       }
 144
 145       return _error->Error("Sub-process returned an error code");
 146    }
 147
 148    return true;
 149 }
 150                                                                         /*}}}*/
 151
 152 // CopyFile - Buffered copy of a file                                   /*{{{*/
 153 // ---------------------------------------------------------------------
 154 /* The caller is expected to set things so that failure causes erasure */
 155 bool CopyFile(FileFd &From,FileFd &To)
 156 {
 157    if (From.IsOpen() == false || To.IsOpen() == false ||
 158          From.Failed() == true || To.Failed() == true)
 159       return false;
 160
 161    // Buffered copy between fds
 162    SPtrArray<unsigned char> Buf = new unsigned char[64000];
 163    unsigned long long Size = From.Size();
 164    while (Size != 0)
 165    {
 166       unsigned long long ToRead = Size;
 167       if (Size > 64000)
 168          ToRead = 64000;
 169
 170       if (From.Read(Buf,ToRead) == false ||
 171           To.Write(Buf,ToRead) == false)
 172          return false;
 173
 174       Size -= ToRead;
 175    }
 176
 177    return true;
 178 }
 179                                                                         /*}}}*/
 180 // GetLock - Gets a lock file                                           /*{{{*/
 181 // ---------------------------------------------------------------------
 182 /* This will create an empty file of the given name and lock it. Once this
 183    is done all other calls to GetLock in any other process will fail with
 184    -1. The return result is the fd of the file, the call should call
 185    close at some time. */
 186 int GetLock(string File,bool Errors)
 187 {
 188    // GetLock() is used in aptitude on directories with public-write access
 189    // Use O_NOFOLLOW here to prevent symlink traversal attacks
 190    int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
 191    if (FD < 0)
 192    {
 193       // Read only .. can't have locking problems there.
 194       if (errno == EROFS)
 195       {
 196          _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
 197          return dup(0);       // Need something for the caller to close
 198       }
 199
 200       if (Errors == true)
 201          _error->Errno("open",_("Could not open lock file %s"),File.c_str());
 202
 203       // Feh.. We do this to distinguish the lock vs open case..
 204       errno = EPERM;
 205       return -1;
 206    }
 207    SetCloseExec(FD,true);
 208
 209    // Acquire a write lock
 210    struct flock fl;
 211    fl.l_type = F_WRLCK;
 212    fl.l_whence = SEEK_SET;
 213    fl.l_start = 0;
 214    fl.l_len = 0;
 215    if (fcntl(FD,F_SETLK,&fl) == -1)
 216    {
 217       // always close to not leak resources
 218       int Tmp = errno;
 219       close(FD);
 220       errno = Tmp;
 221
 222       if (errno == ENOLCK)
 223       {
 224          _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
 225          return dup(0);       // Need something for the caller to close
 226       }
 227
 228       if (Errors == true)
 229          _error->Errno("open",_("Could not get lock %s"),File.c_str());
 230
 231       return -1;
 232    }
 233
 234    return FD;
 235 }
 236                                                                         /*}}}*/
 237 // FileExists - Check if a file exists                                  /*{{{*/
 238 // ---------------------------------------------------------------------
 239 /* Beware: Directories are also files! */
 240 bool FileExists(string File)
 241 {
 242    struct stat Buf;
 243    if (stat(File.c_str(),&Buf) != 0)
 244       return false;
 245    return true;
 246 }
 247                                                                         /*}}}*/
 248 // RealFileExists - Check if a file exists and if it is really a file   /*{{{*/
 249 // ---------------------------------------------------------------------
 250 /* */
 251 bool RealFileExists(string File)
 252 {
 253    struct stat Buf;
 254    if (stat(File.c_str(),&Buf) != 0)
 255       return false;
 256    return ((Buf.st_mode & S_IFREG) != 0);
 257 }
 258                                                                         /*}}}*/
 259 // DirectoryExists - Check if a directory exists and is really one      /*{{{*/
 260 // ---------------------------------------------------------------------
 261 /* */
 262 bool DirectoryExists(string const &Path)
 263 {
 264    struct stat Buf;
 265    if (stat(Path.c_str(),&Buf) != 0)
 266       return false;
 267    return ((Buf.st_mode & S_IFDIR) != 0);
 268 }
 269                                                                         /*}}}*/
 270 // CreateDirectory - poor man's mkdir -p guarded by a parent directory  /*{{{*/
 271 // ---------------------------------------------------------------------
 272 /* This method will create all directories needed for path in good old
 273    mkdir -p style but refuses to do this if Parent is not a prefix of
 274    this Path. Example: /var/cache/ and /var/cache/apt/archives are given,
 275    so it will create apt/archives if /var/cache exists - on the other
 276    hand if the parent is /var/lib the creation will fail as this path
 277    is not a parent of the path to be generated. */
 278 bool CreateDirectory(string const &Parent, string const &Path)
 279 {
 280    if (Parent.empty() == true || Path.empty() == true)
 281       return false;
 282
 283    if (DirectoryExists(Path) == true)
 284       return true;
 285
 286    if (DirectoryExists(Parent) == false)
 287       return false;
 288
 289    // we are not going to create directories "into the blue"
 290    if (Path.compare(0, Parent.length(), Parent) != 0)
 291       return false;
 292
 293    vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');
 294    string progress = Parent;
 295    for (vector<string>::const_iterator d = dirs.begin(); d != dirs.end(); ++d)
 296    {
 297       if (d->empty() == true)
 298          continue;
 299
 300       progress.append("/").append(*d);
 301       if (DirectoryExists(progress) == true)
 302          continue;
 303
 304       if (mkdir(progress.c_str(), 0755) != 0)
 305          return false;
 306    }
 307    return true;
 308 }
 309                                                                         /*}}}*/
 310 // CreateAPTDirectoryIfNeeded - ensure that the given directory exists          /*{{{*/
 311 // ---------------------------------------------------------------------
 312 /* a small wrapper around CreateDirectory to check if it exists and to
 313    remove the trailing "/apt/" from the parent directory if needed */
 314 bool CreateAPTDirectoryIfNeeded(string const &Parent, string const &Path)
 315 {
 316    if (DirectoryExists(Path) == true)
 317       return true;
 318
 319    size_t const len = Parent.size();
 320    if (len > 5 && Parent.find("/apt/", len - 6, 5) == len - 5)
 321    {
 322       if (CreateDirectory(Parent.substr(0,len-5), Path) == true)
 323          return true;
 324    }
 325    else if (CreateDirectory(Parent, Path) == true)
 326       return true;
 327
 328    return false;
 329 }
 330                                                                         /*}}}*/
 331 // GetListOfFilesInDir - returns a vector of files in the given dir     /*{{{*/
 332 // ---------------------------------------------------------------------
 333 /* If an extension is given only files with this extension are included
 334    in the returned vector, otherwise every "normal" file is included. */
 335 std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
 336                                         bool const &SortList, bool const &AllowNoExt)
 337 {
 338    std::vector<string> ext;
 339    ext.reserve(2);
 340    if (Ext.empty() == false)
 341       ext.push_back(Ext);
 342    if (AllowNoExt == true && ext.empty() == false)
 343       ext.push_back("");
 344    return GetListOfFilesInDir(Dir, ext, SortList);
 345 }
 346 std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> const &Ext,
 347                                         bool const &SortList)
 348 {
 349    // Attention debuggers: need to be set with the environment config file!
 350    bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
 351    if (Debug == true)
 352    {
 353       std::clog << "Accept in " << Dir << " only files with the following " << Ext.size() << " extensions:" << std::endl;
 354       if (Ext.empty() == true)
 355          std::clog << "\tNO extension" << std::endl;
 356       else
 357          for (std::vector<string>::const_iterator e = Ext.begin();
 358               e != Ext.end(); ++e)
 359             std::clog << '\t' << (e->empty() == true ? "NO" : *e) << " extension" << std::endl;
 360    }
 361
 362    std::vector<string> List;
 363
 364    if (DirectoryExists(Dir) == false)
 365    {
 366       _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
 367       return List;
 368    }
 369
 370    Configuration::MatchAgainstConfig SilentIgnore("Dir::Ignore-Files-Silently");
 371    DIR *D = opendir(Dir.c_str());
 372    if (D == 0)
 373    {
 374       _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 375       return List;
 376    }
 377
 378    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 379    {
 380       // skip "hidden" files
 381       if (Ent->d_name[0] == '.')
 382          continue;
 383
 384       // Make sure it is a file and not something else
 385       string const File = flCombine(Dir,Ent->d_name);
 386 #ifdef _DIRENT_HAVE_D_TYPE
 387       if (Ent->d_type != DT_REG)
 388 #endif
 389       {
 390          if (RealFileExists(File) == false)
 391          {
 392             // do not show ignoration warnings for directories
 393             if (
 394 #ifdef _DIRENT_HAVE_D_TYPE
 395                 Ent->d_type == DT_DIR ||
 396 #endif
 397                 DirectoryExists(File) == true)
 398                continue;
 399             if (SilentIgnore.Match(Ent->d_name) == false)
 400                _error->Notice(_("Ignoring '%s' in directory '%s' as it is not a regular file"), Ent->d_name, Dir.c_str());
 401             continue;
 402          }
 403       }
 404
 405       // check for accepted extension:
 406       // no extension given -> periods are bad as hell!
 407       // extensions given -> "" extension allows no extension
 408       if (Ext.empty() == false)
 409       {
 410          string d_ext = flExtension(Ent->d_name);
 411          if (d_ext == Ent->d_name) // no extension
 412          {
 413             if (std::find(Ext.begin(), Ext.end(), "") == Ext.end())
 414             {
 415                if (Debug == true)
 416                   std::clog << "Bad file: " << Ent->d_name << " → no extension" << std::endl;
 417                if (SilentIgnore.Match(Ent->d_name) == false)
 418                   _error->Notice(_("Ignoring file '%s' in directory '%s' as it has no filename extension"), Ent->d_name, Dir.c_str());
 419                continue;
 420             }
 421          }
 422          else if (std::find(Ext.begin(), Ext.end(), d_ext) == Ext.end())
 423          {
 424             if (Debug == true)
 425                std::clog << "Bad file: " << Ent->d_name << " → bad extension »" << flExtension(Ent->d_name) << "«" << std::endl;
 426             if (SilentIgnore.Match(Ent->d_name) == false)
 427                _error->Notice(_("Ignoring file '%s' in directory '%s' as it has an invalid filename extension"), Ent->d_name, Dir.c_str());
 428             continue;
 429          }
 430       }
 431
 432       // Skip bad filenames ala run-parts
 433       const char *C = Ent->d_name;
 434       for (; *C != 0; ++C)
 435          if (isalpha(*C) == 0 && isdigit(*C) == 0
 436              && *C != '_' && *C != '-' && *C != ':') {
 437             // no required extension -> dot is a bad character
 438             if (*C == '.' && Ext.empty() == false)
 439                continue;
 440             break;
 441          }
 442
 443       // we don't reach the end of the name -> bad character included
 444       if (*C != 0)
 445       {
 446          if (Debug == true)
 447             std::clog << "Bad file: " << Ent->d_name << " → bad character »"
 448                << *C << "« in filename (period allowed: " << (Ext.empty() ? "no" : "yes") << ")" << std::endl;
 449          continue;
 450       }
 451
 452       // skip filenames which end with a period. These are never valid
 453       if (*(C - 1) == '.')
 454       {
 455          if (Debug == true)
 456             std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
 457          continue;
 458       }
 459
 460       if (Debug == true)
 461          std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
 462       List.push_back(File);
 463    }
 464    closedir(D);
 465
 466    if (SortList == true)
 467       std::sort(List.begin(),List.end());
 468    return List;
 469 }
 470 std::vector<string> GetListOfFilesInDir(string const &Dir, bool SortList)
 471 {
 472    bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
 473    if (Debug == true)
 474       std::clog << "Accept in " << Dir << " all regular files" << std::endl;
 475
 476    std::vector<string> List;
 477
 478    if (DirectoryExists(Dir) == false)
 479    {
 480       _error->Error(_("List of files can't be created as '%s' is not a directory"), Dir.c_str());
 481       return List;
 482    }
 483
 484    DIR *D = opendir(Dir.c_str());
 485    if (D == 0)
 486    {
 487       _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 488       return List;
 489    }
 490
 491    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 492    {
 493       // skip "hidden" files
 494       if (Ent->d_name[0] == '.')
 495          continue;
 496
 497       // Make sure it is a file and not something else
 498       string const File = flCombine(Dir,Ent->d_name);
 499 #ifdef _DIRENT_HAVE_D_TYPE
 500       if (Ent->d_type != DT_REG)
 501 #endif
 502       {
 503          if (RealFileExists(File) == false)
 504          {
 505             if (Debug == true)
 506                std::clog << "Bad file: " << Ent->d_name << " → it is not a real file" << std::endl;
 507             continue;
 508          }
 509       }
 510
 511       // Skip bad filenames ala run-parts
 512       const char *C = Ent->d_name;
 513       for (; *C != 0; ++C)
 514          if (isalpha(*C) == 0 && isdigit(*C) == 0
 515              && *C != '_' && *C != '-' && *C != '.')
 516             break;
 517
 518       // we don't reach the end of the name -> bad character included
 519       if (*C != 0)
 520       {
 521          if (Debug == true)
 522             std::clog << "Bad file: " << Ent->d_name << " → bad character »" << *C << "« in filename" << std::endl;
 523          continue;
 524       }
 525
 526       // skip filenames which end with a period. These are never valid
 527       if (*(C - 1) == '.')
 528       {
 529          if (Debug == true)
 530             std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
 531          continue;
 532       }
 533
 534       if (Debug == true)
 535          std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
 536       List.push_back(File);
 537    }
 538    closedir(D);
 539
 540    if (SortList == true)
 541       std::sort(List.begin(),List.end());
 542    return List;
 543 }
 544                                                                         /*}}}*/
 545 // SafeGetCWD - This is a safer getcwd that returns a dynamic string    /*{{{*/
 546 // ---------------------------------------------------------------------
 547 /* We return / on failure. */
 548 string SafeGetCWD()
 549 {
 550    // Stash the current dir.
 551    char S[300];
 552    S[0] = 0;
 553    if (getcwd(S,sizeof(S)-2) == 0)
 554       return "/";
 555    unsigned int Len = strlen(S);
 556    S[Len] = '/';
 557    S[Len+1] = 0;
 558    return S;
 559 }
 560                                                                         /*}}}*/
 561 // GetModificationTime - Get the mtime of the given file or -1 on error /*{{{*/
 562 // ---------------------------------------------------------------------
 563 /* We return / on failure. */
 564 time_t GetModificationTime(string const &Path)
 565 {
 566    struct stat St;
 567    if (stat(Path.c_str(), &St) < 0)
 568       return -1;
 569    return  St.st_mtime;
 570 }
 571                                                                         /*}}}*/
 572 // flNotDir - Strip the directory from the filename                     /*{{{*/
 573 // ---------------------------------------------------------------------
 574 /* */
 575 string flNotDir(string File)
 576 {
 577    string::size_type Res = File.rfind('/');
 578    if (Res == string::npos)
 579       return File;
 580    Res++;
 581    return string(File,Res,Res - File.length());
 582 }
 583                                                                         /*}}}*/
 584 // flNotFile - Strip the file from the directory name                   /*{{{*/
 585 // ---------------------------------------------------------------------
 586 /* Result ends in a / */
 587 string flNotFile(string File)
 588 {
 589    string::size_type Res = File.rfind('/');
 590    if (Res == string::npos)
 591       return "./";
 592    Res++;
 593    return string(File,0,Res);
 594 }
 595                                                                         /*}}}*/
 596 // flExtension - Return the extension for the file                      /*{{{*/
 597 // ---------------------------------------------------------------------
 598 /* */
 599 string flExtension(string File)
 600 {
 601    string::size_type Res = File.rfind('.');
 602    if (Res == string::npos)
 603       return File;
 604    Res++;
 605    return string(File,Res,Res - File.length());
 606 }
 607                                                                         /*}}}*/
 608 // flNoLink - If file is a symlink then deref it                        /*{{{*/
 609 // ---------------------------------------------------------------------
 610 /* If the name is not a link then the returned path is the input. */
 611 string flNoLink(string File)
 612 {
 613    struct stat St;
 614    if (lstat(File.c_str(),&St) != 0 || S_ISLNK(St.st_mode) == 0)
 615       return File;
 616    if (stat(File.c_str(),&St) != 0)
 617       return File;
 618
 619    /* Loop resolving the link. There is no need to limit the number of
 620       loops because the stat call above ensures that the symlink is not
 621       circular */
 622    char Buffer[1024];
 623    string NFile = File;
 624    while (1)
 625    {
 626       // Read the link
 627       ssize_t Res;
 628       if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 ||
 629           (size_t)Res >= sizeof(Buffer))
 630           return File;
 631
 632       // Append or replace the previous path
 633       Buffer[Res] = 0;
 634       if (Buffer[0] == '/')
 635          NFile = Buffer;
 636       else
 637          NFile = flNotFile(NFile) + Buffer;
 638
 639       // See if we are done
 640       if (lstat(NFile.c_str(),&St) != 0)
 641          return File;
 642       if (S_ISLNK(St.st_mode) == 0)
 643          return NFile;
 644    }
 645 }
 646                                                                         /*}}}*/
 647 // flCombine - Combine a file and a directory                           /*{{{*/
 648 // ---------------------------------------------------------------------
 649 /* If the file is an absolute path then it is just returned, otherwise
 650    the directory is pre-pended to it. */
 651 string flCombine(string Dir,string File)
 652 {
 653    if (File.empty() == true)
 654       return string();
 655
 656    if (File[0] == '/' || Dir.empty() == true)
 657       return File;
 658    if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
 659       return File;
 660    if (Dir[Dir.length()-1] == '/')
 661       return Dir + File;
 662    return Dir + '/' + File;
 663 }
 664                                                                         /*}}}*/
 665 // flAbsPath - Return the absolute path of the filename                 /*{{{*/
 666 // ---------------------------------------------------------------------
 667 /* */
 668 string flAbsPath(string File)
 669 {
 670    char *p = realpath(File.c_str(), NULL);
 671    if (p == NULL)
 672    {
 673       _error->Errno("realpath", "flAbsPath failed");
 674       return "";
 675    }
 676    std::string AbsPath(p);
 677    free(p);
 678    return AbsPath;
 679 }
 680                                                                         /*}}}*/
 681 // SetCloseExec - Set the close on exec flag                            /*{{{*/
 682 // ---------------------------------------------------------------------
 683 /* */
 684 void SetCloseExec(int Fd,bool Close)
 685 {
 686    if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
 687    {
 688       cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
 689       exit(100);
 690    }
 691 }
 692                                                                         /*}}}*/
 693 // SetNonBlock - Set the nonblocking flag                               /*{{{*/
 694 // ---------------------------------------------------------------------
 695 /* */
 696 void SetNonBlock(int Fd,bool Block)
 697 {
 698    int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
 699    if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
 700    {
 701       cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
 702       exit(100);
 703    }
 704 }
 705                                                                         /*}}}*/
 706 // WaitFd - Wait for a FD to become readable                            /*{{{*/
 707 // ---------------------------------------------------------------------
 708 /* This waits for a FD to become readable using select. It is useful for
 709    applications making use of non-blocking sockets. The timeout is
 710    in seconds. */
 711 bool WaitFd(int Fd,bool write,unsigned long timeout)
 712 {
 713    fd_set Set;
 714    struct timeval tv;
 715    FD_ZERO(&Set);
 716    FD_SET(Fd,&Set);
 717    tv.tv_sec = timeout;
 718    tv.tv_usec = 0;
 719    if (write == true)
 720    {
 721       int Res;
 722       do
 723       {
 724          Res = select(Fd+1,0,&Set,0,(timeout != 0?&tv:0));
 725       }
 726       while (Res < 0 && errno == EINTR);
 727
 728       if (Res <= 0)
 729          return false;
 730    }
 731    else
 732    {
 733       int Res;
 734       do
 735       {
 736          Res = select(Fd+1,&Set,0,0,(timeout != 0?&tv:0));
 737       }
 738       while (Res < 0 && errno == EINTR);
 739
 740       if (Res <= 0)
 741          return false;
 742    }
 743
 744    return true;
 745 }
 746                                                                         /*}}}*/
 747 // MergeKeepFdsFromConfiguration - Merge APT::Keep-Fds configuration    /*{{{*/
 748 // ---------------------------------------------------------------------
 749 /* This is used to merge the APT::Keep-Fds with the provided KeepFDs
 750  * set.
 751  */
 752 void MergeKeepFdsFromConfiguration(std::set<int> &KeepFDs)
 753 {
 754       Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
 755       if (Opts != 0 && Opts->Child != 0)
 756       {
 757          Opts = Opts->Child;
 758          for (; Opts != 0; Opts = Opts->Next)
 759          {
 760             if (Opts->Value.empty() == true)
 761                continue;
 762             int fd = atoi(Opts->Value.c_str());
 763             KeepFDs.insert(fd);
 764          }
 765       }
 766 }
 767                                                                         /*}}}*/
 768 // ExecFork - Magical fork that sanitizes the context before execing    /*{{{*/
 769 // ---------------------------------------------------------------------
 770 /* This is used if you want to cleanse the environment for the forked
 771    child, it fixes up the important signals and nukes all of the fds,
 772    otherwise acts like normal fork. */
 773 pid_t ExecFork()
 774 {
 775       set<int> KeepFDs;
 776       // we need to merge the Keep-Fds as external tools like
 777       // debconf-apt-progress use it
 778       MergeKeepFdsFromConfiguration(KeepFDs);
 779       return ExecFork(KeepFDs);
 780 }
 781
 782 pid_t ExecFork(std::set<int> KeepFDs)
 783 {
 784    // Fork off the process
 785    pid_t Process = fork();
 786    if (Process < 0)
 787    {
 788       cerr << "FATAL -> Failed to fork." << endl;
 789       exit(100);
 790    }
 791
 792    // Spawn the subprocess
 793    if (Process == 0)
 794    {
 795       // Setup the signals
 796       signal(SIGPIPE,SIG_DFL);
 797       signal(SIGQUIT,SIG_DFL);
 798       signal(SIGINT,SIG_DFL);
 799       signal(SIGWINCH,SIG_DFL);
 800       signal(SIGCONT,SIG_DFL);
 801       signal(SIGTSTP,SIG_DFL);
 802
 803       // Close all of our FDs - just in case
 804       for (int K = 3; K != sysconf(_SC_OPEN_MAX); K++)
 805       {
 806          if(KeepFDs.find(K) == KeepFDs.end())
 807             fcntl(K,F_SETFD,FD_CLOEXEC);
 808       }
 809    }
 810
 811    return Process;
 812 }
 813                                                                         /*}}}*/
 814 // ExecWait - Fancy waitpid                                             /*{{{*/
 815 // ---------------------------------------------------------------------
 816 /* Waits for the given sub process. If Reap is set then no errors are
 817    generated. Otherwise a failed subprocess will generate a proper descriptive
 818    message */
 819 bool ExecWait(pid_t Pid,const char *Name,bool Reap)
 820 {
 821    if (Pid <= 1)
 822       return true;
 823
 824    // Wait and collect the error code
 825    int Status;
 826    while (waitpid(Pid,&Status,0) != Pid)
 827    {
 828       if (errno == EINTR)
 829          continue;
 830
 831       if (Reap == true)
 832          return false;
 833
 834       return _error->Error(_("Waited for %s but it wasn't there"),Name);
 835    }
 836
 837
 838    // Check for an error code.
 839    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 840    {
 841       if (Reap == true)
 842          return false;
 843       if (WIFSIGNALED(Status) != 0)
 844       {
 845          if( WTERMSIG(Status) == SIGSEGV)
 846             return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
 847          else
 848             return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));
 849       }
 850
 851       if (WIFEXITED(Status) != 0)
 852          return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
 853
 854       return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
 855    }
 856
 857    return true;
 858 }
 859                                                                         /*}}}*/
 860
 861
 862 // StartsWithGPGClearTextSignature - Check if a file is Pgp/GPG clearsigned     /*{{{*/
 863 // ---------------------------------------------------------------------
 864 /* */
 865 bool StartsWithGPGClearTextSignature(string const &FileName)
 866 {
 867    static const char* SIGMSG = "-----BEGIN PGP SIGNED MESSAGE-----\n";
 868    char buffer[strlen(SIGMSG)+1];
 869    FILE* gpg = fopen(FileName.c_str(), "r");
 870    if (gpg == NULL)
 871       return false;
 872
 873    char const * const test = fgets(buffer, sizeof(buffer), gpg);
 874    fclose(gpg);
 875    if (test == NULL || strcmp(buffer, SIGMSG) != 0)
 876       return false;
 877
 878    return true;
 879 }
 880
 881
 882 class FileFdPrivate {                                                   /*{{{*/
 883         public:
 884 #ifdef HAVE_ZLIB
 885         gzFile gz;
 886 #endif
 887 #ifdef HAVE_BZ2
 888         BZFILE* bz2;
 889 #endif
 890 #ifdef HAVE_LZMA
 891         struct LZMAFILE {
 892            FILE* file;
 893            uint8_t buffer[4096];
 894            lzma_stream stream;
 895            lzma_ret err;
 896            bool eof;
 897            bool compressing;
 898
 899            LZMAFILE() : file(NULL), eof(false), compressing(false) {}
 900            ~LZMAFILE() {
 901               if (compressing == true)
 902               {
 903                 for (;;) {
 904                         stream.avail_out = sizeof(buffer)/sizeof(buffer[0]);
 905                         stream.next_out = buffer;
 906                         err = lzma_code(&stream, LZMA_FINISH);
 907                         if (err != LZMA_OK && err != LZMA_STREAM_END)
 908                         {
 909                                 _error->Error("~LZMAFILE: Compress finalisation failed");
 910                                 break;
 911                         }
 912                         size_t const n =  sizeof(buffer)/sizeof(buffer[0]) - stream.avail_out;
 913                         if (n && fwrite(buffer, 1, n, file) != n)
 914                         {
 915                                 _error->Errno("~LZMAFILE",_("Write error"));
 916                                 break;
 917                         }
 918                         if (err == LZMA_STREAM_END)
 919                                 break;
 920                 }
 921               }
 922               lzma_end(&stream);
 923               fclose(file);
 924            }
 925         };
 926         LZMAFILE* lzma;
 927 #endif
 928         int compressed_fd;
 929         pid_t compressor_pid;
 930         bool pipe;
 931         APT::Configuration::Compressor compressor;
 932         unsigned int openmode;
 933         unsigned long long seekpos;
 934         FileFdPrivate() :
 935 #ifdef HAVE_ZLIB
 936                           gz(NULL),
 937 #endif
 938 #ifdef HAVE_BZ2
 939                           bz2(NULL),
 940 #endif
 941 #ifdef HAVE_LZMA
 942                           lzma(NULL),
 943 #endif
 944                           compressed_fd(-1), compressor_pid(-1), pipe(false),
 945                           openmode(0), seekpos(0) {};
 946         bool InternalClose(std::string const &FileName)
 947         {
 948            if (false)
 949               /* dummy so that the rest can be 'else if's */;
 950 #ifdef HAVE_ZLIB
 951            else if (gz != NULL) {
 952               int const e = gzclose(gz);
 953               gz = NULL;
 954               // gzdclose() on empty files always fails with "buffer error" here, ignore that
 955               if (e != 0 && e != Z_BUF_ERROR)
 956                  return _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
 957            }
 958 #endif
 959 #ifdef HAVE_BZ2
 960            else if (bz2 != NULL) {
 961               BZ2_bzclose(bz2);
 962               bz2 = NULL;
 963            }
 964 #endif
 965 #ifdef HAVE_LZMA
 966            else if (lzma != NULL) {
 967               delete lzma;
 968               lzma = NULL;
 969            }
 970 #endif
 971            return true;
 972         }
 973         bool CloseDown(std::string const &FileName)
 974         {
 975            bool const Res = InternalClose(FileName);
 976
 977            if (compressor_pid > 0)
 978               ExecWait(compressor_pid, "FileFdCompressor", true);
 979            compressor_pid = -1;
 980
 981            return Res;
 982         }
 983         bool InternalStream() const {
 984            return false
 985 #ifdef HAVE_BZ2
 986               || bz2 != NULL
 987 #endif
 988 #ifdef HAVE_LZMA
 989               || lzma != NULL
 990 #endif
 991               ;
 992         }
 993
 994
 995         ~FileFdPrivate() { CloseDown(""); }
 996 };
 997                                                                         /*}}}*/
 998 // FileFd::Open - Open a file                                           /*{{{*/
 999 // ---------------------------------------------------------------------
1000 /* The most commonly used open mode combinations are given with Mode */
1001 bool FileFd::Open(string FileName,unsigned int const Mode,CompressMode Compress, unsigned long const AccessMode)
1002 {
1003    if (Mode == ReadOnlyGzip)
1004       return Open(FileName, ReadOnly, Gzip, AccessMode);
1005
1006    if (Compress == Auto && (Mode & WriteOnly) == WriteOnly)
1007       return FileFdError("Autodetection on %s only works in ReadOnly openmode!", FileName.c_str());
1008
1009    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
1010    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
1011    if (Compress == Auto)
1012    {
1013       for (; compressor != compressors.end(); ++compressor)
1014       {
1015          std::string file = FileName + compressor->Extension;
1016          if (FileExists(file) == false)
1017             continue;
1018          FileName = file;
1019          break;
1020       }
1021    }
1022    else if (Compress == Extension)
1023    {
1024       std::string::size_type const found = FileName.find_last_of('.');
1025       std::string ext;
1026       if (found != std::string::npos)
1027       {
1028          ext = FileName.substr(found);
1029          if (ext == ".new" || ext == ".bak")
1030          {
1031             std::string::size_type const found2 = FileName.find_last_of('.', found - 1);
1032             if (found2 != std::string::npos)
1033                ext = FileName.substr(found2, found - found2);
1034             else
1035                ext.clear();
1036          }
1037       }
1038       for (; compressor != compressors.end(); ++compressor)
1039          if (ext == compressor->Extension)
1040             break;
1041       // no matching extension - assume uncompressed (imagine files like 'example.org_Packages')
1042       if (compressor == compressors.end())
1043          for (compressor = compressors.begin(); compressor != compressors.end(); ++compressor)
1044             if (compressor->Name == ".")
1045                break;
1046    }
1047    else
1048    {
1049       std::string name;
1050       switch (Compress)
1051       {
1052       case None: name = "."; break;
1053       case Gzip: name = "gzip"; break;
1054       case Bzip2: name = "bzip2"; break;
1055       case Lzma: name = "lzma"; break;
1056       case Xz: name = "xz"; break;
1057       case Auto:
1058       case Extension:
1059          // Unreachable
1060          return FileFdError("Opening File %s in None, Auto or Extension should be already handled?!?", FileName.c_str());
1061       }
1062       for (; compressor != compressors.end(); ++compressor)
1063          if (compressor->Name == name)
1064             break;
1065       if (compressor == compressors.end())
1066          return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
1067    }
1068
1069    if (compressor == compressors.end())
1070       return FileFdError("Can't find a match for specified compressor mode for file %s", FileName.c_str());
1071    return Open(FileName, Mode, *compressor, AccessMode);
1072 }
1073 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const AccessMode)
1074 {
1075    Close();
1076    Flags = AutoClose;
1077
1078    if ((Mode & WriteOnly) != WriteOnly && (Mode & (Atomic | Create | Empty | Exclusive)) != 0)
1079       return FileFdError("ReadOnly mode for %s doesn't accept additional flags!", FileName.c_str());
1080    if ((Mode & ReadWrite) == 0)
1081       return FileFdError("No openmode provided in FileFd::Open for %s", FileName.c_str());
1082
1083    if ((Mode & Atomic) == Atomic)
1084    {
1085       Flags |= Replace;
1086    }
1087    else if ((Mode & (Exclusive | Create)) == (Exclusive | Create))
1088    {
1089       // for atomic, this will be done by rename in Close()
1090       unlink(FileName.c_str());
1091    }
1092    if ((Mode & Empty) == Empty)
1093    {
1094       struct stat Buf;
1095       if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
1096          unlink(FileName.c_str());
1097    }
1098
1099    int fileflags = 0;
1100    #define if_FLAGGED_SET(FLAG, MODE) if ((Mode & FLAG) == FLAG) fileflags |= MODE
1101    if_FLAGGED_SET(ReadWrite, O_RDWR);
1102    else if_FLAGGED_SET(ReadOnly, O_RDONLY);
1103    else if_FLAGGED_SET(WriteOnly, O_WRONLY);
1104
1105    if_FLAGGED_SET(Create, O_CREAT);
1106    if_FLAGGED_SET(Empty, O_TRUNC);
1107    if_FLAGGED_SET(Exclusive, O_EXCL);
1108    #undef if_FLAGGED_SET
1109
1110    if ((Mode & Atomic) == Atomic)
1111    {
1112       char *name = strdup((FileName + ".XXXXXX").c_str());
1113
1114       if((iFd = mkstemp(name)) == -1)
1115       {
1116           free(name);
1117           return FileFdErrno("mkstemp", "Could not create temporary file for %s", FileName.c_str());
1118       }
1119
1120       TemporaryFileName = string(name);
1121       free(name);
1122
1123       // umask() will always set the umask and return the previous value, so
1124       // we first set the umask and then reset it to the old value
1125       mode_t const CurrentUmask = umask(0);
1126       umask(CurrentUmask);
1127       // calculate the actual file permissions (just like open/creat)
1128       mode_t const FilePermissions = (AccessMode & ~CurrentUmask);
1129
1130       if(fchmod(iFd, FilePermissions) == -1)
1131           return FileFdErrno("fchmod", "Could not change permissions for temporary file %s", TemporaryFileName.c_str());
1132    }
1133    else
1134       iFd = open(FileName.c_str(), fileflags, AccessMode);
1135
1136    this->FileName = FileName;
1137    if (iFd == -1 || OpenInternDescriptor(Mode, compressor) == false)
1138    {
1139       if (iFd != -1)
1140       {
1141          close (iFd);
1142          iFd = -1;
1143       }
1144       return FileFdErrno("open",_("Could not open file %s"), FileName.c_str());
1145    }
1146
1147    SetCloseExec(iFd,true);
1148    return true;
1149 }
1150                                                                         /*}}}*/
1151 // FileFd::OpenDescriptor - Open a filedescriptor                       /*{{{*/
1152 // ---------------------------------------------------------------------
1153 /* */
1154 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose)
1155 {
1156    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
1157    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
1158    std::string name;
1159
1160    // compat with the old API
1161    if (Mode == ReadOnlyGzip && Compress == None)
1162       Compress = Gzip;
1163
1164    switch (Compress)
1165    {
1166    case None: name = "."; break;
1167    case Gzip: name = "gzip"; break;
1168    case Bzip2: name = "bzip2"; break;
1169    case Lzma: name = "lzma"; break;
1170    case Xz: name = "xz"; break;
1171    case Auto:
1172    case Extension:
1173       if (AutoClose == true && Fd != -1)
1174          close(Fd);
1175       return FileFdError("Opening Fd %d in Auto or Extension compression mode is not supported", Fd);
1176    }
1177    for (; compressor != compressors.end(); ++compressor)
1178       if (compressor->Name == name)
1179          break;
1180    if (compressor == compressors.end())
1181    {
1182       if (AutoClose == true && Fd != -1)
1183          close(Fd);
1184       return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
1185    }
1186    return OpenDescriptor(Fd, Mode, *compressor, AutoClose);
1187 }
1188 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
1189 {
1190    Close();
1191    Flags = (AutoClose) ? FileFd::AutoClose : 0;
1192    iFd = Fd;
1193    this->FileName = "";
1194    if (OpenInternDescriptor(Mode, compressor) == false)
1195    {
1196       if (iFd != -1 && (
1197         (Flags & Compressed) == Compressed ||
1198         AutoClose == true))
1199       {
1200          close (iFd);
1201          iFd = -1;
1202       }
1203       return FileFdError(_("Could not open file descriptor %d"), Fd);
1204    }
1205    return true;
1206 }
1207 bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor)
1208 {
1209    if (iFd == -1)
1210       return false;
1211    if (compressor.Name == "." || compressor.Binary.empty() == true)
1212       return true;
1213
1214 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1215    // the API to open files is similar, so setup to avoid code duplicates later
1216    // and while at it ensure that we close before opening (if its a reopen)
1217    void* (*compress_open)(int, const char *) = NULL;
1218    if (false)
1219       /* dummy so that the rest can be 'else if's */;
1220 #define APT_COMPRESS_INIT(NAME,OPEN) \
1221    else if (compressor.Name == NAME) \
1222    { \
1223       compress_open = (void*(*)(int, const char *)) OPEN; \
1224       if (d != NULL) d->InternalClose(FileName); \
1225    }
1226 #ifdef HAVE_ZLIB
1227    APT_COMPRESS_INIT("gzip", gzdopen)
1228 #endif
1229 #ifdef HAVE_BZ2
1230    APT_COMPRESS_INIT("bzip2", BZ2_bzdopen)
1231 #endif
1232 #ifdef HAVE_LZMA
1233    APT_COMPRESS_INIT("xz", fdopen)
1234    APT_COMPRESS_INIT("lzma", fdopen)
1235 #endif
1236 #undef APT_COMPRESS_INIT
1237 #endif
1238
1239    if (d == NULL)
1240    {
1241       d = new FileFdPrivate();
1242       d->openmode = Mode;
1243       d->compressor = compressor;
1244 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1245       if ((Flags & AutoClose) != AutoClose && compress_open != NULL)
1246       {
1247          // Need to duplicate fd here or gz/bz2 close for cleanup will close the fd as well
1248          int const internFd = dup(iFd);
1249          if (internFd == -1)
1250             return FileFdErrno("OpenInternDescriptor", _("Could not open file descriptor %d"), iFd);
1251          iFd = internFd;
1252       }
1253 #endif
1254    }
1255
1256 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1257    if (compress_open != NULL)
1258    {
1259       void* compress_struct = NULL;
1260       if ((Mode & ReadWrite) == ReadWrite)
1261          compress_struct = compress_open(iFd, "r+");
1262       else if ((Mode & WriteOnly) == WriteOnly)
1263          compress_struct = compress_open(iFd, "w");
1264       else
1265          compress_struct = compress_open(iFd, "r");
1266       if (compress_struct == NULL)
1267          return false;
1268
1269       if (false)
1270          /* dummy so that the rest can be 'else if's */;
1271 #ifdef HAVE_ZLIB
1272       else if (compressor.Name == "gzip")
1273          d->gz = (gzFile) compress_struct;
1274 #endif
1275 #ifdef HAVE_BZ2
1276       else if (compressor.Name == "bzip2")
1277          d->bz2 = (BZFILE*) compress_struct;
1278 #endif
1279 #ifdef HAVE_LZMA
1280       else if (compressor.Name == "xz" || compressor.Name == "lzma")
1281       {
1282          uint32_t const xzlevel = 6;
1283          uint64_t const memlimit = UINT64_MAX;
1284          if (d->lzma == NULL)
1285             d->lzma = new FileFdPrivate::LZMAFILE;
1286          d->lzma->file = (FILE*) compress_struct;
1287          lzma_stream tmp_stream = LZMA_STREAM_INIT;
1288          d->lzma->stream = tmp_stream;
1289
1290          if ((Mode & ReadWrite) == ReadWrite)
1291             return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());
1292
1293          if ((Mode & WriteOnly) == WriteOnly)
1294          {
1295             if (compressor.Name == "xz")
1296             {
1297                if (lzma_easy_encoder(&d->lzma->stream, xzlevel, LZMA_CHECK_CRC32) != LZMA_OK)
1298                   return false;
1299             }
1300             else
1301             {
1302                lzma_options_lzma options;
1303                lzma_lzma_preset(&options, xzlevel);
1304                if (lzma_alone_encoder(&d->lzma->stream, &options) != LZMA_OK)
1305                   return false;
1306             }
1307             d->lzma->compressing = true;
1308          }
1309          else
1310          {
1311             if (compressor.Name == "xz")
1312             {
1313                if (lzma_auto_decoder(&d->lzma->stream, memlimit, 0) != LZMA_OK)
1314                   return false;
1315             }
1316             else
1317             {
1318                if (lzma_alone_decoder(&d->lzma->stream, memlimit) != LZMA_OK)
1319                   return false;
1320             }
1321             d->lzma->compressing = false;
1322          }
1323       }
1324 #endif
1325       Flags |= Compressed;
1326       return true;
1327    }
1328 #endif
1329
1330    // collect zombies here in case we reopen
1331    if (d->compressor_pid > 0)
1332       ExecWait(d->compressor_pid, "FileFdCompressor", true);
1333
1334    if ((Mode & ReadWrite) == ReadWrite)
1335       return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());
1336
1337    bool const Comp = (Mode & WriteOnly) == WriteOnly;
1338    if (Comp == false)
1339    {
1340       // Handle 'decompression' of empty files
1341       struct stat Buf;
1342       fstat(iFd, &Buf);
1343       if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
1344          return true;
1345
1346       // We don't need the file open - instead let the compressor open it
1347       // as he properly knows better how to efficiently read from 'his' file
1348       if (FileName.empty() == false)
1349       {
1350          close(iFd);
1351          iFd = -1;
1352       }
1353    }
1354
1355    // Create a data pipe
1356    int Pipe[2] = {-1,-1};
1357    if (pipe(Pipe) != 0)
1358       return FileFdErrno("pipe",_("Failed to create subprocess IPC"));
1359    for (int J = 0; J != 2; J++)
1360       SetCloseExec(Pipe[J],true);
1361
1362    d->compressed_fd = iFd;
1363    d->pipe = true;
1364
1365    if (Comp == true)
1366       iFd = Pipe[1];
1367    else
1368       iFd = Pipe[0];
1369
1370    // The child..
1371    d->compressor_pid = ExecFork();
1372    if (d->compressor_pid == 0)
1373    {
1374       if (Comp == true)
1375       {
1376          dup2(d->compressed_fd,STDOUT_FILENO);
1377          dup2(Pipe[0],STDIN_FILENO);
1378       }
1379       else
1380       {
1381          if (d->compressed_fd != -1)
1382             dup2(d->compressed_fd,STDIN_FILENO);
1383          dup2(Pipe[1],STDOUT_FILENO);
1384       }
1385       int const nullfd = open("/dev/null", O_WRONLY);
1386       if (nullfd != -1)
1387       {
1388          dup2(nullfd,STDERR_FILENO);
1389          close(nullfd);
1390       }
1391
1392       SetCloseExec(STDOUT_FILENO,false);
1393       SetCloseExec(STDIN_FILENO,false);
1394
1395       std::vector<char const*> Args;
1396       Args.push_back(compressor.Binary.c_str());
1397       std::vector<std::string> const * const addArgs =
1398                 (Comp == true) ? &(compressor.CompressArgs) : &(compressor.UncompressArgs);
1399       for (std::vector<std::string>::const_iterator a = addArgs->begin();
1400            a != addArgs->end(); ++a)
1401          Args.push_back(a->c_str());
1402       if (Comp == false && FileName.empty() == false)
1403       {
1404          // commands not needing arguments, do not need to be told about using standard output
1405          // in reality, only testcases with tools like cat, rev, rot13, … are able to trigger this
1406          if (compressor.CompressArgs.empty() == false && compressor.UncompressArgs.empty() == false)
1407             Args.push_back("--stdout");
1408          if (TemporaryFileName.empty() == false)
1409             Args.push_back(TemporaryFileName.c_str());
1410          else
1411             Args.push_back(FileName.c_str());
1412       }
1413       Args.push_back(NULL);
1414
1415       execvp(Args[0],(char **)&Args[0]);
1416       cerr << _("Failed to exec compressor ") << Args[0] << endl;
1417       _exit(100);
1418    }
1419    if (Comp == true)
1420       close(Pipe[0]);
1421    else
1422       close(Pipe[1]);
1423
1424    return true;
1425 }
1426                                                                         /*}}}*/
1427 // FileFd::~File - Closes the file                                      /*{{{*/
1428 // ---------------------------------------------------------------------
1429 /* If the proper modes are selected then we close the Fd and possibly
1430    unlink the file on error. */
1431 FileFd::~FileFd()
1432 {
1433    Close();
1434    if (d != NULL)
1435       d->CloseDown(FileName);
1436    delete d;
1437    d = NULL;
1438 }
1439                                                                         /*}}}*/
1440 // FileFd::Read - Read a bit of the file                                /*{{{*/
1441 // ---------------------------------------------------------------------
1442 /* We are careful to handle interruption by a signal while reading
1443    gracefully. */
1444 bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
1445 {
1446    ssize_t Res;
1447    errno = 0;
1448    if (Actual != 0)
1449       *Actual = 0;
1450    *((char *)To) = '\0';
1451    do
1452    {
1453       if (false)
1454          /* dummy so that the rest can be 'else if's */;
1455 #ifdef HAVE_ZLIB
1456       else if (d != NULL && d->gz != NULL)
1457          Res = gzread(d->gz,To,Size);
1458 #endif
1459 #ifdef HAVE_BZ2
1460       else if (d != NULL && d->bz2 != NULL)
1461          Res = BZ2_bzread(d->bz2,To,Size);
1462 #endif
1463 #ifdef HAVE_LZMA
1464       else if (d != NULL && d->lzma != NULL)
1465       {
1466          if (d->lzma->eof == true)
1467             break;
1468
1469          d->lzma->stream.next_out = (uint8_t *) To;
1470          d->lzma->stream.avail_out = Size;
1471          if (d->lzma->stream.avail_in == 0)
1472          {
1473             d->lzma->stream.next_in = d->lzma->buffer;
1474             d->lzma->stream.avail_in = fread(d->lzma->buffer, 1, sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]), d->lzma->file);
1475          }
1476          d->lzma->err = lzma_code(&d->lzma->stream, LZMA_RUN);
1477          if (d->lzma->err == LZMA_STREAM_END)
1478          {
1479             d->lzma->eof = true;
1480             Res = Size - d->lzma->stream.avail_out;
1481          }
1482          else if (d->lzma->err != LZMA_OK)
1483          {
1484             Res = -1;
1485             errno = 0;
1486          }
1487          else
1488          {
1489             Res = Size - d->lzma->stream.avail_out;
1490             if (Res == 0)
1491             {
1492                // lzma run was okay, but produced no output…
1493                Res = -1;
1494                errno = EINTR;
1495             }
1496          }
1497       }
1498 #endif
1499       else
1500          Res = read(iFd,To,Size);
1501
1502       if (Res < 0)
1503       {
1504          if (errno == EINTR)
1505          {
1506             // trick the while-loop into running again
1507             Res = 1;
1508             errno = 0;
1509             continue;
1510          }
1511          if (false)
1512             /* dummy so that the rest can be 'else if's */;
1513 #ifdef HAVE_ZLIB
1514          else if (d != NULL && d->gz != NULL)
1515          {
1516             int err;
1517             char const * const errmsg = gzerror(d->gz, &err);
1518             if (err != Z_ERRNO)
1519                return FileFdError("gzread: %s (%d: %s)", _("Read error"), err, errmsg);
1520          }
1521 #endif
1522 #ifdef HAVE_BZ2
1523          else if (d != NULL && d->bz2 != NULL)
1524          {
1525             int err;
1526             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1527             if (err != BZ_IO_ERROR)
1528                return FileFdError("BZ2_bzread: %s (%d: %s)", _("Read error"), err, errmsg);
1529          }
1530 #endif
1531 #ifdef HAVE_LZMA
1532          else if (d != NULL && d->lzma != NULL)
1533             return FileFdError("lzma_read: %s (%d)", _("Read error"), d->lzma->err);
1534 #endif
1535          return FileFdErrno("read",_("Read error"));
1536       }
1537
1538       To = (char *)To + Res;
1539       Size -= Res;
1540       if (d != NULL)
1541          d->seekpos += Res;
1542       if (Actual != 0)
1543          *Actual += Res;
1544    }
1545    while (Res > 0 && Size > 0);
1546
1547    if (Size == 0)
1548       return true;
1549
1550    // Eof handling
1551    if (Actual != 0)
1552    {
1553       Flags |= HitEof;
1554       return true;
1555    }
1556
1557    return FileFdError(_("read, still have %llu to read but none left"), Size);
1558 }
1559                                                                         /*}}}*/
1560 // FileFd::ReadLine - Read a complete line from the file                /*{{{*/
1561 // ---------------------------------------------------------------------
1562 /* Beware: This method can be quiet slow for big buffers on UNcompressed
1563    files because of the naive implementation! */
1564 char* FileFd::ReadLine(char *To, unsigned long long const Size)
1565 {
1566    *To = '\0';
1567 #ifdef HAVE_ZLIB
1568    if (d != NULL && d->gz != NULL)
1569       return gzgets(d->gz, To, Size);
1570 #endif
1571
1572    unsigned long long read = 0;
1573    while ((Size - 1) != read)
1574    {
1575       unsigned long long done = 0;
1576       if (Read(To + read, 1, &done) == false)
1577          return NULL;
1578       if (done == 0)
1579          break;
1580       if (To[read++] == '\n')
1581          break;
1582    }
1583    if (read == 0)
1584       return NULL;
1585    To[read] = '\0';
1586    return To;
1587 }
1588                                                                         /*}}}*/
1589 // FileFd::Write - Write to the file                                    /*{{{*/
1590 // ---------------------------------------------------------------------
1591 /* */
1592 bool FileFd::Write(const void *From,unsigned long long Size)
1593 {
1594    ssize_t Res;
1595    errno = 0;
1596    do
1597    {
1598       if (false)
1599          /* dummy so that the rest can be 'else if's */;
1600 #ifdef HAVE_ZLIB
1601       else if (d != NULL && d->gz != NULL)
1602          Res = gzwrite(d->gz,From,Size);
1603 #endif
1604 #ifdef HAVE_BZ2
1605       else if (d != NULL && d->bz2 != NULL)
1606          Res = BZ2_bzwrite(d->bz2,(void*)From,Size);
1607 #endif
1608 #ifdef HAVE_LZMA
1609       else if (d != NULL && d->lzma != NULL)
1610       {
1611          d->lzma->stream.next_in = (uint8_t *)From;
1612          d->lzma->stream.avail_in = Size;
1613          d->lzma->stream.next_out = d->lzma->buffer;
1614          d->lzma->stream.avail_out = sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]);
1615          d->lzma->err = lzma_code(&d->lzma->stream, LZMA_RUN);
1616          if (d->lzma->err != LZMA_OK)
1617             return false;
1618          size_t const n = sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]) - d->lzma->stream.avail_out;
1619          size_t const m = (n == 0) ? 0 : fwrite(d->lzma->buffer, 1, n, d->lzma->file);
1620          if (m != n)
1621             Res = -1;
1622          else
1623             Res = Size - d->lzma->stream.avail_in;
1624       }
1625 #endif
1626       else
1627          Res = write(iFd,From,Size);
1628
1629       if (Res < 0 && errno == EINTR)
1630          continue;
1631       if (Res < 0)
1632       {
1633          if (false)
1634             /* dummy so that the rest can be 'else if's */;
1635 #ifdef HAVE_ZLIB
1636          else if (d != NULL && d->gz != NULL)
1637          {
1638             int err;
1639             char const * const errmsg = gzerror(d->gz, &err);
1640             if (err != Z_ERRNO)
1641                return FileFdError("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1642          }
1643 #endif
1644 #ifdef HAVE_BZ2
1645          else if (d != NULL && d->bz2 != NULL)
1646          {
1647             int err;
1648             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1649             if (err != BZ_IO_ERROR)
1650                return FileFdError("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1651          }
1652 #endif
1653 #ifdef HAVE_LZMA
1654          else if (d != NULL && d->lzma != NULL)
1655             return FileFdErrno("lzma_fwrite", _("Write error"));
1656 #endif
1657          return FileFdErrno("write",_("Write error"));
1658       }
1659
1660       From = (char const *)From + Res;
1661       Size -= Res;
1662       if (d != NULL)
1663          d->seekpos += Res;
1664    }
1665    while (Res > 0 && Size > 0);
1666
1667    if (Size == 0)
1668       return true;
1669
1670    return FileFdError(_("write, still have %llu to write but couldn't"), Size);
1671 }
1672 bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
1673 {
1674    ssize_t Res;
1675    errno = 0;
1676    do
1677    {
1678       Res = write(Fd,From,Size);
1679       if (Res < 0 && errno == EINTR)
1680          continue;
1681       if (Res < 0)
1682          return _error->Errno("write",_("Write error"));
1683
1684       From = (char const *)From + Res;
1685       Size -= Res;
1686    }
1687    while (Res > 0 && Size > 0);
1688
1689    if (Size == 0)
1690       return true;
1691
1692    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
1693 }
1694                                                                         /*}}}*/
1695 // FileFd::Seek - Seek in the file                                      /*{{{*/
1696 // ---------------------------------------------------------------------
1697 /* */
1698 bool FileFd::Seek(unsigned long long To)
1699 {
1700    Flags &= ~HitEof;
1701
1702    if (d != NULL && (d->pipe == true || d->InternalStream() == true))
1703    {
1704       // Our poor man seeking in pipes is costly, so try to avoid it
1705       unsigned long long seekpos = Tell();
1706       if (seekpos == To)
1707          return true;
1708       else if (seekpos < To)
1709          return Skip(To - seekpos);
1710
1711       if ((d->openmode & ReadOnly) != ReadOnly)
1712          return FileFdError("Reopen is only implemented for read-only files!");
1713       d->InternalClose(FileName);
1714       if (iFd != -1)
1715          close(iFd);
1716       iFd = -1;
1717       if (TemporaryFileName.empty() == false)
1718          iFd = open(TemporaryFileName.c_str(), O_RDONLY);
1719       else if (FileName.empty() == false)
1720          iFd = open(FileName.c_str(), O_RDONLY);
1721       else
1722       {
1723          if (d->compressed_fd > 0)
1724             if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
1725                iFd = d->compressed_fd;
1726          if (iFd < 0)
1727             return FileFdError("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");
1728       }
1729
1730       if (OpenInternDescriptor(d->openmode, d->compressor) == false)
1731          return FileFdError("Seek on file %s because it couldn't be reopened", FileName.c_str());
1732
1733       if (To != 0)
1734          return Skip(To);
1735
1736       d->seekpos = To;
1737       return true;
1738    }
1739    off_t res;
1740 #ifdef HAVE_ZLIB
1741    if (d != NULL && d->gz)
1742       res = gzseek(d->gz,To,SEEK_SET);
1743    else
1744 #endif
1745       res = lseek(iFd,To,SEEK_SET);
1746    if (res != (off_t)To)
1747       return FileFdError("Unable to seek to %llu", To);
1748
1749    if (d != NULL)
1750       d->seekpos = To;
1751    return true;
1752 }
1753                                                                         /*}}}*/
1754 // FileFd::Skip - Seek in the file                                      /*{{{*/
1755 // ---------------------------------------------------------------------
1756 /* */
1757 bool FileFd::Skip(unsigned long long Over)
1758 {
1759    if (d != NULL && (d->pipe == true || d->InternalStream() == true))
1760    {
1761       char buffer[1024];
1762       while (Over != 0)
1763       {
1764          unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
1765          if (Read(buffer, toread) == false)
1766             return FileFdError("Unable to seek ahead %llu",Over);
1767          Over -= toread;
1768       }
1769       return true;
1770    }
1771
1772    off_t res;
1773 #ifdef HAVE_ZLIB
1774    if (d != NULL && d->gz != NULL)
1775       res = gzseek(d->gz,Over,SEEK_CUR);
1776    else
1777 #endif
1778       res = lseek(iFd,Over,SEEK_CUR);
1779    if (res < 0)
1780       return FileFdError("Unable to seek ahead %llu",Over);
1781    if (d != NULL)
1782       d->seekpos = res;
1783
1784    return true;
1785 }
1786                                                                         /*}}}*/
1787 // FileFd::Truncate - Truncate the file                                 /*{{{*/
1788 // ---------------------------------------------------------------------
1789 /* */
1790 bool FileFd::Truncate(unsigned long long To)
1791 {
1792    // truncating /dev/null is always successful - as we get an error otherwise
1793    if (To == 0 && FileName == "/dev/null")
1794       return true;
1795 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1796    if (d != NULL && (d->InternalStream() == true
1797 #ifdef HAVE_ZLIB
1798             || d->gz != NULL
1799 #endif
1800             ))
1801       return FileFdError("Truncating compressed files is not implemented (%s)", FileName.c_str());
1802 #endif
1803    if (ftruncate(iFd,To) != 0)
1804       return FileFdError("Unable to truncate to %llu",To);
1805
1806    return true;
1807 }
1808                                                                         /*}}}*/
1809 // FileFd::Tell - Current seek position                                 /*{{{*/
1810 // ---------------------------------------------------------------------
1811 /* */
1812 unsigned long long FileFd::Tell()
1813 {
1814    // In theory, we could just return seekpos here always instead of
1815    // seeking around, but not all users of FileFd use always Seek() and co
1816    // so d->seekpos isn't always true and we can just use it as a hint if
1817    // we have nothing else, but not always as an authority…
1818    if (d != NULL && (d->pipe == true || d->InternalStream() == true))
1819       return d->seekpos;
1820
1821    off_t Res;
1822 #ifdef HAVE_ZLIB
1823    if (d != NULL && d->gz != NULL)
1824      Res = gztell(d->gz);
1825    else
1826 #endif
1827      Res = lseek(iFd,0,SEEK_CUR);
1828    if (Res == (off_t)-1)
1829       FileFdErrno("lseek","Failed to determine the current file position");
1830    if (d != NULL)
1831       d->seekpos = Res;
1832    return Res;
1833 }
1834                                                                         /*}}}*/
1835 static bool StatFileFd(char const * const msg, int const iFd, std::string const &FileName, struct stat &Buf, FileFdPrivate * const d) /*{{{*/
1836 {
1837    bool ispipe = (d != NULL && d->pipe == true);
1838    if (ispipe == false)
1839    {
1840       if (fstat(iFd,&Buf) != 0)
1841          // higher-level code will generate more meaningful messages,
1842          // even translated this would be meaningless for users
1843          return _error->Errno("fstat", "Unable to determine %s for fd %i", msg, iFd);
1844       if (FileName.empty() == false)
1845          ispipe = S_ISFIFO(Buf.st_mode);
1846    }
1847
1848    // for compressor pipes st_size is undefined and at 'best' zero
1849    if (ispipe == true)
1850    {
1851       // we set it here, too, as we get the info here for free
1852       // in theory the Open-methods should take care of it already
1853       if (d != NULL)
1854          d->pipe = true;
1855       if (stat(FileName.c_str(), &Buf) != 0)
1856          return _error->Errno("fstat", "Unable to determine %s for file %s", msg, FileName.c_str());
1857    }
1858    return true;
1859 }
1860                                                                         /*}}}*/
1861 // FileFd::FileSize - Return the size of the file                       /*{{{*/
1862 unsigned long long FileFd::FileSize()
1863 {
1864    struct stat Buf;
1865    if (StatFileFd("file size", iFd, FileName, Buf, d) == false)
1866    {
1867       Flags |= Fail;
1868       return 0;
1869    }
1870    return Buf.st_size;
1871 }
1872                                                                         /*}}}*/
1873 // FileFd::ModificationTime - Return the time of last touch             /*{{{*/
1874 time_t FileFd::ModificationTime()
1875 {
1876    struct stat Buf;
1877    if (StatFileFd("modification time", iFd, FileName, Buf, d) == false)
1878    {
1879       Flags |= Fail;
1880       return 0;
1881    }
1882    return Buf.st_mtime;
1883 }
1884                                                                         /*}}}*/
1885 // FileFd::Size - Return the size of the content in the file            /*{{{*/
1886 // ---------------------------------------------------------------------
1887 /* */
1888 unsigned long long FileFd::Size()
1889 {
1890    unsigned long long size = FileSize();
1891
1892    // for compressor pipes st_size is undefined and at 'best' zero,
1893    // so we 'read' the content and 'seek' back - see there
1894    if (d != NULL && (d->pipe == true || (d->InternalStream() == true && size > 0)))
1895    {
1896       unsigned long long const oldSeek = Tell();
1897       char ignore[1000];
1898       unsigned long long read = 0;
1899       do {
1900          if (Read(ignore, sizeof(ignore), &read) == false)
1901          {
1902             Seek(oldSeek);
1903             return 0;
1904          }
1905       } while(read != 0);
1906       size = Tell();
1907       Seek(oldSeek);
1908    }
1909 #ifdef HAVE_ZLIB
1910    // only check gzsize if we are actually a gzip file, just checking for
1911    // "gz" is not sufficient as uncompressed files could be opened with
1912    // gzopen in "direct" mode as well
1913    else if (d != NULL && d->gz && !gzdirect(d->gz) && size > 0)
1914    {
1915        off_t const oldPos = lseek(iFd,0,SEEK_CUR);
1916        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
1917         * this ourselves; the original (uncompressed) file size is the last 32
1918         * bits of the file */
1919        // FIXME: Size for gz-files is limited by 32bit… no largefile support
1920        if (lseek(iFd, -4, SEEK_END) < 0)
1921        {
1922           FileFdErrno("lseek","Unable to seek to end of gzipped file");
1923           return 0;
1924        }
1925        uint32_t size = 0;
1926        if (read(iFd, &size, 4) != 4)
1927        {
1928           FileFdErrno("read","Unable to read original size of gzipped file");
1929           return 0;
1930        }
1931        size = le32toh(size);
1932
1933        if (lseek(iFd, oldPos, SEEK_SET) < 0)
1934        {
1935           FileFdErrno("lseek","Unable to seek in gzipped file");
1936           return 0;
1937        }
1938
1939        return size;
1940    }
1941 #endif
1942
1943    return size;
1944 }
1945                                                                         /*}}}*/
1946 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
1947 // ---------------------------------------------------------------------
1948 /* */
1949 bool FileFd::Close()
1950 {
1951    if (iFd == -1)
1952       return true;
1953
1954    bool Res = true;
1955    if ((Flags & AutoClose) == AutoClose)
1956    {
1957       if ((Flags & Compressed) != Compressed && iFd > 0 && close(iFd) != 0)
1958          Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
1959       if (d != NULL)
1960       {
1961          Res &= d->CloseDown(FileName);
1962          delete d;
1963          d = NULL;
1964       }
1965    }
1966
1967    if ((Flags & Replace) == Replace) {
1968       if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
1969          Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
1970
1971       FileName = TemporaryFileName; // for the unlink() below.
1972       TemporaryFileName.clear();
1973    }
1974
1975    iFd = -1;
1976
1977    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
1978        FileName.empty() == false)
1979       if (unlink(FileName.c_str()) != 0)
1980          Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
1981
1982    if (Res == false)
1983       Flags |= Fail;
1984    return Res;
1985 }
1986                                                                         /*}}}*/
1987 // FileFd::Sync - Sync the file                                         /*{{{*/
1988 // ---------------------------------------------------------------------
1989 /* */
1990 bool FileFd::Sync()
1991 {
1992    if (fsync(iFd) != 0)
1993       return FileFdErrno("sync",_("Problem syncing the file"));
1994    return true;
1995 }
1996                                                                         /*}}}*/
1997 // FileFd::FileFdErrno - set Fail and call _error->Errno                *{{{*/
1998 bool FileFd::FileFdErrno(const char *Function, const char *Description,...)
1999 {
2000    Flags |= Fail;
2001    va_list args;
2002    size_t msgSize = 400;
2003    int const errsv = errno;
2004    while (true)
2005    {
2006       va_start(args,Description);
2007       if (_error->InsertErrno(GlobalError::ERROR, Function, Description, args, errsv, msgSize) == false)
2008          break;
2009       va_end(args);
2010    }
2011    return false;
2012 }
2013                                                                         /*}}}*/
2014 // FileFd::FileFdError - set Fail and call _error->Error                *{{{*/
2015 bool FileFd::FileFdError(const char *Description,...) {
2016    Flags |= Fail;
2017    va_list args;
2018    size_t msgSize = 400;
2019    while (true)
2020    {
2021       va_start(args,Description);
2022       if (_error->Insert(GlobalError::ERROR, Description, args, msgSize) == false)
2023          break;
2024       va_end(args);
2025    }
2026    return false;
2027 }
2028                                                                         /*}}}*/
2029
2030 APT_DEPRECATED gzFile FileFd::gzFd() {
2031 #ifdef HAVE_ZLIB
2032    return d->gz;
2033 #else
2034    return NULL;
2035 #endif
2036 }
2037
2038
2039 // Glob - wrapper around "glob()"                                      /*{{{*/
2040 // ---------------------------------------------------------------------
2041 /* */
2042 std::vector<std::string> Glob(std::string const &pattern, int flags)
2043 {
2044    std::vector<std::string> result;
2045    glob_t globbuf;
2046    int glob_res;
2047    unsigned int i;
2048
2049    glob_res = glob(pattern.c_str(),  flags, NULL, &globbuf);
2050
2051    if (glob_res != 0)
2052    {
2053       if(glob_res != GLOB_NOMATCH) {
2054          _error->Errno("glob", "Problem with glob");
2055          return result;
2056       }
2057    }
2058
2059    // append results
2060    for(i=0;i<globbuf.gl_pathc;i++)
2061       result.push_back(string(globbuf.gl_pathv[i]));
2062
2063    globfree(&globbuf);
2064    return result;
2065 }
2066                                                                         /*}}}*/
2067
2068 std::string GetTempDir()
2069 {
2070    const char *tmpdir = getenv("TMPDIR");
2071
2072 #ifdef P_tmpdir
2073    if (!tmpdir)
2074       tmpdir = P_tmpdir;
2075 #endif
2076
2077    // check that tmpdir is set and exists
2078    struct stat st;
2079    if (!tmpdir || strlen(tmpdir) == 0 || stat(tmpdir, &st) != 0)
2080       tmpdir = "/tmp";
2081
2082    return string(tmpdir);
2083 }
2084
2085 FileFd* GetTempFile(std::string const &Prefix, bool ImmediateUnlink)
2086 {
2087    char fn[512];
2088    FileFd *Fd = new FileFd();
2089
2090    std::string tempdir = GetTempDir();
2091    snprintf(fn, sizeof(fn), "%s/%s.XXXXXX",
2092             tempdir.c_str(), Prefix.c_str());
2093    int fd = mkstemp(fn);
2094    if(ImmediateUnlink)
2095       unlink(fn);
2096    if (fd < 0)
2097    {
2098       _error->Errno("GetTempFile",_("Unable to mkstemp %s"), fn);
2099       return NULL;
2100    }
2101    if (!Fd->OpenDescriptor(fd, FileFd::WriteOnly, FileFd::None, true))
2102    {
2103       _error->Errno("GetTempFile",_("Unable to write to %s"),fn);
2104       return NULL;
2105    }
2106
2107    return Fd;
2108 }
2109
2110 bool Rename(std::string From, std::string To)
2111 {
2112    if (rename(From.c_str(),To.c_str()) != 0)
2113    {
2114       _error->Error(_("rename failed, %s (%s -> %s)."),strerror(errno),
2115                     From.c_str(),To.c_str());
2116       return false;
2117    }
2118    return true;
2119 }
2120
2121 bool Popen(const char* Args[], FileFd &Fd, pid_t &Child, FileFd::OpenMode Mode)
2122 {
2123    int fd;
2124    if (Mode != FileFd::ReadOnly && Mode != FileFd::WriteOnly)
2125       return _error->Error("Popen supports ReadOnly (x)or WriteOnly mode only");
2126
2127    int Pipe[2] = {-1, -1};
2128    if(pipe(Pipe) != 0)
2129    {
2130       return _error->Errno("pipe", _("Failed to create subprocess IPC"));
2131       return NULL;
2132    }
2133    std::set<int> keep_fds;
2134    keep_fds.insert(Pipe[0]);
2135    keep_fds.insert(Pipe[1]);
2136    Child = ExecFork(keep_fds);
2137    if(Child < 0)
2138       return _error->Errno("fork", "Failed to fork");
2139    if(Child == 0)
2140    {
2141       if(Mode == FileFd::ReadOnly)
2142       {
2143          close(Pipe[0]);
2144          fd = Pipe[1];
2145       }
2146       else if(Mode == FileFd::WriteOnly)
2147       {
2148          close(Pipe[1]);
2149          fd = Pipe[0];
2150       }
2151
2152       if(Mode == FileFd::ReadOnly)
2153       {
2154          dup2(fd, 1);
2155          dup2(fd, 2);
2156       } else if(Mode == FileFd::WriteOnly)
2157          dup2(fd, 0);
2158
2159       execv(Args[0], (char**)Args);
2160       _exit(100);
2161    }
2162    if(Mode == FileFd::ReadOnly)
2163    {
2164       close(Pipe[1]);
2165       fd = Pipe[0];
2166    } else if(Mode == FileFd::WriteOnly)
2167    {
2168       close(Pipe[0]);
2169       fd = Pipe[1];
2170    }
2171    Fd.OpenDescriptor(fd, Mode, FileFd::None, true);
2172
2173    return true;
2174 }
2175
2176 bool DropPrivs()
2177 {
2178    // uid will be 0 in the end, but gid might be different anyway
2179    uid_t old_uid = getuid();
2180    gid_t old_gid = getgid();
2181
2182    if (old_uid != 0)
2183       return true;
2184    if(_config->FindB("Debug::NoDropPrivs", false) == true)
2185       return true;
2186
2187    const std::string nobody = _config->Find("APT::User::Nobody", "_apt");
2188    struct passwd *pw = getpwnam(nobody.c_str());
2189    if (pw == NULL)
2190       return _error->Warning("No user %s, can not drop rights", nobody.c_str());
2191
2192 #if __gnu_linux__
2193    // see prctl(2), needs linux3.5
2194    int ret = prctl(PR_SET_NO_NEW_PRIVS, 1, 0,0, 0);
2195    if(ret < 0)
2196       _error->Warning("PR_SET_NO_NEW_PRIVS failed with %i", ret);
2197 #endif
2198    // Do not change the order here, it might break things
2199    if (setgroups(1, &pw->pw_gid))
2200       return _error->Errno("setgroups", "Failed to setgroups");
2201
2202    if (setegid(pw->pw_gid) != 0)
2203       return _error->Errno("setegid", "Failed to setegid");
2204
2205    if (setgid(pw->pw_gid) != 0)
2206       return _error->Errno("setgid", "Failed to setgid");
2207
2208    if (setuid(pw->pw_uid) != 0)
2209       return _error->Errno("setuid", "Failed to setuid");
2210
2211    // the seteuid() is probably uneeded (at least thats what the linux
2212    // man-page says about setuid(2)) but we cargo culted it anyway
2213    if (seteuid(pw->pw_uid) != 0)
2214       return _error->Errno("seteuid", "Failed to seteuid");
2215
2216    // Verify that the user has only a single group, and the correct one
2217    gid_t groups[1];
2218    if (getgroups(1, groups) != 1)
2219       return _error->Errno("getgroups", "Could not get new groups");
2220    if (groups[0] != pw->pw_gid)
2221       return _error->Error("Could not switch group");
2222
2223    // Verify that gid, egid, uid, and euid changed
2224    if (getgid() != pw->pw_gid)
2225       return _error->Error("Could not switch group");
2226    if (getegid() != pw->pw_gid)
2227       return _error->Error("Could not switch effective group");
2228    if (getuid() != pw->pw_uid)
2229       return _error->Error("Could not switch user");
2230    if (geteuid() != pw->pw_uid)
2231       return _error->Error("Could not switch effective user");
2232
2233 #ifdef HAVE_GETRESUID
2234    // verify that the saved set-user-id was changed as well
2235    uid_t ruid = 0;
2236    uid_t euid = 0;
2237    uid_t suid = 0;
2238    if (getresuid(&ruid, &euid, &suid))
2239       return _error->Errno("getresuid", "Could not get saved set-user-ID");
2240    if (suid != pw->pw_uid)
2241       return _error->Error("Could not switch saved set-user-ID");
2242 #endif
2243
2244 #ifdef HAVE_GETRESGID
2245    // verify that the saved set-group-id was changed as well
2246    gid_t rgid = 0;
2247    gid_t egid = 0;
2248    gid_t sgid = 0;
2249    if (getresgid(&rgid, &egid, &sgid))
2250       return _error->Errno("getresuid", "Could not get saved set-group-ID");
2251    if (sgid != pw->pw_gid)
2252       return _error->Error("Could not switch saved set-group-ID");
2253 #endif
2254
2255    // Check that uid and gid changes do not work anymore
2256    if (pw->pw_gid != old_gid && (setgid(old_gid) != -1 || setegid(old_gid) != -1))
2257       return _error->Error("Could restore a gid to root, privilege dropping did not work");
2258
2259    if (pw->pw_uid != old_uid && (setuid(old_uid) != -1 || seteuid(old_uid) != -1))
2260       return _error->Error("Could restore a uid to root, privilege dropping did not work");
2261
2262    return true;
2263 }