robogg133/packets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: robogg133:afc19b6e4df027f1efb1cf6eb4118bdc2cefab1a
Branches Tags
robogg133:main robogg133:v2 robogg133:test robogg133:v1
..
compare: robogg133:test
Branches Tags
robogg133:main robogg133:v2 robogg133:test robogg133:v1

8 Commits
afc19b6e4d ... test

Author SHA1 Message Date
robogg133
3b6a582937 added a package in newer format 2025-10-25 22:43:24 -03:00
roboogg133
9b15d014c1 package dependency test 2025-10-11 19:14:37 -03:00
roboogg133
39d315c09e removing old package format 2025-10-05 11:24:41 -03:00
roboogg133
3f5a0e3898 new package format 2025-10-05 11:23:56 -03:00
roboogg133
e556b4c982 removing source code from test branch 2025-08-20 15:35:33 -03:00
roboogg133
bd63bf8b1f test package compiling 2025-08-20 15:30:04 -03:00
roboogg133
f75808b8c4 removed files from test branch 2025-08-20 15:29:25 -03:00
roboogg133
2abcec6384 test package 2025-08-20 14:45:11 -03:00
18 changed files with 0 additions and 2138 deletions
Expand all files Collapse all files

36
cmd/httpsocket/main.go
View File

@@ -1,36 +0,0 @@
package main
import (
"fmt"
"log"
"net/http"
"os"
"packets/configs"
"packets/internal/consts"
"path/filepath"
)
type ConfigTOML struct {
Config struct {
DefaultHttpPort int `toml:"httpPort"`
DefaultCacheDir string `toml:"cacheDir"`
} `toml:"Config"`
}
func main() {
cfg, err := configs.GetConfigTOML()
if err != nil {
log.Fatal(err)
}
pid := os.Getpid()
if err := os.WriteFile(filepath.Join(consts.DefaultLinux_d, "http.pid"), []byte(fmt.Sprint(pid)), 0664); err != nil {
fmt.Println("error saving subprocess pid", err)
}
fs := http.FileServer(http.Dir(cfg.Config.Cache_d))
http.Handle("/", fs)
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", cfg.Config.HttpPort), nil))
}

621
cmd/packets/main.go
View File

