One Level Up Top Level

src/http/ngx_http_spdy_module.c - nginx-1.7.10

Global variables defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Nginx, Inc.
  4. * Copyright (C) Valentin V. Bartenev
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>
  11. #include <ngx_http_spdy_module.h>


  14. static ngx_int_t ngx_http_spdy_add_variables(ngx_conf_t *cf);

  16. static ngx_int_t ngx_http_spdy_variable(ngx_http_request_t *r,
  17.     ngx_http_variable_value_t *v, uintptr_t data);
  18. static ngx_int_t ngx_http_spdy_request_priority_variable(ngx_http_request_t *r,
  19.     ngx_http_variable_value_t *v, uintptr_t data);

  21. static ngx_int_t ngx_http_spdy_module_init(ngx_cycle_t *cycle);

  23. static void *ngx_http_spdy_create_main_conf(ngx_conf_t *cf);
  24. static char *ngx_http_spdy_init_main_conf(ngx_conf_t *cf, void *conf);
  25. static void *ngx_http_spdy_create_srv_conf(ngx_conf_t *cf);
  26. static char *ngx_http_spdy_merge_srv_conf(ngx_conf_t *cf, void *parent,
  27.     void *child);
  28. static void *ngx_http_spdy_create_loc_conf(ngx_conf_t *cf);
  29. static char *ngx_http_spdy_merge_loc_conf(ngx_conf_t *cf, void *parent,
  30.     void *child);

  32. static char *ngx_http_spdy_recv_buffer_size(ngx_conf_t *cf, void *post,
  33.     void *data);
  34. static char *ngx_http_spdy_pool_size(ngx_conf_t *cf, void *post, void *data);
  35. static char *ngx_http_spdy_streams_index_mask(ngx_conf_t *cf, void *post,
  36.     void *data);
  37. static char *ngx_http_spdy_chunk_size(ngx_conf_t *cf, void *post, void *data);


  40. ‌static ngx_conf_num_bounds_t  ngx_http_spdy_headers_comp_bounds = {
  41.     ngx_conf_check_num_bounds, 0, 9
  42. };

  44. ‌static ngx_conf_post_t  ngx_http_spdy_recv_buffer_size_post =
  45.     { ngx_http_spdy_recv_buffer_size };
  46. ‌static ngx_conf_post_t  ngx_http_spdy_pool_size_post =
  47.     { ngx_http_spdy_pool_size };
  48. ‌static ngx_conf_post_t  ngx_http_spdy_streams_index_mask_post =
  49.     { ngx_http_spdy_streams_index_mask };
  50. ‌static ngx_conf_post_t  ngx_http_spdy_chunk_size_post =
  51.     { ngx_http_spdy_chunk_size };


  54. ‌static ngx_command_t  ngx_http_spdy_commands[] = {

  56.     { ngx_string("spdy_recv_buffer_size"),
  57.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  58.       ngx_conf_set_size_slot,
  59.       NGX_HTTP_MAIN_CONF_OFFSET,
  60.       offsetof(ngx_http_spdy_main_conf_t, recv_buffer_size),
  61.       &ngx_http_spdy_recv_buffer_size_post },

  63.     { ngx_string("spdy_pool_size"),
  64.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  65.       ngx_conf_set_size_slot,
  66.       NGX_HTTP_SRV_CONF_OFFSET,
  67.       offsetof(ngx_http_spdy_srv_conf_t, pool_size),
  68.       &ngx_http_spdy_pool_size_post },

  70.     { ngx_string("spdy_max_concurrent_streams"),
  71.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  72.       ngx_conf_set_num_slot,
  73.       NGX_HTTP_SRV_CONF_OFFSET,
  74.       offsetof(ngx_http_spdy_srv_conf_t, concurrent_streams),
  75.       NULL },

  77.     { ngx_string("spdy_streams_index_size"),
  78.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  79.       ngx_conf_set_num_slot,
  80.       NGX_HTTP_SRV_CONF_OFFSET,
  81.       offsetof(ngx_http_spdy_srv_conf_t, streams_index_mask),
  82.       &ngx_http_spdy_streams_index_mask_post },

  84.     { ngx_string("spdy_recv_timeout"),
  85.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  86.       ngx_conf_set_msec_slot,
  87.       NGX_HTTP_SRV_CONF_OFFSET,
  88.       offsetof(ngx_http_spdy_srv_conf_t, recv_timeout),
  89.       NULL },

  91.     { ngx_string("spdy_keepalive_timeout"),
  92.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  93.       ngx_conf_set_msec_slot,
  94.       NGX_HTTP_SRV_CONF_OFFSET,
  95.       offsetof(ngx_http_spdy_srv_conf_t, keepalive_timeout),
  96.       NULL },

  98.     { ngx_string("spdy_headers_comp"),
  99.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_CONF_TAKE1,
  100.       ngx_conf_set_num_slot,
  101.       NGX_HTTP_SRV_CONF_OFFSET,
  102.       offsetof(ngx_http_spdy_srv_conf_t, headers_comp),
  103.       &ngx_http_spdy_headers_comp_bounds },

  105.     { ngx_string("spdy_chunk_size"),
  106.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  107.       ngx_conf_set_size_slot,
  108.       NGX_HTTP_LOC_CONF_OFFSET,
  109.       offsetof(ngx_http_spdy_loc_conf_t, chunk_size),
  110.       &ngx_http_spdy_chunk_size_post },

  112.       ngx_null_command
  113. };


  116. ‌static ngx_http_module_t  ngx_http_spdy_module_ctx = {
  117.     ngx_http_spdy_add_variables,           /* preconfiguration */
  118.     NULL,                                  /* postconfiguration */

  120.     ngx_http_spdy_create_main_conf,        /* create main configuration */
  121.     ngx_http_spdy_init_main_conf,          /* init main configuration */

  123.     ngx_http_spdy_create_srv_conf,         /* create server configuration */
  124.     ngx_http_spdy_merge_srv_conf,          /* merge server configuration */

  126.     ngx_http_spdy_create_loc_conf,         /* create location configuration */
  127.     ngx_http_spdy_merge_loc_conf           /* merge location configuration */
  128. };


  131. ‌ngx_module_t  ngx_http_spdy_module = {
  132.     NGX_MODULE_V1,
  133.     &ngx_http_spdy_module_ctx,             /* module context */
  134.     ngx_http_spdy_commands,                /* module directives */
  135.     NGX_HTTP_MODULE,                       /* module type */
  136.     NULL,                                  /* init master */
  137.     ngx_http_spdy_module_init,             /* init module */
  138.     NULL,                                  /* init process */
  139.     NULL,                                  /* init thread */
  140.     NULL,                                  /* exit thread */
  141.     NULL,                                  /* exit process */
  142.     NULL,                                  /* exit master */
  143.     NGX_MODULE_V1_PADDING
  144. };


  147. ‌static ngx_http_variable_t  ngx_http_spdy_vars[] = {

  149.     { ngx_string("spdy"), NULL,
  150.       ngx_http_spdy_variable, 0, 0, 0 },

  152.     { ngx_string("spdy_request_priority"), NULL,
  153.       ngx_http_spdy_request_priority_variable, 0, 0, 0 },

  155.     { ngx_null_string, NULL, NULL, 0, 0, 0 }
  156. };


  159. static ngx_int_t
  160. ‌ngx_http_spdy_add_variables(ngx_conf_t *cf)
  161. {
  162.    ngx_http_variable_t  *var, *v;

  164.     for (v = ngx_http_spdy_vars; v->name.len; v++) {
  165.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  166.         if (var == NULL) {
  167.             return NGX_ERROR;
  168.         }

  170.         var->get_handler = v->get_handler;
  171.         var->data = v->data;
  172.     }

  174.     return NGX_OK;
  175. }


  178. static ngx_int_t
  179. ‌ngx_http_spdy_variable(ngx_http_request_t *r,
  180.     ngx_http_variable_value_t *v, uintptr_t data)
  181. {
  182.     if (r->spdy_stream) {
  183.         v->len = sizeof("3.1") - 1;
  184.         v->valid = 1;
  185.         v->no_cacheable = 0;
  186.         v->not_found = 0;
  187.         v->data = (u_char *) "3.1";

  189.         return NGX_OK;
  190.     }

  192.     *v = ngx_http_variable_null_value;

  194.     return NGX_OK;
  195. }


  198. static ngx_int_t
  199. ‌ngx_http_spdy_request_priority_variable(ngx_http_request_t *r,
  200.     ngx_http_variable_value_t *v, uintptr_t data)
  201. {
  202.     if (r->spdy_stream) {
  203.         v->len = 1;
  204.         v->valid = 1;
  205.         v->no_cacheable = 0;
  206.         v->not_found = 0;

  208.         v->data = ngx_pnalloc(r->pool, 1);
  209.         if (v->data == NULL) {
  210.             return NGX_ERROR;
  211.         }

  213.         v->data[0] = '0' + (u_char) r->spdy_stream->priority;

  215.         return NGX_OK;
  216.     }

  218.     *v = ngx_http_variable_null_value;

  220.     return NGX_OK;
  221. }


  224. static ngx_int_t
  225. ‌ngx_http_spdy_module_init(ngx_cycle_t *cycle)
  226. {
  227.     ngx_http_spdy_request_headers_init();

  229.     return NGX_OK;
  230. }


  233. static void *
  234. ‌ngx_http_spdy_create_main_conf(ngx_conf_t *cf)
  235. {
  236.     ngx_http_spdy_main_conf_t  *smcf;

  238.     smcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_spdy_main_conf_t));
  239.     if (smcf == NULL) {
  240.         return NULL;
  241.     }

  243.     smcf->recv_buffer_size = NGX_CONF_UNSET_SIZE;

  245.     return smcf;
  246. }


  249. static char *
  250. ‌ngx_http_spdy_init_main_conf(ngx_conf_t *cf, void *conf)
  251. {
  252.     ngx_http_spdy_main_conf_t *smcf = conf;

  254.     ngx_conf_init_size_value(smcf->recv_buffer_size, 256 * 1024);

  256.     return NGX_CONF_OK;
  257. }


  260. static void *
  261. ‌ngx_http_spdy_create_srv_conf(ngx_conf_t *cf)
  262. {
  263.     ngx_http_spdy_srv_conf_t  *sscf;

  265.     sscf = ngx_pcalloc(cf->pool, sizeof(ngx_http_spdy_srv_conf_t));
  266.     if (sscf == NULL) {
  267.         return NULL;
  268.     }

  270.     sscf->pool_size = NGX_CONF_UNSET_SIZE;

  272.     sscf->concurrent_streams = NGX_CONF_UNSET_UINT;
  273.     sscf->streams_index_mask = NGX_CONF_UNSET_UINT;

  275.     sscf->recv_timeout = NGX_CONF_UNSET_MSEC;
  276.     sscf->keepalive_timeout = NGX_CONF_UNSET_MSEC;

  278.     sscf->headers_comp = NGX_CONF_UNSET;

  280.     return sscf;
  281. }


  284. static char *
  285. ‌ngx_http_spdy_merge_srv_conf(ngx_conf_t *cf, void *parent, void *child)
  286. {
  287.     ngx_http_spdy_srv_conf_t *prev = parent;
  288.     ngx_http_spdy_srv_conf_t *conf = child;

  290.     ngx_conf_merge_size_value(conf->pool_size, prev->pool_size, 4096);

  292.     ngx_conf_merge_uint_value(conf->concurrent_streams,
  293.                               prev->concurrent_streams, 100);

  295.     ngx_conf_merge_uint_value(conf->streams_index_mask,
  296.                               prev->streams_index_mask, 32 - 1);

  298.     ngx_conf_merge_msec_value(conf->recv_timeout,
  299.                               prev->recv_timeout, 30000);
  300.     ngx_conf_merge_msec_value(conf->keepalive_timeout,
  301.                               prev->keepalive_timeout, 180000);

  303.     ngx_conf_merge_value(conf->headers_comp, prev->headers_comp, 0);

  305.     return NGX_CONF_OK;
  306. }


  309. static void *
  310. ‌ngx_http_spdy_create_loc_conf(ngx_conf_t *cf)
  311. {
  312.     ngx_http_spdy_loc_conf_t  *slcf;

  314.     slcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_spdy_loc_conf_t));
  315.     if (slcf == NULL) {
  316.         return NULL;
  317.     }

  319.     slcf->chunk_size = NGX_CONF_UNSET_SIZE;

  321.     return slcf;
  322. }


  325. static char *
  326. ‌ngx_http_spdy_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  327. {
  328.     ngx_http_spdy_loc_conf_t *prev = parent;
  329.     ngx_http_spdy_loc_conf_t *conf = child;

  331.     ngx_conf_merge_size_value(conf->chunk_size, prev->chunk_size, 8 * 1024);

  333.     return NGX_CONF_OK;
  334. }


  337. static char *
  338. ‌ngx_http_spdy_recv_buffer_size(ngx_conf_t *cf, void *post, void *data)
  339. {
  340.     size_t *sp = data;

  342.     if (*sp <= 2 * NGX_SPDY_STATE_BUFFER_SIZE) {
  343.         return "value is too small";
  344.     }

  346.     return NGX_CONF_OK;
  347. }


  350. static char *
  351. ‌ngx_http_spdy_pool_size(ngx_conf_t *cf, void *post, void *data)
  352. {
  353.     size_t *sp = data;

  355.     if (*sp < NGX_MIN_POOL_SIZE) {
  356.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  357.                            "the pool size must be no less than %uz",
  358.                            NGX_MIN_POOL_SIZE);
  359.         return NGX_CONF_ERROR;
  360.     }

  362.     if (*sp % NGX_POOL_ALIGNMENT) {
  363.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  364.                            "the pool size must be a multiple of %uz",
  365.                            NGX_POOL_ALIGNMENT);
  366.         return NGX_CONF_ERROR;
  367.     }

  369.     return NGX_CONF_OK;
  370. }


  373. static char *
  374. ‌ngx_http_spdy_streams_index_mask(ngx_conf_t *cf, void *post, void *data)
  375. {
  376.     ngx_uint_t *np = data;

  378.     ngx_uint_t  mask;

  380.     mask = *np - 1;

  382.     if (*np == 0 || (*np & mask)) {
  383.         return "must be a power of two";
  384.     }

  386.     *np = mask;

  388.     return NGX_CONF_OK;
  389. }


  392. static char *
  393. ‌ngx_http_spdy_chunk_size(ngx_conf_t *cf, void *post, void *data)
  394. {
  395.     size_t *sp = data;

  397.     if (*sp == 0) {
  398.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  399.                            "the spdy chunk size cannot be zero");
  400.         return NGX_CONF_ERROR;
  401.     }

  403.     if (*sp > NGX_SPDY_MAX_FRAME_SIZE) {
  404.         *sp = NGX_SPDY_MAX_FRAME_SIZE;
  405.     }

  407.     return NGX_CONF_OK;
  408. }

One Level Up Top Level