* dhcp: move HTTP handlers to dhcpd/

dhcpd/dhcp_http.go

@@ -0,0 +1,461 @@
+package dhcpd
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os/exec"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/AdguardTeam/golibs/file"
+	"github.com/AdguardTeam/golibs/log"
+)
+
+func httpError(r *http.Request, w http.ResponseWriter, code int, format string, args ...interface{}) {
+	text := fmt.Sprintf(format, args...)
+	log.Info("DHCP: %s %s: %s", r.Method, r.URL, text)
+	http.Error(w, text, code)
+}
+
+// []Lease -> JSON
+func convertLeases(inputLeases []Lease, includeExpires bool) []map[string]string {
+	leases := []map[string]string{}
+	for _, l := range inputLeases {
+		lease := map[string]string{
+			"mac":      l.HWAddr.String(),
+			"ip":       l.IP.String(),
+			"hostname": l.Hostname,
+		}
+
+		if includeExpires {
+			lease["expires"] = l.Expiry.Format(time.RFC3339)
+		}
+
+		leases = append(leases, lease)
+	}
+	return leases
+}
+
+func (s *Server) handleDHCPStatus(w http.ResponseWriter, r *http.Request) {
+	leases := convertLeases(s.Leases(), true)
+	staticLeases := convertLeases(s.StaticLeases(), false)
+	status := map[string]interface{}{
+		"config":        s.conf,
+		"leases":        leases,
+		"static_leases": staticLeases,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	err := json.NewEncoder(w).Encode(status)
+	if err != nil {
+		httpError(r, w, http.StatusInternalServerError, "Unable to marshal DHCP status json: %s", err)
+		return
+	}
+}
+
+type staticLeaseJSON struct {
+	HWAddr   string `json:"mac"`
+	IP       string `json:"ip"`
+	Hostname string `json:"hostname"`
+}
+
+type dhcpServerConfigJSON struct {
+	ServerConfig `json:",inline"`
+	StaticLeases []staticLeaseJSON `json:"static_leases"`
+}
+
+func (s *Server) handleDHCPSetConfig(w http.ResponseWriter, r *http.Request) {
+	newconfig := dhcpServerConfigJSON{}
+	err := json.NewDecoder(r.Body).Decode(&newconfig)
+	if err != nil {
+		httpError(r, w, http.StatusBadRequest, "Failed to parse new DHCP config json: %s", err)
+		return
+	}
+
+	err = s.CheckConfig(newconfig.ServerConfig)
+	if err != nil {
+		httpError(r, w, http.StatusBadRequest, "Invalid DHCP configuration: %s", err)
+		return
+	}
+
+	err = s.Stop()
+	if err != nil {
+		log.Error("failed to stop the DHCP server: %s", err)
+	}
+
+	err = s.Init(newconfig.ServerConfig)
+	if err != nil {
+		httpError(r, w, http.StatusBadRequest, "Invalid DHCP configuration: %s", err)
+		return
+	}
+	s.conf.ConfigModified()
+
+	if newconfig.Enabled {
+
+		staticIP, err := hasStaticIP(newconfig.InterfaceName)
+		if !staticIP && err == nil {
+			err = setStaticIP(newconfig.InterfaceName)
+			if err != nil {
+				httpError(r, w, http.StatusInternalServerError, "Failed to configure static IP: %s", err)
+				return
+			}
+		}
+
+		err = s.Start()
+		if err != nil {
+			httpError(r, w, http.StatusBadRequest, "Failed to start DHCP server: %s", err)
+			return
+		}
+	}
+}
+
+type netInterface struct {
+	Name         string   `json:"name"`
+	MTU          int      `json:"mtu"`
+	HardwareAddr string   `json:"hardware_address"`
+	Addresses    []string `json:"ip_addresses"`
+	Flags        string   `json:"flags"`
+}
+
+// getValidNetInterfaces returns interfaces that are eligible for DNS and/or DHCP
+// invalid interface is a ppp interface or the one that doesn't allow broadcasts
+func getValidNetInterfaces() ([]net.Interface, error) {
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return nil, fmt.Errorf("Couldn't get list of interfaces: %s", err)
+	}
+
+	netIfaces := []net.Interface{}
+
+	for i := range ifaces {
+		if ifaces[i].Flags&net.FlagPointToPoint != 0 {
+			// this interface is ppp, we're not interested in this one
+			continue
+		}
+
+		iface := ifaces[i]
+		netIfaces = append(netIfaces, iface)
+	}
+
+	return netIfaces, nil
+}
+
+func (s *Server) handleDHCPInterfaces(w http.ResponseWriter, r *http.Request) {
+	response := map[string]interface{}{}
+
+	ifaces, err := getValidNetInterfaces()
+	if err != nil {
+		httpError(r, w, http.StatusInternalServerError, "Couldn't get interfaces: %s", err)
+		return
+	}
+
+	for _, iface := range ifaces {
+		if iface.Flags&net.FlagLoopback != 0 {
+			// it's a loopback, skip it
+			continue
+		}
+		if iface.Flags&net.FlagBroadcast == 0 {
+			// this interface doesn't support broadcast, skip it
+			continue
+		}
+		addrs, err := iface.Addrs()
+		if err != nil {
+			httpError(r, w, http.StatusInternalServerError, "Failed to get addresses for interface %s: %s", iface.Name, err)
+			return
+		}
+
+		jsonIface := netInterface{
+			Name:         iface.Name,
+			MTU:          iface.MTU,
+			HardwareAddr: iface.HardwareAddr.String(),
+		}
+
+		if iface.Flags != 0 {
+			jsonIface.Flags = iface.Flags.String()
+		}
+		// we don't want link-local addresses in json, so skip them
+		for _, addr := range addrs {
+			ipnet, ok := addr.(*net.IPNet)
+			if !ok {
+				// not an IPNet, should not happen
+				httpError(r, w, http.StatusInternalServerError, "SHOULD NOT HAPPEN: got iface.Addrs() element %s that is not net.IPNet, it is %T", addr, addr)
+				return
+			}
+			// ignore link-local
+			if ipnet.IP.IsLinkLocalUnicast() {
+				continue
+			}
+			jsonIface.Addresses = append(jsonIface.Addresses, ipnet.IP.String())
+		}
+		if len(jsonIface.Addresses) != 0 {
+			response[iface.Name] = jsonIface
+		}
+
+	}
+
+	err = json.NewEncoder(w).Encode(response)
+	if err != nil {
+		httpError(r, w, http.StatusInternalServerError, "Failed to marshal json with available interfaces: %s", err)
+		return
+	}
+}
+
+// Perform the following tasks:
+// . Search for another DHCP server running
+// . Check if a static IP is configured for the network interface
+// Respond with results
+func (s *Server) handleDHCPFindActiveServer(w http.ResponseWriter, r *http.Request) {
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		errorText := fmt.Sprintf("failed to read request body: %s", err)
+		log.Error(errorText)
+		http.Error(w, errorText, http.StatusBadRequest)
+		return
+	}
+
+	interfaceName := strings.TrimSpace(string(body))
+	if interfaceName == "" {
+		errorText := fmt.Sprintf("empty interface name specified")
+		log.Error(errorText)
+		http.Error(w, errorText, http.StatusBadRequest)
+		return
+	}
+
+	found, err := CheckIfOtherDHCPServersPresent(interfaceName)
+
+	othSrv := map[string]interface{}{}
+	foundVal := "no"
+	if found {
+		foundVal = "yes"
+	} else if err != nil {
+		foundVal = "error"
+		othSrv["error"] = err.Error()
+	}
+	othSrv["found"] = foundVal
+
+	staticIP := map[string]interface{}{}
+	isStaticIP, err := hasStaticIP(interfaceName)
+	staticIPStatus := "yes"
+	if err != nil {
+		staticIPStatus = "error"
+		staticIP["error"] = err.Error()
+	} else if !isStaticIP {
+		staticIPStatus = "no"
+		staticIP["ip"] = getFullIP(interfaceName)
+	}
+	staticIP["static"] = staticIPStatus
+
+	result := map[string]interface{}{}
+	result["other_server"] = othSrv
+	result["static_ip"] = staticIP
+
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(result)
+	if err != nil {
+		httpError(r, w, http.StatusInternalServerError, "Failed to marshal DHCP found json: %s", err)
+		return
+	}
+}
+
+// Check if network interface has a static IP configured
+func hasStaticIP(ifaceName string) (bool, error) {
+	if runtime.GOOS == "windows" {
+		return false, errors.New("Can't detect static IP: not supported on Windows")
+	}
+
+	body, err := ioutil.ReadFile("/etc/dhcpcd.conf")
+	if err != nil {
+		return false, err
+	}
+	lines := strings.Split(string(body), "\n")
+	nameLine := fmt.Sprintf("interface %s", ifaceName)
+	withinInterfaceCtx := false
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+
+		if withinInterfaceCtx && len(line) == 0 {
+			// an empty line resets our state
+			withinInterfaceCtx = false
+		}
+
+		if len(line) == 0 || line[0] == '#' {
+			continue
+		}
+		line = strings.TrimSpace(line)
+
+		if !withinInterfaceCtx {
+			if line == nameLine {
+				// we found our interface
+				withinInterfaceCtx = true
+			}
+
+		} else {
+			if strings.HasPrefix(line, "interface ") {
+				// we found another interface - reset our state
+				withinInterfaceCtx = false
+				continue
+			}
+			if strings.HasPrefix(line, "static ip_address=") {
+				return true, nil
+			}
+		}
+	}
+
+	return false, nil
+}
+
+// Get IP address with netmask
+func getFullIP(ifaceName string) string {
+	cmd := exec.Command("ip", "-oneline", "-family", "inet", "address", "show", ifaceName)
+	log.Tracef("executing %s %v", cmd.Path, cmd.Args)
+	d, err := cmd.Output()
+	if err != nil || cmd.ProcessState.ExitCode() != 0 {
+		return ""
+	}
+
+	fields := strings.Fields(string(d))
+	if len(fields) < 4 {
+		return ""
+	}
+	_, _, err = net.ParseCIDR(fields[3])
+	if err != nil {
+		return ""
+	}
+
+	return fields[3]
+}
+
+// Get gateway IP address
+func getGatewayIP(ifaceName string) string {
+	cmd := exec.Command("ip", "route", "show", "dev", ifaceName)
+	log.Tracef("executing %s %v", cmd.Path, cmd.Args)
+	d, err := cmd.Output()
+	if err != nil || cmd.ProcessState.ExitCode() != 0 {
+		return ""
+	}
+
+	fields := strings.Fields(string(d))
+	if len(fields) < 3 || fields[0] != "default" {
+		return ""
+	}
+
+	ip := net.ParseIP(fields[2])
+	if ip == nil {
+		return ""
+	}
+
+	return fields[2]
+}
+
+// Set a static IP for network interface
+func setStaticIP(ifaceName string) error {
+	ip := getFullIP(ifaceName)
+	if len(ip) == 0 {
+		return errors.New("Can't get IP address")
+	}
+
+	body, err := ioutil.ReadFile("/etc/dhcpcd.conf")
+	if err != nil {
+		return err
+	}
+
+	ip4, _, err := net.ParseCIDR(ip)
+	if err != nil {
+		return err
+	}
+
+	add := fmt.Sprintf("\ninterface %s\nstatic ip_address=%s\n",
+		ifaceName, ip)
+	body = append(body, []byte(add)...)
+
+	gatewayIP := getGatewayIP(ifaceName)
+	if len(gatewayIP) != 0 {
+		add = fmt.Sprintf("static routers=%s\n",
+			gatewayIP)
+		body = append(body, []byte(add)...)
+	}
+
+	add = fmt.Sprintf("static domain_name_servers=%s\n\n",
+		ip4)
+	body = append(body, []byte(add)...)
+
+	err = file.SafeWrite("/etc/dhcpcd.conf", body)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Server) handleDHCPAddStaticLease(w http.ResponseWriter, r *http.Request) {
+
+	lj := staticLeaseJSON{}
+	err := json.NewDecoder(r.Body).Decode(&lj)
+	if err != nil {
+		httpError(r, w, http.StatusBadRequest, "json.Decode: %s", err)
+		return
+	}
+
+	ip, _ := parseIPv4(lj.IP)
+	if ip == nil {
+		httpError(r, w, http.StatusBadRequest, "invalid IP")
+		return
+	}
+
+	mac, _ := net.ParseMAC(lj.HWAddr)
+
+	lease := Lease{
+		IP:       ip,
+		HWAddr:   mac,
+		Hostname: lj.Hostname,
+	}
+	err = s.AddStaticLease(lease)
+	if err != nil {
+		httpError(r, w, http.StatusBadRequest, "%s", err)
+		return
+	}
+}
+
+func (s *Server) handleDHCPRemoveStaticLease(w http.ResponseWriter, r *http.Request) {
+
+	lj := staticLeaseJSON{}
+	err := json.NewDecoder(r.Body).Decode(&lj)
+	if err != nil {
+		httpError(r, w, http.StatusBadRequest, "json.Decode: %s", err)
+		return
+	}
+
+	ip, _ := parseIPv4(lj.IP)
+	if ip == nil {
+		httpError(r, w, http.StatusBadRequest, "invalid IP")
+		return
+	}
+
+	mac, _ := net.ParseMAC(lj.HWAddr)
+
+	lease := Lease{
+		IP:       ip,
+		HWAddr:   mac,
+		Hostname: lj.Hostname,
+	}
+	err = s.RemoveStaticLease(lease)
+	if err != nil {
+		httpError(r, w, http.StatusBadRequest, "%s", err)
+		return
+	}
+}
+
+func (s *Server) registerHandlers() {
+	s.conf.HTTPRegister("GET", "/control/dhcp/status", s.handleDHCPStatus)
+	s.conf.HTTPRegister("GET", "/control/dhcp/interfaces", s.handleDHCPInterfaces)
+	s.conf.HTTPRegister("POST", "/control/dhcp/set_config", s.handleDHCPSetConfig)
+	s.conf.HTTPRegister("POST", "/control/dhcp/find_active_dhcp", s.handleDHCPFindActiveServer)
+	s.conf.HTTPRegister("POST", "/control/dhcp/add_static_lease", s.handleDHCPAddStaticLease)
+	s.conf.HTTPRegister("POST", "/control/dhcp/remove_static_lease", s.handleDHCPRemoveStaticLease)
+}

