rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/src/fileops.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 the libgit2 contributors
+ * Copyright (C) 2009-2012 the libgit2 contributors
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -10,190 +10,203 @@
 
 int git_futils_mkpath2file(const char *file_path, const mode_t mode)
 {
-	int error = GIT_SUCCESS;
-	char target_folder_path[GIT_PATH_MAX];
+	int result = 0;
+	git_buf target_folder = GIT_BUF_INIT;
 
-	error = git_path_dirname_r(target_folder_path, sizeof(target_folder_path), file_path);
-	if (error < GIT_SUCCESS)
-		return git__throw(GIT_EINVALIDPATH, "Failed to recursively build `%s` tree structure. Unable to parse parent folder name", file_path);
+	if (git_path_dirname_r(&target_folder, file_path) < 0)
+		return -1;
 
 	/* Does the containing folder exist? */
-	if (git_futils_isdir(target_folder_path)) {
-		git_path_join(target_folder_path, target_folder_path, ""); /* Ensure there's a trailing slash */
-
+	if (git_path_isdir(target_folder.ptr) == false)
 		/* Let's create the tree structure */
-		error = git_futils_mkdir_r(target_folder_path, mode);
-		if (error < GIT_SUCCESS)
-			return error;	/* The callee already takes care of setting the correct error message. */
-	}
+		result = git_futils_mkdir_r(target_folder.ptr, NULL, mode);
 
-	return GIT_SUCCESS;
+	git_buf_free(&target_folder);
+	return result;
 }
 
-int git_futils_mktmp(char *path_out, const char *filename)
+int git_futils_mktmp(git_buf *path_out, const char *filename)
 {
 	int fd;
 
-	strcpy(path_out, filename);
-	strcat(path_out, "_git2_XXXXXX");
+	git_buf_sets(path_out, filename);
+	git_buf_puts(path_out, "_git2_XXXXXX");
+
+	if (git_buf_oom(path_out))
+		return -1;
 
-	if ((fd = p_mkstemp(path_out)) < 0)
-		return git__throw(GIT_EOSERR, "Failed to create temporary file %s", path_out);
+	if ((fd = p_mkstemp(path_out->ptr)) < 0) {
+		giterr_set(GITERR_OS,
+			"Failed to create temporary file '%s'", path_out->ptr);
+		return -1;
+	}
 
 	return fd;
 }
 
 int git_futils_creat_withpath(const char *path, const mode_t dirmode, const mode_t mode)
 {
-	if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS)
-		return git__throw(GIT_EOSERR, "Failed to create file %s", path);
-
-	return p_creat(path, mode);
-}
+	int fd;
 
-int git_futils_creat_locked(const char *path, const mode_t mode)
-{
-	int fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode);
-	return fd >= 0 ? fd : git__throw(GIT_EOSERR, "Failed to create locked file. Could not open %s", path);
-}
+	if (git_futils_mkpath2file(path, dirmode) < 0)
+		return -1;
 
-int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode)
-{
-	if (git_futils_mkpath2file(path, dirmode) < GIT_SUCCESS)
-		return git__throw(GIT_EOSERR, "Failed to create locked file %s", path);
+	fd = p_creat(path, mode);
+	if (fd < 0) {
+		giterr_set(GITERR_OS, "Failed to create file '%s'", path);
+		return -1;
+	}
 
-	return git_futils_creat_locked(path, mode);
+	return fd;
 }
 
-int git_futils_isdir(const char *path)
+int git_futils_creat_locked(const char *path, const mode_t mode)
 {
-#ifdef GIT_WIN32
-	DWORD attr = GetFileAttributes(path);
-	if (attr == INVALID_FILE_ATTRIBUTES)
-		return GIT_ERROR;
+	int fd;
 
-	return (attr & FILE_ATTRIBUTE_DIRECTORY) ? GIT_SUCCESS : GIT_ERROR;
+#ifdef GIT_WIN32
+	wchar_t* buf;
 
+	buf = gitwin_to_utf16(path);
+	fd = _wopen(buf, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode);
+	git__free(buf);
 #else
-	struct stat st;
-	if (p_stat(path, &st) < GIT_SUCCESS)
-		return GIT_ERROR;
-
-	return S_ISDIR(st.st_mode) ? GIT_SUCCESS : GIT_ERROR;
+	fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode);
 #endif
