move this code to go.wit.com/lib/hostname

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

.gitignore

@@ -1,5 +1,10 @@
+*.swp
+go.sum
+go.mod
+
 control-panel-dns
 /files/*
 /*.deb
-*.swp
 /plugins/*
+
+control-panel-dns

Makefile

@@ -0,0 +1,17 @@
+all: goimports vet
+
+vet:
+	GO111MODULE=off go vet
+
+goimports:
+	goimports -w *.go
+
+redomod:
+	rm -f go.*
+	goimports -w *.go
+	GO111MODULE= go mod init
+	GO111MODULE= go mod tidy
+
+clean:
+	-rm -f go.*
+	-go-mod-clean --purge

README.md

@@ -0,0 +1,3 @@
+# linuxstatus
+
+this is being moved to go.wit.com/lib/hostname

RFC-8482

@@ -0,0 +1,450 @@
+Internet Engineering Task Force (IETF)                          J. Abley
+Request for Comments: 8482                                       Afilias
+Updates: 1034, 1035                                       O. Gudmundsson
+Category: Standards Track                                   M. Majkowski
+ISSN: 2070-1721                                          Cloudflare Inc.
+                                                                 E. Hunt
+                                                                     ISC
+                                                            January 2019
+
+
+  Providing Minimal-Sized Responses to DNS Queries That Have QTYPE=ANY
+
+Abstract
+
+   The Domain Name System (DNS) specifies a query type (QTYPE) "ANY".
+   The operator of an authoritative DNS server might choose not to
+   respond to such queries for reasons of local policy, motivated by
+   security, performance, or other reasons.
+
+   The DNS specification does not include specific guidance for the
+   behavior of DNS servers or clients in this situation.  This document
+   aims to provide such guidance.
+
+   This document updates RFCs 1034 and 1035.
+
+Status of This Memo
+
+   This is an Internet Standards Track document.
+
+   This document is a product of the Internet Engineering Task Force
+   (IETF).  It represents the consensus of the IETF community.  It has
+   received public review and has been approved for publication by the
+   Internet Engineering Steering Group (IESG).  Further information on
+   Internet Standards is available in Section 2 of RFC 7841.
+
+   Information about the current status of this document, any errata,
+   and how to provide feedback on it may be obtained at
+   https://www.rfc-editor.org/info/rfc8482.
+
+
+Copyright Notice
+
+   Copyright (c) 2019 IETF Trust and the persons identified as the
+   document authors.  All rights reserved.
+
+   This document is subject to BCP 78 and the IETF Trust's Legal
+   Provisions Relating to IETF Documents
+   (https://trustee.ietf.org/license-info) in effect on the date of
+   publication of this document.  Please review these documents
+   carefully, as they describe your rights and restrictions with respect
+   to this document.  Code Components extracted from this document must
+   include Simplified BSD License text as described in Section 4.e of
+   the Trust Legal Provisions and are provided without warranty as
+   described in the Simplified BSD License.
+
+Table of Contents
+
+   1. Introduction ....................................................3
+      1.1. Terminology ................................................3
+   2. Motivations for Use of ANY Queries ..............................3
+   3. General Approach ................................................4
+   4. Behavior of DNS Responders ......................................5
+      4.1. Answer with a Subset of Available RRsets ...................5
+      4.2. Answer with a Synthesized HINFO RRset ......................5
+      4.3. Answer with Best Guess as to Intention .....................6
+      4.4. Transport Considerations ...................................6
+   5. Behavior of DNS Initiators ......................................7
+   6. HINFO Considerations ............................................7
+   7. Updates to RFCs 1034 and 1035 ...................................7
+   8. Implementation Experience .......................................8
+   9. Security Considerations .........................................8
+   10. IANA Considerations ............................................9
+   11. References .....................................................9
+      11.1. Normative References ......................................9
+      11.2. Informative References ....................................9
+   Acknowledgements ..................................................10
+   Authors' Addresses ................................................10
+
+
+1.  Introduction
+
+   The Domain Name System (DNS) specifies a query type (QTYPE) "ANY".
+   The operator of an authoritative DNS server might choose not to
+   respond to such queries for reasons of local policy, motivated by
+   security, performance, or other reasons.
+
+   The DNS specification [RFC1034] [RFC1035] does not include specific
+   guidance for the behavior of DNS servers or clients in this
+   situation.  This document aims to provide such guidance.
+
+1.1.  Terminology
+
+   This document uses terminology specific to the Domain Name System
+   (DNS), descriptions of which can be found in [RFC8499].
+
+   [RFC1035] defined type 255 to be "*".  However, DNS implementations
+   commonly use the keyword "ANY" to refer to that type code; this
+   document follows that common usage.
+
+   In this document, "ANY query" refers to a DNS meta-query with
+   QTYPE=ANY.  An "ANY response" is a response to such a query.
+
+   In this document, "conventional ANY response" means an ANY response
+   that is constructed in accordance with the algorithm documented in
+   Section 4.3.2 of [RFC1034] and specifically without implementing any
+   of the mechanisms described in this document.
+
+   In an exchange of DNS messages between two hosts, this document
+   refers to the host sending a DNS request as the "initiator" and the
+   host sending a DNS response as the "responder".
+
+   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
+   "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and
+   "OPTIONAL" in this document are to be interpreted as described in
+   BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all
+   capitals, as shown here.
+
+2.  Motivations for Use of ANY Queries
+
+   ANY queries are legitimately used for debugging and checking the
+   state of a DNS server for a particular name.
+
+   ANY queries are sometimes used as an attempt to reduce the number of
+   queries needed to get information, e.g., to obtain MX, A, and AAAA
+   resource record sets (RRsets) for a mail domain in a single query.
+   However, there is no documented guidance available for this use case,
+   and some implementations have been observed not to function as their
+
+   developers expected.  If implementers assume that an ANY query will
+   ultimately be received by an authoritative server and will fetch all
+   existing RRsets, they should include a fallback mechanism to use when
+   that does not happen.
+
+   ANY queries are frequently used to exploit the amplification
+   potential of DNS servers and resolvers using spoofed source addresses
+   and UDP transport (see [RFC5358]).  Having the ability to return
+   small responses to such queries makes DNS servers less attractive
+   amplifiers.
+
+   ANY queries are sometimes used to help mine authoritative-only DNS
+   servers for zone data, since they are expected to return all RRsets
+   for a particular query name.  If DNS operators prefer to reduce the
+   potential for information leaks, they might choose not to send large
+   ANY responses.
+
+   Some authoritative-only DNS server implementations require additional
+   processing in order to send a conventional ANY response; avoiding
+   that processing expense might be desirable.
+
+3.  General Approach
+
+   This proposal provides a mechanism for an authoritative DNS server to
+   signal that conventional ANY queries are not supported for a
+   particular QNAME.  It does so in a way that is both compatible with
+   and triggers desirable behavior by unmodified clients (e.g., DNS
+   resolvers).
+
+   Alternative proposals for dealing with ANY queries have been
+   discussed.  One approach proposes using a new RCODE to signal that an
+   authoritative server did not answer ANY queries in the standard way.
+   This approach was found to have an undesirable effect on both
+   resolvers and authoritative-only servers; resolvers receiving an
+   unknown RCODE would resend the same query to all available
+   authoritative servers rather than suppress future ANY queries for the
+   same QNAME.
+
+   The proposal described in this document avoids that outcome by
+   returning a non-empty RRset in the ANY response, which provides
+   resolvers with something to cache and effectively suppresses repeat
+   queries to the same or different authoritative DNS servers.
+
+
+4.  Behavior of DNS Responders
+
+   Below are the three different modes of behavior by DNS responders
+   when processing queries with QNAMEs that exist, QCLASS=IN, and
+   QTYPE=ANY.  Operators and implementers are free to choose whichever
+   mechanism best suits their environment.
+
+   1.  A DNS responder can choose to select one or a larger subset of
+       the available RRsets at the QNAME.
+
+   2.  A DNS responder can return a synthesized HINFO resource record.
+       See Section 6 for discussion of the use of HINFO.
+
+   3.  A resolver can try to give out the most likely records the
+       requester wants.  This is not always possible, and the result
+       might well be a large response.
+
+   Except as described below in this section, the DNS responder MUST
+   follow the standard algorithms when constructing a response.
+
+4.1.  Answer with a Subset of Available RRsets
+
+   A DNS responder that receives an ANY query MAY decline to provide a
+   conventional ANY response or MAY instead send a response with a
+   single RRset (or a larger subset of available RRsets) in the answer
+   section.
+
+   The RRsets returned in the answer section of the response MAY consist
+   of a single RRset owned by the name specified in the QNAME.  Where
+   multiple RRsets exist, the responder SHOULD choose a small subset of
+   those available to reduce the amplification potential of the
+   response.
+
+   If the zone is signed, appropriate RRSIG records MUST be included in
+   the answer.
+
+   Note that this mechanism does not provide any signaling to indicate
+   to a client that an incomplete subset of the available RRsets has
+   been returned.
+
+4.2.  Answer with a Synthesized HINFO RRset
+
+   If there is no CNAME present at the owner name matching the QNAME,
+   the resource record returned in the response MAY instead be
+   synthesized.  In this case, a single HINFO resource record SHOULD be
+   returned.  The CPU field of the HINFO RDATA SHOULD be set to
+   "RFC8482".  The OS field of the HINFO RDATA SHOULD be set to the null
+   string to minimize the size of the response.
+
+   The TTL encoded for the synthesized HINFO resource record SHOULD be
+   chosen by the operator of the DNS responder to be large enough to
+   suppress frequent subsequent ANY queries from the same initiator with
+   the same QNAME, understanding that a TTL that is too long might make
+   policy changes relating to ANY queries difficult to change in the
+   future.  The specific value used SHOULD be configurable by the
+   operator of the nameserver according to local policy, based on the
+   familiar considerations involved in choosing a TTL value for any
+   resource record in any zone.
+
+   If the DNS query includes DO=1 and the QNAME corresponds to a zone
+   that is known by the responder to be signed, a valid RRSIG for the
+   RRsets in the answer (or authority if answer is empty) section MUST
+   be returned.  In the case of DO=0, the RRSIG SHOULD be omitted.
+
+   A system that receives an HINFO response SHOULD NOT infer that the
+   response was generated according to this specification and apply any
+   special processing of the response because, in general, it is not
+   possible to tell with certainty whether the HINFO RRset received was
+   synthesized.  In particular, systems SHOULD NOT rely upon the HINFO
+   RDATA described in this section to distinguish between synthesized
+   and non-synthesized HINFO RRsets.
+
+4.3.  Answer with Best Guess as to Intention
+
+   In some cases, it is possible to guess what the initiator wants in
+   the answer (but not always).  Some implementations have implemented
+   the spirit of this document by returning all RRsets of RRTYPE CNAME,
+   MX, A, and AAAA that are present at the owner name while suppressing
+   others.  This heuristic seems to work well in practice; it satisfies
+   the needs of some applications whilst suppressing other RRsets such
+   as TXT and DNSKEY that can often contribute to large responses.
+   Whilst some applications may be satisfied by this behavior, the
+   resulting responses in the general case are larger than in the
+   approaches described in Sections 4.1 and 4.2.
+
+   As before, if the zone is signed and the DO bit is set on the
+   corresponding query, an RRSIG RRset MUST be included in the response.
+
+4.4.  Transport Considerations
+
+   A DNS responder MAY behave differently when processing ANY queries
+   received over different transports, e.g., by providing a conventional
+   ANY response over TCP whilst using one of the other mechanisms
+   specified in this document in the case where a query was received
+   using UDP.
+
+   Implementers MAY provide configuration options to allow operators to
+   specify different behavior over different transports.
+
+5.  Behavior of DNS Initiators
+
+   A DNS initiator that sends a query with QTYPE=ANY and receives a
+   response containing an HINFO resource record or a single RRset, as
+   described in Section 4, MAY cache the response in the normal way.
+   Such cached resource records SHOULD be retained in the cache
+   following normal caching semantics, as with any other response
+   received from a DNS responder.
+
+   A DNS initiator MAY suppress queries with QTYPE=ANY in the event that
+   the local cache contains a matching HINFO resource record with the
+   CPU field of the HINFO RDATA, as described in Section 4.  A DNS
+   initiator MAY instead respond to such queries with the contents of
+   the local cache in the usual way.
+
+6.  HINFO Considerations
+
+   It is possible that the synthesized HINFO RRset in an ANY response,
+   once cached by the initiator, might suppress subsequent queries from
+   the same initiator with QTYPE=HINFO.  Thus, the use of HINFO in this
+   proposal would effectively mask the HINFO RRset present in the zone.
+
+   Operators of authoritative servers who serve zones that rely upon
+   conventional use of the HINFO RRTYPE SHOULD sensibly choose the
+   "single RRset" method described in this document or select another
+   type.
+
+   The HINFO RRTYPE is believed to be rarely used in the DNS at the time
+   of writing, based on observations made in passive DNS and at
+   recursive and authoritative DNS servers.
+
+7.  Updates to RFCs 1034 and 1035
+
+   This document extends the specification for processing ANY queries
+   described in Section 4.3.2 of [RFC1034].
+
+   It is important to note that returning a subset of available RRsets
+   when processing an ANY query is legitimate and consistent with
+   [RFC1035]; it can be argued that ANY does not always mean ALL, as
+   used in Section 3.2.3 of [RFC1035].  The main difference here is that
+   the TC bit SHOULD NOT be set in the response, thus indicating that
+   this is not a complete answer.
+
+   This document describes optional behavior for both DNS initiators and
+   responders; implementation of the guidance provided by this document
+   is OPTIONAL.
+
+   RRSIG queries (i.e., queries with QTYPE=RRSIG) are similar to ANY
+   queries in the sense that they have the potential to generate large
+   responses as well as extra work for the responders that process them,
+   e.g., in the case where signatures are generated on the fly.  RRSIG
+   RRsets are not usually obtained using such explicit queries but are
+   rather included in the responses for other RRsets that the RRSIGs
+   cover.  This document does not specify appropriate behavior for RRSIG
+   queries; however, future such advice might well benefit from
+   consistency with and experience with the approaches for ANY queries
+   described here.
+
+8.  Implementation Experience
+
+   In October 2015, the Cloudflare authoritative nameserver
+   implementation implemented the HINFO response.  A few minor problems
+   were reported and have since been resolved.
+
+   An implementation of the subset-mode response to ANY queries was
+   implemented in NSD 4.1 in 2016.
+
+   An implementation of a single RRset response to an ANY query was made
+   for BIND9 by Tony Finch, and that functionality was subsequently made
+   available in production releases starting in BIND 9.11.
+
+9.  Security Considerations
+
+   Queries with QTYPE=ANY are frequently observed as part of reflection
+   attacks, since a relatively small query can be used to elicit a large
+   response.  This is a desirable characteristic if the goal is to
+   maximize the amplification potential of a DNS server as part of a
+   volumetric attack.  The ability of a DNS operator to suppress such
+   responses on a particular server makes that server a less useful
+   amplifier.
+
+   The optional behavior described in this document to reduce the size
+   of responses to queries with QTYPE=ANY is compatible with the use of
+   DNSSEC by both initiator and responder.
+
+
+10.  IANA Considerations
+
+   IANA has updated the following entry in the "Resource Record (RR)
+   TYPEs" registry [RR_TYPES]:
+
+   +------+-------+-------------------------------+--------------------+
+   | TYPE | Value | Meaning                       | Reference          |
+   +------+-------+-------------------------------+--------------------+
+   | *    | 255   | A request for some or all     | [RFC1035][RFC6895] |
+   |      |       | records the server has        | [RFC8482]          |
+   |      |       | available                     |                    |
+   +------+-------+-------------------------------+--------------------+
+
+11.  References
+
+11.1.  Normative References
+
+   [RFC1034]  Mockapetris, P., "Domain names - concepts and facilities",
+              STD 13, RFC 1034, DOI 10.17487/RFC1034, November 1987,
+              <https://www.rfc-editor.org/info/rfc1034>.
+
+   [RFC1035]  Mockapetris, P., "Domain names - implementation and
+              specification", STD 13, RFC 1035, DOI 10.17487/RFC1035,
+              November 1987, <https://www.rfc-editor.org/info/rfc1035>.
+
+   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
+              Requirement Levels", BCP 14, RFC 2119,
+              DOI 10.17487/RFC2119, March 1997,
+              <https://www.rfc-editor.org/info/rfc2119>.
+
+   [RFC8174]  Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC
+              2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174,
+              May 2017, <https://www.rfc-editor.org/info/rfc8174>.
+
+11.2.  Informative References
+
+   [RFC5358]  Damas, J. and F. Neves, "Preventing Use of Recursive
+              Nameservers in Reflector Attacks", BCP 140, RFC 5358,
+              DOI 10.17487/RFC5358, October 2008,
+              <https://www.rfc-editor.org/info/rfc5358>.
+
+   [RFC6895]  Eastlake 3rd, D., "Domain Name System (DNS) IANA
+              Considerations", BCP 42, RFC 6895, DOI 10.17487/RFC6895,
+              April 2013, <https://www.rfc-editor.org/info/rfc6895>.
+
+   [RFC8499]  Hoffman, P., Sullivan, A., and K. Fujiwara, "DNS
+              Terminology", BCP 219, RFC 8499, DOI 10.17487/RFC8499,
+              January 2019, <https://www.rfc-editor.org/info/rfc8499>.
+
+   [RR_TYPES] IANA, "Domain Name System (DNS) Parameters",
+              <https://www.iana.org/assignments/dns-parameters>.
+
+Acknowledgements
+
+   David Lawrence provided valuable observations and concrete
+   suggestions.  Jeremy Laidman helped make the document better.  Tony
+   Finch realized that this document was valuable and implemented it
+   while under attack.  Richard Gibson identified areas where more
+   detail and accuracy were useful.  A large number of other people also
+   provided comments and suggestions; we thank them all for the
+   feedback.
+
+Authors' Addresses
+
+   Joe Abley
+   Afilias
+   300-184 York Street
+   London, ON  N6A 1B5
+   Canada
+
+   Phone: +1 519 670 9327
+   Email: jabley@afilias.info
+
+
+   Olafur Gudmundsson
+   Cloudflare Inc.
+
+   Email: olafur+ietf@cloudflare.com
+
+
+   Marek Majkowski
+   Cloudflare Inc.
+
+   Email: marek@cloudflare.com
+
+
+   Evan Hunt
+   ISC
+   950 Charter St
+   Redwood City, CA  94063
+   United States of America
+
+   Email: each@isc.org

args.go

@@ -0,0 +1,38 @@
+package linuxstatus
+
+/*
+	this enables command line options from other packages like 'gui' and 'log'
+*/
+
+import (
+	"go.wit.com/log"
+)
+
+var NOW *log.LogFlag
+var INFO *log.LogFlag
+var NET *log.LogFlag
+var DNS *log.LogFlag
+
+var PROC *log.LogFlag
+var SPEW *log.LogFlag
+var WARN *log.LogFlag
+
+var CHANGE *log.LogFlag
+var STATUS *log.LogFlag
+
+func init() {
+	full := "go.wit.com/control-panels/dns/linuxstatus"
+	short := "linux"
+
+	NOW = log.NewFlag("NOW", true, full, short, "temp debugging stuff")
+	INFO = log.NewFlag("INFO", false, full, short, "normal debugging stuff")
+	NET = log.NewFlag("NET", false, full, short, "Network logging")
+	DNS = log.NewFlag("DNS", false, full, short, "dnsStatus.update()")
+
+	PROC = log.NewFlag("PROC", false, full, short, "/proc loggging")
+	WARN = log.NewFlag("WARN", true, full, short, "bad things")
+	SPEW = log.NewFlag("SPEW", false, full, short, "spew stuff")
+
+	CHANGE = log.NewFlag("CHANGE", true, full, short, "when host or dns change")
+	STATUS = log.NewFlag("STATUS", false, full, short, "Update() details")
+}

