set UserEventSizeLimit to 90K

liuxiaolong

2022-06-28 37714b1093c04061e636e5b1d27179652e671c0a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
 
// +build aix darwin dragonfly freebsd netbsd openbsd solaris windows
 
package ipv4
 
import (
    "net"
    "unsafe"
 
    "golang.org/x/net/internal/socket"
)
 
func (so *sockOpt) setIPMreq(c *socket.Conn, ifi *net.Interface, grp net.IP) error {
    mreq := ipMreq{Multiaddr: [4]byte{grp[0], grp[1], grp[2], grp[3]}}
    if err := setIPMreqInterface(&mreq, ifi); err != nil {
        return err
    }
    b := (*[sizeofIPMreq]byte)(unsafe.Pointer(&mreq))[:sizeofIPMreq]
    return so.Set(c, b)
}
 
func (so *sockOpt) getMulticastIf(c *socket.Conn) (*net.Interface, error) {
    var b [4]byte
    if _, err := so.Get(c, b[:]); err != nil {
        return nil, err
    }
    ifi, err := netIP4ToInterface(net.IPv4(b[0], b[1], b[2], b[3]))
    if err != nil {
        return nil, err
    }
    return ifi, nil
}
 
func (so *sockOpt) setMulticastIf(c *socket.Conn, ifi *net.Interface) error {
    ip, err := netInterfaceToIP4(ifi)
    if err != nil {
        return err
    }
    var b [4]byte
    copy(b[:], ip)
    return so.Set(c, b[:])
}
 
func setIPMreqInterface(mreq *ipMreq, ifi *net.Interface) error {
    if ifi == nil {
        return nil
    }
    ifat, err := ifi.Addrs()
    if err != nil {
        return err
    }
    for _, ifa := range ifat {
        switch ifa := ifa.(type) {
        case *net.IPAddr:
            if ip := ifa.IP.To4(); ip != nil {
                copy(mreq.Interface[:], ip)
                return nil
            }
        case *net.IPNet:
            if ip := ifa.IP.To4(); ip != nil {
                copy(mreq.Interface[:], ip)
                return nil
            }
        }
    }
    return errNoSuchInterface
}
 
func netIP4ToInterface(ip net.IP) (*net.Interface, error) {
    ift, err := net.Interfaces()
    if err != nil {
        return nil, err
    }
    for _, ifi := range ift {
        ifat, err := ifi.Addrs()
        if err != nil {
            return nil, err
        }
        for _, ifa := range ifat {
            switch ifa := ifa.(type) {
            case *net.IPAddr:
                if ip.Equal(ifa.IP) {
                    return &ifi, nil
                }
            case *net.IPNet:
                if ip.Equal(ifa.IP) {
                    return &ifi, nil
                }
            }
        }
    }
    return nil, errNoSuchInterface
}
 
func netInterfaceToIP4(ifi *net.Interface) (net.IP, error) {
    if ifi == nil {
        return net.IPv4zero.To4(), nil
    }
    ifat, err := ifi.Addrs()
    if err != nil {
        return nil, err
    }
    for _, ifa := range ifat {
        switch ifa := ifa.(type) {
        case *net.IPAddr:
            if ip := ifa.IP.To4(); ip != nil {
                return ip, nil
            }
        case *net.IPNet:
            if ip := ifa.IP.To4(); ip != nil {
                return ip, nil
            }
        }
    }
    return nil, errNoSuchInterface
}