refactor: use browserDialers URL array and dialerProxy URL matching

Agent-Logs-Url: https://github.com/XTLS/Xray-core/sessions/6ed9ad08-e0b0-43d4-878b-7fe355be5325

Co-authored-by: RPRX <63339210+RPRX@users.noreply.github.com>

infra/conf/transport_internet.go

@@ -1972,12 +1972,12 @@ func (c *StreamConfig) Build() (*internet.StreamConfig, error) {
 		config.ProtocolName = protocol
 	}
 	if c.SocketSettings != nil && c.SocketSettings.DialerProxy != "" {
-		if _, ok := browser_dialer.GetAddressByTag(c.SocketSettings.DialerProxy); ok {
+		if browser_dialer.HasConfiguredURL(c.SocketSettings.DialerProxy) {
 			if config.ProtocolName != "websocket" && config.ProtocolName != "splithttp" {
-				return nil, errors.New("dialerProxy tag ", c.SocketSettings.DialerProxy, " maps to browserDialers and only supports websocket or splithttp")
+				return nil, errors.New("dialerProxy url ", c.SocketSettings.DialerProxy, " is in browserDialers and only supports websocket or splithttp")
 			}
 			if strings.EqualFold(c.Security, "reality") {
-				return nil, errors.New("dialerProxy tag ", c.SocketSettings.DialerProxy, " maps to browserDialers and does not support REALITY")
+				return nil, errors.New("dialerProxy url ", c.SocketSettings.DialerProxy, " is in browserDialers and does not support REALITY")
 			}
 			if config.ProtocolName == "splithttp" {
 				splitHTTPSettings := c.SplitHTTPSettings
@@ -1991,7 +1991,7 @@ func (c *StreamConfig) Build() (*internet.StreamConfig, error) {
 						return nil, errors.New("failed to build XHTTP config for browserDialers validation.").Base(err)
 					}
 					if splitHTTPConfig, ok := hs.(*splithttp.Config); ok && splitHTTPConfig.Mode != "auto" && splitHTTPConfig.Mode != "packet-up" {
-						return nil, errors.New("dialerProxy tag ", c.SocketSettings.DialerProxy, " maps to browserDialers and only supports XHTTP modes \"auto\" or \"packet-up\", got: \"", splitHTTPConfig.Mode, "\"")
+						return nil, errors.New("dialerProxy url ", c.SocketSettings.DialerProxy, " is in browserDialers and only supports XHTTP modes \"auto\" or \"packet-up\", got: \"", splitHTTPConfig.Mode, "\"")
 					}
 				}
 			}

infra/conf/xray.go

@@ -363,12 +363,7 @@ type Config struct {
 	BurstObservatory *BurstObservatoryConfig `json:"burstObservatory"`
 	Version          *VersionConfig          `json:"version"`
 	Geodata          *GeodataConfig          `json:"geodata"`
-	BrowserDialers   []BrowserDialerConfig   `json:"browserDialers"`
-}
-
-type BrowserDialerConfig struct {
-	Tag string `json:"tag"`
-	URL string `json:"url"`
+	BrowserDialers   []string                `json:"browserDialers"`
 }
 
 func (c *Config) findInboundTag(tag string) int {
@@ -618,17 +613,7 @@ func (c *Config) Build() (*core.Config, error) {
 		return nil, err
 	}
 
-	browserDialerTags := make(map[string]string, len(c.BrowserDialers))
-	for _, browserDialer := range c.BrowserDialers {
-		if browserDialer.Tag == "" {
-			return nil, errors.New("browserDialers tag cannot be empty")
-		}
-		if _, found := browserDialerTags[browserDialer.Tag]; found {
-			return nil, errors.New("duplicate browserDialers tag: ", browserDialer.Tag)
-		}
-		browserDialerTags[browserDialer.Tag] = browserDialer.URL
-	}
-	if err := browser_dialer.ConfigureDialerTags(browserDialerTags); err != nil {
+	if err := browser_dialer.ConfigureDialers(c.BrowserDialers); err != nil {
 		return nil, errors.New("failed to configure browserDialers").Base(err)
 	}
 

transport/internet/browser_dialer/dialer.go

@@ -34,7 +34,7 @@ type task struct {
 
 var dialersByAddress = map[string]*dialerInstance{}
 var serversByListenAddr = map[string]*dialerServer{}
-var addressByTag atomic.Value
+var configuredURLs atomic.Value
 var initMu sync.Mutex
 var initialized bool
 
@@ -49,13 +49,13 @@ var upgrader = &websocket.Upgrader{
 	},
 }
 
-func GetAddressByTag(tag string) (string, bool) {
-	if tag == "" {
-		return "", false
+func HasConfiguredURL(url string) bool {
+	if url == "" {
+		return false
 	}
-	tags, _ := addressByTag.Load().(map[string]string)
-	addr, ok := tags[tag]
-	return addr, ok
+	urls, _ := configuredURLs.Load().(map[string]struct{})
+	_, ok := urls[url]
+	return ok
 }
 
 func CheckLegacyEnv() error {
@@ -66,7 +66,7 @@ func CheckLegacyEnv() error {
 	return errors.PrintRemovedFeatureError("env "+platform.BrowserDialerAddress, "root browserDialers + sockopt.dialerProxy")
 }
 
-func ConfigureDialerTags(tags map[string]string) error {
+func ConfigureDialers(urls []string) error {
 	initMu.Lock()
 	defer initMu.Unlock()
 
@@ -77,28 +77,25 @@ func ConfigureDialerTags(tags map[string]string) error {
 	if err := CheckLegacyEnv(); err != nil {
 		return err
 	}
-	next := make(map[string]string, len(tags))
-	listenAddrByPort := make(map[string]string, len(tags))
-	for tag, addr := range tags {
-		if tag == "" {
-			return errors.New("browserDialers tag cannot be empty")
+	next := make(map[string]struct{}, len(urls))
+	listenAddrByPort := make(map[string]string, len(urls))
+	for _, browserDialerURL := range urls {
+		if browserDialerURL == "" {
+			return errors.New("browserDialers url cannot be empty")
 		}
-		if addr == "" {
-			return errors.New("browserDialers url cannot be empty for tag: ", tag)
-		}
-		listenAddr, _, ok := parseBrowserDialerAddress(addr)
+		listenAddr, _, ok := parseBrowserDialerAddress(browserDialerURL)
 		if !ok {
-			return errors.New("invalid browserDialers entry for tag ", tag, ": ", addr)
+			return errors.New("invalid browserDialers url: ", browserDialerURL)
 		}
 		_, port, err := net.SplitHostPort(listenAddr)
 		if err != nil {
-			return errors.New("invalid browserDialers listen address for tag ", tag, ": ", listenAddr)
+			return errors.New("invalid browserDialers listen address: ", listenAddr)
 		}
 		if existingAddr, found := listenAddrByPort[port]; found && existingAddr != listenAddr {
 			return errors.New("browserDialers cannot use the same port with a different listen address: ", existingAddr, " and ", listenAddr)
 		}
 		listenAddrByPort[port] = listenAddr
-		next[tag] = addr
+		next[browserDialerURL] = struct{}{}
 	}
 	for existingAddr := range serversByListenAddr {
 		_, existingPort, splitErr := net.SplitHostPort(existingAddr)
@@ -109,9 +106,10 @@ func ConfigureDialerTags(tags map[string]string) error {
 			return errors.New("browserDialers cannot use the same port with a different listen address: ", existingAddr, " and ", newAddr)
 		}
 	}
-	for tag, addr := range next {
+	for browserDialerURL := range next {
+		addr := browserDialerURL
 		if err := EnsureDialerWithAddress(addr); err != nil {
-			return errors.New("failed to initialize browserDialers listener for tag ", tag).Base(err)
+			return errors.New("failed to initialize browserDialers listener for url ", browserDialerURL).Base(err)
 		}
 	}
 	for listenAddr, server := range serversByListenAddr {
@@ -119,7 +117,7 @@ func ConfigureDialerTags(tags map[string]string) error {
 			return errors.New("failed to start browserDialers listener on ", listenAddr).Base(err)
 		}
 	}
-	addressByTag.Store(next)
+	configuredURLs.Store(next)
 	initialized = true
 	return nil
 }
@@ -403,7 +401,7 @@ func dialTaskWithAddress(addr string, task task) (*websocket.Conn, error) {
 	}
 
 	if addr == "" {
-		return nil, errors.New("browser dialer is not configured; set root browserDialers and use sockopt.dialerProxy tag")
+		return nil, errors.New("browser dialer is not configured; set root browserDialers and use sockopt.dialerProxy url")
 	}
 	dialer, err := getDialerByAddress(addr)
 	if err != nil {

transport/internet/dialer.go

@@ -270,8 +270,8 @@ func DialSystem(ctx context.Context, dest net.Destination, sockopt *SocketConfig
 	}
 
 	if len(sockopt.DialerProxy) > 0 {
-		if _, ok := browser_dialer.GetAddressByTag(sockopt.DialerProxy); ok {
-			return nil, errors.New("dialerProxy tag ", sockopt.DialerProxy, " maps to browserDialers and only supports WebSocket or splithttp").AtError()
+		if browser_dialer.HasConfiguredURL(sockopt.DialerProxy) {
+			return nil, errors.New("dialerProxy url ", sockopt.DialerProxy, " is in browserDialers and only supports WebSocket or splithttp").AtError()
 		}
 		if obm == nil {
 			return nil, errors.New("there is no outbound manager for dialerProxy").AtError()

transport/internet/splithttp/dialer.go

@@ -63,8 +63,8 @@ func getHTTPClient(ctx context.Context, dest net.Destination, streamSettings *in
 	realityConfig := reality.ConfigFromStreamSettings(streamSettings)
 	browserDialer := ""
 	if streamSettings.SocketSettings != nil {
-		if taggedDialer, ok := browser_dialer.GetAddressByTag(streamSettings.SocketSettings.DialerProxy); ok {
-			browserDialer = taggedDialer
+		if browser_dialer.HasConfiguredURL(streamSettings.SocketSettings.DialerProxy) {
+			browserDialer = streamSettings.SocketSettings.DialerProxy
 		}
 	}
 

transport/internet/websocket/dialer.go

@@ -119,8 +119,8 @@ func dialWebSocket(ctx context.Context, dest net.Destination, streamSettings *in
 
 	browserDialer := ""
 	if streamSettings.SocketSettings != nil {
-		if taggedDialer, ok := browser_dialer.GetAddressByTag(streamSettings.SocketSettings.DialerProxy); ok {
-			browserDialer = taggedDialer
+		if browser_dialer.HasConfiguredURL(streamSettings.SocketSettings.DialerProxy) {
+			browserDialer = streamSettings.SocketSettings.DialerProxy
 		}
 	}
 	if browserDialer != "" {