// Written by retoor@molodetz.nl
// Improved version with better reliability and chunked content support
// MIT License
#ifndef R_HTTP_H
#define R_HTTP_H
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <json-c/json.h>
#include <stdbool.h>
#include "url.h"
#define INITIAL_BUFFER_SIZE (1024 * 1024)
#define MAX_HEADER_SIZE (8 * 1024)
void init_openssl() {
SSL_load_error_strings();
OpenSSL_add_ssl_algorithms();
}
void cleanup_openssl() {
EVP_cleanup();
}
SSL_CTX *create_context() {
const SSL_METHOD *method = TLS_client_method();
SSL_CTX *ctx = SSL_CTX_new(method);
if (!ctx) {
perror("Unable to create SSL context");
ERR_print_errors_fp(stderr);
return NULL;
}
SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
SSL_CTX_load_verify_locations(ctx, "/etc/ssl/certs/ca-certificates.crt", NULL);
return ctx;
}
int create_socket(const char *hostname, int port) {
struct hostent *host;
struct sockaddr_in addr;
host = gethostbyname(hostname);
if (!host) {
perror("Unable to resolve host");
return -1;
}
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("Unable to create socket");
return -1;
}
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = *(long *)(host->h_addr);
if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) != 0) {
perror("Unable to connect to host");
close(sock);
return -1;
}
return sock;
}
char *read_until_ssl(SSL *ssl, const char *until, size_t max_size) {
char *data = (char *)malloc(max_size);
if (!data) return NULL;
size_t index = 0;
size_t until_len = strlen(until);
while (index < max_size - 1) {
char c;
int bytes = SSL_read(ssl, &c, 1);
if (bytes <= 0) {
free(data);
return NULL;
}
data[index++] = c;
data[index] = '\0';
if (index >= until_len &&
memcmp(data + index - until_len, until, until_len) == 0) {
return data;
}
}
free(data);
return NULL;
}
char *read_until(int sock, const char *until, size_t max_size) {
char *data = (char *)malloc(max_size);
if (!data) return NULL;
size_t index = 0;
size_t until_len = strlen(until);
while (index < max_size - 1) {
char c;
ssize_t bytes = recv(sock, &c, 1, 0);
if (bytes <= 0) {
free(data);
return NULL;
}
data[index++] = c;
data[index] = '\0';
if (index >= until_len &&
memcmp(data + index - until_len, until, until_len) == 0) {
return data;
}
}
free(data);
return NULL;
}
size_t hex_to_int(const char *hex) {
size_t result = 0;
while (*hex && *hex != '\r' && *hex != '\n') {
char c = *hex++;
if (c >= '0' && c <= '9') {
result = result * 16 + (c - '0');
} else if (c >= 'a' && c <= 'f') {
result = result * 16 + (c - 'a' + 10);
} else if (c >= 'A' && c <= 'F') {
result = result * 16 + (c - 'A' + 10);
}
}
return result;
}
bool http_has_header(const char *http_headers, const char *http_header_name) {
char search_for[strlen(http_header_name) + 3];
snprintf(search_for, sizeof(search_for), "%s: ", http_header_name);
return strstr(http_headers, search_for) != NULL;
}
char *http_header_get_str(const char *http_headers, const char *http_header_name) {
char search_for[strlen(http_header_name) + 3];
snprintf(search_for, sizeof(search_for), "%s: ", http_header_name);
const char *header = strstr(http_headers, search_for);
if (!header) return NULL;
header += strlen(search_for);
const char *end = strstr(header, "\r\n");
if (!end) return NULL;
size_t value_len = end - header;
char *result = (char *)malloc(value_len + 1);
if (!result) return NULL;
memcpy(result, header, value_len);
result[value_len] = '\0';
return result;
}
long http_header_get_long(const char *http_headers, const char *http_header_name) {
char *str_value = http_header_get_str(http_headers, http_header_name);
if (!str_value) return 0;
long long_value = atol(str_value);
free(str_value);
return long_value;
}
static char *read_chunked_body_ssl(SSL *ssl) {
size_t total_size = 0;
size_t buffer_capacity = INITIAL_BUFFER_SIZE;
char *buffer = (char *)malloc(buffer_capacity);
if (!buffer) return NULL;
while (1) {
// Read chunk size line
char *chunk_header = read_until_ssl(ssl, "\r\n", 256);
if (!chunk_header) {
free(buffer);
return NULL;
}
size_t chunk_size = hex_to_int(chunk_header);
free(chunk_header);
if (chunk_size == 0) {
// Read trailing \r\n after last chunk
char trailing[3];
SSL_read(ssl, trailing, 2);
break;
}
// Resize buffer if needed
if (total_size + chunk_size + 1 > buffer_capacity) {
buffer_capacity = total_size + chunk_size + INITIAL_BUFFER_SIZE;
char *new_buffer = (char *)realloc(buffer, buffer_capacity);
if (!new_buffer) {
free(buffer);
return NULL;
}
buffer = new_buffer;
}
// Read chunk data
size_t bytes_read = 0;
while (bytes_read < chunk_size) {
int n = SSL_read(ssl, buffer + total_size + bytes_read,
chunk_size - bytes_read);
if (n <= 0) {
free(buffer);
return NULL;
}
bytes_read += n;
}
total_size += chunk_size;
// Read trailing \r\n after chunk data
char trailing[3];
SSL_read(ssl, trailing, 2);
}
buffer[total_size] = '\0';
return buffer;
}
static char *read_chunked_body(int sock) {
size_t total_size = 0;
size_t buffer_capacity = INITIAL_BUFFER_SIZE;
char *buffer = (char *)malloc(buffer_capacity);
if (!buffer) return NULL;
while (1) {
// Read chunk size line
char *chunk_header = read_until(sock, "\r\n", 256);
if (!chunk_header) {
free(buffer);
return NULL;
}
size_t chunk_size = hex_to_int(chunk_header);
free(chunk_header);
if (chunk_size == 0) {
// Read trailing \r\n after last chunk
char trailing[3];
recv(sock, trailing, 2, 0);
break;
}
// Resize buffer if needed
if (total_size + chunk_size + 1 > buffer_capacity) {
buffer_capacity = total_size + chunk_size + INITIAL_BUFFER_SIZE;
char *new_buffer = (char *)realloc(buffer, buffer_capacity);
if (!new_buffer) {
free(buffer);
return NULL;
}
buffer = new_buffer;
}
// Read chunk data
size_t bytes_read = 0;
while (bytes_read < chunk_size) {
ssize_t n = recv(sock, buffer + total_size + bytes_read,
chunk_size - bytes_read, 0);
if (n <= 0) {
free(buffer);
return NULL;
}
bytes_read += n;
}
total_size += chunk_size;
// Read trailing \r\n after chunk data
char trailing[3];
recv(sock, trailing, 2, 0);
}
buffer[total_size] = '\0';
return buffer;
}
char *https_post(char *url, char *data) {
url_t parsed_url;
parse_url(url, &parsed_url);
init_openssl();
SSL_CTX *ctx = create_context();
if (!ctx) return NULL;
int sock = create_socket(parsed_url.hostname, 443);
if (sock < 0) {
SSL_CTX_free(ctx);
cleanup_openssl();
return NULL;
}
SSL *ssl = SSL_new(ctx);
SSL_set_connect_state(ssl);
SSL_set_tlsext_host_name(ssl, parsed_url.hostname);
SSL_set_fd(ssl, sock);
char *result = NULL;
if (SSL_connect(ssl) <= 0) {
ERR_print_errors_fp(stderr);
} else {
size_t data_len = strlen(data);
size_t request_size = data_len + 1024;
char *request = (char *)malloc(request_size);
snprintf(request, request_size,
"POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: %zu\r\n"
"Content-Type: application/json\r\n"
"Connection: close\r\n"
"\r\n"
"%s",
parsed_url.path, parsed_url.hostname, data_len,
data);
SSL_write(ssl, request, strlen(request));
free(request);
char *headers = read_until_ssl(ssl, "\r\n\r\n", MAX_HEADER_SIZE);
if (headers) {
long content_length = http_header_get_long(headers, "Content-Length");
if (content_length > 0) {
result = (char *)malloc(content_length + 1);
if (result) {
size_t bytes_read = 0;
while (bytes_read < (size_t)content_length) {
int n = SSL_read(ssl, result + bytes_read,
content_length - bytes_read);
if (n <= 0) {
free(result);
result = NULL;
break;
}
bytes_read += n;
}
if (result) {
result[content_length] = '\0';
}
}
} else if (http_has_header(headers, "Transfer-Encoding")) {
result = read_chunked_body_ssl(ssl);
}
free(headers);
}
}
SSL_free(ssl);
close(sock);
SSL_CTX_free(ctx);
cleanup_openssl();
return result;
}
char *https_get(char *url) {
url_t parsed_url;
parse_url(url, &parsed_url);
init_openssl();
SSL_CTX *ctx = create_context();
if (!ctx) return NULL;
int sock = create_socket(parsed_url.hostname, 443);
if (sock < 0) {
SSL_CTX_free(ctx);
cleanup_openssl();
return NULL;
}
SSL *ssl = SSL_new(ctx);
SSL_set_connect_state(ssl);
SSL_set_tlsext_host_name(ssl, parsed_url.hostname);
SSL_set_fd(ssl, sock);
char *result = NULL;
if (SSL_connect(ssl) <= 0) {
ERR_print_errors_fp(stderr);
} else {
char request[2048];
snprintf(request, sizeof(request),
"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Connection: close\r\n"
"\r\n",
parsed_url.path, parsed_url.hostname);
SSL_write(ssl, request, strlen(request));
char *headers = read_until_ssl(ssl, "\r\n\r\n", MAX_HEADER_SIZE);
if (headers) {
long content_length = http_header_get_long(headers, "Content-Length");
if (content_length > 0) {
result = (char *)malloc(content_length + 1);
if (result) {
size_t bytes_read = 0;
while (bytes_read < (size_t)content_length) {
int n = SSL_read(ssl, result + bytes_read,
content_length - bytes_read);
if (n <= 0) {
free(result);
result = NULL;
break;
}
bytes_read += n;
}
if (result) {
result[content_length] = '\0';
}
}
} else if (http_has_header(headers, "Transfer-Encoding")) {
result = read_chunked_body_ssl(ssl);
}
free(headers);
}
}
SSL_free(ssl);
close(sock);
SSL_CTX_free(ctx);
cleanup_openssl();
return result;
}
char *http_post(char *url, char *data) {
url_t parsed_url;
parse_url(url, &parsed_url);
int port = parsed_url.port ? atoi(parsed_url.port) : 80;
int sock = create_socket(parsed_url.hostname, port);
if (sock < 0) return NULL;
char *result = NULL;
size_t data_len = strlen(data);
size_t request_size = data_len + 1024;
char *request = (char *)malloc(request_size);
snprintf(request, request_size,
"POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: %zu\r\n"
"Content-Type: application/json\r\n"
"Connection: close\r\n"
"\r\n"
"%s",
parsed_url.path, parsed_url.hostname, data_len,
data);
send(sock, request, strlen(request), 0);
free(request);
char *headers = read_until(sock, "\r\n\r\n", MAX_HEADER_SIZE);
if (headers) {
long content_length = http_header_get_long(headers, "Content-Length");
if (content_length > 0) {
result = (char *)malloc(content_length + 1);
if (result) {
size_t bytes_read = 0;
while (bytes_read < (size_t)content_length) {
ssize_t n = recv(sock, result + bytes_read,
content_length - bytes_read, 0);
if (n <= 0) {
free(result);
result = NULL;
break;
}
bytes_read += n;
}
if (result) {
result[content_length] = '\0';
}
}
} else if (http_has_header(headers, "Transfer-Encoding")) {
result = read_chunked_body(sock);
}
free(headers);
}
close(sock);
return result;
}
char *http_get(char *url) {
url_t parsed_url;
parse_url(url, &parsed_url);
int port = parsed_url.port ? atoi(parsed_url.port) : 80;
int sock = create_socket(parsed_url.hostname, port);
if (sock < 0) return NULL;
char *result = NULL;
char request[2048];
snprintf(request, sizeof(request),
"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Connection: close\r\n"
"\r\n",
parsed_url.path, parsed_url.hostname);
send(sock, request, strlen(request), 0);
char *headers = read_until(sock, "\r\n\r\n", MAX_HEADER_SIZE);
if (headers) {
long content_length = http_header_get_long(headers, "Content-Length");
if (content_length > 0) {
result = (char *)malloc(content_length + 1);
if (result) {
size_t bytes_read = 0;
while (bytes_read < (size_t)content_length) {
ssize_t n = recv(sock, result + bytes_read,
content_length - bytes_read, 0);
if (n <= 0) {
free(result);
result = NULL;
break;
}
bytes_read += n;
}
if (result) {
result[content_length] = '\0';
}
}
} else if (http_has_header(headers, "Transfer-Encoding")) {
result = read_chunked_body(sock);
}
free(headers);
}
close(sock);
return result;
}
#endif
Reference in New Issue View Git Blame Copy Permalink