seems to compile and run

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

.gitignore

@@ -2,3 +2,4 @@ control-panel-dns
 /files/*
 /*.deb
 *.swp
+/plugins/*

Makefile

@@ -1,10 +1,16 @@
+.PHONY: debian
+
 run: build
-	./control-panel-dns >/tmp/witgui.log.stderr 2>&1
+	# ./control-panel-dns >/tmp/witgui.log.stderr 2>&1
+	./control-panel-dns
 
 install:
 	go install -v go.wit.com/control-panel-dns@latest
 	# go install -v git.wit.com/wit/control-panel-dns@latest
 
+gocui:
+	./control-panel-dns -gui gocui >/tmp/witgui.log.stderr 2>&1
+
 debug: build
 	./control-panel-dns --verbose --verbose-net --gui-debug
 
@@ -18,6 +24,8 @@ build-release:
 
 build:
 	reset
+	-mkdir -p plugins/
+	-cp ~/go/src/git.wit.org/wit/gui/toolkit/*.so plugins/
 	# GO111MODULE="off" go get -v -x .
 	GO111MODULE="off" go build -v -o control-panel-dns
 
@@ -38,7 +46,7 @@ clean:
 	-rm -rf files/
 	-rm *.deb
 
-deb:
+debian:
 	cd debian && make
 	-wit mirrors
 

args.go

@@ -1,26 +1,96 @@
-// This creates a simple hello world window
 package main
 
+/*
+	this parses the command line arguements
+*/
+
 import 	(
+	"log"
+	"fmt"
+	"reflect"
+	"strconv"
+	arg "github.com/alexflint/go-arg"
 	"git.wit.org/wit/gui"
-	"git.wit.org/jcarr/dnssecsocket"
+	// log "git.wit.org/wit/gui/log"
 )
 
