One Level Up Top Level

src/http/modules/ngx_http_range_filter_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


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


  13. /*
  14. * the single part format:
  15. *
  16. * "HTTP/1.0 206 Partial Content" CRLF
  17. * ... header ...
  18. * "Content-Type: image/jpeg" CRLF
  19. * "Content-Length: SIZE" CRLF
  20. * "Content-Range: bytes START-END/SIZE" CRLF
  21. * CRLF
  22. * ... data ...
  23. *
  24. *
  25. * the multipart format:
  26. *
  27. * "HTTP/1.0 206 Partial Content" CRLF
  28. * ... header ...
  29. * "Content-Type: multipart/byteranges; boundary=0123456789" CRLF
  30. * CRLF
  31. * CRLF
  32. * "--0123456789" CRLF
  33. * "Content-Type: image/jpeg" CRLF
  34. * "Content-Range: bytes START0-END0/SIZE" CRLF
  35. * CRLF
  36. * ... data ...
  37. * CRLF
  38. * "--0123456789" CRLF
  39. * "Content-Type: image/jpeg" CRLF
  40. * "Content-Range: bytes START1-END1/SIZE" CRLF
  41. * CRLF
  42. * ... data ...
  43. * CRLF
  44. * "--0123456789--" CRLF
  45. */


  48. typedef struct {
  49.     off_t        start;
  50.     off_t        end;
  51.     ngx_str_t    content_range;
  52. ‌} ngx_http_range_t;


  55. typedef struct {
  56.     off_t        offset;
  57.     ngx_str_t    boundary_header;
  58.     ngx_array_t  ranges;
  59. ‌} ngx_http_range_filter_ctx_t;


  62. static ngx_int_t ngx_http_range_parse(ngx_http_request_t *r,
  63.     ngx_http_range_filter_ctx_t *ctx, ngx_uint_t ranges);
  64. static ngx_int_t ngx_http_range_singlepart_header(ngx_http_request_t *r,
  65.     ngx_http_range_filter_ctx_t *ctx);
  66. static ngx_int_t ngx_http_range_multipart_header(ngx_http_request_t *r,
  67.     ngx_http_range_filter_ctx_t *ctx);
  68. static ngx_int_t ngx_http_range_not_satisfiable(ngx_http_request_t *r);
  69. static ngx_int_t ngx_http_range_test_overlapped(ngx_http_request_t *r,
  70.     ngx_http_range_filter_ctx_t *ctx, ngx_chain_t *in);
  71. static ngx_int_t ngx_http_range_singlepart_body(ngx_http_request_t *r,
  72.     ngx_http_range_filter_ctx_t *ctx, ngx_chain_t *in);
  73. static ngx_int_t ngx_http_range_multipart_body(ngx_http_request_t *r,
  74.     ngx_http_range_filter_ctx_t *ctx, ngx_chain_t *in);

  76. static ngx_int_t ngx_http_range_header_filter_init(ngx_conf_t *cf);
  77. static ngx_int_t ngx_http_range_body_filter_init(ngx_conf_t *cf);


  80. ‌static ngx_http_module_t  ngx_http_range_header_filter_module_ctx = {
  81.     NULL,                                  /* preconfiguration */
  82.     ngx_http_range_header_filter_init,     /* postconfiguration */

  84.     NULL,                                  /* create main configuration */
  85.     NULL,                                  /* init main configuration */

  87.     NULL,                                  /* create server configuration */
  88.     NULL,                                  /* merge server configuration */

  90.     NULL,                                  /* create location configuration */
  91.     NULL,                                  /* merge location configuration */
  92. };


  95. ‌ngx_module_t  ngx_http_range_header_filter_module = {
  96.     NGX_MODULE_V1,
  97.     &ngx_http_range_header_filter_module_ctx, /* module context */
  98.     NULL,                                  /* module directives */
  99.     NGX_HTTP_MODULE,                       /* module type */
  100.     NULL,                                  /* init master */
  101.     NULL,                                  /* init module */
  102.     NULL,                                  /* init process */
  103.     NULL,                                  /* init thread */
  104.     NULL,                                  /* exit thread */
  105.     NULL,                                  /* exit process */
  106.     NULL,                                  /* exit master */
  107.     NGX_MODULE_V1_PADDING
  108. };


  111. ‌static ngx_http_module_t  ngx_http_range_body_filter_module_ctx = {
  112.     NULL,                                  /* preconfiguration */
  113.     ngx_http_range_body_filter_init,       /* postconfiguration */

  115.     NULL,                                  /* create main configuration */
  116.     NULL,                                  /* init main configuration */

  118.     NULL,                                  /* create server configuration */
  119.     NULL,                                  /* merge server configuration */

  121.     NULL,                                  /* create location configuration */
  122.     NULL,                                  /* merge location configuration */
  123. };


  126. ‌ngx_module_t  ngx_http_range_body_filter_module = {
  127.     NGX_MODULE_V1,
  128.     &ngx_http_range_body_filter_module_ctx, /* module context */
  129.     NULL,                                  /* module directives */
  130.     NGX_HTTP_MODULE,                       /* module type */
  131.     NULL,                                  /* init master */
  132.     NULL,                                  /* init module */
  133.     NULL,                                  /* init process */
  134.     NULL,                                  /* init thread */
  135.     NULL,                                  /* exit thread */
  136.     NULL,                                  /* exit process */
  137.     NULL,                                  /* exit master */
  138.     NGX_MODULE_V1_PADDING
  139. };


  142. ‌static ngx_http_output_header_filter_pt  ngx_http_next_header_filter;
  143. ‌static ngx_http_output_body_filter_pt    ngx_http_next_body_filter;


  146. static ngx_int_t
  147. ‌ngx_http_range_header_filter(ngx_http_request_t *r)
  148. {
  149.     time_t                        if_range_time;
  150.     ngx_str_t                    *if_range, *etag;
  151.     ngx_uint_t                    ranges;
  152.     ngx_http_core_loc_conf_t     *clcf;
  153.     ngx_http_range_filter_ctx_t  *ctx;

  155.     if (r->http_version < NGX_HTTP_VERSION_10
  156.         || r->headers_out.status != NGX_HTTP_OK
  157.         || r != r->main
  158.         || r->headers_out.content_length_n == -1
  159.         || !r->allow_ranges)
  160.     {
  161.         return ngx_http_next_header_filter(r);
  162.     }

  164.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  166.     if (clcf->max_ranges == 0) {
  167.         return ngx_http_next_header_filter(r);
  168.     }

  170.     if (r->headers_in.range == NULL
  171.         || r->headers_in.range->value.len < 7
  172.         || ngx_strncasecmp(r->headers_in.range->value.data,
  173.                            (u_char *) "bytes=", 6)
  174.            != 0)
  175.     {
  176.         goto next_filter;
  177.     }

  179.     if (r->headers_in.if_range) {

  181.         if_range = &r->headers_in.if_range->value;

  183.         if (if_range->len >= 2 && if_range->data[if_range->len - 1] == '"') {

  185.             if (r->headers_out.etag == NULL) {
  186.                 goto next_filter;
  187.             }

  189.             etag = &r->headers_out.etag->value;

  191.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  192.                            "http ir:%V etag:%V", if_range, etag);

  194.             if (if_range->len != etag->len
  195.                 || ngx_strncmp(if_range->data, etag->data, etag->len) != 0)
  196.             {
  197.                 goto next_filter;
  198.             }

  200.             goto parse;
  201.         }

  203.         if (r->headers_out.last_modified_time == (time_t) -1) {
  204.             goto next_filter;
  205.         }

  207.         if_range_time = ngx_http_parse_time(if_range->data, if_range->len);

  209.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  210.                        "http ir:%d lm:%d",
  211.                        if_range_time, r->headers_out.last_modified_time);

  213.         if (if_range_time != r->headers_out.last_modified_time) {
  214.             goto next_filter;
  215.         }
  216.     }

  218. parse:

  220.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_range_filter_ctx_t));
  221.     if (ctx == NULL) {
  222.         return NGX_ERROR;
  223.     }

  225.     if (ngx_array_init(&ctx->ranges, r->pool, 1, sizeof(ngx_http_range_t))
  226.         != NGX_OK)
  227.     {
  228.         return NGX_ERROR;
  229.     }

  231.     ranges = r->single_range ? 1 : clcf->max_ranges;

  233.     switch (ngx_http_range_parse(r, ctx, ranges)) {

  235.     case NGX_OK:
  236.         ngx_http_set_ctx(r, ctx, ngx_http_range_body_filter_module);

  238.         r->headers_out.status = NGX_HTTP_PARTIAL_CONTENT;
  239.         r->headers_out.status_line.len = 0;

  241.         if (ctx->ranges.nelts == 1) {
  242.             return ngx_http_range_singlepart_header(r, ctx);
  243.         }

  245.         return ngx_http_range_multipart_header(r, ctx);

  247.     case NGX_HTTP_RANGE_NOT_SATISFIABLE:
  248.         return ngx_http_range_not_satisfiable(r);

  250.     case NGX_ERROR:
  251.         return NGX_ERROR;

  253.     default: /* NGX_DECLINED */
  254.         break;
  255.     }

  257. next_filter:

  259.     r->headers_out.accept_ranges = ngx_list_push(&r->headers_out.headers);
  260.     if (r->headers_out.accept_ranges == NULL) {
  261.         return NGX_ERROR;
  262.     }

  264.     r->headers_out.accept_ranges->hash = 1;
  265.     ngx_str_set(&r->headers_out.accept_ranges->key, "Accept-Ranges");
  266.     ngx_str_set(&r->headers_out.accept_ranges->value, "bytes");

  268.     return ngx_http_next_header_filter(r);
  269. }


  272. static ngx_int_t
  273. ‌ngx_http_range_parse(ngx_http_request_t *r, ngx_http_range_filter_ctx_t *ctx,
  274.     ngx_uint_t ranges)
  275. {
  276.     u_char            *p;
  277.     off_t              start, end, size, content_length;
  278.     ngx_uint_t         suffix;
  279.     ngx_http_range_t  *range;

  281.     p = r->headers_in.range->value.data + 6;
  282.     size = 0;
  283.     content_length = r->headers_out.content_length_n;

  285.     for ( ;; ) {
  286.         start = 0;
  287.         end = 0;
  288.         suffix = 0;

  290.         while (*p == ' ') { p++; }

  292.         if (*p != '-') {
  293.             if (*p < '0' || *p > '9') {
  294.                 return NGX_HTTP_RANGE_NOT_SATISFIABLE;
  295.             }

  297.             while (*p >= '0' && *p <= '9') {
  298.                 start = start * 10 + *p++ - '0';
  299.             }

  301.             while (*p == ' ') { p++; }

  303.             if (*p++ != '-') {
  304.                 return NGX_HTTP_RANGE_NOT_SATISFIABLE;
  305.             }

  307.             while (*p == ' ') { p++; }

  309.             if (*p == ',' || *p == '\0') {
  310.                 end = content_length;
  311.                 goto found;
  312.             }

  314.         } else {
  315.             suffix = 1;
  316.             p++;
  317.         }

  319.         if (*p < '0' || *p > '9') {
  320.             return NGX_HTTP_RANGE_NOT_SATISFIABLE;
  321.         }

  323.         while (*p >= '0' && *p <= '9') {
  324.             end = end * 10 + *p++ - '0';
  325.         }

  327.         while (*p == ' ') { p++; }

  329.         if (*p != ',' && *p != '\0') {
  330.             return NGX_HTTP_RANGE_NOT_SATISFIABLE;
  331.         }

  333.         if (suffix) {
  334.             start = content_length - end;
  335.             end = content_length - 1;
  336.         }

  338.         if (end >= content_length) {
  339.             end = content_length;

  341.         } else {
  342.             end++;
  343.         }

  345.     found:

  347.         if (start < end) {
  348.             range = ngx_array_push(&ctx->ranges);
  349.             if (range == NULL) {
  350.                 return NGX_ERROR;
  351.             }

  353.             range->start = start;
  354.             range->end = end;

  356.             size += end - start;

  358.             if (ranges-- == 0) {
  359.                 return NGX_DECLINED;
  360.             }
  361.         }

  363.         if (*p++ != ',') {
  364.             break;
  365.         }
  366.     }

  368.     if (ctx->ranges.nelts == 0) {
  369.         return NGX_HTTP_RANGE_NOT_SATISFIABLE;
  370.     }

  372.     if (size > content_length) {
  373.         return NGX_DECLINED;
  374.     }

  376.     return NGX_OK;
  377. }


  380. static ngx_int_t
  381. ‌ngx_http_range_singlepart_header(ngx_http_request_t *r,
  382.     ngx_http_range_filter_ctx_t *ctx)
  383. {
  384.     ngx_table_elt_t   *content_range;
  385.     ngx_http_range_t  *range;

  387.     content_range = ngx_list_push(&r->headers_out.headers);
  388.     if (content_range == NULL) {
  389.         return NGX_ERROR;
  390.     }

  392.     r->headers_out.content_range = content_range;

  394.     content_range->hash = 1;
  395.     ngx_str_set(&content_range->key, "Content-Range");

  397.     content_range->value.data = ngx_pnalloc(r->pool,
  398.                                     sizeof("bytes -/") - 1 + 3 * NGX_OFF_T_LEN);
  399.     if (content_range->value.data == NULL) {
  400.         return NGX_ERROR;
  401.     }

  403.     /* "Content-Range: bytes SSSS-EEEE/TTTT" header */

  405.     range = ctx->ranges.elts;

  407.     content_range->value.len = ngx_sprintf(content_range->value.data,
  408.                                            "bytes %O-%O/%O",
  409.                                            range->start, range->end - 1,
  410.                                            r->headers_out.content_length_n)
  411.                                - content_range->value.data;

  413.     r->headers_out.content_length_n = range->end - range->start;

  415.     if (r->headers_out.content_length) {
  416.         r->headers_out.content_length->hash = 0;
  417.         r->headers_out.content_length = NULL;
  418.     }

  420.     return ngx_http_next_header_filter(r);
  421. }


  424. static ngx_int_t
  425. ‌ngx_http_range_multipart_header(ngx_http_request_t *r,
  426.     ngx_http_range_filter_ctx_t *ctx)
  427. {
  428.     size_t              len;
  429.     ngx_uint_t          i;
  430.     ngx_http_range_t   *range;
  431.     ngx_atomic_uint_t   boundary;

  433.     len = sizeof(CRLF "--") - 1 + NGX_ATOMIC_T_LEN
  434.           + sizeof(CRLF "Content-Type: ") - 1
  435.           + r->headers_out.content_type.len
  436.           + sizeof(CRLF "Content-Range: bytes ") - 1;

  438.     if (r->headers_out.content_type_len == r->headers_out.content_type.len
  439.         && r->headers_out.charset.len)
  440.     {
  441.         len += sizeof("; charset=") - 1 + r->headers_out.charset.len;
  442.     }

  444.     ctx->boundary_header.data = ngx_pnalloc(r->pool, len);
  445.     if (ctx->boundary_header.data == NULL) {
  446.         return NGX_ERROR;
  447.     }

  449.     boundary = ngx_next_temp_number(0);

  451.     /*
  452.      * The boundary header of the range:
  453.      * CRLF
  454.      * "--0123456789" CRLF
  455.      * "Content-Type: image/jpeg" CRLF
  456.      * "Content-Range: bytes "
  457.      */

  459.     if (r->headers_out.content_type_len == r->headers_out.content_type.len
  460.         && r->headers_out.charset.len)
  461.     {
  462.         ctx->boundary_header.len = ngx_sprintf(ctx->boundary_header.data,
  463.                                            CRLF "--%0muA" CRLF
  464.                                            "Content-Type: %V; charset=%V" CRLF
  465.                                            "Content-Range: bytes ",
  466.                                            boundary,
  467.                                            &r->headers_out.content_type,
  468.                                            &r->headers_out.charset)
  469.                                    - ctx->boundary_header.data;

  471.     } else if (r->headers_out.content_type.len) {
  472.         ctx->boundary_header.len = ngx_sprintf(ctx->boundary_header.data,
  473.                                            CRLF "--%0muA" CRLF
  474.                                            "Content-Type: %V" CRLF
  475.                                            "Content-Range: bytes ",
  476.                                            boundary,
  477.                                            &r->headers_out.content_type)
  478.                                    - ctx->boundary_header.data;

  480.     } else {
  481.         ctx->boundary_header.len = ngx_sprintf(ctx->boundary_header.data,
  482.                                            CRLF "--%0muA" CRLF
  483.                                            "Content-Range: bytes ",
  484.                                            boundary)
  485.                                    - ctx->boundary_header.data;
  486.     }

  488.     r->headers_out.content_type.data =
  489.         ngx_pnalloc(r->pool,
  490.                     sizeof("Content-Type: multipart/byteranges; boundary=") - 1
  491.                     + NGX_ATOMIC_T_LEN);

  493.     if (r->headers_out.content_type.data == NULL) {
  494.         return NGX_ERROR;
  495.     }

  497.     r->headers_out.content_type_lowcase = NULL;

  499.     /* "Content-Type: multipart/byteranges; boundary=0123456789" */

  501.     r->headers_out.content_type.len =
  502.                            ngx_sprintf(r->headers_out.content_type.data,
  503.                                        "multipart/byteranges; boundary=%0muA",
  504.                                        boundary)
  505.                            - r->headers_out.content_type.data;

  507.     r->headers_out.content_type_len = r->headers_out.content_type.len;

  509.     r->headers_out.charset.len = 0;

  511.     /* the size of the last boundary CRLF "--0123456789--" CRLF */

  513.     len = sizeof(CRLF "--") - 1 + NGX_ATOMIC_T_LEN + sizeof("--" CRLF) - 1;

  515.     range = ctx->ranges.elts;
  516.     for (i = 0; i < ctx->ranges.nelts; i++) {

  518.         /* the size of the range: "SSSS-EEEE/TTTT" CRLF CRLF */

  520.         range[i].content_range.data =
  521.                                ngx_pnalloc(r->pool, 3 * NGX_OFF_T_LEN + 2 + 4);

  523.         if (range[i].content_range.data == NULL) {
  524.             return NGX_ERROR;
  525.         }

  527.         range[i].content_range.len = ngx_sprintf(range[i].content_range.data,
  528.                                                "%O-%O/%O" CRLF CRLF,
  529.                                                range[i].start, range[i].end - 1,
  530.                                                r->headers_out.content_length_n)
  531.                                      - range[i].content_range.data;

  533.         len += ctx->boundary_header.len + range[i].content_range.len
  534.                                     + (size_t) (range[i].end - range[i].start);
  535.     }

  537.     r->headers_out.content_length_n = len;

  539.     if (r->headers_out.content_length) {
  540.         r->headers_out.content_length->hash = 0;
  541.         r->headers_out.content_length = NULL;
  542.     }

  544.     return ngx_http_next_header_filter(r);
  545. }


  548. static ngx_int_t
  549. ‌ngx_http_range_not_satisfiable(ngx_http_request_t *r)
  550. {
  551.     ngx_table_elt_t  *content_range;

  553.     r->headers_out.status = NGX_HTTP_RANGE_NOT_SATISFIABLE;

  555.     content_range = ngx_list_push(&r->headers_out.headers);
  556.     if (content_range == NULL) {
  557.         return NGX_ERROR;
  558.     }

  560.     r->headers_out.content_range = content_range;

  562.     content_range->hash = 1;
  563.     ngx_str_set(&content_range->key, "Content-Range");

  565.     content_range->value.data = ngx_pnalloc(r->pool,
  566.                                        sizeof("bytes */") - 1 + NGX_OFF_T_LEN);
  567.     if (content_range->value.data == NULL) {
  568.         return NGX_ERROR;
  569.     }

  571.     content_range->value.len = ngx_sprintf(content_range->value.data,
  572.                                            "bytes */%O",
  573.                                            r->headers_out.content_length_n)
  574.                                - content_range->value.data;

  576.     ngx_http_clear_content_length(r);

  578.     return NGX_HTTP_RANGE_NOT_SATISFIABLE;
  579. }


  582. static ngx_int_t
  583. ‌ngx_http_range_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  584. {
  585.     ngx_http_range_filter_ctx_t  *ctx;

  587.     if (in == NULL) {
  588.         return ngx_http_next_body_filter(r, in);
  589.     }

  591.     ctx = ngx_http_get_module_ctx(r, ngx_http_range_body_filter_module);

  593.     if (ctx == NULL) {
  594.         return ngx_http_next_body_filter(r, in);
  595.     }

  597.     if (ctx->ranges.nelts == 1) {
  598.         return ngx_http_range_singlepart_body(r, ctx, in);
  599.     }

  601.     /*
  602.      * multipart ranges are supported only if whole body is in a single buffer
  603.      */

  605.     if (ngx_buf_special(in->buf)) {
  606.         return ngx_http_next_body_filter(r, in);
  607.     }

  609.     if (ngx_http_range_test_overlapped(r, ctx, in) != NGX_OK) {
  610.         return NGX_ERROR;
  611.     }

  613.     return ngx_http_range_multipart_body(r, ctx, in);
  614. }


  617. static ngx_int_t
  618. ‌ngx_http_range_test_overlapped(ngx_http_request_t *r,
  619.     ngx_http_range_filter_ctx_t *ctx, ngx_chain_t *in)
  620. {
  621.     off_t              start, last;
  622.     ngx_buf_t         *buf;
  623.     ngx_uint_t         i;
  624.     ngx_http_range_t  *range;

  626.     if (ctx->offset) {
  627.         goto overlapped;
  628.     }

  630.     buf = in->buf;

  632.     if (!buf->last_buf) {
  633.         start = ctx->offset;
  634.         last = ctx->offset + ngx_buf_size(buf);

  636.         range = ctx->ranges.elts;
  637.         for (i = 0; i < ctx->ranges.nelts; i++) {
  638.             if (start > range[i].start || last < range[i].end) {
  639.                  goto overlapped;
  640.             }
  641.         }
  642.     }

  644.     ctx->offset = ngx_buf_size(buf);

  646.     return NGX_OK;

  648. overlapped:

  650.     ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  651.                   "range in overlapped buffers");

  653.     return NGX_ERROR;
  654. }


  657. static ngx_int_t
  658. ‌ngx_http_range_singlepart_body(ngx_http_request_t *r,
  659.     ngx_http_range_filter_ctx_t *ctx, ngx_chain_t *in)
  660. {
  661.     off_t              start, last;
  662.     ngx_buf_t         *buf;
  663.     ngx_chain_t       *out, *cl, **ll;
  664.     ngx_http_range_t  *range;

  666.     out = NULL;
  667.     ll = &out;
  668.     range = ctx->ranges.elts;

  670.     for (cl = in; cl; cl = cl->next) {

  672.         buf = cl->buf;

  674.         start = ctx->offset;
  675.         last = ctx->offset + ngx_buf_size(buf);

  677.         ctx->offset = last;

  679.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  680.                        "http range body buf: %O-%O", start, last);

  682.         if (ngx_buf_special(buf)) {
  683.             *ll = cl;
  684.             ll = &cl->next;
  685.             continue;
  686.         }

  688.         if (range->end <= start || range->start >= last) {

  690.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  691.                            "http range body skip");

  693.             if (buf->in_file) {
  694.                 buf->file_pos = buf->file_last;
  695.             }

  697.             buf->pos = buf->last;
  698.             buf->sync = 1;

  700.             continue;
  701.         }

  703.         if (range->start > start) {

  705.             if (buf->in_file) {
  706.                 buf->file_pos += range->start - start;
  707.             }

  709.             if (ngx_buf_in_memory(buf)) {
  710.                 buf->pos += (size_t) (range->start - start);
  711.             }
  712.         }

  714.         if (range->end <= last) {

  716.             if (buf->in_file) {
  717.                 buf->file_last -= last - range->end;
  718.             }

  720.             if (ngx_buf_in_memory(buf)) {
  721.                 buf->last -= (size_t) (last - range->end);
  722.             }

  724.             buf->last_buf = 1;
  725.             *ll = cl;
  726.             cl->next = NULL;

  728.             break;
  729.         }

  731.         *ll = cl;
  732.         ll = &cl->next;
  733.     }

  735.     if (out == NULL) {
  736.         return NGX_OK;
  737.     }

  739.     return ngx_http_next_body_filter(r, out);
  740. }


  743. static ngx_int_t
  744. ‌ngx_http_range_multipart_body(ngx_http_request_t *r,
  745.     ngx_http_range_filter_ctx_t *ctx, ngx_chain_t *in)
  746. {
  747.     ngx_buf_t         *b, *buf;
  748.     ngx_uint_t         i;
  749.     ngx_chain_t       *out, *hcl, *rcl, *dcl, **ll;
  750.     ngx_http_range_t  *range;

  752.     ll = &out;
  753.     buf = in->buf;
  754.     range = ctx->ranges.elts;

  756.     for (i = 0; i < ctx->ranges.nelts; i++) {

  758.         /*
  759.          * The boundary header of the range:
  760.          * CRLF
  761.          * "--0123456789" CRLF
  762.          * "Content-Type: image/jpeg" CRLF
  763.          * "Content-Range: bytes "
  764.          */

  766.         b = ngx_calloc_buf(r->pool);
  767.         if (b == NULL) {
  768.             return NGX_ERROR;
  769.         }

  771.         b->memory = 1;
  772.         b->pos = ctx->boundary_header.data;
  773.         b->last = ctx->boundary_header.data + ctx->boundary_header.len;

  775.         hcl = ngx_alloc_chain_link(r->pool);
  776.         if (hcl == NULL) {
  777.             return NGX_ERROR;
  778.         }

  780.         hcl->buf = b;


  783.         /* "SSSS-EEEE/TTTT" CRLF CRLF */

  785.         b = ngx_calloc_buf(r->pool);
  786.         if (b == NULL) {
  787.             return NGX_ERROR;
  788.         }

  790.         b->temporary = 1;
  791.         b->pos = range[i].content_range.data;
  792.         b->last = range[i].content_range.data + range[i].content_range.len;

  794.         rcl = ngx_alloc_chain_link(r->pool);
  795.         if (rcl == NULL) {
  796.             return NGX_ERROR;
  797.         }

  799.         rcl->buf = b;


  802.         /* the range data */

  804.         b = ngx_calloc_buf(r->pool);
  805.         if (b == NULL) {
  806.             return NGX_ERROR;
  807.         }

  809.         b->in_file = buf->in_file;
  810.         b->temporary = buf->temporary;
  811.         b->memory = buf->memory;
  812.         b->mmap = buf->mmap;
  813.         b->file = buf->file;

  815.         if (buf->in_file) {
  816.             b->file_pos = buf->file_pos + range[i].start;
  817.             b->file_last = buf->file_pos + range[i].end;
  818.         }

  820.         if (ngx_buf_in_memory(buf)) {
  821.             b->pos = buf->pos + (size_t) range[i].start;
  822.             b->last = buf->pos + (size_t) range[i].end;
  823.         }

  825.         dcl = ngx_alloc_chain_link(r->pool);
  826.         if (dcl == NULL) {
  827.             return NGX_ERROR;
  828.         }

  830.         dcl->buf = b;

  832.         *ll = hcl;
  833.         hcl->next = rcl;
  834.         rcl->next = dcl;
  835.         ll = &dcl->next;
  836.     }

  838.     /* the last boundary CRLF "--0123456789--" CRLF  */

  840.     b = ngx_calloc_buf(r->pool);
  841.     if (b == NULL) {
  842.         return NGX_ERROR;
  843.     }

  845.     b->temporary = 1;
  846.     b->last_buf = 1;

  848.     b->pos = ngx_pnalloc(r->pool, sizeof(CRLF "--") - 1 + NGX_ATOMIC_T_LEN
  849.                                   + sizeof("--" CRLF) - 1);
  850.     if (b->pos == NULL) {
  851.         return NGX_ERROR;
  852.     }

  854.     b->last = ngx_cpymem(b->pos, ctx->boundary_header.data,
  855.                          sizeof(CRLF "--") - 1 + NGX_ATOMIC_T_LEN);
  856.     *b->last++ = '-'; *b->last++ = '-';
  857.     *b->last++ = CR; *b->last++ = LF;

  859.     hcl = ngx_alloc_chain_link(r->pool);
  860.     if (hcl == NULL) {
  861.         return NGX_ERROR;
  862.     }

  864.     hcl->buf = b;
  865.     hcl->next = NULL;

  867.     *ll = hcl;

  869.     return ngx_http_next_body_filter(r, out);
  870. }


  873. static ngx_int_t
  874. ‌ngx_http_range_header_filter_init(ngx_conf_t *cf)
  875. {
  876.     ngx_http_next_header_filter = ngx_http_top_header_filter;
  877.     ngx_http_top_header_filter = ngx_http_range_header_filter;

  879.     return NGX_OK;
  880. }


  883. static ngx_int_t
  884. ‌ngx_http_range_body_filter_init(ngx_conf_t *cf)
  885. {
  886.     ngx_http_next_body_filter = ngx_http_top_body_filter;
  887.     ngx_http_top_body_filter = ngx_http_range_body_filter;

  889.     return NGX_OK;
  890. }

One Level Up Top Level