native_dynamic_multipart.c

Go to the documentation of this file.

/**
 * @file
 * @brief Pharos-owned multipart form-data parsing for in-process dynamic handling.
 *
 * Provides boundary extraction, part lookup, filename extraction, and
 * file-part extraction so that the dynamic runtime can process multipart
 * uploads without delegating to a child process or relying on app-owned
 * shell logic.
 *
 * This module is the canonical Pharos-owned implementation of multipart
 * parsing.  App-owned shell code must not replicate this logic.
 */
 
#include "native_dynamic_multipart.h"
 
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
/* ------------------------------------------------------------------ */
/* Internal helpers                                                     */
/* ------------------------------------------------------------------ */
 
/**
 * @brief Finds a byte pattern within a buffer.
 *
 * @param haystack      Buffer to search.
 * @param haystack_len  Byte length of @p haystack.
 * @param needle        Pattern to locate.
 * @param needle_len    Byte length of @p needle.
 * @return Pointer to first occurrence within @p haystack, or NULL.
 */
static const unsigned char *multipart_memmem(
  const unsigned char *haystack,
  size_t haystack_len,
  const unsigned char *needle,
  size_t needle_len
) {
  size_t i;
  if (haystack == NULL || needle == NULL || needle_len == 0 || haystack_len < needle_len) {
    return NULL;
  }
  for (i = 0; i + needle_len <= haystack_len; i++) {
    if (memcmp(haystack + i, needle, needle_len) == 0) {
      return haystack + i;
    }
  }
  return NULL;
}
 
/**
 * @brief Allocates a NUL-terminated copy of a byte range.
 *
 * @param start  Start of the range (need not be NUL-terminated).
 * @param len    Number of bytes to copy.
 * @return Newly allocated NUL-terminated string, or NULL on allocation failure.
 */
static char *multipart_dup_range(const char *start, size_t len) {
  char *out;
  if (start == NULL || len == 0) {
    return NULL;
  }
  out = (char *)malloc(len + 1);
  if (out == NULL) {
    return NULL;
  }
  memcpy(out, start, len);
  out[len] = '\0';
  return out;
}
 
/**
 * @brief Extracts the MIME boundary from a Content-Type header value.
 *
 * Handles both quoted and unquoted boundary parameters.
 *
 * @param content_type  The full Content-Type header value.
 * @return Newly allocated boundary string (without the leading @c -- ),
 *         or NULL when the boundary cannot be determined.
 */
char *native_dynamic_multipart_boundary(const char *content_type) {
  const char *boundary_start = NULL;
  const char *boundary_end = NULL;
  if (content_type == NULL) {
    return NULL;
  }
  boundary_start = strstr(content_type, "boundary=");
  if (boundary_start == NULL) {
    return NULL;
  }
  boundary_start += 9;
  if (*boundary_start == '"') {
    boundary_start++;
    boundary_end = strchr(boundary_start, '"');
  } else {
    boundary_end = boundary_start;
    while (*boundary_end != '\0' && *boundary_end != ';' && !isspace((unsigned char)*boundary_end)) {
      boundary_end++;
    }
  }
  if (boundary_end == NULL || boundary_end <= boundary_start) {
    return NULL;
  }
  return multipart_dup_range(boundary_start, (size_t)(boundary_end - boundary_start));
}
 
/**
 * @brief Extracts a quoted parameter value from MIME part headers.
 *
 * @param headers_text  NUL-terminated headers block for one part.
 * @param key           Parameter name (e.g. @c name or @c filename).
 * @return Newly allocated parameter value, or NULL when absent.
 */
static char *multipart_header_param_dup(const char *headers_text, const char *key) {
  char pattern[64];
  const char *match = NULL;
  const char *value_start = NULL;
  const char *value_end = NULL;
  if (headers_text == NULL || key == NULL || key[0] == '\0') {
    return NULL;
  }
  snprintf(pattern, sizeof(pattern), "%s=\"", key);
  match = strstr(headers_text, pattern);
  if (match == NULL) {
    return NULL;
  }
  value_start = match + strlen(pattern);
  value_end = strchr(value_start, '"');
  if (value_end == NULL || value_end < value_start) {
    return NULL;
  }
  return multipart_dup_range(value_start, (size_t)(value_end - value_start));
}
 
/* ------------------------------------------------------------------ */
/* Public API                                                          */
/* ------------------------------------------------------------------ */
 
