1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
|
package hashers
import (
"errors"
"fmt"
"hash"
"io"
)
var _ io.Reader = &Hasher{}
// Hasher wraps io.Reader.
// You can ask it for the digest of the hash function used internally, and the
// number of bytes written.
type Hasher struct {
r io.Reader
h hash.Hash
bytesRead uint32
}
func NewHasher(r io.Reader, h hash.Hash) *Hasher {
return &Hasher{
r: r,
h: h,
bytesRead: 0,
}
}
func (h *Hasher) Read(p []byte) (int, error) {
nRead, rdErr := h.r.Read(p)
// write the number of bytes read from the reader to the hash.
// We need to do this independently on whether there's been error.
// n always describes the number of successfully written bytes.
nHash, hashErr := h.h.Write(p[0:nRead])
if hashErr != nil {
return nRead, fmt.Errorf("unable to write to hash: %w", hashErr)
}
// We assume here the hash function accepts the whole p in one Go,
// and doesn't early-return on the Write.
// We compare it with nRead and bail out if that was not the case.
if nHash != nRead {
return nRead, fmt.Errorf("hash didn't accept the full write")
}
// update bytesWritten
h.bytesRead += uint32(nRead)
if rdErr != nil {
if errors.Is(rdErr, io.EOF) {
return nRead, rdErr
}
return nRead, fmt.Errorf("error from underlying reader: %w", rdErr)
}
return nRead, hashErr
}
func (h *Hasher) BytesWritten() uint32 {
return h.bytesRead
}
func (h *Hasher) Sum(b []byte) []byte {
return h.h.Sum(b)
}
|
