Unified Share My Connection screen with globe, disclosure, Advanced section, and Unbounded mode

assets/locales/en.po

@@ -551,6 +551,12 @@ msgstr "Block Ads"
 msgid "only_active"
 msgstr "Only active when VPN is connected"
 
+msgid "share_my_connection"
+msgstr "Share My Connection"
+
+msgid "share_my_connection_subtitle"
+msgstr "Let other Lantern users route through your connection to bypass censorship."
+
 msgid "vpn_connected"
 msgstr "Lantern is now connected."
 

go.mod

@@ -2,7 +2,11 @@ module github.com/getlantern/lantern
 
 go 1.26.2
 
-// replace github.com/getlantern/radiance => ../radiance
+// Local while peer connection-stats endpoint is in flight; remove once
+// radiance tags a release that includes peer/connstats.go.
+replace github.com/getlantern/radiance => ../radiance
+
+replace github.com/getlantern/lantern-box => ../lantern-box
 
 // replace github.com/getlantern/lantern-server-provisioner => ../lantern-server-provisioner
 

lantern-core/core.go

@@ -18,9 +18,12 @@ import (
 	"github.com/getlantern/radiance/common"
 	"github.com/getlantern/radiance/common/env"
 	"github.com/getlantern/radiance/common/settings"
+	"github.com/getlantern/radiance/events"
 	"github.com/getlantern/radiance/ipc"
 	"github.com/getlantern/radiance/issue"
+	"github.com/getlantern/radiance/peer"
 	"github.com/getlantern/radiance/servers"
+	"github.com/getlantern/radiance/unbounded"
 	"github.com/getlantern/radiance/vpn"
 
 	"github.com/getlantern/lantern/lantern-core/apps"
@@ -36,7 +39,19 @@ const (
 	EventTypeServerLocation EventType = "server-location"
 	EventTypeConfig         EventType = "config"
 	EventTypeCountryCode    EventType = "country-code"
-	DefaultLogLevel                   = "trace"
+	// EventTypePeerConnection signals a samizdat peer accept/close on the
+	// local Share My Connection inbound. Message is JSON
+	// {"state": +1|-1, "source": "ip:port"}; consumers extract the IP for
+	// geo-lookup or rate-limit attribution.
+	EventTypePeerConnection EventType = "peer-connection"
+	// EventTypePeerStatus signals a peer.Client lifecycle phase change
+	// (mapping_port → registering → verifying → serving on the way up,
+	// stopping → idle on the way down, error on failure). Message is the
+	// JSON-marshalled peer.Status struct. The Dart side switches on
+	// .phase to render progress text and on .error to surface
+	// diagnostics on the failure path.
+	EventTypePeerStatus EventType = "peer-status"
+	DefaultLogLevel               = "trace"
 )
 
 // LanternCore wraps an IPC client and provides the interface expected by the FFI and mobile layers.
@@ -153,6 +168,23 @@ type SmartRouting interface {
 	IsSmartRoutingEnabled() bool
 }
 
+type PeerShare interface {
+	SetPeerShareEnabled(bool) error
+	IsPeerShareEnabled() bool
+	// SetPeerManualPort persists the user's manually-configured router
+	// port forward (Advanced setting in the Share My Connection UI).
+	// 0 clears the override, restoring UPnP-discovered port behavior.
+	SetPeerManualPort(port int) error
+	GetPeerManualPort() int
+	// SetUnboundedEnabled is the local opt-in for the broflake /
+	// Unbounded widget proxy ("Basic mode" in the SmC UI). The
+	// proxy actually runs only when this is true AND the server-side
+	// Features[unbounded] flag is on AND the server provides
+	// UnboundedConfig — see radiance/unbounded.shouldRunUnbounded.
+	SetUnboundedEnabled(bool) error
+	IsUnboundedEnabled() bool
+}
+
 type VPN interface {
 	ConnectVPN(tag string) error
 	SelectServer(tag string) error
@@ -169,6 +201,7 @@ type Core interface {
 	SplitTunnel
 	Ads
 	SmartRouting
+	PeerShare
 	VPN
 	Client() *ipc.Client
 }
@@ -240,6 +273,8 @@ func (lc *LanternCore) initialize(opts *utils.Opts, eventEmitter utils.FlutterEv
 	go lc.listenAutoSelectedEvents()
 	go lc.listenConfigEvents()
 	go lc.listenDataCapEvents()
+	go lc.listenPeerConnectionEvents()
+	go lc.listenPeerStatusEvents()
 	go lc.fetchUserDataIfNeeded()
 
 	slog.Debug("LanternCore initialized successfully")
@@ -354,6 +389,91 @@ func (lc *LanternCore) listenDataCapEvents() {
 	}
 }
 
+// listenPeerConnectionEvents forwards inbound accept/close events from
+// either of the two donor protocols (samizdat-over-UPnP "Share My
+// Connection" and broflake "Unbounded") to the Flutter side via the
+// existing FlutterEvent emitter, so the same globe widget can render
+// arcs without caring which protocol produced them. Subscription is
+// process-lifetime; events.Subscribe silently delivers nothing while
+// no peer / widget is active.
+//
+// The wire format unifies both protocols on a single event type
+// (EventTypePeerConnection) with a {state, source} payload. Unbounded
+// has a workerIdx in addition to source IP — surfaced as part of the
+// JSON in case the Dart side eventually wants to disambiguate same-IP
+// reconnects (broflake's WebRTC sessions are short and same-IP churn
+// is more common than for SmC's long-lived TCP).
+func (lc *LanternCore) listenPeerConnectionEvents() {
+	// peer.ConnectionEvent: subscribe via the IPC client's SSE stream.
+	// The events package's globals are process-scoped — events.Emit in
+	// lanternd (where radiance/peer runs) doesn't reach events.Subscribe
+	// in Liblantern. The /peer/connection/events SSE endpoint in
+	// radiance/ipc/server.go bridges the two processes.
+	go func() {
+		err := lc.client.PeerConnectionEvents(lc.ctx, func(evt peer.ConnectionEvent) {
+			jsonBytes, err := json.Marshal(map[string]any{
+				"state":  evt.State,
+				"source": evt.Source,
+			})
+			if err != nil {
+				slog.Error("marshal peer connection event", "error", err)
+				return
+			}
+			lc.notifyFlutter(EventTypePeerConnection, string(jsonBytes))
+		})
+		if err != nil && lc.ctx.Err() == nil {
+			slog.Error("peer-connection event stream exited unexpectedly", "error", err)
+		}
+	}()
+	// unbounded.ConnectionEvent stays on in-process events.Subscribe for
+	// now. Unbounded runs in the same process as the consumer in mobile
+	// builds (broflake-as-library); the desktop path doesn't yet have a
+	// gomobile-bridged Unbounded peer, so the cross-process gap doesn't
+	// hit here today. Worth revisiting if Unbounded ever moves out of
+	// process.
+	events.Subscribe(func(evt unbounded.ConnectionEvent) {
+		jsonBytes, err := json.Marshal(map[string]any{
+			"state":     evt.State,
+			"source":    evt.Addr,
+			"workerIdx": evt.WorkerIdx,
+		})
+		if err != nil {
+			slog.Error("marshal unbounded connection event", "error", err)
+			return
+		}
+		lc.notifyFlutter(EventTypePeerConnection, string(jsonBytes))
+	})
+}
+
+// listenPeerStatusEvents forwards peer.Client lifecycle phase changes to
+// the Flutter side. radiance's peer module emits one StatusEvent per
+// stage during Start (mapping_port → detecting_ip → registering →
+// starting_proxy → verifying → serving) and during Stop (stopping →
+// idle), plus an "error" terminal event with Status.Error populated on
+// failure. The Dart side renders each phase as user-facing progress
+// text instead of a single active/inactive flip.
+//
+// Message body is the JSON-marshalled peer.Status — the struct already
+// carries phase, error, active, sharing_since, external_ip,
+// external_port, route_id with stable JSON tags.
+func (lc *LanternCore) listenPeerStatusEvents() {
+	// Same cross-process bridging story as listenPeerConnectionEvents: the
+	// peer.StatusEvent emits live in lanternd, so subscribing in this
+	// process via events.Subscribe gets us nothing. /peer/status/events
+	// SSE in radiance/ipc/server.go is the canonical source.
+	err := lc.client.PeerStatusEvents(lc.ctx, func(evt peer.StatusEvent) {
+		jsonBytes, err := json.Marshal(evt.Status)
+		if err != nil {
+			slog.Error("marshal peer status event", "error", err)
+			return
+		}
+		lc.notifyFlutter(EventTypePeerStatus, string(jsonBytes))
+	})
+	if err != nil && lc.ctx.Err() == nil {
+		slog.Error("peer-status event stream exited unexpectedly", "error", err)
+	}
+}
+
 /////////////////
 //     VPN     //
 /////////////////
@@ -454,6 +574,47 @@ func (lc *LanternCore) IsSmartRoutingEnabled() bool {
 	return b
 }
 
+func (lc *LanternCore) SetPeerShareEnabled(enabled bool) error {
+	_, err := lc.client.PatchSettings(lc.ctx, settings.Settings{settings.PeerShareEnabledKey: enabled})
+	return err
+}
+
+func (lc *LanternCore) IsPeerShareEnabled() bool {
+	b, _ := lc.settings()[settings.PeerShareEnabledKey].(bool)
+	return b
+}
+
+func (lc *LanternCore) SetPeerManualPort(port int) error {
+	if port < 0 || port > 65535 {
+		return fmt.Errorf("port %d out of range (0-65535)", port)
+	}
+	_, err := lc.client.PatchSettings(lc.ctx, settings.Settings{settings.PeerManualPortKey: port})
+	return err
+}
+
+func (lc *LanternCore) GetPeerManualPort() int {
+	// koanf typically stores numeric settings as float64 after JSON
+	// round-trip; handle both float64 and int paths so loads from disk
+	// and freshly-set values both work.
+	switch v := lc.settings()[settings.PeerManualPortKey].(type) {
+	case int:
+		return v
+	case float64:
+		return int(v)
+	}
+	return 0
+}
+
+func (lc *LanternCore) SetUnboundedEnabled(enabled bool) error {
+	_, err := lc.client.PatchSettings(lc.ctx, settings.Settings{settings.UnboundedKey: enabled})
+	return err
+}
+
+func (lc *LanternCore) IsUnboundedEnabled() bool {
+	b, _ := lc.settings()[settings.UnboundedKey].(bool)
+	return b
+}
+
 func (lc *LanternCore) IsTelemetryEnabled() bool {
 	b, _ := lc.settings()[settings.TelemetryKey].(bool)
 	return b

lantern-core/ffi/ffi.go

@@ -1352,6 +1352,86 @@ func isSmartRoutingEnabled() C.int {
 	return 0
 }
 
+//export setPeerProxyEnabled
+func setPeerProxyEnabled(enabled C.int) *C.char {
+	return runOnGoStack(func() *C.char {
+		c, errStr := requireCore()
+		if errStr != nil {
+			return errStr
+		}
+		if err := c.SetPeerShareEnabled(enabled != 0); err != nil {
+			return SendError(err)
+		}
+		return C.CString("ok")
+	})
+}
+
+//export isPeerProxyEnabled
+func isPeerProxyEnabled() C.int {
+	c, _ := requireCore()
+	if c != nil && c.IsPeerShareEnabled() {
+		return 1
+	}
+	return 0
+}
+
+// setPeerManualPort persists the manually-configured router port-forward
+// for the Share My Connection peer-share feature. 0 clears the override,
+// reverting to UPnP discovery on the next peer.Client.Start.
+//
+//export setPeerManualPort
+func setPeerManualPort(port C.int) *C.char {
+	return runOnGoStack(func() *C.char {
+		c, errStr := requireCore()
+		if errStr != nil {
+			return errStr
+		}
+		if err := c.SetPeerManualPort(int(port)); err != nil {
+			return SendError(err)
+		}
+		return C.CString("ok")
+	})
+}
+
+//export getPeerManualPort
+func getPeerManualPort() C.int {
+	c, _ := requireCore()
+	if c == nil {
+		return 0
+	}
+	return C.int(c.GetPeerManualPort())
+}
+
+// setUnboundedEnabled is the local opt-in for the broflake / Unbounded
+// widget proxy ("Basic mode" in the SmC UI). The widget actually runs
+// only when this is true AND the server-side Features[unbounded] flag
+// is on AND the server provides UnboundedConfig — flipping this to
+// true on a network where the server hasn't enabled the feature is a
+// no-op until the next /config response opts the user in.
+//
+//export setUnboundedEnabled
+func setUnboundedEnabled(enabled C.int) *C.char {
+	return runOnGoStack(func() *C.char {
+		c, errStr := requireCore()
+		if errStr != nil {
+			return errStr
+		}
+		if err := c.SetUnboundedEnabled(enabled != 0); err != nil {
+			return SendError(err)
+		}
+		return C.CString("ok")
+	})
+}
+
+//export isUnboundedEnabled
+func isUnboundedEnabled() C.int {
+	c, _ := requireCore()
+	if c != nil && c.IsUnboundedEnabled() {
+		return 1
+	}
+	return 0
+}
+
 //export getSplitTunnelState
 func getSplitTunnelState() *C.char {
 	return runOnGoStack(func() *C.char {