| // Copyright 2009 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. | |
| package net | |
| import ( | |
| "internal/syscall/windows" | |
| "os" | |
| "runtime" | |
| "syscall" | |
| "time" | |
| "unsafe" | |
| ) | |
| // Default values of KeepAliveTime and KeepAliveInterval on Windows, | |
| // check out https://learn.microsoft.com/en-us/windows/win32/winsock/sio-keepalive-vals#remarks for details. | |
| const ( | |
| defaultKeepAliveIdle = 2 * time.Hour | |
| defaultKeepAliveInterval = time.Second | |
| ) | |
| func setKeepAliveIdle(fd *netFD, d time.Duration) error { | |
| if !windows.SupportTCPKeepAliveIdle() { | |
| return setKeepAliveIdleAndInterval(fd, d, -1) | |
| } | |
| if d == 0 { | |
| d = defaultTCPKeepAliveIdle | |
| } else if d < 0 { | |
| return nil | |
| } | |
| // The kernel expects seconds so round to next highest second. | |
| secs := int(roundDurationUp(d, time.Second)) | |
| err := fd.pfd.SetsockoptInt(syscall.IPPROTO_TCP, windows.TCP_KEEPIDLE, secs) | |
| runtime.KeepAlive(fd) | |
| return os.NewSyscallError("setsockopt", err) | |
| } | |
| func setKeepAliveInterval(fd *netFD, d time.Duration) error { | |
| if !windows.SupportTCPKeepAliveInterval() { | |
| return setKeepAliveIdleAndInterval(fd, -1, d) | |
| } | |
| if d == 0 { | |
| d = defaultTCPKeepAliveInterval | |
| } else if d < 0 { | |
| return nil | |
| } | |
| // The kernel expects seconds so round to next highest second. | |
| secs := int(roundDurationUp(d, time.Second)) | |
| err := fd.pfd.SetsockoptInt(syscall.IPPROTO_TCP, windows.TCP_KEEPINTVL, secs) | |
| runtime.KeepAlive(fd) | |
| return os.NewSyscallError("setsockopt", err) | |
| } | |
| func setKeepAliveCount(fd *netFD, n int) error { | |
| if n == 0 { | |
| n = defaultTCPKeepAliveCount | |
| } else if n < 0 { | |
| return nil | |
| } | |
| err := fd.pfd.SetsockoptInt(syscall.IPPROTO_TCP, windows.TCP_KEEPCNT, n) | |
| runtime.KeepAlive(fd) | |
| return os.NewSyscallError("setsockopt", err) | |
| } | |
| // setKeepAliveIdleAndInterval serves for kernels prior to Windows 10, version 1709. | |
| func setKeepAliveIdleAndInterval(fd *netFD, idle, interval time.Duration) error { | |
| // WSAIoctl with SIO_KEEPALIVE_VALS control code requires all fields in | |
| // `tcp_keepalive` struct to be provided. | |
| // Otherwise, if any of the fields were not provided, just leaving them | |
| // zero will knock off any existing values of keep-alive. | |
| // Unfortunately, Windows doesn't support retrieving current keep-alive | |
| // settings in any form programmatically, which disable us to first retrieve | |
| // the current keep-alive settings, then set it without unwanted corruption. | |
| switch { | |
| case idle < 0 && interval >= 0: | |
| // Given that we can't set KeepAliveInterval alone, and this code path | |
| // is new, it doesn't exist before, so we just return an error. | |
| return syscall.WSAENOPROTOOPT | |
| case idle >= 0 && interval < 0: | |
| // Although we can't set KeepAliveTime alone either, this existing code | |
| // path had been backing up [SetKeepAlivePeriod] which used to be set both | |
| // KeepAliveTime and KeepAliveInterval to 15 seconds. | |
| // Now we will use the default of KeepAliveInterval on Windows if user doesn't | |
| // provide one. | |
| interval = defaultKeepAliveInterval | |
| case idle < 0 && interval < 0: | |
| // Nothing to do, just bail out. | |
| return nil | |
| case idle >= 0 && interval >= 0: | |
| // Go ahead. | |
| } | |
| if idle == 0 { | |
| idle = defaultTCPKeepAliveIdle | |
| } | |
| if interval == 0 { | |
| interval = defaultTCPKeepAliveInterval | |
| } | |
| // The kernel expects milliseconds so round to next highest | |
| // millisecond. | |
| tcpKeepAliveIdle := uint32(roundDurationUp(idle, time.Millisecond)) | |
| tcpKeepAliveInterval := uint32(roundDurationUp(interval, time.Millisecond)) | |
| ka := syscall.TCPKeepalive{ | |
| OnOff: 1, | |
| Time: tcpKeepAliveIdle, | |
| Interval: tcpKeepAliveInterval, | |
| } | |
| ret := uint32(0) | |
| size := uint32(unsafe.Sizeof(ka)) | |
| err := fd.pfd.WSAIoctl(syscall.SIO_KEEPALIVE_VALS, (*byte)(unsafe.Pointer(&ka)), size, nil, 0, &ret, nil, 0) | |
| runtime.KeepAlive(fd) | |
| return os.NewSyscallError("wsaioctl", err) | |
| } |