[PATCH] Simplify date handling and make it more reliable
[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
bdd4da59
PB
286 /* nsec seems unreliable - not all filesystems support it, so
287 * as long as it is in the inode cache you get right nsec
288 * but after it gets flushed, you get zero nsec. */
289 if (ce->mtime.sec != (unsigned int)st->st_mtim.tv_sec
290#ifdef NSEC
291 || ce->mtime.nsec != (unsigned int)st->st_mtim.tv_nsec
292#endif
293 )
734aab75 294 changed |= MTIME_CHANGED;
bdd4da59
PB
295 if (ce->ctime.sec != (unsigned int)st->st_ctim.tv_sec
296#ifdef NSEC
297 || ce->ctime.nsec != (unsigned int)st->st_ctim.tv_nsec
298#endif
299 )
734aab75
LT
300 changed |= CTIME_CHANGED;
301 if (ce->st_uid != (unsigned int)st->st_uid ||
302 ce->st_gid != (unsigned int)st->st_gid)
303 changed |= OWNER_CHANGED;
304 if (ce->st_mode != (unsigned int)st->st_mode)
305 changed |= MODE_CHANGED;
306 if (ce->st_dev != (unsigned int)st->st_dev ||
307 ce->st_ino != (unsigned int)st->st_ino)
308 changed |= INODE_CHANGED;
309 if (ce->st_size != (unsigned int)st->st_size)
310 changed |= DATA_CHANGED;
311 return changed;
312}
313
79517a06 314int cache_name_compare(const char *name1, int len1, const char *name2, int len2)
eb38c22f
LT
315{
316 int len = len1 < len2 ? len1 : len2;
317 int cmp;
318
319 cmp = memcmp(name1, name2, len);
320 if (cmp)
321 return cmp;
322 if (len1 < len2)
323 return -1;
324 if (len1 > len2)
325 return 1;
326 return 0;
327}
328
329int cache_name_pos(const char *name, int namelen)
330{
331 int first, last;
332
333 first = 0;
334 last = active_nr;
335 while (last > first) {
336 int next = (last + first) >> 1;
337 struct cache_entry *ce = active_cache[next];
338 int cmp = cache_name_compare(name, namelen, ce->name, ce->namelen);
339 if (!cmp)
76e7f4ec 340 return next;
eb38c22f
LT
341 if (cmp < 0) {
342 last = next;
343 continue;
344 }
345 first = next+1;
346 }
76e7f4ec 347 return -first-1;
eb38c22f
LT
348}
349
197ee8c9
LT
350int remove_file_from_cache(char *path)
351{
352 int pos = cache_name_pos(path, strlen(path));
76e7f4ec 353 if (pos >= 0) {
197ee8c9
LT
354 active_nr--;
355 if (pos < active_nr)
76e7f4ec 356 memmove(active_cache + pos, active_cache + pos + 1, (active_nr - pos) * sizeof(struct cache_entry *));
197ee8c9
LT
357 }
358 return 0;
359}
360
121481ab 361int add_cache_entry(struct cache_entry *ce, int ok_to_add)
197ee8c9
LT
362{
363 int pos;
364
365 pos = cache_name_pos(ce->name, ce->namelen);
366
367 /* existing match? Just replace it */
76e7f4ec
LT
368 if (pos >= 0) {
369 active_cache[pos] = ce;
197ee8c9
LT
370 return 0;
371 }
76e7f4ec 372 pos = -pos-1;
197ee8c9 373
121481ab
LT
374 if (!ok_to_add)
375 return -1;
376
197ee8c9
LT
377 /* Make sure the array is big enough .. */
378 if (active_nr == active_alloc) {
379 active_alloc = alloc_nr(active_alloc);
380 active_cache = realloc(active_cache, active_alloc * sizeof(struct cache_entry *));
381 }
382
383 /* Add it in.. */
384 active_nr++;
385 if (active_nr > pos)
386 memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce));
387 active_cache[pos] = ce;
388 return 0;
389}
390
e83c5163
LT
391static int verify_hdr(struct cache_header *hdr, unsigned long size)
392{
393 SHA_CTX c;
394 unsigned char sha1[20];
395
396 if (hdr->signature != CACHE_SIGNATURE)
397 return error("bad signature");
398 if (hdr->version != 1)
399 return error("bad version");
400 SHA1_Init(&c);
401 SHA1_Update(&c, hdr, offsetof(struct cache_header, sha1));
402 SHA1_Update(&c, hdr+1, size - sizeof(*hdr));
403 SHA1_Final(sha1, &c);
404 if (memcmp(sha1, hdr->sha1, 20))
405 return error("bad header sha1");
406 return 0;
407}
408
409int read_cache(void)
410{
411 int fd, i;
412 struct stat st;
413 unsigned long size, offset;
414 void *map;
415 struct cache_header *hdr;
416
417 errno = EBUSY;
418 if (active_cache)
419 return error("more than one cachefile");
420 errno = ENOENT;
421 sha1_file_directory = getenv(DB_ENVIRONMENT);
422 if (!sha1_file_directory)
423 sha1_file_directory = DEFAULT_DB_ENVIRONMENT;
424 if (access(sha1_file_directory, X_OK) < 0)
425 return error("no access to SHA1 file directory");
4bb04f21 426 fd = open(".git/index", O_RDONLY);
e83c5163
LT
427 if (fd < 0)
428 return (errno == ENOENT) ? 0 : error("open failed");
429
19b2860c 430 size = 0; // avoid gcc warning
e83c5163
LT
431 map = (void *)-1;
432 if (!fstat(fd, &st)) {
e83c5163
LT
433 size = st.st_size;
434 errno = EINVAL;
59c1e249 435 if (size >= sizeof(struct cache_header))
e83c5163
LT
436 map = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
437 }
438 close(fd);
439 if (-1 == (int)(long)map)
440 return error("mmap failed");
441
442 hdr = map;
443 if (verify_hdr(hdr, size) < 0)
444 goto unmap;
445
446 active_nr = hdr->entries;
447 active_alloc = alloc_nr(active_nr);
448 active_cache = calloc(active_alloc, sizeof(struct cache_entry *));
449
450 offset = sizeof(*hdr);
451 for (i = 0; i < hdr->entries; i++) {
452 struct cache_entry *ce = map + offset;
453 offset = offset + ce_size(ce);
454 active_cache[i] = ce;
455 }
456 return active_nr;
457
458unmap:
459 munmap(map, size);
460 errno = EINVAL;
461 return error("verify header failed");
462}
463
197ee8c9
LT
464int write_cache(int newfd, struct cache_entry **cache, int entries)
465{
466 SHA_CTX c;
467 struct cache_header hdr;
468 int i;
469
470 hdr.signature = CACHE_SIGNATURE;
471 hdr.version = 1;
472 hdr.entries = entries;
473
474 SHA1_Init(&c);
475 SHA1_Update(&c, &hdr, offsetof(struct cache_header, sha1));
476 for (i = 0; i < entries; i++) {
477 struct cache_entry *ce = cache[i];
478 int size = ce_size(ce);
479 SHA1_Update(&c, ce, size);
480 }
481 SHA1_Final(hdr.sha1, &c);
482
483 if (write(newfd, &hdr, sizeof(hdr)) != sizeof(hdr))
484 return -1;
485
486 for (i = 0; i < entries; i++) {
487 struct cache_entry *ce = cache[i];
488 int size = ce_size(ce);
489 if (write(newfd, ce, size) != size)
490 return -1;
491 }
492 return 0;
493}