dhcpd/dhcpd.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"fmt"
 	"net"
+	"net/http"
 	"path/filepath"
 	"strings"
 	"sync"
@@ -45,6 +46,12 @@ type ServerConfig struct {
 	// IP conflict detector: time (ms) to wait for ICMP reply.
 	// 0: disable
 	ICMPTimeout uint `json:"icmp_timeout_msec" yaml:"icmp_timeout_msec"`
+
+	// Called when the configuration is changed by HTTP request
+	ConfigModified func() `json:"-" yaml:"-"`
+
+	// Register an HTTP handler
+	HTTPRegister func(string, string, func(http.ResponseWriter, *http.Request)) `json:"-" yaml:"-"`
 }
 
 // Server - the current state of the DHCP server
@@ -92,6 +99,9 @@ func (s *Server) CheckConfig(config ServerConfig) error {
 func Create(config ServerConfig) *Server {
 	s := Server{}
 	s.conf = config
+	if s.conf.HTTPRegister != nil {
+		s.registerHandlers()
+	}
 	return &s
 }
 
@@ -111,9 +121,6 @@ func (s *Server) WriteDiskConfig(c *ServerConfig) {
 }
 
 func (s *Server) setConfig(config ServerConfig) error {
-	s.conf = config
-	s.conf.DBFilePath = filepath.Join(config.WorkDir, dbFilename)
-
 	iface, err := net.InterfaceByName(config.InterfaceName)
 	if err != nil {
 		printInterfaces()
@@ -165,6 +172,12 @@ func (s *Server) setConfig(config ServerConfig) error {
 		dhcp4.OptionDomainNameServer: s.ipnet.IP,
 	}
 
+	oldconf := s.conf
+	s.conf = config
+	s.conf.WorkDir = oldconf.WorkDir
+	s.conf.HTTPRegister = oldconf.HTTPRegister
+	s.conf.ConfigModified = oldconf.ConfigModified
+	s.conf.DBFilePath = filepath.Join(config.WorkDir, dbFilename)
 	return nil
 }
 

home/control.go

@@ -424,12 +424,6 @@ func registerControlHandlers() {
 	httpRegister(http.MethodGet, "/control/i18n/current_language", handleI18nCurrentLanguage)
 	http.HandleFunc("/control/version.json", postInstall(optionalAuth(handleGetVersionJSON)))
 	httpRegister(http.MethodPost, "/control/update", handleUpdate)
-	httpRegister(http.MethodGet, "/control/dhcp/status", handleDHCPStatus)
-	httpRegister(http.MethodGet, "/control/dhcp/interfaces", handleDHCPInterfaces)
-	httpRegister(http.MethodPost, "/control/dhcp/set_config", handleDHCPSetConfig)
-	httpRegister(http.MethodPost, "/control/dhcp/find_active_dhcp", handleDHCPFindActiveServer)
-	httpRegister(http.MethodPost, "/control/dhcp/add_static_lease", handleDHCPAddStaticLease)
-	httpRegister(http.MethodPost, "/control/dhcp/remove_static_lease", handleDHCPRemoveStaticLease)
 
 	httpRegister(http.MethodGet, "/control/access/list", handleAccessList)
 	httpRegister(http.MethodPost, "/control/access/set", handleAccessSet)

home/dhcp.go

@@ -1,426 +1,9 @@
 package home
 
 import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"os/exec"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/AdguardTeam/AdGuardHome/dhcpd"
-	"github.com/AdguardTeam/golibs/file"
-	"github.com/AdguardTeam/golibs/log"
 	"github.com/joomcode/errorx"
 )
 
-// []dhcpd.Lease -> JSON
-func convertLeases(inputLeases []dhcpd.Lease, includeExpires bool) []map[string]string {
-	leases := []map[string]string{}
-	for _, l := range inputLeases {
-		lease := map[string]string{
-			"mac":      l.HWAddr.String(),
-			"ip":       l.IP.String(),
-			"hostname": l.Hostname,
-		}
-
-		if includeExpires {
-			lease["expires"] = l.Expiry.Format(time.RFC3339)
-		}
-
-		leases = append(leases, lease)
-	}
-	return leases
-}
-
-func handleDHCPStatus(w http.ResponseWriter, r *http.Request) {
-	leases := convertLeases(config.dhcpServer.Leases(), true)
-	staticLeases := convertLeases(config.dhcpServer.StaticLeases(), false)
-	status := map[string]interface{}{
-		"config":        config.DHCP,
-		"leases":        leases,
-		"static_leases": staticLeases,
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	err := json.NewEncoder(w).Encode(status)
-	if err != nil {
-		httpError(w, http.StatusInternalServerError, "Unable to marshal DHCP status json: %s", err)
-		return
-	}
-}
-
-type leaseJSON struct {
-	HWAddr   string `json:"mac"`
-	IP       string `json:"ip"`
-	Hostname string `json:"hostname"`
-}
-
-type dhcpServerConfigJSON struct {
-	dhcpd.ServerConfig `json:",inline"`
-	StaticLeases       []leaseJSON `json:"static_leases"`
-}
-
-func handleDHCPSetConfig(w http.ResponseWriter, r *http.Request) {
-	newconfig := dhcpServerConfigJSON{}
-	err := json.NewDecoder(r.Body).Decode(&newconfig)
-	if err != nil {
-		httpError(w, http.StatusBadRequest, "Failed to parse new DHCP config json: %s", err)
-		return
-	}
-
-	newconfig.ServerConfig.WorkDir = config.ourWorkingDir
-	err = config.dhcpServer.CheckConfig(newconfig.ServerConfig)
-	if err != nil {
-		httpError(w, http.StatusBadRequest, "Invalid DHCP configuration: %s", err)
-		return
-	}
-
-	err = config.dhcpServer.Stop()
-	if err != nil {
-		log.Error("failed to stop the DHCP server: %s", err)
-	}
-
-	err = config.dhcpServer.Init(newconfig.ServerConfig)
-	if err != nil {
-		httpError(w, http.StatusBadRequest, "Invalid DHCP configuration: %s", err)
-		return
-	}
-
-	if newconfig.Enabled {
-
-		staticIP, err := hasStaticIP(newconfig.InterfaceName)
-		if !staticIP && err == nil {
-			err = setStaticIP(newconfig.InterfaceName)
-			if err != nil {
-				httpError(w, http.StatusInternalServerError, "Failed to configure static IP: %s", err)
-				return
-			}
-		}
-
-		err = config.dhcpServer.Start()
-		if err != nil {
-			httpError(w, http.StatusBadRequest, "Failed to start DHCP server: %s", err)
-			return
-		}
-	}
-
-	config.DHCP = newconfig.ServerConfig
-	httpUpdateConfigReloadDNSReturnOK(w, r)
-}
-
-func handleDHCPInterfaces(w http.ResponseWriter, r *http.Request) {
-	response := map[string]interface{}{}
-
-	ifaces, err := getValidNetInterfaces()
-	if err != nil {
-		httpError(w, http.StatusInternalServerError, "Couldn't get interfaces: %s", err)
-		return
-	}
-
-	for _, iface := range ifaces {
-		if iface.Flags&net.FlagLoopback != 0 {
-			// it's a loopback, skip it
-			continue
-		}
-		if iface.Flags&net.FlagBroadcast == 0 {
-			// this interface doesn't support broadcast, skip it
-			continue
-		}
-		addrs, err := iface.Addrs()
-		if err != nil {
-			httpError(w, http.StatusInternalServerError, "Failed to get addresses for interface %s: %s", iface.Name, err)
-			return
-		}
-
-		jsonIface := netInterface{
-			Name:         iface.Name,
-			MTU:          iface.MTU,
-			HardwareAddr: iface.HardwareAddr.String(),
-		}
-
-		if iface.Flags != 0 {
-			jsonIface.Flags = iface.Flags.String()
-		}
-		// we don't want link-local addresses in json, so skip them
-		for _, addr := range addrs {
-			ipnet, ok := addr.(*net.IPNet)
-			if !ok {
-				// not an IPNet, should not happen
-				httpError(w, http.StatusInternalServerError, "SHOULD NOT HAPPEN: got iface.Addrs() element %s that is not net.IPNet, it is %T", addr, addr)
-				return
-			}
-			// ignore link-local
-			if ipnet.IP.IsLinkLocalUnicast() {
-				continue
-			}
-			jsonIface.Addresses = append(jsonIface.Addresses, ipnet.IP.String())
-		}
-		if len(jsonIface.Addresses) != 0 {
-			response[iface.Name] = jsonIface
-		}
-
-	}
-
-	err = json.NewEncoder(w).Encode(response)
-	if err != nil {
-		httpError(w, http.StatusInternalServerError, "Failed to marshal json with available interfaces: %s", err)
-		return
-	}
-}
-
-// Perform the following tasks:
-// . Search for another DHCP server running
-// . Check if a static IP is configured for the network interface
-// Respond with results
-func handleDHCPFindActiveServer(w http.ResponseWriter, r *http.Request) {
-	body, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		errorText := fmt.Sprintf("failed to read request body: %s", err)
-		log.Error(errorText)
-		http.Error(w, errorText, http.StatusBadRequest)
-		return
-	}
-
-	interfaceName := strings.TrimSpace(string(body))
-	if interfaceName == "" {
-		errorText := fmt.Sprintf("empty interface name specified")
-		log.Error(errorText)
-		http.Error(w, errorText, http.StatusBadRequest)
-		return
-	}
-
-	found, err := dhcpd.CheckIfOtherDHCPServersPresent(interfaceName)
-
-	othSrv := map[string]interface{}{}
-	foundVal := "no"
-	if found {
-		foundVal = "yes"
-	} else if err != nil {
-		foundVal = "error"
-		othSrv["error"] = err.Error()
-	}
-	othSrv["found"] = foundVal
-
-	staticIP := map[string]interface{}{}
-	isStaticIP, err := hasStaticIP(interfaceName)
-	staticIPStatus := "yes"
-	if err != nil {
-		staticIPStatus = "error"
-		staticIP["error"] = err.Error()
-	} else if !isStaticIP {
-		staticIPStatus = "no"
-		staticIP["ip"] = getFullIP(interfaceName)
-	}
-	staticIP["static"] = staticIPStatus
-
-	result := map[string]interface{}{}
-	result["other_server"] = othSrv
-	result["static_ip"] = staticIP
-
-	w.Header().Set("Content-Type", "application/json")
-	err = json.NewEncoder(w).Encode(result)
-	if err != nil {
-		httpError(w, http.StatusInternalServerError, "Failed to marshal DHCP found json: %s", err)
-		return
-	}
-}
-
-// Check if network interface has a static IP configured
-func hasStaticIP(ifaceName string) (bool, error) {
-	if runtime.GOOS == "windows" {
-		return false, errors.New("Can't detect static IP: not supported on Windows")
-	}
-
-	body, err := ioutil.ReadFile("/etc/dhcpcd.conf")
-	if err != nil {
-		return false, err
-	}
-	lines := strings.Split(string(body), "\n")
-	nameLine := fmt.Sprintf("interface %s", ifaceName)
-	withinInterfaceCtx := false
-
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-
-		if withinInterfaceCtx && len(line) == 0 {
-			// an empty line resets our state
-			withinInterfaceCtx = false
-		}
-
-		if len(line) == 0 || line[0] == '#' {
-			continue
-		}
-		line = strings.TrimSpace(line)
-
-		if !withinInterfaceCtx {
-			if line == nameLine {
-				// we found our interface
-				withinInterfaceCtx = true
-			}
-
-		} else {
-			if strings.HasPrefix(line, "interface ") {
-				// we found another interface - reset our state
-				withinInterfaceCtx = false
-				continue
-			}
-			if strings.HasPrefix(line, "static ip_address=") {
-				return true, nil
-			}
-		}
-	}
-
-	return false, nil
-}
-
-// Get IP address with netmask
-func getFullIP(ifaceName string) string {
-	cmd := exec.Command("ip", "-oneline", "-family", "inet", "address", "show", ifaceName)
-	log.Tracef("executing %s %v", cmd.Path, cmd.Args)
-	d, err := cmd.Output()
-	if err != nil || cmd.ProcessState.ExitCode() != 0 {
-		return ""
-	}
-
-	fields := strings.Fields(string(d))
-	if len(fields) < 4 {
-		return ""
-	}
-	_, _, err = net.ParseCIDR(fields[3])
-	if err != nil {
-		return ""
-	}
-
-	return fields[3]
-}
-
-// Get gateway IP address
-func getGatewayIP(ifaceName string) string {
-	cmd := exec.Command("ip", "route", "show", "dev", ifaceName)
-	log.Tracef("executing %s %v", cmd.Path, cmd.Args)
-	d, err := cmd.Output()
-	if err != nil || cmd.ProcessState.ExitCode() != 0 {
-		return ""
-	}
-
-	fields := strings.Fields(string(d))
-	if len(fields) < 3 || fields[0] != "default" {
-		return ""
-	}
-
-	ip := net.ParseIP(fields[2])
-	if ip == nil {
-		return ""
-	}
-
-	return fields[2]
-}
-
-// Set a static IP for network interface
-func setStaticIP(ifaceName string) error {
-	ip := getFullIP(ifaceName)
-	if len(ip) == 0 {
-		return errors.New("Can't get IP address")
-	}
-
-	body, err := ioutil.ReadFile("/etc/dhcpcd.conf")
-	if err != nil {
-		return err
-	}
-
-	ip4, _, err := net.ParseCIDR(ip)
-	if err != nil {
-		return err
-	}
-
-	add := fmt.Sprintf("\ninterface %s\nstatic ip_address=%s\n",
-		ifaceName, ip)
-	body = append(body, []byte(add)...)
-
-	gatewayIP := getGatewayIP(ifaceName)
-	if len(gatewayIP) != 0 {
-		add = fmt.Sprintf("static routers=%s\n",
-			gatewayIP)
-		body = append(body, []byte(add)...)
-	}
-
-	add = fmt.Sprintf("static domain_name_servers=%s\n\n",
-		ip4)
-	body = append(body, []byte(add)...)
-
-	err = file.SafeWrite("/etc/dhcpcd.conf", body)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func handleDHCPAddStaticLease(w http.ResponseWriter, r *http.Request) {
-
-	lj := leaseJSON{}
-	err := json.NewDecoder(r.Body).Decode(&lj)
-	if err != nil {
-		httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
-		return
-	}
-
-	ip := parseIPv4(lj.IP)
-	if ip == nil {
-		httpError(w, http.StatusBadRequest, "invalid IP")
-		return
-	}
-
-	mac, _ := net.ParseMAC(lj.HWAddr)
-
-	lease := dhcpd.Lease{
-		IP:       ip,
-		HWAddr:   mac,
-		Hostname: lj.Hostname,
-	}
-	err = config.dhcpServer.AddStaticLease(lease)
-	if err != nil {
-		httpError(w, http.StatusBadRequest, "%s", err)
-		return
-	}
-	returnOK(w)
-}
-
-func handleDHCPRemoveStaticLease(w http.ResponseWriter, r *http.Request) {
-
-	lj := leaseJSON{}
-	err := json.NewDecoder(r.Body).Decode(&lj)
-	if err != nil {
-		httpError(w, http.StatusBadRequest, "json.Decode: %s", err)
-		return
-	}
-
-	ip := parseIPv4(lj.IP)
-	if ip == nil {
-		httpError(w, http.StatusBadRequest, "invalid IP")
-		return
-	}
-
-	mac, _ := net.ParseMAC(lj.HWAddr)
-
-	lease := dhcpd.Lease{
-		IP:       ip,
-		HWAddr:   mac,
-		Hostname: lj.Hostname,
-	}
-	err = config.dhcpServer.RemoveStaticLease(lease)
-	if err != nil {
-		httpError(w, http.StatusBadRequest, "%s", err)
-		return
-	}
-	returnOK(w)
-}
-
 func startDHCPServer() error {
 	if !config.DHCP.Enabled {
 		// not enabled, don't do anything

home/helpers.go

@@ -1,7 +1,6 @@
 package home
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -338,21 +337,6 @@ func _Func() string {
 	return path.Base(f.Name())
 }
 
-// Parse input string and return IPv4 address
-func parseIPv4(s string) net.IP {
-	ip := net.ParseIP(s)
-	if ip == nil {
-		return nil
-	}
-
-	v4InV6Prefix := []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}
-	if !bytes.Equal(ip[0:12], v4InV6Prefix) {
-		return nil
-	}
-
-	return ip.To4()
-}
-
 // SplitNext - split string by a byte and return the first chunk
 // Whitespace is trimmed
 func SplitNext(str *string, splitBy byte) string {

home/home.go

@@ -119,6 +119,9 @@ func run(args options) {
 		}
 	}
 
+	config.DHCP.WorkDir = config.ourWorkingDir
+	config.DHCP.HTTPRegister = httpRegister
+	config.DHCP.ConfigModified = onConfigModified
 	config.dhcpServer = dhcpd.Create(config.DHCP)
 	config.clients.Init(config.Clients, config.dhcpServer)
 	config.Clients = nil