passenger 5.3.4 → 5.3.5

data/src/cxx_supportlib/WrapperRegistry/README.md

@@ -0,0 +1,37 @@
+# The wrapper registry
+
+The wrapper registry (the Registry class) describes for which languages Passenger has wrappers available. Each entry (the Entry class) describes:
+
+ * An identifier for this language (ex: `rack`). Related to `passenger_app_type`.
+ * The path to the wrapper (ex. `rack-loader.rb`).
+ * The title that the spawned process should assume (ex: `Passenger RubyApp`).
+ * The default interpreter command for this language (ex: `ruby`). Related to `passenger_ruby`, among others.
+ * Zero or more names for the default startup file (ex: `config.ru`, `app.js`, `index.js`). Related to `passenger_startup_file`.
+
+## Synopsis
+
+After construction, one can add entries to the registry. When done, one must call `finalize()` after which no more mutations are allowed. The Registry will contain some built-in, hardcoded entries after construction.
+
+Given a language identifier, the Registry can lookup the corresponding Entry.
+
+~~~c++
+Registry reg;
+reg.finalize();
+
+const Entry &ruby = reg.lookup("ruby");
+cout << ruby.language << endl; // => ruby
+cout << ruby.path << endl;     // => rack-loader.rb
+                               // etc
+~~~
+
+## Properties
+
+The Registry, after finalization, is a static, immutable, in-memory database. Default, built-in, hardcoded entries are inserted during object creation. Registry allows adding additional entries after creation, but this functionality is not actually used and is reserved for the future. So at present, the Registry will only contain a small number of known entries.
+
+After finalization, Registry is thread-safe because of its immutability.
+
+Entries' lifetimes are the same as that of the Registry itself.
+
+## Relationships
+
+The wrapper registry's main use is to be used by the AppTypeDetector, to detect what kind of application lives in a certain directory, and (if applicable) which wrapper should be used.

data/src/cxx_supportlib/WrapperRegistry/Registry.h

