Archives/falk-werner_webfuse
1
0
Fork 0
mirror of https://github.com/falk-werner/webfuse synced 2024-10-27 20:34:10 +00:00
Code Issues Releases Wiki Activity

added implementation for access, getattr and readdir

Browse Source
This commit is contained in:
Falk Werner 2022-11-20 13:29:34 +01:00
parent 7924fa1191
commit 0a513322b7
15 changed files with 651 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@ -23,7 +23,8 @@ add_library(webfuse_static STATIC
src/webfuse/filesystem/empty_filesystem.cpp
src/webfuse/ws/config.cpp
src/webfuse/ws/server.cpp
src/webfuse/ws/message.cpp
src/webfuse/ws/messagewriter.cpp
src/webfuse/ws/messagereader.cpp
)
target_include_directories(webfuse_static PUBLIC src)

81
script/provider.py
View File

@ -98,11 +98,24 @@ class MessageWriter:
self.buffer.append(value)
def write_u32(self, value):
a = (value >> 24) & 0xff
b = (value >> 16) & 0xff
c = (value >> 8) & 0xff
d = value & 0xff
self.buffer.extend([a, b, c, d])
self.buffer.extend([
(value >> 24) & 0xff,
(value >> 16) & 0xff,
(value >> 8) & 0xff,
value & 0xff
])
def write_u64(self, value):
self.buffer.extend([
(value >> 56) & 0xff,
(value >> 48) & 0xff,
(value >> 40) & 0xff,
(value >> 32) & 0xff,
(value >> 24) & 0xff,
(value >> 16) & 0xff,
(value >> 8) & 0xff,
value & 0xff
])
def write_i32(self, value):
self.write_u32(value & 0xffffffff)
@ -113,7 +126,23 @@ class MessageWriter:
value = ERRNO[value]
self.write_i32(value)
def write_str(self, value):
data = value.encode('utf-8')
self.write_bytes(data)
def write_bytes(self, value):
size = len(value)
self.write_u32(size)
self.buffer.extend(value)
def write_strings(self, values):
count = len(values)
self.write_u32(count)
for value in values:
self.write_str(value)
def get_bytes(self):
print(self.buffer)
return bytearray(self.buffer)
@ -122,7 +151,9 @@ class FilesystemProvider:
self.root = os.path.abspath(path)
self.url = url
self.commands = {
0x01: FilesystemProvider.access
0x01: FilesystemProvider.access,
0x02: FilesystemProvider.getattr,
0x13: FilesystemProvider.readdir
}
async def run(self):
@ -132,6 +163,7 @@ class FilesystemProvider:
reader = MessageReader(request)
message_id = reader.read_u32()
message_type = reader.read_u8()
print("received message: id=%d, type=%d" % (message_id, message_type))
writer = MessageWriter(message_id, RESPONSE + message_type)
if message_type in self.commands:
method = self.commands[message_type]
@ -152,6 +184,43 @@ class FilesystemProvider:
result = -ex.errno
writer.write_result(result)
def getattr(self, reader, writer):
path = reader.read_path(self.root)
try:
attr = os.lstat(path)
except OSError as ex:
writer.write_result(-ex.errno)
return
writer.write_result(0)
writer.write_u64(attr.st_ino)
writer.write_u64(attr.st_nlink)
writer.write_u32(attr.st_mode)
writer.write_i32(attr.st_uid)
writer.write_i32(attr.st_gid)
writer.write_u64(attr.st_dev)
writer.write_u64(attr.st_size)
writer.write_u64(attr.st_blocks)
writer.write_u64(int(attr.st_atime))
writer.write_u32(attr.st_atime_ns)
writer.write_u64(int(attr.st_mtime))
writer.write_u32(attr.st_mtime_ns)
writer.write_u64(int(attr.st_ctime))
writer.write_u32(attr.st_ctime_ns)
def readdir(self, reader, writer):
path = reader.read_path(self.root)
names = []
try:
with os.scandir(path) as it:
for entry in it:
names.append(entry.name)
except OSError as ex:
writer.write_result(-ex.errno)
return
writer.write_result(0)
writer.write_strings(names)
if __name__ == '__main__':
provider = FilesystemProvider('.', 'ws://localhost:8081')
asyncio.run(provider.run())

154
src/webfuse/filesystem.cpp
View File

