RubyGems - passenger - Versions diffs - 3.0.4 → 3.0.5 - Mend

passenger 3.0.4 → 3.0.5

Potentially problematic release.

This version of passenger might be problematic. Click here for more details.

Files changed (571) hide show

@@ -0,0 +1,26 @@
+<!DOCTYPE html
+     PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Passenger Ruby API</title>
+  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+</head>
+<frameset cols="20%,*">
+    <frameset rows="15%,55%,30%">
+        <frame src="fr_file_index.html"   title="Files" name="Files" />
+        <frame src="fr_class_index.html"  name="Classes" />
+        <frame src="fr_method_index.html" name="Methods" />
+    </frameset>
+    <frame  src="files/README.html" name="docwin" />
+    <noframes>
+          <body bgcolor="white">
+            Click <a href="html/index.html">here</a> for a non-frames
+            version of this page.
+          </body>
+    </noframes>
+</frameset>
+</html>

data/doc/rdoc/rdoc-style.css ADDED

@@ -0,0 +1,187 @@
+a {
+  color: #00F;
+  text-decoration: none;
+}
+a:hover {
+  color: #77F;
+  text-decoration: underline;
+}
+body, td, p {
+  font-family: "Bitstream Vera Sans", Verdana, Arial, Helvetica, sans-serif;
+  background: #FFF;
+  color: #000;
+  margin: 0px;
+  font-size: small;
+}
+p {
+  margin-top: 0.5em;
+  margin-bottom: 0.5em;
+}
+#content {
+  margin: 2em;
+  margin-left: 3.5em;
+  margin-right: 3.5em;
+}
+#description p {
+  margin-bottom: 0.5em;
+}
+.sectiontitle {
+  margin-top: 1em;
+  margin-bottom: 1em;
+  padding: 0.5em;
+  padding-left: 2em;
+  background: #005;
+  color: #FFF;
+  font-weight: bold;
+}
+.attr-rw {
+  padding-left: 1em;
+  padding-right: 1em;
+  text-align: center;
+  color: #055;
+}
+.attr-name {
+  font-weight: bold;
+}
+.attr-desc {
+}
+.attr-value {
+  font-family: monospace;
+}
+.file-title-prefix {
+  font-size: large;
+}
+.file-title {
+  font-size: large;
+  font-weight: bold;
+  background: #005;
+  color: #FFF;
+}
+.banner {
+  background: #005;
+  color: #FFF;
+  border: 1px solid black;
+  padding: 1em;
+}
+.banner td {
+  background: transparent;
+  color: #FFF;
+}
+h1 a, h2 a, .sectiontitle a, .banner a {
+  color: #FF0;
+}
+h1 a:hover, h2 a:hover, .sectiontitle a:hover, .banner a:hover {
+  color: #FF7;
+}
+.dyn-source {
+  display: none;
+  background: #fffde8;
+  color: #000;
+  border: #ffe0bb dotted 1px;
+  margin: 0.5em 2em 0.5em 2em;
+  padding: 0.5em;
+}
+.dyn-source .cmt {
+  color: #00F;
+  font-style: italic;
+}
+.dyn-source .kw {
+  color: #070;
+  font-weight: bold;
+}
+.method {
+  margin-left: 1em;
+  margin-right: 1em;
+  margin-bottom: 1em;
+}
+.description pre {
+  padding: 0.5em;
+  border: #ffe0bb dotted 1px;
+  background: #fffde8;
+}
+.method .title {
+  font-family: monospace;
+  font-size: large;
+  border-bottom: 1px dashed black;
+  margin-bottom: 0.3em;
+  padding-bottom: 0.1em;
+}
+.method .description, .method .sourcecode {
+  margin-left: 1em;
+}
+.description p, .sourcecode p {
+  margin-bottom: 0.5em;
+}
+.method .sourcecode p.source-link {
+  text-indent: 0em;
+  margin-top: 0.5em;
+}
+.method .aka {
+  margin-top: 0.3em;
+  margin-left: 1em;
+  font-style: italic;
+  text-indent: 2em;
+}
+h1 {
+  padding: 1em;
+  margin-left: -1.5em;
+  font-size: x-large;
+  font-weight: bold;
+  color: #FFF;
+  background: #007;
+}
+h2 {
+  padding: 0.5em 1em 0.5em 1em;
+  margin-left: -1.5em;
+  font-size: large;
+  font-weight: bold;
+  color: #FFF;
+  background: #009;
+}
+h3, h4, h5, h6 {
+  color: #220088;
+  border-bottom: #5522bb solid 1px;
+}
+.sourcecode > pre {
+  padding: 0.5em;
+  border: 1px dotted black;
+  background: #FFE;
+}
+dt {
+  font-weight: bold
+}
+dd {
+  margin-bottom: 0.7em;
+}