@@ -0,0 +1,309 @@
+/*
+ *  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_WRAPPER_REGISTRY_REGISTRY_H_
+#define _PASSENGER_WRAPPER_REGISTRY_REGISTRY_H_
+
+#include <cassert>
+#include <cstddef>
+
+#include <boost/foreach.hpp>
+#include <boost/shared_array.hpp>
+#include <oxt/macros.hpp>
+
+#include <WrapperRegistry/Entry.h>
+#include <DataStructures/StringKeyTable.h>
+#include <Constants.h>
+#include <Utils.h>
+#include <Utils/StrIntUtils.h>
+
+namespace Passenger {
+namespace WrapperRegistry {
+
+using namespace std;
+
+
+class Registry {
+public:
+	typedef StringKeyTable<Entry>::ConstIterator ConstIterator;
+
+private:
+	StringKeyTable<Entry> entries;
+	StringKeyTable<HashedStaticString> aliases;
+	boost::shared_array<char> storage;
+	const Entry nullEntry;
+	bool finalized;
+
+	void internStrings() {
+		size_t totalSize = 0;
+		size_t tmpSize;
+		char *newStorage, *pos, *end;
+
+		// Calculate required storage size
+		{
+			StringKeyTable<Entry>::ConstIterator it(entries);
+			while (*it != NULL) {
+				const Entry &entry = it.getValue();
+
+				totalSize += entry.language.size() + 1;
+				totalSize += entry.languageDisplayName.size() + 1;
+				totalSize += entry.path.size() + 1;
+				totalSize += entry.processTitle.size() + 1;
+				totalSize += entry.defaultInterpreter.size() + 1;
+				foreach (const StaticString &defaultStartupFile,
+					entry.defaultStartupFiles)
+				{
+					totalSize += defaultStartupFile.size() + 1;
+				}
+
+				it.next();
+			}
+		}
+		{
+			StringKeyTable<HashedStaticString>::ConstIterator it(aliases);
+			while (*it != NULL) {
+				const HashedStaticString &name = it.getValue();
+				totalSize += name.size() + 1;
+				it.next();
+			}
+		}
+
+		// Allocate new storage
+		newStorage = pos = new char[totalSize];
+		end = newStorage + totalSize;
+
+		// Fill new storage
+		{
+			StringKeyTable<Entry>::ConstIterator it(entries);
+			while (*it != NULL) {
+				const Entry &entry = it.getValue();
+
+				pos = appendData(pos, end, entry.language);
+				pos = appendData(pos, end, "\0", 1);
+
+				pos = appendData(pos, end, entry.languageDisplayName);
+				pos = appendData(pos, end, "\0", 1);
+
+				pos = appendData(pos, end, entry.path);
+				pos = appendData(pos, end, "\0", 1);
+
+				pos = appendData(pos, end, entry.processTitle);
+				pos = appendData(pos, end, "\0", 1);
+
+				pos = appendData(pos, end, entry.defaultInterpreter);
+				pos = appendData(pos, end, "\0", 1);
+
+				foreach (const StaticString &defaultStartupFile,
+					entry.defaultStartupFiles)
+				{
+					pos = appendData(pos, end, defaultStartupFile);
+					pos = appendData(pos, end, "\0", 1);
+				}
+
+				it.next();
+			}
+		}
+		{
+			StringKeyTable<HashedStaticString>::ConstIterator it(aliases);
+			while (*it != NULL) {
+				const HashedStaticString &name = it.getValue();
+				pos = appendData(pos, end, name);
+				pos = appendData(pos, end, "\0", 1);
+				it.next();
+			}
+		}
+
+		// Move over pointers to new storage
+		{
+			StringKeyTable<Entry>::Iterator it(entries);
+			pos = newStorage;
+			while (*it != NULL) {
+				Entry &entry = it.getValue();
+
+				tmpSize = entry.language.size();
+				entry.language = StaticString(pos, tmpSize);
+				pos += tmpSize + 1;
+
+				tmpSize = entry.languageDisplayName.size();
+				entry.languageDisplayName = StaticString(pos, tmpSize);
+				pos += tmpSize + 1;
+
+				tmpSize = entry.path.size();
+				entry.path = StaticString(pos, tmpSize);
+				pos += tmpSize + 1;
+
+				tmpSize = entry.processTitle.size();
+				entry.processTitle = StaticString(pos, tmpSize);
+				pos += tmpSize + 1;
+
+				tmpSize = entry.defaultInterpreter.size();
+				entry.defaultInterpreter = StaticString(pos, tmpSize);
+				pos += tmpSize + 1;
+
+				foreach (StaticString &defaultStartupFile,
+					entry.defaultStartupFiles)
+				{
+					tmpSize = defaultStartupFile.size();
+					defaultStartupFile = StaticString(pos, tmpSize);
+					pos += tmpSize + 1;
+				}
+
+				it.next();
+			}
+		}
+		{
+			StringKeyTable<HashedStaticString>::Iterator it(aliases);
+			while (*it != NULL) {
+				HashedStaticString &name = it.getValue();
+				tmpSize = name.size();
+				name = StaticString(pos, tmpSize);
+				pos += tmpSize + 1;
+				it.next();
+			}
+		}
+
+		// Commit current storage
+		storage.reset(newStorage);
+	}
+
+	void
+	addBuiltinEntries() {
+		{
+			Entry entry;
+			entry.language = "ruby";
+			entry.languageDisplayName = "Ruby";
+			entry.path = "rack-loader.rb";
+			entry.processTitle = SHORT_PROGRAM_NAME " RubyApp";
+			entry.defaultInterpreter = "ruby";
+			entry.defaultStartupFiles.push_back("config.ru");
+			entries.insert(entry.language, entry);
+			aliases.insert("rack", "ruby");
+		}
+
+		{
+			Entry entry;
+			entry.language = "nodejs";
+			entry.languageDisplayName = "Node.js";
+			entry.path = "node-loader.js";
+			entry.processTitle = SHORT_PROGRAM_NAME " NodejsApp";
+			entry.defaultInterpreter = "node";
+			// Other code in Passenger does not yet support the notion
+			// of multiple defaultStartupFiles.
+			//entry.defaultStartupFiles.push_back("index.js");
+			entry.defaultStartupFiles.push_back("app.js");
+			entries.insert(entry.language, entry);
+			aliases.insert("node", "nodejs");
+		}
+
+		{
+			Entry entry;
+			entry.language = "python";
+			entry.languageDisplayName = "Python";
+			entry.path = "wsgi-loader.py";
+			entry.processTitle = SHORT_PROGRAM_NAME " PythonApp";
+			entry.defaultInterpreter = "python";
+			entry.defaultStartupFiles.push_back("passenger_wsgi.py");
+			entries.insert(entry.language, entry);
+			aliases.insert("wsgi", "python");
+		}
+
+		{
+			Entry entry;
+			entry.language = "meteor";
+			entry.languageDisplayName = "Meteor";
+			entry.path = "meteor-loader.rb";
+			entry.processTitle = SHORT_PROGRAM_NAME " MeteorApp";
+			entry.defaultInterpreter = "ruby"; // because meteor-loader.rb is in Ruby
+			entry.defaultStartupFiles.push_back(".meteor");
+			entries.insert(entry.language, entry);
+		}
+
+		internStrings();
+	}
+
+public:
+	Registry()
+		: finalized(false)
+	{
+		addBuiltinEntries();
+	}
+
+	bool add(const Entry &entry) {
+		assert(!isFinalized());
+		// Disallow overwriting builtin entries for security reasons.
+		// Not sure whether overwriting builtin entries can be harmful
+		// but let's err on the safe side.
+		bool result = entries.insert(entry.language, entry, false);
+		internStrings();
+		return result;
+	}
+
+	bool isFinalized() const {
+		return finalized;
+	}
+
+	void finalize() {
+		assert(!isFinalized());
+		entries.compact();
+		aliases.compact();
+		finalized = true;
+	}
+
+	const Entry &lookup(const HashedStaticString &name) const {
+		assert(isFinalized());
+
+		if (OXT_UNLIKELY(name.empty())) {
+			return nullEntry;
+		}
+
+		const Entry *result;
+		HashedStaticString aliasTarget = aliases.lookupCopy(name);
+		if (aliasTarget.empty()) {
+			entries.lookup(name, &result);
+		} else {
+			entries.lookup(aliasTarget, &result);
+		}
+		if (result != NULL) {
+			return *result;
+		} else {
+			return nullEntry;
+		}
+	}
+
+	const Entry &getNullEntry() const {
+		return nullEntry;
+	}
+
+	ConstIterator getIterator() const {
+		assert(isFinalized());
+		return ConstIterator(entries);
+	}
+};
+
+
+} // namespace WrapperRegistry
+} // namespace Passenger
+
+#endif /* _PASSENGER_WRAPPER_REGISTRY_REGISTRY_H_ */

