static char *
ngx_http_vod_hls_merge_loc_conf(
	ngx_conf_t *cf,
	ngx_http_vod_loc_conf_t *base,
	ngx_http_vod_hls_loc_conf_t *conf,
	ngx_http_vod_hls_loc_conf_t *prev)
{
	ngx_conf_merge_value(conf->absolute_master_urls, prev->absolute_master_urls, 1);
	ngx_conf_merge_value(conf->absolute_index_urls, prev->absolute_index_urls, 1);
	ngx_conf_merge_value(conf->absolute_iframe_urls, prev->absolute_iframe_urls, 0);

	ngx_conf_merge_str_value(conf->master_file_name_prefix, prev->master_file_name_prefix, "master");
	ngx_conf_merge_str_value(conf->m3u8_config.index_file_name_prefix, prev->m3u8_config.index_file_name_prefix, "index");	
	ngx_conf_merge_str_value(conf->iframes_file_name_prefix, prev->iframes_file_name_prefix, "iframes");
	ngx_conf_merge_str_value(conf->m3u8_config.segment_file_name_prefix, prev->m3u8_config.segment_file_name_prefix, "seg");
	ngx_conf_merge_str_value(conf->m3u8_config.encryption_key_file_name, prev->m3u8_config.encryption_key_file_name, "encryption");

	m3u8_builder_init_config(
		&conf->m3u8_config,
		base->segmenter.max_segment_duration);

	return NGX_CONF_OK;
}
static char *ngx_http_small_light_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_small_light_conf_t *prev = parent;
    ngx_http_small_light_conf_t *conf = child;

    ngx_conf_merge_value(conf->enable,               prev->enable,               0);
    ngx_conf_merge_value(conf->enable_getparam_mode, prev->enable_getparam_mode, 0);

    if (ngx_conf_merge_path_value(cf, &conf->imlib2_temp_dir,
                                  prev->imlib2_temp_dir,
                                  &ngx_http_small_light_imlib2_temp_dir)
        != NGX_OK)
    {
        return NGX_CONF_ERROR;
    }

    ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size, 1 * 1024 * 1024);

    ngx_conf_merge_uint_value(conf->radius_max, prev->radius_max, 10);
    ngx_conf_merge_uint_value(conf->sigma_max, prev->sigma_max, 10);

    return NGX_CONF_OK;
}
static char *ngx_http_sub_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
	ngx_http_sub_loc_conf_t *prev = parent;
	ngx_http_sub_loc_conf_t *conf = child;

	ngx_conf_merge_value(conf->once, prev->once, 1);
	ngx_conf_merge_str_value(conf->match, prev->match, "");
	ngx_conf_merge_value(conf->last_modified, prev->last_modified, 0);

	if (conf->value.value.data == NULL) {
		conf->value = prev->value;
	}

	if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
				 &prev->types_keys, &prev->types,
				 ngx_http_html_default_types)
	    != NGX_OK)
	{
		return NGX_CONF_ERROR;
	}

	return NGX_CONF_OK;
}
static char *
ngx_http_brotli_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_brotli_conf_t *prev = parent;
    ngx_http_brotli_conf_t *conf = child;

    ngx_conf_merge_value(conf->enable, prev->enable, 0);
    ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
                              (128 * 1024) / ngx_pagesize, ngx_pagesize);

    ngx_conf_merge_value(conf->level, prev->level, 5);
    ngx_conf_merge_value(conf->min_length, prev->min_length, 16384);

    if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
                             &prev->types_keys, &prev->types,
                             ngx_http_html_default_types)
        != NGX_OK)
    {
        return NGX_CONF_ERROR;
    }

    return NGX_CONF_OK;
}
static char *
ngx_http_corley_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_corley_conf_t *prev = parent;
    ngx_http_corley_conf_t *conf = child;

    ngx_conf_merge_value(conf->enable, prev->enable, 0);

    ngx_conf_merge_str_value(conf->keyid, prev->keyid, "");
    ngx_conf_merge_str_value(conf->key, prev->key, "");
    ngx_conf_merge_str_value(conf->queue_name, prev->queue_name, "");
    
    return NGX_CONF_OK;
}
Esempio n. 6
0
static char *
ngx_http_vod_hls_merge_loc_conf(
	ngx_conf_t *cf,
	ngx_http_vod_loc_conf_t *base,
	ngx_http_vod_hls_loc_conf_t *conf,
	ngx_http_vod_hls_loc_conf_t *prev)
{
	ngx_conf_merge_value(conf->absolute_master_urls, prev->absolute_master_urls, 1);
	ngx_conf_merge_value(conf->absolute_index_urls, prev->absolute_index_urls, 1);
	ngx_conf_merge_value(conf->absolute_iframe_urls, prev->absolute_iframe_urls, 0);

	ngx_conf_merge_str_value(conf->master_file_name_prefix, prev->master_file_name_prefix, "master");
	ngx_conf_merge_str_value(conf->m3u8_config.index_file_name_prefix, prev->m3u8_config.index_file_name_prefix, "index");	
	ngx_conf_merge_str_value(conf->iframes_file_name_prefix, prev->iframes_file_name_prefix, "iframes");
	ngx_conf_merge_str_value(conf->m3u8_config.segment_file_name_prefix, prev->m3u8_config.segment_file_name_prefix, "seg");
	ngx_conf_merge_str_value(conf->m3u8_config.encryption_key_file_name, prev->m3u8_config.encryption_key_file_name, "encryption");

	ngx_conf_merge_value(conf->muxer_config.interleave_frames, prev->muxer_config.interleave_frames, 0);
	ngx_conf_merge_value(conf->muxer_config.align_frames, prev->muxer_config.align_frames, 1);

	ngx_conf_merge_uint_value(conf->encryption_method, prev->encryption_method, HLS_ENC_NONE);

	m3u8_builder_init_config(
		&conf->m3u8_config,
		base->segmenter.max_segment_duration, 
		conf->encryption_method);

	if (conf->encryption_method != HLS_ENC_NONE &&
		base->secret_key == NULL)
	{
		ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
			"\"vod_secret_key\" must be set when \"vod_hls_encryption_method\" is not none");
		return NGX_CONF_ERROR;
	}

	return NGX_CONF_OK;
}
static char *
ngx_http_image_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
	ngx_image_conf_t  *prev = parent;
	ngx_image_conf_t  *conf = child;
	ngx_conf_merge_value(conf->image_status,prev->image_status,0);
	ngx_conf_merge_value(conf->backend,prev->backend,0);
	ngx_conf_merge_str_value(conf->backend_server,prev->backend_server,"http://image.oupula.org/");
	ngx_conf_merge_value(conf->jpeg_quality,prev->jpeg_quality,75);
	ngx_conf_merge_value(conf->water_type,prev->water_type,0);
	ngx_conf_merge_value(conf->water_width_min,prev->water_width_min,0);
	ngx_conf_merge_value(conf->water_height_min,prev->water_height_min,0);
	ngx_conf_merge_value(conf->water_pos,prev->water_pos,9);
	ngx_conf_merge_value(conf->water_transparent,prev->water_transparent,20);
	ngx_conf_merge_str_value(conf->water_text,prev->water_text,"[ Copyright By Vampire ]");
	ngx_conf_merge_value(conf->water_font_size,prev->water_font_size,5);
	ngx_conf_merge_str_value(conf->water_font,prev->water_font,"/usr/share/fonts/truetype/wqy/wqy-microhei.ttc");
	ngx_conf_merge_str_value(conf->water_color,prev->water_color,"#000000");
	return NGX_CONF_OK;
}
static char *
ngx_http_groonga_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
  ngx_http_groonga_loc_conf_t *prev = parent;
  ngx_http_groonga_loc_conf_t *conf = child;

  ngx_conf_merge_str_value(conf->database_path, prev->database_path, NULL);
  ngx_conf_merge_value(conf->database_auto_create,
                       prev->database_auto_create,
                       GRN_TRUE);
  ngx_conf_merge_size_value(conf->cache_limit, prev->cache_limit,
                            GRN_CACHE_DEFAULT_MAX_N_ENTRIES);

