-
Notifications
You must be signed in to change notification settings - Fork 52
/
patcher.go
113 lines (98 loc) · 2.44 KB
/
patcher.go
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
package patch
import (
"bytes"
"io"
"github.com/gabstv/go-bsdiff/pkg/bsdiff"
"github.com/gabstv/go-bsdiff/pkg/bspatch"
"github.com/klauspost/compress/zstd"
)
const (
UpdateStrategy = "binary"
)
type BinaryPatcher interface {
GeneratePatch(old io.Reader, new io.Reader, patchOut io.Writer) error
ApplyPatch(old io.Reader, patch io.Reader, newOut io.Writer) error
CheckFormat(reader io.ReaderAt) bool
}
type BsdiffPatcher struct{}
func (BsdiffPatcher) GeneratePatch(old io.Reader, new io.Reader, patchOut io.Writer) (err error) {
return bsdiff.Reader(old, new, patchOut)
}
func (BsdiffPatcher) ApplyPatch(old io.Reader, patch io.Reader, newOut io.Writer) (err error) {
return bspatch.Reader(old, newOut, patch)
}
func (BsdiffPatcher) CheckFormat(reader io.ReaderAt) bool {
header := []byte("BSDIFF40")
buf := make([]byte, len(header))
if _, err := reader.ReadAt(buf, 0); err == nil {
return bytes.Equal(buf, header)
}
return false
}
var allPatchEngines = []BinaryPatcher{
BsdiffPatcher{},
ZstdPatcher{},
}
func NewPatcherFromFormat(reader io.ReaderAt) (BinaryPatcher, bool) {
for _, p := range allPatchEngines {
if p.CheckFormat(reader) {
return p, true
}
}
return nil, false
}
type ZstdPatcher struct{}
func (ZstdPatcher) GeneratePatch(old io.Reader, new io.Reader, patchOut io.Writer) (err error) {
dict, err := io.ReadAll(old)
if err != nil {
return err
}
enc, err := zstd.NewWriter(nil,
zstd.WithEncoderDictRaw(0, dict),
zstd.WithWindowSize(zstd.MaxWindowSize),
zstd.WithEncoderLevel(zstd.SpeedBestCompression),
)
defer enc.Close()
if err != nil {
return err
}
newBytes, err := io.ReadAll(new)
if err != nil {
return err
}
patch := enc.EncodeAll(newBytes, nil)
patchOut.Write(patch)
return nil
}
func (ZstdPatcher) ApplyPatch(old io.Reader, patch io.Reader, newOut io.Writer) (err error) {
dict, err := io.ReadAll(old)
if err != nil {
return err
}
patchBytes, err := io.ReadAll(patch)
if err != nil {
return err
}
dec, err := zstd.NewReader(nil,
zstd.WithDecoderDictRaw(0, dict),
zstd.WithDecoderLowmem(true),
)
if err != nil {
return err
}
defer dec.Close()
out, err := dec.DecodeAll(patchBytes, nil)
if err != nil {
return err
}
newOut.Write(out)
return nil
}
func (ZstdPatcher) CheckFormat(reader io.ReaderAt) bool {
header := "\x28\xb5\x2f\xfd"
buf := make([]byte, len(header))
if _, err := reader.ReadAt(buf, 0); err == nil {
return bytes.Equal(buf, []byte(header))
}
return false
}