Optional HTTP-server providing with known peers information in JSON

[govpn.git] / cmd / govpn-client / main.go

diff --git a/cmd/govpn-client/main.go b/cmd/govpn-client/main.go
index f4a29eb82d2aea2a23d3fdb5eaad906cf41e677d..b5f86f9657a0fae84ff5b7336d2f5a8f630cf00a 100644 (file)
--- a/cmd/govpn-client/main.go
+++ b/cmd/govpn-client/main.go
@@ -36,6 +36,7 @@ var (
        keyPath    = flag.String("key", "", "Path to authentication key file")
        upPath     = flag.String("up", "", "Path to up-script")
        downPath   = flag.String("down", "", "Path to down-script")
+       stats      = flag.String("stats", "", "Enable stats retrieving on host:port")
        mtu        = flag.Int("mtu", 1500, "MTU")
        nonceDiff  = flag.Int("noncediff", 1, "Allow nonce difference")
        timeoutP   = flag.Int("timeout", 60, "Timeout seconds")
@@ -52,6 +53,7 @@ func main() {
        govpn.Noncediff = *nonceDiff
 
        id := govpn.IDDecode(*IDRaw)
+       govpn.PeersInitDummy(id)
        key := govpn.KeyRead(*keyPath)
        if id == nil {
                panic("ID is not specified")
@@ -82,17 +84,28 @@ func main() {
        var ethPkt []byte
        var udpPkt *govpn.UDPPkt
        var udpPktData []byte
+       knownPeers := govpn.KnownPeers(map[string]**govpn.Peer{remote.String(): &peer})
+
+       log.Println(govpn.VersionGet())
+       if *stats != "" {
+               log.Println("Stats are going to listen on", *stats)
+               statsPort, err := net.Listen("tcp", *stats)
+               if err != nil {
+                       panic(err)
+               }
+               go govpn.StatsProcessor(statsPort, &knownPeers)
+       }
 
        termSignal := make(chan os.Signal, 1)
        signal.Notify(termSignal, os.Interrupt, os.Kill)
 
-       log.Println("Client version", govpn.Version)
        log.Println("Starting handshake")
        handshake := govpn.HandshakeStart(conn, remote, id, key)
 
 MainCycle:
        for {
-               if peer != nil && peer.Bytes > govpn.MaxBytesPerKey {
+               if peer != nil && (peer.BytesIn+peer.BytesOut) > govpn.MaxBytesPerKey {
+                       peer.Zero()
                        peer = nil
                        handshake = govpn.HandshakeStart(conn, remote, id, key)
                        log.Println("Rehandshaking")
@@ -119,19 +132,25 @@ MainCycle:
                        }
 
                        udpPktData = udpBuf[:udpPkt.Size]
-                       if govpn.IsValidHandshakePkt(udpPktData) {
+                       if peer == nil {
                                if udpPkt.Addr.String() != remote.String() {
                                        udpReady <- struct{}{}
                                        log.Println("Unknown handshake message")
                                        continue
                                }
-                               if p := handshake.Client(conn, key, udpPktData); p != nil {
+                               if govpn.IDsCache.Find(udpPktData) == nil {
+                                       log.Println("Invalid identity in handshake packet")
+                                       udpReady <- struct{}{}
+                                       continue
+                               }
+                               if p := handshake.Client(id, conn, key, udpPktData); p != nil {
                                        log.Println("Handshake completed")
                                        if firstUpCall {
                                                go govpn.ScriptCall(*upPath, *ifaceName)
                                                firstUpCall = false
                                        }
                                        peer = p
+                                       handshake.Zero()
                                        handshake = nil
                                }
                                udpReady <- struct{}{}