-type LogOptions struct {
+
+var args struct {
 	Verbose bool
 	VerboseNet bool  `arg:"--verbose-net" help:"debug your local OS network settings"`
 	VerboseDNS bool  `arg:"--verbose-dns" help:"debug your dns settings"`
 	LogFile string `help:"write all output to a file"`
 	// User string `arg:"env:USER"`
 	Display string `arg:"env:DISPLAY"`
-}
 
-var args struct {
-	LogOptions
-	dnssecsocket.Args
+	Foo string
+	Bar bool
+	User string `arg:"env:USER"`
+	Demo bool `help:"run a demo"`
 	gui.GuiArgs
+	// log.LogArgs
 }
 
-func parsedown () {
-	dnssecsocket.Parse(args.VerboseDnssec)
+func init() {
+	arg.MustParse(&args)
+	fmt.Println(args.Foo, args.Bar, args.User)
+
+	if (args.Gui != "") {
+		gui.GuiArg.Gui = args.Gui
+	}
+	log.Println(true, "INIT() args.GuiArg.Gui =", gui.GuiArg.Gui)
+
+	Set(&me, "default")
+	log.Println("init() me.artificialSleep =", me.artificialSleep)
+	log.Println("init() me.artificialS =", me.artificialS)
+	me.artificialSleep = 2.3 
+	log.Println("init() me.artificialSleep =", me.artificialSleep)
+	sleep(me.artificialSleep)
+}
+
+func Set(ptr interface{}, tag string) error {
+	if reflect.TypeOf(ptr).Kind() != reflect.Ptr {
+		log.Println(logError, "Set() Not a pointer", ptr, "with tag =", tag)
+		return fmt.Errorf("Not a pointer")
+	}
+
+	v := reflect.ValueOf(ptr).Elem()
+	t := v.Type()
+
+	for i := 0; i < t.NumField(); i++ {
+		defaultVal := t.Field(i).Tag.Get(tag)
+		name := t.Field(i).Name
+		// log("Set() try name =", name, "defaultVal =", defaultVal)
+		setField(v.Field(i), defaultVal, name)
+	}
+	return nil
+}
+
+func setField(field reflect.Value, defaultVal string, name string) error {
+
+	if !field.CanSet() {
+		// log("setField() Can't set value", field, defaultVal)
+		return fmt.Errorf("Can't set value\n")
+	} else {
+		log.Println("setField() Can set value", name, defaultVal)
+	}
+
+	switch field.Kind() {
+	case reflect.Int:
+		val, _ := strconv.Atoi(defaultVal)
+		field.Set(reflect.ValueOf(int(val)).Convert(field.Type()))
+	case reflect.Float64:
+		val, _ := strconv.ParseFloat(defaultVal, 64)
+		field.Set(reflect.ValueOf(float64(val)).Convert(field.Type()))
+	case reflect.String:
+		field.Set(reflect.ValueOf(defaultVal).Convert(field.Type()))
+	case reflect.Bool:
+		if defaultVal == "true" {
+			field.Set(reflect.ValueOf(true))
+		} else {
+			field.Set(reflect.ValueOf(false))
+		}
+	}
+
+	return nil
 }

bash.go

@@ -2,6 +2,7 @@ package main
 
 import (
         "io"
+	"log"
         "os"
         "os/exec"
         "os/signal"
@@ -29,7 +30,7 @@ func test() error {
         go func() {
                 for range ch {
                         if err := pty.InheritSize(os.Stdin, ptmx); err != nil {
-                                log("error resizing pty: %s", err)
+                                log.Println("error resizing pty: %s", err)
                         }
                 }
         }()
@@ -53,7 +54,7 @@ func test() error {
 
 func mainBash() {
         if err := test(); err != nil {
-		log(logError, "exit in mainBash()")
+		log.Println(logError, "exit in mainBash()")
                 exit(err)
         }
 }

dns.go

@@ -5,6 +5,7 @@
 package main
 
 import 	(
+	"log"
 	"net"
 )
 
@@ -23,16 +24,16 @@ func (h *Host) verifyETC() bool {
 func (h *Host) updateIPs(host string) {
     ips, err := net.LookupIP(host)
         if err != nil {
-                log(logError, "updateIPs failed", err)
+                log.Println(logError, "updateIPs failed", err)
         }
         for _, ip := range ips {
-                log(host, ip)
+                log.Println(host, ip)
         }
 }
 
 func (h *Host) setIPv4(ipv4s map[string]*IPtype) {
         for ip, t := range ipv4s {
-		log("IPv4", ip, t)
+		log.Println("IPv4", ip, t)
         }
 }
 
@@ -47,11 +48,11 @@ func (h *Host) checkDNS() {
 			ipt = "IPv6"
 		}
 		if (! t.IsReal()) {
-			log(args.VerboseDNS, "\tIP is not Real", ipt, i.Index, i.Name, s)
+			log.Println(args.VerboseDNS, "\tIP is not Real", ipt, i.Index, i.Name, s)
 			continue
 		}
 
-		log(args.VerboseDNS, "\tIP is Real    ", ipt, i.Index, i.Name, s)
+		log.Println(args.VerboseDNS, "\tIP is Real    ", ipt, i.Index, i.Name, s)
 		if (t.ipv6) {
 			ip6 = true
 		} else {
@@ -60,13 +61,13 @@ func (h *Host) checkDNS() {
 	}
 
 	if (ip4 == true) {
-		log(args.VerboseDNS, "IPv4 should work. Wow. You actually have a real IPv4 address")
+		log.Println(args.VerboseDNS, "IPv4 should work. Wow. You actually have a real IPv4 address")
 	} else {
-		log(args.VerboseDNS, "IPv4 is broken. (be nice and setup ipv4-only.wit.com)")
+		log.Println(args.VerboseDNS, "IPv4 is broken. (be nice and setup ipv4-only.wit.com)")
 	}
 	if (ip6 == true) {
-		log(args.VerboseDNS, "IPv6 should be working. Need to test it here.")
+		log.Println(args.VerboseDNS, "IPv6 should be working. Need to test it here.")
 	} else {
-		log(args.VerboseDNS, "IPv6 is broken. Need to fix it here.")
+		log.Println(args.VerboseDNS, "IPv6 is broken. Need to fix it here.")
 	}
 }

fsnotify.go

@@ -3,7 +3,8 @@ package main
 // Watches for changes to a directory. Works cross-platform
 
 import (
-    "github.com/fsnotify/fsnotify"
+	"log"
+	"github.com/fsnotify/fsnotify"
 )
 
 // This would be a really dumb way to watch for new network interfaces
@@ -13,7 +14,7 @@ func watchSysClassNet() {
     // Create new watcher.
     watcher, err := fsnotify.NewWatcher()
     if err != nil {
-	    log(logError, "watchSysClassNet() failed:", err)
+	    log.Println(logError, "watchSysClassNet() failed:", err)
 	    return
     }
     defer watcher.Close()
@@ -26,15 +27,15 @@ func watchSysClassNet() {
                 if !ok {
                     return
                 }
-                log("event:", event)
+                log.Println("event:", event)
                 if event.Has(fsnotify.Write) {
-                    log("modified file:", event.Name)
+                    log.Println("modified file:", event.Name)
                 }
             case err, ok := <-watcher.Errors:
                 if !ok {
                     return
                 }
-                log("error:", err)
+                log.Println("error:", err)
             }
         }
     }()
@@ -42,7 +43,7 @@ func watchSysClassNet() {
     // Add a path.
     err = watcher.Add("/tmp")
     if err != nil {
-	    log(logError, "watchSysClassNet() watcher.Add() failed:", err)
+	    log.Println(logError, "watchSysClassNet() watcher.Add() failed:", err)
 	    return
     }
 
@@ -65,12 +66,12 @@ func fsnotifyNetworkInterfaceChanges() error {
 	for {
 		select {
 		case event := <-watcher.Events:
-			log("fsnotifyNetworkInterfaceChanges() event =", event)
+			log.Println("fsnotifyNetworkInterfaceChanges() event =", event)
 			if event.Op&fsnotify.Create == fsnotify.Create {
 					// Do something on network interface creation
 			}
 		case err := <-watcher.Errors:
-			log("fsnotifyNetworkInterfaceChanges() event err =", err)
+			log.Println("fsnotifyNetworkInterfaceChanges() event err =", err)
 			return err
 		}
 	}

gui.go

@@ -2,6 +2,7 @@
 package main
 
 import 	(
+	"log"
 	"fmt"
 	"os"
 	"os/user"
@@ -15,24 +16,22 @@ import 	(
 
 // This setups up the dns control panel window
 func setupControlPanelWindow() {
-	me.window = myGui.New2().Window("DNS and IPv6 Control Panel").Standard()
-	me.window.Dump(true)
+	// me.window = myGui.New2().Window("DNS and IPv6 Control Panel").Standard()
+	me.window = myGui.NewWindow("DNS and IPv6 Control Panel").Standard()
+	me.window.Dump()
 
-	sleep(1)
-	addDNSTab("DNS")
+	sleep(me.artificialSleep)
+	dnsTab("DNS")
+	debugTab("Debug")
 
-	if (args.GuiDebug) {
-		gui.DebugWindow()
-	}
-	gui.ShowDebugValues()
 }
 
-func addDNSTab(title string) {
+func debugTab(title string) {
 	var g2 *gui.Node
 
-	me.tab = me.window.NewTab(title)
+	tab := me.window.NewTab(title)
 
-	g2 = me.tab.NewGroup("Real Stuff")
+	g2 = tab.NewGroup("Real Stuff")
 
 	g2.NewButton("gui.DebugWindow()", func () {
 		gui.DebugWindow()
@@ -41,15 +40,14 @@ func addDNSTab(title string) {
 	g2.NewButton("Load 'gocui'", func () {
 		// this set the xterm and mate-terminal window title. maybe works generally?
 		fmt.Println("\033]0;" + title + "blah \007")
-		gui.StartS("gocui")
-		gui.Redraw("gocui")
+		myGui.LoadToolkit("gocui")
 	})
 
 	g2.NewButton("Network Interfaces", func () {
 		for i, t := range me.ifmap {
-			log("name =", t.iface.Name)
-			log("int =", i, "name =", t.name, t.iface)
-			log("iface = " + t.iface.Name)
+			log.Println("name =", t.iface.Name)
+			log.Println("int =", i, "name =", t.name, t.iface)
+			log.Println("iface = " + t.iface.Name)
 		}
 	})
 	g2.NewButton("Hostname", func () {
@@ -59,25 +57,30 @@ func addDNSTab(title string) {
 		var aaaa []string
 		aaaa = realAAAA()
 		for _, s := range aaaa {
-			log("my actual AAAA = ", s)
+			log.Println("my actual AAAA = ", s)
 		}
 	})
 
+	g2.NewButton("Update DNS", func () {
+		log.Println("updateDNS()")
+		updateDNS()
+	})
+
 	g2.NewButton("checkDNS()", func () {
 		checkDNS()
 	})
 	g2.NewButton("os.User()", func () {
 		user, _ := user.Current()
 		spew.Dump(user)
-		log("os.Getuid =", user.Username, os.Getuid())
+		log.Println("os.Getuid =", user.Username, os.Getuid())
 		if (me.uid != nil) {
 			me.uid.SetText(user.Username + " (" + strconv.Itoa(os.Getuid()) + ")")
 		}
 	})
 	g2.NewButton("dig +trace", func () {
 		o := shell.Run("dig +trace +noadditional DS " + me.hostname + " @8.8.8.8")
-		log(o)
-		// log(o)
+		log.Println(o)
+		// log.Println(o)
 	})
 	g2.NewButton("Example_listLink()", func () {
 		Example_listLink()
@@ -90,30 +93,39 @@ func addDNSTab(title string) {
 		if err != nil {
 			return
 		}
-		log("host =", host)
+		log.Println("host =", host)
 	})
 	g2.NewButton("DumpPublicDNSZone(apple.com)", func () {
 		DumpPublicDNSZone("apple.com")
 		dumpIPs("www.apple.com")
 	})
 
-	nsupdateGroup(me.tab)
+	g2.NewLabel("control panel TTL (in tenths of seconds)")
+	ttl := g2.NewSlider("dnsTTL", 1, 100)
+	ttl.Set(me.dnsTTL * 10)
+	ttl.Custom = func () {
+		me.dnsTTL = ttl.I / 10
+		log.Println("dnsTTL =", me.dnsTTL)
+	}
 
-	tmp := me.tab.NewGroup("output")
-	me.output = tmp.NewTextbox("some output")
-	me.output.Custom = func() {
-		s := me.output.GetText()
-		log("output text =", s)
+	g2.NewLabel("control panel loop delay (in tenths of seconds)")
+	ttl2 := g2.NewSlider("dnsTTL", 1, 100)
+	ttl2.Set(me.dnsTTLsleep)
+	ttl2.Custom = func () {
+		me.dnsTTLsleep = float64(ttl2.I) / 10
+		log.Println("dnsTTLsleep =", me.dnsTTLsleep)
 	}
 }
 
 func myDefaultExit(n *gui.Node) {
-        log("You can Do exit() things here")
+        log.Println("You can Do exit() things here")
 	os.Exit(0)
 }
 
-func nsupdateGroup(w *gui.Node) {
-	g := w.NewGroup("dns update")
+func dnsTab(title string) {
+	tab := me.window.NewTab(title)
+
+	g := tab.NewGroup("dns update")
 
 	grid := g.NewGrid("gridnuts", 2, 2)
 
@@ -143,15 +155,43 @@ func nsupdateGroup(w *gui.Node) {
 	grid.NewLabel("DNS Status =")
 	me.DnsStatus = grid.NewLabel("unknown")
 
-	g.NewButton("Update DNS", func () {
-		log("updateDNS()")
-		updateDNS()
-		me.tab.Margin()
-		me.tab.Pad()
-		grid.Pad()
+	me.fix = g.NewButton("Fix", func () {
+		if (goodHostname(me.hostname)) {
+			log.Println("hostname is good:", me.hostname)
+		} else {
+			log.Println("you need to fix your hostname here", me.hostname)
+			return
+		}
+		nsupdate()
 	})
+	me.fix.Disable()
+
+	statusGrid(tab)
+
 }
 
+func statusGrid(n *gui.Node) {
+	problems := n.NewGroup("status")
+
+	gridP := problems.NewGrid("nuts", 2, 2)
+
+	gridP.NewLabel("DNS Status =")
+	gridP.NewLabel("unknown")
+
+	gridP.NewLabel("hostname =")
+	gridP.NewLabel("invalid")
+
+	gridP.NewLabel("dns provider =")
+	gridP.NewLabel("unknown")
+
+	gridP.NewLabel("IPv6 working =")
+	gridP.NewLabel("unknown")
+
+	gridP.NewLabel("dns resolution =")
+	gridP.NewLabel("unknown")
+}
+
+/*
 var outJunk string
 func output(s string, a bool) {
 	if (a) {
@@ -160,8 +200,9 @@ func output(s string, a bool) {
 		outJunk = s
 	}
 	me.output.SetText(outJunk)
-	log(outJunk)
+	log.Println(outJunk)
 }
+*/
 
 func updateDNS() {
 	var aaaa []string
@@ -170,20 +211,20 @@ func updateDNS() {
 		h = "unknown.lab.wit.org"
 		// h = "hpdevone.lab.wit.org"
 	}
-	log("dnsAAAA()()")
+	log.Println("dnsAAAA()()")
 	aaaa = dnsAAAA(h)
-	log("dnsAAAA()()")
-	log(SPEW, me)
+	log.Println("dnsAAAA()()")
+	log.Println(SPEW, me)
 	if (aaaa == nil) {
-		log("There are no DNS AAAA records for hostname: ", h)
+		log.Println("There are no DNS AAAA records for hostname: ", h)
 	}
 	var broken int = 0
 	var all string
 	for _, s := range aaaa {
-		log("host", h, "DNS AAAA =", s)
+		log.Println("host", h, "DNS AAAA =", s)
 		all += s + "\n"
 		if ( me.ipmap[s] == nil) {
-			log("THIS IS THE WRONG AAAA DNS ENTRY:  host", h, "DNS AAAA =", s)
+			log.Println("THIS IS THE WRONG AAAA DNS ENTRY:  host", h, "DNS AAAA =", s)
 			broken = 2
 		} else {
 			if (broken == 0) {
@@ -197,14 +238,16 @@ func updateDNS() {
 		me.DnsStatus.SetText("WORKING")
 	} else {
 		me.DnsStatus.SetText("BROKEN")
-		log("Need to run go-nsupdate here")
+		me.fix.Enable()
+		log.Println("Need to run go-nsupdate here")
+		nsupdate()
 	}
 
 	user, _ := user.Current()
 	spew.Dump(user)
-	log("os.Getuid =", user.Username, os.Getuid())
+	log.Println("os.Getuid =", user.Username, os.Getuid())
 	if (me.uid != nil) {
 		me.uid.SetText(user.Username + " (" + strconv.Itoa(os.Getuid()) + ")")
 	}
-	log("updateDNS() END")
+	log.Println("updateDNS() END")
 }

hostname.go

@@ -5,7 +5,10 @@
 
 package main
 
-// import "net"
+import (
+	"log"
+	"git.wit.org/wit/shell"
+)
 
 // will try to get this hosts FQDN
 import "github.com/Showmax/go-fqdn"
@@ -21,7 +24,7 @@ func getHostname() {
 	var s string = "gui.Label == nil"
 	s, err = fqdn.FqdnHostname()
 	if (err != nil) {
-		log("FQDN hostname error =", err)
+		log.Println("FQDN hostname error =", err)
 		return
 	}
 	if (me.fqdn != nil) {
@@ -31,19 +34,40 @@ func getHostname() {
 			me.changed = true
 		}
 	}
-	log("FQDN =", s)
+	log.Println("FQDN =", s)
+}
+
+// returns true if the hostname is good
+// check that all the OS settings are correct here
+// On Linux, /etc/hosts, /etc/hostname
+//      and domainname and hostname
+func goodHostname(h string) bool {
+	hostname := shell.Chomp(shell.Cat("/etc/hostname"))
+	log.Println("hostname =", hostname)
+
+	hs := run("hostname -s")
+	dn := run("domainname")
+	log.Println("hostname short =", hs, "domainname =", dn)
+
+	tmp := hs + "." + dn
+	if (hostname == tmp) {
+		log.Println("hostname seems to be good", hostname)
+		return true
+	}
+
+	return false
 }
 
 func dnsAAAA(s string) []string {
 	var aaaa []string
 	// lookup the IP address from DNS
 	rrset := dnssecsocket.Dnstrace(s, "AAAA")
-	log(args.VerboseDNS, SPEW, rrset)
+	log.Println(args.VerboseDNS, SPEW, rrset)
 	for i, rr := range rrset {
-		log(args.VerboseDNS, "r.Answer =", i, rr)
+		log.Println(args.VerboseDNS, "r.Answer =", i, rr)
 		ipaddr := dns.Field(rr, 1)
 		aaaa = append(aaaa, ipaddr)
 	}
-	log(args.VerboseDNS, "aaaa =", aaaa)
+	log.Println(args.VerboseDNS, "aaaa =", aaaa)
 	return aaaa
 }

log.go

@@ -1,6 +1,7 @@
 package main
 
 import 	(
+	"log"
 	witlog "git.wit.org/wit/gui/log"
 )
 
@@ -15,16 +16,18 @@ var SPEW witlog.Spewt
 
 // var log interface{}
 
+/*
 func log(a ...any) {
 	witlog.Where = "wit/gui"
 	witlog.Log(a...)
 }
+*/
 
 func sleep(a ...any) {
 	witlog.Sleep(a...)
 }
 
 func exit(a ...any) {
-	log(logError, "got to log() exit")
+	log.Println(logError, "got to log() exit")
 	witlog.Exit(a...)
 }

main.go

@@ -5,48 +5,42 @@
 package main
 
 import 	(
+	"log"
 	"strconv"
 	"runtime"
 	"time"
-	arg "github.com/alexflint/go-arg"
+	"embed"
 	"git.wit.org/wit/gui"
 )
 
-var p *arg.Parser
 var myGui *gui.Node
 
+//go:embed plugins/*.so
+var resToolkit embed.FS
+
 func main() {
-	p = arg.MustParse(&args)
-	parsedown()
+	// parsedown()
 
 	// initialize the maps to track IP addresses and network interfaces
 	me.ipmap = make(map[string]*IPtype)
 	me.dnsmap = make(map[string]*IPtype)
 	me.ifmap = make(map[int]*IFtype)
-	me.dnsTTL = 5		// recheck DNS is working every 2 minutes // TODO: watch rx packets?
+	me.dnsTTL = 2		// recheck DNS is working every 2 minutes // TODO: watch rx packets?
 
-
-	log()
-	log(true, "this is true")
-	log(false, "this is false")
-	sleep(.4)
-	sleep(.3)
-	sleep(.2)
-	sleep("done scanning net")
-
-	// Example_listLink()
-
-	log("Toolkit = ", args.Toolkit)
-	// gui.InitPlugins([]string{"andlabs"})
+	// will set all debugging flags
 	// gui.SetDebug(true)
-	// myGui = gui.Main(initGUI)
-	myGui = gui.Start()
-	sleep(1)
+
+	// myGui = gui.New().InitEmbed(resToolkit).LoadToolkit("gocui")
+	myGui = gui.New().Default()
+	sleep(me.artificialSleep)
 	setupControlPanelWindow()
-	sleep(1)
-	myGui.LoadPlugin("gocui")
-	// gui.Redraw("gocui")
-	sleep(1)
+	sleep(me.artificialSleep)
+	if (args.GuiDebug) {
+		gui.DebugWindow()
+	}
+	gui.ShowDebugValues()
+
+	// forever monitor for network and dns changes
 	checkNetworkChanges()
 }
 
@@ -55,46 +49,43 @@ func main() {
 */
 func checkNetworkChanges() {
 	var ttl int = 0
-	var ttlsleep int = 5
 	for {
-		sleep(ttlsleep)
+		sleep(me.dnsTTLsleep)
 		ttl -= 1
 		if (ttl < 0) {
 			if (runtime.GOOS == "linux") {
 				dnsTTL()
 			} else {
-				log("Windows and MacOS don't work yet")
+				log.Println("Windows and MacOS don't work yet")
 			}
 			ttl = me.dnsTTL
 		}
 	}
 }
 
-// Run this every once and a while
+// This checks for changes to the network settings
+// and verifies that DNS is working or not working
 func dnsTTL() {
 	me.changed = false
-	log("FQDN =", me.fqdn.GetText())
+	log.Println("FQDN =", me.fqdn.GetText())
 	getHostname()
 	scanInterfaces()
 	for i, t := range me.ifmap {
-		log(strconv.Itoa(i) + " iface = " + t.iface.Name)
+		log.Println(strconv.Itoa(i) + " iface = " + t.iface.Name)
 	}
 
 	var aaaa []string
 	aaaa = realAAAA()
 	var all string
 	for _, s := range aaaa {
-		log("my actual AAAA = ",s)
+		log.Println("my actual AAAA = ",s)
 		all += s + "\n"
 	}
 	// me.IPv6.SetText(all)
 
 	if (me.changed) {
 		stamp := time.Now().Format("2006/01/02 15:04:05")
-		s := stamp + " Network things changed"
-		log(logError, "Network things changed on", stamp)
+		log.Println(logError, "Network things changed on", stamp)
 		updateDNS()
-		me.output.SetText(s)
-
 	}
 }

net.go

@@ -2,9 +2,9 @@
 package main
 
 import 	(
+	"log"
 	"net"
 	"strings"
-	// "git.wit.org/wit/gui"
 )
 
 var DEBUGNET bool = false
@@ -18,21 +18,21 @@ func watchNetworkInterfaces() {
 	// Set up a notification channel
 	notification := make(chan net.Interface)
 
-	log(DEBUGNET, "watchNet()")
+	log.Println(DEBUGNET, "watchNet()")
 	// Start goroutine to watch for changes
 	go func() {
-		log(DEBUGNET, "watchNet() func")
+		log.Println(DEBUGNET, "watchNet() func")
 		for {
-			log(DEBUGNET, "forever loop start")
+			log.Println(DEBUGNET, "forever loop start")
 			// Check for changes in each interface
 			for _, i := range interfaces {
-				log(DEBUGNET, "something on i =", i)
+				log.Println(DEBUGNET, "something on i =", i)
 				if status := i.Flags & net.FlagUp; status != 0 {
 					notification <- i
-					log(DEBUGNET, "something on i =", i)
+					log.Println(DEBUGNET, "something on i =", i)
 				}
 			}
-			log(DEBUGNET, "forever loop end")
+			log.Println(DEBUGNET, "forever loop end")
 		}
 	}()
 }
@@ -44,20 +44,20 @@ func IsIPv6(address string) bool {
 
 func (t *IPtype) IsReal() bool {
 	if (t.ip.IsPrivate() || t.ip.IsLoopback() || t.ip.IsLinkLocalUnicast()) {
-		log(DEBUGNET, "\t\tIP is Real = false")
+		log.Println(DEBUGNET, "\t\tIP is Real = false")
 		return false
 	} else {
-		log(DEBUGNET, "\t\tIP is Real = true")
+		log.Println(DEBUGNET, "\t\tIP is Real = true")
 		return true
 	}
 }
 
 func IsReal(ip *net.IP) bool {
 	if (ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast()) {
-		log(DEBUGNET, "\t\tIP is Real = false")
+		log.Println(DEBUGNET, "\t\tIP is Real = false")
 		return false
 	} else {
-		log(DEBUGNET, "\t\tIP is Real = true")
+		log.Println(DEBUGNET, "\t\tIP is Real = true")
 		return true
 	}
 }
@@ -74,7 +74,7 @@ func renameInterface(i *net.Interface) {
 func checkInterface(i net.Interface) {
 	val, ok := me.ifmap[i.Index]
 	if ! ok {
-		log(i.Name, "is a new network interface. The linux kernel index =", i.Index)
+		log.Println(i.Name, "is a new network interface. The linux kernel index =", i.Index)
 		me.ifmap[i.Index] = new(IFtype)
 		me.ifmap[i.Index].gone = false
 		me.ifmap[i.Index].iface = &i
@@ -86,9 +86,9 @@ func checkInterface(i net.Interface) {
 		return
 	}
 	me.ifmap[i.Index].gone = false
-	log(args.VerboseNet, "me.ifmap[i] does exist. Need to compare everything.", i.Index, i.Name, val.iface.Index, val.iface.Name)
+	log.Println(args.VerboseNet, "me.ifmap[i] does exist. Need to compare everything.", i.Index, i.Name, val.iface.Index, val.iface.Name)
 	if (val.iface.Name != i.Name) {
-		log(val.iface.Name, "has changed to it's name to", i.Name)
+		log.Println(val.iface.Name, "has changed to it's name to", i.Name)
 		me.ifmap[i.Index].iface = &i
 		me.changed = true
 		if (me.Interfaces != nil) {
@@ -126,14 +126,14 @@ func checkDNS() (map[string]*IPtype, map[string]*IPtype) {
 			ipt = "IPv6"
 		}
 		if (t.IsReal()) {
-			log("\tIP is Real    ", ipt, i.Index, i.Name, s)
+			log.Println("\tIP is Real    ", ipt, i.Index, i.Name, s)
 			if (t.ipv6) {
 				ipv6s[s] = t
 			} else {
 				ipv4s[s] = t
 			}
 		} else {
-			log("\tIP is not Real", ipt, i.Index, i.Name, s)
+			log.Println("\tIP is not Real", ipt, i.Index, i.Name, s)
 		}
 	}
 	return ipv6s, ipv4s
@@ -141,14 +141,14 @@ func checkDNS() (map[string]*IPtype, map[string]*IPtype) {
 
 // Will figure out if an IP address is new
 func checkIP(ip *net.IPNet, i net.Interface) bool {
-	log(args.VerboseNet, "\t\taddr.(type) = *net.IPNet")
-	log(args.VerboseNet, "\t\taddr.(type) =", ip)
+	log.Println(args.VerboseNet, "\t\taddr.(type) = *net.IPNet")
+	log.Println(args.VerboseNet, "\t\taddr.(type) =", ip)
 	var realip string
 	realip = ip.IP.String()
 
 	val, ok := me.ipmap[realip]
 	if ok {
-		log(args.VerboseNet, val.ipnet.IP.String(), "is already a defined IP address")
+		log.Println(args.VerboseNet, val.ipnet.IP.String(), "is already a defined IP address")
 		me.ipmap[realip].gone = false
 		return false
 	}
@@ -175,14 +175,14 @@ func checkIP(ip *net.IPNet, i net.Interface) bool {
 		}
 	}
 	if (IsReal(&ip.IP)) {
-		log("\tIP is Real    ", t, i.Index, i.Name, realip)
+		log.Println("\tIP is Real    ", t, i.Index, i.Name, realip)
 	} else {
-		log("\tIP is not Real", t, i.Index, i.Name, realip)
+		log.Println("\tIP is not Real", t, i.Index, i.Name, realip)
 	}
-	log(args.VerboseNet, "\t\tIP is IsPrivate() =", ip.IP.IsPrivate())
-	log(args.VerboseNet, "\t\tIP is IsLoopback() =", ip.IP.IsLoopback())
-	log(args.VerboseNet, "\t\tIP is IsLinkLocalUnicast() =", ip.IP.IsLinkLocalUnicast())
-	// log("HERE HERE", "realip =", realip, "me.ip[realip]=", me.ipmap[realip])
+	log.Println(args.VerboseNet, "\t\tIP is IsPrivate() =", ip.IP.IsPrivate())
+	log.Println(args.VerboseNet, "\t\tIP is IsLoopback() =", ip.IP.IsLoopback())
+	log.Println(args.VerboseNet, "\t\tIP is IsLinkLocalUnicast() =", ip.IP.IsLinkLocalUnicast())
+	// log.Println("HERE HERE", "realip =", realip, "me.ip[realip]=", me.ipmap[realip])
 	return true
 }
 
@@ -190,25 +190,25 @@ func scanInterfaces() {
 	me.changed = false
 	ifaces, _ := net.Interfaces()
 	// me.ifnew = ifaces
-	log(DEBUGNET, SPEW, ifaces)
+	log.Println(DEBUGNET, SPEW, ifaces)
 	for _, i := range ifaces {
 		addrs, _ := i.Addrs()
-		// log("range ifaces = ", i)
+		// log.Println("range ifaces = ", i)
 		checkInterface(i)
-		log(args.VerboseNet, "*net.Interface.Name = ", i.Name, i.Index)
-		log(args.VerboseNet, SPEW, i)
-		log(DEBUGNET, SPEW, addrs)
+		log.Println(args.VerboseNet, "*net.Interface.Name = ", i.Name, i.Index)
+		log.Println(args.VerboseNet, SPEW, i)
+		log.Println(DEBUGNET, SPEW, addrs)
 		for _, addr := range addrs {
-			log(DEBUGNET, "\taddr =", addr)
-			log(DEBUGNET, SPEW, addrs)
+			log.Println(DEBUGNET, "\taddr =", addr)
+			log.Println(DEBUGNET, SPEW, addrs)
 			ips, _ := net.LookupIP(addr.String())
-			log(DEBUGNET, "\tLookupIP(addr) =", ips)
+			log.Println(DEBUGNET, "\tLookupIP(addr) =", ips)
 			switch v := addr.(type) {
 			case *net.IPNet:
 				checkIP(v, i)
-				// log("\t\tIP is () =", ip.())
+				// log.Println("\t\tIP is () =", ip.())
 			default:
-				log(DEBUGNET, "\t\taddr.(type) = NO IDEA WHAT TO DO HERE v =", v)
+				log.Println(DEBUGNET, "\t\taddr.(type) = NO IDEA WHAT TO DO HERE v =", v)
 			}
 		}
 	}
@@ -218,12 +218,12 @@ func scanInterfaces() {
 	for s, t := range me.ipmap {
 		if (t.ipv4) {
 			all4 += s + "\n"
-			log("IPv4 =", s)
+			log.Println("IPv4 =", s)
 		} else if (t.ipv6) {
 			all6 += s + "\n"
-			log("IPv6 =", s)
+			log.Println("IPv6 =", s)
 		} else {
-			log("???? =", s)
+			log.Println("???? =", s)
 		}
 	}
 	all4 = strings.TrimSpace(all4)
@@ -236,7 +236,7 @@ func scanInterfaces() {
 func deleteChanges() {
 	for i, t := range me.ifmap {
 		if (t.gone) {
-			log("DELETE int =", i, "name =", t.name, t.iface)
+			log.Println("DELETE int =", i, "name =", t.name, t.iface)
 			delete(me.ifmap, i)
 			me.changed = true
 		}
@@ -244,10 +244,10 @@ func deleteChanges() {
 	}
 	for s, t := range me.ipmap {
 		if (t.gone) {
-			log("DELETE name =", s, "IPv4 =", t.ipv4)
-			log("DELETE name =", s, "IPv6 =", t.ipv6)
-			log("DELETE name =", s, "iface =", t.iface)
-			log("DELETE name =", s, "ip =", t.ip)
+			log.Println("DELETE name =", s, "IPv4 =", t.ipv4)
+			log.Println("DELETE name =", s, "IPv6 =", t.ipv6)
+			log.Println("DELETE name =", s, "iface =", t.iface)
+			log.Println("DELETE name =", s, "ip =", t.ip)
 			delete(me.ipmap, s)
 			me.changed = true
 		}

netlink.go

@@ -1,66 +0,0 @@
-package main
-
-// examples of what ifconfig does
-// example of AF_NETLINK change:
-// https://stackoverflow.com/questions/579783/how-to-detect-ip-address-change-programmatically-in-linux/2353441#2353441
-// from that page, a link to watch for any ip event:
-// https://github.com/angt/ipevent/blob/master/ipevent.c
-
-// https://github.com/mdlayher/talks : Linux, Netlink, and Go in 7 minutes or less! (GopherCon 2018, lightning talk) 
-
-/*
-	c example from ipevent.c :
-	int fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
-
-	struct sockaddr_nl snl = {
-	    .nl_family = AF_NETLINK,
-	    .nl_groups = RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR,
-	};
-*/
-
-/*
-import 	(
-//	"os"
-//	"os/exec"
-	// "log"
-	// "net"
-	// "unix"
-	"github.com/vishvananda/netlink"
-	"github.com/jsimonetti/rtnetlink"
-//	"git.wit.org/wit/gui"
-//	"github.com/davecgh/go-spew/spew"
-)
-
-// In golang, write a function     to register with netlink to detect changes to any network interface     Use tab indentation. Do not include example usage.
-
-func registerNetlink() error {
-	// Create netlink socket
-	sock, err := netlink.Socket(rtnetlink.NETLINK_ROUTE, 0)
-	if err != nil {
-		return err
-	}
-	// Register for interface change events
-	err = netlink.AddMembership(sock, netlink.RTNLGRP_LINK)
-	if err != nil {
-		return err
-	}
-	// Close the socket 
-	defer sock.Close()
-	// Handle incoming notifications
-	for {
-		msgs, _, err := sock.Receive()
-		if err != nil {
-			return err
-		}
-		for _, msg := range msgs {
-			switch msg.Header.Type {
-			case unix.RTM_NEWLINK:
-				// Do something with new link
-			case unix.RTM_DELLINK:
-				// Do something with deleted link
-			}
-		}
-	}
-	return nil
-}
-*/

nsupdate.go

@@ -0,0 +1,34 @@
+// inspired from:
+// https://github.com/mactsouk/opensource.com.git
+// and
+// https://coderwall.com/p/wohavg/creating-a-simple-tcp-server-in-go
+
+package main
+
+import (
+	"log"
+	"os"
+)
+
+//	./go-nsupdate \
+//		--tsig-algorithm=hmac-sha512 \
+//		--tsig-secret="OWh5/ZHIyaz7B8J9m9ZDqZ8448Pke0PTpkYbZmFcOf5a6rEzgmcwrG91u1BHi1/4us+mKKEobDPLw1x6sD+ZJw==" \
+//		-i eno2 farm001.lab.wit.org
+
+func nsupdate() {
+	var tsigSecret string
+	log.Println(true, "nsupdate() START")
+	cmd := "go-nsupdate --tsig-algorithm=hmac-sha512"
+	tsigSecret = os.Getenv("TIG_SECRET")
+	cmd += " --tig-secret=\"" + tsigSecret + "\""
+	cmd += " -i wlo1 " + me.hostname
+	log.Println(true, "nsupdate() RUN:", cmd)
+
+	for s, t := range me.ipmap {
+		if (t.IsReal()) {
+			if (t.ipv6) {
+				log.Println(true, "nsupdate() found real AAAA =", s, "on iface", t.iface.Name)
+			}
+		}
+	}
+}

rtnetlink.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"log"
 	"github.com/jsimonetti/rtnetlink"
 )
 
@@ -9,7 +10,7 @@ func Example_listLink() {
 	// Dial a connection to the rtnetlink socket
 	conn, err := rtnetlink.Dial(nil)
 	if err != nil {
-		log(logError, "Example_listLink() failed", err)
+		log.Println(logError, "Example_listLink() failed", err)
 		return
 	}
 	defer conn.Close()
@@ -17,9 +18,9 @@ func Example_listLink() {
 	// Request a list of interfaces
 	msg, err := conn.Link.List()
 	if err != nil {
-		log(err)
+		log.Println(err)
 	}
 
-	log("%#v", msg)
-	log(SPEW, msg)
+	log.Println("%#v", msg)
+	log.Println(SPEW, msg)
 }

run.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"os/exec"
+
+	"git.wit.org/wit/shell"
+)
+
+func run(s string) string {
+	cmdArgs := strings.Fields(s)
+	// Define the command you want to run
+	// cmd := exec.Command(cmdArgs)
+	cmd := exec.Command(cmdArgs[0], cmdArgs[1:len(cmdArgs)]...)
+
+	// Create a buffer to capture the output
+	var out bytes.Buffer
+
+	// Set the output of the command to the buffer
+	cmd.Stdout = &out
+
+	// Run the command
+	err := cmd.Run()
+	if err != nil {
+		fmt.Println("Error running command:", err)
+		return ""
+	}
+
+	tmp := shell.Chomp(out.String())
+	// Output the results
+	fmt.Println("Command Output:", tmp)
+
+	return tmp
+}
+

structs.go

@@ -13,16 +13,22 @@ type Host struct {
 	hostname	string			// mirrors
 	domainname	string			// kernel.org
 	// fqdn		string			// mirrors.kernel.org
-	dnsTTL		int			// Recheck DNS is working every TTL (in seconds)
+
+	dnsTTL		int	`default:3`	// Recheck DNS is working every TTL (in seconds)
+	dnsTTLsleep	float64			// sleep between loops
+	artificialSleep float64	`default:0.7`	// artificial sleep on startup
+	artificialS     string 	`default:0.7`	// artificial sleep on startup
+
 	changed		bool			// set to true if things changed
 	user		string			// name of the user
+
 	ipmap		map[string]*IPtype	// the current ip addresses
 	dnsmap		map[string]*IPtype	// the current dns addresses
 	ifmap		map[int]*IFtype		// the current interfaces
+
 	window		*gui.Node		// the main window
 	tab		*gui.Node		// the main dns tab
 	notes		*gui.Node		// using this to put notes here
-	output		*gui.Node		// Textbox for dumping output
 	uid		*gui.Node		// user
 	fqdn		*gui.Node		// display the full hostname
 	IPv4		*gui.Node		// show valid IPv4 addresses
@@ -31,6 +37,7 @@ type Host struct {
 	DnsAAAA		*gui.Node		// the actual DNS AAAA results
 	DnsA		*gui.Node		// the actual DNS A results (ignore for status since mostly never happens?)
 	DnsStatus	*gui.Node		// the current state of DNS
+	fix		*gui.Node		// button for the user to click
 }
 
 type IPtype struct {

unix.go

@@ -5,11 +5,10 @@
 package main
 
 import 	(
+	"log"
 	"os"
 	"os/exec"
 	"net"
-//	"git.wit.org/wit/gui"
-//	"github.com/davecgh/go-spew/spew"
 )
 
 func CheckSuperuser() bool {
@@ -24,7 +23,7 @@ func Escalate() {
 		cmd.Stderr = os.Stderr
 		err := cmd.Run()
 		if err != nil {
-			log(logError, "exit in Escalate()")
+			log.Println(logError, "exit in Escalate()")
 			exit(err)
 		}
 	}
@@ -39,17 +38,17 @@ func DumpPublicDNSZone(zone string) {
 		panic(err)
 	}
 	for _, entry := range entries {
-		log(entry)
+		log.Println(entry)
 	}
 }
 
 func dumpIPs(host string) {
     ips, err := net.LookupIP(host)
         if err != nil {
-		log(logError, "dumpIPs() failed:", err)
+		log.Println(logError, "dumpIPs() failed:", err)
         }
         for _, ip := range ips {
-                log(host, ip)
+                log.Println(host, ip)
         }
 }