1 /*
2  * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/queue.h>
18 
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <zlib.h>
23 #include <sha1.h>
24 
25 #include "got_error.h"
26 #include "got_repository.h"
27 #include "got_object.h"
28 
29 #include "delta.h"
30 #include "path.h"
31 #include "zb.h"
32 
33 #ifndef MIN
34 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
35 #endif
36 
37 struct got_delta *
38 got_delta_open(const char *path_packfile, off_t offset, size_t tslen,
39     int type, size_t size)
40 {
41 	struct got_delta *delta;
42 
43 	delta = calloc(1, sizeof(*delta));
44 	if (delta == NULL)
45 		return NULL;
46 
47 	delta->path_packfile = strdup(path_packfile);
48 	if (delta->path_packfile == NULL) {
49 		free(delta);
50 		return NULL;
51 	}
52 	delta->type = type;
53 	delta->offset = offset;
54 	delta->tslen = tslen;
55 	delta->size = size;
56 	return delta;
57 }
58 
59 void
60 got_delta_close(struct got_delta *delta)
61 {
62 	free(delta->path_packfile);
63 	free(delta);
64 
65 }
66 
67 const struct got_error *
68 got_delta_chain_get_base_type(int *type, struct got_delta_chain *deltas)
69 {
70 	struct got_delta *delta;
71 
72 	/* The first delta in the chain should represent the base object. */
73 	delta = SIMPLEQ_FIRST(&deltas->entries);
74 	if (delta->type == GOT_OBJ_TYPE_COMMIT ||
75 	    delta->type == GOT_OBJ_TYPE_TREE ||
76 	    delta->type == GOT_OBJ_TYPE_BLOB ||
77 	    delta->type == GOT_OBJ_TYPE_TAG) {
78 		*type = delta->type;
79 		return NULL;
80 	}
81 
82 	return got_error(GOT_ERR_BAD_DELTA_CHAIN);
83 }
84 
85 /* Fetch another (required) byte from the delta stream. */
86 static const struct got_error *
87 next_delta_byte(const uint8_t **p, size_t *remain)
88 {
89 	if (--(*remain) == 0)
90 		return got_error(GOT_ERR_BAD_DELTA);
91 	(*p)++;
92 	return NULL;
93 }
94 
95 static const struct got_error *
96 parse_size(uint64_t *size, const uint8_t **p, size_t *remain)
97 {
98 	const struct got_error *err = NULL;
99 	int i = 0;
100 
101 	*size = 0;
102 	do {
103 		/* We do not support size values which don't fit in 64 bit. */
104 		if (i > 9)
105 			return got_error(GOT_ERR_NO_SPACE);
106 
107 		if (i == 0)
108 			*size = ((**p) & GOT_DELTA_SIZE_VAL_MASK);
109 		else {
110 			size_t shift = GOT_DELTA_SIZE_SHIFT * i;
111 			*size |= (((**p) & GOT_DELTA_SIZE_VAL_MASK) << shift);
112 		}
113 
114 		if (((**p) & GOT_DELTA_SIZE_MORE) == 0)
115 			break;
116 		i++;
117 		err = next_delta_byte(p, remain);
118 	} while (err == NULL);
119 
120 	return err;
121 }
122 
123 static const struct got_error *
124 parse_opcode(off_t *offset, size_t *len, const uint8_t **p, size_t *remain)
125 {
126 	const struct got_error *err = NULL;
127 	off_t o = 0;
128 	size_t l = 0;
129 	uint8_t opcode = **p;
130 
131 	if (opcode & GOT_DELTA_COPY_OFF1) {
132 		err = next_delta_byte(p, remain);
133 		if (err)
134 			return err;
135 		o = (off_t)(**p);
136 	}
137 	if (opcode & GOT_DELTA_COPY_OFF2) {
138 		err = next_delta_byte(p, remain);
139 		if (err)
140 			return err;
141 		o |= ((off_t)(**p)) << 8;
142 	}
143 	if (opcode & GOT_DELTA_COPY_OFF3) {
144 		err = next_delta_byte(p, remain);
145 		if (err)
146 			return err;
147 		o |= ((off_t)(**p)) << 16;
148 	}
149 	if (opcode & GOT_DELTA_COPY_OFF4) {
150 		err = next_delta_byte(p, remain);
151 		if (err)
152 			return err;
153 		o |= ((off_t)(**p)) << 24;
154 	}
155 
156 	if (opcode & GOT_DELTA_COPY_LEN1) {
157 		err = next_delta_byte(p, remain);
158 		if (err)
159 			return err;
160 		l = (off_t)(**p);
161 	}
162 	if (opcode & GOT_DELTA_COPY_LEN2) {
163 		err = next_delta_byte(p, remain);
164 		if (err)
165 			return err;
166 		l |= ((off_t)(**p)) << 8;
167 	}
168 	if (opcode & GOT_DELTA_COPY_LEN3) {
169 		err = next_delta_byte(p, remain);
170 		if (err)
171 			return err;
172 		l |= ((off_t)(**p)) << 16;
173 	}
174 
175 	if (o == 0)
176 		o = GOT_DELTA_COPY_DEFAULT_OFF;
177 	if (l == 0)
178 		l = GOT_DELTA_COPY_DEFAULT_LEN;
179 
180 	*offset = o;
181 	*len = l;
182 	return NULL;
183 }
184 
185 static const struct got_error *
186 copy_from_base(FILE *base_file, off_t offset, size_t size, FILE *outfile)
187 {
188 	if (fseeko(base_file, offset, SEEK_SET) != 0)
189 		return got_error_from_errno();
190 
191 	while (size > 0) {
192 		uint8_t data[2048];
193 		size_t len = MIN(size, sizeof(data));
194 		size_t n;
195 
196 		n = fread(data, len, 1, base_file);
197 		if (n != 1)
198 			return got_ferror(base_file, GOT_ERR_IO);
199 
200 		n = fwrite(data, len, 1, outfile);
201 		if (n != 1)
202 			return got_ferror(outfile, GOT_ERR_IO);
203 
204 		size -= len;
205 	}
206 
207 	return NULL;
208 }
209 
210 static const struct got_error *
211 copy_from_delta(const uint8_t **p, size_t *remain, size_t len, FILE *outfile)
212 {
213 	size_t n;
214 
215 	if (*remain < len)
216 		return got_error(GOT_ERR_BAD_DELTA);
217 
218 	n = fwrite(*p, len, 1, outfile);
219 	if (n != 1)
220 		return got_ferror(outfile, GOT_ERR_IO);
221 
222 	*p += len;
223 	*remain -= len;
224 	return NULL;
225 }
226 
227 const struct got_error *
228 got_delta_apply(FILE *base_file, const uint8_t *delta_buf,
229     size_t delta_len, FILE *outfile)
230 {
231 	const struct got_error *err = NULL;
232 	uint64_t base_size, result_size;
233 	size_t remain, outsize = 0;
234 	const uint8_t *p;
235 
236 	if (delta_len < GOT_DELTA_STREAM_LENGTH_MIN)
237 		return got_error(GOT_ERR_BAD_DELTA);
238 
239 	p = delta_buf;
240 	remain = delta_len;
241 
242 	/* Read the two size fields at the beginning of the stream. */
243 	err = parse_size(&base_size, &p, &remain);
244 	if (err)
245 		return err;
246 	err = next_delta_byte(&p, &remain);
247 	if (err)
248 		return err;
249 	err = parse_size(&result_size, &p, &remain);
250 	if (err)
251 		return err;
252 
253 	/* Decode and execute copy instructions from the delta stream. */
254 	err = next_delta_byte(&p, &remain);
255 	while (err == NULL) {
256 		if (*p & GOT_DELTA_BASE_COPY) {
257 			off_t offset = 0;
258 			size_t len = 0;
259 			err = parse_opcode(&offset, &len, &p, &remain);
260 			if (err)
261 				break;
262 			err = copy_from_base(base_file, offset, len, outfile);
263 			if (err == NULL)
264 				outsize += len;
265 		} else {
266 			size_t len = (size_t)*p;
267 			if (len == 0) {
268 				err = got_error(GOT_ERR_BAD_DELTA);
269 				break;
270 			}
271 			err = next_delta_byte(&p, &remain);
272 			if (err)
273 				return err;
274 			err = copy_from_delta(&p, &remain, len, outfile);
275 			if (err == NULL)
276 				outsize += len;
277 		}
278 
279 		if (err == NULL) {
280 			if (remain == 0)
281 				break;
282 			/* Fetch the next instruction. */
283 			p++;
284 			remain--;
285 		}
286 	}
287 
288 	if (outsize != result_size)
289 		err = got_error(GOT_ERR_BAD_DELTA);
290 
291 	if (err == NULL)
292 		rewind(outfile);
293 	return err;
294 }