1                 : // -*- mode: cpp; mode: fold -*-
       2                 : // Description                                                          /*{{{*/
       3                 : // $Id: fileutl.h,v 1.26 2001/05/07 05:06:52 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                 :    FileExists - Returns true if the file exists
      11                 :    SafeGetCWD - Returns the CWD in a string with overrun protection 
      12                 :    
      13                 :    The file class is a handy abstraction for various functions+classes
      14                 :    that need to accept filenames.
      15                 :    
      16                 :    This source is placed in the Public Domain, do with it what you will
      17                 :    It was originally written by Jason Gunthorpe.
      18                 :    
      19                 :    ##################################################################### */
      20                 :                                                                         /*}}}*/
      21                 : #ifndef PKGLIB_FILEUTL_H
      22                 : #define PKGLIB_FILEUTL_H
      23                 : 
      24                 : 
      25                 : #include <string>
      26                 : 
      27                 : using std::string;
      28                 : 
      29                 : class FileFd
      30                 : {
      31                 :    protected:
      32                 :    int iFd;
      33                 :  
      34                 :    enum LocalFlags {AutoClose = (1<<0),Fail = (1<<1),DelOnFail = (1<<2),
      35                 :                     HitEof = (1<<3)};
      36                 :    unsigned long Flags;
      37                 :    string FileName;
      38                 :    
      39                 :    public:
      40                 :    enum OpenMode {ReadOnly,WriteEmpty,WriteExists,WriteAny,WriteTemp};
      41                 :    
      42                 :    inline bool Read(void *To,unsigned long Size,bool AllowEof)
      43                 :    {
      44                 :       unsigned long Jnk;
      45                 :       if (AllowEof)
      46                 :          return Read(To,Size,&Jnk);
      47                 :       return Read(To,Size);
      48                 :    }   
      49                 :    bool Read(void *To,unsigned long Size,unsigned long *Actual = 0);
      50                 :    bool Write(const void *From,unsigned long Size);
      51                 :    bool Seek(unsigned long To);
      52                 :    bool Skip(unsigned long To);
      53                 :    bool Truncate(unsigned long To);
      54                 :    unsigned long Tell();
      55                 :    unsigned long Size();
      56                 :    bool Open(string FileName,OpenMode Mode,unsigned long Perms = 0666);
      57                 :    bool Close();
      58                 :    bool Sync();
      59                 :    
      60                 :    // Simple manipulators
      61                 :    inline int Fd() {return iFd;};
      62                 :    inline void Fd(int fd) {iFd = fd;};
      63              32 :    inline bool IsOpen() {return iFd >= 0;};
      64                 :    inline bool Failed() {return (Flags & Fail) == Fail;};
      65                 :    inline void EraseOnFailure() {Flags |= DelOnFail;};
      66                 :    inline void OpFail() {Flags |= Fail;};
      67                 :    inline bool Eof() {return (Flags & HitEof) == HitEof;};
      68                 :    inline string &Name() {return FileName;};
      69                 :    
      70              53 :    FileFd(string FileName,OpenMode Mode,unsigned long Perms = 0666) : iFd(-1), 
      71              53 :             Flags(0) 
      72                 :    {
      73              53 :       Open(FileName,Mode,Perms);
      74              53 :    };
      75              15 :    FileFd(int Fd = -1) : iFd(Fd), Flags(AutoClose) {};
      76                 :    FileFd(int Fd,bool) : iFd(Fd), Flags(0) {};
      77                 :    virtual ~FileFd();
      78                 : };
      79                 : 
      80                 : bool RunScripts(const char *Cnf);
      81                 : bool CopyFile(FileFd &From,FileFd &To);
      82                 : int GetLock(string File,bool Errors = true);
      83                 : bool FileExists(string File);
      84                 : string SafeGetCWD();
      85                 : void SetCloseExec(int Fd,bool Close);
      86                 : void SetNonBlock(int Fd,bool Block);
      87                 : bool WaitFd(int Fd,bool write = false,unsigned long timeout = 0);
      88                 : pid_t ExecFork();
      89                 : bool ExecWait(pid_t Pid,const char *Name,bool Reap = false);
      90                 : 
      91                 : // File string manipulators
      92                 : string flNotDir(string File);
      93                 : string flNotFile(string File);
      94                 : string flNoLink(string File);
      95                 : string flExtension(string File);
      96                 : string flCombine(string Dir,string File);
      97                 : 
      98                 : #endif