One Level Up Top Level

src/http/ngx_http_spdy_filter_module.c - nginx-1.7.10

Global variables defined

Functions defined

Macros 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 <nginx.h>
  12. #include <ngx_http_spdy_module.h>

  14. #include <zlib.h>


  17. ‌#define ngx_http_spdy_nv_nsize(h)  (NGX_SPDY_NV_NLEN_SIZE + sizeof(h) - 1)
  18. ‌#define ngx_http_spdy_nv_vsize(h)  (NGX_SPDY_NV_VLEN_SIZE + sizeof(h) - 1)

  20. ‌#define ngx_http_spdy_nv_write_num   ngx_spdy_frame_write_uint32
  21. ‌#define ngx_http_spdy_nv_write_nlen  ngx_spdy_frame_write_uint32
  22. ‌#define ngx_http_spdy_nv_write_vlen  ngx_spdy_frame_write_uint32

  24. ‌#define ngx_http_spdy_nv_write_name(p, h)                                     \
  25.     ngx_cpymem(ngx_http_spdy_nv_write_nlen(p, sizeof(h) - 1), h, sizeof(h) - 1)

  27. ‌#define ngx_http_spdy_nv_write_val(p, h)                                      \
  28.     ngx_cpymem(ngx_http_spdy_nv_write_vlen(p, sizeof(h) - 1), h, sizeof(h) - 1)


  31. static ngx_chain_t *ngx_http_spdy_send_chain(ngx_connection_t *fc,
  32.     ngx_chain_t *in, off_t limit);

  34. static ngx_inline ngx_int_t ngx_http_spdy_filter_send(
  35.     ngx_connection_t *fc, ngx_http_spdy_stream_t *stream);
  36. static ngx_inline ngx_int_t ngx_http_spdy_flow_control(
  37.     ngx_http_spdy_connection_t *sc, ngx_http_spdy_stream_t *stream);
  38. static void ngx_http_spdy_waiting_queue(ngx_http_spdy_connection_t *sc,
  39.     ngx_http_spdy_stream_t *stream);

  41. static ngx_chain_t *ngx_http_spdy_filter_get_shadow(
  42.     ngx_http_spdy_stream_t *stream, ngx_buf_t *buf, off_t offset, off_t size);
  43. static ngx_http_spdy_out_frame_t *ngx_http_spdy_filter_get_data_frame(
  44.     ngx_http_spdy_stream_t *stream, size_t len, ngx_chain_t *first,
  45.     ngx_chain_t *last);

  47. static ngx_int_t ngx_http_spdy_syn_frame_handler(
  48.     ngx_http_spdy_connection_t *sc, ngx_http_spdy_out_frame_t *frame);
  49. static ngx_int_t ngx_http_spdy_data_frame_handler(
  50.     ngx_http_spdy_connection_t *sc, ngx_http_spdy_out_frame_t *frame);
  51. static ngx_inline void ngx_http_spdy_handle_frame(
  52.     ngx_http_spdy_stream_t *stream, ngx_http_spdy_out_frame_t *frame);
  53. static ngx_inline void ngx_http_spdy_handle_stream(
  54.     ngx_http_spdy_connection_t *sc, ngx_http_spdy_stream_t *stream);

  56. static void ngx_http_spdy_filter_cleanup(void *data);

  58. static ngx_int_t ngx_http_spdy_filter_init(ngx_conf_t *cf);


  61. ‌static ngx_http_module_t  ngx_http_spdy_filter_module_ctx = {
  62.     NULL,                                  /* preconfiguration */
  63.     ngx_http_spdy_filter_init,             /* postconfiguration */

  65.     NULL,                                  /* create main configuration */
  66.     NULL,                                  /* init main configuration */

  68.     NULL,                                  /* create server configuration */
  69.     NULL,                                  /* merge server configuration */

  71.     NULL,                                  /* create location configuration */
  72.     NULL                                   /* merge location configuration */
  73. };


  76. ‌ngx_module_t  ngx_http_spdy_filter_module = {
  77.     NGX_MODULE_V1,
  78.     &ngx_http_spdy_filter_module_ctx,      /* module context */
  79.     NULL,                                  /* module directives */
  80.     NGX_HTTP_MODULE,                       /* module type */
  81.     NULL,                                  /* init master */
  82.     NULL,                                  /* init module */
  83.     NULL,                                  /* init process */
  84.     NULL,                                  /* init thread */
  85.     NULL,                                  /* exit thread */
  86.     NULL,                                  /* exit process */
  87.     NULL,                                  /* exit master */
  88.     NGX_MODULE_V1_PADDING
  89. };


  92. ‌static ngx_http_output_header_filter_pt  ngx_http_next_header_filter;


  95. static ngx_int_t
  96. ‌ngx_http_spdy_header_filter(ngx_http_request_t *r)
  97. {
  98.     int                           rc;
  99.     size_t                        len;
  100.     u_char                       *p, *buf, *last;
  101.     ngx_buf_t                    *b;
  102.     ngx_str_t                     host;
  103.     ngx_uint_t                    i, j, count, port;
  104.     ngx_chain_t                  *cl;
  105.     ngx_list_part_t              *part, *pt;
  106.     ngx_table_elt_t              *header, *h;
  107.     ngx_connection_t             *c;
  108.     ngx_http_cleanup_t           *cln;
  109.     ngx_http_core_loc_conf_t     *clcf;
  110.     ngx_http_core_srv_conf_t     *cscf;
  111.     ngx_http_spdy_stream_t       *stream;
  112.     ngx_http_spdy_out_frame_t    *frame;
  113.     ngx_http_spdy_connection_t   *sc;
  114.     struct sockaddr_in           *sin;
  115. #if (NGX_HAVE_INET6)
  116.     struct sockaddr_in6          *sin6;
  117. #endif
  118.     u_char                        addr[NGX_SOCKADDR_STRLEN];

  120.     if (!r->spdy_stream) {
  121.         return ngx_http_next_header_filter(r);
  122.     }

  124.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  125.                    "spdy header filter");

  127.     if (r->header_sent) {
  128.         return NGX_OK;
  129.     }

  131.     r->header_sent = 1;

  133.     if (r != r->main) {
  134.         return NGX_OK;
  135.     }

  137.     c = r->connection;

  139.     if (r->method == NGX_HTTP_HEAD) {
  140.         r->header_only = 1;
  141.     }

  143.     switch (r->headers_out.status) {

  145.     case NGX_HTTP_OK:
  146.     case NGX_HTTP_PARTIAL_CONTENT:
  147.         break;

  149.     case NGX_HTTP_NOT_MODIFIED:
  150.         r->header_only = 1;
  151.         break;

  153.     case NGX_HTTP_NO_CONTENT:
  154.         r->header_only = 1;

  156.         ngx_str_null(&r->headers_out.content_type);

  158.         r->headers_out.content_length = NULL;
  159.         r->headers_out.content_length_n = -1;

  161.         /* fall through */

  163.     default:
  164.         r->headers_out.last_modified_time = -1;
  165.         r->headers_out.last_modified = NULL;
  166.     }

  168.     len = NGX_SPDY_NV_NUM_SIZE
  169.           + ngx_http_spdy_nv_nsize(":version")
  170.           + ngx_http_spdy_nv_vsize("HTTP/1.1")
  171.           + ngx_http_spdy_nv_nsize(":status")
  172.           + (r->headers_out.status_line.len
  173.              ? NGX_SPDY_NV_VLEN_SIZE + r->headers_out.status_line.len
  174.              : ngx_http_spdy_nv_vsize("418"));

  176.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  178.     if (r->headers_out.server == NULL) {
  179.         len += ngx_http_spdy_nv_nsize("server");
  180.         len += clcf->server_tokens ? ngx_http_spdy_nv_vsize(NGINX_VER)
  181.                                    : ngx_http_spdy_nv_vsize("nginx");
  182.     }

  184.     if (r->headers_out.date == NULL) {
  185.         len += ngx_http_spdy_nv_nsize("date")
  186.                + ngx_http_spdy_nv_vsize("Wed, 31 Dec 1986 10:00:00 GMT");
  187.     }

  189.     if (r->headers_out.content_type.len) {
  190.         len += ngx_http_spdy_nv_nsize("content-type")
  191.                + NGX_SPDY_NV_VLEN_SIZE + r->headers_out.content_type.len;

  193.         if (r->headers_out.content_type_len == r->headers_out.content_type.len
  194.             && r->headers_out.charset.len)
  195.         {
  196.             len += sizeof("; charset=") - 1 + r->headers_out.charset.len;
  197.         }
  198.     }

  200.     if (r->headers_out.content_length == NULL
  201.         && r->headers_out.content_length_n >= 0)
  202.     {
  203.         len += ngx_http_spdy_nv_nsize("content-length")
  204.                + NGX_SPDY_NV_VLEN_SIZE + NGX_OFF_T_LEN;
  205.     }

  207.     if (r->headers_out.last_modified == NULL
  208.         && r->headers_out.last_modified_time != -1)
  209.     {
  210.         len += ngx_http_spdy_nv_nsize("last-modified")
  211.                + ngx_http_spdy_nv_vsize("Wed, 31 Dec 1986 10:00:00 GMT");
  212.     }

  214.     if (r->headers_out.location
  215.         && r->headers_out.location->value.len
  216.         && r->headers_out.location->value.data[0] == '/')
  217.     {
  218.         r->headers_out.location->hash = 0;

  220.         if (clcf->server_name_in_redirect) {
  221.             cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  222.             host = cscf->server_name;

  224.         } else if (r->headers_in.server.len) {
  225.             host = r->headers_in.server;

  227.         } else {
  228.             host.len = NGX_SOCKADDR_STRLEN;
  229.             host.data = addr;

  231.             if (ngx_connection_local_sockaddr(c, &host, 0) != NGX_OK) {
  232.                 return NGX_ERROR;
  233.             }
  234.         }

  236.         switch (c->local_sockaddr->sa_family) {

  238. #if (NGX_HAVE_INET6)
  239.         case AF_INET6:
  240.             sin6 = (struct sockaddr_in6 *) c->local_sockaddr;
  241.             port = ntohs(sin6->sin6_port);
  242.             break;
  243. #endif
  244. #if (NGX_HAVE_UNIX_DOMAIN)
  245.         case AF_UNIX:
  246.             port = 0;
  247.             break;
  248. #endif
  249.         default: /* AF_INET */
  250.             sin = (struct sockaddr_in *) c->local_sockaddr;
  251.             port = ntohs(sin->sin_port);
  252.             break;
  253.         }

  255.         len += ngx_http_spdy_nv_nsize("location")
  256.                + ngx_http_spdy_nv_vsize("https://")
  257.                + host.len
  258.                + r->headers_out.location->value.len;

  260.         if (clcf->port_in_redirect) {

  262. #if (NGX_HTTP_SSL)
  263.             if (c->ssl)
  264.                 port = (port == 443) ? 0 : port;
  265.             else
  266. #endif
  267.                 port = (port == 80) ? 0 : port;

  269.         } else {
  270.             port = 0;
  271.         }

  273.         if (port) {
  274.             len += sizeof(":65535") - 1;
  275.         }

  277.     } else {
  278.         ngx_str_null(&host);
  279.         port = 0;
  280.     }

  282.     part = &r->headers_out.headers.part;
  283.     header = part->elts;

  285.     for (i = 0; /* void */; i++) {

  287.         if (i >= part->nelts) {
  288.             if (part->next == NULL) {
  289.                 break;
  290.             }

  292.             part = part->next;
  293.             header = part->elts;
  294.             i = 0;
  295.         }

  297.         if (header[i].hash == 0) {
  298.             continue;
  299.         }

  301.         len += NGX_SPDY_NV_NLEN_SIZE + header[i].key.len
  302.                + NGX_SPDY_NV_VLEN_SIZE  + header[i].value.len;
  303.     }

  305.     buf = ngx_alloc(len, r->pool->log);
  306.     if (buf == NULL) {
  307.         return NGX_ERROR;
  308.     }

  310.     last = buf + NGX_SPDY_NV_NUM_SIZE;

  312.     last = ngx_http_spdy_nv_write_name(last, ":version");
  313.     last = ngx_http_spdy_nv_write_val(last, "HTTP/1.1");

  315.     last = ngx_http_spdy_nv_write_name(last, ":status");

  317.     if (r->headers_out.status_line.len) {
  318.         last = ngx_http_spdy_nv_write_vlen(last,
  319.                                            r->headers_out.status_line.len);
  320.         last = ngx_cpymem(last, r->headers_out.status_line.data,
  321.                           r->headers_out.status_line.len);
  322.     } else {
  323.         last = ngx_http_spdy_nv_write_vlen(last, 3);
  324.         last = ngx_sprintf(last, "%03ui", r->headers_out.status);
  325.     }

  327.     count = 2;

  329.     if (r->headers_out.server == NULL) {
  330.         last = ngx_http_spdy_nv_write_name(last, "server");
  331.         last = clcf->server_tokens
  332.                ? ngx_http_spdy_nv_write_val(last, NGINX_VER)
  333.                : ngx_http_spdy_nv_write_val(last, "nginx");

  335.         count++;
  336.     }

  338.     if (r->headers_out.date == NULL) {
  339.         last = ngx_http_spdy_nv_write_name(last, "date");

  341.         last = ngx_http_spdy_nv_write_vlen(last, ngx_cached_http_time.len);

  343.         last = ngx_cpymem(last, ngx_cached_http_time.data,
  344.                           ngx_cached_http_time.len);

  346.         count++;
  347.     }

  349.     if (r->headers_out.content_type.len) {

  351.         last = ngx_http_spdy_nv_write_name(last, "content-type");

  353.         p = last + NGX_SPDY_NV_VLEN_SIZE;

  355.         last = ngx_cpymem(p, r->headers_out.content_type.data,
  356.                           r->headers_out.content_type.len);

  358.         if (r->headers_out.content_type_len == r->headers_out.content_type.len
  359.             && r->headers_out.charset.len)
  360.         {
  361.             last = ngx_cpymem(last, "; charset=", sizeof("; charset=") - 1);

  363.             last = ngx_cpymem(last, r->headers_out.charset.data,
  364.                               r->headers_out.charset.len);

  366.             /* update r->headers_out.content_type for possible logging */

  368.             r->headers_out.content_type.len = last - p;
  369.             r->headers_out.content_type.data = p;
  370.         }

  372.         (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
  373.                                            r->headers_out.content_type.len);

  375.         count++;
  376.     }

  378.     if (r->headers_out.content_length == NULL
  379.         && r->headers_out.content_length_n >= 0)
  380.     {
  381.         last = ngx_http_spdy_nv_write_name(last, "content-length");

  383.         p = last + NGX_SPDY_NV_VLEN_SIZE;

  385.         last = ngx_sprintf(p, "%O", r->headers_out.content_length_n);

  387.         (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
  388.                                            last - p);

  390.         count++;
  391.     }

  393.     if (r->headers_out.last_modified == NULL
  394.         && r->headers_out.last_modified_time != -1)
  395.     {
  396.         last = ngx_http_spdy_nv_write_name(last, "last-modified");

  398.         p = last + NGX_SPDY_NV_VLEN_SIZE;

  400.         last = ngx_http_time(p, r->headers_out.last_modified_time);

  402.         (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
  403.                                            last - p);

  405.         count++;
  406.     }

  408.     if (host.data) {

  410.         last = ngx_http_spdy_nv_write_name(last, "location");

  412.         p = last + NGX_SPDY_NV_VLEN_SIZE;

  414.         last = ngx_cpymem(p, "http", sizeof("http") - 1);

  416. #if (NGX_HTTP_SSL)
  417.         if (c->ssl) {
  418.             *last++ ='s';
  419.         }
  420. #endif

  422.         *last++ = ':'; *last++ = '/'; *last++ = '/';

  424.         last = ngx_cpymem(last, host.data, host.len);

  426.         if (port) {
  427.             last = ngx_sprintf(last, ":%ui", port);
  428.         }

  430.         last = ngx_cpymem(last, r->headers_out.location->value.data,
  431.                           r->headers_out.location->value.len);

  433.         /* update r->headers_out.location->value for possible logging */

  435.         r->headers_out.location->value.len = last - p;
  436.         r->headers_out.location->value.data = p;
  437.         ngx_str_set(&r->headers_out.location->key, "location");

  439.         (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
  440.                                            r->headers_out.location->value.len);

  442.         count++;
  443.     }

  445.     part = &r->headers_out.headers.part;
  446.     header = part->elts;

  448.     for (i = 0; /* void */; i++) {

  450.         if (i >= part->nelts) {
  451.             if (part->next == NULL) {
  452.                 break;
  453.             }

  455.             part = part->next;
  456.             header = part->elts;
  457.             i = 0;
  458.         }

  460.         if (header[i].hash == 0 || header[i].hash == 2) {
  461.             continue;
  462.         }

  464.         last = ngx_http_spdy_nv_write_nlen(last, header[i].key.len);

  466.         ngx_strlow(last, header[i].key.data, header[i].key.len);
  467.         last += header[i].key.len;

  469.         p = last + NGX_SPDY_NV_VLEN_SIZE;

  471.         last = ngx_cpymem(p, header[i].value.data, header[i].value.len);

  473.         pt = part;
  474.         h = header;

  476.         for (j = i + 1; /* void */; j++) {

  478.             if (j >= pt->nelts) {
  479.                 if (pt->next == NULL) {
  480.                     break;
  481.                 }

  483.                 pt = pt->next;
  484.                 h = pt->elts;
  485.                 j = 0;
  486.             }

  488.             if (h[j].hash == 0 || h[j].hash == 2
  489.                 || h[j].key.len != header[i].key.len
  490.                 || ngx_strncasecmp(header[i].key.data, h[j].key.data,
  491.                                    header[i].key.len))
  492.             {
  493.                 continue;
  494.             }

  496.             if (h[j].value.len) {
  497.                 if (last != p) {
  498.                     *last++ = '\0';
  499.                 }

  501.                 last = ngx_cpymem(last, h[j].value.data, h[j].value.len);
  502.             }

  504.             h[j].hash = 2;
  505.         }

  507.         (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
  508.                                            last - p);

  510.         count++;
  511.     }

  513.     (void) ngx_http_spdy_nv_write_num(buf, count);

  515.     stream = r->spdy_stream;
  516.     sc = stream->connection;

  518.     len = last - buf;

  520.     b = ngx_create_temp_buf(r->pool, NGX_SPDY_FRAME_HEADER_SIZE
  521.                                      + NGX_SPDY_SYN_REPLY_SIZE
  522.                                      + deflateBound(&sc->zstream_out, len));
  523.     if (b == NULL) {
  524.         ngx_free(buf);
  525.         return NGX_ERROR;
  526.     }

  528.     b->last += NGX_SPDY_FRAME_HEADER_SIZE + NGX_SPDY_SYN_REPLY_SIZE;

  530.     sc->zstream_out.next_in = buf;
  531.     sc->zstream_out.avail_in = len;
  532.     sc->zstream_out.next_out = b->last;
  533.     sc->zstream_out.avail_out = b->end - b->last;

  535.     rc = deflate(&sc->zstream_out, Z_SYNC_FLUSH);

  537.     ngx_free(buf);

  539.     if (rc != Z_OK) {
  540.         ngx_log_error(NGX_LOG_ALERT, c->log, 0, "deflate() failed: %d", rc);
  541.         return NGX_ERROR;
  542.     }

  544.     ngx_log_debug5(NGX_LOG_DEBUG_HTTP, c->log, 0,
  545.                    "spdy deflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
  546.                    sc->zstream_out.next_in, sc->zstream_out.next_out,
  547.                    sc->zstream_out.avail_in, sc->zstream_out.avail_out,
  548.                    rc);

  550.     b->last = sc->zstream_out.next_out;

  552.     p = b->pos;
  553.     p = ngx_spdy_frame_write_head(p, NGX_SPDY_SYN_REPLY);

  555.     len = b->last - b->pos;

  557.     r->header_size = len;

  559.     len -= NGX_SPDY_FRAME_HEADER_SIZE;

  561.     if (r->header_only) {
  562.         b->last_buf = 1;
  563.         p = ngx_spdy_frame_write_flags_and_len(p, NGX_SPDY_FLAG_FIN, len);

  565.     } else {
  566.         p = ngx_spdy_frame_write_flags_and_len(p, 0, len);
  567.     }

  569.     (void) ngx_spdy_frame_write_sid(p, stream->id);

  571.     cl = ngx_alloc_chain_link(r->pool);
  572.     if (cl == NULL) {
  573.         return NGX_ERROR;
  574.     }

  576.     cl->buf = b;
  577.     cl->next = NULL;

  579.     frame = ngx_palloc(r->pool, sizeof(ngx_http_spdy_out_frame_t));
  580.     if (frame == NULL) {
  581.         return NGX_ERROR;
  582.     }

  584.     frame->first = cl;
  585.     frame->last = cl;
  586.     frame->handler = ngx_http_spdy_syn_frame_handler;
  587.     frame->stream = stream;
  588.     frame->length = len;
  589.     frame->priority = stream->priority;
  590.     frame->blocked = 1;
  591.     frame->fin = r->header_only;

  593.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, stream->request->connection->log, 0,
  594.                    "spdy:%ui create SYN_REPLY frame %p: len:%uz",
  595.                    stream->id, frame, frame->length);

  597.     ngx_http_spdy_queue_blocked_frame(sc, frame);

  599.     cln = ngx_http_cleanup_add(r, 0);
  600.     if (cln == NULL) {
  601.         return NGX_ERROR;
  602.     }

  604.     cln->handler = ngx_http_spdy_filter_cleanup;
  605.     cln->data = stream;

  607.     stream->queued = 1;

  609.     c->send_chain = ngx_http_spdy_send_chain;
  610.     c->need_last_buf = 1;

  612.     return ngx_http_spdy_filter_send(c, stream);
  613. }


  616. static ngx_chain_t *
  617. ‌ngx_http_spdy_send_chain(ngx_connection_t *fc, ngx_chain_t *in, off_t limit)
  618. {
  619.     off_t                        size, offset;
  620.     size_t                       rest, frame_size;
  621.     ngx_chain_t                 *cl, *out, **ln;
  622.     ngx_http_request_t          *r;
  623.     ngx_http_spdy_stream_t      *stream;
  624.     ngx_http_spdy_loc_conf_t    *slcf;
  625.     ngx_http_spdy_out_frame_t   *frame;
  626.     ngx_http_spdy_connection_t  *sc;

  628.     r = fc->data;
  629.     stream = r->spdy_stream;

  631. #if (NGX_SUPPRESS_WARN)
  632.     size = 0;
  633. #endif

  635.     while (in) {
  636.         size = ngx_buf_size(in->buf);

  638.         if (size || in->buf->last_buf) {
  639.             break;
  640.         }

  642.         in = in->next;
  643.     }

  645.     if (in == NULL) {

  647.         if (stream->queued) {
  648.             fc->write->delayed = 1;
  649.         } else {
  650.             fc->buffered &= ~NGX_SPDY_BUFFERED;
  651.         }

  653.         return NULL;
  654.     }

  656.     sc = stream->connection;

  658.     if (size && ngx_http_spdy_flow_control(sc, stream) == NGX_DECLINED) {
  659.         fc->write->delayed = 1;
  660.         return in;
  661.     }

  663.     if (limit == 0 || limit > (off_t) sc->send_window) {
  664.         limit = sc->send_window;
  665.     }

  667.     if (limit > stream->send_window) {
  668.         limit = (stream->send_window > 0) ? stream->send_window : 0;
  669.     }

  671.     if (in->buf->tag == (ngx_buf_tag_t) &ngx_http_spdy_filter_get_shadow) {
  672.         cl = ngx_alloc_chain_link(r->pool);
  673.         if (cl == NULL) {
  674.             return NGX_CHAIN_ERROR;
  675.         }

  677.         cl->buf = in->buf;
  678.         in->buf = cl->buf->shadow;

  680.         offset = ngx_buf_in_memory(in->buf)
  681.                  ? (cl->buf->pos - in->buf->pos)
  682.                  : (cl->buf->file_pos - in->buf->file_pos);

  684.         cl->next = stream->free_bufs;
  685.         stream->free_bufs = cl;

  687.     } else {
  688.         offset = 0;
  689.     }

  691. #if (NGX_SUPPRESS_WARN)
  692.     cl = NULL;
  693. #endif

  695.     slcf = ngx_http_get_module_loc_conf(r, ngx_http_spdy_module);

  697.     frame_size = (limit <= (off_t) slcf->chunk_size) ? (size_t) limit
  698.                                                      : slcf->chunk_size;

  700.     for ( ;; ) {
  701.         ln = &out;
  702.         rest = frame_size;

  704.         while ((off_t) rest >= size) {

  706.             if (offset) {
  707.                 cl = ngx_http_spdy_filter_get_shadow(stream, in->buf,
  708.                                                      offset, size);
  709.                 if (cl == NULL) {
  710.                     return NGX_CHAIN_ERROR;
  711.                 }

  713.                 offset = 0;

  715.             } else {
  716.                 cl = ngx_alloc_chain_link(r->pool);
  717.                 if (cl == NULL) {
  718.                     return NGX_CHAIN_ERROR;
  719.                 }

  721.                 cl->buf = in->buf;
  722.             }

  724.             *ln = cl;
  725.             ln = &cl->next;

  727.             rest -= (size_t) size;
  728.             in = in->next;

  730.             if (in == NULL) {
  731.                 frame_size -= rest;
  732.                 rest = 0;
  733.                 break;
  734.             }

  736.             size = ngx_buf_size(in->buf);
  737.         }

  739.         if (rest) {
  740.             cl = ngx_http_spdy_filter_get_shadow(stream, in->buf,
  741.                                                  offset, rest);
  742.             if (cl == NULL) {
  743.                 return NGX_CHAIN_ERROR;
  744.             }

  746.             cl->buf->flush = 0;
  747.             cl->buf->last_buf = 0;

  749.             *ln = cl;

  751.             offset += rest;
  752.             size -= rest;
  753.         }

  755.         frame = ngx_http_spdy_filter_get_data_frame(stream, frame_size,
  756.                                                     out, cl);
  757.         if (frame == NULL) {
  758.             return NGX_CHAIN_ERROR;
  759.         }

  761.         ngx_http_spdy_queue_frame(sc, frame);

  763.         sc->send_window -= frame_size;

  765.         stream->send_window -= frame_size;
  766.         stream->queued++;

  768.         if (in == NULL) {
  769.             break;
  770.         }

  772.         limit -= frame_size;

  774.         if (limit == 0) {
  775.             break;
  776.         }

  778.         if (limit < (off_t) slcf->chunk_size) {
  779.             frame_size = (size_t) limit;
  780.         }
  781.     }

  783.     if (offset) {
  784.         cl = ngx_http_spdy_filter_get_shadow(stream, in->buf, offset, size);
  785.         if (cl == NULL) {
  786.             return NGX_CHAIN_ERROR;
  787.         }

  789.         in->buf = cl->buf;
  790.         ngx_free_chain(r->pool, cl);
  791.     }

  793.     if (ngx_http_spdy_filter_send(fc, stream) == NGX_ERROR) {
  794.         return NGX_CHAIN_ERROR;
  795.     }

  797.     if (in && ngx_http_spdy_flow_control(sc, stream) == NGX_DECLINED) {
  798.         fc->write->delayed = 1;
  799.     }

  801.     return in;
  802. }


  805. static ngx_chain_t *
  806. ‌ngx_http_spdy_filter_get_shadow(ngx_http_spdy_stream_t *stream, ngx_buf_t *buf,
  807.     off_t offset, off_t size)
  808. {
  809.     ngx_buf_t    *chunk;
  810.     ngx_chain_t  *cl;

  812.     cl = ngx_chain_get_free_buf(stream->request->pool, &stream->free_bufs);
  813.     if (cl == NULL) {
  814.         return NULL;
  815.     }

  817.     chunk = cl->buf;

  819.     ngx_memcpy(chunk, buf, sizeof(ngx_buf_t));

  821.     chunk->tag = (ngx_buf_tag_t) &ngx_http_spdy_filter_get_shadow;
  822.     chunk->shadow = buf;

  824.     if (ngx_buf_in_memory(chunk)) {
  825.         chunk->pos += offset;
  826.         chunk->last = chunk->pos + size;
  827.     }

  829.     if (chunk->in_file) {
  830.         chunk->file_pos += offset;
  831.         chunk->file_last = chunk->file_pos + size;
  832.     }

  834.     return cl;
  835. }


  838. static ngx_http_spdy_out_frame_t *
  839. ‌ngx_http_spdy_filter_get_data_frame(ngx_http_spdy_stream_t *stream,
  840.     size_t len, ngx_chain_t *first, ngx_chain_t *last)
  841. {
  842.     u_char                     *p;
  843.     ngx_buf_t                  *buf;
  844.     ngx_uint_t                  flags;
  845.     ngx_chain_t                *cl;
  846.     ngx_http_spdy_out_frame_t  *frame;


  849.     frame = stream->free_frames;

  851.     if (frame) {
  852.         stream->free_frames = frame->next;

  854.     } else {
  855.         frame = ngx_palloc(stream->request->pool,
  856.                            sizeof(ngx_http_spdy_out_frame_t));
  857.         if (frame == NULL) {
  858.             return NULL;
  859.         }
  860.     }

  862.     flags = last->buf->last_buf ? NGX_SPDY_FLAG_FIN : 0;

  864.     ngx_log_debug4(NGX_LOG_DEBUG_HTTP, stream->request->connection->log, 0,
  865.                    "spdy:%ui create DATA frame %p: len:%uz flags:%ui",
  866.                    stream->id, frame, len, flags);

  868.     cl = ngx_chain_get_free_buf(stream->request->pool,
  869.                                 &stream->free_data_headers);
  870.     if (cl == NULL) {
  871.         return NULL;
  872.     }

  874.     buf = cl->buf;

  876.     if (buf->start) {
  877.         p = buf->start;
  878.         buf->pos = p;

  880.         p += NGX_SPDY_SID_SIZE;

  882.         (void) ngx_spdy_frame_write_flags_and_len(p, flags, len);

  884.     } else {
  885.         p = ngx_palloc(stream->request->pool, NGX_SPDY_FRAME_HEADER_SIZE);
  886.         if (p == NULL) {
  887.             return NULL;
  888.         }

  890.         buf->pos = p;
  891.         buf->start = p;

  893.         p = ngx_spdy_frame_write_sid(p, stream->id);
  894.         p = ngx_spdy_frame_write_flags_and_len(p, flags, len);

  896.         buf->last = p;
  897.         buf->end = p;

  899.         buf->tag = (ngx_buf_tag_t) &ngx_http_spdy_filter_get_data_frame;
  900.         buf->memory = 1;
  901.     }

  903.     cl->next = first;
  904.     first = cl;

  906.     last->buf->flush = 1;

  908.     frame->first = first;
  909.     frame->last = last;
  910.     frame->handler = ngx_http_spdy_data_frame_handler;
  911.     frame->stream = stream;
  912.     frame->length = len;
  913.     frame->priority = stream->priority;
  914.     frame->blocked = 0;
  915.     frame->fin = last->buf->last_buf;

  917.     return frame;
  918. }


  921. static ngx_inline ngx_int_t
  922. ‌ngx_http_spdy_filter_send(ngx_connection_t *fc, ngx_http_spdy_stream_t *stream)
  923. {
  924.     stream->blocked = 1;

  926.     if (ngx_http_spdy_send_output_queue(stream->connection) == NGX_ERROR) {
  927.         fc->error = 1;
  928.         return NGX_ERROR;
  929.     }

  931.     stream->blocked = 0;

  933.     if (stream->queued) {
  934.         fc->buffered |= NGX_SPDY_BUFFERED;
  935.         fc->write->delayed = 1;
  936.         return NGX_AGAIN;
  937.     }

  939.     fc->buffered &= ~NGX_SPDY_BUFFERED;

  941.     return NGX_OK;
  942. }


  945. static ngx_inline ngx_int_t
  946. ‌ngx_http_spdy_flow_control(ngx_http_spdy_connection_t *sc,
  947.     ngx_http_spdy_stream_t *stream)
  948. {
  949.     if (stream->send_window <= 0) {
  950.         stream->exhausted = 1;
  951.         return NGX_DECLINED;
  952.     }

  954.     if (sc->send_window == 0) {
  955.         ngx_http_spdy_waiting_queue(sc, stream);
  956.         return NGX_DECLINED;
  957.     }

  959.     return NGX_OK;
  960. }


  963. static void
  964. ‌ngx_http_spdy_waiting_queue(ngx_http_spdy_connection_t *sc,
  965.     ngx_http_spdy_stream_t *stream)
  966. {
  967.     ngx_queue_t             *q;
  968.     ngx_http_spdy_stream_t  *s;

  970.     if (stream->handled) {
  971.         return;
  972.     }

  974.     stream->handled = 1;

  976.     for (q = ngx_queue_last(&sc->waiting);
  977.          q != ngx_queue_sentinel(&sc->waiting);
  978.          q = ngx_queue_prev(q))
  979.     {
  980.         s = ngx_queue_data(q, ngx_http_spdy_stream_t, queue);

  982.         /*
  983.          * NB: higher values represent lower priorities.
  984.          */
  985.         if (stream->priority >= s->priority) {
  986.             break;
  987.         }
  988.     }

  990.     ngx_queue_insert_after(q, &stream->queue);
  991. }


  994. static ngx_int_t
  995. ‌ngx_http_spdy_syn_frame_handler(ngx_http_spdy_connection_t *sc,
  996.     ngx_http_spdy_out_frame_t *frame)
  997. {
  998.     ngx_buf_t               *buf;
  999.     ngx_http_spdy_stream_t  *stream;

  1001.     buf = frame->first->buf;

  1003.     if (buf->pos != buf->last) {
  1004.         return NGX_AGAIN;
  1005.     }

  1007.     stream = frame->stream;

  1009.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
  1010.                    "spdy:%ui SYN_REPLY frame %p was sent", stream->id, frame);

  1012.     ngx_free_chain(stream->request->pool, frame->first);

  1014.     ngx_http_spdy_handle_frame(stream, frame);

  1016.     ngx_http_spdy_handle_stream(sc, stream);

  1018.     return NGX_OK;
  1019. }


  1022. static ngx_int_t
  1023. ‌ngx_http_spdy_data_frame_handler(ngx_http_spdy_connection_t *sc,
  1024.     ngx_http_spdy_out_frame_t *frame)
  1025. {
  1026.     ngx_buf_t               *buf;
  1027.     ngx_chain_t             *cl, *ln;
  1028.     ngx_http_spdy_stream_t  *stream;

  1030.     stream = frame->stream;

  1032.     cl = frame->first;

  1034.     if (cl->buf->tag == (ngx_buf_tag_t) &ngx_http_spdy_filter_get_data_frame) {

  1036.         if (cl->buf->pos != cl->buf->last) {
  1037.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
  1038.                            "spdy:%ui DATA frame %p was sent partially",
  1039.                            stream->id, frame);

  1041.             return NGX_AGAIN;
  1042.         }

  1044.         ln = cl->next;

  1046.         cl->next = stream->free_data_headers;
  1047.         stream->free_data_headers = cl;

  1049.         if (cl == frame->last) {
  1050.             goto done;
  1051.         }

  1053.         cl = ln;
  1054.     }

  1056.     for ( ;; ) {
  1057.         if (cl->buf->tag == (ngx_buf_tag_t) &ngx_http_spdy_filter_get_shadow) {
  1058.             buf = cl->buf->shadow;

  1060.             if (ngx_buf_in_memory(buf)) {
  1061.                 buf->pos = cl->buf->pos;
  1062.             }

  1064.             if (buf->in_file) {
  1065.                 buf->file_pos = cl->buf->file_pos;
  1066.             }
  1067.         }

  1069.         if (ngx_buf_size(cl->buf) != 0) {

  1071.             if (cl != frame->first) {
  1072.                 frame->first = cl;
  1073.                 ngx_http_spdy_handle_stream(sc, stream);
  1074.             }

  1076.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
  1077.                            "spdy:%ui DATA frame %p was sent partially",
  1078.                            stream->id, frame);

  1080.             return NGX_AGAIN;
  1081.         }

  1083.         ln = cl->next;

  1085.         if (cl->buf->tag == (ngx_buf_tag_t) &ngx_http_spdy_filter_get_shadow) {
  1086.             cl->next = stream->free_bufs;
  1087.             stream->free_bufs = cl;

  1089.         } else {
  1090.             ngx_free_chain(stream->request->pool, cl);
  1091.         }

  1093.         if (cl == frame->last) {
  1094.             goto done;
  1095.         }

  1097.         cl = ln;
  1098.     }

  1100. done:

  1102.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
  1103.                    "spdy:%ui DATA frame %p was sent", stream->id, frame);

  1105.     stream->request->header_size += NGX_SPDY_FRAME_HEADER_SIZE;

  1107.     ngx_http_spdy_handle_frame(stream, frame);

  1109.     ngx_http_spdy_handle_stream(sc, stream);

  1111.     return NGX_OK;
  1112. }


  1115. static ngx_inline void
  1116. ‌ngx_http_spdy_handle_frame(ngx_http_spdy_stream_t *stream,
  1117.     ngx_http_spdy_out_frame_t *frame)
  1118. {
  1119.     ngx_http_request_t  *r;

  1121.     r = stream->request;

  1123.     r->connection->sent += NGX_SPDY_FRAME_HEADER_SIZE + frame->length;

  1125.     if (frame->fin) {
  1126.         stream->out_closed = 1;
  1127.     }

  1129.     frame->next = stream->free_frames;
  1130.     stream->free_frames = frame;

  1132.     stream->queued--;
  1133. }


  1136. static ngx_inline void
  1137. ‌ngx_http_spdy_handle_stream(ngx_http_spdy_connection_t *sc,
  1138.     ngx_http_spdy_stream_t *stream)
  1139. {
  1140.     ngx_event_t  *wev;

  1142.     if (stream->handled || stream->blocked || stream->exhausted) {
  1143.         return;
  1144.     }

  1146.     wev = stream->request->connection->write;

  1148.     /*
  1149.      * This timer can only be set if the stream was delayed because of rate
  1150.      * limit.  In that case the event should be triggered by the timer.
  1151.      */

  1153.     if (!wev->timer_set) {
  1154.         wev->delayed = 0;

  1156.         stream->handled = 1;
  1157.         ngx_queue_insert_tail(&sc->posted, &stream->queue);
  1158.     }
  1159. }


  1162. static void
  1163. ‌ngx_http_spdy_filter_cleanup(void *data)
  1164. {
  1165.     ngx_http_spdy_stream_t *stream = data;

  1167.     size_t                       delta;
  1168.     ngx_http_spdy_out_frame_t   *frame, **fn;
  1169.     ngx_http_spdy_connection_t  *sc;

  1171.     if (stream->handled) {
  1172.         stream->handled = 0;
  1173.         ngx_queue_remove(&stream->queue);
  1174.     }

  1176.     if (stream->queued == 0) {
  1177.         return;
  1178.     }

  1180.     delta = 0;
  1181.     sc = stream->connection;
  1182.     fn = &sc->last_out;

  1184.     for ( ;; ) {
  1185.         frame = *fn;

  1187.         if (frame == NULL) {
  1188.             break;
  1189.         }

  1191.         if (frame->stream == stream && !frame->blocked) {
  1192.             *fn = frame->next;

  1194.             delta += frame->length;

  1196.             if (--stream->queued == 0) {
  1197.                 break;
  1198.             }

  1200.             continue;
  1201.         }

  1203.         fn = &frame->next;
  1204.     }

  1206.     if (sc->send_window == 0 && delta && !ngx_queue_empty(&sc->waiting)) {
  1207.         ngx_queue_add(&sc->posted, &sc->waiting);
  1208.         ngx_queue_init(&sc->waiting);
  1209.     }

  1211.     sc->send_window += delta;
  1212. }


  1215. static ngx_int_t
  1216. ‌ngx_http_spdy_filter_init(ngx_conf_t *cf)
  1217. {
  1218.     ngx_http_next_header_filter = ngx_http_top_header_filter;
  1219.     ngx_http_top_header_filter = ngx_http_spdy_header_filter;

  1221.     return NGX_OK;
  1222. }

One Level Up Top Level