diff options
Diffstat (limited to 'data/lighttpd/lighttpd-1.4.53/src/http_chunk.c')
-rw-r--r-- | data/lighttpd/lighttpd-1.4.53/src/http_chunk.c | 236 |
1 files changed, 236 insertions, 0 deletions
diff --git a/data/lighttpd/lighttpd-1.4.53/src/http_chunk.c b/data/lighttpd/lighttpd-1.4.53/src/http_chunk.c new file mode 100644 index 000000000..1bdf2fa89 --- /dev/null +++ b/data/lighttpd/lighttpd-1.4.53/src/http_chunk.c @@ -0,0 +1,236 @@ +#include "first.h" + +/** + * the HTTP chunk-API + * + * + */ + +#include "base.h" +#include "chunk.h" +#include "http_chunk.h" +#include "stat_cache.h" +#include "fdevent.h" +#include "log.h" + +#include <sys/types.h> +#include <sys/stat.h> + +#include <stdlib.h> +#include <unistd.h> + +#include <errno.h> +#include <string.h> + +static buffer * http_chunk_header(buffer *b, uintmax_t len) { + buffer_clear(b); + buffer_append_uint_hex(b, len); + buffer_append_string_len(b, CONST_STR_LEN("\r\n")); + return b; +} + +static void http_chunk_append_len(server *srv, connection *con, uintmax_t len) { + buffer *b = http_chunk_header(srv->tmp_chunk_len, len); + chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(b)); +} + +static int http_chunk_append_file_open_fstat(server *srv, connection *con, buffer *fn, struct stat *st) { + if (!con->conf.follow_symlink) { + /*(preserve existing stat_cache symlink checks)*/ + stat_cache_entry *sce; + if (HANDLER_ERROR == stat_cache_get_entry(srv, con, fn, &sce)) return -1; + } + + return stat_cache_open_rdonly_fstat(srv, con, fn, st); +} + +static void http_chunk_append_file_fd_range(server *srv, connection *con, buffer *fn, int fd, off_t offset, off_t len) { + chunkqueue *cq = con->write_queue; + + if (con->response.send_chunked) { + http_chunk_append_len(srv, con, (uintmax_t)len); + } + + chunkqueue_append_file_fd(cq, fn, fd, offset, len); + + if (con->response.send_chunked) { + chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n")); + } +} + +int http_chunk_append_file_range(server *srv, connection *con, buffer *fn, off_t offset, off_t len) { + struct stat st; + const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st); + if (fd < 0) return -1; + + if (-1 == len) { + if (offset >= st.st_size) { + close(fd); + return (offset == st.st_size) ? 0 : -1; + } + len = st.st_size - offset; + } else if (st.st_size - offset < len) { + close(fd); + return -1; + } + + http_chunk_append_file_fd_range(srv, con, fn, fd, offset, len); + return 0; +} + +int http_chunk_append_file(server *srv, connection *con, buffer *fn) { + struct stat st; + const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st); + if (fd < 0) return -1; + + if (0 != st.st_size) { + http_chunk_append_file_fd_range(srv, con, fn, fd, 0, st.st_size); + } else { + close(fd); + } + return 0; +} + +static int http_chunk_append_to_tempfile(server *srv, connection *con, const char * mem, size_t len) { + chunkqueue * const cq = con->write_queue; + + if (con->response.send_chunked) { + buffer *b = http_chunk_header(srv->tmp_chunk_len, len); + if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_BUF_LEN(b))) { + return -1; + } + } + + if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, mem, len)) { + return -1; + } + + if (con->response.send_chunked) { + if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_STR_LEN("\r\n"))) { + return -1; + } + } + + return 0; +} + +static int http_chunk_append_cq_to_tempfile(server *srv, connection *con, chunkqueue *src, size_t len) { + chunkqueue * const cq = con->write_queue; + + if (con->response.send_chunked) { + buffer *b = http_chunk_header(srv->tmp_chunk_len, len); + if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_BUF_LEN(b))) { + return -1; + } + } + + if (0 != chunkqueue_steal_with_tempfiles(srv, cq, src, len)) { + return -1; + } + + if (con->response.send_chunked) { + if (0!=chunkqueue_append_mem_to_tempfile(srv,cq,CONST_STR_LEN("\r\n"))){ + return -1; + } + } + + return 0; +} + +static int http_chunk_uses_tempfile(server *srv, connection *con, size_t len) { + chunkqueue * const cq = con->write_queue; + chunk *c = cq->last; + UNUSED(srv); + + /* current usage does not append_mem or append_buffer after appending + * file, so not checking if users of this interface have appended large + * (references to) files to chunkqueue, which would not be in memory + * (but included in calculation for whether or not to use temp file) */ + + /*(allow slightly larger mem use if FDEVENT_STREAM_RESPONSE_BUFMIN + * to reduce creation of temp files when backend producer will be + * blocked until more data is sent to network to client)*/ + + if ((c && c->type == FILE_CHUNK && c->file.is_temp) + || cq->bytes_in - cq->bytes_out + len + > 1024 * ((con->conf.stream_response_body & FDEVENT_STREAM_RESPONSE_BUFMIN) ? 128 : 64)) { + return 1; + } + + return 0; +} + +int http_chunk_append_buffer(server *srv, connection *con, buffer *mem) { + chunkqueue * const cq = con->write_queue; + size_t len = buffer_string_length(mem); + if (0 == len) return 0; + + if (http_chunk_uses_tempfile(srv, con, len)) { + return http_chunk_append_to_tempfile(srv, con, mem->ptr, len); + } + + if (con->response.send_chunked) { + http_chunk_append_len(srv, con, len); + } + + /*(chunkqueue_append_buffer() might steal buffer contents)*/ + chunkqueue_append_buffer(cq, mem); + + if (con->response.send_chunked) { + chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n")); + } + + return 0; +} + +int http_chunk_append_mem(server *srv, connection *con, const char * mem, size_t len) { + chunkqueue * const cq = con->write_queue; + if (0 == len) return 0; + force_assert(NULL != mem); + + if (http_chunk_uses_tempfile(srv, con, len)) { + return http_chunk_append_to_tempfile(srv, con, mem, len); + } + + if (con->response.send_chunked) { + http_chunk_append_len(srv, con, len); + } + + chunkqueue_append_mem(cq, mem, len); + + if (con->response.send_chunked) { + chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n")); + } + + return 0; +} + +int http_chunk_transfer_cqlen(server *srv, connection *con, chunkqueue *src, size_t len) { + chunkqueue * const cq = con->write_queue; + if (0 == len) return 0; + + if (http_chunk_uses_tempfile(srv, con, len)) { + return http_chunk_append_cq_to_tempfile(srv, con, src, len); + } + + if (con->response.send_chunked) { + http_chunk_append_len(srv, con, len); + } + + chunkqueue_steal(cq, src, len); + + if (con->response.send_chunked) { + chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n")); + } + + return 0; +} + +void http_chunk_close(server *srv, connection *con) { + UNUSED(srv); + force_assert(NULL != con); + + if (con->response.send_chunked) { + chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("0\r\n\r\n")); + } +} |