From: Sergey Matveev <stargrave@stargrave.org>
Date: Sat, 16 May 2015 13:04:14 +0000 (+0300)
Subject: Replace many panic() with Fatalln less verbose and scary printing
X-Git-Tag: 3.3^2~1
X-Git-Url: http://www.git.cypherpunks.ru/?a=commitdiff_plain;h=1bc6bc30886376a2fc94d7f8f77aff1e4d9cc7ea;p=govpn.git

Replace many panic() with Fatalln less verbose and scary printing

Signed-off-by: Sergey Matveev <stargrave@stargrave.org>
---

diff --git a/src/govpn/cmd/govpn-client/main.go b/src/govpn/cmd/govpn-client/main.go
index f49edf8..a951160 100644
--- a/src/govpn/cmd/govpn-client/main.go
+++ b/src/govpn/cmd/govpn-client/main.go
@@ -53,9 +53,9 @@ func main() {
 
 	govpn.MTU = *mtu
 
-	id := govpn.IDDecode(*IDRaw)
-	if id == nil {
-		panic("ID is not specified")
+	id, err := govpn.IDDecode(*IDRaw)
+	if err != nil {
+		log.Fatalln(err)
 	}
 
 	pub, priv := govpn.NewVerifier(id, govpn.StringFromFile(*keyPath))
@@ -72,15 +72,15 @@ func main() {
 
 	bind, err := net.ResolveUDPAddr("udp", "0.0.0.0:0")
 	if err != nil {
-		panic(err)
+		log.Fatalln("Can not resolve address:", err)
 	}
 	conn, err := net.ListenUDP("udp", bind)
 	if err != nil {
-		panic(err)
+		log.Fatalln("Can not listen on UDP:", err)
 	}
 	remote, err := net.ResolveUDPAddr("udp", *remoteAddr)
 	if err != nil {
-		panic(err)
+		log.Fatalln("Can not resolve remote address:", err)
 	}
 
 	tap, ethSink, ethReady, _, err := govpn.TAPListen(
@@ -89,7 +89,7 @@ func main() {
 		*cpr,
 	)
 	if err != nil {
-		panic(err)
+		log.Fatalln("Can not listen on TAP interface:", err)
 	}
 	udpSink, udpBuf, udpReady := govpn.ConnListen(conn)
 
@@ -107,7 +107,7 @@ func main() {
 		log.Println("Stats are going to listen on", *stats)
 		statsPort, err := net.Listen("tcp", *stats)
 		if err != nil {
-			panic(err)
+			log.Fatalln("Can not listen on stats port:", err)
 		}
 		go govpn.StatsProcessor(statsPort, &knownPeers)
 	}
diff --git a/src/govpn/cmd/govpn-server/main.go b/src/govpn/cmd/govpn-server/main.go
index 8aa26ec..0a127ef 100644
--- a/src/govpn/cmd/govpn-server/main.go
+++ b/src/govpn/cmd/govpn-server/main.go
@@ -85,11 +85,11 @@ func main() {
 
 	bind, err := net.ResolveUDPAddr("udp", *bindAddr)
 	if err != nil {
-		panic(err)
+		log.Fatalln("Can not resolve bind address:", err)
 	}
 	conn, err := net.ListenUDP("udp", bind)
 	if err != nil {
-		panic(err)
+		log.Fatalln("Can listen on UDP:", err)
 	}
 	udpSink, udpBuf, udpReady := govpn.ConnListen(conn)
 
@@ -123,7 +123,7 @@ func main() {
 		log.Println("Stats are going to listen on", *stats)
 		statsPort, err := net.Listen("tcp", *stats)
 		if err != nil {
-			panic(err)
+			log.Fatalln("Can not listen on stats port:", err)
 		}
 		go govpn.StatsProcessor(statsPort, &knownPeers)
 	}
diff --git a/src/govpn/cmd/govpn-verifier/main.go b/src/govpn/cmd/govpn-verifier/main.go
index e7cc0e9..ede2de7 100644
--- a/src/govpn/cmd/govpn-verifier/main.go
+++ b/src/govpn/cmd/govpn-verifier/main.go
@@ -24,6 +24,7 @@ import (
 	"encoding/hex"
 	"flag"
 	"fmt"
+	"log"
 
 	"govpn"
 )
@@ -36,9 +37,9 @@ var (
 
 func main() {
 	flag.Parse()
-	id := govpn.IDDecode(*IDRaw)
-	if id == nil {
-		panic("ID is not specified")
+	id, err := govpn.IDDecode(*IDRaw)
+	if err != nil {
+		log.Fatalln(err)
 	}
 	pub, _ := govpn.NewVerifier(id, govpn.StringFromFile(*keyPath))
 	if *verifierPath == "" {
@@ -46,7 +47,7 @@ func main() {
 	} else {
 		verifier, err := hex.DecodeString(govpn.StringFromFile(*verifierPath))
 		if err != nil {
-			panic("Can not decode verifier")
+			log.Fatalln("Can not decode verifier:", err)
 		}
 		fmt.Println(subtle.ConstantTimeCompare(verifier[:], pub[:]) == 1)
 	}
diff --git a/src/govpn/handshake.go b/src/govpn/handshake.go
index a0bd79b..7019148 100644
--- a/src/govpn/handshake.go
+++ b/src/govpn/handshake.go
@@ -108,7 +108,7 @@ func dhKeypairGen() (*[32]byte, *[32]byte) {
 	reprFound := false
 	for !reprFound {
 		if _, err := rand.Read(priv[:]); err != nil {
-			panic("Can not read random for DH private key")
+			log.Fatalln("Error reading random for DH private key:", err)
 		}
 		reprFound = extra25519.ScalarBaseMult(pub, repr, priv)
 	}
@@ -158,7 +158,7 @@ func HandshakeStart(conf *PeerConf, conn *net.UDPConn, addr *net.UDPAddr) *Hands
 
 	state.rNonce = new([RSize]byte)
 	if _, err := rand.Read(state.rNonce[:]); err != nil {
-		panic("Can not read random for handshake nonce")
+		log.Fatalln("Error reading random for nonce:", err)
 	}
 	enc := make([]byte, 32)
 	salsa20.XORKeyStream(enc, dhPubRepr[:], state.rNonce[:], state.dsaPubH)
@@ -202,11 +202,11 @@ func (h *Handshake) Server(conn *net.UDPConn, data []byte) *Peer {
 		// Generate R* and encrypt them
 		h.rServer = new([RSize]byte)
 		if _, err := rand.Read(h.rServer[:]); err != nil {
-			panic("Can not read random for handshake random key")
+			log.Fatalln("Error reading random for R:", err)
 		}
 		h.sServer = new([SSize]byte)
 		if _, err := rand.Read(h.sServer[:]); err != nil {
-			panic("Can not read random for handshake shared key")
+			log.Fatalln("Error reading random for S:", err)
 		}
 		encRs := make([]byte, RSize+SSize)
 		salsa20.XORKeyStream(encRs, append(h.rServer[:], h.sServer[:]...), h.rNonce[:], h.key)
@@ -288,11 +288,11 @@ func (h *Handshake) Client(conn *net.UDPConn, data []byte) *Peer {
 		// Generate R* and signature and encrypt them
 		h.rClient = new([RSize]byte)
 		if _, err := rand.Read(h.rClient[:]); err != nil {
-			panic("Can not read random for handshake random key")
+			log.Fatalln("Error reading random for R:", err)
 		}
 		h.sClient = new([SSize]byte)
 		if _, err := rand.Read(h.sClient[:]); err != nil {
-			panic("Can not read random for handshake shared key")
+			log.Fatalln("Error reading random for S:", err)
 		}
 		sign := ed25519.Sign(h.Conf.DSAPriv, h.key[:])
 
diff --git a/src/govpn/identify.go b/src/govpn/identify.go
index 4363c58..663afe7 100644
--- a/src/govpn/identify.go
+++ b/src/govpn/identify.go
@@ -21,6 +21,7 @@ package govpn
 import (
 	"crypto/subtle"
 	"encoding/hex"
+	"errors"
 	"io/ioutil"
 	"log"
 	"os"
@@ -112,8 +113,8 @@ func (cc cipherCache) refresh() {
 	}
 	available := make(map[PeerId]bool)
 	for _, peerId := range peerIds {
-		id := IDDecode(peerId)
-		if id == nil {
+		id, err := IDDecode(peerId)
+		if err != nil {
 			continue
 		}
 		available[*id] = true
@@ -220,17 +221,16 @@ func (id *PeerId) Conf() *PeerConf {
 
 // Decode identification string.
 // It must be 32 hexadecimal characters long.
-// If it is not the valid one, then return nil.
-func IDDecode(raw string) *PeerId {
+func IDDecode(raw string) (*PeerId, error) {
 	if len(raw) != IDSize*2 {
-		return nil
+		return nil, errors.New("ID must be 32 characters long")
 	}
 	idDecoded, err := hex.DecodeString(raw)
 	if err != nil {
-		return nil
+		return nil, errors.New("ID must contain hexadecimal characters only")
 	}
 	idP := new([IDSize]byte)
 	copy(idP[:], idDecoded)
 	id := PeerId(*idP)
-	return &id
+	return &id, nil
 }
diff --git a/src/govpn/tap.go b/src/govpn/tap.go
index a807955..c5e3bf8 100644
--- a/src/govpn/tap.go
+++ b/src/govpn/tap.go
@@ -64,7 +64,7 @@ func NewTAP(ifaceName string) (*TAP, error) {
 			<-tap.ready
 			n, err = tap.dev.Read(tap.buf)
 			if err != nil {
-				panic(err)
+				panic("Reading TAP:" + err.Error())
 			}
 			tap.sink <- tap.buf[:n]
 		}
diff --git a/src/govpn/transport_test.go b/src/govpn/transport_test.go
index 51f0e6e..d12c26d 100644
--- a/src/govpn/transport_test.go
+++ b/src/govpn/transport_test.go
@@ -20,7 +20,7 @@ var (
 func init() {
 	MTU = 1500
 	addr, _ = net.ResolveUDPAddr("udp", "[::1]:1")
-	peerId = IDDecode("ffffffffffffffffffffffffffffffff")
+	peerId, _ = IDDecode("ffffffffffffffffffffffffffffffff")
 	conf = &PeerConf{
 		Id:          peerId,
 		Timeout:     time.Second * time.Duration(TimeoutDefault),
diff --git a/src/govpn/verifier.go b/src/govpn/verifier.go
index f86cdcc..8954047 100644
--- a/src/govpn/verifier.go
+++ b/src/govpn/verifier.go
@@ -22,6 +22,7 @@ import (
 	"bytes"
 	"crypto/sha512"
 	"io/ioutil"
+	"log"
 	"strings"
 
 	"github.com/agl/ed25519"
@@ -45,16 +46,16 @@ func NewVerifier(id *PeerId, password string) (*[ed25519.PublicKeySize]byte, *[e
 	src := bytes.NewBuffer(r)
 	pub, priv, err := ed25519.GenerateKey(src)
 	if err != nil {
-		panic("Unable to generate Ed25519 keypair" + err.Error())
+		log.Fatalln("Unable to generate Ed25519 keypair", err)
 	}
 	return pub, priv
 }
 
-// Read string from the file, trimming newline. Panics if error occured.
+// Read string from the file, trimming newline.
 func StringFromFile(path string) string {
 	s, err := ioutil.ReadFile(path)
 	if err != nil {
-		panic("Can not read string from" + path)
+		log.Fatalln("Can not read string from", path, err)
 	}
 	return strings.TrimRight(string(s), "\n")
 }