data/ext/apache2/Configuration.cpp CHANGED

@@ -208,7 +208,7 @@ passenger_config_create_dir(apr_pool_t *p, char *dirspec) {
 	config->restartDir = NULL;
 	config->uploadBufferDir = NULL;
 	config->friendlyErrorPages = DirConfig::UNSET;
-	config->analytics = DirConfig::UNSET;
+	config->unionStationSupport = DirConfig::UNSET;
 	/*************************************/
 	return config;
 }
@@ -258,7 +258,7 @@ passenger_config_merge_dir(apr_pool_t *p, void *basev, void *addv) {
 	MERGE_THREEWAY_CONFIG(resolveSymlinksInDocRoot);
 	MERGE_THREEWAY_CONFIG(allowEncodedSlashes);
 	MERGE_THREEWAY_CONFIG(friendlyErrorPages);
-	MERGE_THREEWAY_CONFIG(analytics);
+	MERGE_THREEWAY_CONFIG(unionStationSupport);
 	/*************************************/
 	return config;
 }
@@ -310,7 +310,7 @@ DEFINE_DIR_STR_CONFIG_SETTER(cmd_union_station_key, unionStationKey)
 DEFINE_DIR_THREEWAY_CONFIG_SETTER(cmd_passenger_resolve_symlinks_in_document_root, resolveSymlinksInDocRoot)
 DEFINE_DIR_THREEWAY_CONFIG_SETTER(cmd_passenger_allow_encoded_slashes, allowEncodedSlashes)
 DEFINE_DIR_THREEWAY_CONFIG_SETTER(cmd_passenger_friendly_error_pages, friendlyErrorPages)
