passenger 2.2.2 → 2.2.3

data/ext/common/Base64.cpp

@@ -0,0 +1,143 @@
+/*
+ * Base64 encoding and decoding routines
+ *
+ * Copyright (C) 2004-2008 René Nyffenegger
+ * Modified by Phusion for inclusion in Phusion Passenger.
+ *
+ * This source code is provided 'as-is', without any express or implied
+ * warranty. In no event will the author be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this source code must not be misrepresented; you must not
+ *    claim that you wrote the original source code. If you use this source code
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original source code.
+ *
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+ *
+ */
+
+#include <ctype.h>
+#include "Base64.h"
+
+namespace Passenger {
+
+static const std::string base64_chars = 
+             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+             "abcdefghijklmnopqrstuvwxyz"
+             "0123456789+/";
+
+
+static inline bool
+is_base64(unsigned char c) {
+	return isalnum(c) || c == '+' || c == '/';
+}
+
+string
+Base64::encode(const unsigned char *bytes_to_encode, unsigned int in_len) {
+	std::string ret;
+	int i = 0;
+	int j = 0;
+	unsigned char char_array_3[3];
+	unsigned char char_array_4[4];
+
+	// According to Wikipedia, base64-encoded data is usually 137%
+	// + 814 bytes larger than the original. Here we reserve a little
+	// more than that to avoid memory reallocations.
+	ret.reserve((std::string::size_type) (in_len * 1.37) + 1024);
+	
+	while (in_len--) {
+		char_array_3[i++] = *(bytes_to_encode++);
+		if (i == 3) {
+			char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+			char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+			char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+			char_array_4[3] = char_array_3[2] & 0x3f;
+
+			for(i = 0; i < 4; i++) {
+				ret += base64_chars[char_array_4[i]];
+			}
+			i = 0;
+		}
+	}
+
+	if (i) {
+		for(j = i; j < 3; j++)
+			char_array_3[j] = '\0';
+
+		char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+		char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+		char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+		char_array_4[3] = char_array_3[2] & 0x3f;
+
+		for (j = 0; (j < i + 1); j++)
+			ret += base64_chars[char_array_4[j]];
+
+		while((i++ < 3))
+			ret += '=';
+	}
+
+	return ret;
+}
+
+std::string
+Base64::decode(const unsigned char *base64_data, unsigned int in_len) {
+	int i = 0;
+	int j = 0;
+	int in_ = 0;
+	unsigned char char_array_4[4], char_array_3[3];
+	std::string ret;
+	unsigned int reserved_size;
+
+	// The decoded data should be about this large.
+	if (in_len > 814) {
+		reserved_size = (unsigned int) ((in_len - 814) / 137.0) * 100;
+	} else {
+		reserved_size = in_len;
+	}
+	ret.reserve(reserved_size);
+	
+	while (in_len-- && ( base64_data[in_] != '=') && is_base64(base64_data[in_])) {
+		char_array_4[i++] = base64_data[in_]; in_++;
+		if (i == 4) {
+			for (i = 0; i <4; i++)
+				char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+			char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+			for (i = 0; i < 3; i++)
+				ret += char_array_3[i];
+			i = 0;
+		}
+	}
+
+	if (i) {
+		for (j = i; j <4; j++)
+			char_array_4[j] = 0;
+
+		for (j = 0; j <4; j++)
+			char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+		char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+		for (j = 0; (j < i - 1); j++)
+			ret += char_array_3[j];
+	}
+
+	return ret;
+}
+
+} // namespace Passenger

data/ext/common/Base64.h

