One Level Up Top Level

src/core/ngx_buf.c - nginx-1.7.10

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>


  12. ngx_buf_t *
  13. ‌ngx_create_temp_buf(ngx_pool_t *pool, size_t size)
  14. {
  15.     ngx_buf_t *b;

  17.     b = ngx_calloc_buf(pool);
  18.     if (b == NULL) {
  19.         return NULL;
  20.     }

  22.     b->start = ngx_palloc(pool, size);
  23.     if (b->start == NULL) {
  24.         return NULL;
  25.     }

  27.     /*
  28.      * set by ngx_calloc_buf():
  29.      *
  30.      *     b->file_pos = 0;
  31.      *     b->file_last = 0;
  32.      *     b->file = NULL;
  33.      *     b->shadow = NULL;
  34.      *     b->tag = 0;
  35.      *     and flags
  36.      */

  38.     b->pos = b->start;
  39.     b->last = b->start;
  40.     b->end = b->last + size;
  41.     b->temporary = 1;

  43.     return b;
  44. }


  47. ngx_chain_t *
  48. ‌ngx_alloc_chain_link(ngx_pool_t *pool)
  49. {
  50.     ngx_chain_t  *cl;

  52.     cl = pool->chain;

  54.     if (cl) {
  55.         pool->chain = cl->next;
  56.         return cl;
  57.     }

  59.     cl = ngx_palloc(pool, sizeof(ngx_chain_t));
  60.     if (cl == NULL) {
  61.         return NULL;
  62.     }

  64.     return cl;
  65. }


  68. ngx_chain_t *
  69. ‌ngx_create_chain_of_bufs(ngx_pool_t *pool, ngx_bufs_t *bufs)
  70. {
  71.     u_char       *p;
  72.     ngx_int_t     i;
  73.     ngx_buf_t    *b;
  74.     ngx_chain_t  *chain, *cl, **ll;

  76.     p = ngx_palloc(pool, bufs->num * bufs->size);
  77.     if (p == NULL) {
  78.         return NULL;
  79.     }

  81.     ll = &chain;

  83.     for (i = 0; i < bufs->num; i++) {

  85.         b = ngx_calloc_buf(pool);
  86.         if (b == NULL) {
  87.             return NULL;
  88.         }

  90.         /*
  91.          * set by ngx_calloc_buf():
  92.          *
  93.          *     b->file_pos = 0;
  94.          *     b->file_last = 0;
  95.          *     b->file = NULL;
  96.          *     b->shadow = NULL;
  97.          *     b->tag = 0;
  98.          *     and flags
  99.          *
  100.          */

  102.         b->pos = p;
  103.         b->last = p;
  104.         b->temporary = 1;

  106.         b->start = p;
  107.         p += bufs->size;
  108.         b->end = p;

  110.         cl = ngx_alloc_chain_link(pool);
  111.         if (cl == NULL) {
  112.             return NULL;
  113.         }

  115.         cl->buf = b;
  116.         *ll = cl;
  117.         ll = &cl->next;
  118.     }

  120.     *ll = NULL;

  122.     return chain;
  123. }


  126. ngx_int_t
  127. ‌ngx_chain_add_copy(ngx_pool_t *pool, ngx_chain_t **chain, ngx_chain_t *in)
  128. {
  129.     ngx_chain_t  *cl, **ll;

  131.     ll = chain;

  133.     for (cl = *chain; cl; cl = cl->next) {
  134.         ll = &cl->next;
  135.     }

  137.     while (in) {
  138.         cl = ngx_alloc_chain_link(pool);
  139.         if (cl == NULL) {
  140.             return NGX_ERROR;
  141.         }

  143.         cl->buf = in->buf;
  144.         *ll = cl;
  145.         ll = &cl->next;
  146.         in = in->next;
  147.     }

  149.     *ll = NULL;

  151.     return NGX_OK;
  152. }


  155. ngx_chain_t *
  156. ‌ngx_chain_get_free_buf(ngx_pool_t *p, ngx_chain_t **free)
  157. {
  158.     ngx_chain_t  *cl;

  160.     if (*free) {
  161.         cl = *free;
  162.         *free = cl->next;
  163.         cl->next = NULL;
  164.         return cl;
  165.     }

  167.     cl = ngx_alloc_chain_link(p);
  168.     if (cl == NULL) {
  169.         return NULL;
  170.     }

  172.     cl->buf = ngx_calloc_buf(p);
  173.     if (cl->buf == NULL) {
  174.         return NULL;
  175.     }

  177.     cl->next = NULL;

  179.     return cl;
  180. }


  183. void
  184. ‌ngx_chain_update_chains(ngx_pool_t *p, ngx_chain_t **free, ngx_chain_t **busy,
  185.     ngx_chain_t **out, ngx_buf_tag_t tag)
  186. {
  187.     ngx_chain_t  *cl;

  189.     if (*busy == NULL) {
  190.         *busy = *out;

  192.     } else {
  193.         for (cl = *busy; cl->next; cl = cl->next) { /* void */ }

  195.         cl->next = *out;
  196.     }

  198.     *out = NULL;

  200.     while (*busy) {
  201.         cl = *busy;

  203.         if (ngx_buf_size(cl->buf) != 0) {
  204.             break;
  205.         }

  207.         if (cl->buf->tag != tag) {
  208.             *busy = cl->next;
  209.             ngx_free_chain(p, cl);
  210.             continue;
  211.         }

  213.         cl->buf->pos = cl->buf->start;
  214.         cl->buf->last = cl->buf->start;

  216.         *busy = cl->next;
  217.         cl->next = *free;
  218.         *free = cl;
  219.     }
  220. }


  223. off_t
  224. ‌ngx_chain_coalesce_file(ngx_chain_t **in, off_t limit)
  225. {
  226.     off_t         total, size, aligned, fprev;
  227.     ngx_fd_t      fd;
  228.     ngx_chain_t  *cl;

  230.     total = 0;

  232.     cl = *in;
  233.     fd = cl->buf->file->fd;

  235.     do {
  236.         size = cl->buf->file_last - cl->buf->file_pos;

  238.         if (size > limit - total) {
  239.             size = limit - total;

  241.             aligned = (cl->buf->file_pos + size + ngx_pagesize - 1)
  242.                        & ~((off_t) ngx_pagesize - 1);

  244.             if (aligned <= cl->buf->file_last) {
  245.                 size = aligned - cl->buf->file_pos;
  246.             }
  247.         }

  249.         total += size;
  250.         fprev = cl->buf->file_pos + size;
  251.         cl = cl->next;

  253.     } while (cl
  254.              && cl->buf->in_file
  255.              && total < limit
  256.              && fd == cl->buf->file->fd
  257.              && fprev == cl->buf->file_pos);

  259.     *in = cl;

  261.     return total;
  262. }


  265. ngx_chain_t *
  266. ‌ngx_chain_update_sent(ngx_chain_t *in, off_t sent)
  267. {
  268.     off_t  size;

  270.     for ( /* void */ ; in; in = in->next) {

  272.         if (ngx_buf_special(in->buf)) {
  273.             continue;
  274.         }

  276.         if (sent == 0) {
  277.             break;
  278.         }

  280.         size = ngx_buf_size(in->buf);

  282.         if (sent >= size) {
  283.             sent -= size;

  285.             if (ngx_buf_in_memory(in->buf)) {
  286.                 in->buf->pos = in->buf->last;
  287.             }

  289.             if (in->buf->in_file) {
  290.                 in->buf->file_pos = in->buf->file_last;
  291.             }

  293.             continue;
  294.         }

  296.         if (ngx_buf_in_memory(in->buf)) {
  297.             in->buf->pos += (size_t) sent;
  298.         }

  300.         if (in->buf->in_file) {
  301.             in->buf->file_pos += sent;
  302.         }

  304.         break;
  305.     }

  307.     return in;
  308. }

One Level Up Top Level