src/Filter.c

@@ -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;
+    (void) filter;
-    char *sender, *room;
+    (void) event;
-    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... */
     return NULL;
 }
-
-void
-FilterDestroy(Filter *filter)
-{
-    if (!filter)
-    {
-        return;
-    }
-
-    FilterFree(filter);
-    Free(filter);
-}

src/Routes/RouteSync.c

@@ -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);
+        /* The filter must be located in the database */
-        if (!(filterData = FilterDecode(db, userName, filter)))
+        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).
+         * 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... */
         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 *e = RoomEventFetch(r, event);
-            HashMap *filteredObj = FilterApply(filterData, eventObj);
+            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);
+                firstEvent = c->event_id;
-                ClientEventWithoutRoomID *c = Malloc(sizeof(*c));
-                memcpy(c, &rc, sizeof(*c));
-
-                if (!firstEvent)
-                {
-                    firstEvent = c->event_id;
-                }
-
-                ArrayAdd(joined.timeline.events, c);
             }
 
-            JsonFree(eventObj);
+            ArrayAdd(joined.timeline.events, c);
-            JsonFree(filteredObj);
         }
         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;

src/State.c

@@ -379,13 +379,7 @@ StateCurrent(Room *room)
 
     return ret;
 }
-
+bool StateIterate(HashMap *state, char **type, char **key, void **event)
-/* 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)
 {
     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)
 {

src/include/Filter.h

@@ -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 */