bash.go

@@ -1,60 +0,0 @@
-package main
-
-import (
-        "io"
-	"log"
-        "os"
-        "os/exec"
-        "os/signal"
-        "syscall"
-
-        "github.com/creack/pty"
-        "golang.org/x/term"
-)
-
-func test() error {
-        // Create arbitrary command.
-        c := exec.Command("bash")
-
-        // Start the command with a pty.
-        ptmx, err := pty.Start(c)
-        if err != nil {
-                return err
-        }
-        // Make sure to close the pty at the end.
-        defer func() { _ = ptmx.Close() }() // Best effort.
-
-        // Handle pty size.
-        ch := make(chan os.Signal, 1)
-        signal.Notify(ch, syscall.SIGWINCH)
-        go func() {
-                for range ch {
-                        if err := pty.InheritSize(os.Stdin, ptmx); err != nil {
-                                log.Println("error resizing pty: %s", err)
-                        }
-                }
-        }()
-        ch <- syscall.SIGWINCH // Initial resize.
-        defer func() { signal.Stop(ch); close(ch) }() // Cleanup signals when done.
-
-        // Set stdin in raw mode.
-        oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
-        if err != nil {
-                panic(err)
-        }
-        defer func() { _ = term.Restore(int(os.Stdin.Fd()), oldState) }() // Best effort.
-
-        // Copy stdin to the pty and the pty to stdout.
-        // NOTE: The goroutine will keep reading until the next keystroke before returning.
-        go func() { _, _ = io.Copy(ptmx, os.Stdin) }()
-        _, _ = io.Copy(os.Stdout, ptmx)
-
-        return nil
-}
-
-func mainBash() {
-        if err := test(); err != nil {
-		log.Println(logError, "exit in mainBash()")
-                exit(err)
-        }
-}

