Clean more

diff --git a/conn_linux.go b/conn_linux.go
index 2b920bf663d8cd938147a6a524985a91f9fe73af..8d076ac2d7b26a580a73b964400b902506d4003c 100644 (file)
--- a/conn_linux.go
+++ b/conn_linux.go
@@ -217,19 +217,6 @@ func (bind *NativeBind) Send(buff []byte, end Endpoint) error {
        }
 }
 
-func rawAddrToIP4(addr *unix.SockaddrInet4) net.IP {
-       return net.IPv4(
-               addr.Addr[0],
-               addr.Addr[1],
-               addr.Addr[2],
-               addr.Addr[3],
-       )
-}
-
-func rawAddrToIP6(addr *unix.SockaddrInet6) net.IP {
-       return addr.Addr[:]
-}
-
 func (end *NativeEndpoint) SrcIP() net.IP {
        if !end.isV6 {
                return net.IPv4(
@@ -624,6 +611,10 @@ func (bind *NativeBind) routineRouteListener(device *Device) {
                                                        peer.mutex.RUnlock()
                                                        continue
                                                }
+                                               if peer.endpoint.(*NativeEndpoint).isV6 || peer.endpoint.(*NativeEndpoint).src4().ifindex == 0 {
+                                                       peer.mutex.RUnlock()
+                                                       break
+                                               }
                                                nlmsg := struct {
                                                        hdr     unix.NlMsghdr
                                                        msg     unix.RtMsg

diff --git a/cookie.go b/cookie.go
index cfee367f982ee2202e093862d5a79a28e33623e0..c0d3ed953b30f879d5dc863e78f68fb489d34458 100644 (file)
--- a/cookie.go
+++ b/cookie.go
@@ -48,19 +48,19 @@ func (st *CookieChecker) Init(pk NoisePublicKey) {
        // mac1 state
 
        func() {
-               hsh, _ := blake2s.New256(nil)
-               hsh.Write([]byte(WGLabelMAC1))
-               hsh.Write(pk[:])
-               hsh.Sum(st.mac1.key[:0])
+               hash, _ := blake2s.New256(nil)
+               hash.Write([]byte(WGLabelMAC1))
+               hash.Write(pk[:])
+               hash.Sum(st.mac1.key[:0])
        }()
 
        // mac2 state
 
        func() {
-               hsh, _ := blake2s.New256(nil)
-               hsh.Write([]byte(WGLabelCookie))
-               hsh.Write(pk[:])
-               hsh.Sum(st.mac2.encryptionKey[:0])
+               hash, _ := blake2s.New256(nil)
+               hash.Write([]byte(WGLabelCookie))
+               hash.Write(pk[:])
+               hash.Sum(st.mac2.encryptionKey[:0])
        }()
 
        st.mac2.secretSet = time.Time{}
@@ -181,17 +181,17 @@ func (st *CookieGenerator) Init(pk NoisePublicKey) {
        defer st.mutex.Unlock()
 
        func() {
-               hsh, _ := blake2s.New256(nil)
-               hsh.Write([]byte(WGLabelMAC1))
-               hsh.Write(pk[:])
-               hsh.Sum(st.mac1.key[:0])
+               hash, _ := blake2s.New256(nil)
+               hash.Write([]byte(WGLabelMAC1))
+               hash.Write(pk[:])
+               hash.Sum(st.mac1.key[:0])
        }()
 
        func() {
-               hsh, _ := blake2s.New256(nil)
-               hsh.Write([]byte(WGLabelCookie))
-               hsh.Write(pk[:])
-               hsh.Sum(st.mac2.encryptionKey[:0])
+               hash, _ := blake2s.New256(nil)
+               hash.Write([]byte(WGLabelCookie))
+               hash.Write(pk[:])
+               hash.Sum(st.mac2.encryptionKey[:0])
        }()
 
        st.mac2.cookieSet = time.Time{}

diff --git a/device.go b/device.go
index 835a75509675c9855f2a7743f0209fe272c8b6df..e91ca72d9217bfd0bad84872faf9bad7daad563b 100644 (file)
--- a/device.go
+++ b/device.go
@@ -225,15 +225,15 @@ func (device *Device) SetPrivateKey(sk NoisePrivateKey) error {
 
        for key, peer := range device.peers.keyMap {
 
-               hs := &peer.handshake
+               handshake := &peer.handshake
 
                if rmKey {
-                       hs.precomputedStaticStatic = [NoisePublicKeySize]byte{}
+                       handshake.precomputedStaticStatic = [NoisePublicKeySize]byte{}
                } else {
-                       hs.precomputedStaticStatic = device.staticIdentity.privateKey.sharedSecret(hs.remoteStatic)
+                       handshake.precomputedStaticStatic = device.staticIdentity.privateKey.sharedSecret(handshake.remoteStatic)
                }
 
-               if isZero(hs.precomputedStaticStatic[:]) {
+               if isZero(handshake.precomputedStaticStatic[:]) {
                        unsafeRemovePeer(device, peer, key)
                }
        }
@@ -267,18 +267,12 @@ func NewDevice(tun TUNDevice, logger *Logger) *Device {
 
        device.peers.keyMap = make(map[NoisePublicKey]*Peer)
 
-       // initialize rate limiter
-
        device.rate.limiter.Init()
        device.rate.underLoadUntil.Store(time.Time{})
 
-       // initialize staticIdentity & crypt-key routine
-
        device.indexTable.Init()
        device.allowedips.Reset()
 
-       // setup buffer pool
-
        device.pool.messageBuffers = sync.Pool{
                New: func() interface{} {
                        return new([MaxMessageSize]byte)

diff --git a/main.go b/main.go
index 6c7b07de91ccba11b975b4635d2c30b7f37a4987..c9ef343936762dd26e6b9b699e20fde685e79a63 100644 (file)
--- a/main.go
+++ b/main.go
@@ -186,7 +186,7 @@ func main() {
                env = append(env, fmt.Sprintf("%s=4", ENV_WG_UAPI_FD))
                env = append(env, fmt.Sprintf("%s=1", ENV_WG_PROCESS_FOREGROUND))
                files := [3]*os.File{}
-               if os.Getenv("LOG_LEVEL") != "" {
+               if os.Getenv("LOG_LEVEL") != "" && logLevel != LogLevelSilent {
                        files[1] = os.Stdout
                        files[2] = os.Stderr
                }

diff --git a/noise-protocol.go b/noise-protocol.go
index ffc2b50e9f04159a35587a9703b0bbd974fe5dcb..c13410708d4b1c20af034440d9918e9c57ea1cd0 100644 (file)
--- a/noise-protocol.go
+++ b/noise-protocol.go
@@ -121,11 +121,11 @@ func mixKey(dst *[blake2s.Size]byte, c *[blake2s.Size]byte, data []byte) {
 }
 
 func mixHash(dst *[blake2s.Size]byte, h *[blake2s.Size]byte, data []byte) {
-       hsh, _ := blake2s.New256(nil)
-       hsh.Write(h[:])
-       hsh.Write(data)
-       hsh.Sum(dst[:0])
-       hsh.Reset()
+       hash, _ := blake2s.New256(nil)
+       hash.Write(h[:])
+       hash.Write(data)
+       hash.Sum(dst[:0])
+       hash.Reset()
 }
 
 func (h *Handshake) Clear() {

diff --git a/tun_darwin.go b/tun_darwin.go
index b212e5771f614076aac0999bc9be272f709d431b..ac8bffd642e03772f4c3063401055381e700e870 100644 (file)
--- a/tun_darwin.go
+++ b/tun_darwin.go
@@ -125,12 +125,6 @@ func CreateTUNFromFile(file *os.File) (TUNDevice, error) {
                return nil, err
        }
 
-       // set default MTU
-       err = tun.setMTU(DefaultMTU)
-       if err != nil {
-               return nil, err
-       }
-
        tun.rwcancel, err = rwcancel.NewRWCancel(int(file.Fd()))
        if err != nil {
                return nil, err
@@ -174,6 +168,13 @@ func CreateTUNFromFile(file *os.File) (TUNDevice, error) {
                }
        }(tun)
 
+       // set default MTU
+       err = tun.setMTU(DefaultMTU)
+       if err != nil {
+               tun.Close()
+               return nil, err
+       }
+
        return tun, nil
 }
 

diff --git a/tun_linux.go b/tun_linux.go
index 18fb72cc764d0d05e7d62ea668cdb552e4fa74fd..8e42d4407aaf1843a934e6bfbada1abceff18c04 100644 (file)
--- a/tun_linux.go
+++ b/tun_linux.go
@@ -395,7 +395,7 @@ func CreateTUN(name string) (TUNDevice, error) {
 }
 
 func CreateTUNFromFile(fd *os.File) (TUNDevice, error) {
-       device := &NativeTun{
+       tun := &NativeTun{
                fd:                      fd,
                events:                  make(chan TUNEvent, 5),
                errors:                  make(chan error, 5),
@@ -404,37 +404,38 @@ func CreateTUNFromFile(fd *os.File) (TUNDevice, error) {
        }
        var err error
 
-       device.rwcancel, err = rwcancel.NewRWCancel(int(fd.Fd()))
+       tun.rwcancel, err = rwcancel.NewRWCancel(int(fd.Fd()))
        if err != nil {
                return nil, err
        }
 
-       _, err = device.Name()
+       _, err = tun.Name()
        if err != nil {
                return nil, err
        }
 
        // start event listener
 
-       device.index, err = getIFIndex(device.name)
+       tun.index, err = getIFIndex(tun.name)
        if err != nil {
                return nil, err
        }
 
-       // set default MTU
-
-       err = device.setMTU(DefaultMTU)
+       tun.netlinkSock, err = createNetlinkSocket()
        if err != nil {
                return nil, err
        }
 
-       device.netlinkSock, err = createNetlinkSocket()
+       go tun.RoutineNetlinkListener()
+       go tun.RoutineHackListener() // cross namespace
+
+       // set default MTU
+
+       err = tun.setMTU(DefaultMTU)
        if err != nil {
+               tun.Close()
                return nil, err
        }
 
-       go device.RoutineNetlinkListener()
-       go device.RoutineHackListener() // cross namespace
-
-       return device, nil
+       return tun, nil
 }