[Vendor] update macaron related (#13409)

* Vendor: update gitea.com/macaron/session to a177a270

* make vendor

* Vendor: update gitea.com/macaron/macaron to 0db5d458

* make vendor

* Vendor: update gitea.com/macaron/cache to 905232fb

* make vendor

* Vendor: update gitea.com/macaron/i18n to 4ca3dd0c

* make vendor

* Vendor: update gitea.com/macaron/gzip to efa5e847

* make vendor

* Vendor: update gitea.com/macaron/captcha to e8597820

* make vendor

9 files changed, 908 insertions, 0 deletions

diff --git a/vendor/gitea.com/lunny/log/.gitignore b/vendor/gitea.com/lunny/log/.gitignore
new file mode 100644
index 0000000000..3a11644b45
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/.gitignore
@@ -0,0 +1,26 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+log.db
+*.log
+logs
+.vscode
\ No newline at end of file
diff --git a/vendor/gitea.com/lunny/log/LICENSE b/vendor/gitea.com/lunny/log/LICENSE
new file mode 100644
index 0000000000..c9338f8293
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2014 - 2016 lunny
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/gitea.com/lunny/log/README.md b/vendor/gitea.com/lunny/log/README.md
new file mode 100644
index 0000000000..be63a4d373
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/README.md
@@ -0,0 +1,51 @@
+## log
+
+[![](https://goreportcard.com/badge/gitea.com/lunny/log)](https://goreportcard.com/report/gitea.com/lunny/log)
+[![GoDoc](https://godoc.org/gitea.com/lunny/log?status.png)](https://godoc.org/gitea.com/lunny/log)
+
+[简体中文](https://gitea.com/lunny/log/blob/master/README_CN.md)
+
+# Installation
+
+```
+go get gitea.com/lunny/log
+```
+
+# Features
+
+* Add color support for unix console
+* Implemented dbwriter to save log to database
+* Implemented FileWriter to save log to file by date or time.
+* Location configuration
+
+# Example
+
+For Single File:
+```Go
+f, _ := os.Create("my.log")
+log.Std.SetOutput(f)
+```
+
+For Multiple Writer:
+```Go
+f, _ := os.Create("my.log")
+log.Std.SetOutput(io.MultiWriter(f, os.Stdout))
+```
+
+For log files by date or time:
+```Go
+w := log.NewFileWriter(log.FileOptions{
+    ByType:log.ByDay,
+    Dir:"./logs",
+})
+log.Std.SetOutput(w)
+```
+
+# About
+
+This repo is an extension of Golang log.
+
+# LICENSE
+
+ BSD License
+ [http://creativecommons.org/licenses/BSD/](http://creativecommons.org/licenses/BSD/)
diff --git a/vendor/gitea.com/lunny/log/README_CN.md b/vendor/gitea.com/lunny/log/README_CN.md
new file mode 100644
index 0000000000..29cd6c1ca4
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/README_CN.md
@@ -0,0 +1,54 @@
+## log
+
+[![](https://goreportcard.com/badge/gitea.com/lunny/log)](https://goreportcard.com/report/gitea.com/lunny/log)
+[![GoDoc](https://godoc.org/gitea.com/lunny/log?status.png)](https://godoc.org/gitea.com/lunny/log)
+
+[English](https://gitea.com/lunny/log/blob/master/README.md)
+
+# 安装
+
+```
+go get gitea.com/lunny/log
+```
+
+# 特性
+
+* 对unix增加控制台颜色支持
+* 实现了保存log到数据库支持
+* 实现了保存log到按日期的文件支持
+* 实现了设置日期的地区
+
+# 例子
+
+保存到单个文件：
+
+```Go
+f, _ := os.Create("my.log")
+log.Std.SetOutput(f)
+```
+
+保存到数据库：
+
+```Go
+f, _ := os.Create("my.log")
+log.Std.SetOutput(io.MultiWriter(f, os.Stdout))
+```
+
+保存到按时间分隔的文件：
+
+```Go
+w := log.NewFileWriter(log.FileOptions{
+    ByType:log.ByDay,
+    Dir:"./logs",
+})
+log.Std.SetOutput(w)
+```
+
+# 关于
+
+本 Log 是在 golang 的 log 之上的扩展
+
+# LICENSE
+
+ BSD License
+ [http://creativecommons.org/licenses/BSD/](http://creativecommons.org/licenses/BSD/)
diff --git a/vendor/gitea.com/lunny/log/dbwriter.go b/vendor/gitea.com/lunny/log/dbwriter.go
new file mode 100644
index 0000000000..e8ff00bd89
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/dbwriter.go
@@ -0,0 +1,36 @@
+package log
+
+import (
+	"database/sql"
+	"time"
+)
+
+type DBWriter struct {
+	db      *sql.DB
+	stmt    *sql.Stmt
+	content chan []byte
+}
+
+func NewDBWriter(db *sql.DB) (*DBWriter, error) {
+	_, err := db.Exec("CREATE TABLE IF NOT EXISTS log (id int, content text, created datetime)")
+	if err != nil {
+		return nil, err
+	}
+	stmt, err := db.Prepare("INSERT INTO log (content, created) values (?, ?)")
+	if err != nil {
+		return nil, err
+	}
+	return &DBWriter{db, stmt, make(chan []byte, 1000)}, nil
+}
+
+func (w *DBWriter) Write(p []byte) (n int, err error) {
+	_, err = w.stmt.Exec(string(p), time.Now())
+	if err == nil {
+		n = len(p)
+	}
+	return
+}
+
+func (w *DBWriter) Close() {
+	w.stmt.Close()
+}
diff --git a/vendor/gitea.com/lunny/log/filewriter.go b/vendor/gitea.com/lunny/log/filewriter.go
new file mode 100644
index 0000000000..f0bb4d1df1
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/filewriter.go
@@ -0,0 +1,112 @@
+package log
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+var _ io.Writer = &Files{}
+
+type ByType int
+
+const (
+	ByDay ByType = iota
+	ByHour
+	ByMonth
+)
+
+var (
+	formats = map[ByType]string{
+		ByDay:   "2006-01-02",
+		ByHour:  "2006-01-02-15",
+		ByMonth: "2006-01",
+	}
+)
+
+func SetFileFormat(t ByType, format string) {
+	formats[t] = format
+}
+
+func (b ByType) Format() string {
+	return formats[b]
+}
+
+type Files struct {
+	FileOptions
+	f          *os.File
+	lastFormat string
+	lock       sync.Mutex
+}
+
+type FileOptions struct {
+	Dir    string
+	ByType ByType
+	Loc    *time.Location
+}
+
+func prepareFileOption(opts []FileOptions) FileOptions {
+	var opt FileOptions
+	if len(opts) > 0 {
+		opt = opts[0]
+	}
+	if opt.Dir == "" {
+		opt.Dir = "./"
+	}
+	err := os.MkdirAll(opt.Dir, os.ModePerm)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	if opt.Loc == nil {
+		opt.Loc = time.Local
+	}
+	return opt
+}
+
+func NewFileWriter(opts ...FileOptions) *Files {
+	opt := prepareFileOption(opts)
+	return &Files{
+		FileOptions: opt,
+	}
+}
+
+func (f *Files) getFile() (*os.File, error) {
+	var err error
+	t := time.Now().In(f.Loc)
+	if f.f == nil {
+		f.lastFormat = t.Format(f.ByType.Format())
+		f.f, err = os.OpenFile(filepath.Join(f.Dir, f.lastFormat+".log"),
+			os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
+		return f.f, err
+	}
+	if f.lastFormat != t.Format(f.ByType.Format()) {
+		f.f.Close()
+		f.lastFormat = t.Format(f.ByType.Format())
+		f.f, err = os.OpenFile(filepath.Join(f.Dir, f.lastFormat+".log"),
+			os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
+		return f.f, err
+	}
+	return f.f, nil
+}
+
+func (f *Files) Write(bs []byte) (int, error) {
+	f.lock.Lock()
+	defer f.lock.Unlock()
+
+	w, err := f.getFile()
+	if err != nil {
+		return 0, err
+	}
+	return w.Write(bs)
+}
+
+func (f *Files) Close() {
+	if f.f != nil {
+		f.f.Close()
+		f.f = nil
+	}
+	f.lastFormat = ""
+}
diff --git a/vendor/gitea.com/lunny/log/go.mod b/vendor/gitea.com/lunny/log/go.mod
new file mode 100644
index 0000000000..f756706435
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/go.mod
@@ -0,0 +1,5 @@
+module gitea.com/lunny/log
+
+go 1.12
+
+require github.com/mattn/go-sqlite3 v1.10.0
diff --git a/vendor/gitea.com/lunny/log/go.sum b/vendor/gitea.com/lunny/log/go.sum
new file mode 100644
index 0000000000..263c18737e
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/go.sum
@@ -0,0 +1,2 @@
+github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o=
+github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
diff --git a/vendor/gitea.com/lunny/log/logext.go b/vendor/gitea.com/lunny/log/logext.go
new file mode 100644
index 0000000000..215c45f309
--- /dev/null
+++ b/vendor/gitea.com/lunny/log/logext.go
@@ -0,0 +1,595 @@
+package log
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+)
+
+// These flags define which text to prefix to each log entry generated by the Logger.
+const (
+	// Bits or'ed together to control what's printed. There is no control over the
+	// order they appear (the order listed here) or the format they present (as
+	// described in the comments).  A colon appears after these items:
+	//	2009/0123 01:23:23.123123 /a/b/c/d.go:23: message
+	Ldate         = 1 << iota     // the date: 2009/0123
+	Ltime                         // the time: 01:23:23
+	Lmicroseconds                 // microsecond resolution: 01:23:23.123123.  assumes Ltime.
+	Llongfile                     // full file name and line number: /a/b/c/d.go:23
+	Lshortfile                    // final file name element and line number: d.go:23. overrides Llongfile
+	Lmodule                       // module name
+	Llevel                        // level: 0(Debug), 1(Info), 2(Warn), 3(Error), 4(Panic), 5(Fatal)
+	Llongcolor                    // color will start [info] end of line
+	Lshortcolor                   // color only include [info]
+	LstdFlags     = Ldate | Ltime // initial values for the standard logger
+	//Ldefault      = Llevel | LstdFlags | Lshortfile | Llongcolor
+) // [prefix][time][level][module][shortfile|longfile]
+
+func Ldefault() int {
+	if runtime.GOOS == "windows" {
+		return Llevel | LstdFlags | Lshortfile
+	}
+	return Llevel | LstdFlags | Lshortfile | Llongcolor
+}
+
+func Version() string {
+	return "0.2.0.1121"
+}
+
+const (
+	Lall = iota
+)
+const (
+	Ldebug = iota
+	Linfo
+	Lwarn
+	Lerror
+	Lpanic
+	Lfatal
+	Lnone
+)
+
+const (
+	ForeBlack  = iota + 30 //30
+	ForeRed                //31
+	ForeGreen              //32
+	ForeYellow             //33
+	ForeBlue               //34
+	ForePurple             //35
+	ForeCyan               //36
+	ForeWhite              //37
+)
+
+const (
+	BackBlack  = iota + 40 //40
+	BackRed                //41
+	BackGreen              //42
+	BackYellow             //43
+	BackBlue               //44
+	BackPurple             //45
+	BackCyan               //46
+	BackWhite              //47
+)
+
+var levels = []string{
+	"[Debug]",
+	"[Info]",
+	"[Warn]",
+	"[Error]",
+	"[Panic]",
+	"[Fatal]",
+}
+
+// MUST called before all logs
+func SetLevels(lvs []string) {
+	levels = lvs
+}
+
+var colors = []int{
+	ForeCyan,
+	ForeGreen,
+	ForeYellow,
+	ForeRed,
+	ForePurple,
+	ForeBlue,
+}
+
+// MUST called before all logs
+func SetColors(cls []int) {
+	colors = cls
+}
+
+// A Logger represents an active logging object that generates lines of
+// output to an io.Writer.  Each logging operation makes a single call to
+// the Writer's Write method.  A Logger can be used simultaneously from
+// multiple goroutines; it guarantees to serialize access to the Writer.
+type Logger struct {
+	mu         sync.Mutex // ensures atomic writes; protects the following fields
+	prefix     string     // prefix to write at beginning of each line
+	flag       int        // properties
+	Level      int
+	out        io.Writer    // destination for output
+	buf        bytes.Buffer // for accumulating text to write
+	levelStats [6]int64
+	loc        *time.Location
+}
+
+// New creates a new Logger.   The out variable sets the
+// destination to which log data will be written.
+// The prefix appears at the beginning of each generated log line.
+// The flag argument defines the logging properties.
+func New(out io.Writer, prefix string, flag int) *Logger {
+	l := &Logger{out: out, prefix: prefix, Level: 1, flag: flag, loc: time.Local}
+	if out != os.Stdout {
+		l.flag = RmColorFlags(l.flag)
+	}
+	return l
+}
+
+var Std = New(os.Stderr, "", Ldefault())
+
+// Cheap integer to fixed-width decimal ASCII.  Give a negative width to avoid zero-padding.
+// Knows the buffer has capacity.
+func itoa(buf *bytes.Buffer, i int, wid int) {
+	var u uint = uint(i)
+	if u == 0 && wid <= 1 {
+		buf.WriteByte('0')
+		return
+	}
+
+	// Assemble decimal in reverse order.
+	var b [32]byte
+	bp := len(b)
+	for ; u > 0 || wid > 0; u /= 10 {
+		bp--
+		wid--
+		b[bp] = byte(u%10) + '0'
+	}
+
+	// avoid slicing b to avoid an allocation.
+	for bp < len(b) {
+		buf.WriteByte(b[bp])
+		bp++
+	}
+}
+
+func moduleOf(file string) string {
+	pos := strings.LastIndex(file, "/")
+	if pos != -1 {
+		pos1 := strings.LastIndex(file[:pos], "/src/")
+		if pos1 != -1 {
+			return file[pos1+5 : pos]
+		}
+	}
+	return "UNKNOWN"
+}
+
+func (l *Logger) formatHeader(buf *bytes.Buffer, t time.Time,
+	file string, line int, lvl int, reqId string) {
+	if l.prefix != "" {
+		buf.WriteString(l.prefix)
+	}
+	if l.flag&(Ldate|Ltime|Lmicroseconds) != 0 {
+		if l.flag&Ldate != 0 {
+			year, month, day := t.Date()
+			itoa(buf, year, 4)
+			buf.WriteByte('/')
+			itoa(buf, int(month), 2)
+			buf.WriteByte('/')
+			itoa(buf, day, 2)
+			buf.WriteByte(' ')
+		}
+		if l.flag&(Ltime|Lmicroseconds) != 0 {
+			hour, min, sec := t.Clock()
+			itoa(buf, hour, 2)
+			buf.WriteByte(':')
+			itoa(buf, min, 2)
+			buf.WriteByte(':')
+			itoa(buf, sec, 2)
+			if l.flag&Lmicroseconds != 0 {
+				buf.WriteByte('.')
+				itoa(buf, t.Nanosecond()/1e3, 6)
+			}
+			buf.WriteByte(' ')
+		}
+	}
+	if reqId != "" {
+		buf.WriteByte('[')
+		buf.WriteString(reqId)
+		buf.WriteByte(']')
+		buf.WriteByte(' ')
+	}
+
+	if l.flag&(Lshortcolor|Llongcolor) != 0 {
+		buf.WriteString(fmt.Sprintf("\033[1;%dm", colors[lvl]))
+	}
+	if l.flag&Llevel != 0 {
+		buf.WriteString(levels[lvl])
+		buf.WriteByte(' ')
+	}
+	if l.flag&Lshortcolor != 0 {
+		buf.WriteString("\033[0m")
+	}
+
+	if l.flag&Lmodule != 0 {
+		buf.WriteByte('[')
+		buf.WriteString(moduleOf(file))
+		buf.WriteByte(']')
+		buf.WriteByte(' ')
+	}
+	if l.flag&(Lshortfile|Llongfile) != 0 {
+		if l.flag&Lshortfile != 0 {
+			short := file
+			for i := len(file) - 1; i > 0; i-- {
+				if file[i] == '/' {
+					short = file[i+1:]
+					break
+				}
+			}
+			file = short
+		}
+		buf.WriteString(file)
+		buf.WriteByte(':')
+		itoa(buf, line, -1)
+		buf.WriteByte(' ')
+	}
+}
+
+// Output writes the output for a logging event.  The string s contains
+// the text to print after the prefix specified by the flags of the
+// Logger.  A newline is appended if the last character of s is not
+// already a newline.  Calldepth is used to recover the PC and is
+// provided for generality, although at the moment on all pre-defined
+// paths it will be 2.
+func (l *Logger) Output(reqId string, lvl int, calldepth int, s string) error {
+	if lvl < l.Level {
+		return nil
+	}
+	now := time.Now().In(l.loc) // get this early.
+	var file string
+	var line int
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.flag&(Lshortfile|Llongfile|Lmodule) != 0 {
+		// release lock while getting caller info - it's expensive.
+		l.mu.Unlock()
+		var ok bool
+		_, file, line, ok = runtime.Caller(calldepth)
+		if !ok {
+			file = "???"
+			line = 0
+		}
+		l.mu.Lock()
+	}
+	l.levelStats[lvl]++
+	l.buf.Reset()
+	l.formatHeader(&l.buf, now, file, line, lvl, reqId)
+	l.buf.WriteString(s)
+	if l.flag&Llongcolor != 0 {
+		l.buf.WriteString("\033[0m")
+	}
+	if len(s) > 0 && s[len(s)-1] != '\n' {
+		l.buf.WriteByte('\n')
+	}
+	_, err := l.out.Write(l.buf.Bytes())
+	return err
+}
+
+// -----------------------------------------
+
+// Printf calls l.Output to print to the logger.
+// Arguments are handled in the manner of fmt.Printf.
+func (l *Logger) Printf(format string, v ...interface{}) {
+	l.Output("", Linfo, 2, fmt.Sprintf(format, v...))
+}
+
+// Print calls l.Output to print to the logger.
+// Arguments are handled in the manner of fmt.Print.
+func (l *Logger) Print(v ...interface{}) {
+	l.Output("", Linfo, 2, fmt.Sprint(v...))
+}
+
+// Println calls l.Output to print to the logger.
+// Arguments are handled in the manner of fmt.Println.
+func (l *Logger) Println(v ...interface{}) {
+	l.Output("", Linfo, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+func (l *Logger) Debugf(format string, v ...interface{}) {
+	l.Output("", Ldebug, 2, fmt.Sprintf(format, v...))
+}
+
+func (l *Logger) Debug(v ...interface{}) {
+	l.Output("", Ldebug, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+func (l *Logger) Infof(format string, v ...interface{}) {
+	l.Output("", Linfo, 2, fmt.Sprintf(format, v...))
+}
+
+func (l *Logger) Info(v ...interface{}) {
+	l.Output("", Linfo, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+func (l *Logger) Warnf(format string, v ...interface{}) {
+	l.Output("", Lwarn, 2, fmt.Sprintf(format, v...))
+}
+
+func (l *Logger) Warn(v ...interface{}) {
+	l.Output("", Lwarn, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+func (l *Logger) Errorf(format string, v ...interface{}) {
+	l.Output("", Lerror, 2, fmt.Sprintf(format, v...))
+}
+
+func (l *Logger) Error(v ...interface{}) {
+	l.Output("", Lerror, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+func (l *Logger) Fatal(v ...interface{}) {
+	l.Output("", Lfatal, 2, fmt.Sprintln(v...))
+	os.Exit(1)
+}
+
+// Fatalf is equivalent to l.Printf() followed by a call to os.Exit(1).
+func (l *Logger) Fatalf(format string, v ...interface{}) {
+	l.Output("", Lfatal, 2, fmt.Sprintf(format, v...))
+	os.Exit(1)
+}
+
+// -----------------------------------------
+// Panic is equivalent to l.Print() followed by a call to panic().
+func (l *Logger) Panic(v ...interface{}) {
+	s := fmt.Sprintln(v...)
+	l.Output("", Lpanic, 2, s)
+	panic(s)
+}
+
+// Panicf is equivalent to l.Printf() followed by a call to panic().
+func (l *Logger) Panicf(format string, v ...interface{}) {
+	s := fmt.Sprintf(format, v...)
+	l.Output("", Lpanic, 2, s)
+	panic(s)
+}
+
+// -----------------------------------------
+func (l *Logger) Stack(v ...interface{}) {
+	s := fmt.Sprint(v...)
+	s += "\n"
+	buf := make([]byte, 1024*1024)
+	n := runtime.Stack(buf, true)
+	s += string(buf[:n])
+	s += "\n"
+	l.Output("", Lerror, 2, s)
+}
+
+// -----------------------------------------
+func (l *Logger) Stat() (stats []int64) {
+	l.mu.Lock()
+	v := l.levelStats
+	l.mu.Unlock()
+	return v[:]
+}
+
+// Flags returns the output flags for the logger.
+func (l *Logger) Flags() int {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.flag
+}
+
+func RmColorFlags(flag int) int {
+	// for un std out, it should not show color since almost them don't support
+	if flag&Llongcolor != 0 {
+		flag = flag ^ Llongcolor
+	}
+	if flag&Lshortcolor != 0 {
+		flag = flag ^ Lshortcolor
+	}
+	return flag
+}
+
+func (l *Logger) Location() *time.Location {
+	return l.loc
+}
+
+func (l *Logger) SetLocation(loc *time.Location) {
+	l.loc = loc
+}
+
+// SetFlags sets the output flags for the logger.
+func (l *Logger) SetFlags(flag int) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.out != os.Stdout {
+		flag = RmColorFlags(flag)
+	}
+	l.flag = flag
+}
+
+// Prefix returns the output prefix for the logger.
+func (l *Logger) Prefix() string {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return l.prefix
+}
+
+// SetPrefix sets the output prefix for the logger.
+func (l *Logger) SetPrefix(prefix string) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.prefix = prefix
+}
+
+// SetOutputLevel sets the output level for the logger.
+func (l *Logger) SetOutputLevel(lvl int) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.Level = lvl
+}
+
+func (l *Logger) OutputLevel() int {
+	return l.Level
+}
+
+func (l *Logger) SetOutput(w io.Writer) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.out = w
+	if w != os.Stdout {
+		l.flag = RmColorFlags(l.flag)
+	}
+}
+
+// SetOutput sets the output destination for the standard logger.
+func SetOutput(w io.Writer) {
+	Std.SetOutput(w)
+}
+
+func SetLocation(loc *time.Location) {
+	Std.SetLocation(loc)
+}
+
+func Location() *time.Location {
+	return Std.Location()
+}
+
+// Flags returns the output flags for the standard logger.
+func Flags() int {
+	return Std.Flags()
+}
+
+// SetFlags sets the output flags for the standard logger.
+func SetFlags(flag int) {
+	Std.SetFlags(flag)
+}
+
+// Prefix returns the output prefix for the standard logger.
+func Prefix() string {
+	return Std.Prefix()
+}
+
+// SetPrefix sets the output prefix for the standard logger.
+func SetPrefix(prefix string) {
+	Std.SetPrefix(prefix)
+}
+
+func SetOutputLevel(lvl int) {
+	Std.SetOutputLevel(lvl)
+}
+
+func OutputLevel() int {
+	return Std.OutputLevel()
+}
+
+// -----------------------------------------
+
+// Print calls Output to print to the standard logger.
+// Arguments are handled in the manner of fmt.Print.
+func Print(v ...interface{}) {
+	Std.Output("", Linfo, 2, fmt.Sprintln(v...))
+}
+
+// Printf calls Output to print to the standard logger.
+// Arguments are handled in the manner of fmt.Printf.
+func Printf(format string, v ...interface{}) {
+	Std.Output("", Linfo, 2, fmt.Sprintf(format, v...))
+}
+
+// Println calls Output to print to the standard logger.
+// Arguments are handled in the manner of fmt.Println.
+func Println(v ...interface{}) {
+	Std.Output("", Linfo, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+func Debugf(format string, v ...interface{}) {
+	Std.Output("", Ldebug, 2, fmt.Sprintf(format, v...))
+}
+
+func Debug(v ...interface{}) {
+	Std.Output("", Ldebug, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+func Infof(format string, v ...interface{}) {
+	Std.Output("", Linfo, 2, fmt.Sprintf(format, v...))
+}
+
+func Info(v ...interface{}) {
+	Std.Output("", Linfo, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+func Warnf(format string, v ...interface{}) {
+	Std.Output("", Lwarn, 2, fmt.Sprintf(format, v...))
+}
+
+func Warn(v ...interface{}) {
+	Std.Output("", Lwarn, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+func Errorf(format string, v ...interface{}) {
+	Std.Output("", Lerror, 2, fmt.Sprintf(format, v...))
+}
+
+func Error(v ...interface{}) {
+	Std.Output("", Lerror, 2, fmt.Sprintln(v...))
+}
+
+// -----------------------------------------
+
+// Fatal is equivalent to Print() followed by a call to os.Exit(1).
+func Fatal(v ...interface{}) {
+	Std.Output("", Lfatal, 2, fmt.Sprintln(v...))
+}
+
+// Fatalf is equivalent to Printf() followed by a call to os.Exit(1).
+func Fatalf(format string, v ...interface{}) {
+	Std.Output("", Lfatal, 2, fmt.Sprintf(format, v...))
+}
+
+// -----------------------------------------
+
+// Panic is equivalent to Print() followed by a call to panic().
+func Panic(v ...interface{}) {
+	Std.Output("", Lpanic, 2, fmt.Sprintln(v...))
+}
+
+// Panicf is equivalent to Printf() followed by a call to panic().
+func Panicf(format string, v ...interface{}) {
+	Std.Output("", Lpanic, 2, fmt.Sprintf(format, v...))
+}
+
+// -----------------------------------------
+
+func Stack(v ...interface{}) {
+	s := fmt.Sprint(v...)
+	s += "\n"
+	buf := make([]byte, 1024*1024)
+	n := runtime.Stack(buf, true)
+	s += string(buf[:n])
+	s += "\n"
+	Std.Output("", Lerror, 2, s)
+}
+
+// -----------------------------------------