GnomeZworc
0c0b58820c
Le contrat et le listener vont dans internal/api/dhcp (package dhcpapi), sur la forme de internal/api/agent, et le client dans internal/client/dhcp. Chaînage des imports : statefile <- dhcpd <- dhcpapi <- dhcpclient, sans cycle. dhcpd parle net.IP et net.IPNet et garde ses structs disque privées ; dhcpapi parle chaînes JSON et convertit à la frontière. Un même type portait jusqu'ici le format du fil, la signature du Store et le format du .state — ce qui couplait le fichier au protocole alors que le ticket le décrit comme un détail interne. Le digest est calculé sur une forme canonique partagée par les deux côtés : MAC, IP et CIDR normalisés, hôtes triés, doublon de MAC refusé. Un écart de digest signale donc une vraie divergence, pas une différence d'écriture. Le listener pose un recover par connexion, plafonne les lignes à 64 Kio, refuse une ligne malformée sans fermer la connexion, écoute en 0600 et supprime une socket résiduelle avant le bind. Le client pose une deadline. 101 tests au total, -race propre, treize mutations toutes détectées. Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
116 lines
2.4 KiB
Go
116 lines
2.4 KiB
Go
package dhcpapi
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net"
|
|
"sort"
|
|
)
|
|
|
|
func canonicalMAC(s string) (string, error) {
|
|
mac, err := net.ParseMAC(s)
|
|
if err != nil {
|
|
return "", fmt.Errorf("invalid mac %q: %w", s, err)
|
|
}
|
|
return mac.String(), nil
|
|
}
|
|
|
|
func canonicalIP(s string) (string, error) {
|
|
ip := net.ParseIP(s)
|
|
if ip == nil {
|
|
return "", fmt.Errorf("invalid ip %q", s)
|
|
}
|
|
return ip.String(), nil
|
|
}
|
|
|
|
func canonicalCIDR(s string) (string, error) {
|
|
_, network, err := net.ParseCIDR(s)
|
|
if err != nil {
|
|
return "", fmt.Errorf("invalid cidr %q: %w", s, err)
|
|
}
|
|
return network.String(), nil
|
|
}
|
|
|
|
func SortHosts(hosts []Host) {
|
|
sort.Slice(hosts, func(i, j int) bool { return hosts[i].MAC < hosts[j].MAC })
|
|
}
|
|
|
|
func CanonicalSubnet(s Subnet) (Subnet, error) {
|
|
network, err := canonicalCIDR(s.Network)
|
|
if err != nil {
|
|
return Subnet{}, err
|
|
}
|
|
interfaceIP, err := canonicalIP(s.InterfaceIP)
|
|
if err != nil {
|
|
return Subnet{}, err
|
|
}
|
|
|
|
out := Subnet{Network: network, InterfaceIP: interfaceIP}
|
|
|
|
if s.VPCRoute != "" {
|
|
if out.VPCRoute, err = canonicalCIDR(s.VPCRoute); err != nil {
|
|
return Subnet{}, err
|
|
}
|
|
}
|
|
if s.DefaultGateway != "" {
|
|
if out.DefaultGateway, err = canonicalIP(s.DefaultGateway); err != nil {
|
|
return Subnet{}, err
|
|
}
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func CanonicalHost(h Host) (Host, error) {
|
|
mac, err := canonicalMAC(h.MAC)
|
|
if err != nil {
|
|
return Host{}, err
|
|
}
|
|
ip, err := canonicalIP(h.IP)
|
|
if err != nil {
|
|
return Host{}, err
|
|
}
|
|
return Host{MAC: mac, IP: ip, VM: h.VM, DefaultRoute: h.DefaultRoute}, nil
|
|
}
|
|
|
|
func Canonical(s State) (State, error) {
|
|
out := State{Hosts: make([]Host, 0, len(s.Hosts))}
|
|
|
|
if s.Subnet != nil {
|
|
subnet, err := CanonicalSubnet(*s.Subnet)
|
|
if err != nil {
|
|
return State{}, err
|
|
}
|
|
out.Subnet = &subnet
|
|
}
|
|
|
|
seen := make(map[string]struct{}, len(s.Hosts))
|
|
for _, h := range s.Hosts {
|
|
host, err := CanonicalHost(h)
|
|
if err != nil {
|
|
return State{}, err
|
|
}
|
|
if _, dup := seen[host.MAC]; dup {
|
|
return State{}, fmt.Errorf("duplicate mac %s", host.MAC)
|
|
}
|
|
seen[host.MAC] = struct{}{}
|
|
out.Hosts = append(out.Hosts, host)
|
|
}
|
|
SortHosts(out.Hosts)
|
|
|
|
return out, nil
|
|
}
|
|
|
|
func Digest(s State) (string, error) {
|
|
canonical, err := Canonical(s)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
raw, err := json.Marshal(canonical)
|
|
if err != nil {
|
|
return "", fmt.Errorf("encode state: %w", err)
|
|
}
|
|
sum := sha256.Sum256(raw)
|
|
return hex.EncodeToString(sum[:]), nil
|
|
}
|