From 90a05228972cd8d180c2723f71ba94e94d1133b3 Mon Sep 17 00:00:00 2001 From: randomdan Date: Sat, 17 Oct 2009 17:26:04 +0000 Subject: *** empty log message *** --- netfs/comms.cpp | 90 ++++++++++++++++ netfs/comms.h | 60 +++++++++++ netfs/configure | 1 + netfs/daemon.cpp | 223 ++++++++++++++++++++++++++++++++++++++ netfs/daemon.xml | 10 ++ netfs/daemonConfig.cpp | 27 +++++ netfs/daemonConfig.h | 31 ++++++ netfs/fuse.cpp | 283 +++++++++++++++++++++++++++++++++++++++++++++++++ netfs/fuseapp.cpp | 154 +++++++++++++++++++++++++++ netfs/fuseapp.h | 50 +++++++++ netfs/fusecallers.h | 4 + netfs/makefile.in | 63 +++++++++++ netfs/msgtypes.cpp | 152 ++++++++++++++++++++++++++ netfs/msgtypes.h | 212 ++++++++++++++++++++++++++++++++++++ netfs/xfers.h | 53 +++++++++ 15 files changed, 1413 insertions(+) create mode 100644 netfs/comms.cpp create mode 100644 netfs/comms.h create mode 100755 netfs/configure create mode 100644 netfs/daemon.cpp create mode 100644 netfs/daemon.xml create mode 100644 netfs/daemonConfig.cpp create mode 100644 netfs/daemonConfig.h create mode 100644 netfs/fuse.cpp create mode 100644 netfs/fuseapp.cpp create mode 100644 netfs/fuseapp.h create mode 100644 netfs/fusecallers.h create mode 100644 netfs/makefile.in create mode 100644 netfs/msgtypes.cpp create mode 100644 netfs/msgtypes.h create mode 100644 netfs/xfers.h diff --git a/netfs/comms.cpp b/netfs/comms.cpp new file mode 100644 index 0000000..86a7313 --- /dev/null +++ b/netfs/comms.cpp @@ -0,0 +1,90 @@ +#include +#include +#include +#include +#include +#include +#include "threads.h" +#include "comms.h" +#include "msgtypes.h" + +Semaphore outQueueSl(0); +Semaphore outQueueSu(30); +Semaphore inQueueS(0); +Mutex outQueueM; +Mutex inQueueM; +std::queue outQueue; +std::queue inQueue; + +Packet::Packet(uint8_t i, DataPayloadPtr p) : + index(i), + data(p) +{ +} +void +sendPacket(PacketPtr p) +{ + outQueueSu.wait(); + outQueueSl.post(); + AutoMutex am(outQueueM); + outQueue.push(p); +} + +void +packetSender(FILE * host) +{ + while (1) { + outQueueSl.wait(); + AutoMutex am(outQueueM); + // We can indicate an exit request by posting the semaphore without putting + // anything in the queue + if (outQueue.size() == 0) { + break; + } + outQueue.front()->write(host); + outQueueSu.post(); + } +} + +Packet::Packet(FILE * host) +{ + if (fread(&index, sizeof(index), 1, host) != 1) { + // error + } + DataPayload::TypeID t = 0; + if (fread(&t, sizeof(t), 1, host) != 1) { + // error + } + data = MsgFacs()[t](); + data->Read(host); +} +void +Packet::write(FILE * host) const +{ + if (fwrite(&index, sizeof(index), 1, host) != 1) { + // error + } + DataPayload::TypeID t = data->dataTypeID(); + if (fwrite(&t, sizeof(t), 1, host) != 1) { + // error + } + data->Send(host); + if (fflush(host) != 0) { + // + } +} + +PacketPtr +recvPacket() +{ + inQueueS.wait(); + AutoMutex am(inQueueM); + PacketPtr rtn = inQueue.front(); + inQueue.pop(); + return rtn; +} + +ContentBase::~ContentBase() +{ +} + diff --git a/netfs/comms.h b/netfs/comms.h new file mode 100644 index 0000000..54681b5 --- /dev/null +++ b/netfs/comms.h @@ -0,0 +1,60 @@ +#ifndef COMMS_H +#define COMMS_H + +#include +#include +#include +#include "smartpointer.h" + +class DataPayload : public IsRefCounted { + public: + typedef uint16_t TypeID; + + virtual TypeID dataTypeID() const = 0; + virtual void Send(FILE *) const = 0; + virtual void Read(FILE *) = 0; +}; +class NetFS; +template +class TypedPayload : public DataPayload { + public: + typedef SmartPointer > Ptr; + Type data; + TypeID dataTypeID() const { return Type::TypeID; } + void Send(FILE * h) const { data.Send(h); } + void Read(FILE * h) { data.Read(h); } +}; +template +class TypedPayloadReq : public TypedPayload { + public: + typedef typename Type::Reply Reply; + typedef SmartPointer > Ptr; + typedef SmartPointer > ReplyPtr; + TypedPayloadReq(fuse_context * fc) + { + TypedPayload::data.uid = fc->uid; + TypedPayload::data.gid = fc->gid; + } + ReplyPtr exchange(NetFS *); +}; + +typedef SmartPointer DataPayloadPtr; +typedef SmartPointer DataPayloadCPtr; + +class Packet : public IsRefCounted { + public: + Packet(FILE *); + Packet(uint8_t i, DataPayloadPtr p); + + void write(FILE *) const; + + uint8_t index; + DataPayloadPtr data; +}; +typedef SmartPointer PacketPtr; + +void +sendPacket(PacketPtr p); + +#endif + diff --git a/netfs/configure b/netfs/configure new file mode 100755 index 0000000..4d06840 --- /dev/null +++ b/netfs/configure @@ -0,0 +1 @@ +cp makefile.in makefile diff --git a/netfs/daemon.cpp b/netfs/daemon.cpp new file mode 100644 index 0000000..1cbb5bc --- /dev/null +++ b/netfs/daemon.cpp @@ -0,0 +1,223 @@ +#include +#include +#include +#include +#include +#include +#include +#include "daemonConfig.h" +#include "comms.h" +#include "msgtypes.h" +#include "misc.h" + +class DaemonGlobalState : public IsRefCounted { +}; +typedef SmartPointer DaemonGlobalStatePtr; +class Sender { + public: + Sender(int i, FILE * f) + { + idx = i; + host = f; + } + void Send(DataPayloadPtr p) + { + PacketPtr r = new Packet(idx, p); + r->write(host); + } + private: + int idx; + FILE * host; +}; +#define handler(type) void handle(SmartPointer > req, Sender & s) +handler(AccessRequest) +{ + TypedPayload * r = new TypedPayload(); + r->data.value = access(req->data.path.c_str(), req->data.access); + s.Send(r); +} +handler(GetAttrRequest) +{ + TypedPayload * r = new TypedPayload(); + r->data.res = stat(req->data.path.c_str(), &r->data.val); + s.Send(r); +} +int dirNo = 0; +std::map dirs; +handler(OpenDirRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + DIR * od = opendir(req->data.path.c_str()); + if (od) { + dirs[++dirNo] = od; + r->data.handle = dirNo; + } + r->data.error = errno; + s.Send(r); +} +handler(CloseDirRequest) +{ + TypedPayload * r = new TypedPayload(); + if (dirs.find(req->data.handle) != dirs.end()) { + errno = 0; + if (closedir(dirs[req->data.handle]) != 0) { + r->data.error = errno; + } + else { + dirs.erase(req->data.handle); + } + } + else { + r->data.error = EBADF; + } + s.Send(r); +} +typedef TypedPayload::Ptr DirContPLPtr; +typedef TypedPayload DirContPL; +typedef std::set DirContPLs; +handler(ReadDirRequest) +{ + TypedPayload * r = new TypedPayload(); + if (dirs.find(req->data.handle) != dirs.end()) { + errno = 0; + dirent * d; + DirContPLs ds; + while ((d = readdir(dirs[req->data.handle])) && errno == 0) { + DirContPLPtr dc = new DirContPL(); + dc->data.path = d->d_name; + ds.insert(dc); + } + r->data.error = errno; + r->data.count = ds.size(); + s.Send(r); + foreach(DirContPLs::const_iterator, ds, dir) { + s.Send(*dir); + } + } + else { + r->data.error = EBADF; + s.Send(r); + } +} +int fileNo = 0; +std::map files; +handler(OpenRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + int fd = open(req->data.path.c_str(), 0); + if (fd != -1) { + files[++fileNo] = fd; + r->data.handle = fileNo; + } + r->data.error = errno; + s.Send(r); +} +handler(CloseRequest) +{ + TypedPayload * r = new TypedPayload(); + if (files.find(req->data.handle) != files.end()) { + errno = 0; + if (close(files[req->data.handle]) != 0) { + r->data.error = errno; + } + else { + files.erase(req->data.handle); + } + } + else { + r->data.error = EBADF; + } + s.Send(r); +} +handler(ReadRequest) +{ + TypedPayload * r = new TypedPayload(); + if (files.find(req->data.handle) != files.end()) { + char * tmpdata = new char[req->data.size](); + errno = 0; + if (pread(files[req->data.handle], tmpdata, req->data.size, req->data.offset) != -1) { + r->data.data = tmpdata; + r->data.size = req->data.size; + } + else { + r->data.size = 0; + r->data.data = NULL; + } + r->data.error = errno; + } + else { + r->data.error = EBADF; + } + s.Send(r); +} +handler(WriteRequest) +{ + TypedPayload * r = new TypedPayload(); + if (files.find(req->data.handle) != files.end()) { + errno = 0; + if (pwrite(files[req->data.handle], req->data.data, req->data.size, req->data.offset) != -1) { + } + r->data.error = errno; + } + else { + r->data.error = EBADF; + } + s.Send(r); +} +#define TRYCLASS(cls) \ + if (type == cls::TypeID) { handle(p->data.as >(), s); } + +void +runDaemonOn(FILE * f, DaemonConfigPtr, DaemonGlobalStatePtr) +{ + while (true) { + PacketPtr p = new Packet(f); + Sender s(p->index, f); + uint16_t type (p->data->dataTypeID()); + TRYCLASS(AccessRequest); + TRYCLASS(GetAttrRequest); + TRYCLASS(OpenDirRequest); + TRYCLASS(CloseDirRequest); + TRYCLASS(ReadDirRequest); + TRYCLASS(OpenRequest); + TRYCLASS(CloseRequest); + TRYCLASS(ReadRequest); + TRYCLASS(WriteRequest); + } + fclose(f); +} + +int main(int, char* []) +{ + DaemonConfigPtr dc = DaemonConfig::Load("daemon.xml"); + struct addrinfo hints; + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + struct addrinfo *result, *rp; + int s = getaddrinfo(NULL, dc->tcpPort.c_str(), &hints, &result); + if (s) { + // Error + } + for (rp = result; rp != NULL; rp = rp->ai_next) { + int sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + if (sfd == -1) + continue; + if (bind(sfd, rp->ai_addr, rp->ai_addrlen) == 0) { + if (listen(sfd, 5)) { + // Error + } + DaemonGlobalStatePtr dgs = new DaemonGlobalState(); + for (int newfd; (newfd = accept(sfd, NULL, NULL)) > 0; ) { + runDaemonOn(fdopen(newfd, "a+"), dc, dgs); + } + break; + } + close(sfd); + } + return 0; +} + diff --git a/netfs/daemon.xml b/netfs/daemon.xml new file mode 100644 index 0000000..2454ff6 --- /dev/null +++ b/netfs/daemon.xml @@ -0,0 +1,10 @@ + + 4000 + + + tmp + /tmp + + + + diff --git a/netfs/daemonConfig.cpp b/netfs/daemonConfig.cpp new file mode 100644 index 0000000..520cec1 --- /dev/null +++ b/netfs/daemonConfig.cpp @@ -0,0 +1,27 @@ +#include "daemonConfig.h" +#include + +DaemonConfigPtr +DaemonConfig::Load(const char * path) +{ + xmlDoc * doc = xmlReadFile(path, NULL, 0); + DaemonConfigPtr dc = new DaemonConfig(doc->children); + xmlFreeDoc(doc); + return dc; +} + +DaemonConfig::DaemonConfig(xmlNodePtr conf) : + tcpPort(xmlGetNodeValue(conf, "tcpPort")) +{ + foreachxml(exp, xmlGetNode(conf, "exports"), "export") { + ExportPtr e = new Export(exp); + exports[e->name] = e; + } +} + +DaemonConfig::Export::Export(xmlNodePtr exp) : + root(xmlGetNodeValue(exp, "root")), + name(xmlGetNodeValue(exp, "name")) +{ +} + diff --git a/netfs/daemonConfig.h b/netfs/daemonConfig.h new file mode 100644 index 0000000..d15fade --- /dev/null +++ b/netfs/daemonConfig.h @@ -0,0 +1,31 @@ +#ifndef DAEMONCONFIG_H +#define DAEMONCONFIG_H + +#include +#include +#include "smartpointer.h" +#include "xml.h" + +class DaemonConfig : public virtual IsRefCounted { + public: + class Export : public virtual IsRefCounted { + public: + Export(xmlNodePtr); + + std::string root; + std::string name; + }; + typedef SmartPointer ExportPtr; + typedef std::map ExportMap; + + DaemonConfig(xmlNodePtr); + static SmartPointer Load(const char * path); + + + std::string tcpPort; + ExportMap exports; +}; +typedef SmartPointer DaemonConfigPtr; + +#endif + diff --git a/netfs/fuse.cpp b/netfs/fuse.cpp new file mode 100644 index 0000000..610605d --- /dev/null +++ b/netfs/fuse.cpp @@ -0,0 +1,283 @@ +#include +#include +#include +#include "fuseapp.h" +#include +#include +#include +#include "comms.h" +#include "msgtypes.h" + +static FuseAppBase * fuseApp; + +template +static int fuseCall(A a) +{ + try { + return (fuseApp->*f)(a); + } + catch (...) { + return -ENOSYS; + } +} +template +static int fuseCall(A a, B b) +{ + try { + return (fuseApp->*f)(a, b); + } + catch (...) { + return -ENOSYS; + } +} +template +static int fuseCall(A a, B b, C c) +{ + try { + return (fuseApp->*f)(a, b, c); + } + catch (...) { + return -ENOSYS; + } +} +template +static int fuseCall(A a, B b, C c, D d) +{ + try { + return (fuseApp->*f)(a, b, c, d); + } + catch (...) { + return -ENOSYS; + } +} +template +static int fuseCall(A a, B b, C c, D d, E e) +{ + try { + return (fuseApp->*f)(a, b, c, d, e); + } + catch (...) { + return -ENOSYS; + } +} +static void * fuseInit (struct fuse_conn_info *conn) +{ + return fuseApp->init(conn); +} +template +static void fuseDestroy(void * x) +{ + delete (App*)x; +} + +class NetFS : public FuseAppBase +{ + int access(const char * p, int a) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.access = a; + msg->data.path = p; + return -msg->exchange(this)->data.value; + } + int getattr(const char * p, struct stat * s) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + TypedPayload::Ptr rep = msg->exchange(this); + *s = rep->data.val; + return -rep->data.res; + } + int opendir(const char * p, struct fuse_file_info * fi) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + TypedPayload::Ptr rep = msg->exchange(this); + fi->fh = rep->data.handle; + return -rep->data.error; + } + int releasedir(const char *, struct fuse_file_info * fi) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.handle = fi->fh; + TypedPayload::Ptr rep = msg->exchange(this); + return -rep->data.error; + } + int readdir(const char *, void * buf, fuse_fill_dir_t filler, off_t, struct fuse_file_info * fi) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.handle = fi->fh; + TypedPayload::Ptr rep = msg->exchange(this); + size_t cnt = rep->data.count; + while (cnt--) { + TypedPayload::Ptr dir = recvType(); + filler(buf, dir->data.path.c_str(), &dir->data.val, 0); + } + return -rep->data.error; + } + int open(const char * p, struct fuse_file_info * fi) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + TypedPayload::Ptr rep = msg->exchange(this); + fi->fh = rep->data.handle; + return -rep->data.error; + } + int release(const char *, struct fuse_file_info * fi) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.handle = fi->fh; + TypedPayload::Ptr rep = msg->exchange(this); + return -rep->data.error; + } + int read(const char *, char * buf, size_t s, off_t o, struct fuse_file_info * fi) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.handle = fi->fh; + msg->data.offset = o; + msg->data.size = s; + TypedPayload::Ptr rep = msg->exchange(this); + if (rep->data.size) { + memcpy(buf, rep->data.data, std::min(s, rep->data.size)); + return rep->data.size; + } + else { + return -rep->data.error; + } + } + int write(const char *, const char * buf, size_t s, off_t o, struct fuse_file_info * fi) + { + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.handle = fi->fh; + msg->data.offset = o; + msg->data.size = s; + msg->data.data = new char[s](); + memcpy(msg->data.data, buf, s); + TypedPayload::Ptr rep = msg->exchange(this); + return -rep->data.error; + } + public: + NetFS() : + f(NULL) + { + struct addrinfo hints; + memset(&hints, 0, sizeof(struct addrinfo)); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; + struct addrinfo *result, *rp; + int s = getaddrinfo("localhost", "4000", &hints, &result); + if (s) { + // Error + } + for (rp = result; rp != NULL; rp = rp->ai_next) { + int sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + if (sfd == -1) + // Error + continue; + if (connect(sfd, rp->ai_addr, rp->ai_addrlen)) { + // Error + continue; + } + f = fdopen(sfd, "a+"); + break; + } + } + ~NetFS() + { + if (f) { + fclose(f); + } + } + DataPayloadPtr exchange(DataPayloadPtr dp) + { + send(dp); + return recv(); + } + void send(DataPayloadPtr dp) + { + PacketPtr sendme = new Packet(0, dp); + sendme->write(f); + } + DataPayloadPtr recv() + { + PacketPtr recvd = new Packet(f); + return recvd->data; + } + template + SmartPointer > recvType() + { + DataPayloadPtr p = this->recv(); + return p.as >(); + } + private: + FILE * f; +}; +template +SmartPointer > TypedPayloadReq::exchange(NetFS * net) +{ + DataPayloadPtr p = net->exchange(this); + return p.as >(); +} + +template +int runFuseApp(int argc, char* argv[]) +{ + struct fuse_opt fuse_opts[] = { + { NULL, 0, 0 } + }; + + fuseApp = new FuseApp(); + struct fuse_operations operations = { + fuseCall, + fuseCall, + NULL, // getdir deprecated + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + NULL, // utime deprecated + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseInit, + fuseDestroy, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall, + fuseCall + }; + struct fuse_args args = FUSE_ARGS_INIT(argc, argv); + if (fuse_opt_parse(&args, fuseApp, fuse_opts, + fuseCall) == -1) { + exit(1); + } + return fuse_main(args.argc, args.argv, &operations, NULL); +} + +int +main(int argc, char* argv[]) +{ + return runFuseApp(argc, argv); +} + diff --git a/netfs/fuseapp.cpp b/netfs/fuseapp.cpp new file mode 100644 index 0000000..b46d3ad --- /dev/null +++ b/netfs/fuseapp.cpp @@ -0,0 +1,154 @@ +#include "fuseapp.h" +#include + +FuseAppBase::FuseAppBase() +{ +} +FuseAppBase::~FuseAppBase() +{ +} +void * FuseAppBase::init(fuse_conn_info*) +{ + return NULL; +} +int FuseAppBase::opt_parse(void*, const char *, int, fuse_args*) +{ + return 1; +} +int FuseAppBase::access(const char *, int) +{ + return -ENOSYS; +} +int FuseAppBase::chmod(const char *, mode_t) +{ + return -ENOSYS; +} +int FuseAppBase::chown(const char *, uid_t, gid_t) +{ + return -ENOSYS; +} +int FuseAppBase::create(const char *, mode_t, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::fgetattr(const char *, struct stat *, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::flush(const char *, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::fsync(const char *, int, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::fsyncdir(const char *, int, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::ftruncate(const char *, off_t, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::getattr(const char *, struct stat *) +{ + return -ENOSYS; +} +int FuseAppBase::getxattr(const char *, const char *, char *, size_t) +{ + return -ENOSYS; +} +int FuseAppBase::link(const char *, const char *) +{ + return -ENOSYS; +} +int FuseAppBase::listxattr(const char *, char *, size_t) +{ + return -ENOSYS; +} +int FuseAppBase::mkdir(const char *, mode_t) +{ + return -ENOSYS; +} +int FuseAppBase::mknod(const char *, mode_t, dev_t) +{ + return -ENOSYS; +} +int FuseAppBase::open(const char *, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::opendir(const char *, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::read(const char *, char *, size_t, off_t, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::readdir(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::readlink(const char *, char *, size_t) +{ + return -ENOSYS; +} +int FuseAppBase::release(const char *, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::releasedir(const char *, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::removexattr(const char *, const char *) +{ + return -ENOSYS; +} +int FuseAppBase::rename(const char *, const char *) +{ + return -ENOSYS; +} +int FuseAppBase::rmdir(const char *) +{ + return -ENOSYS; +} +int FuseAppBase::setxattr(const char *, const char *, const char *, size_t, int) +{ + return -ENOSYS; +} +int FuseAppBase::statfs(const char *, struct statvfs *) +{ + return -ENOSYS; +} +int FuseAppBase::symlink(const char *, const char *) +{ + return -ENOSYS; +} +int FuseAppBase::truncate(const char *, off_t) +{ + return -ENOSYS; +} +int FuseAppBase::unlink(const char *) +{ + return -ENOSYS; +} +int FuseAppBase::write(const char *, const char *, size_t, off_t, struct fuse_file_info *) +{ + return -ENOSYS; +} +int FuseAppBase::lock(const char *, struct fuse_file_info *, int, struct flock *) +{ + return -ENOSYS; +} +int FuseAppBase::utimens(const char *, const struct timespec[2]) +{ + return -ENOSYS; +} +int FuseAppBase::bmap(const char *, size_t, uint64_t *) +{ + return -ENOSYS; +} + diff --git a/netfs/fuseapp.h b/netfs/fuseapp.h new file mode 100644 index 0000000..965ef0d --- /dev/null +++ b/netfs/fuseapp.h @@ -0,0 +1,50 @@ +#ifndef FUSEAPP_H +#define FUSEAPP_H + +#define FUSE_USE_VERSION 26 +#include + +class FuseAppBase { + public: + FuseAppBase(); + virtual ~FuseAppBase() = 0; + virtual void * init (struct fuse_conn_info * info); + virtual int opt_parse(void *, const char * arg, int key, struct fuse_args *); + virtual int access(const char *, int); + virtual int chmod(const char *, mode_t); + virtual int chown(const char *, uid_t, gid_t); + virtual int create(const char *, mode_t, struct fuse_file_info *); + virtual int fgetattr(const char *, struct stat *, struct fuse_file_info *); + virtual int flush(const char *, struct fuse_file_info *); + virtual int fsync(const char *, int, struct fuse_file_info *); + virtual int fsyncdir(const char *, int, struct fuse_file_info *); + virtual int ftruncate(const char *, off_t, struct fuse_file_info *); + virtual int getattr(const char *, struct stat *); + virtual int getxattr(const char *, const char *, char *, size_t); + virtual int link(const char *, const char *); + virtual int listxattr(const char *, char *, size_t); + virtual int mkdir(const char *, mode_t); + virtual int mknod(const char *, mode_t, dev_t); + virtual int open(const char *, struct fuse_file_info *); + virtual int opendir(const char *, struct fuse_file_info *); + virtual int read(const char *, char *, size_t, off_t, struct fuse_file_info *); + virtual int readdir(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *); + virtual int readlink(const char *, char *, size_t); + virtual int release(const char *, struct fuse_file_info *); + virtual int releasedir(const char *, struct fuse_file_info *); + virtual int removexattr(const char *, const char *); + virtual int rename(const char *, const char *); + virtual int rmdir(const char *); + virtual int setxattr(const char *, const char *, const char *, size_t, int); + virtual int statfs(const char *, struct statvfs *); + virtual int symlink(const char *, const char *); + virtual int truncate(const char *, off_t); + virtual int unlink(const char *); + virtual int write(const char *, const char *, size_t, off_t, struct fuse_file_info *); + virtual int lock(const char *, struct fuse_file_info *, int cmd, struct flock *); + virtual int utimens(const char *, const struct timespec tv[2]); + virtual int bmap(const char *, size_t blocksize, uint64_t *idx); +}; + +#endif + diff --git a/netfs/fusecallers.h b/netfs/fusecallers.h new file mode 100644 index 0000000..cb521df --- /dev/null +++ b/netfs/fusecallers.h @@ -0,0 +1,4 @@ +#ifndef FUSECALLERS_H +#define FUSECALLERS_H +#endif + diff --git a/netfs/makefile.in b/netfs/makefile.in new file mode 100644 index 0000000..f7901ba --- /dev/null +++ b/netfs/makefile.in @@ -0,0 +1,63 @@ +FUSEFLAGS=-D_FILE_OFFSET_BITS=64 +COMPFLAGS=-DTHREADSAFE -I ../libmisc -I /usr/include/libxml2 +myCXXFLAGS=${CXXFLAGS} ${COMPFLAGS} ${FUSEFLAGS} +LDFLAGS=-lfuse -Xlinker --warn-once -L ../libmisc -l misc -l xml2 +CXX=g++ +CC=${CXX} +default : makefile all + +-include makedeps.mk + +all : makedeps.mk tags netfs netfsd +makefile : makefile.in + @echo "Makefile out of date. Please re-run configure." + @false + +makedeps.mk : $(patsubst %.cpp, %.d, $(wildcard *.cpp)) $(wildcard *.h) + cat *.d > $@ + +%.o : %.d + +%.o : %.cpp + g++ -c ${myCXXFLAGS} $< -o $@ +%.d : %.cpp $(wildcard *.h) + g++ -M ${myCXXFLAGS} $< -o $@ + +tags : $(wildcard *.c*) $(wildcard *.h) + @exuberant-ctags -R + +NETFSOBJS= \ + comms.o \ + fuse.o \ + fuseapp.o \ + msgtypes.o \ + +NETFSDOBJS= \ + comms.o \ + daemon.o \ + daemonConfig.o \ + msgtypes.o \ + +netfs : ${NETFSOBJS} + g++ -o $@ ${NETFSOBJS} ${LDFLAGS} + +netfsd : ${NETFSDOBJS} + g++ -o $@ ${NETFSDOBJS} ${LDFLAGS} + +.SUFFIXES: .cpp .o +.PHONY: clean test mount umount install uninstall + +clean : + rm -f *.o *.d + rm -f netfsd netfs + rm -f makedeps.mk + +install : netfs netfsd + cp -f netfs /usr/bin/netfs + ln -sf /usr/bin/netfs /sbin/mount.netfs + cp -f netfsd /sbin/netfsd + +uninstall : + rm -f /usr/bin/netfs + rm -f /sbin/mount.netfs + rm -f /sbin/netfsd diff --git a/netfs/msgtypes.cpp b/netfs/msgtypes.cpp new file mode 100644 index 0000000..e7a814e --- /dev/null +++ b/netfs/msgtypes.cpp @@ -0,0 +1,152 @@ +#include "msgtypes.h" +#include "xfers.h" + +MessageFactories & MsgFacs() +{ + static MessageFactories m; + return m; +} + +MSGTYPE(0, SimpleInt) +MSGTYPE(1, AccessRequest) +MSGTYPE(2, GetAttrRequest) +MSGTYPE(3, GetAttrReply) +MSGTYPE(4, OpenDirRequest) +MSGTYPE(5, OpenDirReply) +MSGTYPE(6, CloseDirRequest) +MSGTYPE(7, CloseDirReply) +MSGTYPE(8, ReadDirRequest) +MSGTYPE(9, ReadDirReply) +MSGTYPE(10, ReadDirContent) +MSGTYPE(11, OpenRequest) +MSGTYPE(12, OpenReply) +MSGTYPE(13, CloseRequest) +MSGTYPE(14, CloseReply) +MSGTYPE(15, ReadRequest) +MSGTYPE(16, ReadReply) +MSGTYPE(17, WriteRequest) +MSGTYPE(18, WriteReply) + +template void operator<<(FILE &, const Type & t); +template void operator>>(FILE &, Type & t); + +template<> void operator<<(FILE & f, const std::string & t) +{ + std::string::size_type len = t.length(); + f << len; + if (fwrite(t.data(), len, 1, &f) < len) { + } +} +template<> void operator>>(FILE & f, std::string & t) +{ + std::string::size_type len; + f >> len; + t.clear(); + t.reserve(len); + while (len --) { + t.push_back(fgetc(&f)); + } +} +template void operator<<(FILE & f, const Type & t) +{ + if (fwrite(&t, sizeof(t), 1, &f) < sizeof(t)) { + } +} +template void operator>>(FILE & f, Type & t) +{ + if (fread(&t, sizeof(t), 1, &f) < sizeof(t)) { + } +} + +void +ContentBase::Send(FILE*) const +{ +} +void +ContentBase::Read(FILE*) +{ +} +Xfer2(RequestBase, ContentBase, uid, gid) +Xfer1(OpenDirRequest, RequestBase, path) +Xfer2(OpenDirReply, ContentBase, error, handle) +Xfer2(ReadDirReply, ContentBase, error, count) +Xfer1(ReadDirRequest, RequestBase, handle) +Xfer2(AccessRequest, RequestBase, path, access) +Xfer1(SimpleInt, ContentBase, value) +Xfer1(GetAttrRequest, RequestBase, path) +Xfer2(GetAttrReply, ContentBase, res, val) +Xfer1(CloseDirRequest, RequestBase, handle) +Xfer1(CloseDirReply, ContentBase, error) +Xfer2(ReadDirContent, ContentBase, path, val) +Xfer1(OpenRequest, RequestBase, path) +Xfer2(OpenReply, ContentBase, error, handle) +Xfer1(CloseRequest, RequestBase, handle) +Xfer1(CloseReply, ContentBase, error) +Xfer3(ReadRequest, RequestBase, handle, offset, size) +Xfer1(WriteReply, ContentBase, error) + +ReadReply::~ReadReply() +{ + if (data) { + delete[] data; + } +} +void +ReadReply::Send(FILE*f) const +{ + ContentBase::Send(f); + *f << error; + *f << size; + if (size) { + if (fwrite(data, size, 1, f) < size) { + } + } +} +void +ReadReply::Read(FILE*f) +{ + ContentBase::Read(f); + *f >> error; + *f >> size; + if (size) { + data = new char[size](); + if (fread(data, size, 1, f) < size) { + } + } + else { + data = NULL; + } +} + +WriteRequest::~WriteRequest() +{ + if (data) { + delete[] data; + } +} +void +WriteRequest::Send(FILE*f) const +{ + RequestBase::Send(f); + *f << handle; + *f << size; + *f << offset; + if (fwrite(data, size, 1, f) < size) { + } +} +void +WriteRequest::Read(FILE*f) +{ + RequestBase::Read(f); + *f >> handle; + *f >> size; + *f >> offset; + if (size) { + data = new char[size](); + if (fread(data, size, 1, f) < size) { + } + } + else { + data = NULL; + } +} diff --git a/netfs/msgtypes.h b/netfs/msgtypes.h new file mode 100644 index 0000000..c29dc93 --- /dev/null +++ b/netfs/msgtypes.h @@ -0,0 +1,212 @@ +#ifndef MSGTYPES_H +#define MSGTYPES_H + +#include "smartpointer.h" +#include "comms.h" +#include +#include +#include +#include + +typedef DataPayloadPtr (*MessageFactory)(); +typedef std::map MessageFactories; +MessageFactories & MsgFacs(); + +template +class Factory { + public: + Factory() { MsgFacs()[Cls::TypeID] = &create; } + static DataPayloadPtr create() { + return new TypedPayload(); + } +}; + +class ContentBase : public IsRefCounted { + public: + ~ContentBase() = 0; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class RequestBase : public ContentBase { + public: + uid_t uid; + gid_t gid; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class SimpleInt : public ContentBase { + public: + int value; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class AccessRequest : public RequestBase { + public: + std::string path; + int access; + const static uint16_t TypeID; + typedef SimpleInt Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class GetAttrReply : public ContentBase { + public: + int res; + struct stat val; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class GetAttrRequest : public RequestBase { + public: + std::string path; + const static uint16_t TypeID; + typedef GetAttrReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class OpenDirReply : public ContentBase { + public: + int handle; + int error; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class OpenDirRequest : public RequestBase { + public: + std::string path; + const static uint16_t TypeID; + typedef OpenDirReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class CloseDirReply : public ContentBase { + public: + int error; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class CloseDirRequest : public RequestBase { + public: + int handle; + const static uint16_t TypeID; + typedef CloseDirReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class ReadDirReply : public ContentBase { + public: + int error; + size_t count; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class ReadDirRequest : public RequestBase { + public: + int handle; + const static uint16_t TypeID; + typedef ReadDirReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class ReadDirContent : public ContentBase { + public: + std::string path; + struct stat val; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +class OpenReply : public ContentBase { + public: + int error; + int handle; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class OpenRequest : public RequestBase { + public: + std::string path; + const static uint16_t TypeID; + typedef OpenReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class CloseReply : public ContentBase { + public: + int error; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class CloseRequest : public RequestBase { + public: + int handle; + const static uint16_t TypeID; + typedef CloseReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class ReadReply : public ContentBase { + public: + ~ReadReply(); + int error; + char * data; + size_t size; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class ReadRequest : public RequestBase { + public: + int handle; + size_t size; + off_t offset; + const static uint16_t TypeID; + typedef ReadReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class WriteReply : public ContentBase { + public: + int error; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class WriteRequest : public RequestBase { + public: + ~WriteRequest(); + int handle; + size_t size; + char * data; + off_t offset; + const static uint16_t TypeID; + typedef WriteReply Reply; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; + +#define MSGTYPE(id, cls) \ + const uint16_t cls::TypeID = id; \ + namespace FactoryFor##cls { Factory fac; } +#endif + diff --git a/netfs/xfers.h b/netfs/xfers.h new file mode 100644 index 0000000..c1369eb --- /dev/null +++ b/netfs/xfers.h @@ -0,0 +1,53 @@ +#ifndef XFERS_H +#define XFERS_H + +#define Xfer1(Ptype, Pbase, v1) \ +void \ +Ptype::Send(FILE*f) const \ +{ \ + Pbase::Send(f); \ + *f << v1; \ +} \ +void \ +Ptype::Read(FILE*f) \ +{ \ + Pbase::Read(f); \ + *f >> v1; \ +} + +#define Xfer2(Ptype, Pbase, v1, v2) \ +void \ +Ptype::Send(FILE*f) const \ +{ \ + Pbase::Send(f); \ + *f << v1; \ + *f << v2; \ +} \ +void \ +Ptype::Read(FILE*f) \ +{ \ + Pbase::Read(f); \ + *f >> v1; \ + *f >> v2; \ +} + +#define Xfer3(Ptype, Pbase, v1, v2, v3) \ +void \ +Ptype::Send(FILE*f) const \ +{ \ + Pbase::Send(f); \ + *f << v1; \ + *f << v2; \ + *f << v3; \ +} \ +void \ +Ptype::Read(FILE*f) \ +{ \ + Pbase::Read(f); \ + *f >> v1; \ + *f >> v2; \ + *f >> v3; \ +} + +#endif + -- cgit v1.2.3