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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
package packfile
import (
"errors"
"fmt"
"lindenii.org/go/furgit/object/id"
)
// ErrMalformedEntryHeader reports that
// a packfile entry header is truncated, overlong,
// has an unsupported entry type,
// or declares a size that overflows uint64.
var ErrMalformedEntryHeader = errors.New("internal/format/packfile: malformed entry header")
// MaxTypeSizeLen is the maximum encoded length
// of the type/size prefix of an entry header.
// Every uint64 size is encodable within this bound,
// and [ParseEntryHeader] rejects longer prefixes.
const MaxTypeSizeLen = 10
// MaxEntryHeaderLen returns the maximum encoded length
// of a full entry header
// for packs whose object IDs are hashSize bytes.
//
// Callers parsing from a stream may buffer
// MaxEntryHeaderLen bytes
// (or fewer if the pack data ends sooner)
// and parse with [ParseEntryHeader];
// no valid entry header is longer.
func MaxEntryHeaderLen(hashSize int) int {
return MaxTypeSizeLen + max(hashSize, MaxOfsDeltaDistanceLen)
}
// EntryHeader is one parsed packfile entry header:
// everything from the start of the entry
// up to its zlib payload.
type EntryHeader struct {
// Type is the packfile entry type.
Type EntryType
// Size is the declared inflated size
// of the entry's payload.
// For delta entries this is the delta size,
// not the reconstructed object size.
Size uint64
// HeaderLen is the number of bytes
// the header occupies in the pack;
// the zlib payload begins HeaderLen bytes
// after the start of the entry.
HeaderLen int
// RefBase holds the base object ID
// for ref-delta entries.
// Only the first hashSize bytes are meaningful.
RefBase [id.MaxObjectIDSize]byte
// OfsDistance is the backward distance
// from the start of this entry
// to the start of the base entry,
// for ofs-delta entries.
OfsDistance uint64
}
// ParseEntryHeader parses one packfile entry header
// from the beginning of data.
//
// hashSize must be the object ID size
// of the pack's object format;
// ParseEntryHeader panics on implausible hash sizes.
//
// data need not contain the whole entry;
// [MaxEntryHeaderLen] bytes always suffice.
// Headers of types [EntryTypeInvalid] and [EntryTypeFuture]
// are rejected as malformed.
func ParseEntryHeader(data []byte, hashSize int) (EntryHeader, error) {
var zero EntryHeader
if hashSize <= 0 || hashSize > id.MaxObjectIDSize {
panic("internal/format/packfile: invalid hash size")
}
if len(data) == 0 {
return zero, fmt.Errorf("%w: truncated type/size prefix", ErrMalformedEntryHeader)
}
first := data[0]
header := EntryHeader{
Type: EntryType((first >> 4) & 0x07),
Size: uint64(first & 0x0f),
HeaderLen: 1,
}
shift := uint(4)
b := first
for b&0x80 != 0 {
if header.HeaderLen >= MaxTypeSizeLen {
return zero, fmt.Errorf("%w: overlong type/size prefix", ErrMalformedEntryHeader)
}
if header.HeaderLen >= len(data) {
return zero, fmt.Errorf("%w: truncated type/size prefix", ErrMalformedEntryHeader)
}
b = data[header.HeaderLen]
header.HeaderLen++
group := uint64(b & 0x7f)
if group<<shift>>shift != group {
return zero, fmt.Errorf("%w: size overflows uint64", ErrMalformedEntryHeader)
}
header.Size |= group << shift
shift += 7
}
switch header.Type {
case EntryTypeCommit, EntryTypeTree, EntryTypeBlob, EntryTypeTag:
// Base entries have nothing between the type/size prefix and the payload.
case EntryTypeRefDelta:
end := header.HeaderLen + hashSize
if end > len(data) {
return zero, fmt.Errorf("%w: truncated ref-delta base ID", ErrMalformedEntryHeader)
}
copy(header.RefBase[:], data[header.HeaderLen:end])
header.HeaderLen = end
case EntryTypeOfsDelta:
dist, consumed, err := ParseOfsDeltaDistance(data[header.HeaderLen:])
if err != nil {
return zero, fmt.Errorf("%w: %w", ErrMalformedEntryHeader, err)
}
header.OfsDistance = dist
header.HeaderLen += consumed
case EntryTypeInvalid, EntryTypeFuture:
return zero, fmt.Errorf("%w: unsupported entry type", ErrMalformedEntryHeader)
default:
return zero, fmt.Errorf("%w: unsupported entry type", ErrMalformedEntryHeader)
}
return header, nil
}
// AppendTypeSize appends the type/size prefix encoding
// of an entry header to dst.
//
// entryType must be a valid on-disk entry type;
// [EntryTypeInvalid] and [EntryTypeFuture] and
// values that do not fit in three bits
// produce garbage encodings.
func AppendTypeSize(dst []byte, entryType EntryType, size uint64) []byte {
b := byte(entryType)<<4 | byte(size&0x0f)
size >>= 4
for size != 0 {
dst = append(dst, b|0x80)
b = byte(size & 0x7f)
size >>= 7
}
return append(dst, b)
}
|
