almost have a window

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

gui.go

@@ -227,6 +227,9 @@ func mainWindow(title string) {
 	gr.NewButton("OS details", func () {
 		me.details.Toggle()
 	})
+	gr.NewButton("Linux details", func () {
+		me.statusOS.Update()
+	})
 	gr.NewButton("resolver status", func () {
 		if ! me.digStatus.Ready() {return}
 		me.digStatus.window.Toggle()

linuxstatus/draw.go

@@ -22,7 +22,11 @@ func draw(ls *LinuxStatus) {
 	ls.IPv4		= gadgets.NewOneLiner(ls.grid, "Current IPv4 =")
 	ls.IPv6		= gadgets.NewOneLiner(ls.grid, "Current IPv6 =")
 	ls.workingIPv6	= gadgets.NewOneLiner(ls.grid, "Real IPv6 =")
-	ls.nics		= gadgets.NewOneLiner(ls.grid, "network intefaces =")
+	// ls.nics		= gadgets.NewOneLiner(ls.grid, "network intefaces =")
+
+	ls.grid.NewLabel("interfaces =")
+	ls.Interfaces = ls.grid.NewCombobox("Interfaces")
+
 	ls.speedActual	= gadgets.NewOneLiner(ls.grid, "refresh speed =")
 
 	ls.grid.Margin()

linuxstatus/hostname.go

@@ -11,10 +11,12 @@ import (
 )
 
 func (ls *LinuxStatus) GetDomainName() string {
+	if ! me.Ready() {return ""}
 	return me.domainname.Get()
 }
 
 func (ls *LinuxStatus) setDomainName(dn string) {
+	if ! me.Ready() {return}
 	me.domainname.Set(dn)
 }
 

linuxstatus/linuxloop.go

@@ -0,0 +1,44 @@
+// GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007
+// Copyright (c) 2023 WIT.COM, Inc.
+// This is a control panel for DNS
+
+package linuxstatus
+
+import 	(
+	"strconv"
+
+	"go.wit.com/log"
+)
+
+func linuxLoop() {
+	me.changed = false
+	duration := timeFunction(getHostname)
+	log.Info("getHostname() execution Time: ", duration, "me.changed =", me.changed)
+
+	duration = timeFunction(scanInterfaces)
+	log.Log(NET, "scanInterfaces() execution Time: ", duration)
+	for i, t := range me.ifmap {
+		log.Log(NET, strconv.Itoa(i) + " iface = " + t.iface.Name)
+	}
+
+	var aaaa []string
+	aaaa = dhcpAAAA()
+	var all string
+	for _, s := range aaaa {
+		log.Log(NET, "my actual AAAA = ",s)
+		all += s + "\n"
+	}
+	// me.IPv6.SetText(all)
+
+	/*
+	processName := getProcessNameByPort(53)
+	fmt.Println("Process with port 53:", processName)
+
+	commPath := filepath.Join("/proc", proc.Name(), "comm")
+	comm, err := ioutil.ReadFile(commPath)
+	if err != nil {
+		return "", err // Error reading the process name
+	}
+	return strings.TrimSpace(string(comm)), nil
+	*/
+}

linuxstatus/net.go

@@ -0,0 +1,292 @@
+// This creates a simple hello world window
+package linuxstatus
+
+import 	(
+	// "log"
+	"net"
+	"strings"
+
+	"go.wit.com/log"
+)
+
+// this doesn't work
+/*
+func watchNetworkInterfaces() {
+	// Get list of network interfaces
+	interfaces, _ := net.Interfaces()
+
+	// Set up a notification channel
+	notification := make(chan net.Interface)
+
+	log.Log(NET, "watchNet()")
+	// Start goroutine to watch for changes
+	go func() {
+		log.Log(NET, "watchNet() func")
+		for {
+			log.Log(NET, "forever loop start")
+			// Check for changes in each interface
+			for _, i := range interfaces {
+				log.Log(NET, "something on i =", i)
+				if status := i.Flags & net.FlagUp; status != 0 {
+					notification <- i
+					log.Log(NET, "something on i =", i)
+				}
+			}
+			log.Log(NET, "forever loop end")
+		}
+	}()
+}
+*/
+
+func IsIPv6(address string) bool {
+	return strings.Count(address, ":") >= 2
+}
+
+func (t *IPtype) IsReal() bool {
+	if (t.ip.IsPrivate() || t.ip.IsLoopback() || t.ip.IsLinkLocalUnicast()) {
+		log.Log(NET, "\t\tIP is Real = false")
+		return false
+	} else {
+		log.Log(NET, "\t\tIP is Real = true")
+		return true
+	}
+}
+
+func IsReal(ip *net.IP) bool {
+	if (ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast()) {
+		log.Log(NET, "\t\tIP is Real = false")
+		return false
+	} else {
+		log.Log(NET, "\t\tIP is Real = true")
+		return true
+	}
+}
+
+func renameInterface(i *net.Interface) {
+	/*
+	/sbin/ip link set eth1 down
+	/sbin/ip link set eth1 name eth123
+	/sbin/ip link set eth123 up
+	*/
+}
+
+// Will figure out if an interface was just added
+func checkInterface(i net.Interface) {
+	val, ok := me.ifmap[i.Index]
+	if ! ok {
+		log.Info(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
+		me.changed = true
+		if (me.Interfaces != nil) {
+			me.Interfaces.AddText(i.Name)
+			me.Interfaces.SetText(i.Name)
+		}
+		return
+	}
+	me.ifmap[i.Index].gone = false
+	log.Log(NET, "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.Info(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) {
+			me.Interfaces.AddText(i.Name)
+			me.Interfaces.SetText(i.Name)
+		}
+		return
+	}
+}
+
+/*
+	These are the real IP address you have been
+	given from DHCP
+*/
+func dhcpAAAA() []string {
+	var aaaa []string
+
+	for s, t := range me.ipmap {
+		if (t.IsReal()) {
+			if (t.ipv6) {
+				aaaa = append(aaaa, s)
+			}
+		}
+	}
+	return aaaa
+}
+
+func realA() []string {
+	var a []string
+
+	for s, t := range me.ipmap {
+		if (t.IsReal()) {
+			if (t.ipv4) {
+				a = append(a, s)
+			}
+		}
+	}
+	return a
+}
+
+func checkDNS() (map[string]*IPtype, map[string]*IPtype) {
+	var ipv4s map[string]*IPtype
+	var ipv6s map[string]*IPtype
+
+	ipv4s = make(map[string]*IPtype)
+	ipv6s = make(map[string]*IPtype)
+
+	for s, t := range me.ipmap {
+		i := t.iface
+		ipt := "IPv4"
+		if (t.ipv6) {
+			ipt = "IPv6"
+		}
+		if (t.IsReal()) {
+			log.Info("\tIP is Real    ", ipt, i.Index, i.Name, s)
+			if (t.ipv6) {
+				ipv6s[s] = t
+			} else {
+				ipv4s[s] = t
+			}
+		} else {
+			log.Info("\tIP is not Real", ipt, i.Index, i.Name, s)
+		}
+	}
+	return ipv6s, ipv4s
+}
+
+// Will figure out if an IP address is new
+func checkIP(ip *net.IPNet, i net.Interface) bool {
+	log.Log(NET, "\t\taddr.(type) = *net.IPNet")
+	log.Log(NET, "\t\taddr.(type) =", ip)
+	var realip string
+	realip = ip.IP.String()
+
+	val, ok := me.ipmap[realip]
+	if ok {
+		log.Log(NET, val.ipnet.IP.String(), "is already a defined IP address")
+		me.ipmap[realip].gone = false
+		return false
+	}
+
+	me.ipmap[realip] = new(IPtype)
+	me.ipmap[realip].gone = false
+	me.ipmap[realip].ipv4 = true
+	me.ipmap[realip].ipnet = ip
+	me.ipmap[realip].ip = ip.IP
+	me.ipmap[realip].iface = &i
+	t := "IPv4"
+	if (IsIPv6(ip.String())) {
+		me.ipmap[realip].ipv6 = true
+		me.ipmap[realip].ipv4 = false
+		t = "IPv6"
+		if (me.IPv6 != nil) {
+			me.IPv6.Set(realip)
+		}
+	} else {
+		me.ipmap[realip].ipv6 = false
+		me.ipmap[realip].ipv4 = true
+		if (me.IPv4 != nil) {
+			me.IPv4.Set(realip)
+		}
+	}
+	if (IsReal(&ip.IP)) {
+		log.Info("\tIP is Real    ", t, i.Index, i.Name, realip)
+	} else {
+		log.Info("\tIP is not Real", t, i.Index, i.Name, realip)
+	}
+	log.Log(NET, "\t\tIP is IsPrivate() =", ip.IP.IsPrivate())
+	log.Log(NET, "\t\tIP is IsLoopback() =", ip.IP.IsLoopback())
+	log.Log(NET, "\t\tIP is IsLinkLocalUnicast() =", ip.IP.IsLinkLocalUnicast())
+	// log.Info("HERE HERE", "realip =", realip, "me.ip[realip]=", me.ipmap[realip])
+	return true
+}
+
+func scanInterfaces() {
+	log.Log(NET, "scanInterfaces() START")
+	ifaces, _ := net.Interfaces()
+	// me.ifnew = ifaces
+	log.Log(NET, SPEW, ifaces)
+	for _, i := range ifaces {
+		addrs, _ := i.Addrs()
+		// log.Info("range ifaces = ", i)
+		checkInterface(i)
+		log.Log(NET, "*net.Interface.Name = ", i.Name, i.Index)
+		log.Log(NET, SPEW, i)
+		log.Log(NET, SPEW, addrs)
+		for _, addr := range addrs {
+			log.Log(NET, "\taddr =", addr)
+			log.Log(NET, SPEW, addrs)
+			ips, _ := net.LookupIP(addr.String())
+			log.Log(NET, "\tLookupIP(addr) =", ips)
+			switch v := addr.(type) {
+			case *net.IPNet:
+				if checkIP(v, i) {
+					log.Log(true, "scanInterfaces() IP is new () i =", v.IP.String())
+				}
+			default:
+				log.Log(NET, "\t\taddr.(type) = NO IDEA WHAT TO DO HERE v =", v)
+			}
+		}
+	}
+	if deleteChanges() {
+		me.changed = true
+		log.Log(NET, "deleteChanges() detected network changes")
+	}
+	updateRealAAAA()
+	log.Log(NET, "scanInterfaces() END")
+}
+
+// displays the IP address found on your network interfaces
+func updateRealAAAA() {
+	var all4 string
+	var all6 string
+	for s, t := range me.ipmap {
+		if (t.ipv4) {
+			all4 += s + "\n"
+			log.Log(NET, "IPv4 =", s)
+		} else if (t.ipv6) {
+			all6 += s + "\n"
+			log.Log(NET, "IPv6 =", s)
+		} else {
+			log.Log(NET, "???? =", s)
+		}
+	}
+	all4 = sortLines(all4)
+	all6 = sortLines(all6)
+	if (me.IPv4.Get() != all4) {
+		log.Log(NET, "IPv4 addresses have changed", all4)
+		me.IPv4.Set(all4)
+	}
+	if (me.IPv6.Get() != all6) {
+		log.Log(NET, "IPv6 addresses have changed", all6)
+		me.IPv6.Set(all6)
+	}
+}
+
+// delete network interfaces and ip addresses from the gui
+func deleteChanges() bool {
+	var changed bool = false
+	for i, t := range me.ifmap {
+		if (t.gone) {
+			log.Log(CHANGE, "DELETE int =", i, "name =", t.name, t.iface)
+			delete(me.ifmap, i)
+			changed = true
+		}
+		t.gone = true
+	}
+	for s, t := range me.ipmap {
+		if (t.gone) {
+			log.Log(CHANGE, "DELETE name =", s, "IPv4 =", t.ipv4)
+			log.Log(CHANGE, "DELETE name =", s, "IPv6 =", t.ipv6)
+			log.Log(CHANGE, "DELETE name =", s, "iface =", t.iface)
+			log.Log(CHANGE, "DELETE name =", s, "ip =", t.ip)
+			delete(me.ipmap, s)
+			changed = true
+		}
+		t.gone = true
+	}
+
+	return changed
+}

linuxstatus/structs.go

@@ -6,6 +6,7 @@
 package linuxstatus
 
 import (
+	"net"
 	"go.wit.com/gui/gui"
 	"go.wit.com/gui/gadgets"
 )
@@ -18,18 +19,39 @@ type LinuxStatus struct {
 	hidden		bool
 	changed		bool
 
+	ifmap		map[int]*IFtype		// the current interfaces
+	ipmap		map[string]*IPtype	// the current ip addresses
+
 	window	*gadgets.BasicWindow
 	group	*gui.Node
 	grid	*gui.Node
 
 	hostshort	*gadgets.OneLiner
 	domainname	*gadgets.OneLiner
+	fqdn		*gadgets.OneLiner
 	NSrr		*gadgets.OneLiner
 	uid		*gadgets.OneLiner
 	IPv4		*gadgets.OneLiner
 	IPv6		*gadgets.OneLiner
 	workingIPv6	*gadgets.OneLiner
-	nics		*gadgets.OneLiner
+	Interfaces	*gui.Node
 	speedActual	*gadgets.OneLiner
 
 }
+
+type IPtype struct {
+	gone		bool		// used to track if the ip exists
+	ipv6		bool		// the future
+	ipv4		bool		// the past
+	LinkLocal	bool
+	iface		*net.Interface
+	ip		net.IP
+	ipnet		*net.IPNet
+}
+
+type IFtype struct {
+	gone		bool		// used to track if the interface exists
+	name		string		// just a shortcut to the name. maybe this is dumb
+	// up		bool		// could be used to track ifup/ifdown
+	iface		*net.Interface
+}

linuxstatus/timer.go

@@ -0,0 +1,31 @@
+package linuxstatus
+
+import (
+	"time"
+	"sort"
+	"strings"
+)
+
+// timeFunction takes a function as an argument and returns the execution time.
+func timeFunction(f func()) time.Duration {
+	startTime := time.Now() // Record the start time
+	f()                     // Execute the function
+	return time.Since(startTime) // Calculate the elapsed time
+}
+
+// sortLines takes a string, splits it on newlines, sorts the lines,
+// and rejoins them with newlines.
+func sortLines(input string) string {
+	lines := strings.Split(input, "\n")
+
+	// Trim leading and trailing whitespace from each line
+	for i, line := range lines {
+		lines[i] = strings.TrimSpace(line)
+	}
+
+	sort.Strings(lines)
+	tmp := strings.Join(lines, "\n")
+	tmp = strings.TrimLeft(tmp, "\n")
+	tmp = strings.TrimRight(tmp, "\n")
+	return tmp
+}

linuxstatus/update.go

@@ -0,0 +1,31 @@
+package linuxstatus
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"go.wit.com/log"
+)
+
+func (ls *LinuxStatus) Update() {
+	log.Info("linuxStatus() Update() START")
+	if ls == nil {
+		log.Error(errors.New("linuxStatus() Update() ls == nil"))
+		return
+	}
+	duration := timeFunction(func () {
+		linuxLoop()
+	})
+	s := fmt.Sprint(duration)
+	ls.speedActual.Set(s)
+
+	if (duration > 500 * time.Millisecond ) {
+		// ls.speed, "SLOW")
+	} else if (duration > 100 * time.Millisecond ) {
+		// ls.speed, "OK")
+	} else {
+		// ls.speed, "FAST")
+	}
+	log.Info("linuxStatus() Update() END")
+}