passenger_dudemeister 3.0.1

data/ext/nginx/StaticContentHandler.c

@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) 2010 Phusion
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "StaticContentHandler.h"
+#include "ngx_http_passenger_module.h"
+
+static void
+set_request_extension(ngx_http_request_t *r, ngx_str_t *filename) {
+    u_char *tmp;
+    
+    /* Scan filename from the right until we've found a slash or a dot. */
+    tmp = filename->data + filename->len - 1;
+    while (tmp >= filename->data && *tmp != '/' && *tmp != '.') {
+        tmp--;
+    }
+    if (tmp >= filename->data && *tmp == '.') {
+        /* We found a dot, and until now we haven't seen any slashes.
+         * So we know that this is the filename's extension.
+        */
+        tmp++;
+        r->exten.data = tmp;
+        r->exten.len  = filename->len - (tmp - filename->data);
+    }
+}
+
+ngx_int_t
+passenger_static_content_handler(ngx_http_request_t *r, ngx_str_t *filename)
+{
+    u_char                    *last, *location;
+    size_t                     len;
+    ngx_int_t                  rc;
+    ngx_uint_t                 level;
+    ngx_log_t                 *log;
+    ngx_buf_t                 *b;
+    ngx_chain_t                out;
+    ngx_open_file_info_t       of;
+    ngx_http_core_loc_conf_t  *clcf;
+
+    if (!(r->method & (NGX_HTTP_GET|NGX_HTTP_HEAD|NGX_HTTP_POST))) {
+        return NGX_HTTP_NOT_ALLOWED;
+    }
+
+    if (r->uri.data[r->uri.len - 1] == '/') {
+        return NGX_DECLINED;
+    }
+
+    #if (PASSENGER_NGINX_MINOR_VERSION == 8 && PASSENGER_NGINX_MICRO_VERSION < 38) || \
+        (PASSENGER_NGINX_MINOR_VERSION == 7 && PASSENGER_NGINX_MICRO_VERSION < 66)
+        if (r->zero_in_uri) {
+            return NGX_DECLINED;
+        }
+    #endif
+
+    log = r->connection->log;
+
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0,
+                   "http filename: \"%s\"", filename->data);
+
+    clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
+
+    ngx_memzero(&of, sizeof(ngx_open_file_info_t));
+    #if NGX_VERSION_NUM >= 8000
+        of.read_ahead = clcf->read_ahead;
+    #endif
+    of.directio = clcf->directio;
+    of.valid = clcf->open_file_cache_valid;
+    of.min_uses = clcf->open_file_cache_min_uses;
+    of.errors = clcf->open_file_cache_errors;
+    of.events = clcf->open_file_cache_events;
+
+    if (ngx_open_cached_file(clcf->open_file_cache, filename, &of, r->pool)
+        != NGX_OK)
+    {
+        switch (of.err) {
+
+        case 0:
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+
+        case NGX_ENOENT:
+        case NGX_ENOTDIR:
+        case NGX_ENAMETOOLONG:
+
+            level = NGX_LOG_ERR;
+            rc = NGX_HTTP_NOT_FOUND;
+            break;
+
+        case NGX_EACCES:
+
+            level = NGX_LOG_ERR;
+            rc = NGX_HTTP_FORBIDDEN;
+            break;
+
+        default:
+
+            level = NGX_LOG_CRIT;
+            rc = NGX_HTTP_INTERNAL_SERVER_ERROR;
+            break;
+        }
+
+        if (rc != NGX_HTTP_NOT_FOUND || clcf->log_not_found) {
+            ngx_log_error(level, log, of.err,
+                          ngx_open_file_n " \"%s\" failed", filename->data);
+        }
+
+        return rc;
+    }
+
+    #if NGINX_VERSION_NUM >= 7000
+        r->root_tested = !r->error_page;
+    #endif
+	
+    ngx_log_debug1(NGX_LOG_DEBUG_HTTP, log, 0, "http static fd: %d", of.fd);
+
+    if (of.is_dir) {
+
+        ngx_log_debug0(NGX_LOG_DEBUG_HTTP, log, 0, "http dir");
+
+        r->headers_out.location = ngx_palloc(r->pool, sizeof(ngx_table_elt_t));
+        if (r->headers_out.location == NULL) {
+            return NGX_HTTP_INTERNAL_SERVER_ERROR;
+        }
+
+        len = r->uri.len + 1;
+
+        if (!clcf->alias && clcf->root_lengths == NULL && r->args.len == 0) {
+            location = filename->data + clcf->root.len;
+
+        } else {
+            if (r->args.len) {
+                len += r->args.len + 1;
+            }
+
+            location = ngx_pnalloc(r->pool, len);
+            if (location == NULL) {
+                return NGX_HTTP_INTERNAL_SERVER_ERROR;
+            }
+
+            last = ngx_copy(location, r->uri.data, r->uri.len);
+
+            *last = '/';
+
+            if (r->args.len) {
+                *++last = '?';
+                ngx_memcpy(++last, r->args.data, r->args.len);
+            }
+        }
+
+        /*
+         * we do not need to set the r->headers_out.location->hash and
+         * r->headers_out.location->key fields
+         */
+
+        r->headers_out.location->value.len = len;
+        r->headers_out.location->value.data = location;
+
+        return NGX_HTTP_MOVED_PERMANENTLY;
+    }
+
+#if !(NGX_WIN32) /* the not regular files are probably Unix specific */
+
+    if (!of.is_file) {
+        ngx_log_error(NGX_LOG_CRIT, log, 0,
+                      "\"%s\" is not a regular file", filename->data);
+
+        return NGX_HTTP_NOT_FOUND;
+    }
+
+#endif
+
+    if (r->method & NGX_HTTP_POST) {
+        return NGX_HTTP_NOT_ALLOWED;
+    }
+
+    rc = ngx_http_discard_request_body(r);
+
+    if (rc != NGX_OK) {
+        return rc;
+    }
+
+    log->action = "sending response to client";
+
+    r->headers_out.status = NGX_HTTP_OK;
+    r->headers_out.content_length_n = of.size;
+    r->headers_out.last_modified_time = of.mtime;
+
+    set_request_extension(r, filename);
+    if (ngx_http_set_content_type(r) != NGX_OK) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    if (r != r->main && of.size == 0) {
+        return ngx_http_send_header(r);
+    }
+
+    r->allow_ranges = 1;
+
+    /* we need to allocate all before the header would be sent */
+
+    b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
+    if (b == NULL) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    b->file = ngx_pcalloc(r->pool, sizeof(ngx_file_t));
+    if (b->file == NULL) {
+        return NGX_HTTP_INTERNAL_SERVER_ERROR;
+    }
+
+    rc = ngx_http_send_header(r);
+
+    if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) {
+        return rc;
+    }
+
+    b->file_pos = 0;
+    b->file_last = of.size;
+
+    b->in_file = b->file_last ? 1: 0;
+    b->last_buf = (r == r->main) ? 1: 0;
+    b->last_in_chain = 1;
+
+    b->file->fd = of.fd;
+    b->file->name = *filename;
+    b->file->log = log;
+    #if NGINX_VERSION_NUM >= 7000
+        b->file->directio = of.is_directio;
+    #endif
+
+    out.buf = b;
+    out.next = NULL;
+
+    return ngx_http_output_filter(r, &out);
+}

