Compare commits

..

No commits in common. "55652eaa1505619916a5091a95d5d2e5f65780d1" and "6f045083a2ea3fe17d99b5643c46d38daedc4a1a" have entirely different histories.

4 changed files with 68 additions and 164 deletions

View file

@ -24,121 +24,12 @@
*/
#include <Filter.h>
#include <Cytoplasm/Memory.h>
#include <Cytoplasm/Json.h>
#include <Cytoplasm/Str.h>
#include <string.h>
#include <Schema/Filter.h>
bool
IsRoomFiltered(Filter *filter, char *roomID)
{
size_t i, count;
if (!filter || !roomID)
{
return false;
}
count = ArraySize(filter->room.not_rooms);
for (i = 0; i < count; i++)
{
char *notRoom = ArrayGet(filter->room.not_rooms, i);
if (StrEquals(roomID, notRoom))
{
return true;
}
}
count = ArraySize(filter->room.rooms);
if (count)
{
for (i = 0; i < count; i++)
{
char *room = ArrayGet(filter->room.rooms, i);
if (StrEquals(roomID, room))
{
return false;
}
}
return true;
}
return false;
}
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))
{
return NULL;
}
copy = JsonDuplicate(event);
(void) sender;
return copy;
}
Filter *
FilterDecode(Db *db, char *user, char *filterStr)
{
Filter *ret;
DbRef *filterRef;
HashMap *filterObj;
if (!db || !user || !filterStr)
{
return NULL;
}
if (*filterStr != '{')
{
char *err; /* TODO: use error status somewhere... */
filterRef = DbLock(db, 3, "filters", user, filterStr);
filterObj = DbJson(filterRef);
ret = Malloc(sizeof(*ret));
memset(ret, 0, sizeof(*ret));
if (!FilterFromJson(filterObj, ret, &err))
{
DbUnlock(db, filterRef);
Free(ret);
return NULL;
}
DbUnlock(db, filterRef);
(void) err;
return ret;
}
/* TODO: Decode JSON here... */
(void) filter;
(void) event;
return NULL;
}
void
FilterDestroy(Filter *filter)
{
if (!filter)
{
return;
}
FilterFree(filter);
Free(filter);
}

View file

