native_http_request.c

Go to the documentation of this file.

/**
 * @file
 * @brief Parses HTTP requests from native connections into method, target, header, cookie, and body fields.
 */
 
#include "native_http_request.h"
 
#include "native_spawn_temp_body.h"
#include "native_support.h"
 
#include <stdlib.h>
#include <string.h>
#ifndef _WIN32
#include <unistd.h>
#endif
 
#define PHAROS_HTTP_MAX_HEADER_BYTES (16U * 1024U)
#define PHAROS_HTTP_MAX_REQUEST_LINE_BYTES (8U * 1024U)
#define PHAROS_HTTP_MAX_HEADER_LINE_BYTES (4U * 1024U)
#define PHAROS_HTTP_MAX_HEADER_COUNT 100U
#define PHAROS_HTTP_MAX_BODY_BYTES (1U * 1024U * 1024U)
#define PHAROS_HTTP_MAX_MULTIPART_BODY_BYTES (16U * 1024U * 1024U)
 
#ifdef _WIN32
#include <winsock2.h>
#define native_http_request_strdup _strdup
#else
#include <strings.h>
#include <sys/socket.h>
#define native_http_request_strdup strdup
#endif
 
void free_http_request_native(HttpRequest *request) {
  if (request == NULL) {
    return;
  }
  free(request->method);
  free(request->target);
  free(request->cookie);
  free(request->content_type);
  free(request->headers);
  free(request->body);
  cleanup_native_temp_body_file(&request->body_file_path);
  memset(request, 0, sizeof(*request));
}
 
static int parse_content_length_header_native(const char *header_value, long *content_length) {
  char *end = NULL;
  long parsed_length;
  if (header_value == NULL || content_length == NULL) {
    return 400;
  }
  parsed_length = strtol(header_value, &end, 10);
  if (end == header_value || parsed_length < 0) {
    return 400;
  }
  while (end != NULL && *end != '\0') {
    if (*end != ' ' && *end != '\t') {
      return 400;
    }
    end++;
  }
  *content_length = parsed_length;
  return 0;
}
 
static size_t native_http_body_limit(int is_multipart) {
  return is_multipart ? PHAROS_HTTP_MAX_MULTIPART_BODY_BYTES : PHAROS_HTTP_MAX_BODY_BYTES;
}
 
static int contains_chunked_transfer_native(const char *header_value) {
  const char *cursor;
  if (header_value == NULL) {
    return 0;
  }
  for (cursor = header_value; *cursor != '\0'; cursor++) {
    if ((cursor[0] == 'c' || cursor[0] == 'C') &&
        (cursor[1] == 'h' || cursor[1] == 'H') &&
        (cursor[2] == 'u' || cursor[2] == 'U') &&
        (cursor[3] == 'n' || cursor[3] == 'N') &&
        (cursor[4] == 'k' || cursor[4] == 'K') &&
        (cursor[5] == 'e' || cursor[5] == 'E') &&
        (cursor[6] == 'd' || cursor[6] == 'D')) {
      return 1;
    }
  }
  return 0;
}
 
#ifndef _WIN32
static int native_write_temp_body_chunk(int temp_fd, const char *data, size_t data_len) {
  size_t written = 0;
  if (temp_fd < 0 || (data == NULL && data_len > 0)) {
    return 69;
  }
  while (written < data_len) {
    ssize_t chunk_written = write(temp_fd, data + written, data_len - written);
    if (chunk_written <= 0) {
      return 69;
    }
    written += (size_t)chunk_written;
  }
  return 0;
}
 
