write-tree: refuse to write out trees with unmerged index entries.
[git/git.git] / read-cache.c
CommitLineData
8bc9a0c7
LT
1/*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 */
2de381f9 6#include <stdarg.h>
e83c5163
LT
7#include "cache.h"
8
9const char *sha1_file_directory = NULL;
10struct cache_entry **active_cache = NULL;
11unsigned int active_nr = 0, active_alloc = 0;
12
2de381f9 13void usage(const char *err)
e83c5163 14{
2de381f9
PB
15 fprintf(stderr, "usage: %s\n", err);
16 exit(1);
17}
18
19static void report(const char *prefix, const char *err, va_list params)
20{
21 fputs(prefix, stderr);
22 vfprintf(stderr, err, params);
23 fputs("\n", stderr);
24}
121481ab 25
2de381f9
PB
26void die(const char *err, ...)
27{
28 va_list params;
29
30 va_start(params, err);
31 report("fatal: ", err, params);
32 va_end(params);
e83c5163
LT
33 exit(1);
34}
35
2de381f9
PB
36int error(const char *err, ...)
37{
38 va_list params;
39
40 va_start(params, err);
41 report("error: ", err, params);
42 va_end(params);
43 return -1;
44}
45
46
e83c5163
LT
47static unsigned hexval(char c)
48{
49 if (c >= '0' && c <= '9')
50 return c - '0';
51 if (c >= 'a' && c <= 'f')
52 return c - 'a' + 10;
53 if (c >= 'A' && c <= 'F')
54 return c - 'A' + 10;
55 return ~0;
56}
57
197ee8c9 58int get_sha1_hex(const char *hex, unsigned char *sha1)
e83c5163
LT
59{
60 int i;
61 for (i = 0; i < 20; i++) {
62 unsigned int val = (hexval(hex[0]) << 4) | hexval(hex[1]);
63 if (val & ~0xff)
64 return -1;
65 *sha1++ = val;
66 hex += 2;
67 }
68 return 0;
69}
70
197ee8c9 71char * sha1_to_hex(const unsigned char *sha1)
e83c5163
LT
72{
73 static char buffer[50];
74 static const char hex[] = "0123456789abcdef";
75 char *buf = buffer;
76 int i;
77
78 for (i = 0; i < 20; i++) {
79 unsigned int val = *sha1++;
80 *buf++ = hex[val >> 4];
81 *buf++ = hex[val & 0xf];
82 }
83 return buffer;
84}
85
86/*
87 * NOTE! This returns a statically allocated buffer, so you have to be
88 * careful about using it. Do a "strdup()" if you need to save the
89 * filename.
90 */
73134b6d 91char *sha1_file_name(const unsigned char *sha1)
e83c5163
LT
92{
93 int i;
94 static char *name, *base;
95
96 if (!base) {
97 char *sha1_file_directory = getenv(DB_ENVIRONMENT) ? : DEFAULT_DB_ENVIRONMENT;
98 int len = strlen(sha1_file_directory);
99 base = malloc(len + 60);
100 memcpy(base, sha1_file_directory, len);
101 memset(base+len, 0, 60);
102 base[len] = '/';
103 base[len+3] = '/';
104 name = base + len + 1;
105 }
106 for (i = 0; i < 20; i++) {
107 static char hex[] = "0123456789abcdef";
108 unsigned int val = sha1[i];
109 char *pos = name + i*2 + (i > 0);
110 *pos++ = hex[val >> 4];
111 *pos = hex[val & 0xf];
112 }
113 return base;
114}
115
2ade9340
LT
116int check_sha1_signature(unsigned char *sha1, void *map, unsigned long size)
117{
118 unsigned char real_sha1[20];
119 SHA_CTX c;
120
121 SHA1_Init(&c);
122 SHA1_Update(&c, map, size);
123 SHA1_Final(real_sha1, &c);
124 return memcmp(sha1, real_sha1, 20) ? -1 : 0;
125}
126
73134b6d 127void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
e83c5163 128{
e83c5163 129 char *filename = sha1_file_name(sha1);
24778e33
LT
130 int fd = open(filename, O_RDONLY);
131 struct stat st;
132 void *map;
e83c5163 133
e83c5163
LT
134 if (fd < 0) {
135 perror(filename);
136 return NULL;
137 }
138 if (fstat(fd, &st) < 0) {
aebb2679 139 close(fd);
e83c5163
LT
140 return NULL;
141 }
142 map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
143 close(fd);
144 if (-1 == (int)(long)map)
145 return NULL;
24778e33
LT
146 *size = st.st_size;
147 return map;
148}
149
150void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size)
151{
152 int ret, bytes;
153 z_stream stream;
154 char buffer[8192];
155 char *buf;
e83c5163
LT
156
157 /* Get the data stream */
158 memset(&stream, 0, sizeof(stream));
159 stream.next_in = map;
24778e33 160 stream.avail_in = mapsize;
e83c5163
LT
161 stream.next_out = buffer;
162 stream.avail_out = sizeof(buffer);
163
164 inflateInit(&stream);
165 ret = inflate(&stream, 0);
166 if (sscanf(buffer, "%10s %lu", type, size) != 2)
167 return NULL;
24778e33 168
e83c5163
LT
169 bytes = strlen(buffer) + 1;
170 buf = malloc(*size);
171 if (!buf)
172 return NULL;
173
174 memcpy(buf, buffer + bytes, stream.total_out - bytes);
175 bytes = stream.total_out - bytes;
176 if (bytes < *size && ret == Z_OK) {
177 stream.next_out = buf + bytes;
178 stream.avail_out = *size - bytes;
179 while (inflate(&stream, Z_FINISH) == Z_OK)
180 /* nothing */;
181 }
182 inflateEnd(&stream);
183 return buf;
184}
185
73134b6d 186void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size)
24778e33
LT
187{
188 unsigned long mapsize;
189 void *map, *buf;
190
191 map = map_sha1_file(sha1, &mapsize);
192 if (map) {
193 buf = unpack_sha1_file(map, mapsize, type, size);
194 munmap(map, mapsize);
195 return buf;
196 }
197 return NULL;
198}
199
d6d3f9d0 200int write_sha1_file(char *buf, unsigned len, unsigned char *returnsha1)
e83c5163
LT
201{
202 int size;
203 char *compressed;
204 z_stream stream;
205 unsigned char sha1[20];
206 SHA_CTX c;
207
208 /* Set it up */
209 memset(&stream, 0, sizeof(stream));
210 deflateInit(&stream, Z_BEST_COMPRESSION);
211 size = deflateBound(&stream, len);
212 compressed = malloc(size);
213
214 /* Compress it */
215 stream.next_in = buf;
216 stream.avail_in = len;
217 stream.next_out = compressed;
218 stream.avail_out = size;
219 while (deflate(&stream, Z_FINISH) == Z_OK)
220 /* nothing */;
221 deflateEnd(&stream);
222 size = stream.total_out;
223
224 /* Sha1.. */
225 SHA1_Init(&c);
226 SHA1_Update(&c, compressed, size);
227 SHA1_Final(sha1, &c);
228
229 if (write_sha1_buffer(sha1, compressed, size) < 0)
230 return -1;
d6d3f9d0
LT
231 if (returnsha1)
232 memcpy(returnsha1, sha1, 20);
e83c5163
LT
233 return 0;
234}
235
f864ba74
LT
236static inline int collision_check(char *filename, void *buf, unsigned int size)
237{
238#ifdef COLLISION_CHECK
239 void *map;
240 int fd = open(filename, O_RDONLY);
241 struct stat st;
242 int cmp;
243
244 /* Unreadable object, or object went away? Strange. */
245 if (fd < 0)
246 return -1;
247
248 if (fstat(fd, &st) < 0 || size != st.st_size)
249 return -1;
250
251 map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
252 close(fd);
253 if (map == MAP_FAILED)
254 return -1;
255 cmp = memcmp(buf, map, size);
256 munmap(map, size);
257 if (cmp)
258 return -1;
259#endif
260 return 0;
261}
262
73134b6d 263int write_sha1_buffer(const unsigned char *sha1, void *buf, unsigned int size)
e83c5163
LT
264{
265 char *filename = sha1_file_name(sha1);
19b2860c 266 int fd;
e83c5163
LT
267
268 fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
5c2a7fbc 269 if (fd < 0) {
5c2a7fbc
PB
270 if (errno != EEXIST)
271 return -1;
f864ba74 272 if (collision_check(filename, buf, size))
5c2a7fbc
PB
273 return error("SHA1 collision detected!"
274 " This is bad, bad, BAD!\a\n");
5c2a7fbc
PB
275 return 0;
276 }
e83c5163
LT
277 write(fd, buf, size);
278 close(fd);
279 return 0;
280}
281
734aab75
LT
282int cache_match_stat(struct cache_entry *ce, struct stat *st)
283{
284 unsigned int changed = 0;
285
ccc4feb5 286 if (ce->ce_mtime.sec != htonl(st->st_mtime))
734aab75 287 changed |= MTIME_CHANGED;
ccc4feb5
LT
288 if (ce->ce_ctime.sec != htonl(st->st_ctime))
289 changed |= CTIME_CHANGED;
290
bdd4da59 291#ifdef NSEC
ccc4feb5
LT
292 /*
293 * nsec seems unreliable - not all filesystems support it, so
294 * as long as it is in the inode cache you get right nsec
295 * but after it gets flushed, you get zero nsec.
296 */
297 if (ce->ce_mtime.nsec != htonl(st->st_mtim.tv_nsec)
298 changed |= MTIME_CHANGED;
299 if (ce->ce_ctime.nsec != htonl(st->st_ctim.tv_nsec)
734aab75 300 changed |= CTIME_CHANGED;
ccc4feb5
LT
301#endif
302
303 if (ce->ce_uid != htonl(st->st_uid) ||
304 ce->ce_gid != htonl(st->st_gid))
734aab75 305 changed |= OWNER_CHANGED;
ccc4feb5 306 if (ce->ce_mode != htonl(st->st_mode))
734aab75 307 changed |= MODE_CHANGED;
ccc4feb5
LT
308 if (ce->ce_dev != htonl(st->st_dev) ||
309 ce->ce_ino != htonl(st->st_ino))
734aab75 310 changed |= INODE_CHANGED;
ccc4feb5 311 if (ce->ce_size != htonl(st->st_size))
734aab75
LT
312 changed |= DATA_CHANGED;
313 return changed;
314}
315
79517a06 316int cache_name_compare(const char *name1, int len1, const char *name2, int len2)
eb38c22f
LT
317{
318 int len = len1 < len2 ? len1 : len2;
319 int cmp;
320
321 cmp = memcmp(name1, name2, len);
322 if (cmp)
323 return cmp;
324 if (len1 < len2)
325 return -1;
326 if (len1 > len2)
327 return 1;
328 return 0;
329}
330
331int cache_name_pos(const char *name, int namelen)
332{
333 int first, last;
334
335 first = 0;
336 last = active_nr;
337 while (last > first) {
338 int next = (last + first) >> 1;
339 struct cache_entry *ce = active_cache[next];
ccc4feb5 340 int cmp = cache_name_compare(name, namelen, ce->name, ce_namelen(ce));
eb38c22f 341 if (!cmp)
76e7f4ec 342 return next;
eb38c22f
LT
343 if (cmp < 0) {
344 last = next;
345 continue;
346 }
347 first = next+1;
348 }
76e7f4ec 349 return -first-1;
eb38c22f
LT
350}
351
197ee8c9
LT
352int remove_file_from_cache(char *path)
353{
354 int pos = cache_name_pos(path, strlen(path));
76e7f4ec 355 if (pos >= 0) {
197ee8c9
LT
356 active_nr--;
357 if (pos < active_nr)
76e7f4ec 358 memmove(active_cache + pos, active_cache + pos + 1, (active_nr - pos) * sizeof(struct cache_entry *));
197ee8c9
LT
359 }
360 return 0;
361}
362
121481ab 363int add_cache_entry(struct cache_entry *ce, int ok_to_add)
197ee8c9
LT
364{
365 int pos;
366
ccc4feb5 367 pos = cache_name_pos(ce->name, ce_namelen(ce));
197ee8c9
LT
368
369 /* existing match? Just replace it */
76e7f4ec
LT
370 if (pos >= 0) {
371 active_cache[pos] = ce;
197ee8c9
LT
372 return 0;
373 }
76e7f4ec 374 pos = -pos-1;
197ee8c9 375
121481ab
LT
376 if (!ok_to_add)
377 return -1;
378
197ee8c9
LT
379 /* Make sure the array is big enough .. */
380 if (active_nr == active_alloc) {
381 active_alloc = alloc_nr(active_alloc);
382 active_cache = realloc(active_cache, active_alloc * sizeof(struct cache_entry *));
383 }
384
385 /* Add it in.. */
386 active_nr++;
387 if (active_nr > pos)
388 memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce));
389 active_cache[pos] = ce;
390 return 0;
391}
392
e83c5163
LT
393static int verify_hdr(struct cache_header *hdr, unsigned long size)
394{
395 SHA_CTX c;
396 unsigned char sha1[20];
397
ccc4feb5 398 if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
e83c5163 399 return error("bad signature");
ccc4feb5 400 if (hdr->hdr_version != htonl(1))
e83c5163
LT
401 return error("bad version");
402 SHA1_Init(&c);
403 SHA1_Update(&c, hdr, offsetof(struct cache_header, sha1));
404 SHA1_Update(&c, hdr+1, size - sizeof(*hdr));
405 SHA1_Final(sha1, &c);
406 if (memcmp(sha1, hdr->sha1, 20))
407 return error("bad header sha1");
408 return 0;
409}
410
411int read_cache(void)
412{
413 int fd, i;
414 struct stat st;
415 unsigned long size, offset;
416 void *map;
417 struct cache_header *hdr;
418
419 errno = EBUSY;
420 if (active_cache)
421 return error("more than one cachefile");
422 errno = ENOENT;
423 sha1_file_directory = getenv(DB_ENVIRONMENT);
424 if (!sha1_file_directory)
425 sha1_file_directory = DEFAULT_DB_ENVIRONMENT;
426 if (access(sha1_file_directory, X_OK) < 0)
427 return error("no access to SHA1 file directory");
4bb04f21 428 fd = open(".git/index", O_RDONLY);
e83c5163
LT
429 if (fd < 0)
430 return (errno == ENOENT) ? 0 : error("open failed");
431
19b2860c 432 size = 0; // avoid gcc warning
e83c5163
LT
433 map = (void *)-1;
434 if (!fstat(fd, &st)) {
e83c5163
LT
435 size = st.st_size;
436 errno = EINVAL;
59c1e249 437 if (size >= sizeof(struct cache_header))
e83c5163
LT
438 map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
439 }
440 close(fd);
441 if (-1 == (int)(long)map)
442 return error("mmap failed");
443
444 hdr = map;
445 if (verify_hdr(hdr, size) < 0)
446 goto unmap;
447
ccc4feb5 448 active_nr = ntohl(hdr->hdr_entries);
e83c5163
LT
449 active_alloc = alloc_nr(active_nr);
450 active_cache = calloc(active_alloc, sizeof(struct cache_entry *));
451
452 offset = sizeof(*hdr);
ccc4feb5 453 for (i = 0; i < active_nr; i++) {
e83c5163
LT
454 struct cache_entry *ce = map + offset;
455 offset = offset + ce_size(ce);
456 active_cache[i] = ce;
457 }
458 return active_nr;
459
460unmap:
461 munmap(map, size);
462 errno = EINVAL;
463 return error("verify header failed");
464}
465
197ee8c9
LT
466int write_cache(int newfd, struct cache_entry **cache, int entries)
467{
468 SHA_CTX c;
469 struct cache_header hdr;
470 int i;
471
ccc4feb5
LT
472 hdr.hdr_signature = htonl(CACHE_SIGNATURE);
473 hdr.hdr_version = htonl(1);
474 hdr.hdr_entries = htonl(entries);
197ee8c9
LT
475
476 SHA1_Init(&c);
477 SHA1_Update(&c, &hdr, offsetof(struct cache_header, sha1));
478 for (i = 0; i < entries; i++) {
479 struct cache_entry *ce = cache[i];
480 int size = ce_size(ce);
481 SHA1_Update(&c, ce, size);
482 }
483 SHA1_Final(hdr.sha1, &c);
484
485 if (write(newfd, &hdr, sizeof(hdr)) != sizeof(hdr))
486 return -1;
487
488 for (i = 0; i < entries; i++) {
489 struct cache_entry *ce = cache[i];
490 int size = ce_size(ce);
491 if (write(newfd, ce, size) != size)
492 return -1;
493 }
494 return 0;
495}