mdl_app_cover.c

Go to the documentation of this file.

#include <limits.h>
#include <stdint.h>
#include <string.h>
 
#include "mdl_app_internal.h"
#include "mdl_fetch_body_internal.h"

RA8_INTERNAL static bool internal_cover_copy(char* destination, size_t capacity, const char* source)
{
  if ((destination == nullptr) || (capacity == 0U) || (source == nullptr)) {
    return false;
  }
  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_cover_current(mdl_fetch_ctx_t* ctx, const char* series_directory)
{
  const char* relative = priv_mdl_app_context()->state.cover_path;
  if (relative[0] == '\0') {
    return false;
  }
  char existing[k_fw_fs_path_cap];
  return mdl_path_join(series_directory, relative, existing, sizeof(existing)) &&
         (mdl_urlname_sniff_file(ctx->storage, existing, nullptr, nullptr, 0U, nullptr, 0U) ==
          k_ra8_ok);
}

RA8_INTERNAL static ra8_err_t internal_cover_finish(mdl_fetch_body_t* body, size_t bytes)
{
  ra8_err_t error = priv_mdl_fetch_body_prepare(body);
  if (error != k_ra8_ok) {
    (void)priv_mdl_fetch_body_abort(body);
    ra8_err_t output_error = priv_mdl_stream_text(k_ra8_ok,
                                                  priv_mdl_app_context()->diagnostic,
                                                  "mdl: downloaded series cover is not a "
                                                  "supported image (");
    output_error = priv_mdl_stream_u64(output_error, priv_mdl_app_context()->diagnostic, bytes);
    output_error =
      priv_mdl_stream_text(output_error, priv_mdl_app_context()->diagnostic, " bytes)\n");
    return (output_error == k_ra8_ok) ? error : output_error;
  }
  if (!internal_cover_copy(priv_mdl_app_context()->state.cover_path,
                           sizeof(priv_mdl_app_context()->state.cover_path),
                           body->actual_rel)) {
    (void)priv_mdl_fetch_body_abort(body);
    return k_ra8_err_invalid_size;
  }
  error = priv_mdl_fetch_body_commit(body);
  if (error != k_ra8_ok) {
    priv_mdl_app_context()->state.cover_path[0] = '\0';
  }
  return error;
}

RA8_INTERNAL static ra8_err_t
internal_cover_publish_cached(mdl_fetch_ctx_t* ctx, const char* holding, size_t bytes)
{
  if (bytes > UINT32_MAX) {
    return k_ra8_err_invalid_size;
  }
  mdl_fetch_body_t body = {};
  ra8_err_t error = priv_mdl_fetch_body_init_image(&body, ctx->storage, holding, "cover.download");
  mdl_net_body_sink_t sink     = priv_mdl_fetch_body_sink(&body);
  uint32_t            accepted = 0U;
  if (error == k_ra8_ok) {
    error = sink.write(sink.ctx, (const uint8_t*)ctx->page_buf, (uint32_t)bytes, &accepted);
  }
  if ((error == k_ra8_ok) && (accepted != (uint32_t)bytes)) {
    error = k_ra8_err_invalid_state;
  }
  if (error != k_ra8_ok) {
    const ra8_err_t aborted = priv_mdl_fetch_body_abort(&body);
    return (aborted == k_ra8_ok) ? error : aborted;
  }
  return internal_cover_finish(&body, bytes);
}

RA8_INTERNAL static ra8_err_t internal_cover_stream(mdl_fetch_ctx_t* ctx,
                                                    const char*      holding,
                                                    const char*      host,
                                                    uint32_t         minimum_delay,
                                                    uint32_t         maximum_delay)
{
  const mdl_net_req_t request = {.user_agent = ctx->session->user_agent,
                                 .referer    = priv_mdl_app_context()->state.series_url,
                                 .timeout_ms = ctx->timeout_ms};
  mdl_fetch_body_t    body    = {};
  ra8_err_t error = priv_mdl_fetch_body_init_image(&body, ctx->storage, holding, "cover.download");
  mdl_net_body_sink_t sink     = priv_mdl_fetch_body_sink(&body);
  mdl_net_resp_t      response = {};
  size_t              bytes    = 0U;
  if (error == k_ra8_ok) {
    error = priv_mdl_fetch_with_retry(ctx,
                                      host,
                                      priv_mdl_app_context()->state.cover_url,
                                      &request,
                                      &sink,
                                      minimum_delay,
                                      maximum_delay,
                                      &response,
                                      &bytes);
  }
  if (error == k_ra8_ok) {
    return internal_cover_finish(&body, bytes);
  }
  const ra8_err_t aborted = priv_mdl_fetch_body_abort(&body);
  error                   = (aborted == k_ra8_ok) ? error : aborted;
  priv_mdl_fetch_record_fail(ctx, priv_mdl_app_context()->state.cover_url, response.status, error);
  return error;
}

RA8_INTERNAL static ra8_err_t internal_cover_cached(mdl_fetch_ctx_t* ctx,
                                                    const char*      holding,
                                                    const char*      host,
                                                    uint32_t         minimum_delay,
                                                    uint32_t         maximum_delay,
                                                    bool             current)
{
  mdl_fetch_cache_request_t fetch = {.ctx = ctx, .jmin = minimum_delay, .jmax = maximum_delay};
  if (!internal_cover_copy(fetch.host, sizeof(fetch.host), host)) {
    return k_ra8_err_invalid_size;
  }
  const mdl_net_req_t request  = {.user_agent = ctx->session->user_agent,
                                  .referer    = priv_mdl_app_context()->state.series_url,
                                  .timeout_ms = ctx->timeout_ms};
  mdl_net_resp_t      response = {};
  mdl_cache_result_t  result;
  size_t              bytes = 0U;
  ra8_err_t           error = mdl_cache_get_buf(ctx->cache,
                                                priv_mdl_app_context()->state.cover_url,
                                                &request,
                                                priv_mdl_fetch_cache_get_buf,
                                                &fetch,
                                                ctx->page_buf,
                                                ctx->page_cap,
                                                &bytes,
                                                &response,
                                                &result);
  if (error == k_ra8_ok) {
    error = priv_mdl_app_report_cache(priv_mdl_app_context()->state.cover_url, &result);
  }
  if ((error == k_ra8_ok) && current && result.body_reused) {
    return k_ra8_ok;
  }
  if (error == k_ra8_ok) {
    return internal_cover_publish_cached(ctx, holding, bytes);
  }
  priv_mdl_fetch_record_fail(ctx, priv_mdl_app_context()->state.cover_url, response.status, error);
  return error;
}
 
RA8_PRIV ra8_err_t priv_mdl_app_ensure_series_cover(mdl_fetch_ctx_t* ctx,
                                                    const char*      series_directory)
{
  if ((ctx == nullptr) || (series_directory == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  if (priv_mdl_app_context()->state.cover_url[0] == '\0') {
    return k_ra8_ok;
  }
  const bool current = internal_cover_current(ctx, series_directory);
  if (current && (ctx->cache == nullptr) && !ctx->refetch) {
    return k_ra8_ok;
  }
  char holding[k_fw_fs_path_cap];
  if (!mdl_path_join(series_directory, "cover.download", holding, sizeof(holding))) {
    return k_ra8_err_invalid_size;
  }
  uint32_t crawl = 0U;
  if (!mdl_session_url_allowed(ctx->session, priv_mdl_app_context()->state.cover_url, &crawl)) {
    return k_ra8_err_access_denied;
  }
  char host[k_mdl_gov_host_max];
  if (!mdl_url_host(priv_mdl_app_context()->state.cover_url, host, sizeof(host))) {
    return k_ra8_err_invalid_arg;
  }
  const uint32_t minimum_delay =
    (ctx->site->img_delay_min > crawl) ? ctx->site->img_delay_min : crawl;
  const uint32_t maximum_delay =
    (ctx->site->img_delay_max > crawl) ? ctx->site->img_delay_max : crawl;
  return (ctx->cache != nullptr)
           ? internal_cover_cached(ctx, holding, host, minimum_delay, maximum_delay, current)
           : internal_cover_stream(ctx, holding, host, minimum_delay, maximum_delay);
}