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 "got_delta_lib.h"
30 #include "got_path_lib.h"
31 #include "got_zbuf_lib.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, off_t data_offset)
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 	delta->data_offset = data_offset;
57 	return delta;
58 }
59 
60 void
61 got_delta_close(struct got_delta *delta)
62 {
63 	free(delta->path_packfile);
64 	free(delta);
65 
66 }
67 
68 const struct got_error *
69 got_delta_chain_get_base_type(int *type, struct got_delta_chain *deltas)
70 {
71 	struct got_delta *delta;
72 
73 	/* The first delta in the chain should represent the base object. */
74 	delta = SIMPLEQ_FIRST(&deltas->entries);
75 	if (delta->type == GOT_OBJ_TYPE_COMMIT ||
76 	    delta->type == GOT_OBJ_TYPE_TREE ||
77 	    delta->type == GOT_OBJ_TYPE_BLOB ||
78 	    delta->type == GOT_OBJ_TYPE_TAG) {
79 		*type = delta->type;
80 		return NULL;
81 	}
82 
83 	return got_error(GOT_ERR_BAD_DELTA_CHAIN);
84 }
85 
86 /* Fetch another (required) byte from the delta stream. */
87 static const struct got_error *
88 next_delta_byte(const uint8_t **p, size_t *remain)
89 {
90 	if (--(*remain) == 0)
91 		return got_error(GOT_ERR_BAD_DELTA);
92 	(*p)++;
93 	return NULL;
94 }
95 
96 static const struct got_error *
97 parse_size(uint64_t *size, const uint8_t **p, size_t *remain)
98 {
99 	const struct got_error *err = NULL;
100 	int i = 0;
101 
102 	*size = 0;
103 	do {
104 		/* We do not support size values which don't fit in 64 bit. */
105 		if (i > 9)
106 			return got_error(GOT_ERR_NO_SPACE);
107 
108 		if (i == 0)
109 			*size = ((**p) & GOT_DELTA_SIZE_VAL_MASK);
110 		else {
111 			size_t shift = GOT_DELTA_SIZE_SHIFT * i;
112 			*size |= (((**p) & GOT_DELTA_SIZE_VAL_MASK) << shift);
113 		}
114 
115 		if (((**p) & GOT_DELTA_SIZE_MORE) == 0)
116 			break;
117 		i++;
118 		err = next_delta_byte(p, remain);
119 	} while (err == NULL);
120 
121 	return err;
122 }
123 
124 static const struct got_error *
125 parse_opcode(off_t *offset, size_t *len, const uint8_t **p, size_t *remain)
126 {
127 	const struct got_error *err = NULL;
128 	off_t o = 0;
129 	size_t l = 0;
130 	uint8_t opcode = **p;
131 
132 	if (opcode & GOT_DELTA_COPY_OFF1) {
133 		err = next_delta_byte(p, remain);
134 		if (err)
135 			return err;
136 		o = (off_t)(**p);
137 	}
138 	if (opcode & GOT_DELTA_COPY_OFF2) {
139 		err = next_delta_byte(p, remain);
140 		if (err)
141 			return err;
142 		o |= ((off_t)(**p)) << 8;
143 	}
144 	if (opcode & GOT_DELTA_COPY_OFF3) {
145 		err = next_delta_byte(p, remain);
146 		if (err)
147 			return err;
148 		o |= ((off_t)(**p)) << 16;
149 	}
150 	if (opcode & GOT_DELTA_COPY_OFF4) {
151 		err = next_delta_byte(p, remain);
152 		if (err)
153 			return err;
154 		o |= ((off_t)(**p)) << 24;
155 	}
156 
157 	if (opcode & GOT_DELTA_COPY_LEN1) {
158 		err = next_delta_byte(p, remain);
159 		if (err)
160 			return err;
161 		l = (off_t)(**p);
162 	}
163 	if (opcode & GOT_DELTA_COPY_LEN2) {
164 		err = next_delta_byte(p, remain);
165 		if (err)
166 			return err;
167 		l |= ((off_t)(**p)) << 8;
168 	}
169 	if (opcode & GOT_DELTA_COPY_LEN3) {
170 		err = next_delta_byte(p, remain);
171 		if (err)
172 			return err;
173 		l |= ((off_t)(**p)) << 16;
174 	}
175 
176 	if (o == 0)
177 		o = GOT_DELTA_COPY_DEFAULT_OFF;
178 	if (l == 0)
179 		l = GOT_DELTA_COPY_DEFAULT_LEN;
180 
181 	*offset = o;
182 	*len = l;
183 	return NULL;
184 }
185 
186 static const struct got_error *
187 copy_from_base(FILE *base_file, off_t offset, size_t size, FILE *outfile)
188 {
189 	if (fseeko(base_file, offset, SEEK_SET) != 0)
190 		return got_error_from_errno();
191 
192 	while (size > 0) {
193 		uint8_t data[2048];
194 		size_t len = MIN(size, sizeof(data));
195 		size_t n;
196 
197 		n = fread(data, len, 1, base_file);
198 		if (n != 1)
199 			return got_ferror(base_file, GOT_ERR_IO);
200 
201 		n = fwrite(data, len, 1, outfile);
202 		if (n != 1)
203 			return got_ferror(outfile, GOT_ERR_IO);
204 
205 		size -= len;
206 	}
207 
208 	return NULL;
209 }
210 
211 static const struct got_error *
212 copy_from_delta(const uint8_t **p, size_t *remain, size_t len, FILE *outfile)
213 {
214 	size_t n;
215 
216 	if (*remain < len)
217 		return got_error(GOT_ERR_BAD_DELTA);
218 
219 	n = fwrite(*p, len, 1, outfile);
220 	if (n != 1)
221 		return got_ferror(outfile, GOT_ERR_IO);
222 
223 	*p += len;
224 	*remain -= len;
225 	return NULL;
226 }
227 
228 const struct got_error *
229 got_delta_apply(FILE *base_file, const uint8_t *delta_buf,
230     size_t delta_len, FILE *outfile)
231 {
232 	const struct got_error *err = NULL;
233 	uint64_t base_size, result_size;
234 	size_t remain, outsize = 0;
235 	const uint8_t *p;
236 
237 	if (delta_len < GOT_DELTA_STREAM_LENGTH_MIN)
238 		return got_error(GOT_ERR_BAD_DELTA);
239 
240 	p = delta_buf;
241 	remain = delta_len;
242 
243 	/* Read the two size fields at the beginning of the stream. */
244 	err = parse_size(&base_size, &p, &remain);
245 	if (err)
246 		return err;
247 	err = next_delta_byte(&p, &remain);
248 	if (err)
249 		return err;
250 	err = parse_size(&result_size, &p, &remain);
251 	if (err)
252 		return err;
253 
254 	/* Decode and execute copy instructions from the delta stream. */
255 	err = next_delta_byte(&p, &remain);
256 	while (err == NULL && remain > 0) {
257 		if (*p & GOT_DELTA_BASE_COPY) {
258 			off_t offset = 0;
259 			size_t len = 0;
260 			err = parse_opcode(&offset, &len, &p, &remain);
261 			if (err)
262 				break;
263 			err = copy_from_base(base_file, offset, len, outfile);
264 			if (err == NULL) {
265 				outsize += len;
266 				if (remain > 0) {
267 					p++;
268 					remain--;
269 				}
270 			}
271 		} else {
272 			size_t len = (size_t)*p;
273 			if (len == 0) {
274 				err = got_error(GOT_ERR_BAD_DELTA);
275 				break;
276 			}
277 			err = next_delta_byte(&p, &remain);
278 			if (err)
279 				break;
280 			err = copy_from_delta(&p, &remain, len, outfile);
281 			if (err == NULL)
282 				outsize += len;
283 		}
284 	}
285 
286 	if (outsize != result_size)
287 		err = got_error(GOT_ERR_BAD_DELTA);
288 
289 	if (err == NULL)
290 		rewind(outfile);
291 	return err;
292 }