add log() and go-arg

Signed-off-by: Jeff Carr <jcarr@wit.com>

README.md

@@ -1,3 +1,13 @@
+# Intro
+
 Attempt at some code to validate via DNS / DNSSEC
 the hostname is valid on a simple socket listen
 server
+
+This recursively runs from the root TLD's and purposesly bypasses
+any DNS cache so that the DNS <-> IP address mappings can be verified
+
+## References
+
+* https://github.com/mactsouk/opensource.com.git
+* https://coderwall.com/p/wohavg/creating-a-simple-tcp-server-in-go

args.go

@@ -0,0 +1,45 @@
+package dnssecsocket
+
+//
+// By using the package "github.com/alexflint/go-arg",
+// these can be configured from the command line
+//
+
+import (
+	// arg "github.com/alexflint/go-arg"
+	// "log"
+	// "os"
+)
+
+type Args struct {
+	VerboseDnssec bool `arg:"--verbose-dnssec" help:"debug dnssec lookups"`
+	Foo string `arg:"env:USER"`
+}
+
+var args struct {
+	Args
+	Verbose bool
+}
+
+func Parse (b bool) {
+	args.Verbose = b
+	args.VerboseDnssec = b
+}
+
+// I attempted to pass the *arg.Parser down
+// to see if I could find the value somewhere but I couldn't find it
+/*
+var conf arg.Config
+
+func Parse (p *arg.Parser) {
+	// conf.Program = "control-panel-dns"
+	// conf.IgnoreEnv = false
+	// arg.NewParser(conf, &args)
+	log.Println("fuckit", p, args.VerboseDnssec)
+	for i, v := range p.SubcommandNames() {
+		log.Println("dnssec.Parse", i, v)
+	}
+	p.Jcarr()
+	exit()
+}
+*/

connection_handler.go

@@ -11,7 +11,7 @@ import "math/rand"
 import "net"
 import "strconv"
 import "strings"
-import log "github.com/sirupsen/logrus"
+// import log "github.com/sirupsen/logrus"
 // import "github.com/wercker/journalhook"
 
 import "git.wit.org/wit/shell"
