apt-pkg/contrib/fileutl.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: fileutl.cc,v 1.17 1999/01/18 06:20:08 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    This source is placed in the Public Domain, do with it what you will
  12    It was originally written by Jason Gunthorpe.
  13
  14    ##################################################################### */
  15                                                                         /*}}}*/
  16 // Include Files                                                        /*{{{*/
  17 #ifdef __GNUG__
  18 #pragma implementation "apt-pkg/fileutl.h"
  19 #endif
  20 #include <apt-pkg/fileutl.h>
  21 #include <apt-pkg/error.h>
  22
  23 #include <unistd.h>
  24 #include <sys/stat.h>
  25 #include <sys/fcntl.h>
  26 #include <sys/types.h>
  27                                                                         /*}}}*/
  28
  29 // CopyFile - Buffered copy of a file                                   /*{{{*/
  30 // ---------------------------------------------------------------------
  31 /* The caller is expected to set things so that failure causes erasure */
  32 bool CopyFile(FileFd &From,FileFd &To)
  33 {
  34    if (From.IsOpen() == false || To.IsOpen() == false)
  35       return false;
  36
  37    // Buffered copy between fds
  38    unsigned char *Buf = new unsigned char[64000];
  39    long Size;
  40    while ((Size = read(From.Fd(),Buf,64000)) > 0)
  41    {
  42       if (To.Write(Buf,Size) == false)
  43       {
  44          delete [] Buf;
  45          return false;
  46       }
  47    }
  48
  49    delete [] Buf;
  50    return true;
  51 }
  52                                                                         /*}}}*/
  53 // GetLock - Gets a lock file                                           /*{{{*/
  54 // ---------------------------------------------------------------------
  55 /* This will create an empty file of the given name and lock it. Once this
  56    is done all other calls to GetLock in any other process will fail with
  57    -1. The return result is the fd of the file, the call should call
  58    close at some time. */
  59 int GetLock(string File,bool Errors)
  60 {
  61    int FD = open(File.c_str(),O_RDWR | O_CREAT | O_TRUNC,0640);
  62    if (FD < 0)
  63    {
  64       if (Errors == true)
  65          _error->Errno("open","Could not open lock file %s",File.c_str());
  66       return -1;
  67    }
  68
  69    // Aquire a write lock
  70    struct flock fl;
  71    fl.l_type= F_WRLCK;
  72    fl.l_whence= SEEK_SET;
  73    fl.l_start= 0;
  74    fl.l_len= 1;
  75    if (fcntl(FD,F_SETLK,&fl) == -1)
  76    {
  77       if (Errors == true)
  78          _error->Errno("open","Could not get lock %s",File.c_str());
  79       close(FD);
  80       return -1;
  81    }
  82
  83    return FD;
  84 }
  85                                                                         /*}}}*/
  86 // FileExists - Check if a file exists                                  /*{{{*/
  87 // ---------------------------------------------------------------------
  88 /* */
  89 bool FileExists(string File)
  90 {
  91    struct stat Buf;
  92    if (stat(File.c_str(),&Buf) != 0)
  93       return false;
  94    return true;
  95 }
  96                                                                         /*}}}*/
  97 // SafeGetCWD - This is a safer getcwd that returns a dynamic string    /*{{{*/
  98 // ---------------------------------------------------------------------
  99 /* We return / on failure. */
 100 string SafeGetCWD()
 101 {
 102    // Stash the current dir.
 103    char S[300];
 104    S[0] = 0;
 105    if (getcwd(S,sizeof(S)-2) == 0)
 106       return "/";
 107    unsigned int Len = strlen(S);
 108    S[Len] = '/';
 109    S[Len+1] = 0;
 110    return S;
 111 }
 112                                                                         /*}}}*/
 113 // flNotDir - Strip the directory from the filename                     /*{{{*/
 114 // ---------------------------------------------------------------------
 115 /* */
 116 string flNotDir(string File)
 117 {
 118    string::size_type Res = File.rfind('/');
 119    if (Res == string::npos)
 120       return File;
 121    Res++;
 122    return string(File,Res,Res - File.length());
 123 }
 124                                                                         /*}}}*/
 125 // flNotFile - Strip the file from the directory name                   /*{{{*/
 126 // ---------------------------------------------------------------------
 127 /* */
 128 string flNotFile(string File)
 129 {
 130    string::size_type Res = File.rfind('/');
 131    if (Res == string::npos)
 132       return File;
 133    Res++;
 134    return string(File,0,Res);
 135 }
 136                                                                         /*}}}*/
 137 // SetCloseExec - Set the close on exec flag                            /*{{{*/
 138 // ---------------------------------------------------------------------
 139 /* */
 140 void SetCloseExec(int Fd,bool Close)
 141 {
 142    if (fcntl(Fd,F_SETFD,(Close == false)?0:FD_CLOEXEC) != 0)
 143    {
 144       cerr << "FATAL -> Could not set close on exec " << strerror(errno) << endl;
 145       exit(100);
 146    }
 147 }
 148                                                                         /*}}}*/
 149 // SetNonBlock - Set the nonblocking flag                               /*{{{*/
 150 // ---------------------------------------------------------------------
 151 /* */
 152 void SetNonBlock(int Fd,bool Block)
 153 {
 154    int Flags = fcntl(Fd,F_GETFL) & (~O_NONBLOCK);
 155    if (fcntl(Fd,F_SETFL,Flags | ((Block == false)?0:O_NONBLOCK)) != 0)
 156    {
 157       cerr << "FATAL -> Could not set non-blocking flag " << strerror(errno) << endl;
 158       exit(100);
 159    }
 160 }
 161                                                                         /*}}}*/
 162 // WaitFd - Wait for a FD to become readable                            /*{{{*/
 163 // ---------------------------------------------------------------------
 164 /* This waits for a FD to become readable using select. It is usefull for
 165    applications making use of non-blocking sockets. */
 166 bool WaitFd(int Fd)
 167 {
 168    fd_set Set;
 169    FD_ZERO(&Set);
 170    FD_SET(Fd,&Set);
 171
 172    if (select(Fd+1,&Set,0,0,0) <= 0)
 173       return false;
 174
 175    return true;
 176 }
 177                                                                         /*}}}*/
 178
 179 // FileFd::FileFd - Open a file                                         /*{{{*/
 180 // ---------------------------------------------------------------------
 181 /* The most commonly used open mode combinations are given with Mode */
 182 FileFd::FileFd(string FileName,OpenMode Mode, unsigned long Perms)
 183 {
 184    Flags = AutoClose;
 185    switch (Mode)
 186    {
 187       case ReadOnly:
 188       iFd = open(FileName.c_str(),O_RDONLY);
 189       break;
 190
 191       case WriteEmpty:
 192       {
 193          struct stat Buf;
 194          if (stat(FileName.c_str(),&Buf) == 0 && S_ISLNK(Buf.st_mode))
 195             unlink(FileName.c_str());
 196          iFd = open(FileName.c_str(),O_RDWR | O_CREAT | O_TRUNC,Perms);
 197          break;
 198       }
 199
 200       case WriteExists:
 201       iFd = open(FileName.c_str(),O_RDWR);
 202       break;
 203
 204       case WriteAny:
 205       iFd = open(FileName.c_str(),O_RDWR | O_CREAT,Perms);
 206       break;
 207    }
 208
 209    if (iFd < 0)
 210       _error->Errno("open","Could not open file %s",FileName.c_str());
 211    else
 212    {
 213       this->FileName = FileName;
 214       SetCloseExec(iFd,true);
 215    }
 216 }
 217                                                                         /*}}}*/
 218 // FileFd::~File - Closes the file                                      /*{{{*/
 219 // ---------------------------------------------------------------------
 220 /* If the proper modes are selected then we close the Fd and possibly
 221    unlink the file on error. */
 222 FileFd::~FileFd()
 223 {
 224    Close();
 225 }
 226                                                                         /*}}}*/
 227 // FileFd::Read - Read a bit of the file                                /*{{{*/
 228 // ---------------------------------------------------------------------
 229 /* */
 230 bool FileFd::Read(void *To,unsigned long Size)
 231 {
 232    if (read(iFd,To,Size) != (signed)Size)
 233    {
 234       Flags |= Fail;
 235       return _error->Errno("read","Read error");
 236    }
 237
 238    return true;
 239 }
 240                                                                         /*}}}*/
 241 // FileFd::Write - Write to the file                                    /*{{{*/
 242 // ---------------------------------------------------------------------
 243 /* */
 244 bool FileFd::Write(const void *From,unsigned long Size)
 245 {
 246    if (write(iFd,From,Size) != (signed)Size)
 247    {
 248       Flags |= Fail;
 249       return _error->Errno("write","Write error");
 250    }
 251
 252    return true;
 253 }
 254                                                                         /*}}}*/
 255 // FileFd::Seek - Seek in the file                                      /*{{{*/
 256 // ---------------------------------------------------------------------
 257 /* */
 258 bool FileFd::Seek(unsigned long To)
 259 {
 260    if (lseek(iFd,To,SEEK_SET) != (signed)To)
 261    {
 262       Flags |= Fail;
 263       return _error->Error("Unable to seek to %u",To);
 264    }
 265
 266    return true;
 267 }
 268                                                                         /*}}}*/
 269 // FileFd::Tell - Current seek position                                 /*{{{*/
 270 // ---------------------------------------------------------------------
 271 /* */
 272 unsigned long FileFd::Tell()
 273 {
 274    off_t Res = lseek(iFd,0,SEEK_CUR);
 275    if (Res == (off_t)-1)
 276       _error->Errno("lseek","Failed to determine the current file position");
 277    return Res;
 278 }
 279                                                                         /*}}}*/
 280 // FileFd::Size - Return the size of the file                           /*{{{*/
 281 // ---------------------------------------------------------------------
 282 /* */
 283 unsigned long FileFd::Size()
 284 {
 285    struct stat Buf;
 286    if (fstat(iFd,&Buf) != 0)
 287       return _error->Errno("fstat","Unable to determine the file size");
 288    return Buf.st_size;
 289 }
 290                                                                         /*}}}*/
 291 // FileFd::Close - Close the file if the close flag is set              /*{{{*/
 292 // ---------------------------------------------------------------------
 293 /* */
 294 bool FileFd::Close()
 295 {
 296    bool Res = true;
 297    if ((Flags & AutoClose) == AutoClose)
 298       if (iFd >= 0 && close(iFd) != 0)
 299          Res &= _error->Errno("close","Problem closing the file");
 300    iFd = -1;
 301
 302    if ((Flags & Fail) == Fail && (Flags & DelOnFail) == DelOnFail &&
 303        FileName.empty() == false)
 304       if (unlink(FileName.c_str()) != 0)
 305          Res &= _error->Warning("unlnk","Problem unlinking the file");
 306    return Res;
 307 }
 308                                                                         /*}}}*/