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
  15    The exception is RunScripts() it is under the GPLv2
  16
  17    ##################################################################### */
  18                                                                         /*}}}*/
  19 // Include Files                                                        /*{{{*/
  20 #include <apt-pkg/fileutl.h>
  21 #include <apt-pkg/error.h>
  22 #include <apt-pkg/sptr.h>
  23 #include <apt-pkg/configuration.h>
  24
  25 #include <apti18n.h>
  26
  27 #include <cstdlib>
  28 #include <cstring>
  29
  30 #include <iostream>
  31 #include <unistd.h>
  32 #include <fcntl.h>
  33 #include <sys/stat.h>
  34 #include <sys/types.h>
  35 #include <sys/time.h>
  36 #include <sys/wait.h>
  37 #include <signal.h>
  38 #include <errno.h>
  39 #include <set>
  40                                                                         /*}}}*/
  41
  42 using namespace std;
  43
  44 // RunScripts - Run a set of scripts from a configuration subtree       /*{{{*/
  45 // ---------------------------------------------------------------------
  46 /* */
  47 bool RunScripts(const char *Cnf)
  48 {
  49    Configuration::Item const *Opts = _config->Tree(Cnf);
  50    if (Opts == 0 || Opts->Child == 0)
  51       return true;
  52    Opts = Opts->Child;
  53
  54    // Fork for running the system calls
  55    pid_t Child = ExecFork();
  56
  57    // This is the child
  58    if (Child == 0)
  59    {
  60       if (chdir("/tmp/") != 0)
  61          _exit(100);
  62
  63       unsigned int Count = 1;
  64       for (; Opts != 0; Opts = Opts->Next, Count++)
  65       {
  66          if (Opts->Value.empty() == true)
  67             continue;
  68
  69          if (system(Opts->Value.c_str()) != 0)
  70             _exit(100+Count);
  71       }
  72       _exit(0);
  73    }
  74
  75    // Wait for the child
  76    int Status = 0;
  77    while (waitpid(Child,&Status,0) != Child)
  78    {
  79       if (errno == EINTR)
  80          continue;
  81       return _error->Errno("waitpid","Couldn't wait for subprocess");
  82    }
  83
  84    // Restore sig int/quit
  85    signal(SIGQUIT,SIG_DFL);
  86    signal(SIGINT,SIG_DFL);
  87
  88    // Check for an error code.
  89    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
  90    {
  91       unsigned int Count = WEXITSTATUS(Status);
  92       if (Count > 100)
  93       {
  94          Count -= 100;
  95          for (; Opts != 0 && Count != 1; Opts = Opts->Next, Count--);
  96          _error->Error("Problem executing scripts %s '%s'",Cnf,Opts->Value.c_str());
  97       }
  98
  99       return _error->Error("Sub-process returned an error code");
 100    }
 101
 102    return true;
 103 }
 104                                                                         /*}}}*/
 105
 106 // CopyFile - Buffered copy of a file                                   /*{{{*/
 107 // ---------------------------------------------------------------------
 108 /* The caller is expected to set things so that failure causes erasure */
 109 bool CopyFile(FileFd &From,FileFd &To)
 110 {
 111    if (From.IsOpen() == false || To.IsOpen() == false)
 112       return false;
 113
 114    // Buffered copy between fds
 115    SPtrArray<unsigned char> Buf = new unsigned char[64000];
 116    unsigned long Size = From.Size();
 117    while (Size != 0)
 118    {
 119       unsigned long ToRead = Size;
 120       if (Size > 64000)
 121          ToRead = 64000;
 122
 123       if (From.Read(Buf,ToRead) == false ||
 124           To.Write(Buf,ToRead) == false)
 125          return false;
 126
 127       Size -= ToRead;
 128    }
 129
 130    return true;
 131 }
 132                                                                         /*}}}*/
 133 // GetLock - Gets a lock file                                           /*{{{*/
 134 // ---------------------------------------------------------------------
 135 /* This will create an empty file of the given name and lock it. Once this
 136    is done all other calls to GetLock in any other process will fail with
 137    -1. The return result is the fd of the file, the call should call
 138    close at some time. */
 139 int GetLock(string File,bool Errors)
 140 {
 141    // GetLock() is used in aptitude on directories with public-write access
 142    // Use O_NOFOLLOW here to prevent symlink traversal attacks
 143    int FD = open(File.c_str(),O_RDWR | O_CREAT | O_NOFOLLOW,0640);
 144    if (FD < 0)
 145    {
 146       // Read only .. cant have locking problems there.
 147       if (errno == EROFS)
 148       {
 149          _error->Warning(_("Not using locking for read only lock file %s"),File.c_str());
 150          return dup(0);       // Need something for the caller to close
 151       }
 152
 153       if (Errors == true)
 154          _error->Errno("open",_("Could not open lock file %s"),File.c_str());
 155
 156       // Feh.. We do this to distinguish the lock vs open case..
 157       errno = EPERM;
 158       return -1;
 159    }
 160    SetCloseExec(FD,true);
 161
 162    // Aquire a write lock
 163    struct flock fl;
 164    fl.l_type = F_WRLCK;
 165    fl.l_whence = SEEK_SET;
 166    fl.l_start = 0;
 167    fl.l_len = 0;
 168    if (fcntl(FD,F_SETLK,&fl) == -1)
 169    {
 170       if (errno == ENOLCK)
 171       {
 172          _error->Warning(_("Not using locking for nfs mounted lock file %s"),File.c_str());
 173          return dup(0);       // Need something for the caller to close
 174       }
 175       if (Errors == true)
 176          _error->Errno("open",_("Could not get lock %s"),File.c_str());
 177
 178       int Tmp = errno;
 179       close(FD);
 180       errno = Tmp;
 181       return -1;
 182    }
 183
 184    return FD;
 185 }
 186                                                                         /*}}}*/
 187 // FileExists - Check if a file exists                                  /*{{{*/
 188 // ---------------------------------------------------------------------
 189 /* */
 190 bool FileExists(string File)
 191 {
 192    struct stat Buf;
 193    if (stat(File.c_str(),&Buf) != 0)
 194       return false;
 195    return true;
 196 }
 197                                                                         /*}}}*/
 198 // SafeGetCWD - This is a safer getcwd that returns a dynamic string    /*{{{*/
 199 // ---------------------------------------------------------------------
 200 /* We return / on failure. */
 201 string SafeGetCWD()
 202 {
 203    // Stash the current dir.
 204    char S[300];
 205    S[0] = 0;
 206    if (getcwd(S,sizeof(S)-2) == 0)
 207       return "/";
 208    unsigned int Len = strlen(S);
 209    S[Len] = '/';
 210    S[Len+1] = 0;
 211    return S;
 212 }
 213                                                                         /*}}}*/
 214 // flNotDir - Strip the directory from the filename                     /*{{{*/
 215 // ---------------------------------------------------------------------
 216 /* */
 217 string flNotDir(string File)
 218 {
 219    string::size_type Res = File.rfind('/');
 220    if (Res == string::npos)
 221       return File;
 222    Res++;
 223    return string(File,Res,Res - File.length());
 224 }
 225                                                                         /*}}}*/
 226 // flNotFile - Strip the file from the directory name                   /*{{{*/
 227 // ---------------------------------------------------------------------
 228 /* Result ends in a / */
 229 string flNotFile(string File)
 230 {
 231    string::size_type Res = File.rfind('/');
 232    if (Res == string::npos)
 233       return "./";
 234    Res++;
 235    return string(File,0,Res);
 236 }
 237                                                                         /*}}}*/
 238 // flExtension - Return the extension for the file                      /*{{{*/
 239 // ---------------------------------------------------------------------
 240 /* */
 241 string flExtension(string File)
 242 {
 243    string::size_type Res = File.rfind('.');
 244    if (Res == string::npos)
 245       return File;
 246    Res++;
 247    return string(File,Res,Res - File.length());
 248 }
 249                                                                         /*}}}*/
 250 // flNoLink - If file is a symlink then deref it                        /*{{{*/
 251 // ---------------------------------------------------------------------
 252 /* If the name is not a link then the returned path is the input. */
 253 string flNoLink(string File)
 254 {
 255    struct stat St;
 256    if (lstat(File.c_str(),&St) != 0 || S_ISLNK(St.st_mode) == 0)
 257       return File;
 258    if (stat(File.c_str(),&St) != 0)
 259       return File;
 260
 261    /* Loop resolving the link. There is no need to limit the number of
 262       loops because the stat call above ensures that the symlink is not
 263       circular */
 264    char Buffer[1024];
 265    string NFile = File;
 266    while (1)
 267    {
 268       // Read the link
 269       int Res;
 270       if ((Res = readlink(NFile.c_str(),Buffer,sizeof(Buffer))) <= 0 ||
 271           (unsigned)Res >= sizeof(Buffer))
 272           return File;
 273
 274       // Append or replace the previous path
 275       Buffer[Res] = 0;
 276       if (Buffer[0] == '/')
 277          NFile = Buffer;
 278       else
 279          NFile = flNotFile(NFile) + Buffer;
 280
 281       // See if we are done
 282       if (lstat(NFile.c_str(),&St) != 0)
 283          return File;
 284       if (S_ISLNK(St.st_mode) == 0)
 285          return NFile;
 286    }
 287 }
 288                                                                         /*}}}*/
 289 // flCombine - Combine a file and a directory                           /*{{{*/
 290 // ---------------------------------------------------------------------
 291 /* If the file is an absolute path then it is just returned, otherwise
 292    the directory is pre-pended to it. */
 293 string flCombine(string Dir,string File)
 294 {
 295    if (File.empty() == true)
 296       return string();
 297
 298    if (File[0] == '/' || Dir.empty() == true)
 299       return File;
 300    if (File.length() >= 2 && File[0] == '.' && File[1] == '/')
 301       return File;
 302    if (Dir[Dir.length()-1] == '/')
 303       return Dir + File;
 304    return Dir + '/' + File;
 305 }
 306                                                                         /*}}}*/
 307 // SetCloseExec - Set the close on exec flag                            /*{{{*/
 308 // ---------------------------------------------------------------------
 309 /* */
 310 void SetCloseExec(int Fd,bool Close)
 311 {
 312    if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
 313    {
 314       cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
 315       exit(100);
 316    }
 317 }
 318                                                                         /*}}}*/
 319 // SetNonBlock - Set the nonblocking flag                               /*{{{*/
 320 // ---------------------------------------------------------------------
 321 /* */
 322 void SetNonBlock(int Fd,bool Block)
 323 {
 324    int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
 325    if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
 326    {
 327       cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
 328       exit(100);
 329    }
 330 }
 331                                                                         /*}}}*/
 332 // WaitFd - Wait for a FD to become readable                            /*{{{*/
 333 // ---------------------------------------------------------------------
 334 /* This waits for a FD to become readable using select. It is useful for
 335    applications making use of non-blocking sockets. The timeout is
 336    in seconds. */
 337 bool WaitFd(int Fd,bool write,unsigned long timeout)
 338 {
 339    fd_set Set;
 340    struct timeval tv;
 341    FD_ZERO(&Set);
 342    FD_SET(Fd,&Set);
 343    tv.tv_sec = timeout;
 344    tv.tv_usec = 0;
 345    if (write == true)
 346    {
 347       int Res;
 348       do
 349       {
 350          Res = select(Fd+1,0,&Set,0,(timeout != 0?&tv:0));
 351       }
 352       while (Res < 0 && errno == EINTR);
 353
 354       if (Res <= 0)
 355          return false;
 356    }
 357    else
 358    {
 359       int Res;
 360       do
 361       {
 362          Res = select(Fd+1,&Set,0,0,(timeout != 0?&tv:0));
 363       }
 364       while (Res < 0 && errno == EINTR);
 365
 366       if (Res <= 0)
 367          return false;
 368    }
 369
 370    return true;
 371 }
 372                                                                         /*}}}*/
 373 // ExecFork - Magical fork that sanitizes the context before execing    /*{{{*/
 374 // ---------------------------------------------------------------------
 375 /* This is used if you want to cleanse the environment for the forked
 376    child, it fixes up the important signals and nukes all of the fds,
 377    otherwise acts like normal fork. */
 378 pid_t ExecFork()
 379 {
 380    // Fork off the process
 381    pid_t Process = fork();
 382    if (Process < 0)
 383    {
 384       cerr << "FATAL -> Failed to fork." << endl;
 385       exit(100);
 386    }
 387
 388    // Spawn the subprocess
 389    if (Process == 0)
 390    {
 391       // Setup the signals
 392       signal(SIGPIPE,SIG_DFL);
 393       signal(SIGQUIT,SIG_DFL);
 394       signal(SIGINT,SIG_DFL);
 395       signal(SIGWINCH,SIG_DFL);
 396       signal(SIGCONT,SIG_DFL);
 397       signal(SIGTSTP,SIG_DFL);
 398
 399       set<int> KeepFDs;
 400       Configuration::Item const *Opts = _config->Tree("APT::Keep-Fds");
 401       if (Opts != 0 && Opts->Child != 0)
 402       {
 403          Opts = Opts->Child;
 404          for (; Opts != 0; Opts = Opts->Next)
 405          {
 406             if (Opts->Value.empty() == true)
 407                continue;
 408             int fd = atoi(Opts->Value.c_str());
 409             KeepFDs.insert(fd);
 410          }
 411       }
 412
 413       // Close all of our FDs - just in case
 414       for (int K = 3; K != 40; K++)
 415       {
 416          if(KeepFDs.find(K) == KeepFDs.end())
 417             fcntl(K,F_SETFD,FD_CLOEXEC);
 418       }
 419    }
 420
 421    return Process;
 422 }
 423                                                                         /*}}}*/
 424 // ExecWait - Fancy waitpid                                             /*{{{*/
 425 // ---------------------------------------------------------------------
 426 /* Waits for the given sub process. If Reap is set then no errors are
 427    generated. Otherwise a failed subprocess will generate a proper descriptive
 428    message */
 429 bool ExecWait(pid_t Pid,const char *Name,bool Reap)
 430 {
 431    if (Pid <= 1)
 432       return true;
 433
 434    // Wait and collect the error code
 435    int Status;
 436    while (waitpid(Pid,&Status,0) != Pid)
 437    {
 438       if (errno == EINTR)
 439          continue;
 440
 441       if (Reap == true)
 442          return false;
 443
 444       return _error->Error(_("Waited for %s but it wasn't there"),Name);
 445    }
 446
 447
 448    // Check for an error code.
 449    if (WIFEXITED(Status) == 0 || WEXITSTATUS(Status) != 0)
 450    {
 451       if (Reap == true)
 452          return false;
 453       if (WIFSIGNALED(Status) != 0)
 454          if( WTERMSIG(Status) == SIGSEGV)
 455             return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
 456          else
 457             return _error->Error(_("Sub-process %s received signal %u."),Name, WTERMSIG(Status));
 458
 459       if (WIFEXITED(Status) != 0)
 460          return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
 461
 462       return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
 463    }
 464
 465    return true;
 466 }
 467                                                                         /*}}}*/
 468
 469 // FileFd::Open - Open a file                                           /*{{{*/
 470 // ---------------------------------------------------------------------
 471 /* The most commonly used open mode combinations are given with Mode */
 472 bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
 473 {
 474    Close();
 475    Flags = AutoClose;
 476    switch (Mode)
 477    {
 478       case ReadOnly:
 479       iFd = open(FileName.c_str(),O_RDONLY);
 480       break;
 481
 482       case WriteEmpty:
 483       {
 484          struct stat Buf;
 485          if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
 486             unlink(FileName.c_str());
 487          iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_TRUNC,Perms);
 488          break;
 489       }
 490
 491       case WriteExists:
 492       iFd = open(FileName.c_str(),O_RDWR);
 493       break;
 494
 495       case WriteAny:
 496       iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
 497       break;
 498
 499       case WriteTemp:
 500       unlink(FileName.c_str());
 501       iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
 502       break;
 503    }
 504
 505    if (iFd < 0)
 506       return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
 507
 508    this->FileName = FileName;
 509    SetCloseExec(iFd,true);
 510    return true;
 511 }
 512                                                                         /*}}}*/
 513 // FileFd::~File - Closes the file                                      /*{{{*/
 514 // ---------------------------------------------------------------------
 515 /* If the proper modes are selected then we close the Fd and possibly
 516    unlink the file on error. */
 517 FileFd::~FileFd()
 518 {
 519    Close();
 520 }
 521                                                                         /*}}}*/
 522 // FileFd::Read - Read a bit of the file                                /*{{{*/
 523 // ---------------------------------------------------------------------
 524 /* We are carefull to handle interruption by a signal while reading
 525    gracefully. */
 526 bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
 527 {
 528    int Res;
 529    errno = 0;
 530    if (Actual != 0)
 531       *Actual = 0;
 532
 533    do
 534    {
 535       Res = read(iFd,To,Size);
 536       if (Res < 0 && errno == EINTR)
 537          continue;
 538       if (Res < 0)
 539       {
 540          Flags |= Fail;
 541          return _error->Errno("read",_("Read error"));
 542       }
 543
 544       To = (char *)To + Res;
 545       Size -= Res;
 546       if (Actual != 0)
 547          *Actual += Res;
 548    }
 549    while (Res > 0 && Size > 0);
 550
 551    if (Size == 0)
 552       return true;
 553
 554    // Eof handling
 555    if (Actual != 0)
 556    {
 557       Flags |= HitEof;
 558       return true;
 559    }
 560
 561    Flags |= Fail;
 562    return _error->Error(_("read, still have %lu to read but none left"),Size);
 563 }
 564                                                                         /*}}}*/
 565 // FileFd::Write - Write to the file                                    /*{{{*/
 566 // ---------------------------------------------------------------------
 567 /* */
 568 bool FileFd::Write(const void *From,unsigned long Size)
 569 {
 570    int Res;
 571    errno = 0;
 572    do
 573    {
 574       Res = write(iFd,From,Size);
 575       if (Res < 0 && errno == EINTR)
 576          continue;
 577       if (Res < 0)
 578       {
 579          Flags |= Fail;
 580          return _error->Errno("write",_("Write error"));
 581       }
 582
 583       From = (char *)From + Res;
 584       Size -= Res;
 585    }
 586    while (Res > 0 && Size > 0);
 587
 588    if (Size == 0)
 589       return true;
 590
 591    Flags |= Fail;
 592    return _error->Error(_("write, still have %lu to write but couldn't"),Size);
 593 }
 594                                                                         /*}}}*/
 595 // FileFd::Seek - Seek in the file                                      /*{{{*/
 596 // ---------------------------------------------------------------------
 597 /* */
 598 bool FileFd::Seek(unsigned long To)
 599 {
 600    if (lseek(iFd,To,SEEK_SET) != (signed)To)
 601    {
 602       Flags |= Fail;
 603       return _error->Error("Unable to seek to %lu",To);
 604    }
 605
 606    return true;
 607 }
 608                                                                         /*}}}*/
 609 // FileFd::Skip - Seek in the file                                      /*{{{*/
 610 // ---------------------------------------------------------------------
 611 /* */
 612 bool FileFd::Skip(unsigned long Over)
 613 {
 614    if (lseek(iFd,Over,SEEK_CUR) < 0)
 615    {
 616       Flags |= Fail;
 617       return _error->Error("Unable to seek ahead %lu",Over);
 618    }
 619
 620    return true;
 621 }
 622                                                                         /*}}}*/
 623 // FileFd::Truncate - Truncate the file                                 /*{{{*/
 624 // ---------------------------------------------------------------------
 625 /* */
 626 bool FileFd::Truncate(unsigned long To)
 627 {
 628    if (ftruncate(iFd,To) != 0)
 629    {
 630       Flags |= Fail;
 631       return _error->Error("Unable to truncate to %lu",To);
 632    }
 633
 634    return true;
 635 }
 636                                                                         /*}}}*/
 637 // FileFd::Tell - Current seek position                                 /*{{{*/
 638 // ---------------------------------------------------------------------
 639 /* */
 640 unsigned long FileFd::Tell()
 641 {
 642    off_t Res = lseek(iFd,0,SEEK_CUR);
 643    if (Res == (off_t)-1)
 644       _error->Errno("lseek","Failed to determine the current file position");
 645    return Res;
 646 }
 647                                                                         /*}}}*/
 648 // FileFd::Size - Return the size of the file                           /*{{{*/
 649 // ---------------------------------------------------------------------
 650 /* */
 651 unsigned long FileFd::Size()
 652 {
 653    struct stat Buf;
 654    if (fstat(iFd,&Buf) != 0)
 655       return _error->Errno("fstat","Unable to determine the file size");
 656    return Buf.st_size;
 657 }
 658                                                                         /*}}}*/
 659 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
 660 // ---------------------------------------------------------------------
 661 /* */
 662 bool FileFd::Close()
 663 {
 664    bool Res = true;
 665    if ((Flags & AutoClose) == AutoClose)
 666       if (iFd >= 0 && close(iFd) != 0)
 667          Res &= _error->Errno("close",_("Problem closing the file"));
 668    iFd = -1;
 669
 670    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
 671        FileName.empty() == false)
 672       if (unlink(FileName.c_str()) != 0)
 673          Res &= _error->WarningE("unlnk",_("Problem unlinking the file"));
 674    return Res;
 675 }
 676                                                                         /*}}}*/
 677 // FileFd::Sync - Sync the file                                         /*{{{*/
 678 // ---------------------------------------------------------------------
 679 /* */
 680 bool FileFd::Sync()
 681 {
 682 #ifdef _POSIX_SYNCHRONIZED_IO
 683    if (fsync(iFd) != 0)
 684       return _error->Errno("sync",_("Problem syncing the file"));
 685 #endif
 686    return true;
 687 }
 688                                                                         /*}}}*/