lda/telodendria
lda/telodendria
1
1
Fork 1
forked from Telodendria/Telodendria
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: lda:roomwerk
Branches Tags
lda:master
lda:roomwerk
lda:fix-configure
lda:fix-doublefree
lda:fix-mistake
lda:implement-22-9
lda:contribute
lda:replace-config-j2s
lda:setup-ci-workflows
lda:refactor-matrix-error-create
lda:implement-22
lda:refactor-6
lda:implement-26
lda:implement-27
lda:fix-33
lda:jordan
lda:initial
Telodendria:master
lda:Telodendria-0_3_0
lda:Telodendria-0_2_1
lda:Telodendria-0_2_0
lda:Telodendria-0_1_0
Telodendria:Telodendria-0_1_0
Telodendria:Telodendria-0_2_0
Telodendria:Telodendria-0_2_1
Telodendria:Telodendria-0_3_0
..
compare: lda:master
Branches Tags
lda:roomwerk
lda:master
lda:fix-configure
lda:fix-doublefree
lda:fix-mistake
lda:implement-22-9
lda:contribute
lda:replace-config-j2s
lda:setup-ci-workflows
lda:refactor-matrix-error-create
lda:implement-22
lda:refactor-6
lda:implement-26
lda:implement-27
lda:fix-33
lda:jordan
lda:initial
Telodendria:master
lda:Telodendria-0_3_0
lda:Telodendria-0_2_1
lda:Telodendria-0_2_0
lda:Telodendria-0_1_0
Telodendria:Telodendria-0_1_0
Telodendria:Telodendria-0_2_0
Telodendria:Telodendria-0_2_1
Telodendria:Telodendria-0_3_0

No commits in common. "roomwerk" and "master" have entirely different histories.
roomwerk ... master

57 changed files with 125 additions and 7712 deletions
Show stats Expand all files Collapse all files

2
.gitignore vendored
View file

@ -16,5 +16,3 @@ contrib/.vagrant
src/Schema
src/include/Schema
man/mandoc.db
*swp
.ccls-cache

3
Schema/ClientEvent.json
View file

@ -45,9 +45,6 @@
"state_key": {
"type": "string"
},
"redacts": {
"type": "string"
},
"type": {
"type": "string",
"required": true

25
Schema/PduV1.json
View file

@ -2,16 +2,6 @@
"guard": "TELODENDRIA_SCHEMA_PDUV1_H",
"header": "Schema/PduV1.h",
"types": {
"PduV1Status": {
"type": "enum",
"fields": {
"dropped": { "name": "PDUV1_STATUS_DROPPED" },
"softfail": { "name": "PDUV1_STATUS_SOFTFAIL" },
"accepted": { "name": "PDUV1_STATUS_ACCEPTED" },
"rejected": { "name": "PDUV1_STATUS_REJECTED" }
}
},
"PduV1EventHash": {
"type": "struct",
"fields": {
@ -26,18 +16,6 @@
"fields": {
"age": {
"type": "integer"
},
"next_events": {
"type": "[string]",
"required": false
},
"pdu_status": {
"type": "PduV1Status",
"required": false
},
"redacted_because": {
"type": "object",
"required": false
}
}
},
@ -73,8 +51,7 @@
"required": true
},
"redacts": {
"type": "string",
"required": false
"type": "string"
},
"room_id": {
"type": "string",

19
Schema/Relation.json
View file

@ -1,19 +0,0 @@
{
"guard": "TELODENDRIA_SCHEMA_RELATION_H",
"header": "Schema/Relation.h",
"types": {
"Relation": {
"type": "struct",
"fields": {
"event_id": {
"type": "string",
"required": true
},
"rel_type": {
"type": "string",
"required": true
}
}
}
}
}

113
Schema/SyncResponse.json
View file

@ -1,113 +0,0 @@
{
"guard": "TELODENDRIA_SCHEMA_SYNCRESPONSE_H",
"header": "Schema\/SyncResponse.h",
"types": {
"Event": {
"fields": {
"content": {
"type": "object",
"required": true
},
"type": {
"type": "string",
"required": true
}
},
"type": "struct"
},
"AccountData": {
"fields": {
"events": { "type": "[Event]" }
},
"type": "struct"
},
"InviteState": {
"fields": {
"events": { "type": "[StrippedStateEvent]" }
},
"type": "struct"
},
"States": {
"fields": {
"events": { "type": "[StrippedStateEvent]" }
},
"type": "struct"
},
"StrippedStateEvent": {
"fields": {
"content": {
"type": "object",
"required": true
},
"sender": {
"type": "string",
"required": true
},
"state_key": {
"type": "string",
"required": true
},
"type": {
"type": "string",
"required": true
}
},
"type": "struct"
},
"InvitedRooms": {
"fields": {
"invite_state": { "type": "InviteState" }
},
"type": "struct"
},
"ClientEventWithoutRoomID": {
"fields": {
"content": { "type": "object", "required": true },
"event_id": { "type": "string", "required": true },
"origin_server_ts": { "type": "integer", "required": true },
"sender": { "type": "string", "required": true },
"state_key": { "type": "string" },
"redacts": { "type": "string" },
"type": { "type": "string", "required": true }
},
"type": "struct"
},
"Timeline": {
"fields": {
"events": { "type": "[ClientEventWithoutRoomID]", "required": true },
"limited": { "type": "boolean" },
"prev_batch": { "type": "string" }
},
"type": "struct"
},
"JoinedRooms": {
"fields": {
"timeline": { "type": "Timeline" },
"state": { "type": "States" }
},
"type": "struct"
},
"Rooms": {
"fields": {
"invite": { "type": "{InvitedRooms}" },
"join": { "type": "{JoinedRooms}" }
},
"type": "struct"
},
"SyncResponse": {
"fields": {
"next_batch": {
"type": "string",
"required": true
},
"account_data": {
"type": "AccountData"
},
"rooms": {
"type": "Rooms"
}
},
"type": "struct"
}
}
}

4
configure vendored
View file

@ -15,7 +15,7 @@ TOOLS="tools/src"
SCHEMA="Schema"
CYTOPLASM="Cytoplasm"
CFLAGS="-O1 -D_DEFAULT_SOURCE -I${INCLUDE} -I${SRC} -I${BUILD}"
CFLAGS="-O1 -D_DEFAULT_SOURCE -I${INCLUDE} -I${BUILD}"
LIBS="-lm -pthread -lCytoplasm"
@ -155,7 +155,7 @@ print_obj() {
get_deps() {
src="$1"
${CC} -I${SRC} -I${INCLUDE} -I${BUILD} $(if [ -n "${CYTOPLASM}" ]; then echo "-I${CYTOPLASM}/include"; fi) -E "$src" \
${CC} -I${INCLUDE} -I${BUILD} $(if [ -n "${CYTOPLASM}" ]; then echo "-I${CYTOPLASM}/include"; fi) -E "$src" \
| grep '^#' \
| awk '{print $3}' \
| cut -d '"' -f 2 \

6
contrib/Makefile Normal file
View file

@ -0,0 +1,6 @@
all:
sh tools/bin/td
install:
install build/telodendria $(PREFIX)/bin/telodendria
find man -name 'telodendria*\.[1-8]' -exec install {} $(PREFIX)/{} \;

2
docs/user/admin/privileges.md
View file

@ -14,8 +14,6 @@ administrator API; the regular Matrix API is unaffected.
registration tokens.
- **CONFIG:** Allows a user to modify the Telodendria server daemon's
configuration.
- **APPSERVICE:** Allows a user to register and manage application
services.
- **GRANT_PRIVILEGES:** Allows a user to modify his or her own
privileges or the privileges of other local users.
- **ALIAS:** Allows a user to modify and see room aliases created by

57
src/CanonicalJson.c
View file

@ -22,16 +22,11 @@
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include "Cytoplasm/Io.h"
#include "Cytoplasm/Stream.h"
#include <CanonicalJson.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Array.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <Cytoplasm/Sha.h>
#include <stdio.h>
#include <string.h>
@ -164,55 +159,3 @@ CanonicalJsonEncode(HashMap * object, Stream * out)
ArrayFree(keys);
return length;
}
static ssize_t
StringIoRead(void *cookie, void *buf, size_t count)
{
(void) cookie;
(void) buf;
(void) count;
return -1; /* TODO: Consider reading properly */
}
static ssize_t
StringIoWrite(void *c, void *buf, size_t count)
{
if (count > 0)
{
char **str = c;
char *stringised = Malloc(count + 1);
char *new;
memcpy(stringised, buf, count);
new = StrConcat(2, *str, stringised);
Free(stringised);
if (*str)
{
Free(*str);
}
*str = new;
}
return count;
}
static const IoFunctions Functions = {
.read = StringIoRead,
.write = StringIoWrite,
.close = NULL,
.seek = NULL
};
unsigned char *
CanonicalJsonHash(HashMap *json)
{
char *string = NULL;
unsigned char *sha;
Io *string_writer = IoCreate(&string, Functions);
Stream *io_stream = StreamIo(string_writer);
CanonicalJsonEncode(json, io_stream);
StreamFlush(io_stream);
sha = Sha256(string);
Free(string);
StreamClose(io_stream);
return sha;
}

21
src/Config.c
View file

@ -230,24 +230,3 @@ ConfigLogLevelToSyslog(ConfigLogLevel level)
}
return LOG_INFO;
}
char *
ConfigGetServerName(Db * db)
{
char *name;
Config config;
ConfigLock(db, &config);
if (!config.ok)
{
return NULL;
}
name = StrDuplicate(config.serverName);
ConfigUnlock(&config);
return name;
}

250
src/Filter.c
View file

@ -24,256 +24,12 @@
*/
#include <Filter.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <string.h>
#include <stdio.h>
#include <Schema/Filter.h>
#include <Matrix.h>
/* Verifies whenever an item passes through a set of blacklisted and
* whitelisted groups(e.g "not_rooms"/"rooms"), and makes the calling
* function return true/false if it is explicitely in a filtered list,
* or does nothing otherwise, to allow for chaining multiple filters. */
#define DAFiltered(blacklist, whitelist, item) \
do \
{ \
size_t i, count; \
count = ArraySize(blacklist); \
for (i = 0; i < count; i++) \
{ \
char *notItem = ArrayGet(blacklist, i); \
if (StrEquals(item, notItem)) \
{ \
return true; \
} \
} \
count = ArraySize(whitelist); \
if (count) \
{ \
for (i = 0; i < count; i++) \
{ \
char *yesItem = ArrayGet(whitelist, i); \
if (StrEquals(yesItem, item)) \
{ \
return false; \
} \
} \
return true; \
} \
} while (0)
static bool
IsSenderFiltered(Filter *filter, char *senderID)
{
if (!filter || !senderID)
{
return false;
}
DAFiltered(
filter->room.account_data.not_senders,
filter->room.account_data.senders,
senderID
);
DAFiltered(
filter->room.state.not_senders,
filter->room.state.senders,
senderID
);
DAFiltered(
filter->room.ephemeral.not_senders,
filter->room.ephemeral.senders,
senderID
);
return false;
}
bool
IsRoomFiltered(Filter *filter, char *roomID)
{
if (!filter || !roomID)
{
return false;
}
DAFiltered(
filter->room.not_rooms,
filter->room.rooms,
roomID
);
DAFiltered(
filter->room.account_data.not_rooms,
filter->room.account_data.rooms,
roomID
);
DAFiltered(
filter->room.state.not_rooms,
filter->room.state.rooms,
roomID
);
DAFiltered(
filter->room.ephemeral.not_rooms,
filter->room.ephemeral.rooms,
roomID
);
return false;
}
static HashMap *
IncludeFields(Array * fields, HashMap * event)
{
HashMap *cpy;
size_t i, len;
if (!event)
{
return NULL;
}
if (!fields)
{
return JsonDuplicate(event);
}
cpy = HashMapCreate();
/* NOTE: We intentionally add some fields due to some requirements
* around certain schemas. The specification does find such behavior
* compliant:
* > "[...] A server may include more fields than were requested." */
#define CopyField(field) \
HashMapSet(cpy, field, JsonValueDuplicate(HashMapGet(event, field)))
CopyField("event_id");
CopyField("origin_server_ts");
CopyField("sender");
CopyField("type");
len = ArraySize(fields);
for (i = 0; i < len; i++)
{
char *field = ArrayGet(fields, i);
JsonValue *val = JsonValueDuplicate(MatrixGetJSON(event, field));
JsonValueFree(MatrixSetJSON(cpy, field, val));
}
/* Only copy it if not already present. */
if (!HashMapGet(cpy, "content"))
{
CopyField("content");
}
#undef CopyField
return cpy;
}
/* TODO: MORE FILTERS! */
HashMap *
FilterApply(Filter * filter, HashMap * event)
{
HashMap *copy;
char *sender, *room;
if (!event)
{
return NULL;
}
if (!filter)
{
/* Do NOT filter anything out */
return JsonDuplicate(event);
}
sender = JsonValueAsString(HashMapGet(event, "sender"));
room = JsonValueAsString(HashMapGet(event, "room_id"));
if (IsRoomFiltered(filter, room) ||
IsSenderFiltered(filter, sender))
{
return NULL;
}
copy = IncludeFields(filter->event_fields, event);
return copy;
}
Filter *
FilterDecode(Db *db, char *user, char *filterStr, char **errp)
{
Filter *ret;
DbRef *filterRef;
HashMap *filterObj;
FILE *fakeFile;
Stream *fakeStream;
char *err;
if (!db || !user || !filterStr)
{
if (errp)
{
*errp =
"Internal error: Field required for FilterDecode is missing.";
}
return NULL;
}
if (*filterStr != '{')
{
filterRef = DbLock(db, 3, "filters", user, filterStr);
filterObj = DbJson(filterRef);
ret = Malloc(sizeof(*ret));
memset(ret, 0, sizeof(*ret));
if (!FilterFromJson(filterObj, ret, &err))
{
if (errp)
{
*errp = err;
}
DbUnlock(db, filterRef);
Free(ret);
return NULL;
}
DbUnlock(db, filterRef);
return ret;
}
/* TODO: This should be it's own JSON function, in my
* opinion. */
fakeFile = fmemopen(filterStr, strlen(filterStr), "r");
fakeStream = StreamFile(fakeFile);
filterObj = JsonDecode(fakeStream);
StreamClose(fakeStream); /* auto-frees fakeFile */
ret = Malloc(sizeof(*ret));
memset(ret, 0, sizeof(*ret));
if (!FilterFromJson(filterObj, ret, &err))
{
if (errp)
{
*errp = err;
}
JsonFree(filterObj);
Free(ret);
return NULL;
}
JsonFree(filterObj);
return ret;
}
void
FilterDestroy(Filter *filter)
{
if (!filter)
{
return;
}
FilterFree(filter);
Free(filter);
(void) filter;
(void) event;
return NULL;
}

2
src/Html.c
View file

@ -46,7 +46,7 @@ HtmlBegin(Stream * stream, char *title)
"<meta name=\"viewport\" content=\"width=device-width,initial-scale=1\">"
"<title>%s | Telodendria</title>"
"<link rel=\"stylesheet\" href=\"/_matrix/static/telodendria.css\">"
"<script src=\"/_matrix/static/telodendria.js\"></script>"
"<script src=\"/_matrix/static/telodendria.js\"></script>"
"</head>"
"<body>"
"<pre class=\"logo\">"

41
src/Main.c
View file

@ -79,8 +79,6 @@ SignalHandler(int signal)
for (i = 0; i < ArraySize(httpServers); i++)
{
HttpServer *server = ArrayGet(httpServers, i);
/* TODO: Notify all users, so that the server doesn't have to
* await for a sync reply. */
HttpServerStop(server);
}
@ -88,26 +86,6 @@ SignalHandler(int signal)
}
}
/* TODO: Move this! */
static void
UsersClean(MatrixHttpHandlerArgs *args)
{
Db *db = args->db;
Array *arr = DbList(db, 1, "users");
size_t i;
for (i = 0; i < ArraySize(arr); i++)
{
char *id = ArrayGet(arr, i);
User *user = UserLock(db, id);
UserCleanTemporaryData(user);
UserUnlock(user);
}
DbListFree(arr);
}
typedef enum ArgFlag
{
ARG_VERSION = (1 << 0),
@ -165,12 +143,10 @@ start:
userInfo = NULL;
groupInfo = NULL;
cron = NULL;
tConfig.ok = false;
token = NULL;
memset(&matrixArgs, 0, sizeof(matrixArgs));
UserInitialisePushTable();
if (!LogConfigGlobal())
{
@ -299,8 +275,7 @@ start:
goto finish;
}
if (!tConfig.log.timestampFormat ||
!StrEquals(tConfig.log.timestampFormat, "default"))
if (!tConfig.log.timestampFormat || !StrEquals(tConfig.log.timestampFormat, "default"))
{
LogConfigTimeStampFormatSet(LogConfigGlobal(), tConfig.log.timestampFormat);
}
@ -538,15 +513,10 @@ start:
Log(LOG_DEBUG, "Registering jobs...");
CronEvery(cron, 30 * 60 * 1000, (JobFunc *) UiaCleanup, &matrixArgs);
CronEvery(cron, 5 * 60 * 1000, (JobFunc *) UsersClean, &matrixArgs);
Log(LOG_NOTICE, "Starting job scheduler...");
CronStart(cron);
/* We still call it anyways to be sure. */
Log(LOG_NOTICE, "Cleaning up user data...");
UsersClean(&matrixArgs);
Log(LOG_NOTICE, "Building routing tree...");
matrixArgs.router = RouterBuild();
if (!matrixArgs.router)
@ -613,7 +583,6 @@ start:
finish:
Log(LOG_NOTICE, "Shutting down...");
UserDestroyPushTable();
if (httpServers)
{
for (i = 0; i < ArraySize(httpServers); i++)
@ -637,11 +606,9 @@ finish:
CronFree(cron);
Log(LOG_DEBUG, "Stopped and freed job scheduler.");
}
if (tConfig.ok)
{
ConfigUnlock(&tConfig);
Log(LOG_DEBUG, "Unlocked configuration.");
}
ConfigUnlock(&tConfig);
Log(LOG_DEBUG, "Unlocked configuration.");
DbClose(matrixArgs.db);
Log(LOG_DEBUG, "Closed database.");

149
src/Matrix.c
View file

@ -360,152 +360,3 @@ MatrixClientWellKnown(char *base, char *identity)
return response;
}
JsonValue *
MatrixGetJSON(HashMap *json, char *string)
{
JsonValue *retVal;
HashMap *currentObj;
char *field, *fieldTemp;
size_t i, length;
if (!json || !string)
{
return NULL;
}
currentObj = json;
retVal = NULL;
length = strlen(string);
field = NULL;
#define Append(ch) do \
{ \
char chb[2] = { ch, 0 }; \
fieldTemp = field; \
field = StrConcat(2, field, chb); \
Free(fieldTemp); \
} while (0)
/* We include the 0-terminator as a valid separator. */
for (i = 0; i < length + 1; i++)
{
char currentChar = string[i];
char escape;
if (currentChar == '\\' && (escape = string[i+1]))
{
if (escape != '.' && escape != '\\')
{
Append('\\');
}
Append(escape);
i++;
continue;
}
else if (currentChar == '.' || currentChar == '\0')
{
if (!field || !currentObj)
{
Free(field);
return NULL;
}
retVal = HashMapGet(currentObj, field);
currentObj = JsonValueAsObject(retVal);
Free(field);
field = NULL;
continue;
}
Append(currentChar);
}
#undef Append
if (field)
{
/* This is weird. */
Free(field);
}
return retVal;
}
JsonValue *
MatrixSetJSON(HashMap *json, char *string, JsonValue *new)
{
JsonValue *retVal;
HashMap *currentObj;
char *field, *fieldTemp;
size_t i, length;
if (!json || !string || !new)
{
return NULL;
}
currentObj = json;
retVal = NULL;
length = strlen(string);
field = NULL;
#define Append(ch) do \
{ \
char chb[2] = { ch, 0 }; \
fieldTemp = field; \
field = StrConcat(2, field, chb); \
Free(fieldTemp); \
} while (0)
/* We include the 0-terminator as a valid separator. */
for (i = 0; i < length + 1; i++)
{
char currentChar = string[i];
char escape;
if (currentChar == '\\' && (escape = string[i+1]))
{
if (escape != '.' && escape != '\\')
{
Append('\\');
}
Append(escape);
i++;
continue;
}
else if (currentChar == '.' || currentChar == '\0')
{
if (!field || !currentObj)
{
Free(field);
return NULL;
}
if (currentChar == '.')
{
retVal = HashMapGet(currentObj, field);
if (!retVal)
{
retVal = JsonValueObject(HashMapCreate());
HashMapSet(currentObj, field, retVal);
}
currentObj = JsonValueAsObject(retVal);
Free(field);
field = NULL;
continue;
}
retVal = HashMapSet(currentObj, field, new);
Free(field);
field = NULL;
continue;
}
Append(currentChar);
}
#undef Append
if (field)
{
/* This is weird. */
Free(field);
}
return retVal;
}

