func handleTCP(conn *net.TCPConn, timeouted, rehandshaking, termination chan struct{}) { hs := govpn.HandshakeStart(*remoteAddr, conn, conf) buf := make([]byte, 2*(govpn.EnclessEnlargeSize+*mtu)+*mtu) var n int var err error var prev int var peer *govpn.Peer var terminator chan struct{} HandshakeCycle: for { select { case <-termination: break HandshakeCycle default: } if prev == len(buf) { log.Println("Timeouted waiting for the packet") timeouted <- struct{}{} break HandshakeCycle } conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second)) n, err = conn.Read(buf[prev:]) if err != nil { log.Println("Connection timeouted") timeouted <- struct{}{} break HandshakeCycle } prev += n peerId := idsCache.Find(buf[:prev]) if peerId == nil { continue } peer = hs.Client(buf[:prev]) prev = 0 if peer == nil { continue } log.Println("Handshake completed") knownPeers = govpn.KnownPeers(map[string]**govpn.Peer{*remoteAddr: &peer}) if firstUpCall { go govpn.ScriptCall(*upPath, *ifaceName) firstUpCall = false } hs.Zero() terminator = make(chan struct{}) go func() { heartbeat := time.NewTicker(peer.Timeout) var data []byte Processor: for { select { case <-heartbeat.C: peer.EthProcess(nil) case <-terminator: break Processor case data = <-tap.Sink: peer.EthProcess(data) } } heartbeat.Stop() peer.Zero() }() break HandshakeCycle } if hs != nil { hs.Zero() } if peer == nil { return } nonceExpectation := make([]byte, govpn.NonceSize) peer.NonceExpectation(nonceExpectation) prev = 0 var i int TransportCycle: for { select { case <-termination: break TransportCycle default: } if prev == len(buf) { log.Println("Timeouted waiting for the packet") timeouted <- struct{}{} break TransportCycle } conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second)) n, err = conn.Read(buf[prev:]) if err != nil { log.Println("Connection timeouted") timeouted <- struct{}{} break TransportCycle } prev += n CheckMore: if prev < govpn.MinPktLength { continue } i = bytes.Index(buf[:prev], nonceExpectation) if i == -1 { continue } if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) { log.Println("Unauthenticated packet, dropping connection") timeouted <- struct{}{} break TransportCycle } if atomic.LoadUint64(&peer.BytesIn)+atomic.LoadUint64(&peer.BytesOut) > govpn.MaxBytesPerKey { log.Println("Need rehandshake") rehandshaking <- struct{}{} break TransportCycle } peer.NonceExpectation(nonceExpectation) copy(buf, buf[i+govpn.NonceSize:prev]) prev = prev - i - govpn.NonceSize goto CheckMore } if terminator != nil { terminator <- struct{}{} } peer.Zero() conn.Close() }