No OneTemporary
Actions

Size

45 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/room/room-model.cpp b/src/client/room/room-model.cpp
	index e32fb0f..2f50187 100644
	--- a/src/client/room/room-model.cpp
	+++ b/src/client/room/room-model.cpp
	@@ -1,559 +1,596 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2020-2023 tusooa
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/

	#include <libkazv-config.hpp>


	#include <lager/util.hpp>
	#include <zug/sequence.hpp>
	#include <zug/transducer/map.hpp>
	#include <zug/transducer/filter.hpp>

	#include "debug.hpp"

	#include "room-model.hpp"
	#include "cursorutil.hpp"
	#include "immer-utils.hpp"

	inline const auto receiptTypes = immer::flex_vector<std::string>{"m.read", "m.read.private"};

	namespace Kazv
	{
	PendingRoomKeyEvent makePendingRoomKeyEventV0(std::string txnId, Event event, immer::map<std::string, immer::flex_vector<std::string>> devices)
	{
	immer::map<std::string, immer::map<std::string, Event>> messages;
	for (auto [userId, deviceIds] : devices) {
	messages = setIn(std::move(messages), immer::map<std::string, Event>(), userId);
	for (auto deviceId : deviceIds) {
	messages = setIn(
	std::move(messages),
	event,
	userId, deviceId
	);
	}
	}
	return PendingRoomKeyEvent{txnId, messages};
	}

	bool operator==(const ReadReceipt &a, const ReadReceipt &b)
	{
	return a.eventId == b.eventId && a.timestamp == b.timestamp;
	}

	bool operator!=(const ReadReceipt &a, const ReadReceipt &b)
	{
	return !(a == b);
	}

	bool operator==(const EventReader &a, const EventReader &b)
	{
	return a.userId == b.userId && a.timestamp == b.timestamp;
	}

	bool operator!=(const EventReader &a, const EventReader &b)
	{
	return !(a == b);
	}

	RoomModel RoomModel::update(RoomModel r, Action a)
	{
	return lager::match(std::move(a))(
	[&](AddStateEventsAction a) {
	r.stateEvents = merge(std::move(r.stateEvents), a.stateEvents, keyOfState);

	// If m.room.encryption state event appears,
	// configure the room to use encryption.
	if (r.stateEvents.find(KeyOfState{"m.room.encryption", ""})) {
	auto newRoom = update(std::move(r), SetRoomEncryptionAction{});
	r = std::move(newRoom);
	}
	return r;
	},
	[&](AddToTimelineAction a) {
	auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	zug::map(keyOfTimeline), a.events);

	auto oldMessages = r.messages;
	r.messages = merge(std::move(r.messages), a.events, keyOfTimeline);
	auto exists =
	[=](auto eventId) -> bool {
	return !! oldMessages.find(eventId);
	};
	auto key =
	[=](auto eventId) {
	// sort first by timestamp, then by id
	return std::make_tuple(r.messages[eventId].originServerTs(), eventId);
	};

	auto handleRedaction =
	[&r](const auto &event) {
	if (event.type() == "m.room.redaction") {
	auto origJson = event.originalJson().get();
	if (origJson.contains("redacts") && origJson.at("redacts").is_string()) {
	auto redactedEventId = origJson.at("redacts").template get<std::string>();
	if (r.messages.find(redactedEventId)) {
	r.messages = std::move(r.messages).update(redactedEventId, [&origJson](const auto &eventToBeRedacted) {
	auto newJson = eventToBeRedacted.originalJson().get();
	newJson.merge_patch(json{
	{"unsigned", {{"redacted_because", std::move(origJson)}}},
	});
	newJson["content"] = json::object();
	return Event(newJson);
	});
	}
	}
	}
	return event;
	};

	immer::for_each(a.events, handleRedaction);

	r.timeline = sortedUniqueMerge(r.timeline, eventIds, exists, key);

	// TODO need other way to determine whether it is limited
	// in a pagination request (/messages does not have that field)
	if ((! a.limited.has_value() \|\| a.limited.value())
	&& a.prevBatch.has_value()) {
	// this sync is limited, add a Gap here
	if (!eventIds.empty()) {
	r.timelineGaps = std::move(r.timelineGaps).set(eventIds[0], a.prevBatch.value());
	}
	}

	// remove the original Gap, as it is resolved
	if (a.gapEventId.has_value()) {
	r.timelineGaps = std::move(r.timelineGaps).erase(a.gapEventId.value());
	}

	// remove all Gaps between the gapped event and the first event in this batch
	if (!eventIds.empty() && a.gapEventId.has_value()) {
	auto cmp = [=](auto a, auto b) {
	return key(a) < key(b);
	};
	auto thisBatchStart = std::equal_range(r.timeline.begin(), r.timeline.end(), eventIds[0], cmp).first;
	auto origBatchStart = std::equal_range(thisBatchStart, r.timeline.end(), a.gapEventId.value(), cmp).first;

	// Safety assert: we do not want to execute the for_each if the range is empty,
	// or it will go out of bounds.
	if (thisBatchStart.index() < origBatchStart.index()) {
	std::for_each(thisBatchStart + 1, origBatchStart,
	[&](auto eventId) {
	r.timelineGaps = std::move(r.timelineGaps).erase(eventId);
	});
	}
	}

	// remove all local echoes that are received
	for (const auto &e : a.events) {
	auto jw = e.originalJson();
	const auto &json = jw.get();
	if (json.contains("unsigned")
	&& json["unsigned"].contains("transaction_id")
	&& json["unsigned"]["transaction_id"].is_string()) {
	r = update(std::move(r), RemoveLocalEchoAction{json["unsigned"]["transaction_id"].template get<std::string>()});
	}
	}

	// calculate event relationships
	r.generateRelationships(a.events);

	+ r.addToUndecryptedEvents(a.events);
	+
	return r;
	},
	[&](AddAccountDataAction a) {
	r.accountData = merge(std::move(r.accountData), a.events, keyOfAccountData);
	return r;
	},
	[&](ChangeMembershipAction a) {
	r.membership = a.membership;
	return r;
	},
	[&](ChangeInviteStateAction a) {
	r.inviteState = merge(immer::map<KeyOfState, Event>{}, a.events, keyOfState);
	return r;
	},
	[&](AddEphemeralAction a) {
	auto processReceipt = [&](Event e) {
	const auto content = e.content().get();
	for (auto [eventId, receipts] : content.items()) {
	if (!receipts.is_object()) {
	continue;
	}
	for (auto receiptType : receiptTypes) {
	if (!(receipts.contains(receiptType)
	&& receipts[receiptType].is_object())) {
	continue;
	}

	for (auto [user, receipt]: receipts[receiptType].items()) {
	ReadReceipt readReceipt{
	eventId,
	0,
	};

	if (receipt.is_object() && receipt.contains("ts")
	&& receipt["ts"].is_number()) {
	readReceipt.timestamp = receipt["ts"].template get<Timestamp>();
	}

	// Remove old receipts
	if (r.readReceipts.count(user)) {
	auto oldReceiptEventId = r.readReceipts[user].eventId;
	if (r.eventReadUsers.count(oldReceiptEventId)) {
	auto remaining =
	intoImmer(
	immer::flex_vector<std::string>{},
	zug::filter([user=user](auto userId) {
	return userId != user;
	}),
	r.eventReadUsers[oldReceiptEventId]
	);

	if (remaining.empty()) {
	r.eventReadUsers = std::move(r.eventReadUsers).erase(oldReceiptEventId);
	} else {
	r.eventReadUsers = std::move(r.eventReadUsers).set(oldReceiptEventId, remaining);
	}
	}
	}

	// Add new receipt
	r.readReceipts = std::move(r.readReceipts).set(user, readReceipt);
	auto oldReadUsers = r.eventReadUsers[eventId];
	r.eventReadUsers = std::move(r.eventReadUsers).set(eventId, oldReadUsers.push_back(user));
	}
	}
	}
	};

	for (auto e : a.events) {
	if (e.type() == "m.receipt") {
	processReceipt(e);
	}
	}
	r.ephemeral = merge(std::move(r.ephemeral), a.events, keyOfEphemeral);
	return r;
	},
	[&](SetLocalDraftAction a) {
	r.localDraft = a.localDraft;
	return r;
	},
	[&](SetRoomEncryptionAction) {
	r.encrypted = true;
	return r;
	},
	[&](MarkMembersFullyLoadedAction) {
	r.membersFullyLoaded = true;
	return r;
	},
	[&](SetHeroIdsAction a) {
	r.heroIds = a.heroIds;
	return r;
	},
	[&](AddLocalEchoAction a) {
	auto it = std::find_if(r.localEchoes.begin(), r.localEchoes.end(), [a](const auto &desc) {
	return desc.txnId == a.localEcho.txnId;
	});
	if (it == r.localEchoes.end()) {
	r.localEchoes = std::move(r.localEchoes).push_back(a.localEcho);
	} else {
	r.localEchoes = std::move(r.localEchoes).set(it.index(), a.localEcho);
	}
	return r;
	},
	[&](RemoveLocalEchoAction a) {
	auto it = std::find_if(r.localEchoes.begin(), r.localEchoes.end(), [a](const auto &desc) {
	return desc.txnId == a.txnId;
	});
	if (it != r.localEchoes.end()) {
	r.localEchoes = std::move(r.localEchoes).erase(it.index());
	}
	return r;
	},
	[&](AddPendingRoomKeyAction a) {
	auto it = std::find_if(r.pendingRoomKeyEvents.begin(), r.pendingRoomKeyEvents.end(), [a](const auto &p) {
	return p.txnId == a.pendingRoomKeyEvent.txnId;
	});
	if (it == r.pendingRoomKeyEvents.end()) {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).push_back(a.pendingRoomKeyEvent);
	} else {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).set(it.index(), a.pendingRoomKeyEvent);
	}
	return r;
	},
	[&](RemovePendingRoomKeyAction a) {
	auto it = std::find_if(r.pendingRoomKeyEvents.begin(), r.pendingRoomKeyEvents.end(), [a](const auto &desc) {
	return desc.txnId == a.txnId;
	});
	if (it != r.pendingRoomKeyEvents.end()) {
	r.pendingRoomKeyEvents = std::move(r.pendingRoomKeyEvents).erase(it.index());
	}
	return r;
	},
	[&](UpdateJoinedMemberCountAction a) {
	r.joinedMemberCount = a.joinedMemberCount;
	return r;
	},
	[&](UpdateInvitedMemberCountAction a) {
	r.invitedMemberCount = a.invitedMemberCount;
	return r;
	}
	);
	}

	RoomListModel RoomListModel::update(RoomListModel l, Action a)
	{
	return lager::match(std::move(a))(
	[&](UpdateRoomAction a) {
	l.rooms = std::move(l.rooms)
	.update(a.roomId,
	[=](RoomModel oldRoom) {
	oldRoom.roomId = a.roomId; // in case it is a new room
	return RoomModel::update(std::move(oldRoom), a.roomAction);
	});
	return l;
	}
	);
	}

	static auto membershipTransducer(const std::string &membership)
	{
	return zug::filter([](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s;
	})
	\| zug::map([](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return std::pair<std::string, Kazv::Event>{stateKey, v};
	})
	\| zug::filter([&membership](auto val) {
	auto [stateKey, ev] = val;
	return ev.content().get()
	.at("membership"s) == membership;
	});
	}

	static auto memberIdsByMembership(immer::map<KeyOfState, Event> stateEvents, const std::string &membership)
	{
	return intoImmer(
	immer::flex_vector<std::string>{},
	membershipTransducer(membership)
	\| zug::map([](auto val) {
	auto [stateKey, ev] = val;
	return stateKey;
	}),
	stateEvents);
	}

	auto memberEventsByMembership(immer::map<KeyOfState, Event> stateEvents, const std::string &membership)
	{
	return intoImmer(
	EventList{},
	membershipTransducer(membership)
	\| zug::map([](auto val) {
	auto [stateKey, ev] = val;
	return ev;
	}),
	stateEvents);
	}

	immer::flex_vector<std::string> RoomModel::joinedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "join"s);
	}

	immer::flex_vector<std::string> RoomModel::invitedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "invite"s);
	}

	immer::flex_vector<std::string> RoomModel::knockedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "knock"s);
	}

	immer::flex_vector<std::string> RoomModel::leftMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "leave"s);
	}

	immer::flex_vector<std::string> RoomModel::bannedMemberIds() const
	{
	return memberIdsByMembership(stateEvents, "ban"s);
	}

	EventList RoomModel::joinedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "join"s);
	}

	EventList RoomModel::invitedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "invite"s);
	}

	EventList RoomModel::knockedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "knock"s);
	}

	EventList RoomModel::leftMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "leave"s);
	}

	EventList RoomModel::bannedMemberEvents() const
	{
	return memberEventsByMembership(stateEvents, "ban"s);
	}

	EventList RoomModel::heroMemberEvents() const
	{
	return intoImmer(
	EventList{},
	zug::filter([heroIds=heroIds](auto val) {
	auto [k, ev] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s &&
	std::find(heroIds.begin(), heroIds.end(), stateKey) != heroIds.end();
	})
	\| zug::map([](auto val) {
	auto [_, ev] = val;
	return ev;
	}),
	stateEvents);
	}

	static Timestamp defaultRotateMs = 604800000;
	static int defaultRotateMsgs = 100;

	MegOlmSessionRotateDesc RoomModel::sessionRotateDesc() const
	{
	auto k = KeyOfState{"m.room.encryption", ""};
	auto content = stateEvents[k].content().get();
	auto ms = content.contains("rotation_period_ms")
	? content["rotation_period_ms"].get<Timestamp>()
	: defaultRotateMs;
	auto msgs = content.contains("rotation_period_msgs")
	? content["rotation_period_msgs"].get<int>()
	: defaultRotateMsgs;
	return MegOlmSessionRotateDesc{ ms, msgs };
	}

	bool RoomModel::hasUser(std::string userId) const
	{
	try {
	auto ev = stateEvents.at(KeyOfState{"m.room.member", userId});
	if (ev.content().get().at("membership") == "join") {
	return true;
	}
	} catch (const std::exception &) {
	return false;
	}
	return false;
	}

	std::optional<LocalEchoDesc> RoomModel::getLocalEchoByTxnId(std::string txnId) const
	{
	auto it = std::find_if(localEchoes.begin(), localEchoes.end(), [txnId](const auto &desc) {
	return txnId == desc.txnId;
	});
	if (it != localEchoes.end()) {
	return *it;
	} else {
	return std::nullopt;
	}
	}

	std::optional<PendingRoomKeyEvent> RoomModel::getPendingRoomKeyEventByTxnId(std::string txnId) const
	{
	auto it = std::find_if(pendingRoomKeyEvents.begin(), pendingRoomKeyEvents.end(), [txnId](const auto &desc) {
	return txnId == desc.txnId;
	});
	if (it != pendingRoomKeyEvents.end()) {
	return *it;
	} else {
	return std::nullopt;
	}
	}

	static double getTagOrder(const json &tag)
	{
	// https://spec.matrix.org/v1.7/client-server-api/#events-12
	// If a room has a tag without an order key then it should appear after the rooms with that tag that have an order key.
	return tag.contains("order") && tag["order"].is_number()
	? tag["order"].template get<double>()
	: ROOM_TAG_DEFAULT_ORDER;
	}

	immer::map<std::string, double> RoomModel::tags() const
	{
	auto content = accountData["m.tag"].content().get();
	if (!content.contains("tags") \|\| !content["tags"].is_object()) {
	return {};
	}

	auto tagsObject = content["tags"];
	auto tagsItems = tagsObject.items();
	return std::accumulate(tagsItems.begin(), tagsItems.end(), immer::map<std::string, double>(),
	[=](auto acc, const auto &cur) {
	auto [id, tag] = cur;
	return std::move(acc).set(id, getTagOrder(tag));
	}
	);
	}

	static auto normalizeTagEventJson(Event e)
	{
	auto content = e.content().get();
	if (!content.contains("tags") \|\| !content["tags"].is_object()) {
	content["tags"] = json::object();
	}
	return json{
	{"content", content},
	{"type", "m.tag"},
	};
	}

	Event RoomModel::makeAddTagEvent(std::string tagId, std::optional<double> order) const
	{
	auto eventJson = normalizeTagEventJson(accountData["m.tag"]);
	auto tag = json::object();
	if (order.has_value()) {
	tag["order"] = order.value();
	}

	eventJson["content"]["tags"][tagId] = tag;
	return Event(eventJson);
	}

	Event RoomModel::makeRemoveTagEvent(std::string tagId) const
	{
	auto eventJson = normalizeTagEventJson(accountData["m.tag"]);
	eventJson["content"]["tags"].erase(tagId);
	return Event(eventJson);
	}

	void RoomModel::generateRelationships(EventList newEvents)
	{
	for (const auto &event: newEvents) {
	auto [relType, eventId] = event.relationship();
	if (!relType.empty()) {
	reverseEventRelationships = updateIn(std::move(reverseEventRelationships), [event](auto &&evs) {
	return evs.push_back(event.id());
	}, eventId, relType);
	}
	}
	}

	void RoomModel::regenerateRelationships()
	{
	generateRelationships(intoImmer(EventList{}, zug::map([](const auto &kv) {
	return kv.second;
	}), messages));
	}
	+
	+ void RoomModel::addToUndecryptedEvents(EventList newEvents)
	+ {
	+ if (!encrypted) {
	+ return;
	+ }
	+
	+ for (auto event : newEvents) {
	+ if (event.encrypted() && !event.decrypted()) {
	+ auto original = event.originalJson();
	+ const auto &o = original.get();
	+ if (o.contains("content")
	+ && o["content"].contains("session_id")
	+ && o["content"]["session_id"].is_string()
	+ ) {
	+ auto sessionId = o["content"]["session_id"].template get<std::string>();
	+ undecryptedEvents = std::move(undecryptedEvents)
	+ .update(sessionId, [id=event.id()](const auto &v) {
	+ return v.push_back(id);
	+ });
	+ }
	+ }
	+ }
	+ }
	+
	+ void RoomModel::recalculateUndecryptedEvents()
	+ {
	+ if (!encrypted) {
	+ return;
	+ }
	+
	+ addToUndecryptedEvents(intoImmer(EventList{}, zug::map([](const auto &kv) {
	+ return kv.second;
	+ }), messages));
	+ }
	}
	diff --git a/src/client/room/room-model.hpp b/src/client/room/room-model.hpp
	index c6d3aa7..8dd9d05 100644
	--- a/src/client/room/room-model.hpp
	+++ b/src/client/room/room-model.hpp
	@@ -1,417 +1,441 @@
	/*
	* This file is part of libkazv.
	* SPDX-FileCopyrightText: 2021-2023 tusooa <tusooa@kazv.moe>
	* SPDX-License-Identifier: AGPL-3.0-or-later
	*/


	#pragma once
	#include <libkazv-config.hpp>

	#include <string>
	#include <variant>
	#include <immer/flex_vector.hpp>
	#include <immer/map.hpp>

	#include <serialization/immer-flex-vector.hpp>
	#include <serialization/immer-box.hpp>
	#include <serialization/immer-map.hpp>
	#include <serialization/immer-array.hpp>

	#include <csapi/sync.hpp>
	#include <event.hpp>

	#include <crypto.hpp>

	#include "local-echo.hpp"
	#include "clientutil.hpp"

	namespace Kazv
	{
	struct PendingRoomKeyEvent
	{
	std::string txnId;
	immer::map<std::string, immer::map<std::string, Event>> messages;
	};

	PendingRoomKeyEvent makePendingRoomKeyEventV0(std::string txnId, Event event, immer::map<std::string, immer::flex_vector<std::string>> devices);

	struct ReadReceipt
	{
	std::string eventId;
	Timestamp timestamp;
	};

	template<class Archive>
	void serialize(Archive &ar, ReadReceipt &r, std::uint32_t const /* version */)
	{
	ar & r.eventId & r.timestamp;
	}

	bool operator==(const ReadReceipt &a, const ReadReceipt &b);
	bool operator!=(const ReadReceipt &a, const ReadReceipt &b);

	struct EventReader
	{
	std::string userId;
	Timestamp timestamp;
	};

	bool operator==(const EventReader &a, const EventReader &b);
	bool operator!=(const EventReader &a, const EventReader &b);

	struct AddStateEventsAction
	{
	immer::flex_vector<Event> stateEvents;
	};

	struct AddToTimelineAction
	{
	/// Events from oldest to latest
	immer::flex_vector<Event> events;
	std::optional<std::string> prevBatch;
	std::optional<bool> limited;
	std::optional<std::string> gapEventId;
	};

	struct AddAccountDataAction
	{
	immer::flex_vector<Event> events;
	};

	struct ChangeMembershipAction
	{
	RoomMembership membership;
	};

	struct ChangeInviteStateAction
	{
	immer::flex_vector<Event> events;
	};

	struct AddEphemeralAction
	{
	EventList events;
	};

	struct SetLocalDraftAction
	{
	std::string localDraft;
	};

	struct SetRoomEncryptionAction
	{
	};

	struct MarkMembersFullyLoadedAction
	{
	};

	struct SetHeroIdsAction
	{
	immer::flex_vector<std::string> heroIds;
	};

	struct AddLocalEchoAction
	{
	LocalEchoDesc localEcho;
	};

	struct RemoveLocalEchoAction
	{
	std::string txnId;
	};

	struct AddPendingRoomKeyAction
	{
	PendingRoomKeyEvent pendingRoomKeyEvent;
	};

	struct RemovePendingRoomKeyAction
	{
	std::string txnId;
	};

	struct UpdateJoinedMemberCountAction
	{
	std::size_t joinedMemberCount;
	};

	struct UpdateInvitedMemberCountAction
	{
	std::size_t invitedMemberCount;
	};

	inline bool operator==(const PendingRoomKeyEvent &a, const PendingRoomKeyEvent &b)
	{
	return a.txnId == b.txnId && a.messages == b.messages;
	}

	inline bool operator!=(const PendingRoomKeyEvent &a, const PendingRoomKeyEvent &b)
	{
	return !(a == b);
	}

	inline const double ROOM_TAG_DEFAULT_ORDER = 2;

	template<class Archive>
	void serialize(Archive &ar, PendingRoomKeyEvent &e, std::uint32_t const version)
	{
	if (version < 1) {
	// loading an older version where there is only one event
	std::string txnId;
	Event event;
	immer::map<std::string, immer::flex_vector<std::string>> devices;
	ar & txnId & event & devices;
	e = makePendingRoomKeyEventV0(
	std::move(txnId), std::move(event), std::move(devices));
	} else {
	ar & e.txnId & e.messages;
	}
	}

	struct RoomModel
	{
	using Membership = RoomMembership;
	using ReverseEventRelationshipMap = immer::map<
	std::string /* related event id */,
	immer::map<std::string /* relation type /, immer::flex_vector<std::string / relater event id */>>>;

	std::string roomId;
	immer::map<KeyOfState, Event> stateEvents;
	immer::map<KeyOfState, Event> inviteState;
	// Smaller indices mean earlier events
	// (oldest) 0 --------> n (latest)
	immer::flex_vector<std::string> timeline;
	immer::map<std::string, Event> messages;
	immer::map<std::string, Event> accountData;
	Membership membership{};
	std::string paginateBackToken;
	/// whether this room has earlier events to be fetched
	bool canPaginateBack{true};

	immer::map<std::string /* eventId /, std::string / prevBatch */> timelineGaps;

	immer::map<std::string, Event> ephemeral;

	std::string localDraft;

	bool encrypted{false};
	/// a marker to indicate whether we need to rotate
	/// the session key earlier than it expires
	/// (e.g. when a user in the room's device list changed
	/// or when someone joins or leaves)
	bool shouldRotateSessionKey{true};

	bool membersFullyLoaded{false};
	immer::flex_vector<std::string> heroIds;

	immer::flex_vector<LocalEchoDesc> localEchoes;

	immer::flex_vector<PendingRoomKeyEvent> pendingRoomKeyEvents;

	ReverseEventRelationshipMap reverseEventRelationships;

	std::size_t joinedMemberCount{0};
	std::size_t invitedMemberCount{0};

	/// The local read marker for this room. Indicates that
	/// you have read up to this event.
	std::string localReadMarker;
	/// The local unread count for this room.
	std::size_t localUnreadCount{0};
	/// The local unread notification count for this room.
	std::size_t localNotificationCount{0};
	/// Read receipts for all users
	immer::map<std::string /* userId */, ReadReceipt> readReceipts;
	/// A map from event id to a list of users that has read
	/// receipt at that point
	immer::map<
	std::string /* eventId */,
	immer::flex_vector<std::string /* userId */>> eventReadUsers;

	+ /// A map from the session id to a list of event ids of events
	+ /// that cannot (yet) be decrypted.
	+ immer::map<
	+ std::string /* sessionId */,
	+ immer::flex_vector<std::string /* eventId */>> undecryptedEvents;
	+
	immer::flex_vector<std::string> joinedMemberIds() const;
	immer::flex_vector<std::string> invitedMemberIds() const;
	immer::flex_vector<std::string> knockedMemberIds() const;
	immer::flex_vector<std::string> leftMemberIds() const;
	immer::flex_vector<std::string> bannedMemberIds() const;

	EventList joinedMemberEvents() const;
	EventList invitedMemberEvents() const;
	EventList knockedMemberEvents() const;
	EventList leftMemberEvents() const;
	EventList bannedMemberEvents() const;
	EventList heroMemberEvents() const;

	MegOlmSessionRotateDesc sessionRotateDesc() const;

	bool hasUser(std::string userId) const;

	std::optional<LocalEchoDesc> getLocalEchoByTxnId(std::string txnId) const;
	std::optional<PendingRoomKeyEvent> getPendingRoomKeyEventByTxnId(std::string txnId) const;

	immer::map<std::string, double> tags() const;

	Event makeAddTagEvent(std::string tagId, std::optional<double> order) const;
	Event makeRemoveTagEvent(std::string tagId) const;

	/**
	* Fill in reverseEventRelationships by gathering
	* the relationships specified in `newEvents`
	*
	* @param newEvents The events that just came in after last time event relationships
	* are gathered.
	*/
	void generateRelationships(EventList newEvents);

	void regenerateRelationships();

	+ /**
	+ * Fill in undecryptedEvents by gathering
	+ * the session ids specified in `newEvents`.
	+ *
	+ * @param newEvents New incoming events.
	+ */
	+ void addToUndecryptedEvents(EventList newEvents);
	+
	+ void recalculateUndecryptedEvents();
	+
	using Action = std::variant<
	AddStateEventsAction,
	AddToTimelineAction,
	AddAccountDataAction,
	ChangeMembershipAction,
	ChangeInviteStateAction,
	AddEphemeralAction,
	SetLocalDraftAction,
	SetRoomEncryptionAction,
	MarkMembersFullyLoadedAction,
	SetHeroIdsAction,
	AddLocalEchoAction,
	RemoveLocalEchoAction,
	AddPendingRoomKeyAction,
	RemovePendingRoomKeyAction,
	UpdateJoinedMemberCountAction,
	UpdateInvitedMemberCountAction
	>;

	static RoomModel update(RoomModel r, Action a);
	};

	using RoomAction = RoomModel::Action;

	inline bool operator==(const RoomModel &a, const RoomModel &b)
	{
	return a.roomId == b.roomId
	&& a.stateEvents == b.stateEvents
	&& a.inviteState == b.inviteState
	&& a.timeline == b.timeline
	&& a.messages == b.messages
	&& a.accountData == b.accountData
	&& a.membership == b.membership
	&& a.paginateBackToken == b.paginateBackToken
	&& a.canPaginateBack == b.canPaginateBack
	&& a.timelineGaps == b.timelineGaps
	&& a.ephemeral == b.ephemeral
	&& a.localDraft == b.localDraft
	&& a.encrypted == b.encrypted
	&& a.shouldRotateSessionKey == b.shouldRotateSessionKey
	&& a.membersFullyLoaded == b.membersFullyLoaded
	&& a.heroIds == b.heroIds
	&& a.localEchoes == b.localEchoes
	&& a.pendingRoomKeyEvents == b.pendingRoomKeyEvents
	&& a.reverseEventRelationships == b.reverseEventRelationships
	&& a.joinedMemberCount == b.joinedMemberCount
	&& a.localReadMarker == b.localReadMarker
	&& a.localUnreadCount == b.localUnreadCount
	&& a.localNotificationCount == b.localNotificationCount
	&& a.readReceipts == b.readReceipts
	&& a.eventReadUsers == b.eventReadUsers
	+ && a.undecryptedEvents == b.undecryptedEvents
	;
	}

	struct UpdateRoomAction
	{
	std::string roomId;
	RoomAction roomAction;
	};

	struct RoomListModel
	{
	immer::map<std::string, RoomModel> rooms;

	inline auto at(std::string id) const { return rooms.at(id); }
	inline auto operator[](std::string id) const { return rooms[id]; }
	inline bool has(std::string id) const { return rooms.find(id); }

	using Action = std::variant<
	UpdateRoomAction
	>;
	static RoomListModel update(RoomListModel l, Action a);
	};

	using RoomListAction = RoomListModel::Action;

	inline bool operator==(const RoomListModel &a, const RoomListModel &b)
	{
	return a.rooms == b.rooms;
	}

	template<class Archive>
	void serialize(Archive &ar, RoomModel &r, std::uint32_t const version)
	{
	ar
	& r.roomId
	& r.stateEvents
	& r.inviteState

	& r.timeline
	& r.messages
	& r.accountData
	& r.membership
	& r.paginateBackToken
	& r.canPaginateBack

	& r.timelineGaps
	& r.ephemeral

	& r.localDraft

	& r.encrypted
	& r.shouldRotateSessionKey

	& r.membersFullyLoaded
	;

	if (version >= 1) {
	ar
	& r.heroIds
	;
	}
	if (version >= 2) {
	ar & r.localEchoes;
	}
	if (version >= 3) {
	ar & r.pendingRoomKeyEvents;
	}
	if (version >= 4) {
	ar & r.reverseEventRelationships;
	} else { // must be reading from an older version
	if constexpr (typename Archive::is_loading()) {
	r.regenerateRelationships();
	}
	}
	if (version >= 5) {
	ar & r.joinedMemberCount & r.invitedMemberCount;
	}
	if (version >= 6) {
	ar
	& r.localReadMarker
	& r.localUnreadCount
	& r.localNotificationCount
	& r.readReceipts
	& r.eventReadUsers;
	}
	+ if (version >= 7) {
	+ ar & r.undecryptedEvents;
	+ } else {
	+ if constexpr (typename Archive::is_loading()) {
	+ r.recalculateUndecryptedEvents();
	+ }
	+ }
	}

	template<class Archive>
	void serialize(Archive &ar, RoomListModel &l, std::uint32_t const /version/)
	{
	ar & l.rooms;
	}
	}

	BOOST_CLASS_VERSION(Kazv::PendingRoomKeyEvent, 1)
	BOOST_CLASS_VERSION(Kazv::ReadReceipt, 0)
	-BOOST_CLASS_VERSION(Kazv::RoomModel, 6)
	+BOOST_CLASS_VERSION(Kazv::RoomModel, 7)
	BOOST_CLASS_VERSION(Kazv::RoomListModel, 0)
	diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
	index b21b9d6..4d4b913 100644
	--- a/src/tests/CMakeLists.txt
	+++ b/src/tests/CMakeLists.txt
	@@ -1,114 +1,115 @@

	include(CTest)

	set(KAZVTEST_RESPATH ${CMAKE_CURRENT_SOURCE_DIR}/resources)
	configure_file(kazvtest-respath.hpp.in kazvtest-respath.hpp)

	function(libkazv_add_tests)
	set(options "")
	set(oneValueArgs "")
	set(multiValueArgs EXTRA_LINK_LIBRARIES EXTRA_INCLUDE_DIRECTORIES)
	cmake_parse_arguments(PARSE_ARGV 0 libkazv_add_tests "${options}" "${oneValueArgs}" "${multiValueArgs}")
	foreach(test_source ${libkazv_add_tests_UNPARSED_ARGUMENTS})
	string(REGEX REPLACE "\\.cpp$" "" test_executable "${test_source}")
	string(REGEX REPLACE "/\|\\\\" "--" test_executable "${test_executable}")
	message(STATUS "Test ${test_executable} added")
	add_executable("${test_executable}" "${test_source}")
	target_link_libraries("${test_executable}"
	PRIVATE Catch2::Catch2WithMain
	Threads::Threads
	${libkazv_add_tests_EXTRA_LINK_LIBRARIES}
	)

	target_include_directories(
	"${test_executable}"
	PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}
	${CMAKE_CURRENT_SOURCE_DIR}/..
	${libkazv_add_tests_EXTRA_INCLUDE_DIRECTORIES}
	)

	target_compile_definitions("${test_executable}" PRIVATE CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)

	add_test(NAME "${test_executable}" COMMAND "${test_executable}" "--allow-running-no-tests" "~[needs-internet]")
	endforeach()
	endfunction()

	libkazv_add_tests(
	event-test.cpp
	cursorutiltest.cpp
	base/serialization-test.cpp
	base/types-test.cpp
	base/immer-utils-test.cpp
	base/json-utils-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase
	)

	add_library(client-test-lib SHARED client/client-test-util.cpp)
	target_link_libraries(client-test-lib PUBLIC kazvjob kazvclient)
	libkazv_add_tests(
	client/discovery-test.cpp
	client/sync-test.cpp
	client/content-test.cpp
	client/paginate-test.cpp
	client/util-test.cpp
	client/serialization-test.cpp
	client/encrypted-file-test.cpp
	client/sdk-test.cpp
	client/thread-safety-test.cpp
	client/room-test.cpp
	client/random-generator-test.cpp
	client/profile-test.cpp
	client/kick-test.cpp
	client/ban-test.cpp
	client/join-test.cpp
	client/keys-test.cpp
	client/device-ops-test.cpp
	client/send-test.cpp
	client/encryption-test.cpp
	client/redact-test.cpp
	client/tagging-test.cpp
	client/account-data-test.cpp
	client/room/room-actions-test.cpp
	client/room/local-echo-test.cpp
	client/room/event-relationships-test.cpp
	client/room/member-membership-test.cpp
	client/push-rules-desc-test.cpp
	client/notification-handler-test.cpp
	client/validator-test.cpp
	client/power-levels-desc-test.cpp
	client/client-test.cpp
	client/create-room-test.cpp
	client/device-list-tracker-benchmark-test.cpp
	client/room/read-receipt-test.cpp
	+ client/room/undecrypted-events-test.cpp
	EXTRA_LINK_LIBRARIES kazvclient kazveventemitter kazvjob client-test-lib kazvtestfixtures
	EXTRA_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/client
	)

	libkazv_add_tests(
	basejobtest.cpp
	kazvjobtest.cpp
	file-desc-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazvjob
	)

	libkazv_add_tests(
	promise-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazvjob kazvstore
	)

	libkazv_add_tests(
	event-emitter-test.cpp
	EXTRA_LINK_LIBRARIES kazvbase kazveventemitter
	)

	libkazv_add_tests(
	crypto-test.cpp
	crypto/deterministic-test.cpp
	EXTRA_LINK_LIBRARIES kazvcrypto
	)

	libkazv_add_tests(
	store-test.cpp
	EXTRA_LINK_LIBRARIES kazvstore kazvjob
	)
	diff --git a/src/tests/client/room/undecrypted-events-test.cpp b/src/tests/client/room/undecrypted-events-test.cpp
	new file mode 100644
	index 0000000..801a335
	--- /dev/null
	+++ b/src/tests/client/room/undecrypted-events-test.cpp
	@@ -0,0 +1,141 @@
	+/*
	+ * This file is part of libkazv.
	+ * SPDX-FileCopyrightText: 2024 tusooa <tusooa@kazv.moe>
	+ * SPDX-License-Identifier: AGPL-3.0-or-later
	+ */
	+
	+#include <libkazv-config.hpp>
	+#include <catch2/catch_test_macros.hpp>
	+#include <sstream>
	+#include <boost/archive/text_iarchive.hpp>
	+#include <boost/archive/text_oarchive.hpp>
	+#include <asio-promise-handler.hpp>
	+#include "factory.hpp"
	+#include "client-test-util.hpp"
	+
	+using namespace Kazv;
	+using namespace Kazv::Factory;
	+
	+TEST_CASE("RoomModel::undecryptedEvents", "[client][room][encryption]")
	+{
	+ auto events = EventList{
	+ // not encrypted events, not taken into account
	+ makeEvent(),
	+ makeEvent(withEventKV("/content/session_id"_json_pointer, "some-session-id")),
	+ // encrypted event, not decrypted, valid session id
	+ makeEvent(withEventId("$some-event-0") \| withEventType("m.room.encrypted") \| withEventKV("/content/session_id"_json_pointer, "some-session-id")),
	+ makeEvent(withEventId("$some-event-1") \| withEventType("m.room.encrypted") \| withEventKV("/content/session_id"_json_pointer, "some-other-session-id")),
	+ makeEvent(withEventId("$some-event-2") \| withEventType("m.room.encrypted") \| withEventKV("/content/session_id"_json_pointer, "some-session-id")),
	+ // session id is not a string, not taken into account
	+ makeEvent(withEventId("$some-event-3") \| withEventType("m.room.encrypted") \| withEventKV("/content/session_id"_json_pointer, json())),
	+ // decrypted events are not taken into account
	+ makeEvent(withEventId("$some-event-4") \| withEventType("m.room.encrypted") \| withEventKV("/content/session_id"_json_pointer, "some-other-session-id"))
	+ .setDecryptedJson(json::object({}), Event::Decrypted),
	+ };
	+
	+ SECTION("it calculates for an encrypted room")
	+ {
	+ auto room = makeRoom(withRoomEncrypted(true) \| withRoomTimeline(events));
	+
	+ auto expected = immer::map<std::string, immer::flex_vector<std::string>>{
	+ {"some-session-id", {"$some-event-0", "$some-event-2"}},
	+ {"some-other-session-id", {"$some-event-1"}},
	+ };
	+
	+ REQUIRE(room.undecryptedEvents == expected);
	+ }
	+
	+ SECTION("it does not calculate for an unencrypted room")
	+ {
	+ auto room = makeRoom(withRoomEncrypted(false) \| withRoomTimeline(events));
	+ REQUIRE(room.undecryptedEvents == immer::map<std::string, immer::flex_vector<std::string>>{});
	+ }
	+}
	+
	+TEST_CASE("Serialize RoomModel with undecryptedEvents", "[client][serialization][room]")
	+{
	+ using IAr = boost::archive::text_iarchive;
	+ using OAr = boost::archive::text_oarchive;
	+
	+ auto events = EventList{
	+ makeEvent(withEventId("$some-event-0") \| withEventType("m.room.encrypted") \| withEventKV("/content/session_id"_json_pointer, "some-session-id")),
	+ };
	+
	+ auto expected = immer::map<std::string, immer::flex_vector<std::string>>{
	+ {"some-session-id", {
	+ "$some-event-0",
	+ }},
	+ };
	+
	+ RoomModel m1 = makeRoom(withRoomEncrypted(true) \| withRoomTimeline(events));
	+ m1.undecryptedEvents = {}; // force clear the undecrypted map
	+ RoomModel m2;
	+
	+ WHEN("reading from an archive older than v7") {
	+ std::stringstream stream;
	+
	+ {
	+ auto ar = OAr(stream);
	+ serialize(ar, m1, 6); // HACK to save as v6, thus bypassing event relationships
	+ }
	+
	+ {
	+ auto ar = IAr(stream);
	+ serialize(ar, m2, 6);
	+ }
	+
	+ THEN("it should regenerate undecryptedEvents") {
	+ REQUIRE(m2.undecryptedEvents == expected);
	+ }
	+ }
	+
	+ WHEN("reading from an archive later or equal to v7") {
	+ std::stringstream stream;
	+
	+ {
	+ auto ar = OAr(stream);
	+ ar << m1;
	+ }
	+
	+ {
	+ auto ar = IAr(stream);
	+ ar >> m2;
	+ }
	+
	+ THEN("it should not regenerate undecryptedEvents") {
	+ REQUIRE(m2.undecryptedEvents == immer::map<std::string, immer::flex_vector<std::string>>{});
	+ }
	+ }
	+}
	+
	+TEST_CASE("Serialize unencrypted RoomModel with undecryptedEvents", "[client][serialization][room]")
	+{
	+ using IAr = boost::archive::text_iarchive;
	+ using OAr = boost::archive::text_oarchive;
	+
	+ auto events = EventList{
	+ makeEvent(withEventId("$some-event-0") \| withEventType("m.room.encrypted") \| withEventKV("/content/session_id"_json_pointer, "some-session-id")),
	+ };
	+
	+ RoomModel m1 = makeRoom(withRoomEncrypted(false) \| withRoomTimeline(events));
	+ m1.undecryptedEvents = {}; // force clear the undecrypted map
	+ RoomModel m2;
	+
	+ WHEN("reading from an archive older than v7") {
	+ std::stringstream stream;
	+
	+ {
	+ auto ar = OAr(stream);
	+ serialize(ar, m1, 6); // HACK to save as v6, thus bypassing event relationships
	+ }
	+
	+ {
	+ auto ar = IAr(stream);
	+ serialize(ar, m2, 6);
	+ }
	+
	+ THEN("it not should regenerate undecryptedEvents") {
	+ REQUIRE(m2.undecryptedEvents == immer::map<std::string, immer::flex_vector<std::string>>{});
	+ }
	+ }
	+}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 9, 6:56 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1724301
Default Alt Text: (45 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions