From 4e1c9e144c16c6f0c667ca6d7b5f74455762491c Mon Sep 17 00:00:00 2001 From: Falk Werner Date: Fri, 30 Dec 2022 19:44:55 +0100 Subject: [PATCH] added basic C++ provider infrastructure --- CMakeLists.txt | 15 ++- src/provider_main.cpp | 162 +++++++++++++++++++++++++++++++ src/webfuse/filesystem.cpp | 44 ++++----- src/webfuse/message_type.hpp | 38 -------- src/webfuse/provider.cpp | 94 ++++++++++++++++++ src/webfuse/provider.hpp | 28 ++++++ src/webfuse/request_type.hpp | 38 ++++++++ src/webfuse/response_type.hpp | 38 ++++++++ src/webfuse/ws/client.cpp | 150 ++++++++++++++++++++++++++++ src/webfuse/ws/client.hpp | 33 +++++++ src/webfuse/ws/messagewriter.cpp | 12 ++- src/webfuse/ws/messagewriter.hpp | 6 +- src/webfuse/ws/server.cpp | 2 +- 13 files changed, 594 insertions(+), 66 deletions(-) create mode 100644 src/provider_main.cpp delete mode 100644 src/webfuse/message_type.hpp create mode 100644 src/webfuse/provider.cpp create mode 100644 src/webfuse/provider.hpp create mode 100644 src/webfuse/request_type.hpp create mode 100644 src/webfuse/response_type.hpp create mode 100644 src/webfuse/ws/client.cpp create mode 100644 src/webfuse/ws/client.hpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 4298642..edbd14a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,6 +9,7 @@ pkg_check_modules(LWS REQUIRED IMPORTED_TARGET libwebsockets) add_library(webfuse_static STATIC src/webfuse/webfuse.cpp + src/webfuse/provider.cpp src/webfuse/fuse.cpp src/webfuse/filesystem.cpp src/webfuse/filesystem/status.cpp @@ -19,6 +20,7 @@ add_library(webfuse_static STATIC src/webfuse/filesystem/empty_filesystem.cpp src/webfuse/ws/config.cpp src/webfuse/ws/server.cpp + src/webfuse/ws/client.cpp src/webfuse/ws/messagewriter.cpp src/webfuse/ws/messagereader.cpp ) @@ -31,12 +33,23 @@ add_executable(webfuse target_link_libraries(webfuse PRIVATE webfuse_static) +if(NOT(WITHOUT_PROVIDER)) + +add_executable(webfuse_provider + src/provider_main.cpp) + +target_link_libraries(webfuse_provider PRIVATE webfuse_static) + +endif() + if(NOT(WITHOUT_TEST)) pkg_check_modules(GTEST REQUIRED gtest_main) pkg_check_modules(GMOCK REQUIRED gmock) add_executable(alltests + test-src/webfuse/test/thread.cpp + test-src/webfuse/test/tempdir.cpp test-src/webfuse/test_app.cpp test-src/webfuse/filesystem/test_status.cpp test-src/webfuse/filesystem/test_accessmode.cpp @@ -44,7 +57,7 @@ if(NOT(WITHOUT_TEST)) test-src/webfuse/filesystem/test_filemode.cpp ) - target_include_directories(alltests PRIVATE ${GTEST_INCLUDE_DIRS} ${GMOCK_INCLUDE_DIRS}) + target_include_directories(alltests PRIVATE test-src ${GTEST_INCLUDE_DIRS} ${GMOCK_INCLUDE_DIRS}) target_compile_options(alltests PRIVATE ${GTEST_CFLAGS} ${GTEST_CFLAGS_OTHER} ${GMOCK_CFLAGS} ${GMOCK_CFLAGS_OTHER} diff --git a/src/provider_main.cpp b/src/provider_main.cpp new file mode 100644 index 0000000..ec2c9a3 --- /dev/null +++ b/src/provider_main.cpp @@ -0,0 +1,162 @@ +#include "webfuse/provider.hpp" +#include +#include + +namespace +{ + +static bool shutdown_requested = false; + +void on_signal(int _) +{ + (void) _; + shutdown_requested = true; +} + +class filesystem: public webfuse::filesystem_i +{ +public: + explicit filesystem(std::string const & base_path) + : base_path_(base_path) + { + + } + + ~filesystem() override + { + + } + + int access(std::string const & path, int mode) override + { + return -ENOENT; + } + + int getattr(std::string const & path, struct stat * attr) override + { + return -ENOENT; + } + + int readlink(std::string const & path, std::string & out) override + { + return -ENOENT; + } + + int symlink(std::string const & target, std::string const & linkpath) override + { + return -ENOENT; + } + + int link(std::string const & old_path, std::string const & new_path) override + { + return -ENOENT; + } + + int rename(std::string const & old_path, std::string const & new_path, int flags) override + { + return -ENOENT; + } + + int chmod(std::string const & path, mode_t mode) override + { + return -ENOENT; + } + + int chown(std::string const & path, uid_t uid, gid_t gid) override + { + return -ENOENT; + } + + int truncate(std::string const & path, uint64_t size, uint64_t handle) override + { + return -ENOENT; + } + + int fsync(std::string const & path, bool is_datasync, uint64_t handle) override + { + return -ENOENT; + } + + int utimens(std::string const &path, struct timespec tv[2], uint64_t handle) override + { + return -ENOENT; + } + + int open(std::string const & path, int flags, uint64_t & handle) override + { + return -ENOENT; + } + + int mknod(std::string const & path, mode_t mode, dev_t rdev) override + { + return -ENOENT; + } + + int create(std::string const & path, mode_t mode, uint64_t & handle) override + { + return -ENOENT; + } + + int release(std::string const & path, uint64_t handle) override + { + return -ENOENT; + } + + int unlink(std::string const & path) override + { + return -ENOENT; + } + + int read(std::string const & path, char * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) override + { + return -ENOENT; + } + + int write(std::string const & path, char const * buffer, size_t buffer_size, uint64_t offset, uint64_t handle) override + { + return -ENOENT; + } + + int mkdir(std::string const & path, mode_t mode) override + { + return -ENOENT; + } + + int readdir(std::string const & path, std::vector & entries, uint64_t handle) override + { + return -ENOENT; + } + + int rmdir(std::string const & path) override + { + return -ENOENT; + } + + int statfs(std::string const & path, struct statvfs * statistics) override + { + return -ENOENT; + } + + +private: + std::string base_path_; +}; + +} + + + +int main(int argc, char* argv[]) +{ + signal(SIGINT, &on_signal); + signal(SIGTERM, &on_signal); + + filesystem fs("."); + webfuse::provider provider(fs); + provider.connect("ws://localhost:8080/"); + while (!shutdown_requested) + { + provider.service(); + } + return EXIT_SUCCESS; +} \ No newline at end of file diff --git a/src/webfuse/filesystem.cpp b/src/webfuse/filesystem.cpp index 0a14376..feadeb7 100644 --- a/src/webfuse/filesystem.cpp +++ b/src/webfuse/filesystem.cpp @@ -22,7 +22,7 @@ int filesystem::access(std::string const & path, int mode) { try { - messagewriter req(message_type::access_req); + messagewriter req(request_type::access); req.write_str(path); req.write_access_mode(mode); auto reader = proxy.perform(std::move(req)); @@ -38,7 +38,7 @@ int filesystem::getattr(std::string const & path, struct stat * attr) { try { - messagewriter req(message_type::getattr_req); + messagewriter req(request_type::getattr); req.write_str(path); auto reader = proxy.perform(std::move(req)); int const result = reader.read_result(); @@ -58,7 +58,7 @@ int filesystem::readlink(std::string const & path, std::string & out) { try { - messagewriter req(message_type::readlink_req); + messagewriter req(request_type::readlink); req.write_str(path); auto reader = proxy.perform(std::move(req)); int const result = reader.read_result(); @@ -78,7 +78,7 @@ int filesystem::symlink(std::string const & target, std::string const & linkpath { try { - messagewriter req(message_type::symlink_req); + messagewriter req(request_type::symlink); req.write_str(target); req.write_str(linkpath); auto reader = proxy.perform(std::move(req)); @@ -94,7 +94,7 @@ int filesystem::link(std::string const & old_path, std::string const & new_path) { try { - messagewriter req(message_type::link_req); + messagewriter req(request_type::link); req.write_str(old_path); req.write_str(new_path); auto reader = proxy.perform(std::move(req)); @@ -110,7 +110,7 @@ int filesystem::rename(std::string const & old_path, std::string const & new_pat { try { - messagewriter req(message_type::rename_req); + messagewriter req(request_type::rename); req.write_str(old_path); req.write_str(new_path); req.write_rename_flags(flags); @@ -127,7 +127,7 @@ int filesystem::chmod(std::string const & path, mode_t mode) { try { - messagewriter req(message_type::chmod_req); + messagewriter req(request_type::chmod); req.write_str(path); req.write_mode(mode); auto reader = proxy.perform(std::move(req)); @@ -143,7 +143,7 @@ int filesystem::chown(std::string const & path, uid_t uid, gid_t gid) { try { - messagewriter req(message_type::chown_req); + messagewriter req(request_type::chown); req.write_str(path); req.write_uid(uid); req.write_gid(gid); @@ -160,7 +160,7 @@ int filesystem::truncate(std::string const & path, uint64_t size, uint64_t handl { try { - messagewriter req(message_type::truncate_req); + messagewriter req(request_type::truncate); req.write_str(path); req.write_u64(size); req.write_u64(handle); @@ -177,7 +177,7 @@ int filesystem::fsync(std::string const & path, bool is_datasync, uint64_t handl { try { - messagewriter req(message_type::fsync_req); + messagewriter req(request_type::fsync); req.write_str(path); req.write_bool(is_datasync); req.write_u64(handle); @@ -194,7 +194,7 @@ int filesystem::utimens(std::string const &path, struct timespec tv[2], uint64_t { try { - messagewriter req(message_type::utimens_req); + messagewriter req(request_type::utimens); req.write_str(path); req.write_time(tv[0]); req.write_time(tv[1]); @@ -213,7 +213,7 @@ int filesystem::open(std::string const & path, int flags, uint64_t & handle) { try { - messagewriter req(message_type::open_req); + messagewriter req(request_type::open); req.write_str(path); req.write_openflags(flags); auto reader = proxy.perform(std::move(req)); @@ -234,7 +234,7 @@ int filesystem::mknod(std::string const & path, mode_t mode, dev_t rdev) { try { - messagewriter req(message_type::mknod_req); + messagewriter req(request_type::mknod); req.write_str(path); req.write_mode(mode); req.write_u64(rdev); @@ -251,7 +251,7 @@ int filesystem::create(std::string const & path, mode_t mode, uint64_t & handle) { try { - messagewriter req(message_type::create_req); + messagewriter req(request_type::create); req.write_str(path); req.write_mode(mode); auto reader = proxy.perform(std::move(req)); @@ -272,7 +272,7 @@ int filesystem::release(std::string const & path, uint64_t handle) { try { - messagewriter req(message_type::release_req); + messagewriter req(request_type::release); req.write_str(path); req.write_u64(handle); auto reader = proxy.perform(std::move(req)); @@ -288,7 +288,7 @@ int filesystem::unlink(std::string const & path) { try { - messagewriter req(message_type::unlink_req); + messagewriter req(request_type::unlink); req.write_str(path); auto reader = proxy.perform(std::move(req)); return reader.read_result(); @@ -303,7 +303,7 @@ int filesystem::read(std::string const & path, char * buffer, size_t buffer_size { try { - messagewriter req(message_type::read_req); + messagewriter req(request_type::read); req.write_str(path); req.write_u32(buffer_size); req.write_u64(offset); @@ -334,7 +334,7 @@ int filesystem::write(std::string const & path, char const * buffer, size_t buff { try { - messagewriter req(message_type::write_req); + messagewriter req(request_type::write); req.write_str(path); req.write_data(buffer, buffer_size); req.write_u64(offset); @@ -352,7 +352,7 @@ int filesystem::mkdir(std::string const & path, mode_t mode) { try { - messagewriter req(message_type::mkdir_req); + messagewriter req(request_type::mkdir); req.write_str(path); req.write_mode(mode); auto reader = proxy.perform(std::move(req)); @@ -368,7 +368,7 @@ int filesystem::readdir(std::string const & path, std::vector & ent { try { - messagewriter req(message_type::readdir_req); + messagewriter req(request_type::readdir); req.write_str(path); auto resp = proxy.perform(std::move(req)); int result = resp.read_result(); @@ -388,7 +388,7 @@ int filesystem::rmdir(std::string const & path) { try { - messagewriter req(message_type::rmdir_req); + messagewriter req(request_type::rmdir); req.write_str(path); auto reader = proxy.perform(std::move(req)); return reader.read_result(); @@ -403,7 +403,7 @@ int filesystem::statfs(std::string const & path, struct statvfs * statistics) { try { - messagewriter req(message_type::statfs_req); + messagewriter req(request_type::statfs); req.write_str(path); auto reader = proxy.perform(std::move(req)); int result = reader.read_result(); diff --git a/src/webfuse/message_type.hpp b/src/webfuse/message_type.hpp deleted file mode 100644 index 871466e..0000000 --- a/src/webfuse/message_type.hpp +++ /dev/null @@ -1,38 +0,0 @@ -#ifndef WEBFUSE_MESSAGETYPE_HPP -#define WEBFUSE_MESSAGETYPE_HPP - -#include - -namespace webfuse -{ - -enum class message_type: uint8_t -{ - access_req = 0x01, - getattr_req = 0x02, - readlink_req = 0x03, - symlink_req = 0x04, - link_req = 0x05, - rename_req = 0x06, - chmod_req = 0x07, - chown_req = 0x08, - truncate_req = 0x09, - fsync_req = 0x0a, - open_req = 0x0b, - mknod_req = 0x0c, - create_req = 0x0d, - release_req = 0x0e, - unlink_req = 0x0f, - read_req = 0x10, - write_req = 0x11, - mkdir_req = 0x12, - readdir_req = 0x13, - rmdir_req = 0x14, - statfs_req = 0x15, - utimens_req = 0x16 -}; - - -} - -#endif diff --git a/src/webfuse/provider.cpp b/src/webfuse/provider.cpp new file mode 100644 index 0000000..adf3fdf --- /dev/null +++ b/src/webfuse/provider.cpp @@ -0,0 +1,94 @@ +#include "webfuse/provider.hpp" +#include "webfuse/ws/client.hpp" + +namespace webfuse +{ + +class provider::detail +{ +public: + detail(filesystem_i & fs) + : fs_(fs) + , client([this](auto& reader) { return this->on_message(reader); }) + { + + } + + ~detail() + { + + } + + void connect(std::string const & url) + { + client.connect(url); + } + + void service() + { + client.service(); + } + + messagewriter on_message(messagereader & reader) + { + auto message_id = reader.read_u32(); + auto request_type = reader.read_u8(); + + messagewriter writer(response_type::unknown); + writer.set_id(message_id); + + switch (request_type) + { + + default: + break; + } + + return std::move(writer); + } +private: + filesystem_i & fs_; + ws_client client; +}; + +provider::provider(filesystem_i & fs) +: d(new detail(fs)) +{ + +} + +provider::~provider() +{ + delete d; +} + +provider::provider(provider && other) +{ + this->d = other.d; + other.d = nullptr; +} + +provider& provider::operator=(provider && other) +{ + if (this != &other) + { + delete this->d; + this->d = other.d; + other.d = nullptr; + } + + return *this; +} + +void provider::connect(std::string const & url) +{ + d->connect(url); +} + +void provider::service() +{ + d->service(); +} + + +} \ No newline at end of file diff --git a/src/webfuse/provider.hpp b/src/webfuse/provider.hpp new file mode 100644 index 0000000..806fa83 --- /dev/null +++ b/src/webfuse/provider.hpp @@ -0,0 +1,28 @@ +#ifndef WEBFUSE_PROVIDER_I_HPP +#define WEBFUSE_PROVIDER_I_HPP + +#include "webfuse/filesystem/filesystem_i.hpp" +#include + +namespace webfuse +{ + +class provider +{ + provider(provider const &) = delete; + provider& operator=(provider const &) = delete; +public: + provider(filesystem_i & fs); + ~provider(); + provider(provider && other); + provider& operator=(provider && other); + void connect(std::string const & url); + void service(); +private: + class detail; + detail * d; +}; + +} + +#endif diff --git a/src/webfuse/request_type.hpp b/src/webfuse/request_type.hpp new file mode 100644 index 0000000..4d0687d --- /dev/null +++ b/src/webfuse/request_type.hpp @@ -0,0 +1,38 @@ +#ifndef WEBFUSE_REQUEST_TYPE +#define WEBFUSE_REQUEST_TYPE + +#include + +namespace webfuse +{ + +enum class request_type: uint8_t +{ + unknown = 0x00, + access = 0x01, + getattr = 0x02, + readlink = 0x03, + symlink = 0x04, + link = 0x05, + rename = 0x06, + chmod = 0x07, + chown = 0x08, + truncate = 0x09, + fsync = 0x0a, + open = 0x0b, + mknod = 0x0c, + create = 0x0d, + release = 0x0e, + unlink = 0x0f, + read = 0x10, + write = 0x11, + mkdir = 0x12, + readdir = 0x13, + rmdir = 0x14, + statfs = 0x15, + utimens = 0x16 +}; + +} + +#endif \ No newline at end of file diff --git a/src/webfuse/response_type.hpp b/src/webfuse/response_type.hpp new file mode 100644 index 0000000..064451e --- /dev/null +++ b/src/webfuse/response_type.hpp @@ -0,0 +1,38 @@ +#ifndef WEBFUSE_RESPONSE_TYPE +#define WEBFUSE_RESPONSE_TYPE + +#include + +namespace webfuse +{ + +enum class response_type: uint8_t +{ + unknown = 0x80, + access = 0x81, + getattr = 0x82, + readlink = 0x83, + symlink = 0x84, + link = 0x85, + rename = 0x86, + chmod = 0x87, + chown = 0x88, + truncate = 0x89, + fsync = 0x8a, + open = 0x8b, + mknod = 0x8c, + create = 0x8d, + release = 0x8e, + unlink = 0x8f, + read = 0x90, + write = 0x91, + mkdir = 0x92, + readdir = 0x93, + rmdir = 0x94, + statfs = 0x95, + utimens = 0x96 +}; + +} + +#endif \ No newline at end of file diff --git a/src/webfuse/ws/client.cpp b/src/webfuse/ws/client.cpp new file mode 100644 index 0000000..29a5585 --- /dev/null +++ b/src/webfuse/ws/client.cpp @@ -0,0 +1,150 @@ +#include "webfuse/ws/client.hpp" +#include +#include +#include + +namespace +{ + +extern "C" int webfuse_client_callback(lws * wsi, lws_callback_reasons reason, void* user, void * in, size_t length) +{ + int result = 0; + + lws_protocols const * protocol = lws_get_protocol(wsi); + + if (nullptr != protocol) + { + switch(reason) + { + case LWS_CALLBACK_CLIENT_ESTABLISHED: + std::cout << "established" << std::endl; + break; + case LWS_CALLBACK_CLIENT_CONNECTION_ERROR: + std::cout << "connect error" << std::endl; + break; + case LWS_CALLBACK_CLIENT_CLOSED: + std::cout << "closed" << std::endl; + break; + case LWS_CALLBACK_CLIENT_RECEIVE: + std::cout << "receive" << std::endl; + break; + case LWS_CALLBACK_SERVER_WRITEABLE: + // fall-through + case LWS_CALLBACK_CLIENT_WRITEABLE: + std::cout << "writable" << std::endl; + break; + default: + break; + } + } + + + return result; +} + +} + +namespace webfuse +{ + +class ws_client::detail +{ + detail(detail const &) = delete; + detail& operator=(detail const &) = delete; + detail(detail &&) = delete; + detail& operator=(detail &&) = delete; +public: + detail(ws_client_handler handler) + : handler_(handler) + { + memset(reinterpret_cast(protocols), 0, sizeof(lws_protocols) * 2); + protocols[0].callback = &webfuse_client_callback; + protocols[0].name = "webfuse2-client"; + protocols[0].per_session_data_size = 0; + protocols[0].user = nullptr; + + memset(reinterpret_cast(&info), 0, sizeof(lws_context_creation_info)); + info.port = CONTEXT_PORT_NO_LISTEN; + info.protocols = protocols; + info.uid = -1; + info.gid = -1; + + context = lws_create_context(&info); + } + + ~detail() + { + lws_context_destroy(context); + } + + void connect(std::string const & url) + { + lws_client_connect_info info; + memset(reinterpret_cast(&info), 0, sizeof(lws_client_connect_info)); + info.context = context; + info.port = 8081; + info.address = "localhost"; + info.host = "localhost"; + info.path = "/"; + info.origin = "localhost"; + info.ssl_connection = 0; + info.protocol = "webfuse2"; + info.local_protocol_name = "webfuse2-client"; + info.pwsi = &wsi; + + lws_client_connect_via_info(&info); + } + + void service() + { + lws_service(context, 0); + } + +private: + ws_client_handler handler_; + lws_context_creation_info info; + lws_protocols protocols[2]; + lws_context * context; + lws * wsi; +}; + +ws_client::ws_client(ws_client_handler handler) +: d(new detail(handler)) +{ + +} + +ws_client::~ws_client() +{ + delete d; +} + +ws_client::ws_client(ws_client && other) +{ + this->d = other.d; + other.d = nullptr; +} + +ws_client& ws_client::operator=(ws_client && other) +{ + if (this != &other) + { + delete this->d; + this->d = other.d; + other.d = nullptr; + } + + return *this; +} + +void ws_client::connect(std::string url) +{ + d->connect(url); +} + +void ws_client::service() +{ + d->service(); +} + +} \ No newline at end of file diff --git a/src/webfuse/ws/client.hpp b/src/webfuse/ws/client.hpp new file mode 100644 index 0000000..7441c79 --- /dev/null +++ b/src/webfuse/ws/client.hpp @@ -0,0 +1,33 @@ +#ifndef WEBFUSE_WSCLIENT_HPP +#define WEBFUSE_WSCLIENT_HPP + +#include "webfuse/ws/messagewriter.hpp" +#include "webfuse/ws/messagereader.hpp" + +#include + +namespace webfuse +{ + +using ws_client_handler = std::function; + +class ws_client +{ + ws_client(ws_client const &) = delete; + ws_client& operator=(ws_client const &) = delete; +public: + ws_client(ws_client_handler handler); + ~ws_client(); + ws_client(ws_client && other); + ws_client& operator=(ws_client && other); + + void connect(std::string url); + void service(); +private: + class detail; + detail * d; +}; + +} + +#endif diff --git a/src/webfuse/ws/messagewriter.cpp b/src/webfuse/ws/messagewriter.cpp index 3a8d4f6..0c81a2c 100644 --- a/src/webfuse/ws/messagewriter.cpp +++ b/src/webfuse/ws/messagewriter.cpp @@ -11,12 +11,20 @@ namespace webfuse constexpr uint8_t const rename_noreplace = 0x01; constexpr uint8_t const rename_exchange = 0x02; -messagewriter::messagewriter(message_type msg_type) +messagewriter::messagewriter(request_type req_type) : id(0) , data(LWS_PRE) { write_u32(0); - write_u8(static_cast(msg_type)); + write_u8(static_cast(req_type)); +} + +messagewriter::messagewriter(response_type res_type) +: id(0) +, data(LWS_PRE) +{ + write_u32(0); + write_u8(static_cast(res_type)); } messagewriter::messagewriter(messagewriter && other) diff --git a/src/webfuse/ws/messagewriter.hpp b/src/webfuse/ws/messagewriter.hpp index 22b58d6..cab7cec 100644 --- a/src/webfuse/ws/messagewriter.hpp +++ b/src/webfuse/ws/messagewriter.hpp @@ -1,7 +1,8 @@ #ifndef WEBFUSE_MESSAGEWRITER_HPP #define WEBFUSE_MESSAGEWRITER_HPP -#include "webfuse/message_type.hpp" +#include "webfuse/request_type.hpp" +#include "webfuse/response_type.hpp" #include #include @@ -15,7 +16,8 @@ class messagewriter messagewriter(messagewriter const &) = delete; messagewriter& operator=(messagewriter const &) = delete; public: - explicit messagewriter(message_type msg_type); + explicit messagewriter(request_type req_type); + explicit messagewriter(response_type res_type); ~messagewriter() = default; messagewriter(messagewriter && other); messagewriter& operator=(messagewriter && other); diff --git a/src/webfuse/ws/server.cpp b/src/webfuse/ws/server.cpp index 4ae00b4..51cecb1 100644 --- a/src/webfuse/ws/server.cpp +++ b/src/webfuse/ws/server.cpp @@ -106,7 +106,7 @@ static int ws_server_callback(struct lws *wsi, enum lws_callback_reasons reason, break; case LWS_CALLBACK_SERVER_WRITEABLE: { - webfuse::messagewriter writer(webfuse::message_type::access_req); + webfuse::messagewriter writer(webfuse::request_type::unknown); bool has_msg = false; bool has_more = false;