@@ -1,621 +0,0 @@
package main
import (
"bufio"
"database/sql"
_ "embed"
"fmt"
"log"
"os"
"path/filepath"
"sync"
"packets/configs"
"packets/internal/consts"
"packets/internal/utils"
packets "packets/pkg"
"github.com/pelletier/go-toml/v2"
"github.com/spf13/cobra"
_ "modernc.org/sqlite"
)
// init is doing some verifications
func init() {
log.SetPrefix("error: ")
log.SetFlags(0)
//log.SetFlags(log.Lshortfile)
_, err := os.Stat(consts.DefaultLinux_d)
if os.IsNotExist(err) {
err := os.Mkdir(consts.DefaultLinux_d, 0777)
if err != nil {
if os.IsPermission(err) {
log.Fatal("can't create packets root directory, please run as root")
} else {
log.Fatal(err)
}
}
}
_, err = os.Stat(filepath.Join(consts.DefaultLinux_d, "index.db"))
if err != nil {
if os.IsNotExist(err) {
if len(os.Args) > 1 && os.Args[0] != "sync" {
} else {
fmt.Println("index.db does not exist, try to use \"packets sync\"")
}
} else {
log.Fatal(err)
}
}
_, err = os.Stat(filepath.Join(consts.DefaultLinux_d, "installed.db"))
if err != nil {
if os.IsNotExist(err) {
db, err := sql.Open("sqlite", filepath.Join(consts.DefaultLinux_d, "installed.db"))
if err != nil {
log.Fatal(db)
}
defer db.Close()
if _, err := db.Exec(consts.InstalledDatabaseSchema); err != nil {
log.Fatal(err)
}
} else {
log.Fatal(err)
}
}
_, err = os.Stat(filepath.Join(consts.DefaultLinux_d, "config.toml"))
if os.IsNotExist(err) {
f, err := os.Create(filepath.Join(consts.DefaultLinux_d, "config.toml"))
if err != nil {
log.Fatal(err)
}
defer f.Close()
encoder := toml.NewEncoder(f)
cfg, err := configs.DefaultConfigTOML()
if err != nil {
log.Fatal(err)
}
if err = encoder.Encode(*cfg); err != nil {
log.Fatal(err)
}
}
}
// COBRA CMDS
var rootCmd = &cobra.Command{Use: "packets"}
var syncCmd = &cobra.Command{
Use: "sync [url]",
Args: cobra.MaximumNArgs(1),
Short: "Syncronizes with an remote index.db, and check if the data dir is changed",
Run: func(cmd *cobra.Command, args []string) {
_, err := os.Stat(consts.IndexDB)
if err != nil {
if !os.IsNotExist(err) {
log.Fatal("index.db does not exist, try to use \"packets sync\"")
}
}
f, err := os.OpenFile(consts.IndexDB, os.O_WRONLY, 0)
if err != nil {
log.Fatalf("can't open to write [ %s ]. Are you running packets as root?\n", consts.IndexDB)
}
f.Close()
syncUrl := consts.DefaultSyncUrl
if len(args) > 0 {
syncUrl = args[0]
}
DBB, err := utils.GetFileHTTP(syncUrl)
if err != nil {
log.Fatal(err)
}
if err := os.WriteFile(consts.IndexDB, DBB, 0774); err != nil {
log.Fatal(err)
}
fmt.Printf(":: Sucessifully syncronized index.db with [ %s ]\n", syncUrl)
os.Exit(0)
},
}
type Quer1 struct {
Name string
Version string
Description string
}
var installCmd = &cobra.Command{
Use: "install {package} [packages...]",
Short: "Install a package",
Args: cobra.MinimumNArgs(1),
Run: func(cmd *cobra.Command, args []string) {
_, err := os.Stat(consts.IndexDB)
if err != nil {
if !os.IsNotExist(err) {
log.Fatal("index.db does not exist, try to use \"packets sync\"")
}
}
if os.Getuid() != 0 {
log.Fatal("you must run this command as root")
}
db, err := sql.Open("sqlite", consts.IndexDB)
if err != nil {
fmt.Println(err)
}
defer db.Close()
cfg, err := configs.GetConfigTOML()
if err != nil {
log.Fatal(err)
}
for _, inputName := range args {
var exist bool
err := db.QueryRow("SELECT EXISTS(SELECT 1 FROM packages WHERE name = ?)", inputName).Scan(&exist)
if err != nil {
if err != sql.ErrNoRows {
log.Panic(err)
}
}
if exist {
installed, err := utils.CheckIfPackageInstalled(inputName)
if err != nil {
log.Fatal(err)
}
if installed {
log.Printf("package %s is already installed\n", inputName)
continue
}
fmt.Printf("Checking dependencies of (%s)\n", inputName)
dependenciesRaw, err := utils.GetDependencies(db, inputName)
if err != nil {
log.Fatal(err)
}
dependencies, err := utils.ResolvDependencies(dependenciesRaw)
if err != nil {
log.Fatal(err)
}
if len(dependencies) > 0 {
var wg sync.WaitGroup
var mu sync.Mutex
fmt.Printf(":: Packets will install %s and %d dependencies\nPackages to install:\n", inputName, len(dependencies))
fmt.Println(dependencies)
fmt.Println("Are you sure? (y/N)")
var a string
fmt.Scanf("%s", &a)
if a != "y" && a != "Y" {
os.Exit(1)
}
for _, depn := range dependencies {
wg.Add(1)
go AyncFullInstall(depn, cfg.Config.StorePackages, filepath.Join(cfg.Config.Data_d, inputName), &wg, &mu)
}
wg.Wait()
}
fmt.Printf("Downloading (%s) \n", inputName)
p, err := utils.GetPackage(inputName)
if err != nil {
log.Fatal(err)
}
fmt.Printf(":: Installing (%s) \n", inputName)
if err := packets.InstallPackage(p.PackageF, filepath.Join(cfg.Config.Data_d, inputName)); err != nil {
log.Fatal(err)
}
if cfg.Config.StorePackages {
_, err := p.Write()
if err != nil {
log.Fatal(err)
}
err = p.AddToInstalledDB(1, filepath.Join(cfg.Config.Data_d, inputName))
if err != nil {
log.Fatal(err)
}
} else {
err := p.AddToInstalledDB(0, filepath.Join(cfg.Config.Data_d, inputName))
if err != nil {
log.Fatal(err)
}
}
continue
}
rows, err := db.Query("SELECT id, version, description FROM packages WHERE query_name = ?", inputName)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
var pkgs []Quer1
for rows.Next() {
var q Quer1
if err := rows.Scan(&q.Name, &q.Version, &q.Description); err != nil {
log.Panic(err)
}
pkgs = append(pkgs, q)
}
switch len(pkgs) {
case 0:
log.Fatalf("can't find any results for (%s)\n", inputName)
case 1:
fmt.Printf(":: Founded 1 package for %s \n", inputName)
installed, err := utils.CheckIfPackageInstalled(pkgs[0].Name)
if err != nil {
log.Fatal(err)
}
if installed {
log.Printf("Package %s is already installed\n", pkgs[0].Name)
continue
}
fmt.Printf("Checking dependencies of (%s)\n", pkgs[0].Name)
dependenciesRaw, err := utils.GetDependencies(db, inputName)
if err != nil {
log.Fatal(err)
}
dependencies, err := utils.ResolvDependencies(dependenciesRaw)
if err != nil {
log.Fatal(err)
}
if len(dependencies) > 0 {
var wg sync.WaitGroup
var mu sync.Mutex
fmt.Printf(":: Packets will install %s and %d dependencies\nPackages to install:\n", pkgs[0].Name, len(dependencies))
fmt.Println(dependencies)
fmt.Println("Are you sure? (y/N)")
var a string
fmt.Scanf("%s", &a)
if a != "y" && a != "Y" {
os.Exit(1)
}
for _, depn := range dependencies {
wg.Add(1)
go AyncFullInstall(depn, cfg.Config.StorePackages, filepath.Join(cfg.Config.Data_d, inputName), &wg, &mu)
}
wg.Wait()
}
fmt.Printf("Downloading %s \n", pkgs[0].Name)
p, err := utils.GetPackage(pkgs[0].Name)
if err != nil {
log.Fatal(err)
}
cfg, err := configs.GetConfigTOML()
if err != nil {
log.Fatal(err)
}
fmt.Printf(":: Installing %s \n", pkgs[0].Name)
if err := packets.InstallPackage(p.PackageF, filepath.Join(cfg.Config.Data_d, pkgs[0].Name)); err != nil {
log.Fatal(err)
}
if cfg.Config.StorePackages {
_, err := p.Write()
if err != nil {
log.Fatal(err)
}
err = p.AddToInstalledDB(1, filepath.Join(cfg.Config.Data_d, pkgs[0].Name))
if err != nil {
log.Fatal(err)
}
} else {
err := p.AddToInstalledDB(0, filepath.Join(cfg.Config.Data_d, pkgs[0].Name))
if err != nil {
log.Fatal(err)
}
}
continue
default:
fmt.Printf(":: Founded %d packages for (%s)\n Select 1 to install\n", len(pkgs), inputName)
for i, q := range pkgs {
fmt.Printf("[%d] %s : %s\n %s\n", i, q.Name, q.Version, q.Description)
}
var choice int
optionagain:
fmt.Print(">> ")
fmt.Fscan(bufio.NewReader(os.Stdin), &choice)
if choice > len(pkgs) || choice < 0 {
fmt.Println("invalid option")
goto optionagain
}
installed, err := utils.CheckIfPackageInstalled(pkgs[choice].Name)
if err != nil {
log.Fatal(err)
}
if installed {
log.Printf("package %s is already installed\n", pkgs[choice].Name)
continue
}
fmt.Printf("Checking dependencies of (%s)\n", pkgs[choice].Name)
dependenciesRaw, err := utils.GetDependencies(db, inputName)
if err != nil {
log.Fatal(err)
}
dependencies, err := utils.ResolvDependencies(dependenciesRaw)
if err != nil {
log.Fatal(err)
}
if len(dependencies) > 0 {
var wg sync.WaitGroup
var mu sync.Mutex
fmt.Printf(":: Packets will install %s and %d dependencies\nPackages to install:\n", pkgs[choice].Name, len(dependencies))
fmt.Println(dependencies)
fmt.Println("Are you sure? (y/N)")
var a string
fmt.Scanf("%s", &a)
if a != "y" && a != "Y" {
os.Exit(1)
}
for _, depn := range dependencies {
wg.Add(1)
go AyncFullInstall(depn, cfg.Config.StorePackages, filepath.Join(cfg.Config.Data_d, pkgs[choice].Name), &wg, &mu)
}
wg.Wait()
}
fmt.Printf("Downloading %s \n", pkgs[choice].Name)
p, err := utils.GetPackage(pkgs[choice].Name)
if err != nil {
log.Fatal(err)
}
cfg, err := configs.GetConfigTOML()
if err != nil {
log.Fatal(err)
}
fmt.Printf(":: Installing (%s) \n", pkgs[choice].Name)
if err := packets.InstallPackage(p.PackageF, filepath.Join(cfg.Config.Data_d, pkgs[choice].Name)); err != nil {
log.Fatal(err)
}
if cfg.Config.StorePackages {
_, err := p.Write()
if err != nil {
log.Fatal(err)
}
err = p.AddToInstalledDB(1, filepath.Join(cfg.Config.Data_d, pkgs[choice].Name))
if err != nil {
log.Fatal(err)
}
} else {
err := p.AddToInstalledDB(0, filepath.Join(cfg.Config.Data_d, pkgs[choice].Name))
if err != nil {
log.Fatal(err)
}
}
continue
}
}
},
}
var removeCmd = &cobra.Command{
Use: "remove {package name}[package name...] ",
Args: cobra.MinimumNArgs(1),
Short: "Remove a package from the given names",
Run: func(cmd *cobra.Command, args []string) {
if os.Getuid() != 0 {
log.Fatal("you must run this command as root")
}
fmt.Print("WARNING: This command will remove permanently this packages, are you sure? (y/N) ")
var a string
fmt.Scanf("%s", &a)
if a != "y" && a != "Y" {
os.Exit(1)
}
for _, pkgName := range args {
installed, err := utils.CheckIfPackageInstalled(pkgName)
if err != nil {
log.Fatal(err)
}
if installed {
db, err := sql.Open("sqlite", consts.InstalledDB)
if err != nil {
log.Fatal(err)
}
var packageDir string
if err := db.QueryRow("SELECT package_d FROM packages WHERE query_name = ? OR id = ?", pkgName, pkgName).Scan(&packageDir); err != nil {
log.Fatal(err)
}
f, err := os.Open(filepath.Join(packageDir, "manifest.toml"))
if err != nil {
log.Fatal(err)
}
manifest, err := utils.ManifestFileRead(f)
if err != nil {
log.Fatal(err)
}
fmt.Println(":: Removing", pkgName)
packets.ExecuteRemoveScript(filepath.Join(packageDir, manifest.Hooks.Remove))
if err := os.RemoveAll(packageDir); err != nil {
log.Fatal(err)
}
if err := utils.RemoveFromInstalledDB(pkgName); err != nil {
log.Fatal(err)
}
fmt.Println("Sucessifully removed")
os.Exit(0)
}
log.Fatalf("%s not installed", pkgName)
}
},
}
var listCmd = &cobra.Command{
Use: "list",
Args: cobra.NoArgs,
Short: "List all installed packages",
Run: func(cmd *cobra.Command, args []string) {
db, err := sql.Open("sqlite", consts.InstalledDB)
if err != nil {
log.Fatal(err)
}
defer db.Close()
var count int
if err := db.QueryRow("SELECT COUNT(*) FROM packages").Scan(&count); err != nil {
log.Fatal(err)
}
rows, err := db.Query("SELECT query_name, id, version, description, package_d, os, arch FROM packages")
if err != nil {
log.Fatal(err)
}
defer rows.Close()
fmt.Printf(":: Listing all %d packages installed:\n\n", count)
for rows.Next() {
var queryName, name, version, description, packageDir, os, arch string
if err := rows.Scan(&queryName, &name, &version, &description, &packageDir, &os, &arch); err != nil {
log.Fatal(err)
}
fmt.Printf(" Package %s \n ├──Id: %s\n ├──Version: %s \n ├──Package dir: %s\n ├──OS: %s\n ├──Arch: %s\n └──Description: %s\n", queryName, name, version, packageDir, os, arch, description)
}
},
}
var searchCmd = &cobra.Command{
Use: "search [query]",
Args: cobra.MaximumNArgs(1),
Short: "Search for packages in the index.db",
Run: func(cmd *cobra.Command, args []string) {
db, err := sql.Open("sqlite", consts.IndexDB)
if err != nil {
log.Fatal(err)
}
defer db.Close()
var count int
if err := db.QueryRow("SELECT COUNT(*) FROM packages").Scan(&count); err != nil {
log.Fatal(err)
}
var rows *sql.Rows
if len(args) > 0 {
rows, err = db.Query("SELECT query_name, id, version, description, os, arch FROM packages WHERE name LIKE ? OR description LIKE ? OR query_name LIKE ?", args[0], args[0], args[0])
if err != nil {
log.Fatal(err)
}
defer rows.Close()
} else {
rows, err = db.Query("SELECT query_name, id, version, description, os, arch FROM packages")
if err != nil {
log.Fatal(err)
}
defer rows.Close()
}
fmt.Printf(":: Listing all %d packages:\n\n", count)
for rows.Next() {
var queryName, name, version, description, os, arch string
if err := rows.Scan(&queryName, &name, &version, &description, &os, &arch); err != nil {
log.Fatal(err)
}
fmt.Printf(" Package %s \n ├──Query name: %s\n ├──Version: %s \n ├──OS: %s\n ├──Arch: %s\n └──Description: %s\n", name, queryName, version, os, arch, description)
}
},
}
func main() {
rootCmd.AddCommand(installCmd)
rootCmd.AddCommand(removeCmd)
rootCmd.AddCommand(syncCmd)
rootCmd.AddCommand(listCmd)
rootCmd.AddCommand(searchCmd)
rootCmd.Execute()
}
func AyncFullInstall(dep string, storePackages bool, installPath string, wg *sync.WaitGroup, mu *sync.Mutex) {
defer wg.Done()
fmt.Printf(" downloading %s \n", dep)
p, err := utils.GetPackage(dep)
if err != nil {
log.Fatal(err)
}
fmt.Printf(" installing %s \n", dep)
if err := packets.InstallPackage(p.PackageF, installPath); err != nil {
log.Fatal(err)
}
if storePackages {
_, err := p.Write()
if err != nil {
log.Fatal(err)
return
}
mu.Lock()
defer mu.Unlock()
err = p.AddToInstalledDB(1, installPath)
if err != nil {
log.Fatal(err)
return
}
} else {
mu.Lock()
defer mu.Unlock()
err := p.AddToInstalledDB(0, installPath)
if err != nil {
log.Println(err)
return
}
}
}

