HTTPCache.cc

Go to the documentation of this file.

 
// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#include "config.h"
 
#include <cerrno>
#include <cstring>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
 
#include <algorithm>
#include <iterator>
#include <memory>
#include <mutex>
#include <set>
#include <sstream>
 
#include "Error.h"
#include "InternalErr.h"
#include "ResponseTooBigErr.h"
 
#include "HTTPCache.h"
#include "HTTPCacheTable.h"
 
#include "debug.h"
#include "util.h"
#include "util_mit.h"
 
using namespace std;
 
const string CACHE_LOCATION{"/tmp/"};
 
const string CACHE_ROOT{"dods-cache/"};
 
const string CACHE_INDEX{".index"};
const string CACHE_LOCK{".lock"};
const string CACHE_META{".meta"};
const string CACHE_EMPTY_ETAG{"@cache@"};
 
const string DIR_SEPARATOR_CHAR{"/"};
 
namespace libdap {

 
HTTPCache::HTTPCache(const string &cache_root) {
    // This used to throw an Error object if we could not get the
    // single user lock. However, that results in an invalid object. It's
    // better to have an instance that has default values. If we cannot get
    // the lock, make sure to set the cache as *disabled*. 03/12/03 jhrg
    //
    // I fixed this block so that the cache root is set before we try to get
    // the single user lock. That was the fix for bug #661. To make that
    // work, I had to move the call to create_cache_root out of
    // set_cache_root(). 09/08/03 jhrg
 
    try {
        set_cache_root(cache_root); // sets d_cache_root, even if cache_root is empty.
        // It's OK to call create_cache_root if the directory already exists.
        create_cache_root(d_cache_root);
        string lock = d_cache_root + CACHE_LOCK;
        d_cache_lock_fd = m_initialize_cache_lock(lock);
        d_cache_lock_file = lock;
 
        struct stat s = {};
        int block_size;
        if (stat(cache_root.c_str(), &s) == 0)
            block_size = s.st_blksize;
        else
            block_size = 4096;
 
        d_http_cache_table = new HTTPCacheTable(d_cache_root, block_size);
        d_cache_enabled = true;
    } catch (const Error &) {
        // Write to a log here. 2/18/23 jhrg
        d_cache_enabled = false;
        DBG(cerr << "Failure to get the cache lock" << endl);
    }
}

 
HTTPCache::~HTTPCache() {
    try {
        if (startGC())
            perform_garbage_collection();
 
        d_http_cache_table->cache_index_write();
        delete d_http_cache_table;
    } catch (const Error &e) {
        // If the cache index cannot be written, we've got problems. However,
        // unless we're debugging, still free up the cache table in memory.
        // How should we let users know they cache index is not being
        // written?? 10/03/02 jhrg
        // Write a log message here. 2/18/23 jhrg
        DBG(cerr << e.get_error_message() << endl);
    }
 
    close(d_cache_lock_fd);
}


 
bool HTTPCache::stopGC() const {
    return (d_http_cache_table->get_current_size() + d_folder_size < d_total_size - d_gc_buffer);
}

bool HTTPCache::startGC() const {
    DBG(cerr << "startGC, current_size: " << d_http_cache_table->get_current_size() << endl);
    return (d_http_cache_table->get_current_size() + d_folder_size > d_total_size);
}

 
void HTTPCache::perform_garbage_collection() {
    DBG(cerr << "Performing garbage collection" << endl);
 
    // Remove all the expired responses.
    expired_gc();
 
    // Remove entries larger than max_entry_size.
    too_big_gc();
 
    // Remove entries starting with zero hits, 1, ..., until stopGC()
    // returns true.
    hits_gc();
}

 
void HTTPCache::expired_gc() {
    if (!d_expire_ignored) {
        d_http_cache_table->delete_expired_entries();
    }
}

void HTTPCache::hits_gc() {
    int hits = 0;
 
    if (startGC()) {
        while (!stopGC()) {
            d_http_cache_table->delete_by_hits(hits);
            hits++;
        }
    }
}

void HTTPCache::too_big_gc() {
    if (startGC())
        d_http_cache_table->delete_by_size(d_max_entry_size);
}


 
static inline string get_errno() {
    const char *s_err = strerror(errno);
    return s_err ? s_err : "unknown error";
}
 
// Build a lock of a certain type.
//
// Using whence == SEEK_SET with start and len set to zero means lock the whole file.
// jhrg 9/8/18
static inline struct flock *lock(short type) {
    static struct flock lock;
    lock.l_type = type;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;
    lock.l_pid = getpid();
 
    return &lock;
}

static bool create_locked_file(const string &file_name, int &ref_fd) {
    DBG(cerr << "BEGIN file: " << file_name << endl);
 
    int fd;
    if ((fd = open(file_name.c_str(), O_CREAT | O_EXCL | O_RDWR, 0660)) < 0) {
        if (errno == EEXIST) {
            return false;
        } else {
            throw InternalErr(__FILE__, __LINE__, file_name + ": " + get_errno());
        }
    }
 
    struct flock *l = lock(F_WRLCK);
    // F_SETLKW == set lock, blocking
    if (fcntl(fd, F_SETLKW, l) == -1) {
        close(fd);
        ostringstream oss;
        oss << "cache process: " << l->l_pid << " triggered a locking error for '" << file_name << "': " << get_errno();
        throw InternalErr(__FILE__, __LINE__, oss.str());
    }
 
    DBG(cerr << "END file: " << file_name << endl);
 
    // Success
    ref_fd = fd;
    return true;
}

int HTTPCache::m_initialize_cache_lock(const string &cache_lock) const {
    DBG(cerr << "BEGIN" << endl);
 
    int fd;
    if (create_locked_file(cache_lock, fd)) {
        // This leaves the fd file descriptor open, but unlocked
        m_unlock_cache(fd);
    } else {
        if ((fd = open(cache_lock.c_str(), O_RDWR)) == -1) {
            throw InternalErr(__FILE__, __LINE__,
                              "Failed to open cache lock file: " + cache_lock + " errno: " + get_errno());
        }
    }
 
    DBG(cerr << "END" << endl);
    return fd;
}

void HTTPCache::m_lock_cache_write(int fd) {
    DBG(cerr << "d_cache_info_fd: " << d_cache_info_fd << endl);
 
    // F_SETLKW == set lock, blocking
    if (fcntl(fd, F_SETLKW, lock(F_WRLCK)) == -1) {
        throw InternalErr(__FILE__, __LINE__, "An error occurred trying to lock the cache-control file" + get_errno());
    }
 
    DBG(cerr << "lock status: " << lockStatus(d_cache_info_fd) << endl);
}

void HTTPCache::m_lock_cache_read(int fd) {
    DBG(cerr << "d_cache_info_fd: " << d_cache_info_fd << endl);
 
    if (fcntl(fd, F_SETLKW, lock(F_RDLCK)) == -1) {
        throw InternalErr(__FILE__, __LINE__, "An error occurred trying to lock the cache-control file" + get_errno());
    }
 
    DBG(cerr << "lock status: " << lockStatus(d_cache_info_fd) << endl);
}

void HTTPCache::m_unlock_cache(int fd) {
    DBG(cerr << "d_cache_info_fd: " << d_cache_info_fd << endl);
 
    if (fcntl(fd, F_SETLK, lock(F_UNLCK)) == -1) {
        throw InternalErr(__FILE__, __LINE__,
                          "An error occurred trying to unlock the cache-control file" + get_errno());
    }
 
    DBG(cerr << "lock status: " << lockStatus(d_cache_info_fd) << endl);
}

void HTTPCache::m_exclusive_to_shared_lock(int fd) {
    struct flock lock;
    lock.l_type = F_RDLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;
    lock.l_pid = getpid();
 
    if (fcntl(fd, F_SETLKW, &lock) == -1) {
        throw InternalErr(__FILE__, __LINE__, get_errno());
    }
 
    DBG(cerr << "lock status: " << lockStatus(fd) << endl);
}



 
string HTTPCache::get_cache_root() const { return d_cache_root; }

 
void HTTPCache::create_cache_root(const string &cache_root) const {
    // Save the mask
    mode_t mask = umask(S_IRWXO);
 
    // Ignore the error if the directory exists
    errno = 0;
    if (mkdir(cache_root.c_str(), S_IRWXU | S_IRWXG) < 0 && errno != EEXIST) {
        umask(mask);
        throw Error("HTTPCache::create_cache_root: Could not create the directory for the cache at '" + cache_root +
                    "' (" + strerror(errno) + ").");
    }
 
    // Restore the mask
    umask(mask);
}
 
inline bool ends_with(std::string const &value, std::string const &ending) {
    if (ending.size() > value.size())
        return false;
    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
}

 
void HTTPCache::set_cache_root(const string &root) {
    if (!root.empty()) {
        d_cache_root = root;
        // cache root should end in /.
        if (!ends_with(d_cache_root, DIR_SEPARATOR_CHAR))
            d_cache_root += DIR_SEPARATOR_CHAR;
    } else {
        // If no cache root has been indicated then look for a suitable location.
        d_cache_root = CACHE_LOCATION;
 
        if (!ends_with(d_cache_root, DIR_SEPARATOR_CHAR))
            d_cache_root += DIR_SEPARATOR_CHAR;
 
        d_cache_root += CACHE_ROOT;
    }
 
    // Test d_http_cache_table because this method can be called before that
    // instance is created and also can be called later to change the cache
    // root. jhrg 05.14.08
    if (d_http_cache_table)
        d_http_cache_table->set_cache_root(d_cache_root);
}

 
void HTTPCache::set_cache_enabled(bool mode) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    d_cache_enabled = mode;
}

 
bool HTTPCache::is_cache_enabled() const { return d_cache_enabled; }

 
void HTTPCache::set_cache_disconnected(CacheDisconnectedMode mode) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    d_cache_disconnected = mode;
}

 
CacheDisconnectedMode HTTPCache::get_cache_disconnected() const { return d_cache_disconnected; }

 
void HTTPCache::set_expire_ignored(bool mode) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    d_expire_ignored = mode;
}
 
