Archives
/
falk-werner_webfuse
mirror of https://github.com/falk-werner/webfuse
1
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '6214748495'
${ noResults }
falk-werner_webfuse/example/provider/python/webfuse_provider.py

580 lines
18 KiB
Raw Blame History

#!/usr/bin/env python3
import asyncio
import os
import stat
import websockets
import errno
import getpass
INVALID_FD = 0xffffffffffffffff
F_OK = 0
R_OK = 4
W_OK = 2
X_OK = 1
RESPONSE = 0x80
ERRNO = {
-errno.E2BIG : -7,
-errno.EACCES : -13,
-errno.EAGAIN : -11,
-errno.EBADF : -9,
-errno.EBUSY : -16,
-errno.EDESTADDRREQ : -89,
-errno.EDQUOT : -122,
-errno.EEXIST : -17,
-errno.EFAULT : -14,
-errno.EFBIG : -27,
-errno.EINTR : -4,
-errno.EINVAL : -22,
-errno.EIO : -5,
-errno.EISDIR : -21,
-errno.ELOOP : -40,
-errno.EMFILE : -24,
-errno.EMLINK : -31,
-errno.ENAMETOOLONG : -36,
-errno.ENFILE : -23,
-errno.ENODATA : -61,
-errno.ENODEV : -19,
-errno.ENOENT : -2,
-errno.ENOMEM : -12,
-errno.ENOSPC : -28,
-errno.ENOSYS : -38,
-errno.ENOTDIR : -20,
-errno.ENOTEMPTY : -39,
-errno.ENOTSUP : -95,
-errno.ENXIO : -6,
-errno.EOVERFLOW : -75,
-errno.EPERM : -1,
-errno.EPIPE : -32,
-errno.ERANGE : -34,
-errno.EROFS : -30,
-errno.ETXTBSY : -26,
-errno.EXDEV : -18
}
RENAME_NOREPLACE = 0x01
RENAME_EXCHANGE = 0x02
MODE_REG = 0o100000
MODE_DIR = 0o040000
MODE_CHR = 0o020000
MODE_BLK = 0o060000
MODE_FIFO = 0o010000
MODE_LNK = 0o120000
MODE_SOCK = 0o140000
O_RDONLY = 0o00
O_WRONLY = 0o01
O_RDWR = 0o02
O_APPEND = 0o00002000
O_ASYNC = 0o00020000
O_CLOEXEC = 0o02000000
O_CREAT = 0o00000100
O_DIRECT = 0o00040000
O_DIRECTORY = 0o00200000
O_DSYNC = 0o00010000
O_EXCL = 0o00000200
O_LARGEFILE = 0o00100000
O_NOATIME = 0o01000000
O_NOCTTY = 0o00000400
O_NOFOLLOW = 0o00400000
O_NONBLOCK = 0o00004000
O_NDELAY = 0o00004000
O_PATH = 0o10000000
O_SYNC = 0o04010000
O_TMPFILE = 0o20200000
O_TRUNC = 0o00001000
class MessageReader:
def __init__(self, buffer):
self.buffer = buffer
self.offset = 0
def read_u8(self):
value = self.buffer[self.offset]
self.offset += 1
return value
def read_bool(self):
return self.read_u8() == 1
def read_u32(self):
value = (self.buffer[self.offset] << 24) + (self.buffer[self.offset + 1] << 16) + (self.buffer[self.offset + 2] << 8) + self.buffer[self.offset + 3]
self.offset += 4
return value
def read_u64(self):
value = (
(self.buffer[self.offset ] << 56) +
(self.buffer[self.offset + 1] << 48) +
(self.buffer[self.offset + 2] << 40) +
(self.buffer[self.offset + 3] << 32) +
(self.buffer[self.offset + 4] << 24) +
(self.buffer[self.offset + 5] << 16) +
(self.buffer[self.offset + 6] << 8) +
self.buffer[self.offset + 7])
self.offset += 8
return value
def read_str(self):
return self.read_bytes().decode()
def read_bytes(self):
size = self.read_u32()
value = self.buffer[self.offset : self.offset + size]
self.offset += size
return value
def read_path(self, base_path):
local_path = self.read_str().lstrip('/')
return os.path.join(base_path, local_path)
def read_access_mode(self):
value = self.read_u8()
mode = os.F_OK if F_OK == (value & F_OK) else 0
mode |= os.R_OK if R_OK == (value & R_OK) else 0
mode |= os.W_OK if W_OK == (value & W_OK) else 0
mode |= os.X_OK if X_OK == (value & X_OK) else 0
return mode
def read_rename_flags(self):
return self.read_u8()
def read_mode(self):
value = self.read_u32()
mode = value & 0o7777
mode |= stat.S_IFREG if MODE_REG == (value & MODE_REG ) else 0
mode |= stat.S_IFDIR if MODE_DIR == (value & MODE_DIR ) else 0
mode |= stat.S_IFCHR if MODE_CHR == (value & MODE_CHR ) else 0
mode |= stat.S_IFBLK if MODE_BLK == (value & MODE_BLK ) else 0
mode |= stat.S_IFFIFO if MODE_FIFO == (value & MODE_FIFO) else 0
mode |= stat.S_IFLNK if MODE_LNK == (value & MODE_LNK ) else 0
mode |= stat.S_IFSOCK if MODE_SOCK == (value & MODE_SOCK) else 0
return mode
def read_openflags(self):
value = self.read_u32()
flags = 0
# Access Mode
flags |= os.O_RDONLY if O_RDONLY == (value & O_RDONLY) else 0
flags |= os.O_WRONLY if O_WRONLY == (value & O_WRONLY) else 0
flags |= os.O_RDWR if O_RDWR == (value & O_RDWR ) else 0
# Flags
flags |= os.O_APPEND if O_APPEND == (value & O_APPEND ) else 0
flags |= os.O_ASYNC if O_ASYNC == (value & O_ASYNC ) else 0
flags |= os.O_CLOEXEC if O_CLOEXEC == (value & O_CLOEXEC ) else 0
flags |= os.O_CREAT if O_CREAT == (value & O_CREAT ) else 0
flags |= os.O_DIRECT if O_DIRECT == (value & O_DIRECT ) else 0
flags |= os.O_DIRECTORY if O_DIRECTORY == (value & O_DIRECTORY) else 0
flags |= os.O_DSYNC if O_DSYNC == (value & O_DSYNC ) else 0
flags |= os.O_EXCL if O_EXCL == (value & O_EXCL ) else 0
flags |= os.O_LARGEFILE if O_LARGEFILE == (value & O_LARGEFILE) else 0
flags |= os.O_NOCTTY if O_NOCTTY == (value & O_NOCTTY ) else 0
flags |= os.O_NOFOLLOW if O_NOFOLLOW == (value & O_NOFOLLOW ) else 0
flags |= os.O_NONBLOCK if O_NONBLOCK == (value & O_NONBLOCK ) else 0
flags |= os.O_NDELAY if O_NDELAY == (value & O_NDELAY ) else 0
flags |= os.O_PATH if O_PATH == (value & O_PATH ) else 0
flags |= os.O_SYNC if O_SYNC == (value & O_SYNC ) else 0
flags |= os.O_TMPFILE if O_TMPFILE == (value & O_TMPFILE ) else 0
flags |= os.O_TRUNC if O_TRUNC == (value & O_TRUNC ) else 0
return flags
class MessageWriter:
def __init__(self, message_id, message_type):
self.buffer = []
self.write_u32(message_id)
self.write_u8(message_type)
def write_u8(self, value):
self.buffer.append(value)
def write_u32(self, value):
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)
def write_result(self, value):
if 0 > value:
if value in ERRNO:
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):
return bytearray(self.buffer)
class FilesystemProvider:
def __init__(self, path, url):
self.root = os.path.abspath(path)
self.url = url
self.commands = {
0x01: FilesystemProvider.access,
0x02: FilesystemProvider.getattr,
0x03: FilesystemProvider.readlink,
0x04: FilesystemProvider.symlink,
0x05: FilesystemProvider.link,
0x06: FilesystemProvider.rename,
0x07: FilesystemProvider.chmod,
0x08: FilesystemProvider.chown,
0x09: FilesystemProvider.truncate,
0x0a: FilesystemProvider.fsync,
0x0b: FilesystemProvider.open,
0x0c: FilesystemProvider.mknod,
0x0d: FilesystemProvider.create,
0x0e: FilesystemProvider.release,
0x0f: FilesystemProvider.unlink,
0x10: FilesystemProvider.read,
0x11: FilesystemProvider.write,
0x12: FilesystemProvider.mkdir,
0x13: FilesystemProvider.readdir,
0x14: FilesystemProvider.rmdir,
0x15: FilesystemProvider.statfs,
0x16: FilesystemProvider.utimens,
0x17: FilesystemProvider.getcreds,
}
async def run(self):
extra_headers = [("X-Auth-Token", "user:bob;token=foo")]
async with websockets.connect(self.url, extra_headers=extra_headers) as connection:
while True:
request = await connection.recv()
reader = MessageReader(request)
message_id = reader.read_u32()
message_type = reader.read_u8()
writer = MessageWriter(message_id, RESPONSE + message_type)
if message_type in self.commands:
method = self.commands[message_type]
method(self, reader, writer)
else:
print("unknown message type: %d" % message_type)
response = writer.get_bytes()
await connection.send(response)
def access(self, reader, writer):
path = reader.read_path(self.root)
mode = reader.read_access_mode()
result = -errno.EACCES
try:
if os.access(path, mode) == True:
result = 0
except OSError as ex:
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 readlink(self, reader, writer):
path = reader.read_path(self.root)
try:
link = os.readlink(path)
except OSError as ex:
writer.write_result(-ex.errno)
return
writer.write_result(0)
writer.write_str(link)
def symlink(self, reader, writer):
source = reader.read_str()
target = reader.read_path(self.root)
result = 0
try:
os.symlink(source, target)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def link(self, reader, writer):
source = reader.read_path(self.root)
target = reader.read_path(self.root)
result = 0
try:
os.link(source, target)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def rename(self, reader, writer):
source = reader.read_path(self.root)
target = reader.read_path(self.root)
flags = reader.read_rename_flags()
result = 0
try:
if RENAME_EXCHANGE == (flags & RENAME_EXCHANGE):
# exchange is not supported
result = -errno.EINVAL
elif RENAME_NOREPLACE == (flags & RENAME_NOREPLACE):
os.rename(source, target)
else:
os.replace(source, target)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def chmod(self, reader, writer):
path = reader.read_path(self.root)
mode = reader.read_mode()
result = 0
try:
os.chmod(path, mode)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def chown(self, reader, writer):
path = reader.read_path(self.root)
uid = reader.read_u32()
gid = reader.read_u32()
result = 0
try:
os.chown(path, uid, gid)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def truncate(self, reader, writer):
path = reader.read_path(self.root)
size = reader.read_u64()
fd = reader.read_u64()
result = 0
try:
if fd != INVALID_FD:
os.ftruncate(fd, size)
else:
os.truncate(path, size)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def fsync(self, reader, writer):
path = reader.read_path(self.root)
_ = reader.read_bool()
fd = reader.read_u64()
result = 0
try:
os.fsync(fd)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def utimens(self, reader, writer):
path = reader.read_path(self.root)
atime = reader.read_u64()
atime_ns = reader.read_u32()
mtime = reader.read_u64()
mtime_ns = reader.read_u32()
fd = reader.read_u64()
result = 0
try:
os.utime(path, (atime, mtime), ns = (atime_ns, mtime_ns))
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def open(self, reader, writer):
path = reader.read_path(self.root)
flags = reader.read_openflags()
try:
fd = os.open(path, flags)
except OSError as ex:
writer.write_result(-ex.errno)
return
writer.write_result(0)
writer.write_u64(fd)
def mknod(self, reader, writer):
path = reader.read_path(self.root)
mode = reader.read_mode()
rdev = reader.read_u64()
result = 0
try:
os.mknod(path, mode, rdev)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def create(self, reader, writer):
path = reader.read_path(self.root)
mode = reader.read_mode()
try:
flags = os.O_CREAT | os.O_WRONLY | os.O_TRUNC
fd = os.open(path, flags, mode)
except OSError as ex:
writer.write_result(-ex.errno)
return
writer.write_result(0)
writer.write_u64(fd)
pass
def release(self, reader, writer):
path = reader.read_path(self.root)
fd = reader.read_u64()
result = 0
try:
os.close(fd)
except OSError as ex:
writer.write_result(-ex.errno)
return
writer.write_result(result)
def unlink(self, reader, writer):
path = reader.read_path(self.root)
result = 0
try:
os.unlink(path)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def read(self, reader, writer):
path = reader.read_path(self.root)
size = reader.read_u32()
offset = reader.read_u64()
fd = reader.read_u64()
try:
if fd != INVALID_FD:
buffer = os.pread(fd, size, offset)
else:
with os.open(path, os.O_RDONLY) as f:
buffer = os.pread(f, size, offset)
writer.write_result(len(buffer))
writer.write_bytes(buffer)
except OSError as ex:
writer.write_result(-ex.errno)
def write(self, reader, writer):
path = reader.read_path(self.root)
data = reader.read_bytes()
offset = reader.read_u64()
fd = reader.read_u64()
result = 0
try:
if fd != INVALID_FD:
result = os.pwrite(fd, data, offset)
else:
with os.open(path, os.O_WRONLY) as f:
result = os.pwrite(f, data, offset)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def mkdir(self, reader, writer):
path = reader.read_path(self.root)
mode = reader.read_u32()
result = 0
try:
os.mkdir(path, mode)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
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)
def rmdir(self, reader, writer):
path = reader.read_path(self.root)
result = 0
try:
os.rmdir(path)
except OSError as ex:
result = -ex.errno
writer.write_result(result)
def statfs(self, reader, writer):
path = self.get_path(reader)
try:
buffer = os.statvfs(path)
except OSError as ex:
writer.write_result(-ex.errno)
return
writer.write_result(0)
writer.write_u64(buffer.f_bsize)
writer.write_u64(buffer.f_frsize)
writer.write_u64(buffer.f_blocks)
writer.write_u64(buffer.f_bfree)
writer.write_u64(buffer.f_bavail)
writer.write_u64(buffer.f_files)
writer.write_u64(buffer.f_ffree)
writer.write_u64(buffer.f_namemax)
def getcreds(self, reader, writer):
credentials = getpass.getpass(prompt="credentials: ")
writer.write_str(credentials)
if __name__ == '__main__':
provider = FilesystemProvider('.', 'ws://localhost:8081')
asyncio.run(provider.run())
Reference in new issue View Git Blame Copy Permalink