ucal_static_server.c

Go to the documentation of this file.

/**
 * @file
 * @brief Provides a minimal loopback static server for serving UCAL build artifacts and route-mapped files directly from a build root.
 */
 
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <signal.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
static int send_all(int fd, const char *buf, size_t len) {
  while (len > 0) {
    ssize_t n = send(fd, buf, len, 0);
    if (n <= 0) return -1;
    buf += (size_t)n;
    len -= (size_t)n;
  }
  return 0;
}
 
static char *read_file(const char *path, size_t *len_out) {
  FILE *f = fopen(path, "rb");
  long n;
  char *buf;
  if (!f) return NULL;
  if (fseek(f, 0, SEEK_END) != 0) { fclose(f); return NULL; }
  n = ftell(f);
  if (n < 0) { fclose(f); return NULL; }
  if (fseek(f, 0, SEEK_SET) != 0) { fclose(f); return NULL; }
  buf = (char *)malloc((size_t)n + 1);
  if (!buf) { fclose(f); return NULL; }
  if (fread(buf, 1, (size_t)n, f) != (size_t)n) { free(buf); fclose(f); return NULL; }
  fclose(f);
  buf[n] = '\0';
  *len_out = (size_t)n;
  return buf;
}
 
static int path_has_parent_reference(const char *path) {
  return strstr(path, "..") != NULL;
}
 
static const char *content_type_for_path(const char *path) {
  const char *ext = strrchr(path, '.');
  if (!ext) return "application/octet-stream";
  if (strcmp(ext, ".html") == 0) return "text/html; charset=utf-8";
  if (strcmp(ext, ".json") == 0) return "application/json";
  if (strcmp(ext, ".css") == 0) return "text/css; charset=utf-8";
  if (strcmp(ext, ".js") == 0) return "application/javascript; charset=utf-8";
  if (strcmp(ext, ".svg") == 0) return "image/svg+xml";
  if (strcmp(ext, ".png") == 0) return "image/png";
  if (strcmp(ext, ".jpg") == 0 || strcmp(ext, ".jpeg") == 0) return "image/jpeg";
  if (strcmp(ext, ".gif") == 0) return "image/gif";
  if (strcmp(ext, ".webp") == 0) return "image/webp";
  if (strcmp(ext, ".ico") == 0) return "image/x-icon";
  return "application/octet-stream";
}
 
static int resolve_direct_asset(const char *root, const char *path,
                                char *file_path, size_t file_path_len,
                                char *content_type, size_t content_type_len) {
  const char *relative = path[0] == '/' ? path + 1 : path;
  if (!(strncmp(path, "/static/", 8) == 0 || strncmp(path, "/media/", 7) == 0)) return 0;
  if (path_has_parent_reference(relative)) return -1;
  if (snprintf(file_path, file_path_len, "%s/%s", root, relative) >= (int)file_path_len) return -1;
  if (snprintf(content_type, content_type_len, "%s", content_type_for_path(file_path)) >= (int)content_type_len) return -1;
  return 1;
}
 
static int lookup_route_map(const char *root, const char *path,
                            char *artifact, size_t artifact_len,
                            char *content_type, size_t content_type_len) {
  char map_path[2048];
  char line[4096];
  FILE *f;
  if (snprintf(map_path, sizeof(map_path), "%s/runtime-route-map.tsv", root) >= (int)sizeof(map_path)) return 0;
  f = fopen(map_path, "rb");
  if (!f) return 0;
  while (fgets(line, sizeof(line), f)) {
    char *method = line;
    char *route_path = strchr(method, '\t');
    char *route_artifact;
    char *route_type;
    char *status;
    if (!route_path) continue;
    *route_path++ = '\0';
    route_artifact = strchr(route_path, '\t');
    if (!route_artifact) continue;
    *route_artifact++ = '\0';
    route_type = strchr(route_artifact, '\t');
    if (!route_type) continue;
    *route_type++ = '\0';
    status = strchr(route_type, '\t');
    if (!status) continue;
    *status++ = '\0';
    status[strcspn(status, "\r\n")] = '\0';
    if (strcmp(method, "GET") == 0 && strcmp(route_path, path) == 0) {
      if (snprintf(artifact, artifact_len, "%s", route_artifact) >= (int)artifact_len ||
          snprintf(content_type, content_type_len, "%s", route_type) >= (int)content_type_len) {
        fclose(f);
        return 0;
      }
      fclose(f);
      return 1;
    }
  }
  fclose(f);
  return 0;
}
 
