When inserting a index entry of stage 0, remove all old unmerged entries.
[git/git.git] / read-cache.c
1 /*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 */
6 #include <stdarg.h>
7 #include "cache.h"
8
9 const char *sha1_file_directory = NULL;
10 struct cache_entry **active_cache = NULL;
11 unsigned int active_nr = 0, active_alloc = 0;
12
13 void usage(const char *err)
14 {
15 fprintf(stderr, "usage: %s\n", err);
16 exit(1);
17 }
18
19 static 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 }
25
26 void die(const char *err, ...)
27 {
28 va_list params;
29
30 va_start(params, err);
31 report("fatal: ", err, params);
32 va_end(params);
33 exit(1);
34 }
35
36 int 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
47 static 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
58 int get_sha1_hex(const char *hex, unsigned char *sha1)
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
71 char * sha1_to_hex(const unsigned char *sha1)
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 */
91 char *sha1_file_name(const unsigned char *sha1)
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
116 int 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
127 void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
128 {
129 char *filename = sha1_file_name(sha1);
130 int fd = open(filename, O_RDONLY);
131 struct stat st;
132 void *map;
133
134 if (fd < 0) {
135 perror(filename);
136 return NULL;
137 }
138 if (fstat(fd, &st) < 0) {
139 close(fd);
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;
146 *size = st.st_size;
147 return map;
148 }
149
150 void * 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;
156
157 /* Get the data stream */
158 memset(&stream, 0, sizeof(stream));
159 stream.next_in = map;
160 stream.avail_in = mapsize;
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;
168
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
186 void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size)
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
200 int write_sha1_file(char *buf, unsigned len, unsigned char *returnsha1)
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;
231 if (returnsha1)
232 memcpy(returnsha1, sha1, 20);
233 return 0;
234 }
235
236 static 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
263 int write_sha1_buffer(const unsigned char *sha1, void *buf, unsigned int size)
264 {
265 char *filename = sha1_file_name(sha1);
266 int fd;
267
268 fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
269 if (fd < 0) {
270 if (errno != EEXIST)
271 return -1;
272 if (collision_check(filename, buf, size))
273 return error("SHA1 collision detected!"
274 " This is bad, bad, BAD!\a\n");
275 return 0;
276 }
277 write(fd, buf, size);
278 close(fd);
279 return 0;
280 }
281
282 int cache_match_stat(struct cache_entry *ce, struct stat *st)
283 {
284 unsigned int changed = 0;
285
286 if (ce->ce_mtime.sec != htonl(st->st_mtime))
287 changed |= MTIME_CHANGED;
288 if (ce->ce_ctime.sec != htonl(st->st_ctime))
289 changed |= CTIME_CHANGED;
290
291 #ifdef NSEC
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)
300 changed |= CTIME_CHANGED;
301 #endif
302
303 if (ce->ce_uid != htonl(st->st_uid) ||
304 ce->ce_gid != htonl(st->st_gid))
305 changed |= OWNER_CHANGED;
306 if (ce->ce_mode != htonl(st->st_mode))
307 changed |= MODE_CHANGED;
308 if (ce->ce_dev != htonl(st->st_dev) ||
309 ce->ce_ino != htonl(st->st_ino))
310 changed |= INODE_CHANGED;
311 if (ce->ce_size != htonl(st->st_size))
312 changed |= DATA_CHANGED;
313 return changed;
314 }
315
316 int cache_name_compare(const char *name1, int flags1, const char *name2, int flags2)
317 {
318 int len1 = flags1 & CE_NAMEMASK;
319 int len2 = flags2 & CE_NAMEMASK;
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;
330 if (flags1 < flags2)
331 return -1;
332 if (flags1 > flags2)
333 return 1;
334 return 0;
335 }
336
337 int 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];
346 int cmp = cache_name_compare(name, namelen, ce->name, htons(ce->ce_flags));
347 if (!cmp)
348 return next;
349 if (cmp < 0) {
350 last = next;
351 continue;
352 }
353 first = next+1;
354 }
355 return -first-1;
356 }
357
358 /* Remove entry, return true if there are more entries to go.. */
359 static 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
368 int remove_file_from_cache(char *path)
369 {
370 int pos = cache_name_pos(path, strlen(path));
371 if (pos >= 0)
372 remove_entry_at(pos);
373 return 0;
374 }
375
376 static 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
382 int add_cache_entry(struct cache_entry *ce, int ok_to_add)
383 {
384 int pos;
385
386 pos = cache_name_pos(ce->name, htons(ce->ce_flags));
387
388 /* existing match? Just replace it */
389 if (pos >= 0) {
390 active_cache[pos] = ce;
391 return 0;
392 }
393 pos = -pos-1;
394
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
408 if (!ok_to_add)
409 return -1;
410
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
425 static int verify_hdr(struct cache_header *hdr, unsigned long size)
426 {
427 SHA_CTX c;
428 unsigned char sha1[20];
429
430 if (hdr->hdr_signature != htonl(CACHE_SIGNATURE))
431 return error("bad signature");
432 if (hdr->hdr_version != htonl(1))
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
443 int 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");
460 fd = open(".git/index", O_RDONLY);
461 if (fd < 0)
462 return (errno == ENOENT) ? 0 : error("open failed");
463
464 size = 0; // avoid gcc warning
465 map = (void *)-1;
466 if (!fstat(fd, &st)) {
467 size = st.st_size;
468 errno = EINVAL;
469 if (size >= sizeof(struct cache_header))
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
480 active_nr = ntohl(hdr->hdr_entries);
481 active_alloc = alloc_nr(active_nr);
482 active_cache = calloc(active_alloc, sizeof(struct cache_entry *));
483
484 offset = sizeof(*hdr);
485 for (i = 0; i < active_nr; i++) {
486 struct cache_entry *ce = map + offset;
487 offset = offset + ce_size(ce);
488 active_cache[i] = ce;
489 }
490 return active_nr;
491
492 unmap:
493 munmap(map, size);
494 errno = EINVAL;
495 return error("verify header failed");
496 }
497
498 int write_cache(int newfd, struct cache_entry **cache, int entries)
499 {
500 SHA_CTX c;
501 struct cache_header hdr;
502 int i;
503
504 hdr.hdr_signature = htonl(CACHE_SIGNATURE);
505 hdr.hdr_version = htonl(1);
506 hdr.hdr_entries = htonl(entries);
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 }