src/cypherpunks.ru/govpn/cmd/govpn-server/tcp.go

   1 /*
   2 GoVPN -- simple secure free software virtual private network daemon
   3 Copyright (C) 2014-2017 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         "log"
  24         "net"
  25         "time"
  26
  27         "cypherpunks.ru/govpn"
  28 )
  29
  30 func startTCP() {
  31         bind, err := net.ResolveTCPAddr("tcp", *bindAddr)
  32         if err != nil {
  33                 log.Fatalln("Can not resolve bind address:", err)
  34         }
  35         listener, err := net.ListenTCP("tcp", bind)
  36         if err != nil {
  37                 log.Fatalln("Can not listen on TCP:", err)
  38         }
  39         govpn.BothPrintf(`[tcp-listen bind="%s"]`, *bindAddr)
  40         go func() {
  41                 for {
  42                         conn, err := listener.AcceptTCP()
  43                         if err != nil {
  44                                 govpn.Printf(`[tcp-accept-failed bind="%s" err="%s"]`, *bindAddr, err)
  45                                 continue
  46                         }
  47                         go handleTCP(conn)
  48                 }
  49         }()
  50 }
  51
  52 func handleTCP(conn net.Conn) {
  53         addr := conn.RemoteAddr().String()
  54         buf := make([]byte, govpn.EnclessEnlargeSize+2*govpn.MTUMax)
  55         var n int
  56         var err error
  57         var prev int
  58         var hs *govpn.Handshake
  59         var ps *PeerState
  60         var peer *govpn.Peer
  61         var tap *govpn.TAP
  62         var conf *govpn.PeerConf
  63         var addrPrev string
  64         var peerPrevI interface{}
  65         var peerPrev *PeerState
  66         for {
  67                 if prev == len(buf) {
  68                         break
  69                 }
  70                 conn.SetReadDeadline(time.Now().Add(time.Duration(govpn.TimeoutDefault) * time.Second))
  71                 n, err = conn.Read(buf[prev:])
  72                 if err != nil {
  73                         // Either EOFed or timeouted
  74                         break
  75                 }
  76                 prev += n
  77                 peerID := idsCache.Find(buf[:prev])
  78                 if peerID == nil {
  79                         continue
  80                 }
  81                 if hs == nil {
  82                         conf = confs[*peerID]
  83                         if conf == nil {
  84                                 govpn.Printf(
  85                                         `[conf-get-failed bind="%s" peer="%s"]`,
  86                                         *bindAddr, peerID.String(),
  87                                 )
  88                                 break
  89                         }
  90                         hs = govpn.NewHandshake(addr, conn, conf)
  91                 }
  92                 peer = hs.Server(buf[:prev])
  93                 prev = 0
  94                 if peer == nil {
  95                         continue
  96                 }
  97                 hs.Zero()
  98                 govpn.Printf(
  99                         `[handshake-completed bind="%s" addr="%s" peer="%s"]`,
 100                         *bindAddr, addr, peerID.String(),
 101                 )
 102                 addrPrevI, exists := peersByID.Load(*peer.ID)
 103                 if exists {
 104                         addrPrev = addrPrevI.(string)
 105                         peerPrevI, exists = peers.Load(addrPrev)
 106                         if exists {
 107                                 peerPrev = peerPrevI.(*PeerState)
 108                                 exists = peerPrev == nil
 109                         }
 110                 }
 111                 if exists {
 112                         peerPrev.terminator <- struct{}{}
 113                         tap = peerPrev.tap
 114                         ps = &PeerState{
 115                                 peer:       peer,
 116                                 tap:        tap,
 117                                 terminator: make(chan struct{}),
 118                         }
 119                         go govpn.PeerTapProcessor(ps.peer, ps.tap, ps.terminator)
 120                         peers.Delete(addrPrev)
 121                         peers.Store(addr, ps)
 122                         knownPeers.Delete(addrPrev)
 123                         knownPeers.Store(addr, &peer)
 124                         peersByID.Store(*peer.ID, addr)
 125                         govpn.Printf(
 126                                 `[rehandshake-completed bind="%s" peer="%s"]`,
 127                                 *bindAddr, peerID.String(),
 128                         )
 129                 } else {
 130                         ifaceName, err := callUp(peer.ID, peer.Addr)
 131                         if err != nil {
 132                                 peer = nil
 133                                 break
 134                         }
 135                         tap, err = govpn.TAPListen(ifaceName, peer.MTU)
 136                         if err != nil {
 137                                 govpn.Printf(
 138                                         `[tap-failed bind="%s" peer="%s" err="%s"]`,
 139                                         *bindAddr, peerID.String(), err,
 140                                 )
 141                                 peer = nil
 142                                 break
 143                         }
 144                         ps = &PeerState{
 145                                 peer:       peer,
 146                                 tap:        tap,
 147                                 terminator: make(chan struct{}, 1),
 148                         }
 149                         go govpn.PeerTapProcessor(ps.peer, ps.tap, ps.terminator)
 150                         peers.Store(addr, ps)
 151                         peersByID.Store(*peer.ID, addr)
 152                         knownPeers.Store(addr, &peer)
 153                         govpn.Printf(`[peer-created bind="%s" peer="%s"]`, *bindAddr, peerID.String())
 154                 }
 155                 break
 156         }
 157         if hs != nil {
 158                 hs.Zero()
 159         }
 160         if peer == nil {
 161                 return
 162         }
 163
 164         prev = 0
 165         var i int
 166         for {
 167                 if prev == len(buf) {
 168                         break
 169                 }
 170                 conn.SetReadDeadline(time.Now().Add(conf.Timeout))
 171                 n, err = conn.Read(buf[prev:])
 172                 if err != nil {
 173                         // Either EOFed or timeouted
 174                         break
 175                 }
 176                 prev += n
 177         CheckMore:
 178                 if prev < govpn.MinPktLength {
 179                         continue
 180                 }
 181                 i = bytes.Index(buf[:prev], peer.NonceExpect)
 182                 if i == -1 {
 183                         continue
 184                 }
 185                 if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) {
 186                         govpn.Printf(
 187                                 `[packet-unauthenticated bind="%s" addr="%s" peer="%s"]`,
 188                                 *bindAddr, addr, peer.ID.String(),
 189                         )
 190                         break
 191                 }
 192                 copy(buf, buf[i+govpn.NonceSize:prev])
 193                 prev = prev - i - govpn.NonceSize
 194                 goto CheckMore
 195         }
 196         peer.Zero()
 197 }