passenger 5.0.21 → 5.0.22

data/src/agent/Core/{RequestHandler → Controller}/Request.h

@@ -35,12 +35,13 @@
 #include <ServerKit/FdSourceChannel.h>
 #include <Logging.h>
 #include <Core/ApplicationPool/Pool.h>
-#include <Core/UnionStation/Core.h>
+#include <Core/UnionStation/Context.h>
 #include <Core/UnionStation/Transaction.h>
 #include <Core/UnionStation/StopwatchLog.h>
-#include <Core/RequestHandler/AppResponse.h>
+#include <Core/Controller/AppResponse.h>
 
 namespace Passenger {
+namespace Core {
 
 using namespace std;
 using namespace boost;
@@ -102,7 +103,7 @@ public:
 	// This value is guaranteed to be contiguous.
 	LString *envvars;
 
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 		bool timedAppPoolGet;
 		ev_tstamp timeBeforeAccessingApplicationPool;
 		ev_tstamp timeOnRequestHeaderSent;
@@ -157,10 +158,11 @@ public:
 		options.transaction->message(message);
 	}
 
-	DEFINE_SERVER_KIT_BASE_HTTP_REQUEST_FOOTER(Passenger::Request);
+	DEFINE_SERVER_KIT_BASE_HTTP_REQUEST_FOOTER(Passenger::Core::Request);
 };
 
 
+} // namespace Core
 } // namespace Passenger
 
 #endif /* _PASSENGER_REQUEST_HANDLER_REQUEST_H_ */

data/src/agent/Core/{RequestHandler → Controller}/SendRequest.cpp

@@ -23,13 +23,68 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
+#include <Core/Controller.h>
 
