rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/win32/fnmatch.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2009-2011 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.
+ */
+#ifndef INCLUDE_fnmatch__w32_h__
+#define INCLUDE_fnmatch__w32_h__
+
+#include "common.h"
+
+#define FNM_NOMATCH		1		/* Match failed. */
+#define FNM_NOSYS		2		/* Function not supported (unused). */
+
+#define FNM_NOESCAPE		0x01		/* Disable backslash escaping. */
+#define FNM_PATHNAME		0x02		/* Slash must be matched by slash. */
+#define FNM_PERIOD		0x04		/* Period must be matched by period. */
+#define FNM_LEADING_DIR 0x08		/* Ignore /<tail> after Imatch. */
+#define FNM_CASEFOLD		0x10		/* Case insensitive search. */
+
+#define FNM_IGNORECASE	FNM_CASEFOLD
+#define FNM_FILE_NAME	FNM_PATHNAME
+
+extern int p_fnmatch(const char *pattern, const char *string, int flags);
+
+#endif /* _FNMATCH_H */
+

data/ext/rugged/vendor/libgit2-dist/src/win32/map.c

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2009-2011 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.
+ */
+
+#include "map.h"
+#include <errno.h>
+
+
+static DWORD get_page_size(void)
+{
+	static DWORD page_size;
+	SYSTEM_INFO sys;
+
+	if (!page_size) {
+		GetSystemInfo(&sys);
+		page_size = sys.dwAllocationGranularity;
+	}
+
+	return page_size;
+}
+
+int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
+{
+	HANDLE fh = (HANDLE)_get_osfhandle(fd);
+	DWORD page_size = get_page_size();
+	DWORD fmap_prot = 0;
+	DWORD view_prot = 0;
+	DWORD off_low = 0;
+	DWORD off_hi = 0;
+	git_off_t page_start;
+	git_off_t page_offset;
+
+	assert((out != NULL) && (len > 0));
+
+	if ((out == NULL) || (len == 0)) {
+		errno = EINVAL;
+		return git__throw(GIT_ERROR, "Failed to mmap. No map or zero length");
+	}
+
+	out->data = NULL;
+	out->len = 0;
+	out->fmh = NULL;
+
+	if (fh == INVALID_HANDLE_VALUE) {
+		errno = EBADF;
+		return git__throw(GIT_ERROR, "Failed to mmap. Invalid handle value");
+	}
+
+	if (prot & GIT_PROT_WRITE)
+		fmap_prot |= PAGE_READWRITE;
+	else if (prot & GIT_PROT_READ)
+		fmap_prot |= PAGE_READONLY;
+	else {
+		errno = EINVAL;
+		return git__throw(GIT_ERROR, "Failed to mmap. Invalid protection parameters");
+	}
+
+	if (prot & GIT_PROT_WRITE)
+		view_prot |= FILE_MAP_WRITE;
+	if (prot & GIT_PROT_READ)
+		view_prot |= FILE_MAP_READ;
+
+	if (flags & GIT_MAP_FIXED) {
+		errno = EINVAL;
+		return git__throw(GIT_ERROR, "Failed to mmap. FIXED not set");
+	}
+
+	page_start = (offset / page_size) * page_size;
+	page_offset = offset - page_start;
+
+	if (page_offset != 0) { /* offset must be multiple of page size */
+		errno = EINVAL;
+		return git__throw(GIT_ERROR, "Failed to mmap. Offset must be multiple of page size");
+	}
+
+	out->fmh = CreateFileMapping(fh, NULL, fmap_prot, 0, 0, NULL);
+	if (!out->fmh || out->fmh == INVALID_HANDLE_VALUE) {
+		/* errno = ? */
+		out->fmh = NULL;
+		return git__throw(GIT_ERROR, "Failed to mmap. Invalid handle value");
+	}
+
+	assert(sizeof(git_off_t) == 8);
+	off_low = (DWORD)(page_start);
+	off_hi = (DWORD)(page_start >> 32);
+	out->data = MapViewOfFile(out->fmh, view_prot, off_hi, off_low, len);
+	if (!out->data) {
+		/* errno = ? */
+		CloseHandle(out->fmh);
+		out->fmh = NULL;
+		return git__throw(GIT_ERROR, "Failed to mmap. No data written");
+	}
+	out->len = len;
+
+	return GIT_SUCCESS;
+}
+
+int p_munmap(git_map *map)
+{
+	assert(map != NULL);
+
+	if (!map)
+		return git__throw(GIT_ERROR, "Failed to munmap. Map does not exist");
+
+	if (map->data) {
+		if (!UnmapViewOfFile(map->data)) {
+			/* errno = ? */
+			CloseHandle(map->fmh);
+			map->data = NULL;
+			map->fmh = NULL;
+			return git__throw(GIT_ERROR, "Failed to munmap. Could not unmap view of file");
+		}
+		map->data = NULL;
+	}
+
+	if (map->fmh) {
+		if (!CloseHandle(map->fmh)) {
+			/* errno = ? */
+			map->fmh = NULL;
+			return git__throw(GIT_ERROR, "Failed to munmap. Could not close handle");
+		}
+		map->fmh = NULL;
+	}
+
+	return GIT_SUCCESS;
+}
+
+