data/ext/nginx/StaticContentHandler.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
+ * Copyright (C) 2010 Phusion
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _PASSENGER_NGINX_STATIC_CONTENT_HANDLER_H_
+#define _PASSENGER_NGINX_STATIC_CONTENT_HANDLER_H_
+
+#include <ngx_core.h>
+#include <ngx_http.h>
+
+ngx_int_t passenger_static_content_handler(ngx_http_request_t *r,
+                                           ngx_str_t *filename);
+
+#endif /* _PASSENGER_NGINX_STATIC_CONTENT_HANDLER_H_ */

data/ext/nginx/config

@@ -0,0 +1,56 @@
+if ! test -f "$ngx_addon_dir/../common/libpassenger_common.a" || \
+   ! test -f "$ngx_addon_dir/../common/libboost_oxt.a"; then
+    echo "*** The Phusion Passenger support files are not yet compiled. Compiling them for you... ***"
+    echo "*** Running 'rake nginx RELEASE=yes' in $ngx_addon_dir... ***"
+    if ! cd $ngx_addon_dir; then
+        exit 1
+    fi
+    if ! rake nginx RELEASE=yes; then
+        exit 1
+    fi
+    echo "*** Phusion Passenger support files have been successfully compiled. ***"
+fi
+
+ngx_feature="Math library"
+ngx_feature_name=
+ngx_feature_run=no
+ngx_feature_incs="#include <math.h>"
+ngx_feature_path=
+ngx_feature_libs="-lm"
+ngx_feature_test="pow(1, 2)"
+. auto/feature
+if [ $ngx_found = yes ]; then
+    CORE_LIBS="$CORE_LIBS -lm"
+fi
+
+ngx_addon_name=ngx_http_passenger_module
+HTTP_MODULES="$HTTP_MODULES ngx_http_passenger_module"
+NGX_ADDON_SRCS="$NGX_ADDON_SRCS \
+    ${ngx_addon_dir}/ngx_http_passenger_module.c \
+    ${ngx_addon_dir}/Configuration.c \
+    ${ngx_addon_dir}/ContentHandler.c \
+    ${ngx_addon_dir}/StaticContentHandler.c"
+NGX_ADDON_DEPS="$NGX_ADDON_DEPS \
+    ${ngx_addon_dir}/Configuration.h \
+    ${ngx_addon_dir}/ContentHandler.h \
+    ${ngx_addon_dir}/StaticContentHandler.h \
+    ${ngx_addon_dir}/ngx_http_passenger_module.h \
+    ${ngx_addon_dir}/../common/Constants.h"
+CORE_LIBS="$CORE_LIBS  \
+    ${ngx_addon_dir}/../common/libpassenger_common.a \
+    ${ngx_addon_dir}/../common/libboost_oxt.a \
+    -lstdc++ -lpthread"
+
+nginx_version=`grep 'NGINX_VERSION ' src/core/nginx.h | awk '{ print $3 }' | sed 's/"//g'`
+
+nginx_major_version=`echo "$nginx_version" | cut -d . -f 1`
+have=PASSENGER_NGINX_MAJOR_VERSION value="$nginx_major_version"
+. auto/define
+
+nginx_minor_version=`echo "$nginx_version" | cut -d . -f 2`
+have=PASSENGER_NGINX_MINOR_VERSION value="$nginx_minor_version"
+. auto/define
+
+nginx_micro_version=`echo "$nginx_version" | cut -d . -f 3`
+have=PASSENGER_NGINX_MICRO_VERSION value="$nginx_micro_version"
+. auto/define

