/home/ben/Projects/got/got/../lib/worktree.c

Bug Summary

File:	got/../lib/worktree.c
Warning:	line 6792, column 18 Null pointer passed as 1st argument to string comparison function
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd6.9 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name worktree.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/local/lib/clang/11.1.0 -I /home/ben/Projects/got/got/../include -I /home/ben/Projects/got/got/../lib -D GOT_LIBEXECDIR=/home/ben/bin -D GOT_VERSION=0.53-current -internal-isystem /usr/local/lib/clang/11.1.0/include -internal-externc-isystem /usr/include -O0 -fdebug-compilation-dir /home/ben/Projects/got/got/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/got/scan/2021-05-28-230913-68537-1 -x c /home/ben/Projects/got/got/../lib/worktree.c
1/*
* Copyright (c) 2018, 2019, 2020 Stefan Sperling <stsp@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

17#include <sys/stat.h>
18#include <sys/queue.h>
19#include <sys/tree.h>

21#include <dirent.h>
22#include <limits.h>
23#include <stddef.h>
24#include <string.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <time.h>
28#include <fcntl.h>
29#include <errno(*__errno()).h>
30#include <unistd.h>
31#include <sha1.h>
32#include <zlib.h>
33#include <fnmatch.h>
34#include <libgen.h>
35#include <uuid.h>
36#include <util.h>

38#include "got_error.h"
39#include "got_repository.h"
40#include "got_reference.h"
41#include "got_object.h"
42#include "got_path.h"
43#include "got_cancel.h"
44#include "got_worktree.h"
45#include "got_opentemp.h"
46#include "got_diff.h"

48#include "got_lib_worktree.h"
49#include "got_lib_sha1.h"
50#include "got_lib_fileindex.h"
51#include "got_lib_inflate.h"
52#include "got_lib_delta.h"
53#include "got_lib_object.h"
54#include "got_lib_object_parse.h"
55#include "got_lib_object_create.h"
56#include "got_lib_object_idset.h"
57#include "got_lib_diff.h"
58#include "got_lib_gotconfig.h"

60#ifndef MIN
61#define	MIN(_a,_b)((_a) < (_b) ? (_a) : (_b)) ((_a) < (_b) ? (_a) : (_b))
62#endif

64#define GOT_MERGE_LABEL_MERGED"merged change"	"merged change"
65#define GOT_MERGE_LABEL_BASE"3-way merge base"	"3-way merge base"

67static const struct got_error *
68create_meta_file(const char *path_got, const char *name, const char *content)
69{
const struct got_error *err = NULL((void*)0);
char *path;

if (asprintf(&path, "%s/%s", path_got, name) == -1)
return got_error_from_errno("asprintf");

err = got_path_create_file(path, content);
free(path);
return err;
79}

81static const struct got_error *
82update_meta_file(const char *path_got, const char *name, const char *content)
83{
const struct got_error *err = NULL((void*)0);
FILE *tmpfile = NULL((void*)0);
char *tmppath = NULL((void*)0);
char *path = NULL((void*)0);

if (asprintf(&path, "%s/%s", path_got, name) == -1) {
err = got_error_from_errno("asprintf");
path = NULL((void*)0);
goto done;
}

err = got_opentemp_named(&tmppath, &tmpfile, path);
if (err)
goto done;

if (content) {
int len = fprintf(tmpfile, "%s\n", content);
if (len != strlen(content) + 1) {
	err = got_error_from_errno2("fprintf", tmppath);
	goto done;
}
}

if (rename(tmppath, path) != 0) {
err = got_error_from_errno3("rename", tmppath, path);
unlink(tmppath);
goto done;
}

113done:
if (fclose(tmpfile) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", tmppath);
free(tmppath);
return err;
118}

120static const struct got_error *
121read_meta_file(char **content, const char *path_got, const char *name)
122{
const struct got_error *err = NULL((void*)0);
char *path;
int fd = -1;
ssize_t n;
struct stat sb;

*content = NULL((void*)0);

if (asprintf(&path, "%s/%s", path_got, name) == -1) {
err = got_error_from_errno("asprintf");
path = NULL((void*)0);
goto done;
}

fd = open(path, O_RDONLY0x0000 | O_NOFOLLOW0x0100);
if (fd == -1) {
if (errno(*__errno()) == ENOENT2)
	err = got_error_path(path, GOT_ERR_WORKTREE_META27);
else
	err = got_error_from_errno2("open", path);
goto done;
}
if (flock(fd, LOCK_SH0x01 | LOCK_NB0x04) == -1) {
err = (errno(*__errno()) == EWOULDBLOCK35 ? got_error(GOT_ERR_WORKTREE_BUSY29)
    : got_error_from_errno2("flock", path));
goto done;
}

if (fstat(fd, &sb) != 0) {
err = got_error_from_errno2("fstat", path);
goto done;
}
*content = calloc(1, sb.st_size);
if (*content == NULL((void*)0)) {
err = got_error_from_errno("calloc");
goto done;
}

n = read(fd, *content, sb.st_size);
if (n != sb.st_size) {
err = (n == -1 ? got_error_from_errno2("read", path) :
    got_error_path(path, GOT_ERR_WORKTREE_META27));
goto done;
}
if ((*content)[sb.st_size - 1] != '\n') {
err = got_error_path(path, GOT_ERR_WORKTREE_META27);
goto done;
}
(*content)[sb.st_size - 1] = '\0';

173done:
if (fd != -1 && close(fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("close", path_got);
free(path);
if (err) {
free(*content);
*content = NULL((void*)0);
}
return err;
182}

184static const struct got_error *
185write_head_ref(const char *path_got, struct got_reference *head_ref)
186{
const struct got_error *err = NULL((void*)0);
char *refstr = NULL((void*)0);

if (got_ref_is_symbolic(head_ref)) {
refstr = got_ref_to_str(head_ref);
if (refstr == NULL((void*)0))
	return got_error_from_errno("got_ref_to_str");
} else {
refstr = strdup(got_ref_get_name(head_ref));
if (refstr == NULL((void*)0))
	return got_error_from_errno("strdup");
}
err = update_meta_file(path_got, GOT_WORKTREE_HEAD_REF"head-ref", refstr);
free(refstr);
return err;
202}

204const struct got_error *
205got_worktree_init(const char *path, struct got_reference *head_ref,
  const char *prefix, struct got_repository *repo)
207{
const struct got_error *err = NULL((void*)0);
struct got_object_id *commit_id = NULL((void*)0);
uuid_t uuid;
uint32_t uuid_status;
int obj_type;
char *path_got = NULL((void*)0);
char *formatstr = NULL((void*)0);
char *absprefix = NULL((void*)0);
char *basestr = NULL((void*)0);
char *uuidstr = NULL((void*)0);

if (strcmp(path, got_repo_get_path(repo)) == 0) {
err = got_error(GOT_ERR_WORKTREE_REPO66);
goto done;
}

err = got_ref_resolve(&commit_id, repo, head_ref);
if (err)
return err;
err = got_object_get_type(&obj_type, repo, commit_id);
if (err)
return err;
if (obj_type != GOT_OBJ_TYPE_COMMIT1)
return got_error(GOT_ERR_OBJ_TYPE11);

if (!got_path_is_absolute(prefix)) {
if (asprintf(&absprefix, "/%s", prefix) == -1)
	return got_error_from_errno("asprintf");
}

/* Create top-level directory (may already exist). */
if (mkdir(path, GOT_DEFAULT_DIR_MODE(0040000 | 0000700 | 0000040|0000010 | 0000004|0000001)) == -1 && errno(*__errno()) != EEXIST17) {
err = got_error_from_errno2("mkdir", path);
goto done;
}

/* Create .got directory (may already exist). */
if (asprintf(&path_got, "%s/%s", path, GOT_WORKTREE_GOT_DIR".got") == -1) {
err = got_error_from_errno("asprintf");
goto done;
}
if (mkdir(path_got, GOT_DEFAULT_DIR_MODE(0040000 | 0000700 | 0000040|0000010 | 0000004|0000001)) == -1 && errno(*__errno()) != EEXIST17) {
err = got_error_from_errno2("mkdir", path_got);
goto done;
}

/* Create an empty lock file. */
err = create_meta_file(path_got, GOT_WORKTREE_LOCK"lock", NULL((void*)0));
if (err)
goto done;

/* Create an empty file index. */
err = create_meta_file(path_got, GOT_WORKTREE_FILE_INDEX"file-index", NULL((void*)0));
if (err)
goto done;

/* Write the HEAD reference. */
err = write_head_ref(path_got, head_ref);
if (err)
goto done;

/* Record our base commit. */
err = got_object_id_str(&basestr, commit_id);
if (err)
goto done;
err = create_meta_file(path_got, GOT_WORKTREE_BASE_COMMIT"base-commit", basestr);
if (err)
goto done;

/* Store path to repository. */
err = create_meta_file(path_got, GOT_WORKTREE_REPOSITORY"repository",
   got_repo_get_path(repo));
if (err)
goto done;

/* Store in-repository path prefix. */
err = create_meta_file(path_got, GOT_WORKTREE_PATH_PREFIX"path-prefix",
   absprefix ? absprefix : prefix);
if (err)
goto done;

/* Generate UUID. */
uuid_create(&uuid, &uuid_status);
if (uuid_status != uuid_s_ok0) {
err = got_error_uuid(uuid_status, "uuid_create");
goto done;
}
uuid_to_string(&uuid, &uuidstr, &uuid_status);
if (uuid_status != uuid_s_ok0) {
err = got_error_uuid(uuid_status, "uuid_to_string");
goto done;
}
err = create_meta_file(path_got, GOT_WORKTREE_UUID"uuid", uuidstr);
if (err)
goto done;

/* Stamp work tree with format file. */
if (asprintf(&formatstr, "%d", GOT_WORKTREE_FORMAT_VERSION1) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}
err = create_meta_file(path_got, GOT_WORKTREE_FORMAT"format", formatstr);
if (err)
goto done;

313done:
free(commit_id);
free(path_got);
free(formatstr);
free(absprefix);
free(basestr);
free(uuidstr);
return err;
321}