data/ext/rugged/vendor/libgit2-dist/src/win32/mingw-compat.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2009-2011 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.
+ */
+#ifndef INCLUDE_mingw_compat__
+#define INCLUDE_mingw_compat__
+
+#if defined(__MINGW32__)
+
+/* use a 64-bit file offset type */
+# define lseek _lseeki64
+# define stat _stati64
+# define fstat _fstati64
+
+/* stat: file mode type testing macros */
+# define _S_IFLNK 0120000
+# define S_IFLNK _S_IFLNK
+# define S_ISLNK(m) (((m) & _S_IFMT) == _S_IFLNK)
+
+#endif
+
+#endif /* INCLUDE_mingw_compat__ */

data/ext/rugged/vendor/libgit2-dist/src/win32/msvc-compat.h

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2009-2011 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.
+ */
+#ifndef INCLUDE_msvc_compat__
+#define INCLUDE_msvc_compat__
+
+#if defined(_MSC_VER)
+
+/* access() mode parameter #defines	*/
+#	define F_OK 0 /* existence check */
+#	define W_OK 2 /* write mode check */
+#	define R_OK 4 /* read mode check */
+
+#	define lseek _lseeki64
+#	define stat _stat64
+#	define fstat _fstat64
+
+/* stat: file mode type testing macros */
+#	define _S_IFLNK 0120000
+#	define S_IFLNK _S_IFLNK
+
+#	define S_ISDIR(m)	(((m) & _S_IFMT) == _S_IFDIR)
+#	define S_ISREG(m)	(((m) & _S_IFMT) == _S_IFREG)
+#	define S_ISFIFO(m) (((m) & _S_IFMT) == _S_IFIFO)
+#	define S_ISLNK(m) (((m) & _S_IFMT) == _S_IFLNK)
+
+#	define mode_t unsigned short
+
+/* case-insensitive string comparison */
+#	define strcasecmp	_stricmp
+#	define strncasecmp _strnicmp
+
+#endif
+
+#endif /* INCLUDE_msvc_compat__ */

data/ext/rugged/vendor/libgit2-dist/src/win32/posix.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2009-2011 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.
+ */
+#ifndef INCLUDE_posix__w32_h__
+#define INCLUDE_posix__w32_h__
+
+#include "common.h"
+#include "fnmatch.h"
+#include "utf-conv.h"
+
+GIT_INLINE(int) p_link(const char *GIT_UNUSED(old), const char *GIT_UNUSED(new))
+{
+	GIT_UNUSED_ARG(old)
+	GIT_UNUSED_ARG(new)
+	errno = ENOSYS;
+	return -1;
+}
+
+GIT_INLINE(int) p_mkdir(const char *path, mode_t GIT_UNUSED(mode))
+{
+	wchar_t* buf = gitwin_to_utf16(path);
+	int ret = _wmkdir(buf);
+
+	GIT_UNUSED_ARG(mode)
+
+	git__free(buf);
+	return ret;
+}
+
+extern int p_unlink(const char *path);
+extern int p_lstat(const char *file_name, struct stat *buf);
+extern int p_readlink(const char *link, char *target, size_t target_len);
+extern int p_hide_directory__w32(const char *path);
+extern char *p_realpath(const char *orig_path, char *buffer);
+extern int p_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr);
+extern int p_snprintf(char *buffer, size_t count, const char *format, ...) GIT_FORMAT_PRINTF(3, 4);
+extern int p_mkstemp(char *tmp_path);
+extern int p_setenv(const char* name, const char* value, int overwrite);
+extern int p_stat(const char* path, struct stat* buf);
+extern int p_chdir(const char* path);
+extern int p_chmod(const char* path, mode_t mode);
+extern int p_rmdir(const char* path);
+extern int p_access(const char* path, mode_t mode);
+extern int p_fsync(int fd);
+extern int p_open(const char *path, int flags);
+extern int p_creat(const char *path, mode_t mode);
+extern int p_getcwd(char *buffer_out, size_t size);
+extern int p_rename(const char *from, const char *to);
+
+#endif

