mirror of
https://github.com/AdguardTeam/AdGuardHome.git
synced 2024-12-17 13:11:42 +03:00
2313eda123
Merge in DNS/adguard-home from 2302-static-ip to master Closes #2302. Squashed commit of the following: commit e62b7b033861f1c55f0d06811ca005b3934ddc5b Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 19:38:15 2020 +0300 all: format changelog commit 4127aa7630674ddcfe84f712e6c7c8d06b1cab9a Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 19:24:53 2020 +0300 all: fix changelog typo commit f8a432056d3682facae0cdec99d7d80a5c2bd9b5 Merge: b809a866ee4383189a
Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 19:22:27 2020 +0300 Merge branch 'master' into 2302-static-ip commit b809a866e49147354f9c6952b2f958b6b56ad873 Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 19:20:05 2020 +0300 all: log changes commit 248c35ba411af731d6eae755a901cdbc77980628 Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 18:57:15 2020 +0300 sysutil: use bufio.Scanner commit 0dc19dd5c232fbe9552a2b0d846e048274d73a74 Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 17:26:18 2020 +0300 sysutil: fix linux tests commit 91202d6763595cff187040516dd1db10a20762b7 Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 17:15:29 2020 +0300 sysutil: fix linux files commit 40fbdbb95876322ebaeef1cbdaa8e3299b83ca7e Merge: d9a43ffb69b963fc77
Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 16:52:35 2020 +0300 Merge branch 'master' into 2302-static-ip commit d9a43ffb68a2ddbbcf185b69fc75aed139cd6919 Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 16:49:22 2020 +0300 sysutil: add main test commit bfef89186035ab0423d23246d46511584c26534c Author: Eugene Burkov <e.burkov@adguard.com> Date: Mon Dec 7 16:21:59 2020 +0300 sysutil: improve code quality commit a5f57a373f736971fdeb0c03371da7c8138b3a82 Author: Eugene Burkov <e.burkov@adguard.com> Date: Fri Dec 4 14:14:08 2020 +0300 all: move system functionality from dhcpd package to sysutil. commit 020b51864f85a39ca80e2b4e06faeb47cf318e11 Merge: 967e111a6ab8defdb0
Author: Eugene Burkov <e.burkov@adguard.com> Date: Wed Dec 2 14:53:43 2020 +0300 Merge branch 'master' into 2302-static-ip commit 967e111a663c18b5f4a87f3ae38d076f3ab6c200 Author: Eugene Burkov <e.burkov@adguard.com> Date: Wed Dec 2 13:52:17 2020 +0300 all: improve code quality
379 lines
10 KiB
Go
379 lines
10 KiB
Go
package home
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strconv"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/util"
|
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/sysutil"
|
|
|
|
"github.com/AdguardTeam/golibs/log"
|
|
)
|
|
|
|
type firstRunData struct {
|
|
WebPort int `json:"web_port"`
|
|
DNSPort int `json:"dns_port"`
|
|
Interfaces map[string]interface{} `json:"interfaces"`
|
|
}
|
|
|
|
type netInterfaceJSON struct {
|
|
Name string `json:"name"`
|
|
MTU int `json:"mtu"`
|
|
HardwareAddr string `json:"hardware_address"`
|
|
Addresses []string `json:"ip_addresses"`
|
|
Flags string `json:"flags"`
|
|
}
|
|
|
|
// Get initial installation settings
|
|
func (web *Web) handleInstallGetAddresses(w http.ResponseWriter, r *http.Request) {
|
|
data := firstRunData{}
|
|
data.WebPort = 80
|
|
data.DNSPort = 53
|
|
|
|
ifaces, err := util.GetValidNetInterfacesForWeb()
|
|
if err != nil {
|
|
httpError(w, http.StatusInternalServerError, "Couldn't get interfaces: %s", err)
|
|
return
|
|
}
|
|
|
|
data.Interfaces = make(map[string]interface{})
|
|
for _, iface := range ifaces {
|
|
ifaceJSON := netInterfaceJSON{
|
|
Name: iface.Name,
|
|
MTU: iface.MTU,
|
|
HardwareAddr: iface.HardwareAddr,
|
|
Addresses: iface.Addresses,
|
|
Flags: iface.Flags,
|
|
}
|
|
data.Interfaces[iface.Name] = ifaceJSON
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
err = json.NewEncoder(w).Encode(data)
|
|
if err != nil {
|
|
httpError(w, http.StatusInternalServerError, "Unable to marshal default addresses to json: %s", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
type checkConfigReqEnt struct {
|
|
Port int `json:"port"`
|
|
IP string `json:"ip"`
|
|
Autofix bool `json:"autofix"`
|
|
}
|
|
|
|
type checkConfigReq struct {
|
|
Web checkConfigReqEnt `json:"web"`
|
|
DNS checkConfigReqEnt `json:"dns"`
|
|
SetStaticIP bool `json:"set_static_ip"`
|
|
}
|
|
|
|
type checkConfigRespEnt struct {
|
|
Status string `json:"status"`
|
|
CanAutofix bool `json:"can_autofix"`
|
|
}
|
|
|
|
type staticIPJSON struct {
|
|
Static string `json:"static"`
|
|
IP string `json:"ip"`
|
|
Error string `json:"error"`
|
|
}
|
|
|
|
type checkConfigResp struct {
|
|
Web checkConfigRespEnt `json:"web"`
|
|
DNS checkConfigRespEnt `json:"dns"`
|
|
StaticIP staticIPJSON `json:"static_ip"`
|
|
}
|
|
|
|
// Check if ports are available, respond with results
|
|
func (web *Web) handleInstallCheckConfig(w http.ResponseWriter, r *http.Request) {
|
|
reqData := checkConfigReq{}
|
|
respData := checkConfigResp{}
|
|
err := json.NewDecoder(r.Body).Decode(&reqData)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "Failed to parse 'check_config' JSON data: %s", err)
|
|
return
|
|
}
|
|
|
|
if reqData.Web.Port != 0 && reqData.Web.Port != config.BindPort {
|
|
err = util.CheckPortAvailable(reqData.Web.IP, reqData.Web.Port)
|
|
if err != nil {
|
|
respData.Web.Status = fmt.Sprintf("%v", err)
|
|
}
|
|
}
|
|
|
|
if reqData.DNS.Port != 0 {
|
|
err = util.CheckPacketPortAvailable(reqData.DNS.IP, reqData.DNS.Port)
|
|
|
|
if util.ErrorIsAddrInUse(err) {
|
|
canAutofix := checkDNSStubListener()
|
|
if canAutofix && reqData.DNS.Autofix {
|
|
|
|
err = disableDNSStubListener()
|
|
if err != nil {
|
|
log.Error("Couldn't disable DNSStubListener: %s", err)
|
|
}
|
|
|
|
err = util.CheckPacketPortAvailable(reqData.DNS.IP, reqData.DNS.Port)
|
|
canAutofix = false
|
|
}
|
|
|
|
respData.DNS.CanAutofix = canAutofix
|
|
}
|
|
|
|
if err == nil {
|
|
err = util.CheckPortAvailable(reqData.DNS.IP, reqData.DNS.Port)
|
|
}
|
|
|
|
if err != nil {
|
|
respData.DNS.Status = fmt.Sprintf("%v", err)
|
|
} else if reqData.DNS.IP != "0.0.0.0" {
|
|
respData.StaticIP = handleStaticIP(reqData.DNS.IP, reqData.SetStaticIP)
|
|
}
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
err = json.NewEncoder(w).Encode(respData)
|
|
if err != nil {
|
|
httpError(w, http.StatusInternalServerError, "Unable to marshal JSON: %s", err)
|
|
return
|
|
}
|
|
}
|
|
|
|
// handleStaticIP - handles static IP request
|
|
// It either checks if we have a static IP
|
|
// Or if set=true, it tries to set it
|
|
func handleStaticIP(ip string, set bool) staticIPJSON {
|
|
resp := staticIPJSON{}
|
|
|
|
interfaceName := util.GetInterfaceByIP(ip)
|
|
resp.Static = "no"
|
|
|
|
if len(interfaceName) == 0 {
|
|
resp.Static = "error"
|
|
resp.Error = fmt.Sprintf("Couldn't find network interface by IP %s", ip)
|
|
return resp
|
|
}
|
|
|
|
if set {
|
|
// Try to set static IP for the specified interface
|
|
err := sysutil.IfaceSetStaticIP(interfaceName)
|
|
if err != nil {
|
|
resp.Static = "error"
|
|
resp.Error = err.Error()
|
|
return resp
|
|
}
|
|
}
|
|
|
|
// Fallthrough here even if we set static IP
|
|
// Check if we have a static IP and return the details
|
|
isStaticIP, err := sysutil.IfaceHasStaticIP(interfaceName)
|
|
if err != nil {
|
|
resp.Static = "error"
|
|
resp.Error = err.Error()
|
|
} else {
|
|
if isStaticIP {
|
|
resp.Static = "yes"
|
|
}
|
|
resp.IP = util.GetSubnet(interfaceName)
|
|
}
|
|
return resp
|
|
}
|
|
|
|
// Check if DNSStubListener is active
|
|
func checkDNSStubListener() bool {
|
|
if runtime.GOOS != "linux" {
|
|
return false
|
|
}
|
|
|
|
cmd := exec.Command("systemctl", "is-enabled", "systemd-resolved")
|
|
log.Tracef("executing %s %v", cmd.Path, cmd.Args)
|
|
_, err := cmd.Output()
|
|
if err != nil || cmd.ProcessState.ExitCode() != 0 {
|
|
log.Info("command %s has failed: %v code:%d",
|
|
cmd.Path, err, cmd.ProcessState.ExitCode())
|
|
return false
|
|
}
|
|
|
|
cmd = exec.Command("grep", "-E", "#?DNSStubListener=yes", "/etc/systemd/resolved.conf")
|
|
log.Tracef("executing %s %v", cmd.Path, cmd.Args)
|
|
_, err = cmd.Output()
|
|
if err != nil || cmd.ProcessState.ExitCode() != 0 {
|
|
log.Info("command %s has failed: %v code:%d",
|
|
cmd.Path, err, cmd.ProcessState.ExitCode())
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
const (
|
|
resolvedConfPath = "/etc/systemd/resolved.conf.d/adguardhome.conf"
|
|
resolvedConfData = `[Resolve]
|
|
DNS=127.0.0.1
|
|
DNSStubListener=no
|
|
`
|
|
)
|
|
const resolvConfPath = "/etc/resolv.conf"
|
|
|
|
// Deactivate DNSStubListener
|
|
func disableDNSStubListener() error {
|
|
dir := filepath.Dir(resolvedConfPath)
|
|
err := os.MkdirAll(dir, 0o755)
|
|
if err != nil {
|
|
return fmt.Errorf("os.MkdirAll: %s: %w", dir, err)
|
|
}
|
|
|
|
err = ioutil.WriteFile(resolvedConfPath, []byte(resolvedConfData), 0o644)
|
|
if err != nil {
|
|
return fmt.Errorf("ioutil.WriteFile: %s: %w", resolvedConfPath, err)
|
|
}
|
|
|
|
_ = os.Rename(resolvConfPath, resolvConfPath+".backup")
|
|
err = os.Symlink("/run/systemd/resolve/resolv.conf", resolvConfPath)
|
|
if err != nil {
|
|
_ = os.Remove(resolvedConfPath) // remove the file we've just created
|
|
return fmt.Errorf("os.Symlink: %s: %w", resolvConfPath, err)
|
|
}
|
|
|
|
cmd := exec.Command("systemctl", "reload-or-restart", "systemd-resolved")
|
|
log.Tracef("executing %s %v", cmd.Path, cmd.Args)
|
|
_, err = cmd.Output()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if cmd.ProcessState.ExitCode() != 0 {
|
|
return fmt.Errorf("process %s exited with an error: %d",
|
|
cmd.Path, cmd.ProcessState.ExitCode())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type applyConfigReqEnt struct {
|
|
IP string `json:"ip"`
|
|
Port int `json:"port"`
|
|
}
|
|
|
|
type applyConfigReq struct {
|
|
Web applyConfigReqEnt `json:"web"`
|
|
DNS applyConfigReqEnt `json:"dns"`
|
|
Username string `json:"username"`
|
|
Password string `json:"password"`
|
|
}
|
|
|
|
// Copy installation parameters between two configuration objects
|
|
func copyInstallSettings(dst, src *configuration) {
|
|
dst.BindHost = src.BindHost
|
|
dst.BindPort = src.BindPort
|
|
dst.DNS.BindHost = src.DNS.BindHost
|
|
dst.DNS.Port = src.DNS.Port
|
|
}
|
|
|
|
// Apply new configuration, start DNS server, restart Web server
|
|
func (web *Web) handleInstallConfigure(w http.ResponseWriter, r *http.Request) {
|
|
newSettings := applyConfigReq{}
|
|
err := json.NewDecoder(r.Body).Decode(&newSettings)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "Failed to parse 'configure' JSON: %s", err)
|
|
return
|
|
}
|
|
|
|
if newSettings.Web.Port == 0 || newSettings.DNS.Port == 0 {
|
|
httpError(w, http.StatusBadRequest, "port value can't be 0")
|
|
return
|
|
}
|
|
|
|
restartHTTP := true
|
|
if config.BindHost == newSettings.Web.IP && config.BindPort == newSettings.Web.Port {
|
|
// no need to rebind
|
|
restartHTTP = false
|
|
}
|
|
|
|
// validate that hosts and ports are bindable
|
|
if restartHTTP {
|
|
err = util.CheckPortAvailable(newSettings.Web.IP, newSettings.Web.Port)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "Impossible to listen on IP:port %s due to %s",
|
|
net.JoinHostPort(newSettings.Web.IP, strconv.Itoa(newSettings.Web.Port)), err)
|
|
return
|
|
}
|
|
}
|
|
|
|
err = util.CheckPacketPortAvailable(newSettings.DNS.IP, newSettings.DNS.Port)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "%s", err)
|
|
return
|
|
}
|
|
|
|
err = util.CheckPortAvailable(newSettings.DNS.IP, newSettings.DNS.Port)
|
|
if err != nil {
|
|
httpError(w, http.StatusBadRequest, "%s", err)
|
|
return
|
|
}
|
|
|
|
var curConfig configuration
|
|
copyInstallSettings(&curConfig, &config)
|
|
|
|
Context.firstRun = false
|
|
config.BindHost = newSettings.Web.IP
|
|
config.BindPort = newSettings.Web.Port
|
|
config.DNS.BindHost = newSettings.DNS.IP
|
|
config.DNS.Port = newSettings.DNS.Port
|
|
|
|
err = StartMods()
|
|
if err != nil {
|
|
Context.firstRun = true
|
|
copyInstallSettings(&config, &curConfig)
|
|
httpError(w, http.StatusInternalServerError, "%s", err)
|
|
return
|
|
}
|
|
|
|
u := User{}
|
|
u.Name = newSettings.Username
|
|
Context.auth.UserAdd(&u, newSettings.Password)
|
|
|
|
err = config.write()
|
|
if err != nil {
|
|
Context.firstRun = true
|
|
copyInstallSettings(&config, &curConfig)
|
|
httpError(w, http.StatusInternalServerError, "Couldn't write config: %s", err)
|
|
return
|
|
}
|
|
|
|
web.conf.firstRun = false
|
|
web.conf.BindHost = newSettings.Web.IP
|
|
web.conf.BindPort = newSettings.Web.Port
|
|
|
|
registerControlHandlers()
|
|
|
|
returnOK(w)
|
|
if f, ok := w.(http.Flusher); ok {
|
|
f.Flush()
|
|
}
|
|
|
|
// this needs to be done in a goroutine because Shutdown() is a blocking call, and it will block
|
|
// until all requests are finished, and _we_ are inside a request right now, so it will block indefinitely
|
|
if restartHTTP {
|
|
go func() {
|
|
_ = Context.web.httpServer.Shutdown(context.TODO())
|
|
}()
|
|
}
|
|
}
|
|
|
|
func (web *Web) registerInstallHandlers() {
|
|
Context.mux.HandleFunc("/control/install/get_addresses", preInstall(ensureGET(web.handleInstallGetAddresses)))
|
|
Context.mux.HandleFunc("/control/install/check_config", preInstall(ensurePOST(web.handleInstallCheckConfig)))
|
|
Context.mux.HandleFunc("/control/install/configure", preInstall(ensurePOST(web.handleInstallConfigure)))
|
|
}
|