Gotweb

Blob

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