package dhcpd import ( "encoding/json" "fmt" "io/ioutil" "net" "net/http" "os" "strings" "time" "github.com/AdguardTeam/AdGuardHome/internal/util" "github.com/AdguardTeam/golibs/jsonutil" "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 } type v4ServerConfJSON struct { GatewayIP string `json:"gateway_ip"` SubnetMask string `json:"subnet_mask"` RangeStart string `json:"range_start"` RangeEnd string `json:"range_end"` LeaseDuration uint32 `json:"lease_duration"` } func v4ServerConfToJSON(c V4ServerConf) v4ServerConfJSON { return v4ServerConfJSON{ GatewayIP: c.GatewayIP, SubnetMask: c.SubnetMask, RangeStart: c.RangeStart, RangeEnd: c.RangeEnd, LeaseDuration: c.LeaseDuration, } } func v4JSONToServerConf(j v4ServerConfJSON) V4ServerConf { return V4ServerConf{ GatewayIP: j.GatewayIP, SubnetMask: j.SubnetMask, RangeStart: j.RangeStart, RangeEnd: j.RangeEnd, LeaseDuration: j.LeaseDuration, } } type v6ServerConfJSON struct { RangeStart string `json:"range_start"` LeaseDuration uint32 `json:"lease_duration"` } func v6ServerConfToJSON(c V6ServerConf) v6ServerConfJSON { return v6ServerConfJSON{ RangeStart: c.RangeStart, LeaseDuration: c.LeaseDuration, } } func v6JSONToServerConf(j v6ServerConfJSON) V6ServerConf { return V6ServerConf{ RangeStart: j.RangeStart, LeaseDuration: j.LeaseDuration, } } func (s *Server) handleDHCPStatus(w http.ResponseWriter, r *http.Request) { leases := convertLeases(s.Leases(LeasesDynamic), true) staticLeases := convertLeases(s.Leases(LeasesStatic), false) v4conf := V4ServerConf{} s.srv4.WriteDiskConfig4(&v4conf) v6conf := V6ServerConf{} s.srv6.WriteDiskConfig6(&v6conf) status := map[string]interface{}{ "enabled": s.conf.Enabled, "interface_name": s.conf.InterfaceName, "v4": v4ServerConfToJSON(v4conf), "v6": v6ServerConfToJSON(v6conf), "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 { Enabled bool `json:"enabled"` InterfaceName string `json:"interface_name"` V4 v4ServerConfJSON `json:"v4"` V6 v6ServerConfJSON `json:"v6"` } func (s *Server) handleDHCPSetConfig(w http.ResponseWriter, r *http.Request) { newconfig := dhcpServerConfigJSON{} newconfig.Enabled = s.conf.Enabled newconfig.InterfaceName = s.conf.InterfaceName js, err := jsonutil.DecodeObject(&newconfig, r.Body) if err != nil { httpError(r, w, http.StatusBadRequest, "Failed to parse new DHCP config json: %s", err) return } var s4 DHCPServer var s6 DHCPServer v4Enabled := false v6Enabled := false if js.Exists("v4") { v4conf := v4JSONToServerConf(newconfig.V4) v4conf.Enabled = newconfig.Enabled if len(v4conf.RangeStart) == 0 { v4conf.Enabled = false } v4Enabled = v4conf.Enabled v4conf.InterfaceName = newconfig.InterfaceName c4 := V4ServerConf{} s.srv4.WriteDiskConfig4(&c4) v4conf.notify = c4.notify v4conf.ICMPTimeout = c4.ICMPTimeout s4, err = v4Create(v4conf) if err != nil { httpError(r, w, http.StatusBadRequest, "Invalid DHCPv4 configuration: %s", err) return } } if js.Exists("v6") { v6conf := v6JSONToServerConf(newconfig.V6) v6conf.Enabled = newconfig.Enabled if len(v6conf.RangeStart) == 0 { v6conf.Enabled = false } v6Enabled = v6conf.Enabled v6conf.InterfaceName = newconfig.InterfaceName v6conf.notify = s.onNotify s6, err = v6Create(v6conf) if err != nil { httpError(r, w, http.StatusBadRequest, "Invalid DHCPv6 configuration: %s", err) return } } if newconfig.Enabled && !v4Enabled && !v6Enabled { httpError(r, w, http.StatusBadRequest, "DHCPv4 or DHCPv6 configuration must be complete") return } s.Stop() if js.Exists("enabled") { s.conf.Enabled = newconfig.Enabled } if js.Exists("interface_name") { s.conf.InterfaceName = newconfig.InterfaceName } if s4 != nil { s.srv4 = s4 } if s6 != nil { s.srv6 = s6 } s.conf.ConfigModified() s.dbLoad() if s.conf.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 netInterfaceJSON struct { Name string `json:"name"` GatewayIP string `json:"gateway_ip"` HardwareAddr string `json:"hardware_address"` Addrs4 []string `json:"ipv4_addresses"` Addrs6 []string `json:"ipv6_addresses"` Flags string `json:"flags"` } func (s *Server) handleDHCPInterfaces(w http.ResponseWriter, r *http.Request) { response := map[string]interface{}{} ifaces, err := util.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 := netInterfaceJSON{ Name: iface.Name, 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 } if ipnet.IP.To4() != nil { jsonIface.Addrs4 = append(jsonIface.Addrs4, ipnet.IP.String()) } else { jsonIface.Addrs6 = append(jsonIface.Addrs6, ipnet.IP.String()) } } if len(jsonIface.Addrs4)+len(jsonIface.Addrs6) != 0 { jsonIface.GatewayIP = getGatewayIP(iface.Name) 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) { // This use of ReadAll is safe, because request's body is now limited. body, err := ioutil.ReadAll(r.Body) if err != nil { msg := fmt.Sprintf("failed to read request body: %s", err) log.Error(msg) http.Error(w, msg, http.StatusBadRequest) return } interfaceName := strings.TrimSpace(string(body)) if interfaceName == "" { msg := "empty interface name specified" log.Error(msg) http.Error(w, msg, http.StatusBadRequest) return } found4, err4 := CheckIfOtherDHCPServersPresentV4(interfaceName) 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"] = util.GetSubnet(interfaceName) } staticIP["static"] = staticIPStatus v4 := map[string]interface{}{} othSrv := map[string]interface{}{} foundVal := "no" if found4 { foundVal = "yes" } else if err4 != nil { foundVal = "error" othSrv["error"] = err4.Error() } othSrv["found"] = foundVal v4["other_server"] = othSrv v4["static_ip"] = staticIP found6, err6 := CheckIfOtherDHCPServersPresentV6(interfaceName) v6 := map[string]interface{}{} othSrv = map[string]interface{}{} foundVal = "no" if found6 { foundVal = "yes" } else if err6 != nil { foundVal = "error" othSrv["error"] = err6.Error() } othSrv["found"] = foundVal v6["other_server"] = othSrv result := map[string]interface{}{} result["v4"] = v4 result["v6"] = v6 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 } } 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 := net.ParseIP(lj.IP) if ip != nil && ip.To4() == nil { mac, err := net.ParseMAC(lj.HWAddr) if err != nil { httpError(r, w, http.StatusBadRequest, "invalid MAC") return } lease := Lease{ IP: ip, HWAddr: mac, } err = s.srv6.AddStaticLease(lease) if err != nil { httpError(r, w, http.StatusBadRequest, "%s", err) return } return } ip, _ = parseIPv4(lj.IP) if ip == nil { httpError(r, w, http.StatusBadRequest, "invalid IP") return } mac, err := net.ParseMAC(lj.HWAddr) if err != nil { httpError(r, w, http.StatusBadRequest, "invalid MAC") return } lease := Lease{ IP: ip, HWAddr: mac, Hostname: lj.Hostname, } err = s.srv4.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 := net.ParseIP(lj.IP) if ip != nil && ip.To4() == nil { mac, err := net.ParseMAC(lj.HWAddr) if err != nil { httpError(r, w, http.StatusBadRequest, "invalid MAC") return } lease := Lease{ IP: ip, HWAddr: mac, } err = s.srv6.RemoveStaticLease(lease) if err != nil { httpError(r, w, http.StatusBadRequest, "%s", err) return } 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.srv4.RemoveStaticLease(lease) if err != nil { httpError(r, w, http.StatusBadRequest, "%s", err) return } } func (s *Server) handleReset(w http.ResponseWriter, r *http.Request) { s.Stop() err := os.Remove(s.conf.DBFilePath) if err != nil && !os.IsNotExist(err) { log.Error("DHCP: os.Remove: %s: %s", s.conf.DBFilePath, err) } oldconf := s.conf s.conf = ServerConfig{} s.conf.WorkDir = oldconf.WorkDir s.conf.HTTPRegister = oldconf.HTTPRegister s.conf.ConfigModified = oldconf.ConfigModified s.conf.DBFilePath = oldconf.DBFilePath v4conf := V4ServerConf{} v4conf.ICMPTimeout = 1000 v4conf.notify = s.onNotify s.srv4, _ = v4Create(v4conf) v6conf := V6ServerConf{} v6conf.notify = s.onNotify s.srv6, _ = v6Create(v6conf) s.conf.ConfigModified() } func (s *Server) registerHandlers() { s.conf.HTTPRegister(http.MethodGet, "/control/dhcp/status", s.handleDHCPStatus) s.conf.HTTPRegister(http.MethodGet, "/control/dhcp/interfaces", s.handleDHCPInterfaces) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/set_config", s.handleDHCPSetConfig) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/find_active_dhcp", s.handleDHCPFindActiveServer) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/add_static_lease", s.handleDHCPAddStaticLease) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/remove_static_lease", s.handleDHCPRemoveStaticLease) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/reset", s.handleReset) } // jsonError is a generic JSON error response. // // TODO(a.garipov): Merge together with the implementations in .../home and // other packages after refactoring the web handler registering. type jsonError struct { // Message is the error message, an opaque string. Message string `json:"message"` } // notImplemented returns a handler that replies to any request with an HTTP 501 // Not Implemented status and a JSON error with the provided message msg. // // TODO(a.garipov): Either take the logger from the server after we've // refactored logging or make this not a method of *Server. func (s *Server) notImplemented(msg string) (f func(http.ResponseWriter, *http.Request)) { return func(w http.ResponseWriter, _ *http.Request) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusNotImplemented) err := json.NewEncoder(w).Encode(&jsonError{ Message: msg, }) if err != nil { log.Debug("writing 501 json response: %s", err) } } } func (s *Server) registerNotImplementedHandlers() { h := s.notImplemented("dhcp is not supported on windows") s.conf.HTTPRegister(http.MethodGet, "/control/dhcp/status", h) s.conf.HTTPRegister(http.MethodGet, "/control/dhcp/interfaces", h) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/set_config", h) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/find_active_dhcp", h) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/add_static_lease", h) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/remove_static_lease", h) s.conf.HTTPRegister(http.MethodPost, "/control/dhcp/reset", h) }