mdl_cache.c

Go to the documentation of this file.

#include "mdl_cache.h"
 
#include <stdint.h>
#include <string.h>
#include <time.h>
 
#include "mdl_cache_internal.h"
#include "mdl_hash.h"
#include "ra8_attributes.h"

typedef enum : uint16_t {
  k_cache_http_success_min  = 200U, 
  k_cache_http_success_max  = 299U, 
  k_cache_http_not_modified = 304U, 
  k_cache_http_status_max   = 599U, 
} mdl_cache_http_t;

RA8_INTERNAL static mdl_cache_record_t*
internal_cache_find(mdl_cache_index_t* index, const char* url, uint64_t url_hash)
{
  for (uint16_t i = 0U; i < index->record_count; ++i) {
    if ((index->records[i].url_hash == url_hash) && (strcmp(index->records[i].url, url) == 0)) {
      return &index->records[i];
    }
  }
  return nullptr;
}

RA8_INTERNAL static mdl_cache_record_t* internal_cache_slot(mdl_cache_index_t* index)
{
  if (index->record_count < (uint16_t)k_mdl_cache_record_max) {
    mdl_cache_record_t* slot = &index->records[index->record_count];
    index->record_count += 1U;
    return slot;
  }
  uint16_t oldest = 0U;
  for (uint16_t i = 1U; i < index->record_count; ++i) {
    if (index->records[i].fetched_at < index->records[oldest].fetched_at) {
      oldest = i;
    }
  }
  return &index->records[oldest];
}

RA8_INTERNAL static int64_t internal_cache_age(int64_t fetched_at)
{
  const time_t now = time(nullptr);
  if ((fetched_at < 0) || (now < (time_t)0)) {
    return -1;
  }
  const int64_t current = (int64_t)now;
  return (current >= fetched_at) ? (current - fetched_at) : 0;
}

RA8_INTERNAL static int64_t internal_cache_now(void)
{
  const time_t now = time(nullptr);
  return (now < (time_t)0) ? 0 : (int64_t)now;
}

RA8_INTERNAL static bool internal_cache_copy(char* destination, size_t capacity, const char* source)
{
  const size_t length = strlen(source);
  if (length >= capacity) {
    destination[0] = '\0';
    return false;
  }
  memcpy(destination, source, length + 1U);
  return true;
}

RA8_INTERNAL static bool internal_cache_record_response(mdl_cache_index_t*    index,
                                                        mdl_cache_record_t*   existing,
                                                        const char*           url,
                                                        uint64_t              url_hash,
                                                        uint64_t              content_hash,
                                                        const char*           relative_path,
                                                        const mdl_net_resp_t* response)
{
  mdl_cache_record_t next = {.url_hash        = url_hash,
                             .content_hash    = content_hash,
                             .fetched_at      = internal_cache_now(),
                             .response_status = (uint16_t)response->status};
  if (!internal_cache_copy(next.url, sizeof(next.url), url) ||
      !internal_cache_copy(next.relative_path, sizeof(next.relative_path), relative_path) ||
      !internal_cache_copy(next.etag, sizeof(next.etag), response->etag) ||
      !internal_cache_copy(next.last_modified,
                           sizeof(next.last_modified),
                           response->last_modified)) {
    return false;
  }
  mdl_cache_record_t* destination = (existing != nullptr) ? existing : internal_cache_slot(index);
  *destination                    = next;
  return true;
}

RA8_INTERNAL static ra8_err_t internal_cache_fetch(const mdl_cache_record_t* record,
                                                   const char*               url,
                                                   const mdl_net_req_t*      base_request,
                                                   mdl_cache_fetch_fn        fetch,
                                                   void*                     fetch_context,
                                                   char*                     buffer,
                                                   size_t                    capacity,
                                                   size_t*                   out_length,
                                                   mdl_net_resp_t*           response)
{
  mdl_net_req_t request = *base_request;
  request.if_none_match =
    ((record != nullptr) && (record->etag[0] != '\0')) ? record->etag : nullptr;
  request.if_modified_since =
    ((record != nullptr) && (record->last_modified[0] != '\0')) ? record->last_modified : nullptr;
  *out_length = 0U;
  *response   = (mdl_net_resp_t){};
  return fetch(fetch_context, url, &request, buffer, capacity, out_length, response);
}

