sanitize remote message

Author: fcharlie

modules/term/fmt_test.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"testing"
+	"unicode"
 )
 
 func TestStripAnsi(t *testing.T) {
@@ -15,3 +16,36 @@ func TestStripAnsi(t *testing.T) {
 func TestCygwinTerminal(t *testing.T) {
 	fmt.Fprintf(os.Stderr, "IsCygwinTerminal: %v\n", IsCygwinTerminal(os.Stderr.Fd()))
 }
+
+func TestSanitized(t *testing.T) {
+	ss := []string{
+		"error: Have you \033[31mread\033[m this?\a\n",
+		fmt.Sprintf("\x1b[38;2;254;225;64m* %s jack\x1b[0m", os.Args[0]),
+	}
+	for i, s := range ss {
+		s1 := SanitizeANSI(s, true)
+		s2 := SanitizeANSI(s, false)
+		fmt.Fprintf(os.Stderr, "round %d\n%s\x1b[0m\n%s\x1b[0m\n", i, s1, s2)
+	}
+}
+
+func TestTable(t *testing.T) {
+	table := make([]int, 0, 256)
+	for i := 0; i < 256; i++ {
+		if unicode.IsControl(rune(i)) {
+			table = append(table, CHAR_CONTROL)
+			continue
+		}
+		if unicode.IsDigit(rune(i)) || i == ';' || i == ':' {
+			table = append(table, CHAR_COLOR_SEQUENCE)
+			continue
+		}
+		table = append(table, CHAR_UNSPECIFIED)
+	}
+	for i, b := range table {
+		if i%16 == 0 && i != 0 {
+			fmt.Fprintf(os.Stderr, "\n")
+		}
+		fmt.Fprintf(os.Stderr, "%d,", b)
+	}
+}

modules/term/sanitized.go

@@ -0,0 +1,85 @@
+package term
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+const (
+	CHAR_UNSPECIFIED    = 0
+	CHAR_COLOR_SEQUENCE = 1
+	CHAR_CONTROL        = 2
+)
+
+var (
+	charIndex = []byte{
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+		2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	}
+)
+
+// https://github.com/gitgitgadget/git/pull/1853
+// https://public-inbox.org/git/Z4bqMYKRP7Gva5St@tapette.crustytoothpaste.net/T/#t
+func handleAnsiColorSequence(b *strings.Builder, text []byte, allowColor bool) int {
+	/*
+	 * Valid ANSI color sequences are of the form
+	 *
+	 * ESC [ [<n> [; <n>]*] m
+	 */
+	if len(text) < 3 || text[0] != '\x1b' || text[1] != '[' {
+		return 0
+	}
+	for i := 2; i < len(text); i++ {
+		c := text[i]
+		if c == 'm' {
+			if allowColor {
+				_, _ = b.Write(text[:i+1])
+			}
+			return i
+		}
+		if charIndex[c] != CHAR_COLOR_SEQUENCE {
+			break
+		}
+	}
+	return 0
+}
+
+func SanitizeANSI(content string, allowColor bool) string {
+	b := &strings.Builder{}
+	text := []byte(content)
+	b.Grow(len(text))
+	for i := 0; i < len(text); i++ {
+		c := text[i]
+		if charIndex[c] != CHAR_CONTROL || c == '\t' || c == '\n' {
+			_ = b.WriteByte(c)
+			continue
+		}
+		if j := handleAnsiColorSequence(b, text[i:], allowColor); j != 0 {
+			i += j
+			continue
+		}
+		_ = b.WriteByte('^')
+		_ = b.WriteByte(c + 0x40)
+	}
+	return b.String()
+}
+
+func SanitizedF(format string, a ...any) (int, error) {
+	content := fmt.Sprintf(format, a...)
+	return os.Stderr.WriteString(SanitizeANSI(content, StderrLevel != LevelNone))
+}

pkg/transport/http/base.go

@@ -216,14 +216,14 @@ func parseError(resp *http.Response) error {
 		if err := json.NewDecoder(resp.Body).Decode(ec); err != nil {
 			return fmt.Errorf("decode json error: %w", err)
 		}
-		ec.Message = strings.TrimRightFunc(ec.Message, unicode.IsSpace)
+		ec.Message = term.SanitizeANSI(strings.TrimRightFunc(ec.Message, unicode.IsSpace), true)
 		return ec
 	}
 	b, err := streamio.ReadMax(resp.Body, 1024)
 	if err != nil {
 		return &ErrorCode{status: resp.StatusCode, Message: fmt.Sprintf("%d %s\nError: %v", resp.StatusCode, resp.Status, err)}
 	}
-	body := strings.TrimRightFunc(string(b), unicode.IsSpace)
+	body := term.SanitizeANSI(strings.TrimRightFunc(string(b), unicode.IsSpace), true)
 	return &ErrorCode{status: resp.StatusCode, Message: fmt.Sprintf("%s\n%s", resp.Status, body)}
 }
 

pkg/zeta/odb/pack.go

@@ -14,6 +14,7 @@ import (
 	"github.com/antgroup/hugescm/modules/crc"
 	"github.com/antgroup/hugescm/modules/plumbing"
 	"github.com/antgroup/hugescm/modules/plumbing/format/pktline"
+	"github.com/antgroup/hugescm/modules/term"
 	"github.com/antgroup/hugescm/modules/zeta/backend"
 	"github.com/antgroup/hugescm/pkg/progress"
 )
@@ -136,6 +137,14 @@ type Report struct {
 	Reason        string
 }
 
+func sanitizeLine(s string) string {
+	p := strings.IndexByte(s, '\n')
+	if p != -1 {
+		s = s[:p]
+	}
+	return term.SanitizeANSI(strings.TrimSpace(s), term.StderrLevel != term.LevelNone)
+}
+
 func (d *ODB) OnReport(ctx context.Context, refname plumbing.ReferenceName, reader io.Reader) (result *Report, err error) {
 	var b strings.Builder
 	r := pktline.NewScanner(io.TeeReader(reader, &b))
@@ -149,12 +158,12 @@ func (d *ODB) OnReport(ctx context.Context, refname plumbing.ReferenceName, read
 		line := string(r.Bytes())
 		pos := strings.IndexByte(line, ' ')
 		if pos == -1 {
-			return nil, fmt.Errorf("bad report line: %s", line)
+			return nil, fmt.Errorf("bad report line: %s", sanitizeLine(line))
 		}
 		lab := line[0:pos]
 		substr := line[pos+1:]
 		if lab == "rate" {
-			fmt.Fprintf(os.Stderr, "\x1b[2K\rremote: %s", strings.TrimSpace(substr))
+			fmt.Fprintf(os.Stderr, "\x1b[2K\rremote: %s", sanitizeLine(substr))
 			newLine = true
 			continue
 		}
@@ -165,7 +174,7 @@ func (d *ODB) OnReport(ctx context.Context, refname plumbing.ReferenceName, read
 		}
 		if lab == "unpack" {
 			if substr != "ok" {
-				fmt.Fprintf(os.Stderr, "remote: unpack %s\n", substr)
+				term.SanitizedF("remote: unpack %s\n", substr)
 				result = &Report{ReferenceName: refname, Reason: substr, Rejected: true}
 				break
 			}
@@ -190,7 +199,7 @@ func (d *ODB) OnReport(ctx context.Context, refname plumbing.ReferenceName, read
 			break
 		}
 		if lab == "status" {
-			fmt.Fprintf(os.Stderr, "remote: %s\n", line[pos+1:])
+			term.SanitizedF("remote: %s\n", line[pos+1:])
 			continue
 		}
 	}

pkg/zeta/push.go

@@ -168,9 +168,9 @@ func (r *Repository) doPushRemove(ctx context.Context, target plumbing.Reference
 	if result.Rejected {
 		sv := strengthen.StrSplitSkipEmpty(result.Reason, 2, '\n')
 		for _, s := range sv {
-			fmt.Fprintf(os.Stderr, "remote: %s\n", s)
+			term.Fprintf(os.Stderr, "remote: %s\n", s)
 		}
-		fmt.Fprintf(os.Stderr, "To: %s\n \x1b[31m! [remote rejected]\x1b[0m %s (delete)\n", cleanedRemote, target.Short())
+		term.Fprintf(os.Stderr, "To: %s\n \x1b[31m! [remote rejected]\x1b[0m %s (delete)\n", cleanedRemote, target.Short())
 		error_red("failed to push some refs to '%s'", cleanedRemote)
 		return errors.New(result.Reason)
 	}