58
cmd/udpsocket/main.go
View File

@@ -1,58 +0,0 @@
package main
import (
"fmt"
"log"
"net"
"os"
"packets/configs"
"packets/internal/consts"
"path/filepath"
"strings"
)
func CheckDownloaded(filename string) bool {
cfg, err := configs.GetConfigTOML()
if err != nil {
log.Fatal(err)
}
_, err = os.Stat(filepath.Join(cfg.Config.Cache_d, filename))
return err == nil
}
func main() {
pid := os.Getpid()
if err := os.WriteFile(filepath.Join(consts.DefaultLinux_d, "udp.pid"), []byte(fmt.Sprint(pid)), 0664); err != nil {
fmt.Println("error saving subprocess pid", err)
}
cfg, err := configs.GetConfigTOML()
if err != nil {
log.Fatal(err)
}
addr := net.UDPAddr{IP: net.IPv4zero, Port: 1333}
conn, err := net.ListenUDP("udp", &addr)
if err != nil {
log.Fatal(err)
}
defer conn.Close()
buf := make([]byte, 1500)
for {
n, remote, err := conn.ReadFromUDP(buf)
if err != nil {
log.Println("error creating udp socket", err)
}
msg := string(buf[:n])
if !strings.HasPrefix(msg, "Q:") {
continue
}
filename := strings.TrimPrefix(msg, "Q:")
if CheckDownloaded(filename) {
reply := fmt.Sprintf("H:%s:%d", filename, cfg.Config.HttpPort)
conn.WriteToUDP([]byte(reply), remote)
}
}
}

