lander/src/http_loop/http_loop_res.c

#include <stdio.h>
#include <sys/stat.h>

#include "http_loop.h"
#include "log.h"

#define MIN(x, y) (((x) < (y)) ? (x) : (y))

static const char *http_response_format = "HTTP/1.1 %i %s\n"
                                          "Server: lander/" LANDER_VERSION "\n"
                                          "Content-Length: %lu\n";

/*
 * This function precalculates the size of the total buffer required using
 * snprintf. When this function is called with a buf size of 0, it never tries
 * to write any data, but it does return the amount of bytes that would be
 * written.
 */
void http_loop_init_header(http_response *res) {
  if (res->type == 0) {
    res->type = http_ok;
  }

  const char *response_type_name =
      http_response_type_names[res->type / 100 - 1][res->type % 100];

  // First we calculate the size of the start of the header
  int buf_size = snprintf(NULL, 0, http_response_format, res->type,
                          response_type_name, res->body_len);

  // We add each header's required size
  for (size_t i = 0; i < res->header_count; i++) {
    buf_size +=
        snprintf(NULL, 0, "%s: %s\n", http_header_names[res->headers[i].type],
                 res->headers[i].value);
  }

  // The + 1 is required to store the final null byte, but we will replace it
  // with the required final newline
  char *buf = malloc(buf_size + 1);
  buf_size = sprintf(buf, http_response_format, res->type, response_type_name,
                     res->body_len);

  for (size_t i = 0; i < res->header_count; i++) {
    buf_size +=
        sprintf(&buf[buf_size], "%s: %s\n",
                http_header_names[res->headers[i].type], res->headers[i].value);
  }

  buf[buf_size] = '\n';

  res->head = buf;
  res->head_len = buf_size + 1;
}

void http_loop_write_response(event_loop_conn *conn) {
  http_response *res = &((http_loop_ctx *)conn->ctx)->res;

  // Create head response
  if (res->head == NULL) {
    http_loop_init_header(res);
  }

  // The final iteration marks the end of the response, after which we reset the
  // context so a next request can be processed
  if (res->head_written == res->head_len &&
      res->body_written == res->body_len) {
    http_loop_ctx_reset(conn->ctx);
    conn->state = event_loop_conn_state_req;
    return;
  }

  if (res->head_written < res->head_len) {
    size_t bytes_to_write = MIN(res->head_len - res->head_written,
                                EVENT_LOOP_BUFFER_SIZE - conn->wbuf_size);
    memcpy(&conn->wbuf[conn->wbuf_size], &res->head[res->head_written],
           bytes_to_write);

    conn->wbuf_size += bytes_to_write;
    res->head_written += bytes_to_write;
  }

  if (res->body_written < res->body_len) {
    size_t bytes_to_write = MIN(res->body_len - res->body_written,
                                EVENT_LOOP_BUFFER_SIZE - conn->wbuf_size);
    size_t bytes_written;

    switch (res->body_type) {
    case http_response_body_buf:
      memcpy(&conn->wbuf[conn->wbuf_size], &res->body[res->body_written],
             bytes_to_write);
      conn->wbuf_size += bytes_to_write;
      res->body_written += bytes_to_write;
      break;
    case http_response_body_file:
      bytes_written = fread(&conn->wbuf[conn->wbuf_size], sizeof(uint8_t),
                            bytes_to_write, res->body);
      conn->wbuf_size += bytes_written;
      res->body_written += bytes_written;
      break;
    }
  }
}

void http_loop_res_set_body_buf(http_loop_ctx *ctx, const char *body,
                                size_t body_len, bool owned) {
  ctx->res.body_type = http_response_body_buf;
  ctx->res.body = (void *)body;
  ctx->res.body_len = body_len;
  ctx->res.owns_body = owned;
}

void http_loop_res_set_body_file(http_loop_ctx *ctx, const char *filename) {
  struct stat st;
  stat(filename, &st);

  // TODO error handling
  FILE *f = fopen(filename, "r");

  ctx->res.body_type = http_response_body_file;
  ctx->res.body = f;
  ctx->res.body_len = st.st_size;
}

void http_loop_res_add_header(http_loop_ctx *ctx, http_header type,
                              const char *value, bool owned) {
  ctx->res.headers[ctx->res.header_count].type = type;
  ctx->res.headers[ctx->res.header_count].value = value;
  ctx->res.headers[ctx->res.header_count].owned = owned;

  ctx->res.header_count++;
}