diff options
Diffstat (limited to 'lib')
9 files changed, 289 insertions, 72 deletions
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) + }) +} |