common.go

@@ -0,0 +1,63 @@
+// This creates a simple hello world window
+package linuxstatus
+
+import (
+	"go.wit.com/log"
+)
+
+// reports externally if something has changed
+// since the last time it was asked about it
+func (ls *LinuxStatus) Changed() bool {
+	if !ls.Ready() {
+		return false
+	}
+	if ls.changed {
+		ls.changed = false
+		return true
+	}
+	return false
+}
+
+func (ls *LinuxStatus) Show() {
+	if !ls.Ready() {
+		return
+	}
+	log.Log(CHANGE, "Show() window ready =", ls.ready)
+	ls.window.Show()
+	ls.hidden = false
+}
+
+func (ls *LinuxStatus) Hide() {
+	if !ls.Ready() {
+		return
+	}
+	log.Log(CHANGE, "Hide() window ready =", ls.ready)
+	ls.window.Hide()
+	ls.hidden = true
+}
+
+func (ls *LinuxStatus) Toggle() {
+	if !ls.Ready() {
+		return
+	}
+	log.Log(CHANGE, "Toggle() window ready =", ls.ready)
+	if ls.hidden {
+		ls.Show()
+	} else {
+		ls.Hide()
+	}
+}
+
+func (ls *LinuxStatus) Ready() bool {
+	log.Log(SPEW, "Ready() maybe not ready? ls =", ls)
+	if me == nil {
+		return false
+	}
+	if ls == nil {
+		return false
+	}
+	if ls.window == nil {
+		return false
+	}
+	return me.ready
+}

debian/Makefile

