slon-project/slon
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Meta: Add files to repository

Browse source
This commit is contained in:
Alec Murphy 2025-02-16 15:21:19 -05:00
parent 6d27d43268
commit 52cb92f587
120 changed files with 71820 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

274
Slon/Api/V1/Accounts.HC Normal file
View file

@ -0,0 +1,274 @@
U0 @slon_api_v1_accounts_get(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer;
U8* path = @slon_strnew(session, @slon_http_request_path(session));
I64 path_segments_count = 0;
U8** path_segments = String.Split(path, '/', &path_segments_count);
JsonObject* acct = NULL;
if (!StrICmp("verify_credentials", path_segments[3])) {
if (@slon_api_authorized(session)) {
SLON_AUTH_ACCOUNT_ID
acct = @slon_api_account_by_id(account_id);
if (acct) {
@slon_http_send_json(session, acct);
} else {
@slon_http_set_status_code(session, 404);
}
} else {
@slon_http_set_status_code(session, 401);
}
} else {
// Work with account :id
U8* some_account_id = path_segments[3];
acct = @slon_api_account_by_id(some_account_id);
if (!acct) {
@slon_http_set_status_code(session, 404);
goto slon_api_v1_accounts_get_return;
}
if (path_segments_count > 5) {
U8* method = path_segments[4];
if (!StrICmp("following", method)) {
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
goto slon_api_v1_accounts_get_return;
}
if (!StrICmp("statuses", method)) {
// Return the Account's Statuses
JsonArray* status_array = db->o("statuses")->a(some_account_id);
I64 count = 0;
// FILTERS
I64 limit = 20; // default
U64 max_id = 0;
U64 min_id = 0;
Bool only_media = request_json->@("only_media");
Bool exclude_replies = request_json->@("exclude_replies");
Bool exclude_reblogs = request_json->@("exclude_reblogs");
no_warn exclude_reblogs;
Bool pinned = request_json->@("pinned");
// FIXME: Implement "only_media", "exclude_reblogs", "tagged"
Bool exclude_status = FALSE;
U64 status_id = 0;
if (StrLen(request_json->@("limit")) > 0) {
// 40 = maximum per https://docs.joinmastodon.org/methods/accounts/#statuses
limit = MinI64(40, Str2I64(request_json->@("limit")));
}
if (StrLen(request_json->@("max_id")) > 0) {
max_id = Str2I64(request_json->@("max_id"));
}
if (StrLen(request_json->@("min_id")) > 0) {
min_id = Str2I64(request_json->@("min_id"));
}
JsonArray* statuses = Json.CreateArray();
JsonObject* status = NULL;
if (status_array && status_array->length) {
I64 i;
for (i = 0; i < status_array->length; i++) {
status = status_array->o(i);
status_id = Str2I64(status->@("id"));
exclude_status = FALSE;
if (status->@("deleted")) {
exclude_status = TRUE;
}
if (max_id > 0 && status_id >= max_id) {
exclude_status = TRUE;
}
if (min_id > 0 && status_id <= min_id) {
exclude_status = TRUE;
}
if (only_media && !Json.Get(status, "media_attachments")(JsonArray*)->length) {
exclude_status = TRUE;
}
if (exclude_replies && StrLen(status->@("in_reply_to_account_id")) > 0 && StrICmp(account_id, status->@("in_reply_to_account_id"))) {
exclude_status = TRUE;
}
if (pinned && !status->@("pinned")) {
exclude_status = TRUE;
}
if (!exclude_status) {
statuses->append(Json.CreateItem(status, JSON_OBJECT));
count++;
}
if (limit > 0 && count >= limit) {
break;
}
}
}
@slon_http_send_json(session, statuses);
Json.Delete(statuses);
goto slon_api_v1_accounts_get_return;
}
@slon_http_set_status_code(session, 404);
} else {
// Return the Account profile
JsonObject* profile_object = Json.Clone(acct);
profile_object->unset("source");
@slon_http_send_json(session, profile_object);
Json.Delete(profile_object);
}
}
slon_api_v1_accounts_get_return:
@slon_free(session, path);
}
Bool @slon_api_v1_accounts_key_is_boolean(U8* name)
{
return (!StrICmp(name, "locked") || !StrICmp(name, "bot") || !StrICmp(name, "discoverable") || !StrICmp(name, "hide_collections") || !StrICmp(name, "indexable"));
}
U0 @slon_api_v1_accounts_patch(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
U8* path = @slon_strnew(session, @slon_http_request_path(session));
I64 path_segments_count = 0;
U8** path_segments = String.Split(path, '/', &path_segments_count);
JsonObject* acct = NULL;
if (!StrICmp("update_credentials", path_segments[3])) {
if (@slon_api_authorized(session)) {
SLON_AUTH_ACCOUNT_ID
if (!request_json || !request_json->keys) {
@slon_http_set_status_code(session, 400);
goto slon_api_v1_accounts_patch_return;
}
// FIXME: Support avatars/banners
acct = @slon_api_account_by_id(account_id);
if (!acct) {
@slon_http_set_status_code(session, 404);
goto slon_api_v1_accounts_patch_return;
}
JsonObject* source = acct->@("source");
I64 fields_attributes_indexes[16];
I64 fields_attributes_count = 0;
U8* field_name;
U8* field_value;
JsonKey* update_field_index;
JsonObject* field_object;
Bool update_fields_from_form_data = FALSE;
Bool integer_is_in_index = FALSE;
I64 i;
I64 index;
MemSet(fields_attributes_indexes, NULL, sizeof(I64) * 16);
JsonArray* fields_array = Json.CreateArray();
JsonKey* key = request_json->keys;
while (key) {
if (!String.BeginsWith("fields_attributes", key->name) && !String.BeginsWith("source", key->name)) {
if (@slon_api_v1_accounts_key_is_boolean(key->name)) {
switch (key->type) {
case JSON_STRING:
acct->set(key->name, @slon_api_boolean_from_string(key->value), JSON_BOOLEAN);
break;
default:
acct->set(key->name, key->value > 0, JSON_BOOLEAN);
break;
}
} else {
acct->set(key->name, key->value, key->type);
}
} else if (String.BeginsWith("source", key->name)) {
if (!StrICmp("source[language]", key->name)) {
source->set("language", key->value);
}
if (!StrICmp("source[privacy]", key->name)) {
source->set("privacy", key->value);
}
} else if (String.BeginsWith("fields_attributes[", key->name)) {
// Get fields indexes from form data
update_fields_from_form_data = TRUE;
index = Str2I64(key->name + StrLen("fields_attributes["));
if (!fields_attributes_count) {
fields_attributes_indexes[fields_attributes_count] = index;
++fields_attributes_count;
} else {
integer_is_in_index = FALSE;
i = 0;
while (i < fields_attributes_count) {
if (index == fields_attributes_indexes[i])
integer_is_in_index = TRUE;
++i;
}
if (!integer_is_in_index) {
fields_attributes_indexes[fields_attributes_count] = index;
++fields_attributes_count;
}
}
} else if (!StrICmp("fields_attributes", key->name)) {
// Get fields data from JSON object
AdamLog("let's get fields data from JSON object!!\n");
update_field_index = key->value(JsonObject*)->keys;
while (update_field_index) {
field_object = update_field_index->value;
field_object->set("verified_at", NULL, JSON_NULL);
AdamLog("before stringify\n");
AdamLog("%s\n", Json.Stringify(field_object));
AdamLog("after stringify\n");
fields_array->append(Json.CreateItem(field_object, JSON_OBJECT));
update_field_index = update_field_index->next;
}
}
key = key->next;
}
if (update_fields_from_form_data) {
for (i = 0; i < fields_attributes_count; i++) {
index = fields_attributes_indexes[i];
field_name = NULL;
field_value = NULL;
key = request_json->keys;
while (key) {
StrPrint(scratch_buffer, "fields_attributes[%d][name]", index);
if (String.BeginsWith(scratch_buffer, key->name)) {
field_name = key->value;
}
StrPrint(scratch_buffer, "fields_attributes[%d][value]", index);
if (String.BeginsWith(scratch_buffer, key->name)) {
field_value = key->value;
}
if (field_name && field_value) {
// create new field_object, and append to acct->fields
field_object = Json.CreateObject();
field_object->set("name", field_name, JSON_STRING);
field_object->set("value", field_value, JSON_STRING);
field_object->set("verified_at", NULL, JSON_NULL);
fields_array->append(Json.CreateItem(field_object, JSON_OBJECT));
field_name = NULL;
field_value = NULL;
}
key = key->next;
}
}
}
acct->set("fields", fields_array, JSON_ARRAY);
source->set("fields", acct->@("fields"), JSON_ARRAY);
@slon_db_save_accounts_to_disk;
@slon_db_actors_update_user(acct);
@slon_http_send_json(session, acct);
} else {
@slon_http_set_status_code(session, 401);
}
} else {
@slon_http_set_status_code(session, 404);
}
slon_api_v1_accounts_patch_return:
@slon_free(session, path);
}

73
Slon/Api/V1/Apps.HC Normal file
View file

@ -0,0 +1,73 @@
U8* @slon_api_v1_apps_generate_app_id(SlonHttpSession* session)
{
U8* app_id = @slon_calloc(session, 16);
I64 i;
for (i = 0; i < 6; i++) {
String.Append(app_id, "%d", RandU64 % 10);
}
return app_id;
}
U8* @slon_api_v1_apps_generate_client_id(SlonHttpSession* session)
{
U8* client_id = NULL;
Bool client_id_exists = TRUE;
while (client_id_exists) {
if (client_id)
@slon_free(session, client_id);
client_id = @slon_api_generate_random_hex_string(session, 16);
client_id_exists = db->o("apps")->@(client_id) > 0;
}
return client_id;
}
U8* @slon_api_v1_apps_generate_client_secret(SlonHttpSession* session)
{
return @slon_api_generate_random_hex_string(session, 32);
}
U0 @slon_api_v1_apps_post(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer;
U8* id = @slon_api_v1_apps_generate_app_id(session);
U8* client_id = @slon_api_v1_apps_generate_client_id(session);
U8* client_secret = @slon_api_v1_apps_generate_client_secret(session);
I64 request_scopes_count = 0;
U8** request_scopes = NULL;
if (StrFind("+", request_json->@("scopes")) > 0) {
request_scopes = String.Split(request_json->@("scopes"), '+', &request_scopes_count);
} else {
request_scopes = String.Split(request_json->@("scopes"), ' ', &request_scopes_count);
}
JsonArray* scopes = Json.CreateArray();
I64 i;
for (i = 0; i < request_scopes_count; i++) {
scopes->append(Json.CreateItem(request_scopes[i], JSON_STRING));
}
JsonArray* redirect_uris = Json.CreateArray();
redirect_uris->append(Json.CreateItem(request_json->@("redirect_uris"), JSON_STRING));
JsonObject* credential_app = Json.CreateObject();
credential_app->set("id", id, JSON_STRING);
credential_app->set("name", request_json->@("client_name"), JSON_STRING);
credential_app->set("website", request_json->@("website"), JSON_STRING);
credential_app->set("scopes", scopes, JSON_ARRAY);
credential_app->set("redirect_uris", redirect_uris, JSON_ARRAY);
credential_app->set("redirect_uri", request_json->@("redirect_uris"), JSON_STRING);
credential_app->set("client_id", client_id, JSON_STRING);
credential_app->set("client_secret", client_secret, JSON_STRING);
credential_app->set("client_secret_expires_at", "0", JSON_STRING);
db->o("apps")->set(client_id, credential_app, JSON_OBJECT);
@slon_db_save_apps_to_disk;
@slon_http_send_json(session, credential_app);
@slon_free(session, id);
@slon_free(session, client_id);
@slon_free(session, client_secret);
}

12
Slon/Api/V1/Blocks.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_blocks_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/Bookmarks.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_bookmarks_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/Conversations.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_conversations_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/CustomEmojis.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_custom_emojis_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/Favourites.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_favourites_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/Filters.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_filters_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/FollowRequests.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_follow_requests_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/FollowedTags.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_followed_tags_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

16
Slon/Api/V1/Notifications.HC Normal file
View file

@ -0,0 +1,16 @@
U0 @slon_api_v1_notifications_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
if (String.EndsWith("policy", @slon_http_request_path(session))) {
@slon_http_send_json(session, SLON_EMPTY_JSON_OBJECT);
} else {
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
}
} else {
@slon_http_set_status_code(session, 401);
}
}

144
Slon/Api/V1/Statuses.HC Normal file
View file

@ -0,0 +1,144 @@
U0 (*@slon_api_status_create_fedi)(JsonObject* status) = NULL;
U0 (*@slon_api_status_delete_fedi)(JsonObject* status) = NULL;
U0 @slon_api_v1_statuses_delete(SlonHttpSession* session)
{
if (@slon_api_authorized(session)) {
SLON_AUTH_ACCOUNT_ID
JsonArray* statuses = db->o("statuses")->a(account_id);
if (!statuses || !statuses->length) {
@slon_http_send_json(session, SLON_EMPTY_JSON_OBJECT);
return;
}
U8* path = @slon_strnew(session, @slon_http_request_path(session));
I64 path_segments_count = 0;
U8** path_segments = String.Split(path, '/', &path_segments_count);
if (path_segments_count < 4) {
goto slon_api_v1_statuses_delete_return;
}
U8* id = path_segments[3];
JsonObject* status;
I64 i;
for (i = 0; i < statuses->length; i++) {
status = statuses->@(i);
if (!StrICmp(status->@("id"), id)) {
status->set("deleted", TRUE, JSON_BOOLEAN);
@slon_db_save_statuses_to_disk;
@slon_db_instance_decrement_status_count;
@slon_db_save_instance_to_disk;
if (@slon_api_status_delete_fedi) {
@slon_api_status_delete_fedi(Json.Clone(status));
}
goto slon_api_v1_statuses_delete_return;
}
}
slon_api_v1_statuses_delete_return:
Free(path_segments);
@slon_free(session, path);
@slon_http_send_json(session, SLON_EMPTY_JSON_OBJECT);
} else {
@slon_http_set_status_code(session, 401);
}
}
U0 @slon_api_v1_statuses_post(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
SLON_AUTH_ACCOUNT_ID
Bool idempotency_key_already_seen = FALSE;
U8* idempotency_key = @slon_http_request_header(session, "idempotency-key");
if (StrLen(idempotency_key) > 0 && db->o("idempotency_keys")->@(idempotency_key)) {
idempotency_key_already_seen = TRUE;
}
if (!idempotency_key_already_seen) {
Json.Set(db->o("idempotency_keys"), idempotency_key, Now, JSON_NUMBER);
}
U8* id = @slon_api_generate_unique_id(session);
U8* created_at = @slon_api_timestamp_from_cdate(session, Now);
JsonObject* app_object = db->o("apps")->@(Json.Get(session->auth, "client_id"));
JsonObject* status_app = Json.CreateObject();
status_app->set("name", app_object->@("name"), JSON_STRING);
status_app->set("website", app_object->@("website"), JSON_STRING);
JsonObject* account_object = Json.Clone(@slon_api_account_by_id(account_id));
account_object->unset("source");
// U8* language = request_json->@("language");
U8* username = account_object->@("username");
Bool sensitive = request_json->@("sensitive") > 0;
U8* in_reply_to_id = request_json->@("in_reply_to_id");
U8* visibility = request_json->@("visibility");
if (!StrLen(visibility)) {
visibility = "public";
}
StrPrint(scratch_buffer, "https://%s/users/%s/statuses/%s", db->o("instance")->@("uri"), username, id);
U8* uri = @slon_strnew(session, scratch_buffer);
StrPrint(scratch_buffer, "https://%s/@%s/%s", db->o("instance")->@("uri"), username, id);
U8* url = @slon_strnew(session, scratch_buffer);
// Mona lets us post with: id, created_at, content, visibility, uri, url, account, application
// Mastodon iOS app lets us post with +: reblogs_count, favourites_count, emojis, tags, mentions
// IceCubesApp lets us post with +: media_attachments, replies_count, spoiler_text, sensitive
JsonObject* status = Json.CreateObject();
status->set("id", id, JSON_STRING);
status->set("created_at", created_at, JSON_STRING);
status->set("content", request_json->@("status"), JSON_STRING);
status->set("visibility", visibility, JSON_STRING);
status->set("uri", uri, JSON_STRING);
status->set("url", url, JSON_STRING);
status->set("account", account_object, JSON_OBJECT);
status->set("application", status_app, JSON_OBJECT);
status->set("reblogs_count", 0, JSON_NUMBER);
status->set("favourites_count", 0, JSON_NUMBER);
status->set("emojis", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
status->set("tags", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
status->set("mentions", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
status->set("media_attachments", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
status->set("replies_count", 0, JSON_NUMBER);
status->set("spoiler_text", "", JSON_STRING);
status->set("sensitive", sensitive, JSON_BOOLEAN);
if (StrLen(in_reply_to_id) > 0) {
status->set("in_reply_to_id", in_reply_to_id, JSON_STRING);
}
if (!idempotency_key_already_seen) {
db->o("statuses")->a(account_id)->append(Json.CreateItem(status, JSON_OBJECT));
@slon_db_save_statuses_to_disk;
@slon_db_instance_increment_status_count;
@slon_db_save_instance_to_disk;
if (@slon_api_status_create_fedi) {
@slon_api_status_create_fedi(Json.Clone(status));
}
}
@slon_http_send_json(session, status);
Json.Delete(status_app);
Json.Delete(account_object);
Json.Delete(app_object);
@slon_free(session, uri);
@slon_free(session, url);
@slon_free(session, id);
@slon_free(session, created_at);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V1/Timelines.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v1_timelines_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

12
Slon/Api/V2/Filters.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v2_filters_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

9
Slon/Api/V2/Instance.HC Normal file
View file

@ -0,0 +1,9 @@
U0 @slon_api_v2_instance_get(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn request_json;
StrPrint(scratch_buffer, "{\"domain\":\"%s\"}", db->o("instance")->@("uri"));
@slon_http_set_content_type(session, "application/json; charset=utf-8");
@slon_http_send_string(session, scratch_buffer);
}

12
Slon/Api/V2/Suggestions.HC Normal file
View file

@ -0,0 +1,12 @@
U0 @slon_api_v2_suggestions_get(SlonHttpSession* session)
{
// SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (@slon_api_authorized(session)) {
// SLON_AUTH_ACCOUNT_ID
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_ARRAY);
} else {
@slon_http_set_status_code(session, 401);
}
}

4
Slon/Endpoints/Delete/Statuses.HC Normal file
View file

@ -0,0 +1,4 @@
if (String.BeginsWith("/api/v1/statuses", @slon_http_request_path(session))) {
@slon_api_v1_statuses_delete(session);
return;
}

4
Slon/Endpoints/Get/Accounts.HC Normal file
View file

@ -0,0 +1,4 @@
if (String.BeginsWith("/api/v1/accounts", @slon_http_request_path(session))) {
@slon_api_v1_accounts_get(session);
return;
}

4
Slon/Endpoints/Get/ActivityPub.HC Normal file
View file

@ -0,0 +1,4 @@
if (String.BeginsWith("/users/", @slon_http_request_path(session)) && String.EndsWith("json", @slon_http_request_header(session, "accept"))) {
@slon_activitypub_users_get(session);
return;
}

4
Slon/Endpoints/Get/Blocks.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/blocks", @slon_http_request_path(session))) {
@slon_api_v1_blocks_get(session);
return;
}

4
Slon/Endpoints/Get/Bookmarks.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/bookmarks", @slon_http_request_path(session))) {
@slon_api_v1_bookmarks_get(session);
return;
}

4
Slon/Endpoints/Get/Conversations.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/conversations", @slon_http_request_path(session))) {
@slon_api_v1_conversations_get(session);
return;
}

