passenger 5.0.0.beta2 → 5.0.0.beta3

data/ext/common/agents/HelperAgent/RequestHandler/Hooks.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2011-2014 Phusion
+ *  Copyright (c) 2011-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -68,6 +68,7 @@ onRequestObjectCreated(Client *client, Request *req) {
 virtual void deinitializeClient(Client *client) {
 	ParentClass::deinitializeClient(client);
 	client->output.setBuffersFlushedCallback(NULL);
+	client->output.setDataFlushedCallback(getClientOutputDataFlushedCallback());
 }
 
 virtual void reinitializeRequest(Client *client, Request *req) {
@@ -90,6 +91,7 @@ virtual void reinitializeRequest(Client *client, Request *req) {
 	req->bodyBytesBuffered = 0;
 	req->cacheKey = HashedStaticString();
 	req->cacheControl = NULL;
+	req->varyCookie = NULL;
 
 	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
 		req->timedAppPoolGet = false;

data/ext/common/agents/HelperAgent/RequestHandler/InitRequest.cpp

@@ -137,25 +137,29 @@ initializeFlags(Client *client, Request *req, RequestAnalysis &analysis) {
 
 bool
 respondFromTurboCache(Client *client, Request *req) {
-	if (!turboCaching.isEnabled() || !turboCaching.responseCache.prepareRequest(req)) {
+	if (!turboCaching.isEnabled() || !turboCaching.responseCache.prepareRequest(this, req)) {
 		return false;
 	}
 
-	SKC_TRACE(client, 2, "Turbocaching: trying to reply from cache");
+	SKC_TRACE(client, 2, "Turbocaching: trying to reply from cache (key \"" <<
+		cEscapeString(req->cacheKey) << "\")");
 	SKC_TRACE(client, 2, "Turbocache entries:\n" << turboCaching.responseCache.inspect());
 
 	if (turboCaching.responseCache.requestAllowsFetching(req)) {
 		ResponseCache<Request>::Entry entry(turboCaching.responseCache.fetch(req,
 			ev_now(getLoop())));
 		if (entry.valid()) {
-			SKC_TRACE(client, 2, "Turbocaching: cache hit (key " << req->cacheKey << ")");
+			SKC_TRACE(client, 2, "Turbocaching: cache hit (key \"" <<
+				cEscapeString(req->cacheKey) << "\")");
 			turboCaching.writeResponse(this, client, req, entry);
 			if (!req->ended()) {
 				endRequest(&client, &req);
 			}
 			return true;
 		} else {
-			SKC_TRACE(client, 2, "Turbocaching: cache miss (key " << req->cacheKey << ")");
+			SKC_TRACE(client, 2, "Turbocaching: cache miss: " <<
+				entry.getCacheMissReasonString() <<
+				" (key \"" << cEscapeString(req->cacheKey) << "\")");
 			return false;
 		}
 	} else {
@@ -428,7 +432,7 @@ getStickySessionCookieName(Request *req) {
 	const LString *value = req->headers.lookup(PASSENGER_STICKY_SESSIONS_COOKIE_NAME);
 	if (value == NULL || value->size == 0) {
 		return psg_lstr_create(req->pool,
-			P_STATIC_STRING(DEFAULT_STICKY_SESSIONS_COOKIE_NAME));
+			defaultStickySessionsCookieName);
 	} else {
 		return value;
 	}

data/ext/common/agents/HelperAgent/RequestHandler/Request.h

@@ -90,6 +90,7 @@ public:
 
 	HashedStaticString cacheKey;
 	LString *cacheControl;
+	LString *varyCookie;
 
 	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
 		bool timedAppPoolGet;

data/ext/common/agents/HelperAgent/RequestHandler/SendRequest.cpp

@@ -87,8 +87,8 @@ struct SessionProtocolWorkingState {
 	const LString *remoteAddr;
 	const LString *remotePort;
 	const LString *remoteUser;
-	const LString *contentLength;
 	const LString *contentType;
+	const LString *contentLength;
 	bool hasBaseURI;
 };
 
@@ -177,8 +177,12 @@ determineHeaderSizeForSessionProtocol(Request *req,
 	state.remoteAddr  = req->secureHeaders.lookup(REMOTE_ADDR);
 	state.remotePort  = req->secureHeaders.lookup(REMOTE_PORT);
 	state.remoteUser  = req->secureHeaders.lookup(REMOTE_USER);
-	state.contentLength = req->headers.lookup(HTTP_CONTENT_LENGTH);
 	state.contentType   = req->headers.lookup(HTTP_CONTENT_TYPE);
+	if (req->hasBody()) {
+		state.contentLength = req->headers.lookup(HTTP_CONTENT_LENGTH);
+	} else {
+		state.contentLength = NULL;
+	}
 
 	dataSize += sizeof("REQUEST_URI");
 	dataSize += req->path.size + 1;
@@ -246,16 +250,16 @@ determineHeaderSizeForSessionProtocol(Request *req,
 		dataSize += state.remoteUser->size + 1;
 	}
 
-	if (state.contentLength != NULL) {
-		dataSize += sizeof("CONTENT_LENGTH");
-		dataSize += state.contentLength->size + 1;
-	}
-
 	if (state.contentType != NULL) {
 		dataSize += sizeof("CONTENT_TYPE");
 		dataSize += state.contentType->size + 1;
 	}
 
+	if (state.contentLength != NULL) {
+		dataSize += sizeof("CONTENT_LENGTH");
+		dataSize += state.contentLength->size + 1;
+	}
+
 	dataSize += sizeof("PASSENGER_CONNECT_PASSWORD");
 	dataSize += req->session->getGroupSecret().size() + 1;
 
@@ -269,6 +273,11 @@ determineHeaderSizeForSessionProtocol(Request *req,
 		dataSize += req->options.transaction->getTxnId().size() + 1;
 	}
 
+	if (req->upgraded()) {
+		dataSize += sizeof("HTTP_CONNECTION");
+		dataSize += sizeof("upgrade");
+	}
+
 	ServerKit::HeaderTable::Iterator it(req->headers);
 	while (*it != NULL) {
 		dataSize += sizeof("HTTP_") - 1 + it->header->key.size + 1;
@@ -349,18 +358,18 @@ constructHeaderForSessionProtocol(Request *req, char * restrict buffer, unsigned
 		pos = appendData(pos, end, "", 1);
 	}
 
-	if (state.contentLength != NULL) {
-		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("CONTENT_LENGTH"));
-		pos = appendData(pos, end, state.contentLength);
-		pos = appendData(pos, end, "", 1);
-	}
-
 	if (state.contentType != NULL) {
 		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("CONTENT_TYPE"));
 		pos = appendData(pos, end, state.contentType);
 		pos = appendData(pos, end, "", 1);
 	}
 
+	if (state.contentLength != NULL) {
+		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("CONTENT_LENGTH"));
+		pos = appendData(pos, end, state.contentLength);
+		pos = appendData(pos, end, "", 1);
+	}
+
 	pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("PASSENGER_CONNECT_PASSWORD"));
 	pos = appendData(pos, end, req->session->getGroupSecret());
 	pos = appendData(pos, end, "", 1);
@@ -376,6 +385,11 @@ constructHeaderForSessionProtocol(Request *req, char * restrict buffer, unsigned
 		pos = appendData(pos, end, "", 1);
 	}
 
+	if (req->upgraded()) {
+		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("HTTP_CONNECTION"));
+		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("upgrade"));
+	}
+
 	ServerKit::HeaderTable::Iterator it(req->headers);
 	while (*it != NULL) {
 		if ((it->header->hash == HTTP_CONTENT_LENGTH.hash()

data/ext/common/agents/HelperAgent/ResponseCache.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2014 Phusion
+ *  Copyright (c) 2014-2015 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -31,13 +31,18 @@
 #include <cstring>
 #include <DataStructures/HashedStaticString.h>
 #include <ServerKit/http_parser.h>
+#include <ServerKit/CookieUtils.h>
 #include <StaticString.h>
 #include <Utils/DateParsing.h>
 #include <Utils/StrIntUtils.h>
 
 namespace Passenger {
 
-
+/**
+ * Relevant RFCs:
+ * https://tools.ietf.org/html/rfc7234    HTTP 1.1 Caching
+ * https://tools.ietf.org/html/rfc2109    HTTP State Management Mechanism
+ */
 template<typename Request>
 class ResponseCache {
 public:
@@ -73,6 +78,10 @@ public:
 		unsigned int index;
 		Header *header;
 		Body *body;
+		enum {
+			NOT_FOUND,
+			NOT_FRESH
+		} cacheMissReason;
 
 		Entry()
 			: index(0),
@@ -90,29 +99,48 @@ public:
 		bool valid() const {
 			return header != NULL;
 		}
+
+		const char *getCacheMissReasonString() const {
+			switch (cacheMissReason) {
+			case NOT_FOUND:
+				return "NOT_FOUND";
+			case NOT_FRESH:
+				return "NOT_FRESH";
+			default:
+				return "UNKNOWN";
+			}
+		}
 	};
 
 private:
 	HashedStaticString HOST;
 	HashedStaticString CACHE_CONTROL;
 	HashedStaticString PRAGMA_CONST;
+	HashedStaticString AUTHORIZATION;
 	HashedStaticString VARY;
+	HashedStaticString WWW_AUTHENTICATE;
 	HashedStaticString EXPIRES;
 	HashedStaticString LAST_MODIFIED;
 	HashedStaticString LOCATION;
 	HashedStaticString CONTENT_LOCATION;
+	HashedStaticString COOKIE;
+	HashedStaticString PASSENGER_VARY_TURBOCACHE_BY_COOKIE;
 
 	unsigned int fetches, hits, stores, storeSuccesses;
 
 	Header headers[MAX_ENTRIES];
 	Body bodies[MAX_ENTRIES];
 
-	unsigned int calculateKeyLength(const LString * restrict host, const StaticString &path) {
+	unsigned int calculateKeyLength(const LString * restrict host,
+		const LString * restrict varyCookie,
+		const StaticString &path)
+	{
 		unsigned int size =
 			1  // protocol flag
 			+ ((host != NULL) ? host->size : 0)
-			+ 1  // ':'
-			+ path.size();
+			+ 1  // '\n'
+			+ path.size()
+			+ ((varyCookie != NULL) ? (varyCookie->size + 1) : 0);
 		if (size > MAX_KEY_LENGTH) {
 			return 0;
 		} else {
@@ -121,7 +149,9 @@ private:
 	}
 
 	void generateKey(bool https, const StaticString &path,
-		const LString * restrict host, char * restrict output,
+		const LString * restrict host,
+		const LString * restrict varyCookie,
+		char * restrict output,
 		unsigned int size)
 	{
 		char *pos = output;
@@ -142,8 +172,17 @@ private:
 			}
 		}
 
-		pos = appendData(pos, end, ":", 1);
+		pos = appendData(pos, end, "\n", 1);
 		pos = appendData(pos, end, path);
+
+		if (varyCookie != NULL) {
+			pos = appendData(pos, end, "\n", 1);
+			part = varyCookie->start;
+			while (part != NULL) {
+				pos = appendData(pos, end, part->data, part->size);
+				part = part->next;
+			}
+		}
 	}
 
 	bool statusCodeIsCacheableByDefault(unsigned int code) const {
@@ -194,10 +233,6 @@ private:
 		headers[index].valid = false;
 	}
 
-	time_t parsedDateToTimestamp(struct tm &tm, int zone) const {
-		return mktime(&tm) - zone / 100 * 60 * 60 - zone % 100 * 60;
-	}
-
 	time_t parseDate(psg_pool_t *pool, const LString *date, ev_tstamp now) const {
 		if (date == NULL) {
 			return (time_t) now;
@@ -345,13 +380,13 @@ private:
 			https = req->https;
 		}
 
-		unsigned int keySize = calculateKeyLength(req->host, path);
+		unsigned int keySize = calculateKeyLength(req->host, req->varyCookie, path);
 		if (keySize == 0) {
 			return;
 		}
 
 		char *key = (char *) psg_pnalloc(req->pool, keySize);
-		generateKey(https, path, req->host, key, keySize);
+		generateKey(https, path, req->host, req->varyCookie, key, keySize);
 
 		Entry entry(lookup(StaticString(key, keySize)));
 		if (entry.valid()) {
@@ -363,11 +398,15 @@ public:
 	ResponseCache()
 		: CACHE_CONTROL("cache-control"),
 		  PRAGMA_CONST("pragma"),
+		  AUTHORIZATION("authorization"),
 		  VARY("vary"),
+		  WWW_AUTHENTICATE("www-authenticate"),
 		  EXPIRES("expires"),
 		  LAST_MODIFIED("last-modified"),
 		  LOCATION("location"),
 		  CONTENT_LOCATION("content-location"),
+		  COOKIE("cookie"),
+		  PASSENGER_VARY_TURBOCACHE_BY_COOKIE("!~PASSENGER_VARY_TURBOCACHE_COOKIE"),
 		  fetches(0),
 		  hits(0),
 		  stores(0),
@@ -430,12 +469,29 @@ public:
 	 *
 	 * @post result == !req->cacheKey.empty()
 	 */
-	bool prepareRequest(Request *req) {
+	template<typename RequestHandler>
+	bool prepareRequest(RequestHandler *requestHandler, Request *req) {
 		if (req->upgraded() || req->host == NULL) {
 			return false;
 		}
 
+		LString *varyCookieName = req->secureHeaders.lookup(PASSENGER_VARY_TURBOCACHE_BY_COOKIE);
+		if (varyCookieName == NULL && !requestHandler->defaultVaryTurbocacheByCookie.empty()) {
+			varyCookieName = (LString *) psg_palloc(req->pool, sizeof(LString));
+			psg_lstr_init(varyCookieName);
+			psg_lstr_append(varyCookieName, req->pool,
+				requestHandler->defaultVaryTurbocacheByCookie.data(),
+				requestHandler->defaultVaryTurbocacheByCookie.size());
+		}
+		if (varyCookieName != NULL) {
+			LString *cookieHeader = req->headers.lookup(COOKIE);
+			if (cookieHeader != NULL) {
+				req->varyCookie = ServerKit::findCookie(req->pool, cookieHeader, varyCookieName);
+			}
+		}
+
 		unsigned int size = calculateKeyLength(req->host,
+			req->varyCookie,
 			StaticString(req->path.start->data, req->path.size));
 		if (size == 0) {
 			req->cacheKey = HashedStaticString();
@@ -443,7 +499,7 @@ public:
 		}
 
 		req->cacheControl = req->headers.lookup(CACHE_CONTROL);
-		if (req->cacheControl != NULL) {
+		if (req->cacheControl == NULL) {
 			// hasPragmaHeader is only used by requestAllowsFetching(),
 			// so if there is no Cache-Control header then it's not
 			// necessary to check for the Pragma header.
@@ -452,7 +508,7 @@ public:
 
 		char *key = (char *) psg_pnalloc(req->pool, size);
 		generateKey(req->https, StaticString(req->path.start->data, req->path.size),
-			req->host, key, size);
+			req->host, req->varyCookie, key, size);
 		req->cacheKey = HashedStaticString(key, size);
 		return true;
 	}
@@ -481,9 +537,12 @@ public:
 				return entry;
 			} else {
 				erase(entry.index);
-				return Entry();
+				Entry result;
+				result.cacheMissReason = Entry::NOT_FRESH;
+				return result;
 			}
 		} else {
+			entry.cacheMissReason = Entry::NOT_FOUND;
 			return entry;
 		}
 	}
@@ -492,7 +551,7 @@ public:
 	// @pre prepareRequest() returned true
 	OXT_FORCE_INLINE
 	bool requestAllowsStoring(Request *req) const {
-		return requestAllowsFetching(req);
+		return req->method != HTTP_HEAD && requestAllowsFetching(req);
 	}
 
 	// @pre prepareRequest() returned true
@@ -503,16 +562,6 @@ public:
 
 		ServerKit::HeaderTable &respHeaders = req->appResponse.headers;
 
-		if (req->cacheControl != NULL) {
-			req->cacheControl = psg_lstr_make_contiguous(req->cacheControl,
-				req->pool);
-			StaticString cacheControl = StaticString(req->cacheControl->start->data,
-				req->cacheControl->size);
-			if (cacheControl.find(P_STATIC_STRING("no-store")) != string::npos) {
-				return false;
-			}
-		}
-
 		req->appResponse.cacheControl = respHeaders.lookup(CACHE_CONTROL);
 		if (req->appResponse.cacheControl != NULL) {
 			req->appResponse.cacheControl = psg_lstr_make_contiguous(
@@ -521,12 +570,17 @@ public:
 			StaticString cacheControl = StaticString(
 				req->appResponse.cacheControl->start->data,
 				req->appResponse.cacheControl->size);
-			if (cacheControl.find(P_STATIC_STRING("no-store")) != string::npos) {
+			if (cacheControl.find(P_STATIC_STRING("no-store")) != string::npos
+			 || cacheControl.find(P_STATIC_STRING("private")) != string::npos)
+			{
 				return false;
 			}
 		}
 
-		if (respHeaders.lookup(VARY) != NULL) {
+		if (req->headers.lookup(AUTHORIZATION) != NULL
+		 || respHeaders.lookup(VARY) != NULL
+		 || respHeaders.lookup(WWW_AUTHENTICATE) != NULL)
+		{
 			return false;
 		}
 
@@ -548,7 +602,8 @@ public:
 					req->pool);
 		}
 
-		return true;
+		return req->appResponse.cacheControl != NULL
+			|| req->appResponse.expiresHeader != NULL;
 	}
 
 	// @pre requestAllowsStoring()
@@ -609,10 +664,12 @@ public:
 	string inspect() const {
 		stringstream stream;
 		for (unsigned int i = 0; i < MAX_ENTRIES; i++) {
+			time_t expiryDate = bodies[i].expiryDate;
 			stream << " #" << i << ": valid=" << headers[i].valid
-				<< ", hash=" << headers[i].hash << ", keySize="
-				<< headers[i].keySize << ", key="
-				<< StaticString(bodies[i].key, headers[i].keySize) << "\n";
+				<< ", hash=" << headers[i].hash
+				<< ", expiryDate=" << expiryDate
+				<< ", keySize=" << headers[i].keySize << ", key=\""
+				<< cEscapeString(StaticString(bodies[i].key, headers[i].keySize)) << "\"\n";
 		}
 		return stream.str();
 	}