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 *len = (filelength > APR_BUCKET_BUFF_SIZE) 112 ? APR_BUCKET_BUFF_SIZE 113 : filelength; 114 *str = NULL; /* in case we die prematurely */ 115 buf = apr_bucket_alloc(*len, e->list); 116 117 /* Handle offset ... */ 118 rv = apr_file_seek(f, APR_SET, &fileoffset); 119 if (rv != APR_SUCCESS) { 120 apr_bucket_free(buf); 121 return rv; 122 } 123 rv = apr_file_read(f, buf, len); 124 if (rv != APR_SUCCESS && rv != APR_EOF) { 125 apr_bucket_free(buf); 126 return rv; 127 } 128 filelength -= *len; 129 /* 130 * Change the current bucket to refer to what we read, 131 * even if we read nothing because we hit EOF. 132 */ 133 apr_bucket_heap_make(e, buf, *len, apr_bucket_free); 134 135 /* If we have more to read from the file, then create another bucket */ 136 if (filelength > 0 && rv != APR_EOF) { 137 /* for efficiency, we can just build a new apr_bucket struct 138 * to wrap around the existing file bucket */ 139 b = apr_bucket_alloc(sizeof(*b), e->list); 140 b->start = fileoffset + (*len); 141 b->length = filelength; 142 b->data = a; 143 b->type = &apr_bucket_type_file; 144 b->free = apr_bucket_free; 145 b->list = e->list; 146 APR_BUCKET_INSERT_AFTER(e, b); 147 } 148 else { 149 file_bucket_destroy(a); 150 } 151 152 *str = buf; 153 return rv; 154} 155 156APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd, 157 apr_off_t offset, 158 apr_size_t len, apr_pool_t *p) 159{ 160 apr_bucket_file *f; 161 162 f = apr_bucket_alloc(sizeof(*f), b->list); 163 f->fd = fd; 164 f->readpool = p; 165#if APR_HAS_MMAP 166 f->can_mmap = 1; 167#endif 168 169 b = apr_bucket_shared_make(b, f, offset, len); 170 b->type = &apr_bucket_type_file; 171 172 return b; 173} 174 175APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd, 176 apr_off_t offset, 177 apr_size_t len, apr_pool_t *p, 178 apr_bucket_alloc_t *list) 179{ 180 apr_bucket *b = apr_bucket_alloc(sizeof(*b), list); 181 182 APR_BUCKET_INIT(b); 183 b->free = apr_bucket_free; 184 b->list = list; 185 return apr_bucket_file_make(b, fd, offset, len, p); 186} 187 188APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *e, 189 int enabled) 190{ 191#if APR_HAS_MMAP 192 apr_bucket_file *a = e->data; 193 a->can_mmap = enabled; 194 return APR_SUCCESS; 195#else 196 return APR_ENOTIMPL; 197#endif /* APR_HAS_MMAP */ 198} 199 200 201static apr_status_t file_bucket_setaside(apr_bucket *data, apr_pool_t *reqpool) 202{ 203 apr_bucket_file *a = data->data; 204 apr_file_t *fd = NULL; 205 apr_file_t *f = a->fd; 206 apr_pool_t *curpool = apr_file_pool_get(f); 207 208 if (apr_pool_is_ancestor(curpool, reqpool)) { 209 return APR_SUCCESS; 210 } 211 212 if (!apr_pool_is_ancestor(a->readpool, reqpool)) { 213 a->readpool = reqpool; 214 } 215 216 apr_file_setaside(&fd, f, reqpool); 217 a->fd = fd; 218 return APR_SUCCESS; 219} 220 221APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_file = { 222 "FILE", 5, APR_BUCKET_DATA, 223 file_bucket_destroy, 224 file_bucket_read, 225 file_bucket_setaside, 226 apr_bucket_shared_split, 227 apr_bucket_shared_copy 228}; 229