@@ -0,0 +1,57 @@
+/*
+ * Base64 encoding and decoding routines
+ *
+ * Copyright (C) 2004-2008 René Nyffenegger
+ * Modified by Phusion for inclusion in Phusion Passenger.
+ *
+ * This source code is provided 'as-is', without any express or implied
+ * warranty. In no event will the author be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this source code must not be misrepresented; you must not
+ *    claim that you wrote the original source code. If you use this source code
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original source code.
+ *
+ * 3. This notice may not be removed or altered from any source distribution.
+ *
+ * René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+ *
+ */
+
+#ifndef _PASSENGER_BASE64_H_
+#define _PASSENGER_BASE64_H_
+
+#include <iostream>
+#include <string>
+#include "StaticString.h"
+
+namespace Passenger {
+
+using namespace std;
+
+class Base64 {
+public:
+	static string encode(const StaticString &data) {
+		return encode((const unsigned char *) data.data(), data.size());
+	}
+	
+	static string decode(const StaticString &base64_data) {
+		return decode((const unsigned char *) base64_data.data(), base64_data.size());
+	}
+	
+	static string encode(const unsigned char *data, unsigned int len);
+	
+	static string decode(const unsigned char *base64_data, unsigned int len);
+};
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_BASE64_H_ */

data/ext/common/CachedFileStat.cpp

@@ -23,97 +23,40 @@
  *  THE SOFTWARE.
  */
 #include "CachedFileStat.h"
+#include "CachedFileStat.hpp"
 
-#include <map>
-#include <list>
+extern "C" {
 
-#include <boost/shared_ptr.hpp>
-#include <boost/thread.hpp>
-
-using namespace std;
-using namespace boost;
-using namespace Passenger;
-
-// CachedMultiFileStat is written in C++, with a C wrapper API around it.
-// I'm not going to reinvent my own linked list and hash table in C when I
-// can just use the STL.
-struct CachedMultiFileStat {
-	struct Item {
-		string filename;
-		CachedFileStat cstat;
-		
-		Item(const string &filename)
-			: cstat(filename)
-		{
-			this->filename = filename;
-		}
-	};
-	
-	typedef shared_ptr<Item> ItemPtr;
-	typedef list<ItemPtr> ItemList;
-	typedef map<string, ItemList::iterator> ItemMap;
+struct CachedFileStat {
+	Passenger::CachedFileStat cfs;
 	
-	unsigned int maxSize;
-	ItemList items;
-	ItemMap cache;
-	boost::mutex lock;
-	
-	CachedMultiFileStat(unsigned int maxSize) {
-		this->maxSize = maxSize;
-	}
-	
-	int stat(const string &filename, struct stat *buf, unsigned int throttleRate = 0) {
-		boost::unique_lock<boost::mutex> l(lock);
-		ItemMap::iterator it(cache.find(filename));
-		ItemPtr item;
-		int ret;
-		
-		if (it == cache.end()) {
-			// Filename not in cache.
-			// If cache is full, remove the least recently used
-			// cache entry.
-			if (cache.size() == maxSize) {
-				ItemList::iterator listEnd(items.end());
-				listEnd--;
-				string filename((*listEnd)->filename);
-				items.pop_back();
-				cache.erase(filename);
-			}
-			
-			// Add to cache as most recently used.
-			item = ItemPtr(new Item(filename));
-			items.push_front(item);
-			cache[filename] = items.begin();
-		} else {
-			// Cache hit.
-			item = *it->second;
-			
-			// Mark this cache item as most recently used.
-			items.erase(it->second);
-			items.push_front(item);
-			cache[filename] = items.begin();
-		}
-		ret = item->cstat.refresh(throttleRate);
-		*buf = item->cstat.info;
-		return ret;
-	}
+	CachedFileStat(unsigned int maxSize): cfs(maxSize) { }
 };
 
-CachedMultiFileStat *
-cached_multi_file_stat_new(unsigned int max_size) {
-	return new CachedMultiFileStat(max_size);
+CachedFileStat *
+cached_file_stat_new(unsigned int max_size) {
+	return new CachedFileStat(max_size);
 }
 
 void
-cached_multi_file_stat_free(CachedMultiFileStat *mstat) {
-	delete mstat;
+cached_file_stat_free(CachedFileStat *cstat) {
+	delete cstat;
 }
 
 int
-cached_multi_file_stat_perform(CachedMultiFileStat *mstat,
-                               const char *filename,
-                               struct stat *buf,
-                               unsigned int throttle_rate)
-{
-	return mstat->stat(filename, buf, throttle_rate);
+cached_file_stat_perform(CachedFileStat *cstat,
+                         const char *filename,
+                         struct stat *buf,
+                         unsigned int throttle_rate) {
+	try {
+		return cstat->cfs.stat(filename, buf, throttle_rate);
+	} catch (const Passenger::TimeRetrievalException &e) {
+		errno = e.code();
+		return -1;
+	} catch (const boost::thread_interrupted &) {
+		errno = EINTR;
+		return -1;
+	}
 }
+
+} // extern "C"

data/ext/common/CachedFileStat.h

@@ -25,141 +25,27 @@
 #ifndef _PASSENGER_CACHED_FILE_STAT_H_
 #define _PASSENGER_CACHED_FILE_STAT_H_
 
-#include <sys/types.h>
 #include <sys/stat.h>
-#include <unistd.h>
-#include <time.h>
 
 #ifdef __cplusplus
+extern "C" {
+#endif
 
-#include <errno.h>
-#include <string>
-#include <oxt/system_calls.hpp>
-
-#include "SystemTime.h"
-
-namespace Passenger {
-
-using namespace std;
-using namespace oxt;
-
-/**
- * CachedFileStat allows one to stat() a file at a throttled rate, in order
- * to minimize stress on the filesystem. It does this by caching the old stat
- * data for a specified amount of time.
- */
-class CachedFileStat {
-private:
-	/** The last return value of stat(). */
-	int last_result;
-
-	/** The errno set by the last stat() call. */
-	int last_errno;
-
-	/** The filename of the file to stat. */
-	string filename;
-
-	/** The last time a stat() was performed. */
-	time_t last_time;
-	
-	/**
-	 * Checks whether <em>interval</em> seconds have elapsed since <em>begin</em>
-	 * The current time is returned via the <tt>currentTime</tt> argument,
-	 * so that the caller doesn't have to call time() again if it needs the current
-	 * time.
-	 *
-	 * @pre begin <= time(NULL)
-	 * @return Whether <tt>interval</tt> seconds have elapsed since <tt>begin</tt>.
-	 * @throws SystemException Something went wrong while retrieving the time.
-	 * @throws boost::thread_interrupted
-	 */
-	bool expired(time_t begin, unsigned int interval, time_t &currentTime) {
-		currentTime = SystemTime::get();
-		return (unsigned int) (currentTime - begin) >= interval;
-	}
-
-public:
-	/** The cached stat info. */
-	struct stat info;
-	
-	/**
-	 * Creates a new CachedFileStat object. The file will not be
-	 * stat()ted until you call refresh().
-	 *
-	 * @param filename The file to stat.
-	 */
-	CachedFileStat(const string &filename) {
-		memset(&info, 0, sizeof(struct stat));
-		last_result = -1;
-		last_errno = 0;
-		this->filename = filename;
-		last_time = 0;
-	}
-	
-	/**
-	 * Re-stat() the file, if necessary. If <tt>throttleRate</tt> seconds have
-	 * passed since the last time stat() was called, then the file will be
-	 * re-stat()ted.
-	 *
-	 * The stat information, which may either be the result of a new stat() call
-	 * or just the old cached information, is be available in the <tt>info</tt>
-	 * member.
-	 *
-	 * @return 0 if the stat() call succeeded or if no stat() was performed,
-	 *         -1 if something went wrong while statting the file. In the latter
-	 *         case, <tt>errno</tt> will be populated with an appropriate error code.
-	 * @throws SystemException Something went wrong while retrieving the
-	 *         system time. stat() errors will <em>not</em> result in SystemException
-	 *         being thrown.
-	 * @throws boost::thread_interrupted
-	 */
-	int refresh(unsigned int throttleRate) {
-		time_t currentTime;
-		
-		if (expired(last_time, throttleRate, currentTime)) {
-			last_result = syscalls::stat(filename.c_str(), &info);
-			last_errno = errno;
-			last_time = currentTime;
-			return last_result;
-		} else {
-			errno = last_errno;
-			return last_result;
-		}
-	}
-};
 
-} // namespace Passenger
+/** C bindings for Passenger::CachedFileStat. */
 
-#endif /* __cplusplus */
+typedef struct CachedFileStat CachedFileStat;
 
+CachedFileStat *cached_file_stat_new(unsigned int max_size);
+void cached_file_stat_free(CachedFileStat *cstat);
+int  cached_file_stat_perform(CachedFileStat *cstat,
+                              const char *filename,
+                              struct stat *buf,
+                              unsigned int throttle_rate);
 
-#ifdef __cplusplus
-	extern "C" {
-#endif
-
-/**
- * CachedMultiFileStat allows one to stat() files at a throttled rate, in order
- * to minimize stress on the filesystem. It does this by caching the old stat
- * data for a specified amount of time.
- *
- * Unlike CachedFileStat, which can only stat() one specific file per
- * CachedFileStat object, CachedMultiFileStat can stat() any file. The
- * number of cached stat() information is limited by the given cache size.
- *
- * This class is fully thread-safe.
- */
-typedef struct CachedMultiFileStat CachedMultiFileStat;
-
-CachedMultiFileStat *cached_multi_file_stat_new(unsigned int max_size);
-void cached_multi_file_stat_free(CachedMultiFileStat *mstat);
-int  cached_multi_file_stat_perform(CachedMultiFileStat *mstat,
-                                    const char *filename,
-                                    struct stat *buf,
-                                    unsigned int throttle_rate);
 
 #ifdef __cplusplus
-	}
+}
 #endif
 
 #endif /* _PASSENGER_CACHED_FILE_STAT_H_ */
-