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