323static const struct got_error *
324open_worktree(struct got_worktree **worktree, const char *path)
325{
const struct got_error *err = NULL((void*)0);
char *path_got;
char *formatstr = NULL((void*)0);
char *uuidstr = NULL((void*)0);
char *path_lock = NULL((void*)0);
char *base_commit_id_str = NULL((void*)0);
int version, fd = -1;
const char *errstr;
struct got_repository *repo = NULL((void*)0);
uint32_t uuid_status;

*worktree = NULL((void*)0);

if (asprintf(&path_got, "%s/%s", path, GOT_WORKTREE_GOT_DIR".got") == -1) {
err = got_error_from_errno("asprintf");
path_got = NULL((void*)0);
goto done;
}

if (asprintf(&path_lock, "%s/%s", path_got, GOT_WORKTREE_LOCK"lock") == -1) {
err = got_error_from_errno("asprintf");
path_lock = NULL((void*)0);
goto done;
}

fd = open(path_lock, O_RDWR0x0002 | O_EXLOCK0x0020 | O_NONBLOCK0x0004);
if (fd == -1) {
err = (errno(*__errno()) == EWOULDBLOCK35 ? got_error(GOT_ERR_WORKTREE_BUSY29)
    : got_error_from_errno2("open", path_lock));
goto done;
}

err = read_meta_file(&formatstr, path_got, GOT_WORKTREE_FORMAT"format");
if (err)
goto done;

version = strtonum(formatstr, 1, INT_MAX2147483647, &errstr);
if (errstr) {
err = got_error_msg(GOT_ERR_WORKTREE_META27,
    "could not parse work tree format version number");
goto done;
}
if (version != GOT_WORKTREE_FORMAT_VERSION1) {
err = got_error(GOT_ERR_WORKTREE_VERS28);
goto done;
}

*worktree = calloc(1, sizeof(**worktree));
if (*worktree == NULL((void*)0)) {
err = got_error_from_errno("calloc");
goto done;
}
(*worktree)->lockfd = -1;

(*worktree)->root_path = realpath(path, NULL((void*)0));
if ((*worktree)->root_path == NULL((void*)0)) {
err = got_error_from_errno2("realpath", path);
goto done;
}
err = read_meta_file(&(*worktree)->repo_path, path_got,
   GOT_WORKTREE_REPOSITORY"repository");
if (err)
goto done;

err = read_meta_file(&(*worktree)->path_prefix, path_got,
   GOT_WORKTREE_PATH_PREFIX"path-prefix");
if (err)
goto done;

err = read_meta_file(&base_commit_id_str, path_got,
   GOT_WORKTREE_BASE_COMMIT"base-commit");
if (err)
goto done;

err = read_meta_file(&uuidstr, path_got, GOT_WORKTREE_UUID"uuid");
if (err)
goto done;
uuid_from_string(uuidstr, &(*worktree)->uuid, &uuid_status);
if (uuid_status != uuid_s_ok0) {
err = got_error_uuid(uuid_status, "uuid_from_string");
goto done;
}

err = got_repo_open(&repo, (*worktree)->repo_path, NULL((void*)0));
if (err)
goto done;

err = got_object_resolve_id_str(&(*worktree)->base_commit_id, repo,
   base_commit_id_str);
if (err)
goto done;

err = read_meta_file(&(*worktree)->head_ref_name, path_got,
   GOT_WORKTREE_HEAD_REF"head-ref");
if (err)
goto done;

if (asprintf(&(*worktree)->gotconfig_path, "%s/%s/%s",
   (*worktree)->root_path,
   GOT_WORKTREE_GOT_DIR".got", GOT_GOTCONFIG_FILENAME"got.conf") == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

err = got_gotconfig_read(&(*worktree)->gotconfig,
   (*worktree)->gotconfig_path);

(*worktree)->root_fd = open((*worktree)->root_path, O_DIRECTORY0x20000);
if ((*worktree)->root_fd == -1) {
err = got_error_from_errno2("open", (*worktree)->root_path);
goto done;
}
438done:
if (repo)
got_repo_close(repo);
free(path_got);
free(path_lock);
free(base_commit_id_str);
free(uuidstr);
free(formatstr);
if (err) {
if (fd != -1)
	close(fd);
if (*worktree != NULL((void*)0))
	got_worktree_close(*worktree);
*worktree = NULL((void*)0);
} else
(*worktree)->lockfd = fd;

return err;
456}

458const struct got_error *
459got_worktree_open(struct got_worktree **worktree, const char *path)
460{
const struct got_error *err = NULL((void*)0);
char *worktree_path;

worktree_path = strdup(path);
if (worktree_path == NULL((void*)0))
return got_error_from_errno("strdup");

for (;;) {
char *parent_path;

err = open_worktree(worktree, worktree_path);
if (err && !(err->code == GOT_ERR_ERRNO1 && errno(*__errno()) == ENOENT2)) {
	free(worktree_path);
	return err;
}
if (*worktree) {
	free(worktree_path);
	return NULL((void*)0);
}
if (worktree_path[0] == '/' && worktree_path[1] == '\0')
	break;
err = got_path_dirname(&parent_path, worktree_path);
if (err) {
	if (err->code != GOT_ERR_BAD_PATH4) {
		free(worktree_path);
		return err;
	}
	break;
}
free(worktree_path);
worktree_path = parent_path;
}

free(worktree_path);
return got_error(GOT_ERR_NOT_WORKTREE60);
496}

498const struct got_error *
499got_worktree_close(struct got_worktree *worktree)
500{
const struct got_error *err = NULL((void*)0);

if (worktree->lockfd != -1) {
if (close(worktree->lockfd) == -1)
	err = got_error_from_errno2("close",
	    got_worktree_get_root_path(worktree));
}
if (close(worktree->root_fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("close",
    got_worktree_get_root_path(worktree));
free(worktree->repo_path);
free(worktree->path_prefix);
free(worktree->base_commit_id);
free(worktree->head_ref_name);
free(worktree->root_path);
free(worktree->gotconfig_path);
got_gotconfig_free(worktree->gotconfig);
free(worktree);
return err;
520}

522const char *
523got_worktree_get_root_path(struct got_worktree *worktree)
524{
return worktree->root_path;
526}

528const char *
529got_worktree_get_repo_path(struct got_worktree *worktree)
530{
return worktree->repo_path;
532}
533const char *
534got_worktree_get_path_prefix(struct got_worktree *worktree)
535{
return worktree->path_prefix;
537}

539const struct got_error *
540got_worktree_match_path_prefix(int *match, struct got_worktree *worktree,
  const char *path_prefix)
542{
char *absprefix = NULL((void*)0);

if (!got_path_is_absolute(path_prefix)) {
if (asprintf(&absprefix, "/%s", path_prefix) == -1)
	return got_error_from_errno("asprintf");
}
*match = (strcmp(absprefix ? absprefix : path_prefix,
   worktree->path_prefix) == 0);
free(absprefix);
return NULL((void*)0);
553}

555const char *
556got_worktree_get_head_ref_name(struct got_worktree *worktree)
557{
return worktree->head_ref_name;
559}

561const struct got_error *
562got_worktree_set_head_ref(struct got_worktree *worktree,
  struct got_reference *head_ref)
564{
const struct got_error *err = NULL((void*)0);
char *path_got = NULL((void*)0), *head_ref_name = NULL((void*)0);

if (asprintf(&path_got, "%s/%s", worktree->root_path,
   GOT_WORKTREE_GOT_DIR".got") == -1) {
err = got_error_from_errno("asprintf");
path_got = NULL((void*)0);
goto done;
}

head_ref_name = strdup(got_ref_get_name(head_ref));
if (head_ref_name == NULL((void*)0)) {
err = got_error_from_errno("strdup");
goto done;
}

err = write_head_ref(path_got, head_ref);
if (err)
goto done;

free(worktree->head_ref_name);
worktree->head_ref_name = head_ref_name;
587done:
free(path_got);
if (err)
free(head_ref_name);
return err;
592}

594struct got_object_id *
595got_worktree_get_base_commit_id(struct got_worktree *worktree)
596{
return worktree->base_commit_id;
598}

600const struct got_error *
601got_worktree_set_base_commit_id(struct got_worktree *worktree,
  struct got_repository *repo, struct got_object_id *commit_id)
603{
const struct got_error *err;
struct got_object *obj = NULL((void*)0);
char *id_str = NULL((void*)0);
char *path_got = NULL((void*)0);

if (asprintf(&path_got, "%s/%s", worktree->root_path,
   GOT_WORKTREE_GOT_DIR".got") == -1) {
err = got_error_from_errno("asprintf");
path_got = NULL((void*)0);
goto done;
}

err = got_object_open(&obj, repo, commit_id);
if (err)
return err;

if (obj->type != GOT_OBJ_TYPE_COMMIT1) {
err = got_error(GOT_ERR_OBJ_TYPE11);
goto done;
}

/* Record our base commit. */
err = got_object_id_str(&id_str, commit_id);
if (err)
goto done;
err = update_meta_file(path_got, GOT_WORKTREE_BASE_COMMIT"base-commit", id_str);
if (err)
goto done;

free(worktree->base_commit_id);
worktree->base_commit_id = got_object_id_dup(commit_id);
if (worktree->base_commit_id == NULL((void*)0)) {
err = got_error_from_errno("got_object_id_dup");
goto done;
}
639done:
if (obj)
got_object_close(obj);
free(id_str);
free(path_got);
return err;
645}

647const struct got_gotconfig *
648got_worktree_get_gotconfig(struct got_worktree *worktree)
649{
return worktree->gotconfig;
651}

653static const struct got_error *
654lock_worktree(struct got_worktree *worktree, int operation)
655{
if (flock(worktree->lockfd, operation | LOCK_NB0x04) == -1)
return (errno(*__errno()) == EWOULDBLOCK35 ? got_error(GOT_ERR_WORKTREE_BUSY29)
    : got_error_from_errno2("flock",
    got_worktree_get_root_path(worktree)));
return NULL((void*)0);
661}

663static const struct got_error *
664add_dir_on_disk(struct got_worktree *worktree, const char *path)
665{
const struct got_error *err = NULL((void*)0);
char *abspath;

if (asprintf(&abspath, "%s/%s", worktree->root_path, path) == -1)
return got_error_from_errno("asprintf");

err = got_path_mkdir(abspath);
if (err && err->code == GOT_ERR_ERRNO1 && errno(*__errno()) == EEXIST17) {
struct stat sb;
err = NULL((void*)0);
if (lstat(abspath, &sb) == -1) {
	err = got_error_from_errno2("lstat", abspath);
} else if (!S_ISDIR(sb.st_mode)((sb.st_mode & 0170000) == 0040000)) {
	/* TODO directory is obstructed; do something */
	err = got_error_path(abspath, GOT_ERR_FILE_OBSTRUCTED31);
}
}
free(abspath);
return err;
685}

687static const struct got_error *
688check_file_contents_equal(int *same, FILE *f1, FILE *f2)
689{
const struct got_error *err = NULL((void*)0);
uint8_t fbuf1[8192];
uint8_t fbuf2[8192];
size_t flen1 = 0, flen2 = 0;

*same = 1;

for (;;) {
flen1 = fread(fbuf1, 1, sizeof(fbuf1), f1);
if (flen1 == 0 && ferror(f1)(!__isthreaded ? (((f1)->_flags & 0x0040) != 0) : (ferror
)(f1))) {
	err = got_error_from_errno("fread");
	break;
}
flen2 = fread(fbuf2, 1, sizeof(fbuf2), f2);
if (flen2 == 0 && ferror(f2)(!__isthreaded ? (((f2)->_flags & 0x0040) != 0) : (ferror
)(f2))) {
	err = got_error_from_errno("fread");
	break;
}
if (flen1 == 0) {
	if (flen2 != 0)
		*same = 0;
	break;
} else if (flen2 == 0) {
	if (flen1 != 0)
		*same = 0;
	break;
} else if (flen1 == flen2) {
	if (memcmp(fbuf1, fbuf2, flen2) != 0) {
		*same = 0;
		break;
	}
} else {
	*same = 0;
	break;
}
}

return err;
728}

730static const struct got_error *
731check_files_equal(int *same, const char *f1_path, const char *f2_path)
732{
const struct got_error *err = NULL((void*)0);
struct stat sb;
size_t size1, size2;
FILE *f1 = NULL((void*)0), *f2 = NULL((void*)0);

*same = 1;

if (lstat(f1_path, &sb) != 0) {
err = got_error_from_errno2("lstat", f1_path);
goto done;
}
size1 = sb.st_size;

if (lstat(f2_path, &sb) != 0) {
err = got_error_from_errno2("lstat", f2_path);
goto done;
}
size2 = sb.st_size;

if (size1 != size2) {
*same = 0;
return NULL((void*)0);
}

f1 = fopen(f1_path, "r");
if (f1 == NULL((void*)0))
return got_error_from_errno2("fopen", f1_path);

f2 = fopen(f2_path, "r");
if (f2 == NULL((void*)0)) {
err = got_error_from_errno2("fopen", f2_path);
goto done;
}

err = check_file_contents_equal(same, f1, f2);
768done:
if (f1 && fclose(f1) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno("fclose");
if (f2 && fclose(f2) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno("fclose");

return err;
775}

777/*
* Perform a 3-way merge where blob_orig acts as the common ancestor,
* the file at deriv_path acts as the first derived version, and the
* file on disk acts as the second derived version.
*/
782static const struct got_error *
783merge_file(int *local_changes_subsumed, struct got_worktree *worktree,
  struct got_blob_object *blob_orig, const char *ondisk_path,
  const char *path, uint16_t st_mode, const char *deriv_path,
  const char *label_orig, const char *label_deriv,
  struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
789{
const struct got_error *err = NULL((void*)0);
int merged_fd = -1;
FILE *f_orig = NULL((void*)0);
char *blob_orig_path = NULL((void*)0);
char *merged_path = NULL((void*)0), *base_path = NULL((void*)0);
int overlapcnt = 0;
char *parent = NULL((void*)0);
char *symlink_path = NULL((void*)0);
FILE *symlinkf = NULL((void*)0);

*local_changes_subsumed = 0;

err = got_path_dirname(&parent, ondisk_path);
if (err)
return err;

if (asprintf(&base_path, "%s/got-merged", parent) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

err = got_opentemp_named_fd(&merged_path, &merged_fd, base_path);
if (err)
goto done;

free(base_path);
if (asprintf(&base_path, "%s/got-merge-blob-orig", parent) == -1) {
err = got_error_from_errno("asprintf");
base_path = NULL((void*)0);
goto done;
}

err = got_opentemp_named(&blob_orig_path, &f_orig, base_path);
if (err)
goto done;
if (blob_orig) {
err = got_object_blob_dump_to_file(NULL((void*)0), NULL((void*)0), NULL((void*)0), f_orig,
    blob_orig);
if (err)
	goto done;
} else {
/*
 * If the file has no blob, this is an "add vs add" conflict,
 * and we simply use an empty ancestor file to make both files
 * appear in the merged result in their entirety.
 */
}

/* 
* In order the run a 3-way merge with a symlink we copy the symlink's
* target path into a temporary file and use that file with diff3.
*/
if (S_ISLNK(st_mode)((st_mode & 0170000) == 0120000)) {
char target_path[PATH_MAX1024];
ssize_t target_len;
size_t n;

free(base_path);
if (asprintf(&base_path, "%s/got-symlink-merge",
    parent) == -1) {
	err = got_error_from_errno("asprintf");
	base_path = NULL((void*)0);
	goto done;
}
err = got_opentemp_named(&symlink_path, &symlinkf, base_path);
if (err)
	goto done;
target_len = readlink(ondisk_path, target_path,
    sizeof(target_path));
if (target_len == -1) {
	err = got_error_from_errno2("readlink", ondisk_path);
	goto done;
}
n = fwrite(target_path, 1, target_len, symlinkf);
if (n != target_len) {
	err = got_ferror(symlinkf, GOT_ERR_IO6);
	goto done;
}
if (fflush(symlinkf) == EOF(-1)) {
	err = got_error_from_errno2("fflush", symlink_path);
	goto done;
}
}

err = got_merge_diff3(&overlapcnt, merged_fd, deriv_path,
   blob_orig_path, symlink_path ? symlink_path : ondisk_path,
   label_deriv, label_orig, NULL((void*)0));
if (err)
goto done;

err = (*progress_cb)(progress_arg,
   overlapcnt > 0 ? GOT_STATUS_CONFLICT'C' : GOT_STATUS_MERGE'G', path);
if (err)
goto done;

if (fsync(merged_fd) != 0) {
err = got_error_from_errno("fsync");
goto done;
}

/* Check if a clean merge has subsumed all local changes. */
if (overlapcnt == 0) {
err = check_files_equal(local_changes_subsumed, deriv_path,
    merged_path);
if (err)
	goto done;
}

if (fchmod(merged_fd, st_mode) != 0) {
err = got_error_from_errno2("fchmod", merged_path);
goto done;
}

if (rename(merged_path, ondisk_path) != 0) {
err = got_error_from_errno3("rename", merged_path,
    ondisk_path);
goto done;
}
908done:
if (err) {
if (merged_path)
	unlink(merged_path);
}
if (symlink_path) {
if (unlink(symlink_path) == -1 && err == NULL((void*)0))
	err = got_error_from_errno2("unlink", symlink_path);
}
if (symlinkf && fclose(symlinkf) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", symlink_path);
free(symlink_path);
if (merged_fd != -1 && close(merged_fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno("close");
if (f_orig && fclose(f_orig) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno("fclose");
free(merged_path);
free(base_path);
if (blob_orig_path) {
unlink(blob_orig_path);
free(blob_orig_path);
}
free(parent);
return err;
932}

934static const struct got_error *
935update_symlink(const char *ondisk_path, const char *target_path,
  size_t target_len)
937{
/* This is not atomic but matches what 'ln -sf' does. */
if (unlink(ondisk_path) == -1)
return got_error_from_errno2("unlink", ondisk_path);
if (symlink(target_path, ondisk_path) == -1)
return got_error_from_errno3("symlink", target_path,
    ondisk_path);
return NULL((void*)0);
945}

947/*
* Overwrite a symlink (or a regular file in case there was a "bad" symlink)
* in the work tree with a file that contains conflict markers and the
* conflicting target paths of the original version, a "derived version"
* of a symlink from an incoming change, and a local version of the symlink.
*
* The original versions's target path can be NULL if it is not available,
* such as if both derived versions added a new symlink at the same path.
*
* The incoming derived symlink target is NULL in case the incoming change
* has deleted this symlink.
*/
959static const struct got_error *
960install_symlink_conflict(const char *deriv_target,
  struct got_object_id *deriv_base_commit_id, const char *orig_target,
  const char *label_orig, const char *local_target, const char *ondisk_path)
963{
const struct got_error *err;
char *id_str = NULL((void*)0), *label_deriv = NULL((void*)0), *path = NULL((void*)0);
FILE *f = NULL((void*)0);

err = got_object_id_str(&id_str, deriv_base_commit_id);
if (err)
return got_error_from_errno("asprintf");

if (asprintf(&label_deriv, "%s: commit %s",
   GOT_MERGE_LABEL_MERGED"merged change", id_str) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

err = got_opentemp_named(&path, &f, "got-symlink-conflict");
if (err)
goto done;

if (fchmod(fileno(f)(!__isthreaded ? ((f)->_file) : (fileno)(f)), GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004)) == -1) {
err = got_error_from_errno2("fchmod", path);
goto done;
}

if (fprintf(f, "%s %s\n%s\n%s%s%s%s%s\n%s\n%s\n",
   GOT_DIFF_CONFLICT_MARKER_BEGIN"<<<<<<<", label_deriv,
   deriv_target ? deriv_target : "(symlink was deleted)",
   orig_target ? label_orig : "",
   orig_target ? "\n" : "",
   orig_target ? orig_target : "",
   orig_target ? "\n" : "",
   GOT_DIFF_CONFLICT_MARKER_SEP"=======",
   local_target, GOT_DIFF_CONFLICT_MARKER_END">>>>>>>") < 0) {
err = got_error_from_errno2("fprintf", path);
goto done;
}

if (unlink(ondisk_path) == -1) {
err = got_error_from_errno2("unlink", ondisk_path);
goto done;
}
if (rename(path, ondisk_path) == -1) {
err = got_error_from_errno3("rename", path, ondisk_path);
goto done;
}
1008done:
if (f != NULL((void*)0) && fclose(f) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", path);
free(path);
free(id_str);
free(label_deriv);
return err;
1015}

1017/* forward declaration */
1018static const struct got_error *
1019merge_blob(int *, struct got_worktree *, struct got_blob_object *,
  const char *, const char *, uint16_t, const char *,
  struct got_blob_object *, struct got_object_id *,
  struct got_repository *, got_worktree_checkout_cb, void *);

1024/*
* Merge a symlink into the work tree, where blob_orig acts as the common
* ancestor, deriv_target is the link target of the first derived version,
* and the symlink on disk acts as the second derived version.
* Assume that contents of both blobs represent symlinks.
*/
1030static const struct got_error *
1031merge_symlink(struct got_worktree *worktree,
  struct got_blob_object *blob_orig, const char *ondisk_path,
  const char *path, const char *label_orig, const char *deriv_target,
  struct got_object_id *deriv_base_commit_id, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
1036{
const struct got_error *err = NULL((void*)0);
char *ancestor_target = NULL((void*)0);
struct stat sb;
ssize_t ondisk_len, deriv_len;
char ondisk_target[PATH_MAX1024];
int have_local_change = 0;
int have_incoming_change = 0;

if (lstat(ondisk_path, &sb) == -1)
return got_error_from_errno2("lstat", ondisk_path);

ondisk_len = readlink(ondisk_path, ondisk_target,
   sizeof(ondisk_target));
if (ondisk_len == -1) {
err = got_error_from_errno2("readlink",
    ondisk_path);
goto done;
}
ondisk_target[ondisk_len] = '\0';

if (blob_orig) {
err = got_object_blob_read_to_str(&ancestor_target, blob_orig);
if (err)
	goto done;
}

if (ancestor_target == NULL((void*)0) ||
   (ondisk_len != strlen(ancestor_target) ||
   memcmp(ondisk_target, ancestor_target, ondisk_len) != 0))
have_local_change = 1;

deriv_len = strlen(deriv_target);
if (ancestor_target == NULL((void*)0) ||
   (deriv_len != strlen(ancestor_target) ||
   memcmp(deriv_target, ancestor_target, deriv_len) != 0))
have_incoming_change = 1;

if (!have_local_change && !have_incoming_change) {
if (ancestor_target) {
	/* Both sides made the same change. */
	err = (*progress_cb)(progress_arg, GOT_STATUS_MERGE'G',
	    path);
} else if (deriv_len == ondisk_len &&
    memcmp(ondisk_target, deriv_target, deriv_len) == 0) {
	/* Both sides added the same symlink. */
	err = (*progress_cb)(progress_arg, GOT_STATUS_MERGE'G',
	    path);
} else {
	/* Both sides added symlinks which don't match. */
	err = install_symlink_conflict(deriv_target,
	    deriv_base_commit_id, ancestor_target,
	    label_orig, ondisk_target, ondisk_path);
	if (err)
		goto done;
	err = (*progress_cb)(progress_arg, GOT_STATUS_CONFLICT'C',
	    path);
}
} else if (!have_local_change && have_incoming_change) {
/* Apply the incoming change. */
err = update_symlink(ondisk_path, deriv_target,
    strlen(deriv_target));
if (err)
	goto done;
err = (*progress_cb)(progress_arg, GOT_STATUS_MERGE'G', path);
} else if (have_local_change && have_incoming_change) {
if (deriv_len == ondisk_len &&
    memcmp(deriv_target, ondisk_target, deriv_len) == 0) {
	/* Both sides made the same change. */
	err = (*progress_cb)(progress_arg, GOT_STATUS_MERGE'G',
	    path);
} else {
	err = install_symlink_conflict(deriv_target,
	    deriv_base_commit_id, ancestor_target, label_orig,
	    ondisk_target, ondisk_path);
	if (err)
		goto done;
	err = (*progress_cb)(progress_arg, GOT_STATUS_CONFLICT'C',
	    path);
}
}

1118done:
free(ancestor_target);
return err;
1121}

1123/*
* Perform a 3-way merge where blob_orig acts as the common ancestor,
* blob_deriv acts as the first derived version, and the file on disk
* acts as the second derived version.
*/
1128static const struct got_error *
1129merge_blob(int *local_changes_subsumed, struct got_worktree *worktree,
  struct got_blob_object *blob_orig, const char *ondisk_path,
  const char *path, uint16_t st_mode, const char *label_orig,
  struct got_blob_object *blob_deriv,
  struct got_object_id *deriv_base_commit_id, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
1135{
const struct got_error *err = NULL((void*)0);
FILE *f_deriv = NULL((void*)0);
char *blob_deriv_path = NULL((void*)0), *base_path = NULL((void*)0), *id_str = NULL((void*)0);
char *label_deriv = NULL((void*)0), *parent = NULL((void*)0);

*local_changes_subsumed = 0;

err = got_path_dirname(&parent, ondisk_path);
if (err)
return err;

free(base_path);
if (asprintf(&base_path, "%s/got-merge-blob-deriv", parent) == -1) {
err = got_error_from_errno("asprintf");
base_path = NULL((void*)0);
goto done;
}

err = got_opentemp_named(&blob_deriv_path, &f_deriv, base_path);
if (err)
goto done;
err = got_object_blob_dump_to_file(NULL((void*)0), NULL((void*)0), NULL((void*)0), f_deriv,
   blob_deriv);
if (err)
goto done;

err = got_object_id_str(&id_str, deriv_base_commit_id);
if (err)
goto done;
if (asprintf(&label_deriv, "%s: commit %s",
   GOT_MERGE_LABEL_MERGED"merged change", id_str) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

err = merge_file(local_changes_subsumed, worktree, blob_orig,
   ondisk_path, path, st_mode, blob_deriv_path, label_orig,
   label_deriv, repo, progress_cb, progress_arg);
1174done:
if (f_deriv && fclose(f_deriv) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno("fclose");
free(base_path);
if (blob_deriv_path) {
unlink(blob_deriv_path);
free(blob_deriv_path);
}
free(id_str);
free(label_deriv);
free(parent);
return err;
1186}

1188static const struct got_error *
1189create_fileindex_entry(struct got_fileindex_entry **new_iep,
  struct got_fileindex *fileindex, struct got_object_id *base_commit_id,
  int wt_fd, const char *path, struct got_object_id *blob_id)
1192{
const struct got_error *err = NULL((void*)0);
struct got_fileindex_entry *new_ie;

*new_iep = NULL((void*)0);

err = got_fileindex_entry_alloc(&new_ie, path);
if (err)
return err;

err = got_fileindex_entry_update(new_ie, wt_fd, path,
   blob_id->sha1, base_commit_id->sha1, 1);
if (err)
goto done;

err = got_fileindex_entry_add(fileindex, new_ie);
1208done:
if (err)
got_fileindex_entry_free(new_ie);
else
*new_iep = new_ie;
return err;
1214}

1216static mode_t
1217get_ondisk_perms(int executable, mode_t st_mode)
1218{
mode_t xbits = S_IXUSR0000100;

if (executable) {
/* Map read bits to execute bits. */
if (st_mode & S_IRGRP0000040)
	xbits |= S_IXGRP0000010;
if (st_mode & S_IROTH0000004)
	xbits |= S_IXOTH0000001;
return st_mode | xbits;
}

return (st_mode & ~(S_IXUSR0000100 | S_IXGRP0000010 | S_IXOTH0000001));
1231}

1233/* forward declaration */
1234static const struct got_error *
1235install_blob(struct got_worktree *worktree, const char *ondisk_path,
  const char *path, mode_t te_mode, mode_t st_mode,
  struct got_blob_object *blob, int restoring_missing_file,
  int reverting_versioned_file, int installing_bad_symlink,
  int path_is_unversioned, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg);

1242/*
* This function assumes that the provided symlink target points at a
* safe location in the work tree!
*/
1246static const struct got_error *
1247replace_existing_symlink(int *did_something, const char *ondisk_path,
  const char *target_path, size_t target_len)
1249{
const struct got_error *err = NULL((void*)0);
ssize_t elen;
char etarget[PATH_MAX1024];
int fd;

*did_something = 0;

/*
* "Bad" symlinks (those pointing outside the work tree or into the
* .got directory) are installed in the work tree as a regular file
* which contains the bad symlink target path.
* The new symlink target has already been checked for safety by our
* caller. If we can successfully open a regular file then we simply
* replace this file with a symlink below.
*/
fd = open(ondisk_path, O_RDWR0x0002 | O_EXCL0x0800 | O_NOFOLLOW0x0100);
if (fd == -1) {
if (errno(*__errno()) != ELOOP62)
	return got_error_from_errno2("open", ondisk_path);

/* We are updating an existing on-disk symlink. */
elen = readlink(ondisk_path, etarget, sizeof(etarget));
if (elen == -1)
	return got_error_from_errno2("readlink", ondisk_path);

if (elen == target_len &&
    memcmp(etarget, target_path, target_len) == 0)
	return NULL((void*)0); /* nothing to do */
}

*did_something = 1;
err = update_symlink(ondisk_path, target_path, target_len);
if (fd != -1 && close(fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("close", ondisk_path);
return err;
1285}

1287static const struct got_error *
1288is_bad_symlink_target(int *is_bad_symlink, const char *target_path,
  size_t target_len, const char *ondisk_path, const char *wtroot_path)
1290{
const struct got_error *err = NULL((void*)0);
char canonpath[PATH_MAX1024];
char *path_got = NULL((void*)0);

*is_bad_symlink = 0;

if (target_len >= sizeof(canonpath)) {
*is_bad_symlink = 1;
return NULL((void*)0);
}

/*
* We do not use realpath(3) to resolve the symlink's target
* path because we don't want to resolve symlinks recursively.
* Instead we make the path absolute and then canonicalize it.
* Relative symlink target lookup should begin at the directory
* in which the blob object is being installed.
*/
if (!got_path_is_absolute(target_path)) {
char *abspath, *parent;
err = got_path_dirname(&parent, ondisk_path);
if (err)
	return err;
if (asprintf(&abspath, "%s/%s",  parent, target_path) == -1) {
	free(parent);
	return got_error_from_errno("asprintf");
}
free(parent);
if (strlen(abspath) >= sizeof(canonpath)) {
	err = got_error_path(abspath, GOT_ERR_BAD_PATH4);
	free(abspath);
	return err;
}
err = got_canonpath(abspath, canonpath, sizeof(canonpath));
free(abspath);
if (err)
	return err;
} else {
err = got_canonpath(target_path, canonpath, sizeof(canonpath));
if (err)
	return err;
}

/* Only allow symlinks pointing at paths within the work tree. */
if (!got_path_is_child(canonpath, wtroot_path, strlen(wtroot_path))) {
*is_bad_symlink = 1;
return NULL((void*)0);
}

/* Do not allow symlinks pointing into the .got directory. */
if (asprintf(&path_got, "%s/%s", wtroot_path,
   GOT_WORKTREE_GOT_DIR".got") == -1)
return got_error_from_errno("asprintf");
if (got_path_is_child(canonpath, path_got, strlen(path_got)))
*is_bad_symlink = 1;

free(path_got);
return NULL((void*)0);
1349}

1351static const struct got_error *
1352install_symlink(int *is_bad_symlink, struct got_worktree *worktree,
  const char *ondisk_path, const char *path, struct got_blob_object *blob,
  int restoring_missing_file, int reverting_versioned_file,
  int path_is_unversioned, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
1357{
const struct got_error *err = NULL((void*)0);
char target_path[PATH_MAX1024];
size_t len, target_len = 0;
char *path_got = NULL((void*)0);
const uint8_t *buf = got_object_blob_get_read_buf(blob);
size_t hdrlen = got_object_blob_get_hdrlen(blob);

*is_bad_symlink = 0;

/* 
* Blob object content specifies the target path of the link.
* If a symbolic link cannot be installed we instead create
* a regular file which contains the link target path stored
* in the blob object.
*/
do {
err = got_object_blob_read_block(&len, blob);
if (len + target_len >= sizeof(target_path)) {
	/* Path too long; install as a regular file. */
	*is_bad_symlink = 1;
	got_object_blob_rewind(blob);
	return install_blob(worktree, ondisk_path, path,
	    GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004), GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004), blob,
	    restoring_missing_file, reverting_versioned_file,
	    1, path_is_unversioned, repo, progress_cb,
	    progress_arg);
}
if (len > 0) {
	/* Skip blob object header first time around. */
	memcpy(target_path + target_len, buf + hdrlen,
	    len - hdrlen);
	target_len += len - hdrlen;
	hdrlen = 0;
}
} while (len != 0);
target_path[target_len] = '\0';

err = is_bad_symlink_target(is_bad_symlink, target_path, target_len,
   ondisk_path, worktree->root_path);
if (err)
return err;

if (*is_bad_symlink) {
/* install as a regular file */
got_object_blob_rewind(blob);
err = install_blob(worktree, ondisk_path, path,
    GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004), GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004), blob,
    restoring_missing_file, reverting_versioned_file, 1,
    path_is_unversioned, repo, progress_cb, progress_arg);
goto done;
}

if (symlink(target_path, ondisk_path) == -1) {
if (errno(*__errno()) == EEXIST17) {
	int symlink_replaced;
	if (path_is_unversioned) {
		err = (*progress_cb)(progress_arg,
		    GOT_STATUS_UNVERSIONED'?', path);
		goto done;
	}
	err = replace_existing_symlink(&symlink_replaced,
	    ondisk_path, target_path, target_len);
	if (err)
		goto done;
	if (progress_cb) {
		if (symlink_replaced) {
			err = (*progress_cb)(progress_arg,
			    reverting_versioned_file ?
			    GOT_STATUS_REVERT'R' :
			    GOT_STATUS_UPDATE'U', path);
		} else {
			err = (*progress_cb)(progress_arg,
			    GOT_STATUS_EXISTS'E', path);
		}
	}
	goto done; /* Nothing else to do. */
}

if (errno(*__errno()) == ENOENT2) {
	char *parent;
	err = got_path_dirname(&parent, ondisk_path);
	if (err)
		goto done;
	err = add_dir_on_disk(worktree, parent);
	free(parent);
	if (err)
		goto done;
	/*
	 * Retry, and fall through to error handling
	 * below if this second attempt fails.
	 */
	if (symlink(target_path, ondisk_path) != -1) {
		err = NULL((void*)0); /* success */
		goto done;
	}
}

/* Handle errors from first or second creation attempt. */
if (errno(*__errno()) == ENAMETOOLONG63) {
	/* bad target path; install as a regular file */
	*is_bad_symlink = 1;
	got_object_blob_rewind(blob);
	err = install_blob(worktree, ondisk_path, path,
	    GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004), GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004), blob,
	    restoring_missing_file, reverting_versioned_file, 1,
	    path_is_unversioned, repo,
	    progress_cb, progress_arg);
} else if (errno(*__errno()) == ENOTDIR20) {
	err = got_error_path(ondisk_path,
	    GOT_ERR_FILE_OBSTRUCTED31);
} else {
	err = got_error_from_errno3("symlink",
	    target_path, ondisk_path);
}
} else if (progress_cb)
err = (*progress_cb)(progress_arg, reverting_versioned_file ?
    GOT_STATUS_REVERT'R' : GOT_STATUS_ADD'A', path);
1475done:
free(path_got);
return err;
1478}

1480static const struct got_error *
1481install_blob(struct got_worktree *worktree, const char *ondisk_path,
  const char *path, mode_t te_mode, mode_t st_mode,
  struct got_blob_object *blob, int restoring_missing_file,
  int reverting_versioned_file, int installing_bad_symlink,
  int path_is_unversioned, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
1487{
const struct got_error *err = NULL((void*)0);
int fd = -1;
size_t len, hdrlen;
int update = 0;
char *tmppath = NULL((void*)0);

fd = open(ondisk_path, O_RDWR0x0002 | O_CREAT0x0200 | O_EXCL0x0800 | O_NOFOLLOW0x0100,
   GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004));
if (fd == -1) {
if (errno(*__errno()) == ENOENT2) {
	char *parent;
	err = got_path_dirname(&parent, path);
	if (err)
		return err;
	err = add_dir_on_disk(worktree, parent);
	free(parent);
	if (err)
		return err;
	fd = open(ondisk_path,
	    O_RDWR0x0002 | O_CREAT0x0200 | O_EXCL0x0800 | O_NOFOLLOW0x0100,
	    GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004));
	if (fd == -1)
		return got_error_from_errno2("open",
		    ondisk_path);
} else if (errno(*__errno()) == EEXIST17) {
	if (path_is_unversioned) {
		err = (*progress_cb)(progress_arg,
		    GOT_STATUS_UNVERSIONED'?', path);
		goto done;
	}
	if (!(S_ISLNK(st_mode)((st_mode & 0170000) == 0120000) && S_ISREG(te_mode)((te_mode & 0170000) == 0100000)) &&
	    !S_ISREG(st_mode)((st_mode & 0170000) == 0100000) && !installing_bad_symlink) {
		/* TODO file is obstructed; do something */
		err = got_error_path(ondisk_path,
		    GOT_ERR_FILE_OBSTRUCTED31);
		goto done;
	} else {
		err = got_opentemp_named_fd(&tmppath, &fd,
		    ondisk_path);
		if (err)
			goto done;
		update = 1;
	}
} else
	return got_error_from_errno2("open", ondisk_path);
}

if (fchmod(fd, get_ondisk_perms(te_mode & S_IXUSR0000100, st_mode)) == -1) {
err = got_error_from_errno2("fchmod",
    update ? tmppath : ondisk_path);
goto done;
}

if (progress_cb) {
if (restoring_missing_file)
	err = (*progress_cb)(progress_arg, GOT_STATUS_MISSING'!',
	    path);
else if (reverting_versioned_file)
	err = (*progress_cb)(progress_arg, GOT_STATUS_REVERT'R',
	    path);
else
	err = (*progress_cb)(progress_arg,
	    update ? GOT_STATUS_UPDATE'U' : GOT_STATUS_ADD'A', path);
if (err)
	goto done;
}

hdrlen = got_object_blob_get_hdrlen(blob);
do {
const uint8_t *buf = got_object_blob_get_read_buf(blob);
err = got_object_blob_read_block(&len, blob);
if (err)
	break;
if (len > 0) {
	/* Skip blob object header first time around. */
	ssize_t outlen = write(fd, buf + hdrlen, len - hdrlen);
	if (outlen == -1) {
		err = got_error_from_errno("write");
		goto done;
	} else if (outlen != len - hdrlen) {
		err = got_error(GOT_ERR_IO6);
		goto done;
	}
	hdrlen = 0;
}
} while (len != 0);

if (fsync(fd) != 0) {
err = got_error_from_errno("fsync");
goto done;
}

if (update) {
if (S_ISLNK(st_mode)((st_mode & 0170000) == 0120000) && unlink(ondisk_path) == -1) {
	err = got_error_from_errno2("unlink", ondisk_path);
	goto done;
}
if (rename(tmppath, ondisk_path) != 0) {
	err = got_error_from_errno3("rename", tmppath,
	    ondisk_path);
	goto done;
}
free(tmppath);
tmppath = NULL((void*)0);
}

1594done:
if (fd != -1 && close(fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno("close");
if (tmppath != NULL((void*)0) && unlink(tmppath) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("unlink", tmppath);
free(tmppath);
return err;
1601}

1603/* Upgrade STATUS_MODIFY to STATUS_CONFLICT if a conflict marker is found. */
1604static const struct got_error *
1605get_modified_file_content_status(unsigned char *status, FILE *f)
1606{
const struct got_error *err = NULL((void*)0);
const char *markers[3] = {
GOT_DIFF_CONFLICT_MARKER_BEGIN"<<<<<<<",
GOT_DIFF_CONFLICT_MARKER_SEP"=======",
GOT_DIFF_CONFLICT_MARKER_END">>>>>>>"
};
int i = 0;
char *line = NULL((void*)0);
size_t linesize = 0;
ssize_t linelen;

while (*status == GOT_STATUS_MODIFY'M') {
linelen = getline(&line, &linesize, f);
if (linelen == -1) {
	if (feof(f)(!__isthreaded ? (((f)->_flags & 0x0020) != 0) : (feof
)(f)))
		break;
	err = got_ferror(f, GOT_ERR_IO6);
	break;
}

if (strncmp(line, markers[i], strlen(markers[i])) == 0) {
	if (strcmp(markers[i], GOT_DIFF_CONFLICT_MARKER_END">>>>>>>")
	    == 0)
		*status = GOT_STATUS_CONFLICT'C';
	else
		i++;
}
}
free(line);

return err;
1638}

1640static int
1641xbit_differs(struct got_fileindex_entry *ie, uint16_t st_mode)
1642{
mode_t ie_mode = got_fileindex_perms_to_st(ie);
return ((ie_mode & S_IXUSR0000100) != (st_mode & S_IXUSR0000100));
1645}

1647static int
1648stat_info_differs(struct got_fileindex_entry *ie, struct stat *sb)
1649{
return !(ie->ctime_sec == sb->st_ctim.tv_sec &&
   ie->ctime_nsec == sb->st_ctim.tv_nsec &&
   ie->mtime_sec == sb->st_mtim.tv_sec &&
   ie->mtime_nsec == sb->st_mtim.tv_nsec &&
   ie->size == (sb->st_size & 0xffffffff) &&
   !xbit_differs(ie, sb->st_mode));
1656}

1658static unsigned char
1659get_staged_status(struct got_fileindex_entry *ie)
1660{
switch (got_fileindex_entry_stage_get(ie)) {
case GOT_FILEIDX_STAGE_ADD2:
return GOT_STATUS_ADD'A';
case GOT_FILEIDX_STAGE_DELETE3:
return GOT_STATUS_DELETE'D';
case GOT_FILEIDX_STAGE_MODIFY1:
return GOT_STATUS_MODIFY'M';
default:
return GOT_STATUS_NO_CHANGE' ';
}
1671}

1673static const struct got_error *
1674get_symlink_modification_status(unsigned char *status,
  struct got_fileindex_entry *ie, const char *abspath,
  int dirfd, const char *de_name, struct got_blob_object *blob)
1677{
const struct got_error *err = NULL((void*)0);
char target_path[PATH_MAX1024];
char etarget[PATH_MAX1024];
ssize_t elen;
size_t len, target_len = 0;
const uint8_t *buf = got_object_blob_get_read_buf(blob);
size_t hdrlen = got_object_blob_get_hdrlen(blob);

*status = GOT_STATUS_NO_CHANGE' ';

/* Blob object content specifies the target path of the link. */
do {
err = got_object_blob_read_block(&len, blob);
if (err)
	return err;
if (len + target_len >= sizeof(target_path)) {
	/*
	 * Should not happen. The blob contents were OK
	 * when this symlink was installed.
	 */
	return got_error(GOT_ERR_NO_SPACE9);
}
if (len > 0) {
	/* Skip blob object header first time around. */
	memcpy(target_path + target_len, buf + hdrlen,
	    len - hdrlen);
	target_len += len - hdrlen;
	hdrlen = 0;
}
} while (len != 0);
target_path[target_len] = '\0';

if (dirfd != -1) {
elen = readlinkat(dirfd, de_name, etarget, sizeof(etarget));
if (elen == -1)
	return got_error_from_errno2("readlinkat", abspath);
} else {
elen = readlink(abspath, etarget, sizeof(etarget));
if (elen == -1)
	return got_error_from_errno2("readlink", abspath);
}

if (elen != target_len || memcmp(etarget, target_path, target_len) != 0)
*status = GOT_STATUS_MODIFY'M';

return NULL((void*)0);
1724}

1726static const struct got_error *
1727get_file_status(unsigned char *status, struct stat *sb,
  struct got_fileindex_entry *ie, const char *abspath,
  int dirfd, const char *de_name, struct got_repository *repo)
1730{
const struct got_error *err = NULL((void*)0);
struct got_object_id id;
size_t hdrlen;
int fd = -1;
FILE *f = NULL((void*)0);
uint8_t fbuf[8192];
struct got_blob_object *blob = NULL((void*)0);
size_t flen, blen;
unsigned char staged_status = get_staged_status(ie);

*status = GOT_STATUS_NO_CHANGE' ';
memset(sb, 0, sizeof(*sb));

/*
* Whenever the caller provides a directory descriptor and a
* directory entry name for the file, use them! This prevents
* race conditions if filesystem paths change beneath our feet.
*/
if (dirfd != -1) {
if (fstatat(dirfd, de_name, sb, AT_SYMLINK_NOFOLLOW0x02) == -1) {
	if (errno(*__errno()) == ENOENT2) {
		if (got_fileindex_entry_has_file_on_disk(ie))
			*status = GOT_STATUS_MISSING'!';
		else
			*status = GOT_STATUS_DELETE'D';
		goto done;
	}
	err = got_error_from_errno2("fstatat", abspath);
	goto done;
}
} else {
fd = open(abspath, O_RDONLY0x0000 | O_NOFOLLOW0x0100);
if (fd == -1 && errno(*__errno()) != ENOENT2 && errno(*__errno()) != ELOOP62)
	return got_error_from_errno2("open", abspath);
else if (fd == -1 && errno(*__errno()) == ELOOP62) {
	if (lstat(abspath, sb) == -1)
		return got_error_from_errno2("lstat", abspath);
} else if (fd == -1 || fstat(fd, sb) == -1) {
	if (errno(*__errno()) == ENOENT2) {
		if (got_fileindex_entry_has_file_on_disk(ie))
			*status = GOT_STATUS_MISSING'!';
		else
			*status = GOT_STATUS_DELETE'D';
		goto done;
	}
	err = got_error_from_errno2("fstat", abspath);
	goto done;
}
}

if (!S_ISREG(sb->st_mode)((sb->st_mode & 0170000) == 0100000) && !S_ISLNK(sb->st_mode)((sb->st_mode & 0170000) == 0120000)) {
*status = GOT_STATUS_OBSTRUCTED'~';
goto done;
}

if (!got_fileindex_entry_has_file_on_disk(ie)) {
*status = GOT_STATUS_DELETE'D';
goto done;
} else if (!got_fileindex_entry_has_blob(ie) &&
   staged_status != GOT_STATUS_ADD'A') {
*status = GOT_STATUS_ADD'A';
goto done;
}

if (!stat_info_differs(ie, sb))
goto done;

if (S_ISLNK(sb->st_mode)((sb->st_mode & 0170000) == 0120000) &&
   got_fileindex_entry_filetype_get(ie) != GOT_FILEIDX_MODE_SYMLINK2) {
*status = GOT_STATUS_MODIFY'M';
goto done;
}

if (staged_status == GOT_STATUS_MODIFY'M' ||
   staged_status == GOT_STATUS_ADD'A')
memcpy(id.sha1, ie->staged_blob_sha1, sizeof(id.sha1));
else
memcpy(id.sha1, ie->blob_sha1, sizeof(id.sha1));

err = got_object_open_as_blob(&blob, repo, &id, sizeof(fbuf));
if (err)
goto done;

if (S_ISLNK(sb->st_mode)((sb->st_mode & 0170000) == 0120000)) {
err = get_symlink_modification_status(status, ie,
    abspath, dirfd, de_name, blob);
goto done;
}

if (dirfd != -1) {
fd = openat(dirfd, de_name, O_RDONLY0x0000 | O_NOFOLLOW0x0100);
if (fd == -1) {
	err = got_error_from_errno2("openat", abspath);
	goto done;
}
}

f = fdopen(fd, "r");
if (f == NULL((void*)0)) {
err = got_error_from_errno2("fdopen", abspath);
goto done;
}
fd = -1;
hdrlen = got_object_blob_get_hdrlen(blob);
for (;;) {
const uint8_t *bbuf = got_object_blob_get_read_buf(blob);
err = got_object_blob_read_block(&blen, blob);
if (err)
	goto done;
/* Skip length of blob object header first time around. */
flen = fread(fbuf, 1, sizeof(fbuf) - hdrlen, f);
if (flen == 0 && ferror(f)(!__isthreaded ? (((f)->_flags & 0x0040) != 0) : (ferror
)(f))) {
	err = got_error_from_errno("fread");
	goto done;
}
if (blen - hdrlen == 0) {
	if (flen != 0)
		*status = GOT_STATUS_MODIFY'M';
	break;
} else if (flen == 0) {
	if (blen - hdrlen != 0)
		*status = GOT_STATUS_MODIFY'M';
	break;
} else if (blen - hdrlen == flen) {
	/* Skip blob object header first time around. */
	if (memcmp(bbuf + hdrlen, fbuf, flen) != 0) {
		*status = GOT_STATUS_MODIFY'M';
		break;
	}
} else {
	*status = GOT_STATUS_MODIFY'M';
	break;
}
hdrlen = 0;
}

if (*status == GOT_STATUS_MODIFY'M') {
rewind(f);
err = get_modified_file_content_status(status, f);
} else if (xbit_differs(ie, sb->st_mode))
*status = GOT_STATUS_MODE_CHANGE'm';
1872done:
if (blob)
got_object_blob_close(blob);
if (f != NULL((void*)0) && fclose(f) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", abspath);
if (fd != -1 && close(fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("close", abspath);
return err;
1880}

1882/*
* Update timestamps in the file index if a file is unmodified and
* we had to run a full content comparison to find out.
*/
1886static const struct got_error *
1887sync_timestamps(int wt_fd, const char *path, unsigned char status,
  struct got_fileindex_entry *ie, struct stat *sb)
1889{
if (status == GOT_STATUS_NO_CHANGE' ' && stat_info_differs(ie, sb))
return got_fileindex_entry_update(ie, wt_fd, path,
    ie->blob_sha1, ie->commit_sha1, 1);

return NULL((void*)0);
1895}

1897static const struct got_error *
1898update_blob(struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_fileindex_entry *ie,
  struct got_tree_entry *te, const char *path,
  struct got_repository *repo, got_worktree_checkout_cb progress_cb,
  void *progress_arg)
1903{
const struct got_error *err = NULL((void*)0);
struct got_blob_object *blob = NULL((void*)0);
char *ondisk_path;
unsigned char status = GOT_STATUS_NO_CHANGE' ';
struct stat sb;

if (asprintf(&ondisk_path, "%s/%s", worktree->root_path, path) == -1)
return got_error_from_errno("asprintf");

if (ie) {
if (get_staged_status(ie) != GOT_STATUS_NO_CHANGE' ') {
	err = got_error_path(ie->path, GOT_ERR_FILE_STAGED101);
	goto done;
}
err = get_file_status(&status, &sb, ie, ondisk_path, -1, NULL((void*)0),
    repo);
if (err)
	goto done;
if (status == GOT_STATUS_MISSING'!' || status == GOT_STATUS_DELETE'D')
	sb.st_mode = got_fileindex_perms_to_st(ie);
} else {
sb.st_mode = GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004);
status = GOT_STATUS_UNVERSIONED'?';
}

if (status == GOT_STATUS_OBSTRUCTED'~') {
err = (*progress_cb)(progress_arg, status, path);
goto done;
}
if (status == GOT_STATUS_CONFLICT'C') {
err = (*progress_cb)(progress_arg, GOT_STATUS_CANNOT_UPDATE'#',
    path);
goto done;
}

if (ie && status != GOT_STATUS_MISSING'!' && S_ISREG(sb.st_mode)((sb.st_mode & 0170000) == 0100000) &&
   (S_ISLNK(te->mode)((te->mode & 0170000) == 0120000) ||
   (te->mode & S_IXUSR0000100) == (sb.st_mode & S_IXUSR0000100))) {
/*
 * This is a regular file or an installed bad symlink.
 * If the file index indicates that this file is already
 * up-to-date with respect to the repository we can skip
 * updating contents of this file.
 */
if (got_fileindex_entry_has_commit(ie) &&
    memcmp(ie->commit_sha1, worktree->base_commit_id->sha1,
    SHA1_DIGEST_LENGTH20) == 0) {
	/* Same commit. */
	err = sync_timestamps(worktree->root_fd,
	    path, status, ie, &sb);
	if (err)
		goto done;
	err = (*progress_cb)(progress_arg, GOT_STATUS_EXISTS'E',
	    path);
	goto done;
}
if (got_fileindex_entry_has_blob(ie) &&
    memcmp(ie->blob_sha1, te->id.sha1,
    SHA1_DIGEST_LENGTH20) == 0) {
	/* Different commit but the same blob. */
	err = sync_timestamps(worktree->root_fd,
	    path, status, ie, &sb);
	if (err)
		goto done;
	err = (*progress_cb)(progress_arg, GOT_STATUS_EXISTS'E',
	    path);
	goto done;
}
}

err = got_object_open_as_blob(&blob, repo, &te->id, 8192);
if (err)
goto done;

if (status == GOT_STATUS_MODIFY'M' || status == GOT_STATUS_ADD'A') {
int update_timestamps;
struct got_blob_object *blob2 = NULL((void*)0);
char *label_orig = NULL((void*)0);
if (got_fileindex_entry_has_blob(ie)) {
	struct got_object_id id2;
	memcpy(id2.sha1, ie->blob_sha1, SHA1_DIGEST_LENGTH20);
	err = got_object_open_as_blob(&blob2, repo, &id2, 8192);
	if (err)
		goto done;
}
if (got_fileindex_entry_has_commit(ie)) {
	char id_str[SHA1_DIGEST_STRING_LENGTH(20 * 2 + 1)];
	if (got_sha1_digest_to_str(ie->commit_sha1, id_str,
	    sizeof(id_str)) == NULL((void*)0)) {
		err = got_error_path(id_str,
		    GOT_ERR_BAD_OBJ_ID_STR23);
		goto done;
	}
	if (asprintf(&label_orig, "%s: commit %s",
	    GOT_MERGE_LABEL_BASE"3-way merge base", id_str) == -1) {
		err = got_error_from_errno("asprintf");
		goto done;
	}
}
if (S_ISLNK(te->mode)((te->mode & 0170000) == 0120000) && S_ISLNK(sb.st_mode)((sb.st_mode & 0170000) == 0120000)) {
	char *link_target;
	err = got_object_blob_read_to_str(&link_target, blob);
	if (err)
		goto done;
	err = merge_symlink(worktree, blob2, ondisk_path, path,
	    label_orig, link_target, worktree->base_commit_id,
	    repo, progress_cb, progress_arg);
	free(link_target);
} else {
	err = merge_blob(&update_timestamps, worktree, blob2,
	    ondisk_path, path, sb.st_mode, label_orig, blob,
	    worktree->base_commit_id, repo,
	    progress_cb, progress_arg);
}
free(label_orig);
if (blob2)
	got_object_blob_close(blob2);
if (err)
	goto done;
/*
 * Do not update timestamps of files with local changes.
 * Otherwise, a future status walk would treat them as
 * unmodified files again.
 */
err = got_fileindex_entry_update(ie, worktree->root_fd, path,
    blob->id.sha1, worktree->base_commit_id->sha1,
    update_timestamps);
} else if (status == GOT_STATUS_MODE_CHANGE'm') {
err = got_fileindex_entry_update(ie, worktree->root_fd, path,
    blob->id.sha1, worktree->base_commit_id->sha1, 0);
} else if (status == GOT_STATUS_DELETE'D') {
err = (*progress_cb)(progress_arg, GOT_STATUS_MERGE'G', path);
if (err)
	goto done;
err = got_fileindex_entry_update(ie, worktree->root_fd, path,
    blob->id.sha1, worktree->base_commit_id->sha1, 0);
if (err)
	goto done;
} else {
int is_bad_symlink = 0;
if (S_ISLNK(te->mode)((te->mode & 0170000) == 0120000)) {
	err = install_symlink(&is_bad_symlink, worktree,
	    ondisk_path, path, blob,
	    status == GOT_STATUS_MISSING'!', 0,
	    status == GOT_STATUS_UNVERSIONED'?', repo,
	    progress_cb, progress_arg);
} else {
	err = install_blob(worktree, ondisk_path, path,
	    te->mode, sb.st_mode, blob,
	    status == GOT_STATUS_MISSING'!', 0, 0,
	    status == GOT_STATUS_UNVERSIONED'?', repo,
	    progress_cb, progress_arg);
}
if (err)
	goto done;

if (ie) {
	err = got_fileindex_entry_update(ie,
	    worktree->root_fd, path, blob->id.sha1,
	    worktree->base_commit_id->sha1, 1);
} else {
	err = create_fileindex_entry(&ie, fileindex,
	    worktree->base_commit_id, worktree->root_fd, path,
	    &blob->id);
}
if (err)
	goto done;

if (is_bad_symlink) {
	got_fileindex_entry_filetype_set(ie,
	    GOT_FILEIDX_MODE_BAD_SYMLINK3);
}
}
got_object_blob_close(blob);
2078done:
free(ondisk_path);
return err;
2081}

2083static const struct got_error *
2084remove_ondisk_file(const char *root_path, const char *path)
2085{
const struct got_error *err = NULL((void*)0);
char *ondisk_path = NULL((void*)0);

if (asprintf(&ondisk_path, "%s/%s", root_path, path) == -1)
return got_error_from_errno("asprintf");

if (unlink(ondisk_path) == -1) {
if (errno(*__errno()) != ENOENT2)
	err = got_error_from_errno2("unlink", ondisk_path);
} else {
size_t root_len = strlen(root_path);
do {
	char *parent;
	err = got_path_dirname(&parent, ondisk_path);
	if (err)
		break;
	free(ondisk_path);
	ondisk_path = parent;
	if (rmdir(ondisk_path) == -1) {
		if (errno(*__errno()) != ENOTEMPTY66)
			err = got_error_from_errno2("rmdir",
			    ondisk_path);
		break;
	}
} while (got_path_cmp(ondisk_path, root_path,
    strlen(ondisk_path), root_len) != 0);
}
free(ondisk_path);
return err;
2115}

2117static const struct got_error *
2118delete_blob(struct got_worktree *worktree, struct got_fileindex *fileindex,
  struct got_fileindex_entry *ie, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
2121{
const struct got_error *err = NULL((void*)0);
unsigned char status;
struct stat sb;
char *ondisk_path;

if (get_staged_status(ie) != GOT_STATUS_NO_CHANGE' ')
return got_error_path(ie->path, GOT_ERR_FILE_STAGED101);

if (asprintf(&ondisk_path, "%s/%s", worktree->root_path, ie->path)
   == -1)
return got_error_from_errno("asprintf");

err = get_file_status(&status, &sb, ie, ondisk_path, -1, NULL((void*)0), repo);
if (err)
goto done;

if (S_ISLNK(sb.st_mode)((sb.st_mode & 0170000) == 0120000) && status != GOT_STATUS_NO_CHANGE' ') {
char ondisk_target[PATH_MAX1024];
ssize_t ondisk_len = readlink(ondisk_path, ondisk_target,
    sizeof(ondisk_target));
if (ondisk_len == -1) {
	err = got_error_from_errno2("readlink", ondisk_path);
	goto done;
}
ondisk_target[ondisk_len] = '\0';
err = install_symlink_conflict(NULL((void*)0), worktree->base_commit_id,
    NULL((void*)0), NULL((void*)0), /* XXX pass common ancestor info? */
    ondisk_target, ondisk_path);
if (err)
	goto done;
err = (*progress_cb)(progress_arg, GOT_STATUS_CONFLICT'C',
    ie->path);
goto done;
}

if (status == GOT_STATUS_MODIFY'M' || status == GOT_STATUS_CONFLICT'C' ||
   status == GOT_STATUS_ADD'A') {
err = (*progress_cb)(progress_arg, GOT_STATUS_MERGE'G', ie->path);
if (err)
	goto done;
/*
 * Preserve the working file and change the deleted blob's
 * entry into a schedule-add entry.
 */
err = got_fileindex_entry_update(ie, worktree->root_fd,
    ie->path, NULL((void*)0), NULL((void*)0), 0);
} else {
err = (*progress_cb)(progress_arg, GOT_STATUS_DELETE'D', ie->path);
if (err)
	goto done;
if (status == GOT_STATUS_NO_CHANGE' ') {
	err = remove_ondisk_file(worktree->root_path, ie->path);
	if (err)
		goto done;
}
got_fileindex_entry_remove(fileindex, ie);
}
2179done:
free(ondisk_path);
return err;
2182}

2184struct diff_cb_arg {
  struct got_fileindex *fileindex;
  struct got_worktree *worktree;
  struct got_repository *repo;
  got_worktree_checkout_cb progress_cb;
  void *progress_arg;
  got_cancel_cb cancel_cb;
  void *cancel_arg;
2192};

2194static const struct got_error *
2195diff_old_new(void *arg, struct got_fileindex_entry *ie,
  struct got_tree_entry *te, const char *parent_path)
2197{
struct diff_cb_arg *a = arg;

if (a->cancel_cb && a->cancel_cb(a->cancel_arg))
return got_error(GOT_ERR_CANCELLED49);

return update_blob(a->worktree, a->fileindex, ie, te,
   ie->path, a->repo, a->progress_cb, a->progress_arg);
2205}

2207static const struct got_error *
2208diff_old(void *arg, struct got_fileindex_entry *ie, const char *parent_path)
2209{
struct diff_cb_arg *a = arg;

if (a->cancel_cb && a->cancel_cb(a->cancel_arg))
return got_error(GOT_ERR_CANCELLED49);

return delete_blob(a->worktree, a->fileindex, ie,
   a->repo, a->progress_cb, a->progress_arg);
2217}

2219static const struct got_error *
2220diff_new(void *arg, struct got_tree_entry *te, const char *parent_path)
2221{
struct diff_cb_arg *a = arg;
const struct got_error *err;
char *path;

if (a->cancel_cb && a->cancel_cb(a->cancel_arg))
return got_error(GOT_ERR_CANCELLED49);

if (got_object_tree_entry_is_submodule(te))
return NULL((void*)0);

if (asprintf(&path, "%s%s%s", parent_path,
   parent_path[0] ? "/" : "", te->name)
   == -1)
return got_error_from_errno("asprintf");

if (S_ISDIR(te->mode)((te->mode & 0170000) == 0040000))
err = add_dir_on_disk(a->worktree, path);
else
err = update_blob(a->worktree, a->fileindex, NULL((void*)0), te, path,
    a->repo, a->progress_cb, a->progress_arg);

free(path);
return err;
2245}

2247const struct got_error *
2248got_worktree_get_uuid(char **uuidstr, struct got_worktree *worktree)
2249{
uint32_t uuid_status;

uuid_to_string(&worktree->uuid, uuidstr, &uuid_status);
if (uuid_status != uuid_s_ok0) {
4
←
Assuming 'uuid_status' is equal to uuid_s_ok→
5
←
Taking false branch→
*uuidstr = NULL((void*)0);
return got_error_uuid(uuid_status, "uuid_to_string");
}

return NULL((void*)0);
6
←
Returning null pointer, which participates in a condition later→
2259}

2261static const struct got_error *
2262get_ref_name(char **refname, struct got_worktree *worktree, const char *prefix)
2263{
const struct got_error *err = NULL((void*)0);
char *uuidstr = NULL((void*)0);

*refname = NULL((void*)0);

err = got_worktree_get_uuid(&uuidstr, worktree);
3
←
Calling 'got_worktree_get_uuid'→
7
←
Returning from 'got_worktree_get_uuid'→
if (err7.1
'err' is null
)
8
←
Taking false branch→
return err;

if (asprintf(refname, "%s-%s", prefix, uuidstr) == -1) {
9
←
Assuming the condition is true→
10
←
Taking true branch→
err = got_error_from_errno("asprintf");
*refname = NULL((void*)0);
11
←
Null pointer value stored to 'tmp_branch_name'→
}
free(uuidstr);
return err;
12
←
Returning pointer (loaded from 'err'), which participates in a condition later→
2279}

2281const struct got_error *
2282got_worktree_get_base_ref_name(char **refname, struct got_worktree *worktree)
2283{
return get_ref_name(refname, worktree, GOT_WORKTREE_BASE_REF_PREFIX"refs/got/worktree/base");
2285}

2287static const struct got_error *
2288get_rebase_tmp_ref_name(char **refname, struct got_worktree *worktree)
2289{
return get_ref_name(refname, worktree,
   GOT_WORKTREE_REBASE_TMP_REF_PREFIX"refs/got/worktree/rebase/tmp");
2292}

2294static const struct got_error *
2295get_newbase_symref_name(char **refname, struct got_worktree *worktree)
2296{
return get_ref_name(refname, worktree, GOT_WORKTREE_NEWBASE_REF_PREFIX"refs/got/worktree/rebase/newbase");
2298}

2300static const struct got_error *
2301get_rebase_branch_symref_name(char **refname, struct got_worktree *worktree)
2302{
return get_ref_name(refname, worktree,
   GOT_WORKTREE_REBASE_BRANCH_REF_PREFIX"refs/got/worktree/rebase/branch");
2305}

2307static const struct got_error *
2308get_rebase_commit_ref_name(char **refname, struct got_worktree *worktree)
2309{
return get_ref_name(refname, worktree,
   GOT_WORKTREE_REBASE_COMMIT_REF_PREFIX"refs/got/worktree/rebase/commit");
2312}

2314static const struct got_error *
2315get_histedit_tmp_ref_name(char **refname, struct got_worktree *worktree)
2316{
return get_ref_name(refname, worktree,
2
←
Calling 'get_ref_name'→
13
←
Returning from 'get_ref_name'→
14
←
Returning pointer, which participates in a condition later→
   GOT_WORKTREE_HISTEDIT_TMP_REF_PREFIX"refs/got/worktree/histedit/tmp");
2319}

2321static const struct got_error *
2322get_histedit_branch_symref_name(char **refname, struct got_worktree *worktree)
2323{
return get_ref_name(refname, worktree,
   GOT_WORKTREE_HISTEDIT_BRANCH_REF_PREFIX"refs/got/worktree/histedit/branch");
2326}

2328static const struct got_error *
2329get_histedit_base_commit_ref_name(char **refname, struct got_worktree *worktree)
2330{
return get_ref_name(refname, worktree,
   GOT_WORKTREE_HISTEDIT_BASE_COMMIT_REF_PREFIX"refs/got/worktree/histedit/base-commit");
2333}

2335static const struct got_error *
2336get_histedit_commit_ref_name(char **refname, struct got_worktree *worktree)
2337{
return get_ref_name(refname, worktree,
   GOT_WORKTREE_HISTEDIT_COMMIT_REF_PREFIX"refs/got/worktree/histedit/commit");
2340}

2342const struct got_error *
2343got_worktree_get_histedit_script_path(char **path,
  struct got_worktree *worktree)
2345{
if (asprintf(path, "%s/%s/%s", worktree->root_path,
   GOT_WORKTREE_GOT_DIR".got", GOT_WORKTREE_HISTEDIT_SCRIPT"histedit-script") == -1) {
*path = NULL((void*)0);
return got_error_from_errno("asprintf");
}
return NULL((void*)0);
2352}

2354/*
* Prevent Git's garbage collector from deleting our base commit by
* setting a reference to our base commit's ID.
*/
2358static const struct got_error *
2359ref_base_commit(struct got_worktree *worktree, struct got_repository *repo)
2360{
const struct got_error *err = NULL((void*)0);
struct got_reference *ref = NULL((void*)0);
char *refname;

err = got_worktree_get_base_ref_name(&refname, worktree);
if (err)
return err;

err = got_ref_alloc(&ref, refname, worktree->base_commit_id);
if (err)
goto done;

err = got_ref_write(ref, repo);
2374done:
free(refname);
if (ref)
got_ref_close(ref);
return err;
2379}

2381static const struct got_error *
2382get_fileindex_path(char **fileindex_path, struct got_worktree *worktree)
2383{
const struct got_error *err = NULL((void*)0);

if (asprintf(fileindex_path, "%s/%s/%s", worktree->root_path,
   GOT_WORKTREE_GOT_DIR".got", GOT_WORKTREE_FILE_INDEX"file-index") == -1) {
err = got_error_from_errno("asprintf");
*fileindex_path = NULL((void*)0);
}
return err;
2392}


2395static const struct got_error *
2396open_fileindex(struct got_fileindex **fileindex, char **fileindex_path,
  struct got_worktree *worktree)
2398{
const struct got_error *err = NULL((void*)0);
FILE *index = NULL((void*)0);

*fileindex_path = NULL((void*)0);
*fileindex = got_fileindex_alloc();
if (*fileindex == NULL((void*)0))
return got_error_from_errno("got_fileindex_alloc");

err = get_fileindex_path(fileindex_path, worktree);
if (err)
goto done;

index = fopen(*fileindex_path, "rb");
if (index == NULL((void*)0)) {
if (errno(*__errno()) != ENOENT2)
	err = got_error_from_errno2("fopen", *fileindex_path);
} else {
err = got_fileindex_read(*fileindex, index);
if (fclose(index) == EOF(-1) && err == NULL((void*)0))
	err = got_error_from_errno("fclose");
}
2420done:
if (err) {
free(*fileindex_path);
*fileindex_path = NULL((void*)0);
got_fileindex_free(*fileindex);
*fileindex = NULL((void*)0);
}
return err;
2428}

2430struct bump_base_commit_id_arg {
struct got_object_id *base_commit_id;
const char *path;
size_t path_len;
const char *entry_name;
got_worktree_checkout_cb progress_cb;
void *progress_arg;
2437};

2439/* Bump base commit ID of all files within an updated part of the work tree. */
2440static const struct got_error *
2441bump_base_commit_id(void *arg, struct got_fileindex_entry *ie)
2442{
const struct got_error *err;
struct bump_base_commit_id_arg *a = arg;

if (a->entry_name) {
if (strcmp(ie->path, a->path) != 0)
	return NULL((void*)0);
} else if (!got_path_is_child(ie->path, a->path, a->path_len))
return NULL((void*)0);

if (memcmp(ie->commit_sha1, a->base_commit_id->sha1,
   SHA1_DIGEST_LENGTH20) == 0)
return NULL((void*)0);

if (a->progress_cb) {
err = (*a->progress_cb)(a->progress_arg, GOT_STATUS_BUMP_BASE'b',
    ie->path);
if (err)
	return err;
}
memcpy(ie->commit_sha1, a->base_commit_id->sha1, SHA1_DIGEST_LENGTH20);
return NULL((void*)0);
2464}

2466static const struct got_error *
2467bump_base_commit_id_everywhere(struct got_worktree *worktree,
   struct got_fileindex *fileindex,
   got_worktree_checkout_cb progress_cb, void *progress_arg)
2470{
struct bump_base_commit_id_arg bbc_arg;

bbc_arg.base_commit_id = worktree->base_commit_id;
bbc_arg.entry_name = NULL((void*)0);
bbc_arg.path = "";
bbc_arg.path_len = 0;
bbc_arg.progress_cb = progress_cb;
bbc_arg.progress_arg = progress_arg;

return got_fileindex_for_each_entry_safe(fileindex,
   bump_base_commit_id, &bbc_arg);
2482}

2484static const struct got_error *
2485sync_fileindex(struct got_fileindex *fileindex, const char *fileindex_path)
2486{
const struct got_error *err = NULL((void*)0);
char *new_fileindex_path = NULL((void*)0);
FILE *new_index = NULL((void*)0);
struct timespec timeout;

err = got_opentemp_named(&new_fileindex_path, &new_index,
   fileindex_path);
if (err)
goto done;

err = got_fileindex_write(fileindex, new_index);
if (err)
goto done;

if (rename(new_fileindex_path, fileindex_path) != 0) {
err = got_error_from_errno3("rename", new_fileindex_path,
    fileindex_path);
unlink(new_fileindex_path);
}

/*
* Sleep for a short amount of time to ensure that files modified after
* this program exits have a different time stamp from the one which
* was recorded in the file index.
*/
timeout.tv_sec = 0;
timeout.tv_nsec = 1;
nanosleep(&timeout,  NULL((void*)0));
2515done:
if (new_index)
fclose(new_index);
free(new_fileindex_path);
return err;
2520}

2522static const struct got_error *
2523find_tree_entry_for_checkout(int *entry_type, char **tree_relpath,
  struct got_object_id **tree_id, const char *wt_relpath,
  struct got_worktree *worktree, struct got_repository *repo)
2526{
const struct got_error *err = NULL((void*)0);
struct got_object_id *id = NULL((void*)0);
char *in_repo_path = NULL((void*)0);
int is_root_wt = got_path_is_root_dir(worktree->path_prefix);

*entry_type = GOT_OBJ_TYPE_ANY0;
*tree_relpath = NULL((void*)0);
*tree_id = NULL((void*)0);

if (wt_relpath[0] == '\0') {
/* Check out all files within the work tree. */
*entry_type = GOT_OBJ_TYPE_TREE2;
*tree_relpath = strdup("");
if (*tree_relpath == NULL((void*)0)) {
	err = got_error_from_errno("strdup");
	goto done;
}
err = got_object_id_by_path(tree_id, repo,
    worktree->base_commit_id, worktree->path_prefix);
if (err)
	goto done;
return NULL((void*)0);
}

/* Check out a subset of files in the work tree. */

if (asprintf(&in_repo_path, "%s%s%s", worktree->path_prefix,
   is_root_wt ? "" : "/", wt_relpath) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

err = got_object_id_by_path(&id, repo, worktree->base_commit_id,
   in_repo_path);
if (err)
goto done;

free(in_repo_path);
in_repo_path = NULL((void*)0);

err = got_object_get_type(entry_type, repo, id);
if (err)
goto done;

if (*entry_type == GOT_OBJ_TYPE_BLOB3) {
/* Check out a single file. */
if (strchr(wt_relpath, '/')  == NULL((void*)0)) {
	/* Check out a single file in work tree's root dir. */
	in_repo_path = strdup(worktree->path_prefix);
	if (in_repo_path == NULL((void*)0)) {
		err = got_error_from_errno("strdup");
		goto done;
	}
	*tree_relpath = strdup("");
	if (*tree_relpath == NULL((void*)0)) {
		err = got_error_from_errno("strdup");
		goto done;
	}
} else {
	/* Check out a single file in a subdirectory. */
	err = got_path_dirname(tree_relpath, wt_relpath);
	if (err)
		return err;
	if (asprintf(&in_repo_path, "%s%s%s",
	    worktree->path_prefix, is_root_wt ? "" : "/",
	    *tree_relpath) == -1) {
		err = got_error_from_errno("asprintf");
		goto done;
	}
}
err = got_object_id_by_path(tree_id, repo,
    worktree->base_commit_id, in_repo_path);
} else {
/* Check out all files within a subdirectory. */
*tree_id = got_object_id_dup(id);
if (*tree_id == NULL((void*)0)) {
	err = got_error_from_errno("got_object_id_dup");
	goto done;
}
*tree_relpath = strdup(wt_relpath);
if (*tree_relpath == NULL((void*)0)) {
	err = got_error_from_errno("strdup");
	goto done;
}
}
2612done:
free(id);
free(in_repo_path);
if (err) {
*entry_type = GOT_OBJ_TYPE_ANY0;
free(*tree_relpath);
*tree_relpath = NULL((void*)0);
free(*tree_id);
*tree_id = NULL((void*)0);
}
return err;
2623}

2625static const struct got_error *
2626checkout_files(struct got_worktree *worktree, struct got_fileindex *fileindex,
  const char *relpath, struct got_object_id *tree_id, const char *entry_name,
  struct got_repository *repo, got_worktree_checkout_cb progress_cb,
  void *progress_arg, got_cancel_cb cancel_cb, void *cancel_arg)
2630{
const struct got_error *err = NULL((void*)0);
struct got_commit_object *commit = NULL((void*)0);
struct got_tree_object *tree = NULL((void*)0);
struct got_fileindex_diff_tree_cb diff_cb;
struct diff_cb_arg arg;

err = ref_base_commit(worktree, repo);
if (err) {
if (!(err->code == GOT_ERR_ERRNO1 &&
    (errno(*__errno()) == EACCES13 || errno(*__errno()) == EROFS30)))
	goto done;
err = (*progress_cb)(progress_arg,
    GOT_STATUS_BASE_REF_ERR'B', worktree->root_path);
if (err)
	return err;
}

err = got_object_open_as_commit(&commit, repo,
   worktree->base_commit_id);
if (err)
goto done;

err = got_object_open_as_tree(&tree, repo, tree_id);
if (err)
goto done;

if (entry_name &&
   got_object_tree_find_entry(tree, entry_name) == NULL((void*)0)) {
err = got_error_path(entry_name, GOT_ERR_NO_TREE_ENTRY50);
goto done;
}

diff_cb.diff_old_new = diff_old_new;
diff_cb.diff_old = diff_old;
diff_cb.diff_new = diff_new;
arg.fileindex = fileindex;
arg.worktree = worktree;
arg.repo = repo;
arg.progress_cb = progress_cb;
arg.progress_arg = progress_arg;
arg.cancel_cb = cancel_cb;
arg.cancel_arg = cancel_arg;
err = got_fileindex_diff_tree(fileindex, tree, relpath,
   entry_name, repo, &diff_cb, &arg);
2675done:
if (tree)
got_object_tree_close(tree);
if (commit)
got_object_commit_close(commit);
return err;
2681}

2683const struct got_error *
2684got_worktree_checkout_files(struct got_worktree *worktree,
  struct got_pathlist_head *paths, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)
2688{
const struct got_error *err = NULL((void*)0), *sync_err, *unlockerr;
struct got_commit_object *commit = NULL((void*)0);
struct got_tree_object *tree = NULL((void*)0);
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct got_pathlist_entry *pe;
struct tree_path_data {
SIMPLEQ_ENTRY(tree_path_data)struct { struct tree_path_data *sqe_next; } entry;
struct got_object_id *tree_id;
int entry_type;
char *relpath;
char *entry_name;
} *tpd = NULL((void*)0);
SIMPLEQ_HEAD(tree_paths, tree_path_data)struct tree_paths { struct tree_path_data *sqh_first; struct tree_path_data
 **sqh_last; } tree_paths;

SIMPLEQ_INIT(&tree_paths)do { (&tree_paths)->sqh_first = ((void*)0); (&tree_paths
)->sqh_last = &(&tree_paths)->sqh_first; } while
 (0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

/* Map all specified paths to in-repository trees. */
TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
tpd = malloc(sizeof(*tpd));
if (tpd == NULL((void*)0)) {
	err = got_error_from_errno("malloc");
	goto done;
}

err = find_tree_entry_for_checkout(&tpd->entry_type,
    &tpd->relpath, &tpd->tree_id, pe->path, worktree, repo);
if (err) {
	free(tpd);
	goto done;
}

if (tpd->entry_type == GOT_OBJ_TYPE_BLOB3) {
	err = got_path_basename(&tpd->entry_name, pe->path);
	if (err) {
		free(tpd->relpath);
		free(tpd->tree_id);
		free(tpd);
		goto done;
	}
} else
	tpd->entry_name = NULL((void*)0);

SIMPLEQ_INSERT_TAIL(&tree_paths, tpd, entry)do { (tpd)->entry.sqe_next = ((void*)0); *(&tree_paths
)->sqh_last = (tpd); (&tree_paths)->sqh_last = &
(tpd)->entry.sqe_next; } while (0);
}

/*
* Read the file index.
* Checking out files is supposed to be an idempotent operation.
* If the on-disk file index is incomplete we will try to complete it.
*/
err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

tpd = SIMPLEQ_FIRST(&tree_paths)((&tree_paths)->sqh_first);
TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
struct bump_base_commit_id_arg bbc_arg;

err = checkout_files(worktree, fileindex, tpd->relpath,
    tpd->tree_id, tpd->entry_name, repo,
    progress_cb, progress_arg, cancel_cb, cancel_arg);
if (err)
	break;

bbc_arg.base_commit_id = worktree->base_commit_id;
bbc_arg.entry_name = tpd->entry_name;
bbc_arg.path = pe->path;
bbc_arg.path_len = pe->path_len;
bbc_arg.progress_cb = progress_cb;
bbc_arg.progress_arg = progress_arg;
err = got_fileindex_for_each_entry_safe(fileindex,
    bump_base_commit_id, &bbc_arg);
if (err)
	break;

tpd = SIMPLEQ_NEXT(tpd, entry)((tpd)->entry.sqe_next);
}
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
2774done:
free(fileindex_path);
if (tree)
got_object_tree_close(tree);
if (commit)
got_object_commit_close(commit);
if (fileindex)
got_fileindex_free(fileindex);
while (!SIMPLEQ_EMPTY(&tree_paths)(((&tree_paths)->sqh_first) == ((void*)0))) {
tpd = SIMPLEQ_FIRST(&tree_paths)((&tree_paths)->sqh_first);
SIMPLEQ_REMOVE_HEAD(&tree_paths, entry)do { if (((&tree_paths)->sqh_first = (&tree_paths)
->sqh_first->entry.sqe_next) == ((void*)0)) (&tree_paths
)->sqh_last = &(&tree_paths)->sqh_first; } while
 (0);
free(tpd->relpath);
free(tpd->tree_id);
free(tpd);
}
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
2793}

2795struct merge_file_cb_arg {
  struct got_worktree *worktree;
  struct got_fileindex *fileindex;
  got_worktree_checkout_cb progress_cb;
  void *progress_arg;
  got_cancel_cb cancel_cb;
  void *cancel_arg;
  const char *label_orig;
  struct got_object_id *commit_id2;
2804};

2806static const struct got_error *
2807merge_file_cb(void *arg, struct got_blob_object *blob1,
  struct got_blob_object *blob2, struct got_object_id *id1,
  struct got_object_id *id2, const char *path1, const char *path2,
  mode_t mode1, mode_t mode2, struct got_repository *repo)
2811{
static const struct got_error *err = NULL((void*)0);
struct merge_file_cb_arg *a = arg;
struct got_fileindex_entry *ie;
char *ondisk_path = NULL((void*)0);
struct stat sb;
unsigned char status;
int local_changes_subsumed;

if (blob1 && blob2) {
ie = got_fileindex_entry_get(a->fileindex, path2,
    strlen(path2));
if (ie == NULL((void*)0))
	return (*a->progress_cb)(a->progress_arg,
	    GOT_STATUS_MISSING'!', path2);

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path,
    path2) == -1)
	return got_error_from_errno("asprintf");

err = get_file_status(&status, &sb, ie, ondisk_path, -1, NULL((void*)0),
    repo);
if (err)
	goto done;

if (status == GOT_STATUS_DELETE'D') {
	err = (*a->progress_cb)(a->progress_arg,
	    GOT_STATUS_MERGE'G', path2);
	goto done;
}
if (status != GOT_STATUS_NO_CHANGE' ' &&
    status != GOT_STATUS_MODIFY'M' &&
    status != GOT_STATUS_CONFLICT'C' &&
    status != GOT_STATUS_ADD'A') {
	err = (*a->progress_cb)(a->progress_arg, status, path2);
	goto done;
}

if (S_ISLNK(mode1)((mode1 & 0170000) == 0120000) && S_ISLNK(mode2)((mode2 & 0170000) == 0120000)) {
	char *link_target2;
	err = got_object_blob_read_to_str(&link_target2, blob2);
	if (err)
		goto done;
	err = merge_symlink(a->worktree, blob1, ondisk_path,
	    path2, a->label_orig, link_target2, a->commit_id2,
	    repo, a->progress_cb, a->progress_arg);
	free(link_target2);
} else {
	err = merge_blob(&local_changes_subsumed, a->worktree,
	    blob1, ondisk_path, path2, sb.st_mode,
	    a->label_orig, blob2, a->commit_id2, repo,
	    a->progress_cb, a->progress_arg);
}
} else if (blob1) {
ie = got_fileindex_entry_get(a->fileindex, path1,
    strlen(path1));
if (ie == NULL((void*)0))
	return (*a->progress_cb)(a->progress_arg,
	    GOT_STATUS_MISSING'!', path1);

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path,
    path1) == -1)
	return got_error_from_errno("asprintf");

err = get_file_status(&status, &sb, ie, ondisk_path, -1, NULL((void*)0),
    repo);
if (err)
	goto done;

switch (status) {
case GOT_STATUS_NO_CHANGE' ':
	err = (*a->progress_cb)(a->progress_arg,
	    GOT_STATUS_DELETE'D', path1);
	if (err)
		goto done;
	err = remove_ondisk_file(a->worktree->root_path, path1);
	if (err)
		goto done;
	if (ie)
		got_fileindex_entry_mark_deleted_from_disk(ie);
	break;
case GOT_STATUS_DELETE'D':
case GOT_STATUS_MISSING'!':
	err = (*a->progress_cb)(a->progress_arg,
	    GOT_STATUS_DELETE'D', path1);
	if (err)
		goto done;
	if (ie)
		got_fileindex_entry_mark_deleted_from_disk(ie);
	break;
case GOT_STATUS_ADD'A': {
	struct got_object_id *id;
	FILE *blob1_f;
	/*
	 * Delete the added file only if its content already
	 * exists in the repository.
	 */
	err = got_object_blob_file_create(&id, &blob1_f, path1);
	if (err)
		goto done;
	if (got_object_id_cmp(id, id1) == 0) {
		err = (*a->progress_cb)(a->progress_arg,
		    GOT_STATUS_DELETE'D', path1);
		if (err)
			goto done;
		err = remove_ondisk_file(a->worktree->root_path,
		    path1);
		if (err)
			goto done;
		if (ie)
			got_fileindex_entry_remove(a->fileindex,
			    ie);
	} else {
		err = (*a->progress_cb)(a->progress_arg,
		    GOT_STATUS_CANNOT_DELETE'd', path1);
	}
	if (fclose(blob1_f) == EOF(-1) && err == NULL((void*)0))
		err = got_error_from_errno("fclose");
	free(id);
	if (err)
		goto done;
	break;
}
case GOT_STATUS_MODIFY'M':
case GOT_STATUS_CONFLICT'C':
	err = (*a->progress_cb)(a->progress_arg,
	    GOT_STATUS_CANNOT_DELETE'd', path1);
	if (err)
		goto done;
	break;
case GOT_STATUS_OBSTRUCTED'~':
	err = (*a->progress_cb)(a->progress_arg, status, path1);
	if (err)
		goto done;
	break;
default:
	break;
}
} else if (blob2) {
if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path,
    path2) == -1)
	return got_error_from_errno("asprintf");
ie = got_fileindex_entry_get(a->fileindex, path2,
    strlen(path2));
if (ie) {
	err = get_file_status(&status, &sb, ie, ondisk_path,
	    -1, NULL((void*)0), repo);
	if (err)
		goto done;
	if (status != GOT_STATUS_NO_CHANGE' ' &&
	    status != GOT_STATUS_MODIFY'M' &&
	    status != GOT_STATUS_CONFLICT'C' &&
	    status != GOT_STATUS_ADD'A') {
		err = (*a->progress_cb)(a->progress_arg,
		    status, path2);
		goto done;
	}
	if (S_ISLNK(mode2)((mode2 & 0170000) == 0120000) && S_ISLNK(sb.st_mode)((sb.st_mode & 0170000) == 0120000)) {
		char *link_target2;
		err = got_object_blob_read_to_str(&link_target2,
		    blob2);
		if (err)
			goto done;
		err = merge_symlink(a->worktree, NULL((void*)0),
		    ondisk_path, path2, a->label_orig,
		    link_target2, a->commit_id2, repo,
		    a->progress_cb, a->progress_arg);
		free(link_target2);
	} else if (S_ISREG(sb.st_mode)((sb.st_mode & 0170000) == 0100000)) {
		err = merge_blob(&local_changes_subsumed,
		    a->worktree, NULL((void*)0), ondisk_path, path2,
		    sb.st_mode, a->label_orig, blob2,
		    a->commit_id2, repo, a->progress_cb,
		    a->progress_arg);
	} else {
		err = got_error_path(ondisk_path,
		    GOT_ERR_FILE_OBSTRUCTED31);
	}
	if (err)
		goto done;
	if (status == GOT_STATUS_DELETE'D') {
		err = got_fileindex_entry_update(ie,
		    a->worktree->root_fd, path2, blob2->id.sha1,
		    a->worktree->base_commit_id->sha1, 0);
		if (err)
			goto done;
	}
} else {
	int is_bad_symlink = 0;
	sb.st_mode = GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004);
	if (S_ISLNK(mode2)((mode2 & 0170000) == 0120000)) {
		err = install_symlink(&is_bad_symlink,
		    a->worktree, ondisk_path, path2, blob2, 0,
		    0, 1, repo, a->progress_cb, a->progress_arg);
	} else {
		err = install_blob(a->worktree, ondisk_path, path2,
		    mode2, sb.st_mode, blob2, 0, 0, 0, 1, repo,
		    a->progress_cb, a->progress_arg);
	}
	if (err)
		goto done;
	err = got_fileindex_entry_alloc(&ie, path2);
	if (err)
		goto done;
	err = got_fileindex_entry_update(ie,
	    a->worktree->root_fd, path2, NULL((void*)0), NULL((void*)0), 1);
	if (err) {
		got_fileindex_entry_free(ie);
		goto done;
	}
	err = got_fileindex_entry_add(a->fileindex, ie);
	if (err) {
		got_fileindex_entry_free(ie);
		goto done;
	}
	if (is_bad_symlink) {
		got_fileindex_entry_filetype_set(ie,
		    GOT_FILEIDX_MODE_BAD_SYMLINK3);
	}
}
}
3032done:
free(ondisk_path);
return err;
3035}

3037struct check_merge_ok_arg {
struct got_worktree *worktree;
struct got_repository *repo;
3040};

3042static const struct got_error *
3043check_merge_ok(void *arg, struct got_fileindex_entry *ie)
3044{
const struct got_error *err = NULL((void*)0);
struct check_merge_ok_arg *a = arg;
unsigned char status;
struct stat sb;
char *ondisk_path;

/* Reject merges into a work tree with mixed base commits. */
if (memcmp(ie->commit_sha1, a->worktree->base_commit_id->sha1,
   SHA1_DIGEST_LENGTH20))
return got_error(GOT_ERR_MIXED_COMMITS81);

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path, ie->path)
   == -1)
return got_error_from_errno("asprintf");

/* Reject merges into a work tree with conflicted files. */
err = get_file_status(&status, &sb, ie, ondisk_path, -1, NULL((void*)0), a->repo);
if (err)
return err;
if (status == GOT_STATUS_CONFLICT'C')
return got_error(GOT_ERR_CONFLICTS82);

return NULL((void*)0);
3068}

3070static const struct got_error *
3071merge_files(struct got_worktree *worktree, struct got_fileindex *fileindex,
  const char *fileindex_path, struct got_object_id *commit_id1,
  struct got_object_id *commit_id2, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)
3076{
const struct got_error *err = NULL((void*)0), *sync_err;
struct got_object_id *tree_id1 = NULL((void*)0), *tree_id2 = NULL((void*)0);
struct got_tree_object *tree1 = NULL((void*)0), *tree2 = NULL((void*)0);
struct merge_file_cb_arg arg;
char *label_orig = NULL((void*)0);

if (commit_id1) {
err = got_object_id_by_path(&tree_id1, repo, commit_id1,
    worktree->path_prefix);
if (err && err->code != GOT_ERR_NO_TREE_ENTRY50)
	goto done;
}
if (tree_id1) {
char *id_str;

err = got_object_open_as_tree(&tree1, repo, tree_id1);
if (err)
	goto done;

err = got_object_id_str(&id_str, commit_id1);
if (err)
	goto done;

if (asprintf(&label_orig, "%s: commit %s",
    GOT_MERGE_LABEL_BASE"3-way merge base", id_str) == -1) {
	err = got_error_from_errno("asprintf");
	free(id_str);
	goto done;
}
free(id_str);
}

err = got_object_id_by_path(&tree_id2, repo, commit_id2,
   worktree->path_prefix);
if (err)
goto done;

err = got_object_open_as_tree(&tree2, repo, tree_id2);
if (err)
goto done;

arg.worktree = worktree;
arg.fileindex = fileindex;
arg.progress_cb = progress_cb;
arg.progress_arg = progress_arg;
arg.cancel_cb = cancel_cb;
arg.cancel_arg = cancel_arg;
arg.label_orig = label_orig;
arg.commit_id2 = commit_id2;
err = got_diff_tree(tree1, tree2, "", "", repo, merge_file_cb, &arg, 1);
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
3130done:
if (tree1)
got_object_tree_close(tree1);
if (tree2)
got_object_tree_close(tree2);
free(label_orig);
return err;
3137}

3139const struct got_error *
3140got_worktree_merge_files(struct got_worktree *worktree,
  struct got_object_id *commit_id1, struct got_object_id *commit_id2,
  struct got_repository *repo, got_worktree_checkout_cb progress_cb,
  void *progress_arg, got_cancel_cb cancel_cb, void *cancel_arg)
3144{
const struct got_error *err, *unlockerr;
char *fileindex_path = NULL((void*)0);
struct got_fileindex *fileindex = NULL((void*)0);
struct check_merge_ok_arg mok_arg;

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

mok_arg.worktree = worktree;
mok_arg.repo = repo;
err = got_fileindex_for_each_entry_safe(fileindex, check_merge_ok,
   &mok_arg);
if (err)
goto done;

err = merge_files(worktree, fileindex, fileindex_path, commit_id1,
   commit_id2, repo, progress_cb, progress_arg, cancel_cb, cancel_arg);
3167done:
if (fileindex)
got_fileindex_free(fileindex);
free(fileindex_path);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
3175}

3177struct diff_dir_cb_arg {
  struct got_fileindex *fileindex;
  struct got_worktree *worktree;
  const char *status_path;
  size_t status_path_len;
  struct got_repository *repo;
  got_worktree_status_cb status_cb;
  void *status_arg;
  got_cancel_cb cancel_cb;
  void *cancel_arg;
  /* A pathlist containing per-directory pathlists of ignore patterns. */
  struct got_pathlist_head ignores;
  int report_unchanged;
  int no_ignores;
3191};

3193static const struct got_error *
3194report_file_status(struct got_fileindex_entry *ie, const char *abspath,
  int dirfd, const char *de_name,
  got_worktree_status_cb status_cb, void *status_arg,
  struct got_repository *repo, int report_unchanged)
3198{
const struct got_error *err = NULL((void*)0);
unsigned char status = GOT_STATUS_NO_CHANGE' ';
unsigned char staged_status = get_staged_status(ie);
struct stat sb;
struct got_object_id blob_id, commit_id, staged_blob_id;
struct got_object_id *blob_idp = NULL((void*)0), *commit_idp = NULL((void*)0);
struct got_object_id *staged_blob_idp = NULL((void*)0);

err = get_file_status(&status, &sb, ie, abspath, dirfd, de_name, repo);
if (err)
return err;

if (status == GOT_STATUS_NO_CHANGE' ' &&
   staged_status == GOT_STATUS_NO_CHANGE' ' && !report_unchanged)
return NULL((void*)0);

if (got_fileindex_entry_has_blob(ie)) {
memcpy(blob_id.sha1, ie->blob_sha1, SHA1_DIGEST_LENGTH20);
blob_idp = &blob_id;
}
if (got_fileindex_entry_has_commit(ie)) {
memcpy(commit_id.sha1, ie->commit_sha1, SHA1_DIGEST_LENGTH20);
commit_idp = &commit_id;
}
if (staged_status == GOT_STATUS_ADD'A' ||
   staged_status == GOT_STATUS_MODIFY'M') {
memcpy(staged_blob_id.sha1, ie->staged_blob_sha1,
    SHA1_DIGEST_LENGTH20);
staged_blob_idp = &staged_blob_id;
}

return (*status_cb)(status_arg, status, staged_status,
   ie->path, blob_idp, staged_blob_idp, commit_idp, dirfd, de_name);
3232}

3234static const struct got_error *
3235status_old_new(void *arg, struct got_fileindex_entry *ie,
  struct dirent *de, const char *parent_path, int dirfd)
3237{
const struct got_error *err = NULL((void*)0);
struct diff_dir_cb_arg *a = arg;
char *abspath;

if (a->cancel_cb && a->cancel_cb(a->cancel_arg))
return got_error(GOT_ERR_CANCELLED49);

if (got_path_cmp(parent_path, a->status_path,
   strlen(parent_path), a->status_path_len) != 0 &&
   !got_path_is_child(parent_path, a->status_path, a->status_path_len))
return NULL((void*)0);

if (parent_path[0]) {
if (asprintf(&abspath, "%s/%s/%s", a->worktree->root_path,
    parent_path, de->d_name) == -1)
	return got_error_from_errno("asprintf");
} else {
if (asprintf(&abspath, "%s/%s", a->worktree->root_path,
    de->d_name) == -1)
	return got_error_from_errno("asprintf");
}

err = report_file_status(ie, abspath, dirfd, de->d_name,
   a->status_cb, a->status_arg, a->repo, a->report_unchanged);
free(abspath);
return err;
3264}

3266static const struct got_error *
3267status_old(void *arg, struct got_fileindex_entry *ie, const char *parent_path)
3268{
struct diff_dir_cb_arg *a = arg;
struct got_object_id blob_id, commit_id;
unsigned char status;

if (a->cancel_cb && a->cancel_cb(a->cancel_arg))
return got_error(GOT_ERR_CANCELLED49);

if (!got_path_is_child(ie->path, a->status_path, a->status_path_len))
return NULL((void*)0);

memcpy(blob_id.sha1, ie->blob_sha1, SHA1_DIGEST_LENGTH20);
memcpy(commit_id.sha1, ie->commit_sha1, SHA1_DIGEST_LENGTH20);
if (got_fileindex_entry_has_file_on_disk(ie))
status = GOT_STATUS_MISSING'!';
else
status = GOT_STATUS_DELETE'D';
return (*a->status_cb)(a->status_arg, status, get_staged_status(ie),
   ie->path, &blob_id, NULL((void*)0), &commit_id, -1, NULL((void*)0));
3287}

3289void
3290free_ignorelist(struct got_pathlist_head *ignorelist)
3291{
struct got_pathlist_entry *pe;

TAILQ_FOREACH(pe, ignorelist, entry)for((pe) = ((ignorelist)->tqh_first); (pe) != ((void*)0); (
pe) = ((pe)->entry.tqe_next))
free((char *)pe->path);
got_pathlist_free(ignorelist);
3297}

3299void
3300free_ignores(struct got_pathlist_head *ignores)
3301{
struct got_pathlist_entry *pe;

TAILQ_FOREACH(pe, ignores, entry)for((pe) = ((ignores)->tqh_first); (pe) != ((void*)0); (pe
) = ((pe)->entry.tqe_next)) {
struct got_pathlist_head *ignorelist = pe->data;
free_ignorelist(ignorelist);
free((char *)pe->path);
}
got_pathlist_free(ignores);
3310}

3312static const struct got_error *
3313read_ignores(struct got_pathlist_head *ignores, const char *path, FILE *f)
3314{
const struct got_error *err = NULL((void*)0);
struct got_pathlist_entry *pe = NULL((void*)0);
struct got_pathlist_head *ignorelist;
char *line = NULL((void*)0), *pattern, *dirpath = NULL((void*)0);
size_t linesize = 0;
ssize_t linelen;

ignorelist = calloc(1, sizeof(*ignorelist));
if (ignorelist == NULL((void*)0))
return got_error_from_errno("calloc");
TAILQ_INIT(ignorelist)do { (ignorelist)->tqh_first = ((void*)0); (ignorelist)->
tqh_last = &(ignorelist)->tqh_first; } while (0);

while ((linelen = getline(&line, &linesize, f)) != -1) {
if (linelen > 0 && line[linelen - 1] == '\n')
	line[linelen - 1] = '\0';

/* Git's ignores may contain comments. */
if (line[0] == '#')
	continue;

/* Git's negated patterns are not (yet?) supported. */
if (line[0] == '!')
	continue;

if (asprintf(&pattern, "%s%s%s", path, path[0] ? "/" : "",
    line) == -1) {
	err = got_error_from_errno("asprintf");
	goto done;
}
err = got_pathlist_insert(NULL((void*)0), ignorelist, pattern, NULL((void*)0));
if (err)
	goto done;
}
if (ferror(f)(!__isthreaded ? (((f)->_flags & 0x0040) != 0) : (ferror
)(f))) {
err = got_error_from_errno("getline");
goto done;
}

dirpath = strdup(path);
if (dirpath == NULL((void*)0)) {
err = got_error_from_errno("strdup");
goto done;
}
err = got_pathlist_insert(&pe, ignores, dirpath, ignorelist);
3359done:
free(line);
if (err || pe == NULL((void*)0)) {
free(dirpath);
free_ignorelist(ignorelist);
}
return err;
3366}

3368int
3369match_ignores(struct got_pathlist_head *ignores, const char *path)
3370{
struct got_pathlist_entry *pe;

/* Handle patterns which match in all directories. */
TAILQ_FOREACH(pe, ignores, entry)for((pe) = ((ignores)->tqh_first); (pe) != ((void*)0); (pe
) = ((pe)->entry.tqe_next)) {
struct got_pathlist_head *ignorelist = pe->data;
struct got_pathlist_entry *pi;

TAILQ_FOREACH(pi, ignorelist, entry)for((pi) = ((ignorelist)->tqh_first); (pi) != ((void*)0); (
pi) = ((pi)->entry.tqe_next)) {
	const char *p, *pattern = pi->path;

	if (strncmp(pattern, "**/", 3) != 0)
		continue;
	pattern += 3;
	p = path;
	while (*p) {
		if (fnmatch(pattern, p,
		    FNM_PATHNAME0x02 | FNM_LEADING_DIR0x08)) {
			/* Retry in next directory. */
			while (*p && *p != '/')
				p++;
			while (*p == '/')
				p++;
			continue;
		}
		return 1;
	}
}
}

/*
* The ignores pathlist contains ignore lists from children before
* parents, so we can find the most specific ignorelist by walking
* ignores backwards.
*/
pe = TAILQ_LAST(ignores, got_pathlist_head)(*(((struct got_pathlist_head *)((ignores)->tqh_last))->
tqh_last));
while (pe) {
if (got_path_is_child(path, pe->path, pe->path_len)) {
	struct got_pathlist_head *ignorelist = pe->data;
	struct got_pathlist_entry *pi;
	TAILQ_FOREACH(pi, ignorelist, entry)for((pi) = ((ignorelist)->tqh_first); (pi) != ((void*)0); (
pi) = ((pi)->entry.tqe_next)) {
		const char *pattern = pi->path;
		int flags = FNM_LEADING_DIR0x08;
		if (strstr(pattern, "/**/") == NULL((void*)0))
			flags |= FNM_PATHNAME0x02;
		if (fnmatch(pattern, path, flags))
			continue;
		return 1;
	}
}
pe = TAILQ_PREV(pe, got_pathlist_head, entry)(*(((struct got_pathlist_head *)((pe)->entry.tqe_prev))->
tqh_last));
}

return 0;
3424}

3426static const struct got_error *
3427add_ignores(struct got_pathlist_head *ignores, const char *root_path,
  const char *path, int dirfd, const char *ignores_filename)
3429{
const struct got_error *err = NULL((void*)0);
char *ignorespath;
int fd = -1;
FILE *ignoresfile = NULL((void*)0);

if (asprintf(&ignorespath, "%s/%s%s%s", root_path, path,
   path[0] ? "/" : "", ignores_filename) == -1)
return got_error_from_errno("asprintf");

if (dirfd != -1) {
fd = openat(dirfd, ignores_filename, O_RDONLY0x0000 | O_NOFOLLOW0x0100);
if (fd == -1) {
	if (errno(*__errno()) != ENOENT2 && errno(*__errno()) != EACCES13)
		err = got_error_from_errno2("openat",
		    ignorespath);
} else {
	ignoresfile = fdopen(fd, "r");
	if (ignoresfile == NULL((void*)0)) 
		err = got_error_from_errno2("fdopen",
		    ignorespath);
	else {
		fd = -1;
		err = read_ignores(ignores, path, ignoresfile);
	}
}
} else {
ignoresfile = fopen(ignorespath, "r");
if (ignoresfile == NULL((void*)0)) {
	if (errno(*__errno()) != ENOENT2 && errno(*__errno()) != EACCES13)
		err = got_error_from_errno2("fopen",
		    ignorespath);
} else
	err = read_ignores(ignores, path, ignoresfile);
}

if (ignoresfile && fclose(ignoresfile) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", path);
if (fd != -1 && close(fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("close", path);
free(ignorespath);
return err;
3471}

3473static const struct got_error *
3474status_new(void *arg, struct dirent *de, const char *parent_path, int dirfd)
3475{
const struct got_error *err = NULL((void*)0);
struct diff_dir_cb_arg *a = arg;
char *path = NULL((void*)0);

if (a->cancel_cb && a->cancel_cb(a->cancel_arg))
return got_error(GOT_ERR_CANCELLED49);

if (parent_path[0]) {
if (asprintf(&path, "%s/%s", parent_path, de->d_name) == -1)
	return got_error_from_errno("asprintf");
} else {
path = de->d_name;
}

if (de->d_type != DT_DIR4 &&
   got_path_is_child(path, a->status_path, a->status_path_len)
   && !match_ignores(&a->ignores, path))
err = (*a->status_cb)(a->status_arg, GOT_STATUS_UNVERSIONED'?',
    GOT_STATUS_NO_CHANGE' ', path, NULL((void*)0), NULL((void*)0), NULL((void*)0), -1, NULL((void*)0));
if (parent_path[0])
free(path);
return err;
3498}

3500static const struct got_error *
3501status_traverse(void *arg, const char *path, int dirfd)
3502{
const struct got_error *err = NULL((void*)0);
struct diff_dir_cb_arg *a = arg;

if (a->no_ignores)
return NULL((void*)0);

err = add_ignores(&a->ignores, a->worktree->root_path,
   path, dirfd, ".cvsignore");
if (err)
return err;

err = add_ignores(&a->ignores, a->worktree->root_path, path,
   dirfd, ".gitignore");

return err;
3518}

3520static const struct got_error *
3521report_single_file_status(const char *path, const char *ondisk_path,
3522struct got_fileindex *fileindex, got_worktree_status_cb status_cb,
3523void *status_arg, struct got_repository *repo, int report_unchanged)
3524{
struct got_fileindex_entry *ie;
struct stat sb;

ie = got_fileindex_entry_get(fileindex, path, strlen(path));
if (ie)
return report_file_status(ie, ondisk_path, -1, NULL((void*)0),
    status_cb, status_arg, repo, report_unchanged);

if (lstat(ondisk_path, &sb) == -1) {
if (errno(*__errno()) != ENOENT2)
	return got_error_from_errno2("lstat", ondisk_path);
return (*status_cb)(status_arg, GOT_STATUS_NONEXISTENT'N',
    GOT_STATUS_NO_CHANGE' ', path, NULL((void*)0), NULL((void*)0), NULL((void*)0), -1, NULL((void*)0));
return NULL((void*)0);
}

if (S_ISREG(sb.st_mode)((sb.st_mode & 0170000) == 0100000) || S_ISLNK(sb.st_mode)((sb.st_mode & 0170000) == 0120000))
return (*status_cb)(status_arg, GOT_STATUS_UNVERSIONED'?',
    GOT_STATUS_NO_CHANGE' ', path, NULL((void*)0), NULL((void*)0), NULL((void*)0), -1, NULL((void*)0));

return NULL((void*)0);
3546}

3548static const struct got_error *
3549add_ignores_from_parent_paths(struct got_pathlist_head *ignores,
  const char *root_path, const char *path)
3551{
const struct got_error *err;
char *parent_path, *next_parent_path = NULL((void*)0);

err = add_ignores(ignores, root_path, "", -1,
   ".cvsignore");
if (err)
return err;

err = add_ignores(ignores, root_path, "", -1,
   ".gitignore");
if (err)
return err;

err = got_path_dirname(&parent_path, path);
if (err) {
if (err->code == GOT_ERR_BAD_PATH4)
	return NULL((void*)0); /* cannot traverse parent */
return err;
}
for (;;) {
err = add_ignores(ignores, root_path, parent_path, -1,
    ".cvsignore");
if (err)
	break;
err = add_ignores(ignores, root_path, parent_path, -1,
    ".gitignore");
if (err)
	break;
err = got_path_dirname(&next_parent_path, parent_path);
if (err) {
	if (err->code == GOT_ERR_BAD_PATH4)
		err = NULL((void*)0); /* traversed everything */
	break;
}
free(parent_path);
parent_path = next_parent_path;
next_parent_path = NULL((void*)0);
}

free(parent_path);
free(next_parent_path);
return err;
3594}

3596static const struct got_error *
3597worktree_status(struct got_worktree *worktree, const char *path,
  struct got_fileindex *fileindex, struct got_repository *repo,
  got_worktree_status_cb status_cb, void *status_arg,
  got_cancel_cb cancel_cb, void *cancel_arg, int no_ignores,
  int report_unchanged)
3602{
const struct got_error *err = NULL((void*)0);
int fd = -1;
struct got_fileindex_diff_dir_cb fdiff_cb;
struct diff_dir_cb_arg arg;
char *ondisk_path = NULL((void*)0);

TAILQ_INIT(&arg.ignores)do { (&arg.ignores)->tqh_first = ((void*)0); (&arg
.ignores)->tqh_last = &(&arg.ignores)->tqh_first
; } while (0);

if (asprintf(&ondisk_path, "%s%s%s",
   worktree->root_path, path[0] ? "/" : "", path) == -1)
return got_error_from_errno("asprintf");

fd = open(ondisk_path, O_RDONLY0x0000 | O_NOFOLLOW0x0100 | O_DIRECTORY0x20000);
if (fd == -1) {
if (errno(*__errno()) != ENOTDIR20 && errno(*__errno()) != ENOENT2 && errno(*__errno()) != EACCES13 &&
    errno(*__errno()) != ELOOP62)
	err = got_error_from_errno2("open", ondisk_path);
else
	err = report_single_file_status(path, ondisk_path,
	    fileindex, status_cb, status_arg, repo,
	    report_unchanged);
} else {
fdiff_cb.diff_old_new = status_old_new;
fdiff_cb.diff_old = status_old;
fdiff_cb.diff_new = status_new;
fdiff_cb.diff_traverse = status_traverse;
arg.fileindex = fileindex;
arg.worktree = worktree;
arg.status_path = path;
arg.status_path_len = strlen(path);
arg.repo = repo;
arg.status_cb = status_cb;
arg.status_arg = status_arg;
arg.cancel_cb = cancel_cb;
arg.cancel_arg = cancel_arg;
arg.report_unchanged = report_unchanged;
arg.no_ignores = no_ignores;
if (!no_ignores) {
	err = add_ignores_from_parent_paths(&arg.ignores,
	    worktree->root_path, path);
	if (err)
		goto done;
}
err = got_fileindex_diff_dir(fileindex, fd,
    worktree->root_path, path, repo, &fdiff_cb, &arg);
}
3649done:
free_ignores(&arg.ignores);
if (fd != -1 && close(fd) == -1 && err == NULL((void*)0))
err = got_error_from_errno("close");
free(ondisk_path);
return err;
3655}

3657const struct got_error *
3658got_worktree_status(struct got_worktree *worktree,
  struct got_pathlist_head *paths, struct got_repository *repo,
  got_worktree_status_cb status_cb, void *status_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)
3662{
const struct got_error *err = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct got_fileindex *fileindex = NULL((void*)0);
struct got_pathlist_entry *pe;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
return err;

TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
	status_cb, status_arg, cancel_cb, cancel_arg, 0, 0);
if (err)
	break;
}
free(fileindex_path);
got_fileindex_free(fileindex);
return err;
3681}

3683const struct got_error *
3684got_worktree_resolve_path(char **wt_path, struct got_worktree *worktree,
  const char *arg)
3686{
const struct got_error *err = NULL((void*)0);
char *resolved = NULL((void*)0), *cwd = NULL((void*)0), *path = NULL((void*)0);
size_t len;
struct stat sb;
char *abspath = NULL((void*)0);
char canonpath[PATH_MAX1024];

*wt_path = NULL((void*)0);

cwd = getcwd(NULL((void*)0), 0);
if (cwd == NULL((void*)0))
return got_error_from_errno("getcwd");

if (lstat(arg, &sb) == -1) {
if (errno(*__errno()) != ENOENT2) {
	err = got_error_from_errno2("lstat", arg);
	goto done;
}
sb.st_mode = 0;
}
if (S_ISLNK(sb.st_mode)((sb.st_mode & 0170000) == 0120000)) {
/*
 * We cannot use realpath(3) with symlinks since we want to
 * operate on the symlink itself.
 * But we can make the path absolute, assuming it is relative
 * to the current working directory, and then canonicalize it.
 */
if (!got_path_is_absolute(arg)) {
	if (asprintf(&abspath, "%s/%s", cwd, arg) == -1) {
		err = got_error_from_errno("asprintf");
		goto done;
	}

}
err = got_canonpath(abspath ? abspath : arg, canonpath,
    sizeof(canonpath));
if (err)
	goto done;
resolved = strdup(canonpath);
if (resolved == NULL((void*)0)) {
	err = got_error_from_errno("strdup");
	goto done;
}
} else {
resolved = realpath(arg, NULL((void*)0));
if (resolved == NULL((void*)0)) {
	if (errno(*__errno()) != ENOENT2) {
		err = got_error_from_errno2("realpath", arg);
		goto done;
	}
	if (asprintf(&abspath, "%s/%s", cwd, arg) == -1) {
		err = got_error_from_errno("asprintf");
		goto done;
	}
	err = got_canonpath(abspath, canonpath,
	    sizeof(canonpath));
	if (err)
		goto done;
	resolved = strdup(canonpath);
	if (resolved == NULL((void*)0)) {
		err = got_error_from_errno("strdup");
		goto done;
	}
}
}

if (strncmp(got_worktree_get_root_path(worktree), resolved,
   strlen(got_worktree_get_root_path(worktree)))) {
err = got_error_path(resolved, GOT_ERR_BAD_PATH4);
goto done;
}

if (strlen(resolved) > strlen(got_worktree_get_root_path(worktree))) {
err = got_path_skip_common_ancestor(&path,
    got_worktree_get_root_path(worktree), resolved);
if (err)
	goto done;
} else {
path = strdup("");
if (path == NULL((void*)0)) {
	err = got_error_from_errno("strdup");
	goto done;
}
}

/* XXX status walk can't deal with trailing slash! */
len = strlen(path);
while (len > 0 && path[len - 1] == '/') {
path[len - 1] = '\0';
len--;
}
3778done:
free(abspath);
free(resolved);
free(cwd);
if (err == NULL((void*)0))
*wt_path = path;
else
free(path);
return err;
3787}

3789struct schedule_addition_args {
struct got_worktree *worktree;
struct got_fileindex *fileindex;
got_worktree_checkout_cb progress_cb;
void *progress_arg;
struct got_repository *repo;
3795};

3797static const struct got_error *
3798schedule_addition(void *arg, unsigned char status, unsigned char staged_status,
  const char *relpath, struct got_object_id *blob_id,
  struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
  int dirfd, const char *de_name)
3802{
struct schedule_addition_args *a = arg;
const struct got_error *err = NULL((void*)0);
struct got_fileindex_entry *ie;
struct stat sb;
char *ondisk_path;

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path,
   relpath) == -1)
return got_error_from_errno("asprintf");

ie = got_fileindex_entry_get(a->fileindex, relpath, strlen(relpath));
if (ie) {
err = get_file_status(&status, &sb, ie, ondisk_path, dirfd,
    de_name, a->repo);
if (err)
	goto done;
/* Re-adding an existing entry is a no-op. */
if (status == GOT_STATUS_ADD'A')
	goto done;
err = got_error_path(relpath, GOT_ERR_FILE_STATUS68);
if (err)
	goto done;
}

if (status != GOT_STATUS_UNVERSIONED'?') {
err = got_error_path(ondisk_path, GOT_ERR_FILE_STATUS68);
goto done;
}

err = got_fileindex_entry_alloc(&ie, relpath);
if (err)
goto done;
err = got_fileindex_entry_update(ie, a->worktree->root_fd,
   relpath, NULL((void*)0), NULL((void*)0), 1);
if (err) {
got_fileindex_entry_free(ie);
goto done;
}
err = got_fileindex_entry_add(a->fileindex, ie);
if (err) {
got_fileindex_entry_free(ie);
goto done;
}
3846done:
free(ondisk_path);
if (err)
return err;
if (status == GOT_STATUS_ADD'A')
return NULL((void*)0);
return (*a->progress_cb)(a->progress_arg, GOT_STATUS_ADD'A', relpath);
3853}

3855const struct got_error *
3856got_worktree_schedule_add(struct got_worktree *worktree,
  struct got_pathlist_head *paths,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  struct got_repository *repo, int no_ignores)
3860{
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
const struct got_error *err = NULL((void*)0), *sync_err, *unlockerr;
struct got_pathlist_entry *pe;
struct schedule_addition_args saa;

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

saa.worktree = worktree;
saa.fileindex = fileindex;
saa.progress_cb = progress_cb;
saa.progress_arg = progress_arg;
saa.repo = repo;

TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
	schedule_addition, &saa, NULL((void*)0), NULL((void*)0), no_ignores, 0);
if (err)
	break;
}
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
3890done:
free(fileindex_path);
if (fileindex)
got_fileindex_free(fileindex);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
3898}

3900struct schedule_deletion_args {
struct got_worktree *worktree;
struct got_fileindex *fileindex;
got_worktree_delete_cb progress_cb;
void *progress_arg;
struct got_repository *repo;
int delete_local_mods;
int keep_on_disk;
const char *status_codes;
3909};

3911static const struct got_error *
3912schedule_for_deletion(void *arg, unsigned char status,
  unsigned char staged_status, const char *relpath,
  struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
  struct got_object_id *commit_id, int dirfd, const char *de_name)
3916{
struct schedule_deletion_args *a = arg;
const struct got_error *err = NULL((void*)0);
struct got_fileindex_entry *ie = NULL((void*)0);
struct stat sb;
char *ondisk_path;

ie = got_fileindex_entry_get(a->fileindex, relpath, strlen(relpath));
if (ie == NULL((void*)0))
return got_error_path(relpath, GOT_ERR_BAD_PATH4);

staged_status = get_staged_status(ie);
if (staged_status != GOT_STATUS_NO_CHANGE' ') {
if (staged_status == GOT_STATUS_DELETE'D')
	return NULL((void*)0);
return got_error_path(relpath, GOT_ERR_FILE_STAGED101);
}

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path,
   relpath) == -1)
return got_error_from_errno("asprintf");

err = get_file_status(&status, &sb, ie, ondisk_path, dirfd, de_name,
   a->repo);
if (err)
goto done;

if (a->status_codes) {
size_t ncodes = strlen(a->status_codes);
int i;
for (i = 0; i < ncodes ; i++) {
	if (status == a->status_codes[i])
		break;
}
if (i == ncodes) { 
	/* Do not delete files in non-matching status. */
	free(ondisk_path);
	return NULL((void*)0);
}
if (a->status_codes[i] != GOT_STATUS_MODIFY'M' &&
    a->status_codes[i] != GOT_STATUS_MISSING'!') {
	static char msg[64];
	snprintf(msg, sizeof(msg),
	    "invalid status code '%c'", a->status_codes[i]);
	err = got_error_msg(GOT_ERR_FILE_STATUS68, msg);
	goto done;
}
}

if (status != GOT_STATUS_NO_CHANGE' ') {
if (status == GOT_STATUS_DELETE'D')
	goto done;
if (status == GOT_STATUS_MODIFY'M' && !a->delete_local_mods) {
	err = got_error_path(relpath, GOT_ERR_FILE_MODIFIED67);
	goto done;
}
if (status != GOT_STATUS_MODIFY'M' &&
    status != GOT_STATUS_MISSING'!') {
	err = got_error_path(relpath, GOT_ERR_FILE_STATUS68);
	goto done;
}
}

if (!a->keep_on_disk && status != GOT_STATUS_MISSING'!') {
size_t root_len;

if (dirfd != -1) {
	if (unlinkat(dirfd, de_name, 0) != 0) {
		err = got_error_from_errno2("unlinkat",
		    ondisk_path);
		goto done;
	}
} else if (unlink(ondisk_path) != 0) {
	err = got_error_from_errno2("unlink", ondisk_path);
	goto done;
}

root_len = strlen(a->worktree->root_path);
do {
	char *parent;
	err = got_path_dirname(&parent, ondisk_path);
	if (err)
		goto done;
	free(ondisk_path);
	ondisk_path = parent;
	if (rmdir(ondisk_path) == -1) {
		if (errno(*__errno()) != ENOTEMPTY66)
			err = got_error_from_errno2("rmdir",
			    ondisk_path);
		break;
	}
} while (got_path_cmp(ondisk_path, a->worktree->root_path,
    strlen(ondisk_path), root_len) != 0);
}

got_fileindex_entry_mark_deleted_from_disk(ie);
4012done:
free(ondisk_path);
if (err)
return err;
if (status == GOT_STATUS_DELETE'D')
return NULL((void*)0);
return (*a->progress_cb)(a->progress_arg, GOT_STATUS_DELETE'D',
   staged_status, relpath);
4020}

4022const struct got_error *
4023got_worktree_schedule_delete(struct got_worktree *worktree,
  struct got_pathlist_head *paths, int delete_local_mods,
  const char *status_codes,
  got_worktree_delete_cb progress_cb, void *progress_arg,
  struct got_repository *repo, int keep_on_disk)
4028{
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
const struct got_error *err = NULL((void*)0), *sync_err, *unlockerr;
struct got_pathlist_entry *pe;
struct schedule_deletion_args sda;

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

sda.worktree = worktree;
sda.fileindex = fileindex;
sda.progress_cb = progress_cb;
sda.progress_arg = progress_arg;
sda.repo = repo;
sda.delete_local_mods = delete_local_mods;
sda.keep_on_disk = keep_on_disk;
sda.status_codes = status_codes;

TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
	schedule_for_deletion, &sda, NULL((void*)0), NULL((void*)0), 0, 1);
if (err)
	break;
}
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
4061done:
free(fileindex_path);
if (fileindex)
got_fileindex_free(fileindex);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
4069}

4071static const struct got_error *
4072copy_one_line(FILE *infile, FILE *outfile, FILE *rejectfile)
4073{
const struct got_error *err = NULL((void*)0);
char *line = NULL((void*)0);
size_t linesize = 0, n;
ssize_t linelen;

linelen = getline(&line, &linesize, infile);
if (linelen == -1) {
if (ferror(infile)(!__isthreaded ? (((infile)->_flags & 0x0040) != 0) : (
ferror)(infile))) {
	err = got_error_from_errno("getline");
	goto done;
}
return NULL((void*)0);
}
if (outfile) {
n = fwrite(line, 1, linelen, outfile);
if (n != linelen) {
	err = got_ferror(outfile, GOT_ERR_IO6);
	goto done;
}
}
if (rejectfile) {
n = fwrite(line, 1, linelen, rejectfile);
if (n != linelen)
	err = got_ferror(outfile, GOT_ERR_IO6);
}
4099done:
free(line);
return err;
4102}

4104static const struct got_error *
4105skip_one_line(FILE *f)
4106{
char *line = NULL((void*)0);
size_t linesize = 0;
ssize_t linelen;

linelen = getline(&line, &linesize, f);
if (linelen == -1) {
if (ferror(f)(!__isthreaded ? (((f)->_flags & 0x0040) != 0) : (ferror
)(f)))
	return got_error_from_errno("getline");
return NULL((void*)0);
}
free(line);
return NULL((void*)0);
4119}

4121static const struct got_error *
4122copy_change(FILE *f1, FILE *f2, int *line_cur1, int *line_cur2,
  int start_old, int end_old, int start_new, int end_new,
  FILE *outfile, FILE *rejectfile)
{
const struct got_error *err;

/* Copy old file's lines leading up to patch. */
while (!feof(f1)(!__isthreaded ? (((f1)->_flags & 0x0020) != 0) : (feof
)(f1)) && *line_cur1 < start_old) {
err = copy_one_line(f1, outfile, NULL((void*)0));
if (err)
	return err;
(*line_cur1)++;
}
/* Skip new file's lines leading up to patch. */
while (!feof(f2)(!__isthreaded ? (((f2)->_flags & 0x0020) != 0) : (feof
)(f2)) && *line_cur2 < start_new) {
if (rejectfile)
	err = copy_one_line(f2, NULL((void*)0), rejectfile);
else
	err = skip_one_line(f2);
if (err)
	return err;
(*line_cur2)++;
}
/* Copy patched lines. */
while (!feof(f2)(!__isthreaded ? (((f2)->_flags & 0x0020) != 0) : (feof
)(f2)) && *line_cur2 <= end_new) {
err = copy_one_line(f2, outfile, NULL((void*)0));
if (err)
	return err;
(*line_cur2)++;
}
/* Skip over old file's replaced lines. */
while (!feof(f1)(!__isthreaded ? (((f1)->_flags & 0x0020) != 0) : (feof
)(f1)) && *line_cur1 <= end_old) {
if (rejectfile)
	err = copy_one_line(f1, NULL((void*)0), rejectfile);
else
	err = skip_one_line(f1);
if (err)
	return err;
(*line_cur1)++;
}

return NULL((void*)0);
4164}

4166static const struct got_error *
4167copy_remaining_content(FILE *f1, FILE *f2, int *line_cur1, int *line_cur2,
  FILE *outfile, FILE *rejectfile)
4169{
const struct got_error *err;

if (outfile) {
/* Copy old file's lines until EOF. */
while (!feof(f1)(!__isthreaded ? (((f1)->_flags & 0x0020) != 0) : (feof
)(f1))) {
	err = copy_one_line(f1, outfile, NULL((void*)0));
	if (err)
		return err;
	(*line_cur1)++;
}
}
if (rejectfile) {
/* Copy new file's lines until EOF. */
while (!feof(f2)(!__isthreaded ? (((f2)->_flags & 0x0020) != 0) : (feof
)(f2))) {
	err = copy_one_line(f2, NULL((void*)0), rejectfile);
	if (err)
		return err;
	(*line_cur2)++;
}
}

return NULL((void*)0);
4192}

4194static const struct got_error *
4195apply_or_reject_change(int *choice, int *nchunks_used,
  struct diff_result *diff_result, int n,
  const char *relpath, FILE *f1, FILE *f2, int *line_cur1, int *line_cur2,
  FILE *outfile, FILE *rejectfile, int changeno, int nchanges,
  got_worktree_patch_cb patch_cb, void *patch_arg)
4200{
const struct got_error *err = NULL((void*)0);
struct diff_chunk_context cc = {}; 
int start_old, end_old, start_new, end_new;
FILE *hunkfile;
struct diff_output_unidiff_state *diff_state;
struct diff_input_info diff_info;
int rc;

*choice = GOT_PATCH_CHOICE_NONE0;

/* Get changed line numbers without context lines for copy_change(). */
diff_chunk_context_load_change(&cc, NULL((void*)0), diff_result, n, 0);
start_old = cc.left.start;
end_old = cc.left.end;
start_new = cc.right.start;
end_new = cc.right.end;

/* Get the same change with context lines for display. */
memset(&cc, 0, sizeof(cc));
diff_chunk_context_load_change(&cc, nchunks_used, diff_result, n, 3);

memset(&diff_info, 0, sizeof(diff_info));
diff_info.left_path = relpath;
diff_info.right_path = relpath;

diff_state = diff_output_unidiff_state_alloc();
if (diff_state == NULL((void*)0))
return got_error_set_errno(ENOMEM12,
    "diff_output_unidiff_state_alloc");

hunkfile = got_opentemp();
if (hunkfile == NULL((void*)0)) {
err = got_error_from_errno("got_opentemp");
goto done;
}

rc = diff_output_unidiff_chunk(NULL((void*)0), hunkfile, diff_state, &diff_info,
   diff_result, &cc);
if (rc != DIFF_RC_OK0) {
err = got_error_set_errno(rc, "diff_output_unidiff_chunk");
goto done;
}

if (fseek(hunkfile, 0L, SEEK_SET0) == -1) {
err = got_ferror(hunkfile, GOT_ERR_IO6);
goto done;
}

err = (*patch_cb)(choice, patch_arg, GOT_STATUS_MODIFY'M', relpath,
   hunkfile, changeno, nchanges);
if (err)
goto done;

switch (*choice) {
case GOT_PATCH_CHOICE_YES1:
err = copy_change(f1, f2, line_cur1, line_cur2, start_old,
    end_old, start_new, end_new, outfile, rejectfile);
break;
case GOT_PATCH_CHOICE_NO2:
err = copy_change(f1, f2, line_cur1, line_cur2, start_old,
    end_old, start_new, end_new, rejectfile, outfile);
break;
case GOT_PATCH_CHOICE_QUIT3:
break;
default:
err = got_error(GOT_ERR_PATCH_CHOICE107);
break;
}
4269done:
diff_output_unidiff_state_free(diff_state);
if (hunkfile && fclose(hunkfile) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno("fclose");
return err;
4274}

4276struct revert_file_args {
struct got_worktree *worktree;
struct got_fileindex *fileindex;
got_worktree_checkout_cb progress_cb;
void *progress_arg;
got_worktree_patch_cb patch_cb;
void *patch_arg;
struct got_repository *repo;
4284};

4286static const struct got_error *
4287create_patched_content(char **path_outfile, int reverse_patch,
  struct got_object_id *blob_id, const char *path2,
  int dirfd2, const char *de_name2,
  const char *relpath, struct got_repository *repo,
  got_worktree_patch_cb patch_cb, void *patch_arg)
4292{
const struct got_error *err, *free_err;
struct got_blob_object *blob = NULL((void*)0);
FILE *f1 = NULL((void*)0), *f2 = NULL((void*)0), *outfile = NULL((void*)0);
int fd2 = -1;
char link_target[PATH_MAX1024];
ssize_t link_len = 0;
char *path1 = NULL((void*)0), *id_str = NULL((void*)0);
struct stat sb2;
struct got_diffreg_result *diffreg_result = NULL((void*)0);
int line_cur1 = 1, line_cur2 = 1, have_content = 0;
int i = 0, n = 0, nchunks_used = 0, nchanges = 0;

*path_outfile = NULL((void*)0);

err = got_object_id_str(&id_str, blob_id);
if (err)
return err;

if (dirfd2 != -1) {
fd2 = openat(dirfd2, de_name2, O_RDONLY0x0000 | O_NOFOLLOW0x0100);
if (fd2 == -1) {
	if (errno(*__errno()) != ELOOP62) {
		err = got_error_from_errno2("openat", path2);
		goto done;
	}
	link_len = readlinkat(dirfd2, de_name2,
	    link_target, sizeof(link_target));
	if (link_len == -1)
		return got_error_from_errno2("readlinkat", path2);
	sb2.st_mode = S_IFLNK0120000;
	sb2.st_size = link_len;
}
} else {
fd2 = open(path2, O_RDONLY0x0000 | O_NOFOLLOW0x0100);
if (fd2 == -1) {
	if (errno(*__errno()) != ELOOP62) {
		err = got_error_from_errno2("open", path2);
		goto done;
	}
	link_len = readlink(path2, link_target,
	    sizeof(link_target));
	if (link_len == -1)
		return got_error_from_errno2("readlink", path2);
	sb2.st_mode = S_IFLNK0120000;
	sb2.st_size = link_len;
}
}
if (fd2 != -1) {
if (fstat(fd2, &sb2) == -1) {
	err = got_error_from_errno2("fstat", path2);
	goto done;
}

f2 = fdopen(fd2, "r");
if (f2 == NULL((void*)0)) {
	err = got_error_from_errno2("fdopen", path2);
	goto done;
}
fd2 = -1;
} else {
size_t n;
f2 = got_opentemp();
if (f2 == NULL((void*)0)) {
	err = got_error_from_errno2("got_opentemp", path2);
	goto done;
}
n = fwrite(link_target, 1, link_len, f2);
if (n != link_len) {
	err = got_ferror(f2, GOT_ERR_IO6);
	goto done;
}
if (fflush(f2) == EOF(-1)) {
	err = got_error_from_errno("fflush");
	goto done;
}
rewind(f2);
}

err = got_object_open_as_blob(&blob, repo, blob_id, 8192);
if (err)
goto done;

err = got_opentemp_named(&path1, &f1, "got-patched-blob");
if (err)
goto done;

err = got_object_blob_dump_to_file(NULL((void*)0), NULL((void*)0), NULL((void*)0), f1, blob);
if (err)
goto done;

err = got_diff_files(&diffreg_result, f1, id_str, f2, path2, 3, 0, 1,
   NULL((void*)0));
if (err)
goto done;

err = got_opentemp_named(path_outfile, &outfile, "got-patched-content");
if (err)
goto done;

if (fseek(f1, 0L, SEEK_SET0) == -1)
return got_ferror(f1, GOT_ERR_IO6);
if (fseek(f2, 0L, SEEK_SET0) == -1)
return got_ferror(f2, GOT_ERR_IO6);

/* Count the number of actual changes in the diff result. */
for (n = 0; n < diffreg_result->result->chunks.len; n += nchunks_used) {
struct diff_chunk_context cc = {}; 
diff_chunk_context_load_change(&cc, &nchunks_used,
    diffreg_result->result, n, 0);
nchanges++;
}
for (n = 0; n < diffreg_result->result->chunks.len; n += nchunks_used) {
int choice;
err = apply_or_reject_change(&choice, &nchunks_used,
    diffreg_result->result, n, relpath, f1, f2,
    &line_cur1, &line_cur2,
    reverse_patch ? NULL((void*)0) : outfile,
    reverse_patch ? outfile : NULL((void*)0),
    ++i, nchanges, patch_cb, patch_arg);
if (err)
	goto done;
if (choice == GOT_PATCH_CHOICE_YES1)
	have_content = 1;
else if (choice == GOT_PATCH_CHOICE_QUIT3)
	break;
}
if (have_content) {
err = copy_remaining_content(f1, f2, &line_cur1, &line_cur2,
    reverse_patch ? NULL((void*)0) : outfile,
    reverse_patch ? outfile : NULL((void*)0));
if (err)
	goto done;

if (!S_ISLNK(sb2.st_mode)((sb2.st_mode & 0170000) == 0120000)) {
	if (fchmod(fileno(outfile)(!__isthreaded ? ((outfile)->_file) : (fileno)(outfile)), sb2.st_mode) == -1) {
		err = got_error_from_errno2("fchmod", path2);
		goto done;
	}
}
}
4433done:
free(id_str);
if (blob)
got_object_blob_close(blob);
free_err = got_diffreg_result_free(diffreg_result);
if (err == NULL((void*)0))
err = free_err;
if (f1 && fclose(f1) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", path1);
if (f2 && fclose(f2) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", path2);
if (fd2 != -1 && close(fd2) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("close", path2);
if (outfile && fclose(outfile) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", *path_outfile);
if (path1 && unlink(path1) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("unlink", path1);
if (err || !have_content) {
if (*path_outfile && unlink(*path_outfile) == -1 && err == NULL((void*)0))
	err = got_error_from_errno2("unlink", *path_outfile);
free(*path_outfile);
*path_outfile = NULL((void*)0);
}
free(path1);
return err;
4458}

4460static const struct got_error *
4461revert_file(void *arg, unsigned char status, unsigned char staged_status,
  const char *relpath, struct got_object_id *blob_id,
  struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
  int dirfd, const char *de_name)
4465{
struct revert_file_args *a = arg;
const struct got_error *err = NULL((void*)0);
char *parent_path = NULL((void*)0);
struct got_fileindex_entry *ie;
struct got_tree_object *tree = NULL((void*)0);
struct got_object_id *tree_id = NULL((void*)0);
const struct got_tree_entry *te = NULL((void*)0);
char *tree_path = NULL((void*)0), *te_name;
char *ondisk_path = NULL((void*)0), *path_content = NULL((void*)0);
struct got_blob_object *blob = NULL((void*)0);

/* Reverting a staged deletion is a no-op. */
if (status == GOT_STATUS_DELETE'D' &&
   staged_status != GOT_STATUS_NO_CHANGE' ')
return NULL((void*)0);

if (status == GOT_STATUS_UNVERSIONED'?')
return (*a->progress_cb)(a->progress_arg,
    GOT_STATUS_UNVERSIONED'?', relpath);

ie = got_fileindex_entry_get(a->fileindex, relpath, strlen(relpath));
if (ie == NULL((void*)0))
return got_error_path(relpath, GOT_ERR_BAD_PATH4);

/* Construct in-repository path of tree which contains this blob. */
err = got_path_dirname(&parent_path, ie->path);
if (err) {
if (err->code != GOT_ERR_BAD_PATH4)
	goto done;
parent_path = strdup("/");
if (parent_path == NULL((void*)0)) {
	err = got_error_from_errno("strdup");
	goto done;
}
}
if (got_path_is_root_dir(a->worktree->path_prefix)) {
tree_path = strdup(parent_path);
if (tree_path == NULL((void*)0)) {
	err = got_error_from_errno("strdup");
	goto done;
}
} else {
if (got_path_is_root_dir(parent_path)) {
	tree_path = strdup(a->worktree->path_prefix);
	if (tree_path == NULL((void*)0)) {
		err = got_error_from_errno("strdup");
		goto done;
	}
} else {
	if (asprintf(&tree_path, "%s/%s",
	    a->worktree->path_prefix, parent_path) == -1) {
		err = got_error_from_errno("asprintf");
		goto done;
	}
}
}

err = got_object_id_by_path(&tree_id, a->repo,
   a->worktree->base_commit_id, tree_path);
if (err) {
if (!(err->code == GOT_ERR_NO_TREE_ENTRY50 &&
    (status == GOT_STATUS_ADD'A' ||
    staged_status == GOT_STATUS_ADD'A')))
	goto done;
} else {
err = got_object_open_as_tree(&tree, a->repo, tree_id);
if (err)
	goto done;

err = got_path_basename(&te_name, ie->path);
if (err)
	goto done;

te = got_object_tree_find_entry(tree, te_name);
free(te_name);
if (te == NULL((void*)0) && status != GOT_STATUS_ADD'A' &&
    staged_status != GOT_STATUS_ADD'A') {
	err = got_error_path(ie->path, GOT_ERR_NO_TREE_ENTRY50);
	goto done;
}
}

switch (status) {
case GOT_STATUS_ADD'A':
if (a->patch_cb) {
	int choice = GOT_PATCH_CHOICE_NONE0;
	err = (*a->patch_cb)(&choice, a->patch_arg,
	    status, ie->path, NULL((void*)0), 1, 1);
	if (err)
		goto done;
	if (choice != GOT_PATCH_CHOICE_YES1)
		break;
}
err = (*a->progress_cb)(a->progress_arg, GOT_STATUS_REVERT'R',
    ie->path);
if (err)
	goto done;
got_fileindex_entry_remove(a->fileindex, ie);
break;
case GOT_STATUS_DELETE'D':
if (a->patch_cb) {
	int choice = GOT_PATCH_CHOICE_NONE0;
	err = (*a->patch_cb)(&choice, a->patch_arg,
	    status, ie->path, NULL((void*)0), 1, 1);
	if (err)
		goto done;
	if (choice != GOT_PATCH_CHOICE_YES1)
		break;
}
/* fall through */
case GOT_STATUS_MODIFY'M':
case GOT_STATUS_MODE_CHANGE'm':
case GOT_STATUS_CONFLICT'C':
case GOT_STATUS_MISSING'!': {
struct got_object_id id;
if (staged_status == GOT_STATUS_ADD'A' ||
    staged_status == GOT_STATUS_MODIFY'M') {
	memcpy(id.sha1, ie->staged_blob_sha1,
	    SHA1_DIGEST_LENGTH20);
} else
	memcpy(id.sha1, ie->blob_sha1,
	    SHA1_DIGEST_LENGTH20);
err = got_object_open_as_blob(&blob, a->repo, &id, 8192);
if (err)
	goto done;

if (asprintf(&ondisk_path, "%s/%s",
    got_worktree_get_root_path(a->worktree), relpath) == -1) {
	err = got_error_from_errno("asprintf");
	goto done;
}

if (a->patch_cb && (status == GOT_STATUS_MODIFY'M' ||
    status == GOT_STATUS_CONFLICT'C')) {
	int is_bad_symlink = 0;
	err = create_patched_content(&path_content, 1, &id,
	    ondisk_path, dirfd, de_name, ie->path, a->repo,
	    a->patch_cb, a->patch_arg);
	if (err || path_content == NULL((void*)0))
		break;
	if (te && S_ISLNK(te->mode)((te->mode & 0170000) == 0120000)) {
		if (unlink(path_content) == -1) {
			err = got_error_from_errno2("unlink",
			    path_content);
			break;
		}
		err = install_symlink(&is_bad_symlink,
		    a->worktree, ondisk_path, ie->path,
		    blob, 0, 1, 0, a->repo,
		    a->progress_cb, a->progress_arg);
	} else {
		if (rename(path_content, ondisk_path) == -1) {
			err = got_error_from_errno3("rename",
			    path_content, ondisk_path);
			goto done;
		}
	}
} else {
	int is_bad_symlink = 0;
	if (te && S_ISLNK(te->mode)((te->mode & 0170000) == 0120000)) {
		err = install_symlink(&is_bad_symlink,
		    a->worktree, ondisk_path, ie->path,
		    blob, 0, 1, 0, a->repo,
		    a->progress_cb, a->progress_arg);
	} else {
		err = install_blob(a->worktree, ondisk_path,
		    ie->path,
		    te ? te->mode : GOT_DEFAULT_FILE_MODE(0100000 | 0000400|0000200 | 0000040 | 0000004),
		    got_fileindex_perms_to_st(ie), blob,
		    0, 1, 0, 0, a->repo,
		    a->progress_cb, a->progress_arg);
	}
	if (err)
		goto done;
	if (status == GOT_STATUS_DELETE'D' ||
	    status == GOT_STATUS_MODE_CHANGE'm') {
		err = got_fileindex_entry_update(ie,
		    a->worktree->root_fd, relpath,
		    blob->id.sha1,
		    a->worktree->base_commit_id->sha1, 1);
		if (err)
			goto done;
	}
	if (is_bad_symlink) {
		got_fileindex_entry_filetype_set(ie,
		    GOT_FILEIDX_MODE_BAD_SYMLINK3);
	}
}
break;
}
default:
break;
}
4659done:
free(ondisk_path);
free(path_content);
free(parent_path);
free(tree_path);
if (blob)
got_object_blob_close(blob);
if (tree)
got_object_tree_close(tree);
free(tree_id);
return err;
4670}

4672const struct got_error *
4673got_worktree_revert(struct got_worktree *worktree,
  struct got_pathlist_head *paths,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_worktree_patch_cb patch_cb, void *patch_arg,
  struct got_repository *repo)
4678{
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
const struct got_error *err = NULL((void*)0), *unlockerr = NULL((void*)0);
const struct got_error *sync_err = NULL((void*)0);
struct got_pathlist_entry *pe;
struct revert_file_args rfa;

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

rfa.worktree = worktree;
rfa.fileindex = fileindex;
rfa.progress_cb = progress_cb;
rfa.progress_arg = progress_arg;
rfa.patch_cb = patch_cb;
rfa.patch_arg = patch_arg;
rfa.repo = repo;
TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
    revert_file, &rfa, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
	break;
}
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
4710done:
free(fileindex_path);
if (fileindex)
got_fileindex_free(fileindex);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
4718}

4720static void
4721free_commitable(struct got_commitable *ct)
4722{
free(ct->path);
free(ct->in_repo_path);
free(ct->ondisk_path);
free(ct->blob_id);
free(ct->base_blob_id);
free(ct->staged_blob_id);
free(ct->base_commit_id);
free(ct);
4731}

4733struct collect_commitables_arg {
struct got_pathlist_head *commitable_paths;
struct got_repository *repo;
struct got_worktree *worktree;
struct got_fileindex *fileindex;
int have_staged_files;
int allow_bad_symlinks;
4740};

4742static const struct got_error *
4743collect_commitables(void *arg, unsigned char status,
  unsigned char staged_status, const char *relpath,
  struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
  struct got_object_id *commit_id, int dirfd, const char *de_name)
4747{
struct collect_commitables_arg *a = arg;
const struct got_error *err = NULL((void*)0);
struct got_commitable *ct = NULL((void*)0);
struct got_pathlist_entry *new = NULL((void*)0);
char *parent_path = NULL((void*)0), *path = NULL((void*)0);
struct stat sb;

if (a->have_staged_files) {
if (staged_status != GOT_STATUS_MODIFY'M' &&
    staged_status != GOT_STATUS_ADD'A' &&
    staged_status != GOT_STATUS_DELETE'D')
	return NULL((void*)0);
} else {
if (status == GOT_STATUS_CONFLICT'C')
	return got_error(GOT_ERR_COMMIT_CONFLICT69);

if (status != GOT_STATUS_MODIFY'M' &&
    status != GOT_STATUS_MODE_CHANGE'm' &&
    status != GOT_STATUS_ADD'A' &&
    status != GOT_STATUS_DELETE'D')
	return NULL((void*)0);
}

if (asprintf(&path, "/%s", relpath) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}
if (strcmp(path, "/") == 0) {
parent_path = strdup("");
if (parent_path == NULL((void*)0))
	return got_error_from_errno("strdup");
} else {
err = got_path_dirname(&parent_path, path);
if (err)
	return err;
}

ct = calloc(1, sizeof(*ct));
if (ct == NULL((void*)0)) {
err = got_error_from_errno("calloc");
goto done;
}

if (asprintf(&ct->ondisk_path, "%s/%s", a->worktree->root_path,
   relpath) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

if (staged_status == GOT_STATUS_ADD'A' ||
   staged_status == GOT_STATUS_MODIFY'M') {
struct got_fileindex_entry *ie;
ie = got_fileindex_entry_get(a->fileindex, path, strlen(path));
switch (got_fileindex_entry_staged_filetype_get(ie)) {
case GOT_FILEIDX_MODE_REGULAR_FILE1:
case GOT_FILEIDX_MODE_BAD_SYMLINK3:
	ct->mode = S_IFREG0100000;
	break;
case GOT_FILEIDX_MODE_SYMLINK2:
	ct->mode = S_IFLNK0120000;
	break;
default:
	err = got_error_path(path, GOT_ERR_BAD_FILETYPE3);
	goto done;
}
ct->mode |= got_fileindex_entry_perms_get(ie);
} else if (status != GOT_STATUS_DELETE'D' &&
   staged_status != GOT_STATUS_DELETE'D') {
if (dirfd != -1) {
	if (fstatat(dirfd, de_name, &sb,
	    AT_SYMLINK_NOFOLLOW0x02) == -1) {
		err = got_error_from_errno2("fstatat",
		    ct->ondisk_path);
		goto done;
	}
} else if (lstat(ct->ondisk_path, &sb) == -1) {
	err = got_error_from_errno2("lstat", ct->ondisk_path);
	goto done;
}
ct->mode = sb.st_mode;
}

if (asprintf(&ct->in_repo_path, "%s%s%s", a->worktree->path_prefix,
   got_path_is_root_dir(a->worktree->path_prefix) ? "" : "/",
   relpath) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

if (S_ISLNK(ct->mode)((ct->mode & 0170000) == 0120000) && staged_status == GOT_STATUS_NO_CHANGE' ' &&
   status == GOT_STATUS_ADD'A' && !a->allow_bad_symlinks) {
int is_bad_symlink;
char target_path[PATH_MAX1024];
ssize_t target_len;
target_len = readlink(ct->ondisk_path, target_path,
    sizeof(target_path));
if (target_len == -1) {
	err = got_error_from_errno2("readlink",
	    ct->ondisk_path);
	goto done;
}
err = is_bad_symlink_target(&is_bad_symlink, target_path,
    target_len, ct->ondisk_path, a->worktree->root_path);
if (err)
	goto done;
if (is_bad_symlink) {
	err = got_error_path(ct->ondisk_path,
	    GOT_ERR_BAD_SYMLINK129);
	goto done;
}
}


ct->status = status;
ct->staged_status = staged_status;
ct->blob_id = NULL((void*)0); /* will be filled in when blob gets created */
if (ct->status != GOT_STATUS_ADD'A' &&
   ct->staged_status != GOT_STATUS_ADD'A') {
ct->base_blob_id = got_object_id_dup(blob_id);
if (ct->base_blob_id == NULL((void*)0)) {
	err = got_error_from_errno("got_object_id_dup");
	goto done;
}
ct->base_commit_id = got_object_id_dup(commit_id);
if (ct->base_commit_id == NULL((void*)0)) {
	err = got_error_from_errno("got_object_id_dup");
	goto done;
}
}
if (ct->staged_status == GOT_STATUS_ADD'A' ||
   ct->staged_status == GOT_STATUS_MODIFY'M') {
ct->staged_blob_id = got_object_id_dup(staged_blob_id);
if (ct->staged_blob_id == NULL((void*)0)) {
	err = got_error_from_errno("got_object_id_dup");
	goto done;
}
}
ct->path = strdup(path);
if (ct->path == NULL((void*)0)) {
err = got_error_from_errno("strdup");
goto done;
}
err = got_pathlist_insert(&new, a->commitable_paths, ct->path, ct);
4891done:
if (ct && (err || new == NULL((void*)0)))
free_commitable(ct);
free(parent_path);
free(path);
return err;
4897}

4899static const struct got_error *write_tree(struct got_object_id **, int *,
  struct got_tree_object *, const char *, struct got_pathlist_head *,
  got_worktree_status_cb status_cb, void *status_arg,
  struct got_repository *);

4904static const struct got_error *
4905write_subtree(struct got_object_id **new_subtree_id, int *nentries,
  struct got_tree_entry *te, const char *parent_path,
  struct got_pathlist_head *commitable_paths,
  got_worktree_status_cb status_cb, void *status_arg,
  struct got_repository *repo)
4910{
const struct got_error *err = NULL((void*)0);
struct got_tree_object *subtree;
char *subpath;

if (asprintf(&subpath, "%s%s%s", parent_path,
   got_path_is_root_dir(parent_path) ? "" : "/", te->name) == -1)
return got_error_from_errno("asprintf");

err = got_object_open_as_tree(&subtree, repo, &te->id);
if (err)
return err;

err = write_tree(new_subtree_id, nentries, subtree, subpath,
   commitable_paths, status_cb, status_arg, repo);
got_object_tree_close(subtree);
free(subpath);
return err;
4928}

4930static const struct got_error *
4931match_ct_parent_path(int *match, struct got_commitable *ct, const char *path)
4932{
const struct got_error *err = NULL((void*)0);
char *ct_parent_path = NULL((void*)0);

*match = 0;

if (strchr(ct->in_repo_path, '/') == NULL((void*)0)) {
*match = got_path_is_root_dir(path);
return NULL((void*)0);
}

err = got_path_dirname(&ct_parent_path, ct->in_repo_path);
if (err)
return err;
*match = (strcmp(path, ct_parent_path) == 0);
free(ct_parent_path);
return err;
4949}

4951static mode_t
4952get_ct_file_mode(struct got_commitable *ct)
4953{
if (S_ISLNK(ct->mode)((ct->mode & 0170000) == 0120000))
return S_IFLNK0120000;

return S_IFREG0100000 | (ct->mode & ((S_IRWXU0000700 | S_IRWXG0000070 | S_IRWXO0000007)));
4958}

4960static const struct got_error *
4961alloc_modified_blob_tree_entry(struct got_tree_entry **new_te,
  struct got_tree_entry *te, struct got_commitable *ct)
4963{
const struct got_error *err = NULL((void*)0);

*new_te = NULL((void*)0);

err = got_object_tree_entry_dup(new_te, te);
if (err)
goto done;

(*new_te)->mode = get_ct_file_mode(ct);

if (ct->staged_status == GOT_STATUS_MODIFY'M')
memcpy(&(*new_te)->id, ct->staged_blob_id,
    sizeof((*new_te)->id));
else
memcpy(&(*new_te)->id, ct->blob_id, sizeof((*new_te)->id));
4979done:
if (err && *new_te) {
free(*new_te);
*new_te = NULL((void*)0);
}
return err;
4985}

4987static const struct got_error *
4988alloc_added_blob_tree_entry(struct got_tree_entry **new_te,
  struct got_commitable *ct)
4990{
const struct got_error *err = NULL((void*)0);
char *ct_name = NULL((void*)0);

*new_te = NULL((void*)0);

*new_te = calloc(1, sizeof(**new_te));
if (*new_te == NULL((void*)0))
return got_error_from_errno("calloc");

err = got_path_basename(&ct_name, ct->path);
if (err)
goto done;
if (strlcpy((*new_te)->name, ct_name, sizeof((*new_te)->name)) >=
   sizeof((*new_te)->name)) {
err = got_error(GOT_ERR_NO_SPACE9);
goto done;
}

(*new_te)->mode = get_ct_file_mode(ct);

if (ct->staged_status == GOT_STATUS_ADD'A')
memcpy(&(*new_te)->id, ct->staged_blob_id,
    sizeof((*new_te)->id));
else
memcpy(&(*new_te)->id, ct->blob_id, sizeof((*new_te)->id));
5016done:
free(ct_name);
if (err && *new_te) {
free(*new_te);
*new_te = NULL((void*)0);
}
return err;
5023}

5025static const struct got_error *
5026insert_tree_entry(struct got_tree_entry *new_te,
  struct got_pathlist_head *paths)
5028{
const struct got_error *err = NULL((void*)0);
struct got_pathlist_entry *new_pe;

err = got_pathlist_insert(&new_pe, paths, new_te->name, new_te);
if (err)
return err;
if (new_pe == NULL((void*)0))
return got_error(GOT_ERR_TREE_DUP_ENTRY58);
return NULL((void*)0);
5038}

5040static const struct got_error *
5041report_ct_status(struct got_commitable *ct,
  got_worktree_status_cb status_cb, void *status_arg)
5043{
const char *ct_path = ct->path;
unsigned char status;

while (ct_path[0] == '/')
ct_path++;

if (ct->staged_status != GOT_STATUS_NO_CHANGE' ')
status = ct->staged_status;
else
status = ct->status;

return (*status_cb)(status_arg, status, GOT_STATUS_NO_CHANGE' ',
   ct_path, ct->blob_id, NULL((void*)0), NULL((void*)0), -1, NULL((void*)0));
5057}

5059static const struct got_error *
5060match_modified_subtree(int *modified, struct got_tree_entry *te,
  const char *base_tree_path, struct got_pathlist_head *commitable_paths)
5062{
const struct got_error *err = NULL((void*)0);
struct got_pathlist_entry *pe;
char *te_path;

*modified = 0;

if (asprintf(&te_path, "%s%s%s", base_tree_path,
   got_path_is_root_dir(base_tree_path) ? "" : "/",
   te->name) == -1)
return got_error_from_errno("asprintf");

TAILQ_FOREACH(pe, commitable_paths, entry)for((pe) = ((commitable_paths)->tqh_first); (pe) != ((void
*)0); (pe) = ((pe)->entry.tqe_next)) {
struct got_commitable *ct = pe->data;
*modified = got_path_is_child(ct->in_repo_path, te_path,
    strlen(te_path));
if (*modified)
	break;
}

free(te_path);
return err;
5084}

5086static const struct got_error *
5087match_deleted_or_modified_ct(struct got_commitable **ctp,
  struct got_tree_entry *te, const char *base_tree_path,
  struct got_pathlist_head *commitable_paths)
5090{
const struct got_error *err = NULL((void*)0);
struct got_pathlist_entry *pe;

*ctp = NULL((void*)0);

TAILQ_FOREACH(pe, commitable_paths, entry)for((pe) = ((commitable_paths)->tqh_first); (pe) != ((void
*)0); (pe) = ((pe)->entry.tqe_next)) {
struct got_commitable *ct = pe->data;
char *ct_name = NULL((void*)0);
int path_matches;

if (ct->staged_status == GOT_STATUS_NO_CHANGE' ') {
	if (ct->status != GOT_STATUS_MODIFY'M' &&
	    ct->status != GOT_STATUS_MODE_CHANGE'm' &&
	    ct->status != GOT_STATUS_DELETE'D')
		continue;
} else {
	if (ct->staged_status != GOT_STATUS_MODIFY'M' &&
	    ct->staged_status != GOT_STATUS_DELETE'D')
		continue;
}

if (got_object_id_cmp(ct->base_blob_id, &te->id) != 0)
	continue;

err = match_ct_parent_path(&path_matches, ct, base_tree_path);
if (err)
	return err;
if (!path_matches)
	continue;

err = got_path_basename(&ct_name, pe->path);
if (err)
	return err;

if (strcmp(te->name, ct_name) != 0) {
	free(ct_name);
	continue;
}
free(ct_name);

*ctp = ct;
break;
}

return err;
5136}

5138static const struct got_error *
5139make_subtree_for_added_blob(struct got_tree_entry **new_tep,
  const char *child_path, const char *path_base_tree,
  struct got_pathlist_head *commitable_paths,
  got_worktree_status_cb status_cb, void *status_arg,
  struct got_repository *repo)
5144{
const struct got_error *err = NULL((void*)0);
struct got_tree_entry *new_te;
char *subtree_path;
struct got_object_id *id = NULL((void*)0);
int nentries;

*new_tep = NULL((void*)0);

if (asprintf(&subtree_path, "%s%s%s", path_base_tree,
   got_path_is_root_dir(path_base_tree) ? "" : "/",
   child_path) == -1)
return got_error_from_errno("asprintf");

new_te = calloc(1, sizeof(*new_te));
if (new_te == NULL((void*)0))
return got_error_from_errno("calloc");
new_te->mode = S_IFDIR0040000;

if (strlcpy(new_te->name, child_path, sizeof(new_te->name)) >=
   sizeof(new_te->name)) {
err = got_error(GOT_ERR_NO_SPACE9);
goto done;
}
err = write_tree(&id, &nentries, NULL((void*)0), subtree_path,
   commitable_paths, status_cb, status_arg, repo);
if (err) {
free(new_te);
goto done;
}
memcpy(&new_te->id, id, sizeof(new_te->id));
5175done:
free(id);
free(subtree_path);
if (err == NULL((void*)0))
*new_tep = new_te;
return err;
5181}

5183static const struct got_error *
5184write_tree(struct got_object_id **new_tree_id, int *nentries,
  struct got_tree_object *base_tree, const char *path_base_tree,
  struct got_pathlist_head *commitable_paths,
  got_worktree_status_cb status_cb, void *status_arg,
  struct got_repository *repo)
5189{
const struct got_error *err = NULL((void*)0);
struct got_pathlist_head paths;
struct got_tree_entry *te, *new_te = NULL((void*)0);
struct got_pathlist_entry *pe;

TAILQ_INIT(&paths)do { (&paths)->tqh_first = ((void*)0); (&paths)->
tqh_last = &(&paths)->tqh_first; } while (0);
*nentries = 0;

/* Insert, and recurse into, newly added entries first. */
TAILQ_FOREACH(pe, commitable_paths, entry)for((pe) = ((commitable_paths)->tqh_first); (pe) != ((void
*)0); (pe) = ((pe)->entry.tqe_next)) {
struct got_commitable *ct = pe->data;
char *child_path = NULL((void*)0), *slash;

if ((ct->status != GOT_STATUS_ADD'A' &&
    ct->staged_status != GOT_STATUS_ADD'A') ||
    (ct->flags & GOT_COMMITABLE_ADDED0x01))
	continue;

if (!got_path_is_child(ct->in_repo_path, path_base_tree,
    strlen(path_base_tree)))
	continue;

err = got_path_skip_common_ancestor(&child_path, path_base_tree,
    ct->in_repo_path);
if (err)
	goto done;

slash = strchr(child_path, '/');
if (slash == NULL((void*)0)) {
	err = alloc_added_blob_tree_entry(&new_te, ct);
	if (err)
		goto done;
	err = report_ct_status(ct, status_cb, status_arg);
	if (err)
		goto done;
	ct->flags |= GOT_COMMITABLE_ADDED0x01;
	err = insert_tree_entry(new_te, &paths);
	if (err)
		goto done;
	(*nentries)++;
} else {
	*slash = '\0'; /* trim trailing path components */
	if (base_tree == NULL((void*)0) ||
	    got_object_tree_find_entry(base_tree, child_path)
	    == NULL((void*)0)) {
		err = make_subtree_for_added_blob(&new_te,
		    child_path, path_base_tree,
		    commitable_paths, status_cb, status_arg,
		    repo);
		if (err)
			goto done;
		err = insert_tree_entry(new_te, &paths);
		if (err)
			goto done;
		(*nentries)++;
	}
}
}

if (base_tree) {
int i, nbase_entries;
/* Handle modified and deleted entries. */
nbase_entries = got_object_tree_get_nentries(base_tree);
for (i = 0; i < nbase_entries; i++) {
	struct got_commitable *ct = NULL((void*)0);

	te = got_object_tree_get_entry(base_tree, i);
	if (got_object_tree_entry_is_submodule(te)) {
		/* Entry is a submodule; just copy it. */
		err = got_object_tree_entry_dup(&new_te, te);
		if (err)
			goto done;
		err = insert_tree_entry(new_te, &paths);
		if (err)
			goto done;
		(*nentries)++;
		continue;
	}

	if (S_ISDIR(te->mode)((te->mode & 0170000) == 0040000)) {
		int modified;
		err = got_object_tree_entry_dup(&new_te, te);
		if (err)
			goto done;
		err = match_modified_subtree(&modified, te,
		    path_base_tree, commitable_paths);
		if (err)
			goto done;
		/* Avoid recursion into unmodified subtrees. */
		if (modified) {
			struct got_object_id *new_id;
			int nsubentries;
			err = write_subtree(&new_id,
			    &nsubentries, te,
			    path_base_tree, commitable_paths,
			    status_cb, status_arg, repo);
			if (err)
				goto done;
			if (nsubentries == 0) {
				/* All entries were deleted. */
				free(new_id);
				continue;
			}
			memcpy(&new_te->id, new_id,
			    sizeof(new_te->id));
			free(new_id);
		}
		err = insert_tree_entry(new_te, &paths);
		if (err)
			goto done;
		(*nentries)++;
		continue;
	}

	err = match_deleted_or_modified_ct(&ct, te,
	    path_base_tree, commitable_paths);
	if (err)
		goto done;
	if (ct) {
		/* NB: Deleted entries get dropped here. */
		if (ct->status == GOT_STATUS_MODIFY'M' ||
		    ct->status == GOT_STATUS_MODE_CHANGE'm' ||
		    ct->staged_status == GOT_STATUS_MODIFY'M') {
			err = alloc_modified_blob_tree_entry(
			    &new_te, te, ct);
			if (err)
				goto done;
			err = insert_tree_entry(new_te, &paths);
			if (err)
				goto done;
			(*nentries)++;
		}
		err = report_ct_status(ct, status_cb,
		    status_arg);
		if (err)
			goto done;
	} else {
		/* Entry is unchanged; just copy it. */
		err = got_object_tree_entry_dup(&new_te, te);
		if (err)
			goto done;
		err = insert_tree_entry(new_te, &paths);
		if (err)
			goto done;
		(*nentries)++;
	}
}
}

/* Write new list of entries; deleted entries have been dropped. */
err = got_object_tree_create(new_tree_id, &paths, *nentries, repo);
5341done:
got_pathlist_free(&paths);
return err;
5344}

5346static const struct got_error *
5347update_fileindex_after_commit(struct got_worktree *worktree,
  struct got_pathlist_head *commitable_paths,
  struct got_object_id *new_base_commit_id,
  struct got_fileindex *fileindex, int have_staged_files)
5351{
const struct got_error *err = NULL((void*)0);
struct got_pathlist_entry *pe;
char *relpath = NULL((void*)0);

TAILQ_FOREACH(pe, commitable_paths, entry)for((pe) = ((commitable_paths)->tqh_first); (pe) != ((void
*)0); (pe) = ((pe)->entry.tqe_next)) {
struct got_fileindex_entry *ie;
struct got_commitable *ct = pe->data;

ie = got_fileindex_entry_get(fileindex, pe->path, pe->path_len);

err = got_path_skip_common_ancestor(&relpath,
    worktree->root_path, ct->ondisk_path);
if (err)
	goto done;

if (ie) {
	if (ct->status == GOT_STATUS_DELETE'D' ||
	    ct->staged_status == GOT_STATUS_DELETE'D') {
		got_fileindex_entry_remove(fileindex, ie);
	} else if (ct->staged_status == GOT_STATUS_ADD'A' ||
	    ct->staged_status == GOT_STATUS_MODIFY'M') {
		got_fileindex_entry_stage_set(ie,
		    GOT_FILEIDX_STAGE_NONE0);
		got_fileindex_entry_staged_filetype_set(ie, 0);

		err = got_fileindex_entry_update(ie,
		    worktree->root_fd, relpath,
		    ct->staged_blob_id->sha1,
		    new_base_commit_id->sha1,
		    !have_staged_files);
	} else
		err = got_fileindex_entry_update(ie,
		    worktree->root_fd, relpath,
		    ct->blob_id->sha1,
		    new_base_commit_id->sha1,
		    !have_staged_files);
} else {
	err = got_fileindex_entry_alloc(&ie, pe->path);
	if (err)
		goto done;
	err = got_fileindex_entry_update(ie,
	    worktree->root_fd, relpath, ct->blob_id->sha1,
	    new_base_commit_id->sha1, 1);
	if (err) {
		got_fileindex_entry_free(ie);
		goto done;
	}
	err = got_fileindex_entry_add(fileindex, ie);
	if (err) {
		got_fileindex_entry_free(ie);
		goto done;
	}
}
free(relpath);
relpath = NULL((void*)0);
}
5408done:
free(relpath);
return err;
5411}


5414static const struct got_error *
5415check_out_of_date(const char *in_repo_path, unsigned char status,
  unsigned char staged_status, struct got_object_id *base_blob_id,
  struct got_object_id *base_commit_id,
  struct got_object_id *head_commit_id, struct got_repository *repo,
  int ood_errcode)
5420{
const struct got_error *err = NULL((void*)0);
struct got_object_id *id = NULL((void*)0);

if (status != GOT_STATUS_ADD'A' && staged_status != GOT_STATUS_ADD'A') {
/* Trivial case: base commit == head commit */
if (got_object_id_cmp(base_commit_id, head_commit_id) == 0)
	return NULL((void*)0);
/*
 * Ensure file content which local changes were based
 * on matches file content in the branch head.
 */
err = got_object_id_by_path(&id, repo, head_commit_id,
    in_repo_path);
if (err) {
	if (err->code == GOT_ERR_NO_TREE_ENTRY50)
		err = got_error(ood_errcode);
	goto done;
} else if (got_object_id_cmp(id, base_blob_id) != 0)
	err = got_error(ood_errcode);
} else {
/* Require that added files don't exist in the branch head. */
err = got_object_id_by_path(&id, repo, head_commit_id,
    in_repo_path);
if (err && err->code != GOT_ERR_NO_TREE_ENTRY50)
	goto done;
err = id ? got_error(ood_errcode) : NULL((void*)0);
}
5448done:
free(id);
return err;
5451}

5453const struct got_error *
5454commit_worktree(struct got_object_id **new_commit_id,
  struct got_pathlist_head *commitable_paths,
  struct got_object_id *head_commit_id, struct got_worktree *worktree,
  const char *author, const char *committer,
  got_worktree_commit_msg_cb commit_msg_cb, void *commit_arg,
  got_worktree_status_cb status_cb, void *status_arg,
  struct got_repository *repo)
5461{
const struct got_error *err = NULL((void*)0), *unlockerr = NULL((void*)0);
struct got_pathlist_entry *pe;
const char *head_ref_name = NULL((void*)0);
struct got_commit_object *head_commit = NULL((void*)0);
struct got_reference *head_ref2 = NULL((void*)0);
struct got_object_id *head_commit_id2 = NULL((void*)0);
struct got_tree_object *head_tree = NULL((void*)0);
struct got_object_id *new_tree_id = NULL((void*)0);
int nentries;
struct got_object_id_queue parent_ids;
struct got_object_qid *pid = NULL((void*)0);
char *logmsg = NULL((void*)0);

*new_commit_id = NULL((void*)0);

SIMPLEQ_INIT(&parent_ids)do { (&parent_ids)->sqh_first = ((void*)0); (&parent_ids
)->sqh_last = &(&parent_ids)->sqh_first; } while
 (0);

err = got_object_open_as_commit(&head_commit, repo, head_commit_id);
if (err)
goto done;

err = got_object_open_as_tree(&head_tree, repo, head_commit->tree_id);
if (err)
goto done;

if (commit_msg_cb != NULL((void*)0)) {
err = commit_msg_cb(commitable_paths, &logmsg, commit_arg);
if (err)
	goto done;
}

if (logmsg == NULL((void*)0) || strlen(logmsg) == 0) {
err = got_error(GOT_ERR_COMMIT_MSG_EMPTY74);
goto done;
}

/* Create blobs from added and modified files and record their IDs. */
TAILQ_FOREACH(pe, commitable_paths, entry)for((pe) = ((commitable_paths)->tqh_first); (pe) != ((void
*)0); (pe) = ((pe)->entry.tqe_next)) {
struct got_commitable *ct = pe->data;
char *ondisk_path;

/* Blobs for staged files already exist. */
if (ct->staged_status == GOT_STATUS_ADD'A' ||
    ct->staged_status == GOT_STATUS_MODIFY'M')
	continue;

if (ct->status != GOT_STATUS_ADD'A' &&
    ct->status != GOT_STATUS_MODIFY'M' &&
    ct->status != GOT_STATUS_MODE_CHANGE'm')
	continue;

if (asprintf(&ondisk_path, "%s/%s",
    worktree->root_path, pe->path) == -1) {
	err = got_error_from_errno("asprintf");
	goto done;
}
err = got_object_blob_create(&ct->blob_id, ondisk_path, repo);
free(ondisk_path);
if (err)
	goto done;
}

/* Recursively write new tree objects. */
err = write_tree(&new_tree_id, &nentries, head_tree, "/",
   commitable_paths, status_cb, status_arg, repo);
if (err)
goto done;

err = got_object_qid_alloc(&pid, worktree->base_commit_id);
if (err)
goto done;
SIMPLEQ_INSERT_TAIL(&parent_ids, pid, entry)do { (pid)->entry.sqe_next = ((void*)0); *(&parent_ids
)->sqh_last = (pid); (&parent_ids)->sqh_last = &
(pid)->entry.sqe_next; } while (0);
err = got_object_commit_create(new_commit_id, new_tree_id, &parent_ids,
   1, author, time(NULL((void*)0)), committer, time(NULL((void*)0)), logmsg, repo);
got_object_qid_free(pid);
if (logmsg != NULL((void*)0))
free(logmsg);
if (err)
goto done;

/* Check if a concurrent commit to our branch has occurred. */
head_ref_name = got_worktree_get_head_ref_name(worktree);
if (head_ref_name == NULL((void*)0)) {
err = got_error_from_errno("got_worktree_get_head_ref_name");
goto done;
}
/* Lock the reference here to prevent concurrent modification. */
err = got_ref_open(&head_ref2, repo, head_ref_name, 1);
if (err)
goto done;
err = got_ref_resolve(&head_commit_id2, repo, head_ref2);
if (err)
goto done;
if (got_object_id_cmp(head_commit_id, head_commit_id2) != 0) {
err = got_error(GOT_ERR_COMMIT_HEAD_CHANGED72);
goto done;
}
/* Update branch head in repository. */
err = got_ref_change_ref(head_ref2, *new_commit_id);
if (err)
goto done;
err = got_ref_write(head_ref2, repo);
if (err)
goto done;

err = got_worktree_set_base_commit_id(worktree, repo, *new_commit_id);
if (err)
goto done;

err = ref_base_commit(worktree, repo);
if (err)
goto done;
5574done:
if (head_tree)
got_object_tree_close(head_tree);
if (head_commit)
got_object_commit_close(head_commit);
free(head_commit_id2);
if (head_ref2) {
unlockerr = got_ref_unlock(head_ref2);
if (unlockerr && err == NULL((void*)0))
	err = unlockerr;
got_ref_close(head_ref2);
}
return err;
5587}

5589static const struct got_error *
5590check_path_is_commitable(const char *path,
  struct got_pathlist_head *commitable_paths)
5592{
struct got_pathlist_entry *cpe = NULL((void*)0);
size_t path_len = strlen(path);

TAILQ_FOREACH(cpe, commitable_paths, entry)for((cpe) = ((commitable_paths)->tqh_first); (cpe) != ((void
*)0); (cpe) = ((cpe)->entry.tqe_next)) {
struct got_commitable *ct = cpe->data;
const char *ct_path = ct->path;

while (ct_path[0] == '/')
	ct_path++;

if (strcmp(path, ct_path) == 0 ||
    got_path_is_child(ct_path, path, path_len))
	break;
}

if (cpe == NULL((void*)0))
return got_error_path(path, GOT_ERR_BAD_PATH4);

return NULL((void*)0);
5612}

5614static const struct got_error *
5615check_staged_file(void *arg, struct got_fileindex_entry *ie)
5616{
int *have_staged_files = arg;

if (got_fileindex_entry_stage_get(ie) != GOT_FILEIDX_STAGE_NONE0) {
*have_staged_files = 1;
return got_error(GOT_ERR_CANCELLED49);
}

return NULL((void*)0);
5625}

5627static const struct got_error *
5628check_non_staged_files(struct got_fileindex *fileindex,
  struct got_pathlist_head *paths)
5630{
struct got_pathlist_entry *pe;
struct got_fileindex_entry *ie;

TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
if (pe->path[0] == '\0')
	continue;
ie = got_fileindex_entry_get(fileindex, pe->path, pe->path_len);
if (ie == NULL((void*)0))
	return got_error_path(pe->path, GOT_ERR_BAD_PATH4);
if (got_fileindex_entry_stage_get(ie) == GOT_FILEIDX_STAGE_NONE0)
	return got_error_path(pe->path,
	    GOT_ERR_FILE_NOT_STAGED105);
}

return NULL((void*)0);
5646}

5648const struct got_error *
5649got_worktree_commit(struct got_object_id **new_commit_id,
  struct got_worktree *worktree, struct got_pathlist_head *paths,
  const char *author, const char *committer, int allow_bad_symlinks,
  got_worktree_commit_msg_cb commit_msg_cb, void *commit_arg,
  got_worktree_status_cb status_cb, void *status_arg,
  struct got_repository *repo)
5655{
const struct got_error *err = NULL((void*)0), *unlockerr = NULL((void*)0), *sync_err;
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct got_pathlist_head commitable_paths;
struct collect_commitables_arg cc_arg;
struct got_pathlist_entry *pe;
struct got_reference *head_ref = NULL((void*)0);
struct got_object_id *head_commit_id = NULL((void*)0);
int have_staged_files = 0;

*new_commit_id = NULL((void*)0);

TAILQ_INIT(&commitable_paths)do { (&commitable_paths)->tqh_first = ((void*)0); (&
commitable_paths)->tqh_last = &(&commitable_paths)
->tqh_first; } while (0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
goto done;

err = got_ref_open(&head_ref, repo, worktree->head_ref_name, 0);
if (err)
goto done;

err = got_ref_resolve(&head_commit_id, repo, head_ref);
if (err)
goto done;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

err = got_fileindex_for_each_entry_safe(fileindex, check_staged_file,
   &have_staged_files);
if (err && err->code != GOT_ERR_CANCELLED49)
goto done;
if (have_staged_files) {
err = check_non_staged_files(fileindex, paths);
if (err)
	goto done;
}

cc_arg.commitable_paths = &commitable_paths;
cc_arg.worktree = worktree;
cc_arg.fileindex = fileindex;
cc_arg.repo = repo;
cc_arg.have_staged_files = have_staged_files;
cc_arg.allow_bad_symlinks = allow_bad_symlinks;
TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
    collect_commitables, &cc_arg, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
	goto done;
}

if (TAILQ_EMPTY(&commitable_paths)(((&commitable_paths)->tqh_first) == ((void*)0))) {
err = got_error(GOT_ERR_COMMIT_NO_CHANGES76);
goto done;
}

TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = check_path_is_commitable(pe->path, &commitable_paths);
if (err)
	goto done;
}

TAILQ_FOREACH(pe, &commitable_paths, entry)for((pe) = ((&commitable_paths)->tqh_first); (pe) != (
(void*)0); (pe) = ((pe)->entry.tqe_next)) {
struct got_commitable *ct = pe->data;
const char *ct_path = ct->in_repo_path;

while (ct_path[0] == '/')
	ct_path++;
err = check_out_of_date(ct_path, ct->status,
    ct->staged_status, ct->base_blob_id, ct->base_commit_id,
    head_commit_id, repo, GOT_ERR_COMMIT_OUT_OF_DATE73);
if (err)
	goto done;

}

err = commit_worktree(new_commit_id, &commitable_paths,
   head_commit_id, worktree, author, committer,
   commit_msg_cb, commit_arg, status_cb, status_arg, repo);
if (err)
goto done;

err = update_fileindex_after_commit(worktree, &commitable_paths,
   *new_commit_id, fileindex, have_staged_files);
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
5745done:
if (fileindex)
got_fileindex_free(fileindex);
free(fileindex_path);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
TAILQ_FOREACH(pe, &commitable_paths, entry)for((pe) = ((&commitable_paths)->tqh_first); (pe) != (
(void*)0); (pe) = ((pe)->entry.tqe_next)) {
struct got_commitable *ct = pe->data;
free_commitable(ct);
}
got_pathlist_free(&commitable_paths);
return err;
5758}

5760const char *
5761got_commitable_get_path(struct got_commitable *ct)
5762{
return ct->path;
5764}

5766unsigned int
5767got_commitable_get_status(struct got_commitable *ct)
5768{
return ct->status;
5770}

5772struct check_rebase_ok_arg {
struct got_worktree *worktree;
struct got_repository *repo;
5775};

5777static const struct got_error *
5778check_rebase_ok(void *arg, struct got_fileindex_entry *ie)
5779{
const struct got_error *err = NULL((void*)0);
struct check_rebase_ok_arg *a = arg;
unsigned char status;
struct stat sb;
char *ondisk_path;

/* Reject rebase of a work tree with mixed base commits. */
if (memcmp(ie->commit_sha1, a->worktree->base_commit_id->sha1,
   SHA1_DIGEST_LENGTH20))
return got_error(GOT_ERR_MIXED_COMMITS81);

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path, ie->path)
   == -1)
return got_error_from_errno("asprintf");

/* Reject rebase of a work tree with modified or staged files. */
err = get_file_status(&status, &sb, ie, ondisk_path, -1, NULL((void*)0), a->repo);
free(ondisk_path);
if (err)
return err;

if (status != GOT_STATUS_NO_CHANGE' ')
return got_error(GOT_ERR_MODIFIED84);
if (get_staged_status(ie) != GOT_STATUS_NO_CHANGE' ')
return got_error_path(ie->path, GOT_ERR_FILE_STAGED101);

return NULL((void*)0);
5807}

5809const struct got_error *
5810got_worktree_rebase_prepare(struct got_reference **new_base_branch_ref,
  struct got_reference **tmp_branch, struct got_fileindex **fileindex,
  struct got_worktree *worktree, struct got_reference *branch,
  struct got_repository *repo)
5814{
const struct got_error *err = NULL((void*)0);
char *tmp_branch_name = NULL((void*)0), *new_base_branch_ref_name = NULL((void*)0);
char *branch_ref_name = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct check_rebase_ok_arg ok_arg;
struct got_reference *wt_branch = NULL((void*)0), *branch_ref = NULL((void*)0);
struct got_object_id *wt_branch_tip = NULL((void*)0);

*new_base_branch_ref = NULL((void*)0);
*tmp_branch = NULL((void*)0);
*fileindex = NULL((void*)0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(fileindex, &fileindex_path, worktree);
if (err)
goto done;

ok_arg.worktree = worktree;
ok_arg.repo = repo;
err = got_fileindex_for_each_entry_safe(*fileindex, check_rebase_ok,
   &ok_arg);
if (err)
goto done;

err = get_rebase_tmp_ref_name(&tmp_branch_name, worktree);
if (err)
goto done;

err = get_newbase_symref_name(&new_base_branch_ref_name, worktree);
if (err)
goto done;

err = get_rebase_branch_symref_name(&branch_ref_name, worktree);
if (err)
goto done;

err = got_ref_open(&wt_branch, repo, worktree->head_ref_name,
   0);
if (err)
goto done;

err = got_ref_resolve(&wt_branch_tip, repo, wt_branch);
if (err)
goto done;
if (got_object_id_cmp(worktree->base_commit_id, wt_branch_tip) != 0) {
err = got_error(GOT_ERR_REBASE_OUT_OF_DATE115);
goto done;
}

err = got_ref_alloc_symref(new_base_branch_ref,
   new_base_branch_ref_name, wt_branch);
if (err)
goto done;
err = got_ref_write(*new_base_branch_ref, repo);
if (err)
goto done;

/* TODO Lock original branch's ref while rebasing? */

err = got_ref_alloc_symref(&branch_ref, branch_ref_name, branch);
if (err)
goto done;

err = got_ref_write(branch_ref, repo);
if (err)
goto done;

err = got_ref_alloc(tmp_branch, tmp_branch_name,
   worktree->base_commit_id);
if (err)
goto done;
err = got_ref_write(*tmp_branch, repo);
if (err)
goto done;

err = got_worktree_set_head_ref(worktree, *tmp_branch);
if (err)
goto done;
5896done:
free(fileindex_path);
free(tmp_branch_name);
free(new_base_branch_ref_name);
free(branch_ref_name);
if (branch_ref)
got_ref_close(branch_ref);
if (wt_branch)
got_ref_close(wt_branch);
free(wt_branch_tip);
if (err) {
if (*new_base_branch_ref) {
	got_ref_close(*new_base_branch_ref);
	*new_base_branch_ref = NULL((void*)0);
}
if (*tmp_branch) {
	got_ref_close(*tmp_branch);
	*tmp_branch = NULL((void*)0);
}
if (*fileindex) {
	got_fileindex_free(*fileindex);
	*fileindex = NULL((void*)0);
}
lock_worktree(worktree, LOCK_SH0x01);
}
return err;
5922}

5924const struct got_error *
5925got_worktree_rebase_continue(struct got_object_id **commit_id,
  struct got_reference **new_base_branch, struct got_reference **tmp_branch,
  struct got_reference **branch, struct got_fileindex **fileindex,
  struct got_worktree *worktree, struct got_repository *repo)
5929{
const struct got_error *err;
char *commit_ref_name = NULL((void*)0), *new_base_branch_ref_name = NULL((void*)0);
char *tmp_branch_name = NULL((void*)0), *branch_ref_name = NULL((void*)0);
struct got_reference *commit_ref = NULL((void*)0), *branch_ref = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
int have_staged_files = 0;

*commit_id = NULL((void*)0);
*new_base_branch = NULL((void*)0);
*tmp_branch = NULL((void*)0);
*branch = NULL((void*)0);
*fileindex = NULL((void*)0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(fileindex, &fileindex_path, worktree);
if (err)
goto done;

err = got_fileindex_for_each_entry_safe(*fileindex, check_staged_file,
   &have_staged_files);
if (err && err->code != GOT_ERR_CANCELLED49)
goto done;
if (have_staged_files) {
err = got_error(GOT_ERR_STAGED_PATHS106);
goto done;
}

err = get_rebase_tmp_ref_name(&tmp_branch_name, worktree);
if (err)
goto done;

err = get_rebase_branch_symref_name(&branch_ref_name, worktree);
if (err)
goto done;

err = get_rebase_commit_ref_name(&commit_ref_name, worktree);
if (err)
goto done;

err = get_newbase_symref_name(&new_base_branch_ref_name, worktree);
if (err)
goto done;

err = got_ref_open(&branch_ref, repo, branch_ref_name, 0);
if (err)
goto done;

err = got_ref_open(branch, repo,
   got_ref_get_symref_target(branch_ref), 0);
if (err)
goto done;

err = got_ref_open(&commit_ref, repo, commit_ref_name, 0);
if (err)
goto done;

err = got_ref_resolve(commit_id, repo, commit_ref);
if (err)
goto done;

err = got_ref_open(new_base_branch, repo,
   new_base_branch_ref_name, 0);
if (err)
goto done;

err = got_ref_open(tmp_branch, repo, tmp_branch_name, 0);
if (err)
goto done;
6001done:
free(commit_ref_name);
free(branch_ref_name);
free(fileindex_path);
if (commit_ref)
got_ref_close(commit_ref);
if (branch_ref)
got_ref_close(branch_ref);
if (err) {
free(*commit_id);
*commit_id = NULL((void*)0);
if (*tmp_branch) {
	got_ref_close(*tmp_branch);
	*tmp_branch = NULL((void*)0);
}
if (*new_base_branch) {
	got_ref_close(*new_base_branch);
	*new_base_branch = NULL((void*)0);
}
if (*branch) {
	got_ref_close(*branch);
	*branch = NULL((void*)0);
}
if (*fileindex) {
	got_fileindex_free(*fileindex);
	*fileindex = NULL((void*)0);
}
lock_worktree(worktree, LOCK_SH0x01);
}
return err;
6031}

6033const struct got_error *
6034got_worktree_rebase_in_progress(int *in_progress, struct got_worktree *worktree)
6035{
const struct got_error *err;
char *tmp_branch_name = NULL((void*)0);

err = get_rebase_tmp_ref_name(&tmp_branch_name, worktree);
if (err)
return err;

*in_progress = (strcmp(tmp_branch_name, worktree->head_ref_name) == 0);
free(tmp_branch_name);
return NULL((void*)0);
6046}

6048static const struct got_error *
6049collect_rebase_commit_msg(struct got_pathlist_head *commitable_paths,
  char **logmsg, void *arg)
6051{
*logmsg = arg;
return NULL((void*)0);
6054}

6056static const struct got_error *
6057rebase_status(void *arg, unsigned char status, unsigned char staged_status,
  const char *path, struct got_object_id *blob_id,
  struct got_object_id *staged_blob_id, struct got_object_id *commit_id,
  int dirfd, const char *de_name)
6061{
return NULL((void*)0);
6063}

6065struct collect_merged_paths_arg {
got_worktree_checkout_cb progress_cb;
void *progress_arg;
struct got_pathlist_head *merged_paths;
6069};

6071static const struct got_error *
6072collect_merged_paths(void *arg, unsigned char status, const char *path)
6073{
const struct got_error *err;
struct collect_merged_paths_arg *a = arg;
char *p;
struct got_pathlist_entry *new;

err = (*a->progress_cb)(a->progress_arg, status, path);
if (err)
return err;

if (status != GOT_STATUS_MERGE'G' &&
   status != GOT_STATUS_ADD'A' &&
   status != GOT_STATUS_DELETE'D' &&
   status != GOT_STATUS_CONFLICT'C')
return NULL((void*)0);

p = strdup(path);
if (p == NULL((void*)0))
return got_error_from_errno("strdup");

err = got_pathlist_insert(&new, a->merged_paths, p, NULL((void*)0));
if (err || new == NULL((void*)0))
free(p);
return err;
6097}

6099void
6100got_worktree_rebase_pathlist_free(struct got_pathlist_head *merged_paths)
6101{
struct got_pathlist_entry *pe;

TAILQ_FOREACH(pe, merged_paths, entry)for((pe) = ((merged_paths)->tqh_first); (pe) != ((void*)0)
; (pe) = ((pe)->entry.tqe_next))
free((char *)pe->path);

got_pathlist_free(merged_paths);
6108}

6110static const struct got_error *
6111store_commit_id(const char *commit_ref_name, struct got_object_id *commit_id,
  int is_rebase, struct got_repository *repo)
6113{
const struct got_error *err;
struct got_reference *commit_ref = NULL((void*)0);

err = got_ref_open(&commit_ref, repo, commit_ref_name, 0);
if (err) {
if (err->code != GOT_ERR_NOT_REF5)
	goto done;
err = got_ref_alloc(&commit_ref, commit_ref_name, commit_id);
if (err)
	goto done;
err = got_ref_write(commit_ref, repo);
if (err)
	goto done;
} else if (is_rebase) {
struct got_object_id *stored_id;
int cmp;

err = got_ref_resolve(&stored_id, repo, commit_ref);
if (err)
	goto done;
cmp = got_object_id_cmp(commit_id, stored_id);
free(stored_id);
if (cmp != 0) {
	err = got_error(GOT_ERR_REBASE_COMMITID87);
	goto done;
}
}
6141done:
if (commit_ref)
got_ref_close(commit_ref);
return err;
6145}

6147static const struct got_error *
6148rebase_merge_files(struct got_pathlist_head *merged_paths,
  const char *commit_ref_name, struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_object_id *parent_commit_id,
  struct got_object_id *commit_id, struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)
6154{
const struct got_error *err;
struct got_reference *commit_ref = NULL((void*)0);
struct collect_merged_paths_arg cmp_arg;
char *fileindex_path;

/* Work tree is locked/unlocked during rebase preparation/teardown. */

err = get_fileindex_path(&fileindex_path, worktree);
if (err)
return err;

cmp_arg.progress_cb = progress_cb;
cmp_arg.progress_arg = progress_arg;
cmp_arg.merged_paths = merged_paths;
err = merge_files(worktree, fileindex, fileindex_path,
   parent_commit_id, commit_id, repo, collect_merged_paths,
   &cmp_arg, cancel_cb, cancel_arg);
if (commit_ref)
got_ref_close(commit_ref);
return err;
6175}

6177const struct got_error *
6178got_worktree_rebase_merge_files(struct got_pathlist_head *merged_paths,
  struct got_worktree *worktree, struct got_fileindex *fileindex,
  struct got_object_id *parent_commit_id, struct got_object_id *commit_id,
  struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)
6184{
const struct got_error *err;
char *commit_ref_name;

err = get_rebase_commit_ref_name(&commit_ref_name, worktree);
if (err)
return err;

err = store_commit_id(commit_ref_name, commit_id, 1, repo);
if (err)
goto done;

err = rebase_merge_files(merged_paths, commit_ref_name, worktree,
   fileindex, parent_commit_id, commit_id, repo, progress_cb,
   progress_arg, cancel_cb, cancel_arg);
6199done:
free(commit_ref_name);
return err;
6202}

6204const struct got_error *
6205got_worktree_histedit_merge_files(struct got_pathlist_head *merged_paths,
  struct got_worktree *worktree, struct got_fileindex *fileindex,
  struct got_object_id *parent_commit_id, struct got_object_id *commit_id,
  struct got_repository *repo,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)
6211{
const struct got_error *err;
char *commit_ref_name;

err = get_histedit_commit_ref_name(&commit_ref_name, worktree);
if (err)
return err;

err = store_commit_id(commit_ref_name, commit_id, 0, repo);
if (err)
goto done;

err = rebase_merge_files(merged_paths, commit_ref_name, worktree,
   fileindex, parent_commit_id, commit_id, repo, progress_cb,
   progress_arg, cancel_cb, cancel_arg);
6226done:
free(commit_ref_name);
return err;
6229}

6231static const struct got_error *
6232rebase_commit(struct got_object_id **new_commit_id,
  struct got_pathlist_head *merged_paths, struct got_reference *commit_ref,
  struct got_worktree *worktree, struct got_fileindex *fileindex,
  struct got_reference *tmp_branch, struct got_commit_object *orig_commit,
  const char *new_logmsg, struct got_repository *repo)
6237{
const struct got_error *err, *sync_err;
struct got_pathlist_head commitable_paths;
struct collect_commitables_arg cc_arg;
char *fileindex_path = NULL((void*)0);
struct got_reference *head_ref = NULL((void*)0);
struct got_object_id *head_commit_id = NULL((void*)0);
char *logmsg = NULL((void*)0);

TAILQ_INIT(&commitable_paths)do { (&commitable_paths)->tqh_first = ((void*)0); (&
commitable_paths)->tqh_last = &(&commitable_paths)
->tqh_first; } while (0);
*new_commit_id = NULL((void*)0);

/* Work tree is locked/unlocked during rebase preparation/teardown. */

err = get_fileindex_path(&fileindex_path, worktree);
if (err)
return err;

cc_arg.commitable_paths = &commitable_paths;
cc_arg.worktree = worktree;
cc_arg.repo = repo;
cc_arg.have_staged_files = 0;
/*
* If possible get the status of individual files directly to
* avoid crawling the entire work tree once per rebased commit.
* TODO: Ideally, merged_paths would contain a list of commitables
* we could use so we could skip worktree_status() entirely.
*/
if (merged_paths) {
struct got_pathlist_entry *pe;
TAILQ_FOREACH(pe, merged_paths, entry)for((pe) = ((merged_paths)->tqh_first); (pe) != ((void*)0)
; (pe) = ((pe)->entry.tqe_next)) {
	err = worktree_status(worktree, pe->path, fileindex,
	    repo, collect_commitables, &cc_arg, NULL((void*)0), NULL((void*)0), 0,
	    0);
	if (err)
		goto done;
}
} else {
err = worktree_status(worktree, "", fileindex, repo,
    collect_commitables, &cc_arg, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
	goto done;
}

if (TAILQ_EMPTY(&commitable_paths)(((&commitable_paths)->tqh_first) == ((void*)0))) {
/* No-op change; commit will be elided. */
err = got_ref_delete(commit_ref, repo);
if (err)
	goto done;
err = got_error(GOT_ERR_COMMIT_NO_CHANGES76);
goto done;
}

err = got_ref_open(&head_ref, repo, worktree->head_ref_name, 0);
if (err)
goto done;

err = got_ref_resolve(&head_commit_id, repo, head_ref);
if (err)
goto done;

if (new_logmsg) {
logmsg = strdup(new_logmsg);
if (logmsg == NULL((void*)0)) {
	err = got_error_from_errno("strdup");
	goto done;
}
} else {
err = got_object_commit_get_logmsg(&logmsg, orig_commit);
if (err)
	goto done;
}

/* NB: commit_worktree will call free(logmsg) */
err = commit_worktree(new_commit_id, &commitable_paths, head_commit_id,
   worktree, got_object_commit_get_author(orig_commit),
   got_object_commit_get_committer(orig_commit),
   collect_rebase_commit_msg, logmsg, rebase_status, NULL((void*)0), repo);
if (err)
goto done;

err = got_ref_change_ref(tmp_branch, *new_commit_id);
if (err)
goto done;

err = got_ref_delete(commit_ref, repo);
if (err)
goto done;

err = update_fileindex_after_commit(worktree, &commitable_paths,
   *new_commit_id, fileindex, 0);
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
6331done:
free(fileindex_path);
free(head_commit_id);
if (head_ref)
got_ref_close(head_ref);
if (err) {
free(*new_commit_id);
*new_commit_id = NULL((void*)0);
}
return err;
6341}

6343const struct got_error *
6344got_worktree_rebase_commit(struct got_object_id **new_commit_id,
  struct got_pathlist_head *merged_paths, struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_reference *tmp_branch,
  struct got_commit_object *orig_commit,
  struct got_object_id *orig_commit_id, struct got_repository *repo)
6349{
const struct got_error *err;
char *commit_ref_name;
struct got_reference *commit_ref = NULL((void*)0);
struct got_object_id *commit_id = NULL((void*)0);

err = get_rebase_commit_ref_name(&commit_ref_name, worktree);
if (err)
return err;

err = got_ref_open(&commit_ref, repo, commit_ref_name, 0);
if (err)
goto done;
err = got_ref_resolve(&commit_id, repo, commit_ref);
if (err)
goto done;
if (got_object_id_cmp(commit_id, orig_commit_id) != 0) {
err = got_error(GOT_ERR_REBASE_COMMITID87);
goto done;
}

err = rebase_commit(new_commit_id, merged_paths, commit_ref,
   worktree, fileindex, tmp_branch, orig_commit, NULL((void*)0), repo);
6372done:
if (commit_ref)
got_ref_close(commit_ref);
free(commit_ref_name);
free(commit_id);
return err;
6378}

6380const struct got_error *
6381got_worktree_histedit_commit(struct got_object_id **new_commit_id,
  struct got_pathlist_head *merged_paths, struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_reference *tmp_branch,
  struct got_commit_object *orig_commit,
  struct got_object_id *orig_commit_id, const char *new_logmsg,
  struct got_repository *repo)
6387{
const struct got_error *err;
char *commit_ref_name;
struct got_reference *commit_ref = NULL((void*)0);

err = get_histedit_commit_ref_name(&commit_ref_name, worktree);
if (err)
return err;

err = got_ref_open(&commit_ref, repo, commit_ref_name, 0);
if (err)
goto done;

err = rebase_commit(new_commit_id, merged_paths, commit_ref,
   worktree, fileindex, tmp_branch, orig_commit, new_logmsg, repo);
6402done:
if (commit_ref)
got_ref_close(commit_ref);
free(commit_ref_name);
return err;
6407}

6409const struct got_error *
6410got_worktree_rebase_postpone(struct got_worktree *worktree,
  struct got_fileindex *fileindex)
6412{
if (fileindex)
got_fileindex_free(fileindex);
return lock_worktree(worktree, LOCK_SH0x01);
6416}

6418static const struct got_error *
6419delete_ref(const char *name, struct got_repository *repo)
6420{
const struct got_error *err;
struct got_reference *ref;

err = got_ref_open(&ref, repo, name, 0);
if (err) {
if (err->code == GOT_ERR_NOT_REF5)
	return NULL((void*)0);
return err;
}

err = got_ref_delete(ref, repo);
got_ref_close(ref);
return err;
6434}

6436static const struct got_error *
6437delete_rebase_refs(struct got_worktree *worktree, struct got_repository *repo)
6438{
const struct got_error *err;
char *tmp_branch_name = NULL((void*)0), *new_base_branch_ref_name = NULL((void*)0);
char *branch_ref_name = NULL((void*)0), *commit_ref_name = NULL((void*)0);

err = get_rebase_tmp_ref_name(&tmp_branch_name, worktree);
if (err)
goto done;
err = delete_ref(tmp_branch_name, repo);
if (err)
goto done;

err = get_newbase_symref_name(&new_base_branch_ref_name, worktree);
if (err)
goto done;
err = delete_ref(new_base_branch_ref_name, repo);
if (err)
goto done;

err = get_rebase_branch_symref_name(&branch_ref_name, worktree);
if (err)
goto done;
err = delete_ref(branch_ref_name, repo);
if (err)
goto done;

err = get_rebase_commit_ref_name(&commit_ref_name, worktree);
if (err)
goto done;
err = delete_ref(commit_ref_name, repo);
if (err)
goto done;

6471done:
free(tmp_branch_name);
free(new_base_branch_ref_name);
free(branch_ref_name);
free(commit_ref_name);
return err;
6477}

6479const struct got_error *
6480create_backup_ref(const char *backup_ref_prefix, struct got_reference *branch,
  struct got_object_id *new_commit_id, struct got_repository *repo)
6482{
const struct got_error *err;
struct got_reference *ref = NULL((void*)0);
struct got_object_id *old_commit_id = NULL((void*)0);
const char *branch_name = NULL((void*)0);
char *new_id_str = NULL((void*)0);
char *refname = NULL((void*)0);

branch_name = got_ref_get_name(branch);
if (strncmp(branch_name, "refs/heads/", 11) != 0)
return got_error(GOT_ERR_BAD_REF_NAME65); /* should not happen */
branch_name += 11;

err = got_object_id_str(&new_id_str, new_commit_id);
if (err)
return err;

if (asprintf(&refname, "%s/%s/%s", backup_ref_prefix, branch_name,
   new_id_str) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

err = got_ref_resolve(&old_commit_id, repo, branch);
if (err)
goto done;

err = got_ref_alloc(&ref, refname, old_commit_id);
if (err)
goto done;

err = got_ref_write(ref, repo);
6514done:
free(new_id_str);
free(refname);
free(old_commit_id);
if (ref)
got_ref_close(ref);
return err;
6521}

6523const struct got_error *
6524got_worktree_rebase_complete(struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_reference *new_base_branch,
  struct got_reference *tmp_branch, struct got_reference *rebased_branch,
  struct got_repository *repo, int create_backup)
6528{
const struct got_error *err, *unlockerr, *sync_err;
struct got_object_id *new_head_commit_id = NULL((void*)0);
char *fileindex_path = NULL((void*)0);

err = got_ref_resolve(&new_head_commit_id, repo, tmp_branch);
if (err)
return err;

if (create_backup) {
err = create_backup_ref(GOT_WORKTREE_REBASE_BACKUP_REF_PREFIX"refs/got/backup/rebase",
    rebased_branch, new_head_commit_id, repo);
if (err)
	goto done;
}

err = got_ref_change_ref(rebased_branch, new_head_commit_id);
if (err)
goto done;

err = got_ref_write(rebased_branch, repo);
if (err)
goto done;

err = got_worktree_set_head_ref(worktree, rebased_branch);
if (err)
goto done;

err = delete_rebase_refs(worktree, repo);
if (err)
goto done;

err = get_fileindex_path(&fileindex_path, worktree);
if (err)
goto done;
err = bump_base_commit_id_everywhere(worktree, fileindex, NULL((void*)0), NULL((void*)0));
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
6567done:
got_fileindex_free(fileindex);
free(fileindex_path);
free(new_head_commit_id);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
6575}

6577const struct got_error *
6578got_worktree_rebase_abort(struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_repository *repo,
  struct got_reference *new_base_branch,
   got_worktree_checkout_cb progress_cb, void *progress_arg)
6582{
const struct got_error *err, *unlockerr, *sync_err;
struct got_reference *resolved = NULL((void*)0);
struct got_object_id *commit_id = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct revert_file_args rfa;
struct got_object_id *tree_id = NULL((void*)0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = got_ref_open(&resolved, repo,
   got_ref_get_symref_target(new_base_branch), 0);
if (err)
goto done;

err = got_worktree_set_head_ref(worktree, resolved);
if (err)
goto done;

/*
* XXX commits to the base branch could have happened while
* we were busy rebasing; should we store the original commit ID
* when rebase begins and read it back here?
*/
err = got_ref_resolve(&commit_id, repo, resolved);
if (err)
goto done;

err = got_worktree_set_base_commit_id(worktree, repo, commit_id);
if (err)
goto done;

err = got_object_id_by_path(&tree_id, repo,
   worktree->base_commit_id, worktree->path_prefix);
if (err)
goto done;

err = delete_rebase_refs(worktree, repo);
if (err)
goto done;

err = get_fileindex_path(&fileindex_path, worktree);
if (err)
goto done;

rfa.worktree = worktree;
rfa.fileindex = fileindex;
rfa.progress_cb = progress_cb;
rfa.progress_arg = progress_arg;
rfa.patch_cb = NULL((void*)0);
rfa.patch_arg = NULL((void*)0);
rfa.repo = repo;
err = worktree_status(worktree, "", fileindex, repo,
   revert_file, &rfa, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
goto sync;

err = checkout_files(worktree, fileindex, "", tree_id, NULL((void*)0),
   repo, progress_cb, progress_arg, NULL((void*)0), NULL((void*)0));
6643sync:
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
6647done:
got_ref_close(resolved);
free(tree_id);
free(commit_id);
if (fileindex)
got_fileindex_free(fileindex);
free(fileindex_path);

unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
6659}

6661const struct got_error *
6662got_worktree_histedit_prepare(struct got_reference **tmp_branch,
  struct got_reference **branch_ref, struct got_object_id **base_commit_id,
  struct got_fileindex **fileindex, struct got_worktree *worktree,
  struct got_repository *repo)
6666{
const struct got_error *err = NULL((void*)0);
char *tmp_branch_name = NULL((void*)0);
char *branch_ref_name = NULL((void*)0);
char *base_commit_ref_name = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct check_rebase_ok_arg ok_arg;
struct got_reference *wt_branch = NULL((void*)0);
struct got_reference *base_commit_ref = NULL((void*)0);

*tmp_branch = NULL((void*)0);
*branch_ref = NULL((void*)0);
*base_commit_id = NULL((void*)0);
*fileindex = NULL((void*)0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(fileindex, &fileindex_path, worktree);
if (err)
goto done;

ok_arg.worktree = worktree;
ok_arg.repo = repo;
err = got_fileindex_for_each_entry_safe(*fileindex, check_rebase_ok,
   &ok_arg);
if (err)
goto done;

err = get_histedit_tmp_ref_name(&tmp_branch_name, worktree);
if (err)
goto done;

err = get_histedit_branch_symref_name(&branch_ref_name, worktree);
if (err)
goto done;

err = get_histedit_base_commit_ref_name(&base_commit_ref_name,
   worktree);
if (err)
goto done;

err = got_ref_open(&wt_branch, repo, worktree->head_ref_name,
   0);
if (err)
goto done;

err = got_ref_alloc_symref(branch_ref, branch_ref_name, wt_branch);
if (err)
goto done;

err = got_ref_write(*branch_ref, repo);
if (err)
goto done;

err = got_ref_alloc(&base_commit_ref, base_commit_ref_name,
   worktree->base_commit_id);
if (err)
goto done;
err = got_ref_write(base_commit_ref, repo);
if (err)
goto done;
*base_commit_id = got_object_id_dup(worktree->base_commit_id);
if (*base_commit_id == NULL((void*)0)) {
err = got_error_from_errno("got_object_id_dup");
goto done;
}

err = got_ref_alloc(tmp_branch, tmp_branch_name,
   worktree->base_commit_id);
if (err)
goto done;
err = got_ref_write(*tmp_branch, repo);
if (err)
goto done;

err = got_worktree_set_head_ref(worktree, *tmp_branch);
if (err)
goto done;
6746done:
free(fileindex_path);
free(tmp_branch_name);
free(branch_ref_name);
free(base_commit_ref_name);
if (wt_branch)
got_ref_close(wt_branch);
if (err) {
if (*branch_ref) {
	got_ref_close(*branch_ref);
	*branch_ref = NULL((void*)0);
}
if (*tmp_branch) {
	got_ref_close(*tmp_branch);
	*tmp_branch = NULL((void*)0);
}
free(*base_commit_id);
if (*fileindex) {
	got_fileindex_free(*fileindex);
	*fileindex = NULL((void*)0);
}
lock_worktree(worktree, LOCK_SH0x01);
}
return err;
6770}

6772const struct got_error *
6773got_worktree_histedit_postpone(struct got_worktree *worktree,
  struct got_fileindex *fileindex)
6775{
if (fileindex)
got_fileindex_free(fileindex);
return lock_worktree(worktree, LOCK_SH0x01);
6779}

6781const struct got_error *
6782got_worktree_histedit_in_progress(int *in_progress,
  struct got_worktree *worktree)
6784{
const struct got_error *err;
char *tmp_branch_name = NULL((void*)0);

err = get_histedit_tmp_ref_name(&tmp_branch_name, worktree);
1
Calling 'get_histedit_tmp_ref_name'→
15
←
Returning from 'get_histedit_tmp_ref_name'→
if (err)
16
←
Assuming 'err' is null→
17
←
Taking false branch→
return err;

*in_progress = (strcmp(tmp_branch_name, worktree->head_ref_name) == 0);
18
←
Null pointer passed as 1st argument to string comparison function
free(tmp_branch_name);
return NULL((void*)0);
6795}

6797const struct got_error *
6798got_worktree_histedit_continue(struct got_object_id **commit_id,
  struct got_reference **tmp_branch, struct got_reference **branch_ref,
  struct got_object_id **base_commit_id, struct got_fileindex **fileindex,
  struct got_worktree *worktree, struct got_repository *repo)
6802{
const struct got_error *err;
char *commit_ref_name = NULL((void*)0), *base_commit_ref_name = NULL((void*)0);
char *tmp_branch_name = NULL((void*)0), *branch_ref_name = NULL((void*)0);
struct got_reference *commit_ref = NULL((void*)0);
struct got_reference *base_commit_ref = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
int have_staged_files = 0;

*commit_id = NULL((void*)0);
*tmp_branch = NULL((void*)0);
*base_commit_id = NULL((void*)0);
*fileindex = NULL((void*)0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(fileindex, &fileindex_path, worktree);
if (err)
goto done;

err = got_fileindex_for_each_entry_safe(*fileindex, check_staged_file,
   &have_staged_files);
if (err && err->code != GOT_ERR_CANCELLED49)
goto done;
if (have_staged_files) {
err = got_error(GOT_ERR_STAGED_PATHS106);
goto done;
}

err = get_histedit_tmp_ref_name(&tmp_branch_name, worktree);
if (err)
goto done;

err = get_histedit_branch_symref_name(&branch_ref_name, worktree);
if (err)
goto done;

err = get_histedit_commit_ref_name(&commit_ref_name, worktree);
if (err)
goto done;

err = get_histedit_base_commit_ref_name(&base_commit_ref_name,
   worktree);
if (err)
goto done;

err = got_ref_open(branch_ref, repo, branch_ref_name, 0);
if (err)
goto done;

err = got_ref_open(&commit_ref, repo, commit_ref_name, 0);
if (err)
goto done;
err = got_ref_resolve(commit_id, repo, commit_ref);
if (err)
goto done;

err = got_ref_open(&base_commit_ref, repo, base_commit_ref_name, 0);
if (err)
goto done;
err = got_ref_resolve(base_commit_id, repo, base_commit_ref);
if (err)
goto done;

err = got_ref_open(tmp_branch, repo, tmp_branch_name, 0);
if (err)
goto done;
6871done:
free(commit_ref_name);
free(branch_ref_name);
free(fileindex_path);
if (commit_ref)
got_ref_close(commit_ref);
if (base_commit_ref)
got_ref_close(base_commit_ref);
if (err) {
free(*commit_id);
*commit_id = NULL((void*)0);
free(*base_commit_id);
*base_commit_id = NULL((void*)0);
if (*tmp_branch) {
	got_ref_close(*tmp_branch);
	*tmp_branch = NULL((void*)0);
}
if (*fileindex) {
	got_fileindex_free(*fileindex);
	*fileindex = NULL((void*)0);
}
lock_worktree(worktree, LOCK_EX0x02);
}
return err;
6895}

6897static const struct got_error *
6898delete_histedit_refs(struct got_worktree *worktree, struct got_repository *repo)
6899{
const struct got_error *err;
char *tmp_branch_name = NULL((void*)0), *base_commit_ref_name = NULL((void*)0);
char *branch_ref_name = NULL((void*)0), *commit_ref_name = NULL((void*)0);

err = get_histedit_tmp_ref_name(&tmp_branch_name, worktree);
if (err)
goto done;
err = delete_ref(tmp_branch_name, repo);
if (err)
goto done;

err = get_histedit_base_commit_ref_name(&base_commit_ref_name,
   worktree);
if (err)
goto done;
err = delete_ref(base_commit_ref_name, repo);
if (err)
goto done;

err = get_histedit_branch_symref_name(&branch_ref_name, worktree);
if (err)
goto done;
err = delete_ref(branch_ref_name, repo);
if (err)
goto done;

err = get_histedit_commit_ref_name(&commit_ref_name, worktree);
if (err)
goto done;
err = delete_ref(commit_ref_name, repo);
if (err)
goto done;
6932done:
free(tmp_branch_name);
free(base_commit_ref_name);
free(branch_ref_name);
free(commit_ref_name);
return err;
6938}

6940const struct got_error *
6941got_worktree_histedit_abort(struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_repository *repo,
  struct got_reference *branch, struct got_object_id *base_commit_id,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
6945{
const struct got_error *err, *unlockerr, *sync_err;
struct got_reference *resolved = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct got_object_id *tree_id = NULL((void*)0);
struct revert_file_args rfa;

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = got_ref_open(&resolved, repo,
   got_ref_get_symref_target(branch), 0);
if (err)
goto done;

err = got_worktree_set_head_ref(worktree, resolved);
if (err)
goto done;

err = got_worktree_set_base_commit_id(worktree, repo, base_commit_id);
if (err)
goto done;

err = got_object_id_by_path(&tree_id, repo, base_commit_id,
   worktree->path_prefix);
if (err)
goto done;

err = delete_histedit_refs(worktree, repo);
if (err)
goto done;

err = get_fileindex_path(&fileindex_path, worktree);
if (err)
goto done;

rfa.worktree = worktree;
rfa.fileindex = fileindex;
rfa.progress_cb = progress_cb;
rfa.progress_arg = progress_arg;
rfa.patch_cb = NULL((void*)0);
rfa.patch_arg = NULL((void*)0);
rfa.repo = repo;
err = worktree_status(worktree, "", fileindex, repo,
   revert_file, &rfa, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
goto sync;

err = checkout_files(worktree, fileindex, "", tree_id, NULL((void*)0),
   repo, progress_cb, progress_arg, NULL((void*)0), NULL((void*)0));
6996sync:
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
7000done:
got_ref_close(resolved);
free(tree_id);
free(fileindex_path);

unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
7009}

7011const struct got_error *
7012got_worktree_histedit_complete(struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_reference *tmp_branch,
  struct got_reference *edited_branch, struct got_repository *repo)
7015{
const struct got_error *err, *unlockerr, *sync_err;
struct got_object_id *new_head_commit_id = NULL((void*)0);
struct got_reference *resolved = NULL((void*)0);
char *fileindex_path = NULL((void*)0);

err = got_ref_resolve(&new_head_commit_id, repo, tmp_branch);
if (err)
return err;

err = got_ref_open(&resolved, repo,
   got_ref_get_symref_target(edited_branch), 0);
if (err)
goto done;

err = create_backup_ref(GOT_WORKTREE_HISTEDIT_BACKUP_REF_PREFIX"refs/got/backup/histedit",
   resolved, new_head_commit_id, repo);
if (err)
goto done;

err = got_ref_change_ref(resolved, new_head_commit_id);
if (err)
goto done;

err = got_ref_write(resolved, repo);
if (err)
goto done;

err = got_worktree_set_head_ref(worktree, resolved);
if (err)
goto done;

err = delete_histedit_refs(worktree, repo);
if (err)
goto done;

err = get_fileindex_path(&fileindex_path, worktree);
if (err)
goto done;
err = bump_base_commit_id_everywhere(worktree, fileindex, NULL((void*)0), NULL((void*)0));
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
7058done:
got_fileindex_free(fileindex);
free(fileindex_path);
free(new_head_commit_id);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
7066}

7068const struct got_error *
7069got_worktree_histedit_skip_commit(struct got_worktree *worktree,
  struct got_object_id *commit_id, struct got_repository *repo)
7071{
const struct got_error *err;
char *commit_ref_name;

err = get_histedit_commit_ref_name(&commit_ref_name, worktree);
if (err)
return err;

err = store_commit_id(commit_ref_name, commit_id, 0, repo);
if (err)
goto done;

err = delete_ref(commit_ref_name, repo);
7084done:
free(commit_ref_name);
return err;
7087}

7089const struct got_error *
7090got_worktree_integrate_prepare(struct got_fileindex **fileindex,
  struct got_reference **branch_ref, struct got_reference **base_branch_ref,
  struct got_worktree *worktree, const char *refname,
  struct got_repository *repo)
7094{
const struct got_error *err = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct check_rebase_ok_arg ok_arg;

*fileindex = NULL((void*)0);
*branch_ref = NULL((void*)0);
*base_branch_ref = NULL((void*)0);

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

if (strcmp(refname, got_worktree_get_head_ref_name(worktree)) == 0) {
err = got_error_msg(GOT_ERR_SAME_BRANCH79,
    "cannot integrate a branch into itself; "
    "update -b or different branch name required");
goto done;
}

err = open_fileindex(fileindex, &fileindex_path, worktree);
if (err)
goto done;

/* Preconditions are the same as for rebase. */
ok_arg.worktree = worktree;
ok_arg.repo = repo;
err = got_fileindex_for_each_entry_safe(*fileindex, check_rebase_ok,
   &ok_arg);
if (err)
goto done;

err = got_ref_open(branch_ref, repo, refname, 1);
if (err)
goto done;

err = got_ref_open(base_branch_ref, repo,
   got_worktree_get_head_ref_name(worktree), 1);
7132done:
if (err) {
if (*branch_ref) {
	got_ref_close(*branch_ref);
	*branch_ref = NULL((void*)0);
}
if (*base_branch_ref) {
	got_ref_close(*base_branch_ref);
	*base_branch_ref = NULL((void*)0);
}
if (*fileindex) {
	got_fileindex_free(*fileindex);
	*fileindex = NULL((void*)0);
}
lock_worktree(worktree, LOCK_SH0x01);
}
return err;
7149}

7151const struct got_error *
7152got_worktree_integrate_continue(struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_repository *repo,
  struct got_reference *branch_ref, struct got_reference *base_branch_ref,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)
7157{
const struct got_error *err = NULL((void*)0), *sync_err, *unlockerr;
char *fileindex_path = NULL((void*)0);
struct got_object_id *tree_id = NULL((void*)0), *commit_id = NULL((void*)0);

err = get_fileindex_path(&fileindex_path, worktree);
if (err)
goto done;

err = got_ref_resolve(&commit_id, repo, branch_ref);
if (err)
goto done;

err = got_object_id_by_path(&tree_id, repo, commit_id,
   worktree->path_prefix);
if (err)
goto done;

err = got_worktree_set_base_commit_id(worktree, repo, commit_id);
if (err)
goto done;

err = checkout_files(worktree, fileindex, "", tree_id, NULL((void*)0), repo,
   progress_cb, progress_arg, cancel_cb, cancel_arg);
if (err)
goto sync;

err = got_ref_change_ref(base_branch_ref, commit_id);
if (err)
goto sync;

err = got_ref_write(base_branch_ref, repo);
if (err)
goto sync;

err = bump_base_commit_id_everywhere(worktree, fileindex, NULL((void*)0), NULL((void*)0));
7193sync:
sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;

7198done:
unlockerr = got_ref_unlock(branch_ref);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
got_ref_close(branch_ref);

unlockerr = got_ref_unlock(base_branch_ref);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
got_ref_close(base_branch_ref);

got_fileindex_free(fileindex);
free(fileindex_path);
free(tree_id);

unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
7217}

7219const struct got_error *
7220got_worktree_integrate_abort(struct got_worktree *worktree,
  struct got_fileindex *fileindex, struct got_repository *repo,
  struct got_reference *branch_ref, struct got_reference *base_branch_ref)
7223{
const struct got_error *err = NULL((void*)0), *unlockerr = NULL((void*)0);

got_fileindex_free(fileindex);

err = lock_worktree(worktree, LOCK_SH0x01);

unlockerr = got_ref_unlock(branch_ref);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
got_ref_close(branch_ref);

unlockerr = got_ref_unlock(base_branch_ref);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
got_ref_close(base_branch_ref);

return err;
7241}

7243struct check_stage_ok_arg {
struct got_object_id *head_commit_id;
struct got_worktree *worktree;
struct got_fileindex *fileindex;
struct got_repository *repo;
int have_changes;
7249};

7251const struct got_error *
7252check_stage_ok(void *arg, unsigned char status,
  unsigned char staged_status, const char *relpath,
  struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
  struct got_object_id *commit_id, int dirfd, const char *de_name)
7256{
struct check_stage_ok_arg *a = arg;
const struct got_error *err = NULL((void*)0);
struct got_fileindex_entry *ie;
struct got_object_id base_commit_id;
struct got_object_id *base_commit_idp = NULL((void*)0);
char *in_repo_path = NULL((void*)0), *p;

if (status == GOT_STATUS_UNVERSIONED'?' ||
   status == GOT_STATUS_NO_CHANGE' ')
return NULL((void*)0);
if (status == GOT_STATUS_NONEXISTENT'N')
return got_error_set_errno(ENOENT2, relpath);

ie = got_fileindex_entry_get(a->fileindex, relpath, strlen(relpath));
if (ie == NULL((void*)0))
return got_error_path(relpath, GOT_ERR_FILE_STATUS68);

if (asprintf(&in_repo_path, "%s%s%s", a->worktree->path_prefix,
   got_path_is_root_dir(a->worktree->path_prefix) ? "" : "/",
   relpath) == -1)
return got_error_from_errno("asprintf");

if (got_fileindex_entry_has_commit(ie)) {
memcpy(base_commit_id.sha1, ie->commit_sha1,
    SHA1_DIGEST_LENGTH20);
base_commit_idp = &base_commit_id;
}

if (status == GOT_STATUS_CONFLICT'C') {
err = got_error_path(ie->path, GOT_ERR_STAGE_CONFLICT103);
goto done;
} else if (status != GOT_STATUS_ADD'A' &&
   status != GOT_STATUS_MODIFY'M' &&
   status != GOT_STATUS_DELETE'D') {
err = got_error_path(ie->path, GOT_ERR_FILE_STATUS68);
goto done;
}

a->have_changes = 1;

p = in_repo_path;
while (p[0] == '/')
p++;
err = check_out_of_date(p, status, staged_status,
   blob_id, base_commit_idp, a->head_commit_id, a->repo,
   GOT_ERR_STAGE_OUT_OF_DATE104);
7303done:
free(in_repo_path);
return err;
7306}

7308struct stage_path_arg {
struct got_worktree *worktree;
struct got_fileindex *fileindex;
struct got_repository *repo;
got_worktree_status_cb status_cb;
void *status_arg;
got_worktree_patch_cb patch_cb;
void *patch_arg;
int staged_something;
int allow_bad_symlinks;
7318};

7320static const struct got_error *
7321stage_path(void *arg, unsigned char status,
  unsigned char staged_status, const char *relpath,
  struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
  struct got_object_id *commit_id, int dirfd, const char *de_name)
7325{
struct stage_path_arg *a = arg;
const struct got_error *err = NULL((void*)0);
struct got_fileindex_entry *ie;
char *ondisk_path = NULL((void*)0), *path_content = NULL((void*)0);
uint32_t stage;
struct got_object_id *new_staged_blob_id = NULL((void*)0);
struct stat sb;

if (status == GOT_STATUS_UNVERSIONED'?')
return NULL((void*)0);

ie = got_fileindex_entry_get(a->fileindex, relpath, strlen(relpath));
if (ie == NULL((void*)0))
return got_error_path(relpath, GOT_ERR_FILE_STATUS68);

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path,
   relpath)== -1)
return got_error_from_errno("asprintf");

switch (status) {
case GOT_STATUS_ADD'A':
case GOT_STATUS_MODIFY'M':
/* XXX could sb.st_mode be passed in by our caller? */
if (lstat(ondisk_path, &sb) == -1) {
	err = got_error_from_errno2("lstat", ondisk_path);
	break;
}
if (a->patch_cb) {
	if (status == GOT_STATUS_ADD'A') {
		int choice = GOT_PATCH_CHOICE_NONE0;
		err = (*a->patch_cb)(&choice, a->patch_arg,
		    status, ie->path, NULL((void*)0), 1, 1);
		if (err)
			break;
		if (choice != GOT_PATCH_CHOICE_YES1)
			break;
	} else {
		err = create_patched_content(&path_content, 0,
		    staged_blob_id ? staged_blob_id : blob_id,
		    ondisk_path, dirfd, de_name, ie->path,
		    a->repo, a->patch_cb, a->patch_arg);
		if (err || path_content == NULL((void*)0))
			break;
	}
}
err = got_object_blob_create(&new_staged_blob_id,
    path_content ? path_content : ondisk_path, a->repo);
if (err)
	break;
memcpy(ie->staged_blob_sha1, new_staged_blob_id->sha1,
    SHA1_DIGEST_LENGTH20);
if (status == GOT_STATUS_ADD'A' || staged_status == GOT_STATUS_ADD'A')
	stage = GOT_FILEIDX_STAGE_ADD2;
else
	stage = GOT_FILEIDX_STAGE_MODIFY1;
got_fileindex_entry_stage_set(ie, stage);
if (S_ISLNK(sb.st_mode)((sb.st_mode & 0170000) == 0120000)) {
	int is_bad_symlink = 0;
	if (!a->allow_bad_symlinks) {
		char target_path[PATH_MAX1024];
		ssize_t target_len;
		target_len = readlink(ondisk_path, target_path,
		    sizeof(target_path));
		if (target_len == -1) {
			err = got_error_from_errno2("readlink",
			    ondisk_path);
			break;
		}
		err = is_bad_symlink_target(&is_bad_symlink,
		    target_path, target_len, ondisk_path,
		    a->worktree->root_path);
		if (err)
			break;
		if (is_bad_symlink) {
			err = got_error_path(ondisk_path,
			    GOT_ERR_BAD_SYMLINK129);
			break;
		}
	}
	if (is_bad_symlink)
		got_fileindex_entry_staged_filetype_set(ie,
		    GOT_FILEIDX_MODE_BAD_SYMLINK3);
	else
		got_fileindex_entry_staged_filetype_set(ie,
		    GOT_FILEIDX_MODE_SYMLINK2);
} else {
	got_fileindex_entry_staged_filetype_set(ie,
	    GOT_FILEIDX_MODE_REGULAR_FILE1);
}
a->staged_something = 1;
if (a->status_cb == NULL((void*)0))
	break;
err = (*a->status_cb)(a->status_arg, GOT_STATUS_NO_CHANGE' ',
    get_staged_status(ie), relpath, blob_id,
    new_staged_blob_id, NULL((void*)0), dirfd, de_name);
break;
case GOT_STATUS_DELETE'D':
if (staged_status == GOT_STATUS_DELETE'D')
	break;
if (a->patch_cb) {
	int choice = GOT_PATCH_CHOICE_NONE0;
	err = (*a->patch_cb)(&choice, a->patch_arg, status,
	    ie->path, NULL((void*)0), 1, 1);
	if (err)
		break;
	if (choice == GOT_PATCH_CHOICE_NO2)
		break;
	if (choice != GOT_PATCH_CHOICE_YES1) {
		err = got_error(GOT_ERR_PATCH_CHOICE107);
		break;
	}
}
stage = GOT_FILEIDX_STAGE_DELETE3;
got_fileindex_entry_stage_set(ie, stage);
a->staged_something = 1;
if (a->status_cb == NULL((void*)0))
	break;
err = (*a->status_cb)(a->status_arg, GOT_STATUS_NO_CHANGE' ',
    get_staged_status(ie), relpath, NULL((void*)0), NULL((void*)0), NULL((void*)0), dirfd,
    de_name);
break;
case GOT_STATUS_NO_CHANGE' ':
break;
case GOT_STATUS_CONFLICT'C':
err = got_error_path(relpath, GOT_ERR_STAGE_CONFLICT103);
break;
case GOT_STATUS_NONEXISTENT'N':
err = got_error_set_errno(ENOENT2, relpath);
break;
default:
err = got_error_path(relpath, GOT_ERR_FILE_STATUS68);
break;
}

if (path_content && unlink(path_content) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("unlink", path_content);
free(path_content);
free(ondisk_path);
free(new_staged_blob_id);
return err;
7466}

7468const struct got_error *
7469got_worktree_stage(struct got_worktree *worktree,
  struct got_pathlist_head *paths,
  got_worktree_status_cb status_cb, void *status_arg,
  got_worktree_patch_cb patch_cb, void *patch_arg,
  int allow_bad_symlinks, struct got_repository *repo)
7474{
const struct got_error *err = NULL((void*)0), *sync_err, *unlockerr;
struct got_pathlist_entry *pe;
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct got_reference *head_ref = NULL((void*)0);
struct got_object_id *head_commit_id = NULL((void*)0);
struct check_stage_ok_arg oka;
struct stage_path_arg spa;

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = got_ref_open(&head_ref, repo,
   got_worktree_get_head_ref_name(worktree), 0);
if (err)
goto done;
err = got_ref_resolve(&head_commit_id, repo, head_ref);
if (err)
goto done;
err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

/* Check pre-conditions before staging anything. */
oka.head_commit_id = head_commit_id;
oka.worktree = worktree;
oka.fileindex = fileindex;
oka.repo = repo;
oka.have_changes = 0;
TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
    check_stage_ok, &oka, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
	goto done;
}
if (!oka.have_changes) {
err = got_error(GOT_ERR_STAGE_NO_CHANGE102);
goto done;
}

spa.worktree = worktree;
spa.fileindex = fileindex;
spa.repo = repo;
spa.patch_cb = patch_cb;
spa.patch_arg = patch_arg;
spa.status_cb = status_cb;
spa.status_arg = status_arg;
spa.staged_something = 0;
spa.allow_bad_symlinks = allow_bad_symlinks;
TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
    stage_path, &spa, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
	goto done;
}
if (!spa.staged_something) {
err = got_error(GOT_ERR_STAGE_NO_CHANGE102);
goto done;
}

sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
7539done:
if (head_ref)
got_ref_close(head_ref);
free(head_commit_id);
free(fileindex_path);
if (fileindex)
got_fileindex_free(fileindex);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
7550}

7552struct unstage_path_arg {
struct got_worktree *worktree;
struct got_fileindex *fileindex;
struct got_repository *repo;
got_worktree_checkout_cb progress_cb;
void *progress_arg;
got_worktree_patch_cb patch_cb;
void *patch_arg;
7560};

7562static const struct got_error *
7563create_unstaged_content(char **path_unstaged_content,
  char **path_new_staged_content, struct got_object_id *blob_id,
  struct got_object_id *staged_blob_id, const char *relpath,
  struct got_repository *repo,
  got_worktree_patch_cb patch_cb, void *patch_arg)
7568{
const struct got_error *err, *free_err;
struct got_blob_object *blob = NULL((void*)0), *staged_blob = NULL((void*)0);
FILE *f1 = NULL((void*)0), *f2 = NULL((void*)0), *outfile = NULL((void*)0), *rejectfile = NULL((void*)0);
char *path1 = NULL((void*)0), *path2 = NULL((void*)0), *label1 = NULL((void*)0);
struct got_diffreg_result *diffreg_result = NULL((void*)0);
int line_cur1 = 1, line_cur2 = 1, n = 0, nchunks_used = 0;
int have_content = 0, have_rejected_content = 0, i = 0, nchanges = 0;

*path_unstaged_content = NULL((void*)0);
*path_new_staged_content = NULL((void*)0);

err = got_object_id_str(&label1, blob_id);
if (err)
return err;
err = got_object_open_as_blob(&blob, repo, blob_id, 8192);
if (err)
goto done;

err = got_opentemp_named(&path1, &f1, "got-unstage-blob-base");
if (err)
goto done;

err = got_object_blob_dump_to_file(NULL((void*)0), NULL((void*)0), NULL((void*)0), f1, blob);
if (err)
goto done;

err = got_object_open_as_blob(&staged_blob, repo, staged_blob_id, 8192);
if (err)
goto done;

err = got_opentemp_named(&path2, &f2, "got-unstage-blob-staged");
if (err)
goto done;

err = got_object_blob_dump_to_file(NULL((void*)0), NULL((void*)0), NULL((void*)0), f2, staged_blob);
if (err)
goto done;

err = got_diff_files(&diffreg_result, f1, label1, f2,
   path2, 3, 0, 1, NULL((void*)0));
if (err)
goto done;

err = got_opentemp_named(path_unstaged_content, &outfile,
   "got-unstaged-content");
if (err)
goto done;
err = got_opentemp_named(path_new_staged_content, &rejectfile,
   "got-new-staged-content");
if (err)
goto done;

if (fseek(f1, 0L, SEEK_SET0) == -1) {
err = got_ferror(f1, GOT_ERR_IO6);
goto done;
}
if (fseek(f2, 0L, SEEK_SET0) == -1) {
err = got_ferror(f2, GOT_ERR_IO6);
goto done;
}
/* Count the number of actual changes in the diff result. */
for (n = 0; n < diffreg_result->result->chunks.len; n += nchunks_used) {
struct diff_chunk_context cc = {}; 
diff_chunk_context_load_change(&cc, &nchunks_used,
    diffreg_result->result, n, 0);
nchanges++;
}
for (n = 0; n < diffreg_result->result->chunks.len; n += nchunks_used) {
int choice;
err = apply_or_reject_change(&choice, &nchunks_used,
    diffreg_result->result, n, relpath, f1, f2,
    &line_cur1, &line_cur2,
    outfile, rejectfile, ++i, nchanges, patch_cb, patch_arg);
if (err)
	goto done;
if (choice == GOT_PATCH_CHOICE_YES1)
	have_content = 1;
else
	have_rejected_content = 1;
if (choice == GOT_PATCH_CHOICE_QUIT3)
	break;
}
if (have_content || have_rejected_content)
err = copy_remaining_content(f1, f2, &line_cur1, &line_cur2,
    outfile, rejectfile);
7654done:
free(label1);
if (blob)
got_object_blob_close(blob);
if (staged_blob)
got_object_blob_close(staged_blob);
free_err = got_diffreg_result_free(diffreg_result);
if (free_err && err == NULL((void*)0))
err = free_err;
if (f1 && fclose(f1) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", path1);
if (f2 && fclose(f2) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", path2);
if (outfile && fclose(outfile) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", *path_unstaged_content);
if (rejectfile && fclose(rejectfile) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", *path_new_staged_content);
if (path1 && unlink(path1) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("unlink", path1);
if (path2 && unlink(path2) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("unlink", path2);
if (err || !have_content) {
if (*path_unstaged_content &&
    unlink(*path_unstaged_content) == -1 && err == NULL((void*)0))
	err = got_error_from_errno2("unlink",
	    *path_unstaged_content);
free(*path_unstaged_content);
*path_unstaged_content = NULL((void*)0);
}
if (err || !have_content || !have_rejected_content) {
if (*path_new_staged_content &&
    unlink(*path_new_staged_content) == -1 && err == NULL((void*)0))
	err = got_error_from_errno2("unlink",
	    *path_new_staged_content);
free(*path_new_staged_content);
*path_new_staged_content = NULL((void*)0);
}
free(path1);
free(path2);
return err;
7694}

7696static const struct got_error *
7697unstage_hunks(struct got_object_id *staged_blob_id,
  struct got_blob_object *blob_base,
  struct got_object_id *blob_id, struct got_fileindex_entry *ie,
  const char *ondisk_path, const char *label_orig,
  struct got_worktree *worktree, struct got_repository *repo,
  got_worktree_patch_cb patch_cb, void *patch_arg,
  got_worktree_checkout_cb progress_cb, void *progress_arg)
7704{
const struct got_error *err = NULL((void*)0);
char *path_unstaged_content = NULL((void*)0);
char *path_new_staged_content = NULL((void*)0);
struct got_object_id *new_staged_blob_id = NULL((void*)0);
FILE *f = NULL((void*)0);
struct stat sb;

err = create_unstaged_content(&path_unstaged_content,
   &path_new_staged_content, blob_id, staged_blob_id,
   ie->path, repo, patch_cb, patch_arg);
if (err)
return err;

if (path_unstaged_content == NULL((void*)0))
return NULL((void*)0);

if (path_new_staged_content) {
err = got_object_blob_create(&new_staged_blob_id,
    path_new_staged_content, repo);
if (err)
	goto done;
}

f = fopen(path_unstaged_content, "r");
if (f == NULL((void*)0)) {
err = got_error_from_errno2("fopen",
    path_unstaged_content);
goto done;
}
if (fstat(fileno(f)(!__isthreaded ? ((f)->_file) : (fileno)(f)), &sb) == -1) {
err = got_error_from_errno2("fstat", path_unstaged_content);
goto done;
}
if (got_fileindex_entry_staged_filetype_get(ie) ==
   GOT_FILEIDX_MODE_SYMLINK2 && sb.st_size < PATH_MAX1024) {
char link_target[PATH_MAX1024];
size_t r;
r = fread(link_target, 1, sizeof(link_target), f);
if (r == 0 && ferror(f)(!__isthreaded ? (((f)->_flags & 0x0040) != 0) : (ferror
)(f))) {
	err = got_error_from_errno("fread");
	goto done;
}
if (r >= sizeof(link_target)) { /* should not happen */
	err = got_error(GOT_ERR_NO_SPACE9);
	goto done;
}
link_target[r] = '\0';
err = merge_symlink(worktree, blob_base,
    ondisk_path, ie->path, label_orig, link_target,
    worktree->base_commit_id, repo, progress_cb,
    progress_arg);
} else {
int local_changes_subsumed;
err = merge_file(&local_changes_subsumed, worktree,
    blob_base, ondisk_path, ie->path,
    got_fileindex_perms_to_st(ie),
    path_unstaged_content, label_orig, "unstaged",
    repo, progress_cb, progress_arg);
}
if (err)
goto done;

if (new_staged_blob_id) {
memcpy(ie->staged_blob_sha1, new_staged_blob_id->sha1,
    SHA1_DIGEST_LENGTH20);
} else {
got_fileindex_entry_stage_set(ie, GOT_FILEIDX_STAGE_NONE0);
got_fileindex_entry_staged_filetype_set(ie, 0);
}
7774done:
free(new_staged_blob_id);
if (path_unstaged_content &&
   unlink(path_unstaged_content) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("unlink", path_unstaged_content);
if (path_new_staged_content &&
   unlink(path_new_staged_content) == -1 && err == NULL((void*)0))
err = got_error_from_errno2("unlink", path_new_staged_content);
if (f && fclose(f) == EOF(-1) && err == NULL((void*)0))
err = got_error_from_errno2("fclose", path_unstaged_content);
free(path_unstaged_content);
free(path_new_staged_content);
return err;
7787}

7789static const struct got_error *
7790unstage_path(void *arg, unsigned char status,
  unsigned char staged_status, const char *relpath,
  struct got_object_id *blob_id, struct got_object_id *staged_blob_id,
  struct got_object_id *commit_id, int dirfd, const char *de_name)
7794{
const struct got_error *err = NULL((void*)0);
struct unstage_path_arg *a = arg;
struct got_fileindex_entry *ie;
struct got_blob_object *blob_base = NULL((void*)0), *blob_staged = NULL((void*)0);
char *ondisk_path = NULL((void*)0);
char *id_str = NULL((void*)0), *label_orig = NULL((void*)0);
int local_changes_subsumed;
struct stat sb;

if (staged_status != GOT_STATUS_ADD'A' &&
   staged_status != GOT_STATUS_MODIFY'M' &&
   staged_status != GOT_STATUS_DELETE'D')
return NULL((void*)0);

ie = got_fileindex_entry_get(a->fileindex, relpath, strlen(relpath));
if (ie == NULL((void*)0))
return got_error_path(relpath, GOT_ERR_FILE_STATUS68);

if (asprintf(&ondisk_path, "%s/%s", a->worktree->root_path, relpath)
   == -1)
return got_error_from_errno("asprintf");

err = got_object_id_str(&id_str,
   commit_id ? commit_id : a->worktree->base_commit_id);
if (err)
goto done;
if (asprintf(&label_orig, "%s: commit %s", GOT_MERGE_LABEL_BASE"3-way merge base",
   id_str) == -1) {
err = got_error_from_errno("asprintf");
goto done;
}

switch (staged_status) {
case GOT_STATUS_MODIFY'M':
err = got_object_open_as_blob(&blob_base, a->repo,
    blob_id, 8192);
if (err)
	break;
/* fall through */
case GOT_STATUS_ADD'A':
if (a->patch_cb) {
	if (staged_status == GOT_STATUS_ADD'A') {
		int choice = GOT_PATCH_CHOICE_NONE0;
		err = (*a->patch_cb)(&choice, a->patch_arg,
		    staged_status, ie->path, NULL((void*)0), 1, 1);
		if (err)
			break;
		if (choice != GOT_PATCH_CHOICE_YES1)
			break;
	} else {
		err = unstage_hunks(staged_blob_id,
		    blob_base, blob_id, ie, ondisk_path,
		    label_orig, a->worktree, a->repo,
		    a->patch_cb, a->patch_arg,
		    a->progress_cb, a->progress_arg);
		break; /* Done with this file. */
	}
}
err = got_object_open_as_blob(&blob_staged, a->repo,
    staged_blob_id, 8192);
if (err)
	break;
switch (got_fileindex_entry_staged_filetype_get(ie)) {
case GOT_FILEIDX_MODE_BAD_SYMLINK3:
case GOT_FILEIDX_MODE_REGULAR_FILE1:
	err = merge_blob(&local_changes_subsumed, a->worktree,
	    blob_base, ondisk_path, relpath,
	    got_fileindex_perms_to_st(ie), label_orig,
	    blob_staged, commit_id ? commit_id :
	    a->worktree->base_commit_id, a->repo,
	    a->progress_cb, a->progress_arg);
	break;
case GOT_FILEIDX_MODE_SYMLINK2:
	if (S_ISLNK(got_fileindex_perms_to_st(ie))((got_fileindex_perms_to_st(ie) & 0170000) == 0120000)) {
		char *staged_target;
		err = got_object_blob_read_to_str(
		    &staged_target, blob_staged);
		if (err)
			goto done;
		err = merge_symlink(a->worktree, blob_base,
		    ondisk_path, relpath, label_orig,
		    staged_target, commit_id ? commit_id :
		    a->worktree->base_commit_id,
		    a->repo, a->progress_cb, a->progress_arg);
		free(staged_target);
	} else {
		err = merge_blob(&local_changes_subsumed,
		    a->worktree, blob_base, ondisk_path,
		    relpath, got_fileindex_perms_to_st(ie),
		    label_orig, blob_staged,
		    commit_id ? commit_id :
		    a->worktree->base_commit_id, a->repo,
		    a->progress_cb, a->progress_arg);
	}
	break;
default:
	err = got_error_path(relpath, GOT_ERR_BAD_FILETYPE3);
	break;
}
if (err == NULL((void*)0)) {
	got_fileindex_entry_stage_set(ie,
	    GOT_FILEIDX_STAGE_NONE0);
	got_fileindex_entry_staged_filetype_set(ie, 0);
}
break;
case GOT_STATUS_DELETE'D':
if (a->patch_cb) {
	int choice = GOT_PATCH_CHOICE_NONE0;
	err = (*a->patch_cb)(&choice, a->patch_arg,
	    staged_status, ie->path, NULL((void*)0), 1, 1);
	if (err)
		break;
	if (choice == GOT_PATCH_CHOICE_NO2)
		break;
	if (choice != GOT_PATCH_CHOICE_YES1) {
		err = got_error(GOT_ERR_PATCH_CHOICE107);
		break;
	}
}
got_fileindex_entry_stage_set(ie, GOT_FILEIDX_STAGE_NONE0);
got_fileindex_entry_staged_filetype_set(ie, 0);
err = get_file_status(&status, &sb, ie, ondisk_path,
    dirfd, de_name, a->repo);
if (err)
	break;
err = (*a->progress_cb)(a->progress_arg, status, relpath);
break;
}
7923done:
free(ondisk_path);
if (blob_base)
got_object_blob_close(blob_base);
if (blob_staged)
got_object_blob_close(blob_staged);
free(id_str);
free(label_orig);
return err;
7932}

7934const struct got_error *
7935got_worktree_unstage(struct got_worktree *worktree,
  struct got_pathlist_head *paths,
  got_worktree_checkout_cb progress_cb, void *progress_arg,
  got_worktree_patch_cb patch_cb, void *patch_arg,
  struct got_repository *repo)
7940{
const struct got_error *err = NULL((void*)0), *sync_err, *unlockerr;
struct got_pathlist_entry *pe;
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct unstage_path_arg upa;

err = lock_worktree(worktree, LOCK_EX0x02);
if (err)
return err;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

upa.worktree = worktree;
upa.fileindex = fileindex;
upa.repo = repo;
upa.progress_cb = progress_cb;
upa.progress_arg = progress_arg;
upa.patch_cb = patch_cb;
upa.patch_arg = patch_arg;
TAILQ_FOREACH(pe, paths, entry)for((pe) = ((paths)->tqh_first); (pe) != ((void*)0); (pe) =
 ((pe)->entry.tqe_next)) {
err = worktree_status(worktree, pe->path, fileindex, repo,
    unstage_path, &upa, NULL((void*)0), NULL((void*)0), 0, 0);
if (err)
	goto done;
}

sync_err = sync_fileindex(fileindex, fileindex_path);
if (sync_err && err == NULL((void*)0))
err = sync_err;
7972done:
free(fileindex_path);
if (fileindex)
got_fileindex_free(fileindex);
unlockerr = lock_worktree(worktree, LOCK_SH0x01);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
7980}

7982struct report_file_info_arg {
struct got_worktree *worktree;
got_worktree_path_info_cb info_cb;
void *info_arg;
struct got_pathlist_head *paths;
got_cancel_cb cancel_cb;
void *cancel_arg;
7989};

7991static const struct got_error *
7992report_file_info(void *arg, struct got_fileindex_entry *ie)
7993{
struct report_file_info_arg *a = arg;
struct got_pathlist_entry *pe;
struct got_object_id blob_id, staged_blob_id, commit_id;
struct got_object_id *blob_idp = NULL((void*)0), *staged_blob_idp = NULL((void*)0);
struct got_object_id *commit_idp = NULL((void*)0);
int stage;

if (a->cancel_cb && a->cancel_cb(a->cancel_arg))
return got_error(GOT_ERR_CANCELLED49);

TAILQ_FOREACH(pe, a->paths, entry)for((pe) = ((a->paths)->tqh_first); (pe) != ((void*)0);
 (pe) = ((pe)->entry.tqe_next)) {
if (pe->path_len == 0 || strcmp(pe->path, ie->path) == 0 ||
    got_path_is_child(ie->path, pe->path, pe->path_len))
	break;
}
if (pe == NULL((void*)0)) /* not found */
return NULL((void*)0);

if (got_fileindex_entry_has_blob(ie)) {
memcpy(blob_id.sha1, ie->blob_sha1, SHA1_DIGEST_LENGTH20);
blob_idp = &blob_id;
}
stage = got_fileindex_entry_stage_get(ie);
if (stage == GOT_FILEIDX_STAGE_MODIFY1 ||
   stage == GOT_FILEIDX_STAGE_ADD2) {
memcpy(staged_blob_id.sha1, ie->staged_blob_sha1,
    SHA1_DIGEST_LENGTH20);
staged_blob_idp = &staged_blob_id;
}

if (got_fileindex_entry_has_commit(ie)) {
memcpy(commit_id.sha1, ie->commit_sha1, SHA1_DIGEST_LENGTH20);
commit_idp = &commit_id;
}

return a->info_cb(a->info_arg, ie->path, got_fileindex_perms_to_st(ie),
   (time_t)ie->mtime_sec, blob_idp, staged_blob_idp, commit_idp);
8031}

8033const struct got_error *
8034got_worktree_path_info(struct got_worktree *worktree,
  struct got_pathlist_head *paths,
  got_worktree_path_info_cb info_cb, void *info_arg,
  got_cancel_cb cancel_cb, void *cancel_arg)

8039{
const struct got_error *err = NULL((void*)0), *unlockerr;
struct got_fileindex *fileindex = NULL((void*)0);
char *fileindex_path = NULL((void*)0);
struct report_file_info_arg arg;

err = lock_worktree(worktree, LOCK_SH0x01);
if (err)
return err;

err = open_fileindex(&fileindex, &fileindex_path, worktree);
if (err)
goto done;

arg.worktree = worktree;
arg.info_cb = info_cb;
arg.info_arg = info_arg;
arg.paths = paths;
arg.cancel_cb = cancel_cb;
arg.cancel_arg = cancel_arg;
err = got_fileindex_for_each_entry_safe(fileindex, report_file_info,
   &arg);
8061done:
free(fileindex_path);
if (fileindex)
got_fileindex_free(fileindex);
unlockerr = lock_worktree(worktree, LOCK_UN0x08);
if (unlockerr && err == NULL((void*)0))
err = unlockerr;
return err;
8069}