upgrade to go 1.20

Author: pyke369

.gitignore

@@ -1,5 +1,4 @@
 pdhcp
-debian/pdhcp
 debian/*debhelper*
 debian/*substvars*
 debian/files

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2015-2020 Pierre-Yves Kerembellec
+Copyright (c) 2015-2023 Pierre-Yves Kerembellec
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -3,28 +3,32 @@
 # build targets
 .PHONY: support
 all: pdhcp support
-pdhcp: src/*.go
-	@export GOPATH=/tmp/go; export CGO_ENABLED=0; cd src && go build -trimpath -o ../pdhcp && cd .. && strip pdhcp
+pdhcp: *.go
+	@env GOPATH=/tmp/go go get -d && env GOPATH=/tmp/go CGO_ENABLED=0 go build -trimpath -o pdhcp
+	@-strip pdhcp 2>/dev/null || true
+	@-upx -9 pdhcp 2>/dev/null || true
 support:
 	@make -C support
 clean:
 	@make -C support clean
 distclean:
 	@make -C support distclean
-	@rm -f pdhcp
+	@rm -f pdhcp *.upx
 deb:
 	@debuild -e GOROOT -e GOPATH -e PATH -i -us -uc -b
 debclean:
 	@debuild -- clean
 	@rm -f ../pdhcp_*
 
 # run targets
+run: pdhcp
+	@./pdhcp -i eth0
 client: pdhcp
 	@./pdhcp -i veth0i
 local-backend: pdhcp
 	@./pdhcp -i br0 -b support/local-backend.py -w 4
 remote-backend: pdhcp
-	@./pdhcp -i eth0 -b http://install.dm.gg/dev.php
+	@./pdhcp -i eth0 -b http://remote.server.com/dhcp
 relay: pdhcp
 	@./pdhcp -i br0 -r localhost:6767
 remote-server: pdhcp

src/bsd.go bsd.go

@@ -1,4 +1,4 @@
-// +build freebsd openbsd netbsd darwin
+//go:build freebsd || openbsd || netbsd || darwin
 
 package main
 

debian/changelog

@@ -1,3 +1,9 @@
+pdhcp (2.0.6) stable; urgency=medium
+
+  * update to go 1.20
+
+ -- Pierre-Yves Kerembellec <[email protected]>  Sat, 04 Feb 2023 14:50:44 +0100
+
 pdhcp (2.0.5) stable; urgency=medium
 
   * more fixes to service autostart madness

debian/compat

@@ -1 +1 @@
-9
+10

debian/control

@@ -2,7 +2,7 @@ Source: pdhcp
 Section: net
 Priority: optional
 Maintainer: Pierre-Yves Kerembellec <[email protected]>
-Build-Depends: debhelper (>= 5), golang-1.15
+Build-Depends: debhelper (>= 5), golang-1.20
 Standards-Version: 3.7.2
 
 Package: pdhcp

src/dhcp.go dhcp.go

@@ -1,8 +1,8 @@
 module pdhcp
 
-go 1.15
+go 1.20
 
 require (
-	github.com/pyke369/golang-support v0.0.0-20200321184731-cd1ed731523d
-	golang.org/x/sys v0.0.0-20200909081042-eff7692f9009
+	github.com/pyke369/golang-support v0.0.0-20230108182845-9fe2fa61d8f6
+	golang.org/x/sys v0.4.0
 )

src/dhcpv4.go dhcpv4.go

@@ -1,4 +1,4 @@
-github.com/pyke369/golang-support v0.0.0-20200321184731-cd1ed731523d h1:bssjYWDUaYbjtBc7gZ6BI3YBerIg5EAn+kAM5hMQf2s=
-github.com/pyke369/golang-support v0.0.0-20200321184731-cd1ed731523d/go.mod h1:0XGrzgrEp0fa/+JSV8XZePUwyjnU6C3bMc7Xz2bHHKI=
-golang.org/x/sys v0.0.0-20200909081042-eff7692f9009 h1:W0lCpv29Hv0UaM1LXb9QlBHLNP8UFfcKjblhVCWftOM=
-golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+github.com/pyke369/golang-support v0.0.0-20230108182845-9fe2fa61d8f6 h1:F76ajQ+Rq3bLrUZnBYdAJ20MjQRQk0HLMjHtvgJJu/U=
+github.com/pyke369/golang-support v0.0.0-20230108182845-9fe2fa61d8f6/go.mod h1:86DUae4wbzSq5Zaoh8ufyM0br8ZEm8o5QrmEiOqg7eM=
+golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
+golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

src/dhcpv6.go dhcpv6.go

@@ -1,4 +1,4 @@
-// +build linux
+//go:build linux
 
 package main
 
@@ -169,7 +169,6 @@ func (rc *RawConn) ReadFrom(data []byte) (read int, from *RawAddr, err error) {
 		}
 		return
 	}
-	return
 }
 
 func (rc *RawConn) WriteTo(from, to *RawAddr, data []byte) (written int, err error) {

go.mod

@@ -26,8 +26,8 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-const progname = "pdhcp"
-const version = "2.0.5"
+const PROGNAME = "pdhcp"
+const VERSION = "2.0.6"
 
 type SOURCE struct {
 	mode    string
@@ -48,7 +48,7 @@ type CONTEXT struct {
 }
 
 var (
-	log      *ulog.ULog
+	logger   *ulog.ULog
 	sources  = map[string]*SOURCE{}
 	contexts = map[string]*CONTEXT{}
 	lock     sync.RWMutex
@@ -68,8 +68,7 @@ func main() {
 	arguments = flag.FlagSet{Usage: func() {
 		fmt.Fprintf(os.Stderr, "usage: %s [OPTIONS...]\n\noptions are:\n", filepath.Base(os.Args[0]))
 		arguments.PrintDefaults()
-	},
-	}
+	}}
 	help := arguments.Bool("h", false, "show this help screen")
 	sversion := arguments.Bool("v", false, "show the program version")
 	list1 := arguments.Bool("l", false, "list all available DHCP options (human format)")
@@ -110,7 +109,7 @@ func main() {
 
 	// show program version
 	if *sversion {
-		fmt.Printf("%s/v%s\n", progname, version)
+		fmt.Printf("%s/v%s\n", PROGNAME, VERSION)
 		os.Exit(0)
 	}
 
@@ -124,9 +123,9 @@ func main() {
 	if *format == "" {
 		*format = "console(output=stderr,time=msdatetime) syslog(facility=local0)"
 	}
-	log = ulog.New(*format)
+	logger = ulog.New(*format)
 	if mode != "client" {
-		log.Info(map[string]interface{}{"mode": mode, "event": "start", "version": version, "pid": os.Getpid()})
+		logger.Info(map[string]interface{}{"mode": mode, "event": "start", "version": VERSION, "pid": os.Getpid()})
 	}
 
 	// start and keep backend workers alive
@@ -143,8 +142,8 @@ func main() {
 								if request, err := http.NewRequest(http.MethodPost, *backend, bytes.NewBuffer(payload)); err == nil {
 									request.Header.Set("Content-Length", fmt.Sprintf("%d", len(payload)))
 									request.Header.Set("Content-Type", "application/json")
-									request.Header.Set("User-Agent", fmt.Sprintf("%s/%s", progname, version))
-									log.Info(map[string]interface{}{"event": "http-send", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
+									request.Header.Set("User-Agent", fmt.Sprintf("%s/%s", PROGNAME, VERSION))
+									logger.Info(map[string]interface{}{"event": "http-send", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
 										"txid": fmt.Sprintf("%v/%v", frame["client-hardware-address"], frame["bootp-transaction-id"]), "target": *backend})
 									client := &http.Client{Timeout: 7 * time.Second}
 									if response, err := client.Do(request); err == nil {
@@ -156,7 +155,7 @@ func main() {
 											lock.RLock()
 											if contexts[v4key(frame)] != nil {
 												if packet, err := v4build(frame); err == nil {
-													log.Info(map[string]interface{}{"event": "http-receive", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
+													logger.Info(map[string]interface{}{"event": "http-receive", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
 														"txid": fmt.Sprintf("%v/%v", frame["client-hardware-address"], frame["bootp-transaction-id"]), "target": *backend})
 													pmux <- PACKET{source: "http", client: *backend, data: packet}
 												}
@@ -175,25 +174,26 @@ func main() {
 			for *workers > 0 {
 				go func() {
 					for {
-						command, pid := &exec.Cmd{Path: *backend}, 0
+						command, pid := &exec.Cmd{Path: *backend, Stderr: os.Stderr}, 0
 						if stdin, err := command.StdinPipe(); err == nil {
 							if stdout, err := command.StdoutPipe(); err == nil {
 								if err := command.Start(); err == nil {
 									pid = command.Process.Pid
-									log.Info(map[string]interface{}{"event": "worker-start", "backend": *backend, "worker": pid})
-									backend := make(chan FRAME)
+									logger.Info(map[string]interface{}{"event": "worker-start", "backend": *backend, "worker": pid})
+									queue := make(chan FRAME)
 									go func() {
 										reader := bufio.NewReader(stdout)
 										for {
 											if line, err := reader.ReadString('\n'); err != nil {
-												backend <- nil
+												queue <- nil
 												break
 											} else {
 												var frame FRAME
+
 												if err := json.Unmarshal([]byte(line), &frame); err == nil {
 													lock.RLock()
 													if contexts[v4key(frame)] != nil {
-														backend <- frame
+														queue <- frame
 													}
 													lock.RUnlock()
 												} else {
@@ -209,17 +209,17 @@ func main() {
 											if payload, err := json.Marshal(frame); err == nil {
 												payload = append(payload, '\n')
 												if _, err := stdin.Write(payload); err == nil {
-													log.Info(map[string]interface{}{"event": "worker-send", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
+													logger.Info(map[string]interface{}{"event": "worker-send", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
 														"txid": fmt.Sprintf("%v/%v", frame["client-hardware-address"], frame["bootp-transaction-id"]), "worker": pid})
 												}
 											}
 
-										case frame := <-backend:
+										case frame := <-queue:
 											if frame == nil {
 												break loop
 											}
 											if packet, err := v4build(frame); err == nil {
-												log.Info(map[string]interface{}{"event": "worker-receive", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
+												logger.Info(map[string]interface{}{"event": "worker-receive", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
 													"txid": fmt.Sprintf("%v/%v", frame["client-hardware-address"], frame["bootp-transaction-id"]), "worker": pid})
 												pmux <- PACKET{source: "worker", client: fmt.Sprintf("%d", pid), data: packet}
 											}
@@ -228,7 +228,7 @@ func main() {
 								}
 							}
 						}
-						log.Warn(map[string]interface{}{"event": "worker-stop", "backend": *backend, "worker": pid, "status": fmt.Sprintf("%v", command.Wait())})
+						logger.Warn(map[string]interface{}{"event": "worker-stop", "backend": *backend, "worker": pid, "status": fmt.Sprintf("%v", command.Wait())})
 						time.Sleep(5 * time.Second)
 					}
 				}()
@@ -323,11 +323,11 @@ func main() {
 				if name != "" {
 					if handle, err := NewRawConn(&RawAddr{Port: *port, Device: name}); err == nil {
 						if handle.Local.Addr == nil {
-							log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("skipping interface %s: no ip address", name)})
+							logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("skipping interface %s: no ip address", name)})
 							return
 						}
 						source.rhandle = handle
-						log.Info(map[string]interface{}{"event": "listen", "listen": fmt.Sprintf("%s@%s:%d", name, *address, *port),
+						logger.Info(map[string]interface{}{"event": "listen", "listen": fmt.Sprintf("%s@%s:%d", name, *address, *port),
 							"source": fmt.Sprintf("%s@%s", handle.Local.HardwareAddr, handle.Local.Addr)})
 					} else if mode == "relay" {
 						config := net.ListenConfig{
@@ -341,13 +341,13 @@ func main() {
 							}}
 						if handle, err := config.ListenPacket(context.Background(), "udp", fmt.Sprintf("%s:%d", *address, *port)); err == nil {
 							source.handle = handle
-							log.Info(map[string]interface{}{"event": "listen", "listen": fmt.Sprintf("%s@%s:%d", name, *address, *port)})
+							logger.Info(map[string]interface{}{"event": "listen", "listen": fmt.Sprintf("%s@%s:%d", name, *address, *port)})
 						} else {
-							log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("skipping interface %s: %v", name, err)})
+							logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("skipping interface %s: %v", name, err)})
 							return
 						}
 					} else {
-						log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("skipping interface %s: %v", name, err)})
+						logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("skipping interface %s: %v", name, err)})
 						return
 					}
 				} else {
@@ -362,9 +362,9 @@ func main() {
 						}}
 					if handle, err := config.ListenPacket(context.Background(), "udp", fmt.Sprintf("%s:%d", *address, *port)); err == nil {
 						source.handle = handle
-						log.Info(map[string]interface{}{"event": "listen", "listen": fmt.Sprintf("%s@%s:%d", name, *address, *port)})
+						logger.Info(map[string]interface{}{"event": "listen", "listen": fmt.Sprintf("%s@%s:%d", name, *address, *port)})
 					} else {
-						log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
+						logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
 						return
 					}
 				}
@@ -406,7 +406,7 @@ func main() {
 			select {
 			case packet := <-pmux:
 				if frame, err := v4parse(packet.data); err != nil {
-					log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err), "source": packet.source, "client": packet.client})
+					logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err), "source": packet.source, "client": packet.client})
 				} else {
 					key := v4key(frame)
 					if frame["bootp-opcode"] == "request" {
@@ -443,7 +443,7 @@ func main() {
 						if value, ok := frame["hostname"].(string); ok {
 							hostname = value
 						}
-						log.Info(map[string]interface{}{"event": "request", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
+						logger.Info(map[string]interface{}{"event": "request", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
 							"txid":   fmt.Sprintf("%v/%v", frame["client-hardware-address"], frame["bootp-transaction-id"]),
 							"source": packet.source, "client": packet.client, "requested-ip-address": address, "hostname": hostname,
 						})
@@ -463,7 +463,7 @@ func main() {
 							if rpacket, err := v4build(rframe); err == nil {
 								if raddress, err := net.ResolveUDPAddr("udp", *relay); err == nil {
 									if _, err := sources["-"].handle.WriteTo(rpacket, raddress); err == nil {
-										log.Info(map[string]interface{}{"event": "relay-send", "message": fmt.Sprintf("dhcp-%v", rframe["dhcp-message-type"]),
+										logger.Info(map[string]interface{}{"event": "relay-send", "message": fmt.Sprintf("dhcp-%v", rframe["dhcp-message-type"]),
 											"txid": fmt.Sprintf("%v/%v", rframe["client-hardware-address"], rframe["bootp-transaction-id"]), "relay": relay})
 									}
 								}
@@ -500,7 +500,7 @@ func main() {
 							break
 						}
 						if mode == "relay" {
-							log.Info(map[string]interface{}{"event": "relay-receive", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
+							logger.Info(map[string]interface{}{"event": "relay-receive", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
 								"txid": fmt.Sprintf("%s/%s", frame["client-hardware-address"], frame["bootp-transaction-id"]), "relay": relay})
 						}
 						if sources[context.source].rhandle != nil && sources[context.source].rhandle.Local.Addr != nil {
@@ -515,21 +515,21 @@ func main() {
 									to.HardwareAddr, _ = net.ParseMAC(frame["client-hardware-address"].(string))
 								}
 								if _, err := sources[context.source].rhandle.WriteTo(nil, to, packet); err != nil {
-									log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
+									logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
 									break
 								}
 							} else {
-								log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
+								logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
 								break
 							}
 						} else {
 							if address, err := net.ResolveUDPAddr("udp", client); err == nil {
 								if _, err := sources[context.source].handle.WriteTo(packet, address); err != nil {
-									log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
+									logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
 									break
 								}
 							} else {
-								log.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
+								logger.Warn(map[string]interface{}{"event": "error", "error": fmt.Sprintf("%v", err)})
 								break
 							}
 						}
@@ -543,7 +543,7 @@ func main() {
 								hostname += "." + value
 							}
 						}
-						log.Info(map[string]interface{}{"event": "reply", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
+						logger.Info(map[string]interface{}{"event": "reply", "message": fmt.Sprintf("dhcp-%v", frame["dhcp-message-type"]),
 							"txid":   fmt.Sprintf("%s/%s", frame["client-hardware-address"], frame["bootp-transaction-id"]),
 							"source": context.source, "client": client, "bootp-assigned-address": address, "hostname": hostname,
 							"duration": fmt.Sprintf("%.2fms", float64(time.Now().Sub(context.created))/float64(time.Millisecond))})

go.sum

@@ -2,10 +2,12 @@
 
 # build targets
 http-backend: http-backend.go
-	@export GOPATH=/tmp/go; export CGO_ENABLED=0; go build -trimpath -o http-backend http-backend.go && strip http-backend
+	@env GOPATH=/tmp/go go get -d && env GOPATH=/tmp/go CGO_ENABLED=0 go build -trimpath -o http-backend
+	@-strip http-backend 2>/dev/null || true
+	@-upx -9 http-backend 2>/dev/null || true
 clean:
 distclean:
-	@rm -f http-backend
+	@rm -f http-backend *.upx
 
 # run targets
 primary: http-backend

src/linux.go linux.go

@@ -320,13 +320,14 @@ func main() {
 	for _, path := range config.GetPaths("backend.listen") {
 		if parts := strings.Split(config.GetStringMatch(path, "_", "^.*?(:\\d+)?((,[^,]+){2})?$"), ","); parts[0] != "_" {
 			if len(parts) > 1 {
-				loader := &dynacert.DYNACERT{Public: parts[1], Key: parts[2]}
+				certificates := &dynacert.DYNACERT{}
+				certificates.Add("*", parts[1], parts[2])
 				server := &http.Server{
 					Addr:         strings.TrimLeft(parts[0], "*"),
 					ReadTimeout:  uconfig.Duration(config.GetDurationBounds("backend.read_timeout", 10, 5, 30)),
 					IdleTimeout:  uconfig.Duration(config.GetDurationBounds("backend.idle_timeout", 30, 5, 30)),
 					WriteTimeout: uconfig.Duration(config.GetDurationBounds("backend.write_timeout", 15, 5, 30)),
-					TLSConfig:    dynacert.IntermediateTLSConfig(loader.GetCertificate),
+					TLSConfig:    dynacert.IntermediateTLSConfig(certificates.GetCertificate),
 					TLSNextProto: map[string]func(*http.Server, *tls.Conn, http.Handler){},
 				}
 				go func(server *http.Server, parts []string) {