4
Slon/Endpoints/Get/CustomEmojis.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/custom_emojis", @slon_http_request_path(session))) {
@slon_api_v1_custom_emojis_get(session);
return;
}

4
Slon/Endpoints/Get/Favourites.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/favourites", @slon_http_request_path(session))) {
@slon_api_v1_favourites_get(session);
return;
}

9
Slon/Endpoints/Get/Filters.HC Normal file
View file

@ -0,0 +1,9 @@
if (!StrICmp("/api/v1/filters", @slon_http_request_path(session))) {
@slon_api_v1_filters_get(session);
return;
}
if (!StrICmp("/api/v2/filters", @slon_http_request_path(session))) {
@slon_api_v2_filters_get(session);
return;
}

4
Slon/Endpoints/Get/FollowRequests.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/follow_requests", @slon_http_request_path(session))) {
@slon_api_v1_follow_requests_get(session);
return;
}

4
Slon/Endpoints/Get/FollowedTags.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/followed_tags", @slon_http_request_path(session))) {
@slon_api_v1_followed_tags_get(session);
return;
}

9
Slon/Endpoints/Get/Instance.HC Normal file
View file

@ -0,0 +1,9 @@
if (!StrICmp("/api/v1/instance", @slon_http_request_path(session))) {
@slon_http_send_json(session, db->o("instance"));
return;
}
if (!StrICmp("/api/v2/instance", @slon_http_request_path(session))) {
@slon_api_v2_instance_get(session);
return;
}

4
Slon/Endpoints/Get/Notifications.HC Normal file
View file

@ -0,0 +1,4 @@
if (String.BeginsWith("/api/v1/notifications", @slon_http_request_path(session))) {
@slon_api_v1_notifications_get(session);
return;
}

9
Slon/Endpoints/Get/OAuth.HC Normal file
View file

@ -0,0 +1,9 @@
if (!StrICmp("/oauth/authorize", @slon_http_request_path(session))) {
@slon_http_send_html_file(session, "M:/Slon/Static/oauth/authorize.html");
return;
}
if (!StrICmp("/oauth/verify_access", @slon_http_request_path(session))) {
@slon_oauth_verify_access_get(session);
return;
}

4
Slon/Endpoints/Get/Suggestions.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v2/suggestions", @slon_http_request_path(session))) {
@slon_api_v2_suggestions_get(session);
return;
}

4
Slon/Endpoints/Get/Timelines.HC Normal file
View file

@ -0,0 +1,4 @@
if (String.BeginsWith("/api/v1/timelines", @slon_http_request_path(session))) {
@slon_api_v1_timelines_get(session);
return;
}

28
Slon/Endpoints/Get/Web.HC Normal file
View file

@ -0,0 +1,28 @@
if (String.EndsWith(".css", @slon_http_request_path(session))) {
@slon_http_set_content_type(session, "text/css");
@slon_http_send_file(session, "M:/Slon/Static/css/main.css");
return;
}
if (!StrICmp("/js/header.js", @slon_http_request_path(session))) {
@slon_http_set_content_type(session, "text/javascript");
@slon_http_send_file(session, "M:/Slon/Static/js/header.js");
return;
}
if (String.EndsWith(".js", @slon_http_request_path(session))) {
@slon_http_set_content_type(session, "text/javascript");
@slon_http_send_file(session, "M:/Slon/Static/js/statuses.js");
return;
}
if (!StrICmp("/alec.png", @slon_http_request_path(session))) {
@slon_http_set_content_type(session, "image/png");
@slon_http_send_file(session, "A:/avatar-circle-4bpp.png");
return;
}
if (String.BeginsWith("/@", @slon_http_request_path(session))) {
@slon_web_user_get(session);
return;
}

14
Slon/Endpoints/Get/WellKnown.HC Normal file
View file

@ -0,0 +1,14 @@
if (!StrICmp("/.well-known/host-meta", @slon_http_request_path(session))) {
@slon_host_meta(session);
return;
}
if (!StrICmp("/.well-known/oauth-authorization-server", @slon_http_request_path(session))) {
@slon_oauth_well_known(session);
return;
}
if (!StrICmp("/.well-known/webfinger", @slon_http_request_path(session))) {
@slon_webfinger(session);
return;
}

4
Slon/Endpoints/Patch/Accounts.HC Normal file
View file

@ -0,0 +1,4 @@
if (String.BeginsWith("/api/v1/accounts", @slon_http_request_path(session))) {
@slon_api_v1_accounts_patch(session);
return;
}

4
Slon/Endpoints/Post/ActivityPub.HC Normal file
View file

@ -0,0 +1,4 @@
if (String.BeginsWith("/users/", @slon_http_request_path(session))) {
@slon_activitypub_users_post(session);
return;
}

4
Slon/Endpoints/Post/Apps.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/apps", @slon_http_request_path(session))) {
@slon_api_v1_apps_post(session);
return;
}

4
Slon/Endpoints/Post/OAuth.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/oauth/token", @slon_http_request_path(session))) {
@slon_oauth_token_post(session);
return;
}

4
Slon/Endpoints/Post/Statuses.HC Normal file
View file

@ -0,0 +1,4 @@
if (!StrICmp("/api/v1/statuses", @slon_http_request_path(session))) {
@slon_api_v1_statuses_post(session);
return;
}

394
Slon/Http/AdminServer.HC Normal file
View file

