passenger 5.3.4 → 6.0.1

data/src/cxx_supportlib/AppLocalConfigFileUtils.h

@@ -0,0 +1,148 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2018 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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.
+ */
+#ifndef _PASSENGER_APP_LOCAL_CONFIG_FILE_UTILS_H_
+#define _PASSENGER_APP_LOCAL_CONFIG_FILE_UTILS_H_
+
+#include <oxt/system_calls.hpp>
+#include <oxt/backtrace.hpp>
+
+#include <cerrno>
+#include <fcntl.h>
+
+#include <jsoncpp/json.h>
+
+#include <StaticString.h>
+#include <Constants.h>
+#include <Exceptions.h>
+#include <IOTools/IOUtils.h>
+#include <Utils/ScopeGuard.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+struct AppLocalConfig {
+	string appStartCommand;
+	bool appSupportsKuriaProtocol;
+
+	AppLocalConfig()
+		: appSupportsKuriaProtocol(false)
+		{ }
+};
+
+
+inline AppLocalConfig
+parseAppLocalConfigFile(const StaticString appRoot) {
+	TRACE_POINT();
+	string path = appRoot + "/Passengerfile.json";
+
+	// Reading from Passengerfile.json from a root process is unsafe
+	// because of symlink attacks and other kinds of attacks. See the
+	// comments for safeReadFile().
+	//
+	// We are unable to use safeReadFile() here because we do not
+	// control the safety of the directories leading up to appRoot.
+	//
+	// What we can do is preventing the contents of an arbitrary
+	// file read from leaking out. Therefore, our result struct
+	// only contains a limited number of fields, that are known
+	// not to contain sensitive information. We also don't propagate
+	// JSON parsing error messages, which may contain the content.
+
+	int fd = syscalls::open(path.c_str(), O_RDONLY | O_NONBLOCK);
+	if (fd == -1) {
+		if (errno == ENOENT) {
+			return AppLocalConfig();
+		} else {
+			int e = errno;
+			throw FileSystemException("Error opening '" + path
+				+ "' for reading", e, path);
+		}
+	}
+
+	UPDATE_TRACE_POINT();
+	FdGuard fdGuard(fd, __FILE__, __LINE__);
+	pair<string, bool> content;
+	try {
+		content = readAll(fd, 1024 * 512);
+	} catch (const SystemException &e) {
+		throw FileSystemException("Error reading from '" + path + "'",
+			e.code(), path);
+	}
+	if (!content.second) {
+		throw SecurityException("Error parsing " + path
+			+ ": file exceeds size limit of 512 KB");
+	}
+	fdGuard.runNow();
+
+	UPDATE_TRACE_POINT();
+	Json::Reader reader;
+	Json::Value config;
+	if (!reader.parse(content.first, config)) {
+		if (geteuid() == 0) {
+			throw RuntimeException("Error parsing " + path
+				+ " (error messages suppressed for security reasons)");
+		} else {
+			throw RuntimeException("Error parsing " + path + ": "
+				+ reader.getFormattedErrorMessages());
+		}
+	}
+	// We no longer need the raw data so free the memory.
+	content.first.resize(0);
+
+
+	UPDATE_TRACE_POINT();
+	AppLocalConfig result;
+
+	if (!config.isObject()) {
+		throw RuntimeException("Config file " + path
+			+ " is not valid: top-level JSON object expected");
+	}
+	if (config.isMember("app_start_command")) {
+		if (config["app_start_command"].isString()) {
+			result.appStartCommand = config["app_start_command"].asString();
+		} else {
+			throw RuntimeException("Config file " + path
+				+ " is not valid: key 'app_start_command' must be a boolean");
+		}
+	}
+	if (config.isMember("app_supports_kuria_protocol")) {
+		if (config["app_supports_kuria_protocol"].isBool()) {
+			result.appSupportsKuriaProtocol = config["app_supports_kuria_protocol"].asBool();
+		} else {
+			throw RuntimeException("Config file " + path
+				+ " is not valid: key 'app_supports_kuria_protocol' must be a boolean");
+		}
+	}
+
+	return result;
+}
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_APP_LOCAL_CONFIG_FILE_UTILS_H_ */

data/src/cxx_supportlib/AppTypeDetector/CBindings.cpp

