native_dynamic_media.c

Go to the documentation of this file.

/**
 * @file
 * @brief Serves static assets from the artifact directory for in-process
 *        dynamic-app request handling, and provides media mutation helpers
 *        for upload, delete, and path-resolution operations.
 */
 
#include "native_dynamic_media.h"
 
#include "native_dynamic_multipart.h"
#include "native_fs.h"
#include "native_http_log.h"
#include "native_http_response.h"
#include "native_support.h"
#include "native_yyjson_helpers.h"
 
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/**
 * @brief Well-known JSON endpoints served from the artifact directory.
 */
static const char *WELL_KNOWN_JSON_PATHS[] = {
  "/manifest.json",
  "/route-manifest.json",
  "/app-graph-schema.json",
  "/app-model.json",
  "/component-graph.json",
  "/server-actions.json",
  "/dispatch-table.json",
  "/permission-matrix.json",
  "/cache-matrix.json",
  "/tau-state-catalog.json",
  "/tau-profile.json",
  "/native-graph.json",
  "/radius-graph.json",
  "/route-explain-project-detail.json",
  "/impact-project-card.json",
  "/dead-surface-report.json",
  "/consistency-report.json",
  "/policy-cache-report.json",
  "/performance-budget.json",
  "/generated-docs.json",
  "/generated-tests.json",
  "/scoreboard.json",
  "/release-evidence.json",
  "/api/manifest",
  "/api/graph/export/native",
  "/api/graph/export/radius",
  "/api/graph/explain",
  "/api/graph/impact",
  "/api/tau/profile",
  "/api/projects",
  "/api/projects/sample",
  "/api/scoreboard",
  NULL
};
 
/**
 * @brief Well-known HTML fallback routes that resolve to index.html.
 */
static const char *WELL_KNOWN_HTML_FALLBACKS[] = {
  "/",
  NULL
};
 
int native_dynamic_media_is_static_path(const char *path) {
  size_t i;
 
  if (path == NULL || path[0] == '\0') {
    return 0;
  }
 
  /* Static asset directories */
  if (starts_with(path, "/static/") || starts_with(path, "/media/")) {
    return 1;
  }
 
  /* Well-known JSON endpoints */
  for (i = 0; WELL_KNOWN_JSON_PATHS[i] != NULL; i++) {
    if (streq(path, WELL_KNOWN_JSON_PATHS[i])) {
      return 1;
    }
  }
 
  return 0;
}
 
char *native_dynamic_media_resolve_path(const char *artifact_dir, const char *path) {
  const char *relative;
  size_t path_len;
 
  if (artifact_dir == NULL || path == NULL) {
    return NULL;
  }
 
  path_len = strlen(path);
 
  /* Well-known JSON endpoints map to their artifact-local source file. */
  if (streq(path, "/manifest.json")) {
    return path_join(artifact_dir, "pharos.app.json");
  }
  if (streq(path, "/dispatch-table.json")) {
    return path_join(artifact_dir, "dispatch-table.json");
  }
  if (streq(path, "/api/manifest")) {
    return path_join(artifact_dir, "pharos.app.json");
  }
 
  /* Root and well-known HTML fallbacks -> index.html */
  if (path_len == 0 || (path_len == 1 && path[0] == '/')) {
    return path_join(artifact_dir, "index.html");
  }
 
  /* Static and media directories */
  if (starts_with(path, "/static/") || starts_with(path, "/media/")) {
    relative = path + 1; /* skip the leading / */
    return path_join(artifact_dir, relative);
  }
 
  /* Trailing slash -> try index.html in that directory */
  if (path[path_len - 1] == '/') {
    relative = path + 1;
    {
      char *dir_path = path_join(artifact_dir, relative);
      char *result = NULL;
      if (dir_path != NULL) {
        result = path_join(dir_path, "index.html");
        free(dir_path);
      }
      return result;
    }
  }
 
  /* Everything else: strip the leading / and look in artifact dir */
  relative = path + 1;
  return path_join(artifact_dir, relative);
}
 