-}
 
-int git_futils_isfile(const char *path)
-{
-	struct stat st;
-	int stat_error;
-
-	assert(path);
-	stat_error = p_stat(path, &st);
-
-	if (stat_error < GIT_SUCCESS)
+	if (fd < 0) {
+		giterr_set(GITERR_OS, "Failed to create locked file '%s'", path);
 		return -1;
+	}
 
-	if (!S_ISREG(st.st_mode))
+	return fd;
+}
+
+int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode)
+{
+	if (git_futils_mkpath2file(path, dirmode) < 0)
 		return -1;
 
-	return 0;
+	return git_futils_creat_locked(path, mode);
 }
 
-int git_futils_exists(const char *path)
+int git_futils_open_ro(const char *path)
 {
-	assert(path);
-	return p_access(path, F_OK);
+	int fd = p_open(path, O_RDONLY);
+	if (fd < 0) {
+		if (errno == ENOENT)
+			fd = GIT_ENOTFOUND;
+		giterr_set(GITERR_OS, "Failed to open '%s'", path);
+	}
+	return fd;
 }
 
 git_off_t git_futils_filesize(git_file fd)
 {
 	struct stat sb;
-	if (p_fstat(fd, &sb))
-		return GIT_ERROR;
+
+	if (p_fstat(fd, &sb)) {
+		giterr_set(GITERR_OS, "Failed to stat file descriptor");
+		return -1;
+	}
 
 	return sb.st_size;
 }
 