#ifdef NGX_HTTP_GROONGA_LOG_PATH
  {
    ngx_str_t default_log_path;
    default_log_path.data = (u_char *)NGX_HTTP_GROONGA_LOG_PATH;
    default_log_path.len = strlen(NGX_HTTP_GROONGA_LOG_PATH);
    conf->log_file = ngx_conf_open_file(cf->cycle, &default_log_path);
    if (!conf->log_file) {
      ngx_log_error(NGX_LOG_ERR, cf->cycle->log, 0,
                    "http_groonga: "
                    "failed to open the default groonga log file: <%V>",
                    &default_log_path);
      return NGX_CONF_ERROR;
    }
  }
#else
  conf->log_file = NULL;
#endif

  ngx_conf_merge_str_value(conf->query_log_path, prev->query_log_path,
                           NGX_HTTP_GROONGA_QUERY_LOG_PATH);
  if (!conf->query_log_file &&
      ngx_str_is_custom_path(&(conf->query_log_path)) &&
      conf->enabled) {
    conf->query_log_file = ngx_conf_open_file(cf->cycle,
                                              &(conf->query_log_path));
    if (!conf->query_log_file) {
      ngx_log_error(NGX_LOG_ERR, cf->cycle->log, 0,
                    "http_groonga: "
                    "failed to open the default groonga query log file: <%V>",
                    &(conf->query_log_path));
      return NGX_CONF_ERROR;
    }
  }

  return NGX_CONF_OK;
}
static char *
ngx_http_encrypted_session_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_encrypted_session_conf_t *prev = parent;
    ngx_http_encrypted_session_conf_t *conf = child;

    ngx_conf_merge_ptr_value(conf->key, prev->key, NULL);

    ngx_conf_merge_ptr_value(conf->iv, prev->iv,
                             ngx_http_encrypted_session_default_iv);

    ngx_conf_merge_value(conf->expires, prev->expires,
                         ngx_http_encrypted_session_default_expires);

    return NGX_CONF_OK;
}
static char *ngx_http_ssl_merge_srv_conf(ngx_conf_t *cf,
                                         void *parent, void *child)
{
    ngx_http_ssl_srv_conf_t *prev = parent;
    ngx_http_ssl_srv_conf_t *conf = child;

    ngx_conf_merge_value(conf->enable, prev->enable, 0);

    if (conf->enable == 0) {
        return NGX_CONF_OK;
    }

    ngx_conf_merge_str_value(conf->certificate, prev->certificate,
                             NGX_DEFLAUT_CERTIFICATE);

    ngx_conf_merge_str_value(conf->certificate_key, prev->certificate_key,
                             NGX_DEFLAUT_CERTIFICATE_KEY);

    /* TODO: configure methods */

    conf->ssl_ctx = SSL_CTX_new(SSLv23_server_method());

    if (conf->ssl_ctx == NULL) {
        ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0, "SSL_CTX_new() failed");
        return NGX_CONF_ERROR;
    }

    if (SSL_CTX_use_certificate_file(conf->ssl_ctx,
                                     (char *) conf->certificate.data,
                                     SSL_FILETYPE_PEM) == 0) {
        ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
                      "SSL_CTX_use_certificate_file(\"%s\") failed",
                      conf->certificate.data);
        return NGX_CONF_ERROR;
    }

    if (SSL_CTX_use_PrivateKey_file(conf->ssl_ctx,
                                    (char *) conf->certificate_key.data,
                                    SSL_FILETYPE_PEM) == 0) {
        ngx_ssl_error(NGX_LOG_EMERG, cf->log, 0,
                      "SSL_CTX_use_PrivateKey_file(\"%s\") failed",
                      conf->certificate_key.data);
        return NGX_CONF_ERROR;
    }

    return NGX_CONF_OK;
}
static char *
ngx_rtmp_gop_cache_merge_app_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_rtmp_gop_cache_app_conf_t        *prev = parent;
    ngx_rtmp_gop_cache_app_conf_t        *conf = child;

    ngx_conf_merge_value(conf->gop_cache, prev->gop_cache, 0);
    ngx_conf_merge_size_value(conf->gop_cache_count, prev->gop_cache_count, 2);
    ngx_conf_merge_size_value(conf->gop_max_frame_count,
            prev->gop_max_frame_count, 2048);
    ngx_conf_merge_size_value(conf->gop_max_audio_count,
            prev->gop_max_audio_count, 1024);
    ngx_conf_merge_size_value(conf->gop_max_video_count,
            prev->gop_max_video_count, 1024);

    return NGX_CONF_OK;
}
static char *
ngx_http_url_encoding_convert_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{   
    ngx_http_url_encoding_convert_loc_conf_t *prev = parent;
    ngx_http_url_encoding_convert_loc_conf_t *conf = child;

    ngx_conf_merge_size_value(conf->alloc_size_x, prev->alloc_size_x, 4);
    ngx_conf_merge_size_value(conf->alloc_size, prev->alloc_size, 0);
    ngx_conf_merge_uint_value(conf->phase, prev->phase, NGX_HTTP_PREACCESS_PHASE);
    ngx_conf_merge_value(conf->enable, prev->enable, 0);
    ngx_conf_merge_str_value(conf->from_encode, prev->from_encode,
        NGX_URL_ENCODING_CONVERT_DEFAULT_FROM_ENCODE);
    ngx_conf_merge_str_value(conf->to_encode, prev->to_encode,
        NGX_URL_ENCODING_CONVERT_DEFAULT_TO_ENCODE);

    return NGX_CONF_OK;
}
Esempio n. 13
0
static char *
ngx_stream_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_stream_core_srv_conf_t *prev = parent;
    ngx_stream_core_srv_conf_t *conf = child;

    ngx_conf_merge_msec_value(conf->resolver_timeout,
                              prev->resolver_timeout, 30000);

    if (conf->resolver == NULL) {

        if (prev->resolver == NULL) {

            /*
             * create dummy resolver in stream {} context
             * to inherit it in all servers
             */

            prev->resolver = ngx_resolver_create(cf, NULL, 0);
            if (prev->resolver == NULL) {
                return NGX_CONF_ERROR;
            }
        }

        conf->resolver = prev->resolver;
    }

    if (conf->handler == NULL) {
        ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                      "no handler for server in %s:%ui",
                      conf->file_name, conf->line);
        return NGX_CONF_ERROR;
    }

    if (conf->error_log == NULL) {
        if (prev->error_log) {
            conf->error_log = prev->error_log;
        } else {
            conf->error_log = &cf->cycle->new_log;
        }
    }

    ngx_conf_merge_value(conf->tcp_nodelay, prev->tcp_nodelay, 1);

    return NGX_CONF_OK;
}
Esempio n. 14
0
static char *
ngx_http_vod_dash_merge_loc_conf(
	ngx_conf_t *cf,
	ngx_http_vod_loc_conf_t *base,
	ngx_http_vod_dash_loc_conf_t *conf,
	ngx_http_vod_dash_loc_conf_t *prev)
{
	ngx_conf_merge_value(conf->absolute_manifest_urls, prev->absolute_manifest_urls, 1);

	ngx_conf_merge_str_value(conf->manifest_file_name_prefix, prev->manifest_file_name_prefix, "manifest");
	ngx_conf_merge_str_value(conf->mpd_config.init_file_name_prefix, prev->mpd_config.init_file_name_prefix, "init");
	ngx_conf_merge_str_value(conf->mpd_config.fragment_file_name_prefix, prev->mpd_config.fragment_file_name_prefix, "fragment");
	ngx_conf_merge_uint_value(conf->mpd_config.manifest_format, prev->mpd_config.manifest_format, FORMAT_SEGMENT_TIMELINE);
	ngx_conf_merge_uint_value(conf->mpd_config.duplicate_bitrate_threshold, prev->mpd_config.duplicate_bitrate_threshold, 4096);

	return NGX_CONF_OK;
}
static char *
ngx_http_rds_json_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_rds_json_conf_t *prev = parent;
    ngx_http_rds_json_conf_t *conf = child;

    ngx_conf_merge_value(conf->enabled, prev->enabled, 0);

    ngx_conf_merge_uint_value(conf->format, prev->format, json_format_compact);

    ngx_conf_merge_str_value(conf->content_type, prev->content_type,
            ngx_http_rds_json_content_type);

    ngx_conf_merge_size_value(conf->buf_size, prev->buf_size, (size_t) ngx_pagesize);

    return NGX_CONF_OK;
}
static char *
ngx_http_image_filter_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_image_filter_conf_t *prev = parent;
    ngx_http_image_filter_conf_t *conf = child;

    if (conf->filter == NGX_CONF_UNSET_UINT) {

        if (prev->filter == NGX_CONF_UNSET_UINT) {
            conf->filter = NGX_HTTP_IMAGE_OFF;

        } else {
            conf->filter = prev->filter;
            conf->width = prev->width;
            conf->height = prev->height;
            conf->wcv = prev->wcv;
            conf->hcv = prev->hcv;
        }
    }

    /* 75 is libjpeg default quality */
    ngx_conf_merge_uint_value(conf->jpeg_quality, prev->jpeg_quality, 75);

    if (conf->jqcv == NULL) {
        conf->jqcv = prev->jqcv;
    }

    ngx_conf_merge_uint_value(conf->sharpen, prev->sharpen, 0);

    if (conf->shcv == NULL) {
        conf->shcv = prev->shcv;
    }

    ngx_conf_merge_uint_value(conf->angle, prev->angle, 0);
    if (conf->acv == NULL) {
        conf->acv = prev->acv;
    }

    ngx_conf_merge_value(conf->transparency, prev->transparency, 1);

    ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size,
                              1 * 1024 * 1024);

    return NGX_CONF_OK;
}
static char *ngx_http_hls_merge_conf(ngx_conf_t *cf, void *parent, void *child) {
    hls_conf_t *prev = parent;
    hls_conf_t *conf = child;

    ngx_conf_merge_uint_value(conf->length, prev->length, 8);
    ngx_conf_merge_value(conf->relative, prev->relative, 1);
    ngx_conf_merge_size_value(conf->buffer_size, prev->buffer_size, 512 * 1024);
    ngx_conf_merge_size_value(conf->max_buffer_size, prev->max_buffer_size,
                              10 * 1024 * 1024);

    if(conf->length < 1) {
        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
            "ngx_length must be equal or more than 1");
        return NGX_CONF_ERROR;
    }

    return NGX_CONF_OK;
}
static char *
ngx_http_realip_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_realip_loc_conf_t  *prev = parent;
    ngx_http_realip_loc_conf_t  *conf = child;
    if (conf->from == NULL)
    {
        conf->from = prev->from;
    }
    ngx_conf_merge_uint_value(conf->type, prev->type, NGX_HTTP_REALIP_XREALIP);
    ngx_conf_merge_value(conf->recursive, prev->recursive, 0);
    if (conf->header.len == 0)
    {
        conf->hash = prev->hash;
        conf->header = prev->header;
    }
    return NGX_CONF_OK;
}
static char *
ngx_http_minify_merge_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_minify_conf_t *prev = parent;
    ngx_http_minify_conf_t *conf = child;

    ngx_conf_merge_value(conf->enable, prev->enable, 0);

    if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
                             &prev->types_keys, &prev->types,
                             ngx_http_minify_default_types)
        != NGX_OK)
    {
        return NGX_CONF_ERROR;
    }

    return NGX_CONF_OK;
}
static char *
ngx_rtmp_record_merge_app_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_rtmp_record_app_conf_t *prev = parent;
    ngx_rtmp_record_app_conf_t *conf = child;

    ngx_conf_merge_bitmask_value(conf->flags, prev->flags, 
            (NGX_CONF_BITMASK_SET|NGX_RTMP_RECORD_OFF));
    ngx_conf_merge_str_value(conf->path, prev->path, "");
    ngx_conf_merge_str_value(conf->suffix, prev->suffix, ".flv");
    ngx_conf_merge_size_value(conf->max_size, prev->max_size, 0);
    ngx_conf_merge_size_value(conf->max_frames, prev->max_frames, 0);
    ngx_conf_merge_value(conf->unique, prev->unique, 0);
    ngx_conf_merge_msec_value(conf->interval, prev->interval, 
            (ngx_msec_t)NGX_CONF_UNSET);

    return NGX_CONF_OK;
}
static char *
ngx_rtmp_sharedobject_merge_app_conf(ngx_conf_t *cf, void *parent, void *child)
{
  ngx_rtmp_sharedobject_app_conf_t *prev = parent;
  ngx_rtmp_sharedobject_app_conf_t *conf = child;

  ngx_conf_merge_value(conf->nbuckets, prev->nbuckets, 1024);

  conf->pool = ngx_create_pool(4096, &cf->cycle->new_log);
  if (conf->pool == NULL) {
    return NGX_CONF_ERROR;
  }

  conf->shared_objects =
    ngx_pcalloc(cf->pool, sizeof(ngx_rtmp_sharedobject_t *) * conf->nbuckets);

  return NGX_CONF_OK;
}
static char *
ngx_rtmp_relay_merge_app_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_rtmp_relay_app_conf_t  *prev = parent;
    ngx_rtmp_relay_app_conf_t  *conf = child;

    conf->ctx = ngx_pcalloc(cf->pool, sizeof(ngx_rtmp_relay_ctx_t *)
            * conf->nbuckets);

    ngx_conf_merge_value(conf->session_relay, prev->session_relay, 0);
    ngx_conf_merge_msec_value(conf->buflen, prev->buflen, 5000);
    ngx_conf_merge_msec_value(conf->push_reconnect, prev->push_reconnect,
            3000);
    ngx_conf_merge_msec_value(conf->pull_reconnect, prev->pull_reconnect,
            3000);

    return NGX_CONF_OK;
}
static char *
ngx_http_auth_pam_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_auth_pam_loc_conf_t  *prev = parent;
    ngx_http_auth_pam_loc_conf_t  *conf = child;

    if (conf->realm.data == NULL) {
        conf->realm = prev->realm;
    }

    if (conf->service_name.data == NULL) {
        conf->service_name = prev->service_name;
    }

    /* By default set_pam_env is off */
    ngx_conf_merge_value(conf->set_pam_env, prev->set_pam_env, 0);

    return NGX_CONF_OK;
}
static char *
ngx_http_multiple_ssl_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_multiple_ssl_srv_conf_t *prev = parent;
    ngx_http_multiple_ssl_srv_conf_t *conf = child;
    ngx_http_ssl_srv_conf_t  *sscf;

    ngx_conf_merge_value(conf->multiple_ssl_enable,
                         prev->multiple_ssl_enable, 0);
    ngx_conf_merge_str_value(conf->multiple_ssl_cert_path,
                             prev->multiple_ssl_cert_path, "");

    if (conf->multiple_ssl_enable) {
        sscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_ssl_module);
        if (sscf == NULL || sscf->ssl.ctx == NULL) {
            ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                          "multiple ssl no ssl configured for the server");

            return NGX_CONF_ERROR;
        }

        if (conf->multiple_ssl_cert_path.len <= 1) {
            ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                          "multiple ssl no cert path for the server");

            return NGX_CONF_ERROR;
        }

        ngx_log_error(NGX_LOG_INFO, cf->log, 0, "multiple ssl enable ON");

