141 lines
4.1 KiB
Markdown
141 lines
4.1 KiB
Markdown
# OmniSocketC
|
|
|
|
Linux-only C11 implementation of the UDP/KCP transport stack from `OmniSocketGo`.
|
|
|
|
This subtree is intentionally standalone. The Go code stays in place as the behavior reference, while the C implementation builds its own binaries under `c/bin/`.
|
|
|
|
## Build
|
|
|
|
```bash
|
|
make -j$(nproc)
|
|
```
|
|
|
|
Build outputs:
|
|
|
|
- `./bin/udpserver`
|
|
- `./bin/udppeer`
|
|
- `./bin/udpping`
|
|
- `./bin/udprelay`
|
|
- `./bin/kcpserver`
|
|
- `./bin/kcppeer`
|
|
- `./bin/kcpping`
|
|
|
|
Python extension build:
|
|
|
|
```bash
|
|
make python-ext
|
|
make python-install
|
|
```
|
|
|
|
## A-Side OmniDaemon
|
|
|
|
The A-side daemon is configured from `config/a_side_omnidaemon.yaml` in this repo. The safest way to start it is to pass that file explicitly, because the installed Python package does not bundle the YAML config.
|
|
|
|
Run from a source checkout:
|
|
|
|
```bash
|
|
python -m omnisocket_a_side.daemon --config "$(pwd)/config/a_side_omnidaemon.yaml"
|
|
```
|
|
|
|
Or, if you installed the console script:
|
|
|
|
```bash
|
|
OMNIDAEMON_CONFIG="$(pwd)/config/a_side_omnidaemon.yaml" \
|
|
omnisocket-a-side-daemon
|
|
```
|
|
|
|
Optional overrides:
|
|
|
|
- `OMNIDAEMON_SOCKET=/tmp/omnisocket-a-side.sock` selects the local UDS path.
|
|
- `OMNIDAEMON_CONFIG=/abs/path/to/a_side_omnidaemon.yaml` overrides `--config`.
|
|
|
|
For `robot-command-center` and the A-side senders, keep the daemon and its clients on the same Linux machine so they can share the Unix-domain socket.
|
|
|
|
## Run On Different Machines
|
|
|
|
Server `D` runs the KCP hub on `0.0.0.0:10909`:
|
|
|
|
```bash
|
|
./bin/kcpserver -listen 0.0.0.0:10909 \
|
|
-kcp-ts-debug-log logs/d-kcp-ts.jsonl \
|
|
-kcp-session-stats-log logs/d-kcp-stats.jsonl
|
|
```
|
|
|
|
Relay `C` runs a raw UDP forwarder to `D`:
|
|
|
|
```bash
|
|
./bin/kcpserver -mode=relay -listen 0.0.0.0:10909 -relay-remote 172.21.32.15:10909
|
|
```
|
|
|
|
Peer `A` dials `D` through relay `C`:
|
|
|
|
```bash
|
|
./bin/kcppeer -id peer-a -server 172.21.32.15:10909 -relay-via 106.55.173.235:10909 \
|
|
-inbox-dir inbox/a \
|
|
-latency-log logs/a-latency.jsonl \
|
|
-kcp-ts-debug-log logs/a-kcp-ts.jsonl \
|
|
-kcp-session-stats-log logs/a-kcp-stats.jsonl
|
|
```
|
|
|
|
Peer `B` dials `D` directly:
|
|
|
|
```bash
|
|
./bin/kcppeer -id peer-b -server 81.70.156.140:10909 \
|
|
-inbox-dir inbox/b \
|
|
-latency-log logs/b-latency.jsonl \
|
|
-kcp-ts-debug-log logs/b-kcp-ts.jsonl \
|
|
-kcp-session-stats-log logs/b-kcp-stats.jsonl
|
|
```
|
|
|
|
Optional ping / echo tools:
|
|
|
|
```bash
|
|
./bin/kcpping -id peer-a -server 106.55.173.235:10909 -echo
|
|
./bin/kcpping -id peer-b -server 81.70.156.140:10909 -to peer-a -count 20 -interval 100ms
|
|
./bin/udpserver -listen 0.0.0.0:9001
|
|
./bin/udppeer -id peer-a -server 127.0.0.1:9001
|
|
./bin/udpping -id pinger -server 127.0.0.1:9001 -to peer-a -count 20
|
|
```
|
|
|
|
Python control/video demos use two KCP sessions:
|
|
|
|
- `peer-a-ctrl <-> peer-b-ctrl` for small binary control packets
|
|
- `peer-b-video -> peer-a-video` for larger binary video frames
|
|
|
|
Example demo entry points:
|
|
|
|
- `udp_keyboard_sender.py`
|
|
- `udp_xbox_sender.py`
|
|
- `udp_fsm_controller.py`
|
|
- `omnisocket_video_sender.py`
|
|
- `omnisocket_video_receiver.py`
|
|
- `scripts/kcp_control_benchmark.py`
|
|
|
|
Python `recv_into()` note:
|
|
|
|
- The writable buffer must be large enough for the full incoming payload.
|
|
- If the buffer is too small, `recv_into()` reports the required size but the current frame has already been consumed and is lost.
|
|
- For the video demo, keep `video_receiver.buffer_bytes >= video_sender.frame_bytes`.
|
|
|
|
## Interactive Commands
|
|
|
|
`udppeer` and `kcppeer` support the same interactive shell:
|
|
|
|
```text
|
|
help
|
|
text peer-b hello
|
|
text peer-a hi
|
|
file peer-a /tmp/test125.bin
|
|
quit
|
|
```
|
|
|
|
## Notes
|
|
|
|
- The C project targets Linux only.
|
|
- It preserves the Go wire format for UDP datagrams and KCP stream frames.
|
|
- It now supports `binary` payload messages in addition to `text`, `file`, `register`, and `error`.
|
|
- Python `Session.recv_into()` is a zero-copy receive helper for already-sized buffers; it does not retain oversized frames for a retry.
|
|
- It keeps runtime JSONL logging, UDP TX timestamp debug, KCP packet debug, and KCP session stats.
|
|
- Offline `latencysummary` and HTML chart generation are intentionally not migrated.
|
|
- No automated C tests are included in this subtree; validation is expected to happen on Linux via `make` and manual smoke tests.
|