🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.29.3 / . / sha1-file.c
blob: dd65bd5c681513c1f7c9bf908dc9f8675e24a829 [file] [log] [blame]
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1/*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 *
6 * This handles basic git sha1 object files - packing, unpacking,
7 * creation etc.
8 */
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]9#include "cache.h"
Brandon Williamsb2141fc2017-06-14 18:07:36[diff] [blame]10#include "config.h"
Michael Haggerty6eac50d2012-11-05 08:41:22[diff] [blame]11#include "string-list.h"
Michael Haggerty697cc8e2014-10-01 10:28:42[diff] [blame]12#include "lockfile.h"
Junio C Hamano1f688552005-06-27 10:35:33[diff] [blame]13#include "delta.h"
Linus Torvaldsa733cb62005-06-28 21:21:02[diff] [blame]14#include "pack.h"
Peter Eriksen8e440252006-04-02 12:44:09[diff] [blame]15#include "blob.h"
16#include "commit.h"
Junio C Hamano4dd1fbc2011-05-08 08:47:35[diff] [blame]17#include "run-command.h"
Peter Eriksen8e440252006-04-02 12:44:09[diff] [blame]18#include "tag.h"
19#include "tree.h"
Nguyễn Thái Ngọc Duyc879daa2011-02-05 10:52:21[diff] [blame]20#include "tree-walk.h"
Linus Torvaldsf35a6d32007-04-10 04:20:29[diff] [blame]21#include "refs.h"
Nicolas Pitre70f5d5d2008-02-28 05:25:19[diff] [blame]22#include "pack-revindex.h"
Junio C Hamano628522e2007-12-29 10:05:47[diff] [blame]23#include "sha1-lookup.h"
Junio C Hamano568508e2011-10-28 21:48:40[diff] [blame]24#include "bulk-checkin.h"
Stefan Beller031dc922018-03-23 17:20:57[diff] [blame]25#include "repository.h"
Stefan Beller47f351e2018-04-12 00:21:06[diff] [blame]26#include "replace-object.h"
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]27#include "streaming.h"
Nguyễn Thái Ngọc Duy543c5ca2013-02-15 12:07:10[diff] [blame]28#include "dir.h"
Jeff King12d95ef2016-08-22 21:59:42[diff] [blame]29#include "list.h"
René Scharfec4c6eff2016-09-13 17:54:42[diff] [blame]30#include "mergesort.h"
Jeff Kingcf3c6352016-12-12 19:52:22[diff] [blame]31#include "quote.h"
Jonathan Tan4f39cd82017-08-18 22:20:16[diff] [blame]32#include "packfile.h"
Stefan Beller90c62152018-03-23 17:20:55[diff] [blame]33#include "object-store.h"
Christian Couderb14ed5a2019-06-25 13:40:31[diff] [blame]34#include "promisor-remote.h"
Pavel Roskine05db0f2007-01-10 04:07:11[diff] [blame]35
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]36/* The maximum size for an object header. */
37#define MAX_HEADER_LEN 32
38
brian m. carlsone1ccd7e2018-05-02 00:26:07[diff] [blame]39
40#define EMPTY_TREE_SHA1_BIN_LITERAL \
41 "\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60" \
42 "\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04"
brian m. carlson13eeedb2018-11-14 04:09:36[diff] [blame]43#define EMPTY_TREE_SHA256_BIN_LITERAL \
44 "\x6e\xf1\x9b\x41\x22\x5c\x53\x69\xf1\xc1" \
45 "\x04\xd4\x5d\x8d\x85\xef\xa9\xb0\x57\xb5" \
46 "\x3b\x14\xb4\xb9\xb9\x39\xdd\x74\xde\xcc" \
47 "\x53\x21"
brian m. carlsone1ccd7e2018-05-02 00:26:07[diff] [blame]48
49#define EMPTY_BLOB_SHA1_BIN_LITERAL \
50 "\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \
51 "\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91"
brian m. carlson13eeedb2018-11-14 04:09:36[diff] [blame]52#define EMPTY_BLOB_SHA256_BIN_LITERAL \
53 "\x47\x3a\x0f\x4c\x3b\xe8\xa9\x36\x81\xa2" \
54 "\x67\xe3\xb1\xe9\xa7\xdc\xda\x11\x85\x43" \
55 "\x6f\xe1\x41\xf7\x74\x91\x20\xa3\x03\x72" \
56 "\x18\x13"
brian m. carlsone1ccd7e2018-05-02 00:26:07[diff] [blame]57
brian m. carlson3e56e722015-12-06 22:16:35[diff] [blame]58const struct object_id null_oid;
brian m. carlsone1ccd7e2018-05-02 00:26:07[diff] [blame]59static const struct object_id empty_tree_oid = {
Jacob Keller8576fde2016-08-31 23:27:18[diff] [blame]60 EMPTY_TREE_SHA1_BIN_LITERAL
61};
brian m. carlsone1ccd7e2018-05-02 00:26:07[diff] [blame]62static const struct object_id empty_blob_oid = {
Jacob Keller8576fde2016-08-31 23:27:18[diff] [blame]63 EMPTY_BLOB_SHA1_BIN_LITERAL
64};
brian m. carlson13eeedb2018-11-14 04:09:36[diff] [blame]65static const struct object_id empty_tree_oid_sha256 = {
66 EMPTY_TREE_SHA256_BIN_LITERAL
67};
68static const struct object_id empty_blob_oid_sha256 = {
69 EMPTY_BLOB_SHA256_BIN_LITERAL
70};
Junio C Hamano88cd6212005-09-30 21:02:47[diff] [blame]71
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]72static void git_hash_sha1_init(git_hash_ctx *ctx)
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]73{
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]74 git_SHA1_Init(&ctx->sha1);
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]75}
76
brian m. carlson768e30e2020-02-22 20:17:27[diff] [blame]77static void git_hash_sha1_clone(git_hash_ctx *dst, const git_hash_ctx *src)
78{
79 git_SHA1_Clone(&dst->sha1, &src->sha1);
80}
81
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]82static void git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len)
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]83{
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]84 git_SHA1_Update(&ctx->sha1, data, len);
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]85}
86
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]87static void git_hash_sha1_final(unsigned char *hash, git_hash_ctx *ctx)
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]88{
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]89 git_SHA1_Final(hash, &ctx->sha1);
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]90}
91
brian m. carlson13eeedb2018-11-14 04:09:36[diff] [blame]92
93static void git_hash_sha256_init(git_hash_ctx *ctx)
94{
95 git_SHA256_Init(&ctx->sha256);
96}
97
brian m. carlson768e30e2020-02-22 20:17:27[diff] [blame]98static void git_hash_sha256_clone(git_hash_ctx *dst, const git_hash_ctx *src)
99{
100 git_SHA256_Clone(&dst->sha256, &src->sha256);
101}
102
brian m. carlson13eeedb2018-11-14 04:09:36[diff] [blame]103static void git_hash_sha256_update(git_hash_ctx *ctx, const void *data, size_t len)
104{
105 git_SHA256_Update(&ctx->sha256, data, len);
106}
107
108static void git_hash_sha256_final(unsigned char *hash, git_hash_ctx *ctx)
109{
110 git_SHA256_Final(hash, &ctx->sha256);
111}
112
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]113static void git_hash_unknown_init(git_hash_ctx *ctx)
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]114{
Nguyễn Thái Ngọc Duy1a07e592018-07-21 07:49:19[diff] [blame]115 BUG("trying to init unknown hash");
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]116}
117
brian m. carlson768e30e2020-02-22 20:17:27[diff] [blame]118static void git_hash_unknown_clone(git_hash_ctx *dst, const git_hash_ctx *src)
119{
120 BUG("trying to clone unknown hash");
121}
122
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]123static void git_hash_unknown_update(git_hash_ctx *ctx, const void *data, size_t len)
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]124{
Nguyễn Thái Ngọc Duy1a07e592018-07-21 07:49:19[diff] [blame]125 BUG("trying to update unknown hash");
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]126}
127
brian m. carlsonac73ced2018-02-01 02:18:38[diff] [blame]128static void git_hash_unknown_final(unsigned char *hash, git_hash_ctx *ctx)
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]129{
Nguyễn Thái Ngọc Duy1a07e592018-07-21 07:49:19[diff] [blame]130 BUG("trying to finalize unknown hash");
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]131}
132
133const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = {
134 {
135 NULL,
136 0x00000000,
137 0,
138 0,
brian m. carlsona2ce0a72018-11-14 04:09:33[diff] [blame]139 0,
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]140 git_hash_unknown_init,
brian m. carlson768e30e2020-02-22 20:17:27[diff] [blame]141 git_hash_unknown_clone,
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]142 git_hash_unknown_update,
143 git_hash_unknown_final,
144 NULL,
145 NULL,
146 },
147 {
brian m. carlson1ccf07c2018-10-22 02:43:31[diff] [blame]148 "sha1",
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]149 /* "sha1", big-endian */
150 0x73686131,
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]151 GIT_SHA1_RAWSZ,
152 GIT_SHA1_HEXSZ,
brian m. carlsona2ce0a72018-11-14 04:09:33[diff] [blame]153 GIT_SHA1_BLKSZ,
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]154 git_hash_sha1_init,
brian m. carlson768e30e2020-02-22 20:17:27[diff] [blame]155 git_hash_sha1_clone,
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]156 git_hash_sha1_update,
157 git_hash_sha1_final,
158 &empty_tree_oid,
159 &empty_blob_oid,
160 },
brian m. carlson13eeedb2018-11-14 04:09:36[diff] [blame]161 {
162 "sha256",
163 /* "s256", big-endian */
164 0x73323536,
165 GIT_SHA256_RAWSZ,
166 GIT_SHA256_HEXSZ,
167 GIT_SHA256_BLKSZ,
168 git_hash_sha256_init,
brian m. carlson768e30e2020-02-22 20:17:27[diff] [blame]169 git_hash_sha256_clone,
brian m. carlson13eeedb2018-11-14 04:09:36[diff] [blame]170 git_hash_sha256_update,
171 git_hash_sha256_final,
172 &empty_tree_oid_sha256,
173 &empty_blob_oid_sha256,
174 }
brian m. carlsonf50e7662017-11-12 21:28:52[diff] [blame]175};
176
brian m. carlsond8a92ce2018-05-02 00:25:54[diff] [blame]177const char *empty_tree_oid_hex(void)
178{
179 static char buf[GIT_MAX_HEXSZ + 1];
180 return oid_to_hex_r(buf, the_hash_algo->empty_tree);
181}
182
183const char *empty_blob_oid_hex(void)
184{
185 static char buf[GIT_MAX_HEXSZ + 1];
186 return oid_to_hex_r(buf, the_hash_algo->empty_blob);
187}
188
brian m. carlson2f90b9d2018-10-22 02:43:32[diff] [blame]189int hash_algo_by_name(const char *name)
190{
191 int i;
192 if (!name)
193 return GIT_HASH_UNKNOWN;
194 for (i = 1; i < GIT_HASH_NALGOS; i++)
195 if (!strcmp(name, hash_algos[i].name))
196 return i;
197 return GIT_HASH_UNKNOWN;
198}
199
200int hash_algo_by_id(uint32_t format_id)
201{
202 int i;
203 for (i = 1; i < GIT_HASH_NALGOS; i++)
204 if (format_id == hash_algos[i].format_id)
205 return i;
206 return GIT_HASH_UNKNOWN;
207}
208
brian m. carlson95399782019-02-19 00:05:17[diff] [blame]209int hash_algo_by_length(int len)
210{
211 int i;
212 for (i = 1; i < GIT_HASH_NALGOS; i++)
213 if (len == hash_algos[i].rawsz)
214 return i;
215 return GIT_HASH_UNKNOWN;
216}
brian m. carlson2f90b9d2018-10-22 02:43:32[diff] [blame]217
Nguyễn Thái Ngọc Duyc597ba82011-02-05 14:03:01[diff] [blame]218/*
219 * This is meant to hold a *small* number of objects that you would
Jeff Kingcb1c8d12019-01-07 08:33:52[diff] [blame]220 * want read_object_file() to be able to return, but yet you do not want
Nguyễn Thái Ngọc Duyc597ba82011-02-05 14:03:01[diff] [blame]221 * to write them into the object store (e.g. a browse-only
222 * application).
223 */
224static struct cached_object {
brian m. carlson62ba93e2018-05-02 00:26:03[diff] [blame]225 struct object_id oid;
Nguyễn Thái Ngọc Duyc597ba82011-02-05 14:03:01[diff] [blame]226 enum object_type type;
227 void *buf;
228 unsigned long size;
229} *cached_objects;
230static int cached_object_nr, cached_object_alloc;
231
232static struct cached_object empty_tree = {
brian m. carlson62ba93e2018-05-02 00:26:03[diff] [blame]233 { EMPTY_TREE_SHA1_BIN_LITERAL },
Nguyễn Thái Ngọc Duyc597ba82011-02-05 14:03:01[diff] [blame]234 OBJ_TREE,
235 "",
236 0
237};
238
brian m. carlson62ba93e2018-05-02 00:26:03[diff] [blame]239static struct cached_object *find_cached_object(const struct object_id *oid)
Nguyễn Thái Ngọc Duyc597ba82011-02-05 14:03:01[diff] [blame]240{
241 int i;
242 struct cached_object *co = cached_objects;
243
244 for (i = 0; i < cached_object_nr; i++, co++) {
Jeff King4a7e27e2018-08-28 21:22:40[diff] [blame]245 if (oideq(&co->oid, oid))
Nguyễn Thái Ngọc Duyc597ba82011-02-05 14:03:01[diff] [blame]246 return co;
247 }
Jeff King4a7e27e2018-08-28 21:22:40[diff] [blame]248 if (oideq(oid, the_hash_algo->empty_tree))
Nguyễn Thái Ngọc Duyc597ba82011-02-05 14:03:01[diff] [blame]249 return &empty_tree;
250 return NULL;
251}
252
Torsten Bögershausen94729352017-11-16 16:38:28[diff] [blame]253
Torsten Bögershausen8462ff42018-01-13 22:49:31[diff] [blame]254static int get_conv_flags(unsigned flags)
Torsten Bögershausen94729352017-11-16 16:38:28[diff] [blame]255{
256 if (flags & HASH_RENORMALIZE)
Torsten Bögershausen8462ff42018-01-13 22:49:31[diff] [blame]257 return CONV_EOL_RENORMALIZE;
Torsten Bögershausen94729352017-11-16 16:38:28[diff] [blame]258 else if (flags & HASH_WRITE_OBJECT)
Lars Schneider107642f2018-04-15 18:16:07[diff] [blame]259 return global_conv_flags_eol | CONV_WRITE_OBJECT;
Torsten Bögershausen94729352017-11-16 16:38:28[diff] [blame]260 else
Torsten Bögershausen8462ff42018-01-13 22:49:31[diff] [blame]261 return 0;
Torsten Bögershausen94729352017-11-16 16:38:28[diff] [blame]262}
263
264
Junio C Hamano90a64642011-03-11 00:02:50[diff] [blame]265int mkdir_in_gitdir(const char *path)
266{
267 if (mkdir(path, 0777)) {
268 int saved_errno = errno;
269 struct stat st;
270 struct strbuf sb = STRBUF_INIT;
271
272 if (errno != EEXIST)
273 return -1;
274 /*
275 * Are we looking at a path in a symlinked worktree
276 * whose original repository does not yet have it?
277 * e.g. .git/rr-cache pointing at its original
278 * repository in which the user hasn't performed any
279 * conflict resolution yet?
280 */
281 if (lstat(path, &st) || !S_ISLNK(st.st_mode) ||
282 strbuf_readlink(&sb, path, st.st_size) ||
283 !is_absolute_path(sb.buf) ||
284 mkdir(sb.buf, 0777)) {
285 strbuf_release(&sb);
286 errno = saved_errno;
287 return -1;
288 }
289 strbuf_release(&sb);
290 }
291 return adjust_shared_perm(path);
292}
293
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]294enum scld_error safe_create_leading_directories(char *path)
Junio C Hamanob2cb9422005-07-06 08:11:52[diff] [blame]295{
Michael Haggerty26c8ae22014-01-06 13:45:22[diff] [blame]296 char *next_component = path + offset_1st_component(path);
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]297 enum scld_error ret = SCLD_OK;
Jason Riedy67d42212006-02-10 01:56:13[diff] [blame]298
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]299 while (ret == SCLD_OK && next_component) {
Michael Haggertyf0502332014-01-06 13:45:20[diff] [blame]300 struct stat st;
Michael Haggerty0f527402014-01-18 23:40:44[diff] [blame]301 char *slash = next_component, slash_character;
Michael Haggertyf0502332014-01-06 13:45:20[diff] [blame]302
Michael Haggerty0f527402014-01-18 23:40:44[diff] [blame]303 while (*slash && !is_dir_sep(*slash))
304 slash++;
305
306 if (!*slash)
Junio C Hamanob2cb9422005-07-06 08:11:52[diff] [blame]307 break;
Michael Haggertybf10cf72014-01-06 13:45:23[diff] [blame]308
Michael Haggerty26c8ae22014-01-06 13:45:22[diff] [blame]309 next_component = slash + 1;
Michael Haggerty0f527402014-01-18 23:40:44[diff] [blame]310 while (is_dir_sep(*next_component))
Michael Haggertybf10cf72014-01-06 13:45:23[diff] [blame]311 next_component++;
Michael Haggerty26c8ae22014-01-06 13:45:22[diff] [blame]312 if (!*next_component)
Junio C Hamano5f0bdf52008-09-02 21:10:15[diff] [blame]313 break;
Michael Haggerty831651f2014-01-06 13:45:21[diff] [blame]314
Michael Haggerty0f527402014-01-18 23:40:44[diff] [blame]315 slash_character = *slash;
Michael Haggerty831651f2014-01-06 13:45:21[diff] [blame]316 *slash = '\0';
Jason Riedy67d42212006-02-10 01:56:13[diff] [blame]317 if (!stat(path, &st)) {
318 /* path exists */
Michael Haggerty204a0472017-01-06 16:22:25[diff] [blame]319 if (!S_ISDIR(st.st_mode)) {
320 errno = ENOTDIR;
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]321 ret = SCLD_EXISTS;
Michael Haggerty204a0472017-01-06 16:22:25[diff] [blame]322 }
Michael Haggerty53a39722014-01-06 13:45:19[diff] [blame]323 } else if (mkdir(path, 0777)) {
Steven Walter928734d2013-03-17 14:09:27[diff] [blame]324 if (errno == EEXIST &&
Michael Haggerty9e6f8852014-01-06 13:45:24[diff] [blame]325 !stat(path, &st) && S_ISDIR(st.st_mode))
Steven Walter928734d2013-03-17 14:09:27[diff] [blame]326 ; /* somebody created it since we checked */
Michael Haggerty18d37e82014-01-06 13:45:27[diff] [blame]327 else if (errno == ENOENT)
328 /*
329 * Either mkdir() failed because
330 * somebody just pruned the containing
331 * directory, or stat() failed because
332 * the file that was in our way was
333 * just removed. Either way, inform
334 * the caller that it might be worth
335 * trying again:
336 */
337 ret = SCLD_VANISHED;
Michael Haggerty9e6f8852014-01-06 13:45:24[diff] [blame]338 else
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]339 ret = SCLD_FAILED;
Michael Haggerty53a39722014-01-06 13:45:19[diff] [blame]340 } else if (adjust_shared_perm(path)) {
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]341 ret = SCLD_PERMS;
Jason Riedy67d42212006-02-10 01:56:13[diff] [blame]342 }
Michael Haggerty0f527402014-01-18 23:40:44[diff] [blame]343 *slash = slash_character;
Junio C Hamanob2cb9422005-07-06 08:11:52[diff] [blame]344 }
Michael Haggerty9e6f8852014-01-06 13:45:24[diff] [blame]345 return ret;
Junio C Hamanob2cb9422005-07-06 08:11:52[diff] [blame]346}
347
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]348enum scld_error safe_create_leading_directories_const(const char *path)
Jeff King8e21d632008-06-25 05:41:34[diff] [blame]349{
Michael Haggerty02944302017-01-06 16:22:24[diff] [blame]350 int save_errno;
Jeff King8e21d632008-06-25 05:41:34[diff] [blame]351 /* path points to cache entries, so xstrdup before messing with it */
352 char *buf = xstrdup(path);
Michael Haggerty0be05212014-01-06 13:45:25[diff] [blame]353 enum scld_error result = safe_create_leading_directories(buf);
Michael Haggerty02944302017-01-06 16:22:24[diff] [blame]354
355 save_errno = errno;
Jeff King8e21d632008-06-25 05:41:34[diff] [blame]356 free(buf);
Michael Haggerty02944302017-01-06 16:22:24[diff] [blame]357 errno = save_errno;
Jeff King8e21d632008-06-25 05:41:34[diff] [blame]358 return result;
359}
360
Michael Haggerty177978f2017-01-06 16:22:26[diff] [blame]361int raceproof_create_file(const char *path, create_file_fn fn, void *cb)
362{
363 /*
364 * The number of times we will try to remove empty directories
365 * in the way of path. This is only 1 because if another
366 * process is racily creating directories that conflict with
367 * us, we don't want to fight against them.
368 */
369 int remove_directories_remaining = 1;
370
371 /*
372 * The number of times that we will try to create the
373 * directories containing path. We are willing to attempt this
374 * more than once, because another process could be trying to
375 * clean up empty directories at the same time as we are
376 * trying to create them.
377 */
378 int create_directories_remaining = 3;
379
380 /* A scratch copy of path, filled lazily if we need it: */
381 struct strbuf path_copy = STRBUF_INIT;
382
383 int ret, save_errno;
384
385 /* Sanity check: */
386 assert(*path);
387
388retry_fn:
389 ret = fn(path, cb);
390 save_errno = errno;
391 if (!ret)
392 goto out;
393
394 if (errno == EISDIR && remove_directories_remaining-- > 0) {
395 /*
396 * A directory is in the way. Maybe it is empty; try
397 * to remove it:
398 */
399 if (!path_copy.len)
400 strbuf_addstr(&path_copy, path);
401
402 if (!remove_dir_recursively(&path_copy, REMOVE_DIR_EMPTY_ONLY))
403 goto retry_fn;
404 } else if (errno == ENOENT && create_directories_remaining-- > 0) {
405 /*
406 * Maybe the containing directory didn't exist, or
407 * maybe it was just deleted by a process that is
408 * racing with us to clean up empty directories. Try
409 * to create it:
410 */
411 enum scld_error scld_result;
412
413 if (!path_copy.len)
414 strbuf_addstr(&path_copy, path);
415
416 do {
417 scld_result = safe_create_leading_directories(path_copy.buf);
418 if (scld_result == SCLD_OK)
419 goto retry_fn;
420 } while (scld_result == SCLD_VANISHED && create_directories_remaining-- > 0);
421 }
422
423out:
424 strbuf_release(&path_copy);
425 errno = save_errno;
426 return ret;
427}
428
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]429static void fill_loose_path(struct strbuf *buf, const struct object_id *oid)
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]430{
431 int i;
brian m. carlson94b5e092018-07-16 01:28:07[diff] [blame]432 for (i = 0; i < the_hash_algo->rawsz; i++) {
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]433 static char hex[] = "0123456789abcdef";
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]434 unsigned int val = oid->hash[i];
Jeff Kingf7b77742016-10-03 20:36:09[diff] [blame]435 strbuf_addch(buf, hex[val >> 4]);
436 strbuf_addch(buf, hex[val & 0xf]);
Jeff Kingafbba2f2016-10-03 20:35:55[diff] [blame]437 if (!i)
Jeff Kingf7b77742016-10-03 20:36:09[diff] [blame]438 strbuf_addch(buf, '/');
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]439 }
440}
441
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]442static const char *odb_loose_path(struct object_directory *odb,
443 struct strbuf *buf,
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]444 const struct object_id *oid)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]445{
Jeff Kingb69fb862018-11-12 14:48:56[diff] [blame]446 strbuf_reset(buf);
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]447 strbuf_addstr(buf, odb->path);
Christian Couder34498472018-01-18 10:08:54[diff] [blame]448 strbuf_addch(buf, '/');
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]449 fill_loose_path(buf, oid);
Jeff King38dbe5f2016-10-03 20:36:04[diff] [blame]450 return buf->buf;
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]451}
452
Jeff Kingf3f043a2018-11-12 14:49:35[diff] [blame]453const char *loose_object_path(struct repository *r, struct strbuf *buf,
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]454 const struct object_id *oid)
Jeff Kingf3f043a2018-11-12 14:49:35[diff] [blame]455{
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]456 return odb_loose_path(r->objects->odb, buf, oid);
Jeff Kingf3f043a2018-11-12 14:49:35[diff] [blame]457}
458
Junio C Hamanoddd5d052005-05-08 20:51:13[diff] [blame]459/*
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]460 * Return non-zero iff the path is usable as an alternate object database.
461 */
Stefan Beller13313fc2018-03-23 17:21:03[diff] [blame]462static int alt_odb_usable(struct raw_object_store *o,
463 struct strbuf *path,
464 const char *normalized_objdir)
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]465{
Jeff King263db402018-11-12 14:48:47[diff] [blame]466 struct object_directory *odb;
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]467
468 /* Detect cases where alternate disappeared */
469 if (!is_directory(path->buf)) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]470 error(_("object directory %s does not exist; "
471 "check .git/objects/info/alternates"),
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]472 path->buf);
473 return 0;
474 }
475
476 /*
477 * Prevent the common mistake of listing the same
478 * thing twice, or object directory itself.
479 */
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]480 for (odb = o->odb; odb; odb = odb->next) {
Jeff King263db402018-11-12 14:48:47[diff] [blame]481 if (!fspathcmp(path->buf, odb->path))
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]482 return 0;
483 }
484 if (!fspathcmp(path->buf, normalized_objdir))
485 return 0;
486
487 return 1;
488}
489
490/*
Junio C Hamanoddd5d052005-05-08 20:51:13[diff] [blame]491 * Prepare alternate object database registry.
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]492 *
493 * The variable alt_odb_list points at the list of struct
Jeff King263db402018-11-12 14:48:47[diff] [blame]494 * object_directory. The elements on this list come from
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]495 * non-empty elements from colon separated ALTERNATE_DB_ENVIRONMENT
496 * environment variable, and $GIT_OBJECT_DIRECTORY/info/alternates,
Junio C Hamano1494e032005-12-05 06:48:43[diff] [blame]497 * whose contents is similar to that environment variable but can be
498 * LF separated. Its base points at a statically allocated buffer that
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]499 * contains "/the/directory/corresponding/to/.git/objects/...", while
500 * its name points just after the slash at the end of ".git/objects/"
501 * in the example above, and has enough space to hold 40-byte hex
502 * SHA1, an extra slash for the first level indirection, and the
503 * terminating NUL.
Junio C Hamanoddd5d052005-05-08 20:51:13[diff] [blame]504 */
Stefan Beller77f012e2018-03-23 17:21:08[diff] [blame]505static void read_info_alternates(struct repository *r,
506 const char *relative_base,
507 int depth);
508static int link_alt_odb_entry(struct repository *r, const char *entry,
Stefan Bellercfc62fc2018-03-23 17:21:04[diff] [blame]509 const char *relative_base, int depth, const char *normalized_objdir)
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]510{
Jeff King263db402018-11-12 14:48:47[diff] [blame]511 struct object_directory *ent;
Hui Wang5bdf0a82011-09-07 10:37:47[diff] [blame]512 struct strbuf pathbuf = STRBUF_INIT;
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]513
Johannes Sixt85dadc32007-11-13 20:05:00[diff] [blame]514 if (!is_absolute_path(entry) && relative_base) {
Brandon Williams4ac90062016-12-12 18:16:55[diff] [blame]515 strbuf_realpath(&pathbuf, relative_base, 1);
Hui Wang5bdf0a82011-09-07 10:37:47[diff] [blame]516 strbuf_addch(&pathbuf, '/');
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]517 }
Michael Haggerty6eac50d2012-11-05 08:41:22[diff] [blame]518 strbuf_addstr(&pathbuf, entry);
Hui Wang5bdf0a82011-09-07 10:37:47[diff] [blame]519
Jeff King37a95862016-11-08 04:50:17[diff] [blame]520 if (strbuf_normalize_path(&pathbuf) < 0 && relative_base) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]521 error(_("unable to normalize alternate object path: %s"),
Jeff King670c3592016-10-03 20:34:17[diff] [blame]522 pathbuf.buf);
523 strbuf_release(&pathbuf);
524 return -1;
525 }
Hui Wang5bdf0a82011-09-07 10:37:47[diff] [blame]526
527 /*
528 * The trailing slash after the directory name is given by
529 * this function at the end. Remove duplicates.
530 */
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]531 while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/')
532 strbuf_setlen(&pathbuf, pathbuf.len - 1);
Hui Wang5bdf0a82011-09-07 10:37:47[diff] [blame]533
Stefan Beller77f012e2018-03-23 17:21:08[diff] [blame]534 if (!alt_odb_usable(r->objects, &pathbuf, normalized_objdir)) {
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]535 strbuf_release(&pathbuf);
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]536 return -1;
537 }
538
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]539 ent = xcalloc(1, sizeof(*ent));
540 ent->path = xstrdup(pathbuf.buf);
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]541
542 /* add the alternate entry */
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]543 *r->objects->odb_tail = ent;
544 r->objects->odb_tail = &(ent->next);
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]545 ent->next = NULL;
546
547 /* recursively add alternates */
Stefan Beller77f012e2018-03-23 17:21:08[diff] [blame]548 read_info_alternates(r, pathbuf.buf, depth + 1);
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]549
Jeff King4ea82472016-10-03 20:34:48[diff] [blame]550 strbuf_release(&pathbuf);
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]551 return 0;
552}
553
Jeff Kingcf3c6352016-12-12 19:52:22[diff] [blame]554static const char *parse_alt_odb_entry(const char *string,
555 int sep,
556 struct strbuf *out)
557{
558 const char *end;
559
560 strbuf_reset(out);
561
562 if (*string == '#') {
563 /* comment; consume up to next separator */
564 end = strchrnul(string, sep);
565 } else if (*string == '"' && !unquote_c_style(out, string, &end)) {
566 /*
567 * quoted path; unquote_c_style has copied the
568 * data for us and set "end". Broken quoting (e.g.,
569 * an entry that doesn't end with a quote) falls
570 * back to the unquoted case below.
571 */
572 } else {
573 /* normal, unquoted path */
574 end = strchrnul(string, sep);
575 strbuf_add(out, string, end - string);
576 }
577
578 if (*end)
579 end++;
580 return end;
581}
582
Stefan Beller77f012e2018-03-23 17:21:08[diff] [blame]583static void link_alt_odb_entries(struct repository *r, const char *alt,
584 int sep, const char *relative_base, int depth)
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]585{
Ephrim Khong539e7502014-07-15 11:29:45[diff] [blame]586 struct strbuf objdirbuf = STRBUF_INIT;
Jeff Kingcf3c6352016-12-12 19:52:22[diff] [blame]587 struct strbuf entry = STRBUF_INIT;
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]588
Jeff Kingf28e3662017-11-12 10:27:39[diff] [blame]589 if (!alt || !*alt)
590 return;
591
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]592 if (depth > 5) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]593 error(_("%s: ignoring alternate object stores, nesting too deep"),
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]594 relative_base);
595 return;
596 }
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]597
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]598 strbuf_add_absolute_path(&objdirbuf, r->objects->odb->path);
Jeff King670c3592016-10-03 20:34:17[diff] [blame]599 if (strbuf_normalize_path(&objdirbuf) < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]600 die(_("unable to normalize object directory: %s"),
Jeff King670c3592016-10-03 20:34:17[diff] [blame]601 objdirbuf.buf);
Ephrim Khong539e7502014-07-15 11:29:45[diff] [blame]602
Jeff Kingcf3c6352016-12-12 19:52:22[diff] [blame]603 while (*alt) {
604 alt = parse_alt_odb_entry(alt, sep, &entry);
605 if (!entry.len)
Junio C Hamano9577e7e2005-08-17 01:22:05[diff] [blame]606 continue;
Stefan Beller77f012e2018-03-23 17:21:08[diff] [blame]607 link_alt_odb_entry(r, entry.buf,
Stefan Bellercfc62fc2018-03-23 17:21:04[diff] [blame]608 relative_base, depth, objdirbuf.buf);
Junio C Hamano9577e7e2005-08-17 01:22:05[diff] [blame]609 }
Jeff Kingcf3c6352016-12-12 19:52:22[diff] [blame]610 strbuf_release(&entry);
Ephrim Khong539e7502014-07-15 11:29:45[diff] [blame]611 strbuf_release(&objdirbuf);
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]612}
613
Stefan Beller77f012e2018-03-23 17:21:08[diff] [blame]614static void read_info_alternates(struct repository *r,
615 const char *relative_base,
616 int depth)
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]617{
Jeff King5015f012015-08-19 18:12:45[diff] [blame]618 char *path;
Jeff Kingdc732bd2017-09-19 19:41:07[diff] [blame]619 struct strbuf buf = STRBUF_INIT;
Jason Riedyc7c81b32005-08-23 20:34:07[diff] [blame]620
Jeff King5015f012015-08-19 18:12:45[diff] [blame]621 path = xstrfmt("%s/info/alternates", relative_base);
Jeff Kingdc732bd2017-09-19 19:41:07[diff] [blame]622 if (strbuf_read_file(&buf, path, 1024) < 0) {
Jeff Kingf0f7beb2017-09-19 19:41:10[diff] [blame]623 warn_on_fopen_errors(path);
Jeff Kingdc732bd2017-09-19 19:41:07[diff] [blame]624 free(path);
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]625 return;
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]626 }
Junio C Hamanod5a63b92005-08-15 00:25:57[diff] [blame]627
Stefan Beller77f012e2018-03-23 17:21:08[diff] [blame]628 link_alt_odb_entries(r, buf.buf, '\n', relative_base, depth);
Jeff Kingdc732bd2017-09-19 19:41:07[diff] [blame]629 strbuf_release(&buf);
630 free(path);
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]631}
632
Daniel Barkalowbef70b22008-04-17 23:32:30[diff] [blame]633void add_to_alternates_file(const char *reference)
634{
Martin Ågrenf132a122017-10-05 20:32:03[diff] [blame]635 struct lock_file lock = LOCK_INIT;
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]636 char *alts = git_pathdup("objects/info/alternates");
637 FILE *in, *out;
Martin Ågrenf132a122017-10-05 20:32:03[diff] [blame]638 int found = 0;
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]639
Martin Ågrenf132a122017-10-05 20:32:03[diff] [blame]640 hold_lock_file_for_update(&lock, alts, LOCK_DIE_ON_ERROR);
641 out = fdopen_lock_file(&lock, "w");
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]642 if (!out)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]643 die_errno(_("unable to fdopen alternates lockfile"));
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]644
645 in = fopen(alts, "r");
646 if (in) {
647 struct strbuf line = STRBUF_INIT;
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]648
Junio C Hamano3f163962015-10-28 20:29:24[diff] [blame]649 while (strbuf_getline(&line, in) != EOF) {
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]650 if (!strcmp(reference, line.buf)) {
651 found = 1;
652 break;
653 }
654 fprintf_or_die(out, "%s\n", line.buf);
655 }
656
657 strbuf_release(&line);
658 fclose(in);
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]659 }
660 else if (errno != ENOENT)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]661 die_errno(_("unable to read alternates file"));
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]662
Martin Ågrenf132a122017-10-05 20:32:03[diff] [blame]663 if (found) {
664 rollback_lock_file(&lock);
665 } else {
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]666 fprintf_or_die(out, "%s\n", reference);
Martin Ågrenf132a122017-10-05 20:32:03[diff] [blame]667 if (commit_lock_file(&lock))
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]668 die_errno(_("unable to move new alternates file into place"));
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]669 if (the_repository->objects->loaded_alternates)
Stefan Beller93d8d1e2018-03-23 17:21:06[diff] [blame]670 link_alt_odb_entries(the_repository, reference,
671 '\n', NULL, 0);
Jeff King77b9b1d2015-08-10 09:34:46[diff] [blame]672 }
673 free(alts);
Daniel Barkalowbef70b22008-04-17 23:32:30[diff] [blame]674}
675
Jeff Kinga5b34d22016-10-03 20:35:03[diff] [blame]676void add_to_alternates_memory(const char *reference)
677{
678 /*
679 * Make sure alternates are initialized, or else our entry may be
680 * overwritten when they are.
681 */
Stefan Beller0b209032018-03-23 17:21:07[diff] [blame]682 prepare_alt_odb(the_repository);
Jeff Kinga5b34d22016-10-03 20:35:03[diff] [blame]683
Stefan Beller93d8d1e2018-03-23 17:21:06[diff] [blame]684 link_alt_odb_entries(the_repository, reference,
685 '\n', NULL, 0);
Jeff Kinga5b34d22016-10-03 20:35:03[diff] [blame]686}
687
Stefan Beller9eeea7d2016-08-15 21:53:24[diff] [blame]688/*
689 * Compute the exact path an alternate is at and returns it. In case of
690 * error NULL is returned and the human readable error is added to `err`
Robert P. J. Dayefde7b72018-06-03 14:32:50[diff] [blame]691 * `path` may be relative and should point to $GIT_DIR.
Stefan Beller9eeea7d2016-08-15 21:53:24[diff] [blame]692 * `err` must not be null.
693 */
694char *compute_alternate_path(const char *path, struct strbuf *err)
695{
696 char *ref_git = NULL;
Alexandr Miloslavskiy4530a852020-03-10 13:11:23[diff] [blame]697 const char *repo;
Stefan Beller9eeea7d2016-08-15 21:53:24[diff] [blame]698 int seen_error = 0;
699
Alexandr Miloslavskiy4530a852020-03-10 13:11:23[diff] [blame]700 ref_git = real_pathdup(path, 0);
701 if (!ref_git) {
Stefan Beller9eeea7d2016-08-15 21:53:24[diff] [blame]702 seen_error = 1;
703 strbuf_addf(err, _("path '%s' does not exist"), path);
704 goto out;
Alexandr Miloslavskiy4530a852020-03-10 13:11:23[diff] [blame]705 }
Stefan Beller9eeea7d2016-08-15 21:53:24[diff] [blame]706
707 repo = read_gitfile(ref_git);
708 if (!repo)
709 repo = read_gitfile(mkpath("%s/.git", ref_git));
710 if (repo) {
711 free(ref_git);
712 ref_git = xstrdup(repo);
713 }
714
715 if (!repo && is_directory(mkpath("%s/.git/objects", ref_git))) {
716 char *ref_git_git = mkpathdup("%s/.git", ref_git);
717 free(ref_git);
718 ref_git = ref_git_git;
719 } else if (!is_directory(mkpath("%s/objects", ref_git))) {
720 struct strbuf sb = STRBUF_INIT;
721 seen_error = 1;
722 if (get_common_dir(&sb, ref_git)) {
723 strbuf_addf(err,
724 _("reference repository '%s' as a linked "
725 "checkout is not supported yet."),
726 path);
727 goto out;
728 }
729
730 strbuf_addf(err, _("reference repository '%s' is not a "
731 "local repository."), path);
732 goto out;
733 }
734
735 if (!access(mkpath("%s/shallow", ref_git), F_OK)) {
736 strbuf_addf(err, _("reference repository '%s' is shallow"),
737 path);
738 seen_error = 1;
739 goto out;
740 }
741
742 if (!access(mkpath("%s/info/grafts", ref_git), F_OK)) {
743 strbuf_addf(err,
744 _("reference repository '%s' is grafted"),
745 path);
746 seen_error = 1;
747 goto out;
748 }
749
750out:
751 if (seen_error) {
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46[diff] [blame]752 FREE_AND_NULL(ref_git);
Stefan Beller9eeea7d2016-08-15 21:53:24[diff] [blame]753 }
754
755 return ref_git;
756}
757
Jeff King709dfa62019-07-01 13:17:40[diff] [blame]758static void fill_alternate_refs_command(struct child_process *cmd,
759 const char *repo_path)
760{
761 const char *value;
762
763 if (!git_config_get_value("core.alternateRefsCommand", &value)) {
764 cmd->use_shell = 1;
765
Jeff Kingc972bf42020-07-28 20:25:12[diff] [blame]766 strvec_push(&cmd->args, value);
767 strvec_push(&cmd->args, repo_path);
Jeff King709dfa62019-07-01 13:17:40[diff] [blame]768 } else {
769 cmd->git_cmd = 1;
770
Jeff Kingc972bf42020-07-28 20:25:12[diff] [blame]771 strvec_pushf(&cmd->args, "--git-dir=%s", repo_path);
772 strvec_push(&cmd->args, "for-each-ref");
773 strvec_push(&cmd->args, "--format=%(objectname)");
Jeff King709dfa62019-07-01 13:17:40[diff] [blame]774
775 if (!git_config_get_value("core.alternateRefsPrefixes", &value)) {
Jeff Kingc972bf42020-07-28 20:25:12[diff] [blame]776 strvec_push(&cmd->args, "--");
777 strvec_split(&cmd->args, value);
Jeff King709dfa62019-07-01 13:17:40[diff] [blame]778 }
779 }
780
781 cmd->env = local_repo_env;
782 cmd->out = -1;
783}
784
785static void read_alternate_refs(const char *path,
786 alternate_ref_fn *cb,
787 void *data)
788{
789 struct child_process cmd = CHILD_PROCESS_INIT;
790 struct strbuf line = STRBUF_INIT;
791 FILE *fh;
792
793 fill_alternate_refs_command(&cmd, path);
794
795 if (start_command(&cmd))
796 return;
797
798 fh = xfdopen(cmd.out, "r");
799 while (strbuf_getline_lf(&line, fh) != EOF) {
800 struct object_id oid;
801 const char *p;
802
803 if (parse_oid_hex(line.buf, &oid, &p) || *p) {
804 warning(_("invalid line while parsing alternate refs: %s"),
805 line.buf);
806 break;
807 }
808
809 cb(&oid, data);
810 }
811
812 fclose(fh);
813 finish_command(&cmd);
René Scharfe86ad3ea2019-08-07 11:15:25[diff] [blame]814 strbuf_release(&line);
Jeff King709dfa62019-07-01 13:17:40[diff] [blame]815}
816
817struct alternate_refs_data {
818 alternate_ref_fn *fn;
819 void *data;
820};
821
822static int refs_from_alternate_cb(struct object_directory *e,
823 void *data)
824{
825 struct strbuf path = STRBUF_INIT;
826 size_t base_len;
827 struct alternate_refs_data *cb = data;
828
829 if (!strbuf_realpath(&path, e->path, 0))
830 goto out;
831 if (!strbuf_strip_suffix(&path, "/objects"))
832 goto out;
833 base_len = path.len;
834
835 /* Is this a git repository with refs? */
836 strbuf_addstr(&path, "/refs");
837 if (!is_directory(path.buf))
838 goto out;
839 strbuf_setlen(&path, base_len);
840
841 read_alternate_refs(path.buf, cb->fn, cb->data);
842
843out:
844 strbuf_release(&path);
845 return 0;
846}
847
848void for_each_alternate_ref(alternate_ref_fn fn, void *data)
849{
850 struct alternate_refs_data cb;
851 cb.fn = fn;
852 cb.data = data;
853 foreach_alt_odb(refs_from_alternate_cb, &cb);
854}
855
Jeff Kingfe1b2262014-10-15 22:33:13[diff] [blame]856int foreach_alt_odb(alt_odb_fn fn, void *cb)
Junio C Hamanod79796b2008-09-09 08:27:10[diff] [blame]857{
Jeff King263db402018-11-12 14:48:47[diff] [blame]858 struct object_directory *ent;
Jeff Kingfe1b2262014-10-15 22:33:13[diff] [blame]859 int r = 0;
Junio C Hamanod79796b2008-09-09 08:27:10[diff] [blame]860
Stefan Beller0b209032018-03-23 17:21:07[diff] [blame]861 prepare_alt_odb(the_repository);
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]862 for (ent = the_repository->objects->odb->next; ent; ent = ent->next) {
Jeff Kingfe1b2262014-10-15 22:33:13[diff] [blame]863 r = fn(ent, cb);
864 if (r)
865 break;
866 }
867 return r;
Junio C Hamanod79796b2008-09-09 08:27:10[diff] [blame]868}
869
Stefan Beller13068bf2018-03-23 17:21:09[diff] [blame]870void prepare_alt_odb(struct repository *r)
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]871{
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]872 if (r->objects->loaded_alternates)
Shawn O. Pearce7dc24aa2007-05-26 05:24:40[diff] [blame]873 return;
874
Stefan Beller13068bf2018-03-23 17:21:09[diff] [blame]875 link_alt_odb_entries(r, r->objects->alternate_db, PATH_SEP, NULL, 0);
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]876
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]877 read_info_alternates(r, r->objects->odb->path, 0);
878 r->objects->loaded_alternates = 1;
Martin Waitzc2f493a2006-05-07 18:19:21[diff] [blame]879}
880
Jeff King3096b2e2015-07-08 20:33:52[diff] [blame]881/* Returns 1 if we have successfully freshened the file, 0 otherwise. */
Jeff King33d42212014-10-15 22:42:22[diff] [blame]882static int freshen_file(const char *fn)
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]883{
luciano.rocha@booking.com312cd762020-04-14 14:27:26[diff] [blame]884 return !utime(fn, NULL);
Brandon Casey0f4dc142008-11-10 05:59:57[diff] [blame]885}
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]886
Jeff King3096b2e2015-07-08 20:33:52[diff] [blame]887/*
888 * All of the check_and_freshen functions return 1 if the file exists and was
889 * freshened (if freshening was requested), 0 otherwise. If they return
890 * 0, you should not assume that it is safe to skip a write of the object (it
891 * either does not exist on disk, or has a stale mtime and may be subject to
892 * pruning).
893 */
Christian Couder6a5e6f52017-02-27 18:00:11[diff] [blame]894int check_and_freshen_file(const char *fn, int freshen)
Jeff King33d42212014-10-15 22:42:22[diff] [blame]895{
896 if (access(fn, F_OK))
897 return 0;
Jeff King3096b2e2015-07-08 20:33:52[diff] [blame]898 if (freshen && !freshen_file(fn))
Jeff King33d42212014-10-15 22:42:22[diff] [blame]899 return 0;
900 return 1;
901}
902
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]903static int check_and_freshen_odb(struct object_directory *odb,
904 const struct object_id *oid,
905 int freshen)
906{
907 static struct strbuf path = STRBUF_INIT;
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]908 odb_loose_path(odb, &path, oid);
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]909 return check_and_freshen_file(path.buf, freshen);
910}
911
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]912static int check_and_freshen_local(const struct object_id *oid, int freshen)
Jeff King33d42212014-10-15 22:42:22[diff] [blame]913{
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]914 return check_and_freshen_odb(the_repository->objects->odb, oid, freshen);
Jeff King33d42212014-10-15 22:42:22[diff] [blame]915}
916
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]917static int check_and_freshen_nonlocal(const struct object_id *oid, int freshen)
Brandon Casey0f4dc142008-11-10 05:59:57[diff] [blame]918{
Jeff King263db402018-11-12 14:48:47[diff] [blame]919 struct object_directory *odb;
Jeff Kingf3f043a2018-11-12 14:49:35[diff] [blame]920
Stefan Beller0b209032018-03-23 17:21:07[diff] [blame]921 prepare_alt_odb(the_repository);
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]922 for (odb = the_repository->objects->odb->next; odb; odb = odb->next) {
923 if (check_and_freshen_odb(odb, oid, freshen))
Linus Torvaldsc529d752008-06-14 18:43:01[diff] [blame]924 return 1;
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]925 }
Linus Torvaldsc529d752008-06-14 18:43:01[diff] [blame]926 return 0;
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]927}
928
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]929static int check_and_freshen(const struct object_id *oid, int freshen)
Jeff King33d42212014-10-15 22:42:22[diff] [blame]930{
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]931 return check_and_freshen_local(oid, freshen) ||
932 check_and_freshen_nonlocal(oid, freshen);
Jeff King33d42212014-10-15 22:42:22[diff] [blame]933}
934
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]935int has_loose_object_nonlocal(const struct object_id *oid)
Jeff King33d42212014-10-15 22:42:22[diff] [blame]936{
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]937 return check_and_freshen_nonlocal(oid, 0);
Jeff King33d42212014-10-15 22:42:22[diff] [blame]938}
939
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]940static int has_loose_object(const struct object_id *oid)
Brandon Casey0f4dc142008-11-10 05:59:57[diff] [blame]941{
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]942 return check_and_freshen(oid, 0);
Brandon Casey0f4dc142008-11-10 05:59:57[diff] [blame]943}
944
Steffen Prohaska02710222014-08-26 15:23:23[diff] [blame]945static void mmap_limit_check(size_t length)
946{
947 static size_t limit = 0;
948 if (!limit) {
949 limit = git_env_ulong("GIT_MMAP_LIMIT", 0);
950 if (!limit)
951 limit = SIZE_MAX;
952 }
953 if (length > limit)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]954 die(_("attempting to mmap %"PRIuMAX" over limit %"PRIuMAX),
Steffen Prohaska02710222014-08-26 15:23:23[diff] [blame]955 (uintmax_t)length, (uintmax_t)limit);
956}
957
Jeff King15708562015-05-28 07:56:15[diff] [blame]958void *xmmap_gently(void *start, size_t length,
959 int prot, int flags, int fd, off_t offset)
Jonathan Nieder58ecbd52010-11-06 11:44:11[diff] [blame]960{
Steffen Prohaska02710222014-08-26 15:23:23[diff] [blame]961 void *ret;
962
963 mmap_limit_check(length);
964 ret = mmap(start, length, prot, flags, fd, offset);
Jeff King9827d4c2019-08-12 20:50:21[diff] [blame]965 if (ret == MAP_FAILED && !length)
966 ret = NULL;
Jonathan Nieder58ecbd52010-11-06 11:44:11[diff] [blame]967 return ret;
968}
969
Jeff King15708562015-05-28 07:56:15[diff] [blame]970void *xmmap(void *start, size_t length,
971 int prot, int flags, int fd, off_t offset)
972{
973 void *ret = xmmap_gently(start, length, prot, flags, fd, offset);
974 if (ret == MAP_FAILED)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]975 die_errno(_("mmap failed"));
Jeff King15708562015-05-28 07:56:15[diff] [blame]976 return ret;
977}
978
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]979/*
980 * With an in-core object data in "map", rehash it to make sure the
Jeff Kingcb1c8d12019-01-07 08:33:52[diff] [blame]981 * object name actually matches "oid" to detect object corruption.
982 * With "map" == NULL, try reading the object named with "oid" using
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]983 * the streaming interface and rehash it to do the same.
984 */
Matheus Tavaresb98d1882020-01-30 20:32:23[diff] [blame]985int check_object_signature(struct repository *r, const struct object_id *oid,
986 void *map, unsigned long size, const char *type)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]987{
Patryk Obaraf070fac2018-01-28 00:13:13[diff] [blame]988 struct object_id real_oid;
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]989 enum object_type obj_type;
990 struct git_istream *st;
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]991 git_hash_ctx c;
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]992 char hdr[MAX_HEADER_LEN];
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]993 int hdrlen;
994
995 if (map) {
Matheus Tavaresb98d1882020-01-30 20:32:23[diff] [blame]996 hash_object_file(r->hash_algo, map, size, type, &real_oid);
Jeff King9001dc22018-08-28 21:22:48[diff] [blame]997 return !oideq(oid, &real_oid) ? -1 : 0;
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]998 }
999
Matheus Tavaresb98d1882020-01-30 20:32:23[diff] [blame]1000 st = open_istream(r, oid, &obj_type, &size, NULL);
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]1001 if (!st)
1002 return -1;
1003
1004 /* Generate the header */
Torsten Bögershausenca473ce2018-11-11 07:05:04[diff] [blame]1005 hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %"PRIuMAX , type_name(obj_type), (uintmax_t)size) + 1;
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]1006
1007 /* Sha1.. */
Matheus Tavaresb98d1882020-01-30 20:32:23[diff] [blame]1008 r->hash_algo->init_fn(&c);
1009 r->hash_algo->update_fn(&c, hdr, hdrlen);
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]1010 for (;;) {
1011 char buf[1024 * 16];
1012 ssize_t readlen = read_istream(st, buf, sizeof(buf));
1013
Jeff Kingf54fac52013-03-25 20:17:17[diff] [blame]1014 if (readlen < 0) {
1015 close_istream(st);
1016 return -1;
1017 }
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]1018 if (!readlen)
1019 break;
Matheus Tavaresb98d1882020-01-30 20:32:23[diff] [blame]1020 r->hash_algo->update_fn(&c, buf, readlen);
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]1021 }
Matheus Tavaresb98d1882020-01-30 20:32:23[diff] [blame]1022 r->hash_algo->final_fn(real_oid.hash, &c);
Nguyễn Thái Ngọc Duy090ea122012-03-07 10:54:18[diff] [blame]1023 close_istream(st);
Jeff King9001dc22018-08-28 21:22:48[diff] [blame]1024 return !oideq(oid, &real_oid) ? -1 : 0;
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1025}
1026
Junio C Hamano1b8ac5e2016-10-28 13:23:07[diff] [blame]1027int git_open_cloexec(const char *name, int flags)
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1028{
Junio C Hamano1e3001a2016-10-31 17:41:41[diff] [blame]1029 int fd;
1030 static int o_cloexec = O_CLOEXEC;
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1031
Junio C Hamano1e3001a2016-10-31 17:41:41[diff] [blame]1032 fd = open(name, flags | o_cloexec);
1033 if ((o_cloexec & O_CLOEXEC) && fd < 0 && errno == EINVAL) {
Lars Schneidercd66ada2016-10-24 18:02:59[diff] [blame]1034 /* Try again w/o O_CLOEXEC: the kernel might not support it */
Junio C Hamano1e3001a2016-10-31 17:41:41[diff] [blame]1035 o_cloexec &= ~O_CLOEXEC;
1036 fd = open(name, flags | o_cloexec);
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1037 }
Junio C Hamano1e3001a2016-10-31 17:41:41[diff] [blame]1038
Eric Wong9fb94952017-07-15 18:55:40[diff] [blame]1039#if defined(F_GETFD) && defined(F_SETFD) && defined(FD_CLOEXEC)
Junio C Hamano1e3001a2016-10-31 17:41:41[diff] [blame]1040 {
1041 static int fd_cloexec = FD_CLOEXEC;
1042
1043 if (!o_cloexec && 0 <= fd && fd_cloexec) {
1044 /* Opened w/o O_CLOEXEC? try with fcntl(2) to add it */
Eric Wong9fb94952017-07-15 18:55:40[diff] [blame]1045 int flags = fcntl(fd, F_GETFD);
1046 if (fcntl(fd, F_SETFD, flags | fd_cloexec))
Junio C Hamano1e3001a2016-10-31 17:41:41[diff] [blame]1047 fd_cloexec = 0;
1048 }
1049 }
1050#endif
Junio C Hamano1b8ac5e2016-10-28 13:23:07[diff] [blame]1051 return fd;
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1052}
1053
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1054/*
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1055 * Find "oid" as a loose object in the local repository or in an alternate.
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1056 * Returns 0 on success, negative on failure.
1057 *
1058 * The "path" out-parameter will give the path of the object we found (if any).
1059 * Note that it may point to static storage and is only valid until another
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1060 * call to stat_loose_object().
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1061 */
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1062static int stat_loose_object(struct repository *r, const struct object_id *oid,
1063 struct stat *st, const char **path)
Jeff King052fe5e2013-07-12 06:30:48[diff] [blame]1064{
Jeff King263db402018-11-12 14:48:47[diff] [blame]1065 struct object_directory *odb;
Christian Couderea657732018-01-17 17:54:54[diff] [blame]1066 static struct strbuf buf = STRBUF_INIT;
Jeff King052fe5e2013-07-12 06:30:48[diff] [blame]1067
Stefan Bellerd2607fa2018-03-23 17:21:17[diff] [blame]1068 prepare_alt_odb(r);
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]1069 for (odb = r->objects->odb; odb; odb = odb->next) {
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1070 *path = odb_loose_path(odb, &buf, oid);
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1071 if (!lstat(*path, st))
Jeff King052fe5e2013-07-12 06:30:48[diff] [blame]1072 return 0;
1073 }
1074
1075 return -1;
1076}
1077
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1078/*
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1079 * Like stat_loose_object(), but actually open the object and return the
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1080 * descriptor. See the caveats on the "path" parameter above.
1081 */
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1082static int open_loose_object(struct repository *r,
1083 const struct object_id *oid, const char **path)
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1084{
1085 int fd;
Jeff King263db402018-11-12 14:48:47[diff] [blame]1086 struct object_directory *odb;
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]1087 int most_interesting_errno = ENOENT;
Christian Couderea657732018-01-17 17:54:54[diff] [blame]1088 static struct strbuf buf = STRBUF_INIT;
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1089
Stefan Bellerec7283e2018-03-23 17:21:18[diff] [blame]1090 prepare_alt_odb(r);
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]1091 for (odb = r->objects->odb; odb; odb = odb->next) {
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1092 *path = odb_loose_path(odb, &buf, oid);
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1093 fd = git_open(*path);
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1094 if (fd >= 0)
1095 return fd;
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]1096
Jeff Kingd6c8a052014-05-15 08:54:06[diff] [blame]1097 if (most_interesting_errno == ENOENT)
1098 most_interesting_errno = errno;
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1099 }
Jeff Kingd6c8a052014-05-15 08:54:06[diff] [blame]1100 errno = most_interesting_errno;
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1101 return -1;
1102}
1103
Jeff King61c77112018-11-12 14:54:42[diff] [blame]1104static int quick_has_loose(struct repository *r,
Jeff Kingd7a24572019-01-07 08:37:29[diff] [blame]1105 const struct object_id *oid)
Jeff King61c77112018-11-12 14:54:42[diff] [blame]1106{
Jeff King61c77112018-11-12 14:54:42[diff] [blame]1107 struct object_directory *odb;
1108
Jeff King61c77112018-11-12 14:54:42[diff] [blame]1109 prepare_alt_odb(r);
1110 for (odb = r->objects->odb; odb; odb = odb->next) {
Jeff Kingd7a24572019-01-07 08:37:29[diff] [blame]1111 if (oid_array_lookup(odb_loose_cache(odb, oid), oid) >= 0)
Jeff King61c77112018-11-12 14:54:42[diff] [blame]1112 return 1;
1113 }
1114 return 0;
1115}
1116
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]1117/*
1118 * Map the loose object at "path" if it is not NULL, or the path found by
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1119 * searching for a loose object named "oid".
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]1120 */
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1121static void *map_loose_object_1(struct repository *r, const char *path,
1122 const struct object_id *oid, unsigned long *size)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1123{
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1124 void *map;
Linus Torvalds144bde72005-04-23 18:09:32[diff] [blame]1125 int fd;
Junio C Hamanoace15342005-05-07 07:38:04[diff] [blame]1126
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]1127 if (path)
1128 fd = git_open(path);
1129 else
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1130 fd = open_loose_object(r, oid, &path);
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1131 map = NULL;
1132 if (fd >= 0) {
1133 struct stat st;
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1134
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1135 if (!fstat(fd, &st)) {
1136 *size = xsize_t(st.st_size);
Matthieu Moy33e42de2012-02-06 16:24:52[diff] [blame]1137 if (!*size) {
1138 /* mmap() is forbidden on empty files */
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1139 error(_("object file %s is empty"), path);
René Scharfe68819252019-01-07 16:48:02[diff] [blame]1140 close(fd);
Matthieu Moy33e42de2012-02-06 16:24:52[diff] [blame]1141 return NULL;
1142 }
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1143 map = xmmap(NULL, *size, PROT_READ, MAP_PRIVATE, fd, 0);
Linus Torvalds144bde72005-04-23 18:09:32[diff] [blame]1144 }
Linus Torvalds44d1c192008-06-14 18:32:37[diff] [blame]1145 close(fd);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1146 }
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1147 return map;
1148}
1149
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1150void *map_loose_object(struct repository *r,
1151 const struct object_id *oid,
1152 unsigned long *size)
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]1153{
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1154 return map_loose_object_1(r, NULL, oid, size);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]1155}
1156
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1157static int unpack_loose_short_header(git_zstream *stream,
1158 unsigned char *map, unsigned long mapsize,
1159 void *buffer, unsigned long bufsiz)
Linus Torvaldsc4483572005-06-02 00:54:59[diff] [blame]1160{
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1161 int ret;
1162
Linus Torvaldsc4483572005-06-02 00:54:59[diff] [blame]1163 /* Get the data stream */
1164 memset(stream, 0, sizeof(*stream));
1165 stream->next_in = map;
1166 stream->avail_in = mapsize;
1167 stream->next_out = buffer;
Linus Torvalds93821bd2006-07-11 19:48:08[diff] [blame]1168 stream->avail_out = bufsiz;
Linus Torvaldsc4483572005-06-02 00:54:59[diff] [blame]1169
Linus Torvalds39c68542009-01-08 03:54:47[diff] [blame]1170 git_inflate_init(stream);
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1171 obj_read_unlock();
1172 ret = git_inflate(stream, 0);
1173 obj_read_lock();
1174
1175 return ret;
Linus Torvaldsc4483572005-06-02 00:54:59[diff] [blame]1176}
1177
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1178int unpack_loose_header(git_zstream *stream,
1179 unsigned char *map, unsigned long mapsize,
1180 void *buffer, unsigned long bufsiz)
Junio C Hamanod21f8422016-09-26 04:29:04[diff] [blame]1181{
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1182 int status = unpack_loose_short_header(stream, map, mapsize,
1183 buffer, bufsiz);
Junio C Hamanod21f8422016-09-26 04:29:04[diff] [blame]1184
1185 if (status < Z_OK)
1186 return status;
1187
1188 /* Make sure we have the terminating NUL */
1189 if (!memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1190 return -1;
1191 return 0;
1192}
1193
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1194static int unpack_loose_header_to_strbuf(git_zstream *stream, unsigned char *map,
1195 unsigned long mapsize, void *buffer,
1196 unsigned long bufsiz, struct strbuf *header)
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1197{
1198 int status;
1199
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1200 status = unpack_loose_short_header(stream, map, mapsize, buffer, bufsiz);
Junio C Hamanod21f8422016-09-26 04:29:04[diff] [blame]1201 if (status < Z_OK)
1202 return -1;
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1203
1204 /*
1205 * Check if entire header is unpacked in the first iteration.
1206 */
1207 if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1208 return 0;
1209
1210 /*
1211 * buffer[0..bufsiz] was not large enough. Copy the partial
1212 * result out to header, and then append the result of further
1213 * reading the stream.
1214 */
1215 strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
1216 stream->next_out = buffer;
1217 stream->avail_out = bufsiz;
1218
1219 do {
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1220 obj_read_unlock();
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1221 status = git_inflate(stream, 0);
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1222 obj_read_lock();
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1223 strbuf_add(header, buffer, stream->next_out - (unsigned char *)buffer);
1224 if (memchr(buffer, '\0', stream->next_out - (unsigned char *)buffer))
1225 return 0;
1226 stream->next_out = buffer;
1227 stream->avail_out = bufsiz;
1228 } while (status != Z_STREAM_END);
1229 return -1;
1230}
1231
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1232static void *unpack_loose_rest(git_zstream *stream,
1233 void *buffer, unsigned long size,
1234 const struct object_id *oid)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1235{
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1236 int bytes = strlen(buffer) + 1;
Ilari Liusvaara3aee68a2010-01-26 18:24:14[diff] [blame]1237 unsigned char *buf = xmallocz(size);
Linus Torvalds93821bd2006-07-11 19:48:08[diff] [blame]1238 unsigned long n;
Junio C Hamano7efbff72007-03-05 08:21:37[diff] [blame]1239 int status = Z_OK;
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1240
Linus Torvalds93821bd2006-07-11 19:48:08[diff] [blame]1241 n = stream->total_out - bytes;
1242 if (n > size)
1243 n = size;
1244 memcpy(buf, (char *) buffer + bytes, n);
1245 bytes = n;
Linus Torvalds456cdf62007-03-20 05:49:53[diff] [blame]1246 if (bytes <= size) {
1247 /*
1248 * The above condition must be (bytes <= size), not
1249 * (bytes < size). In other words, even though we
Junio C Hamanoccf5ace2011-05-15 19:16:03[diff] [blame]1250 * expect no more output and set avail_out to zero,
Linus Torvalds456cdf62007-03-20 05:49:53[diff] [blame]1251 * the input zlib stream may have bytes that express
1252 * "this concludes the stream", and we *do* want to
1253 * eat that input.
1254 *
1255 * Otherwise we would not be able to test that we
1256 * consumed all the input to reach the expected size;
1257 * we also want to check that zlib tells us that all
1258 * went well with status == Z_STREAM_END at the end.
1259 */
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1260 stream->next_out = buf + bytes;
1261 stream->avail_out = size - bytes;
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1262 while (status == Z_OK) {
1263 obj_read_unlock();
Linus Torvalds39c68542009-01-08 03:54:47[diff] [blame]1264 status = git_inflate(stream, Z_FINISH);
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1265 obj_read_lock();
1266 }
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1267 }
Linus Torvalds456cdf62007-03-20 05:49:53[diff] [blame]1268 if (status == Z_STREAM_END && !stream->avail_in) {
Linus Torvalds39c68542009-01-08 03:54:47[diff] [blame]1269 git_inflate_end(stream);
Junio C Hamano7efbff72007-03-05 08:21:37[diff] [blame]1270 return buf;
1271 }
1272
1273 if (status < 0)
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1274 error(_("corrupt loose object '%s'"), oid_to_hex(oid));
Junio C Hamano7efbff72007-03-05 08:21:37[diff] [blame]1275 else if (stream->avail_in)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1276 error(_("garbage at end of loose object '%s'"),
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1277 oid_to_hex(oid));
Junio C Hamano7efbff72007-03-05 08:21:37[diff] [blame]1278 free(buf);
1279 return NULL;
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1280}
1281
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1282/*
1283 * We used to just use "sscanf()", but that's actually way
1284 * too permissive for what we want to check. So do an anal
1285 * object header parse by hand.
1286 */
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1287static int parse_loose_header_extended(const char *hdr, struct object_info *oi,
1288 unsigned int flags)
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1289{
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1290 const char *type_buf = hdr;
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1291 unsigned long size;
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1292 int type, type_len = 0;
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1293
1294 /*
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1295 * The type can be of any size but is followed by
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1296 * a space.
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1297 */
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1298 for (;;) {
1299 char c = *hdr++;
Junio C Hamanod21f8422016-09-26 04:29:04[diff] [blame]1300 if (!c)
1301 return -1;
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1302 if (c == ' ')
1303 break;
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1304 type_len++;
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1305 }
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1306
1307 type = type_from_string_gently(type_buf, type_len, 1);
Brandon Williams6ca32f42018-02-14 18:59:23[diff] [blame]1308 if (oi->type_name)
1309 strbuf_add(oi->type_name, type_buf, type_len);
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1310 /*
1311 * Set type to 0 if its an unknown object and
Ville Skyttä2e3a16b2016-08-09 08:53:38[diff] [blame]1312 * we're obtaining the type using '--allow-unknown-type'
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1313 * option.
1314 */
Jonathan Tan19fc5e82017-06-22 00:40:18[diff] [blame]1315 if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE) && (type < 0))
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1316 type = 0;
1317 else if (type < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1318 die(_("invalid object type"));
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1319 if (oi->typep)
1320 *oi->typep = type;
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1321
1322 /*
1323 * The length must follow immediately, and be in canonical
1324 * decimal format (ie "010" is not valid).
1325 */
1326 size = *hdr++ - '0';
1327 if (size > 9)
1328 return -1;
1329 if (size) {
1330 for (;;) {
1331 unsigned long c = *hdr - '0';
1332 if (c > 9)
1333 break;
1334 hdr++;
1335 size = size * 10 + c;
1336 }
1337 }
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1338
1339 if (oi->sizep)
1340 *oi->sizep = size;
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1341
1342 /*
1343 * The length must be followed by a zero byte
1344 */
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1345 return *hdr ? -1 : type;
1346}
1347
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1348int parse_loose_header(const char *hdr, unsigned long *sizep)
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1349{
Jeff King27b5c1a2016-08-11 09:24:35[diff] [blame]1350 struct object_info oi = OBJECT_INFO_INIT;
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1351
1352 oi.sizep = sizep;
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1353 return parse_loose_header_extended(hdr, &oi, 0);
Linus Torvalds5180cac2005-06-02 14:57:25[diff] [blame]1354}
1355
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1356static int loose_object_info(struct repository *r,
1357 const struct object_id *oid,
1358 struct object_info *oi, int flags)
Junio C Hamano65c2e0c2005-06-02 22:20:54[diff] [blame]1359{
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1360 int status = 0;
1361 unsigned long mapsize;
Junio C Hamano65c2e0c2005-06-02 22:20:54[diff] [blame]1362 void *map;
Junio C Hamanoef49a7a2011-06-10 18:52:15[diff] [blame]1363 git_zstream stream;
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]1364 char hdr[MAX_HEADER_LEN];
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1365 struct strbuf hdrbuf = STRBUF_INIT;
Jonathan Tanc84a1f32017-06-22 00:40:21[diff] [blame]1366 unsigned long size_scratch;
Junio C Hamano65c2e0c2005-06-02 22:20:54[diff] [blame]1367
Jeff Kingb99b6bc2020-02-24 04:36:56[diff] [blame]1368 if (oi->delta_base_oid)
1369 oidclr(oi->delta_base_oid);
Jeff King5d642e72013-12-21 14:24:20[diff] [blame]1370
Jeff King052fe5e2013-07-12 06:30:48[diff] [blame]1371 /*
1372 * If we don't care about type or size, then we don't
Junio C Hamano4ef8d1d2013-11-06 18:00:57[diff] [blame]1373 * need to look inside the object at all. Note that we
1374 * do not optimize out the stat call, even if the
1375 * caller doesn't care about the disk-size, since our
1376 * return value implicitly indicates whether the
1377 * object even exists.
Jeff King052fe5e2013-07-12 06:30:48[diff] [blame]1378 */
Brandon Williams6ca32f42018-02-14 18:59:23[diff] [blame]1379 if (!oi->typep && !oi->type_name && !oi->sizep && !oi->contentp) {
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1380 const char *path;
Junio C Hamano4ef8d1d2013-11-06 18:00:57[diff] [blame]1381 struct stat st;
Jeff King61c77112018-11-12 14:54:42[diff] [blame]1382 if (!oi->disk_sizep && (flags & OBJECT_INFO_QUICK))
Jeff Kingd7a24572019-01-07 08:37:29[diff] [blame]1383 return quick_has_loose(r, oid) ? 0 : -1;
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1384 if (stat_loose_object(r, oid, &st, &path) < 0)
Junio C Hamano4ef8d1d2013-11-06 18:00:57[diff] [blame]1385 return -1;
1386 if (oi->disk_sizep)
Jeff King23c339c2013-07-12 06:37:53[diff] [blame]1387 *oi->disk_sizep = st.st_size;
Jeff King052fe5e2013-07-12 06:30:48[diff] [blame]1388 return 0;
1389 }
1390
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1391 map = map_loose_object(r, oid, &mapsize);
Johannes Schindelinf0df4ed2006-11-27 23:18:55[diff] [blame]1392 if (!map)
Thomas Rastdbea72a2013-05-30 20:00:22[diff] [blame]1393 return -1;
Jonathan Tanc84a1f32017-06-22 00:40:21[diff] [blame]1394
1395 if (!oi->sizep)
1396 oi->sizep = &size_scratch;
1397
Jeff King23c339c2013-07-12 06:37:53[diff] [blame]1398 if (oi->disk_sizep)
1399 *oi->disk_sizep = mapsize;
Jonathan Tan19fc5e82017-06-22 00:40:18[diff] [blame]1400 if ((flags & OBJECT_INFO_ALLOW_UNKNOWN_TYPE)) {
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1401 if (unpack_loose_header_to_strbuf(&stream, map, mapsize, hdr, sizeof(hdr), &hdrbuf) < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1402 status = error(_("unable to unpack %s header with --allow-unknown-type"),
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1403 oid_to_hex(oid));
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1404 } else if (unpack_loose_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1405 status = error(_("unable to unpack %s header"),
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1406 oid_to_hex(oid));
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1407 if (status < 0)
1408 ; /* Do nothing */
1409 else if (hdrbuf.len) {
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1410 if ((status = parse_loose_header_extended(hdrbuf.buf, oi, flags)) < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1411 status = error(_("unable to parse %s header with --allow-unknown-type"),
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1412 oid_to_hex(oid));
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1413 } else if ((status = parse_loose_header_extended(hdr, oi, flags)) < 0)
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1414 status = error(_("unable to parse %s header"), oid_to_hex(oid));
Jonathan Tanc84a1f32017-06-22 00:40:21[diff] [blame]1415
Jeff Kingb3ea7dd2017-10-05 05:59:52[diff] [blame]1416 if (status >= 0 && oi->contentp) {
Jeff King00a77602019-01-07 08:37:02[diff] [blame]1417 *oi->contentp = unpack_loose_rest(&stream, hdr,
1418 *oi->sizep, oid);
Jeff Kingb3ea7dd2017-10-05 05:59:52[diff] [blame]1419 if (!*oi->contentp) {
1420 git_inflate_end(&stream);
1421 status = -1;
1422 }
1423 } else
Jonathan Tanc84a1f32017-06-22 00:40:21[diff] [blame]1424 git_inflate_end(&stream);
1425
Junio C Hamano65c2e0c2005-06-02 22:20:54[diff] [blame]1426 munmap(map, mapsize);
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1427 if (status && oi->typep)
Jeff King23c339c2013-07-12 06:37:53[diff] [blame]1428 *oi->typep = status;
Jonathan Tanc84a1f32017-06-22 00:40:21[diff] [blame]1429 if (oi->sizep == &size_scratch)
1430 oi->sizep = NULL;
Karthik Nayak46f03442015-05-03 14:29:59[diff] [blame]1431 strbuf_release(&hdrbuf);
Jonathan Tan3ab0fb02017-08-11 20:36:14[diff] [blame]1432 oi->whence = OI_LOOSE;
Jeff King93cff9a2017-04-01 08:05:21[diff] [blame]1433 return (status < 0) ? status : 0;
Junio C Hamano65c2e0c2005-06-02 22:20:54[diff] [blame]1434}
1435
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1436int obj_read_use_lock = 0;
1437pthread_mutex_t obj_read_mutex;
1438
1439void enable_obj_read_lock(void)
1440{
1441 if (obj_read_use_lock)
1442 return;
1443
1444 obj_read_use_lock = 1;
1445 init_recursive_mutex(&obj_read_mutex);
1446}
1447
1448void disable_obj_read_lock(void)
1449{
1450 if (!obj_read_use_lock)
1451 return;
1452
1453 obj_read_use_lock = 0;
1454 pthread_mutex_destroy(&obj_read_mutex);
1455}
1456
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1457int fetch_if_missing = 1;
1458
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1459static int do_oid_object_info_extended(struct repository *r,
1460 const struct object_id *oid,
1461 struct object_info *oi, unsigned flags)
Johannes Schindelinf0df4ed2006-11-27 23:18:55[diff] [blame]1462{
Jonathan Tancd585e22017-06-22 00:40:23[diff] [blame]1463 static struct object_info blank_oi = OBJECT_INFO_INIT;
Jonathan Tan9c8a2942020-01-02 20:16:30[diff] [blame]1464 struct cached_object *co;
Johannes Schindelinf0df4ed2006-11-27 23:18:55[diff] [blame]1465 struct pack_entry e;
Jeff King5b086402013-07-12 06:34:57[diff] [blame]1466 int rtype;
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1467 const struct object_id *real = oid;
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1468 int already_retried = 0;
Johannes Schindelinf0df4ed2006-11-27 23:18:55[diff] [blame]1469
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1470
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1471 if (flags & OBJECT_INFO_LOOKUP_REPLACE)
Stefan Beller9d983542018-04-25 18:21:06[diff] [blame]1472 real = lookup_replace_object(r, oid);
Johannes Schindelinf0df4ed2006-11-27 23:18:55[diff] [blame]1473
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1474 if (is_null_oid(real))
Jeff King87b5e232017-11-21 23:17:39[diff] [blame]1475 return -1;
1476
Jonathan Tancd585e22017-06-22 00:40:23[diff] [blame]1477 if (!oi)
1478 oi = &blank_oi;
1479
Jonathan Tan9c8a2942020-01-02 20:16:30[diff] [blame]1480 co = find_cached_object(real);
1481 if (co) {
1482 if (oi->typep)
1483 *(oi->typep) = co->type;
1484 if (oi->sizep)
1485 *(oi->sizep) = co->size;
1486 if (oi->disk_sizep)
1487 *(oi->disk_sizep) = 0;
Jeff Kingb99b6bc2020-02-24 04:36:56[diff] [blame]1488 if (oi->delta_base_oid)
1489 oidclr(oi->delta_base_oid);
Jonathan Tan9c8a2942020-01-02 20:16:30[diff] [blame]1490 if (oi->type_name)
1491 strbuf_addstr(oi->type_name, type_name(co->type));
1492 if (oi->contentp)
1493 *oi->contentp = xmemdupz(co->buf, co->size);
1494 oi->whence = OI_CACHED;
1495 return 0;
Nguyễn Thái Ngọc Duyc4d99862011-02-05 14:03:02[diff] [blame]1496 }
1497
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1498 while (1) {
Junio C Hamano42c8ce12018-05-30 05:04:10[diff] [blame]1499 if (find_pack_entry(r, real, &e))
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1500 break;
1501
Takuto Ikuta024aa462018-03-14 06:32:42[diff] [blame]1502 if (flags & OBJECT_INFO_IGNORE_LOOSE)
1503 return -1;
1504
Steven Grimmddd63e62008-08-05 20:08:41[diff] [blame]1505 /* Most likely it's a loose object. */
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1506 if (!loose_object_info(r, real, oi, flags))
Jeff King5b086402013-07-12 06:34:57[diff] [blame]1507 return 0;
Steven Grimmddd63e62008-08-05 20:08:41[diff] [blame]1508
1509 /* Not a loose object; someone else may have just packed it. */
Jonathan Tan2b7750c2018-03-13 15:30:29[diff] [blame]1510 if (!(flags & OBJECT_INFO_QUICK)) {
Stefan Beller9d983542018-04-25 18:21:06[diff] [blame]1511 reprepare_packed_git(r);
Junio C Hamano42c8ce12018-05-30 05:04:10[diff] [blame]1512 if (find_pack_entry(r, real, &e))
Jonathan Tan2b7750c2018-03-13 15:30:29[diff] [blame]1513 break;
1514 }
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1515
1516 /* Check if it is a missing object */
Christian Couderb14ed5a2019-06-25 13:40:31[diff] [blame]1517 if (fetch_if_missing && has_promisor_remote() &&
Jonathan Tan0f4a4fb2019-03-29 21:39:27[diff] [blame]1518 !already_retried && r == the_repository &&
Derrick Stolee31f52562019-05-28 15:19:07[diff] [blame]1519 !(flags & OBJECT_INFO_SKIP_FETCH_OBJECT)) {
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1520 /*
Christian Couderb14ed5a2019-06-25 13:40:31[diff] [blame]1521 * TODO Investigate checking promisor_remote_get_direct()
1522 * TODO return value and stopping on error here.
1523 * TODO Pass a repository struct through
1524 * promisor_remote_get_direct(), such that arbitrary
1525 * repositories work.
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1526 */
Christian Couderb14ed5a2019-06-25 13:40:31[diff] [blame]1527 promisor_remote_get_direct(r, real, 1);
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1528 already_retried = 1;
1529 continue;
Jonathan Tandfdd4af2017-06-22 00:40:22[diff] [blame]1530 }
Jonathan Tan8b4c0102017-12-08 15:27:14[diff] [blame]1531
1532 return -1;
Johannes Schindelinf0df4ed2006-11-27 23:18:55[diff] [blame]1533 }
Nicolas Pitre3d77d872008-10-29 23:02:47[diff] [blame]1534
Jonathan Tancd585e22017-06-22 00:40:23[diff] [blame]1535 if (oi == &blank_oi)
1536 /*
1537 * We know that the caller doesn't actually need the
1538 * information below, so return early.
1539 */
1540 return 0;
Stefan Beller9d983542018-04-25 18:21:06[diff] [blame]1541 rtype = packed_object_info(r, e.p, e.offset, oi);
Jeff King412916e2013-07-12 06:32:25[diff] [blame]1542 if (rtype < 0) {
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1543 mark_bad_packed_object(e.p, real->hash);
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1544 return do_oid_object_info_extended(r, real, oi, 0);
Jonathan Tan3ab0fb02017-08-11 20:36:14[diff] [blame]1545 } else if (oi->whence == OI_PACKED) {
Junio C Hamano9a490592011-05-12 22:51:38[diff] [blame]1546 oi->u.packed.offset = e.offset;
1547 oi->u.packed.pack = e.p;
1548 oi->u.packed.is_delta = (rtype == OBJ_REF_DELTA ||
1549 rtype == OBJ_OFS_DELTA);
Nicolas Pitre3d77d872008-10-29 23:02:47[diff] [blame]1550 }
Nicolas Pitre3d77d872008-10-29 23:02:47[diff] [blame]1551
Jeff King5b086402013-07-12 06:34:57[diff] [blame]1552 return 0;
Johannes Schindelinf0df4ed2006-11-27 23:18:55[diff] [blame]1553}
1554
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1555int oid_object_info_extended(struct repository *r, const struct object_id *oid,
1556 struct object_info *oi, unsigned flags)
1557{
1558 int ret;
1559 obj_read_lock();
1560 ret = do_oid_object_info_extended(r, oid, oi, flags);
1561 obj_read_unlock();
1562 return ret;
1563}
1564
1565
Christian Couder3fc0dca2013-10-26 22:34:30[diff] [blame]1566/* returns enum object_type or negative */
Stefan Beller9d983542018-04-25 18:21:06[diff] [blame]1567int oid_object_info(struct repository *r,
1568 const struct object_id *oid,
1569 unsigned long *sizep)
Junio C Hamano9a490592011-05-12 22:51:38[diff] [blame]1570{
Jeff King5b086402013-07-12 06:34:57[diff] [blame]1571 enum object_type type;
Jeff King27b5c1a2016-08-11 09:24:35[diff] [blame]1572 struct object_info oi = OBJECT_INFO_INIT;
Junio C Hamano9a490592011-05-12 22:51:38[diff] [blame]1573
Jeff King5b086402013-07-12 06:34:57[diff] [blame]1574 oi.typep = &type;
Junio C Hamano9a490592011-05-12 22:51:38[diff] [blame]1575 oi.sizep = sizep;
Stefan Beller9d983542018-04-25 18:21:06[diff] [blame]1576 if (oid_object_info_extended(r, oid, &oi,
1577 OBJECT_INFO_LOOKUP_REPLACE) < 0)
Jeff King5b086402013-07-12 06:34:57[diff] [blame]1578 return -1;
1579 return type;
Junio C Hamano9a490592011-05-12 22:51:38[diff] [blame]1580}
1581
Stefan Beller1b9b5c62018-10-16 23:35:32[diff] [blame]1582static void *read_object(struct repository *r,
Junio C Hamanocba595a2019-02-07 06:05:27[diff] [blame]1583 const struct object_id *oid, enum object_type *type,
Jonathan Tanf1d81302017-08-18 22:20:30[diff] [blame]1584 unsigned long *size)
1585{
1586 struct object_info oi = OBJECT_INFO_INIT;
1587 void *content;
1588 oi.typep = type;
1589 oi.sizep = size;
1590 oi.contentp = &content;
1591
Junio C Hamanocba595a2019-02-07 06:05:27[diff] [blame]1592 if (oid_object_info_extended(r, oid, &oi, 0) < 0)
Jonathan Tanf1d81302017-08-18 22:20:30[diff] [blame]1593 return NULL;
1594 return content;
1595}
1596
Patryk Obara829e5c32018-01-28 00:13:11[diff] [blame]1597int pretend_object_file(void *buf, unsigned long len, enum object_type type,
1598 struct object_id *oid)
Junio C Hamanod66b37b2007-02-05 05:42:38[diff] [blame]1599{
1600 struct cached_object *co;
1601
Matheus Tavares2dcde202020-01-30 20:32:22[diff] [blame]1602 hash_object_file(the_hash_algo, buf, len, type_name(type), oid);
Jonathan Tana64d2aa2020-07-21 22:50:20[diff] [blame]1603 if (has_object_file_with_flags(oid, OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT) ||
1604 find_cached_object(oid))
Junio C Hamanod66b37b2007-02-05 05:42:38[diff] [blame]1605 return 0;
Dmitry S. Dolzhenkoc7353962014-03-03 22:32:02[diff] [blame]1606 ALLOC_GROW(cached_objects, cached_object_nr + 1, cached_object_alloc);
Junio C Hamanod66b37b2007-02-05 05:42:38[diff] [blame]1607 co = &cached_objects[cached_object_nr++];
1608 co->size = len;
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1609 co->type = type;
Junio C Hamanoefa13f72007-02-16 01:02:06[diff] [blame]1610 co->buf = xmalloc(len);
1611 memcpy(co->buf, buf, len);
brian m. carlson62ba93e2018-05-02 00:26:03[diff] [blame]1612 oidcpy(&co->oid, oid);
Junio C Hamanod66b37b2007-02-05 05:42:38[diff] [blame]1613 return 0;
1614}
1615
Junio C Hamanob6c4cec2010-10-28 18:13:06[diff] [blame]1616/*
1617 * This function dies on corrupt objects; the callers who want to
1618 * deal with them should arrange to call read_object() and give error
1619 * messages themselves.
1620 */
Stefan Bellera3b72c82018-11-14 00:12:46[diff] [blame]1621void *read_object_file_extended(struct repository *r,
1622 const struct object_id *oid,
brian m. carlsonb4f5aca2018-03-12 02:27:53[diff] [blame]1623 enum object_type *type,
1624 unsigned long *size,
1625 int lookup_replace)
Nicolas Pitreac939102008-07-15 01:46:48[diff] [blame]1626{
Junio C Hamano3ba7a062010-10-28 18:13:06[diff] [blame]1627 void *data;
Junio C Hamanob6c4cec2010-10-28 18:13:06[diff] [blame]1628 const struct packed_git *p;
Jeff King771e7d52017-01-13 17:54:39[diff] [blame]1629 const char *path;
1630 struct stat st;
Stefan Beller1f2e7ce2018-04-12 00:21:13[diff] [blame]1631 const struct object_id *repl = lookup_replace ?
Stefan Bellera3b72c82018-11-14 00:12:46[diff] [blame]1632 lookup_replace_object(r, oid) : oid;
Junio C Hamanob6c4cec2010-10-28 18:13:06[diff] [blame]1633
Junio C Hamano3ba7a062010-10-28 18:13:06[diff] [blame]1634 errno = 0;
Junio C Hamanocba595a2019-02-07 06:05:27[diff] [blame]1635 data = read_object(r, repl, type, size);
Junio C Hamano4bbf5a22011-05-15 19:54:52[diff] [blame]1636 if (data)
Junio C Hamanob6c4cec2010-10-28 18:13:06[diff] [blame]1637 return data;
Christian Couder68095572009-01-23 09:06:53[diff] [blame]1638
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1639 obj_read_lock();
Björn Steinbrink25f3af32011-01-20 20:12:20[diff] [blame]1640 if (errno && errno != ENOENT)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1641 die_errno(_("failed to read object %s"), oid_to_hex(oid));
Junio C Hamano3ba7a062010-10-28 18:13:06[diff] [blame]1642
Christian Couder68095572009-01-23 09:06:53[diff] [blame]1643 /* die if we replaced an object with one that does not exist */
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1644 if (repl != oid)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1645 die(_("replacement %s not found for %s"),
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1646 oid_to_hex(repl), oid_to_hex(oid));
Christian Couder68095572009-01-23 09:06:53[diff] [blame]1647
Junio C Hamanocba595a2019-02-07 06:05:27[diff] [blame]1648 if (!stat_loose_object(r, repl, &st, &path))
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1649 die(_("loose object %s (stored in %s) is corrupt"),
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1650 oid_to_hex(repl), path);
Christian Couder68095572009-01-23 09:06:53[diff] [blame]1651
Stefan Bellera3b72c82018-11-14 00:12:46[diff] [blame]1652 if ((p = has_packed_and_bad(r, repl->hash)) != NULL)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1653 die(_("packed object %s (stored in %s) is corrupt"),
brian m. carlsonb383a132018-03-12 02:27:54[diff] [blame]1654 oid_to_hex(repl), p->pack_name);
Matheus Tavares31877c92020-01-16 02:39:53[diff] [blame]1655 obj_read_unlock();
Christian Couderf5552ae2009-01-23 09:07:01[diff] [blame]1656
Junio C Hamanob6c4cec2010-10-28 18:13:06[diff] [blame]1657 return NULL;
Nicolas Pitreac939102008-07-15 01:46:48[diff] [blame]1658}
1659
Nguyễn Thái Ngọc Duyd3b47052019-06-27 09:28:47[diff] [blame]1660void *read_object_with_reference(struct repository *r,
1661 const struct object_id *oid,
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1662 const char *required_type_name,
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1663 unsigned long *size,
brian m. carlson02f05472018-03-12 02:27:52[diff] [blame]1664 struct object_id *actual_oid_return)
Junio C Hamanof4913f92005-04-21 01:06:49[diff] [blame]1665{
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1666 enum object_type type, required_type;
Junio C Hamanof4913f92005-04-21 01:06:49[diff] [blame]1667 void *buffer;
1668 unsigned long isize;
brian m. carlson02f05472018-03-12 02:27:52[diff] [blame]1669 struct object_id actual_oid;
Junio C Hamanof4913f92005-04-21 01:06:49[diff] [blame]1670
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1671 required_type = type_from_string(required_type_name);
brian m. carlson02f05472018-03-12 02:27:52[diff] [blame]1672 oidcpy(&actual_oid, oid);
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1673 while (1) {
1674 int ref_length = -1;
1675 const char *ref_type = NULL;
Junio C Hamanof4913f92005-04-21 01:06:49[diff] [blame]1676
Nguyễn Thái Ngọc Duyd3b47052019-06-27 09:28:47[diff] [blame]1677 buffer = repo_read_object_file(r, &actual_oid, &type, &isize);
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1678 if (!buffer)
1679 return NULL;
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1680 if (type == required_type) {
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1681 *size = isize;
brian m. carlson02f05472018-03-12 02:27:52[diff] [blame]1682 if (actual_oid_return)
1683 oidcpy(actual_oid_return, &actual_oid);
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1684 return buffer;
1685 }
1686 /* Handle references */
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1687 else if (type == OBJ_COMMIT)
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1688 ref_type = "tree ";
Nicolas Pitre21666f12007-02-26 19:55:59[diff] [blame]1689 else if (type == OBJ_TAG)
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1690 ref_type = "object ";
1691 else {
1692 free(buffer);
1693 return NULL;
1694 }
1695 ref_length = strlen(ref_type);
1696
brian m. carlson94b5e092018-07-16 01:28:07[diff] [blame]1697 if (ref_length + the_hash_algo->hexsz > isize ||
Martin Koegler50974ec2008-02-18 20:47:52[diff] [blame]1698 memcmp(buffer, ref_type, ref_length) ||
brian m. carlson02f05472018-03-12 02:27:52[diff] [blame]1699 get_oid_hex((char *) buffer + ref_length, &actual_oid)) {
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1700 free(buffer);
1701 return NULL;
1702 }
Sergey Vlasov1cf58e72005-08-08 18:44:43[diff] [blame]1703 free(buffer);
Junio C Hamano40469ee2005-04-28 23:42:27[diff] [blame]1704 /* Now we have the ID of the referred-to object in
brian m. carlson02f05472018-03-12 02:27:52[diff] [blame]1705 * actual_oid. Check again. */
Junio C Hamanof4913f92005-04-21 01:06:49[diff] [blame]1706 }
Junio C Hamanof4913f92005-04-21 01:06:49[diff] [blame]1707}
1708
Matheus Tavares7ad5c442020-01-30 20:32:21[diff] [blame]1709static void write_object_file_prepare(const struct git_hash_algo *algo,
1710 const void *buf, unsigned long len,
Patryk Obaraa09c9852018-01-28 00:13:19[diff] [blame]1711 const char *type, struct object_id *oid,
1712 char *hdr, int *hdrlen)
Junio C Hamanod410c0f2005-06-28 02:03:13[diff] [blame]1713{
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]1714 git_hash_ctx c;
Junio C Hamanod410c0f2005-06-28 02:03:13[diff] [blame]1715
1716 /* Generate the header */
Torsten Bögershausenca473ce2018-11-11 07:05:04[diff] [blame]1717 *hdrlen = xsnprintf(hdr, *hdrlen, "%s %"PRIuMAX , type, (uintmax_t)len)+1;
Junio C Hamanod410c0f2005-06-28 02:03:13[diff] [blame]1718
1719 /* Sha1.. */
Matheus Tavares7ad5c442020-01-30 20:32:21[diff] [blame]1720 algo->init_fn(&c);
1721 algo->update_fn(&c, hdr, *hdrlen);
1722 algo->update_fn(&c, buf, len);
1723 algo->final_fn(oid->hash, &c);
Junio C Hamanod410c0f2005-06-28 02:03:13[diff] [blame]1724}
1725
Linus Torvalds230f1322005-10-08 22:54:01[diff] [blame]1726/*
Junio C Hamano5a688fe2009-03-25 23:19:36[diff] [blame]1727 * Move the just written object into its final resting place.
Linus Torvalds230f1322005-10-08 22:54:01[diff] [blame]1728 */
Junio C Hamanocb5add52015-08-07 21:40:24[diff] [blame]1729int finalize_object_file(const char *tmpfile, const char *filename)
Linus Torvalds230f1322005-10-08 22:54:01[diff] [blame]1730{
Thomas Raste32c0a92008-09-18 22:24:46[diff] [blame]1731 int ret = 0;
Junio C Hamano5a688fe2009-03-25 23:19:36[diff] [blame]1732
Johannes Schindelin348df162009-04-27 22:32:25[diff] [blame]1733 if (object_creation_mode == OBJECT_CREATION_USES_RENAMES)
Johannes Schindelinbe66a6c2009-04-25 09:57:14[diff] [blame]1734 goto try_rename;
1735 else if (link(tmpfile, filename))
Thomas Raste32c0a92008-09-18 22:24:46[diff] [blame]1736 ret = errno;
Linus Torvalds7ebb6fc2005-10-26 17:27:36[diff] [blame]1737
1738 /*
1739 * Coda hack - coda doesn't like cross-directory links,
1740 * so we fall back to a rename, which will mean that it
1741 * won't be able to check collisions, but that's not a
1742 * big deal.
1743 *
1744 * The same holds for FAT formatted media.
1745 *
Junio C Hamano3be1f182009-03-28 06:14:39[diff] [blame]1746 * When this succeeds, we just return. We have nothing
Linus Torvalds7ebb6fc2005-10-26 17:27:36[diff] [blame]1747 * left to unlink.
1748 */
1749 if (ret && ret != EEXIST) {
Johannes Schindelinbe66a6c2009-04-25 09:57:14[diff] [blame]1750 try_rename:
Linus Torvalds7ebb6fc2005-10-26 17:27:36[diff] [blame]1751 if (!rename(tmpfile, filename))
Junio C Hamano3be1f182009-03-28 06:14:39[diff] [blame]1752 goto out;
Johannes Schindelin9e48b382005-10-25 23:41:20[diff] [blame]1753 ret = errno;
Linus Torvalds230f1322005-10-08 22:54:01[diff] [blame]1754 }
Alex Riesen691f1a22009-04-29 21:22:56[diff] [blame]1755 unlink_or_warn(tmpfile);
Linus Torvalds230f1322005-10-08 22:54:01[diff] [blame]1756 if (ret) {
1757 if (ret != EEXIST) {
Jeff King2c319882019-01-07 08:39:33[diff] [blame]1758 return error_errno(_("unable to write file %s"), filename);
Linus Torvalds230f1322005-10-08 22:54:01[diff] [blame]1759 }
1760 /* FIXME!!! Collision check here ? */
1761 }
1762
Junio C Hamano3be1f182009-03-28 06:14:39[diff] [blame]1763out:
Matthieu Moy5256b002010-02-22 22:32:16[diff] [blame]1764 if (adjust_shared_perm(filename))
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1765 return error(_("unable to set permission to '%s'"), filename);
Linus Torvalds230f1322005-10-08 22:54:01[diff] [blame]1766 return 0;
1767}
1768
Linus Torvalds4d548152006-05-24 15:30:54[diff] [blame]1769static int write_buffer(int fd, const void *buf, size_t len)
1770{
Linus Torvaldsd34cf192007-01-12 04:23:00[diff] [blame]1771 if (write_in_full(fd, buf, len) < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1772 return error_errno(_("file write error"));
Linus Torvalds4d548152006-05-24 15:30:54[diff] [blame]1773 return 0;
1774}
1775
Matheus Tavares2dcde202020-01-30 20:32:22[diff] [blame]1776int hash_object_file(const struct git_hash_algo *algo, const void *buf,
1777 unsigned long len, const char *type,
Patryk Obaraf070fac2018-01-28 00:13:13[diff] [blame]1778 struct object_id *oid)
Rene Scharfeabdc3fc2006-10-14 10:45:36[diff] [blame]1779{
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]1780 char hdr[MAX_HEADER_LEN];
Jeff Kingef1286d2015-09-24 21:06:42[diff] [blame]1781 int hdrlen = sizeof(hdr);
Matheus Tavares2dcde202020-01-30 20:32:22[diff] [blame]1782 write_object_file_prepare(algo, buf, len, type, oid, hdr, &hdrlen);
Rene Scharfeabdc3fc2006-10-14 10:45:36[diff] [blame]1783 return 0;
1784}
1785
Linus Torvaldse9039dd2008-06-11 01:47:18[diff] [blame]1786/* Finalize a file on disk, and close it. */
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1787static void close_loose_object(int fd)
Linus Torvaldse9039dd2008-06-11 01:47:18[diff] [blame]1788{
Linus Torvaldsaafe9fb2008-06-18 22:18:44[diff] [blame]1789 if (fsync_object_files)
Jeff King76011352019-01-07 08:39:24[diff] [blame]1790 fsync_or_die(fd, "loose object file");
Linus Torvaldse9039dd2008-06-11 01:47:18[diff] [blame]1791 if (close(fd) != 0)
Jeff King76011352019-01-07 08:39:24[diff] [blame]1792 die_errno(_("error when closing loose object file"));
Linus Torvaldse9039dd2008-06-11 01:47:18[diff] [blame]1793}
1794
Linus Torvalds5723fe72008-06-14 17:50:12[diff] [blame]1795/* Size of directory component, including the ending '/' */
1796static inline int directory_size(const char *filename)
1797{
1798 const char *s = strrchr(filename, '/');
1799 if (!s)
1800 return 0;
1801 return s - filename + 1;
1802}
1803
1804/*
1805 * This creates a temporary file in the same directory as the final
1806 * 'filename'
1807 *
1808 * We want to avoid cross-directory filename renames, because those
1809 * can have problems on various filesystems (FAT, NFS, Coda).
1810 */
Jeff Kingd4b3d112015-09-24 21:07:49[diff] [blame]1811static int create_tmpfile(struct strbuf *tmp, const char *filename)
Linus Torvalds5723fe72008-06-14 17:50:12[diff] [blame]1812{
1813 int fd, dirlen = directory_size(filename);
1814
Jeff Kingd4b3d112015-09-24 21:07:49[diff] [blame]1815 strbuf_reset(tmp);
1816 strbuf_add(tmp, filename, dirlen);
1817 strbuf_addstr(tmp, "tmp_obj_XXXXXX");
1818 fd = git_mkstemp_mode(tmp->buf, 0444);
Joey Hesscbacbf42008-11-20 18:56:28[diff] [blame]1819 if (fd < 0 && dirlen && errno == ENOENT) {
Jeff Kingd4b3d112015-09-24 21:07:49[diff] [blame]1820 /*
1821 * Make sure the directory exists; note that the contents
1822 * of the buffer are undefined after mkstemp returns an
1823 * error, so we have to rewrite the whole buffer from
1824 * scratch.
1825 */
1826 strbuf_reset(tmp);
1827 strbuf_add(tmp, filename, dirlen - 1);
1828 if (mkdir(tmp->buf, 0777) && errno != EEXIST)
Johan Herlandb2476a62013-10-27 11:35:43[diff] [blame]1829 return -1;
Jeff Kingd4b3d112015-09-24 21:07:49[diff] [blame]1830 if (adjust_shared_perm(tmp->buf))
Linus Torvalds5723fe72008-06-14 17:50:12[diff] [blame]1831 return -1;
1832
1833 /* Try again */
Jeff Kingd4b3d112015-09-24 21:07:49[diff] [blame]1834 strbuf_addstr(tmp, "/tmp_obj_XXXXXX");
1835 fd = git_mkstemp_mode(tmp->buf, 0444);
Linus Torvalds5723fe72008-06-14 17:50:12[diff] [blame]1836 }
1837 return fd;
1838}
1839
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1840static int write_loose_object(const struct object_id *oid, char *hdr,
1841 int hdrlen, const void *buf, unsigned long len,
1842 time_t mtime)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1843{
Jeff King915308b2009-01-29 05:56:34[diff] [blame]1844 int fd, ret;
Nicolas Pitre9892beb2010-02-21 04:27:31[diff] [blame]1845 unsigned char compressed[4096];
Junio C Hamanoef49a7a2011-06-10 18:52:15[diff] [blame]1846 git_zstream stream;
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]1847 git_hash_ctx c;
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1848 struct object_id parano_oid;
Jeff Kingd4b3d112015-09-24 21:07:49[diff] [blame]1849 static struct strbuf tmp_file = STRBUF_INIT;
Christian Couderea657732018-01-17 17:54:54[diff] [blame]1850 static struct strbuf filename = STRBUF_INIT;
Linus Torvaldsa44c9a52005-04-25 17:19:53[diff] [blame]1851
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1852 loose_object_path(the_repository, &filename, oid);
Christian Couderea657732018-01-17 17:54:54[diff] [blame]1853
1854 fd = create_tmpfile(&tmp_file, filename.buf);
Linus Torvaldsaac17942005-05-03 18:46:16[diff] [blame]1855 if (fd < 0) {
Sam Vilain35243572008-11-14 07:19:34[diff] [blame]1856 if (errno == EACCES)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1857 return error(_("insufficient permission for adding an object to repository database %s"), get_object_directory());
Petr Baudis916d0812006-11-09 12:52:05[diff] [blame]1858 else
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1859 return error_errno(_("unable to create temporary file"));
Linus Torvaldsaac17942005-05-03 18:46:16[diff] [blame]1860 }
1861
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1862 /* Set it up */
Junio C Hamano55bb5c92011-06-10 17:55:10[diff] [blame]1863 git_deflate_init(&stream, zlib_compression_level);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1864 stream.next_out = compressed;
Nicolas Pitre9892beb2010-02-21 04:27:31[diff] [blame]1865 stream.avail_out = sizeof(compressed);
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]1866 the_hash_algo->init_fn(&c);
Linus Torvaldsa44c9a52005-04-25 17:19:53[diff] [blame]1867
1868 /* First header.. */
Nicolas Pitred65a16f2007-02-26 19:55:55[diff] [blame]1869 stream.next_in = (unsigned char *)hdr;
Linus Torvaldsa44c9a52005-04-25 17:19:53[diff] [blame]1870 stream.avail_in = hdrlen;
Junio C Hamano55bb5c92011-06-10 17:55:10[diff] [blame]1871 while (git_deflate(&stream, 0) == Z_OK)
1872 ; /* nothing */
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]1873 the_hash_algo->update_fn(&c, hdr, hdrlen);
Linus Torvaldsa44c9a52005-04-25 17:19:53[diff] [blame]1874
1875 /* Then the data itself.. */
Jeff Kingc00e6572010-04-02 00:03:18[diff] [blame]1876 stream.next_in = (void *)buf;
Linus Torvaldsa44c9a52005-04-25 17:19:53[diff] [blame]1877 stream.avail_in = len;
Nicolas Pitre9892beb2010-02-21 04:27:31[diff] [blame]1878 do {
Nicolas Pitre748af442010-02-21 20:48:06[diff] [blame]1879 unsigned char *in0 = stream.next_in;
Junio C Hamano55bb5c92011-06-10 17:55:10[diff] [blame]1880 ret = git_deflate(&stream, Z_FINISH);
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]1881 the_hash_algo->update_fn(&c, in0, stream.next_in - in0);
Nicolas Pitre9892beb2010-02-21 04:27:31[diff] [blame]1882 if (write_buffer(fd, compressed, stream.next_out - compressed) < 0)
Jeff King76011352019-01-07 08:39:24[diff] [blame]1883 die(_("unable to write loose object file"));
Nicolas Pitre9892beb2010-02-21 04:27:31[diff] [blame]1884 stream.next_out = compressed;
1885 stream.avail_out = sizeof(compressed);
1886 } while (ret == Z_OK);
1887
Linus Torvaldsac54c272007-03-20 18:38:34[diff] [blame]1888 if (ret != Z_STREAM_END)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1889 die(_("unable to deflate new object %s (%d)"), oid_to_hex(oid),
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1890 ret);
Junio C Hamano55bb5c92011-06-10 17:55:10[diff] [blame]1891 ret = git_deflate_end_gently(&stream);
Linus Torvaldsac54c272007-03-20 18:38:34[diff] [blame]1892 if (ret != Z_OK)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1893 die(_("deflateEnd on object %s failed (%d)"), oid_to_hex(oid),
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1894 ret);
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]1895 the_hash_algo->final_fn(parano_oid.hash, &c);
Jeff King9001dc22018-08-28 21:22:48[diff] [blame]1896 if (!oideq(oid, &parano_oid))
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1897 die(_("confused by unstable object source data for %s"),
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1898 oid_to_hex(oid));
Linus Torvaldsac54c272007-03-20 18:38:34[diff] [blame]1899
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]1900 close_loose_object(fd);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1901
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1902 if (mtime) {
1903 struct utimbuf utb;
1904 utb.actime = mtime;
1905 utb.modtime = mtime;
Jeff Kingd4b3d112015-09-24 21:07:49[diff] [blame]1906 if (utime(tmp_file.buf, &utb) < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]1907 warning_errno(_("failed utime() on %s"), tmp_file.buf);
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1908 }
1909
Christian Couderea657732018-01-17 17:54:54[diff] [blame]1910 return finalize_object_file(tmp_file.buf, filename.buf);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1911}
Daniel Barkalow8237b182005-04-24 01:47:23[diff] [blame]1912
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]1913static int freshen_loose_object(const struct object_id *oid)
Jeff King33d42212014-10-15 22:42:22[diff] [blame]1914{
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]1915 return check_and_freshen(oid, 1);
Jeff King33d42212014-10-15 22:42:22[diff] [blame]1916}
1917
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]1918static int freshen_packed_object(const struct object_id *oid)
Jeff King33d42212014-10-15 22:42:22[diff] [blame]1919{
1920 struct pack_entry e;
brian m. carlson544443c2018-05-02 00:25:35[diff] [blame]1921 if (!find_pack_entry(the_repository, oid, &e))
Jeff Kingee1c6c32015-04-20 19:55:00[diff] [blame]1922 return 0;
1923 if (e.p->freshened)
1924 return 1;
1925 if (!freshen_file(e.p->pack_name))
1926 return 0;
1927 e.p->freshened = 1;
1928 return 1;
Jeff King33d42212014-10-15 22:42:22[diff] [blame]1929}
1930
Patryk Obaraa09c9852018-01-28 00:13:19[diff] [blame]1931int write_object_file(const void *buf, unsigned long len, const char *type,
1932 struct object_id *oid)
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1933{
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]1934 char hdr[MAX_HEADER_LEN];
Jeff Kingef1286d2015-09-24 21:06:42[diff] [blame]1935 int hdrlen = sizeof(hdr);
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1936
1937 /* Normally if we have it in the pack then we do not bother writing
1938 * it out into .git/objects/??/?{38} file.
1939 */
Matheus Tavares7ad5c442020-01-30 20:32:21[diff] [blame]1940 write_object_file_prepare(the_hash_algo, buf, len, type, oid, hdr,
1941 &hdrlen);
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]1942 if (freshen_packed_object(oid) || freshen_loose_object(oid))
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1943 return 0;
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1944 return write_loose_object(oid, hdr, hdrlen, buf, len, 0);
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1945}
1946
Patryk Obara1752cbb2018-01-28 00:13:22[diff] [blame]1947int hash_object_file_literally(const void *buf, unsigned long len,
1948 const char *type, struct object_id *oid,
1949 unsigned flags)
Eric Sunshine0c3db672015-05-04 07:25:15[diff] [blame]1950{
1951 char *header;
1952 int hdrlen, status = 0;
1953
1954 /* type string, SP, %lu of the length plus NUL must fit this */
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]1955 hdrlen = strlen(type) + MAX_HEADER_LEN;
Jeff Kingef1286d2015-09-24 21:06:42[diff] [blame]1956 header = xmalloc(hdrlen);
Matheus Tavares7ad5c442020-01-30 20:32:21[diff] [blame]1957 write_object_file_prepare(the_hash_algo, buf, len, type, oid, header,
1958 &hdrlen);
Eric Sunshine0c3db672015-05-04 07:25:15[diff] [blame]1959
1960 if (!(flags & HASH_WRITE_OBJECT))
1961 goto cleanup;
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]1962 if (freshen_packed_object(oid) || freshen_loose_object(oid))
Eric Sunshine0c3db672015-05-04 07:25:15[diff] [blame]1963 goto cleanup;
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1964 status = write_loose_object(oid, header, hdrlen, buf, len, 0);
Eric Sunshine0c3db672015-05-04 07:25:15[diff] [blame]1965
1966cleanup:
1967 free(header);
1968 return status;
1969}
1970
Patryk Obara4bdb70a2018-01-28 00:13:20[diff] [blame]1971int force_object_loose(const struct object_id *oid, time_t mtime)
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1972{
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1973 void *buf;
1974 unsigned long len;
1975 enum object_type type;
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]1976 char hdr[MAX_HEADER_LEN];
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1977 int hdrlen;
Björn Steinbrink1fb23e62008-10-18 00:37:31[diff] [blame]1978 int ret;
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1979
brian m. carlson6862ebb2018-05-02 00:25:34[diff] [blame]1980 if (has_loose_object(oid))
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1981 return 0;
Junio C Hamanocba595a2019-02-07 06:05:27[diff] [blame]1982 buf = read_object(the_repository, oid, &type, &len);
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1983 if (!buf)
Jeff King2c319882019-01-07 08:39:33[diff] [blame]1984 return error(_("cannot read object for %s"), oid_to_hex(oid));
Torsten Bögershausenca473ce2018-11-11 07:05:04[diff] [blame]1985 hdrlen = xsnprintf(hdr, sizeof(hdr), "%s %"PRIuMAX , type_name(type), (uintmax_t)len) + 1;
Patryk Obara3fc72812018-01-28 00:13:21[diff] [blame]1986 ret = write_loose_object(oid, hdr, hdrlen, buf, len, mtime);
Björn Steinbrink1fb23e62008-10-18 00:37:31[diff] [blame]1987 free(buf);
1988
1989 return ret;
Nicolas Pitrebbac7312008-05-14 05:32:48[diff] [blame]1990}
1991
Jonathan Tan1d8d9cb2020-08-05 23:06:49[diff] [blame]1992int has_object(struct repository *r, const struct object_id *oid,
1993 unsigned flags)
1994{
1995 int quick = !(flags & HAS_OBJECT_RECHECK_PACKED);
1996 unsigned object_info_flags = OBJECT_INFO_SKIP_FETCH_OBJECT |
1997 (quick ? OBJECT_INFO_QUICK : 0);
1998
1999 if (!startup_info->have_repository)
2000 return 0;
2001 return oid_object_info_extended(r, oid, NULL, object_info_flags) >= 0;
2002}
2003
Junio C Hamanocba595a2019-02-07 06:05:27[diff] [blame]2004int repo_has_object_file_with_flags(struct repository *r,
2005 const struct object_id *oid, int flags)
Daniel Barkalow8237b182005-04-24 01:47:23[diff] [blame]2006{
Jonathan Nieder3e8b7d32017-04-11 22:47:13[diff] [blame]2007 if (!startup_info->have_repository)
2008 return 0;
Jonathan Tan9c8a2942020-01-02 20:16:30[diff] [blame]2009 return oid_object_info_extended(r, oid, NULL, flags) >= 0;
Daniel Barkalow8237b182005-04-24 01:47:23[diff] [blame]2010}
Junio C Hamano74400e72005-05-02 06:45:49[diff] [blame]2011
Stefan Beller9b45f492018-11-14 00:12:48[diff] [blame]2012int repo_has_object_file(struct repository *r,
2013 const struct object_id *oid)
brian m. carlsonb419aa22015-11-10 02:22:19[diff] [blame]2014{
Junio C Hamanocba595a2019-02-07 06:05:27[diff] [blame]2015 return repo_has_object_file_with_flags(r, oid, 0);
Jeff King5827a032016-10-13 16:53:44[diff] [blame]2016}
2017
Nguyễn Thái Ngọc Duyc879daa2011-02-05 10:52:21[diff] [blame]2018static void check_tree(const void *buf, size_t size)
2019{
2020 struct tree_desc desc;
2021 struct name_entry entry;
2022
2023 init_tree_desc(&desc, buf, size);
2024 while (tree_entry(&desc, &entry))
2025 /* do nothing
2026 * tree_entry() will die() on malformed entries */
2027 ;
2028}
2029
2030static void check_commit(const void *buf, size_t size)
2031{
2032 struct commit c;
2033 memset(&c, 0, sizeof(c));
Stefan Beller08f4f442018-06-29 01:22:00[diff] [blame]2034 if (parse_commit_buffer(the_repository, &c, buf, size, 0))
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2035 die(_("corrupt commit"));
Nguyễn Thái Ngọc Duyc879daa2011-02-05 10:52:21[diff] [blame]2036}
2037
2038static void check_tag(const void *buf, size_t size)
2039{
2040 struct tag t;
2041 memset(&t, 0, sizeof(t));
Stefan Beller0e740fe2018-06-29 01:22:04[diff] [blame]2042 if (parse_tag_buffer(the_repository, &t, buf, size))
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2043 die(_("corrupt tag"));
Nguyễn Thái Ngọc Duyc879daa2011-02-05 10:52:21[diff] [blame]2044}
2045
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2046static int index_mem(struct index_state *istate,
2047 struct object_id *oid, void *buf, size_t size,
Junio C Hamanoc4ce46f2011-05-08 08:47:33[diff] [blame]2048 enum object_type type,
2049 const char *path, unsigned flags)
Björn Engelmanne7332f92006-05-23 18:19:04[diff] [blame]2050{
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]2051 int ret, re_allocated = 0;
Junio C Hamanoc4ce46f2011-05-08 08:47:33[diff] [blame]2052 int write_object = flags & HASH_WRITE_OBJECT;
Junio C Hamano74400e72005-05-02 06:45:49[diff] [blame]2053
Bryan Larsen7672db22005-07-08 23:51:55[diff] [blame]2054 if (!type)
Junio C Hamanoedaec3f2007-02-28 19:45:56[diff] [blame]2055 type = OBJ_BLOB;
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]2056
2057 /*
2058 * Convert blobs to git internal format
2059 */
Dmitry Potapov43df4f82008-08-03 04:39:16[diff] [blame]2060 if ((type == OBJ_BLOB) && path) {
Brandon Caseyf285a2d2008-10-09 19:12:12[diff] [blame]2061 struct strbuf nbuf = STRBUF_INIT;
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2062 if (convert_to_git(istate, path, buf, size, &nbuf,
Torsten Bögershausen8462ff42018-01-13 22:49:31[diff] [blame]2063 get_conv_flags(flags))) {
Pierre Habouzitb315c5c2007-09-27 10:58:23[diff] [blame]2064 buf = strbuf_detach(&nbuf, &size);
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]2065 re_allocated = 1;
2066 }
2067 }
Junio C Hamanoc4ce46f2011-05-08 08:47:33[diff] [blame]2068 if (flags & HASH_FORMAT_CHECK) {
Nguyễn Thái Ngọc Duyc879daa2011-02-05 10:52:21[diff] [blame]2069 if (type == OBJ_TREE)
2070 check_tree(buf, size);
2071 if (type == OBJ_COMMIT)
2072 check_commit(buf, size);
2073 if (type == OBJ_TAG)
2074 check_tag(buf, size);
2075 }
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]2076
Bryan Larsen7672db22005-07-08 23:51:55[diff] [blame]2077 if (write_object)
Junio C Hamano169c9c02018-03-06 22:54:07[diff] [blame]2078 ret = write_object_file(buf, size, type_name(type), oid);
Rene Scharfeabdc3fc2006-10-14 10:45:36[diff] [blame]2079 else
Matheus Tavares2dcde202020-01-30 20:32:22[diff] [blame]2080 ret = hash_object_file(the_hash_algo, buf, size,
2081 type_name(type), oid);
Dmitry Potapov43df4f82008-08-03 04:39:16[diff] [blame]2082 if (re_allocated)
Linus Torvalds6c510be2007-02-13 19:07:23[diff] [blame]2083 free(buf);
Dmitry Potapov43df4f82008-08-03 04:39:16[diff] [blame]2084 return ret;
2085}
2086
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2087static int index_stream_convert_blob(struct index_state *istate,
2088 struct object_id *oid,
2089 int fd,
2090 const char *path,
2091 unsigned flags)
Steffen Prohaska9035d752014-08-26 15:23:25[diff] [blame]2092{
2093 int ret;
2094 const int write_object = flags & HASH_WRITE_OBJECT;
2095 struct strbuf sbuf = STRBUF_INIT;
2096
2097 assert(path);
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2098 assert(would_convert_to_git_filter_fd(istate, path));
Steffen Prohaska9035d752014-08-26 15:23:25[diff] [blame]2099
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2100 convert_to_git_filter_fd(istate, path, fd, &sbuf,
Torsten Bögershausen8462ff42018-01-13 22:49:31[diff] [blame]2101 get_conv_flags(flags));
Steffen Prohaska9035d752014-08-26 15:23:25[diff] [blame]2102
2103 if (write_object)
Junio C Hamano169c9c02018-03-06 22:54:07[diff] [blame]2104 ret = write_object_file(sbuf.buf, sbuf.len, type_name(OBJ_BLOB),
Patryk Obaraa09c9852018-01-28 00:13:19[diff] [blame]2105 oid);
Steffen Prohaska9035d752014-08-26 15:23:25[diff] [blame]2106 else
Matheus Tavares2dcde202020-01-30 20:32:22[diff] [blame]2107 ret = hash_object_file(the_hash_algo, sbuf.buf, sbuf.len,
2108 type_name(OBJ_BLOB), oid);
Steffen Prohaska9035d752014-08-26 15:23:25[diff] [blame]2109 strbuf_release(&sbuf);
2110 return ret;
2111}
2112
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2113static int index_pipe(struct index_state *istate, struct object_id *oid,
2114 int fd, enum object_type type,
Junio C Hamano7b41e1e2011-05-08 08:47:34[diff] [blame]2115 const char *path, unsigned flags)
2116{
2117 struct strbuf sbuf = STRBUF_INIT;
2118 int ret;
2119
2120 if (strbuf_read(&sbuf, fd, 4096) >= 0)
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2121 ret = index_mem(istate, oid, sbuf.buf, sbuf.len, type, path, flags);
Junio C Hamano7b41e1e2011-05-08 08:47:34[diff] [blame]2122 else
2123 ret = -1;
2124 strbuf_release(&sbuf);
2125 return ret;
2126}
2127
Dmitry Potapovea68b0c2010-02-21 06:32:19[diff] [blame]2128#define SMALL_FILE_SIZE (32*1024)
2129
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2130static int index_core(struct index_state *istate,
2131 struct object_id *oid, int fd, size_t size,
Junio C Hamano7b41e1e2011-05-08 08:47:34[diff] [blame]2132 enum object_type type, const char *path,
2133 unsigned flags)
Dmitry Potapov43df4f82008-08-03 04:39:16[diff] [blame]2134{
2135 int ret;
Dmitry Potapov43df4f82008-08-03 04:39:16[diff] [blame]2136
Junio C Hamano7b41e1e2011-05-08 08:47:34[diff] [blame]2137 if (!size) {
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2138 ret = index_mem(istate, oid, "", size, type, path, flags);
Dmitry Potapovea68b0c2010-02-21 06:32:19[diff] [blame]2139 } else if (size <= SMALL_FILE_SIZE) {
2140 char *buf = xmalloc(size);
Jeff King90dca672017-09-27 06:01:07[diff] [blame]2141 ssize_t read_result = read_in_full(fd, buf, size);
2142 if (read_result < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2143 ret = error_errno(_("read error while indexing %s"),
Jeff King90dca672017-09-27 06:01:07[diff] [blame]2144 path ? path : "<unknown>");
2145 else if (read_result != size)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2146 ret = error(_("short read while indexing %s"),
Jeff King90dca672017-09-27 06:01:07[diff] [blame]2147 path ? path : "<unknown>");
Dmitry Potapovea68b0c2010-02-21 06:32:19[diff] [blame]2148 else
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2149 ret = index_mem(istate, oid, buf, size, type, path, flags);
Dmitry Potapovea68b0c2010-02-21 06:32:19[diff] [blame]2150 free(buf);
Dmitry Potapov08bda202010-05-10 21:38:17[diff] [blame]2151 } else {
Dmitry Potapov43df4f82008-08-03 04:39:16[diff] [blame]2152 void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2153 ret = index_mem(istate, oid, buf, size, type, path, flags);
Linus Torvaldsaac17942005-05-03 18:46:16[diff] [blame]2154 munmap(buf, size);
Dmitry Potapov08bda202010-05-10 21:38:17[diff] [blame]2155 }
Junio C Hamano7b41e1e2011-05-08 08:47:34[diff] [blame]2156 return ret;
2157}
2158
Junio C Hamano4dd1fbc2011-05-08 08:47:35[diff] [blame]2159/*
Junio C Hamano568508e2011-10-28 21:48:40[diff] [blame]2160 * This creates one packfile per large blob unless bulk-checkin
2161 * machinery is "plugged".
Junio C Hamano4dd1fbc2011-05-08 08:47:35[diff] [blame]2162 *
2163 * This also bypasses the usual "convert-to-git" dance, and that is on
2164 * purpose. We could write a streaming version of the converting
2165 * functions and insert that before feeding the data to fast-import
Jeff King4f22b102012-02-24 22:10:17[diff] [blame]2166 * (or equivalent in-core API described above). However, that is
2167 * somewhat complicated, as we do not know the size of the filter
2168 * result, which we need to know beforehand when writing a git object.
2169 * Since the primary motivation for trying to stream from the working
2170 * tree file and to avoid mmaping it in core is to deal with large
2171 * binary blobs, they generally do not want to get any conversion, and
2172 * callers should avoid this code path when filters are requested.
Junio C Hamano4dd1fbc2011-05-08 08:47:35[diff] [blame]2173 */
Patryk Obara7d5e1dc2017-08-20 20:09:31[diff] [blame]2174static int index_stream(struct object_id *oid, int fd, size_t size,
Junio C Hamano4dd1fbc2011-05-08 08:47:35[diff] [blame]2175 enum object_type type, const char *path,
2176 unsigned flags)
2177{
brian m. carlson68ee6df2018-03-12 02:27:21[diff] [blame]2178 return index_bulk_checkin(oid, fd, size, type, path, flags);
Junio C Hamano4dd1fbc2011-05-08 08:47:35[diff] [blame]2179}
2180
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2181int index_fd(struct index_state *istate, struct object_id *oid,
2182 int fd, struct stat *st,
Junio C Hamano7b41e1e2011-05-08 08:47:34[diff] [blame]2183 enum object_type type, const char *path, unsigned flags)
2184{
2185 int ret;
Junio C Hamano7b41e1e2011-05-08 08:47:34[diff] [blame]2186
Steffen Prohaska9079ab72014-09-21 10:03:26[diff] [blame]2187 /*
2188 * Call xsize_t() only when needed to avoid potentially unnecessary
2189 * die() for large files.
2190 */
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2191 if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(istate, path))
2192 ret = index_stream_convert_blob(istate, oid, fd, path, flags);
Steffen Prohaska9035d752014-08-26 15:23:25[diff] [blame]2193 else if (!S_ISREG(st->st_mode))
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2194 ret = index_pipe(istate, oid, fd, type, path, flags);
Steffen Prohaska9079ab72014-09-21 10:03:26[diff] [blame]2195 else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2196 (path && would_convert_to_git(istate, path)))
2197 ret = index_core(istate, oid, fd, xsize_t(st->st_size),
2198 type, path, flags);
Junio C Hamano4dd1fbc2011-05-08 08:47:35[diff] [blame]2199 else
Patryk Obara7d5e1dc2017-08-20 20:09:31[diff] [blame]2200 ret = index_stream(oid, fd, xsize_t(st->st_size), type, path,
Steffen Prohaska9079ab72014-09-21 10:03:26[diff] [blame]2201 flags);
Dmitry Potapov43df4f82008-08-03 04:39:16[diff] [blame]2202 close(fd);
Linus Torvaldsaac17942005-05-03 18:46:16[diff] [blame]2203 return ret;
Junio C Hamano74400e72005-05-02 06:45:49[diff] [blame]2204}
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2205
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2206int index_path(struct index_state *istate, struct object_id *oid,
2207 const char *path, struct stat *st, unsigned flags)
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2208{
2209 int fd;
Linus Torvaldsb760d3a2008-12-17 17:51:53[diff] [blame]2210 struct strbuf sb = STRBUF_INIT;
Rene Scharfeea8e0292017-08-30 18:00:29[diff] [blame]2211 int rc = 0;
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2212
2213 switch (st->st_mode & S_IFMT) {
2214 case S_IFREG:
2215 fd = open(path, O_RDONLY);
2216 if (fd < 0)
Nguyễn Thái Ngọc Duy7616c6c2016-05-08 09:47:56[diff] [blame]2217 return error_errno("open(\"%s\")", path);
Nguyễn Thái Ngọc Duy58bf2a42018-09-21 15:57:31[diff] [blame]2218 if (index_fd(istate, oid, fd, st, OBJ_BLOB, path, flags) < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2219 return error(_("%s: failed to insert into database"),
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2220 path);
2221 break;
2222 case S_IFLNK:
Nguyễn Thái Ngọc Duy7616c6c2016-05-08 09:47:56[diff] [blame]2223 if (strbuf_readlink(&sb, path, st->st_size))
2224 return error_errno("readlink(\"%s\")", path);
Junio C Hamanoc4ce46f2011-05-08 08:47:33[diff] [blame]2225 if (!(flags & HASH_WRITE_OBJECT))
Matheus Tavares2dcde202020-01-30 20:32:22[diff] [blame]2226 hash_object_file(the_hash_algo, sb.buf, sb.len,
2227 blob_type, oid);
Patryk Obaraa09c9852018-01-28 00:13:19[diff] [blame]2228 else if (write_object_file(sb.buf, sb.len, blob_type, oid))
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2229 rc = error(_("%s: failed to insert into database"), path);
Linus Torvaldsb760d3a2008-12-17 17:51:53[diff] [blame]2230 strbuf_release(&sb);
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2231 break;
Linus Torvaldsf35a6d32007-04-10 04:20:29[diff] [blame]2232 case S_IFDIR:
brian m. carlsona98e6102017-10-15 22:07:07[diff] [blame]2233 return resolve_gitlink_ref(path, "HEAD", oid);
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2234 default:
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2235 return error(_("%s: unsupported file type"), path);
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2236 }
Rene Scharfeea8e0292017-08-30 18:00:29[diff] [blame]2237 return rc;
Junio C Hamanoec1fcc12005-10-07 10:42:00[diff] [blame]2238}
Junio C Hamanoa69e5422007-01-23 05:55:18[diff] [blame]2239
2240int read_pack_header(int fd, struct pack_header *header)
2241{
Jeff Kingf48ecd32017-09-13 18:47:22[diff] [blame]2242 if (read_in_full(fd, header, sizeof(*header)) != sizeof(*header))
Heikki Orsilac697ad12008-05-03 13:27:26[diff] [blame]2243 /* "eof before pack header was fully read" */
2244 return PH_ERROR_EOF;
2245
Junio C Hamanoa69e5422007-01-23 05:55:18[diff] [blame]2246 if (header->hdr_signature != htonl(PACK_SIGNATURE))
2247 /* "protocol error (pack signature mismatch detected)" */
2248 return PH_ERROR_PACK_SIGNATURE;
2249 if (!pack_version_ok(header->hdr_version))
2250 /* "protocol error (pack version unsupported)" */
2251 return PH_ERROR_PROTOCOL;
2252 return 0;
2253}
Jeff King40d52ff2010-04-02 00:05:23[diff] [blame]2254
brian m. carlsone816caa2018-03-12 02:27:42[diff] [blame]2255void assert_oid_type(const struct object_id *oid, enum object_type expect)
Jeff King40d52ff2010-04-02 00:05:23[diff] [blame]2256{
Stefan Beller0df8e962018-04-25 18:20:59[diff] [blame]2257 enum object_type type = oid_object_info(the_repository, oid, NULL);
Jeff King40d52ff2010-04-02 00:05:23[diff] [blame]2258 if (type < 0)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2259 die(_("%s is not a valid object"), oid_to_hex(oid));
Jeff King40d52ff2010-04-02 00:05:23[diff] [blame]2260 if (type != expect)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2261 die(_("%s is not a valid '%s' object"), oid_to_hex(oid),
Brandon Williamsdebca9d2018-02-14 18:59:24[diff] [blame]2262 type_name(expect));
Jeff King40d52ff2010-04-02 00:05:23[diff] [blame]2263}
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2264
René Scharfe70c49052017-06-24 14:09:39[diff] [blame]2265int for_each_file_in_obj_subdir(unsigned int subdir_nr,
René Scharfecc817ca2017-06-22 18:19:48[diff] [blame]2266 struct strbuf *path,
2267 each_loose_object_fn obj_cb,
2268 each_loose_cruft_fn cruft_cb,
2269 each_loose_subdir_fn subdir_cb,
2270 void *data)
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2271{
René Scharfe0375f472017-06-24 12:12:30[diff] [blame]2272 size_t origlen, baselen;
2273 DIR *dir;
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2274 struct dirent *de;
2275 int r = 0;
René Scharfe62a24c82017-10-31 13:50:06[diff] [blame]2276 struct object_id oid;
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2277
René Scharfe70c49052017-06-24 14:09:39[diff] [blame]2278 if (subdir_nr > 0xff)
2279 BUG("invalid loose object subdirectory: %x", subdir_nr);
2280
René Scharfe0375f472017-06-24 12:12:30[diff] [blame]2281 origlen = path->len;
2282 strbuf_complete(path, '/');
2283 strbuf_addf(path, "%02x", subdir_nr);
René Scharfe0375f472017-06-24 12:12:30[diff] [blame]2284
2285 dir = opendir(path->buf);
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2286 if (!dir) {
René Scharfe0375f472017-06-24 12:12:30[diff] [blame]2287 if (errno != ENOENT)
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2288 r = error_errno(_("unable to open %s"), path->buf);
René Scharfe0375f472017-06-24 12:12:30[diff] [blame]2289 strbuf_setlen(path, origlen);
2290 return r;
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2291 }
2292
René Scharfe62a24c82017-10-31 13:50:06[diff] [blame]2293 oid.hash[0] = subdir_nr;
Derrick Stolee163ee5e2017-12-04 14:06:03[diff] [blame]2294 strbuf_addch(path, '/');
2295 baselen = path->len;
René Scharfe62a24c82017-10-31 13:50:06[diff] [blame]2296
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2297 while ((de = readdir(dir))) {
Derrick Stolee163ee5e2017-12-04 14:06:03[diff] [blame]2298 size_t namelen;
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2299 if (is_dot_or_dotdot(de->d_name))
2300 continue;
2301
Derrick Stolee163ee5e2017-12-04 14:06:03[diff] [blame]2302 namelen = strlen(de->d_name);
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2303 strbuf_setlen(path, baselen);
Derrick Stolee163ee5e2017-12-04 14:06:03[diff] [blame]2304 strbuf_add(path, de->d_name, namelen);
brian m. carlson94b5e092018-07-16 01:28:07[diff] [blame]2305 if (namelen == the_hash_algo->hexsz - 2 &&
René Scharfe62a24c82017-10-31 13:50:06[diff] [blame]2306 !hex_to_bytes(oid.hash + 1, de->d_name,
brian m. carlson94b5e092018-07-16 01:28:07[diff] [blame]2307 the_hash_algo->rawsz - 1)) {
René Scharfe62a24c82017-10-31 13:50:06[diff] [blame]2308 if (obj_cb) {
2309 r = obj_cb(&oid, path->buf, data);
2310 if (r)
2311 break;
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2312 }
René Scharfe62a24c82017-10-31 13:50:06[diff] [blame]2313 continue;
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2314 }
2315
2316 if (cruft_cb) {
2317 r = cruft_cb(de->d_name, path->buf, data);
2318 if (r)
2319 break;
2320 }
2321 }
Johannes Sixt094c7e62015-08-12 17:43:01[diff] [blame]2322 closedir(dir);
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2323
Derrick Stolee163ee5e2017-12-04 14:06:03[diff] [blame]2324 strbuf_setlen(path, baselen - 1);
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2325 if (!r && subdir_cb)
2326 r = subdir_cb(subdir_nr, path->buf, data);
2327
René Scharfe0375f472017-06-24 12:12:30[diff] [blame]2328 strbuf_setlen(path, origlen);
2329
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2330 return r;
2331}
2332
Jeff Kinge6f875e2015-02-09 01:13:22[diff] [blame]2333int for_each_loose_file_in_objdir_buf(struct strbuf *path,
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2334 each_loose_object_fn obj_cb,
2335 each_loose_cruft_fn cruft_cb,
2336 each_loose_subdir_fn subdir_cb,
2337 void *data)
2338{
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2339 int r = 0;
2340 int i;
2341
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2342 for (i = 0; i < 256; i++) {
Jeff Kinge6f875e2015-02-09 01:13:22[diff] [blame]2343 r = for_each_file_in_obj_subdir(i, path, obj_cb, cruft_cb,
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2344 subdir_cb, data);
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2345 if (r)
2346 break;
2347 }
2348
Jeff Kinge6f875e2015-02-09 01:13:22[diff] [blame]2349 return r;
2350}
2351
2352int for_each_loose_file_in_objdir(const char *path,
2353 each_loose_object_fn obj_cb,
2354 each_loose_cruft_fn cruft_cb,
2355 each_loose_subdir_fn subdir_cb,
2356 void *data)
2357{
2358 struct strbuf buf = STRBUF_INIT;
2359 int r;
2360
2361 strbuf_addstr(&buf, path);
2362 r = for_each_loose_file_in_objdir_buf(&buf, obj_cb, cruft_cb,
2363 subdir_cb, data);
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2364 strbuf_release(&buf);
Jeff Kinge6f875e2015-02-09 01:13:22[diff] [blame]2365
Jeff King27e1e222014-10-15 22:38:55[diff] [blame]2366 return r;
2367}
Jeff King660c8892014-10-15 22:41:21[diff] [blame]2368
Jeff Kinga7ff6f52018-08-10 23:09:44[diff] [blame]2369int for_each_loose_object(each_loose_object_fn cb, void *data,
2370 enum for_each_object_flags flags)
Jeff King660c8892014-10-15 22:41:21[diff] [blame]2371{
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]2372 struct object_directory *odb;
Jeff King660c8892014-10-15 22:41:21[diff] [blame]2373
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]2374 prepare_alt_odb(the_repository);
2375 for (odb = the_repository->objects->odb; odb; odb = odb->next) {
2376 int r = for_each_loose_file_in_objdir(odb->path, cb, NULL,
2377 NULL, data);
2378 if (r)
2379 return r;
Jeff King660c8892014-10-15 22:41:21[diff] [blame]2380
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]2381 if (flags & FOR_EACH_OBJECT_LOCAL_ONLY)
2382 break;
2383 }
Jeff King1385bb72015-03-27 11:32:41[diff] [blame]2384
Jeff Kingf0eaf632018-11-12 14:50:39[diff] [blame]2385 return 0;
Jeff King660c8892014-10-15 22:41:21[diff] [blame]2386}
2387
Jeff King3a2e0822018-11-12 14:50:56[diff] [blame]2388static int append_loose_object(const struct object_id *oid, const char *path,
2389 void *data)
2390{
2391 oid_array_append(data, oid);
2392 return 0;
2393}
2394
René Scharfe0000d652019-01-06 16:45:30[diff] [blame]2395struct oid_array *odb_loose_cache(struct object_directory *odb,
2396 const struct object_id *oid)
2397{
2398 int subdir_nr = oid->hash[0];
Jeff King3a2e0822018-11-12 14:50:56[diff] [blame]2399 struct strbuf buf = STRBUF_INIT;
2400
2401 if (subdir_nr < 0 ||
2402 subdir_nr >= ARRAY_SIZE(odb->loose_objects_subdir_seen))
2403 BUG("subdir_nr out of range");
2404
2405 if (odb->loose_objects_subdir_seen[subdir_nr])
René Scharfe8be88db2019-01-07 17:29:16[diff] [blame]2406 return &odb->loose_objects_cache[subdir_nr];
Jeff King3a2e0822018-11-12 14:50:56[diff] [blame]2407
2408 strbuf_addstr(&buf, odb->path);
2409 for_each_file_in_obj_subdir(subdir_nr, &buf,
2410 append_loose_object,
2411 NULL, NULL,
René Scharfe4cea1ce2019-01-06 16:45:52[diff] [blame]2412 &odb->loose_objects_cache[subdir_nr]);
Jeff King3a2e0822018-11-12 14:50:56[diff] [blame]2413 odb->loose_objects_subdir_seen[subdir_nr] = 1;
Jeff King7317aa72018-11-22 17:53:00[diff] [blame]2414 strbuf_release(&buf);
René Scharfe8be88db2019-01-07 17:29:16[diff] [blame]2415 return &odb->loose_objects_cache[subdir_nr];
Jeff King660c8892014-10-15 22:41:21[diff] [blame]2416}
2417
René Scharfed4e19e52019-01-06 16:45:39[diff] [blame]2418void odb_clear_loose_cache(struct object_directory *odb)
2419{
René Scharfe4cea1ce2019-01-06 16:45:52[diff] [blame]2420 int i;
2421
2422 for (i = 0; i < ARRAY_SIZE(odb->loose_objects_cache); i++)
2423 oid_array_clear(&odb->loose_objects_cache[i]);
René Scharfed4e19e52019-01-06 16:45:39[diff] [blame]2424 memset(&odb->loose_objects_subdir_seen, 0,
2425 sizeof(odb->loose_objects_subdir_seen));
2426}
2427
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2428static int check_stream_oid(git_zstream *stream,
2429 const char *hdr,
2430 unsigned long size,
2431 const char *path,
2432 const struct object_id *expected_oid)
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2433{
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]2434 git_hash_ctx c;
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2435 struct object_id real_oid;
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2436 unsigned char buf[4096];
2437 unsigned long total_read;
2438 int status = Z_OK;
2439
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]2440 the_hash_algo->init_fn(&c);
2441 the_hash_algo->update_fn(&c, hdr, stream->total_out);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2442
2443 /*
2444 * We already read some bytes into hdr, but the ones up to the NUL
2445 * do not count against the object's content size.
2446 */
2447 total_read = stream->total_out - strlen(hdr) - 1;
2448
2449 /*
2450 * This size comparison must be "<=" to read the final zlib packets;
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2451 * see the comment in unpack_loose_rest for details.
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2452 */
2453 while (total_read <= size &&
Junio C Hamano18ad13e2018-10-31 04:12:12[diff] [blame]2454 (status == Z_OK ||
2455 (status == Z_BUF_ERROR && !stream->avail_out))) {
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2456 stream->next_out = buf;
2457 stream->avail_out = sizeof(buf);
2458 if (size - total_read < stream->avail_out)
2459 stream->avail_out = size - total_read;
2460 status = git_inflate(stream, Z_FINISH);
brian m. carlson18e25882018-02-01 02:18:41[diff] [blame]2461 the_hash_algo->update_fn(&c, buf, stream->next_out - buf);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2462 total_read += stream->next_out - buf;
2463 }
2464 git_inflate_end(stream);
2465
2466 if (status != Z_STREAM_END) {
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2467 error(_("corrupt loose object '%s'"), oid_to_hex(expected_oid));
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2468 return -1;
2469 }
Jeff Kingcce044d2017-01-13 18:00:25[diff] [blame]2470 if (stream->avail_in) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2471 error(_("garbage at end of loose object '%s'"),
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2472 oid_to_hex(expected_oid));
Jeff Kingcce044d2017-01-13 18:00:25[diff] [blame]2473 return -1;
2474 }
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2475
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2476 the_hash_algo->final_fn(real_oid.hash, &c);
2477 if (!oideq(expected_oid, &real_oid)) {
Jeff King01f8d592019-01-07 08:40:34[diff] [blame]2478 error(_("hash mismatch for %s (expected %s)"), path,
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2479 oid_to_hex(expected_oid));
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2480 return -1;
2481 }
2482
2483 return 0;
2484}
2485
2486int read_loose_object(const char *path,
brian m. carlsond61d87b2018-03-12 02:27:38[diff] [blame]2487 const struct object_id *expected_oid,
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2488 enum object_type *type,
2489 unsigned long *size,
2490 void **contents)
2491{
2492 int ret = -1;
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2493 void *map = NULL;
2494 unsigned long mapsize;
2495 git_zstream stream;
brian m. carlson1af64f72018-03-12 02:27:55[diff] [blame]2496 char hdr[MAX_HEADER_LEN];
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2497
2498 *contents = NULL;
2499
Jeff King514c5fd2019-01-07 08:35:42[diff] [blame]2500 map = map_loose_object_1(the_repository, path, NULL, &mapsize);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2501 if (!map) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2502 error_errno(_("unable to mmap %s"), path);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2503 goto out;
2504 }
2505
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2506 if (unpack_loose_header(&stream, map, mapsize, hdr, sizeof(hdr)) < 0) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2507 error(_("unable to unpack header of %s"), path);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2508 goto out;
2509 }
2510
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2511 *type = parse_loose_header(hdr, size);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2512 if (*type < 0) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2513 error(_("unable to parse header of %s"), path);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2514 git_inflate_end(&stream);
2515 goto out;
2516 }
2517
Jeff King7ac4f3a2018-05-02 19:44:51[diff] [blame]2518 if (*type == OBJ_BLOB && *size > big_file_threshold) {
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2519 if (check_stream_oid(&stream, hdr, *size, path, expected_oid) < 0)
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2520 goto out;
2521 } else {
Jeff King00a77602019-01-07 08:37:02[diff] [blame]2522 *contents = unpack_loose_rest(&stream, hdr, *size, expected_oid);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2523 if (!*contents) {
Nguyễn Thái Ngọc Duy259328b2018-07-21 07:49:39[diff] [blame]2524 error(_("unable to unpack contents of %s"), path);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2525 git_inflate_end(&stream);
2526 goto out;
2527 }
Matheus Tavaresb98d1882020-01-30 20:32:23[diff] [blame]2528 if (check_object_signature(the_repository, expected_oid,
2529 *contents, *size,
2530 type_name(*type))) {
Jeff King01f8d592019-01-07 08:40:34[diff] [blame]2531 error(_("hash mismatch for %s (expected %s)"), path,
brian m. carlsond61d87b2018-03-12 02:27:38[diff] [blame]2532 oid_to_hex(expected_oid));
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2533 free(*contents);
2534 goto out;
2535 }
2536 }
2537
2538 ret = 0; /* everything checks out */
2539
2540out:
2541 if (map)
2542 munmap(map, mapsize);
Jeff Kingf6371f92017-01-13 17:58:16[diff] [blame]2543 return ret;
2544}