}
select {
case <-termSignal:
- log.Println("Finishing")
- govpn.Println("Finishing")
+ govpn.BothPrintf(`[finish remote="%s"]`, *remoteAddr)
termination <- struct{}{}
break MainCycle
case <-timeouted:
if err != nil || resp.StatusCode != http.StatusOK {
log.Fatalln("Unexpected response from proxy")
}
- govpn.Println("Connected to proxy:", *proxyAddr)
+ govpn.Printf(`[proxy-connected remote="%s" addr="%s"]`, *remoteAddr, *proxyAddr)
go handleTCP(conn, timeouted, rehandshaking, termination)
}
if err != nil {
log.Fatalln("Can not connect to address:", err)
}
- govpn.Println("Connected to TCP:" + *remoteAddr)
+ govpn.Printf(`[connected remote="%s"]`, *remoteAddr)
handleTCP(conn, timeouted, rehandshaking, termination)
}
default:
}
if prev == len(buf) {
- govpn.Println("Timeouted waiting for the packet")
+ govpn.Printf(`[packet-timeouted remote="%s"]`, *remoteAddr)
timeouted <- struct{}{}
break HandshakeCycle
}
conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
n, err = conn.Read(buf[prev:])
if err != nil {
- govpn.Println("Connection timeouted")
+ govpn.Printf(`[connection-timeouted remote="%s"]`, *remoteAddr)
timeouted <- struct{}{}
break HandshakeCycle
}
if peer == nil {
continue
}
- govpn.Println("Handshake completed")
+ govpn.Printf(`[handshake-completed remote="%s"]`, *remoteAddr)
knownPeers = govpn.KnownPeers(map[string]**govpn.Peer{*remoteAddr: &peer})
if firstUpCall {
go govpn.ScriptCall(*upPath, *ifaceName, *remoteAddr)
default:
}
if prev == len(buf) {
- govpn.Println("Timeouted waiting for the packet")
+ govpn.Printf(`[packet-timeouted remote="%s"]`, *remoteAddr)
timeouted <- struct{}{}
break TransportCycle
}
conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
n, err = conn.Read(buf[prev:])
if err != nil {
- govpn.Println("Connection timeouted")
+ govpn.Printf(`[connection-timeouted remote="%s"]`, *remoteAddr)
timeouted <- struct{}{}
break TransportCycle
}
continue
}
if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) {
- govpn.Println("Unauthenticated packet, dropping connection")
+ govpn.Printf(`[packet-unauthenticated remote="%s"]`, *remoteAddr)
timeouted <- struct{}{}
break TransportCycle
}
if atomic.LoadUint64(&peer.BytesIn)+atomic.LoadUint64(&peer.BytesOut) > govpn.MaxBytesPerKey {
- govpn.Println("Need rehandshake")
+ govpn.Printf(`[rehandshake-required remote="%s"]`, *remoteAddr)
rehandshaking <- struct{}{}
break TransportCycle
}
if err != nil {
log.Fatalln("Can not listen on UDP:", err)
}
- govpn.Println("Connected to UDP:" + *remoteAddr)
+ govpn.Printf(`[connected remote="%s"]`, *remoteAddr)
hs := govpn.HandshakeStart(*remoteAddr, conn, conf)
buf := make([]byte, *mtu*2)
conn.SetReadDeadline(time.Now().Add(time.Second))
n, err = conn.Read(buf)
if timeouts == timeout {
- govpn.Println("Timeouted")
+ govpn.Printf(`[connection-timeouted remote="%s"]`, *remoteAddr)
timeouted <- struct{}{}
break
}
if peer.PktProcess(buf[:n], tap, true) {
timeouts = 0
} else {
- govpn.Println("Unauthenticated packet")
+ govpn.Printf(`[packet-unauthenticated remote="%s"]`, *remoteAddr)
timeouts++
}
if atomic.LoadUint64(&peer.BytesIn)+atomic.LoadUint64(&peer.BytesOut) > govpn.MaxBytesPerKey {
- govpn.Println("Need rehandshake")
+ govpn.Printf(`[rehandshake-required remote="%s"]`, *remoteAddr)
rehandshaking <- struct{}{}
break MainCycle
}
continue
}
if idsCache.Find(buf[:n]) == nil {
- govpn.Println("Invalid identity in handshake packet")
+ govpn.Printf(`[identity-invalid remote="%s"]`, *remoteAddr)
continue
}
timeouts = 0
if peer == nil {
continue
}
- govpn.Println("Handshake completed")
+ govpn.Printf(`[handshake-completed remote="%s"]`, *remoteAddr)
knownPeers = govpn.KnownPeers(map[string]**govpn.Peer{*remoteAddr: &peer})
if firstUpCall {
go govpn.ScriptCall(*upPath, *ifaceName, *remoteAddr)
if confs[*peerId].Up != "" {
result, err := govpn.ScriptCall(confs[*peerId].Up, ifaceName, remoteAddr)
if err != nil {
- govpn.Println("Script", confs[*peerId].Up, "call failed", err)
+ govpn.Printf(`[script-failed bind="%s" path="%s" err="%s"]`, *bindAddr, confs[*peerId].Up, err)
return "", err
}
if ifaceName == "" {
}
}
if ifaceName == "" {
- govpn.Println("Can not obtain interface name for", *peerId)
+ govpn.Printf(`[tap-failed bind="%s" peer="%s"]`, *bindAddr, *peerId)
}
return ifaceName, nil
}
pc.MTU = govpn.MTUDefault
}
if pc.MTU > govpn.MTUMax {
- govpn.Println("MTU value", pc.MTU, "is too high, overriding to", govpn.MTUMax)
+ govpn.Printf(`[mtu-high bind="%s" value="%d" overriden="%d"]`, *bindAddr, pc.MTU, govpn.MTUMax)
pc.MTU = govpn.MTUMax
}
conf := govpn.PeerConf{
func confRefresh() error {
newConfs, err := confRead()
if err != nil {
- govpn.Println("Unable to parse peers configuration:", err)
+ govpn.Printf(`[conf-parse-failed bind="%s" err="%s"]`, *bindAddr, err)
return err
}
confs = *newConfs
govpn.EGDInit(*egdPath)
}
+ if *syslog {
+ govpn.SyslogEnable()
+ }
+
switch *proto {
case "udp":
startUDP()
if *proxy != "" {
go proxyStart()
}
-
- if *syslog {
- govpn.SyslogEnable()
- }
- log.Println("Server started")
- govpn.Println("Server started")
+ govpn.BothPrintf(`[started bind="%s"]`, *bindAddr)
var needsDeletion bool
MainCycle:
for {
select {
case <-termSignal:
- log.Println("Terminating")
- govpn.Println("Terminating")
+ govpn.BothPrintf(`[terminating bind="%s"]`, *bindAddr)
for _, ps := range peers {
govpn.ScriptCall(
confs[*ps.peer.Id].Down,
hsLock.Lock()
for addr, hs := range handshakes {
if hs.LastPing.Add(timeout).Before(now) {
- govpn.Println("Deleting handshake state", addr)
+ govpn.Printf(`[handshake-delete bind="%s" addr="%s"]`, *bindAddr, addr)
hs.Zero()
delete(handshakes, addr)
}
needsDeletion = ps.peer.LastPing.Add(timeout).Before(now)
ps.peer.BusyR.Unlock()
if needsDeletion {
- govpn.Println("Deleting peer", ps.peer)
+ govpn.Printf(`[peer-delete bind="%s" peer="%s"]`, *bindAddr, ps.peer)
delete(peers, addr)
delete(knownPeers, addr)
delete(peersById, *ps.peer.Id)
package main
import (
- "log"
"net/http"
"cypherpunks.ru/govpn"
func (p proxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
conn, _, err := w.(http.Hijacker).Hijack()
if err != nil {
- govpn.Println("Hijacking failed:", err.Error())
+ govpn.Printf(`[proxy-hijack-failed bind="%s" err="%s"]`, *bindAddr, err)
return
}
conn.Write([]byte("HTTP/1.0 200 OK\n\n"))
}
func proxyStart() {
- log.Println("HTTP proxy listening on:" + *proxy)
- govpn.Println("HTTP proxy listening on:" + *proxy)
+ govpn.BothPrintf(`[proxy-listen bind="%s" addr="%s"]`, *bindAddr, *proxy)
s := &http.Server{
Addr: *proxy,
Handler: proxyHandler{},
}
- log.Println("HTTP proxy result:", s.ListenAndServe())
- govpn.Println("HTTP proxy result:", s.ListenAndServe())
+ govpn.BothPrintf(`[proxy-finished bind="%s" result="%s"]`, *bindAddr, s.ListenAndServe())
}
if err != nil {
log.Fatalln("Can not listen on TCP:", err)
}
- log.Println("Listening on TCP:" + *bindAddr)
- govpn.Println("Listening on TCP:" + *bindAddr)
+ govpn.BothPrintf(`[tcp-listen bind="%s"]`, *bindAddr)
go func() {
for {
conn, err := listener.AcceptTCP()
if err != nil {
- govpn.Println("Error accepting TCP:", err)
+ govpn.Printf(`[tcp-accept-failed bind="%s" err="%s"]`, *bindAddr, err)
continue
}
go handleTCP(conn)
if hs == nil {
conf = confs[*peerId]
if conf == nil {
- govpn.Println("Can not get peer configuration:", peerId.String())
+ govpn.Printf(
+ `[conf-get-failed bind="%s" peer="%s"]`,
+ *bindAddr, peerId.String(),
+ )
break
}
hs = govpn.NewHandshake(addr, conn, conf)
continue
}
hs.Zero()
- govpn.Println("Peer handshake finished:", addr, peer.Id.String())
+ govpn.Printf(
+ `[handshake-completed bind="%s" addr="%s" peer="%s"]`,
+ *bindAddr, addr, peerId.String(),
+ )
peersByIdLock.RLock()
addrPrev, exists := peersById[*peer.Id]
peersByIdLock.RUnlock()
peersLock.Unlock()
peersByIdLock.Unlock()
kpLock.Unlock()
- govpn.Println("Rehandshake processed:", peer.Id.String())
+ govpn.Printf(
+ `[rehandshake-completed bind="%s" peer="%s"]`,
+ *bindAddr, peerId.String(),
+ )
} else {
ifaceName, err := callUp(peer.Id, peer.Addr)
if err != nil {
}
tap, err = govpn.TAPListen(ifaceName, peer.MTU)
if err != nil {
- govpn.Println("Unable to create TAP:", err)
+ govpn.Printf(
+ `[tap-failed bind="%s" peer="%s" err="%s"]`,
+ *bindAddr, peerId.String(), err,
+ )
peer = nil
break
}
peersLock.Unlock()
peersByIdLock.Unlock()
kpLock.Unlock()
- govpn.Println("Peer created:", peer.Id.String())
+ govpn.Printf(`[peer-created bind="%s" peer="%s"]`, *bindAddr, peerId.String())
}
break
}
continue
}
if !peer.PktProcess(buf[:i+govpn.NonceSize], tap, false) {
- govpn.Println(
- "Unauthenticated packet, dropping connection",
- addr, peer.Id.String(),
+ govpn.Printf(
+ `[packet-unauthenticated bind="%s" addr="%s" peer="%s"]`,
+ *bindAddr, addr, peer.Id.String(),
)
break
}
if err != nil {
log.Fatalln("Can not listen on UDP:", err)
}
- log.Println("Listening on UDP:" + *bindAddr)
- govpn.Println("Listening on UDP:" + *bindAddr)
+ govpn.BothPrintf(`[udp-listen bind="%s"]`, *bindAddr)
udpBufs <- make([]byte, govpn.MTUMax)
go func() {
buf = <-udpBufs
n, raddr, err = conn.ReadFromUDP(buf)
if err != nil {
- govpn.Println("Unexpected error when receiving", err)
+ govpn.Printf(`[receive-failed bind="%s" err="%s"]`, *bindAddr, err)
break
}
addr = raddr.String()
goto Finished
}
- govpn.Println("Peer handshake finished:", addr, peer.Id.String())
+ govpn.Printf(
+ `[handshake-completed bind="%s" addr="%s" peer="%s"]`,
+ *bindAddr, addr, peerId.String(),
+ )
hs.Zero()
hsLock.Lock()
delete(handshakes, addr)
peersLock.Unlock()
peersByIdLock.Unlock()
kpLock.Unlock()
- govpn.Println("Rehandshake processed:", peer.Id.String())
+ govpn.Printf(
+ `[rehandshake-completed bind="%s" peer="%s"]`,
+ *bindAddr, peer.Id.String(),
+ )
} else {
go func(addr string, peer *govpn.Peer) {
ifaceName, err := callUp(peer.Id, peer.Addr)
}
tap, err := govpn.TAPListen(ifaceName, peer.MTU)
if err != nil {
- govpn.Println("Unable to create TAP:", err)
+ govpn.Printf(
+ `[tap-failed bind="%s" peer="%s" err="%s"]`,
+ *bindAddr, peer.Id.String(), err,
+ )
return
}
ps = &PeerState{
peersLock.Unlock()
peersByIdLock.Unlock()
kpLock.Unlock()
- govpn.Println("Peer created:", peer.Id.String())
+ govpn.Printf(`[peer-created bind="%s" peer="%s"]`, *bindAddr, peer.Id.String())
}(addr, peer)
}
goto Finished
CheckID:
peerId = idsCache.Find(buf[:n])
if peerId == nil {
- govpn.Println("Unknown identity from:", addr)
+ govpn.Printf(`[identity-unknown bind="%s" addr="%s"]`, *bindAddr, addr)
goto Finished
}
conf = confs[*peerId]
if conf == nil {
- govpn.Println("Unable to get peer configuration:", peerId.String())
+ govpn.Printf(
+ `[conf-get-failed bind="%s" peer="%s"]`,
+ *bindAddr, peerId.String(),
+ )
goto Finished
}
hs = govpn.NewHandshake(
}
}
-// Call either syslog-related logger.Println if SyslogEnabled,
-// default log.Println otherwise.
-func Println(v ...interface{}) {
+// Call either syslog-related logger.Printf if SyslogEnabled,
+// default log.Printf otherwise.
+func Printf(f string, v ...interface{}) {
if sysloger == nil {
- log.Println(v...)
+ log.Printf(f, v...)
} else {
- sysloger.Println(v...)
+ sysloger.Printf(f, v...)
+ }
+}
+
+// Call both default log.Printf and syslog-related one.
+func BothPrintf(f string, v ...interface{}) {
+ log.Printf(f, v...)
+ if sysloger != nil {
+ sysloger.Printf(f, v...)
}
}