Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
ngx_http_spdy_filter_module.c
Go to the documentation of this file.
1 
2 /*
3  * Copyright (C) Nginx, Inc.
4  * Copyright (C) Valentin V. Bartenev
5  */
6 
7 
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>
13 
14 #include <zlib.h>
15 
16 
17 #define NGX_SPDY_WRITE_BUFFERED NGX_HTTP_WRITE_BUFFERED
18 
19 #define ngx_http_spdy_nv_nsize(h) (NGX_SPDY_NV_NLEN_SIZE + sizeof(h) - 1)
20 #define ngx_http_spdy_nv_vsize(h) (NGX_SPDY_NV_VLEN_SIZE + sizeof(h) - 1)
21 
22 #define ngx_http_spdy_nv_write_num ngx_spdy_frame_write_uint16
23 #define ngx_http_spdy_nv_write_nlen ngx_spdy_frame_write_uint16
24 #define ngx_http_spdy_nv_write_vlen ngx_spdy_frame_write_uint16
25 
26 #define ngx_http_spdy_nv_write_name(p, h) \
27  ngx_cpymem(ngx_http_spdy_nv_write_nlen(p, sizeof(h) - 1), h, sizeof(h) - 1)
28 
29 #define ngx_http_spdy_nv_write_val(p, h) \
30  ngx_cpymem(ngx_http_spdy_nv_write_vlen(p, sizeof(h) - 1), h, sizeof(h) - 1)
31 
32 static ngx_inline ngx_int_t ngx_http_spdy_filter_send(
33  ngx_connection_t *fc, ngx_http_spdy_stream_t *stream);
34 
35 static ngx_http_spdy_out_frame_t *ngx_http_spdy_filter_get_data_frame(
36  ngx_http_spdy_stream_t *stream, size_t len, ngx_uint_t flags,
37  ngx_chain_t *first, ngx_chain_t *last);
38 
39 static ngx_int_t ngx_http_spdy_syn_frame_handler(
40  ngx_http_spdy_connection_t *sc, ngx_http_spdy_out_frame_t *frame);
41 static ngx_int_t ngx_http_spdy_data_frame_handler(
42  ngx_http_spdy_connection_t *sc, ngx_http_spdy_out_frame_t *frame);
43 static ngx_inline void ngx_http_spdy_handle_frame(
44  ngx_http_spdy_stream_t *stream, ngx_http_spdy_out_frame_t *frame);
45 static ngx_inline void ngx_http_spdy_handle_stream(
46  ngx_http_spdy_connection_t *sc, ngx_http_spdy_stream_t *stream);
47 
48 static void ngx_http_spdy_filter_cleanup(void *data);
49 
50 static ngx_int_t ngx_http_spdy_filter_init(ngx_conf_t *cf);
51 
52 
53 static ngx_http_module_t ngx_http_spdy_filter_module_ctx = {
54  NULL, /* preconfiguration */
55  ngx_http_spdy_filter_init, /* postconfiguration */
56 
57  NULL, /* create main configuration */
58  NULL, /* init main configuration */
59 
60  NULL, /* create server configuration */
61  NULL, /* merge server configuration */
62 
63  NULL, /* create location configuration */
64  NULL /* merge location configuration */
65 };
66 
67 
68 ngx_module_t ngx_http_spdy_filter_module = {
69  NGX_MODULE_V1,
70  &ngx_http_spdy_filter_module_ctx, /* module context */
71  NULL, /* module directives */
72  NGX_HTTP_MODULE, /* module type */
73  NULL, /* init master */
74  NULL, /* init module */
75  NULL, /* init process */
76  NULL, /* init thread */
77  NULL, /* exit thread */
78  NULL, /* exit process */
79  NULL, /* exit master */
80  NGX_MODULE_V1_PADDING
81 };
82 
83 
84 static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
85 static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
86 
87 
88 static ngx_int_t
89 ngx_http_spdy_header_filter(ngx_http_request_t *r)
90 {
91  int rc;
92  size_t len;
93  u_char *p, *buf, *last;
94  ngx_buf_t *b;
95  ngx_str_t host;
96  ngx_uint_t i, j, count, port;
97  ngx_chain_t *cl;
98  ngx_list_part_t *part, *pt;
99  ngx_table_elt_t *header, *h;
100  ngx_connection_t *c;
101  ngx_http_cleanup_t *cln;
102  ngx_http_core_loc_conf_t *clcf;
103  ngx_http_core_srv_conf_t *cscf;
104  ngx_http_spdy_stream_t *stream;
105  ngx_http_spdy_out_frame_t *frame;
106  ngx_http_spdy_connection_t *sc;
107  struct sockaddr_in *sin;
108 #if (NGX_HAVE_INET6)
109  struct sockaddr_in6 *sin6;
110 #endif
111  u_char addr[NGX_SOCKADDR_STRLEN];
112 
113  if (!r->spdy_stream) {
114  return ngx_http_next_header_filter(r);
115  }
116 
117  ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
118  "spdy header filter");
119 
120  if (r->header_sent) {
121  return NGX_OK;
122  }
123 
124  r->header_sent = 1;
125 
126  if (r != r->main) {
127  return NGX_OK;
128  }
129 
130  c = r->connection;
131 
132  if (r->method == NGX_HTTP_HEAD) {
133  r->header_only = 1;
134  }
135 
136  switch (r->headers_out.status) {
137 
138  case NGX_HTTP_OK:
139  case NGX_HTTP_PARTIAL_CONTENT:
140  break;
141 
142  case NGX_HTTP_NOT_MODIFIED:
143  r->header_only = 1;
144  break;
145 
146  case NGX_HTTP_NO_CONTENT:
147  r->header_only = 1;
148 
149  ngx_str_null(&r->headers_out.content_type);
150 
151  r->headers_out.content_length = NULL;
152  r->headers_out.content_length_n = -1;
153 
154  /* fall through */
155 
156  default:
157  r->headers_out.last_modified_time = -1;
158  r->headers_out.last_modified = NULL;
159  }
160 
161  len = NGX_SPDY_NV_NUM_SIZE
162  + ngx_http_spdy_nv_nsize("version")
163  + ngx_http_spdy_nv_vsize("HTTP/1.1")
164  + ngx_http_spdy_nv_nsize("status")
165  + ngx_http_spdy_nv_vsize("418");
166 
167  clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
168 
169  if (r->headers_out.server == NULL) {
170  len += ngx_http_spdy_nv_nsize("server");
171  len += clcf->server_tokens ? ngx_http_spdy_nv_vsize(NGINX_VER)
172  : ngx_http_spdy_nv_vsize("nginx");
173  }
174 
175  if (r->headers_out.date == NULL) {
176  len += ngx_http_spdy_nv_nsize("date")
177  + ngx_http_spdy_nv_vsize("Wed, 31 Dec 1986 10:00:00 GMT");
178  }
179 
180  if (r->headers_out.content_type.len) {
181  len += ngx_http_spdy_nv_nsize("content-type")
182  + NGX_SPDY_NV_VLEN_SIZE + r->headers_out.content_type.len;
183 
184  if (r->headers_out.content_type_len == r->headers_out.content_type.len
185  && r->headers_out.charset.len)
186  {
187  len += sizeof("; charset=") - 1 + r->headers_out.charset.len;
188  }
189  }
190 
191  if (r->headers_out.content_length == NULL
192  && r->headers_out.content_length_n >= 0)
193  {
194  len += ngx_http_spdy_nv_nsize("content-length")
195  + NGX_SPDY_NV_VLEN_SIZE + NGX_OFF_T_LEN;
196  }
197 
198  if (r->headers_out.last_modified == NULL
199  && r->headers_out.last_modified_time != -1)
200  {
201  len += ngx_http_spdy_nv_nsize("last-modified")
202  + ngx_http_spdy_nv_vsize("Wed, 31 Dec 1986 10:00:00 GMT");
203  }
204 
205  if (r->headers_out.location
206  && r->headers_out.location->value.len
207  && r->headers_out.location->value.data[0] == '/')
208  {
209  r->headers_out.location->hash = 0;
210 
211  if (clcf->server_name_in_redirect) {
212  cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
213  host = cscf->server_name;
214 
215  } else if (r->headers_in.server.len) {
216  host = r->headers_in.server;
217 
218  } else {
219  host.len = NGX_SOCKADDR_STRLEN;
220  host.data = addr;
221 
222  if (ngx_connection_local_sockaddr(c, &host, 0) != NGX_OK) {
223  return NGX_ERROR;
224  }
225  }
226 
227  switch (c->local_sockaddr->sa_family) {
228 
229 #if (NGX_HAVE_INET6)
230  case AF_INET6:
231  sin6 = (struct sockaddr_in6 *) c->local_sockaddr;
232  port = ntohs(sin6->sin6_port);
233  break;
234 #endif
235 #if (NGX_HAVE_UNIX_DOMAIN)
236  case AF_UNIX:
237  port = 0;
238  break;
239 #endif
240  default: /* AF_INET */
241  sin = (struct sockaddr_in *) c->local_sockaddr;
242  port = ntohs(sin->sin_port);
243  break;
244  }
245 
246  len += ngx_http_spdy_nv_nsize("location")
247  + ngx_http_spdy_nv_vsize("https://")
248  + host.len
249  + r->headers_out.location->value.len;
250 
251  if (clcf->port_in_redirect) {
252 
253 #if (NGX_HTTP_SSL)
254  if (c->ssl)
255  port = (port == 443) ? 0 : port;
256  else
257 #endif
258  port = (port == 80) ? 0 : port;
259 
260  } else {
261  port = 0;
262  }
263 
264  if (port) {
265  len += sizeof(":65535") - 1;
266  }
267 
268  } else {
269  ngx_str_null(&host);
270  port = 0;
271  }
272 
273  part = &r->headers_out.headers.part;
274  header = part->elts;
275 
276  for (i = 0; /* void */; i++) {
277 
278  if (i >= part->nelts) {
279  if (part->next == NULL) {
280  break;
281  }
282 
283  part = part->next;
284  header = part->elts;
285  i = 0;
286  }
287 
288  if (header[i].hash == 0) {
289  continue;
290  }
291 
292  len += NGX_SPDY_NV_NLEN_SIZE + header[i].key.len
293  + NGX_SPDY_NV_VLEN_SIZE + header[i].value.len;
294  }
295 
296  buf = ngx_alloc(len, r->pool->log);
297  if (buf == NULL) {
298  return NGX_ERROR;
299  }
300 
301  last = buf + NGX_SPDY_NV_NUM_SIZE;
302 
303  last = ngx_http_spdy_nv_write_name(last, "version");
304  last = ngx_http_spdy_nv_write_val(last, "HTTP/1.1");
305 
306  last = ngx_http_spdy_nv_write_name(last, "status");
307  last = ngx_spdy_frame_write_uint16(last, 3);
308  last = ngx_sprintf(last, "%03ui", r->headers_out.status);
309 
310  count = 2;
311 
312  if (r->headers_out.server == NULL) {
313  last = ngx_http_spdy_nv_write_name(last, "server");
314  last = clcf->server_tokens
315  ? ngx_http_spdy_nv_write_val(last, NGINX_VER)
316  : ngx_http_spdy_nv_write_val(last, "nginx");
317 
318  count++;
319  }
320 
321  if (r->headers_out.date == NULL) {
322  last = ngx_http_spdy_nv_write_name(last, "date");
323 
324  last = ngx_http_spdy_nv_write_vlen(last, ngx_cached_http_time.len);
325 
326  last = ngx_cpymem(last, ngx_cached_http_time.data,
327  ngx_cached_http_time.len);
328 
329  count++;
330  }
331 
332  if (r->headers_out.content_type.len) {
333 
334  last = ngx_http_spdy_nv_write_name(last, "content-type");
335 
336  p = last + NGX_SPDY_NV_VLEN_SIZE;
337 
338  last = ngx_cpymem(p, r->headers_out.content_type.data,
339  r->headers_out.content_type.len);
340 
341  if (r->headers_out.content_type_len == r->headers_out.content_type.len
342  && r->headers_out.charset.len)
343  {
344  last = ngx_cpymem(last, "; charset=", sizeof("; charset=") - 1);
345 
346  last = ngx_cpymem(last, r->headers_out.charset.data,
347  r->headers_out.charset.len);
348 
349  /* update r->headers_out.content_type for possible logging */
350 
351  r->headers_out.content_type.len = last - p;
352  r->headers_out.content_type.data = p;
353  }
354 
355  (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
356  r->headers_out.content_type.len);
357 
358  count++;
359  }
360 
361  if (r->headers_out.content_length == NULL
362  && r->headers_out.content_length_n >= 0)
363  {
364  last = ngx_http_spdy_nv_write_name(last, "content-length");
365 
366  p = last + NGX_SPDY_NV_VLEN_SIZE;
367 
368  last = ngx_sprintf(p, "%O", r->headers_out.content_length_n);
369 
370  (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
371  last - p);
372 
373  count++;
374  }
375 
376  if (r->headers_out.last_modified == NULL
377  && r->headers_out.last_modified_time != -1)
378  {
379  last = ngx_http_spdy_nv_write_name(last, "last-modified");
380 
381  p = last + NGX_SPDY_NV_VLEN_SIZE;
382 
383  last = ngx_http_time(p, r->headers_out.last_modified_time);
384 
385  (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
386  last - p);
387 
388  count++;
389  }
390 
391  if (host.data) {
392 
393  last = ngx_http_spdy_nv_write_name(last, "location");
394 
395  p = last + NGX_SPDY_NV_VLEN_SIZE;
396 
397  last = ngx_cpymem(p, "http", sizeof("http") - 1);
398 
399 #if (NGX_HTTP_SSL)
400  if (c->ssl) {
401  *last++ ='s';
402  }
403 #endif
404 
405  *last++ = ':'; *last++ = '/'; *last++ = '/';
406 
407  last = ngx_cpymem(last, host.data, host.len);
408 
409  if (port) {
410  last = ngx_sprintf(last, ":%ui", port);
411  }
412 
413  last = ngx_cpymem(last, r->headers_out.location->value.data,
414  r->headers_out.location->value.len);
415 
416  /* update r->headers_out.location->value for possible logging */
417 
418  r->headers_out.location->value.len = last - p;
419  r->headers_out.location->value.data = p;
420  ngx_str_set(&r->headers_out.location->key, "location");
421 
422  (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
423  r->headers_out.location->value.len);
424 
425  count++;
426  }
427 
428  part = &r->headers_out.headers.part;
429  header = part->elts;
430 
431  for (i = 0; /* void */; i++) {
432 
433  if (i >= part->nelts) {
434  if (part->next == NULL) {
435  break;
436  }
437 
438  part = part->next;
439  header = part->elts;
440  i = 0;
441  }
442 
443  if (header[i].hash == 0 || header[i].hash == 2) {
444  continue;
445  }
446 
447  if ((header[i].key.len == 6
448  && ngx_strncasecmp(header[i].key.data,
449  (u_char *) "status", 6) == 0)
450  || (header[i].key.len == 7
451  && ngx_strncasecmp(header[i].key.data,
452  (u_char *) "version", 7) == 0))
453  {
454  header[i].hash = 0;
455  continue;
456  }
457 
458  last = ngx_http_spdy_nv_write_nlen(last, header[i].key.len);
459 
460  ngx_strlow(last, header[i].key.data, header[i].key.len);
461  last += header[i].key.len;
462 
463  p = last + NGX_SPDY_NV_VLEN_SIZE;
464 
465  last = ngx_cpymem(p, header[i].value.data, header[i].value.len);
466 
467  pt = part;
468  h = header;
469 
470  for (j = i + 1; /* void */; j++) {
471 
472  if (j >= pt->nelts) {
473  if (pt->next == NULL) {
474  break;
475  }
476 
477  pt = pt->next;
478  h = pt->elts;
479  j = 0;
480  }
481 
482  if (h[j].hash == 0 || h[j].hash == 2
483  || h[j].key.len != header[i].key.len
484  || ngx_strncasecmp(header[i].key.data, h[j].key.data,
485  header[i].key.len))
486  {
487  continue;
488  }
489 
490  *last++ = '\0';
491 
492  last = ngx_cpymem(last, h[j].value.data, h[j].value.len);
493 
494  h[j].hash = 2;
495  }
496 
497  (void) ngx_http_spdy_nv_write_vlen(p - NGX_SPDY_NV_VLEN_SIZE,
498  last - p);
499 
500  count++;
501  }
502 
503  (void) ngx_spdy_frame_write_uint16(buf, count);
504 
505  stream = r->spdy_stream;
506  sc = stream->connection;
507 
508  len = last - buf;
509 
510  b = ngx_create_temp_buf(r->pool, NGX_SPDY_FRAME_HEADER_SIZE
511  + NGX_SPDY_SYN_REPLY_SIZE
512  + deflateBound(&sc->zstream_out, len));
513  if (b == NULL) {
514  ngx_free(buf);
515  return NGX_ERROR;
516  }
517 
518  b->last += NGX_SPDY_FRAME_HEADER_SIZE + NGX_SPDY_SYN_REPLY_SIZE;
519 
520  sc->zstream_out.next_in = buf;
521  sc->zstream_out.avail_in = len;
522  sc->zstream_out.next_out = b->last;
523  sc->zstream_out.avail_out = b->end - b->last;
524 
525  rc = deflate(&sc->zstream_out, Z_SYNC_FLUSH);
526 
527  ngx_free(buf);
528 
529  if (rc != Z_OK) {
530  ngx_log_error(NGX_LOG_ALERT, c->log, 0,
531  "spdy deflate() failed: %d", rc);
532  return NGX_ERROR;
533  }
534 
535  ngx_log_debug5(NGX_LOG_DEBUG_HTTP, c->log, 0,
536  "spdy deflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
537  sc->zstream_out.next_in, sc->zstream_out.next_out,
538  sc->zstream_out.avail_in, sc->zstream_out.avail_out,
539  rc);
540 
541  b->last = sc->zstream_out.next_out;
542 
543  p = b->pos;
544  p = ngx_spdy_frame_write_head(p, NGX_SPDY_SYN_REPLY);
545 
546  len = b->last - b->pos;
547 
548  r->header_size = len;
549 
550  if (r->header_only) {
551  b->last_buf = 1;
552  p = ngx_spdy_frame_write_flags_and_len(p, NGX_SPDY_FLAG_FIN,
553  len - NGX_SPDY_FRAME_HEADER_SIZE);
554  } else {
555  p = ngx_spdy_frame_write_flags_and_len(p, 0,
556  len - NGX_SPDY_FRAME_HEADER_SIZE);
557  }
558 
559  (void) ngx_spdy_frame_write_sid(p, stream->id);
560 
561  cl = ngx_alloc_chain_link(r->pool);
562  if (cl == NULL) {
563  return NGX_ERROR;
564  }
565 
566  cl->buf = b;
567  cl->next = NULL;
568 
569  frame = ngx_palloc(r->pool, sizeof(ngx_http_spdy_out_frame_t));
570  if (frame == NULL) {
571  return NGX_ERROR;
572  }
573 
574  frame->first = cl;
575  frame->last = cl;
576  frame->handler = ngx_http_spdy_syn_frame_handler;
577  frame->free = NULL;
578  frame->stream = stream;
579  frame->size = len;
580  frame->priority = stream->priority;
581  frame->blocked = 1;
582  frame->fin = r->header_only;
583 
584  ngx_log_debug3(NGX_LOG_DEBUG_HTTP, stream->request->connection->log, 0,
585  "spdy:%ui create SYN_REPLY frame %p: size:%uz",
586  stream->id, frame, frame->size);
587 
588  ngx_http_spdy_queue_blocked_frame(sc, frame);
589 
590  r->blocked++;
591 
592  cln = ngx_http_cleanup_add(r, 0);
593  if (cln == NULL) {
594  return NGX_ERROR;
595  }
596 
597  cln->handler = ngx_http_spdy_filter_cleanup;
598  cln->data = stream;
599 
600  stream->waiting = 1;
601 
602  return ngx_http_spdy_filter_send(c, stream);
603 }
604 
605 
606 static ngx_int_t
607 ngx_http_spdy_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
608 {
609  off_t size;
610  ngx_buf_t *b;
611  ngx_chain_t *cl, *ll, *out, **ln;
612  ngx_http_spdy_stream_t *stream;
613  ngx_http_spdy_out_frame_t *frame;
614 
615  stream = r->spdy_stream;
616 
617  if (stream == NULL) {
618  return ngx_http_next_body_filter(r, in);
619  }
620 
621  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
622  "spdy body filter \"%V?%V\"", &r->uri, &r->args);
623 
624  if (in == NULL || r->header_only) {
625 
626  if (stream->waiting) {
627  return NGX_AGAIN;
628  }
629 
630  r->connection->buffered &= ~NGX_SPDY_WRITE_BUFFERED;
631 
632  return NGX_OK;
633  }
634 
635  size = 0;
636  ln = &out;
637  ll = in;
638 
639  for ( ;; ) {
640  b = ll->buf;
641 #if 1
642  if (ngx_buf_size(b) == 0 && !ngx_buf_special(b)) {
643  ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
644  "zero size buf in spdy body filter "
645  "t:%d r:%d f:%d %p %p-%p %p %O-%O",
646  b->temporary,
647  b->recycled,
648  b->in_file,
649  b->start,
650  b->pos,
651  b->last,
652  b->file,
653  b->file_pos,
654  b->file_last);
655 
656  ngx_debug_point();
657  return NGX_ERROR;
658  }
659 #endif
660  cl = ngx_alloc_chain_link(r->pool);
661  if (cl == NULL) {
662  return NGX_ERROR;
663  }
664 
665  size += ngx_buf_size(b);
666  cl->buf = b;
667 
668  *ln = cl;
669  ln = &cl->next;
670 
671  if (ll->next == NULL) {
672  break;
673  }
674 
675  ll = ll->next;
676  }
677 
678  if (size > NGX_SPDY_MAX_FRAME_SIZE) {
679  ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
680  "FIXME: chain too big in spdy filter: %O", size);
681  return NGX_ERROR;
682  }
683 
684  frame = ngx_http_spdy_filter_get_data_frame(stream, (size_t) size,
685  b->last_buf, out, cl);
686  if (frame == NULL) {
687  return NGX_ERROR;
688  }
689 
690  ngx_http_spdy_queue_frame(stream->connection, frame);
691 
692  stream->waiting++;
693 
694  r->main->blocked++;
695 
696  return ngx_http_spdy_filter_send(r->connection, stream);
697 }
698 
699 
700 static ngx_http_spdy_out_frame_t *
701 ngx_http_spdy_filter_get_data_frame(ngx_http_spdy_stream_t *stream,
702  size_t len, ngx_uint_t fin, ngx_chain_t *first, ngx_chain_t *last)
703 {
704  u_char *p;
705  ngx_buf_t *buf;
706  ngx_uint_t flags;
707  ngx_chain_t *cl;
708  ngx_http_spdy_out_frame_t *frame;
709 
710 
711  frame = stream->free_frames;
712 
713  if (frame) {
714  stream->free_frames = frame->free;
715 
716  } else {
717  frame = ngx_palloc(stream->request->pool,
718  sizeof(ngx_http_spdy_out_frame_t));
719  if (frame == NULL) {
720  return NULL;
721  }
722  }
723 
724  ngx_log_debug4(NGX_LOG_DEBUG_HTTP, stream->request->connection->log, 0,
725  "spdy:%ui create DATA frame %p: len:%uz fin:%ui",
726  stream->id, frame, len, fin);
727 
728  if (len || fin) {
729 
730  flags = fin ? NGX_SPDY_FLAG_FIN : 0;
731 
732  cl = ngx_chain_get_free_buf(stream->request->pool,
733  &stream->free_data_headers);
734  if (cl == NULL) {
735  return NULL;
736  }
737 
738  buf = cl->buf;
739 
740  if (buf->start) {
741  p = buf->start;
742  buf->pos = p;
743 
744  p += sizeof(uint32_t);
745 
746  (void) ngx_spdy_frame_write_flags_and_len(p, flags, len);
747 
748  } else {
749  p = ngx_palloc(stream->request->pool, NGX_SPDY_FRAME_HEADER_SIZE);
750  if (p == NULL) {
751  return NULL;
752  }
753 
754  buf->pos = p;
755  buf->start = p;
756 
757  p = ngx_spdy_frame_write_sid(p, stream->id);
758  p = ngx_spdy_frame_write_flags_and_len(p, flags, len);
759 
760  buf->last = p;
761  buf->end = p;
762 
763  buf->tag = (ngx_buf_tag_t) &ngx_http_spdy_filter_module;
764  buf->memory = 1;
765  }
766 
767  cl->next = first;
768  first = cl;
769  }
770 
771  frame->first = first;
772  frame->last = last;
773  frame->handler = ngx_http_spdy_data_frame_handler;
774  frame->free = NULL;
775  frame->stream = stream;
776  frame->size = NGX_SPDY_FRAME_HEADER_SIZE + len;
777  frame->priority = stream->priority;
778  frame->blocked = 0;
779  frame->fin = fin;
780 
781  return frame;
782 }
783 
784 
785 static ngx_inline ngx_int_t
786 ngx_http_spdy_filter_send(ngx_connection_t *fc, ngx_http_spdy_stream_t *stream)
787 {
788  if (ngx_http_spdy_send_output_queue(stream->connection) == NGX_ERROR) {
789  fc->error = 1;
790  return NGX_ERROR;
791  }
792 
793  if (stream->waiting) {
794  fc->buffered |= NGX_SPDY_WRITE_BUFFERED;
795  fc->write->delayed = 1;
796  return NGX_AGAIN;
797  }
798 
799  fc->buffered &= ~NGX_SPDY_WRITE_BUFFERED;
800 
801  return NGX_OK;
802 }
803 
804 
805 static ngx_int_t
806 ngx_http_spdy_syn_frame_handler(ngx_http_spdy_connection_t *sc,
807  ngx_http_spdy_out_frame_t *frame)
808 {
809  ngx_buf_t *buf;
810  ngx_http_spdy_stream_t *stream;
811 
812  buf = frame->first->buf;
813 
814  if (buf->pos != buf->last) {
815  return NGX_AGAIN;
816  }
817 
818  stream = frame->stream;
819 
820  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
821  "spdy:%ui SYN_REPLY frame %p was sent", stream->id, frame);
822 
823  ngx_free_chain(stream->request->pool, frame->first);
824 
825  ngx_http_spdy_handle_frame(stream, frame);
826 
827  ngx_http_spdy_handle_stream(sc, stream);
828 
829  return NGX_OK;
830 }
831 
832 
833 static ngx_int_t
834 ngx_http_spdy_data_frame_handler(ngx_http_spdy_connection_t *sc,
835  ngx_http_spdy_out_frame_t *frame)
836 {
837  ngx_chain_t *cl, *ln;
838  ngx_http_spdy_stream_t *stream;
839 
840  stream = frame->stream;
841 
842  cl = frame->first;
843 
844  if (cl->buf->tag == (ngx_buf_tag_t) &ngx_http_spdy_filter_module) {
845 
846  if (cl->buf->pos != cl->buf->last) {
847  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
848  "spdy:%ui DATA frame %p was sent partially",
849  stream->id, frame);
850 
851  return NGX_AGAIN;
852  }
853 
854  ln = cl->next;
855 
856  cl->next = stream->free_data_headers;
857  stream->free_data_headers = cl;
858 
859  if (cl == frame->last) {
860  goto done;
861  }
862 
863  cl = ln;
864  }
865 
866  for ( ;; ) {
867  if (ngx_buf_size(cl->buf) != 0) {
868 
869  if (cl != frame->first) {
870  frame->first = cl;
871  ngx_http_spdy_handle_stream(sc, stream);
872  }
873 
874  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
875  "spdy:%ui DATA frame %p was sent partially",
876  stream->id, frame);
877 
878  return NGX_AGAIN;
879  }
880 
881  ln = cl->next;
882 
883  ngx_free_chain(stream->request->pool, cl);
884 
885  if (cl == frame->last) {
886  goto done;
887  }
888 
889  cl = ln;
890  }
891 
892 done:
893 
894  ngx_log_debug2(NGX_LOG_DEBUG_HTTP, sc->connection->log, 0,
895  "spdy:%ui DATA frame %p was sent", stream->id, frame);
896 
897  stream->request->header_size += NGX_SPDY_FRAME_HEADER_SIZE;
898 
899  ngx_http_spdy_handle_frame(stream, frame);
900 
901  ngx_http_spdy_handle_stream(sc, stream);
902 
903  return NGX_OK;
904 }
905 
906 
907 static ngx_inline void
908 ngx_http_spdy_handle_frame(ngx_http_spdy_stream_t *stream,
909  ngx_http_spdy_out_frame_t *frame)
910 {
911  ngx_http_request_t *r;
912 
913  r = stream->request;
914 
915  r->connection->sent += frame->size;
916  r->blocked--;
917 
918  if (frame->fin) {
919  stream->out_closed = 1;
920  }
921 
922  frame->free = stream->free_frames;
923  stream->free_frames = frame;
924 
925  stream->waiting--;
926 }
927 
928 
929 static ngx_inline void
930 ngx_http_spdy_handle_stream(ngx_http_spdy_connection_t *sc,
931  ngx_http_spdy_stream_t *stream)
932 {
933  ngx_connection_t *fc;
934 
935  fc = stream->request->connection;
936 
937  fc->write->delayed = 0;
938 
939  if (stream->handled) {
940  return;
941  }
942 
943  if (sc->blocked == 2) {
944  stream->handled = 1;
945 
946  stream->next = sc->last_stream;
947  sc->last_stream = stream;
948  }
949 }
950 
951 
952 static void
953 ngx_http_spdy_filter_cleanup(void *data)
954 {
955  ngx_http_spdy_stream_t *stream = data;
956 
957  ngx_http_request_t *r;
958  ngx_http_spdy_out_frame_t *frame, **fn;
959 
960  if (stream->waiting == 0) {
961  return;
962  }
963 
964  r = stream->request;
965 
966  fn = &stream->connection->last_out;
967 
968  for ( ;; ) {
969  frame = *fn;
970 
971  if (frame == NULL) {
972  break;
973  }
974 
975  if (frame->stream == stream && !frame->blocked) {
976 
977  stream->waiting--;
978  r->blocked--;
979 
980  *fn = frame->next;
981  continue;
982  }
983 
984  fn = &frame->next;
985  }
986 }
987 
988 
989 static ngx_int_t
990 ngx_http_spdy_filter_init(ngx_conf_t *cf)
991 {
992  ngx_http_next_header_filter = ngx_http_top_header_filter;
993  ngx_http_top_header_filter = ngx_http_spdy_header_filter;
994 
995  ngx_http_next_body_filter = ngx_http_top_body_filter;
996  ngx_http_top_body_filter = ngx_http_spdy_body_filter;
997 
998  return NGX_OK;
999 }
Generated on Sun Nov 10 2013 09:49:08 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2