diff options
58 files changed, 1628 insertions, 1652 deletions
diff --git a/netfs/Jamfile.jam b/netfs/Jamfile.jam index 7ed27fa..3bfc849 100644 --- a/netfs/Jamfile.jam +++ b/netfs/Jamfile.jam @@ -15,97 +15,8 @@ lib IceBox : : <name>IceBox ; lib pthread : : <name>pthread ; lib fuse : : <name>fuse ; -lib netfsComms : - netfsComms.ice : - <library>Ice - <library>IceUtil - <library>pthread - ; - -lib netfsCommon : - pchCommon - entCache.cpp ../libmisc/xml.cpp : - <define>_FILE_OFFSET_BITS=64 - <include>../libmisc - <library>libxml2 - <library>netfsComms - <library>boost_thread - <library>boost_system - <library>Ice - <library>IceUtil - ; - -cpp-pch pchFuse : pchCommon pchFuse.hpp : - <define>_FILE_OFFSET_BITS=64 - <include>../libmisc - <include>../libfusepp - <implicit-dependency>netfsComms - <library>netfsComms - <library>boost_thread - <library>fuse - <library>Ice - <library>libxml2 - ; - -cpp-pch pchDaemon : pchCommon pchDaemon.hpp : - <define>_FILE_OFFSET_BITS=64 - <include>../libmisc - <implicit-dependency>netfsComms - <library>netfsComms - <library>boost_thread - <library>Ice - <library>libxml2 - ; - -cpp-pch pchCommon : pchCommon.hpp : - <define>_FILE_OFFSET_BITS=64 - <include>../libmisc - <implicit-dependency>netfsComms - <library>netfsComms - <library>boost_thread - <library>fuse - <library>Ice - <library>libxml2 - ; - -exe netfs : - pchFuse - [ glob fuse*.cpp ] - [ glob ../libfusepp/fuse*.cpp ] - : - <define>_FILE_OFFSET_BITS=64 - <include>../libmisc - <include>../libfusepp - <implicit-dependency>netfsComms - <library>netfsComms - <library>netfsCommon - <library>boost_thread - <library>boost_system - <library>fuse - <library>Ice - <library>IceUtil - <library>pthread - <library>libxml2 - ; - -lib netfsd : - pchDaemon - [ glob daemon*.cpp ] - : - <define>_FILE_OFFSET_BITS=64 - <include>../libmisc - <implicit-dependency>netfsComms - <library>netfsComms - <library>netfsCommon - <library>boost_random - <library>boost_thread - <library>boost_filesystem - <library>boost_system - <library>Ice - <library>IceUtil - <library>IceBox - <library>libxml2 - ; +build-project daemon ; +build-project fuse ; explicit install ; package.install install : : netfs : netfsd ; diff --git a/netfs/daemon.cpp b/netfs/daemon.cpp deleted file mode 100644 index 65b9d4e..0000000 --- a/netfs/daemon.cpp +++ /dev/null @@ -1,163 +0,0 @@ -#include "pchDaemon.hpp" -#include <Ice/Ice.h> -#include <boost/foreach.hpp> -#include <boost/crc.hpp> -#include "daemon.h" -#include "daemonConfig.h" -#include "daemonFileSystem.h" -#include "daemonService.h" - -int16_t -makeHostID() -{ - char buf[128]; - gethostname(buf, sizeof(buf)); - boost::crc_basic<16> crc_ccitt1( 0x1021, 0xFFFF, 0, false, false ); - crc_ccitt1.process_bytes(buf, sizeof(buf)); - return crc_ccitt1.checksum(); -} - -// name = NetFSDaemonAdapter -void -NetFSDaemon::start(const std::string & name, const Ice::CommunicatorPtr & ic, const Ice::StringSeq&) -{ - Ice::PropertiesPtr props = ic->getProperties(); - dc = DaemonConfig::Load(props->getProperty("NetFSD.ConfigPath")); - dgs = new DaemonGlobalState(dc); - - int16_t hostseed = makeHostID(); - adapter = ic->createObjectAdapterWithEndpoints(name, dc->self->iceEndpoint); - adapter->add(new FileSystemServer(dgs), ic->stringToIdentity("FileSystem")); - adapter->add(new ServiceServer(hostseed, dgs), ic->stringToIdentity("Service")); - adapter->activate(); -} - -void -NetFSDaemon::stop() -{ - adapter->deactivate(); -} - -extern "C" { - IceBox::Service * - createNetFSDaemon(Ice::CommunicatorPtr) - { - return new NetFSDaemon(); - } -} - -DaemonGlobalState::DaemonGlobalState(DaemonConfigPtr c) : - config(c) -{ -} - -DaemonGlobalState::NSP -DaemonGlobalState::newSession(int16_t hostseed, const std::string & ex) -{ - boost::lock_guard<boost::mutex> lg(lock); - DaemonConfig::ExportMap::iterator e = config->exports.find(ex); - if (e == config->exports.end()) { - throw NetFSComms::ConfigError(); - } - SP s = new Session(hostseed, e->second); - while (Ice::Long tok = random()) { - if (sessions.find(tok) == sessions.end()) { - sessions[tok] = s; - return NSP(tok, s); - } - } - throw NetFSComms::AuthError(); -} - -DaemonGlobalState::SP -DaemonGlobalState::getSession(Ice::Long tok) const -{ - boost::lock_guard<boost::mutex> lg(lock); - Sessions::const_iterator s = sessions.find(tok); - if (s != sessions.end()) { - return s->second; - } - throw NetFSComms::AuthError(); -} - -void -DaemonGlobalState::endSession(Ice::Long tok) -{ - boost::lock_guard<boost::mutex> lg(lock); - sessions.erase(tok); -} - -DaemonGlobalState::Session::Session(int16_t hostseed, DaemonConfig::ExportPtr ex) : - dirs(hostseed), - files(hostseed), - exportCfg(ex) -{ -} - -DaemonGlobalState::Session::~Session() -{ -} - -SessionPtr::SessionPtr(boost::intrusive_ptr<DaemonGlobalState::Session> s, bool lock) : - ptr(s), - doUnlock(lock) -{ - if (lock) { - ptr->lock.lock(); - } -} - -SessionPtr::~SessionPtr() -{ - if (doUnlock) { - ptr->lock.unlock(); - } -} - -void -SessionPtr::lock() const -{ - ptr->lock.lock(); - doUnlock = true; -} - -void -SessionPtr::unlock() const -{ - ptr->lock.unlock(); - doUnlock = false; -} - -DaemonGlobalState::Session * -SessionPtr::operator->() const -{ - return ptr.get(); -} - -TempPrivs::TempPrivs(uid_t u, gid_t g) : - myu(u), oldu(geteuid()), - myg(g), oldg(getegid()) -{ - if (setegid(myg)) - throw NetFSComms::SystemError(errno); - if (seteuid(myu)) - throw NetFSComms::SystemError(errno); -} - -TempPrivs::TempPrivs(const NetFSComms::ReqEnv & re, const UserEntCache * uec, const GroupEntCache * gec) : - myu(uec->getID(re.user)), oldu(geteuid()), - myg(gec->getID(re.grp)), oldg(getegid()) -{ - if (setegid(myg)) - throw NetFSComms::SystemError(errno); - if (seteuid(myu)) - throw NetFSComms::SystemError(errno); -} - -TempPrivs::~TempPrivs() -{ - if (seteuid(oldu)) - throw NetFSComms::SystemError(errno); - if (setegid(oldg)) - throw NetFSComms::SystemError(errno); -} diff --git a/netfs/daemon.h b/netfs/daemon.h deleted file mode 100644 index 1f4fc64..0000000 --- a/netfs/daemon.h +++ /dev/null @@ -1,82 +0,0 @@ -#ifndef DAEMON_H -#define DAEMON_H - -#include <Ice/Ice.h> -#include <IceBox/IceBox.h> -#include <boost/thread/locks.hpp> -#include <boost/thread/mutex.hpp> -#include <boost/tuple/tuple.hpp> -#include <boost/nondet_random.hpp> -#include "daemonConfig.h" -#include "netfsComms.h" -#include "entCache.h" -#include "guidmap.h" -#include <dirent.h> - -class DaemonGlobalState : public IntrusivePtrBase { - public: - DaemonGlobalState(DaemonConfigPtr c); - class Session : public IntrusivePtrBase { - public: - Session(int16_t hostseed, DaemonConfig::ExportPtr exportCfg); - ~Session(); - - GUIDMapImpl<DIR*, closedir> dirs; - GUIDMapImpl<int, close> files; - - boost::mutex lock; - DaemonConfig::ExportPtr exportCfg; - }; - - typedef boost::intrusive_ptr<Session> SP; - typedef boost::tuple<Ice::Long, SP> NSP; - NSP newSession(int16_t hostseed, const std::string & ex); - SP getSession(Ice::Long tok) const; - void endSession(Ice::Long tok); - - const DaemonConfigPtr config; - private: - typedef std::map<Ice::Long, SP> Sessions; - Sessions sessions; - mutable boost::mutex lock; - boost::random_device random; -}; -typedef boost::intrusive_ptr<DaemonGlobalState> DaemonGlobalStatePtr; - -class NetFSDaemon : public IceBox::Service { - public: - virtual void start(const std::string&, const Ice::CommunicatorPtr&, const Ice::StringSeq&); - virtual void stop(); - private: - Ice::ObjectAdapterPtr adapter; - DaemonConfigPtr dc; - DaemonGlobalStatePtr dgs; -}; - -class SessionPtr { - public: - SessionPtr(boost::intrusive_ptr<DaemonGlobalState::Session> ptr, bool lock); - ~SessionPtr(); - - DaemonGlobalState::Session * operator->() const; - - void lock() const; - void unlock() const; - private: - const boost::intrusive_ptr<DaemonGlobalState::Session> ptr; - mutable bool doUnlock; -}; - -class TempPrivs { - public: - TempPrivs(uid_t u, gid_t g); - TempPrivs(const NetFSComms::ReqEnv & re, const UserEntCache * uec, const GroupEntCache * gec); - virtual ~TempPrivs(); - - private: - const uid_t myu, oldu; - const gid_t myg, oldg; -}; - -#endif - diff --git a/netfs/daemon/Jamfile.jam b/netfs/daemon/Jamfile.jam new file mode 100644 index 0000000..1ea5dca --- /dev/null +++ b/netfs/daemon/Jamfile.jam @@ -0,0 +1,31 @@ +cpp-pch pch : pch.hpp : + <define>_FILE_OFFSET_BITS=64 + <include>../../libmisc + <implicit-dependency>../ice//netfsComms + <library>../ice//netfsComms + <library>../lib//netfsCommon + <library>..//boost_thread + <library>..//Ice + <library>..//libxml2 + ; + +lib netfsd : + pch + [ glob *.cpp ] + : + <define>_FILE_OFFSET_BITS=64 + <include>../libmisc + <implicit-dependency>../ice//netfsComms + <library>../ice//netfsComms + <library>../lib//netfsCommon + <library>..//boost_random + <library>..//boost_thread + <library>..//boost_filesystem + <library>..//boost_system + <library>..//Ice + <library>..//IceUtil + <library>..//IceBox + <library>..//libxml2 + ; + + diff --git a/netfs/daemon/daemon.cpp b/netfs/daemon/daemon.cpp new file mode 100644 index 0000000..0cbe2ad --- /dev/null +++ b/netfs/daemon/daemon.cpp @@ -0,0 +1,73 @@ +#include "pch.hpp" +#include <Ice/Ice.h> +#include <boost/foreach.hpp> +#include <boost/crc.hpp> +#include "daemon.h" +#include "daemonConfig.h" +#include "daemonService.h" +#include "daemonVolume.h" + +int16_t +makeHostID() +{ + char buf[128]; + gethostname(buf, sizeof(buf)); + boost::crc_basic<16> crc_ccitt1( 0x1021, 0xFFFF, 0, false, false ); + crc_ccitt1.process_bytes(buf, sizeof(buf)); + return crc_ccitt1.checksum(); +} + +// name = NetFSDaemonAdapter +void +NetFSDaemon::start(const std::string & name, const Ice::CommunicatorPtr & ic, const Ice::StringSeq&) +{ + Ice::PropertiesPtr props = ic->getProperties(); + dc = DaemonConfig::Load(props->getProperty("NetFSD.ConfigPath")); + + int16_t hostseed = makeHostID(); + adapter = ic->createObjectAdapterWithEndpoints(name, dc->self->iceEndpoint); + adapter->add(new ServiceServer(hostseed, dc), ic->stringToIdentity("Service")); + adapter->activate(); +} + +void +NetFSDaemon::stop() +{ + adapter->deactivate(); +} + +extern "C" { + IceBox::Service * + createNetFSDaemon(Ice::CommunicatorPtr) + { + return new NetFSDaemon(); + } +} + +TempPrivs::TempPrivs(uid_t u, gid_t g) : + myu(u), oldu(geteuid()), + myg(g), oldg(getegid()) +{ + if (setegid(myg)) + throw NetFS::SystemError(errno); + if (seteuid(myu)) + throw NetFS::SystemError(errno); +} + +TempPrivs::TempPrivs(const NetFS::ReqEnv & re, const UserEntCache * uec, const GroupEntCache * gec) : + myu(uec->getID(re.user)), oldu(geteuid()), + myg(gec->getID(re.grp)), oldg(getegid()) +{ + if (setegid(myg)) + throw NetFS::SystemError(errno); + if (seteuid(myu)) + throw NetFS::SystemError(errno); +} + +TempPrivs::~TempPrivs() +{ + if (seteuid(oldu)) + throw NetFS::SystemError(errno); + if (setegid(oldg)) + throw NetFS::SystemError(errno); +} diff --git a/netfs/daemon/daemon.h b/netfs/daemon/daemon.h new file mode 100644 index 0000000..385dbb3 --- /dev/null +++ b/netfs/daemon/daemon.h @@ -0,0 +1,39 @@ +#ifndef DAEMON_H +#define DAEMON_H + +#include <Ice/Ice.h> +#include <IceBox/IceBox.h> +#include <boost/thread/locks.hpp> +#include <boost/thread/mutex.hpp> +#include <boost/tuple/tuple.hpp> +#include <boost/nondet_random.hpp> +#include "daemonConfig.h" +#include <types.h> +#include <volume.h> +#include <entCache.h> +#include "guidmap.h" +#include <dirent.h> + +class NetFSDaemon : public IceBox::Service { + public: + virtual void start(const std::string&, const Ice::CommunicatorPtr&, const Ice::StringSeq&); + virtual void stop(); + + private: + Ice::ObjectAdapterPtr adapter; + DaemonConfigPtr dc; +}; + +class TempPrivs { + public: + TempPrivs(uid_t u, gid_t g); + TempPrivs(const NetFS::ReqEnv & re, const UserEntCache * uec, const GroupEntCache * gec); + virtual ~TempPrivs(); + + private: + const uid_t myu, oldu; + const gid_t myg, oldg; +}; + +#endif + diff --git a/netfs/daemonConfig.cpp b/netfs/daemon/daemonConfig.cpp index 0d05c44..7f171eb 100644 --- a/netfs/daemonConfig.cpp +++ b/netfs/daemon/daemonConfig.cpp @@ -1,4 +1,4 @@ -#include "pchDaemon.hpp" +#include "pch.hpp" #include "daemonConfig.h" #include <string.h> diff --git a/netfs/daemonConfig.h b/netfs/daemon/daemonConfig.h index f27aedb..f27aedb 100644 --- a/netfs/daemonConfig.h +++ b/netfs/daemon/daemonConfig.h diff --git a/netfs/daemon/daemonDirectory.cpp b/netfs/daemon/daemonDirectory.cpp new file mode 100644 index 0000000..f679653 --- /dev/null +++ b/netfs/daemon/daemonDirectory.cpp @@ -0,0 +1,41 @@ +#include "pch.hpp" +#include <dirent.h> +#include <errno.h> +#include <map> +#include <sys/stat.h> +#include <sys/types.h> +#include "daemonDirectory.h" + +DirectoryServer::DirectoryServer(DIR * d) : + od(d) +{ +} + +DirectoryServer::~DirectoryServer() +{ +} + +void +DirectoryServer::close(const Ice::Current & ice) +{ + errno = 0; + if (::closedir(od) != 0) { + throw NetFS::SystemError(errno); + } + ice.adapter->remove(ice.id); +} + +NetFS::NameList +DirectoryServer::readdir(const Ice::Current&) +{ + errno = 0; + NetFS::NameList list; + while (dirent * d = ::readdir(od)) { + if (errno) { + throw NetFS::SystemError(errno); + } + list.push_back(d->d_name); + } + return list; +} + diff --git a/netfs/daemon/daemonDirectory.h b/netfs/daemon/daemonDirectory.h new file mode 100644 index 0000000..c1ef3c6 --- /dev/null +++ b/netfs/daemon/daemonDirectory.h @@ -0,0 +1,22 @@ +#ifndef DAEMONDIRECTORY_H +#define DAEMONDIRECTORY_H + +#include <directory.h> +#include "entCache.h" + +class DirectoryServer : public NetFS::Directory { + public: + DirectoryServer(DIR * od); + virtual ~DirectoryServer(); + + virtual void close(const Ice::Current&) override; + virtual NetFS::NameList readdir(const Ice::Current&) override; + + private: + DIR * od; +}; + +#endif + + + diff --git a/netfs/daemon/daemonFile.cpp b/netfs/daemon/daemonFile.cpp new file mode 100644 index 0000000..0b94787 --- /dev/null +++ b/netfs/daemon/daemonFile.cpp @@ -0,0 +1,75 @@ +#include "pch.hpp" +#include <errno.h> +#include <map> +#include <fcntl.h> +#include <typeConvert.h> +#include <sys/stat.h> +#include "daemonFile.h" + +FileServer::FileServer(int f) : + fd(f) +{ +} + +FileServer::~FileServer() +{ +} + +void +FileServer::ftruncate(const NetFS::ReqEnv & re, Ice::Long size, const Ice::Current&) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + if (::ftruncate(fd, size) != 0) { + throw NetFS::SystemError(errno); + } +} + +NetFS::Attr +FileServer::fgetattr(const NetFS::ReqEnv & re, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + struct stat s; + if (::fstat(fd, &s) != 0) { + throw NetFS::SystemError(errno); + } + NetFS::Attr a; + a << StatSource { s, boost::bind(&UserEntCache::getName, &uentries, _1), boost::bind(&GroupEntCache::getName, &gentries, _1) }; + return a; +} + +void +FileServer::close(const Ice::Current & ice) +{ + errno = 0; + if (::close(fd) != 0) { + throw NetFS::SystemError(errno); + } + ice.adapter->remove(ice.id); +} + +NetFS::Buffer +FileServer::read(Ice::Long offset, Ice::Long size, const Ice::Current&) +{ + NetFS::Buffer buf; + buf.resize(size); + errno = 0; + int r = pread(fd, &buf[0], size, offset); + if (r == -1) { + throw NetFS::SystemError(errno); + } + else if (r != size) { + buf.resize(r); + } + return buf; +} + +void +FileServer::write(Ice::Long offset, Ice::Long size, const NetFS::Buffer & data, const Ice::Current&) +{ + errno = 0; + if (pwrite(fd, &data.front(), size, offset) != size) { + throw NetFS::SystemError(errno); + } +} + diff --git a/netfs/daemon/daemonFile.h b/netfs/daemon/daemonFile.h new file mode 100644 index 0000000..9f170e4 --- /dev/null +++ b/netfs/daemon/daemonFile.h @@ -0,0 +1,28 @@ +#ifndef DAEMONFILE_H +#define DAEMONFILE_H + +#include <file.h> +#include "entCache.h" + +class FileServer : public NetFS::File { + public: + FileServer(int fd); + virtual ~FileServer(); + + virtual void close(const Ice::Current&) override; + virtual void ftruncate(const NetFS::ReqEnv &, Ice::Long size, const Ice::Current&) override; + virtual NetFS::Attr fgetattr(const NetFS::ReqEnv &, const Ice::Current&) override; + + virtual NetFS::Buffer read(Ice::Long offset, Ice::Long size, const Ice::Current&) override; + virtual void write(Ice::Long offset, Ice::Long size, const NetFS::Buffer & data, const Ice::Current&) override; + + private: + const int fd; + + UserEntCache uentries; + GroupEntCache gentries; +}; + +#endif + + diff --git a/netfs/daemon/daemonService.cpp b/netfs/daemon/daemonService.cpp new file mode 100644 index 0000000..024e5a5 --- /dev/null +++ b/netfs/daemon/daemonService.cpp @@ -0,0 +1,21 @@ +#include "pch.hpp" +#include "daemonService.h" +#include "daemonVolume.h" + +ServiceServer::ServiceServer(int16_t hs, DaemonConfigPtr c) : + config(c), + hostseed(hs) +{ +} + +NetFS::VolumePrx +ServiceServer::connect(const std::string & share, const std::string &, const Ice::Current & ice) +{ + //boost::lock_guard<boost::mutex> lg(lock); + DaemonConfig::ExportMap::iterator e = config->exports.find(share); + if (e == config->exports.end()) { + throw NetFS::ConfigError(); + } + return NetFS::VolumePrx::checkedCast(ice.adapter->addWithUUID(new VolumeServer(e->second->root))); +} + diff --git a/netfs/daemon/daemonService.h b/netfs/daemon/daemonService.h new file mode 100644 index 0000000..5618c84 --- /dev/null +++ b/netfs/daemon/daemonService.h @@ -0,0 +1,18 @@ +#ifndef DAEMONSERVICE_H +#define DAEMONSERVICE_H + +#include <service.h> + +class ServiceServer : public NetFS::Service { + public: + ServiceServer(int16_t hostseed, DaemonConfigPtr c); + + virtual NetFS::VolumePrx connect(const std::string & share, const std::string & auth, const Ice::Current&) override; + + private: + DaemonConfigPtr config; + const int16_t hostseed; +}; + +#endif + diff --git a/netfs/daemon/daemonVolume.cpp b/netfs/daemon/daemonVolume.cpp new file mode 100644 index 0000000..b87958b --- /dev/null +++ b/netfs/daemon/daemonVolume.cpp @@ -0,0 +1,243 @@ +#include "pch.hpp" +#include <errno.h> +#include <map> +#include <unistd.h> +#include <sys/stat.h> +#include <limits.h> +#include <fcntl.h> +#include <typeConvert.h> +#include "daemonVolume.h" +#include "daemonFile.h" +#include "daemonDirectory.h" + +extern std::map<Ice::Int, int> files; + +VolumeServer::VolumeServer(const boost::filesystem::path & r) : + root(r) +{ +} + +VolumeServer::~VolumeServer() +{ +} + +void +VolumeServer::disconnect(const Ice::Current & ice) +{ + ice.adapter->remove(ice.id); +} + +Ice::Int +VolumeServer::access(const NetFS::ReqEnv & re, const std::string & path, Ice::Int mode, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + boost::filesystem::path p = root / path; + return ::access(p.string().c_str(), mode); +} + +NetFS::Attr +VolumeServer::getattr(const NetFS::ReqEnv & re, const std::string & path, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + struct stat s; + boost::filesystem::path p = root / path; + if (::lstat(p.string().c_str(), &s) != 0) { + throw NetFS::SystemError(errno); + } + NetFS::Attr a; + a << StatSource { s, boost::bind(&UserEntCache::getName, &uentries, _1), boost::bind(&GroupEntCache::getName, &gentries, _1) }; + return a; +} + +void +VolumeServer::symlink(const NetFS::ReqEnv & re, const std::string & path1, const std::string & path2, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path2; + if (::symlink(path1.c_str(), p.string().c_str()) != 0) { + throw NetFS::SystemError(errno); + } +} + +void +VolumeServer::link(const NetFS::ReqEnv & re, const std::string & path1, const std::string & path2, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p1 = root / path1; + boost::filesystem::path p2 = root / path2; + if (::link(p1.string().c_str(), p2.string().c_str()) != 0) { + throw NetFS::SystemError(errno); + } +} + +void +VolumeServer::rename(const NetFS::ReqEnv & re, const std::string & from, const std::string & to, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path f = root / from; + boost::filesystem::path t = root / to; + if (::rename(f.string().c_str(), t.string().c_str()) != 0) { + throw NetFS::SystemError(errno); + } +} + +std::string +VolumeServer::readlink(const NetFS::ReqEnv & re, const std::string & path, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + char buf[PATH_MAX]; + boost::filesystem::path p = root / path; + ssize_t rc = ::readlink(p.string().c_str(), buf, PATH_MAX); + if (rc == -1) { + throw NetFS::SystemError(errno); + } + return std::string(buf, rc); +} + +void +VolumeServer::chmod(const NetFS::ReqEnv & re, const std::string & path, Ice::Int mode, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + if (::chmod(p.string().c_str(), mode) != 0) { + throw NetFS::SystemError(errno); + } +} + +void +VolumeServer::chown(const NetFS::ReqEnv & re, const std::string & path, Ice::Int uid, Ice::Int gid, const Ice::Current &) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + if (::lchown(p.string().c_str(), uid, gid) != 0) { + throw NetFS::SystemError(errno); + } +} + +void +VolumeServer::utimens(const NetFS::ReqEnv & re, const std::string & path, + Ice::Long s0, Ice::Long ns0, Ice::Long s1, Ice::Long ns1, const Ice::Current&) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + struct timespec times[2]; + times[0].tv_sec = s0; + times[0].tv_nsec = ns0; + times[1].tv_sec = s1; + times[1].tv_nsec = ns1; + boost::filesystem::path p = root / path; + if (::utimensat(0, p.string().c_str(), times, AT_SYMLINK_NOFOLLOW) != 0) { + throw NetFS::SystemError(errno); + } +} + +NetFS::VFS +VolumeServer::statfs(const NetFS::ReqEnv & re, const std::string & path, const Ice::Current&) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + struct statvfs s; + boost::filesystem::path p = root / path; + if (::statvfs(p.string().c_str(), &s) != 0) { + throw NetFS::SystemError(errno); + } + NetFS::VFS t; + t << s; + return t; +} + +void +VolumeServer::truncate(const NetFS::ReqEnv & re, const std::string & path, Ice::Long size, const Ice::Current&) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + if (::truncate(p.string().c_str(), size) != 0) { + throw NetFS::SystemError(errno); + } +} + +void +VolumeServer::unlink(const NetFS::ReqEnv & re, const std::string & path, const Ice::Current&) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + if (::unlink(p.string().c_str()) != 0) { + throw NetFS::SystemError(errno); + } +} + +NetFS::ReadOnlyFilePrx +VolumeServer::openReadOnly(const NetFS::ReqEnv & re, const std::string & path, Ice::Int flags, const Ice::Current & ice) +{ + return open(re, path, flags, ice); +} + +NetFS::FilePrx +VolumeServer::open(const NetFS::ReqEnv & re, const std::string & path, Ice::Int flags, const Ice::Current & ice) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + int fd = ::open(p.string().c_str(), flags); + if (fd == -1) { + throw NetFS::SystemError(errno); + } + return NetFS::FilePrx::checkedCast(ice.adapter->addWithUUID(new FileServer(fd))); +} + +NetFS::FilePrx +VolumeServer::create(const NetFS::ReqEnv & re, const std::string & path, Ice::Int flags, Ice::Int mode, const Ice::Current & ice) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + int fd = ::open(p.string().c_str(), O_CREAT | flags, mode); + if (fd == -1) { + throw NetFS::SystemError(errno); + } + return NetFS::FilePrx::checkedCast(ice.adapter->addWithUUID(new FileServer(fd))); +} + +NetFS::DirectoryPrx +VolumeServer::opendir(const NetFS::ReqEnv & re, const std::string & path, const Ice::Current & ice) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + DIR * od = ::opendir(p.string().c_str()); + if (!od) { + throw NetFS::SystemError(errno); + } + return NetFS::DirectoryPrx::checkedCast(ice.adapter->addWithUUID(new DirectoryServer(od))); +} + +void +VolumeServer::mkdir(const NetFS::ReqEnv & re, const std::string & path, Ice::Int mode, const Ice::Current&) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + if (::mkdir(p.string().c_str(), mode) != 0) { + throw NetFS::SystemError(errno); + } +} + +void +VolumeServer::rmdir(const NetFS::ReqEnv & re, const std::string & path, const Ice::Current&) +{ + TempPrivs tp(re, &uentries, &gentries); + errno = 0; + boost::filesystem::path p = root / path; + if (::rmdir(p.string().c_str()) != 0) { + throw NetFS::SystemError(errno); + } +} + diff --git a/netfs/daemon/daemonVolume.h b/netfs/daemon/daemonVolume.h new file mode 100644 index 0000000..e8a5b72 --- /dev/null +++ b/netfs/daemon/daemonVolume.h @@ -0,0 +1,47 @@ +#ifndef DAEMONVOLUME_H +#define DAEMONVOLUME_H + +#include <volume.h> +#include "entCache.h" + +class VolumeServer : public NetFS::Volume { + public: + VolumeServer(const boost::filesystem::path & root); + virtual ~VolumeServer(); + + virtual NetFS::DirectoryPrx opendir(const NetFS::ReqEnv &, const std::string & path, const Ice::Current&) override; + + virtual void mkdir(const NetFS::ReqEnv &, const std::string & path, Ice::Int id, const Ice::Current&) override; + virtual void rmdir(const NetFS::ReqEnv &, const std::string & path, const Ice::Current&) override; + + virtual void truncate(const NetFS::ReqEnv &, const std::string & path, Ice::Long size, const Ice::Current&) override; + + virtual void unlink(const NetFS::ReqEnv &, const std::string & path, const Ice::Current&) override; + + virtual NetFS::FilePrx open(const NetFS::ReqEnv &, const std::string & path, Ice::Int flags, const Ice::Current&) override; + virtual NetFS::ReadOnlyFilePrx openReadOnly(const NetFS::ReqEnv &, const std::string & path, Ice::Int flags, const Ice::Current&) override; + virtual NetFS::FilePrx create(const NetFS::ReqEnv &, const std::string & path, Ice::Int flags, Ice::Int mode, const Ice::Current&) override; + + virtual NetFS::VFS statfs(const NetFS::ReqEnv &, const std::string & path, const Ice::Current&) override; + + virtual Ice::Int access(const NetFS::ReqEnv &, const std::string & path, Ice::Int mode, const Ice::Current&) override; + virtual NetFS::Attr getattr(const NetFS::ReqEnv &, const std::string & path, const Ice::Current&) override; + virtual void symlink(const NetFS::ReqEnv &, const std::string & path1, const std::string & path2, const Ice::Current&) override; + virtual void link(const NetFS::ReqEnv &, const std::string & path1, const std::string & path2, const Ice::Current&) override; + virtual void rename(const NetFS::ReqEnv &, const std::string & path1, const std::string & path2, const Ice::Current&) override; + virtual std::string readlink(const NetFS::ReqEnv &, const std::string & path, const Ice::Current&) override; + virtual void chmod(const NetFS::ReqEnv &, const std::string & path, Ice::Int mode, const Ice::Current&) override; + virtual void chown(const NetFS::ReqEnv &, const std::string & path, Ice::Int uid, Ice::Int gid, const Ice::Current&) override; + virtual void utimens(const NetFS::ReqEnv &, const std::string & path, Ice::Long, Ice::Long, Ice::Long, Ice::Long, const Ice::Current&) override; + + virtual void disconnect(const Ice::Current&) override; + + private: + const boost::filesystem::path root; + + UserEntCache uentries; + GroupEntCache gentries; +}; + +#endif + diff --git a/netfs/pchDaemon.hpp b/netfs/daemon/pch.hpp index cece5cb..3229655 100644 --- a/netfs/pchDaemon.hpp +++ b/netfs/daemon/pch.hpp @@ -2,7 +2,7 @@ #ifndef NETFS_DAEMON_PCH #define NETFS_DAEMON_PCH -#include "pchCommon.hpp" +#include "../lib/pch.hpp" #include <boost/filesystem/path.hpp> #include "daemon.h" #include <IceBox/IceBox.h> diff --git a/netfs/daemonDirs.cpp b/netfs/daemonDirs.cpp deleted file mode 100644 index 1fb3965..0000000 --- a/netfs/daemonDirs.cpp +++ /dev/null @@ -1,91 +0,0 @@ -#include "pchDaemon.hpp" -#include <dirent.h> -#include <errno.h> -#include <map> -#include <sys/stat.h> -#include <sys/types.h> -#include "daemonFileSystem.h" - -Ice::Int -FileSystemServer::opendir(const NetFSComms::ReqEnv & re, const std::string & path, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - DIR * od = ::opendir(p.string().c_str()); - if (!od) { - throw NetFSComms::SystemError(errno); - } - //s.replicatedRequest = true; - return sess->dirs.store(od); -} - -void -FileSystemServer::closedir(Ice::Long tok, Ice::Int id, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(tok), false); - try { - errno = 0; - if (::closedir(sess->dirs.get(id)) != 0) { - throw NetFSComms::SystemError(errno); - } - sess->dirs.remove(id); - } - catch (GUIDMap::NotFound) { - throw NetFSComms::SystemError(EBADF); - } - //s.replicatedRequest = true; -} - -NetFSComms::NameList -FileSystemServer::readdir(Ice::Long tok, Ice::Int id, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(tok), false); - try { - errno = 0; - dirent * d; - NetFSComms::NameList list; - DIR * dir = sess->dirs.get(id); - while ((d = ::readdir(dir))) { - if (errno) { - throw NetFSComms::SystemError(errno); - } - list.push_back(d->d_name); - } - return list; - } - catch (GUIDMap::NotFound) { - throw NetFSComms::SystemError(EBADF); - } -} - -void -FileSystemServer::mkdir(const NetFSComms::ReqEnv & re, const std::string & path, Ice::Int mode, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::mkdir(p.string().c_str(), mode) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -void -FileSystemServer::rmdir(const NetFSComms::ReqEnv & re, const std::string & path, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::rmdir(p.string().c_str()) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - diff --git a/netfs/daemonFileSystem.cpp b/netfs/daemonFileSystem.cpp deleted file mode 100644 index f0d3546..0000000 --- a/netfs/daemonFileSystem.cpp +++ /dev/null @@ -1,12 +0,0 @@ -#include "pchDaemon.hpp" -#include "daemonFileSystem.h" - -FileSystemServer::FileSystemServer(DaemonGlobalStatePtr dgs) : - DaemonModule(dgs) -{ -} - -FileSystemServer::~FileSystemServer() -{ -} - diff --git a/netfs/daemonFileSystem.h b/netfs/daemonFileSystem.h deleted file mode 100644 index 2950f79..0000000 --- a/netfs/daemonFileSystem.h +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef DAEMONFILESYSTEM_H -#define DAEMONFILESYSTEM_H - -#include "netfsComms.h" -#include "daemonModule.h" -#include "entCache.h" -#include <dirent.h> - -class FileSystemServer : public DaemonModule, public NetFSComms::FileSystem { - public: - FileSystemServer(DaemonGlobalStatePtr dgs); - virtual ~FileSystemServer(); - - virtual Ice::Int opendir(const NetFSComms::ReqEnv &, const std::string & path, const Ice::Current&); - virtual void closedir(Ice::Long tok, Ice::Int id, const Ice::Current&); - virtual NetFSComms::NameList readdir(Ice::Long tok, Ice::Int id, const Ice::Current&); - - virtual void mkdir(const NetFSComms::ReqEnv &, const std::string & path, Ice::Int id, const Ice::Current&); - virtual void rmdir(const NetFSComms::ReqEnv &, const std::string & path, const Ice::Current&); - - virtual void truncate(const NetFSComms::ReqEnv &, const std::string & path, Ice::Long size, const Ice::Current&); - virtual void ftruncate(const NetFSComms::ReqEnv &, Ice::Int id, Ice::Long size, const Ice::Current&); - virtual NetFSComms::Attr fgetattr(const NetFSComms::ReqEnv &, Ice::Int id, const Ice::Current&); - - virtual void unlink(const NetFSComms::ReqEnv &, const std::string & path, const Ice::Current&); - - virtual Ice::Int open(const NetFSComms::ReqEnv &, const std::string & path, Ice::Int flags, const Ice::Current&); - virtual Ice::Int create(const NetFSComms::ReqEnv &, const std::string & path, Ice::Int flags, Ice::Int mode, const Ice::Current&); - virtual void close(Ice::Long tok, Ice::Int id, const Ice::Current&); - virtual NetFSComms::Buffer read(Ice::Long tok, Ice::Int id, Ice::Long offset, Ice::Long size, const Ice::Current&); - virtual void write(Ice::Long tok, Ice::Int id, Ice::Long offset, Ice::Long size, const NetFSComms::Buffer & data, const Ice::Current&); - - virtual NetFSComms::VFS statfs(const NetFSComms::ReqEnv &, const std::string & path, const Ice::Current&); - - virtual Ice::Int access(const NetFSComms::ReqEnv &, const std::string & path, Ice::Int mode, const Ice::Current&); - virtual NetFSComms::Attr getattr(const NetFSComms::ReqEnv &, const std::string & path, const Ice::Current&); - virtual void symlink(const NetFSComms::ReqEnv &, const std::string & path1, const std::string & path2, const Ice::Current&); - virtual void link(const NetFSComms::ReqEnv &, const std::string & path1, const std::string & path2, const Ice::Current&); - virtual void rename(const NetFSComms::ReqEnv &, const std::string & path1, const std::string & path2, const Ice::Current&); - virtual std::string readlink(const NetFSComms::ReqEnv &, const std::string & path, const Ice::Current&); - virtual void chmod(const NetFSComms::ReqEnv &, const std::string & path, Ice::Int mode, const Ice::Current&); - virtual void chown(const NetFSComms::ReqEnv &, const std::string & path, Ice::Int uid, Ice::Int gid, const Ice::Current&); - virtual void utimens(const NetFSComms::ReqEnv &, const std::string & path, Ice::Long, Ice::Long, Ice::Long, Ice::Long, const Ice::Current&); - private: - UserEntCache uentries; - GroupEntCache gentries; -}; - -#endif - diff --git a/netfs/daemonFiles.cpp b/netfs/daemonFiles.cpp deleted file mode 100644 index 75d9058..0000000 --- a/netfs/daemonFiles.cpp +++ /dev/null @@ -1,170 +0,0 @@ -#include "pchDaemon.hpp" -#include <errno.h> -#include <map> -#include <fcntl.h> -#include <sys/stat.h> -#include "daemonFileSystem.h" - -void -FileSystemServer::truncate(const NetFSComms::ReqEnv & re, const std::string & path, Ice::Long size, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::truncate(p.string().c_str(), size) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -void -FileSystemServer::ftruncate(const NetFSComms::ReqEnv & re, Ice::Int id, Ice::Long size, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), false); - TempPrivs tp(re, &uentries, &gentries); - try { - errno = 0; - if (::ftruncate(sess->files.get(id), size) != 0) { - throw NetFSComms::SystemError(errno); - } - } - catch (GUIDMap::NotFound) { - throw NetFSComms::SystemError(EBADF); - } - // s.replicatedRequest = true; -} - -NetFSComms::Attr -FileSystemServer::fgetattr(const NetFSComms::ReqEnv & re, Ice::Int id, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), false); - TempPrivs tp(re, &uentries, &gentries); - try { - struct stat s; - if (::fstat(sess->files.get(id), &s) != 0) { - throw NetFSComms::SystemError(errno); - } - NetFSComms::Attr a; - a.dev = s.st_dev; - a.inode = s.st_ino; - a.mode = s.st_mode; - a.links = s.st_nlink; - a.uid = uentries.getName(s.st_uid); - a.gid = gentries.getName(s.st_gid); - a.rdev = s.st_rdev; - a.size = s.st_size; - a.blockSize = s.st_blksize; - a.blocks = s.st_blocks; - a.atime = s.st_atime; - a.mtime = s.st_mtime; - a.ctime = s.st_ctime; - return a; - } - catch (GUIDMap::NotFound) { - throw NetFSComms::SystemError(EBADF); - } -} - -void -FileSystemServer::unlink(const NetFSComms::ReqEnv & re, const std::string & path, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::unlink(p.string().c_str()) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -Ice::Int -FileSystemServer::open(const NetFSComms::ReqEnv & re, const std::string & path, Ice::Int flags, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - int fd = ::open(p.string().c_str(), flags); - if (fd == -1) { - throw NetFSComms::SystemError(errno); - } - //s.replicatedRequest = true; - return sess->files.store(fd); -} - -Ice::Int -FileSystemServer::create(const NetFSComms::ReqEnv & re, const std::string & path, Ice::Int flags, Ice::Int mode, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - int fd = ::open(p.string().c_str(), O_CREAT | flags, mode); - if (fd == -1) { - throw NetFSComms::SystemError(errno); - } - //s.replicatedRequest = true; - return sess->files.store(fd); -} - -void -FileSystemServer::close(Ice::Long tok, Ice::Int id, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(tok), false); - try { - errno = 0; - if (::close(sess->files.get(id)) != 0) { - throw NetFSComms::SystemError(errno); - } - sess->files.remove(id); - // s.replicatedRequest = true; - } - catch (GUIDMap::NotFound) { - throw NetFSComms::SystemError(EBADF); - } -} - -NetFSComms::Buffer -FileSystemServer::read(Ice::Long tok, Ice::Int id, Ice::Long offset, Ice::Long size, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(tok), false); - try { - NetFSComms::Buffer buf; - buf.resize(size); - errno = 0; - int r = pread(sess->files.get(id), &buf[0], size, offset); - if (r == -1) { - throw NetFSComms::SystemError(errno); - } - else if (r != size) { - buf.resize(r); - } - return buf; - } - catch (GUIDMap::NotFound) { - throw NetFSComms::SystemError(EBADF); - } -} - -void -FileSystemServer::write(Ice::Long tok, Ice::Int id, Ice::Long offset, Ice::Long size, const NetFSComms::Buffer & data, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(tok), false); - try { - errno = 0; - if (pwrite(sess->files.get(id), &data[0], size, offset) != size) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; - } - catch (GUIDMap::NotFound) { - throw NetFSComms::SystemError(EBADF); - } -} - diff --git a/netfs/daemonMisc.cpp b/netfs/daemonMisc.cpp deleted file mode 100644 index e548606..0000000 --- a/netfs/daemonMisc.cpp +++ /dev/null @@ -1,157 +0,0 @@ -#include "pchDaemon.hpp" -#include <errno.h> -#include <map> -#include <unistd.h> -#include <sys/stat.h> -#include <limits.h> -#include <fcntl.h> -#include "daemonFileSystem.h" - -extern std::map<Ice::Int, int> files; - -Ice::Int -FileSystemServer::access(const NetFSComms::ReqEnv & re, const std::string & path, Ice::Int mode, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - return ::access(p.string().c_str(), mode); -} - -NetFSComms::Attr -FileSystemServer::getattr(const NetFSComms::ReqEnv & re, const std::string & path, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - struct stat s; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::lstat(p.string().c_str(), &s) != 0) { - throw NetFSComms::SystemError(errno); - } - NetFSComms::Attr a; - a.dev = s.st_dev; - a.inode = s.st_ino; - a.mode = s.st_mode; - a.links = s.st_nlink; - a.uid = uentries.getName(s.st_uid); - a.gid = gentries.getName(s.st_gid); - a.rdev = s.st_rdev; - a.size = s.st_size; - a.blockSize = s.st_blksize; - a.blocks = s.st_blocks; - a.atime = s.st_atime; - a.mtime = s.st_mtime; - a.ctime = s.st_ctime; - return a; -} - -void -FileSystemServer::symlink(const NetFSComms::ReqEnv & re, const std::string & path1, const std::string & path2, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path2; - sess.unlock(); - if (::symlink(path1.c_str(), p.string().c_str()) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -void -FileSystemServer::link(const NetFSComms::ReqEnv & re, const std::string & path1, const std::string & path2, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p1 = sess->exportCfg->root / path1; - boost::filesystem::path p2 = sess->exportCfg->root / path2; - sess.unlock(); - if (::link(p1.string().c_str(), p2.string().c_str()) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -void -FileSystemServer::rename(const NetFSComms::ReqEnv & re, const std::string & from, const std::string & to, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path f = sess->exportCfg->root / from; - boost::filesystem::path t = sess->exportCfg->root / to; - sess.unlock(); - if (::rename(f.string().c_str(), t.string().c_str()) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -std::string -FileSystemServer::readlink(const NetFSComms::ReqEnv & re, const std::string & path, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - char buf[PATH_MAX]; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - ssize_t rc = ::readlink(p.string().c_str(), buf, PATH_MAX); - if (rc == -1) { - throw NetFSComms::SystemError(errno); - } - return std::string(buf, rc); -} - -void -FileSystemServer::chmod(const NetFSComms::ReqEnv & re, const std::string & path, Ice::Int mode, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::chmod(p.string().c_str(), mode) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -void -FileSystemServer::chown(const NetFSComms::ReqEnv & re, const std::string & path, Ice::Int uid, Ice::Int gid, const Ice::Current &) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::lchown(p.string().c_str(), uid, gid) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - -void -FileSystemServer::utimens(const NetFSComms::ReqEnv & re, const std::string & path, - Ice::Long s0, Ice::Long ns0, Ice::Long s1, Ice::Long ns1, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - struct timespec times[2]; - times[0].tv_sec = s0; - times[0].tv_nsec = ns0; - times[1].tv_sec = s1; - times[1].tv_nsec = ns1; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::utimensat(0, p.string().c_str(), times, AT_SYMLINK_NOFOLLOW) != 0) { - throw NetFSComms::SystemError(errno); - } - // s.replicatedRequest = true; -} - diff --git a/netfs/daemonModule.cpp b/netfs/daemonModule.cpp deleted file mode 100644 index 8be108c..0000000 --- a/netfs/daemonModule.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include "pchDaemon.hpp" -#include "daemonModule.h" - -DaemonModule::DaemonModule(DaemonGlobalStatePtr d) : - dgs(d) -{ -} - diff --git a/netfs/daemonModule.h b/netfs/daemonModule.h deleted file mode 100644 index 7525e74..0000000 --- a/netfs/daemonModule.h +++ /dev/null @@ -1,14 +0,0 @@ -#ifndef DAEMONMODULE_H -#define DAEMONMODULE_H - -#include "daemon.h" - -class DaemonModule { - protected: - DaemonModule(DaemonGlobalStatePtr dgs); - - DaemonGlobalStatePtr dgs; -}; - -#endif - diff --git a/netfs/daemonService.cpp b/netfs/daemonService.cpp deleted file mode 100644 index bb13fbc..0000000 --- a/netfs/daemonService.cpp +++ /dev/null @@ -1,22 +0,0 @@ -#include "pchDaemon.hpp" -#include "daemonService.h" - -ServiceServer::ServiceServer(int16_t hs, DaemonGlobalStatePtr dgs) : - DaemonModule(dgs), - hostseed(hs) -{ -} - -Ice::Long -ServiceServer::connect(const std::string & share, const std::string &, const Ice::Current &) -{ - DaemonGlobalState::NSP s = dgs->newSession(hostseed, share); - return s.get<0>(); -} - -void -ServiceServer::disconnect(Ice::Long tok, const Ice::Current &) -{ - dgs->endSession(tok); -} - diff --git a/netfs/daemonService.h b/netfs/daemonService.h deleted file mode 100644 index 067e4a5..0000000 --- a/netfs/daemonService.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef DAEMONSERVICE_H -#define DAEMONSERVICE_H - -#include "netfsComms.h" -#include "daemonModule.h" - -class ServiceServer : public DaemonModule, public NetFSComms::Service { - public: - ServiceServer(int16_t hostseed, DaemonGlobalStatePtr dgs); - - virtual Ice::Long connect(const std::string & share, const std::string & auth, const Ice::Current&); - virtual void disconnect(Ice::Long tok, const Ice::Current&); - private: - const int16_t hostseed; -}; - -#endif - diff --git a/netfs/daemonSystem.cpp b/netfs/daemonSystem.cpp deleted file mode 100644 index 1f683d6..0000000 --- a/netfs/daemonSystem.cpp +++ /dev/null @@ -1,33 +0,0 @@ -#include "pchDaemon.hpp" -#include <errno.h> -#include <sys/statvfs.h> -#include <sys/vfs.h> -#include "daemonFileSystem.h" - -NetFSComms::VFS -FileSystemServer::statfs(const NetFSComms::ReqEnv & re, const std::string & path, const Ice::Current&) -{ - SessionPtr sess(dgs->getSession(re.tok), true); - TempPrivs tp(re, &uentries, &gentries); - errno = 0; - struct statvfs s; - boost::filesystem::path p = sess->exportCfg->root / path; - sess.unlock(); - if (::statvfs(p.string().c_str(), &s) != 0) { - throw NetFSComms::SystemError(errno); - } - NetFSComms::VFS t; - t.blockSize = s.f_bsize; - t.fragmentSize = s.f_frsize; - t.blocks = s.f_blocks; - t.freeBlocks = s.f_bfree; - t.availBlocks = s.f_bavail; - t.files = s.f_files; - t.freeFiles = s.f_ffree; - t.availFiles = s.f_favail; - t.FSID = s.f_fsid; - t.flags = s.f_flag; - t.maxNameLen = s.f_namemax; - return t; -} - diff --git a/netfs/fuse.cpp b/netfs/fuse.cpp deleted file mode 100644 index 057daa0..0000000 --- a/netfs/fuse.cpp +++ /dev/null @@ -1,120 +0,0 @@ -#include "pchFuse.hpp" -#include <string.h> -#include <boost/foreach.hpp> -#include "fuse.h" - -NetFS::ReqEnv::ReqEnv(const NetFS * netfs) -{ - struct fuse_context * c = fuse_get_context(); - tok = netfs->authtok; - user = netfs->uentries.getName(c->uid); - grp = netfs->gentries.getName(c->gid); -} - -NetFS::NetFS(int & argc, char ** argv) : - _argc(argc), - _argv(argv), - authtok(0), - openFileID(0) -{ -} - -NetFS::~NetFS() -{ - if (authtok) { - service->disconnect(authtok); - } - if (ic) { - ic->destroy(); - } -} - -void * -NetFS::init(struct fuse_conn_info *) -{ - ic = Ice::initialize(_argc, _argv); - fc = FuseConfig::Load(configPath); - return NULL; -} - -int -NetFS::opt_parse(void *, const char * arg, int, struct fuse_args *) -{ - if (strncmp(arg, "--Ice.", 6) == 0) { - return 0; - } - else if (arg[0] == '-') { - return 1; - } - else if (exportName.empty()) { - const char * colon = strchr(arg, ':'); - exportName = colon + 1; - configPath.assign(arg, colon); - return 0; - } - else if (mountPoint.empty()) { - mountPoint = arg; - return 1; - } - return 1; -} - -void -NetFS::connect() -{ - LOCK; - connect_nl(); -} -void -NetFS::connect_nl() -{ - authtok = service->connect(exportName, "bar"); - BOOST_FOREACH(const OpenFiles::value_type & of, openFiles) { - of.second->remoteID = filesystem->open(reqEnv(), of.second->path, of.second->flags); - } - BOOST_FOREACH(const OpenDirs::value_type & of, openDirs) { - of.second->remoteID = filesystem->opendir(reqEnv(), of.second->path); - } -} - -int -NetFS::onError(const std::exception & e) throw() -{ - if (dynamic_cast<const NetFSComms::AuthError *>(&e)) { - // I've become unauthenticated... reauthenticate - connect_nl(); - return 0; - } - return FuseAppBase::onError(e); -} - -NetFS::ReqEnv -NetFS::reqEnv() -{ - LOCK; - if (!service || !filesystem) { - FuseConfig::ExportPtr e = fc->exports[exportName]; - const std::string & ep = *e->endpoints.begin(); - - service = NetFSComms::ServicePrx::checkedCast(ic->stringToProxy("Service:" + ep)); - if (!service) { - throw "Invalid service proxy"; - } - - filesystem = NetFSComms::FileSystemPrx::checkedCast(ic->stringToProxy("FileSystem:" + ep)); - if (!filesystem) { - throw "Invalid filesystem proxy"; - } - } - if (authtok == 0) { - connect_nl(); - } - return ReqEnv(this); -} - -int -main(int argc, char* argv[]) -{ - return FuseAppBase::run(argc, argv, new NetFS(argc, argv)); -} - diff --git a/netfs/fuse.h b/netfs/fuse.h deleted file mode 100644 index 4a0abfd..0000000 --- a/netfs/fuse.h +++ /dev/null @@ -1,113 +0,0 @@ -#ifndef FUSE_H -#define FUSE_H - -#include <boost/thread/mutex.hpp> -#include <Ice/Ice.h> -#include "netfsComms.h" -#include "fuseapp.h" -#include "fuseConfig.h" -#include "entCache.h" -#include "intrusivePtrBase.h" - -#define LOCK boost::unique_lock<boost::mutex> _lck(_lock) - -class NetFS : public FuseAppBase -{ - private: - class ReqEnv : public NetFSComms::ReqEnv { - public: - ReqEnv(const NetFS *); - }; - - class OpenDir : public IntrusivePtrBase { - public: - OpenDir(Ice::Int remoteID, const std::string & path); - - Ice::Int remoteID; - const std::string path; - }; - typedef boost::intrusive_ptr<OpenDir> OpenDirPtr; - typedef std::map<int, OpenDirPtr> OpenDirs; - - class OpenFile : public IntrusivePtrBase { - public: - OpenFile(Ice::Int remoteID, const std::string & path, int flags); - - Ice::Int remoteID; - const std::string path; - const int flags; - }; - typedef boost::intrusive_ptr<OpenFile> OpenFilePtr; - typedef std::map<int, OpenFilePtr> OpenFiles; - - public: - NetFS(int & argc, char ** argv); - ~NetFS(); - private: - void * init (struct fuse_conn_info * info); - int opt_parse(void *, const char * arg, int key, struct fuse_args *); - void connect(); - void connect_nl(); - public: - // misc - int access(const char * p, int a); - int getattr(const char * p, struct stat * s); - int fgetattr(const char *, struct stat *, struct fuse_file_info *); - int chmod(const char *, mode_t); - int chown(const char *, uid_t, gid_t); - int link(const char *, const char *); - int readlink(const char *, char *, size_t); - int rename(const char *, const char *); - int symlink(const char *, const char *); - int unlink(const char *); - int utimens(const char *, const struct timespec tv[2]); - // dirs - int opendir(const char * p, struct fuse_file_info * fi); - int releasedir(const char *, struct fuse_file_info * fi); - int readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi); - int mkdir(const char *, mode_t); - int rmdir(const char *); - // files - int open(const char * p, struct fuse_file_info * fi); - int create(const char *, mode_t, struct fuse_file_info *); - int release(const char *, struct fuse_file_info * fi); - int read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi); - int write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi); - int truncate(const char *, off_t); - int ftruncate(const char *, off_t, struct fuse_file_info *); - // fs - int statfs(const char *, struct statvfs *); - // stuff - int onError(const std::exception & err) throw(); - private: - int getNextFileID(); - Ice::Int getRemoteIDforFile(int localID) const; - int getNextDirID(); - Ice::Int getRemoteIDforDir(int localID) const; - - ReqEnv reqEnv(); - - int & _argc; - char ** _argv; - Ice::CommunicatorPtr ic; - FuseConfigPtr fc; - mutable boost::mutex _lock; - - NetFSComms::FileSystemPrx filesystem; - NetFSComms::ServicePrx service; - - mutable Ice::Long authtok; - - std::string mountPoint; - std::string exportName; - std::string configPath; - - UserEntCache uentries; - GroupEntCache gentries; - OpenDirs openDirs; - int openDirID; - OpenFiles openFiles; - int openFileID; -}; - -#endif diff --git a/netfs/fuse/Jamfile.jam b/netfs/fuse/Jamfile.jam new file mode 100644 index 0000000..873f67c --- /dev/null +++ b/netfs/fuse/Jamfile.jam @@ -0,0 +1,33 @@ +cpp-pch pch : pch.hpp : + <define>_FILE_OFFSET_BITS=64 + <include>../../libmisc + <include>../../libfusepp + <implicit-dependency>../ice//netfsComms + <library>../ice//netfsComms + <library>..//boost_thread + <library>..//fuse + <library>..//Ice + <library>..//libxml2 + ; + + +exe netfs : + pch + [ glob *.cpp ] + [ glob ../../libfusepp/fuse*.cpp ] + : + <define>_FILE_OFFSET_BITS=64 + <include>../../libmisc + <include>../../libfusepp + <implicit-dependency>../ice//netfsComms + <library>../ice//netfsComms + <library>../lib//netfsCommon + <library>..//boost_thread + <library>..//boost_system + <library>..//fuse + <library>..//Ice + <library>..//IceUtil + <library>..//pthread + <library>..//libxml2 + ; + diff --git a/netfs/fuse/fuse.cpp b/netfs/fuse/fuse.cpp new file mode 100644 index 0000000..e221cfd --- /dev/null +++ b/netfs/fuse/fuse.cpp @@ -0,0 +1,148 @@ +#include "pch.hpp" +#include <string.h> +#include <boost/foreach.hpp> +#include "fuse.h" + +NetFS::FuseApp::FuseApp(int & argc, char ** argv) : + _argc(argc), + _argv(argv), + openDirID(0), + openFileID(0) +{ +} + +NetFS::FuseApp::~FuseApp() +{ + volume->disconnect(); + if (ic) { + ic->destroy(); + } +} + +void * +NetFS::FuseApp::init(struct fuse_conn_info *) +{ + ic = Ice::initialize(_argc, _argv); + fc = FuseConfig::Load(configPath); + return NULL; +} + +int +NetFS::FuseApp::opt_parse(void *, const char * arg, int, struct fuse_args *) +{ + if (strncmp(arg, "--Ice.", 6) == 0) { + return 0; + } + else if (arg[0] == '-') { + return 1; + } + else if (exportName.empty()) { + const char * colon = strchr(arg, ':'); + exportName = colon + 1; + configPath.assign(arg, colon); + return 0; + } + else if (mountPoint.empty()) { + mountPoint = arg; + return 1; + } + return 1; +} + +void +NetFS::FuseApp::connectToService() +{ + if (!service) { + LOCK; + FuseConfig::ExportPtr e = fc->exports[exportName]; + const std::string & ep = *e->endpoints.begin(); + + service = NetFS::ServicePrx::checkedCast(ic->stringToProxy("Service:" + ep)); + if (!service) { + throw "Invalid service proxy"; + } + } +} + +void +NetFS::FuseApp::connectToVolume() +{ + if (!volume) { + volume = service->connect(exportName, "bar"); + if (!volume) { + throw "Invalid filesystem proxy"; + } + } +} + +void +NetFS::FuseApp::connectHandles() +{ + BOOST_FOREACH(const OpenFiles::value_type & of, openFiles) { + try { + of.second->remote->ice_ping(); + } + catch (const Ice::ObjectNotExistException &) { + of.second->remote = volume->open(reqEnv(), of.second->path, of.second->flags); + } + } + BOOST_FOREACH(const OpenDirs::value_type & of, openDirs) { + try { + of.second->remote->ice_ping(); + } + catch (const Ice::ObjectNotExistException &) { + of.second->remote = volume->opendir(reqEnv(), of.second->path); + } + } +} + +void +NetFS::FuseApp::verifyConnection() +{ + LOCK; + if (service) { + try { + service->ice_ping(); + } + catch (const Ice::Exception &) { + service = NULL; + } + } + if (volume) { + try { + volume->ice_ping(); + } + catch (const Ice::Exception &) { + volume = NULL; + } + } +} + +int +NetFS::FuseApp::onError(const std::exception & e) throw() +{ + if (dynamic_cast<const Ice::ObjectNotExistException *>(&e)) { + verifyConnection(); + connectToService(); + connectToVolume(); + connectHandles(); + return 0; + } + return FuseAppBase::onError(e); +} + +NetFS::ReqEnv +NetFS::FuseApp::reqEnv() +{ + connectToService(); + connectToVolume(); + struct fuse_context * c = fuse_get_context(); + return { uentries.getName(c->uid), gentries.getName(c->gid) }; +} + +int +main(int argc, char* argv[]) +{ + return FuseAppBase::run(argc, argv, new NetFS::FuseApp(argc, argv)); +} + diff --git a/netfs/fuse/fuse.h b/netfs/fuse/fuse.h new file mode 100644 index 0000000..033d7fa --- /dev/null +++ b/netfs/fuse/fuse.h @@ -0,0 +1,117 @@ +#ifndef FUSE_H +#define FUSE_H + +#include <boost/thread/shared_mutex.hpp> +#include <Ice/Ice.h> +#include <service.h> +#include "fuseapp.h" +#include "fuseConfig.h" +#include "entCache.h" +#include "intrusivePtrBase.h" + +#define LOCK boost::unique_lock<boost::shared_mutex> _lck(_lock) +#define SLOCK boost::shared_lock<boost::shared_mutex> _lck(_lock) + +namespace NetFS { + class FuseApp : public FuseAppBase { + private: + class OpenDir : public IntrusivePtrBase { + public: + OpenDir(DirectoryPrx remote, const std::string & path); + + DirectoryPrx remote; + const std::string path; + }; + typedef boost::intrusive_ptr<OpenDir> OpenDirPtr; + typedef std::map<int, OpenDirPtr> OpenDirs; + + class OpenFile : public IntrusivePtrBase { + public: + OpenFile(FilePrx remote, const std::string & path, int flags); + + FilePrx remote; + const std::string path; + const int flags; + }; + typedef boost::intrusive_ptr<OpenFile> OpenFilePtr; + typedef std::map<int, OpenFilePtr> OpenFiles; + + public: + FuseApp(int & argc, char ** argv); + ~FuseApp(); + + private: + void * init (struct fuse_conn_info * info); + int opt_parse(void *, const char * arg, int key, struct fuse_args *); + + void connectToService(); + void connectToVolume(); + void connectHandles(); + void verifyConnection(); + + public: + // misc + int access(const char * p, int a); + int getattr(const char * p, struct stat * s); + int fgetattr(const char *, struct stat *, struct fuse_file_info *); + int chmod(const char *, mode_t); + int chown(const char *, uid_t, gid_t); + int link(const char *, const char *); + int readlink(const char *, char *, size_t); + int rename(const char *, const char *); + int symlink(const char *, const char *); + int unlink(const char *); + int utimens(const char *, const struct timespec tv[2]); + // dirs + int opendir(const char * p, struct fuse_file_info * fi); + int releasedir(const char *, struct fuse_file_info * fi); + int readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi); + int mkdir(const char *, mode_t); + int rmdir(const char *); + // files + int open(const char * p, struct fuse_file_info * fi); + int create(const char *, mode_t, struct fuse_file_info *); + int release(const char *, struct fuse_file_info * fi); + int read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi); + int write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi); + int truncate(const char *, off_t); + int ftruncate(const char *, off_t, struct fuse_file_info *); + // fs + int statfs(const char *, struct statvfs *); + // stuff + int onError(const std::exception & err) throw(); + + private: + void setProxy(OpenFilePtr, uint64_t & fh); + OpenFilePtr getFileProxy(uint64_t localID) const; + void clearFileProxy(uint64_t localID); + + void setProxy(OpenDirPtr, uint64_t & fh); + OpenDirPtr getDirProxy(uint64_t localID) const; + void clearDirProxy(uint64_t localID); + + ReqEnv reqEnv(); + + int & _argc; + char ** _argv; + Ice::CommunicatorPtr ic; + FuseConfigPtr fc; + mutable boost::shared_mutex _lock; + + NetFS::VolumePrx volume; + NetFS::ServicePrx service; + + std::string mountPoint; + std::string exportName; + std::string configPath; + + UserEntCache uentries; + GroupEntCache gentries; + OpenDirs openDirs; + int openDirID; + OpenFiles openFiles; + int openFileID; + }; +} + +#endif diff --git a/netfs/fuseConfig.cpp b/netfs/fuse/fuseConfig.cpp index 4030738..168550e 100644 --- a/netfs/fuseConfig.cpp +++ b/netfs/fuse/fuseConfig.cpp @@ -1,4 +1,4 @@ -#include "pchFuse.hpp" +#include "pch.hpp" #include "fuseConfig.h" #include <string.h> diff --git a/netfs/fuseConfig.h b/netfs/fuse/fuseConfig.h index f33c8f7..f33c8f7 100644 --- a/netfs/fuseConfig.h +++ b/netfs/fuse/fuseConfig.h diff --git a/netfs/fuse/fuseDirs.cpp b/netfs/fuse/fuseDirs.cpp new file mode 100644 index 0000000..fac70a6 --- /dev/null +++ b/netfs/fuse/fuseDirs.cpp @@ -0,0 +1,103 @@ +#include "pch.hpp" +#include "fuse.h" +#include "misc.h" + +NetFS::FuseApp::OpenDir::OpenDir(DirectoryPrx r, const std::string & p) : + remote(r), + path(p) +{ +} + +void +NetFS::FuseApp::setProxy(OpenDirPtr od, uint64_t & fh) +{ + LOCK; + while (openDirs.find(fh = ++openDirID) != openDirs.end()) ; + openDirs.insert({ fh, od }); +} + +NetFS::FuseApp::OpenDirPtr +NetFS::FuseApp::getDirProxy(uint64_t localID) const +{ + SLOCK; + OpenDirs::const_iterator i = openDirs.find(localID); + if (i != openDirs.end()) { + return i->second; + } + throw NetFS::SystemError(EBADF); +} + +void +NetFS::FuseApp::clearDirProxy(uint64_t localID) +{ + LOCK; + openDirs.erase(localID); +} + +int +NetFS::FuseApp::opendir(const char * p, struct fuse_file_info * fi) +{ + try { + auto remote = volume->opendir(reqEnv(), p); + setProxy(new OpenDir(remote, p), fi->fh); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::releasedir(const char *, struct fuse_file_info * fi) +{ + try { + auto remote = getDirProxy(fi->fh)->remote; + remote->close(); + clearDirProxy(fi->fh); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi) +{ + try { + auto remote = getDirProxy(fi->fh)->remote; + NetFS::NameList ds = remote->readdir(); + BOOST_FOREACH(const auto & e, ds) { + filler(buf, e.c_str(), NULL, 0); + } + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::mkdir(const char * p, mode_t m) +{ + try { + volume->mkdir(reqEnv(), p, m); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::rmdir(const char * p) +{ + try { + volume->rmdir(reqEnv(), p); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + diff --git a/netfs/fuse/fuseFiles.cpp b/netfs/fuse/fuseFiles.cpp new file mode 100644 index 0000000..4a96e51 --- /dev/null +++ b/netfs/fuse/fuseFiles.cpp @@ -0,0 +1,155 @@ +#include "pch.hpp" +#include <string.h> +#include <typeConvert.h> +#include "fuse.h" + +NetFS::FuseApp::OpenFile::OpenFile(FilePrx r, const std::string & p, int f) : + remote(r), + path(p), + flags(f) +{ +} + +void +NetFS::FuseApp::setProxy(OpenFilePtr of, uint64_t & fh) +{ + LOCK; + while (openFiles.find(fh = ++openFileID) != openFiles.end()) ; + openFiles.insert({ fh, of }); +} + +NetFS::FuseApp::OpenFilePtr +NetFS::FuseApp::getFileProxy(uint64_t localID) const +{ + SLOCK; + OpenFiles::const_iterator i = openFiles.find(localID); + if (i != openFiles.end()) { + return i->second; + } + throw NetFS::SystemError(EBADF); +} + +void +NetFS::FuseApp::clearFileProxy(uint64_t localID) +{ + LOCK; + openFiles.erase(localID); +} + +int +NetFS::FuseApp::open(const char * p, struct fuse_file_info * fi) +{ + try { + auto remote = volume->open(reqEnv(), p, fi->flags); + setProxy(new OpenFile(remote, p, fi->flags), fi->fh); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::create(const char * p, mode_t m, struct fuse_file_info * fi) +{ + try { + auto remote = volume->create(reqEnv(), p, fi->flags, m); + setProxy(new OpenFile(remote, p, fi->flags), fi->fh); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::release(const char *, struct fuse_file_info * fi) +{ + try { + auto remote = getFileProxy(fi->fh)->remote; + remote->close(); + clearFileProxy(fi->fh); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) +{ + try { + auto remote = getFileProxy(fi->fh)->remote; + NetFS::Buffer data = remote->read(o, s); + memcpy(buf, &data.front(), data.size()); + return data.size(); + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) +{ + try { + auto remote = getFileProxy(fi->fh)->remote; + remote->write(o, s, NetFS::Buffer(buf, buf + s)); + return s; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::truncate(const char * p, off_t o) +{ + try { + volume->truncate(reqEnv(), p, o); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::ftruncate(const char *, off_t o, fuse_file_info * fi) +{ + try { + auto remote = getFileProxy(fi->fh)->remote; + remote->ftruncate(reqEnv(), o); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::fgetattr(const char *, struct stat * s, fuse_file_info * fi) +{ + try { + auto remote = getFileProxy(fi->fh)->remote; + *s << AttrSource { remote->fgetattr(reqEnv()), boost::bind(&UserEntCache::getID, &uentries, _1), boost::bind(&GroupEntCache::getID, &gentries, _1) }; + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::unlink(const char * p) +{ + try { + volume->unlink(reqEnv(), p); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + diff --git a/netfs/fuse/fuseMisc.cpp b/netfs/fuse/fuseMisc.cpp new file mode 100644 index 0000000..568cf52 --- /dev/null +++ b/netfs/fuse/fuseMisc.cpp @@ -0,0 +1,110 @@ +#include "pch.hpp" +#include "fuse.h" +#include <string.h> +#include <typeConvert.h> + +int +NetFS::FuseApp::access(const char * p, int a) +{ + return -volume->access(reqEnv(), p, a); +} + +int +NetFS::FuseApp::getattr(const char * p, struct stat * s) +{ + try { + *s << AttrSource { volume->getattr(reqEnv(), p), boost::bind(&UserEntCache::getID, &uentries, _1), boost::bind(&GroupEntCache::getID, &gentries, _1) }; + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::chmod(const char * p, mode_t m) +{ + try { + volume->chmod(reqEnv(), p, m); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::chown(const char * p, uid_t u, gid_t g) +{ + try { + volume->chown(reqEnv(), p, u, g); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::link(const char * p1, const char * p2) +{ + try { + volume->link(reqEnv(), p1, p2); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::symlink(const char * p1, const char * p2) +{ + try { + volume->symlink(reqEnv(), p1, p2); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::readlink(const char * p, char * p2, size_t s) +{ + try { + std::string l = volume->readlink(reqEnv(), p); + l.copy(p2, s); + p2[l.length()] = '\0'; + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::rename(const char * p1, const char * p2) +{ + try { + volume->rename(reqEnv(), p1, p2); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + +int +NetFS::FuseApp::utimens(const char * path, const struct timespec times[2]) +{ + try { + volume->utimens(reqEnv(), path, + times[0].tv_sec, times[0].tv_nsec, times[1].tv_sec, times[1].tv_nsec); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + diff --git a/netfs/fuse/fuseSystem.cpp b/netfs/fuse/fuseSystem.cpp new file mode 100644 index 0000000..0b29d86 --- /dev/null +++ b/netfs/fuse/fuseSystem.cpp @@ -0,0 +1,16 @@ +#include "pch.hpp" +#include <typeConvert.h> +#include "fuse.h" + +int +NetFS::FuseApp::statfs(const char * p, struct statvfs * vfs) +{ + try { + *vfs << volume->statfs(reqEnv(), p); + return 0; + } + catch (NetFS::SystemError & e) { + return -e.syserrno; + } +} + diff --git a/netfs/pchFuse.hpp b/netfs/fuse/pch.hpp index d563b57..7cb79ed 100644 --- a/netfs/pchFuse.hpp +++ b/netfs/fuse/pch.hpp @@ -2,9 +2,8 @@ #ifndef NETFS_FUSE_PCH #define NETFS_FUSE_PCH -#include "pchCommon.hpp" -#include "fuseapp.h" -#include "fuseConfig.h" +#include "../lib/pch.hpp" +#include "../../libfusepp/fuseapp.h" #include <fuse.h> #endif diff --git a/netfs/fuseDirs.cpp b/netfs/fuseDirs.cpp deleted file mode 100644 index 28b8363..0000000 --- a/netfs/fuseDirs.cpp +++ /dev/null @@ -1,97 +0,0 @@ -#include "pchFuse.hpp" -#include "fuse.h" -#include "misc.h" - -NetFS::OpenDir::OpenDir(Ice::Int rid, const std::string & p) : - remoteID(rid), - path(p) -{ -} - -int -NetFS::getNextDirID() -{ - LOCK; - while (openDirs.find(++openDirID) != openDirs.end()) ; - return openDirID; -} - -Ice::Int -NetFS::getRemoteIDforDir(int localID) const -{ - LOCK; - OpenDirs::const_iterator i = openDirs.find(localID); - if (i != openDirs.end()) { - return i->second->remoteID; - } - throw NetFSComms::SystemError(EBADF); -} - -int -NetFS::opendir(const char * p, struct fuse_file_info * fi) -{ - try { - Ice::Int remoteID = filesystem->opendir(reqEnv(), p); - fi->fh = getNextDirID(); - LOCK; - openDirs[fi->fh] = new OpenDir(remoteID, p); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::releasedir(const char *, struct fuse_file_info * fi) -{ - try { - filesystem->closedir(authtok, getRemoteIDforDir(fi->fh)); - LOCK; - openDirs.erase(fi->fh); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi) -{ - try { - NetFSComms::NameList ds = filesystem->readdir(authtok, getRemoteIDforDir(fi->fh)); - for (NetFSComms::NameList::const_iterator e = ds.begin(); e != ds.end(); e++) { - filler(buf, e->c_str(), NULL, 0); - } - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::mkdir(const char * p, mode_t m) -{ - try { - filesystem->mkdir(reqEnv(), p, m); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::rmdir(const char * p) -{ - try { - filesystem->rmdir(reqEnv(), p); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - diff --git a/netfs/fuseFiles.cpp b/netfs/fuseFiles.cpp deleted file mode 100644 index 40709bd..0000000 --- a/netfs/fuseFiles.cpp +++ /dev/null @@ -1,162 +0,0 @@ -#include "pchFuse.hpp" -#include <string.h> -#include "fuse.h" - -NetFS::OpenFile::OpenFile(Ice::Int rid, const std::string & p, int f) : - remoteID(rid), - path(p), - flags(f) -{ -} - -int -NetFS::getNextFileID() -{ - LOCK; - while (openFiles.find(++openFileID) != openFiles.end()) ; - return openFileID; -} - -Ice::Int -NetFS::getRemoteIDforFile(int localID) const -{ - LOCK; - OpenFiles::const_iterator i = openFiles.find(localID); - if (i != openFiles.end()) { - return i->second->remoteID; - } - throw NetFSComms::SystemError(EBADF); -} - -int -NetFS::open(const char * p, struct fuse_file_info * fi) -{ - try { - Ice::Int remoteID = filesystem->open(reqEnv(), p, fi->flags); - fi->fh = getNextFileID(); - LOCK; - openFiles[fi->fh] = new OpenFile(remoteID, p, fi->flags); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::create(const char * p, mode_t m, struct fuse_file_info * fi) -{ - try { - Ice::Int remoteID = filesystem->create(reqEnv(), p, fi->flags, m); - fi->fh = getNextFileID(); - LOCK; - openFiles[fi->fh] = new OpenFile(remoteID, p, fi->flags); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::release(const char *, struct fuse_file_info * fi) -{ - try { - filesystem->close(authtok, getRemoteIDforFile(fi->fh)); - LOCK; - openFiles.erase(fi->fh); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) -{ - try { - NetFSComms::Buffer data = filesystem->read(authtok, getRemoteIDforFile(fi->fh), o, s); - for (NetFSComms::Buffer::const_iterator i = data.begin(); i != data.end(); i++, buf++) { - *buf = *i; - } - return data.size(); - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) -{ - try { - filesystem->write(authtok, getRemoteIDforFile(fi->fh), o, s, NetFSComms::Buffer(buf, buf + s)); - return s; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::truncate(const char * p, off_t o) -{ - try { - filesystem->truncate(reqEnv(), p, o); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::ftruncate(const char *, off_t o, fuse_file_info * fi) -{ - try { - filesystem->ftruncate(reqEnv(), getRemoteIDforFile(fi->fh), o); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::fgetattr(const char *, struct stat * s, fuse_file_info * fi) -{ - try { - NetFSComms::Attr a = filesystem->fgetattr(reqEnv(), getRemoteIDforFile(fi->fh)); - s->st_dev = a.dev; - s->st_ino = a.inode; - s->st_mode = a.mode; - s->st_nlink = a.links; - s->st_uid = uentries.getID(a.uid); - s->st_gid = gentries.getID(a.gid); - s->st_rdev = a.rdev; - s->st_size = a.size; - s->st_blksize = a.blockSize; - s->st_blocks = a.blocks; - s->st_atime = a.atime; - s->st_mtime = a.mtime; - s->st_ctime = a.ctime; - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::unlink(const char * p) -{ - try { - filesystem->unlink(reqEnv(), p); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - diff --git a/netfs/fuseMisc.cpp b/netfs/fuseMisc.cpp deleted file mode 100644 index 2cb79c0..0000000 --- a/netfs/fuseMisc.cpp +++ /dev/null @@ -1,122 +0,0 @@ -#include "pchFuse.hpp" -#include "fuse.h" -#include <string.h> - -int -NetFS::access(const char * p, int a) -{ - return -filesystem->access(reqEnv(), p, a); -} - -int -NetFS::getattr(const char * p, struct stat * s) -{ - try { - NetFSComms::Attr a = filesystem->getattr(reqEnv(), p); - s->st_dev = a.dev; - s->st_ino = a.inode; - s->st_mode = a.mode; - s->st_nlink = a.links; - s->st_uid = uentries.getID(a.uid); - s->st_gid = gentries.getID(a.gid); - s->st_rdev = a.rdev; - s->st_size = a.size; - s->st_blksize = a.blockSize; - s->st_blocks = a.blocks; - s->st_atime = a.atime; - s->st_mtime = a.mtime; - s->st_ctime = a.ctime; - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::chmod(const char * p, mode_t m) -{ - try { - filesystem->chmod(reqEnv(), p, m); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::chown(const char * p, uid_t u, gid_t g) -{ - try { - filesystem->chown(reqEnv(), p, u, g); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::link(const char * p1, const char * p2) -{ - try { - filesystem->link(reqEnv(), p1, p2); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::symlink(const char * p1, const char * p2) -{ - try { - filesystem->symlink(reqEnv(), p1, p2); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::readlink(const char * p, char * p2, size_t s) -{ - try { - std::string l = filesystem->readlink(reqEnv(), p); - l.copy(p2, s); - p2[l.length()] = '\0'; - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::rename(const char * p1, const char * p2) -{ - try { - filesystem->rename(reqEnv(), p1, p2); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - -int -NetFS::utimens(const char * path, const struct timespec times[2]) -{ - try { - filesystem->utimens(reqEnv(), path, - times[0].tv_sec, times[0].tv_nsec, times[1].tv_sec, times[1].tv_nsec); - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - diff --git a/netfs/fuseSystem.cpp b/netfs/fuseSystem.cpp deleted file mode 100644 index bcb9c79..0000000 --- a/netfs/fuseSystem.cpp +++ /dev/null @@ -1,26 +0,0 @@ -#include "pchFuse.hpp" -#include "fuse.h" - -int -NetFS::statfs(const char * p, struct statvfs * vfs) -{ - try { - NetFSComms::VFS v = filesystem->statfs(reqEnv(), p); - vfs->f_bsize = v.blockSize; - vfs->f_frsize = v.fragmentSize; - vfs->f_blocks = v.blocks; - vfs->f_bfree = v.freeBlocks; - vfs->f_bavail = v.availBlocks; - vfs->f_files = v.files; - vfs->f_ffree = v.freeFiles; - vfs->f_favail = v.availFiles; - vfs->f_fsid = v.FSID; - vfs->f_flag = v.flags; - vfs->f_namemax = v.maxNameLen; - return 0; - } - catch (NetFSComms::SystemError & e) { - return -e.syserrno; - } -} - diff --git a/netfs/ice/Jamfile.jam b/netfs/ice/Jamfile.jam new file mode 100644 index 0000000..a227478 --- /dev/null +++ b/netfs/ice/Jamfile.jam @@ -0,0 +1,16 @@ +lib Ice ; +lib IceUtil ; +lib pthread ; + +lib netfsComms : + [ glob *.cpp *.ice ] : + <library>Ice + <library>IceUtil + <library>pthread + : : + <include>. + <library>Ice + <library>IceUtil + <library>pthread + ; + diff --git a/netfs/ice/directory.ice b/netfs/ice/directory.ice new file mode 100644 index 0000000..7468503 --- /dev/null +++ b/netfs/ice/directory.ice @@ -0,0 +1,17 @@ +#ifndef _DIRECTORY +#define _DIRECTORY + +#include "exceptions.ice" +#include "types.ice" + +module NetFS { + interface Directory { + void close() throws AuthError, SystemError; + + idempotent NameList readdir() throws AuthError, SystemError; + }; + +}; + +#endif + diff --git a/netfs/ice/exceptions.ice b/netfs/ice/exceptions.ice new file mode 100644 index 0000000..9d5b970 --- /dev/null +++ b/netfs/ice/exceptions.ice @@ -0,0 +1,18 @@ +#ifndef _EXCEPTIONS +#define _EXCEPTIONS + +module NetFS { + // Exceptions + exception SystemError { + int syserrno; + }; + + exception AuthError { + }; + + exception ConfigError { + }; +}; + +#endif + diff --git a/netfs/ice/file.ice b/netfs/ice/file.ice new file mode 100644 index 0000000..bbfb2d5 --- /dev/null +++ b/netfs/ice/file.ice @@ -0,0 +1,22 @@ +#ifndef _FILES +#define _FILES + +#include "exceptions.ice" +#include "types.ice" + +module NetFS { + interface ReadOnlyFile { + void close() throws AuthError, SystemError; + + idempotent Attr fgetattr(ReqEnv env) throws AuthError, SystemError; + idempotent Buffer read(long offset, long size) throws AuthError, SystemError; + }; + + interface File extends ReadOnlyFile { + idempotent void ftruncate(ReqEnv env, long size) throws AuthError, SystemError; + idempotent void write(long offset, long size, Buffer data) throws AuthError, SystemError; + }; +}; + +#endif + diff --git a/netfs/ice/service.ice b/netfs/ice/service.ice new file mode 100644 index 0000000..d691ae2 --- /dev/null +++ b/netfs/ice/service.ice @@ -0,0 +1,16 @@ +#ifndef _SERVICE +#define _SERVICE + +#include "exceptions.ice" +#include "types.ice" +#include "volume.ice" + +module NetFS { + interface Service { + // NameList volumes() throws ConfigError; + Volume * connect(string volume, string auth) throws AuthError, ConfigError; + }; +}; + +#endif + diff --git a/netfs/ice/typeConvert.cpp b/netfs/ice/typeConvert.cpp new file mode 100644 index 0000000..538b894 --- /dev/null +++ b/netfs/ice/typeConvert.cpp @@ -0,0 +1,70 @@ +#include "typeConvert.h" + +void +operator<<(struct stat & s, const AttrSource & a) +{ + s.st_dev = a.attr.dev; + s.st_ino = a.attr.inode; + s.st_mode = a.attr.mode; + s.st_nlink = a.attr.links; + s.st_uid = a.user(a.attr.uid); + s.st_gid = a.group(a.attr.gid); + s.st_rdev = a.attr.rdev; + s.st_size = a.attr.size; + s.st_blksize = a.attr.blockSize; + s.st_blocks = a.attr.blocks; + s.st_atime = a.attr.atime; + s.st_mtime = a.attr.mtime; + s.st_ctime = a.attr.ctime; +} + +void +operator<<(struct statvfs & vfs, const NetFS::VFS & v) +{ + vfs.f_bsize = v.blockSize; + vfs.f_frsize = v.fragmentSize; + vfs.f_blocks = v.blocks; + vfs.f_bfree = v.freeBlocks; + vfs.f_bavail = v.availBlocks; + vfs.f_files = v.files; + vfs.f_ffree = v.freeFiles; + vfs.f_favail = v.availFiles; + vfs.f_fsid = v.FSID; + vfs.f_flag = v.flags; + vfs.f_namemax = v.maxNameLen; +} + +void +operator<<(NetFS::Attr & a, const struct StatSource & s) +{ + a.dev = s.stat.st_dev; + a.inode = s.stat.st_ino; + a.mode = s.stat.st_mode; + a.links = s.stat.st_nlink; + a.uid = s.user(s.stat.st_uid); + a.gid = s.group(s.stat.st_gid); + a.rdev = s.stat.st_rdev; + a.size = s.stat.st_size; + a.blockSize = s.stat.st_blksize; + a.blocks = s.stat.st_blocks; + a.atime = s.stat.st_atime; + a.mtime = s.stat.st_mtime; + a.ctime = s.stat.st_ctime; +} + +void +operator<<(NetFS::VFS & t, const struct statvfs & s) +{ + t.blockSize = s.f_bsize; + t.fragmentSize = s.f_frsize; + t.blocks = s.f_blocks; + t.freeBlocks = s.f_bfree; + t.availBlocks = s.f_bavail; + t.files = s.f_files; + t.freeFiles = s.f_ffree; + t.availFiles = s.f_favail; + t.FSID = s.f_fsid; + t.flags = s.f_flag; + t.maxNameLen = s.f_namemax; +} + diff --git a/netfs/ice/typeConvert.h b/netfs/ice/typeConvert.h new file mode 100644 index 0000000..dd56a3f --- /dev/null +++ b/netfs/ice/typeConvert.h @@ -0,0 +1,29 @@ +#include <types.h> +#include <sys/stat.h> +#include <sys/statvfs.h> +#include <boost/function.hpp> + +typedef boost::function<uid_t(const std::string &)> UserIdLookup; +typedef boost::function<gid_t(const std::string &)> GroupIdLookup; + +typedef boost::function<std::string(uid_t)> UserNameLookup; +typedef boost::function<std::string(gid_t)> GroupNameLookup; + +struct AttrSource { + const NetFS::Attr & attr; + const UserIdLookup & user; + const GroupIdLookup & group; +}; + +struct StatSource { + const struct stat & stat; + const UserNameLookup & user; + const GroupNameLookup & group; +}; + +void operator<<(struct stat &, const AttrSource &); +void operator<<(struct statvfs &, const NetFS::VFS &); + +void operator<<(NetFS::Attr &, const struct StatSource &); +void operator<<(NetFS::VFS &, const struct statvfs &); + diff --git a/netfs/ice/types.ice b/netfs/ice/types.ice new file mode 100644 index 0000000..74f48ce --- /dev/null +++ b/netfs/ice/types.ice @@ -0,0 +1,46 @@ +#ifndef _TYPES +#define _TYPES + +module NetFS { + struct VFS { + long blockSize; + long fragmentSize; + long blocks; + long freeBlocks; + long availBlocks; + long files; + long freeFiles; + long availFiles; + long FSID; + long flags; + long maxNameLen; + }; + + struct Attr { + int dev; + long inode; + int mode; + int links; + string uid; + string gid; + int rdev; + long size; + long blockSize; + long blocks; + long atime; + long mtime; + long ctime; + }; + + struct ReqEnv { + string user; + string grp; + }; + + sequence<byte> Buffer; + + sequence<string> NameList; +}; + +#endif + diff --git a/netfs/ice/volume.ice b/netfs/ice/volume.ice new file mode 100644 index 0000000..7b0e3e0 --- /dev/null +++ b/netfs/ice/volume.ice @@ -0,0 +1,42 @@ +#ifndef _VOLUME +#define _VOLUME + +#include "exceptions.ice" +#include "types.ice" +#include "file.ice" +#include "directory.ice" + +module NetFS { + interface ReadOnlyVolume { + void disconnect() throws AuthError; + + ReadOnlyFile * openReadOnly(ReqEnv env, string path, int flags) throws AuthError, SystemError; + Directory * opendir(ReqEnv env, string path) throws AuthError, SystemError; + + idempotent VFS statfs(ReqEnv env, string path) throws AuthError, SystemError; + idempotent int access(ReqEnv env, string path, int mode) throws AuthError, SystemError; + idempotent Attr getattr(ReqEnv env, string path) throws AuthError, SystemError; + idempotent string readlink(ReqEnv env, string path) throws AuthError, SystemError; + }; + + interface Volume extends ReadOnlyVolume { + File * open(ReqEnv env, string path, int flags) throws AuthError, SystemError; + File * create(ReqEnv env, string path, int flags, int mode) throws AuthError, SystemError; + + idempotent void truncate(ReqEnv env, string path, long size) throws AuthError, SystemError; + void unlink(ReqEnv env, string path) throws AuthError, SystemError; + + void mkdir(ReqEnv env, string path, int mode) throws AuthError, SystemError; + void rmdir(ReqEnv env, string path) throws AuthError, SystemError; + + void symlink(ReqEnv env, string path1, string path2) throws AuthError, SystemError; + void link(ReqEnv env, string path1, string path2) throws AuthError, SystemError; + void rename(ReqEnv env, string from, string to) throws AuthError, SystemError; + idempotent void chmod(ReqEnv env, string path, int mode) throws AuthError, SystemError; + idempotent void chown(ReqEnv env, string path, int uid, int gid) throws AuthError, SystemError; + idempotent void utimens(ReqEnv env, string path, long atime, long atimens, long mtime, long mtimens) throws AuthError, SystemError; + }; +}; + +#endif + diff --git a/netfs/lib/Jamfile.jam b/netfs/lib/Jamfile.jam new file mode 100644 index 0000000..bf6dd1a --- /dev/null +++ b/netfs/lib/Jamfile.jam @@ -0,0 +1,21 @@ +cpp-pch pch : pch.hpp : + <define>_FILE_OFFSET_BITS=64 + <include>../../libmisc + ; + +lib netfsCommon : + pch + [ glob *.cpp ] + ../../libmisc/xml.cpp : + <define>_FILE_OFFSET_BITS=64 + <include>../../libmisc + <library>..//boost_system + <library>..//boost_thread + <library>..//libxml2 + <library>../ice//netfsComms + <implicit-dependency>../ice//netfsComms + : : + <include>. + <include>../../libmisc + ; + diff --git a/netfs/entCache.cpp b/netfs/lib/entCache.cpp index d79de29..7dee1e6 100644 --- a/netfs/entCache.cpp +++ b/netfs/lib/entCache.cpp @@ -1,6 +1,6 @@ -#include "pchCommon.hpp" +#include "pch.hpp" #include "entCache.h" -#include <netfsComms.h> +#include <exceptions.h> #define LOCK boost::unique_lock<boost::shared_mutex> _lck(lock) #define SLOCK boost::shared_lock<boost::shared_mutex> _lck(lock) @@ -32,7 +32,7 @@ EntCache<id_t, name_t>::getID(const name_t & u) const if (cu != idcache.right.end()) { return cu->second; } - throw NetFSComms::SystemError(EPERM); + throw NetFS::SystemError(EPERM); } template<class id_t, class name_t> @@ -52,7 +52,7 @@ EntCache<id_t, name_t>::getName(const id_t & u) const if (cu != idcache.left.end()) { return cu->second; } - throw NetFSComms::SystemError(EPERM); + throw NetFS::SystemError(EPERM); } template class EntCache<uid_t, std::string>; @@ -80,5 +80,3 @@ GroupEntCache::fillCache() const endgrent(); } - - diff --git a/netfs/entCache.h b/netfs/lib/entCache.h index c16cd0b..c16cd0b 100644 --- a/netfs/entCache.h +++ b/netfs/lib/entCache.h diff --git a/netfs/guidmap.h b/netfs/lib/guidmap.h index b550b30..b550b30 100644 --- a/netfs/guidmap.h +++ b/netfs/lib/guidmap.h diff --git a/netfs/pchCommon.hpp b/netfs/lib/pch.hpp index 5d4270b..e5ee5d7 100644 --- a/netfs/pchCommon.hpp +++ b/netfs/lib/pch.hpp @@ -8,17 +8,13 @@ #include <boost/thread/mutex.hpp> #include <boost/thread/shared_mutex.hpp> #include <boost/tuple/tuple.hpp> -#include "entCache.h" #include <exception> -#include "guidmap.h" #include <Ice/Ice.h> #include <intrusivePtrBase.h> #include <map> -#include "netfsComms.h" #include <set> #include <string> #include <typeinfo> -#include "xml.h" #endif #endif diff --git a/netfs/netfsComms.ice b/netfs/netfsComms.ice deleted file mode 100644 index 44f983a..0000000 --- a/netfs/netfsComms.ice +++ /dev/null @@ -1,85 +0,0 @@ -module NetFSComms { - // Exceptions - exception SystemError { - int syserrno; - }; - exception AuthError { - }; - exception ConfigError { - }; - // Types - struct VFS { - long blockSize; - long fragmentSize; - long blocks; - long freeBlocks; - long availBlocks; - long files; - long freeFiles; - long availFiles; - long FSID; - long flags; - long maxNameLen; - }; - struct Attr { - int dev; - long inode; - int mode; - int links; - string uid; - string gid; - int rdev; - long size; - long blockSize; - long blocks; - long atime; - long mtime; - long ctime; - }; - struct ReqEnv { - string user; - string grp; - long tok; - }; - sequence<byte> Buffer; - sequence<string> NameList; - // Interfaces - interface FileSystem { - idempotent void truncate(ReqEnv env, string path, long size) throws AuthError, SystemError; - idempotent void ftruncate(ReqEnv env, int id, long size) throws AuthError, SystemError; - idempotent Attr fgetattr(ReqEnv env, int id) throws AuthError, SystemError; - - void unlink(ReqEnv env, string path) throws AuthError, SystemError; - - int open(ReqEnv env, string path, int flags) throws AuthError, SystemError; - int create(ReqEnv env, string path, int flags, int mode) throws AuthError, SystemError; - void close(long tok, int id) throws AuthError, SystemError; - - idempotent Buffer read(long tok, int id, long offset, long size) throws AuthError, SystemError; - idempotent void write(long tok, int id, long offset, long size, Buffer data) throws AuthError, SystemError; - - int opendir(ReqEnv env, string path) throws AuthError, SystemError; - void closedir(long tok, int id) throws AuthError, SystemError; - idempotent NameList readdir(long tok, int id) throws AuthError, SystemError; - - void mkdir(ReqEnv env, string path, int mode) throws AuthError, SystemError; - void rmdir(ReqEnv env, string path) throws AuthError, SystemError; - - idempotent VFS statfs(ReqEnv env, string path) throws AuthError, SystemError; - - idempotent int access(ReqEnv env, string path, int mode) throws AuthError, SystemError; - idempotent Attr getattr(ReqEnv env, string path) throws AuthError, SystemError; - void symlink(ReqEnv env, string path1, string path2) throws AuthError, SystemError; - void link(ReqEnv env, string path1, string path2) throws AuthError, SystemError; - void rename(ReqEnv env, string from, string to) throws AuthError, SystemError; - idempotent string readlink(ReqEnv env, string path) throws AuthError, SystemError; - idempotent void chmod(ReqEnv env, string path, int mode) throws AuthError, SystemError; - idempotent void chown(ReqEnv env, string path, int uid, int gid) throws AuthError, SystemError; - idempotent void utimens(ReqEnv env, string path, long atime, long atimens, long mtime, long mtimens) throws AuthError, SystemError; - }; - interface Service { - long connect(string volume, string auth) throws AuthError, ConfigError; - void disconnect(long tok) throws AuthError; - }; -}; - |