2 * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
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.
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.
17 #include <sys/types.h>
19 #include <sys/queue.h>
21 #include <sys/socket.h>
36 #include "got_error.h"
37 #include "got_object.h"
38 #include "got_repository.h"
39 #include "got_opentemp.h"
41 #include "got_lib_sha1.h"
42 #include "got_lib_delta.h"
43 #include "got_lib_pack.h"
44 #include "got_lib_path.h"
45 #include "got_lib_zbuf.h"
46 #include "got_lib_object.h"
47 #include "got_lib_privsep.h"
50 #define MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
54 #define nitems(_a) (sizeof(_a) / sizeof((_a)[0]))
57 #define GOT_OBJ_TAG_COMMIT "commit"
58 #define GOT_OBJ_TAG_TREE "tree"
59 #define GOT_OBJ_TAG_BLOB "blob"
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 "
66 const struct got_error *
67 got_object_id_str(char **outbuf, struct got_object_id *id)
69 static const size_t len = SHA1_DIGEST_STRING_LENGTH;
71 *outbuf = calloc(1, len);
73 return got_error_from_errno();
75 if (got_sha1_digest_to_str(id->sha1, *outbuf, len) == NULL) {
78 return got_error(GOT_ERR_BAD_OBJ_ID_STR);
85 got_object_id_cmp(struct got_object_id *id1, struct got_object_id *id2)
87 return memcmp(id1->sha1, id2->sha1, SHA1_DIGEST_LENGTH);
90 struct got_object_id *
91 got_object_id_dup(struct got_object_id *id1)
93 struct got_object_id *id2;
95 id2 = malloc(sizeof(*id2));
98 memcpy(id2, id1, sizeof(*id2));
102 struct got_object_id *
103 got_object_get_id(struct got_object *obj)
105 return got_object_id_dup(&obj->id);
108 const struct got_error *
109 got_object_get_id_str(char **outbuf, struct got_object *obj)
111 return got_object_id_str(outbuf, &obj->id);
115 got_object_get_type(struct got_object *obj)
118 case GOT_OBJ_TYPE_COMMIT:
119 case GOT_OBJ_TYPE_TREE:
120 case GOT_OBJ_TYPE_BLOB:
121 case GOT_OBJ_TYPE_TAG:
132 static const struct got_error *
133 parse_object_header(struct got_object **obj, char *buf, size_t len)
135 const char *obj_tags[] = {
140 const int obj_types[] = {
146 size_t size = 0, hdrlen = 0;
148 char *p = strchr(buf, '\0');
151 return got_error(GOT_ERR_BAD_OBJ_HDR);
153 hdrlen = strlen(buf) + 1 /* '\0' */;
155 for (i = 0; i < nitems(obj_tags); i++) {
156 const char *tag = obj_tags[i];
157 size_t tlen = strlen(tag);
160 if (strncmp(buf, tag, tlen) != 0)
165 return got_error(GOT_ERR_BAD_OBJ_HDR);
166 size = strtonum(buf + tlen, 0, LONG_MAX, &errstr);
168 return got_error(GOT_ERR_BAD_OBJ_HDR);
173 return got_error(GOT_ERR_BAD_OBJ_HDR);
175 *obj = calloc(1, sizeof(**obj));
177 return got_error_from_errno();
179 (*obj)->hdrlen = hdrlen;
184 static const struct got_error *
185 read_object_header(struct got_object **obj, FILE *f)
187 const struct got_error *err;
188 struct got_zstream_buf zb;
190 const size_t zbsize = 64;
191 size_t outlen, totlen;
194 buf = calloc(zbsize, sizeof(char));
196 return got_error_from_errno();
198 err = got_inflate_init(&zb, NULL, zbsize);
205 err = got_inflate_read(&zb, f, &outlen);
208 if (strchr(zb.outbuf, '\0') == NULL) {
209 buf = recallocarray(buf, 1 + i, 2 + i, zbsize);
211 err = got_error_from_errno();
215 memcpy(buf + totlen, zb.outbuf, outlen);
218 } while (strchr(zb.outbuf, '\0') == NULL);
220 err = parse_object_header(obj, buf, totlen);
222 got_inflate_end(&zb);
227 read_object_header_privsep_child(int obj_fd, int imsg_fds[2])
229 const struct got_error *err = NULL;
230 struct got_object *obj = NULL;
235 setproctitle("read object header");
237 imsg_init(&ibuf, imsg_fds[1]);
239 /* revoke access to most system calls */
240 if (pledge("stdio", NULL) == -1) {
241 err = got_error_from_errno();
245 f = fdopen(obj_fd, "rb");
247 err = got_error_from_errno();
252 err = read_object_header(&obj, f);
256 err = got_privsep_send_obj(&ibuf, obj, 0);
259 got_object_close(obj);
261 got_privsep_send_error(&ibuf, err);
271 static const struct got_error *
272 wait_for_child(pid_t pid)
276 waitpid(pid, &child_status, 0);
278 if (!WIFEXITED(child_status))
279 return got_error(GOT_ERR_PRIVSEP_DIED);
281 if (WEXITSTATUS(child_status) != 0)
282 return got_error(GOT_ERR_PRIVSEP_EXIT);
287 static const struct got_error *
288 read_object_header_privsep(struct got_object **obj, int fd)
290 struct imsgbuf parent_ibuf;
292 const struct got_error *err = NULL, *err_child = NULL;
295 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
296 return got_error_from_errno();
300 return got_error_from_errno();
302 read_object_header_privsep_child(fd, imsg_fds);
307 imsg_init(&parent_ibuf, imsg_fds[0]);
308 err = got_privsep_recv_obj(obj, &parent_ibuf);
309 imsg_clear(&parent_ibuf);
310 err_child = wait_for_child(pid);
312 return err ? err : err_child;
315 static const struct got_error *
316 object_path(char **path, struct got_object_id *id, struct got_repository *repo)
318 const struct got_error *err = NULL;
320 char *path_objects = got_repo_get_path_objects(repo);
324 if (path_objects == NULL)
325 return got_error_from_errno();
327 err = got_object_id_str(&hex, id);
331 if (asprintf(path, "%s/%.2x/%s", path_objects,
332 id->sha1[0], hex + 2) == -1)
333 err = got_error_from_errno();
340 static const struct got_error *
341 open_loose_object(int *fd, struct got_object *obj, struct got_repository *repo)
343 const struct got_error *err = NULL;
346 err = object_path(&path, &obj->id, repo);
349 *fd = open(path, O_RDONLY | O_NOFOLLOW, GOT_DEFAULT_FILE_MODE);
351 err = got_error_from_errno();
359 const struct got_error *
360 got_object_open(struct got_object **obj, struct got_repository *repo,
361 struct got_object_id *id)
363 const struct got_error *err = NULL;
367 err = object_path(&path, id, repo);
371 fd = open(path, O_RDONLY | O_NOFOLLOW, GOT_DEFAULT_FILE_MODE);
373 if (errno != ENOENT) {
374 err = got_error_from_errno();
377 err = got_packfile_open_object(obj, id, repo);
381 err = got_error(GOT_ERR_NO_OBJ);
383 err = read_object_header_privsep(obj, fd);
386 memcpy((*obj)->id.sha1, id->sha1, SHA1_DIGEST_LENGTH);
396 const struct got_error *
397 got_object_open_by_id_str(struct got_object **obj, struct got_repository *repo,
400 struct got_object_id id;
402 if (!got_parse_sha1_digest(id.sha1, id_str))
403 return got_error(GOT_ERR_BAD_OBJ_ID_STR);
405 return got_object_open(obj, repo, &id);
409 got_object_close(struct got_object *obj)
411 if (obj->flags & GOT_OBJ_FLAG_DELTIFIED) {
412 struct got_delta *delta;
413 while (!SIMPLEQ_EMPTY(&obj->deltas.entries)) {
414 delta = SIMPLEQ_FIRST(&obj->deltas.entries);
415 SIMPLEQ_REMOVE_HEAD(&obj->deltas.entries, entry);
416 got_delta_close(delta);
419 if (obj->flags & GOT_OBJ_FLAG_PACKED)
420 free(obj->path_packfile);
424 struct got_commit_object *
425 got_object_commit_alloc_partial(void)
427 struct got_commit_object *commit;
429 commit = calloc(1, sizeof(*commit));
432 commit->tree_id = calloc(1, sizeof(*commit->tree_id));
433 if (commit->tree_id == NULL) {
438 SIMPLEQ_INIT(&commit->parent_ids);
443 const struct got_error *
444 got_object_open_as_commit(struct got_commit_object **commit,
445 struct got_repository *repo, struct got_object_id *id)
447 const struct got_error *err;
448 struct got_object *obj;
450 err = got_object_open(&obj, repo, id);
453 if (got_object_get_type(obj) != GOT_OBJ_TYPE_COMMIT) {
454 err = got_error(GOT_ERR_OBJ_TYPE);
458 err = got_object_commit_open(commit, repo, obj);
460 got_object_close(obj);
464 const struct got_error *
465 got_object_commit_add_parent(struct got_commit_object *commit,
468 const struct got_error *err = NULL;
469 struct got_object_qid *qid;
471 qid = calloc(1, sizeof(*qid));
473 return got_error_from_errno();
475 qid->id = calloc(1, sizeof(*qid->id));
476 if (qid->id == NULL) {
477 err = got_error_from_errno();
482 if (!got_parse_sha1_digest(qid->id->sha1, id_str)) {
483 err = got_error(GOT_ERR_BAD_OBJ_DATA);
489 SIMPLEQ_INSERT_TAIL(&commit->parent_ids, qid, entry);
495 static const struct got_error *
496 parse_commit_time(time_t *time, char **tzoff, char *committer)
503 /* Parse and then strip trailing timezone indicator. */
504 space = strrchr(committer, ' ');
506 return got_error(GOT_ERR_BAD_OBJ_DATA);
507 *tzoff = strdup(space + 1);
509 return got_error_from_errno();
512 /* Timestamp is separated from committer name + email by space. */
513 space = strrchr(committer, ' ');
515 return got_error(GOT_ERR_BAD_OBJ_DATA);
517 *time = strtonum(space + 1, 0, INT64_MAX, &errstr);
519 return got_error(GOT_ERR_BAD_OBJ_DATA);
521 /* Strip off parsed time information, leaving just author and email. */
526 static const struct got_error *
527 parse_commit_object(struct got_commit_object **commit, char *buf, size_t len)
529 const struct got_error *err = NULL;
532 ssize_t remain = (ssize_t)len;
534 *commit = got_object_commit_alloc_partial();
536 return got_error_from_errno();
538 tlen = strlen(GOT_COMMIT_TAG_TREE);
539 if (strncmp(s, GOT_COMMIT_TAG_TREE, tlen) == 0) {
541 if (remain < SHA1_DIGEST_STRING_LENGTH) {
542 err = got_error(GOT_ERR_BAD_OBJ_DATA);
546 if (!got_parse_sha1_digest((*commit)->tree_id->sha1, s)) {
547 err = got_error(GOT_ERR_BAD_OBJ_DATA);
550 remain -= SHA1_DIGEST_STRING_LENGTH;
551 s += SHA1_DIGEST_STRING_LENGTH;
553 err = got_error(GOT_ERR_BAD_OBJ_DATA);
557 tlen = strlen(GOT_COMMIT_TAG_PARENT);
558 while (strncmp(s, GOT_COMMIT_TAG_PARENT, tlen) == 0) {
560 if (remain < SHA1_DIGEST_STRING_LENGTH) {
561 err = got_error(GOT_ERR_BAD_OBJ_DATA);
565 err = got_object_commit_add_parent(*commit, s);
569 remain -= SHA1_DIGEST_STRING_LENGTH;
570 s += SHA1_DIGEST_STRING_LENGTH;
573 tlen = strlen(GOT_COMMIT_TAG_AUTHOR);
574 if (strncmp(s, GOT_COMMIT_TAG_AUTHOR, tlen) == 0) {
580 err = got_error(GOT_ERR_BAD_OBJ_DATA);
586 err = got_error(GOT_ERR_BAD_OBJ_DATA);
591 err = parse_commit_time(&(*commit)->author_time,
592 &(*commit)->author_tzoff, s);
595 (*commit)->author = strdup(s);
596 if ((*commit)->author == NULL) {
597 err = got_error_from_errno();
604 tlen = strlen(GOT_COMMIT_TAG_COMMITTER);
605 if (strncmp(s, GOT_COMMIT_TAG_COMMITTER, tlen) == 0) {
611 err = got_error(GOT_ERR_BAD_OBJ_DATA);
617 err = got_error(GOT_ERR_BAD_OBJ_DATA);
622 err = parse_commit_time(&(*commit)->committer_time,
623 &(*commit)->committer_tzoff, s);
626 (*commit)->committer = strdup(s);
627 if ((*commit)->committer == NULL) {
628 err = got_error_from_errno();
635 (*commit)->logmsg = strndup(s, remain);
636 if ((*commit)->logmsg == NULL) {
637 err = got_error_from_errno();
642 got_object_commit_close(*commit);
649 tree_entry_close(struct got_tree_entry *te)
656 struct got_tree_entry *
657 got_alloc_tree_entry_partial(void)
659 struct got_tree_entry *te;
661 te = calloc(1, sizeof(*te));
665 te->id = calloc(1, sizeof(*te->id));
666 if (te->id == NULL) {
673 static const struct got_error *
674 parse_tree_entry(struct got_tree_entry **te, size_t *elen, char *buf,
677 char *p = buf, *space;
678 const struct got_error *err = NULL;
680 *te = got_alloc_tree_entry_partial();
682 return got_error_from_errno();
684 *elen = strlen(buf) + 1;
685 if (*elen > maxlen) {
688 return got_error(GOT_ERR_BAD_OBJ_DATA);
691 space = strchr(buf, ' ');
693 err = got_error(GOT_ERR_BAD_OBJ_DATA);
699 if (*p < '0' && *p > '7') {
700 err = got_error(GOT_ERR_BAD_OBJ_DATA);
704 (*te)->mode |= *p - '0';
708 (*te)->name = strdup(space + 1);
709 if (*elen > maxlen || maxlen - *elen < SHA1_DIGEST_LENGTH) {
710 err = got_error(GOT_ERR_BAD_OBJ_DATA);
713 buf += strlen(buf) + 1;
714 memcpy((*te)->id->sha1, buf, SHA1_DIGEST_LENGTH);
715 *elen += SHA1_DIGEST_LENGTH;
718 tree_entry_close(*te);
724 static const struct got_error *
725 parse_tree_object(struct got_tree_object **tree, uint8_t *buf, size_t len)
727 const struct got_error *err;
730 *tree = calloc(1, sizeof(**tree));
732 return got_error_from_errno();
734 SIMPLEQ_INIT(&(*tree)->entries);
737 struct got_tree_entry *te;
740 err = parse_tree_entry(&te, &elen, buf, remain);
744 SIMPLEQ_INSERT_TAIL(&(*tree)->entries, te, entry);
750 got_object_tree_close(*tree);
751 return got_error(GOT_ERR_BAD_OBJ_DATA);
757 static const struct got_error *
758 read_to_mem(uint8_t **outbuf, size_t *outlen, FILE *f)
760 const struct got_error *err = NULL;
761 static const size_t blocksize = 512;
762 size_t n, total, remain;
768 buf = calloc(1, blocksize);
770 return got_error_from_errno();
777 newbuf = reallocarray(buf, 1, total + blocksize);
778 if (newbuf == NULL) {
779 err = got_error_from_errno();
785 n = fread(buf + total, 1, remain, f);
788 err = got_ferror(f, GOT_ERR_IO);
806 static const struct got_error *
807 read_commit_object(struct got_commit_object **commit, struct got_object *obj,
810 const struct got_error *err = NULL;
814 if (obj->flags & GOT_OBJ_FLAG_PACKED)
815 err = read_to_mem(&p, &len, f);
817 err = got_inflate_to_mem(&p, &len, f);
821 if (len < obj->hdrlen + obj->size) {
822 err = got_error(GOT_ERR_BAD_OBJ_DATA);
826 /* Skip object header. */
828 err = parse_commit_object(commit, p + obj->hdrlen, len);
835 read_commit_object_privsep_child(struct got_object *obj, int obj_fd,
838 const struct got_error *err = NULL;
839 struct got_commit_object *commit = NULL;
844 setproctitle("read commit object");
846 imsg_init(&ibuf, imsg_fds[1]);
848 /* revoke access to most system calls */
849 if (pledge("stdio", NULL) == -1) {
850 err = got_error_from_errno();
854 f = fdopen(obj_fd, "rb");
856 err = got_error_from_errno();
861 err = read_commit_object(&commit, obj, f);
865 err = got_privsep_send_commit(&ibuf, commit);
868 got_object_commit_close(commit);
870 got_privsep_send_error(&ibuf, err);
880 static const struct got_error *
881 read_commit_object_privsep(struct got_commit_object **commit,
882 struct got_repository *repo, struct got_object *obj, int fd)
884 const struct got_error *err = NULL, *err_child = NULL;
885 struct imsgbuf parent_ibuf;
889 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
890 return got_error_from_errno();
894 return got_error_from_errno();
896 read_commit_object_privsep_child(obj, fd, imsg_fds);
901 imsg_init(&parent_ibuf, imsg_fds[0]);
902 err = got_privsep_recv_commit(commit, &parent_ibuf);
903 imsg_clear(&parent_ibuf);
904 err_child = wait_for_child(pid);
906 return err ? err : err_child;
909 const struct got_error *
910 got_object_commit_open(struct got_commit_object **commit,
911 struct got_repository *repo, struct got_object *obj)
913 const struct got_error *err = NULL;
915 if (obj->type != GOT_OBJ_TYPE_COMMIT)
916 return got_error(GOT_ERR_OBJ_TYPE);
918 if (obj->flags & GOT_OBJ_FLAG_PACKED) {
921 err = got_packfile_extract_object_to_mem(&buf, &len, obj, repo);
925 err = parse_commit_object(commit, buf, len);
929 err = open_loose_object(&fd, obj, repo);
932 err = read_commit_object_privsep(commit, repo, obj, fd);
939 got_object_commit_close(struct got_commit_object *commit)
941 struct got_object_qid *qid;
943 while (!SIMPLEQ_EMPTY(&commit->parent_ids)) {
944 qid = SIMPLEQ_FIRST(&commit->parent_ids);
945 SIMPLEQ_REMOVE_HEAD(&commit->parent_ids, entry);
950 free(commit->tree_id);
951 free(commit->author);
952 free(commit->author_tzoff);
953 free(commit->committer);
954 free(commit->committer_tzoff);
955 free(commit->logmsg);
959 static const struct got_error *
960 read_tree_object(struct got_tree_object **tree, struct got_object *obj, FILE *f)
962 const struct got_error *err = NULL;
966 if (obj->flags & GOT_OBJ_FLAG_PACKED)
967 err = read_to_mem(&p, &len, f);
969 err = got_inflate_to_mem(&p, &len, f);
973 if (len < obj->hdrlen + obj->size) {
974 err = got_error(GOT_ERR_BAD_OBJ_DATA);
978 /* Skip object header. */
980 err = parse_tree_object(tree, p + obj->hdrlen, len);
987 read_tree_object_privsep_child(struct got_object *obj, int obj_fd,
990 const struct got_error *err = NULL;
991 struct got_tree_object *tree = NULL;
996 setproctitle("read tree object");
998 imsg_init(&ibuf, imsg_fds[1]);
1000 /* revoke access to most system calls */
1001 if (pledge("stdio", NULL) == -1) {
1002 err = got_error_from_errno();
1006 f = fdopen(obj_fd, "rb");
1008 err = got_error_from_errno();
1013 err = read_tree_object(&tree, obj, f);
1017 err = got_privsep_send_tree(&ibuf, tree);
1020 got_object_tree_close(tree);
1022 got_privsep_send_error(&ibuf, err);
1032 static const struct got_error *
1033 read_tree_object_privsep(struct got_tree_object **tree, struct got_object *obj,
1036 const struct got_error *err = NULL, *err_child = NULL;
1037 struct imsgbuf parent_ibuf;
1041 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1042 return got_error_from_errno();
1046 return got_error_from_errno();
1047 else if (pid == 0) {
1048 read_tree_object_privsep_child(obj, fd, imsg_fds);
1053 imsg_init(&parent_ibuf, imsg_fds[0]);
1054 err = got_privsep_recv_tree(tree, &parent_ibuf);
1055 imsg_clear(&parent_ibuf);
1056 err_child = wait_for_child(pid);
1058 return err ? err : err_child;
1061 const struct got_error *
1062 got_object_tree_open(struct got_tree_object **tree,
1063 struct got_repository *repo, struct got_object *obj)
1065 const struct got_error *err = NULL;
1067 if (obj->type != GOT_OBJ_TYPE_TREE)
1068 return got_error(GOT_ERR_OBJ_TYPE);
1070 if (obj->flags & GOT_OBJ_FLAG_PACKED) {
1073 err = got_packfile_extract_object_to_mem(&buf, &len, obj, repo);
1077 err = parse_tree_object(tree, buf, len);
1081 err = open_loose_object(&fd, obj, repo);
1084 err = read_tree_object_privsep(tree, obj, fd);
1091 got_object_tree_close(struct got_tree_object *tree)
1093 struct got_tree_entry *te;
1095 while (!SIMPLEQ_EMPTY(&tree->entries)) {
1096 te = SIMPLEQ_FIRST(&tree->entries);
1097 SIMPLEQ_REMOVE_HEAD(&tree->entries, entry);
1098 tree_entry_close(te);
1104 static const struct got_error *
1105 read_blob_object_privsep_child(int outfd, int infd, int imsg_fds[2])
1107 const struct got_error *err = NULL;
1108 struct imsgbuf ibuf;
1111 FILE *infile = NULL;
1113 setproctitle("read blob object");
1115 imsg_init(&ibuf, imsg_fds[1]);
1117 /* revoke access to most system calls */
1118 if (pledge("stdio", NULL) == -1) {
1119 err = got_error_from_errno();
1123 infile = fdopen(infd, "rb");
1124 if (infile == NULL) {
1125 err = got_error_from_errno();
1129 err = got_inflate_to_fd(&size, infile, outfd);
1134 err = got_privsep_send_blob(&ibuf, size);
1137 got_privsep_send_error(&ibuf, err);
1146 static const struct got_error *
1147 read_blob_object_privsep(size_t *size, int outfd, int infd)
1149 struct imsgbuf parent_ibuf;
1151 const struct got_error *err = NULL, *err_child = NULL;
1154 if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, imsg_fds) == -1)
1155 return got_error_from_errno();
1159 return got_error_from_errno();
1160 else if (pid == 0) {
1161 read_blob_object_privsep_child(outfd, infd, imsg_fds);
1166 imsg_init(&parent_ibuf, imsg_fds[0]);
1167 err = got_privsep_recv_blob(size, &parent_ibuf);
1168 imsg_clear(&parent_ibuf);
1169 err_child = wait_for_child(pid);
1171 if (lseek(outfd, SEEK_SET, 0) == -1)
1172 err = got_error_from_errno();
1173 return err ? err : err_child;
1176 const struct got_error *
1177 got_object_blob_open(struct got_blob_object **blob,
1178 struct got_repository *repo, struct got_object *obj, size_t blocksize)
1180 const struct got_error *err = NULL;
1182 if (obj->type != GOT_OBJ_TYPE_BLOB)
1183 return got_error(GOT_ERR_OBJ_TYPE);
1185 if (blocksize < obj->hdrlen)
1186 return got_error(GOT_ERR_NO_SPACE);
1188 *blob = calloc(1, sizeof(**blob));
1190 return got_error_from_errno();
1192 (*blob)->read_buf = calloc(1, blocksize);
1193 if ((*blob)->read_buf == NULL) {
1194 err = got_error_from_errno();
1197 if (obj->flags & GOT_OBJ_FLAG_PACKED) {
1198 err = got_packfile_extract_object(&((*blob)->f), obj, repo);
1206 err = open_loose_object(&infd, obj, repo);
1211 outfd = got_opentempfd();
1213 err = got_error_from_errno();
1218 err = read_blob_object_privsep(&size, outfd, infd);
1223 if (size != obj->hdrlen + obj->size) {
1224 err = got_error(GOT_ERR_PRIVSEP_LEN);
1229 if (fstat(outfd, &sb) == -1) {
1230 err = got_error_from_errno();
1235 if (sb.st_size != size) {
1236 err = got_error(GOT_ERR_PRIVSEP_LEN);
1241 (*blob)->f = fdopen(outfd, "rb");
1242 if ((*blob)->f == NULL) {
1243 err = got_error_from_errno();
1249 (*blob)->hdrlen = obj->hdrlen;
1250 (*blob)->blocksize = blocksize;
1251 memcpy(&(*blob)->id.sha1, obj->id.sha1, SHA1_DIGEST_LENGTH);
1257 free((*blob)->read_buf);
1265 got_object_blob_close(struct got_blob_object *blob)
1267 free(blob->read_buf);
1273 got_object_blob_id_str(struct got_blob_object *blob, char *buf, size_t size)
1275 return got_sha1_digest_to_str(blob->id.sha1, buf, size);
1279 got_object_blob_get_hdrlen(struct got_blob_object *blob)
1281 return blob->hdrlen;
1285 got_object_blob_get_read_buf(struct got_blob_object *blob)
1287 return blob->read_buf;
1290 const struct got_error *
1291 got_object_blob_read_block(size_t *outlenp, struct got_blob_object *blob)
1295 n = fread(blob->read_buf, 1, blob->blocksize, blob->f);
1296 if (n == 0 && ferror(blob->f))
1297 return got_ferror(blob->f, GOT_ERR_IO);