Method ProcessRx

internal/session/session.go:465–491

ProcessRx enqueues f to the per-session rxLoop goroutine. The fast path is non-blocking. If rxInbox is saturated (slow SOCKS consumer or large burst), we wait up to rxInboxBlockTimeout to absorb the transient backpressure before declaring the session dead and killing it. Blocking briefly is far pref

(f *frame.Frame)

// stall — the original kill-on-overflow behavior caused mid-stream session
// drops under multi-user fan-out and brief GC pauses.
func (s *Session) ProcessRx(f *frame.Frame) {
	s.mu.Lock()
	if s.rxClosed {
		s.mu.Unlock()
		return
	}
	s.mu.Unlock()
	// Fast path: enqueue without blocking when there is room.
	select {
	case s.rxInbox <- f:
		return
	case <-s.rxDone:
		return
	default:
	}
	// Slow path: rxInbox is full. Block briefly so transient consumer pauses
	// (GC, syscall, page fault) don't tear down the session. Only kill on a
	// genuine deadlock that exceeds rxInboxBlockTimeout.
	t := time.NewTimer(rxInboxBlockTimeout)
	defer t.Stop()
	select {
	case s.rxInbox <- f:
	case <-s.rxDone:
	case <-t.C:
		s.Stop()
	}
}

// deliverRx performs in-order reassembly and delivers payloads to RxChan.
// Called exclusively by rxLoop. Returns true when a FIN frame is processed