src/http_chunk.c

   1 #include "first.h"
   2
   3 /**
   4  * the HTTP chunk-API
   5  *
   6  *
   7  */
   8
   9 #include "base.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 buffer * http_chunk_header(buffer *b, uintmax_t len) {
  26     buffer_clear(b);
  27     buffer_append_uint_hex(b, len);
  28     buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
  29     return b;
  30 }
  31
  32 static void http_chunk_append_len(server *srv, connection *con, uintmax_t len) {
  33     buffer *b = http_chunk_header(srv->tmp_chunk_len, len);
  34     chunkqueue_append_mem(con->write_queue, CONST_BUF_LEN(b));
  35 }
  36
  37 static int http_chunk_append_file_open_fstat(server *srv, connection *con, buffer *fn, struct stat *st) {
  38         if (!con->conf.follow_symlink) {
  39                 /*(preserve existing stat_cache symlink checks)*/
  40                 stat_cache_entry *sce;
  41                 if (HANDLER_ERROR == stat_cache_get_entry(srv, con, fn, &sce)) return -1;
  42         }
  43
  44         return stat_cache_open_rdonly_fstat(fn, st, con->conf.follow_symlink);
  45 }
  46
  47 static void http_chunk_append_file_fd_range(server *srv, connection *con, buffer *fn, int fd, off_t offset, off_t len) {
  48         chunkqueue *cq = con->write_queue;
  49
  50         if (con->response.send_chunked) {
  51                 http_chunk_append_len(srv, con, (uintmax_t)len);
  52         }
  53
  54         chunkqueue_append_file_fd(cq, fn, fd, offset, len);
  55
  56         if (con->response.send_chunked) {
  57                 chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
  58         }
  59 }
  60
  61 int http_chunk_append_file_range(server *srv, connection *con, buffer *fn, off_t offset, off_t len) {
  62         struct stat st;
  63         const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st);
  64         if (fd < 0) return -1;
  65
  66         if (-1 == len) {
  67                 if (offset >= st.st_size) {
  68                         close(fd);
  69                         return (offset == st.st_size) ? 0 : -1;
  70                 }
  71                 len = st.st_size - offset;
  72         } else if (st.st_size - offset < len) {
  73                 close(fd);
  74                 return -1;
  75         }
  76
  77         http_chunk_append_file_fd_range(srv, con, fn, fd, offset, len);
  78         return 0;
  79 }
  80
  81 int http_chunk_append_file(server *srv, connection *con, buffer *fn) {
  82         struct stat st;
  83         const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st);
  84         if (fd < 0) return -1;
  85
  86         if (0 != st.st_size) {
  87                 http_chunk_append_file_fd_range(srv, con, fn, fd, 0, st.st_size);
  88         } else {
  89                 close(fd);
  90         }
  91         return 0;
  92 }
  93
  94 static int http_chunk_append_to_tempfile(server *srv, connection *con, const char * mem, size_t len) {
  95         chunkqueue * const cq = con->write_queue;
  96
  97         if (con->response.send_chunked) {
  98                 buffer *b = http_chunk_header(srv->tmp_chunk_len, len);
  99                 if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_BUF_LEN(b))) {
 100                         return -1;
 101                 }
 102         }
 103
 104         if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, mem, len)) {
 105                 return -1;
 106         }
 107
 108         if (con->response.send_chunked) {
 109                 if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_STR_LEN("\r\n"))) {
 110                         return -1;
 111                 }
 112         }
 113
 114         return 0;
 115 }
 116
 117 static int http_chunk_append_cq_to_tempfile(server *srv, connection *con, chunkqueue *src, size_t len) {
 118     chunkqueue * const cq = con->write_queue;
 119
 120     if (con->response.send_chunked) {
 121         buffer *b = http_chunk_header(srv->tmp_chunk_len, len);
 122         if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_BUF_LEN(b))) {
 123             return -1;
 124         }
 125     }
 126
 127     if (0 != chunkqueue_steal_with_tempfiles(srv, cq, src, len)) {
 128         return -1;
 129     }
 130
 131     if (con->response.send_chunked) {
 132         if (0!=chunkqueue_append_mem_to_tempfile(srv,cq,CONST_STR_LEN("\r\n"))){
 133             return -1;
 134         }
 135     }
 136
 137     return 0;
 138 }
 139
 140 static int http_chunk_uses_tempfile(server *srv, connection *con, size_t len) {
 141         chunkqueue * const cq = con->write_queue;
 142         chunk *c = cq->last;
 143         UNUSED(srv);
 144
 145         /* current usage does not append_mem or append_buffer after appending
 146          * file, so not checking if users of this interface have appended large
 147          * (references to) files to chunkqueue, which would not be in memory
 148          * (but included in calculation for whether or not to use temp file) */
 149
 150         /*(allow slightly larger mem use if FDEVENT_STREAM_RESPONSE_BUFMIN
 151          * to reduce creation of temp files when backend producer will be
 152          * blocked until more data is sent to network to client)*/
 153
 154         if ((c && c->type == FILE_CHUNK && c->file.is_temp)
 155             || cq->bytes_in - cq->bytes_out + len
 156                 > 1024 * ((con->conf.stream_response_body & FDEVENT_STREAM_RESPONSE_BUFMIN) ? 128 : 64)) {
 157                 return 1;
 158         }
 159
 160         return 0;
 161 }
 162
 163 int http_chunk_append_buffer(server *srv, connection *con, buffer *mem) {
 164     chunkqueue * const cq = con->write_queue;
 165     size_t len = buffer_string_length(mem);
 166     if (0 == len) return 0;
 167
 168     if (http_chunk_uses_tempfile(srv, con, len)) {
 169         return http_chunk_append_to_tempfile(srv, con, mem->ptr, len);
 170     }
 171
 172     if (con->response.send_chunked) {
 173         http_chunk_append_len(srv, con, len);
 174     }
 175
 176     /*(chunkqueue_append_buffer() might steal buffer contents)*/
 177     chunkqueue_append_buffer(cq, mem);
 178
 179     if (con->response.send_chunked) {
 180         chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
 181     }
 182
 183     return 0;
 184 }
 185
 186 int http_chunk_append_mem(server *srv, connection *con, const char * mem, size_t len) {
 187     chunkqueue * const cq = con->write_queue;
 188     if (0 == len) return 0;
 189     force_assert(NULL != mem);
 190
 191     if (http_chunk_uses_tempfile(srv, con, len)) {
 192         return http_chunk_append_to_tempfile(srv, con, mem, len);
 193     }
 194
 195     if (con->response.send_chunked) {
 196         http_chunk_append_len(srv, con, len);
 197     }
 198
 199     chunkqueue_append_mem(cq, mem, len);
 200
 201     if (con->response.send_chunked) {
 202         chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
 203     }
 204
 205     return 0;
 206 }
 207
 208 int http_chunk_transfer_cqlen(server *srv, connection *con, chunkqueue *src, size_t len) {
 209     chunkqueue * const cq = con->write_queue;
 210     if (0 == len) return 0;
 211
 212     if (http_chunk_uses_tempfile(srv, con, len)) {
 213         return http_chunk_append_cq_to_tempfile(srv, con, src, len);
 214     }
 215
 216     if (con->response.send_chunked) {
 217         http_chunk_append_len(srv, con, len);
 218     }
 219
 220     chunkqueue_steal(cq, src, len);
 221
 222     if (con->response.send_chunked) {
 223         chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
 224     }
 225
 226     return 0;
 227 }
 228
 229 void http_chunk_close(server *srv, connection *con) {
 230         UNUSED(srv);
 231         force_assert(NULL != con);
 232
 233         if (con->response.send_chunked) {
 234                 chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("0\r\n\r\n"));
 235         }
 236 }