src/govpn/cmd/govpn-client/tcp.go

   1 /*
   2 GoVPN -- simple secure free software virtual private network daemon
   3 Copyright (C) 2014-2015 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 package main
  20
  21 import (
  22         "bytes"
  23         "encoding/binary"
  24         "log"
  25         "net"
  26         "sync/atomic"
  27         "time"
  28
  29         "govpn"
  30 )
  31
  32 func startTCP(timeouted, rehandshaking, termination chan struct{}) {
  33         remote, err := net.ResolveTCPAddr("tcp", *remoteAddr)
  34         if err != nil {
  35                 log.Fatalln("Can not resolve remote address:", err)
  36         }
  37         conn, err := net.DialTCP("tcp", nil, remote)
  38         if err != nil {
  39                 log.Fatalln("Can not connect to remote address:", err)
  40         }
  41         handleTCP(conn, timeouted, rehandshaking, termination)
  42 }
  43
  44 func handleTCP(conn *net.TCPConn, timeouted, rehandshaking, termination chan struct{}) {
  45         hs := govpn.HandshakeStart(*remoteAddr, conn, conf)
  46         buf := make([]byte, govpn.MTU)
  47         var n int
  48         var err error
  49         var prev int
  50         var peer *govpn.Peer
  51         var terminator chan struct{}
  52 HandshakeCycle:
  53         for {
  54                 select {
  55                 case <-termination:
  56                         break HandshakeCycle
  57                 default:
  58                 }
  59                 if prev == govpn.MTU {
  60                         break HandshakeCycle
  61                 }
  62
  63                 conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
  64                 n, err = conn.Read(buf[prev:])
  65                 if err != nil {
  66                         // Either EOFed or timeouted
  67                         break HandshakeCycle
  68                 }
  69
  70                 prev += n
  71                 peerId := govpn.IDsCache.Find(buf[:prev])
  72                 if peerId == nil {
  73                         continue
  74                 }
  75                 peer = hs.Client(buf[:prev])
  76                 prev = 0
  77                 if peer == nil {
  78                         continue
  79                 }
  80                 log.Println("Handshake completed")
  81                 knownPeers = govpn.KnownPeers(map[string]**govpn.Peer{*remoteAddr: &peer})
  82                 if firstUpCall {
  83                         go govpn.ScriptCall(*upPath, *ifaceName)
  84                         firstUpCall = false
  85                 }
  86                 hs.Zero()
  87                 terminator = make(chan struct{})
  88                 go func() {
  89                         heartbeat := time.NewTicker(peer.Timeout)
  90                         var data []byte
  91                 Processor:
  92                         for {
  93                                 select {
  94                                 case <-heartbeat.C:
  95                                         peer.EthProcess(nil)
  96                                 case <-terminator:
  97                                         break Processor
  98                                 case data = <-tap.Sink:
  99                                         peer.EthProcess(data)
 100                                 }
 101                         }
 102                         heartbeat.Stop()
 103                         peer.Zero()
 104                 }()
 105                 break HandshakeCycle
 106         }
 107         if hs != nil {
 108                 hs.Zero()
 109         }
 110         if peer == nil {
 111                 return
 112         }
 113
 114         nonceExpectation := make([]byte, govpn.NonceSize)
 115         binary.BigEndian.PutUint64(nonceExpectation, peer.NonceExpect)
 116         peer.NonceCipher.Encrypt(nonceExpectation, nonceExpectation)
 117         prev = 0
 118         var i int
 119 TransportCycle:
 120         for {
 121                 select {
 122                 case <-termination:
 123                         break TransportCycle
 124                 default:
 125                 }
 126                 if prev == govpn.MTU {
 127                         timeouted <- struct{}{}
 128                         break TransportCycle
 129                 }
 130                 conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
 131                 n, err = conn.Read(buf[prev:])
 132                 if err != nil {
 133                         // Either EOFed or timeouted
 134                         timeouted <- struct{}{}
 135                         break TransportCycle
 136                 }
 137                 prev += n
 138         CheckMore:
 139                 i = bytes.Index(buf[:prev], nonceExpectation)
 140                 if i == -1 {
 141                         continue
 142                 }
 143                 if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) {
 144                         timeouted <- struct{}{}
 145                         break TransportCycle
 146                 }
 147                 if atomic.LoadInt64(&peer.BytesIn)+atomic.LoadInt64(&peer.BytesOut) > govpn.MaxBytesPerKey {
 148                         log.Println("Need rehandshake")
 149                         rehandshaking <- struct{}{}
 150                         break TransportCycle
 151                 }
 152                 binary.BigEndian.PutUint64(nonceExpectation, peer.NonceExpect)
 153                 peer.NonceCipher.Encrypt(nonceExpectation, nonceExpectation)
 154                 copy(buf, buf[i+govpn.NonceSize:prev])
 155                 prev = prev - i - govpn.NonceSize
 156                 goto CheckMore
 157         }
 158         if terminator != nil {
 159                 terminator <- struct{}{}
 160         }
 161         peer.Zero()
 162 }