data/ext/nginx/ngx_http_passenger_module.c

@@ -0,0 +1,499 @@
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
+ * Copyright (C) 2010 Phusion
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+#include <nginx.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+
+#include "ngx_http_passenger_module.h"
+#include "Configuration.h"
+#include "ContentHandler.h"
+
+
+#define HELPER_SERVER_MAX_SHUTDOWN_TIME 5
+#define HELPER_SERVER_PASSWORD_SIZE     64
+
+
+static int      first_start = 1;
+ngx_str_t       passenger_schema_string;
+ngx_str_t       passenger_placeholder_upstream_address;
+CachedFileStat *passenger_stat_cache;
+AgentsStarter  *passenger_agents_starter = NULL;
+ngx_cycle_t    *passenger_current_cycle;
+
+
+/*
+    HISTORIC NOTE:
+    We used to register passenger_content_handler as a default content handler,
+    instead of setting ngx_http_core_loc_conf_t->handler. However, if
+    ngx_http_read_client_request_body (and thus passenger_content_handler)
+    returns NGX_AGAIN, then Nginx will pass the not-fully-receive file upload
+    data to the upstream handler even though it shouldn't. Is this an Nginx
+    bug? In any case, setting ngx_http_core_loc_conf_t->handler fixed the
+    problem.
+    
+static ngx_int_t
+register_content_handler(ngx_conf_t *cf)
+{
+    ngx_http_handler_pt        *h;
+    ngx_http_core_main_conf_t  *cmcf;
+
+    cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
+
+    h = ngx_array_push(&cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers);
+    if (h == NULL) {
+        return NGX_ERROR;
+    }
+    *h = passenger_content_handler;
+    
+    return NGX_OK;
+}
+*/
+
+static void
+ignore_sigpipe()
+{
+    struct sigaction action;
+    
+    action.sa_handler = SIG_IGN;
+    action.sa_flags   = 0;
+    sigemptyset(&action.sa_mask);
+    sigaction(SIGPIPE, &action, NULL);
+}
+
+char *
+ngx_str_null_terminate(ngx_str_t *str) {
+    char *result = malloc(str->len + 1);
+    memcpy(result, str->data, str->len);
+    result[str->len] = '\0';
+    return result;
+}
+
+/**
+ * Save the Nginx master process's PID into a file under the server instance directory.
+ *
+ * A bug/limitation in Nginx doesn't allow us to create the server instance dir
+ * *after* Nginx has daemonized, so the server instance dir's filename contains Nginx's
+ * PID before daemonization. Normally PhusionPassenger::AdminTools::ServerInstance (used
+ * by e.g. passenger-status) will think that the server instance dir is stale because the
+ * PID in the filename doesn't exist. This PID file tells AdminTools::ServerInstance
+ * what the actual PID is.
+ */
+static ngx_int_t
+save_master_process_pid(ngx_cycle_t *cycle) {
+    u_char filename[NGX_MAX_PATH];
+    u_char *last;
+    FILE *f;
+    
+    last = ngx_snprintf(filename, sizeof(filename) - 1, "%s/control_process.pid",
+        agents_starter_get_server_instance_dir(passenger_agents_starter));
+    *last = (u_char) '\0';
+    
+    f = fopen((const char *) filename, "w");
+    if (f != NULL) {
+        fprintf(f, "%ld", (long) getppid());
+        fclose(f);
+    } else {
+        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                      "could not create %s", filename);
+    }
+    
+    return NGX_OK;
+}
+
+/**
+ * This function is called after forking and just before exec()ing the helper server.
+ */
+static void
+starting_helper_server_after_fork(void *arg) {
+    ngx_cycle_t *cycle = (void *) arg;
+    char        *log_filename;
+    FILE        *log_file;
+    
+    /* At this point, stdout and stderr may still point to the console.
+     * Make sure that they're both redirected to the log file.
+     */
+    log_file = NULL;
+    if (cycle->new_log.file->name.len > 0) {
+        log_filename = ngx_str_null_terminate(&cycle->new_log.file->name);
+        log_file = fopen((const char *) log_filename, "a");
+        if (log_file == NULL) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                          "could not open the error log file for writing");
+        }
+        free(log_filename);
+    } else if (cycle->log != NULL && cycle->log->file->name.len > 0) {
+        log_filename = ngx_str_null_terminate(&cycle->log->file->name);
+        log_file = fopen((const char *) log_filename, "a");
+        if (log_file == NULL) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+                          "could not open the error log file for writing");
+        }
+        free(log_filename);
+    }
+    if (log_file == NULL) {
+        /* If the log file cannot be opened then we redirect stdout
+         * and stderr to /dev/null, because if the user disconnects
+         * from the console on which Nginx is started, then on Linux
+         * any writes to stdout or stderr will result in an EIO error.
+         */
+        log_file = fopen("/dev/null", "w");
+    }
+    if (log_file != NULL) {
+        dup2(fileno(log_file), 1);
+        dup2(fileno(log_file), 2);
+        fclose(log_file);
+    }
+    
+    /* Set SERVER_SOFTWARE so that application processes know what web
+     * server they're running on during startup. */
+    setenv("SERVER_SOFTWARE", NGINX_VER, 1);
+}
+
+static ngx_int_t
+create_file(ngx_cycle_t *cycle, const u_char *filename, const u_char *contents, size_t len) {
+    FILE  *f;
+    int    ret;
+    size_t total_written = 0, written;
+
+    f = fopen((const char *) filename, "w");
+    if (f != NULL) {
+        /* We must do something with these return values because
+         * otherwise on some platforms it will cause a compiler
+         * warning.
+         */
+        do {
+            ret = fchmod(fileno(f), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+        } while (ret == -1 && errno == EINTR);
+        do {
+            written = fwrite(contents + total_written, 1,
+                len - total_written, f);
+            total_written += written;
+        } while (total_written < len);
+        fclose(f);
+        return NGX_OK;
+    } else {
+        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
+            "could not create %s", filename);
+            return NGX_ERROR;
+    }
+}
+
+/**
+ * Start the helper server and save its runtime information into various variables.
+ *
+ * @pre The helper server isn't already started.
+ * @pre The Nginx configuration has been loaded.
+ */
+static ngx_int_t
+start_helper_server(ngx_cycle_t *cycle) {
+    ngx_core_conf_t *core_conf;
+    ngx_int_t        ret, result;
+    ngx_uint_t       i;
+    ngx_str_t       *prestart_uris;
+    char           **prestart_uris_ary = NULL;
+    u_char  filename[NGX_MAX_PATH], *last;
+    char   *debug_log_file = NULL;
+    char   *default_user = NULL;
+    char   *default_group = NULL;
+    char   *passenger_root = NULL;
+    char   *ruby = NULL;
+    char   *analytics_log_dir;
+    char   *analytics_log_user;
+    char   *analytics_log_group;
+    char   *analytics_log_permissions;
+    char   *union_station_gateway_address;
+    char   *union_station_gateway_cert;
+    char   *error_message = NULL;
+    
+    core_conf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
+    result    = NGX_OK;
+    
+    /* Create null-terminated versions of some strings. */
+    debug_log_file = ngx_str_null_terminate(&passenger_main_conf.debug_log_file);
+    default_user   = ngx_str_null_terminate(&passenger_main_conf.default_user);
+    default_group  = ngx_str_null_terminate(&passenger_main_conf.default_group);
+    passenger_root = ngx_str_null_terminate(&passenger_main_conf.root_dir);
+    ruby           = ngx_str_null_terminate(&passenger_main_conf.ruby);
+    analytics_log_dir = ngx_str_null_terminate(&passenger_main_conf.analytics_log_dir);
+    analytics_log_user = ngx_str_null_terminate(&passenger_main_conf.analytics_log_user);
+    analytics_log_group = ngx_str_null_terminate(&passenger_main_conf.analytics_log_group);
+    analytics_log_permissions = ngx_str_null_terminate(&passenger_main_conf.analytics_log_permissions);
+    union_station_gateway_address = ngx_str_null_terminate(&passenger_main_conf.union_station_gateway_address);
+    union_station_gateway_cert = ngx_str_null_terminate(&passenger_main_conf.union_station_gateway_cert);
+    
+    prestart_uris = (ngx_str_t *) passenger_main_conf.prestart_uris->elts;
+    prestart_uris_ary = calloc(sizeof(char *), passenger_main_conf.prestart_uris->nelts);
+    for (i = 0; i < passenger_main_conf.prestart_uris->nelts; i++) {
+        prestart_uris_ary[i] = malloc(prestart_uris[i].len + 1);
+        if (prestart_uris_ary[i] == NULL) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ENOMEM, "Cannot allocate memory");
+            result = NGX_ERROR;
+            goto cleanup;
+        }
+        memcpy(prestart_uris_ary[i], prestart_uris[i].data, prestart_uris[i].len);
+        prestart_uris_ary[i][prestart_uris[i].len] = '\0';
+    }
+    
+    ret = agents_starter_start(passenger_agents_starter,
+        passenger_main_conf.log_level, debug_log_file, getpid(),
+        "", passenger_main_conf.user_switching,
+        default_user, default_group,
+        core_conf->user, core_conf->group,
+        passenger_root, ruby, passenger_main_conf.max_pool_size,
+        passenger_main_conf.max_instances_per_app,
+        passenger_main_conf.pool_idle_time,
+        "",
+        analytics_log_dir, analytics_log_user,
+        analytics_log_group, analytics_log_permissions,
+        union_station_gateway_address,
+        passenger_main_conf.union_station_gateway_port,
+        union_station_gateway_cert,
+        (const char **) prestart_uris_ary, passenger_main_conf.prestart_uris->nelts,
+        starting_helper_server_after_fork,
+        cycle,
+        &error_message);
+    if (!ret) {
+        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "%s", error_message);
+        result = NGX_ERROR;
+        goto cleanup;
+    }
+    
+    /* Create the file passenger_temp_dir + "/control_process.pid"
+     * and make it writable by the worker processes. This is because
+     * save_master_process_pid is run after Nginx has lowered privileges.
+     */
+    last = ngx_snprintf(filename, sizeof(filename) - 1,
+                        "%s/control_process.pid",
+                        agents_starter_get_server_instance_dir(passenger_agents_starter));
+    *last = (u_char) '\0';
+    if (create_file(cycle, filename, (const u_char *) "", 0) != NGX_OK) {
+        result = NGX_ERROR;
+        goto cleanup;
+    }
+    do {
+        ret = chown((const char *) filename, (uid_t) core_conf->user, (gid_t) -1);
+    } while (ret == -1 && errno == EINTR);
+    if (ret == -1) {
+        result = NGX_ERROR;
+        goto cleanup;
+    }
+
+    /* Create various other info files. */
+    last = ngx_snprintf(filename, sizeof(filename) - 1,
+                        "%s/web_server.txt",
+                        agents_starter_get_generation_dir(passenger_agents_starter));
+    *last = (u_char) '\0';
+    if (create_file(cycle, filename, (const u_char *) NGINX_VER, strlen(NGINX_VER)) != NGX_OK) {
+        result = NGX_ERROR;
+        goto cleanup;
+    }
+
+    last = ngx_snprintf(filename, sizeof(filename) - 1,
+                        "%s/config_files.txt",
+                        agents_starter_get_generation_dir(passenger_agents_starter));
+    *last = (u_char) '\0';
+    if (create_file(cycle, filename, cycle->conf_file.data, cycle->conf_file.len) != NGX_OK) {
+        result = NGX_ERROR;
+        goto cleanup;
+    }
+    
+    last = ngx_snprintf(filename, sizeof(filename) - 1,
+                        "%s/analytics_log_dir.txt",
+                        agents_starter_get_generation_dir(passenger_agents_starter));
+    *last = (u_char) '\0';
+    if (create_file(cycle, filename, passenger_main_conf.analytics_log_dir.data,
+                    passenger_main_conf.analytics_log_dir.len) != NGX_OK) {
+        result = NGX_ERROR;
+        goto cleanup;
+    }
+
+cleanup:
+    free(debug_log_file);
+    free(default_user);
+    free(default_group);
+    free(passenger_root);
+    free(ruby);
+    free(analytics_log_dir);
+    free(analytics_log_user);
+    free(analytics_log_group);
+    free(analytics_log_permissions);
+    free(union_station_gateway_address);
+    free(union_station_gateway_cert);
+    free(error_message);
+    if (prestart_uris_ary != NULL) {
+        for (i = 0; i < passenger_main_conf.prestart_uris->nelts; i++) {
+            free(prestart_uris_ary[i]);
+        }
+        free(prestart_uris_ary);
+    }
+    
+    if (result == NGX_ERROR && passenger_main_conf.abort_on_startup_error) {
+        exit(1);
+    }
+    
+    return result;
+}
+
+/**
+ * Shutdown the helper server, if there's one running.
+ */
+static void
+shutdown_helper_server() {
+    if (passenger_agents_starter != NULL) {
+        agents_starter_free(passenger_agents_starter);
+        passenger_agents_starter = NULL;
+    }
+}
+
+
+/**
+ * Called when:
+ * - Nginx is started, before the configuration is loaded and before daemonization.
+ * - Nginx is restarted, before the configuration is reloaded.
+ */
+static ngx_int_t
+pre_config_init(ngx_conf_t *cf)
+{
+    char *error_message;
+    
+    shutdown_helper_server();
+    
+    ngx_memzero(&passenger_main_conf, sizeof(passenger_main_conf_t));
+    passenger_schema_string.data = (u_char *) "passenger:";
+    passenger_schema_string.len  = sizeof("passenger:") - 1;
+    passenger_placeholder_upstream_address.data = (u_char *) "unix:/passenger_helper_server";
+    passenger_placeholder_upstream_address.len  = sizeof("unix:/passenger_helper_server") - 1;
+    passenger_stat_cache = cached_file_stat_new(1024);
+    passenger_agents_starter = agents_starter_new(AS_NGINX, &error_message);
+    
+    if (passenger_agents_starter == NULL) {
+        ngx_log_error(NGX_LOG_ALERT, cf->log, ngx_errno, "%s", error_message);
+        free(error_message);
+        return NGX_ERROR;
+    }
+    
+    return NGX_OK;
+}
+
+/**
+ * Called when:
+ * - Nginx is started, before daemonization and after the configuration has loaded.
+ * - Nginx is restarted, after the configuration has reloaded.
+ */
+static ngx_int_t
+init_module(ngx_cycle_t *cycle) {
+    if (passenger_main_conf.root_dir.len != 0) {
+        if (first_start) {
+            /* Ignore SIGPIPE now so that, if the helper server fails to start,
+             * Nginx doesn't get killed by the default SIGPIPE handler upon
+             * writing the password to the helper server.
+             */
+            ignore_sigpipe();
+            first_start = 0;
+        }
+        if (start_helper_server(cycle) != NGX_OK) {
+            passenger_main_conf.root_dir.len = 0;
+            return NGX_OK;
+        }
+        passenger_current_cycle = cycle;
+    }
+    return NGX_OK;
+}
+
+/**
+ * Called when an Nginx worker process is started. This happens after init_module
+ * is called.
+ *
+ * If 'master_process' is turned off, then there is only one single Nginx process
+ * in total, and this process also acts as the worker process. In this case
+ * init_worker_process is only called when Nginx is started, but not when it's restarted.
+ */
+static ngx_int_t
+init_worker_process(ngx_cycle_t *cycle) {
+    ngx_core_conf_t *core_conf;
+    
+    if (passenger_main_conf.root_dir.len != 0) {
+        save_master_process_pid(cycle);
+        
+        core_conf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
+        if (core_conf->master) {
+            agents_starter_detach(passenger_agents_starter);
+        }
+    }
+    return NGX_OK;
+}
+
+/**
+ * Called when Nginx exits. Not called when Nginx is restarted.
+ */
+static void
+exit_master(ngx_cycle_t *cycle) {
+    shutdown_helper_server();
+}
+
+
+static ngx_http_module_t passenger_module_ctx = {
+    pre_config_init,                     /* preconfiguration */
+    /* register_content_handler */ NULL, /* postconfiguration */
+
+    passenger_create_main_conf,          /* create main configuration */
+    passenger_init_main_conf,            /* init main configuration */
+
+    NULL,                                /* create server configuration */
+    NULL,                                /* merge server configuration */
+
+    passenger_create_loc_conf,           /* create location configuration */
+    passenger_merge_loc_conf             /* merge location configuration */
+};
+
+
+ngx_module_t ngx_http_passenger_module = {
+    NGX_MODULE_V1,
+    &passenger_module_ctx,                  /* module context */
+    (ngx_command_t *) passenger_commands,   /* module directives */
+    NGX_HTTP_MODULE,                        /* module type */
+    NULL,                                   /* init master */
+    init_module,                            /* init module */
+    init_worker_process,                    /* init process */
+    NULL,                                   /* init thread */
+    NULL,                                   /* exit thread */
+    NULL,                                   /* exit process */
+    exit_master,                            /* exit master */
+    NGX_MODULE_V1_PADDING
+};