Return to http_chunk.c CVS log

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

Annotation of embedaddon/lighttpd/src/http_chunk.c, revision 1.1

1.1     ! misho       1: /**
        !             2:  * the HTTP chunk-API
        !             3:  *
        !             4:  *
        !             5:  */
        !             6: 
        !             7: #include "server.h"
        !             8: #include "chunk.h"
        !             9: #include "http_chunk.h"
        !            10: #include "log.h"
        !            11: 
        !            12: #include <sys/types.h>
        !            13: #include <sys/stat.h>
        !            14: 
        !            15: #include <stdlib.h>
        !            16: #include <fcntl.h>
        !            17: #include <unistd.h>
        !            18: 
        !            19: #include <stdio.h>
        !            20: #include <errno.h>
        !            21: #include <string.h>
        !            22: 
        !            23: static int http_chunk_append_len(server *srv, connection *con, size_t len) {
        !            24:        size_t i, olen = len, j;
        !            25:        buffer *b;
        !            26: 
        !            27:        b = srv->tmp_chunk_len;
        !            28: 
        !            29:        if (len == 0) {
        !            30:                buffer_copy_string_len(b, CONST_STR_LEN("0"));
        !            31:        } else {
        !            32:                for (i = 0; i < 8 && len; i++) {
        !            33:                        len >>= 4;
        !            34:                }
        !            35: 
        !            36:                /* i is the number of hex digits we have */
        !            37:                buffer_prepare_copy(b, i + 1);
        !            38: 
        !            39:                for (j = i-1, len = olen; j+1 > 0; j--) {
        !            40:                        b->ptr[j] = (len & 0xf) + (((len & 0xf) <= 9) ? '0' : 'a' - 10);
        !            41:                        len >>= 4;
        !            42:                }
        !            43:                b->used = i;
        !            44:                b->ptr[b->used++] = '\0';
        !            45:        }
        !            46: 
        !            47:        buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
        !            48:        chunkqueue_append_buffer(con->write_queue, b);
        !            49: 
        !            50:        return 0;
        !            51: }
        !            52: 
        !            53: 
        !            54: int http_chunk_append_file(server *srv, connection *con, buffer *fn, off_t offset, off_t len) {
        !            55:        chunkqueue *cq;
        !            56: 
        !            57:        if (!con) return -1;
        !            58: 
        !            59:        cq = con->write_queue;
        !            60: 
        !            61:        if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
        !            62:                http_chunk_append_len(srv, con, len);
        !            63:        }
        !            64: 
        !            65:        chunkqueue_append_file(cq, fn, offset, len);
        !            66: 
        !            67:        if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED && len > 0) {
        !            68:                chunkqueue_append_mem(cq, "\r\n", 2 + 1);
        !            69:        }
        !            70: 
        !            71:        return 0;
        !            72: }
        !            73: 
        !            74: int http_chunk_append_buffer(server *srv, connection *con, buffer *mem) {
        !            75:        chunkqueue *cq;
        !            76: 
        !            77:        if (!con) return -1;
        !            78: 
        !            79:        cq = con->write_queue;
        !            80: 
        !            81:        if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
        !            82:                http_chunk_append_len(srv, con, mem->used - 1);
        !            83:        }
        !            84: 
        !            85:        chunkqueue_append_buffer(cq, mem);
        !            86: 
        !            87:        if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED && mem->used > 0) {
        !            88:                chunkqueue_append_mem(cq, "\r\n", 2 + 1);
        !            89:        }
        !            90: 
        !            91:        return 0;
        !            92: }
        !            93: 
        !            94: int http_chunk_append_mem(server *srv, connection *con, const char * mem, size_t len) {
        !            95:        chunkqueue *cq;
        !            96: 
        !            97:        if (!con) return -1;
        !            98: 
        !            99:        cq = con->write_queue;
        !           100: 
        !           101:        if (len == 0) {
        !           102:                if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
        !           103:                        chunkqueue_append_mem(cq, "0\r\n\r\n", 5 + 1);
        !           104:                } else {
        !           105:                        chunkqueue_append_mem(cq, "", 1);
        !           106:                }
        !           107:                return 0;
        !           108:        }
        !           109: 
        !           110:        if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
        !           111:                http_chunk_append_len(srv, con, len - 1);
        !           112:        }
        !           113: 
        !           114:        chunkqueue_append_mem(cq, mem, len);
        !           115: 
        !           116:        if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
        !           117:                chunkqueue_append_mem(cq, "\r\n", 2 + 1);
        !           118:        }
        !           119: 
        !           120:        return 0;
        !           121: }
        !           122: 
        !           123: 
        !           124: off_t http_chunkqueue_length(server *srv, connection *con) {
        !           125:        if (!con) {
        !           126:                log_error_write(srv, __FILE__, __LINE__, "s", "connection is NULL!!");
        !           127: 
        !           128:                return 0;
        !           129:        }
        !           130: 
        !           131:        return chunkqueue_length(con->write_queue);
        !           132: }