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 Perms)
 962 {
 963    if (Mode == ReadOnlyGzip)
 964       return Open(FileName, ReadOnly, Gzip, Perms);
 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, Perms);
1032 }
1033 bool FileFd::Open(string FileName,unsigned int const Mode,APT::Configuration::Compressor const &compressor, unsigned long const Perms)
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       if(Perms != 600 && fchmod(iFd, Perms) == -1)
1084           return FileFdErrno("fchmod", "Could not change permissions for temporary file %s", TemporaryFileName.c_str());
1085    }
1086    else
1087       iFd = open(FileName.c_str(), fileflags, Perms);
1088
1089    this->FileName = FileName;
1090    if (iFd == -1 || OpenInternDescriptor(Mode, compressor) == false)
1091    {
1092       if (iFd != -1)
1093       {
1094          close (iFd);
1095          iFd = -1;
1096       }
1097       return FileFdErrno("open",_("Could not open file %s"), FileName.c_str());
1098    }
1099
1100    SetCloseExec(iFd,true);
1101    return true;
1102 }
1103                                                                         /*}}}*/
1104 // FileFd::OpenDescriptor - Open a filedescriptor                       /*{{{*/
1105 // ---------------------------------------------------------------------
1106 /* */
1107 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, CompressMode Compress, bool AutoClose)
1108 {
1109    std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
1110    std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
1111    std::string name;
1112
1113    // compat with the old API
1114    if (Mode == ReadOnlyGzip && Compress == None)
1115       Compress = Gzip;
1116
1117    switch (Compress)
1118    {
1119    case None: name = "."; break;
1120    case Gzip: name = "gzip"; break;
1121    case Bzip2: name = "bzip2"; break;
1122    case Lzma: name = "lzma"; break;
1123    case Xz: name = "xz"; break;
1124    case Auto:
1125    case Extension:
1126       if (AutoClose == true && Fd != -1)
1127          close(Fd);
1128       return FileFdError("Opening Fd %d in Auto or Extension compression mode is not supported", Fd);
1129    }
1130    for (; compressor != compressors.end(); ++compressor)
1131       if (compressor->Name == name)
1132          break;
1133    if (compressor == compressors.end())
1134    {
1135       if (AutoClose == true && Fd != -1)
1136          close(Fd);
1137       return FileFdError("Can't find a configured compressor %s for file %s", name.c_str(), FileName.c_str());
1138    }
1139    return OpenDescriptor(Fd, Mode, *compressor, AutoClose);
1140 }
1141 bool FileFd::OpenDescriptor(int Fd, unsigned int const Mode, APT::Configuration::Compressor const &compressor, bool AutoClose)
1142 {
1143    Close();
1144    Flags = (AutoClose) ? FileFd::AutoClose : 0;
1145    iFd = Fd;
1146    this->FileName = "";
1147    if (OpenInternDescriptor(Mode, compressor) == false)
1148    {
1149       if (iFd != -1 && (
1150         (Flags & Compressed) == Compressed ||
1151         AutoClose == true))
1152       {
1153          close (iFd);
1154          iFd = -1;
1155       }
1156       return FileFdError(_("Could not open file descriptor %d"), Fd);
1157    }
1158    return true;
1159 }
1160 bool FileFd::OpenInternDescriptor(unsigned int const Mode, APT::Configuration::Compressor const &compressor)
1161 {
1162    if (iFd == -1)
1163       return false;
1164    if (compressor.Name == "." || compressor.Binary.empty() == true)
1165       return true;
1166
1167 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1168    // the API to open files is similar, so setup to avoid code duplicates later
1169    // and while at it ensure that we close before opening (if its a reopen)
1170    void* (*compress_open)(int, const char *) = NULL;
1171    if (false)
1172       /* dummy so that the rest can be 'else if's */;
1173 #define APT_COMPRESS_INIT(NAME,OPEN) \
1174    else if (compressor.Name == NAME) \
1175    { \
1176       compress_open = (void*(*)(int, const char *)) OPEN; \
1177       if (d != NULL) d->InternalClose(FileName); \
1178    }
1179 #ifdef HAVE_ZLIB
1180    APT_COMPRESS_INIT("gzip", gzdopen)
1181 #endif
1182 #ifdef HAVE_BZ2
1183    APT_COMPRESS_INIT("bzip2", BZ2_bzdopen)
1184 #endif
1185 #ifdef HAVE_LZMA
1186    APT_COMPRESS_INIT("xz", fdopen)
1187    APT_COMPRESS_INIT("lzma", fdopen)
1188 #endif
1189 #undef APT_COMPRESS_INIT
1190 #endif
1191
1192    if (d == NULL)
1193    {
1194       d = new FileFdPrivate();
1195       d->openmode = Mode;
1196       d->compressor = compressor;
1197 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1198       if ((Flags & AutoClose) != AutoClose && compress_open != NULL)
1199       {
1200          // Need to duplicate fd here or gz/bz2 close for cleanup will close the fd as well
1201          int const internFd = dup(iFd);
1202          if (internFd == -1)
1203             return FileFdErrno("OpenInternDescriptor", _("Could not open file descriptor %d"), iFd);
1204          iFd = internFd;
1205       }
1206 #endif
1207    }
1208
1209 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1210    if (compress_open != NULL)
1211    {
1212       void* compress_struct = NULL;
1213       if ((Mode & ReadWrite) == ReadWrite)
1214          compress_struct = compress_open(iFd, "r+");
1215       else if ((Mode & WriteOnly) == WriteOnly)
1216          compress_struct = compress_open(iFd, "w");
1217       else
1218          compress_struct = compress_open(iFd, "r");
1219       if (compress_struct == NULL)
1220          return false;
1221
1222       if (false)
1223          /* dummy so that the rest can be 'else if's */;
1224 #ifdef HAVE_ZLIB
1225       else if (compressor.Name == "gzip")
1226          d->gz = (gzFile) compress_struct;
1227 #endif
1228 #ifdef HAVE_BZ2
1229       else if (compressor.Name == "bzip2")
1230          d->bz2 = (BZFILE*) compress_struct;
1231 #endif
1232 #ifdef HAVE_LZMA
1233       else if (compressor.Name == "xz" || compressor.Name == "lzma")
1234       {
1235          uint32_t const xzlevel = 6;
1236          uint64_t const memlimit = UINT64_MAX;
1237          if (d->lzma == NULL)
1238             d->lzma = new FileFdPrivate::LZMAFILE;
1239          d->lzma->file = (FILE*) compress_struct;
1240          d->lzma->stream = LZMA_STREAM_INIT;
1241
1242          if ((Mode & ReadWrite) == ReadWrite)
1243             return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());
1244
1245          if ((Mode & WriteOnly) == WriteOnly)
1246          {
1247             if (compressor.Name == "xz")
1248             {
1249                if (lzma_easy_encoder(&d->lzma->stream, xzlevel, LZMA_CHECK_CRC32) != LZMA_OK)
1250                   return false;
1251             }
1252             else
1253             {
1254                lzma_options_lzma options;
1255                lzma_lzma_preset(&options, xzlevel);
1256                if (lzma_alone_encoder(&d->lzma->stream, &options) != LZMA_OK)
1257                   return false;
1258             }
1259             d->lzma->compressing = true;
1260          }
1261          else
1262          {
1263             if (compressor.Name == "xz")
1264             {
1265                if (lzma_auto_decoder(&d->lzma->stream, memlimit, 0) != LZMA_OK)
1266                   return false;
1267             }
1268             else
1269             {
1270                if (lzma_alone_decoder(&d->lzma->stream, memlimit) != LZMA_OK)
1271                   return false;
1272             }
1273             d->lzma->compressing = false;
1274          }
1275       }
1276 #endif
1277       Flags |= Compressed;
1278       return true;
1279    }
1280 #endif
1281
1282    // collect zombies here in case we reopen
1283    if (d->compressor_pid > 0)
1284       ExecWait(d->compressor_pid, "FileFdCompressor", true);
1285
1286    if ((Mode & ReadWrite) == ReadWrite)
1287       return FileFdError("ReadWrite mode is not supported for file %s", FileName.c_str());
1288
1289    bool const Comp = (Mode & WriteOnly) == WriteOnly;
1290    if (Comp == false)
1291    {
1292       // Handle 'decompression' of empty files
1293       struct stat Buf;
1294       fstat(iFd, &Buf);
1295       if (Buf.st_size == 0 && S_ISFIFO(Buf.st_mode) == false)
1296          return true;
1297
1298       // We don't need the file open - instead let the compressor open it
1299       // as he properly knows better how to efficiently read from 'his' file
1300       if (FileName.empty() == false)
1301       {
1302          close(iFd);
1303          iFd = -1;
1304       }
1305    }
1306
1307    // Create a data pipe
1308    int Pipe[2] = {-1,-1};
1309    if (pipe(Pipe) != 0)
1310       return FileFdErrno("pipe",_("Failed to create subprocess IPC"));
1311    for (int J = 0; J != 2; J++)
1312       SetCloseExec(Pipe[J],true);
1313
1314    d->compressed_fd = iFd;
1315    d->pipe = true;
1316
1317    if (Comp == true)
1318       iFd = Pipe[1];
1319    else
1320       iFd = Pipe[0];
1321
1322    // The child..
1323    d->compressor_pid = ExecFork();
1324    if (d->compressor_pid == 0)
1325    {
1326       if (Comp == true)
1327       {
1328          dup2(d->compressed_fd,STDOUT_FILENO);
1329          dup2(Pipe[0],STDIN_FILENO);
1330       }
1331       else
1332       {
1333          if (d->compressed_fd != -1)
1334             dup2(d->compressed_fd,STDIN_FILENO);
1335          dup2(Pipe[1],STDOUT_FILENO);
1336       }
1337       int const nullfd = open("/dev/null", O_WRONLY);
1338       if (nullfd != -1)
1339       {
1340          dup2(nullfd,STDERR_FILENO);
1341          close(nullfd);
1342       }
1343
1344       SetCloseExec(STDOUT_FILENO,false);
1345       SetCloseExec(STDIN_FILENO,false);
1346
1347       std::vector<char const*> Args;
1348       Args.push_back(compressor.Binary.c_str());
1349       std::vector<std::string> const * const addArgs =
1350                 (Comp == true) ? &(compressor.CompressArgs) : &(compressor.UncompressArgs);
1351       for (std::vector<std::string>::const_iterator a = addArgs->begin();
1352            a != addArgs->end(); ++a)
1353          Args.push_back(a->c_str());
1354       if (Comp == false && FileName.empty() == false)
1355       {
1356          Args.push_back("--stdout");
1357          if (TemporaryFileName.empty() == false)
1358             Args.push_back(TemporaryFileName.c_str());
1359          else
1360             Args.push_back(FileName.c_str());
1361       }
1362       Args.push_back(NULL);
1363
1364       execvp(Args[0],(char **)&Args[0]);
1365       cerr << _("Failed to exec compressor ") << Args[0] << endl;
1366       _exit(100);
1367    }
1368    if (Comp == true)
1369       close(Pipe[0]);
1370    else
1371       close(Pipe[1]);
1372
1373    return true;
1374 }
1375                                                                         /*}}}*/
1376 // FileFd::~File - Closes the file                                      /*{{{*/
1377 // ---------------------------------------------------------------------
1378 /* If the proper modes are selected then we close the Fd and possibly
1379    unlink the file on error. */
1380 FileFd::~FileFd()
1381 {
1382    Close();
1383    if (d != NULL)
1384       d->CloseDown(FileName);
1385    delete d;
1386    d = NULL;
1387 }
1388                                                                         /*}}}*/
1389 // FileFd::Read - Read a bit of the file                                /*{{{*/
1390 // ---------------------------------------------------------------------
1391 /* We are careful to handle interruption by a signal while reading
1392    gracefully. */
1393 bool FileFd::Read(void *To,unsigned long long Size,unsigned long long *Actual)
1394 {
1395    ssize_t Res;
1396    errno = 0;
1397    if (Actual != 0)
1398       *Actual = 0;
1399    *((char *)To) = '\0';
1400    do
1401    {
1402       if (false)
1403          /* dummy so that the rest can be 'else if's */;
1404 #ifdef HAVE_ZLIB
1405       else if (d != NULL && d->gz != NULL)
1406          Res = gzread(d->gz,To,Size);
1407 #endif
1408 #ifdef HAVE_BZ2
1409       else if (d != NULL && d->bz2 != NULL)
1410          Res = BZ2_bzread(d->bz2,To,Size);
1411 #endif
1412 #ifdef HAVE_LZMA
1413       else if (d != NULL && d->lzma != NULL)
1414       {
1415          if (d->lzma->eof == true)
1416             break;
1417
1418          d->lzma->stream.next_out = (uint8_t *) To;
1419          d->lzma->stream.avail_out = Size;
1420          if (d->lzma->stream.avail_in == 0)
1421          {
1422             d->lzma->stream.next_in = d->lzma->buffer;
1423             d->lzma->stream.avail_in = fread(d->lzma->buffer, 1, sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]), d->lzma->file);
1424          }
1425          d->lzma->err = lzma_code(&d->lzma->stream, LZMA_RUN);
1426          if (d->lzma->err == LZMA_STREAM_END)
1427          {
1428             d->lzma->eof = true;
1429             Res = Size - d->lzma->stream.avail_out;
1430          }
1431          else if (d->lzma->err != LZMA_OK)
1432          {
1433             Res = -1;
1434             errno = 0;
1435          }
1436          else
1437          {
1438             Res = Size - d->lzma->stream.avail_out;
1439             if (Res == 0)
1440             {
1441                // lzma run was okay, but produced no output…
1442                Res = -1;
1443                errno = EINTR;
1444             }
1445          }
1446       }
1447 #endif
1448       else
1449          Res = read(iFd,To,Size);
1450
1451       if (Res < 0)
1452       {
1453          if (errno == EINTR)
1454          {
1455             // trick the while-loop into running again
1456             Res = 1;
1457             errno = 0;
1458             continue;
1459          }
1460          if (false)
1461             /* dummy so that the rest can be 'else if's */;
1462 #ifdef HAVE_ZLIB
1463          else if (d != NULL && d->gz != NULL)
1464          {
1465             int err;
1466             char const * const errmsg = gzerror(d->gz, &err);
1467             if (err != Z_ERRNO)
1468                return FileFdError("gzread: %s (%d: %s)", _("Read error"), err, errmsg);
1469          }
1470 #endif
1471 #ifdef HAVE_BZ2
1472          else if (d != NULL && d->bz2 != NULL)
1473          {
1474             int err;
1475             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1476             if (err != BZ_IO_ERROR)
1477                return FileFdError("BZ2_bzread: %s (%d: %s)", _("Read error"), err, errmsg);
1478          }
1479 #endif
1480 #ifdef HAVE_LZMA
1481          else if (d != NULL && d->lzma != NULL)
1482             return FileFdError("lzma_read: %s (%d)", _("Read error"), d->lzma->err);
1483 #endif
1484          return FileFdErrno("read",_("Read error"));
1485       }
1486
1487       To = (char *)To + Res;
1488       Size -= Res;
1489       if (d != NULL)
1490          d->seekpos += Res;
1491       if (Actual != 0)
1492          *Actual += Res;
1493    }
1494    while (Res > 0 && Size > 0);
1495
1496    if (Size == 0)
1497       return true;
1498
1499    // Eof handling
1500    if (Actual != 0)
1501    {
1502       Flags |= HitEof;
1503       return true;
1504    }
1505
1506    return FileFdError(_("read, still have %llu to read but none left"), Size);
1507 }
1508                                                                         /*}}}*/
1509 // FileFd::ReadLine - Read a complete line from the file                /*{{{*/
1510 // ---------------------------------------------------------------------
1511 /* Beware: This method can be quiet slow for big buffers on UNcompressed
1512    files because of the naive implementation! */
1513 char* FileFd::ReadLine(char *To, unsigned long long const Size)
1514 {
1515    *To = '\0';
1516 #ifdef HAVE_ZLIB
1517    if (d != NULL && d->gz != NULL)
1518       return gzgets(d->gz, To, Size);
1519 #endif
1520
1521    unsigned long long read = 0;
1522    while ((Size - 1) != read)
1523    {
1524       unsigned long long done = 0;
1525       if (Read(To + read, 1, &done) == false)
1526          return NULL;
1527       if (done == 0)
1528          break;
1529       if (To[read++] == '\n')
1530          break;
1531    }
1532    if (read == 0)
1533       return NULL;
1534    To[read] = '\0';
1535    return To;
1536 }
1537                                                                         /*}}}*/
1538 // FileFd::Write - Write to the file                                    /*{{{*/
1539 // ---------------------------------------------------------------------
1540 /* */
1541 bool FileFd::Write(const void *From,unsigned long long Size)
1542 {
1543    ssize_t Res;
1544    errno = 0;
1545    do
1546    {
1547       if (false)
1548          /* dummy so that the rest can be 'else if's */;
1549 #ifdef HAVE_ZLIB
1550       else if (d != NULL && d->gz != NULL)
1551          Res = gzwrite(d->gz,From,Size);
1552 #endif
1553 #ifdef HAVE_BZ2
1554       else if (d != NULL && d->bz2 != NULL)
1555          Res = BZ2_bzwrite(d->bz2,(void*)From,Size);
1556 #endif
1557 #ifdef HAVE_LZMA
1558       else if (d != NULL && d->lzma != NULL)
1559       {
1560          d->lzma->stream.next_in = (uint8_t *)From;
1561          d->lzma->stream.avail_in = Size;
1562          d->lzma->stream.next_out = d->lzma->buffer;
1563          d->lzma->stream.avail_out = sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]);
1564          d->lzma->err = lzma_code(&d->lzma->stream, LZMA_RUN);
1565          if (d->lzma->err != LZMA_OK)
1566             return false;
1567          size_t const n = sizeof(d->lzma->buffer)/sizeof(d->lzma->buffer[0]) - d->lzma->stream.avail_out;
1568          size_t const m = (n == 0) ? 0 : fwrite(d->lzma->buffer, 1, n, d->lzma->file);
1569          if (m != n)
1570             Res = -1;
1571          else
1572             Res = Size - d->lzma->stream.avail_in;
1573       }
1574 #endif
1575       else
1576          Res = write(iFd,From,Size);
1577
1578       if (Res < 0 && errno == EINTR)
1579          continue;
1580       if (Res < 0)
1581       {
1582          if (false)
1583             /* dummy so that the rest can be 'else if's */;
1584 #ifdef HAVE_ZLIB
1585          else if (d != NULL && d->gz != NULL)
1586          {
1587             int err;
1588             char const * const errmsg = gzerror(d->gz, &err);
1589             if (err != Z_ERRNO)
1590                return FileFdError("gzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1591          }
1592 #endif
1593 #ifdef HAVE_BZ2
1594          else if (d != NULL && d->bz2 != NULL)
1595          {
1596             int err;
1597             char const * const errmsg = BZ2_bzerror(d->bz2, &err);
1598             if (err != BZ_IO_ERROR)
1599                return FileFdError("BZ2_bzwrite: %s (%d: %s)", _("Write error"), err, errmsg);
1600          }
1601 #endif
1602 #ifdef HAVE_LZMA
1603          else if (d != NULL && d->lzma != NULL)
1604             return FileFdErrno("lzma_fwrite", _("Write error"));
1605 #endif
1606          return FileFdErrno("write",_("Write error"));
1607       }
1608
1609       From = (char const *)From + Res;
1610       Size -= Res;
1611       if (d != NULL)
1612          d->seekpos += Res;
1613    }
1614    while (Res > 0 && Size > 0);
1615
1616    if (Size == 0)
1617       return true;
1618
1619    return FileFdError(_("write, still have %llu to write but couldn't"), Size);
1620 }
1621 bool FileFd::Write(int Fd, const void *From, unsigned long long Size)
1622 {
1623    ssize_t Res;
1624    errno = 0;
1625    do
1626    {
1627       Res = write(Fd,From,Size);
1628       if (Res < 0 && errno == EINTR)
1629          continue;
1630       if (Res < 0)
1631          return _error->Errno("write",_("Write error"));
1632
1633       From = (char const *)From + Res;
1634       Size -= Res;
1635    }
1636    while (Res > 0 && Size > 0);
1637
1638    if (Size == 0)
1639       return true;
1640
1641    return _error->Error(_("write, still have %llu to write but couldn't"), Size);
1642 }
1643                                                                         /*}}}*/
1644 // FileFd::Seek - Seek in the file                                      /*{{{*/
1645 // ---------------------------------------------------------------------
1646 /* */
1647 bool FileFd::Seek(unsigned long long To)
1648 {
1649    if (d != NULL && (d->pipe == true || d->InternalStream() == true))
1650    {
1651       // Our poor man seeking in pipes is costly, so try to avoid it
1652       unsigned long long seekpos = Tell();
1653       if (seekpos == To)
1654          return true;
1655       else if (seekpos < To)
1656          return Skip(To - seekpos);
1657
1658       if ((d->openmode & ReadOnly) != ReadOnly)
1659          return FileFdError("Reopen is only implemented for read-only files!");
1660       d->InternalClose(FileName);
1661       if (iFd != -1)
1662          close(iFd);
1663       iFd = -1;
1664       if (TemporaryFileName.empty() == false)
1665          iFd = open(TemporaryFileName.c_str(), O_RDONLY);
1666       else if (FileName.empty() == false)
1667          iFd = open(FileName.c_str(), O_RDONLY);
1668       else
1669       {
1670          if (d->compressed_fd > 0)
1671             if (lseek(d->compressed_fd, 0, SEEK_SET) != 0)
1672                iFd = d->compressed_fd;
1673          if (iFd < 0)
1674             return FileFdError("Reopen is not implemented for pipes opened with FileFd::OpenDescriptor()!");
1675       }
1676
1677       if (OpenInternDescriptor(d->openmode, d->compressor) == false)
1678          return FileFdError("Seek on file %s because it couldn't be reopened", FileName.c_str());
1679
1680       if (To != 0)
1681          return Skip(To);
1682
1683       d->seekpos = To;
1684       return true;
1685    }
1686    off_t res;
1687 #ifdef HAVE_ZLIB
1688    if (d != NULL && d->gz)
1689       res = gzseek(d->gz,To,SEEK_SET);
1690    else
1691 #endif
1692       res = lseek(iFd,To,SEEK_SET);
1693    if (res != (off_t)To)
1694       return FileFdError("Unable to seek to %llu", To);
1695
1696    if (d != NULL)
1697       d->seekpos = To;
1698    return true;
1699 }
1700                                                                         /*}}}*/
1701 // FileFd::Skip - Seek in the file                                      /*{{{*/
1702 // ---------------------------------------------------------------------
1703 /* */
1704 bool FileFd::Skip(unsigned long long Over)
1705 {
1706    if (d != NULL && (d->pipe == true || d->InternalStream() == true))
1707    {
1708       d->seekpos += Over;
1709       char buffer[1024];
1710       while (Over != 0)
1711       {
1712          unsigned long long toread = std::min((unsigned long long) sizeof(buffer), Over);
1713          if (Read(buffer, toread) == false)
1714             return FileFdError("Unable to seek ahead %llu",Over);
1715          Over -= toread;
1716       }
1717       return true;
1718    }
1719
1720    off_t res;
1721 #ifdef HAVE_ZLIB
1722    if (d != NULL && d->gz != NULL)
1723       res = gzseek(d->gz,Over,SEEK_CUR);
1724    else
1725 #endif
1726       res = lseek(iFd,Over,SEEK_CUR);
1727    if (res < 0)
1728       return FileFdError("Unable to seek ahead %llu",Over);
1729    if (d != NULL)
1730       d->seekpos = res;
1731
1732    return true;
1733 }
1734                                                                         /*}}}*/
1735 // FileFd::Truncate - Truncate the file                                 /*{{{*/
1736 // ---------------------------------------------------------------------
1737 /* */
1738 bool FileFd::Truncate(unsigned long long To)
1739 {
1740    // truncating /dev/null is always successful - as we get an error otherwise
1741    if (To == 0 && FileName == "/dev/null")
1742       return true;
1743 #if defined HAVE_ZLIB || defined HAVE_BZ2 || defined HAVE_LZMA
1744    if (d != NULL && (d->InternalStream() == true
1745 #ifdef HAVE_ZLIB
1746             || d->gz != NULL
1747 #endif
1748             ))
1749       return FileFdError("Truncating compressed files is not implemented (%s)", FileName.c_str());
1750 #endif
1751    if (ftruncate(iFd,To) != 0)
1752       return FileFdError("Unable to truncate to %llu",To);
1753
1754    return true;
1755 }
1756                                                                         /*}}}*/
1757 // FileFd::Tell - Current seek position                                 /*{{{*/
1758 // ---------------------------------------------------------------------
1759 /* */
1760 unsigned long long FileFd::Tell()
1761 {
1762    // In theory, we could just return seekpos here always instead of
1763    // seeking around, but not all users of FileFd use always Seek() and co
1764    // so d->seekpos isn't always true and we can just use it as a hint if
1765    // we have nothing else, but not always as an authority…
1766    if (d != NULL && (d->pipe == true || d->InternalStream() == true))
1767       return d->seekpos;
1768
1769    off_t Res;
1770 #ifdef HAVE_ZLIB
1771    if (d != NULL && d->gz != NULL)
1772      Res = gztell(d->gz);
1773    else
1774 #endif
1775      Res = lseek(iFd,0,SEEK_CUR);
1776    if (Res == (off_t)-1)
1777       FileFdErrno("lseek","Failed to determine the current file position");
1778    if (d != NULL)
1779       d->seekpos = Res;
1780    return Res;
1781 }
1782                                                                         /*}}}*/
1783 static bool StatFileFd(char const * const msg, int const iFd, std::string const &FileName, struct stat &Buf, FileFdPrivate * const d) /*{{{*/
1784 {
1785    bool ispipe = (d != NULL && d->pipe == true);
1786    if (ispipe == false)
1787    {
1788       if (fstat(iFd,&Buf) != 0)
1789          // higher-level code will generate more meaningful messages,
1790          // even translated this would be meaningless for users
1791          return _error->Errno("fstat", "Unable to determine %s for fd %i", msg, iFd);
1792       ispipe = S_ISFIFO(Buf.st_mode);
1793    }
1794
1795    // for compressor pipes st_size is undefined and at 'best' zero
1796    if (ispipe == true)
1797    {
1798       // we set it here, too, as we get the info here for free
1799       // in theory the Open-methods should take care of it already
1800       if (d != NULL)
1801          d->pipe = true;
1802       if (stat(FileName.c_str(), &Buf) != 0)
1803          return _error->Errno("fstat", "Unable to determine %s for file %s", msg, FileName.c_str());
1804    }
1805    return true;
1806 }
1807                                                                         /*}}}*/
1808 // FileFd::FileSize - Return the size of the file                       /*{{{*/
1809 unsigned long long FileFd::FileSize()
1810 {
1811    struct stat Buf;
1812    if (StatFileFd("file size", iFd, FileName, Buf, d) == false)
1813    {
1814       Flags |= Fail;
1815       return 0;
1816    }
1817    return Buf.st_size;
1818 }
1819                                                                         /*}}}*/
1820 // FileFd::ModificationTime - Return the time of last touch             /*{{{*/
1821 time_t FileFd::ModificationTime()
1822 {
1823    struct stat Buf;
1824    if (StatFileFd("modification time", iFd, FileName, Buf, d) == false)
1825    {
1826       Flags |= Fail;
1827       return 0;
1828    }
1829    return Buf.st_mtime;
1830 }
1831                                                                         /*}}}*/
1832 // FileFd::Size - Return the size of the content in the file            /*{{{*/
1833 // ---------------------------------------------------------------------
1834 /* */
1835 unsigned long long FileFd::Size()
1836 {
1837    unsigned long long size = FileSize();
1838
1839    // for compressor pipes st_size is undefined and at 'best' zero,
1840    // so we 'read' the content and 'seek' back - see there
1841    if (d != NULL && (d->pipe == true || (d->InternalStream() == true && size > 0)))
1842    {
1843       unsigned long long const oldSeek = Tell();
1844       char ignore[1000];
1845       unsigned long long read = 0;
1846       do {
1847          if (Read(ignore, sizeof(ignore), &read) == false)
1848          {
1849             Seek(oldSeek);
1850             return 0;
1851          }
1852       } while(read != 0);
1853       size = Tell();
1854       Seek(oldSeek);
1855    }
1856 #ifdef HAVE_ZLIB
1857    // only check gzsize if we are actually a gzip file, just checking for
1858    // "gz" is not sufficient as uncompressed files could be opened with
1859    // gzopen in "direct" mode as well
1860    else if (d != NULL && d->gz && !gzdirect(d->gz) && size > 0)
1861    {
1862        off_t const oldPos = lseek(iFd,0,SEEK_CUR);
1863        /* unfortunately zlib.h doesn't provide a gzsize(), so we have to do
1864         * this ourselves; the original (uncompressed) file size is the last 32
1865         * bits of the file */
1866        // FIXME: Size for gz-files is limited by 32bit… no largefile support
1867        if (lseek(iFd, -4, SEEK_END) < 0)
1868        {
1869           FileFdErrno("lseek","Unable to seek to end of gzipped file");
1870           return 0;
1871        }
1872        size = 0;
1873        if (read(iFd, &size, 4) != 4)
1874        {
1875           FileFdErrno("read","Unable to read original size of gzipped file");
1876           return 0;
1877        }
1878
1879 #ifdef WORDS_BIGENDIAN
1880        uint32_t tmp_size = size;
1881        uint8_t const * const p = (uint8_t const * const) &tmp_size;
1882        tmp_size = (p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0];
1883        size = tmp_size;
1884 #endif
1885
1886        if (lseek(iFd, oldPos, SEEK_SET) < 0)
1887        {
1888           FileFdErrno("lseek","Unable to seek in gzipped file");
1889           return 0;
1890        }
1891
1892        return size;
1893    }
1894 #endif
1895
1896    return size;
1897 }
1898                                                                         /*}}}*/
1899 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
1900 // ---------------------------------------------------------------------
1901 /* */
1902 bool FileFd::Close()
1903 {
1904    if (iFd == -1)
1905       return true;
1906
1907    bool Res = true;
1908    if ((Flags & AutoClose) == AutoClose)
1909    {
1910       if ((Flags & Compressed) != Compressed && iFd > 0 && close(iFd) != 0)
1911          Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
1912
1913       if (d != NULL)
1914       {
1915          Res &= d->CloseDown(FileName);
1916          delete d;
1917          d = NULL;
1918       }
1919    }
1920
1921    if ((Flags & Replace) == Replace) {
1922       if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
1923          Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
1924
1925       FileName = TemporaryFileName; // for the unlink() below.
1926       TemporaryFileName.clear();
1927    }
1928
1929    iFd = -1;
1930
1931    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
1932        FileName.empty() == false)
1933       if (unlink(FileName.c_str()) != 0)
1934          Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
1935
1936    if (Res == false)
1937       Flags |= Fail;
1938    return Res;
1939 }
1940                                                                         /*}}}*/
1941 // FileFd::Sync - Sync the file                                         /*{{{*/
1942 // ---------------------------------------------------------------------
1943 /* */
1944 bool FileFd::Sync()
1945 {
1946    if (fsync(iFd) != 0)
1947       return FileFdErrno("sync",_("Problem syncing the file"));
1948    return true;
1949 }
1950                                                                         /*}}}*/
1951 // FileFd::FileFdErrno - set Fail and call _error->Errno                *{{{*/
1952 bool FileFd::FileFdErrno(const char *Function, const char *Description,...)
1953 {
1954    Flags |= Fail;
1955    va_list args;
1956    size_t msgSize = 400;
1957    int const errsv = errno;
1958    while (true)
1959    {
1960       va_start(args,Description);
1961       if (_error->InsertErrno(GlobalError::ERROR, Function, Description, args, errsv, msgSize) == false)
1962          break;
1963       va_end(args);
1964    }
1965    return false;
1966 }
1967                                                                         /*}}}*/
1968 // FileFd::FileFdError - set Fail and call _error->Error                *{{{*/
1969 bool FileFd::FileFdError(const char *Description,...) {
1970    Flags |= Fail;
1971    va_list args;
1972    size_t msgSize = 400;
1973    while (true)
1974    {
1975       va_start(args,Description);
1976       if (_error->Insert(GlobalError::ERROR, Description, args, msgSize) == false)
1977          break;
1978       va_end(args);
1979    }
1980    return false;
1981 }
1982                                                                         /*}}}*/
1983
1984 APT_DEPRECATED gzFile FileFd::gzFd() {
1985 #ifdef HAVE_ZLIB
1986    return d->gz;
1987 #else
1988    return NULL;
1989 #endif
1990 }
1991
1992
1993 // Glob - wrapper around "glob()"                                      /*{{{*/
1994 // ---------------------------------------------------------------------
1995 /* */
1996 std::vector<std::string> Glob(std::string const &pattern, int flags)
1997 {
1998    std::vector<std::string> result;
1999    glob_t globbuf;
2000    int glob_res;
2001    unsigned int i;
2002
2003    glob_res = glob(pattern.c_str(),  flags, NULL, &globbuf);
2004
2005    if (glob_res != 0)
2006    {
2007       if(glob_res != GLOB_NOMATCH) {
2008          _error->Errno("glob", "Problem with glob");
2009          return result;
2010       }
2011    }
2012
2013    // append results
2014    for(i=0;i<globbuf.gl_pathc;i++)
2015       result.push_back(string(globbuf.gl_pathv[i]));
2016
2017    globfree(&globbuf);
2018    return result;
2019 }
2020                                                                         /*}}}*/
2021
2022 std::string GetTempDir()
2023 {
2024    const char *tmpdir = getenv("TMPDIR");
2025
2026 #ifdef P_tmpdir
2027    if (!tmpdir)
2028       tmpdir = P_tmpdir;
2029 #endif
2030
2031    // check that tmpdir is set and exists
2032    struct stat st;
2033    if (!tmpdir || strlen(tmpdir) == 0 || stat(tmpdir, &st) != 0)
2034       tmpdir = "/tmp";
2035
2036    return string(tmpdir);
2037 }
2038
2039 bool Rename(std::string From, std::string To)
2040 {
2041    if (rename(From.c_str(),To.c_str()) != 0)
2042    {
2043       _error->Error(_("rename failed, %s (%s -> %s)."),strerror(errno),
2044                     From.c_str(),To.c_str());
2045       return false;
2046    }
2047    return true;
2048 }