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 f49edf8de8c05be0a87c7633e18aaace92e5eeea..a951160a21d7ce737e01d53188b3fa4b70a272df 100644 (file)
--- 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 8aa26ec83bdb8878766fd28efd96c06f6a6e9d98..0a127efa78104147f93b0a48e72853ba910ed21b 100644 (file)
--- 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 e7cc0e9ec4a3ecf1c211298480523ca523a314e5..ede2de7438a370c43f770120a818ed454a453b71 100644 (file)
--- 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 a0bd79bd8820238dc64a8d6a8efbce63b7921ee2..7019148e899949f754435bdbad61c2042963350c 100644 (file)
--- 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 4363c58d39fd9bd001b8aaae73cab6c8e2b93e81..663afe73599bf14b8fc40acf7e2b738c9ae6d7e6 100644 (file)
--- 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 a80795534a70adf431b183c5d339e2ca61c51706..c5e3bf835cfee5f993f4eeff946c035bd005617e 100644 (file)
--- 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 51f0e6e322f17efa25edfabe9484c8a587b6e134..d12c26dacb68210e1f54ebf8d93ced4580d9eb3f 100644 (file)
--- 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 f86cdcce1f1b73d5fbf25eb857aa1baf5c8f9586..895404792cfd9edcdff67e28f43528d724adb026 100644 (file)
--- 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")
 }