contrib/apr-util/buckets/apr_buckets_file.c

   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
  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
  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
  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     *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
 156 APU_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
 175 APU_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
 188 APU_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
 201 static 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
 221 APU_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 };