Repository for the Web Protocols course at URU. It gathers the final versions of the class exercises and projects built around TCP, UDP, and higher-level protocols on top of them.
Table of Contents
This repository brings together the material covered in the Web Protocols course. Its purpose is to keep the final, working version of each class exercise and project in one organized place — everything from raw TCP/UDP sockets to a full FTP client and a UDP-based video streaming service.
Each project folder is self-contained and has its own README with setup instructions and implementation details.
Each project has its own dependencies and run instructions — see its individual README linked in Main Projects.
- Node.js and npm
- A JDK (for the TCP project's Java implementation)
- Python 3 (for the WebSocket example, the serial image bridge, and the UDS project)
- A C compiler and a Unix-like environment (Linux/WSL) for the UDS project's C implementation
- Clone the repo
git clone https://github.com/jerichd4c/web-protocols.git
- Open the folder for the project you want to run.
- Follow that project's own README.
These are the practices and projects currently available in the repository:
ftp-graphical-client/: FileZilla-style graphical FTP client between two physical machines.tcp-remote-method-execution/: TCP server that executes methods of server-side classes via reflection, implemented in both Node.js and Java.udp-video-streaming/: web video player streamed over raw UDP through an HTTP bridge.serial-image-bridge/: desktop app that transmits images to a microcontroller byte-by-byte over serial.unix-domain-socket-messaging/: local client/server chat over a Unix Domain Socket, implemented in both C and Python.websocket-example/: small in-class WebSocket demo in Python (client/server "hello world").
These are the most substantial works developed during the course. Each one has its own internal documentation.
A dual-panel FTP client (local/remote), built with Express and basic-ftp, tested over a real connection between two physical computers.
- Features: connect/upload/download, in-browser text file editing on either side, independent local+remote selection.
- Documentation: Project README
A TCP server that resolves a class and method by reflection and executes it on request — implemented twice, in Node.js and in Java.
- Features: dynamic class loading, a shared pipe-delimited wire protocol, matching CLI menus in both languages.
- Documentation: Project README
A browser video player backed by a custom UDP streaming protocol (LIST/GET/ACK/EOF), bridged to HTTP for the browser.
- Features: chunked UDP transfer with promise-based ACK flow control, video listing and playback in the browser.
- Documentation: Project README
A CustomTkinter desktop app that sends an image to a microcontroller byte-by-byte over serial, with a handshake protocol, and reconstructs whatever comes back.
- Features: grayscale + downsampling pipeline, serial handshake, live transmission log.
- Documentation: Project README
A local client/server chat over a Unix Domain Socket (a filesystem-path pipe instead of an IP/port) — implemented twice, in C and in Python.
- Features: matching wire protocol in both languages, graceful shutdown and cleanup of the socket file on both server implementations.
- Documentation: Project README
This roadmap summarizes the course progress and can keep growing as new units or assignments are added.
- Raw TCP sockets and remote method execution via reflection.
- Raw UDP sockets and a UDP-backed video streaming service.
- A full FTP client between two physical machines.
- Serial communication with a microcontroller (Arduino/ESP32).
- Unix Domain Sockets (UDS) client/server for local message passing.