Move Browser Dialer to sockopt.dialerProxy browser:// URL usage, with UUID path validation, startup-time conflict checks, instance-lifecycle listen/serve control, XHTTP mode constraints, and static initialization simplification

core/xray.go

@@ -18,6 +18,7 @@ import (
 	"github.com/xtls/xray-core/features/routing"
 	"github.com/xtls/xray-core/features/stats"
 	"github.com/xtls/xray-core/transport/internet"
+	"github.com/xtls/xray-core/transport/internet/browser_dialer"
 )
 
 // Server is an instance of Xray. At any time, there must be at most one Server instance running.
@@ -262,6 +263,9 @@ func (s *Instance) Close() error {
 	s.running = false
 
 	var errs []interface{}
+	if err := browser_dialer.StopCollectedDialerProxyURLs(); err != nil {
+		errs = append(errs, err)
+	}
 	for _, f := range s.features {
 		if err := f.Close(); err != nil {
 			errs = append(errs, err)
@@ -385,9 +389,16 @@ func (s *Instance) Start() error {
 	s.statusLock.Lock()
 	defer s.statusLock.Unlock()
 
+	if err := browser_dialer.StartCollectedDialerProxyURLs(); err != nil {
+		return err
+	}
 	s.running = true
 	for _, f := range s.features {
 		if err := f.Start(); err != nil {
+			s.running = false
+			if stopErr := browser_dialer.StopCollectedDialerProxyURLs(); stopErr != nil {
+				return errors.New("browser dialer cleanup after startup failure also failed: ", stopErr).Base(err)
+			}
 			return err
 		}
 	}

infra/conf/transport_internet.go

@@ -21,6 +21,7 @@ import (
 	"github.com/xtls/xray-core/common/platform/filesystem"
 	"github.com/xtls/xray-core/common/serial"
 	"github.com/xtls/xray-core/transport/internet"
+	"github.com/xtls/xray-core/transport/internet/browser_dialer"
 	"github.com/xtls/xray-core/transport/internet/finalmask/fragment"
 	"github.com/xtls/xray-core/transport/internet/finalmask/header/custom"
 	"github.com/xtls/xray-core/transport/internet/finalmask/header/dns"
@@ -1970,6 +1971,35 @@ func (c *StreamConfig) Build() (*internet.StreamConfig, error) {
 		}
 		config.ProtocolName = protocol
 	}
+	if c.SocketSettings != nil && c.SocketSettings.DialerProxy != "" {
+		if browser_dialer.IsBrowserDialerProxy(c.SocketSettings.DialerProxy) {
+			if config.ProtocolName != "websocket" && config.ProtocolName != "splithttp" {
+				return nil, errors.New("dialerProxy ", c.SocketSettings.DialerProxy, " only supports websocket or splithttp")
+			}
+			if strings.EqualFold(c.Security, "reality") {
+				return nil, errors.New("dialerProxy ", c.SocketSettings.DialerProxy, " does not support REALITY")
+			}
+			if config.ProtocolName == "splithttp" {
+				splitHTTPSettings := c.SplitHTTPSettings
+				if c.XHTTPSettings != nil {
+					splitHTTPSettings = c.XHTTPSettings
+				}
+				if splitHTTPSettings != nil {
+					splitHTTPSettingsCopy := *splitHTTPSettings
+					hs, err := splitHTTPSettingsCopy.Build()
+					if err != nil {
+						return nil, errors.New("failed to build XHTTP config for browser dialer validation").Base(err)
+					}
+					if splitHTTPConfig, ok := hs.(*splithttp.Config); ok && splitHTTPConfig.Mode != "auto" && splitHTTPConfig.Mode != "packet-up" {
+						return nil, errors.New("dialerProxy ", c.SocketSettings.DialerProxy, " only supports XHTTP modes \"auto\" or \"packet-up\", got: \"", splitHTTPConfig.Mode, "\"")
+					}
+				}
+			}
+			if err := browser_dialer.RegisterDialerProxyURL(c.SocketSettings.DialerProxy); err != nil {
+				return nil, errors.New("failed to collect browser dialer URL").Base(err)
+			}
+		}
+	}
 
 	switch strings.ToLower(c.Security) {
 	case "", "none":

infra/conf/xray.go

@@ -15,6 +15,7 @@ import (
 	"github.com/xtls/xray-core/common/serial"
 	core "github.com/xtls/xray-core/core"
 	"github.com/xtls/xray-core/transport/internet"
+	"github.com/xtls/xray-core/transport/internet/browser_dialer"
 )
 
 var (
@@ -437,7 +438,6 @@ func (c *Config) Override(o *Config, fn string) {
 	if o.Geodata != nil {
 		c.Geodata = o.Geodata
 	}
-
 	// update the Inbound in slice if the only one in override config has same tag
 	if len(o.InboundConfigs) > 0 {
 		for i := range o.InboundConfigs {
@@ -604,6 +604,9 @@ func (c *Config) Build() (*core.Config, error) {
 	if len(c.Transport) > 0 {
 		return nil, errors.PrintRemovedFeatureError("Global transport config", "streamSettings in inbounds and outbounds")
 	}
+	if err := browser_dialer.BeginCollectingDialerProxyURLs(); err != nil {
+		return nil, err
+	}
 
 	for _, rawInboundConfig := range inbounds {
 		ic, err := rawInboundConfig.Build()
@@ -626,6 +629,9 @@ func (c *Config) Build() (*core.Config, error) {
 		}
 		config.Outbound = append(config.Outbound, oc)
 	}
+	if err := browser_dialer.ConfigureCollectedDialerProxyURLs(); err != nil {
+		return nil, errors.New("failed to configure browser dialer").Base(err)
+	}
 
 	return config, nil
 }

transport/internet/browser_dialer/dialer.go

@@ -1,101 +1,33 @@
 package browser_dialer
 
 import (
-	"bytes"
-	"context"
 	_ "embed"
 	"encoding/base64"
 	"encoding/json"
 	"net/http"
-	"sync"
-	"time"
 
 	"github.com/gorilla/websocket"
 	"github.com/xtls/xray-core/common/errors"
-	"github.com/xtls/xray-core/common/platform"
-	"github.com/xtls/xray-core/common/uuid"
 )
 
 //go:embed dialer.html
 var webpage []byte
 
 type task struct {
-	Method string `json:"method"`
-	URL    string `json:"url"`
-	Extra  any    `json:"extra,omitempty"`
-	StreamResponse bool `json:"streamResponse"`
-}
-
-var conns chan *websocket.Conn
-var server *http.Server
-var mu sync.Mutex
-
-var upgrader = &websocket.Upgrader{
-	ReadBufferSize:   0,
-	WriteBufferSize:  0,
-	HandshakeTimeout: time.Second * 4,
-	CheckOrigin: func(r *http.Request) bool {
-		return true
-	},
-}
-
-// Used by external projects when using xray as a go module
-func Reload() {
-	addr := platform.NewEnvFlag(platform.BrowserDialerAddress).GetValue(func() string { return "" })
-	mu.Lock()
-	defer mu.Unlock()
-
-	if server != nil {
-		server.Close()
-	}
-	if HasBrowserDialer() {
-		for len(conns) > 0 {
-			select {
-				case c := <-conns:
-					c.Close()
-				default:
-			}
-		}
-		conns = nil
-	}
-	if addr != "" {
-		token := uuid.New()
-		csrfToken := token.String()
-		webpage := bytes.ReplaceAll(webpage, []byte("csrfToken"), []byte(csrfToken))
-		conns = make(chan *websocket.Conn, 256)
-		server = &http.Server{
-			Addr: addr,
-			Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				if r.URL.Path == "/websocket" {
-					if r.URL.Query().Get("token") == csrfToken {
-						if conn, err := upgrader.Upgrade(w, r, nil); err == nil {
-							conns <- conn
-						} else {
-							errors.LogError(context.Background(), "Browser dialer http upgrade unexpected error")
-						}
-					}
-				} else {
-					w.Header().Set("Access-Control-Allow-Origin", "*");
-					w.Write(webpage)
-				}
-			}),
-		}
-		go server.ListenAndServe()
-	}
-}
-
-func HasBrowserDialer() bool {
-	return conns != nil
+	Method         string `json:"method"`
+	URL            string `json:"url"`
+	Extra          any    `json:"extra,omitempty"`
+	StreamResponse bool   `json:"streamResponse"`
 }
 
 type webSocketExtra struct {
 	Protocol string `json:"protocol,omitempty"`
 }
 
-func DialWS(uri string, ed []byte) (*websocket.Conn, error) {
+func DialWSWithAddress(addr string, uri string, ed []byte) (*websocket.Conn, error) {
 	task := task{
-		Method: "WS",
-		URL:    uri,
+		Method:         "WS",
+		URL:            uri,
 		StreamResponse: true,
 	}
 
@@ -105,7 +37,7 @@ func DialWS(uri string, ed []byte) (*websocket.Conn, error) {
 		}
 	}
 
-	return dialTask(task)
+	return dialTaskWithAddress(addr, task)
 }
 
 type httpExtra struct {
@@ -142,30 +74,26 @@ func httpExtraFromHeadersAndCookies(headers http.Header, cookies []*http.Cookie)
 	return &extra
 }
 
-func DialGet(uri string, headers http.Header, cookies []*http.Cookie) (*websocket.Conn, error) {
+func DialGetWithAddress(addr string, uri string, headers http.Header, cookies []*http.Cookie) (*websocket.Conn, error) {
 	task := task{
-		Method: "GET",
-		URL:    uri,
-		Extra:  httpExtraFromHeadersAndCookies(headers, cookies),
+		Method:         "GET",
+		URL:            uri,
+		Extra:          httpExtraFromHeadersAndCookies(headers, cookies),
 		StreamResponse: true,
 	}
 
-	return dialTask(task)
+	return dialTaskWithAddress(addr, task)
 }
 
-func DialPacket(method string, uri string, headers http.Header, cookies []*http.Cookie, payload []byte) error {
-	return dialWithBody(method, uri, headers, cookies, payload)
-}
-
-func dialWithBody(method string, uri string, headers http.Header, cookies []*http.Cookie, payload []byte) error {
+func DialPacketWithAddress(addr string, method string, uri string, headers http.Header, cookies []*http.Cookie, payload []byte) error {
 	task := task{
-		Method: method,
-		URL:    uri,
-		Extra:  httpExtraFromHeadersAndCookies(headers, cookies),
+		Method:         method,
+		URL:            uri,
+		Extra:          httpExtraFromHeadersAndCookies(headers, cookies),
 		StreamResponse: false,
 	}
 
-	conn, err := dialTask(task)
+	conn, err := dialTaskWithAddress(addr, task)
 	if err != nil {
 		return err
 	}
@@ -184,12 +112,21 @@ func dialWithBody(method string, uri string, headers http.Header, cookies []*htt
 	return nil
 }
 
-func dialTask(task task) (*websocket.Conn, error) {
+func dialTaskWithAddress(addr string, task task) (*websocket.Conn, error) {
 	data, err := json.Marshal(task)
 	if err != nil {
 		return nil, err
 	}
 
+	if addr == "" {
+		return nil, errors.New("browser dialer is not configured; set sockopt.dialerProxy to browser://host:port/uuid")
+	}
+	dialer, err := getDialerByAddress(addr)
+	if err != nil {
+		return nil, err
+	}
+	conns := dialer.conns
+
 	var conn *websocket.Conn
 	for {
 		conn = <-conns
@@ -218,8 +155,3 @@ func CheckOK(conn *websocket.Conn) error {
 
 	return nil
 }
-
-func init() {
-	Reload()
-}
-

transport/internet/browser_dialer/dialer.html

@@ -10,7 +10,7 @@
 		// Enable a much more aggressive JIT for performance gains
 
 		// Copyright (c) 2021 XRAY. Mozilla Public License 2.0.
-		let url = "ws://" + window.location.host + "/websocket?token=csrfToken";
+		let url = "ws://" + window.location.host + "/dialerPath";
 		let clientIdleCount = 0;
 		let upstreamGetCount = 0;
 		let upstreamWsCount = 0;
@@ -67,7 +67,7 @@
 			}
 			clientIdleCount += 1;
 			console.log("Prepare", url);
-			let ws = new WebSocket(url);
+			let ws = new WebSocket(url, "browser-dialer");
 			// arraybuffer is significantly faster in chrome than default
 			// blob, tested with chrome 123
 			ws.binaryType = "arraybuffer";