Return to ngx_buf.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / core

Annotation of embedaddon/nginx/src/core/ngx_buf.c, revision 1.1

1.1     ! misho       1: 
        !             2: /*
        !             3:  * Copyright (C) Igor Sysoev
        !             4:  * Copyright (C) Nginx, Inc.
        !             5:  */
        !             6: 
        !             7: 
        !             8: #include <ngx_config.h>
        !             9: #include <ngx_core.h>
        !            10: 
        !            11: 
        !            12: ngx_buf_t *
        !            13: ngx_create_temp_buf(ngx_pool_t *pool, size_t size)
        !            14: {
        !            15:     ngx_buf_t *b;
        !            16: 
        !            17:     b = ngx_calloc_buf(pool);
        !            18:     if (b == NULL) {
        !            19:         return NULL;
        !            20:     }
        !            21: 
        !            22:     b->start = ngx_palloc(pool, size);
        !            23:     if (b->start == NULL) {
        !            24:         return NULL;
        !            25:     }
        !            26: 
        !            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:      */
        !            37: 
        !            38:     b->pos = b->start;
        !            39:     b->last = b->start;
        !            40:     b->end = b->last + size;
        !            41:     b->temporary = 1;
        !            42: 
        !            43:     return b;
        !            44: }
        !            45: 
        !            46: 
        !            47: ngx_chain_t *
        !            48: ngx_alloc_chain_link(ngx_pool_t *pool)
        !            49: {
        !            50:     ngx_chain_t  *cl;
        !            51: 
        !            52:     cl = pool->chain;
        !            53: 
        !            54:     if (cl) {
        !            55:         pool->chain = cl->next;
        !            56:         return cl;
        !            57:     }
        !            58: 
        !            59:     cl = ngx_palloc(pool, sizeof(ngx_chain_t));
        !            60:     if (cl == NULL) {
        !            61:         return NULL;
        !            62:     }
        !            63: 
        !            64:     return cl;
        !            65: }
        !            66: 
        !            67: 
        !            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;
        !            75: 
        !            76:     p = ngx_palloc(pool, bufs->num * bufs->size);
        !            77:     if (p == NULL) {
        !            78:         return NULL;
        !            79:     }
        !            80: 
        !            81:     ll = &chain;
        !            82: 
        !            83:     for (i = 0; i < bufs->num; i++) {
        !            84: 
        !            85:         b = ngx_calloc_buf(pool);
        !            86:         if (b == NULL) {
        !            87:             return NULL;
        !            88:         }
        !            89: 
        !            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:          */
        !           101: 
        !           102:         b->pos = p;
        !           103:         b->last = p;
        !           104:         b->temporary = 1;
        !           105: 
        !           106:         b->start = p;
        !           107:         p += bufs->size;
        !           108:         b->end = p;
        !           109: 
        !           110:         cl = ngx_alloc_chain_link(pool);
        !           111:         if (cl == NULL) {
        !           112:             return NULL;
        !           113:         }
        !           114: 
        !           115:         cl->buf = b;
        !           116:         *ll = cl;
        !           117:         ll = &cl->next;
        !           118:     }
        !           119: 
        !           120:     *ll = NULL;
        !           121: 
        !           122:     return chain;
        !           123: }
        !           124: 
        !           125: 
        !           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;
        !           130: 
        !           131:     ll = chain;
        !           132: 
        !           133:     for (cl = *chain; cl; cl = cl->next) {
        !           134:         ll = &cl->next;
        !           135:     }
        !           136: 
        !           137:     while (in) {
        !           138:         cl = ngx_alloc_chain_link(pool);
        !           139:         if (cl == NULL) {
        !           140:             return NGX_ERROR;
        !           141:         }
        !           142: 
        !           143:         cl->buf = in->buf;
        !           144:         *ll = cl;
        !           145:         ll = &cl->next;
        !           146:         in = in->next;
        !           147:     }
        !           148: 
        !           149:     *ll = NULL;
        !           150: 
        !           151:     return NGX_OK;
        !           152: }
        !           153: 
        !           154: 
        !           155: ngx_chain_t *
        !           156: ngx_chain_get_free_buf(ngx_pool_t *p, ngx_chain_t **free)
        !           157: {
        !           158:     ngx_chain_t  *cl;
        !           159: 
        !           160:     if (*free) {
        !           161:         cl = *free;
        !           162:         *free = cl->next;
        !           163:         cl->next = NULL;
        !           164:         return cl;
        !           165:     }
        !           166: 
        !           167:     cl = ngx_alloc_chain_link(p);
        !           168:     if (cl == NULL) {
        !           169:         return NULL;
        !           170:     }
        !           171: 
        !           172:     cl->buf = ngx_calloc_buf(p);
        !           173:     if (cl->buf == NULL) {
        !           174:         return NULL;
        !           175:     }
        !           176: 
        !           177:     cl->next = NULL;
        !           178: 
        !           179:     return cl;
        !           180: }
        !           181: 
        !           182: 
        !           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;
        !           188: 
        !           189:     if (*busy == NULL) {
        !           190:         *busy = *out;
        !           191: 
        !           192:     } else {
        !           193:         for (cl = *busy; cl->next; cl = cl->next) { /* void */ }
        !           194: 
        !           195:         cl->next = *out;
        !           196:     }
        !           197: 
        !           198:     *out = NULL;
        !           199: 
        !           200:     while (*busy) {
        !           201:         cl = *busy;
        !           202: 
        !           203:         if (ngx_buf_size(cl->buf) != 0) {
        !           204:             break;
        !           205:         }
        !           206: 
        !           207:         if (cl->buf->tag != tag) {
        !           208:             *busy = cl->next;
        !           209:             ngx_free_chain(p, cl);
        !           210:             continue;
        !           211:         }
        !           212: 
        !           213:         cl->buf->pos = cl->buf->start;
        !           214:         cl->buf->last = cl->buf->start;
        !           215: 
        !           216:         *busy = cl->next;
        !           217:         cl->next = *free;
        !           218:         *free = cl;
        !           219:     }
        !           220: }