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 && WTERMSIG(Status) == SIGSEGV)
 454          return _error->Error(_("Sub-process %s received a segmentation fault."),Name);
 455
 456       if (WIFEXITED(Status) != 0)
 457          return _error->Error(_("Sub-process %s returned an error code (%u)"),Name,WEXITSTATUS(Status));
 458
 459       return _error->Error(_("Sub-process %s exited unexpectedly"),Name);
 460    }
 461
 462    return true;
 463 }
 464                                                                         /*}}}*/
 465
 466 // FileFd::Open - Open a file                                           /*{{{*/
 467 // ---------------------------------------------------------------------
 468 /* The most commonly used open mode combinations are given with Mode */
 469 bool FileFd::Open(string FileName,OpenMode Mode, unsigned long Perms)
 470 {
 471    Close();
 472    Flags = AutoClose;
 473    switch (Mode)
 474    {
 475       case ReadOnly:
 476       iFd = open(FileName.c_str(),O_RDONLY);
 477       break;
 478
 479       case WriteEmpty:
 480       {
 481          struct stat Buf;
 482          if (lstat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
 483             unlink(FileName.c_str());
 484          iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_TRUNC,Perms);
 485          break;
 486       }
 487
 488       case WriteExists:
 489       iFd = open(FileName.c_str(),O_RDWR);
 490       break;
 491
 492       case WriteAny:
 493       iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
 494       break;
 495
 496       case WriteTemp:
 497       unlink(FileName.c_str());
 498       iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_EXCL,Perms);
 499       break;
 500    }
 501
 502    if (iFd < 0)
 503       return _error->Errno("open",_("Could not open file %s"),FileName.c_str());
 504
 505    this->FileName = FileName;
 506    SetCloseExec(iFd,true);
 507    return true;
 508 }
 509                                                                         /*}}}*/
 510 // FileFd::~File - Closes the file                                      /*{{{*/
 511 // ---------------------------------------------------------------------
 512 /* If the proper modes are selected then we close the Fd and possibly
 513    unlink the file on error. */
 514 FileFd::~FileFd()
 515 {
 516    Close();
 517 }
 518                                                                         /*}}}*/
 519 // FileFd::Read - Read a bit of the file                                /*{{{*/
 520 // ---------------------------------------------------------------------
 521 /* We are carefull to handle interruption by a signal while reading
 522    gracefully. */
 523 bool FileFd::Read(void *To,unsigned long Size,unsigned long *Actual)
 524 {
 525    int Res;
 526    errno = 0;
 527    if (Actual != 0)
 528       *Actual = 0;
 529
 530    do
 531    {
 532       Res = read(iFd,To,Size);
 533       if (Res < 0 && errno == EINTR)
 534          continue;
 535       if (Res < 0)
 536       {
 537          Flags |= Fail;
 538          return _error->Errno("read",_("Read error"));
 539       }
 540
 541       To = (char *)To + Res;
 542       Size -= Res;
 543       if (Actual != 0)
 544          *Actual += Res;
 545    }
 546    while (Res > 0 && Size > 0);
 547
 548    if (Size == 0)
 549       return true;
 550
 551    // Eof handling
 552    if (Actual != 0)
 553    {
 554       Flags |= HitEof;
 555       return true;
 556    }
 557
 558    Flags |= Fail;
 559    return _error->Error(_("read, still have %lu to read but none left"),Size);
 560 }
 561                                                                         /*}}}*/
 562 // FileFd::Write - Write to the file                                    /*{{{*/
 563 // ---------------------------------------------------------------------
 564 /* */
 565 bool FileFd::Write(const void *From,unsigned long Size)
 566 {
 567    int Res;
 568    errno = 0;
 569    do
 570    {
 571       Res = write(iFd,From,Size);
 572       if (Res < 0 && errno == EINTR)
 573          continue;
 574       if (Res < 0)
 575       {
 576          Flags |= Fail;
 577          return _error->Errno("write",_("Write error"));
 578       }
 579
 580       From = (char *)From + Res;
 581       Size -= Res;
 582    }
 583    while (Res > 0 && Size > 0);
 584
 585    if (Size == 0)
 586       return true;
 587
 588    Flags |= Fail;
 589    return _error->Error(_("write, still have %lu to write but couldn't"),Size);
 590 }
 591                                                                         /*}}}*/
 592 // FileFd::Seek - Seek in the file                                      /*{{{*/
 593 // ---------------------------------------------------------------------
 594 /* */
 595 bool FileFd::Seek(unsigned long To)
 596 {
 597    if (lseek(iFd,To,SEEK_SET) != (signed)To)
 598    {
 599       Flags |= Fail;
 600       return _error->Error("Unable to seek to %lu",To);
 601    }
 602
 603    return true;
 604 }
 605                                                                         /*}}}*/
 606 // FileFd::Skip - Seek in the file                                      /*{{{*/
 607 // ---------------------------------------------------------------------
 608 /* */
 609 bool FileFd::Skip(unsigned long Over)
 610 {
 611    if (lseek(iFd,Over,SEEK_CUR) < 0)
 612    {
 613       Flags |= Fail;
 614       return _error->Error("Unable to seek ahead %lu",Over);
 615    }
 616
 617    return true;
 618 }
 619                                                                         /*}}}*/
 620 // FileFd::Truncate - Truncate the file                                 /*{{{*/
 621 // ---------------------------------------------------------------------
 622 /* */
 623 bool FileFd::Truncate(unsigned long To)
 624 {
 625    if (ftruncate(iFd,To) != 0)
 626    {
 627       Flags |= Fail;
 628       return _error->Error("Unable to truncate to %lu",To);
 629    }
 630
 631    return true;
 632 }
 633                                                                         /*}}}*/
 634 // FileFd::Tell - Current seek position                                 /*{{{*/
 635 // ---------------------------------------------------------------------
 636 /* */
 637 unsigned long FileFd::Tell()
 638 {
 639    off_t Res = lseek(iFd,0,SEEK_CUR);
 640    if (Res == (off_t)-1)
 641       _error->Errno("lseek","Failed to determine the current file position");
 642    return Res;
 643 }
 644                                                                         /*}}}*/
 645 // FileFd::Size - Return the size of the file                           /*{{{*/
 646 // ---------------------------------------------------------------------
 647 /* */
 648 unsigned long FileFd::Size()
 649 {
 650    struct stat Buf;
 651    if (fstat(iFd,&Buf) != 0)
 652       return _error->Errno("fstat","Unable to determine the file size");
 653    return Buf.st_size;
 654 }
 655                                                                         /*}}}*/
 656 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
 657 // ---------------------------------------------------------------------
 658 /* */
 659 bool FileFd::Close()
 660 {
 661    bool Res = true;
 662    if ((Flags & AutoClose) == AutoClose)
 663       if (iFd >= 0 && close(iFd) != 0)
 664          Res &= _error->Errno("close",_("Problem closing the file"));
 665    iFd = -1;
 666
 667    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
 668        FileName.empty() == false)
 669       if (unlink(FileName.c_str()) != 0)
 670          Res &= _error->WarningE("unlnk",_("Problem unlinking the file"));
 671    return Res;
 672 }
 673                                                                         /*}}}*/
 674 // FileFd::Sync - Sync the file                                         /*{{{*/
 675 // ---------------------------------------------------------------------
 676 /* */
 677 bool FileFd::Sync()
 678 {
 679 #ifdef _POSIX_SYNCHRONIZED_IO
 680    if (fsync(iFd) != 0)
 681       return _error->Errno("sync",_("Problem syncing the file"));
 682 #endif
 683    return true;
 684 }
 685                                                                         /*}}}*/