feat(serverHandler/log): output unescaped url path

Author: marjune163

src/serverHandler/log.go

@@ -1,21 +1,39 @@
 package serverHandler
 
 import (
+	"../util"
 	"net/http"
+	"net/url"
 )
 
 func (h *handler) logRequest(r *http.Request) {
 	if !h.logger.CanLogAccess() {
 		return
 	}
 
-	buf := make([]byte, 0, 2+len(r.RemoteAddr)+len(r.Method)+len(r.RequestURI))
+	var unescapedUri []byte
+	unescapedLen := 0
+	unescapedStr, err := url.QueryUnescape(r.RequestURI)
+	if err == nil && unescapedStr != r.RequestURI {
+		unescapedUri = util.EscapeControllingRune(unescapedStr)
+		if len(unescapedUri) > 0 {
+			unescapedLen = len(unescapedUri) + 5 // " <=> "
+		}
+	}
+
+	uri := util.EscapeControllingRune(r.RequestURI)
+
+	buf := make([]byte, 0, 2+len(r.RemoteAddr)+len(r.Method)+unescapedLen+len(uri))
 
 	buf = append(buf, []byte(r.RemoteAddr)...) // ~ 9-47 bytes, mainly 21 bytes
 	buf = append(buf, ' ')                     // 1 byte
 	buf = append(buf, []byte(r.Method)...)     // ~ 3-4 bytes
 	buf = append(buf, ' ')                     // 1 byte
-	buf = append(buf, []byte(r.RequestURI)...)
+	if unescapedLen > 0 {
+		buf = append(buf, unescapedUri...)
+		buf = append(buf, ' ', '<', '=', '>', ' ') // 5 bytes
+	}
+	buf = append(buf, uri...)
 
 	go h.logger.LogAccess(buf)
 }

src/util/conv.go

@@ -0,0 +1,9 @@
+package util
+
+var hexSeq = [...]byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}
+
+func ByteToHex(b byte) (high, low byte) {
+	high = hexSeq[b>>4]
+	low = hexSeq[b&15]
+	return
+}

src/util/conv_test.go

@@ -0,0 +1,47 @@
+package util
+
+import "testing"
+
+func TestByteToHex(t *testing.T) {
+	var h, l byte
+
+	h, l = ByteToHex(0)
+	if h != '0' && l != '0' {
+		t.Error(h, l)
+	}
+
+	h, l = ByteToHex(8)
+	if h != '0' && l != '8' {
+		t.Error(h, l)
+	}
+
+	h, l = ByteToHex(15)
+	if h != '0' && l != 'f' {
+		t.Error(h, l)
+	}
+
+	h, l = ByteToHex(16)
+	if h != '1' && l != '0' {
+		t.Error(h, l)
+	}
+
+	h, l = ByteToHex(24)
+	if h != '1' && l != '8' {
+		t.Error(h, l)
+	}
+
+	h, l = ByteToHex(240)
+	if h != 'f' && l != '0' {
+		t.Error(h, l)
+	}
+
+	h, l = ByteToHex(248)
+	if h != 'f' && l != '8' {
+		t.Error(h, l)
+	}
+
+	h, l = ByteToHex(255)
+	if h != 'f' && l != 'f' {
+		t.Error(h, l)
+	}
+}

src/util/str.go

@@ -1,6 +1,10 @@
 package util
 
-import "strings"
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
 
 type StrEqualFunc func(a, b string) bool
 
@@ -11,3 +15,47 @@ func IsStrEqualAccurate(a, b string) bool {
 func IsStrEqualNoCase(a, b string) bool {
 	return strings.EqualFold(a, b)
 }
+
+func EscapeControllingRune(str string) []byte {
+	runeBytes := make([]byte, 4)
+	buf := make([]byte, 0, len(str))
+
+	for _, r := range str {
+		if uint32(r) < 32 { // non-printable chars
+			b := byte(r)
+			if b == 0 {
+				buf = append(buf, '\\', '0')
+			} else if b == '\a' {
+				buf = append(buf, '\\', 'a')
+			} else if b == '\b' {
+				buf = append(buf, '\\', 'b')
+			} else if b == '\f' {
+				buf = append(buf, '\\', 'f')
+			} else if b == '\n' {
+				buf = append(buf, '\\', 'n')
+			} else if b == '\r' {
+				buf = append(buf, '\\', 'r')
+			} else if b == '\t' {
+				buf = append(buf, '\\', 't')
+			} else if b == '\v' {
+				buf = append(buf, '\\', 'v')
+			} else {
+				h, l := ByteToHex(b)
+				buf = append(buf, '\\', 'x', h, l)
+			}
+			continue
+		}
+
+		if unicode.IsControl(r) {
+			nBytes := utf8.EncodeRune(runeBytes, r)
+			for i := 0; i < nBytes; i++ {
+				h, l := ByteToHex(runeBytes[i])
+				buf = append(buf, '\\', 'x', h, l)
+			}
+		} else {
+			buf = utf8.AppendRune(buf, r)
+		}
+	}
+
+	return buf
+}

src/util/str_test.go

@@ -0,0 +1,35 @@
+package util
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestReplaceControllingRune(t *testing.T) {
+	var str string
+	buf := make([]byte, 0, 64)
+
+	str = "abcdefg"
+	buf = EscapeControllingRune(str)
+	if !bytes.Equal(buf, []byte(str)) {
+		t.Error(string(buf))
+	}
+
+	str = "abc\tdef"
+	buf = EscapeControllingRune(str)
+	if !bytes.Equal(buf, []byte("abc\\tdef")) {
+		t.Error(string(buf))
+	}
+
+	str = "<\000\a\b\f\n\r\t\v>"
+	buf = EscapeControllingRune(str)
+	if !bytes.Equal(buf, []byte("<\\0\\a\\b\\f\\n\\r\\t\\v>")) {
+		t.Error(string(buf))
+	}
+
+	str = string([]byte{'[', 0x0e, 127, ']'})
+	buf = EscapeControllingRune(str)
+	if !bytes.Equal(buf, []byte("[\\x0e\\x7f]")) {
+		t.Error(string(buf))
+	}
+}