60
configs/main.go
View File

@@ -1,60 +0,0 @@
package configs
import (
"os"
"packets/internal/consts"
"path/filepath"
"github.com/pelletier/go-toml/v2"
)
// DefaultConfigTOML returns configTOML struct with all default values and create all directorys
func DefaultConfigTOML() (*ConfigTOML, error) {
var config ConfigTOML
_, err := os.Stat(consts.DefaultCache_d)
if err != nil {
if os.IsNotExist(err) {
err := os.MkdirAll(consts.DefaultCache_d, 0666)
if err != nil {
return nil, err
}
}
}
_, err = os.Stat(consts.DefaultCache_d)
if err != nil {
if os.IsNotExist(err) {
err := os.MkdirAll(consts.DefaultData_d, 0644)
if err != nil {
return nil, err
}
}
}
config.Config.Cache_d = consts.DefaultCache_d
config.Config.Data_d = consts.DefaultData_d
config.Config.HttpPort = consts.DefaultHttpPort
config.Config.Bin_d = consts.DefaultBin_d
config.Config.StorePackages = true
return &config, nil
}
// GetConfigTOML return settings values
func GetConfigTOML() (*ConfigTOML, error) {
f, err := os.Open(filepath.Join(consts.DefaultLinux_d, "config.toml"))
if err != nil {
return nil, err
}
decoder := toml.NewDecoder(f)
var config ConfigTOML
if err := decoder.Decode(&config); err != nil {
return nil, err
}
return &config, nil
}

26
configs/structs.go
View File

@@ -1,26 +0,0 @@
package configs
type Manifest struct {
Info struct {
Name string `toml:"name"`
Id string `toml:"id"`
Version string `toml:"version"`
Description string `toml:"description"`
Dependencies map[string]string `toml:"dependencies"`
Author string `toml:"author"`
} `toml:"Info"`
Hooks struct {
Install string `toml:"install"`
Remove string `toml:"remove"`
} `toml:"Hooks"`
}
type ConfigTOML struct {
Config struct {
HttpPort int `toml:"httpPort"`
Cache_d string `toml:"cache_d"`
Data_d string `toml:"data_d"`
Bin_d string `toml:"bin_d"`
StorePackages bool `toml:"store_packages"`
} `toml:"Config"`
}

47
doc/indexdbSchema.txt
View File

@@ -1,47 +0,0 @@
CREATE TABLE packages (
id TEXT NOT NULL UNIQUE PRIMARY KEY,
query_name TEXT NOT NULL,
version TEXT NOT NULL,
serial INTEGER NOT NULL,
description TEXT NOT NULL,
image_url TEXT NOT NULL,
package_url TEXT NOT NULL,
public_key BLOB NOT NULL,
signature BLOB NOT NULL,
author TEXT NOT NULL,
author_verified INTEGER NOT NULL DEFAULT 0,
arch TEXT NOT NULL,
os TEXT NOT NULL,
size INTEGER NOT NULL DEFAULT 0,
UNIQUE(query_name, version),
UNIQUE(query_name, serial)
);
CREATE TABLE package_dependencies(
package_id TEXT NOT NULL,
dependency_name TEXT NOT NULL,
version_constraint TEXT NOT NULL,
PRIMARY KEY (package_id, dependency_name)
);
CREATE INDEX index_dependency_name ON package_dependencies(dependency_name);
CREATE TABLE IF NOT EXISTS packages (
query_name TEXT NOT NULL UNIQUE PRIMARY KEY,
id TEXT NOT NULL UNIQUE,
version TEXT NOT NULL,
dependencies TEXT NOT NULL DEFAULT '',
description TEXT NOT NULL,
package_d TEXT NOT NULL,
filename TEXT NOT NULL,
os TEXT NOT NULL,
arch TEXT NOT NULL,
in_cache INTEGER NOT NULL DEFAULT 1,
serial INTEGER NOT NULL,
UNIQUE(query_name, version),
UNIQUE(query_name, serial)
);

55
go.mod
View File

@@ -1,55 +0,0 @@
module packets
go 1.25.1
require (
github.com/gin-gonic/gin v1.11.0
github.com/klauspost/compress v1.18.0
github.com/pelletier/go-toml/v2 v2.2.4
github.com/spf13/cobra v1.10.1
github.com/yuin/gopher-lua v1.1.1
golang.org/x/net v0.44.0
modernc.org/sqlite v1.38.2
)
require (
github.com/bytedance/sonic v1.14.0 // indirect
github.com/bytedance/sonic/loader v0.3.0 // indirect
github.com/cloudwego/base64x v0.1.6 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/gabriel-vasile/mimetype v1.4.8 // indirect
github.com/gin-contrib/sse v1.1.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.27.0 // indirect
github.com/goccy/go-json v0.10.2 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect
github.com/google/uuid v1.6.0 // indirect
github.com/inconshreveable/mousetrap v1.1.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/ncruces/go-strftime v0.1.9 // indirect
github.com/quic-go/qpack v0.5.1 // indirect
github.com/quic-go/quic-go v0.54.0 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
github.com/spf13/pflag v1.0.10 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.3.0 // indirect
go.uber.org/mock v0.5.0 // indirect
golang.org/x/arch v0.20.0 // indirect
golang.org/x/crypto v0.42.0 // indirect
golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect
golang.org/x/mod v0.27.0 // indirect
golang.org/x/sync v0.17.0 // indirect
golang.org/x/sys v0.36.0 // indirect
golang.org/x/text v0.29.0 // indirect
golang.org/x/tools v0.36.0 // indirect
google.golang.org/protobuf v1.36.9 // indirect
modernc.org/libc v1.66.3 // indirect
modernc.org/mathutil v1.7.1 // indirect
modernc.org/memory v1.11.0 // indirect
)

139
go.sum
View File

