2019-06-10 08:33:19 +00:00
|
|
|
package home
|
2019-04-25 11:57:03 +00:00
|
|
|
|
|
|
|
import (
|
2021-01-26 16:44:19 +00:00
|
|
|
"context"
|
2019-04-25 11:57:03 +00:00
|
|
|
"encoding/json"
|
2020-12-24 18:44:36 +00:00
|
|
|
"errors"
|
2019-04-25 11:57:03 +00:00
|
|
|
"net/http"
|
|
|
|
"os"
|
|
|
|
"os/exec"
|
|
|
|
"path/filepath"
|
|
|
|
"runtime"
|
|
|
|
"syscall"
|
2020-12-22 10:59:09 +00:00
|
|
|
"time"
|
2019-04-25 11:57:03 +00:00
|
|
|
|
2020-11-30 16:23:14 +00:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/sysutil"
|
2021-01-13 13:18:51 +00:00
|
|
|
"github.com/AdguardTeam/AdGuardHome/internal/updater"
|
2019-04-25 11:57:03 +00:00
|
|
|
"github.com/AdguardTeam/golibs/log"
|
|
|
|
)
|
|
|
|
|
2020-12-25 09:54:22 +00:00
|
|
|
// temporaryError is the interface for temporary errors from the Go standard
|
2020-12-24 18:44:36 +00:00
|
|
|
// library.
|
2020-12-25 09:54:22 +00:00
|
|
|
type temporaryError interface {
|
2020-12-24 18:44:36 +00:00
|
|
|
error
|
|
|
|
Temporary() (ok bool)
|
|
|
|
}
|
|
|
|
|
2019-04-25 11:57:03 +00:00
|
|
|
// Get the latest available version from the Internet
|
|
|
|
func handleGetVersionJSON(w http.ResponseWriter, r *http.Request) {
|
2021-01-21 16:55:41 +00:00
|
|
|
resp := &versionResponse{}
|
2020-02-13 15:42:07 +00:00
|
|
|
if Context.disableUpdate {
|
2021-01-21 16:55:41 +00:00
|
|
|
// w.Header().Set("Content-Type", "application/json")
|
|
|
|
resp.Disabled = true
|
|
|
|
_ = json.NewEncoder(w).Encode(resp)
|
|
|
|
// TODO(e.burkov): Add error handling and deal with headers.
|
2019-05-27 15:48:33 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-01-21 16:55:41 +00:00
|
|
|
req := &struct {
|
|
|
|
Recheck bool `json:"recheck_now"`
|
|
|
|
}{}
|
|
|
|
|
2020-07-10 19:20:30 +00:00
|
|
|
var err error
|
|
|
|
if r.ContentLength != 0 {
|
2021-01-21 16:55:41 +00:00
|
|
|
err = json.NewDecoder(r.Body).Decode(req)
|
2020-07-10 19:20:30 +00:00
|
|
|
if err != nil {
|
|
|
|
httpError(w, http.StatusBadRequest, "JSON parse: %s", err)
|
|
|
|
return
|
|
|
|
}
|
2019-06-25 12:55:09 +00:00
|
|
|
}
|
|
|
|
|
2020-07-22 11:20:14 +00:00
|
|
|
for i := 0; i != 3; i++ {
|
2020-12-24 18:44:36 +00:00
|
|
|
func() {
|
|
|
|
Context.controlLock.Lock()
|
|
|
|
defer Context.controlLock.Unlock()
|
|
|
|
|
2021-01-21 16:55:41 +00:00
|
|
|
resp.VersionInfo, err = Context.updater.VersionInfo(req.Recheck)
|
2020-12-24 18:44:36 +00:00
|
|
|
}()
|
|
|
|
|
|
|
|
if err != nil {
|
2020-12-25 09:54:22 +00:00
|
|
|
var terr temporaryError
|
2020-12-24 18:44:36 +00:00
|
|
|
if errors.As(err, &terr) && terr.Temporary() {
|
|
|
|
// Temporary network error. This case may happen while
|
|
|
|
// we're restarting our DNS server. Log and sleep for
|
|
|
|
// some time.
|
|
|
|
//
|
|
|
|
// See https://github.com/AdguardTeam/AdGuardHome/issues/934.
|
|
|
|
d := time.Duration(i) * time.Second
|
|
|
|
log.Info("temp net error: %q; sleeping for %s and retrying", err, d)
|
|
|
|
time.Sleep(d)
|
|
|
|
|
|
|
|
continue
|
|
|
|
}
|
2019-08-26 13:02:56 +00:00
|
|
|
}
|
2020-12-24 18:44:36 +00:00
|
|
|
|
2019-08-26 13:02:56 +00:00
|
|
|
break
|
|
|
|
}
|
2019-04-25 11:57:03 +00:00
|
|
|
if err != nil {
|
2021-01-13 13:18:51 +00:00
|
|
|
vcu := Context.updater.VersionCheckURL()
|
2021-01-21 16:55:41 +00:00
|
|
|
// TODO(a.garipov): Figure out the purpose of %T verb.
|
2021-01-13 13:18:51 +00:00
|
|
|
httpError(w, http.StatusBadGateway, "Couldn't get version check json from %s: %T %s\n", vcu, err, err)
|
|
|
|
|
2019-04-25 11:57:03 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-01-21 16:55:41 +00:00
|
|
|
resp.confirmAutoUpdate()
|
|
|
|
|
2019-05-15 08:02:09 +00:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2021-01-21 16:55:41 +00:00
|
|
|
err = json.NewEncoder(w).Encode(resp)
|
2019-05-15 08:02:09 +00:00
|
|
|
if err != nil {
|
|
|
|
httpError(w, http.StatusInternalServerError, "Couldn't write body: %s", err)
|
|
|
|
}
|
2019-04-25 11:57:03 +00:00
|
|
|
}
|
|
|
|
|
2021-01-26 16:44:19 +00:00
|
|
|
// handleUpdate performs an update to the latest available version procedure.
|
2020-07-22 17:27:20 +00:00
|
|
|
func handleUpdate(w http.ResponseWriter, _ *http.Request) {
|
2021-01-13 13:18:51 +00:00
|
|
|
if Context.updater.NewVersion() == "" {
|
2020-07-09 16:54:53 +00:00
|
|
|
httpError(w, http.StatusBadRequest, "/update request isn't allowed now")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2021-01-13 13:18:51 +00:00
|
|
|
err := Context.updater.Update()
|
2020-07-09 16:54:53 +00:00
|
|
|
if err != nil {
|
|
|
|
httpError(w, http.StatusInternalServerError, "%s", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
returnOK(w)
|
|
|
|
if f, ok := w.(http.Flusher); ok {
|
|
|
|
f.Flush()
|
|
|
|
}
|
|
|
|
|
2021-01-26 16:44:19 +00:00
|
|
|
// The background context is used because the underlying functions wrap
|
|
|
|
// it with timeout and shut down the server, which handles current
|
|
|
|
// request. It also should be done in a separate goroutine due to the
|
|
|
|
// same reason.
|
|
|
|
go func() {
|
|
|
|
finishUpdate(context.Background())
|
|
|
|
}()
|
2020-07-09 16:54:53 +00:00
|
|
|
}
|
|
|
|
|
2021-01-21 16:55:41 +00:00
|
|
|
// versionResponse is the response for /control/version.json endpoint.
|
|
|
|
type versionResponse struct {
|
|
|
|
Disabled bool `json:"disabled"`
|
|
|
|
updater.VersionInfo
|
|
|
|
}
|
2020-07-09 16:54:53 +00:00
|
|
|
|
2021-01-21 16:55:41 +00:00
|
|
|
// confirmAutoUpdate checks the real possibility of auto update.
|
|
|
|
func (vr *versionResponse) confirmAutoUpdate() {
|
|
|
|
if vr.CanAutoUpdate != nil && *vr.CanAutoUpdate {
|
2020-07-09 16:54:53 +00:00
|
|
|
canUpdate := true
|
|
|
|
|
2021-01-21 16:55:41 +00:00
|
|
|
var tlsConf *tlsConfigSettings
|
|
|
|
if runtime.GOOS != "windows" {
|
|
|
|
tlsConf = &tlsConfigSettings{}
|
|
|
|
Context.tls.WriteDiskConfig(tlsConf)
|
|
|
|
}
|
2020-07-09 16:54:53 +00:00
|
|
|
|
2021-01-21 16:55:41 +00:00
|
|
|
if tlsConf != nil &&
|
2020-08-27 12:03:07 +00:00
|
|
|
((tlsConf.Enabled && (tlsConf.PortHTTPS < 1024 ||
|
|
|
|
tlsConf.PortDNSOverTLS < 1024 ||
|
|
|
|
tlsConf.PortDNSOverQUIC < 1024)) ||
|
2020-07-09 16:54:53 +00:00
|
|
|
config.BindPort < 1024 ||
|
|
|
|
config.DNS.Port < 1024) {
|
2020-11-30 16:23:14 +00:00
|
|
|
canUpdate, _ = sysutil.CanBindPrivilegedPorts()
|
2020-07-09 16:54:53 +00:00
|
|
|
}
|
2021-01-21 16:55:41 +00:00
|
|
|
vr.CanAutoUpdate = &canUpdate
|
2020-07-09 16:54:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-26 16:44:19 +00:00
|
|
|
// finishUpdate completes an update procedure.
|
|
|
|
func finishUpdate(ctx context.Context) {
|
2019-04-25 11:57:03 +00:00
|
|
|
log.Info("Stopping all tasks")
|
2021-01-26 16:44:19 +00:00
|
|
|
cleanup(ctx)
|
2019-04-25 11:57:03 +00:00
|
|
|
cleanupAlways()
|
|
|
|
|
2020-07-22 11:20:14 +00:00
|
|
|
exeName := "AdGuardHome"
|
|
|
|
if runtime.GOOS == "windows" {
|
|
|
|
exeName = "AdGuardHome.exe"
|
|
|
|
}
|
|
|
|
curBinName := filepath.Join(Context.workDir, exeName)
|
|
|
|
|
2019-04-25 11:57:03 +00:00
|
|
|
if runtime.GOOS == "windows" {
|
2020-02-13 15:42:07 +00:00
|
|
|
if Context.runningAsService {
|
2019-04-25 11:57:03 +00:00
|
|
|
// Note:
|
|
|
|
// we can't restart the service via "kardianos/service" package - it kills the process first
|
|
|
|
// we can't start a new instance - Windows doesn't allow it
|
|
|
|
cmd := exec.Command("cmd", "/c", "net stop AdGuardHome & net start AdGuardHome")
|
|
|
|
err := cmd.Start()
|
|
|
|
if err != nil {
|
|
|
|
log.Fatalf("exec.Command() failed: %s", err)
|
|
|
|
}
|
|
|
|
os.Exit(0)
|
|
|
|
}
|
|
|
|
|
2020-07-22 11:20:14 +00:00
|
|
|
cmd := exec.Command(curBinName, os.Args[1:]...)
|
2019-04-25 11:57:03 +00:00
|
|
|
log.Info("Restarting: %v", cmd.Args)
|
|
|
|
cmd.Stdin = os.Stdin
|
|
|
|
cmd.Stdout = os.Stdout
|
|
|
|
cmd.Stderr = os.Stderr
|
|
|
|
err := cmd.Start()
|
|
|
|
if err != nil {
|
|
|
|
log.Fatalf("exec.Command() failed: %s", err)
|
|
|
|
}
|
|
|
|
os.Exit(0)
|
|
|
|
} else {
|
|
|
|
log.Info("Restarting: %v", os.Args)
|
2020-07-22 11:20:14 +00:00
|
|
|
err := syscall.Exec(curBinName, os.Args, os.Environ())
|
2019-04-25 11:57:03 +00:00
|
|
|
if err != nil {
|
|
|
|
log.Fatalf("syscall.Exec() failed: %s", err)
|
|
|
|
}
|
|
|
|
// Unreachable code
|
|
|
|
}
|
|
|
|
}
|