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