Gotweb

Blob

Date:: Tue Feb 5 15:22:04 2019 UTC
Message:: rename a local variable in got_worktree_status()
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/stat.h>
18 #include <sys/limits.h>
19 #include <sys/queue.h>
20 #include <sys/tree.h>
21 
22 #include <dirent.h>
23 #include <stddef.h>
24 #include <string.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <fcntl.h>
28 #include <errno.h>
29 #include <unistd.h>
30 #include <sha1.h>
31 #include <zlib.h>
32 #include <fnmatch.h>
33 #include <libgen.h>
34 
35 #include "got_error.h"
36 #include "got_repository.h"
37 #include "got_reference.h"
38 #include "got_object.h"
39 #include "got_worktree.h"
40 #include "got_opentemp.h"
41 
42 #include "got_lib_worktree.h"
43 #include "got_lib_path.h"
44 #include "got_lib_sha1.h"
45 #include "got_lib_fileindex.h"
46 #include "got_lib_inflate.h"
47 #include "got_lib_delta.h"
48 #include "got_lib_object.h"
49 
50 #ifndef MIN
51 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
52 #endif
53 
54 static const struct got_error *
55 create_meta_file(const char *path_got, const char *name, const char *content)
56 {
57 	const struct got_error *err = NULL;
58 	char *path;
59 	int fd = -1;
60 
61 	if (asprintf(&path, "%s/%s", path_got, name) == -1) {
62 		err = got_error_from_errno();
63 		path = NULL;
64 		goto done;
65 	}
66 
67 	fd = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW,
68 	    GOT_DEFAULT_FILE_MODE);
69 	if (fd == -1) {
70 		err = got_error_from_errno();
71 		goto done;
72 	}
73 
74 	if (content) {
75 		int len = dprintf(fd, "%s\n", content);
76 		if (len != strlen(content) + 1) {
77 			err = got_error_from_errno();
78 			goto done;
79 		}
80 	}
81 
82 done:
83 	if (fd != -1 && close(fd) == -1 && err == NULL)
84 		err = got_error_from_errno();
85 	free(path);
86 	return err;
87 }
88 
89 static const struct got_error *
90 update_meta_file(const char *path_got, const char *name, const char *content)
91 {
92 	const struct got_error *err = NULL;
93 	FILE *tmpfile = NULL;
94 	char *tmppath = NULL;
95 	char *path = NULL;
96 
97 	if (asprintf(&path, "%s/%s", path_got, name) == -1) {
98 		err = got_error_from_errno();
99 		path = NULL;
100 		goto done;
101 	}
102 
103 	err = got_opentemp_named(&tmppath, &tmpfile, path);
104 	if (err)
105 		goto done;
106 
107 	if (content) {
108 		int len = fprintf(tmpfile, "%s\n", content);
109 		if (len != strlen(content) + 1) {
110 			err = got_error_from_errno();
111 			goto done;
112 		}
113 	}
114 
115 	if (rename(tmppath, path) != 0) {
116 		err = got_error_from_errno();
117 		goto done;
118 	}
119 
120 done:
121 	free(tmppath);
122 	fclose(tmpfile);
123 	return err;
124 }
125 
126 static const struct got_error *
127 read_meta_file(char **content, const char *path_got, const char *name)
128 {
129 	const struct got_error *err = NULL;
130 	char *path;
131 	int fd = -1;
132 	ssize_t n;
133 	struct stat sb;
134 
135 	*content = NULL;
136 
137 	if (asprintf(&path, "%s/%s", path_got, name) == -1) {
138 		err = got_error_from_errno();
139 		path = NULL;
140 		goto done;
141 	}
142 
143 	fd = open(path, O_RDONLY | O_NOFOLLOW);
144 	if (fd == -1) {
145 		err = got_error_from_errno();
146 		goto done;
147 	}
148 	if (flock(fd, LOCK_SH | LOCK_NB) == -1) {
149 		err = (errno == EWOULDBLOCK ? got_error(GOT_ERR_WORKTREE_BUSY)
150 		    : got_error_from_errno());
151 		goto done;
152 	}
153 
154 	stat(path, &sb);
155 	*content = calloc(1, sb.st_size);
156 	if (*content == NULL) {
157 		err = got_error_from_errno();
158 		goto done;
159 	}
160 
161 	n = read(fd, *content, sb.st_size);
162 	if (n != sb.st_size) {
163 		err = (n == -1 ? got_error_from_errno() :
164 		    got_error(GOT_ERR_WORKTREE_META));
165 		goto done;
166 	}
167 	if ((*content)[sb.st_size - 1] != '\n') {
168 		err = got_error(GOT_ERR_WORKTREE_META);
169 		goto done;
170 	}
171 	(*content)[sb.st_size - 1] = '\0';
172 
173 done:
174 	if (fd != -1 && close(fd) == -1 && err == NULL)
175 		err = got_error_from_errno();
176 	free(path);
177 	if (err) {
178 		free(*content);
179 		*content = NULL;
180 	}
181 	return err;
182 }
183 
184 const struct got_error *
185 got_worktree_init(const char *path, struct got_reference *head_ref,
186     const char *prefix, struct got_repository *repo)
187 {
188 	const struct got_error *err = NULL;
189 	struct got_object_id *commit_id = NULL;
190 	int obj_type;
191 	char *path_got = NULL;
192 	char *refstr = NULL;
193 	char *formatstr = NULL;
194 	char *absprefix = NULL;
195 	char *basestr = NULL;
196 
197 	err = got_ref_resolve(&commit_id, repo, head_ref);
198 	if (err)
199 		return err;
200 	err = got_object_get_type(&obj_type, repo, commit_id);
201 	if (err)
202 		return err;
203 	if (obj_type != GOT_OBJ_TYPE_COMMIT)
204 		return got_error(GOT_ERR_OBJ_TYPE);
205 
206 	if (!got_path_is_absolute(prefix)) {
207 		if (asprintf(&absprefix, "/%s", prefix) == -1)
208 			return got_error_from_errno();
209 	}
210 
211 	/* Create top-level directory (may already exist). */
212 	if (mkdir(path, GOT_DEFAULT_DIR_MODE) == -1 && errno != EEXIST) {
213 		err = got_error_from_errno();
214 		goto done;
215 	}
216 
217 	/* Create .got directory (may already exist). */
218 	if (asprintf(&path_got, "%s/%s", path, GOT_WORKTREE_GOT_DIR) == -1) {
219 		err = got_error_from_errno();
220 		goto done;
221 	}
222 	if (mkdir(path_got, GOT_DEFAULT_DIR_MODE) == -1 && errno != EEXIST) {
223 		err = got_error_from_errno();
224 		goto done;
225 	}
226 
227 	/* Create an empty lock file. */
228 	err = create_meta_file(path_got, GOT_WORKTREE_LOCK, NULL);
229 	if (err)
230 		goto done;
231 
232 	/* Create an empty file index. */
233 	err = create_meta_file(path_got, GOT_WORKTREE_FILE_INDEX, NULL);
234 	if (err)
235 		goto done;
236 
237 	/* Write the HEAD reference. */
238 	refstr = got_ref_to_str(head_ref);
239 	if (refstr == NULL) {
240 		err = got_error_from_errno();
241 		goto done;
242 	}
243 	err = create_meta_file(path_got, GOT_WORKTREE_HEAD_REF, refstr);
244 	if (err)
245 		goto done;
246 
247 	/* Record our base commit. */
248 	err = got_object_id_str(&basestr, commit_id);
249 	if (err)
250 		goto done;
251 	err = create_meta_file(path_got, GOT_WORKTREE_BASE_COMMIT, basestr);
252 	if (err)
253 		goto done;
254 
255 	/* Store path to repository. */
256 	err = create_meta_file(path_got, GOT_WORKTREE_REPOSITORY,
257 	    got_repo_get_path(repo));
258 	if (err)
259 		goto done;
260 
261 	/* Store in-repository path prefix. */
262 	err = create_meta_file(path_got, GOT_WORKTREE_PATH_PREFIX,
263 	    absprefix ? absprefix : prefix);
264 	if (err)
265 		goto done;
266 
267 	/* Stamp work tree with format file. */
268 	if (asprintf(&formatstr, "%d", GOT_WORKTREE_FORMAT_VERSION) == -1) {
269 		err = got_error_from_errno();
270 		goto done;
271 	}
272 	err = create_meta_file(path_got, GOT_WORKTREE_FORMAT, formatstr);
273 	if (err)
274 		goto done;
275 
276 done:
277 	free(commit_id);
278 	free(path_got);
279 	free(formatstr);
280 	free(refstr);
281 	free(absprefix);
282 	free(basestr);
283 	return err;
284 }
285 
286 const struct got_error *
287 got_worktree_open(struct got_worktree **worktree, const char *path)
288 {
289 	const struct got_error *err = NULL;
290 	char *path_got;
291 	char *formatstr = NULL;
292 	char *path_lock = NULL;
293 	char *base_commit_id_str = NULL;
294 	char *head_ref_str = NULL;
295 	int version, fd = -1;
296 	const char *errstr;
297 	struct got_repository *repo = NULL;
298 
299 	*worktree = NULL;
300 
301 	if (asprintf(&path_got, "%s/%s", path, GOT_WORKTREE_GOT_DIR) == -1) {
302 		err = got_error_from_errno();
303 		path_got = NULL;
304 		goto done;
305 	}
306 
307 	if (asprintf(&path_lock, "%s/%s", path_got, GOT_WORKTREE_LOCK) == -1) {
308 		err = got_error_from_errno();
309 		path_lock = NULL;
310 		goto done;
311 	}
312 
313 	fd = open(path_lock, O_RDWR | O_EXLOCK | O_NONBLOCK);
314 	if (fd == -1) {
315 		err = (errno == EWOULDBLOCK ? got_error(GOT_ERR_WORKTREE_BUSY)
316 		    : got_error_from_errno());
317 		goto done;
318 	}
319 
320 	err = read_meta_file(&formatstr, path_got, GOT_WORKTREE_FORMAT);
321 	if (err)
322 		goto done;
323 
324 	version = strtonum(formatstr, 1, INT_MAX, &errstr);
325 	if (errstr) {
326 		err = got_error(GOT_ERR_WORKTREE_META);
327 		goto done;
328 	}
329 	if (version != GOT_WORKTREE_FORMAT_VERSION) {
330 		err = got_error(GOT_ERR_WORKTREE_VERS);
331 		goto done;
332 	}
333 
334 	*worktree = calloc(1, sizeof(**worktree));
335 	if (*worktree == NULL) {
336 		err = got_error_from_errno();
337 		goto done;
338 	}
339 	(*worktree)->lockfd = -1;
340 
341 	(*worktree)->root_path = strdup(path);
342 	if ((*worktree)->root_path == NULL) {
343 		err = got_error_from_errno();
344 		goto done;
345 	}
346 	err = read_meta_file(&(*worktree)->repo_path, path_got,
347 	    GOT_WORKTREE_REPOSITORY);
348 	if (err)
349 		goto done;
350 
351 	err = read_meta_file(&(*worktree)->path_prefix, path_got,
352 	    GOT_WORKTREE_PATH_PREFIX);
353 	if (err)
354 		goto done;
355 
356 	err = read_meta_file(&base_commit_id_str, path_got,
357 	    GOT_WORKTREE_BASE_COMMIT);
358 	if (err)
359 		goto done;
360 
361 	err = got_repo_open(&repo, (*worktree)->repo_path);
362 	if (err)
363 		goto done;
364 
365 	err = got_object_resolve_id_str(&(*worktree)->base_commit_id, repo,
366 	    base_commit_id_str);
367 	if (err)
368 		goto done;
369 
370 	err = read_meta_file(&head_ref_str, path_got, GOT_WORKTREE_HEAD_REF);
371 	if (err)
372 		goto done;
373 
374 	err = got_ref_open(&(*worktree)->head_ref, repo, head_ref_str);
375 done:
376 	if (repo)
377 		got_repo_close(repo);
378 	free(path_got);
379 	free(path_lock);
380 	free(head_ref_str);
381 	free(base_commit_id_str);
382 	if (err) {
383 		if (fd != -1)
384 			close(fd);
385 		if (*worktree != NULL)
386 			got_worktree_close(*worktree);
387 		*worktree = NULL;
388 	} else
389 		(*worktree)->lockfd = fd;
390 
391 	return err;
392 }
393 
394 void
395 got_worktree_close(struct got_worktree *worktree)
396 {
397 	free(worktree->root_path);
398 	free(worktree->repo_path);
399 	free(worktree->path_prefix);
400 	free(worktree->base_commit_id);
401 	if (worktree->head_ref)
402 		got_ref_close(worktree->head_ref);
403 	if (worktree->lockfd != -1)
404 		close(worktree->lockfd);
405 	free(worktree);
406 }
407 
408 const char *
409 got_worktree_get_repo_path(struct got_worktree *worktree)
410 {
411 	return worktree->repo_path;
412 }
413 
414 const char *
415 got_worktree_get_path_prefix(struct got_worktree *worktree)
416 {
417 	return worktree->path_prefix;
418 }
419 
420 const struct got_error *
421 got_worktree_match_path_prefix(int *match, struct got_worktree *worktree,
422     const char *path_prefix)
423 {
424 	char *absprefix = NULL;
425 
426 	if (!got_path_is_absolute(path_prefix)) {
427 		if (asprintf(&absprefix, "/%s", path_prefix) == -1)
428 			return got_error_from_errno();
429 	}
430 	*match = (strcmp(absprefix ? absprefix : path_prefix,
431 	    worktree->path_prefix) == 0);
432 	free(absprefix);
433 	return NULL;
434 }
435 
436 char *
437 got_worktree_get_head_ref_name(struct got_worktree *worktree)
438 {
439 	return got_ref_to_str(worktree->head_ref);
440 }
441 
442 struct got_reference *
443 got_worktree_get_head_ref(struct got_worktree *worktree)
444 {
445 	return got_ref_dup(worktree->head_ref);
446 }
447 
448 const struct got_object_id *
449 got_worktree_get_base_commit_id(struct got_worktree *worktree)
450 {
451 	return worktree->base_commit_id;
452 }
453 
454 const struct got_error *
455 got_worktree_set_base_commit_id(struct got_worktree *worktree,
456     struct got_repository *repo, struct got_object_id *commit_id)
457 {
458 	const struct got_error *err;
459 	struct got_object *obj = NULL;
460 	char *id_str = NULL;
461 	char *path_got = NULL;
462 
463 	if (asprintf(&path_got, "%s/%s", worktree->root_path,
464 	    GOT_WORKTREE_GOT_DIR) == -1) {
465 		err = got_error_from_errno();
466 		path_got = NULL;
467 		goto done;
468 	}
469 
470 	err = got_object_open(&obj, repo, commit_id);
471 	if (err)
472 		return err;
473 
474 	if (obj->type != GOT_OBJ_TYPE_COMMIT) {
475 		err = got_error(GOT_ERR_OBJ_TYPE);
476 		goto done;
477 	}
478 
479 	/* Record our base commit. */
480 	err = got_object_id_str(&id_str, commit_id);
481 	if (err)
482 		goto done;
483 	err = update_meta_file(path_got, GOT_WORKTREE_BASE_COMMIT, id_str);
484 	if (err)
485 		goto done;
486 
487 	free(worktree->base_commit_id);
488 	worktree->base_commit_id = got_object_id_dup(commit_id);
489 	if (worktree->base_commit_id == NULL) {
490 		err = got_error_from_errno();
491 		goto done;
492 	}
493 done:
494 	if (obj)
495 		got_object_close(obj);
496 	free(id_str);
497 	free(path_got);
498 	return err;
499 }
500 
501 static const struct got_error *
502 lock_worktree(struct got_worktree *worktree, int operation)
503 {
504 	if (flock(worktree->lockfd, operation | LOCK_NB) == -1)
505 		return (errno == EWOULDBLOCK ? got_error(GOT_ERR_WORKTREE_BUSY)
506 		    : got_error_from_errno());
507 	return NULL;
508 }
509 
510 static const struct got_error *
511 make_parent_dirs(const char *abspath)
512 {
513 	const struct got_error *err = NULL;
514 
515 	char *parent = dirname(abspath);
516 	if (parent == NULL)
517 		return NULL;
518 
519 	if (mkdir(parent, GOT_DEFAULT_DIR_MODE) == -1) {
520 		if (errno == ENOENT) {
521 			err = make_parent_dirs(parent);
522 			if (err)
523 				return err;
524 			if (mkdir(parent, GOT_DEFAULT_DIR_MODE) == -1)
525 				return got_error_from_errno();
526 		} else
527 			err = got_error_from_errno();
528 	}
529 
530 	return err;
531 }
532 
533 static const struct got_error *
534 add_dir_on_disk(struct got_worktree *worktree, const char *path)
535 {
536 	const struct got_error *err = NULL;
537 	char *abspath;
538 
539 	if (asprintf(&abspath, "%s/%s", worktree->root_path, path) == -1)
540 		return got_error_from_errno();
541 
542 	/* XXX queue work rather than editing disk directly? */
543 	if (mkdir(abspath, GOT_DEFAULT_DIR_MODE) == -1) {
544 		struct stat sb;
545 
546 		if (errno == EEXIST) {
547 			if (lstat(abspath, &sb) == -1) {
548 				err = got_error_from_errno();
549 				goto done;
550 			}
551 
552 			if (!S_ISDIR(sb.st_mode)) {
553 				/* TODO directory is obstructed; do something */
554 				err = got_error(GOT_ERR_FILE_OBSTRUCTED);
555 				goto done;
556 			}
557 
558 			return NULL;
559 		} else if (errno == ENOENT) {
560 			err = make_parent_dirs(abspath);
561 			if (err)
562 				goto done;
563 			if (mkdir(abspath, GOT_DEFAULT_DIR_MODE) == -1)
564 				err = got_error_from_errno();
565 		} else
566 			err = got_error_from_errno();
567 	}
568 
569 done:
570 	free(abspath);
571 	return err;
572 }
573 
574 static const struct got_error *
575 install_blob(struct got_worktree *worktree, struct got_fileindex *fileindex,
576    struct got_fileindex_entry *entry, const char *path,
577    struct got_blob_object *blob,
578    struct got_repository *repo, got_worktree_checkout_cb progress_cb,
579    void *progress_arg)
580 {
581 	const struct got_error *err = NULL;
582 	char *ondisk_path;
583 	int fd = -1;
584 	size_t len, hdrlen;
585 	int update = 0;
586 	char *tmppath = NULL;
587 
588 	if (asprintf(&ondisk_path, "%s/%s", worktree->root_path, path) == -1)
589 		return got_error_from_errno();
590 
591 	fd = open(ondisk_path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW,
592 	    GOT_DEFAULT_FILE_MODE);
593 	if (fd == -1) {
594 		if (errno == ENOENT) {
595 			char *parent = dirname(path);
596 			if (parent == NULL)
597 				return got_error_from_errno();
598 			err = add_dir_on_disk(worktree, parent);
599 			if (err)
600 				return err;
601 			fd = open(ondisk_path,
602 			    O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW,
603 			    GOT_DEFAULT_FILE_MODE);
604 			if (fd == -1)
605 				return got_error_from_errno();
606 		} else if (errno == EEXIST) {
607 			struct stat sb;
608 			if (lstat(ondisk_path, &sb) == -1) {
609 				err = got_error_from_errno();
610 				goto done;
611 			} else if (!S_ISREG(sb.st_mode)) {
612 				/* TODO file is obstructed; do something */
613 				err = got_error(GOT_ERR_FILE_OBSTRUCTED);
614 				goto done;
615 			} else {
616 				err = got_opentemp_named_fd(&tmppath, &fd,
617 				    ondisk_path);
618 				if (err)
619 					goto done;
620 				update = 1;
621 			}
622 		} else
623 			return got_error_from_errno();
624 	}
625 
626 	(*progress_cb)(progress_arg,
627 	    update ? GOT_STATUS_UPDATE : GOT_STATUS_ADD, path);
628 
629 	hdrlen = got_object_blob_get_hdrlen(blob);
630 	do {
631 		const uint8_t *buf = got_object_blob_get_read_buf(blob);
632 		err = got_object_blob_read_block(&len, blob);
633 		if (err)
634 			break;
635 		if (len > 0) {
636 			/* Skip blob object header first time around. */
637 			ssize_t outlen = write(fd, buf + hdrlen, len - hdrlen);
638 			if (outlen == -1) {
639 				err = got_error_from_errno();
640 				goto done;
641 			} else if (outlen != len - hdrlen) {
642 				err = got_error(GOT_ERR_IO);
643 				goto done;
644 			}
645 			hdrlen = 0;
646 		}
647 	} while (len != 0);
648 
649 	fsync(fd);
650 
651 	if (update) {
652 		if (rename(tmppath, ondisk_path) != 0) {
653 			err = got_error_from_errno();
654 			goto done;
655 		}
656 	}
657 
658 	if (entry == NULL)
659 		entry = got_fileindex_entry_get(fileindex, path);
660 	if (entry)
661 		err = got_fileindex_entry_update(entry, ondisk_path,
662 		    blob->id.sha1, worktree->base_commit_id->sha1);
663 	else {
664 		err = got_fileindex_entry_alloc(&entry, ondisk_path,
665 		    path, blob->id.sha1, worktree->base_commit_id->sha1);
666 		if (err)
667 			goto done;
668 		err = got_fileindex_entry_add(fileindex, entry);
669 	}
670 done:
671 	if (fd != -1)
672 		close(fd);
673 	free(ondisk_path);
674 	free(tmppath);
675 	return err;
676 }
677 
678 static const struct got_error *
679 update_blob(struct got_worktree *worktree,
680     struct got_fileindex *fileindex, struct got_fileindex_entry *ie,
681     struct got_tree_entry *te, const char *path,
682     struct got_repository *repo, got_worktree_checkout_cb progress_cb,
683     void *progress_arg, got_worktree_cancel_cb cancel_cb, void *cancel_arg)
684 {
685 	const struct got_error *err = NULL;
686 	struct got_blob_object *blob = NULL;
687 
688 	if (ie) {
689 		if (memcmp(ie->commit_sha1, worktree->base_commit_id->sha1,
690 		    SHA1_DIGEST_LENGTH) == 0) {
691 			(*progress_cb)(progress_arg, GOT_STATUS_EXISTS,
692 			    path);
693 			return NULL;
694 		}
695 		if (memcmp(ie->blob_sha1,
696 		    te->id->sha1, SHA1_DIGEST_LENGTH) == 0)
697 			return NULL;
698 	}
699 
700 	err = got_object_open_as_blob(&blob, repo, te->id, 8192);
701 	if (err)
702 		return err;
703 
704 	err = install_blob(worktree, fileindex, ie, path, blob, repo,
705 	    progress_cb, progress_arg);
706 	got_object_blob_close(blob);
707 	return err;
708 }
709 
710 static const struct got_error *
711 remove_ondisk_file(const char *root_path, const char *path)
712 {
713 	const struct got_error *err = NULL;
714 	char *ondisk_path = NULL;
715 
716 	if (asprintf(&ondisk_path, "%s/%s", root_path, path) == -1)
717 		return got_error_from_errno();
718 
719 	if (unlink(ondisk_path) == -1) {
720 		if (errno != ENOENT)
721 			err = got_error_from_errno();
722 	} else {
723 		char *parent = dirname(ondisk_path);
724 		while (parent && strcmp(parent, root_path) != 0) {
725 			if (rmdir(parent) == -1) {
726 				if (errno != ENOTEMPTY)
727 					err = got_error_from_errno();
728 				break;
729 			}
730 			parent = dirname(parent);
731 		}
732 	}
733 	free(ondisk_path);
734 	return err;
735 }
736 
737 struct diff_cb_arg {
738     struct got_fileindex *fileindex;
739     struct got_worktree *worktree;
740     struct got_repository *repo;
741     got_worktree_checkout_cb progress_cb;
742     void *progress_arg;
743     got_worktree_cancel_cb cancel_cb;
744     void *cancel_arg;
745 };
746 
747 static const struct got_error *
748 diff_old_new(void *arg, struct got_fileindex_entry *ie,
749     struct got_tree_entry *te, const char *parent_path)
750 {
751 	struct diff_cb_arg *a = arg;
752 
753 	return update_blob(a->worktree, a->fileindex, ie, te,
754 	    ie->path, a->repo, a->progress_cb, a->progress_arg,
755 	    a->cancel_cb, a->cancel_arg);
756 }
757 
758 static const struct got_error *
759 diff_old(void *arg, struct got_fileindex_entry *ie, const char *parent_path)
760 {
761 	const struct got_error *err;
762 	struct diff_cb_arg *a = arg;
763 
764 	(*a->progress_cb)(a->progress_arg, GOT_STATUS_DELETE, ie->path);
765 
766 	err = remove_ondisk_file(a->worktree->root_path, ie->path);
767 	if (err)
768 		return err;
769 	got_fileindex_entry_remove(a->fileindex, ie);
770 	return NULL;
771 }
772 
773 static const struct got_error *
774 diff_new(void *arg, struct got_tree_entry *te, const char *parent_path)
775 {
776 	struct diff_cb_arg *a = arg;
777 	const struct got_error *err;
778 	char *path;
779 
780 	if (asprintf(&path, "%s%s%s", parent_path,
781 	    parent_path[0] ? "/" : "", te->name)
782 	    == -1)
783 		return got_error_from_errno();
784 
785 	if (S_ISDIR(te->mode))
786 		err = add_dir_on_disk(a->worktree, path);
787 	else
788 		err = update_blob(a->worktree, a->fileindex, NULL, te, path,
789 		    a->repo, a->progress_cb, a->progress_arg,
790 		    a->cancel_cb, a->cancel_arg);
791 
792 	free(path);
793 	return err;
794 }
795 
796 const struct got_error *
797 got_worktree_checkout_files(struct got_worktree *worktree,
798     struct got_repository *repo, got_worktree_checkout_cb progress_cb,
799     void *progress_arg, got_worktree_cancel_cb cancel_cb, void *cancel_arg)
800 {
801 	const struct got_error *err = NULL, *unlockerr, *checkout_err = NULL;
802 	struct got_commit_object *commit = NULL;
803 	struct got_object_id *tree_id = NULL;
804 	struct got_tree_object *tree = NULL;
805 	char *fileindex_path = NULL, *new_fileindex_path = NULL;
806 	struct got_fileindex *fileindex = NULL;
807 	FILE *index = NULL, *new_index = NULL;
808 	struct got_fileindex_diff_tree_cb diff_cb;
809 	struct diff_cb_arg arg;
810 
811 	err = lock_worktree(worktree, LOCK_EX);
812 	if (err)
813 		return err;
814 
815 	fileindex = got_fileindex_alloc();
816 	if (fileindex == NULL) {
817 		err = got_error_from_errno();
818 		goto done;
819 	}
820 
821 	if (asprintf(&fileindex_path, "%s/%s/%s", worktree->root_path,
822 	    GOT_WORKTREE_GOT_DIR, GOT_WORKTREE_FILE_INDEX) == -1) {
823 		err = got_error_from_errno();
824 		fileindex_path = NULL;
825 		goto done;
826 	}
827 
828 	/*
829 	 * Read the file index.
830 	 * Checking out files is supposed to be an idempotent operation.
831 	 * If the on-disk file index is incomplete we will try to complete it.
832 	 */
833 	index = fopen(fileindex_path, "rb");
834 	if (index == NULL) {
835 		if (errno != ENOENT) {
836 			err = got_error_from_errno();
837 			goto done;
838 		}
839 	} else {
840 		err = got_fileindex_read(fileindex, index);
841 		fclose(index);
842 		if (err)
843 			goto done;
844 	}
845 
846 	err = got_opentemp_named(&new_fileindex_path, &new_index,
847 	    fileindex_path);
848 	if (err)
849 		goto done;
850 
851 	err = got_object_open_as_commit(&commit, repo,
852 	   worktree->base_commit_id);
853 	if (err)
854 		goto done;
855 
856 	err = got_object_id_by_path(&tree_id, repo,
857 	    worktree->base_commit_id, worktree->path_prefix);
858 	if (err)
859 		goto done;
860 
861 	err = got_object_open_as_tree(&tree, repo, tree_id);
862 	if (err)
863 		goto done;
864 
865 	diff_cb.diff_old_new = diff_old_new;
866 	diff_cb.diff_old = diff_old;
867 	diff_cb.diff_new = diff_new;
868 	arg.fileindex = fileindex;
869 	arg.worktree = worktree;
870 	arg.repo = repo;
871 	arg.progress_cb = progress_cb;
872 	arg.progress_arg = progress_arg;
873 	arg.cancel_cb = cancel_cb;
874 	arg.cancel_arg = cancel_arg;
875 	checkout_err = got_fileindex_diff_tree(fileindex, tree, repo,
876 	    &diff_cb, &arg);
877 
878 	/* Try to sync the fileindex back to disk in any case. */
879 	err = got_fileindex_write(fileindex, new_index);
880 	if (err)
881 		goto done;
882 
883 	if (rename(new_fileindex_path, fileindex_path) != 0) {
884 		err = got_error_from_errno();
885 		goto done;
886 	}
887 
888 	free(new_fileindex_path);
889 	new_fileindex_path = NULL;
890 
891 done:
892 	if (tree)
893 		got_object_tree_close(tree);
894 	if (commit)
895 		got_object_commit_close(commit);
896 	if (new_fileindex_path)
897 		unlink(new_fileindex_path);
898 	if (new_index)
899 		fclose(new_index);
900 	free(new_fileindex_path);
901 	free(fileindex_path);
902 	got_fileindex_free(fileindex);
903 	if (checkout_err)
904 		err = checkout_err;
905 	unlockerr = lock_worktree(worktree, LOCK_SH);
906 	if (unlockerr && err == NULL)
907 		err = unlockerr;
908 	return err;
909 }
910 
911 struct diff_dir_cb_arg {
912     struct got_fileindex *fileindex;
913     struct got_worktree *worktree;
914     struct got_repository *repo;
915     got_worktree_status_cb status_cb;
916     void *status_arg;
917     got_worktree_cancel_cb cancel_cb;
918     void *cancel_arg;
919 };
920 
921 static const struct got_error *
922 get_file_status(unsigned char *status, struct got_fileindex_entry *ie,
923     const char *abspath, struct got_repository *repo)
924 {
925 	const struct got_error *err = NULL;
926 	struct got_object_id id;
927 	size_t hdrlen;
928 	FILE *f = NULL;
929 	uint8_t fbuf[8192];
930 	struct got_blob_object *blob = NULL;
931 	size_t flen, blen;
932 	struct stat sb;
933 
934 	*status = GOT_STATUS_NO_CHANGE;
935 
936 	if (lstat(abspath, &sb) == -1)
937 		return got_error_from_errno();
938 
939 	if (!S_ISREG(sb.st_mode)) {
940 		*status = GOT_STATUS_OBSTRUCTED;
941 		return NULL;
942 	}
943 
944 	if (ie->ctime_sec == sb.st_ctime &&
945 	    ie->ctime_nsec == sb.st_ctimensec &&
946 	    ie->mtime_sec == sb.st_mtime &&
947 	    ie->mtime_sec == sb.st_mtime &&
948 	    ie->mtime_nsec == sb.st_mtimensec &&
949 	    ie->size == (sb.st_size & 0xffffffff))
950 		return NULL;
951 
952 	memcpy(id.sha1, ie->blob_sha1, sizeof(id.sha1));
953 	err = got_object_open_as_blob(&blob, repo, &id, sizeof(fbuf));
954 	if (err)
955 		return err;
956 
957 	f = fopen(abspath, "r");
958 	if (f == NULL) {
959 		err = got_error_from_errno();
960 		goto done;
961 	}
962 	hdrlen = got_object_blob_get_hdrlen(blob);
963 	while (1) {
964 		const uint8_t *bbuf = got_object_blob_get_read_buf(blob);
965 		err = got_object_blob_read_block(&blen, blob);
966 		if (err)
967 			break;
968 		flen = fread(fbuf, 1, sizeof(fbuf), f);
969 		if (blen == 0) {
970 			if (flen != 0)
971 				*status = GOT_STATUS_MODIFIY;
972 			break;
973 		} else if (flen == 0) {
974 			if (blen != 0)
975 				*status = GOT_STATUS_MODIFIY;
976 			break;
977 		} else if (blen == flen) {
978 			/* Skip blob object header first time around. */
979 			if (memcmp(bbuf + hdrlen, fbuf, flen) != 0) {
980 				*status = GOT_STATUS_MODIFIY;
981 				break;
982 			}
983 		} else {
984 			*status = GOT_STATUS_MODIFIY;
985 			break;
986 		}
987 		hdrlen = 0;
988 	}
989 done:
990 	if (blob)
991 		got_object_blob_close(blob);
992 	if (f)
993 		fclose(f);
994 	return err;
995 }
996 
997 static const struct got_error *
998 status_old_new(void *arg, struct got_fileindex_entry *ie,
999     struct dirent *de, const char *parent_path)
1000 {
1001 	const struct got_error *err = NULL;
1002 	struct diff_dir_cb_arg *a = arg;
1003 	char *abspath;
1004 	unsigned char status = GOT_STATUS_NO_CHANGE;
1005 
1006 	if (parent_path[0]) {
1007 		if (asprintf(&abspath, "%s/%s/%s", a->worktree->root_path,
1008 		    parent_path, de->d_name) == -1)
1009 			return got_error_from_errno();
1010 	} else {
1011 		if (asprintf(&abspath, "%s/%s", a->worktree->root_path,
1012 		    de->d_name) == -1)
1013 			return got_error_from_errno();
1014 	}
1015 
1016 	err = get_file_status(&status, ie, abspath, a->repo);
1017 	if (err == NULL && status != GOT_STATUS_NO_CHANGE)
1018 		(*a->status_cb)(a->status_arg, status, ie->path);
1019 	free(abspath);
1020 	return err;
1021 }
1022 
1023 static const struct got_error *
1024 status_old(void *arg, struct got_fileindex_entry *ie, const char *parent_path)
1025 {
1026 	struct diff_dir_cb_arg *a = arg;
1027 	(*a->status_cb)(a->status_arg, GOT_STATUS_MISSING, ie->path);
1028 	return NULL;
1029 }
1030 
1031 static const struct got_error *
1032 status_new(void *arg, struct dirent *de, const char *parent_path)
1033 {
1034 	struct diff_dir_cb_arg *a = arg;
1035 	char *path = NULL;
1036 
1037 	if (de->d_type == DT_DIR)
1038 		return NULL;
1039 
1040 	if (parent_path[0]) {
1041 		if (asprintf(&path, "%s/%s", parent_path, de->d_name) == -1)
1042 			return got_error_from_errno();
1043 	} else {
1044 		path = de->d_name;
1045 	}
1046 
1047 	(*a->status_cb)(a->status_arg, GOT_STATUS_UNVERSIONED, path);
1048 	if (parent_path[0])
1049 		free(path);
1050 	return NULL;
1051 }
1052 
1053 const struct got_error *
1054 got_worktree_status(struct got_worktree *worktree,
1055     struct got_repository *repo, got_worktree_status_cb status_cb,
1056     void *status_arg, got_worktree_cancel_cb cancel_cb, void *cancel_arg)
1057 {
1058 	const struct got_error *err = NULL;
1059 	DIR *workdir = NULL;
1060 	char *fileindex_path = NULL;
1061 	struct got_fileindex *fileindex = NULL;
1062 	FILE *index = NULL;
1063 	struct got_fileindex_diff_dir_cb fdiff_cb;
1064 	struct diff_dir_cb_arg arg;
1065 
1066 	fileindex = got_fileindex_alloc();
1067 	if (fileindex == NULL) {
1068 		err = got_error_from_errno();
1069 		goto done;
1070 	}
1071 
1072 	if (asprintf(&fileindex_path, "%s/%s/%s", worktree->root_path,
1073 	    GOT_WORKTREE_GOT_DIR, GOT_WORKTREE_FILE_INDEX) == -1) {
1074 		err = got_error_from_errno();
1075 		fileindex_path = NULL;
1076 		goto done;
1077 	}
1078 
1079 	index = fopen(fileindex_path, "rb");
1080 	if (index == NULL) {
1081 		if (errno != ENOENT) {
1082 			err = got_error_from_errno();
1083 			goto done;
1084 		}
1085 	} else {
1086 		err = got_fileindex_read(fileindex, index);
1087 		fclose(index);
1088 		if (err)
1089 			goto done;
1090 	}
1091 
1092 	workdir = opendir(worktree->root_path);
1093 	fdiff_cb.diff_old_new = status_old_new;
1094 	fdiff_cb.diff_old = status_old;
1095 	fdiff_cb.diff_new = status_new;
1096 	arg.fileindex = fileindex;
1097 	arg.worktree = worktree;
1098 	arg.repo = repo;
1099 	arg.status_cb = status_cb;
1100 	arg.status_arg = status_arg;
1101 	arg.cancel_cb = cancel_cb;
1102 	arg.cancel_arg = cancel_arg;
1103 	err = got_fileindex_diff_dir(fileindex, workdir, repo, &fdiff_cb, &arg);
1104 done:
1105 	if (workdir)
1106 		closedir(workdir);
1107 	free(fileindex_path);
1108 	got_fileindex_free(fileindex);
1109 	return err;
1110 }