}
select {
case <-termSignal:
- log.Fatalln("Finishing...")
+ log.Fatalln("Finishing")
termination <- struct{}{}
break MainCycle
case <-timeouted:
if err != nil || resp.StatusCode != http.StatusOK {
log.Fatalln("Unexpected response from proxy")
}
+ log.Println("Connected to proxy:", *proxyAddr)
go handleTCP(conn, timeouted, rehandshaking, termination)
}
}
conn, err := net.DialTCP("tcp", nil, remote)
if err != nil {
- log.Fatalln("Can not connect to remote address:", err)
+ log.Fatalln("Can not connect to address:", err)
}
+ log.Println("Connected to TCP:" + *remoteAddr)
handleTCP(conn, timeouted, rehandshaking, termination)
}
default:
}
if prev == govpn.MTU {
+ 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 {
- // Either EOFed or timeouted
+ log.Println("Connection timeouted")
+ timeouted <- struct{}{}
break HandshakeCycle
}
default:
}
if prev == govpn.MTU {
+ 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 {
- // Either EOFed or timeouted
+ log.Println("Connection timeouted")
timeouted <- struct{}{}
break TransportCycle
}
continue
}
if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) {
+ log.Println("Unauthenticated packet, dropping connection")
timeouted <- struct{}{}
break TransportCycle
}
if err != nil {
log.Fatalln("Can not listen on UDP:", err)
}
+ log.Println("Connected to UDP:" + *remoteAddr)
hs := govpn.HandshakeStart(*remoteAddr, conn, conf)
buf := make([]byte, govpn.MTU)
if peer.PktProcess(buf[:n], tap, true) {
timeouts = 0
} else {
+ log.Println("Unauthenticated packet")
timeouts++
}
if atomic.LoadInt64(&peer.BytesIn)+atomic.LoadInt64(&peer.BytesOut) > govpn.MaxBytesPerKey {
}
func proxyStart() {
- log.Println("HTTP proxy listening on:", *proxy)
+ log.Println("HTTP proxy listening on:" + *proxy)
s := &http.Server{
Addr: *proxy,
Handler: proxyHandler{},
if err != nil {
log.Fatalln("Can not listen on TCP:", err)
}
- log.Println("Listening on TCP", *bindAddr)
+ log.Println("Listening on TCP:" + *bindAddr)
go func() {
for {
conn, err := listener.AcceptTCP()
continue
}
hs.Zero()
+ log.Println("Peer handshake finished:", addr, peer.Id.String())
peersByIdLock.RLock()
addrPrev, exists := peersById[*peer.Id]
peersByIdLock.RUnlock()
peersByIdLock.Unlock()
kpLock.Unlock()
go peerReady(*ps)
- log.Println("Rehandshake finished:", peer.Id.String())
+ log.Println("Rehandshake processed:", peer.Id.String())
} else {
ifaceName, err := callUp(peer.Id)
if err != nil {
peersLock.Unlock()
peersByIdLock.Unlock()
kpLock.Unlock()
- log.Println("New peer:", peer.Id.String())
+ log.Println("Peer created:", peer.Id.String())
}
break
}
continue
}
if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) {
+ log.Println(
+ "Unauthenticated packet, dropping connection",
+ addr, peer.Id.String(),
+ )
break
}
binary.BigEndian.PutUint64(nonceExpectation, peer.NonceExpect)
if err != nil {
log.Fatalln("Can not listen on UDP:", err)
}
- log.Println("Listening on UDP", *bindAddr)
+ log.Println("Listening on UDP:" + *bindAddr)
+
udpBufs <- make([]byte, govpn.MTU)
go func() {
var buf []byte
var conf *govpn.PeerConf
for {
buf = <-udpBufs
-
n, raddr, err = conn.ReadFromUDP(buf)
if err != nil {
+ log.Println("Unexpected error when receiving", err)
break
}
addr = raddr.String()
goto Finished
}
- log.Println("Peer handshake finished:", addr)
+ log.Println("Peer handshake finished:", addr, peer.Id.String())
hs.Zero()
hsLock.Lock()
delete(handshakes, addr)
<-udpBufs
<-udpBufs
}(*ps)
- log.Println("Rehandshake finished:", peer.Id.String())
+ log.Println("Rehandshake processed:", peer.Id.String())
} else {
go func(addr string, peer *govpn.Peer) {
ifaceName, err := callUp(peer.Id)
peersLock.Unlock()
peersByIdLock.Unlock()
kpLock.Unlock()
- log.Println("New peer:", peer.Id.String())
+ log.Println("Peer created:", peer.Id.String())
}(addr, peer)
}
goto Finished
}
conf = peerId.Conf()
if conf == nil {
- log.Println("Can not get peer configuration:", peerId.String())
+ log.Println("Unable to get peer configuration:", peerId.String())
goto Finished
}
hs = govpn.NewHandshake(