func rewriteParse(c *caddy.Controller) ([]httpserver.HandlerConfig, error) { var rules []httpserver.HandlerConfig for c.Next() { var rule Rule var err error var base = "/" var pattern, to string var ext []string args := c.RemainingArgs() var matcher httpserver.RequestMatcher switch len(args) { case 1: base = args[0] fallthrough case 0: // Integrate request matcher for 'if' conditions. matcher, err = httpserver.SetupIfMatcher(c) if err != nil { return nil, err } for c.NextBlock() { if httpserver.IfMatcherKeyword(c) { continue } switch c.Val() { case "r", "regexp": if !c.NextArg() { return nil, c.ArgErr() } pattern = c.Val() case "to": args1 := c.RemainingArgs() if len(args1) == 0 { return nil, c.ArgErr() } to = strings.Join(args1, " ") case "ext": args1 := c.RemainingArgs() if len(args1) == 0 { return nil, c.ArgErr() } ext = args1 default: return nil, c.ArgErr() } } // ensure to is specified if to == "" { return nil, c.ArgErr() } if rule, err = NewComplexRule(base, pattern, to, ext, matcher); err != nil { return nil, err } rules = append(rules, rule) // the only unhandled case is 2 and above default: rule = NewSimpleRule(args[0], strings.Join(args[1:], " ")) rules = append(rules, rule) } } return rules, nil }
func redirParse(c *caddy.Controller) ([]Rule, error) { var redirects []Rule cfg := httpserver.GetConfig(c) initRule := func(rule *Rule, defaultCode string, args []string) error { if cfg.TLS.Enabled { rule.FromScheme = "https" } else { rule.FromScheme = "http" } var ( from = "/" to string code = defaultCode ) switch len(args) { case 1: // To specified (catch-all redirect) // Not sure why user is doing this in a table, as it causes all other redirects to be ignored. // As such, this feature remains undocumented. to = args[0] case 2: // From and To specified from = args[0] to = args[1] case 3: // From, To, and Code specified from = args[0] to = args[1] code = args[2] default: return c.ArgErr() } rule.FromPath = from rule.To = to if code == "meta" { rule.Meta = true code = defaultCode } if codeNumber, ok := httpRedirs[code]; ok { rule.Code = codeNumber } else { return c.Errf("Invalid redirect code '%v'", code) } return nil } // checkAndSaveRule checks the rule for validity (except the redir code) // and saves it if it's valid, or returns an error. checkAndSaveRule := func(rule Rule) error { if rule.FromPath == rule.To { return c.Err("'from' and 'to' values of redirect rule cannot be the same") } for _, otherRule := range redirects { if otherRule.FromPath == rule.FromPath { return c.Errf("rule with duplicate 'from' value: %s -> %s", otherRule.FromPath, otherRule.To) } } redirects = append(redirects, rule) return nil } const initDefaultCode = "301" for c.Next() { args := c.RemainingArgs() matcher, err := httpserver.SetupIfMatcher(c) if err != nil { return nil, err } var hadOptionalBlock bool for c.NextBlock() { if httpserver.IfMatcherKeyword(c) { continue } hadOptionalBlock = true rule := Rule{ RequestMatcher: matcher, } defaultCode := initDefaultCode // Set initial redirect code if len(args) == 1 { defaultCode = args[0] } // RemainingArgs only gets the values after the current token, but in our // case we want to include the current token to get an accurate count. insideArgs := append([]string{c.Val()}, c.RemainingArgs()...) err := initRule(&rule, defaultCode, insideArgs) if err != nil { return redirects, err } err = checkAndSaveRule(rule) if err != nil { return redirects, err } } if !hadOptionalBlock { rule := Rule{ RequestMatcher: matcher, } err := initRule(&rule, initDefaultCode, args) if err != nil { return redirects, err } err = checkAndSaveRule(rule) if err != nil { return redirects, err } } } return redirects, nil }
func redirParse(c *caddy.Controller) ([]Rule, error) { var redirects []Rule cfg := httpserver.GetConfig(c) // setRedirCode sets the redirect code for rule if it can, or returns an error setRedirCode := func(code string, rule *Rule) error { if code == "meta" { rule.Meta = true } else if codeNumber, ok := httpRedirs[code]; ok { rule.Code = codeNumber } else { return c.Errf("Invalid redirect code '%v'", code) } return nil } // checkAndSaveRule checks the rule for validity (except the redir code) // and saves it if it's valid, or returns an error. checkAndSaveRule := func(rule Rule) error { if rule.FromPath == rule.To { return c.Err("'from' and 'to' values of redirect rule cannot be the same") } for _, otherRule := range redirects { if otherRule.FromPath == rule.FromPath { return c.Errf("rule with duplicate 'from' value: %s -> %s", otherRule.FromPath, otherRule.To) } } redirects = append(redirects, rule) return nil } for c.Next() { matcher, err := httpserver.SetupIfMatcher(c.Dispenser) if err != nil { return nil, err } args := c.RemainingArgs() var hadOptionalBlock bool for c.NextBlock() { if httpserver.IfMatcherKeyword(c.Val()) { continue } hadOptionalBlock = true var rule = Rule{ RequestMatcher: matcher, } if cfg.TLS.Enabled { rule.FromScheme = "https" } else { rule.FromScheme = "http" } // Set initial redirect code // BUG: If the code is specified for a whole block and that code is invalid, // the line number will appear on the first line inside the block, even if that // line overwrites the block-level code with a valid redirect code. The program // still functions correctly, but the line number in the error reporting is // misleading to the user. if len(args) == 1 { err := setRedirCode(args[0], &rule) if err != nil { return redirects, err } } else { rule.Code = http.StatusMovedPermanently // default code } // RemainingArgs only gets the values after the current token, but in our // case we want to include the current token to get an accurate count. insideArgs := append([]string{c.Val()}, c.RemainingArgs()...) switch len(insideArgs) { case 1: // To specified (catch-all redirect) // Not sure why user is doing this in a table, as it causes all other redirects to be ignored. // As such, this feature remains undocumented. rule.FromPath = "/" rule.To = insideArgs[0] case 2: // From and To specified rule.FromPath = insideArgs[0] rule.To = insideArgs[1] case 3: // From, To, and Code specified rule.FromPath = insideArgs[0] rule.To = insideArgs[1] err := setRedirCode(insideArgs[2], &rule) if err != nil { return redirects, err } default: return redirects, c.ArgErr() } err := checkAndSaveRule(rule) if err != nil { return redirects, err } } if !hadOptionalBlock { var rule = Rule{ RequestMatcher: matcher, } if cfg.TLS.Enabled { rule.FromScheme = "https" } else { rule.FromScheme = "http" } rule.Code = http.StatusMovedPermanently // default switch len(args) { case 1: // To specified (catch-all redirect) rule.FromPath = "/" rule.To = args[0] case 2: // To and Code specified (catch-all redirect) rule.FromPath = "/" rule.To = args[0] err := setRedirCode(args[1], &rule) if err != nil { return redirects, err } case 3: // From, To, and Code specified rule.FromPath = args[0] rule.To = args[1] err := setRedirCode(args[2], &rule) if err != nil { return redirects, err } default: return redirects, c.ArgErr() } err := checkAndSaveRule(rule) if err != nil { return redirects, err } } } return redirects, nil }
func rewriteParse(c *caddy.Controller) ([]Rule, error) { var simpleRules []Rule var regexpRules []Rule for c.Next() { var rule Rule var err error var base = "/" var pattern, to string var status int var ext []string args := c.RemainingArgs() var matcher httpserver.RequestMatcher switch len(args) { case 1: base = args[0] fallthrough case 0: // Integrate request matcher for 'if' conditions. matcher, err = httpserver.SetupIfMatcher(c.Dispenser) if err != nil { return nil, err } block: for c.NextBlock() { switch c.Val() { case "r", "regexp": if !c.NextArg() { return nil, c.ArgErr() } pattern = c.Val() case "to": args1 := c.RemainingArgs() if len(args1) == 0 { return nil, c.ArgErr() } to = strings.Join(args1, " ") case "ext": args1 := c.RemainingArgs() if len(args1) == 0 { return nil, c.ArgErr() } ext = args1 case "status": if !c.NextArg() { return nil, c.ArgErr() } status, _ = strconv.Atoi(c.Val()) if status < 200 || (status > 299 && status < 400) || status > 499 { return nil, c.Err("status must be 2xx or 4xx") } default: if httpserver.IfMatcherKeyword(c.Val()) { continue block } return nil, c.ArgErr() } } // ensure to or status is specified if to == "" && status == 0 { return nil, c.ArgErr() } if rule, err = NewComplexRule(base, pattern, to, status, ext, matcher); err != nil { return nil, err } regexpRules = append(regexpRules, rule) // the only unhandled case is 2 and above default: rule = NewSimpleRule(args[0], strings.Join(args[1:], " ")) simpleRules = append(simpleRules, rule) } } // put simple rules in front to avoid regexp computation for them return append(simpleRules, regexpRules...), nil }