From 212a4763b7f5236e05b38f6ab5190678e1926c0a Mon Sep 17 00:00:00 2001 From: randomdan Date: Fri, 23 Oct 2009 19:17:14 +0000 Subject: All basic funcs implemented, not tested --- netfs/comms.cpp | 10 +-- netfs/comms.h | 19 +++-- netfs/daemon.cpp | 183 ++++++++---------------------------------------- netfs/daemon.h | 49 +++++++++++++ netfs/daemonDirs.cpp | 82 ++++++++++++++++++++++ netfs/daemonFS.cpp | 20 ++++++ netfs/daemonFiles.cpp | 118 +++++++++++++++++++++++++++++++ netfs/daemonMisc.cpp | 108 ++++++++++++++++++++++++++++ netfs/fuse.cpp | 190 ++++++++++++-------------------------------------- netfs/fuse.h | 60 ++++++++++++++++ netfs/fuseDirs.cpp | 48 +++++++++++++ netfs/fuseFS.cpp | 13 ++++ netfs/fuseFiles.cpp | 75 ++++++++++++++++++++ netfs/fuseMisc.cpp | 87 +++++++++++++++++++++++ netfs/makefile.in | 8 +++ netfs/msgtypes.cpp | 30 +++++--- netfs/msgtypes.h | 10 +++ 17 files changed, 793 insertions(+), 317 deletions(-) create mode 100644 netfs/daemon.h create mode 100644 netfs/daemonDirs.cpp create mode 100644 netfs/daemonFS.cpp create mode 100644 netfs/daemonFiles.cpp create mode 100644 netfs/daemonMisc.cpp create mode 100644 netfs/fuse.h create mode 100644 netfs/fuseDirs.cpp create mode 100644 netfs/fuseFS.cpp create mode 100644 netfs/fuseFiles.cpp create mode 100644 netfs/fuseMisc.cpp diff --git a/netfs/comms.cpp b/netfs/comms.cpp index 86a7313..5993ac7 100644 --- a/netfs/comms.cpp +++ b/netfs/comms.cpp @@ -49,11 +49,11 @@ packetSender(FILE * host) Packet::Packet(FILE * host) { if (fread(&index, sizeof(index), 1, host) != 1) { - // error + throw ReadMessageFailed(); } DataPayload::TypeID t = 0; if (fread(&t, sizeof(t), 1, host) != 1) { - // error + throw ReadMessageFailed(); } data = MsgFacs()[t](); data->Read(host); @@ -62,15 +62,15 @@ void Packet::write(FILE * host) const { if (fwrite(&index, sizeof(index), 1, host) != 1) { - // error + throw WriteMessageFailed(); } DataPayload::TypeID t = data->dataTypeID(); if (fwrite(&t, sizeof(t), 1, host) != 1) { - // error + throw WriteMessageFailed(); } data->Send(host); if (fflush(host) != 0) { - // + throw WriteMessageFailed(); } } diff --git a/netfs/comms.h b/netfs/comms.h index 54681b5..cd25a9e 100644 --- a/netfs/comms.h +++ b/netfs/comms.h @@ -3,9 +3,13 @@ #include #include -#include #include "smartpointer.h" +#include "fuseapp.h" +class WriteMessageFailed : std::exception { +}; +class ReadMessageFailed : std::exception { +}; class DataPayload : public IsRefCounted { public: typedef uint16_t TypeID; @@ -24,6 +28,9 @@ class TypedPayload : public DataPayload { void Send(FILE * h) const { data.Send(h); } void Read(FILE * h) { data.Read(h); } }; +typedef SmartPointer DataPayloadPtr; +typedef SmartPointer DataPayloadCPtr; + template class TypedPayloadReq : public TypedPayload { public: @@ -35,11 +42,15 @@ class TypedPayloadReq : public TypedPayload { TypedPayload::data.uid = fc->uid; TypedPayload::data.gid = fc->gid; } - ReplyPtr exchange(NetFS *); + ReplyPtr exchange(NetFS * net); + /* + { + DataPayloadPtr p = net->exchange(this); + return p.as >(); + } + */ }; -typedef SmartPointer DataPayloadPtr; -typedef SmartPointer DataPayloadCPtr; class Packet : public IsRefCounted { public: diff --git a/netfs/daemon.cpp b/netfs/daemon.cpp index 1cbb5bc..b029316 100644 --- a/netfs/daemon.cpp +++ b/netfs/daemon.cpp @@ -1,7 +1,6 @@ #include #include #include -#include #include #include #include @@ -9,163 +8,19 @@ #include "comms.h" #include "msgtypes.h" #include "misc.h" +#include "daemon.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) +Sender::Sender(int i, FILE * f) { - 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); + idx = i; + host = f; } -handler(CloseRequest) +void Sender::Send(DataPayloadPtr p) { - 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); + PacketPtr r = new Packet(idx, p); + r->write(host); } + #define TRYCLASS(cls) \ if (type == cls::TypeID) { handle(p->data.as >(), s); } @@ -176,15 +31,33 @@ runDaemonOn(FILE * f, DaemonConfigPtr, DaemonGlobalStatePtr) PacketPtr p = new Packet(f); Sender s(p->index, f); uint16_t type (p->data->dataTypeID()); - TRYCLASS(AccessRequest); - TRYCLASS(GetAttrRequest); + // Dirs TRYCLASS(OpenDirRequest); TRYCLASS(CloseDirRequest); TRYCLASS(ReadDirRequest); + TRYCLASS(RmDirRequest); + TRYCLASS(MkDirRequest); + // Misc + TRYCLASS(AccessRequest); + TRYCLASS(GetAttrRequest); + TRYCLASS(FgetAttrRequest); + TRYCLASS(UnlinkRequest); + TRYCLASS(SymlinkRequest); + TRYCLASS(LinkRequest); + TRYCLASS(RenameRequest); + TRYCLASS(ReadlinkRequest); + TRYCLASS(ChmodRequest); + TRYCLASS(ChownRequest); + // Files TRYCLASS(OpenRequest); TRYCLASS(CloseRequest); TRYCLASS(ReadRequest); TRYCLASS(WriteRequest); + TRYCLASS(TruncateRequest); + TRYCLASS(FtruncateRequest); + TRYCLASS(CreateRequest); + // FS + TRYCLASS(StatfsRequest); } fclose(f); } diff --git a/netfs/daemon.h b/netfs/daemon.h new file mode 100644 index 0000000..2517529 --- /dev/null +++ b/netfs/daemon.h @@ -0,0 +1,49 @@ +#ifndef DAEMON_H +#define DAEMON_H + +#include "comms.h" +#include "msgtypes.h" + +class DaemonGlobalState : public IsRefCounted { +}; +typedef SmartPointer DaemonGlobalStatePtr; +class Sender { + public: + Sender(int i, FILE * f); + void Send(DataPayloadPtr p); + private: + int idx; + FILE * host; +}; + +#define handler(type) void handle(SmartPointer > req, Sender & s) +// Dirs +handler(OpenDirRequest); +handler(CloseDirRequest); +handler(ReadDirRequest); +handler(RmDirRequest); +handler(MkDirRequest); +// Misc +handler(AccessRequest); +handler(GetAttrRequest); +handler(FgetAttrRequest); +handler(UnlinkRequest); +handler(SymlinkRequest); +handler(LinkRequest); +handler(RenameRequest); +handler(ReadlinkRequest); +handler(ChmodRequest); +handler(ChownRequest); +// Files +handler(OpenRequest); +handler(CloseRequest); +handler(ReadRequest); +handler(WriteRequest); +handler(TruncateRequest); +handler(FtruncateRequest); +handler(CreateRequest); +// FS +handler(StatfsRequest); + +#endif + diff --git a/netfs/daemonDirs.cpp b/netfs/daemonDirs.cpp new file mode 100644 index 0000000..89b2426 --- /dev/null +++ b/netfs/daemonDirs.cpp @@ -0,0 +1,82 @@ +#include +#include +#include +#include "comms.h" +#include "msgtypes.h" +#include "daemon.h" +#include "misc.h" + +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); + } +} +handler(MkDirRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + mkdir(req->data.path.c_str(), req->data.mode); + r->data.value = errno; + s.Send(r); +} +handler(RmDirRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + rmdir(req->data.path.c_str()); + r->data.value = errno; + s.Send(r); +} diff --git a/netfs/daemonFS.cpp b/netfs/daemonFS.cpp new file mode 100644 index 0000000..f8220ea --- /dev/null +++ b/netfs/daemonFS.cpp @@ -0,0 +1,20 @@ +#include +#include +#include "comms.h" +#include "msgtypes.h" +#include "daemon.h" +#include "misc.h" + +handler(StatfsRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (statvfs(req->data.path.c_str(), &r->data.statfs) != 0) { + r->data.error = errno; + } + else { + r->data.error = 0; + } + s.Send(r); +} + diff --git a/netfs/daemonFiles.cpp b/netfs/daemonFiles.cpp new file mode 100644 index 0000000..fe518ae --- /dev/null +++ b/netfs/daemonFiles.cpp @@ -0,0 +1,118 @@ +#include +#include +#include "comms.h" +#include "msgtypes.h" +#include "daemon.h" +#include "misc.h" + +handler(TruncateRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (truncate(req->data.path.c_str(), req->data.size) != 0) { + r->data.value = errno; + } + else { + r->data.value = 0; + } + s.Send(r); +} +handler(FtruncateRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (ftruncate(req->data.handle, req->data.size) != 0) { + r->data.value = errno; + } + else { + r->data.value = 0; + } + s.Send(r); +} +handler(UnlinkRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + unlink(req->data.path.c_str()); + r->data.value = errno; + 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(CreateRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + int fd = open(req->data.path.c_str(), O_CREAT, req->data.mode); + 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); +} + diff --git a/netfs/daemonMisc.cpp b/netfs/daemonMisc.cpp new file mode 100644 index 0000000..e3cebc3 --- /dev/null +++ b/netfs/daemonMisc.cpp @@ -0,0 +1,108 @@ +#include +#include +#include +#include +#include "comms.h" +#include "msgtypes.h" +#include "daemon.h" +#include "misc.h" + +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(); + errno = 0; + r->data.res = stat(req->data.path.c_str(), &r->data.val); + r->data.res = errno; + s.Send(r); +} +handler(FgetAttrRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + r->data.res = fstat(req->data.handle, &r->data.val); + r->data.res = errno; + s.Send(r); +} +handler(SymlinkRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (symlink(req->data.path1.c_str(), req->data.path2.c_str()) != 0) { + r->data.value = errno; + } + else { + r->data.value = 0; + } + s.Send(r); +} +handler(LinkRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (link(req->data.path1.c_str(), req->data.path2.c_str()) != 0) { + r->data.value = errno; + } + else { + r->data.value = 0; + } + s.Send(r); +} +handler(RenameRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (rename(req->data.path1.c_str(), req->data.path2.c_str()) != 0) { + r->data.value = errno; + } + else { + r->data.value = 0; + } + s.Send(r); +} +handler(ReadlinkRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + char buf[PATH_MAX]; + ssize_t rc = readlink(req->data.path.c_str(), buf, PATH_MAX); + if (rc == -1) { + r->data.error = errno; + } + else { + buf[rc] = '\0'; + r->data.path = buf; + r->data.error = 0; + } + s.Send(r); +} +handler(ChmodRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (chmod(req->data.path.c_str(), req->data.mode) != 0) { + r->data.value = errno; + } + else { + r->data.value = 0; + } + s.Send(r); +} +handler(ChownRequest) +{ + TypedPayload * r = new TypedPayload(); + errno = 0; + if (chown(req->data.path.c_str(), req->data.user, req->data.group) != 0) { + r->data.value = errno; + } + else { + r->data.value = 0; + } + s.Send(r); +} + diff --git a/netfs/fuse.cpp b/netfs/fuse.cpp index 610605d..c540af1 100644 --- a/netfs/fuse.cpp +++ b/netfs/fuse.cpp @@ -1,12 +1,10 @@ #include #include #include -#include "fuseapp.h" #include #include #include -#include "comms.h" -#include "msgtypes.h" +#include "fuse.h" static FuseAppBase * fuseApp; @@ -70,153 +68,55 @@ static void fuseDestroy(void * x) delete (App*)x; } -class NetFS : public FuseAppBase +NetFS::NetFS() : + f(NULL) { - 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); + 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; } - 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; + f = fdopen(sfd, "a+"); + break; } - 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; +} +NetFS::~NetFS() +{ + if (f) { + fclose(f); } - 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 +NetFS::exchange(DataPayloadPtr dp) +{ + send(dp); + return recv(); +} +void +NetFS::send(DataPayloadPtr dp) +{ + PacketPtr sendme = new Packet(0, dp); + sendme->write(f); +} +DataPayloadPtr +NetFS::recv() { - DataPayloadPtr p = net->exchange(this); - return p.as >(); + PacketPtr recvd = new Packet(f); + return recvd->data; } template diff --git a/netfs/fuse.h b/netfs/fuse.h new file mode 100644 index 0000000..dc0a124 --- /dev/null +++ b/netfs/fuse.h @@ -0,0 +1,60 @@ +#ifndef FUSE_H +#define FUSE_H + +#include "fuseapp.h" +#include "comms.h" + +class NetFS : public FuseAppBase +{ + // 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 *); + // 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 + public: + NetFS(); + ~NetFS(); + DataPayloadPtr exchange(DataPayloadPtr dp); + void send(DataPayloadPtr dp); + DataPayloadPtr recv(); + template + SmartPointer > recvType() + { + DataPayloadPtr p = this->recv(); + return p.as >(); + } + private: + FILE * f; +}; + +// this needs to go here to avoid circular includes regarding the net->exchange call +template +SmartPointer > TypedPayloadReq::exchange(NetFS * net) +{ + DataPayloadPtr p = net->exchange(this); + return p.as >(); +} +#endif diff --git a/netfs/fuseDirs.cpp b/netfs/fuseDirs.cpp new file mode 100644 index 0000000..17e4a3e --- /dev/null +++ b/netfs/fuseDirs.cpp @@ -0,0 +1,48 @@ +#include "fuse.h" +#include "msgtypes.h" + +int +NetFS::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 +NetFS::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 +NetFS::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 +NetFS::mkdir(const char * d, mode_t m) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = d; + msg->data.mode = m; + return -msg->exchange(this)->data.value; +} +int +NetFS::rmdir(const char * d) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = d; + return -msg->exchange(this)->data.value; +} diff --git a/netfs/fuseFS.cpp b/netfs/fuseFS.cpp new file mode 100644 index 0000000..ab27044 --- /dev/null +++ b/netfs/fuseFS.cpp @@ -0,0 +1,13 @@ +#include "fuse.h" +#include "msgtypes.h" + +int +NetFS::statfs(const char * p, struct statvfs * vfs) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + TypedPayload::Ptr rep = msg->exchange(this); + *vfs = rep->data.statfs; + return -rep->data.error; +} + diff --git a/netfs/fuseFiles.cpp b/netfs/fuseFiles.cpp new file mode 100644 index 0000000..42b3012 --- /dev/null +++ b/netfs/fuseFiles.cpp @@ -0,0 +1,75 @@ +#include +#include "fuse.h" +#include "msgtypes.h" + +int +NetFS::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 +NetFS::create(const char * p, mode_t m, struct fuse_file_info * fi) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + msg->data.mode = m; + TypedPayload::Ptr rep = msg->exchange(this); + fi->fh = rep->data.handle; + return -rep->data.error; +} +int +NetFS::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 +NetFS::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 +NetFS::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; +} +int +NetFS::truncate(const char * p, off_t o) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + msg->data.size = o; + return -msg->exchange(this)->data.value; +} +int +NetFS::ftruncate(const char *, off_t o, fuse_file_info * fi) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.handle = fi->fh; + msg->data.size = o; + return -msg->exchange(this)->data.value; +} diff --git a/netfs/fuseMisc.cpp b/netfs/fuseMisc.cpp new file mode 100644 index 0000000..2746916 --- /dev/null +++ b/netfs/fuseMisc.cpp @@ -0,0 +1,87 @@ +#include "fuse.h" +#include "msgtypes.h" +#include + +int +NetFS::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 +NetFS::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 +NetFS::fgetattr(const char *, struct stat * s, fuse_file_info * fi) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.handle = fi->fh; + TypedPayload::Ptr rep = msg->exchange(this); + *s = rep->data.val; + return -rep->data.res; +} +int +NetFS::chmod(const char * p, mode_t m) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + msg->data.mode = m; + return msg->exchange(this)->data.value; +} +int +NetFS::chown(const char * p, uid_t u, gid_t g) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + msg->data.user = u; + msg->data.group = g; + return msg->exchange(this)->data.value; +} +int +NetFS::link(const char * p1, const char * p2) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path1 = p1; + msg->data.path2 = p2; + return msg->exchange(this)->data.value; +} +int +NetFS::symlink(const char * p1, const char * p2) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path1 = p1; + msg->data.path2 = p2; + return msg->exchange(this)->data.value; +} +int +NetFS::readlink(const char * p, char * p2, size_t s) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + TypedPayload::Ptr rep = msg->exchange(this); + strncpy(p2, rep->data.path.c_str(), std::min(rep->data.path.length(), s)); + return -rep->data.error; +} +int +NetFS::rename(const char * p1, const char * p2) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path1 = p1; + msg->data.path2 = p2; + return msg->exchange(this)->data.value; +} +int +NetFS::unlink(const char * p) +{ + TypedPayloadReq::Ptr msg = new TypedPayloadReq(fuse_get_context()); + msg->data.path = p; + return msg->exchange(this)->data.value; +} diff --git a/netfs/makefile.in b/netfs/makefile.in index f7901ba..4086315 100644 --- a/netfs/makefile.in +++ b/netfs/makefile.in @@ -30,11 +30,19 @@ NETFSOBJS= \ comms.o \ fuse.o \ fuseapp.o \ + fuseFiles.o \ + fuseDirs.o \ + fuseMisc.o \ + fuseFS.o \ msgtypes.o \ NETFSDOBJS= \ comms.o \ daemon.o \ + daemonDirs.o \ + daemonFiles.o \ + daemonMisc.o \ + daemonFS.o \ daemonConfig.o \ msgtypes.o \ diff --git a/netfs/msgtypes.cpp b/netfs/msgtypes.cpp index b2d449e..9ac6b04 100644 --- a/netfs/msgtypes.cpp +++ b/netfs/msgtypes.cpp @@ -14,7 +14,8 @@ 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) { + if (fwrite(t.data(), len, 1, &f) != 1) { + throw WriteMessageFailed(); } } template<> void operator>>(FILE & f, std::string & t) @@ -24,17 +25,23 @@ template<> void operator>>(FILE & f, std::string & t) t.clear(); t.reserve(len); while (len --) { - t.push_back(fgetc(&f)); + int c = fgetc(&f); + if (c == EOF) { + throw ReadMessageFailed(); + } + t.push_back(c); } } template void operator<<(FILE & f, const Type & t) { - if (fwrite(&t, sizeof(t), 1, &f) < sizeof(t)) { + if (fwrite(&t, sizeof(t), 1, &f) != 1) { + throw WriteMessageFailed(); } } template void operator>>(FILE & f, Type & t) { - if (fread(&t, sizeof(t), 1, &f) < sizeof(t)) { + if (fread(&t, sizeof(t), 1, &f) != 1) { + throw ReadMessageFailed(); } } @@ -90,6 +97,9 @@ Xfer2(29, TruncateRequest, RequestBase, path, size) Xfer2(30, FtruncateRequest, RequestBase, handle, size) Xfer1(31, StatfsRequest, RequestBase, path) Xfer2(32, StatfsReply, ContentBase, statfs, error) +Xfer1(33, FgetAttrRequest, RequestBase, handle) +Xfer2(34, CreateRequest, RequestBase, path, mode) +Xfer1(35, RmDirRequest, RequestBase, path) MSGTYPE(2, ReadReply) ReadReply::~ReadReply() @@ -105,7 +115,8 @@ ReadReply::Send(FILE*f) const *f << error; *f << size; if (size) { - if (fwrite(data, size, 1, f) < size) { + if (fwrite(data, size, 1, f) != 1) { + throw WriteMessageFailed(); } } } @@ -117,7 +128,8 @@ ReadReply::Read(FILE*f) *f >> size; if (size) { data = new char[size](); - if (fread(data, size, 1, f) < size) { + if (fread(data, size, 1, f) != 1) { + throw ReadMessageFailed(); } } else { @@ -139,7 +151,8 @@ WriteRequest::Send(FILE*f) const *f << handle; *f << size; *f << offset; - if (fwrite(data, size, 1, f) < size) { + if (fwrite(data, size, 1, f) != 1) { + throw WriteMessageFailed(); } } void @@ -151,7 +164,8 @@ WriteRequest::Read(FILE*f) *f >> offset; if (size) { data = new char[size](); - if (fread(data, size, 1, f) < size) { + if (fread(data, size, 1, f) != 1) { + throw ReadMessageFailed(); } } else { diff --git a/netfs/msgtypes.h b/netfs/msgtypes.h index 78986d3..71909cc 100644 --- a/netfs/msgtypes.h +++ b/netfs/msgtypes.h @@ -222,6 +222,15 @@ class WriteRequest : public RequestBase { virtual void Read(FILE*); }; class MkDirRequest : public RequestBase { + public: + std::string path; + mode_t mode; + typedef SimpleInt Reply; + const static uint16_t TypeID; + virtual void Send(FILE*) const; + virtual void Read(FILE*); +}; +class RmDirRequest : public RequestBase { public: std::string path; typedef SimpleInt Reply; @@ -267,6 +276,7 @@ class RenameRequest : public RequestBase { class ReadlinkReply : public ContentBase { public: std::string path; + int error; const static uint16_t TypeID; virtual void Send(FILE*) const; virtual void Read(FILE*); -- cgit v1.2.3