rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/win32/path_w32.c

@@ -0,0 +1,476 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * 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 "path_w32.h"
+
+#include "path.h"
+#include "utf-conv.h"
+#include "posix.h"
+#include "reparse.h"
+#include "dir.h"
+
+#define PATH__NT_NAMESPACE     L"\\\\?\\"
+#define PATH__NT_NAMESPACE_LEN 4
+
+#define PATH__ABSOLUTE_LEN     3
+
+#define path__is_nt_namespace(p) \
+	(((p)[0] == '\\' && (p)[1] == '\\' && (p)[2] == '?' && (p)[3] == '\\') || \
+	 ((p)[0] == '/' && (p)[1] == '/' && (p)[2] == '?' && (p)[3] == '/'))
+
+#define path__is_unc(p) \
+	(((p)[0] == '\\' && (p)[1] == '\\') || ((p)[0] == '/' && (p)[1] == '/'))
+
+GIT_INLINE(int) path__cwd(wchar_t *path, int size)
+{
+	int len;
+
+	if ((len = GetCurrentDirectoryW(size, path)) == 0) {
+		errno = GetLastError() == ERROR_ACCESS_DENIED ? EACCES : ENOENT;
+		return -1;
+	} else if (len > size) {
+		errno = ENAMETOOLONG;
+		return -1;
+	}
+
+	/* The Win32 APIs may return "\\?\" once you've used it first.
+	 * But it may not.  What a gloriously predictible API!
+	 */
+	if (wcsncmp(path, PATH__NT_NAMESPACE, PATH__NT_NAMESPACE_LEN))
+		return len;
+
+	len -= PATH__NT_NAMESPACE_LEN;
+
+	memmove(path, path + PATH__NT_NAMESPACE_LEN, sizeof(wchar_t) * len);
+	return len;
+}
+
+static wchar_t *path__skip_server(wchar_t *path)
+{
+	wchar_t *c;
+
+	for (c = path; *c; c++) {
+		if (git_path_is_dirsep(*c))
+			return c + 1;
+	}
+
+	return c;
+}
+
+static wchar_t *path__skip_prefix(wchar_t *path)
+{
+	if (path__is_nt_namespace(path)) {
+		path += PATH__NT_NAMESPACE_LEN;
+
+		if (wcsncmp(path, L"UNC\\", 4) == 0)
+			path = path__skip_server(path + 4);
+		else if (git_path_is_absolute(path))
+			path += PATH__ABSOLUTE_LEN;
+	} else if (git_path_is_absolute(path)) {
+		path += PATH__ABSOLUTE_LEN;
+	} else if (path__is_unc(path)) {
+		path = path__skip_server(path + 2);
+	}
+
+	return path;
+}
+
+int git_win32_path_canonicalize(git_win32_path path)
+{
+	wchar_t *base, *from, *to, *next;
+	size_t len;
+
+	base = to = path__skip_prefix(path);
+
+	/* Unposixify if the prefix */
+	for (from = path; from < to; from++) {
+		if (*from == L'/')
+			*from = L'\\';
+	}
+
+	while (*from) {
+		for (next = from; *next; ++next) {
+			if (*next == L'/') {
+				*next = L'\\';
+				break;
+			}
+
+			if (*next == L'\\')
+				break;
+		}
+
+		len = next - from;
+
+		if (len == 1 && from[0] == L'.')
+			/* do nothing with singleton dot */;
+
+		else if (len == 2 && from[0] == L'.' && from[1] == L'.') {
+			if (to == base) {
+				/* no more path segments to strip, eat the "../" */
+				if (*next == L'\\')
+					len++;
+
+				base = to;
+			} else {
+				/* back up a path segment */
+				while (to > base && to[-1] == L'\\') to--;
+				while (to > base && to[-1] != L'\\') to--;
+			}
+		} else {
+			if (*next == L'\\' && *from != L'\\')
+				len++;
+
+			if (to != from)
+				memmove(to, from, sizeof(wchar_t) * len);
+
+			to += len;
+		}
+
+		from += len;
+
+		while (*from == L'\\') from++;
+	}
+
+	/* Strip trailing backslashes */
+	while (to > base && to[-1] == L'\\') to--;
+
+	*to = L'\0';
+
+	return (to - path);
+}
+
+int git_win32_path__cwd(wchar_t *out, size_t len)
+{
+	int cwd_len;
+
+	if ((cwd_len = path__cwd(out, len)) < 0)
+		return -1;
+
+	/* UNC paths */
+	if (wcsncmp(L"\\\\", out, 2) == 0) {
+		/* Our buffer must be at least 5 characters larger than the
+		 * current working directory:  we swallow one of the leading
+		 * '\'s, but we we add a 'UNC' specifier to the path, plus
+		 * a trailing directory separator, plus a NUL.
+		 */
+		if (cwd_len > MAX_PATH - 4) {
+			errno = ENAMETOOLONG;
+			return -1;
+		}
+
+		memmove(out+2, out, sizeof(wchar_t) * cwd_len);
+		out[0] = L'U';
+		out[1] = L'N';
+		out[2] = L'C';
+
+		cwd_len += 2;
+	}
+
+	/* Our buffer must be at least 2 characters larger than the current
+	 * working directory.  (One character for the directory separator,
+	 * one for the null.
+	 */
+	else if (cwd_len > MAX_PATH - 2) {
+		errno = ENAMETOOLONG;
+		return -1;
+	}
+
+	return cwd_len;
+}
+
+int git_win32_path_from_utf8(git_win32_path out, const char *src)
+{
+	wchar_t *dest = out;
+
+	/* All win32 paths are in NT-prefixed format, beginning with "\\?\". */
+	memcpy(dest, PATH__NT_NAMESPACE, sizeof(wchar_t) * PATH__NT_NAMESPACE_LEN);
+	dest += PATH__NT_NAMESPACE_LEN;
+
+	/* See if this is an absolute path (beginning with a drive letter) */
+	if (git_path_is_absolute(src)) {
+		if (git__utf8_to_16(dest, MAX_PATH, src) < 0)
+			goto on_error;
+	}
+	/* File-prefixed NT-style paths beginning with \\?\ */
+	else if (path__is_nt_namespace(src)) {
+		/* Skip the NT prefix, the destination already contains it */
+		if (git__utf8_to_16(dest, MAX_PATH, src + PATH__NT_NAMESPACE_LEN) < 0)
+			goto on_error;
+	}
+	/* UNC paths */
+	else if (path__is_unc(src)) {
+		memcpy(dest, L"UNC\\", sizeof(wchar_t) * 4);
+		dest += 4;
+
+		/* Skip the leading "\\" */
+		if (git__utf8_to_16(dest, MAX_PATH - 2, src + 2) < 0)
+			goto on_error;
+	}
+	/* Absolute paths omitting the drive letter */
+	else if (src[0] == '\\' || src[0] == '/') {
+		if (path__cwd(dest, MAX_PATH) < 0)
+			goto on_error;
+
+		if (!git_path_is_absolute(dest)) {
+			errno = ENOENT;
+			goto on_error;
+		}
+
+		/* Skip the drive letter specification ("C:") */
+		if (git__utf8_to_16(dest + 2, MAX_PATH - 2, src) < 0)
+			goto on_error;
+	}
+	/* Relative paths */
+	else {
+		int cwd_len;
+
+		if ((cwd_len = git_win32_path__cwd(dest, MAX_PATH)) < 0)
+			goto on_error;
+
+		dest[cwd_len++] = L'\\';
+
+		if (git__utf8_to_16(dest + cwd_len, MAX_PATH - cwd_len, src) < 0)
+			goto on_error;
+	}
+
+	return git_win32_path_canonicalize(out);
+
+on_error:
+	/* set windows error code so we can use its error message */
+	if (errno == ENAMETOOLONG)
+		SetLastError(ERROR_FILENAME_EXCED_RANGE);
+
+	return -1;
+}
+
+int git_win32_path_to_utf8(git_win32_utf8_path dest, const wchar_t *src)
+{
+	char *out = dest;
+	int len;
+
+	/* Strip NT namespacing "\\?\" */
+	if (path__is_nt_namespace(src)) {
+		src += 4;
+
+		/* "\\?\UNC\server\share" -> "\\server\share" */
+		if (wcsncmp(src, L"UNC\\", 4) == 0) {
+			src += 4;
+
+			memcpy(dest, "\\\\", 2);
+			out = dest + 2;
+		}
+	}
+
+	if ((len = git__utf16_to_8(out, GIT_WIN_PATH_UTF8, src)) < 0)
+		return len;
+
+	git_path_mkposix(dest);
+
+	return len;
+}
+
+char *git_win32_path_8dot3_name(const char *path)
+{
+	git_win32_path longpath, shortpath;
+	wchar_t *start;
+	char *shortname;
+	int len, namelen = 1;
+
+	if (git_win32_path_from_utf8(longpath, path) < 0)
+		return NULL;
+
+	len = GetShortPathNameW(longpath, shortpath, GIT_WIN_PATH_UTF16);
+
+	while (len && shortpath[len-1] == L'\\')
+		shortpath[--len] = L'\0';
+
+	if (len == 0 || len >= GIT_WIN_PATH_UTF16)
+		return NULL;
+
+	for (start = shortpath + (len - 1);
+		start > shortpath && *(start-1) != '/' && *(start-1) != '\\';
+		start--)
+		namelen++;
+
+	/* We may not have actually been given a short name.  But if we have,
+	 * it will be in the ASCII byte range, so we don't need to worry about
+	 * multi-byte sequences and can allocate naively.
+	 */
+	if (namelen > 12 || (shortname = git__malloc(namelen + 1)) == NULL)
+		return NULL;
+
+	if ((len = git__utf16_to_8(shortname, namelen + 1, start)) < 0)
+		return NULL;
+
+	return shortname;
+}
+
+static bool path_is_volume(wchar_t *target, size_t target_len)
+{
+	return (target_len && wcsncmp(target, L"\\??\\Volume{", 11) == 0);
+}
+
+/* On success, returns the length, in characters, of the path stored in dest.
+ * On failure, returns a negative value. */
+int git_win32_path_readlink_w(git_win32_path dest, const git_win32_path path)
+{
+	BYTE buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
+	GIT_REPARSE_DATA_BUFFER *reparse_buf = (GIT_REPARSE_DATA_BUFFER *)buf;
+	HANDLE handle = NULL;
+	DWORD ioctl_ret;
+	wchar_t *target;
+	size_t target_len;
+
+	int error = -1;
+
+	handle = CreateFileW(path, GENERIC_READ,
+		FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
+		FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
+
+	if (handle == INVALID_HANDLE_VALUE) {
+		errno = ENOENT;
+		return -1;
+	}
+
+	if (!DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0,
+		reparse_buf, sizeof(buf), &ioctl_ret, NULL)) {
+		errno = EINVAL;
+		goto on_error;
+	}
+
+	switch (reparse_buf->ReparseTag) {
+	case IO_REPARSE_TAG_SYMLINK:
+		target = reparse_buf->SymbolicLinkReparseBuffer.PathBuffer +
+			(reparse_buf->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR));
+		target_len = reparse_buf->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(WCHAR);
+	break;
+	case IO_REPARSE_TAG_MOUNT_POINT:
+		target = reparse_buf->MountPointReparseBuffer.PathBuffer +
+			(reparse_buf->MountPointReparseBuffer.SubstituteNameOffset / sizeof(WCHAR));
+		target_len = reparse_buf->MountPointReparseBuffer.SubstituteNameLength / sizeof(WCHAR);
+	break;
+	default:
+		errno = EINVAL;
+		goto on_error;
+	}
+
+	if (path_is_volume(target, target_len)) {
+		/* This path is a reparse point that represents another volume mounted
+		 * at this location, it is not a symbolic link our input was canonical.
+		 */
+		errno = EINVAL;
+		error = -1;
+	} else if (target_len) {
+		/* The path may need to have a namespace prefix removed. */
+		target_len = git_win32_path_remove_namespace(target, target_len);
+
+		/* Need one additional character in the target buffer
+		 * for the terminating NULL. */
+		if (GIT_WIN_PATH_UTF16 > target_len) {
+			wcscpy(dest, target);
+			error = (int)target_len;
+		}
+	}
+
+on_error:
+	CloseHandle(handle);
+	return error;
+}
+
+/**
+ * Removes any trailing backslashes from a path, except in the case of a drive
+ * letter path (C:\, D:\, etc.). This function cannot fail.
+ *
+ * @param path The path which should be trimmed.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32_path_trim_end(wchar_t *str, size_t len)
+{
+	while (1) {
+		if (!len || str[len - 1] != L'\\')
+			break;
+
+		/*
+		 * Don't trim backslashes from drive letter paths, which
+		 * are 3 characters long and of the form C:\, D:\, etc.
+		 */
+		if (len == 3 && git_win32__isalpha(str[0]) && str[1] == ':')
+			break;
+
+		len--;
+	}
+
+	str[len] = L'\0';
+
+	return len;
+}
+
+/**
+ * Removes any of the following namespace prefixes from a path,
+ * if found: "\??\", "\\?\", "\\?\UNC\". This function cannot fail.
+ *
+ * @param path The path which should be converted.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32_path_remove_namespace(wchar_t *str, size_t len)
+{
+	static const wchar_t dosdevices_namespace[] = L"\\\?\?\\";
+	static const wchar_t nt_namespace[] = L"\\\\?\\";
+	static const wchar_t unc_namespace_remainder[] = L"UNC\\";
+	static const wchar_t unc_prefix[] = L"\\\\";
+
+	const wchar_t *prefix = NULL, *remainder = NULL;
+	size_t prefix_len = 0, remainder_len = 0;
+
+	/* "\??\" -- DOS Devices prefix */
+	if (len >= CONST_STRLEN(dosdevices_namespace) &&
+		!wcsncmp(str, dosdevices_namespace, CONST_STRLEN(dosdevices_namespace))) {
+		remainder = str + CONST_STRLEN(dosdevices_namespace);
+		remainder_len = len - CONST_STRLEN(dosdevices_namespace);
+	}
+	/* "\\?\" -- NT namespace prefix */
+	else if (len >= CONST_STRLEN(nt_namespace) &&
+		!wcsncmp(str, nt_namespace, CONST_STRLEN(nt_namespace))) {
+		remainder = str + CONST_STRLEN(nt_namespace);
+		remainder_len = len - CONST_STRLEN(nt_namespace);
+	}
+
+	/* "\??\UNC\", "\\?\UNC\" -- UNC prefix */
+	if (remainder_len >= CONST_STRLEN(unc_namespace_remainder) &&
+		!wcsncmp(remainder, unc_namespace_remainder, CONST_STRLEN(unc_namespace_remainder))) {
+
+		/*
+		 * The proper Win32 path for a UNC share has "\\" at beginning of it
+		 * and looks like "\\server\share\<folderStructure>".  So remove the
+		 * UNC namespace and add a prefix of "\\" in its place.
+		 */
+		remainder += CONST_STRLEN(unc_namespace_remainder);
+		remainder_len -= CONST_STRLEN(unc_namespace_remainder);
+
+		prefix = unc_prefix;
+		prefix_len = CONST_STRLEN(unc_prefix);
+	}
+
+	if (remainder) {
+		/*
+		 * Sanity check that the new string isn't longer than the old one.
+		 * (This could only happen due to programmer error introducing a
+		 * prefix longer than the namespace it replaces.)
+		 */
+		assert(len >= remainder_len + prefix_len);
+
+		if (prefix)
+			memmove(str, prefix, prefix_len * sizeof(wchar_t));
+
+		memmove(str + prefix_len, remainder, remainder_len * sizeof(wchar_t));
+
+		len = remainder_len + prefix_len;
+		str[len] = L'\0';
+	}
+
+	return git_win32_path_trim_end(str, len);
+}

