diff --git a/.github/workflows/linter.yml b/.github/workflows/linter.yml index 285f29d8..625ceb04 100644 --- a/.github/workflows/linter.yml +++ b/.github/workflows/linter.yml @@ -20,6 +20,9 @@ jobs: stable: false - name: golangci-lint - uses: golangci/golangci-lint-action@v3 - with: - version: latest + #uses: golangci/golangci-lint-action@v3 + #with: + # version: latest + run: | + go install github.com/golangci/golangci-lint/cmd/golangci-lint@93a0015 + golangci-lint run ./... diff --git a/.golangci.yaml b/.golangci.yaml index efe91527..c4265cf5 100644 --- a/.golangci.yaml +++ b/.golangci.yaml @@ -4,7 +4,7 @@ linters: - gofumpt - megacheck - govet - - gci +# - gci linters-settings: gci: diff --git a/component/process/process.go b/component/process/process.go index 67a5df66..2fc288c5 100644 --- a/component/process/process.go +++ b/component/process/process.go @@ -3,6 +3,8 @@ package process import ( "errors" "net" + + C "github.com/Dreamacro/clash/constant" ) var ( @@ -19,3 +21,45 @@ const ( func FindProcessName(network string, srcIP net.IP, srcPort int) (string, error) { return findProcessName(network, srcIP, srcPort) } + +func ShouldFindProcess(metadata *C.Metadata) bool { + if metadata.Process != "" { + return false + } + for _, ip := range localIPs { + if ip.Equal(metadata.SrcIP) { + return true + } + } + return false +} + +func getLocalIPs() []net.IP { + ips := []net.IP{net.IPv4(198, 18, 0, 1), net.IPv4zero, net.IPv6zero} + + netInterfaces, err := net.Interfaces() + if err != nil { + ips = append(ips, net.IPv4(127, 0, 0, 1), net.IPv6loopback) + return ips + } + + for i := 0; i < len(netInterfaces); i++ { + if (netInterfaces[i].Flags & net.FlagUp) != 0 { + adds, _ := netInterfaces[i].Addrs() + + for _, address := range adds { + if ipNet, ok := address.(*net.IPNet); ok { + ips = append(ips, ipNet.IP) + } + } + } + } + + return ips +} + +var localIPs []net.IP + +func init() { + localIPs = getLocalIPs() +} diff --git a/config/config.go b/config/config.go index 98045017..5fa70cf6 100644 --- a/config/config.go +++ b/config/config.go @@ -439,7 +439,7 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { var ( payload string target string - params = []string{} + params []string ruleName = strings.ToUpper(rule[0]) ) @@ -456,6 +456,12 @@ func parseRules(cfg *RawConfig, proxies map[string]C.Proxy) ([]C.Rule, error) { payload = rule[1] target = rule[2] case l >= 4: + if ruleName == "MATCH" { + payload = "" + target = rule[1] + params = rule[2:] + break + } payload = rule[1] target = rule[2] params = rule[3:] diff --git a/constant/metadata.go b/constant/metadata.go index 8487fe5e..f63816b1 100644 --- a/constant/metadata.go +++ b/constant/metadata.go @@ -69,16 +69,17 @@ func (t Type) MarshalJSON() ([]byte, error) { // Metadata is used to store connection address type Metadata struct { - NetWork NetWork `json:"network"` - Type Type `json:"type"` - SrcIP net.IP `json:"sourceIP"` - DstIP net.IP `json:"destinationIP"` - SrcPort string `json:"sourcePort"` - DstPort string `json:"destinationPort"` - AddrType int `json:"-"` - Host string `json:"host"` - Process string `json:"process"` - DNSMode DNSMode `json:"dnsMode"` + NetWork NetWork `json:"network"` + Type Type `json:"type"` + SrcIP net.IP `json:"sourceIP"` + DstIP net.IP `json:"destinationIP"` + SrcPort string `json:"sourcePort"` + DstPort string `json:"destinationPort"` + AddrType int `json:"-"` + Host string `json:"host"` + DNSMode DNSMode `json:"dnsMode"` + Process string `json:"process"` + ProcessPath string `json:"processPath"` } func (m *Metadata) RemoteAddress() string { diff --git a/constant/rule.go b/constant/rule.go index f36a3b51..23f421aa 100644 --- a/constant/rule.go +++ b/constant/rule.go @@ -12,6 +12,7 @@ const ( SrcPort DstPort Process + ProcessPath MATCH ) @@ -39,6 +40,8 @@ func (rt RuleType) String() string { return "DstPort" case Process: return "Process" + case ProcessPath: + return "ProcessPath" case MATCH: return "Match" default: @@ -53,4 +56,6 @@ type Rule interface { Payload() string ShouldResolveIP() bool RuleExtra() *RuleExtra + SetRuleExtra(re *RuleExtra) + ShouldFindProcess() bool } diff --git a/dns/filters.go b/dns/filters.go index 9c1be0d0..3293f674 100644 --- a/dns/filters.go +++ b/dns/filters.go @@ -20,7 +20,11 @@ type geoipFilter struct { func (gf *geoipFilter) Match(ip net.IP) bool { record, _ := mmdb.Instance().Country(ip) - return !strings.EqualFold(record.Country.IsoCode, gf.code) && !ip.IsPrivate() && !ip.Equal(C.TunBroadcastAddr) + return !strings.EqualFold(record.Country.IsoCode, gf.code) && + !ip.IsPrivate() && + !ip.IsLoopback() && + !ip.IsUnspecified() && + !ip.Equal(C.TunBroadcastAddr) } type ipnetFilter struct { diff --git a/go.mod b/go.mod index 18179ab7..6d76fbdd 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,6 @@ go 1.18 require ( github.com/Dreamacro/go-shadowsocks2 v0.1.7 - github.com/Kr328/tun2socket v0.0.0-20211231120722-962f339492e8 github.com/go-chi/chi/v5 v5.0.7 github.com/go-chi/cors v1.2.0 github.com/go-chi/render v1.0.1 @@ -31,8 +30,6 @@ require ( gvisor.dev/gvisor v0.0.0-20220311014831-b314d81fbac7 ) -replace github.com/Kr328/tun2socket => github.com/yaling888/tun2socket v0.0.0-20220311175825-946fa2efc456 - require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/google/btree v1.0.1 // indirect diff --git a/go.sum b/go.sum index d93e0ebe..cd8c4c45 100644 --- a/go.sum +++ b/go.sum @@ -69,8 +69,6 @@ github.com/u-root/uio v0.0.0-20210528114334-82958018845c h1:BFvcl34IGnw8yvJi8hlq github.com/u-root/uio v0.0.0-20210528114334-82958018845c/go.mod h1:LpEX5FO/cB+WF4TYGY1V5qktpaZLkKkSegbr0V4eYXA= github.com/xtls/go v0.0.0-20210920065950-d4af136d3672 h1:4mkzGhKqt3JO1BWYjtD3iRFyAx4ow67hmSqOcGjuxqQ= github.com/xtls/go v0.0.0-20210920065950-d4af136d3672/go.mod h1:YGGVbz9cOxyKFUmhW7LGaLZaMA0cPlHJinvAmVxEMSU= -github.com/yaling888/tun2socket v0.0.0-20220311175825-946fa2efc456 h1:nQJinYmzP/QPw3ZUMUx1kktQe3krU+aIXtq/zTAzy5k= -github.com/yaling888/tun2socket v0.0.0-20220311175825-946fa2efc456/go.mod h1:S+eXY++0DlzcTSRC3nyKJtboVNPZpwvGG/W5/kuvTl0= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.etcd.io/bbolt v1.3.6 h1:/ecaJf0sk1l4l6V4awd65v2C3ILy7MSj+s/x1ADCIMU= go.etcd.io/bbolt v1.3.6/go.mod h1:qXsaaIqmgQH0T+OPdb99Bf+PKfBBQVAdyD6TY9G8XM4= diff --git a/listener/tun/ipstack/commons/config.go b/listener/tun/ipstack/commons/config.go deleted file mode 100644 index 93497b02..00000000 --- a/listener/tun/ipstack/commons/config.go +++ /dev/null @@ -1,57 +0,0 @@ -//go:build windows -// +build windows - -package commons - -import ( - "fmt" - "net" - "strconv" - "strings" -) - -type IPCidr struct { - IP net.IP - Cidr uint8 -} - -func (r *IPCidr) String() string { - return fmt.Sprintf("%s/%d", r.IP.String(), r.Cidr) -} - -func (r *IPCidr) Bits() uint8 { - if r.IP.To4() != nil { - return 32 - } - return 128 -} - -func (r *IPCidr) IPNet() net.IPNet { - return net.IPNet{ - IP: r.IP, - Mask: net.CIDRMask(int(r.Cidr), int(r.Bits())), - } -} - -func (r *IPCidr) MaskSelf() { - bits := int(r.Bits()) - mask := net.CIDRMask(int(r.Cidr), bits) - for i := 0; i < bits/8; i++ { - r.IP[i] &= mask[i] - } -} - -func ParseIPCidr(ipcidr string) *IPCidr { - s := strings.Split(ipcidr, "/") - if len(s) != 2 { - return nil - } - cidr, err := strconv.Atoi(s[1]) - if err != nil { - return nil - } - return &IPCidr{ - IP: net.ParseIP(s[0]), - Cidr: uint8(cidr), - } -} diff --git a/listener/tun/ipstack/system/mars/mars.go b/listener/tun/ipstack/system/mars/mars.go new file mode 100644 index 00000000..ffc38bf7 --- /dev/null +++ b/listener/tun/ipstack/system/mars/mars.go @@ -0,0 +1,42 @@ +package mars + +import ( + "io" + "net/netip" + + "github.com/Dreamacro/clash/listener/tun/ipstack/system/mars/nat" +) + +type StackListener struct { + device io.Closer + tcp *nat.TCP + udp *nat.UDP +} + +func StartListener(device io.ReadWriteCloser, gateway netip.Addr, portal netip.Addr) (*StackListener, error) { + tcp, udp, err := nat.Start(device, gateway, portal) + if err != nil { + return nil, err + } + + return &StackListener{ + device: device, + tcp: tcp, + udp: udp, + }, nil +} + +func (t *StackListener) Close() error { + _ = t.tcp.Close() + _ = t.udp.Close() + + return t.device.Close() +} + +func (t *StackListener) TCP() *nat.TCP { + return t.tcp +} + +func (t *StackListener) UDP() *nat.UDP { + return t.udp +} diff --git a/listener/tun/ipstack/system/mars/nat/nat.go b/listener/tun/ipstack/system/mars/nat/nat.go new file mode 100644 index 00000000..d1aecc88 --- /dev/null +++ b/listener/tun/ipstack/system/mars/nat/nat.go @@ -0,0 +1,196 @@ +package nat + +import ( + "io" + "net" + "net/netip" + + "github.com/Dreamacro/clash/listener/tun/ipstack/system/mars/tcpip" +) + +func Start( + device io.ReadWriter, + gateway netip.Addr, + portal netip.Addr, +) (*TCP, *UDP, error) { + if !portal.Is4() || !gateway.Is4() { + return nil, nil, net.InvalidAddrError("only ipv4 supported") + } + + listener, err := net.ListenTCP("tcp4", nil) + if err != nil { + return nil, nil, err + } + + tab := newTable() + udp := &UDP{ + calls: map[*call]struct{}{}, + device: device, + buf: [65535]byte{}, + } + tcp := &TCP{ + listener: listener, + portal: portal, + table: tab, + } + + gatewayPort := uint16(listener.Addr().(*net.TCPAddr).Port) + + go func() { + defer tcp.Close() + defer udp.Close() + + buf := make([]byte, 65535) + + for { + n, err := device.Read(buf) + if err != nil { + return + } + + raw := buf[:n] + + var ( + ipVersion int + ip tcpip.IP + ) + + ipVersion = tcpip.IPVersion(raw) + + switch ipVersion { + case tcpip.IPv4Version: + ipv4 := tcpip.IPv4Packet(raw) + if !ipv4.Valid() { + continue + } + + if ipv4.TimeToLive() == 0x00 { + continue + } + + if ipv4.Flags()&tcpip.FlagMoreFragment != 0 { + continue + } + + if ipv4.Offset() != 0 { + continue + } + + ip = ipv4 + case tcpip.IPv6Version: + ipv6 := tcpip.IPv6Packet(raw) + if !ipv6.Valid() { + continue + } + + if ipv6.HopLimit() == 0x00 { + continue + } + + ip = ipv6 + default: + continue + } + + switch ip.Protocol() { + case tcpip.TCP: + t := tcpip.TCPPacket(ip.Payload()) + if !t.Valid() { + continue + } + + if ip.DestinationIP() == portal { + if ip.SourceIP() == gateway && t.SourcePort() == gatewayPort { + tup := tab.tupleOf(t.DestinationPort()) + if tup == zeroTuple { + continue + } + + ip.SetSourceIP(tup.DestinationAddr.Addr()) + t.SetSourcePort(tup.DestinationAddr.Port()) + ip.SetDestinationIP(tup.SourceAddr.Addr()) + t.SetDestinationPort(tup.SourceAddr.Port()) + + ip.DecTimeToLive() + ip.ResetChecksum() + t.ResetChecksum(ip.PseudoSum()) + + _, _ = device.Write(raw) + } + } else { + tup := tuple{ + SourceAddr: netip.AddrPortFrom(ip.SourceIP(), t.SourcePort()), + DestinationAddr: netip.AddrPortFrom(ip.DestinationIP(), t.DestinationPort()), + } + + port := tab.portOf(tup) + if port == 0 { + if t.Flags() != tcpip.TCPSyn { + continue + } + + port = tab.newConn(tup) + } + + ip.SetSourceIP(portal) + ip.SetDestinationIP(gateway) + t.SetSourcePort(port) + t.SetDestinationPort(gatewayPort) + + ip.DecTimeToLive() + ip.ResetChecksum() + t.ResetChecksum(ip.PseudoSum()) + + _, _ = device.Write(raw) + } + case tcpip.UDP: + u := tcpip.UDPPacket(ip.Payload()) + if !u.Valid() { + continue + } + + udp.handleUDPPacket(ip, u) + case tcpip.ICMP: + i := tcpip.ICMPPacket(ip.Payload()) + + if i.Type() != tcpip.ICMPTypePingRequest || i.Code() != 0 { + continue + } + + i.SetType(tcpip.ICMPTypePingResponse) + + source := ip.SourceIP() + destination := ip.DestinationIP() + ip.SetSourceIP(destination) + ip.SetDestinationIP(source) + + ip.DecTimeToLive() + ip.ResetChecksum() + i.ResetChecksum() + + _, _ = device.Write(raw) + case tcpip.ICMPv6: + i := tcpip.ICMPv6Packet(ip.Payload()) + + if i.Type() != tcpip.ICMPv6EchoRequest || i.Code() != 0 { + continue + } + + i.SetType(tcpip.ICMPv6EchoReply) + + source := ip.SourceIP() + destination := ip.DestinationIP() + ip.SetSourceIP(destination) + ip.SetDestinationIP(source) + + ip.DecTimeToLive() + ip.ResetChecksum() + i.ResetChecksum(ip.PseudoSum()) + + _, _ = device.Write(raw) + } + } + }() + + return tcp, udp, nil +} diff --git a/listener/tun/ipstack/system/mars/nat/table.go b/listener/tun/ipstack/system/mars/nat/table.go new file mode 100644 index 00000000..e0d86ccc --- /dev/null +++ b/listener/tun/ipstack/system/mars/nat/table.go @@ -0,0 +1,83 @@ +package nat + +import ( + "container/list" + "net/netip" +) + +const ( + portBegin = 30000 + portLength = 4096 +) + +var zeroTuple = tuple{} + +type tuple struct { + SourceAddr netip.AddrPort + DestinationAddr netip.AddrPort +} + +type binding struct { + tuple tuple + offset uint16 +} + +type table struct { + tuples map[tuple]*list.Element + ports [portLength]*list.Element + available *list.List +} + +func (t *table) tupleOf(port uint16) tuple { + offset := port - portBegin + if offset > portLength { + return zeroTuple + } + + elm := t.ports[offset] + + t.available.MoveToFront(elm) + + return elm.Value.(*binding).tuple +} + +func (t *table) portOf(tuple tuple) uint16 { + elm := t.tuples[tuple] + if elm == nil { + return 0 + } + + t.available.MoveToFront(elm) + + return portBegin + elm.Value.(*binding).offset +} + +func (t *table) newConn(tuple tuple) uint16 { + elm := t.available.Back() + b := elm.Value.(*binding) + + delete(t.tuples, b.tuple) + t.tuples[tuple] = elm + b.tuple = tuple + + t.available.MoveToFront(elm) + + return portBegin + b.offset +} + +func newTable() *table { + result := &table{ + tuples: make(map[tuple]*list.Element, portLength), + ports: [portLength]*list.Element{}, + available: list.New(), + } + + for idx := range result.ports { + result.ports[idx] = result.available.PushFront(&binding{ + tuple: tuple{}, + offset: uint16(idx), + }) + } + + return result +} diff --git a/listener/tun/ipstack/system/mars/nat/tcp.go b/listener/tun/ipstack/system/mars/nat/tcp.go new file mode 100644 index 00000000..fccc3ca2 --- /dev/null +++ b/listener/tun/ipstack/system/mars/nat/tcp.go @@ -0,0 +1,69 @@ +package nat + +import ( + "net" + "net/netip" + "time" +) + +type TCP struct { + listener *net.TCPListener + portal netip.Addr + table *table +} + +type conn struct { + net.Conn + + tuple tuple +} + +func (t *TCP) Accept() (net.Conn, error) { + c, err := t.listener.AcceptTCP() + if err != nil { + return nil, err + } + + addr := c.RemoteAddr().(*net.TCPAddr) + tup := t.table.tupleOf(uint16(addr.Port)) + if !addr.IP.Equal(t.portal.AsSlice()) || tup == zeroTuple { + _ = c.Close() + + return nil, net.InvalidAddrError("unknown remote addr") + } + + // _ = c.SetKeepAlive(false) + + addition(c) + + return &conn{ + Conn: c, + tuple: tup, + }, nil +} + +func (t *TCP) Close() error { + return t.listener.Close() +} + +func (t *TCP) Addr() net.Addr { + return t.listener.Addr() +} + +func (t *TCP) SetDeadline(time time.Time) error { + return t.listener.SetDeadline(time) +} + +func (c *conn) LocalAddr() net.Addr { + return &net.TCPAddr{ + IP: c.tuple.SourceAddr.Addr().AsSlice(), + Port: int(c.tuple.SourceAddr.Port()), + } +} + +func (c *conn) RemoteAddr() net.Addr { + return &net.TCPAddr{ + IP: c.tuple.DestinationAddr.Addr().AsSlice(), + Port: int(c.tuple.DestinationAddr.Port()), + } +} diff --git a/listener/tun/ipstack/system/mars/nat/tcp_linux.go b/listener/tun/ipstack/system/mars/nat/tcp_linux.go new file mode 100644 index 00000000..9f433a3a --- /dev/null +++ b/listener/tun/ipstack/system/mars/nat/tcp_linux.go @@ -0,0 +1,15 @@ +package nat + +import ( + "net" + "syscall" +) + +func addition(c *net.TCPConn) { + sys, err := c.SyscallConn() + if err == nil { + _ = sys.Control(func(fd uintptr) { + _ = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_NO_CHECK, 1) + }) + } +} diff --git a/listener/tun/ipstack/system/mars/nat/tcp_others.go b/listener/tun/ipstack/system/mars/nat/tcp_others.go new file mode 100644 index 00000000..cc46bdbd --- /dev/null +++ b/listener/tun/ipstack/system/mars/nat/tcp_others.go @@ -0,0 +1,7 @@ +//go:build !linux + +package nat + +import "net" + +func addition(*net.TCPConn) {} diff --git a/listener/tun/ipstack/system/mars/nat/udp.go b/listener/tun/ipstack/system/mars/nat/udp.go new file mode 100644 index 00000000..08fa3998 --- /dev/null +++ b/listener/tun/ipstack/system/mars/nat/udp.go @@ -0,0 +1,140 @@ +package nat + +import ( + "io" + "math/rand" + "net" + "net/netip" + "sync" + + "github.com/Dreamacro/clash/listener/tun/ipstack/system/mars/tcpip" +) + +type call struct { + cond *sync.Cond + buf []byte + n int + source net.Addr + destination net.Addr +} + +type UDP struct { + closed bool + lock sync.Mutex + calls map[*call]struct{} + device io.Writer + bufLock sync.Mutex + buf [65535]byte +} + +func (u *UDP) ReadFrom(buf []byte) (int, net.Addr, net.Addr, error) { + u.lock.Lock() + defer u.lock.Unlock() + + for !u.closed { + c := &call{ + cond: sync.NewCond(&u.lock), + buf: buf, + n: -1, + source: nil, + destination: nil, + } + + u.calls[c] = struct{}{} + + c.cond.Wait() + + if c.n >= 0 { + return c.n, c.source, c.destination, nil + } + } + + return -1, nil, nil, net.ErrClosed +} + +func (u *UDP) WriteTo(buf []byte, local net.Addr, remote net.Addr) (int, error) { + u.bufLock.Lock() + defer u.bufLock.Unlock() + + if len(buf) > 0xffff { + return 0, net.InvalidAddrError("invalid ip version") + } + + srcAddr, srcOk := local.(*net.UDPAddr) + dstAddr, dstOk := remote.(*net.UDPAddr) + if !srcOk || !dstOk { + return 0, net.InvalidAddrError("invalid addr") + } + + srcIP, _ := netip.AddrFromSlice(srcAddr.IP) + dstIp, _ := netip.AddrFromSlice(dstAddr.IP) + + srcAddrPort := netip.AddrPortFrom(srcIP, uint16(srcAddr.Port)) + dstAddrPort := netip.AddrPortFrom(dstIp, uint16(dstAddr.Port)) + + if !srcAddrPort.Addr().Is4() || !dstAddrPort.Addr().Is4() { + return 0, net.InvalidAddrError("invalid ip version") + } + + ip := tcpip.IPv4Packet(u.buf[:]) + tcpip.SetIPv4(ip) + ip.SetHeaderLen(tcpip.IPv4HeaderSize) + ip.SetTotalLength(tcpip.IPv4HeaderSize + tcpip.UDPHeaderSize + uint16(len(buf))) + ip.SetTypeOfService(0) + ip.SetIdentification(uint16(rand.Uint32())) + ip.SetFragmentOffset(0) + ip.SetTimeToLive(64) + ip.SetProtocol(tcpip.UDP) + ip.SetSourceIP(srcAddrPort.Addr()) + ip.SetDestinationIP(dstAddrPort.Addr()) + + udp := tcpip.UDPPacket(ip.Payload()) + udp.SetLength(tcpip.UDPHeaderSize + uint16(len(buf))) + udp.SetSourcePort(srcAddrPort.Port()) + udp.SetDestinationPort(dstAddrPort.Port()) + copy(udp.Payload(), buf) + + ip.ResetChecksum() + udp.ResetChecksum(ip.PseudoSum()) + + return u.device.Write(u.buf[:ip.TotalLen()]) +} + +func (u *UDP) Close() error { + u.lock.Lock() + defer u.lock.Unlock() + + u.closed = true + + for c := range u.calls { + c.cond.Signal() + } + + return nil +} + +func (u *UDP) handleUDPPacket(ip tcpip.IP, pkt tcpip.UDPPacket) { + var c *call + + u.lock.Lock() + + for c = range u.calls { + delete(u.calls, c) + break + } + + u.lock.Unlock() + + if c != nil { + c.source = &net.UDPAddr{ + IP: ip.SourceIP().AsSlice(), + Port: int(pkt.SourcePort()), + } + c.destination = &net.UDPAddr{ + IP: ip.DestinationIP().AsSlice(), + Port: int(pkt.DestinationPort()), + } + c.n = copy(c.buf, pkt.Payload()) + c.cond.Signal() + } +} diff --git a/listener/tun/ipstack/system/mars/tcpip/icmp.go b/listener/tun/ipstack/system/mars/tcpip/icmp.go new file mode 100644 index 00000000..d473c25f --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/icmp.go @@ -0,0 +1,40 @@ +package tcpip + +import ( + "encoding/binary" +) + +type ICMPType = byte + +const ( + ICMPTypePingRequest byte = 0x8 + ICMPTypePingResponse byte = 0x0 +) + +type ICMPPacket []byte + +func (p ICMPPacket) Type() ICMPType { + return p[0] +} + +func (p ICMPPacket) SetType(v ICMPType) { + p[0] = v +} + +func (p ICMPPacket) Code() byte { + return p[1] +} + +func (p ICMPPacket) Checksum() uint16 { + return binary.BigEndian.Uint16(p[2:]) +} + +func (p ICMPPacket) SetChecksum(sum [2]byte) { + p[2] = sum[0] + p[3] = sum[1] +} + +func (p ICMPPacket) ResetChecksum() { + p.SetChecksum(zeroChecksum) + p.SetChecksum(Checksum(0, p)) +} diff --git a/listener/tun/ipstack/system/mars/tcpip/icmpv6.go b/listener/tun/ipstack/system/mars/tcpip/icmpv6.go new file mode 100644 index 00000000..a87f965f --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/icmpv6.go @@ -0,0 +1,172 @@ +package tcpip + +import ( + "encoding/binary" +) + +type ICMPv6Packet []byte + +const ( + ICMPv6HeaderSize = 4 + + ICMPv6MinimumSize = 8 + + ICMPv6PayloadOffset = 8 + + ICMPv6EchoMinimumSize = 8 + + ICMPv6ErrorHeaderSize = 8 + + ICMPv6DstUnreachableMinimumSize = ICMPv6MinimumSize + + ICMPv6PacketTooBigMinimumSize = ICMPv6MinimumSize + + ICMPv6ChecksumOffset = 2 + + icmpv6PointerOffset = 4 + + icmpv6MTUOffset = 4 + + icmpv6IdentOffset = 4 + + icmpv6SequenceOffset = 6 + + NDPHopLimit = 255 +) + +type ICMPv6Type byte + +const ( + ICMPv6DstUnreachable ICMPv6Type = 1 + ICMPv6PacketTooBig ICMPv6Type = 2 + ICMPv6TimeExceeded ICMPv6Type = 3 + ICMPv6ParamProblem ICMPv6Type = 4 + ICMPv6EchoRequest ICMPv6Type = 128 + ICMPv6EchoReply ICMPv6Type = 129 + + ICMPv6RouterSolicit ICMPv6Type = 133 + ICMPv6RouterAdvert ICMPv6Type = 134 + ICMPv6NeighborSolicit ICMPv6Type = 135 + ICMPv6NeighborAdvert ICMPv6Type = 136 + ICMPv6RedirectMsg ICMPv6Type = 137 + + ICMPv6MulticastListenerQuery ICMPv6Type = 130 + ICMPv6MulticastListenerReport ICMPv6Type = 131 + ICMPv6MulticastListenerDone ICMPv6Type = 132 +) + +func (typ ICMPv6Type) IsErrorType() bool { + return typ&0x80 == 0 +} + +type ICMPv6Code byte + +const ( + ICMPv6NetworkUnreachable ICMPv6Code = 0 + ICMPv6Prohibited ICMPv6Code = 1 + ICMPv6BeyondScope ICMPv6Code = 2 + ICMPv6AddressUnreachable ICMPv6Code = 3 + ICMPv6PortUnreachable ICMPv6Code = 4 + ICMPv6Policy ICMPv6Code = 5 + ICMPv6RejectRoute ICMPv6Code = 6 +) + +const ( + ICMPv6HopLimitExceeded ICMPv6Code = 0 + ICMPv6ReassemblyTimeout ICMPv6Code = 1 +) + +const ( + ICMPv6ErroneousHeader ICMPv6Code = 0 + + ICMPv6UnknownHeader ICMPv6Code = 1 + + ICMPv6UnknownOption ICMPv6Code = 2 +) + +const ICMPv6UnusedCode ICMPv6Code = 0 + +func (b ICMPv6Packet) Type() ICMPv6Type { + return ICMPv6Type(b[0]) +} + +func (b ICMPv6Packet) SetType(t ICMPv6Type) { + b[0] = byte(t) +} + +func (b ICMPv6Packet) Code() ICMPv6Code { + return ICMPv6Code(b[1]) +} + +func (b ICMPv6Packet) SetCode(c ICMPv6Code) { + b[1] = byte(c) +} + +func (b ICMPv6Packet) TypeSpecific() uint32 { + return binary.BigEndian.Uint32(b[icmpv6PointerOffset:]) +} + +func (b ICMPv6Packet) SetTypeSpecific(val uint32) { + binary.BigEndian.PutUint32(b[icmpv6PointerOffset:], val) +} + +func (b ICMPv6Packet) Checksum() uint16 { + return binary.BigEndian.Uint16(b[ICMPv6ChecksumOffset:]) +} + +func (b ICMPv6Packet) SetChecksum(sum [2]byte) { + _ = b[ICMPv6ChecksumOffset+1] + b[ICMPv6ChecksumOffset] = sum[0] + b[ICMPv6ChecksumOffset+1] = sum[1] +} + +func (ICMPv6Packet) SourcePort() uint16 { + return 0 +} + +func (ICMPv6Packet) DestinationPort() uint16 { + return 0 +} + +func (ICMPv6Packet) SetSourcePort(uint16) { +} + +func (ICMPv6Packet) SetDestinationPort(uint16) { +} + +func (b ICMPv6Packet) MTU() uint32 { + return binary.BigEndian.Uint32(b[icmpv6MTUOffset:]) +} + +func (b ICMPv6Packet) SetMTU(mtu uint32) { + binary.BigEndian.PutUint32(b[icmpv6MTUOffset:], mtu) +} + +func (b ICMPv6Packet) Ident() uint16 { + return binary.BigEndian.Uint16(b[icmpv6IdentOffset:]) +} + +func (b ICMPv6Packet) SetIdent(ident uint16) { + binary.BigEndian.PutUint16(b[icmpv6IdentOffset:], ident) +} + +func (b ICMPv6Packet) Sequence() uint16 { + return binary.BigEndian.Uint16(b[icmpv6SequenceOffset:]) +} + +func (b ICMPv6Packet) SetSequence(sequence uint16) { + binary.BigEndian.PutUint16(b[icmpv6SequenceOffset:], sequence) +} + +func (b ICMPv6Packet) MessageBody() []byte { + return b[ICMPv6HeaderSize:] +} + +func (b ICMPv6Packet) Payload() []byte { + return b[ICMPv6PayloadOffset:] +} + +func (b ICMPv6Packet) ResetChecksum(psum uint32) { + b.SetChecksum(zeroChecksum) + b.SetChecksum(Checksum(psum, b)) +} diff --git a/listener/tun/ipstack/system/mars/tcpip/ip.go b/listener/tun/ipstack/system/mars/tcpip/ip.go new file mode 100644 index 00000000..1ca49d8d --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/ip.go @@ -0,0 +1,215 @@ +package tcpip + +import ( + "encoding/binary" + "errors" + "net/netip" +) + +type IPProtocol = byte + +type IP interface { + Payload() []byte + SourceIP() netip.Addr + DestinationIP() netip.Addr + SetSourceIP(ip netip.Addr) + SetDestinationIP(ip netip.Addr) + Protocol() IPProtocol + DecTimeToLive() + ResetChecksum() + PseudoSum() uint32 +} + +// IPProtocol type +const ( + ICMP IPProtocol = 0x01 + TCP IPProtocol = 0x06 + UDP IPProtocol = 0x11 + ICMPv6 IPProtocol = 0x3a +) + +const ( + FlagDontFragment = 1 << 1 + FlagMoreFragment = 1 << 2 +) + +const ( + IPv4HeaderSize = 20 + + IPv4Version = 4 + + IPv4OptionsOffset = 20 + IPv4PacketMinLength = IPv4OptionsOffset +) + +var ( + ErrInvalidLength = errors.New("invalid packet length") + ErrInvalidIPVersion = errors.New("invalid ip version") + ErrInvalidChecksum = errors.New("invalid checksum") +) + +type IPv4Packet []byte + +func (p IPv4Packet) TotalLen() uint16 { + return binary.BigEndian.Uint16(p[2:]) +} + +func (p IPv4Packet) SetTotalLength(length uint16) { + binary.BigEndian.PutUint16(p[2:], length) +} + +func (p IPv4Packet) HeaderLen() uint16 { + return uint16(p[0]&0xf) * 4 +} + +func (p IPv4Packet) SetHeaderLen(length uint16) { + p[0] &= 0xF0 + p[0] |= byte(length / 4) +} + +func (p IPv4Packet) TypeOfService() byte { + return p[1] +} + +func (p IPv4Packet) SetTypeOfService(tos byte) { + p[1] = tos +} + +func (p IPv4Packet) Identification() uint16 { + return binary.BigEndian.Uint16(p[4:]) +} + +func (p IPv4Packet) SetIdentification(id uint16) { + binary.BigEndian.PutUint16(p[4:], id) +} + +func (p IPv4Packet) FragmentOffset() uint16 { + return binary.BigEndian.Uint16([]byte{p[6] & 0x7, p[7]}) * 8 +} + +func (p IPv4Packet) SetFragmentOffset(offset uint32) { + flags := p.Flags() + binary.BigEndian.PutUint16(p[6:], uint16(offset/8)) + p.SetFlags(flags) +} + +func (p IPv4Packet) DataLen() uint16 { + return p.TotalLen() - p.HeaderLen() +} + +func (p IPv4Packet) Payload() []byte { + return p[p.HeaderLen():p.TotalLen()] +} + +func (p IPv4Packet) Protocol() IPProtocol { + return p[9] +} + +func (p IPv4Packet) SetProtocol(protocol IPProtocol) { + p[9] = protocol +} + +func (p IPv4Packet) Flags() byte { + return p[6] >> 5 +} + +func (p IPv4Packet) SetFlags(flags byte) { + p[6] &= 0x1F + p[6] |= flags << 5 +} + +func (p IPv4Packet) Offset() uint16 { + offset := binary.BigEndian.Uint16(p[6:8]) + + return (offset & 0x1fff) * 8 +} + +func (p IPv4Packet) SourceIP() netip.Addr { + return netip.AddrFrom4([4]byte{p[12], p[13], p[14], p[15]}) +} + +func (p IPv4Packet) SetSourceIP(ip netip.Addr) { + if ip.Is4() { + copy(p[12:16], ip.AsSlice()) + } +} + +func (p IPv4Packet) DestinationIP() netip.Addr { + return netip.AddrFrom4([4]byte{p[16], p[17], p[18], p[19]}) +} + +func (p IPv4Packet) SetDestinationIP(ip netip.Addr) { + if ip.Is4() { + copy(p[16:20], ip.AsSlice()) + } +} + +func (p IPv4Packet) Checksum() uint16 { + return binary.BigEndian.Uint16(p[10:]) +} + +func (p IPv4Packet) SetChecksum(sum [2]byte) { + p[10] = sum[0] + p[11] = sum[1] +} + +func (p IPv4Packet) TimeToLive() uint8 { + return p[8] +} + +func (p IPv4Packet) SetTimeToLive(ttl uint8) { + p[8] = ttl +} + +func (p IPv4Packet) DecTimeToLive() { + p[8] = p[8] - uint8(1) +} + +func (p IPv4Packet) ResetChecksum() { + p.SetChecksum(zeroChecksum) + p.SetChecksum(Checksum(0, p[:p.HeaderLen()])) +} + +// PseudoSum for tcp checksum +func (p IPv4Packet) PseudoSum() uint32 { + sum := Sum(p[12:20]) + sum += uint32(p.Protocol()) + sum += uint32(p.DataLen()) + return sum +} + +func (p IPv4Packet) Valid() bool { + return len(p) >= IPv4HeaderSize && uint16(len(p)) >= p.TotalLen() +} + +func (p IPv4Packet) Verify() error { + if len(p) < IPv4PacketMinLength { + return ErrInvalidLength + } + + checksum := []byte{p[10], p[11]} + headerLength := uint16(p[0]&0xF) * 4 + packetLength := binary.BigEndian.Uint16(p[2:]) + + if p[0]>>4 != 4 { + return ErrInvalidIPVersion + } + + if uint16(len(p)) < packetLength || packetLength < headerLength { + return ErrInvalidLength + } + + p[10] = 0 + p[11] = 0 + defer copy(p[10:12], checksum) + + answer := Checksum(0, p[:headerLength]) + + if answer[0] != checksum[0] || answer[1] != checksum[1] { + return ErrInvalidChecksum + } + + return nil +} + +var _ IP = (*IPv4Packet)(nil) diff --git a/listener/tun/ipstack/system/mars/tcpip/ipv6.go b/listener/tun/ipstack/system/mars/tcpip/ipv6.go new file mode 100644 index 00000000..fd7502d6 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/ipv6.go @@ -0,0 +1,141 @@ +package tcpip + +import ( + "encoding/binary" + "net/netip" +) + +const ( + versTCFL = 0 + + IPv6PayloadLenOffset = 4 + + IPv6NextHeaderOffset = 6 + hopLimit = 7 + v6SrcAddr = 8 + v6DstAddr = v6SrcAddr + IPv6AddressSize + + IPv6FixedHeaderSize = v6DstAddr + IPv6AddressSize +) + +const ( + versIHL = 0 + tos = 1 + ipVersionShift = 4 + ipIHLMask = 0x0f + IPv4IHLStride = 4 +) + +type IPv6Packet []byte + +const ( + IPv6MinimumSize = IPv6FixedHeaderSize + + IPv6AddressSize = 16 + + IPv6Version = 6 + + IPv6MinimumMTU = 1280 +) + +func (b IPv6Packet) PayloadLength() uint16 { + return binary.BigEndian.Uint16(b[IPv6PayloadLenOffset:]) +} + +func (b IPv6Packet) HopLimit() uint8 { + return b[hopLimit] +} + +func (b IPv6Packet) NextHeader() byte { + return b[IPv6NextHeaderOffset] +} + +func (b IPv6Packet) Protocol() IPProtocol { + return b.NextHeader() +} + +func (b IPv6Packet) Payload() []byte { + return b[IPv6MinimumSize:][:b.PayloadLength()] +} + +func (b IPv6Packet) SourceIP() netip.Addr { + addr, _ := netip.AddrFromSlice(b[v6SrcAddr:][:IPv6AddressSize]) + return addr +} + +func (b IPv6Packet) DestinationIP() netip.Addr { + addr, _ := netip.AddrFromSlice(b[v6DstAddr:][:IPv6AddressSize]) + return addr +} + +func (IPv6Packet) Checksum() uint16 { + return 0 +} + +func (b IPv6Packet) TOS() (uint8, uint32) { + v := binary.BigEndian.Uint32(b[versTCFL:]) + return uint8(v >> 20), v & 0xfffff +} + +func (b IPv6Packet) SetTOS(t uint8, l uint32) { + vtf := (6 << 28) | (uint32(t) << 20) | (l & 0xfffff) + binary.BigEndian.PutUint32(b[versTCFL:], vtf) +} + +func (b IPv6Packet) SetPayloadLength(payloadLength uint16) { + binary.BigEndian.PutUint16(b[IPv6PayloadLenOffset:], payloadLength) +} + +func (b IPv6Packet) SetSourceIP(addr netip.Addr) { + if addr.Is6() { + copy(b[v6SrcAddr:][:IPv6AddressSize], addr.AsSlice()) + } +} + +func (b IPv6Packet) SetDestinationIP(addr netip.Addr) { + if addr.Is6() { + copy(b[v6DstAddr:][:IPv6AddressSize], addr.AsSlice()) + } +} + +func (b IPv6Packet) SetHopLimit(v uint8) { + b[hopLimit] = v +} + +func (b IPv6Packet) SetNextHeader(v byte) { + b[IPv6NextHeaderOffset] = v +} + +func (b IPv6Packet) SetProtocol(p IPProtocol) { + b.SetNextHeader(p) +} + +func (b IPv6Packet) DecTimeToLive() { + b[hopLimit] = b[hopLimit] - uint8(1) +} + +func (IPv6Packet) SetChecksum(uint16) { +} + +func (IPv6Packet) ResetChecksum() { +} + +func (b IPv6Packet) PseudoSum() uint32 { + sum := Sum(b[v6SrcAddr:IPv6FixedHeaderSize]) + sum += uint32(b.Protocol()) + sum += uint32(b.PayloadLength()) + return sum +} + +func (b IPv6Packet) Valid() bool { + return len(b) >= IPv6MinimumSize && len(b) >= int(b.PayloadLength())+IPv6MinimumSize +} + +func IPVersion(b []byte) int { + if len(b) < versIHL+1 { + return -1 + } + return int(b[versIHL] >> ipVersionShift) +} + +var _ IP = (*IPv6Packet)(nil) diff --git a/listener/tun/ipstack/system/mars/tcpip/tcp.go b/listener/tun/ipstack/system/mars/tcpip/tcp.go new file mode 100644 index 00000000..d3d08878 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcp.go @@ -0,0 +1,90 @@ +package tcpip + +import ( + "encoding/binary" + "net" +) + +const ( + TCPFin uint16 = 1 << 0 + TCPSyn uint16 = 1 << 1 + TCPRst uint16 = 1 << 2 + TCPPuh uint16 = 1 << 3 + TCPAck uint16 = 1 << 4 + TCPUrg uint16 = 1 << 5 + TCPEce uint16 = 1 << 6 + TCPEwr uint16 = 1 << 7 + TCPNs uint16 = 1 << 8 +) + +const TCPHeaderSize = 20 + +type TCPPacket []byte + +func (p TCPPacket) SourcePort() uint16 { + return binary.BigEndian.Uint16(p) +} + +func (p TCPPacket) SetSourcePort(port uint16) { + binary.BigEndian.PutUint16(p, port) +} + +func (p TCPPacket) DestinationPort() uint16 { + return binary.BigEndian.Uint16(p[2:]) +} + +func (p TCPPacket) SetDestinationPort(port uint16) { + binary.BigEndian.PutUint16(p[2:], port) +} + +func (p TCPPacket) Flags() uint16 { + return uint16(p[13] | (p[12] & 0x1)) +} + +func (p TCPPacket) Checksum() uint16 { + return binary.BigEndian.Uint16(p[16:]) +} + +func (p TCPPacket) SetChecksum(sum [2]byte) { + p[16] = sum[0] + p[17] = sum[1] +} + +func (p TCPPacket) ResetChecksum(psum uint32) { + p.SetChecksum(zeroChecksum) + p.SetChecksum(Checksum(psum, p)) +} + +func (p TCPPacket) Valid() bool { + return len(p) >= TCPHeaderSize +} + +func (p TCPPacket) Verify(sourceAddress net.IP, targetAddress net.IP) error { + var checksum [2]byte + checksum[0] = p[16] + checksum[1] = p[17] + + // reset checksum + p[16] = 0 + p[17] = 0 + + // restore checksum + defer func() { + p[16] = checksum[0] + p[17] = checksum[1] + }() + + // check checksum + s := uint32(0) + s += Sum(sourceAddress) + s += Sum(targetAddress) + s += uint32(TCP) + s += uint32(len(p)) + + check := Checksum(s, p) + if checksum[0] != check[0] || checksum[1] != check[1] { + return ErrInvalidChecksum + } + + return nil +} diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip.go b/listener/tun/ipstack/system/mars/tcpip/tcpip.go new file mode 100644 index 00000000..87811ea2 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip.go @@ -0,0 +1,24 @@ +package tcpip + +var zeroChecksum = [2]byte{0x00, 0x00} + +var SumFnc = SumCompat + +func Sum(b []byte) uint32 { + return SumFnc(b) +} + +// Checksum for Internet Protocol family headers +func Checksum(sum uint32, b []byte) (answer [2]byte) { + sum += Sum(b) + sum = (sum >> 16) + (sum & 0xffff) + sum += sum >> 16 + sum = ^sum + answer[0] = byte(sum >> 8) + answer[1] = byte(sum) + return +} + +func SetIPv4(packet []byte) { + packet[0] = (packet[0] & 0x0f) | (4 << 4) +} diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64.go b/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64.go new file mode 100644 index 00000000..d6f48dc0 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64.go @@ -0,0 +1,27 @@ +//go:build !noasm +// +build !noasm + +package tcpip + +import ( + "unsafe" + + "golang.org/x/sys/cpu" +) + +//go:noescape +func sumAsmAvx2(data unsafe.Pointer, length uintptr) uintptr + +func SumAVX2(data []byte) uint32 { + if len(data) == 0 { + return 0 + } + + return uint32(sumAsmAvx2(unsafe.Pointer(&data[0]), uintptr(len(data)))) +} + +func init() { + if cpu.X86.HasAVX2 { + SumFnc = SumAVX2 + } +} diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64.s b/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64.s new file mode 100644 index 00000000..100820ba --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64.s @@ -0,0 +1,140 @@ +#include "textflag.h" + +DATA endian_swap_mask<>+0(SB)/8, $0x607040502030001 +DATA endian_swap_mask<>+8(SB)/8, $0xE0F0C0D0A0B0809 +DATA endian_swap_mask<>+16(SB)/8, $0x607040502030001 +DATA endian_swap_mask<>+24(SB)/8, $0xE0F0C0D0A0B0809 +GLOBL endian_swap_mask<>(SB), RODATA, $32 + +// func sumAsmAvx2(data unsafe.Pointer, length uintptr) uintptr +// +// args (8 bytes aligned): +// data unsafe.Pointer - 8 bytes - 0 offset +// length uintptr - 8 bytes - 8 offset +// result uintptr - 8 bytes - 16 offset +#define PDATA AX +#define LENGTH CX +#define RESULT BX +TEXT ·sumAsmAvx2(SB),NOSPLIT,$0-24 + MOVQ data+0(FP), PDATA + MOVQ length+8(FP), LENGTH + XORQ RESULT, RESULT + +#define VSUM Y0 +#define ENDIAN_SWAP_MASK Y1 +BEGIN: + VMOVDQU endian_swap_mask<>(SB), ENDIAN_SWAP_MASK + VPXOR VSUM, VSUM, VSUM + +#define LOADED_0 Y2 +#define LOADED_1 Y3 +#define LOADED_2 Y4 +#define LOADED_3 Y5 +BATCH_64: + CMPQ LENGTH, $64 + JB BATCH_32 + VPMOVZXWD (PDATA), LOADED_0 + VPMOVZXWD 16(PDATA), LOADED_1 + VPMOVZXWD 32(PDATA), LOADED_2 + VPMOVZXWD 48(PDATA), LOADED_3 + VPSHUFB ENDIAN_SWAP_MASK, LOADED_0, LOADED_0 + VPSHUFB ENDIAN_SWAP_MASK, LOADED_1, LOADED_1 + VPSHUFB ENDIAN_SWAP_MASK, LOADED_2, LOADED_2 + VPSHUFB ENDIAN_SWAP_MASK, LOADED_3, LOADED_3 + VPADDD LOADED_0, VSUM, VSUM + VPADDD LOADED_1, VSUM, VSUM + VPADDD LOADED_2, VSUM, VSUM + VPADDD LOADED_3, VSUM, VSUM + ADDQ $-64, LENGTH + ADDQ $64, PDATA + JMP BATCH_64 +#undef LOADED_0 +#undef LOADED_1 +#undef LOADED_2 +#undef LOADED_3 + +#define LOADED_0 Y2 +#define LOADED_1 Y3 +BATCH_32: + CMPQ LENGTH, $32 + JB BATCH_16 + VPMOVZXWD (PDATA), LOADED_0 + VPMOVZXWD 16(PDATA), LOADED_1 + VPSHUFB ENDIAN_SWAP_MASK, LOADED_0, LOADED_0 + VPSHUFB ENDIAN_SWAP_MASK, LOADED_1, LOADED_1 + VPADDD LOADED_0, VSUM, VSUM + VPADDD LOADED_1, VSUM, VSUM + ADDQ $-32, LENGTH + ADDQ $32, PDATA + JMP BATCH_32 +#undef LOADED_0 +#undef LOADED_1 + +#define LOADED Y2 +BATCH_16: + CMPQ LENGTH, $16 + JB COLLECT + VPMOVZXWD (PDATA), LOADED + VPSHUFB ENDIAN_SWAP_MASK, LOADED, LOADED + VPADDD LOADED, VSUM, VSUM + ADDQ $-16, LENGTH + ADDQ $16, PDATA + JMP BATCH_16 +#undef LOADED + +#define EXTRACTED Y2 +#define EXTRACTED_128 X2 +#define TEMP_64 DX +COLLECT: + VEXTRACTI128 $0, VSUM, EXTRACTED_128 + VPEXTRD $0, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT + VPEXTRD $1, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT + VPEXTRD $2, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT + VPEXTRD $3, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT + VEXTRACTI128 $1, VSUM, EXTRACTED_128 + VPEXTRD $0, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT + VPEXTRD $1, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT + VPEXTRD $2, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT + VPEXTRD $3, EXTRACTED_128, TEMP_64 + ADDL TEMP_64, RESULT +#undef EXTRACTED +#undef EXTRACTED_128 +#undef TEMP_64 + +#define TEMP DX +#define TEMP2 SI +BATCH_2: + CMPQ LENGTH, $2 + JB BATCH_1 + XORQ TEMP, TEMP + MOVW (PDATA), TEMP + MOVQ TEMP, TEMP2 + SHRW $8, TEMP2 + SHLW $8, TEMP + ORW TEMP2, TEMP + ADDL TEMP, RESULT + ADDQ $-2, LENGTH + ADDQ $2, PDATA + JMP BATCH_2 +#undef TEMP + +#define TEMP DX +BATCH_1: + CMPQ LENGTH, $0 + JZ RETURN + XORQ TEMP, TEMP + MOVB (PDATA), TEMP + SHLW $8, TEMP + ADDL TEMP, RESULT +#undef TEMP + +RETURN: + MOVQ RESULT, result+16(FP) + RET diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64_test.go b/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64_test.go new file mode 100644 index 00000000..7133845a --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_amd64_test.go @@ -0,0 +1,51 @@ +package tcpip + +import ( + "crypto/rand" + "testing" + + "golang.org/x/sys/cpu" +) + +func Test_SumAVX2(t *testing.T) { + if !cpu.X86.HasAVX2 { + t.Skipf("AVX2 unavailable") + } + + bytes := make([]byte, chunkSize) + + for size := 0; size <= chunkSize; size++ { + for count := 0; count < chunkCount; count++ { + _, err := rand.Reader.Read(bytes[:size]) + if err != nil { + t.Skipf("Rand read failed: %v", err) + } + + compat := SumCompat(bytes[:size]) + avx := SumAVX2(bytes[:size]) + + if compat != avx { + t.Errorf("Sum of length=%d mismatched", size) + } + } + } +} + +func Benchmark_SumAVX2(b *testing.B) { + if !cpu.X86.HasAVX2 { + b.Skipf("AVX2 unavailable") + } + + bytes := make([]byte, chunkSize) + + _, err := rand.Reader.Read(bytes) + if err != nil { + b.Skipf("Rand read failed: %v", err) + } + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + SumAVX2(bytes) + } +} diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64.go b/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64.go new file mode 100644 index 00000000..c16c8fac --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64.go @@ -0,0 +1,24 @@ +package tcpip + +import ( + "unsafe" + + "golang.org/x/sys/cpu" +) + +//go:noescape +func sumAsmNeon(data unsafe.Pointer, length uintptr) uintptr + +func SumNeon(data []byte) uint32 { + if len(data) == 0 { + return 0 + } + + return uint32(sumAsmNeon(unsafe.Pointer(&data[0]), uintptr(len(data)))) +} + +func init() { + if cpu.ARM64.HasASIMD { + SumFnc = SumNeon + } +} diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64.s b/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64.s new file mode 100644 index 00000000..f6d57cf0 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64.s @@ -0,0 +1,118 @@ +#include "textflag.h" + +// func sumAsmNeon(data unsafe.Pointer, length uintptr) uintptr +// +// args (8 bytes aligned): +// data unsafe.Pointer - 8 bytes - 0 offset +// length uintptr - 8 bytes - 8 offset +// result uintptr - 8 bytes - 16 offset +#define PDATA R0 +#define LENGTH R1 +#define RESULT R2 +#define VSUM V0 +TEXT ·sumAsmNeon(SB),NOSPLIT,$0-24 + MOVD data+0(FP), PDATA + MOVD length+8(FP), LENGTH + MOVD $0, RESULT + VMOVQ $0, $0, VSUM + +#define LOADED_0 V1 +#define LOADED_1 V2 +#define LOADED_2 V3 +#define LOADED_3 V4 +BATCH_32: + CMP $32, LENGTH + BLO BATCH_16 + VLD1 (PDATA), [LOADED_0.B8, LOADED_1.B8, LOADED_2.B8, LOADED_3.B8] + VREV16 LOADED_0.B8, LOADED_0.B8 + VREV16 LOADED_1.B8, LOADED_1.B8 + VREV16 LOADED_2.B8, LOADED_2.B8 + VREV16 LOADED_3.B8, LOADED_3.B8 + VUSHLL $0, LOADED_0.H4, LOADED_0.S4 + VUSHLL $0, LOADED_1.H4, LOADED_1.S4 + VUSHLL $0, LOADED_2.H4, LOADED_2.S4 + VUSHLL $0, LOADED_3.H4, LOADED_3.S4 + VADD LOADED_0.S4, VSUM.S4, VSUM.S4 + VADD LOADED_1.S4, VSUM.S4, VSUM.S4 + VADD LOADED_2.S4, VSUM.S4, VSUM.S4 + VADD LOADED_3.S4, VSUM.S4, VSUM.S4 + ADD $-32, LENGTH + ADD $32, PDATA + B BATCH_32 +#undef LOADED_0 +#undef LOADED_1 +#undef LOADED_2 +#undef LOADED_3 + +#define LOADED_0 V1 +#define LOADED_1 V2 +BATCH_16: + CMP $16, LENGTH + BLO BATCH_8 + VLD1 (PDATA), [LOADED_0.B8, LOADED_1.B8] + VREV16 LOADED_0.B8, LOADED_0.B8 + VREV16 LOADED_1.B8, LOADED_1.B8 + VUSHLL $0, LOADED_0.H4, LOADED_0.S4 + VUSHLL $0, LOADED_1.H4, LOADED_1.S4 + VADD LOADED_0.S4, VSUM.S4, VSUM.S4 + VADD LOADED_1.S4, VSUM.S4, VSUM.S4 + ADD $-16, LENGTH + ADD $16, PDATA + B BATCH_16 +#undef LOADED_0 +#undef LOADED_1 + +#define LOADED_0 V1 +BATCH_8: + CMP $8, LENGTH + BLO BATCH_2 + VLD1 (PDATA), [LOADED_0.B8] + VREV16 LOADED_0.B8, LOADED_0.B8 + VUSHLL $0, LOADED_0.H4, LOADED_0.S4 + VADD LOADED_0.S4, VSUM.S4, VSUM.S4 + ADD $-8, LENGTH + ADD $8, PDATA + B BATCH_8 +#undef LOADED_0 + +#define LOADED_L R3 +#define LOADED_H R4 +BATCH_2: + CMP $2, LENGTH + BLO BATCH_1 + MOVBU (PDATA), LOADED_H + MOVBU 1(PDATA), LOADED_L + LSL $8, LOADED_H + ORR LOADED_H, LOADED_L, LOADED_L + ADD LOADED_L, RESULT, RESULT + ADD $2, PDATA + ADD $-2, LENGTH + B BATCH_2 +#undef LOADED_H +#undef LOADED_L + +#define LOADED R3 +BATCH_1: + CMP $1, LENGTH + BLO COLLECT + MOVBU (PDATA), LOADED + LSL $8, LOADED + ADD LOADED, RESULT, RESULT + +#define EXTRACTED R3 +COLLECT: + VMOV VSUM.S[0], EXTRACTED + ADD EXTRACTED, RESULT + VMOV VSUM.S[1], EXTRACTED + ADD EXTRACTED, RESULT + VMOV VSUM.S[2], EXTRACTED + ADD EXTRACTED, RESULT + VMOV VSUM.S[3], EXTRACTED + ADD EXTRACTED, RESULT +#undef VSUM +#undef PDATA +#undef LENGTH + +RETURN: + MOVD RESULT, result+16(FP) + RET diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64_test.go b/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64_test.go new file mode 100644 index 00000000..131a8266 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_arm64_test.go @@ -0,0 +1,51 @@ +package tcpip + +import ( + "crypto/rand" + "testing" + + "golang.org/x/sys/cpu" +) + +func Test_SumNeon(t *testing.T) { + if !cpu.ARM64.HasASIMD { + t.Skipf("Neon unavailable") + } + + bytes := make([]byte, chunkSize) + + for size := 0; size <= chunkSize; size++ { + for count := 0; count < chunkCount; count++ { + _, err := rand.Reader.Read(bytes[:size]) + if err != nil { + t.Skipf("Rand read failed: %v", err) + } + + compat := SumCompat(bytes[:size]) + neon := sumNeon(bytes[:size]) + + if compat != neon { + t.Errorf("Sum of length=%d mismatched", size) + } + } + } +} + +func Benchmark_SumNeon(b *testing.B) { + if !cpu.ARM64.HasASIMD { + b.Skipf("Neon unavailable") + } + + bytes := make([]byte, chunkSize) + + _, err := rand.Reader.Read(bytes) + if err != nil { + b.Skipf("Rand read failed: %v", err) + } + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + sumNeon(bytes) + } +} diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_compat.go b/listener/tun/ipstack/system/mars/tcpip/tcpip_compat.go new file mode 100644 index 00000000..0b9dbb01 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_compat.go @@ -0,0 +1,14 @@ +package tcpip + +func SumCompat(b []byte) (sum uint32) { + n := len(b) + if n&1 != 0 { + n-- + sum += uint32(b[n]) << 8 + } + + for i := 0; i < n; i += 2 { + sum += (uint32(b[i]) << 8) | uint32(b[i+1]) + } + return +} diff --git a/listener/tun/ipstack/system/mars/tcpip/tcpip_compat_test.go b/listener/tun/ipstack/system/mars/tcpip/tcpip_compat_test.go new file mode 100644 index 00000000..f8595aa5 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/tcpip_compat_test.go @@ -0,0 +1,26 @@ +package tcpip + +import ( + "crypto/rand" + "testing" +) + +const ( + chunkSize = 9000 + chunkCount = 10 +) + +func Benchmark_SumCompat(b *testing.B) { + bytes := make([]byte, chunkSize) + + _, err := rand.Reader.Read(bytes) + if err != nil { + b.Skipf("Rand read failed: %v", err) + } + + b.ResetTimer() + + for i := 0; i < b.N; i++ { + SumCompat(bytes) + } +} diff --git a/listener/tun/ipstack/system/mars/tcpip/udp.go b/listener/tun/ipstack/system/mars/tcpip/udp.go new file mode 100644 index 00000000..d2cb7f46 --- /dev/null +++ b/listener/tun/ipstack/system/mars/tcpip/udp.go @@ -0,0 +1,55 @@ +package tcpip + +import ( + "encoding/binary" +) + +const UDPHeaderSize = 8 + +type UDPPacket []byte + +func (p UDPPacket) Length() uint16 { + return binary.BigEndian.Uint16(p[4:]) +} + +func (p UDPPacket) SetLength(length uint16) { + binary.BigEndian.PutUint16(p[4:], length) +} + +func (p UDPPacket) SourcePort() uint16 { + return binary.BigEndian.Uint16(p) +} + +func (p UDPPacket) SetSourcePort(port uint16) { + binary.BigEndian.PutUint16(p, port) +} + +func (p UDPPacket) DestinationPort() uint16 { + return binary.BigEndian.Uint16(p[2:]) +} + +func (p UDPPacket) SetDestinationPort(port uint16) { + binary.BigEndian.PutUint16(p[2:], port) +} + +func (p UDPPacket) Payload() []byte { + return p[UDPHeaderSize:p.Length()] +} + +func (p UDPPacket) Checksum() uint16 { + return binary.BigEndian.Uint16(p[6:]) +} + +func (p UDPPacket) SetChecksum(sum [2]byte) { + p[6] = sum[0] + p[7] = sum[1] +} + +func (p UDPPacket) ResetChecksum(psum uint32) { + p.SetChecksum(zeroChecksum) + p.SetChecksum(Checksum(psum, p)) +} + +func (p UDPPacket) Valid() bool { + return len(p) >= UDPHeaderSize && uint16(len(p)) >= p.Length() +} diff --git a/listener/tun/ipstack/system/stack.go b/listener/tun/ipstack/system/stack.go index a22c9301..693d7f2f 100644 --- a/listener/tun/ipstack/system/stack.go +++ b/listener/tun/ipstack/system/stack.go @@ -15,10 +15,9 @@ import ( "github.com/Dreamacro/clash/listener/tun/device" "github.com/Dreamacro/clash/listener/tun/ipstack" D "github.com/Dreamacro/clash/listener/tun/ipstack/commons" + "github.com/Dreamacro/clash/listener/tun/ipstack/system/mars" "github.com/Dreamacro/clash/log" "github.com/Dreamacro/clash/transport/socks5" - - "github.com/Kr328/tun2socket" ) type sysStack struct { @@ -42,7 +41,7 @@ func New(device device.Device, dnsHijack []netip.AddrPort, tunAddress netip.Pref portal := tunAddress.Addr() gateway := portal - stack, err := tun2socket.StartTun2Socket(device, gateway, portal) + stack, err := mars.StartListener(device, gateway, portal) if err != nil { _ = device.Close() @@ -66,18 +65,18 @@ func New(device device.Device, dnsHijack []netip.AddrPort, tunAddress netip.Pref lAddr := conn.LocalAddr().(*net.TCPAddr) rAddr := conn.RemoteAddr().(*net.TCPAddr) - addrIp, _ := netip.AddrFromSlice(rAddr.IP) - addrPort := netip.AddrPortFrom(addrIp, uint16(rAddr.Port)) + rAddrIp, _ := netip.AddrFromSlice(rAddr.IP) + rAddrPort := netip.AddrPortFrom(rAddrIp, uint16(rAddr.Port)) - if ipv4LoopBack.Contains(addrIp) { + if ipv4LoopBack.Contains(rAddrIp) { conn.Close() continue } - if D.ShouldHijackDns(dnsAddr, addrPort) { + if D.ShouldHijackDns(dnsAddr, rAddrPort) { go func() { - log.Debugln("[TUN] hijack dns tcp: %s", addrPort.String()) + log.Debugln("[TUN] hijack dns tcp: %s", rAddrPort.String()) defer conn.Close() @@ -144,16 +143,16 @@ func New(device device.Device, dnsHijack []netip.AddrPort, tunAddress netip.Pref lAddr := lRAddr.(*net.UDPAddr) rAddr := rRAddr.(*net.UDPAddr) - addrIp, _ := netip.AddrFromSlice(rAddr.IP) - addrPort := netip.AddrPortFrom(addrIp, uint16(rAddr.Port)) + rAddrIp, _ := netip.AddrFromSlice(rAddr.IP) + rAddrPort := netip.AddrPortFrom(rAddrIp, uint16(rAddr.Port)) - if ipv4LoopBack.Contains(addrIp) { + if ipv4LoopBack.Contains(rAddrIp) { pool.Put(buf) continue } - if D.ShouldHijackDns(dnsAddr, addrPort) { + if D.ShouldHijackDns(dnsAddr, rAddrPort) { go func() { defer pool.Put(buf) @@ -164,7 +163,7 @@ func New(device device.Device, dnsHijack []netip.AddrPort, tunAddress netip.Pref _, _ = stack.UDP().WriteTo(msg, rAddr, lAddr) - log.Debugln("[TUN] hijack dns udp: %s", addrPort.String()) + log.Debugln("[TUN] hijack dns udp: %s", rAddrPort.String()) }() continue diff --git a/rule/base.go b/rule/base.go index beee7797..94513cd9 100644 --- a/rule/base.go +++ b/rule/base.go @@ -14,6 +14,22 @@ var ( noResolve = "no-resolve" ) +type Base struct { + ruleExtra *C.RuleExtra +} + +func (b *Base) RuleExtra() *C.RuleExtra { + return b.ruleExtra +} + +func (b *Base) SetRuleExtra(re *C.RuleExtra) { + b.ruleExtra = re +} + +func (b *Base) ShouldFindProcess() bool { + return false +} + func HasNoResolve(params []string) bool { for _, p := range params { if p == noResolve { diff --git a/rule/domain.go b/rule/domain.go index 42281b5d..f68427a2 100644 --- a/rule/domain.go +++ b/rule/domain.go @@ -7,9 +7,9 @@ import ( ) type Domain struct { - domain string - adapter string - ruleExtra *C.RuleExtra + *Base + domain string + adapter string } func (d *Domain) RuleType() C.RuleType { @@ -35,14 +35,12 @@ func (d *Domain) ShouldResolveIP() bool { return false } -func (d *Domain) RuleExtra() *C.RuleExtra { - return d.ruleExtra -} - -func NewDomain(domain string, adapter string, ruleExtra *C.RuleExtra) *Domain { +func NewDomain(domain string, adapter string) *Domain { return &Domain{ - domain: strings.ToLower(domain), - adapter: adapter, - ruleExtra: ruleExtra, + Base: &Base{}, + domain: strings.ToLower(domain), + adapter: adapter, } } + +var _ C.Rule = (*Domain)(nil) diff --git a/rule/domain_keyword.go b/rule/domain_keyword.go index 933e2524..720cc13c 100644 --- a/rule/domain_keyword.go +++ b/rule/domain_keyword.go @@ -7,9 +7,9 @@ import ( ) type DomainKeyword struct { - keyword string - adapter string - ruleExtra *C.RuleExtra + *Base + keyword string + adapter string } func (dk *DomainKeyword) RuleType() C.RuleType { @@ -36,14 +36,12 @@ func (dk *DomainKeyword) ShouldResolveIP() bool { return false } -func (dk *DomainKeyword) RuleExtra() *C.RuleExtra { - return dk.ruleExtra -} - -func NewDomainKeyword(keyword string, adapter string, ruleExtra *C.RuleExtra) *DomainKeyword { +func NewDomainKeyword(keyword string, adapter string) *DomainKeyword { return &DomainKeyword{ - keyword: strings.ToLower(keyword), - adapter: adapter, - ruleExtra: ruleExtra, + Base: &Base{}, + keyword: strings.ToLower(keyword), + adapter: adapter, } } + +var _ C.Rule = (*DomainKeyword)(nil) diff --git a/rule/domain_suffix.go b/rule/domain_suffix.go index 0ea4cea6..afb3969b 100644 --- a/rule/domain_suffix.go +++ b/rule/domain_suffix.go @@ -7,9 +7,9 @@ import ( ) type DomainSuffix struct { - suffix string - adapter string - ruleExtra *C.RuleExtra + *Base + suffix string + adapter string } func (ds *DomainSuffix) RuleType() C.RuleType { @@ -36,14 +36,12 @@ func (ds *DomainSuffix) ShouldResolveIP() bool { return false } -func (ds *DomainSuffix) RuleExtra() *C.RuleExtra { - return ds.ruleExtra -} - -func NewDomainSuffix(suffix string, adapter string, ruleExtra *C.RuleExtra) *DomainSuffix { +func NewDomainSuffix(suffix string, adapter string) *DomainSuffix { return &DomainSuffix{ - suffix: strings.ToLower(suffix), - adapter: adapter, - ruleExtra: ruleExtra, + Base: &Base{}, + suffix: strings.ToLower(suffix), + adapter: adapter, } } + +var _ C.Rule = (*DomainSuffix)(nil) diff --git a/rule/final.go b/rule/final.go index 532824b9..14965e5c 100644 --- a/rule/final.go +++ b/rule/final.go @@ -5,8 +5,8 @@ import ( ) type Match struct { - adapter string - ruleExtra *C.RuleExtra + *Base + adapter string } func (f *Match) RuleType() C.RuleType { @@ -29,16 +29,11 @@ func (f *Match) ShouldResolveIP() bool { return false } -func (f *Match) RuleExtra() *C.RuleExtra { - return f.ruleExtra +func NewMatch(adapter string) *Match { + return &Match{ + Base: &Base{}, + adapter: adapter, + } } -func NewMatch(adapter string, ruleExtra *C.RuleExtra) *Match { - if ruleExtra.SourceIPs == nil { - ruleExtra = nil - } - return &Match{ - adapter: adapter, - ruleExtra: ruleExtra, - } -} +var _ C.Rule = (*Match)(nil) diff --git a/rule/geoip.go b/rule/geoip.go index 86114acc..a5fccbaa 100644 --- a/rule/geoip.go +++ b/rule/geoip.go @@ -8,10 +8,10 @@ import ( ) type GEOIP struct { + *Base country string adapter string noResolveIP bool - ruleExtra *C.RuleExtra } func (g *GEOIP) RuleType() C.RuleType { @@ -48,21 +48,19 @@ func (g *GEOIP) ShouldResolveIP() bool { return !g.noResolveIP } -func (g *GEOIP) RuleExtra() *C.RuleExtra { - return g.ruleExtra -} - func (g *GEOIP) GetCountry() string { return g.country } -func NewGEOIP(country string, adapter string, noResolveIP bool, ruleExtra *C.RuleExtra) (*GEOIP, error) { +func NewGEOIP(country string, adapter string, noResolveIP bool) *GEOIP { geoip := &GEOIP{ + Base: &Base{}, country: country, adapter: adapter, noResolveIP: noResolveIP, - ruleExtra: ruleExtra, } - return geoip, nil + return geoip } + +var _ C.Rule = (*GEOIP)(nil) diff --git a/rule/geosite.go b/rule/geosite.go index 5c21761a..b765d643 100644 --- a/rule/geosite.go +++ b/rule/geosite.go @@ -11,10 +11,10 @@ import ( ) type GEOSITE struct { - country string - adapter string - ruleExtra *C.RuleExtra - matcher *router.DomainMatcher + *Base + country string + adapter string + matcher *router.DomainMatcher } func (gs *GEOSITE) RuleType() C.RuleType { @@ -42,15 +42,11 @@ func (gs *GEOSITE) ShouldResolveIP() bool { return false } -func (gs *GEOSITE) RuleExtra() *C.RuleExtra { - return gs.ruleExtra -} - func (gs *GEOSITE) GetDomainMatcher() *router.DomainMatcher { return gs.matcher } -func NewGEOSITE(country string, adapter string, ruleExtra *C.RuleExtra) (*GEOSITE, error) { +func NewGEOSITE(country string, adapter string) (*GEOSITE, error) { matcher, recordsCount, err := geodata.LoadGeoSiteMatcher(country) if err != nil { return nil, fmt.Errorf("load GeoSite data error, %s", err.Error()) @@ -59,11 +55,13 @@ func NewGEOSITE(country string, adapter string, ruleExtra *C.RuleExtra) (*GEOSIT log.Infoln("Start initial GeoSite rule %s => %s, records: %d", country, adapter, recordsCount) geoSite := &GEOSITE{ - country: country, - adapter: adapter, - ruleExtra: ruleExtra, - matcher: matcher, + Base: &Base{}, + country: country, + adapter: adapter, + matcher: matcher, } return geoSite, nil } + +var _ C.Rule = (*GEOSITE)(nil) diff --git a/rule/ipcidr.go b/rule/ipcidr.go index 8910110f..db55e465 100644 --- a/rule/ipcidr.go +++ b/rule/ipcidr.go @@ -21,9 +21,9 @@ func WithIPCIDRNoResolve(noResolve bool) IPCIDROption { } type IPCIDR struct { + *Base ipnet *net.IPNet adapter string - ruleExtra *C.RuleExtra isSourceIP bool noResolveIP bool } @@ -55,20 +55,16 @@ func (i *IPCIDR) ShouldResolveIP() bool { return !i.noResolveIP } -func (i *IPCIDR) RuleExtra() *C.RuleExtra { - return i.ruleExtra -} - -func NewIPCIDR(s string, adapter string, ruleExtra *C.RuleExtra, opts ...IPCIDROption) (*IPCIDR, error) { +func NewIPCIDR(s string, adapter string, opts ...IPCIDROption) (*IPCIDR, error) { _, ipnet, err := net.ParseCIDR(s) if err != nil { return nil, errPayload } ipcidr := &IPCIDR{ - ipnet: ipnet, - adapter: adapter, - ruleExtra: ruleExtra, + Base: &Base{}, + ipnet: ipnet, + adapter: adapter, } for _, o := range opts { @@ -77,3 +73,5 @@ func NewIPCIDR(s string, adapter string, ruleExtra *C.RuleExtra, opts ...IPCIDRO return ipcidr, nil } + +var _ C.Rule = (*IPCIDR)(nil) diff --git a/rule/parser.go b/rule/parser.go index bfd056e1..3374108e 100644 --- a/rule/parser.go +++ b/rule/parser.go @@ -12,40 +12,48 @@ func ParseRule(tp, payload, target string, params []string) (C.Rule, error) { parsed C.Rule ) + switch tp { + case "DOMAIN": + parsed = NewDomain(payload, target) + case "DOMAIN-SUFFIX": + parsed = NewDomainSuffix(payload, target) + case "DOMAIN-KEYWORD": + parsed = NewDomainKeyword(payload, target) + case "GEOSITE": + parsed, parseErr = NewGEOSITE(payload, target) + case "GEOIP": + noResolve := HasNoResolve(params) + parsed = NewGEOIP(payload, target, noResolve) + case "IP-CIDR", "IP-CIDR6": + noResolve := HasNoResolve(params) + parsed, parseErr = NewIPCIDR(payload, target, WithIPCIDRNoResolve(noResolve)) + case "SRC-IP-CIDR": + parsed, parseErr = NewIPCIDR(payload, target, WithIPCIDRSourceIP(true), WithIPCIDRNoResolve(true)) + case "SRC-PORT": + parsed, parseErr = NewPort(payload, target, true) + case "DST-PORT": + parsed, parseErr = NewPort(payload, target, false) + case "PROCESS-NAME": + parsed, parseErr = NewProcess(payload, target, true) + case "PROCESS-PATH": + parsed, parseErr = NewProcess(payload, target, false) + case "MATCH": + parsed = NewMatch(target) + default: + parseErr = fmt.Errorf("unsupported rule type %s", tp) + } + + if parseErr != nil { + return nil, parseErr + } + ruleExtra := &C.RuleExtra{ Network: findNetwork(params), SourceIPs: findSourceIPs(params), ProcessNames: findProcessName(params), } - switch tp { - case "DOMAIN": - parsed = NewDomain(payload, target, ruleExtra) - case "DOMAIN-SUFFIX": - parsed = NewDomainSuffix(payload, target, ruleExtra) - case "DOMAIN-KEYWORD": - parsed = NewDomainKeyword(payload, target, ruleExtra) - case "GEOSITE": - parsed, parseErr = NewGEOSITE(payload, target, ruleExtra) - case "GEOIP": - noResolve := HasNoResolve(params) - parsed, parseErr = NewGEOIP(payload, target, noResolve, ruleExtra) - case "IP-CIDR", "IP-CIDR6": - noResolve := HasNoResolve(params) - parsed, parseErr = NewIPCIDR(payload, target, ruleExtra, WithIPCIDRNoResolve(noResolve)) - case "SRC-IP-CIDR": - parsed, parseErr = NewIPCIDR(payload, target, ruleExtra, WithIPCIDRSourceIP(true), WithIPCIDRNoResolve(true)) - case "SRC-PORT": - parsed, parseErr = NewPort(payload, target, true, ruleExtra) - case "DST-PORT": - parsed, parseErr = NewPort(payload, target, false, ruleExtra) - case "PROCESS-NAME": - parsed, parseErr = NewProcess(payload, target, ruleExtra) - case "MATCH": - parsed = NewMatch(target, ruleExtra) - default: - parseErr = fmt.Errorf("unsupported rule type %s", tp) - } + parsed.SetRuleExtra(ruleExtra) - return parsed, parseErr + return parsed, nil } diff --git a/rule/port.go b/rule/port.go index 70e5abfb..298afe83 100644 --- a/rule/port.go +++ b/rule/port.go @@ -14,11 +14,11 @@ type portReal struct { } type Port struct { - adapter string - port string - isSource bool - portList []portReal - ruleExtra *C.RuleExtra + *Base + adapter string + port string + isSource bool + portList []portReal } func (p *Port) RuleType() C.RuleType { @@ -47,10 +47,6 @@ func (p *Port) ShouldResolveIP() bool { return false } -func (p *Port) RuleExtra() *C.RuleExtra { - return p.ruleExtra -} - func (p *Port) matchPortReal(portRef string) bool { port, _ := strconv.Atoi(portRef) var rs bool @@ -67,7 +63,7 @@ func (p *Port) matchPortReal(portRef string) bool { return false } -func NewPort(port string, adapter string, isSource bool, ruleExtra *C.RuleExtra) (*Port, error) { +func NewPort(port string, adapter string, isSource bool) (*Port, error) { ports := strings.Split(port, "/") if len(ports) > 28 { return nil, fmt.Errorf("%s, too many ports to use, maximum support 28 ports", errPayload.Error()) @@ -85,24 +81,25 @@ func NewPort(port string, adapter string, isSource bool, ruleExtra *C.RuleExtra) return nil, errPayload } - portStart, err := strconv.Atoi(strings.Trim(subPorts[0], "[ ]")) - if err != nil || portStart < 0 || portStart > 65535 { + portStart, err := strconv.ParseUint(strings.Trim(subPorts[0], "[ ]"), 10, 16) + if err != nil { return nil, errPayload } - if subPortsLen == 1 { - portList = append(portList, portReal{portStart, -1}) - } else if subPortsLen == 2 { - portEnd, err1 := strconv.Atoi(strings.Trim(subPorts[1], "[ ]")) - if err1 != nil || portEnd < 0 || portEnd > 65535 { + switch subPortsLen { + case 1: + portList = append(portList, portReal{int(portStart), -1}) + case 2: + portEnd, err := strconv.ParseUint(strings.Trim(subPorts[1], "[ ]"), 10, 16) + if err != nil { return nil, errPayload } shouldReverse := portStart > portEnd if shouldReverse { - portList = append(portList, portReal{portEnd, portStart}) + portList = append(portList, portReal{int(portEnd), int(portStart)}) } else { - portList = append(portList, portReal{portStart, portEnd}) + portList = append(portList, portReal{int(portStart), int(portEnd)}) } } } @@ -112,10 +109,12 @@ func NewPort(port string, adapter string, isSource bool, ruleExtra *C.RuleExtra) } return &Port{ - adapter: adapter, - port: port, - isSource: isSource, - portList: portList, - ruleExtra: ruleExtra, + Base: &Base{}, + adapter: adapter, + port: port, + isSource: isSource, + portList: portList, }, nil } + +var _ C.Rule = (*Port)(nil) diff --git a/rule/process.go b/rule/process.go index e5ad07bd..b8b8f7c9 100644 --- a/rule/process.go +++ b/rule/process.go @@ -1,27 +1,16 @@ package rules import ( - "fmt" - "net" - "strconv" "strings" - "github.com/Dreamacro/clash/common/cache" - "github.com/Dreamacro/clash/component/process" C "github.com/Dreamacro/clash/constant" - "github.com/Dreamacro/clash/log" -) - -var ( - processCache = cache.NewLRUCache(cache.WithAge(2), cache.WithSize(64)) - - localIPs = getLocalIPs() ) type Process struct { - adapter string - process string - ruleExtra *C.RuleExtra + *Base + adapter string + process string + nameOnly bool } func (ps *Process) RuleType() C.RuleType { @@ -29,37 +18,11 @@ func (ps *Process) RuleType() C.RuleType { } func (ps *Process) Match(metadata *C.Metadata) bool { - if metadata.Process != "" { + if ps.nameOnly { return strings.EqualFold(metadata.Process, ps.process) } - // ignore source IP not on local machine - if !isLocalIP(metadata.SrcIP) { - return false - } - - key := fmt.Sprintf("%s:%s:%s", metadata.NetWork.String(), metadata.SrcIP.String(), metadata.SrcPort) - cached, hit := processCache.Get(key) - if !hit { - srcPort, err := strconv.Atoi(metadata.SrcPort) - if err != nil { - processCache.Set(key, "") - return false - } - - name, err := process.FindProcessName(metadata.NetWork.String(), metadata.SrcIP, srcPort) - if err != nil { - log.Debugln("[Rule] find process name %s error: %s", C.Process.String(), err.Error()) - } - - processCache.Set(key, name) - - cached = name - } - - metadata.Process = cached.(string) - - return strings.EqualFold(metadata.Process, ps.process) + return strings.EqualFold(metadata.ProcessPath, ps.process) } func (ps *Process) Adapter() string { @@ -74,46 +37,17 @@ func (ps *Process) ShouldResolveIP() bool { return false } -func (ps *Process) RuleExtra() *C.RuleExtra { - return ps.ruleExtra +func (ps *Process) ShouldFindProcess() bool { + return true } -func NewProcess(process string, adapter string, ruleExtra *C.RuleExtra) (*Process, error) { +func NewProcess(process string, adapter string, nameOnly bool) (*Process, error) { return &Process{ - adapter: adapter, - process: process, - ruleExtra: ruleExtra, + Base: &Base{}, + adapter: adapter, + process: process, + nameOnly: nameOnly, }, nil } -func getLocalIPs() []net.IP { - ips := []net.IP{net.IPv4(198, 18, 0, 1), net.IPv4zero, net.IPv6zero} - - netInterfaces, err := net.Interfaces() - if err != nil { - return ips - } - - for i := 0; i < len(netInterfaces); i++ { - if (netInterfaces[i].Flags & net.FlagUp) != 0 { - adds, _ := netInterfaces[i].Addrs() - - for _, address := range adds { - if ipNet, ok := address.(*net.IPNet); ok { - ips = append(ips, ipNet.IP) - } - } - } - } - - return ips -} - -func isLocalIP(srcIP net.IP) bool { - for _, ip := range localIPs { - if ip.Equal(srcIP) { - return true - } - } - return false -} +var _ C.Rule = (*Process)(nil) diff --git a/test/go.mod b/test/go.mod index 15eb89cd..3edea504 100644 --- a/test/go.mod +++ b/test/go.mod @@ -1,6 +1,6 @@ module clash-test -go 1.17 +go 1.18 require ( github.com/Dreamacro/clash v1.7.2-0.20211108085948-bd2ea2b917aa @@ -15,7 +15,6 @@ replace github.com/Dreamacro/clash => ../ require ( github.com/Dreamacro/go-shadowsocks2 v0.1.7 // indirect - github.com/Kr328/tun2socket v0.0.0-20211231120722-962f339492e8 // indirect github.com/Microsoft/go-winio v0.5.1 // indirect github.com/containerd/containerd v1.5.8 // indirect github.com/davecgh/go-spew v1.1.1 // indirect diff --git a/test/go.sum b/test/go.sum index 3bbd0fd6..d3ff53ad 100644 --- a/test/go.sum +++ b/test/go.sum @@ -1,5 +1,4 @@ bazil.org/fuse v0.0.0-20160811212531-371fbbdaa898/go.mod h1:Xbm+BRKSBEpa4q4hTSxohYNQpsxXPbPry4JJWOB3LB8= -bazil.org/fuse v0.0.0-20200407214033-5883e5a4b512/go.mod h1:FbcW6z/2VytnFDhZfumh8Ss8zxHE6qpMP5sHTRe0EaM= cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= @@ -11,27 +10,17 @@ cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6T cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= -cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk= -cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs= -cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc= -cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= -cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg= -cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc= -cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ= cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= -cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU= cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk= -cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs= -cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0= dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= github.com/Azure/azure-sdk-for-go v16.2.1+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc= github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= @@ -39,27 +28,18 @@ github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOEl github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E= github.com/Azure/go-autorest v10.8.1+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24= github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24= -github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI= github.com/Azure/go-autorest/autorest v0.11.1/go.mod h1:JFgpikqFJ/MleTTxwepExTKnFUKKszPS8UavbQYUMuw= -github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0= github.com/Azure/go-autorest/autorest/adal v0.9.0/go.mod h1:/c022QCutn2P7uY+/oQWWNcK9YU+MH96NgK+jErpbcg= github.com/Azure/go-autorest/autorest/adal v0.9.5/go.mod h1:B7KF7jKIeC9Mct5spmyCB/A8CG/sEz1vwIRGv/bbw7A= -github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA= github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74= -github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= -github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= github.com/Azure/go-autorest/autorest/mocks v0.4.0/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k= github.com/Azure/go-autorest/autorest/mocks v0.4.1/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k= -github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc= github.com/Azure/go-autorest/logger v0.2.0/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= -github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk= github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/Dreamacro/go-shadowsocks2 v0.1.7 h1:8CtbE1HoPPMfrQZGXmlluq6dO2lL31W6WRRE8fabc4Q= github.com/Dreamacro/go-shadowsocks2 v0.1.7/go.mod h1:8p5G4cAj5ZlXwUR+Ww63gfSikr8kvw8uw3TDwLAJpUc= -github.com/Kr328/tun2socket v0.0.0-20211231120722-962f339492e8 h1:4Ceb/pU/u7fKGMCE2DNrWIEHkoR1ELRlYJXzbFOR+E0= -github.com/Kr328/tun2socket v0.0.0-20211231120722-962f339492e8/go.mod h1:YR9wK13TgI5ww8iKWm91MHiSoHC7Oz0U4beCCmtXqLw= github.com/Microsoft/go-winio v0.4.11/go.mod h1:VhR8bwka0BXejwEJY73c50VrPtXAaKcyvVC4A4RozmA= github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA= github.com/Microsoft/go-winio v0.4.15-0.20190919025122-fc70bd9a86b5/go.mod h1:tTuCMEN+UleMWgg9dVx4Hu52b1bJo+59jBh3ajtinzw= @@ -82,9 +62,7 @@ github.com/Microsoft/hcsshim/test v0.0.0-20201218223536-d3e5debf77da/go.mod h1:5 github.com/Microsoft/hcsshim/test v0.0.0-20210227013316-43a75bb4edd3/go.mod h1:mw7qgWloBUl75W/gVH3cQszUg1+gUITj7D6NY7ywVnY= github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= -github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/Shopify/logrus-bugsnag v0.0.0-20171204204709-577dee27f20d/go.mod h1:HI8ITrYtUY+O+ZhtlqUnD8+KwNPOyugEhfP9fdUIaEQ= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= @@ -96,7 +74,6 @@ github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kd github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= github.com/aws/aws-sdk-go v1.15.11/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0= -github.com/bazelbuild/rules_go v0.30.0/go.mod h1:MC23Dc/wkXEyk3Wpq6lCqz0ZAYOZDw2DR5y3N1q2i7M= github.com/beorn7/perks v0.0.0-20160804104726-4c0e84591b9a/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= @@ -112,7 +89,6 @@ github.com/buger/jsonparser v0.0.0-20180808090653-f4dd9f5a6b44/go.mod h1:bbYlZJ7 github.com/bugsnag/bugsnag-go v0.0.0-20141110184014-b1d153021fcd/go.mod h1:2oa8nejYd4cQ/b0hMIopN0lCRxU0bueqREvZLWFrtK8= github.com/bugsnag/osext v0.0.0-20130617224835-0dd3f918b21b/go.mod h1:obH5gd0BsqsP2LwDJ9aOkm/6J86V6lyAXCoQWGw3K50= github.com/bugsnag/panicwrap v0.0.0-20151223152923-e2c28503fcd0/go.mod h1:D/8v3kj0zr8ZAKg1AQ6crr+5VwKN5eIywRkfhyM/+dE= -github.com/cenkalti/backoff v1.1.1-0.20190506075156-2146c9339422/go.mod h1:b6Nc7NRH5C4aCISLry0tLnTjcuTEvoiqcWDdsU0sOGM= github.com/cenkalti/backoff/v4 v4.1.1/go.mod h1:scbssz8iZGpm3xbr14ovlUdkxfGXNInqkPWOWmG2CLw= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= @@ -160,7 +136,6 @@ github.com/containerd/containerd v1.3.0-beta.2.0.20190828155532-0293cbd26c69/go. github.com/containerd/containerd v1.3.0/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.3.1-0.20191213020239-082f7e3aed57/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.3.2/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= -github.com/containerd/containerd v1.3.9/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.4.0-beta.2.0.20200729163537-40b22ef07410/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.4.1/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= github.com/containerd/containerd v1.4.3/go.mod h1:bC6axHOhabU15QhwfG7w5PipXdVtMXFTttgp+kVtyUA= @@ -178,7 +153,6 @@ github.com/containerd/continuity v0.0.0-20200710164510-efbc4488d8fe/go.mod h1:cE github.com/containerd/continuity v0.0.0-20201208142359-180525291bb7/go.mod h1:kR3BEg7bDFaEddKm54WSmrol1fKWDU1nKYkgrcgZT7Y= github.com/containerd/continuity v0.0.0-20210208174643-50096c924a4e/go.mod h1:EXlVlkqNba9rJe3j7w3Xa924itAMLgZH4UD/Q4PExuQ= github.com/containerd/continuity v0.1.0/go.mod h1:ICJu0PwR54nI0yPEnJ6jcS+J7CZAUXrLh8lPo2knzsM= -github.com/containerd/continuity v0.2.1/go.mod h1:wCYX+dRqZdImhGucXOqTQn05AhX6EUDaGEMUzTFFpLg= github.com/containerd/fifo v0.0.0-20180307165137-3d5202aec260/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI= github.com/containerd/fifo v0.0.0-20190226154929-a9fb20d87448/go.mod h1:ODA38xgv3Kuk8dQz2ZQXpnv/UZZUHUCL7pnLehbXgQI= github.com/containerd/fifo v0.0.0-20200410184934-f15a3290365b/go.mod h1:jPQ2IAeZRCYxpS/Cm1495vGFww6ecHmMk1YJH2Q5ln0= @@ -246,7 +220,6 @@ github.com/d2g/dhcp4 v0.0.0-20170904100407-a1d1b6c41b1c/go.mod h1:Ct2BUK8SB0YC1S github.com/d2g/dhcp4client v1.0.0/go.mod h1:j0hNfjhrt2SxUOw55nL0ATM/z4Yt3t2Kd1mW34z5W5s= github.com/d2g/dhcp4server v0.0.0-20181031114812-7d4a0a7f59a5/go.mod h1:Eo87+Kg/IX2hfWJfwxMzLyuSZyxSoAug2nGa1G2QAi8= github.com/d2g/hardwareaddr v0.0.0-20190221164911-e7d9fbe030e4/go.mod h1:bMl4RjIciD2oAxI7DmWRx6gbeqrkoLqv3MV0vzNad+I= -github.com/davecgh/go-spew v0.0.0-20151105211317-5215b55f46b2/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -274,7 +247,6 @@ github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZ github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= -github.com/elazarl/goproxy v0.0.0-20170405201442-c4fc26588b6e/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc= github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkgs4iZTTu3o/KG3Itv/qCCa8VVMlb3i9OVuzc= github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs= github.com/emicklei/go-restful v2.9.5+incompatible/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs= @@ -285,7 +257,6 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/evanphx/json-patch v4.2.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/fanliao/go-promise v0.0.0-20141029170127-1890db352a72/go.mod h1:PjfxuH4FZdUyfMdtBio2lsRr1AKEaVPwelzuHuh8Lqc= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= @@ -297,9 +268,6 @@ github.com/fullsailor/pkcs7 v0.0.0-20190404230743-d7302db945fa/go.mod h1:KnogPXt github.com/garyburd/redigo v0.0.0-20150301180006-535138d7bcd7/go.mod h1:NR3MbYisc3/PwhQ00EMzDiPmrwpPxAn5GI05/YaO1SY= github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/go-chi/chi/v5 v5.0.7/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8= -github.com/go-chi/cors v1.2.0/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vzc58= -github.com/go-chi/render v1.0.1/go.mod h1:pq4Rr7HbnsdaeHagklXub+p6Wd16Af5l9koip1OvJns= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= @@ -310,15 +278,11 @@ github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= -github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0= github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg= github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= -github.com/go-openapi/jsonreference v0.0.0-20160704190145-13c6e3589ad9/go.mod h1:W3Z9FmVs9qj+KR4zFKmDPGiLdk1D9Rlm7cyMvf57TTg= github.com/go-openapi/jsonreference v0.19.2/go.mod h1:jMjeRr2HHw6nAVajTXJ4eiUwohSTlpa0o73RUL1owJc= github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8= -github.com/go-openapi/spec v0.0.0-20160808142527-6aced65f8501/go.mod h1:J8+jY1nAiCcj+friV/PDoE1/3eeccG9LYBs0tYvLOWc= github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8Lj9mJglo= -github.com/go-openapi/swag v0.0.0-20160704191624-1d0bd113de87/go.mod h1:DXUve3Dpr1UfpPtxFw+EFuQ41HhCWZfha5jSVRG7C7I= github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= @@ -327,7 +291,6 @@ github.com/godbus/dbus v0.0.0-20180201030542-885f9cc04c9c/go.mod h1:/YcGZj5zSblf github.com/godbus/dbus v0.0.0-20190422162347-ade71ed3457e/go.mod h1:bBOAhwG1umN6/6ZUMtDFBMQR8jRg9O75tm9K00oMsK4= github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/gofrs/flock v0.8.0/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU= github.com/gofrs/uuid v4.2.0+incompatible h1:yyYWMnhkhrKwwr8gAOcOCYxOOscHgDS9yZgBrnJfGa0= github.com/gofrs/uuid v4.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= github.com/gogo/googleapis v1.2.0/go.mod h1:Njal3psf3qN6dwBtQfUmBZh2ybovJ0tlu3o/AC7HYjU= @@ -350,9 +313,6 @@ github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfb github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= -github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= -github.com/golang/protobuf v0.0.0-20161109072736-4bd1920723d7/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -378,39 +338,28 @@ github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5a github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= -github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/gofuzz v0.0.0-20161122191042-44d81051d367/go.mod h1:HP5RmnzzSNb993RKQDq4+1A4ia9nllfqcQFTQJedwGI= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= -github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= -github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= -github.com/google/subcommands v1.0.2-0.20190508160503-636abe8753b8/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= -github.com/googleapis/gnostic v0.0.0-20170729233727-0c5108395e2d/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY= -github.com/googleapis/gnostic v0.4.0/go.mod h1:on+2t9HRStVgn95RSsFWFz+6Q0Snyqv1awfrALZdbtU= github.com/googleapis/gnostic v0.4.1/go.mod h1:LRhVm6pbyptWbWbuZ38d1eyptfvIytN3ir6b65WBswg= -github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gorilla/handlers v0.0.0-20150720190736-60c7bfde3e33/go.mod h1:Qkdc/uu4tH4g6mTK6auzZ766c4CA0Ng8+o/OAirnOIQ= github.com/gorilla/mux v1.7.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs= @@ -432,7 +381,6 @@ github.com/hashicorp/errwrap v0.0.0-20141028054710-7554cd9344ce/go.mod h1:YH+1FK github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= github.com/hashicorp/go-multierror v0.0.0-20161216184304-ed905158d874/go.mod h1:JMRHfdO9jKNzS/+BTlxCjKNQHg/jZAft8U7LloJvN7I= github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= -github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= @@ -455,7 +403,6 @@ github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a/go.mod h1:Oz+ github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4/go.mod h1:WGuG/smIU4J/54PblvSbh+xvCZmpJnFgr3ds6Z55XMQ= github.com/jsimonetti/rtnetlink v0.0.0-20201009170750-9c6f07d100c1/go.mod h1:hqoO/u39cqLeBLebZ8fWdE96O7FxrAsRYhnVOdgHxok= github.com/jsimonetti/rtnetlink v0.0.0-20201110080708-d2c240429e6c/go.mod h1:huN4d1phzjhlOsNIjFsw2SVRbwIHj3fJDMEU2SDPTmg= -github.com/json-iterator/go v0.0.0-20180612202835-f2b4162afba3/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= @@ -478,19 +425,14 @@ github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfn github.com/kr/pretty v0.2.1 h1:Fmg33tUaq4/8ym9TJN1x7sLJnHVwhP33CNkpYV/7rwI= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/pty v1.1.4-0.20190131011033-7dc38fb350b1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= -github.com/lxn/walk v0.0.0-20210112085537-c389da54e794/go.mod h1:E23UucZGqpuUANJooIbHWCufXvOcT6E7Stq81gU+CSQ= -github.com/lxn/win v0.0.0-20210218163916-a377121e959e/go.mod h1:KxxjdtRkfNoYDCUP5ryK7XJJNTnpC8atvtmTheChOtk= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= -github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs= github.com/marstr/guid v1.1.0/go.mod h1:74gB1z2wpxxInTG6yaqA7KrtM0NZ+RbrcqDvYHefzho= -github.com/mattbaird/jsonpatch v0.0.0-20171005235357-81af80346b1a/go.mod h1:M1qoD/MqPgTZIk0EWKB38wE28ACRfVcn+cU08jyArI0= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= @@ -520,10 +462,8 @@ github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 h1:dcztxKSvZ4Id8iPpHERQB github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6/go.mod h1:E2VnQOmVuvZB6UYnnDB0qG5Nq/1tD9acaOpo6xmt0Kw= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/reflect2 v0.0.0-20180320133207-05fbef0ca5da/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/mohae/deepcopy v0.0.0-20170308212314-bb9b5e7adda9/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8= github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A= github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc= github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ= @@ -538,14 +478,12 @@ github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:v github.com/onsi/ginkgo v0.0.0-20151202141238-7f8ab55aaf3b/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/gomega v0.0.0-20151007035656-2152b45fa28a/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= github.com/onsi/gomega v0.0.0-20170829124025-dcabb60a477c/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA= -github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.10.3/go.mod h1:V9xEwhxec5O8UDM77eCW8vLymOMltsqPVYWrpDsH8xc= @@ -563,7 +501,6 @@ github.com/opencontainers/runc v0.0.0-20190115041553-12f6a991201f/go.mod h1:qT5X github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= github.com/opencontainers/runc v1.0.0-rc8.0.20190926000215-3e425f80a8c9/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= github.com/opencontainers/runc v1.0.0-rc9/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= -github.com/opencontainers/runc v1.0.0-rc90/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U= github.com/opencontainers/runc v1.0.0-rc93/go.mod h1:3NOsor4w32B2tC0Zbl8Knk4Wg84SM2ImC1fxBuqJ/H0= github.com/opencontainers/runc v1.0.2/go.mod h1:aTaHFFwQXuA71CiyxOdFFIorAoemI04suvGRQFzWTD0= github.com/opencontainers/runtime-spec v0.1.2-0.20190507144316-5b71a03e2700/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= @@ -572,7 +509,6 @@ github.com/opencontainers/runtime-spec v1.0.2-0.20190207185410-29686dbc5559/go.m github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/opencontainers/runtime-spec v1.0.3-0.20200929063507-e6143ca7d51d/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= -github.com/opencontainers/runtime-spec v1.0.3-0.20211123151946-c2389c3cb60a/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/opencontainers/runtime-tools v0.0.0-20181011054405-1d69bd0f9c39/go.mod h1:r3f7wjNzSs2extwzU3Y+6pKfobzPh+kKFJ3ofN+3nfs= github.com/opencontainers/selinux v1.6.0/go.mod h1:VVGKuOLlE7v4PJyT6h7mNWvq1rzqiriPsEqVhc+svHE= github.com/opencontainers/selinux v1.8.0/go.mod h1:RScLhm78qiWa2gbVCcGkC7tCGdgk3ogry1nUQF8Evvo= @@ -589,7 +525,6 @@ github.com/pkg/errors v0.8.1-0.20171018195549-f15c970de5b7/go.mod h1:bwawxfHBFNV github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pquerna/cachecontrol v0.0.0-20171018203845-0dec1b30a021/go.mod h1:prYjPmNq4d1NPVmpShWobRqXY3q7Vp+80DqgxxUrUIA= @@ -662,7 +597,6 @@ github.com/stretchr/objx v0.0.0-20180129172003-8a3f7159479f/go.mod h1:HFkY916IF+ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE= -github.com/stretchr/testify v0.0.0-20151208002404-e3a8ff8ce365/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v0.0.0-20180303142811-b89eecf5ca5d/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= @@ -677,7 +611,6 @@ github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG github.com/tchap/go-patricia v2.2.6+incompatible/go.mod h1:bmLyhP68RS6kStMGxByiQ23RP/odRBOTVjwp2cDyi6I= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= -github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c/go.mod h1:hzIxponao9Kjc7aWznkXaL4U4TWaDSs8zcsY4Ka08nM= github.com/u-root/uio v0.0.0-20210528114334-82958018845c h1:BFvcl34IGnw8yvJi8hlqLFo9EshRInwWBs2M5fGWzQA= github.com/u-root/uio v0.0.0-20210528114334-82958018845c/go.mod h1:LpEX5FO/cB+WF4TYGY1V5qktpaZLkKkSegbr0V4eYXA= github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= @@ -686,13 +619,11 @@ github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijb github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/vishvananda/netlink v0.0.0-20181108222139-023a6dafdcdf/go.mod h1:+SR5DhBJrl6ZM7CoCKvpw5BKroDKQ+PJqOg65H/2ktk= -github.com/vishvananda/netlink v1.0.1-0.20190930145447-2ec5bdc52b86/go.mod h1:+SR5DhBJrl6ZM7CoCKvpw5BKroDKQ+PJqOg65H/2ktk= github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE= github.com/vishvananda/netlink v1.1.1-0.20201029203352-d40f9887b852/go.mod h1:twkDnbuQxJYemMlGd4JFIcuhgX83tXhKS2B/PRMpOho= github.com/vishvananda/netns v0.0.0-20180720170159-13995c7128cc/go.mod h1:ZjcWmFBXmLKZu9Nxj3WKYEafiSqer2rnvPr0en9UNpI= github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU= github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0= -github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0= github.com/willf/bitset v1.1.11-0.20200630133818-d5bec3311243/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4= github.com/willf/bitset v1.1.11/go.mod h1:83CECat5yLh5zVOf4P1ErAgKA5UDvKtgyUABdr3+MjI= github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= @@ -702,13 +633,9 @@ github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= github.com/xtls/go v0.0.0-20210920065950-d4af136d3672 h1:4mkzGhKqt3JO1BWYjtD3iRFyAx4ow67hmSqOcGjuxqQ= github.com/xtls/go v0.0.0-20210920065950-d4af136d3672/go.mod h1:YGGVbz9cOxyKFUmhW7LGaLZaMA0cPlHJinvAmVxEMSU= -github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yuin/goldmark v1.4.0/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= github.com/yvasiyarov/go-metrics v0.0.0-20140926110328-57bccd1ccd43/go.mod h1:aX5oPXxHm3bOH+xeAttToC8pqch2ScQN/JoXYupl6xs= github.com/yvasiyarov/gorelic v0.0.0-20141212073537-a9bba5b9ab50/go.mod h1:NUSPSUX/bi6SeDMUh6brw0nXpxHnc96TguQh0+r/ssA= github.com/yvasiyarov/newrelic_platform_go v0.0.0-20140908184405-b21fdbd4370f/go.mod h1:GlGEuHIJweS1mbCqG+7vt2nvWLzLLnRHbXz5JKd/Qbg= @@ -723,35 +650,27 @@ go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= -go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE= go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -go.uber.org/automaxprocs v1.4.0/go.mod h1:/mTEdr7LvHhs0v7mjdxDreTz1OG5zdZGqgOnhWiR/+Q= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= golang.org/x/crypto v0.0.0-20171113213409-9f005a07e0d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181009213950-7c1a557ab941/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20200220183623-bac4c82f6975/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210317152858-513c2a44f670/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.0.0-20220131195533-30dcbda58838/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220214200702-86341886e292 h1:f+lwQ+GtmgoY+A2YaQxlSOnDjXcQ7ZRLWOHbC6HtRqE= golang.org/x/crypto v0.0.0-20220214200702-86341886e292/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -788,7 +707,6 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38= golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= -golang.org/x/net v0.0.0-20170114055629-f2499483f923/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -807,7 +725,6 @@ golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190619014844-b5b0513f8c1b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -820,11 +737,6 @@ golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLL golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= -golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= golang.org/x/net v0.0.0-20201006153459-a7d1128ccaa0/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= @@ -835,11 +747,6 @@ golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210805182204-aaa1db679c0d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211111083644-e5c967477495/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f h1:oA4XRj0qtSt8Yo1Zms0CUlsT3KG69V2UGQWPBxujDmc= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -847,26 +754,22 @@ golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4Iltr golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= -golang.org/x/oauth2 v0.0.0-20211005180243-6b3c2da341f1/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20170830134202-bb24a47a89ea/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190209173611-3b5209105503/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190411185658-b44545bcd369/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -886,7 +789,6 @@ golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190801041406-cbf593c0f2f3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190812073006-9eafafc0a87e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -912,15 +814,9 @@ golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200728102440-3e129f6d46b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200817155316-9781c653f443/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200916030750-2334cc1a136f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -928,7 +824,6 @@ golang.org/x/sys v0.0.0-20200922070232-aee5d888a860/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200923182605-d9f96fdee20d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201018230417-eeed37f84f13/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201101102859-da207088b7d1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201112073958-5cba982894dd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201117170446-d9b008d0a637/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -942,22 +837,11 @@ golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210525143221-35b2ab0089ea/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211110154304-99a53858aa08/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211116061358-0a5406a5449c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9 h1:nhht2DYV/Sn3qOayu8lM+cU1ii9sTLUeBQwQQfUHtrs= golang.org/x/sys v0.0.0-20220227234510-4e6760a101f9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/text v0.0.0-20160726164857-2910a502d2bf/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -966,7 +850,6 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8-0.20220124021120-d1c84af989ab h1:eHo2TTVBaAPw9lDGK2Gb9GyPMXT6g7O63W6sx3ylbzU= golang.org/x/text v0.3.8-0.20220124021120-d1c84af989ab/go.mod h1:EFNZuWvGYxIRUEX+K8UmCFwYmZjqcrnq15ZuVldZkZ0= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -978,7 +861,6 @@ golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11 h1:GZokNIeuVkl3aZHJchRrr13W golang.org/x/time v0.0.0-20211116232009-f0f3c7e86c11/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= @@ -1011,22 +893,11 @@ golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapK golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= -golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= -golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= -golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= -golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.7/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo= golang.org/x/tools v0.1.9 h1:j9KsMiaP1c3B0OTQGth0/k+miLGTgLsAFUCrF2vLcF8= golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -1034,7 +905,6 @@ golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.zx2c4.com/go118/netip v0.0.0-20211111135330-a4a02eeacf9d/go.mod h1:5yyfuiqVIJ7t+3MqrpTQ+QqRkMWiESiyDvPNvKYCecg= golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224 h1:Ug9qvr1myri/zFN6xL17LSCBGFDnphBBhzmILHsM5TY= golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224/go.mod h1:deeaetjYA+DHMHg+sMSMI58GrEteJUUzzw7en6TJQcI= golang.zx2c4.com/wireguard v0.0.0-20220202223031-3b95c81cc178 h1:Nrf94TOjrvW8nm6N3u2xtbnMZaZudNI9b8nIJH8p8qY= @@ -1051,20 +921,12 @@ google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsb google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= -google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE= -google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM= -google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= -google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/cloud v0.0.0-20151119220103-975617b05ea8/go.mod h1:0H1ncTHf11KCFhTc/+EFRbzSCOZx+VUbRMk55Yv5MYk= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= @@ -1085,19 +947,9 @@ google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvx google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA= google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= -google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U= google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= -google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA= -google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= -google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20201110150050-8816d57aaa9a/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210722135532-667f2b7c528f h1:YORWxaStkWBnWgELOHTmDrqNlFXuVGEbhwbB5iK94bQ= google.golang.org/genproto v0.0.0-20210722135532-667f2b7c528f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= @@ -1113,15 +965,11 @@ google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQ google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= -google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= -google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk= google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= -google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0= google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc= google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= -google.golang.org/grpc v1.42.0-dev.0.20211020220737-f00baa6c3c84/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= google.golang.org/grpc v1.43.0 h1:Eeu7bZtDZ2DpRCsLhUlcrLnvYaMK1Gz86a+hMVvELmM= google.golang.org/grpc v1.43.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= @@ -1181,20 +1029,15 @@ honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -k8s.io/api v0.16.13/go.mod h1:QWu8UWSTiuQZMMeYjwLs6ILu5O74qKSJ0c+4vrchDxs= k8s.io/api v0.20.1/go.mod h1:KqwcCVogGxQY3nBlRpwt+wpAMF/KjaCc7RpywacvqUo= k8s.io/api v0.20.4/go.mod h1:++lNL1AJMkDymriNniQsWRkMDzRaX2Y/POTUi8yvqYQ= k8s.io/api v0.20.6/go.mod h1:X9e8Qag6JV/bL5G6bU8sdVRltWKmdHsFUGS3eVndqE8= -k8s.io/apimachinery v0.16.13/go.mod h1:4HMHS3mDHtVttspuuhrJ1GGr/0S9B6iWYWZ57KnnZqQ= -k8s.io/apimachinery v0.16.14-rc.0/go.mod h1:4HMHS3mDHtVttspuuhrJ1GGr/0S9B6iWYWZ57KnnZqQ= k8s.io/apimachinery v0.20.1/go.mod h1:WlLqWAHZGg07AeltaI0MV5uk1Omp8xaN0JGLY6gkRpU= k8s.io/apimachinery v0.20.4/go.mod h1:WlLqWAHZGg07AeltaI0MV5uk1Omp8xaN0JGLY6gkRpU= k8s.io/apimachinery v0.20.6/go.mod h1:ejZXtW1Ra6V1O5H8xPBGz+T3+4gfkTCeExAHKU57MAc= k8s.io/apiserver v0.20.1/go.mod h1:ro5QHeQkgMS7ZGpvf4tSMx6bBOgPfE+f52KwvXfScaU= k8s.io/apiserver v0.20.4/go.mod h1:Mc80thBKOyy7tbvFtB4kJv1kbdD0eIH8k8vianJcbFM= k8s.io/apiserver v0.20.6/go.mod h1:QIJXNt6i6JB+0YQRNcS0hdRHJlMhflFmsBDeSgT1r8Q= -k8s.io/client-go v0.16.13/go.mod h1:UKvVT4cajC2iN7DCjLgT0KVY/cbY6DGdUCyRiIfws5M= k8s.io/client-go v0.20.1/go.mod h1:/zcHdt1TeWSd5HoUe6elJmHSQ6uLLgp4bIJHVEuy+/Y= k8s.io/client-go v0.20.4/go.mod h1:LiMv25ND1gLUdBeYxBIwKpkSC5IsozMMmOOeSJboP+k= k8s.io/client-go v0.20.6/go.mod h1:nNQMnOvEUEsOzRRFIIkdmYOjAZrC8bgq0ExboWSU1I0= @@ -1205,24 +1048,17 @@ k8s.io/cri-api v0.17.3/go.mod h1:X1sbHmuXhwaHs9xxYffLqJogVsnI+f6cPRcgPel7ywM= k8s.io/cri-api v0.20.1/go.mod h1:2JRbKt+BFLTjtrILYVqQK5jqhI+XNdF6UiGMgczeBCI= k8s.io/cri-api v0.20.4/go.mod h1:2JRbKt+BFLTjtrILYVqQK5jqhI+XNdF6UiGMgczeBCI= k8s.io/cri-api v0.20.6/go.mod h1:ew44AjNXwyn1s0U4xCKGodU7J1HzBeZ1MpGrpa5r8Yc= -k8s.io/gengo v0.0.0-20190128074634-0689ccc1d7d6/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= -k8s.io/klog v0.0.0-20181102134211-b9b56d5dfc92/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk= -k8s.io/klog v0.3.0/go.mod h1:Gq+BEi5rUBO/HRz0bTSXDUcqjScdoY3a9IHpCEIOOfk= -k8s.io/klog v1.0.0/go.mod h1:4Bi6QPql/J/LkTDqv7R/cd3hPo4k2DG6Ptcz060Ez5I= k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE= k8s.io/klog/v2 v2.4.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= -k8s.io/kube-openapi v0.0.0-20200410163147-594e756bea31/go.mod h1:1TqjTSzOxsLGIKfj0lK8EeCP7K1iUG65v09OM0/WG5E= k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd/go.mod h1:WOJ3KddDSol4tAGcJo0Tvi+dK12EcqSLqcWsryKMpfM= k8s.io/kubernetes v1.13.0/go.mod h1:ocZa8+6APFNC2tX1DZASIbocyYT5jHzqFVsY5aoB7Jk= -k8s.io/utils v0.0.0-20190801114015-581e00157fb1/go.mod h1:sZAwmy6armz5eXlNoLmJcl4F1QuKu7sr+mFQ0byX7Ew= k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.14/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.15/go.mod h1:LEScyzhFmoF5pso/YSeBstl57mOzx9xlU9n85RGrDQg= -sigs.k8s.io/structured-merge-diff v0.0.0-20190525122527-15d366b2352e/go.mod h1:wWxsB5ozmmv/SG7nM11ayaAW51xMvak/t1r0CSlcokI= sigs.k8s.io/structured-merge-diff/v4 v4.0.2/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= sigs.k8s.io/structured-merge-diff/v4 v4.0.3/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= diff --git a/tunnel/tunnel.go b/tunnel/tunnel.go index 964cb5fe..f42b1e72 100644 --- a/tunnel/tunnel.go +++ b/tunnel/tunnel.go @@ -4,18 +4,20 @@ import ( "context" "fmt" "net" + "path/filepath" "runtime" + "strconv" "sync" "time" "github.com/Dreamacro/clash/adapter/inbound" "github.com/Dreamacro/clash/component/nat" + P "github.com/Dreamacro/clash/component/process" "github.com/Dreamacro/clash/component/resolver" C "github.com/Dreamacro/clash/constant" "github.com/Dreamacro/clash/constant/provider" icontext "github.com/Dreamacro/clash/context" "github.com/Dreamacro/clash/log" - R "github.com/Dreamacro/clash/rule" "github.com/Dreamacro/clash/tunnel/statistic" ) @@ -33,9 +35,6 @@ var ( // default timeout for UDP session udpTimeout = 60 * time.Second - - // a default rule type of process, use to pre resolve process name - defaultProcessRule, _ = R.NewProcess("", "", nil) ) func init() { @@ -151,7 +150,17 @@ func preHandleMetadata(metadata *C.Metadata) error { } // pre resolve process name - defaultProcessRule.Match(metadata) + srcPort, err := strconv.Atoi(metadata.SrcPort) + if err == nil && P.ShouldFindProcess(metadata) { + path, err := P.FindProcessName(metadata.NetWork.String(), metadata.SrcIP, srcPort) + if err != nil { + log.Debugln("[Process] find process %s: %v", metadata.String(), err) + } else { + log.Debugln("[Process] %s from process %s", metadata.String(), path) + metadata.Process = filepath.Base(path) + metadata.ProcessPath = path + } + } return nil }