int native_dynamic_media_serve_asset(
  NativeConnection *connection,
  const char *artifact_dir,
  const char *path,
  const HttpRequest *request
) {
  char *file_path = NULL;
  char *content_type = NULL;
  FILE *file = NULL;
  int status = 500;
  long long content_length = 0;
 
  (void)request;
 
  if (connection == NULL || artifact_dir == NULL || path == NULL) {
    native_send_text_response(connection, 500, "Internal Server Error", "invalid parameters\n");
    return 500;
  }
 
  /* Block path traversal */
  if (strstr(path, "..") != NULL) {
    native_send_text_response(connection, 400, "Bad Request", "blocked path traversal\n");
    return 400;
  }
 
  file_path = native_dynamic_media_resolve_path(artifact_dir, path);
  if (file_path == NULL) {
    native_send_text_response(connection, 500, "Internal Server Error", "memory allocation failed\n");
    return 500;
  }
 
  if (!path_exists(file_path)) {
    native_send_text_response(connection, 404, "Not Found", "Not Found");
    free(file_path);
    return 404;
  }
 
  if (path_is_directory(file_path)) {
    char *dir_index = path_join(file_path, "index.html");
    free(file_path);
    file_path = dir_index;
    if (file_path == NULL || !path_exists(file_path)) {
      native_send_text_response(connection, 404, "Not Found", "Not Found");
      free(file_path);
      return 404;
    }
  }
 
  file = fopen(file_path, "rb");
  if (file == NULL) {
    native_send_text_response(connection, 404, "Not Found", "Not Found");
    free(file_path);
    return 404;
  }
 
  if (fseek(file, 0, SEEK_END) != 0) {
    native_send_text_response(connection, 500, "Internal Server Error", "failed to read asset\n");
    status = 500;
    goto cleanup;
  }
  content_length = (long long)ftell(file);
  if (content_length < 0 || fseek(file, 0, SEEK_SET) != 0) {
    native_send_text_response(connection, 500, "Internal Server Error", "failed to read asset\n");
    status = 500;
    goto cleanup;
  }
 
  content_type = mime_type_for_path(file_path);
  if (content_type == NULL) {
    native_send_text_response(connection, 500, "Internal Server Error", "mime type failure\n");
    status = 500;
    goto cleanup;
  }
 
  /* API paths that resolve to octet-stream should be treated as JSON */
  if (starts_with(path, "/api/") && streq(content_type, "application/octet-stream")) {
    free(content_type);
    content_type = strdup("application/json");
    if (content_type == NULL) {
      native_send_text_response(connection, 500, "Internal Server Error", "mime type failure\n");
      status = 500;
      goto cleanup;
    }
  }
 
  if (native_connection_printf(
        connection,
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: %s\r\n"
        "Content-Length: %lld\r\n"
        "Connection: close\r\n"
        "\r\n",
        content_type,
        content_length
      ) != 0) {
    status = -1;
    goto cleanup;
  }
 
  {
    char chunk[4096];
    size_t bytes_read;
    while ((bytes_read = fread(chunk, 1, sizeof(chunk), file)) > 0) {
      if (native_connection_write(connection, chunk, bytes_read) != 0) {
        status = -1;
        goto cleanup;
      }
    }
  }
  status = 200;
 
cleanup:
  free(file_path);
  free(content_type);
  if (file != NULL) {
    fclose(file);
  }
  return status;
}
 
/* ------------------------------------------------------------------ */
/* Media mutation helpers                                              */
/* ------------------------------------------------------------------ */
 
char *safe_upload_filename_dup(const char *raw_name) {
  const char *base_name = raw_name;
  char *safe_name = NULL;
  size_t needed = 0;
  size_t write_index = 0;
  size_t index = 0;
  if (base_name == NULL) {
    return strdup("");
  }
  {
    const char *slash = strrchr(base_name, '/');
    const char *backslash = strrchr(base_name, '\\');
    if (slash != NULL && (backslash == NULL || slash > backslash)) {
      base_name = slash + 1;
    } else if (backslash != NULL) {
      base_name = backslash + 1;
    }
  }
  needed = strlen(base_name) + 1;
  safe_name = (char *)malloc(needed);
  if (safe_name == NULL) {
    return NULL;
  }
  for (index = 0; base_name[index] != '\0'; index++) {
    unsigned char ch = (unsigned char)base_name[index];
    char out = '_';
    if (isalnum(ch) || ch == '.' || ch == '_' || ch == '-') {
      out = (char)ch;
    } else if (ch == ' ') {
      out = '_';
    }
    safe_name[write_index++] = out;
  }
  safe_name[write_index] = '\0';
  while (safe_name[0] == '_' || safe_name[0] == '.' || safe_name[0] == '-') {
    memmove(safe_name, safe_name + 1, strlen(safe_name));
  }
  while (write_index > 0) {
    char tail = safe_name[write_index - 1];
    if (tail != '_' && tail != '.' && tail != '-') {
      break;
    }
    safe_name[--write_index] = '\0';
  }
  return safe_name;
}
 
