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 "log.h"
  14
  15 #include <sys/types.h>
  16 #include <sys/stat.h>
  17
  18 #include <stdlib.h>
  19 #include <fcntl.h>
  20 #include <unistd.h>
  21
  22 #include <stdio.h>
  23 #include <errno.h>
  24 #include <string.h>
  25
  26 static void http_chunk_append_len(server *srv, connection *con, uintmax_t len) {
  27         buffer *b;
  28
  29         force_assert(NULL != srv);
  30
  31         b = srv->tmp_chunk_len;
  32
  33         buffer_string_set_length(b, 0);
  34         buffer_append_uint_hex(b, len);
  35         buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
  36
  37         chunkqueue_append_buffer(con->write_queue, b);
  38 }
  39
  40 static int http_chunk_append_file_open_fstat(server *srv, connection *con, buffer *fn, struct stat *st) {
  41         if (!con->conf.follow_symlink) {
  42                 /*(preserve existing stat_cache symlink checks)*/
  43                 stat_cache_entry *sce;
  44                 if (HANDLER_ERROR == stat_cache_get_entry(srv, con, fn, &sce)) return -1;
  45         }
  46
  47         return stat_cache_open_rdonly_fstat(srv, con, fn, st);
  48 }
  49
  50 static void http_chunk_append_file_fd_range(server *srv, connection *con, buffer *fn, int fd, off_t offset, off_t len) {
  51         chunkqueue *cq = con->write_queue;
  52
  53         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
  54                 http_chunk_append_len(srv, con, (uintmax_t)len);
  55         }
  56
  57         chunkqueue_append_file_fd(cq, fn, fd, offset, len);
  58
  59         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
  60                 chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
  61         }
  62 }
  63
  64 int http_chunk_append_file_range(server *srv, connection *con, buffer *fn, off_t offset, off_t len) {
  65         struct stat st;
  66         const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st);
  67         if (fd < 0) return -1;
  68
  69         if (-1 == len) {
  70                 if (offset >= st.st_size) {
  71                         close(fd);
  72                         return (offset == st.st_size) ? 0 : -1;
  73                 }
  74                 len = st.st_size - offset;
  75         } else if (st.st_size - offset < len) {
  76                 close(fd);
  77                 return -1;
  78         }
  79
  80         http_chunk_append_file_fd_range(srv, con, fn, fd, offset, len);
  81         return 0;
  82 }
  83
  84 int http_chunk_append_file(server *srv, connection *con, buffer *fn) {
  85         struct stat st;
  86         const int fd = http_chunk_append_file_open_fstat(srv, con, fn, &st);
  87         if (fd < 0) return -1;
  88
  89         if (0 != st.st_size) {
  90                 http_chunk_append_file_fd_range(srv, con, fn, fd, 0, st.st_size);
  91         } else {
  92                 close(fd);
  93         }
  94         return 0;
  95 }
  96
  97 void http_chunk_append_buffer(server *srv, connection *con, buffer *mem) {
  98         chunkqueue *cq;
  99
 100         force_assert(NULL != con);
 101
 102         if (buffer_string_is_empty(mem)) return;
 103
 104         cq = con->write_queue;
 105
 106         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 107                 http_chunk_append_len(srv, con, buffer_string_length(mem));
 108         }
 109
 110         chunkqueue_append_buffer(cq, mem);
 111
 112         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 113                 chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
 114         }
 115 }
 116
 117 void http_chunk_append_mem(server *srv, connection *con, const char * mem, size_t len) {
 118         chunkqueue *cq;
 119
 120         force_assert(NULL != con);
 121         force_assert(NULL != mem || 0 == len);
 122
 123         if (NULL == mem || 0 == len) return;
 124
 125         cq = con->write_queue;
 126
 127         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 128                 http_chunk_append_len(srv, con, len);
 129         }
 130
 131         chunkqueue_append_mem(cq, mem, len);
 132
 133         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 134                 chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
 135         }
 136 }
 137
 138 void http_chunk_close(server *srv, connection *con) {
 139         UNUSED(srv);
 140         force_assert(NULL != con);
 141
 142         if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
 143                 chunkqueue_append_mem(con->write_queue, CONST_STR_LEN("0\r\n\r\n"));
 144         }
 145 }