1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "apr.h"
18 #include "apr_general.h"
19 #include "apr_file_io.h"
20 #include "apr_buckets.h"
21
22 #if APR_HAS_MMAP
23 #include "apr_mmap.h"
24
25 /* mmap support for static files based on ideas from John Heidemann's
26 * patch against 1.0.5. See
27 * <http://www.isi.edu/~johnh/SOFTWARE/APACHE/index.html>.
28 */
29
30 #endif /* APR_HAS_MMAP */
31
file_bucket_destroy(void * data)32 static void file_bucket_destroy(void *data)
33 {
34 apr_bucket_file *f = data;
35
36 if (apr_bucket_shared_destroy(f)) {
37 /* no need to close the file here; it will get
38 * done automatically when the pool gets cleaned up */
39 apr_bucket_free(f);
40 }
41 }
42
43 #if APR_HAS_MMAP
file_make_mmap(apr_bucket * e,apr_size_t filelength,apr_off_t fileoffset,apr_pool_t * p)44 static int file_make_mmap(apr_bucket *e, apr_size_t filelength,
45 apr_off_t fileoffset, apr_pool_t *p)
46 {
47 apr_bucket_file *a = e->data;
48 apr_mmap_t *mm;
49
50 if (!a->can_mmap) {
51 return 0;
52 }
53
54 if (filelength > APR_MMAP_LIMIT) {
55 if (apr_mmap_create(&mm, a->fd, fileoffset, APR_MMAP_LIMIT,
56 APR_MMAP_READ, p) != APR_SUCCESS)
57 {
58 return 0;
59 }
60 apr_bucket_split(e, APR_MMAP_LIMIT);
61 filelength = APR_MMAP_LIMIT;
62 }
63 else if ((filelength < APR_MMAP_THRESHOLD) ||
64 (apr_mmap_create(&mm, a->fd, fileoffset, filelength,
65 APR_MMAP_READ, p) != APR_SUCCESS))
66 {
67 return 0;
68 }
69 apr_bucket_mmap_make(e, mm, 0, filelength);
70 file_bucket_destroy(a);
71 return 1;
72 }
73 #endif
74
file_bucket_read(apr_bucket * e,const char ** str,apr_size_t * len,apr_read_type_e block)75 static apr_status_t file_bucket_read(apr_bucket *e, const char **str,
76 apr_size_t *len, apr_read_type_e block)
77 {
78 apr_bucket_file *a = e->data;
79 apr_file_t *f = a->fd;
80 apr_bucket *b = NULL;
81 char *buf;
82 apr_status_t rv;
83 apr_size_t filelength = e->length; /* bytes remaining in file past offset */
84 apr_off_t fileoffset = e->start;
85 #if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
86 apr_int32_t flags;
87 #endif
88
89 #if APR_HAS_MMAP
90 if (file_make_mmap(e, filelength, fileoffset, a->readpool)) {
91 return apr_bucket_read(e, str, len, block);
92 }
93 #endif
94
95 #if APR_HAS_THREADS && !APR_HAS_XTHREAD_FILES
96 if ((flags = apr_file_flags_get(f)) & APR_FOPEN_XTHREAD) {
97 /* this file descriptor is shared across multiple threads and
98 * this OS doesn't support that natively, so as a workaround
99 * we must reopen the file into a->readpool */
100 const char *fname;
101 apr_file_name_get(&fname, f);
102
103 rv = apr_file_open(&f, fname, (flags & ~APR_FOPEN_XTHREAD), 0, a->readpool);
104 if (rv != APR_SUCCESS)
105 return rv;
106
107 a->fd = f;
108 }
109 #endif
110
111 *str = NULL; /* in case we die prematurely */
112 *len = (filelength > a->read_size) ? a->read_size : filelength;
113 buf = apr_bucket_alloc(*len, e->list);
114
115 /* Handle offset ... */
116 rv = apr_file_seek(f, APR_SET, &fileoffset);
117 if (rv != APR_SUCCESS) {
118 apr_bucket_free(buf);
119 return rv;
120 }
121 rv = apr_file_read(f, buf, len);
122 if (rv != APR_SUCCESS && rv != APR_EOF) {
123 apr_bucket_free(buf);
124 return rv;
125 }
126 filelength -= *len;
127 /*
128 * Change the current bucket to refer to what we read,
129 * even if we read nothing because we hit EOF.
130 */
131 apr_bucket_heap_make(e, buf, *len, apr_bucket_free);
132
133 /* If we have more to read from the file, then create another bucket */
134 if (filelength > 0 && rv != APR_EOF) {
135 /* for efficiency, we can just build a new apr_bucket struct
136 * to wrap around the existing file bucket */
137 b = apr_bucket_alloc(sizeof(*b), e->list);
138 b->start = fileoffset + (*len);
139 b->length = filelength;
140 b->data = a;
141 b->type = &apr_bucket_type_file;
142 b->free = apr_bucket_free;
143 b->list = e->list;
144 APR_BUCKET_INSERT_AFTER(e, b);
145 }
146 else {
147 file_bucket_destroy(a);
148 }
149
150 *str = buf;
151 return rv;
152 }
153
apr_bucket_file_make(apr_bucket * b,apr_file_t * fd,apr_off_t offset,apr_size_t len,apr_pool_t * p)154 APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd,
155 apr_off_t offset,
156 apr_size_t len, apr_pool_t *p)
157 {
158 apr_bucket_file *f;
159
160 f = apr_bucket_alloc(sizeof(*f), b->list);
161 f->fd = fd;
162 f->readpool = p;
163 #if APR_HAS_MMAP
164 f->can_mmap = 1;
165 #endif
166 f->read_size = APR_BUCKET_BUFF_SIZE;
167
168 b = apr_bucket_shared_make(b, f, offset, len);
169 b->type = &apr_bucket_type_file;
170
171 return b;
172 }
173
apr_bucket_file_create(apr_file_t * fd,apr_off_t offset,apr_size_t len,apr_pool_t * p,apr_bucket_alloc_t * list)174 APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd,
175 apr_off_t offset,
176 apr_size_t len, apr_pool_t *p,
177 apr_bucket_alloc_t *list)
178 {
179 apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
180
181 APR_BUCKET_INIT(b);
182 b->free = apr_bucket_free;
183 b->list = list;
184 return apr_bucket_file_make(b, fd, offset, len, p);
185 }
186
apr_bucket_file_enable_mmap(apr_bucket * e,int enabled)187 APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *e,
188 int enabled)
189 {
190 #if APR_HAS_MMAP
191 apr_bucket_file *a = e->data;
192 a->can_mmap = enabled;
193 return APR_SUCCESS;
194 #else
195 return APR_ENOTIMPL;
196 #endif /* APR_HAS_MMAP */
197 }
198
apr_bucket_file_set_buf_size(apr_bucket * e,apr_size_t size)199 APU_DECLARE(apr_status_t) apr_bucket_file_set_buf_size(apr_bucket *e,
200 apr_size_t size)
201 {
202 apr_bucket_file *a = e->data;
203
204 if (size <= APR_BUCKET_BUFF_SIZE) {
205 a->read_size = APR_BUCKET_BUFF_SIZE;
206 }
207 else {
208 apr_size_t floor = apr_bucket_alloc_aligned_floor(e->list, size);
209 a->read_size = (size < floor) ? size : floor;
210 }
211
212 return APR_SUCCESS;
213 }
214
file_bucket_setaside(apr_bucket * data,apr_pool_t * reqpool)215 static apr_status_t file_bucket_setaside(apr_bucket *data, apr_pool_t *reqpool)
216 {
217 apr_bucket_file *a = data->data;
218 apr_file_t *fd = NULL;
219 apr_file_t *f = a->fd;
220 apr_pool_t *curpool = apr_file_pool_get(f);
221
222 if (apr_pool_is_ancestor(curpool, reqpool)) {
223 return APR_SUCCESS;
224 }
225
226 if (!apr_pool_is_ancestor(a->readpool, reqpool)) {
227 a->readpool = reqpool;
228 }
229
230 apr_file_setaside(&fd, f, reqpool);
231 a->fd = fd;
232 return APR_SUCCESS;
233 }
234
235 APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_file = {
236 "FILE", 5, APR_BUCKET_DATA,
237 file_bucket_destroy,
238 file_bucket_read,
239 file_bucket_setaside,
240 apr_bucket_shared_split,
241 apr_bucket_shared_copy
242 };
243