| // Copyright 2023 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| //go:build solaris && !illumos | |
| package net | |
| import ( | |
| "internal/syscall/unix" | |
| "syscall" | |
| "testing" | |
| "time" | |
| ) | |
| func getCurrentKeepAliveSettings(fd fdType) (cfg KeepAliveConfig, err error) { | |
| tcpKeepAlive, err := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE) | |
| if err != nil { | |
| return | |
| } | |
| var ( | |
| tcpKeepAliveIdle int | |
| tcpKeepAliveInterval int | |
| tcpKeepAliveIdleTime time.Duration | |
| tcpKeepAliveIntervalTime time.Duration | |
| tcpKeepAliveCount int | |
| ) | |
| if unix.SupportTCPKeepAliveIdleIntvlCNT() { | |
| tcpKeepAliveIdle, err = syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall_TCP_KEEPIDLE) | |
| if err != nil { | |
| return | |
| } | |
| tcpKeepAliveIdleTime = time.Duration(tcpKeepAliveIdle) * time.Second | |
| tcpKeepAliveInterval, err = syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall_TCP_KEEPINTVL) | |
| if err != nil { | |
| return | |
| } | |
| tcpKeepAliveIntervalTime = time.Duration(tcpKeepAliveInterval) * time.Second | |
| tcpKeepAliveCount, err = syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall_TCP_KEEPCNT) | |
| if err != nil { | |
| return | |
| } | |
| } else { | |
| tcpKeepAliveIdle, err = syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPALIVE_THRESHOLD) | |
| if err != nil { | |
| return | |
| } | |
| tcpKeepAliveIdleTime = time.Duration(tcpKeepAliveIdle) * time.Millisecond | |
| // TCP_KEEPINTVL and TCP_KEEPCNT are not available on Solaris prior to 11.4, | |
| // so we have to use the value of TCP_KEEPALIVE_ABORT_THRESHOLD for Interval | |
| // and 1 for Count to keep this test going. | |
| tcpKeepAliveInterval, err = syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPALIVE_ABORT_THRESHOLD) | |
| if err != nil { | |
| return | |
| } | |
| tcpKeepAliveIntervalTime = time.Duration(tcpKeepAliveInterval) * time.Millisecond | |
| tcpKeepAliveCount = 1 | |
| } | |
| cfg = KeepAliveConfig{ | |
| Enable: tcpKeepAlive != 0, | |
| Idle: tcpKeepAliveIdleTime, | |
| Interval: tcpKeepAliveIntervalTime, | |
| Count: tcpKeepAliveCount, | |
| } | |
| return | |
| } | |
| func verifyKeepAliveSettings(t *testing.T, fd fdType, oldCfg, cfg KeepAliveConfig) { | |
| const defaultTcpKeepAliveAbortThreshold = 8 * time.Minute // default value on Solaris | |
| if cfg.Idle == 0 { | |
| cfg.Idle = defaultTCPKeepAliveIdle | |
| } | |
| if cfg.Interval == 0 { | |
| cfg.Interval = defaultTCPKeepAliveInterval | |
| } | |
| if cfg.Count == 0 { | |
| cfg.Count = defaultTCPKeepAliveCount | |
| } | |
| if cfg.Idle == -1 { | |
| cfg.Idle = oldCfg.Idle | |
| } | |
| tcpKeepAliveAbortThreshold := defaultTcpKeepAliveAbortThreshold | |
| if unix.SupportTCPKeepAliveIdleIntvlCNT() { | |
| // Check out the comment on KeepAliveConfig to understand the following logic. | |
| switch { | |
| case cfg.Interval == -1 && cfg.Count == -1: | |
| cfg.Interval = oldCfg.Interval | |
| cfg.Count = oldCfg.Count | |
| case cfg.Interval == -1 && cfg.Count > 0: | |
| cfg.Interval = defaultTcpKeepAliveAbortThreshold / time.Duration(cfg.Count) | |
| case cfg.Count == -1 && cfg.Interval > 0: | |
| cfg.Count = int(defaultTcpKeepAliveAbortThreshold / cfg.Interval) | |
| case cfg.Interval > 0 && cfg.Count > 0: | |
| // TCP_KEEPALIVE_ABORT_THRESHOLD will be recalculated only when both TCP_KEEPINTVL | |
| // and TCP_KEEPCNT are set, otherwise it will remain the default value. | |
| tcpKeepAliveAbortThreshold = cfg.Interval * time.Duration(cfg.Count) | |
| } | |
| } else { | |
| cfg.Interval = cfg.Interval * time.Duration(cfg.Count) | |
| // Either Interval or Count is set to a negative value, TCP_KEEPALIVE_ABORT_THRESHOLD | |
| // will remain the default value, so use the old Interval for the subsequent test. | |
| if cfg.Interval == -1 || cfg.Count == -1 { | |
| cfg.Interval = oldCfg.Interval | |
| } | |
| cfg.Count = 1 | |
| tcpKeepAliveAbortThreshold = cfg.Interval | |
| } | |
| tcpKeepAlive, err := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if (tcpKeepAlive != 0) != cfg.Enable { | |
| t.Fatalf("SO_KEEPALIVE: got %t; want %t", tcpKeepAlive != 0, cfg.Enable) | |
| } | |
| // TCP_KEEPALIVE_THRESHOLD and TCP_KEEPALIVE_ABORT_THRESHOLD are both available on Solaris 11.4 | |
| // and previous versions, so we can verify these two options regardless of the kernel version. | |
| tcpKeepAliveThreshold, err := syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPALIVE_THRESHOLD) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if time.Duration(tcpKeepAliveThreshold)*time.Millisecond != cfg.Idle { | |
| t.Fatalf("TCP_KEEPIDLE: got %dms; want %v", tcpKeepAliveThreshold, cfg.Idle) | |
| } | |
| tcpKeepAliveAbortInterval, err := syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall.TCP_KEEPALIVE_ABORT_THRESHOLD) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if time.Duration(tcpKeepAliveAbortInterval)*time.Millisecond != tcpKeepAliveAbortThreshold { | |
| t.Fatalf("TCP_KEEPALIVE_ABORT_THRESHOLD: got %dms; want %v", tcpKeepAliveAbortInterval, tcpKeepAliveAbortThreshold) | |
| } | |
| if unix.SupportTCPKeepAliveIdleIntvlCNT() { | |
| tcpKeepAliveIdle, err := syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall_TCP_KEEPIDLE) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if time.Duration(tcpKeepAliveIdle)*time.Second != cfg.Idle { | |
| t.Fatalf("TCP_KEEPIDLE: got %ds; want %v", tcpKeepAliveIdle, cfg.Idle) | |
| } | |
| tcpKeepAliveInterval, err := syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall_TCP_KEEPINTVL) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if time.Duration(tcpKeepAliveInterval)*time.Second != cfg.Interval { | |
| t.Fatalf("TCP_KEEPINTVL: got %ds; want %v", tcpKeepAliveInterval, cfg.Interval) | |
| } | |
| tcpKeepAliveCount, err := syscall.GetsockoptInt(fd, syscall.IPPROTO_TCP, syscall_TCP_KEEPCNT) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if tcpKeepAliveCount != cfg.Count { | |
| t.Fatalf("TCP_KEEPCNT: got %d; want %d", tcpKeepAliveCount, cfg.Count) | |
| } | |
| } else { | |
| if cfg.Count != 1 { | |
| t.Fatalf("TCP_KEEPCNT: got %d; want 1", cfg.Count) | |
| } | |
| } | |
| } |