static int native_spool_request_body_to_temp_file(
  Buffer *buffer,
  size_t body_offset,
  long content_length,
  NativeConnection *connection,
  char **body_file_path_out
) {
  char temp_template[] = "/tmp/pharos-body-XXXXXX";
  int temp_fd;
  size_t initial_len;
  size_t written = 0;
  char chunk[4096];
  if (buffer == NULL || connection == NULL || body_file_path_out == NULL || content_length < 0) {
    return 69;
  }
  *body_file_path_out = NULL;
  temp_fd = mkstemp(temp_template);
  if (temp_fd < 0) {
    return 69;
  }
  initial_len = buffer->len > body_offset ? buffer->len - body_offset : 0;
  if ((long)initial_len > content_length) {
    initial_len = (size_t)content_length;
  }
  if (initial_len > 0 && native_write_temp_body_chunk(temp_fd, buffer->data + body_offset, initial_len) != 0) {
    close(temp_fd);
    unlink(temp_template);
    return 69;
  }
  written = initial_len;
  while (written < (size_t)content_length) {
    size_t remaining = (size_t)content_length - written;
    size_t to_read = remaining < sizeof(chunk) ? remaining : sizeof(chunk);
    int bytes_read = native_connection_read(connection, chunk, to_read);
    if (bytes_read <= 0) {
      close(temp_fd);
      unlink(temp_template);
      return 65;
    }
    if (native_write_temp_body_chunk(temp_fd, chunk, (size_t)bytes_read) != 0) {
      close(temp_fd);
      unlink(temp_template);
      return 69;
    }
    written += (size_t)bytes_read;
  }
  if (close(temp_fd) != 0) {
    unlink(temp_template);
    return 69;
  }
  *body_file_path_out = native_http_request_strdup(temp_template);
  if (*body_file_path_out == NULL) {
    unlink(temp_template);
    return 69;
  }
  return 0;
}
#else
static int native_spool_request_body_to_temp_file(
  Buffer *buffer,
  size_t body_offset,
  long content_length,
  NativeConnection *connection,
  char **body_file_path_out
) {
  (void)buffer;
  (void)body_offset;
  (void)content_length;
  (void)connection;
  if (body_file_path_out != NULL) {
    *body_file_path_out = NULL;
  }
  return 78;
}
#endif
 
static void apply_known_header_native(
  HttpRequest *request,
  const char *header_name,
  const char *header_value,
  long *content_length,
  int *chunked_transfer
) {
  static const struct {
    const char *name;
    int kind;
  } header_map[] = {
    { "Content-Length", 1 },
    { "Content-Type", 2 },
    { "Cookie", 3 },
    { "Transfer-Encoding", 4 }
  };
  size_t index;
  for (index = 0; index < sizeof(header_map) / sizeof(header_map[0]); index++) {
    if (strcasecmp(header_name, header_map[index].name) != 0) {
      continue;
    }
    switch (header_map[index].kind) {
      case 1:
        if (parse_content_length_header_native(header_value, content_length) != 0) {
          *content_length = -1;
        }
        return;
      case 2:
        free(request->content_type);
        request->content_type = native_http_request_strdup(header_value);
        return;
      case 3:
        free(request->cookie);
        request->cookie = native_http_request_strdup(header_value);
        return;
      case 4:
        if (chunked_transfer != NULL && contains_chunked_transfer_native(header_value)) {
          *chunked_transfer = 1;
        }
        return;
    }
  }
}
 
