passenger 5.1.12 → 5.2.0

data/src/cxx_supportlib/FileTools/FileManip.h

@@ -0,0 +1,162 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2017 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+#ifndef _PASSENGER_FILE_TOOLS_FILE_MANIP_H_
+#define _PASSENGER_FILE_TOOLS_FILE_MANIP_H_
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <cstddef>
+#include <string>
+#include <StaticString.h>
+
+namespace boost {
+	class mutex;
+}
+
+namespace Passenger {
+
+using namespace std;
+
+// All functions in this file allow non-NULL-terminated StaticStrings.
+
+
+class CachedFileStat;
+
+static const uid_t USER_NOT_GIVEN = (uid_t) -1;
+static const gid_t GROUP_NOT_GIVEN = (gid_t) -1;
+
+/** Enumeration which indicates what kind of file a file is. */
+typedef enum {
+	/** The file doesn't exist. */
+	FT_NONEXISTANT,
+	/** A regular file or a symlink to a regular file. */
+	FT_REGULAR,
+	/** A directory. */
+	FT_DIRECTORY,
+	/** Something else, e.g. a pipe or a socket. */
+	FT_OTHER
+} FileType;
+
+/**
+ * Given a filename, FileGuard will unlink the file in its destructor, unless
+ * commit() was called. Used in file operation functions that don't want to
+ * leave behind half-finished files after error conditions.
+ */
+struct FileGuard {
+	string filename;
+	bool committed;
+
+	FileGuard(const StaticString &filename);
+	~FileGuard();
+	void commit();
+};
+
+
+/**
+ * Check whether the specified file exists.
+ *
+ * @param filename The filename to check.
+ * @param cstat A CachedFileStat object, if you want to use cached statting.
+ * @param cstatMutex A mutex for locking cstat while this function uses it.
+ *                   Makes this function thread-safe. May be NULL.
+ * @param throttleRate A throttle rate for cstat. Only applicable if cstat is not NULL.
+ * @return Whether the file exists.
+ * @throws FileSystemException Unable to check because of a filesystem error.
+ * @throws TimeRetrievalException
+ * @throws boost::thread_interrupted
+ */
+bool fileExists(const StaticString &filename, CachedFileStat *cstat = 0,
+	boost::mutex *cstatMutex = NULL, unsigned int throttleRate = 0);
+
+/**
+* Check whether 'filename' exists and what kind of file it is.
+*
+* @param filename The filename to check. It MUST be NULL-terminated.
+* @param cstat A CachedFileStat object, if you want to use cached statting.
+* @param cstatMutex A mutex for locking cstat while this function uses it.
+*                   Makes this function thread-safe. May be NULL.
+* @param throttleRate A throttle rate for cstat. Only applicable if cstat is not NULL.
+* @return The file type.
+* @throws FileSystemException Unable to check because of a filesystem error.
+* @throws TimeRetrievalException
+* @throws boost::thread_interrupted
+* @ingroup Support
+*/
+FileType getFileType(const StaticString &filename, CachedFileStat *cstat = 0,
+		 boost::mutex *cstatMutex = NULL, unsigned int throttleRate = 0);
+
+/**
+* Create the given file with the given contents, permissions and ownership.
+* This function does not leave behind junk files: if the ownership cannot be set
+* or if not all data can be written then then the file will be deleted.
+*
+* @param filename The file to create.
+* @param contents The contents to write to the file.
+* @param permissions The desired file permissions.
+* @param owner The desired file owner. Specify USER_NOT_GIVEN if you want to use the current
+*              process's owner as the file owner.
+* @param group The desired file group. Specify GROUP_NOT_GIVEN if you want to use the current
+*              process's group as the file group.
+* @param overwrite Whether to overwrite the file if it exists. If set to false
+*                  and the file exists then nothing will happen.
+* @throws FileSystemException Something went wrong.
+*/
+void createFile(const string &filename, const StaticString &contents,
+	mode_t permissions = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH,
+	uid_t owner = USER_NOT_GIVEN, gid_t group = GROUP_NOT_GIVEN,
+	bool overwrite = true,
+	const char *callerFile = NULL, unsigned int callerLine = 0);
+
+/**
+ * Create the directory at the given path, creating intermediate directories
+ * if necessary. The created directories' permissions are exactly as specified
+ * by the 'mode' parameter (i.e. the umask will be ignored). You can specify
+ * this directory's owner and group through the 'owner' and 'group' parameters.
+ * A value of USER_NOT_GIVEN for 'owner' and/or GROUP_NOT_GIVEN 'group' means
+ * that the owner/group should not be changed.
+ *
+ * If 'path' already exists, then nothing will happen.
+ *
+ * @param mode A mode string, as supported by parseModeString().
+ * @throws FileSystemException Something went wrong.
+ * @throws InvalidModeStringException The mode string cannot be parsed.
+ */
+void makeDirTree(const string &path, const StaticString &mode = "u=rwx,g=,o=",
+	uid_t owner = USER_NOT_GIVEN, gid_t group = GROUP_NOT_GIVEN);
+
+/**
+ * Remove an entire directory tree recursively. If the directory doesn't exist then this
+ * function does nothing.
+ *
+ * @throws RuntimeException Something went wrong.
+ */
+void removeDirTree(const string &path);
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_FILE_TOOLS_FILE_MANIP_H_ */

data/src/cxx_supportlib/{Utils → FileTools}/LargeFiles.cpp

@@ -11,17 +11,19 @@
 	#define _LARGEFILE64_SOURCE
 #endif
 
-#include <Utils/LargeFiles.h>
+#include <FileTools/LargeFiles.h>
+#include <stdio.h>
 #include <stdlib.h>
 
 namespace Passenger {
 
-FILE *
+
+::FILE *
 lfs_fopen(const char *filename, const char *mode) {
 	return fopen(filename, mode);
 }
 
-FILE *
+::FILE *
 lfs_fdopen(int filedes, const char *mode) {
 	return fdopen(filedes, mode);
 }
@@ -35,4 +37,5 @@ lfs_mkstemp(char *templ) {
 	#endif
 }
 
+
 } // namespace Passenger

data/src/cxx_supportlib/{Utils → FileTools}/LargeFiles.h

@@ -23,8 +23,8 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
-#ifndef _PASSENGER_UTILS_LARGE_FILES_H_
-#define _PASSENGER_UTILS_LARGE_FILES_H_
+#ifndef _PASSENGER_FILE_TOOLS_LARGE_FILES_H_
+#define _PASSENGER_FILE_TOOLS_LARGE_FILES_H_
 
 #include <stdio.h>
 
@@ -32,10 +32,12 @@
 
 namespace Passenger {
 
-FILE *lfs_fopen(const char *filename, const char *mode);
-FILE *lfs_fdopen(int filedes, const char *mode);
+
+::FILE *lfs_fopen(const char *filename, const char *mode);
+::FILE *lfs_fdopen(int filedes, const char *mode);
 int lfs_mkstemp(char *templ);
 
+
 } // namespace Passenger
 
-#endif /* _PASSENGER_UTILS_LARGE_FILES_H_ */
+#endif /* _PASSENGER_FILE_TOOLS_LARGE_FILES_H_ */

data/src/cxx_supportlib/FileTools/PathManip.cpp

@@ -0,0 +1,240 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2010-2017 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in
+ *  all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ *  THE SOFTWARE.
+ */
+
+#include <sys/param.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <limits.h>
+#include <libgen.h>
+
+#include <vector>
+#include <cerrno>
+#include <cstring>
+
+#include <FileTools/PathManip.h>
+#include <Exceptions.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+string
+canonicalizePath(const string &path) {
+	#ifdef __GLIBC__
+		// We're using a GNU extension here. See the 'BUGS'
+		// section of the realpath(3) Linux manpage for
+		// rationale.
+		char *tmp = realpath(path.c_str(), NULL);
+		if (tmp == NULL) {
+			int e = errno;
+			string message;
+
+			message = "Cannot resolve the path '";
+			message.append(path);
+			message.append("'");
+			throw FileSystemException(message, e, path);
+		} else {
+			string result(tmp);
+			free(tmp);
+			return result;
+		}
+	#else
+		char tmp[PATH_MAX];
+		if (realpath(path.c_str(), tmp) == NULL) {
+			int e = errno;
+			string message;
+
+			message = "Cannot resolve the path '";
+			message.append(path);
+			message.append("'");
+			throw FileSystemException(message, e, path);
+		} else {
+			return tmp;
+		}
+	#endif
+}
+
+string
+absolutizePath(const StaticString &path, const StaticString &workingDir) {
+	vector<string> components;
+	if (!startsWith(path, "/")) {
+		if (workingDir.empty()) {
+			char buffer[PATH_MAX];
+			if (getcwd(buffer, sizeof(buffer)) == NULL) {
+				int e = errno;
+				throw SystemException("Unable to query current working directory", e);
+			}
+			split(buffer + 1, '/', components);
+		} else {
+			string absoluteWorkingDir = absolutizePath(workingDir);
+			split(StaticString(absoluteWorkingDir.data() + 1, absoluteWorkingDir.size() - 1),
+				'/', components);
+		}
+	}
+
+	const char *begin = path.data();
+	const char *end = path.data() + path.size();
+
+	// Skip leading slashes.
+	while (begin < end && *begin == '/') {
+		begin++;
+	}
+
+	while (begin < end) {
+		const char *next = (const char *) memchr(begin, '/', end - begin);
+		if (next == NULL) {
+			next = end;
+		}
+
+		StaticString component(begin, next - begin);
+		if (component == "..") {
+			if (!components.empty()) {
+				components.pop_back();
+			}
+		} else if (component != ".") {
+			components.push_back(component);
+		}
+
+		// Skip slashes until beginning of next path component.
+		begin = next + 1;
+		while (begin < end && *begin == '/') {
+			begin++;
+		}
+	}
+
+	string result;
+	vector<string>::const_iterator c_it, c_end = components.end();
+	for (c_it = components.begin(); c_it != c_end; c_it++) {
+		result.append("/");
+		result.append(*c_it);
+	}
+	if (result.empty()) {
+		result = "/";
+	}
+	return result;
+}
+
+string
+resolveSymlink(const StaticString &path) {
+	string pathNt(path.data(), path.size());
+	char buf[PATH_MAX];
+	ssize_t size;
+
+	size = readlink(pathNt.c_str(), buf, sizeof(buf) - 1);
+	if (size == -1) {
+		if (errno == EINVAL) {
+			return pathNt;
+		} else {
+			int e = errno;
+			string message = "Cannot resolve possible symlink '";
+			message.append(path.data(), path.size());
+			message.append("'");
+			throw FileSystemException(message, e, pathNt);
+		}
+	} else {
+		buf[size] = '\0';
+		if (buf[0] == '\0') {
+			string message = "The file '";
+			message.append(path.data(), path.size());
+			message.append("' is a symlink, and it refers to an empty filename. This is not allowed.");
+			throw FileSystemException(message, ENOENT, pathNt);
+		} else if (buf[0] == '/') {
+			// Symlink points to an absolute path.
+			return buf;
+		} else {
+			return extractDirNameStatic(path) + "/" + buf;
+		}
+	}
+}
+
+string
+extractDirName(const StaticString &path) {
+	DynamicBuffer pathCopy(path.size() + 1);
+	memcpy(pathCopy.data, path.data(), path.size());
+	pathCopy.data[path.size()] = '\0';
+	return string(dirname(pathCopy.data));
+}
+
+StaticString
+extractDirNameStatic(const StaticString &path) {
+	if (path.empty()) {
+		return StaticString(".", 1);
+	}
+
+	const char *data = path.data();
+	const char *end = path.data() + path.size();
+
+	// Ignore trailing '/' characters.
+	while (end > data && end[-1] == '/') {
+		end--;
+	}
+	if (end == data) {
+		// Apparently the entire path consists of slashes.
+		return StaticString("/", 1);
+	}
+
+	// Find last '/'.
+	end--;
+	while (end > data && *end != '/') {
+		end--;
+	}
+	if (end == data) {
+		if (*data == '/') {
+			// '/' found, but it's the first character in the path.
+			return StaticString("/", 1);
+		} else {
+			// No '/' found in path.
+			return StaticString(".", 1);
+		}
+	} else {
+		// '/' found and it's not the first character in path.
+		// 'end' points to that '/' character.
+		// Skip to first non-'/' character.
+		while (end >= data && *end == '/') {
+			end--;
+		}
+		if (end < data) {
+			// The entire path consists of '/' characters.
+			return StaticString("/", 1);
+		} else {
+			return StaticString(data, end - data + 1);
+		}
+	}
+}
+
+string
+extractBaseName(const StaticString &path) {
+	DynamicBuffer pathNt(path.size() + 1);
+	memcpy(pathNt.data, path.data(), path.size());
+	pathNt.data[path.size()] = '\0';
+	string result = basename(pathNt.data);
+	return result;
+}
+
+
+} // namespace Passenger