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
166
167
168
169
170
|
// Package librsync allows you to create binary deltas.
package librsync
/*
#cgo LDFLAGS: -lrsync
#include <stdio.h>
#include <librsync.h>
#include <stdlib.h>
rs_buffers_t* new_rs_buffers() {
return (rs_buffers_t*) malloc(sizeof(rs_buffers_t));
}
*/
import "C"
import (
"errors"
"fmt"
"io"
"unsafe"
)
const (
inbufSize = 16 * 1024
outbufSize = 16 * 1024
)
var (
ErrInputEnded = errors.New("Input ended (possibly unexpected)")
ErrBadMagic = errors.New("Bad magic number. Probably not an librsync file.")
ErrCorrupt = errors.New("Input stream corrupted")
ErrInternal = errors.New("Internal error (library bug?)")
)
// SignatureGen holds information to generate a librsync file signature.
// It must be constructed with the NewSignatureGen or NewDefaultSignatureGen functions.
type SignatureGen struct {
rsbufs *C.rs_buffers_t
job *C.rs_job_t
running bool
err error
inbuf []byte
in io.Reader
outbufTotal []byte
outbuf []byte
blocklen, stronglen uint
}
// NewDefaultSignatureGen is like NewSignatureGen, but uses default values for blocklen and stronglen.
func NewDefaultSignatureGen(input io.Reader) (siggen *SignatureGen, err error) {
siggen, err = NewSignatureGen(C.RS_DEFAULT_BLOCK_LEN, C.RS_DEFAULT_STRONG_LEN, input)
return
}
// NewSignatureGen creates a new SignatureGen instance.
//
// blocklen is the length of a block.
// stronglen is the length of the stong hash.
// input is an io.Reader that provides the input data.
func NewSignatureGen(blocklen, stronglen uint, input io.Reader) (siggen *SignatureGen, err error) {
siggen = new(SignatureGen)
siggen.blocklen, siggen.stronglen = blocklen, stronglen
siggen.in = input
siggen.inbuf = make([]byte, inbufSize)
siggen.outbufTotal = make([]byte, outbufSize)
siggen.rsbufs = C.new_rs_buffers()
if siggen.rsbufs == nil {
return nil, fmt.Errorf("Could not allocate memory for rs_buffers_t object")
}
siggen.job = C.rs_sig_begin(C.size_t(blocklen), C.size_t(stronglen))
if siggen.job == nil {
siggen.Close()
return nil, fmt.Errorf("rs_sig_begin failed")
}
siggen.running = true
return
}
// Close will free memory that Go's garbage collector would not be able to free.
func (siggen *SignatureGen) Close() error {
C.free(unsafe.Pointer(siggen.rsbufs))
C.rs_job_free(siggen.job)
return nil
}
func jobIter(job *C.rs_job_t, rsbufs *C.rs_buffers_t) (running bool, err error) {
switch res := C.rs_job_iter(job, rsbufs); res {
case C.RS_DONE:
case C.RS_BLOCKED:
running = true
case C.RS_INPUT_ENDED:
err = ErrInputEnded
case C.RS_BAD_MAGIC:
err = ErrBadMagic
case C.RS_CORRUPT:
err = ErrCorrupt
case C.RS_INTERNAL_ERROR:
err = ErrInternal
default:
err = fmt.Errorf("Unexpected result from library: %d", res)
}
return
}
// Read reads len(p) or less bytes of the generated signature.
func (siggen *SignatureGen) Read(p []byte) (readN int, outerr error) {
if len(siggen.outbuf) > 0 {
if len(siggen.outbuf) > len(p) {
readN = len(p)
} else {
readN = len(siggen.outbuf)
}
copy(p[:readN], siggen.outbuf[:readN])
p = p[:readN]
siggen.outbuf = siggen.outbuf[readN:]
return
}
if !siggen.running {
if siggen.err != nil {
return 0, siggen.err
}
return 0, io.EOF
}
// Fill input buffer
if (siggen.rsbufs.avail_in == 0) && (siggen.rsbufs.eof_in == 0) {
n, err := siggen.in.Read(siggen.inbuf[0:inbufSize])
switch err {
case nil:
case io.EOF:
siggen.rsbufs.eof_in = 1
default:
outerr = err
siggen.err = err
siggen.running = false
return
}
siggen.rsbufs.next_in = (*C.char)(unsafe.Pointer(&(siggen.inbuf[0])))
siggen.rsbufs.avail_in = C.size_t(n)
}
siggen.outbuf = siggen.outbufTotal
siggen.rsbufs.next_out = (*C.char)(unsafe.Pointer(&(siggen.outbuf[0])))
siggen.rsbufs.avail_out = C.size_t(len(siggen.outbuf))
var err error
siggen.running, err = jobIter(siggen.job, siggen.rsbufs)
outN := int(uintptr(unsafe.Pointer(siggen.rsbufs.next_out)) - uintptr(unsafe.Pointer(&(siggen.outbuf[0]))))
siggen.outbuf = siggen.outbuf[:outN]
if err != nil {
return outN, err
}
return
}
|
