When inserting a index entry of stage 0, remove all old unmerged 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
95fd5bf8 316int cache_name_compare(const char *name1, int flags1, const char *name2, int flags2)
eb38c22f 317{
95fd5bf8
LT
318 int len1 = flags1 & CE_NAMEMASK;
319 int len2 = flags2 & CE_NAMEMASK;
eb38c22f
LT
320 int len = len1 < len2 ? len1 : len2;
321 int cmp;
322
323 cmp = memcmp(name1, name2, len);
324 if (cmp)
325 return cmp;
326 if (len1 < len2)
327 return -1;
328 if (len1 > len2)
329 return 1;
95fd5bf8
LT
330 if (flags1 < flags2)
331 return -1;
332 if (flags1 > flags2)
333 return 1;
eb38c22f
LT
334 return 0;
335}
336
337int cache_name_pos(const char *name, int namelen)
338{
339 int first, last;
340
341 first = 0;
342 last = active_nr;
343 while (last > first) {
344 int next = (last + first) >> 1;
345 struct cache_entry *ce = active_cache[next];
95fd5bf8 346 int cmp = cache_name_compare(name, namelen, ce->name, htons(ce->ce_flags));
eb38c22f 347 if (!cmp)
76e7f4ec 348 return next;
eb38c22f
LT
349 if (cmp < 0) {
350 last = next;
351 continue;
352 }
353 first = next+1;
354 }
76e7f4ec 355 return -first-1;
eb38c22f
LT
356}
357
7b937ca3
LT
358/* Remove entry, return true if there are more entries to go.. */
359static int remove_entry_at(int pos)
360{
361 active_nr--;
362 if (pos >= active_nr)
363 return 0;
364 memmove(active_cache + pos, active_cache + pos + 1, (active_nr - pos) * sizeof(struct cache_entry *));
365 return 1;
366}
367
197ee8c9
LT
368int remove_file_from_cache(char *path)
369{
370 int pos = cache_name_pos(path, strlen(path));
7b937ca3
LT
371 if (pos >= 0)
372 remove_entry_at(pos);
197ee8c9
LT
373 return 0;
374}
375
7b937ca3
LT
376static int same_name(struct cache_entry *a, struct cache_entry *b)
377{
378 int len = ce_namelen(a);
379 return ce_namelen(b) == len && !memcmp(a->name, b->name, len);
380}
381
121481ab 382int add_cache_entry(struct cache_entry *ce, int ok_to_add)
197ee8c9
LT
383{
384 int pos;
385
95fd5bf8 386 pos = cache_name_pos(ce->name, htons(ce->ce_flags));
197ee8c9
LT
387
388 /* existing match? Just replace it */
76e7f4ec
LT
389 if (pos >= 0) {
390 active_cache[pos] = ce;
197ee8c9
LT
391 return 0;
392 }
76e7f4ec 393 pos = -pos-1;
197ee8c9 394
7b937ca3
LT
395 /*
396 * Inserting a merged entry ("stage 0") into the index
397 * will always replace all non-merged entries..
398 */
399 if (pos < active_nr && ce_stage(ce) == 0) {
400 while (same_name(active_cache[pos], ce)) {
401 ok_to_add = 1;
402 active_nr--;
403 if (!remove_entry_at(pos))
404 break;
405 }
406 }
407
121481ab
LT
408 if (!ok_to_add)
409 return -1;
410
197ee8c9
LT
411 /* Make sure the array is big enough .. */
412 if (active_nr == active_alloc) {
413 active_alloc = alloc_nr(active_alloc);
414 active_cache = realloc(active_cache, active_alloc * sizeof(struct cache_entry *));
415 }
416
417 /* Add it in.. */
418 active_nr++;
419 if (active_nr > pos)
420 memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce));
421 active_cache[pos] = ce;
422 return 0;
423}
424
e83c5163
LT
425static int verify_hdr(struct cache_header *hdr, unsigned long size)
426{
427 SHA_CTX c;
428 unsigned char sha1[20];
429
ccc4feb5 430 if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
e83c5163 431 return error("bad signature");
ccc4feb5 432 if (hdr->hdr_version != htonl(1))
e83c5163
LT
433 return error("bad version");
434 SHA1_Init(&c);
435 SHA1_Update(&c, hdr, offsetof(struct cache_header, sha1));
436 SHA1_Update(&c, hdr+1, size - sizeof(*hdr));
437 SHA1_Final(sha1, &c);
438 if (memcmp(sha1, hdr->sha1, 20))
439 return error("bad header sha1");
440 return 0;
441}
442
443int read_cache(void)
444{
445 int fd, i;
446 struct stat st;
447 unsigned long size, offset;
448 void *map;
449 struct cache_header *hdr;
450
451 errno = EBUSY;
452 if (active_cache)
453 return error("more than one cachefile");
454 errno = ENOENT;
455 sha1_file_directory = getenv(DB_ENVIRONMENT);
456 if (!sha1_file_directory)
457 sha1_file_directory = DEFAULT_DB_ENVIRONMENT;
458 if (access(sha1_file_directory, X_OK) < 0)
459 return error("no access to SHA1 file directory");
4bb04f21 460 fd = open(".git/index", O_RDONLY);
e83c5163
LT
461 if (fd < 0)
462 return (errno == ENOENT) ? 0 : error("open failed");
463
19b2860c 464 size = 0; // avoid gcc warning
e83c5163
LT
465 map = (void *)-1;
466 if (!fstat(fd, &st)) {
e83c5163
LT
467 size = st.st_size;
468 errno = EINVAL;
59c1e249 469 if (size >= sizeof(struct cache_header))
e83c5163
LT
470 map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
471 }
472 close(fd);
473 if (-1 == (int)(long)map)
474 return error("mmap failed");
475
476 hdr = map;
477 if (verify_hdr(hdr, size) < 0)
478 goto unmap;
479
ccc4feb5 480 active_nr = ntohl(hdr->hdr_entries);
e83c5163
LT
481 active_alloc = alloc_nr(active_nr);
482 active_cache = calloc(active_alloc, sizeof(struct cache_entry *));
483
484 offset = sizeof(*hdr);
ccc4feb5 485 for (i = 0; i < active_nr; i++) {
e83c5163
LT
486 struct cache_entry *ce = map + offset;
487 offset = offset + ce_size(ce);
488 active_cache[i] = ce;
489 }
490 return active_nr;
491
492unmap:
493 munmap(map, size);
494 errno = EINVAL;
495 return error("verify header failed");
496}
497
197ee8c9
LT
498int write_cache(int newfd, struct cache_entry **cache, int entries)
499{
500 SHA_CTX c;
501 struct cache_header hdr;
502 int i;
503
ccc4feb5
LT
504 hdr.hdr_signature = htonl(CACHE_SIGNATURE);
505 hdr.hdr_version = htonl(1);
506 hdr.hdr_entries = htonl(entries);
197ee8c9
LT
507
508 SHA1_Init(&c);
509 SHA1_Update(&c, &hdr, offsetof(struct cache_header, sha1));
510 for (i = 0; i < entries; i++) {
511 struct cache_entry *ce = cache[i];
512 int size = ce_size(ce);
513 SHA1_Update(&c, ce, size);
514 }
515 SHA1_Final(hdr.sha1, &c);
516
517 if (write(newfd, &hdr, sizeof(hdr)) != sizeof(hdr))
518 return -1;
519
520 for (i = 0; i < entries; i++) {
521 struct cache_entry *ce = cache[i];
522 int size = ce_size(ce);
523 if (write(newfd, ce, size) != size)
524 return -1;
525 }
526 return 0;
527}