int parse_http_request_native(NativeConnection *connection, HttpRequest *request) {
  Buffer buffer;
  char chunk[4096];
  int bytes_read;
  char *header_end;
  size_t header_len;
  size_t body_offset;
  long content_length = 0;
  char *request_line_end;
  char *space1;
  char *space2;
  char *headers_copy = NULL;
  char *line;
  int parse_code = 0;
  int chunked_transfer = 0;
  size_t header_count = 0;
  size_t body_limit;
  buffer_init(&buffer);
  memset(request, 0, sizeof(*request));
  while (1) {
    bytes_read = native_connection_read(connection, chunk, sizeof(chunk));
    if (bytes_read <= 0) {
      parse_code = 65;
      goto cleanup;
    }
    if (buffer_append(&buffer, chunk, (size_t)bytes_read) != 0) {
      parse_code = 69;
      goto cleanup;
    }
    header_end = strstr(buffer.data, "\r\n\r\n");
    if (header_end == NULL) {
      header_end = strstr(buffer.data, "\n\n");
    }
    if (header_end != NULL) {
      break;
    }
    if (buffer.len > PHAROS_HTTP_MAX_HEADER_BYTES) {
      parse_code = 431;
      goto cleanup;
    }
  }
  header_end = strstr(buffer.data, "\r\n\r\n");
  if (header_end != NULL) {
    header_len = (size_t)(header_end - buffer.data);
    body_offset = header_len + 4;
  } else {
    header_end = strstr(buffer.data, "\n\n");
    if (header_end == NULL) {
      parse_code = 65;
      goto cleanup;
    }
    header_len = (size_t)(header_end - buffer.data);
    body_offset = header_len + 2;
  }
  if (header_len > PHAROS_HTTP_MAX_HEADER_BYTES) {
    parse_code = 431;
    goto cleanup;
  }
  headers_copy = dup_range(buffer.data, header_len);
  if (headers_copy == NULL) {
    parse_code = 69;
    goto cleanup;
  }
  request_line_end = strstr(headers_copy, "\r\n");
  if (request_line_end == NULL) {
    request_line_end = strchr(headers_copy, '\n');
  }
  if (request_line_end == NULL) {
    parse_code = 65;
    goto cleanup;
  }
  *request_line_end = '\0';
  if (strlen(headers_copy) > PHAROS_HTTP_MAX_REQUEST_LINE_BYTES) {
    parse_code = 414;
    goto cleanup;
  }
  space1 = strchr(headers_copy, ' ');
  if (space1 == NULL) {
    parse_code = 65;
    goto cleanup;
  }
  *space1 = '\0';
  request->method = native_http_request_strdup(headers_copy);
  space2 = strchr(space1 + 1, ' ');
  if (space2 == NULL) {
    parse_code = 65;
    goto cleanup;
  }
  *space2 = '\0';
  request->target = native_http_request_strdup(space1 + 1);
  request->content_type = native_http_request_strdup("application/x-www-form-urlencoded");
  request->cookie = native_http_request_strdup("");
  if (request->method == NULL || request->target == NULL || request->content_type == NULL || request->cookie == NULL) {
    parse_code = 69;
    goto cleanup;
  }
  {
    Buffer header_lines;
    buffer_init(&header_lines);
    line = request_line_end + 1;
    if (*line == '\n') {
      line++;
    }
    while (line != NULL && *line != '\0') {
      char *next = strstr(line, "\r\n");
      if (next == NULL) {
        next = strchr(line, '\n');
      }
      if (next != NULL) {
        *next = '\0';
      }
      if (*line != '\0') {
        char *colon;
        header_count++;
        if (header_count > PHAROS_HTTP_MAX_HEADER_COUNT || strlen(line) > PHAROS_HTTP_MAX_HEADER_LINE_BYTES) {
          buffer_free(&header_lines);
          parse_code = 431;
          goto cleanup;
        }
        colon = strchr(line, ':');
        if (colon == NULL) {
          buffer_free(&header_lines);
          parse_code = 400;
          goto cleanup;
        }
        *colon = '\0';
        trim_in_place(line);
        trim_in_place(colon + 1);
        apply_known_header_native(request, line, colon + 1, &content_length, &chunked_transfer);
        if (content_length < 0) {
          buffer_free(&header_lines);
          parse_code = 400;
          goto cleanup;
        }
        if (buffer_append(&header_lines, line, strlen(line)) != 0 ||
            buffer_append(&header_lines, ":", 1) != 0 ||
            buffer_append(&header_lines, colon + 1, strlen(colon + 1)) != 0 ||
            buffer_append(&header_lines, "\n", 1) != 0) {
          buffer_free(&header_lines);
          parse_code = 69;
          goto cleanup;
        }
      }
      if (next == NULL) {
        break;
      }
      line = next + 1;
      if (*line == '\n') {
        line++;
      }
    }
    request->headers = header_lines.data;
  }
  if (chunked_transfer) {
    parse_code = 501;
    goto cleanup;
  }
  request->is_multipart = request->content_type != NULL && strstr(request->content_type, "multipart/form-data") != NULL;
  body_limit = native_http_body_limit(request->is_multipart);
  if ((unsigned long)content_length > (unsigned long)body_limit) {
    parse_code = 413;
    goto cleanup;
  }
  request->body_len = content_length > 0 ? (size_t)content_length : 0;
  if (request->body_len == 0) {
    parse_code = 0;
    goto cleanup;
  }
  parse_code = native_spool_request_body_to_temp_file(
    &buffer,
    body_offset,
    content_length,
    connection,
    &request->body_file_path
  );
  goto cleanup;
  while ((long)(buffer.len - body_offset) < content_length) {
    bytes_read = native_connection_read(connection, chunk, sizeof(chunk));
    if (bytes_read <= 0) {
      parse_code = 65;
      goto cleanup;
    }
    if (buffer_append(&buffer, chunk, (size_t)bytes_read) != 0) {
      parse_code = 69;
      goto cleanup;
    }
  }
  request->body = dup_range(buffer.data + body_offset, request->body_len);
  if (request->body == NULL && request->body_len > 0) {
    parse_code = 69;
    goto cleanup;
  }
 
cleanup:
  free(headers_copy);
  buffer_free(&buffer);
  if (parse_code != 0) {
    free_http_request_native(request);
  }
  return parse_code;
}