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
32static 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
44static 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
75static 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
154APU_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
174APU_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
187APU_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
199APU_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
215static 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
235APU_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