passenger 2.1.3 → 2.2.0

data/ext/nginx/HttpStatusExtractor.h

@@ -0,0 +1,161 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2009 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 <string>
+
+namespace Passenger {
+
+using namespace std;
+
+/**
+ * Utility class for extracting the HTTP status value from an HTTP response.
+ *
+ * This class is used for generating a proper HTTP response. The response data
+ * that Passenger backend processes generate are like CGI responses, and do not
+ * include an initial "HTTP/1.1 [status here]" line, so this class used to
+ * extract the status from the response in order to generate a proper initial
+ * HTTP response line.
+ *
+ * This class is supposed to be used as follows:
+ * - Keep feeding HTTP response data until feed() returns true. feed()
+ *   buffers all fed data until it is able to extract the HTTP status.
+ * - Call getStatusLine() to retrieve the status line, and use this to generate
+ *   an HTTP response line.
+ * - Call getBuffer() to retrieve all fed data so far. This data can be sent to
+ *   the HTTP client.
+ *
+ * @note
+ * When the API documentation for this class refers to "\r\n", we actually
+ * mean "\x0D\x0A" (the HTTP line termination string). "\r\n" is only written
+ * out of convenience.
+ */
+class HttpStatusExtractor {
+private:
+	static const char CR = '\x0D';
+	static const char LF = '\x0A';
+
+	string buffer;
+	unsigned int searchStart;
+	bool fullHeaderReceived;
+	string statusLine;
+	
+	bool extractStatusLine() {
+		static const char statusHeaderName[] = "Status: ";
+		string::size_type start_pos, newline_pos;
+		
+		if (buffer.size() > sizeof(statusHeaderName) - 1
+		 && memcmp(buffer.c_str(), statusHeaderName, sizeof(statusHeaderName) - 1) == 0) {
+			// Status line starts at beginning of the header.
+			start_pos = sizeof(statusHeaderName) - 1;
+			newline_pos = buffer.find("\x0D\x0A", 0, 2) + 2;
+		} else {
+			// Status line is not at the beginning of the header.
+			// Look for it.
+			start_pos = buffer.find("\x0D\x0AStatus: ");
+			if (start_pos != string::npos) {
+				start_pos += 2 + sizeof(statusHeaderName) - 1;
+				newline_pos = buffer.find("\x0D\x0A", start_pos, 2) + 2;
+			}
+		}
+		if (start_pos != string::npos) {
+			// Status line has been found. Extract it.
+			statusLine = buffer.substr(start_pos, newline_pos - start_pos);
+			return true;
+		} else {
+			// Status line is not found. Do not change default
+			// status line value.
+			return false;
+		}
+	}
+	
+public:
+	HttpStatusExtractor() {
+		searchStart = 0;
+		fullHeaderReceived = false;
+		statusLine = "200 OK\r\n";
+	}
+	
+	/**
+	 * Feed HTTP response data to this HttpStatusExtractor.
+	 *
+	 * One is to keep feeding data until this method returns true.
+	 * When a sufficient amount of data has been fed, this method will
+	 * extract the status line from the data that has been fed so far,
+	 * and return true.
+	 *
+	 * Do not call this method again once it has returned true.
+	 *
+	 * It is safe to feed excess data. That is, it is safe if the 'data'
+	 * argument contains a part of the HTTP response body.
+	 * HttpStatusExtractor will only look for the status line in the HTTP
+	 * response header, not in the HTTP response body. All fed data is
+	 * buffered and will be available via getBuffer(), so no data will be
+	 * lost.
+	 *
+	 * @return Whether the HTTP status has been extracted yet.
+	 * @pre feed() did not previously return true.
+	 * @pre data != NULL
+	 * @pre size > 0
+	 */
+	bool feed(const char *data, unsigned int size) {
+		if (fullHeaderReceived) {
+			return true;
+		}
+		buffer.append(data, size);
+		for (; buffer.size() >= 3 && searchStart < buffer.size() - 3; searchStart++) {
+			if (buffer[searchStart] == CR &&
+			    buffer[searchStart + 1] == LF &&
+			    buffer[searchStart + 2] == CR &&
+			    buffer[searchStart + 3] == LF) {
+				fullHeaderReceived = true;
+				extractStatusLine();
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Returns the HTTP status line that has been determined.
+	 *
+	 * The default value is "200 OK\r\n", which is returned if the HTTP
+	 * response data that has been fed so far does not include a status
+	 * line.
+	 *
+	 * @note The return value includes a trailing CRLF, e.g. "404 Not Found\r\n".
+	 */
+	string getStatusLine() const {
+		return statusLine;
+	}
+	
+	/**
+	 * Get the data that has been fed so far.
+	 */
+	string getBuffer() const {
+		return buffer;
+	}
+};
+
+} // namespace Passenger

data/ext/nginx/ScgiRequestParser.h

@@ -0,0 +1,317 @@
+/*
+ *  Phusion Passenger - http://www.modrails.com/
+ *  Copyright (c) 2009 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 <string>
+#include <map>
+
+#include "StaticString.h"
+
+using namespace std;
+
+namespace Passenger {
+
+/**
+ * A parser for SCGI requests. It parses the request header and ignores the
+ * body data.
+ *
+ * You can use it by constructing a parser object, then feeding data to the
+ * parser until it has reached a final state.
+ *
+ * Example:
+ * @code
+ *    ScgiRequestParser parser;
+ *    char buf[1024 * 16];
+ *    ssize_t size;
+ *    unsigned in bytesAccepted;
+ *    
+ *    do {
+ *        size = read(fd, buf, sizeof(buf));
+ *        bytesAccepted = parser.feed(buf, size);
+ *    } while (parser.acceptingInput());
+ *    // Parser is done when its return value isn't equal to the input size.
+ *    
+ *    // Check whether a parse error occured.
+ *    if (parser.getState() == ScgiRequestParser::ERROR) {
+ *        bailOut();
+ *    } else {
+ *        // All good! Do something with the SCGI header that the parser parsed.
+ *        processHeader(parser.getHeaderData());
+ *        
+ *        // If the last buffer passed to the parser also contains body data,
+ *        // then the body data starts at 'buf + bytesAccepted'.
+ *        if (bytesAccepted < size) {
+ *            processBody(buf + bytesAccepted);
+ *        }
+ *        while (!end_of_file(fd)) {
+ *            ... read(...) ...
+ *            processBody(...);
+ *        }
+ *    }
+ * @endcode
+ *
+ * Parser properties:
+ * - A parser object can only process a single SCGI request. You must discard
+ *   the existing parser object and create a new one if you want to process
+ *   another SCGI request.
+ * - This parser checks whether the header netstring is valid. It will enter
+ *   the error state if it encounters a parse error.
+ * - However, this parser does not perform any validation of the actual header
+ *   contents. For example, it doesn't check that CONTENT_LENGTH is the first
+ *   header, or that the SCGI header is present.
+ */
+class ScgiRequestParser {
+public:
+	enum State {
+		READING_LENGTH_STRING,
+		READING_HEADER_DATA,
+		EXPECTING_COMMA,
+		DONE,
+		ERROR
+	};
+	
+private:
+	State state;
+	char lengthStringBuffer[sizeof("4294967296")];
+	unsigned int lengthStringBufferSize;
+	unsigned long headerSize;
+	string headerBuffer;
+	map<StaticString, StaticString> headers;
+	
+	static inline bool isDigit(char byte) {
+		return byte >= '0' && byte <= '9';
+	}
+	
+	/**
+	 * Parse the given header data into key-value pairs.
+	 */
+	bool parseHeaderData(const string &data, map<StaticString, StaticString> &output) {
+		bool isName = true; // Whether we're currently expecting a name or a value.
+		const char *startOfString, *current, *end;
+		StaticString key, value;
+		
+		if (data.size() == 0) {
+			return true;
+		}
+		
+		startOfString = data.c_str();
+		end           = data.c_str() + data.size();
+		
+		if (*(end - 1) != '\0') {
+			return false;
+		}
+		
+		for (current = data.c_str(); current != end; current++) {
+			if (isName && *current == '\0') {
+				key = StaticString(startOfString, current - startOfString);
+				startOfString = current + 1;
+				isName = false;
+			} else if (!isName && *current == '\0') {
+				value = StaticString(startOfString, current - startOfString);
+				startOfString = current + 1;
+				isName = true;
+				
+				output[key] = value;
+				key   = StaticString();
+				value = StaticString();
+			}
+		}
+		
+		return isName;
+	}
+	
+	/**
+	 * Process the given data, which contains header data and possibly
+	 * some body data as well.
+	 */
+	unsigned int readHeaderData(const char *data, unsigned int size) {
+		unsigned int bytesToRead;
+		
+		// Calculate how many bytes of header data is left to be read.
+		// Do not read past the header data.
+		if (size < headerSize - headerBuffer.size()) {
+			bytesToRead = size;
+		} else {
+			bytesToRead = headerSize - headerBuffer.size();
+		}
+		// Append the newly received header data to the header data buffer.
+		headerBuffer.append(data, bytesToRead);
+		
+		if (headerBuffer.size() == headerSize) {
+			// We've received all header data. Now attempt to parse this.
+			if (bytesToRead < size) {
+				if (data[bytesToRead] == ',') {
+					if (parseHeaderData(headerBuffer, headers)) {
+						state = DONE;
+						return bytesToRead + 1;
+					} else {
+						state = ERROR;
+						return bytesToRead;
+					}
+				} else {
+					state = ERROR;
+					return bytesToRead;
+				}
+			} else {
+				if (parseHeaderData(headerBuffer, headers)) {
+					state = EXPECTING_COMMA;
+				} else {
+					state = ERROR;
+				}
+				return bytesToRead;
+			}
+		} else {
+			// Not all header data has been received yet.
+			return bytesToRead;
+		}
+	}
+	
+public:
+	/**
+	 * Create a new ScgiRequestParser, ready to parse a request.
+	 */
+	ScgiRequestParser() {
+		state = READING_LENGTH_STRING;
+		lengthStringBufferSize = 0;
+		headerSize = 0;
+	}
+	
+	/**
+	 * Feed SCGI request data to the parser.
+	 *
+	 * @param data The data to feed.
+	 * @param size The size of the data, in bytes.
+	 * @return The number of recognized SCGI header bytes. If this value
+	 *         equals 'size', then it means all data in 'data' is part of
+	 *         the SCGI header. If this value is less than size, then it
+	 *         means only some data in 'data' is part of the SCGI header,
+	 *         and the remaining 'size - result' bytes are part of the
+	 *         request body.
+	 * @pre size > 0
+	 * @post result <= size
+	 * @post if result <= size: getState() == DONE || getState() == ERROR
+	 */
+	unsigned int feed(const char *data, unsigned int size) {
+		unsigned int i;
+		
+		switch (state) {
+		case READING_LENGTH_STRING:
+			// Keep processing length string data...
+			for (i = 0; i < size; i++) {
+				char byte = data[i];
+				
+				if (lengthStringBufferSize == sizeof(lengthStringBuffer) - 1) {
+					// ...and abort if the length string is too long.
+					state = ERROR;
+					return i;
+				} else if (!isDigit(byte)) {
+					if (byte == ':') {
+						// ...until the end of the length string has been reached.
+						state = READING_HEADER_DATA;
+						lengthStringBuffer[lengthStringBufferSize] = '\0';
+						headerSize = atol(lengthStringBuffer);
+						headerBuffer.reserve(headerSize);
+						// From here on, process the rest of the data that we've
+						// received, as header data.
+						return readHeaderData(data + i + 1, size - i - 1) + i + 1;
+					} else {
+						// ...until we encounter a parse error.
+						state = ERROR;
+						return i;
+					}
+				} else {
+					lengthStringBuffer[lengthStringBufferSize] = byte;
+					lengthStringBufferSize++;
+				}
+			}
+			return i;
+		
+		case READING_HEADER_DATA:
+			return readHeaderData(data, size);
+		
+		case EXPECTING_COMMA:
+			if (data[0] == ',') {
+				state = DONE;
+				return 1;
+			} else {
+				state = ERROR;
+				return 0;
+			}
+		
+		default:
+			return 0;
+		}
+	}
+	
+	/**
+	 * Get the raw header data that has been processed so far.
+	 */
+	string getHeaderData() const {
+		return headerBuffer;
+	}
+	
+	/**
+	 * Get the value of the header with the given name.
+	 * Lookup is case-sensitive.
+	 *
+	 * Returns the empty string if there is no such header.
+	 *
+	 * @pre getState() == DONE
+	 */
+	StaticString getHeader(const StaticString &name) const {
+		map<StaticString, StaticString>::const_iterator it(headers.find(name));
+		if (it == headers.end()) {
+			return "";
+		} else {
+			return it->second;
+		}
+	}
+	
+	/**
+	 * Checks whether there is a header with the given name.
+	 * Lookup is case-sensitive.
+	 *
+	 * @pre getState() == DONE
+	 */
+	bool hasHeader(const StaticString &name) const {
+		return headers.find(name) != headers.end();
+	}
+	
+	/**
+	 * Get the parser's current state.
+	 */
+	State getState() const {
+		return state;
+	}
+	
+	/**
+	 * Checks whether this parser is still capable of accepting input (that
+	 * is, that this parser is not in a final state).
+	 */
+	bool acceptingInput() const {
+		return state != DONE && state != ERROR;
+	}
+};
+
+} // namespace Passenger