v1.0.0

infra/conf/json/reader.go

@@ -0,0 +1,133 @@
+package json
+
+import (
+	"io"
+
+	"github.com/xtls/xray-core/v1/common/buf"
+)
+
+// State is the internal state of parser.
+type State byte
+
+const (
+	StateContent State = iota
+	StateEscape
+	StateDoubleQuote
+	StateDoubleQuoteEscape
+	StateSingleQuote
+	StateSingleQuoteEscape
+	StateComment
+	StateSlash
+	StateMultilineComment
+	StateMultilineCommentStar
+)
+
+// Reader is a reader for filtering comments.
+// It supports Java style single and multi line comment syntax, and Python style single line comment syntax.
+type Reader struct {
+	io.Reader
+
+	state State
+	br    *buf.BufferedReader
+}
+
+// Read implements io.Reader.Read(). Buffer must be at least 3 bytes.
+func (v *Reader) Read(b []byte) (int, error) {
+	if v.br == nil {
+		v.br = &buf.BufferedReader{Reader: buf.NewReader(v.Reader)}
+	}
+
+	p := b[:0]
+	for len(p) < len(b)-2 {
+		x, err := v.br.ReadByte()
+		if err != nil {
+			if len(p) == 0 {
+				return 0, err
+			}
+			return len(p), nil
+		}
+		switch v.state {
+		case StateContent:
+			switch x {
+			case '"':
+				v.state = StateDoubleQuote
+				p = append(p, x)
+			case '\'':
+				v.state = StateSingleQuote
+				p = append(p, x)
+			case '\\':
+				v.state = StateEscape
+			case '#':
+				v.state = StateComment
+			case '/':
+				v.state = StateSlash
+			default:
+				p = append(p, x)
+			}
+		case StateEscape:
+			p = append(p, '\\', x)
+			v.state = StateContent
+		case StateDoubleQuote:
+			switch x {
+			case '"':
+				v.state = StateContent
+				p = append(p, x)
+			case '\\':
+				v.state = StateDoubleQuoteEscape
+			default:
+				p = append(p, x)
+			}
+		case StateDoubleQuoteEscape:
+			p = append(p, '\\', x)
+			v.state = StateDoubleQuote
+		case StateSingleQuote:
+			switch x {
+			case '\'':
+				v.state = StateContent
+				p = append(p, x)
+			case '\\':
+				v.state = StateSingleQuoteEscape
+			default:
+				p = append(p, x)
+			}
+		case StateSingleQuoteEscape:
+			p = append(p, '\\', x)
+			v.state = StateSingleQuote
+		case StateComment:
+			if x == '\n' {
+				v.state = StateContent
+				p = append(p, '\n')
+			}
+		case StateSlash:
+			switch x {
+			case '/':
+				v.state = StateComment
+			case '*':
+				v.state = StateMultilineComment
+			default:
+				p = append(p, '/', x)
+			}
+		case StateMultilineComment:
+			switch x {
+			case '*':
+				v.state = StateMultilineCommentStar
+			case '\n':
+				p = append(p, '\n')
+			}
+		case StateMultilineCommentStar:
+			switch x {
+			case '/':
+				v.state = StateContent
+			case '*':
+				// Stay
+			case '\n':
+				p = append(p, '\n')
+			default:
+				v.state = StateMultilineComment
+			}
+		default:
+			panic("Unknown state.")
+		}
+	}
+	return len(p), nil
+}

infra/conf/json/reader_test.go

@@ -0,0 +1,96 @@
+package json_test
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/xtls/xray-core/v1/common"
+	. "github.com/xtls/xray-core/v1/infra/conf/json"
+)
+
+func TestReader(t *testing.T) {
+	data := []struct {
+		input  string
+		output string
+	}{
+		{
+			`
+content #comment 1
+#comment 2
+content 2`,
+			`
+content 
+
+content 2`},
+		{`content`, `content`},
+		{" ", " "},
+		{`con/*abcd*/tent`, "content"},
+		{`
+text // adlkhdf /*
+//comment adfkj
+text 2*/`, `
+text 
+
+text 2*`},
+		{`"//"content`, `"//"content`},
+		{`abcd'//'abcd`, `abcd'//'abcd`},
+		{`"\""`, `"\""`},
+		{`\"/*abcd*/\"`, `\"\"`},
+	}
+
+	for _, testCase := range data {
+		reader := &Reader{
+			Reader: bytes.NewReader([]byte(testCase.input)),
+		}
+
+		actual := make([]byte, 1024)
+		n, err := reader.Read(actual)
+		common.Must(err)
+		if r := cmp.Diff(string(actual[:n]), testCase.output); r != "" {
+			t.Error(r)
+		}
+	}
+}
+
+func TestReader1(t *testing.T) {
+	type dataStruct struct {
+		input  string
+		output string
+	}
+
+	bufLen := 8
+
+	data := []dataStruct{
+		{"loooooooooooooooooooooooooooooooooooooooog", "loooooooooooooooooooooooooooooooooooooooog"},
+		{`{"t": "\/testlooooooooooooooooooooooooooooong"}`, `{"t": "\/testlooooooooooooooooooooooooooooong"}`},
+		{`{"t": "\/test"}`, `{"t": "\/test"}`},
+		{`"\// fake comment"`, `"\// fake comment"`},
+		{`"\/\/\/\/\/"`, `"\/\/\/\/\/"`},
+	}
+
+	for _, testCase := range data {
+		reader := &Reader{
+			Reader: bytes.NewReader([]byte(testCase.input)),
+		}
+		target := make([]byte, 0)
+		buf := make([]byte, bufLen)
+		var n int
+		var err error
+		for n, err = reader.Read(buf); err == nil; n, err = reader.Read(buf) {
+			if n > len(buf) {
+				t.Error("n: ", n)
+			}
+			target = append(target, buf[:n]...)
+			buf = make([]byte, bufLen)
+		}
+		if err != nil && err != io.EOF {
+			t.Error("error: ", err)
+		}
+		if string(target) != testCase.output {
+			t.Error("got ", string(target), " want ", testCase.output)
+		}
+	}
+}