set splice-timeout to 24 hours

common/signal/timer.go

@@ -15,9 +15,10 @@ type ActivityUpdater interface {
 
 type ActivityTimer struct {
 	sync.RWMutex
-	updated   chan struct{}
+	updated    chan struct{}
-	checkTask *task.Periodic
+	checkTask  *task.Periodic
-	onTimeout func()
+	onTimeout  func()
+	overridden bool
 }
 
 func (t *ActivityTimer) Update() {
@@ -31,14 +32,16 @@ func (t *ActivityTimer) check() error {
 	select {
 	case <-t.updated:
 	default:
-		t.finish()
+		t.finish(false)
 	}
 	return nil
 }
 
-func (t *ActivityTimer) finish() {
+func (t *ActivityTimer) finish(locked bool) {
-	t.Lock()
+	if !locked {
-	defer t.Unlock()
+		t.Lock()
+		defer t.Unlock()
+	}
 
 	if t.onTimeout != nil {
 		t.onTimeout()
@@ -50,9 +53,12 @@ func (t *ActivityTimer) finish() {
 	}
 }
 
-func (t *ActivityTimer) SetTimeout(timeout time.Duration) {
+func (t *ActivityTimer) setTimeout(timeout time.Duration) {
+	if t.onTimeout == nil {
+		return
+	}
 	if timeout == 0 {
-		t.finish()
+		t.finish(true)
 		return
 	}
 
@@ -61,14 +67,26 @@ func (t *ActivityTimer) SetTimeout(timeout time.Duration) {
 		Execute:  t.check,
 	}
 
-	t.Lock()
-
 	if t.checkTask != nil {
 		t.checkTask.Close()
+		t.overridden = true
 	}
 	t.checkTask = checkTask
 	t.Update()
 	common.Must(checkTask.Start())
+}
+
+func (t *ActivityTimer) SetTimeout(timeout time.Duration) {
+	t.Lock()
+	t.setTimeout(timeout)
+	t.Unlock()
+}
+
+func (t *ActivityTimer) SetTimeoutIfNotOverridden(timeout time.Duration) {
+	t.Lock()
+	if !t.overridden {
+		t.setTimeout(timeout)
+	}
 	t.Unlock()
 }
 

proxy/dns/dns.go

@@ -5,7 +5,6 @@ import (
 	go_errors "errors"
 	"io"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/xtls/xray-core/common"
@@ -370,10 +369,6 @@ type outboundConn struct {
 	access sync.Mutex
 	dialer func() (stat.Connection, error)
 
-	closeOnce sync.Once
-	dialOnce  sync.Once
-	closed    atomic.Bool
-
 	conn      net.Conn
 	connReady chan struct{}
 }
@@ -383,28 +378,24 @@ func (c *outboundConn) dial() error {
 	if err != nil {
 		return err
 	}
-	if c.closed.Load() {
-		return errors.New("connection closed during dial")
-	}
 	c.conn = conn
 	c.connReady <- struct{}{}
 	return nil
 }
 
 func (c *outboundConn) Write(b []byte) (int, error) {
-	c.dialOnce.Do(func() {
-		c.dial()
-	})
 	c.access.Lock()
-	conn := c.conn
+
-	c.access.Unlock()
+	if c.conn == nil {
-	if conn == nil {
+		if err := c.dial(); err != nil {
-		_, open := <-c.connReady
+			c.access.Unlock()
-		if !open {
+			errors.LogWarningInner(context.Background(), err, "failed to dial outbound connection")
-			return 0, io.EOF
+			return len(b), nil
 		}
-		conn = c.conn
 	}
+
+	c.access.Unlock()
+
 	return c.conn.Write(b)
 }
 
@@ -426,14 +417,11 @@ func (c *outboundConn) Read(b []byte) (int, error) {
 }
 
 func (c *outboundConn) Close() error {
-	c.closeOnce.Do(func() {
+	c.access.Lock()
-		c.access.Lock()
+	close(c.connReady)
-		c.closed.Store(true)
+	if c.conn != nil {
-		close(c.connReady)
+		c.conn.Close()
-		if c.conn != nil {
+	}
-			c.conn.Close()
+	c.access.Unlock()
-		}
-		c.access.Unlock()
-	})
 	return nil
 }

proxy/proxy.go

@@ -595,10 +595,10 @@ func CopyRawConnIfExist(ctx context.Context, readerConn net.Conn, writerConn net
 			errors.LogInfo(ctx, "CopyRawConn splice")
 			statWriter, _ := writer.(*dispatcher.SizeStatWriter)
 			//runtime.Gosched() // necessary
-			time.Sleep(time.Millisecond)    // without this, there will be a rare ssl error for freedom splice
+			time.Sleep(time.Millisecond)                    // without this, there will be a rare ssl error for freedom splice
-			timer.SetTimeout(8 * time.Hour) // prevent leak, just in case
+			timer.SetTimeoutIfNotOverridden(24 * time.Hour) // prevent leak, just in case
 			if inTimer != nil {
-				inTimer.SetTimeout(8 * time.Hour)
+				inTimer.SetTimeoutIfNotOverridden(24 * time.Hour)
 			}
 			w, err := tc.ReadFrom(readerConn)
 			if readCounter != nil {