/* Is the cache ignoring Expires headers returned with responses that have
   been cached? */
 
bool HTTPCache::is_expire_ignored() const { return d_expire_ignored; }

 
void HTTPCache::set_max_size(unsigned long size) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    unsigned long new_size = size < MIN_CACHE_TOTAL_SIZE ? MIN_CACHE_TOTAL_SIZE * MEGA : size * MEGA;
    unsigned long old_size = d_total_size;
    d_total_size = new_size;
    d_folder_size = d_total_size / CACHE_FOLDER_PCT;
    d_gc_buffer = d_total_size / CACHE_GC_PCT;
 
    if (new_size < old_size && startGC()) {
        perform_garbage_collection();
        d_http_cache_table->cache_index_write();
    }
}

 
unsigned long HTTPCache::get_max_size() const { return d_total_size / MEGA; }

 
void HTTPCache::set_max_entry_size(unsigned long size) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    unsigned long new_size = size * MEGA;
    if (new_size > 0 && new_size < d_total_size - d_folder_size) {
        unsigned long old_size = d_max_entry_size;
        d_max_entry_size = new_size;
        if (new_size < old_size && startGC()) {
            perform_garbage_collection();
            d_http_cache_table->cache_index_write();
        }
    }
}

 
unsigned long HTTPCache::get_max_entry_size() const { return d_max_entry_size / MEGA; }

 
void HTTPCache::set_default_expiration(const int exp_time) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    d_default_expiration = exp_time;
}

 
int HTTPCache::get_default_expiration() const { return d_default_expiration; }

 
void HTTPCache::set_always_validate(bool validate) { d_always_validate = validate; }

 
bool HTTPCache::get_always_validate() const { return d_always_validate; }

 
void HTTPCache::set_cache_control(const vector<string> &cc) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    d_cache_control = cc;
 
    for (auto &line : cc) {
        string header = line.substr(0, line.find(':'));
        string value = line.substr(line.find(": ") + 2);
        if (header != "Cache-Control") {
            throw InternalErr(__FILE__, __LINE__, "Expected cache control header not found.");
        } else {
            if (value == "no-cache" || value == "no-store")
                d_cache_enabled = false;
            else if (value.find("max-age") != string::npos) {
                string max_age = value.substr(value.find('=') + 1);
                d_max_age = parse_time(max_age.c_str());
            } else if (value == "max-stale")
                d_max_stale = 0; // indicates will take anything;
            else if (value.find("max-stale") != string::npos) {
                string max_stale = value.substr(value.find('=') + 1);
                d_max_stale = parse_time(max_stale.c_str());
            } else if (value.find("min-fresh") != string::npos) {
                string min_fresh = value.substr(value.find('=') + 1);
                d_min_fresh = parse_time(min_fresh.c_str());
            }
        }
    }
}

 
vector<string> HTTPCache::get_cache_control() const { return d_cache_control; }


 
bool HTTPCache::is_url_in_cache(const string &url) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    HTTPCacheTable::CacheEntry *entry = d_http_cache_table->get_read_locked_entry_from_cache_table(url);
 
    if (entry) {
        entry->unlock_read_response();
        return true;
    }
    return false;
}

 
bool is_hop_by_hop_header(const string &header) {
    return header.find("Connection") != string::npos || header.find("Keep-Alive") != string::npos ||
           header.find("Proxy-Authenticate") != string::npos || header.find("Proxy-Authorization") != string::npos ||
           header.find("Transfer-Encoding") != string::npos || header.find("Upgrade") != string::npos;
}

 
void HTTPCache::write_metadata(const string &cachename, const vector<string> &headers) {
    string fname = cachename + CACHE_META;
    d_open_files.push_back(fname);
 
    FILE *dest = fopen(fname.c_str(), "w");
    if (!dest) {
        throw InternalErr(__FILE__, __LINE__, "Could not open named cache entry file.");
    }
 
    vector<string>::const_iterator i;
    for (auto &header : headers) /*i = headers.begin(); i != headers.end(); ++i)*/ {
        if (!is_hop_by_hop_header(header)) {
            size_t s = fwrite(header.c_str(), header.size(), 1, dest);
            if (s != 1) {
                fclose(dest);
                throw InternalErr(__FILE__, __LINE__, "could not write header: '" + (*i) + "' " + long_to_string(s));
            }
            s = fwrite("\n", 1, 1, dest);
            if (s != 1) {
                fclose(dest);
                throw InternalErr(__FILE__, __LINE__, "could not write header: " + long_to_string(s));
            }
        }
    }
 
    int res = fclose(dest);
    if (res) {
        DBG(cerr << "HTTPCache::write_metadata - Failed to close " << dest << endl);
    }
 
    d_open_files.pop_back();
}

 
void HTTPCache::read_metadata(const string &cachename, vector<string> &headers) const {
    FILE *md = fopen(string(cachename + CACHE_META).c_str(), "r");
    if (!md) {
        throw InternalErr(__FILE__, __LINE__, "Could not open named cache entry meta data file.");
    }
 
    const size_t line_buf_len = 1024;
    char line[line_buf_len];
    while (!feof(md) && fgets(line, line_buf_len, md)) {
        line[std::min(line_buf_len, strnlen(line, line_buf_len)) - 1] = '\0'; // erase newline
        headers.emplace_back(line);
    }
 
    int res = fclose(md);
    if (res) {
        DBG(cerr << "HTTPCache::read_metadata - Failed to close " << md << endl);
    }
}

 
int HTTPCache::write_body(const string &cachename, const FILE *src) {
    d_open_files.push_back(cachename);
 
    FILE *dest = fopen(cachename.c_str(), "wb");
    if (!dest) {
        throw InternalErr(__FILE__, __LINE__, "Could not open named cache entry file.");
    }
 
    // Read and write in 1k blocks; an attempt at doing this efficiently.
    // 09/30/02 jhrg
    char line[1024];
    size_t n;
    int total = 0;
    while ((n = fread(line, 1, 1024, const_cast<FILE *>(src))) > 0) {
        total += fwrite(line, 1, n, dest);
        DBG2(sleep(3));
    }
 
    if (ferror(const_cast<FILE *>(src)) || ferror(dest)) {
        int res = fclose(dest);
        res = res & unlink(cachename.c_str());
        if (res) {
            DBG(cerr << "HTTPCache::write_body - Failed to close/unlink " << dest << endl);
        }
        throw InternalErr(__FILE__, __LINE__, "I/O error transferring data to the cache.");
    }
 
    rewind(const_cast<FILE *>(src));
 
    int res = fclose(dest);
    if (res) {
        DBG(cerr << "HTTPCache::write_body - Failed to close " << dest << endl);
    }
 
    d_open_files.pop_back();
 
    return total;
}

 
FILE *HTTPCache::open_body(const string &cachename) {
    DBG(cerr << "cachename: " << cachename << endl);
 
    FILE *src = fopen(cachename.c_str(), "rb"); // Read only
    if (!src)
        throw InternalErr(__FILE__, __LINE__, "Could not open cache file.");
 
    return src;
}

 
bool HTTPCache::cache_response(const string &url, time_t request_time, const vector<string> &headers,
                               const FILE *body) {
 
    // If this is not an http or https URL, don't cache.
    if (url.find("http:") == string::npos && url.find("https:") == string::npos) {
        return false;
    }
 
    lock_guard<mutex> lock{d_cache_mutex};
    mp_lock_guard write_lock{d_cache_lock_fd,
                             mp_lock_guard::operation::write}; // Blocks until the write lock is acquired.
 
    // This does nothing if url is not already in the cache. It's
    // more efficient to do this than to first check and see if the entry
    // exists. 10/10/02 jhrg
    d_http_cache_table->remove_entry_from_cache_table(url);
    auto *entry = new HTTPCacheTable::CacheEntry(url);
    entry->lock_write_response();
 
    try {
        d_http_cache_table->parse_headers(entry, d_max_entry_size, headers); // etag, lm, date, age, expires, max_age.
        if (entry->is_no_cache()) {
            DBG(cerr << "Not cache-able; deleting HTTPCacheTable::CacheEntry: " << entry << "(" << url << ")" << endl);
            entry->unlock_write_response();
            delete entry;
            return false;
        }
 
        // corrected_initial_age, freshness_lifetime, response_time.
        d_http_cache_table->calculate_time(entry, d_default_expiration, request_time);
 
        d_http_cache_table->create_location(entry); // cachename, cache_body_fd
        // move these write function to cache table
        entry->set_size(write_body(entry->get_cachename(), body));
        write_metadata(entry->get_cachename(), headers);
        d_http_cache_table->add_entry_to_cache_table(entry);
        entry->unlock_write_response();
    } catch (const ResponseTooBigErr &e) {
        // Oops. Bummer. Clean up and exit.
        DBG(cerr << e.get_error_message() << endl);
        remove(entry->get_cachename().c_str());
        remove(string(entry->get_cachename() + CACHE_META).c_str());
        entry->unlock_write_response();
        delete entry;
        return false;
    }
 
    if (d_http_cache_table->get_new_entries() > DUMP_FREQUENCY) {
        if (startGC())
            perform_garbage_collection();
 
        d_http_cache_table->cache_index_write(); // resets new_entries
    }
 
    return true;
}

 
vector<string> HTTPCache::get_conditional_request_headers(const string &url) {
 
    HTTPCacheTable::CacheEntry *entry = nullptr;
    vector<string> headers;
 
    lock_guard<mutex> lock{d_cache_mutex};
    mp_lock_guard read_lock{d_cache_lock_fd, mp_lock_guard::operation::read}; // Blocks until the lock is acquired.
 
    try {
        entry = d_http_cache_table->get_read_locked_entry_from_cache_table(url);
        if (!entry)
            throw Error(internal_error, "There is no cache entry for the URL: " + url);
 
        if (!entry->get_etag().empty())
            headers.push_back(string("If-None-Match: ") + entry->get_etag());
 
        if (entry->get_lm() > 0) {
            time_t lm = entry->get_lm();
            headers.push_back(string("If-Modified-Since: ") + date_time_str(&lm));
        } else if (entry->get_max_age() > 0) {
            time_t max_age = entry->get_max_age();
            headers.push_back(string("If-Modified-Since: ") + date_time_str(&max_age));
        } else if (entry->get_expires() > 0) {
            time_t expires = entry->get_expires();
            headers.push_back(string("If-Modified-Since: ") + date_time_str(&expires));
        }
        entry->unlock_read_response();
    } catch (...) {
        if (entry) {
            entry->unlock_read_response();
        }
        throw;
    }
 
    return headers;
}

 
struct HeaderLess : binary_function<const string &, const string &, bool> {
    bool operator()(const string &s1, const string &s2) const {
        return s1.substr(0, s1.find(':')) < s2.substr(0, s2.find(':'));
    }
};

 
void HTTPCache::update_response(const string &url, time_t request_time, const vector<string> &headers) {
    HTTPCacheTable::CacheEntry *entry = nullptr;
 
    try {
        lock_guard<mutex> lock{d_cache_mutex};
        mp_lock_guard write_lock{d_cache_lock_fd,
                                 mp_lock_guard::operation::write}; // Blocks until the lock is acquired.
 
        entry = d_http_cache_table->get_write_locked_entry_from_cache_table(url);
        if (!entry)
            throw Error(internal_error, "There is no cache entry for the URL: " + url);
 
        // Merge the new headers with the exiting HTTPCacheTable::CacheEntry object.
        d_http_cache_table->parse_headers(entry, d_max_entry_size, headers);
 
        // Update corrected_initial_age, freshness_lifetime, response_time.
        d_http_cache_table->calculate_time(entry, d_default_expiration, request_time);
 
        // Merge the new headers with those in the persistent store. How:
        // Load the new headers into a set, then merge the old headers. Since
        // set<> ignores duplicates, old headers with the same name as a new
        // header will go into the bit bucket. Define a special compare
        // functor to make sure that headers are compared using only their
        // name and not their value too.
        set<string, HeaderLess> merged_headers;
 
        // Load in the new headers
        copy(headers.begin(), headers.end(), inserter(merged_headers, merged_headers.begin()));
 
        // Get the old headers and load them in.
        vector<string> old_headers;
        read_metadata(entry->get_cachename(), old_headers);
        copy(old_headers.begin(), old_headers.end(), inserter(merged_headers, merged_headers.begin()));
 
        // Read the values back out. Use reverse iterators with back_inserter
        // to preserve header order. NB: vector<> does not support push_front
        // so we can't use front_inserter(). 01/09/03 jhrg
        vector<string> result;
        copy(merged_headers.rbegin(), merged_headers.rend(), back_inserter(result));
 
        write_metadata(entry->get_cachename(), result);
        entry->unlock_write_response();
    } catch (...) {
        if (entry) {
            entry->unlock_read_response();
        }
        throw;
    }
}

 
bool HTTPCache::is_url_valid(const string &url) {
 
    bool freshness;
    HTTPCacheTable::CacheEntry *entry = nullptr;
 
    try {
        if (d_always_validate) {
            return false; // force re-validation.
        }
 
        lock_guard<mutex> lock{d_cache_mutex};
        mp_lock_guard read_lock{d_cache_lock_fd, mp_lock_guard::operation::read}; // Blocks until the lock is acquired.
 
        entry = d_http_cache_table->get_read_locked_entry_from_cache_table(url);
        if (!entry)
            throw Error(internal_error, "There is no cache entry for the URL: " + url);
 
        // If we supported range requests, we'd need code here to check if
        // there was only a partial response in the cache. 10/02/02 jhrg
 
        // In case this entry is of type "must-revalidate" then we consider it
        // invalid.
        if (entry->get_must_revalidate()) {
            entry->unlock_read_response();
            return false;
        }
 
        time_t resident_time = time(nullptr) - entry->get_response_time();
        time_t current_age = entry->get_corrected_initial_age() + resident_time;
 
        // Check that the max-age, max-stale, and min-fresh directives
        // given in the request cache control header is followed.
        if (d_max_age >= 0 && current_age > d_max_age) {
            entry->unlock_read_response();
            return false;
        }
        if (d_min_fresh >= 0 && entry->get_freshness_lifetime() < current_age + d_min_fresh) {
            entry->unlock_read_response();
            return false;
        }
 
        freshness = (entry->get_freshness_lifetime() + (d_max_stale >= 0 ? d_max_stale : 0) > current_age);
        entry->unlock_read_response();
    } catch (...) {
        if (entry) {
            entry->unlock_read_response();
        }
        throw;
    }
 
    return freshness;
}

 
FILE *HTTPCache::get_cached_response(const string &url, vector<string> &headers, string &cacheName) {
    FILE *body = nullptr;
    HTTPCacheTable::CacheEntry *entry = nullptr;
 
    try {
        lock_guard<mutex> lock{d_cache_mutex};
        mp_lock_guard read_lock{d_cache_lock_fd, mp_lock_guard::operation::read}; // Blocks until the lock is acquired.
 
        DBG(cerr << "Getting the cached response for " << url << endl);
 
        entry = d_http_cache_table->get_read_locked_entry_from_cache_table(url);
        if (!entry) {
            return nullptr;
        }
 
        cacheName = entry->get_cachename();
        read_metadata(entry->get_cachename(), headers);
 
        DBG(cerr << "Headers just read from cache: " << endl);
        DBGN(copy(headers.begin(), headers.end(), ostream_iterator<string>(cerr, "\n")));
 
        body = open_body(entry->get_cachename());
 
        DBG(cerr << "Returning: " << url << " from the cache." << endl);
 
        d_http_cache_table->bind_entry_to_data(entry, body);
 
        // Set 'read_lock' so that it will not unlock the cache when it goes out of scope.
        // The client must call release_cached_response() to unlock the cache.
        read_lock.release();
    } catch (...) {
        if (body != nullptr)
            fclose(body);
        throw;
    }
 
    return body;
}

 
FILE *HTTPCache::get_cached_response(const string &url, vector<string> &headers) {
    string discard_name;
    return get_cached_response(url, headers, discard_name);
}

 
FILE *HTTPCache::get_cached_response(const string &url) {
    string discard_name;
    vector<string> discard_headers;
    return get_cached_response(url, discard_headers, discard_name);
}

 
void HTTPCache::release_cached_response(FILE *body) {
    lock_guard<mutex> lock{d_cache_mutex};
 
    // fclose(body); This results in a seg fault on linux jhrg 8/27/13
    d_http_cache_table->uncouple_entry_from_data(body);
    m_unlock_cache(d_cache_lock_fd);
}

 
void HTTPCache::purge_cache() {
    lock_guard<mutex> lock{d_cache_mutex};
    mp_lock_guard write_lock{d_cache_lock_fd, mp_lock_guard::operation::write}; // Blocks until the lock is acquired.
 
    if (d_http_cache_table->is_locked_read_responses())
        throw Error(internal_error, "Attempt to purge the cache with entries in use.");
 
    d_http_cache_table->delete_all_entries();
}
 
} // namespace libdap