Source File
	relay.go

Belonging Package
	github.com/tmc/go-iroh/internal/socket

package socket

import (
	"context"

	"github.com/tmc/go-iroh/internal/relayproto"
	"github.com/tmc/go-iroh/netaddr"
	"github.com/tmc/go-iroh/relay"
	"github.com/tmc/go-iroh/watch"
)

// RelayTransport is the magic socket's relay path: it owns a [RelayActor],
// forwards datagrams received from relays into the [MagicConn]'s recv channel
// (tagged so they surface as a [RelayMappedAddr]), and routes outgoing datagrams
// addressed to a relay mapped address to the right relay connection.
//
// It is the Go analog of the Rust RelayTransport
// (iroh/src/socket/transports/relay.rs:31). Create one with [NewRelayTransport]
// and start it with [RelayTransport.Serve]. The zero value is not usable.
type RelayTransport struct {
	sock   *Socket
	actor  *RelayActor
	recvCh chan<- recvBatch
}

// NewRelayTransport returns a RelayTransport that drives actor and delivers
// received relay datagrams to recvCh. sock supplies the relay mapped-address
// table shared with the [MagicConn]. The transport does not start the actor;
// call [RelayTransport.Serve].
func NewRelayTransport(sock *Socket, actor *RelayActor, recvCh chan<- recvBatch) *RelayTransport {
	return &RelayTransport{sock: sock, actor: actor, recvCh: recvCh}
}

// Serve runs the relay actor and the recv-forwarding loop until ctx is
// cancelled. It blocks; run it in its own goroutine.
func (t *RelayTransport) Serve(ctx context.Context) {
	go t.actor.Run(ctx)
	t.forwardRecv(ctx)
}

// forwardRecv drains datagrams from the actor and forwards each as a recvBatch
// tagged with the relay [Addr], so [MagicConn.recvAddr] rewrites it to the
// relay mapped IPv6 ULA quic-go addresses the path by. A relay transmit may
// carry a GRO batch (segment size set); each segment is delivered as its own
// recvBatch, matching the re-batching in the Rust poll_recv
// (iroh/src/socket/transports/relay.rs:115).
func (t *RelayTransport) forwardRecv(ctx context.Context) {
	for {
		select {
		case <-ctx.Done():
			return
		case dm, ok := <-t.actor.Recv():
			if !ok {
				return
			}
			t.deliver(ctx, dm)
		}
	}
}

// deliver splits dm into single datagrams (by its segment size) and forwards
// each to the recv channel.
func (t *RelayTransport) deliver(ctx context.Context, dm RelayRecvDatagram) {
	remote := RelayAddr(dm.URL, dm.Src)
	for _, seg := range splitSegments(dm.Datagrams) {
		data := make([]byte, len(seg))
		copy(data, seg)
		select {
		case t.recvCh <- recvBatch{data: data, info: RecvInfo{Remote: remote}}:
		case <-ctx.Done():
			return
		}
	}
}

// splitSegments returns the individual datagrams in d. A zero segment size means
// a single datagram; otherwise the contents are sliced into segment-size strides
// (the final segment may be shorter), matching the relay GRO stride
// (iroh/src/socket/transports/relay.rs:154).
func splitSegments(d relayproto.Datagrams) [][]byte {
	if d.SegmentSize == 0 || len(d.Contents) == 0 {
		return [][]byte{d.Contents}
	}
	stride := int(d.SegmentSize)
	var out [][]byte
	for off := 0; off < len(d.Contents); off += stride {
		end := off + stride
		if end > len(d.Contents) {
			end = len(d.Contents)
		}
		out = append(out, d.Contents[off:end])
	}
	return out
}

// Send routes p to the relay addressed by the relay mapped address m. It looks
// up the (relay url, endpoint id) pair m maps to and queues a datagram to the
// relay actor. It reports whether the datagram was routed; a false result means
// the address is unknown or the send queue was full, in which case the datagram
// is treated as lost (QUIC's loss recovery retransmits), matching the Rust
// blackhole-on-failure invariant (iroh/src/socket/transports.rs:1176).
func (t *RelayTransport) Send(m RelayMappedAddr, p []byte) bool {
	rk, ok := t.sock.LookupRelay(m)
	if !ok {
		return false
	}
	return t.actor.Send(RelaySendItem{
		RemoteEndpoint: rk.EID,
		URL:            rk.URL,
		Datagrams:      relayproto.DatagramsFromBytes(p),
	})
}

// SetHomeRelay designates url as the endpoint's home relay. See
// [RelayActor.SetHomeRelay].
func (t *RelayTransport) SetHomeRelay(url netaddr.RelayURL) { t.actor.SetHomeRelay(url) }

// InsertRelay adds or replaces a relay config in the underlying actor.
func (t *RelayTransport) InsertRelay(url netaddr.RelayURL, cfg relay.Config) (relay.Config, bool) {
	return t.actor.InsertRelay(url, cfg)
}

// RemoveRelay removes a relay config from the underlying actor.
func (t *RelayTransport) RemoveRelay(url netaddr.RelayURL) (relay.Config, bool) {
	return t.actor.RemoveRelay(url)
}

// HomeRelayStatus returns a watcher over the home relay's connection status. See
// [RelayActor.HomeRelayStatus].
func (t *RelayTransport) HomeRelayStatus() watch.Observer[*RelayStatus] {
	return t.actor.HomeRelayStatus()
}

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.