11 #include "http_chunk.h"
12 #include "stat_cache.h"
15 #include <sys/types.h>
26 static void http_chunk_append_len(server
*srv
, connection
*con
, uintmax_t len
) {
29 force_assert(NULL
!= srv
);
31 b
= srv
->tmp_chunk_len
;
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"));
37 chunkqueue_append_buffer(con
->write_queue
, b
);
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;
47 return stat_cache_open_rdonly_fstat(srv
, con
, fn
, st
);
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
;
53 if (con
->response
.transfer_encoding
& HTTP_TRANSFER_ENCODING_CHUNKED
) {
54 http_chunk_append_len(srv
, con
, (uintmax_t)len
);
57 chunkqueue_append_file_fd(cq
, fn
, fd
, offset
, len
);
59 if (con
->response
.transfer_encoding
& HTTP_TRANSFER_ENCODING_CHUNKED
) {
60 chunkqueue_append_mem(cq
, CONST_STR_LEN("\r\n"));
64 int http_chunk_append_file_range(server
*srv
, connection
*con
, buffer
*fn
, off_t offset
, off_t len
) {
66 const int fd
= http_chunk_append_file_open_fstat(srv
, con
, fn
, &st
);
67 if (fd
< 0) return -1;
70 if (offset
>= st
.st_size
) {
72 return (offset
== st
.st_size
) ? 0 : -1;
74 len
= st
.st_size
- offset
;
75 } else if (st
.st_size
- offset
< len
) {
80 http_chunk_append_file_fd_range(srv
, con
, fn
, fd
, offset
, len
);
84 int http_chunk_append_file(server
*srv
, connection
*con
, buffer
*fn
) {
86 const int fd
= http_chunk_append_file_open_fstat(srv
, con
, fn
, &st
);
87 if (fd
< 0) return -1;
89 if (0 != st
.st_size
) {
90 http_chunk_append_file_fd_range(srv
, con
, fn
, fd
, 0, st
.st_size
);
97 static int http_chunk_append_to_tempfile(server
*srv
, connection
*con
, const char * mem
, size_t len
) {
98 chunkqueue
* const cq
= con
->write_queue
;
100 if (con
->response
.transfer_encoding
& HTTP_TRANSFER_ENCODING_CHUNKED
) {
101 /*http_chunk_append_len(srv, con, len);*/
102 buffer
*b
= srv
->tmp_chunk_len
;
104 buffer_string_set_length(b
, 0);
105 buffer_append_uint_hex(b
, len
);
106 buffer_append_string_len(b
, CONST_STR_LEN("\r\n"));
108 if (0 != chunkqueue_append_mem_to_tempfile(srv
, cq
, CONST_BUF_LEN(b
))) {
113 if (0 != chunkqueue_append_mem_to_tempfile(srv
, cq
, mem
, len
)) {
117 if (con
->response
.transfer_encoding
& HTTP_TRANSFER_ENCODING_CHUNKED
) {
118 if (0 != chunkqueue_append_mem_to_tempfile(srv
, cq
, CONST_STR_LEN("\r\n"))) {
126 static int http_chunk_append_data(server
*srv
, connection
*con
, buffer
*b
, const char * mem
, size_t len
) {
128 chunkqueue
* const cq
= con
->write_queue
;
130 if (0 == len
) return 0;
132 /* current usage does not append_mem or append_buffer after appending
133 * file, so not checking if users of this interface have appended large
134 * (references to) files to chunkqueue, which would not be in memory */
136 /*(allow slightly larger mem use if FDEVENT_STREAM_RESPONSE_BUFMIN
137 * to reduce creation of temp files when backend producer will be
138 * blocked until more data is sent to network to client)*/
140 if ((c
&& c
->type
== FILE_CHUNK
&& c
->file
.is_temp
)
141 || cq
->bytes_in
- cq
->bytes_out
+ len
142 > 1024 * ((con
->conf
.stream_response_body
& FDEVENT_STREAM_RESPONSE_BUFMIN
) ? 128 : 64)) {
143 return http_chunk_append_to_tempfile(srv
, con
, b
? b
->ptr
: mem
, len
);
146 /* not appending to prior mem chunk just in case using openssl
147 * and need to resubmit same args as prior call to openssl (required?)*/
149 if (con
->response
.transfer_encoding
& HTTP_TRANSFER_ENCODING_CHUNKED
) {
150 http_chunk_append_len(srv
, con
, len
);
153 /*(chunkqueue_append_buffer() might steal buffer contents)*/
154 b
? chunkqueue_append_buffer(cq
, b
) : chunkqueue_append_mem(cq
, mem
, len
);
156 if (con
->response
.transfer_encoding
& HTTP_TRANSFER_ENCODING_CHUNKED
) {
157 chunkqueue_append_mem(cq
, CONST_STR_LEN("\r\n"));
163 int http_chunk_append_buffer(server
*srv
, connection
*con
, buffer
*mem
) {
164 force_assert(NULL
!= con
);
166 return http_chunk_append_data(srv
, con
, mem
, NULL
, buffer_string_length(mem
));
169 int http_chunk_append_mem(server
*srv
, connection
*con
, const char * mem
, size_t len
) {
170 force_assert(NULL
!= con
);
171 force_assert(NULL
!= mem
|| 0 == len
);
173 return http_chunk_append_data(srv
, con
, NULL
, mem
, len
);
176 void http_chunk_close(server
*srv
, connection
*con
) {
178 force_assert(NULL
!= con
);
180 if (con
->response
.transfer_encoding
& HTTP_TRANSFER_ENCODING_CHUNKED
) {
181 chunkqueue_append_mem(con
->write_queue
, CONST_STR_LEN("0\r\n\r\n"));