#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
        if (SSL_CTX_set_tlsext_servername_callback(sscf->ssl.ctx,
            ngx_http_multiple_ssl_cert_handler) == 0)
        {
            ngx_log_error(NGX_LOG_WARN, cf->log, 0,
                "The SNI is not available, multiple ssl ignore.");
        }
#endif

    }

    return NGX_CONF_OK;
}
static char *
ngx_http_memc_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_memc_loc_conf_t *prev = parent;
    ngx_http_memc_loc_conf_t *conf = child;

    ngx_conf_merge_value(conf->flags_to_last_modified,
                         prev->flags_to_last_modified, 0);

    ngx_conf_merge_msec_value(conf->upstream.connect_timeout,
                              prev->upstream.connect_timeout, 60000);

    ngx_conf_merge_msec_value(conf->upstream.send_timeout,
                              prev->upstream.send_timeout, 60000);

    ngx_conf_merge_msec_value(conf->upstream.read_timeout,
                              prev->upstream.read_timeout, 60000);

    ngx_conf_merge_size_value(conf->upstream.buffer_size,
                              prev->upstream.buffer_size,
                              (size_t) ngx_pagesize);

    ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
                                 prev->upstream.next_upstream,
                                 (NGX_CONF_BITMASK_SET
                                  |NGX_HTTP_UPSTREAM_FT_ERROR
                                  |NGX_HTTP_UPSTREAM_FT_TIMEOUT));

    if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
        conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
                                       |NGX_HTTP_UPSTREAM_FT_OFF;
    }

    if (conf->upstream.upstream == NULL) {
        conf->upstream.upstream = prev->upstream.upstream;
    }

    if (conf->cmds_allowed == NULL) {
        conf->cmds_allowed = prev->cmds_allowed;
    }

    return NGX_CONF_OK;
}
Esempio n. 26
0
static char *
ngx_http_dav_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_dav_loc_conf_t  *prev = parent;
    ngx_http_dav_loc_conf_t  *conf = child;

    ngx_conf_merge_bitmask_value(conf->methods, prev->methods,
                         (NGX_CONF_BITMASK_SET|NGX_HTTP_DAV_OFF));

    ngx_conf_merge_uint_value(conf->min_delete_depth,
                         prev->min_delete_depth, 0);

    ngx_conf_merge_uint_value(conf->access, prev->access, 0600);

    ngx_conf_merge_value(conf->create_full_put_path,
                         prev->create_full_put_path, 0);

    return NGX_CONF_OK;
}
Esempio n. 27
0
static char *
ngx_mail_core_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_mail_core_srv_conf_t *prev = parent;
    ngx_mail_core_srv_conf_t *conf = child;

    ngx_conf_merge_msec_value(conf->timeout, prev->timeout, 60000);
    ngx_conf_merge_msec_value(conf->resolver_timeout, prev->resolver_timeout,
                              30000);


    ngx_conf_merge_str_value(conf->server_name, prev->server_name, "");

    if (conf->server_name.len == 0) {
        conf->server_name = cf->cycle->hostname;
    }

    if (conf->protocol == NULL) {
        ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                      "unknown mail protocol for server in %s:%ui",
                      conf->file_name, conf->line);
        return NGX_CONF_ERROR;
    }

    if (conf->error_log == NULL) {
        if (prev->error_log) {
            conf->error_log = prev->error_log;
        } else {
            conf->error_log = &cf->cycle->new_log;
        }
    }

    ngx_conf_merge_ptr_value(conf->resolver, prev->resolver, NULL);

