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