@@ -0,0 +1,147 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2018 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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 <cstddef>
+#include <new>
+#include <exception>
+
+#include <StaticString.h>
+#include <AppTypeDetector/CBindings.h>
+#include <AppTypeDetector/Detector.h>
+
+using namespace Passenger;
+using namespace Passenger::WrapperRegistry;
+using namespace Passenger::AppTypeDetector;
+
+
+size_t
+psg_app_type_detector_result_get_object_size() {
+	return sizeof(Detector::Result);
+}
+
+PsgAppTypeDetectorResult *
+psg_app_type_detector_result_init(void *memory) {
+	Detector::Result *cxxResult = new (memory) Detector::Result();
+	return static_cast<PsgAppTypeDetectorResult *>(cxxResult);
+}
+
+void
+psg_app_type_detector_result_deinit(PsgAppTypeDetectorResult *result) {
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	cxxResult->~Result();
+}
+
+int
+psg_app_type_detector_result_is_null(const PsgAppTypeDetectorResult *result) {
+	const Detector::Result *cxxResult = static_cast<const Detector::Result *>(result);
+	return (int) cxxResult->isNull();
+}
+
+const PsgWrapperRegistryEntry *
+psg_app_type_detector_result_get_wrapper_registry_entry(const PsgAppTypeDetectorResult *result) {
+	const Detector::Result *cxxResult = static_cast<const Detector::Result *>(result);
+	return static_cast<const PsgWrapperRegistryEntry *>(cxxResult->wrapperRegistryEntry);
+}
+
+void
+psg_app_type_detector_result_set_wrapper_registry_entry(PsgAppTypeDetectorResult *result,
+	const PsgWrapperRegistryEntry *entry)
+{
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	cxxResult->wrapperRegistryEntry = static_cast<const WrapperRegistry::Entry *>(entry);
+}
+
+const char *
+psg_app_type_detector_result_get_app_start_command(const PsgAppTypeDetectorResult *result,
+	size_t *len)
+{
+	const Detector::Result *cxxResult = static_cast<const Detector::Result *>(result);
+	if (len != NULL) {
+		*len = cxxResult->appStartCommand.size();
+	}
+	return cxxResult->appStartCommand.data();
+}
+
+
+PsgAppTypeDetector *
+psg_app_type_detector_new(const PsgWrapperRegistry *registry,
+	unsigned int throttleRate)
+{
+	const Registry *cxxRegistry = static_cast<const Registry *>(registry);
+	try {
+		Detector *detector = new Detector(*cxxRegistry, NULL, NULL, throttleRate, NULL);
+		return static_cast<PsgAppTypeDetector *>(detector);
+	} catch (const std::bad_alloc &) {
+		return NULL;
+	}
+}
+
+void
+psg_app_type_detector_free(PsgAppTypeDetector *detector) {
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	delete cxxDetector;
+}
+
+void
+psg_app_type_detector_set_throttle_rate(PsgAppTypeDetector *detector,
+	unsigned int throttleRate)
+{
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	cxxDetector->setThrottleRate(throttleRate);
+}
+
+void
+psg_app_type_detector_check_document_root(
+	PsgAppTypeDetector *detector, PsgAppTypeDetectorResult *result,
+	const char *documentRoot, unsigned int len, int resolveFirstSymlink,
+	PP_Error *error)
+{
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	try {
+		*cxxResult = cxxDetector->checkDocumentRoot(
+			StaticString(documentRoot, len), resolveFirstSymlink);
+	} catch (const std::exception &e) {
+		pp_error_set(e, error);
+		*cxxResult = Detector::Result();
+	}
+}
+
+void
+psg_app_type_detector_check_app_root(
+	PsgAppTypeDetector *detector, PsgAppTypeDetectorResult *result,
+	const char *appRoot, unsigned int len, PP_Error *error)
+{
+	Detector *cxxDetector = static_cast<Detector *>(detector);
+	Detector::Result *cxxResult = static_cast<Detector::Result *>(result);
+	try {
+		*cxxResult = cxxDetector->checkAppRoot(
+			StaticString(appRoot, len));
+	} catch (const std::exception &e) {
+		pp_error_set(e, error);
+		*cxxResult = Detector::Result();
+	}
+}

data/src/cxx_supportlib/AppTypeDetector/CBindings.h

