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: static int http_chunk_append_to_tempfile(server *srv, connection *con, const char * mem, size_t len) {
98: chunkqueue * const cq = con->write_queue;
99:
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;
103:
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"));
107:
108: if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, CONST_BUF_LEN(b))) {
109: return -1;
110: }
111: }
112:
113: if (0 != chunkqueue_append_mem_to_tempfile(srv, cq, mem, len)) {
114: return -1;
115: }
116:
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"))) {
119: return -1;
120: }
121: }
122:
123: return 0;
124: }
125:
126: static int http_chunk_append_data(server *srv, connection *con, buffer *b, const char * mem, size_t len) {
127:
128: chunkqueue * const cq = con->write_queue;
129: chunk *c = cq->last;
130: if (0 == len) return 0;
131:
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 */
135:
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)*/
139:
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);
144: }
145:
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?)*/
148:
149: if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
150: http_chunk_append_len(srv, con, len);
151: }
152:
153: /*(chunkqueue_append_buffer() might steal buffer contents)*/
154: b ? chunkqueue_append_buffer(cq, b) : chunkqueue_append_mem(cq, mem, len);
155:
156: if (con->response.transfer_encoding & HTTP_TRANSFER_ENCODING_CHUNKED) {
157: chunkqueue_append_mem(cq, CONST_STR_LEN("\r\n"));
158: }
159:
160: return 0;
161: }
162:
163: int http_chunk_append_buffer(server *srv, connection *con, buffer *mem) {
164: force_assert(NULL != con);
165:
166: return http_chunk_append_data(srv, con, mem, NULL, buffer_string_length(mem));
167: }
168:
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);
172:
173: return http_chunk_append_data(srv, con, NULL, mem, len);
174: }
175:
176: void http_chunk_close(server *srv, connection *con) {
177: UNUSED(srv);
178: force_assert(NULL != con);
179:
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"));
182: }
183: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_chunk.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lighttpd / src