func NewLinuxSocketBind() Bind { return &LinuxSocketBind{sock4: -1, sock6: -1} }
func NewDefaultBind() Bind { return NewLinuxSocketBind() }
-var _ Endpoint = (*LinuxSocketEndpoint)(nil)
-var _ Bind = (*LinuxSocketBind)(nil)
+var (
+ _ Endpoint = (*LinuxSocketEndpoint)(nil)
+ _ Bind = (*LinuxSocketBind)(nil)
+)
func (*LinuxSocketBind) ParseEndpoint(s string) (Endpoint, error) {
var end LinuxSocketEndpoint
unix.SO_MARK,
int(value),
)
-
if err != nil {
return err
}
unix.SO_MARK,
int(value),
)
-
if err != nil {
return err
}
}
func create4(port uint16) (int, uint16, error) {
-
// create socket
fd, err := unix.Socket(
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return -1, 0, err
}
}
func create6(port uint16) (int, uint16, error) {
-
// create socket
fd, err := unix.Socket(
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return -1, 0, err
}
}
return unix.Bind(fd, &addr)
-
}(); err != nil {
unix.Close(fd)
return -1, 0, err
}
func send4(sock int, end *LinuxSocketEndpoint, buff []byte) error {
-
// construct message header
cmsg := struct {
}
func send6(sock int, end *LinuxSocketEndpoint, buff []byte) error {
-
// construct message header
cmsg := struct {
}
func receive4(sock int, buff []byte, end *LinuxSocketEndpoint) (int, error) {
-
// construct message header
var cmsg struct {
}
size, _, _, newDst, err := unix.Recvmsg(sock, buff, (*[unsafe.Sizeof(cmsg)]byte)(unsafe.Pointer(&cmsg))[:], 0)
-
if err != nil {
return 0, err
}
}
func receive6(sock int, buff []byte, end *LinuxSocketEndpoint) (int, error) {
-
// construct message header
var cmsg struct {
}
size, _, _, newDst, err := unix.Recvmsg(sock, buff, (*[unsafe.Sizeof(cmsg)]byte)(unsafe.Pointer(&cmsg))[:], 0)
-
if err != nil {
return 0, err
}
type StdNetEndpoint net.UDPAddr
-var _ Bind = (*StdNetBind)(nil)
-var _ Endpoint = (*StdNetEndpoint)(nil)
+var (
+ _ Bind = (*StdNetBind)(nil)
+ _ Endpoint = (*StdNetEndpoint)(nil)
+)
func (*StdNetBind) ParseEndpoint(s string) (Endpoint, error) {
e, err := netip.ParseAddrPort(s)
data [30]byte
}
-var _ Bind = (*WinRingBind)(nil)
-var _ Endpoint = (*WinRingEndpoint)(nil)
+var (
+ _ Bind = (*WinRingBind)(nil)
+ _ Endpoint = (*WinRingEndpoint)(nil)
+)
func (*WinRingBind) ParseEndpoint(s string) (Endpoint, error) {
host, port, err := net.SplitHostPort(s)
count = winrio.DequeueCompletion(bind.rx.cq, results[:])
if count == 0 {
return 0, nil, io.ErrNoProgress
-
}
}
bind.rx.Return(1)
bind.blackhole6 = blackhole
return nil
}
+
func (bind *WinRingBind) BindSocketToInterface4(interfaceIndex uint32, blackhole bool) error {
bind.mu.RLock()
defer bind.mu.RUnlock()
type ChannelEndpoint uint16
-var _ conn.Bind = (*ChannelBind)(nil)
-var _ conn.Endpoint = (*ChannelEndpoint)(nil)
+var (
+ _ conn.Bind = (*ChannelBind)(nil)
+ _ conn.Endpoint = (*ChannelEndpoint)(nil)
+)
func NewChannelBinds() [2]conn.Bind {
arx4 := make(chan []byte, 8192)
overlapped *windows.Overlapped
}
-var initialized sync.Once
-var available bool
+var (
+ initialized sync.Once
+ available bool
+)
func Initialize() bool {
initialized.Do(func() {
return
}
defer windows.CloseHandle(socket)
- var WSAID_MULTIPLE_RIO = &windows.GUID{0x8509e081, 0x96dd, 0x4005, [8]byte{0xb1, 0x65, 0x9e, 0x2e, 0xe8, 0xc7, 0x9e, 0x3f}}
+ WSAID_MULTIPLE_RIO := &windows.GUID{0x8509e081, 0x96dd, 0x4005, [8]byte{0xb1, 0x65, 0x9e, 0x2e, 0xe8, 0xc7, 0x9e, 0x3f}}
const SIO_GET_MULTIPLE_EXTENSION_FUNCTION_POINTER = 0xc8000024
ob := uint32(0)
err = windows.WSAIoctl(socket, SIO_GET_MULTIPLE_EXTENSION_FUNCTION_POINTER,
}
func TestCommonBits(t *testing.T) {
-
tests := []testPairCommonBits{
{s1: []byte{1, 4, 53, 128}, s2: []byte{0, 0, 0, 0}, match: 7},
{s1: []byte{0, 4, 53, 128}, s2: []byte{0, 0, 0, 0}, match: 13},
}
}
-func benchmarkTrie(peerNumber int, addressNumber int, addressLength int, b *testing.B) {
+func benchmarkTrie(peerNumber, addressNumber, addressLength int, b *testing.B) {
var trie *trieEntry
var peers []*Peer
root := parentIndirection{&trie, 2}
return hmac.Equal(mac1[:], msg[smac1:smac2])
}
-func (st *CookieChecker) CheckMAC2(msg []byte, src []byte) bool {
+func (st *CookieChecker) CheckMAC2(msg, src []byte) bool {
st.RLock()
defer st.RUnlock()
recv uint32,
src []byte,
) (*MessageCookieReply, error) {
-
st.RLock()
// refresh cookie secret
xchapoly, _ := chacha20poly1305.NewX(st.mac2.encryptionKey[:])
_, err := xchapoly.Open(cookie[:0], msg.Nonce[:], msg.Cookie[:], st.mac2.lastMAC1[:])
-
if err != nil {
return false
}
}
func (st *CookieGenerator) AddMacs(msg []byte) {
-
size := len(msg)
smac2 := size - blake2s.Size128
)
func TestCookieMAC1(t *testing.T) {
-
// setup generator / checker
var (
msg[5] ^= 0x20
- srcBad1 := []byte{192, 168, 13, 37, 40, 01}
+ srcBad1 := []byte{192, 168, 13, 37, 40, 1}
if checker.CheckMAC2(msg, srcBad1) {
t.Fatal("MAC2 generation/verification failed")
}
- srcBad2 := []byte{192, 168, 13, 38, 40, 01}
+ srcBad2 := []byte{192, 168, 13, 38, 40, 1}
if checker.CheckMAC2(msg, srcBad2) {
t.Fatal("MAC2 generation/verification failed")
}
// genConfigs generates a pair of configs that connect to each other.
// The configs use distinct, probably-usable ports.
-func genConfigs(tb testing.TB) (cfgs [2]string, endpointCfgs [2]string) {
+func genConfigs(tb testing.TB) (cfgs, endpointCfgs [2]string) {
var key1, key2 NoisePrivateKey
_, err := rand.Read(key1[:])
if err != nil {
t2 string
}
-func assertEquals(t *testing.T, a string, b string) {
+func assertEquals(t *testing.T, a, b string) {
if a != b {
t.Fatal("expected", a, "=", b)
}
ZeroNonce [chacha20poly1305.NonceSize]byte
)
-func mixKey(dst *[blake2s.Size]byte, c *[blake2s.Size]byte, data []byte) {
+func mixKey(dst, c *[blake2s.Size]byte, data []byte) {
KDF1(dst, c[:], data)
}
-func mixHash(dst *[blake2s.Size]byte, h *[blake2s.Size]byte, data []byte) {
+func mixHash(dst, h *[blake2s.Size]byte, data []byte) {
hash, _ := blake2s.New256(nil)
hash.Write(h[:])
hash.Write(data)
}
func (device *Device) CreateMessageInitiation(peer *Peer) (*MessageInitiation, error) {
- var errZeroECDHResult = errors.New("ECDH returned all zeros")
+ errZeroECDHResult := errors.New("ECDH returned all zeros")
device.staticIdentity.RLock()
defer device.staticIdentity.RUnlock()
)
ok := func() bool {
-
// lock handshake state
handshake.mutex.RLock()
offset := MessageTransportHeaderSize
size, err := device.tun.device.Read(elem.buffer[:], offset)
-
if err != nil {
if !device.isClosed() {
if !errors.Is(err, os.ErrClosed) {
}
peer.Unlock()
peer.SendHandshakeInitiation(false)
-
}
func expiredZeroKeyMaterial(peer *Peer) {
}
func() {
-
// lock required resources
device.net.RLock()
type timeoutChan chan struct{}
-var ioInitOnce sync.Once
-var ioCompletionPort windows.Handle
+var (
+ ioInitOnce sync.Once
+ ioCompletionPort windows.Handle
+)
// ioResult contains the result of an asynchronous IO operation
type ioResult struct {
}
}
-func getConnection(cfg *namedpipe.ListenConfig) (client net.Conn, server net.Conn, err error) {
+func getConnection(cfg *namedpipe.ListenConfig) (client, server net.Conn, err error) {
pipePath := randomPipePath()
if cfg == nil {
cfg = &namedpipe.ListenConfig{}
}
func UAPIListen(name string, file *os.File) (net.Listener, error) {
-
// wrap file in listener
listener, err := net.FileListener(file)
}
func UAPIListen(name string, file *os.File) (net.Listener, error) {
-
// wrap file in listener
listener, err := net.FileListener(file)
}
func UAPIOpen(name string) (*os.File, error) {
- if err := os.MkdirAll(socketDirectory, 0755); err != nil {
+ if err := os.MkdirAll(socketDirectory, 0o755); err != nil {
return nil, err
}
return nil, err
}
- oldUmask := unix.Umask(0077)
+ oldUmask := unix.Umask(0o077)
defer unix.Umask(oldUmask)
listener, err := net.ListenUnix("unix", addr)
return os.NewFile(uintptr(fd), ""), nil
}()
-
if err != nil {
logger.Errorf("UAPI listen error: %v", err)
os.Exit(ExitSetupFailed)
// ValidateCounter checks if the counter should be accepted.
// Overlimit counters (>= limit) are always rejected.
-func (f *Filter) ValidateCounter(counter uint64, limit uint64) bool {
+func (f *Filter) ValidateCounter(counter, limit uint64) bool {
if counter >= limit {
return false
}
package rwcancel
-type RWCancel struct {
-}
+type RWCancel struct{}
func (*RWCancel) Cancel() {}
"time"
)
-const TimestampSize = 12
-const base = uint64(0x400000000000000a)
-const whitenerMask = uint32(0x1000000 - 1)
+const (
+ TimestampSize = 12
+ base = uint64(0x400000000000000a)
+ whitenerMask = uint32(0x1000000 - 1)
+)
type Timestamp [TimestampSize]byte
dnsServers []netip.Addr
hasV4, hasV6 bool
}
-type endpoint netTun
-type Net netTun
+
+type (
+ endpoint netTun
+ Net netTun
+)
func (e *endpoint) Attach(dispatcher stack.NetworkDispatcher) {
e.dispatcher = dispatcher
if err == nil && name == "utun" {
fname := os.Getenv("WG_TUN_NAME_FILE")
if fname != "" {
- os.WriteFile(fname, []byte(tun.(*NativeTun).name+"\n"), 0400)
+ os.WriteFile(fname, []byte(tun.(*NativeTun).name+"\n"), 0o400)
}
}
}
func (tun *NativeTun) Write(buff []byte, offset int) (int, error) {
-
// reserve space for header
buff = buff[offset-4:]
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return err
}
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return 0, err
}
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return err
}
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return 0, err
}
if err == nil && name == "tun" {
fname := os.Getenv("WG_TUN_NAME_FILE")
if fname != "" {
- os.WriteFile(fname, []byte(tun.(*NativeTun).name+"\n"), 0400)
+ os.WriteFile(fname, []byte(tun.(*NativeTun).name+"\n"), 0o400)
}
}
}
func (tun *NativeTun) Write(buff []byte, offset int) (int, error) {
-
// reserve space for header
buff = buff[offset-4:]
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return err
}
unix.SOCK_DGRAM,
0,
)
-
if err != nil {
return 0, err
}
forcedMTU int
}
-var WintunTunnelType = "WireGuard"
-var WintunStaticRequestedGUID *windows.GUID
+var (
+ WintunTunnelType = "WireGuard"
+ WintunStaticRequestedGUID *windows.GUID
+)
//go:linkname procyield runtime.procyield
func procyield(cycles uint32)
projects / thirdparty / wireguard-go.git / commitdiff
