src/http_chunk.c

   1 #include "first.h"
   2
   3 /**
   4  * the HTTP chunk-API
   5  *
   6  *
   7  */
   8
   9 #include "server.h"
  10 #include "chunk.h"
  11 #include "http_chunk.h"
  12 #include "stat_cache.h"
  13 #include "fdevent.h"
  14 #include "log.h"
  15
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21
  22 #include <errno.h>
  23 #include <string.h>
  24
  25 static void http_chunk_append_len(server *srv, connection *con, uintmax_t len) {
  26         buffer *b;
  27
  28         force_assert(NULL != srv);
  29
  30         b = srv->tmp_chunk_len;
  31
  32         buffer_string_set_length(b, 0);
  33         buffer_append_uint_hex(b, len);
  34         buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
  35
  36         chunkqueue_append_buffer(con->write_queue, b);
  37 }
  38
  39 static int http_chunk_append_file_open_fstat(server *srv, connection *con, buffer *fn, struct stat *st) {
  40         if (!con->conf.follow_symlink) {
  41                 /*(preserve existing stat_cache symlink checks)*/
  42                 stat_cache_entry *sce;
  43                 if (HANDLER_ERROR == stat_cache_get_entry(srv, con, fn, &sce)) return -1;
  44         }
  45
  46         return stat_cache_open_rdonly_fstat(srv, con, fn, st);
  47 }
  48
  49 static void http_chunk_append_file_fd_range(server *srv, connection *con, buffer *fn, int fd, off_t offset, off_t len) {
  50         chunkqueue *cq = con->write_queue;
  51
  52         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
  53                 http_chunk_append_len(srv, con, (uintmax_t)len);
  54         }
  55
  56         chunkqueue_append_file_fd(cq, fn, fd, offset, len);
  57
  58         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
  59                 chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
  60         }
  61 }
  62
  63 int http_chunk_append_file_range(server *srv, connection *con, buffer *fn, off_t offset, off_t len) {
  64         struct stat st;
  65         const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st);
  66         if (fd < 0) return -1;
  67
  68         if (-1 == len) {
  69                 if (offset >= st.st_size) {
  70                         close(fd);
  71                         return (offset == st.st_size) ? 0 : -1;
  72                 }
  73                 len = st.st_size - offset;
  74         } else if (st.st_size - offset < len) {
  75                 close(fd);
  76                 return -1;
  77         }
  78
  79         http_chunk_append_file_fd_range(srv, con, fn, fd, offset, len);
  80         return 0;
  81 }
  82
  83 int http_chunk_append_file(server *srv, connection *con, buffer *fn) {
  84         struct stat st;
  85         const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st);
  86         if (fd < 0) return -1;
  87
  88         if (0 != st.st_size) {
  89                 http_chunk_append_file_fd_range(srv, con, fn, fd, 0, st.st_size);
  90         } else {
  91                 close(fd);
  92         }
  93         return 0;
  94 }
  95
  96 static int http_chunk_append_to_tempfile(server *srv, connection *con, const char * mem, size_t len) {
  97         chunkqueue * const cq = con->write_queue;
  98
  99         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 100                 /*http_chunk_append_len(srv, con, len);*/
 101                 buffer *b = srv->tmp_chunk_len;
 102
 103                 buffer_string_set_length(b, 0);
 104                 buffer_append_uint_hex(b, len);
 105                 buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
 106
 107                 if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_BUF_LEN(b))) {
 108                         return -1;
 109                 }
 110         }
 111
 112         if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, mem, len)) {
 113                 return -1;
 114         }
 115
 116         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 117                 if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_STR_LEN("\r\n"))) {
 118                         return -1;
 119                 }
 120         }
 121
 122         return 0;
 123 }
 124
 125 static int http_chunk_append_data(server *srv, connection *con, buffer *b, const char * mem, size_t len) {
 126
 127         chunkqueue * const cq = con->write_queue;
 128         chunk *c = cq->last;
 129         if (0 == len) return 0;
 130
 131         /* current usage does not append_mem or append_buffer after appending
 132          * file, so not checking if users of this interface have appended large
 133          * (references to) files to chunkqueue, which would not be in memory */
 134
 135         /*(allow slightly larger mem use if FDEVENT_STREAM_RESPONSE_BUFMIN
 136          * to reduce creation of temp files when backend producer will be
 137          * blocked until more data is sent to network to client)*/
 138
 139         if ((c && c->type == FILE_CHUNK && c->file.is_temp)
 140             || cq->bytes_in - cq->bytes_out + len
 141                 > 1024 * ((con->conf.stream_response_body & FDEVENT_STREAM_RESPONSE_BUFMIN) ? 128 : 64)) {
 142                 return http_chunk_append_to_tempfile(srv, con, b ? b->ptr : mem, len);
 143         }
 144
 145         /* not appending to prior mem chunk just in case using openssl
 146          * and need to resubmit same args as prior call to openssl (required?)*/
 147
 148         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 149                 http_chunk_append_len(srv, con, len);
 150         }
 151
 152         /*(chunkqueue_append_buffer() might steal buffer contents)*/
 153         b ? chunkqueue_append_buffer(cq, b) : chunkqueue_append_mem(cq, mem, len);
 154
 155         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 156                 chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
 157         }
 158
 159         return 0;
 160 }
 161
 162 int http_chunk_append_buffer(server *srv, connection *con, buffer *mem) {
 163         force_assert(NULL != con);
 164
 165         return http_chunk_append_data(srv, con, mem, NULL, buffer_string_length(mem));
 166 }
 167
 168 int http_chunk_append_mem(server *srv, connection *con, const char * mem, size_t len) {
 169         force_assert(NULL != con);
 170         force_assert(NULL != mem || 0 == len);
 171
 172         return http_chunk_append_data(srv, con, NULL, mem, len);
 173 }
 174
 175 void http_chunk_close(server *srv, connection *con) {
 176         UNUSED(srv);
 177         force_assert(NULL != con);
 178
 179         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 180                 chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("0\r\n\r\n"));
 181         }
 182 }