data/src/helper-scripts/download_binaries/extconf.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #  Phusion Passenger - https://www.phusionpassenger.com/
-#  Copyright (c) 2010-2017 Phusion Holding B.V.
+#  Copyright (c) 2010-2018 Phusion Holding B.V.
 #
 #  "Passenger", "Phusion Passenger" and "Union Station" are registered
 #  trademarks of Phusion Holding B.V.
@@ -95,7 +95,11 @@ def download(name, options = {})
 end
 
 def really_download(site, name, logger, options)
-  url = "#{site[:url]}/#{PhusionPassenger::VERSION_STRING}/#{name}"
+  if site[:url].include?('{{VERSION}}')
+    url = site[:url].gsub('{{VERSION}}', PhusionPassenger::VERSION_STRING) + "/#{name}"
+  else
+    url = "#{site[:url]}/#{PhusionPassenger::VERSION_STRING}/#{name}"
+  end
   puts "Attempting to download #{url} into #{Dir.pwd}"
   File.unlink("#{name}.tmp") rescue nil
 

data/src/nginx_module/ConfigGeneral/AutoGeneratedDefinitions.c

@@ -134,6 +134,22 @@
     offsetof(passenger_main_conf_t, autogenerated.security_update_check_proxy),
     NULL
 },
+{
+    ngx_string("passenger_disable_anonymous_telemetry"),
+    NGX_HTTP_MAIN_CONF | NGX_CONF_FLAG,
+    passenger_conf_set_disable_anonymous_telemetry,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    offsetof(passenger_main_conf_t, autogenerated.disable_anonymous_telemetry),
+    NULL
+},
+{
+    ngx_string("passenger_anonymous_telemetry_proxy"),
+    NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1,
+    passenger_conf_set_anonymous_telemetry_proxy,
+    NGX_HTTP_MAIN_CONF_OFFSET,
+    offsetof(passenger_main_conf_t, autogenerated.anonymous_telemetry_proxy),
+    NULL
+},
 {
     ngx_string("passenger_pre_start"),
     NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1,

data/src/nginx_module/ConfigGeneral/AutoGeneratedManifestDefaultsInitialization.c

@@ -87,6 +87,12 @@ set_manifest_autogenerated_global_conf_defaults(manifest_gen_ctx_t *ctx) {
         sizeof("passenger_disable_security_update_check") - 1,
         0);
 
+    add_manifest_options_container_static_default_bool(ctx,
+        ctx->global_config_container,
+        "passenger_disable_anonymous_telemetry",
+        sizeof("passenger_disable_anonymous_telemetry") - 1,
+        0);
+
     add_manifest_options_container_dynamic_default(ctx,
         ctx->global_config_container,
         "passenger_instance_registry_dir",

data/src/nginx_module/ConfigGeneral/AutoGeneratedSetterFuncs.c

@@ -217,6 +217,30 @@ passenger_conf_set_security_update_check_proxy(ngx_conf_t *cf, ngx_command_t *cm
     return ngx_conf_set_str_slot(cf, cmd, conf);
 }
 
+static char *
+passenger_conf_set_disable_anonymous_telemetry(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+    passenger_main_conf_t *passenger_conf = conf;
+
+    passenger_conf->autogenerated.disable_anonymous_telemetry_explicitly_set = 1;
+    record_main_conf_source_location(cf,
+        &passenger_conf->autogenerated.disable_anonymous_telemetry_source_file,
+        &passenger_conf->autogenerated.disable_anonymous_telemetry_source_line);
+
+    return ngx_conf_set_flag_slot(cf, cmd, conf);
+}
+
+static char *
+passenger_conf_set_anonymous_telemetry_proxy(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
+    passenger_main_conf_t *passenger_conf = conf;
+
+    passenger_conf->autogenerated.anonymous_telemetry_proxy_explicitly_set = 1;
+    record_main_conf_source_location(cf,
+        &passenger_conf->autogenerated.anonymous_telemetry_proxy_source_file,
+        &passenger_conf->autogenerated.anonymous_telemetry_proxy_source_line);
+
+    return ngx_conf_set_str_slot(cf, cmd, conf);
+}
+
 static char *
 passenger_conf_set_pre_start(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
     passenger_main_conf_t *passenger_conf = conf;

data/src/nginx_module/ContentHandler.c

@@ -169,6 +169,11 @@ map_uri_to_page_cache_file(ngx_http_request_t *r, ngx_str_t *public_dir,
     }
 }
 
+static void
+cleanup_detector_result(void *data) {
+    psg_app_type_detector_result_deinit((PsgAppTypeDetectorResult *) data);
+}
+
 static int
 find_base_uri(ngx_http_request_t *r, const passenger_loc_conf_t *loc,
               ngx_str_t *found_base_uri)
@@ -357,6 +362,7 @@ prepare_request_buffer_construction(ngx_http_request_t *r, passenger_context_t *
 #if (NGX_HAVE_INET6)
     struct sockaddr_in6  *sin6;
 #endif
+    const PsgWrapperRegistryEntry *wrapper_registry_entry;
 
     switch (r->method) {
     case NGX_HTTP_GET:
@@ -409,9 +415,10 @@ prepare_request_buffer_construction(ngx_http_request_t *r, passenger_context_t *
         break;
     }
 
-    state->app_type.data = (u_char *) pp_get_app_type_name(context->app_type);
-    /* Include null terminator */
-    state->app_type.len  = strlen((const char *) state->app_type.data);
+    wrapper_registry_entry = psg_app_type_detector_result_get_wrapper_registry_entry(
+        context->detector_result);
+    state->app_type.data = (u_char *) psg_wrapper_registry_entry_get_language(wrapper_registry_entry,
+        &state->app_type.len);
 
     /*
      * Nginx unescapes URI's before passing them to Phusion Passenger,
@@ -1362,7 +1369,10 @@ passenger_content_handler(ngx_http_request_t *r)
     u_char                 page_cache_file_str[NGX_MAX_PATH + 1];
     ngx_str_t              page_cache_file;
     passenger_context_t   *context;
+    void                  *detector_result_mem;
+    ngx_pool_cleanup_t    *detector_result_cleanup;
     PP_Error               error;
+    const PsgWrapperRegistryEntry *wrapper_registry_entry;
 
     if (passenger_main_conf.autogenerated.root_dir.len == 0) {
         return NGX_DECLINED;
@@ -1450,24 +1460,31 @@ passenger_content_handler(ngx_http_request_t *r)
         return passenger_static_content_handler(r, &page_cache_file);
     }
 
+    detector_result_mem = ngx_palloc(r->pool,
+        psg_app_type_detector_result_get_object_size());
+    context->detector_result = psg_app_type_detector_result_init(detector_result_mem);
+    detector_result_cleanup = ngx_pool_cleanup_add(r->pool, 0);
+    detector_result_cleanup->handler = cleanup_detector_result;
+    detector_result_cleanup->data = context->detector_result;
+
     if (slcf->autogenerated.app_type.data == NULL) {
         pp_error_init(&error);
         if (slcf->autogenerated.app_root.data == NULL) {
-            context->app_type = pp_app_type_detector_check_document_root(
-                pp_app_type_detector,
+            psg_app_type_detector_check_document_root(
+                psg_app_type_detector, context->detector_result,
                 (const char *) context->public_dir.data, context->public_dir.len,
                 context->base_uri.len != 0,
                 &error);
         } else {
-            context->app_type = pp_app_type_detector_check_app_root(
-                pp_app_type_detector,
+             psg_app_type_detector_check_app_root(
+                psg_app_type_detector, context->detector_result,
                 (const char *) slcf->autogenerated.app_root.data, slcf->autogenerated.app_root.len,
                 &error);
         }
-        if (context->app_type == PAT_NONE) {
-            return NGX_DECLINED;
-        } else if (context->app_type == PAT_ERROR) {
-            if (error.errnoCode == EACCES) {
+        if (psg_app_type_detector_result_is_null(context->detector_result)) {
+            if (error.message == NULL) {
+                return NGX_DECLINED;
+            } else if (error.errnoCode == EACCES) {
                 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
                               "%s; This error means that the Nginx worker process (PID %d, "
                               "running as UID %d) does not have permission to access this file. "
@@ -1486,10 +1503,14 @@ passenger_content_handler(ngx_http_request_t *r)
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
         }
     } else {
-        context->app_type = pp_get_app_type2((const char *) slcf->autogenerated.app_type.data,
+        wrapper_registry_entry = psg_wrapper_registry_lookup(psg_wrapper_registry,
+            (const char *) slcf->autogenerated.app_type.data,
             slcf->autogenerated.app_type.len);
-        if (context->app_type == PAT_NONE) {
+        if (psg_wrapper_registry_entry_is_null(wrapper_registry_entry)) {
             return NGX_DECLINED;
+        } else {
+            psg_app_type_detector_result_set_wrapper_registry_entry(
+                context->detector_result, wrapper_registry_entry);
         }
     }