2
src/Parser.c
View file

@ -487,7 +487,7 @@ ParserRecomposeCommonID(CommonID id)
if (id.server.hostname)
{
char *server = ParserRecomposeServerPart(id.server);
char *tmp = StrConcat(3, ret, ":", server);
char *tmp = StrConcat(4, "@", ret, ":", server);
Free(ret);
Free(server);

732
src/Room.c
View file

@ -23,95 +23,35 @@
* SOFTWARE.
*/
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Array.h>
#include <Cytoplasm/Json.h>
#include <Parser.h>
#include <User.h>
#include <Room.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Base64.h>
#include <Cytoplasm/Util.h>
#include <Cytoplasm/Str.h>
#include <Cytoplasm/Log.h>
#include <Cytoplasm/Db.h>
#include <Schema/RoomCreateRequest.h>
#include <Schema/PduV1.h>
#include <Schema/PduV3.h>
#include <CanonicalJson.h>
#include <Config.h>
#include <Parser.h>
#include <State.h>
#include <Event.h>
#include <stdlib.h>
#include <string.h>
#include "Room/internal.h"
static char *
GenerateRoomId(ServerPart s)
struct Room
{
CommonID cid;
char *string;
Db *db;
DbRef *ref;
cid.sigil = '!';
cid.local = StrRandom(32);
cid.server = s;
string = ParserRecomposeCommonID(cid);
Free(cid.local);
char *id;
int version;
};
return string;
}
Room *
RoomCreate(Db * db, User *user, RoomCreateRequest * req, ServerPart s)
RoomCreate(Db * db, RoomCreateRequest * req)
{
Room *room;
char *version_string, *full_creator;
int version_num = 1;
HashMap *json;
if (!db || !req || !user)
{
return NULL;
}
version_string = req->room_version;
if (version_string)
{
/* TODO: Eventually use something else than room version 1 by
* default, and maybe add a config parameter. */
version_num = atoi(version_string);
version_num = version_num == 0 ? 1 : version_num;
}
room = Malloc(sizeof(Room));
room->db = db;
room->creator.hostname = s.hostname ? StrDuplicate(s.hostname) : NULL;
room->creator.port = s.port ? StrDuplicate(s.port) : NULL;
room->id = GenerateRoomId(s);
room->version = version_num;
room->state_ref = DbCreate(db, 3, "rooms", room->id, "state");
room->leaves_ref = DbCreate(db, 3, "rooms", room->id, "leaves");
json = DbJson(room->leaves_ref);
JsonSet(json, JsonValueArray(ArrayCreate()), 1, "leaves");
full_creator = ParserRecomposeServerPart(room->creator);
JsonSet(json, JsonValueString(full_creator), 1, "creator");
JsonSet(json, JsonValueInteger(version_num), 1, "version");
Free(full_creator);
RoomPopulate(room, user, req, s);
return room;
(void) db;
(void) req;
return NULL;
}
Room *
RoomLock(Db * db, char *id)
{
DbRef *state_ref, *leaves_ref;
HashMap *json;
DbRef *ref;
Room *room;
if (!db || !id)
@ -119,10 +59,9 @@ RoomLock(Db * db, char *id)
return NULL;
}
state_ref = DbLock(db, 3, "rooms", id, "state");
leaves_ref = DbLock(db, 3, "rooms", id, "leaves");
ref = DbLock(db, 3, "rooms", id, "state");
if (!state_ref || !leaves_ref)
if (!ref)
{
return NULL;
}
@ -130,21 +69,13 @@ RoomLock(Db * db, char *id)
room = Malloc(sizeof(Room));
if (!room)
{
DbUnlock(db, state_ref);
DbUnlock(db, leaves_ref);
DbUnlock(db, ref);
return NULL;
}
room->db = db;
room->state_ref = state_ref;
room->leaves_ref = leaves_ref;
room->ref = ref;
room->id = StrDuplicate(id);
room->version = JsonValueAsInteger(HashMapGet(DbJson(leaves_ref), "version"));
json = DbJson(room->leaves_ref);
ParseServerPart(
JsonValueAsString(JsonGet(json, 1, "creator")),
&room->creator);
return room;
}
@ -153,8 +84,7 @@ int
RoomUnlock(Room * room)
{
Db *db;
DbRef *state_ref;
DbRef *leaves_ref;
DbRef *ref;
if (!room)
{
@ -162,647 +92,33 @@ RoomUnlock(Room * room)
}
db = room->db;
state_ref = room->state_ref;
leaves_ref = room->leaves_ref;
ref = room->ref;
Free(room->id);
Free(room);
ServerPartFree(room->creator);
return DbUnlock(db, state_ref) &&
DbUnlock(db, leaves_ref);
}
int64_t
ParsePL(JsonValue *v, int64_t def)
{
if (!v)
{
return def;
}
if (JsonValueType(v) == JSON_INTEGER)
{
return JsonValueAsInteger(v);
}
if (JsonValueType(v) == JSON_STRING)
{
char *string = JsonValueAsString(v), *end;
int64_t value= strtoll(string, &end, 10);
if (!((*string != '\0') && (*end == '\0')))
{
/* Invalid string: return the default. */
return def;
}
return value;
}
return def;
return DbUnlock(db, ref);
}
char *
EventContentHash(HashMap * pdu_json)
RoomIdGet(Room * room)
{
HashMap * copy = JsonDuplicate(pdu_json);
unsigned char *sha;
char *b64;
JsonValueFree(HashMapDelete(copy, "unsigned"));
JsonValueFree(HashMapDelete(copy, "signatures"));
JsonValueFree(HashMapDelete(copy, "hashes"));
sha = CanonicalJsonHash(copy);
b64 = Base64Encode((const char *) sha, 32);
Base64Unpad(b64, strlen(b64));
Free(sha);
JsonFree(copy);
return b64;
return room ? room->id : NULL;
}
/* TODO: Separate this when we eventually steamroll */
static HashMap *
RoomEventSendV3(Room * room, HashMap * event)
int
RoomVersionGet(Room * room)
{
/* TODO */
(void) room;
(void) event;
return NULL;
return room ? room->version : 0;
}
HashMap *
RoomEventSend(Room * room, HashMap * event, char **errp)
{
if (!room || !event)
{
return NULL;
}
if (room->version < 3)
{
/* Manage with PDUv1 */
return RoomEventSendV1(room, event, errp);
}
/* Manage with PDUv3 otherwise */
return RoomEventSendV3(room, event);
}
char *
CreateSafeID(char *unsafe_id)
{
size_t length = strlen(unsafe_id);
char *safe_id = Malloc(length + 1);
size_t i;
/* Creates a room ID safe to be put into the database
* for room version 3 and above.
* (with '/'s replaced by '-') */
memcpy(safe_id, unsafe_id, length + 1);
for (i = 0; i < length; i++)
{
if (safe_id[i] == '/')
{
safe_id[i] = '-';
}
}
return safe_id;
}
HashMap *
RoomEventFetch(Room *room, char *id)
{
char *safe_id, *redactor;
HashMap *ret, *unsign;
DbRef *event_ref;
uint64_t ts;
if (!room || !id)
{
return NULL;
}
/* Let's try to locally find that event in our junk. */
safe_id = CreateSafeID(id);
event_ref = DbLock(room->db, 4, "rooms", room->id, "events", safe_id);
if (!event_ref)
{
/* TODO: Fetch from another homeserver if possible. */
ret = NULL;
goto finish;
}
ret = JsonDuplicate(JsonValueAsObject(HashMapGet(DbJson(event_ref), "pdu")));
unsign = JsonValueAsObject(HashMapGet(ret, "unsigned"));
/* Overwrite a few unsigned properties on the fly. */
JsonValueFree(HashMapSet(
unsign,
"next_events",
JsonValueDuplicate(HashMapGet(DbJson(event_ref), "next_events"))
));
JsonValueFree(HashMapSet(
unsign,
"pdu_status",
JsonValueDuplicate(HashMapGet(DbJson(event_ref), "status"))
));
ts = JsonValueAsInteger(HashMapGet(ret, "origin_server_ts"));
JsonValueFree(HashMapSet(
unsign,
"age",
JsonValueInteger(UtilTsMillis() - ts)
));
redactor = JsonValueAsString(HashMapGet(DbJson(event_ref), "redacted_by"));
JsonValueFree(HashMapSet(
unsign,
"redacted_because",
JsonValueObject(RoomEventFetch(room, redactor))
));
DbUnlock(room->db, event_ref);
finish:
Free(safe_id);
return ret;
}
HashMap *
RoomEventCreate(char *sender, char *type, char *key, HashMap *c)
{
HashMap *event;
if (!sender || !type || !c)
{
return NULL;
}
event = HashMapCreate();
JsonSet(event, JsonValueObject(c), 1, "content");
JsonSet(event, JsonValueString(sender), 1, "sender");
JsonSet(event, JsonValueString(type), 1, "type");
if (key)
{
JsonSet(event, JsonValueString(key), 1, "state_key");
}
return event;
}
void
RoomAddAlias(Db *db, char *roomAlias, char *roomId, char *sender, char *serv)
{
DbRef *aliasRef;
HashMap *json, *alias, *idObject;
Array *servers, *ids;
if (!db || !roomAlias || !roomId || !sender || !serv)
{
return;
}
aliasRef = DbLock(db, 1, "aliases");
if (!aliasRef)
{
aliasRef = DbCreate(db, 1, "aliases");
if (!aliasRef)
{
return;
}
}
json = DbJson(aliasRef);
servers = ArrayCreate();
ArrayAdd(servers, JsonValueString(serv));
/* alias => ID */
alias = HashMapCreate();
JsonSet(alias, JsonValueString(roomId), 1, "id");
JsonSet(alias, JsonValueString(sender), 1, "createdBy");
JsonSet(alias, JsonValueArray(servers), 1, "servers");
JsonValueFree(
JsonSet(json, JsonValueObject(alias), 2, "aliases", roomAlias));
/* ID => alias(es) */
if (!(idObject =
JsonValueAsObject(JsonGet(json, 2, "id", roomId))))
{
ids = ArrayCreate();
idObject = HashMapCreate();
HashMapSet(idObject, "aliases", JsonValueArray(ids));
JsonSet(
json,
JsonValueObject(idObject),
2, "id", roomId);
}
ids = JsonValueAsArray(HashMapGet(idObject, "aliases"));
ArrayAdd(ids, JsonValueString(roomAlias));
DbUnlock(db, aliasRef);
}
char *
RoomResolveAlias(Db *db, char *roomAlias)
{
DbRef *aliasRef;
HashMap *json;
char *ret;
if (!db || !roomAlias)
{
return NULL;
}
aliasRef = DbLock(db, 1, "aliases");
if (!aliasRef)
{
return NULL;
}
json = DbJson(aliasRef);
ret = JsonValueAsString(JsonGet(json, 3, "aliases", roomAlias, "id"));
ret = StrDuplicate(ret);
DbUnlock(db, aliasRef);
return ret;
}
Array *
RoomReverseAlias(Db *db, char *roomId)
{
DbRef *aliasRef;
HashMap *json, *idObject;
Array *ret, *original;
size_t i;
if (!db || !roomId)
{
return NULL;
}
aliasRef = DbLock(db, 1, "aliases");
if (!aliasRef)
{
return NULL;
}
json = DbJson(aliasRef);
if (!(idObject =
JsonValueAsObject(JsonGet(json, 2, "id", roomId))))
{
DbUnlock(db, aliasRef);
return NULL;
}
original = JsonValueAsArray(HashMapGet(idObject, "aliases"));
ret = ArrayCreate();
for (i = 0; i < ArraySize(original); i++)
{
JsonValue *v = ArrayGet(original, i);
ArrayAdd(ret, StrDuplicate(JsonValueAsString(v)));
}
DbUnlock(db, aliasRef);
return ret;
}
void
RoomFreeReverse(Array *arr)
{
size_t i;
if (!arr)
{
return;
}
for (i = 0; i < ArraySize(arr); i++)
{
Free(ArrayGet(arr, i));
}
ArrayFree(arr);
}
void
RoomSendInvite(User *sender, bool direct, char *user, Room *room)
{
HashMap *content, *event;
CommonID *senderID;
char *senderStr;
Config conf;
if (!sender || !user || !room)
{
return;
}
ConfigLock(room->db, &conf);
senderID = UserIdParse(UserGetName(sender), conf.serverName);
senderID->sigil = '@';
senderStr = ParserRecomposeCommonID(*senderID);
UserIdFree(senderID);
content = HashMapCreate();
JsonSet(content, JsonValueBoolean(direct), 1, "is_direct");
JsonSet(content, JsonValueString("invite"), 1, "membership");
event = RoomEventCreate(senderStr, "m.room.member", user, content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
/* TODO: Send to "local" invite list if user is local.
* Otherwise, ping the entire world about it. */
ConfigUnlock(&conf);
Free(senderStr);
}
Db *
RoomGetDB(Room *room)
RoomStateGet(Room * room)
{
if (!room)
{
return NULL;
}
return room->db;
}
bool
RoomContainsUser(Room *room, char *user)
{
State *state;
bool ret;
if (!room || !user)
{
return false;
}
state = StateCurrent(room);
ret = RoomUserHasMembership(room, state, user, "join");
StateFree(state);
return ret;
}
bool
RoomCanJoin(Room *room, char *user)
{
State *state;
HashMap *joinRule = NULL;
char *joinRuleV;
bool ret;
if (!room || !user)
{
return false;
}
state = StateCurrent(room);
/* No rooms for banned people! */
if (RoomUserHasMembership(room, state, user, "ban"))
{
ret = false;
goto end;
}
/* Check join_rules */
joinRule = RoomEventFetch(
room,
StateGet(state, "m.room.join_rules", "")
);
joinRuleV = JsonValueAsString(JsonGet(joinRule, 2, "content", "join_rule"));
if (StrEquals(joinRuleV, "public"))
{
/* Anyone can join the room without any prior action. */
ret = true;
goto end;
}
if (StrEquals(joinRuleV, "invite"))
{
/* A user must first receive an invite from someone already in the
* room in order to join. */
ret = RoomUserHasMembership(room, state, user, "invite");
goto end;
}
if (StrEquals(joinRuleV, "knock"))
{
/* TODO: Knocking and restricted rooms. */
ret = false;
goto end;
}
if (StrEquals(joinRuleV, "restricted"))
{
/* TODO: Knocking and restricted rooms. */
ret = false;
goto end;
}
if (StrEquals(joinRuleV, "knock_restricted"))
{
/* TODO: Knocking and restricted rooms. */
ret = false;
goto end;
}
/* All other rooms are considered private. */
ret = false;
end:
StateFree(state);
JsonFree(joinRule);
return ret;
}
bool
RoomLeave(Room *room, User *user, char **errp)
{
CommonID *userId = NULL;
char *userString = NULL;
char *server = NULL;
HashMap *content = NULL;
HashMap *event = NULL;
HashMap *pdu = NULL;
bool ret = false;
if (!room || !user)
{
return false;
}
server = ConfigGetServerName(room->db);
if (!server)
{
return false;
}
userId = UserIdParse(UserGetName(user), server);
userId->sigil = '@';
userString = ParserRecomposeCommonID(*userId);
Free(server);
server = NULL;
content = HashMapCreate();
JsonSet(content, JsonValueString("leave"), 1, "membership");
event = RoomEventCreate(userString, "m.room.member", userString, content);
pdu = RoomEventSend(room, event, errp);
/* TODO: One ought to be extremely careful with managing users in those
* scenarios, as the DB flushes do not sync. */
ret = !!pdu;
if (ret)
{
UserRemoveJoin(user, room->id);
}
UserIdFree(userId);
JsonFree(event);
JsonFree(pdu);
if (userString)
{
Free(userString);
}
return ret;
}
char *
RoomRedact(Room *room, User *user, char *eventID, char *reason, char **errp)
{
CommonID *userId = NULL;
char *userString = NULL;
char *server = NULL;
HashMap *event = NULL;
HashMap *content = NULL;
HashMap *pdu = NULL;
char *ret = NULL;
if (!room || !user || !eventID)
{
return NULL;
}
server = ConfigGetServerName(room->db);
if (!server)
{
if (errp)
{
*errp = "Could not retrieve servername.";
}
return NULL;
}
userId = UserIdParse(UserGetName(user), server);
userId->sigil = '@';
userString = ParserRecomposeCommonID(*userId);
Free(server);
server = NULL;
if (!RoomContainsUser(room, userString))
{
ret = NULL;
if (errp)
{
*errp = "User is not already in-room.";
}
goto end;
}
content = HashMapCreate();
HashMapSet(content, "reason", JsonValueString(reason));
event = RoomEventCreate(userString,
"m.room.redaction", NULL,
content
);
HashMapSet(event, "redacts", JsonValueString(eventID));
pdu = RoomEventSend(room, event, errp);
ret = StrDuplicate(JsonValueAsString(HashMapGet(pdu, "event_id")));
if (errp && !*errp && !ret)
{
*errp = "Unknown error when redacting.";
}
end:
UserIdFree(userId);
JsonFree(event);
JsonFree(pdu);
if (userString)
{
Free(userString);
}
return ret;
}
bool
RoomJoin(Room *room, User *user, char **errp)
{
CommonID *userId = NULL;
char *userString = NULL;
char *server = NULL;
HashMap *content = NULL;
HashMap *event = NULL;
HashMap *pdu = NULL;
bool ret = false;
if (!room || !user)
{
return false;
}
server = ConfigGetServerName(room->db);
if (!server)
{
return false;
}
userId = UserIdParse(UserGetName(user), server);
userId->sigil = '@';
userString = ParserRecomposeCommonID(*userId);
Free(server);
server = NULL;
if (!RoomCanJoin(room, userString))
{
ret = false;
goto end;
}
content = HashMapCreate();
JsonSet(content, JsonValueString("join"), 1, "membership");
event = RoomEventCreate(userString, "m.room.member", userString, content);
pdu = RoomEventSend(room, event, errp);
/* TODO: One ought to be extremely careful with managing users in those
* scenarios, as the DB flushes do not sync. */
ret = !!pdu;
if (ret)
{
UserAddJoin(user, room->id);
}
end:
UserIdFree(userId);
JsonFree(event);
JsonFree(pdu);
if (userString)
{
Free(userString);
}
return ret;
}
HashMap *
RoomEventClientify(HashMap *pdu)
{
HashMap *event;
if (!pdu)
{
return NULL;
}
event = HashMapCreate();
#define CopyField(field, req) do { \
JsonValue *f = HashMapGet(pdu, field);\
if (!f && req) \
{ \
goto failure; \
} \
HashMapSet( \
event, \
field, JsonValueDuplicate(f) \
); \
} \
while(0)
CopyField("content", true);
CopyField("event_id", true);
CopyField("origin_server_ts", true);
CopyField("room_id", true);
CopyField("sender", true);
CopyField("type", true);
CopyField("state_key",false);
CopyField("redacts", false);
return event;
failure:
JsonFree(event);
return NULL;
#undef CopyField
}

73
src/Room/Info.c
View file

@ -1,73 +0,0 @@
#include "Room/internal.h"
char *
RoomIdGet(Room * room)
{
return room ? room->id : NULL;
}
int
RoomVersionGet(Room * room)
{
return room ? room->version : 0;
}
ServerPart
RoomGetCreator(Room *room)
{
ServerPart ret = { 0 };
if (!room)
{
return ret;
}
return room->creator;
}
Array *
RoomPrevEventsGet(Room *room)
{
HashMap *json;
if (!room)
{
return NULL;
}
json = DbJson(room->leaves_ref);
return JsonValueAsArray(JsonGet(json, 1, "leaves"));
}
/* TODO: This has it's fair share of problems, as a malicious
* homeserver could *easily* fake a PDU depth and put this
* function to the depth limit. */
uint64_t
RoomGetDepth(Room *room)
{
Array *leaves;
HashMap *pdu;
size_t i;
uint64_t max;
if (!room)
{
return 0;
}
leaves = RoomPrevEventsGet(room);
if (!leaves)
{
return 0;
}
max = 0;
for (i = 0; i < ArraySize(leaves); i++)
{
uint64_t depth;
pdu = JsonValueAsObject(ArrayGet(leaves, i));
depth = JsonValueAsInteger(HashMapGet(pdu, "depth"));
if (depth > max)
{
max = depth;
}
}
return max;
}

