passenger 4.0.48 → 4.0.49

data/ext/common/FileDescriptor.h

@@ -68,19 +68,19 @@ private:
 	struct SharedData {
 		int fd;
 		bool autoClose;
-		
+
 		SharedData(int fd, bool autoClose) {
 			this->fd = fd;
 			this->autoClose = autoClose;
 		}
-		
+
 		~SharedData() {
 			if (fd >= 0 && autoClose) {
 				this_thread::disable_syscall_interruption dsi;
 				syscalls::close(fd);
 			}
 		}
-		
+
 		void close(bool checkErrors = true) {
 			if (fd >= 0) {
 				this_thread::disable_syscall_interruption dsi;
@@ -89,7 +89,7 @@ private:
 				safelyClose(theFd, !checkErrors);
 			}
 		}
-		
+
 		void detach() {
 			fd = -1;
 		}
@@ -99,14 +99,14 @@ private:
 	boost::shared_ptr<SharedData> data;
 
 public:
-	/** 
+	/**
 	 * Creates a new empty FileDescriptor instance that has no underlying
 	 * file descriptor.
 	 *
 	 * @post *this == -1
 	 */
 	FileDescriptor() { }
-	
+
 	/**
 	 * Creates a new FileDescriptor instance with the given fd as a handle.
 	 *
@@ -127,7 +127,7 @@ public:
 			errno = e;
 		}
 	}
-	
+
 	/**
 	 * Close the underlying file descriptor. If it was already closed, then
 	 * nothing will happen. If there are multiple copies of this FileDescriptor
@@ -147,7 +147,7 @@ public:
 			data.reset();
 		}
 	}
-	
+
 	/**
 	 * Detach from the underlying file descriptor without closing it.
 	 * This FileDescriptor and all copies will no longer affect the
@@ -166,7 +166,7 @@ public:
 			return -1;
 		}
 	}
-	
+
 	/**
 	 * Overloads the integer cast operator so that it will return the underlying
 	 * file descriptor handle as an integer.
@@ -180,7 +180,7 @@ public:
 			return data->fd;
 		}
 	}
-	
+
 	FileDescriptor &operator=(int fd) {
 		/* Make sure that the 'new' and 'delete' operators don't
 		 * overwrite errno so that we can write code like this:
@@ -200,7 +200,7 @@ public:
 		errno = e;
 		return *this;
 	}
-	
+
 	FileDescriptor &operator=(const FileDescriptor &other) {
 		/* Make sure that the 'delete' operator implicitly invoked by
 		 * boost::shared_ptr doesn't overwrite errno so that we can write code
@@ -226,11 +226,11 @@ public:
 class FileDescriptorPair: public pair<FileDescriptor, FileDescriptor> {
 public:
 	FileDescriptorPair() { }
-	
+
 	FileDescriptorPair(const FileDescriptor &a, const FileDescriptor &b)
 		: pair<FileDescriptor, FileDescriptor>(a, b)
 		{ }
-	
+
 	FileDescriptor &operator[](int index) {
 		if (index == 0) {
 			return first;
@@ -257,11 +257,11 @@ class EventFd {
 private:
 	int reader;
 	int writer;
-	
+
 public:
 	EventFd() {
 		int fds[2];
-		
+
 		if (syscalls::pipe(fds) == -1) {
 			int e = errno;
 			throw SystemException("Cannot create a pipe", e);
@@ -269,13 +269,13 @@ public:
 		reader = fds[0];
 		writer = fds[1];
 	}
-	
+
 	~EventFd() {
 		this_thread::disable_syscall_interruption dsi;
 		syscalls::close(reader);
 		syscalls::close(writer);
 	}
-	
+
 	void notify() {
 		ssize_t ret = syscalls::write(writer, "x", 1);
 		if (ret == -1 && errno != EAGAIN) {
@@ -283,7 +283,7 @@ public:
 			throw SystemException("Cannot write notification data", e);
 		}
 	}
-	
+
 	int fd() const {
 		return reader;
 	}

data/ext/common/Logging.cpp

@@ -74,7 +74,7 @@ _prepareLogEntry(std::stringstream &sstream, const char *file, unsigned int line
 			}
 		}
 	}
-	
+
 	the_time = time(NULL);
 	localtime_r(&the_time, &the_tm);
 	strftime(datetime_buf, sizeof(datetime_buf) - 1, "%F %H:%M:%S", &the_tm);

data/ext/common/MessageClient.h

@@ -45,17 +45,17 @@ class MessageClient {
 protected:
 	FileDescriptor fd;
 	bool shouldAutoDisconnect;
-	
+
 	/* sendUsername() and sendPassword() exist and are virtual in order to facilitate unit testing. */
-	
+
 	virtual void sendUsername(int fd, const StaticString &username, unsigned long long *timeout) {
 		writeScalarMessage(fd, username);
 	}
-	
+
 	virtual void sendPassword(int fd, const StaticString &userSuppliedPassword, unsigned long long *timeout) {
 		writeScalarMessage(fd, userSuppliedPassword);
 	}
-	
+
 	/**
 	 * Authenticate to the server with the given username and password.
 	 *
@@ -69,10 +69,10 @@ protected:
 		unsigned long long *timeout)
 	{
 		vector<string> args;
-		
+
 		sendUsername(fd, username, timeout);
 		sendPassword(fd, userSuppliedPassword, timeout);
-		
+
 		if (!readArrayMessage(fd, args, timeout)) {
 			throw IOException("The message server did not send an authentication response.");
 		} else if (args.size() != 1) {
@@ -81,19 +81,19 @@ protected:
 			throw SecurityException("The message server denied authentication: " + args[0]);
 		}
 	}
-	
+
 	void checkConnection() {
 		if (!connected()) {
 			throw IOException("Not connected");
 		}
 	}
-	
+
 	void autoDisconnect() {
 		if (shouldAutoDisconnect) {
 			fd.close(false);
 		}
 	}
-	
+
 public:
 	/**
 	 * Create a new MessageClient object. It doesn't actually connect to the server until
@@ -106,9 +106,9 @@ public:
 		 */
 		shouldAutoDisconnect = true;
 	}
