1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
package sock
import (
"fmt"
"net"
"github.com/tetratelabs/wazero/experimental/sys"
)
// TCPSock is a pseudo-file representing a TCP socket.
type TCPSock interface {
sys.File
Accept() (TCPConn, sys.Errno)
}
// TCPConn is a pseudo-file representing a TCP connection.
type TCPConn interface {
sys.File
// Recvfrom only supports the flag sysfs.MSG_PEEK
// TODO: document this like sys.File with known sys.Errno
Recvfrom(p []byte, flags int) (n int, errno sys.Errno)
// TODO: document this like sys.File with known sys.Errno
Shutdown(how int) sys.Errno
}
// ConfigKey is a context.Context Value key. Its associated value should be a Config.
type ConfigKey struct{}
// Config is an internal struct meant to implement
// the interface in experimental/sock/Config.
type Config struct {
// TCPAddresses is a slice of the configured host:port pairs.
TCPAddresses []TCPAddress
}
// TCPAddress is a host:port pair to pre-open.
type TCPAddress struct {
// Host is the host name for this listener.
Host string
// Port is the port number for this listener.
Port int
}
// WithTCPListener implements the method of the same name in experimental/sock/Config.
//
// However, to avoid cyclic dependencies, this is returning the *Config in this scope.
// The interface is implemented in experimental/sock/Config via delegation.
func (c *Config) WithTCPListener(host string, port int) *Config {
ret := c.clone()
ret.TCPAddresses = append(ret.TCPAddresses, TCPAddress{host, port})
return &ret
}
// Makes a deep copy of this sockConfig.
func (c *Config) clone() Config {
ret := *c
ret.TCPAddresses = make([]TCPAddress, 0, len(c.TCPAddresses))
ret.TCPAddresses = append(ret.TCPAddresses, c.TCPAddresses...)
return ret
}
// BuildTCPListeners build listeners from the current configuration.
func (c *Config) BuildTCPListeners() (tcpListeners []*net.TCPListener, err error) {
for _, tcpAddr := range c.TCPAddresses {
var ln net.Listener
ln, err = net.Listen("tcp", tcpAddr.String())
if err != nil {
break
}
if tcpln, ok := ln.(*net.TCPListener); ok {
tcpListeners = append(tcpListeners, tcpln)
}
}
if err != nil {
// An error occurred, cleanup.
for _, l := range tcpListeners {
_ = l.Close() // Ignore errors, we are already cleaning.
}
tcpListeners = nil
}
return
}
func (t TCPAddress) String() string {
return fmt.Sprintf("%s:%d", t.Host, t.Port)
}
|