@@ -1,139 +0,0 @@
github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=
github.com/bytedance/sonic v1.14.0/go.mod h1:WoEbx8WTcFJfzCe0hbmyTGrfjt8PzNEBdxlNUO24NhA=
github.com/bytedance/sonic/loader v0.3.0 h1:dskwH8edlzNMctoruo8FPTJDF3vLtDT0sXZwvZJyqeA=
github.com/bytedance/sonic/loader v0.3.0/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/gabriel-vasile/mimetype v1.4.8 h1:FfZ3gj38NjllZIeJAmMhr+qKL8Wu+nOoI3GqacKw1NM=
github.com/gabriel-vasile/mimetype v1.4.8/go.mod h1:ByKUIKGjh1ODkGM1asKUbQZOLGrPjydw3hYPU2YU9t8=
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
github.com/gin-gonic/gin v1.11.0/go.mod h1:+iq/FyxlGzII0KHiBGjuNn4UNENUlKbGlNmc+W50Dls=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
github.com/quic-go/quic-go v0.54.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
github.com/ugorji/go/codec v1.3.0/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=
golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
modernc.org/cc/v4 v4.26.2 h1:991HMkLjJzYBIfha6ECZdjrIYz2/1ayr+FL8GN+CNzM=
modernc.org/cc/v4 v4.26.2/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
modernc.org/fileutil v1.3.8 h1:qtzNm7ED75pd1C7WgAGcK4edm4fvhtBsEiI/0NQ54YM=
modernc.org/fileutil v1.3.8/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
modernc.org/libc v1.66.3 h1:cfCbjTUcdsKyyZZfEUKfoHcP3S0Wkvz3jgSzByEWVCQ=
modernc.org/libc v1.66.3/go.mod h1:XD9zO8kt59cANKvHPXpx7yS2ELPheAey0vjIuZOhOU8=
modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
modernc.org/sqlite v1.38.2 h1:Aclu7+tgjgcQVShZqim41Bbw9Cho0y/7WzYptXqkEek=
modernc.org/sqlite v1.38.2/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

43
internal/consts/consts.go
View File

@@ -1,43 +0,0 @@
package consts
import "time"
const (
DefaultLinux_d = "/etc/packets"
DefaultCache_d = "/var/cache/packets"
DefaultHttpPort = 9123
DefaultBin_d = "/usr/local/bin"
DefaultData_d = "/opt/packets"
LANDeadline = 2 * time.Second
IndexDB = "/etc/packets/index.db"
InstalledDB = "/etc/packets/installed.db"
DefaultSyncUrl = "https://servidordomal.fun/index.db"
)
const InstalledDatabaseSchema = `CREATE TABLE IF NOT EXISTS packages (
query_name TEXT NOT NULL UNIQUE PRIMARY KEY,
id TEXT NOT NULL UNIQUE,
version TEXT NOT NULL,
dependencies TEXT NOT NULL DEFAULT '',
description TEXT NOT NULL,
package_d TEXT NOT NULL,
filename TEXT NOT NULL,
os TEXT NOT NULL,
arch TEXT NOT NULL,
in_cache INTEGER NOT NULL DEFAULT 1,
serial INTEGER NOT NULL,
UNIQUE(query_name, version),
UNIQUE(query_name, serial)
);
CREATE TABLE package_dependencies(
package_id TEXT NOT NULL,
dependency_name TEXT NOT NULL,
version_constraint TEXT NOT NULL,
PRIMARY KEY (package_id, dependency_name)
);
CREATE INDEX index_dependency_name ON package_dependencies(dependency_name);
`

9
internal/errors/errors.go
View File

@@ -1,9 +0,0 @@
package errors_packets
import "errors"
var (
ErrResponseNot200OK = errors.New("the request is not 200, download failed")
ErrCantFindManifestTOML = errors.New("can't find manifest.toml when trying to read the packagefile")
ErrInvalidSignature = errors.New("the signature is invalid")
)

80
internal/utils/lan.go
View File

@@ -1,80 +0,0 @@
package utils
import (
"fmt"
"net"
"packets/internal/consts"
"strconv"
"strings"
"time"
"golang.org/x/net/ipv4"
)
type Peer struct {
IP net.IP
Port int
}
func BroadcastAddr(ip net.IP, mask net.IPMask) net.IP {
b := make(net.IP, len(ip))
for i := range ip {
b[i] = ip[i] | ^mask[i]
}
return b
}
func AskLAN(filename string) ([]Peer, error) {
var peers []Peer
query := []byte("Q:" + filename)
pc, err := net.ListenPacket("udp", ":0")
if err != nil {
return []Peer{}, err
}
defer pc.Close()
if pconn := ipv4.NewPacketConn(pc); pconn != nil {
_ = pconn.SetTTL(1)
}
ifaces, _ := net.Interfaces()
for _, ifc := range ifaces {
if ifc.Flags&net.FlagUp == 0 || ifc.Flags&net.FlagLoopback != 0 {
continue
}
addrs, _ := ifc.Addrs()
for _, a := range addrs {
ipnet, ok := a.(*net.IPNet)
if !ok || ipnet.IP.To4() == nil {
continue
}
bcast := BroadcastAddr(ipnet.IP.To4(), ipnet.Mask)
dst := &net.UDPAddr{IP: bcast, Port: 1333}
_, err = pc.WriteTo(query, dst)
if err != nil {
fmt.Printf(":: (%s) can't send to %s: %s\n", ifc.Name, bcast, err.Error())
}
}
}
_ = pc.SetDeadline(time.Now().Add(consts.LANDeadline))
buf := make([]byte, 1500)
for {
n, addr, err := pc.ReadFrom(buf)
if err != nil {
break
}
msg := string(buf[:n])
if strings.HasPrefix(msg, "H:"+filename) {
parts := strings.Split(msg, ":")
port, _ := strconv.Atoi(parts[2])
peers = append(peers, Peer{IP: addr.(*net.UDPAddr).IP, Port: port})
}
}
return peers, nil
}

36
internal/utils/lua/lua.go
View File

@@ -1,36 +0,0 @@
package utils_lua
import (
"packets/configs"
lua "github.com/yuin/gopher-lua"
)
func GetSandBox() (lua.LState, error) {
cfg, err := configs.GetConfigTOML()
if err != nil {
return *lua.NewState(), err
}
L := lua.NewState()
osObject := L.GetGlobal("os").(*lua.LTable)
L.SetGlobal("SAFE_MODE", lua.LTrue)
L.SetGlobal("PACKETS_DATADIR", lua.LString(cfg.Config.Data_d))
L.SetGlobal("packets_bin_dir", lua.LString(cfg.Config.Bin_d))
L.SetGlobal("path_join", L.NewFunction(Ljoin))
// Packets build functions
osObject.RawSetString("remove", L.NewFunction(LSafeRemove))
osObject.RawSetString("rename", L.NewFunction(LSafeRename))
osObject.RawSetString("copy", L.NewFunction(LSafeCopy))
osObject.RawSetString("symlink", L.NewFunction(LSymlink))
osObject.RawSetString("mkdir", L.NewFunction(LMkdir))
//ioObject.RawSetString("open", L.NewFunction(LOpen))
return *L, nil
}

260
internal/utils/lua/luafunctions.go
View File