@@ -1,50 +0,0 @@
-# GITVERSION=$(shell git rev-parse FETCH_HEAD)
-VERSION=$(shell git describe --tags $(git rev-list --tags --max-count=1) | sed 's/^v//')
-
-BASENAME=control-panel-dns
-
-all: help deb
-
-help:
-	@echo
-	@echo "make deb     # attempt to build the .deb package using dpkg"
-	@echo
-
-deb: clean extract DEBIAN build
-
-clean:
-	rm -rf ../files
-	rm -f ../*.deb
-	rm -f ../*.tar.xz data.tar.xz
-	rm -rf DEBIAN
-
-extract:
-	mkdir -p ../files/usr/bin
-	mkdir -p ../files/usr/lib/control-panel-dns/
-	-cp ~/go/src/git.wit.org/wit/gui/toolkit/*.so ../files/usr/lib/control-panel-dns/
-	cp  ../README.md ../files/usr/lib/control-panel-dns/
-	cp  ../control-panel-dns ../files/usr/bin/
-
-# makes the DEBIAN/ directory
-DEBIAN:
-	mkdir -p DEBIAN
-
-	# make the md5sum file
-	cd ../files/ && find -type f -exec md5sum '{}' \; |sort -k2 >../md5sums
-	mv ../md5sums DEBIAN/
-
-	# make the control there
-	mkdir -p DEBIAN
-	cp control DEBIAN/
-	echo Version: ${VERSION} >>DEBIAN/control
-
-	cp postinst DEBIAN
-
-build:
-	mv DEBIAN ../files/
-	cd .. && dpkg-deb --build files ${BASENAME}_${VERSION}_amd64.deb
-	@echo
-	@echo '#######################'
-	cd .. && dpkg-deb --info ${BASENAME}_${VERSION}_amd64.deb
-	@echo '#######################'
-	@echo

debian/compat

@@ -1 +0,0 @@
-10

debian/control

@@ -1,9 +0,0 @@
-Source: control-panel-dns
-Build-Depends: golang
-Package: control-panel-dns
-Maintainer: Jeff Carr <jcarr@wit.com>
-Architecture: amd64
-Depends:
-Recommends: libgtk-3-0, ddclient, ddupdate
-Description: a control panel for DNS and IPv6 settings
- Goals: show the settings, validate & update DNS

debian/postinst

@@ -1 +0,0 @@
-#!/bin/sh

draw.go

@@ -0,0 +1,36 @@
+// This creates a simple hello world window
+package linuxstatus
+
+import (
+	"go.wit.com/lib/gadgets"
+)
+
+// creates the actual widgets.
+// it's assumed you are always passing in a box
+func draw(ls *LinuxStatus) {
+	ls.group = ls.window.Box().NewGroup("What Linux Knows It Is")
+
+	ls.grid = ls.group.NewGrid("gridnuts", 2, 2)
+
+	ls.hostnameStatus = gadgets.NewOneLiner(ls.grid, "status")
+	ls.hostname = gadgets.NewOneLiner(ls.grid, "hostname -f")
+	ls.hostshort = gadgets.NewOneLiner(ls.grid, "hostname -s")
+	ls.domainname = gadgets.NewOneLiner(ls.grid, "domain name")
+	ls.resolver = gadgets.NewOneLiner(ls.grid, "nameservers =")
+	ls.resolver.SetText("TODO")
+	ls.uid = gadgets.NewOneLiner(ls.grid, "UID =")
+	ls.IPv4 = gadgets.NewOneLiner(ls.grid, "Current IPv4 =")
+	ls.IPv6 = gadgets.NewOneLiner(ls.grid, "Current IPv6 =")
+	ls.workingIPv4 = gadgets.NewOneLiner(ls.grid, "Real IPv4 =")
+	ls.workingIPv6 = gadgets.NewOneLiner(ls.grid, "Real IPv6 =")
+	// ls.nics		= gadgets.NewOneLiner(ls.grid, "network intefaces =")
+
+	ls.grid.NewLabel("interfaces =")
+	ls.Interfaces = ls.grid.NewCombobox()
+
+	ls.speed = gadgets.NewOneLiner(ls.grid, "refresh speed =")
+	ls.speedActual = gadgets.NewOneLiner(ls.grid, "refresh speed =")
+
+	ls.grid.Margin()
+	ls.grid.Pad()
+}

dynamic-dns-update.go

@@ -1,32 +0,0 @@
-package main
-
-/* 
-	https://pkg.go.dev/github.com/miekg/dns#section-readme
-
-DYNAMIC UPDATES
-
-Dynamic updates reuses the DNS message format, but renames three of the sections. Question is Zone, Answer is Prerequisite, Authority is Update, only the Additional is not renamed. See RFC 2136 for the gory details.
-
-You can set a rather complex set of rules for the existence of absence of certain resource records or names in a zone to specify if resource records should be added or removed. The table from RFC 2136 supplemented with the Go DNS function shows which functions exist to specify the prerequisites.
-
-3.2.4 - Table Of Metavalues Used In Prerequisite Section
-
- CLASS    TYPE     RDATA    Meaning                    Function
- --------------------------------------------------------------
- ANY      ANY      empty    Name is in use             dns.NameUsed
- ANY      rrset    empty    RRset exists (value indep) dns.RRsetUsed
- NONE     ANY      empty    Name is not in use         dns.NameNotUsed
- NONE     rrset    empty    RRset does not exist       dns.RRsetNotUsed
- zone     rrset    rr       RRset exists (value dep)   dns.Used
-
-The prerequisite section can also be left empty. If you have decided on the prerequisites you can tell what RRs should be added or deleted. The next table shows the options you have and what functions to call.
-
-3.4.2.6 - Table Of Metavalues Used In Update Section
-
- CLASS    TYPE     RDATA    Meaning                     Function
- ---------------------------------------------------------------
- ANY      ANY      empty    Delete all RRsets from name dns.RemoveName
- ANY      rrset    empty    Delete an RRset             dns.RemoveRRset
- NONE     rrset    rr       Delete an RR from RRset     dns.Remove
- zone     rrset    rr       Add to an RRset             dns.Insert
-*/

fsnotify.go

@@ -1,79 +0,0 @@
-package main
-
-// Watches for changes to a directory. Works cross-platform
-
-import (
-	"log"
-	"github.com/fsnotify/fsnotify"
-)
-
-// This would be a really dumb way to watch for new network interfaces
-// since it then watches a linux only directory /sys/class/net for changes
-
-func watchSysClassNet() {
-    // Create new watcher.
-    watcher, err := fsnotify.NewWatcher()
-    if err != nil {
-	    log.Println(logError, "watchSysClassNet() failed:", err)
-	    return
-    }
-    defer watcher.Close()
-
-    // Start listening for events.
-    go func() {
-        for {
-            select {
-            case event, ok := <-watcher.Events:
-                if !ok {
-                    return
-                }
-                log.Println("event:", event)
-                if event.Has(fsnotify.Write) {
-                    log.Println("modified file:", event.Name)
-                }
-            case err, ok := <-watcher.Errors:
-                if !ok {
-                    return
-                }
-                log.Println("error:", err)
-            }
-        }
-    }()
-
-    // Add a path.
-    err = watcher.Add("/tmp")
-    if err != nil {
-	    log.Println(logError, "watchSysClassNet() watcher.Add() failed:", err)
-	    return
-    }
-
-    // Block main goroutine forever.
-    <-make(chan struct{})
-}
-
-func fsnotifyNetworkInterfaceChanges() error {
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
-		return err
-	}
-	defer watcher.Close()
-
-	// Watch for network interface changes
-	err = watcher.Add("/sys/class/net")
-	if err != nil {
-		return err
-	}
-	for {
-		select {
-		case event := <-watcher.Events:
-			log.Println("fsnotifyNetworkInterfaceChanges() event =", event)
-			if event.Op&fsnotify.Create == fsnotify.Create {
-					// Do something on network interface creation
-			}
-		case err := <-watcher.Errors:
-			log.Println("fsnotifyNetworkInterfaceChanges() event err =", err)
-			return err
-		}
-	}
-}
-