@@ -0,0 +1,75 @@
+/*
+ *  Phusion Passenger - https://www.phusionpassenger.com/
+ *  Copyright (c) 2018 Phusion Holding B.V.
+ *
+ *  "Passenger", "Phusion Passenger" and "Union Station" are registered
+ *  trademarks of Phusion Holding B.V.
+ *
+ *  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.
+ */
+#ifndef _PASSENGER_APP_TYPE_DETECTOR_CBINDINGS_H_
+#define _PASSENGER_APP_TYPE_DETECTOR_CBINDINGS_H_
+
+#include <stddef.h>
+#include "../WrapperRegistry/CBindings.h"
+#include "../Exceptions.h"
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+
+typedef void PsgAppTypeDetectorResult;
+
+size_t psg_app_type_detector_result_get_object_size();
+PsgAppTypeDetectorResult *psg_app_type_detector_result_init(void *memory);
+void psg_app_type_detector_result_deinit(PsgAppTypeDetectorResult *result);
+
+int psg_app_type_detector_result_is_null(const PsgAppTypeDetectorResult *result);
+const PsgWrapperRegistryEntry *psg_app_type_detector_result_get_wrapper_registry_entry(
+	const PsgAppTypeDetectorResult *result);
+void psg_app_type_detector_result_set_wrapper_registry_entry(PsgAppTypeDetectorResult *result,
+	const PsgWrapperRegistryEntry *entry);
+const char *psg_app_type_detector_result_get_app_start_command(const PsgAppTypeDetectorResult *result,
+	size_t *len);
+
+
+typedef void PsgAppTypeDetector;
+
+PsgAppTypeDetector *psg_app_type_detector_new(const PsgWrapperRegistry *registry,
+	unsigned int throttleRate);
+void psg_app_type_detector_free(PsgAppTypeDetector *detector);
+void psg_app_type_detector_set_throttle_rate(PsgAppTypeDetector *detector,
+	unsigned int throttleRate);
+void psg_app_type_detector_check_document_root(
+	PsgAppTypeDetector *detector,
+	PsgAppTypeDetectorResult *result,
+	const char *documentRoot, unsigned int len, int resolveFirstSymlink,
+	PP_Error *error);
+void psg_app_type_detector_check_app_root(
+	PsgAppTypeDetector *detector,
+	PsgAppTypeDetectorResult *result,
+	const char *appRoot, unsigned int len, PP_Error *error);
+
+
+#ifdef __cplusplus
+	} // extern "C"
+#endif
+
+#endif /* _PASSENGER_APP_TYPE_DETECTOR_CBINDINGS_H_ */

data/src/cxx_supportlib/{AppTypes.h → AppTypeDetector/Detector.h}

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - https://www.phusionpassenger.com/
- *  Copyright (c) 2013-2017 Phusion Holding B.V.
+ *  Copyright (c) 2018 Phusion Holding B.V.
  *
  *  "Passenger", "Phusion Passenger" and "Union Station" are registered
  *  trademarks of Phusion Holding B.V.
@@ -23,117 +23,115 @@
  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  *  THE SOFTWARE.
  */
-#ifndef _PASSENGER_APP_TYPES_H_
-#define _PASSENGER_APP_TYPES_H_
-
-/**
- * Application type registry
- *
- * All supported application types (e.g. Rack, classic Rails, WSGI, etc)
- * are registered here. The AppTypeDetector is responsible for checking
- * what kind of application lives under the given directory.
- */
-
-#include "Exceptions.h"
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-typedef enum {
-	PAT_RACK,
-	PAT_WSGI,
-	PAT_NODE,
-	PAT_METEOR,
-	PAT_NONE,
-	PAT_ERROR
-} PassengerAppType;
-
-typedef void PP_AppTypeDetector;
-
-PP_AppTypeDetector *pp_app_type_detector_new(unsigned int throttleRate);
-void pp_app_type_detector_free(PP_AppTypeDetector *detector);
-void pp_app_type_detector_set_throttle_rate(PP_AppTypeDetector *detector,
-	unsigned int throttleRate);
-PassengerAppType pp_app_type_detector_check_document_root(PP_AppTypeDetector *detector,
-	const char *documentRoot, unsigned int len, int resolveFirstSymlink,
-	PP_Error *error);
-PassengerAppType pp_app_type_detector_check_app_root(PP_AppTypeDetector *detector,
-	const char *appRoot, unsigned int len, PP_Error *error);
-
-const char *pp_get_app_type_name(PassengerAppType type);
-PassengerAppType pp_get_app_type2(const char *name, unsigned int len);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
+#ifndef _PASSENGER_APP_TYPE_DECTECTOR_H_
+#define _PASSENGER_APP_TYPE_DECTECTOR_H_
 
+#include <limits.h>
 
