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 WriteEmpty:
 673       {
 674          Flags |= Replace;
 675          char *name = strdup((FileName + ".XXXXXX").c_str());
 676          TemporaryFileName = string(mktemp(name));
 677          iFd = open(TemporaryFileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
 678          free(name);
 679          break;
 680       }
 681
 682       case WriteExists:
 683       iFd = open(FileName.c_str(),O_RDWR);
 684       break;
 685
 686       case WriteAny:
 687       iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
 688       break;
 689
 690       case WriteTemp:
 691       unlink(FileName.c_str());
 692       iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
 693       break;
 694    }
 695
 696    if (iFd < 0)
 697       return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
 698
 699    this->FileName = FileName;
 700    SetCloseExec(iFd,true);
 701    return true;
 702 }
 703                                                                         /*}}}*/
 704 // FileFd::~File - Closes the file                                      /*{{{*/
 705 // ---------------------------------------------------------------------
 706 /* If the proper modes are selected then we close the Fd and possibly
 707    unlink the file on error. */
 708 FileFd::~FileFd()
 709 {
 710    Close();
 711 }
 712                                                                         /*}}}*/
 713 // FileFd::Read - Read a bit of the file                                /*{{{*/
 714 // ---------------------------------------------------------------------
 715 /* We are carefull to handle interruption by a signal while reading
 716    gracefully. */
 717 bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
 718 {
 719    int Res;
 720    errno = 0;
 721    if (Actual != 0)
 722       *Actual = 0;
 723
 724    do
 725    {
 726       if (gz != NULL)
 727          Res = gzread(gz,To,Size);
 728       else
 729          Res = read(iFd,To,Size);
 730       if (Res < 0 && errno == EINTR)
 731          continue;
 732       if (Res < 0)
 733       {
 734          Flags |= Fail;
 735          return _error->Errno("read",_("Read error"));
 736       }
 737
 738       To = (char *)To + Res;
 739       Size -= Res;
 740       if (Actual != 0)
 741          *Actual += Res;
 742    }
 743    while (Res > 0 && Size > 0);
 744
 745    if (Size == 0)
 746       return true;
 747
 748    // Eof handling
 749    if (Actual != 0)
 750    {
 751       Flags |= HitEof;
 752       return true;
 753    }
 754
 755    Flags |= Fail;
 756    return _error->Error(_("read, still have %lu to read but none left"),Size);
 757 }
 758                                                                         /*}}}*/
 759 // FileFd::Write - Write to the file                                    /*{{{*/
 760 // ---------------------------------------------------------------------
 761 /* */
 762 bool FileFd::Write(const void *From,unsigned long Size)
 763 {
 764    int Res;
 765    errno = 0;
 766    do
 767    {
 768       if (gz != NULL)
 769          Res = gzwrite(gz,From,Size);
 770       else
 771          Res = write(iFd,From,Size);
 772       if (Res < 0 && errno == EINTR)
 773          continue;
 774       if (Res < 0)
 775       {
 776          Flags |= Fail;
 777          return _error->Errno("write",_("Write error"));
 778       }
 779
 780       From = (char *)From + Res;
 781       Size -= Res;
 782    }
 783    while (Res > 0 && Size > 0);
 784
 785    if (Size == 0)
 786       return true;
 787
 788    Flags |= Fail;
 789    return _error->Error(_("write, still have %lu to write but couldn't"),Size);
 790 }
 791                                                                         /*}}}*/
 792 // FileFd::Seek - Seek in the file                                      /*{{{*/
 793 // ---------------------------------------------------------------------
 794 /* */
 795 bool FileFd::Seek(unsigned long To)
 796 {
 797    int res;
 798    if (gz)
 799       res = gzseek(gz,To,SEEK_SET);
 800    else
 801       res = lseek(iFd,To,SEEK_SET);
 802    if (res != (signed)To)
 803    {
 804       Flags |= Fail;
 805       return _error->Error("Unable to seek to %lu",To);
 806    }
 807
 808    return true;
 809 }
 810                                                                         /*}}}*/
 811 // FileFd::Skip - Seek in the file                                      /*{{{*/
 812 // ---------------------------------------------------------------------
 813 /* */
 814 bool FileFd::Skip(unsigned long Over)
 815 {
 816    int res;
 817    if (gz)
 818       res = gzseek(gz,Over,SEEK_CUR);
 819    else
 820       res = lseek(iFd,Over,SEEK_CUR);
 821    if (res < 0)
 822    {
 823       Flags |= Fail;
 824       return _error->Error("Unable to seek ahead %lu",Over);
 825    }
 826
 827    return true;
 828 }
 829                                                                         /*}}}*/
 830 // FileFd::Truncate - Truncate the file                                 /*{{{*/
 831 // ---------------------------------------------------------------------
 832 /* */
 833 bool FileFd::Truncate(unsigned long To)
 834 {
 835    if (gz)
 836    {
 837       Flags |= Fail;
 838       return _error->Error("Truncating gzipped files is not implemented (%s)", FileName.c_str());
 839    }
 840    if (ftruncate(iFd,To) != 0)
 841    {
 842       Flags |= Fail;
 843       return _error->Error("Unable to truncate to %lu",To);
 844    }
 845
 846    return true;
 847 }
 848                                                                         /*}}}*/
 849 // FileFd::Tell - Current seek position                                 /*{{{*/
 850 // ---------------------------------------------------------------------
 851 /* */
 852 unsigned long FileFd::Tell()
 853 {
 854    off_t Res;
 855    if (gz)
 856      Res = gztell(gz);
 857    else
 858      Res = lseek(iFd,0,SEEK_CUR);
 859    if (Res == (off_t)-1)
 860       _error->Errno("lseek","Failed to determine the current file position");
 861    return Res;
 862 }
 863                                                                         /*}}}*/
 864 // FileFd::Size - Return the size of the file                           /*{{{*/
 865 // ---------------------------------------------------------------------
 866 /* */
 867 unsigned long FileFd::Size()
 868 {
 869    //TODO: For gz, do we need the actual file size here or the uncompressed length?
 870    struct stat Buf;
 871    if (fstat(iFd,&Buf) != 0)
 872       return _error->Errno("fstat","Unable to determine the file size");
 873    return Buf.st_size;
 874 }
 875                                                                         /*}}}*/
 876 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
 877 // ---------------------------------------------------------------------
 878 /* */
 879 bool FileFd::Close()
 880 {
 881    bool Res = true;
 882    if ((Flags & AutoClose) == AutoClose)
 883    {
 884       if (gz != NULL) {
 885          int const e = gzclose(gz);
 886          // gzdopen() on empty files always fails with "buffer error" here, ignore that
 887          if (e != 0 && e != Z_BUF_ERROR)
 888             Res &= _error->Errno("close",_("Problem closing the gzip file %s"), FileName.c_str());
 889       } else
 890          if (iFd > 0 && close(iFd) != 0)
 891             Res &= _error->Errno("close",_("Problem closing the file %s"), FileName.c_str());
 892    }
 893
 894    if ((Flags & Replace) == Replace && iFd >= 0) {
 895       if (rename(TemporaryFileName.c_str(), FileName.c_str()) != 0)
 896          Res &= _error->Errno("rename",_("Problem renaming the file %s to %s"), TemporaryFileName.c_str(), FileName.c_str());
 897
 898       FileName = TemporaryFileName; // for the unlink() below.
 899    }
 900
 901    iFd = -1;
 902    gz = NULL;
 903
 904    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
 905        FileName.empty() == false)
 906       if (unlink(FileName.c_str()) != 0)
 907          Res &= _error->WarningE("unlnk",_("Problem unlinking the file %s"), FileName.c_str());
 908
 909
 910    return Res;
 911 }
 912                                                                         /*}}}*/
 913 // FileFd::Sync - Sync the file                                         /*{{{*/
 914 // ---------------------------------------------------------------------
 915 /* */
 916 bool FileFd::Sync()
 917 {
 918 #ifdef _POSIX_SYNCHRONIZED_IO
 919    if (fsync(iFd) != 0)
 920       return _error->Errno("sync",_("Problem syncing the file"));
 921 #endif
 922    return true;
 923 }
 924                                                                         /*}}}*/