simplify router

app/router/router.go

@@ -1,8 +1,10 @@
 package router
 
 import (
+	"errors"
+
 	"v2ray.com/core/app"
-	"v2ray.com/core/common"
+	"v2ray.com/core/app/dns"
 	"v2ray.com/core/common/log"
 	v2net "v2ray.com/core/common/net"
 )
@@ -11,31 +13,97 @@ const (
 	APP_ID = app.ID(3)
 )
 
-type Router interface {
-	common.Releasable
-	TakeDetour(v2net.Destination) (string, error)
-}
-
-type RouterFactory interface {
-	Create(rawConfig interface{}, space app.Space) (Router, error)
-}
-
 var (
-	routerCache = make(map[string]RouterFactory)
+	ErrInvalidRule      = errors.New("Invalid Rule")
+	ErrNoRuleApplicable = errors.New("No rule applicable")
 )
 
-func RegisterRouter(name string, factory RouterFactory) error {
-	if _, found := routerCache[name]; found {
-		return common.ErrDuplicatedName
-	}
-	routerCache[name] = factory
-	return nil
+type Router struct {
+	domainStrategy Config_DomainStrategy
+	rules          []Rule
+	cache          *RoutingTable
+	dnsServer      dns.Server
 }
 
-func CreateRouter(name string, rawConfig interface{}, space app.Space) (Router, error) {
-	if factory, found := routerCache[name]; found {
-		return factory.Create(rawConfig, space)
+func NewRouter(config *Config, space app.Space) *Router {
+	r := &Router{
+		domainStrategy: config.DomainStrategy,
+		cache:          NewRoutingTable(),
+		rules:          make([]Rule, len(config.Rule)),
 	}
-	log.Error("Router: not found: ", name)
-	return nil, common.ErrObjectNotFound
+
+	space.InitializeApplication(func() error {
+		for idx, rule := range config.Rule {
+			r.rules[idx].Tag = rule.Tag
+			cond, err := rule.BuildCondition()
+			if err != nil {
+				return err
+			}
+			r.rules[idx].Condition = cond
+		}
+
+		if !space.HasApp(dns.APP_ID) {
+			log.Error("DNS: Router is not found in the space.")
+			return app.ErrMissingApplication
+		}
+		r.dnsServer = space.GetApp(dns.APP_ID).(dns.Server)
+		return nil
+	})
+	return r
+}
+
+func (this *Router) Release() {
+
+}
+
+// Private: Visible for testing.
+func (this *Router) ResolveIP(dest v2net.Destination) []v2net.Destination {
+	ips := this.dnsServer.Get(dest.Address.Domain())
+	if len(ips) == 0 {
+		return nil
+	}
+	dests := make([]v2net.Destination, len(ips))
+	for idx, ip := range ips {
+		if dest.Network == v2net.Network_TCP {
+			dests[idx] = v2net.TCPDestination(v2net.IPAddress(ip), dest.Port)
+		} else {
+			dests[idx] = v2net.UDPDestination(v2net.IPAddress(ip), dest.Port)
+		}
+	}
+	return dests
+}
+
+func (this *Router) takeDetourWithoutCache(dest v2net.Destination) (string, error) {
+	for _, rule := range this.rules {
+		if rule.Apply(dest) {
+			return rule.Tag, nil
+		}
+	}
+	if this.domainStrategy == Config_IpIfNonMatch && dest.Address.Family().IsDomain() {
+		log.Info("Router: Looking up IP for ", dest)
+		ipDests := this.ResolveIP(dest)
+		if ipDests != nil {
+			for _, ipDest := range ipDests {
+				log.Info("Router: Trying IP ", ipDest)
+				for _, rule := range this.rules {
+					if rule.Apply(ipDest) {
+						return rule.Tag, nil
+					}
+				}
+			}
+		}
+	}
+
+	return "", ErrNoRuleApplicable
+}
+
+func (this *Router) TakeDetour(dest v2net.Destination) (string, error) {
+	destStr := dest.String()
+	found, tag, err := this.cache.Get(destStr)
+	if !found {
+		tag, err := this.takeDetourWithoutCache(dest)
+		this.cache.Set(destStr, tag, err)
+		return tag, err
+	}
+	return tag, err
 }