fix: geo auto update #1261

component/updater/update_core.go

@@ -0,0 +1,499 @@
+package updater
+
+import (
+	"archive/zip"
+	"compress/gzip"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	mihomoHttp "github.com/metacubex/mihomo/component/http"
+	C "github.com/metacubex/mihomo/constant"
+	"github.com/metacubex/mihomo/log"
+
+	"github.com/klauspost/cpuid/v2"
+)
+
+// modify from https://github.com/AdguardTeam/AdGuardHome/blob/595484e0b3fb4c457f9bb727a6b94faa78a66c5f/internal/updater/updater.go
+// Updater is the mihomo updater.
+var (
+	goarm           string
+	gomips          string
+	amd64Compatible string
+
+	workDir string
+
+	// mu protects all fields below.
+	mu sync.Mutex
+
+	currentExeName string // 当前可执行文件
+	updateDir      string // 更新目录
+	packageName    string // 更新压缩文件
+	backupDir      string // 备份目录
+	backupExeName  string // 备份文件名
+	updateExeName  string // 更新后的可执行文件
+
+	baseURL       string = "https://github.com/MetaCubeX/mihomo/releases/download/Prerelease-Alpha/mihomo"
+	versionURL    string = "https://github.com/MetaCubeX/mihomo/releases/download/Prerelease-Alpha/version.txt"
+	packageURL    string
+	latestVersion string
+)
+
+func init() {
+	if runtime.GOARCH == "amd64" && cpuid.CPU.X64Level() < 3 {
+		amd64Compatible = "-compatible"
+	}
+	if !strings.HasPrefix(C.Version, "alpha") {
+		baseURL = "https://github.com/MetaCubeX/mihomo/releases/latest/download/mihomo"
+		versionURL = "https://github.com/MetaCubeX/mihomo/releases/latest/download/version.txt"
+	}
+}
+
+type updateError struct {
+	Message string
+}
+
+func (e *updateError) Error() string {
+	return fmt.Sprintf("update error: %s", e.Message)
+}
+
+// Update performs the auto-updater.  It returns an error if the updater failed.
+// If firstRun is true, it assumes the configuration file doesn't exist.
+func UpdateCore(execPath string) (err error) {
+	mu.Lock()
+	defer mu.Unlock()
+
+	latestVersion, err = getLatestVersion()
+	if err != nil {
+		return err
+	}
+
+	log.Infoln("current version %s, latest version %s", C.Version, latestVersion)
+
+	if latestVersion == C.Version {
+		err := &updateError{Message: "already using latest version"}
+		return err
+	}
+
+	updateDownloadURL()
+
+	defer func() {
+		if err != nil {
+			log.Errorln("updater: failed: %v", err)
+		} else {
+			log.Infoln("updater: finished")
+		}
+	}()
+
+	workDir = filepath.Dir(execPath)
+
+	err = prepare(execPath)
+	if err != nil {
+		return fmt.Errorf("preparing: %w", err)
+	}
+
+	defer clean()
+
+	err = downloadPackageFile()
+	if err != nil {
+		return fmt.Errorf("downloading package file: %w", err)
+	}
+
+	err = unpack()
+	if err != nil {
+		return fmt.Errorf("unpacking: %w", err)
+	}
+
+	err = backup()
+	if err != nil {
+		return fmt.Errorf("backuping: %w", err)
+	}
+
+	err = replace()
+	if err != nil {
+		return fmt.Errorf("replacing: %w", err)
+	}
+
+	return nil
+}
+
+// prepare fills all necessary fields in Updater object.
+func prepare(exePath string) (err error) {
+	updateDir = filepath.Join(workDir, "meta-update")
+	currentExeName = exePath
+	_, pkgNameOnly := filepath.Split(packageURL)
+	if pkgNameOnly == "" {
+		return fmt.Errorf("invalid PackageURL: %q", packageURL)
+	}
+
+	packageName = filepath.Join(updateDir, pkgNameOnly)
+	//log.Infoln(packageName)
+	backupDir = filepath.Join(workDir, "meta-backup")
+
+	if runtime.GOOS == "windows" {
+		updateExeName = "mihomo" + "-" + runtime.GOOS + "-" + runtime.GOARCH + amd64Compatible + ".exe"
+	} else if runtime.GOOS == "android" && runtime.GOARCH == "arm64" {
+		updateExeName = "mihomo-android-arm64-v8"
+	} else {
+		updateExeName = "mihomo" + "-" + runtime.GOOS + "-" + runtime.GOARCH + amd64Compatible
+	}
+
+	log.Infoln("updateExeName: %s ", updateExeName)
+
+	backupExeName = filepath.Join(backupDir, filepath.Base(exePath))
+	updateExeName = filepath.Join(updateDir, updateExeName)
+
+	log.Infoln(
+		"updater: updating using url: %s",
+		packageURL,
+	)
+
+	currentExeName = exePath
+	_, err = os.Stat(currentExeName)
+	if err != nil {
+		return fmt.Errorf("checking %q: %w", currentExeName, err)
+	}
+
+	return nil
+}
+
+// unpack extracts the files from the downloaded archive.
+func unpack() error {
+	var err error
+	_, pkgNameOnly := filepath.Split(packageURL)
+
+	log.Infoln("updater: unpacking package")
+	if strings.HasSuffix(pkgNameOnly, ".zip") {
+		_, err = zipFileUnpack(packageName, updateDir)
+		if err != nil {
+			return fmt.Errorf(".zip unpack failed: %w", err)
+		}
+
+	} else if strings.HasSuffix(pkgNameOnly, ".gz") {
+		_, err = gzFileUnpack(packageName, updateDir)
+		if err != nil {
+			return fmt.Errorf(".gz unpack failed: %w", err)
+		}
+
+	} else {
+		return fmt.Errorf("unknown package extension")
+	}
+
+	return nil
+}
+
+// backup makes a backup of the current executable file
+func backup() (err error) {
+	log.Infoln("updater: backing up current ExecFile:%s to %s", currentExeName, backupExeName)
+	_ = os.Mkdir(backupDir, 0o755)
+
+	err = os.Rename(currentExeName, backupExeName)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// replace moves the current executable with the updated one
+func replace() error {
+	var err error
+
+	log.Infoln("replacing: %s to %s", updateExeName, currentExeName)
+	if runtime.GOOS == "windows" {
+		// rename fails with "File in use" error
+		err = copyFile(updateExeName, currentExeName)
+	} else {
+		err = os.Rename(updateExeName, currentExeName)
+	}
+	if err != nil {
+		return err
+	}
+
+	log.Infoln("updater: renamed: %s to %s", updateExeName, currentExeName)
+
+	return nil
+}
+
+// clean removes the temporary directory itself and all it's contents.
+func clean() {
+	_ = os.RemoveAll(updateDir)
+}
+
+// MaxPackageFileSize is a maximum package file length in bytes. The largest
+// package whose size is limited by this constant currently has the size of
+// approximately 9 MiB.
+const MaxPackageFileSize = 32 * 1024 * 1024
+
+// Download package file and save it to disk
+func downloadPackageFile() (err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*90)
+	defer cancel()
+	resp, err := mihomoHttp.HttpRequest(ctx, packageURL, http.MethodGet, http.Header{"User-Agent": {C.UA}}, nil)
+	if err != nil {
+		return fmt.Errorf("http request failed: %w", err)
+	}
+
+	defer func() {
+		closeErr := resp.Body.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	var r io.Reader
+	r, err = LimitReader(resp.Body, MaxPackageFileSize)
+	if err != nil {
+		return fmt.Errorf("http request failed: %w", err)
+	}
+
+	log.Debugln("updater: reading http body")
+	// This use of ReadAll is now safe, because we limited body's Reader.
+	body, err := io.ReadAll(r)
+	if err != nil {
+		return fmt.Errorf("io.ReadAll() failed: %w", err)
+	}
+
+	log.Debugln("updateDir %s", updateDir)
+	err = os.Mkdir(updateDir, 0o755)
+	if err != nil {
+		return fmt.Errorf("mkdir error: %w", err)
+	}
+
+	log.Debugln("updater: saving package to file %s", packageName)
+	err = os.WriteFile(packageName, body, 0o644)
+	if err != nil {
+		return fmt.Errorf("os.WriteFile() failed: %w", err)
+	}
+	return nil
+}
+
+// Unpack a single .gz file to the specified directory
+// Existing files are overwritten
+// All files are created inside outDir, subdirectories are not created
+// Return the output file name
+func gzFileUnpack(gzfile, outDir string) (string, error) {
+	f, err := os.Open(gzfile)
+	if err != nil {
+		return "", fmt.Errorf("os.Open(): %w", err)
+	}
+
+	defer func() {
+		closeErr := f.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	gzReader, err := gzip.NewReader(f)
+	if err != nil {
+		return "", fmt.Errorf("gzip.NewReader(): %w", err)
+	}
+
+	defer func() {
+		closeErr := gzReader.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+	// Get the original file name from the .gz file header
+	originalName := gzReader.Header.Name
+	if originalName == "" {
+		// Fallback: remove the .gz extension from the input file name if the header doesn't provide the original name
+		originalName = filepath.Base(gzfile)
+		originalName = strings.TrimSuffix(originalName, ".gz")
+	}
+
+	outputName := filepath.Join(outDir, originalName)
+
+	// Create the output file
+	wc, err := os.OpenFile(
+		outputName,
+		os.O_WRONLY|os.O_CREATE|os.O_TRUNC,
+		0o755,
+	)
+	if err != nil {
+		return "", fmt.Errorf("os.OpenFile(%s): %w", outputName, err)
+	}
+
+	defer func() {
+		closeErr := wc.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	// Copy the contents of the gzReader to the output file
+	_, err = io.Copy(wc, gzReader)
+	if err != nil {
+		return "", fmt.Errorf("io.Copy(): %w", err)
+	}
+
+	return outputName, nil
+}
+
+// Unpack a single file from .zip file to the specified directory
+// Existing files are overwritten
+// All files are created inside 'outDir', subdirectories are not created
+// Return the output file name
+func zipFileUnpack(zipfile, outDir string) (string, error) {
+	zrc, err := zip.OpenReader(zipfile)
+	if err != nil {
+		return "", fmt.Errorf("zip.OpenReader(): %w", err)
+	}
+
+	defer func() {
+		closeErr := zrc.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+	if len(zrc.File) == 0 {
+		return "", fmt.Errorf("no files in the zip archive")
+	}
+
+	// Assuming the first file in the zip archive is the target file
+	zf := zrc.File[0]
+	var rc io.ReadCloser
+	rc, err = zf.Open()
+	if err != nil {
+		return "", fmt.Errorf("zip file Open(): %w", err)
+	}
+
+	defer func() {
+		closeErr := rc.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+	fi := zf.FileInfo()
+	name := fi.Name()
+	outputName := filepath.Join(outDir, name)
+
+	if fi.IsDir() {
+		return "", fmt.Errorf("the target file is a directory")
+	}
+
+	var wc io.WriteCloser
+	wc, err = os.OpenFile(outputName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fi.Mode())
+	if err != nil {
+		return "", fmt.Errorf("os.OpenFile(): %w", err)
+	}
+
+	defer func() {
+		closeErr := wc.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+	_, err = io.Copy(wc, rc)
+	if err != nil {
+		return "", fmt.Errorf("io.Copy(): %w", err)
+	}
+
+	return outputName, nil
+}
+
+// Copy file on disk
+func copyFile(src, dst string) error {
+	d, e := os.ReadFile(src)
+	if e != nil {
+		return e
+	}
+	e = os.WriteFile(dst, d, 0o644)
+	if e != nil {
+		return e
+	}
+	return nil
+}
+
+func getLatestVersion() (version string, err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+	defer cancel()
+	resp, err := mihomoHttp.HttpRequest(ctx, versionURL, http.MethodGet, http.Header{"User-Agent": {C.UA}}, nil)
+	if err != nil {
+		return "", fmt.Errorf("get Latest Version fail: %w", err)
+	}
+	defer func() {
+		closeErr := resp.Body.Close()
+		if closeErr != nil && err == nil {
+			err = closeErr
+		}
+	}()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("get Latest Version fail: %w", err)
+	}
+	content := strings.TrimRight(string(body), "\n")
+	return content, nil
+}
+
+func updateDownloadURL() {
+	var middle string
+
+	if runtime.GOARCH == "arm" && probeGoARM() {
+		//-linux-armv7-alpha-e552b54.gz
+		middle = fmt.Sprintf("-%s-%s%s-%s", runtime.GOOS, runtime.GOARCH, goarm, latestVersion)
+	} else if runtime.GOARCH == "arm64" {
+		//-linux-arm64-alpha-e552b54.gz
+		if runtime.GOOS == "android" {
+			middle = fmt.Sprintf("-%s-%s-v8-%s", runtime.GOOS, runtime.GOARCH, latestVersion)
+		} else {
+			middle = fmt.Sprintf("-%s-%s-%s", runtime.GOOS, runtime.GOARCH, latestVersion)
+		}
+	} else if isMIPS(runtime.GOARCH) && gomips != "" {
+		middle = fmt.Sprintf("-%s-%s-%s-%s", runtime.GOOS, runtime.GOARCH, gomips, latestVersion)
+	} else {
+		middle = fmt.Sprintf("-%s-%s%s-%s", runtime.GOOS, runtime.GOARCH, amd64Compatible, latestVersion)
+	}
+
+	if runtime.GOOS == "windows" {
+		middle += ".zip"
+	} else {
+		middle += ".gz"
+	}
+	packageURL = baseURL + middle
+	//log.Infoln(packageURL)
+}
+
+// isMIPS returns true if arch is any MIPS architecture.
+func isMIPS(arch string) (ok bool) {
+	switch arch {
+	case
+		"mips",
+		"mips64",
+		"mips64le",
+		"mipsle":
+		return true
+	default:
+		return false
+	}
+}
+
+// linux only
+func probeGoARM() (ok bool) {
+	cmd := exec.Command("cat", "/proc/cpuinfo")
+	output, err := cmd.Output()
+	if err != nil {
+		log.Errorln("probe goarm error:%s", err)
+		return false
+	}
+	cpuInfo := string(output)
+	if strings.Contains(cpuInfo, "vfpv3") || strings.Contains(cpuInfo, "vfpv4") {
+		goarm = "v7"
+	} else if strings.Contains(cpuInfo, "vfp") {
+		goarm = "v6"
+	} else {
+		goarm = "v5"
+	}
+	return true
+}

component/updater/update_geo.go

@@ -0,0 +1,180 @@
+package updater
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/metacubex/mihomo/common/atomic"
+	"github.com/metacubex/mihomo/component/geodata"
+	_ "github.com/metacubex/mihomo/component/geodata/standard"
+	"github.com/metacubex/mihomo/component/mmdb"
+	C "github.com/metacubex/mihomo/constant"
+	"github.com/metacubex/mihomo/log"
+
+	"github.com/oschwald/maxminddb-golang"
+)
+
+var (
+	updateGeoMux sync.Mutex
+	UpdatingGeo  atomic.Bool
+)
+
+func updateGeoDatabases() error {
+	defer runtime.GC()
+	geoLoader, err := geodata.GetGeoDataLoader("standard")
+	if err != nil {
+		return err
+	}
+
+	if C.GeodataMode {
+		data, err := downloadForBytes(C.GeoIpUrl)
+		if err != nil {
+			return fmt.Errorf("can't download GeoIP database file: %w", err)
+		}
+
+		if _, err = geoLoader.LoadIPByBytes(data, "cn"); err != nil {
+			return fmt.Errorf("invalid GeoIP database file: %s", err)
+		}
+
+		if err = saveFile(data, C.Path.GeoIP()); err != nil {
+			return fmt.Errorf("can't save GeoIP database file: %w", err)
+		}
+
+	} else {
+		defer mmdb.ReloadIP()
+		data, err := downloadForBytes(C.MmdbUrl)
+		if err != nil {
+			return fmt.Errorf("can't download MMDB database file: %w", err)
+		}
+
+		instance, err := maxminddb.FromBytes(data)
+		if err != nil {
+			return fmt.Errorf("invalid MMDB database file: %s", err)
+		}
+		_ = instance.Close()
+
+		mmdb.IPInstance().Reader.Close() //  mmdb is loaded with mmap, so it needs to be closed before overwriting the file
+		if err = saveFile(data, C.Path.MMDB()); err != nil {
+			return fmt.Errorf("can't save MMDB database file: %w", err)
+		}
+	}
+
+	if C.ASNEnable {
+		defer mmdb.ReloadASN()
+		data, err := downloadForBytes(C.ASNUrl)
+		if err != nil {
+			return fmt.Errorf("can't download ASN database file: %w", err)
+		}
+
+		instance, err := maxminddb.FromBytes(data)
+		if err != nil {
+			return fmt.Errorf("invalid ASN database file: %s", err)
+		}
+		_ = instance.Close()
+
+		mmdb.ASNInstance().Reader.Close()
+		if err = saveFile(data, C.Path.ASN()); err != nil {
+			return fmt.Errorf("can't save ASN database file: %w", err)
+		}
+	}
+
+	data, err := downloadForBytes(C.GeoSiteUrl)
+	if err != nil {
+		return fmt.Errorf("can't download GeoSite database file: %w", err)
+	}
+
+	if _, err = geoLoader.LoadSiteByBytes(data, "cn"); err != nil {
+		return fmt.Errorf("invalid GeoSite database file: %s", err)
+	}
+
+	if err = saveFile(data, C.Path.GeoSite()); err != nil {
+		return fmt.Errorf("can't save GeoSite database file: %w", err)
+	}
+
+	geodata.ClearCache()
+
+	return nil
+}
+
+func UpdateGeoDatabases() error {
+	log.Infoln("[GEO] Start updating GEO database")
+
+	updateGeoMux.Lock()
+
+	if UpdatingGeo.Load() {
+		updateGeoMux.Unlock()
+		return errors.New("GEO database is updating, skip")
+	}
+
+	UpdatingGeo.Store(true)
+	updateGeoMux.Unlock()
+
+	defer func() {
+		UpdatingGeo.Store(false)
+	}()
+
+	log.Infoln("[GEO] Updating GEO database")
+
+	if err := updateGeoDatabases(); err != nil {
+		log.Errorln("[GEO] update GEO database error: %s", err.Error())
+		return err
+	}
+
+	return nil
+}
+
+func getUpdateTime() (err error, time time.Time) {
+	var fileInfo os.FileInfo
+	if C.GeodataMode {
+		fileInfo, err = os.Stat(C.Path.GeoIP())
+		if err != nil {
+			return err, time
+		}
+	} else {
+		fileInfo, err = os.Stat(C.Path.MMDB())
+		if err != nil {
+			return err, time
+		}
+	}
+
+	return nil, fileInfo.ModTime()
+}
+
+func RegisterGeoUpdater() {
+	if C.GeoUpdateInterval <= 0 {
+		log.Errorln("[GEO] Invalid update interval: %d", C.GeoUpdateInterval)
+		return
+	}
+
+	ticker := time.NewTicker(time.Duration(C.GeoUpdateInterval) * time.Hour)
+	defer ticker.Stop()
+
+	log.Infoln("[GEO] update GEO database every %d hours", C.GeoUpdateInterval)
+	go func() {
+		err, lastUpdate := getUpdateTime()
+		if err != nil {
+			log.Errorln("[GEO] Get GEO database update time error: %s", err.Error())
+			return
+		}
+
+		log.Infoln("[GEO] last update time %s", lastUpdate)
+		if lastUpdate.Add(time.Duration(C.GeoUpdateInterval) * time.Hour).Before(time.Now()) {
+			log.Infoln("[GEO] Database has not been updated for %v, update now", time.Duration(C.GeoUpdateInterval)*time.Hour)
+			if err := UpdateGeoDatabases(); err != nil {
+				log.Errorln("[GEO] Failed to update GEO database: %s", err.Error())
+				return
+			}
+		}
+
+		for range ticker.C {
+			if err := UpdateGeoDatabases(); err != nil {
+				log.Errorln("[GEO] Failed to update GEO database: %s", err.Error())
+				return
+			}
+		}
+	}()
+}

component/updater/update_ui.go

@@ -0,0 +1,145 @@
+package updater
+
+import (
+	"archive/zip"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	C "github.com/metacubex/mihomo/constant"
+)
+
+var (
+	ExternalUIURL    string
+	ExternalUIPath   string
+	ExternalUIFolder string
+	ExternalUIName   string
+)
+var (
+	ErrIncompleteConf = errors.New("ExternalUI configure incomplete")
+)
+var xdMutex sync.Mutex
+
+func UpdateUI() error {
+	xdMutex.Lock()
+	defer xdMutex.Unlock()
+
+	err := prepare_ui()
+	if err != nil {
+		return err
+	}
+
+	data, err := downloadForBytes(ExternalUIURL)
+	if err != nil {
+		return fmt.Errorf("can't download  file: %w", err)
+	}
+
+	saved := path.Join(C.Path.HomeDir(), "download.zip")
+	if err = saveFile(data, saved); err != nil {
+		return fmt.Errorf("can't save zip file: %w", err)
+	}
+	defer os.Remove(saved)
+
+	err = cleanup(ExternalUIFolder)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			return fmt.Errorf("cleanup exist file error: %w", err)
+		}
+	}
+
+	unzipFolder, err := unzip(saved, C.Path.HomeDir())
+	if err != nil {
+		return fmt.Errorf("can't extract zip file: %w", err)
+	}
+
+	err = os.Rename(unzipFolder, ExternalUIFolder)
+	if err != nil {
+		return fmt.Errorf("can't rename folder: %w", err)
+	}
+	return nil
+}
+
+func prepare_ui() error {
+	if ExternalUIPath == "" || ExternalUIURL == "" {
+		return ErrIncompleteConf
+	}
+
+	if ExternalUIName != "" {
+		ExternalUIFolder = filepath.Clean(path.Join(ExternalUIPath, ExternalUIName))
+		if _, err := os.Stat(ExternalUIPath); os.IsNotExist(err) {
+			if err := os.MkdirAll(ExternalUIPath, os.ModePerm); err != nil {
+				return err
+			}
+		}
+	} else {
+		ExternalUIFolder = ExternalUIPath
+	}
+
+	return nil
+}
+
+func unzip(src, dest string) (string, error) {
+	r, err := zip.OpenReader(src)
+	if err != nil {
+		return "", err
+	}
+	defer r.Close()
+	var extractedFolder string
+	for _, f := range r.File {
+		fpath := filepath.Join(dest, f.Name)
+		if !strings.HasPrefix(fpath, filepath.Clean(dest)+string(os.PathSeparator)) {
+			return "", fmt.Errorf("invalid file path: %s", fpath)
+		}
+		if f.FileInfo().IsDir() {
+			os.MkdirAll(fpath, os.ModePerm)
+			continue
+		}
+		if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
+			return "", err
+		}
+		outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
+		if err != nil {
+			return "", err
+		}
+		rc, err := f.Open()
+		if err != nil {
+			return "", err
+		}
+		_, err = io.Copy(outFile, rc)
+		outFile.Close()
+		rc.Close()
+		if err != nil {
+			return "", err
+		}
+		if extractedFolder == "" {
+			extractedFolder = filepath.Dir(fpath)
+		}
+	}
+	return extractedFolder, nil
+}
+
+func cleanup(root string) error {
+	if _, err := os.Stat(root); os.IsNotExist(err) {
+		return nil
+	}
+	return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if info.IsDir() {
+			if err := os.RemoveAll(path); err != nil {
+				return err
+			}
+		} else {
+			if err := os.Remove(path); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}

component/updater/utils.go

@@ -0,0 +1,90 @@
+package updater
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"time"
+
+	mihomoHttp "github.com/metacubex/mihomo/component/http"
+	C "github.com/metacubex/mihomo/constant"
+
+	"golang.org/x/exp/constraints"
+)
+
+func downloadForBytes(url string) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*90)
+	defer cancel()
+	resp, err := mihomoHttp.HttpRequest(ctx, url, http.MethodGet, http.Header{"User-Agent": {C.UA}}, nil)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	return io.ReadAll(resp.Body)
+}
+
+func saveFile(bytes []byte, path string) error {
+	return os.WriteFile(path, bytes, 0o644)
+}
+
+// LimitReachedError records the limit and the operation that caused it.
+type LimitReachedError struct {
+	Limit int64
+}
+
+// Error implements the [error] interface for *LimitReachedError.
+//
+// TODO(a.garipov): Think about error string format.
+func (lre *LimitReachedError) Error() string {
+	return fmt.Sprintf("attempted to read more than %d bytes", lre.Limit)
+}
+
+// limitedReader is a wrapper for [io.Reader] limiting the input and dealing
+// with errors package.
+type limitedReader struct {
+	r     io.Reader
+	limit int64
+	n     int64
+}
+
+// Read implements the [io.Reader] interface.
+func (lr *limitedReader) Read(p []byte) (n int, err error) {
+	if lr.n == 0 {
+		return 0, &LimitReachedError{
+			Limit: lr.limit,
+		}
+	}
+
+	p = p[:Min(lr.n, int64(len(p)))]
+
+	n, err = lr.r.Read(p)
+	lr.n -= int64(n)
+
+	return n, err
+}
+
+// LimitReader wraps Reader to make it's Reader stop with ErrLimitReached after
+// n bytes read.
+func LimitReader(r io.Reader, n int64) (limited io.Reader, err error) {
+	if n < 0 {
+		return nil, &updateError{Message: "limit must be non-negative"}
+	}
+
+	return &limitedReader{
+		r:     r,
+		limit: n,
+		n:     n,
+	}, nil
+}
+
+// Min returns the smaller of x or y.
+func Min[T constraints.Integer | ~string](x, y T) (res T) {
+	if x < y {
+		return x
+	}
+
+	return y
+}