package util import ( "context" "errors" "net" "os" "sync" "sync/atomic" "time" "github.com/seaweedfs/seaweedfs/weed/glog" "github.com/seaweedfs/seaweedfs/weed/stats" ) // Listener wraps a net.Listener, and gives a place to store the timeout // parameters. On Accept, it will wrap the net.Conn with our own Conn for us. type Listener struct { net.Listener Timeout time.Duration } func (l *Listener) Accept() (net.Conn, error) { c, err := l.Listener.Accept() if err != nil { return nil, err } stats.ConnectionOpen() tc := &Conn{ Conn: c, Timeout: l.Timeout, } return tc, nil } // Conn wraps a net.Conn and implements a "no activity timeout". // Any activity (read or write) resets the deadline, so the connection // only times out when there's no activity in either direction. // // Callers may also set deadlines directly — net/http's server does this // to interrupt a blocked read (abortPendingRead sets a deadline in the // past) and to enforce its own Read/Write timeouts. The activity // extension must never overwrite such an externally-set deadline, or the // interrupt is lost and the read stays blocked until the activity // timeout fires (wedging connection drain on shutdown for up to the full // idle timeout). mu serializes deadline updates, and while an external // deadline is in force on a direction the activity extension for that // direction is suspended; it resumes once the caller clears the deadline // (sets the zero time). type Conn struct { net.Conn Timeout time.Duration isClosed bool mu sync.Mutex externalReadDeadline bool externalWriteDeadline bool readEndedByServer atomic.Bool } func (c *Conn) SetDeadline(t time.Time) error { c.mu.Lock() defer c.mu.Unlock() c.externalReadDeadline = !t.IsZero() c.externalWriteDeadline = !t.IsZero() return c.Conn.SetDeadline(t) } func (c *Conn) SetReadDeadline(t time.Time) error { c.mu.Lock() defer c.mu.Unlock() c.externalReadDeadline = !t.IsZero() return c.Conn.SetReadDeadline(t) } func (c *Conn) SetWriteDeadline(t time.Time) error { c.mu.Lock() defer c.mu.Unlock() c.externalWriteDeadline = !t.IsZero() return c.Conn.SetWriteDeadline(t) } // extendDeadline extends the connection deadline from now. // This implements "no activity timeout" - any activity keeps the // connection alive in both directions (a long write-only response must // keep the read deadline alive too, or net/http's background read would // time out and cancel the in-flight request). Each direction is extended // independently: an externally-managed deadline on one side (e.g. a // server WriteTimeout) must not leave the other side's deadline stale. func (c *Conn) extendDeadline() error { c.mu.Lock() defer c.mu.Unlock() if c.Timeout <= 0 { return nil } if !c.externalReadDeadline && !c.externalWriteDeadline { return c.Conn.SetDeadline(time.Now().Add(c.Timeout)) } if !c.externalReadDeadline { if err := c.Conn.SetReadDeadline(time.Now().Add(c.Timeout)); err != nil { return err } } if !c.externalWriteDeadline { if err := c.Conn.SetWriteDeadline(time.Now().Add(c.Timeout)); err != nil { return err } } return nil } func (c *Conn) Read(b []byte) (count int, e error) { // Extend deadline before reading - any activity keeps connection alive if e = c.extendDeadline(); e == nil { if count, e = c.Conn.Read(b); e == nil { stats.BytesIn(int64(count)) } } c.readEndedByServer.Store(errors.Is(e, os.ErrDeadlineExceeded) || errors.Is(e, net.ErrClosed)) return } func (c *Conn) Write(b []byte) (count int, e error) { // Extend deadline before writing - any activity keeps connection alive if err := c.extendDeadline(); err != nil { return 0, err } count, e = c.Conn.Write(b) if e == nil { stats.BytesOut(int64(count)) } return } func (c *Conn) Close() error { err := c.Conn.Close() if err == nil { if !c.isClosed { stats.ConnectionClose() c.isClosed = true } } return err } type connContextKey struct{} // ConnContext is an http.Server.ConnContext hook that lets ClientGone see the // connection serving a request. func ConnContext(ctx context.Context, c net.Conn) context.Context { if tlsConn, ok := c.(interface{ NetConn() net.Conn }); ok { c = tlsConn.NetConn() } if tc, ok := c.(*Conn); ok { return context.WithValue(ctx, connContextKey{}, tc) } return ctx } // ClientGone reports whether the client is why the request context ctx is // canceled. net/http cancels it when a read of the connection fails or the // HTTP/2 stream is reset; a read the server ended itself, by the idle timeout // or by closing the connection, is not the client's doing. func ClientGone(ctx context.Context) bool { tc, _ := ctx.Value(connContextKey{}).(*Conn) return tc != nil && ctx.Err() == context.Canceled && !tc.readEndedByServer.Load() } func NewListener(addr string, timeout time.Duration) (ipListener net.Listener, err error) { listener, err := net.Listen("tcp", addr) if err != nil { return } ipListener = &Listener{ Listener: listener, Timeout: timeout, } return } // IsLoopbackOrWildcardAddress reports whether host already covers loopback // traffic — empty (all interfaces), a wildcard address, or a loopback address — // in which case a separate localhost listener is unnecessary. func IsLoopbackOrWildcardAddress(host string) bool { switch host { case "", "localhost", "0.0.0.0", "127.0.0.1", "[::]", "[::1]": return true } return false } // NewIpAndLocalListeners binds host:port and, unless listenOnLocalhost is given // as false, a second listener on localhost:port so that local clients still // reach the service when it binds a specific address. Callers pass false when // the user explicitly chose the bind address (e.g. -ip.bind), honoring exactly // that address. func NewIpAndLocalListeners(host string, port int, timeout time.Duration, listenOnLocalhost ...bool) (ipListener net.Listener, localListener net.Listener, err error) { listener, err := net.Listen("tcp", JoinHostPort(host, port)) if err != nil { return } ipListener = &Listener{ Listener: listener, Timeout: timeout, } if (len(listenOnLocalhost) == 0 || listenOnLocalhost[0]) && !IsLoopbackOrWildcardAddress(host) { listener, err = net.Listen("tcp", JoinHostPort("localhost", port)) if err != nil { glog.V(0).Infof("skip starting localhost listener on :%d: %v", port, err) return ipListener, nil, nil } localListener = &Listener{ Listener: listener, Timeout: timeout, } } return }