267 lines
6.7 KiB
Go
267 lines
6.7 KiB
Go
package update
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"syscall"
|
|
"time"
|
|
)
|
|
|
|
// CurrentVersion is the shipped client version.
|
|
const CurrentVersion = "1.2.0"
|
|
|
|
// DefaultManifestURL is the update feed (hosted in the project git repo).
|
|
const DefaultManifestURL = "https://git.evilfox.cc/test2/navi/raw/branch/main/dist/update.json"
|
|
|
|
// Manifest describes a remote release.
|
|
type Manifest struct {
|
|
Version string `json:"version"`
|
|
URL string `json:"url"`
|
|
SHA256 string `json:"sha256,omitempty"`
|
|
Notes string `json:"notes,omitempty"`
|
|
Mandatory bool `json:"mandatory,omitempty"`
|
|
}
|
|
|
|
// Status is returned to the UI.
|
|
type Status struct {
|
|
Current string `json:"current"`
|
|
Latest string `json:"latest,omitempty"`
|
|
Notes string `json:"notes,omitempty"`
|
|
URL string `json:"url,omitempty"`
|
|
Available bool `json:"available"`
|
|
Mandatory bool `json:"mandatory"`
|
|
Checking bool `json:"checking,omitempty"`
|
|
Error string `json:"error,omitempty"`
|
|
ManifestURL string `json:"manifest_url"`
|
|
}
|
|
|
|
// Check fetches the manifest and compares versions.
|
|
func Check(ctx context.Context, manifestURL string) (Status, error) {
|
|
if manifestURL == "" {
|
|
manifestURL = DefaultManifestURL
|
|
}
|
|
st := Status{Current: CurrentVersion, ManifestURL: manifestURL}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, manifestURL, nil)
|
|
if err != nil {
|
|
return st, err
|
|
}
|
|
req.Header.Set("User-Agent", "Navis/"+CurrentVersion)
|
|
req.Header.Set("Accept", "application/json")
|
|
|
|
client := &http.Client{Timeout: 20 * time.Second}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
st.Error = err.Error()
|
|
return st, err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
err = fmt.Errorf("update feed HTTP %d", resp.StatusCode)
|
|
st.Error = err.Error()
|
|
return st, err
|
|
}
|
|
var m Manifest
|
|
if err := json.NewDecoder(io.LimitReader(resp.Body, 1<<20)).Decode(&m); err != nil {
|
|
st.Error = err.Error()
|
|
return st, err
|
|
}
|
|
st.Latest = strings.TrimSpace(m.Version)
|
|
st.Notes = m.Notes
|
|
st.URL = m.URL
|
|
st.Mandatory = m.Mandatory
|
|
st.Available = Compare(st.Latest, CurrentVersion) > 0 && m.URL != ""
|
|
return st, nil
|
|
}
|
|
|
|
// Compare returns 1 if a>b, -1 if a<b, 0 if equal (semver-ish dotted ints).
|
|
func Compare(a, b string) int {
|
|
as := splitVer(a)
|
|
bs := splitVer(b)
|
|
n := len(as)
|
|
if len(bs) > n {
|
|
n = len(bs)
|
|
}
|
|
for i := 0; i < n; i++ {
|
|
var ai, bi int
|
|
if i < len(as) {
|
|
ai = as[i]
|
|
}
|
|
if i < len(bs) {
|
|
bi = bs[i]
|
|
}
|
|
if ai > bi {
|
|
return 1
|
|
}
|
|
if ai < bi {
|
|
return -1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func splitVer(v string) []int {
|
|
v = strings.TrimPrefix(strings.TrimSpace(v), "v")
|
|
parts := strings.Split(v, ".")
|
|
out := make([]int, 0, len(parts))
|
|
for _, p := range parts {
|
|
p = strings.TrimSpace(p)
|
|
if p == "" {
|
|
out = append(out, 0)
|
|
continue
|
|
}
|
|
// strip pre-release suffix: 1.2.3-beta
|
|
if i := strings.IndexAny(p, "-+"); i >= 0 {
|
|
p = p[:i]
|
|
}
|
|
n, _ := strconv.Atoi(p)
|
|
out = append(out, n)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// Apply downloads the new exe and schedules replacement after exit.
|
|
func Apply(ctx context.Context, manifestURL string) (string, error) {
|
|
st, err := Check(ctx, manifestURL)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if !st.Available {
|
|
return "", fmt.Errorf("обновление не найдено")
|
|
}
|
|
if !allowedDownloadURL(st.URL) {
|
|
return "", fmt.Errorf("URL обновления должен быть на git.evilfox.cc или files.de4ima.uk")
|
|
}
|
|
|
|
exe, err := os.Executable()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
exe, err = filepath.Abs(exe)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
dir := filepath.Dir(exe)
|
|
tmp := filepath.Join(dir, "Navis.exe.new")
|
|
bat := filepath.Join(dir, "navis-update.bat")
|
|
|
|
if err := downloadFile(ctx, st.URL, tmp); err != nil {
|
|
return "", err
|
|
}
|
|
man, err := fetchManifest(ctx, manifestURL)
|
|
if err == nil && man.SHA256 != "" {
|
|
sum, err := fileSHA256(tmp)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if !strings.EqualFold(sum, man.SHA256) {
|
|
_ = os.Remove(tmp)
|
|
return "", fmt.Errorf("checksum mismatch")
|
|
}
|
|
}
|
|
|
|
// Important: do NOT self-delete the .bat at the end — that causes
|
|
// "Не удается найти пакетный файл" on paths with spaces (e.g. D:\vpn navi).
|
|
script := "@echo off\r\n" +
|
|
"setlocal EnableExtensions\r\n" +
|
|
"cd /d \"" + dir + "\"\r\n" +
|
|
"set \"EXE=" + exe + "\"\r\n" +
|
|
"set \"NEW=" + tmp + "\"\r\n" +
|
|
":wait\r\n" +
|
|
"ping -n 2 127.0.0.1 >nul\r\n" +
|
|
"del /f /q \"%EXE%\" >nul 2>&1\r\n" +
|
|
"if exist \"%EXE%\" goto wait\r\n" +
|
|
"move /y \"%NEW%\" \"%EXE%\" >nul\r\n" +
|
|
"if not exist \"%EXE%\" exit /b 1\r\n" +
|
|
"start \"\" \"%EXE%\"\r\n" +
|
|
"exit /b 0\r\n"
|
|
if err := os.WriteFile(bat, []byte(script), 0o755); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// Detached cmd so Apply returns while updater keeps running.
|
|
cmd := exec.Command("cmd.exe", "/C", bat)
|
|
cmd.Dir = dir
|
|
cmd.SysProcAttr = &syscall.SysProcAttr{
|
|
HideWindow: true,
|
|
CreationFlags: 0x00000008 | 0x00000200, // DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP
|
|
}
|
|
if err := cmd.Start(); err != nil {
|
|
return "", fmt.Errorf("start updater: %w", err)
|
|
}
|
|
return st.Latest, nil
|
|
}
|
|
|
|
func allowedDownloadURL(u string) bool {
|
|
u = strings.ToLower(strings.TrimSpace(u))
|
|
return strings.HasPrefix(u, "https://git.evilfox.cc/") ||
|
|
strings.HasPrefix(u, "https://files.de4ima.uk/")
|
|
}
|
|
|
|
func fetchManifest(ctx context.Context, manifestURL string) (Manifest, error) {
|
|
if manifestURL == "" {
|
|
manifestURL = DefaultManifestURL
|
|
}
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, manifestURL, nil)
|
|
if err != nil {
|
|
return Manifest{}, err
|
|
}
|
|
req.Header.Set("User-Agent", "Navis/"+CurrentVersion)
|
|
client := &http.Client{Timeout: 20 * time.Second}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return Manifest{}, err
|
|
}
|
|
defer resp.Body.Close()
|
|
var m Manifest
|
|
err = json.NewDecoder(io.LimitReader(resp.Body, 1<<20)).Decode(&m)
|
|
return m, err
|
|
}
|
|
|
|
func downloadFile(ctx context.Context, url, dest string) error {
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("User-Agent", "Navis/"+CurrentVersion)
|
|
client := &http.Client{Timeout: 10 * time.Minute}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("download HTTP %d", resp.StatusCode)
|
|
}
|
|
f, err := os.Create(dest)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
_, err = io.Copy(f, io.LimitReader(resp.Body, 200<<20))
|
|
return err
|
|
}
|
|
|
|
func fileSHA256(path string) (string, error) {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer f.Close()
|
|
h := sha256.New()
|
|
if _, err := io.Copy(h, f); err != nil {
|
|
return "", err
|
|
}
|
|
return hex.EncodeToString(h.Sum(nil)), nil
|
|
}
|