passenger 5.3.4 → 6.0.1

data/src/nginx_module/ContentHandler.c

@@ -1,7 +1,7 @@
 /*
  * Copyright (C) Igor Sysoev
  * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
- * Copyright (c) 2010-2017 Phusion Holding B.V.
+ * Copyright (c) 2010-2018 Phusion Holding B.V.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -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)
@@ -326,6 +331,179 @@ header_is_transfer_encoding(ngx_str_t *key)
         ngx_strncasecmp(key->data + 1, (u_char *) "ransfer-encodin", sizeof("ransfer-encodin") - 1) == 0;
 }
 
+/* Given an ngx_chain_t head and tail position, appends a new chain element at the end,
+ * updates the head (if necessary) and returns the new element.
+ *
+ *  - The element is allocated from a freelist.
+ *  - Ensures that the element contains a buffer of at least `size` bytes.
+ *  - Sets the given tag on the buffer in the chain element.
+ *
+ * On error, returns NULL without modifying the given chain.
+ */
+static ngx_chain_t *
+append_ngx_chain_element(ngx_pool_t *p, ngx_chain_t **head,
+    ngx_chain_t *tail, ngx_chain_t **freelist, ngx_buf_tag_t tag, size_t size)
+{
+    ngx_chain_t *elem;
+    ngx_buf_t *buf;
+
+    elem = ngx_chain_get_free_buf(p, freelist);
+    if (elem == NULL) {
+        return NULL;
+    }
+
+    buf = elem->buf;
+    buf->tag = tag;
+
+    if (size > 0 && (buf->pos == NULL || buf->last == NULL
+        || (size_t) ngx_buf_size(buf) < size))
+    {
+        ngx_memzero(buf, sizeof(ngx_buf_t));
+
+        buf->start = ngx_palloc(p, size);
+        if (buf->start == NULL) {
+            return NULL;
+        }
+
+        /*
+         * set by ngx_memzero():
+         *
+         *     b->file_pos = 0;
+         *     b->file_last = 0;
+         *     b->file = NULL;
+         *     b->shadow = NULL;
+         *     b->tag = 0;
+         *     and flags
+         */
+
+        buf->pos = buf->start;
+        buf->last = buf->start;
+        buf->end = buf->last + size;
+        buf->temporary = 1;
+    }
+
+    if (*head == NULL) {
+        *head = elem;
+    } else {
+        tail->next = elem;
+    }
+    return elem;
+}
+
+/* Given a chain of buffers containing client body data,
+ * this filter wraps all that data into chunked encoding
+ * headers and footers.
+ */
+static ngx_int_t
+body_rechunk_output_filter(void *data, ngx_chain_t *input)
+{
+    ngx_http_request_t *r = data;
+    ngx_chain_t *output_head = NULL, *output_tail = NULL;
+    ngx_int_t body_eof_reached = 0;
+    ngx_int_t rc;
+    passenger_context_t *ctx;
+
+    ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
+                   PROGRAM_NAME " rechunk output filter");
+
+    ctx = ngx_http_get_module_ctx(r, ngx_http_passenger_module);
+
+    if (input == NULL) {
+        goto out;
+    }
+
+    if (!ctx->header_sent) {
+        /* The first buffer contains the request header, so pass it unmodified. */
+        ctx->header_sent = 1;
+
+        while (input != NULL) {
+            output_tail = append_ngx_chain_element(r->pool,
+                &output_head, output_tail, &ctx->free,
+                (ngx_buf_tag_t) &body_rechunk_output_filter,
+                0);
+            if (output_tail == NULL) {
+                return NGX_ERROR;
+            }
+
+            ngx_memcpy(output_tail->buf, input->buf, sizeof(ngx_buf_t));
+
+            body_eof_reached = input->buf->last_buf;
+            input = input->next;
+        }
+    } else {
+        while (input != NULL) {
+            /* Append chunked encoding size header */
+            output_tail = append_ngx_chain_element(r->pool,
+                &output_head, output_tail, &ctx->free,
+                (ngx_buf_tag_t) &body_rechunk_output_filter,
+                32);
+            if (output_tail == NULL) {
+                return NGX_ERROR;
+            }
+
+            output_tail->buf->last = ngx_sprintf(output_tail->buf->last, "%xO\r\n",
+                ngx_buf_size(input->buf));
+
+
+            /* Append chunked encoding payload */
+            output_tail = append_ngx_chain_element(r->pool,
+                &output_head, output_tail, &ctx->free,
+                (ngx_buf_tag_t) &body_rechunk_output_filter,
+                0);
+            if (output_tail == NULL) {
+                return NGX_ERROR;
+            }
+
+            ngx_memcpy(output_tail->buf, input->buf, sizeof(ngx_buf_t));
+
+
+            /* Append chunked encoding footer */
+            output_tail = append_ngx_chain_element(r->pool,
+                &output_head, output_tail, &ctx->free,
+                (ngx_buf_tag_t) &body_rechunk_output_filter,
+                2);
+            if (output_tail == NULL) {
+                return NGX_ERROR;
+            }
+
+            output_tail->buf->last = ngx_copy(output_tail->buf->last, "\r\n", 2);
+
+
+            body_eof_reached = input->buf->last_buf;
+            input = input->next;
+        }
+    }
+
+    if (body_eof_reached) {
+        /* Append final termination chunk. */
+        output_tail = append_ngx_chain_element(r->pool,
+                &output_head, output_tail, &ctx->free,
+                (ngx_buf_tag_t) &body_rechunk_output_filter,
+                5);
+        if (output_tail == NULL) {
+            return NGX_ERROR;
+        }
+
+        output_tail->buf->last = ngx_copy(output_tail->buf->last,
+            "0\r\n\r\n", 5);
+    }
+
+out:
+
+    rc = ngx_chain_writer(&r->upstream->writer, output_head);
+
+    /*
+     * The previous ngx_chain_writer() call consumed some buffers.
+     * Find such consumped (empty) buffers in the output buffer list,
+     * and either free them or add them to the freelist depending on
+     * whether the buffer's tag matches ours.
+     */
+    ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &output_head,
+        (ngx_buf_tag_t) &body_rechunk_output_filter);
+
+    return rc;
+}
+
 #define SET_NGX_STR(str, the_data) \
     do { \
         (str)->data = (u_char *) the_data; \
@@ -341,15 +519,25 @@ header_is_transfer_encoding(ngx_str_t *key)
 typedef struct {
     ngx_str_t     method; /* Includes trailing space */
     ngx_str_t     app_type;
+    ngx_str_t     app_start_command;
     ngx_str_t     escaped_uri;
-    ngx_str_t     content_length;
+    ngx_str_t     content_length; /* Only used if !r->request_body_no_buffering */
     ngx_str_t     core_password;
     ngx_str_t     remote_port;
 } buffer_construction_state;
 
+/* prepare_request_buffer_construction() and construct_request_buffer() are
+ * used to create an HTTP request header buffer to be sent to the Core Controller.
+ *
+ * construct_request_buffer() is actually called twice: the first time in "no-op" mode to
+ * calculate how many bytes it must allocate, and the second time to actually create the
+ * buffer. For efficiency reasons, as much preparation work as possible is split into
+ * the prepare_request_buffer_construction() function so that the two construct_request_buffer()
+ * calls don't have to perform that work twice.
+ */
 static ngx_int_t
-prepare_request_buffer_construction(ngx_http_request_t *r, passenger_context_t *context,
-    buffer_construction_state *state)
+prepare_request_buffer_construction(ngx_http_request_t *r, passenger_loc_conf_t *slcf,
+    passenger_context_t *context, buffer_construction_state *state)
 {
     unsigned int          len;
     ngx_uint_t            port;
@@ -357,7 +545,9 @@ 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;
 
+    /* Construct HTTP method string, including trailing space. */
     switch (r->method) {
     case NGX_HTTP_GET:
         SET_NGX_STR(&state->method, "GET ");
@@ -409,9 +599,28 @@ 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);
+    if (slcf->autogenerated.app_start_command.data != NULL) {
+        /* The config specified that this is either a generic app or a Kuria app. */
+        state->app_type.data = NULL;
+        state->app_type.len = 0;
+        state->app_start_command = slcf->autogenerated.app_start_command;
+    } else {
+        wrapper_registry_entry = psg_app_type_detector_result_get_wrapper_registry_entry(
+            context->detector_result);
+        if (wrapper_registry_entry != NULL) {
+            /* This is an auto-supported app. */
+            state->app_type.data = (u_char *) psg_wrapper_registry_entry_get_language(wrapper_registry_entry,
+                &state->app_type.len);
+            state->app_start_command.data = NULL;
+            state->app_start_command.len = 0;
+        } else {
+            /* This has been autodetected to be a generic app or a Kuria app. */
+            state->app_type.data = NULL;
+            state->app_type.len = 0;
+            state->app_start_command.data = (u_char *) psg_app_type_detector_result_get_app_start_command(
+                context->detector_result, &state->app_start_command.len);
+        }
+    }
 
     /*
      * Nginx unescapes URI's before passing them to Phusion Passenger,
@@ -439,7 +648,7 @@ prepare_request_buffer_construction(ngx_http_request_t *r, passenger_context_t *
             NGX_ESCAPE_URI);
     }
 
-    if (r->headers_in.chunked) {
+    if (r->headers_in.chunked && !r->request_body_no_buffering) {
         /* If the request body is chunked, then Nginx sets r->headers_in.content_length_n
          * but does not set r->headers_in.headers, so we add this header ourselves.
          */
@@ -488,6 +697,7 @@ prepare_request_buffer_construction(ngx_http_request_t *r, passenger_context_t *
     return NGX_OK;
 }
 
+/* See comment for prepare_request_buffer_construction() */
 static ngx_uint_t
 construct_request_buffer(ngx_http_request_t *r, passenger_loc_conf_t *slcf,
     passenger_context_t *context, buffer_construction_state *state, ngx_buf_t *b)
@@ -547,7 +757,7 @@ construct_request_buffer(ngx_http_request_t *r, passenger_loc_conf_t *slcf,
 
         if (ngx_hash_find(&slcf->headers_set_hash, header[i].hash,
                           header[i].lowcase_key, header[i].key.len)
-         || header_is_transfer_encoding(&header[i].key))
+         || (!r->request_body_no_buffering && header_is_transfer_encoding(&header[i].key)))
         {
             continue;
         }
@@ -561,7 +771,7 @@ construct_request_buffer(ngx_http_request_t *r, passenger_loc_conf_t *slcf,
         total_size += header[i].key.len + header[i].value.len + 4;
     }
 
-    if (r->headers_in.chunked) {
+    if (r->headers_in.chunked && !r->request_body_no_buffering) {
         PUSH_STATIC_STR("Content-Length: ");
         if (b != NULL) {
             b->last = ngx_copy(b->last, state->content_length.data,
@@ -749,13 +959,23 @@ construct_request_buffer(ngx_http_request_t *r, passenger_loc_conf_t *slcf,
         PUSH_STATIC_STR("\r\n");
     }
 
-    PUSH_STATIC_STR("!~PASSENGER_APP_TYPE: ");
-    if (b != NULL) {
-        b->last = ngx_copy(b->last, state->app_type.data,
-            state->app_type.len);
+    if (state->app_type.len > 0) {
+        PUSH_STATIC_STR("!~PASSENGER_APP_TYPE: ");
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, state->app_type.data,
+                state->app_type.len);
+        }
+        total_size += state->app_type.len;
+        PUSH_STATIC_STR("\r\n");
+    } else {
+        PUSH_STATIC_STR("!~PASSENGER_APP_START_COMMAND: ");
+        if (b != NULL) {
+            b->last = ngx_copy(b->last, state->app_start_command.data,
+                state->app_start_command.len);
+        }
+        total_size += state->app_start_command.len;
+        PUSH_STATIC_STR("\r\n");
     }
-    total_size += state->app_type.len;
-    PUSH_STATIC_STR("\r\n");
 
     if (b != NULL) {
         b->last = ngx_copy(b->last, slcf->options_cache.data, slcf->options_cache.len);
@@ -809,7 +1029,7 @@ create_request(ngx_http_request_t *r)
 
     /* Construct and pass request headers */
 
-    if (prepare_request_buffer_construction(r, context, &state) != NGX_OK) {
+    if (prepare_request_buffer_construction(r, slcf, context, &state) != NGX_OK) {
         return NGX_ERROR;
     }
     request_size = construct_request_buffer(r, slcf, context, &state, NULL);
@@ -818,20 +1038,45 @@ create_request(ngx_http_request_t *r)
     if (b == NULL) {
         return NGX_ERROR;
     }
+    construct_request_buffer(r, slcf, context, &state, b);
+
     cl = ngx_alloc_chain_link(r->pool);
     if (cl == NULL) {
         return NGX_ERROR;
     }
     cl->buf = b;
 
-    construct_request_buffer(r, slcf, context, &state, b);
 
-    /* Pass request body */
+    /* Pass already received request body buffers. Make sure they come
+     * after the request header buffer we just constructed.
+     */
 
     body = r->upstream->request_bufs;
     r->upstream->request_bufs = cl;
 
     while (body) {
+        if (r->headers_in.chunked && r->request_body_no_buffering) {
+            /* If Transfer-Encoding is chunked, then Nginx dechunks the body.
+             * If at the same time request body buffering is disabled, then
+             * we pass the Transfer-Encoding header to the Passenger Core,
+             * and thus we also need to ensure we rechunk the body.
+             */
+            b = ngx_create_temp_buf(r->pool, 32);
+            if (b == NULL) {
+                return NGX_ERROR;
+            }
+
+            b->last = ngx_sprintf(b->last, "%xO\r\n",
+                ngx_buf_size(body->buf));
+            cl->next = ngx_alloc_chain_link(r->pool);
+            if (cl->next == NULL) {
+                return NGX_ERROR;
+            }
+
+            cl = cl->next;
+            cl->buf = b;
+        }
+
         b = ngx_alloc_buf(r->pool);
         if (b == NULL) {
             return NGX_ERROR;
@@ -843,15 +1088,41 @@ create_request(ngx_http_request_t *r)
         if (cl->next == NULL) {
             return NGX_ERROR;
         }
-
         cl = cl->next;
         cl->buf = b;
 
         body = body->next;
+
+        if (r->headers_in.chunked && r->request_body_no_buffering) {
+            b = ngx_create_temp_buf(r->pool, 2);
+            if (b == NULL) {
+                return NGX_ERROR;
+            }
+
+            b->last = ngx_copy(b->last, "\r\n", 2);
+            cl->next = ngx_alloc_chain_link(r->pool);
+            if (cl->next == NULL) {
+                return NGX_ERROR;
+            }
+
+            cl = cl->next;
+            cl->buf = b;
+        }
     }
+
     b->flush = 1;
     cl->next = NULL;
 
+    /* Again, if Transfer-Encoding is chunked, then Nginx dechunks the body.
+     * Here we install an output filter to make sure that the request body parts
+     * that will be received in the future, will also be rechunked when passed
+     * to the Passenger Core.
+     */
+    if (r->headers_in.chunked && r->request_body_no_buffering) {
+        r->upstream->output.output_filter = body_rechunk_output_filter;
+        r->upstream->output.filter_ctx = r;
+    }
+
     return NGX_OK;
 }
 
@@ -1362,7 +1633,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 +1724,39 @@ passenger_content_handler(ngx_http_request_t *r)
         return passenger_static_content_handler(r, &page_cache_file);
     }
 
-    if (slcf->autogenerated.app_type.data == NULL) {
+    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 `app_start_command` is set, then it means the config specified that it is
+     * either a generic app or a Kuria app.
+     */
+    if (slcf->autogenerated.app_start_command.data == NULL
+     && slcf->autogenerated.app_type.data == NULL)
+    {
+        /* If neither `app_start_command` nor `app_type` are set, then
+         * autodetect what kind of app this is.
+         */
         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. "
@@ -1485,11 +1774,19 @@ passenger_content_handler(ngx_http_request_t *r)
             pp_error_destroy(&error);
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
         }
-    } else {
-        context->app_type = pp_get_app_type2((const char *) slcf->autogenerated.app_type.data,
+    } else if (slcf->autogenerated.app_start_command.data == NULL) {
+        /* If `app_start_command` is not set but `app_type` is, then
+         * verify whether the given `app_type` value is supported
+         * and resolve aliases.
+         */
+        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);
         }
     }
 
@@ -1526,6 +1823,8 @@ passenger_content_handler(ngx_http_request_t *r)
     u->pipe->input_filter = ngx_event_pipe_copy_input_filter;
     u->pipe->input_ctx = r;
 
+    r->request_body_no_buffering = !slcf->upstream_config.request_buffering;
+
     rc = ngx_http_read_client_request_body(r, ngx_http_upstream_init);
 
     fix_peer_address(r);

data/src/nginx_module/ContentHandler.h

@@ -30,7 +30,7 @@
 
 #include <ngx_core.h>
 #include <ngx_http.h>
-#include "cxx_supportlib/AppTypes.h"
+#include "cxx_supportlib/AppTypeDetector/CBindings.h"
 
 
 typedef struct {
@@ -40,14 +40,19 @@ typedef struct {
     u_char     *status_start;
     u_char     *status_end;
 
+    /* body_rechunk_output_filter state. */
+    ngx_chain_t *free;
+    ngx_chain_t *busy;
+    unsigned header_sent: 1;
+
     /** The application's 'public' directory. */
     ngx_str_t   public_dir;
 
     /** The application's base URI. Points to an empty string if none. */
     ngx_str_t   base_uri;
 
-    /** The application's type. */
-    PassengerAppType app_type;
+    /** Detected information about the app. */
+    PsgAppTypeDetectorResult *detector_result;
 } passenger_context_t;
 
 

data/src/nginx_module/LocationConfig/AutoGeneratedCreateFunction.c

@@ -75,6 +75,8 @@ passenger_create_autogenerated_loc_conf(passenger_autogenerated_loc_conf_t  *con
     conf->app_type.len  = 0;
     conf->startup_file.data = NULL;
     conf->startup_file.len  = 0;
+    conf->app_start_command.data = NULL;
+    conf->app_start_command.len  = 0;
     conf->restart_dir.data = NULL;
     conf->restart_dir.len  = 0;
     conf->abort_websockets_on_process_shutdown = NGX_CONF_UNSET;
@@ -183,6 +185,10 @@ passenger_create_autogenerated_loc_conf(passenger_autogenerated_loc_conf_t  *con
     conf->startup_file_source_file.len = 0;
     conf->startup_file_source_line = 0;
     conf->startup_file_explicitly_set = 0;
+    conf->app_start_command_source_file.data = NULL;
+    conf->app_start_command_source_file.len = 0;
+    conf->app_start_command_source_line = 0;
+    conf->app_start_command_explicitly_set = 0;
     conf->restart_dir_source_file.data = NULL;
     conf->restart_dir_source_file.len = 0;
     conf->restart_dir_source_line = 0;
@@ -255,6 +261,10 @@ passenger_create_autogenerated_loc_conf(passenger_autogenerated_loc_conf_t  *con
     conf->upstream_config_busy_buffers_size_conf_source_file.len = 0;
     conf->upstream_config_busy_buffers_size_conf_source_line = 0;
     conf->upstream_config_busy_buffers_size_conf_explicitly_set = 0;
+    conf->upstream_config_request_buffering_source_file.data = NULL;
+    conf->upstream_config_request_buffering_source_file.len = 0;
+    conf->upstream_config_request_buffering_source_line = 0;
+    conf->upstream_config_request_buffering_explicitly_set = 0;
     conf->upstream_config_intercept_errors_source_file.data = NULL;
     conf->upstream_config_intercept_errors_source_file.len = 0;
     conf->upstream_config_intercept_errors_source_line = 0;

data/src/nginx_module/LocationConfig/AutoGeneratedManifestGeneration.c

@@ -345,6 +345,20 @@ generate_config_manifest_for_autogenerated_loc_conf(manifest_gen_ctx_t *ctx, pas
             (const char *) plcf->autogenerated.startup_file.data,
             plcf->autogenerated.startup_file.len);
     }
+    if (plcf->autogenerated.app_start_command_explicitly_set) {
+        find_or_create_manifest_app_and_loc_options_containers(ctx,
+            plcf, cscf, clcf, &app_options_container, &loc_options_container);
+        option_container = find_or_create_manifest_option_container(ctx,
+            app_options_container,
+            "passenger_app_start_command",
+            sizeof("passenger_app_start_command") - 1);
+        hierarchy_member = add_manifest_option_container_hierarchy_member(option_container,
+            &plcf->autogenerated.app_start_command_source_file,
+            plcf->autogenerated.app_start_command_source_line);
+        psg_json_value_set_str(hierarchy_member, "value",
+            (const char *) plcf->autogenerated.app_start_command.data,
+            plcf->autogenerated.app_start_command.len);
+    }
     if (plcf->autogenerated.restart_dir_explicitly_set) {
         find_or_create_manifest_app_and_loc_options_containers(ctx,
             plcf, cscf, clcf, &app_options_container, &loc_options_container);
@@ -529,6 +543,19 @@ generate_config_manifest_for_autogenerated_loc_conf(manifest_gen_ctx_t *ctx, pas
         psg_json_value_set_bool(hierarchy_member, "value",
             plcf->upstream_config.buffering);
     }
+    if (plcf->autogenerated.upstream_config_request_buffering_explicitly_set) {
+        find_or_create_manifest_app_and_loc_options_containers(ctx,
+            plcf, cscf, clcf, &app_options_container, &loc_options_container);
+        option_container = find_or_create_manifest_option_container(ctx,
+            loc_options_container,
+            "passenger_request_buffering",
+            sizeof("passenger_request_buffering") - 1);
+        hierarchy_member = add_manifest_option_container_hierarchy_member(option_container,
+            &plcf->autogenerated.upstream_config_request_buffering_source_file,
+            plcf->autogenerated.upstream_config_request_buffering_source_line);
+        psg_json_value_set_bool(hierarchy_member, "value",
+            plcf->upstream_config.request_buffering);
+    }
     if (plcf->autogenerated.upstream_config_intercept_errors_explicitly_set) {
         find_or_create_manifest_app_and_loc_options_containers(ctx,
             plcf, cscf, clcf, &app_options_container, &loc_options_container);

data/src/nginx_module/LocationConfig/AutoGeneratedMergeFunction.c

@@ -113,6 +113,9 @@ passenger_merge_autogenerated_loc_conf(passenger_autogenerated_loc_conf_t *conf,
     ngx_conf_merge_str_value(conf->startup_file,
         prev->startup_file,
         NULL);
+    ngx_conf_merge_str_value(conf->app_start_command,
+        prev->app_start_command,
+        NULL);
     ngx_conf_merge_str_value(conf->restart_dir,
         prev->restart_dir,
         "tmp");