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/types.h>
18 #include <sys/stat.h>
19 #include <sys/queue.h>
20 #include <sys/uio.h>
21 #include <sys/socket.h>
22 #include <sys/syslimits.h>
23 #include <sys/wait.h>
24 
25 #include <errno.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <stdint.h>
30 #include <sha1.h>
31 #include <zlib.h>
32 #include <ctype.h>
33 #include <limits.h>
34 #include <imsg.h>
35 #include <time.h>
36 #include <unistd.h>
37 
38 #include "got_error.h"
39 #include "got_object.h"
40 #include "got_repository.h"
41 #include "got_opentemp.h"
42 
43 #include "got_lib_sha1.h"
44 #include "got_lib_delta.h"
45 #include "got_lib_privsep.h"
46 #include "got_lib_pack.h"
47 #include "got_lib_inflate.h"
48 #include "got_lib_object.h"
49 #include "got_lib_object_cache.h"
50 #include "got_lib_repository.h"
51 
52 #ifndef nitems
53 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
54 #endif
55 
56 #define GOT_OBJ_TAG_COMMIT	"commit"
57 #define GOT_OBJ_TAG_TREE	"tree"
58 #define GOT_OBJ_TAG_BLOB	"blob"
59 #define GOT_OBJ_TAG_TAG		"tag"
60 
61 #define GOT_COMMIT_TAG_TREE		"tree "
62 #define GOT_COMMIT_TAG_PARENT		"parent "
63 #define GOT_COMMIT_TAG_AUTHOR		"author "
64 #define GOT_COMMIT_TAG_COMMITTER	"committer "
65 
66 #define GOT_TAG_TAG_OBJECT		"object "
67 #define GOT_TAG_TAG_TYPE		"type "
68 #define GOT_TAG_TAG_TAG			"tag "
69 #define GOT_TAG_TAG_TAGGER		"tagger "
70 
71 int
72 got_object_id_cmp(const struct got_object_id *id1,
73     const struct got_object_id *id2)
74 {
75 	return memcmp(id1->sha1, id2->sha1, SHA1_DIGEST_LENGTH);
76 }
77 
78 const struct got_error *
79 got_object_qid_alloc_partial(struct got_object_qid **qid)
80 {
81 	const struct got_error *err = NULL;
82 
83 	*qid = malloc(sizeof(**qid));
84 	if (*qid == NULL)
85 		return got_error_from_errno();
86 
87 	(*qid)->id = malloc(sizeof(*((*qid)->id)));
88 	if ((*qid)->id == NULL) {
89 		err = got_error_from_errno();
90 		got_object_qid_free(*qid);
91 		*qid = NULL;
92 		return err;
93 	}
94 
95 	return NULL;
96 }
97 
98 const struct got_error *
99 got_object_id_str(char **outbuf, struct got_object_id *id)
100 {
101 	static const size_t len = SHA1_DIGEST_STRING_LENGTH;
102 
103 	*outbuf = malloc(len);
104 	if (*outbuf == NULL)
105 		return got_error_from_errno();
106 
107 	if (got_sha1_digest_to_str(id->sha1, *outbuf, len) == NULL) {
108 		free(*outbuf);
109 		*outbuf = NULL;
110 		return got_error(GOT_ERR_BAD_OBJ_ID_STR);
111 	}
112 
113 	return NULL;
114 }
115 
116 void
117 got_object_close(struct got_object *obj)
118 {
119 	if (obj->refcnt > 0) {
120 		obj->refcnt--;
121 		if (obj->refcnt > 0)
122 			return;
123 	}
124 
125 	if (obj->flags & GOT_OBJ_FLAG_DELTIFIED) {
126 		struct got_delta *delta;
127 		while (!SIMPLEQ_EMPTY(&obj->deltas.entries)) {
128 			delta = SIMPLEQ_FIRST(&obj->deltas.entries);
129 			SIMPLEQ_REMOVE_HEAD(&obj->deltas.entries, entry);
130 			got_delta_close(delta);
131 		}
132 	}
133 	if (obj->flags & GOT_OBJ_FLAG_PACKED)
134 		free(obj->path_packfile);
135 	free(obj);
136 }
137 
138 void
139 got_object_qid_free(struct got_object_qid *qid)
140 {
141 	free(qid->id);
142 	free(qid);
143 }
144 
145 struct got_commit_object *
146 got_object_commit_alloc_partial(void)
147 {
148 	struct got_commit_object *commit;
149 
150 	commit = calloc(1, sizeof(*commit));
151 	if (commit == NULL)
152 		return NULL;
153 	commit->tree_id = malloc(sizeof(*commit->tree_id));
154 	if (commit->tree_id == NULL) {
155 		free(commit);
156 		return NULL;
157 	}
158 
159 	SIMPLEQ_INIT(&commit->parent_ids);
160 
161 	return commit;
162 }
163 
164 const struct got_error *
165 got_object_commit_add_parent(struct got_commit_object *commit,
166     const char *id_str)
167 {
168 	const struct got_error *err = NULL;
169 	struct got_object_qid *qid;
170 
171 	err = got_object_qid_alloc_partial(&qid);
172 	if (err)
173 		return err;
174 
175 	if (!got_parse_sha1_digest(qid->id->sha1, id_str)) {
176 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
177 		free(qid->id);
178 		free(qid);
179 		return err;
180 	}
181 
182 	SIMPLEQ_INSERT_TAIL(&commit->parent_ids, qid, entry);
183 	commit->nparents++;
184 
185 	return NULL;
186 }
187 
188 static const struct got_error *
189 parse_gmtoff(time_t *gmtoff, const char *tzstr)
190 {
191 	int sign = 1;
192 	const char *p = tzstr;
193 	time_t h, m;
194 
195 	*gmtoff = 0;
196 
197 	if (*p == '-')
198 		sign = -1;
199 	else if (*p != '+')
200 		return got_error(GOT_ERR_BAD_OBJ_DATA);
201 	p++;
202 	if (!isdigit(*p) && !isdigit(*(p + 1)))
203 		return got_error(GOT_ERR_BAD_OBJ_DATA);
204 	h = (((*p - '0') * 10) + (*(p + 1) - '0'));
205 
206 	p += 2;
207 	if (!isdigit(*p) && !isdigit(*(p + 1)))
208 		return got_error(GOT_ERR_BAD_OBJ_DATA);
209 	m = ((*p - '0') * 10) + (*(p + 1) - '0');
210 
211 	*gmtoff = (h * 60 * 60 + m * 60) * sign;
212 	return NULL;
213 }
214 
215 static const struct got_error *
216 parse_commit_time(time_t *time, time_t *gmtoff, char *committer)
217 {
218 	const struct got_error *err = NULL;
219 	const char *errstr;
220 	char *space, *tzstr;
221 
222 	/* Parse and strip off trailing timezone indicator string. */
223 	space = strrchr(committer, ' ');
224 	if (space == NULL)
225 		return got_error(GOT_ERR_BAD_OBJ_DATA);
226 	tzstr = strdup(space + 1);
227 	if (tzstr == NULL)
228 		return got_error_from_errno();
229 	err = parse_gmtoff(gmtoff, tzstr);
230 	free(tzstr);
231 	if (err)
232 		return err;
233 	*space = '\0';
234 
235 	/* Timestamp is separated from committer name + email by space. */
236 	space = strrchr(committer, ' ');
237 	if (space == NULL)
238 		return got_error(GOT_ERR_BAD_OBJ_DATA);
239 
240 	/* Timestamp parsed here is expressed in comitter's local time. */
241 	*time = strtonum(space + 1, 0, INT64_MAX, &errstr);
242 	if (errstr)
243 		return got_error(GOT_ERR_BAD_OBJ_DATA);
244 
245 	/* Express the time stamp in UTC. */
246 	*time -= *gmtoff;
247 
248 	/* Strip off parsed time information, leaving just author and email. */
249 	*space = '\0';
250 
251 	return NULL;
252 }
253 
254 void
255 got_object_commit_close(struct got_commit_object *commit)
256 {
257 	struct got_object_qid *qid;
258 
259 	if (commit->refcnt > 0) {
260 		commit->refcnt--;
261 		if (commit->refcnt > 0)
262 			return;
263 	}
264 
265 	while (!SIMPLEQ_EMPTY(&commit->parent_ids)) {
266 		qid = SIMPLEQ_FIRST(&commit->parent_ids);
267 		SIMPLEQ_REMOVE_HEAD(&commit->parent_ids, entry);
268 		got_object_qid_free(qid);
269 	}
270 
271 	free(commit->tree_id);
272 	free(commit->author);
273 	free(commit->committer);
274 	free(commit->logmsg);
275 	free(commit);
276 }
277 
278 const struct got_error *
279 got_object_parse_commit(struct got_commit_object **commit, char *buf, size_t len)
280 {
281 	const struct got_error *err = NULL;
282 	char *s = buf;
283 	size_t tlen;
284 	ssize_t remain = (ssize_t)len;
285  
286 	*commit = got_object_commit_alloc_partial();
287 	if (*commit == NULL)
288 		return got_error_from_errno();
289 
290 	tlen = strlen(GOT_COMMIT_TAG_TREE);
291 	if (strncmp(s, GOT_COMMIT_TAG_TREE, tlen) == 0) {
292 		remain -= tlen;
293 		if (remain < SHA1_DIGEST_STRING_LENGTH) {
294 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
295 			goto done;
296 		}
297 		s += tlen;
298 		if (!got_parse_sha1_digest((*commit)->tree_id->sha1, s)) {
299 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
300 			goto done;
301 		}
302 		remain -= SHA1_DIGEST_STRING_LENGTH;
303 		s += SHA1_DIGEST_STRING_LENGTH;
304 	} else {
305 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
306 		goto done;
307 	}
308 
309 	tlen = strlen(GOT_COMMIT_TAG_PARENT);
310 	while (strncmp(s, GOT_COMMIT_TAG_PARENT, tlen) == 0) {
311 		remain -= tlen;
312 		if (remain < SHA1_DIGEST_STRING_LENGTH) {
313 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
314 			goto done;
315 		}
316 		s += tlen;
317 		err = got_object_commit_add_parent(*commit, s);
318 		if (err)
319 			goto done;
320 
321 		remain -= SHA1_DIGEST_STRING_LENGTH;
322 		s += SHA1_DIGEST_STRING_LENGTH;
323 	}
324 
325 	tlen = strlen(GOT_COMMIT_TAG_AUTHOR);
326 	if (strncmp(s, GOT_COMMIT_TAG_AUTHOR, tlen) == 0) {
327 		char *p;
328 		size_t slen;
329 
330 		remain -= tlen;
331 		if (remain <= 0) {
332 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
333 			goto done;
334 		}
335 		s += tlen;
336 		p = strchr(s, '\n');
337 		if (p == NULL) {
338 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
339 			goto done;
340 		}
341 		*p = '\0';
342 		slen = strlen(s);
343 		err = parse_commit_time(&(*commit)->author_time,
344 		    &(*commit)->author_gmtoff, s);
345 		if (err)
346 			goto done;
347 		(*commit)->author = strdup(s);
348 		if ((*commit)->author == NULL) {
349 			err = got_error_from_errno();
350 			goto done;
351 		}
352 		s += slen + 1;
353 		remain -= slen + 1;
354 	}
355 
356 	tlen = strlen(GOT_COMMIT_TAG_COMMITTER);
357 	if (strncmp(s, GOT_COMMIT_TAG_COMMITTER, tlen) == 0) {
358 		char *p;
359 		size_t slen;
360 
361 		remain -= tlen;
362 		if (remain <= 0) {
363 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
364 			goto done;
365 		}
366 		s += tlen;
367 		p = strchr(s, '\n');
368 		if (p == NULL) {
369 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
370 			goto done;
371 		}
372 		*p = '\0';
373 		slen = strlen(s);
374 		err = parse_commit_time(&(*commit)->committer_time,
375 		    &(*commit)->committer_gmtoff, s);
376 		if (err)
377 			goto done;
378 		(*commit)->committer = strdup(s);
379 		if ((*commit)->committer == NULL) {
380 			err = got_error_from_errno();
381 			goto done;
382 		}
383 		s += slen + 1;
384 		remain -= slen + 1;
385 	}
386 
387 	(*commit)->logmsg = strndup(s, remain);
388 	if ((*commit)->logmsg == NULL) {
389 		err = got_error_from_errno();
390 		goto done;
391 	}
392 done:
393 	if (err) {
394 		got_object_commit_close(*commit);
395 		*commit = NULL;
396 	}
397 	return err;
398 }
399 
400 void
401 got_object_tree_entry_close(struct got_tree_entry *te)
402 {
403 	free(te->id);
404 	free(te->name);
405 	free(te);
406 }
407 
408 void
409 got_object_tree_close(struct got_tree_object *tree)
410 {
411 	struct got_tree_entry *te;
412 
413 	if (tree->refcnt > 0) {
414 		tree->refcnt--;
415 		if (tree->refcnt > 0)
416 			return;
417 	}
418 
419 	while (!SIMPLEQ_EMPTY(&tree->entries.head)) {
420 		te = SIMPLEQ_FIRST(&tree->entries.head);
421 		SIMPLEQ_REMOVE_HEAD(&tree->entries.head, entry);
422 		got_object_tree_entry_close(te);
423 	}
424 
425 	free(tree);
426 }
427 
428 struct got_tree_entry *
429 got_alloc_tree_entry_partial(void)
430 {
431 	struct got_tree_entry *te;
432 
433 	te = malloc(sizeof(*te));
434 	if (te == NULL)
435 		return NULL;
436 
437 	te->id = malloc(sizeof(*te->id));
438 	if (te->id == NULL) {
439 		free(te);
440 		te = NULL;
441 	}
442 	return te;
443 }
444 
445 static const struct got_error *
446 parse_tree_entry(struct got_tree_entry **te, size_t *elen, char *buf,
447     size_t maxlen)
448 {
449 	char *p = buf, *space;
450 	const struct got_error *err = NULL;
451 
452 	*te = got_alloc_tree_entry_partial();
453 	if (*te == NULL)
454 		return got_error_from_errno();
455 
456 	*elen = strlen(buf) + 1;
457 	if (*elen > maxlen) {
458 		free(*te);
459 		*te = NULL;
460 		return got_error(GOT_ERR_BAD_OBJ_DATA);
461 	}
462 
463 	space = strchr(buf, ' ');
464 	if (space == NULL) {
465 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
466 		free(*te);
467 		*te = NULL;
468 		return err;
469 	}
470 	(*te)->mode = 0;
471 	while (*p != ' ') {
472 		if (*p < '0' && *p > '7') {
473 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
474 			goto done;
475 		}
476 		(*te)->mode <<= 3;
477 		(*te)->mode |= *p - '0';
478 		p++;
479 	}
480 
481 	(*te)->name = strdup(space + 1);
482 	if (*elen > maxlen || maxlen - *elen < SHA1_DIGEST_LENGTH) {
483 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
484 		goto done;
485 	}
486 	buf += *elen;
487 	memcpy((*te)->id->sha1, buf, SHA1_DIGEST_LENGTH);
488 	*elen += SHA1_DIGEST_LENGTH;
489 done:
490 	if (err) {
491 		got_object_tree_entry_close(*te);
492 		*te = NULL;
493 	}
494 	return err;
495 }
496 
497 const struct got_error *
498 got_object_parse_tree(struct got_tree_object **tree, uint8_t *buf, size_t len)
499 {
500 	const struct got_error *err;
501 	size_t remain = len;
502 
503 	*tree = calloc(1, sizeof(**tree));
504 	if (*tree == NULL)
505 		return got_error_from_errno();
506 
507 	SIMPLEQ_INIT(&(*tree)->entries.head);
508 
509 	while (remain > 0) {
510 		struct got_tree_entry *te;
511 		size_t elen;
512 
513 		err = parse_tree_entry(&te, &elen, buf, remain);
514 		if (err)
515 			return err;
516 		(*tree)->entries.nentries++;
517 		SIMPLEQ_INSERT_TAIL(&(*tree)->entries.head, te, entry);
518 		buf += elen;
519 		remain -= elen;
520 	}
521 
522 	if (remain != 0) {
523 		got_object_tree_close(*tree);
524 		*tree = NULL;
525 		return got_error(GOT_ERR_BAD_OBJ_DATA);
526 	}
527 
528 	return NULL;
529 }
530 
531 void
532 got_object_tag_close(struct got_tag_object *tag)
533 {
534 	free(tag->tag);
535 	free(tag->tagger);
536 	free(tag->tagmsg);
537 	free(tag);
538 }
539 
540 const struct got_error *
541 got_object_parse_tag(struct got_tag_object **tag, uint8_t *buf, size_t len)
542 {
543 	const struct got_error *err = NULL;
544 	size_t remain = len;
545 	char *s = buf;
546 	size_t tlen;
547 
548 	*tag = calloc(1, sizeof(**tag));
549 	if (*tag == NULL)
550 		return got_error_from_errno();
551 
552 	tlen = strlen(GOT_TAG_TAG_OBJECT);
553 	if (strncmp(s, GOT_TAG_TAG_OBJECT, tlen) == 0) {
554 		remain -= tlen;
555 		if (remain < SHA1_DIGEST_STRING_LENGTH) {
556 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
557 			goto done;
558 		}
559 		s += tlen;
560 		if (!got_parse_sha1_digest((*tag)->id.sha1, s)) {
561 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
562 			goto done;
563 		}
564 		remain -= SHA1_DIGEST_STRING_LENGTH;
565 		s += SHA1_DIGEST_STRING_LENGTH;
566 	} else {
567 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
568 		goto done;
569 	}
570 
571 	if (remain <= 0) {
572 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
573 		goto done;
574 	}
575 
576 	tlen = strlen(GOT_TAG_TAG_TYPE);
577 	if (strncmp(s, GOT_TAG_TAG_TYPE, tlen) == 0) {
578 		remain -= tlen;
579 		if (remain <= 0) {
580 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
581 			goto done;
582 		}
583 		s += tlen;
584 		if (strncmp(s, GOT_OBJ_TAG_COMMIT,
585 		    strlen(GOT_OBJ_TAG_COMMIT)) == 0) {
586 			(*tag)->obj_type = GOT_OBJ_TYPE_COMMIT;
587 			tlen = strlen(GOT_OBJ_TAG_COMMIT);
588 			s += tlen;
589 			remain -= tlen;
590 		} else if (strncmp(s, GOT_OBJ_TAG_TREE,
591 		    strlen(GOT_OBJ_TAG_TREE)) == 0) {
592 			(*tag)->obj_type = GOT_OBJ_TYPE_TREE;
593 			tlen = strlen(GOT_OBJ_TAG_TREE);
594 			s += tlen;
595 			remain -= tlen;
596 		} else if (strncmp(s, GOT_OBJ_TAG_BLOB,
597 		    strlen(GOT_OBJ_TAG_BLOB)) == 0) {
598 			(*tag)->obj_type = GOT_OBJ_TYPE_BLOB;
599 			tlen = strlen(GOT_OBJ_TAG_BLOB);
600 			s += tlen;
601 			remain -= tlen;
602 		} else if (strncmp(s, GOT_OBJ_TAG_TAG,
603 		    strlen(GOT_OBJ_TAG_TAG)) == 0) {
604 			(*tag)->obj_type = GOT_OBJ_TYPE_TAG;
605 			tlen = strlen(GOT_OBJ_TAG_TAG);
606 			s += tlen;
607 			remain -= tlen;
608 		} else {
609 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
610 			goto done;
611 		}
612 
613 		if (remain <= 0 || *s != '\n') {
614 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
615 			goto done;
616 		}
617 		s++;
618 		remain--;
619 		if (remain <= 0) {
620 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
621 			goto done;
622 		}
623 	} else {
624 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
625 		goto done;
626 	}
627 
628 	tlen = strlen(GOT_TAG_TAG_TAG);
629 	if (strncmp(s, GOT_TAG_TAG_TAG, tlen) == 0) {
630 		char *p;
631 		size_t slen;
632 		remain -= tlen;
633 		if (remain <= 0) {
634 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
635 			goto done;
636 		}
637 		s += tlen;
638 		p = strchr(s, '\n');
639 		if (p == NULL) {
640 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
641 			goto done;
642 		}
643 		*p = '\0';
644 		slen = strlen(s);
645 		(*tag)->tag = strndup(s, slen);
646 		if ((*tag)->tag == NULL) {
647 			err = got_error_from_errno();
648 			goto done;
649 		}
650 		s += slen + 1;
651 		remain -= slen + 1;
652 		if (remain <= 0) {
653 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
654 			goto done;
655 		}
656 	} else {
657 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
658 		goto done;
659 	}
660 
661 	tlen = strlen(GOT_TAG_TAG_TAGGER);
662 	if (strncmp(s, GOT_TAG_TAG_TAGGER, tlen) == 0) {
663 		char *p;
664 		size_t slen;
665 
666 		remain -= tlen;
667 		if (remain <= 0) {
668 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
669 			goto done;
670 		}
671 		s += tlen;
672 		p = strchr(s, '\n');
673 		if (p == NULL) {
674 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
675 			goto done;
676 		}
677 		*p = '\0';
678 		slen = strlen(s);
679 		err = parse_commit_time(&(*tag)->tagger_time,
680 		    &(*tag)->tagger_gmtoff, s);
681 		if (err)
682 			goto done;
683 		(*tag)->tagger = strdup(s);
684 		if ((*tag)->tagger == NULL) {
685 			err = got_error_from_errno();
686 			goto done;
687 		}
688 		s += slen + 1;
689 		remain -= slen + 1;
690 		if (remain <= 0) {
691 			err = got_error(GOT_ERR_BAD_OBJ_DATA);
692 			goto done;
693 		}
694 	} else {
695 		err = got_error(GOT_ERR_BAD_OBJ_DATA);
696 		goto done;
697 	}
698 
699 	(*tag)->tagmsg = strndup(s, remain);
700 	if ((*tag)->tagmsg == NULL) {
701 		err = got_error_from_errno();
702 		goto done;
703 	}
704 done:
705 	if (err) {
706 		got_object_tag_close(*tag);
707 		*tag = NULL;
708 	}
709 	return err;
710 }
711 
712 const struct got_error *
713 got_read_file_to_mem(uint8_t **outbuf, size_t *outlen, FILE *f)
714 {
715 	const struct got_error *err = NULL;
716 	static const size_t blocksize = 512;
717 	size_t n, total, remain;
718 	uint8_t *buf;
719 
720 	*outbuf = NULL;
721 	*outlen = 0;
722 
723 	buf = malloc(blocksize);
724 	if (buf == NULL)
725 		return got_error_from_errno();
726 
727 	remain = blocksize;
728 	total = 0;
729 	while (1) {
730 		if (remain == 0) {
731 			uint8_t *newbuf;
732 			newbuf = reallocarray(buf, 1, total + blocksize);
733 			if (newbuf == NULL) {
734 				err = got_error_from_errno();
735 				goto done;
736 			}
737 			buf = newbuf;
738 			remain += blocksize;
739 		}
740 		n = fread(buf + total, 1, remain, f);
741 		if (n == 0) {
742 			if (ferror(f)) {
743 				err = got_ferror(f, GOT_ERR_IO);
744 				goto done;
745 			}
746 			break; /* EOF */
747 		}
748 		remain -= n;
749 		total += n;
750 	};
751 
752 done:
753 	if (err == NULL) {
754 		*outbuf = buf;
755 		*outlen = total;
756 	} else
757 		free(buf);
758 	return err;
759 }