V13

2026-08-16 13:17:19 -03:00
parent c0a337be3f
commit 7b8e7bfbd0
82 changed files with 5479 additions and 1016 deletions
@@ -0,0 +1,791 @@
+package main
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"sort"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"dragontcp/internal/protocol"
+	"dragontcp/internal/wire"
+)
+
+type chunkClientOptions struct {
+	startSize      int
+	minSize        int
+	maxSize        int
+	adaptive       bool
+	adaptSuccesses int
+	adaptLog       bool
+	pollers        int
+	reconnectEvery int
+	pollDelay      time.Duration
+	txnTimeout     time.Duration
+	tcpBuffer      int
+}
+
+type adaptiveSizer struct {
+	mu             sync.Mutex
+	name           string
+	current        int
+	min            int
+	max            int
+	adaptive       bool
+	adaptSuccesses int
+	successes      int
+	good           int
+	bad            int
+	logChanges     bool
+}
+
+func newAdaptiveSizer(name string, start int, opts chunkClientOptions) *adaptiveSizer {
+	if start < opts.minSize {
+		start = opts.minSize
+	}
+	if start > opts.maxSize {
+		start = opts.maxSize
+	}
+	return &adaptiveSizer{
+		name:     name,
+		current:  start,
+		min:      opts.minSize,
+		max:      opts.maxSize,
+		adaptive: opts.adaptive,
+		adaptSuccesses: func() int {
+			if opts.adaptSuccesses > 0 {
+				return opts.adaptSuccesses
+			}
+			return 64
+		}(),
+		logChanges: opts.adaptLog,
+	}
+}
+
+func (s *adaptiveSizer) Current() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.current
+}
+
+func (s *adaptiveSizer) Success(attempted int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if !s.adaptive || attempted != s.current || s.current >= s.max {
+		return
+	}
+	if attempted > s.good {
+		s.good = attempted
+	}
+	s.successes++
+	growAfter := s.adaptSuccesses
+	if s.bad > 0 && s.bad-s.good <= 64 {
+		growAfter *= 8
+	}
+	if s.successes < growAfter {
+		return
+	}
+	s.successes = 0
+
+	old := s.current
+	next := 0
+	if s.bad > old+1 {
+		next = old + (s.bad-old)/2
+	} else {
+		if s.bad > 0 {
+			s.bad = 0
+		}
+		step := old / 4
+		if step < 32 {
+			step = 32
+		}
+		next = old + step
+	}
+	if next > s.max {
+		next = s.max
+	}
+	if next <= old {
+		return
+	}
+	s.current = next
+	if s.logChanges {
+		fmt.Printf("adaptive %s chunk: %d -> %d after stable success\n", s.name, old, next)
+	}
+}
+
+func (s *adaptiveSizer) Failure(attempted int) (int, int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	old := s.current
+	if !s.adaptive || attempted != s.current {
+		return old, old
+	}
+	s.successes = 0
+	if s.bad == 0 || attempted < s.bad {
+		s.bad = attempted
+	}
+	next := attempted / 2
+	if s.good > 0 && s.good < attempted {
+		next = s.good
+	} else {
+		s.good = 0
+	}
+	if next < s.min {
+		next = s.min
+	}
+	if next >= attempted && attempted > s.min {
+		next = attempted - 1
+	}
+	if next < s.min {
+		next = s.min
+	}
+	s.current = next
+	if s.logChanges && old != next {
+		fmt.Printf("adaptive %s chunk: %d -> %d after transport failure\n", s.name, old, next)
+	}
+	return old, next
+}
+
+type physicalConn struct {
+	conn     net.Conn
+	requests int
+}
+
+type requestLane struct {
+	mu             sync.Mutex
+	serverAddr     string
+	tcpBuffer      int
+	reconnectEvery int
+	timeout        time.Duration
+	pc             *physicalConn
+	closed         bool
+}
+
+func newRequestLane(serverAddr string, tcpBuffer, reconnectEvery int, timeout time.Duration) *requestLane {
+	return &requestLane{
+		serverAddr:     serverAddr,
+		tcpBuffer:      tcpBuffer,
+		reconnectEvery: reconnectEvery,
+		timeout:        timeout,
+	}
+}
+
+func (l *requestLane) discardLocked() {
+	if l.pc != nil {
+		_ = l.pc.conn.Close()
+		l.pc = nil
+	}
+}
+
+func (l *requestLane) closeAfterLocked() {
+	if l.pc != nil && l.reconnectEvery > 0 && l.pc.requests >= l.reconnectEvery {
+		l.discardLocked()
+	}
+}
+
+func (l *requestLane) ensureLocked() error {
+	if l.closed {
+		return net.ErrClosed
+	}
+	if l.pc != nil {
+		if l.reconnectEvery <= 0 || l.pc.requests < l.reconnectEvery {
+			return nil
+		}
+		l.discardLocked()
+	}
+	d := net.Dialer{Timeout: 10 * time.Second, KeepAlive: 30 * time.Second}
+	conn, err := d.Dial("tcp", l.serverAddr)
+	if err != nil {
+		return err
+	}
+	protocol.TuneTCP(conn)
+	protocol.TuneTCPBuffer(conn, l.tcpBuffer)
+	l.pc = &physicalConn{conn: conn}
+	return nil
+}
+
+func (l *requestLane) Close() {
+	l.mu.Lock()
+	l.closed = true
+	l.discardLocked()
+	l.mu.Unlock()
+}
+
+func (l *requestLane) single(mode byte, sid wire.SessionID, seq uint64, payload []byte) (byte, []byte, error) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if err := l.ensureLocked(); err != nil {
+		return 0, nil, err
+	}
+	timeout := l.timeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	_ = l.pc.conn.SetDeadline(time.Now().Add(timeout))
+	if err := wire.WriteRequest(l.pc.conn, mode, sid, seq, payload); err != nil {
+		l.discardLocked()
+		return 0, nil, err
+	}
+	status, body, err := wire.ReadResponse(l.pc.conn)
+	if err != nil {
+		l.discardLocked()
+		return 0, nil, err
+	}
+	l.pc.requests++
+	_ = l.pc.conn.SetDeadline(time.Time{})
+	l.closeAfterLocked()
+	if status != wire.StatusError && len(body) > 0 {
+		body = wire.DecodeMaskedResponse(status, body, sid, mode, seq)
+	}
+	return status, body, nil
+}
+
+// download sends one compact request and consumes up to count response records.
+// startOffset is also the response keystream sequence. Each DATA response advances
+// it by exactly the returned byte count.
+func (l *requestLane) download(sid wire.SessionID, startOffset, ackOffset uint64, maxChunk, count int) ([][]byte, byte, error) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if err := l.ensureLocked(); err != nil {
+		return nil, 0, err
+	}
+	timeout := l.timeout
+	if timeout <= 0 {
+		timeout = 5 * time.Second
+	}
+	_ = l.pc.conn.SetDeadline(time.Now().Add(timeout))
+
+	payload := make([]byte, 14)
+	binary.BigEndian.PutUint64(payload[0:8], ackOffset)
+	binary.BigEndian.PutUint32(payload[8:12], uint32(maxChunk))
+	binary.BigEndian.PutUint16(payload[12:14], uint16(count))
+	if err := wire.WriteRequest(l.pc.conn, wire.ModeDownload, sid, startOffset, payload); err != nil {
+		l.discardLocked()
+		return nil, 0, err
+	}
+
+	out := make([][]byte, 0, count)
+	offset := startOffset
+	lastStatus := wire.StatusOK
+	for i := 0; i < count; i++ {
+		status, body, err := wire.ReadResponse(l.pc.conn)
+		if err != nil {
+			l.discardLocked()
+			return out, lastStatus, err
+		}
+		lastStatus = status
+		switch status {
+		case wire.StatusData:
+			body = wire.DecodeMaskedResponse(status, body, sid, wire.ModeDownload, offset)
+			if len(body) == 0 {
+				l.discardLocked()
+				return out, status, fmt.Errorf("empty DATA response")
+			}
+			out = append(out, body)
+			offset += uint64(len(body))
+		case wire.StatusWait, wire.StatusEOF:
+			i = count // stop after this response
+		case wire.StatusError:
+			l.discardLocked()
+			return out, status, fmt.Errorf("%s", string(body))
+		default:
+			l.discardLocked()
+			return out, status, fmt.Errorf("unknown response status %d", status)
+		}
+		if status == wire.StatusWait || status == wire.StatusEOF {
+			break
+		}
+	}
+
+	l.pc.requests++
+	_ = l.pc.conn.SetDeadline(time.Time{})
+	l.closeAfterLocked()
+	return out, lastStatus, nil
+}
+
+type pathProfile struct {
+	upload     int
+	download   int
+	persistent bool
+	at         time.Time
+}
+
+var profileState struct {
+	sync.Mutex
+	key string
+	p   pathProfile
+}
+
+var probeSeq atomic.Uint64
+
+func randomSessionID() (wire.SessionID, error) {
+	var sid wire.SessionID
+	_, err := rand.Read(sid[:])
+	return sid, err
+}
+
+func probePattern(n int) []byte {
+	out := make([]byte, n)
+	for i := range out {
+		out[i] = byte((i*31 + 17) & 0xff)
+	}
+	return out
+}
+
+func makeProbePayload(kind byte, value, total int, token string) []byte {
+	base := 11 + len(token)
+	if total < base {
+		total = base
+	}
+	out := make([]byte, total)
+	copy(out[:4], wire.ProbeMagic[:])
+	out[4] = kind
+	binary.BigEndian.PutUint16(out[5:7], uint16(len(token)))
+	binary.BigEndian.PutUint32(out[7:11], uint32(value))
+	copy(out[11:11+len(token)], token)
+	for i := base; i < len(out); i++ {
+		out[i] = byte((i*31 + 17) & 0xff)
+	}
+	return out
+}
+
+func probeOne(serverAddr, token string, opts chunkClientOptions, kind byte, candidate int) bool {
+	sid, err := randomSessionID()
+	if err != nil {
+		return false
+	}
+	timeout := opts.txnTimeout
+	if timeout <= 0 || timeout > 2500*time.Millisecond {
+		timeout = 2500 * time.Millisecond
+	}
+	lane := newRequestLane(serverAddr, opts.tcpBuffer, 1, timeout)
+	defer lane.Close()
+	seq := probeSeq.Add(1)
+
+	total := 0
+	value := candidate
+	if kind == wire.ProbeUpload {
+		total = candidate
+	}
+	payload := makeProbePayload(kind, value, total, token)
+	status, body, err := lane.single(wire.ModeProbe, sid, seq, payload)
+	if err != nil {
+		return false
+	}
+	if kind == wire.ProbeUpload {
+		return status == wire.StatusOK
+	}
+	if kind == wire.ProbeDownload {
+		if status != wire.StatusData || len(body) != candidate {
+			return false
+		}
+		want := probePattern(candidate)
+		for i := range body {
+			if body[i] != want[i] {
+				return false
+			}
+		}
+		return true
+	}
+	return status == wire.StatusOK
+}
+
+func probePersistent(serverAddr, token string, opts chunkClientOptions) bool {
+	sid, err := randomSessionID()
+	if err != nil {
+		return false
+	}
+	timeout := opts.txnTimeout
+	if timeout <= 0 || timeout > 2500*time.Millisecond {
+		timeout = 2500 * time.Millisecond
+	}
+	lane := newRequestLane(serverAddr, opts.tcpBuffer, 0, timeout)
+	defer lane.Close()
+	for i := 0; i < 8; i++ {
+		seq := probeSeq.Add(1)
+		payload := makeProbePayload(wire.ProbeKeepalive, i, 32+len(token), token)
+		status, _, err := lane.single(wire.ModeProbe, sid, seq, payload)
+		if err != nil || status != wire.StatusOK {
+			return false
+		}
+	}
+	return true
+}
+
+func probeCandidates(minSize, maxSize int) []int {
+	base := []int{32, 64, 128, 256, 512, 1024, 1200, 1280, 1320, 1350, 1360, 1380, 1400, 1450, 1600, 2048, 3205, 4096, 8192, 16384, 32768, 65536, 98304, 131072, 262144, 524288, 786432, 1048576}
+	seen := map[int]bool{}
+	out := make([]int, 0, len(base)+2)
+	for _, n := range base {
+		if n >= minSize && n <= maxSize && !seen[n] {
+			out = append(out, n)
+			seen[n] = true
+		}
+	}
+	if !seen[minSize] {
+		out = append(out, minSize)
+	}
+	if !seen[maxSize] {
+		out = append(out, maxSize)
+	}
+	sort.Ints(out)
+	return out
+}
+
+func probeMaximum(serverAddr, token string, opts chunkClientOptions, kind byte) int {
+	candidates := probeCandidates(opts.minSize, opts.maxSize)
+	lo, hi := 0, len(candidates)-1
+	best := opts.minSize
+	for lo <= hi {
+		mid := lo + (hi-lo)/2
+		candidate := candidates[mid]
+		if probeOne(serverAddr, token, opts, kind, candidate) {
+			best = candidate
+			lo = mid + 1
+		} else {
+			hi = mid - 1
+		}
+	}
+	if best < opts.minSize {
+		best = opts.minSize
+	}
+	return best
+}
+
+func getPathProfile(serverAddr, token string, opts chunkClientOptions) pathProfile {
+	key := fmt.Sprintf("%s|%s|%d|%d", serverAddr, token, opts.minSize, opts.maxSize)
+	profileState.Lock()
+	if profileState.key == key && time.Since(profileState.p.at) < 30*time.Minute {
+		p := profileState.p
+		profileState.Unlock()
+		return p
+	}
+	profileState.Unlock()
+
+	fallbackUp := minInt(opts.maxSize, maxInt(opts.minSize, 32768))
+	fallbackDown := minInt(opts.maxSize, maxInt(opts.minSize, 1350))
+
+	upCh := make(chan int, 1)
+	downCh := make(chan int, 1)
+	go func() { upCh <- probeMaximum(serverAddr, token, opts, wire.ProbeUpload) }()
+	go func() { downCh <- probeMaximum(serverAddr, token, opts, wire.ProbeDownload) }()
+
+	p := pathProfile{upload: fallbackUp, download: fallbackDown, persistent: false, at: time.Now()}
+	select {
+	case p.upload = <-upCh:
+	case <-time.After(20 * time.Second):
+	}
+	select {
+	case p.download = <-downCh:
+	case <-time.After(20 * time.Second):
+	}
+	p.persistent = probePersistent(serverAddr, token, opts)
+
+	fmt.Printf("path probe: upload=%d download=%d persistent=%t\n", p.upload, p.download, p.persistent)
+
+	profileState.Lock()
+	profileState.key = key
+	profileState.p = p
+	profileState.Unlock()
+	return p
+}
+
+func encodeOpen(token, host string, port int) ([]byte, error) {
+	if len(token) > 65535 || len(host) > 65535 {
+		return nil, fmt.Errorf("token or hostname too long")
+	}
+	out := make([]byte, 6+len(token)+len(host))
+	binary.BigEndian.PutUint16(out[0:2], uint16(len(token)))
+	binary.BigEndian.PutUint16(out[2:4], uint16(len(host)))
+	binary.BigEndian.PutUint16(out[4:6], uint16(port))
+	copy(out[6:6+len(token)], token)
+	copy(out[6+len(token):], host)
+	return out, nil
+}
+
+type chunkConn struct {
+	sid          wire.SessionID
+	opts         chunkClientOptions
+	uploadLane   *requestLane
+	downloadLane *requestLane
+	serverMax    int
+	upSizer      *adaptiveSizer
+	downSizer    *adaptiveSizer
+
+	writeMu  sync.Mutex
+	upOffset uint64
+
+	readMu         sync.Mutex
+	readBuf        []byte
+	downloadOffset uint64
+	consumedOffset uint64
+	eof            bool
+	pipeline       int
+	maxPipeline    int
+
+	closeOnce sync.Once
+}
+
+func openChunkTunnel(serverAddr, token, targetHost string, targetPort int, opts chunkClientOptions) (net.Conn, error) {
+	if opts.minSize < 32 {
+		opts.minSize = 32
+	}
+	if opts.maxSize < opts.minSize {
+		opts.maxSize = opts.minSize
+	}
+	if opts.maxSize > 1024*1024 {
+		opts.maxSize = 1024 * 1024
+	}
+	if opts.txnTimeout <= 0 {
+		opts.txnTimeout = 5 * time.Second
+	}
+	if opts.adaptSuccesses < 1 {
+		opts.adaptSuccesses = 64
+	}
+	if opts.reconnectEvery < 0 {
+		opts.reconnectEvery = 0
+	}
+
+	profile := getPathProfile(serverAddr, token, opts)
+	reconnect := opts.reconnectEvery
+	// Compatibility-friendly reconnect modes:
+	//   0 = persistent (CLI explicit)
+	//   1 = auto: persistent when the path probe succeeds, otherwise one request/connection
+	//   N>=2 = force connection rotation after N logical requests
+	if reconnect == 1 {
+		if profile.persistent {
+			reconnect = 0
+			fmt.Printf("path probe: reconnect mode auto -> persistent\n")
+		} else {
+			fmt.Printf("path probe: reconnect mode auto -> every request\n")
+		}
+	}
+
+	sid, err := randomSessionID()
+	if err != nil {
+		return nil, err
+	}
+	control := newRequestLane(serverAddr, opts.tcpBuffer, reconnect, opts.txnTimeout)
+	payload, err := encodeOpen(token, targetHost, targetPort)
+	if err != nil {
+		control.Close()
+		return nil, err
+	}
+	status, body, err := control.single(wire.ModeOpen, sid, 0, payload)
+	if err != nil {
+		control.Close()
+		return nil, err
+	}
+	if status == wire.StatusError {
+		control.Close()
+		return nil, fmt.Errorf("%s", string(body))
+	}
+	if status != wire.StatusOK || len(body) != 4 {
+		control.Close()
+		return nil, fmt.Errorf("bad OPEN response")
+	}
+	serverMax := int(binary.BigEndian.Uint32(body))
+	control.Close()
+	if serverMax < opts.minSize {
+		return nil, fmt.Errorf("server maximum chunk %d is below client minimum %d", serverMax, opts.minSize)
+	}
+	if opts.maxSize > serverMax {
+		opts.maxSize = serverMax
+	}
+	upStart := minInt(profile.upload, opts.maxSize)
+	downStart := minInt(profile.download, opts.maxSize)
+	if upStart < opts.minSize {
+		upStart = opts.minSize
+	}
+	if downStart < opts.minSize {
+		downStart = opts.minSize
+	}
+
+	c := &chunkConn{
+		sid:          sid,
+		opts:         opts,
+		serverMax:    serverMax,
+		uploadLane:   newRequestLane(serverAddr, opts.tcpBuffer, reconnect, opts.txnTimeout),
+		downloadLane: newRequestLane(serverAddr, opts.tcpBuffer, reconnect, opts.txnTimeout),
+		// BHTTP-style safe pipeline: request up to 256 records immediately.
+		// Hybrid v1 already supported 256 on the wire/server; starting at 32
+		// made tiny-path downloads spend many RTTs ramping up.
+		pipeline:    256,
+		maxPipeline: 256,
+	}
+	c.upSizer = newAdaptiveSizer("upload", upStart, opts)
+	c.downSizer = newAdaptiveSizer("download", downStart, opts)
+	return c, nil
+}
+
+func (c *chunkConn) fillReadBuffer() error {
+	if c.eof {
+		return io.EOF
+	}
+	minFailures := 0
+	for len(c.readBuf) == 0 && !c.eof {
+		chunk := c.downSizer.Current()
+		count := c.pipeline
+		if count < 1 {
+			count = 1
+		}
+		if count > c.maxPipeline {
+			count = c.maxPipeline
+		}
+		// Bound each batch to roughly 1 MiB of useful data.
+		if maxCount := (1024 * 1024) / maxInt(chunk, 1); maxCount < count {
+			count = maxInt(maxCount, 1)
+		}
+
+		data, status, err := c.downloadLane.download(c.sid, c.downloadOffset, c.consumedOffset, chunk, count)
+		for _, part := range data {
+			c.readBuf = append(c.readBuf, part...)
+			c.downloadOffset += uint64(len(part))
+		}
+		if len(data) > 0 {
+			c.downSizer.Success(chunk)
+			if c.pipeline < c.maxPipeline {
+				c.pipeline++
+			}
+			minFailures = 0
+		}
+		if err != nil {
+			if c.pipeline > 1 {
+				old := c.pipeline
+				c.pipeline /= 2
+				if c.pipeline < 1 {
+					c.pipeline = 1
+				}
+				if c.opts.adaptLog && old != c.pipeline {
+					fmt.Printf("adaptive download pipeline: %d -> %d after transport failure\n", old, c.pipeline)
+				}
+			} else {
+				old, next := c.downSizer.Failure(chunk)
+				if old == next && next == c.opts.minSize {
+					minFailures++
+					if minFailures >= 8 {
+						return fmt.Errorf("download failed at minimum chunk %d: %w", next, err)
+					}
+				}
+			}
+			time.Sleep(30 * time.Millisecond)
+			if len(c.readBuf) > 0 {
+				return nil
+			}
+			continue
+		}
+		switch status {
+		case wire.StatusEOF:
+			c.eof = true
+		case wire.StatusWait:
+			if c.opts.pollDelay > 0 {
+				time.Sleep(c.opts.pollDelay)
+			} else {
+				time.Sleep(5 * time.Millisecond)
+			}
+		}
+		if len(c.readBuf) > 0 {
+			return nil
+		}
+	}
+	if c.eof && len(c.readBuf) == 0 {
+		return io.EOF
+	}
+	return nil
+}
+
+func (c *chunkConn) Read(p []byte) (int, error) {
+	c.readMu.Lock()
+	defer c.readMu.Unlock()
+	if len(p) == 0 {
+		return 0, nil
+	}
+	if len(c.readBuf) == 0 {
+		if err := c.fillReadBuffer(); err != nil {
+			return 0, err
+		}
+	}
+	n := copy(p, c.readBuf)
+	c.readBuf = c.readBuf[n:]
+	c.consumedOffset += uint64(n)
+	return n, nil
+}
+
+func (c *chunkConn) Write(p []byte) (int, error) {
+	c.writeMu.Lock()
+	defer c.writeMu.Unlock()
+	if len(p) == 0 {
+		return 0, nil
+	}
+	total := 0
+	minFailures := 0
+	for len(p) > 0 {
+		size := c.upSizer.Current()
+		n := minInt(size, len(p))
+		status, body, err := c.uploadLane.single(wire.ModeUpload, c.sid, c.upOffset, p[:n])
+		if err != nil {
+			old, next := c.upSizer.Failure(size)
+			if old == next && next == c.opts.minSize {
+				minFailures++
+				if minFailures >= 8 {
+					return total, fmt.Errorf("upload failed at minimum chunk %d: %w", next, err)
+				}
+			} else {
+				minFailures = 0
+			}
+			time.Sleep(30 * time.Millisecond)
+			continue
+		}
+		if status == wire.StatusError {
+			return total, fmt.Errorf("%s", string(body))
+		}
+		if status != wire.StatusOK {
+			return total, fmt.Errorf("unexpected upload status %d", status)
+		}
+		c.upOffset += uint64(n)
+		total += n
+		p = p[n:]
+		c.upSizer.Success(size)
+		minFailures = 0
+	}
+	return total, nil
+}
+
+func (c *chunkConn) Close() error {
+	c.closeOnce.Do(func() {
+		lane := newRequestLane(c.uploadLane.serverAddr, c.opts.tcpBuffer, 1, c.opts.txnTimeout)
+		_, _, _ = lane.single(wire.ModeClose, c.sid, 0, nil)
+		lane.Close()
+		c.uploadLane.Close()
+		c.downloadLane.Close()
+	})
+	return nil
+}
+
+func (c *chunkConn) LocalAddr() net.Addr              { return dummyAddr("dragontcp-binary-local") }
+func (c *chunkConn) RemoteAddr() net.Addr             { return dummyAddr("dragontcp-binary-remote") }
+func (c *chunkConn) SetDeadline(time.Time) error      { return nil }
+func (c *chunkConn) SetReadDeadline(time.Time) error  { return nil }
+func (c *chunkConn) SetWriteDeadline(time.Time) error { return nil }
+
+type dummyAddr string
+
+func (d dummyAddr) Network() string { return "dragontcp-binary" }
+func (d dummyAddr) String() string  { return string(d) }
+
+func minInt(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+func maxInt(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
@@ -0,0 +1,31 @@
+package main
+
+import "testing"
+
+func TestAdaptiveSizerRecoversFromMinimum(t *testing.T) {
+	opts := chunkClientOptions{
+		startSize:      64,
+		minSize:        32,
+		maxSize:        1024,
+		adaptive:       true,
+		adaptSuccesses: 2,
+	}
+	s := newAdaptiveSizer("test", 64, opts)
+	_, next := s.Failure(64)
+	if next != 32 {
+		t.Fatalf("failure should reduce 64 -> 32, got %d", next)
+	}
+	for i := 0; i < 16; i++ {
+		s.Success(32)
+	}
+	if got := s.Current(); got <= 32 {
+		t.Fatalf("adaptive controller remained stuck at minimum: %d", got)
+	}
+}
+
+func TestReconnectZeroMeansPersistent(t *testing.T) {
+	lane := newRequestLane("127.0.0.1:1", 0, 0, 0)
+	if lane.reconnectEvery != 0 {
+		t.Fatalf("reconnectEvery=%d, want 0", lane.reconnectEvery)
+	}
+}
@@ -0,0 +1,482 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"net"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"dragontcp/internal/protocol"
+)
+
+const maxHeader = 128 * 1024
+
+var requestCounter atomic.Uint32
+
+func readHTTPHeaders(conn net.Conn) ([]byte, []byte, error) {
+	buf := make([]byte, 0, 8192)
+	tmp := make([]byte, 8192)
+
+	for {
+		n, err := conn.Read(tmp)
+		if n > 0 {
+			buf = append(buf, tmp[:n]...)
+
+			if len(buf) > maxHeader {
+				return nil, nil, fmt.Errorf("HTTP headers too large")
+			}
+
+			if i := bytes.Index(buf, []byte("\r\n\r\n")); i >= 0 {
+				end := i + 4
+				return buf[:end], buf[end:], nil
+			}
+		}
+
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+}
+
+func parseHostPort(authority string, defaultPort int) (string, int, error) {
+	authority = strings.TrimSpace(authority)
+
+	if host, portText, err := net.SplitHostPort(authority); err == nil {
+		port, err := strconv.Atoi(portText)
+		return host, port, err
+	}
+
+	// Host without port.
+	if strings.HasPrefix(authority, "[") && strings.HasSuffix(authority, "]") {
+		return strings.Trim(authority, "[]"), defaultPort, nil
+	}
+
+	if strings.Count(authority, ":") == 0 {
+		return authority, defaultPort, nil
+	}
+
+	// Bare IPv6.
+	if ip := net.ParseIP(authority); ip != nil {
+		return authority, defaultPort, nil
+	}
+
+	return "", 0, fmt.Errorf("invalid authority: %s", authority)
+}
+
+func rewritePlainHTTPRequest(header []byte) (string, int, []byte, error) {
+	text := string(header)
+	lines := strings.Split(text, "\r\n")
+	if len(lines) == 0 {
+		return "", 0, nil, fmt.Errorf("empty request")
+	}
+
+	parts := strings.SplitN(lines[0], " ", 3)
+	if len(parts) != 3 {
+		return "", 0, nil, fmt.Errorf("invalid request line")
+	}
+
+	method, target, version := parts[0], parts[1], parts[2]
+
+	var (
+		hostHeader string
+		headers    []string
+	)
+
+	for _, line := range lines[1:] {
+		if line == "" {
+			continue
+		}
+
+		k, v, ok := strings.Cut(line, ":")
+		if !ok {
+			continue
+		}
+
+		lk := strings.ToLower(strings.TrimSpace(k))
+
+		if lk == "host" {
+			hostHeader = strings.TrimSpace(v)
+		}
+
+		if lk == "connection" ||
+			lk == "proxy-connection" ||
+			lk == "proxy-authorization" {
+			continue
+		}
+
+		headers = append(headers, k+": "+strings.TrimSpace(v))
+	}
+
+	u, err := url.Parse(target)
+	if err != nil {
+		return "", 0, nil, err
+	}
+
+	var host string
+	var port int
+	path := target
+
+	if u.Hostname() != "" {
+		if strings.ToLower(u.Scheme) != "http" {
+			return "", 0, nil, fmt.Errorf("unsupported plain HTTP scheme: %s", u.Scheme)
+		}
+
+		host = u.Hostname()
+		port = 80
+
+		if u.Port() != "" {
+			port, err = strconv.Atoi(u.Port())
+			if err != nil {
+				return "", 0, nil, err
+			}
+		}
+
+		path = u.EscapedPath()
+		if path == "" {
+			path = "/"
+		}
+		if u.RawQuery != "" {
+			path += "?" + u.RawQuery
+		}
+	} else {
+		if hostHeader == "" {
+			return "", 0, nil, fmt.Errorf("missing Host header")
+		}
+
+		host, port, err = parseHostPort(hostHeader, 80)
+		if err != nil {
+			return "", 0, nil, err
+		}
+		if path == "" {
+			path = "/"
+		}
+	}
+
+	var out strings.Builder
+	fmt.Fprintf(&out, "%s %s %s\r\n", method, path, version)
+
+	sawHost := false
+	for _, h := range headers {
+		if strings.HasPrefix(strings.ToLower(h), "host:") {
+			sawHost = true
+		}
+		out.WriteString(h)
+		out.WriteString("\r\n")
+	}
+
+	if !sawHost {
+		if port == 80 {
+			fmt.Fprintf(&out, "Host: %s\r\n", host)
+		} else {
+			fmt.Fprintf(&out, "Host: %s\r\n", net.JoinHostPort(host, strconv.Itoa(port)))
+		}
+	}
+
+	out.WriteString("Connection: close\r\n\r\n")
+
+	return host, port, []byte(out.String()), nil
+}
+
+func openDragonTCPTunnel(serverAddr, token, targetHost string, targetPort int, transport string, tcpBuffer int) (net.Conn, error) {
+	d := net.Dialer{
+		Timeout:   10 * time.Second,
+		KeepAlive: 30 * time.Second,
+	}
+
+	conn, err := d.Dial("tcp", serverAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	protocol.TuneTCP(conn)
+	protocol.TuneTCPBuffer(conn, tcpBuffer)
+	_ = conn.SetDeadline(time.Now().Add(15 * time.Second))
+
+	// Correlation only; cryptographic randomness is unnecessary here.
+	requestID := requestCounter.Add(1)
+
+	var command []byte
+	if transport == "raw" {
+		command = []byte(fmt.Sprintf("TUNNEL2 %s %s %d RAW", token, targetHost, targetPort))
+	} else {
+		// Legacy XOR command remains compatible with the older server.
+		command = []byte(fmt.Sprintf("TUNNEL %s %s %d", token, targetHost, targetPort))
+	}
+
+	if err := protocol.WriteRequestFrame(conn, requestID, command); err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	responseID, response, err := protocol.ReadResponseFrame(conn)
+	if err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	if responseID != requestID {
+		conn.Close()
+		return nil, fmt.Errorf("request ID mismatch")
+	}
+
+	if string(response) != "CONNECTED" {
+		conn.Close()
+		return nil, fmt.Errorf("%s", response)
+	}
+
+	_ = conn.SetDeadline(time.Time{})
+	return conn, nil
+}
+
+func writeHTTPError(conn net.Conn, code int, reason, detail string) {
+	if detail == "" {
+		detail = reason
+	}
+
+	body := []byte(detail)
+
+	fmt.Fprintf(
+		conn,
+		"HTTP/1.1 %d %s\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: %d\r\nConnection: close\r\n\r\n",
+		code,
+		reason,
+		len(body),
+	)
+	_, _ = conn.Write(body)
+}
+
+func handleLocal(conn net.Conn, serverAddr, token, transport string, tcpBuffer int, chunkOpts chunkClientOptions, slots chan struct{}) {
+	defer func() {
+		<-slots
+		_ = conn.Close()
+	}()
+
+	protocol.TuneTCP(conn)
+	protocol.TuneTCPBuffer(conn, tcpBuffer)
+	_ = conn.SetDeadline(time.Now().Add(15 * time.Second))
+
+	header, extra, err := readHTTPHeaders(conn)
+	if err != nil {
+		return
+	}
+
+	firstLine := strings.SplitN(string(header), "\r\n", 2)[0]
+	parts := strings.SplitN(firstLine, " ", 3)
+
+	if len(parts) != 3 {
+		writeHTTPError(conn, 400, "Bad Request", "invalid HTTP request line")
+		return
+	}
+
+	method, target := parts[0], parts[1]
+
+	if strings.EqualFold(method, "CONNECT") {
+		host, port, err := parseHostPort(target, 443)
+		if err != nil {
+			writeHTTPError(conn, 400, "Bad Request", err.Error())
+			return
+		}
+
+		var remote net.Conn
+		if transport == "chunk" {
+			remote, err = openChunkTunnel(serverAddr, token, host, port, chunkOpts)
+		} else {
+			remote, err = openDragonTCPTunnel(serverAddr, token, host, port, transport, tcpBuffer)
+		}
+		if err != nil {
+			writeHTTPError(conn, 502, "Bad Gateway", err.Error())
+			return
+		}
+		defer remote.Close()
+
+		_, _ = conn.Write([]byte(
+			"HTTP/1.1 200 Connection Established\r\n" +
+				"Proxy-Agent: dragontcp-proxy/2.0\r\n\r\n",
+		))
+
+		if len(extra) > 0 {
+			if transport == "xor" {
+				protocol.XorInPlace(extra)
+			}
+			if _, err := remote.Write(extra); err != nil {
+				return
+			}
+		}
+
+		_ = conn.SetDeadline(time.Time{})
+		if transport == "xor" {
+			protocol.RelayXOR(conn, remote)
+		} else {
+			// raw and chunk connections expose a normal plaintext net.Conn.
+			protocol.RelayRaw(conn, remote)
+		}
+		return
+	}
+
+	host, port, rewritten, err := rewritePlainHTTPRequest(header)
+	if err != nil {
+		writeHTTPError(conn, 400, "Bad Request", err.Error())
+		return
+	}
+
+	var remote net.Conn
+	if transport == "chunk" {
+		remote, err = openChunkTunnel(serverAddr, token, host, port, chunkOpts)
+	} else {
+		remote, err = openDragonTCPTunnel(serverAddr, token, host, port, transport, tcpBuffer)
+	}
+	if err != nil {
+		writeHTTPError(conn, 502, "Bad Gateway", err.Error())
+		return
+	}
+	defer remote.Close()
+
+	initial := make([]byte, 0, len(rewritten)+len(extra))
+	initial = append(initial, rewritten...)
+	initial = append(initial, extra...)
+	if transport == "xor" {
+		protocol.XorInPlace(initial)
+	}
+
+	if _, err := remote.Write(initial); err != nil {
+		return
+	}
+
+	_ = conn.SetDeadline(time.Time{})
+	if transport == "xor" {
+		protocol.RelayXOR(conn, remote)
+	} else {
+		protocol.RelayRaw(conn, remote)
+	}
+}
+
+func main() {
+	var (
+		listenHost      = flag.String("listen-host", "127.0.0.1", "local proxy listen host")
+		listenPort      = flag.Int("listen-port", 8080, "local proxy listen port")
+		serverHost      = flag.String("server-host", "", "remote DragonTCP server host")
+		serverPort      = flag.Int("server-port", 53, "remote DragonTCP server port")
+		token           = flag.String("token", "", "optional shared token")
+		maxConnections  = flag.Int("max-connections", 20000, "max simultaneous proxy connections")
+		transport       = flag.String("transport", "chunk", "transport: chunk (DragonTCP binary adaptive transport)")
+		tcpBuffer       = flag.Int("tcp-buffer", 0, "optional TCP read/write buffer bytes; 0 keeps OS autotuning")
+		chunkStart      = flag.Int("chunk-start", 1048576, "initial adaptive chunk payload bytes")
+		chunkMin        = flag.Int("chunk-min", 32, "minimum adaptive chunk payload bytes")
+		chunkMax        = flag.Int("chunk-max", 1048576, "maximum adaptive chunk payload bytes (up to 1 MiB)")
+		chunkAdaptive   = flag.Bool("chunk-adaptive", true, "automatically shrink on failures and grow after stable success")
+		chunkSuccesses  = flag.Int("chunk-grow-after", 16, "successful data records required before increasing chunk size")
+		chunkAdaptLog   = flag.Bool("chunk-adapt-log", true, "print adaptive chunk size changes")
+		chunkSizeLegacy = flag.Int("chunk-size", 0, "legacy fixed chunk size; nonzero disables adaptation")
+		chunkPollers    = flag.Int("chunk-pollers", 1, "reserved compatibility setting; binary transport uses one download worker")
+		chunkReconnect  = flag.Int("chunk-reconnect-every", 0, "force reconnect after N logical requests; 0 = persistent/automatic")
+		chunkPollDelay  = flag.Duration("chunk-poll-delay", 2*time.Millisecond, "delay after an empty chunk poll")
+		chunkTimeout    = flag.Duration("chunk-timeout", 2*time.Second, "per-record transaction timeout before adaptive shrink")
+	)
+	flag.Parse()
+
+	if *serverHost == "" {
+		fmt.Fprintln(os.Stderr, "--server-host is required")
+		os.Exit(2)
+	}
+
+	*transport = strings.ToLower(*transport)
+	if *transport != "chunk" {
+		fmt.Fprintln(os.Stderr, "DragonTCP requires --transport chunk (binary adaptive TCP/53 transport)")
+		os.Exit(2)
+	}
+	if *chunkSizeLegacy != 0 {
+		if *chunkSizeLegacy < 32 || *chunkSizeLegacy > protocol.MaxChunkPayload {
+			fmt.Fprintf(os.Stderr, "--chunk-size must be between 32 and %d\n", protocol.MaxChunkPayload)
+			os.Exit(2)
+		}
+		*chunkStart = *chunkSizeLegacy
+		*chunkMin = *chunkSizeLegacy
+		*chunkMax = *chunkSizeLegacy
+		*chunkAdaptive = false
+	}
+	if *chunkMin < 32 || *chunkMax > protocol.MaxChunkPayload || *chunkMin > *chunkStart || *chunkStart > *chunkMax {
+		fmt.Fprintf(os.Stderr, "require 32 <= --chunk-min <= --chunk-start <= --chunk-max <= %d\n", protocol.MaxChunkPayload)
+		os.Exit(2)
+	}
+	if *chunkSuccesses < 1 {
+		fmt.Fprintln(os.Stderr, "--chunk-grow-after must be at least 1")
+		os.Exit(2)
+	}
+	if *chunkPollers < 1 || *chunkPollers > 128 {
+		fmt.Fprintln(os.Stderr, "--chunk-pollers must be between 1 and 128")
+		os.Exit(2)
+	}
+	if *chunkReconnect < 0 {
+		fmt.Fprintln(os.Stderr, "--chunk-reconnect-every must be 0 or greater")
+		os.Exit(2)
+	}
+	chunkOpts := chunkClientOptions{
+		startSize:      *chunkStart,
+		minSize:        *chunkMin,
+		maxSize:        *chunkMax,
+		adaptive:       *chunkAdaptive,
+		adaptSuccesses: *chunkSuccesses,
+		adaptLog:       *chunkAdaptLog,
+		pollers:        *chunkPollers,
+		reconnectEvery: *chunkReconnect,
+		pollDelay:      *chunkPollDelay,
+		txnTimeout:     *chunkTimeout,
+		tcpBuffer:      *tcpBuffer,
+	}
+
+	listenAddr := net.JoinHostPort(*listenHost, strconv.Itoa(*listenPort))
+	serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
+
+	ln, err := net.Listen("tcp", listenAddr)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	defer ln.Close()
+
+	fmt.Printf("local Go HTTP proxy listening on %s\n", listenAddr)
+	fmt.Printf("remote DragonTCP endpoint=%s\n", serverAddr)
+	fmt.Printf("max_connections=%d transport=%s tcp_buffer=%d\n", *maxConnections, *transport, *tcpBuffer)
+	if *transport == "chunk" {
+		fmt.Printf(
+			"adaptive_chunk=%v start=%d min=%d max=%d grow_after=%d pollers=%d reconnect_every=%d timeout=%s\n",
+			*chunkAdaptive,
+			*chunkStart,
+			*chunkMin,
+			*chunkMax,
+			*chunkSuccesses,
+			*chunkPollers,
+			*chunkReconnect,
+			chunkTimeout.String(),
+		)
+	}
+
+	slots := make(chan struct{}, *maxConnections)
+
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			fmt.Fprintln(os.Stderr, "accept:", err)
+			continue
+		}
+
+		select {
+		case slots <- struct{}{}:
+			go handleLocal(conn, serverAddr, *token, *transport, *tcpBuffer, chunkOpts, slots)
+		default:
+			writeHTTPError(
+				conn,
+				503,
+				"Service Unavailable",
+				"proxy connection limit reached",
+			)
+			_ = conn.Close()
+		}
+	}
+}