-	
+
 	virtual ~MessageClient() { }
-	
+
 	/**
 	 * Connect to the given MessageServer. If a connection was already established,
 	 * then the old connection will be closed and a new connection will be established.
@@ -134,9 +134,9 @@ public:
 	{
 		TRACE_POINT();
 		ScopeGuard g(boost::bind(&MessageClient::autoDisconnect, this));
-		
+
 		fd = connectToServer(serverAddress.c_str());
-		
+
 		vector<string> args;
 		if (!readArrayMessage(fd, args)) {
 			throw IOException("The message server closed the connection before sending a version identifier.");
@@ -149,29 +149,29 @@ public:
 				args[1] + ".";
 			throw IOException(message);
 		}
-		
+
 		authenticate(username, userSuppliedPassword, NULL);
-		
+
 		g.clear();
 		return this;
 	}
-	
+
 	void disconnect() {
 		fd.close();
 	}
-	
+
 	bool connected() const {
 		return fd != -1;
 	}
-	
+
 	void setAutoDisconnect(bool value) {
 		shouldAutoDisconnect = value;
 	}
-	
+
 	FileDescriptor getConnection() const {
 		return fd;
 	}
-	
+
 	/**
 	 * @throws SystemException
 	 * @throws TimeoutException
@@ -180,7 +180,7 @@ public:
 	bool read(vector<string> &args, unsigned long long *timeout = NULL) {
 		return readArray(args);
 	}
-	
+
 	/**
 	 * @throws SystemException
 	 * @throws TimeoutException
@@ -193,7 +193,7 @@ public:
 		g.clear();
 		return result;
 	}
-	
+
 	/**
 	 * @throws SystemException
 	 * @throws SecurityException
@@ -212,7 +212,7 @@ public:
 			return false;
 		}
 	}
-	
+
 	/**
 	 * @throws SystemExeption
 	 * @throws IOException
@@ -230,7 +230,7 @@ public:
 		g.clear();
 		return result;
 	}
-	
+
 	/**
 	 * @throws SystemException
 	 * @throws boost::thread_interrupted
@@ -252,7 +252,7 @@ public:
 			throw;
 		}
 	}
-	
+
 	/**
 	 * @throws SystemException
 	 * @throws TimeoutException
@@ -264,7 +264,7 @@ public:
 		writeScalarMessage(fd, data, size, timeout);
 		g.clear();
 	}
-	
+
 	/**
 	 * @throws SystemException
 	 * @throws TimeoutException
@@ -276,7 +276,7 @@ public:
 		writeScalarMessage(fd, data, timeout);
 		g.clear();
 	}
-	
+
 	/**
 	 * @throws SystemException
 	 * @throws boost::thread_interrupted

data/ext/common/MessageReadersWriters.h

@@ -75,7 +75,7 @@
        char buf[1024];
        ssize_t size = recv(fd, buf, sizeof(buf));
        size_t consumed = 0;
-       
+
        // ...and process it all. We only feed data to the message object
        // that hasn't already been fed.
        while (consumed < size) {
@@ -119,22 +119,22 @@ using namespace std;
  */
 class Uint16Message {
 private:
-	uint16_t val;
-	uint8_t  consumed;
-	
+	boost::uint16_t val;
+	boost::uint8_t  consumed;
+
 public:
 	Uint16Message() {
 		consumed = 0;
 	}
-	
+
 	void reset() {
 		consumed = 0;
 	}
-	
+
 	size_t feed(const char *data, size_t size) {
 		size_t locallyConsumed;
-		
-		locallyConsumed = std::min(size, sizeof(uint16_t) - consumed);
+
+		locallyConsumed = std::min(size, sizeof(boost::uint16_t) - consumed);
 		memcpy((char *) &val + consumed, data, locallyConsumed);
 		consumed += locallyConsumed;
 		if (locallyConsumed > 0 && done()) {
@@ -142,16 +142,16 @@ public:
 		}
 		return locallyConsumed;
 	}
-	
+
 	bool done() const {
-		return consumed == sizeof(uint16_t);
+		return consumed == sizeof(boost::uint16_t);
 	}
-	
-	uint16_t value() const {
+
+	boost::uint16_t value() const {
 		return val;
 	}
-	
-	static void generate(void *buf, uint16_t val) {
+
+	static void generate(void *buf, boost::uint16_t val) {
 		val = htons(val);
 		memcpy(buf, &val, sizeof(val));
 	}
@@ -162,22 +162,22 @@ public:
  */
 class Uint32Message {
 private:
-	uint32_t val;
-	uint8_t  consumed;
-	
+	boost::uint32_t val;
+	boost::uint8_t  consumed;
+
 public:
 	Uint32Message() {
 		consumed = 0;
 	}
-	
+
 	void reset() {
 		consumed = 0;
 	}
-	
+
 	size_t feed(const char *data, size_t size) {
 		size_t locallyConsumed;
-		
-		locallyConsumed = std::min(size, sizeof(uint32_t) - consumed);
+
+		locallyConsumed = std::min(size, sizeof(boost::uint32_t) - consumed);
 		memcpy((char *) &val + consumed, data, locallyConsumed);
 		consumed += locallyConsumed;
 		if (locallyConsumed > 0 && done()) {
@@ -185,16 +185,16 @@ public:
 		}
 		return locallyConsumed;
 	}
-	
+
 	bool done() const {
-		return consumed == sizeof(uint32_t);
+		return consumed == sizeof(boost::uint32_t);
 	}
-	
-	uint32_t value() const {
+
+	boost::uint32_t value() const {
 		return val;
 	}
-	
-	static void generate(void *buf, uint32_t val) {
+
+	static void generate(void *buf, boost::uint32_t val) {
 		val = htonl(val);
 		memcpy(buf, &val, sizeof(val));
 	}
@@ -208,7 +208,7 @@ public:
 	enum Error {
 		TOO_LARGE
 	};
-	
+
 private:
 	enum State {
 		READING_HEADER,
@@ -216,20 +216,20 @@ private:
 		DONE,
 		ERROR
 	};
-	
-	uint16_t toReserve;
-	uint16_t maxSize;
+
+	boost::uint16_t toReserve;
+	boost::uint16_t maxSize;
 	Uint16Message headerReader;
-	uint8_t state;
-	uint8_t error;
+	boost::uint8_t state;
+	boost::uint8_t error;
 	string buffer;
 	vector<StaticString> result;
-	
+
 	void parseBody(const char *data, size_t size) {
 		const char *start = data;
 		const char *terminator;
 		size_t rest = size;
-		
+
 		while ((terminator = (const char *) memchr(start, '\0', rest)) != NULL) {
 			size_t len = terminator - start;
 			result.push_back(StaticString(start, len));
@@ -237,23 +237,23 @@ private:
 			rest = size - (start - data);
 		}
 	}
-	
+
 public:
 	ArrayMessage() {
 		state = READING_HEADER;
 		toReserve = 0;
 		maxSize = 0;
 	}
-	
-	void reserve(uint16_t size) {
+
+	void reserve(boost::uint16_t size) {
 		toReserve = size;
 		result.reserve(size);
 	}
-	
-	void setMaxSize(uint16_t size) {
+
+	void setMaxSize(boost::uint16_t size) {
 		maxSize = size;
 	}
-	
+
 	void reset() {
 		state = READING_HEADER;
 		headerReader.reset();
@@ -263,14 +263,14 @@ public:
 			result.reserve(toReserve);
 		}
 	}
-	
+
 	size_t feed(const char *data, size_t size) {
 		size_t consumed = 0;
-		
+
 		while (consumed < size && !done()) {
 			const char *current = data + consumed;
 			size_t rest = size - consumed;
-			
+
 			switch (state) {
 			case READING_HEADER:
 				consumed += headerReader.feed(current, rest);
@@ -311,23 +311,23 @@ public:
 		}
 		return consumed;
 	}
-	
+
 	bool done() const {
 		return state == DONE || state == ERROR;
 	}
-	
+
 	bool hasError() const {
 		return state == ERROR;
 	}
-	
+
 	Error errorCode() const {
 		return (Error) error;
 	}
-	
+
 	const vector<StaticString> &value() const {
 		return result;
 	}
-	
+
 	/**
 	 * Given a bunch of array items, generates an array message. The message is
 	 * generated in the form of an array of StaticStrings which must all be written
@@ -346,30 +346,30 @@ public:
 	 * @param outCount The number of items in <em>out</em>.
 	 */
 	static void generate(StaticString args[], unsigned int argsCount,
-		char headerBuf[sizeof(uint16_t)], StaticString *out, unsigned int outCount)
+		char headerBuf[sizeof(boost::uint16_t)], StaticString *out, unsigned int outCount)
 	{
 		if (OXT_UNLIKELY(outCount < outputSize(argsCount))) {
 			throw ArgumentException("outCount too small.");
 		}
-		
+
 		unsigned int size = 0;
 		unsigned int i;
-		
+
 		for (i = 0; i < argsCount; i++) {
 			size += args[i].size() + 1;
 		}
 		if (OXT_UNLIKELY(size > 0xFFFF)) {
 			throw ArgumentException("Data size exceeds maximum size for array messages.");
 		}
-		
+
 		Uint16Message::generate(headerBuf, size);
-		out[0] = StaticString(headerBuf, sizeof(uint16_t));
+		out[0] = StaticString(headerBuf, sizeof(boost::uint16_t));
 		for (i = 0; i < argsCount; i++) {
 			out[1 + 2 * i] = args[i];
 			out[1 + 2 * i + 1] = StaticString("\0", 1);
 		}
 	}
-	
+
 	static unsigned int outputSize(unsigned int argsCount) {
 		return argsCount * 2 + 1;
 	}
@@ -383,7 +383,7 @@ public:
 	enum Error {
 		TOO_LARGE
 	};
-	
+
 private:
 	enum State {
 		READING_HEADER,
@@ -391,24 +391,24 @@ private:
 		DONE,
 		ERROR
 	};
-	
-	uint8_t state;
-	uint8_t error;
-	uint32_t maxSize;
+
+	boost::uint8_t state;
+	boost::uint8_t error;
+	boost::uint32_t maxSize;
 	Uint32Message headerReader;
 	string buffer;
 	StaticString result;
-	
+
 public:
-	ScalarMessage(uint32_t maxSize = 0) {
+	ScalarMessage(boost::uint32_t maxSize = 0) {
 		state = READING_HEADER;
 		this->maxSize = maxSize;
 	}
-	
-	void setMaxSize(uint32_t maxSize) {
+
+	void setMaxSize(boost::uint32_t maxSize) {
 		this->maxSize = maxSize;
 	}
-	
+
 	/**
 	 * Resets the internal state so that this object can be used for processing
 	 * another scalar message.
@@ -425,14 +425,14 @@ public:
 		headerReader.reset();
 		buffer.clear();
 	}
-	
+
 	size_t feed(const char *data, size_t size) {
 		size_t consumed = 0;
-		
+
 		while (consumed < size && !done()) {
 			const char *current = data + consumed;
 			size_t rest = size - consumed;
-			
+
 			switch (state) {
 			case READING_HEADER:
 				consumed += headerReader.feed(current, rest);
@@ -473,41 +473,41 @@ public:
 		}
 		return consumed;
 	}
-	
+
 	bool done() const {
 		return state == DONE || state == ERROR;
 	}
-	
+
 	bool hasError() const {
 		return state == ERROR;
 	}
-	
+
 	Error errorCode() const {
 		return (Error) error;
 	}
-	
+
 	const StaticString &value() const {
 		return result;
 	}
-	
-	static void generate(const StaticString &data, char headerBuf[sizeof(uint32_t)],
+
+	static void generate(const StaticString &data, char headerBuf[sizeof(boost::uint32_t)],
 		StaticString output[2])
 	{
 		if (OXT_UNLIKELY(data.size() > 0xFFFFFFFF)) {
 			throw ArgumentException("Data size exceeds maximum size for scalar messages.");
 		}
-		
+
 		Uint32Message::generate(headerBuf, data.size());
-		output[0] = StaticString(headerBuf, sizeof(uint32_t));
+		output[0] = StaticString(headerBuf, sizeof(boost::uint32_t));
 		output[1] = data;
 	}
 
 	// output must be at least count + 1 in length
 	static void generate(const StaticString data[], unsigned int count,
-		char headerBuf[sizeof(uint32_t)], StaticString *output)
+		char headerBuf[sizeof(boost::uint32_t)], StaticString *output)
 	{
 		unsigned int i;
-		uint32_t totalSize = 0;
+		boost::uint32_t totalSize = 0;
 
 		for (i = 0; i < count; i++) {
 			if (OXT_UNLIKELY(data[i].size() > 0xFFFFFFFF)) {
@@ -518,7 +518,7 @@ public:
 		}
 
 		Uint32Message::generate(headerBuf, totalSize);
-		output[0] = StaticString(headerBuf, sizeof(uint32_t));
+		output[0] = StaticString(headerBuf, sizeof(boost::uint32_t));
 	}
 };