Merge branch 'lukeshu/json'

10 files changed, 297 insertions, 77 deletions

diff --git a/cmd/btrfs-rec/inspect/rebuildmappings/scan.go b/cmd/btrfs-rec/inspect/rebuildmappings/scan.go
index d96005e..9454ca0 100644
--- a/cmd/btrfs-rec/inspect/rebuildmappings/scan.go
+++ b/cmd/btrfs-rec/inspect/rebuildmappings/scan.go
@@ -19,6 +19,7 @@ import (
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsvol"
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfsutil"
 	"git.lukeshu.com/btrfs-progs-ng/lib/containers"
+	"git.lukeshu.com/btrfs-progs-ng/lib/jsonutil"
 	"git.lukeshu.com/btrfs-progs-ng/lib/textui"
 )
 
@@ -27,6 +28,8 @@ import (
 type ScanDevicesResult = map[btrfsvol.DeviceID]ScanOneDeviceResult
 
 type ScanOneDeviceResult struct {
+	Size             btrfsvol.PhysicalAddr
+	Superblock       jsonutil.Binary[btrfstree.Superblock]
 	Checksums        btrfssum.SumRun[btrfsvol.PhysicalAddr]
 	FoundNodes       map[btrfsvol.LogicalAddr][]btrfsvol.PhysicalAddr
 	FoundChunks      []FoundChunk
@@ -72,7 +75,6 @@ func ScanOneDevice(ctx context.Context, dev *btrfs.Device) (ScanOneDeviceResult,
 // scanner implementation //////////////////////////////////////////////////////
 
 type deviceScanner struct {
-	alg    btrfssum.CSumType
 	sums   strings.Builder
 	result ScanOneDeviceResult
 }
@@ -104,17 +106,18 @@ func (scanner *deviceScanner) ScanStats() scanStats {
 	}
 }
 
-func newDeviceScanner(_ context.Context, sb btrfstree.Superblock, _ btrfsvol.PhysicalAddr, numSectors int) btrfsutil.DeviceScanner[scanStats, ScanOneDeviceResult] {
+func newDeviceScanner(_ context.Context, sb btrfstree.Superblock, numBytes btrfsvol.PhysicalAddr, numSectors int) btrfsutil.DeviceScanner[scanStats, ScanOneDeviceResult] {
 	scanner := new(deviceScanner)
-	scanner.alg = sb.ChecksumType
+	scanner.result.Size = numBytes
+	scanner.result.Superblock.Val = sb
 	scanner.result.FoundNodes = make(map[btrfsvol.LogicalAddr][]btrfsvol.PhysicalAddr)
-	scanner.result.Checksums.ChecksumSize = scanner.alg.Size()
+	scanner.result.Checksums.ChecksumSize = scanner.result.Superblock.Val.ChecksumType.Size()
 	scanner.sums.Grow(scanner.result.Checksums.ChecksumSize * numSectors)
 	return scanner
 }
 
 func (scanner *deviceScanner) ScanSector(_ context.Context, dev *btrfs.Device, paddr btrfsvol.PhysicalAddr) error {
-	sum, err := btrfs.ChecksumPhysical(dev, scanner.alg, paddr)
+	sum, err := btrfs.ChecksumPhysical(dev, scanner.result.Superblock.Val.ChecksumType, paddr)
 	if err != nil {
 		return err
 	}
diff --git a/lib/btrfs/btrfssum/shortsum.go b/lib/btrfs/btrfssum/shortsum.go
index 754a79d..a3a6d11 100644
--- a/lib/btrfs/btrfssum/shortsum.go
+++ b/lib/btrfs/btrfssum/shortsum.go
@@ -5,12 +5,13 @@
 package btrfssum
 
 import (
-	"fmt"
 	"io"
-	"math"
 	"strings"
 
 	"git.lukeshu.com/go/lowmemjson"
+
+	"git.lukeshu.com/btrfs-progs-ng/lib/jsonutil"
+	"git.lukeshu.com/btrfs-progs-ng/lib/textui"
 )
 
 type ShortSum string
@@ -27,72 +28,13 @@ func (sum ShortSum) ToFullSum() CSum {
 }
 
 func (sum ShortSum) EncodeJSON(w io.Writer) error {
-	const hextable = "0123456789abcdef"
-	var buf [2]byte
-	buf[0] = '"'
-	if _, err := w.Write(buf[:1]); err != nil {
-		return err
-	}
-	for i := 0; i < len(sum); i++ {
-		buf[0] = hextable[sum[i]>>4]
-		buf[1] = hextable[sum[i]&0x0f]
-		if _, err := w.Write(buf[:]); err != nil {
-			return err
-		}
-	}
-	buf[0] = '"'
-	if _, err := w.Write(buf[:1]); err != nil {
-		return err
-	}
-	return nil
-}
-
-func deHex(r rune) (byte, bool) {
-	if r > math.MaxUint8 {
-		return 0, false
-	}
-	c := byte(r)
-	//nolint:gomnd // Hex conversion.
-	switch {
-	case '0' <= c && c <= '9':
-		return c - '0', true
-	case 'a' <= c && c <= 'f':
-		return c - 'a' + 10, true
-	case 'A' <= c && c <= 'F':
-		return c - 'A' + 10, true
-	default:
-		return 0, false
-	}
+	return jsonutil.EncodeSplitHexString(w, sum, textui.Tunable(80))
 }
 
 func (sum *ShortSum) DecodeJSON(r io.RuneScanner) error {
 	var out strings.Builder
-	if c, _, err := r.ReadRune(); err != nil {
+	if err := jsonutil.DecodeSplitHexString(r, &out); err != nil {
 		return err
-	} else if c != '"' {
-		return fmt.Errorf("expected %q, got %q", '"', c)
-	}
-	for {
-		a, _, err := r.ReadRune()
-		if err != nil {
-			return err
-		}
-		if a == '"' {
-			break
-		}
-		aN, ok := deHex(a)
-		if !ok {
-			return fmt.Errorf("expected a hex digit, got %q", a)
-		}
-		b, _, err := r.ReadRune()
-		if err != nil {
-			return err
-		}
-		bN, ok := deHex(b)
-		if !ok {
-			return fmt.Errorf("expected a hex digit, got %q", b)
-		}
-		out.WriteByte(aN<<4 | bN)
 	}
 	*sum = ShortSum(out.String())
 	return nil
diff --git a/lib/btrfs/btrfssum/shortsum_test.go b/lib/btrfs/btrfssum/shortsum_test.go
new file mode 100644
index 0000000..aa7849a
--- /dev/null
+++ b/lib/btrfs/btrfssum/shortsum_test.go
@@ -0,0 +1,66 @@
+// Copyright (C) 2023  Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package btrfssum_test
+
+import (
+	"bytes"
+	"testing"
+
+	"git.lukeshu.com/go/lowmemjson"
+	"github.com/stretchr/testify/assert"
+
+	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfssum"
+)
+
+func TestShortSumEncodeJSON(t *testing.T) {
+	t.Parallel()
+	type TestCase struct {
+		InputSum   btrfssum.ShortSum
+		OutputJSON string
+	}
+	testcases := map[string]TestCase{
+		"short": {
+			InputSum:   "xyz",
+			OutputJSON: `"78797a"`,
+		},
+		"long": {
+			InputSum:   "0123456789abcdefghijklmnopqrstuvwxyz;:.,ABCDEFG",
+			OutputJSON: `["303132333435363738396162636465666768696a6b6c6d6e6f707172737475767778797a3b3a2e2c","41424344454647"]`,
+		},
+		"medium": { // exactly the maximum string length
+			InputSum:   "0123456789abcdefghijklmnopqrstuvwxyz;:.,",
+			OutputJSON: `"303132333435363738396162636465666768696a6b6c6d6e6f707172737475767778797a3b3a2e2c"`,
+		},
+	}
+	for tcName, tc := range testcases {
+		tc := tc
+		t.Run(tcName, func(t *testing.T) {
+			t.Parallel()
+
+			var jsonBuf bytes.Buffer
+			assert.NoError(t, lowmemjson.NewEncoder(&jsonBuf).Encode(tc.InputSum))
+			assert.Equal(t, tc.OutputJSON, jsonBuf.String())
+
+			var rtSum btrfssum.ShortSum
+			assert.NoError(t, lowmemjson.NewDecoder(&jsonBuf).DecodeThenEOF(&rtSum))
+			assert.Equal(t, tc.InputSum, rtSum)
+		})
+	}
+}
+
+func FuzzShortSumJSONFuzz(f *testing.F) {
+	f.Fuzz(func(t *testing.T, _inSum []byte) {
+		t.Logf("in = %q", _inSum)
+		inSum := btrfssum.ShortSum(_inSum)
+
+		var jsonBuf bytes.Buffer
+		assert.NoError(t, lowmemjson.NewEncoder(&jsonBuf).Encode(inSum))
+		t.Logf("json = %q", jsonBuf.Bytes())
+
+		var outSum btrfssum.ShortSum
+		assert.NoError(t, lowmemjson.NewDecoder(&jsonBuf).DecodeThenEOF(&outSum))
+		assert.Equal(t, inSum, outSum)
+	})
+}
diff --git a/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/162fbf5f010234baa3e0f8c91825ebb8bce17b9ad8365ae1cad6977b4114d1ec b/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/162fbf5f010234baa3e0f8c91825ebb8bce17b9ad8365ae1cad6977b4114d1ec
new file mode 100644
index 0000000..338adec
--- /dev/null
+++ b/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/162fbf5f010234baa3e0f8c91825ebb8bce17b9ad8365ae1cad6977b4114d1ec
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("00000000000000000000000000000000000000000")
diff --git a/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/b15b16f1ef330f9113455291780be2915cecf2bd1b7dbe2e3af0505f042751e8 b/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/b15b16f1ef330f9113455291780be2915cecf2bd1b7dbe2e3af0505f042751e8
new file mode 100644
index 0000000..c9fd0e4
--- /dev/null
+++ b/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/b15b16f1ef330f9113455291780be2915cecf2bd1b7dbe2e3af0505f042751e8
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("Z")
diff --git a/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/fecd8dd05aeedabe b/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/fecd8dd05aeedabe
new file mode 100644
index 0000000..66b87de
--- /dev/null
+++ b/lib/btrfs/btrfssum/testdata/fuzz/FuzzShortSumJSONFuzz/fecd8dd05aeedabe
@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("\xb8")
diff --git a/lib/containers/optional.go b/lib/containers/optional.go
index 26ec494..f29665e 100644
--- a/lib/containers/optional.go
+++ b/lib/containers/optional.go
@@ -5,7 +5,9 @@
 package containers
 
 import (
-	"encoding/json"
+	"io"
+
+	"git.lukeshu.com/go/lowmemjson"
 )
 
 type Optional[T any] struct {
@@ -27,22 +29,28 @@ func OptionalNil[T any]() Optional[T] {
 }
 
 var (
-	_ json.Marshaler   = Optional[bool]{}
-	_ json.Unmarshaler = (*Optional[bool])(nil)
+	_ lowmemjson.Encodable = Optional[bool]{}
+	_ lowmemjson.Decodable = (*Optional[bool])(nil)
 )
 
-func (o Optional[T]) MarshalJSON() ([]byte, error) {
+func (o Optional[T]) EncodeJSON(w io.Writer) error {
 	if !o.OK {
-		return []byte("null"), nil
+		_, err := io.WriteString(w, "null")
+		return err
 	}
-	return json.Marshal(o.Val)
+	return lowmemjson.NewEncoder(w).Encode(o.Val)
 }
 
-func (o *Optional[T]) UnmarshalJSON(dat []byte) error {
-	if string(dat) == "null" {
+func (o *Optional[T]) DecodeJSON(r io.RuneScanner) error {
+	c, _, _ := r.ReadRune()
+	if c == 'n' {
+		_, _, _ = r.ReadRune() // u
+		_, _, _ = r.ReadRune() // l
+		_, _, _ = r.ReadRune() // l
 		*o = Optional[T]{}
 		return nil
 	}
+	_ = r.UnreadRune()
 	o.OK = true
-	return json.Unmarshal(dat, &o.Val)
+	return lowmemjson.NewDecoder(r).Decode(&o.Val)
 }
diff --git a/lib/jsonutil/binstruct.go b/lib/jsonutil/binstruct.go
new file mode 100644
index 0000000..7f4bd3f
--- /dev/null
+++ b/lib/jsonutil/binstruct.go
@@ -0,0 +1,48 @@
+// Copyright (C) 2023  Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jsonutil
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"git.lukeshu.com/go/lowmemjson"
+
+	"git.lukeshu.com/btrfs-progs-ng/lib/binstruct"
+	"git.lukeshu.com/btrfs-progs-ng/lib/textui"
+)
+
+type Binary[T any] struct {
+	Val T
+}
+
+var (
+	_ lowmemjson.Encodable = Binary[int]{}
+	_ lowmemjson.Decodable = (*Binary[int])(nil)
+)
+
+func (o Binary[T]) EncodeJSON(w io.Writer) error {
+	bs, err := binstruct.Marshal(o.Val)
+	if err != nil {
+		return err
+	}
+	return EncodeSplitHexString(w, bs, textui.Tunable(80))
+}
+
+func (o *Binary[T]) DecodeJSON(r io.RuneScanner) error {
+	var buf bytes.Buffer
+	if err := DecodeSplitHexString(r, &buf); err != nil {
+		return err
+	}
+	n, err := binstruct.Unmarshal(buf.Bytes(), &o.Val)
+	if err != nil {
+		return err
+	}
+	if n < buf.Len() {
+		return fmt.Errorf("%d bytes of garbage after value", n-buf.Len())
+	}
+	return nil
+}
diff --git a/lib/jsonutil/hex_decoder.go b/lib/jsonutil/hex_decoder.go
new file mode 100644
index 0000000..e5c84a7
--- /dev/null
+++ b/lib/jsonutil/hex_decoder.go
@@ -0,0 +1,61 @@
+// Copyright (C) 2023  Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+package jsonutil
+
+import (
+	"fmt"
+	"io"
+	"math"
+)
+
+type invalidHexRuneError rune
+
+func (e invalidHexRuneError) Error() string {
+	return fmt.Sprintf("jsonutil: invalid hex digit: %q", rune(e))
+}
+
+// hexDecoder is like an encoding/hex.Decoder, but has a "push"
+// interface rather than a "pull" interface.
+type hexDecoder struct {
+	dst io.ByteWriter
+
+	buf   byte
+	bufOK bool
+}
+
+func (d *hexDecoder) WriteRune(r rune) (int, error) {
+	if r > math.MaxUint8 {
+		return 0, invalidHexRuneError(r)
+	}
+
+	c := byte(r)
+	var v byte
+	//nolint:gomnd // Hex conversion.
+	switch {
+	case '0' <= c && c <= '9':
+		v = c - '0'
+	case 'a' <= c && c <= 'f':
+		v = c - 'a' + 10
+	case 'A' <= c && c <= 'F':
+		v = c - 'A' + 10
+	default:
+		return 0, invalidHexRuneError(r)
+	}
+
+	if !d.bufOK {
+		d.buf = v
+		d.bufOK = true
+		return 1, nil
+	}
+	d.bufOK = false
+	return 1, d.dst.WriteByte(d.buf<<4 | v)
+}
+
+func (d *hexDecoder) Close() error {
+	if d.bufOK {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
diff --git a/lib/jsonutil/hex_string.go b/lib/jsonutil/hex_string.go
new file mode 100644
index 0000000..3e0b154
--- /dev/null
+++ b/lib/jsonutil/hex_string.go
@@ -0,0 +1,86 @@
+// Copyright (C) 2023  Luke Shumaker <lukeshu@lukeshu.com>
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// Package jsonutil provides utilities for implementing the interfaces
+// consumed by the "git.lukeshu.com/go/lowmemjson" package.
+package jsonutil
+
+import (
+	"io"
+
+	"git.lukeshu.com/go/lowmemjson"
+)
+
+func EncodeHexString[T ~[]byte | ~string](w io.Writer, str T) error {
+	const hextable = "0123456789abcdef"
+	var buf [2]byte
+	buf[0] = '"'
+	if _, err := w.Write(buf[:1]); err != nil {
+		return err
+	}
+	for i := 0; i < len(str); i++ {
+		buf[0] = hextable[str[i]>>4]
+		buf[1] = hextable[str[i]&0x0f]
+		if _, err := w.Write(buf[:]); err != nil {
+			return err
+		}
+	}
+	buf[0] = '"'
+	if _, err := w.Write(buf[:1]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func DecodeHexString(r io.RuneScanner, dst io.ByteWriter) error {
+	dec := &hexDecoder{dst: dst}
+	if err := lowmemjson.DecodeString(r, dec); err != nil {
+		return err
+	}
+	return dec.Close()
+}
+
+func EncodeSplitHexString[T ~[]byte | ~string](w io.Writer, str T, maxStrLen int) error {
+	if maxStrLen <= 0 || len(str) <= maxStrLen/2 {
+		return EncodeHexString(w, str)
+	}
+	var buf [1]byte
+	buf[0] = '['
+	if _, err := w.Write(buf[:]); err != nil {
+		return err
+	}
+	for len(str) > maxStrLen/2 {
+		if err := EncodeHexString(w, str[:maxStrLen/2]); err != nil {
+			return err
+		}
+		str = str[maxStrLen/2:]
+		if len(str) > 0 {
+			buf[0] = ','
+			if _, err := w.Write(buf[:]); err != nil {
+				return err
+			}
+		}
+	}
+	if len(str) > 0 {
+		if err := EncodeHexString(w, str); err != nil {
+			return err
+		}
+	}
+	buf[0] = ']'
+	if _, err := w.Write(buf[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func DecodeSplitHexString(r io.RuneScanner, dst io.ByteWriter) error {
+	c, _, _ := r.ReadRune()
+	_ = r.UnreadRune()
+	if c == '"' {
+		return DecodeHexString(r, dst)
+	}
+	return lowmemjson.DecodeArray(r, func(r io.RuneScanner) error {
+		return DecodeHexString(r, dst)
+	})
+}