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