// retoor <retoor@molodetz.nl>
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <math.h>
#include <unistd.h>
#include <locale.h>
#include <poll.h>
#include <errno.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <signal.h>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <stdbool.h>
#include <ctype.h>
#define STYLE_RESET "\033[0m"
#define STYLE_BOLD "\033[1m"
#define STYLE_RED "\033[31m"
#define STYLE_GREEN "\033[32m"
#define STYLE_YELLOW "\033[33m"
#define STYLE_CYAN "\033[36m"
#define MAX_HEADER_SIZE (16 * 1024)
#define INITIAL_BUFFER_SIZE (64 * 1024)
#define MAX_BUFFER_SIZE (16 * 1024 * 1024)
#define REQUEST_TIMEOUT_MS 30000
#define URL_SCHEME_MAX 16
#define URL_HOSTNAME_MAX 256
#define URL_PATH_MAX 2048
typedef struct {
char scheme[URL_SCHEME_MAX];
char hostname[URL_HOSTNAME_MAX];
int port;
char path[URL_PATH_MAX];
} url_t;
typedef struct {
long status;
double duration_ms;
size_t body_size_bytes;
size_t header_size_bytes;
char server_software[128];
int failed;
char error[256];
} RequestResult;
typedef struct {
int sock;
SSL *ssl;
SSL_CTX *ctx;
bool is_https;
bool in_use;
bool chunked;
bool chunked_done;
size_t chunk_remaining;
int request_index;
char *send_buffer;
size_t send_offset;
size_t send_total;
char *recv_buffer;
size_t recv_offset;
size_t recv_capacity;
bool headers_complete;
long content_length;
struct timespec start_time;
} Connection;
static volatile sig_atomic_t g_shutdown_requested = 0;
static long total_connections_made = 0;
static Connection *connection_pool = NULL;
static int pool_size = 0;
static bool ssl_initialized = false;
static void signal_handler(int sig) {
(void)sig;
g_shutdown_requested = 1;
}
static void setup_signal_handlers(void) {
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = signal_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
signal(SIGPIPE, SIG_IGN);
}
static int parse_url(const char *url_str, url_t *url) {
if (!url_str || !url) {
return -1;
}
memset(url, 0, sizeof(url_t));
const char *p = strstr(url_str, "://");
if (p) {
size_t scheme_len = (size_t)(p - url_str);
if (scheme_len >= URL_SCHEME_MAX) {
return -1;
}
memcpy(url->scheme, url_str, scheme_len);
url->scheme[scheme_len] = '\0';
url_str = p + 3;
} else {
strncpy(url->scheme, "http", URL_SCHEME_MAX - 1);
url->scheme[URL_SCHEME_MAX - 1] = '\0';
}
p = strchr(url_str, '/');
char host_port[URL_HOSTNAME_MAX + 8];
if (p) {
size_t hp_len = (size_t)(p - url_str);
if (hp_len >= sizeof(host_port)) {
return -1;
}
memcpy(host_port, url_str, hp_len);
host_port[hp_len] = '\0';
size_t path_len = strlen(p);
if (path_len >= URL_PATH_MAX) {
return -1;
}
strncpy(url->path, p, URL_PATH_MAX - 1);
url->path[URL_PATH_MAX - 1] = '\0';
} else {
size_t hp_len = strlen(url_str);
if (hp_len >= sizeof(host_port)) {
return -1;
}
strncpy(host_port, url_str, sizeof(host_port) - 1);
host_port[sizeof(host_port) - 1] = '\0';
strncpy(url->path, "/", URL_PATH_MAX - 1);
url->path[URL_PATH_MAX - 1] = '\0';
}
char *colon = strchr(host_port, ':');
if (colon) {
size_t host_len = (size_t)(colon - host_port);
if (host_len >= URL_HOSTNAME_MAX) {
return -1;
}
memcpy(url->hostname, host_port, host_len);
url->hostname[host_len] = '\0';
url->port = atoi(colon + 1);
if (url->port <= 0 || url->port > 65535) {
return -1;
}
} else {
if (strlen(host_port) >= URL_HOSTNAME_MAX) {
return -1;
}
strncpy(url->hostname, host_port, URL_HOSTNAME_MAX - 1);
url->hostname[URL_HOSTNAME_MAX - 1] = '\0';
url->port = (strcmp(url->scheme, "https") == 0) ? 443 : 80;
}
if (strlen(url->hostname) == 0) {
return -1;
}
return 0;
}
static void init_openssl(void) {
if (!ssl_initialized) {
#if OPENSSL_VERSION_NUMBER >= 0x10100000L
OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL);
#else
SSL_library_init();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
#endif
ssl_initialized = true;
}
}
static void cleanup_openssl(void) {
if (ssl_initialized) {
#if OPENSSL_VERSION_NUMBER < 0x10100000L
EVP_cleanup();
ERR_free_strings();
#endif
ssl_initialized = false;
}
}
static SSL_CTX *create_context(bool verify_peer) {
const SSL_METHOD *method = TLS_client_method();
SSL_CTX *ctx = SSL_CTX_new(method);
if (!ctx) {
return NULL;
}
if (verify_peer) {
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
SSL_CTX_set_default_verify_paths(ctx);
} else {
SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);
}
return ctx;
}
static int create_socket(const char *hostname, int port) {
struct addrinfo hints, *result, *rp;
int sock = -1;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
char port_str[8];
snprintf(port_str, sizeof(port_str), "%d", port);
int ret = getaddrinfo(hostname, port_str, &hints, &result);
if (ret != 0) {
return -1;
}
for (rp = result; rp != NULL; rp = rp->ai_next) {
sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (sock < 0) {
continue;
}
int flags = fcntl(sock, F_GETFL, 0);
if (flags < 0) {
close(sock);
sock = -1;
continue;
}
if (fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) {
close(sock);
sock = -1;
continue;
}
ret = connect(sock, rp->ai_addr, rp->ai_addrlen);
if (ret < 0 && errno != EINPROGRESS) {
close(sock);
sock = -1;
continue;
}
break;
}
freeaddrinfo(result);
if (sock >= 0) {
total_connections_made++;
}
return sock;
}
static void release_connection(Connection *conn, bool keep_alive, int *active_connections);
static Connection* get_or_create_connection(url_t *url, int *active_connections, int max_connections, bool keep_alive, bool verify_ssl) {
if (keep_alive) {
for (int i = 0; i < pool_size; i++) {
if (!connection_pool[i].in_use && connection_pool[i].sock >= 0) {
connection_pool[i].in_use = true;
return &connection_pool[i];
}
}
}
if (*active_connections >= max_connections) {
return NULL;
}
Connection *conn = NULL;
for (int i = 0; i < pool_size; i++) {
if (connection_pool[i].sock < 0) {
conn = &connection_pool[i];
break;
}
}
if (!conn) {
int new_size = pool_size + 1;
Connection *new_pool = realloc(connection_pool, sizeof(Connection) * (size_t)new_size);
if (!new_pool) {
return NULL;
}
connection_pool = new_pool;
pool_size = new_size;
conn = &connection_pool[pool_size - 1];
}
memset(conn, 0, sizeof(Connection));
conn->sock = create_socket(url->hostname, url->port);
if (conn->sock < 0) {
conn->sock = -1;
return NULL;
}
conn->is_https = (strcmp(url->scheme, "https") == 0);
if (conn->is_https) {
init_openssl();
conn->ctx = create_context(verify_ssl);
if (!conn->ctx) {
close(conn->sock);
conn->sock = -1;
return NULL;
}
conn->ssl = SSL_new(conn->ctx);
if (!conn->ssl) {
SSL_CTX_free(conn->ctx);
conn->ctx = NULL;
close(conn->sock);
conn->sock = -1;
return NULL;
}
SSL_set_fd(conn->ssl, conn->sock);
SSL_set_connect_state(conn->ssl);
SSL_set_tlsext_host_name(conn->ssl, url->hostname);
}
conn->recv_buffer = malloc(INITIAL_BUFFER_SIZE);
if (!conn->recv_buffer) {
if (conn->ssl) {
SSL_free(conn->ssl);
conn->ssl = NULL;
}
if (conn->ctx) {
SSL_CTX_free(conn->ctx);
conn->ctx = NULL;
}
close(conn->sock);
conn->sock = -1;
return NULL;
}
conn->recv_capacity = INITIAL_BUFFER_SIZE;
conn->in_use = true;
conn->content_length = -1;
(*active_connections)++;
return conn;
}
static void release_connection(Connection *conn, bool keep_alive, int *active_connections) {
if (!conn) return;
if (keep_alive && conn->sock >= 0) {
conn->in_use = false;
conn->send_offset = 0;
conn->recv_offset = 0;
conn->headers_complete = false;
conn->content_length = -1;
conn->chunked = false;
conn->chunked_done = false;
conn->chunk_remaining = 0;
if (conn->send_buffer) {
free(conn->send_buffer);
conn->send_buffer = NULL;
}
} else {
if (conn->ssl) {
SSL_shutdown(conn->ssl);
SSL_free(conn->ssl);
conn->ssl = NULL;
}
if (conn->ctx) {
SSL_CTX_free(conn->ctx);
conn->ctx = NULL;
}
if (conn->sock >= 0) {
close(conn->sock);
conn->sock = -1;
}
if (conn->send_buffer) {
free(conn->send_buffer);
conn->send_buffer = NULL;
}
if (conn->recv_buffer) {
free(conn->recv_buffer);
conn->recv_buffer = NULL;
}
conn->recv_capacity = 0;
(*active_connections)--;
}
}
static long parse_status_code(const char *headers) {
const char *space = strchr(headers, ' ');
if (!space) return 0;
return atol(space + 1);
}
static char* get_header_value(const char *headers, const char *name) {
size_t name_len = strlen(name);
const char *p = headers;
while ((p = strchr(p, '\n')) != NULL) {
p++;
if (strncasecmp(p, name, name_len) == 0 && p[name_len] == ':') {
const char *value_start = p + name_len + 1;
while (*value_start == ' ' || *value_start == '\t') {
value_start++;
}
const char *value_end = strstr(value_start, "\r\n");
if (!value_end) {
value_end = value_start + strlen(value_start);
}
size_t len = (size_t)(value_end - value_start);
char *value = malloc(len + 1);
if (!value) {
return NULL;
}
memcpy(value, value_start, len);
value[len] = '\0';
return value;
}
}
return NULL;
}
static bool is_chunked_encoding(const char *headers) {
char *te = get_header_value(headers, "Transfer-Encoding");
if (!te) {
return false;
}
bool chunked = (strcasestr(te, "chunked") != NULL);
free(te);
return chunked;
}
static size_t parse_chunk_size(const char *data, size_t *chunk_header_len) {
const char *end = strstr(data, "\r\n");
if (!end) {
*chunk_header_len = 0;
return 0;
}
*chunk_header_len = (size_t)(end - data) + 2;
char hex[20];
size_t hex_len = (size_t)(end - data);
if (hex_len >= sizeof(hex)) {
hex_len = sizeof(hex) - 1;
}
memcpy(hex, data, hex_len);
hex[hex_len] = '\0';
char *semicolon = strchr(hex, ';');
if (semicolon) {
*semicolon = '\0';
}
return (size_t)strtoul(hex, NULL, 16);
}
static const char* format_bytes(long long bytes) {
static char buffer[4][128];
static int idx = 0;
idx = (idx + 1) % 4;
const char *units[] = {"bytes", "KB", "MB", "GB", "TB"};
double value = (double)bytes;
int i = 0;
if (bytes < 1024) {
snprintf(buffer[idx], sizeof(buffer[idx]), "%lld bytes", bytes);
return buffer[idx];
}
while (value >= 1024.0 && i < 4) {
value /= 1024.0;
i++;
}
snprintf(buffer[idx], sizeof(buffer[idx]), "%.2f %s", value, units[i]);
return buffer[idx];
}
static int compare_doubles(const void *a, const void *b) {
double da = *(const double *)a;
double db = *(const double *)b;
if (da < db) return -1;
if (da > db) return 1;
return 0;
}
static double get_mean(const double data[], int n) {
if (n <= 0) return 0.0;
double sum = 0.0;
for (int i = 0; i < n; ++i) sum += data[i];
return sum / n;
}
static double get_stdev(const double data[], int n) {
if (n < 2) return 0.0;
double mean = get_mean(data, n);
double sum_sq_diff = 0.0;
for (int i = 0; i < n; ++i) {
sum_sq_diff += (data[i] - mean) * (data[i] - mean);
}
return sqrt(sum_sq_diff / (n - 1));
}
static void print_summary(RequestResult results[], int total_requests, double total_duration_s, const char *url, int concurrency, long total_connections) {
double *request_durations_ms = malloc(sizeof(double) * (size_t)total_requests);
if (!request_durations_ms) {
fprintf(stderr, "Failed to allocate memory for statistics\n");
return;
}
int success_count = 0;
long long total_html_transferred = 0;
long long total_transferred = 0;
for (int i = 0; i < total_requests; ++i) {
if (!results[i].failed) {
request_durations_ms[success_count++] = results[i].duration_ms;
total_html_transferred += (long long)results[i].body_size_bytes;
total_transferred += (long long)(results[i].body_size_bytes + results[i].header_size_bytes);
}
}
int failed_count = total_requests - success_count;
if (success_count == 0) {
printf("%sAll requests failed. Cannot generate a detailed summary.%s\n", STYLE_RED, STYLE_RESET);
printf("Total time: %.3f seconds\n", total_duration_s);
printf("Failed requests: %d\n", failed_count);
if (total_requests > 0 && results[0].error[0] != '\0') {
printf("Sample error: %s\n", results[0].error);
}
free(request_durations_ms);
return;
}
url_t parsed_url;
if (parse_url(url, &parsed_url) != 0) {
strncpy(parsed_url.hostname, "unknown", URL_HOSTNAME_MAX - 1);
parsed_url.port = 0;
strncpy(parsed_url.path, "/", URL_PATH_MAX - 1);
}
RequestResult first_result = {0};
for (int i = 0; i < total_requests; ++i) {
if (!results[i].failed) {
first_result = results[i];
break;
}
}
double req_per_second = (double)total_requests / total_duration_s;
double time_per_req_concurrent = (total_duration_s * 1000) / total_requests;
double time_per_req_mean = (total_duration_s * 1000 * concurrency) / total_requests;
double transfer_rate_kbytes_s = (total_transferred / 1024.0) / total_duration_s;
qsort(request_durations_ms, (size_t)success_count, sizeof(double), compare_doubles);
double min_time = request_durations_ms[0];
double mean_time = get_mean(request_durations_ms, success_count);
double stdev_time = get_stdev(request_durations_ms, success_count);
double median_time = success_count % 2 ? request_durations_ms[success_count / 2] : (request_durations_ms[success_count / 2 - 1] + request_durations_ms[success_count / 2]) / 2.0;
double max_time = request_durations_ms[success_count - 1];
int percentile_points[] = {50, 66, 75, 80, 90, 95, 98, 99, 100};
double percentile_values[9];
for (int i = 0; i < 8; ++i) {
int index = (int)(success_count * percentile_points[i] / 100.0) - 1;
if (index < 0) index = 0;
percentile_values[i] = request_durations_ms[index];
}
percentile_values[8] = max_time;
const char *fail_color = (failed_count == 0) ? STYLE_GREEN : STYLE_RED;
printf("%sServer Software:%s %s\n", STYLE_YELLOW, STYLE_RESET, strlen(first_result.server_software) > 0 ? first_result.server_software : "N/A");
printf("%sServer Hostname:%s %s\n", STYLE_YELLOW, STYLE_RESET, parsed_url.hostname);
printf("%sServer Port:%s %d\n\n", STYLE_YELLOW, STYLE_RESET, parsed_url.port);
printf("%sDocument Path:%s %s\n", STYLE_YELLOW, STYLE_RESET, parsed_url.path);
printf("%sDocument Length:%s %s\n\n", STYLE_YELLOW, STYLE_RESET, format_bytes((long long)first_result.body_size_bytes));
printf("%sConcurrency Level:%s %d\n", STYLE_YELLOW, STYLE_RESET, concurrency);
printf("%sTime taken for tests:%s %.3f seconds\n", STYLE_YELLOW, STYLE_RESET, total_duration_s);
printf("%sComplete requests:%s %d\n", STYLE_YELLOW, STYLE_RESET, total_requests);
printf("%sFailed requests:%s %s%d%s\n", STYLE_YELLOW, STYLE_RESET, fail_color, failed_count, STYLE_RESET);
printf("%sTotal connections made:%s %ld\n", STYLE_YELLOW, STYLE_RESET, total_connections);
printf("%sTotal transferred:%s %s\n", STYLE_YELLOW, STYLE_RESET, format_bytes(total_transferred));
printf("%sHTML transferred:%s %s\n", STYLE_YELLOW, STYLE_RESET, format_bytes(total_html_transferred));
printf("%sRequests per second:%s %s%.2f%s [#/sec] (mean)\n", STYLE_YELLOW, STYLE_RESET, STYLE_GREEN, req_per_second, STYLE_RESET);
printf("%sTime per request:%s %.3f [ms] (mean)\n", STYLE_YELLOW, STYLE_RESET, time_per_req_mean);
printf("%sTime per request:%s %.3f [ms] (mean, across all concurrent requests)\n", STYLE_YELLOW, STYLE_RESET, time_per_req_concurrent);
printf("%sTransfer rate:%s %s%.2f%s [Kbytes/sec] received\n\n", STYLE_YELLOW, STYLE_RESET, STYLE_GREEN, transfer_rate_kbytes_s, STYLE_RESET);
printf("%s%sConnection Times (ms)%s\n", STYLE_CYAN, STYLE_BOLD, STYLE_RESET);
printf("%s---------------------%s\n", STYLE_CYAN, STYLE_RESET);
printf("%-10s%8.0f\n", "min:", min_time);
printf("%-10s%8.0f\n", "mean:", mean_time);
printf("%-10s%8.1f\n", "sd:", stdev_time);
printf("%-10s%8.0f\n", "median:", median_time);
printf("%-10s%8.0f\n\n", "max:", max_time);
printf("%s%sPercentage of the requests served within a certain time (ms)%s\n", STYLE_CYAN, STYLE_BOLD, STYLE_RESET);
for (int i = 0; i < 9; ++i) {
printf(" %s%3d%%%s %.0f\n", STYLE_GREEN, percentile_points[i], STYLE_RESET, percentile_values[i]);
}
free(request_durations_ms);
}
static double get_elapsed_ms(struct timespec *start) {
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
return ((now.tv_sec - start->tv_sec) * 1000.0) + ((now.tv_nsec - start->tv_nsec) / 1000000.0);
}
static void print_usage(const char *prog) {
fprintf(stderr, "Usage: %s -n <requests> -c <concurrency> [-k] [-i] <url>\n", prog);
fprintf(stderr, " -n Total number of requests to perform\n");
fprintf(stderr, " -c Number of concurrent connections\n");
fprintf(stderr, " -k Use HTTP Keep-Alive\n");
fprintf(stderr, " -i Insecure mode (skip SSL certificate verification)\n");
}
int main(int argc, char *argv[]) {
setlocale(LC_ALL, "");
setup_signal_handlers();
int total_requests = 0;
int concurrency = 0;
int keep_alive = 0;
int insecure = 0;
char *url = NULL;
int opt;
while ((opt = getopt(argc, argv, "n:c:ki")) != -1) {
switch (opt) {
case 'n': {
char *endptr;
long val = strtol(optarg, &endptr, 10);
if (*endptr != '\0' || val <= 0 || val > INT_MAX) {
fprintf(stderr, "Error: Invalid value for -n: %s\n", optarg);
return 1;
}
total_requests = (int)val;
break;
}
case 'c': {
char *endptr;
long val = strtol(optarg, &endptr, 10);
if (*endptr != '\0' || val <= 0 || val > 10000) {
fprintf(stderr, "Error: Invalid value for -c: %s (max 10000)\n", optarg);
return 1;
}
concurrency = (int)val;
break;
}
case 'k':
keep_alive = 1;
break;
case 'i':
insecure = 1;
break;
default:
print_usage(argv[0]);
return 1;
}
}
if (optind < argc) {
url = argv[optind];
}
if (total_requests <= 0 || concurrency <= 0 || url == NULL) {
print_usage(argv[0]);
return 1;
}
if (total_requests < concurrency) {
fprintf(stderr, "Error: Number of requests (-n) cannot be less than the concurrency level (-c).\n");
return 1;
}
url_t parsed_url;
if (parse_url(url, &parsed_url) != 0) {
fprintf(stderr, "Error: Failed to parse URL: %s\n", url);
return 1;
}
printf("abr, a C-based HTTP benchmark inspired by ApacheBench.\n");
printf("Benchmarking %s (be patient)...\n", parsed_url.hostname);
if (insecure && strcmp(parsed_url.scheme, "https") == 0) {
printf("%sWarning: SSL certificate verification disabled%s\n", STYLE_YELLOW, STYLE_RESET);
}
RequestResult *results = calloc((size_t)total_requests, sizeof(RequestResult));
if (!results) {
fprintf(stderr, "Error: Failed to allocate memory for results\n");
return 1;
}
int requests_initiated = 0;
int requests_completed = 0;
int active_connections = 0;
struct timespec benchmark_start_time, current_time;
clock_gettime(CLOCK_MONOTONIC, &benchmark_start_time);
connection_pool = calloc((size_t)concurrency, sizeof(Connection));
if (!connection_pool) {
fprintf(stderr, "Error: Failed to allocate connection pool\n");
free(results);
return 1;
}
pool_size = concurrency;
for (int i = 0; i < concurrency; i++) {
connection_pool[i].sock = -1;
}
struct pollfd *poll_fds = malloc(sizeof(struct pollfd) * (size_t)concurrency);
int *poll_conn_map = malloc(sizeof(int) * (size_t)concurrency);
if (!poll_fds || !poll_conn_map) {
fprintf(stderr, "Error: Failed to allocate poll structures\n");
free(poll_fds);
free(poll_conn_map);
free(connection_pool);
free(results);
return 1;
}
while (requests_completed < total_requests && !g_shutdown_requested) {
int nfds = 0;
while (requests_initiated < total_requests && active_connections < concurrency && !g_shutdown_requested) {
Connection *conn = get_or_create_connection(&parsed_url, &active_connections, concurrency, keep_alive, !insecure);
if (!conn) break;
conn->request_index = requests_initiated;
clock_gettime(CLOCK_MONOTONIC, &conn->start_time);
char request[4096];
int req_len = snprintf(request, sizeof(request),
"GET %s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-Agent: abr/1.0\r\n"
"Accept: */*\r\n"
"Connection: %s\r\n"
"\r\n",
parsed_url.path, parsed_url.hostname,
keep_alive ? "keep-alive" : "close");
if (req_len < 0 || req_len >= (int)sizeof(request)) {
snprintf(results[requests_initiated].error, sizeof(results[requests_initiated].error), "Request too large");
results[requests_initiated].failed = 1;
requests_completed++;
release_connection(conn, false, &active_connections);
requests_initiated++;
continue;
}
conn->send_buffer = malloc((size_t)req_len + 1);
if (!conn->send_buffer) {
snprintf(results[requests_initiated].error, sizeof(results[requests_initiated].error), "Memory allocation failed");
results[requests_initiated].failed = 1;
requests_completed++;
release_connection(conn, false, &active_connections);
requests_initiated++;
continue;
}
memcpy(conn->send_buffer, request, (size_t)req_len + 1);
conn->send_total = (size_t)req_len;
conn->send_offset = 0;
requests_initiated++;
}
for (int i = 0; i < pool_size; i++) {
Connection *conn = &connection_pool[i];
if (conn->sock >= 0 && conn->in_use) {
double elapsed = get_elapsed_ms(&conn->start_time);
if (elapsed > REQUEST_TIMEOUT_MS) {
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "Request timeout (%.0fms)", elapsed);
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = elapsed;
requests_completed++;
release_connection(conn, false, &active_connections);
continue;
}
poll_fds[nfds].fd = conn->sock;
poll_fds[nfds].events = POLLERR | POLLHUP;
if (conn->send_offset < conn->send_total) {
poll_fds[nfds].events |= POLLOUT;
} else {
poll_fds[nfds].events |= POLLIN;
}
poll_fds[nfds].revents = 0;
poll_conn_map[nfds] = i;
nfds++;
}
}
if (nfds == 0) {
usleep(1000);
continue;
}
int ready = poll(poll_fds, (nfds_t)nfds, 10);
if (ready < 0) {
if (errno == EINTR) continue;
break;
}
if (ready == 0) continue;
for (int p = 0; p < nfds; p++) {
if (poll_fds[p].revents == 0) continue;
int i = poll_conn_map[p];
Connection *conn = &connection_pool[i];
if (conn->sock < 0 || !conn->in_use) continue;
if (poll_fds[p].revents & (POLLERR | POLLNVAL)) {
int err = 0;
socklen_t errlen = sizeof(err);
getsockopt(conn->sock, SOL_SOCKET, SO_ERROR, &err, &errlen);
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "Connection error: %s", err ? strerror(err) : "Unknown error");
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
continue;
}
if ((poll_fds[p].revents & POLLOUT) && conn->send_offset < conn->send_total) {
ssize_t sent;
if (conn->is_https && conn->ssl) {
sent = SSL_write(conn->ssl, conn->send_buffer + conn->send_offset,
(int)(conn->send_total - conn->send_offset));
if (sent <= 0) {
int ssl_err = SSL_get_error(conn->ssl, (int)sent);
if (ssl_err != SSL_ERROR_WANT_READ && ssl_err != SSL_ERROR_WANT_WRITE) {
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "SSL write error");
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
}
continue;
}
} else {
sent = send(conn->sock, conn->send_buffer + conn->send_offset,
conn->send_total - conn->send_offset, MSG_NOSIGNAL);
if (sent <= 0) {
if (errno != EAGAIN && errno != EWOULDBLOCK) {
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "Send error: %s", strerror(errno));
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
}
continue;
}
}
if (sent > 0) {
conn->send_offset += (size_t)sent;
}
}
if (poll_fds[p].revents & POLLIN) {
if (conn->recv_offset >= conn->recv_capacity - 1) {
if (conn->recv_capacity >= MAX_BUFFER_SIZE) {
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "Response too large");
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
continue;
}
size_t new_capacity = conn->recv_capacity * 2;
if (new_capacity > MAX_BUFFER_SIZE) {
new_capacity = MAX_BUFFER_SIZE;
}
char *new_buffer = realloc(conn->recv_buffer, new_capacity);
if (!new_buffer) {
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "Memory allocation failed");
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
continue;
}
conn->recv_buffer = new_buffer;
conn->recv_capacity = new_capacity;
}
ssize_t received;
size_t space = conn->recv_capacity - conn->recv_offset - 1;
if (conn->is_https && conn->ssl) {
received = SSL_read(conn->ssl, conn->recv_buffer + conn->recv_offset, (int)space);
if (received <= 0) {
int ssl_err = SSL_get_error(conn->ssl, (int)received);
if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE) {
continue;
}
if (ssl_err == SSL_ERROR_ZERO_RETURN || received == 0) {
goto connection_closed;
}
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "SSL read error");
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
continue;
}
} else {
received = recv(conn->sock, conn->recv_buffer + conn->recv_offset, space, 0);
if (received <= 0) {
if (received < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
continue;
}
if (received == 0) {
goto connection_closed;
}
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "Recv error: %s", strerror(errno));
results[conn->request_index].failed = 1;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
continue;
}
}
conn->recv_offset += (size_t)received;
conn->recv_buffer[conn->recv_offset] = '\0';
if (!conn->headers_complete) {
char *header_end = strstr(conn->recv_buffer, "\r\n\r\n");
if (header_end) {
conn->headers_complete = true;
size_t header_size = (size_t)(header_end - conn->recv_buffer) + 4;
results[conn->request_index].header_size_bytes = header_size;
results[conn->request_index].status = parse_status_code(conn->recv_buffer);
char *server = get_header_value(conn->recv_buffer, "Server");
if (server) {
strncpy(results[conn->request_index].server_software, server, sizeof(results[conn->request_index].server_software) - 1);
results[conn->request_index].server_software[sizeof(results[conn->request_index].server_software) - 1] = '\0';
free(server);
}
conn->chunked = is_chunked_encoding(conn->recv_buffer);
if (!conn->chunked) {
char *content_length_str = get_header_value(conn->recv_buffer, "Content-Length");
if (content_length_str) {
conn->content_length = atol(content_length_str);
free(content_length_str);
} else {
conn->content_length = -1;
}
}
}
}
if (conn->headers_complete) {
char *header_end = strstr(conn->recv_buffer, "\r\n\r\n");
size_t header_size = (size_t)(header_end - conn->recv_buffer) + 4;
size_t body_received = conn->recv_offset - header_size;
bool complete = false;
size_t body_size = 0;
if (conn->chunked) {
char *body_start = header_end + 4;
size_t body_data_len = conn->recv_offset - header_size;
size_t pos = 0;
size_t decoded_size = 0;
while (pos < body_data_len && !conn->chunked_done) {
if (conn->chunk_remaining > 0) {
size_t available = body_data_len - pos;
size_t to_consume = (available < conn->chunk_remaining) ? available : conn->chunk_remaining;
decoded_size += to_consume;
pos += to_consume;
conn->chunk_remaining -= to_consume;
if (conn->chunk_remaining == 0) {
if (pos + 2 <= body_data_len && body_start[pos] == '\r' && body_start[pos + 1] == '\n') {
pos += 2;
} else if (pos + 2 > body_data_len) {
break;
}
}
} else {
size_t chunk_header_len;
size_t chunk_size = parse_chunk_size(body_start + pos, &chunk_header_len);
if (chunk_header_len == 0) {
break;
}
if (chunk_size == 0) {
conn->chunked_done = true;
complete = true;
body_size = decoded_size;
break;
}
pos += chunk_header_len;
conn->chunk_remaining = chunk_size;
}
}
if (!complete && conn->chunked_done) {
complete = true;
body_size = decoded_size;
}
} else if (conn->content_length >= 0) {
complete = (body_received >= (size_t)conn->content_length);
if (complete) {
body_size = (size_t)conn->content_length;
}
} else {
continue;
}
if (complete) {
results[conn->request_index].body_size_bytes = body_size;
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
results[conn->request_index].failed = (results[conn->request_index].status >= 400);
requests_completed++;
long long total_bytes_transferred = 0;
double total_duration_ms = 0;
int success_count = 0;
int failed_count = 0;
for (int j = 0; j < requests_completed; ++j) {
total_bytes_transferred += (long long)(results[j].body_size_bytes + results[j].header_size_bytes);
if (results[j].failed) {
failed_count++;
} else {
success_count++;
total_duration_ms += results[j].duration_ms;
}
}
clock_gettime(CLOCK_MONOTONIC, &current_time);
double elapsed_time = (current_time.tv_sec - benchmark_start_time.tv_sec) +
(current_time.tv_nsec - benchmark_start_time.tv_nsec) / 1e9;
double req_per_sec = elapsed_time > 0 ? requests_completed / elapsed_time : 0;
double avg_latency_ms = success_count > 0 ? total_duration_ms / success_count : 0;
double transfer_rate_kbs = elapsed_time > 0 ? (total_bytes_transferred / 1024.0) / elapsed_time : 0;
const char *fail_color = (failed_count == 0) ? STYLE_GREEN : STYLE_RED;
fprintf(stdout, "\r%sCompleted: %d/%d | Failed: %s%d%s%s | RPS: %s%.1f%s%s | Avg Latency: %.0fms | Rate: %.1f KB/s%s",
STYLE_BOLD, requests_completed, total_requests,
fail_color, failed_count, STYLE_RESET, STYLE_BOLD,
STYLE_GREEN, req_per_sec, STYLE_RESET, STYLE_BOLD,
avg_latency_ms, transfer_rate_kbs, STYLE_RESET);
fflush(stdout);
release_connection(conn, keep_alive, &active_connections);
}
}
continue;
connection_closed:
if (!conn->headers_complete) {
snprintf(results[conn->request_index].error, sizeof(results[conn->request_index].error), "Connection closed prematurely");
results[conn->request_index].failed = 1;
} else if (conn->content_length < 0 && !conn->chunked) {
char *header_end = strstr(conn->recv_buffer, "\r\n\r\n");
size_t header_size = (size_t)(header_end - conn->recv_buffer) + 4;
results[conn->request_index].body_size_bytes = conn->recv_offset - header_size;
results[conn->request_index].failed = (results[conn->request_index].status >= 400);
}
results[conn->request_index].duration_ms = get_elapsed_ms(&conn->start_time);
requests_completed++;
release_connection(conn, false, &active_connections);
}
}
}
if (g_shutdown_requested) {
printf("\n%sShutdown requested, cleaning up...%s\n", STYLE_YELLOW, STYLE_RESET);
}
struct timespec benchmark_end_time;
clock_gettime(CLOCK_MONOTONIC, &benchmark_end_time);
double total_duration = (benchmark_end_time.tv_sec - benchmark_start_time.tv_sec) +
(benchmark_end_time.tv_nsec - benchmark_start_time.tv_nsec) / 1e9;
fprintf(stdout, "\n\n");
printf("%s%sFinished %d requests%s\n\n", STYLE_GREEN, STYLE_BOLD, requests_completed, STYLE_RESET);
print_summary(results, requests_completed, total_duration, url, concurrency, total_connections_made);
for (int i = 0; i < pool_size; i++) {
if (connection_pool[i].sock >= 0) {
release_connection(&connection_pool[i], false, &active_connections);
}
}
free(poll_fds);
free(poll_conn_map);
free(connection_pool);
connection_pool = NULL;
pool_size = 0;
free(results);
cleanup_openssl();
return g_shutdown_requested ? 130 : 0;
}
Reference in New Issue View Git Blame Copy Permalink