-#ifdef __cplusplus
+#include <boost/thread.hpp>
+#include <boost/foreach.hpp>
 #include <oxt/macros.hpp>
 #include <oxt/backtrace.hpp>
-#include <boost/thread.hpp>
-#include <cstdlib>
-#include <limits.h>
+
+#include <cassert>
+#include <cstddef>
 #include <string>
-#include <LoggingKit/LoggingKit.h>
-#include <StaticString.h>
+
+#include <Exceptions.h>
+#include <AppLocalConfigFileUtils.h>
+#include <WrapperRegistry/Registry.h>
 #include <FileTools/PathManip.h>
 #include <FileTools/FileManip.h>
+#include <StrIntTools/StrIntUtils.h>
+#include <DataStructures/StringKeyTable.h>
 #include <Utils.h>
-#include <Utils/StrIntUtils.h>
 #include <Utils/CachedFileStat.hpp>
 
 namespace Passenger {
+namespace AppTypeDetector {
 
 using namespace std;
 
+typedef AppLocalConfig* AppLocalConfigPtr;
+typedef StringKeyTable<AppLocalConfig> AppLocalConfigMap;
 
-struct AppTypeDefinition {
-	const PassengerAppType type;
-	const char * const name;
-	const char * const startupFile;
-	const char * const processTitle;
-};
+class Detector {
+public:
+	struct Result {
+		const WrapperRegistry::Entry *wrapperRegistryEntry;
+		string appStartCommand;
 
-extern const AppTypeDefinition appTypeDefinitions[];
+		Result()
+			: wrapperRegistryEntry(NULL)
+			{ }
 
+		bool isNull() const {
+			return wrapperRegistryEntry == NULL && appStartCommand.empty();
+		}
+	};
 
-class AppTypeDetector {
 private:
+	const WrapperRegistry::Registry &registry;
 	CachedFileStat *cstat;
 	boost::mutex *cstatMutex;
 	unsigned int throttleRate;
 	bool ownsCstat;
+	AppLocalConfigMap appLocalConfigCache;
+	boost::mutex *configMutex;
+	StringKeyTable<time_t> appRootCheckTimes;
 
-	bool check(char *buf, const char *end, const StaticString &appRoot, const char *name) {
+	bool check(char *buf, const char *end, const StaticString &appRoot,
+		const StaticString &name)
+	{
 		char *pos = buf;
 		pos = appendData(pos, end, appRoot);
-		pos = appendData(pos, end, "/");
+		pos = appendData(pos, end, "/", 1);
 		pos = appendData(pos, end, name);
 		pos = appendData(pos, end, "\0", 1);
 		if (OXT_UNLIKELY(pos == end)) {
 			TRACE_POINT();
 			throw RuntimeException("Not enough buffer space");
 		}
-		return getFileType(StaticString(buf, pos - buf - 1), cstat, cstatMutex, throttleRate) != FT_NONEXISTANT;
+		return getFileType(StaticString(buf, pos - buf - 1),
+			cstat, cstatMutex, throttleRate) != FT_NONEXISTANT;
+	}
+
+	AppLocalConfigPtr getAppLocalConfigFromCache(const StaticString &appRoot) {
+		boost::unique_lock<boost::mutex> l;
+		time_t currentTime = SystemTime::get();
+		if (configMutex != NULL) {
+			l = boost::unique_lock<boost::mutex>(*configMutex);
+		}
+		if (!appLocalConfigCache.contains(appRoot)
+			|| currentTime >= (appRootCheckTimes.lookupCopy(appRoot) + throttleRate)) {
+			AppLocalConfig config = parseAppLocalConfigFile(appRoot);
+			appLocalConfigCache.insert(appRoot, config);
+			appRootCheckTimes.insert(appRoot, currentTime);
+		}
+		AppLocalConfigPtr appLocalConfig;
+		appLocalConfigCache.lookup(appRoot, &appLocalConfig);
+		return appLocalConfig;
 	}
 
 public:
-	AppTypeDetector(CachedFileStat *_cstat = NULL, boost::mutex *_cstatMutex = NULL, unsigned int _throttleRate = 1)
-		: cstat(_cstat),
+	Detector(const WrapperRegistry::Registry &_registry,
+		CachedFileStat *_cstat = NULL, boost::mutex *_cstatMutex = NULL,
+		unsigned int _throttleRate = 1, boost::mutex *_configMutex = NULL)
+		: registry(_registry),
+		  cstat(_cstat),
 		  cstatMutex(_cstatMutex),
 		  throttleRate(_throttleRate),
-		  ownsCstat(false)
+		  ownsCstat(false),
+		  configMutex(_configMutex)
 	{
+		assert(_registry.isFinalized());
 		if (_cstat == NULL) {
 			cstat = new CachedFileStat();
 			ownsCstat = true;
 		}
 	}
 
-	~AppTypeDetector() {
+	~Detector() {
 		if (ownsCstat) {
 			delete cstat;
 		}
@@ -146,7 +144,7 @@ public:
 	/**
 	 * Given a web server document root (that is, some subdirectory under the
 	 * application root, e.g. "/webapps/foobar/public"), returns the type of
-	 * application that lives there. Returns PAT_NONE if it wasn't able to detect
+	 * application that lives there. Returns a null result if it wasn't able to detect
 	 * a supported application type.
 	 *
 	 * If `resolveFirstSymlink` is given, and `documentRoot` is a symlink, then
@@ -161,7 +159,7 @@ public:
 	 * @throws TimeRetrievalException
 	 * @throws boost::thread_interrupted
 	 */
-	PassengerAppType checkDocumentRoot(const StaticString &documentRoot,
+	const Result checkDocumentRoot(const StaticString &documentRoot,
 		bool resolveFirstSymlink = false,
 		string *appRoot = NULL)
 	{
@@ -193,83 +191,46 @@ public:
 
 	/**
 	 * Returns the type of application that lives under the application
-	 * directory `appRoot`. Returns PAT_NONE if it wasn't able to detect
+	 * directory `appRoot`. Returns a null result if it wasn't able to detect
 	 * a supported application type.
 	 *
 	 * @throws FileSystemException Unable to check because of a filesystem error.
 	 * @throws TimeRetrievalException
 	 * @throws boost::thread_interrupted
 	 */
-	PassengerAppType checkAppRoot(const StaticString &appRoot) {
+	const Result checkAppRoot(const StaticString &appRoot) {
 		char buf[PATH_MAX + 32];
 		const char *end = buf + sizeof(buf) - 1;
-		const AppTypeDefinition *definition = &appTypeDefinitions[0];
-
-		while (definition->type != PAT_NONE) {
-			if (check(buf, end, appRoot, definition->startupFile)) {
-				return definition->type;
-			}
-			definition++;
-		}
-		return PAT_NONE;
-	}
-};
 
+		AppLocalConfigPtr appLocalConfig = getAppLocalConfigFromCache(appRoot);
 
-inline const char *
-getAppTypeName(PassengerAppType type) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
-
-	while (definition->type != PAT_NONE) {
-		if (definition->type == type) {
-			return definition->name;
+		if (!appLocalConfig->appStartCommand.empty()) {
+			Result result;
+			result.appStartCommand = appLocalConfig->appStartCommand;
+			return result;
 		}
-		definition++;
-	}
-	return NULL;
-}
 
-inline PassengerAppType
-getAppType(const StaticString &name) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
-
-	while (definition->type != PAT_NONE) {
-		if (name == definition->name) {
-			return definition->type;
-		}
-		definition++;
-	}
-	return PAT_NONE;
-}
-
-inline const char *
-getAppTypeStartupFile(PassengerAppType type) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
-
-	while (definition->type != PAT_NONE) {
-		if (definition->type == type) {
-			return definition->startupFile;
+		WrapperRegistry::Registry::ConstIterator it(registry.getIterator());
+		while (*it != NULL) {
+			const WrapperRegistry::Entry &entry = it.getValue();
+			foreach (const StaticString &defaultStartupFile,
+				entry.defaultStartupFiles)
+			{
+				if (check(buf, end, appRoot, defaultStartupFile)) {
+					Result result;
+					result.wrapperRegistryEntry = &entry;
+					return result;
+				}
+			}
+			it.next();
 		}
-		definition++;
-	}
-	return NULL;
-}
-
-inline const char *
-getAppTypeProcessTitle(PassengerAppType type) {
-	const AppTypeDefinition *definition = &appTypeDefinitions[0];
 
-	while (definition->type != PAT_NONE) {
-		if (definition->type == type) {
-			return definition->processTitle;
-		}
-		definition++;
+		return Result();
 	}
-	return NULL;
-}
+};
 
 
+} // namespace AppTypeDetector
 } // namespace Passenger
-#endif /* __cplusplus */
 
-#endif /* _PASSENGER_APP_TYPES_H_ */
+#endif /* _PASSENGER_APP_TYPE_DECTECTOR_H_ */