@@ -49,41 +49,41 @@ func HandleConnection(conn *net.TCPConn) {
 	// spew.Dump(conn)
 	// ipv6client := GetRemoteAddr(c)
 	ipv6client := conn.RemoteAddr()
-	log.Println("Serving to %s as the IPv6 client", ipv6client)
+	log(args.VerboseDnssec, "Serving to %s as the IPv6 client", ipv6client)
 
 	// setup this TCP socket as the "standard input"
 	// newStdin, _ := bufio.NewReader(conn.File())
 	newStdin, _ := conn.File()
 	newreader := bufio.NewReader(newStdin)
 
-	log.Println("Waiting for the client to tell me its name")
+	log(args.VerboseDnssec, "Waiting for the client to tell me its name")
 	netData, err := newreader.ReadString('\n')
 	if err != nil {
-		log.Println(err)
+		log(args.VerboseDnssec, err)
 		return
 	}
 	clientHostname := strings.TrimSpace(netData)
-	log.Println("Recieved client hostname as:", clientHostname)
+	log(args.VerboseDnssec, "Recieved client hostname as:", clientHostname)
 
 	dnsRR := Dnstrace(clientHostname, "AAAA")
 	if (dnsRR == nil) {
-		log.Println("dnsRR IS NIL")
+		log(args.VerboseDnssec, "dnsRR IS NIL")
-		log.Println("dnsRR IS NIL")
+		log(args.VerboseDnssec, "dnsRR IS NIL")
-		log.Println("dnsRR IS NIL")
+		log(args.VerboseDnssec, "dnsRR IS NIL")
 		conn.Close()
 		return
 	}
 	ipaddr := dns.Field(dnsRR[1], 1)
-	log.Println("Client claims to be:   ", ipaddr)
+	log(args.VerboseDnssec, "Client claims to be:   ", ipaddr)
-	log.Println("Serving to IPv6 client:", ipv6client)
+	log(args.VerboseDnssec, "Serving to IPv6 client:", ipv6client)
 
 /* TODO: figure out how to fix this check
 	if (ipaddr != ipv6client) {
-		log.Println()
+		log(args.VerboseDnssec)
-		log.Println("DNSSEC ERROR: client IPv6 does not work")
+		log(args.VerboseDnssec, "DNSSEC ERROR: client IPv6 does not work")
-		log.Println("DNSSEC ERROR: client IPv6 does not work")
+		log(args.VerboseDnssec, "DNSSEC ERROR: client IPv6 does not work")
-		log.Println("DNSSEC ERROR: client IPv6 does not work")
+		log(args.VerboseDnssec, "DNSSEC ERROR: client IPv6 does not work")
-		log.Println()
+		log(args.VerboseDnssec)
 		conn.Close()
 		return
 	}
@@ -101,7 +101,7 @@ func HandleConnection(conn *net.TCPConn) {
 		defer conn.Close()
 		netData, err := newreader.ReadString('\n')
 		if err != nil {
-			log.Println(err)
+			log(args.VerboseDnssec, err)
 			return
 		}
 
@@ -109,17 +109,17 @@ func HandleConnection(conn *net.TCPConn) {
 		if temp == "STOP" {
 			break
 		}
-		log.Println("Recieved: ", temp)
+		log(args.VerboseDnssec, "Recieved: ", temp)
 
 		if (temp == "list") {
-			log.Println("Should run list here")
+			log(args.VerboseDnssec, "Should run list here")
 			shell.SetStdout(f)
 			shell.Run("/root/bin/list.testing.com")
 			shell.SetStdout(os.Stdout)
 		}
 
 		if (temp == "cpuinfo") {
-			log.Println("Should cat /proc/cpuinfo")
+			log(args.VerboseDnssec, "Should cat /proc/cpuinfo")
 			shell.SetStdout(f)
 			shell.Run("cat /proc/cpuinfo")
 			shell.SetStdout(os.Stdout)

dnstrace.go

@@ -4,14 +4,14 @@ package dnssecsocket
 
 import "fmt"
 import "net"
-import "os"
+// import "os"
 import "strings"
 import "time"
 
 import "github.com/miekg/dns"
 import "github.com/rs/dnstrace/client"
 
-import log "github.com/sirupsen/logrus"
+// import log "github.com/sirupsen/logrus"
 
 // this is cool, but breaks the Windows build
 // import "github.com/wercker/journalhook"
@@ -75,13 +75,13 @@ func Dnstrace(hostname string, qtypestr string) []dns.RR {
 			qname := m.Question[0].Name
 			qtype := dns.TypeToString[m.Question[0].Qtype]
 			if i > 1 {
-				log.Println()
+				log(args.VerboseDnssec)
 			}
-			log.Printf("%d - query %s %s", i, qtype, qname)
+			log(args.VerboseDnssec, "%d - query %s %s", i, qtype, qname)
 			if r != nil {
-				log.Printf(": %s", strings.Replace(strings.Replace(r.MsgHdr.String(), ";; ", "", -1), "\n", ", ", -1))
+				log(args.VerboseDnssec, ": %s", strings.Replace(strings.Replace(r.MsgHdr.String(), ";; ", "", -1), "\n", ", ", -1))
 			}
-			log.Println()
+			log(args.VerboseDnssec)
 			for _, pr := range rs {
 				ln := 0
 				if pr.Msg != nil {
@@ -94,15 +94,15 @@ func Dnstrace(hostname string, qtypestr string) []dns.RR {
 				} else if pr.Server.LookupRTT > 0 {
 					lrtt = fmt.Sprintf("%.2fms", float64(pr.Server.LookupRTT)/float64(time.Millisecond))
 				}
-				log.Printf(col("  - %d bytes in %.2fms + %s lookup on %s(%s)", cDarkGray), ln, rtt, lrtt, pr.Server.Name, pr.Addr)
+				log(args.VerboseDnssec, col("  - %d bytes in %.2fms + %s lookup on %s(%s)", cDarkGray), ln, rtt, lrtt, pr.Server.Name, pr.Addr)
 				if pr.Err != nil {
 					err := pr.Err
 					if oerr, ok := err.(*net.OpError); ok {
 						err = oerr.Err
 					}
-					log.Printf(": %v", col(err, cRed))
+					log(args.VerboseDnssec, ": %v", col(err, cRed))
 				}
-				log.Print("\n")
+				log(args.VerboseDnssec, "\n")
 			}
 
 			switch rtype {
@@ -122,28 +122,29 @@ func Dnstrace(hostname string, qtypestr string) []dns.RR {
 					} else {
 						glue = col("no glue", cYellow)
 					}
-					log.Printf("%s %d NS %s (%s)\n", label, s.TTL, s.Name, glue)
+					log(args.VerboseDnssec, "%s %d NS %s (%s)\n", label, s.TTL, s.Name, glue)
 				}
 			case client.ResponseTypeCNAME:
 				for _, rr := range r.Answer {
-					log.Println(rr)
+					log(args.VerboseDnssec, rr)
 				}
 			}
 		},
 		FollowingCNAME: func(domain, target string) {
-			log.Printf(col("\n~ following CNAME %s -> %s\n", cBlue), domain, target)
+			log(args.VerboseDnssec, col("\n~ following CNAME %s -> %s\n", cBlue), domain, target)
 		},
 	}
 	r, rtt, err := c.RecursiveQuery(m, t)
 	if err != nil {
-		log.Printf(col("*** error: %v\n", cRed), err)
+		log(args.VerboseDnssec, col("*** error: %v\n", cRed), err)
-		os.Exit(1)
+		exit(1)
 	}
 
-	log.Println()
+	log(args.VerboseDnssec)
-	log.Printf(col(";; Cold best path time: %s\n\n", cGray), rtt)
+	log(args.VerboseDnssec, col(";; Cold best path time: %s\n\n", cGray), rtt)
 	for i, rr := range r.Answer {
-		log.Println("r.Answer =", i, rr)
+		log(args.VerboseDnssec, "r.Answer =", i, rr, args.VerboseDnssec)
+		// exit(0)
 	}
 	return r.Answer
 	// for _, rr := range r.Answer {
@@ -163,6 +164,6 @@ func ResolveIPv6hostname(hostname string) *net.TCPAddr {
 }
 
 func UseJournalctl() {
-	log.Println("journalhook is disabled because it breaks the Windows build right now")
+	log(args.VerboseDnssec, "journalhook is disabled because it breaks the Windows build right now")
         // journalhook.Enable()
 }

log.go

@@ -0,0 +1,119 @@
+//
+// version v1.1
+//
+// I like things to be easy.
+//
+// this means all the log settings are in one place. it should allow
+// things to be over-ridden externally to the library
+// but still allow command line --args to pass debugging settings
+//
+// I also have a generic sleep() and exit() in here because it's simple
+//
+// Usage:
+//
+// log("something", foo, bar)
+// var DEBUG bool = true
+// log(DEBUG, "something else", someOtherVariable)  # if DEBUG == false, return doing nothing
+// log(SPEW, "something else", someOtherVariable)   # this get's sent to spew.Dump(). Very useful for debugging!
+//
+package dnssecsocket
+
+import 	(
+	"os"
+	golog "log"
+	"time"
+	"reflect"
+	"github.com/davecgh/go-spew/spew"
+	// "net"
+)
+
+var 	LOGOFF	bool	= false	// turn this off, all logging stops
+var	WARN	bool
+var 	INFO	bool
+
+type spewt struct {
+	a bool
+}
+
+var SPEW spewt
+
+
+/*
+	sleep()		# you know what this does? sleeps for 1 second. yep. dump. easy.
+	sleep(.1)	# you know what this does? yes, it sleeps for 1/10th of a second
+*/
+func sleep(a ...any) {
+	if (a == nil) {
+		time.Sleep(time.Second)
+		return
+	}
+
+	log(args.Verbose, "sleep", a[0])
+
+	switch a[0].(type) {
+	case int:
+		time.Sleep(time.Duration(a[0].(int)) * time.Second)
+	case float64:
+		time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond)
+	default:
+		log("sleep a[0], type = ", a[0], reflect.TypeOf(a[0]))
+	}
+}
+
+/*
+	exit()		# yep. exits. I guess everything must be fine
+	exit(3)		# I guess 3 it is then
+	exit("dont like apples")	# ok. I'll make a note of that
+*/
+func exit(a ...any) {
+	log("exit", a)
+	//if (a) {
+	//	os.Exit(a)
+	//}
+	os.Exit(0)
+}
+
+/*
+	I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
+	I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
+	implementation is probably faster than all of those because you just set one bool to FALSE
+	and it all stops.
+	Sometimes I need to capture to stdout, sometimes stdout can't
+	work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
+	over 8 million references in every .go file. I'm tapping out and putting
+	it in one place. here it is. Also, this makes having debug levels really fucking easy.
+	You can define whatever level of logging you want from anywhere (command line) etc.
+
+	log()		# doesn't do anything
+	log(stuff)	# sends it to whatever log you define in a single place. here is the place
+*/
+
+func log(a ...any) {
+	if (LOGOFF) {
+		return
+	}
+
+	if (a == nil) {
+		return
+	}
+	var blah bool
+	if (reflect.TypeOf(a[0]) == reflect.TypeOf(blah)) {
+		// golog.Println("\t a[0] = bool")
+		if (a[0] == false) {
+			return
+		}
+		a = a[1:]
+	}
+
+	if (reflect.TypeOf(a[0]) == reflect.TypeOf(SPEW)) {
+		a = a[1:]
+		spew.Dump(a)
+		return
+	}
+
+	golog.Println(a...)
+	// golog.Println("\t a[0] =", a[0])
+	// for argNum, arg := range a {
+	// 	golog.Println("\t", argNum, arg)
+	// }
+}