alexcoder04 / rfap

proof-of-concept network file access protocol

Reliable File Access Protocol

This project is in alpha stage, so expect radical changes to come.

This repository contains documentation, specifications, overviews, organizational information and general discussions about the protocol. See related projects for actual implementations.

Protocol specifications (in progress)

• for general protocol specifications, see specification.md
• for YML metadata specification, see metadata-example.yml
• for a full overview of commands, see commands.md
• for a full overview of error codes, see errors.md

Related projects (in progress)

• https://github.com/alexcoder04/rfap-go-server - reference server implementation
• https://github.com/alexcoder04/librfap - Python library
• https://github.com/BoettcherDasOriginal/rfap-cs-lib - C# library
• https://github.com/alexcoder04/rfap-pycli - Python CLI client based on librfap
• https://github.com/alexcoder04/rfap-fuse - FUSE implementation in Python based on librfap

Contributing

Please see CONTRIBUTING.md for more information.

Why did we start this project?

FTP is too old.

NFS is unencrypted.

SMB is too complex.

WebDAV makes not much sense.

SSHFS is for nerds.

So what is the best way to share files?

rfap's Issues

Send commands from server to client

This is very likely never to be implemented: to achieve this, the client would have to be listening to the server all the time, so it couldn't send commands.

The only possible solution would be to open a second socket which would have to run in a separate thread that can communicate with the main thread, so the overall design would become much more complicated.

TUI app

A client with terminal user interface (e.g. curses-based). Maybe in Go, so it's even cross-platform

Send list of supported features in initial packet

Like whether the client/server support compression/collab mode/live mode/...

Server console

(Although it's a go-server problem, we can discuss it here)

What should we use for the console?
Stdin is not an option, because we don't have a window with the server running open all the time; moreover the server would print messages while you are typing your command, so it wouldn't really work.
A Unix domain socket would be much better, but it's not supported on Windows (does Windows have something like that?).
Another socket listening on localhost? Seems complicated to me.

FUSE module for Linux

FUSE allows to write filesystems for Linux in userspace. With PyFUSE, we could build a filesystem based on librfap

When exactly to send which metadata

Some metadata values are only sent if requested (elements number in directory), some only if info is called, some are sent always.
We should document this more clearly.

Optional compression

To save bandwidth, we can add optional compression for large text files. The compression would be turned on if both sides support it and the information about the compression standard would be sent inside the header

Splitting large files

If we send files bigger than 16MB, we would need to split them over multiple packets, so we need a specification and implementation of that feature

Air-Drop-like app

(idea for a new implementation)

This app would be able to act as a server as well as a client, but only on the local network (maybe even over Bluetooth?).

What are the protocol specifications?

[headline]