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