go vet/lint

[govpn.git] / src / cypherpunks.ru / govpn / cmd / govpn-server / tcp.go

diff --git a/src/cypherpunks.ru/govpn/cmd/govpn-server/tcp.go b/src/cypherpunks.ru/govpn/cmd/govpn-server/tcp.go
index 417fcb1601f9fac8c67509ca5693a2b447891656..c36da3fed3ca02f8610a7ff9040b679f3e4b3981 100644 (file)
--- a/src/cypherpunks.ru/govpn/cmd/govpn-server/tcp.go
+++ b/src/cypherpunks.ru/govpn/cmd/govpn-server/tcp.go
@@ -1,6 +1,6 @@
 /*
 GoVPN -- simple secure free software virtual private network daemon
-Copyright (C) 2014-2016 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2014-2017 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -36,12 +36,12 @@ func startTCP() {
        if err != nil {
                log.Fatalln("Can not listen on TCP:", err)
        }
-       log.Println("Listening on TCP:" + *bindAddr)
+       govpn.BothPrintf(`[tcp-listen bind="%s"]`, *bindAddr)
        go func() {
                for {
                        conn, err := listener.AcceptTCP()
                        if err != nil {
-                               log.Println("Error accepting TCP:", err)
+                               govpn.Printf(`[tcp-accept-failed bind="%s" err="%s"]`, *bindAddr, err)
                                continue
                        }
                        go handleTCP(conn)
@@ -71,14 +71,17 @@ func handleTCP(conn net.Conn) {
                        break
                }
                prev += n
-               peerId := idsCache.Find(buf[:prev])
-               if peerId == nil {
+               peerID := idsCache.Find(buf[:prev])
+               if peerID == nil {
                        continue
                }
                if hs == nil {
-                       conf = confs[*peerId]
+                       conf = confs[*peerID]
                        if conf == nil {
-                               log.Println("Can not get peer configuration:", peerId.String())
+                               govpn.Printf(
+                                       `[conf-get-failed bind="%s" peer="%s"]`,
+                                       *bindAddr, peerID.String(),
+                               )
                                break
                        }
                        hs = govpn.NewHandshake(addr, conn, conf)
@@ -89,10 +92,13 @@ func handleTCP(conn net.Conn) {
                        continue
                }
                hs.Zero()
-               log.Println("Peer handshake finished:", addr, peer.Id.String())
-               peersByIdLock.RLock()
-               addrPrev, exists := peersById[*peer.Id]
-               peersByIdLock.RUnlock()
+               govpn.Printf(
+                       `[handshake-completed bind="%s" addr="%s" peer="%s"]`,
+                       *bindAddr, addr, peerID.String(),
+               )
+               peersByIDLock.RLock()
+               addrPrev, exists := peersByID[*peer.ID]
+               peersByIDLock.RUnlock()
                if exists {
                        peersLock.Lock()
                        peers[addrPrev].terminator <- struct{}{}
@@ -102,27 +108,33 @@ func handleTCP(conn net.Conn) {
                                tap:        tap,
                                terminator: make(chan struct{}),
                        }
-                       go peerReady(*ps)
-                       peersByIdLock.Lock()
+                       go govpn.PeerTapProcessor(ps.peer, ps.tap, ps.terminator)
+                       peersByIDLock.Lock()
                        kpLock.Lock()
                        delete(peers, addrPrev)
                        delete(knownPeers, addrPrev)
                        peers[addr] = ps
                        knownPeers[addr] = &peer
-                       peersById[*peer.Id] = addr
+                       peersByID[*peer.ID] = addr
                        peersLock.Unlock()
-                       peersByIdLock.Unlock()
+                       peersByIDLock.Unlock()
                        kpLock.Unlock()
-                       log.Println("Rehandshake processed:", peer.Id.String())
+                       govpn.Printf(
+                               `[rehandshake-completed bind="%s" peer="%s"]`,
+                               *bindAddr, peerID.String(),
+                       )
                } else {
-                       ifaceName, err := callUp(peer.Id)
+                       ifaceName, err := callUp(peer.ID, peer.Addr)
                        if err != nil {
                                peer = nil
                                break
                        }
                        tap, err = govpn.TAPListen(ifaceName, peer.MTU)
                        if err != nil {
-                               log.Println("Unable to create TAP:", err)
+                               govpn.Printf(
+                                       `[tap-failed bind="%s" peer="%s" err="%s"]`,
+                                       *bindAddr, peerID.String(), err,
+                               )
                                peer = nil
                                break
                        }
@@ -131,17 +143,17 @@ func handleTCP(conn net.Conn) {
                                tap:        tap,
                                terminator: make(chan struct{}, 1),
                        }
-                       go peerReady(*ps)
+                       go govpn.PeerTapProcessor(ps.peer, ps.tap, ps.terminator)
                        peersLock.Lock()
-                       peersByIdLock.Lock()
+                       peersByIDLock.Lock()
                        kpLock.Lock()
                        peers[addr] = ps
-                       peersById[*peer.Id] = addr
+                       peersByID[*peer.ID] = addr
                        knownPeers[addr] = &peer
                        peersLock.Unlock()
-                       peersByIdLock.Unlock()
+                       peersByIDLock.Unlock()
                        kpLock.Unlock()
-                       log.Println("Peer created:", peer.Id.String())
+                       govpn.Printf(`[peer-created bind="%s" peer="%s"]`, *bindAddr, peerID.String())
                }
                break
        }
@@ -152,8 +164,6 @@ func handleTCP(conn net.Conn) {
                return
        }
 
-       nonceExpectation := make([]byte, govpn.NonceSize)
-       peer.NonceExpectation(nonceExpectation)
        prev = 0
        var i int
        for {
@@ -171,18 +181,17 @@ func handleTCP(conn net.Conn) {
                if prev < govpn.MinPktLength {
                        continue
                }
-               i = bytes.Index(buf[:prev], nonceExpectation)
+               i = bytes.Index(buf[:prev], peer.NonceExpect)
                if i == -1 {
                        continue
                }
                if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) {
-                       log.Println(
-                               "Unauthenticated packet, dropping connection",
-                               addr, peer.Id.String(),
+                       govpn.Printf(
+                               `[packet-unauthenticated bind="%s" addr="%s" peer="%s"]`,
+                               *bindAddr, addr, peer.ID.String(),
                        )
                        break
                }
-               peer.NonceExpectation(nonceExpectation)
                copy(buf, buf[i+govpn.NonceSize:prev])
                prev = prev - i - govpn.NonceSize
                goto CheckMore