hostname.go

@@ -1,73 +1,195 @@
-// inspired from:
-// https://github.com/mactsouk/opensource.com.git
-// and
-// https://coderwall.com/p/wohavg/creating-a-simple-tcp-server-in-go
-
-package main
+// figures out if your hostname is valid
+// then checks if your DNS is setup correctly
+package linuxstatus
 
 import (
-	"log"
-	"git.wit.org/wit/shell"
-)
+	"fmt"
+	"io/ioutil"
+	"strings"
+
+	"go.wit.com/lib/gui/shell"
+	"go.wit.com/log"
 
 	// will try to get this hosts FQDN
-import "github.com/Showmax/go-fqdn"
+	"github.com/Showmax/go-fqdn"
+)
 
-// this is the king of dns libraries
-import "github.com/miekg/dns"
+func (ls *LinuxStatus) GetDomainName() string {
+	if !me.Ready() {
+		return ""
+	}
+	return me.domainname.String()
+}
 
-// dnssec IPv6 socket library
-import "git.wit.org/jcarr/dnssecsocket"
-
-func getHostname() {
-	var err error
-	var s string = "gui.Label == nil"
-	s, err = fqdn.FqdnHostname()
-	if (err != nil) {
-		log.Println("FQDN hostname error =", err)
+func (ls *LinuxStatus) setDomainName() {
+	if !me.Ready() {
 		return
 	}
-	if (me.fqdn != nil) {
-		if (me.hostname != s) {
-			me.fqdn.SetText(s)
-			me.hostname = s
+
+	dn := run("domainname")
+	if me.domainname.String() != dn {
+		log.Log(CHANGE, "domainname has changed from", me.GetDomainName(), "to", dn)
+		me.domainname.SetText(dn)
+		me.changed = true
+	}
+}
+
+func (ls *LinuxStatus) GetHostname() string {
+	if !me.Ready() {
+		return ""
+	}
+	return me.hostname.String()
+}
+
+func (ls *LinuxStatus) ValidHostname() bool {
+	if !me.Ready() {
+		log.Info("ValidHostname() not ready")
+		return false
+	}
+	if me.hostnameStatus.String() == "WORKING" {
+		return true
+	}
+	return false
+}
+
+func (ls *LinuxStatus) setHostname(newname string) {
+	if !me.Ready() {
+		return
+	}
+	if newname == me.hostname.String() {
+		return
+	}
+	log.Log(CHANGE, "hostname has changed from", me.GetHostname(), "to", newname)
+	me.hostname.SetText(newname)
+	me.changed = true
+}
+
+func (ls *LinuxStatus) GetHostShort() string {
+	if !me.Ready() {
+		return ""
+	}
+	return me.hostshort.String()
+}
+
+func (ls *LinuxStatus) setHostShort() {
+	if !me.Ready() {
+		return
+	}
+	hshort := run("hostname -s")
+	if me.hostshort.String() != hshort {
+		log.Log(CHANGE, "hostname -s has changed from", me.hostshort.String(), "to", hshort)
+		me.hostshort.SetText(hshort)
+		me.changed = true
+	}
+}
+
+// getDomainName extracts the domain name from a given hostname
+func getDomainName(hostname string) (string, error) {
+	parts := strings.Split(hostname, ".")
+	if len(parts) < 3 {
+		return "", fmt.Errorf("hostname '%s' is too short to extract a domain name", hostname)
+	}
+	// Join all parts except the first one, which is assumed to be a subdomain
+	domain := strings.Join(parts[1:], ".")
+	return domain, nil
+}
+
+func lookupHostname() {
+	if !me.Ready() {
+		return
+	}
+	var err error
+	var hostfqdn string = "broken"
+	hostfqdn, err = fqdn.FqdnHostname()
+	if err != nil {
+		log.Error(err, "FQDN hostname error")
+		return
+	}
+	log.Log(NET, "full hostname should be: ", hostfqdn)
+
+	me.setDomainName()
+	me.setHostShort()
+
+	// these are authoritative
+	// if they work wrong, your linux configuration is wrong.
+	// Do not complain.
+	// Fix your distro if your box is otherwise not working this way
+	hshort := me.GetHostShort()  // from `hostname -s`
+	dn := me.GetDomainName()     // from `domanname`
+	hostname := me.GetHostname() // from `hostname -f`
+
+	if hostfqdn != hostname {
+		log.Log(WARN, "hostname", hostname, "does not equal fqdn.FqdnHostname()", hostfqdn)
+		// TODO: figure out what is wrong
+		if dn == "(none)" {
+			realdn, err := getDomainName(hostfqdn)
+			if err == nil {
+				log.Log(WARN, "need to run: 'domainname", realdn, "' here")
+				me.changed = true
+				me.hostnameStatus.SetText("FIXING")
+				shell.Run([]string{"domainname", realdn})
+				return
+			} else {
+				log.Log(WARN, "getDomainName() err =", err)
+				log.Log(WARN, "/etc/hostname is too short. let the user set the name here.")
+				// me.changed = true
+				me.hostnameStatus.SetText("INVALID DOMAIN NAME")
+				// return
+			}
+		}
+		log.Log(WARN, "don't know what to do here with domainname")
+		log.Log(WARN, "check that /etc/hostname is valid?")
+		// me.changed = true
+		me.hostnameStatus.SetText("UNKNOWN")
+		// return
+	}
+
+	var test string
+	test = hshort + "." + dn
+
+	me.setHostname(test)
+
+	if hostname != test {
+		log.Log(CHANGE, "hostname", hostname, "does not equal", test)
+		if me.hostnameStatus.String() != "BROKEN" {
+			log.Log(CHANGE, "hostname", hostname, "does not equal", test)
+			me.changed = true
+			me.hostnameStatus.SetText("BROKEN")
+		}
+	} else {
+		if me.hostnameStatus.String() != "WORKING" {
+			log.Log(CHANGE, "hostname", hostname, "is valid")
+			me.hostnameStatus.SetText("WORKING")
 			me.changed = true
 		}
 	}
-	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)
+func goodHostname() bool {
+	content, err := ioutil.ReadFile("/etc/hostname")
+	if err != nil {
+		// this needs to be a fixWindow() error
+		log.Error(err)
+	}
+
+	hostname := string(content)
+
+	log.Log(NOW, "hostname =", hostname)
 
 	hs := run("hostname -s")
 	dn := run("domainname")
-	log.Println("hostname short =", hs, "domainname =", dn)
+	log.Log(NOW, "hostname short =", hs, "domainname =", dn)
 
 	tmp := hs + "." + dn
-	if (hostname == tmp) {
-		log.Println("hostname seems to be good", hostname)
+	if hostname == tmp {
+		log.Log(NOW, "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.Println(args.VerboseDNS, SPEW, rrset)
-	for i, rr := range rrset {
-		log.Println(args.VerboseDNS, "r.Answer =", i, rr)
-		ipaddr := dns.Field(rr, 1)
-		aaaa = append(aaaa, ipaddr)
-	}
-	log.Println(args.VerboseDNS, "aaaa =", aaaa)
-	return aaaa
-}

linuxloop.go

@@ -0,0 +1,99 @@
+// GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007
+// Copyright (c) 2023 WIT.COM, Inc.
+
+// This is a control panel for DNS
+
+// This is the main Linux kernel / OS code
+// to check your network settings are correct
+// This does (and should do) no network or external checking
+// This is just the state of your OS
+
+package linuxstatus
+
+import (
+	"io/ioutil"
+	"os"
+	"os/user"
+	"sort"
+	"strconv"
+	"strings"
+
+	"go.wit.com/log"
+)
+
+func linuxLoop() {
+	me.changed = false
+
+	// checks for a VALID hostname
+	lookupHostname()
+	if me.changed {
+		log.Log(CHANGE, "lookupHostname() detected a change")
+	}
+
+	// scans the linux network intefaces for your available IPv4 & IPv6 addresses
+	scanInterfaces()
+	if me.changed {
+		log.Log(CHANGE, "scanInterfaces() detected a change")
+	}
+	for i, t := range me.ifmap {
+		log.Log(NET, strconv.Itoa(i)+" iface = "+t.iface.Name)
+	}
+
+	// get all the real A records from all the network interfaces linux can see
+	a := realA()
+	sort.Strings(a)
+	tmp := strings.Join(a, "\n")
+	if tmp != me.workingIPv4.String() {
+		log.Log(CHANGE, "realA() your real IPv6 addresses changed")
+		me.changed = true
+		me.workingIPv4.SetText(tmp)
+	}
+
+	// get all the real AAAA records from all the network interfaces linux can see
+	aaaa := realAAAA()
+	sort.Strings(aaaa)
+	tmp = strings.Join(aaaa, "\n")
+	if tmp != me.workingIPv6.String() {
+		log.Log(CHANGE, "realAAAA() your real IPv6 addresses changed")
+		me.changed = true
+		me.workingIPv6.SetText(tmp)
+	}
+
+	user, _ := user.Current()
+	tmp = user.Username + " (" + strconv.Itoa(os.Getuid()) + ")"
+	if tmp != me.uid.String() {
+		log.Log(CHANGE, "os.Getuid =", user.Username, os.Getuid())
+		me.changed = true
+		me.uid.SetText(tmp)
+	}
+
+	content, _ := ioutil.ReadFile("/etc/resolv.conf")
+	var ns []string
+	for _, line := range strings.Split(string(content), "\n") {
+		parts := strings.Split(line, " ")
+		if len(parts) > 1 {
+			if parts[0] == "nameserver" {
+				ns = append(ns, parts[1])
+			}
+		}
+	}
+	sort.Strings(ns)
+	newNS := strings.Join(ns, "\n")
+	if newNS != me.resolver.String() {
+		log.Log(CHANGE, "resolver changed in /etc/resolv.conf to", ns)
+		me.changed = true
+		me.resolver.SetText(newNS)
+	}
+
+	/*
+		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
+	*/
+}

log.go

@@ -1,33 +0,0 @@
-package main
-
-import 	(
-	"log"
-	witlog "git.wit.org/wit/gui/log"
-)
-
-// various debugging flags
-var logNow bool = true	// useful for active development
-var logError bool = true
-var logWarn bool = false
-var logInfo bool = false
-var logVerbose bool = false
-
-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.Println(logError, "got to log() exit")
-	witlog.Exit(a...)
-}

lookupAAAA.go

@@ -1,32 +0,0 @@
-package main
-
-/*
-import "log"
-import "github.com/miekg/dns"
-
-import "git.wit.org/jcarr/dnssecsocket"
-
-import "github.com/davecgh/go-spew/spew"
-// import "github.com/Showmax/go-fqdn"
-
-func lookupAAAA(hostname string) string {
-	// lookup the IP address from DNS
-	dnsRR := dnssecsocket.Dnstrace(hostname, "AAAA")
-	spew.Dump(dnsRR)
-	if (dnsRR == nil) {
-		return "BROKEN"
-	}
-	ipaddr := dns.Field(dnsRR, 1)
-	log.Println("ipaddr", ipaddr)
-	return ipaddr
-}
-*/
-
-/*
-func main() {
-	hostname := "check.lab.wit.org"
-	// 2604:bbc0:2:248:5054:f0ff:fe00:156
-
-	lookupAAAA(hostname)
-}
-*/

net.go

@@ -1,63 +1,35 @@
 // This creates a simple hello world window
-package main
+package linuxstatus
 
 import (
-	"log"
+	// "log"
 	"net"
+	"sort"
 	"strings"
+
+	"go.wit.com/log"
 )
 
-var DEBUGNET bool = false
-
-// 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.Println(DEBUGNET, "watchNet()")
-	// Start goroutine to watch for changes
-	go func() {
-		log.Println(DEBUGNET, "watchNet() func")
-		for {
-			log.Println(DEBUGNET, "forever loop start")
-			// Check for changes in each interface
-			for _, i := range interfaces {
-				log.Println(DEBUGNET, "something on i =", i)
-				if status := i.Flags & net.FlagUp; status != 0 {
-					notification <- i
-					log.Println(DEBUGNET, "something on i =", i)
-				}
-			}
-			log.Println(DEBUGNET, "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.Println(DEBUGNET, "\t\tIP is Real = false")
+	if t.ip.IsPrivate() || t.ip.IsLoopback() || t.ip.IsLinkLocalUnicast() {
+		log.Log(NET, "\t\tIP is Real = false")
 		return false
 	} else {
-		log.Println(DEBUGNET, "\t\tIP is Real = true")
+		log.Log(NET, "\t\tIP is Real = true")
 		return true
 	}
 }
 
 func IsReal(ip *net.IP) bool {
-	if (ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast()) {
-		log.Println(DEBUGNET, "\t\tIP is Real = false")
+	if ip.IsPrivate() || ip.IsLoopback() || ip.IsLinkLocalUnicast() {
+		log.Log(NET, "\t\tIP is Real = false")
 		return false
 	} else {
-		log.Println(DEBUGNET, "\t\tIP is Real = true")
+		log.Log(NET, "\t\tIP is Real = true")
 		return true
 	}
 }
@@ -74,24 +46,24 @@ func renameInterface(i *net.Interface) {
 func checkInterface(i net.Interface) {
 	val, ok := me.ifmap[i.Index]
 	if !ok {
-		log.Println(i.Name, "is a new network interface. The linux kernel index =", i.Index)
+		log.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) {
+		if me.Interfaces != nil {
 			me.Interfaces.AddText(i.Name)
 			me.Interfaces.SetText(i.Name)
 		}
 		return
 	}
 	me.ifmap[i.Index].gone = false
-	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.Println(val.iface.Name, "has changed to it's name to", i.Name)
+	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.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) {
+		if me.Interfaces != nil {
 			me.Interfaces.AddText(i.Name)
 			me.Interfaces.SetText(i.Name)
 		}
@@ -99,12 +71,16 @@ func checkInterface(i net.Interface) {
 	}
 }
 
+/*
+These are the real IP address you have been
+given from DHCP
+*/
 func realAAAA() []string {
 	var aaaa []string
 
 	for s, t := range me.ipmap {
-		if (t.IsReal()) {
-			if (t.ipv6) {
+		if t.IsReal() {
+			if t.ipv6 {
 				aaaa = append(aaaa, s)
 			}
 		}
@@ -112,7 +88,20 @@ func realAAAA() []string {
 	return aaaa
 }
 
-func checkDNS() (map[string]*IPtype, map[string]*IPtype) {
+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 checkDNSOld() (map[string]*IPtype, map[string]*IPtype) {
 	var ipv4s map[string]*IPtype
 	var ipv6s map[string]*IPtype
 
@@ -122,18 +111,18 @@ func checkDNS() (map[string]*IPtype, map[string]*IPtype) {
 	for s, t := range me.ipmap {
 		i := t.iface
 		ipt := "IPv4"
-		if (t.ipv6) {
+		if t.ipv6 {
 			ipt = "IPv6"
 		}
-		if (t.IsReal()) {
-			log.Println("\tIP is Real    ", ipt, i.Index, i.Name, s)
-			if (t.ipv6) {
+		if t.IsReal() {
+			log.Log(INFO, "\tIP is Real    ", ipt, i.Index, i.Name, s)
+			if t.ipv6 {
 				ipv6s[s] = t
 			} else {
 				ipv4s[s] = t
 			}
 		} else {
-			log.Println("\tIP is not Real", ipt, i.Index, i.Name, s)
+			log.Log(INFO, "\tIP is not Real", ipt, i.Index, i.Name, s)
 		}
 	}
 	return ipv6s, ipv4s
@@ -141,14 +130,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.Println(args.VerboseNet, "\t\taddr.(type) = *net.IPNet")
-	log.Println(args.VerboseNet, "\t\taddr.(type) =", ip)
+	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.Println(args.VerboseNet, val.ipnet.IP.String(), "is already a defined IP address")
+		log.Log(NET, val.ipnet.IP.String(), "is already a defined IP address")
 		me.ipmap[realip].gone = false
 		return false
 	}
@@ -160,97 +149,147 @@ func checkIP(ip *net.IPNet, i net.Interface) bool {
 	me.ipmap[realip].ip = ip.IP
 	me.ipmap[realip].iface = &i
 	t := "IPv4"
-	if (IsIPv6(ip.String())) {
+	if IsIPv6(ip.String()) {
 		me.ipmap[realip].ipv6 = true
 		me.ipmap[realip].ipv4 = false
 		t = "IPv6"
-		if (me.IPv6 != nil) {
+		if me.IPv6 != nil {
 			me.IPv6.SetText(realip)
 		}
 	} else {
 		me.ipmap[realip].ipv6 = false
 		me.ipmap[realip].ipv4 = true
-		if (me.IPv4 != nil) {
+		if me.IPv4 != nil {
 			me.IPv4.SetText(realip)
 		}
 	}
-	if (IsReal(&ip.IP)) {
-		log.Println("\tIP is Real    ", t, i.Index, i.Name, realip)
+	if IsReal(&ip.IP) {
+		log.Log(INFO, "\tIP is Real    ", t, i.Index, i.Name, realip)
 	} else {
-		log.Println("\tIP is not Real", t, i.Index, i.Name, realip)
+		log.Log(INFO, "\tIP is not Real", t, i.Index, i.Name, 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])
+	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.Log(INFO, "HERE HERE", "realip =", realip, "me.ip[realip]=", me.ipmap[realip])
 	return true
 }
 
 func scanInterfaces() {
-	me.changed = false
+	log.Log(NET, "scanInterfaces() START")
 	ifaces, _ := net.Interfaces()
 	// me.ifnew = ifaces
-	log.Println(DEBUGNET, SPEW, ifaces)
+	log.Log(NET, SPEW, ifaces)
 	for _, i := range ifaces {
 		addrs, _ := i.Addrs()
-		// log.Println("range ifaces = ", i)
+		// log.Log(INFO, "range ifaces = ", i)
 		checkInterface(i)
-		log.Println(args.VerboseNet, "*net.Interface.Name = ", i.Name, i.Index)
-		log.Println(args.VerboseNet, SPEW, i)
-		log.Println(DEBUGNET, SPEW, addrs)
+		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.Println(DEBUGNET, "\taddr =", addr)
-			log.Println(DEBUGNET, SPEW, addrs)
+			log.Log(NET, "\taddr =", addr)
+			log.Log(NET, SPEW, addrs)
 			ips, _ := net.LookupIP(addr.String())
-			log.Println(DEBUGNET, "\tLookupIP(addr) =", ips)
+			log.Log(NET, "\tLookupIP(addr) =", ips)
 			switch v := addr.(type) {
 			case *net.IPNet:
-				checkIP(v, i)
-				// log.Println("\t\tIP is () =", ip.())
+				if checkIP(v, i) {
+					log.Log(NET, "scanInterfaces() IP is new () i =", v.IP.String())
+				}
 			default:
-				log.Println(DEBUGNET, "\t\taddr.(type) = NO IDEA WHAT TO DO HERE v =", v)
+				log.Log(NET, "\t\taddr.(type) = NO IDEA WHAT TO DO HERE v =", v)
 			}
 		}
 	}
-	deleteChanges()
-	var all4 string
-	var all6 string
+	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.Println("IPv4 =", s)
-		} else if (t.ipv6) {
-			all6 += s + "\n"
-			log.Println("IPv6 =", s)
+		if t.ipv4 {
+			all4 = append(all4, s)
+			log.Log(NET, "IPv4 =", s)
+		} else if t.ipv6 {
+			all6 = append(all6, s)
+			log.Log(NET, "IPv6 =", s)
 		} else {
-			log.Println("???? =", s)
+			log.Log(NET, "???? =", s)
 		}
 	}
-	all4 = strings.TrimSpace(all4)
-	all6 = strings.TrimSpace(all6)
-	me.IPv4.SetText(all4)
-	me.IPv6.SetText(all6)
+
+	// sort and create text
+	sort.Strings(all4)
+	sort.Strings(all6)
+	s4 := strings.Join(all4, "\n")
+	s6 := strings.Join(all6, "\n")
+
+	if me.IPv4.String() != s4 {
+		log.Log(CHANGE, "IPv4 addresses have changed", s4)
+		me.IPv4.SetText(s4)
+		me.changed = true
+	}
+	if me.IPv6.String() != s6 {
+		log.Log(CHANGE, "IPv6 addresses have changed", s6)
+		me.IPv6.SetText(s6)
+		me.changed = true
+	}
 }
 
 // delete network interfaces and ip addresses from the gui
-func deleteChanges() {
+func deleteChanges() bool {
+	var changed bool = false
 	for i, t := range me.ifmap {
-		if (t.gone) {
-			log.Println("DELETE int =", i, "name =", t.name, t.iface)
+		if t.gone {
+			log.Log(CHANGE, "DELETE int =", i, "name =", t.name, t.iface)
 			delete(me.ifmap, i)
-			me.changed = true
+			changed = true
 		}
 		t.gone = true
 	}
 	for s, t := range me.ipmap {
-		if (t.gone) {
-			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)
+		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)
-			me.changed = true
+			changed = true
 		}
 		t.gone = true
 	}
+
+	return changed
+}
+
+func (ls *LinuxStatus) GetIPv6() []string {
+	if !me.Ready() {
+		return nil
+	}
+	tmp := me.workingIPv6.String()
+	return strings.Split(tmp, "\n")
+}
+
+func (ls *LinuxStatus) GetIPv4() []string {
+	if !me.Ready() {
+		return nil
+	}
+	tmp := me.workingIPv4.String()
+	return strings.Split(tmp, "\n")
+}
+
+func (ls *LinuxStatus) GetNameservers() []string {
+	if !me.Ready() {
+		return nil
+	}
+	tmp := me.resolver.String()
+	return strings.Split(tmp, "\n")
 }

new.go

@@ -0,0 +1,29 @@
+// This creates a simple hello world window
+package linuxstatus
+
+import (
+	"go.wit.com/log"
+
+	"go.wit.com/lib/gadgets"
+)
+
+func InitLinuxStatus() *LinuxStatus {
+	if me != nil {
+		log.Log(WARN, "You have done New() twice. You can only do this once")
+		return me
+	}
+	me = &LinuxStatus{
+		hidden: true,
+		ready:  false,
+	}
+	me.ifmap = make(map[int]*IFtype)
+	me.ipmap = make(map[string]*IPtype)
+
+	log.Log(WARN, "Creating the Window")
+	me.window = gadgets.RawBasicWindow("OS Hostname Details")
+	me.window.Make()
+	draw(me)
+
+	me.ready = true
+	return me
+}

nsupdate.go

@@ -1,34 +0,0 @@
-// 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)
-			}
-		}
-	}
-}

proc.go

@@ -0,0 +1,101 @@
+package linuxstatus
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"go.wit.com/log"
+)
+
+func GetProcessNameByPort(port int) string {
+	// Convert port to hex string
+	portHex := strconv.FormatInt(int64(port), 16)
+
+	// Function to search /proc/net/tcp or /proc/net/udp
+	searchProcNet := func(file string) string {
+		data, err := ioutil.ReadFile(file)
+		if err != nil {
+			return ""
+		}
+		// log.Log(PROC, "searchProcNet() data:", string(data))
+
+		lines := strings.Split(string(data), "\n")
+		for _, line := range lines {
+			fields := strings.Fields(line)
+			log.Log(PROC, "searchProcNet() portHex:", portHex)
+			if len(fields) > 9 {
+				log.Log(PROC, "searchProcNet() fields[9]", fields[9])
+			}
+			log.Log(PROC, "searchProcNet() lines:", line)
+			if len(fields) > 1 {
+				parts := strings.Split(fields[1], ":")
+				if len(parts) > 1 {
+					// Convert the hexadecimal string to an integer
+					value, _ := strconv.ParseInt(parts[1], 16, 64)
+					log.Log(PROC, "searchProcNet() value, port =", value, port, "parts[1] =", parts[1])
+					if port == int(value) {
+						log.Log(PROC, "searchProcNet() THIS IS THE LINE:", fields)
+						return fields[9]
+					}
+				}
+			}
+		}
+
+		return ""
+	}
+
+	// Search TCP and then UDP
+	inode := searchProcNet("/proc/net/tcp")
+	if inode == "" {
+		inode = searchProcNet("/proc/net/udp")
+	}
+	log.Log(PROC, "searchProcNet() inode =", inode)
+
+	// Search for process with the inode
+	procs, _ := ioutil.ReadDir("/proc")
+	for _, proc := range procs {
+		if !proc.IsDir() {
+			continue
+		}
+
+		fdPath := filepath.Join("/proc", proc.Name(), "fd")
+		fds, err := ioutil.ReadDir(fdPath)
+		if err != nil {
+			continue // Process might have exited; skip it
+		}
+
+		for _, fd := range fds {
+			fdLink, _ := os.Readlink(filepath.Join(fdPath, fd.Name()))
+			var s string
+			s = "socket:[" + inode + "]"
+			if strings.Contains(fdLink, "socket:[") {
+				log.Log(PROC, "searchProcNet() fdLink has socket:", fdLink)
+				log.Log(PROC, "searchProcNet() proc.Name() =", proc.Name(), "s =", s)
+			}
+			if strings.Contains(fdLink, "socket:[35452]") {
+				log.Log(PROC, "searchProcNet() found proc.Name() =", proc.Name(), fdLink)
+				return proc.Name()
+			}
+			if strings.Contains(fdLink, "socket:[35450]") {
+				log.Log(PROC, "searchProcNet() found proc.Name() =", proc.Name(), fdLink)
+				return proc.Name()
+			}
+			if strings.Contains(fdLink, "socket:[35440]") {
+				log.Log(PROC, "searchProcNet() found proc.Name() =", proc.Name(), fdLink)
+				return proc.Name()
+			}
+			if strings.Contains(fdLink, "socket:[21303]") {
+				log.Log(PROC, "searchProcNet() found proc.Name() =", proc.Name(), fdLink)
+				// return proc.Name()
+			}
+			if strings.Contains(fdLink, "socket:["+inode+"]") {
+				return proc.Name()
+			}
+		}
+	}
+
+	return ""
+}

rtnetlink.go

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

run.go

@@ -1,37 +0,0 @@
-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

@@ -0,0 +1,61 @@
+/*
+	figures out if your hostname is valid
+	then checks if your DNS is setup correctly
+*/
+
+package linuxstatus
+
+import (
+	"net"
+
+	"go.wit.com/gui"
+	"go.wit.com/lib/gadgets"
+)
+
+var me *LinuxStatus
+
+type LinuxStatus struct {
+	ready   bool
+	hidden  bool
+	changed bool
+
+	parent *gui.Node
+
+	ifmap map[int]*IFtype    // the current interfaces
+	ipmap map[string]*IPtype // the current ip addresses
+
+	window *gadgets.BasicWindow
+	group  *gui.Node
+	grid   *gui.Node
+
+	hostnameStatus *gadgets.OneLiner
+	hostname       *gadgets.OneLiner
+	hostshort      *gadgets.OneLiner
+	domainname     *gadgets.OneLiner
+	resolver       *gadgets.OneLiner
+	uid            *gadgets.OneLiner
+	IPv4           *gadgets.OneLiner
+	IPv6           *gadgets.OneLiner
+	workingIPv4    *gadgets.OneLiner
+	workingIPv6    *gadgets.OneLiner
+	Interfaces     *gui.Node
+	speed          *gadgets.OneLiner
+	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
+}

timer.go

@@ -0,0 +1,38 @@
+package linuxstatus
+
+import (
+	"sort"
+	"strings"
+	"time"
+)
+
+// 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
+}
+
+func (ls *LinuxStatus) SetSpeedActual(s string) {
+	if !ls.Ready() {
+		return
+	}
+	ls.speedActual.SetText(s)
+}

unix.go

@@ -2,13 +2,17 @@
 
 // https://wiki.archlinux.org/title/Dynamic_DNS
 
-package main
+package linuxstatus
 
 import (
-	"log"
+	"bytes"
+	"fmt"
+	"net"
 	"os"
 	"os/exec"
-	"net"
+	"strings"
+
+	"go.wit.com/log"
 )
 
 func CheckSuperuser() bool {
@@ -23,15 +27,15 @@ func Escalate() {
 		cmd.Stderr = os.Stderr
 		err := cmd.Run()
 		if err != nil {
-			log.Println(logError, "exit in Escalate()")
-			exit(err)
+			log.Error(err, "exit in Escalate()")
+			log.Exit(err)
 		}
 	}
 }
 
 // You need permission to do a zone transfer. Otherwise:
-// dig +noall +answer +multiline lab.wit.org any 
-// dig +all +multiline fire.lab.wit.org # gives the zonefile header (ttl vals)
+// dig +noall +answer +multiline lab.wit.com any
+// dig +all +multiline fire.lab.wit.com # gives the zonefile header (ttl vals)
 func DumpPublicDNSZone(zone string) {
 	entries, err := net.LookupHost(zone)
 	if err != nil {
@@ -45,7 +49,7 @@ func DumpPublicDNSZone(zone string) {
 func dumpIPs(host string) {
 	ips, err := net.LookupIP(host)
 	if err != nil {
-		log.Println(logError, "dumpIPs() failed:", err)
+		log.Error(err, "dumpIPs() failed")
 	}
 	for _, ip := range ips {
 		log.Println(host, ip)
@@ -64,3 +68,30 @@ func ddclient() {
 */
 func ddupdate() {
 }
+
+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 ""
+	}
+
+	// Trim leading and trailing whitespace from each line
+	tmp := strings.TrimSpace(out.String())
+	// Output the results
+	log.Verbose("Command Output:", tmp)
+
+	return tmp
+}

update.go

@@ -0,0 +1,43 @@
+package linuxstatus
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"go.wit.com/log"
+)
+
+func (ls *LinuxStatus) Update() {
+	if ls == nil {
+		return
+	}
+	if !ls.Ready() {
+		log.Log(WARN, "can't update yet. ready is false")
+		log.Error(errors.New("Update() is not ready yet"))
+		return
+	}
+	log.Log(INFO, "Update() START")
+	duration := timeFunction(func() {
+		linuxLoop()
+	})
+	ls.setSpeed(duration)
+	log.Log(INFO, "Update() END")
+}
+
+func (ls *LinuxStatus) setSpeed(duration time.Duration) {
+	s := fmt.Sprint(duration)
+	if ls.speedActual == nil {
+		log.Log(WARN, "can't actually warn")
+		return
+	}
+	ls.speedActual.SetText(s)
+
+	if duration > 500*time.Millisecond {
+		ls.speed.SetText("SLOW")
+	} else if duration > 100*time.Millisecond {
+		ls.speed.SetText("OK")
+	} else {
+		ls.speed.SetText("FAST")
+	}
+}