1 /*
2  * Copyright (c) 2022 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 #include <sys/stat.h>
19 
20 #include <errno.h>
21 #include <limits.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 
27 #include "got_error.h"
28 #include "got_object.h"
29 #include "got_repository.h"
30 #include "got_path.h"
31 
32 #include "got_lib_delta.h"
33 #include "got_lib_object.h"
34 #include "got_lib_object_cache.h"
35 #include "got_lib_object_parse.h"
36 #include "got_lib_pack.h"
37 #include "got_lib_repository.h"
38 
39 const struct got_error *
40 got_object_open_packed(struct got_object **obj, struct got_object_id *id,
41     struct got_repository *repo)
42 {
43 	const struct got_error *err = NULL;
44 	struct got_pack *pack = NULL;
45 	struct got_packidx *packidx = NULL;
46 	int idx;
47 	char *path_packfile;
48 
49 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
50 	if (err)
51 		return err;
52 
53 	err = got_packidx_get_packfile_path(&path_packfile,
54 	    packidx->path_packidx);
55 	if (err)
56 		return err;
57 
58 	pack = got_repo_get_cached_pack(repo, path_packfile);
59 	if (pack == NULL) {
60 		err = got_repo_cache_pack(&pack, repo, path_packfile, packidx);
61 		if (err)
62 			goto done;
63 	}
64 
65 	err = got_packfile_open_object(obj, pack, packidx, idx, id);
66 	if (err)
67 		return err;
68 	(*obj)->refcnt++;
69 
70 	err = got_repo_cache_object(repo, id, *obj);
71 	if (err) {
72 		if (err->code == GOT_ERR_OBJ_EXISTS ||
73 		    err->code == GOT_ERR_OBJ_TOO_LARGE)
74 			err = NULL;
75 	}
76 done:
77 	free(path_packfile);
78 	return err;
79 }
80 
81 const struct got_error *
82 got_object_open_from_packfile(struct got_object **obj, struct got_object_id *id,
83     struct got_pack *pack, struct got_packidx *packidx, int obj_idx,
84     struct got_repository *repo)
85 {
86 	const struct got_error *err;
87 
88 	*obj = got_repo_get_cached_object(repo, id);
89 	if (*obj != NULL) {
90 		(*obj)->refcnt++;
91 		return NULL;
92 	}
93 
94 	err = got_packfile_open_object(obj, pack, packidx, obj_idx, id);
95 	if (err)
96 		return err;
97 	(*obj)->refcnt++;
98 
99 	err = got_repo_cache_object(repo, id, *obj);
100 	if (err) {
101 		if (err->code == GOT_ERR_OBJ_EXISTS ||
102 		    err->code == GOT_ERR_OBJ_TOO_LARGE)
103 			err = NULL;
104 		return err;
105 	}
106 	(*obj)->refcnt++;
107 	return NULL;
108 }
109 
110 const struct got_error *
111 got_object_read_raw_delta(uint64_t *base_size, uint64_t *result_size,
112     off_t *delta_size, off_t *delta_compressed_size, off_t *delta_offset,
113     off_t *delta_out_offset, struct got_object_id **base_id, int delta_cache_fd,
114     struct got_packidx *packidx, int obj_idx, struct got_object_id *id,
115     struct got_repository *repo)
116 {
117 	return got_error(GOT_ERR_NOT_IMPL);
118 }
119 
120 const struct got_error *
121 got_object_open(struct got_object **obj, struct got_repository *repo,
122     struct got_object_id *id)
123 {
124 	const struct got_error *err = NULL;
125 	int fd;
126 
127 	*obj = got_repo_get_cached_object(repo, id);
128 	if (*obj != NULL) {
129 		(*obj)->refcnt++;
130 		return NULL;
131 	}
132 
133 	err = got_object_open_packed(obj, id, repo);
134 	if (err) {
135 		if (err->code != GOT_ERR_NO_OBJ)
136 			return err;
137 	} else
138 		return NULL;
139 
140 	err = got_object_open_loose_fd(&fd, id, repo);
141 	if (err) {
142 		if (err->code == GOT_ERR_ERRNO && errno == ENOENT)
143 			err = got_error_no_obj(id);
144 		return err;
145 	}
146 
147 	err = got_object_read_header(obj, fd);
148 	if (err)
149 		goto done;
150 
151 	memcpy(&(*obj)->id, id, sizeof((*obj)->id));
152 	(*obj)->refcnt++;
153 
154 	err = got_repo_cache_object(repo, id, *obj);
155 	if (err) {
156 		if (err->code == GOT_ERR_OBJ_EXISTS ||
157 		    err->code == GOT_ERR_OBJ_TOO_LARGE)
158 			err = NULL;
159 	}
160 done:
161 	if (close(fd) == -1 && err == NULL)
162 		err = got_error_from_errno("close");
163 	return err;
164 }
165 
166 static const struct got_error *
167 wrap_fd(FILE **f, int wrapped_fd)
168 {
169 	const struct got_error *err = NULL;
170 	int fd;
171 
172 	if (ftruncate(wrapped_fd, 0L) == -1)
173 		return got_error_from_errno("ftruncate");
174 
175 	if (lseek(wrapped_fd, 0L, SEEK_SET) == -1)
176 		return got_error_from_errno("lseek");
177 
178 	fd = dup(wrapped_fd);
179 	if (fd == -1)
180 		return got_error_from_errno("dup");
181 
182 	*f = fdopen(fd, "w+");
183 	if (*f == NULL) {
184 		err = got_error_from_errno("fdopen");
185 		close(fd);
186 	}
187 	return err;
188 }
189 
190 static const struct got_error *
191 read_packed_object_raw(uint8_t **outbuf, off_t *size, size_t *hdrlen,
192     int outfd, struct got_pack *pack, struct got_packidx *packidx, int idx,
193     struct got_object_id *id)
194 {
195 	const struct got_error *err = NULL;
196 	uint64_t raw_size = 0;
197 	struct got_object *obj;
198 	FILE *outfile = NULL, *basefile = NULL, *accumfile = NULL;
199 
200 	*outbuf = NULL;
201 	*size = 0;
202 	*hdrlen = 0;
203 
204 	err = got_packfile_open_object(&obj, pack, packidx, idx, id);
205 	if (err)
206 		return err;
207 
208 	if (obj->flags & GOT_OBJ_FLAG_DELTIFIED) {
209 		err = got_pack_get_max_delta_object_size(&raw_size, obj, pack);
210 		if (err)
211 			goto done;
212 	} else
213 		raw_size = obj->size;
214 
215 	if (raw_size <= GOT_DELTA_RESULT_SIZE_CACHED_MAX) {
216 		size_t len;
217 		err = got_packfile_extract_object_to_mem(outbuf, &len,
218 		    obj, pack);
219 		if (err)
220 			goto done;
221 		*size = (off_t)len;
222 	} else {
223 		/*
224 		 * XXX This uses 3 file extra descriptors for no good reason.
225 		 * We should have got_packfile_extract_object_to_fd().
226 		 */
227 		err = wrap_fd(&outfile, outfd);
228 		if (err)
229 			goto done;
230 		err = wrap_fd(&basefile, pack->basefd);
231 		if (err)
232 			goto done;
233 		err = wrap_fd(&accumfile, pack->accumfd);
234 		if (err)
235 			goto done;
236 		err = got_packfile_extract_object(pack, obj, outfile, basefile,
237 		    accumfile);
238 		if (err)
239 			goto done;
240 		*size = obj->size;
241 	}
242 
243 	*hdrlen = obj->hdrlen;
244 done:
245 	got_object_close(obj);
246 	if (outfile && fclose(outfile) == EOF && err == NULL)
247 		err = got_error_from_errno("fclose");
248 	if (basefile && fclose(basefile) == EOF && err == NULL)
249 		err = got_error_from_errno("fclose");
250 	if (accumfile && fclose(accumfile) == EOF && err == NULL)
251 		err = got_error_from_errno("fclose");
252 	return err;
253 
254 }
255 
256 static void
257 put_raw_object_tempfile(struct got_raw_object *obj)
258 {
259 	struct got_repository *repo = obj->close_arg;
260 
261 	if (obj->tempfile_idx != -1)
262 		got_repo_temp_fds_put(obj->tempfile_idx, repo);
263 }
264 
265 /* *outfd must be initialized to -1 by caller */
266 const struct got_error *
267 got_object_raw_open(struct got_raw_object **obj, int *outfd,
268     struct got_repository *repo, struct got_object_id *id)
269 {
270 	const struct got_error *err = NULL;
271 	struct got_packidx *packidx = NULL;
272 	int idx, tempfd, tempfile_idx;
273 	uint8_t *outbuf = NULL;
274 	off_t size = 0;
275 	size_t hdrlen = 0;
276 	char *path_packfile = NULL;
277 
278 	*obj = got_repo_get_cached_raw_object(repo, id);
279 	if (*obj != NULL) {
280 		(*obj)->refcnt++;
281 		return NULL;
282 	}
283 
284 	err = got_repo_temp_fds_get(&tempfd, &tempfile_idx, repo);
285 	if (err)
286 		return err;
287 
288 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
289 	if (err == NULL) {
290 		struct got_pack *pack = NULL;
291 
292 		err = got_packidx_get_packfile_path(&path_packfile,
293 		    packidx->path_packidx);
294 		if (err)
295 			goto done;
296 
297 		pack = got_repo_get_cached_pack(repo, path_packfile);
298 		if (pack == NULL) {
299 			err = got_repo_cache_pack(&pack, repo, path_packfile,
300 			    packidx);
301 			if (err)
302 				goto done;
303 		}
304 		err = read_packed_object_raw(&outbuf, &size, &hdrlen,
305 		    tempfd, pack, packidx, idx, id);
306 		if (err)
307 			goto done;
308 	} else if (err->code == GOT_ERR_NO_OBJ) {
309 		int fd;
310 
311 		err = got_object_open_loose_fd(&fd, id, repo);
312 		if (err)
313 			goto done;
314 		err = got_object_read_raw(&outbuf, &size, &hdrlen,
315 		    GOT_DELTA_RESULT_SIZE_CACHED_MAX, tempfd, id, fd);
316 		if (close(fd) == -1 && err == NULL)
317 			err = got_error_from_errno("close");
318 		if (err)
319 			goto done;
320 	}
321 
322 	if (outbuf == NULL) {
323 		if (*outfd != -1) {
324 			err = got_error_msg(GOT_ERR_NOT_IMPL, "bad outfd");
325 			goto done;
326 		}
327 
328 		/*
329 		 * Duplicate tempfile descriptor to allow use of
330 		 * fdopen(3) inside got_object_raw_alloc().
331 		 */
332 		*outfd = dup(tempfd);
333 		if (*outfd == -1) {
334 			err = got_error_from_errno("dup");
335 			goto done;
336 		}
337 	}
338 
339 	err = got_object_raw_alloc(obj, outbuf, outfd,
340 	    GOT_DELTA_RESULT_SIZE_CACHED_MAX, hdrlen, size);
341 	if (err)
342 		goto done;
343 
344 	err = got_repo_cache_raw_object(repo, id, *obj);
345 	if (err) {
346 		if (err->code == GOT_ERR_OBJ_EXISTS ||
347 		    err->code == GOT_ERR_OBJ_TOO_LARGE)
348 			err = NULL;
349 	}
350 done:
351 	free(path_packfile);
352 	if (err) {
353 		if (*obj) {
354 			got_object_raw_close(*obj);
355 			*obj = NULL;
356 		}
357 		free(outbuf);
358 		got_repo_temp_fds_put(tempfile_idx, repo);
359 		if (*outfd != -1) {
360 			close(*outfd);
361 			*outfd = -1;
362 		}
363 	} else {
364 		if (((*obj)->f == NULL && (*obj)->fd == -1)) {
365 			/* This raw object is not backed by a file. */
366 			got_repo_temp_fds_put(tempfile_idx, repo);
367 			if (*outfd != -1) {
368 				close(*outfd);
369 				*outfd = -1;
370 			}
371 		} else {
372 			(*obj)->tempfile_idx = tempfile_idx;
373 			(*obj)->close_cb = put_raw_object_tempfile;
374 			(*obj)->close_arg = repo;
375 		}
376 	}
377 	return err;
378 }
379 
380 static const struct got_error *
381 open_commit(struct got_commit_object **commit,
382     struct got_repository *repo, struct got_object_id *id, int check_cache)
383 {
384 	const struct got_error *err = NULL;
385 	struct got_packidx *packidx = NULL;
386 	int idx;
387 	char *path_packfile = NULL;
388 
389 	if (check_cache) {
390 		*commit = got_repo_get_cached_commit(repo, id);
391 		if (*commit != NULL) {
392 			(*commit)->refcnt++;
393 			return NULL;
394 		}
395 	} else
396 		*commit = NULL;
397 
398 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
399 	if (err == NULL) {
400 		struct got_pack *pack = NULL;
401 		struct got_object *obj;
402 		uint8_t *buf;
403 		size_t len;
404 
405 		err = got_packidx_get_packfile_path(&path_packfile,
406 		    packidx->path_packidx);
407 		if (err)
408 			return err;
409 
410 		pack = got_repo_get_cached_pack(repo, path_packfile);
411 		if (pack == NULL) {
412 			err = got_repo_cache_pack(&pack, repo, path_packfile,
413 			    packidx);
414 			if (err)
415 				goto done;
416 		}
417 		err = got_packfile_open_object(&obj, pack, packidx, idx, id);
418 		if (err)
419 			goto done;
420 		err = got_packfile_extract_object_to_mem(&buf, &len,
421 		    obj, pack);
422 		got_object_close(obj);
423 		if (err)
424 			goto done;
425 		err = got_object_parse_commit(commit, buf, len);
426 		free(buf);
427 	} else if (err->code == GOT_ERR_NO_OBJ) {
428 		int fd;
429 
430 		err = got_object_open_loose_fd(&fd, id, repo);
431 		if (err)
432 			return err;
433 		err = got_object_read_commit(commit, fd, id, 0);
434 		if (close(fd) == -1 && err == NULL)
435 			err = got_error_from_errno("close");
436 		if (err)
437 			return err;
438 	}
439 
440 	if (err == NULL) {
441 		(*commit)->refcnt++;
442 		err = got_repo_cache_commit(repo, id, *commit);
443 		if (err) {
444 			if (err->code == GOT_ERR_OBJ_EXISTS ||
445 			    err->code == GOT_ERR_OBJ_TOO_LARGE)
446 				err = NULL;
447 		}
448 	}
449 done:
450 	free(path_packfile);
451 	return err;
452 }
453 
454 const struct got_error *
455 got_object_open_as_commit(struct got_commit_object **commit,
456     struct got_repository *repo, struct got_object_id *id)
457 {
458 	*commit = got_repo_get_cached_commit(repo, id);
459 	if (*commit != NULL) {
460 		(*commit)->refcnt++;
461 		return NULL;
462 	}
463 
464 	return open_commit(commit, repo, id, 0);
465 }
466 
467 const struct got_error *
468 got_object_commit_open(struct got_commit_object **commit,
469     struct got_repository *repo, struct got_object *obj)
470 {
471 	return open_commit(commit, repo, got_object_get_id(obj), 1);
472 }
473 
474 static const struct got_error *
475 open_tree(struct got_tree_object **tree,
476     struct got_repository *repo, struct got_object_id *id, int check_cache)
477 {
478 	const struct got_error *err = NULL;
479 	struct got_packidx *packidx = NULL;
480 	int idx;
481 	char *path_packfile = NULL;
482 	struct got_parsed_tree_entry *entries = NULL;
483 	size_t nentries = 0, nentries_alloc = 0, i;
484 	uint8_t *buf = NULL;
485 
486 	if (check_cache) {
487 		*tree = got_repo_get_cached_tree(repo, id);
488 		if (*tree != NULL) {
489 			(*tree)->refcnt++;
490 			return NULL;
491 		}
492 	} else
493 		*tree = NULL;
494 
495 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
496 	if (err == NULL) {
497 		struct got_pack *pack = NULL;
498 		struct got_object *obj;
499 		size_t len;
500 
501 		err = got_packidx_get_packfile_path(&path_packfile,
502 		    packidx->path_packidx);
503 		if (err)
504 			return err;
505 
506 		pack = got_repo_get_cached_pack(repo, path_packfile);
507 		if (pack == NULL) {
508 			err = got_repo_cache_pack(&pack, repo, path_packfile,
509 			    packidx);
510 			if (err)
511 				goto done;
512 		}
513 		err = got_packfile_open_object(&obj, pack, packidx, idx, id);
514 		if (err)
515 			goto done;
516 		err = got_packfile_extract_object_to_mem(&buf, &len,
517 		    obj, pack);
518 		got_object_close(obj);
519 		if (err)
520 			goto done;
521 		err = got_object_parse_tree(&entries, &nentries,
522 		    &nentries_alloc, buf, len);
523 		if (err)
524 			goto done;
525 	} else if (err->code == GOT_ERR_NO_OBJ) {
526 		int fd;
527 
528 		err = got_object_open_loose_fd(&fd, id, repo);
529 		if (err)
530 			return err;
531 		err = got_object_read_tree(&entries, &nentries,
532 		    &nentries_alloc, &buf, fd, id);
533 		if (close(fd) == -1 && err == NULL)
534 			err = got_error_from_errno("close");
535 		if (err)
536 			goto done;
537 	} else
538 		goto done;
539 
540 	*tree = malloc(sizeof(**tree));
541 	if (*tree == NULL) {
542 		err = got_error_from_errno("malloc");
543 		goto done;
544 	}
545 	(*tree)->entries = calloc(nentries, sizeof(struct got_tree_entry));
546 	if ((*tree)->entries == NULL) {
547 		err = got_error_from_errno("malloc");
548 		goto done;
549 	}
550 	(*tree)->nentries = nentries;
551 	(*tree)->refcnt = 0;
552 
553 	for (i = 0; i < nentries; i++) {
554 		struct got_parsed_tree_entry *pe = &entries[i];
555 		struct got_tree_entry *te = &(*tree)->entries[i];
556 	
557 		if (strlcpy(te->name, pe->name,
558 		    sizeof(te->name)) >= sizeof(te->name)) {
559 			err = got_error(GOT_ERR_NO_SPACE);
560 			goto done;
561 		}
562 		memcpy(te->id.sha1, pe->id, SHA1_DIGEST_LENGTH);
563 		te->mode = pe->mode;
564 		te->idx = i;
565 	}
566 done:
567 	free(path_packfile);
568 	free(entries);
569 	free(buf);
570 	if (err == NULL) {
571 		(*tree)->refcnt++;
572 		err = got_repo_cache_tree(repo, id, *tree);
573 		if (err) {
574 			if (err->code == GOT_ERR_OBJ_EXISTS ||
575 			    err->code == GOT_ERR_OBJ_TOO_LARGE)
576 				err = NULL;
577 		}
578 	}
579 	if (err) {
580 		if (*tree)
581 			free((*tree)->entries);
582 		free(*tree);
583 		*tree = NULL;
584 	}
585 	return err;
586 }
587 
588 const struct got_error *
589 got_object_open_as_tree(struct got_tree_object **tree,
590     struct got_repository *repo, struct got_object_id *id)
591 {
592 	*tree = got_repo_get_cached_tree(repo, id);
593 	if (*tree != NULL) {
594 		(*tree)->refcnt++;
595 		return NULL;
596 	}
597 
598 	return open_tree(tree, repo, id, 0);
599 }
600 
601 const struct got_error *
602 got_object_tree_open(struct got_tree_object **tree,
603     struct got_repository *repo, struct got_object *obj)
604 {
605 	return open_tree(tree, repo, got_object_get_id(obj), 1);
606 }
607 
608 const struct got_error *
609 got_object_open_as_blob(struct got_blob_object **blob,
610     struct got_repository *repo, struct got_object_id *id, size_t blocksize,
611     int outfd)
612 {
613 	return got_error(GOT_ERR_NOT_IMPL);
614 }
615 
616 const struct got_error *
617 got_object_blob_open(struct got_blob_object **blob,
618     struct got_repository *repo, struct got_object *obj, size_t blocksize,
619     int outfd)
620 {
621 	return got_error(GOT_ERR_NOT_IMPL);
622 }
623 
624 static const struct got_error *
625 open_tag(struct got_tag_object **tag, struct got_repository *repo,
626     struct got_object_id *id, int check_cache)
627 {
628 	const struct got_error *err = NULL;
629 	struct got_packidx *packidx = NULL;
630 	int idx;
631 	char *path_packfile = NULL;
632 	struct got_object *obj = NULL;
633 	int obj_type = GOT_OBJ_TYPE_ANY;
634 
635 	if (check_cache) {
636 		*tag = got_repo_get_cached_tag(repo, id);
637 		if (*tag != NULL) {
638 			(*tag)->refcnt++;
639 			return NULL;
640 		}
641 	} else
642 		*tag = NULL;
643 
644 	err = got_repo_search_packidx(&packidx, &idx, repo, id);
645 	if (err == NULL) {
646 		struct got_pack *pack = NULL;
647 		uint8_t *buf = NULL;
648 		size_t len;
649 
650 		err = got_packidx_get_packfile_path(&path_packfile,
651 		    packidx->path_packidx);
652 		if (err)
653 			return err;
654 
655 		pack = got_repo_get_cached_pack(repo, path_packfile);
656 		if (pack == NULL) {
657 			err = got_repo_cache_pack(&pack, repo, path_packfile,
658 			    packidx);
659 			if (err)
660 				goto done;
661 		}
662 
663 		/* Beware of "lightweight" tags: Check object type first. */
664 		err = got_packfile_open_object(&obj, pack, packidx, idx, id);
665 		if (err)
666 			goto done;
667 		obj_type = obj->type;
668 		if (obj_type != GOT_OBJ_TYPE_TAG) {
669 			err = got_error(GOT_ERR_OBJ_TYPE);
670 			got_object_close(obj);
671 			goto done;
672 		}
673 		err = got_packfile_extract_object_to_mem(&buf, &len,
674 		    obj, pack);
675 		got_object_close(obj);
676 		if (err)
677 			goto done;
678 		err = got_object_parse_tag(tag, buf, len);
679 		free(buf);
680 	} else if (err->code == GOT_ERR_NO_OBJ) {
681 		int fd;
682 
683 		err = got_object_open_loose_fd(&fd, id, repo);
684 		if (err)
685 			return err;
686 		err = got_object_read_header(&obj, fd);
687 		if (close(fd) == -1 && err == NULL)
688 			err = got_error_from_errno("close");
689 		if (err)
690 			return err;
691 		obj_type = obj->type;
692 		got_object_close(obj);
693 		if (obj_type != GOT_OBJ_TYPE_TAG)
694 			return got_error(GOT_ERR_OBJ_TYPE);
695 
696 		err = got_object_open_loose_fd(&fd, id, repo);
697 		if (err)
698 			return err;
699 		err = got_object_read_tag(tag, fd, id, 0);
700 		if (close(fd) == -1 && err == NULL)
701 			err = got_error_from_errno("close");
702 		if (err)
703 			return err;
704 	}
705 
706 	if (err == NULL) {
707 		(*tag)->refcnt++;
708 		err = got_repo_cache_tag(repo, id, *tag);
709 		if (err) {
710 			if (err->code == GOT_ERR_OBJ_EXISTS ||
711 			    err->code == GOT_ERR_OBJ_TOO_LARGE)
712 				err = NULL;
713 		}
714 	}
715 done:
716 	free(path_packfile);
717 	return err;
718 }
719 
720 const struct got_error *
721 got_object_open_as_tag(struct got_tag_object **tag,
722     struct got_repository *repo, struct got_object_id *id)
723 {
724 	*tag = got_repo_get_cached_tag(repo, id);
725 	if (*tag != NULL) {
726 		(*tag)->refcnt++;
727 		return NULL;
728 	}
729 
730 	return open_tag(tag, repo, id, 0);
731 }
732 
733 const struct got_error *
734 got_object_tag_open(struct got_tag_object **tag,
735     struct got_repository *repo, struct got_object *obj)
736 {
737 	return open_tag(tag, repo, got_object_get_id(obj), 1);
738 }