@@ -1,260 +0,0 @@
package utils_lua
import (
"fmt"
"log"
"os"
"packets/configs"
"packets/internal/consts"
"packets/internal/utils"
"path/filepath"
"strings"
"github.com/pelletier/go-toml/v2"
lua "github.com/yuin/gopher-lua"
)
func IsSafe(str string) bool {
s, err := filepath.EvalSymlinks(filepath.Clean(str))
if err != nil {
s = filepath.Clean(str)
}
var cfg configs.ConfigTOML
f, err := os.Open(filepath.Join(consts.DefaultLinux_d, "config.toml"))
if err != nil {
log.Println("error here opening config.toml")
return false
}
defer f.Close()
decoder := toml.NewDecoder(f)
if err := decoder.Decode(&cfg); err != nil {
log.Println("error decoding")
return false
}
if strings.HasPrefix(s, cfg.Config.Data_d) || strings.HasPrefix(s, cfg.Config.Bin_d) {
return true
} else if strings.Contains(s, ".ssh") {
return false
} else if strings.HasPrefix(s, "/etc") {
return false
} else if strings.HasPrefix(s, "/usr") || strings.HasPrefix(s, "/bin") {
fmt.Println(s, "está dentro de usr")
return strings.HasPrefix(s, "/usr/share")
} else if strings.HasPrefix(s, "/var/mail") {
return false
} else if strings.HasPrefix(s, "/proc") {
return false
} else if strings.HasPrefix(s, "/sys") {
return false
} else if strings.HasPrefix(s, "/var/run") || strings.HasPrefix(s, "/run") {
return false
} else if strings.HasPrefix(s, "/tmp") {
return false
} else if strings.HasPrefix(s, "/dev") {
return false
} else if strings.HasPrefix(s, "/boot") {
return false
} else if strings.HasPrefix(s, "/home") {
if strings.Contains(s, "/Pictures") || strings.Contains(s, "/Videos") || strings.Contains(s, "/Documents") || strings.Contains(s, "/Downloads") {
return false
}
} else if strings.HasPrefix(s, "/lib") || strings.HasPrefix(s, "/lib64") || strings.HasPrefix(s, "/var/lib64") || strings.HasPrefix(s, "/lib") {
return false
} else if strings.HasPrefix(s, "/sbin") {
return false
} else if strings.HasPrefix(s, "/srv") {
return false
} else if strings.HasPrefix(s, "/mnt") {
return false
} else if strings.HasPrefix(s, "/media") {
return false
} else if strings.HasPrefix(s, "/snap") {
return false
}
return true
}
// lua functions
func LSafeRemove(L *lua.LState) int {
filename := L.CheckString(1)
fmt.Printf(" remove %s\n", filename)
err := os.RemoveAll(filename)
if err != nil {
L.Push(lua.LFalse)
L.Push(lua.LString(err.Error()))
return 2
}
L.Push(lua.LTrue)
L.Push(lua.LNil)
return 2
}
func LSafeRename(L *lua.LState) int {
oldname := L.CheckString(1)
newname := L.CheckString(2)
fmt.Printf(" move %s -> %s\n", oldname, newname)
if err := os.Rename(oldname, newname); err != nil {
L.Push(lua.LFalse)
L.Push(lua.LString(err.Error()))
return 2
}
L.Push(lua.LTrue)
return 1
}
func LSafeCopy(L *lua.LState) int {
oldname := L.CheckString(1)
newname := L.CheckString(2)
fmt.Printf(" copy %s -> %s\n", oldname, newname)
if err := utils.CopyDir(oldname, newname); err != nil {
L.Push(lua.LFalse)
L.Push(lua.LString(err.Error()))
return 2
}
L.Push(lua.LTrue)
L.Push(lua.LNil)
return 2
}
func LSymlink(L *lua.LState) int {
fileName := L.CheckString(1)
destination := L.CheckString(2)
fmt.Printf(" symlink %s -> %s\n", fileName, destination)
_ = os.RemoveAll(destination)
if err := os.Symlink(fileName, destination); err != nil {
L.Push(lua.LFalse)
L.Push(lua.LString(err.Error()))
return 2
}
L.Push(lua.LTrue)
L.Push(lua.LNil)
return 2
}
func modeFlags(mode string) int {
switch mode {
case "r", "rb":
return os.O_RDONLY
case "w", "wb":
return os.O_CREATE | os.O_WRONLY | os.O_TRUNC
case "a", "ab":
return os.O_CREATE | os.O_WRONLY | os.O_APPEND
case "r+", "r+b", "rb+", "br+":
return os.O_RDWR
case "w+", "w+b", "wb+", "bw+":
return os.O_CREATE | os.O_RDWR | os.O_TRUNC
case "a+", "a+b", "ab+", "ba+":
return os.O_CREATE | os.O_RDWR | os.O_APPEND
default:
return os.O_RDONLY
}
}
/*
func LOpen(L *lua.LState) int {
path := L.CheckString(1)
mode := L.OptString(2, "r")
file, err := os.OpenFile(path, modeFlags(mode), 0644)
if err != nil {
L.Push(lua.LNil)
L.Push(lua.LString(err.Error()))
return 2
}
ud := L.NewUserData()
ud.Value = file
L.SetMetatable(ud, L.GetTypeMetatable("file"))
L.Push(ud)
L.Push(lua.LNil)
return 2
}
*/
func Ljoin(L *lua.LState) int {
n := L.GetTop()
parts := make([]string, 0, n)
for i := 1; i <= n; i++ {
val := L.Get(i)
parts = append(parts, val.String())
}
result := filepath.Join(parts...)
L.Push(lua.LString(result))
return 1
}
func LMkdir(L *lua.LState) int {
path := L.CheckString(1)
perm := L.CheckInt(2)
fmt.Printf(" mkdir %s \n", path)
/*
if !IsSafe(path) {
L.Push(lua.LFalse)
L.Push(lua.LString("unsafe filepath"))
return 2
}
*/
if err := os.MkdirAll(path, os.FileMode(perm)); err != nil {
L.Push(lua.LFalse)
L.Push(lua.LString(err.Error()))
return 2
}
L.Push(lua.LTrue)
L.Push(lua.LNil)
return 2
}
func LError(L *lua.LState) int {
n := L.GetTop()
parts := make([]any, 0, n)
for i := 1; i <= n; i++ {
val := L.Get(i)
parts = append(parts, val.String())
}
Llogger().Panic(parts...)
return 0
}
func Llogger() *log.Logger { return log.New(os.Stderr, " script error: ", 0) }

504
internal/utils/utils.go
View File