/**
 * @brief Serves one loopback client request from the UCAL build root.
 */
static void handle_client(int client, const char *root) {
  char req[4096];
  char method[16];
  char path[1024];
  char content_type[128];
  char rel[1024];
  char file_path[2048];
  char header[512];
  char *body;
  int direct_asset_status;
  size_t body_len = 0;
  ssize_t got = recv(client, req, sizeof(req) - 1, 0);
  if (got <= 0) return;
  req[got] = '\0';
  method[0] = '\0';
  path[0] = '\0';
  if (sscanf(req, "%15s %1023s", method, path) != 2 || strcmp(method, "GET") != 0) {
    const char *bad = "HTTP/1.1 405 Method Not Allowed\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
    (void)send_all(client, bad, strlen(bad));
    return;
  }
  direct_asset_status = resolve_direct_asset(root, path, file_path, sizeof(file_path), content_type, sizeof(content_type));
  if (direct_asset_status < 0) {
    const char *bad = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
    (void)send_all(client, bad, strlen(bad));
    return;
  }
  if (direct_asset_status == 0) {
    if (!lookup_route_map(root, path, rel, sizeof(rel), content_type, sizeof(content_type))) {
      const char *not_found = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
      (void)send_all(client, not_found, strlen(not_found));
      return;
    }
    if (snprintf(file_path, sizeof(file_path), "%s/%s", root, rel) >= (int)sizeof(file_path)) {
      const char *too_long = "HTTP/1.1 414 URI Too Long\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
      (void)send_all(client, too_long, strlen(too_long));
      return;
    }
  }
  body = read_file(file_path, &body_len);
  if (!body) {
    const char *missing = "HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";
    (void)send_all(client, missing, strlen(missing));
    return;
  }
  (void)snprintf(header, sizeof(header),
                 "HTTP/1.1 200 OK\r\nContent-Type: %s\r\nContent-Length: %zu\r\nConnection: close\r\n\r\n",
                 content_type, body_len);
  (void)send_all(client, header, strlen(header));
  (void)send_all(client, body, body_len);
  free(body);
}
 
/**
 * @brief Starts the minimal UCAL loopback static server.
 */
int main(int argc, char **argv) {
  const char *root = argc > 1 ? argv[1] : ".";
  int port = argc > 2 ? atoi(argv[2]) : 19090;
  int max_requests = argc > 3 ? atoi(argv[3]) : 3;
  int server_fd;
  int opt = 1;
  struct sockaddr_in addr;
  if (port <= 0 || port > 65535) return 64;
  if (max_requests <= 0) max_requests = 3;
  signal(SIGPIPE, SIG_IGN);
  server_fd = socket(AF_INET, SOCK_STREAM, 0);
  if (server_fd < 0) return 70;
  (void)setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
  memset(&addr, 0, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_port = htons((uint16_t)port);
  addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  if (bind(server_fd, (struct sockaddr *)&addr, sizeof(addr)) != 0) return 71;
  if (listen(server_fd, 16) != 0) return 72;
  for (int i = 0; i < max_requests; i++) {
    int client = accept(server_fd, NULL, NULL);
    if (client < 0) {
      if (errno == EINTR) { i--; continue; }
      break;
    }
    handle_client(client, root);
    close(client);
  }
  close(server_fd);
  return 0;
}