defer unlock

[govpn.git] / src / cypherpunks.ru / govpn / peer.go

diff --git a/src/cypherpunks.ru/govpn/peer.go b/src/cypherpunks.ru/govpn/peer.go
index 3856208d01a4bb38aa12a713648a1844dad8e0ad..989fd31ef1720deedd0ccd88c90de7fed81c336d 100644 (file)
--- a/src/cypherpunks.ru/govpn/peer.go
+++ b/src/cypherpunks.ru/govpn/peer.go
@@ -293,16 +293,18 @@ func newPeer(isClient bool, addr string, conn io.Writer, conf *PeerConf, key *[S
 // packets will be sent to remote Peer side immediately.
 func (p *Peer) EthProcess(data []byte) error {
        const paddingSize = 1
-       lenData := len(data)
-       if lenData > p.MTU-paddingSize {
-               logger.WithFields(p.LogFields()).WithFields(
+       if len(data) > p.MTU-paddingSize {
+               logger.WithFields(
+                       p.LogFields(),
+               ).WithFields(
                        p.ConfigurationLogFields(),
                ).WithFields(
                        logrus.Fields{
                                "func":        logFuncPrefix + "Peer.EthProcess",
                                "padding":     paddingSize,
-                               "packet_size": lenData,
-                       }).Warning("Ignore padded data packet larger than MTU")
+                               "packet_size": len(data),
+                       },
+               ).Warning("Ignore padded data packet larger than MTU")
                return nil
        }
        p.BusyT.Lock()
@@ -310,15 +312,15 @@ func (p *Peer) EthProcess(data []byte) error {
 
        // Zero size is a heartbeat packet
        SliceZero(p.bufT)
-       if lenData == 0 {
+       if len(data) == 0 {
                p.bufT[CC20IBS+0] = padByte
                p.HeartbeatSent++
        } else {
                // Copy payload to our internal buffer and we are ready to
                // accept the next one
                copy(p.bufT[CC20IBS:], data)
-               p.bufT[CC20IBS+lenData] = padByte
-               p.BytesPayloadOut += uint64(lenData)
+               p.bufT[CC20IBS+len(data)] = padByte
+               p.BytesPayloadOut += uint64(len(data))
        }
 
        if p.NoiseEnable && !p.Encless {
@@ -326,7 +328,7 @@ func (p *Peer) EthProcess(data []byte) error {
        } else if p.Encless {
                p.frameT = p.bufT[CC20IBS : CC20IBS+p.MTU]
        } else {
-               p.frameT = p.bufT[CC20IBS : CC20IBS+lenData+1+NonceSize]
+               p.frameT = p.bufT[CC20IBS : CC20IBS+len(data)+1+NonceSize]
        }
        copy(p.frameT[len(p.frameT)-NonceSize:], (<-p.noncesT)[:])
        var out []byte
@@ -357,31 +359,37 @@ func (p *Peer) EthProcess(data []byte) error {
 
 // PktProcess processes data of a single packet
 func (p *Peer) PktProcess(data []byte, tap io.Writer, reorderable bool) bool {
-       lenData := len(data)
        fields := logrus.Fields{
                "func":        logFuncPrefix + "Peer.PktProcess",
                "reorderable": reorderable,
-               "data":        lenData,
+               "data":        len(data),
        }
-       if lenData < MinPktLength {
-               logger.WithFields(p.LogFields()).WithFields(fields).WithField(
-                       "minimum_packet_Length", MinPktLength,
+       if len(data) < MinPktLength {
+               logger.WithFields(
+                       p.LogFields(),
+               ).WithFields(
+                       fields,
+               ).WithField(
+                       "minimum_packet_Length",
+                       MinPktLength,
                ).Debug("Ignore packet smaller than allowed minimum")
                return false
        }
-       if !p.Encless && lenData > len(p.bufR)-CC20IBS {
+       if !p.Encless && len(data) > len(p.bufR)-CC20IBS {
                return false
        }
        var out []byte
-       p.BusyR.Lock() // TODO use defer to unlock?
-       copy(p.nonceR[8:], data[lenData-NonceSize:])
+       p.BusyR.Lock()
+       defer p.BusyR.Unlock()
+       copy(p.nonceR[8:], data[len(data)-NonceSize:])
        if p.Encless {
                var err error
-               out, err = EnclessDecode(p.key, p.nonceR, data[:lenData-NonceSize])
+               out, err = EnclessDecode(p.key, p.nonceR, data[:len(data)-NonceSize])
                if err != nil {
-                       logger.WithFields(p.LogFields()).WithError(err).Debug("Failed to decode encless")
+                       logger.WithFields(
+                               p.LogFields(),
+                       ).WithError(err).Debug("Failed to decode encless")
                        p.FramesUnauth++
-                       p.BusyR.Unlock()
                        return false
                }
        } else {
@@ -390,8 +398,8 @@ func (p *Peer) PktProcess(data []byte, tap io.Writer, reorderable bool) bool {
                }
                copy(p.bufR[CC20IBS:], data[tagSize:])
                chacha20.XORKeyStream(
-                       p.bufR[:CC20IBS+lenData-tagSize-NonceSize],
-                       p.bufR[:CC20IBS+lenData-tagSize-NonceSize],
+                       p.bufR[:CC20IBS+len(data)-tagSize-NonceSize],
+                       p.bufR[:CC20IBS+len(data)-tagSize-NonceSize],
                        p.nonceR,
                        p.key,
                )
@@ -399,14 +407,13 @@ func (p *Peer) PktProcess(data []byte, tap io.Writer, reorderable bool) bool {
                copy(p.tagR[:], data[:tagSize])
                if !poly1305.Verify(p.tagR, data[tagSize:], p.keyAuthR) {
                        p.FramesUnauth++
-                       p.BusyR.Unlock()
                        return false
                }
-               out = p.bufR[CC20IBS : CC20IBS+lenData-tagSize-NonceSize]
+               out = p.bufR[CC20IBS : CC20IBS+len(data)-tagSize-NonceSize]
        }
 
        if reorderable {
-               copy(p.nonceRecv[:], data[lenData-NonceSize:])
+               copy(p.nonceRecv[:], data[len(data)-NonceSize:])
                _, foundL := p.nonceBucketL[p.nonceRecv]
                _, foundM := p.nonceBucketM[p.nonceRecv]
                _, foundH := p.nonceBucketH[p.nonceRecv]
@@ -414,7 +421,6 @@ func (p *Peer) PktProcess(data []byte, tap io.Writer, reorderable bool) bool {
                // or too new (many packets were lost)
                if !(foundL || foundM || foundH) {
                        p.FramesDup++
-                       p.BusyR.Unlock()
                        return false
                }
                // Delete seen nonce
@@ -438,38 +444,33 @@ func (p *Peer) PktProcess(data []byte, tap io.Writer, reorderable bool) bool {
                        }
                }
        } else {
-               if subtle.ConstantTimeCompare(data[lenData-NonceSize:], p.NonceExpect) != 1 {
+               if subtle.ConstantTimeCompare(data[len(data)-NonceSize:], p.NonceExpect) != 1 {
                        p.FramesDup++
-                       p.BusyR.Unlock()
                        return false
                }
                copy(p.NonceExpect, (<-p.noncesExpect)[:])
        }
 
        p.FramesIn++
-       atomic.AddUint64(&p.BytesIn, uint64(lenData))
+       atomic.AddUint64(&p.BytesIn, uint64(len(data)))
        p.LastPing = time.Now()
        p.pktSizeR = bytes.LastIndexByte(out, padByte)
        if p.pktSizeR == -1 {
-               p.BusyR.Unlock()
                return false
        }
        // Validate the pad
        for i := p.pktSizeR + 1; i < len(out); i++ {
                if out[i] != 0 {
-                       p.BusyR.Unlock()
                        return false
                }
        }
 
        if p.pktSizeR == 0 {
                p.HeartbeatRecv++
-               p.BusyR.Unlock()
                return true
        }
        p.BytesPayloadIn += uint64(p.pktSizeR)
        tap.Write(out[:p.pktSizeR])
-       p.BusyR.Unlock()
        return true
 }
 
@@ -506,7 +507,9 @@ func PeerTapProcessor(peer *Peer, tap *TAP, terminator chan struct{}) {
                                }
                        case data = <-tap.Sink:
                                if err = peer.EthProcess(data); err != nil {
-                                       logger.WithFields(fields).WithFields(
+                                       logger.WithFields(
+                                               fields,
+                                       ).WithFields(
                                                peer.LogFields(),
                                        ).WithError(err).Warn("Can't process ethernet packet")
                                }
@@ -522,7 +525,9 @@ func PeerTapProcessor(peer *Peer, tap *TAP, terminator chan struct{}) {
                                break CPRProcessor
                        case data = <-tap.Sink:
                                if err = peer.EthProcess(data); err != nil {
-                                       logger.WithFields(fields).WithFields(
+                                       logger.WithFields(
+                                               fields,
+                                       ).WithFields(
                                                peer.LogFields(),
                                        ).WithError(err).Warn("Can't process ethernet packet")
                                }
@@ -530,7 +535,9 @@ func PeerTapProcessor(peer *Peer, tap *TAP, terminator chan struct{}) {
                        }
                        if data == nil {
                                if err = peer.EthProcess(nil); err != nil {
-                                       logger.WithFields(fields).WithFields(
+                                       logger.WithFields(
+                                               fields,
+                                       ).WithFields(
                                                peer.LogFields(),
                                        ).WithError(err).Warn("Can't process nil ethernet packet")
                                }