Commit ⋅ gin-gonic/gin

25

@@ -55,7 +55,7 @@

Loading


// JSON creates a properly formatted JSON
func (msg *Error) JSON() interface{} {
	json := H{}
	jsonData := H{}
	if msg.Meta != nil {
		value := reflect.ValueOf(msg.Meta)
		switch value.Kind() {

@@ -63,16 +63,16 @@

Loading

			return msg.Meta
		case reflect.Map:
			for _, key := range value.MapKeys() {
				json[key.String()] = value.MapIndex(key).Interface()
				jsonData[key.String()] = value.MapIndex(key).Interface()
			}
		default:
			json["meta"] = msg.Meta
			jsonData["meta"] = msg.Meta
		}
	}
	if _, ok := json["error"]; !ok {
		json["error"] = msg.Error()
	if _, ok := jsonData["error"]; !ok {
		jsonData["error"] = msg.Error()
	}
	return json
	return jsonData
}

// MarshalJSON implements the json.Marshaller interface.

@@ -90,6 +90,11 @@

Loading

	return (msg.Type & flags) > 0
}

// Unwrap returns the wrapped error, to allow interoperability with errors.Is(), errors.As() and errors.Unwrap()
func (msg *Error) Unwrap() error {
	return msg.Err
}

// ByType returns a readonly copy filtered the byte.
// ie ByType(gin.ErrorTypePublic) returns a slice of errors with type=ErrorTypePublic.
func (a errorMsgs) ByType(typ ErrorType) errorMsgs {

@@ -135,17 +140,17 @@

Loading

}

func (a errorMsgs) JSON() interface{} {
	switch len(a) {
	switch length := len(a); length {
	case 0:
		return nil
	case 1:
		return a.Last().JSON()
	default:
		json := make([]interface{}, len(a))
		jsonData := make([]interface{}, length)
		for i, err := range a {
			json[i] = err.JSON()
			jsonData[i] = err.JSON()
		}
		return json
		return jsonData
	}
}


@@ -8,6 +8,8 @@

Loading

	"encoding/base64"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin/internal/bytesconv"
)

// AuthUserKey is the cookie name for user credential in basic auth.

@@ -68,8 +70,9 @@

Loading

}

func processAccounts(accounts Accounts) authPairs {
	assert1(len(accounts) > 0, "Empty list of authorized credentials")
	pairs := make(authPairs, 0, len(accounts))
	length := len(accounts)
	assert1(length > 0, "Empty list of authorized credentials")
	pairs := make(authPairs, 0, length)
	for user, password := range accounts {
		assert1(user != "", "User can not be empty")
		value := authorizationHeader(user, password)

@@ -83,5 +86,5 @@

Loading


func authorizationHeader(user, password string) string {
	base := user + ":" + password
	return "Basic " + base64.StdEncoding.EncodeToString([]byte(base))
	return "Basic " + base64.StdEncoding.EncodeToString(bytesconv.StringToBytes(base))
}

@@ -8,7 +8,7 @@

Loading

	"net/http"
)

const defaultMemory = 32 * 1024 * 1024
const defaultMemory = 32 << 20

type formBinding struct{}
type formPostBinding struct{}

@@ -13,24 +13,26 @@

Loading

	"path"
	"sync"

	"github.com/gin-gonic/gin/internal/bytesconv"
	"github.com/gin-gonic/gin/render"
)

const defaultMultipartMemory = 32 << 20 // 32 MB

var (
	default404Body   = []byte("404 page not found")
	default405Body   = []byte("405 method not allowed")
	defaultAppEngine bool
	default404Body = []byte("404 page not found")
	default405Body = []byte("405 method not allowed")
)

var defaultAppEngine bool

// HandlerFunc defines the handler used by gin middleware as return value.
type HandlerFunc func(*Context)

// HandlersChain defines a HandlerFunc array.
type HandlersChain []HandlerFunc

// Last returns the last handler in the chain. ie. the last handler is the main own.
// Last returns the last handler in the chain. ie. the last handler is the main one.
func (c HandlersChain) Last() HandlerFunc {
	if length := len(c); length > 0 {
		return c[length-1]

@@ -97,8 +99,12 @@

Loading

	// method call.
	MaxMultipartMemory int64

	// RemoveExtraSlash a parameter can be parsed from the URL even with extra slashes.
	// See the PR #1817 and issue #1644
	RemoveExtraSlash bool

	delims           render.Delims
	secureJsonPrefix string
	secureJSONPrefix string
	HTMLRender       render.HTMLRender
	FuncMap          template.FuncMap
	allNoRoute       HandlersChain

@@ -107,6 +113,7 @@

Loading

	noMethod         HandlersChain
	pool             sync.Pool
	trees            methodTrees
	maxParams        uint16
}

var _ IRouter = &Engine{}

@@ -134,11 +141,12 @@

Loading

		ForwardedByClientIP:    true,
		AppEngine:              defaultAppEngine,
		UseRawPath:             false,
		RemoveExtraSlash:       false,
		UnescapePathValues:     true,
		MaxMultipartMemory:     defaultMultipartMemory,
		trees:                  make(methodTrees, 0, 9),
		delims:                 render.Delims{Left: "{{", Right: "}}"},
		secureJsonPrefix:       "while(1);",
		secureJSONPrefix:       "while(1);",
	}
	engine.RouterGroup.engine = engine
	engine.pool.New = func() interface{} {

@@ -156,7 +164,8 @@

Loading

}

func (engine *Engine) allocateContext() *Context {
	return &Context{engine: engine}
	v := make(Params, 0, engine.maxParams)
	return &Context{engine: engine, params: &v}
}

// Delims sets template left and right delims and returns a Engine instance.

@@ -165,9 +174,9 @@

Loading

	return engine
}

// SecureJsonPrefix sets the secureJsonPrefix used in Context.SecureJSON.
// SecureJsonPrefix sets the secureJSONPrefix used in Context.SecureJSON.
func (engine *Engine) SecureJsonPrefix(prefix string) *Engine {
	engine.secureJsonPrefix = prefix
	engine.secureJSONPrefix = prefix
	return engine
}


@@ -249,6 +258,7 @@

Loading

	assert1(len(handlers) > 0, "there must be at least one handler")

	debugPrintRoute(method, path, handlers)

	root := engine.trees.get(method)
	if root == nil {
		root = new(node)

@@ -256,6 +266,11 @@

Loading

		engine.trees = append(engine.trees, methodTree{method: method, root: root})
	}
	root.addRoute(path, handlers)

	// Update maxParams
	if paramsCount := countParams(path); paramsCount > engine.maxParams {
		engine.maxParams = paramsCount
	}
}

// Routes returns a slice of registered routes, including some useful information, such as:

@@ -314,13 +329,13 @@

Loading

	debugPrint("Listening and serving HTTP on unix:/%s", file)
	defer func() { debugPrintError(err) }()

	os.Remove(file)
	listener, err := net.Listen("unix", file)
	if err != nil {
		return
	}
	defer listener.Close()
	os.Chmod(file, 0777)
	defer os.Remove(file)

	err = http.Serve(listener, engine)
	return
}

@@ -338,6 +353,15 @@

Loading

		return
	}
	defer listener.Close()
	err = engine.RunListener(listener)
	return
}

// RunListener attaches the router to a http.Server and starts listening and serving HTTP requests
// through the specified net.Listener
func (engine *Engine) RunListener(listener net.Listener) (err error) {
	debugPrint("Listening and serving HTTP on listener what's bind with address@%s", listener.Addr())
	defer func() { debugPrintError(err) }()
	err = http.Serve(listener, engine)
	return
}

@@ -373,7 +397,10 @@

Loading

		rPath = c.Request.URL.RawPath
		unescape = engine.UnescapePathValues
	}
	rPath = cleanPath(rPath)

	if engine.RemoveExtraSlash {
		rPath = cleanPath(rPath)
	}

	// Find root of the tree for the given HTTP method
	t := engine.trees

@@ -383,10 +410,12 @@

Loading

		}
		root := t[i].root
		// Find route in tree
		value := root.getValue(rPath, c.Params, unescape)
		value := root.getValue(rPath, c.params, unescape)
		if value.params != nil {
			c.Params = *value.params
		}
		if value.handlers != nil {
			c.handlers = value.handlers
			c.Params = value.params
			c.fullPath = value.fullPath
			c.Next()
			c.writermem.WriteHeaderNow()

@@ -445,18 +474,11 @@

Loading

	if prefix := path.Clean(c.Request.Header.Get("X-Forwarded-Prefix")); prefix != "." {
		p = prefix + "/" + req.URL.Path
	}
	code := http.StatusMovedPermanently // Permanent redirect, request with GET method
	if req.Method != "GET" {
		code = http.StatusTemporaryRedirect
	}

	req.URL.Path = p + "/"
	if length := len(p); length > 1 && p[length-1] == '/' {
		req.URL.Path = p[:length-1]
	}
	debugPrint("redirecting request %d: %s --> %s", code, p, req.URL.String())
	http.Redirect(c.Writer, req, req.URL.String(), code)
	c.writermem.WriteHeaderNow()
	redirectRequest(c)
}

func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {

@@ -464,15 +486,23 @@

Loading

	rPath := req.URL.Path

	if fixedPath, ok := root.findCaseInsensitivePath(cleanPath(rPath), trailingSlash); ok {
		code := http.StatusMovedPermanently // Permanent redirect, request with GET method
		if req.Method != "GET" {
			code = http.StatusTemporaryRedirect
		}
		req.URL.Path = string(fixedPath)
		debugPrint("redirecting request %d: %s --> %s", code, rPath, req.URL.String())
		http.Redirect(c.Writer, req, req.URL.String(), code)
		c.writermem.WriteHeaderNow()
		req.URL.Path = bytesconv.BytesToString(fixedPath)
		redirectRequest(c)
		return true
	}
	return false
}

func redirectRequest(c *Context) {
	req := c.Request
	rPath := req.URL.Path
	rURL := req.URL.String()

	code := http.StatusMovedPermanently // Permanent redirect, request with GET method
	if req.Method != http.MethodGet {
		code = http.StatusTemporaryRedirect
	}
	debugPrint("redirecting request %d: %s --> %s", code, rPath, rURL)
	http.Redirect(c.Writer, req, rURL, code)
	c.writermem.WriteHeaderNow()
}

@@ -67,7 +67,7 @@

Loading