char *media_disk_path_dup(const char *artifact_dir, const char *media_url) {
  if (artifact_dir == NULL || artifact_dir[0] == '\0' || media_url == NULL || !starts_with(media_url, "/media/")) {
    return NULL;
  }
  return path_join(artifact_dir, media_url + 1);
}
 
int ensure_media_subtree(const char *artifact_dir, const char *entity_type, const char *entity_slug) {
  char *fixture_path = NULL;
  yyjson_doc *doc = NULL;
  yyjson_val *root = NULL;
  yyjson_val *subtrees = NULL;
  yyjson_val *entry = NULL;
  size_t idx = 0;
  size_t count = 0;
  yyjson_val *type_val = NULL;
  const char *entry_type = NULL;
  char *base_template = NULL;
  yyjson_val *subdirs = NULL;
  char *base_path = NULL;
  int code = 69;
 
  if (artifact_dir == NULL || entity_type == NULL || entity_slug == NULL ||
      artifact_dir[0] == '\0' || entity_type[0] == '\0' || entity_slug[0] == '\0') {
    return 64;
  }
 
  /* Build fixture path */
  fixture_path = path_join(artifact_dir, "data/framework/media-policy-v1.json");
  if (fixture_path == NULL) {
    return 69;
  }
 
  /* Load the fixture */
  doc = native_json_doc_load_file(fixture_path);
  free(fixture_path);
  if (doc == NULL) {
    return 69;
  }
 
  root = yyjson_doc_get_root(doc);
  if (root == NULL || !yyjson_is_obj(root)) {
    native_json_doc_free(doc);
    return 69;
  }
 
  /* Get the media_subtrees array */
  subtrees = native_json_obj_get_array(root, "media_subtrees");
  if (subtrees == NULL) {
    native_json_doc_free(doc);
    return 69;
  }
 
  /* Look for the matching entity type */
  count = yyjson_arr_size(subtrees);
  entry = NULL;
  for (idx = 0; idx < count; idx++) {
    yyjson_val *candidate = yyjson_arr_get(subtrees, idx);
    if (candidate == NULL || !yyjson_is_obj(candidate)) {
      continue;
    }
    type_val = native_json_obj_get(candidate, "entity_type");
    if (type_val == NULL || !yyjson_is_str(type_val)) {
      continue;
    }
    entry_type = yyjson_get_str(type_val);
    if (streq(entry_type, entity_type)) {
      entry = candidate;
      break;
    }
  }
 
  if (entry == NULL) {
    native_json_doc_free(doc);
    return 0; /* No matching policy — not an error */
  }
 
  /* Get the base path template and replace {slug} */
  base_template = native_json_obj_get_string_dup(entry, "base_path_template");
  if (base_template == NULL || base_template[0] == '\0') {
    free(base_template);
    native_json_doc_free(doc);
    return 64;
  }
 
  {
    /* Replace {slug} with the entity slug */
    const char *placeholder = "{slug}";
    char *slug_pos = strstr(base_template, placeholder);
    if (slug_pos != NULL) {
      size_t prefix_len = (size_t)(slug_pos - base_template);
      size_t suffix_len = strlen(slug_pos + strlen(placeholder));
      size_t slug_len = strlen(entity_slug);
      base_path = (char *)malloc(prefix_len + slug_len + suffix_len + 1);
      if (base_path == NULL) {
        free(base_template);
        native_json_doc_free(doc);
        return 69;
      }
      memcpy(base_path, base_template, prefix_len);
      memcpy(base_path + prefix_len, entity_slug, slug_len);
      memmove(base_path + prefix_len + slug_len, slug_pos + strlen(placeholder), suffix_len + 1);
    } else {
      base_path = strdup(base_template);
      if (base_path == NULL) {
        free(base_template);
        native_json_doc_free(doc);
        return 69;
      }
    }
    free(base_template);
  }
 
  /* Create the base directory */
  {
    char *full_dir = path_join(artifact_dir, base_path);
    if (full_dir == NULL) {
      free(base_path);
      native_json_doc_free(doc);
      return 69;
    }
    code = ensure_directory(full_dir);
    free(full_dir);
    if (code != 0) {
      free(base_path);
      native_json_doc_free(doc);
      return code;
    }
  }
 
  /* Create each subdirectory declared in the fixture */
  subdirs = native_json_obj_get_array(entry, "subdirectories");
  if (subdirs != NULL) {
    size_t sub_count = yyjson_arr_size(subdirs);
    for (idx = 0; idx < sub_count; idx++) {
      yyjson_val *sub_val = yyjson_arr_get(subdirs, idx);
      if (sub_val == NULL || !yyjson_is_str(sub_val)) {
        continue;
      }
      {
        const char *sub_name = yyjson_get_str(sub_val);
        char *sub_path = path_join(base_path, sub_name);
        char *full_sub_dir = NULL;
        if (sub_path == NULL) {
          free(base_path);
          native_json_doc_free(doc);
          return 69;
        }
        full_sub_dir = path_join(artifact_dir, sub_path);
        free(sub_path);
        if (full_sub_dir == NULL) {
          free(base_path);
          native_json_doc_free(doc);
          return 69;
        }
        code = ensure_directory(full_sub_dir);
        free(full_sub_dir);
        if (code != 0) {
          free(base_path);
          native_json_doc_free(doc);
          return code;
        }
      }
    }
  }
 
  free(base_path);
  native_json_doc_free(doc);
  return 0;
}
 