-// This file is included inside the RequestHandler class.
+// For calculating delta_monotonic (Ruby < 2.1 workaround, otherwise unused)
+#include <uv.h>
+
+/*************************************************************************
+ *
+ * Implements Core::Controller methods pertaining sending request data
+ * to a selected application process. This happens in parallel to forwarding
+ * application response data to the client.
+ *
+ *************************************************************************/
+
+
+namespace Passenger {
+namespace Core {
+
+using namespace std;
+using namespace boost;
+
+
+/****************************
+ *
+ * Private methods
+ *
+ ****************************/
+
+
+struct Controller::SessionProtocolWorkingState {
+	StaticString path;
+	StaticString queryString;
+	StaticString methodStr;
+	StaticString serverName;
+	StaticString serverPort;
+	const LString *remoteAddr;
+	const LString *remotePort;
+	const LString *remoteUser;
+	const LString *contentType;
+	const LString *contentLength;
+	char *environmentVariablesData;
+	size_t environmentVariablesSize;
+	bool hasBaseURI;
+
+	SessionProtocolWorkingState()
+		: environmentVariablesData(NULL)
+		{ }
+
+	~SessionProtocolWorkingState() {
+		free(environmentVariablesData);
+	}
+};
+
+struct Controller::HttpHeaderConstructionCache {
+	StaticString methodStr;
+	const LString *remoteAddr;
+	const LString *setCookie;
+	bool cached;
+};
 
-private:
 
 void
-sendHeaderToApp(Client *client, Request *req) {
+Controller::sendHeaderToApp(Client *client, Request *req) {
 	TRACE_POINT();
 	SKC_TRACE(client, 2, "Sending headers to application with " <<
 		req->session->getProtocol() << " protocol");
@@ -79,36 +134,16 @@ sendHeaderToApp(Client *client, Request *req) {
 	}
 }
 
-struct SessionProtocolWorkingState {
-	StaticString path;
-	StaticString queryString;
-	StaticString methodStr;
-	StaticString serverName;
-	StaticString serverPort;
-	const LString *remoteAddr;
-	const LString *remotePort;
-	const LString *remoteUser;
-	const LString *contentType;
-	const LString *contentLength;
-	char *environmentVariablesData;
-	size_t environmentVariablesSize;
-	bool hasBaseURI;
-
-	SessionProtocolWorkingState()
-		: environmentVariablesData(NULL)
-		{ }
-
-	~SessionProtocolWorkingState() {
-		free(environmentVariablesData);
-	}
-};
-
 void
-sendHeaderToAppWithSessionProtocol(Client *client, Request *req) {
+Controller::sendHeaderToAppWithSessionProtocol(Client *client, Request *req) {
 	TRACE_POINT();
 	SessionProtocolWorkingState state;
+
+	// Workaround for Ruby < 2.1 support.
+	std::string delta_monotonic = boost::to_string(SystemTime::getUsec() - (uv_hrtime() / 1000));
+
 	unsigned int bufferSize = determineHeaderSizeForSessionProtocol(req,
-		state);
+		state, delta_monotonic);
 	MemoryKit::mbuf_pool &mbuf_pool = getContext()->mbuf_pool;
 	const unsigned int MBUF_MAX_SIZE = mbuf_pool_data_size(&mbuf_pool);
 	bool ok;
@@ -118,7 +153,7 @@ sendHeaderToAppWithSessionProtocol(Client *client, Request *req) {
 		bufferSize = MBUF_MAX_SIZE;
 
 		ok = constructHeaderForSessionProtocol(req, buffer.start,
-			bufferSize, state);
+			bufferSize, state, delta_monotonic);
 		assert(ok);
 		buffer = MemoryKit::mbuf(buffer, 0, bufferSize);
 		SKC_TRACE(client, 3, "Header data: \"" << cEscapeString(
@@ -128,7 +163,7 @@ sendHeaderToAppWithSessionProtocol(Client *client, Request *req) {
 		char *buffer = (char *) psg_pnalloc(req->pool, bufferSize);
 
 		ok = constructHeaderForSessionProtocol(req, buffer,
-			bufferSize, state);
+			bufferSize, state, delta_monotonic);
 		assert(ok);
 		SKC_TRACE(client, 3, "Header data: \"" << cEscapeString(
 			StaticString(buffer, bufferSize)) << "\"");
@@ -139,15 +174,15 @@ sendHeaderToAppWithSessionProtocol(Client *client, Request *req) {
 	(void) ok; // Shut up compiler warning
 }
 
-static void
-sendBodyToAppWhenAppSinkIdle(Channel *_channel, unsigned int size) {
+void
+Controller::sendBodyToAppWhenAppSinkIdle(Channel *_channel, unsigned int size) {
 	FdSinkChannel *channel = reinterpret_cast<FdSinkChannel *>(_channel);
 	Request *req = static_cast<Request *>(static_cast<
 		ServerKit::BaseHttpRequest *>(channel->getHooks()->userData));
 	Client *client = static_cast<Client *>(req->client);
-	RequestHandler *self = static_cast<RequestHandler *>(
+	Controller *self = static_cast<Controller *>(
 		getServerFromClient(client));
-	SKC_LOG_EVENT_FROM_STATIC(self, RequestHandler, client, "sendBodyToAppWhenAppSinkIdle");
+	SKC_LOG_EVENT_FROM_STATIC(self, Controller, client, "sendBodyToAppWhenAppSinkIdle");
 
 	channel->setConsumedCallback(NULL);
 	if (channel->acceptingInput()) {
@@ -169,9 +204,96 @@ sendBodyToAppWhenAppSinkIdle(Channel *_channel, unsigned int size) {
 	}
 }
 
+static bool
+isAlphaNum(char ch) {
+	return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+}
+
+/**
+ * For CGI, alphanum headers with optional dashes are mapped to UPP3R_CAS3. This
+ * function can be used to reject non-alphanum/dash headers that would end up with
+ * the same mapping (e.g. upp3r_cas3 and upp3r-cas3 would end up the same, and
+ * potentially collide each other in the receiving application). This is
+ * used to fix CVE-2015-7519.
+ */
+static bool
+containsNonAlphaNumDash(const LString &s) {
+	const LString::Part *part = s.start;
+	while (part != NULL) {
+		for (unsigned int i = 0; i < part->size; i++) {
+			const char start = part->data[i];
+			if (start != '-' && !isAlphaNum(start)) {
+				return true;
+			}
+		}
+		part = part->next;
+	}
+	return false;
+}
+
+static void
+httpHeaderToScgiUpperCase(unsigned char *data, unsigned int size) {
+	static const boost::uint8_t toUpperMap[256] = {
+		'\0', 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, '\t',
+		'\n', 0x0b, 0x0c, '\r', 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
+		0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+		0x1e, 0x1f,  ' ',  '!',  '"',  '#',  '$',  '%',  '&', '\'',
+		 '(',  ')',  '*',  '+',  ',',  '_',  '.',  '/',  '0',  '1',
+		 '2',  '3',  '4',  '5',  '6',  '7',  '8',  '9',  ':',  ';',
+		 '<',  '=',  '>',  '?',  '@',  'A',  'B',  'C',  'D',  'E',
+		 'F',  'G',  'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
+		 'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',  'X',  'Y',
+		 'Z',  '[', '\\',  ']',  '^',  '_',  '`',  'A',  'B',  'C',
+		 'D',  'E',  'F',  'G',  'H',  'I',  'J',  'K',  'L',  'M',
+		 'N',  'O',  'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
+		 'X',  'Y',  'Z',  '{',  '|',  '}',  '~', 0x7f, 0x80, 0x81,
+		0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
+		0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
+		0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+		0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
+		0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
+		0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd,
+		0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+		0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
+		0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
+		0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5,
+		0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+		0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+		0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+	};
+
+	const unsigned char *buf = data;
+	const size_t imax = size / 8;
+	const size_t leftover = size % 8;
+	size_t i;
+
+	for (i = 0; i < imax; i++, data += 8) {
+		data[0] = (unsigned char) toUpperMap[data[0]];
+		data[1] = (unsigned char) toUpperMap[data[1]];
+		data[2] = (unsigned char) toUpperMap[data[2]];
+		data[3] = (unsigned char) toUpperMap[data[3]];
+		data[4] = (unsigned char) toUpperMap[data[4]];
+		data[5] = (unsigned char) toUpperMap[data[5]];
+		data[6] = (unsigned char) toUpperMap[data[6]];
+		data[7] = (unsigned char) toUpperMap[data[7]];
+	}
+
+	i = imax * 8;
+	switch (leftover) {
+	case 7: *data++ = (unsigned char) toUpperMap[buf[i++]];
+	case 6: *data++ = (unsigned char) toUpperMap[buf[i++]];
+	case 5: *data++ = (unsigned char) toUpperMap[buf[i++]];
+	case 4: *data++ = (unsigned char) toUpperMap[buf[i++]];
+	case 3: *data++ = (unsigned char) toUpperMap[buf[i++]];
+	case 2: *data++ = (unsigned char) toUpperMap[buf[i++]];
+	case 1: *data++ = (unsigned char) toUpperMap[buf[i]];
+	case 0: break;
+	}
+}
+
 unsigned int
-determineHeaderSizeForSessionProtocol(Request *req,
-	SessionProtocolWorkingState &state)
+Controller::determineHeaderSizeForSessionProtocol(Request *req,
+	SessionProtocolWorkingState &state, string delta_monotonic)
 {
 	unsigned int dataSize = sizeof(boost::uint32_t);
 
@@ -302,6 +424,9 @@ determineHeaderSizeForSessionProtocol(Request *req,
 	if (req->options.analytics) {
 		dataSize += sizeof("PASSENGER_TXN_ID");
 		dataSize += req->options.transaction->getTxnId().size() + 1;
+
+		dataSize += sizeof("PASSENGER_DELTA_MONOTONIC");
+		dataSize += delta_monotonic.size() + 1;
 	}
 
 	if (req->upgraded()) {
@@ -324,8 +449,8 @@ determineHeaderSizeForSessionProtocol(Request *req,
 }
 
 bool
-constructHeaderForSessionProtocol(Request *req, char * restrict buffer, unsigned int &size,
-	const SessionProtocolWorkingState &state)
+Controller::constructHeaderForSessionProtocol(Request *req, char * restrict buffer,
+	unsigned int &size, const SessionProtocolWorkingState &state, string delta_monotonic)
 {
 	char *pos = buffer;
 	const char *end = buffer + size;
@@ -418,6 +543,10 @@ constructHeaderForSessionProtocol(Request *req, char * restrict buffer, unsigned
 		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("PASSENGER_TXN_ID"));
 		pos = appendData(pos, end, req->options.transaction->getTxnId());
 		pos = appendData(pos, end, "", 1);
+
+		pos = appendData(pos, end, P_STATIC_STRING_WITH_NULL("PASSENGER_DELTA_MONOTONIC"));
+		pos = appendData(pos, end, delta_monotonic);
+		pos = appendData(pos, end, "", 1);
 	}
 
 	if (req->upgraded()) {
@@ -427,12 +556,18 @@ constructHeaderForSessionProtocol(Request *req, char * restrict buffer, unsigned
 
 	ServerKit::HeaderTable::Iterator it(req->headers);
 	while (*it != NULL) {
-		if ((it->header->hash == HTTP_CONTENT_LENGTH.hash()
-			|| it->header->hash == HTTP_CONTENT_TYPE.hash()
-			|| it->header->hash == HTTP_CONNECTION.hash())
-		 && (psg_lstr_cmp(&it->header->key, P_STATIC_STRING("content-type"))
-			|| psg_lstr_cmp(&it->header->key, P_STATIC_STRING("content-length"))
-			|| psg_lstr_cmp(&it->header->key, P_STATIC_STRING("connection"))))
+		// This header-skipping is not accounted for in determineHeaderSizeForSessionProtocol(), but
+		// since we are only reducing the size it just wastes some mem bytes.
+		if ((
+				(it->header->hash == HTTP_CONTENT_LENGTH.hash()
+						|| it->header->hash == HTTP_CONTENT_TYPE.hash()
+						|| it->header->hash == HTTP_CONNECTION.hash()
+				) && (psg_lstr_cmp(&it->header->key, P_STATIC_STRING("content-type"))
+						|| psg_lstr_cmp(&it->header->key, P_STATIC_STRING("content-length"))
+						|| psg_lstr_cmp(&it->header->key, P_STATIC_STRING("connection"))
+				)
+			) || containsNonAlphaNumDash(it->header->key)
+		   )
 		{
 			it.next();
 			continue;
@@ -469,74 +604,7 @@ constructHeaderForSessionProtocol(Request *req, char * restrict buffer, unsigned
 }
 
 void
-httpHeaderToScgiUpperCase(unsigned char *data, unsigned int size) {
-	static const boost::uint8_t toUpperMap[256] = {
-		'\0', 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, '\t',
-		'\n', 0x0b, 0x0c, '\r', 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
-		0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
-		0x1e, 0x1f,  ' ',  '!',  '"',  '#',  '$',  '%',  '&', '\'',
-		 '(',  ')',  '*',  '+',  ',',  '_',  '.',  '/',  '0',  '1',
-		 '2',  '3',  '4',  '5',  '6',  '7',  '8',  '9',  ':',  ';',
-		 '<',  '=',  '>',  '?',  '@',  'A',  'B',  'C',  'D',  'E',
-		 'F',  'G',  'H',  'I',  'J',  'K',  'L',  'M',  'N',  'O',
-		 'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',  'X',  'Y',
-		 'Z',  '[', '\\',  ']',  '^',  '_',  '`',  'A',  'B',  'C',
-		 'D',  'E',  'F',  'G',  'H',  'I',  'J',  'K',  'L',  'M',
-		 'N',  'O',  'P',  'Q',  'R',  'S',  'T',  'U',  'V',  'W',
-		 'X',  'Y',  'Z',  '{',  '|',  '}',  '~', 0x7f, 0x80, 0x81,
-		0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
-		0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
-		0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
-		0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
-		0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
-		0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd,
-		0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
-		0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
-		0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
-		0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5,
-		0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
-		0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
-		0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
-	};
-
-	const unsigned char *buf = data;
-	const size_t imax = size / 8;
-	const size_t leftover = size % 8;
-	size_t i;
-
-	for (i = 0; i < imax; i++, data += 8) {
-		data[0] = (unsigned char) toUpperMap[data[0]];
-		data[1] = (unsigned char) toUpperMap[data[1]];
-		data[2] = (unsigned char) toUpperMap[data[2]];
-		data[3] = (unsigned char) toUpperMap[data[3]];
-		data[4] = (unsigned char) toUpperMap[data[4]];
-		data[5] = (unsigned char) toUpperMap[data[5]];
-		data[6] = (unsigned char) toUpperMap[data[6]];
-		data[7] = (unsigned char) toUpperMap[data[7]];
-	}
-
-	i = imax * 8;
-	switch (leftover) {
-	case 7: *data++ = (unsigned char) toUpperMap[buf[i++]];
-	case 6: *data++ = (unsigned char) toUpperMap[buf[i++]];
-	case 5: *data++ = (unsigned char) toUpperMap[buf[i++]];
-	case 4: *data++ = (unsigned char) toUpperMap[buf[i++]];
-	case 3: *data++ = (unsigned char) toUpperMap[buf[i++]];
-	case 2: *data++ = (unsigned char) toUpperMap[buf[i++]];
-	case 1: *data++ = (unsigned char) toUpperMap[buf[i]];
-	case 0: break;
-	}
-}
-
-struct HttpHeaderConstructionCache {
-	StaticString methodStr;
-	const LString *remoteAddr;
-	const LString *setCookie;
-	bool cached;
-};
-
-void
-sendHeaderToAppWithHttpProtocol(Client *client, Request *req) {
+Controller::sendHeaderToAppWithHttpProtocol(Client *client, Request *req) {
 	ssize_t bytesWritten;
 	HttpHeaderConstructionCache cache;
 
@@ -592,7 +660,7 @@ sendHeaderToAppWithHttpProtocol(Client *client, Request *req) {
  * In this case, this method always returns true.
  */
 bool
-constructHeaderBuffersForHttpProtocol(Request *req, struct iovec *buffers,
+Controller::constructHeaderBuffersForHttpProtocol(Request *req, struct iovec *buffers,
 	unsigned int maxbuffers, unsigned int & restrict_ref nbuffers,
 	unsigned int & restrict_ref dataSize, HttpHeaderConstructionCache &cache)
 {
@@ -795,7 +863,7 @@ constructHeaderBuffersForHttpProtocol(Request *req, struct iovec *buffers,
 }
 
 bool
-sendHeaderToAppWithHttpProtocolAndWritev(Request *req, ssize_t &bytesWritten,
+Controller::sendHeaderToAppWithHttpProtocolAndWritev(Request *req, ssize_t &bytesWritten,
 	HttpHeaderConstructionCache &cache)
 {
 	unsigned int maxbuffers = std::min<unsigned int>(
@@ -820,8 +888,8 @@ sendHeaderToAppWithHttpProtocolAndWritev(Request *req, ssize_t &bytesWritten,
 }
 
 void
-sendHeaderToAppWithHttpProtocolWithBuffering(Request *req, unsigned int offset,
-	HttpHeaderConstructionCache &cache)
+Controller::sendHeaderToAppWithHttpProtocolWithBuffering(Request *req,
+	unsigned int offset, HttpHeaderConstructionCache &cache)
 {
 	struct iovec *buffers;
 	unsigned int nbuffers, dataSize;
@@ -854,10 +922,10 @@ sendHeaderToAppWithHttpProtocolWithBuffering(Request *req, unsigned int offset,
 }
 
 void
-sendBodyToApp(Client *client, Request *req) {
+Controller::sendBodyToApp(Client *client, Request *req) {
 	TRACE_POINT();
 	assert(req->appSink.acceptingInput());
-	#ifdef DEBUG_RH_EVENT_LOOP_BLOCKING
+	#ifdef DEBUG_CC_EVENT_LOOP_BLOCKING
 		req->timeOnRequestHeaderSent = ev_now(getLoop());
 		reportLargeTimeDiff(client,
 			"ApplicationPool get until headers sent",
@@ -881,7 +949,7 @@ sendBodyToApp(Client *client, Request *req) {
 }
 
 void
-halfCloseAppSink(Client *client, Request *req) {
+Controller::halfCloseAppSink(Client *client, Request *req) {
 	P_ASSERT_EQ(req->state, Request::WAITING_FOR_APP_OUTPUT);
 	if (req->halfCloseAppConnection) {
 		SKC_TRACE(client, 3, "Half-closing application socket with SHUT_WR");
@@ -889,8 +957,8 @@ halfCloseAppSink(Client *client, Request *req) {
 	}
 }
 
-Channel::Result
-whenSendingRequest_onRequestBody(Client *client, Request *req,
+ServerKit::Channel::Result
+Controller::whenSendingRequest_onRequestBody(Client *client, Request *req,
 	const MemoryKit::mbuf &buffer, int errcode)
 {
 	TRACE_POINT();
@@ -952,14 +1020,16 @@ whenSendingRequest_onRequestBody(Client *client, Request *req,
 	}
 }
 
-static void
-resumeRequestBodyChannelWhenAppSinkIdle(Channel *_channel, unsigned int size) {
+void
+Controller::resumeRequestBodyChannelWhenAppSinkIdle(Channel *_channel,
+	unsigned int size)
+{
 	FdSinkChannel *channel = reinterpret_cast<FdSinkChannel *>(_channel);
 	Request *req = static_cast<Request *>(static_cast<
 		ServerKit::BaseHttpRequest *>(channel->getHooks()->userData));
 	Client *client = static_cast<Client *>(req->client);
-	RequestHandler *self = static_cast<RequestHandler *>(getServerFromClient(client));
-	SKC_LOG_EVENT_FROM_STATIC(self, RequestHandler, client, "resumeRequestBodyChannelWhenAppSinkIdle");
+	Controller *self = static_cast<Controller *>(getServerFromClient(client));
+	SKC_LOG_EVENT_FROM_STATIC(self, Controller, client, "resumeRequestBodyChannelWhenAppSinkIdle");
 
 	P_ASSERT_EQ(req->state, Request::FORWARDING_BODY_TO_APP);
 	req->appSink.setConsumedCallback(NULL);
@@ -980,7 +1050,7 @@ resumeRequestBodyChannelWhenAppSinkIdle(Channel *_channel, unsigned int size) {
 }
 
 void
-startBodyChannel(Client *client, Request *req) {
+Controller::startBodyChannel(Client *client, Request *req) {
 	if (req->requestBodyBuffering) {
 		req->bodyBuffer.start();
 	} else {
@@ -989,7 +1059,7 @@ startBodyChannel(Client *client, Request *req) {
 }
 
 void
-stopBodyChannel(Client *client, Request *req) {
+Controller::stopBodyChannel(Client *client, Request *req) {
 	if (req->requestBodyBuffering) {
 		req->bodyBuffer.stop();
 	} else {
@@ -998,12 +1068,17 @@ stopBodyChannel(Client *client, Request *req) {
 }
 
 void
-logAppSocketWriteError(Client *client, int errcode) {
+Controller::logAppSocketWriteError(Client *client, int errcode) {
 	if (errcode == EPIPE) {
-		SKC_INFO(client, "App socket write error: the application closed the socket prematurely"
+		SKC_INFO(client,
+			"App socket write error: the application closed the socket prematurely"
 			" (Broken pipe; errno=" << errcode << ")");
 	} else {
 		SKC_INFO(client, "App socket write error: " << ServerKit::getErrorDesc(errcode) <<
 			" (errno=" << errcode << ")");
 	}
 }
+
+
+} // namespace Core
+} // namespace Passenger