release: version 3.1.2

v2/common/cache.go

@@ -0,0 +1,192 @@
+package common
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"log"
+	"os"
+	"time"
+
+	"github.com/hiddify/hiddify-core/v2/service_manager"
+	"github.com/sagernet/sing-box/option"
+
+	"github.com/sagernet/bbolt"
+	bboltErrors "github.com/sagernet/bbolt/errors"
+
+	"github.com/sagernet/sing/common"
+	E "github.com/sagernet/sing/common/exceptions"
+	"github.com/sagernet/sing/service/filemanager"
+)
+
+var (
+	Storage         CacheFile
+	bucketExtension = []byte("extension")
+	bucketHiddify   = []byte("hiddify")
+
+	bucketNameList = []string{
+		string(bucketExtension),
+		string(bucketHiddify),
+	}
+)
+
+type StorageService struct {
+	// Storage *CacheFile
+}
+
+func (s *StorageService) Start() error {
+	Storage = *NewStorage(context.Background(), option.CacheFileOptions{})
+	return nil
+}
+
+func (s *StorageService) Close() error {
+	Storage.DB.Close()
+	return nil
+}
+
+func init() {
+	service_manager.RegisterPreservice(&StorageService{})
+}
+
+type CacheFile struct {
+	ctx     context.Context
+	path    string
+	cacheID []byte
+
+	DB *bbolt.DB
+}
+
+func NewStorage(ctx context.Context, options option.CacheFileOptions) *CacheFile {
+	var path string
+	if options.Path != "" {
+		path = options.Path
+	} else {
+		path = "hiddify.db"
+	}
+	var cacheIDBytes []byte
+	if options.CacheID != "" {
+		cacheIDBytes = append([]byte{0}, []byte(options.CacheID)...)
+	}
+	cache := &CacheFile{
+		ctx:     ctx,
+		path:    filemanager.BasePath(ctx, path),
+		cacheID: cacheIDBytes,
+	}
+	err := cache.start()
+	if err != nil {
+		log.Panic(err)
+	}
+	return cache
+}
+
+func (c *CacheFile) start() error {
+	const fileMode = 0o666
+	options := bbolt.Options{Timeout: time.Second}
+	var (
+		db  *bbolt.DB
+		err error
+	)
+	for i := 0; i < 10; i++ {
+		db, err = bbolt.Open(c.path, fileMode, &options)
+		if err == nil {
+			break
+		}
+		if errors.Is(err, bboltErrors.ErrTimeout) {
+			continue
+		}
+		if E.IsMulti(err, bboltErrors.ErrInvalid, bboltErrors.ErrChecksum, bboltErrors.ErrVersionMismatch) {
+			rmErr := os.Remove(c.path)
+			if rmErr != nil {
+				return err
+			}
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	if err != nil {
+		return err
+	}
+	err = filemanager.Chown(c.ctx, c.path)
+	if err != nil {
+		db.Close()
+		return E.Cause(err, "platform chown")
+	}
+	err = db.Batch(func(tx *bbolt.Tx) error {
+		return tx.ForEach(func(name []byte, b *bbolt.Bucket) error {
+			if name[0] == 0 {
+				return b.ForEachBucket(func(k []byte) error {
+					bucketName := string(k)
+					if !(common.Contains(bucketNameList, bucketName)) {
+						_ = b.DeleteBucket(name)
+					}
+					return nil
+				})
+			} else {
+				bucketName := string(name)
+				if !(common.Contains(bucketNameList, bucketName)) {
+					_ = tx.DeleteBucket(name)
+				}
+			}
+			return nil
+		})
+	})
+	if err != nil {
+		db.Close()
+		return err
+	}
+	c.DB = db
+	return nil
+}
+
+func (c *CacheFile) bucket(t *bbolt.Tx, key []byte) *bbolt.Bucket {
+	if c.cacheID == nil {
+		return t.Bucket(key)
+	}
+	bucket := t.Bucket(c.cacheID)
+	if bucket == nil {
+		return nil
+	}
+	return bucket.Bucket(key)
+}
+
+func (c *CacheFile) createBucket(t *bbolt.Tx, key []byte) (*bbolt.Bucket, error) {
+	if c.cacheID == nil {
+		return t.CreateBucketIfNotExists(key)
+	}
+	bucket, err := t.CreateBucketIfNotExists(c.cacheID)
+	if bucket == nil {
+		return nil, err
+	}
+	return bucket.CreateBucketIfNotExists(key)
+}
+
+func (c *CacheFile) GetExtensionData(extension_id string, default_value any) error {
+	err := c.DB.View(func(t *bbolt.Tx) error {
+		bucket := c.bucket(t, bucketExtension)
+		if bucket == nil {
+			return os.ErrNotExist
+		}
+		setBinary := bucket.Get([]byte(extension_id))
+		if len(setBinary) == 0 {
+			return os.ErrInvalid
+		}
+		return json.Unmarshal(setBinary, &default_value)
+	})
+	return err
+}
+
+func (c *CacheFile) SaveExtensionData(extension_id string, data any) error {
+	return c.DB.Batch(func(t *bbolt.Tx) error {
+		bucket, err := c.createBucket(t, bucketExtension)
+		if err != nil {
+			return err
+		}
+
+		// Assuming T implements MarshalBinary
+
+		setBinary, err := json.MarshalIndent(data, " ", "")
+		if err != nil {
+			return err
+		}
+		return bucket.Put([]byte(extension_id), setBinary)
+	})
+}

v2/common/utils.go

@@ -0,0 +1,25 @@
+package common
+
+import (
+	"net"
+	"net/netip"
+	"time"
+)
+
+func CanConnectIPv6Addr(remoteAddr netip.AddrPort) bool {
+	dialer := net.Dialer{
+		Timeout: 1 * time.Second,
+	}
+
+	conn, err := dialer.Dial("tcp6", remoteAddr.String())
+	if err != nil {
+		return false
+	}
+	defer conn.Close()
+
+	return true
+}
+
+func CanConnectIPv6() bool {
+	return CanConnectIPv6Addr(netip.MustParseAddrPort("[2001:4860:4860::8888]:80"))
+}

v2/grpc_server.go

@@ -35,7 +35,6 @@ func StartGrpcServer(listenAddressG string, service string) (*grpc.Server, error
 	if service == "core" {
 
 		// Setup("./tmp/", "./tmp", "./tmp", 11111, false)
-		Setup("./tmp", "./", "./tmp", 0, false)
 
 		useFlutterBridge = false
 		pb.RegisterCoreServer(s, &CoreService{})

v2/service.go

@@ -8,6 +8,8 @@ import (
 	runtimeDebug "runtime/debug"
 	"time"
 
+	"github.com/hiddify/hiddify-core/v2/service_manager"
+
 	B "github.com/sagernet/sing-box"
 	"github.com/sagernet/sing-box/common/urltest"
 	"github.com/sagernet/sing-box/experimental/libbox"
@@ -27,9 +29,13 @@ var (
 	statusPropagationPort int64
 )
 
+func InitHiddifyService() error {
+	return service_manager.StartServices()
+}
+
 func Setup(basePath string, workingPath string, tempPath string, statusPort int64, debug bool) error {
 	statusPropagationPort = int64(statusPort)
-	tcpConn := runtime.GOOS == "windows" //TODO add TVOS
+	tcpConn := runtime.GOOS == "windows" // TODO add TVOS
 	libbox.Setup(basePath, workingPath, tempPath, tcpConn)
 	sWorkingPath = workingPath
 	os.Chdir(sWorkingPath)
@@ -53,7 +59,11 @@ func Setup(basePath string, workingPath string, tempPath string, statusPort int6
 			// },
 		})
 	coreLogFactory = factory
-	return err
+
+	if err != nil {
+		return E.Cause(err, "create logger")
+	}
+	return InitHiddifyService()
 }
 
 func NewService(options option.Options) (*libbox.BoxService, error) {

v2/service_manager/hiddify.go

@@ -0,0 +1,46 @@
+package service_manager
+
+import (
+	"github.com/sagernet/sing-box/adapter"
+)
+
+var (
+	services    = []adapter.Service{}
+	preservices = []adapter.Service{}
+)
+
+func RegisterPreservice(service adapter.Service) {
+	preservices = append(services, service)
+}
+
+func Register(service adapter.Service) {
+	services = append(services, service)
+}
+
+func StartServices() error {
+	for _, service := range preservices {
+		if err := service.Start(); err != nil {
+			return err
+		}
+	}
+	for _, service := range services {
+		if err := service.Start(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func CloseServices() error {
+	for _, service := range services {
+		if err := service.Close(); err != nil {
+			return err
+		}
+	}
+	for _, service := range preservices {
+		if err := service.Close(); err != nil {
+			return err
+		}
+	}
+	return nil
+}