Fixed rehandshake-related code

* Do not use buffered termination channels: we need guarantee that
  processor is stopped. Otherwise we can be locked and client will be
  timeouted
* Single peersLock call, no separate read and write related
* Create processing goroutine earlier

Signed-off-by: Sergey Matveev <stargrave@stargrave.org>

diff --git a/src/govpn/cmd/govpn-server/common.go b/src/govpn/cmd/govpn-server/common.go
index 92e1bb15d349a6da07994358c6e26caeb4f7c977..06e82e64e272c7b060317a8d6e736d96582fc97b 100644 (file)
--- a/src/govpn/cmd/govpn-server/common.go
+++ b/src/govpn/cmd/govpn-server/common.go
@@ -43,6 +43,7 @@ Processor:
                        ps.peer.EthProcess(data)
                }
        }
+       close(ps.terminator)
        ps.peer.Zero()
        heartbeat.Stop()
 }

diff --git a/src/govpn/cmd/govpn-server/tcp.go b/src/govpn/cmd/govpn-server/tcp.go
index 6dd3a010437e3ca2632eea60f519475bd2c0e3bd..c1969faa486d511000103a660e1780278e12a3e7 100644 (file)
--- a/src/govpn/cmd/govpn-server/tcp.go
+++ b/src/govpn/cmd/govpn-server/tcp.go
@@ -95,28 +95,25 @@ func handleTCP(conn net.Conn) {
                addrPrev, exists := peersById[*peer.Id]
                peersByIdLock.RUnlock()
                if exists {
-                       peersLock.RLock()
+                       peersLock.Lock()
+                       peers[addrPrev].terminator <- struct{}{}
                        tap = peers[addrPrev].tap
                        ps = &PeerState{
                                peer:       peer,
                                tap:        tap,
-                               terminator: peers[addrPrev].terminator,
+                               terminator: make(chan struct{}),
                        }
-                       peersLock.RUnlock()
-                       ps.terminator <- struct{}{}
-                       peersLock.Lock()
+                       go peerReady(*ps)
                        peersByIdLock.Lock()
                        kpLock.Lock()
                        delete(peers, addrPrev)
                        delete(knownPeers, addrPrev)
-                       delete(peersById, *peer.Id)
                        peers[addr] = ps
                        knownPeers[addr] = &peer
                        peersById[*peer.Id] = addr
                        peersLock.Unlock()
                        peersByIdLock.Unlock()
                        kpLock.Unlock()
-                       go peerReady(*ps)
                        log.Println("Rehandshake processed:", peer.Id.String())
                } else {
                        ifaceName, err := callUp(peer.Id)

diff --git a/src/govpn/cmd/govpn-server/udp.go b/src/govpn/cmd/govpn-server/udp.go
index 2c6a0f3b4fb2e8b011c2816e5a8530a1bab41ce6..148ff68cf1e2b492cd42c8fac638d0931696fd97 100644 (file)
--- a/src/govpn/cmd/govpn-server/udp.go
+++ b/src/govpn/cmd/govpn-server/udp.go
@@ -110,31 +110,28 @@ func startUDP() {
                        addrPrev, exists = peersById[*peer.Id]
                        peersByIdLock.RUnlock()
                        if exists {
-                               peersLock.RLock()
+                               peersLock.Lock()
+                               peers[addrPrev].terminator <- struct{}{}
                                ps = &PeerState{
                                        peer:       peer,
                                        tap:        peers[addrPrev].tap,
-                                       terminator: peers[addrPrev].terminator,
+                                       terminator: make(chan struct{}),
                                }
-                               peersLock.RUnlock()
-                               ps.terminator <- struct{}{}
-                               peersLock.Lock()
+                               go func(ps PeerState) {
+                                       peerReady(ps)
+                                       <-udpBufs
+                                       <-udpBufs
+                               }(*ps)
                                peersByIdLock.Lock()
                                kpLock.Lock()
                                delete(peers, addrPrev)
                                delete(knownPeers, addrPrev)
-                               delete(peersById, *peer.Id)
                                peers[addr] = ps
                                knownPeers[addr] = &peer
                                peersById[*peer.Id] = addr
                                peersLock.Unlock()
                                peersByIdLock.Unlock()
                                kpLock.Unlock()
-                               go func(ps PeerState) {
-                                       peerReady(ps)
-                                       <-udpBufs
-                                       <-udpBufs
-                               }(*ps)
                                log.Println("Rehandshake processed:", peer.Id.String())
                        } else {
                                go func(addr string, peer *govpn.Peer) {
@@ -150,7 +147,7 @@ func startUDP() {
                                        ps = &PeerState{
                                                peer:       peer,
                                                tap:        tap,
-                                               terminator: make(chan struct{}, 1),
+                                               terminator: make(chan struct{}),
                                        }
                                        go func(ps PeerState) {
                                                peerReady(ps)