@ -34,7 +34,6 @@
#include <Cytoplasm/Util.h>
#include <Cytoplasm/Str.h>
#include <Filter.h>
#include <State.h>
#include <User.h>
#include <Room.h>
@ -60,6 +59,42 @@ StripStateEventSync(HashMap *pdu)
return ret;
}
/* Verify whenever a room is filtered out by a filter given in. */
static bool
IsRoomFiltered(Filter *filter, char *roomID)
{
size_t i, count;
if (!filter || !roomID)
{
return false;
}
count = ArraySize(filter->room.not_rooms);
for (i = 0; i < count; i++)
{
char *notRoom = ArrayGet(filter->room.not_rooms, i);
if (StrEquals(roomID, notRoom))
{
return true;
}
}
count = ArraySize(filter->room.rooms);
if (count)
{
for (i = 0; i < count; i++)
{
char *room = ArrayGet(filter->room.rooms, i);
if (StrEquals(roomID, room))
{
return false;
}
}
return true;
}
return false;
}
ROUTE_IMPL(RouteSync, path, argp)
{
RouteArgs *args = argp;
@ -68,7 +103,7 @@ ROUTE_IMPL(RouteSync, path, argp)
HashMap *params = NULL;
HashMap *response = NULL;
SyncResponse sync = { 0 };
Filter *filterData = NULL;
Filter filterData = { 0 };
Array *invites;
Array *joins;
@ -118,15 +153,25 @@ ROUTE_IMPL(RouteSync, path, argp)
filter = HashMapGet(params, "filter");
timeoutDuration = timeout ? atoi(timeout) : 0;
if (filter)
if (filter && *filter != '{')
{
char *userName = UserGetName(user);
if (!(filterData = FilterDecode(db, userName, filter)))
/* The filter must be located in the database */
DbRef *filterRef = DbLock(db, 3,
"filters", UserGetName(user), filter
);
HashMap *filterJson = DbJson(filterRef);
if (!FilterFromJson(filterJson, &filterData, &err))
{
err = "Couldn't decode filter given in";
HttpResponseStatus(args->context, HTTP_BAD_REQUEST);
response = MatrixErrorCreate(M_BAD_JSON, err);
DbUnlock(db, filterRef);
goto finish;
}
/* We now grabbed a filter JSON */
DbUnlock(db, filterRef);
}
if (!prevBatch)
@ -143,9 +188,8 @@ ROUTE_IMPL(RouteSync, path, argp)
UserUnlock(user);
/* TODO: Using pthreads' condition variables with a timeout would be
* the best way to proceed (as in Parsee's ParseeAwaitStanza function).
* Also, how would Cytoplasm proceed if the all of HTTP threads are used
* for syncing? That sounds like a really bad bottleneck... */
* the best way to proceed (as in Parsee's ParseeAwaitStanza function)
*/
while (passed < timeoutDuration)
{
if (UserGetNotification(name))
@ -173,7 +217,7 @@ ROUTE_IMPL(RouteSync, path, argp)
InvitedRooms invited = { 0 };
HashMap *invitedObject;
if (IsRoomFiltered(filterData, roomId))
if (IsRoomFiltered(&filterData, roomId))
{
continue;
}
@ -204,7 +248,7 @@ ROUTE_IMPL(RouteSync, path, argp)
size_t j;
Room *r;
if (IsRoomFiltered(filterData, roomId))
if (IsRoomFiltered(&filterData, roomId))
{
continue;
}
@ -218,25 +262,19 @@ ROUTE_IMPL(RouteSync, path, argp)
for (j = 0; j < ArraySize(el); j++)
{
char *event = ArrayGet(el, j);
HashMap *eventObj = RoomEventFetch(r, event);
HashMap *filteredObj = FilterApply(filterData, eventObj);
HashMap *e = RoomEventFetch(r, event);
ClientEventWithoutRoomID rc = ClientfyEventSync(e);
ClientEventWithoutRoomID *c = Malloc(sizeof(*c));
memcpy(c, &rc, sizeof(*c));
if (filteredObj)
JsonFree(e);
if (j == 0)
{
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);
firstEvent = c->event_id;
}
JsonFree(eventObj);
JsonFree(filteredObj);
ArrayAdd(joined.timeline.events, c);
}
joined.timeline.prev_batch = UserNewMessageToken(
user, roomId, firstEvent
@ -278,7 +316,7 @@ ROUTE_IMPL(RouteSync, path, argp)
response = SyncResponseToJson(&sync);
SyncResponseFree(&sync);
finish:
FilterDestroy(filterData);
FilterFree(&filterData);
UserUnlock(user);
(void) path;
return response;

View file

@ -379,13 +379,7 @@ StateCurrent(Room *room)
return ret;
}
/* TODO: USING A ',' DELIMITED HASHMAP IS A _BAD_ IDEA!
* I'll need to change these functions, and some things in the room
* implementation, thankfully _that_ was abstracted away, so I don't have
* to think about it too much... */
bool
StateIterate(HashMap *state, char **type, char **key, void **event)
bool StateIterate(HashMap *state, char **type, char **key, void **event)
{
char *tuple;
bool ret;
@ -406,7 +400,6 @@ StateIterate(HashMap *state, char **type, char **key, void **event)
return ret;
}
char *
StateGet(HashMap *state, char *type, char *key)
{

View file

@ -28,7 +28,6 @@
#include <Schema/Filter.h>
#include <Cytoplasm/HashMap.h>
#include <Cytoplasm/Db.h>
/***
* @Nm Filter
@ -48,21 +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.
*/
extern Filter * FilterDecode(Db *, char *, char *);
/**
* Frees all memory created by
* .Fn FilterDecode .
*/
extern void FilterDestroy(Filter *);
#endif /* TELODENDRIA_FILTER_H */