286
src/Room/Populate.c
View file

@ -1,286 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Array.h>
#include <Cytoplasm/Json.h>
#include <Parser.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Base64.h>
#include <Cytoplasm/Util.h>
#include <Cytoplasm/Str.h>
#include <Cytoplasm/Log.h>
#include <Cytoplasm/Db.h>
#include <Schema/RoomCreateRequest.h>
#include <Schema/PduV1.h>
#include <Schema/PduV3.h>
#include <CanonicalJson.h>
#include <Config.h>
#include <Parser.h>
#include <State.h>
#include <Event.h>
#include <stdlib.h>
#include <string.h>
#include "Room/internal.h"
void
RoomPopulate(Room *room, User *user, RoomCreateRequest *req, ServerPart s)
{
CommonID sender;
char *sender_str, *key, *version;
HashMap *content, *event, *override, *pl_content;
Array *initial_states;
JsonValue *val;
int64_t pl = 100;
size_t i;
char *join_rules_preset = NULL;
char *history_visibility_preset = NULL;
char *guest_access_preset = NULL;
bool trusted_room = false;
sender.sigil = '@';
sender.local = UserGetName(user);
sender.server = s;
sender_str = ParserRecomposeCommonID(sender);
/* m.room.create */
content = HashMapCreate();
if (room->version <= 10)
{
JsonSet(content, JsonValueString(sender_str), 1, "creator");
}
version = req->room_version ?
StrDuplicate(req->room_version) : StrInt(room->version);
JsonSet(content, JsonValueString(version), 1, "room_version");
Free(version);
while (HashMapIterate(req->creation_content, &key, (void **) &val))
{
JsonValue *content_v = HashMapGet(content, key);
if (content_v &&
!StrEquals(key, "creator") &&
!StrEquals(key, "room_version"))
{
continue;
}
JsonValueFree(HashMapSet(content, key, JsonValueDuplicate(val)));
}
event = RoomEventCreate(sender_str, "m.room.create", "", content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
UserAddJoin(user, room->id);
/* m.room.member */
content = HashMapCreate();
JsonSet(content, JsonValueString("join"), 1, "membership");
event = RoomEventCreate(sender_str, "m.room.member", sender_str, content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
/* m.room.power_levels */
content = HashMapCreate();
JsonSet(
content,
JsonValueInteger(pl),
2, "users", sender_str);
override = req->power_level_content_override;
while (override && HashMapIterate(override, &key, (void **) &val))
{
JsonValue *main = HashMapGet(content, key);
if (main)
{
HashMapDelete(content, key);
JsonValueFree(main);
}
HashMapSet(content, key, JsonValueDuplicate(val));
}
event = RoomEventCreate(sender_str, "m.room.power_levels", "", content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
/* Presets */
switch (req->preset)
{
case ROOM_CREATE_PUBLIC:
join_rules_preset = "public";
history_visibility_preset = "shared";
guest_access_preset = "forbidden";
break;
case ROOM_CREATE_TRUSTED:
trusted_room = true;
/* Fallthrough */
case ROOM_CREATE_PRIVATE:
join_rules_preset = "invite";
history_visibility_preset = "shared";
guest_access_preset = "can_join";
break;
default:
switch (req->visibility)
{
case ROOM_PUBLIC:
join_rules_preset = "public";
history_visibility_preset = "shared";
guest_access_preset = "forbidden";
break;
case ROOM_PRIVATE:
join_rules_preset = "invite";
history_visibility_preset = "shared";
guest_access_preset = "can_join";
break;
}
break;
}
/* Write out presets */
#define SetIfExistent(p,a) do { \
if (p##_preset) \
{ \
content = HashMapCreate(); \
JsonSet( \
content, \
JsonValueString(p##_preset) \
, 1, a); \
event = RoomEventCreate( \
sender_str, \
"m.room." #p, "", content); \
JsonFree(RoomEventSend(room, event, NULL)); \
JsonFree(event); \
} \
} \
while (0)
SetIfExistent(join_rules, "join_rule");
SetIfExistent(history_visibility, "history_visibility");
SetIfExistent(guest_access, "guest_access");
#undef SetIfExistent
/* User-provided initial states */
initial_states = req->initial_state;
for (i = 0; i < ArraySize(initial_states); i++)
{
RoomStateEvent *rse = ArrayGet(initial_states, i);
HashMap *rseObject = RoomStateEventToJson(rse);
if (!HashMapGet(rseObject, "state_key"))
{
HashMapSet(rseObject, "state_key", JsonValueString(""));
}
HashMapSet(rseObject, "sender", JsonValueString(sender_str));
JsonFree(RoomEventSend(room, rseObject, NULL));
JsonFree(rseObject);
}
/* Name and topic. */
if (req->name)
{
content = HashMapCreate();
JsonSet(content, JsonValueString(req->name), 1, "name");
event = RoomEventCreate(sender_str, "m.room.name", "", content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
}
if (req->topic)
{
content = HashMapCreate();
JsonSet(content, JsonValueString(req->topic), 1, "topic");
event = RoomEventCreate(sender_str, "m.room.topic", "", content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
}
/* Custom alias */
if (req->room_alias_name && !RoomResolveAlias(room->db, room->id))
{
CommonID full;
char *fullStr, *serverStr;
full.sigil = '#';
full.local = req->room_alias_name;
full.server = s;
fullStr = ParserRecomposeCommonID(full);
serverStr = ParserRecomposeServerPart(room->creator);
RoomAddAlias(room->db, fullStr, room->id, sender_str, serverStr);
content = HashMapCreate();
JsonSet(content, JsonValueString(fullStr), 1, "alias");
event = RoomEventCreate(
sender_str,
"m.room.canonical_alias", "", content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
Free(fullStr);
Free(serverStr);
}
/* Invites */
pl_content = HashMapCreate();
JsonSet(pl_content, JsonValueInteger(pl), 2, "users", sender_str);
for (i = 0; i < ArraySize(req->invite); i++)
{
char *user_id = ArrayGet(req->invite, i);
if (!user_id || !ValidCommonID(user_id, '@'))
{
/* TODO: Raise error. */
break;
}
RoomSendInvite(user, req->is_direct, user_id, room);
if (trusted_room)
{
JsonValue *own = JsonValueInteger(pl);
JsonSet(pl_content, own, 2, "users", user_id);
}
}
event = RoomEventCreate(sender_str, "m.room.power_levels", "", pl_content);
JsonFree(RoomEventSend(room, event, NULL));
JsonFree(event);
JsonValueFree(JsonSet(
DbJson(room->leaves_ref),
JsonValueBoolean(req->is_direct), 1, "is_direct"));
/* TODO: The rest of the events mandated by the specification on
* POST /createRoom, and error management. */
Free(sender_str);
/* TODO: Error management (and invite_3pid, later) */
}

282
src/Room/State.c
View file

@ -1,282 +0,0 @@
#include "Room/internal.h"
#include <Cytoplasm/Memory.h>
#include <Config.h>
#include <State.h>
State *
RoomStateGet(Room * room)
{
HashMap *database_state;
if (!room)
{
return NULL;
}
/* TODO: Consider caching the deserialised result, as doing that on a
* large state would probably eat up a lot of time! */
/* TODO: Update the cached state */
database_state = DbJson(room->state_ref);
return StateDeserialise(database_state);
}
State *
RoomStateGetID(Room * room, char *event_id)
{
HashMap *event;
State *state;
if (!room || !event_id)
{
return NULL;
}
event = RoomEventFetch(room, event_id);
if (!event)
{
return NULL;
}
state = StateResolve(room, event);
JsonFree(event);
return state;
}
static char *
GetCurrentMembership(Room *room, State *s, char *mxid)
{
State *state;
HashMap *event;
char *event_id;
char *ret;
if (!room || !mxid)
{
return NULL;
}
if (s)
{
state = s;
}
else
{
state = StateCurrent(room);
}
event_id = StateGet(state, "m.room.member", mxid);
event = RoomEventFetch(room, event_id);
if (!s)
{
StateFree(state);
}
ret = StrDuplicate(
JsonValueAsString(JsonGet(event, 2, "content", "membership"))
);
JsonFree(event);
return ret;
}
bool
RoomIsEventVisible(Room *room, User *user, char *eventId)
{
State *state;
HashMap *entryV;
char *visibility;
char *membership, *currentMembership;
CommonID cid;
char *server;
char *mxid;
bool ret = false;
if (!room || !user || !eventId)
{
return false;
}
server = ConfigGetServerName(room->db);
cid.sigil = '@';
cid.local = UserGetName(user);
ParseServerPart(server, &cid.server);
mxid = ParserRecomposeCommonID(cid);
Free(server);
state = RoomStateGetID(room, eventId);
entryV = RoomEventFetch(room,
StateGet(state, "m.room.history_visibility", "")
);
if (!(visibility = JsonValueAsString(
JsonGet(entryV, 2, "content", "history_visibility"))))
{
visibility = "shared";
}
visibility = StrDuplicate(visibility);
JsonFree(entryV);
membership = GetCurrentMembership(room, state, mxid);
currentMembership = GetCurrentMembership(room, NULL, mxid);
StateFree(state);
/* TODO: (for shared) "and the user joined the room at _any_
* point after the event was sent, allow."
* Aargh. *Why?* */
if (StrEquals(visibility, "world_readable"))
{
ret = true;
}
else if (StrEquals(membership, "join"))
{
ret = true;
}
else if (StrEquals(visibility, "shared") &&
StrEquals(currentMembership, "join")) /* Check the current
* membership, as a hack */
{
ret = true;
}
else if (StrEquals(visibility, "invited") &&
StrEquals(membership, "invite"))
{
ret = true;
}
Free(mxid);
Free(membership);
Free(visibility);
Free(currentMembership);
ServerPartFree(cid.server);
return ret;
}
#define PrepareState(room, S, type, key, n) \
do \
{ \
id_##n = StateGet(S, type, key); \
if (!id_##n) \
{ \
goto finish; \
} \
n = RoomEventFetch(room, id_##n); \
if (!n) \
{ \
goto finish; \
} \
} \
while (0)
#define FinishState(name) \
if (name) \
{ \
JsonFree(name); \
} \
return ret
bool
RoomIsJoinRule(Room * room, State *state, char *jr)
{
HashMap *joinrule = NULL;
char *id_joinrule = NULL;
bool ret = false;
if (!room || !state || !jr)
{
return false;
}
PrepareState(room, state, "m.room.join_rules", "", joinrule);
ret = StrEquals(
JsonValueAsString(JsonGet(joinrule, 2, "content", "join_rule")),
jr);
finish:
FinishState(joinrule);
}
/* Verifies if user has a specific membership before [e_id] in the room. */
bool
RoomUserHasMembership(Room * room, State *state, char *user, char *mbr)
{
HashMap *membership = NULL;
char *id_membership = NULL;
char *membership_value;
bool ret = false;
if (!room || !state || !user || !mbr)
{
return false;
}
PrepareState(room, state, "m.room.member", user, membership);
membership_value =
JsonValueAsString(JsonGet(membership, 2, "content", "membership"));
ret = StrEquals(membership_value, mbr);
finish:
FinishState(membership);
}
/* Computes the smallest PL needed to do something somewhere */
int64_t
RoomMinPL(Room * room, State *state, char *type, char *act)
{
HashMap *pl = NULL;
JsonValue *val;
char *id_pl;
int64_t ret = 0, def = 0;
if (!room || !state || !act)
{
return 0;
}
PrepareState(room, state, "m.room.power_levels", "", pl);
/* Every other act has a minimum PL of 0 */
def = 0;
if (StrEquals(act, "ban") ||
StrEquals(act, "kick") ||
StrEquals(act, "redact") ||
StrEquals(act, "state_default") ||
(StrEquals(type, "notifications") && StrEquals(act, "room")))
{
def = 50;
}
if (!type)
{
val = JsonGet(pl, 2, "content", act);
}
else
{
val = JsonGet(pl, 3, "content", type, act);
}
ret = ParsePL(val, def);
finish:
FinishState(pl);
}
/* Finds the power level of an user at a state. */
/* TODO: The creator should have PL100 by default. */
int64_t
RoomUserPL(Room * room, State *state, char *user)
{
HashMap *pl = NULL;
char *id_pl;
int64_t ret = 0, def = 0;
if (!room || !state || !user)
{
return 0;
}
PrepareState(room, state, "m.room.power_levels", "", pl);
def = RoomMinPL(room, state, NULL, "users_default");
ret = ParsePL(JsonGet(pl, 3, "content", "users", user), def);
finish:
FinishState(pl);
}

65
src/Room/V1/Auth/Alias.c
View file

@ -1,65 +0,0 @@
#include "Room/internal.h"
#include <Schema/PduV1.h>
#include <Parser.h>
static bool
VerifyServers(char *id1, char *id2)
{
CommonID cid1;
CommonID cid2;
char *str1;
char *str2;
bool ret = false;
if (!ParseCommonID(id1, &cid1))
{
return false;
}
if (!ParseCommonID(id2, &cid2))
{
return false;
}
str1 = ParserRecomposeServerPart(cid1.server);
str2 = ParserRecomposeServerPart(cid2.server);
if (StrEquals(str1, str2))
{
ret = true;
goto end;
}
end:
Free(str1);
Free(str2);
CommonIDFree(cid1);
CommonIDFree(cid2);
return ret;
}
bool
AuthoriseAliasV1(PduV1 pdu, char **errp)
{
/* Step 4.1: If event has no state_key, reject. */
if (!pdu.state_key || StrEquals(pdu.state_key, ""))
{
if (errp)
{
*errp = "Step 4.1 fail: no state key in the alias";
}
return false;
}
/* Step 4.2: If sender's domain doesn't matches state_key, reject. */
if (!VerifyServers(pdu.state_key, pdu.sender))
{
if (errp)
{
*errp = "Step 4.2 fail: alias domain doesnt match statekey";
}
return false;
}
/* Step 4.3: Otherwise, allow. */
return true;
}

174
src/Room/V1/Auth/Auth.c
View file

@ -1,174 +0,0 @@
#include "Room/internal.h"
#include "Room/V1/Auth/internal.h"
#include <Schema/PduV1.h>
#include <Parser.h>
static bool
VerifyServers(char *id1, char *id2)
{
CommonID cid1;
CommonID cid2;
char *str1;
char *str2;
bool ret = false;
if (!ParseCommonID(id1, &cid1))
{
return false;
}
if (!ParseCommonID(id2, &cid2))
{
return false;
}
str1 = ParserRecomposeServerPart(cid1.server);
str2 = ParserRecomposeServerPart(cid2.server);
if (StrEquals(str1, str2))
{
ret = true;
goto end;
}
end:
Free(str1);
Free(str2);
CommonIDFree(cid1);
CommonIDFree(cid2);
return ret;
}
bool
RoomAuthoriseEventV1(Room * room, PduV1 pdu, State *state, char **errp)
{
HashMap *create_event;
char *create_event_id;
JsonValue *federate;
int64_t pdu_pl = RoomUserPL(room, state, pdu.sender);
int64_t event_pl = RoomMinPL(room,state, "events", pdu.type);
/* Step 1: If m.room.create */
if (StrEquals(pdu.type, "m.room.create"))
{
return AuthoriseCreateV1(pdu, errp);
}
/* Step 2: Considering the event's auth_events. */
if (!ConsiderAuthEventsV1(room, pdu, errp))
{
return false;
}
/* Step 3: If the content of the m.room.create event in the room state
* has the property m.federate set to false, and the sender domain of
* the event does not match the sender domain of the create event,
* reject.
*/
create_event_id = StateGet(state, "m.room.create", "");
if (!state || !create_event_id)
{
/* At this point, [create_event_id] has to exist */
if (errp)
{
*errp = "No creation event in the state. Needless to say, "
"your room is done for.";
}
return false;
}
create_event = RoomEventFetch(room, create_event_id);
federate = JsonGet(create_event, 2, "content", "m.federate");
if (JsonValueType(federate) == JSON_BOOLEAN)
{
if (!JsonValueAsBoolean(federate))
{
char *c_sender =
JsonValueAsString(JsonGet(create_event, 1, "sender"));
char *p_sender = pdu.sender;
if (!VerifyServers(c_sender, p_sender))
{
if (errp)
{
*errp = "Trying to access a room with m.federate off.";
}
return false;
}
}
}
JsonFree(create_event);
/* Step 4: If type is m.room.aliases */
if (StrEquals(pdu.type, "m.room.aliases"))
{
return AuthoriseAliasV1(pdu, errp);
}
/* Step 5: If type is m.room.member */
if (StrEquals(pdu.type, "m.room.member"))
{
return AuthoriseMemberV1(room, pdu, state, errp);
}
/* Step 6: If the sender's current membership state is not join, reject. */
if (!RoomUserHasMembership(room, state, pdu.sender, "join"))
{
return false;
}
/* Step 7: If type is m.room.third_party_invite */
if (StrEquals(pdu.type, "m.room.third_party_invite"))
{
/* Allow if and only if sender's current power level is greater than
* or equal to the invite level */
int64_t min_pl = RoomMinPL(room, state, NULL, "invite");
return pdu_pl >= min_pl;
}
/* Step 8: If the event type's required power level is greater than the
* sender's power level, reject. */
if (event_pl > pdu_pl)
{
return false;
}
/* Step (9): If the event has a state_key that starts with an @ and does
* not match the sender, reject. */
if (pdu.state_key && *pdu.state_key == '@')
{
if (!StrEquals(pdu.state_key, pdu.sender))
{
return false;
}
}
/* Step 10: If type is m.room.power_levels */
if (StrEquals(pdu.type, "m.room.power_levels"))
{
return AuthorisePowerLevelsV1(room, pdu, state);
}
/* Step 11: If type is m.room.redaction */
if (StrEquals(pdu.type, "m.room.redaction"))
{
int64_t min_pl = RoomMinPL(room, state, NULL, "redact");
/* Step 11.1: If the sender's power level is greater than or equal
* to the redact level, allow. */
if (pdu_pl >= min_pl)
{
return true;
}
/* Step 11.2: If the domain of the event_id of the event being
* redacted is the same as the domain of the event_id of the
* m.room.redaction, allow. */
if (pdu.redacts && VerifyServers(pdu.redacts, pdu.event_id))
{
return true;
}
/* Step 11.3: Otherwise, reject. */
return false;
}
/* Step 12: Otherwise, allow. */
return true;
}

183
src/Room/V1/Auth/AuthEvents.c
View file

@ -1,183 +0,0 @@
#include "Room/internal.h"
#include "Room/V1/Auth/internal.h"
#include <Schema/PduV1.h>
#include <Cytoplasm/Log.h>
#include <Parser.h>
static bool
VerifyPDUV1(PduV1 *auth_pdu)
{
/* TODO: The PDU could come from an unknown source, which may lack
* the tools to verify softfailing(or we may not trust them)*/
/* TODO:
* https://spec.matrix.org/v1.7/server-server-api/
* #checks-performed-on-receipt-of-a-pdu */
if (RoomIsRejectedV1(*auth_pdu))
{
Log(LOG_ERR, "Auth PDU has been rejected.");
return false;
}
if (RoomIsSoftfailedV1(*auth_pdu))
{
Log(LOG_ERR, "Auth PDU has been softfailed.");
}
return true; /* This only shows whenever an event was rejected, not
* soft-failed */
}
static bool
ValidAuthEventV1(PduV1 *auth_pdu, PduV1 *pdu)
{
if (IsState(auth_pdu, "m.room.create", ""))
{
return true;
}
if (IsState(auth_pdu, "m.room.power_levels", ""))
{
/* TODO: Check if it's the latest in terms of [pdu] */
return true;
}
if (IsState(auth_pdu, "m.room.member", pdu->sender))
{
/* TODO: Check if it's the latest in terms of [pdu] */
return true;
}
if (StrEquals(pdu->type, "m.room.member"))
{
char *membership =
JsonValueAsString(JsonGet(pdu->content, 1, "membership"));
JsonValue *third_pid =
JsonGet(pdu->content, 1, "third_party_invite");
/* The PDU's state_key is the target. So we check if if the
* auth PDU would count as the target's membership. Was very fun to
* find that out when I wanted to kick my 'yukari' alt. */
if (IsState(auth_pdu, "m.room.member", pdu->state_key))
{
/* TODO: Check if it's the latest in terms of [pdu] */
return true;
}
if ((StrEquals(membership, "join") ||
StrEquals(membership, "invite")) &&
IsState(auth_pdu, "m.room.join_rules",""))
{
/* TODO: Check if it's the latest in terms of [pdu] */
return true;
}
if (StrEquals(membership, "invite") && third_pid)
{
HashMap *tpid = JsonValueAsObject(third_pid);
JsonValue *token =
JsonGet(tpid, 2, "signed", "token");
char *token_str = JsonValueAsString(token);
if (IsState(auth_pdu, "m.room.third_party_invite", token_str))
{
/* TODO: Check if it is the latest. */
return true;
}
}
/* V1 simply doesn't have the concept of restricted rooms,
* so we can safely skip this one for this function. */
}
return false;
}
bool
ConsiderAuthEventsV1(Room * room, PduV1 pdu, char **errp)
{
char *ignored;
size_t i;
bool room_create = false;
HashMap *state_keytype;
state_keytype = HashMapCreate();
for (i = 0; i < ArraySize(pdu.auth_events); i++)
{
char *event_id = JsonValueAsString(ArrayGet(pdu.auth_events, i));
HashMap *event = RoomEventFetch(room, event_id);
PduV1 auth_pdu = { 0 };
char *key_type_id;
if (!PduV1FromJson(event, &auth_pdu, &ignored))
{
JsonFree(event);
HashMapFree(state_keytype);
if (errp)
{
*errp = "Couldn't parse an auth event";
}
return false; /* Yeah... we aren't doing that. */
}
/* TODO: Find a better way to do this. Using HashMaps as sets
* *works*, but it's not the best of ideas here. Also, we're using
* strings to compare things, which yeah. */
key_type_id = StrConcat(3, auth_pdu.type, ",", auth_pdu.state_key);
if (HashMapGet(state_keytype, key_type_id))
{
/* Duplicate found! We actually ignore it's actual value. */
if (errp)
{
*errp = "Duplicate auth event was found";
}
JsonFree(event);
PduV1Free(&auth_pdu);
HashMapFree(state_keytype);
Free(key_type_id);
return false;
}
/* Whenever event is valid or not really doesn't matter, as we're
* not using it's value anywhere. */
HashMapSet(state_keytype, key_type_id, event);
Free(key_type_id);
/* Step 2.2: If there are entries whose type and state_key don't
* match those specified by the auth events selection algorithm
* described in the server specification, reject. */
if (!ValidAuthEventV1(&auth_pdu, &pdu))
{
if (errp)
{
*errp = "Invalid authevent given.";
}
JsonFree(event);
PduV1Free(&auth_pdu);
HashMapFree(state_keytype);
return false;
}
/* Step 2.3: If there are entries which were themselves rejected
* under the checks performed on receipt of a PDU, reject.
* TODO */
if (!VerifyPDUV1(&auth_pdu))
{
if (errp)
{
*errp = "Event depends on rejected PDUs";
}
PduV1Free(&auth_pdu);
JsonFree(event);
HashMapFree(state_keytype);
return false;
}
/* Step 2.4: If there is no m.room.create event among the entries,
* reject. */
if (!room_create && IsState(&auth_pdu, "m.room.create", ""))
{
room_create = true; /* Here, we check for the opposite. */
}
JsonFree(event);
PduV1Free(&auth_pdu);
}
HashMapFree(state_keytype);
if (!room_create && errp)
{
*errp = "Room creation event was not in the PDU's auth events";
}
return room_create; /* Step 2.4 is actually done here. */
}

68
src/Room/V1/Auth/Create.c
View file

@ -1,68 +0,0 @@
#include "Room/internal.h"
#include "Room/V1/Auth/internal.h"
#include <Schema/PduV1.h>
#include <Parser.h>
bool
AuthoriseCreateV1(PduV1 pdu, char **errp)
{
bool ret = true;
CommonID sender = { 0 }, room_id = { 0 };
char *sender_serv = NULL, *id_serv = NULL;
if (ArraySize(pdu.auth_events) > 0)
{
if (errp)
{
*errp = "Room creation event has auth events";
}
ret = false;
goto finish;
}
if (!ParseCommonID(pdu.room_id, &room_id) ||
!ParseCommonID(pdu.sender, &sender))
{
if (errp)
{
*errp = "Couldn't parse the sender/room ID";
}
ret = false;
goto finish;
}
sender_serv = ParserRecomposeServerPart(sender.server);
id_serv = ParserRecomposeServerPart(room_id.server);
if (!StrEquals(sender_serv, id_serv))
{
if (errp)
{
*errp = "Room is not properly namespaced";
}
ret = false;
goto finish;
}
/* TODO: Check room_version as in step 1.3 */
if (!HashMapGet(pdu.content, "creator"))
{
if (errp)
{
*errp = "Room creation event has auth events";
}
ret = false;
goto finish;
}
finish:
if (sender_serv)
{
Free(sender_serv);
}
if (id_serv)
{
Free(id_serv);
}
CommonIDFree(sender);
CommonIDFree(room_id);
return ret;
}

371
src/Room/V1/Auth/Member.c
View file

@ -1,371 +0,0 @@
#include "Room/internal.h"
#include <Schema/PduV1.h>
#include <Parser.h>
static bool
AuthorizeInviteMembershipV1(Room * room, PduV1 pdu, State *state, char **errp)
{
int64_t invite_level;
int64_t pdu_level;
JsonValue *third_pi;
/* Step 5.3.1: If content has a third_party_invite property */
if ((third_pi = JsonGet(pdu.content, 1, "third_party_invite")))
{
JsonValue *signed_val, *mxid, *token;
HashMap *third_pi_obj = JsonValueAsObject(third_pi), *signed_obj;
HashMap *third_pi_event;
char *third_pi_id, *thirdpi_event_sender;
/* Step 5.3.1.1: If target user is banned, reject. */
if (RoomUserHasMembership(room, state, pdu.state_key, "ban"))
{
if (errp)
{
*errp = "Step 5.3.1.1 fail: target is banned";
}
return false;
}
/* Step 5.3.1.2: If content.third_party_invite does not have a signed
* property, reject. */
if (!(signed_val = JsonGet(third_pi_obj, 1, "signed")))
{
if (errp)
{
*errp = "Step 5.3.1.2 fail: unsigned 3PII";
}
return false;
}
signed_obj = JsonValueAsObject(signed_val);
/* Step 5.3.1.3: If signed does not have mxid and token properties,
* reject. */
if (!(mxid = JsonGet(signed_obj, 1, "mxid")))
{
if (errp)
{
*errp = "Step 5.3.1.3 fail: no MXID in 3PII";
}
return false;
}
if (!(token = JsonGet(signed_obj, 1, "token")))
{
if (errp)
{
*errp = "Step 5.3.1.3 fail: no token in 3PII";
}
return false;
}
/* Step 5.3.1.4: If mxid does not match state_key, reject. */
if (!StrEquals(JsonValueAsString(mxid), pdu.state_key))
{
if (errp)
{
*errp = "Step 5.3.1.4 fail: 3PII's MXID != state_key";
}
return false;
}
/* Step 5.3.1.5: If there is no m.room.third_party_invite event
* in the current room state with state_key matching token, reject. */
if (!(third_pi_id = StateGet(
state,
"m.room.third_party_invite", JsonValueAsString(token))))
{
if (errp)
{
*errp = "Step 5.3.1.5 fail: no proper 3PII event";
}
return false;
}
third_pi_event = RoomEventFetch(room, third_pi_id);
/* Step 5.3.1.6: If sender does not match sender of the
* m.room.third_party_invite, reject. */
thirdpi_event_sender = JsonValueAsString(JsonGet(third_pi_event, 1, "sender"));
if (!StrEquals(thirdpi_event_sender, pdu.sender))
{
if (errp)
{
*errp = "Step 5.3.1.6 fail: sender does not match 3PII";
}
JsonFree(third_pi_event);
return false;
}
JsonFree(third_pi_event);
/* TODO:
* Step 5.3.1.7: If any signature in signed matches any public key in
* the m.room.third_party_invite event, allow.
*
* The public keys are in content of m.room.third_party_invite as:
* - A single public key in the public_key property.
* - A list of public keys in the public_keys property. */
/* Step 5.3.1.8: Otherwise, reject. */
if (errp)
{
*errp = "Step 5.3.1.8 fail: signature check do not match";
}
return false;
}
/* Step 5.3.2: If the sender's current membership state is not join,
* reject. */
if (!RoomUserHasMembership(room, state, pdu.sender, "join"))
{
if (errp)
{
*errp = "Step 5.3.2 fail: sender is not 'join'ed";
}
return false;
}
/* Step 5.3.3: If target user's current membership state is join or ban, reject. */
if (RoomUserHasMembership(room, state, pdu.state_key, "join") ||
RoomUserHasMembership(room, state, pdu.state_key, "ban"))
{
if (errp)
{
*errp = "Step 5.3.3 fail: target is 'join'|'ban'd";
}
return false;
}
/* Step 5.3.4: If the sender's power level is greater than or equal to the
* invite level, allow. */
invite_level = RoomMinPL(room, state, NULL, "invite");
pdu_level = RoomUserPL(room, state, pdu.sender);
if (pdu_level >= invite_level)
{
return true;
}
/* Step 5.3.5: Otherwise, reject. */
if (errp)
{
*errp = "Step 5.3.5 fail: sender has no permissions to do so";
}
return false;
}
static bool
AuthorizeLeaveMembershipV1(Room * room, PduV1 pdu, State *state, char **errp)
{
int64_t ban_level = RoomMinPL(room, state, NULL, "ban");
int64_t kick_level = RoomMinPL(room, state, NULL, "kick");
int64_t sender_level = RoomUserPL(room, state, pdu.sender);
int64_t target_level = RoomUserPL(room, state, pdu.state_key);
/* Step 5.4.1: If the sender matches state_key, allow if and only if
* that user's current membership state is invite or join. */
if (StrEquals(pdu.sender, pdu.state_key))
{
bool flag =
RoomUserHasMembership(room, state, pdu.sender, "invite") ||
RoomUserHasMembership(room, state, pdu.sender, "join");
if (!flag && errp)
{
*errp = "Step 5.4.1 fail: user tries to leave but is "
"~'invite' AND ~'join'.";
}
return flag;
}
/* Step 5.4.2: If the sender's current membership state is not join,
* reject. */
if (!RoomUserHasMembership(room, state, pdu.sender, "join"))
{
if (errp)
{
*errp = "Step 5.4.2 fail: sender tries to kick but is "
"~'invite'.";
}
return false;
}
/* Step 5.4.3: If the target user's current membership state is ban,
* and the sender's power level is less than the ban level, reject. */
if (RoomUserHasMembership(room, state, pdu.state_key, "ban") &&
sender_level < ban_level)
{
if (errp)
{
*errp = "Step 5.4.3 fail: sender tries to unban but has no "
"permissions to do so.";
}
return false;
}
/* Step 5.4.4: If the sender's power level is greater than or equal to
* the kick level, and the target user's power level is less than the
* sender's power level, allow. */
if ((sender_level >= kick_level) && target_level < sender_level)
{
return true;
}
/* Step 5.4.5: Otherwise, reject. */
if (errp)
{
*errp = "Step 5.4.5 fail: sender tried to kick but has no "
"permissions to do so.";
}
return false;
}
static bool
AuthorizeBanMembershipV1(Room * room, PduV1 pdu, State *state, char **errp)
{
int64_t ban_pl, pdu_pl, target_pl;
/* Step 5.5.1: If the sender's current membership state is not join, reject. */
if (!RoomUserHasMembership(room, state, pdu.sender, "join"))
{
if (errp)
{
*errp = "Step 5.5.1 fail: sender tries to ban but is not "
"'join'ed";
}
return false;
}
/* Step 5.5.2: If the sender's power level is greater than or equal
* to the ban level, and the target user's power level is less than
* the sender's power level, allow. */
ban_pl = RoomMinPL(room, state, NULL, "ban");
pdu_pl = RoomUserPL(room, state, pdu.sender);
target_pl = RoomUserPL(room, state, pdu.state_key);
if ((pdu_pl >= ban_pl) && (target_pl < pdu_pl))
{
return true;
}
/* Step 5.5.3: Otherwise, reject. */
if (errp)
{
*errp = "Step 5.5.3 fail: sender tries to ban has no permissions to "
"do so";
}
return false;
}
static bool
AuthorizeJoinMembershipV1(Room * room, PduV1 pdu, State *state, char **errp)
{
/* Step 5.2.1: If the only previous event is an m.room.create and the
* state_key is the creator, allow. */
Array *prev = pdu.prev_events;
if (ArraySize(prev) == 1)
{
/* Interperet prev properly, as a list of JsonObjects. */
char *prev_id = JsonValueAsString(ArrayGet(prev, 0));
HashMap *prev_event = RoomEventFetch(room, prev_id);
bool flag = false;
if (prev_event)
{
char *type = JsonValueAsString(HashMapGet(prev_event, "type"));
char *sender = JsonValueAsString(HashMapGet(prev_event, "sender"));
if (StrEquals(type, "m.room.create") &&
StrEquals(sender, pdu.state_key))
{
flag = true;
}
}
JsonFree(prev_event);
if (flag)
{
return true;
}
}
/* Step 5.2.2: If the sender does not match state_key, reject. */
if (!StrEquals(pdu.sender, pdu.state_key))
{
if (errp)
{
*errp = "Step 5.2.2 fail: sender does not match statekey "
"on 'join'";
}
return false;
}
/* Step 5.2.3: If the sender is banned, reject. */
if (RoomUserHasMembership(room, state, pdu.sender, "ban"))
{
if (errp)
{
*errp = "Step 5.2.2 fail: sender is banned on 'join'";
}
return false;
}
/* Step 5.2.4: If the join_rule is invite then allow if membership
* state is invite or join. */
if (RoomIsJoinRule(room, state, "invite") &&
(RoomUserHasMembership(room, state, pdu.sender, "invite") ||
RoomUserHasMembership(room, state, pdu.sender, "join")))
{
return true;
}
/* Step 5.2.5: If the join_rule is public, allow. */
if (RoomIsJoinRule(room, state, "public"))
{
return true;
}
/* Step 5.2.6: Otherwise, reject. */
if (errp)
{
*errp = "Step 5.2.6 fail: join_rule does not allow 'join'";
}
return false;
}
bool
AuthoriseMemberV1(Room * room, PduV1 pdu, State *state, char **errp)
{
JsonValue *membership;
char *membership_str;
/* Step 5.1: If there is no state_key property, or no membership
* property in content, reject. */
if (!pdu.state_key ||
StrEquals(pdu.state_key, "") ||
!(membership = JsonGet(pdu.content, 1, "membership")))
{
if (errp)
{
*errp = "Step 5.1 fail: broken membership's statekey/membership";
}
return false;
}
if (JsonValueType(membership) != JSON_STRING)
{
/* Also check for the type */
if (errp)
{
*errp = "Step 5.1 fail: broken membership's membership";
}
return false;
}
membership_str = JsonValueAsString(membership);
#define JumpIfMembership(mem, func) do { \
if (StrEquals(membership_str, mem)) \
{ \
return func(room, pdu, state, errp); \
} \
} while (0)
/* Step 5.2: If membership is join. */
JumpIfMembership("join", AuthorizeJoinMembershipV1);
/* Step 5.3: If membership is invite. */
JumpIfMembership("invite", AuthorizeInviteMembershipV1);
/* Step 5.4: If membership is leave. */
JumpIfMembership("leave", AuthorizeLeaveMembershipV1);
/* Step 5.5: If membership is ban. */
JumpIfMembership("ban", AuthorizeBanMembershipV1);
/* Step 5.6: Otherwise, the membership is unknown. Reject. */
return false;
#undef JumpIfMembership
}

182
src/Room/V1/Auth/PL.c
View file

@ -1,182 +0,0 @@
#include "Room/internal.h"
#include <Schema/PduV1.h>
#include <Parser.h>
bool
AuthorisePowerLevelsV1(Room * room, PduV1 pdu, State *state)
{
/* Step 10.1: If the users property in content is not an object with
* keys that are valid user IDs with values that are integers
* (or a string that is an integer), reject. */
JsonValue *users = JsonGet(pdu.content, 1, "users");
HashMap *users_o, *prev_plevent;
char *user_id, *prev_pl_id, *ev_type;
JsonValue *power_level, *ev_obj;
bool flag = true;
int64_t userpl = RoomUserPL(room, state, pdu.sender);
HashMap *event_obj;
if (JsonValueType(users) != JSON_OBJECT)
{
return false;
}
users_o = JsonValueAsObject(users);
while (HashMapIterate(users_o, &user_id, (void **) &power_level))
{
CommonID as_cid;
if (!flag)
{
continue;
}
if (!ParseCommonID(user_id, &as_cid))
{
flag = false;
}
if (as_cid.sigil != '@')
{
CommonIDFree(as_cid);
flag = false;
continue;
}
/* Verify powerlevels.
* We'll use INT64_MAX as a sentinel value, as this isn't
* a valid powervalue for the specification. */
if (ParsePL(power_level, INT64_MAX) == INT64_MAX)
{
flag = false;
CommonIDFree(as_cid);
continue;
}
CommonIDFree(as_cid);
}
/* HashMapIterate does not support breaking, so we just set a
* flag to be used. */
if (!flag)
{
return false;
}
/* Step 10.2: If there is no previous m.room.power_levels event
* in the room, allow. */
if (!(prev_pl_id = StateGet(state, "m.room.power_levels", "")))
{
return true;
}
/* Step 10.3: For the properties users_default, events_default,
* state_default, ban, redact, kick, invite, check if they were
* added, changed or removed. For each found alteration: */
prev_plevent = RoomEventFetch(room, prev_pl_id);
#define CheckChange(prop) do \
{ \
JsonValue *old = \
JsonGet(prev_plevent, 2, "content", prop);\
JsonValue *new = \
JsonGet(pdu.content, 1, prop); \
int64_t oldv = 0, newv = 0; \
oldv = JsonValueAsInteger(old); \
newv = JsonValueAsInteger(new); \
if ((old && !new) || (!old && new) || \
(oldv != newv)) \
{ \
if (old && (oldv > userpl)) \
{ \
return false; \
} \
if (new && (newv > userpl)) \
{ \
return false; \
} \
} \
} \
while(0)
CheckChange("users_default");
CheckChange("events_default");
CheckChange("state_default");
CheckChange("ban");
CheckChange("redact");
CheckChange("kick");
CheckChange("invite");
#undef CheckChange
#define CheckPLOld(prop) \
event_obj = \
JsonValueAsObject(JsonGet(prev_plevent, 2, "content", prop)); \
flag = true; \
while (HashMapIterate(event_obj, &ev_type, (void **) &ev_obj)) \
{ \
JsonValue *new; \
int64_t new_pl, old_pl; \
\
if (!flag) \
{ \
continue; \
} \
\
new = JsonGet(pdu.content, 2, prop, ev_type); \
old_pl = ParsePL(new, INT64_MAX); \
if (((new_pl = ParsePL(new, INT64_MAX)) != INT64_MAX) && \
((new_pl != old_pl) && old_pl > userpl)) \
{ \
flag = false; \
} \
} \
if (!flag) \
{ \
JsonFree(prev_plevent); \
return false; \
} \
flag = true
#define CheckPLNew(prop) \
event_obj = \
JsonValueAsObject(JsonGet(pdu.content, 1, prop)); \
flag = true; \
while (HashMapIterate(event_obj, &ev_type, (void **) &ev_obj)) \
{ \
JsonValue *old; \
int64_t new_pl, old_pl; \
\
if (!flag) \
{ \
continue; \
} \
\
old = JsonGet(prev_plevent, 3, "content", prop, ev_type); \
new_pl = ParsePL(ev_obj, INT64_MAX); \
if (((old_pl = ParsePL(old, INT64_MAX)) != INT64_MAX && \
new_pl != old_pl) && new_pl > userpl) \
{ \
flag = false; \
} \
} \
if (!flag) \
{ \
JsonFree(prev_plevent); \
return false; \
} \
flag = true
/* Step 10.4: For each entry being changed in, or removed from, the
* events property:
* - If the current value is greater than the sender's current
* power level, reject. */
CheckPLOld("events");
/* Step 10.5: For each entry being added to, or changed in, the events
* property:
* - If the new value is greater than the sender's current power level,
* reject. */
CheckPLNew("events");
/* Steps 10.6 and 10.7 are effectively the same. */
CheckPLOld("users");
CheckPLNew("users");
#undef CheckPLOld
#undef CheckPLNew
/* Step 10.8: Otherwise, allow. */
JsonFree(prev_plevent);
return true;
}

35
src/Room/V1/Auth/internal.h
View file

@ -1,35 +0,0 @@
#ifndef TELODENDRIA_IROOM_V1_AUTH_H
#define TELODENDRIA_IROOM_V1_AUTH_H
#include "Room/internal.h"
/**
* Verifies if a room creation PDU would be allowed
* by the auth rules in room version 1 (step 1)
*/
extern bool AuthoriseCreateV1(PduV1, char **);
/**
* Verifies if an auth event PDU would be allowed by the
* auth rules in room version 1 (step 2)
*/
extern bool ConsiderAuthEventsV1(Room *, PduV1, char **);
/**
* Verifies if an alias PDU would be authorised in room
* version 1 (step 4)
*/
extern bool AuthoriseAliasV1(PduV1, char **);
/**
* Verifies if a membership PDUv1 would be allowed by the
* auth rules in room version 1 (step 5)
*/
extern bool AuthoriseMemberV1(Room *, PduV1, State *, char **);
/**
* Verifies if a PDU (power levels) would be allowed by
* the auth rules in room version 1 (step 10)
*/
extern bool AuthorisePowerLevelsV1(Room *, PduV1, State *);
#endif

17
src/Room/V1/Info.c
View file

@ -1,17 +0,0 @@
#include "Room/internal.h"
#include <Schema/PduV1.h>
#include <Parser.h>
bool
RoomIsSoftfailedV1(PduV1 pdu)
{
return pdu._unsigned.pdu_status == PDUV1_STATUS_SOFTFAIL;
}
bool
RoomIsRejectedV1(PduV1 pdu)
{
return pdu._unsigned.pdu_status == PDUV1_STATUS_SOFTFAIL;
}

74
src/Room/V1/Populate.c
View file

@ -1,74 +0,0 @@
#include "Room/internal.h"
#include <Schema/PduV1.h>
#include <Parser.h>
bool
PopulateEventV1(Room * room, HashMap * event, PduV1 * pdu, ServerPart serv)
{
char *unused;
Array *prev_events;
size_t i;
CommonID cid;
if (PduV1FromJson(event, pdu, &unused))
{
/* TODO: Clean up some fields */
return true;
}
/* Consider the PDU dropped by default */
pdu->_unsigned.pdu_status = PDUV1_STATUS_DROPPED;
/* TODO: Create a PDU of our own, signed and everything.
* https://telodendria.io/blog/matrix-protocol-overview
* has some ideas on how this could be done(up until stage 5). */
pdu->sender =
StrDuplicate(JsonValueAsString(JsonGet(event, 1, "sender")));
pdu->type =
StrDuplicate(JsonValueAsString(JsonGet(event, 1, "type")));
pdu->redacts =
StrDuplicate(JsonValueAsString(JsonGet(event, 1, "redacts")));
if (JsonGet(event, 1, "state_key"))
{
pdu->state_key =
StrDuplicate(JsonValueAsString(JsonGet(event, 1, "state_key")));
}
pdu->auth_events = ArrayCreate();
pdu->origin_server_ts = UtilTsMillis();
pdu->content =
JsonDuplicate(JsonValueAsObject(JsonGet(event, 1, "content")));
pdu->room_id = StrDuplicate(room->id);
pdu->signatures = HashMapCreate();
pdu->depth = RoomGetDepth(room) + 1;
pdu->depth = pdu->depth >= INT64_MAX ? INT64_MAX : pdu->depth;
/* Create a random event ID for this PDU.
* TODO: Optionally verify whenever it's already used, but that
* would be unlikely considering the lengths of event IDs. */
cid.sigil = '$';
cid.local = StrRandom(32);
cid.server.hostname = StrDuplicate(serv.hostname);
cid.server.port = serv.port ? StrDuplicate(serv.port) : NULL;
pdu->event_id = ParserRecomposeCommonID(cid);
CommonIDFree(cid);
/* Fill prev_events with actual event data.
* Note that we don't actually *clear* out these from our list, as
* that should be done later. */
pdu->prev_events = ArrayCreate();
prev_events = RoomPrevEventsGet(room);
for (i = 0; i < ArraySize(prev_events); i++)
{
HashMap *event = JsonValueAsObject(ArrayGet(prev_events, i));
JsonValue *event_id = JsonGet(event, 1, "event_id");
ArrayAdd(pdu->prev_events, JsonValueDuplicate(event_id));
}
/* TODO: Signatures.
* We currently *don't* have an Ed25519 implementation. */
return false;
}

550
src/Room/V1/Send.c
View file

@ -1,550 +0,0 @@
#include "Room/internal.h"
#include <Schema/Relation.h>
#include <Schema/PduV1.h>
#include <Parser.h>
static char *
RoomHashEventV1(PduV1 pdu)
{
HashMap *json = PduV1ToJson(&pdu);
char *b64;
b64 = EventContentHash(json);
JsonFree(json);
return b64;
}
static bool
EventFits(HashMap *pdu)
{
int size = CanonicalJsonEncode(pdu, NULL);
JsonValue *key;
/* Main PDU length is 65536 bytes */
if (size > 65536)
{
return false;
}
#define VerifyKey(k,s) do \
{ \
if ((key = JsonGet(pdu, 1, k)) && \
(strlen(JsonValueAsString(key)) > s)) \
{ \
return false; \
} \
} \
while (0)
VerifyKey("sender", 255);
VerifyKey("room_id", 255);
VerifyKey("state_key", 255);
VerifyKey("type", 255);
VerifyKey("event_id", 255);
return true;
#undef VerifyKey
}
static bool
EventFitsV1(PduV1 pdu)
{
HashMap *hm;
bool ret;
hm = PduV1ToJson(&pdu);
ret = EventFits(hm);
JsonFree(hm);
return ret;
}
/* TODO: Rejection */
static PduV1Status
RoomGetEventStatusV1(Room *room, PduV1 *pdu, State *prev, bool client, char **errp)
{
if (!room || !pdu || !prev)
{
if (errp)
{
*errp = "Illegal arguments given to RoomGetEventStatusV1";
}
return PDUV1_STATUS_DROPPED;
}
if (!EventFitsV1(*pdu))
{
/* Reject this event as it is too large. */
if (errp)
{
*errp = "PDU is too large to fit";
}
return PDUV1_STATUS_DROPPED;
}
if (!RoomAuthoriseEventV1(room, *pdu, prev, errp))
{
/* Reject this event as the PDU's own state does not allow it. */
return PDUV1_STATUS_DROPPED;
}
if (!client)
{
/* Checking for soft-failure is not that useful in that case,
* we're only doing pointless computation. */
State *current = StateCurrent(room);
if (!RoomAuthoriseEventV1(room, *pdu, current, errp))
{
StateFree(current);
return PDUV1_STATUS_SOFTFAIL;
}
StateFree(current);
}
return PDUV1_STATUS_ACCEPTED;
}
static void
RedactPDU1(HashMap *obj)
{
Array *keys;
HashMap *content;
char *type = JsonValueAsString(HashMapGet(obj, "type"));
size_t i;
if (!obj)
{
return;
}
keys = HashMapKeys(obj);
for (i = 0; i < ArraySize(keys); i++)
{
char *key = ArrayGet(keys, i);
if (!StrEquals(key, "event_id") && !StrEquals(key, "type") &&
!StrEquals(key, "room_id") && !StrEquals(key, "sender") &&
!StrEquals(key, "state_key")&& !StrEquals(key, "content") &&
!StrEquals(key, "hashes") && !StrEquals(key, "signature") &&
!StrEquals(key, "depth") && !StrEquals(key, "prev_events") &&
!StrEquals(key, "auth_events")&& !StrEquals(key, "origin") &&
!StrEquals(key, "unsigned") &&
!StrEquals(key, "origin_server_ts")&&!StrEquals(key, "membership"))
{
JsonValueFree(HashMapDelete(obj, key));
continue;
}
}
ArrayFree(keys);
JsonValueFree(HashMapSet(
obj,
"unsigned", JsonValueObject(HashMapCreate())
));
content = JsonValueAsObject(HashMapGet(obj, "content"));
keys = HashMapKeys(content);
for (i = 0; i < ArraySize(keys); i++)
{
char *key = ArrayGet(keys, i);
if (StrEquals(type, "m.room.member"))
{
if (StrEquals(key, "membership"))
{
continue;
}
}
if (StrEquals(type, "m.room.create"))
{
if (StrEquals(key, "creator"))
{
continue;
}
}
if (StrEquals(type, "m.room.join_rules"))
{
if (StrEquals(key, "join_rule"))
{
continue;
}
}
if (StrEquals(type, "m.room.aliases"))
{
if (StrEquals(key, "aliases"))
{
continue;
}
}
if (StrEquals(type, "m.room.history_visibility"))
{
if (StrEquals(key, "history_visibility"))
{
continue;
}
}
if (StrEquals(type, "m.room.power_levels"))
{
if (StrEquals(key, "ban") ||
StrEquals(key, "events") ||
StrEquals(key, "events_default") ||
StrEquals(key, "kick") ||
StrEquals(key, "redact") ||
StrEquals(key, "state_default") ||
StrEquals(key, "users") ||
StrEquals(key, "users_default"))
{
continue;
}
}
JsonValueFree(HashMapDelete(content, key));
}
ArrayFree(keys);
}
bool
RoomAddEventV1(Room *room, PduV1 pdu, PduV1Status status)
{
DbRef *event_ref;
Array *prev_events = NULL, *leaves = NULL;
HashMap *leaves_json = NULL, *pdu_json = NULL;
JsonValue *leaves_val;
char *safe_id;
size_t i;
if (!room || room->version >= 3 ||
status == PDUV1_STATUS_DROPPED)
{
return false;
}
/* Insert our PDU into the event table, regardless of status */
safe_id = CreateSafeID(pdu.event_id);
event_ref = DbCreate(room->db, 4, "rooms", room->id, "events", safe_id);
pdu_json = PduV1ToJson(&pdu);
/* TODO: Use those values concretely. */
pdu._unsigned.pdu_status = status;
JsonSet(DbJson(event_ref), JsonValueObject(pdu_json), 1, "pdu");
pdu_json = NULL;
JsonSet(
DbJson(event_ref),
JsonValueString(PduV1StatusToStr(status)),
1, "status"
);
JsonSet(
DbJson(event_ref),
JsonValueArray(ArrayCreate()),
1, "next_events"
);
DbUnlock(room->db, event_ref);
Free(safe_id);
/* Only accepted PDUs get to do the news */
if (status == PDUV1_STATUS_ACCEPTED)
{
/* Remove managed leaves here. */
leaves_json = DbJson(room->leaves_ref);
leaves_val = JsonValueDuplicate(JsonGet(leaves_json, 1, "leaves"));
leaves = JsonValueAsArray(leaves_val);
Free(leaves_val); /* We do not care about the array's JSON shell. */
prev_events = pdu.prev_events;
for (i = 0; i < ArraySize(prev_events); i++)
{
JsonValue *event_val = ArrayGet(prev_events, i);
char *event_id = JsonValueAsString(event_val);
size_t j;
ssize_t delete_index = -1;
for (j = 0; j < ArraySize(leaves); j++)
{
JsonValue *leaf_val = ArrayGet(leaves, j);
HashMap *leaf_object = JsonValueAsObject(leaf_val);
char *leaf_id =
JsonValueAsString(JsonGet(leaf_object, 1, "event_id"));
if (StrEquals(leaf_id, event_id))
{
delete_index = j;
break;
}
}
if (delete_index == -1)
{
continue;
}
JsonValueFree(ArrayDelete(leaves, delete_index));
}
/* Add our current PDU to the leaves. */
ArrayAdd(leaves, JsonValueObject(PduV1ToJson(&pdu)));
leaves_json = JsonDuplicate(leaves_json);
JsonValueFree(HashMapDelete(leaves_json, "leaves"));
JsonSet(leaves_json, JsonValueArray(leaves), 1, "leaves");
DbJsonSet(room->leaves_ref, leaves_json);
JsonFree(leaves_json);
}
for (i = 0; i < ArraySize(prev_events); i++)
{
JsonValue *event_val = ArrayGet(prev_events, i);
char *id = JsonValueAsString(event_val);
char *error = NULL;
PduV1 prev_pdu = { 0 };
HashMap *prev_object = NULL;
Array *next_events = NULL;
HashMap *refObj = NULL;
HashMap *pduObj = NULL;
/* TODO: This confuses me! */
event_ref = DbLock(room->db, 4, "rooms", room->id, "events", id);
refObj = DbJson(event_ref);
pduObj = JsonValueAsObject(HashMapGet(refObj, "pdu"));
PduV1FromJson(pduObj, &prev_pdu, &error);
next_events = JsonValueAsArray(HashMapGet(refObj, "next_events"));
ArrayAdd(next_events, JsonValueString(pdu.event_id));
prev_object = PduV1ToJson(&prev_pdu);
JsonValueFree(HashMapSet(refObj, "pdu", JsonValueObject(prev_object)));
PduV1Free(&prev_pdu);
DbUnlock(room->db, event_ref);
}
/* Accepted PDUs should be the only one that users should be
* notified about. */
if (status == PDUV1_STATUS_ACCEPTED)
{
HashMap *relates_to =
JsonValueAsObject(HashMapGet(pdu.content, "m.relates_to"));
Relation rel = { 0 };
State *state;
char *type, *state_key, *event_id;
pdu_json = PduV1ToJson(&pdu);
/* If we have a membership change, then add it to the
* proper table. */
if (RelationFromJson(relates_to, &rel, NULL))
{
DbRef *relate = DbLock(
room->db,
4, "rooms", room->id, "events", rel.event_id
);
HashMap *relObj = DbJson(relate);
if (relObj)
{
Array *relList = JsonValueAsArray(HashMapGet(
relObj, "relations"
));
if (!relList)
{
relList = ArrayCreate();
JsonValueFree(HashMapSet(
relObj, "relations", JsonValueArray(relList)
));
}
/* TODO: We may want to treat the relation as 'special'
* if the specification asks us to bundle it. */
ArrayAdd(relList, JsonValueString(pdu.event_id));
}
RelationFree(&rel);
DbUnlock(room->db, relate);
}
if (StrEquals(pdu.type, "m.room.member"))
{
CommonID *id = UserIdParse(pdu.state_key, NULL);
User *user = UserLockID(room->db, id);
char *membership = JsonValueAsString(
HashMapGet(pdu.content, "membership")
);
if (StrEquals(membership, "join") && user)
{
UserAddJoin(user, room->id);
UserPushJoinSync(user, room->id);
}
else if (StrEquals(membership, "invite") && user)
{
UserAddInvite(user, room->id);
UserPushInviteSync(user, room->id);
}
else if ((StrEquals(membership, "leave") && user) ||
StrEquals(membership, "ban"))
{
UserRemoveInvite(user, room->id);
UserRemoveJoin(user, room->id);
}
UserIdFree(id);
UserUnlock(user);
}
else if (StrEquals(pdu.type, "m.room.redaction") && pdu.redacts)
{
char *redacted = pdu.redacts;
DbRef *eventRef = DbLock(room->db,
4, "rooms", room->id,
"events", redacted
);
RedactPDU1(
JsonValueAsObject(HashMapGet(DbJson(eventRef), "pdu"))
);
JsonValueFree(HashMapSet(
DbJson(eventRef),
"redacted_by", JsonValueString(pdu.redacts)
));
DbUnlock(room->db, eventRef);
}
state = StateCurrent(room);
while (StateIterate(state, &type, &state_key, (void **) &event_id))
{
if (StrEquals(type, "m.room.member"))
{
CommonID *id = UserIdParse(state_key, NULL);
User *user = UserLockID(room->db, id);
UserPushEvent(user, pdu_json);
UserIdFree(id);
UserUnlock(user);
}
Free(type);
Free(state_key);
}
StateFree(state);
JsonFree(pdu_json);
}
return true;
}
HashMap *
RoomEventSendV1(Room * room, HashMap * event, char **errp)
{
PduV1 pdu = { 0 };
HashMap *pdu_object = NULL;
bool client_event, valid = false;
State *state = NULL;
PduV1Status status;
client_event = !PopulateEventV1(room, event, &pdu, RoomGetCreator(room));
pdu_object = PduV1ToJson(&pdu);
state = StateResolve(room, pdu_object);
if (client_event)
{
char *ev_id;
#define AddState(type, key) do \
{ \
ev_id = StateGet(state, type, key); \
if (ev_id) \
{ \
JsonValue *v = JsonValueString(ev_id); \
ArrayAdd(pdu.auth_events, v); \
} \
} \
while (0)
/*
* Implemented from
* https://spec.matrix.org/v1.7/server-server-api/
* #auth-events-selection */
AddState("m.room.create", "");
AddState("m.room.power_levels", "");
AddState("m.room.member", pdu.sender);
if (StrEquals(pdu.type, "m.room.member"))
{
char *target = pdu.state_key;
char *membership =
JsonValueAsString(JsonGet(pdu.content, 1, "membership"));
char *auth_via =
JsonValueAsString(
JsonGet(
pdu.content, 1, "join_authorised_via_users_server")
);
HashMap *inv =
JsonValueAsObject(
JsonGet(pdu.content, 1, "third_party_invite"));
if (target && !StrEquals(target, pdu.sender))
{
AddState("m.room.member", target);
}
if (StrEquals(membership, "join") ||
StrEquals(membership, "invite"))
{
AddState("m.room.join_rules", "");
}
if (StrEquals(membership, "invite") && inv)
{
char *token =
JsonValueAsString(JsonGet(inv, 2, "signed", "token"));
AddState("m.room.third_party_invite", token);
}
if (auth_via && room->version >= 8)
{
AddState("m.room.member", auth_via);
}
}
pdu.hashes.sha256 = RoomHashEventV1(pdu);
#undef AddState
}
/* It seems like we need to behave differently in terms of
* verifying PDUs from the client/federation.
* - In the client, we just do not care about any events that
* are incorrect. We simply drop them, as if they never existed.
* - In the server on the otherhand, the only place where we can
* possibly drop events as such is if it fails signatures. In
* other cases, we *have* to store it(ableit with flags, to
* restrict what we can do).
* - Rejection: We avoid relaying/linking those to anything.
* They must NOT be used for stateres.
* - Softfail: Essentially almost the same as rejects, except
* that they *are* used for stateres.
* I guess a way to do this may be to add a CheckAuthStatus
* function that also verifies if it is a client event, and returns
* an enum:
* - DROPPED: Do NOT process it _at all_
* - REJECT: Process that event as if it was rejected
* - SOFTFAIL: Process the event as if it was softfailed
* The main issue is storing it in the PDU. A naive approach would be to
* add the status to the unsigned field of the PDU, and add functions to
* return the status. I guess that is possible, but then again, can we
* really abuse the unsigned field for this?
*/
/* TODO: For PDU events, we should verify their hashes. */
status = RoomGetEventStatusV1(room, &pdu, state, client_event, errp);
if (status == PDUV1_STATUS_DROPPED)
{
goto finish;
}
StateFree(state);
RoomAddEventV1(room, pdu, status);
state = NULL;
valid = true;
/* If it is a client event, we should make sure that we shout at
* every other homeserver about our new event. */
finish:
if (state)
{
StateFree(state);
}
if (pdu_object)
{
JsonFree(pdu_object);
pdu_object = NULL;
}
if (valid)
{
pdu_object = PduV1ToJson(&pdu);
}
PduV1Free(&pdu);
return pdu_object;
}

90
src/Room/internal.h
View file

@ -1,90 +0,0 @@
#ifndef TELODENDRIA_IROOM_H
#define TELODENDRIA_IROOM_H
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Util.h>
#include <Cytoplasm/Str.h>
#include <Cytoplasm/Db.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <CanonicalJson.h>
#include <Parser.h>
#include <Config.h>
#include <State.h>
#include <User.h>
#define IsState(p, typ, key) (StrEquals((p)->type, typ) && \
StrEquals((p)->state_key, key))
struct Room
{
Db *db;
DbRef *state_ref;
DbRef *leaves_ref; /* Reference to the leaf list */
ServerPart creator;
char *id;
int version;
};
/**
* Populates a room with the events required for its creation.
*/
extern void RoomPopulate(Room *, User *, RoomCreateRequest *, ServerPart);
/**
* Verifies if the current room state has a joinrule set to a
* specific value.
*/
extern bool RoomIsJoinRule(Room *, State *, char *);
/**
* Tries to parse a PL value from a JsonValue, with a default
* powerlevel, if it cannot parse it.
*/
extern int64_t ParsePL(JsonValue *, int64_t);
/**
* Computes the lowest powerlevel required to execute an action
* in a room.
*/
extern int64_t RoomMinPL(Room *, State *, char *, char *);
/**
* Computes the user's powerlevel at a specific state.
*/
extern int64_t RoomUserPL(Room *, State *, char *);
/**
* Populates an event to a valid PDUv1(and returns true if
* properly created).
*/
extern bool PopulateEventV1(Room *, HashMap *, PduV1 *, ServerPart);
/**
* Sends an event to a room, be it a PDUv1/client event
*/
extern HashMap * RoomEventSendV1(Room *, HashMap *, char **);
/**
* Verifies if the user has a specific membership at a given state.
*/
extern bool RoomUserHasMembership(Room *, State *, char *, char *);
/**
* Computes a PDU's contenthash.
*/
extern char * EventContentHash(HashMap *);
/**
* Creates a new "DB-safe" ID for events.
*/
extern char * CreateSafeID(char *);
#endif

20
src/Routes.c
View file

@ -77,31 +77,11 @@ RouterBuild(void)
R("/_matrix/client/v3/user/(.*)/filter", RouteFilter);
R("/_matrix/client/v3/user/(.*)/filter/(.*)", RouteFilter);
R("/_matrix/client/v3/rooms/(.*)/send/(.*)/(.*)", RouteSendEvent);
R("/_matrix/client/v3/rooms/(.*)/redact/(.*)/(.*)", RouteRedact);
R("/_matrix/client/v3/rooms/(.*)/state/(.*)/(.*)", RouteSendState);
R("/_matrix/client/v3/rooms/(.*)/state/(.*)", RouteSendState);
R("/_matrix/client/v3/rooms/(.*)/event/(.*)", RouteFetchEvent);
R("/_matrix/client/v3/rooms/(.*)/(join|leave)", RouteJoinRoom);
R("/_matrix/client/v3/rooms/(.*)/(kick|ban|unban)", RouteKickRoom);
R("/_matrix/client/v3/rooms/(.*)/messages", RouteMessages);
R("/_matrix/client/v3/join/(.*)", RouteJoinRoomAlias);
R("/_matrix/client/v3/joined_rooms", RouteJoinedRooms);
R("/_matrix/client/v3/createRoom", RouteCreateRoom);
R("/_matrix/client/v3/sync", RouteSync);
R("/_matrix/client/v3/directory/room/(.*)", RouteAliasDirectory);
R("/_matrix/client/v3/rooms/(.*)/aliases", RouteRoomAliases);
/* Spoofed endpoints, to be TODO'd */
R("/_matrix/client/v3/keys/(query|upload)", RouteKeyQuery);
R("/_matrix/client/v3/pushrules", RoutePushrules);
/* Telodendria Admin API Routes */
R("/_telodendria/admin/v1/(restart|shutdown|stats)", RouteProcControl);

338
src/Routes/RouteActRoom.c
View file

@ -1,338 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <string.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RouteJoinRoom, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *request = NULL;
HashMap *response = NULL;
User *user = NULL;
char *token = NULL;
CommonID *id = NULL;
char *roomId = ArrayGet(path, 0);
char *action = ArrayGet(path, 1);
char *sender = NULL, *serverName = NULL;
Room *room = NULL;
char *err;
if (!roomId)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (HttpRequestMethodGet(args->context) != HTTP_POST)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
room = RoomLock(db, roomId);
if (!room)
{
err = "Room ID does not exist.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNKNOWN, err);
goto finish;
}
if (StrEquals(action, "join"))
{
if (RoomContainsUser(room, sender))
{
err = "User is already in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
if (!RoomCanJoin(room, sender))
{
err = "User cannot be in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
/* TODO: Custom reason parameter. */
if (!RoomJoin(room, user, &err))
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_BAD_STATE, err);
goto finish;
}
response = HashMapCreate();
JsonSet(response, JsonValueString(roomId), 1, "room_id");
}
else if (StrEquals(action, "leave"))
{
if (!RoomContainsUser(room, sender))
{
err = "User is not already in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
if (!RoomLeave(room, user, &err))
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_BAD_STATE, err);
goto finish;
}
response = HashMapCreate();
}
finish:
UserIdFree(id);
JsonFree(request);
if (sender)
{
Free(sender);
}
if (serverName)
{
Free(serverName);
}
RoomUnlock(room);
UserUnlock(user);
return response;
}
ROUTE_IMPL(RouteKickRoom, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *request = NULL;
HashMap *response = NULL;
HashMap *content, *membership;
HashMap *pduResponse;
User *user = NULL;
char *token = NULL;
CommonID *id = NULL;
char *roomId = ArrayGet(path, 0);
char *action = ArrayGet(path, 1);
char *kicked = NULL, *reason = NULL;
char *sender = NULL, *serverName = NULL;
char *membershipState;
Room *room = NULL;
char *err;
if (!roomId || !action)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (StrEquals(action, "kick"))
{
membershipState = "leave";
}
else if (StrEquals(action, "ban"))
{
membershipState = "ban";
}
else if (StrEquals(action, "unban"))
{
membershipState = "leave";
}
else
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (HttpRequestMethodGet(args->context) != HTTP_POST)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
kicked = JsonValueAsString(HashMapGet(request, "reason"));
if (!(kicked = JsonValueAsString(HashMapGet(request, "user_id"))))
{
err = "'user_id' field required(string), but not given";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_BAD_JSON, err);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
room = RoomLock(db, roomId);
if (!RoomContainsUser(room, sender))
{
err = "Sender is not already in the room";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
if (RoomContainsUser(room, kicked) == StrEquals(action, "unban"))
{
err = "Victim is not present in the room";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_BAD_STATE, err);
goto finish;
}
content = HashMapCreate();
membership = RoomEventCreate(
sender,
"m.room.member", kicked,
content
);
HashMapSet(content, "membership", JsonValueString(membershipState));
if (reason)
{
HashMapSet(content, "reason", JsonValueString(reason));
}
pduResponse = RoomEventSend(room, membership, &err);
if (!pduResponse)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_BAD_STATE, err);
JsonFree(membership);
goto finish;
}
JsonFree(pduResponse);
JsonFree(membership);
response = HashMapCreate();
finish:
UserIdFree(id);
JsonFree(request);
if (sender)
{
Free(sender);
}
if (serverName)
{
Free(serverName);
}
RoomUnlock(room);
UserUnlock(user);
return response;
}

58
src/Routes/RouteCreateRoom.c
View file

@ -23,14 +23,11 @@
* SOFTWARE.
*/
#include "Cytoplasm/Http.h"
#include <Routes.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Log.h>
#include <Room.h>
#include <User.h>
#include <Schema/RoomCreateRequest.h>
ROUTE_IMPL(RouteCreateRoom, path, argp)
{
@ -38,21 +35,11 @@ ROUTE_IMPL(RouteCreateRoom, path, argp)
HashMap *request = NULL;
HashMap *response;
Room *room = NULL;
Db *db = args->matrixArgs->db;
RoomCreateRequest parsed = { 0 };
User *user = NULL;
Config cfg;
ServerPart server;
char *token;
RoomCreateRequest parsed;
char *err;
(void) path;
ConfigLock(db, &cfg);
ParseServerPart(cfg.serverName, &server);
if (HttpRequestMethodGet(args->context) != HTTP_POST)
{
err = "Unknown request method.";
@ -61,18 +48,6 @@ ROUTE_IMPL(RouteCreateRoom, path, argp)
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
return response;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
return MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
@ -80,19 +55,7 @@ ROUTE_IMPL(RouteCreateRoom, path, argp)
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
/* j2s hack: Setting to a default value like that.
* It's definitely NOT good(you can't rely on enums to
* store values outside their limits in the C standard,
* and this line will need to be changed everytime the
* preset list is changed).
*
* I do believe a decent solution to this would be to
* add a 'default' type(maybe initialised to 0 so that
* memsets would work as intended), that *wouldn't* be
* returned by j2s itself.
* TODO. */
parsed.preset = ROOM_CREATE_PRIVATE + 1;
if (!RoomCreateRequestFromJson(request, &parsed, &err))
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
@ -104,24 +67,9 @@ ROUTE_IMPL(RouteCreateRoom, path, argp)
JsonFree(request);
request = NULL;
if (!(room = RoomCreate(db, user, &parsed, server)))
{
err = "Couldn't create room.";
/* Consider another error status. */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
response = HashMapCreate();
JsonSet(response, JsonValueString(RoomIdGet(room)), 1, "room_id");
finish:
JsonFree(request);
RoomUnlock(room);
UserUnlock(user);
ConfigUnlock(&cfg);
ServerPartFree(server);
RoomCreateRequestFree(&parsed);
return response;
}

126
src/Routes/RouteFetchEvent.c
View file

@ -1,126 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <string.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RouteFetchEvent, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *event = NULL;
HashMap *response = NULL;
User *user = NULL;
char *token = NULL;
CommonID *id = NULL;
char *roomId = ArrayGet(path, 0);
char *eventId= ArrayGet(path, 1);
char *sender = NULL, *serverName = NULL;
Room *room = NULL;
char *err;
if (!roomId || !eventId)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (HttpRequestMethodGet(args->context) != HTTP_GET)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
/* TODO: Better auth(as in check m.room.history_visibility) */
room = RoomLock(db, roomId);
if (!RoomContainsUser(room, sender))
{
err = "User is not in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
event = RoomEventFetch(room, eventId);
response = RoomEventClientify(event);
JsonFree(event);
finish:
UserIdFree(id);
if (sender)
{
Free(sender);
}
if (serverName)
{
Free(serverName);
}
RoomUnlock(room);
UserUnlock(user);
return response;
}

28
src/Routes/RouteFilter.c
View file

@ -30,13 +30,31 @@
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <User.h>
#include <string.h>
#include <Config.h>
#include <User.h>
#include <Schema/Filter.h>
static char *
GetServerName(Db * db)
{
char *name;
Config config;
ConfigLock(db, &config);
if (!config.ok)
{
return NULL;
}
name = StrDuplicate(config.serverName);
ConfigUnlock(&config);
return name;
}
ROUTE_IMPL(RouteFilter, path, argp)
{
RouteArgs *args = argp;
@ -62,7 +80,7 @@ ROUTE_IMPL(RouteFilter, path, argp)
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
serverName = ConfigGetServerName(db);
serverName = GetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
@ -171,7 +189,7 @@ ROUTE_IMPL(RouteFilter, path, argp)
DbJsonSet(ref, filterJson);
DbUnlock(db, ref);
JsonFree(filterJson);
Free(filterJson);
response = HashMapCreate();
HashMapSet(response, "filter_id", JsonValueString(filterId));

171
src/Routes/RouteJoinRoomAlias.c
View file

@ -1,171 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <string.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RouteJoinRoomAlias, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *request = NULL;
HashMap *response = NULL;
User *user = NULL;
char *token = NULL;
CommonID *id = NULL;
char *roomId = ArrayGet(path, 0);
char *sender = NULL, *serverName = NULL;
Room *room = NULL;
char *err;
if (!roomId)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (*roomId != '!')
{
roomId = RoomResolveAlias(db, roomId);
}
else
{
roomId = StrDuplicate(roomId);
}
if (!roomId)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
if (HttpRequestMethodGet(args->context) != HTTP_POST)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
room = RoomLock(db, roomId);
if (!room)
{
err = "Room ID does not exist.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNKNOWN, err);
goto finish;
}
if (RoomContainsUser(room, sender))
{
err = "User is already in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
if (!RoomCanJoin(room, sender))
{
err = "User cannot be in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
/* TODO: Custom reason parameter. */
if (!RoomJoin(room, user, &err))
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
response = HashMapCreate();
JsonSet(response, JsonValueString(roomId), 1, "room_id");
finish:
Free(roomId);
UserIdFree(id);
JsonFree(request);
if (sender)
{
Free(sender);
}
if (serverName)
{
Free(serverName);
}
RoomUnlock(room);
UserUnlock(user);
return response;
}

93
src/Routes/RouteJoinedRooms.c
View file

@ -1,93 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <User.h>
#include <Room.h>
#include <string.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RouteJoinedRooms, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *response = NULL;
User *user = NULL;
char *token = NULL;
Array *rawRoomList;
Array *roomIds;
char *err;
size_t i;
if (HttpRequestMethodGet(args->context) != HTTP_GET)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
rawRoomList = UserListJoins(user);
roomIds = ArrayCreate();
for (i = 0; i < ArraySize(rawRoomList); i++)
{
ArrayAdd(roomIds, JsonValueString(ArrayGet(rawRoomList, i)));
}
UserFreeList(rawRoomList);
response = HashMapCreate();
HashMapSet(response, "joined_rooms", JsonValueArray(roomIds));
(void) path;
finish:
UserUnlock(user);
return response;
}

159
src/Routes/RouteMessages.c
View file

@ -1,159 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
#include <string.h>
#include <stdlib.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RouteMessages, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *params = HttpRequestParams(args->context);
HashMap *response = NULL;
User *user = NULL;
char *token = NULL;
char *roomId = ArrayGet(path, 0);
char *from = HashMapGet(params, "from");
char *limitStr = HashMapGet(params, "limit");
char *end = NULL;
char *sender = NULL;
char *serverName = NULL;
CommonID *id = NULL;
int limit = strtol(limitStr, NULL, 10);
Array *messages = NULL;
Room *room = NULL;
char *err;
if (!limit || limit < 0)
{
limit = 10;
}
if (!roomId)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (HttpRequestMethodGet(args->context) != HTTP_GET)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
room = RoomLock(db, roomId);
if (!RoomContainsUser(room, sender))
{
err = "User is not in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
RoomUnlock(room);
/* TODO: Filters, to, and friends */
messages = UserFetchMessages(user, limit, from, &end);
if (!messages)
{
Room *r = RoomLock(db, roomId);
Array *leaf = RoomPrevEventsGet(r);
HashMap *start = JsonValueAsObject(ArrayGet(leaf, 0));
char *startId = StrDuplicate(
JsonValueAsString(HashMapGet(start, "event_id"))
);
char *token = UserNewMessageToken(user, roomId, startId);
RoomUnlock(r);
messages = UserFetchMessages(user, limit, token, &end);
Free(token);
Free(startId);
}
response = HashMapCreate();
JsonSet(response, JsonValueArray(messages), 1, "chunk");
if (end)
{
JsonSet(response, JsonValueString(end), 1, "end");
Free(end);
}
UserFreeMessageToken(user, from);
finish:
UserUnlock(user);
UserIdFree(id);
if (sender)
{
Free(sender);
}
if (serverName)
{
Free(serverName);
}
return response;
}

129
src/Routes/RoutePushRules.c
View file

@ -1,129 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Cytoplasm/HttpServer.h>
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <User.h>
#include <Room.h>
#include <string.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RoutePushrules, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *response = NULL;
User *user = NULL;
char *token = NULL;
char *err;
if (HttpRequestMethodGet(args->context) != HTTP_GET)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
response = HashMapCreate();
JsonSet(response, JsonValueObject(HashMapCreate()), 1, "global");
(void) path;
finish:
UserUnlock(user);
return response;
}
ROUTE_IMPL(RouteKeyQuery, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *request = NULL;
HashMap *response = NULL;
User *user = NULL;
char *token = NULL;
char *err;
if (HttpRequestMethodGet(args->context) != HTTP_POST)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
response = HashMapCreate();
(void) path;
finish:
JsonFree(request);
UserUnlock(user);
return response;
}

150
src/Routes/RouteRedact.c
View file

@ -1,150 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <string.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RouteRedact, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *request = NULL;
HashMap *response = NULL;
User *user = NULL;
CommonID *id = NULL;
char *token = NULL;
char *serverName = NULL;
char *roomId = ArrayGet(path, 0);
char *eventId = ArrayGet(path, 1);
char *transId = ArrayGet(path, 2);
char *redactId = NULL;
char *sender = NULL;
char *reason = NULL;
Room *room = NULL;
char *err = NULL;
if (!roomId || !eventId || !transId)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (HttpRequestMethodGet(args->context) != HTTP_PUT)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
reason = JsonValueAsString(HashMapGet(request, "reason"));
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
if ((response = UserGetTransaction(user, transId, "redact")))
{
goto finish;
}
room = RoomLock(db, roomId);
if (!RoomContainsUser(room, sender))
{
err = "User is not in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
if (!(redactId = RoomRedact(room, user, eventId, reason, &err)))
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
response = HashMapCreate();
HashMapSet(response, "event_id", JsonValueString(redactId));
UserSetTransaction(user, transId, "redact", response);
Free(redactId);
finish:
RoomUnlock(room);
Free(serverName);
if (sender)
{
Free(sender);
}
UserIdFree(id);
UserUnlock(user);
JsonFree(request);
return response;
}

26
src/Routes/RouteRoomAliases.c
View file

@ -31,7 +31,6 @@
#include <Matrix.h>
#include <User.h>
#include <Room.h>
ROUTE_IMPL(RouteRoomAliases, path, argp)
{
@ -41,15 +40,16 @@ ROUTE_IMPL(RouteRoomAliases, path, argp)
char *msg;
HashMap *response = NULL;
HashMap *aliases = NULL;
HashMap *reversealias = NULL;
Array *alias = NULL, *arr;
JsonValue *val;
Db *db = args->matrixArgs->db;
DbRef *ref = NULL;
User *user = NULL;
size_t i;
if (HttpRequestMethodGet(args->context) != HTTP_GET)
{
msg = "Route only accepts GET.";
@ -81,10 +81,11 @@ ROUTE_IMPL(RouteRoomAliases, path, argp)
response = MatrixErrorCreate(M_FORBIDDEN, msg);
goto finish;
}
alias = RoomReverseAlias(db, roomId);
if (!alias)
ref = DbLock(db, 1, "aliases");
aliases = DbJson(ref);
reversealias = JsonValueAsObject(JsonGet(aliases, 2, "id", roomId));
if (!reversealias)
{
/* We do not know about the room ID. */
msg = "Unknown room ID.";
@ -92,17 +93,12 @@ ROUTE_IMPL(RouteRoomAliases, path, argp)
response = MatrixErrorCreate(M_INVALID_PARAM, msg);
goto finish;
}
arr = ArrayCreate();
for (i = 0; i < ArraySize(alias); i++)
{
char *str = ArrayGet(alias, i);
ArrayAdd(arr, JsonValueString(str));
}
response = HashMapCreate();
HashMapSet(response, "aliases", JsonValueArray(arr));
val = JsonGet(reversealias, 1, "aliases");
HashMapSet(response, "aliases", JsonValueDuplicate(val));
finish:
RoomFreeReverse(alias);
DbUnlock(db, ref);
UserUnlock(user);
return response;
}

267
src/Routes/RouteSendEvent.c
View file

@ -1,267 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Routes.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <string.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
#include <Schema/Filter.h>
ROUTE_IMPL(RouteSendEvent, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *request = NULL, *event = NULL;
HashMap *response = NULL, *filled = NULL;
User *user = NULL;
CommonID *id = NULL;
char *token = NULL;
char *serverName = NULL;
char *roomId = ArrayGet(path, 0);
char *eventType = ArrayGet(path, 1);
char *transId = ArrayGet(path, 2);
char *sender = NULL;
Room *room = NULL;
char *err = NULL;
if (!roomId || !eventType || !transId)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (HttpRequestMethodGet(args->context) != HTTP_PUT)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
if ((response = UserGetTransaction(user, transId, "send")))
{
goto finish;
}
room = RoomLock(db, roomId);
if (!RoomContainsUser(room, sender))
{
err = "User is not in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
event = RoomEventCreate(sender, eventType, NULL, JsonDuplicate(request));
filled = RoomEventSend(room, event, &err);
JsonFree(event);
if (!filled)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
response = HashMapCreate();
HashMapSet(
response, "event_id",
JsonValueDuplicate(HashMapGet(filled, "event_id"))
);
JsonFree(filled);
UserSetTransaction(user, transId, "send", response);
finish:
RoomUnlock(room);
Free(serverName);
if (sender)
{
Free(sender);
}
UserIdFree(id);
UserUnlock(user);
JsonFree(request);
return response;
}
ROUTE_IMPL(RouteSendState, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *request = NULL, *event = NULL;
HashMap *response = NULL, *filled = NULL;
User *user = NULL;
CommonID *id = NULL;
char *token = NULL;
char *serverName = NULL;
char *roomId = ArrayGet(path, 0);
char *eventType = ArrayGet(path, 1);
char *stateKey = ArrayGet(path, 2);
char *sender = NULL;
Room *room = NULL;
char *err;
if (!roomId || !eventType)
{
/* Should be impossible */
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
return MatrixErrorCreate(M_UNKNOWN, NULL);
}
if (HttpRequestMethodGet(args->context) != HTTP_PUT)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
serverName = ConfigGetServerName(db);
if (!serverName)
{
HttpResponseStatus(args->context, HTTP_INTERNAL_SERVER_ERROR);
response = MatrixErrorCreate(M_UNKNOWN, NULL);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
request = JsonDecode(HttpServerStream(args->context));
if (!request)
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_NOT_JSON, NULL);
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
id = UserIdParse(UserGetName(user), serverName);
id->sigil = '@';
sender = ParserRecomposeCommonID(*id);
room = RoomLock(db, roomId);
if (!RoomContainsUser(room, sender))
{
err = "User is not in the room.";
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
event = RoomEventCreate(
sender,
eventType, stateKey ? stateKey : "",
JsonDuplicate(request)
);
filled = RoomEventSend(room, event, &err);
JsonFree(event);
if (!filled)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_FORBIDDEN, err);
goto finish;
}
response = HashMapCreate();
HashMapSet(
response, "event_id",
JsonValueDuplicate(HashMapGet(filled, "event_id"))
);
JsonFree(filled);
finish:
RoomUnlock(room);
Free(serverName);
if (sender)
{
Free(sender);
}
UserIdFree(id);
UserUnlock(user);
JsonFree(request);
return response;
}

8
src/Routes/RouteStaticLogin.c
View file

@ -52,8 +52,8 @@ ROUTE_IMPL(RouteStaticLogin, path, argp)
StreamPuts(stream,
"function buildRequest(user, pass) {"
" var d = findGetParameter('device_id');"
" var i = findGetParameter('initial_device_display_name');"
" var r = findGetParameter('refresh_token') === 'true';"
" var i = findGetParameter('initial_device_display_name');"
" var r = findGetParameter('refresh_token') === 'true';"
" var request = {};"
" request['type'] = 'm.login.password';"
" request['identifier'] = {"
@ -88,9 +88,9 @@ ROUTE_IMPL(RouteStaticLogin, path, argp)
StreamPuts(stream,
"onFormSubmit('login-form', (frm) => {"
" var user = document.getElementById('user').value;"
" var pass = document.getElementById('password').value;"
" var pass = document.getElementById('password').value;"
" if (!user || !pass) {"
" setFormError('Please provide a username and password.');"
" setFormError('Please provide a username and password.');"
" return;"
" }"
" setFormError(null);"

266
src/Routes/RouteSync.c
View file

@ -1,266 +0,0 @@
/*
* Copyright (C) 2022-2024 Jordan Bancino <@jordan:bancino.net> with
* other valuable contributors. See CONTRIBUTORS.txt for the full list.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation files
* (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#include <Cytoplasm/HttpServer.h>
#include <Routes.h>
#include <Schema/SyncResponse.h>
#include <Schema/Filter.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Util.h>
#include <Cytoplasm/Str.h>
#include <Filter.h>
#include <State.h>
#include <User.h>
#include <Room.h>
#include <string.h>
#include <stdlib.h>
static ClientEventWithoutRoomID
ClientfyEventSync(HashMap *pdu)
{
ClientEventWithoutRoomID ret = { 0 };
char *ignored;
ClientEventWithoutRoomIDFromJson(pdu, &ret, &ignored);
return ret;
}
static StrippedStateEvent
StripStateEventSync(HashMap *pdu)
{
StrippedStateEvent ret = { 0 };
char *ignored;
StrippedStateEventFromJson(pdu, &ret, &ignored);
return ret;
}
ROUTE_IMPL(RouteSync, path, argp)
{
RouteArgs *args = argp;
Db *db = args->matrixArgs->db;
HashMap *params = NULL;
HashMap *response = NULL;
SyncResponse sync = { 0 };
Filter *filterData = NULL;
Array *invites;
Array *joins;
size_t i;
User *user = NULL;
char *token = NULL;
char *prevBatch = NULL;
char *nextBatch = NULL;
char *currBatch = NULL;
char *timeout = NULL;
char *filter = NULL;
char *err;
int timeoutDuration;
/* TODO: Respect `timeout', (and stop when something is
* pushed, maybe by 'polling' the database? sounds like
* a bad idea) */
if (HttpRequestMethodGet(args->context) != HTTP_GET)
{
err = "Unknown request method.";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_UNRECOGNIZED, err);
goto finish;
}
response = MatrixGetAccessToken(args->context, &token);
if (response)
{
goto finish;
}
user = UserAuthenticate(db, token);
if (!user)
{
HttpResponseStatus(args->context, HTTP_UNAUTHORIZED);
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
params = HttpRequestParams(args->context);
prevBatch = HashMapGet(params, "since");
timeout = HashMapGet(params, "timeout");
filter = HashMapGet(params, "filter");
timeoutDuration = timeout ? atoi(timeout) : 0;
if (filter)
{
char *userName = UserGetName(user);
if (!(filterData = FilterDecode(db, userName, filter, &err)))
{
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_BAD_JSON, err);
}
}
if (!prevBatch)
{
prevBatch = NULL;
nextBatch = UserInitSyncDiff(user);
UserFillSyncDiff(user, nextBatch);
}
else if (timeout && timeoutDuration)
{
char *name = StrDuplicate(UserGetName(user));
UserUnlock(user);
UserAwaitNotification(name, timeoutDuration);
Free(name);
user = UserAuthenticate(db, token);
}
currBatch = prevBatch ? prevBatch : nextBatch;
/* TODO: I only am manually parsing this because j2s does not support
* a hashmap of unknown keys pointing to a known type. */
sync.rooms.invite = HashMapCreate();
sync.rooms.join = HashMapCreate();
/* invites */
invites = UserGetInvites(user, currBatch);
for (i = 0; i < ArraySize(invites); i++)
{
char *roomId = ArrayGet(invites, i);
InvitedRooms *invited;
if (IsRoomFiltered(filterData, roomId))
{
continue;
}
invited = Malloc(sizeof(*invited));
memset(invited, 0, sizeof(*invited));
/* TODO: Populate the invitestate */
invited->invite_state.events = ArrayCreate();
HashMapSet(sync.rooms.invite, roomId, invited);
}
UserFreeList(invites);
/* Joins */
joins = UserGetJoins(user, currBatch);
for (i = 0; i < ArraySize(joins); i++)
{
/* TODO: Rename these variables */
char *roomId = ArrayGet(joins, i);
JoinedRooms *joined;
char *firstEvent = NULL;
char *type, *key, *id;
State *state;
Array *el;
size_t j;
Room *r;
if (IsRoomFiltered(filterData, roomId))
{
continue;
}
joined = Malloc(sizeof(*joined));
memset(joined, 0, sizeof(*joined));
el = UserGetEvents(user, currBatch, roomId);
r = RoomLock(db, roomId);
state = StateCurrent(r);
joined->timeline.events = ArrayCreate();
for (j = 0; j < ArraySize(el); j++)
{
char *event = ArrayGet(el, j);
HashMap *eventObj = RoomEventFetch(r, event);
HashMap *filteredObj = FilterApply(filterData, eventObj);
if (filteredObj)
{
ClientEventWithoutRoomID rc = ClientfyEventSync(filteredObj);
ClientEventWithoutRoomID *c = Malloc(sizeof(*c));
memcpy(c, &rc, sizeof(*c));
if (!firstEvent)
{
firstEvent = c->event_id;
}
ArrayAdd(joined->timeline.events, c);
}
JsonFree(eventObj);
JsonFree(filteredObj);
}
joined->timeline.prev_batch = UserNewMessageToken(
user, roomId, firstEvent
);
/* TODO: Don't shove the entire state.
* That's a recipe for disaster, especially on large rooms. */
joined->state.events = ArrayCreate();
while (StateIterate(state, &type, &key, (void **) &id))
{
HashMap *e = RoomEventFetch(r, id);
StrippedStateEvent rs = StripStateEventSync(e);
StrippedStateEvent *s = Malloc(sizeof(*s));
memcpy(s, &rs, sizeof(*s));
JsonFree(e);
ArrayAdd(joined->state.events, s);
Free(type);
Free(key);
}
StateFree(state);
RoomUnlock(r);
UserFreeList(el);
HashMapSet(sync.rooms.join, roomId, joined);
}
UserFreeList(joins);
if (prevBatch)
{
UserDropSync(user, prevBatch);
nextBatch = UserInitSyncDiff(user);
UserFillSyncDiff(user, nextBatch);
}
sync.next_batch = nextBatch;
response = SyncResponseToJson(&sync);
SyncResponseFree(&sync);
finish:
FilterDestroy(filterData);
UserUnlock(user);
(void) path;
return response;
}

47
src/Routes/RouteUserProfile.c
View file

@ -28,52 +28,10 @@
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <User.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <Config.h>
#include <User.h>
#include <Room.h>
static void
SendMembership(Db *db, User *user)
{
char *displayname = UserGetProfile(user, "displayname");
char *avatar_url = UserGetProfile(user, "avatar_url");
Array *joins = UserListJoins(user);
size_t i;
char *server_name = ConfigGetServerName(db);
CommonID *user_id = UserIdParse(UserGetName(user), server_name);
char *sender = ParserRecomposeCommonID(*user_id);
Free(server_name);
for (i = 0; i < ArraySize(joins); i++)
{
char *room_id = ArrayGet(joins, i);
Room *room = RoomLock(db, room_id);
HashMap *content = HashMapCreate();
HashMap *membership = RoomEventCreate(
sender, "m.room.member", sender,
content
);
HashMapSet(content, "membership", JsonValueString("join"));
HashMapSet(content, "displayname", JsonValueString(displayname));
HashMapSet(content, "avatar_url", JsonValueString(avatar_url));
JsonFree(RoomEventSend(room, membership, NULL));
JsonFree(membership);
RoomUnlock(room);
}
UserFreeList(joins);
UserIdFree(user_id);
Free(sender);
}
ROUTE_IMPL(RouteUserProfile, path, argp)
{
RouteArgs *args = argp;
@ -184,8 +142,6 @@ ROUTE_IMPL(RouteUserProfile, path, argp)
response = MatrixErrorCreate(M_UNKNOWN_TOKEN, NULL);
goto finish;
}
/* TODO: This may change in the future. */
entry = ArrayGet(path, 1);
if (StrEquals(entry, "displayname") ||
StrEquals(entry, "avatar_url"))
@ -197,7 +153,6 @@ ROUTE_IMPL(RouteUserProfile, path, argp)
/* TODO: Make UserSetProfile notify other parties of
* the change */
UserSetProfile(user, entry, value);
SendMembership(db, user);
response = HashMapCreate();
goto finish;
}

3
src/Routes/RouteVersions.c
View file

@ -37,9 +37,6 @@ ROUTE_IMPL(RouteVersions, path, argp)
(void) argp;
#define DECLARE_SPEC_VERSION(x) ArrayAdd(versions, JsonValueString(x))
DECLARE_SPEC_VERSION("v1.0");
DECLARE_SPEC_VERSION("v1.1");
DECLARE_SPEC_VERSION("v1.2");
DECLARE_SPEC_VERSION("v1.3");
DECLARE_SPEC_VERSION("v1.4");

546
src/State.c
View file

@ -26,326 +26,26 @@
#include <State.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Base64.h>
#include <Cytoplasm/Array.h>
#include <Cytoplasm/Str.h>
#include <Cytoplasm/Sha.h>
#include <string.h>
#include <Event.h>
#include <Room.h>
#include <Event.h>
struct State {
/* A hashmap of event IDs for a state */
HashMap *table;
};
static State *
InitialiseState(void)
static HashMap *
StateResolveV1(Array * states)
{
State *ret = Malloc(sizeof(*ret));
ret->table = HashMapCreate();
return ret;
(void) states;
return NULL;
}
int
V1Cmp(void *a, void *b)
{
HashMap *e1 = a, *e2 = b;
int64_t depth1, depth2;
depth1 =
JsonValueAsInteger(JsonGet(e1, 1, "depth"));
depth2 =
JsonValueAsInteger(JsonGet(e2, 1, "depth"));
if (depth1 > depth2)
{
return 1;
}
else if (depth1 < depth2)
{
return -1;
}
else
{
char *e1id =
JsonValueAsString(JsonGet(e1, 1, "event_id"));
char *e2id =
JsonValueAsString(JsonGet(e2, 1, "event_id"));
/* Matrix, *seriously*? */
unsigned char *sha1 = Sha1(e1id);
unsigned char *sha2 = Sha1(e2id);
char *str1 = ShaToHex(sha1, HASH_SHA1);
char *str2 = ShaToHex(sha2, HASH_SHA1);
int ret = strcmp(str1, str2) * -1;
Free(str1);
Free(str2);
Free(sha1);
Free(sha2);
/* Descending */
return ret;
}
}
static char *
EncodeStateTuple(char *type, char *stateKey)
{
size_t typeLen = type ? strlen(type) : 0;
size_t stateKeyLen = stateKey ? strlen(stateKey) : 0;
size_t length = typeLen + 1 + stateKeyLen + 1;
char *tuple = Malloc(length);
char *base64;
memset(tuple, '\0', length);
memcpy(tuple, type, typeLen);
memcpy(tuple + typeLen + 1, stateKey, stateKeyLen);
base64 = Base64Encode((const char *) tuple, length);
Free(tuple);
return base64;
}
static void
DecodeStateTuple(char *base64, char **key, char **val)
{
size_t base64Size = base64 ? strlen(base64) : 0;
char *decodeBuffer = NULL;
if (!base64 || !key || !val)
{
return;
}
decodeBuffer = Base64Decode((const char *) base64, base64Size);
*key = StrDuplicate(decodeBuffer);
*val = StrDuplicate(decodeBuffer + strlen(decodeBuffer) + 1);
Free(decodeBuffer);
}
static void
BuildBaseAndConflictV1(Room *room, Array *states, State *R, HashMap *conflicts)
{
size_t i;
char *type = NULL, *key = NULL;
for (i = 0; i < ArraySize(states); i++)
{
char *event_id;
State *state = ArrayGet(states, i);
while (StateIterate(state, &type, &key, (void **) &event_id))
{
char *tuple = EncodeStateTuple(type, key);
if (StateGet(R, type, key) || HashMapGet(conflicts, tuple))
{
Array *arr;
HashMap *hm;
/* Conflicts! */
StateSet(R, type, key, NULL);
arr = HashMapGet(conflicts, tuple);
if (!arr)
{
arr = ArrayCreate();
}
hm = RoomEventFetch(room, event_id);
ArrayAdd(arr, hm);
HashMapSet(conflicts, tuple, arr);
}
else
{
/* Add to R */
StateSet(R, type, key, event_id);
}
Free(tuple);
Free(type);
Free(key);
}
}
}
static void
FixoutConflictV1(char *t, Room *room, State *R, HashMap *conflicts)
{
HashMap *first;
Array *state_keys, *conflicting, *events;
char *tuple;
size_t i;
events = ArrayCreate();
while (HashMapIterate(conflicts, &tuple, (void **) &conflicting))
{
char *type, *key;
DecodeStateTuple(tuple, &type, &key);
if (StrEquals(type, t))
{
for (i = 0; i < ArraySize(conflicting); i++)
{
HashMap *event = ArrayGet(conflicting, i);
ArrayAdd(events, event);
}
}
Free(type);
Free(key);
}
ArraySort(events, V1Cmp);
/* Add first event. */
first = ArrayDelete(events, 0);
StateSet(
R,
JsonValueAsString(JsonGet(first, 1, "type")),
JsonValueAsString(JsonGet(first, 1, "state_key")),
JsonValueAsString(JsonGet(first, 1, "event_id"))
);
JsonFree(first);
for (i = 0; i < ArraySize(events); i++)
{
HashMap *event = ArrayGet(events, i);
PduV1 pdu;
char *msg;
PduV1FromJson(event, &pdu, &msg);
if (RoomAuthoriseEventV1(room, pdu, R, NULL))
{
StateSet(R, pdu.type, pdu.state_key, pdu.event_id);
}
else
{
PduV1Free(&pdu);
JsonFree(event);
break;
}
(void) msg;
PduV1Free(&pdu);
JsonFree(event);
}
ArrayFree(events);
state_keys = ArrayCreate();
while (HashMapIterate(conflicts, &tuple, (void **) &conflicting))
{
char *type, *key;
DecodeStateTuple(tuple, &type, &key);
if (StrEquals(type, t))
{
ArrayAdd(state_keys, key);
}
else
{
Free(key);
}
Free(type);
}
for (i = 0; i < ArraySize(state_keys); i++)
{
char *state_key = ArrayGet(state_keys, i);
char *tuple = EncodeStateTuple(t, state_key);
Array *conflict = HashMapDelete(conflicts, tuple);
/* All of the other values are already freed */
ArrayFree(conflict);
Free(state_key);
Free(tuple);
}
ArrayFree(state_keys);
}
static State *
StateResolveV1(Room * room, Array * states)
{
State *R = InitialiseState();
HashMap *conflicts = HashMapCreate();
Array *events = NULL, *conflicting = NULL;
char *type, *key, *tuple;
BuildBaseAndConflictV1(room, states, R, conflicts);
/* R and conflicts are now configured */
FixoutConflictV1("m.room.power_levels", room, R, conflicts);
FixoutConflictV1("m.room.join_rules", room, R, conflicts);
FixoutConflictV1("m.room.member", room, R, conflicts);
while (HashMapIterate(conflicts, &tuple, (void **) &conflicting))
{
ssize_t i;
DecodeStateTuple(tuple, &type, &key);
ArraySort(conflicting, V1Cmp);
for (i = ArraySize(conflicting) - 1; i >= 0; i--)
{
HashMap *event = ArrayGet(events, i);
PduV1 pdu = { 0 };
char *msg;
if (!PduV1FromJson(event, &pdu, &msg))
{
continue;
}
if (RoomAuthoriseEventV1(room, pdu, R, NULL))
{
StateSet(R, pdu.type, pdu.state_key, pdu.event_id);
PduV1Free(&pdu);
break;
}
(void) msg;
PduV1Free(&pdu);
}
Free(type);
Free(key);
}
while (HashMapIterate(conflicts, &tuple, (void **) &conflicting))
{
size_t i;
for (i = 0; i < ArraySize(conflicting); i++)
{
JsonFree(ArrayGet(conflicting, i));
}
ArrayFree(conflicting);
}
HashMapFree(conflicts);
return R;
}
static State *
static HashMap *
StateResolveV2(Array * states)
{
(void) states;
return NULL;
}
static State *
StateFromPrevs(Room *room, Array *states)
{
switch (RoomVersionGet(room))
{
case 1:
return StateResolveV1(room, states);
default:
return StateResolveV2(states);
}
}
static bool
IsRejected(HashMap *pdu)
{
JsonValue *val = JsonGet(pdu, 2, "unsigned", "status");
return StrEquals(JsonValueAsString(val), "rejected");
}
State *
HashMap *
StateResolve(Room * room, HashMap * event)
{
Array *states;
@ -353,246 +53,36 @@ StateResolve(Room * room, HashMap * event)
Array *prevEvents;
State *ret_state;
char *room_id, *event_id;
Db *db;
if (!room || !event)
{
return NULL;
}
db = RoomGetDB(room);
room_id = JsonValueAsString(HashMapGet(event, "room_id"));
event_id = JsonValueAsString(HashMapGet(event, "event_id"));
if (DbExists(db, 4, "rooms", room_id, "state", event_id))
{
DbRef *ref = DbLock(db, 4,
"rooms", room_id, "state", event_id
);
ret_state = StateDeserialise(DbJson(ref));
DbUnlock(db, ref);
if (ret_state)
{
return ret_state;
}
/* If a DB error stops us from getting an existing state,
* recompute it. */
}
/* TODO: Return cached state if it exists */
states = ArrayCreate();
if (!states)
{
return NULL;
}
prevEvents = JsonValueAsArray(HashMapGet(event, "prev_events"));
prevEvents = HashMapGet(event, "prev_events");
for (i = 0; i < ArraySize(prevEvents); i++)
{
HashMap *prevEvent =
RoomEventFetch(room, JsonValueAsString(ArrayGet(prevEvents, i)));
State *state = StateResolve(room, prevEvent);
HashMap *prevEvent = ArrayGet(prevEvents, i);
HashMap *state = StateResolve(room, prevEvent);
if (HashMapGet(prevEvent, "state_key") && !IsRejected(prevEvent))
{
StateSet(
state,
JsonValueAsString(HashMapGet(prevEvent, "type")),
JsonValueAsString(HashMapGet(prevEvent, "state_key")),
JsonValueAsString(HashMapGet(prevEvent, "event_id"))
);
}
ArrayAdd(states, state);
JsonFree(prevEvent);
}
ret_state = StateFromPrevs(room, states);
for (i = 0; i < ArraySize(states); i++)
{
State *state = ArrayGet(states, i);
StateFree(state);
}
ArrayFree(states);
if (ret_state)
{
HashMap *json = StateSerialise(ret_state);
DbRef *ref = DbCreate(db, 4, "rooms", room_id, "state", event_id);
DbJsonSet(ref, json);
JsonFree(json);
DbUnlock(db, ref);
}
return ret_state;
}
State *
StateCurrent(Room *room)
{
Array *prevEvents;
Array *states;
size_t i;
State *ret;
if (!room)
{
return NULL;
}
prevEvents = RoomPrevEventsGet(room);
states = ArrayCreate();
for (i = 0; i < ArraySize(prevEvents); i++)
{
HashMap *event =
JsonValueAsObject(ArrayGet(prevEvents, i));
State *state = StateResolve(room, event);
if (HashMapGet(event, "state_key") && !IsRejected(event))
{
StateSet(
state,
JsonValueAsString(HashMapGet(event, "type")),
JsonValueAsString(HashMapGet(event, "state_key")),
JsonValueAsString(HashMapGet(event, "event_id"))
);
}
/* TODO: Apply prevEvent to state if it is a state event */
ArrayAdd(states, state);
}
ret = StateFromPrevs(room, states);
for (i = 0; i < ArraySize(states); i++)
switch (RoomVersionGet(room))
{
State *state = ArrayGet(states, i);
StateFree(state);
case 1:
return StateResolveV1(states);
default:
return StateResolveV2(states);
}
ArrayFree(states);
return ret;
}
bool
StateIterate(State *state, char **type, char **key, void **event)
{
bool ret;
char *tuple;
if (!state || !type || !key || !event)
{
return false;
}
ret = HashMapIterate(state->table, &tuple, event);
if (ret)
{
DecodeStateTuple(tuple, type, key);
}
return ret;
}
char *
StateGet(State *state, char *type, char *key)
{
char *tableKey;
char *ret;
if (!state || !type || !key)
{
return NULL;
}
tableKey = EncodeStateTuple(type, key);
ret = HashMapGet(state->table, tableKey);
Free(tableKey);
return ret;
}
void
StateSet(State *state, char *type, char *key, char *event)
{
char *tableKey;
if (!state || !type || !key)
{
return;
}
tableKey = EncodeStateTuple(type, key);
Free(HashMapDelete(state->table, tableKey));
if (event)
{
HashMapSet(state->table, tableKey, StrDuplicate(event));
}
Free(tableKey);
}
void
StateFree(State *state)
{
char *tuple;
char *eventID;
if (!state)
{
return;
}
while (HashMapIterate(state->table, &tuple, (void **) &eventID))
{
Free(eventID);
}
HashMapFree(state->table);
Free(state);
}
State *
StateDeserialise(HashMap *json_state)
{
State *raw_state;
char *state_type;
JsonValue *state_keys;
if (!json_state)
{
return NULL;
}
raw_state = InitialiseState();
while (HashMapIterate(json_state, &state_type, (void **) &state_keys))
{
HashMap *state_keys_obj = JsonValueAsObject(state_keys);
char *state_key;
JsonValue *event_id;
while (HashMapIterate(state_keys_obj, &state_key, (void **) &event_id))
{
char *eid_string = JsonValueAsString(event_id);
StateSet(raw_state, state_type, state_key, eid_string);
}
}
return raw_state;
}
HashMap *
StateSerialise(State *rawState)
{
HashMap *returned;
char *type, *key, *event;
if (!rawState)
{
return NULL;
}
returned = HashMapCreate();
while (StateIterate(rawState, &type, &key, (void **) &event))
{
JsonSet(returned, JsonValueString(event), 2, type, key);
Free(type);
Free(key);
}
return returned;
}

10
src/Uia.c
View file

@ -312,16 +312,14 @@ UiaComplete(Array * flows, HttpServerContext * context, Db * db,
}
}
/* TODO: The type may sometimes be omitted. This means it is implied
* from context. */
val = HashMapGet(auth, "type");
if (!val || JsonValueType(val) != JSON_STRING)
{
/* TODO: Clients may want to retrieve the flowlist.
* Still stupid, but eh. */
HttpResponseStatus(context, HTTP_UNAUTHORIZED);
ret = BuildResponse(flows, db, response, session, dbRef);
msg = "'auth->type' is unset or not a string.";
HttpResponseStatus(context, HTTP_BAD_REQUEST);
*response = MatrixErrorCreate(M_BAD_JSON, msg);
ret = 0;
goto finish;
}

1075
src/User.c
View file

File diff suppressed because it is too large Load diff

10
src/include/CanonicalJson.h
View file

@ -79,16 +79,6 @@
*/
extern int CanonicalJsonEncode(HashMap *, Stream *);
/**
* Computes a JSON object encoded as Canonical JSON's SHA-256
* hash.
*
* This function returns a SHA-256 hexstream stored on the heap,
* which will need to be freed with
* .Fn Free .
*/
extern unsigned char * CanonicalJsonHash(HashMap *);
/**
* Encode a JSON value following the rules of Canonical JSON.
* See the documentation for

10
src/include/Config.h
View file

@ -98,16 +98,6 @@ extern void ConfigLock(Db *, Config *);
*/
extern int ConfigUnlock(Config *);
/**
* Returns the configuration's server name from a database.
* This is an utility function that masks behind
* .Fn ConfigLock ,
* and the value returned lives on the heap, and must be freed
* with
* .Fn Free .
*/
extern char * ConfigGetServerName(Db *);
/**
* Converts a ConfigLogLevel into a valid syslog level.
*/

19
src/include/Filter.h
View file

@ -28,7 +28,6 @@
#include <Schema/Filter.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Db.h>
/***
* @Nm Filter
@ -48,22 +47,4 @@
extern HashMap *
FilterApply(Filter *, HashMap *);
/**
* Verifies if a room would be filtered out by a filter given in.
*/
extern bool IsRoomFiltered(Filter *, char *);
/**
* Decodes a filter from a JSON stream to decode or an ID that was
* registered using the filter API, and may return an optional error
* string, if not set to NULL.
*/
extern Filter * FilterDecode(Db *, char *, char *, char **);
/**
* Frees all memory created by
* .Fn FilterDecode .
*/
extern void FilterDestroy(Filter *);
#endif /* TELODENDRIA_FILTER_H */

18
src/include/Matrix.h
View file

@ -39,9 +39,8 @@
#include <Cytoplasm/HttpServer.h>
#include <Cytoplasm/HttpRouter.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Log.h>
#include <Cytoplasm/HashMap.h>
#include <Config.h>
#include <Cytoplasm/Db.h>
@ -155,19 +154,4 @@ extern HashMap * MatrixRateLimit(HttpServerContext *, Db *);
*/
extern HashMap * MatrixClientWellKnown(char *, char *);
/**
* Decodes a dot-separated path (as defined by the Specification) and
* tries to retrieve it from a JSON object hashmap, failing with NULL
* if it cannot be found, like Cytoplasm's
* .Fn JsonGet .
*/
extern JsonValue * MatrixGetJSON(HashMap *, char *);
/**
* Sets a value given a dot-separated path (see
* .Fn MatrixGetJSON
* for more information).
*/
extern JsonValue * MatrixSetJSON(HashMap *, char *, JsonValue *);
#endif

141
src/include/Room.h
View file

@ -41,23 +41,17 @@
#include <Cytoplasm/Db.h>
#include <Schema/RoomCreateRequest.h>
#include <Schema/PduV1.h>
#include <Parser.h>
#include <User.h>
/**
* The functions in this API operate on an opaque structure.
*/
typedef struct Room Room;
#include <State.h>
/**
* Create a new room in the given database using the given
* RoomCreateRequest.
*/
extern Room * RoomCreate(Db *, User *, RoomCreateRequest *, ServerPart);
extern Room * RoomCreate(Db *, RoomCreateRequest *);
/**
* Lock the existing room in the specified database,
@ -69,11 +63,6 @@ extern Room * RoomCreate(Db *, User *, RoomCreateRequest *, ServerPart);
*/
extern Room * RoomLock(Db *, char *);
/**
* Returns the database structure a room is tied to.
*/
extern Db * RoomGetDB(Room *);
/**
* Unlock a room handle, returning it to the database.
* This function returns the result of calling
@ -106,14 +95,7 @@ extern int RoomVersionGet(Room *);
* which is used to select auth events on incoming
* client events.
*/
extern State * RoomStateGet(Room *);
/**
* Resolves the room's state before a specific point,
* (with the event hashmap taking priority),
* like
* .Fn RoomStateGet .
*/
extern State * RoomStateGetID(Room *, char *);
extern HashMap * RoomStateGet(Room *);
/**
* Get a list of the most recent events in the
@ -144,123 +126,6 @@ extern int RoomPrevEventsSet(Room *, Array *);
* the room version, which includes setting the
* prev_events and auth_events fields correctly.
*/
extern HashMap * RoomEventSend(Room *, HashMap *, char **);
/**
* Sends an invite to a user in a room, and tries
* to notify such user of it.
*/
extern void RoomSendInvite(User *, bool, char *, Room *);
/**
* See if a user is allowed to see an event in a room,
* based on its visibility.
*/
extern bool RoomIsEventVisible(Room *, User *, char *);
/**
* Fetch a single event's PDU in a room into an
* hashmap, given an event ID, from the database
* if possible, or otherwise fetched from a remote
* homeserver participating in the room.
*/
extern HashMap * RoomEventFetch(Room *, char *);
/**
* Strips all the fields not required in a
* Matrix ClientEvent from a PDU object.
*/
extern HashMap * RoomEventClientify(HashMap *);
/**
* Verifies whenever an event(as a PDUv1) is
* authorised by a room.
*/
extern bool RoomAuthoriseEventV1(Room *, PduV1, State *, char **);
/**
* Gets the room's creator as a ServerPart. This value should
* not be freed, as it lives alongside the room itself
*/
extern ServerPart RoomGetCreator(Room *);
/**
* Puts a PDUv1 into the event list, while updating the leaf
* list.
*/
extern bool RoomAddEventV1(Room *, PduV1, PduV1Status);
/**
* Creates a barebones JSON object to be sent to
* .Fn RoomEventFetch .
*/
extern HashMap * RoomEventCreate(char *, char *, char *, HashMap *);
/**
* Computes an approximation of the PDU depth by looking at
* the leaves stored in the room data.
*/
extern uint64_t RoomGetDepth(Room *);
/**
* Tries to find an alias from room alias to an ID stored
* on the heap, or NULL if it does not exist.
*/
extern char * RoomResolveAlias(Db *, char *);
/**
* Tries to resolve a list of aliases from a room ID into
* an array of strings stored on the heap.
*/
extern Array * RoomReverseAlias(Db *, char *);
/**
* Frees the array returned by
* .Fn RoomReverseAlias .
*/
extern void RoomFreeReverse(Array *);
/**
* Checks whenever a room contains a specific user.
*/
extern bool RoomContainsUser(Room *, char *);
/**
* Checks whenever an user can join a specific room,
* given it's permissions.
*/
extern bool RoomCanJoin(Room *, char *);
/**
* Makes a local user redact an event(from it's ID).
*/
extern char * RoomRedact(Room *, User *, char *, char *, char **);
/**
* Makes a local user join a room, and returns true if
* the room was joined.
*/
extern bool RoomJoin(Room *, User *, char **);
/**
* Makes a local user leave a room, and returns true if
* the room was left.
*/
extern bool RoomLeave(Room *, User *, char **);
/**
* Adds or overwrites a room alias.
*/
extern void RoomAddAlias(Db *, char *, char *, char *, char *);
/**
* Checks if a PDU has been qualified as 'soft-failed'.
*/
extern bool RoomIsSoftfailedV1(PduV1);
/**
* Checks if a PDU has been qualified as 'rejected'.
*/
extern bool RoomIsRejectedV1(PduV1);
extern HashMap * RoomEventSend(Room *, HashMap *);
#endif /* TELODENDRIA_ROOM_H */

12
src/include/Routes.h
View file

@ -101,16 +101,6 @@ ROUTE(RouteConfig);
ROUTE(RoutePrivileges);
ROUTE(RouteCreateRoom);
ROUTE(RouteSendEvent);
ROUTE(RouteRedact);
ROUTE(RouteSendState);
ROUTE(RouteJoinRoom);
ROUTE(RouteKickRoom);
ROUTE(RouteJoinRoomAlias);
ROUTE(RouteFetchEvent);
ROUTE(RouteJoinedRooms);
ROUTE(RouteSync);
ROUTE(RouteMessages);
ROUTE(RouteAliasDirectory);
ROUTE(RouteRoomAliases);
@ -119,8 +109,6 @@ ROUTE(RouteAdminDeactivate);
ROUTE(RouteAdminTokens);
ROUTE(RouteKeyQuery);
ROUTE(RoutePushrules);
#undef ROUTE
#endif

45
src/include/State.h
View file

@ -37,60 +37,21 @@
#include <Cytoplasm/HashMap.h>
/**
* An opaque structure to hold information about the state.
*/
typedef struct State State;
#include <Room.h>
/**
* Retrieve the value of a state tuple.
*/
extern char *StateGet(State *, char *, char *);
extern char *StateGet(HashMap *, char *, char *);
/**
* Set a state tuple to a value.
*/
extern void StateSet(State *, char *, char *, char *);
/**
* Iterates through a statemap, with (type, key) -> event.
* The type and keys are stored on the heap, and will need
* to be freed.
* This function behaves like
* .Fn HashMapIterate .
*/
extern bool StateIterate(State *, char **, char **, void **);
extern char *StateSet(HashMap *, char *, char *, char *);
/**
* Compute the room state before the specified event was sent.
*/
extern State * StateResolve(Room *, HashMap *);
/**
* Computes the current state from the room's leaves.
*/
extern State * StateCurrent(Room *);
/**
* Frees an entire state table from the heap.
*/
extern void StateFree(State *);
/**
* Deserialises a state map from JSON to the internal format
* used by this API.
*
* The returned value is independent from the JSON format,
* and should be freed with
* .Fn StateFree .
*/
extern State * StateDeserialise(HashMap *);
/**
* Serialises a state map from the internal format to JSON
* used for the database, for example
*/
extern HashMap * StateSerialise(State *);
extern HashMap * StateResolve(Room *, HashMap *);
#endif /* TELODENDRIA_STATE_H */

184
src/include/User.h
View file

@ -66,8 +66,7 @@ typedef enum UserPrivileges
USER_GRANT_PRIVILEGES = (1 << 3),
USER_PROC_CONTROL = (1 << 4),
USER_ALIAS = (1 << 5),
USER_APPSERVICE = (1 << 6),
USER_ALL = ((1 << 7) - 1)
USER_ALL = ((1 << 6) - 1)
} UserPrivileges;
/**
@ -92,7 +91,6 @@ typedef struct UserLoginInfo
char *refreshToken;
} UserLoginInfo;
/**
* Take a localpart and domain as separate parameters and validate them
* against the rules of the Matrix specification. The reasion the
@ -136,13 +134,6 @@ extern User * UserCreate(Db *, char *, char *);
*/
extern User * UserLock(Db *, char *);
/**
* Behaves like
* .Fn UserLock ,
* but tries to check from a CommonID, and verifies
* for the serverpart. */
extern User * UserLockID(Db *, CommonID *);
/**
* Take an access token, figure out what user it belongs to, and then
* returns a reference to that user. This function should be used by
@ -312,182 +303,9 @@ extern int UserDecodePrivilege(const char *);
*/
extern CommonID * UserIdParse(char *, char *);
/**
* Gets the reply sent to the user from a transaction ID, and an opaque
* ""path"" ID, which is unique per route.
*/
extern HashMap * UserGetTransaction(User *, char *, char *);
/**
* Stores a transaction for a path with a given response JSON.
*/
extern void UserSetTransaction(User *, char *, char *, HashMap *);
/**
* Puts a room (indexed by room ID) in a user's invite list.
*/
extern void UserAddInvite(User *, char *);
/**
* Removes a room from the user's invite list.
*/
extern void UserRemoveInvite(User *, char *);
/**
* Lists all the rooms a user is invited to into an array of
* strings(room ID) to be freed by
* .Fn UserFreeInvites .
*/
extern Array * UserListInvites(User *);
/**
* Puts a room (indexed by room ID) in a user's join list.
*/
extern void UserAddJoin(User *, char *);
/**
* Removes a room from the user's join list.
*/
extern void UserRemoveJoin(User *, char *);
/**
* Lists all the rooms a user has joined into an array of
* strings(room ID) to be freed by
* .Fn UserFreeJoins .
*/
extern Array * UserListJoins(User *);
/**
* Frees a join/invite list as created by
* .Fn UserListJoins
* or
* .Fn UserListInvites .
*/
extern void UserFreeList(Array *);
/**
* Frees the user's common ID and the memory allocated for it.
*/
extern void UserIdFree(CommonID *);
/**
* Initialises a sync diff table, and returns a next_batch parameter,
* which is stored on the heap.
*/
extern char * UserInitSyncDiff(User *);
/**
* Fills a sync table with initial sync information
*/
extern void UserFillSyncDiff(User *, char *);
/**
* Pushes an invite onto all sync diff tables.
*/
extern void UserPushInviteSync(User *, char *);
/**
* Pushes a join onto all sync diff tables.
*/
extern void UserPushJoinSync(User *, char *);
/**
* Pushes an event (ID) into every diff table of a user.
*/
extern void UserPushEvent(User *, HashMap *);
/**
* Shows the invite list(as a room ID table) for an user
* and a specified diff table, to be freed by
* .Fn UserFreeList .
*/
extern Array * UserGetInvites(User *, char *);
/**
* Shows a list of rooms for an user and a specified diff
* table, to be freed by
* .Fn UserFreeList .
*/
extern Array * UserGetJoins(User *, char *);
/**
* Get a list of event IDs for a diff table(and room ID),
* to be freed by
* .Fn UserFreeList .
*/
extern Array * UserGetEvents(User *, char *, char *);
/**
* Drops a sync diff, denoted by it's previous batch ID, if it
* exists.
*/
extern void UserDropSync(User *, char *);
/**
* Verifies if the 'sync' data is considered old, and can be
* reasonably removed from the database.
*/
extern bool UserIsSyncOld(User *, char *);
/**
* Verifies if a sync diff exists.
*/
extern bool UserSyncExists(User *, char *);
/**
* Creates a new "message token" start from a room and event ID,
* given a specified direction(with false<=>'b' and true<=>'f')
* to be used by /messages.
*/
extern char * UserNewMessageToken(User *, char *, char *);
/**
* Grabs events from a message token(with the correct direction)
* into an array of HashMaps(which store PDU objects).
* If the string pointer is not NULL, this function sets its
* value to a new message token(which is stored on the heap),
* if and only if, there are any new events to retrieve.
*
* If the counter is negative, then it is treated as a 'f',
* otherwise, it is treated as 'b'.
*/
extern Array * UserFetchMessages(User *, int, char *, char **);
/**
* Deletes a "message token".
*/
extern void UserFreeMessageToken(User *, char *);
/**
* Deletes temporary data about a specific user.
*/
extern void UserCleanTemporaryData(User *);
/**
* Initialise a temporary sync table to signal any /sync changes.
* This should be paired with a call to
* .Fn UserDestroyPushTable .
*/
extern void UserInitialisePushTable(void);
/**
* Notifies the user of a sync update.
*/
extern void UserNotifyUser(User *);
/**
* Waits for a notification for a specific user for a specific
* duration in milliseconds to wait (with 30000ms being the default,
* if the value is negative), and returns true if anything came up.
*/
extern bool UserAwaitNotification(char *, int);
/**
* Destroys the temporary push table created by
* .Fn UserInitialisePushTable .
*/
extern void UserDestroyPushTable(void);
#endif /* TELODENDRIA_USER_H */