text: /*
   * Copyright (C) Igor Sysoev
   * Copyright (C) 2007 Manlio Perillo (manlio.perillo@gmail.com)
   * Copyright (c) 2010-2017 Phusion Holding B.V.
   *
   * 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 <ngx_http.h>
  
  #include <sys/types.h>
  #include <pwd.h>
  #include <stdlib.h>
  #include <assert.h>
  
  #include "ngx_http_passenger_module.h"
  #include "Configuration.h"
  #include "ContentHandler.h"
  #include "ConfigGeneral/AutoGeneratedManifestDefaultsInitialization.c"
  #include "ConfigGeneral/AutoGeneratedSetterFuncs.c"
  #include "ConfigGeneral/ManifestGeneration.c"
  #include "MainConfig/AutoGeneratedCreateFunction.c"
  #include "MainConfig/AutoGeneratedManifestGeneration.c"
  #include "LocationConfig/AutoGeneratedCreateFunction.c"
  #include "LocationConfig/AutoGeneratedManifestGeneration.c"
  #include "cxx_supportlib/Constants.h"
  #include "cxx_supportlib/vendor-modified/modp_b64.h"
  
  
  static ngx_str_t headers_to_hide[] = {
      /* NOTE: Do not hide the "Status" header; some broken HTTP clients
       * expect this header. http://code.google.com/p/phusion-passenger/issues/detail?id=177
       */
      ngx_string("X-Accel-Expires"),
      ngx_string("X-Accel-Redirect"),
      ngx_string("X-Accel-Limit-Rate"),
      ngx_string("X-Accel-Buffering"),
      ngx_null_string
  };
  
  passenger_main_conf_t passenger_main_conf;
  
  static ngx_path_init_t  ngx_http_proxy_temp_path = {
      ngx_string(NGX_HTTP_PROXY_TEMP_PATH), { 1, 2, 0 }
  };
  
  
  static ngx_int_t merge_headers(ngx_conf_t *cf, passenger_loc_conf_t *conf,
      passenger_loc_conf_t *prev);
  static ngx_int_t merge_string_array(ngx_conf_t *cf, ngx_array_t **prev,
      ngx_array_t **conf);
  static ngx_int_t merge_string_keyval_table(ngx_conf_t *cf, ngx_array_t **prev,
      ngx_array_t **conf);
  
  
  #include "LocationConfig/AutoGeneratedMergeFunction.c"
  #include "LocationConfig/AutoGeneratedHeaderSerialization.c"
  
  
  void *
  passenger_create_main_conf(ngx_conf_t *cf)
  {
      passenger_main_conf_t *conf;
  
      conf = ngx_pcalloc(cf->pool, sizeof(passenger_main_conf_t));
      if (conf == NULL) {
          return NGX_CONF_ERROR;
      }
  
      conf->default_ruby.data = NULL;
      conf->default_ruby.len = 0;
  
      passenger_create_autogenerated_main_conf(&conf->autogenerated);
  
      return conf;
  }
  
  char *
  passenger_init_main_conf(ngx_conf_t *cf, void *conf_pointer)
  {
      passenger_main_conf_t *conf;
      struct passwd         *user_entry;
      struct group          *group_entry;
      char buf[128];
  
      conf = &passenger_main_conf;
      *conf = *((passenger_main_conf_t *) conf_pointer);
  
      if (conf->autogenerated.abort_on_startup_error == NGX_CONF_UNSET) {
          conf->autogenerated.abort_on_startup_error = 0;
      }
  
      if (conf->autogenerated.show_version_in_header == NGX_CONF_UNSET) {
          conf->autogenerated.show_version_in_header = 1;
      }
  
      if (conf->autogenerated.default_user.len == 0) {
          conf->autogenerated.default_user.len  = sizeof(DEFAULT_WEB_APP_USER) - 1;
          conf->autogenerated.default_user.data = (u_char *) DEFAULT_WEB_APP_USER;
      }
      if (conf->autogenerated.default_user.len > sizeof(buf) - 1) {
          return "Value for 'passenger_default_user' is too long.";
      }
      memcpy(buf, conf->autogenerated.default_user.data, conf->autogenerated.default_user.len);
      buf[conf->autogenerated.default_user.len] = '\0';
      user_entry = getpwnam(buf);
      if (user_entry == NULL) {
          return "The user specified by the 'passenger_default_user' option does not exist.";
      }
  
      if (conf->autogenerated.default_group.len > 0) {
          if (conf->autogenerated.default_group.len > sizeof(buf) - 1) {
              return "Value for 'passenger_default_group' is too long.";
          }
          memcpy(buf, conf->autogenerated.default_group.data, conf->autogenerated.default_group.len);
          buf[conf->autogenerated.default_group.len] = '\0';
          group_entry = getgrnam(buf);
          if (group_entry == NULL) {
              return "The group specified by the 'passenger_default_group' option does not exist.";
          }
      }
  
      return NGX_CONF_OK;
  }
  
  void *
  passenger_create_loc_conf(ngx_conf_t *cf)
  {
      passenger_loc_conf_t  *conf;
  
      conf = ngx_pcalloc(cf->pool, sizeof(passenger_loc_conf_t));
      if (conf == NULL) {
          return NGX_CONF_ERROR;
      }
  
      /*
       * set by ngx_pcalloc():
       *
       *     conf->upstream_config.bufs.num = 0;
       *     conf->upstream_config.next_upstream = 0;
       *     conf->upstream_config.temp_path = NULL;
       *     conf->upstream_config.hide_headers_hash = { NULL, 0 };
       *     conf->upstream_config.hide_headers = NULL;
       *     conf->upstream_config.pass_headers = NULL;
       *     conf->upstream_config.uri = { 0, NULL };
       *     conf->upstream_config.location = NULL;
       *     conf->upstream_config.store_lengths = NULL;
       *     conf->upstream_config.store_values = NULL;
       */
  
      conf->parent = NULL;
      if (ngx_array_init(&conf->children, cf->pool, 8,
                         sizeof(passenger_loc_conf_t *))
          != NGX_OK)
      {
          return NGX_CONF_ERROR;
      }
  
      if (cf->conf_file == NULL) {
          conf->context_source_file.data = (u_char *) NULL;
          conf->context_source_file.len = 0;
          conf->context_source_line = 0;
      } else if (cf->conf_file->file.fd == NGX_INVALID_FILE) {
          conf->context_source_file.data = (u_char *) "(command line)";
          conf->context_source_file.len = sizeof("(command line)") - 1;
          conf->context_source_line = 0;
      } else {
          conf->context_source_file = cf->conf_file->file.name;
          conf->context_source_line = cf->conf_file->line;
      }
  
      conf->cscf = NULL;
      conf->clcf = NULL;
  
      passenger_create_autogenerated_loc_conf(&conf->autogenerated);
  
      /******************************/
      /******************************/
  
      conf->upstream_config.pass_headers = NGX_CONF_UNSET_PTR;
      conf->upstream_config.hide_headers = NGX_CONF_UNSET_PTR;
  
      conf->upstream_config.store = NGX_CONF_UNSET;
      conf->upstream_config.store_access = NGX_CONF_UNSET_UINT;
      #if NGINX_VERSION_NUM >= 1007005
          conf->upstream_config.next_upstream_tries = NGX_CONF_UNSET_UINT;
      #endif
      conf->upstream_config.buffering = NGX_CONF_UNSET;
      conf->upstream_config.request_buffering = NGX_CONF_UNSET;
      conf->upstream_config.ignore_client_abort = NGX_CONF_UNSET;
      #if NGINX_VERSION_NUM >= 1007007
          conf->upstream_config.force_ranges = NGX_CONF_UNSET;
      #endif
  
      conf->upstream_config.local = NGX_CONF_UNSET_PTR;
  
      conf->upstream_config.connect_timeout = NGX_CONF_UNSET_MSEC;
      conf->upstream_config.send_timeout = NGX_CONF_UNSET_MSEC;
      conf->upstream_config.read_timeout = NGX_CONF_UNSET_MSEC;
      #if NGINX_VERSION_NUM >= 1007005
          conf->upstream_config.next_upstream_timeout = NGX_CONF_UNSET_MSEC;
      #endif
  
      conf->upstream_config.send_lowat = NGX_CONF_UNSET_SIZE;
      conf->upstream_config.buffer_size = NGX_CONF_UNSET_SIZE;
      #if NGINX_VERSION_NUM >= 1007007
          conf->upstream_config.limit_rate = NGX_CONF_UNSET_SIZE;
      #endif
  
      conf->upstream_config.busy_buffers_size_conf = NGX_CONF_UNSET_SIZE;
      conf->upstream_config.max_temp_file_size_conf = NGX_CONF_UNSET_SIZE;
      conf->upstream_config.temp_file_write_size_conf = NGX_CONF_UNSET_SIZE;
  
      conf->upstream_config.pass_request_headers = NGX_CONF_UNSET;
      conf->upstream_config.pass_request_body = NGX_CONF_UNSET;
  
  #if (NGX_HTTP_CACHE)
      #if NGINX_VERSION_NUM >= 1007009
          conf->upstream_config.cache = NGX_CONF_UNSET;
      #else
          conf->upstream_config.cache = NGX_CONF_UNSET_PTR;
      #endif
      conf->upstream_config.cache_min_uses = NGX_CONF_UNSET_UINT;
      conf->upstream_config.cache_bypass = NGX_CONF_UNSET_PTR;
      conf->upstream_config.no_cache = NGX_CONF_UNSET_PTR;
      conf->upstream_config.cache_valid = NGX_CONF_UNSET_PTR;
      conf->upstream_config.cache_lock = NGX_CONF_UNSET;
      conf->upstream_config.cache_lock_timeout = NGX_CONF_UNSET_MSEC;
      #if NGINX_VERSION_NUM >= 1007008
          conf->upstream_config.cache_lock_age = NGX_CONF_UNSET_MSEC;
      #endif
      #if NGINX_VERSION_NUM >= 1006000
          conf->upstream_config.cache_revalidate = NGX_CONF_UNSET;
      #endif
  #endif
  
      conf->upstream_config.intercept_errors = NGX_CONF_UNSET;
  
      conf->upstream_config.cyclic_temp_file = 0;
      conf->upstream_config.change_buffering = 1;
  
      ngx_str_set(&conf->upstream_config.module, "passenger");
  
      conf->options_cache.data  = NULL;
      conf->options_cache.len   = 0;
      conf->env_vars_cache.data = NULL;
      conf->env_vars_cache.len  = 0;
  
      return conf;
  }
  
  static ngx_int_t
  serialize_loc_conf_to_headers(ngx_conf_t *cf, passenger_loc_conf_t *conf)
  {
      ngx_uint_t     i;
      ngx_keyval_t  *env_vars;
      size_t         unencoded_len;
      u_char        *unencoded_buf;
  
      if (passenger_serialize_autogenerated_loc_conf_to_headers(cf, conf) == 0) {
          return NGX_ERROR;
      }
  
      if (conf->autogenerated.env_vars != NULL) {
          size_t len = 0;
          u_char *buf;
          u_char *pos;
  
          /* Cache env vars data as base64-serialized string.
           * First, calculate the length of the unencoded data.
           */
  
          unencoded_len = 0;
          env_vars = (ngx_keyval_t *) conf->autogenerated.env_vars->elts;
  
          for (i = 0; i < conf->autogenerated.env_vars->nelts; i++) {
              unencoded_len += env_vars[i].key.len + 1 + env_vars[i].value.len + 1;
          }
  
          /* Create the unecoded data. */
  
          unencoded_buf = pos = (u_char *) malloc(unencoded_len);
          if (unencoded_buf == NULL) {
              ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                 "cannot allocate buffer of %z bytes for environment variables data",
                                 unencoded_len);
              return NGX_ERROR;
          }
  
          for (i = 0; i < conf->autogenerated.env_vars->nelts; i++) {
              pos = ngx_copy(pos, env_vars[i].key.data, env_vars[i].key.len);
              *pos = '\0';
              pos++;
  
              pos = ngx_copy(pos, env_vars[i].value.data, env_vars[i].value.len);
              *pos = '\0';
              pos++;
          }
  
          assert((size_t) (pos - unencoded_buf) == unencoded_len);
  
          /* Create base64-serialized string. */
  
          buf = ngx_palloc(cf->pool, modp_b64_encode_len(unencoded_len));
          if (buf == NULL) {
              ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                 "cannot allocate buffer of %z bytes for base64 encoding",
                                 modp_b64_encode_len(unencoded_len));
              return NGX_ERROR;
          }
          len = modp_b64_encode((char *) buf, (const char *) unencoded_buf, unencoded_len);
          if (len == (size_t) -1) {
              ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                 "error during base64 encoding");
              free(unencoded_buf);
              return NGX_ERROR;
          }
  
          conf->env_vars_cache.data = buf;
          conf->env_vars_cache.len = len;
          free(unencoded_buf);
      }
  
      return NGX_OK;
  }
  
  char *
  passenger_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  {
      passenger_loc_conf_t         *prev = parent;
      passenger_loc_conf_t         *conf = child;
      passenger_loc_conf_t         **children_elem;
      ngx_http_core_loc_conf_t     *clcf;
  
      size_t                        size;
      ngx_hash_init_t               hash;
  
      clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
      /* The following works for all contexts within the http{} block, but does
       * not work for the http{} block itself. To obtain the ngx_http_core_(loc|srv)_conf_t
       * associated with the http{} block itself, we also set conf->(cscf|clcf)
       * from record_loc_conf_source_location(), which is called from the various
       * configuration setter functions.
       */
       conf->cscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_core_module);
       conf->clcf = clcf;
  
      if (passenger_merge_autogenerated_loc_conf(&conf->autogenerated, &prev->autogenerated, cf) == 0) {
          return NGX_CONF_ERROR;
      }
  
      conf->parent = prev;
      children_elem = ngx_array_push(&prev->children);
      if (children_elem == NULL) {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, ngx_errno,
              "cannot allocate memory");
          return NGX_CONF_ERROR;
      }
      *children_elem = conf;
  
      if (prev->options_cache.data == NULL) {
          if (serialize_loc_conf_to_headers(cf, prev) != NGX_OK) {
              ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                 "cannot create " PROGRAM_NAME " configuration serialization cache");
              return NGX_CONF_ERROR;
          }
      }
  
      /******************************/
      /******************************/
  
      #if (NGX_HTTP_CACHE) && NGINX_VERSION_NUM >= 1007009
          if (conf->upstream_config.store > 0) {
              conf->upstream_config.cache = 0;
          }
          if (conf->upstream_config.cache > 0) {
              conf->upstream_config.store = 0;
          }
      #endif
  
      #if NGINX_VERSION_NUM >= 1007009
          if (conf->upstream_config.store == NGX_CONF_UNSET) {
              ngx_conf_merge_value(conf->upstream_config.store,
                                        prev->upstream_config.store, 0);
  
              conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
              conf->upstream_config.store_values = prev->upstream_config.store_values;
          }
      #else
          if (conf->upstream_config.store != 0) {
              ngx_conf_merge_value(conf->upstream_config.store,
                                        prev->upstream_config.store, 0);
  
              if (conf->upstream_config.store_lengths == NULL) {
                  conf->upstream_config.store_lengths = prev->upstream_config.store_lengths;
                  conf->upstream_config.store_values = prev->upstream_config.store_values;
              }
          }
      #endif
  
      ngx_conf_merge_uint_value(conf->upstream_config.store_access,
                                prev->upstream_config.store_access, 0600);
  
      #if NGINX_VERSION_NUM >= 1007005
          ngx_conf_merge_uint_value(conf->upstream_config.next_upstream_tries,
                                    prev->upstream_config.next_upstream_tries, 0);
      #endif
  
      ngx_conf_merge_value(conf->upstream_config.buffering,
                           prev->upstream_config.buffering, 0);
  
      ngx_conf_merge_value(conf->upstream_config.request_buffering,
                           prev->upstream_config.request_buffering, 1);
  
      ngx_conf_merge_value(conf->upstream_config.ignore_client_abort,
                           prev->upstream_config.ignore_client_abort, 0);
  
      #if NGINX_VERSION_NUM >= 1007007
          ngx_conf_merge_value(conf->upstream_config.force_ranges,
                               prev->upstream_config.force_ranges, 0);
      #endif
  
      ngx_conf_merge_ptr_value(conf->upstream_config.local,
                               prev->upstream_config.local, NULL);
  
      ngx_conf_merge_msec_value(conf->upstream_config.connect_timeout,
                                prev->upstream_config.connect_timeout, 12000000);
  
      ngx_conf_merge_msec_value(conf->upstream_config.send_timeout,
                                prev->upstream_config.send_timeout, 12000000);
  
      ngx_conf_merge_msec_value(conf->upstream_config.read_timeout,
                                prev->upstream_config.read_timeout, 12000000);
  
      #if NGINX_VERSION_NUM >= 1007005
          ngx_conf_merge_msec_value(conf->upstream_config.next_upstream_timeout,
                                    prev->upstream_config.next_upstream_timeout, 0);
      #endif
  
      ngx_conf_merge_size_value(conf->upstream_config.send_lowat,
                                prev->upstream_config.send_lowat, 0);
  
      ngx_conf_merge_size_value(conf->upstream_config.buffer_size,
                                prev->upstream_config.buffer_size,
                                16 * 1024);
  
      #if NGINX_VERSION_NUM >= 1007007
          ngx_conf_merge_size_value(conf->upstream_config.limit_rate,
                                    prev->upstream_config.limit_rate, 0);
      #endif
  
  
      ngx_conf_merge_bufs_value(conf->upstream_config.bufs, prev->upstream_config.bufs,
                                8, 16 * 1024);
  
      if (conf->upstream_config.bufs.num < 2) {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                             "there must be at least 2 \"passenger_buffers\"");
          return NGX_CONF_ERROR;
      }
  
  
      size = conf->upstream_config.buffer_size;
      if (size < conf->upstream_config.bufs.size) {
          size = conf->upstream_config.bufs.size;
      }
  
  
      ngx_conf_merge_size_value(conf->upstream_config.busy_buffers_size_conf,
                                prev->upstream_config.busy_buffers_size_conf,
                                NGX_CONF_UNSET_SIZE);
  
      if (conf->upstream_config.busy_buffers_size_conf == NGX_CONF_UNSET_SIZE) {
          conf->upstream_config.busy_buffers_size = 2 * size;
      } else {
          conf->upstream_config.busy_buffers_size =
                                           conf->upstream_config.busy_buffers_size_conf;
      }
  
      if (conf->upstream_config.busy_buffers_size < size) {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
               "\"passenger_busy_buffers_size\" must be equal to or greater "
               "than the maximum of the value of \"passenger_buffer_size\" and "
               "one of the \"passenger_buffers\"");
  
          return NGX_CONF_ERROR;
      }
  
      if (conf->upstream_config.busy_buffers_size
          > (conf->upstream_config.bufs.num - 1) * conf->upstream_config.bufs.size)
      {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
               "\"passenger_busy_buffers_size\" must be less than "
               "the size of all \"passenger_buffers\" minus one buffer");
  
          return NGX_CONF_ERROR;
      }
  
  
      ngx_conf_merge_size_value(conf->upstream_config.temp_file_write_size_conf,
                                prev->upstream_config.temp_file_write_size_conf,
                                NGX_CONF_UNSET_SIZE);
  
      if (conf->upstream_config.temp_file_write_size_conf == NGX_CONF_UNSET_SIZE) {
          conf->upstream_config.temp_file_write_size = 2 * size;
      } else {
          conf->upstream_config.temp_file_write_size =
                                        conf->upstream_config.temp_file_write_size_conf;
      }
  
      if (conf->upstream_config.temp_file_write_size < size) {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
               "\"passenger_temp_file_write_size\" must be equal to or greater than "
               "the maximum of the value of \"passenger_buffer_size\" and "
               "one of the \"passenger_buffers\"");
  
          return NGX_CONF_ERROR;
      }
  
  
      ngx_conf_merge_size_value(conf->upstream_config.max_temp_file_size_conf,
                                prev->upstream_config.max_temp_file_size_conf,
                                NGX_CONF_UNSET_SIZE);
  
      if (conf->upstream_config.max_temp_file_size_conf == NGX_CONF_UNSET_SIZE) {
          conf->upstream_config.max_temp_file_size = 1024 * 1024 * 1024;
      } else {
          conf->upstream_config.max_temp_file_size =
                                          conf->upstream_config.max_temp_file_size_conf;
      }
  
      if (conf->upstream_config.max_temp_file_size != 0
          && conf->upstream_config.max_temp_file_size < size)
      {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
               "\"passenger_max_temp_file_size\" must be equal to zero to disable "
               "temporary files usage or must be equal to or greater than "
               "the maximum of the value of \"passenger_buffer_size\" and "
               "one of the \"passenger_buffers\"");
  
          return NGX_CONF_ERROR;
      }
  
      ngx_conf_merge_bitmask_value(conf->upstream_config.ignore_headers,
                                   prev->upstream_config.ignore_headers,
                                   NGX_CONF_BITMASK_SET);
  
      ngx_conf_merge_bitmask_value(conf->upstream_config.next_upstream,
                                prev->upstream_config.next_upstream,
                                (NGX_CONF_BITMASK_SET
                                 |NGX_HTTP_UPSTREAM_FT_ERROR
                                 |NGX_HTTP_UPSTREAM_FT_TIMEOUT));
  
      if (conf->upstream_config.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
          conf->upstream_config.next_upstream = NGX_CONF_BITMASK_SET
                                         |NGX_HTTP_UPSTREAM_FT_OFF;
      }
  
      if (ngx_conf_merge_path_value(cf,
                                &conf->upstream_config.temp_path,
                                prev->upstream_config.temp_path,
                                &ngx_http_proxy_temp_path)
          != NGX_OK)
      {
          return NGX_CONF_ERROR;
      }
  
  #if (NGX_HTTP_CACHE)
  
      #if NGINX_VERSION_NUM >= 1007009
          if (conf->upstream_config.cache == NGX_CONF_UNSET) {
             ngx_conf_merge_value(conf->upstream_config.cache,
                                  prev->upstream_config.cache, 0);
  
             conf->upstream_config.cache_zone = prev->upstream_config.cache_zone;
             conf->upstream_config.cache_value = prev->upstream_config.cache_value;
          }
  
          if (conf->upstream_config.cache_zone && conf->upstream_config.cache_zone->data == NULL) {
              ngx_shm_zone_t  *shm_zone;
  
              shm_zone = conf->upstream_config.cache_zone;
  
              ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                 "\"scgi_cache\" zone \"%V\" is unknown",
                                 &shm_zone->shm.name);
  
              return NGX_CONF_ERROR;
          }
      #else
          ngx_conf_merge_ptr_value(conf->upstream_config.cache,
                                   prev->upstream_config.cache, NULL);
  
          if (conf->upstream_config.cache && conf->upstream_config.cache->data == NULL) {
              ngx_shm_zone_t  *shm_zone;
  
              shm_zone = conf->upstream_config.cache;
  
              ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                                 "\"scgi_cache\" zone \"%V\" is unknown",
                                 &shm_zone->shm.name);
  
              return NGX_CONF_ERROR;
          }
      #endif
  
      ngx_conf_merge_uint_value(conf->upstream_config.cache_min_uses,
                                prev->upstream_config.cache_min_uses, 1);
  
      ngx_conf_merge_bitmask_value(conf->upstream_config.cache_use_stale,
                                prev->upstream_config.cache_use_stale,
                                (NGX_CONF_BITMASK_SET
                                 | NGX_HTTP_UPSTREAM_FT_OFF));
  
      if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_OFF) {
          conf->upstream_config.cache_use_stale = NGX_CONF_BITMASK_SET
                                                  | NGX_HTTP_UPSTREAM_FT_OFF;
      }
  
      if (conf->upstream_config.cache_use_stale & NGX_HTTP_UPSTREAM_FT_ERROR) {
          conf->upstream_config.cache_use_stale |= NGX_HTTP_UPSTREAM_FT_NOLIVE;
      }
  
      if (conf->upstream_config.cache_methods == 0) {
          conf->upstream_config.cache_methods = prev->upstream_config.cache_methods;
      }
  
      conf->upstream_config.cache_methods |= NGX_HTTP_GET | NGX_HTTP_HEAD;
  
      ngx_conf_merge_ptr_value(conf->upstream_config.cache_bypass,
                               prev->upstream_config.cache_bypass, NULL);
  
      ngx_conf_merge_ptr_value(conf->upstream_config.no_cache,
                               prev->upstream_config.no_cache, NULL);
  
      ngx_conf_merge_ptr_value(conf->upstream_config.cache_valid,
                               prev->upstream_config.cache_valid, NULL);
  
      if (conf->cache_key.value.data == NULL) {
          conf->cache_key = prev->cache_key;
      }
  
      ngx_conf_merge_value(conf->upstream_config.cache_lock,
                           prev->upstream_config.cache_lock, 0);
  
      ngx_conf_merge_msec_value(conf->upstream_config.cache_lock_timeout,
                                prev->upstream_config.cache_lock_timeout, 5000);
  
      ngx_conf_merge_value(conf->upstream_config.cache_revalidate,
                           prev->upstream_config.cache_revalidate, 0);
  
      #if NGINX_VERSION_NUM >= 1007008
          ngx_conf_merge_msec_value(conf->upstream_config.cache_lock_age,
                                    prev->upstream_config.cache_lock_age, 5000);
      #endif
  
      #if NGINX_VERSION_NUM >= 1006000
          ngx_conf_merge_value(conf->upstream_config.cache_revalidate,
                               prev->upstream_config.cache_revalidate, 0);
      #endif
  
  #endif
  
      ngx_conf_merge_value(conf->upstream_config.pass_request_headers,
                           prev->upstream_config.pass_request_headers, 1);
      ngx_conf_merge_value(conf->upstream_config.pass_request_body,
                           prev->upstream_config.pass_request_body, 1);
  
      ngx_conf_merge_value(conf->upstream_config.intercept_errors,
                           prev->upstream_config.intercept_errors, 0);
  
  
      hash.max_size = 512;
      hash.bucket_size = ngx_align(64, ngx_cacheline_size);
      hash.name = "passenger_hide_headers_hash";
  
      if (ngx_http_upstream_hide_headers_hash(cf, &conf->upstream_config,
              &prev->upstream_config, headers_to_hide, &hash)
          != NGX_OK)
      {
          return NGX_CONF_ERROR;
      }
  
      if (conf->upstream_config.upstream == NULL) {
          conf->upstream_config.upstream = prev->upstream_config.upstream;
      }
  
      if (conf->autogenerated.enabled == 1 /* and not NGX_CONF_UNSET */
       && passenger_main_conf.autogenerated.root_dir.len != 0
       && clcf->handler == NULL /* no handler set by other modules */)
      {
          clcf->handler = passenger_content_handler;
      }
  
      conf->autogenerated.headers_hash_bucket_size = ngx_align(
          conf->autogenerated.headers_hash_bucket_size,
          ngx_cacheline_size);
      hash.max_size = conf->autogenerated.headers_hash_max_size;
      hash.bucket_size = conf->autogenerated.headers_hash_bucket_size;
      hash.name = "passenger_headers_hash";
  
      if (merge_headers(cf, conf, prev) != NGX_OK) {
          return NGX_CONF_ERROR;
      }
  
      if (serialize_loc_conf_to_headers(cf, conf) != NGX_OK) {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
                             "cannot create " PROGRAM_NAME " configuration serialization cache");
          return NGX_CONF_ERROR;
      }
  
      return NGX_CONF_OK;
  }
  
  static ngx_int_t
  merge_headers(ngx_conf_t *cf, passenger_loc_conf_t *conf, passenger_loc_conf_t *prev)
  {
      u_char                       *p;
      size_t                        size;
      uintptr_t                    *code;
      ngx_uint_t                    i;
      ngx_array_t                   headers_names, headers_merged;
      ngx_keyval_t                 *src, *s;
      ngx_hash_key_t               *hk;
      ngx_hash_init_t               hash;
      ngx_http_script_compile_t     sc;
      ngx_http_script_copy_code_t  *copy;
  
      if (conf->autogenerated.headers_source == NULL) {
          conf->flushes = prev->flushes;
          conf->headers_set_len = prev->headers_set_len;
          conf->headers_set = prev->headers_set;
          conf->headers_set_hash = prev->headers_set_hash;
          conf->autogenerated.headers_source = prev->autogenerated.headers_source;
      }
  
      if (conf->headers_set_hash.buckets
  #if (NGX_HTTP_CACHE)
      #if NGINX_VERSION_NUM >= 1007009
          && ((conf->upstream_config.cache == NGX_CONF_UNSET) == (prev->upstream_config.cache == NGX_CONF_UNSET))
      #else
          && ((conf->upstream_config.cache == NGX_CONF_UNSET_PTR) == (prev->upstream_config.cache == NGX_CONF_UNSET_PTR))
      #endif
  #endif
         )
      {
          return NGX_OK;
      }
  
  
      if (ngx_array_init(&headers_names, cf->temp_pool, 4, sizeof(ngx_hash_key_t))
          != NGX_OK)
      {
          return NGX_ERROR;
      }
  
      if (ngx_array_init(&headers_merged, cf->temp_pool, 4, sizeof(ngx_keyval_t))
          != NGX_OK)
      {
          return NGX_ERROR;
      }
  
      if (conf->autogenerated.headers_source == NULL) {
          conf->autogenerated.headers_source = ngx_array_create(cf->pool, 4,
                                                  sizeof(ngx_keyval_t));
          if (conf->autogenerated.headers_source == NULL) {
              return NGX_ERROR;
          }
      }
  
      conf->headers_set_len = ngx_array_create(cf->pool, 64, 1);
      if (conf->headers_set_len == NULL) {
          return NGX_ERROR;
      }
  
      conf->headers_set = ngx_array_create(cf->pool, 512, 1);
      if (conf->headers_set == NULL) {
          return NGX_ERROR;
      }
  
  
      src = conf->autogenerated.headers_source->elts;
      for (i = 0; i < conf->autogenerated.headers_source->nelts; i++) {
  
          s = ngx_array_push(&headers_merged);
          if (s == NULL) {
              return NGX_ERROR;
          }
  
          *s = src[i];
      }
  
  
      src = headers_merged.elts;
      for (i = 0; i < headers_merged.nelts; i++) {
  
          hk = ngx_array_push(&headers_names);
          if (hk == NULL) {
              return NGX_ERROR;
          }
  
          hk->key = src[i].key;
          hk->key_hash = ngx_hash_key_lc(src[i].key.data, src[i].key.len);
          hk->value = (void *) 1;
  
          if (src[i].value.len == 0) {
              continue;
          }
  
          if (ngx_http_script_variables_count(&src[i].value) == 0) {
              copy = ngx_array_push_n(conf->headers_set_len,
                                      sizeof(ngx_http_script_copy_code_t));
              if (copy == NULL) {
                  return NGX_ERROR;
              }
  
              copy->code = (ngx_http_script_code_pt) (void *)
                                                   ngx_http_script_copy_len_code;
              copy->len = src[i].key.len + sizeof(": ") - 1
                          + src[i].value.len + sizeof(CRLF) - 1;
  
  
              size = (sizeof(ngx_http_script_copy_code_t)
                         + src[i].key.len + sizeof(": ") - 1
                         + src[i].value.len + sizeof(CRLF) - 1
                         + sizeof(uintptr_t) - 1)
                      & ~(sizeof(uintptr_t) - 1);
  
              copy = ngx_array_push_n(conf->headers_set, size);
              if (copy == NULL) {
                  return NGX_ERROR;
              }
  
              copy->code = ngx_http_script_copy_code;
              copy->len = src[i].key.len + sizeof(": ") - 1
                          + src[i].value.len + sizeof(CRLF) - 1;
  
              p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
  
              p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
              *p++ = ':'; *p++ = ' ';
              p = ngx_cpymem(p, src[i].value.data, src[i].value.len);
              *p++ = CR; *p = LF;
  
          } else {
              copy = ngx_array_push_n(conf->headers_set_len,
                                      sizeof(ngx_http_script_copy_code_t));
              if (copy == NULL) {
                  return NGX_ERROR;
              }
  
              copy->code = (ngx_http_script_code_pt) (void *)
                                                   ngx_http_script_copy_len_code;
              copy->len = src[i].key.len + sizeof(": ") - 1;
  
  
              size = (sizeof(ngx_http_script_copy_code_t)
                      + src[i].key.len + sizeof(": ") - 1 + sizeof(uintptr_t) - 1)
                      & ~(sizeof(uintptr_t) - 1);
  
              copy = ngx_array_push_n(conf->headers_set, size);
              if (copy == NULL) {
                  return NGX_ERROR;
              }
  
              copy->code = ngx_http_script_copy_code;
              copy->len = src[i].key.len + sizeof(": ") - 1;
  
              p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
              p = ngx_cpymem(p, src[i].key.data, src[i].key.len);
              *p++ = ':'; *p = ' ';
  
  
              ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));
  
              sc.cf = cf;
              sc.source = &src[i].value;
              sc.flushes = &conf->flushes;
              sc.lengths = &conf->headers_set_len;
              sc.values = &conf->headers_set;
  
              if (ngx_http_script_compile(&sc) != NGX_OK) {
                  return NGX_ERROR;
              }
  
  
              copy = ngx_array_push_n(conf->headers_set_len,
                                      sizeof(ngx_http_script_copy_code_t));
              if (copy == NULL) {
                  return NGX_ERROR;
              }
  
              copy->code = (ngx_http_script_code_pt) (void *)
                                                   ngx_http_script_copy_len_code;
              copy->len = sizeof(CRLF) - 1;
  
  
              size = (sizeof(ngx_http_script_copy_code_t)
                      + sizeof(CRLF) - 1 + sizeof(uintptr_t) - 1)
                      & ~(sizeof(uintptr_t) - 1);
  
              copy = ngx_array_push_n(conf->headers_set, size);
              if (copy == NULL) {
                  return NGX_ERROR;
              }
  
              copy->code = ngx_http_script_copy_code;
              copy->len = sizeof(CRLF) - 1;
  
              p = (u_char *) copy + sizeof(ngx_http_script_copy_code_t);
              *p++ = CR; *p = LF;
          }
  
          code = ngx_array_push_n(conf->headers_set_len, sizeof(uintptr_t));
          if (code == NULL) {
              return NGX_ERROR;
          }
  
          *code = (uintptr_t) NULL;
  
          code = ngx_array_push_n(conf->headers_set, sizeof(uintptr_t));
          if (code == NULL) {
              return NGX_ERROR;
          }
  
          *code = (uintptr_t) NULL;
      }
  
      code = ngx_array_push_n(conf->headers_set_len, sizeof(uintptr_t));
      if (code == NULL) {
          return NGX_ERROR;
      }
  
      *code = (uintptr_t) NULL;
  
  
      hash.hash = &conf->headers_set_hash;
      hash.key = ngx_hash_key_lc;
      hash.max_size = conf->autogenerated.headers_hash_max_size;
      hash.bucket_size = conf->autogenerated.headers_hash_bucket_size;
      hash.name = "passenger_headers_hash";
      hash.pool = cf->pool;
      hash.temp_pool = NULL;
  
      return ngx_hash_init(&hash, headers_names.elts, headers_names.nelts);
  }
  
  static ngx_int_t
  merge_string_array(ngx_conf_t *cf, ngx_array_t **prev, ngx_array_t **conf)
  {
      ngx_str_t  *prev_elems, *elem;
      ngx_uint_t  i;
  
      if (*prev != NGX_CONF_UNSET_PTR) {
          if (*conf == NGX_CONF_UNSET_PTR) {
              *conf = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
              if (*conf == NULL) {
                  return NGX_ERROR;
              }
          }
  
          prev_elems = (ngx_str_t *) (*prev)->elts;
          for (i = 0; i < (*prev)->nelts; i++) {
              elem = (ngx_str_t *) ngx_array_push(*conf);
              if (elem == NULL) {
                  return NGX_ERROR;
              }
              *elem = prev_elems[i];
          }
      }
  
      return NGX_OK;
  }
  
  ngx_int_t
  passenger_postprocess_config(ngx_conf_t *cf)
  {
      ngx_http_conf_ctx_t  *http_ctx;
      passenger_loc_conf_t *toplevel_plcf;
      ngx_pool_cleanup_t   *manifest_cleanup;
      char                 *dump_path, *dump_content;
      FILE                 *dump_file;
      u_char               *end;
  
      http_ctx = cf->ctx;
      toplevel_plcf = http_ctx->loc_conf[ngx_http_passenger_module.ctx_index];
  
      passenger_main_conf.default_ruby = toplevel_plcf->autogenerated.ruby;
      if (passenger_main_conf.default_ruby.len == 0) {
          passenger_main_conf.default_ruby.data = (u_char *) DEFAULT_RUBY;
          passenger_main_conf.default_ruby.len = strlen(DEFAULT_RUBY);
      }
  
      passenger_main_conf.manifest = generate_config_manifest(cf, toplevel_plcf);
      manifest_cleanup = ngx_pool_cleanup_add(cf->pool, 0);
      manifest_cleanup->handler = (ngx_pool_cleanup_pt) psg_json_value_free;
      manifest_cleanup->data = passenger_main_conf.manifest;
  
      if (passenger_main_conf.autogenerated.dump_config_manifest.len != 0) {
          dump_path = (char *) ngx_pnalloc(cf->temp_pool,
              passenger_main_conf.autogenerated.dump_config_manifest.len + 1);
          end = ngx_copy(dump_path,
              passenger_main_conf.autogenerated.dump_config_manifest.data,
              passenger_main_conf.autogenerated.dump_config_manifest.len);
          *end = '\0';
  
          dump_file = fopen(dump_path, "w");
          if (dump_file != NULL) {
              dump_content = psg_json_value_to_styled_string(
                  passenger_main_conf.manifest);
              ssize_t ret = fwrite(dump_content, 1, strlen(dump_content), dump_file);
              (void) ret; // Ignore compilation warning.
              fclose(dump_file);
              free(dump_content);
          } else {
              ngx_conf_log_error(NGX_LOG_ALERT, cf, 0,
                  "Error dumping " PROGRAM_NAME " configuration manifest to %V",
                  &passenger_main_conf.autogenerated.dump_config_manifest);
          }
      }
  
      return NGX_OK;
  }
  
  static int
  string_keyval_has_key(ngx_array_t *table, ngx_str_t *key)
  {
      ngx_keyval_t  *elems;
      ngx_uint_t     i;
  
      elems = (ngx_keyval_t *) table->elts;
      for (i = 0; i < table->nelts; i++) {
          if (elems[i].key.len == key->len
           && memcmp(elems[i].key.data, key->data, key->len) == 0)
          {
              return 1;
          }
      }
  
      return 0;
  }
  
  static ngx_int_t
  merge_string_keyval_table(ngx_conf_t *cf, ngx_array_t **prev, ngx_array_t **conf)
  {
      ngx_keyval_t  *prev_elems, *elem;
      ngx_uint_t     i;
  
      if (*prev != NULL) {
          if (*conf == NULL) {
              *conf = ngx_array_create(cf->pool, 4, sizeof(ngx_keyval_t));
              if (*conf == NULL) {
                  return NGX_ERROR;
              }
          }
  
          prev_elems = (ngx_keyval_t *) (*prev)->elts;
          for (i = 0; i < (*prev)->nelts; i++) {
              if (!string_keyval_has_key(*conf, &prev_elems[i].key)) {
                  elem = (ngx_keyval_t *) ngx_array_push(*conf);
                  if (elem == NULL) {
                      return NGX_ERROR;
                  }
                  *elem = prev_elems[i];
              }
          }
      }
  
      return NGX_OK;
  }
  
  #ifndef PASSENGER_IS_ENTERPRISE
  static char *
  passenger_enterprise_only(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
      return ": this feature is only available in Phusion Passenger Enterprise. "
          "You are currently running the open source Phusion Passenger. "
          "Please learn more about and/or buy Phusion Passenger Enterprise at https://www.phusionpassenger.com/enterprise ;";
  }
  #endif
  
  static char *
  passenger_enabled(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  {
      passenger_loc_conf_t        *passenger_conf = conf;
      ngx_http_core_loc_conf_t    *clcf;
      ngx_str_t                   *value;
      ngx_url_t                    upstream_url;
  
      passenger_conf->autogenerated.enabled_explicitly_set = 1;
      record_loc_conf_source_location(cf, passenger_conf,
          &passenger_conf->autogenerated.enabled_source_file,
          &passenger_conf->autogenerated.enabled_source_line);
  
      value = cf->args->elts;
      if (ngx_strcasecmp(value[1].data, (u_char *) "on") == 0) {
          passenger_conf->autogenerated.enabled = 1;
  
          /* Register a placeholder value as upstream address. The real upstream
           * address (the Passenger core socket filename) will be set while processing
           * requests, because we can't start the watchdog (and thus the Passenger core)
           * until config loading is done.
           */
          ngx_memzero(&upstream_url, sizeof(ngx_url_t));
          upstream_url.url = pp_placeholder_upstream_address;
          upstream_url.no_resolve = 1;
          passenger_conf->upstream_config.upstream = ngx_http_upstream_add(cf, &upstream_url, 0);
          if (passenger_conf->upstream_config.upstream == NULL) {
              return NGX_CONF_ERROR;
          }
  
          clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module);
          clcf->handler = passenger_content_handler;
  
          if (clcf->name.data != NULL
           && clcf->name.data[clcf->name.len - 1] == '/') {
              clcf->auto_redirect = 1;
          }
      } else if (ngx_strcasecmp(value[1].data, (u_char *) "off") == 0) {
          passenger_conf->autogenerated.enabled = 0;
      } else {
          ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
              "\"passenger_enabled\" must be either set to \"on\" "
              "or \"off\"");
  
          return NGX_CONF_ERROR;
      }
  
      return NGX_CONF_OK;
  }
  
  static char *
  passenger_conf_set_request_buffering(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {
      #ifdef NGINX_NO_SEND_REQUEST_BODY_INFINITE_LOOP_BUG
          passenger_loc_conf_t *passenger_conf = conf;
  
          passenger_conf->autogenerated.upstream_config_request_buffering_explicitly_set = 1;
          record_loc_conf_source_location(cf, passenger_conf,
              &passenger_conf->autogenerated.upstream_config_request_buffering_source_file,
              &passenger_conf->autogenerated.upstream_config_request_buffering_source_line);
  
          return ngx_conf_set_flag_slot(cf, cmd, conf);
      #else
          return "config cannot be set in Nginx < 1.15.3 due to this bug: https://trac.nginx.org/nginx/ticket/1618";
      #endif /* NGINX_NO_SEND_REQUEST_BODY_INFINITE_LOOP_BUG */
  }
  
  static char *
  rails_framework_spawner_idle_time(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  {
      ngx_conf_log_error(NGX_LOG_ALERT, cf, 0, "The 'rails_framework_spawner_idle_time' "
          "directive is deprecated; please set 'passenger_max_preloader_idle_time' instead");
      return NGX_CONF_OK;
  }
  
  static char *
  passenger_use_global_queue(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  {
      ngx_conf_log_error(NGX_LOG_ALERT, cf, 0, "The 'passenger_use_global_queue' "
          "directive is obsolete and doesn't do anything anymore. Global queuing "
          "is now always enabled. Please remove this configuration directive.");
      return NGX_CONF_OK;
  }
  
  static char *
  passenger_obsolete_directive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  {
      ngx_conf_log_error(NGX_LOG_ALERT, cf, 0, "The '%V' directive is obsolete "
          "and doesn't do anything anymore.", &cmd->name);
      return NGX_CONF_OK;
  }
  
  
  PsgJsonValue *
  psg_json_value_set_str_array(PsgJsonValue *doc, const char *name, ngx_array_t *ary) {
      PsgJsonValue *subdoc = psg_json_value_new_with_type(PSG_JSON_VALUE_TYPE_ARRAY);
      PsgJsonValue *elem, *result;
      ngx_str_t *values;
      ngx_uint_t i;
  
      if (ary != NULL) {
          values = (ngx_str_t *) ary->elts;
          for (i = 0; i < ary->nelts; i++) {
              elem = psg_json_value_new_str(
                  (const char *) values[i].data, values[i].len);
              psg_json_value_append_val(subdoc, elem);
              psg_json_value_free(elem);
          }
      }
  
      result = psg_json_value_set_value(doc, name, -1, subdoc);
      psg_json_value_free(subdoc);
  
      return result;
  }
  
  PsgJsonValue *
  psg_json_value_set_str_keyval(PsgJsonValue *doc, const char *name, ngx_array_t *ary) {
      PsgJsonValue *subdoc = psg_json_value_new_with_type(PSG_JSON_VALUE_TYPE_OBJECT);
      PsgJsonValue *elem, *result;
      ngx_keyval_t *values;
      ngx_uint_t i;
  
      if (ary != NULL) {
          values = (ngx_keyval_t *) ary->elts;
          for (i = 0; i < ary->nelts; i++) {
              elem = psg_json_value_new_str(
                  (const char *) values[i].value.data, values[i].value.len);
              psg_json_value_set_value(subdoc,
                  (const char *) values[i].key.data, values[i].key.len,
                  elem);
              psg_json_value_free(elem);
          }
      }
  
      result = psg_json_value_set_value(doc, name, -1, subdoc);
      psg_json_value_free(subdoc);
  
      return result;
  }
  
  
  const ngx_command_t passenger_commands[] = {
  
      #include "ConfigGeneral/AutoGeneratedDefinitions.c"
  
      ngx_null_command
  };
  