int ensure_business_media_tree(const char *artifact_dir, const char *business_slug) {
  return ensure_media_subtree(artifact_dir, "business", business_slug);
}
 
int remove_media_url_file(const char *artifact_dir, const char *media_url) {
  char *disk_path = NULL;
  if (artifact_dir == NULL || artifact_dir[0] == '\0' || media_url == NULL || !starts_with(media_url, "/media/businesses/")) {
    return 0;
  }
  disk_path = media_disk_path_dup(artifact_dir, media_url);
  if (disk_path != NULL && path_exists(disk_path)) {
    remove(disk_path);
  }
  free(disk_path);
  return 0;
}
 
char *store_uploaded_media(
  const char *artifact_dir,
  const char *content_type,
  const char *body_path,
  const char *field_name,
  const char *target_url_dir,
  const char *fallback_filename
) {
  unsigned char *body_bytes = NULL;
  size_t body_len = 0;
  const unsigned char *content_start = NULL;
  size_t content_len = 0;
  char *raw_filename = NULL;
  char *safe_filename = NULL;
  char *target_dir = NULL;
  char *target_path = NULL;
  char *media_url = NULL;
  size_t media_url_len = 0;
  int code = 69;
  if (artifact_dir == NULL || artifact_dir[0] == '\0' || content_type == NULL || body_path == NULL || body_path[0] == '\0' || field_name == NULL || field_name[0] == '\0' || target_url_dir == NULL || target_url_dir[0] == '\0') {
    return NULL;
  }
  body_bytes = read_file_bytes_dup_runtime(body_path, &body_len);
  if (body_bytes == NULL) {
    return NULL;
  }
  if (!native_dynamic_multipart_find_part(body_bytes, body_len, content_type, field_name, NULL, &raw_filename, &content_start, &content_len)) {
    code = 0;
    goto cleanup;
  }
  safe_filename = safe_upload_filename_dup(raw_filename != NULL && raw_filename[0] != '\0' ? raw_filename : fallback_filename);
  if ((safe_filename == NULL || safe_filename[0] == '\0') && fallback_filename != NULL && fallback_filename[0] != '\0') {
    free(safe_filename);
    safe_filename = safe_upload_filename_dup(fallback_filename);
  }
  if (safe_filename == NULL || safe_filename[0] == '\0') {
    code = 0;
    goto cleanup;
  }
  target_dir = path_join(artifact_dir, target_url_dir[0] == '/' ? target_url_dir + 1 : target_url_dir);
  target_path = target_dir != NULL ? path_join(target_dir, safe_filename) : NULL;
  if (target_dir == NULL || target_path == NULL || ensure_directory(target_dir) != 0) {
    code = 69;
    goto cleanup;
  }
  code = write_binary_file_runtime(target_path, content_start, content_len);
  if (code != 0) {
    goto cleanup;
  }
  media_url_len = strlen(target_url_dir) + 1 + strlen(safe_filename) + 1;
  media_url = (char *)malloc(media_url_len);
  if (media_url == NULL) {
    code = 69;
    goto cleanup;
  }
  snprintf(media_url, media_url_len, "%s/%s", target_url_dir, safe_filename);
  code = 0;
cleanup:
  free(body_bytes);
  free(raw_filename);
  free(safe_filename);
  free(target_dir);
  free(target_path);
  if (code != 0) {
    free(media_url);
    media_url = NULL;
  }
  return media_url;
}