apt-pkg/contrib/fileutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: fileutl.cc,v 1.42 2002/09/14 05:29:22 jgg Exp $
   4 /* ######################################################################
   5
   6    File Utilities
   7
   8    CopyFile - Buffered copy of a single file
   9    GetLock - dpkg compatible lock file manipulation (fcntl)
  10
  11    Most of this source is placed in the Public Domain, do with it what
  12    you will
  13    It was originally written by Jason Gunthorpe <jgg@debian.org>.
  14    FileFd gzip support added by Martin Pitt <martin.pitt@canonical.com>
  15
  16    The exception is RunScripts() it is under the GPLv2
  17
  18    ##################################################################### */
  19                                                                         /*}}}*/
  20 // Include Files                                                        /*{{{*/
  21 #include <apt-pkg/fileutl.h>
  22 #include <apt-pkg/strutl.h>
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/sptr.h>
  25 #include <apt-pkg/configuration.h>
  26
  27 #include <apti18n.h>
  28
  29 #include <cstdlib>
  30 #include <cstring>
  31 #include <cstdio>
  32
  33 #include <iostream>
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <sys/stat.h>
  37 #include <sys/types.h>
  38 #include <sys/time.h>
  39 #include <sys/wait.h>
  40 #include <dirent.h>
  41 #include <signal.h>
  42 #include <errno.h>
  43 #include <set>
  44 #include <algorithm>
  45                                                                         /*}}}*/
  46
  47 using namespace std;
  48
  49 // RunScripts - Run a set of scripts from a configuration subtree       /*{{{*/
  50 // ---------------------------------------------------------------------
  51 /* */
  52 bool RunScripts(const char *Cnf)
  53 {
  54    Configuration::Item const *Opts = _config->Tree(Cnf);
  55    if (Opts == 0 || Opts->Child == 0)
  56       return true;
  57    Opts = Opts->Child;
  58
  59    // Fork for running the system calls
  60    pid_t Child = ExecFork();
  61
  62    // This is the child
  63    if (Child == 0)
  64    {
  65       if (chdir("/tmp/") != 0)
  66          _exit(100);
  67
  68       unsigned int Count = 1;
  69       for (; Opts != 0; Opts = Opts->Next, Count++)
  70       {
  71          if (Opts->Value.empty() == true)
  72             continue;
  73
  74          if (system(Opts->Value.c_str()) != 0)
  75             _exit(100+Count);
  76       }
  77       _exit(0);
  78    }
  79
  80    // Wait for the child
  81    int Status = 0;
  82    while (waitpid(Child,&Status,0) != Child)
  83    {
  84       if (errno == EINTR)
  85          continue;
  86       return _error->Errno("waitpid","Couldn't wait for subprocess");
  87    }
  88
  89    // Restore sig int/quit
  90    signal(SIGQUIT,SIG_DFL);
  91    signal(SIGINT,SIG_DFL);
  92
  93    // Check for an error code.
  94    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
  95    {
  96       unsigned int Count = WEXITSTATUS(Status);
  97       if (Count > 100)
  98       {
  99          Count -= 100;
 100          for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
 101          _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
 102       }
 103
 104       return _error->Error("Sub-process returned an error code");
 105    }
 106
 107    return true;
 108 }
 109                                                                         /*}}}*/
 110
 111 // CopyFile - Buffered copy of a file                                   /*{{{*/
 112 // ---------------------------------------------------------------------
 113 /* The caller is expected to set things so that failure causes erasure */
 114 bool CopyFile(FileFd &From,FileFd &To)
 115 {
 116    if (From.IsOpen() == false || To.IsOpen() == false)
 117       return false;
 118
 119    // Buffered copy between fds
 120    SPtrArray<unsigned char> Buf = new unsigned char[64000];
 121    unsigned long Size = From.Size();
 122    while (Size != 0)
 123    {
 124       unsigned long ToRead = Size;
 125       if (Size > 64000)
 126          ToRead = 64000;
 127
 128       if (From.Read(Buf,ToRead) == false ||
 129           To.Write(Buf,ToRead) == false)
 130          return false;
 131
 132       Size -= ToRead;
 133    }
 134
 135    return true;
 136 }
 137                                                                         /*}}}*/
 138 // GetLock - Gets a lock file                                           /*{{{*/
 139 // ---------------------------------------------------------------------
 140 /* This will create an empty file of the given name and lock it. Once this
 141    is done all other calls to GetLock in any other process will fail with
 142    -1. The return result is the fd of the file, the call should call
 143    close at some time. */
 144 int GetLock(string File,bool Errors)
 145 {
 146    // GetLock() is used in aptitude on directories with public-write access
 147    // Use O_NOFOLLOW here to prevent symlink traversal attacks
 148    int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
 149    if (FD < 0)
 150    {
 151       // Read only .. cant have locking problems there.
 152       if (errno == EROFS)
 153       {
 154          _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
 155          return dup(0);       // Need something for the caller to close
 156       }
 157
 158       if (Errors == true)
 159          _error->Errno("open",_("Could not open lock file %s"),File.c_str());
 160
 161       // Feh.. We do this to distinguish the lock vs open case..
 162       errno = EPERM;
 163       return -1;
 164    }
 165    SetCloseExec(FD,true);
 166
 167    // Aquire a write lock
 168    struct flock fl;
 169    fl.l_type = F_WRLCK;
 170    fl.l_whence = SEEK_SET;
 171    fl.l_start = 0;
 172    fl.l_len = 0;
 173    if (fcntl(FD,F_SETLK,&fl) == -1)
 174    {
 175       if (errno == ENOLCK)
 176       {
 177          _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
 178          return dup(0);       // Need something for the caller to close
 179       }
 180       if (Errors == true)
 181          _error->Errno("open",_("Could not get lock %s"),File.c_str());
 182
 183       int Tmp = errno;
 184       close(FD);
 185       errno = Tmp;
 186       return -1;
 187    }
 188
 189    return FD;
 190 }
 191                                                                         /*}}}*/
 192 // FileExists - Check if a file exists                                  /*{{{*/
 193 // ---------------------------------------------------------------------
 194 /* */
 195 bool FileExists(string File)
 196 {
 197    struct stat Buf;
 198    if (stat(File.c_str(),&Buf) != 0)
 199       return false;
 200    return true;
 201 }
 202                                                                         /*}}}*/
 203 // DirectoryExists - Check if a directory exists and is really one      /*{{{*/
 204 // ---------------------------------------------------------------------
 205 /* */
 206 bool DirectoryExists(string const &Path)
 207 {
 208    struct stat Buf;
 209    if (stat(Path.c_str(),&Buf) != 0)
 210       return false;
 211    return ((Buf.st_mode & S_IFDIR) != 0);
 212 }
 213                                                                         /*}}}*/
 214 // CreateDirectory - poor man's mkdir -p guarded by a parent directory  /*{{{*/
 215 // ---------------------------------------------------------------------
 216 /* This method will create all directories needed for path in good old
 217    mkdir -p style but refuses to do this if Parent is not a prefix of
 218    this Path. Example: /var/cache/ and /var/cache/apt/archives are given,
 219    so it will create apt/archives if /var/cache exists - on the other
 220    hand if the parent is /var/lib the creation will fail as this path
 221    is not a parent of the path to be generated. */
 222 bool CreateDirectory(string const &Parent, string const &Path)
 223 {
 224    if (Parent.empty() == true || Path.empty() == true)
 225       return false;
 226
 227    if (DirectoryExists(Path) == true)
 228       return true;
 229
 230    if (DirectoryExists(Parent) == false)
 231       return false;
 232
 233    // we are not going to create directories "into the blue"
 234    if (Path.find(Parent, 0) != 0)
 235       return false;
 236
 237    vector<string> const dirs = VectorizeString(Path.substr(Parent.size()), '/');
 238    string progress = Parent;
 239    for (vector<string>::const_iterator d = dirs.begin(); d != dirs.end(); ++d)
 240    {
 241       if (d->empty() == true)
 242          continue;
 243
 244       progress.append("/").append(*d);
 245       if (DirectoryExists(progress) == true)
 246          continue;
 247
 248       if (mkdir(progress.c_str(), 0755) != 0)
 249          return false;
 250    }
 251    return true;
 252 }
 253                                                                         /*}}}*/
 254 // GetListOfFilesInDir - returns a vector of files in the given dir     /*{{{*/
 255 // ---------------------------------------------------------------------
 256 /* If an extension is given only files with this extension are included
 257    in the returned vector, otherwise every "normal" file is included. */
 258 std::vector<string> GetListOfFilesInDir(string const &Dir, string const &Ext,
 259                                         bool const &SortList, bool const &AllowNoExt)
 260 {
 261    std::vector<string> ext;
 262    ext.reserve(2);
 263    if (Ext.empty() == false)
 264       ext.push_back(Ext);
 265    if (AllowNoExt == true && ext.empty() == false)
 266       ext.push_back("");
 267    return GetListOfFilesInDir(Dir, ext, SortList);
 268 }
 269 std::vector<string> GetListOfFilesInDir(string const &Dir, std::vector<string> const &Ext,
 270                                         bool const &SortList)
 271 {
 272    // Attention debuggers: need to be set with the environment config file!
 273    bool const Debug = _config->FindB("Debug::GetListOfFilesInDir", false);
 274    if (Debug == true)
 275    {
 276       std::clog << "Accept in " << Dir << " only files with the following " << Ext.size() << " extensions:" << std::endl;
 277       if (Ext.empty() == true)
 278          std::clog << "\tNO extension" << std::endl;
 279       else
 280          for (std::vector<string>::const_iterator e = Ext.begin();
 281               e != Ext.end(); ++e)
 282             std::clog << '\t' << (e->empty() == true ? "NO" : *e) << " extension" << std::endl;
 283    }
 284
 285    std::vector<string> List;
 286    Configuration::MatchAgainstConfig SilentIgnore("Dir::Ignore-Files-Silently");
 287    DIR *D = opendir(Dir.c_str());
 288    if (D == 0)
 289    {
 290       _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
 291       return List;
 292    }
 293
 294    for (struct dirent *Ent = readdir(D); Ent != 0; Ent = readdir(D))
 295    {
 296       // skip "hidden" files
 297       if (Ent->d_name[0] == '.')
 298          continue;
 299
 300       // check for accepted extension:
 301       // no extension given -> periods are bad as hell!
 302       // extensions given -> "" extension allows no extension
 303       if (Ext.empty() == false)
 304       {
 305          string d_ext = flExtension(Ent->d_name);
 306          if (d_ext == Ent->d_name) // no extension
 307          {
 308             if (std::find(Ext.begin(), Ext.end(), "") == Ext.end())
 309             {
 310                if (Debug == true)
 311                   std::clog << "Bad file: " << Ent->d_name << " → no extension" << std::endl;
 312                _error->Notice("Ignoring file '%s' in directory '%s' as it has no filename extension", Ent->d_name, Dir.c_str());
 313                continue;
 314             }
 315          }
 316          else if (std::find(Ext.begin(), Ext.end(), d_ext) == Ext.end())
 317          {
 318             if (Debug == true)
 319                std::clog << "Bad file: " << Ent->d_name << " → bad extension »" << flExtension(Ent->d_name) << "«" << std::endl;
 320             if (SilentIgnore.Match(Ent->d_name) == false)
 321                _error->Notice("Ignoring file '%s' in directory '%s' as it has an invalid filename extension", Ent->d_name, Dir.c_str());
 322             continue;
 323          }
 324       }
 325
 326       // Skip bad filenames ala run-parts
 327       const char *C = Ent->d_name;
 328       for (; *C != 0; ++C)
 329          if (isalpha(*C) == 0 && isdigit(*C) == 0
 330              && *C != '_' && *C != '-') {
 331             // no required extension -> dot is a bad character
 332             if (*C == '.' && Ext.empty() == false)
 333                continue;
 334             break;
 335          }
 336
 337       // we don't reach the end of the name -> bad character included
 338       if (*C != 0)
 339       {
 340          if (Debug == true)
 341             std::clog << "Bad file: " << Ent->d_name << " → bad character »"
 342                << *C << "« in filename (period allowed: " << (Ext.empty() ? "no" : "yes") << ")" << std::endl;
 343          continue;
 344       }
 345
 346       // skip filenames which end with a period. These are never valid
 347       if (*(C - 1) == '.')
 348       {
 349          if (Debug == true)
 350             std::clog << "Bad file: " << Ent->d_name << " → Period as last character" << std::endl;
 351          continue;
 352       }
 353
 354       // Make sure it is a file and not something else
 355       string const File = flCombine(Dir,Ent->d_name);
 356       struct stat St;
 357       if (stat(File.c_str(),&St) != 0 || S_ISREG(St.st_mode) == 0)
 358       {
 359          if (Debug == true)
 360             std::clog << "Bad file: " << Ent->d_name << " → stat says not a good file" << std::endl;
 361          continue;
 362       }
 363
 364       if (Debug == true)
 365          std::clog << "Accept file: " << Ent->d_name << " in " << Dir << std::endl;
 366       List.push_back(File);
 367    }
 368    closedir(D);
 369
 370    if (SortList == true)
 371       std::sort(List.begin(),List.end());
 372    return List;
 373 }
 374                                                                         /*}}}*/
 375 // SafeGetCWD - This is a safer getcwd that returns a dynamic string    /*{{{*/
 376 // ---------------------------------------------------------------------
 377 /* We return / on failure. */
 378 string SafeGetCWD()
 379 {
 380    // Stash the current dir.
 381    char S[300];
 382    S[0] = 0;
 383    if (getcwd(S,sizeof(S)-2) == 0)
 384       return "/";
 385    unsigned int Len = strlen(S);
 386    S[Len] = '/';
 387    S[Len+1] = 0;
 388    return S;
 389 }
 390                                                                         /*}}}*/
 391 // flNotDir - Strip the directory from the filename                     /*{{{*/
 392 // ---------------------------------------------------------------------
 393 /* */
 394 string flNotDir(string File)
 395 {
 396    string::size_type Res = File.rfind('/');
 397    if (Res == string::npos)
 398       return File;
 399    Res++;
 400    return string(File,Res,Res - File.length());
 401 }
 402                                                                         /*}}}*/
 403 // flNotFile - Strip the file from the directory name                   /*{{{*/
 404 // ---------------------------------------------------------------------
 405 /* Result ends in a / */
 406 string flNotFile(string File)
 407 {
 408    string::size_type Res = File.rfind('/');
 409    if (Res == string::npos)
 410       return "./";
 411    Res++;
 412    return string(File,0,Res);
 413 }
 414                                                                         /*}}}*/
 415 // flExtension - Return the extension for the file                      /*{{{*/
 416 // ---------------------------------------------------------------------
 417 /* */
 418 string flExtension(string File)
 419 {
 420    string::size_type Res = File.rfind('.');
 421    if (Res == string::npos)
 422       return File;
 423    Res++;
 424    return string(File,Res,Res - File.length());
 425 }
 426                                                                         /*}}}*/
 427 // flNoLink - If file is a symlink then deref it                        /*{{{*/
 428 // ---------------------------------------------------------------------
 429 /* If the name is not a link then the returned path is the input. */
 430 string flNoLink(string File)
 431 {
 432    struct stat St;
 433    if (lstat(File.c_str(),&St) != 0 || S_ISLNK(St.st_mode) == 0)
 434       return File;
 435    if (stat(File.c_str(),&St) != 0)
 436       return File;
 437
 438    /* Loop resolving the link. There is no need to limit the number of
 439       loops because the stat call above ensures that the symlink is not
 440       circular */
 441    char Buffer[1024];
 442    string NFile = File;
 443    while (1)
 444    {
 445       // Read the link
 446       int Res;
 447       if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 ||
 448           (unsigned)Res >= sizeof(Buffer))
 449           return File;
 450
 451       // Append or replace the previous path
 452       Buffer[Res] = 0;
 453       if (Buffer[0] == '/')
 454          NFile = Buffer;
 455       else
 456          NFile = flNotFile(NFile) + Buffer;
 457
 458       // See if we are done
 459       if (lstat(NFile.c_str(),&St) != 0)
 460          return File;
 461       if (S_ISLNK(St.st_mode) == 0)
 462          return NFile;
 463    }
 464 }
 465                                                                         /*}}}*/
 466 // flCombine - Combine a file and a directory                           /*{{{*/
 467 // ---------------------------------------------------------------------
 468 /* If the file is an absolute path then it is just returned, otherwise
 469    the directory is pre-pended to it. */
 470 string flCombine(string Dir,string File)
 471 {
 472    if (File.empty() == true)
 473       return string();
 474
 475    if (File[0] == '/' || Dir.empty() == true)
 476       return File;
 477    if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
 478       return File;
 479    if (Dir[Dir.length()-1] == '/')
 480       return Dir + File;
 481    return Dir + '/' + File;
 482 }
 483                                                                         /*}}}*/
 484 // SetCloseExec - Set the close on exec flag                            /*{{{*/
 485 // ---------------------------------------------------------------------
 486 /* */
 487 void SetCloseExec(int Fd,bool Close)
 488 {
 489    if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
 490    {
 491       cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
 492       exit(100);
 493    }
 494 }
 495                                                                         /*}}}*/
 496 // SetNonBlock - Set the nonblocking flag                               /*{{{*/
 497 // ---------------------------------------------------------------------
 498 /* */
 499 void SetNonBlock(int Fd,bool Block)
 500 {
 501    int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
 502    if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
 503    {
 504       cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
 505       exit(100);
 506    }
 507 }
 508                                                                         /*}}}*/
 509 // WaitFd - Wait for a FD to become readable                            /*{{{*/
 510 // ---------------------------------------------------------------------
 511 /* This waits for a FD to become readable using select. It is useful for
 512    applications making use of non-blocking sockets. The timeout is
 513    in seconds. */
 514 bool WaitFd(int Fd,bool write,unsigned long timeout)
 515 {
 516    fd_set Set;
 517    struct timeval tv;
 518    FD_ZERO(&Set);
 519    FD_SET(Fd,&Set);
 520    tv.tv_sec = timeout;
 521    tv.tv_usec = 0;
 522    if (write == true)
 523    {
 524       int Res;
 525       do
 526       {
 527          Res = select(Fd+1,0,&Set,0,(timeout != 0?&tv:0));
 528       }
 529       while (Res < 0 && errno == EINTR);
 530
 531       if (Res <= 0)
 532          return false;
 533    }
 534    else
 535    {
 536       int Res;
 537       do
 538       {
 539          Res = select(Fd+1,&Set,0,0,(timeout != 0?&tv:0));
 540       }
 541       while (Res < 0 && errno == EINTR);
 542
 543       if (Res <= 0)
 544          return false;
 545    }
 546
 547    return true;
 548 }
 549                                                                         /*}}}*/
 550 // ExecFork - Magical fork that sanitizes the context before execing    /*{{{*/
 551 // ---------------------------------------------------------------------
 552 /* This is used if you want to cleanse the environment for the forked
 553    child, it fixes up the important signals and nukes all of the fds,
 554    otherwise acts like normal fork. */
 555 pid_t ExecFork()
 556 {
 557    // Fork off the process
 558    pid_t Process = fork();
 559    if (Process < 0)
 560    {
 561       cerr << "FATAL -> Failed to fork." << endl;
 562       exit(100);
 563    }
 564
 565    // Spawn the subprocess
 566    if (Process == 0)
 567    {
 568       // Setup the signals
 569       signal(SIGPIPE,SIG_DFL);
 570       signal(SIGQUIT,SIG_DFL);
 571       signal(SIGINT,SIG_DFL);
 572       signal(SIGWINCH,SIG_DFL);
 573       signal(SIGCONT,SIG_DFL);
 574       signal(SIGTSTP,SIG_DFL);
 575
 576       set<int> KeepFDs;
 577       Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
 578       if (Opts != 0 && Opts->Child != 0)
 579       {
 580          Opts = Opts->Child;
 581          for (; Opts != 0; Opts = Opts->Next)
 582          {
 583             if (Opts->Value.empty() == true)
 584                continue;
 585             int fd = atoi(Opts->Value.c_str());
 586             KeepFDs.insert(fd);
 587          }
 588       }
 589
 590       // Close all of our FDs - just in case
 591       for (int K = 3; K != 40; K++)
 592       {
 593          if(KeepFDs.find(K) == KeepFDs.end())
 594             fcntl(K,F_SETFD,FD_CLOEXEC);
 595       }
 596    }
 597
 598    return Process;
 599 }
 600                                                                         /*}}}*/
 601 // ExecWait - Fancy waitpid                                             /*{{{*/
 602 // ---------------------------------------------------------------------
 603 /* Waits for the given sub process. If Reap is set then no errors are
 604    generated. Otherwise a failed subprocess will generate a proper descriptive
 605    message */
 606 bool ExecWait(pid_t Pid,const char *Name,bool Reap)
 607 {
 608    if (Pid <= 1)
 609       return true;
 610
 611    // Wait and collect the error code
 612    int Status;
 613    while (waitpid(Pid,&Status,0) != Pid)
 614    {
 615       if (errno == EINTR)
 616          continue;
 617
 618       if (Reap == true)
 619          return false;
 620
 621       return _error->Error(_("Waited for %s but it wasn't there"),Name);
 622    }
 623
 624
 625    // Check for an error code.
 626    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 627    {
 628       if (Reap == true)
 629          return false;
 630       if (WIFSIGNALED(Status) != 0)
 631       {
 632          if( WTERMSIG(Status) == SIGSEGV)
 633             return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
 634          else
 635             return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));
 636       }
 637
 638       if (WIFEXITED(Status) != 0)
 639          return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
 640
 641       return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
 642    }
 643
 644    return true;
 645 }
 646                                                                         /*}}}*/
 647
 648 // FileFd::Open - Open a file                                           /*{{{*/
 649 // ---------------------------------------------------------------------
 650 /* The most commonly used open mode combinations are given with Mode */
 651 bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
 652 {
 653    Close();
 654    Flags = AutoClose;
 655    switch (Mode)
 656    {
 657       case ReadOnly:
 658       iFd = open(FileName.c_str(),O_RDONLY);
 659       break;
 660
 661       case ReadOnlyGzip:
 662       iFd = open(FileName.c_str(),O_RDONLY);
 663       if (iFd > 0) {
 664          gz = gzdopen (iFd, "r");
 665          if (gz == NULL) {
 666              close (iFd);
 667              iFd = -1;
 668          }
 669       }
 670       break;
 671
 672       case WriteAtomic:
 673       case WriteEmpty:
 674       {
 675          Flags |= Replace;
 676          char *name = strdup((FileName + ".XXXXXX").c_str());
 677          TemporaryFileName = string(mktemp(name));
 678          iFd = open(TemporaryFileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
 679          free(name);
 680          break;
 681       }
 682
 683
 684       case WriteExists:
 685       iFd = open(FileName.c_str(),O_RDWR);
 686       break;
 687
 688       case WriteAny:
 689       iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
 690       break;
 691
 692       case WriteTemp:
 693       unlink(FileName.c_str());
 694       iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
 695       break;
 696    }
 697
 698    if (iFd < 0)
 699       return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
 700
 701    this->FileName = FileName;
 702    SetCloseExec(iFd,true);
 703    return true;
 704 }
 705
 706 bool FileFd::OpenDescriptor(int Fd, OpenMode Mode, bool AutoClose)
 707 {
 708    Close();
 709    Flags = (AutoClose) ? FileFd::AutoClose : 0;
 710    iFd = Fd;
 711    if (Mode == ReadOnlyGzip) {
 712       gz = gzdopen (iFd, "r");
 713       if (gz == NULL) {
 714          if (AutoClose)
 715             close (iFd);
 716          return _error->Errno("gzdopen",_("Could not open file descriptor %d"),
 717                               Fd);
 718       }
 719    }
 720    this->FileName = "";
 721    return true;
 722 }
 723                                                                         /*}}}*/
 724 // FileFd::~File - Closes the file                                      /*{{{*/
 725 // ---------------------------------------------------------------------
 726 /* If the proper modes are selected then we close the Fd and possibly
 727    unlink the file on error. */
 728 FileFd::~FileFd()
 729 {
 730    Close();
 731 }
 732                                                                         /*}}}*/
 733 // FileFd::Read - Read a bit of the file                                /*{{{*/
 734 // ---------------------------------------------------------------------
 735 /* We are carefull to handle interruption by a signal while reading
 736    gracefully. */
 737 bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
 738 {
 739    int Res;
 740    errno = 0;
 741    if (Actual != 0)
 742       *Actual = 0;
 743
 744    do
 745    {
 746       if (gz != NULL)
 747          Res = gzread(gz,To,Size);
 748       else
 749          Res = read(iFd,To,Size);
 750       if (Res < 0 && errno == EINTR)
 751          continue;
 752       if (Res < 0)
 753       {
 754          Flags |= Fail;
 755          return _error->Errno("read",_("Read error"));
 756       }
 757
 758       To = (char *)To + Res;
 759       Size -= Res;
 760       if (Actual != 0)
 761          *Actual += Res;
 762    }
 763    while (Res > 0 && Size > 0);
 764
 765    if (Size == 0)
 766       return true;
 767
 768    // Eof handling
 769    if (Actual != 0)
 770    {
 771       Flags |= HitEof;
 772       return true;
 773    }
 774
 775    Flags |= Fail;
 776    return _error->Error(_("read, still have %lu to read but none left"),Size);
 777 }
 778                                                                         /*}}}*/
 779 // FileFd::Write - Write to the file                                    /*{{{*/
 780 // ---------------------------------------------------------------------
 781 /* */
 782 bool FileFd::Write(const void *From,unsigned long Size)
 783 {
 784    int Res;
 785    errno = 0;
 786    do
 787    {
 788       if (gz != NULL)
 789          Res = gzwrite(gz,From,Size);
 790       else
 791          Res = write(iFd,From,Size);
 792       if (Res < 0 && errno == EINTR)
 793          continue;
 794       if (Res < 0)
 795       {
 796          Flags |= Fail;
 797          return _error->Errno("write",_("Write error"));
 798       }
 799
 800       From = (char *)From + Res;
 801       Size -= Res;
 802    }
 803    while (Res > 0 && Size > 0);
 804
 805    if (Size == 0)
 806       return true;
 807
 808    Flags |= Fail;
 809    return _error->Error(_("write, still have %lu to write but couldn't"),Size);
 810 }
 811                                                                         /*}}}*/
 812 // FileFd::Seek - Seek in the file                                      /*{{{*/
 813 // ---------------------------------------------------------------------
 814 /* */
 815 bool FileFd::Seek(unsigned long To)
 816 {
 817    int res;
 818    if (gz)
 819       res = gzseek(gz,To,SEEK_SET);
 820    else
 821       res = lseek(iFd,To,SEEK_SET);
 822    if (res != (signed)To)
 823    {
 824       Flags |= Fail;
 825       return _error->Error("Unable to seek to %lu",To);
 826    }
 827
 828    return true;
 829 }
 830                                                                         /*}}}*/
 831 // FileFd::Skip - Seek in the file                                      /*{{{*/
 832 // ---------------------------------------------------------------------
 833 /* */
 834 bool FileFd::Skip(unsigned long Over)
 835 {
 836    int res;
 837    if (gz)
 838       res = gzseek(gz,Over,SEEK_CUR);
 839    else
 840       res = lseek(iFd,Over,SEEK_CUR);
 841    if (res < 0)
 842    {
 843       Flags |= Fail;
 844       return _error->Error("Unable to seek ahead %lu",Over);
 845    }
 846
 847    return true;
 848 }
 849                                                                         /*}}}*/
 850 // FileFd::Truncate - Truncate the file                                 /*{{{*/
 851 // ---------------------------------------------------------------------
 852 /* */
 853 bool FileFd::Truncate(unsigned long To)
 854 {
 855    if (gz)
 856    {
 857       Flags |= Fail;
 858       return _error->Error("Truncating gzipped files is not implemented (%s)", FileName.c_str());
 859    }
 860    if (ftruncate(iFd,To) != 0)
 861    {
 862       Flags |= Fail;
 863       return _error->Error("Unable to truncate to %lu",To);
 864    }
 865
 866    return true;
 867 }
 868                                                                         /*}}}*/
 869 // FileFd::Tell - Current seek position                                 /*{{{*/
 870 // ---------------------------------------------------------------------
 871 /* */
 872 unsigned long FileFd::Tell()
 873 {
 874    off_t Res;
 875    if (gz)
 876      Res = gztell(gz);
 877    else
 878      Res = lseek(iFd,0,SEEK_CUR);
 879    if (Res == (off_t)-1)
 880       _error->Errno("lseek","Failed to determine the current file position");
 881    return Res;
 882 }
 883                                                                         /*}}}*/
 884 // FileFd::Size - Return the size of the file                           /*{{{*/
 885 // ---------------------------------------------------------------------
 886 /* */
 887 unsigned long FileFd::Size()
 888 {
 889    //TODO: For gz, do we need the actual file size here or the uncompressed length?
 890    struct stat Buf;
 891    if (fstat(iFd,&Buf) != 0)
 892       return _error->Errno("fstat","Unable to determine the file size");
 893    return Buf.st_size;
 894 }
 895                                                                         /*}}}*/
 896 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
 897 // ---------------------------------------------------------------------
 898 /* */
 899 bool FileFd::Close()
 900 {
 901    bool Res = true;
 902    if ((Flags & AutoClose) == AutoClose)
 903    {
 904       if (gz != NULL) {
 905          int const e = gzclose(gz);
 906          // gzdopen() on empty files always fails with "buffer error" here, ignore that
 907          if (e != 0 && e != Z_BUF_ERROR)
 908             Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
 909       } else
 910          if (iFd > 0 && close(iFd) != 0)
 911             Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
 912    }
 913
 914    if ((Flags & Replace) == Replace && iFd >= 0) {
 915       if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
 916          Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
 917
 918       FileName = TemporaryFileName; // for the unlink() below.
 919    }
 920
 921    iFd = -1;
 922    gz = NULL;
 923
 924    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
 925        FileName.empty() == false)
 926       if (unlink(FileName.c_str()) != 0)
 927          Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
 928
 929
 930    return Res;
 931 }
 932                                                                         /*}}}*/
 933 // FileFd::Sync - Sync the file                                         /*{{{*/
 934 // ---------------------------------------------------------------------
 935 /* */
 936 bool FileFd::Sync()
 937 {
 938 #ifdef _POSIX_SYNCHRONIZED_IO
 939    if (fsync(iFd) != 0)
 940       return _error->Errno("sync",_("Problem syncing the file"));
 941 #endif
 942    return true;
 943 }
 944                                                                         /*}}}*/