cozis/cHTTP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace http_/HTTP_ prefixes with chttp_/CHTTP_

Browse Source
This commit is contained in:
cozis
2025-12-09 12:12:21 +01:00
parent db030b3834
commit 04deae62d6
25 changed files with 1703 additions and 1703 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/000_simple_client.c
+5 -5
View File
@@ -2,14 +2,14 @@
int main(void)
{
HTTP_Response *response;
CHTTP_Response *response;
int ret = http_get(HTTP_STR("http://coz.is/"), NULL, 0, &response);
if (ret == HTTP_OK) {
int ret = chttp_get(CHTTP_STR("http://coz.is/"), NULL, 0, &response);
if (ret == CHTTP_OK) {
printf("Received %d bytes\n", response->body.len);
http_free_response(response);
chttp_free_response(response);
} else {
printf("Request failure: %s\n", http_strerror(ret));
printf("Request failure: %s\n", chttp_strerror(ret));
}
return 0;
}
examples/001_simple_server.c
+14 -14
View File
@@ -4,33 +4,33 @@ int main(void)
{
int ret;
HTTP_Server server;
ret = http_server_init(&server);
CHTTP_Server server;
ret = chttp_server_init(&server);
if (ret < 0) {
fprintf(stderr, "Couldn't initialize server (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't initialize server (%s)\n", chttp_strerror(ret));
return -1;
}
http_server_set_reuse_addr(&server, true);
http_server_set_trace_bytes(&server, true);
chttp_server_set_reuse_addr(&server, true);
chttp_server_set_trace_bytes(&server, true);
ret = http_server_listen_tcp(&server, HTTP_STR("127.0.0.1"), 8080);
ret = chttp_server_listen_tcp(&server, CHTTP_STR("127.0.0.1"), 8080);
if (ret < 0) {
fprintf(stderr, "Couldn't start listening (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't start listening (%s)\n", chttp_strerror(ret));
return -1;
}
for (;;) {
HTTP_Request *request;
HTTP_ResponseBuilder builder;
http_server_wait_request(&server, &request, &builder);
CHTTP_Request *request;
CHTTP_ResponseBuilder builder;
chttp_server_wait_request(&server, &request, &builder);
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello, world!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello, world!"));
chttp_response_builder_send(builder);
}
http_server_free(&server);
chttp_server_free(&server);
return 0;
}
examples/002_proxy.c
+48 -48
View File
@@ -13,41 +13,41 @@ int main()
{
int ret;
HTTP_String remote = HTTP_STR("http://coz.is");
CHTTP_String remote = CHTTP_STR("http://coz.is");
HTTP_Client client;
ret = http_client_init(&client);
CHTTP_Client client;
ret = chttp_client_init(&client);
if (ret < 0) {
printf("Couldn't initialize client (%s)\n", http_strerror(ret));
printf("Couldn't initialize client (%s)\n", chttp_strerror(ret));
return -1;
}
HTTP_Server server;
ret = http_server_init(&server);
CHTTP_Server server;
ret = chttp_server_init(&server);
if (ret < 0) {
fprintf(stderr, "Couldn't initialize server (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't initialize server (%s)\n", chttp_strerror(ret));
return -1;
}
http_server_set_reuse_addr(&server, true);
http_server_set_trace_bytes(&server, true);
chttp_server_set_reuse_addr(&server, true);
chttp_server_set_trace_bytes(&server, true);
ret = http_server_listen_tcp(&server, HTTP_STR("127.0.0.1"), 8080);
ret = chttp_server_listen_tcp(&server, CHTTP_STR("127.0.0.1"), 8080);
if (ret < 0) {
fprintf(stderr, "Couldn't start listening (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't start listening (%s)\n", chttp_strerror(ret));
return -1;
}
bool used[HTTP_SERVER_CAPACITY];
for (int i = 0; i < HTTP_SERVER_CAPACITY; i++)
bool used[CHTTP_SERVER_CAPACITY];
for (int i = 0; i < CHTTP_SERVER_CAPACITY; i++)
used[i] = false;
HTTP_ResponseBuilder pending[HTTP_SERVER_CAPACITY];
CHTTP_ResponseBuilder pending[CHTTP_SERVER_CAPACITY];
int num_pending = 0;
for (;;) {
#define POLL_CAPACITY (HTTP_CLIENT_POLL_CAPACITY + HTTP_SERVER_POLL_CAPACITY)
#define POLL_CAPACITY (CHTTP_CLIENT_POLL_CAPACITY + CHTTP_SERVER_POLL_CAPACITY)
void *ptrs[POLL_CAPACITY];
struct pollfd polled[POLL_CAPACITY];
@@ -57,14 +57,14 @@ int main()
polled,
0
};
http_server_register_events(&server, &server_reg);
chttp_server_register_events(&server, &server_reg);
EventRegister client_reg = {
ptrs + server_reg.num_polled,
polled + server_reg.num_polled,
0
};
http_client_register_events(&client, &client_reg);
chttp_client_register_events(&client, &client_reg);
if (server_reg.num_polled > 0 ||
client_reg.num_polled > 0) {
@@ -75,62 +75,62 @@ int main()
int result;
void *user;
HTTP_Response *response;
http_client_process_events(&client, client_reg);
while (http_client_next_response(&client, &result, &user, &response)) {
CHTTP_Response *response;
chttp_client_process_events(&client, client_reg);
while (chttp_client_next_response(&client, &result, &user, &response)) {
HTTP_ResponseBuilder *builder = (HTTP_ResponseBuilder*) user;
CHTTP_ResponseBuilder *builder = (CHTTP_ResponseBuilder*) user;
int i = builder - pending;
assert(i > -1);
assert(i < HTTP_SERVER_CAPACITY);
assert(i < CHTTP_SERVER_CAPACITY);
if (result == HTTP_OK) {
http_response_builder_status(*builder, response->status);
http_response_builder_body(*builder, response->body);
http_response_builder_send(*builder);
if (result == CHTTP_OK) {
chttp_response_builder_status(*builder, response->status);
chttp_response_builder_body(*builder, response->body);
chttp_response_builder_send(*builder);
} else {
http_response_builder_status(*builder, 500);
http_response_builder_send(*builder);
chttp_response_builder_status(*builder, 500);
chttp_response_builder_send(*builder);
}
used[i] = false;
num_pending--;
}
HTTP_Request *request;
HTTP_ResponseBuilder response_builder;
http_server_process_events(&server, server_reg);
while (http_server_next_request(&server, &request, &response_builder)) {
CHTTP_Request *request;
CHTTP_ResponseBuilder response_builder;
chttp_server_process_events(&server, server_reg);
while (chttp_server_next_request(&server, &request, &response_builder)) {
int i = 0;
while (used[i]) {
i++;
assert(i < HTTP_SERVER_CAPACITY);
assert(i < CHTTP_SERVER_CAPACITY);
}
HTTP_String path = request->url.path;
CHTTP_String path = request->url.path;
if (path.len == 0)
path = HTTP_STR("/");
path = CHTTP_STR("/");
char target[1<<10];
int target_len = snprintf(target, sizeof(target),
"%.*s%.*s", HTTP_UNPACK(remote), HTTP_UNPACK(path));
"%.*s%.*s", CHTTP_UNPACK(remote), CHTTP_UNPACK(path));
if (target_len < 0 || target_len >= (int) sizeof(target)) {
http_response_builder_status(response_builder, 500);
http_response_builder_send(response_builder);
chttp_response_builder_status(response_builder, 500);
chttp_response_builder_send(response_builder);
continue;
}
HTTP_RequestBuilder request_builder = http_client_get_builder(&client);
http_request_builder_set_user(request_builder, &pending[i]);
http_request_builder_trace(request_builder, true);
http_request_builder_method(request_builder, request->method);
http_request_builder_target(request_builder, (HTTP_String) { target, target_len });
ret = http_request_builder_send(request_builder);
CHTTP_RequestBuilder request_builder = chttp_client_get_builder(&client);
chttp_request_builder_set_user(request_builder, &pending[i]);
chttp_request_builder_trace(request_builder, true);
chttp_request_builder_method(request_builder, request->method);
chttp_request_builder_target(request_builder, (CHTTP_String) { target, target_len });
ret = chttp_request_builder_send(request_builder);
if (ret < 0) {
http_response_builder_status(response_builder, 500);
http_response_builder_send(response_builder);
chttp_response_builder_status(response_builder, 500);
chttp_response_builder_send(response_builder);
continue;
}
@@ -140,7 +140,7 @@ int main()
}
}
http_server_free(&server);
http_client_free(&client);
chttp_server_free(&server);
chttp_client_free(&client);
return 0;
}
examples/003_virtual_hosts.c
+23 -23
View File
@@ -16,21 +16,21 @@ int main(void)
int ret;
HTTP_Server server;
ret = http_server_init(&server);
CHTTP_Server server;
ret = chttp_server_init(&server);
if (ret < 0) {
fprintf(stderr, "Couldn't initialize server (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't initialize server (%s)\n", chttp_strerror(ret));
return -1;
}
http_server_set_reuse_addr(&server, true);
http_server_set_trace_bytes(&server, true);
chttp_server_set_reuse_addr(&server, true);
chttp_server_set_trace_bytes(&server, true);
HTTP_String local_addr = HTTP_STR("127.0.0.1");
CHTTP_String local_addr = CHTTP_STR("127.0.0.1");
uint16_t local_port = 8080;
ret = http_server_listen_tcp(&server, local_addr, local_port);
ret = chttp_server_listen_tcp(&server, local_addr, local_port);
if (ret < 0) {
fprintf(stderr, "Couldn't start listening (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't start listening (%s)\n", chttp_strerror(ret));
return -1;
}
@@ -48,29 +48,29 @@ int main(void)
for (;;) {
HTTP_Request *req;
HTTP_ResponseBuilder builder;
http_server_wait_request(&server, &req, &builder);
CHTTP_Request *req;
CHTTP_ResponseBuilder builder;
chttp_server_wait_request(&server, &req, &builder);
if (http_match_host(req, HTTP_STR("websiteB.com"), local_port)) {
if (chttp_match_host(req, CHTTP_STR("websiteB.com"), local_port)) {
// Website B
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello from websiteB.com!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello from websiteB.com!"));
chttp_response_builder_send(builder);
} else if (http_match_host(req, HTTP_STR("websiteC.com"), local_port)) {
} else if (chttp_match_host(req, CHTTP_STR("websiteC.com"), local_port)) {
// Website C
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello from websiteC.com!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello from websiteC.com!"));
chttp_response_builder_send(builder);
} else {
// Serve websiteA by default
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello from websiteA.com!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello from websiteA.com!"));
chttp_response_builder_send(builder);
}
}
http_server_free(&server);
chttp_server_free(&server);
return 0;
}
examples/004_https_server.c
+17 -17
View File
@@ -4,39 +4,39 @@
int main(void)
{
HTTP_String local_addr = HTTP_STR("127.0.0.1");
CHTTP_String local_addr = CHTTP_STR("127.0.0.1");
uint16_t local_port = 8443;
HTTP_String cert_file = HTTP_STR("websiteA_cert.pem");
HTTP_String key_file = HTTP_STR("websiteA_key.pem");
CHTTP_String cert_file = CHTTP_STR("websiteA_cert.pem");
CHTTP_String key_file = CHTTP_STR("websiteA_key.pem");
HTTP_Server server;
int ret = http_server_init(&server);
CHTTP_Server server;
int ret = chttp_server_init(&server);
if (ret < 0) {
fprintf(stderr, "Couldn't initialize server (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't initialize server (%s)\n", chttp_strerror(ret));
return -1;
}
http_server_set_reuse_addr(&server, true);
http_server_set_trace_bytes(&server, true);
chttp_server_set_reuse_addr(&server, true);
chttp_server_set_trace_bytes(&server, true);
ret = http_server_listen_tls(&server, local_addr, local_port, cert_file, key_file);
ret = chttp_server_listen_tls(&server, local_addr, local_port, cert_file, key_file);
if (ret < 0) {
fprintf(stderr, "Couldn't start listening (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't start listening (%s)\n", chttp_strerror(ret));
return -1;
}
for (;;) {
HTTP_Request *req;
HTTP_ResponseBuilder builder;
http_server_wait_request(&server, &req, &builder);
CHTTP_Request *req;
CHTTP_ResponseBuilder builder;
chttp_server_wait_request(&server, &req, &builder);
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello from websiteA.com!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello from websiteA.com!"));
chttp_response_builder_send(builder);
}
http_server_free(&server);
chttp_server_free(&server);
return 0;
}
examples/005_virtual_hosts_over_https.c
+53 -53
View File
@@ -38,47 +38,47 @@ int main(void)
if (ret < 0)
return -1;
HTTP_Server server;
ret = http_server_init(&server);
CHTTP_Server server;
ret = chttp_server_init(&server);
if (ret < 0) {
fprintf(stderr, "Couldn't initialize server (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't initialize server (%s)\n", chttp_strerror(ret));
return -1;
}
http_server_set_reuse_addr(&server, true);
http_server_set_trace_bytes(&server, true);
chttp_server_set_reuse_addr(&server, true);
chttp_server_set_trace_bytes(&server, true);
// First, set up an HTTPS server instance with one
// of the certificate. This will act as default certificate
// when ecrypted connections don't target a specific domain.
HTTP_String local_addr = HTTP_STR("127.0.0.1");
CHTTP_String local_addr = CHTTP_STR("127.0.0.1");
uint16_t local_port = 8443;
HTTP_String cert_file = HTTP_STR("websiteA_cert.pem");
HTTP_String key_file = HTTP_STR("websiteA_key.pem");
CHTTP_String cert_file = CHTTP_STR("websiteA_cert.pem");
CHTTP_String key_file = CHTTP_STR("websiteA_key.pem");
ret = http_server_listen_tls(&server, local_addr, local_port, cert_file, key_file);
ret = chttp_server_listen_tls(&server, local_addr, local_port, cert_file, key_file);
if (ret < 0) {
fprintf(stderr, "Couldn't start listening (%s)\n", http_strerror(ret));
fprintf(stderr, "Couldn't start listening (%s)\n", chttp_strerror(ret));
return -1;
}
// Then we can add an arbitrary number of additional
// certificates using the add_website function
ret = http_server_add_certificate(&server,
HTTP_STR("websiteB.com"),
HTTP_STR("websiteB_cert.pem"),
HTTP_STR("websiteB_key.pem"));
ret = chttp_server_add_certificate(&server,
CHTTP_STR("websiteB.com"),
CHTTP_STR("websiteB_cert.pem"),
CHTTP_STR("websiteB_key.pem"));
if (ret < 0)
return -1;
ret = http_server_add_certificate(&server,
HTTP_STR("websiteC.com"),
HTTP_STR("websiteC_cert.pem"),
HTTP_STR("websiteC_key.pem"));
ret = chttp_server_add_certificate(&server,
CHTTP_STR("websiteC.com"),
CHTTP_STR("websiteC_cert.pem"),
CHTTP_STR("websiteC_key.pem"));
if (ret < 0)
return -1;
@@ -109,67 +109,67 @@ int main(void)
for (;;) {
HTTP_Request *req;
HTTP_ResponseBuilder builder;
http_server_wait_request(&server, &req, &builder);
CHTTP_Request *req;
CHTTP_ResponseBuilder builder;
chttp_server_wait_request(&server, &req, &builder);
if (http_match_host(req, HTTP_STR("websiteB.com"), 8080) ||
http_match_host(req, HTTP_STR("websiteB.com"), 8443)) {
if (chttp_match_host(req, CHTTP_STR("websiteB.com"), 8080) ||
chttp_match_host(req, CHTTP_STR("websiteB.com"), 8443)) {
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello from websiteB.com!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello from websiteB.com!"));
chttp_response_builder_send(builder);
} else if (http_match_host(req, HTTP_STR("websiteC.com"), 8080) ||
http_match_host(req, HTTP_STR("websiteC.com"), 8443)) {
} else if (chttp_match_host(req, CHTTP_STR("websiteC.com"), 8080) ||
chttp_match_host(req, CHTTP_STR("websiteC.com"), 8443)) {
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello from websiteC.com!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello from websiteC.com!"));
chttp_response_builder_send(builder);
} else {
// Serve websiteA.com by default to be consistent
// with the certificate setup
http_response_builder_status(builder, 200);
http_response_builder_body(builder, HTTP_STR("Hello from websiteA.com!"));
http_response_builder_send(builder);
chttp_response_builder_status(builder, 200);
chttp_response_builder_body(builder, CHTTP_STR("Hello from websiteA.com!"));
chttp_response_builder_send(builder);
}
}
http_server_free(&server);
chttp_server_free(&server);
return 0;
}
int setup_test_certificates(void)
{
int ret = http_create_test_certificate(
HTTP_STR("IT"),
HTTP_STR("Organization A"),
HTTP_STR("websiteA.com"),
HTTP_STR("websiteA_cert.pem"),
HTTP_STR("websiteA_key.pem")
int ret = chttp_create_test_certificate(
CHTTP_STR("IT"),
CHTTP_STR("Organization A"),
CHTTP_STR("websiteA.com"),
CHTTP_STR("websiteA_cert.pem"),
CHTTP_STR("websiteA_key.pem")
);
if (ret < 0)
return -1;
ret = http_create_test_certificate(
HTTP_STR("IT"),
HTTP_STR("Organization B"),
HTTP_STR("websiteB.com"),
HTTP_STR("websiteB_cert.pem"),
HTTP_STR("websiteB_key.pem")
ret = chttp_create_test_certificate(
CHTTP_STR("IT"),
CHTTP_STR("Organization B"),
CHTTP_STR("websiteB.com"),
CHTTP_STR("websiteB_cert.pem"),
CHTTP_STR("websiteB_key.pem")
);
if (ret < 0)
return -1;
ret = http_create_test_certificate(
HTTP_STR("IT"),
HTTP_STR("Organization C"),
HTTP_STR("websiteC.com"),
HTTP_STR("websiteC_cert.pem"),
HTTP_STR("websiteC_key.pem")
ret = chttp_create_test_certificate(
CHTTP_STR("IT"),
CHTTP_STR("Organization C"),
CHTTP_STR("websiteC.com"),
CHTTP_STR("websiteC_cert.pem"),
CHTTP_STR("websiteC_key.pem")
);
if (ret < 0)
return -1;
examples/006_parallel_client.c
+15 -15
View File
@@ -4,37 +4,37 @@ int main(void)
{
int ret;
HTTP_Client client;
ret = http_client_init(&client);
CHTTP_Client client;
ret = chttp_client_init(&client);
if (ret < 0) {
printf("Couldn't initialize client (%s)\n", http_strerror(ret));
printf("Couldn't initialize client (%s)\n", chttp_strerror(ret));
return -1;
}
HTTP_RequestBuilder builder = http_client_get_builder(&client);
CHTTP_RequestBuilder builder = chttp_client_get_builder(&client);
http_request_builder_method(builder, HTTP_METHOD_GET);
http_request_builder_target(builder, HTTP_STR("http://coz.is"));
http_request_builder_header(builder, HTTP_STR("Greeting: Hello from the cHTTP example!"));
chttp_request_builder_method(builder, CHTTP_METHOD_GET);
chttp_request_builder_target(builder, CHTTP_STR("http://coz.is"));
chttp_request_builder_header(builder, CHTTP_STR("Greeting: Hello from the cHTTP example!"));
ret = http_request_builder_send(builder);
ret = chttp_request_builder_send(builder);
if (ret < 0) {
printf("Couldn't build request (%s)\n", http_strerror(ret));
printf("Couldn't build request (%s)\n", chttp_strerror(ret));
return -1;
}
int result;
void *user;
HTTP_Response *response;
http_client_wait_response(&client, &result, &user, &response);
CHTTP_Response *response;
chttp_client_wait_response(&client, &result, &user, &response);
if (result == HTTP_OK) {
if (result == CHTTP_OK) {
printf("Received %d bytes\n", response->body.len);
} else {
printf("Couldn't receive response (%s)\n", http_strerror(result));
printf("Couldn't receive response (%s)\n", chttp_strerror(result));
}
http_free_response(response);
http_client_free(&client);
chttp_free_response(response);
chttp_client_free(&client);
return 0;
}