@ -0,0 +1,394 @@
U0 @slon_admin_html_form_from_json_object(SlonHttpSession* session, U8* buf, JsonObject* o)
{
if (!session || !buf || !o)
return;
JsonKey* key = o->keys;
String.Append(buf, "<table>");
while (key) {
switch (key->type) {
case JSON_BOOLEAN:
case JSON_STRING:
case JSON_NUMBER:
String.Append(buf, "<tr><td><label>%s</label></td><td>", key->name);
break;
default:
break;
}
switch (key->type) {
case JSON_BOOLEAN:
String.Append(buf, "<input name=%s type=checkbox %s>", key->name, @t(key->value, "checked", ""));
break;
case JSON_STRING:
String.Append(buf, "<input name=%s type=text value=\"%s\" required>", key->name, key->value);
break;
case JSON_NUMBER:
String.Append(buf, "<input name=%s type=text value=\"%d\" required>", key->name, ToI64(key->value));
break;
default:
break;
}
String.Append(buf, "</td></tr>");
key = key->next;
}
String.Append(buf, "</table>");
}
U0 @slon_admin_create_ap_actor(SlonHttpSession* session, JsonObject* acct)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
JsonObject* actors = db->o("actors");
U8* domain = db->o("instance")->@("uri");
U8* username = acct->@("username");
JsonObject* actor = Json.Clone(SLON_DEFAULT_ACTOR_OBJECT);
StrPrint(scratch_buffer, "https://%s/users/%s", domain, username);
actor->set("id", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s/following", domain, username);
actor->set("following", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s/followers", domain, username);
actor->set("followers", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s/inbox", domain, username);
actor->set("inbox", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s/outbox", domain, username);
actor->set("outbox", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s/collections/featured", domain, username);
actor->set("featured", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s/collections/tags", domain, username);
actor->set("featuredTags", scratch_buffer, JSON_STRING);
actor->set("preferredUsername", username, JSON_STRING);
actor->set("name", acct->@("display_name"), JSON_STRING);
actor->set("summary", acct->@("note"), JSON_STRING);
JsonObject* icon = Json.Parse("{\"type\":\"Image\"}");
icon->set("url", acct->@("avatar"), JSON_STRING);
actor->set("icon", icon, JSON_OBJECT);
StrPrint(scratch_buffer, "https://%s/@%s", domain, username);
actor->set("url", scratch_buffer, JSON_STRING);
actor->set("published", acct->@("created_at"), JSON_STRING);
actor->set("attachment", acct->@("fields"), JSON_ARRAY);
actor->set("accountId", acct->@("id"), JSON_STRING);
db->o("private_keys")->set(username, request_json->@("privatekey"), JSON_STRING);
JsonObject* publickey = Json.CreateObject();
StrPrint(scratch_buffer, "https://%s/users/%s#main-key", domain, username);
publickey->set("id", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s", domain, username);
publickey->set("owner", scratch_buffer, JSON_STRING);
I64 x;
publickey->set("publicKeyPem", @base64_decode(request_json->@("publickey"), &x), JSON_STRING);
actor->set("publicKey", publickey, JSON_OBJECT);
actors->set(acct->@("username"), actor, JSON_OBJECT);
@slon_db_save_to_disk;
}
U0 @slon_admin_create_account(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
U8* id = @slon_api_generate_unique_id(session);
U8* created_at = @slon_api_timestamp_from_cdate(session, Now);
JsonObject* acct = Json.CreateObject();
JsonObject* source = Json.CreateObject();
acct->set("id", id, JSON_STRING);
acct->set("created_at", created_at, JSON_STRING);
acct->set("username", request_json->@("username"), JSON_STRING);
acct->set("acct", request_json->@("username"), JSON_STRING);
acct->set("display_name", request_json->@("display_name"), JSON_STRING);
acct->set("email", request_json->@("email"), JSON_STRING);
acct->set("note", request_json->@("bio"), JSON_STRING);
acct->set("avatar", request_json->@("avatar"), JSON_STRING);
acct->set("header", request_json->@("header"), JSON_STRING);
acct->set("avatar_static", acct->@("avatar"), JSON_STRING);
acct->set("header_static", acct->@("header"), JSON_STRING);
acct->set("last_status_at", "0", JSON_STRING);
acct->set("followers_count", 0, JSON_NUMBER);
acct->set("following_count", 0, JSON_NUMBER);
acct->set("statuses_count", 0, JSON_NUMBER);
acct->set("locked", FALSE, JSON_BOOLEAN);
acct->set("bot", FALSE, JSON_BOOLEAN);
acct->set("discoverable", FALSE, JSON_BOOLEAN);
acct->set("indexable", FALSE, JSON_BOOLEAN);
acct->set("hide_collections", FALSE, JSON_BOOLEAN);
acct->set("emojis", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
acct->set("fields", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
source->set("privacy", "public", JSON_STRING);
source->set("sensitive", FALSE, JSON_BOOLEAN);
source->set("language", "", JSON_STRING);
source->set("note", acct->@("note"), JSON_STRING);
source->set("fields", acct->@("fields"), JSON_ARRAY);
source->set("follow_requests_count", 0, JSON_NUMBER);
acct->set("source", source, JSON_OBJECT);
StrPrint(scratch_buffer, "https://%s/@%s", db->o("instance")->@("uri"), acct->@("username"));
acct->set("url", scratch_buffer, JSON_STRING);
db->a("accounts")->append(Json.CreateItem(acct, JSON_OBJECT));
db->o("statuses")->set(acct->@("id"), Json.CreateArray(), JSON_ARRAY);
@slon_admin_create_ap_actor(session, acct);
@slon_db_instance_update_user_count;
@slon_db_save_to_disk;
@slon_free(session, created_at);
@slon_free(session, id);
}
U0 @slon_admin_settings_accounts_new_get(SlonHttpSession* session, U8* buf)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer, request_json;
String.Append(buf, "settings/accounts/new");
String.Append(buf, "<br><br><form action=/settings/accounts/new/save>");
@slon_admin_html_form_from_json_object(session, buf, SLON_DEFAULT_ACCT_OBJECT);
String.Append(buf, "<br><br><input id=save type=submit value=Save></form>");
}
U0 @slon_admin_settings_accounts_get(SlonHttpSession* session, U8* buf)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer, request_json;
String.Append(buf, "settings/accounts");
String.Append(buf, "<br><br><table><tr><th>id</th><th>username</th></tr>");
JsonArray* arr = db->a("accounts");
JsonObject* acct;
I64 i;
for (i = 0; i < arr->length; i++) {
acct = arr->@(i);
if (acct) {
String.Append(buf, "<tr><td>%s</td><td>%s</td></tr>", acct->@("id"), acct->@("username"));
}
}
String.Append(buf, "</table><br><br><button onclick=\"window.location='/settings/accounts/new'\">New</button>");
}
U0 @slon_admin_settings_apps_get(SlonHttpSession* session, U8* buf)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer, request_json;
String.Append(buf, "settings/apps");
String.Append(buf, "<br><br>");
U8* tmp = Json.Stringify(db->o("apps"));
String.Append(buf, tmp);
Free(tmp);
}
U0 @slon_admin_settings_oauth_get(SlonHttpSession* session, U8* buf)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer, request_json;
String.Append(buf, "settings/oauth");
String.Append(buf, "<br><br>");
U8* tmp = Json.Stringify(db->o("oauth"));
String.Append(buf, tmp);
Free(tmp);
}
U0 @slon_admin_settings_instance_save_get(SlonHttpSession* session, U8* buf)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer;
JsonObject* instance = db->o("instance");
instance->set("uri", request_json->@("uri"));
instance->set("title", request_json->@("title"));
instance->set("short_description", request_json->@("short_description"));
instance->set("description", request_json->@("description"));
instance->set("email", request_json->@("email"));
instance->set("version", request_json->@("version"));
if (!request_json->@("registrations")) {
instance->set("registrations", FALSE);
} else {
instance->set("registrations", !StrICmp("on", request_json->@("registrations")));
}
String.Append(buf, "<script>window.location='/settings/instance';</script>");
}
U0 @slon_admin_settings_instance_get(SlonHttpSession* session, U8* buf)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer, request_json;
String.Append(buf, "settings/instance");
String.Append(buf, "<br><br><form action=/settings/instance/save>");
@slon_admin_html_form_from_json_object(session, buf, db->o("instance"));
String.Append(buf, "<br><br><input type=submit value=Save></form>");
}
U0 @slon_admin_new_account(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
if (db->o("actors")->@(request_json->@("username"))) {
StrPrint(scratch_buffer, "{\"error\":\"account already exists\"}");
@slon_http_set_content_type(session, "application/json");
@slon_http_send(session, scratch_buffer, StrLen(scratch_buffer));
} else {
@slon_admin_create_account(session);
@slon_http_send_json(session, SLON_EMPTY_JSON_OBJECT);
}
}
U0 @slon_admin_manage_accounts(SlonHttpSession* session)
{
@slon_http_send_json(session, db->a("accounts"));
}
U0 @slon_admin_info_stats(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn request_json;
StrPrint(scratch_buffer, "{");
String.Append(scratch_buffer, "\"uptime\":\"%d\"", cnts.jiffies);
String.Append(scratch_buffer, "}");
@slon_http_set_content_type(session, "application/json");
@slon_http_send(session, scratch_buffer, StrLen(scratch_buffer));
}
U0 @slon_admin_server_get(SlonHttpSession* session)
{
if (!db->@("setup")) {
if (StrICmp("/", @slon_http_request_path(session))) {
@slon_http_set_status_code(session, 302);
@slon_http_set_header(session, "Location", "/");
} else {
@slon_http_send_html_file(session, "M:/Slon/Static/html/admin/setup_instance.html");
}
return;
}
if (!StrICmp("/info/stats", @slon_http_request_path(session))) {
@slon_admin_info_stats(session);
return;
}
if (!StrICmp("/manage/accounts", @slon_http_request_path(session))) {
@slon_admin_manage_accounts(session);
return;
}
if (!StrICmp("/", @slon_http_request_path(session))) {
@slon_http_send_html_file(session, "M:/Slon/Static/html/admin/main.html");
return;
}
@slon_http_set_status_code(session, 404);
}
U0 @slon_admin_setup_instance(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer;
JsonObject* instance = db->o("instance");
instance->set("uri", request_json->@("uri"));
instance->set("title", request_json->@("title"));
instance->set("short_description", request_json->@("description"));
instance->set("description", request_json->@("description"));
instance->set("email", request_json->@("email"));
instance->set("registrations", request_json->@("registrations"));
@slon_db_save_to_disk;
db->set("setup", TRUE);
@slon_http_send_json(session, SLON_EMPTY_JSON_OBJECT);
}
U0 @slon_admin_server_post(SlonHttpSession* session)
{
if (StrFind("json", @slon_http_request_header(session, "content-type")) > 0) {
@slon_http_parse_request_as_json(session);
}
if (!StrICmp("/setup/instance", @slon_http_request_path(session))) {
@slon_admin_setup_instance(session);
return;
}
if (!StrICmp("/new/account", @slon_http_request_path(session))) {
@slon_admin_new_account(session);
return;
}
@slon_http_set_status_code(session, 404);
}
U0 @slon_admin_http_handle_get_request(SlonHttpSession* session)
{
if (@slon_http_request_has_query_string(session)) {
@slon_http_parse_query_string(session);
}
@slon_admin_server_get(session);
}
U0 @slon_admin_http_handle_post_request(SlonHttpSession* session)
{
@slon_admin_server_post(session);
}
U0 @slon_admin_http_handle_request(SlonHttpSession* session)
{
switch (@slon_http_request_verb(session)) {
case SLON_HTTP_VERB_GET:
@slon_admin_http_handle_get_request(session);
break;
case SLON_HTTP_VERB_POST:
@slon_admin_http_handle_post_request(session);
break;
default:
@slon_http_set_status_code(session, 405);
}
}
U0 @slon_admin_http_task(TcpSocket* s)
{
// Bail if we can't acquire socket for some reason
if (!@tcp_socket_accept(s))
return;
// Init session
SlonHttpSession* session = @slon_http_init_session(s);
// Parse headers if they are available
while (!@slon_http_request_headers_have_been_parsed(session)) {
@slon_http_receive(session);
// Handle malformed requests (anything less than "GET / HTTP/1.0\r\n\r\n" is probably a bad request)
if (session->request->buffer->size < 18) {
@slon_http_set_status_code(session, 400);
goto slon_admin_http_task_send_response;
}
@slon_http_try_parse_request_headers(session);
}
// If we have a content-length header, consume until we receive all the data, then set request->data pointer and size
if (StrLen(@slon_http_request_header(session, "content-length"))) {
I64 content_length = Str2I64(@slon_http_request_header(session, "content-length"));
while (session->request->buffer->data + session->request->buffer->size - session->request->data < content_length)
@slon_http_receive(session);
}
@slon_admin_http_handle_request(session);
slon_admin_http_task_send_response:
@slon_http_send_response(session);
@slon_http_free_session(session);
s->close();
}
Adam("U0 @spawn_slon_admin_http_task(TcpSocket *s){Spawn(%d, s, \"SlonAdminHttpTask\");};\n", &@slon_admin_http_task);
@tcp_socket_bind(9000, "@spawn_slon_admin_http_task");

232
Slon/Http/LocalServer.HC Normal file
View file

@ -0,0 +1,232 @@
U0 @slon_local_server_set_mime_type(SlonHttpSession* session, U8* filepath)
{
// FIXME: Do this programmatically like the Jakt version, this is awful
if (String.EndsWith(".html", filepath)) {
@slon_http_set_content_type(session, "text/html");
return;
}
if (String.EndsWith(".txt", filepath)) {
@slon_http_set_content_type(session, "text/plain");
return;
}
if (String.EndsWith(".css", filepath)) {
@slon_http_set_content_type(session, "text/css");
return;
}
if (String.EndsWith(".js", filepath)) {
@slon_http_set_content_type(session, "text/javascript");
return;
}
if (String.EndsWith(".json", filepath)) {
@slon_http_set_content_type(session, "application/json");
return;
}
if (String.EndsWith(".gif", filepath)) {
@slon_http_set_content_type(session, "image/gif");
return;
}
if (String.EndsWith(".png", filepath)) {
@slon_http_set_content_type(session, "image/png");
return;
}
if (String.EndsWith(".jpeg", filepath) || String.EndsWith(".jpg", filepath)) {
@slon_http_set_content_type(session, "image/jpeg");
return;
}
@slon_http_set_content_type(session, "application/octet-stream");
}
U0 @slon_local_server_send_file(SlonHttpSession* session, U8* filepath)
{
@slon_local_server_set_mime_type(session, filepath);
@slon_http_send_file(session, filepath);
}
U0 @slon_local_server_directory_listing(SlonHttpSession* session, U8* path)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn request_json;
U8* html = @slon_calloc(session, 1048576);
String.Append(html, "<html><head><title>Index of ");
String.Append(html, path);
String.Append(html, "</title><style type=text/css>.img-back{content:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAWCAMAAAD3n0w0AAAAElBMVEX////M//+ZmZlmZmYzMzMAAACei5rnAAAAAnRSTlP/AOW3MEoAAABVSURBVHjabdFBCsBACENR45j7X7kQtC0T//KRjRhYevGgyjBL+VLZUtlS2VItS1AI1QQONgNZHCSUZJAc+ZB3sViFGzPcDmxZqdsvgRB/aJRu73D0HuO2BJfZn2SOAAAAAElFTkSuQmCC)} .img-folder{content:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAWCAMAAAD3n0w0AAAAElBMVEX/////zJnM//+ZZjMzMzMAAADCEvqoAAAAA3RSTlP//wDXyg1BAAAASElEQVR42s3KAQbAQAxE0W4m//5XboesdihQ6A/ES4566TsyPZE1caNtwmFE22bBuDTtG8ZMaoyZ8Z+fijEWytpYdEZfWGRdJzEsA9OaTRTxAAAAAElFTkSuQmCC)} .img-file{content:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAWCAMAAAD3n0w0AAAAD1BMVEX////M//+ZmZkzMzMAAABVsTOVAAAAAnRSTlP/AOW3MEoAAAA6SURBVHja3cjHAcAwEIRATqj/lp3jWhUYfoPPag+5EkeII8QRYmB3O3ArENrSB0k8+ivaXrliVY+qZm7SAaxLXnOsAAAAAElFTkSuQmCC)}</style></head><body><h1>Index of ");
String.Append(html, path);
String.Append(html, "</h1><table>");
String.Append(html, "<tr><th></th><th align=left style=padding-right:16px>Name</th><th align=left>Last modified</th><th align=right>Size</th></tr>");
String.Append(html, "<tr><th colspan=4><hr></th></tr>");
StrPrint(scratch_buffer, "A:%s*", path);
CDirEntry* files = FilesFind(scratch_buffer);
CDirEntry* de = files->next;
CDateStruct ds;
while (de) {
String.Append(html, "<tr><td><a href=\"");
String.Append(html, de->name);
String.Append(html, "\">");
if (!StrICmp("..", de->name)) {
String.Append(html, "<img class=img-back alt=Back>");
} else {
if (de->attr & RS_ATTR_DIR) {
String.Append(html, "<img class=img-folder alt=Folder>");
} else {
String.Append(html, "<img class=img-file alt=File>");
}
}
String.Append(html, "</a></td>");
String.Append(html, "<td><a href=\"");
String.Append(html, de->name);
if (de->attr & RS_ATTR_DIR) {
String.Append(html, "/");
}
String.Append(html, "\">");
if (!StrICmp("..", de->name)) {
String.Append(html, "Parent Directory");
} else {
String.Append(html, de->name);
}
String.Append(html, "</a></td><td align=right>");
Date2Struct(&ds, de->datetime);
String.Append(html, "%02d-%03tZ-%04d %02d:%02d", ds.day_of_mon, ds.mon - 1, "ST_MONTHS", ds.year, ds.hour, ds.min);
String.Append(html, " ");
String.Append(html, "</td><td align=right>");
if (de->attr & RS_ATTR_DIR) {
String.Append(html, " - ");
} else {
String.Append(html, "%d", de->size);
}
String.Append(html, "</td></tr>");
de = de->next;
}
DirTreeDel(files);
String.Append(html, "<tr><th colspan=4><hr></th></tr>");
String.Append(html, "</table>");
String.Append(html, "<address>Slon static file webserver for (TempleOS) Server</address>");
String.Append(html, "</body></html>");
@slon_http_set_content_type(session, "text/html");
@slon_http_send(session, html, StrLen(html));
@slon_free(session, html);
}
U0 @slon_local_server_not_found(SlonHttpSession* session)
{
@slon_http_set_status_code(session, 404);
@slon_http_set_content_type(session, "text/html");
@slon_http_send(session, "<h2>404 Not Found</h2>", 22);
}
U0 @slon_local_server_get(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn request_json;
U8* path = @slon_http_request_path(session);
if (!path || !StrLen(path) || StrFind(":", path) > 0) {
@slon_local_server_not_found(session);
return;
}
if (path[0] == '/' && StrLen(path) == 1) {
// Handle root path
if (FileFind("A:/index.html")) {
@slon_local_server_send_file(session, "A:/index.html");
} else {
@slon_local_server_directory_listing(session, "/");
}
return;
}
if (String.EndsWith("/", path)) {
StrPrint(scratch_buffer, "A:%sindex.html", path);
if (FileFind(scratch_buffer)) {
@slon_local_server_send_file(session, scratch_buffer);
} else {
StrPrint(scratch_buffer, "A:%s", path);
scratch_buffer[StrLen(scratch_buffer) - 1] = NULL;
if (IsDir(scratch_buffer)) {
@slon_local_server_directory_listing(session, path);
} else {
@slon_local_server_not_found(session);
}
}
return;
}
StrPrint(scratch_buffer, "A:%s", path);
if (!FileFind(scratch_buffer)) {
@slon_local_server_not_found(session);
return;
} else {
if (IsDir(scratch_buffer)) {
@slon_http_set_status_code(session, 301);
StrPrint(scratch_buffer, "%s/", path);
@slon_http_set_header(session, "Location", scratch_buffer);
} else {
@slon_local_server_send_file(session, scratch_buffer);
}
return;
}
// shouldn't get here :^)
@slon_http_set_status_code(session, 400);
}
U0 @slon_local_http_handle_get_request(SlonHttpSession* session)
{
@slon_local_server_get(session);
}
U0 @slon_local_http_handle_request(SlonHttpSession* session)
{
switch (@slon_http_request_verb(session)) {
case SLON_HTTP_VERB_GET:
@slon_local_http_handle_get_request(session);
break;
default:
@slon_http_set_status_code(session, 405);
}
}
U0 @slon_local_http_task(TcpSocket* s)
{
// Bail if we can't acquire socket for some reason
if (!@tcp_socket_accept(s))
return;
// Init session
SlonHttpSession* session = @slon_http_init_session(s);
// Parse headers if they are available
while (!@slon_http_request_headers_have_been_parsed(session)) {
@slon_http_receive(session);
// Handle malformed requests (anything less than "GET / HTTP/1.0\r\n\r\n" is probably a bad request)
if (session->request->buffer->size < 18) {
@slon_http_set_status_code(session, 400);
goto slon_local_http_task_send_response;
}
@slon_http_try_parse_request_headers(session);
}
// If we have a content-length header, consume until we receive all the data, then set request->data pointer and size
if (StrLen(@slon_http_request_header(session, "content-length"))) {
I64 content_length = Str2I64(@slon_http_request_header(session, "content-length"));
while (session->request->buffer->data + session->request->buffer->size - session->request->data < content_length)
@slon_http_receive(session);
}
@slon_local_http_handle_request(session);
slon_local_http_task_send_response:
@slon_http_send_response(session);
@slon_http_free_session(session);
s->close();
}
Adam("U0 @spawn_slon_local_http_task(TcpSocket *s){Spawn(%d, s, \"SlonLocalHttpTask\");};\n", &@slon_local_http_task);
@tcp_socket_bind(8000, "@spawn_slon_local_http_task");

542
Slon/Http/Server.HC Normal file
View file

@ -0,0 +1,542 @@
SlonHttpBuffer* @slon_http_init_buffer(SlonHttpSession* session)
{
SlonHttpBuffer* buffer = @slon_calloc(session, sizeof(SlonHttpBuffer));
buffer->data = @slon_calloc(session, SLON_HTTP_BUFFER_SIZE);
buffer->capacity = SLON_HTTP_BUFFER_SIZE;
return buffer;
}
U0 @slon_http_free_response(SlonHttpSession* session, SlonHttpResponse* response)
{
// FIXME: Free headers JsonObject
if (response) {
if (response->buffer && response->buffer->data) {
@slon_free(session, response->buffer->data);
@slon_free(session, response->buffer);
}
@slon_free(session, response);
}
}
U0 @slon_http_free_request(SlonHttpSession* session, SlonHttpRequest* request)
{
// FIXME: Free headers JsonObject
if (request) {
if (request->buffer && request->buffer->data) {
@slon_free(session, request->buffer->data);
@slon_free(session, request->buffer);
}
if (request->verb)
@slon_free(session, session->request->verb);
if (request->raw_path)
@slon_free(session, session->request->raw_path);
if (request->path)
@slon_free(session, session->request->path);
@slon_free(session, request);
}
}
U0 @slon_http_free_session(SlonHttpSession* session)
{
if (!session)
return;
@slon_http_free_response(session, session->response);
@slon_http_free_request(session, session->request);
I64 bytes_used = session->bytes_used - MSize2(session);
Free(session);
if (bytes_used) {
AdamLog("*** Session leaked %d bytes of memory ***\n", bytes_used);
}
}
SlonHttpRequest* @slon_http_init_request(SlonHttpSession* session)
{
SlonHttpRequest* request = @slon_calloc(session, sizeof(SlonHttpRequest));
request->buffer = @slon_http_init_buffer(session);
request->headers = Json.CreateObject();
return request;
}
SlonHttpResponse* @slon_http_init_response(SlonHttpSession* session)
{
SlonHttpResponse* response = @slon_calloc(session, sizeof(SlonHttpResponse));
response->buffer = @slon_http_init_buffer(session);
response->headers = Json.CreateObject();
return response;
}
SlonHttpSession* @slon_http_init_session(TcpSocket* s)
{
SlonHttpSession* session = CAlloc(sizeof(SlonHttpSession), adam_task);
session->bytes_used = MSize2(session);
session->s = s;
session->request = @slon_http_init_request(session);
session->response = @slon_http_init_response(session);
return session;
}
U0 @slon_http_receive(SlonHttpSession* session)
{
// FIXME: grow the buffer
SlonHttpBuffer* buffer = session->request->buffer;
I64 chunk_size = @tcp_socket_receive(session->s, buffer->data + buffer->size, 65536);
buffer->size += chunk_size;
}
Bool @slon_http_request_headers_have_been_parsed(SlonHttpSession* session)
{
return session->request->headers_have_been_parsed;
}
U0 @slon_http_buffer_append(SlonHttpBuffer* buffer, U8* src, I64 size)
{
if (!buffer || !src || !size)
return;
MemCpy(buffer->data + buffer->size, src, size);
buffer->size += size;
}
U0 @slon_http_buffer_append_string(SlonHttpBuffer* buffer, U8* str)
{
@slon_http_buffer_append(buffer, str, StrLen(str));
}
U0 @slon_http_send_response(SlonHttpSession* session)
{
SlonHttpBuffer* buffer = session->response->buffer;
U8 scratch_buffer[256][4];
StrPrint(scratch_buffer[0], "%d", session->response->status_code);
StrPrint(scratch_buffer[1], "HTTP/1.0 %d %s\r\n", session->response->status_code, Json.Get(SLON_HTTP_STATUS_CODES, scratch_buffer[0]));
@slon_http_buffer_append_string(buffer, scratch_buffer[1]);
JsonKey* key = session->response->headers->keys;
while (key) {
StrPrint(scratch_buffer[0], "%s: %s\r\n", key->name, key->value);
@slon_http_buffer_append_string(buffer, scratch_buffer[0]);
key = key->next;
}
StrPrint(scratch_buffer[0], "content-length: %d\r\n", session->response->size);
@slon_http_buffer_append_string(buffer, scratch_buffer[0]);
StrCpy(scratch_buffer[0], "pragma: no-cache\r\n\r\n");
@slon_http_buffer_append_string(buffer, scratch_buffer[0]);
if (session->response->data && session->response->size) {
@slon_http_buffer_append(buffer, session->response->data, session->response->size);
@slon_free(session, session->response->data);
}
@tcp_socket_send(session->s, buffer->data, buffer->size);
}
U0 @slon_http_rstrip_char_from_string(U8* str, I64 ch)
{
while (str[StrLen(str) - 1] == ch)
str[StrLen(str) - 1] = NULL;
}
U0 @slon_http_try_parse_request_headers(SlonHttpSession* session)
{
SlonHttpBuffer* buffer = session->request->buffer;
I64 i = 0;
// Do we have headers yet? let's find out
while (i < buffer->size) {
if (!MemCmp(buffer->data + i, "\r\n\r\n", 4)) {
i += 4;
goto slon_http_parse_request_headers;
}
++i;
}
return;
slon_http_parse_request_headers:
// Set pointer for request content
session->request->data = buffer->data + i;
// We have headers, let's parse them
U8* raw_headers = @slon_calloc(session, i);
MemCpy(raw_headers, buffer->data, i - 4);
I64 raw_header_lines_count = 0;
U8** raw_header_lines = String.Split(raw_headers, '\n', &raw_header_lines_count);
if (!raw_header_lines_count) {
// FIXME: Handle this
}
I64 request_first_line_segments_count = 0;
U8** request_first_line_segments = String.Split(raw_header_lines[0], ' ', &request_first_line_segments_count);
if (request_first_line_segments_count < 2) {
// FIXME: Handle this
}
session->request->verb = @slon_strnew(session, request_first_line_segments[0]);
session->request->raw_path = @slon_strnew(session, request_first_line_segments[1]);
if (StrFind("?", session->request->raw_path)) {
session->request->path = @slon_strnew(session, session->request->raw_path);
*(StrFind("?", session->request->path)) = NULL;
} else {
session->request->path = @slon_strnew(session, session->request->raw_path);
}
U8* key;
U8* value;
for (i = 1; i < raw_header_lines_count; i++) {
key = NULL;
value = NULL;
if (StrFind(": ", raw_header_lines[i])) {
value = StrFind(": ", raw_header_lines[i]) + 2;
@slon_http_rstrip_char_from_string(value, '\r');
*(StrFind(": ", raw_header_lines[i])) = NULL;
key = raw_header_lines[i];
Json.Set(session->request->headers, key, value, JSON_STRING);
}
}
@slon_free(session, raw_headers);
session->request->headers_have_been_parsed = TRUE;
}
U0 @slon_http_authorize(SlonHttpSession* session)
{
if (StrLen(@slon_http_request_header(session, "authorization"))) {
U8* access_token = StrFind(" ", @slon_http_request_header(session, "authorization")) + 1;
session->auth = db->o("oauth")->o("tokens")->@(access_token);
}
}
U0 @slon_http_debug_print_request(SlonHttpSession* session, Bool show_headers = FALSE)
{
AdamLog("[httpd] %d => request: %s %s\n", session->s, session->request->verb, session->request->raw_path);
if (show_headers) {
U8* headers_stringified = Json.Stringify(session->request->headers);
AdamLog("[httpd] %d => headers: %s\n", session->s, headers_stringified);
Free(headers_stringified);
//@slon_free(session, headers_stringified);
}
}
U0 @slon_http_debug_print_response(SlonHttpSession* session, Bool show_headers = FALSE)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn request_json;
StrPrint(scratch_buffer, "%d", session->response->status_code);
AdamLog("[httpd] %d <= response: %d %s\n", session->s, session->response->status_code, Json.Get(SLON_HTTP_STATUS_CODES, scratch_buffer));
if (show_headers) {
U8* headers_stringified = Json.Stringify(session->response->headers);
AdamLog("[httpd] %d <= headers: %s\n", session->s, headers_stringified);
Free(headers_stringified);
//@slon_free(session, headers_stringified);
}
if (session->response->data) {
AdamLog("data: %s\n", session->response->data);
}
}
U8* @slon_http_json_string_from_form_urlencoded_string(SlonHttpSession* session, U8* form_urlencoded_string)
{
// FIXME: Implement arrays, objects per https://jsonapi.org/format/#fetching
U8* json_string = @slon_calloc(session, StrLen(form_urlencoded_string) * 2);
String.Append(json_string, "{");
U8* form_urlencoded_string_copy = @slon_strnew(session, form_urlencoded_string);
I64 raw_values_count = 0;
U8** raw_values = String.Split(form_urlencoded_string_copy, '&', &raw_values_count);
I64 i = 0;
U8* key;
U8* value;
for (i = 0; i < raw_values_count; i++) {
value = StrFind("=", raw_values[i]) + 1;
*(StrFind("=", raw_values[i])) = NULL;
key = raw_values[i];
U8* decoded_value = @slon_http_decode_urlencoded_string(session, value);
String.Append(json_string, "\"%s\":\"%s\"", key, decoded_value);
@slon_free(session, decoded_value);
if (i < raw_values_count - 1) {
String.Append(json_string, ",");
}
}
String.Append(json_string, "}");
@slon_free(session, form_urlencoded_string_copy);
return json_string;
}
U8* @slon_http_json_string_from_multipart_form_data(SlonHttpSession* session, U8* multipart_form_data)
{
U8* json_string = @slon_calloc(session, StrLen(multipart_form_data) * 2);
String.Append(json_string, "{");
U8* multipart_form_data_copy = @slon_strnew(session, multipart_form_data);
U8* boundary = StrFind("boundary=", @slon_http_request_header(session, "content-type")) + 9;
// Strip begin double-quotes and ending CRLF, double-quotes
while (boundary[0] == '"')
boundary++;
while (boundary[StrLen(boundary) - 1] == '\"' || boundary[StrLen(boundary) - 1] == ' ' || boundary[StrLen(boundary) - 1] == '\r' || boundary[StrLen(boundary) - 1] == '\n')
boundary[StrLen(boundary) - 1] = NULL;
I64 state = SLON_MULTIPART_PARSER_CONSUME_BOUNDARY;
I64 lines_count = 0;
U8** lines = String.Split(multipart_form_data_copy, '\n', &lines_count);
U8* line;
U8* name;
U8* replace_line;
I64 i = 0;
while (i < lines_count) {
line = lines[i];
// Strip any ending CRLF
while (line[StrLen(line) - 1] == '\r' || line[StrLen(line) - 1] == '\n') {
line[StrLen(line) - 1] = NULL;
}
switch (state) {
case SLON_MULTIPART_PARSER_CONSUME_BOUNDARY:
if (StrFind(boundary, line)) {
state = SLON_MULTIPART_PARSER_CONSUME_CONTENT_DISPOSITION;
}
break;
case SLON_MULTIPART_PARSER_CONSUME_CONTENT_DISPOSITION:
if (StrFind("ontent-", line) && StrFind("isposition:", line) && StrFind("name=", line)) {
name = StrFind("name=", line) + 5;
// Strip begin/end double-quotes
while (name[0] == '"')
name++;
while (name[StrLen(name) - 1] == '\"')
name[StrLen(name) - 1] = NULL;
String.Append(json_string, "\"%s\":\"", name);
state = SLON_MULTIPART_PARSER_CONSUME_CONTENT;
}
break;
case SLON_MULTIPART_PARSER_CONSUME_CONTENT:
if (StrFind(boundary, line)) {
String.Append(json_string, "\"");
if (!String.EndsWith("--", line)) {
String.Append(json_string, ",");
state = SLON_MULTIPART_PARSER_CONSUME_CONTENT_DISPOSITION;
} else {
state = SLON_MULTIPART_PARSER_DONE;
}
} else {
replace_line = String.Replace(line, "\"", "\\\"");
String.Append(json_string, replace_line);
Free(replace_line);
}
break;
default:
break;
}
++i;
}
String.Append(json_string, "}");
@slon_free(session, multipart_form_data_copy);
return json_string;
}
U0 @slon_http_parse_query_string(SlonHttpSession* session)
{
U8* raw_path_copy = @slon_strnew(session, session->request->raw_path);
I64 raw_path_split_count = 0;
U8** raw_path_split = String.Split(raw_path_copy, '?', &raw_path_split_count);
if (raw_path_split_count > 1) {
U8* json_string = @slon_http_json_string_from_form_urlencoded_string(session, raw_path_split[1]);
session->request->json = Json.Parse(json_string);
@slon_free(session, json_string);
}
@slon_free(session, raw_path_copy);
}
U0 @slon_http_parse_request_as_form_urlencoded(SlonHttpSession* session)
{
U8* json_string = @slon_http_json_string_from_form_urlencoded_string(session, session->request->data);
session->request->json = Json.Parse(json_string);
@slon_free(session, json_string);
}
U0 @slon_http_parse_request_as_multipart_form_data(SlonHttpSession* session)
{
U8* json_string = @slon_http_json_string_from_multipart_form_data(session, session->request->data);
session->request->json = Json.Parse(json_string);
@slon_free(session, json_string);
}
U0 @slon_http_parse_request_as_json(SlonHttpSession* session)
{
session->request->json = Json.Parse(session->request->data);
}
U0 @slon_http_handle_delete_request(SlonHttpSession* session)
{
/* clang-format off */
#include "Endpoints/Delete/Statuses";
/* clang-format on */
// FIXME: Implement this
@slon_http_send_json(session, SLON_EMPTY_JSON_OBJECT);
}
U0 @slon_http_handle_get_request(SlonHttpSession* session)
{
if (@slon_http_request_has_query_string(session)) {
@slon_http_parse_query_string(session);
}
SLON_DEBUG_PRINT_REQUEST_JSON
/* clang-format off */
#include "Endpoints/Get/Accounts";
#include "Endpoints/Get/ActivityPub";
#include "Endpoints/Get/Blocks";
#include "Endpoints/Get/Bookmarks";
#include "Endpoints/Get/Conversations";
#include "Endpoints/Get/CustomEmojis";
#include "Endpoints/Get/Favourites";
#include "Endpoints/Get/Filters";
#include "Endpoints/Get/FollowRequests";
#include "Endpoints/Get/FollowedTags";
#include "Endpoints/Get/Instance";
#include "Endpoints/Get/Notifications";
#include "Endpoints/Get/OAuth";
#include "Endpoints/Get/Suggestions";
#include "Endpoints/Get/Timelines";
#include "Endpoints/Get/Web";
#include "Endpoints/Get/WellKnown";
/* clang-format on */
@slon_http_set_status_code(session, 404);
}
U0 @slon_http_handle_patch_request(SlonHttpSession* session)
{
if (StrFind("json", @slon_http_request_header(session, "content-type")) > 0) {
@slon_http_parse_request_as_json(session);
}
if (String.BeginsWith("application/x-www-form-urlencoded", @slon_http_request_header(session, "content-type"))) {
@slon_http_parse_request_as_form_urlencoded(session);
}
if (String.BeginsWith("multipart/form-data", @slon_http_request_header(session, "content-type"))) {
@slon_http_parse_request_as_multipart_form_data(session);
}
SLON_DEBUG_PRINT_REQUEST_JSON
/* clang-format off */
#include "Endpoints/Patch/Accounts";
/* clang-format on */
@slon_http_set_status_code(session, 404);
}
U0 @slon_http_handle_post_request(SlonHttpSession* session)
{
if (StrFind("json", @slon_http_request_header(session, "content-type")) > 0) {
@slon_http_parse_request_as_json(session);
}
if (String.BeginsWith("application/x-www-form-urlencoded", @slon_http_request_header(session, "content-type"))) {
@slon_http_parse_request_as_form_urlencoded(session);
}
if (String.BeginsWith("multipart/form-data", @slon_http_request_header(session, "content-type"))) {
@slon_http_parse_request_as_multipart_form_data(session);
}
// Workaround for IceCubesApp: https://github.com/Dimillian/IceCubesApp/issues/2235
if (!StrLen(@slon_http_request_header(session, "content-type")) && @slon_http_request_has_query_string(session)) {
@slon_http_parse_query_string(session);
}
SLON_DEBUG_PRINT_REQUEST_JSON
/* clang-format off */
#include "Endpoints/Post/ActivityPub";
#include "Endpoints/Post/Apps";
#include "Endpoints/Post/OAuth";
#include "Endpoints/Post/Statuses";
/* clang-format on */
@slon_http_set_status_code(session, 404);
}
U0 @slon_http_handle_request(SlonHttpSession* session)
{
// .purge_expired_idempotency_keys()
@slon_http_authorize(session);
switch (@slon_http_request_verb(session)) {
case SLON_HTTP_VERB_DELETE:
@slon_http_handle_delete_request(session);
break;
case SLON_HTTP_VERB_GET:
@slon_http_handle_get_request(session);
break;
case SLON_HTTP_VERB_OPTIONS:
@slon_http_set_status_code(session, 200);
break;
case SLON_HTTP_VERB_PATCH:
@slon_http_handle_patch_request(session);
break;
case SLON_HTTP_VERB_POST:
@slon_http_handle_post_request(session);
break;
default:
@slon_http_set_status_code(session, 405);
}
}
U0 @slon_http_task(TcpSocket* s)
{
// Bail if we can't acquire socket for some reason
if (!@tcp_socket_accept(s))
return;
// Init session
SlonHttpSession* session = @slon_http_init_session(s);
// Parse headers if they are available
while (!@slon_http_request_headers_have_been_parsed(session)) {
@slon_http_receive(session);
// Handle malformed requests (anything less than "GET / HTTP/1.0\r\n\r\n" is probably a bad request)
if (session->request->buffer->size < 18) {
@slon_http_set_status_code(session, 400);
goto slon_http_task_send_response;
}
@slon_http_try_parse_request_headers(session);
}
//@slon_http_debug_print_request(session, FALSE);
// If we have a content-length header, consume until we receive all the data, then set request->data pointer and size
if (StrLen(@slon_http_request_header(session, "content-length"))) {
I64 content_length = Str2I64(@slon_http_request_header(session, "content-length"));
while (session->request->buffer->data + session->request->buffer->size - session->request->data < content_length)
@slon_http_receive(session);
}
@slon_http_handle_request(session);
slon_http_task_send_response:
//@slon_http_debug_print_response(session, FALSE);
@slon_http_send_response(session);
@slon_http_free_session(session);
AdamLog("\n");
s->close();
}
Adam("U0 @spawn_slon_http_task(TcpSocket *s){Spawn(%d, s, \"SlonHttpTask\");};\n", &@slon_http_task);
@tcp_socket_bind(80, "@spawn_slon_http_task");

42
Slon/MakeSlon.HC Normal file
View file

@ -0,0 +1,42 @@
/* clang-format off */
DocMax(Fs);
WinMax(Fs);
#include "Modules/Log";
#include "Modules/Db";
#include "Modules/Http";
#include "Modules/Api";
#include "Api/V1/Accounts";
#include "Api/V1/Apps";
#include "Api/V1/Blocks";
#include "Api/V1/Bookmarks";
#include "Api/V1/Conversations";
#include "Api/V1/CustomEmojis";
#include "Api/V1/Favourites";
#include "Api/V1/Filters";
#include "Api/V1/FollowRequests";
#include "Api/V1/FollowedTags";
#include "Api/V1/Notifications";
#include "Api/V1/Statuses";
#include "Api/V1/Timelines";
#include "Api/V2/Filters";
#include "Api/V2/Instance";
#include "Api/V2/Suggestions";
#include "Modules/ActivityPub";
#include "Modules/Meta";
#include "Modules/OAuth";
#include "Modules/Web";
#include "Modules/Webfinger";
#include "Http/Server";
#include "Http/LocalServer";
#include "Http/AdminServer";
@slon_log(0, "slon is up and running");
@slon_log(0, "instance on port 80, fs on port 8000, admin on port 9000");
WinToTop(adam_task);

795
Slon/Modules/ActivityPub.HC Normal file
View file

