package rules import ( "errors" "fmt" "net/http" "reflect" "sort" "strings" "github.com/containous/mux" "github.com/containous/traefik/hostresolver" "github.com/containous/traefik/old/middlewares" "github.com/containous/traefik/old/types" ) // Rules holds rule parsing and configuration type Rules struct { Route *types.ServerRoute err error HostResolver *hostresolver.Resolver } func (r *Rules) host(hosts ...string) *mux.Route { for i, host := range hosts { hosts[i] = strings.ToLower(host) } return r.Route.Route.MatcherFunc(func(req *http.Request, route *mux.RouteMatch) bool { reqHost := middlewares.GetCanonizedHost(req.Context()) if len(reqHost) == 0 { return false } if r.HostResolver != nil && r.HostResolver.CnameFlattening { reqH, flatH := r.HostResolver.CNAMEFlatten(reqHost) for _, host := range hosts { if strings.EqualFold(reqH, host) || strings.EqualFold(flatH, host) { return true } // FIXME //log.Debugf("CNAMEFlattening: request %s which resolved to %s, is not matched to route %s", reqH, flatH, host) } return false } for _, host := range hosts { if reqHost == host { return true } } return false }) } func (r *Rules) hostRegexp(hostPatterns ...string) *mux.Route { router := r.Route.Route.Subrouter() for _, hostPattern := range hostPatterns { router.Host(hostPattern) } return r.Route.Route } func (r *Rules) path(paths ...string) *mux.Route { router := r.Route.Route.Subrouter() for _, path := range paths { router.Path(path) } return r.Route.Route } func (r *Rules) pathPrefix(paths ...string) *mux.Route { router := r.Route.Route.Subrouter() for _, path := range paths { buildPath(path, router) } return r.Route.Route } func buildPath(path string, router *mux.Router) { // {} are used to define a regex pattern in http://www.gorillatoolkit.org/pkg/mux. // if we find a { in the path, that means we use regex, then the gorilla/mux implementation is chosen // otherwise, we use a lightweight implementation if strings.Contains(path, "{") { router.PathPrefix(path) } else { m := &prefixMatcher{prefix: path} router.NewRoute().MatcherFunc(m.Match) } } type prefixMatcher struct { prefix string } func (m *prefixMatcher) Match(r *http.Request, _ *mux.RouteMatch) bool { return strings.HasPrefix(r.URL.Path, m.prefix) || strings.HasPrefix(r.URL.Path, m.prefix+"/") } type bySize []string func (a bySize) Len() int { return len(a) } func (a bySize) Swap(i, j int) { a[i], a[j] = a[j], a[i] } func (a bySize) Less(i, j int) bool { return len(a[i]) > len(a[j]) } func (r *Rules) pathStrip(paths ...string) *mux.Route { sort.Sort(bySize(paths)) r.Route.StripPrefixes = paths router := r.Route.Route.Subrouter() for _, path := range paths { router.Path(strings.TrimSpace(path)) } return r.Route.Route } func (r *Rules) pathStripRegex(paths ...string) *mux.Route { sort.Sort(bySize(paths)) r.Route.StripPrefixesRegex = paths router := r.Route.Route.Subrouter() for _, path := range paths { router.Path(path) } return r.Route.Route } func (r *Rules) replacePath(paths ...string) *mux.Route { for _, path := range paths { r.Route.ReplacePath = path } return r.Route.Route } func (r *Rules) replacePathRegex(paths ...string) *mux.Route { for _, path := range paths { r.Route.ReplacePathRegex = path } return r.Route.Route } func (r *Rules) addPrefix(paths ...string) *mux.Route { for _, path := range paths { r.Route.AddPrefix = path } return r.Route.Route } func (r *Rules) pathPrefixStrip(paths ...string) *mux.Route { sort.Sort(bySize(paths)) r.Route.StripPrefixes = paths router := r.Route.Route.Subrouter() for _, path := range paths { buildPath(path, router) } return r.Route.Route } func (r *Rules) pathPrefixStripRegex(paths ...string) *mux.Route { sort.Sort(bySize(paths)) r.Route.StripPrefixesRegex = paths router := r.Route.Route.Subrouter() for _, path := range paths { router.PathPrefix(path) } return r.Route.Route } func (r *Rules) methods(methods ...string) *mux.Route { return r.Route.Route.Methods(methods...) } func (r *Rules) headers(headers ...string) *mux.Route { return r.Route.Route.Headers(headers...) } func (r *Rules) headersRegexp(headers ...string) *mux.Route { return r.Route.Route.HeadersRegexp(headers...) } func (r *Rules) query(query ...string) *mux.Route { var queries []string for _, elem := range query { queries = append(queries, strings.Split(elem, "=")...) } return r.Route.Route.Queries(queries...) } func (r *Rules) parseRules(expression string, onRule func(functionName string, function interface{}, arguments []string) error) error { functions := map[string]interface{}{ "Host": r.host, "HostRegexp": r.hostRegexp, "Path": r.path, "PathStrip": r.pathStrip, "PathStripRegex": r.pathStripRegex, "PathPrefix": r.pathPrefix, "PathPrefixStrip": r.pathPrefixStrip, "PathPrefixStripRegex": r.pathPrefixStripRegex, "Method": r.methods, "Headers": r.headers, "HeadersRegexp": r.headersRegexp, "AddPrefix": r.addPrefix, "ReplacePath": r.replacePath, "ReplacePathRegex": r.replacePathRegex, "Query": r.query, } if len(expression) == 0 { return errors.New("empty rule") } f := func(c rune) bool { return c == ':' } // Allow multiple rules separated by ; splitRule := func(c rune) bool { return c == ';' } parsedRules := strings.FieldsFunc(expression, splitRule) for _, rule := range parsedRules { // get function parsedFunctions := strings.FieldsFunc(rule, f) if len(parsedFunctions) == 0 { return fmt.Errorf("error parsing rule: '%s'", rule) } functionName := strings.TrimSpace(parsedFunctions[0]) parsedFunction, ok := functions[functionName] if !ok { return fmt.Errorf("error parsing rule: '%s'. Unknown function: '%s'", rule, parsedFunctions[0]) } parsedFunctions = append(parsedFunctions[:0], parsedFunctions[1:]...) // get function fargs := func(c rune) bool { return c == ',' } parsedArgs := strings.FieldsFunc(strings.Join(parsedFunctions, ":"), fargs) if len(parsedArgs) == 0 { return fmt.Errorf("error parsing args from rule: '%s'", rule) } for i := range parsedArgs { parsedArgs[i] = strings.TrimSpace(parsedArgs[i]) } err := onRule(functionName, parsedFunction, parsedArgs) if err != nil { return fmt.Errorf("parsing error on rule: %v", err) } } return nil } // Parse parses rules expressions func (r *Rules) Parse(expression string) (*mux.Route, error) { var resultRoute *mux.Route err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error { inputs := make([]reflect.Value, len(arguments)) for i := range arguments { inputs[i] = reflect.ValueOf(arguments[i]) } method := reflect.ValueOf(function) if method.IsValid() { resultRoute = method.Call(inputs)[0].Interface().(*mux.Route) if r.err != nil { return r.err } if resultRoute == nil { return fmt.Errorf("invalid expression: %s", expression) } if resultRoute.GetError() != nil { return resultRoute.GetError() } } else { return fmt.Errorf("method not found: '%s'", functionName) } return nil }) if err != nil { return nil, fmt.Errorf("error parsing rule: %v", err) } return resultRoute, nil } // ParseDomains parses rules expressions and returns domains func (r *Rules) ParseDomains(expression string) ([]string, error) { var domains []string isHostRule := false err := r.parseRules(expression, func(functionName string, function interface{}, arguments []string) error { if functionName == "Host" { isHostRule = true domains = append(domains, arguments...) } return nil }) if err != nil { return nil, fmt.Errorf("error parsing domains: %v", err) } var cleanDomains []string for _, domain := range domains { canonicalDomain := strings.ToLower(domain) if len(canonicalDomain) > 0 { cleanDomains = append(cleanDomains, canonicalDomain) } } // Return an error if an Host rule is detected but no domain are parsed if isHostRule && len(cleanDomains) == 0 { return nil, fmt.Errorf("unable to parse correctly the domains in the Host rule from %q", expression) } return cleanDomains, nil }