gatuna/PROTOCOL.md

# gatuna wire protocol

All frames ride Ethernet with ethertype `0x6969`. The ethertype is the sole
discriminator; there is no magic number inside the payload.

## Frame layout

```
 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+---------------+---------------+-------------------------------+
| version       | type          | session_id                    |
+---------------+---------------+-------------------------------+
| payload_len (big-endian)      | payload ...                   |
+-------------------------------+                               +
|                                                               |
+---------------------------------------------------------------+
```

- **version** (u8): protocol version. Currently `1`.
- **type** (u8): frame type, see table below.
- **session_id** (u32, big-endian): `0` for non-session frames; the
  server-assigned ID for session-scoped frames.
- **payload_len** (u16, big-endian): number of payload bytes that follow.
  The receiver reads exactly this many bytes and ignores any trailing
  Ethernet padding (frames under 60 bytes are zero-padded by the NIC to
  meet the minimum Ethernet frame size).
- **payload** (`payload_len` bytes): type-dependent.

No CRC, no retransmit, no ordering at this layer. TCP reliability is handled by
the endpoints' TCP stacks; UDP (reserved) will rely on application-level
mechanisms.

Maximum payload: 1500 (Ethernet MTU) − 8 (our header) = **1492 bytes**. In
practice we cap at **1480** to stay conservative. Larger payloads are not
emitted in v1.

## Frame types

| Type | Name        | Direction     | session_id | Payload                          |
|------|-------------|---------------|------------|----------------------------------|
| 0x01 | DISCOVER    | C → broadcast | 0          | empty                            |
| 0x02 | MANIFEST    | S → C         | 0          | `id:1, proto:1, port:2` × N      |
| 0x03 | OPEN        | C → S         | 0          | `upstream_id:1`                  |
| 0x04 | OPEN_ACK    | S → C         | assigned   | `upstream_id:1`                  |
| 0x05 | OPEN_NAK    | S → C         | 0          | `upstream_id:1, reason:1`        |
| 0x06 | DATA        | both          | session    | raw bytes (≤1480)                |
| 0x07 | CLOSE       | both          | session    | optional `reason:1`              |

Reserved (unimplemented in v1; parse returns Err, encode unimplemented):

| Type | Name        |
|------|-------------|
| 0x08 | UDP_OPEN    |
| 0x09 | UDP_DATA    |
| 0x0A | UDP_CLOSE   |

## Payload field encodings

### MANIFEST payload

A hostname prefix followed by variable-length entries, parsed sequentially
until the payload is consumed.

```
 0                   1                   2                   3
 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+---------------+-----------------------------------------------+
| hostname_len  | hostname (UTF-8, hostname_len bytes) ...       |
+---------------+-----------------------------------------------+
| id            | proto         | port (big-endian)             |
+---------------+---------------+-------------------------------+
| label_len     | label (UTF-8, label_len bytes) ...           |
+---------------+-----------------------------------------------+
| ... repeated ...                                             |
+---------------------------------------------------------------+
```

- **hostname_len** (u8): length in bytes of the server's hostname. `0` is valid
  (unknown hostname).
- **hostname** (`hostname_len` bytes, UTF-8): the server's hostname, read via
  `gethostname(2)` at startup. Maximum 255 bytes.
- **id** (u8): upstream identifier (1-based positional index from `gatunad`
  cmdline).
- **proto** (u8): `1 = TCP`, `2 = UDP` (reserved; not emitted in v1).
- **port** (u16, big-endian): the real port on the server's `127.0.0.1`.
- **label_len** (u8): length in bytes of the label that follows. `0` means no
  label.
- **label** (`label_len` bytes, UTF-8): human-readable name for the upstream,
  taken from the `PORT[:label]` cmdline argument. Maximum 255 bytes.

To parse: read `hostname_len`, then `hostname_len` bytes of hostname, then read
5-byte fixed entry prefixes + `label_len` bytes of label each, repeating until
the payload is exhausted. The number of entries is not carried explicitly.

### OPEN payload

```
+---------------+
| upstream_id   |
+---------------+
```

- **upstream_id** (u8): which MANIFEST entry to open.

### OPEN_ACK payload

```
+---------------+
| upstream_id   |
+---------------+
```

- **upstream_id** (u8): echoes the requested upstream. The session is
  identified by the `session_id` field in the header, not the payload.

### OPEN_NAK payload

```
+---------------+---------------+
| upstream_id   | reason        |
+---------------+---------------+
```

- **upstream_id** (u8): echoes the requested upstream.
- **reason** (u8): see reason codes.

### DATA payload

Raw application bytes. Up to 1480 bytes per frame. The `session_id` header
field identifies which session the bytes belong to.

### CLOSE payload

```
+---------------+
| reason?       |
+---------------+
```

- **reason** (u8, optional): present iff payload length ≥ 1. See reason codes.

## Reason codes

| Value | Meaning           |
|-------|-------------------|
| 0     | unspecified       |
| 1     | unknown_upstream  |
| 2     | connect_failed    |
| 3     | oversize          |
| 4     | unknown_session   |

## Discovery flow

```
client                            server
  |                                 |
  | DISCOVER (dst = broadcast)      |
  |-------------------------------->|
  |                                 |
  |        MANIFEST (unicast)       |
  |<--------------------------------|
  |                                 |
```

The server learns the client's MAC from the DISCOVER frame's source address and
unicasts the MANIFEST back. The server never speaks unsolicited.

## TCP session lifecycle

```
client                            server
  |                                 |
  | OPEN { upstream_id }            |
  |-------------------------------->|
  |                                 | TcpStream::connect(127.0.0.1:port)
  |                                 |
  |   OPEN_ACK { session_id }       |
  |<--------------------------------|   (on success)
  |        OR                       |
  |   OPEN_NAK { reason }           |
  |<--------------------------------|   (on failure)
  |                                 |
  | DATA { session_id, bytes }      |
  |<------------------------------->| DATA { session_id, bytes }
  |                                 |
  | CLOSE { session_id, reason? }   |
  |<------------------------------->|   (on EOF, RST, or error)
  |                                 |
```

- `session_id` is allocated by the server as a monotonically increasing u32
  (starting at 1) from an atomic counter. Collision by wraparound is ignored.
- Either side may send `CLOSE`. The side receiving `CLOSE` tears down its half
  and stops emitting frames for that session.
- The server's socket→tunnel pump reads `TcpStream` in 1480-byte chunks and
  emits one `DATA` frame per chunk. On `read` returning 0 (FIN) or an error,
  it emits `CLOSE` and exits.
- The server's tunnel→socket path writes `DATA` payloads to the `TcpStream`
  with `write_all`. On error it emits `CLOSE` and drops the session.