data/ext/rugged/vendor/libgit2-dist/src/win32/posix_w32.c

@@ -0,0 +1,404 @@
+/*
+ * Copyright (C) 2009-2011 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.
+ */
+#include "posix.h"
+#include "path.h"
+#include "utf-conv.h"
+#include <errno.h>
+#include <io.h>
+#include <fcntl.h>
+
+
+int p_unlink(const char *path)
+{
+	int ret = 0;
+	wchar_t* buf;
+
+	buf = gitwin_to_utf16(path);
+	_wchmod(buf, 0666);
+	ret = _wunlink(buf);
+	git__free(buf);
+
+	return ret;
+}
+
+int p_fsync(int fd)
+{
+	HANDLE fh = (HANDLE)_get_osfhandle(fd);
+
+	if (fh == INVALID_HANDLE_VALUE) {
+		errno = EBADF;
+		return -1;
+	}
+
+	if (!FlushFileBuffers(fh)) {
+		DWORD code = GetLastError();
+
+		if (code == ERROR_INVALID_HANDLE)
+			errno = EINVAL;
+		else
+			errno = EIO;
+
+		return -1;
+	}
+
+	return 0;
+}
+
+GIT_INLINE(time_t) filetime_to_time_t(const FILETIME *ft)
+{
+	long long winTime = ((long long)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
+	winTime -= 116444736000000000LL; /* Windows to Unix Epoch conversion */
+	winTime /= 10000000;		 /* Nano to seconds resolution */
+	return (time_t)winTime;
+}
+
+static int do_lstat(const char *file_name, struct stat *buf)
+{
+	WIN32_FILE_ATTRIBUTE_DATA fdata;
+	wchar_t* fbuf = gitwin_to_utf16(file_name);
+
+	if (GetFileAttributesExW(fbuf, GetFileExInfoStandard, &fdata)) {
+		int fMode = S_IREAD;
+
+		if (fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+			fMode |= S_IFDIR;
+		else
+			fMode |= S_IFREG;
+
+		if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
+			fMode |= S_IWRITE;
+
+		if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
+			fMode |= S_IFLNK;
+
+		buf->st_ino = 0;
+		buf->st_gid = 0;
+		buf->st_uid = 0;
+		buf->st_nlink = 1;
+		buf->st_mode = (mode_t)fMode;
+		buf->st_size = fdata.nFileSizeLow; /* Can't use nFileSizeHigh, since it's not a stat64 */
+		buf->st_dev = buf->st_rdev = (_getdrive() - 1);
+		buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
+		buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
+		buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
+
+		git__free(fbuf);
+		return GIT_SUCCESS;
+	}
+
+	git__free(fbuf);
+
+	switch (GetLastError()) {
+		case ERROR_ACCESS_DENIED:
+		case ERROR_SHARING_VIOLATION:
+		case ERROR_LOCK_VIOLATION:
+		case ERROR_SHARING_BUFFER_EXCEEDED:
+			return GIT_EOSERR;
+
+		case ERROR_BUFFER_OVERFLOW:
+		case ERROR_NOT_ENOUGH_MEMORY:
+			return GIT_ENOMEM;
+
+		default:
+			return GIT_EINVALIDPATH;
+	}
+}
+
+int p_lstat(const char *file_name, struct stat *buf)
+{
+	int namelen, error;
+	char alt_name[GIT_PATH_MAX];
+
+	if ((error = do_lstat(file_name, buf)) == GIT_SUCCESS)
+		return GIT_SUCCESS;
+
+	/* if file_name ended in a '/', Windows returned ENOENT;
+	 * try again without trailing slashes
+	 */
+	if (error != GIT_EINVALIDPATH)
+		return git__throw(GIT_EOSERR, "Failed to lstat file");
+
+	namelen = strlen(file_name);
+	if (namelen && file_name[namelen-1] != '/')
+		return git__throw(GIT_EOSERR, "Failed to lstat file");
+
+	while (namelen && file_name[namelen-1] == '/')
+		--namelen;
+
+	if (!namelen || namelen >= GIT_PATH_MAX)
+		return git__throw(GIT_ENOMEM, "Failed to lstat file");
+
+	memcpy(alt_name, file_name, namelen);
+	alt_name[namelen] = 0;
+	return do_lstat(alt_name, buf);
+}
+
+int p_readlink(const char *link, char *target, size_t target_len)
+{
+	typedef DWORD (WINAPI *fpath_func)(HANDLE, LPWSTR, DWORD, DWORD);
+	static fpath_func pGetFinalPath = NULL;
+	HANDLE hFile;
+	DWORD dwRet;
+	wchar_t* link_w;
+	wchar_t* target_w;
+
+	/*
+	 * Try to load the pointer to pGetFinalPath dynamically, because
+	 * it is not available in platforms older than Vista
+	 */
+	if (pGetFinalPath == NULL) {
+		HINSTANCE library = LoadLibrary("kernel32");
+
+		if (library != NULL)
+			pGetFinalPath = (fpath_func)GetProcAddress(library, "GetFinalPathNameByHandleW");
+
+		if (pGetFinalPath == NULL)
+			return git__throw(GIT_EOSERR,
+				"'GetFinalPathNameByHandleW' is not available in this platform");
+	}
+
+	link_w = gitwin_to_utf16(link);
+
+	hFile = CreateFileW(link_w,			// file to open
+			GENERIC_READ,			// open for reading
+			FILE_SHARE_READ,		// share for reading
+			NULL,					// default security
+			OPEN_EXISTING,			// existing file only
+			FILE_FLAG_BACKUP_SEMANTICS, // normal file
+			NULL);					// no attr. template
+
+	git__free(link_w);
+
+	if (hFile == INVALID_HANDLE_VALUE)
+		return GIT_EOSERR;
+
+	if (target_len <= 0) {
+		return GIT_EINVALIDARGS;
+	}
+
+	target_w = (wchar_t*)git__malloc(target_len * sizeof(wchar_t));
+
+	dwRet = pGetFinalPath(hFile, target_w, target_len, 0x0);
+	if (dwRet >= target_len) {
+		git__free(target_w);
+		CloseHandle(hFile);
+		return GIT_ENOMEM;
+	}
+
+	if (!WideCharToMultiByte(CP_UTF8, 0, target_w, -1, target, target_len * sizeof(char), NULL, NULL)) {
+		git__free(target_w);
+		return GIT_EOSERR;
+	}
+
+	git__free(target_w);
+	CloseHandle(hFile);
+
+	if (dwRet > 4) {
+		/* Skip first 4 characters if they are "\\?\" */
+		if (target[0] == '\\' && target[1] == '\\' && target[2] == '?' && target[3] == '\\') {
+			char tmp[GIT_PATH_MAX];
+			unsigned int offset = 4;
+			dwRet -= 4;
+
+			/* \??\UNC\ */
+			if (dwRet > 7 && target[4] == 'U' && target[5] == 'N' && target[6] == 'C') {
+				offset += 2;
+				dwRet -= 2;
+				target[offset] = '\\';
+			}
+
+			memcpy(tmp, target + offset, dwRet);
+			memcpy(target, tmp, dwRet);
+		}
+	}
+
+	target[dwRet] = '\0';
+	return dwRet;
+}
+
+int p_open(const char *path, int flags)
+{
+	int fd;
+	wchar_t* buf = gitwin_to_utf16(path);
+	fd = _wopen(buf, flags | _O_BINARY);
+
+	git__free(buf);
+	return fd;
+}
+
+int p_creat(const char *path, mode_t mode)
+{
+	int fd;
+	wchar_t* buf = gitwin_to_utf16(path);
+	fd = _wopen(buf, _O_WRONLY | _O_CREAT | _O_TRUNC | _O_BINARY, mode);
+
+	git__free(buf);
+	return fd;
+}
+
+int p_getcwd(char *buffer_out, size_t size)
+{
+	wchar_t* buf = (wchar_t*)git__malloc(sizeof(wchar_t) * (int)size);
+	_wgetcwd(buf, (int)size);
+
+	if (!WideCharToMultiByte(CP_UTF8, 0, buf, -1, buffer_out, size, NULL, NULL)) {
+		git__free(buf);
+		return GIT_EOSERR;
+	}
+
+	git__free(buf);
+	return GIT_SUCCESS;
+}
+
+int p_stat(const char* path, struct stat* buf)
+{
+	return do_lstat(path, buf);
+}
+
+int p_chdir(const char* path)
+{
+	wchar_t* buf = gitwin_to_utf16(path);
+	int ret = _wchdir(buf);
+
+	git__free(buf);
+	return ret;
+}
+
+int p_chmod(const char* path, mode_t mode)
+{
+	wchar_t* buf = gitwin_to_utf16(path);
+	int ret = _wchmod(buf, mode);
+
+	git__free(buf);
+	return ret;
+}
+
+int p_rmdir(const char* path)
+{
+	wchar_t* buf = gitwin_to_utf16(path);
+	int ret = _wrmdir(buf);
+
+	git__free(buf);
+	return ret;
+}
+
+int p_hide_directory__w32(const char *path)
+{
+	int error;
+	wchar_t* buf = gitwin_to_utf16(path);
+
+	error = SetFileAttributesW(buf, FILE_ATTRIBUTE_HIDDEN) != 0 ?
+		GIT_SUCCESS : GIT_ERROR; /* MSDN states a "non zero" value indicates a success */
+
+	git__free(buf);
+
+	if (error < GIT_SUCCESS)
+		error = git__throw(GIT_EOSERR, "Failed to hide directory '%s'", path);
+
+	return error;
+}
+
+char *p_realpath(const char *orig_path, char *buffer)
+{
+	int ret, alloc = 0;
+	wchar_t* orig_path_w = gitwin_to_utf16(orig_path);
+	wchar_t* buffer_w = (wchar_t*)git__malloc(GIT_PATH_MAX * sizeof(wchar_t));
+
+	if (buffer == NULL) {
+		buffer = (char *)git__malloc(GIT_PATH_MAX);
+		alloc = 1;
+	}
+
+	ret = GetFullPathNameW(orig_path_w, GIT_PATH_MAX, buffer_w, NULL);
+	git__free(orig_path_w);
+
+	if (!ret || ret > GIT_PATH_MAX) {
+		git__free(buffer_w);
+		if (alloc) git__free(buffer);
+
+		return NULL;
+	}
+
+	if (!WideCharToMultiByte(CP_UTF8, 0, buffer_w, -1, buffer, GIT_PATH_MAX, NULL, NULL)) {
+		git__free(buffer_w);
+		if (alloc) git__free(buffer);
+	}
+	
+	git__free(buffer_w);
+	git_path_mkposix(buffer);
+	return buffer;
+}
+
+int p_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr)
+{
+#ifdef _MSC_VER
+	int len = _vsnprintf(buffer, count, format, argptr);
+	return (len < 0) ? _vscprintf(format, argptr) : len;
+#else /* MinGW */
+	return vsnprintf(buffer, count, format, argptr);
+#endif
+}
+
+int p_snprintf(char *buffer, size_t count, const char *format, ...)
+{
+	va_list va;
+	int r;
+
+	va_start(va, format);
+	r = p_vsnprintf(buffer, count, format, va);
+	va_end(va);
+
+	return r;
+}
+
+extern int p_creat(const char *path, mode_t mode);
+
+int p_mkstemp(char *tmp_path)
+{
+#if defined(_MSC_VER)
+	if (_mktemp_s(tmp_path, GIT_PATH_MAX) != 0)
+		return GIT_EOSERR;
+#else
+	if (_mktemp(tmp_path) == NULL)
+		return GIT_EOSERR;
+#endif
+
+	return p_creat(tmp_path, 0744);
+}
+
+int p_setenv(const char* name, const char* value, int overwrite)
+{
+	if (overwrite != 1)
+		return EINVAL;
+
+	return (SetEnvironmentVariableA(name, value) == 0 ? GIT_EOSERR : GIT_SUCCESS);
+}
+
+int p_access(const char* path, mode_t mode)
+{
+	wchar_t *buf = gitwin_to_utf16(path);
+	int ret;
+
+	ret = _waccess(buf, mode);
+	git__free(buf);
+
+	return ret;
+}
+
+extern int p_rename(const char *from, const char *to)
+{
+	wchar_t *wfrom = gitwin_to_utf16(from);
+	wchar_t *wto = gitwin_to_utf16(to);
+	int ret;
+
+	ret = MoveFileExW(wfrom, wto, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) ? GIT_SUCCESS : GIT_EOSERR;
+
+	git__free(wfrom);
+	git__free(wto);
+
+	return ret;
+}