massive refactoring for interoperability

proxy/freedom/freedom.go

@@ -4,9 +4,9 @@ package freedom
 
 import (
 	"context"
+	"time"
 
-	"v2ray.com/core/app"
-	"v2ray.com/core/app/policy"
+	"v2ray.com/core"
 	"v2ray.com/core/common"
 	"v2ray.com/core/common/buf"
 	"v2ray.com/core/common/dice"
@@ -20,37 +20,35 @@ import (
 
 // Handler handles Freedom connections.
 type Handler struct {
-	domainStrategy Config_DomainStrategy
-	timeout        uint32
-	destOverride   *DestinationOverride
-	policy         policy.Policy
+	policyManager core.PolicyManager
+	dns           core.DNSClient
+	config        Config
 }
 
 // New creates a new Freedom handler.
 func New(ctx context.Context, config *Config) (*Handler, error) {
-	space := app.SpaceFromContext(ctx)
-	if space == nil {
-		return nil, newError("no space in context")
+	v := core.FromContext(ctx)
+	if v == nil {
+		return nil, newError("V is not found in context.")
 	}
+
 	f := &Handler{
-		domainStrategy: config.DomainStrategy,
-		timeout:        config.Timeout,
-		destOverride:   config.DestinationOverride,
+		config:        *config,
+		policyManager: v.PolicyManager(),
+		dns:           v.DNSClient(),
 	}
-	space.On(app.SpaceInitializing, func(interface{}) error {
-		pm := policy.FromSpace(space)
-		if pm == nil {
-			return newError("Policy not found in space.")
-		}
-		f.policy = pm.GetPolicy(config.UserLevel)
-		if config.Timeout > 0 && config.UserLevel == 0 {
-			f.policy.Timeout.ConnectionIdle.Value = config.Timeout
-		}
-		return nil
-	})
+
 	return f, nil
 }
 
+func (h *Handler) policy() core.Policy {
+	p := h.policyManager.ForLevel(h.config.UserLevel)
+	if h.config.Timeout > 0 && h.config.UserLevel == 0 {
+		p.Timeouts.ConnectionIdle = time.Duration(h.config.Timeout) * time.Second
+	}
+	return p
+}
+
 func (h *Handler) resolveIP(ctx context.Context, domain string) net.Address {
 	if resolver, ok := proxy.ResolvedIPsFromContext(ctx); ok {
 		ips := resolver.Resolve()
@@ -60,7 +58,7 @@ func (h *Handler) resolveIP(ctx context.Context, domain string) net.Address {
 		return ips[dice.Roll(len(ips))]
 	}
 
-	ips, err := net.LookupIP(domain)
+	ips, err := h.dns.LookupIP(domain)
 	if err != nil {
 		newError("failed to get IP address for domain ", domain).Base(err).WriteToLog()
 	}
@@ -73,8 +71,8 @@ func (h *Handler) resolveIP(ctx context.Context, domain string) net.Address {
 // Process implements proxy.Outbound.
 func (h *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dialer proxy.Dialer) error {
 	destination, _ := proxy.TargetFromContext(ctx)
-	if h.destOverride != nil {
-		server := h.destOverride.Server
+	if h.config.DestinationOverride != nil {
+		server := h.config.DestinationOverride.Server
 		destination = net.Destination{
 			Network: destination.Network,
 			Address: server.Address.AsAddress(),
@@ -86,7 +84,7 @@ func (h *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
 	input := outboundRay.OutboundInput()
 	output := outboundRay.OutboundOutput()
 
-	if h.domainStrategy == Config_USE_IP && destination.Address.Family().IsDomain() {
+	if h.config.DomainStrategy == Config_USE_IP && destination.Address.Family().IsDomain() {
 		ip := h.resolveIP(ctx, destination.Address.Domain())
 		if ip != nil {
 			destination = net.Destination{
@@ -113,7 +111,7 @@ func (h *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
 	defer conn.Close()
 
 	ctx, cancel := context.WithCancel(ctx)
-	timer := signal.CancelAfterInactivity(ctx, cancel, h.policy.Timeout.ConnectionIdle.Duration())
+	timer := signal.CancelAfterInactivity(ctx, cancel, h.policy().Timeouts.ConnectionIdle)
 
 	requestDone := signal.ExecuteAsync(func() error {
 		var writer buf.Writer
@@ -125,7 +123,7 @@ func (h *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
 		if err := buf.Copy(input, writer, buf.UpdateActivity(timer)); err != nil {
 			return newError("failed to process request").Base(err)
 		}
-		timer.SetTimeout(h.policy.Timeout.DownlinkOnly.Duration())
+		timer.SetTimeout(h.policy().Timeouts.DownlinkOnly)
 		return nil
 	})
 
@@ -136,7 +134,7 @@ func (h *Handler) Process(ctx context.Context, outboundRay ray.OutboundRay, dial
 		if err := buf.Copy(v2reader, output, buf.UpdateActivity(timer)); err != nil {
 			return newError("failed to process response").Base(err)
 		}
-		timer.SetTimeout(h.policy.Timeout.UplinkOnly.Duration())
+		timer.SetTimeout(h.policy().Timeouts.UplinkOnly)
 		return nil
 	})