data/vendor/libgit2/src/win32/path_w32.h

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * 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_win32_path_w32_h__
+#define INCLUDE_win32_path_w32_h__
+
+#include "common.h"
+
+#include "vector.h"
+
+/*
+ * Provides a large enough buffer to support Windows paths:  MAX_PATH is
+ * 260, corresponding to a maximum path length of 259 characters plus a
+ * NULL terminator.  Prefixing with "\\?\" adds 4 characters, but if the
+ * original was a UNC path, then we turn "\\server\share" into
+ * "\\?\UNC\server\share".  So we replace the first two characters with
+ * 8 characters, a net gain of 6, so the maximum length is MAX_PATH+6.
+ */
+#define GIT_WIN_PATH_UTF16		MAX_PATH+6
+
+/* Maximum size of a UTF-8 Win32 path.  We remove the "\\?\" or "\\?\UNC\"
+ * prefixes for presentation, bringing us back to 259 (non-NULL)
+ * characters.  UTF-8 does have 4-byte sequences, but they are encoded in
+ * UTF-16 using surrogate pairs, which takes up the space of two characters.
+ * Two characters in the range U+0800 -> U+FFFF take up more space in UTF-8
+ * (6 bytes) than one surrogate pair (4 bytes).
+ */
+#define GIT_WIN_PATH_UTF8		(259 * 3 + 1)
+
+/*
+ * The length of a Windows "shortname", for 8.3 compatibility.
+ */
+#define GIT_WIN_PATH_SHORTNAME  13
+
+/* Win32 path types */
+typedef wchar_t git_win32_path[GIT_WIN_PATH_UTF16];
+typedef char git_win32_utf8_path[GIT_WIN_PATH_UTF8];
+
+/**
+ * Create a Win32 path (in UCS-2 format) from a UTF-8 string.
+ *
+ * @param dest The buffer to receive the wide string.
+ * @param src The UTF-8 string to convert.
+ * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ */
+extern int git_win32_path_from_utf8(git_win32_path dest, const char *src);
+
+/**
+ * Canonicalize a Win32 UCS-2 path so that it is suitable for delivery to the
+ * Win32 APIs: remove multiple directory separators, squashing to a single one,
+ * strip trailing directory separators, ensure directory separators are all
+ * canonical (always backslashes, never forward slashes) and process any
+ * directory entries of '.' or '..'.
+ *
+ * This processes the buffer in place.
+ *
+ * @param path The buffer to process
+ * @return The new length of the buffer, in wchar_t's (not counting the NULL terminator)
+ */
+extern int git_win32_path_canonicalize(git_win32_path path);
+
+/**
+ * Create an internal format (posix-style) UTF-8 path from a Win32 UCS-2 path.
+ *
+ * @param dest The buffer to receive the UTF-8 string.
+ * @param src The wide string to convert.
+ * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ */
+extern int git_win32_path_to_utf8(git_win32_utf8_path dest, const wchar_t *src);
+
+/**
+ * Get the short name for the terminal path component in the given path.
+ * For example, given "C:\Foo\Bar\Asdf.txt", this will return the short name
+ * for the file "Asdf.txt".
+ *
+ * @param path The given path in UTF-8
+ * @return The name of the shortname for the given path
+ */
+extern char *git_win32_path_8dot3_name(const char *path);
+
+extern int git_win32_path_readlink_w(git_win32_path dest, const git_win32_path path);
+
+/**
+ * Removes any trailing backslashes from a path, except in the case of a drive
+ * letter path (C:\, D:\, etc.). This function cannot fail.
+ *
+ * @param path The path which should be trimmed.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32_path_trim_end(wchar_t *str, size_t len);
+
+/**
+ * Removes any of the following namespace prefixes from a path,
+ * if found: "\??\", "\\?\", "\\?\UNC\". This function cannot fail.
+ *
+ * @param path The path which should be converted.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32_path_remove_namespace(wchar_t *str, size_t len);
+
+#endif

data/vendor/libgit2/src/win32/posix.h

@@ -4,51 +4,50 @@
  * 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__
+#ifndef INCLUDE_win32_posix_h__
+#define INCLUDE_win32_posix_h__
 
 #include "common.h"
+#include "../posix.h"
+#include "win32-compat.h"
+#include "path_w32.h"
 #include "utf-conv.h"
+#include "dir.h"
 
-GIT_INLINE(int) p_link(const char *old, const char *new)
-{
-	GIT_UNUSED(old);
-	GIT_UNUSED(new);
-	errno = ENOSYS;
-	return -1;
-}
-
-GIT_INLINE(int) p_mkdir(const char *path, mode_t mode)
-{
-	wchar_t buf[GIT_WIN_PATH];
-	GIT_UNUSED(mode);
-	git__utf8_to_16(buf, GIT_WIN_PATH, path);
-	return _wmkdir(buf);
-}
+extern unsigned long git_win32__createfile_sharemode;
+extern int git_win32__retries;
 
-extern int p_unlink(const char *path);
+typedef SOCKET GIT_SOCKET;
+
+#define p_lseek(f,n,w) _lseeki64(f, n, w)
+
+extern int p_fstat(int fd, struct stat *buf);
 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_stat(const char* path, struct stat *buf);
+
+extern int p_utimes(const char *filename, const struct p_timeval times[2]);
+extern int p_futimes(int fd, const struct p_timeval times[2]);
+
+extern int p_readlink(const char *path, char *buf, size_t bufsiz);
 extern int p_symlink(const char *old, const char *new);
-extern int p_hide_directory__w32(const char *path);
+extern int p_link(const char *old, const char *new);
+extern int p_unlink(const char *path);
+extern int p_mkdir(const char *path, mode_t mode);
+extern int p_fsync(int fd);
 extern char *p_realpath(const char *orig_path, char *buffer);
+
+extern int p_recv(GIT_SOCKET socket, void *buffer, size_t length, int flags);
+extern int p_send(GIT_SOCKET socket, const void *buffer, size_t length, int flags);
+extern int p_inet_pton(int af, const char* src, void* dst);
+
 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);
-extern int p_recv(GIT_SOCKET socket, void *buffer, size_t length, int flags);
-extern int p_send(GIT_SOCKET socket, const void *buffer, size_t length, int flags);
-extern int p_inet_pton(int af, const char* src, void* dst);
+extern int p_ftruncate(int fd, git_off_t size);
 
 /* p_lstat is almost but not quite POSIX correct.  Specifically, the use of
  * ENOTDIR is wrong, in that it does not mean precisely that a non-directory
@@ -58,4 +57,10 @@ extern int p_inet_pton(int af, const char* src, void* dst);
  */
 extern int p_lstat_posixly(const char *filename, struct stat *buf);
 
+extern struct tm * p_localtime_r(const time_t *timer, struct tm *result);
+extern struct tm * p_gmtime_r(const time_t *timer, struct tm *result);
+
+/* Use the bundled regcomp */
+#define p_regcomp regcomp
+
 #endif