typedef struct {
  mdl_cache_paths_t   paths;           
  mdl_cache_record_t* record;          
  size_t              retained_length; 
  bool                held;            
} mdl_cache_lookup_t;

RA8_INTERNAL static ra8_err_t internal_cache_prepare(mdl_cache_t*        cache,
                                                     const char*         url,
                                                     char*               buffer,
                                                     size_t              capacity,
                                                     mdl_cache_result_t* result,
                                                     mdl_cache_lookup_t* lookup)
{
  *lookup         = (mdl_cache_lookup_t){};
  ra8_err_t error = priv_mdl_cache_load(cache, url, &lookup->paths, &result->index_rebuilt);
  if (error != k_ra8_ok) {
    return error;
  }
  const uint64_t url_hash = mdl_hash_str(url);
  lookup->record          = internal_cache_find(cache->index, url, url_hash);
  lookup->held =
    (lookup->record != nullptr) && (priv_mdl_cache_read_body(cache->storage,
                                                             &lookup->paths,
                                                             lookup->record,
                                                             buffer,
                                                             capacity,
                                                             &lookup->retained_length) == k_ra8_ok);
  if (lookup->held) {
    result->age_seconds     = internal_cache_age(lookup->record->fetched_at);
    result->observed_status = lookup->record->response_status;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_cache_retry_unconditional(const char*          url,
                                                                 const mdl_net_req_t* base_request,
                                                                 mdl_cache_fetch_fn   fetch,
                                                                 void*                fetch_context,
                                                                 char*                buffer,
                                                                 size_t               capacity,
                                                                 size_t*              out_length,
                                                                 mdl_net_resp_t*      response)
{
  mdl_net_req_t request     = *base_request;
  request.if_none_match     = nullptr;
  request.if_modified_since = nullptr;
  *out_length               = 0U;
  *response                 = (mdl_net_resp_t){};
  const ra8_err_t error =
    fetch(fetch_context, url, &request, buffer, capacity, out_length, response);
  return ((error == k_ra8_ok) && (response->status == (long)k_cache_http_not_modified))
           ? k_ra8_err_protocol_error
           : error;
}

RA8_INTERNAL static ra8_err_t internal_cache_finish_304(mdl_cache_t*             cache,
                                                        const mdl_cache_paths_t* paths,
                                                        mdl_cache_record_t*      record,
                                                        char*                    buffer,
                                                        size_t                   capacity,
                                                        size_t*                  out_length,
                                                        mdl_cache_result_t*      result)
{
  ra8_err_t error =
    priv_mdl_cache_read_body(cache->storage, paths, record, buffer, capacity, out_length);
  if (error != k_ra8_ok) {
    return error;
  }
  record->fetched_at      = internal_cache_now();
  record->response_status = (uint16_t)k_cache_http_not_modified;
  error                   = priv_mdl_cache_save(cache, paths);
  if (error == k_ra8_ok) {
    result->body_reused     = true;
    result->observed_status = (uint16_t)k_cache_http_not_modified;
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_cache_publish(mdl_cache_t*             cache,
                                                     const mdl_cache_paths_t* paths,
                                                     mdl_cache_record_t*      existing,
                                                     const char*              url,
                                                     const char*              buffer,
                                                     size_t                   length,
                                                     const mdl_net_resp_t*    response,
                                                     mdl_cache_result_t*      result)
{
  if ((response->status < (long)k_cache_http_success_min) ||
      (response->status > (long)k_cache_http_success_max) ||
      (response->status > (long)k_cache_http_status_max) || (length == 0U)) {
    return k_ra8_err_protocol_error;
  }
  const uint64_t url_hash     = mdl_hash_str(url);
  const uint64_t content_hash = mdl_hash_bytes(buffer, length);
  char           relative[k_mdl_relpath_max];
  ra8_err_t      error = priv_mdl_cache_publish_body(cache->storage,
                                                     paths,
                                                     url_hash,
                                                     content_hash,
                                                     buffer,
                                                     length,
                                                     relative,
                                                     sizeof(relative));
  if (error != k_ra8_ok) {
    return error;
  }
  if (!internal_cache_record_response(cache->index,
                                      existing,
                                      url,
                                      url_hash,
                                      content_hash,
                                      relative,
                                      response)) {
    return k_ra8_err_invalid_size;
  }
  error = priv_mdl_cache_save(cache, paths);
  if (error == k_ra8_ok) {
    result->observed_status = (uint16_t)response->status;
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_cache_network(mdl_cache_t*              cache,
                                                     const mdl_cache_lookup_t* lookup,
                                                     const char*               url,
                                                     const mdl_net_req_t*      base_request,
                                                     mdl_cache_fetch_fn        fetch,
                                                     void*                     fetch_context,
                                                     char*                     buffer,
                                                     size_t                    capacity,
                                                     size_t*                   out_length,
                                                     mdl_net_resp_t*           response,
                                                     mdl_cache_result_t*       result)
{
  result->revalidated = true;
  ra8_err_t error     = internal_cache_fetch(lookup->held ? lookup->record : nullptr,
                                             url,
                                             base_request,
                                             fetch,
                                             fetch_context,
                                             buffer,
                                             capacity,
                                             out_length,
                                             response);
  if (error != k_ra8_ok) {
    return error;
  }
  if (response->status == (long)k_cache_http_not_modified) {
    if (lookup->held) {
      return internal_cache_finish_304(cache,
                                       &lookup->paths,
                                       lookup->record,
                                       buffer,
                                       capacity,
                                       out_length,
                                       result);
    }
    error = internal_cache_retry_unconditional(url,
                                               base_request,
                                               fetch,
                                               fetch_context,
                                               buffer,
                                               capacity,
                                               out_length,
                                               response);
    if (error != k_ra8_ok) {
      return error;
    }
  }
  return internal_cache_publish(cache,
                                &lookup->paths,
                                lookup->record,
                                url,
                                buffer,
                                *out_length,
                                response,
                                result);
}
 
ra8_err_t mdl_cache_get_buf(mdl_cache_t*         cache,
                            const char*          url,
                            const mdl_net_req_t* base_request,
                            mdl_cache_fetch_fn   fetch,
                            void*                fetch_context,
                            char*                buffer,
                            size_t               capacity,
                            size_t*              out_length,
                            mdl_net_resp_t*      response,
                            mdl_cache_result_t*  result)
{
  if ((cache == nullptr) || (cache->storage == nullptr) || (cache->index == nullptr) ||
      (cache->root == nullptr) || (url == nullptr) || (base_request == nullptr) ||
      (fetch == nullptr) || (buffer == nullptr) || (capacity == 0U) || (out_length == nullptr) ||
      (response == nullptr) || (result == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  *out_length = 0U;
  *response   = (mdl_net_resp_t){};
  *result     = (mdl_cache_result_t){.age_seconds = -1};
  mdl_cache_lookup_t lookup;
  ra8_err_t          error = internal_cache_prepare(cache, url, buffer, capacity, result, &lookup);
  if (error != k_ra8_ok) {
    return error;
  }
  const bool validators =
    lookup.held && ((lookup.record->etag[0] != '\0') || (lookup.record->last_modified[0] != '\0'));
  if (lookup.held && !cache->refetch && !validators) {
    *out_length         = lookup.retained_length;
    result->body_reused = true;
    return k_ra8_ok;
  }
  return internal_cache_network(cache,
                                &lookup,
                                url,
                                base_request,
                                fetch,
                                fetch_context,
                                buffer,
                                capacity,
                                out_length,
                                response,
                                result);
}