@ -0,0 +1,795 @@
U8* @slon_activitypub_strip_double_quotes(U8* str)
{
while (str[0] == '"')
str++;
while (str[StrLen(str) - 1] == '"')
str[StrLen(str) - 1] = NULL;
return str;
}
Bool @slon_activitypub_http_signature_is_valid(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer;
// 1. Check that we have a signature and digest
if (!StrLen(@slon_http_request_header(session, "signature")) || !StrLen(@slon_http_request_header(session, "digest"))) {
AdamLog("[verify_signature] no signature or digest header present\n");
return FALSE;
}
// 2. Check that digest 1) is SHA-256 and 2) matches content
U8* request_digest = @slon_http_request_header(session, "digest");
if (!(String.BeginsWith("SHA-256", request_digest) || String.BeginsWith("sha-256", request_digest))) {
AdamLog("[verify_signature] digest is not SHA-256\n");
return FALSE;
}
request_digest = StrFind("=", request_digest) + 1;
I64 content_length = Str2I64(@slon_http_request_header(session, "content-length"));
if (!content_length) {
AdamLog("[verify_signature] content-length is 0\n");
return FALSE;
}
U8 content_hash[512];
calc_sha_256(content_hash, session->request->data, content_length);
U8* computed_digest = @base64_encode(content_hash, 32);
if (StrICmp(computed_digest, request_digest)) {
AdamLog("[verify_signature] digest header and computed digest do not match\n");
Free(computed_digest);
return FALSE;
} else {
Free(computed_digest);
}
// Parse values from Signature header
U8* signature_header = @slon_http_request_header(session, "signature");
I64 signature_fragment_count = 0;
U8** signature_fragments = String.Split(signature_header, ',', &signature_fragment_count);
U8* keyId = NULL;
U8* algorithm = NULL;
U8* headers = NULL;
U8* signature = NULL;
I64 i;
for (i = 0; i < signature_fragment_count; i++) {
if (String.BeginsWith("keyId=", signature_fragments[i])) {
keyId = signature_fragments[i] + 6;
keyId = @slon_activitypub_strip_double_quotes(keyId);
}
if (String.BeginsWith("algorithm=", signature_fragments[i])) {
algorithm = signature_fragments[i] + 10;
algorithm = @slon_activitypub_strip_double_quotes(algorithm);
}
if (String.BeginsWith("headers=", signature_fragments[i])) {
headers = signature_fragments[i] + 8;
headers = @slon_activitypub_strip_double_quotes(headers);
}
if (String.BeginsWith("signature=", signature_fragments[i])) {
signature = signature_fragments[i] + 10;
signature = @slon_activitypub_strip_double_quotes(signature);
}
}
// 3. Confirm actor matches keyId
if (!request_json->@("actor")) {
AdamLog("[verify_signature] actor is not present in request\n");
return FALSE;
}
if (!String.BeginsWith(request_json->@("actor"), keyId)) {
AdamLog("[verify_signature] actor does not match keyId\n");
return FALSE;
}
// Check if public key is cached for keyId, if not, fetch it
if (!db->o("public_keys")->@(keyId)) {
@slon_log(LOG_HTTPD, "Actor's public key is not cached, attempting to fetch");
HttpUrl* url = @http_parse_url(request_json->@("actor"));
if (!url) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, malformed url or unspecified error");
return FALSE;
}
U8* fetch_buffer = CAlloc(HTTP_FETCH_BUFFER_SIZE, adam_task);
JsonObject* http_headers = Json.CreateObject();
http_headers->set("accept", "application/json", JSON_STRING);
@http_response* resp = Http.Get(url, fetch_buffer, NULL, http_headers);
if (!resp) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, invalid response from remote server");
Free(fetch_buffer);
return FALSE;
}
while (resp->state != HTTP_STATE_DONE) {
Sleep(1);
}
if (!resp->body.length) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, empty response from remote server");
Free(fetch_buffer);
return FALSE;
}
Free(fetch_buffer);
JsonObject* user_object = Json.Parse(resp->body.data);
if (!user_object) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, user object not present in response from remote server");
return FALSE;
}
JsonObject* pubkey_object = user_object->@("publicKey");
if (!pubkey_object) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, publicKey object not present in user object");
return FALSE;
}
if (!pubkey_object->@("id")) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, id not present in publicKey object");
return FALSE;
}
if (!pubkey_object->@("owner")) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, owner not present in publicKey object");
return FALSE;
}
if (!pubkey_object->@("publicKeyPem")) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, publicKeyPem not present in publicKey object");
return FALSE;
}
if (StrICmp(pubkey_object->@("id"), keyId)) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, keyId does not match id present in publicKey object");
return FALSE;
}
if (StrICmp(pubkey_object->@("owner"), request_json->@("actor"))) {
@slon_log(LOG_HTTPD, "Could not fetch actor's public key, actor does not match owner present in publicKey object");
return FALSE;
}
U8* pem_string = pubkey_object->@("publicKeyPem");
// Convert Base64 PEM to single line
U8* pem_single_line = @slon_calloc(session, StrLen(pem_string));
I64 pem_lines_count = 0;
U8** pem_lines = String.Split(pem_string, '\n', &pem_lines_count);
i = 0;
while (i < pem_lines_count) {
if (pem_lines[i] && StrLen(pem_lines[i]) > 0) {
if (!StrFind("KEY", pem_lines[i])) {
StrCpy(pem_single_line + StrLen(pem_single_line), pem_lines[i]);
}
}
++i;
}
// Decode PEM to DER
I64 der_buf_length = 0;
U8* der_buf = @base64_decode(pem_single_line, &der_buf_length);
// Cache the public key
JsonObject* cached_key = Json.CreateObject();
cached_key->set("key", der_buf, JSON_NUMBER);
cached_key->set("length", der_buf_length, JSON_NUMBER);
db->o("public_keys")->set(keyId, cached_key, JSON_OBJECT);
@slon_free(session, pem_single_line);
Json.Delete(user_object);
Json.Delete(http_headers);
}
// Calculate our signature string allocation
I64 sig_string_alloc_length = 0;
I64 headers_split_count = 0;
U8** headers_split = String.Split(headers, ' ', &headers_split_count);
i = 0;
while (i < headers_split_count) {
sig_string_alloc_length += StrLen(@slon_http_request_header(session, headers_split[i]));
++i;
}
sig_string_alloc_length += StrLen(@slon_http_request_verb(session));
sig_string_alloc_length += StrLen(@slon_http_request_path(session));
sig_string_alloc_length *= 2;
// Construct our signature string
U8* sig_string = @slon_calloc(session, sig_string_alloc_length);
i = 0;
while (i < headers_split_count) {
if (StrLen(headers_split[i]) && headers_split[i][0] >= 'A' && headers_split[i][0] <= 'Z') {
headers_split[i][0] += 'a' - headers_split[i][0];
}
if (!StrCmp("(request-target)", headers_split[i])) {
String.Append(sig_string, "(request-target): %s %s", "post", @slon_http_request_path(session));
} else {
String.Append(sig_string, "%s: %s", headers_split[i], @slon_http_request_header(session, headers_split[i]));
}
++i;
if (i < headers_split_count) {
String.Append(sig_string, "\n");
}
}
// Base64 decode request's signature
I64 verify_sig_buf_length = 0;
U8* verify_sig_buf = @base64_decode(signature, &verify_sig_buf_length);
// Hash our constructed signature string
U8 sig_string_hash[32];
calc_sha_256(sig_string_hash, sig_string, StrLen(sig_string));
// Import RSA key
U64 rsa_key = CAlloc(sizeof(U64) * 32, adam_task);
I64 res = @rsa_import(db->o("public_keys")->o(keyId)->@("key"), db->o("public_keys")->o(keyId)->@("length"), rsa_key);
if (res != 0) { // CRYPT_OK = 0
@slon_log(LOG_HTTPD, "Received error from @rsa_import: %d", res);
return FALSE;
}
// Verify signature
I32 stat = 0;
res = @rsa_verify_signature(verify_sig_buf, verify_sig_buf_length, sig_string_hash, 32, &stat, rsa_key);
if (res != 0) { // CRYPT_OK = 0
@slon_log(LOG_HTTPD, "Received error from @rsa_verify_signature: %d", res);
return FALSE;
}
Free(rsa_key);
Free(verify_sig_buf);
@slon_free(session, sig_string);
return stat;
}
U0 @slon_activitypub_users_get(SlonHttpSession* session)
{
U8* path = @slon_strnew(session, @slon_http_request_path(session));
I64 path_segments_count = 0;
U8** path_segments = String.Split(path, '/', &path_segments_count);
if (path_segments_count == 3) {
JsonObject* actor = db->o("actors")->@(path_segments[1]);
if (actor) {
@slon_http_send_ap_json(session, actor);
} else {
@slon_http_set_status_code(session, 404);
}
} else {
@slon_http_set_status_code(session, 400);
}
slon_activitypub_users_get_return:
@slon_free(session, path);
}
U0 @slon_activitypub_async_accept_request(JsonObject* o)
{
JsonObject* request = o->o("request");
if (!StrICmp("accept", request->@("type")) || !StrICmp("reject", request->@("type"))) {
return;
}
Sleep(2000);
U8 scratch_buffer[2048];
U8* this_actor = db->o("actors")->o(o->@("user"))->@("id");
StrPrint(scratch_buffer, "%s/accept/%d", this_actor, Now);
JsonObject* accept_object = Json.CreateObject();
accept_object->set("@context", request->@("@context"), JSON_STRING);
accept_object->set("id", scratch_buffer, JSON_STRING);
accept_object->set("type", "Accept", JSON_STRING);
accept_object->set("actor", this_actor, JSON_STRING);
accept_object->set("object", request, JSON_OBJECT);
U8* accept_object_s = Json.Stringify(accept_object);
U8 content_hash[512];
calc_sha_256(content_hash, accept_object_s, StrLen(accept_object_s));
U8* computed_digest = @base64_encode(content_hash, 32);
JsonObject* http_headers = Json.CreateObject();
StrPrint(scratch_buffer, "%s/inbox", request->@("actor"));
HttpUrl* url = @http_parse_url(scratch_buffer);
CDateStruct ds;
Date2Struct(&ds, Now + 1043910000);
StrPrint(scratch_buffer, "%03tZ, %02d %03tZ %04d %02d:%02d:%02d GMT", ds.day_of_week, "ST_DAYS_OF_WEEK", ds.day_of_mon, ds.mon - 1, "ST_MONTHS",
ds.year, ds.hour, ds.min, ds.sec);
http_headers->set("Date", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "SHA-256=%s", computed_digest);
http_headers->set("Digest", scratch_buffer, JSON_STRING);
http_headers->set("Content-Type", "application/activity+json", JSON_STRING);
StrPrint(scratch_buffer, "");
String.Append(scratch_buffer, "(request-target): post %s\n", url->path);
String.Append(scratch_buffer, "host: %s\n", url->host);
String.Append(scratch_buffer, "date: %s\n", http_headers->@("Date"));
String.Append(scratch_buffer, "digest: %s\n", http_headers->@("Digest"));
String.Append(scratch_buffer, "content-type: %s", http_headers->@("Content-Type"));
AdamLog("headers_to_sign:\n```%s```\n", scratch_buffer);
calc_sha_256(content_hash, scratch_buffer, StrLen(scratch_buffer));
U8* user = StrFind("/users/", this_actor) + 7;
JsonObject* private_key_binary = db->o("private_keys_binary")->o(user);
if (!private_key_binary) {
I64 private_key_binary_size = 0;
private_key_binary = Json.CreateObject();
private_key_binary->set("data", @base64_decode(db->o("private_keys")->@(user), &private_key_binary_size), JSON_OBJECT);
private_key_binary->set("size", private_key_binary_size, JSON_NUMBER);
db->o("private_keys_binary")->set(user, private_key_binary, JSON_OBJECT);
}
I64 res;
// Import RSA key
U64 rsa_key = CAlloc(sizeof(U64) * 32, adam_task);
res = @rsa_import(private_key_binary->@("data"), private_key_binary->@("size"), rsa_key);
AdamLog("@rsa_import: res: %d\n", res);
U8 sig[256];
U64 siglen = 256;
res = @rsa_create_signature(sig, &siglen, content_hash, 32, rsa_key);
AdamLog("@rsa_create_signature: res: %d\n", res);
U8* computed_sig = @base64_encode(sig, 256);
StrCpy(scratch_buffer, "");
String.Append(scratch_buffer, "keyId=\"%s#main-key\",", this_actor);
String.Append(scratch_buffer, "algorithm=\"rsa-sha256\",");
String.Append(scratch_buffer, "headers=\"(request-target) host date digest content-type\",");
String.Append(scratch_buffer, "signature=\"%s\"", computed_sig);
http_headers->set("Signature", scratch_buffer, JSON_STRING);
U8* fetch_buffer = CAlloc(HTTP_FETCH_BUFFER_SIZE, adam_task);
@http_response* resp = Http.Post(url, fetch_buffer, accept_object_s, http_headers);
if (!resp) {
@slon_log(LOG_HTTPD, "Could not POST Accept, invalid response from remote server");
Free(fetch_buffer);
return;
}
while (resp->state != HTTP_STATE_DONE) {
Sleep(1);
}
AdamLog("code: %d\n", resp->status.code);
Free(fetch_buffer);
}
U0 @slon_activitypub_follow_request()
{
U8 scratch_buffer[2048];
U8* this_actor = "https://error.checksum.fail/users/alec";
StrPrint(scratch_buffer, "%s/follow/%d", this_actor, Now);
JsonObject* follow_object = Json.CreateObject();
follow_object->set("@context", "https://www.w3.org/ns/activitystreams", JSON_STRING);
follow_object->set("id", scratch_buffer, JSON_STRING);
follow_object->set("type", "Follow", JSON_STRING);
follow_object->set("actor", this_actor, JSON_STRING);
follow_object->set("object", "https://techhub.social/users/ryeucrvtexw3", JSON_STRING);
U8* follow_object_s = Json.Stringify(follow_object);
U8 content_hash[512];
calc_sha_256(content_hash, follow_object_s, StrLen(follow_object_s));
U8* computed_digest = @base64_encode(content_hash, 32);
JsonObject* http_headers = Json.CreateObject();
StrPrint(scratch_buffer, "%s/inbox", "https://techhub.social/users/ryeucrvtexw3");
HttpUrl* url = @http_parse_url(scratch_buffer);
CDateStruct ds;
Date2Struct(&ds, Now + 1043910000);
StrPrint(scratch_buffer, "%03tZ, %02d %03tZ %04d %02d:%02d:%02d GMT", ds.day_of_week, "ST_DAYS_OF_WEEK", ds.day_of_mon, ds.mon - 1, "ST_MONTHS",
ds.year, ds.hour, ds.min, ds.sec);
http_headers->set("Date", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "SHA-256=%s", computed_digest);
http_headers->set("Digest", scratch_buffer, JSON_STRING);
http_headers->set("Content-Type", "application/activity+json", JSON_STRING);
StrPrint(scratch_buffer, "");
String.Append(scratch_buffer, "(request-target): post %s\n", url->path);
String.Append(scratch_buffer, "host: %s\n", url->host);
String.Append(scratch_buffer, "date: %s\n", http_headers->@("Date"));
String.Append(scratch_buffer, "digest: %s\n", http_headers->@("Digest"));
String.Append(scratch_buffer, "content-type: %s", http_headers->@("Content-Type"));
AdamLog("headers_to_sign:\n```%s```\n", scratch_buffer);
calc_sha_256(content_hash, scratch_buffer, StrLen(scratch_buffer));
U8* user = StrFind("/users/", this_actor) + 7;
JsonObject* private_key_binary = db->o("private_keys_binary")->o(user);
if (!private_key_binary) {
I64 private_key_binary_size = 0;
private_key_binary = Json.CreateObject();
private_key_binary->set("data", @base64_decode(db->o("private_keys")->@(user), &private_key_binary_size), JSON_OBJECT);
private_key_binary->set("size", private_key_binary_size, JSON_NUMBER);
db->o("private_keys_binary")->set(user, private_key_binary, JSON_OBJECT);
}
I64 res;
// Import RSA key
U64 rsa_key = CAlloc(sizeof(U64) * 32, adam_task);
res = @rsa_import(private_key_binary->@("data"), private_key_binary->@("size"), rsa_key);
AdamLog("@rsa_import: res: %d\n", res);
U8 sig[256];
U64 siglen = 256;
res = @rsa_create_signature(sig, &siglen, content_hash, 32, rsa_key);
AdamLog("@rsa_create_signature: res: %d\n", res);
U8* computed_sig = @base64_encode(sig, 256);
StrCpy(scratch_buffer, "");
String.Append(scratch_buffer, "keyId=\"%s#main-key\",", this_actor);
String.Append(scratch_buffer, "algorithm=\"rsa-sha256\",");
String.Append(scratch_buffer, "headers=\"(request-target) host date digest content-type\",");
String.Append(scratch_buffer, "signature=\"%s\"", computed_sig);
http_headers->set("Signature", scratch_buffer, JSON_STRING);
U8* fetch_buffer = CAlloc(HTTP_FETCH_BUFFER_SIZE, adam_task);
@http_response* resp = Http.Post(url, fetch_buffer, follow_object_s, http_headers);
if (!resp) {
@slon_log(LOG_HTTPD, "Could not POST Accept, invalid response from remote server");
Free(fetch_buffer);
return;
}
while (resp->state != HTTP_STATE_DONE) {
Sleep(1);
}
AdamLog("code: %d\n", resp->status.code);
Free(fetch_buffer);
}
U0 @slon_activitypub_async_create_status(JsonObject* status)
{
Sleep(2000);
U8 scratch_buffer[2048];
U8* dest = "https://techhub.social/users/ryeucrvtexw3/inbox";
U8* this_actor = StrNew(status->@("uri"), adam_task);
StrFind("/statuses/", this_actor)[0] = NULL;
JsonObject* create_object = Json.CreateObject();
create_object->set("@context", "https://www.w3.org/ns/activitystreams", JSON_STRING);
StrPrint(scratch_buffer, "%s/activity", status->@("uri"));
create_object->set("id", scratch_buffer, JSON_STRING);
create_object->set("type", "Create", JSON_STRING);
create_object->set("actor", this_actor, JSON_STRING);
create_object->set("published", status->@("created_at"), JSON_STRING);
create_object->set("to", Json.Parse("[\"https://www.w3.org/ns/activitystreams#Public\"]"), JSON_ARRAY);
JsonArray* cc = Json.CreateArray();
StrPrint(scratch_buffer, "%s/followers", this_actor);
cc->append(Json.CreateItem(scratch_buffer, JSON_STRING));
create_object->set("cc", cc, JSON_ARRAY);
JsonObject* note_object = Json.CreateObject();
note_object->set("id", status->@("uri"), JSON_STRING);
note_object->set("type", "Note", JSON_STRING);
note_object->set("summary", NULL, JSON_NULL);
note_object->set("inReplyTo", NULL, JSON_NULL);
note_object->set("published", status->@("created_at"), JSON_STRING);
note_object->set("attributedTo", this_actor, JSON_STRING);
note_object->set("to", Json.Parse("[\"https://www.w3.org/ns/activitystreams#Public\"]"), JSON_ARRAY);
note_object->set("cc", cc, JSON_ARRAY);
note_object->set("sensitive", status->@("sensitive"), JSON_BOOLEAN);
note_object->set("atomUri", status->@("uri"), JSON_STRING);
note_object->set("inReplyToAtomUri", NULL, JSON_NULL);
note_object->set("content", status->@("content"), JSON_STRING);
JsonObject* content_map = Json.CreateObject();
content_map->set("en", status->@("content"), JSON_STRING);
note_object->set("contentMap", content_map, JSON_OBJECT);
note_object->set("attachment", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
note_object->set("tag", SLON_EMPTY_JSON_ARRAY, JSON_ARRAY);
note_object->set("replies", SLON_EMPTY_JSON_OBJECT, JSON_OBJECT);
note_object->set("likes", SLON_EMPTY_JSON_OBJECT, JSON_OBJECT);
note_object->set("shares", SLON_EMPTY_JSON_OBJECT, JSON_OBJECT);
create_object->set("object", note_object, JSON_OBJECT);
U8* create_object_s = Json.Stringify(create_object);
U8 content_hash[512];
calc_sha_256(content_hash, create_object_s, StrLen(create_object_s));
U8* computed_digest = @base64_encode(content_hash, 32);
JsonObject* http_headers = Json.CreateObject();
HttpUrl* url = @http_parse_url(dest);
CDateStruct ds;
Date2Struct(&ds, Now + 1043910000);
StrPrint(scratch_buffer, "%03tZ, %02d %03tZ %04d %02d:%02d:%02d GMT", ds.day_of_week, "ST_DAYS_OF_WEEK", ds.day_of_mon, ds.mon - 1, "ST_MONTHS",
ds.year, ds.hour, ds.min, ds.sec);
http_headers->set("Date", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "SHA-256=%s", computed_digest);
http_headers->set("Digest", scratch_buffer, JSON_STRING);
http_headers->set("Content-Type", "application/activity+json", JSON_STRING);
StrPrint(scratch_buffer, "");
String.Append(scratch_buffer, "(request-target): post %s\n", url->path);
String.Append(scratch_buffer, "host: %s\n", url->host);
String.Append(scratch_buffer, "date: %s\n", http_headers->@("Date"));
String.Append(scratch_buffer, "digest: %s\n", http_headers->@("Digest"));
String.Append(scratch_buffer, "content-type: %s", http_headers->@("Content-Type"));
AdamLog("headers_to_sign:\n```%s```\n", scratch_buffer);
calc_sha_256(content_hash, scratch_buffer, StrLen(scratch_buffer));
U8* user = StrFind("/users/", this_actor) + 7;
JsonObject* private_key_binary = db->o("private_keys_binary")->o(user);
if (!private_key_binary) {
I64 private_key_binary_size = 0;
private_key_binary = Json.CreateObject();
private_key_binary->set("data", @base64_decode(db->o("private_keys")->@(user), &private_key_binary_size), JSON_OBJECT);
private_key_binary->set("size", private_key_binary_size, JSON_NUMBER);
db->o("private_keys_binary")->set(user, private_key_binary, JSON_OBJECT);
}
I64 res;
// Import RSA key
U64 rsa_key = CAlloc(sizeof(U64) * 32, adam_task);
res = @rsa_import(private_key_binary->@("data"), private_key_binary->@("size"), rsa_key);
AdamLog("@rsa_import: res: %d\n", res);
U8 sig[256];
U64 siglen = 256;
res = @rsa_create_signature(sig, &siglen, content_hash, 32, rsa_key);
AdamLog("@rsa_create_signature: res: %d\n", res);
U8* computed_sig = @base64_encode(sig, 256);
StrCpy(scratch_buffer, "");
String.Append(scratch_buffer, "keyId=\"%s#main-key\",", this_actor);
String.Append(scratch_buffer, "algorithm=\"rsa-sha256\",");
String.Append(scratch_buffer, "headers=\"(request-target) host date digest content-type\",");
String.Append(scratch_buffer, "signature=\"%s\"", computed_sig);
http_headers->set("Signature", scratch_buffer, JSON_STRING);
U8* fetch_buffer = CAlloc(HTTP_FETCH_BUFFER_SIZE, adam_task);
@http_response* resp = Http.Post(url, fetch_buffer, create_object_s, http_headers);
if (!resp) {
@slon_log(LOG_HTTPD, "Could not POST Accept, invalid response from remote server");
Free(fetch_buffer);
return;
}
while (resp->state != HTTP_STATE_DONE) {
Sleep(1);
}
AdamLog("code: %d\n", resp->status.code);
Free(fetch_buffer);
}
U0 @slon_activitypub_async_delete_status(JsonObject* status)
{
Sleep(2000);
U8 scratch_buffer[2048];
U8* dest = "https://techhub.social/users/ryeucrvtexw3/inbox";
U8* this_actor = StrNew(status->@("uri"), adam_task);
StrFind("/statuses/", this_actor)[0] = NULL;
JsonObject* delete_object = Json.CreateObject();
delete_object->set("@context", "https://www.w3.org/ns/activitystreams", JSON_STRING);
StrPrint(scratch_buffer, "%s#delete", status->@("uri"));
delete_object->set("id", scratch_buffer, JSON_STRING);
delete_object->set("type", "Delete", JSON_STRING);
delete_object->set("actor", this_actor, JSON_STRING);
delete_object->set("to", Json.Parse("[\"https://www.w3.org/ns/activitystreams#Public\"]"), JSON_ARRAY);
JsonObject* ts_object = Json.CreateObject();
ts_object->set("id", status->@("uri"), JSON_STRING);
ts_object->set("type", "Tombstone", JSON_STRING);
ts_object->set("atomUri", status->@("uri"), JSON_STRING);
delete_object->set("object", ts_object, JSON_OBJECT);
U8* delete_object_s = Json.Stringify(delete_object);
U8 content_hash[512];
calc_sha_256(content_hash, delete_object_s, StrLen(delete_object_s));
U8* computed_digest = @base64_encode(content_hash, 32);
JsonObject* http_headers = Json.CreateObject();
HttpUrl* url = @http_parse_url(dest);
CDateStruct ds;
Date2Struct(&ds, Now + 1043910000);
StrPrint(scratch_buffer, "%03tZ, %02d %03tZ %04d %02d:%02d:%02d GMT", ds.day_of_week, "ST_DAYS_OF_WEEK", ds.day_of_mon, ds.mon - 1, "ST_MONTHS",
ds.year, ds.hour, ds.min, ds.sec);
http_headers->set("Date", scratch_buffer, JSON_STRING);
StrPrint(scratch_buffer, "SHA-256=%s", computed_digest);
http_headers->set("Digest", scratch_buffer, JSON_STRING);
http_headers->set("Content-Type", "application/activity+json", JSON_STRING);
StrPrint(scratch_buffer, "");
String.Append(scratch_buffer, "(request-target): post %s\n", url->path);
String.Append(scratch_buffer, "host: %s\n", url->host);
String.Append(scratch_buffer, "date: %s\n", http_headers->@("Date"));
String.Append(scratch_buffer, "digest: %s\n", http_headers->@("Digest"));
String.Append(scratch_buffer, "content-type: %s", http_headers->@("Content-Type"));
AdamLog("headers_to_sign:\n```%s```\n", scratch_buffer);
calc_sha_256(content_hash, scratch_buffer, StrLen(scratch_buffer));
U8* user = StrFind("/users/", this_actor) + 7;
JsonObject* private_key_binary = db->o("private_keys_binary")->o(user);
if (!private_key_binary) {
I64 private_key_binary_size = 0;
private_key_binary = Json.CreateObject();
private_key_binary->set("data", @base64_decode(db->o("private_keys")->@(user), &private_key_binary_size), JSON_OBJECT);
private_key_binary->set("size", private_key_binary_size, JSON_NUMBER);
db->o("private_keys_binary")->set(user, private_key_binary, JSON_OBJECT);
}
I64 res;
// Import RSA key
U64 rsa_key = CAlloc(sizeof(U64) * 32, adam_task);
res = @rsa_import(private_key_binary->@("data"), private_key_binary->@("size"), rsa_key);
AdamLog("@rsa_import: res: %d\n", res);
U8 sig[256];
U64 siglen = 256;
res = @rsa_create_signature(sig, &siglen, content_hash, 32, rsa_key);
AdamLog("@rsa_create_signature: res: %d\n", res);
U8* computed_sig = @base64_encode(sig, 256);
StrCpy(scratch_buffer, "");
String.Append(scratch_buffer, "keyId=\"%s#main-key\",", this_actor);
String.Append(scratch_buffer, "algorithm=\"rsa-sha256\",");
String.Append(scratch_buffer, "headers=\"(request-target) host date digest content-type\",");
String.Append(scratch_buffer, "signature=\"%s\"", computed_sig);
http_headers->set("Signature", scratch_buffer, JSON_STRING);
U8* fetch_buffer = CAlloc(HTTP_FETCH_BUFFER_SIZE, adam_task);
@http_response* resp = Http.Post(url, fetch_buffer, delete_object_s, http_headers);
if (!resp) {
@slon_log(LOG_HTTPD, "Could not POST Accept, invalid response from remote server");
Free(fetch_buffer);
return;
}
while (resp->state != HTTP_STATE_DONE) {
Sleep(1);
}
AdamLog("code: %d\n", resp->status.code);
Free(fetch_buffer);
}
U0 @slon_activitypub_create_status_fedi(JsonObject* status)
{
Spawn(&@slon_activitypub_async_create_status, status, "SlonAsyncCreateTask");
}
U0 @slon_activitypub_delete_status_fedi(JsonObject* status)
{
Spawn(&@slon_activitypub_async_delete_status, status, "SlonAsyncDeleteTask");
}
@slon_api_status_create_fedi = &@slon_activitypub_create_status_fedi;
@slon_api_status_delete_fedi = &@slon_activitypub_delete_status_fedi;
U0 @slon_activitypub_users_inbox(SlonHttpSession* session, U8* user)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer;
I64 i;
JsonObject* account = @slon_api_account_by_username(user);
Bool already_following = FALSE;
JsonArray* followers = NULL;
JsonArray* statuses = NULL;
JsonObject* status = NULL;
if (!StrICmp("follow", request_json->@("type"))) {
if (!db->o("followers")->@(user)) {
db->o("followers")->set(user, Json.CreateArray(), JSON_ARRAY);
}
followers = db->o("followers")->a(user);
for (i = 0; i < followers->length; i++) {
if (!StrCmp(request_json->@("actor"), followers->@(i))) {
already_following = TRUE;
}
}
if (!already_following) {
followers->append(Json.CreateItem(request_json->@("actor"), JSON_STRING));
account->set("followers_count", account->@("followers_count") + 1);
@slon_db_save_to_disk;
}
}
if (!StrICmp("like", request_json->@("type"))) {
U8* status_id = StrFind("/", StrFind("/statuses/", request_json->@("object")) + 1) + 1;
statuses = db->o("statuses")->a(account->@("id"));
for (i = 0; i < statuses->length; i++) {
status = statuses->@(i);
if (!StrICmp(status_id, status->@("id"))) {
status->set("favourites_count", status->@("favourites_count") + 1);
break;
}
}
@slon_db_save_statuses_to_disk;
}
JsonObject* o = Json.CreateObject();
o->set("user", user, JSON_STRING);
o->set("request", Json.Clone(request_json), JSON_OBJECT);
Spawn(&@slon_activitypub_async_accept_request, o, "SlonAsyncAcceptTask");
@slon_http_set_status_code(session, 200);
return;
}
U0 @slon_activitypub_users_post(SlonHttpSession* session)
{
if (!@slon_activitypub_http_signature_is_valid(session)) {
@slon_http_set_status_code(session, 401);
return;
}
U8* path = @slon_strnew(session, @slon_http_request_path(session));
I64 path_segments_count = 0;
U8** path_segments = String.Split(path, '/', &path_segments_count);
if (path_segments_count < 3) {
@slon_http_set_status_code(session, 400);
goto slon_activitypub_users_post_return;
}
U8* user = path_segments[1];
JsonObject* actor = db->o("actors")->@(user);
if (!actor) {
@slon_http_set_status_code(session, 404);
goto slon_activitypub_users_post_return;
}
U8* method = path_segments[2];
if (!StrICmp("inbox", method)) {
@slon_activitypub_users_inbox(session, user);
goto slon_activitypub_users_post_return;
}
@slon_http_set_status_code(session, 404);
slon_activitypub_users_post_return:
@slon_free(session, path);
}

