timamsk/sing-box
1
0
Fork 0
mirror of https://github.com/SagerNet/sing-box.git synced 2026-04-13 20:28:32 +10:00
Code Issues Packages Projects Releases Wiki Activity

Remove hello_world cloudflare service

Browse Source
This commit is contained in:
世界
2026-03-24 21:45:14 +08:00
parent 1320b737b9
commit 7ca692d8c2
5 changed files with 4 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
protocol/cloudflare/dispatch.go
View File

@@ -150,14 +150,6 @@ func (i *Inbound) resolveHTTPService(requestURL string) (ResolvedService, string
if !loaded {
return ResolvedService{}, "", E.New("no ingress rule matched request host/path")
}
if service.Kind == ResolvedServiceHelloWorld {
helloURL, err := i.ensureHelloWorldURL()
if err != nil {
return ResolvedService{}, "", err
}
service.BaseURL = helloURL
service.OriginRequest.NoTLSVerify = true
}
originURL, err := service.BuildRequestURL(requestURL)
if err != nil {
return ResolvedService{}, "", E.Cause(err, "build origin request URL")
@@ -266,7 +258,7 @@ func (i *Inbound) handleHTTPService(ctx context.Context, stream io.ReadWriteClos
return
}
i.handleStreamService(ctx, stream, respWriter, request, metadata, service)
case ResolvedServiceUnix, ResolvedServiceUnixTLS, ResolvedServiceHelloWorld:
case ResolvedServiceUnix, ResolvedServiceUnixTLS:
if request.Type == ConnectionTypeHTTP {
i.handleDirectHTTPStream(ctx, stream, respWriter, request, metadata, service)
} else {
@@ -439,11 +431,6 @@ func (i *Inbound) newDirectOriginTransport(service ResolvedService, requestHost
transport.DialContext = func(ctx context.Context, _, _ string) (net.Conn, error) {
return dialer.DialContext(ctx, "unix", service.UnixPath)
}
case ResolvedServiceHelloWorld:
target := service.BaseURL.Host
transport.DialContext = func(ctx context.Context, _, _ string) (net.Conn, error) {
return dialer.DialContext(ctx, "tcp", target)
}
default:
return nil, nil, E.New("unsupported direct origin service")
}

49
protocol/cloudflare/inbound.go
View File

@@ -4,21 +4,16 @@ package cloudflare
import (
"context"
stdTLS "crypto/tls"
"encoding/base64"
"errors"
"io"
"math/rand"
"net"
"net/http"
"net/url"
"sync"
"time"
"github.com/sagernet/sing-box/adapter"
"github.com/sagernet/sing-box/adapter/inbound"
boxDialer "github.com/sagernet/sing-box/common/dialer"
boxTLS "github.com/sagernet/sing-box/common/tls"
C "github.com/sagernet/sing-box/constant"
"github.com/sagernet/sing-box/log"
"github.com/sagernet/sing-box/option"
@@ -63,10 +58,6 @@ type Inbound struct {
datagramV3Muxers map[DatagramSender]*DatagramV3Muxer
datagramV3Manager *DatagramV3SessionManager
helloWorldAccess sync.Mutex
helloWorldServer *http.Server
helloWorldURL *url.URL
connectedAccess sync.Mutex
connectedIndices map[uint8]struct{}
connectedNotify chan uint8
@@ -231,49 +222,9 @@ func (i *Inbound) Close() error {
}
i.connections = nil
i.connectionAccess.Unlock()
if i.helloWorldServer != nil {
i.helloWorldServer.Close()
}
return nil
}
func (i *Inbound) ensureHelloWorldURL() (*url.URL, error) {
i.helloWorldAccess.Lock()
defer i.helloWorldAccess.Unlock()
if i.helloWorldURL != nil {
return i.helloWorldURL, nil
}
mux := http.NewServeMux()
mux.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
writer.WriteHeader(http.StatusOK)
_, _ = writer.Write([]byte("Hello World"))
})
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return nil, E.Cause(err, "listen hello world server")
}
certificate, err := boxTLS.GenerateKeyPair(nil, nil, time.Now, "localhost")
if err != nil {
_ = listener.Close()
return nil, E.Cause(err, "generate hello world certificate")
}
tlsListener := stdTLS.NewListener(listener, &stdTLS.Config{
Certificates: []stdTLS.Certificate{*certificate},
})
server := &http.Server{Handler: mux}
go server.Serve(tlsListener)
i.helloWorldServer = server
i.helloWorldURL = &url.URL{
Scheme: "https",
Host: listener.Addr().String(),
}
return i.helloWorldURL, nil
}
const (
backoffBaseTime = time.Second
backoffMaxTime = 2 * time.Minute

26
protocol/cloudflare/ingress_test.go
View File

@@ -162,29 +162,3 @@ func TestResolveHTTPServiceStatus(t *testing.T) {
t.Fatalf("status service should keep request URL, got %s", requestURL)
}
}
func TestResolveHTTPServiceHelloWorld(t *testing.T) {
inboundInstance := newTestIngressInbound(t)
inboundInstance.configManager.activeConfig = RuntimeConfig{
Ingress: []compiledIngressRule{
{Service: mustResolvedService(t, "hello_world")},
},
}
service, requestURL, err := inboundInstance.resolveHTTPService("https://hello.example.com/path")
if err != nil {
t.Fatal(err)
}
if service.Kind != ResolvedServiceHelloWorld {
t.Fatalf("expected hello world service, got %#v", service)
}
if service.BaseURL == nil || service.BaseURL.Scheme != "https" {
t.Fatalf("expected hello world base URL to be https, got %#v", service.BaseURL)
}
if !service.OriginRequest.NoTLSVerify {
t.Fatal("expected hello world to force no_tls_verify")
}
if requestURL == "" || requestURL[:8] != "https://" {
t.Fatalf("expected https request URL, got %s", requestURL)
}
}

7
protocol/cloudflare/origin_request_test.go
View File

@@ -58,11 +58,8 @@ func TestApplyHTTPTransportProxy(t *testing.T) {
func TestNewDirectOriginTransportNoHappyEyeballs(t *testing.T) {
inbound := &Inbound{}
transport, cleanup, err := inbound.newDirectOriginTransport(ResolvedService{
Kind: ResolvedServiceHelloWorld,
BaseURL: &url.URL{
Scheme: "http",
Host: "127.0.0.1:8080",
},
Kind: ResolvedServiceUnix,
UnixPath: "/tmp/test.sock",
OriginRequest: OriginRequestConfig{
NoHappyEyeballs: true,
},

21
protocol/cloudflare/runtime_config.go
View File

@@ -35,7 +35,6 @@ const (
ResolvedServiceHTTP ResolvedServiceKind = iota
ResolvedServiceStream
ResolvedServiceStatus
ResolvedServiceHelloWorld
ResolvedServiceUnix
ResolvedServiceUnixTLS
ResolvedServiceBastion
@@ -70,20 +69,6 @@ func (s ResolvedService) BuildRequestURL(requestURL string) (string, error) {
originURL.RawQuery = requestParsed.RawQuery
originURL.Fragment = requestParsed.Fragment
return originURL.String(), nil
case ResolvedServiceHelloWorld:
if s.BaseURL == nil {
return "", E.New("hello world service is unavailable")
}
requestParsed, err := url.Parse(requestURL)
if err != nil {
return "", err
}
originURL := *s.BaseURL
originURL.Path = requestParsed.Path
originURL.RawPath = requestParsed.RawPath
originURL.RawQuery = requestParsed.RawQuery
originURL.Fragment = requestParsed.Fragment
return originURL.String(), nil
default:
return requestURL, nil
}
@@ -413,11 +398,7 @@ func parseResolvedService(rawService string, originRequest OriginRequestConfig)
OriginRequest: originRequest,
}, nil
case rawService == "hello_world" || rawService == "hello-world":
return ResolvedService{
Kind: ResolvedServiceHelloWorld,
Service: rawService,
OriginRequest: originRequest,
}, nil
return ResolvedService{}, E.New("unsupported ingress service: hello_world")
case rawService == "bastion":
return ResolvedService{
Kind: ResolvedServiceBastion,