func debugPrintWARNINGDefault() {
	if v, e := getMinVer(runtime.Version()); e == nil && v <= ginSupportMinGoVer {
		debugPrint(`[WARNING] Now Gin requires Go 1.10 or later and Go 1.11 will be required soon.
		debugPrint(`[WARNING] Now Gin requires Go 1.11 or later and Go 1.12 will be required soon.

`)
	}

@@ -90,20 +90,23 @@

Loading

}

func chooseData(custom, wildcard interface{}) interface{} {
	if custom == nil {
		if wildcard == nil {
			panic("negotiation config is invalid")
		}
	if custom != nil {
		return custom
	}
	if wildcard != nil {
		return wildcard
	}
	return custom
	panic("negotiation config is invalid")
}

func parseAccept(acceptHeader string) []string {
	parts := strings.Split(acceptHeader, ",")
	out := make([]string, 0, len(parts))
	for _, part := range parts {
		if part = strings.TrimSpace(strings.Split(part, ";")[0]); part != "" {
		if i := strings.IndexByte(part, ';'); i > 0 {
			part = part[:i]
		}
		if part = strings.TrimSpace(part); part != "" {
			out = append(out, part)
		}
	}

@@ -127,8 +130,7 @@

Loading

	}

	finalPath := path.Join(absolutePath, relativePath)
	appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/'
	if appendSlash {
	if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' {
		return finalPath + "/"
	}
	return finalPath

@@ -12,10 +12,11 @@

Loading

	"strings"
	"time"

	"github.com/gin-gonic/gin/internal/bytesconv"
	"github.com/gin-gonic/gin/internal/json"
)

var errUnknownType = errors.New("Unknown type")
var errUnknownType = errors.New("unknown type")

func mapUri(ptr interface{}, m map[string][]string) error {
	return mapFormByTag(ptr, m, "uri")

@@ -51,6 +52,10 @@

Loading

}

func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
	if field.Tag.Get(tag) == "-" { // just ignoring this field
		return false, nil
	}

	var vKind = value.Kind()

	if vKind == reflect.Ptr {

@@ -112,9 +117,6 @@

Loading

	tagValue = field.Tag.Get(tag)
	tagValue, opts := head(tagValue, ",")

	if tagValue == "-" { // just ignoring this field
		return false, nil
	}
	if tagValue == "" { // default value is FieldName
		tagValue = field.Name
	}

@@ -207,9 +209,9 @@

Loading

		case time.Time:
			return setTimeField(val, field, value)
		}
		return json.Unmarshal([]byte(val), value.Addr().Interface())
		return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
	case reflect.Map:
		return json.Unmarshal([]byte(val), value.Addr().Interface())
		return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
	default:
		return errUnknownType
	}

@@ -268,7 +270,7 @@

Loading


	switch tf := strings.ToLower(timeFormat); tf {
	case "unix", "unixnano":
		tv, err := strconv.ParseInt(val, 10, 0)
		tv, err := strconv.ParseInt(val, 10, 64)
		if err != nil {
			return err
		}

@@ -99,19 +99,19 @@

Loading

	method := p.Method

	switch method {
	case "GET":
	case http.MethodGet:
		return blue
	case "POST":
	case http.MethodPost:
		return cyan
	case "PUT":
	case http.MethodPut:
		return yellow
	case "DELETE":
	case http.MethodDelete:
		return red
	case "PATCH":
	case http.MethodPatch:
		return green
	case "HEAD":
	case http.MethodHead:
		return magenta
	case "OPTIONS":
	case http.MethodOptions:
		return white
	default:
		return reset

@@ -141,7 +141,7 @@

Loading

		// Truncate in a golang < 1.8 safe way
		param.Latency = param.Latency - param.Latency%time.Second
	}
	return fmt.Sprintf("[GIN] %v |%s %3d %s| %13v | %15s |%s %-7s %s %s\n%s",
	return fmt.Sprintf("[GIN] %v |%s %3d %s| %13v | %15s |%s %-7s %s %#v\n%s",
		param.TimeStamp.Format("2006/01/02 - 15:04:05"),
		statusColor, param.StatusCode, resetColor,
		param.Latency,

@@ -26,13 +26,29 @@

Loading

	slash     = []byte("/")
)

// RecoveryFunc defines the function passable to CustomRecovery.
type RecoveryFunc func(c *Context, err interface{})

// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
func Recovery() HandlerFunc {
	return RecoveryWithWriter(DefaultErrorWriter)
}

//CustomRecovery returns a middleware that recovers from any panics and calls the provided handle func to handle it.
func CustomRecovery(handle RecoveryFunc) HandlerFunc {
	return RecoveryWithWriter(DefaultErrorWriter, handle)
}

// RecoveryWithWriter returns a middleware for a given writer that recovers from any panics and writes a 500 if there was one.
func RecoveryWithWriter(out io.Writer) HandlerFunc {
func RecoveryWithWriter(out io.Writer, recovery ...RecoveryFunc) HandlerFunc {
	if len(recovery) > 0 {
		return CustomRecoveryWithWriter(out, recovery[0])
	}
	return CustomRecoveryWithWriter(out, defaultHandleRecovery)
}

// CustomRecoveryWithWriter returns a middleware for a given writer that recovers from any panics and calls the provided handle func to handle it.
func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc {
	var logger *log.Logger
	if out != nil {
		logger = log.New(out, "\n\n\x1b[31m", log.LstdFlags)

@@ -60,23 +76,23 @@

Loading

							headers[idx] = current[0] + ": *"
						}
					}
					headersToStr := strings.Join(headers, "\r\n")
					if brokenPipe {
						logger.Printf("%s\n%s%s", err, string(httpRequest), reset)
						logger.Printf("%s\n%s%s", err, headersToStr, reset)
					} else if IsDebugging() {
						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
							timeFormat(time.Now()), strings.Join(headers, "\r\n"), err, stack, reset)
							timeFormat(time.Now()), headersToStr, err, stack, reset)
					} else {
						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s",
							timeFormat(time.Now()), err, stack, reset)
					}
				}

				// If the connection is dead, we can't write a status to it.
				if brokenPipe {
					// If the connection is dead, we can't write a status to it.
					c.Error(err.(error)) // nolint: errcheck
					c.Abort()
				} else {
					c.AbortWithStatus(http.StatusInternalServerError)
					handle(c, err)
				}
			}
		}()

@@ -84,6 +100,10 @@

Loading

	}
}

func defaultHandleRecovery(c *Context, err interface{}) {
	c.AbortWithStatus(http.StatusInternalServerError)
}

// stack returns a nicely formatted stack frame, skipping skip frames.
func stack(skip int) []byte {
	buf := new(bytes.Buffer) // the returned data

@@ -146,6 +166,6 @@

Loading

}

func timeFormat(t time.Time) string {
	var timeString = t.Format("2006/01/02 - 15:04:05")
	timeString := t.Format("2006/01/02 - 15:04:05")
	return timeString
}

@@ -10,6 +10,7 @@

Loading

	"html/template"
	"net/http"

	"github.com/gin-gonic/gin/internal/bytesconv"
	"github.com/gin-gonic/gin/internal/json"
)


@@ -40,9 +41,6 @@

Loading

	Data interface{}
}

// SecureJSONPrefix is a string which represents SecureJSON prefix.
type SecureJSONPrefix string

// PureJSON contains the given interface object.
type PureJSON struct {
	Data interface{}

@@ -68,8 +66,11 @@

Loading

// WriteJSON marshals the given interface object and writes it with custom ContentType.
func WriteJSON(w http.ResponseWriter, obj interface{}) error {
	writeContentType(w, jsonContentType)
	encoder := json.NewEncoder(w)
	err := encoder.Encode(&obj)
	jsonBytes, err := json.Marshal(obj)
	if err != nil {
		return err
	}
	_, err = w.Write(jsonBytes)
	return err
}


@@ -97,8 +98,9 @@

Loading

		return err
	}
	// if the jsonBytes is array values
	if bytes.HasPrefix(jsonBytes, []byte("[")) && bytes.HasSuffix(jsonBytes, []byte("]")) {
		_, err = w.Write([]byte(r.Prefix))
	if bytes.HasPrefix(jsonBytes, bytesconv.StringToBytes("[")) && bytes.HasSuffix(jsonBytes,
		bytesconv.StringToBytes("]")) {
		_, err = w.Write(bytesconv.StringToBytes(r.Prefix))
		if err != nil {
			return err
		}

@@ -126,11 +128,11 @@

Loading

	}

	callback := template.JSEscapeString(r.Callback)
	_, err = w.Write([]byte(callback))
	_, err = w.Write(bytesconv.StringToBytes(callback))
	if err != nil {
		return err
	}
	_, err = w.Write([]byte("("))
	_, err = w.Write(bytesconv.StringToBytes("("))
	if err != nil {
		return err
	}

@@ -138,7 +140,7 @@

Loading

	if err != nil {
		return err
	}
	_, err = w.Write([]byte(");"))
	_, err = w.Write(bytesconv.StringToBytes(");"))
	if err != nil {
		return err
	}

@@ -160,7 +162,7 @@

Loading

	}

	var buffer bytes.Buffer
	for _, r := range string(ret) {
	for _, r := range bytesconv.BytesToString(ret) {
		cvt := string(r)
		if r >= 128 {
			cvt = fmt.Sprintf("\\u%04x", int64(r))

@@ -9,7 +9,7 @@

Loading

	"os"
)

type onlyfilesFS struct {
type onlyFilesFS struct {
	fs http.FileSystem
}


@@ -26,11 +26,11 @@

Loading

	if listDirectory {
		return fs
	}
	return &onlyfilesFS{fs}
	return &onlyFilesFS{fs}
}

// Open conforms to http.Filesystem.
func (fs onlyfilesFS) Open(name string) (http.File, error) {
func (fs onlyFilesFS) Open(name string) (http.File, error) {
	f, err := fs.fs.Open(name)
	if err != nil {
		return nil, err

@@ -95,51 +95,51 @@

Loading


// POST is a shortcut for router.Handle("POST", path, handle).
func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle("POST", relativePath, handlers)
	return group.handle(http.MethodPost, relativePath, handlers)
}

// GET is a shortcut for router.Handle("GET", path, handle).
func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle("GET", relativePath, handlers)
	return group.handle(http.MethodGet, relativePath, handlers)
}

// DELETE is a shortcut for router.Handle("DELETE", path, handle).
func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle("DELETE", relativePath, handlers)
	return group.handle(http.MethodDelete, relativePath, handlers)
}

// PATCH is a shortcut for router.Handle("PATCH", path, handle).
func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle("PATCH", relativePath, handlers)
	return group.handle(http.MethodPatch, relativePath, handlers)
}

// PUT is a shortcut for router.Handle("PUT", path, handle).
func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle("PUT", relativePath, handlers)
	return group.handle(http.MethodPut, relativePath, handlers)
}

// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle).
func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle("OPTIONS", relativePath, handlers)
	return group.handle(http.MethodOptions, relativePath, handlers)
}

// HEAD is a shortcut for router.Handle("HEAD", path, handle).
func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle("HEAD", relativePath, handlers)
	return group.handle(http.MethodHead, relativePath, handlers)
}

// Any registers a route that matches all the HTTP methods.
// GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE.
func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) IRoutes {
	group.handle("GET", relativePath, handlers)
	group.handle("POST", relativePath, handlers)
	group.handle("PUT", relativePath, handlers)
	group.handle("PATCH", relativePath, handlers)
	group.handle("HEAD", relativePath, handlers)
	group.handle("OPTIONS", relativePath, handlers)
	group.handle("DELETE", relativePath, handlers)
	group.handle("CONNECT", relativePath, handlers)
	group.handle("TRACE", relativePath, handlers)
	group.handle(http.MethodGet, relativePath, handlers)
	group.handle(http.MethodPost, relativePath, handlers)
	group.handle(http.MethodPut, relativePath, handlers)
	group.handle(http.MethodPatch, relativePath, handlers)
	group.handle(http.MethodHead, relativePath, handlers)
	group.handle(http.MethodOptions, relativePath, handlers)
	group.handle(http.MethodDelete, relativePath, handlers)
	group.handle(http.MethodConnect, relativePath, handlers)
	group.handle(http.MethodTrace, relativePath, handlers)
	return group.returnObj()
}


@@ -187,19 +187,21 @@

Loading

	fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))

	return func(c *Context) {
		if _, nolisting := fs.(*onlyfilesFS); nolisting {
		if _, noListing := fs.(*onlyFilesFS); noListing {
			c.Writer.WriteHeader(http.StatusNotFound)
		}

		file := c.Param("filepath")
		// Check if file exists and/or if we have permission to access it
		if _, err := fs.Open(file); err != nil {
		f, err := fs.Open(file)
		if err != nil {
			c.Writer.WriteHeader(http.StatusNotFound)
			c.handlers = group.engine.noRoute
			// Reset index
			c.index = -1
			return
		}
		f.Close()

		fileServer.ServeHTTP(c.Writer, c.Request)
	}

@@ -5,9 +5,18 @@

Loading

package gin

import (
	"bytes"
	"net/url"
	"strings"
	"unicode"
	"unicode/utf8"

	"github.com/gin-gonic/gin/internal/bytesconv"
)

var (
	strColon = []byte(":")
	strStar  = []byte("*")
)

// Param is a single URL parameter, consisting of a key and a value.

@@ -62,18 +71,21 @@

Loading

	return b
}

func countParams(path string) uint8 {
	var n uint
	for i := 0; i < len(path); i++ {
		if path[i] != ':' && path[i] != '*' {
			continue
		}
		n++
func longestCommonPrefix(a, b string) int {
	i := 0
	max := min(len(a), len(b))
	for i < max && a[i] == b[i] {
		i++
	}
	if n >= 255 {
		return 255
	}
	return uint8(n)
	return i
}

func countParams(path string) uint16 {
	var n uint16
	s := bytesconv.StringToBytes(path)
	n += uint16(bytes.Count(s, strColon))
	n += uint16(bytes.Count(s, strStar))
	return n
}

type nodeType uint8

@@ -88,34 +100,33 @@

Loading

type node struct {
	path      string
	indices   string
	wildChild bool
	nType     nodeType
	priority  uint32
	children  []*node
	handlers  HandlersChain
	priority  uint32
	nType     nodeType
	maxParams uint8
	wildChild bool
	fullPath  string
}

// increments priority of the given child and reorders if necessary.
// Increments priority of the given child and reorders if necessary
func (n *node) incrementChildPrio(pos int) int {
	n.children[pos].priority++
	prio := n.children[pos].priority
	cs := n.children
	cs[pos].priority++
	prio := cs[pos].priority

	// adjust position (move to front)
	// Adjust position (move to front)
	newPos := pos
	for newPos > 0 && n.children[newPos-1].priority < prio {
		// swap node positions
		n.children[newPos-1], n.children[newPos] = n.children[newPos], n.children[newPos-1]
	for ; newPos > 0 && cs[newPos-1].priority < prio; newPos-- {
		// Swap node positions
		cs[newPos-1], cs[newPos] = cs[newPos], cs[newPos-1]

		newPos--
	}

	// build new index char string
	// Build new index char string
	if newPos != pos {
		n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
			n.indices[pos:pos+1] + // the index char we move
			n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
		n.indices = n.indices[:newPos] + // Unchanged prefix, might be empty
			n.indices[pos:pos+1] + // The index char we move
			n.indices[newPos:pos] + n.indices[pos+1:] // Rest without char at 'pos'
	}

	return newPos

@@ -126,254 +137,250 @@

Loading

func (n *node) addRoute(path string, handlers HandlersChain) {
	fullPath := path
	n.priority++
	numParams := countParams(path)

	// Empty tree
	if len(n.path) == 0 && len(n.children) == 0 {
		n.insertChild(path, fullPath, handlers)
		n.nType = root
		return
	}

	parentFullPathIndex := 0

	// non-empty tree
	if len(n.path) > 0 || len(n.children) > 0 {
	walk:
		for {
			// Update maxParams of the current node
			if numParams > n.maxParams {
				n.maxParams = numParams
walk:
	for {
		// Find the longest common prefix.
		// This also implies that the common prefix contains no ':' or '*'
		// since the existing key can't contain those chars.
		i := longestCommonPrefix(path, n.path)

		// Split edge
		if i < len(n.path) {
			child := node{
				path:      n.path[i:],
				wildChild: n.wildChild,
				indices:   n.indices,
				children:  n.children,
				handlers:  n.handlers,
				priority:  n.priority - 1,
				fullPath:  n.fullPath,
			}

			// Find the longest common prefix.
			// This also implies that the common prefix contains no ':' or '*'
			// since the existing key can't contain those chars.
			i := 0
			max := min(len(path), len(n.path))
			for i < max && path[i] == n.path[i] {
				i++
			}
			n.children = []*node{&child}
			// []byte for proper unicode char conversion, see #65
			n.indices = bytesconv.BytesToString([]byte{n.path[i]})
			n.path = path[:i]
			n.handlers = nil
			n.wildChild = false
			n.fullPath = fullPath[:parentFullPathIndex+i]
		}

			// Split edge
			if i < len(n.path) {
				child := node{
					path:      n.path[i:],
					wildChild: n.wildChild,
					indices:   n.indices,
					children:  n.children,
					handlers:  n.handlers,
					priority:  n.priority - 1,
					fullPath:  n.fullPath,
				}
		// Make new node a child of this node
		if i < len(path) {
			path = path[i:]

				// Update maxParams (max of all children)
				for i := range child.children {
					if child.children[i].maxParams > child.maxParams {
						child.maxParams = child.children[i].maxParams
					}
			if n.wildChild {
				parentFullPathIndex += len(n.path)
				n = n.children[0]
				n.priority++

				// Check if the wildcard matches
				if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
					// Adding a child to a catchAll is not possible
					n.nType != catchAll &&
					// Check for longer wildcard, e.g. :name and :names
					(len(n.path) >= len(path) || path[len(n.path)] == '/') {
					continue walk
				}

				n.children = []*node{&child}
				// []byte for proper unicode char conversion, see #65
				n.indices = string([]byte{n.path[i]})
				n.path = path[:i]
				n.handlers = nil
				n.wildChild = false
				n.fullPath = fullPath[:parentFullPathIndex+i]
				pathSeg := path
				if n.nType != catchAll {
					pathSeg = strings.SplitN(path, "/", 2)[0]
				}
				prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
				panic("'" + pathSeg +
					"' in new path '" + fullPath +
					"' conflicts with existing wildcard '" + n.path +
					"' in existing prefix '" + prefix +
					"'")
			}

			// Make new node a child of this node
			if i < len(path) {
				path = path[i:]

				if n.wildChild {
					parentFullPathIndex += len(n.path)
					n = n.children[0]
					n.priority++

					// Update maxParams of the child node
					if numParams > n.maxParams {
						n.maxParams = numParams
					}
					numParams--

					// Check if the wildcard matches
					if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
						// check for longer wildcard, e.g. :name and :names
						if len(n.path) >= len(path) || path[len(n.path)] == '/' {
							continue walk
						}
					}
			c := path[0]

					pathSeg := path
					if n.nType != catchAll {
						pathSeg = strings.SplitN(path, "/", 2)[0]
					}
					prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
					panic("'" + pathSeg +
						"' in new path '" + fullPath +
						"' conflicts with existing wildcard '" + n.path +
						"' in existing prefix '" + prefix +
						"'")
				}

				c := path[0]
			// slash after param
			if n.nType == param && c == '/' && len(n.children) == 1 {
				parentFullPathIndex += len(n.path)
				n = n.children[0]
				n.priority++
				continue walk
			}

				// slash after param
				if n.nType == param && c == '/' && len(n.children) == 1 {
			// Check if a child with the next path byte exists
			for i, max := 0, len(n.indices); i < max; i++ {
				if c == n.indices[i] {
					parentFullPathIndex += len(n.path)
					n = n.children[0]
					n.priority++
					i = n.incrementChildPrio(i)
					n = n.children[i]
					continue walk
				}
			}

				// Check if a child with the next path byte exists
				for i := 0; i < len(n.indices); i++ {
					if c == n.indices[i] {
						parentFullPathIndex += len(n.path)
						i = n.incrementChildPrio(i)
						n = n.children[i]
						continue walk
					}
				}

				// Otherwise insert it
				if c != ':' && c != '*' {
					// []byte for proper unicode char conversion, see #65
					n.indices += string([]byte{c})
					child := &node{
						maxParams: numParams,
						fullPath:  fullPath,
					}
					n.children = append(n.children, child)
					n.incrementChildPrio(len(n.indices) - 1)
					n = child
				}
				n.insertChild(numParams, path, fullPath, handlers)
				return

			} else if i == len(path) { // Make node a (in-path) leaf
				if n.handlers != nil {
					panic("handlers are already registered for path '" + fullPath + "'")
			// Otherwise insert it
			if c != ':' && c != '*' {
				// []byte for proper unicode char conversion, see #65
				n.indices += bytesconv.BytesToString([]byte{c})
				child := &node{
					fullPath: fullPath,
				}
				n.handlers = handlers
				n.children = append(n.children, child)
				n.incrementChildPrio(len(n.indices) - 1)
				n = child
			}
			n.insertChild(path, fullPath, handlers)
			return
		}
	} else { // Empty tree
		n.insertChild(numParams, path, fullPath, handlers)
		n.nType = root

		// Otherwise and handle to current node
		if n.handlers != nil {
			panic("handlers are already registered for path '" + fullPath + "'")
		}
		n.handlers = handlers
		n.fullPath = fullPath
		return
	}
}

func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers HandlersChain) {
	var offset int // already handled bytes of the path

	// find prefix until first wildcard (beginning with ':' or '*')
	for i, max := 0, len(path); numParams > 0; i++ {
		c := path[i]
// Search for a wildcard segment and check the name for invalid characters.
// Returns -1 as index, if no wildcard was found.
func findWildcard(path string) (wildcard string, i int, valid bool) {
	// Find start
	for start, c := range []byte(path) {
		// A wildcard starts with ':' (param) or '*' (catch-all)
		if c != ':' && c != '*' {
			continue
		}

		// find wildcard end (either '/' or path end)
		end := i + 1
		for end < max && path[end] != '/' {
			switch path[end] {
			// the wildcard name must not contain ':' and '*'
		// Find end and check for invalid characters
		valid = true
		for end, c := range []byte(path[start+1:]) {
			switch c {
			case '/':
				return path[start : start+1+end], start, valid
			case ':', '*':
				panic("only one wildcard per path segment is allowed, has: '" +
					path[i:] + "' in path '" + fullPath + "'")
			default:
				end++
				valid = false
			}
		}
		return path[start:], start, valid
	}
	return "", -1, false
}

		// check if this Node existing children which would be
		// unreachable if we insert the wildcard here
		if len(n.children) > 0 {
			panic("wildcard route '" + path[i:end] +
				"' conflicts with existing children in path '" + fullPath + "'")
func (n *node) insertChild(path string, fullPath string, handlers HandlersChain) {
	for {
		// Find prefix until first wildcard
		wildcard, i, valid := findWildcard(path)
		if i < 0 { // No wildcard found
			break
		}

		// The wildcard name must not contain ':' and '*'
		if !valid {
			panic("only one wildcard per path segment is allowed, has: '" +
				wildcard + "' in path '" + fullPath + "'")
		}

		// check if the wildcard has a name
		if end-i < 2 {
		if len(wildcard) < 2 {
			panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
		}

		if c == ':' { // param
			// split path at the beginning of the wildcard
		// Check if this node has existing children which would be
		// unreachable if we insert the wildcard here
		if len(n.children) > 0 {
			panic("wildcard segment '" + wildcard +
				"' conflicts with existing children in path '" + fullPath + "'")
		}

		if wildcard[0] == ':' { // param
			if i > 0 {
				n.path = path[offset:i]
				offset = i
				// Insert prefix before the current wildcard
				n.path = path[:i]
				path = path[i:]
			}

			n.wildChild = true
			child := &node{
				nType:     param,
				maxParams: numParams,
				fullPath:  fullPath,
				nType:    param,
				path:     wildcard,
				fullPath: fullPath,
			}
			n.children = []*node{child}
			n.wildChild = true
			n = child
			n.priority++
			numParams--

			// if the path doesn't end with the wildcard, then there
			// will be another non-wildcard subpath starting with '/'
			if end < max {
				n.path = path[offset:end]
				offset = end
			if len(wildcard) < len(path) {
				path = path[len(wildcard):]

				child := &node{
					maxParams: numParams,
					priority:  1,
					fullPath:  fullPath,
					priority: 1,
					fullPath: fullPath,
				}
				n.children = []*node{child}
				n = child
				continue
			}

		} else { // catchAll
			if end != max || numParams > 1 {
				panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
			}
			// Otherwise we're done. Insert the handle in the new leaf
			n.handlers = handlers
			return
		}

			if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
				panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
			}
		// catchAll
		if i+len(wildcard) != len(path) {
			panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
		}

			// currently fixed width 1 for '/'
			i--
			if path[i] != '/' {
				panic("no / before catch-all in path '" + fullPath + "'")
			}
		if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
			panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
		}

			n.path = path[offset:i]
		// currently fixed width 1 for '/'
		i--
		if path[i] != '/' {
			panic("no / before catch-all in path '" + fullPath + "'")
		}

			// first node: catchAll node with empty path
			child := &node{
				wildChild: true,
				nType:     catchAll,
				maxParams: 1,
				fullPath:  fullPath,
			}
			n.children = []*node{child}
			n.indices = string(path[i])
			n = child
			n.priority++
		n.path = path[:i]

			// second node: node holding the variable
			child = &node{
				path:      path[i:],
				nType:     catchAll,
				maxParams: 1,
				handlers:  handlers,
				priority:  1,
				fullPath:  fullPath,
			}
			n.children = []*node{child}
		// First node: catchAll node with empty path
		child := &node{
			wildChild: true,
			nType:     catchAll,
			fullPath:  fullPath,
		}

			return
		n.children = []*node{child}
		n.indices = string('/')
		n = child
		n.priority++

		// second node: node holding the variable
		child = &node{
			path:     path[i:],
			nType:    catchAll,
			handlers: handlers,
			priority: 1,
			fullPath: fullPath,
		}
		n.children = []*node{child}

		return
	}

	// insert remaining path part and handle to the leaf
	n.path = path[offset:]
	// If no wildcard was found, simply insert the path and handle
	n.path = path
	n.handlers = handlers
	n.fullPath = fullPath
}

@@ -381,30 +388,30 @@

Loading

// nodeValue holds return values of (*Node).getValue method
type nodeValue struct {
	handlers HandlersChain
	params   Params
	params   *Params
	tsr      bool
	fullPath string
}

// getValue returns the handle registered with the given path (key). The values of
// Returns the handle registered with the given path (key). The values of
// wildcards are saved to a map.
// If no handle can be found, a TSR (trailing slash redirect) recommendation is
// made if a handle exists with an extra (without the) trailing slash for the
// given path.
func (n *node) getValue(path string, po Params, unescape bool) (value nodeValue) {
	value.params = po
func (n *node) getValue(path string, params *Params, unescape bool) (value nodeValue) {
walk: // Outer loop for walking the tree
	for {
		if len(path) > len(n.path) {
			if path[:len(n.path)] == n.path {
				path = path[len(n.path):]
		prefix := n.path
		if len(path) > len(prefix) {
			if path[:len(prefix)] == prefix {
				path = path[len(prefix):]
				// If this node does not have a wildcard (param or catchAll)
				// child,  we can just look up the next child node and continue
				// child, we can just look up the next child node and continue
				// to walk down the tree
				if !n.wildChild {
					c := path[0]
					for i := 0; i < len(n.indices); i++ {
						if c == n.indices[i] {
					idxc := path[0]
					for i, c := range []byte(n.indices) {
						if c == idxc {
							n = n.children[i]
							continue walk
						}

@@ -413,35 +420,38 @@

Loading

					// Nothing found.
					// We can recommend to redirect to the same URL without a
					// trailing slash if a leaf exists for that path.
					value.tsr = path == "/" && n.handlers != nil
					value.tsr = (path == "/" && n.handlers != nil)
					return
				}

				// handle wildcard child
				// Handle wildcard child
				n = n.children[0]
				switch n.nType {
				case param:
					// find param end (either '/' or path end)
					// Find param end (either '/' or path end)
					end := 0
					for end < len(path) && path[end] != '/' {
						end++
					}

					// save param value
					if cap(value.params) < int(n.maxParams) {
						value.params = make(Params, 0, n.maxParams)
					}
					i := len(value.params)
					value.params = value.params[:i+1] // expand slice within preallocated capacity
					value.params[i].Key = n.path[1:]
					val := path[:end]
					if unescape {
						var err error
						if value.params[i].Value, err = url.QueryUnescape(val); err != nil {
							value.params[i].Value = val // fallback, in case of error
					// Save param value
					if params != nil {
						if value.params == nil {
							value.params = params
						}
						// Expand slice within preallocated capacity
						i := len(*value.params)
						*value.params = (*value.params)[:i+1]
						val := path[:end]
						if unescape {
							if v, err := url.QueryUnescape(val); err == nil {
								val = v
							}
						}
						(*value.params)[i] = Param{
							Key:   n.path[1:],
							Value: val,
						}
					} else {
						value.params[i].Value = val
					}

					// we need to go deeper!

@@ -453,7 +463,7 @@

Loading

						}

						// ... but we can't
						value.tsr = len(path) == end+1
						value.tsr = (len(path) == end+1)
						return
					}


@@ -465,26 +475,29 @@

Loading

						// No handle found. Check if a handle for this path + a
						// trailing slash exists for TSR recommendation
						n = n.children[0]
						value.tsr = n.path == "/" && n.handlers != nil
						value.tsr = (n.path == "/" && n.handlers != nil)
					}

					return

				case catchAll:
					// save param value
					if cap(value.params) < int(n.maxParams) {
						value.params = make(Params, 0, n.maxParams)
					}
					i := len(value.params)
					value.params = value.params[:i+1] // expand slice within preallocated capacity
					value.params[i].Key = n.path[2:]
					if unescape {
						var err error
						if value.params[i].Value, err = url.QueryUnescape(path); err != nil {
							value.params[i].Value = path // fallback, in case of error
					// Save param value
					if params != nil {
						if value.params == nil {
							value.params = params
						}
						// Expand slice within preallocated capacity
						i := len(*value.params)
						*value.params = (*value.params)[:i+1]
						val := path
						if unescape {
							if v, err := url.QueryUnescape(path); err == nil {
								val = v
							}
						}
						(*value.params)[i] = Param{
							Key:   n.path[2:],
							Value: val,
						}
					} else {
						value.params[i].Value = path
					}

					value.handlers = n.handlers

@@ -495,7 +508,9 @@

Loading

					panic("invalid node type")
				}
			}
		} else if path == n.path {
		}

		if path == prefix {
			// We should have reached the node containing the handle.
			// Check if this node has a handle registered.
			if value.handlers = n.handlers; value.handlers != nil {

@@ -503,6 +518,9 @@

Loading

				return
			}

			// If there is no handle for this route, but this route has a
			// wildcard child, there must be a handle for this path with an
			// additional trailing slash
			if path == "/" && n.wildChild && n.nType != root {
				value.tsr = true
				return

@@ -510,8 +528,8 @@

Loading


			// No handle found. Check if a handle for this path + a
			// trailing slash exists for trailing slash recommendation
			for i := 0; i < len(n.indices); i++ {
				if n.indices[i] == '/' {
			for i, c := range []byte(n.indices) {
				if c == '/' {
					n = n.children[i]
					value.tsr = (len(n.path) == 1 && n.handlers != nil) ||
						(n.nType == catchAll && n.children[0].handlers != nil)

@@ -525,22 +543,61 @@

Loading

		// Nothing found. We can recommend to redirect to the same URL with an
		// extra trailing slash if a leaf exists for that path
		value.tsr = (path == "/") ||
			(len(n.path) == len(path)+1 && n.path[len(path)] == '/' &&
				path == n.path[:len(n.path)-1] && n.handlers != nil)
			(len(prefix) == len(path)+1 && prefix[len(path)] == '/' &&
				path == prefix[:len(prefix)-1] && n.handlers != nil)
		return
	}
}

// findCaseInsensitivePath makes a case-insensitive lookup of the given path and tries to find a handler.
// Makes a case-insensitive lookup of the given path and tries to find a handler.
// It can optionally also fix trailing slashes.
// It returns the case-corrected path and a bool indicating whether the lookup
// was successful.
func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
	ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) ([]byte, bool) {
	const stackBufSize = 128

	// Use a static sized buffer on the stack in the common case.
	// If the path is too long, allocate a buffer on the heap instead.
	buf := make([]byte, 0, stackBufSize)
	if l := len(path) + 1; l > stackBufSize {
		buf = make([]byte, 0, l)
	}

	// Outer loop for walking the tree
	for len(path) >= len(n.path) && strings.EqualFold(path[:len(n.path)], n.path) {
		path = path[len(n.path):]
	ciPath := n.findCaseInsensitivePathRec(
		path,
		buf,       // Preallocate enough memory for new path
		[4]byte{}, // Empty rune buffer
		fixTrailingSlash,
	)

	return ciPath, ciPath != nil
}

// Shift bytes in array by n bytes left
func shiftNRuneBytes(rb [4]byte, n int) [4]byte {
	switch n {
	case 0:
		return rb
	case 1:
		return [4]byte{rb[1], rb[2], rb[3], 0}
	case 2:
		return [4]byte{rb[2], rb[3]}
	case 3:
		return [4]byte{rb[3]}
	default:
		return [4]byte{}
	}
}

// Recursive case-insensitive lookup function used by n.findCaseInsensitivePath
func (n *node) findCaseInsensitivePathRec(path string, ciPath []byte, rb [4]byte, fixTrailingSlash bool) []byte {
	npLen := len(n.path)

walk: // Outer loop for walking the tree
	for len(path) >= npLen && (npLen == 0 || strings.EqualFold(path[1:npLen], n.path[1:])) {
		// Add common prefix to result
		oldPath := path
		path = path[npLen:]
		ciPath = append(ciPath, n.path...)

		if len(path) > 0 {

@@ -548,65 +605,132 @@

Loading

			// we can just look up the next child node and continue to walk down
			// the tree
			if !n.wildChild {
				r := unicode.ToLower(rune(path[0]))
				for i, index := range n.indices {
					// must use recursive approach since both index and
					// ToLower(index) could exist. We must check both.
					if r == unicode.ToLower(index) {
						out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash)
						if found {
							return append(ciPath, out...), true
				// Skip rune bytes already processed
				rb = shiftNRuneBytes(rb, npLen)

				if rb[0] != 0 {
					// Old rune not finished
					idxc := rb[0]
					for i, c := range []byte(n.indices) {
						if c == idxc {
							// continue with child node
							n = n.children[i]
							npLen = len(n.path)
							continue walk
						}
					}
				} else {
					// Process a new rune
					var rv rune

					// Find rune start.
					// Runes are up to 4 byte long,
					// -4 would definitely be another rune.
					var off int
					for max := min(npLen, 3); off < max; off++ {
						if i := npLen - off; utf8.RuneStart(oldPath[i]) {
							// read rune from cached path
							rv, _ = utf8.DecodeRuneInString(oldPath[i:])
							break
						}
					}

					// Calculate lowercase bytes of current rune
					lo := unicode.ToLower(rv)
					utf8.EncodeRune(rb[:], lo)

					// Skip already processed bytes
					rb = shiftNRuneBytes(rb, off)

					idxc := rb[0]
					for i, c := range []byte(n.indices) {
						// Lowercase matches
						if c == idxc {
							// must use a recursive approach since both the
							// uppercase byte and the lowercase byte might exist
							// as an index
							if out := n.children[i].findCaseInsensitivePathRec(
								path, ciPath, rb, fixTrailingSlash,
							); out != nil {
								return out
							}
							break
						}
					}

					// If we found no match, the same for the uppercase rune,
					// if it differs
					if up := unicode.ToUpper(rv); up != lo {
						utf8.EncodeRune(rb[:], up)
						rb = shiftNRuneBytes(rb, off)

						idxc := rb[0]
						for i, c := range []byte(n.indices) {
							// Uppercase matches
							if c == idxc {
								// Continue with child node
								n = n.children[i]
								npLen = len(n.path)
								continue walk
							}
						}
					}
				}

				// Nothing found. We can recommend to redirect to the same URL
				// without a trailing slash if a leaf exists for that path
				found = fixTrailingSlash && path == "/" && n.handlers != nil
				return
				if fixTrailingSlash && path == "/" && n.handlers != nil {
					return ciPath
				}
				return nil
			}

			n = n.children[0]
			switch n.nType {
			case param:
				// find param end (either '/' or path end)
				k := 0
				for k < len(path) && path[k] != '/' {
					k++
				// Find param end (either '/' or path end)
				end := 0
				for end < len(path) && path[end] != '/' {
					end++
				}

				// add param value to case insensitive path
				ciPath = append(ciPath, path[:k]...)
				// Add param value to case insensitive path
				ciPath = append(ciPath, path[:end]...)

				// we need to go deeper!
				if k < len(path) {
				// We need to go deeper!
				if end < len(path) {
					if len(n.children) > 0 {
						path = path[k:]
						// Continue with child node
						n = n.children[0]
						npLen = len(n.path)
						path = path[end:]
						continue
					}

					// ... but we can't
					if fixTrailingSlash && len(path) == k+1 {
						return ciPath, true
					if fixTrailingSlash && len(path) == end+1 {
						return ciPath
					}
					return
					return nil
				}

				if n.handlers != nil {
					return ciPath, true
				} else if fixTrailingSlash && len(n.children) == 1 {
					return ciPath
				}

				if fixTrailingSlash && len(n.children) == 1 {
					// No handle found. Check if a handle for this path + a
					// trailing slash exists
					n = n.children[0]
					if n.path == "/" && n.handlers != nil {
						return append(ciPath, '/'), true
						return append(ciPath, '/')
					}
				}
				return

				return nil

			case catchAll:
				return append(ciPath, path...), true
				return append(ciPath, path...)

			default:
				panic("invalid node type")

@@ -615,24 +739,24 @@

Loading

			// We should have reached the node containing the handle.
			// Check if this node has a handle registered.
			if n.handlers != nil {
				return ciPath, true
				return ciPath
			}

			// No handle found.
			// Try to fix the path by adding a trailing slash
			if fixTrailingSlash {
				for i := 0; i < len(n.indices); i++ {
					if n.indices[i] == '/' {
				for i, c := range []byte(n.indices) {
					if c == '/' {
						n = n.children[i]
						if (len(n.path) == 1 && n.handlers != nil) ||
							(n.nType == catchAll && n.children[0].handlers != nil) {
							return append(ciPath, '/'), true
							return append(ciPath, '/')
						}
						return
						return nil
					}
				}
			}
			return
			return nil
		}
	}


@@ -640,13 +764,12 @@

Loading

	// Try to fix the path by adding / removing a trailing slash
	if fixTrailingSlash {
		if path == "/" {
			return ciPath, true
			return ciPath
		}
		if len(path)+1 == len(n.path) && n.path[len(path)] == '/' &&
			strings.EqualFold(path, n.path[:len(path)]) &&
			n.handlers != nil {
			return append(ciPath, n.path...), true
		if len(path)+1 == npLen && n.path[len(path)] == '/' &&
			strings.EqualFold(path[1:], n.path[1:len(path)]) && n.handlers != nil {
			return append(ciPath, n.path...)
		}
	}
	return
	return nil
}

@@ -19,13 +19,17 @@

Loading

//
// If the result of this process is an empty string, "/" is returned.
func cleanPath(p string) string {
	const stackBufSize = 128
	// Turn empty string into "/"
	if p == "" {
		return "/"
	}

	// Reasonably sized buffer on stack to avoid allocations in the common case.
	// If a larger buffer is required, it gets allocated dynamically.
	buf := make([]byte, 0, stackBufSize)

	n := len(p)
	var buf []byte

	// Invariants:
	//      reading from path; r is index of next byte to process.

@@ -37,15 +41,21 @@

Loading


	if p[0] != '/' {
		r = 0
		buf = make([]byte, n+1)

		if n+1 > stackBufSize {
			buf = make([]byte, n+1)
		} else {
			buf = buf[:n+1]
		}
		buf[0] = '/'
	}

	trailing := n > 1 && p[n-1] == '/'

	// A bit more clunky without a 'lazybuf' like the path package, but the loop
	// gets completely inlined (bufApp). So in contrast to the path package this
	// loop has no expensive function calls (except 1x make)
	// gets completely inlined (bufApp calls).
	// loop has no expensive function calls (except 1x make)		// So in contrast to the path package this loop has no expensive function
	// calls (except make, if needed).

	for r < n {
		switch {

@@ -69,7 +79,7 @@

Loading

69	79		// can backtrack
70	80		w--
71	81
72		-	if buf == nil {
	82	+	if len(buf) == 0 {
73	83		for w > 1 && p[w] != '/' {
74	84		w--
75	85		}

@@ -81,14 +91,14 @@

Loading

			}

		default:
			// real path element.
			// add slash if needed
			// Real path element.
			// Add slash if needed
			if w > 1 {
				bufApp(&buf, p, w, '/')
				w++
			}

			// copy element
			// Copy element
			for r < n && p[r] != '/' {
				bufApp(&buf, p, w, p[r])
				w++

@@ -97,27 +107,44 @@

Loading

		}
	}

	// re-append trailing slash
	// Re-append trailing slash
	if trailing && w > 1 {
		bufApp(&buf, p, w, '/')
		w++
	}

	if buf == nil {
	// If the original string was not modified (or only shortened at the end),
	// return the respective substring of the original string.
	// Otherwise return a new string from the buffer.
	if len(buf) == 0 {
		return p[:w]
	}
	return string(buf[:w])
}

// internal helper to lazily create a buffer if necessary.
// Internal helper to lazily create a buffer if necessary.
// Calls to this function get inlined.
func bufApp(buf *[]byte, s string, w int, c byte) {
	if *buf == nil {
	b := *buf
	if len(b) == 0 {
		// No modification of the original string so far.
		// If the next character is the same as in the original string, we do
		// not yet have to allocate a buffer.
		if s[w] == c {
			return
		}

		*buf = make([]byte, len(s))
		copy(*buf, s[:w])
		// Otherwise use either the stack buffer, if it is large enough, or
		// allocate a new buffer on the heap, and copy all previous characters.
		length := len(s)
		if length > cap(b) {
			*buf = make([]byte, length)
		} else {
			*buf = (*buf)[:length]
		}
		b = *buf

		copy(b, s[:w])
	}
	(*buf)[w] = c
	b[w] = c
}

@@ -18,6 +18,12 @@

Loading

// interface{} as a Number instead of as a float64.
var EnableDecoderUseNumber = false

// EnableDecoderDisallowUnknownFields is used to call the DisallowUnknownFields method
// on the JSON Decoder instance. DisallowUnknownFields causes the Decoder to
// return an error when the destination is a struct and the input contains object
// keys which do not match any non-ignored, exported fields in the destination.
var EnableDecoderDisallowUnknownFields = false

type jsonBinding struct{}

func (jsonBinding) Name() string {

@@ -40,6 +46,9 @@

Loading

	if EnableDecoderUseNumber {
		decoder.UseNumber()
	}
	if EnableDecoderDisallowUnknownFields {
		decoder.DisallowUnknownFields()
	}
	if err := decoder.Decode(obj); err != nil {
		return err
	}

@@ -27,7 +27,6 @@

Loading

	_ HTMLRender = HTMLDebug{}
	_ HTMLRender = HTMLProduction{}
	_ Render     = YAML{}
	_ Render     = MsgPack{}
	_ Render     = Reader{}
	_ Render     = AsciiJSON{}
	_ Render     = ProtoBuf{}

@@ -16,6 +16,7 @@

Loading

	"net/url"
	"os"
	"strings"
	"sync"
	"time"

	"github.com/gin-contrib/sse"

@@ -33,9 +34,11 @@

Loading

	MIMEPOSTForm          = binding.MIMEPOSTForm
	MIMEMultipartPOSTForm = binding.MIMEMultipartPOSTForm
	MIMEYAML              = binding.MIMEYAML
	BodyBytesKey          = "_gin-gonic/gin/bodybyteskey"
)

// BodyBytesKey indicates a default body bytes key.
const BodyBytesKey = "_gin-gonic/gin/bodybyteskey"

const abortIndex int8 = math.MaxInt8 / 2

// Context is the most important part of gin. It allows us to pass variables between middleware,

@@ -51,6 +54,10 @@

Loading

	fullPath string

	engine *Engine
	params *Params

	// This mutex protect Keys map
	mu sync.RWMutex

	// Keys is a key/value pair exclusively for the context of each request.
	Keys map[string]interface{}

@@ -67,6 +74,10 @@

Loading

	// formCache use url.ParseQuery cached PostForm contains the parsed form data from POST, PATCH,
	// or PUT body parameters.
	formCache url.Values

	// SameSite allows a server to define a cookie attribute making it impossible for
	// the browser to send this cookie along with cross-site requests.
	sameSite http.SameSite
}

/************************************/

@@ -78,18 +89,25 @@

Loading

	c.Params = c.Params[0:0]
	c.handlers = nil
	c.index = -1

	c.fullPath = ""
	c.Keys = nil
	c.Errors = c.Errors[0:0]
	c.Accepted = nil
	c.queryCache = nil
	c.formCache = nil
	*c.params = (*c.params)[0:0]
}

// Copy returns a copy of the current context that can be safely used outside the request's scope.
// This has to be used when the context has to be passed to a goroutine.
func (c *Context) Copy() *Context {
	var cp = *c
	cp := Context{
		writermem: c.writermem,
		Request:   c.Request,
		Params:    c.Params,
		engine:    c.engine,
	}
	cp.writermem.ResponseWriter = nil
	cp.Writer = &cp.writermem
	cp.index = abortIndex

@@ -219,16 +237,21 @@

Loading

// Set is used to store a new key/value pair exclusively for this context.
// It also lazy initializes  c.Keys if it was not used previously.
func (c *Context) Set(key string, value interface{}) {
	c.mu.Lock()
	if c.Keys == nil {
		c.Keys = make(map[string]interface{})
	}

	c.Keys[key] = value
	c.mu.Unlock()
}

// Get returns the value for the given key, ie: (value, true).
// If the value does not exists it returns (nil, false)
func (c *Context) Get(key string) (value interface{}, exists bool) {
	c.mu.RLock()
	value, exists = c.Keys[key]
	c.mu.RUnlock()
	return
}


@@ -272,6 +295,22 @@

Loading

	return
}

// GetUint returns the value associated with the key as an unsigned integer.
func (c *Context) GetUint(key string) (ui uint) {
	if val, ok := c.Get(key); ok && val != nil {
		ui, _ = val.(uint)
	}
	return
}

// GetUint64 returns the value associated with the key as an unsigned integer.
func (c *Context) GetUint64(key string) (ui64 uint64) {
	if val, ok := c.Get(key); ok && val != nil {
		ui64, _ = val.(uint64)
	}
	return
}

// GetFloat64 returns the value associated with the key as a float64.
func (c *Context) GetFloat64(key string) (f64 float64) {
	if val, ok := c.Get(key); ok && val != nil {

@@ -391,17 +430,20 @@

Loading

	return values
}

func (c *Context) getQueryCache() {
func (c *Context) initQueryCache() {
	if c.queryCache == nil {
		c.queryCache = make(url.Values)
		c.queryCache, _ = url.ParseQuery(c.Request.URL.RawQuery)
		if c.Request != nil {
			c.queryCache = c.Request.URL.Query()
		} else {
			c.queryCache = url.Values{}
		}
	}
}

// GetQueryArray returns a slice of strings for a given query key, plus
// a boolean value whether at least one value exists for the given key.
func (c *Context) GetQueryArray(key string) ([]string, bool) {
	c.getQueryCache()
	c.initQueryCache()
	if values, ok := c.queryCache[key]; ok && len(values) > 0 {
		return values, true
	}

@@ -417,7 +459,7 @@

Loading

// GetQueryMap returns a map for a given query key, plus a boolean value
// whether at least one value exists for the given key.
func (c *Context) GetQueryMap(key string) (map[string]string, bool) {
	c.getQueryCache()
	c.initQueryCache()
	return c.get(c.queryCache, key)
}


@@ -459,7 +501,7 @@

Loading

	return values
}

func (c *Context) getFormCache() {
func (c *Context) initFormCache() {
	if c.formCache == nil {
		c.formCache = make(url.Values)
		req := c.Request

@@ -475,7 +517,7 @@

Loading

// GetPostFormArray returns a slice of strings for a given form key, plus
// a boolean value whether at least one value exists for the given key.
func (c *Context) GetPostFormArray(key string) ([]string, bool) {
	c.getFormCache()
	c.initFormCache()
	if values := c.formCache[key]; len(values) > 0 {
		return values, true
	}

@@ -491,13 +533,8 @@

Loading

// GetPostFormMap returns a map for a given form key, plus a boolean value
// whether at least one value exists for the given key.
func (c *Context) GetPostFormMap(key string) (map[string]string, bool) {
	req := c.Request
	if err := req.ParseMultipartForm(c.engine.MaxMultipartMemory); err != nil {
		if err != http.ErrNotMultipart {
			debugPrint("error on parse multipart form map: %v", err)
		}
	}
	return c.get(req.PostForm, key)
	c.initFormCache()
	return c.get(c.formCache, key)
}

// get is an internal method and returns a map which satisfy conditions.

@@ -522,7 +559,11 @@

Loading

			return nil, err
		}
	}
	_, fh, err := c.Request.FormFile(name)
	f, fh, err := c.Request.FormFile(name)
	if err != nil {
		return nil, err
	}
	f.Close()
	return fh, err
}


@@ -760,7 +801,7 @@

Loading


// Status sets the HTTP response code.
func (c *Context) Status(code int) {
	c.writermem.WriteHeader(code)
	c.Writer.WriteHeader(code)
}

// Header is a intelligent shortcut for c.Writer.Header().Set(key, value).

@@ -784,6 +825,11 @@

Loading

	return ioutil.ReadAll(c.Request.Body)
}

// SetSameSite with cookie
func (c *Context) SetSameSite(samesite http.SameSite) {
	c.sameSite = samesite
}

// SetCookie adds a Set-Cookie header to the ResponseWriter's headers.
// The provided cookie must have a valid Name. Invalid cookies may be
// silently dropped.

@@ -797,6 +843,7 @@

Loading

		MaxAge:   maxAge,
		Path:     path,
		Domain:   domain,
		SameSite: c.sameSite,
		Secure:   secure,
		HttpOnly: httpOnly,
	})

@@ -850,7 +897,7 @@

Loading

// Default prepends "while(1)," to response body if the given struct is array values.
// It also sets the Content-Type as "application/json".
func (c *Context) SecureJSON(code int, obj interface{}) {
	c.Render(code, render.SecureJSON{Prefix: c.engine.secureJsonPrefix, Data: obj})
	c.Render(code, render.SecureJSON{Prefix: c.engine.secureJSONPrefix, Data: obj})
}

// JSONP serializes the given struct as JSON into the response body.

@@ -936,10 +983,21 @@

Loading

	http.ServeFile(c.Writer, c.Request, filepath)
}

// FileFromFS writes the specified file from http.FileSystem into the body stream in an efficient way.
func (c *Context) FileFromFS(filepath string, fs http.FileSystem) {
	defer func(old string) {
		c.Request.URL.Path = old
	}(c.Request.URL.Path)

	c.Request.URL.Path = filepath

	http.FileServer(fs).ServeHTTP(c.Writer, c.Request)
}

// FileAttachment writes the specified file into the body stream in an efficient way
// On the client side, the file will typically be downloaded with the given filename
func (c *Context) FileAttachment(filepath, filename string) {
	c.Writer.Header().Set("content-disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
	c.Writer.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))
	http.ServeFile(c.Writer, c.Request, filepath)
}


@@ -981,6 +1039,7 @@

Loading

	HTMLData interface{}
	JSONData interface{}
	XMLData  interface{}
	YAMLData interface{}
	Data     interface{}
}


@@ -999,6 +1058,10 @@

Loading

		data := chooseData(config.XMLData, config.Data)
		c.XML(code, data)

	case binding.MIMEYAML:
		data := chooseData(config.YAMLData, config.Data)
		c.YAML(code, data)

	default:
		c.AbortWithError(http.StatusNotAcceptable, errors.New("the accepted formats are not offered by the server")) // nolint: errcheck
	}

@@ -1015,20 +1078,20 @@

Loading

		return offered[0]
	}
	for _, accepted := range c.Accepted {
		for _, offert := range offered {
		for _, offer := range offered {
			// According to RFC 2616 and RFC 2396, non-ASCII characters are not allowed in headers,
			// therefore we can just iterate over the string without casting it into []rune
			i := 0
			for ; i < len(accepted); i++ {
				if accepted[i] == '*' || offert[i] == '*' {
					return offert
				if accepted[i] == '*' || offer[i] == '*' {
					return offer
				}
				if accepted[i] != offert[i] {
				if accepted[i] != offer[i] {
					break
				}
			}
			if i == len(accepted) {
				return offert
				return offer
			}
		}
	}

@@ -1044,26 +1107,20 @@

Loading

/***** GOLANG.ORG/X/NET/CONTEXT *****/
/************************************/

// Deadline returns the time when work done on behalf of this context
// should be canceled. Deadline returns ok==false when no deadline is
// set. Successive calls to Deadline return the same results.
// Deadline always returns that there is no deadline (ok==false),
// maybe you want to use Request.Context().Deadline() instead.
func (c *Context) Deadline() (deadline time.Time, ok bool) {
	return
}

// Done returns a channel that's closed when work done on behalf of this
// context should be canceled. Done may return nil if this context can
// never be canceled. Successive calls to Done return the same value.
// Done always returns nil (chan which will wait forever),
// if you want to abort your work when the connection was closed
// you should use Request.Context().Done() instead.
func (c *Context) Done() <-chan struct{} {
	return nil
}

// Err returns a non-nil error value after Done is closed,
// successive calls to Err return the same error.
// If Done is not yet closed, Err returns nil.
// If Done is closed, Err returns a non-nil error explaining why:
// Canceled if the context was canceled
// or DeadlineExceeded if the context's deadline passed.
// Err always returns nil, maybe you want to use Request.Context().Err() instead.
func (c *Context) Err() error {
	return nil
}

@@ -22,6 +22,7 @@

Loading

	// TestMode indicates gin mode is test.
	TestMode = "test"
)

const (
	debugCode = iota
	releaseCode

@@ -50,8 +51,12 @@

Loading


// SetMode sets gin mode according to input string.
func SetMode(value string) {
	if value == "" {
		value = DebugMode
	}

	switch value {
	case DebugMode, "":
	case DebugMode:
		ginMode = debugCode
	case ReleaseMode:
		ginMode = releaseCode

@@ -60,9 +65,7 @@

Loading

	default:
		panic("gin mode unknown: " + value)
	}
	if value == "" {
		value = DebugMode
	}

	modeName = value
}


@@ -71,12 +74,18 @@

Loading

	binding.Validator = nil
}

// EnableJsonDecoderUseNumber sets true for binding.EnableDecoderUseNumberto to
// EnableJsonDecoderUseNumber sets true for binding.EnableDecoderUseNumber to
// call the UseNumber method on the JSON Decoder instance.
func EnableJsonDecoderUseNumber() {
	binding.EnableDecoderUseNumber = true
}

// EnableJsonDecoderDisallowUnknownFields sets true for binding.EnableDecoderDisallowUnknownFields to
// call the DisallowUnknownFields method on the JSON Decoder instance.
func EnableJsonDecoderDisallowUnknownFields() {
	binding.EnableDecoderDisallowUnknownFields = true
}

// Mode returns currently gin mode.
func Mode() string {
	return modeName

@@ -8,7 +8,7 @@

Loading

	"reflect"
	"sync"

	"gopkg.in/go-playground/validator.v8"
	"github.com/go-playground/validator/v10"
)

type defaultValidator struct {

@@ -45,7 +45,7 @@

Loading


func (v *defaultValidator) lazyinit() {
	v.once.Do(func() {
		config := &validator.Config{TagName: "binding"}
		v.validate = validator.New(config)
		v.validate = validator.New()
		v.validate.SetTagName("binding")
	})
}

@@ -2,6 +2,8 @@

Loading

// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.

// +build !nomsgpack

package binding

import (

@@ -2,6 +2,8 @@

Loading

// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.

// +build !nomsgpack

package render

import (

@@ -10,6 +12,10 @@

Loading

	"github.com/ugorji/go/codec"
)

var (
	_ Render = MsgPack{}
)

// MsgPack contains the given interface object.
type MsgPack struct {
	Data interface{}

@@ -2,6 +2,8 @@

Loading

// Use of this source code is governed by a MIT style
// license that can be found in the LICENSE file.

// +build !nomsgpack

package binding

import "net/http"

@@ -85,7 +87,7 @@

Loading

// Default returns the appropriate Binding instance based on the HTTP method
// and the content type.
func Default(method, contentType string) Binding {
	if method == "GET" {
	if method == http.MethodGet {
		return Form
	}


@@ -6,8 +6,9 @@

Loading


import (
	"fmt"
	"io"
	"net/http"

	"github.com/gin-gonic/gin/internal/bytesconv"
)

// String contains the given interface object slice and its format.

@@ -35,6 +36,6 @@

Loading

		_, err = fmt.Fprintf(w, format, data...)
		return
	}
	_, err = io.WriteString(w, format)
	_, err = w.Write(bytesconv.StringToBytes(format))
	return
}

@@ -22,6 +22,9 @@

Loading

func (r Reader) Render(w http.ResponseWriter) (err error) {
	r.WriteContentType(w)
	if r.ContentLength >= 0 {
		if r.Headers == nil {
			r.Headers = map[string]string{}
		}
		r.Headers["Content-Length"] = strconv.FormatInt(r.ContentLength, 10)
	}
	r.writeHeaders(w, r.Headers)

165	174		return engine
166	175		}
167	176
168		-	// SecureJsonPrefix sets the secureJsonPrefix used in Context.SecureJSON.
	177	+	// SecureJsonPrefix sets the secureJSONPrefix used in Context.SecureJSON.
169	178		func (engine Engine) SecureJsonPrefix(prefix string) Engine {
170		-	engine.secureJsonPrefix = prefix
	179	+	engine.secureJSONPrefix = prefix
171	180		return engine
172	181		}
173	182

314	329		debugPrint("Listening and serving HTTP on unix:/%s", file)
315	330		defer func() { debugPrintError(err) }()
316	331
317		-	os.Remove(file)
318	332		listener, err := net.Listen("unix", file)
319	333		if err != nil {
320	334		return
321	335		}
322	336		defer listener.Close()
323		-	os.Chmod(file, 0777)
	337	+	defer os.Remove(file)
	338	+
324	339		err = http.Serve(listener, engine)
325	340		return
326	341		}

338	353		return
339	354		}
340	355		defer listener.Close()
	356	+	err = engine.RunListener(listener)
	357	+	return
	358	+	}
	359	+
	360	+	// RunListener attaches the router to a http.Server and starts listening and serving HTTP requests
	361	+	// through the specified net.Listener
	362	+	func (engine *Engine) RunListener(listener net.Listener) (err error) {
	363	+	debugPrint("Listening and serving HTTP on listener what's bind with address@%s", listener.Addr())
	364	+	defer func() { debugPrintError(err) }()
341	365		err = http.Serve(listener, engine)
342	366		return
343	367		}

373	397		rPath = c.Request.URL.RawPath
374	398		unescape = engine.UnescapePathValues
375	399		}
376		-	rPath = cleanPath(rPath)
	400	+
	401	+	if engine.RemoveExtraSlash {
	402	+	rPath = cleanPath(rPath)
	403	+	}
377	404
378	405		// Find root of the tree for the given HTTP method
379	406		t := engine.trees

445	474		if prefix := path.Clean(c.Request.Header.Get("X-Forwarded-Prefix")); prefix != "." {
446	475		p = prefix + "/" + req.URL.Path
447	476		}
448		-	code := http.StatusMovedPermanently // Permanent redirect, request with GET method
449		-	if req.Method != "GET" {
450		-	code = http.StatusTemporaryRedirect
451		-	}
452		-
453	477		req.URL.Path = p + "/"
454	478		if length := len(p); length > 1 && p[length-1] == '/' {
455	479		req.URL.Path = p[:length-1]
456	480		}
457		-	debugPrint("redirecting request %d: %s --> %s", code, p, req.URL.String())
458		-	http.Redirect(c.Writer, req, req.URL.String(), code)
459		-	c.writermem.WriteHeaderNow()
	481	+	redirectRequest(c)
460	482		}
461	483
462	484		func redirectFixedPath(c Context, root node, trailingSlash bool) bool {

55	55
56	56		// JSON creates a properly formatted JSON
57	57		func (msg *Error) JSON() interface{} {
58		-	json := H{}
	58	+	jsonData := H{}
59	59		if msg.Meta != nil {
60	60		value := reflect.ValueOf(msg.Meta)
61	61		switch value.Kind() {

63	63		return msg.Meta
64	64		case reflect.Map:
65	65		for _, key := range value.MapKeys() {
66		-	json[key.String()] = value.MapIndex(key).Interface()
	66	+	jsonData[key.String()] = value.MapIndex(key).Interface()
67	67		}
68	68		default:
69		-	json["meta"] = msg.Meta
	69	+	jsonData["meta"] = msg.Meta
70	70		}
71	71		}
72		-	if _, ok := json["error"]; !ok {
73		-	json["error"] = msg.Error()
	72	+	if _, ok := jsonData["error"]; !ok {
	73	+	jsonData["error"] = msg.Error()
74	74		}
75		-	return json
	75	+	return jsonData
76	76		}
77	77
78	78		// MarshalJSON implements the json.Marshaller interface.

90	90		return (msg.Type & flags) > 0
91	91		}
92	92
	93	+	// Unwrap returns the wrapped error, to allow interoperability with errors.Is(), errors.As() and errors.Unwrap()
	94	+	func (msg *Error) Unwrap() error {
	95	+	return msg.Err
	96	+	}
	97	+
93	98		// ByType returns a readonly copy filtered the byte.
94	99		// ie ByType(gin.ErrorTypePublic) returns a slice of errors with type=ErrorTypePublic.
95	100		func (a errorMsgs) ByType(typ ErrorType) errorMsgs {

135	140		}
136	141
137	142		func (a errorMsgs) JSON() interface{} {
138		-	switch len(a) {
	143	+	switch length := len(a); length {
139	144		case 0:
140	145		return nil
141	146		case 1:
142	147		return a.Last().JSON()
143	148		default:
144		-	json := make([]interface{}, len(a))
	149	+	jsonData := make([]interface{}, length)
145	150		for i, err := range a {
146		-	json[i] = err.JSON()
	151	+	jsonData[i] = err.JSON()
147	152		}
148		-	return json
	153	+	return jsonData
149	154		}
150	155		}
151	156

8	8		"encoding/base64"
9	9		"net/http"
10	10		"strconv"
	11	+
	12	+	"github.com/gin-gonic/gin/internal/bytesconv"
11	13		)
12	14
13	15		// AuthUserKey is the cookie name for user credential in basic auth.

68	70		}
69	71
70	72		func processAccounts(accounts Accounts) authPairs {
71		-	assert1(len(accounts) > 0, "Empty list of authorized credentials")
72		-	pairs := make(authPairs, 0, len(accounts))
	73	+	length := len(accounts)
	74	+	assert1(length > 0, "Empty list of authorized credentials")
	75	+	pairs := make(authPairs, 0, length)
73	76		for user, password := range accounts {
74	77		assert1(user != "", "User can not be empty")
75	78		value := authorizationHeader(user, password)

83	86
84	87		func authorizationHeader(user, password string) string {
85	88		base := user + ":" + password
86		-	return "Basic " + base64.StdEncoding.EncodeToString([]byte(base))
	89	+	return "Basic " + base64.StdEncoding.EncodeToString(bytesconv.StringToBytes(base))
87	90		}

8	8		"net/http"
9	9		)
10	10
11		-	const defaultMemory = 32 * 1024 * 1024
	11	+	const defaultMemory = 32 << 20
12	12
13	13		type formBinding struct{}
14	14		type formPostBinding struct{}

13	13		"path"
14	14		"sync"
15	15
	16	+	"github.com/gin-gonic/gin/internal/bytesconv"
16	17		"github.com/gin-gonic/gin/render"
17	18		)
18	19
19	20		const defaultMultipartMemory = 32 << 20 // 32 MB
20	21
21	22		var (
22		-	default404Body = []byte("404 page not found")
23		-	default405Body = []byte("405 method not allowed")
24		-	defaultAppEngine bool
	23	+	default404Body = []byte("404 page not found")
	24	+	default405Body = []byte("405 method not allowed")
25	25		)
26	26
	27	+	var defaultAppEngine bool
	28	+
27	29		// HandlerFunc defines the handler used by gin middleware as return value.
28	30		type HandlerFunc func(*Context)
29	31
30	32		// HandlersChain defines a HandlerFunc array.
31	33		type HandlersChain []HandlerFunc
32	34
33		-	// Last returns the last handler in the chain. ie. the last handler is the main own.
	35	+	// Last returns the last handler in the chain. ie. the last handler is the main one.
34	36		func (c HandlersChain) Last() HandlerFunc {
35	37		if length := len(c); length > 0 {
36	38		return c[length-1]

97	99		// method call.
98	100		MaxMultipartMemory int64
99	101
	102	+	// RemoveExtraSlash a parameter can be parsed from the URL even with extra slashes.
	103	+	// See the PR #1817 and issue #1644
	104	+	RemoveExtraSlash bool
	105	+
100	106		delims render.Delims
101		-	secureJsonPrefix string
	107	+	secureJSONPrefix string
102	108		HTMLRender render.HTMLRender
103	109		FuncMap template.FuncMap
104	110		allNoRoute HandlersChain

107	113		noMethod HandlersChain
108	114		pool sync.Pool
109	115		trees methodTrees
	116	+	maxParams uint16
110	117		}
111	118
112	119		var _ IRouter = &Engine{}

134	141		ForwardedByClientIP: true,
135	142		AppEngine: defaultAppEngine,
136	143		UseRawPath: false,
	144	+	RemoveExtraSlash: false,
137	145		UnescapePathValues: true,
138	146		MaxMultipartMemory: defaultMultipartMemory,
139	147		trees: make(methodTrees, 0, 9),
140	148		delims: render.Delims{Left: "{{", Right: "}}"},
141		-	secureJsonPrefix: "while(1);",
	149	+	secureJSONPrefix: "while(1);",
142	150		}
143	151		engine.RouterGroup.engine = engine
144	152		engine.pool.New = func() interface{} {

156	164		}
157	165
158	166		func (engine Engine) allocateContext() Context {
159		-	return &Context{engine: engine}
	167	+	v := make(Params, 0, engine.maxParams)
	168	+	return &Context{engine: engine, params: &v}
160	169		}
161	170
162	171		// Delims sets template left and right delims and returns a Engine instance.

249	258		assert1(len(handlers) > 0, "there must be at least one handler")
250	259
251	260		debugPrintRoute(method, path, handlers)
	261	+
252	262		root := engine.trees.get(method)
253	263		if root == nil {
254	264		root = new(node)

256	266		engine.trees = append(engine.trees, methodTree{method: method, root: root})
257	267		}
258	268		root.addRoute(path, handlers)
	269	+
	270	+	// Update maxParams
	271	+	if paramsCount := countParams(path); paramsCount > engine.maxParams {
	272	+	engine.maxParams = paramsCount
	273	+	}
259	274		}
260	275
261	276		// Routes returns a slice of registered routes, including some useful information, such as:

383	410		}
384	411		root := t[i].root
385	412		// Find route in tree
386		-	value := root.getValue(rPath, c.Params, unescape)
	413	+	value := root.getValue(rPath, c.params, unescape)
	414	+	if value.params != nil {
	415	+	c.Params = *value.params
	416	+	}
387	417		if value.handlers != nil {
388	418		c.handlers = value.handlers
389		-	c.Params = value.params
390	419		c.fullPath = value.fullPath
391	420		c.Next()
392	421		c.writermem.WriteHeaderNow()

464	486		rPath := req.URL.Path
465	487
466	488		if fixedPath, ok := root.findCaseInsensitivePath(cleanPath(rPath), trailingSlash); ok {
467		-	code := http.StatusMovedPermanently // Permanent redirect, request with GET method
468		-	if req.Method != "GET" {
469		-	code = http.StatusTemporaryRedirect
470		-	}
471		-	req.URL.Path = string(fixedPath)
472		-	debugPrint("redirecting request %d: %s --> %s", code, rPath, req.URL.String())
473		-	http.Redirect(c.Writer, req, req.URL.String(), code)
474		-	c.writermem.WriteHeaderNow()
	489	+	req.URL.Path = bytesconv.BytesToString(fixedPath)
	490	+	redirectRequest(c)
475	491		return true
476	492		}
477	493		return false
478	494		}
	495	+
	496	+	func redirectRequest(c *Context) {
	497	+	req := c.Request
	498	+	rPath := req.URL.Path
	499	+	rURL := req.URL.String()
	500	+
	501	+	code := http.StatusMovedPermanently // Permanent redirect, request with GET method
	502	+	if req.Method != http.MethodGet {
	503	+	code = http.StatusTemporaryRedirect
	504	+	}
	505	+	debugPrint("redirecting request %d: %s --> %s", code, rPath, rURL)
	506	+	http.Redirect(c.Writer, req, rURL, code)
	507	+	c.writermem.WriteHeaderNow()
	508	+	}

67	67
68	68		func debugPrintWARNINGDefault() {
69	69		if v, e := getMinVer(runtime.Version()); e == nil && v <= ginSupportMinGoVer {
70		-	debugPrint(`[WARNING] Now Gin requires Go 1.10 or later and Go 1.11 will be required soon.
	70	+	debugPrint(`[WARNING] Now Gin requires Go 1.11 or later and Go 1.12 will be required soon.
71	71
72	72		`)
73	73		}

90	90		}
91	91
92	92		func chooseData(custom, wildcard interface{}) interface{} {
93		-	if custom == nil {
94		-	if wildcard == nil {
95		-	panic("negotiation config is invalid")
96		-	}
	93	+	if custom != nil {
	94	+	return custom
	95	+	}
	96	+	if wildcard != nil {
97	97		return wildcard
98	98		}
99		-	return custom
	99	+	panic("negotiation config is invalid")
100	100		}
101	101
102	102		func parseAccept(acceptHeader string) []string {
103	103		parts := strings.Split(acceptHeader, ",")
104	104		out := make([]string, 0, len(parts))
105	105		for _, part := range parts {
106		-	if part = strings.TrimSpace(strings.Split(part, ";")[0]); part != "" {
	106	+	if i := strings.IndexByte(part, ';'); i > 0 {
	107	+	part = part[:i]
	108	+	}
	109	+	if part = strings.TrimSpace(part); part != "" {
107	110		out = append(out, part)
108	111		}
109	112		}

127	130		}
128	131
129	132		finalPath := path.Join(absolutePath, relativePath)
130		-	appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/'
131		-	if appendSlash {
	133	+	if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' {
132	134		return finalPath + "/"
133	135		}
134	136		return finalPath

12	12		"strings"
13	13		"time"
14	14
	15	+	"github.com/gin-gonic/gin/internal/bytesconv"
15	16		"github.com/gin-gonic/gin/internal/json"
16	17		)
17	18
18		-	var errUnknownType = errors.New("Unknown type")
	19	+	var errUnknownType = errors.New("unknown type")
19	20
20	21		func mapUri(ptr interface{}, m map[string][]string) error {
21	22		return mapFormByTag(ptr, m, "uri")

51	52		}
52	53
53	54		func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
	55	+	if field.Tag.Get(tag) == "-" { // just ignoring this field
	56	+	return false, nil
	57	+	}
	58	+
54	59		var vKind = value.Kind()
55	60
56	61		if vKind == reflect.Ptr {

112	117		tagValue = field.Tag.Get(tag)
113	118		tagValue, opts := head(tagValue, ",")
114	119
115		-	if tagValue == "-" { // just ignoring this field
116		-	return false, nil
117		-	}
118	120		if tagValue == "" { // default value is FieldName
119	121		tagValue = field.Name
120	122		}

207	209		case time.Time:
208	210		return setTimeField(val, field, value)
209	211		}
210		-	return json.Unmarshal([]byte(val), value.Addr().Interface())
	212	+	return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
211	213		case reflect.Map:
212		-	return json.Unmarshal([]byte(val), value.Addr().Interface())
	214	+	return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
213	215		default:
214	216		return errUnknownType
215	217		}

268	270
269	271		switch tf := strings.ToLower(timeFormat); tf {
270	272		case "unix", "unixnano":
271		-	tv, err := strconv.ParseInt(val, 10, 0)
	273	+	tv, err := strconv.ParseInt(val, 10, 64)
272	274		if err != nil {
273	275		return err
274	276		}

99	99		method := p.Method
100	100
101	101		switch method {
102		-	case "GET":
	102	+	case http.MethodGet:
103	103		return blue
104		-	case "POST":
	104	+	case http.MethodPost:
105	105		return cyan
106		-	case "PUT":
	106	+	case http.MethodPut:
107	107		return yellow
108		-	case "DELETE":
	108	+	case http.MethodDelete:
109	109		return red
110		-	case "PATCH":
	110	+	case http.MethodPatch:
111	111		return green
112		-	case "HEAD":
	112	+	case http.MethodHead:
113	113		return magenta
114		-	case "OPTIONS":
	114	+	case http.MethodOptions:
115	115		return white
116	116		default:
117	117		return reset

141	141		// Truncate in a golang < 1.8 safe way
142	142		param.Latency = param.Latency - param.Latency%time.Second
143	143		}
144		-	return fmt.Sprintf("[GIN] %v \|%s %3d %s\| %13v \| %15s \|%s %-7s %s %s\n%s",
	144	+	return fmt.Sprintf("[GIN] %v \|%s %3d %s\| %13v \| %15s \|%s %-7s %s %#v\n%s",
145	145		param.TimeStamp.Format("2006/01/02 - 15:04:05"),
146	146		statusColor, param.StatusCode, resetColor,
147	147		param.Latency,

26	26		slash = []byte("/")
27	27		)
28	28
	29	+	// RecoveryFunc defines the function passable to CustomRecovery.
	30	+	type RecoveryFunc func(c *Context, err interface{})
	31	+
29	32		// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
30	33		func Recovery() HandlerFunc {
31	34		return RecoveryWithWriter(DefaultErrorWriter)
32	35		}
33	36
	37	+	//CustomRecovery returns a middleware that recovers from any panics and calls the provided handle func to handle it.
	38	+	func CustomRecovery(handle RecoveryFunc) HandlerFunc {
	39	+	return RecoveryWithWriter(DefaultErrorWriter, handle)
	40	+	}
	41	+
34	42		// RecoveryWithWriter returns a middleware for a given writer that recovers from any panics and writes a 500 if there was one.
35		-	func RecoveryWithWriter(out io.Writer) HandlerFunc {
	43	+	func RecoveryWithWriter(out io.Writer, recovery ...RecoveryFunc) HandlerFunc {
	44	+	if len(recovery) > 0 {
	45	+	return CustomRecoveryWithWriter(out, recovery[0])
	46	+	}
	47	+	return CustomRecoveryWithWriter(out, defaultHandleRecovery)
	48	+	}
	49	+
	50	+	// CustomRecoveryWithWriter returns a middleware for a given writer that recovers from any panics and calls the provided handle func to handle it.
	51	+	func CustomRecoveryWithWriter(out io.Writer, handle RecoveryFunc) HandlerFunc {
36	52		var logger *log.Logger
37	53		if out != nil {
38	54		logger = log.New(out, "\n\n\x1b[31m", log.LstdFlags)

60	76		headers[idx] = current[0] + ": *"
61	77		}
62	78		}
	79	+	headersToStr := strings.Join(headers, "\r\n")
63	80		if brokenPipe {
64		-	logger.Printf("%s\n%s%s", err, string(httpRequest), reset)
	81	+	logger.Printf("%s\n%s%s", err, headersToStr, reset)
65	82		} else if IsDebugging() {
66	83		logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
67		-	timeFormat(time.Now()), strings.Join(headers, "\r\n"), err, stack, reset)
	84	+	timeFormat(time.Now()), headersToStr, err, stack, reset)
68	85		} else {
69	86		logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s",
70	87		timeFormat(time.Now()), err, stack, reset)
71	88		}
72	89		}
73		-
74		-	// If the connection is dead, we can't write a status to it.
75	90		if brokenPipe {
	91	+	// If the connection is dead, we can't write a status to it.
76	92		c.Error(err.(error)) // nolint: errcheck
77	93		c.Abort()
78	94		} else {
79		-	c.AbortWithStatus(http.StatusInternalServerError)
	95	+	handle(c, err)
80	96		}
81	97		}
82	98		}()

84	100		}
85	101		}
86	102
	103	+	func defaultHandleRecovery(c *Context, err interface{}) {
	104	+	c.AbortWithStatus(http.StatusInternalServerError)
	105	+	}
	106	+
87	107		// stack returns a nicely formatted stack frame, skipping skip frames.
88	108		func stack(skip int) []byte {
89	109		buf := new(bytes.Buffer) // the returned data