int native_dynamic_multipart_find_part(
  const unsigned char *body,
  size_t body_len,
  const char *content_type,
  const char *field_name,
  char **out_text,
  char **out_filename,
  const unsigned char **out_content_start,
  size_t *out_content_len
) {
  char *boundary = NULL;
  char *delimiter = NULL;
  char *delimiter_crlf = NULL;
  char *delimiter_lf = NULL;
  const unsigned char *cursor = NULL;
  size_t delimiter_len = 0;
  int found = 0;
 
  if (out_text != NULL) *out_text = NULL;
  if (out_filename != NULL) *out_filename = NULL;
  if (out_content_start != NULL) *out_content_start = NULL;
  if (out_content_len != NULL) *out_content_len = 0;
 
  if (body == NULL || body_len == 0 || content_type == NULL || field_name == NULL || field_name[0] == '\0') {
    return 0;
  }
 
  boundary = native_dynamic_multipart_boundary(content_type);
  if (boundary == NULL || boundary[0] == '\0') {
    free(boundary);
    return 0;
  }
 
  delimiter_len = strlen(boundary) + 2;
  delimiter = (char *)malloc(delimiter_len + 1);
  delimiter_crlf = (char *)malloc(delimiter_len + 3);
  delimiter_lf = (char *)malloc(delimiter_len + 2);
  if (delimiter == NULL || delimiter_crlf == NULL || delimiter_lf == NULL) {
    free(boundary); free(delimiter); free(delimiter_crlf); free(delimiter_lf);
    return 0;
  }
  snprintf(delimiter, delimiter_len + 1, "--%s", boundary);
  snprintf(delimiter_crlf, delimiter_len + 3, "\r\n--%s", boundary);
  snprintf(delimiter_lf, delimiter_len + 2, "\n--%s", boundary);
 
  cursor = multipart_memmem(body, body_len, (const unsigned char *)delimiter, delimiter_len);
  while (cursor != NULL && (size_t)(cursor - body) + delimiter_len <= body_len) {
    const unsigned char *part_cursor = cursor + delimiter_len;
    const unsigned char *header_end = NULL;
    const unsigned char *content_start = NULL;
    const unsigned char *next_marker = NULL;
    size_t header_sep_len = 0;
    size_t headers_len = 0;
    size_t content_len = 0;
    char *headers_text = NULL;
    char *part_name = NULL;
    char *filename = NULL;
 
    /* Check for closing delimiter (--) */
    if ((size_t)(part_cursor - body) + 2 <= body_len && part_cursor[0] == '-' && part_cursor[1] == '-') {
      break;
    }
 
    /* Skip CRLF or LF after delimiter */
    if ((size_t)(part_cursor - body) + 2 <= body_len && part_cursor[0] == '\r' && part_cursor[1] == '\n') {
      part_cursor += 2;
    } else if ((size_t)(part_cursor - body) + 1 <= body_len && part_cursor[0] == '\n') {
      part_cursor += 1;
    }
 
    /* Find header/body separator */
    {
      const unsigned char *next_crlf = multipart_memmem(part_cursor, body_len - (size_t)(part_cursor - body), (const unsigned char *)"\r\n\r\n", 4);
      const unsigned char *next_lf = multipart_memmem(part_cursor, body_len - (size_t)(part_cursor - body), (const unsigned char *)"\n\n", 2);
      if (next_crlf != NULL && (next_lf == NULL || next_crlf <= next_lf)) {
        header_end = next_crlf;
        header_sep_len = 4;
      } else if (next_lf != NULL) {
        header_end = next_lf;
        header_sep_len = 2;
      } else {
        break;
      }
    }
 
    headers_len = (size_t)(header_end - part_cursor);
    headers_text = multipart_dup_range((const char *)part_cursor, headers_len);
    part_name = multipart_header_param_dup(headers_text, "name");
    filename = multipart_header_param_dup(headers_text, "filename");
    content_start = header_end + header_sep_len;
 
    /* Find the next delimiter to bound this part's content */
    {
      const unsigned char *next_crlf = multipart_memmem(content_start, body_len - (size_t)(content_start - body), (const unsigned char *)delimiter_crlf, delimiter_len + 2);
      const unsigned char *next_lf = multipart_memmem(content_start, body_len - (size_t)(content_start - body), (const unsigned char *)delimiter_lf, delimiter_len + 1);
      if (next_crlf != NULL && (next_lf == NULL || next_crlf <= next_lf)) {
        next_marker = next_crlf;
      } else if (next_lf != NULL) {
        next_marker = next_lf;
      } else {
        next_marker = body + body_len;
      }
    }
 
    content_len = (size_t)(next_marker - content_start);
 
    if (part_name != NULL && strcmp(part_name, field_name) == 0) {
      if (out_text != NULL) {
        *out_text = multipart_dup_range((const char *)content_start, content_len);
      }
      if (out_filename != NULL && filename != NULL) {
        *out_filename = strdup(filename);
      }
      if (out_content_start != NULL) {
        *out_content_start = content_start;
      }
      if (out_content_len != NULL) {
        *out_content_len = content_len;
      }
      found = 1;
      free(headers_text);
      free(part_name);
      free(filename);
      break;
    }
 
    free(headers_text);
    free(part_name);
    free(filename);
 
    if (next_marker >= body + body_len) {
      break;
    }
    cursor = next_marker + (next_marker[0] == '\r' ? 2 : 1);
    cursor = multipart_memmem(cursor, body_len - (size_t)(cursor - body), (const unsigned char *)delimiter, delimiter_len);
  }
 
  free(boundary);
  free(delimiter);
  free(delimiter_crlf);
  free(delimiter_lf);
  return found;
}
 
char *native_dynamic_multipart_filename(
  const unsigned char *body,
  size_t body_len,
  const char *content_type,
  const char *field_name
) {
  char *filename = NULL;
  native_dynamic_multipart_find_part(body, body_len, content_type, field_name, NULL, &filename, NULL, NULL);
  return filename;
}
 
char *native_dynamic_multipart_extract_text(
  const unsigned char *body,
  size_t body_len,
  const char *content_type,
  const char *field_name
) {
  char *text = NULL;
  native_dynamic_multipart_find_part(body, body_len, content_type, field_name, &text, NULL, NULL, NULL);
  return text;
}
 
int native_dynamic_multipart_extract_file(
  const unsigned char *body,
  size_t body_len,
  const char *content_type,
  const char *field_name,
  const char *output_path
) {
  const unsigned char *content_start = NULL;
  size_t content_len = 0;
  FILE *fp = NULL;
  size_t written;
 
  if (output_path == NULL || output_path[0] == '\0') {
    return 64;
  }
 
  if (!native_dynamic_multipart_find_part(body, body_len, content_type, field_name, NULL, NULL, &content_start, &content_len)) {
    return 1;
  }
 
  if (content_start == NULL || content_len == 0) {
    return 1;
  }
 
  fp = fopen(output_path, "wb");
  if (fp == NULL) {
    return 73;
  }
 
  written = fwrite(content_start, 1, content_len, fp);
  fclose(fp);
  return written == content_len ? 0 : 74;
}