86
Slon/Modules/Api.HC Normal file
View file

@ -0,0 +1,86 @@
#define SLON_API_LOCAL_TIME_OFFSET 3550
#define SLON_AUTH_ACCOUNT_ID U8* account_id = Json.Get(session->auth, "account_id");
Bool @slon_api_authorized(SlonHttpSession* session)
{
return session->auth > 0;
}
U8* @slon_api_generate_random_hex_string(SlonHttpSession* session, I64 size)
{
U8* str = @slon_calloc(session, (size + 1) * 2);
I64 i;
for (i = 0; i < size; i++) {
String.Append(str, "%02x", RandU64 & 0xff);
}
return str;
}
U8* @slon_api_generate_unique_id(SlonHttpSession* session)
{
U8* unique_id = @slon_calloc(session, 64);
U64 id = ((CDate2Unix(Now) + SLON_API_LOCAL_TIME_OFFSET) * 1000) << 16;
id += RandU64 & 0xffff;
StrPrint(unique_id, "%d", id);
return unique_id;
}
U8* @slon_api_timestamp_from_cdate(SlonHttpSession* session, CDate* date)
{
CDateStruct ds;
Date2Struct(&ds, date);
U8* timestamp = @slon_calloc(session, 32);
StrPrint(timestamp, "%04d-%02d-%02dT%02d:%02d:%02d.000-05:00", ds.year, ds.mon, ds.day_of_mon, ds.hour, ds.min, ds.sec);
return timestamp;
}
Bool @slon_api_boolean_from_string(U8* s)
{
// https://docs.joinmastodon.org/client/intro/#boolean
// True-or-false (Booleans)
// A boolean value is considered false for the values 0, f, F, false, FALSE, off, OFF; considered to not be provided for empty strings;
// and considered to be true for all other values. When using JSON data, use the literals true, false, and null instead.
return !(!StrICmp("0", s) || !StrICmp("f", s) || !StrICmp("false", s) || !StrICmp("off", s));
}
JsonObject* @slon_api_account_by_email(U8* email)
{
if (!email || !StrLen(email))
return NULL;
JsonArray* accts = db->a("accounts");
I64 i;
for (i = 0; i < accts->length; i++) {
if (!StrICmp(accts->o(i)->@("email"), email)) {
return accts->o(i);
}
}
return NULL;
}
JsonObject* @slon_api_account_by_id(U8* id)
{
if (!id || !StrLen(id))
return NULL;
JsonArray* accts = db->a("accounts");
I64 i;
for (i = 0; i < accts->length; i++) {
if (!StrICmp(accts->o(i)->@("id"), id)) {
return accts->o(i);
}
}
return NULL;
}
JsonObject* @slon_api_account_by_username(U8* username)
{
if (!username || !StrLen(username))
return NULL;
JsonArray* accts = db->a("accounts");
I64 i;
for (i = 0; i < accts->length; i++) {
if (!StrICmp(accts->o(i)->@("username"), username)) {
return accts->o(i);
}
}
return NULL;
}

252
Slon/Modules/Db.HC Normal file
View file

