FileAccess.h

#ifndef __ARC_FILEACCESS_H__
#define __ARC_FILEACCESS_H__

#include <string>
#include <list>

#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>

#include <glibmm.h>


namespace Arc {

  class Run;


  class FileAccess {
  public:
    FileAccess(void);
    ~FileAccess(void);
    static FileAccess* Acquire(void);
    static void Release(FileAccess* fa);
    bool ping(void);

    bool fa_setuid(int uid,int gid);

    bool fa_mkdir(const std::string& path, mode_t mode);

    bool fa_mkdirp(const std::string& path, mode_t mode);

    bool fa_link(const std::string& oldpath, const std::string& newpath);

    bool fa_softlink(const std::string& oldpath, const std::string& newpath);

    bool fa_copy(const std::string& oldpath, const std::string& newpath, mode_t mode);

    bool fa_rename(const std::string& oldpath, const std::string& newpath);

    bool fa_chmod(const std::string& path,mode_t mode);

    bool fa_stat(const std::string& path, struct stat& st);

    bool fa_lstat(const std::string& path, struct stat& st);

    bool fa_fstat(struct stat& st);

    bool fa_ftruncate(off_t length);

    off_t fa_fallocate(off_t length);

    bool fa_readlink(const std::string& path, std::string& linkpath);

    bool fa_remove(const std::string& path);

    bool fa_unlink(const std::string& path);

    bool fa_rmdir(const std::string& path);

    bool fa_rmdirr(const std::string& path);

    bool fa_opendir(const std::string& path);

    bool fa_closedir(void);

    bool fa_readdir(std::string& name);

    bool fa_open(const std::string& path, int flags, mode_t mode);

    bool fa_close(void);

    bool fa_mkstemp(std::string& path, mode_t mode);

    off_t fa_lseek(off_t offset, int whence);

    ssize_t fa_read(void* buf,size_t size);

    ssize_t fa_write(const void* buf,size_t size);

    ssize_t fa_pread(void* buf,size_t size,off_t offset);

    ssize_t fa_pwrite(const void* buf,size_t size,off_t offset);
    int geterrno() { return errno_; };
    operator bool(void) { return (file_access_ != NULL); };
    bool operator!(void) { return (file_access_ == NULL); };
    static void testtune(void);
  private:
    Glib::Mutex lock_;
    Run* file_access_;
    int errno_;
    uid_t uid_;
    gid_t gid_;
  public:
    typedef struct {
      unsigned int size;
      unsigned int cmd;
    } header_t;
  };


  class FileAccessContainer {
  public:
    FileAccessContainer(unsigned int minval, unsigned int maxval);
    FileAccessContainer(void);
    ~FileAccessContainer(void);

    FileAccess* Acquire(void);

    void Release(FileAccess* fa);
    void SetMin(unsigned int val);
    void SetMax(unsigned int val);
  private:
    Glib::Mutex lock_;
    unsigned int min_;
    unsigned int max_;
    std::list<FileAccess*> fas_;
    void KeepRange(void);
  };

} // namespace Arc 

#endif // __ARC_FILEACCESS_H__