2015-03-27 23:21:30 +02:00
|
|
|
package echo
|
2015-03-01 19:45:13 +02:00
|
|
|
|
|
|
|
import (
|
2016-10-21 03:25:40 +02:00
|
|
|
"bytes"
|
2015-07-11 21:20:59 +02:00
|
|
|
"encoding/xml"
|
2016-08-22 23:46:21 +02:00
|
|
|
"fmt"
|
2016-02-15 18:11:29 +02:00
|
|
|
"io"
|
2016-03-21 22:10:20 +02:00
|
|
|
"mime/multipart"
|
2016-09-23 07:53:44 +02:00
|
|
|
"net"
|
2015-03-01 19:45:13 +02:00
|
|
|
"net/http"
|
2016-09-23 07:53:44 +02:00
|
|
|
"net/url"
|
|
|
|
"strings"
|
2019-02-12 20:56:26 +02:00
|
|
|
"sync"
|
2015-03-01 19:45:13 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
type (
|
2016-03-20 00:47:20 +02:00
|
|
|
// Context represents the context of the current HTTP request. It holds request and
|
|
|
|
// response objects, path, path parameters, data and registered handler.
|
2015-12-04 03:23:53 +02:00
|
|
|
Context interface {
|
2016-09-23 07:53:44 +02:00
|
|
|
// Request returns `*http.Request`.
|
|
|
|
Request() *http.Request
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-10-21 03:25:40 +02:00
|
|
|
// SetRequest sets `*http.Request`.
|
2016-12-09 20:24:14 +02:00
|
|
|
SetRequest(r *http.Request)
|
2016-10-11 02:31:26 +02:00
|
|
|
|
2019-08-07 20:10:18 +02:00
|
|
|
// SetResponse sets `*Response`.
|
|
|
|
SetResponse(r *Response)
|
|
|
|
|
2017-01-02 08:02:14 +02:00
|
|
|
// Response returns `*Response`.
|
2016-09-23 07:53:44 +02:00
|
|
|
Response() *Response
|
|
|
|
|
|
|
|
// IsTLS returns true if HTTP connection is TLS otherwise false.
|
|
|
|
IsTLS() bool
|
|
|
|
|
2017-06-04 19:39:08 +02:00
|
|
|
// IsWebSocket returns true if HTTP connection is WebSocket otherwise false.
|
|
|
|
IsWebSocket() bool
|
|
|
|
|
2016-09-23 07:53:44 +02:00
|
|
|
// Scheme returns the HTTP protocol scheme, `http` or `https`.
|
|
|
|
Scheme() string
|
|
|
|
|
|
|
|
// RealIP returns the client's network address based on `X-Forwarded-For`
|
|
|
|
// or `X-Real-IP` request header.
|
2020-02-24 18:29:34 +02:00
|
|
|
// The behavior can be configured using `Echo#IPExtractor`.
|
2016-09-23 07:53:44 +02:00
|
|
|
RealIP() string
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// Path returns the registered path for the handler.
|
2015-12-04 03:23:53 +02:00
|
|
|
Path() string
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-04-17 00:53:27 +02:00
|
|
|
// SetPath sets the registered path for the handler.
|
2016-12-09 20:24:14 +02:00
|
|
|
SetPath(p string)
|
2016-04-17 00:53:27 +02:00
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// Param returns path parameter by name.
|
2016-12-09 20:24:14 +02:00
|
|
|
Param(name string) string
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// ParamNames returns path parameter names.
|
2016-03-06 06:03:11 +02:00
|
|
|
ParamNames() []string
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-04-17 00:53:27 +02:00
|
|
|
// SetParamNames sets path parameter names.
|
2016-12-09 20:24:14 +02:00
|
|
|
SetParamNames(names ...string)
|
2016-04-17 00:53:27 +02:00
|
|
|
|
|
|
|
// ParamValues returns path parameter values.
|
|
|
|
ParamValues() []string
|
|
|
|
|
|
|
|
// SetParamValues sets path parameter values.
|
2016-12-09 20:24:14 +02:00
|
|
|
SetParamValues(values ...string)
|
2016-04-17 00:53:27 +02:00
|
|
|
|
2016-09-23 07:53:44 +02:00
|
|
|
// QueryParam returns the query param for the provided name.
|
2016-12-09 20:24:14 +02:00
|
|
|
QueryParam(name string) string
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-09-23 07:53:44 +02:00
|
|
|
// QueryParams returns the query parameters as `url.Values`.
|
|
|
|
QueryParams() url.Values
|
2016-03-23 18:10:22 +02:00
|
|
|
|
2016-09-23 07:53:44 +02:00
|
|
|
// QueryString returns the URL query string.
|
|
|
|
QueryString() string
|
|
|
|
|
|
|
|
// FormValue returns the form field value for the provided name.
|
2016-12-09 20:24:14 +02:00
|
|
|
FormValue(name string) string
|
2016-03-21 22:10:20 +02:00
|
|
|
|
2016-09-23 07:53:44 +02:00
|
|
|
// FormParams returns the form parameters as `url.Values`.
|
|
|
|
FormParams() (url.Values, error)
|
2016-03-23 18:10:22 +02:00
|
|
|
|
2016-09-23 07:53:44 +02:00
|
|
|
// FormFile returns the multipart form file for the provided name.
|
2016-12-09 20:24:14 +02:00
|
|
|
FormFile(name string) (*multipart.FileHeader, error)
|
2016-03-21 22:10:20 +02:00
|
|
|
|
2016-05-03 01:19:35 +02:00
|
|
|
// MultipartForm returns the multipart form.
|
2016-03-21 22:10:20 +02:00
|
|
|
MultipartForm() (*multipart.Form, error)
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-05-03 01:19:35 +02:00
|
|
|
// Cookie returns the named cookie provided in the request.
|
2016-12-09 20:24:14 +02:00
|
|
|
Cookie(name string) (*http.Cookie, error)
|
2016-05-03 01:19:35 +02:00
|
|
|
|
|
|
|
// SetCookie adds a `Set-Cookie` header in HTTP response.
|
2016-12-09 20:24:14 +02:00
|
|
|
SetCookie(cookie *http.Cookie)
|
2016-05-03 01:19:35 +02:00
|
|
|
|
|
|
|
// Cookies returns the HTTP cookies sent with the request.
|
2016-09-23 07:53:44 +02:00
|
|
|
Cookies() []*http.Cookie
|
2016-05-03 01:19:35 +02:00
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// Get retrieves data from the context.
|
2016-12-09 20:24:14 +02:00
|
|
|
Get(key string) interface{}
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// Set saves data in the context.
|
2016-12-09 20:24:14 +02:00
|
|
|
Set(key string, val interface{})
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2023-03-15 23:50:00 +02:00
|
|
|
// Bind binds path params, query params and the request body into provided type `i`. The default binder
|
|
|
|
// binds body based on Content-Type header.
|
2016-12-09 20:24:14 +02:00
|
|
|
Bind(i interface{}) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-12-13 03:19:41 +02:00
|
|
|
// Validate validates provided `i`. It is usually called after `Context#Bind()`.
|
|
|
|
// Validator must be registered using `Echo#Validator`.
|
|
|
|
Validate(i interface{}) error
|
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// Render renders a template with data and sends a text/html response with status
|
2016-12-13 03:19:41 +02:00
|
|
|
// code. Renderer must be registered using `Echo.Renderer`.
|
2016-12-09 20:24:14 +02:00
|
|
|
Render(code int, name string, data interface{}) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// HTML sends an HTTP response with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
HTML(code int, html string) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-12-07 04:57:06 +02:00
|
|
|
// HTMLBlob sends an HTTP blob response with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
HTMLBlob(code int, b []byte) error
|
2016-12-07 04:57:06 +02:00
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// String sends a string response with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
String(code int, s string) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// JSON sends a JSON response with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
JSON(code int, i interface{}) error
|
|
|
|
|
|
|
|
// JSONPretty sends a pretty-print JSON with status code.
|
|
|
|
JSONPretty(code int, i interface{}, indent string) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// JSONBlob sends a JSON blob response with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
JSONBlob(code int, b []byte) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// JSONP sends a JSONP response with status code. It uses `callback` to construct
|
|
|
|
// the JSONP payload.
|
2016-12-09 20:24:14 +02:00
|
|
|
JSONP(code int, callback string, i interface{}) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-09-10 00:30:07 +02:00
|
|
|
// JSONPBlob sends a JSONP blob response with status code. It uses `callback`
|
|
|
|
// to construct the JSONP payload.
|
2016-12-09 20:24:14 +02:00
|
|
|
JSONPBlob(code int, callback string, b []byte) error
|
2016-09-10 00:30:07 +02:00
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// XML sends an XML response with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
XML(code int, i interface{}) error
|
|
|
|
|
|
|
|
// XMLPretty sends a pretty-print XML with status code.
|
|
|
|
XMLPretty(code int, i interface{}, indent string) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-12-14 06:26:25 +02:00
|
|
|
// XMLBlob sends an XML blob response with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
XMLBlob(code int, b []byte) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-09-10 00:30:07 +02:00
|
|
|
// Blob sends a blob response with status code and content type.
|
2016-12-09 20:24:14 +02:00
|
|
|
Blob(code int, contentType string, b []byte) error
|
2016-09-10 00:30:07 +02:00
|
|
|
|
|
|
|
// Stream sends a streaming response with status code and content type.
|
2016-12-09 20:24:14 +02:00
|
|
|
Stream(code int, contentType string, r io.Reader) error
|
2016-09-10 00:30:07 +02:00
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// File sends a response with the content of the file.
|
2016-12-09 20:24:14 +02:00
|
|
|
File(file string) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-10-25 23:53:17 +02:00
|
|
|
// Attachment sends a response as attachment, prompting client to save the
|
|
|
|
// file.
|
2016-12-09 20:24:14 +02:00
|
|
|
Attachment(file string, name string) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-10-25 23:53:17 +02:00
|
|
|
// Inline sends a response as inline, opening the file in the browser.
|
2016-12-09 20:24:14 +02:00
|
|
|
Inline(file string, name string) error
|
2016-08-22 23:46:21 +02:00
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// NoContent sends a response with no body and a status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
NoContent(code int) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-12-14 06:26:25 +02:00
|
|
|
// Redirect redirects the request to a provided URL with status code.
|
2016-12-09 20:24:14 +02:00
|
|
|
Redirect(code int, url string) error
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2022-11-30 15:47:23 +02:00
|
|
|
// Error invokes the registered global HTTP error handler. Generally used by middleware.
|
|
|
|
// A side-effect of calling global error handler is that now Response has been committed (sent to the client) and
|
|
|
|
// middlewares up in chain can not change Response status code or Response body anymore.
|
|
|
|
//
|
|
|
|
// Avoid using this method in handlers as no middleware will be able to effectively handle errors after that.
|
2015-12-04 03:23:53 +02:00
|
|
|
Error(err error)
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2016-04-12 01:49:20 +02:00
|
|
|
// Handler returns the matched handler by router.
|
|
|
|
Handler() HandlerFunc
|
|
|
|
|
2016-04-17 00:53:27 +02:00
|
|
|
// SetHandler sets the matched handler by router.
|
2016-12-09 20:24:14 +02:00
|
|
|
SetHandler(h HandlerFunc)
|
2016-04-17 00:53:27 +02:00
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// Logger returns the `Logger` instance.
|
2016-09-25 21:14:50 +02:00
|
|
|
Logger() Logger
|
2016-03-20 00:47:20 +02:00
|
|
|
|
2022-10-06 10:34:00 +02:00
|
|
|
// SetLogger Set the logger
|
2019-11-11 22:34:13 +02:00
|
|
|
SetLogger(l Logger)
|
|
|
|
|
2016-03-20 00:47:20 +02:00
|
|
|
// Echo returns the `Echo` instance.
|
2016-02-19 00:04:28 +02:00
|
|
|
Echo() *Echo
|
2016-03-20 00:47:20 +02:00
|
|
|
|
|
|
|
// Reset resets the context after request completes. It must be called along
|
2016-05-04 02:23:31 +02:00
|
|
|
// with `Echo#AcquireContext()` and `Echo#ReleaseContext()`.
|
|
|
|
// See `Echo#ServeHTTP()`
|
2016-12-09 20:24:14 +02:00
|
|
|
Reset(r *http.Request, w http.ResponseWriter)
|
2015-12-04 03:23:53 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
context struct {
|
2016-11-13 19:36:57 +02:00
|
|
|
request *http.Request
|
|
|
|
response *Response
|
|
|
|
path string
|
|
|
|
pnames []string
|
|
|
|
pvalues []string
|
|
|
|
query url.Values
|
|
|
|
handler HandlerFunc
|
|
|
|
store Map
|
|
|
|
echo *Echo
|
2019-11-11 22:34:13 +02:00
|
|
|
logger Logger
|
2019-02-12 20:56:26 +02:00
|
|
|
lock sync.RWMutex
|
2015-03-01 19:45:13 +02:00
|
|
|
}
|
|
|
|
)
|
|
|
|
|
2021-12-04 20:02:11 +02:00
|
|
|
const (
|
|
|
|
// ContextKeyHeaderAllow is set by Router for getting value for `Allow` header in later stages of handler call chain.
|
|
|
|
// Allow header is mandatory for status 405 (method not found) and useful for OPTIONS method requests.
|
|
|
|
// It is added to context only when Router does not find matching method handler for request.
|
2021-12-09 21:57:20 +02:00
|
|
|
ContextKeyHeaderAllow = "echo_header_allow"
|
2021-12-04 20:02:11 +02:00
|
|
|
)
|
|
|
|
|
2016-02-15 18:11:29 +02:00
|
|
|
const (
|
2016-09-23 07:53:44 +02:00
|
|
|
defaultMemory = 32 << 20 // 32 MB
|
|
|
|
indexPage = "index.html"
|
2019-01-14 20:56:17 +02:00
|
|
|
defaultIndent = " "
|
2016-02-15 18:11:29 +02:00
|
|
|
)
|
|
|
|
|
2018-03-15 07:51:06 +02:00
|
|
|
func (c *context) writeContentType(value string) {
|
|
|
|
header := c.Response().Header()
|
2018-03-15 07:59:15 +02:00
|
|
|
if header.Get(HeaderContentType) == "" {
|
2018-03-15 07:51:06 +02:00
|
|
|
header.Set(HeaderContentType, value)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Request() *http.Request {
|
|
|
|
return c.request
|
2016-03-14 17:09:48 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) SetRequest(r *http.Request) {
|
|
|
|
c.request = r
|
2015-05-22 13:40:01 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Response() *Response {
|
2015-05-22 13:40:01 +02:00
|
|
|
return c.response
|
|
|
|
}
|
|
|
|
|
2019-08-07 20:10:18 +02:00
|
|
|
func (c *context) SetResponse(r *Response) {
|
|
|
|
c.response = r
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) IsTLS() bool {
|
2016-09-23 07:53:44 +02:00
|
|
|
return c.request.TLS != nil
|
|
|
|
}
|
|
|
|
|
2017-06-04 19:39:08 +02:00
|
|
|
func (c *context) IsWebSocket() bool {
|
|
|
|
upgrade := c.request.Header.Get(HeaderUpgrade)
|
2021-02-26 23:52:32 +02:00
|
|
|
return strings.EqualFold(upgrade, "websocket")
|
2017-06-04 19:39:08 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Scheme() string {
|
2016-09-23 07:53:44 +02:00
|
|
|
// Can't use `r.Request.URL.Scheme`
|
|
|
|
// See: https://groups.google.com/forum/#!topic/golang-nuts/pMUkBlQBDF0
|
|
|
|
if c.IsTLS() {
|
|
|
|
return "https"
|
|
|
|
}
|
2017-06-04 18:41:17 +02:00
|
|
|
if scheme := c.request.Header.Get(HeaderXForwardedProto); scheme != "" {
|
|
|
|
return scheme
|
2017-06-04 19:39:08 +02:00
|
|
|
}
|
|
|
|
if scheme := c.request.Header.Get(HeaderXForwardedProtocol); scheme != "" {
|
|
|
|
return scheme
|
|
|
|
}
|
2017-06-04 18:41:17 +02:00
|
|
|
if ssl := c.request.Header.Get(HeaderXForwardedSsl); ssl == "on" {
|
|
|
|
return "https"
|
|
|
|
}
|
2017-06-04 19:39:08 +02:00
|
|
|
if scheme := c.request.Header.Get(HeaderXUrlScheme); scheme != "" {
|
|
|
|
return scheme
|
|
|
|
}
|
2016-09-23 07:53:44 +02:00
|
|
|
return "http"
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) RealIP() string {
|
2020-02-24 18:29:34 +02:00
|
|
|
if c.echo != nil && c.echo.IPExtractor != nil {
|
|
|
|
return c.echo.IPExtractor(c.request)
|
|
|
|
}
|
|
|
|
// Fall back to legacy behavior
|
2016-09-23 07:53:44 +02:00
|
|
|
if ip := c.request.Header.Get(HeaderXForwardedFor); ip != "" {
|
2021-05-20 16:51:15 +02:00
|
|
|
i := strings.IndexAny(ip, ",")
|
2020-09-15 10:58:05 +02:00
|
|
|
if i > 0 {
|
2022-11-24 22:17:31 +02:00
|
|
|
xffip := strings.TrimSpace(ip[:i])
|
|
|
|
xffip = strings.TrimPrefix(xffip, "[")
|
|
|
|
xffip = strings.TrimSuffix(xffip, "]")
|
|
|
|
return xffip
|
2020-09-15 10:58:05 +02:00
|
|
|
}
|
|
|
|
return ip
|
2016-09-23 07:53:44 +02:00
|
|
|
}
|
2018-09-19 19:18:50 +02:00
|
|
|
if ip := c.request.Header.Get(HeaderXRealIP); ip != "" {
|
2022-11-24 22:17:31 +02:00
|
|
|
ip = strings.TrimPrefix(ip, "[")
|
|
|
|
ip = strings.TrimSuffix(ip, "]")
|
2018-09-19 19:18:50 +02:00
|
|
|
return ip
|
|
|
|
}
|
|
|
|
ra, _, _ := net.SplitHostPort(c.request.RemoteAddr)
|
2016-09-23 07:53:44 +02:00
|
|
|
return ra
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Path() string {
|
2015-11-13 06:23:14 +02:00
|
|
|
return c.path
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) SetPath(p string) {
|
2016-04-17 00:53:27 +02:00
|
|
|
c.path = p
|
|
|
|
}
|
|
|
|
|
2016-11-13 19:36:57 +02:00
|
|
|
func (c *context) Param(name string) string {
|
2015-04-26 07:32:20 +02:00
|
|
|
for i, n := range c.pnames {
|
2016-11-18 04:42:00 +02:00
|
|
|
if i < len(c.pvalues) {
|
2016-11-17 17:58:44 +02:00
|
|
|
if n == name {
|
2016-11-13 19:36:57 +02:00
|
|
|
return c.pvalues[i]
|
|
|
|
}
|
2015-04-06 05:08:52 +02:00
|
|
|
}
|
|
|
|
}
|
2016-11-13 19:36:57 +02:00
|
|
|
return ""
|
2015-03-01 19:45:13 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) ParamNames() []string {
|
2016-03-06 06:03:11 +02:00
|
|
|
return c.pnames
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) SetParamNames(names ...string) {
|
2016-04-17 00:53:27 +02:00
|
|
|
c.pnames = names
|
2020-10-28 06:30:41 +02:00
|
|
|
|
|
|
|
l := len(names)
|
|
|
|
if *c.echo.maxParam < l {
|
|
|
|
*c.echo.maxParam = l
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(c.pvalues) < l {
|
|
|
|
// Keeping the old pvalues just for backward compatibility, but it sounds that doesn't make sense to keep them,
|
|
|
|
// probably those values will be overriden in a Context#SetParamValues
|
|
|
|
newPvalues := make([]string, l)
|
|
|
|
copy(newPvalues, c.pvalues)
|
|
|
|
c.pvalues = newPvalues
|
|
|
|
}
|
2016-04-17 00:53:27 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) ParamValues() []string {
|
2017-03-30 12:05:24 +02:00
|
|
|
return c.pvalues[:len(c.pnames)]
|
2016-04-17 00:53:27 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) SetParamValues(values ...string) {
|
2020-10-28 06:30:41 +02:00
|
|
|
// NOTE: Don't just set c.pvalues = values, because it has to have length c.echo.maxParam at all times
|
|
|
|
// It will brake the Router#Find code
|
|
|
|
limit := len(values)
|
|
|
|
if limit > *c.echo.maxParam {
|
|
|
|
limit = *c.echo.maxParam
|
|
|
|
}
|
|
|
|
for i := 0; i < limit; i++ {
|
|
|
|
c.pvalues[i] = values[i]
|
|
|
|
}
|
2016-04-17 00:53:27 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) QueryParam(name string) string {
|
2016-09-23 07:53:44 +02:00
|
|
|
if c.query == nil {
|
|
|
|
c.query = c.request.URL.Query()
|
|
|
|
}
|
|
|
|
return c.query.Get(name)
|
2015-07-05 20:08:17 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) QueryParams() url.Values {
|
2016-09-23 07:53:44 +02:00
|
|
|
if c.query == nil {
|
|
|
|
c.query = c.request.URL.Query()
|
|
|
|
}
|
|
|
|
return c.query
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) QueryString() string {
|
2016-09-23 07:53:44 +02:00
|
|
|
return c.request.URL.RawQuery
|
2016-03-23 18:10:22 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) FormValue(name string) string {
|
2016-01-29 09:46:11 +02:00
|
|
|
return c.request.FormValue(name)
|
2015-07-05 20:08:17 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) FormParams() (url.Values, error) {
|
2016-09-23 07:53:44 +02:00
|
|
|
if strings.HasPrefix(c.request.Header.Get(HeaderContentType), MIMEMultipartForm) {
|
|
|
|
if err := c.request.ParseMultipartForm(defaultMemory); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if err := c.request.ParseForm(); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return c.request.Form, nil
|
2016-03-23 18:10:22 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) FormFile(name string) (*multipart.FileHeader, error) {
|
2019-10-24 20:52:14 +02:00
|
|
|
f, fh, err := c.request.FormFile(name)
|
2020-02-29 17:46:25 +02:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2020-10-20 05:54:40 +02:00
|
|
|
f.Close()
|
2020-02-29 17:46:25 +02:00
|
|
|
return fh, nil
|
2016-03-21 22:10:20 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) MultipartForm() (*multipart.Form, error) {
|
2016-09-23 07:53:44 +02:00
|
|
|
err := c.request.ParseMultipartForm(defaultMemory)
|
|
|
|
return c.request.MultipartForm, err
|
2016-03-21 22:10:20 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Cookie(name string) (*http.Cookie, error) {
|
2016-05-03 01:19:35 +02:00
|
|
|
return c.request.Cookie(name)
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) SetCookie(cookie *http.Cookie) {
|
2016-09-23 07:53:44 +02:00
|
|
|
http.SetCookie(c.Response(), cookie)
|
2016-05-03 01:19:35 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Cookies() []*http.Cookie {
|
2016-05-03 01:19:35 +02:00
|
|
|
return c.request.Cookies()
|
|
|
|
}
|
|
|
|
|
2016-12-09 20:24:14 +02:00
|
|
|
func (c *context) Get(key string) interface{} {
|
2019-02-12 20:56:26 +02:00
|
|
|
c.lock.RLock()
|
|
|
|
defer c.lock.RUnlock()
|
2016-12-09 20:24:14 +02:00
|
|
|
return c.store[key]
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Set(key string, val interface{}) {
|
2019-02-12 20:56:26 +02:00
|
|
|
c.lock.Lock()
|
|
|
|
defer c.lock.Unlock()
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
if c.store == nil {
|
2016-10-14 01:45:27 +02:00
|
|
|
c.store = make(Map)
|
2016-10-11 02:31:26 +02:00
|
|
|
}
|
|
|
|
c.store[key] = val
|
2015-05-30 19:54:55 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Bind(i interface{}) error {
|
2016-09-23 07:53:44 +02:00
|
|
|
return c.echo.Binder.Bind(i, c)
|
2015-03-01 19:45:13 +02:00
|
|
|
}
|
|
|
|
|
2016-12-13 03:19:41 +02:00
|
|
|
func (c *context) Validate(i interface{}) error {
|
|
|
|
if c.echo.Validator == nil {
|
|
|
|
return ErrValidatorNotRegistered
|
|
|
|
}
|
|
|
|
return c.echo.Validator.Validate(i)
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Render(code int, name string, data interface{}) (err error) {
|
2016-09-23 07:53:44 +02:00
|
|
|
if c.echo.Renderer == nil {
|
2016-02-15 18:11:29 +02:00
|
|
|
return ErrRendererNotRegistered
|
2015-04-11 06:48:26 +02:00
|
|
|
}
|
2015-10-06 15:48:33 +02:00
|
|
|
buf := new(bytes.Buffer)
|
2016-09-23 07:53:44 +02:00
|
|
|
if err = c.echo.Renderer.Render(buf, name, data, c); err != nil {
|
2015-10-02 20:23:52 +02:00
|
|
|
return
|
|
|
|
}
|
2016-12-07 04:57:06 +02:00
|
|
|
return c.HTMLBlob(code, buf.Bytes())
|
2015-03-30 08:35:08 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) HTML(code int, html string) (err error) {
|
2016-12-07 04:57:06 +02:00
|
|
|
return c.HTMLBlob(code, []byte(html))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *context) HTMLBlob(code int, b []byte) (err error) {
|
|
|
|
return c.Blob(code, MIMETextHTMLCharsetUTF8, b)
|
2015-07-08 22:51:08 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) String(code int, s string) (err error) {
|
2016-12-07 04:57:06 +02:00
|
|
|
return c.Blob(code, MIMETextPlainCharsetUTF8, []byte(s))
|
2015-07-11 21:20:59 +02:00
|
|
|
}
|
|
|
|
|
2019-01-14 20:12:22 +02:00
|
|
|
func (c *context) jsonPBlob(code int, callback string, i interface{}) (err error) {
|
2021-07-05 21:33:19 +02:00
|
|
|
indent := ""
|
|
|
|
if _, pretty := c.QueryParams()["pretty"]; c.echo.Debug || pretty {
|
|
|
|
indent = defaultIndent
|
2019-01-14 20:12:22 +02:00
|
|
|
}
|
|
|
|
c.writeContentType(MIMEApplicationJavaScriptCharsetUTF8)
|
|
|
|
c.response.WriteHeader(code)
|
|
|
|
if _, err = c.response.Write([]byte(callback + "(")); err != nil {
|
|
|
|
return
|
|
|
|
}
|
2021-07-05 21:33:19 +02:00
|
|
|
if err = c.echo.JSONSerializer.Serialize(c, i, indent); err != nil {
|
2019-01-14 20:12:22 +02:00
|
|
|
return
|
2017-01-04 22:00:49 +02:00
|
|
|
}
|
2019-01-14 20:12:22 +02:00
|
|
|
if _, err = c.response.Write([]byte(");")); err != nil {
|
2016-12-09 20:24:14 +02:00
|
|
|
return
|
2015-11-01 20:48:55 +02:00
|
|
|
}
|
2019-01-14 20:12:22 +02:00
|
|
|
return
|
2016-12-09 20:24:14 +02:00
|
|
|
}
|
|
|
|
|
2019-01-14 20:56:17 +02:00
|
|
|
func (c *context) json(code int, i interface{}, indent string) error {
|
2024-02-06 07:41:33 +02:00
|
|
|
c.writeContentType(MIMEApplicationJSON)
|
2019-05-24 07:13:57 +02:00
|
|
|
c.response.Status = code
|
2021-07-05 21:33:19 +02:00
|
|
|
return c.echo.JSONSerializer.Serialize(c, i, indent)
|
2019-01-14 20:12:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *context) JSON(code int, i interface{}) (err error) {
|
2019-01-14 20:56:17 +02:00
|
|
|
indent := ""
|
2019-01-14 20:12:22 +02:00
|
|
|
if _, pretty := c.QueryParams()["pretty"]; c.echo.Debug || pretty {
|
2019-01-14 20:56:17 +02:00
|
|
|
indent = defaultIndent
|
2015-10-02 20:23:52 +02:00
|
|
|
}
|
2019-01-14 20:56:17 +02:00
|
|
|
return c.json(code, i, indent)
|
2019-01-14 20:12:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *context) JSONPretty(code int, i interface{}, indent string) (err error) {
|
2019-01-14 20:56:17 +02:00
|
|
|
return c.json(code, i, indent)
|
2015-11-08 06:06:58 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) JSONBlob(code int, b []byte) (err error) {
|
2024-02-06 07:41:33 +02:00
|
|
|
return c.Blob(code, MIMEApplicationJSON, b)
|
2015-04-05 23:21:03 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) JSONP(code int, callback string, i interface{}) (err error) {
|
2019-01-14 20:12:22 +02:00
|
|
|
return c.jsonPBlob(code, callback, i)
|
2016-09-10 00:30:07 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) JSONPBlob(code int, callback string, b []byte) (err error) {
|
2018-03-15 07:51:06 +02:00
|
|
|
c.writeContentType(MIMEApplicationJavaScriptCharsetUTF8)
|
2015-07-24 21:28:35 +02:00
|
|
|
c.response.WriteHeader(code)
|
2016-03-13 01:06:52 +02:00
|
|
|
if _, err = c.response.Write([]byte(callback + "(")); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
if _, err = c.response.Write(b); err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
_, err = c.response.Write([]byte(");"))
|
2015-07-24 21:28:35 +02:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-01-14 20:56:17 +02:00
|
|
|
func (c *context) xml(code int, i interface{}, indent string) (err error) {
|
2019-01-14 20:12:22 +02:00
|
|
|
c.writeContentType(MIMEApplicationXMLCharsetUTF8)
|
|
|
|
c.response.WriteHeader(code)
|
|
|
|
enc := xml.NewEncoder(c.response)
|
2019-01-14 20:56:17 +02:00
|
|
|
if indent != "" {
|
|
|
|
enc.Indent("", indent)
|
2017-01-04 22:00:49 +02:00
|
|
|
}
|
2019-01-14 20:12:22 +02:00
|
|
|
if _, err = c.response.Write([]byte(xml.Header)); err != nil {
|
2016-12-09 20:24:14 +02:00
|
|
|
return
|
2015-11-08 01:39:09 +02:00
|
|
|
}
|
2019-01-14 20:12:22 +02:00
|
|
|
return enc.Encode(i)
|
2015-11-08 06:06:58 +02:00
|
|
|
}
|
|
|
|
|
2019-01-14 20:12:22 +02:00
|
|
|
func (c *context) XML(code int, i interface{}) (err error) {
|
2019-01-14 20:56:17 +02:00
|
|
|
indent := ""
|
2019-01-14 20:12:22 +02:00
|
|
|
if _, pretty := c.QueryParams()["pretty"]; c.echo.Debug || pretty {
|
2019-01-14 20:56:17 +02:00
|
|
|
indent = defaultIndent
|
2016-12-09 20:24:14 +02:00
|
|
|
}
|
2019-01-14 20:56:17 +02:00
|
|
|
return c.xml(code, i, indent)
|
2019-01-14 20:12:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (c *context) XMLPretty(code int, i interface{}, indent string) (err error) {
|
2019-01-14 20:56:17 +02:00
|
|
|
return c.xml(code, i, indent)
|
2016-12-09 20:24:14 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) XMLBlob(code int, b []byte) (err error) {
|
2018-03-15 07:51:06 +02:00
|
|
|
c.writeContentType(MIMEApplicationXMLCharsetUTF8)
|
2016-10-25 17:08:46 +02:00
|
|
|
c.response.WriteHeader(code)
|
2016-03-13 01:06:52 +02:00
|
|
|
if _, err = c.response.Write([]byte(xml.Header)); err != nil {
|
|
|
|
return
|
|
|
|
}
|
2016-10-25 17:08:46 +02:00
|
|
|
_, err = c.response.Write(b)
|
|
|
|
return
|
2016-09-10 00:30:07 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Blob(code int, contentType string, b []byte) (err error) {
|
2018-03-15 07:51:06 +02:00
|
|
|
c.writeContentType(contentType)
|
2016-09-10 00:30:07 +02:00
|
|
|
c.response.WriteHeader(code)
|
2016-03-13 01:06:52 +02:00
|
|
|
_, err = c.response.Write(b)
|
2016-02-11 02:51:43 +02:00
|
|
|
return
|
2015-11-08 01:39:09 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Stream(code int, contentType string, r io.Reader) (err error) {
|
2018-03-15 07:51:06 +02:00
|
|
|
c.writeContentType(contentType)
|
2016-09-10 00:30:07 +02:00
|
|
|
c.response.WriteHeader(code)
|
|
|
|
_, err = io.Copy(c.response, r)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-03-06 19:17:03 +02:00
|
|
|
func (c *context) Attachment(file, name string) error {
|
2016-10-25 23:53:17 +02:00
|
|
|
return c.contentDisposition(file, name, "attachment")
|
2016-08-22 23:46:21 +02:00
|
|
|
}
|
|
|
|
|
2018-03-06 19:17:03 +02:00
|
|
|
func (c *context) Inline(file, name string) error {
|
2016-10-25 23:53:17 +02:00
|
|
|
return c.contentDisposition(file, name, "inline")
|
2016-08-22 23:46:21 +02:00
|
|
|
}
|
|
|
|
|
2023-11-07 14:10:06 +02:00
|
|
|
var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")
|
|
|
|
|
2018-03-06 19:17:03 +02:00
|
|
|
func (c *context) contentDisposition(file, name, dispositionType string) error {
|
2023-11-07 14:10:06 +02:00
|
|
|
c.response.Header().Set(HeaderContentDisposition, fmt.Sprintf(`%s; filename="%s"`, dispositionType, quoteEscaper.Replace(name)))
|
2018-03-06 19:17:03 +02:00
|
|
|
return c.File(file)
|
2015-08-01 04:25:03 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) NoContent(code int) error {
|
2015-05-22 13:40:01 +02:00
|
|
|
c.response.WriteHeader(code)
|
2015-04-19 01:47:48 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Redirect(code int, url string) error {
|
2017-03-27 05:15:48 +02:00
|
|
|
if code < 300 || code > 308 {
|
2016-02-15 18:11:29 +02:00
|
|
|
return ErrInvalidRedirectCode
|
2015-07-22 18:44:52 +02:00
|
|
|
}
|
2016-04-06 16:28:53 +02:00
|
|
|
c.response.Header().Set(HeaderLocation, url)
|
2016-02-20 22:54:43 +02:00
|
|
|
c.response.WriteHeader(code)
|
2015-07-21 04:24:33 +02:00
|
|
|
return nil
|
2015-05-30 02:20:13 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Error(err error) {
|
2016-09-23 07:53:44 +02:00
|
|
|
c.echo.HTTPErrorHandler(err, c)
|
2015-04-20 01:00:23 +02:00
|
|
|
}
|
2015-03-09 08:58:10 +02:00
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Echo() *Echo {
|
2016-02-19 00:04:28 +02:00
|
|
|
return c.echo
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Handler() HandlerFunc {
|
2016-04-12 01:49:20 +02:00
|
|
|
return c.handler
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) SetHandler(h HandlerFunc) {
|
2016-04-17 00:53:27 +02:00
|
|
|
c.handler = h
|
2015-12-04 18:13:26 +02:00
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Logger() Logger {
|
2019-11-11 22:34:13 +02:00
|
|
|
res := c.logger
|
|
|
|
if res != nil {
|
|
|
|
return res
|
|
|
|
}
|
2016-09-23 07:53:44 +02:00
|
|
|
return c.echo.Logger
|
2015-12-01 21:22:45 +02:00
|
|
|
}
|
|
|
|
|
2019-11-11 22:34:13 +02:00
|
|
|
func (c *context) SetLogger(l Logger) {
|
|
|
|
c.logger = l
|
|
|
|
}
|
|
|
|
|
2016-10-11 02:31:26 +02:00
|
|
|
func (c *context) Reset(r *http.Request, w http.ResponseWriter) {
|
2016-09-23 07:53:44 +02:00
|
|
|
c.request = r
|
|
|
|
c.response.reset(w)
|
2017-01-31 23:55:39 +02:00
|
|
|
c.query = nil
|
2016-07-05 17:43:46 +02:00
|
|
|
c.handler = NotFoundHandler
|
2017-01-31 23:55:39 +02:00
|
|
|
c.store = nil
|
2017-03-30 12:05:24 +02:00
|
|
|
c.path = ""
|
2017-04-10 22:10:31 +02:00
|
|
|
c.pnames = nil
|
2019-11-11 22:34:13 +02:00
|
|
|
c.logger = nil
|
2017-04-10 22:10:31 +02:00
|
|
|
// NOTE: Don't reset because it has to have length c.echo.maxParam at all times
|
2019-10-24 19:48:56 +02:00
|
|
|
for i := 0; i < *c.echo.maxParam; i++ {
|
|
|
|
c.pvalues[i] = ""
|
|
|
|
}
|
2015-03-06 21:12:33 +02:00
|
|
|
}
|