← Back to branch summary

~britco/nginx/nginx

« back to all changes in this revision

Viewing changes to debian/modules/chunkin-nginx-module/README

  • Committer: Package Import Robot
  • Author(s): Dmitry E. Oboukhov
  • Date: 2011-11-24 14:16:50 UTC
  • mfrom: (4.2.40 sid)
  • Revision ID: package-import@ubuntu.com-20111124141650-4n06eynzekxycf6c
Tags: 1.1.8-2
http://bugs.debian.org/638814
* debian/modules/chunkin-nginx-module:
  + Reinclude HttpChunkin Module with new upstream version (closes: #638814)
* debian/control:
  + Add myself to uploaders list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/chunkin-nginx-module/README
 
1
Name
 
2
    ngx_chunkin - HTTP 1.1 chunked-encoding request body support for Nginx.
 
3
 
 
4
    *This module is not distributed with the Nginx source.* See the
 
5
    installation instructions.
 
6
 
 
7
Status
 
8
    This module is considered production ready.
 
9
 
 
10
Version
 
11
    This document describes chunkin-nginx-module v0.22
 
12
    (<http://github.com/agentzh/chunkin-nginx-module/tags>) released on
 
13
    October 14, 2011.
 
14
 
 
15
Synopsis
 
16
      chunkin on;
 
17
 
 
18
      error_page 411 = @my_411_error;
 
19
      location @my_411_error {
 
20
          chunkin_resume;
 
21
      }
 
22
 
 
23
      location /foo {
 
24
          # your fastcgi_pass/proxy_pass/set/if and
 
25
          # any other config directives go here...
 
26
      }
 
27
      ...
 
28
 
 
29
      chunkin on;
 
30
 
 
31
      error_page 411 = @my_411_error;
 
32
      location @my_411_error {
 
33
          chunkin_resume;
 
34
      }
 
35
 
 
36
      location /bar {
 
37
        chunkin_keepalive on;  # WARNING: too experimental!
 
38
 
 
39
        # your fastcgi_pass/proxy_pass/set/if and
 
40
        # any other config directives go here...
 
41
      }
 
42
 
 
43
Description
 
44
    This module adds HTTP 1.1 chunked
 
45
    (<http://tools.ietf.org/html/rfc2616#section-3.6.1>) input support for
 
46
    Nginx without the need of patching the Nginx core.
 
47
 
 
48
    Behind the scene, it registers an access-phase handler that will eagerly
 
49
    read and decode incoming request bodies when a "Transfer-Encoding:
 
50
    chunked" header triggers a 411 error page in Nginx. For requests that
 
51
    are not in the "chunked" transfer encoding, this module is a "no-op".
 
52
 
 
53
    To enable the magic, just turn on the chunkin config option and define a
 
54
    custom "411 error_page" using chunkin_resume, like this:
 
55
 
 
56
      server {
 
57
        chunkin on;
 
58
 
 
59
        error_page 411 = @my_411_error;
 
60
        location @my_411_error {
 
61
            chunkin_resume;
 
62
        }
 
63
 
 
64
        ...
 
65
      }
 
66
 
 
67
    No other modification is required in your nginx.conf file and everything
 
68
    should work out of the box including the standard [module
 
69
    (HttpProxyModule)] (except for those known issues). Note that the
 
70
    chunkin directive is not allowed in the location block while the
 
71
    chunkin_resume directive is only allowed on in "locations".
 
72
 
 
73
    The core module's client_body_buffer_size, client_max_body_size, and
 
74
    client_body_timeout directive settings are honored. Note that, the "body
 
75
    sizes" here always indicate chunked-encoded body, not the data that has
 
76
    already been decoded. Basically, the chunked-encoded body will always be
 
77
    slightly larger than the original data that is not encoded.
 
78
 
 
79
    The client_body_in_file_only and client_body_in_single_buffer settings
 
80
    are followed partially. See Know Issues.
 
81
 
 
82
    This module is not supposed to be merged into the Nginx core because
 
83
    I've used Ragel (<http://www.complang.org/ragel/>) to generate the
 
84
    chunked encoding parser for joy :)
 
85
 
 
86
  How it works
 
87
    Nginx explicitly checks chunked "Transfer-Encoding" headers and absent
 
88
    content length header in its very early phase. Well, as early as the
 
89
    "ngx_http_process_request_header" function. So this module takes a
 
90
    rather tricky approach. That is, use an output filter to intercept the
 
91
    "411 Length Required" error page response issued by
 
92
    "ngx_http_process_request_header", fix things and finally issue an
 
93
    internal redirect to the current location, thus starting from those
 
94
    phases we all know and love, this time bypassing the horrible
 
95
    "ngx_http_process_request_header" function.
 
96
 
 
97
    In the "rewrite" phase of the newly created request, this module eagerly
 
98
    reads in the chunked request body in a way similar to that of the
 
99
    standard "ngx_http_read_client_request_body" function, but using its own
 
100
    chunked parser generated by Ragel. The decoded request body will be put
 
101
    into "r->request_body->bufs" and a corresponding "Content-Length" header
 
102
    will be inserted into "r->headers_in".
 
103
 
 
104
    Those modules using the standard "ngx_http_read_client_request_body"
 
105
    function to read the request body will just work out of box because
 
106
    "ngx_http_read_client_request_body" returns immediately when it sees
 
107
    "r->request_body->bufs" already exists.
 
108
 
 
109
    Special efforts have been made to reduce data copying and dynamic memory
 
110
    allocation.
 
111
 
 
112
Directives
 
113
  chunkin
 
114
    syntax: *chunkin on|off*
 
115
 
 
116
    default: *off*
 
117
 
 
118
    context: *http, server*
 
119
 
 
120
    phase: *access*
 
121
 
 
122
    Enables or disables this module's hooks.
 
123
 
 
124
  chunkin_resume
 
125
    syntax: *chunkin_resume*
 
126
 
 
127
    default: *no*
 
128
 
 
129
    context: *location*
 
130
 
 
131
    phase: *content*
 
132
 
 
133
    This directive must be used in your custom "411 error page" location to
 
134
    help this module work correctly. For example:
 
135
 
 
136
      error_page 411 = @my_error;
 
137
      location @my_error {
 
138
          chunkin_resume;
 
139
      }
 
140
 
 
141
    For the technical reason behind the necessity of this directive, please
 
142
    read the "nginx-devel" thread Content-Length is not ignored for chunked
 
143
    requests: Nginx violates RFC 2616
 
144
    (<http://nginx.org/pipermail/nginx-devel/2009-December/000041.html>).
 
145
 
 
146
    This directive was first introduced in the v0.17 release.
 
147
 
 
148
  chunkin_max_chunks_per_buf
 
149
    syntax: *chunkin_max_chunks_per_buf <number>*
 
150
 
 
151
    default: *512*
 
152
 
 
153
    context: *http, server, location*
 
154
 
 
155
    Set the max chunk count threshold for the buffer determined by the
 
156
    client_body_buffer_size directive. If the average chunk size is "1 KB"
 
157
    and your client_body_buffer_size setting is 1 meta bytes, then you
 
158
    should set this threshold to 1024 or 2048.
 
159
 
 
160
    When the raw body size is exceeding client_body_buffer_size *or* the
 
161
    chunk counter is exceeding this "chunkin_max_chunks_per_buf" setting,
 
162
    the decoded data will be temporarily buffered into disk files, and then
 
163
    the main buffer gets cleared and the chunk counter gets reset back to 0
 
164
    (or 1 if there's a "pending chunk").
 
165
 
 
166
    This directive was first introduced in the v0.17 release.
 
167
 
 
168
  chunkin_keepalive
 
169
    syntax: *chunkin_keepalive on|off*
 
170
 
 
171
    default: *off*
 
172
 
 
173
    context: *http, server, location, if*
 
174
 
 
175
    Turns on or turns off HTTP 1.1 keep-alive and HTTP 1.1 pipelining
 
176
    support.
 
177
 
 
178
    Keep-alive without pipelining should be quite stable but pipelining
 
179
    support is very preliminary, limited, and almost untested.
 
180
 
 
181
    This directive was first introduced in the v0.07 release.
 
182
 
 
183
    Technical note on the HTTP 1.1 pipeling support
 
184
 
 
185
    The basic idea is to copy the bytes left by my chunked parser in
 
186
    "r->request_body->buf" over into "r->header_in" so that nginx's
 
187
    "ngx_http_set_keepalive" and "ngx_http_init_request" functions will pick
 
188
    it up for the subsequent pipelined requests. When the request body is
 
189
    small enough to be completely preread into the "r->header_in" buffer,
 
190
    then no data copy is needed here -- just setting "r->header_in->pos"
 
191
    correctly will suffice.
 
192
 
 
193
    The only issue that remains is how to enlarge "r->header_in" when the
 
194
    data left in "r->request_body->buf" is just too large to be hold in the
 
195
    remaining room between "r->header_in->pos" and "r->header_in->end". For
 
196
    now, this module will just give up and simply turn off "r->keepalive".
 
197
 
 
198
    I know we can always use exactly the remaining room in "r->header_in" as
 
199
    the buffer size when reading data from "c->recv", but's suboptimal when
 
200
    the remaining room in "r->header_in" happens to be very small while
 
201
    "r->request_body->buf" is quite large.
 
202
 
 
203
    I haven't fully grokked all the details among "r->header_in",
 
204
    "c->buffer", busy/free lists and those so-called "large header buffers".
 
205
    Is there a clean and safe way to reallocate or extend the "r->header_in"
 
206
    buffer?
 
207
 
 
208
Installation
 
209
    Grab the nginx source code from nginx.org (<http://nginx.org/>), for
 
210
    example, the version 1.0.8 (see nginx compatibility), and then build the
 
211
    source with this module:
 
212
 
 
213
        wget 'http://nginx.org/download/nginx-1.0.8.tar.gz'
 
214
        tar -xzvf nginx-1.0.8.tar.gz
 
215
        cd nginx-1.0.8/
 
216
 
 
217
        # Here we assume you would install you nginx under /opt/nginx/.
 
218
        ./configure --prefix=/opt/nginx \
 
219
            --add-module=/path/to/chunkin-nginx-module
 
220
 
 
221
        make -j2
 
222
        make install
 
223
 
 
224
    Download the latest version of the release tarball of this module from
 
225
    chunkin-nginx-module file list
 
226
    (<http://github.com/agentzh/chunkin-nginx-module/tags>).
 
227
 
 
228
  For Developers
 
229
    The chunked parser is generated by Ragel
 
230
    (<http://www.complang.org/ragel/>). If you want to regenerate the
 
231
    parser's C file, i.e., src/chunked_parser.c
 
232
    (<http://github.com/agentzh/chunkin-nginx-module/blob/master/src/chunked
 
233
    _parser.c>), use the following command from the root of the chunkin
 
234
    module's source tree:
 
235
 
 
236
        $ ragel -G2 src/chunked_parser.rl
 
237
 
 
238
Packages from users
 
239
  Fedora 13 RPM files
 
240
    The following source and binary rpm files are contributed by Ernest
 
241
    Folch, with nginx 0.8.54, ngx_chunkin v0.21 and ngx_headers_more v0.13:
 
242
 
 
243
    *   nginx-0.8.54-1.fc13.src.rpm
 
244
        (<http://agentzh.org/misc/nginx/ernest/nginx-0.8.54-1.fc13.src.rpm>)
 
245
 
 
246
    *   nginx-0.8.54-1.fc13.x86_64.rpm
 
247
        (<http://agentzh.org/misc/nginx/ernest/nginx-0.8.54-1.fc13.x86_64.rp
 
248
        m>)
 
249
 
 
250
Compatibility
 
251
    The following versions of Nginx should work with this module:
 
252
 
 
253
    *   1.1.x (last tested: 1.1.5)
 
254
 
 
255
    *   1.0.x (last tested: 1.0.8)
 
256
 
 
257
    *   0.8.x (last tested: 0.8.54)
 
258
 
 
259
    *   0.7.x >= 0.7.21 (last tested: 0.7.67)
 
260
 
 
261
    Earlier versions of Nginx like 0.6.x and 0.5.x will *not* work.
 
262
 
 
263
    If you find that any particular version of Nginx above 0.7.21 does not
 
264
    work with this module, please consider reporting a bug.
 
265
 
 
266
Report Bugs
 
267
    Although a lot of effort has been put into testing and code tuning,
 
268
    there must be some serious bugs lurking somewhere in this module. So
 
269
    whenever you are bitten by any quirks, please don't hesitate to
 
270
 
 
271
    1.  send a bug report or even patches to <agentzh@gmail.com>,
 
272
 
 
273
    2.  or create a ticket on the issue tracking interface
 
274
        (<http://github.com/agentzh/chunkin-nginx-module/issues>) provided
 
275
        by GitHub.
 
276
 
 
277
Source Repository
 
278
    Available on github at agentzh/chunkin-nginx-module
 
279
    (<http://github.com/agentzh/chunkin-nginx-module>).
 
280
 
 
281
ChangeLog
 
282
  v0.22
 
283
    *   now we remove the request header Transfer-Encoding completely
 
284
        because at least Apache will complain about the empty-value
 
285
        "Transfer-Encoding" request header. thanks hoodoos and Sandesh
 
286
        Kotwal.
 
287
 
 
288
    *   now we allow DELETE requests with chunked request bodies per
 
289
        hoodoos's request.
 
290
 
 
291
    *   now we use the 2-clause BSD license.
 
292
 
 
293
  v0.21
 
294
    *   applied a patch from Gong Kaihui (龚开晖) to always call "post_handler"
 
295
        in "ngx_http_chunkin_read_chunked_request_body".
 
296
 
 
297
  v0.20
 
298
    *   fixed a bug that may read incomplete chunked body. thanks Gong
 
299
        Kaihui (龚开晖).
 
300
 
 
301
    *   fixed various memory issues in the implementation which may cause
 
302
        nginx processes to crash.
 
303
 
 
304
    *   added support for chunked PUT requests.
 
305
 
 
306
    *   now we always require "error_page 411 @resume" and no default
 
307
        (buggy) magic any more. thanks Gong Kaihui (龚开晖).
 
308
 
 
309
  v0.19
 
310
    *   we now use ragel -G2 to generate the chunked parser and we're 36%
 
311
        faster.
 
312
 
 
313
    *   we now eagerly read the data octets in the chunked parser and we're
 
314
        43% faster.
 
315
 
 
316
  v0.18
 
317
    *   added support for "chunk-extension" to the chunked parser as per RFC
 
318
        2616 (<http://tools.ietf.org/html/rfc2616#section-3.6.1>), but we
 
319
        just ignore them (if any) because we don't understand them.
 
320
 
 
321
    *   added more diagnostic information for certian error messages.
 
322
 
 
323
  v0.17
 
324
    *   implemented the chunkin_max_chunks_per_buf directive to allow
 
325
        overriding the default 512 setting.
 
326
 
 
327
    *   we now bypass nginx's discard requesty body bug
 
328
        (<http://nginx.org/pipermail/nginx-devel/2009-December/000041.html>)
 
329
        by requiring our users to define explicit "411 error_page" with
 
330
        chunkin_resume in the error page location. Thanks J for reporting
 
331
        related bugs.
 
332
 
 
333
    *   fixed "r->phase_handler" in our post read handler. our handler may
 
334
        run one more time before :P
 
335
 
 
336
    *   the chunkin handler now returns "NGX_DECLINED" rather than "NGX_OK"
 
337
        when our "ngx_http_chunkin_read_chunked_request_body" function
 
338
        returns "NGX_OK", to avoid bypassing other access-phase handlers.
 
339
 
 
340
  v0.16
 
341
    *   turned off ddebug in the previous release. thanks J for reporting
 
342
        it.
 
343
 
 
344
  v0.15
 
345
    *   fixed a regression that ctx->chunks_count never incremented in
 
346
        earlier versions.
 
347
 
 
348
  v0.14
 
349
    *   now we no longer skip those operations between the (interrupted)
 
350
        ngx_http_process_request_header and the server rewrite phase. this
 
351
        fixed the security issues regarding the internal directive as well
 
352
        as SSL sessions.
 
353
 
 
354
    *   try to ignore CR/LF/SP/HT at the begining of the chunked body.
 
355
 
 
356
    *   now we allow HT as padding spaces and ignore leading CRLFs.
 
357
 
 
358
    *   improved diagnostic info in the error.log messages when parsefail
 
359
        occurs.
 
360
 
 
361
  v0.11
 
362
    *   added a random valid-chunked-request generator in t/random.t.
 
363
 
 
364
    *   fixed a new connection leak issue caught by t/random.t.
 
365
 
 
366
  v0.10
 
367
    *   fixed a serious bug in the chunked parser grammer: there would be
 
368
        ambiguity when CRLF appears in the chunked data sections. Thanks J
 
369
        for reporting it.
 
370
 
 
371
  v0.08
 
372
    *   fixed gcc compilation errors on x86_64, thanks J for reporting it.
 
373
 
 
374
    *   used the latest Ragel 6.6 to generate the "chunked_parser.c" file in
 
375
        the source tree.
 
376
 
 
377
  v0.07
 
378
    *   marked the disgarded 411 error page's output chain bufs as consumed
 
379
        by setting "buf->pos = buf->last". (See this nginx-devel thread
 
380
        (<http://nginx.org/pipermail/nginx-devel/2009-December/000025.html>)
 
381
        for more details.)
 
382
 
 
383
    *   added the chunkin_keepalive directive which can enable HTTP 1.1
 
384
        keep-alive and HTTP 1.1 pipelining, and defaults to "off".
 
385
 
 
386
    *   fixed the "alphtype" bug in the Ragel parser spec; which caused
 
387
        rejection of non-ascii octets in the chunked data. Thanks J for his
 
388
        bug report.
 
389
 
 
390
    *   added "Test::Nginx::Socket" to test our nginx module on the socket
 
391
        level. Thanks J for his bug report.
 
392
 
 
393
    *   rewrote the bufs recycling part and preread-buf-to-rb-buf transition
 
394
        part, also refactored the Ragel parser spec, thus eliminating lots
 
395
        of serious bugs.
 
396
 
 
397
    *   provided better diagnostics in the error log message for "bad
 
398
        chunked body" parsefails in the chunked parser. For example:
 
399
 
 
400
     2009/12/02 17:35:52 [error] 32244#0: *1 bad chunked body (offset 7, near "4^M
 
401
     hell <-- HERE o^M
 
402
     0^M
 
403
     ^M
 
404
     ", marked by " <-- HERE ").
 
405
     , client: 127.0.0.1, server: localhost, request: "POST /main
 
406
    HTTP/1.1", host: "localhost"
 
407
 
 
408
    *   added some code to let the chunked parser handle special 0-size
 
409
        chunks that are not the last chunk.
 
410
 
 
411
    *   fixed a connection leak bug regarding incorrect "r->main->count"
 
412
        reference counter handling for nginx 0.8.11+ (well, the
 
413
        "ngx_http_read_client_request_body" function in the nginx core also
 
414
        has this issue, I'll report it later.)
 
415
 
 
416
  v0.06
 
417
    *   minor optimization: we won't traverse the output chain link if the
 
418
        chain count is not large enough.
 
419
 
 
420
Test Suite
 
421
    This module comes with a Perl-driven test suite. The test cases
 
422
    (<http://github.com/agentzh/chunkin-nginx-module/tree/master/test/t/>)
 
423
    are declarative
 
424
    (<http://github.com/agentzh/chunkin-nginx-module/blob/master/test/t/sani
 
425
    ty.t>) too. Thanks to the Test::Base
 
426
    (<http://search.cpan.org/perldoc?Test::Base>) module in the Perl world.
 
427
 
 
428
    To run it on your side:
 
429
 
 
430
        $ cd test
 
431
        $ PATH=/path/to/your/nginx-with-chunkin-module:$PATH prove -r t
 
432
 
 
433
    You need to terminate any Nginx processes before running the test suite
 
434
    if you have changed the Nginx server binary.
 
435
 
 
436
    At the moment, LWP::UserAgent
 
437
    (<http://search.cpan.org/perldoc?LWP::UserAgent>) is used by the test
 
438
    scaffold
 
439
    (<http://github.com/agentzh/chunkin-nginx-module/blob/master/test/lib/Te
 
440
    st/Nginx/LWP.pm>) for simplicity.
 
441
 
 
442
    Because a single nginx server (by default, "localhost:1984") is used
 
443
    across all the test scripts (".t" files), it's meaningless to run the
 
444
    test suite in parallel by specifying "-jN" when invoking the "prove"
 
445
    utility.
 
446
 
 
447
    Some parts of the test suite requires modules proxy and echo to be
 
448
    enabled as well when building Nginx.
 
449
 
 
450
Known Issues
 
451
    *   May not work with certain 3rd party modules like the upload module
 
452
        (<http://www.grid.net.ru/nginx/upload.en.html>) because it
 
453
        implements its own request body reading mechanism.
 
454
 
 
455
    *   "client_body_in_single_buffer on" may *not* be obeyed for short
 
456
        contents and fast network.
 
457
 
 
458
    *   "client_body_in_file_only on" may *not* be obeyed for short contents
 
459
        and fast network.
 
460
 
 
461
    *   HTTP 1.1 pipelining may not fully work yet.
 
462
 
 
463
TODO
 
464
    *   make the chunkin handler run at the end of the "access phase" rather
 
465
        than beginning.
 
466
 
 
467
    *   add support for "trailers" as specified in the RFC 2616
 
468
        (<http://tools.ietf.org/html/rfc2616#section-3.6.1>).
 
469
 
 
470
    *   fix the known issues.
 
471
 
 
472
Getting involved
 
473
    You'll be very welcomed to submit patches to the author or just ask for
 
474
    a commit bit to the source repository on GitHub.
 
475
 
 
476
Author
 
477
    Zhang "agentzh" Yichun (章亦春) *<agentzh@gmail.com>*
 
478
 
 
479
    This wiki page is also maintained by the author himself, and everybody
 
480
    is encouraged to improve this page as well.
 
481
 
 
482
Copyright & License
 
483
    The basic client request body reading code is based on the
 
484
    "ngx_http_read_client_request_body" function and its utility functions
 
485
    in the Nginx 0.8.20 core. This part of code is copyrighted by Igor
 
486
    Sysoev.
 
487
 
 
488
    Copyright (c) 2009, Taobao Inc., Alibaba Group ( http://www.taobao.com
 
489
    ).
 
490
 
 
491
    Copyright (c) 2009, 2010, 2011, Zhang "agentzh" Yichun (章亦春)
 
492
    <agentzh@gmail.com>.
 
493
 
 
494
    This module is licensed under the terms of the BSD license.
 
495
 
 
496
    Redistribution and use in source and binary forms, with or without
 
497
    modification, are permitted provided that the following conditions are
 
498
    met:
 
499
 
 
500
    *   Redistributions of source code must retain the above copyright
 
501
        notice, this list of conditions and the following disclaimer.
 
502
 
 
503
    *   Redistributions in binary form must reproduce the above copyright
 
504
        notice, this list of conditions and the following disclaimer in the
 
505
        documentation and/or other materials provided with the distribution.
 
506
 
 
507
    *   Neither the name of the Taobao Inc. nor the names of its
 
508
        contributors may be used to endorse or promote products derived from
 
509
        this software without specific prior written permission.
 
510
 
 
511
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 
512
    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 
513
    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 
514
    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
515
    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
516
    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 
517
    TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
518
    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 
519
    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 
520
    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
521
    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
522
 
 
523
See Also
 
524
    *   The original thread on the Nginx mailing list that inspires this
 
525
        module's development: "'Content-Length' header for POSTs"
 
526
        (<http://forum.nginx.org/read.php?2,4453,20543>).
 
527
 
 
528
    *   The orginal announcement thread on the Nginx mailing list: "The
 
529
        chunkin module: Experimental chunked input support for Nginx"
 
530
        (<http://forum.nginx.org/read.php?2,22967>).
 
531
 
 
532
    *   The original blog post
 
533
        (<http://agentzh.spaces.live.com/blog/cns!FF3A735632E41548!481.entry
 
534
        >) about this module's initial development.
 
535
 
 
536
    *   The thread discussing chunked input support on the nginx-devel
 
537
        mailing list: "Chunked request body and HTTP header parser"
 
538
        (<http://nginx.org/pipermail/nginx-devel/2009-December/000021.html>)
 
539
        .
 
540
 
 
541
    *   The [module (HttpEchoModule)] for Nginx module's automated testing.
 
542
 
 
543
    *   RFC 2616 - Chunked Transfer Coding
 
544
        (<http://tools.ietf.org/html/rfc2616#section-3.6.1>).
 
545