| /* |
| * This file is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License, version 2, |
| * as published by the Free Software Foundation. |
| * |
| * In addition to the permissions in the GNU General Public License, |
| * the authors give you unlimited permission to link the compiled |
| * version of this file into combinations with other programs, |
| * and to distribute those combinations without any restriction |
| * coming from the use of this file. (The General Public License |
| * restrictions do apply in other respects; for example, they cover |
| * modification of the file, and distribution when not linked into |
| * a combined executable.) |
| * |
| * This file is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; see the file COPYING. If not, write to |
| * the Free Software Foundation, 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #include "common.h" |
| #include "git2.h" |
| #include "fileops.h" |
| #include "hash.h" |
| #include "vector.h" |
| #include "tree.h" |
| #include "git2/status.h" |
| |
| struct status_entry { |
| char path[GIT_PATH_MAX]; |
| |
| git_index_time mtime; |
| |
| git_oid head_oid; |
| git_oid index_oid; |
| git_oid wt_oid; |
| |
| unsigned int status_flags:6; |
| }; |
| |
| static int status_cmp(const void *a, const void *b) |
| { |
| const struct status_entry *entry_a = (const struct status_entry *)(a); |
| const struct status_entry *entry_b = (const struct status_entry *)(b); |
| |
| return strcmp(entry_a->path, entry_b->path); |
| } |
| |
| static int status_srch(const void *key, const void *array_member) |
| { |
| const char *path = (const char *)key; |
| const struct status_entry *entry = (const struct status_entry *)(array_member); |
| |
| return strcmp(path, entry->path); |
| } |
| |
| static int find_status_entry(git_vector *entries, const char *path) |
| { |
| return git_vector_bsearch2(entries, status_srch, path); |
| } |
| |
| static struct status_entry *new_status_entry(git_vector *entries, const char *path) |
| { |
| struct status_entry *e = git__malloc(sizeof(struct status_entry)); |
| memset(e, 0x0, sizeof(struct status_entry)); |
| if (entries != NULL) |
| git_vector_insert(entries, e); |
| strcpy(e->path, path); |
| return e; |
| } |
| |
| static void recurse_tree_entries(git_tree *tree, git_vector *entries, char *path) |
| { |
| int i, cnt, idx; |
| struct status_entry *e; |
| char file_path[GIT_PATH_MAX]; |
| git_tree *subtree; |
| |
| cnt = git_tree_entrycount(tree); |
| for (i = 0; i < cnt; ++i) { |
| const git_tree_entry *tree_entry = git_tree_entry_byindex(tree, i); |
| |
| git_path_join(file_path, path, tree_entry->filename); |
| |
| if (git_tree_lookup(&subtree, tree->object.repo, &tree_entry->oid) == GIT_SUCCESS) { |
| recurse_tree_entries(subtree, entries, file_path); |
| git_tree_close(subtree); |
| continue; |
| } |
| |
| if ((idx = find_status_entry(entries, file_path)) != GIT_ENOTFOUND) |
| e = (struct status_entry *)git_vector_get(entries, idx); |
| else |
| e = new_status_entry(entries, file_path); |
| |
| git_oid_cpy(&e->head_oid, &tree_entry->oid); |
| } |
| } |
| |
| static void recurse_tree_entry(git_tree *tree, struct status_entry *e, const char *path) |
| { |
| char *dir_sep; |
| char buffer[GIT_PATH_MAX]; |
| const git_tree_entry *tree_entry; |
| git_tree *subtree; |
| |
| strcpy(buffer, path); |
| |
| dir_sep = strchr(buffer, '/'); |
| if (dir_sep) { |
| *dir_sep = '\0'; |
| |
| tree_entry = git_tree_entry_byname(tree, buffer); |
| if (tree_entry != NULL) { |
| if (git_tree_lookup(&subtree, tree->object.repo, &tree_entry->oid) == GIT_SUCCESS) { |
| recurse_tree_entry(subtree, e, dir_sep+1); |
| git_tree_close(subtree); |
| return; |
| } |
| } |
| } |
| |
| tree_entry = git_tree_entry_byname(tree, path); |
| if (tree_entry != NULL) { |
| git_oid_cpy(&e->head_oid, &tree_entry->oid); |
| } |
| } |
| |
| struct status_st { |
| union { |
| git_vector *vector; |
| struct status_entry *e; |
| } entry; |
| |
| int workdir_path_len; |
| }; |
| |
| static int dirent_cb(void *state, char *full_path) |
| { |
| int idx; |
| struct status_entry *e; |
| struct status_st *st = (struct status_st *)state; |
| char *file_path = full_path + st->workdir_path_len; |
| struct stat filest; |
| git_oid oid; |
| |
| if ((git_futils_isdir(full_path) == GIT_SUCCESS) && (!strcmp(".git", file_path))) |
| return 0; |
| |
| if (git_futils_isdir(full_path) == GIT_SUCCESS) |
| return git_futils_direach(full_path, GIT_PATH_MAX, dirent_cb, state); |
| |
| if ((idx = find_status_entry(st->entry.vector, file_path)) != GIT_ENOTFOUND) { |
| e = (struct status_entry *)git_vector_get(st->entry.vector, idx); |
| |
| if (p_stat(full_path, &filest) < 0) |
| return git__throw(GIT_EOSERR, "Failed to read file %s", full_path); |
| |
| if (e->mtime.seconds == (git_time_t)filest.st_mtime) { |
| git_oid_cpy(&e->wt_oid, &e->index_oid); |
| return 0; |
| } |
| } else { |
| e = new_status_entry(st->entry.vector, file_path); |
| } |
| |
| git_odb_hashfile(&oid, full_path, GIT_OBJ_BLOB); |
| git_oid_cpy(&e->wt_oid, &oid); |
| |
| return 0; |
| } |
| |
| static int single_dirent_cb(void *state, char *full_path) |
| { |
| struct status_st *st = (struct status_st *)state; |
| struct status_entry *e = st->entry.e; |
| |
| char *file_path = full_path + st->workdir_path_len; |
| struct stat filest; |
| git_oid oid; |
| |
| if ((git_futils_isdir(full_path) == GIT_SUCCESS) && (!strcmp(".git", file_path))) |
| return 0; |
| |
| if (git_futils_isdir(full_path) == GIT_SUCCESS) |
| return git_futils_direach(full_path, GIT_PATH_MAX, single_dirent_cb, state); |
| |
| if (!strcmp(file_path, e->path)) { |
| if (p_stat(full_path, &filest) < 0) |
| return git__throw(GIT_EOSERR, "Failed to read file %s", full_path); |
| |
| if (e->mtime.seconds == (git_time_t)filest.st_mtime) { |
| git_oid_cpy(&e->wt_oid, &e->index_oid); |
| return 1; |
| } |
| |
| git_odb_hashfile(&oid, full_path, GIT_OBJ_BLOB); |
| git_oid_cpy(&e->wt_oid, &oid); |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| static int set_status_flags(struct status_entry *e) |
| { |
| git_oid zero; |
| int head_zero, index_zero, wt_zero; |
| |
| memset(&zero, 0x0, sizeof(git_oid)); |
| |
| head_zero = git_oid_cmp(&zero, &e->head_oid); |
| index_zero = git_oid_cmp(&zero, &e->index_oid); |
| wt_zero = git_oid_cmp(&zero, &e->wt_oid); |
| |
| if (head_zero == 0 && index_zero == 0 && wt_zero == 0) |
| return GIT_ENOTFOUND; |
| |
| if (head_zero == 0 && index_zero != 0) |
| e->status_flags |= GIT_STATUS_INDEX_NEW; |
| else if (index_zero == 0 && head_zero != 0) |
| e->status_flags |= GIT_STATUS_INDEX_DELETED; |
| else if (git_oid_cmp(&e->head_oid, &e->index_oid) != 0) |
| e->status_flags |= GIT_STATUS_INDEX_MODIFIED; |
| |
| if (index_zero == 0 && wt_zero != 0) |
| e->status_flags |= GIT_STATUS_WT_NEW; |
| else if (wt_zero == 0 && index_zero != 0) |
| e->status_flags |= GIT_STATUS_WT_DELETED; |
| else if (git_oid_cmp(&e->index_oid, &e->wt_oid) != 0) |
| e->status_flags |= GIT_STATUS_WT_MODIFIED; |
| |
| return GIT_SUCCESS; |
| } |
| |
| int git_status_foreach(git_repository *repo, int (*callback)(const char *, unsigned int, void *), void *payload) |
| { |
| git_vector entries; |
| struct status_entry *e; |
| git_index *index; |
| unsigned int i, cnt; |
| git_index_entry *index_entry; |
| char temp_path[GIT_PATH_MAX]; |
| int error; |
| git_tree *tree; |
| struct status_st dirent_st; |
| |
| git_reference *head_ref, *resolved_head_ref; |
| git_commit *head_commit; |
| |
| git_repository_index(&index, repo); |
| |
| cnt = git_index_entrycount(index); |
| git_vector_init(&entries, cnt, status_cmp); |
| for (i = 0; i < cnt; ++i) { |
| index_entry = git_index_get(index, i); |
| |
| e = new_status_entry(&entries, index_entry->path); |
| git_oid_cpy(&e->index_oid, &index_entry->oid); |
| e->mtime = index_entry->mtime; |
| } |
| git_index_free(index); |
| |
| git_reference_lookup(&head_ref, repo, GIT_HEAD_FILE); |
| git_reference_resolve(&resolved_head_ref, head_ref); |
| |
| git_commit_lookup(&head_commit, repo, git_reference_oid(resolved_head_ref)); |
| |
| // recurse through tree entries |
| git_commit_tree(&tree, head_commit); |
| recurse_tree_entries(tree, &entries, ""); |
| git_tree_close(tree); |
| git_commit_close(head_commit); |
| |
| dirent_st.workdir_path_len = strlen(repo->path_workdir); |
| dirent_st.entry.vector = &entries; |
| strcpy(temp_path, repo->path_workdir); |
| git_futils_direach(temp_path, GIT_PATH_MAX, dirent_cb, &dirent_st); |
| |
| for (i = 0; i < entries.length; ++i) { |
| e = (struct status_entry *)git_vector_get(&entries, i); |
| |
| set_status_flags(e); |
| } |
| |
| |
| for (i = 0; i < entries.length; ++i) { |
| e = (struct status_entry *)git_vector_get(&entries, i); |
| |
| if ((error = callback(e->path, e->status_flags, payload)) < GIT_SUCCESS) |
| return git__throw(error, "Failed to list statuses. User callback failed"); |
| } |
| |
| for (i = 0; i < entries.length; ++i) { |
| e = (struct status_entry *)git_vector_get(&entries, i); |
| free(e); |
| } |
| git_vector_free(&entries); |
| |
| return GIT_SUCCESS; |
| } |
| |
| int git_status_file(unsigned int *status_flags, git_repository *repo, const char *path) |
| { |
| struct status_entry *e; |
| git_index *index; |
| git_index_entry *index_entry; |
| char temp_path[GIT_PATH_MAX]; |
| int idx, error; |
| git_tree *tree; |
| git_reference *head_ref, *resolved_head_ref; |
| git_commit *head_commit; |
| struct status_st dirent_st; |
| |
| assert(status_flags); |
| |
| e = new_status_entry(NULL, path); |
| |
| // Find file in Index |
| git_repository_index(&index, repo); |
| idx = git_index_find(index, path); |
| if (idx >= 0) { |
| index_entry = git_index_get(index, idx); |
| git_oid_cpy(&e->index_oid, &index_entry->oid); |
| e->mtime = index_entry->mtime; |
| } |
| git_index_free(index); |
| |
| // Find file in HEAD |
| git_reference_lookup(&head_ref, repo, GIT_HEAD_FILE); |
| git_reference_resolve(&resolved_head_ref, head_ref); |
| |
| git_commit_lookup(&head_commit, repo, git_reference_oid(resolved_head_ref)); |
| |
| git_commit_tree(&tree, head_commit); |
| recurse_tree_entry(tree, e, path); |
| git_tree_close(tree); |
| git_commit_close(head_commit); |
| |
| // Find file in Workdir |
| dirent_st.workdir_path_len = strlen(repo->path_workdir); |
| dirent_st.entry.e = e; |
| strcpy(temp_path, repo->path_workdir); |
| git_futils_direach(temp_path, GIT_PATH_MAX, single_dirent_cb, &dirent_st); |
| |
| if ((error = set_status_flags(e)) < GIT_SUCCESS) { |
| free(e); |
| return git__throw(error, "Nonexistent file"); |
| } |
| |
| *status_flags = e->status_flags; |
| |
| free(e); |
| |
| return GIT_SUCCESS; |
| } |