TUN status hack was causing spam during shutdown

diff --git a/peer.go b/peer.go
index 1170720dbde091eb4ba309926fd493e9605f58fa..5580cf69f1d192098d08c3a659a8a3c61bc86742 100644 (file)
--- a/peer.go
+++ b/peer.go
@@ -54,8 +54,8 @@ type Peer struct {
                handshakeDeadline   Timer // complete handshake timeout
                handshakeTimeout    Timer // current handshake message timeout
 
-               sendLastMinuteHandshake bool
-               needAnotherKeepalive    bool
+               sendLastMinuteHandshake AtomicBool
+               needAnotherKeepalive    AtomicBool
        }
 
        queue struct {
@@ -170,15 +170,8 @@ func (peer *Peer) SendBuffer(buffer []byte) error {
 /* Returns a short string identifier for logging
  */
 func (peer *Peer) String() string {
-       if peer.endpoint == nil {
-               return fmt.Sprintf(
-                       "peer(unknown %s)",
-                       base64.StdEncoding.EncodeToString(peer.handshake.remoteStatic[:]),
-               )
-       }
        return fmt.Sprintf(
-               "peer(%s %s)",
-               peer.endpoint.DstToString(),
+               "peer(%s)",
                base64.StdEncoding.EncodeToString(peer.handshake.remoteStatic[:]),
        )
 }

diff --git a/timer.go b/timer.go
index 6cac40d99edebc871f404b044674976d3dba7279..74e3a4e46e9a08e3bc78a10fc7a1d63e12757304 100644 (file)
--- a/timer.go
+++ b/timer.go
@@ -1,44 +1,52 @@
 package main
 
 import (
+       "sync"
        "time"
 )
 
 type Timer struct {
-       pending AtomicBool
+       mutex   sync.Mutex
+       pending bool
        timer   *time.Timer
 }
 
 /* Starts the timer if not already pending
  */
 func (t *Timer) Start(dur time.Duration) bool {
-       if !t.pending.Swap(true) {
+       t.mutex.Lock()
+       defer t.mutex.Unlock()
+
+       started := !t.pending
+       if started {
                t.timer.Reset(dur)
-               return true
        }
-       return false
+       return started
 }
 
-/* Stops the timer
- */
 func (t *Timer) Stop() {
-       if t.pending.Swap(true) {
-               t.timer.Stop()
-               select {
-               case <-t.timer.C:
-               default:
-               }
+       t.mutex.Lock()
+       defer t.mutex.Unlock()
+
+       t.timer.Stop()
+       select {
+       case <-t.timer.C:
+       default:
        }
-       t.pending.Set(false)
+       t.pending = false
 }
 
 func (t *Timer) Pending() bool {
-       return t.pending.Get()
+       t.mutex.Lock()
+       defer t.mutex.Unlock()
+
+       return t.pending
 }
 
 func (t *Timer) Reset(dur time.Duration) {
-       t.pending.Set(false)
-       t.Start(dur)
+       t.mutex.Lock()
+       defer t.mutex.Unlock()
+       t.timer.Reset(dur)
 }
 
 func (t *Timer) Wait() <-chan time.Time {
@@ -46,8 +54,8 @@ func (t *Timer) Wait() <-chan time.Time {
 }
 
 func NewTimer() (t Timer) {
-       t.pending.Set(false)
-       t.timer = time.NewTimer(0)
+       t.pending = false
+       t.timer = time.NewTimer(time.Hour)
        t.timer.Stop()
        select {
        case <-t.timer.C:

diff --git a/timers.go b/timers.go
index 1240c219c89ae30a1ae8d7c30eb76ee080996408..76dffb990b89ed481c56d0b870f882a8da62aeb4 100644 (file)
--- a/timers.go
+++ b/timers.go
@@ -36,7 +36,7 @@ func (peer *Peer) KeepKeyFreshSending() {
  * NOTE: Not thread safe, but called by sequential receiver!
  */
 func (peer *Peer) KeepKeyFreshReceiving() {
-       if peer.timer.sendLastMinuteHandshake {
+       if peer.timer.sendLastMinuteHandshake.Get() {
                return
        }
        kp := peer.keyPairs.Current()
@@ -50,7 +50,7 @@ func (peer *Peer) KeepKeyFreshReceiving() {
        send := nonce > RekeyAfterMessages || time.Now().Sub(kp.created) > RekeyAfterTimeReceiving
        if send {
                // do a last minute attempt at initiating a new handshake
-               peer.timer.sendLastMinuteHandshake = true
+               peer.timer.sendLastMinuteHandshake.Set(true)
                peer.signal.handshakeBegin.Send()
        }
 }
@@ -87,7 +87,7 @@ func (peer *Peer) TimerDataSent() {
  */
 func (peer *Peer) TimerDataReceived() {
        if !peer.timer.keepalivePassive.Start(KeepaliveTimeout) {
-               peer.timer.needAnotherKeepalive = true
+               peer.timer.needAnotherKeepalive.Set(true)
        }
 }
 
@@ -238,8 +238,7 @@ func (peer *Peer) RoutineTimerHandler() {
 
                        peer.SendKeepAlive()
 
-                       if peer.timer.needAnotherKeepalive {
-                               peer.timer.needAnotherKeepalive = false
+                       if peer.timer.needAnotherKeepalive.Swap(false) {
                                peer.timer.keepalivePassive.Reset(KeepaliveTimeout)
                        }
 
@@ -342,7 +341,7 @@ func (peer *Peer) RoutineTimerHandler() {
                        peer.timer.handshakeDeadline.Stop()
                        peer.signal.handshakeBegin.Enable()
 
-                       peer.timer.sendLastMinuteHandshake = false
+                       peer.timer.sendLastMinuteHandshake.Set(false)
                }
        }
 }

diff --git a/tun.go b/tun.go
index 6259f33a49c97f58798b5dda1b312238c708e317..7b044ad12c703ee140968a8ec93d58408572203f 100644 (file)
--- a/tun.go
+++ b/tun.go
@@ -26,6 +26,7 @@ type TUNDevice interface {
 }
 
 func (device *Device) RoutineTUNEventReader() {
+       setUp := false
        logInfo := device.log.Info
        logError := device.log.Error
 
@@ -45,13 +46,15 @@ func (device *Device) RoutineTUNEventReader() {
                        }
                }
 
-               if event&TUNEventUp != 0 && !device.isUp.Get() {
+               if event&TUNEventUp != 0 && !setUp {
                        logInfo.Println("Interface set up")
+                       setUp = true
                        device.Up()
                }
 
-               if event&TUNEventDown != 0 && device.isUp.Get() {
+               if event&TUNEventDown != 0 && setUp {
                        logInfo.Println("Interface set down")
+                       setUp = false
                        device.Down()
                }
        }