-int git_futils_readbuffer_updated(git_fbuffer *obj, const char *path, time_t *mtime, int *updated)
+mode_t git_futils_canonical_mode(mode_t raw_mode)
+{
+	if (S_ISREG(raw_mode))
+		return S_IFREG | GIT_CANONICAL_PERMS(raw_mode);
+	else if (S_ISLNK(raw_mode))
+		return S_IFLNK;
+	else if (S_ISGITLINK(raw_mode))
+		return S_IFGITLINK;
+	else if (S_ISDIR(raw_mode))
+		return S_IFDIR;
+	else
+		return 0;
+}
+
+int git_futils_readbuffer_updated(git_buf *buf, const char *path, time_t *mtime, int *updated)
 {
 	git_file fd;
 	size_t len;
 	struct stat st;
-	unsigned char *buff;
 
-	assert(obj && path && *path);
+	assert(buf && path && *path);
 
 	if (updated != NULL)
 		*updated = 0;
 
-	if (p_stat(path, &st) < 0)
-		return git__throw(GIT_ENOTFOUND, "Failed to stat file %s", path);
+	if ((fd = git_futils_open_ro(path)) < 0)
+		return fd;
 
-	if (S_ISDIR(st.st_mode))
-		return git__throw(GIT_ERROR, "Can't read a dir into a buffer");
+	if (p_fstat(fd, &st) < 0 || S_ISDIR(st.st_mode) || !git__is_sizet(st.st_size+1)) {
+		p_close(fd);
+		giterr_set(GITERR_OS, "Invalid regular file stat for '%s'", path);
+		return -1;
+	}
 
 	/*
 	 * If we were given a time, we only want to read the file if it
 	 * has been modified.
 	 */
-	if (mtime != NULL && *mtime >= st.st_mtime)
-		return GIT_SUCCESS;
+	if (mtime != NULL && *mtime >= st.st_mtime) {
+		p_close(fd);
+		return 0;
+	}
 
 	if (mtime != NULL)
 		*mtime = st.st_mtime;
-	if (!git__is_sizet(st.st_size+1))
-		return git__throw(GIT_ERROR, "Failed to read file `%s`. An error occured while calculating its size", path);
 
 	len = (size_t) st.st_size;
 
-	if ((fd = p_open(path, O_RDONLY)) < 0)
-		return git__throw(GIT_EOSERR, "Failed to open %s for reading", path);
+	git_buf_clear(buf);
 
-	if ((buff = git__malloc(len + 1)) == NULL) {
+	if (git_buf_grow(buf, len + 1) < 0) {
 		p_close(fd);
-		return GIT_ENOMEM;
+		return -1;
 	}
 
-	if (p_read(fd, buff, len) < 0) {
-		p_close(fd);
-		git__free(buff);
-		return git__throw(GIT_ERROR, "Failed to read file `%s`", path);
+	buf->ptr[len] = '\0';
+
+	while (len > 0) {
+		ssize_t read_size = p_read(fd, buf->ptr, len);
+
+		if (read_size < 0) {
+			p_close(fd);
+			giterr_set(GITERR_OS, "Failed to read descriptor for '%s'", path);
+			return -1;
+		}
+
+		len -= read_size;
+		buf->size += read_size;
 	}
-	buff[len] = '\0';
 
 	p_close(fd);
 
-	if (mtime != NULL)
-		*mtime = st.st_mtime;
 	if (updated != NULL)
 		*updated = 1;
 
-	obj->data = buff;
-	obj->len = len;
-
-	return GIT_SUCCESS;
-}
-
-int git_futils_readbuffer(git_fbuffer *obj, const char *path)
-{
-	return git_futils_readbuffer_updated(obj, path, NULL, NULL);
+	return 0;
 }
 
-void git_futils_freebuffer(git_fbuffer *obj)
+int git_futils_readbuffer(git_buf *buf, const char *path)
 {
-	assert(obj);
-	git__free(obj->data);
-	obj->data = NULL;
+	return git_futils_readbuffer_updated(buf, path, NULL, NULL);
 }
 
-
 int git_futils_mv_withpath(const char *from, const char *to, const mode_t dirmode)
 {
-	if (git_futils_mkpath2file(to, dirmode) < GIT_SUCCESS)
-		return GIT_EOSERR;	/* The callee already takes care of setting the correct error message. */
+	if (git_futils_mkpath2file(to, dirmode) < 0)
+		return -1;
 
-	return p_rename(from, to); /* The callee already takes care of setting the correct error message. */
+	if (p_rename(from, to) < 0) {
+		giterr_set(GITERR_OS, "Failed to rename '%s' to '%s'", from, to);
+		return -1;
+	}
+
+	return 0;
 }
 
 int git_futils_mmap_ro(git_map *out, git_file fd, git_off_t begin, size_t len)
@@ -201,158 +214,269 @@ int git_futils_mmap_ro(git_map *out, git_file fd, git_off_t begin, size_t len)
 	return p_mmap(out, len, GIT_PROT_READ, GIT_MAP_SHARED, fd, begin);
 }
 
-void git_futils_mmap_free(git_map *out)
+int git_futils_mmap_ro_file(git_map *out, const char *path)
 {
-	p_munmap(out);
+	git_file fd = git_futils_open_ro(path);
+	git_off_t len;
+	int result;
+
+	if (fd < 0)
+		return fd;
+
+	len = git_futils_filesize(fd);
+	if (!git__is_sizet(len)) {
+		giterr_set(GITERR_OS, "File `%s` too large to mmap", path);
+		return -1;
+	}
+
+	result = git_futils_mmap_ro(out, fd, 0, (size_t)len);
+	p_close(fd);
+	return result;
 }
 
-/* Taken from git.git */
-GIT_INLINE(int) is_dot_or_dotdot(const char *name)
+void git_futils_mmap_free(git_map *out)
 {
-	return (name[0] == '.' &&
-		(name[1] == '\0' ||
-		 (name[1] == '.' && name[2] == '\0')));
+	p_munmap(out);
 }
 
-int git_futils_direach(
-	char *path,
-	size_t path_sz,
-	int (*fn)(void *, char *),
-	void *arg)
+int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
 {
-	size_t wd_len = strlen(path);
-	DIR *dir;
-	struct dirent *de;
+	git_buf make_path = GIT_BUF_INIT;
+	size_t start = 0;
+	char *pp, *sp;
+	bool failed = false;
+
+	if (base != NULL) {
+		/*
+		 * when a base is being provided, it is supposed to already exist.
+		 * Therefore, no attempt is being made to recursively create this leading path
+		 * segment. It's just skipped. */
+		start = strlen(base);
+		if (git_buf_joinpath(&make_path, base, path) < 0)
+			return -1;
+	} else {
+		int root_path_offset;
+
+		if (git_buf_puts(&make_path, path) < 0)
+			return -1;
+
+		root_path_offset = git_path_root(make_path.ptr);
+		if (root_path_offset > 0) {
+			 /*
+			  * On Windows, will skip the drive name (eg. C: or D:)
+			  * or the leading part of a network path (eg. //computer_name ) */
+			start = root_path_offset;
+		}
+	}
 
-	if (!wd_len || path_sz < wd_len + 2)
-		return git__throw(GIT_EINVALIDARGS, "Failed to process `%s` tree structure. Path is either empty or buffer size is too short", path);
+	pp = make_path.ptr + start;
 
-	while (path[wd_len - 1] == '/')
-		wd_len--;
-	path[wd_len++] = '/';
-	path[wd_len] = '\0';
+	while (!failed && (sp = strchr(pp, '/')) != NULL) {
+		if (sp != pp && git_path_isdir(make_path.ptr) == false) {
+			*sp = 0;
 
-	dir = opendir(path);
-	if (!dir)
-		return git__throw(GIT_EOSERR, "Failed to process `%s` tree structure. An error occured while opening the directory", path);
+			/* Do not choke while trying to recreate an existing directory */
+			if (p_mkdir(make_path.ptr, mode) < 0 && errno != EEXIST)
+				failed = true;
 
-	while ((de = readdir(dir)) != NULL) {
-		size_t de_len;
-		int result;
+			*sp = '/';
+		}
 
-		if (is_dot_or_dotdot(de->d_name))
-			continue;
+		pp = sp + 1;
+	}
 
-		de_len = strlen(de->d_name);
-		if (path_sz < wd_len + de_len + 1) {
-			closedir(dir);
-			return git__throw(GIT_ERROR, "Failed to process `%s` tree structure. Buffer size is too short", path);
-		}
+	if (*pp != '\0' && !failed) {
+		if (p_mkdir(make_path.ptr, mode) < 0 && errno != EEXIST)
+			failed = true;
+	}
 
-		strcpy(path + wd_len, de->d_name);
-		result = fn(arg, path);
-		if (result < GIT_SUCCESS) {
-			closedir(dir);
-			return result;	/* The callee is reponsible for setting the correct error message */
-		}
-		if (result > 0) {
-			closedir(dir);
-			return result;
-		}
+	git_buf_free(&make_path);
+
+	if (failed) {
+		giterr_set(GITERR_OS,
+			"Failed to create directory structure at '%s'", path);
+		return -1;
 	}
 
-	closedir(dir);
-	return GIT_SUCCESS;
+	return 0;
 }
 
-int git_futils_mkdir_r(const char *path, const mode_t mode)
+static int _rmdir_recurs_foreach(void *opaque, git_buf *path)
 {
-	int error, root_path_offset;
-	char *pp, *sp;
-	char *path_copy = git__strdup(path);
+	git_directory_removal_type removal_type = *(git_directory_removal_type *)opaque;
 
-	if (path_copy == NULL)
-		return GIT_ENOMEM;
+	assert(removal_type == GIT_DIRREMOVAL_EMPTY_HIERARCHY
+		|| removal_type == GIT_DIRREMOVAL_FILES_AND_DIRS
+		|| removal_type == GIT_DIRREMOVAL_ONLY_EMPTY_DIRS);
 
-	error = GIT_SUCCESS;
-	pp = path_copy;
+	if (git_path_isdir(path->ptr) == true) {
+		if (git_path_direach(path, _rmdir_recurs_foreach, opaque) < 0)
+			return -1;
 
-	root_path_offset = git_path_root(pp);
-	if (root_path_offset > 0)
-		pp += root_path_offset; /* On Windows, will skip the drive name (eg. C: or D:) */
+		if (p_rmdir(path->ptr) < 0) {
+			if (removal_type == GIT_DIRREMOVAL_ONLY_EMPTY_DIRS && (errno == ENOTEMPTY || errno == EEXIST))
+				return 0;
 
-	while (error == GIT_SUCCESS && (sp = strchr(pp, '/')) != NULL) {
-		if (sp != pp && git_futils_isdir(path_copy) < GIT_SUCCESS) {
-			*sp = 0;
-			error = p_mkdir(path_copy, mode);
+			giterr_set(GITERR_OS, "Could not remove directory '%s'", path->ptr);
+			return -1;
+		}
 
-			/* Do not choke while trying to recreate an existing directory */
-			if (errno == EEXIST)
-				error = GIT_SUCCESS;
+		return 0;
+	}
 
-			*sp = '/';
+	if (removal_type == GIT_DIRREMOVAL_FILES_AND_DIRS) {
+		if (p_unlink(path->ptr) < 0) {
+			giterr_set(GITERR_OS, "Could not remove directory.  File '%s' cannot be removed", path->ptr);
+			return -1;
 		}
 
-		pp = sp + 1;
+		return 0;
 	}
 
-	if (*pp != '\0' && error == GIT_SUCCESS) {
-		error = p_mkdir(path, mode);
-		if (errno == EEXIST)
-			error = GIT_SUCCESS;
+	if (removal_type == GIT_DIRREMOVAL_EMPTY_HIERARCHY) {
+		giterr_set(GITERR_OS, "Could not remove directory. File '%s' still present", path->ptr);
+		return -1;
 	}
 
-	git__free(path_copy);
+	return 0;
+}
 
-	if (error < GIT_SUCCESS)
-		return git__throw(error, "Failed to recursively create `%s` tree structure", path);
+int git_futils_rmdir_r(const char *path, git_directory_removal_type removal_type)
+{
+	int error;
+	git_buf p = GIT_BUF_INIT;
+
+	error = git_buf_sets(&p, path);
+	if (!error)
+		error = _rmdir_recurs_foreach(&removal_type, &p);
+	git_buf_free(&p);
+	return error;
+}
 
-	return GIT_SUCCESS;
+#ifdef GIT_WIN32
+struct win32_path {
+	wchar_t path[MAX_PATH];
+	DWORD len;
+};
+
+static int win32_expand_path(struct win32_path *s_root, const wchar_t *templ)
+{
+	s_root->len = ExpandEnvironmentStringsW(templ, s_root->path, MAX_PATH);
+	return s_root->len ? 0 : -1;
 }
 
-static int _rmdir_recurs_foreach(void *opaque, char *path)
+static int win32_find_file(git_buf *path, const struct win32_path *root, const char *filename)
 {
-	int error = GIT_SUCCESS;
-	int force = *(int *)opaque;
+	int error = 0;
+	size_t len;
+	wchar_t *file_utf16 = NULL;
+	char *file_utf8 = NULL;
+
+	if (!root || !filename || (len = strlen(filename)) == 0)
+		return GIT_ENOTFOUND;
 
-	if (git_futils_isdir(path) == GIT_SUCCESS) {
-		size_t root_size = strlen(path);
+	/* allocate space for wchar_t path to file */
+	file_utf16 = git__calloc(root->len + len + 2, sizeof(wchar_t));
+	GITERR_CHECK_ALLOC(file_utf16);
 
-		if ((error = git_futils_direach(path, GIT_PATH_MAX, _rmdir_recurs_foreach, opaque)) < GIT_SUCCESS)
-			return git__rethrow(error, "Failed to remove directory `%s`", path);
+	/* append root + '\\' + filename as wchar_t */
+	memcpy(file_utf16, root->path, root->len * sizeof(wchar_t));
 
-		path[root_size] = '\0';
-		return p_rmdir(path);
+	if (*filename == '/' || *filename == '\\')
+		filename++;
 
-	} else if (force) {
-		return p_unlink(path);
+	if (gitwin_append_utf16(file_utf16 + root->len - 1, filename, len + 1) !=
+		(int)len + 1) {
+		error = -1;
+		goto cleanup;
 	}
 
-	return git__rethrow(error, "Failed to remove directory. `%s` is not empty", path);
+	/* check access */
+	if (_waccess(file_utf16, F_OK) < 0) {
+		error = GIT_ENOTFOUND;
+		goto cleanup;
+	}
+
+	/* convert to utf8 */
+	if ((file_utf8 = gitwin_from_utf16(file_utf16)) == NULL)
+		error = -1;
+	else {
+		git_path_mkposix(file_utf8);
+		git_buf_attach(path, file_utf8, 0);
+	}
+
+cleanup:
+	git__free(file_utf16);
+	return error;
 }
+#endif
 
-int git_futils_rmdir_r(const char *path, int force)
+int git_futils_find_system_file(git_buf *path, const char *filename)
 {
-	char p[GIT_PATH_MAX];
-	strncpy(p, path, GIT_PATH_MAX);
-	return _rmdir_recurs_foreach(&force, p);
+#ifdef GIT_WIN32
+	struct win32_path root;
+
+	if (win32_expand_path(&root, L"%PROGRAMFILES%\\Git\\etc\\") < 0 ||
+		root.path[0] == L'%') /* i.e. no expansion happened */
+	{
+		giterr_set(GITERR_OS, "Cannot locate the system's Program Files directory");
+		return -1;
+	}
+
+	if (win32_find_file(path, &root, filename) < 0) {
+		git_buf_clear(path);
+		return GIT_ENOTFOUND;
+	}
+
+	return 0;
+
+#else
+	if (git_buf_joinpath(path, "/etc", filename) < 0)
+		return -1;
+
+	if (git_path_exists(path->ptr) == true)
+		return 0;
+
+	git_buf_clear(path);
+	return GIT_ENOTFOUND;
+#endif
 }
 
-int git_futils_cmp_path(const char *name1, int len1, int isdir1,
-		const char *name2, int len2, int isdir2)
+int git_futils_find_global_file(git_buf *path, const char *filename)
 {
-	int len = len1 < len2 ? len1 : len2;
-	int cmp;
-
-	cmp = memcmp(name1, name2, len);
-	if (cmp)
-		return cmp;
-	if (len1 < len2)
-		return ((!isdir1 && !isdir2) ? -1 :
-						(isdir1 ? '/' - name2[len1] : name2[len1] - '/'));
-	if (len1 > len2)
-		return ((!isdir1 && !isdir2) ? 1 :
-						(isdir2 ? name1[len2] - '/' : '/' - name1[len2]));
+#ifdef GIT_WIN32
+	struct win32_path root;
+
+	if (win32_expand_path(&root, L"%USERPROFILE%\\") < 0 ||
+		root.path[0] == L'%') /* i.e. no expansion happened */
+	{
+		giterr_set(GITERR_OS, "Cannot locate the user's profile directory");
+		return -1;
+	}
+
+	if (win32_find_file(path, &root, filename) < 0) {
+		git_buf_clear(path);
+		return GIT_ENOTFOUND;
+	}
+
 	return 0;
-}
+#else
+	const char *home = getenv("HOME");
 
+	if (home == NULL) {
+		giterr_set(GITERR_OS, "Global file lookup failed. "
+			"Cannot locate the user's home directory");
+		return -1;
+	}
+
+	if (git_buf_joinpath(path, home, filename) < 0)
+		return -1;
+
+	if (git_path_exists(path->ptr) == false) {
+		git_buf_clear(path);
+		return GIT_ENOTFOUND;
+	}
+
+	return 0;
+#endif
+}