@ -0,0 +1,252 @@
#define SLON_DB_PATH "A:/db"
JsonObject* db = Json.CreateObject();
U0 @slon_db_load_accounts_from_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/accounts.json", SLON_DB_PATH);
db->set("accounts", Json.ParseFile(scratch_buffer), JSON_ARRAY);
}
U0 @slon_db_load_actors_from_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/actors.json", SLON_DB_PATH);
db->set("actors", Json.ParseFile(scratch_buffer), JSON_OBJECT);
}
U0 @slon_db_load_apps_from_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/apps.json", SLON_DB_PATH);
db->set("apps", Json.ParseFile(scratch_buffer), JSON_OBJECT);
}
U0 @slon_db_load_instance_from_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/instance.json", SLON_DB_PATH);
db->set("instance", Json.ParseFile(scratch_buffer), JSON_OBJECT);
}
U0 @slon_db_load_oauth_from_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/oauth.json", SLON_DB_PATH);
db->set("oauth", Json.ParseFile(scratch_buffer), JSON_OBJECT);
}
U0 @slon_db_load_private_keys_from_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/private_keys.json", SLON_DB_PATH);
db->set("private_keys", Json.ParseFile(scratch_buffer), JSON_OBJECT);
}
U0 @slon_db_load_followers_from_disk()
{
JsonObject* followers = Json.CreateObject();
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/followers/*.json", SLON_DB_PATH);
CDirEntry* files = FilesFind(scratch_buffer);
CDirEntry* de = files;
JsonArray* follower_array = NULL;
while (de) {
follower_array = Json.ParseFile(de->full_name);
if (follower_array) {
StrFind(".json", de->name)[0] = NULL;
followers->set(de->name, follower_array, JSON_ARRAY);
}
de = de->next;
}
DirTreeDel(files);
db->set("followers", followers, JSON_OBJECT);
}
U0 @slon_db_load_statuses_from_disk()
{
JsonObject* statuses = Json.CreateObject();
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/statuses/*.json", SLON_DB_PATH);
CDirEntry* files = FilesFind(scratch_buffer);
CDirEntry* de = files;
JsonArray* status_array = NULL;
while (de) {
status_array = Json.ParseFile(de->full_name);
if (status_array) {
StrFind(".json", de->name)[0] = NULL;
statuses->set(de->name, status_array, JSON_ARRAY);
}
de = de->next;
}
DirTreeDel(files);
db->set("statuses", statuses, JSON_OBJECT);
}
U0 @slon_db_save_accounts_to_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/accounts.json", SLON_DB_PATH);
Json.DumpToFile(scratch_buffer, db->a("accounts"));
}
U0 @slon_db_save_actors_to_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/actors.json", SLON_DB_PATH);
Json.DumpToFile(scratch_buffer, db->o("actors"));
}
U0 @slon_db_save_apps_to_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/apps.json", SLON_DB_PATH);
Json.DumpToFile(scratch_buffer, db->o("apps"));
}
U0 @slon_db_save_instance_to_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/instance.json", SLON_DB_PATH);
Json.DumpToFile(scratch_buffer, db->o("instance"));
}
U0 @slon_db_save_oauth_to_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/oauth.json", SLON_DB_PATH);
Json.DumpToFile(scratch_buffer, db->o("oauth"));
}
U0 @slon_db_save_private_keys_to_disk()
{
U8 scratch_buffer[256];
StrPrint(scratch_buffer, "%s/private_keys.json", SLON_DB_PATH);
Json.DumpToFile(scratch_buffer, db->o("private_keys"));
}
U0 @slon_db_save_followers_to_disk()
{
U8 scratch_buffer[256];
JsonKey* key = db->o("followers")->keys;
while (key) {
StrPrint(scratch_buffer, "%s/followers/%s.json", SLON_DB_PATH, key->name);
Json.DumpToFile(scratch_buffer, key->value);
key = key->next;
}
}
U0 @slon_db_save_statuses_to_disk()
{
U8 scratch_buffer[256];
JsonKey* key = db->o("statuses")->keys;
while (key) {
StrPrint(scratch_buffer, "%s/statuses/%s.json", SLON_DB_PATH, key->name);
Json.DumpToFile(scratch_buffer, key->value);
key = key->next;
}
}
U0 @slon_db_save_to_disk()
{
@slon_db_save_accounts_to_disk();
@slon_db_save_actors_to_disk();
@slon_db_save_apps_to_disk();
@slon_db_save_followers_to_disk();
@slon_db_save_instance_to_disk();
@slon_db_save_oauth_to_disk();
@slon_db_save_private_keys_to_disk();
@slon_db_save_statuses_to_disk();
}
U0 @slon_db_load_from_defaults()
{
db->set("accounts", Json.CreateArray(), JSON_ARRAY);
db->set("actors", Json.CreateObject(), JSON_OBJECT);
db->set("apps", Json.CreateObject(), JSON_OBJECT);
db->set("idempotency_keys", Json.CreateObject(), JSON_OBJECT);
db->set("private_keys", Json.CreateObject(), JSON_OBJECT);
db->set("private_keys_binary", Json.CreateObject(), JSON_OBJECT);
db->set("public_keys", Json.CreateObject(), JSON_OBJECT);
db->set("followers", Json.CreateObject(), JSON_OBJECT);
db->set("instance", Json.ParseFile("M:/Slon/Static/defaults/instance.json"), JSON_OBJECT);
db->set("statuses", Json.CreateObject(), JSON_OBJECT);
JsonObject* oauth = Json.CreateObject();
oauth->set("codes", Json.CreateObject(), JSON_OBJECT);
oauth->set("requests", Json.CreateObject(), JSON_OBJECT);
oauth->set("responses", Json.CreateObject(), JSON_OBJECT);
oauth->set("tokens", Json.CreateObject(), JSON_OBJECT);
db->set("oauth", oauth, JSON_OBJECT);
db->set("setup", FALSE, JSON_BOOLEAN);
}
U0 @slon_db_load_from_disk()
{
@slon_db_load_accounts_from_disk();
@slon_db_load_actors_from_disk();
@slon_db_load_apps_from_disk();
db->set("idempotency_keys", Json.CreateObject(), JSON_OBJECT);
@slon_db_load_private_keys_from_disk();
db->set("private_keys_binary", Json.CreateObject(), JSON_OBJECT);
db->set("public_keys", Json.CreateObject(), JSON_OBJECT);
@slon_db_load_followers_from_disk();
@slon_db_load_instance_from_disk();
@slon_db_load_oauth_from_disk();
@slon_db_load_statuses_from_disk();
db->set("setup", TRUE, JSON_BOOLEAN);
}
U0 @slon_db_instance_update_user_count()
{
JsonObject* stats = db->o("instance")->o("stats");
stats->set("user_count", db->a("accounts")->length);
}
U0 @slon_db_instance_decrement_status_count()
{
JsonObject* stats = db->o("instance")->o("stats");
stats->set("status_count", MaxI64(0, stats->@("status_count") - 1));
}
U0 @slon_db_instance_increment_status_count()
{
JsonObject* stats = db->o("instance")->o("stats");
stats->set("status_count", stats->@("status_count") + 1);
}
U0 @slon_db_actors_update_user(JsonObject* acct)
{
JsonObject* actors = db->o("actors");
JsonObject* actor = actors->o(acct->@("username"));
if (!actor) {
// FIXME: Handle this error
return;
}
actor->set("name", acct->@("display_name"));
actor->set("summary", acct->@("note"));
JsonObject* icon = actor->o("icon");
icon->set("url", acct->@("avatar"));
actor->set("attachment", acct->@("fields"));
@slon_db_save_actors_to_disk;
}
U0 @slon_db_init()
{
if (FileFind(SLON_DB_PATH)) {
@slon_log(LOG_DB, "loading db from disk");
@slon_db_load_from_disk;
} else {
@slon_log(LOG_DB, "no db found; loading defaults");
@slon_db_load_from_defaults;
}
}
@slon_db_init;
JsonArray* SLON_EMPTY_JSON_ARRAY = Json.CreateArray();
JsonObject* SLON_EMPTY_JSON_OBJECT = Json.CreateObject();
JsonObject* SLON_DEFAULT_ACCT_OBJECT = Json.ParseFile("M:/Slon/Static/defaults/account.json");
JsonObject* SLON_DEFAULT_ACTOR_OBJECT = Json.ParseFile("M:/Slon/Static/defaults/actor.json");

249
Slon/Modules/Http.HC Normal file
View file

@ -0,0 +1,249 @@
#define SLON_HTTP_BUFFER_SIZE 1048576
#define SLON_HTTP_VERB_DELETE 1
#define SLON_HTTP_VERB_GET 2
#define SLON_HTTP_VERB_OPTIONS 3
#define SLON_HTTP_VERB_PATCH 4
#define SLON_HTTP_VERB_POST 5
#define SLON_MULTIPART_PARSER_CONSUME_BOUNDARY 0
#define SLON_MULTIPART_PARSER_CONSUME_CONTENT_DISPOSITION 1
#define SLON_MULTIPART_PARSER_CONSUME_CONTENT 2
#define SLON_MULTIPART_PARSER_DONE 3
#define SLON_SCRATCH_BUFFER_AND_REQUEST_JSON \
U8 scratch_buffer[256]; \
JsonObject* request_json = @slon_http_request_json(session);
#define SLON_DEBUG_PRINT_REQUEST_JSON \
JsonObject* request_json = @slon_http_request_json(session); \
U8* request_json_str = Json.Stringify(request_json); \
AdamLog("request_json: %s\n", request_json_str); \
Free(request_json_str);
JsonObject* SLON_HTTP_STATUS_CODES = Json.ParseFile("M:/Slon/Settings/status_codes.json");
class SlonHttpBuffer {
U8* data;
I64 size;
I64 capacity;
};
class SlonHttpRequest {
SlonHttpBuffer* buffer;
JsonObject* headers;
JsonObject* json;
U8* data;
I64 size;
U8* verb;
U8* raw_path;
U8* path;
Bool headers_have_been_parsed;
};
class SlonHttpResponse {
SlonHttpBuffer* buffer;
JsonObject* headers;
U8* data;
I64 size;
I64 status_code;
};
class SlonHttpSession {
U64 s;
SlonHttpRequest* request;
SlonHttpResponse* response;
I64 bytes_used;
JsonObject* auth;
};
U64 @slon_calloc(SlonHttpSession* session, I64 size)
{
if (!session || !size)
return NULL;
U64 res = CAlloc(size, adam_task);
session->bytes_used += MSize2(res);
// AdamLog("@slon_calloc: requested %d, total used: %d\n", MSize2(res), session->bytes_used);
return res;
}
U0 @slon_free(SlonHttpSession* session, U64 ptr)
{
if (!session || !ptr)
return;
session->bytes_used -= MSize2(ptr);
// AdamLog("@slon_free: freed %d, total used: %d\n", MSize2(ptr), session->bytes_used);
Free(ptr);
}
U64 @slon_malloc(SlonHttpSession* session, I64 size)
{
if (!session || !size)
return NULL;
U64 res = MAlloc(size, adam_task);
session->bytes_used += MSize2(res);
// AdamLog("@slon_malloc: requested %d, total used: %d\n", MSize2(res), session->bytes_used);
return res;
}
U8* @slon_strnew(SlonHttpSession* session, U8* str)
{
if (!session || !str)
return NULL;
U8* new = StrNew(str, adam_task);
session->bytes_used += MSize2(new);
// AdamLog("@slon_strnew: requested %d, total used: %d\n", MSize2(new), session->bytes_used);
// AdamLog("@slon_strnew: %s\n", new);
return new;
}
U8* @slon_http_decode_urlencoded_string(SlonHttpSession* session, U8* str)
{
if (!StrFind("%", str) && !StrFind("+", str)) {
return @slon_strnew(session, str);
}
U8* decoded_string = @slon_calloc(session, StrLen(str));
I64 i = 0;
I64 j;
U32 code_point;
while (i < StrLen(str)) {
if (str[i] == '%') {
code_point = 0;
for (j = 2; j > 0; j--) {
if (str[i + j] >= '0' && str[i + j] <= '9')
code_point += (@t(j == 1, 16, 1) * (str[i + j] - '0'));
if (str[i + j] >= 'A' && str[i + j] <= 'F')
code_point += (@t(j == 1, 16, 1) * (10 + (str[i + j] - 'A')));
if (str[i + j] >= 'a' && str[i + j] <= 'f')
code_point += (@t(j == 1, 16, 1) * (10 + (str[i + j] - 'a')));
}
String.Append(decoded_string, "%c", code_point);
i += 3;
} else if (str[i] == '+') {
String.Append(decoded_string, " ");
i++;
} else {
String.Append(decoded_string, "%c", str[i]);
i++;
}
}
return decoded_string;
}
JsonObject* @slon_http_request_json(SlonHttpSession* session)
{
if (!session->request->json)
return SLON_EMPTY_JSON_OBJECT;
return session->request->json;
}
U0 @slon_http_set_header(SlonHttpSession* session, U8* key, U8* value)
{
Json.Set(session->response->headers, key, value, JSON_STRING);
}
U0 @slon_http_set_content_type(SlonHttpSession* session, U8* value)
{
@slon_http_set_header(session, "content-type", value);
}
U0 @slon_http_set_status_code(SlonHttpSession* session, I64 status_code)
{
session->response->status_code = status_code;
}
U0 @slon_http_send_ap_json(SlonHttpSession* session, U64 json)
{
// a stringified copy of "json" is created, a strnew is sent, we clean up stringified copy, sender cleans up "json"
@slon_http_set_status_code(session, 200);
@slon_http_set_content_type(session, "application/activity+json; charset=utf-8");
U8* json_string = Json.Stringify(json);
session->response->data = @slon_strnew(session, json_string);
session->response->size = StrLen(session->response->data);
Free(json_string);
}
U0 @slon_http_send_json(SlonHttpSession* session, U64 json)
{
// a stringified copy of "json" is created, a strnew is sent, we clean up stringified copy, sender cleans up "json"
@slon_http_set_status_code(session, 200);
@slon_http_set_content_type(session, "application/json; charset=utf-8");
U8* json_string = Json.Stringify(json);
session->response->data = @slon_strnew(session, json_string);
session->response->size = StrLen(session->response->data);
Free(json_string);
}
U0 @slon_http_send_string(SlonHttpSession* session, U8* str)
{
// a strnew of "str" is sent, sender cleans up "str"
@slon_http_set_status_code(session, 200);
session->response->data = @slon_strnew(session, str);
session->response->size = StrLen(str);
}
U0 @slon_http_send(SlonHttpSession* session, U64 data, I64 size)
{
// a malloc copy of "data" is sent, sender cleans up "data"
@slon_http_set_status_code(session, 200);
U8* data_new = @slon_malloc(session, size);
MemCpy(data_new, data, size);
session->response->data = data_new;
session->response->size = size;
}
U0 @slon_http_send_file(SlonHttpSession* session, U8* path)
{
if (!session || !path)
return;
if (!FileFind(path))
return;
I64 size = 0;
U8* data = FileRead(path, &size);
@slon_http_send(session, data, size);
Free(data);
}
U0 @slon_http_send_html_file(SlonHttpSession* session, U8* path)
{
@slon_http_set_content_type(session, "text/html");
@slon_http_send_file(session, path);
}
U0 @slon_http_send_json_file(SlonHttpSession* session, U8* path, U8* content_type = "application/json; charset=utf-8")
{
@slon_http_set_content_type(session, content_type);
@slon_http_send_file(session, path);
}
U8* @slon_http_request_path(SlonHttpSession* session)
{
return session->request->path;
}
I64 @slon_http_request_verb(SlonHttpSession* session)
{
if (!StrCmp(session->request->verb, "DELETE"))
return SLON_HTTP_VERB_DELETE;
if (!StrCmp(session->request->verb, "GET"))
return SLON_HTTP_VERB_GET;
if (!StrCmp(session->request->verb, "OPTIONS"))
return SLON_HTTP_VERB_OPTIONS;
if (!StrCmp(session->request->verb, "PATCH"))
return SLON_HTTP_VERB_PATCH;
if (!StrCmp(session->request->verb, "POST"))
return SLON_HTTP_VERB_POST;
return 999;
}
U8* @slon_http_request_header(SlonHttpSession* session, U8* key)
{
U64 value = Json.Get(session->request->headers, key);
if (!value)
return "";
return value;
}
Bool @slon_http_request_has_query_string(SlonHttpSession* session)
{
return StrFind("?", session->request->raw_path) > 0 && !String.EndsWith("?", session->request->raw_path);
}

22
Slon/Modules/Log.HC Normal file
View file

@ -0,0 +1,22 @@
#define LOG_DB 100
#define LOG_HTTPD 101
U0 @slon_log(I64 module, U8* fmt, ...)
{
CDateStruct ds;
Date2Struct(&ds, Now);
AdamLog("[%02d:%02d]", ds.hour, ds.min);
switch (module) {
case LOG_DB:
AdamLog("[ slon/db] ");
break;
case LOG_HTTPD:
AdamLog("[slon/httpd] ");
break;
default:
AdamLog("[ slon/misc] ");
break;
}
AdamLog(fmt, argc, argv);
AdamLog("\n");
}

9
Slon/Modules/Meta.HC Normal file
View file

@ -0,0 +1,9 @@
U0 @slon_host_meta(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn request_json;
StrPrint(scratch_buffer, "<?xml version=\"1.0\" encoding=\"UTF-8\"?><XRD xmlns=\"http://docs.oasis-open.org/ns/xri/xrd-1.0\"><Link rel=\"lrdd\" template=\"https://%s/.well-known/webfinger?resource={uri}\"/></XRD>", db->o("instance")->@("uri"));
@slon_http_set_content_type(session, "application/xrd+xml; charset=utf-8");
@slon_http_send_string(session, scratch_buffer);
}

192
Slon/Modules/OAuth.HC Normal file
View file

@ -0,0 +1,192 @@
#define SLON_OAUTH_USERINFO_URL "https://app.simplelogin.io/oauth2/userinfo?access_token="
U0 @slon_oauth_well_known(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn request_json;
StrPrint(scratch_buffer, "{\"issuer\":\"https://%s\",\"authorization_endpoint\":\"https://%s/oauth/authorize\",\"response_types_supported\":[\"code\"],\"app_registration_endpoint\":\"https://%s/api/v1/apps\"}",
db->o("instance")->@("uri"), db->o("instance")->@("uri"), db->o("instance")->@("uri"));
@slon_http_set_content_type(session, "application/json; charset=utf-8");
@slon_http_send_string(session, scratch_buffer);
}
U0 @slon_oauth_fetch_token(U8* client_id)
{
if (!client_id || !StrLen(client_id))
return;
U8 url_string[256];
JsonObject* oauth_request = db->o("oauth")->o("requests")->@(client_id);
if (!oauth_request)
return;
U8* access_token = oauth_request->@("access_token");
if (!access_token) {
return;
}
U8* fetch_buffer = CAlloc(HTTP_FETCH_BUFFER_SIZE, adam_task);
StrPrint(url_string, "%s%s", SLON_OAUTH_USERINFO_URL, access_token);
@http_response* resp = fetch(url_string, fetch_buffer);
if (!resp)
goto oauth_free_and_return;
if (resp->body.length) {
// POSIX people think JSON should end with a new line, and the Jakt parser disagrees :^)
while (resp->body.data[StrLen(resp->body.data) - 1] == '\n')
resp->body.data[StrLen(resp->body.data) - 1] = NULL;
JsonObject* response = Json.Parse(resp->body.data);
db->o("oauth")->o("responses")->set(client_id, response, JSON_OBJECT);
}
// FIXME: Free resp
oauth_free_and_return:
Free(fetch_buffer);
Free(client_id);
}
U0 @async_slon_oauth_fetch_token(U8* client_id)
{
Spawn(&@slon_oauth_fetch_token, StrNew(client_id, adam_task), "OauthFetchTokenTask");
}
U8* @slon_oauth_generate_access_token(SlonHttpSession* session)
{
return @slon_api_generate_random_hex_string(session, 16);
}
U8* @slon_oauth_generate_authorization_code(SlonHttpSession* session)
{
return @slon_api_generate_random_hex_string(session, 16);
}
U0 @slon_oauth_verify_access_get(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
U8* client_id = request_json->@("client_id");
U8* redirect_uri = request_json->@("redirect_uri");
JsonObject* app_object = db->o("apps")->@(client_id);
// If client_id or redirect_uri are empty, or if client app doesn't exist, Bad Request
if (!StrLen(client_id) || !StrLen(redirect_uri) || !app_object) {
@slon_http_set_status_code(session, 400);
return;
}
U8* client_secret = app_object->@("client_secret");
JsonObject* userinfo = db->o("oauth")->o("responses")->@(client_id);
if (userinfo) {
// If a userinfo with the client_id exists, read the userinfo Object.
U8* email = userinfo->@("email");
if (email && StrLen(email)) {
JsonObject* acct = @slon_api_account_by_email(email);
if (acct) {
// If the account exists,
// create a token that points to the account
U8* access_token = NULL;
Bool access_token_exists = TRUE;
while (access_token_exists) {
if (access_token) {
@slon_free(session, access_token);
}
access_token = @slon_oauth_generate_access_token(session);
access_token_exists = db->o("oauth")->o("tokens")->@(access_token) > 0;
}
I64 created_at = ToF64(CDate2Unix(Now));
JsonObject* token_object = Json.CreateObject();
token_object->set("access_token", access_token, JSON_STRING);
token_object->set("token_type", "Bearer", JSON_STRING);
token_object->set("scope", "read write follow push", JSON_STRING);
token_object->set("created_at", created_at, JSON_NUMBER);
token_object->set("account_id", acct->@("id"), JSON_STRING);
token_object->set("client_id", client_id, JSON_STRING);
token_object->set("email", email, JSON_STRING);
db->o("oauth")->o("tokens")->set(access_token, token_object, JSON_OBJECT);
// FIXME: We need to commit this to disk eventually? but not immediately
U8* authorization_code = NULL;
Bool authorization_code_exists = TRUE;
while (authorization_code_exists) {
if (authorization_code) {
@slon_free(session, authorization_code);
}
authorization_code = @slon_oauth_generate_authorization_code(session);
authorization_code_exists = db->o("oauth")->o("codes")->@(authorization_code) > 0;
}
JsonObject* code_object = Json.CreateObject();
code_object->set("access_token", access_token, JSON_STRING);
code_object->set("token_type", "Bearer", JSON_STRING);
code_object->set("scope", "read write follow push", JSON_STRING);
code_object->set("created_at", created_at, JSON_NUMBER);
code_object->set("account_id", acct->@("id"), JSON_STRING);
code_object->set("client_id", client_id, JSON_STRING);
code_object->set("client_secret", client_secret, JSON_STRING);
code_object->set("email", email, JSON_STRING);
db->o("oauth")->o("codes")->set(authorization_code, code_object, JSON_OBJECT);
@slon_db_save_oauth_to_disk;
StrPrint(scratch_buffer, "%s?code=%s", redirect_uri, authorization_code);
JsonObject* redirect_uri_object = Json.CreateObject();
redirect_uri_object->set("redirect_uri", scratch_buffer, JSON_STRING);
@slon_http_send_json(session, redirect_uri_object);
Json.Delete(redirect_uri_object);
@slon_free(session, authorization_code);
@slon_free(session, access_token);
} else {
// If the account does not exist, return Not Found
@slon_http_set_status_code(session, 404);
}
} else {
// Response doesn't contain an email, therefore user is Unauthorized.
@slon_http_set_status_code(session, 401);
}
return;
} else {
if (!db->o("oauth")->o("requests")->@(client_id)) {
// If a request with the client_id does not exist, create one, and spawn a fetch() instance to retrieve the OAuth2 token.
db->o("oauth")->o("requests")->set(client_id, request_json, JSON_OBJECT);
@async_slon_oauth_fetch_token(client_id);
}
@slon_http_set_status_code(session, 202);
}
Json.Delete(app_object);
}
U0 @slon_oauth_token_post(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer;
U8* client_id = request_json->@("client_id");
U8* client_secret = request_json->@("client_secret");
U8* code = request_json->@("code");
JsonObject* code_object = db->o("oauth")->o("codes")->@(code);
if (!StrLen(client_id) || !StrLen(client_secret) || !code_object) {
// If client_id is empty, or client_secret is empty, or the code doesn't exist, it's a Bad Request.
@slon_http_set_status_code(session, 400);
return;
}
U8* access_token = code_object->@("access_token");
if (!StrCmp(client_id, code_object->@("client_id")) && !StrCmp(client_secret, code_object->@("client_secret"))) {
JsonObject* token = db->o("oauth")->o("tokens")->@(access_token);
if (token) {
@slon_http_send_json(session, token);
} else {
// If the token doesn't exist, Page Expired?
@slon_http_set_status_code(session, 419);
}
} else {
// If client_id and client_secret do not match, it's Unauthorized
@slon_http_set_status_code(session, 401);
}
Json.Delete(code_object);
}

42
Slon/Modules/Web.HC Normal file
View file

@ -0,0 +1,42 @@
U0 @slon_web_user_get(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
no_warn scratch_buffer, request_json;
I64 path_segments_count = 0;
U8** path_segments = String.Split(StrFind("@", @slon_http_request_path(session)) + 1, '/', &path_segments_count);
U8* user = path_segments[0];
if (path_segments_count == 1) {
JsonObject* actor = db->o("actors")->@(user);
if (!actor) {
@slon_http_set_status_code(session, 404);
goto slon_web_user_get_return;
}
// gib profil pl0x
I64 html_file_size;
U8* html_file_data = FileRead("M:/Slon/Static/html/user.html", &html_file_size);
U8* user_file_data = Json.Stringify(actor);
U8* html_data = @slon_calloc(session, (html_file_size * 2) + (StrLen(user_file_data) * 2));
String.Append(html_data, html_file_data);
String.Append(html_data, "<script>getStatuses(");
String.Append(html_data, user_file_data);
String.Append(html_data, ");</script>");
@slon_http_set_content_type(session, "text/html");
@slon_http_send(session, html_data, StrLen(html_data));
Free(html_file_data);
Free(user_file_data);
@slon_free(session, html_data);
goto slon_web_user_get_return;
} else {
// do something here (statuses, followers, media, etc.)
@slon_http_set_status_code(session, 404);
}
slon_web_user_get_return:
Free(path_segments);
}

39
Slon/Modules/Webfinger.HC Normal file
View file

@ -0,0 +1,39 @@
U0 @slon_webfinger(SlonHttpSession* session)
{
SLON_SCRATCH_BUFFER_AND_REQUEST_JSON
U8* resource = request_json->@("resource");
StrPrint(scratch_buffer, "@%s", db->o("instance")->@("uri"));
if (resource && String.BeginsWith("acct:", resource) && String.EndsWith(scratch_buffer, resource)) {
resource = StrFind(":", resource) + 1;
StrFind("@", resource)[0] = NULL;
if (db->o("actors")->@(resource)) {
JsonObject* webfinger_object = Json.CreateObject();
StrPrint(scratch_buffer, "acct:%s@%s", resource, db->o("instance")->@("uri"));
webfinger_object->set("subject", scratch_buffer, JSON_STRING);
JsonArray* aliases = Json.CreateArray();
StrPrint(scratch_buffer, "https://%s/@%s", db->o("instance")->@("uri"), resource);
aliases->append(Json.CreateItem(scratch_buffer, JSON_STRING));
StrPrint(scratch_buffer, "https://%s/users/%s", db->o("instance")->@("uri"), resource);
aliases->append(Json.CreateItem(scratch_buffer, JSON_STRING));
webfinger_object->set("aliases", aliases, JSON_ARRAY);
JsonArray* links = Json.CreateArray();
JsonObject* link_object = Json.CreateObject();
link_object->set("rel", "self", JSON_STRING);
link_object->set("type", "application/activity+json", JSON_STRING);
StrPrint(scratch_buffer, "https://%s/users/%s", db->o("instance")->@("uri"), resource);
link_object->set("href", scratch_buffer, JSON_STRING);
links->append(Json.CreateItem(link_object, JSON_OBJECT));
webfinger_object->set("links", links, JSON_ARRAY);
@slon_http_send_json(session, webfinger_object);
Json.Delete(webfinger_object);
} else {
@slon_http_set_status_code(session, 404);
}
} else {
@slon_http_set_status_code(session, 400);
}
}

1
Slon/Settings/status_codes.json Normal file
View file

@ -0,0 +1 @@
{"100": "Continue", "101": "Switching Protocols", "102": "Processing", "103": "Early Hints", "200": "OK", "201": "Created", "202": "Accepted", "203": "Non-Authoritative Information", "204": "No Content", "205": "Reset Content", "206": "Partial Content", "207": "Multi-Status", "208": "Already Reported", "218": "This is fine", "226": "IM Used", "300": "Multiple Choices", "301": "Moved Permanently", "302": "Found", "303": "See Other", "304": "Not Modified", "306": "Switch Proxy", "307": "Temporary Redirect", "308": "Resume Incomplete", "400": "Bad Request", "401": "Unauthorized", "402": "Payment Required", "403": "Forbidden", "404": "Not Found", "405": "Method Not Allowed", "406": "Not Acceptable", "407": "Proxy Authentication Required", "408": "Request Timeout", "409": "Conflict", "410": "Gone", "411": "Length Required", "412": "Precondition Failed", "413": "Request Entity Too Large", "414": "Request-URI Too Long", "415": "Unsupported Media Type", "416": "Requested Range Not Satisfiable", "417": "Expectation Failed", "418": "I'm a teapot", "419": "Page Expired", "420": "Method Failure", "421": "Misdirected Request", "422": "Unprocessable Entity", "423": "Locked", "424": "Failed Dependency", "426": "Upgrade Required", "428": "Precondition Required", "429": "Too Many Requests", "431": "Request Header Fields Too Large", "440": "Login Time-out", "444": "Connection Closed Without Response", "449": "Retry With", "450": "Blocked by Windows Parental Controls", "451": "Unavailable For Legal Reasons", "494": "Request Header Too Large", "495": "SSL Certificate Error", "496": "SSL Certificate Required", "497": "HTTP Request Sent to HTTPS Port", "498": "Invalid Token", "499": "Client Closed Request", "500": "Internal Server Error", "501": "Not Implemented", "502": "Bad Gateway", "503": "Service Unavailable", "504": "Gateway Timeout", "505": "HTTP Version Not Supported", "506": "Variant Also Negotiates", "507": "Insufficient Storage", "508": "Loop Detected", "509": "Bandwidth Limit Exceeded", "510": "Not Extended", "511": "Network Authentication Required", "520": "Unknown Error", "521": "Web Server Is Down", "522": "Connection Timed Out", "523": "Origin Is Unreachable", "524": "A Timeout Occurred", "525": "SSL Handshake Failed", "526": "Invalid SSL Certificate", "527": "Railgun Listener to Origin Error", "530": "Origin DNS Error", "598": "Network Read Timeout Error"}

117
Slon/Static/css/main.css Normal file
View file

File diff suppressed because one or more lines are too long

8
Slon/Static/defaults/account.json Normal file
View file

@ -0,0 +1,8 @@
{
"username": "",
"display_name": "",
"email": "",
"note": "",
"avatar": "",
"header": ""
}

44
Slon/Static/defaults/actor.json Normal file
View file

@ -0,0 +1,44 @@
{
"@context": [
"https://www.w3.org/ns/activitystreams",
"https://w3id.org/security/v1",
{
"manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
"toot": "http://joinmastodon.org/ns#",
"featured": {
"@id": "toot:featured",
"@type": "@id"
},
"featuredTags": {
"@id": "toot:featuredTags",
"@type": "@id"
},
"alsoKnownAs": {
"@id": "as:alsoKnownAs",
"@type": "@id"
},
"movedTo": {
"@id": "as:movedTo",
"@type": "@id"
},
"schema": "http://schema.org#",
"PropertyValue": "schema:PropertyValue",
"value": "schema:value",
"discoverable": "toot:discoverable",
"suspended": "toot:suspended",
"memorial": "toot:memorial",
"indexable": "toot:indexable",
"attributionDomains": {
"@id": "toot:attributionDomains",
"@type": "@id"
}
}
],
"type": "Person",
"manuallyApprovesFollowers": false,
"discoverable": false,
"indexable": false,
"memorial": false,
"tag": [],
"endpoints": {}
}

14
Slon/Static/defaults/instance.json Normal file
View file

@ -0,0 +1,14 @@
{
"uri": "error.checksum.fail",
"title": "error.checksum.fail",
"short_description": "A fediverse instance running on TempleOS",
"description": "A fediverse instance running on TempleOS",
"email": "alec@checksum.fail",
"version": "1.0.0",
"registrations": false,
"stats": {
"user_count": 0,
"status_count": 0,
"domain_count": 0
}
}

168
Slon/Static/html/admin/main.html Normal file
View file

@ -0,0 +1,168 @@
<!doctypehtml>
<link href=https://cdn.jsdelivr.net/npm/bulma@1.0.3/css/bulma.min.css rel=stylesheet>
<style>
body {
padding: 32px
}
.container-x {
width: 640px
}
.next {
text-align: right
}
.spacer {
height: 16px
}
.main-content {
padding-left: 32px;
width: 100%;
vertical-align: top
}
.menu {
width: 240px
}
</style>
<aside class="menu is-inline-block">
<p class="menu-label">Info</p>
<ul class="menu-list">
<li><a onclick="infoStats()" id="menuitem-stats">Statistics</a></li>
</ul>
<p class="menu-label">Manage</p>
<ul class="menu-list">
<li><a onclick="manageAccounts()" id="menuitem-accounts">Accounts</a></li>
<li><a onclick="manageInstance()" id="menuitem-instance">Instance</a></li>
</ul>
<p class="menu-label">Diagnostics</p>
<ul class="menu-list">
<li><a onclick="diagsLogs()" id="menuitem-logs">Logs</a></li>
</ul>
</aside>
<div id="content" class="container main-content is-inline-block">
</div>
<script>
function clearActiveLinks() {
document.querySelectorAll("a").forEach(function (a) { a.className = ""; });
}
function setActiveLink(link) {
document.getElementById("menuitem-" + link).className = "is-active";
}
function setContent(html) {
document.getElementById("content").innerHTML = html;
}
async function infoStats() {
clearActiveLinks();
const request = new Request("/info/stats");
const response = await fetch(request);
const stats = await response.json();
let html = "<h4 class=\"title is-4\">Statistics</h4><div class=spacer></div><div>Uptime: " + formatTime(stats["uptime"]) + "</div>";
setContent(html);
setActiveLink("stats");
}
async function manageAccounts() {
clearActiveLinks();
const request = new Request("/manage/accounts");
const response = await fetch(request);
const accounts = await response.json();
let html = "<h4 class=\"title is-4\">Accounts</h4><div class=spacer></div>";
if (accounts.length) {
html += "<table class=table><thead><tr><th>id</th><th>username</th></tr></head><tbody>";
for (let i = 0; i < accounts.length; i++) {
html += "<tr><td>" + accounts[i]["id"] + "</td><td>" + accounts[i]["username"] + "</td><tr>";
}
html += "</tbody></table>";
} else {
html += "No users";
}
html += "<br><br><input onclick=manageNewUser() class=button type=button value=\"New User\">";
setContent(html);
setActiveLink("accounts");
}
function manageNewUser() {
clearActiveLinks();
let html = "<h4 class=\"title is-4\">New User</h4><div class=spacer></div>";
html += "<form action=\"javascript:saveNewUser()\"><div>";
html += "<div class=\"section is-inline-block\" style=\"width:420px;vertical-align:top\">";
html += "<label class=label>Username</label><div class=control><input id=username class=input placeholder=baoh required autocomplete=off></div><div class=spacer></div>";
html += "<label class=label>Display Name</label><div class=control><input id=display_name class=input placeholder=\"Ikuro Hashizawa\" required autocomplete=off></div><div class=spacer></div>";
html += "<label class=label>Email</label><div class=control><input id=email class=input type=email placeholder=\"cooldude42069@checksum.fail\" required autocomplete=off></div><div class=spacer></div>";
html += "<label class=label>Bio</label><div class=control><input id=bio class=input placeholder=\"ima firin mah lazer cannon\" required autocomplete=off></div><div class=spacer></div>";
html += "</div>";
html += "<div class=\"section is-inline-block\" style=\"width:420px;vertical-align:top\">";
html += "<label class=label>Avatar</label><div class=control><input id=avatar class=input placeholder=\"https://full.path.to/my/avatar.png\" required autocomplete=off></div><div class=spacer></div>";
html += "<label class=label>Header</label><div class=control><input id=header class=input placeholder=\"https://full.path.to/my/header.png\" required autocomplete=off></div><div class=spacer></div>";
html += "<label class=label>Private Key (must be in DER format)</label><div class=control><input onchange=updateBase64(this) id=privatekey type=file required autocomplete=off></div><div class=spacer></div>";
html += "<label class=label>Public Key (must be in PEM format)</label><div class=control><input onchange=updateBase64(this) id=publickey type=file required autocomplete=off></div><div class=spacer></div>";
html += "</div>";
html += "</div>";
html += "<div class=\"control next\"><input class=\"button is-link\" type=submit value=Save></div>"
html += "</div></form>";
setContent(html);
setActiveLink("accounts");
}
async function saveNewUser() {
let data = {};
let fields = document.getElementsByTagName("input");
for (var i = 0; i < fields.length; i++) {
switch (fields[i].type) {
case "checkbox":
data[fields[i].id] = fields[i].checked;
break;
case "file":
data[fields[i].id] = fields[i].base64;
break;
case "submit":
break;
default:
data[fields[i].id] = fields[i].value;
break;
}
}
const request = new Request("/new/account", {
headers: { "Content-Type": "application/json" },
method: "POST",
body: JSON.stringify(data)
});
const response = await fetch(request);
const json = await response.json();
if (!Object.keys(json).length) {
manageAccounts();
} else {
alert(JSON.stringify(json));
}
}
function updateBase64(el) {
let reader = new FileReader();
reader.readAsDataURL(el.files[0]);
reader.addEventListener(
"load",
() => {
el.base64 = reader.result.split(";base64,")[1];
}
);
}
const formatTime = milliseconds => {
const seconds = Math.floor((milliseconds / 1000) % 60);
const minutes = Math.floor((milliseconds / 1000 / 60) % 60);
const hours = Math.floor((milliseconds / 1000 / 60 / 60) % 24);
return [
hours.toString().padStart(2, "0"),
minutes.toString().padStart(2, "0"),
seconds.toString().padStart(2, "0")
].join(":");
}
addEventListener("DOMContentLoaded", (event) => {
infoStats();
})
document.querySelectorAll("input[type=file]").forEach(function (e) {
a.className = "";
});
</script>

83
Slon/Static/html/admin/setup_instance.html Normal file
View file

@ -0,0 +1,83 @@
<!doctypehtml>
<link href=https://cdn.jsdelivr.net/npm/bulma@1.0.3/css/bulma.min.css rel=stylesheet>
<style>
body {
padding: 32px
}
.container {
width: 640px
}
.next {
text-align: right
}
.spacer {
height: 16px
}
</style>
<div class=container>
<nav class=panel>
<form action="javascript:setupInstance()">
<p class=panel-heading>Setup
<div class=section>
<p>Enter the following information to set up your Slon instance.
<div class=spacer></div>
<label class=label>URI</label>
<div class=control><input id=uri class=input placeholder=my-slon-instance.foo required
autocomplete=off></div>
<div style=height:16px></div>
<label class=label>Title</label>
<div class=control><input id=title class=input placeholder="My Slon Instance" required
autocomplete=off></div>
<div class=spacer></div>
<label class=label>Description</label>
<div class=control><input id=description class=input
placeholder="A fediverse instance running on TempleOS" required autocomplete=off></div>
<div class=spacer></div>
<label class=label>Administrator Email</label>
<div class=control><input id=email class=input placeholder=alec@checksum.fail required type=email
autocomplete=off>
</div>
<div class=spacer></div>
<label class=checkbox><input id=registrations type=checkbox> Enable
registrations</label>
<div class="control next"><input class="button is-link" type=submit value=Next></div>
</div>
</form>
</nav>
</div>
<script>
addEventListener("DOMContentLoaded", (event) => {
document.getElementById("uri").focus();
})
async function setupInstance() {
let data = {};
let fields = document.getElementsByTagName("input");
for (var i = 0; i < fields.length; i++) {
switch (fields[i].type) {
case "checkbox":
data[fields[i].id] = fields[i].checked;
break;
case "submit":
break;
default:
data[fields[i].id] = fields[i].value;
break;
}
}
const request = new Request("/setup/instance", {
headers: { "Content-Type": "application/json" },
method: "POST",
body: JSON.stringify(data)
});
const response = await fetch(request);
const json = await response.json();
window.location = "/";
}
</script>

29
Slon/Static/html/user.html Normal file
View file

@ -0,0 +1,29 @@
<!doctypehtml>
<title></title>
<link href=https://error.checksum.fail/css/12391289038129038.css rel=stylesheet>
<link href=https://linusg.github.io/serenityos-emoji-font/SerenityOS-Emoji.css rel=stylesheet>
<style>
* {
font-family: "SerenityOS Emoji", "TempleOS", -apple-system, BlinkMacSystemFont, avenir next, avenir, segoe ui, helvetica neue, helvetica, Cantarell, Ubuntu, roboto, noto, arial, sans-serif
}
.pix {
image-rendering: pixelated
}
</style>
<div class=page-container>
<div class=page-header></div>
<div class=page-content>
<br>
<br>
<center><font style="color: #fff">Loading Statuses...</font><img class="text-cursor"></center>
<br>
</div>
<div class=page-footer>This server is powered by <a href=https://slon-project.org>Slon</a>, a
Mastodon-compatible fediverse instance for TempleOS, written in HolyC</div>
</div>
<script src="https://cdn.jsdelivr.net/npm/dayjs@1/dayjs.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/dayjs@1/plugin/relativeTime.js"></script>
<script>dayjs.extend(window.dayjs_plugin_relativeTime)</script>
<script src=https://error.checksum.fail/js/header.js></script>
<script src=https://error.checksum.fail/js/12389290138092193.js></script>

3
Slon/Static/js/header.js Normal file
View file

@ -0,0 +1,3 @@
let lastFrameTime=0,fps=0;function calculateFPS(){requestAnimationFrame(()=>{const a=performance.now();fps=1E3/(a-lastFrameTime);lastFrameTime=a;calculateFPS()})}
function updatePageHeader(){var a=new Date,c=a.toString().substring(0,3);const d=String(a.getMonth()+1).padStart(2,"0"),e=String(a.getDate()).padStart(2,"0");a=a.toString().substring(16,24);const f="CPU <b>"+(10*Math.random()).toFixed(0)+"</b>";if(navigator.userAgent.toLowerCase().includes("firefox"))var b=3735929054;else b=performance.memory,b=b.jsHeapSizeLimit-b.usedJSHeapSize;c=c+" "+d+"/"+e+" "+a+" FPS:"+fps.toFixed(0)+" Mem:"+b.toString(16).toUpperCase()+" "+f;document.getElementsByClassName("page-header")[0].innerHTML=
c}calculateFPS();updatePageHeader();setInterval(updatePageHeader,300);

132
Slon/Static/js/statuses.js Normal file
View file

@ -0,0 +1,132 @@
function updateStatusContainers() {
let els = document.getElementsByClassName('status-container');
for (var n = 0; n < els.length; n++) {
let pc = els[n];
let post_html = ""
let horizontal_fill_count = ((pc.offsetWidth - 32) / 16);
let url = pc.getElementsByTagName('url')[0].textContent;
let marqueeHref = url == "Unnamed Task" ? window.location : url;
post_html += "<b>\u2554";
for (var i = 0; i < (horizontal_fill_count / 2) - ((240 / 16) / 2); i++) {
post_html += "\u2550";
}
post_html += "<a href=\"" + marqueeHref + "\"><marquee scrollamount=16>" + url + "...</marquee></a>";
for (var i = 0; i < (horizontal_fill_count / 2) - ((240 / 16) / 2) - 2; i++) {
post_html += "\u2550";
}
post_html += "[X]\u2557<br></b>";
let height = Math.ceil(pc.getElementsByClassName('status-content')[0].offsetHeight / 16);
let desc = "Term";
for (var y = 0; y < height; y++) {
let ch = y < 4 ? desc[y] : "\u2551";
post_html += "<b>" + ch + "<div style=\"display: inline-block; height: 16px; width: " + ((horizontal_fill_count + 1) * 16).toString() + "px\"></div>\u2551</b><br>";
}
post_html += "<b>\u255a";
for (var i = 0; i < (horizontal_fill_count + 1); i++) {
post_html += "\u2550";
}
post_html += "\u255d<br></b>";
pc.innerHTML += post_html;
pc.style.display = "inline";
}
}
function smolDate(a){return a.split(" ago")[0].replace("a ","1").replace("an ","1").replace("days","d").replace("day","d").replace("hours","h").replace("hour","h").replace("minutes","m").replace("minute","m").replace("seconds","s").replace("second","s").replace("few","").replace(" ","")};
function updateStatuses(user, statuses) {
let pageContent = document.getElementsByClassName("page-content")[0];
let elements = document.createElement('div');
let container = document.createElement('div');
container.className = "status-container";
// Render user profile
{
let content = document.createElement('div');
content.className = "status-content";
let content_html = "";
content_html += "<div class=status-avatar style=margin:16px;background:url(" + user["icon"]["url"] + ");width:72px;height:72px;background-size:contain;background-repeat:no-repeat></div>";
content_html += "<div class=status-header>" + user["preferredUsername"] + "<br><a href=" + user["url"] + ">@" + user["preferredUsername"] + "@" + location.host + "</a></div>"
content_html += "<div class=status-text><font style=color:#0>" + user["summary"] + "</font></div>";
content_html += "<div class=status-text>Joined " + new Date(Date.parse(user["published"])).toString().substr(0,15) + "</div>";
content.innerHTML = content_html;
let url = document.createElement('url');
url.textContent = window.location;
let menuImg = document.createElement('img');
menuImg.className = "text-menu";
content.appendChild(menuImg);
container.appendChild(content);
container.appendChild(url);
elements.appendChild(container);
let spacer = document.createElement('div');
spacer.style.height = "16px";
elements.appendChild(spacer);
}
elements.className = "statuses";
statuses.sort((a,b) => b.id - a.id);
for (var i = 0; i < statuses.length; i++) {
let status = statuses[i];
let container = document.createElement('div');
container.className = "status-container";
let content = document.createElement('div');
content.className = "status-content";
let content_html = "";
if (status["visibility"] == "public") {
content_html += "<span title=Public>&#127758;</span> ";
}
content_html += "<span class=status-timestamp>" + smolDate(dayjs(status["created_at"]).fromNow()) + "</span><br></div>";
content_html += "<div class=status-text>" + status["content"] + "</div>";
content_html += "<span class=status-counts>&#128172; " + status["replies_count"] + " &#128257; " + status["reblogs_count"] + " &#11088; " + status["favourites_count"] + "</span>";
content_html += "<div class=status-footer>via <a href=" + status["application"]["website"] + ">" + status["application"]["name"] + "</a></div>";
content.innerHTML = content_html;
let url = document.createElement('url');
url.textContent = status["url"];
let menuImg = document.createElement('img');
menuImg.className = "text-menu";
content.appendChild(menuImg);
container.appendChild(content);
container.appendChild(url);
elements.appendChild(container);
if (i < statuses.length - 1) {
let spacer = document.createElement('div');
spacer.style.height = "16px";
elements.appendChild(spacer);
}
}
if (!statuses.length) {
let container = document.createElement('div');
container.className = "status-container";
let content = document.createElement('div');
content.className = "status-content";
let content_html = "";
content_html += "<div class=nostatus><font style=color:#0000a8>&FileRead &StatusRead &StatusPrint &ExeCmdLine <img class=text-error> No statuses found.\n " + Math.random().toFixed(6) + "s ans=0x00000000=0<br>C:/Home><img class=text-cursor></font></div>";
content.innerHTML = content_html;
let url = document.createElement('url');
url.textContent = "Unnamed Task";
let menuImg = document.createElement('img');
menuImg.className = "text-menu";
content.appendChild(menuImg);
container.appendChild(content);
container.appendChild(url);
elements.appendChild(container);
}
pageContent.innerHTML = "";
pageContent.appendChild(elements);
updateStatusContainers();
}
function getStatuses(user) {
fetch("https://error.checksum.fail/api/v1/accounts/" + user["accountId"] + "/statuses", {
method: 'GET',
headers: {'Accept': 'application/json' }
})
.then(response => response.json())
.then(data => updateStatuses(user, data));
}

12
Slon/Static/oauth/authorize.html Normal file
View file

@ -0,0 +1,12 @@
<html>
<body>
<script src="https://cdn.jsdelivr.net/gh/IdentityModel/oidc-client-js@1.8/dist/oidc-client.min.js"></script>
<script>
var retry_count = 0, retry_timeout = 2E3; function retryVerifyAccess() { 3 < ++retry_count ? alert("Retry limit exceeded") : setTimeout(verifyAccess, retry_timeout) }
async function verifyAccess() { try { var b = localStorage.getItem("authorize"); if (null != b) { const a = await fetch("https://" + window.location.host + "/oauth/verify_access?" + b + window.location.hash.substring(1)); if (a.ok) { const c = await a.json(); window.location = c.redirect_uri } else 202 == a.status ? retryVerifyAccess() : alert("Unexpected response status: " + a.status.toString()) } } catch (a) { retryVerifyAccess() } }
var settings = { authority: "https://app.simplelogin.io/", client_id: "templeosfediverseserver-yssuxmkust", response_type: "id_token token", scope: "openid", redirect_uri: "https://" + window.location.host + "/oauth/authorize" }, mgr = new Oidc.UserManager(settings); window.location.search && localStorage.setItem("authorize", window.location.search.replace("?", "").replace("state", "client_state") + "&"); window.location.hash ? verifyAccess() : mgr.signinRedirect();
</script>
</body>
</html>