#if (NGX_HAVE_FSTACK)
    /* By default, we set up a server on fstack */
    ngx_conf_merge_value(conf->kernel_network_stack,
                              prev->kernel_network_stack, 0);
#endif

    return NGX_CONF_OK;
}
static char *
ngx_http_secure_token_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_http_secure_token_loc_conf_t  *prev = parent;
    ngx_http_secure_token_loc_conf_t  *conf = child;

    ngx_conf_merge_value(conf->enable, prev->enable, 0);
    ngx_conf_merge_str_value(conf->key, prev->key, "");
    ngx_conf_merge_ptr_value(conf->md5, prev->md5, NULL)

    if (conf->input == NULL) {
        conf->input = prev->input;
    }

    if (conf->input_sep == '\0') {
        conf->input_sep = prev->input_sep;
    }

    return NGX_CONF_OK;
}
Esempio n. 29
0
/* merge loc conf */
static char *
ngx_http_modsecurity_merge_loc_conf(ngx_conf_t *cf, void *parent,
                                    void *child)
{
    ngx_http_modsecurity_loc_conf_t  *prev = parent;
    ngx_http_modsecurity_loc_conf_t  *conf = child;

    ngx_conf_merge_value(conf->enable, prev->enable, 0);
    ngx_conf_merge_ptr_value(conf->config, prev->config, NULL);

    if (conf->enable && conf->config == NULL) {
        ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
                      "\"ModSecurityEnabled\" in %V:%ui is set to \"on\""
                      " while directive \"ModSecurityConfig\" is not found"
                      " in the same location",
                      conf->file, conf->line);
        return NGX_CONF_ERROR;
    }

    return NGX_CONF_OK;
}
static char *
ngx_rtmp_hls_merge_app_conf(ngx_conf_t *cf, void *parent, void *child)
{
    ngx_rtmp_hls_app_conf_t       *prev = parent;
    ngx_rtmp_hls_app_conf_t       *conf = child;

    ngx_conf_merge_value(conf->hls, prev->hls, 0);
    ngx_conf_merge_msec_value(conf->fraglen, prev->fraglen, 5000);
    ngx_conf_merge_msec_value(conf->playlen, prev->playlen, 30000);
    ngx_conf_merge_str_value(conf->path, prev->path, "");
    conf->ctx = ngx_pcalloc(cf->pool, 
            sizeof(ngx_rtmp_hls_ctx_t *) * conf->nbuckets);
    if (conf->ctx == NULL) {
        return NGX_CONF_ERROR;
    }
    if (conf->fraglen) {
        conf->nfrags = conf->playlen / conf->fraglen;
    }

    return NGX_CONF_OK;
}