-DEFINE_DIR_THREEWAY_CONFIG_SETTER(cmd_passenger_analytics, analytics)
+DEFINE_DIR_THREEWAY_CONFIG_SETTER(cmd_union_station_support, unionStationSupport)
 static const char *
 cmd_passenger_spawn_method(cmd_parms *cmd, void *pcfg, const char *arg) {
@@ -644,11 +644,11 @@ const command_rec passenger_commands[] = {
 		NULL,
 		RSRC_CONF,
 		"Prestart the given web applications during startup."),
-	AP_INIT_TAKE1("PassengerAnalytics",
-		(Take1Func) cmd_passenger_analytics,
+	AP_INIT_FLAG("UnionStationSupport",
+		(Take1Func) cmd_union_station_support,
 		NULL,
 		OR_OPTIONS | ACCESS_CONF | RSRC_CONF,
-		"Whether to enable analytics logging."),
+		"Whether to enable logging through Union Station."),
 	/*****************************/

data/ext/apache2/Configuration.hpp CHANGED

@@ -195,7 +195,7 @@ struct DirConfig {
 	/**
 	 * Whether analytics logging should be enabled.
 	 */
-	Threeway analytics;
+	Threeway unionStationSupport;
 	/*************************************/
 	/*************************************/
@@ -329,8 +329,8 @@ struct DirConfig {
 		return friendlyErrorPages != DISABLED;
 	}
-	bool analyticsEnabled() const {
-		return analytics == ENABLED;
+	bool useUnionStation() const {
+		return unionStationSupport == ENABLED;
 	}
 	string getUnionStationFilterString() const {

data/ext/apache2/HelperAgent.cpp CHANGED

@@ -254,7 +254,7 @@ public:
 		pool->setMaxIdleTime(poolIdleTime);
 		messageServer->addHandler(ptr(new TimerUpdateHandler(exitTimer)));
-		messageServer->addHandler(ptr(new ApplicationPool::Server(pool)));
+		messageServer->addHandler(ptr(new ApplicationPool::Server(pool, analyticsLogger)));
 		messageServer->addHandler(ptr(new BacktracesServer()));
 		messageServer->addHandler(ptr(new ExitHandler(exitEvent)));

data/ext/apache2/Hooks.cpp CHANGED

@@ -566,7 +566,7 @@ private:
 		UPDATE_TRACE_POINT();
 		try {
 			AnalyticsLogPtr log;
-			if (config->analyticsEnabled()) {
+			if (config->useUnionStation()) {
 				log = analyticsLogger->newTransaction(
 					config->getAppGroupName(appRoot),
 					"requests",
@@ -662,7 +662,7 @@ private:
 					config->getRestartDir(),
 					DEFAULT_BACKEND_ACCOUNT_RIGHTS,
 					false,
-					config->analyticsEnabled(),
+					config->useUnionStation(),
 					log->isNull() ? AnalyticsLogPtr() : log
 				);
 				options.environmentVariables = ptr(new EnvironmentVariablesStringListCreator(r));
@@ -1058,7 +1058,7 @@ private:
 			addHeader(headers, env[i].key, env[i].val);
 		}
-		if (config->analyticsEnabled()) {
+		if (config->useUnionStation()) {
 			addHeader(headers, "PASSENGER_GROUP_NAME",
 				config->getAppGroupName(appRoot).c_str());
 			addHeader(headers, "PASSENGER_TXN_ID", log->getTxnId().c_str());

data/ext/common/ApplicationPool/Pool.h CHANGED

@@ -943,7 +943,7 @@ private:
 					this_thread::restore_syscall_interruption rsi(dsi);
 					newAppGroupCreatable.wait(l);
 					goto beginning_of_function;
-				} else if (count == max) {
+				} else if (count >= max) {
 					processInfo = inactiveApps.front();
 					P_DEBUG("Killing process " << processInfo->process->getPid() <<
 						" because an extra slot is necessary for spawning");

data/ext/common/ApplicationPool/Server.h CHANGED

@@ -237,6 +237,8 @@ private:
 	/** The application pool that's being exposed through the socket. */
 	ApplicationPool::Ptr pool;
+	AnalyticsLoggerPtr analyticsLogger;
 	/*********************************************
 	 * Message handler methods
@@ -274,7 +276,7 @@ private:
 		commonContext.requireRights(Account::GET);
 		try {
-			PoolOptions options(args, 1);
+			PoolOptions options(args, 1, analyticsLogger);
 			options.environmentVariables = ptr(new EnvironmentVariablesFetcher(
 				commonContext.channel, options));
 			options.initiateSession = false;
@@ -417,8 +419,9 @@ public:
 	 *
 	 * @param pool The pool to expose.
 	 */
-	Server(ApplicationPool::Ptr pool) {
+	Server(const ApplicationPool::Ptr &pool, const AnalyticsLoggerPtr &analyticsLogger = AnalyticsLoggerPtr()) {
 		this->pool = pool;
+		this->analyticsLogger = analyticsLogger;
 	}
 	virtual MessageServer::ClientContextPtr newClient(CommonClientContext &commonContext) {

data/ext/common/Constants.h CHANGED

@@ -26,7 +26,7 @@
 #define _PASSENGER_CONSTANTS_H_
 /* Don't forget to update lib/phusion_passenger.rb too. */
-#define PASSENGER_VERSION "3.0.4"
+#define PASSENGER_VERSION "3.0.5"
 #define FEEDBACK_FD 3

data/ext/common/LoggingAgent/FilterSupport.cpp ADDED

@@ -0,0 +1,66 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2011 Phusion
+ *
+ *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
+ *
+ *  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 "FilterSupport.h"
+#include <cstring>
+#include <cstdlib>
+using namespace Passenger;
+extern "C" {
+PassengerFilter *
+passenger_filter_create(const char *source, int size, char **error) {
+	if (size == -1) {
+		size = strlen(source);
+	}
+	try {
+		return (PassengerFilter *) new FilterSupport::Filter(StaticString(source, size));
+	} catch (const SyntaxError &e) {
+		if (error != NULL) {
+			*error = strdup(e.what());
+		}
+		return NULL;
+	}
+}
+void
+passenger_filter_free(PassengerFilter *filter) {
+	delete (FilterSupport::Filter *) filter;
+}
+char *
+passenger_filter_validate(const char *source, int size) {
+	if (size == -1) {
+		size = strlen(source);
+	}
+	try {
+		FilterSupport::Filter(StaticString(source, size));
+		return NULL;
+	} catch (const SyntaxError &e) {
+		return strdup(e.what());
+	}
+}
+} // extern "C"

data/ext/common/LoggingAgent/FilterSupport.h CHANGED

@@ -25,6 +25,8 @@
 #ifndef _PASSENGER_FILTER_SUPPORT_H_
 #define _PASSENGER_FILTER_SUPPORT_H_
+#ifdef __cplusplus
 #include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <oxt/tracable_exception.hpp>
@@ -35,6 +37,7 @@
 #include <cstring>
 #include <StaticString.h>
+#include <Exceptions.h>
 #include <Utils/StrIntUtils.h>
 namespace Passenger {
@@ -66,6 +69,8 @@ public:
 		REGEXP,
 		STRING,
 		INTEGER,
+		TRUE_LIT,
+		FALSE_LIT,
 		IDENTIFIER,
 		END_OF_DATA
 	};
@@ -126,7 +131,7 @@ private:
 		return data[pos + 1];
 	}
-	static bool isLiteralChar(char ch) {
+	static bool isIdentifierChar(char ch) {
 		return (ch >= 'a' && ch <= 'z')
 			|| (ch >= 'A' && ch <= 'Z')
 			|| (ch >= '0' && ch <= '9')
@@ -139,7 +144,7 @@ private:
 	Token logToken(const Token &token) const {
 		if (debug) {
-			printf("Token: %s\n", token.toString().c_str());
+			printf("# Token: %s\n", token.toString().c_str());
 		}
 		return token;
 	}
@@ -227,7 +232,7 @@ private:
 		}
 	}
-	Token matchRegexp() {
+	Token matchRegexp(char terminator) {
 		unsigned int start = pos;
 		bool endFound = false;
@@ -244,7 +249,7 @@ private:
 				} else {
 					pos++;
 				}
-			} else if (ch == '/') {
+			} else if (ch == terminator) {
 				pos++;
 				endFound = true;
 			} else {
@@ -274,7 +279,7 @@ private:
 		}
 	}
-	Token matchString() {
+	Token matchString(char terminator) {
 		unsigned int start = pos;
 		bool endFound = false;
@@ -291,7 +296,7 @@ private:
 				} else {
 					pos++;
 				}
-			} else if (ch == '"') {
+			} else if (ch == terminator) {
 				pos++;
 				endFound = true;
 			} else {
@@ -327,12 +332,20 @@ private:
 		    ch == '_') {
 			unsigned int start = pos;
 			pos++;
-			while (pos < data.size() && isLiteralChar(current())) {
+			while (pos < data.size() && isIdentifierChar(current())) {
 				pos++;
 			}
-			return Token(IDENTIFIER, start, pos - start, data.substr(start, pos - start));
+			StaticString val = data.substr(start, pos - start);
+			if (val == "true") {
+				return Token(TRUE_LIT, start, pos - start, val);
+			} else if (val == "false") {
+				return Token(FALSE_LIT, start, pos - start, val);
+			} else {
+				return Token(IDENTIFIER, start, pos - start, val);
+			}
 		} else {
-			raiseSyntaxError();
+			raiseSyntaxError("Identifier expected, but got an unknown token");
 			return Token(); // Shut up compiler warning.
 		}
 	}
@@ -370,9 +383,19 @@ public:
 		case ',':
 			return logToken(matchToken(COMMA, 1));
 		case '/':
-			return logToken(matchRegexp());
+			return logToken(matchRegexp('/'));
+		case '%':
+			expectingAtLeast(3);
+			if (memcmp(data.data() + pos, "%r{", 3) != 0) {
+				raiseSyntaxError("expected '%r{', but found '" +
+					data.substr(pos, 3) + "'");
+			}
+			pos += 2;
+			return logToken(matchRegexp('}'));
 		case '"':
-			return logToken(matchString());
+			return logToken(matchString('"'));
+		case '\'':
+			return logToken(matchString('\''));
 		case '-':
 			return logToken(matchInteger());
 		default:
@@ -422,6 +445,10 @@ public:
 			return "STRING";
 		case INTEGER:
 			return "INTEGER";
+		case TRUE_LIT:
+			return "TRUE";
+		case FALSE_LIT:
+			return "FALSE";
 		case IDENTIFIER:
 			return "IDENTIFIER";
 		case END_OF_DATA:
@@ -437,6 +464,7 @@ enum ValueType {
 	REGEXP_TYPE,
 	STRING_TYPE,
 	INTEGER_TYPE,
+	BOOLEAN_TYPE,
 	UNKNOWN_TYPE
 };
@@ -449,6 +477,8 @@ public:
 		RESPONSE_TIME
 	};
+	virtual ~Context() { }
 	virtual string getURI() const = 0;
 	virtual string getController() const = 0;
 	virtual int getResponseTime() const = 0;
@@ -476,6 +506,19 @@ public:
 		}
 	}
+	bool queryBoolField(FieldIdentifier id) const {
+		switch (id) {
+		case URI:
+			return !getURI().empty();
+		case CONTROLLER:
+			return !getController().empty();
+		case RESPONSE_TIME:
+			return getResponseTime() > 0;
+		default:
+			return false;
+		}
+	}
 	static ValueType getFieldType(FieldIdentifier id) {
 		switch (id) {
 		case URI:
@@ -700,6 +743,7 @@ private:
 	typedef shared_ptr<FunctionCall> FunctionCallPtr;
 	struct BooleanComponent {
+		virtual ~BooleanComponent() { }
 		virtual bool evaluate(const Context &ctx) = 0;
 	};
@@ -716,7 +760,8 @@ private:
 		GREATER_THAN,
 		GREATER_THAN_OR_EQUALS,
 		LESS_THAN,
-		LESS_THAN_OR_EQUALS
+		LESS_THAN_OR_EQUALS,
+		UNKNOWN_COMPARATOR
 	};
 	struct MultiExpression: public BooleanComponent {
@@ -730,16 +775,21 @@ private:
 		virtual bool evaluate(const Context &ctx) {
 			bool result = firstExpression->evaluate(ctx);
-			vector<Part>::iterator it = rest.begin(), end = rest.end();
-			while (it != end && result) {
-				Part &part = *it;
-				if (part.theOperator == AND) {
-					result = result && part.expression->evaluate(ctx);
+			unsigned int i = 0;
+			bool done = i == rest.size();
+			while (!done) {
+				Part &nextPart = rest[i];
+				if (nextPart.theOperator == AND) {
+					result = result && nextPart.expression->evaluate(ctx);
+					done = !result;
 				} else {
-					result = result || part.expression->evaluate(ctx);
+					result = result || nextPart.expression->evaluate(ctx);
 				}
-				it++;
+				i++;
+				done = done || i == rest.size();
 			}
 			return result;
 		}
 	};
@@ -761,6 +811,7 @@ private:
 			REGEXP_LITERAL,
 			STRING_LITERAL,
 			INTEGER_LITERAL,
+			BOOLEAN_LITERAL,
 			CONTEXT_FIELD_IDENTIFIER
 		};
@@ -774,6 +825,7 @@ private:
 				} regexp;
 			} stringOrRegexpValue;
 			int intValue;
+			bool boolValue;
 			Context::FieldIdentifier contextFieldIdentifier;
 		} u;
@@ -795,6 +847,7 @@ private:
 			new (u.stringOrRegexpValue.stringStorage) string(value.data(), value.size());
 			if (regexp) {
 				int options = REG_EXTENDED;
+				u.stringOrRegexpValue.regexp.options = 0;
 				if (caseInsensitive) {
 					options |= REG_ICASE;
 					u.stringOrRegexpValue.regexp.options |=
@@ -811,6 +864,11 @@ private:
 			u.intValue = val;
 		}
+		Value(bool val) {
+			source = BOOLEAN_LITERAL;
+			u.boolValue = val;
+		}
 		Value(Context::FieldIdentifier identifier) {
 			source = CONTEXT_FIELD_IDENTIFIER;
 			u.contextFieldIdentifier = identifier;
@@ -841,6 +899,12 @@ private:
 				return storedString();
 			case INTEGER_LITERAL:
 				return toString(u.intValue);
+			case BOOLEAN_LITERAL:
+				if (u.boolValue) {
+					return "true";
+				} else {
+					return "false";
+				}
 			case CONTEXT_FIELD_IDENTIFIER:
 				return ctx.queryStringField(u.contextFieldIdentifier);
 			default:
@@ -856,6 +920,8 @@ private:
 				return atoi(storedString());
 			case INTEGER_LITERAL:
 				return u.intValue;
+			case BOOLEAN_LITERAL:
+				return (int) u.boolValue;
 			case CONTEXT_FIELD_IDENTIFIER:
 				return ctx.queryIntField(u.contextFieldIdentifier);
 			default:
@@ -863,6 +929,23 @@ private:
 			}
 		}
+		bool getBooleanValue(const Context &ctx) const {
+			switch (source) {
+			case REGEXP_LITERAL:
+				return true;
+			case STRING_LITERAL:
+				return !storedString().empty();
+			case INTEGER_LITERAL:
+				return (bool) u.intValue;
+			case BOOLEAN_LITERAL:
+				return u.boolValue;
+			case CONTEXT_FIELD_IDENTIFIER:
+				return ctx.queryBoolField(u.contextFieldIdentifier);
+			default:
+				return 0;
+			}
+		}
 		ValueType getType() const {
 			switch (source) {
 			case REGEXP_LITERAL:
@@ -871,6 +954,8 @@ private:
 				return STRING_TYPE;
 			case INTEGER_LITERAL:
 				return INTEGER_TYPE;
+			case BOOLEAN_LITERAL:
+				return BOOLEAN_TYPE;
 			case CONTEXT_FIELD_IDENTIFIER:
 				return Context::getFieldType(u.contextFieldIdentifier);
 			default:
@@ -917,6 +1002,9 @@ private:
 			case INTEGER_LITERAL:
 				u.intValue = other.u.intValue;
 				break;
+			case BOOLEAN_LITERAL:
+				u.boolValue = other.u.boolValue;
+				break;
 			case CONTEXT_FIELD_IDENTIFIER:
 				u.contextFieldIdentifier = other.u.contextFieldIdentifier;
 				break;
@@ -924,6 +1012,18 @@ private:
 		}
 	};
+	struct SingleValueComponent: public BooleanComponent {
+		Value val;
+		SingleValueComponent(const Value &v)
+			: val(v)
+			{ }
+		virtual bool evaluate(const Context &ctx) {
+			return val.getBooleanValue(ctx);
+		}
+	};
 	struct Comparison: public BooleanComponent {
 		Value subject;
 		Comparator comparator;
@@ -935,6 +1035,8 @@ private:
 				return compareStringOrRegexp(subject.getStringValue(ctx), ctx);
 			case INTEGER_TYPE:
 				return compareInteger(subject.getIntegerValue(ctx), ctx);
+			case BOOLEAN_TYPE:
+				return compareBoolean(subject.getBooleanValue(ctx), ctx);
 			default:
 				// error
 				return false;
@@ -978,6 +1080,19 @@ private:
 				return false;
 			}
 		}
+		bool compareBoolean(bool value, const Context &ctx) {
+			bool value2 = object.getBooleanValue(ctx);
+			switch (comparator) {
+			case EQUALS:
+				return value == value2;
+			case NOT_EQUALS:
+				return value != value2;
+			default:
+				// error
+				return false;
+			}
+		}
 	};
 	struct FunctionCall: public BooleanComponent {
@@ -1016,11 +1131,14 @@ private:
 	Tokenizer tokenizer;
 	BooleanComponentPtr root;
 	Token lookahead;
+	bool debug;
 	static bool isLiteralToken(const Token &token) {
 		return token.type == Tokenizer::REGEXP
 			|| token.type == Tokenizer::STRING
-			|| token.type == Tokenizer::INTEGER;
+			|| token.type == Tokenizer::INTEGER
+			|| token.type == Tokenizer::TRUE_LIT
+			|| token.type == Tokenizer::FALSE_LIT;
 	}
 	static bool isValueToken(const Token &token) {
@@ -1032,6 +1150,29 @@ private:
 			|| token.type == Tokenizer::OR;
 	}
+	static Comparator determineComparator(Tokenizer::TokenType type) {
+		switch (type) {
+		case Tokenizer::MATCHES:
+			return MATCHES;
+		case Tokenizer::NOT_MATCHES:
+			return NOT_MATCHES;
+		case Tokenizer::EQUALS:
+			return EQUALS;
+		case Tokenizer::NOT_EQUALS:
+			return NOT_EQUALS;
+		case Tokenizer::GREATER_THAN:
+			return GREATER_THAN;
+		case Tokenizer::GREATER_THAN_OR_EQUALS:
+			return GREATER_THAN_OR_EQUALS;
+		case Tokenizer::LESS_THAN:
+			return LESS_THAN;
+		case Tokenizer::LESS_THAN_OR_EQUALS:
+			return LESS_THAN_OR_EQUALS;
+		default:
+			return UNKNOWN_COMPARATOR;
+		}
+	}
 	static bool comparatorAcceptsValueTypes(Comparator cmp, ValueType subjectType, ValueType objectType) {
 		switch (cmp) {
 		case MATCHES:
@@ -1039,7 +1180,7 @@ private:
 			return subjectType == STRING_TYPE && objectType == REGEXP_TYPE;
 		case EQUALS:
 		case NOT_EQUALS:
-			return (subjectType == STRING_TYPE || subjectType == INTEGER_TYPE)
+			return (subjectType == STRING_TYPE || subjectType == INTEGER_TYPE || subjectType == BOOLEAN_TYPE)
 				&& subjectType == objectType;
 		case GREATER_THAN:
 		case GREATER_THAN_OR_EQUALS:
@@ -1089,6 +1230,19 @@ private:
 		return result;
 	}
+	void logMatch(int level, const char *name) const {
+		if (level > 100) {
+			// If level is too deep then it's probably a bug.
+			abort();
+		}
+		if (debug) {
+			for (int i = 0; i < level; i++) {
+				printf("   ");
+			}
+			printf("Matching: %s\n", name);
+		}
+	}
 	Token peek() const {
 		return lookahead;
 	}
@@ -1127,21 +1281,23 @@ private:
 		}
 	}
-	BooleanComponentPtr matchMultiExpression() {
+	BooleanComponentPtr matchMultiExpression(int level) {
+		logMatch(level, "matchMultiExpression()");
 		MultiExpressionPtr result = make_shared<MultiExpression>();
-		result->firstExpression = matchExpression();
+		result->firstExpression = matchExpression(level + 1);
 		while (isLogicalOperatorToken(peek())) {
 			MultiExpression::Part part;
-			part.theOperator = matchOperator();
-			part.expression  = matchExpression();
+			part.theOperator = matchOperator(level + 1);
+			part.expression  = matchExpression(level + 1);
 			result->rest.push_back(part);
 		}
 		return result;
 	}
-	BooleanComponentPtr matchExpression() {
+	BooleanComponentPtr matchExpression(int level) {
+		logMatch(level, "matchExpression()");
 		bool negate = false;
 		if (peek(Tokenizer::NOT)) {
@@ -1151,7 +1307,8 @@ private:
 		Token next = peek();
 		if (next.type == Tokenizer::LPARENTHESIS) {
-			BooleanComponentPtr expression = matchMultiExpression();
+			match();
+			BooleanComponentPtr expression = matchMultiExpression(level + 1);
 			match(Tokenizer::RPARENTHESIS);
 			if (negate) {
 				return make_shared<Negation>(expression);
@@ -1160,12 +1317,17 @@ private:
 			}
 		} else if (isValueToken(next)) {
 			BooleanComponentPtr component;
-			next = match();
+			Token &current = next;
+			match();
 			if (peek(Tokenizer::LPARENTHESIS)) {
-				component = matchFunctionCall(next);
+				component = matchFunctionCall(level + 1, current);
+			} else if (determineComparator(peek().type) != UNKNOWN_COMPARATOR) {
+				component = matchComparison(level + 1, current);
+			} else if (current.type == Tokenizer::TRUE_LIT || current.type == Tokenizer::FALSE_LIT) {
+				component = matchSingleValueComponent(level + 1, current);
 			} else {
-				component = matchComparison(next);
+				raiseSyntaxError("expected a function call, comparison or boolean literal", current);
 			}
 			if (negate) {
@@ -1179,18 +1341,25 @@ private:
 		}
 	}
-	ComparisonPtr matchComparison(const Token &subjectToken) {
+	BooleanComponentPtr matchSingleValueComponent(int level, const Token &token) {
+		logMatch(level, "matchSingleValueComponent()");
+		return make_shared<SingleValueComponent>(matchLiteral(level + 1, token));
+	}
+	ComparisonPtr matchComparison(int level, const Token &subjectToken) {
+		logMatch(level, "matchComparison()");
 		ComparisonPtr comparison = make_shared<Comparison>();
-		comparison->subject    = matchValue(subjectToken);
-		comparison->comparator = matchComparator();
-		comparison->object     = matchValue(match());
+		comparison->subject    = matchValue(level + 1, subjectToken);
+		comparison->comparator = matchComparator(level + 1);
+		comparison->object     = matchValue(level + 1, match());
 		if (!comparatorAcceptsValueTypes(comparison->comparator, comparison->subject.getType(), comparison->object.getType())) {
 			raiseSyntaxError("the comparator cannot operate on the given combination of types", subjectToken);
 		}
 		return comparison;
 	}
-	FunctionCallPtr matchFunctionCall(const Token &id) {
+	FunctionCallPtr matchFunctionCall(int level, const Token &id) {
+		logMatch(level, "matchFunctionCall()");
 		FunctionCallPtr function;
 		if (id.rawValue == "starts_with") {
@@ -1203,10 +1372,10 @@ private:
 		match(Tokenizer::LPARENTHESIS);
 		if (isValueToken(peek())) {
-			function->arguments.push_back(matchValue(match()));
+			function->arguments.push_back(matchValue(level + 1, match()));
 			while (peek(Tokenizer::COMMA)) {
 				match();
-				function->arguments.push_back(matchValue(match()));
+				function->arguments.push_back(matchValue(level + 1, match()));
 			}
 		}
 		match(Tokenizer::RPARENTHESIS);
@@ -1214,22 +1383,27 @@ private:
 		return function;
 	}
-	Value matchValue(const Token &token) {
+	Value matchValue(int level, const Token &token) {
+		logMatch(level, "matchValue()");
 		if (isLiteralToken(token)) {
-			return matchLiteral(token);
+			return matchLiteral(level + 1, token);
 		} else if (token.type == Tokenizer::IDENTIFIER) {
-			return matchContextFieldIdentifier(token);
+			return matchContextFieldIdentifier(level + 1, token);
 		} else {
-			raiseSyntaxError("", token);
+			raiseSyntaxError("Unrecognized value token " +
+				Tokenizer::typeToString(token.type), token);
 			return Value(); // Shut up compiler warning.
 		}
 	}
-	LogicalOperator matchOperator() {
+	LogicalOperator matchOperator(int level) {
+		logMatch(level, "matchOperator()");
 		if (peek(Tokenizer::AND)) {
+			logMatch(level + 1, "AND");
 			match();
 			return AND;
 		} else if (peek(Tokenizer::OR)) {
+			logMatch(level + 1, "OR");
 			match();
 			return OR;
 		} else {
@@ -1238,52 +1412,45 @@ private:
 		}
 	}
-	Comparator matchComparator() {
-		if (peek(Tokenizer::MATCHES)) {
-			match();
-			return MATCHES;
-		} else if (peek(Tokenizer::NOT_MATCHES)) {
-			match();
-			return NOT_MATCHES;
-		} else if (peek(Tokenizer::EQUALS)) {
-			match();
-			return EQUALS;
-		} else if (peek(Tokenizer::NOT_EQUALS)) {
-			match();
-			return NOT_EQUALS;
-		} else if (peek(Tokenizer::GREATER_THAN)) {
-			match();
-			return GREATER_THAN;
-		} else if (peek(Tokenizer::GREATER_THAN_OR_EQUALS)) {
-			match();
-			return GREATER_THAN_OR_EQUALS;
-		} else if (peek(Tokenizer::LESS_THAN)) {
-			match();
-			return LESS_THAN;
-		} else if (peek(Tokenizer::LESS_THAN_OR_EQUALS)) {
-			match();
-			return LESS_THAN_OR_EQUALS;
-		} else {
+	Comparator matchComparator(int level) {
+		logMatch(level, "matchComparator()");
+		Comparator comparator = determineComparator(peek().type);
+		if (comparator == UNKNOWN_COMPARATOR) {
 			raiseSyntaxError("", peek());
 			return MATCHES; // Shut up compiler warning.
+		} else {
+			logMatch(level + 1, Tokenizer::typeToString(peek().type).c_str());
+			match();
+			return comparator;
 		}
 	}
-	Value matchLiteral(const Token &token) {
+	Value matchLiteral(int level, const Token &token) {
+		logMatch(level, "matchLiteral()");
 		if (token.type == Tokenizer::REGEXP) {
+			logMatch(level + 1, "regexp");
 			return Value(true, unescapeCString(token.rawValue.substr(1, token.rawValue.size() - 2)),
 				token.options & Tokenizer::REGEXP_OPTION_CASE_INSENSITIVE);
 		} else if (token.type == Tokenizer::STRING) {
+			logMatch(level + 1, "string");
 			return Value(false, unescapeCString(token.rawValue.substr(1, token.rawValue.size() - 2)));
 		} else if (token.type == Tokenizer::INTEGER) {
+			logMatch(level + 1, "integer");
 			return Value(atoi(token.rawValue.toString()));
+		} else if (token.type == Tokenizer::TRUE_LIT) {
+			logMatch(level + 1, "true");
+			return Value(true);
+		} else if (token.type == Tokenizer::FALSE_LIT) {
+			logMatch(level + 1, "false");
+			return Value(false);
 		} else {
-			raiseSyntaxError("regular expression, string or integer expected", token);
+			raiseSyntaxError("regular expression, string, integer or boolean expected", token);
 			return Value(); // Shut up compiler warning.
 		}
 	}
-	Value matchContextFieldIdentifier(const Token &token) {
+	Value matchContextFieldIdentifier(int level, const Token &token) {
+		logMatch(level, "matchContextFieldIdentifier()");
 		if (token.rawValue == "uri") {
 			return Value(Context::URI);
 		} else if (token.rawValue == "controller") {
@@ -1295,13 +1462,15 @@ private:
 			return Value(); // Shut up compiler warning.
 		}
 	}
 public:
 	Filter(const StaticString &source, bool debug = false)
 		: tokenizer(source, debug)
 	{
+		this->debug = debug;
 		lookahead = tokenizer.getNext();
-		root = matchMultiExpression();
+		root = matchMultiExpression(0);
+		logMatch(0, "end of data");
 		match(Tokenizer::END_OF_DATA);
 	}
@@ -1314,4 +1483,24 @@ public:
 } // namespace FilterSupport
 } // namespace Passenger
+#endif /* __cplusplus */
+/********* C bindings *********/
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef void *PassengerFilter;
+PassengerFilter *passenger_filter_create(const char *source, int size, char **error);
+void passenger_filter_free(PassengerFilter *filter);
+char *passenger_filter_validate(const char *source, int size);
+#ifdef __cplusplus
+}
+#endif
 #endif /* _PASSENGER_FILTER_SUPPORT_H_ */