@@ -1,504 +0,0 @@
package utils
import (
"archive/tar"
"bytes"
"crypto/ed25519"
"database/sql"
"fmt"
"io"
"log"
"net/http"
"os"
"os/exec"
"path"
"path/filepath"
"strconv"
"strings"
"syscall"
"packets/configs"
"packets/internal/consts"
errors_packets "packets/internal/errors"
"github.com/klauspost/compress/zstd"
"github.com/pelletier/go-toml/v2"
)
type Package struct {
PackageF []byte
Version string
ImageUrl string
QueryName string
Description string
Author string
AuthorVerified bool
OS string
Arch string
Filename string
Size int64
Dependencies map[string]string
Signature []byte
PublicKey ed25519.PublicKey
Manifest configs.Manifest
Serial int
}
func GetFileHTTP(url string) ([]byte, error) {
resp, err := http.Get(url)
if err != nil {
log.Fatal(err)
}
if resp.StatusCode != http.StatusOK {
return nil, errors_packets.ErrResponseNot200OK
}
fileBytes, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
return fileBytes, nil
}
// ReadManifest is crucial to get package metadata it reads manifest.toml from a package file (tar.zst)
func ReadManifest(file io.Reader) (configs.Manifest, error) {
zstdReader, err := zstd.NewReader(file)
if err != nil {
return configs.Manifest{}, err
}
defer zstdReader.Close()
tarReader := tar.NewReader(zstdReader)
for {
header, err := tarReader.Next()
if err == io.EOF {
break
}
if err != nil {
return configs.Manifest{}, err
}
if filepath.Base(header.Name) == "manifest.toml" {
decoder := toml.NewDecoder(tarReader)
var manifest configs.Manifest
if err := decoder.Decode(&manifest); err != nil {
return configs.Manifest{}, nil
}
return manifest, nil
}
}
return configs.Manifest{}, errors_packets.ErrCantFindManifestTOML
}
// CopyDir copies a directory from source to destination
func CopyDir(src string, dest string) error {
if stats, err := os.Stat(src); err != nil {
return err
} else {
if stats.IsDir() {
files, err := os.ReadDir(src)
if err != nil {
return err
}
if err := os.MkdirAll(dest, 0o755); err != nil {
return err
}
for _, file := range files {
if file.IsDir() {
CopyDir(filepath.Join(src, file.Name()), filepath.Join(dest, file.Name()))
continue
}
srcFile := filepath.Join(src, file.Name())
f, err := os.Create(filepath.Join(dest, file.Name()))
if err != nil {
return err
}
defer f.Close()
opennedSrcFile, err := os.Open(srcFile)
if err != nil {
return err
}
defer opennedSrcFile.Close()
if _, err := io.Copy(f, opennedSrcFile); err != nil {
return err
}
}
} else {
if err := CopyFile(src, dest); err != nil {
return err
}
}
}
return nil
}
// CopyFile copies a file from source to destination
func CopyFile(source string, destination string) error {
src, err := os.Open(source)
if err != nil {
return err
}
defer src.Close()
status, err := src.Stat()
if err != nil {
return err
}
err = os.MkdirAll(filepath.Dir(destination), 0o755)
if err != nil {
return err
}
dst, err := os.Create(destination)
if err != nil {
if !os.IsExist(err) {
dst, err = os.Open(destination)
if err != nil {
return err
}
} else {
return err
}
}
defer dst.Close()
if err := dst.Chmod(status.Mode()); err != nil {
return err
}
_, err = io.Copy(dst, src)
if err != nil {
return err
}
return nil
}
// Write writes the package file to the cache directory and returns the path to it
func (p *Package) Write() (string, error) {
if err := os.WriteFile(filepath.Join(consts.DefaultCache_d, p.Filename), p.PackageF, 0o644); err != nil {
_ = os.Remove(filepath.Join(consts.DefaultCache_d, p.Filename))
return "", err
}
return filepath.Join(consts.DefaultCache_d, p.Filename), nil
}
func (p *Package) AddToInstalledDB(inCache int, packagePath string) error {
db, err := sql.Open("sqlite", consts.InstalledDB)
if err != nil {
return err
}
defer db.Close()
var success bool
defer func() {
if !success {
_, err := db.Exec("DELETE FROM packages WHERE id = ?", p.Manifest.Info.Id)
if err != nil {
log.Println("failed to rollback package addition:", err)
}
}
}()
_, err = db.Exec(`
INSERT INTO packages (
query_name, id, version, description,
serial, package_d, filename, os, arch, in_cache
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
p.QueryName,
p.Manifest.Info.Id,
p.Version,
p.Description,
p.Serial,
packagePath,
p.Filename,
p.OS,
p.Arch,
inCache,
)
if err != nil {
return err
}
for depnName, versionConstraint := range p.Dependencies {
_, err = db.Exec("INSERT INTO package_dependencies (package_id, dependency_name, version_constraint) VALUES (?, ?, ?)", p.Manifest.Info.Id, depnName, versionConstraint)
}
success = true
return err
}
func CheckIfPackageInstalled(name string) (bool, error) {
db, err := sql.Open("sqlite", consts.InstalledDB)
if err != nil {
return false, err
}
defer db.Close()
var exists bool
err = db.QueryRow("SELECT EXISTS(SELECT 1 FROM packages WHERE id = ? OR query_name = ?)", name, name).Scan(&exists)
if err != nil {
return false, err
}
return exists, nil
}
func GetDependencies(db *sql.DB, id string) (map[string]string, error) {
rows, err := db.Query("SELECT dependency_name, version_constraint FROM package_dependencies WHERE package_id = ?", id)
if err != nil {
return map[string]string{}, err
}
defer rows.Close()
dependencies := make(map[string]string)
for rows.Next() {
var a, versionConstraint string
if err := rows.Scan(&a, &versionConstraint); err != nil {
return map[string]string{}, err
}
dependencies[a] = versionConstraint
}
return dependencies, nil
}
func ResolvDependencies(depnList map[string]string) ([]string, error) {
db, err := sql.Open("sqlite", consts.IndexDB)
if err != nil {
return []string{}, err
}
defer db.Close()
var resolved []string
for dependencieName, constraint := range depnList {
var filter, order string
value := strings.TrimLeft(constraint, "<>=")
switch {
case strings.HasPrefix(constraint, ">"):
filter = fmt.Sprintf("AND serial > %s", value)
order = "ORDER BY serial ASC LIMIT 1"
case strings.HasPrefix(constraint, "<="):
filter = fmt.Sprintf("AND serial <= %s", value)
order = "ORDER BY serial DESC LIMIT 1"
case strings.HasPrefix(constraint, "<"):
filter = fmt.Sprintf("AND serial < %s", value)
order = "ORDER BY serial DESC LIMIT 1"
case strings.HasPrefix(constraint, "="):
filter = fmt.Sprintf("AND serial = %s", value)
order = ""
}
var packageId string
err := db.QueryRow(fmt.Sprintf("SELECT id FROM packages WHERE query_name = ? %s %s", filter, order), dependencieName).Scan(&packageId)
if err != nil {
if err == sql.ErrNoRows {
continue
}
return []string{}, err
}
resolved = append(resolved, packageId)
dp, err := GetDependencies(db, packageId)
if err != nil {
return resolved, err
}
depn, err := ResolvDependencies(dp)
if err != nil {
return resolved, err
}
resolved = append(resolved, depn...)
}
return resolved, nil
}
func ManifestFileRead(file io.Reader) (configs.Manifest, error) {
decoder := toml.NewDecoder(file)
var manifest configs.Manifest
if err := decoder.Decode(&manifest); err != nil {
return configs.Manifest{}, nil
}
return manifest, nil
}
func RemoveFromInstalledDB(id string) error {
db, err := sql.Open("sqlite", consts.InstalledDB)
if err != nil {
return err
}
if _, err = db.Exec("DELETE FROM packages WHERE id = ? OR query_name = ?", id, id); err != nil {
return err
}
return nil
}
// GetPackage retrieves package information from the index database and downloads the package file
func GetPackage(id string) (Package, error) {
var this Package
var peers []Peer
db, err := sql.Open("sqlite", consts.IndexDB)
if err != nil {
return this, err
}
defer db.Close()
var packageUrl string
err = db.QueryRow("SELECT query_name, version, package_url, image_url, description, author, author_verified, os, arch, signature, public_key, serial, size FROM packages WHERE id = ?", id).
Scan(
&this.QueryName,
&this.Version,
&packageUrl,
&this.ImageUrl,
&this.Description,
&this.Author,
&this.AuthorVerified,
&this.OS,
&this.Arch,
&this.Signature,
&this.PublicKey,
&this.Serial,
&this.Size,
)
if err != nil {
return Package{}, err
}
rows, err := db.Query("SELECT dependency_name, version_constraint FROM package_dependencies WHERE package_id = ?", id)
if err != nil {
return Package{}, err
}
defer rows.Close()
for rows.Next() {
var a, vConstraint string
if err := rows.Scan(&a, &vConstraint); err != nil {
return Package{}, err
}
this.Dependencies[a] = vConstraint
}
filename := path.Base(packageUrl)
this.Filename = filename
dirEntry, err := os.ReadDir(consts.DefaultCache_d)
if err != nil {
return Package{}, err
}
for _, v := range dirEntry {
if v.Name() == filename {
this.PackageF, err = os.ReadFile(filepath.Join(consts.DefaultCache_d, filename))
if err != nil {
break
}
goto skipping
}
}
peers, err = AskLAN(filename)
if err != nil {
return Package{}, err
}
if len(peers) == 0 {
this.PackageF, err = GetFileHTTP(packageUrl)
if err != nil {
return Package{}, err
}
} else {
var totalerrors int = 0
for _, peer := range peers {
this.PackageF, err = GetFileHTTP(fmt.Sprintf("http://%s:%d/%s", peer.IP, peer.Port, filename))
if err == nil {
break
} else {
totalerrors++
}
}
if totalerrors == len(peers) {
this.PackageF, err = GetFileHTTP(packageUrl)
if err != nil {
return Package{}, err
}
}
}
skipping:
reader := bytes.NewReader(this.PackageF)
this.Manifest, err = ReadManifest(reader)
if err != nil {
return Package{}, err
}
if !ed25519.Verify(this.PublicKey, this.PackageF, this.Signature) {
return Package{}, errors_packets.ErrInvalidSignature
}
return this, nil
}
func GetPacketsUID() (int, error) {
_ = exec.Command("useradd", "-M", "-N", "-r", "packets").Run()
cmd := exec.Command("id", "-u", "packets")
out, err := cmd.CombinedOutput()
if err != nil {
return -1, err
}
s := strings.TrimSpace(string(out))
uid, err := strconv.Atoi(s)
if err != nil {
return -1, err
}
return uid, nil
}
func ChangeToNoPermission() error {
uid, err := GetPacketsUID()
if err != nil {
return err
}
return syscall.Setresuid(0, uid, 0)
}
func ElevatePermission() error { return syscall.Setresuid(0, 0, 0) }

BIN
ola@3000.pkt.tar.zst Normal file
View File

Binary file not shown.

164
pkg/main.go
View File

@@ -1,164 +0,0 @@
package packets
import (
"archive/tar"
"bytes"
"io"
"os"
"packets/internal/utils"
"runtime"
utils_lua "packets/internal/utils/lua"
"path/filepath"
"strings"
"github.com/klauspost/compress/zstd"
lua "github.com/yuin/gopher-lua"
_ "modernc.org/sqlite"
)
// Install exctract and fully install from a package file ( tar.zst )
func InstallPackage(file []byte, destDir string) error {
manifest, err := utils.ReadManifest(bytes.NewReader(file))
if err != nil {
return err
}
zstdReader, err := zstd.NewReader(bytes.NewReader(file))
if err != nil {
return err
}
defer zstdReader.Close()
tarReader := tar.NewReader(zstdReader)
uid, err := utils.GetPacketsUID()
if err != nil {
return err
}
for {
hdr, err := tarReader.Next()
if err == io.EOF {
break
}
if err != nil {
return err
}
rel := filepath.Clean(hdr.Name)
if rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
continue
}
if err := os.MkdirAll(destDir, 0775); err != nil {
return err
}
if err := os.Chown(destDir, uid, 0); err != nil {
return err
}
absPath := filepath.Join(destDir, rel)
switch hdr.Typeflag {
case tar.TypeDir:
err = os.MkdirAll(absPath, os.FileMode(hdr.Mode))
if err != nil {
return err
}
if err := os.Chown(absPath, uid, 0); err != nil {
return err
}
case tar.TypeReg:
err = os.MkdirAll(filepath.Dir(absPath), 0775)
if err != nil {
return err
}
out, err := os.Create(absPath)
if err != nil {
return err
}
_, err = io.Copy(out, tarReader)
out.Close()
if err != nil {
return err
}
err = os.Chmod(absPath, os.FileMode(0775))
if err != nil {
return err
}
if filepath.Base(hdr.Name) == "manifest.toml" || filepath.Base(hdr.Name) == manifest.Hooks.Install || filepath.Base(hdr.Name) == manifest.Hooks.Remove {
err = os.Chmod(absPath, os.FileMode(0755))
if err != nil {
return err
}
} else {
if err := os.Chown(absPath, uid, 0); err != nil {
return err
}
}
}
}
L, err := utils_lua.GetSandBox()
if err != nil {
return err
}
L.SetGlobal("data_dir", lua.LString(filepath.Join(destDir, "data")))
L.SetGlobal("script", lua.LString(manifest.Hooks.Install))
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if err := utils.ChangeToNoPermission(); err != nil {
return err
}
if err := L.DoFile(filepath.Join(destDir, manifest.Hooks.Install)); err != nil {
return err
}
if err := utils.ElevatePermission(); err != nil {
return err
}
return nil
}
// ExecuteRemoveScript executes the remove script from the package
func ExecuteRemoveScript(path string) error {
L, err := utils_lua.GetSandBox()
if err != nil {
return err
}
L.SetGlobal("data_dir", lua.LFalse)
L.SetGlobal("script", lua.LString(path))
L.SetGlobal("build", lua.LNil)
runtime.LockOSThread()
defer runtime.UnlockOSThread()
if err := utils.ChangeToNoPermission(); err != nil {
return err
}
if err := L.DoFile(path); err != nil {
return err
}
if err := utils.ElevatePermission(); err != nil {
return err
}
return nil
}

BIN
realtime@1.25.0.pkt.tar.zst Normal file
View File

Binary file not shown.

BIN
teste@1.0.pkt.tar.zst Normal file
View File

Binary file not shown.