forked from cory/tildefriends
I think the new HTTP implementation is basically working, now.
git-svn-id: https://www.unprompted.com/svn/projects/tildefriends/trunk@4707 ed5197a5-7fde-0310-b194-c3ffbd925b24
This commit is contained in:
parent
2f6a92168e
commit
d02f17a8cf
14
core/core.js
14
core/core.js
@ -1006,6 +1006,20 @@ loadSettings().then(function() {
|
||||
}
|
||||
});
|
||||
httpd_impl.start(tildefriends.http_port);
|
||||
|
||||
if (tildefriends.args.httpdc && tildefriends.https_port) {
|
||||
async function start_tls() {
|
||||
const kCertificatePath = "data/httpd/certificate.pem";
|
||||
const kPrivateKeyPath = "data/httpd/privatekey.pem";
|
||||
let privateKey = utf8Decode(await File.readFile(kPrivateKeyPath));
|
||||
let certificate = utf8Decode(await File.readFile(kCertificatePath));
|
||||
let context = new TlsContext();
|
||||
context.setPrivateKey(privateKey);
|
||||
context.setCertificate(certificate);
|
||||
httpd_impl.start(tildefriends.https_port, context);
|
||||
}
|
||||
start_tls();
|
||||
}
|
||||
}).catch(function(error) {
|
||||
print('Failed to load settings.');
|
||||
printError({print: print}, error);
|
||||
|
||||
377
src/http.c
377
src/http.c
@ -2,6 +2,7 @@
|
||||
|
||||
#include "log.h"
|
||||
#include "mem.h"
|
||||
#include "tls.h"
|
||||
#include "util.js.h"
|
||||
|
||||
#include "picohttpparser.h"
|
||||
@ -21,27 +22,30 @@ static const int k_timeout_ms = 60000;
|
||||
typedef struct _tf_http_connection_t
|
||||
{
|
||||
tf_http_t* http;
|
||||
tf_tls_session_t* tls;
|
||||
uv_tcp_t tcp;
|
||||
uv_shutdown_t shutdown;
|
||||
uv_timer_t timeout;
|
||||
|
||||
int ref_count;
|
||||
bool is_handshaking;
|
||||
bool is_receiving_headers;
|
||||
bool is_response_sent;
|
||||
bool is_shutting_down;
|
||||
|
||||
const char* method;
|
||||
const char* path;
|
||||
const char* query;
|
||||
int minor_version;
|
||||
|
||||
char incoming[8192];
|
||||
|
||||
char headers_buffer[8192];
|
||||
size_t headers_buffer_length;
|
||||
int parsed_length;
|
||||
|
||||
char buffer[8192];
|
||||
size_t buffer_length;
|
||||
|
||||
struct phr_header headers[32];
|
||||
int headers_length;
|
||||
bool headers_done;
|
||||
|
||||
tf_http_callback_t* callback;
|
||||
tf_http_request_t* request;
|
||||
@ -62,9 +66,16 @@ typedef struct _tf_http_handler_t
|
||||
void* user_data;
|
||||
} tf_http_handler_t;
|
||||
|
||||
typedef struct _tf_http_listener_t
|
||||
{
|
||||
tf_http_t* http;
|
||||
tf_tls_context_t* tls;
|
||||
uv_tcp_t tcp;
|
||||
} tf_http_listener_t;
|
||||
|
||||
typedef struct _tf_http_t
|
||||
{
|
||||
uv_tcp_t** listeners;
|
||||
tf_http_listener_t** listeners;
|
||||
int listeners_count;
|
||||
|
||||
tf_http_connection_t** connections;
|
||||
@ -81,6 +92,7 @@ static const char* _http_connection_get_header(const tf_http_connection_t* conne
|
||||
static void _http_connection_destroy(tf_http_connection_t* connection, const char* reason);
|
||||
static const char* _http_status_text(int status);
|
||||
static void _http_timer_reset(tf_http_connection_t* connection);
|
||||
static void _http_tls_update(tf_http_connection_t* connection);
|
||||
|
||||
tf_http_t* tf_http_create(uv_loop_t* loop)
|
||||
{
|
||||
@ -92,17 +104,10 @@ tf_http_t* tf_http_create(uv_loop_t* loop)
|
||||
return http;
|
||||
}
|
||||
|
||||
void _http_allocate_buffer(uv_handle_t* handle, size_t suggestedSize, uv_buf_t* buf)
|
||||
void _http_allocate_buffer(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf)
|
||||
{
|
||||
tf_http_connection_t* connection = handle->data;
|
||||
if (!connection->headers_done)
|
||||
{
|
||||
*buf = uv_buf_init(connection->headers_buffer + connection->headers_buffer_length, sizeof(connection->headers_buffer) - connection->headers_buffer_length);
|
||||
}
|
||||
else
|
||||
{
|
||||
*buf = uv_buf_init(connection->buffer + connection->buffer_length, sizeof(connection->buffer) - connection->buffer_length);
|
||||
}
|
||||
*buf = uv_buf_init(connection->incoming, sizeof(connection->incoming));
|
||||
}
|
||||
|
||||
bool _http_find_handler(tf_http_t* http, const char* path, tf_http_callback_t** out_callback, void** out_user_data)
|
||||
@ -136,6 +141,8 @@ static void _http_connection_on_close(uv_handle_t* handle)
|
||||
|
||||
static void _http_connection_destroy(tf_http_connection_t* connection, const char* reason)
|
||||
{
|
||||
connection->is_shutting_down = true;
|
||||
|
||||
if (connection->tcp.data && !uv_is_closing((uv_handle_t*)&connection->tcp))
|
||||
{
|
||||
uv_close((uv_handle_t*)&connection->tcp, _http_connection_on_close);
|
||||
@ -144,6 +151,11 @@ static void _http_connection_destroy(tf_http_connection_t* connection, const cha
|
||||
{
|
||||
uv_close((uv_handle_t*)&connection->timeout, _http_connection_on_close);
|
||||
}
|
||||
if (connection->tls)
|
||||
{
|
||||
tf_tls_session_destroy(connection->tls);
|
||||
connection->tls = NULL;
|
||||
}
|
||||
|
||||
if (connection->ref_count == 0 &&
|
||||
!connection->tcp.data &&
|
||||
@ -175,11 +187,14 @@ static void _http_builtin_404_handler(tf_http_request_t* request)
|
||||
|
||||
static void _http_reset_connection(tf_http_connection_t* connection)
|
||||
{
|
||||
connection->headers_done = false;
|
||||
connection->headers_buffer_length = 0;
|
||||
connection->body_length = 0;
|
||||
connection->content_length = 0;
|
||||
connection->headers_buffer_length = 0;
|
||||
connection->headers_length = 0;
|
||||
connection->is_receiving_headers = true;
|
||||
connection->is_response_sent = false;
|
||||
connection->parsed_length = 0;
|
||||
connection->path = NULL;
|
||||
}
|
||||
|
||||
static void _http_websocket_mask_in_place(uint8_t* p, uint32_t mask, size_t size)
|
||||
@ -268,6 +283,10 @@ static void _http_add_body_bytes(tf_http_connection_t* connection, const void* d
|
||||
memmove(connection->body, (char*)connection->body + total_length, connection->body_length - total_length);
|
||||
connection->body_length -= total_length;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -300,101 +319,135 @@ static void _http_add_body_bytes(tf_http_connection_t* connection, const void* d
|
||||
tf_http_request_ref(request);
|
||||
connection->callback(request);
|
||||
tf_http_request_release(request);
|
||||
if (!connection->is_websocket)
|
||||
{
|
||||
_http_reset_connection(connection);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static size_t _http_on_read_plain_internal(tf_http_connection_t* connection, const void* data, size_t read_size)
|
||||
{
|
||||
if (connection->is_receiving_headers)
|
||||
{
|
||||
size_t used_read_size = tf_min(read_size, sizeof(connection->headers_buffer) - connection->headers_buffer_length);
|
||||
memcpy(connection->headers_buffer + connection->headers_buffer_length, data, used_read_size);
|
||||
connection->headers_buffer_length += used_read_size;
|
||||
|
||||
const char* method = NULL;
|
||||
size_t method_length = 0;
|
||||
const char* path = NULL;
|
||||
size_t path_length = 0;
|
||||
size_t header_count = sizeof(connection->headers) / sizeof(*connection->headers);
|
||||
|
||||
int parse_result = phr_parse_request(connection->headers_buffer, connection->headers_buffer_length, &method, &method_length, &path, &path_length, &connection->minor_version, connection->headers, &header_count, connection->parsed_length);
|
||||
connection->parsed_length = connection->headers_buffer_length;
|
||||
if (parse_result > 0)
|
||||
{
|
||||
connection->is_receiving_headers = false;
|
||||
connection->headers_length = header_count;
|
||||
connection->method = method;
|
||||
((char*)connection->method)[method_length] = '\0';
|
||||
connection->path = path;
|
||||
((char*)connection->path)[path_length] = '\0';
|
||||
char* q = strchr(connection->path, '?');
|
||||
if (q)
|
||||
{
|
||||
*q = '\0';
|
||||
connection->query = q + 1;
|
||||
}
|
||||
|
||||
connection->connection_close = connection->minor_version == 0;
|
||||
|
||||
for (int i = 0; i < (int)header_count; i++)
|
||||
{
|
||||
for (size_t j = 0; j < connection->headers[i].name_len; j++)
|
||||
{
|
||||
if (connection->headers[i].name[j] >= 'A' &&
|
||||
connection->headers[i].name[j] <= 'Z')
|
||||
{
|
||||
((char*)connection->headers[i].name)[j] += 'a' - 'A';
|
||||
}
|
||||
}
|
||||
((char*)connection->headers[i].name)[connection->headers[i].name_len] = '\0';
|
||||
((char*)connection->headers[i].value)[connection->headers[i].value_len] = '\0';
|
||||
if (strcasecmp(connection->headers[i].name, "content-length") == 0)
|
||||
{
|
||||
connection->content_length = strtoull(connection->headers[i].value, NULL, 10);
|
||||
}
|
||||
else if (strcasecmp(connection->headers[i].name, "connection") == 0)
|
||||
{
|
||||
if (strcasecmp(connection->headers[i].value, "close") == 0)
|
||||
{
|
||||
connection->connection_close = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (connection->content_length)
|
||||
{
|
||||
connection->body = tf_malloc(connection->content_length);
|
||||
}
|
||||
|
||||
if (!_http_find_handler(connection->http, connection->path, &connection->callback, &connection->user_data) || !connection->callback)
|
||||
{
|
||||
connection->callback = _http_builtin_404_handler;
|
||||
}
|
||||
size_t consumed = read_size - (connection->headers_buffer_length - connection->parsed_length) - (read_size - used_read_size);
|
||||
_http_add_body_bytes(connection, NULL, 0);
|
||||
return consumed;
|
||||
}
|
||||
else if (parse_result == -2)
|
||||
{
|
||||
/* Incomplete. Will try again next time. */
|
||||
return used_read_size;
|
||||
}
|
||||
else
|
||||
{
|
||||
tf_printf("phr_parse_request: %d\n", parse_result);
|
||||
_http_connection_destroy(connection, "failed to parse request headers");
|
||||
return used_read_size;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
_http_add_body_bytes(connection, data, read_size);
|
||||
return read_size;
|
||||
}
|
||||
}
|
||||
|
||||
static void _http_on_read_plain(tf_http_connection_t* connection, const void* data, size_t read_size)
|
||||
{
|
||||
size_t total_consumed = 0;
|
||||
while (total_consumed < read_size)
|
||||
{
|
||||
size_t consumed = _http_on_read_plain_internal(connection, ((const uint8_t*)data) + total_consumed, read_size - total_consumed);
|
||||
if (!consumed)
|
||||
{
|
||||
_http_connection_destroy(connection, "_http_on_read_plain_internal didn't consume any data");
|
||||
break;
|
||||
}
|
||||
total_consumed += consumed;
|
||||
}
|
||||
}
|
||||
|
||||
static void _http_on_read(uv_stream_t* stream, ssize_t read_size, const uv_buf_t* buffer)
|
||||
{
|
||||
tf_http_connection_t* connection = stream->data;
|
||||
_http_timer_reset(connection);
|
||||
if (read_size > 0)
|
||||
{
|
||||
if (!connection->headers_done)
|
||||
if (connection->tls)
|
||||
{
|
||||
connection->headers_buffer_length += read_size;
|
||||
|
||||
const char* method = NULL;
|
||||
size_t method_length = 0;
|
||||
const char* path = NULL;
|
||||
size_t path_length = 0;
|
||||
size_t header_count = sizeof(connection->headers) / sizeof(*connection->headers);
|
||||
|
||||
int parse_result = phr_parse_request(connection->headers_buffer, connection->headers_buffer_length, &method, &method_length, &path, &path_length, &connection->minor_version, connection->headers, &header_count, connection->parsed_length);
|
||||
connection->parsed_length = connection->headers_buffer_length;
|
||||
if (parse_result > 0)
|
||||
if (tf_tls_session_write_encrypted(connection->tls, buffer->base, read_size) < 0)
|
||||
{
|
||||
connection->headers_done = true;
|
||||
connection->headers_length = header_count;
|
||||
connection->method = method;
|
||||
((char*)connection->method)[method_length] = '\0';
|
||||
connection->path = path;
|
||||
((char*)connection->path)[path_length] = '\0';
|
||||
char* q = strchr(connection->path, '?');
|
||||
if (q)
|
||||
{
|
||||
*q = '\0';
|
||||
connection->query = q + 1;
|
||||
}
|
||||
|
||||
connection->connection_close = connection->minor_version == 0;
|
||||
|
||||
for (int i = 0; i < (int)header_count; i++)
|
||||
{
|
||||
for (size_t j = 0; j < connection->headers[i].name_len; j++)
|
||||
{
|
||||
if (connection->headers[i].name[j] >= 'A' &&
|
||||
connection->headers[i].name[j] <= 'Z')
|
||||
{
|
||||
((char*)connection->headers[i].name)[j] += 'a' - 'A';
|
||||
}
|
||||
}
|
||||
((char*)connection->headers[i].name)[connection->headers[i].name_len] = '\0';
|
||||
((char*)connection->headers[i].value)[connection->headers[i].value_len] = '\0';
|
||||
if (strcasecmp(connection->headers[i].name, "content-length") == 0)
|
||||
{
|
||||
connection->content_length = strtoull(connection->headers[i].value, NULL, 10);
|
||||
}
|
||||
else if (strcasecmp(connection->headers[i].name, "connection") == 0)
|
||||
{
|
||||
if (strcasecmp(connection->headers[i].value, "close") == 0)
|
||||
{
|
||||
connection->connection_close = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (connection->content_length)
|
||||
{
|
||||
connection->body = tf_malloc(connection->content_length);
|
||||
}
|
||||
|
||||
if (!_http_find_handler(connection->http, connection->path, &connection->callback, &connection->user_data) || !connection->callback)
|
||||
{
|
||||
connection->callback = _http_builtin_404_handler;
|
||||
}
|
||||
|
||||
_http_add_body_bytes(connection, connection->headers_buffer + parse_result, connection->headers_buffer_length - parse_result);
|
||||
}
|
||||
else if (parse_result == -2)
|
||||
{
|
||||
/* Incomplete. Will try again next time. */
|
||||
_http_connection_destroy(connection, "tf_tls_session_write_encrypted");
|
||||
}
|
||||
else
|
||||
{
|
||||
tf_printf("phr_parse_request: %d\n", parse_result);
|
||||
_http_connection_destroy(connection, "failed to parse request headers");
|
||||
_http_tls_update(connection);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
connection->buffer_length += read_size;
|
||||
_http_add_body_bytes(connection, connection->buffer, connection->buffer_length);
|
||||
connection->buffer_length = 0;
|
||||
_http_on_read_plain(connection, buffer->base, read_size);
|
||||
}
|
||||
}
|
||||
else if (read_size < 0)
|
||||
@ -428,9 +481,21 @@ static void _http_timer_reset(tf_http_connection_t* connection)
|
||||
|
||||
static void _http_on_connection(uv_stream_t* stream, int status)
|
||||
{
|
||||
tf_http_t* http = stream->data;
|
||||
tf_http_listener_t* listener = stream->data;
|
||||
tf_http_t* http = listener->http;
|
||||
tf_http_connection_t* connection = tf_malloc(sizeof(tf_http_connection_t));
|
||||
*connection = (tf_http_connection_t) { .http = http, .tcp = { .data = connection } };
|
||||
*connection = (tf_http_connection_t) { .http = http, .tcp = { .data = connection }, .is_receiving_headers = true };
|
||||
if (listener->tls)
|
||||
{
|
||||
connection->tls = tf_tls_context_create_session(listener->tls);
|
||||
if (!connection->tls)
|
||||
{
|
||||
_http_connection_destroy(connection, "tf_tls_context_create_session");
|
||||
return;
|
||||
}
|
||||
tf_tls_session_start_accept(connection->tls);
|
||||
connection->is_handshaking = true;
|
||||
}
|
||||
int r = uv_tcp_init(connection->http->loop, &connection->tcp);
|
||||
if (r)
|
||||
{
|
||||
@ -471,15 +536,20 @@ static void _http_on_connection(uv_stream_t* stream, int status)
|
||||
return;
|
||||
}
|
||||
|
||||
if (connection->tls)
|
||||
{
|
||||
_http_tls_update(connection);
|
||||
}
|
||||
|
||||
http->connections = tf_realloc(http->connections, sizeof(tf_http_connection_t*) * (http->connections_count + 1));
|
||||
http->connections[http->connections_count++] = connection;
|
||||
}
|
||||
|
||||
void tf_http_listen(tf_http_t* http, int port)
|
||||
void tf_http_listen(tf_http_t* http, int port, tf_tls_context_t* tls)
|
||||
{
|
||||
uv_tcp_t* tcp = tf_malloc(sizeof(uv_tcp_t));
|
||||
*tcp = (uv_tcp_t) { .data = http };
|
||||
int r = uv_tcp_init(http->loop, tcp);
|
||||
tf_http_listener_t* listener = tf_malloc(sizeof(tf_http_listener_t));
|
||||
*listener = (tf_http_listener_t) { .http = http, .tls = tls, .tcp = { .data = listener } };
|
||||
int r = uv_tcp_init(http->loop, &listener->tcp);
|
||||
if (r)
|
||||
{
|
||||
tf_printf("uv_tcp_init: %s\n", uv_strerror(r));
|
||||
@ -493,7 +563,7 @@ void tf_http_listen(tf_http_t* http, int port)
|
||||
.sin_addr = { .s_addr = INADDR_ANY },
|
||||
.sin_port = ntohs(port),
|
||||
};
|
||||
r = uv_tcp_bind(tcp, (struct sockaddr*)&addr, 0);
|
||||
r = uv_tcp_bind(&listener->tcp, (struct sockaddr*)&addr, 0);
|
||||
if (r)
|
||||
{
|
||||
tf_printf("uv_tcp_bind: %s\n", uv_strerror(r));
|
||||
@ -502,7 +572,7 @@ void tf_http_listen(tf_http_t* http, int port)
|
||||
|
||||
if (r == 0)
|
||||
{
|
||||
r = uv_listen((uv_stream_t*)tcp, 16, _http_on_connection);
|
||||
r = uv_listen((uv_stream_t*)&listener->tcp, 16, _http_on_connection);
|
||||
if (r)
|
||||
{
|
||||
tf_printf("uv_listen: %s\n", uv_strerror(r));
|
||||
@ -511,8 +581,8 @@ void tf_http_listen(tf_http_t* http, int port)
|
||||
|
||||
if (r == 0)
|
||||
{
|
||||
http->listeners = tf_realloc(http->listeners, sizeof(uv_tcp_t*) * (http->listeners_count + 1));
|
||||
http->listeners[http->listeners_count++] = tcp;
|
||||
http->listeners = tf_realloc(http->listeners, sizeof(tf_http_listener_t*) * (http->listeners_count + 1));
|
||||
http->listeners[http->listeners_count++] = listener;
|
||||
}
|
||||
}
|
||||
|
||||
@ -527,17 +597,18 @@ void tf_http_add_handler(tf_http_t* http, const char* pattern, tf_http_callback_
|
||||
};
|
||||
}
|
||||
|
||||
static void _http_free_on_close(uv_handle_t* handle)
|
||||
static void _http_free_listener_on_close(uv_handle_t* handle)
|
||||
{
|
||||
tf_http_listener_t* listener = handle->data;
|
||||
handle->data = NULL;
|
||||
tf_free(handle);
|
||||
tf_free(listener);
|
||||
}
|
||||
|
||||
void tf_http_destroy(tf_http_t* http)
|
||||
{
|
||||
for (int i = 0; i < http->listeners_count; i++)
|
||||
{
|
||||
uv_close((uv_handle_t*)http->listeners[i], _http_free_on_close);
|
||||
uv_close((uv_handle_t*)&http->listeners[i]->tcp, _http_free_listener_on_close);
|
||||
}
|
||||
tf_free(http->listeners);
|
||||
http->listeners = NULL;
|
||||
@ -582,16 +653,77 @@ static void _http_on_shutdown(uv_shutdown_t* request, int status)
|
||||
request->data = NULL;
|
||||
}
|
||||
|
||||
static void _http_write_internal(tf_http_connection_t* connection, const void* data, size_t size)
|
||||
{
|
||||
if (size && !connection->is_shutting_down)
|
||||
{
|
||||
uv_write_t* write = tf_malloc(sizeof(uv_write_t) + size);
|
||||
*write = (uv_write_t) { .data = connection };
|
||||
memcpy(write + 1, data, size);
|
||||
int r = uv_write(write, (uv_stream_t*)&connection->tcp, &(uv_buf_t) { .base = (void*)(write + 1), .len = size }, 1, _http_on_write);
|
||||
if (r)
|
||||
{
|
||||
tf_printf("uv_write: %s\n", uv_strerror(r));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void _http_tls_update(tf_http_connection_t* connection)
|
||||
{
|
||||
bool again = true;
|
||||
while (again)
|
||||
{
|
||||
again = false;
|
||||
|
||||
if (connection->is_handshaking)
|
||||
{
|
||||
switch (tf_tls_session_handshake(connection->tls))
|
||||
{
|
||||
case k_tls_handshake_done:
|
||||
connection->is_handshaking = false;
|
||||
break;
|
||||
case k_tls_handshake_more:
|
||||
break;
|
||||
case k_tls_handshake_failed:
|
||||
_http_connection_destroy(connection, "tf_tls_session_handshake");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
char buffer[8192];
|
||||
int r = tf_tls_session_read_encrypted(connection->tls, buffer, sizeof(buffer));
|
||||
if (r > 0)
|
||||
{
|
||||
_http_write_internal(connection, buffer, r);
|
||||
again = true;
|
||||
}
|
||||
|
||||
r = tf_tls_session_read_plain(connection->tls, buffer, sizeof(buffer));
|
||||
if (r > 0)
|
||||
{
|
||||
_http_on_read_plain(connection, buffer, r);
|
||||
again = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void _http_write(tf_http_connection_t* connection, const void* data, size_t size)
|
||||
{
|
||||
_http_timer_reset(connection);
|
||||
uv_write_t* write = tf_malloc(sizeof(uv_write_t) + size);
|
||||
*write = (uv_write_t) { .data = connection };
|
||||
memcpy(write + 1, data, size);
|
||||
int r = uv_write(write, (uv_stream_t*)&connection->tcp, &(uv_buf_t) { .base = (void*)(write + 1), .len = size }, 1, _http_on_write);
|
||||
if (r)
|
||||
if (connection->tls)
|
||||
{
|
||||
tf_printf("uv_write: %s\n", uv_strerror(r));
|
||||
int r = tf_tls_session_write_plain(connection->tls, data, size);
|
||||
if (r < (ssize_t)size)
|
||||
{
|
||||
char buffer[8192];
|
||||
tf_tls_session_get_error(connection->tls, buffer, sizeof(buffer));
|
||||
tf_printf("tf_tls_session_write_plain: %s\n", buffer);
|
||||
}
|
||||
_http_tls_update(connection);
|
||||
}
|
||||
else
|
||||
{
|
||||
_http_write_internal(connection, data, size);
|
||||
}
|
||||
}
|
||||
|
||||
@ -602,6 +734,12 @@ void tf_http_request_send(tf_http_request_t* request, const void* data, size_t s
|
||||
|
||||
void tf_http_respond(tf_http_request_t* request, int status, const char** headers, int headers_count, const void* body, size_t content_length)
|
||||
{
|
||||
if (request->connection->is_response_sent)
|
||||
{
|
||||
return;
|
||||
}
|
||||
request->connection->is_response_sent = true;
|
||||
|
||||
const char* status_text = _http_status_text(status);
|
||||
/* HTTP/1.x 200 OK\r\n */
|
||||
bool sent_content_length = false;
|
||||
@ -629,9 +767,7 @@ void tf_http_respond(tf_http_request_t* request, int status, const char** header
|
||||
headers_length += content_length_buffer_length;
|
||||
}
|
||||
|
||||
uv_write_t* write = tf_malloc(sizeof(uv_write_t) + headers_length + content_length + 1);
|
||||
*write = (uv_write_t) { .data = request->connection };
|
||||
char* buffer = (char*)(write + 1);
|
||||
char* buffer = alloca(headers_length + 1);
|
||||
int offset = snprintf(buffer, headers_length + 1, "HTTP/1.%d %03d %s\r\n", request->connection->minor_version, status, status_text);
|
||||
if (headers)
|
||||
{
|
||||
@ -647,16 +783,12 @@ void tf_http_respond(tf_http_request_t* request, int status, const char** header
|
||||
}
|
||||
offset += snprintf(buffer + offset, headers_length + 1 - offset, "\r\n");
|
||||
assert(offset == headers_length);
|
||||
_http_write(request->connection, buffer, headers_length);
|
||||
if (content_length)
|
||||
{
|
||||
memcpy(buffer + offset, body, content_length);
|
||||
_http_write(request->connection, body, content_length);
|
||||
}
|
||||
_http_timer_reset(request->connection);
|
||||
int r = uv_write(write, (uv_stream_t*)&request->connection->tcp, &(uv_buf_t) { .base = buffer, .len = headers_length + content_length }, 1, _http_on_write);
|
||||
if (r)
|
||||
{
|
||||
tf_printf("uv_write: %s\n", uv_strerror(r));
|
||||
}
|
||||
|
||||
if (request->connection->connection_close &&
|
||||
!request->connection->shutdown.data)
|
||||
@ -682,7 +814,10 @@ void tf_http_request_release(tf_http_request_t* request)
|
||||
{
|
||||
if (--request->connection->ref_count == 0)
|
||||
{
|
||||
/* Reset the connection? */
|
||||
if (!request->connection->is_websocket)
|
||||
{
|
||||
_http_reset_connection(request->connection);
|
||||
}
|
||||
}
|
||||
if (--request->ref_count == 0)
|
||||
{
|
||||
|
||||
@ -2,10 +2,11 @@
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
typedef struct uv_loop_s uv_loop_t;
|
||||
typedef struct _tf_http_t tf_http_t;
|
||||
typedef struct _tf_http_connection_t tf_http_connection_t;
|
||||
typedef struct _tf_http_request_t tf_http_request_t;
|
||||
typedef struct _tf_http_t tf_http_t;
|
||||
typedef struct _tf_tls_context_t tf_tls_context_t;
|
||||
typedef struct uv_loop_s uv_loop_t;
|
||||
|
||||
typedef enum _tf_http_callback_phase_t
|
||||
{
|
||||
@ -35,7 +36,7 @@ typedef struct _tf_http_request_t
|
||||
typedef void (tf_http_callback_t)(tf_http_request_t* request);
|
||||
|
||||
tf_http_t* tf_http_create(uv_loop_t* loop);
|
||||
void tf_http_listen(tf_http_t* http, int port);
|
||||
void tf_http_listen(tf_http_t* http, int port, tf_tls_context_t* tls);
|
||||
void tf_http_add_handler(tf_http_t* http, const char* pattern, tf_http_callback_t* callback, void* user_data);
|
||||
void tf_http_respond(tf_http_request_t* request, int status, const char** headers, int headers_count, const void* body, size_t content_length);
|
||||
size_t tf_http_get_body(const tf_http_request_t* request, const void** out_data);
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
#include "log.h"
|
||||
#include "mem.h"
|
||||
#include "task.h"
|
||||
#include "tlscontext.js.h"
|
||||
#include "util.js.h"
|
||||
|
||||
#include "picohttpparser.h"
|
||||
@ -291,7 +292,8 @@ static JSValue _httpd_start(JSContext* context, JSValueConst this_val, int argc,
|
||||
tf_http_t* http = JS_GetOpaque(this_val, _httpd_class_id);
|
||||
int port = 0;
|
||||
JS_ToInt32(context, &port, argv[0]);
|
||||
tf_http_listen(http, port);
|
||||
tf_tls_context_t* tls = tf_tls_context_get(JS_DupValue(context, argv[1]));
|
||||
tf_http_listen(http, port, tls);
|
||||
return JS_UNDEFINED;
|
||||
}
|
||||
|
||||
@ -340,7 +342,7 @@ void tf_httpd_register(JSContext* context)
|
||||
JS_SetPropertyStr(context, httpd, "handlers", JS_NewObject(context));
|
||||
JS_SetPropertyStr(context, httpd, "all", JS_NewCFunction(context, _httpd_all, "all", 2));
|
||||
JS_SetPropertyStr(context, httpd, "registerSocketHandler", JS_NewCFunction(context, _httpd_register_socket_handler, "register_socket_handler", 2));
|
||||
JS_SetPropertyStr(context, httpd, "start", JS_NewCFunction(context, _httpd_start, "start", 1));
|
||||
JS_SetPropertyStr(context, httpd, "start", JS_NewCFunction(context, _httpd_start, "start", 2));
|
||||
JS_SetPropertyStr(context, global, "httpdc", httpd);
|
||||
JS_FreeValue(context, global);
|
||||
}
|
||||
|
||||
@ -574,7 +574,7 @@ static int _tf_command_usage(const char* file, int argc, char* argv[])
|
||||
{
|
||||
tf_printf(" %s - %s\n", k_commands[i].name, k_commands[i].description);
|
||||
}
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@ -739,7 +739,7 @@ static void _test_http(const tf_test_options_t* options)
|
||||
tf_http_t* http = tf_http_create(&loop);
|
||||
tf_http_add_handler(http, "/hello", _test_http_handler, NULL);
|
||||
tf_http_add_handler(http, "/post", _test_http_handler_post, NULL);
|
||||
tf_http_listen(http, 23456);
|
||||
tf_http_listen(http, 23456, NULL);
|
||||
|
||||
test_http_t test = { .loop = &loop };
|
||||
uv_async_init(&loop, &test.async, _test_http_async);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user