2022-11-20 12:29:34 +00:00
|
|
|
#include "webfuse/ws/messagewriter.hpp"
|
|
|
|
#include "webfuse/filesystem/accessmode.hpp"
|
2022-11-20 13:48:56 +00:00
|
|
|
#include "webfuse/filesystem/filemode.hpp"
|
|
|
|
#include "webfuse/filesystem/openflags.hpp"
|
2022-11-20 12:29:34 +00:00
|
|
|
|
2022-11-19 21:57:32 +00:00
|
|
|
#include <libwebsockets.h>
|
|
|
|
|
|
|
|
namespace webfuse
|
|
|
|
{
|
|
|
|
|
2022-11-20 13:48:56 +00:00
|
|
|
constexpr uint8_t const rename_noreplace = 0x01;
|
|
|
|
constexpr uint8_t const rename_exchange = 0x02;
|
|
|
|
|
2022-12-30 18:44:55 +00:00
|
|
|
messagewriter::messagewriter(request_type req_type)
|
2022-11-19 21:57:32 +00:00
|
|
|
: id(0)
|
|
|
|
, data(LWS_PRE)
|
|
|
|
{
|
2022-11-20 12:29:34 +00:00
|
|
|
write_u32(0);
|
2022-12-30 18:44:55 +00:00
|
|
|
write_u8(static_cast<uint8_t>(req_type));
|
|
|
|
}
|
|
|
|
|
|
|
|
messagewriter::messagewriter(response_type res_type)
|
|
|
|
: id(0)
|
|
|
|
, data(LWS_PRE)
|
|
|
|
{
|
|
|
|
write_u32(0);
|
|
|
|
write_u8(static_cast<uint8_t>(res_type));
|
2022-11-19 21:57:32 +00:00
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
messagewriter::messagewriter(messagewriter && other)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
this->id = other.id;
|
|
|
|
this->data = std::move(other.data);
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
messagewriter& messagewriter::operator=(messagewriter && other)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
if (this != &other)
|
|
|
|
{
|
|
|
|
this->id = other.id;
|
|
|
|
this->data = std::move(other.data);
|
|
|
|
}
|
|
|
|
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::set_id(uint32_t value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
2022-11-20 12:29:34 +00:00
|
|
|
id = value;
|
2023-01-06 15:50:32 +00:00
|
|
|
|
|
|
|
// NOLINTBEGIN(readability-magic-numbers)
|
2022-11-19 21:57:32 +00:00
|
|
|
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;
|
2023-01-06 15:50:32 +00:00
|
|
|
// NOLINTEND(readability-magic-numbers)
|
2022-11-19 21:57:32 +00:00
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
uint32_t messagewriter::get_id() const
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_bool(bool value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
data.push_back(value ? 0x01 : 0x00);
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_u8(uint8_t value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
data.push_back(value);
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_i8(int8_t value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
data.push_back(static_cast<uint8_t>(value));
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_i32(int32_t value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
2022-11-20 12:29:34 +00:00
|
|
|
write_u32((static_cast<uint32_t>(value)));
|
2022-11-19 21:57:32 +00:00
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_u32(uint32_t value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
auto const offset = data.size();
|
2023-01-06 15:50:32 +00:00
|
|
|
|
|
|
|
// NOLINTBEGIN(readability-magic-numbers)
|
2022-11-19 21:57:32 +00:00
|
|
|
data.resize(offset + 4);
|
|
|
|
data[offset ] = (value >> 24) & 0xff;
|
|
|
|
data[offset + 1] = (value >> 16) & 0xff;
|
|
|
|
data[offset + 2] = (value >> 8) & 0xff;
|
|
|
|
data[offset + 3] = value & 0xff;
|
2023-01-06 15:50:32 +00:00
|
|
|
// NOLINTEND(readability-magic-numbers)
|
2022-11-19 21:57:32 +00:00
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_u64(uint64_t value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
2023-01-06 15:50:32 +00:00
|
|
|
auto const offset = data.size();
|
|
|
|
|
|
|
|
// NOLINTBEGIN(readability-magic-numbers)
|
2022-11-19 21:57:32 +00:00
|
|
|
data.resize(offset + 8);
|
|
|
|
data[offset ] = (value >> 56) & 0xff;
|
|
|
|
data[offset + 1] = (value >> 48) & 0xff;
|
|
|
|
data[offset + 2] = (value >> 40) & 0xff;
|
|
|
|
data[offset + 3] = (value >> 32) & 0xff;
|
|
|
|
data[offset + 4] = (value >> 24) & 0xff;
|
|
|
|
data[offset + 5] = (value >> 16) & 0xff;
|
|
|
|
data[offset + 6] = (value >> 8) & 0xff;
|
|
|
|
data[offset + 7] = value & 0xff;
|
2023-01-06 15:50:32 +00:00
|
|
|
// NOLINTEND(readability-magic-numbers)
|
2022-11-19 21:57:32 +00:00
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_str(std::string const &value)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
2022-11-20 12:29:34 +00:00
|
|
|
write_data(value.data(), value.size());
|
2022-11-19 21:57:32 +00:00
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_data(char const * buffer, size_t size)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
uint32_t const effective_size = size & 0xffffffff;
|
2022-11-20 12:29:34 +00:00
|
|
|
write_u32(effective_size);
|
2022-11-19 21:57:32 +00:00
|
|
|
|
|
|
|
if (size > 0)
|
|
|
|
{
|
|
|
|
auto const offset = data.size();
|
|
|
|
data.resize(offset + effective_size);
|
2023-01-06 15:50:32 +00:00
|
|
|
void * to = reinterpret_cast<void*>(&data[offset]);
|
2022-11-19 21:57:32 +00:00
|
|
|
void const * from = reinterpret_cast<void const *>(buffer);
|
|
|
|
memcpy(to, from, effective_size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_strings(std::vector<std::string> const & list)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
uint32_t const count = list.size() & 0xffffffff;
|
2022-11-20 12:29:34 +00:00
|
|
|
write_u32(count);
|
2022-11-19 21:57:32 +00:00
|
|
|
for (auto const & item: list)
|
|
|
|
{
|
2022-11-20 12:29:34 +00:00
|
|
|
write_str(item);
|
2022-11-19 21:57:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-30 22:06:47 +00:00
|
|
|
void messagewriter::write_attr(struct stat const * attr)
|
|
|
|
{
|
|
|
|
write_u64(static_cast<uint64_t>(attr->st_ino));
|
|
|
|
write_u64(static_cast<uint64_t>(attr->st_nlink));
|
|
|
|
write_mode(filemode::from_mode(attr->st_mode));
|
|
|
|
write_u32(static_cast<uint32_t>(attr->st_uid));
|
|
|
|
write_u32(static_cast<uint32_t>(attr->st_gid));
|
|
|
|
write_u64(static_cast<uint64_t>(attr->st_rdev));
|
|
|
|
write_u64(static_cast<uint64_t>(attr->st_size));
|
|
|
|
write_u64(static_cast<uint64_t>(attr->st_blocks));
|
|
|
|
write_time(attr->st_atim);
|
|
|
|
write_time(attr->st_mtim);
|
|
|
|
write_time(attr->st_ctim);
|
|
|
|
}
|
|
|
|
|
2022-11-20 12:29:34 +00:00
|
|
|
void messagewriter::write_access_mode(int value)
|
|
|
|
{
|
|
|
|
access_mode mode = access_mode::from_int(value);
|
|
|
|
write_i8(mode);
|
|
|
|
}
|
|
|
|
|
2022-11-20 13:48:56 +00:00
|
|
|
void messagewriter::write_rename_flags(unsigned int value)
|
|
|
|
{
|
|
|
|
uint8_t flags = 0;
|
|
|
|
if (RENAME_NOREPLACE == (value & RENAME_NOREPLACE)) { flags |= rename_noreplace; }
|
|
|
|
if (RENAME_EXCHANGE == (value & RENAME_EXCHANGE )) { flags |= rename_exchange; }
|
|
|
|
|
|
|
|
write_u8(flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void messagewriter::write_mode(mode_t value)
|
|
|
|
{
|
|
|
|
filemode mode = filemode::from_mode(value);
|
|
|
|
write_u32(mode);
|
|
|
|
}
|
|
|
|
|
|
|
|
void messagewriter::write_uid(uid_t value)
|
|
|
|
{
|
|
|
|
write_u32(static_cast<uint32_t>(value));
|
|
|
|
}
|
|
|
|
|
|
|
|
void messagewriter::write_gid(gid_t value)
|
|
|
|
{
|
|
|
|
write_u32(static_cast<uint32_t>(value));
|
|
|
|
}
|
|
|
|
|
|
|
|
void messagewriter::write_openflags(int value)
|
|
|
|
{
|
|
|
|
openflags flags = openflags::from_int(value);
|
|
|
|
write_i32(flags);
|
|
|
|
}
|
|
|
|
|
2022-11-27 19:26:45 +00:00
|
|
|
void messagewriter::write_time(timespec const & value)
|
|
|
|
{
|
|
|
|
write_u64(static_cast<uint64_t>(value.tv_sec));
|
|
|
|
write_u32(static_cast<uint32_t>(value.tv_nsec));
|
|
|
|
}
|
|
|
|
|
2023-01-04 19:51:57 +00:00
|
|
|
void messagewriter::write_statistics(struct statvfs const * statistics)
|
|
|
|
{
|
|
|
|
write_u64(statistics->f_bsize);
|
|
|
|
write_u64(statistics->f_frsize);
|
|
|
|
write_u64(statistics->f_blocks);
|
|
|
|
write_u64(statistics->f_bfree);
|
|
|
|
write_u64(statistics->f_bavail);
|
|
|
|
write_u64(statistics->f_files);
|
|
|
|
write_u64(statistics->f_ffree);
|
|
|
|
write_u64(statistics->f_namemax);
|
|
|
|
}
|
2022-11-20 12:29:34 +00:00
|
|
|
|
|
|
|
unsigned char * messagewriter::get_data(size_t &size)
|
2022-11-19 21:57:32 +00:00
|
|
|
{
|
|
|
|
size = data.size() - LWS_PRE;
|
2023-01-06 15:50:32 +00:00
|
|
|
void * result = reinterpret_cast<void *>(&data[LWS_PRE]);
|
2022-11-19 21:57:32 +00:00
|
|
|
|
|
|
|
return reinterpret_cast<unsigned char *>(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-01-25 20:22:51 +00:00
|
|
|
}
|