2019-06-10 11:33:19 +03:00
|
|
|
package home
|
2019-04-23 11:48:30 +03:00
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"encoding/json"
|
|
|
|
"fmt"
|
2021-05-21 14:55:42 +03:00
|
|
|
"io"
|
2019-04-23 11:48:30 +03:00
|
|
|
"net/http"
|
2022-10-14 15:29:44 +03:00
|
|
|
"net/netip"
|
2019-12-16 15:48:11 +03:00
|
|
|
"os"
|
2019-04-23 11:48:30 +03:00
|
|
|
"os/exec"
|
2019-12-16 15:48:11 +03:00
|
|
|
"path/filepath"
|
2019-12-23 14:57:10 +03:00
|
|
|
"runtime"
|
2021-01-26 19:44:19 +03:00
|
|
|
"time"
|
2022-02-10 18:30:41 +03:00
|
|
|
"unicode/utf8"
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghalg"
|
2021-12-16 20:54:59 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
|
2021-03-16 19:42:15 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/aghnet"
|
2022-01-18 15:05:34 +03:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/version"
|
2021-09-13 16:00:36 +03:00
|
|
|
"github.com/AdguardTeam/golibs/errors"
|
2019-04-23 11:48:30 +03:00
|
|
|
"github.com/AdguardTeam/golibs/log"
|
2024-12-02 18:20:31 +03:00
|
|
|
"github.com/AdguardTeam/golibs/logutil/slogutil"
|
2023-02-08 13:39:04 +03:00
|
|
|
"github.com/quic-go/quic-go/http3"
|
2019-04-23 11:48:30 +03:00
|
|
|
)
|
|
|
|
|
2021-01-21 19:55:41 +03:00
|
|
|
// getAddrsResponse is the response for /install/get_addresses endpoint.
|
|
|
|
type getAddrsResponse struct {
|
2021-12-24 20:14:36 +03:00
|
|
|
Interfaces map[string]*aghnet.NetInterface `json:"interfaces"`
|
2022-01-18 15:05:34 +03:00
|
|
|
|
|
|
|
// Version is the version of AdGuard Home.
|
|
|
|
//
|
|
|
|
// TODO(a.garipov): In the new API, rename this endpoint to something more
|
|
|
|
// general, since there will be more information here than just network
|
|
|
|
// interfaces.
|
|
|
|
Version string `json:"version"`
|
|
|
|
|
|
|
|
WebPort int `json:"web_port"`
|
|
|
|
DNSPort int `json:"dns_port"`
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2021-01-21 19:55:41 +03:00
|
|
|
// handleInstallGetAddresses is the handler for /install/get_addresses endpoint.
|
2023-04-11 17:22:51 +03:00
|
|
|
func (web *webAPI) handleInstallGetAddresses(w http.ResponseWriter, r *http.Request) {
|
2021-12-24 20:14:36 +03:00
|
|
|
data := getAddrsResponse{
|
2022-01-18 15:05:34 +03:00
|
|
|
Version: version.Version(),
|
|
|
|
|
2023-10-05 15:26:19 +03:00
|
|
|
WebPort: int(defaultPortHTTP),
|
|
|
|
DNSPort: int(defaultPortDNS),
|
2021-12-24 20:14:36 +03:00
|
|
|
}
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2021-03-16 19:42:15 +03:00
|
|
|
ifaces, err := aghnet.GetValidNetInterfacesForWeb()
|
2019-04-23 11:48:30 +03:00
|
|
|
if err != nil {
|
2021-12-16 20:54:59 +03:00
|
|
|
aghhttp.Error(r, w, http.StatusInternalServerError, "Couldn't get interfaces: %s", err)
|
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-03-16 19:42:15 +03:00
|
|
|
data.Interfaces = make(map[string]*aghnet.NetInterface)
|
2019-04-23 11:48:30 +03:00
|
|
|
for _, iface := range ifaces {
|
2021-01-21 19:55:41 +03:00
|
|
|
data.Interfaces[iface.Name] = iface
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2023-08-29 20:03:40 +03:00
|
|
|
aghhttp.WriteJSONResponseOK(w, r, data)
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
type checkConfReqEnt struct {
|
2022-10-14 15:29:44 +03:00
|
|
|
IP netip.Addr `json:"ip"`
|
2023-10-05 15:26:19 +03:00
|
|
|
Port uint16 `json:"port"`
|
2022-10-14 15:29:44 +03:00
|
|
|
Autofix bool `json:"autofix"`
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
2020-11-05 15:20:57 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
type checkConfReq struct {
|
|
|
|
Web checkConfReqEnt `json:"web"`
|
|
|
|
DNS checkConfReqEnt `json:"dns"`
|
|
|
|
SetStaticIP bool `json:"set_static_ip"`
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
type checkConfRespEnt struct {
|
2019-04-23 11:48:30 +03:00
|
|
|
Status string `json:"status"`
|
|
|
|
CanAutofix bool `json:"can_autofix"`
|
|
|
|
}
|
2020-11-05 15:20:57 +03:00
|
|
|
|
2020-02-13 18:42:07 +03:00
|
|
|
type staticIPJSON struct {
|
|
|
|
Static string `json:"static"`
|
|
|
|
IP string `json:"ip"`
|
|
|
|
Error string `json:"error"`
|
|
|
|
}
|
2020-11-05 15:20:57 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
type checkConfResp struct {
|
|
|
|
StaticIP staticIPJSON `json:"static_ip"`
|
|
|
|
Web checkConfRespEnt `json:"web"`
|
|
|
|
DNS checkConfRespEnt `json:"dns"`
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
// validateWeb returns error is the web part if the initial configuration can't
|
|
|
|
// be set.
|
2022-08-03 14:36:18 +03:00
|
|
|
func (req *checkConfReq) validateWeb(tcpPorts aghalg.UniqChecker[tcpPort]) (err error) {
|
2022-01-19 20:45:50 +03:00
|
|
|
defer func() { err = errors.Annotate(err, "validating ports: %w") }()
|
2021-12-16 20:54:59 +03:00
|
|
|
|
2023-06-29 15:29:52 +03:00
|
|
|
// TODO(a.garipov): Declare all port variables anywhere as uint16.
|
2023-10-05 15:26:19 +03:00
|
|
|
reqPort := req.Web.Port
|
2023-06-29 15:29:52 +03:00
|
|
|
port := tcpPort(reqPort)
|
2023-01-23 12:47:59 +03:00
|
|
|
addPorts(tcpPorts, port)
|
2022-08-03 14:36:18 +03:00
|
|
|
if err = tcpPorts.Validate(); err != nil {
|
|
|
|
// Reset the value for the port to 1 to make sure that validateDNS
|
|
|
|
// doesn't throw the same error, unless the same TCP port is set there
|
|
|
|
// as well.
|
|
|
|
tcpPorts[port] = 1
|
2021-12-16 20:54:59 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
return err
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2023-06-29 15:29:52 +03:00
|
|
|
switch reqPort {
|
|
|
|
case 0, config.HTTPConfig.Address.Port():
|
2022-01-19 20:45:50 +03:00
|
|
|
return nil
|
|
|
|
default:
|
|
|
|
// Go on and check the port binding only if it's not zero or won't be
|
|
|
|
// unbound after install.
|
|
|
|
}
|
|
|
|
|
2023-06-29 15:29:52 +03:00
|
|
|
return aghnet.CheckPort("tcp", netip.AddrPortFrom(req.Web.IP, reqPort))
|
2022-01-19 20:45:50 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// validateDNS returns error if the DNS part of the initial configuration can't
|
2022-01-20 17:19:09 +03:00
|
|
|
// be set. canAutofix is true if the port can be unbound by AdGuard Home
|
2022-01-19 20:45:50 +03:00
|
|
|
// automatically.
|
2022-08-03 14:36:18 +03:00
|
|
|
func (req *checkConfReq) validateDNS(
|
|
|
|
tcpPorts aghalg.UniqChecker[tcpPort],
|
|
|
|
) (canAutofix bool, err error) {
|
2022-01-19 20:45:50 +03:00
|
|
|
defer func() { err = errors.Annotate(err, "validating ports: %w") }()
|
|
|
|
|
2023-10-05 15:26:19 +03:00
|
|
|
port := req.DNS.Port
|
2022-01-19 20:45:50 +03:00
|
|
|
switch port {
|
|
|
|
case 0:
|
|
|
|
return false, nil
|
2023-06-29 15:29:52 +03:00
|
|
|
case config.HTTPConfig.Address.Port():
|
2022-01-19 20:45:50 +03:00
|
|
|
// Go on and only check the UDP port since the TCP one is already bound
|
|
|
|
// by AdGuard Home for web interface.
|
|
|
|
default:
|
|
|
|
// Check TCP as well.
|
2022-08-03 14:36:18 +03:00
|
|
|
addPorts(tcpPorts, tcpPort(port))
|
|
|
|
if err = tcpPorts.Validate(); err != nil {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
|
2023-10-05 15:26:19 +03:00
|
|
|
err = aghnet.CheckPort("tcp", netip.AddrPortFrom(req.DNS.IP, port))
|
2019-04-23 11:48:30 +03:00
|
|
|
if err != nil {
|
2022-01-19 20:45:50 +03:00
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-10-05 15:26:19 +03:00
|
|
|
err = aghnet.CheckPort("udp", netip.AddrPortFrom(req.DNS.IP, port))
|
2022-01-19 20:45:50 +03:00
|
|
|
if !aghnet.IsAddrInUse(err) {
|
|
|
|
return false, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to fix automatically.
|
|
|
|
canAutofix = checkDNSStubListener()
|
|
|
|
if canAutofix && req.DNS.Autofix {
|
|
|
|
if derr := disableDNSStubListener(); derr != nil {
|
|
|
|
log.Error("disabling DNSStubListener: %s", err)
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
2022-01-19 20:45:50 +03:00
|
|
|
|
2023-10-05 15:26:19 +03:00
|
|
|
err = aghnet.CheckPort("udp", netip.AddrPortFrom(req.DNS.IP, port))
|
2022-01-19 20:45:50 +03:00
|
|
|
canAutofix = false
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
return canAutofix, err
|
|
|
|
}
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
// handleInstallCheckConfig handles the /check_config endpoint.
|
2023-04-11 17:22:51 +03:00
|
|
|
func (web *webAPI) handleInstallCheckConfig(w http.ResponseWriter, r *http.Request) {
|
2022-01-19 20:45:50 +03:00
|
|
|
req := &checkConfReq{}
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
err := json.NewDecoder(r.Body).Decode(req)
|
|
|
|
if err != nil {
|
|
|
|
aghhttp.Error(r, w, http.StatusBadRequest, "decoding the request: %s", err)
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
return
|
|
|
|
}
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2022-01-19 20:45:50 +03:00
|
|
|
resp := &checkConfResp{}
|
2022-08-03 14:36:18 +03:00
|
|
|
tcpPorts := aghalg.UniqChecker[tcpPort]{}
|
|
|
|
if err = req.validateWeb(tcpPorts); err != nil {
|
2022-01-19 20:45:50 +03:00
|
|
|
resp.Web.Status = err.Error()
|
|
|
|
}
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2022-08-03 14:36:18 +03:00
|
|
|
if resp.DNS.CanAutofix, err = req.validateDNS(tcpPorts); err != nil {
|
2022-01-19 20:45:50 +03:00
|
|
|
resp.DNS.Status = err.Error()
|
|
|
|
} else if !req.DNS.IP.IsUnspecified() {
|
|
|
|
resp.StaticIP = handleStaticIP(req.DNS.IP, req.SetStaticIP)
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2023-08-29 20:03:40 +03:00
|
|
|
aghhttp.WriteJSONResponseOK(w, r, resp)
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2020-02-13 18:42:07 +03:00
|
|
|
// handleStaticIP - handles static IP request
|
|
|
|
// It either checks if we have a static IP
|
|
|
|
// Or if set=true, it tries to set it
|
2022-10-14 15:29:44 +03:00
|
|
|
func handleStaticIP(ip netip.Addr, set bool) staticIPJSON {
|
2020-02-13 18:42:07 +03:00
|
|
|
resp := staticIPJSON{}
|
|
|
|
|
2022-08-10 13:39:28 +03:00
|
|
|
interfaceName := aghnet.InterfaceByIP(ip)
|
2020-02-13 18:42:07 +03:00
|
|
|
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
|
2021-03-16 19:42:15 +03:00
|
|
|
err := aghnet.IfaceSetStaticIP(interfaceName)
|
2020-02-13 18:42:07 +03:00
|
|
|
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
|
2021-03-16 19:42:15 +03:00
|
|
|
isStaticIP, err := aghnet.IfaceHasStaticIP(interfaceName)
|
2020-02-13 18:42:07 +03:00
|
|
|
if err != nil {
|
|
|
|
resp.Static = "error"
|
|
|
|
resp.Error = err.Error()
|
|
|
|
} else {
|
|
|
|
if isStaticIP {
|
|
|
|
resp.Static = "yes"
|
|
|
|
}
|
2021-03-16 19:42:15 +03:00
|
|
|
resp.IP = aghnet.GetSubnet(interfaceName).String()
|
2020-02-13 18:42:07 +03:00
|
|
|
}
|
|
|
|
return resp
|
|
|
|
}
|
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
// Check if DNSStubListener is active
|
|
|
|
func checkDNSStubListener() bool {
|
2019-12-23 14:57:10 +03:00
|
|
|
if runtime.GOOS != "linux" {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
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 {
|
2020-02-13 18:42:07 +03:00
|
|
|
log.Info("command %s has failed: %v code:%d",
|
2019-04-23 11:48:30 +03:00
|
|
|
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 {
|
2020-02-13 18:42:07 +03:00
|
|
|
log.Info("command %s has failed: %v code:%d",
|
2019-04-23 11:48:30 +03:00
|
|
|
cmd.Path, err, cmd.ProcessState.ExitCode())
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
2020-11-05 15:20:57 +03:00
|
|
|
const (
|
|
|
|
resolvedConfPath = "/etc/systemd/resolved.conf.d/adguardhome.conf"
|
|
|
|
resolvedConfData = `[Resolve]
|
2019-12-16 15:48:11 +03:00
|
|
|
DNS=127.0.0.1
|
|
|
|
DNSStubListener=no
|
|
|
|
`
|
2020-11-05 15:20:57 +03:00
|
|
|
)
|
2019-12-16 15:48:11 +03:00
|
|
|
const resolvConfPath = "/etc/resolv.conf"
|
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
// Deactivate DNSStubListener
|
2024-10-02 21:00:15 +03:00
|
|
|
func disableDNSStubListener() (err error) {
|
2019-12-16 15:48:11 +03:00
|
|
|
dir := filepath.Dir(resolvedConfPath)
|
2024-10-02 21:00:15 +03:00
|
|
|
err = os.MkdirAll(dir, 0o755)
|
2019-04-23 11:48:30 +03:00
|
|
|
if err != nil {
|
2020-11-05 15:20:57 +03:00
|
|
|
return fmt.Errorf("os.MkdirAll: %s: %w", dir, err)
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
2019-12-16 15:48:11 +03:00
|
|
|
|
2021-05-21 14:55:42 +03:00
|
|
|
err = os.WriteFile(resolvedConfPath, []byte(resolvedConfData), 0o644)
|
2019-12-16 15:48:11 +03:00
|
|
|
if err != nil {
|
2021-05-21 14:55:42 +03:00
|
|
|
return fmt.Errorf("os.WriteFile: %s: %w", resolvedConfPath, err)
|
2019-12-16 15:48:11 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
_ = 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
|
2020-11-05 15:20:57 +03:00
|
|
|
return fmt.Errorf("os.Symlink: %s: %w", resolvConfPath, err)
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2019-12-16 15:48:11 +03:00
|
|
|
cmd := exec.Command("systemctl", "reload-or-restart", "systemd-resolved")
|
2019-04-23 11:48:30 +03:00
|
|
|
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 {
|
2022-10-14 15:29:44 +03:00
|
|
|
IP netip.Addr `json:"ip"`
|
2023-10-05 15:26:19 +03:00
|
|
|
Port uint16 `json:"port"`
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
2020-11-05 15:20:57 +03:00
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
type applyConfigReq struct {
|
2022-01-18 15:05:34 +03:00
|
|
|
Username string `json:"username"`
|
|
|
|
Password string `json:"password"`
|
|
|
|
|
|
|
|
Web applyConfigReqEnt `json:"web"`
|
|
|
|
DNS applyConfigReqEnt `json:"dns"`
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2021-09-14 18:03:14 +03:00
|
|
|
// copyInstallSettings copies the installation parameters between two
|
|
|
|
// configuration structures.
|
2020-12-07 16:04:53 +03:00
|
|
|
func copyInstallSettings(dst, src *configuration) {
|
2023-06-29 15:29:52 +03:00
|
|
|
dst.HTTPConfig = src.HTTPConfig
|
2021-03-23 12:32:07 +03:00
|
|
|
dst.DNS.BindHosts = src.DNS.BindHosts
|
2019-04-23 11:48:30 +03:00
|
|
|
dst.DNS.Port = src.DNS.Port
|
|
|
|
}
|
|
|
|
|
2021-01-26 19:44:19 +03:00
|
|
|
// shutdownTimeout is the timeout for shutting HTTP server down operation.
|
|
|
|
const shutdownTimeout = 5 * time.Second
|
|
|
|
|
2022-10-03 18:08:05 +03:00
|
|
|
// shutdownSrv shuts srv down and prints error messages to the log.
|
2021-12-06 17:26:43 +03:00
|
|
|
func shutdownSrv(ctx context.Context, srv *http.Server) {
|
2021-05-24 17:28:11 +03:00
|
|
|
defer log.OnPanic("")
|
2021-03-12 14:32:08 +03:00
|
|
|
|
|
|
|
if srv == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
err := srv.Shutdown(ctx)
|
2022-10-03 18:08:05 +03:00
|
|
|
if err == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
const msgFmt = "shutting down http server %q: %s"
|
|
|
|
if errors.Is(err, context.Canceled) {
|
|
|
|
log.Debug(msgFmt, srv.Addr, err)
|
|
|
|
} else {
|
|
|
|
log.Error(msgFmt, srv.Addr, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// shutdownSrv3 shuts srv down and prints error messages to the log.
|
|
|
|
//
|
|
|
|
// TODO(a.garipov): Think of a good way to merge with [shutdownSrv].
|
|
|
|
func shutdownSrv3(srv *http3.Server) {
|
|
|
|
defer log.OnPanic("")
|
|
|
|
|
|
|
|
if srv == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
err := srv.Close()
|
|
|
|
if err == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
const msgFmt = "shutting down http/3 server %q: %s"
|
|
|
|
if errors.Is(err, context.Canceled) {
|
|
|
|
log.Debug(msgFmt, srv.Addr, err)
|
|
|
|
} else {
|
|
|
|
log.Error(msgFmt, srv.Addr, err)
|
2021-03-12 14:32:08 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-10 18:30:41 +03:00
|
|
|
// PasswordMinRunes is the minimum length of user's password in runes.
|
|
|
|
const PasswordMinRunes = 8
|
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
// Apply new configuration, start DNS server, restart Web server
|
2023-04-11 17:22:51 +03:00
|
|
|
func (web *webAPI) handleInstallConfigure(w http.ResponseWriter, r *http.Request) {
|
2021-09-13 16:00:36 +03:00
|
|
|
req, restartHTTP, err := decodeApplyConfigReq(r.Body)
|
2019-04-23 11:48:30 +03:00
|
|
|
if err != nil {
|
2021-12-16 20:54:59 +03:00
|
|
|
aghhttp.Error(r, w, http.StatusBadRequest, "%s", err)
|
2019-04-23 11:48:30 +03:00
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2022-02-10 18:30:41 +03:00
|
|
|
if utf8.RuneCountInString(req.Password) < PasswordMinRunes {
|
|
|
|
aghhttp.Error(
|
|
|
|
r,
|
|
|
|
w,
|
|
|
|
http.StatusUnprocessableEntity,
|
|
|
|
"password must be at least %d symbols long",
|
|
|
|
PasswordMinRunes,
|
|
|
|
)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-10-05 15:26:19 +03:00
|
|
|
err = aghnet.CheckPort("udp", netip.AddrPortFrom(req.DNS.IP, req.DNS.Port))
|
2019-04-23 11:48:30 +03:00
|
|
|
if err != nil {
|
2021-12-16 20:54:59 +03:00
|
|
|
aghhttp.Error(r, w, http.StatusBadRequest, "%s", err)
|
2021-09-13 16:00:36 +03:00
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2023-10-05 15:26:19 +03:00
|
|
|
err = aghnet.CheckPort("tcp", netip.AddrPortFrom(req.DNS.IP, req.DNS.Port))
|
2019-04-23 11:48:30 +03:00
|
|
|
if err != nil {
|
2021-12-16 20:54:59 +03:00
|
|
|
aghhttp.Error(r, w, http.StatusBadRequest, "%s", err)
|
2021-09-13 16:00:36 +03:00
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-09-14 18:03:14 +03:00
|
|
|
curConfig := &configuration{}
|
2021-09-13 16:00:36 +03:00
|
|
|
copyInstallSettings(curConfig, config)
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2020-02-13 18:42:07 +03:00
|
|
|
Context.firstRun = false
|
2022-10-14 15:29:44 +03:00
|
|
|
config.DNS.BindHosts = []netip.Addr{req.DNS.IP}
|
2021-06-01 21:06:55 +03:00
|
|
|
config.DNS.Port = req.DNS.Port
|
2024-10-02 21:00:15 +03:00
|
|
|
config.Filtering.SafeFSPatterns = []string{
|
|
|
|
filepath.Join(Context.workDir, userFilterDataDir, "*"),
|
|
|
|
}
|
|
|
|
config.HTTPConfig.Address = netip.AddrPortFrom(req.Web.IP, req.Web.Port)
|
2019-04-23 11:48:30 +03:00
|
|
|
|
2023-10-05 16:20:28 +03:00
|
|
|
u := &webUser{
|
|
|
|
Name: req.Username,
|
|
|
|
}
|
2023-11-03 16:07:15 +03:00
|
|
|
err = Context.auth.addUser(u, req.Password)
|
2023-10-05 16:20:28 +03:00
|
|
|
if err != nil {
|
|
|
|
Context.firstRun = true
|
|
|
|
copyInstallSettings(config, curConfig)
|
|
|
|
aghhttp.Error(r, w, http.StatusUnprocessableEntity, "%s", err)
|
|
|
|
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-12-16 20:54:59 +03:00
|
|
|
// TODO(e.burkov): StartMods() should be put in a separate goroutine at the
|
|
|
|
// moment we'll allow setting up TLS in the initial configuration or the
|
|
|
|
// configuration itself will use HTTPS protocol, because the underlying
|
|
|
|
// functions potentially restart the HTTPS server.
|
2024-12-02 18:20:31 +03:00
|
|
|
err = startMods(web.baseLogger)
|
2020-02-19 15:28:06 +03:00
|
|
|
if err != nil {
|
2020-02-13 18:42:07 +03:00
|
|
|
Context.firstRun = true
|
2021-09-13 16:00:36 +03:00
|
|
|
copyInstallSettings(config, curConfig)
|
2021-12-16 20:54:59 +03:00
|
|
|
aghhttp.Error(r, w, http.StatusInternalServerError, "%s", err)
|
2021-09-13 16:00:36 +03:00
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
err = config.write()
|
|
|
|
if err != nil {
|
2020-02-13 18:42:07 +03:00
|
|
|
Context.firstRun = true
|
2021-09-13 16:00:36 +03:00
|
|
|
copyInstallSettings(config, curConfig)
|
2021-12-16 20:54:59 +03:00
|
|
|
aghhttp.Error(r, w, http.StatusInternalServerError, "Couldn't write config: %s", err)
|
2021-09-13 16:00:36 +03:00
|
|
|
|
2019-04-23 11:48:30 +03:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2020-04-08 19:08:35 +03:00
|
|
|
web.conf.firstRun = false
|
2023-10-05 15:26:19 +03:00
|
|
|
web.conf.BindAddr = netip.AddrPortFrom(req.Web.IP, req.Web.Port)
|
2020-04-08 19:08:35 +03:00
|
|
|
|
2023-07-19 16:57:57 +03:00
|
|
|
registerControlHandlers(web)
|
2020-02-18 19:27:09 +03:00
|
|
|
|
2021-12-16 20:54:59 +03:00
|
|
|
aghhttp.OK(w)
|
2020-04-24 15:50:57 +03:00
|
|
|
if f, ok := w.(http.Flusher); ok {
|
|
|
|
f.Flush()
|
|
|
|
}
|
|
|
|
|
2021-12-06 17:26:43 +03:00
|
|
|
if !restartHTTP {
|
|
|
|
return
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
2021-12-06 17:26:43 +03:00
|
|
|
|
|
|
|
// Method http.(*Server).Shutdown needs to be called in a separate goroutine
|
|
|
|
// and with its own context, because it waits until all requests are handled
|
|
|
|
// and will be blocked by it's own caller.
|
|
|
|
go func(timeout time.Duration) {
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
2024-12-02 18:20:31 +03:00
|
|
|
defer slogutil.RecoverAndLog(ctx, web.logger)
|
2021-12-06 17:26:43 +03:00
|
|
|
defer cancel()
|
|
|
|
|
|
|
|
shutdownSrv(ctx, web.httpServer)
|
|
|
|
}(shutdownTimeout)
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|
|
|
|
|
2021-09-13 16:00:36 +03:00
|
|
|
// decodeApplyConfigReq decodes the configuration, validates some parameters,
|
|
|
|
// and returns it along with the boolean indicating whether or not the HTTP
|
|
|
|
// server must be restarted.
|
|
|
|
func decodeApplyConfigReq(r io.Reader) (req *applyConfigReq, restartHTTP bool, err error) {
|
|
|
|
req = &applyConfigReq{}
|
|
|
|
err = json.NewDecoder(r).Decode(&req)
|
|
|
|
if err != nil {
|
|
|
|
return nil, false, fmt.Errorf("parsing request: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if req.Web.Port == 0 || req.DNS.Port == 0 {
|
|
|
|
return nil, false, errors.Error("ports cannot be 0")
|
|
|
|
}
|
|
|
|
|
2023-06-29 15:29:52 +03:00
|
|
|
addrPort := config.HTTPConfig.Address
|
2023-10-05 15:26:19 +03:00
|
|
|
restartHTTP = addrPort.Addr() != req.Web.IP || addrPort.Port() != req.Web.Port
|
2021-09-13 16:00:36 +03:00
|
|
|
if restartHTTP {
|
2023-10-05 15:26:19 +03:00
|
|
|
err = aghnet.CheckPort("tcp", netip.AddrPortFrom(req.Web.IP, req.Web.Port))
|
2021-09-13 16:00:36 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, false, fmt.Errorf(
|
|
|
|
"checking address %s:%d: %w",
|
|
|
|
req.Web.IP.String(),
|
|
|
|
req.Web.Port,
|
|
|
|
err,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return req, restartHTTP, err
|
|
|
|
}
|
|
|
|
|
2023-04-11 17:22:51 +03:00
|
|
|
func (web *webAPI) registerInstallHandlers() {
|
2020-11-25 15:50:59 +03:00
|
|
|
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)))
|
2019-04-23 11:48:30 +03:00
|
|
|
}
|