@ -1,4 +1,5 @@
#include "webfuse/filesystem.hpp"
#include <errno.h>
namespace webfuse
{
@ -14,15 +15,15 @@ filesystem::~filesystem()
}
status filesystem::access(std::string const & path, access_mode mode)
int filesystem::access(std::string const & path, int mode)
{
try
{
message req(message_type::access_req);
req.add_str(path);
req.add_i8(mode);
proxy.perform(std::move(req));
return status::bad_enoent;
messagewriter req(message_type::access_req);
req.write_str(path);
req.write_access_mode(mode);
auto reader = proxy.perform(std::move(req));
return reader.read_result();
}
catch(...)
{
@ -30,27 +31,34 @@ status filesystem::access(std::string const & path, access_mode mode)
}
}
status filesystem::getattr(std::string const & path, file_attributes & attr)
int filesystem::getattr(std::string const & path, struct stat * attr)
{
try
{
message req(message_type::getattr_req);
proxy.perform(std::move(req));
return status::bad_enoent;
messagewriter req(message_type::getattr_req);
req.write_str(path);
auto reader = proxy.perform(std::move(req));
int const result = reader.read_result();
if (0 == result)
{
reader.read_attr(attr);
}
return result;
}
catch(...)
{
puts("getattr: failed");
return fallback.getattr(path, attr);
}
}
status filesystem::readlink(std::string const & path, std::string & out)
int filesystem::readlink(std::string const & path, std::string & out)
{
try
{
message req(message_type::readlink_req);
messagewriter req(message_type::readlink_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -58,13 +66,13 @@ status filesystem::readlink(std::string const & path, std::string & out)
}
}
status filesystem::symlink(std::string const & target, std::string const & linkpath)
int filesystem::symlink(std::string const & target, std::string const & linkpath)
{
try
{
message req(message_type::symlink_req);
messagewriter req(message_type::symlink_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -72,13 +80,13 @@ status filesystem::symlink(std::string const & target, std::string const & linkp
}
}
status filesystem::link(std::string const & old_path, std::string const & new_path)
int filesystem::link(std::string const & old_path, std::string const & new_path)
{
try
{
message req(message_type::link_req);
messagewriter req(message_type::link_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -86,27 +94,27 @@ status filesystem::link(std::string const & old_path, std::string const & new_pa
}
}
status filesystem::rename(std::string const & old_path, std::string const & new_path)
int filesystem::rename(std::string const & old_path, std::string const & new_path, int flags)
{
try
{
message req(message_type::rename_req);
messagewriter req(message_type::rename_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
return fallback.rename(old_path, new_path);
return fallback.rename(old_path, new_path, flags);
}
}
status filesystem::chmod(std::string const & path, filemode mode)
int filesystem::chmod(std::string const & path, mode_t mode)
{
try
{
message req(message_type::chmod_req);
messagewriter req(message_type::chmod_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -114,13 +122,13 @@ status filesystem::chmod(std::string const & path, filemode mode)
}
}
status filesystem::chown(std::string const & path, user_id uid, group_id gid)
int filesystem::chown(std::string const & path, uid_t uid, gid_t gid)
{
try
{
message req(message_type::chown_req);
messagewriter req(message_type::chown_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -128,27 +136,27 @@ status filesystem::chown(std::string const & path, user_id uid, group_id gid)
}
}
status filesystem::truncate(std::string const & path, uint64_t offset, filehandle handle)
int filesystem::truncate(std::string const & path, uint64_t size, uint64_t handle)
{
try
{
message req(message_type::truncate_req);
messagewriter req(message_type::truncate_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
return fallback.truncate(path, offset, handle);
return fallback.truncate(path, size, handle);
}
}
status filesystem::fsync(std::string const & path, bool is_datasync, filehandle handle)
int filesystem::fsync(std::string const & path, bool is_datasync, uint64_t handle)
{
try
{
message req(message_type::fsync_req);
messagewriter req(message_type::fsync_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -156,13 +164,13 @@ status filesystem::fsync(std::string const & path, bool is_datasync, filehandle
}
}
status filesystem::open(std::string const & path, openflags flags, filehandle & handle)
int filesystem::open(std::string const & path, int flags, uint64_t & handle)
{
try
{
message req(message_type::open_req);
messagewriter req(message_type::open_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -170,13 +178,13 @@ status filesystem::open(std::string const & path, openflags flags, filehandle &
}
}
status filesystem::mknod(std::string const & path, filemode mode, uint64_t rdev)
int filesystem::mknod(std::string const & path, mode_t mode, dev_t rdev)
{
try
{
message req(message_type::mknod_req);
messagewriter req(message_type::mknod_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -184,13 +192,13 @@ status filesystem::mknod(std::string const & path, filemode mode, uint64_t rdev)
}
}
status filesystem::create(std::string const & path, filemode mode, filehandle & handle)
int filesystem::create(std::string const & path, mode_t mode, uint64_t & handle)
{
try
{
message req(message_type::create_req);
messagewriter req(message_type::create_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -198,13 +206,13 @@ status filesystem::create(std::string const & path, filemode mode, filehandle &
}
}
status filesystem::release(std::string const & path, filehandle handle)
int filesystem::release(std::string const & path, uint64_t handle)
{
try
{
message req(message_type::release_req);
messagewriter req(message_type::release_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -212,13 +220,13 @@ status filesystem::release(std::string const & path, filehandle handle)
}
}
status filesystem::unlink(std::string const & path)
int filesystem::unlink(std::string const & path)
{
try
{
message req(message_type::unlink_req);
messagewriter req(message_type::unlink_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -226,13 +234,13 @@ status filesystem::unlink(std::string const & path)
}
}
status filesystem::read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, filehandle handle)
int filesystem::read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, uint64_t handle)
{
try
{
message req(message_type::read_req);
messagewriter req(message_type::read_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -240,13 +248,13 @@ status filesystem::read(std::string const & path, char * buffer, size_t buffer_s
}
}
status filesystem::write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, filehandle handle)
int filesystem::write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, uint64_t handle)
{
try
{
message req(message_type::write_req);
messagewriter req(message_type::write_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -254,13 +262,13 @@ status filesystem::write(std::string const & path, char const * buffer, size_t b
}
}
status filesystem::mkdir(std::string const & path, filemode mode)
int filesystem::mkdir(std::string const & path, mode_t mode)
{
try
{
message req(message_type::mkdir_req);
messagewriter req(message_type::mkdir_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -268,13 +276,19 @@ status filesystem::mkdir(std::string const & path, filemode mode)
}
}
status filesystem::readdir(std::string const & path, std::vector<std::string> & entries, filehandle handle)
int filesystem::readdir(std::string const & path, std::vector<std::string> & entries, uint64_t handle)
{
try
{
message req(message_type::readdir_req);
proxy.perform(std::move(req));
return status::bad_enoent;
messagewriter req(message_type::readdir_req);
req.write_str(path);
auto resp = proxy.perform(std::move(req));
int result = resp.read_result();
if (0 == result)
{
resp.read_strings(entries);
}
return result;
}
catch(...)
{
@ -282,13 +296,13 @@ status filesystem::readdir(std::string const & path, std::vector<std::string> &
}
}
status filesystem::rmdir(std::string const & path)
int filesystem::rmdir(std::string const & path)
{
try
{
message req(message_type::rmdir_req);
messagewriter req(message_type::rmdir_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{
@ -296,13 +310,13 @@ status filesystem::rmdir(std::string const & path)
}
}
status filesystem::statfs(std::string const & path, filesystem_statistics & statistics)
int filesystem::statfs(std::string const & path, struct statvfs * statistics)
{
try
{
message req(message_type::statfs_req);
messagewriter req(message_type::statfs_req);
proxy.perform(std::move(req));
return status::bad_enoent;
return -ENOENT;
}
catch(...)
{

42
src/webfuse/filesystem.hpp
View File

@ -18,33 +18,33 @@ public:
explicit filesystem(ws_server& server);
~filesystem() override;
status access(std::string const & path, access_mode mode) override;
status getattr(std::string const & path, file_attributes & attr) override;
int access(std::string const & path, int mode) override;
int getattr(std::string const & path, struct stat * attr) override;
status readlink(std::string const & path, std::string & out) override;
status symlink(std::string const & target, std::string const & linkpath) override;
status link(std::string const & old_path, std::string const & new_path) override;
int readlink(std::string const & path, std::string & out) override;
int symlink(std::string const & target, std::string const & linkpath) override;
int link(std::string const & old_path, std::string const & new_path) override;
status rename(std::string const & old_path, std::string const & new_path) override;
status chmod(std::string const & path, filemode mode) override;
status chown(std::string const & path, user_id uid, group_id gid) override;
status truncate(std::string const & path, uint64_t offset, filehandle handle) override;
status fsync(std::string const & path, bool is_datasync, filehandle handle) override;
int rename(std::string const & old_path, std::string const & new_path, int flags) override;
int chmod(std::string const & path, mode_t mode) override;
int chown(std::string const & path, uid_t uid, gid_t gid) override;
int truncate(std::string const & path, uint64_t size, uint64_t handle) override;
int fsync(std::string const & path, bool is_datasync, uint64_t handle) override;
status open(std::string const & path, openflags flags, filehandle & handle) override;
status mknod(std::string const & path, filemode mode, uint64_t rdev) override;
status create(std::string const & path, filemode mode, filehandle & handle) override;
status release(std::string const & path, filehandle handle) override;
status unlink(std::string const & path) override;
int open(std::string const & path, int flags, uint64_t & handle) override;
int mknod(std::string const & path, mode_t mode, dev_t rdev) override;
int create(std::string const & path, mode_t mode, uint64_t & handle) override;
int release(std::string const & path, uint64_t handle) override;
int unlink(std::string const & path) override;
status read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, filehandle handle) override;
status write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, filehandle handle) override;
int read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) override;
int write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) override;
status mkdir(std::string const & path, filemode mode) override;
status readdir(std::string const & path, std::vector<std::string> & entries, filehandle handle) override;
status rmdir(std::string const & path) override;
int mkdir(std::string const & path, mode_t mode) override;
int readdir(std::string const & path, std::vector<std::string> & entries, uint64_t handle) override;
int rmdir(std::string const & path) override;
status statfs(std::string const & path, filesystem_statistics & statistics) override;
int statfs(std::string const & path, struct statvfs * statistics) override;
private:

97
src/webfuse/filesystem/empty_filesystem.cpp
View File

@ -1,134 +1,135 @@
#include "webfuse/filesystem/empty_filesystem.hpp"
#include <errno.h>
namespace webfuse
{
status empty_filesystem::access(std::string const & path, access_mode mode)
int empty_filesystem::access(std::string const & path, int mode)
{
if (path == "/")
{
return status::good;
return 0;
}
else
{
return status::bad_enoent;
return -ENOENT;
}
}
status empty_filesystem::getattr(std::string const & path, file_attributes & attr)
int empty_filesystem::getattr(std::string const & path, struct stat * attr)
{
if (path == "/")
{
attr.inode = 1;
attr.nlink = 1;
attr.mode = filemode(filemode::dir | 0x444);
return status::good;
attr->st_ino = 1;
attr->st_nlink = 1;
attr->st_mode = S_IFDIR | 0x444;
return 0;
}
else
{
return status::bad_enoent;
return -ENOENT;
}
}
status empty_filesystem::readlink(std::string const & path, std::string & out)
int empty_filesystem::readlink(std::string const & path, std::string & out)
{
return status::bad_enoent;
return -ENOENT;
}
status empty_filesystem::symlink(std::string const & target, std::string const & linkpath)
int empty_filesystem::symlink(std::string const & target, std::string const & linkpath)
{
return status::bad_enoent;
return -ENOENT;
}
status empty_filesystem::link(std::string const & old_path, std::string const & new_path)
int empty_filesystem::link(std::string const & old_path, std::string const & new_path)
{
return status::bad_enoent;
return -ENOENT;
}
status empty_filesystem::rename(std::string const & old_path, std::string const & new_path)
int empty_filesystem::rename(std::string const & old_path, std::string const & new_path, int flags)
{
return status::bad_enoent;
return -ENOENT;
}
status empty_filesystem::chmod(std::string const & path, filemode mode)
int empty_filesystem::chmod(std::string const & path, mode_t mode)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::chown(std::string const & path, user_id uid, group_id gid)
int empty_filesystem::chown(std::string const & path, uid_t uid, gid_t gid)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::truncate(std::string const & path, uint64_t offset, filehandle handle)
int empty_filesystem::truncate(std::string const & path, uint64_t size, uint64_t handle)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::fsync(std::string const & path, bool is_datasync, filehandle handle)
int empty_filesystem::fsync(std::string const & path, bool is_datasync, uint64_t handle)
{
return status::good;
return 0;
}
status empty_filesystem::open(std::string const & path, openflags flags, filehandle & handle)
int empty_filesystem::open(std::string const & path, int flags, uint64_t & handle)
{
return status::bad_enoent;
return -ENOENT;
}
status empty_filesystem::mknod(std::string const & path, filemode mode, uint64_t rdev)
int empty_filesystem::mknod(std::string const & path, mode_t mode, dev_t rdev)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::create(std::string const & path, filemode mode, filehandle & handle)
int empty_filesystem::create(std::string const & path, mode_t mode, uint64_t & handle)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::release(std::string const & path, filehandle handle)
int empty_filesystem::release(std::string const & path, uint64_t handle)
{
return status::good;
return 0;
}
status empty_filesystem::unlink(std::string const & path)
int empty_filesystem::unlink(std::string const & path)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, filehandle handle)
int empty_filesystem::read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, uint64_t handle)
{
return status::bad_ebadf;
return -EBADF;
}
status empty_filesystem::write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, filehandle handle)
int empty_filesystem::write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, uint64_t handle)
{
return status::bad_ebadf;
return -EBADF;
}
status empty_filesystem::mkdir(std::string const & path, filemode mode)
int empty_filesystem::mkdir(std::string const & path, mode_t mode)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::readdir(std::string const & path, std::vector<std::string> & entries, filehandle handle)
int empty_filesystem::readdir(std::string const & path, std::vector<std::string> & entries, uint64_t handle)
{
if (path == "/")
{
return status::good;
return 0;
}
else
{
return status::bad_enoent;
return -ENOENT;
}
}
status empty_filesystem::rmdir(std::string const & path)
int empty_filesystem::rmdir(std::string const & path)
{
return status::bad_eperm;
return -EPERM;
}
status empty_filesystem::statfs(std::string const & path, filesystem_statistics & statistics)
int empty_filesystem::statfs(std::string const & path, struct statvfs * statistics)
{
return status::bad_enosys;
return -ENOSYS;
}

42
src/webfuse/filesystem/empty_filesystem.hpp
View File

@ -11,33 +11,33 @@ class empty_filesystem: public filesystem_i
public:
~empty_filesystem() override = default;
status access(std::string const & path, access_mode mode) override;
status getattr(std::string const & path, file_attributes & attr) override;
int access(std::string const & path, int mode) override;
int getattr(std::string const & path, struct stat * attr) override;
status readlink(std::string const & path, std::string & out) override;
status symlink(std::string const & target, std::string const & linkpath) override;
status link(std::string const & old_path, std::string const & new_path) override;
int readlink(std::string const & path, std::string & out) override;
int symlink(std::string const & target, std::string const & linkpath) override;
int link(std::string const & old_path, std::string const & new_path) override;
status rename(std::string const & old_path, std::string const & new_path) override;
status chmod(std::string const & path, filemode mode) override;
status chown(std::string const & path, user_id uid, group_id gid) override;
status truncate(std::string const & path, uint64_t offset, filehandle handle) override;
status fsync(std::string const & path, bool is_datasync, filehandle handle) override;
int rename(std::string const & old_path, std::string const & new_path, int flags) override;
int chmod(std::string const & path, mode_t mode) override;
int chown(std::string const & path, uid_t uid, gid_t gid) override;
int truncate(std::string const & path, uint64_t size, uint64_t handle) override;
int fsync(std::string const & path, bool is_datasync, uint64_t handle) override;
status open(std::string const & path, openflags flags, filehandle & handle) override;
status mknod(std::string const & path, filemode mode, uint64_t rdev) override;
status create(std::string const & path, filemode mode, filehandle & handle) override;
status release(std::string const & path, filehandle handle) override;
status unlink(std::string const & path) override;
int open(std::string const & path, int flags, uint64_t & handle) override;
int mknod(std::string const & path, mode_t mode, dev_t rdev) override;
int create(std::string const & path, mode_t mode, uint64_t & handle) override;
int release(std::string const & path, uint64_t handle) override;
int unlink(std::string const & path) override;
status read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, filehandle handle) override;
status write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, filehandle handle) override;
int read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) override;
int write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) override;
status mkdir(std::string const & path, filemode mode) override;
status readdir(std::string const & path, std::vector<std::string> & entries, filehandle handle) override;
status rmdir(std::string const & path) override;
int mkdir(std::string const & path, mode_t mode) override;
int readdir(std::string const & path, std::vector<std::string> & entries, uint64_t handle) override;
int rmdir(std::string const & path) override;
status statfs(std::string const & path, filesystem_statistics & statistics) override;
int statfs(std::string const & path, struct statvfs * statistivs) override;
};
}

55
src/webfuse/filesystem/filesystem_i.hpp
View File

@ -1,15 +1,10 @@
#ifndef WEBFUSE_FILESYSTEM_I_HPP
#define WEBFUSE_FILESYSTEM_I_HPP
#include "webfuse/filesystem/filehandle.hpp"
#include "webfuse/filesystem/accessmode.hpp"
#include "webfuse/filesystem/filemode.hpp"
#include "webfuse/filesystem/fileattributes.hpp"
#include "webfuse/filesystem/openflags.hpp"
#include "webfuse/filesystem/userid.hpp"
#include "webfuse/filesystem/groupid.hpp"
#include "webfuse/filesystem/status.hpp"
#include "webfuse/filesystem/filesystem_statistics.hpp"
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <unistd.h>
#include <cinttypes>
#include <string>
@ -23,33 +18,33 @@ class filesystem_i
public:
virtual ~filesystem_i() = default;
virtual status access(std::string const & path, access_mode mode) = 0;
virtual status getattr(std::string const & path, file_attributes & attr) = 0;
virtual int access(std::string const & path, int mode) = 0;
virtual int getattr(std::string const & path, struct stat * attr) = 0;
virtual status readlink(std::string const & path, std::string & out) = 0;
virtual status symlink(std::string const & target, std::string const & linkpath) = 0;
virtual status link(std::string const & old_path, std::string const & new_path) = 0;
virtual int readlink(std::string const & path, std::string & out) = 0;
virtual int symlink(std::string const & target, std::string const & linkpath) = 0;
virtual int link(std::string const & old_path, std::string const & new_path) = 0;
virtual status rename(std::string const & old_path, std::string const & new_path) = 0;
virtual status chmod(std::string const & path, filemode mode) = 0;
virtual status chown(std::string const & path, user_id uid, group_id gid) = 0;
virtual status truncate(std::string const & path, uint64_t offset, filehandle handle) = 0;
virtual status fsync(std::string const & path, bool is_datasync, filehandle handle) = 0;
virtual int rename(std::string const & old_path, std::string const & new_path, int flags) = 0;
virtual int chmod(std::string const & path, mode_t mode) = 0;
virtual int chown(std::string const & path, uid_t uid, gid_t gid) = 0;
virtual int truncate(std::string const & path, uint64_t size, uint64_t handle) = 0;
virtual int fsync(std::string const & path, bool is_datasync, uint64_t handle) = 0;
virtual status open(std::string const & path, openflags flags, filehandle & handle) = 0;
virtual status mknod(std::string const & path, filemode mode, uint64_t rdev) = 0;
virtual status create(std::string const & path, filemode mode, filehandle & handle) = 0;
virtual status release(std::string const & path, filehandle handle) = 0;
virtual status unlink(std::string const & path) = 0;
virtual int open(std::string const & path, int flags, uint64_t & handle) = 0;
virtual int mknod(std::string const & path, mode_t mode, dev_t rdev) = 0;
virtual int create(std::string const & path, mode_t mode, uint64_t & handle) = 0;
virtual int release(std::string const & path, uint64_t handle) = 0;
virtual int unlink(std::string const & path) = 0;
virtual status read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, filehandle handle) = 0;
virtual status write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, filehandle handle) = 0;
virtual int read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) = 0;
virtual int write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) = 0;
virtual status mkdir(std::string const & path, filemode mode) = 0;
virtual status readdir(std::string const & path, std::vector<std::string> & entries, filehandle handle) = 0;
virtual status rmdir(std::string const & path) = 0;
virtual int mkdir(std::string const & path, mode_t mode) = 0;
virtual int readdir(std::string const & path, std::vector<std::string> & entries, uint64_t handle) = 0;
virtual int rmdir(std::string const & path) = 0;
virtual status statfs(std::string const & path, filesystem_statistics & statistics) = 0;
virtual int statfs(std::string const & path, struct statvfs * statistics) = 0;
};
}

112
src/webfuse/fuse.cpp
View File

@ -15,9 +15,9 @@ static webfuse::filesystem_i * fs_get_filesystem()
return reinterpret_cast<webfuse::filesystem_i*>(private_data);
}
static webfuse::filehandle fs_get_handle(fuse_file_info * info)
static uint64_t fs_get_handle(fuse_file_info * info)
{
return (nullptr != info) ? info->fh : webfuse::invalid_handle;
return (nullptr != info) ? info->fh : ((uint64_t) -1);
}
static void * fs_init(fuse_conn_info * connection, fuse_config * config)
@ -33,24 +33,18 @@ static void * fs_init(fuse_conn_info * connection, fuse_config * config)
}
static int fs_access(char const * path, int raw_mode)
static int fs_access(char const * path, int mode)
{
auto * const fs = fs_get_filesystem();
auto const mode = webfuse::access_mode::from_int(raw_mode);
auto const result = fs->access(path, mode);
return result.to_fusestatus();
return fs->access(path, mode);
}
static int fs_getattr(char const * path, struct stat * buffer, fuse_file_info * info)
{
(void) info;
auto * const fs = fs_get_filesystem();
webfuse::file_attributes attributes(*buffer);
auto const result = fs->getattr(path, attributes);
attributes.to_stat(*buffer);
return result.to_fusestatus();
return fs->getattr(path, buffer);
}
static int fs_readlink(char const * path, char * buffer, size_t buffer_size)
@ -59,63 +53,55 @@ static int fs_readlink(char const * path, char * buffer, size_t buffer_size)
std::string out;
auto result = fs->readlink(path, out);
if (webfuse::status::good == result)
if (0 == result)
{
snprintf(buffer, buffer_size, "%s", out.c_str());
result = strlen(buffer);
}
return result.to_fusestatus();
return result;
}
static int fs_symlink(char const * target, char const * linkpath)
{
auto * const fs = fs_get_filesystem();
auto const result = fs->symlink(target, linkpath);
return result.to_fusestatus();
return fs->symlink(target, linkpath);
}
static int fs_link(char const * old_path, char const * new_path)
{
auto * const fs = fs_get_filesystem();
auto const result = fs->link(old_path, new_path);
return result.to_fusestatus();
return fs->link(old_path, new_path);
}
static int fs_rename(char const * from, char const * to, unsigned int flags)
{
// ToDo: provide flags
auto * const fs = fs_get_filesystem();
auto const result = fs->rename(from, to);
return result.to_fusestatus();
return fs->rename(from, to, flags);
}
static int fs_chmod(char const * path, mode_t raw_mode, fuse_file_info * info)
static int fs_chmod(char const * path, mode_t mode, fuse_file_info * info)
{
(void) info;
auto * const fs = fs_get_filesystem();
auto const mode = webfuse::filemode::from_mode(raw_mode);
auto const result = fs->chmod(path, mode);
return result.to_fusestatus();
return fs->chmod(path, mode);
}
static int fs_chown(char const * path, uid_t raw_uid,
gid_t raw_gid, fuse_file_info * info)
static int fs_chown(char const * path, uid_t uid, gid_t gid, fuse_file_info * info)
{
(void) info;
auto * const fs = fs_get_filesystem();
auto const uid = webfuse::user_id::from_uid(raw_uid);
auto const gid = webfuse::group_id::from_gid(raw_gid);
auto const result = fs->chown(path, uid, gid);
return result.to_fusestatus();
return fs->chown(path, uid, gid);
}
static int fs_truncate(char const * path, off_t raw_size, fuse_file_info * info)
static int fs_truncate(char const * path, off_t size, fuse_file_info * info)
{
auto * const fs = fs_get_filesystem();
auto const size = static_cast<uint64_t>(raw_size);
auto const handle = fs_get_handle(info);
auto const result = fs->truncate(path, size, handle);
return result.to_fusestatus();
return fs->truncate(path, size, handle);
}
static int fs_fsync(char const * path, int isdatasync, fuse_file_info * info)
@ -124,36 +110,30 @@ static int fs_fsync(char const * path, int isdatasync, fuse_file_info * info)
bool const is_datasync = (is_datasync != 0);
auto const handle = fs_get_handle(info);
auto const result = fs->fsync(path, is_datasync, handle);
return result.to_fusestatus();
return fs->fsync(path, is_datasync, handle);
}
static int fs_open(char const * path, fuse_file_info * info)
{
auto * const fs = fs_get_filesystem();
auto const flags = webfuse::openflags::from_int(info->flags);
auto const flags = info->flags;
auto const result = fs->open(path, flags, info->fh);
return result.to_fusestatus();
return fs->open(path, flags, info->fh);
}
static int fs_mknod(char const * path, mode_t raw_mode, dev_t raw_rdev)
static int fs_mknod(char const * path, mode_t mode, dev_t raw_rdev)
{
auto * const fs = fs_get_filesystem();
auto const mode = webfuse::filemode::from_mode(raw_mode);
auto const rdev = static_cast<uint64_t>(raw_rdev);
auto const result = fs->mknod(path, mode, rdev);
return result.to_fusestatus();
return fs->mknod(path, mode, rdev);
}
static int fs_create(char const * path, mode_t raw_mode, fuse_file_info * info)
static int fs_create(char const * path, mode_t mode, fuse_file_info * info)
{
auto * const fs = fs_get_filesystem();
auto const mode = webfuse::filemode::from_mode(raw_mode);
auto const result = fs->create(path, mode, info->fh);
return result.to_fusestatus();
return fs->create(path, mode, info->fh);
}
static int fs_release(char const * path, fuse_file_info * info)
@ -161,15 +141,13 @@ static int fs_release(char const * path, fuse_file_info * info)
auto * const fs = fs_get_filesystem();
auto const handle = fs_get_handle(info);
auto const result = fs->release(path, handle);
return result.to_fusestatus();
return fs->release(path, handle);
}
static int fs_unlink(char const * path)
{
auto * const fs = fs_get_filesystem();
auto const result = fs->unlink(path);
return result.to_fusestatus();
return fs->unlink(path);
}
static int fs_read(char const * path, char * buffer,
@ -180,8 +158,7 @@ static int fs_read(char const * path, char * buffer,
auto const offset = static_cast<uint64_t>(raw_offset);
auto const handle = fs_get_handle(info);
auto const result = fs->read(path, buffer, buffer_size, offset, handle);
return result.to_fusestatus();
return fs->read(path, buffer, buffer_size, offset, handle);
}
static int fs_write(char const * path, char const * buffer,
@ -192,17 +169,13 @@ static int fs_write(char const * path, char const * buffer,
auto const offset = static_cast<uint64_t>(raw_offset);
auto const handle = fs_get_handle(info);
auto const result = fs->write(path, buffer, buffer_size, offset, handle);
return result.to_fusestatus();
return fs->write(path, buffer, buffer_size, offset, handle);
}
static int fs_mkdir(char const * path, mode_t raw_mode)
static int fs_mkdir(char const * path, mode_t mode)
{
auto * const fs = fs_get_filesystem();
auto const mode = webfuse::filemode::from_mode(raw_mode);
auto const result = fs->mkdir(path, mode);
return result.to_fusestatus();
return fs->mkdir(path, mode);
}
static int fs_readdir(char const * path, void * buffer,
@ -213,7 +186,7 @@ static int fs_readdir(char const * path, void * buffer,
auto handle = fs_get_handle(info);
std::vector<std::string> names;
auto const result = fs->readdir(path, names, handle);
if (result.is_good())
if (0 == result)
{
filler(buffer, ".", nullptr, 0, static_cast<fuse_fill_dir_flags>(0));
filler(buffer, "..", nullptr, 0, static_cast<fuse_fill_dir_flags>(0));
@ -223,26 +196,19 @@ static int fs_readdir(char const * path, void * buffer,
}
}
return result.to_fusestatus();
return result;
}
static int fs_rmdir(char const * path)
{
auto * const fs = fs_get_filesystem();
auto const result = fs->rmdir(path);
return result.to_fusestatus();
return fs->rmdir(path);
}
static int fs_statfs(char const * path, struct statvfs * buffer)
{
auto * const fs = fs_get_filesystem();
webfuse::filesystem_statistics statistics(*buffer);
auto const result = fs->statfs(path, statistics);
statistics.copy_to(*buffer);
return result.to_fusestatus();
return fs->statfs(path, buffer);
}
}

45
src/webfuse/ws/message.hpp
View File

@ -1,45 +0,0 @@
#ifndef WEBFUSE_MESSAGEBUILDER_HPP
#define WEBFUSE_MESSAGEBUILDER_HPP
#include "webfuse/message_type.hpp"
#include <cinttypes>
#include <string>
#include <vector>
namespace webfuse
{
class message
{
message(message const &) = delete;
message& operator=(message const &) = delete;
public:
explicit message(message_type msg_type);
~message() = default;
message(message && other);
message& operator=(message && other);
void set_id(uint32_t value);
uint32_t get_id() const;
void add_bool(bool value);
void add_u8(uint8_t value);
void add_i8(int8_t value);
void add_i32(int32_t value);
void add_u32(uint32_t value);
void add_u64(uint64_t value);
void add_str(std::string const &value);
void add_data(char const * buffer, size_t size);
void add_strings(std::vector<std::string> const & list);
unsigned char * get_data(size_t &size);
private:
uint32_t id;
std::vector<uint8_t> data;
};
}
#endif

158
src/webfuse/ws/messagereader.cpp Normal file
View File

@ -0,0 +1,158 @@
#include "webfuse/ws/messagereader.hpp"
#include "webfuse/filesystem/status.hpp"
#include "webfuse/filesystem/fileattributes.hpp"
#include "webfuse/filesystem/filemode.hpp"
#include <stdexcept>
namespace webfuse
{
messagereader::messagereader(std::string & value)
: data(std::move(value))
, pos(0)
{
}
messagereader::messagereader(messagereader && other)
{
this->data = std::move(other.data);
this->pos = other.pos;
}
messagereader& messagereader::operator=(messagereader && other)
{
if (this != &other)
{
this->data = std::move(other.data);
this->pos = other.pos;
}
return *this;
}
int messagereader::read_result()
{
status value(read_i32());
return value.to_fusestatus();
}
void messagereader::read_attr(struct stat * attr)
{
attr->st_ino = static_cast<ino_t>(read_u64());
attr->st_nlink = static_cast<nlink_t>(read_u64());
attr->st_mode = read_mode();
attr->st_uid = static_cast<uid_t>(read_u32());
attr->st_gid = static_cast<gid_t>(read_u32());
attr->st_rdev = static_cast<dev_t>(read_u64());
attr->st_size = static_cast<off_t>(read_u64());
attr->st_blocks = static_cast<blkcnt64_t>(read_u64());
attr->st_atim.tv_sec = static_cast<time_t>(read_u64());
attr->st_atim.tv_nsec = static_cast<long>(read_u32());
attr->st_mtim.tv_sec = static_cast<time_t>(read_u64());
attr->st_mtim.tv_nsec = static_cast<long>(read_u32());
attr->st_ctim.tv_sec = static_cast<time_t>(read_u64());
attr->st_ctim.tv_nsec = static_cast<long>(read_u32());
}
mode_t messagereader::read_mode()
{
filemode mode(read_u32());
return mode.to_mode();
}
uint8_t messagereader::read_u8()
{
if (pos < data.size())
{
uint8_t value = static_cast<uint8_t>(data[pos]);
pos++;
return value;
}
else
{
throw std::runtime_error("out of bounds");
}
}
uint32_t messagereader::read_u32()
{
if ((pos + 3) < data.size())
{
uint32_t value =
((static_cast<uint32_t>(data[pos ]) & 0xff) << 24) |
((static_cast<uint32_t>(data[pos + 1]) & 0xff) << 16) |
((static_cast<uint32_t>(data[pos + 2]) & 0xff) << 8) |
((static_cast<uint32_t>(data[pos + 3]) & 0xff) );
pos += 4;
return value;
}
else
{
throw std::runtime_error("out of bounds");
}
}
uint64_t messagereader::read_u64()
{
if ((pos + 7) < data.size())
{
uint32_t value =
(static_cast<uint64_t>(data[pos ] & 0xff) << 56) |
(static_cast<uint64_t>(data[pos + 1] & 0xff) << 48) |
(static_cast<uint64_t>(data[pos + 2] & 0xff) << 40) |
(static_cast<uint64_t>(data[pos + 3] & 0xff) << 32) |
(static_cast<uint64_t>(data[pos + 4] & 0xff) << 24) |
(static_cast<uint64_t>(data[pos + 5] & 0xff) << 16) |
(static_cast<uint64_t>(data[pos + 6] & 0xff) << 8) |
(static_cast<uint64_t>(data[pos + 7] & 0xff) );
pos += 8;
return value;
}
else
{
throw std::runtime_error("out of bounds");
}
}
int32_t messagereader::read_i32()
{
uint32_t value = read_u32();
return static_cast<int32_t>(value);
}
std::string messagereader::read_str()
{
return std::move(read_bytes());
}
std::string messagereader::read_bytes()
{
uint32_t size = read_u32();
if ((pos + size) <= data.size())
{
std::string const value(&data[pos], size);
pos += size;
return std::move(value);
}
else
{
throw std::runtime_error("out of bounds");
}
}
void messagereader::read_strings(std::vector<std::string> &entries)
{
uint32_t const count = read_u32();
for(uint32_t i = 0; i < count; i++)
{
std::string entry = read_str();
entries.push_back(entry);
}
}
}

30
src/webfuse/ws/messagereader.hpp
View File

@ -1,17 +1,43 @@
#ifndef WEBFUSE_MESSAGEREADER_HPP
#define WEBFUSE_MESSAGEREADER_HPP
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <cinttypes>
#include <string>
#include <vector>
namespace webfuse
{
class messagereader
{
messagereader(messagereader const &) = delete;
messagereader& operator=(messagereader const &) = delete;
public:
explicit messagereader(std::string && value);
explicit messagereader(std::string & value);
~messagereader() = default;
messagereader(messagereader && other);
messagereader& operator=(messagereader && other);
int read_result();
void read_attr(struct stat * attr);
mode_t read_mode();
uint8_t read_u8();
uint32_t read_u32();
uint64_t read_u64();
int32_t read_i32();
std::string read_str();
std::string read_bytes();
void read_strings(std::vector<std::string> &entries);
private:
std::string data;

57
src/webfuse/ws/message.cpp → src/webfuse/ws/messagewriter.cpp
View File

@ -1,24 +1,26 @@
#include "message.hpp"
#include "webfuse/ws/messagewriter.hpp"
#include "webfuse/filesystem/accessmode.hpp"
#include <libwebsockets.h>
namespace webfuse
{
message::message(message_type msg_type)
messagewriter::messagewriter(message_type msg_type)
: id(0)
, data(LWS_PRE)
{
add_u32(0);
add_u8(static_cast<uint8_t>(msg_type));
write_u32(0);
write_u8(static_cast<uint8_t>(msg_type));
}
message::message(message && other)
messagewriter::messagewriter(messagewriter && other)
{
this->id = other.id;
this->data = std::move(other.data);
}
message& message::operator=(message && other)
messagewriter& messagewriter::operator=(messagewriter && other)
{
if (this != &other)
{
@ -29,41 +31,41 @@ message& message::operator=(message && other)
return *this;
}
void message::set_id(uint32_t value)
void messagewriter::set_id(uint32_t value)
{
id = id;
id = value;
data[LWS_PRE ] = (id >> 24) & 0xff;
data[LWS_PRE + 1] = (id >> 16) & 0xff;
data[LWS_PRE + 2] = (id >> 8) & 0xff;
data[LWS_PRE + 3] = id & 0xff;
}
uint32_t message::get_id() const
uint32_t messagewriter::get_id() const
{
return id;
}
void message::add_bool(bool value)
void messagewriter::write_bool(bool value)
{
data.push_back(value ? 0x01 : 0x00);
}
void message::add_u8(uint8_t value)
void messagewriter::write_u8(uint8_t value)
{
data.push_back(value);
}
void message::add_i8(int8_t value)
void messagewriter::write_i8(int8_t value)
{
data.push_back(static_cast<uint8_t>(value));
}
void message::add_i32(int32_t value)
void messagewriter::write_i32(int32_t value)
{
add_u32((static_cast<uint32_t>(value)));
write_u32((static_cast<uint32_t>(value)));
}
void message::add_u32(uint32_t value)
void messagewriter::write_u32(uint32_t value)
{
auto const offset = data.size();
data.resize(offset + 4);
@ -73,7 +75,7 @@ void message::add_u32(uint32_t value)
data[offset + 3] = value & 0xff;
}
void message::add_u64(uint64_t value)
void messagewriter::write_u64(uint64_t value)
{
auto const offset = data.size();
data.resize(offset + 8);
@ -87,15 +89,15 @@ void message::add_u64(uint64_t value)
data[offset + 7] = value & 0xff;
}
void message::add_str(std::string const &value)
void messagewriter::write_str(std::string const &value)
{
add_data(value.data(), value.size());
write_data(value.data(), value.size());
}
void message::add_data(char const * buffer, size_t size)
void messagewriter::write_data(char const * buffer, size_t size)
{
uint32_t const effective_size = size & 0xffffffff;
add_u32(effective_size);
write_u32(effective_size);
if (size > 0)
{
@ -107,17 +109,24 @@ void message::add_data(char const * buffer, size_t size)
}
}
void message::add_strings(std::vector<std::string> const & list)
void messagewriter::write_strings(std::vector<std::string> const & list)
{
uint32_t const count = list.size() & 0xffffffff;
add_u32(count);
write_u32(count);
for (auto const & item: list)
{
add_str(item);
write_str(item);
}
}
unsigned char * message::get_data(size_t &size)
void messagewriter::write_access_mode(int value)
{
access_mode mode = access_mode::from_int(value);
write_i8(mode);
}
unsigned char * messagewriter::get_data(size_t &size)
{
size = data.size() - LWS_PRE;
void * result = reinterpret_cast<void *>(&data.data()[LWS_PRE]);

47
src/webfuse/ws/messagewriter.hpp Normal file
View File

@ -0,0 +1,47 @@
#ifndef WEBFUSE_MESSAGEWRITER_HPP
#define WEBFUSE_MESSAGEWRITER_HPP
#include "webfuse/message_type.hpp"
#include <cinttypes>
#include <string>
#include <vector>
namespace webfuse
{
class messagewriter
{
messagewriter(messagewriter const &) = delete;
messagewriter& operator=(messagewriter const &) = delete;
public:
explicit messagewriter(message_type msg_type);
~messagewriter() = default;
messagewriter(messagewriter && other);
messagewriter& operator=(messagewriter && other);
void set_id(uint32_t value);
uint32_t get_id() const;
void write_bool(bool value);
void write_u8(uint8_t value);
void write_i8(int8_t value);
void write_i32(int32_t value);
void write_u32(uint32_t value);
void write_u64(uint64_t value);
void write_str(std::string const &value);
void write_data(char const * buffer, size_t size);
void write_strings(std::vector<std::string> const & list);
void write_access_mode(int value);
unsigned char * get_data(size_t &size);
private:
uint32_t id;
std::vector<uint8_t> data;
};
}
#endif

81
src/webfuse/ws/server.cpp
View File

@ -1,5 +1,4 @@
#include "webfuse/ws/server.hpp"
#include "webfuse/ws/message.hpp"
#include <libwebsockets.h>
@ -25,10 +24,12 @@ namespace
struct user_data
{
struct lws * connection = nullptr;
std::string current_message;
std::mutex mut;
std::queue<webfuse::message> requests;
std::unordered_map<uint32_t, std::promise<std::string>> pending_responses;
uint32_t id = 0;
std::queue<webfuse::messagewriter> requests;
std::unordered_map<uint32_t, std::promise<webfuse::messagereader>> pending_responses;
};
}
@ -68,11 +69,49 @@ static int ws_server_callback(struct lws *wsi, enum lws_callback_reasons reason,
break;
case LWS_CALLBACK_RECEIVE:
std::cout << "lws: receive "<< std::endl;
{
auto * fragment = reinterpret_cast<char*>(in);
data->current_message.append(fragment, len);
if (lws_is_final_fragment(wsi))
{
try
{
webfuse::messagereader reader(data->current_message);
uint32_t id = reader.read_u32();
uint8_t message_type = reader.read_u8();
std::lock_guard lock(data->mut);
auto it = data->pending_responses.find(id);
if (it != data->pending_responses.end())
{
std::cout << "propagate message" << std::endl;
it->second.set_value(std::move(reader));
data->pending_responses.erase(it);
}
else
{
// ToDo: log request not found
std::cout << "warning: request not found: id=" << id << std::endl;
for(auto const & entry: data->pending_responses)
{
std::cout << "\t" << entry.first << std::endl;
}
}
}
catch(...)
{
// ToDo: log invalid message
std::cout << "warning: invalid message" << std::endl;
}
}
}
break;
case LWS_CALLBACK_SERVER_WRITEABLE:
std::cout << "lws: server writable "<< std::endl;
{
webfuse::message msg(webfuse::message_type::access_req);
webfuse::messagewriter writer(webfuse::message_type::access_req);
bool has_msg = false;
bool has_more = false;
@ -82,7 +121,7 @@ static int ws_server_callback(struct lws *wsi, enum lws_callback_reasons reason,
if (has_msg)
{
has_msg = true;
msg = std::move(data->requests.front());
writer = std::move(data->requests.front());
data->requests.pop();
has_more = !(data->requests.empty());
@ -92,7 +131,7 @@ static int ws_server_callback(struct lws *wsi, enum lws_callback_reasons reason,
if (has_msg)
{
size_t size;
unsigned char * raw_data = msg.get_data(size);
unsigned char * raw_data = writer.get_data(size);
int const rc = lws_write(data->connection, raw_data, size, LWS_WRITE_BINARY);
}
@ -148,11 +187,12 @@ public:
{
if (nullptr != data.connection)
{
std::cout << "request write" << std::endl;
lws_callback_on_writable(data.connection);
}
else
{
data.requests = std::move(std::queue<webfuse::message>());
data.requests = std::move(std::queue<webfuse::messagewriter>());
data.pending_responses.clear();
}
}
@ -172,6 +212,16 @@ public:
lws_context_destroy(context);
}
uint32_t next_id()
{
data.id++;
if (0 == data.id)
{
data.id = 1;
}
return data.id;
}
std::thread thread;
std::atomic<bool> shutdown_requested;
lws_protocols protocols[2];
@ -209,26 +259,27 @@ ws_server& ws_server::operator=(ws_server && other)
return *this;
}
void ws_server::perform(message msg)
messagereader ws_server::perform(messagewriter writer)
{
std::future<std::string> f;
std::future<messagereader> f;
{
std::promise<std::string> p;
std::promise<messagereader> p;
f = p.get_future();
std::lock_guard lock(d->data.mut);
d->data.requests.emplace(std::move(msg));
d->data.pending_responses.emplace(42, std::move(p));
uint32_t id = d->next_id();
writer.set_id(id);
d->data.requests.emplace(std::move(writer));
d->data.pending_responses.emplace(id, std::move(p));
}
lws_cancel_service(d->context);
if(std::future_status::timeout == f.wait_for(std::chrono::seconds(1)))
if(std::future_status::timeout == f.wait_for(std::chrono::seconds(10)))
{
throw std::runtime_error("timeout");
}
std::string resp = f.get();
throw std::runtime_error("not implemented");
return std::move(f.get());
}

5
src/webfuse/ws/server.hpp
View File

@ -2,7 +2,8 @@
#define WEBFUSE_WSSERVER_HPP
#include "webfuse/ws/config.hpp"
#include "webfuse/ws/message.hpp"
#include "webfuse/ws/messagewriter.hpp"
#include "webfuse/ws/messagereader.hpp"
#include <vector>
#include <string>
@ -21,7 +22,7 @@ public:
ws_server(ws_server && other);
ws_server& operator=(ws_server && other);
void perform(message msg);
messagereader perform(messagewriter writer);
private:
class detail;
detail * d;