[MOD/FIX] Separate XMPP thread, fix EINVAL issue

threading is good actually. please hmu if you ever trigger the
achievement.

src/XMPPThread/Stanzas/IQ.c

@@ -0,0 +1,447 @@
+#include "XMPPThread/internal.h"
+
+#include <Cytoplasm/Memory.h>
+#include <Cytoplasm/Base64.h>
+#include <Cytoplasm/Str.h>
+#include <Cytoplasm/Log.h>
+
+#include <StringStream.h>
+#include <Matrix.h>
+#include <AS.h>
+
+#include <string.h>
+#include <ctype.h>
+
+static XMLElement *
+CreateTagWithText(const char *tn, char *text)
+{
+    XMLElement *tag = XMLCreateTag((char *) tn);
+    XMLElement *tex = XMLCreateText(text);
+
+    XMLAddChild(tag, tex);
+
+    return tag;
+}
+
+char *
+TrimBase64(char *b64)
+{
+    char *ret, *tmp;
+
+    ret = NULL;
+    while (*b64)
+    {
+        char ch[2] = { *b64, 0 };
+        if (isspace(*b64))
+        {
+            b64++;
+            continue;
+        }
+
+        tmp = ret;
+        ret = StrConcat(2, ret, ch);
+        Free(tmp);
+        b64++;
+    }
+    return ret;
+}
+
+#define DISCO   "http://jabber.org/protocol/disco#info"
+static XMLElement *
+IQGenerateQuery(void)
+{
+    XMLElement *query = XMLCreateTag("query");
+    XMLAddAttr(query, "xmlns", DISCO);
+    {
+        XMLElement *feature;
+#define IdentitySimple(c,t,n)  do \
+                        { \
+                            feature = XMLCreateTag("identity"); \
+                            XMLAddAttr(feature, "category", c); \
+                            XMLAddAttr(feature, "type", t); \
+                            XMLAddAttr(feature, "name", n); \
+                            XMLAddChild(query, feature); \
+                        } \
+                        while (0);
+        IQ_IDENTITY
+#undef IdentitySimple
+#define AdvertiseSimple(f)  do \
+                        { \
+                            feature = XMLCreateTag("feature"); \
+                            XMLAddAttr(feature, "var", f); \
+                            XMLAddChild(query, feature); \
+                        } \
+                        while (0);
+
+        IQ_ADVERT
+#undef AdvertiseSimple
+    }
+
+    return query;
+}
+void
+IQDiscoGet(ParseeData *args, XMPPComponent *jabber, XMLElement *stanza)
+{
+    char *from, *to, *id;
+    XMLElement *iq_reply, *query;
+
+    from = HashMapGet(stanza->attrs, "from");
+    to = HashMapGet(stanza->attrs, "to");
+    id = HashMapGet(stanza->attrs, "id");
+
+    /* Generate an IQ reply with discovery information */
+    iq_reply = XMLCreateTag("iq");
+    XMLAddAttr(iq_reply, "to", from);
+    XMLAddAttr(iq_reply, "from", to);
+    XMLAddAttr(iq_reply, "type", "result");
+    XMLAddAttr(iq_reply, "id", id);
+
+    query = IQGenerateQuery();
+    {
+        char *ver = XMPPGenerateVer();
+        char *node = StrConcat(3, REPOSITORY, "#", ver);
+        XMLAddAttr(query, "node", node);
+
+        Free(node);
+        Free(ver);
+    }
+    XMLAddChild(iq_reply, query);
+
+    pthread_mutex_lock(&jabber->write_lock);
+    XMLEncode(jabber->stream, iq_reply);
+    StreamFlush(jabber->stream);
+    pthread_mutex_unlock(&jabber->write_lock);
+
+    XMLFreeElement(iq_reply);
+}
+
+void
+IQResult(ParseeData *args, XMLElement *stanza, XMPPThread *thr)
+{
+    XMLElement *vcard = XMLookForTKV(stanza, "vCard", "xmlns", "vcard-temp");
+
+    XMLElement *event = XMLookForTKV(stanza, "pubsub", 
+        "xmlns", "http://jabber.org/protocol/pubsub"
+    );
+
+    (void) thr;
+
+    if (event)
+    {
+        size_t i;
+        XMLElement *retrieve = 
+            XMLookForTKV(event, "items", "node", "urn:xmpp:avatar:data");
+        if (retrieve)
+        {
+            for (i = 0; i < ArraySize(retrieve->children); i++)
+            {
+                XMLElement *item = 
+                    ArrayGet(retrieve->children, i);
+                XMLElement *avatar_data = XMLookForTKV(
+                    item, "data", "xmlns", "urn:xmpp:avatar:data"
+                );
+                XMLElement *data = ArrayGet(avatar_data->children, 0);
+                char *id = HashMapGet(item->attrs, "id");
+                char *from = HashMapGet(stanza->attrs, "from");
+                char *base64;
+                char *bdata;
+                size_t length, b64len;
+                Stream *datastream;
+                char *mxc, *from_matrix, *jid;
+                DbRef *avatars;
+                HashMap *json;
+
+                if (!data || !data->data)
+                {
+                    return;
+                }
+                avatars = DbLock(args->db, 1, "avatars");
+                if (!avatars)
+                {
+                    avatars = DbCreate(args->db, 1, "avatars");
+                }
+                json = DbJson(avatars);
+
+                if (StrEquals(GrabString(json, 1, from), id))
+                {
+                    DbUnlock(args->db, avatars);
+                    return;
+                }
+
+                base64 = TrimBase64(data->data);
+                b64len = base64 ? strlen(base64) : 0;
+                length = Base64DecodedSize(base64, b64len);
+
+                /* TODO: Bound checks for a size limit. */
+                bdata = (char *) Base64Decode(base64, b64len);
+                datastream = StrStreamReaderN(bdata, length);
+
+                /* XEP-0084 effectively assumes an image/png MIME. */
+                mxc = ASUpload(args->config, datastream, length, "image/png");
+                
+                jid = ParseeLookupJID(from);
+                from_matrix = ParseeEncodeJID(args->config, jid, false);
+                ASSetAvatar(args->config, from_matrix, mxc);
+
+                JsonValueFree(JsonSet(
+                    json, JsonValueString(id),
+                    1, from
+                ));
+                DbUnlock(args->db, avatars);
+
+                Free(mxc);
+                Free(jid);
+                Free(bdata);
+                Free(from_matrix);
+                Free(base64);
+                StreamClose(datastream);
+            }
+
+        }
+    }
+    if (vcard)
+    {
+        XMLElement *photo = XMLookForUnique(vcard, "PHOTO");
+
+        if (photo)
+        {
+            XMLElement *binval = XMLookForUnique(photo, "BINVAL");
+            XMLElement *type = XMLookForUnique(photo, "TYPE");
+            XMLElement *data = 
+                binval ? ArrayGet(binval->children, 0) : NULL;
+            XMLElement *tdata = type ? ArrayGet(type->children, 0) : NULL;
+            char *base64;
+            char *bdata;
+            size_t length, b64len;
+            Stream *datastream;
+            char *mxc = NULL, *from_matrix = NULL, *jid = NULL;
+            char *room = NULL, *resource;
+            char *from = HashMapGet(stanza->attrs, "from");
+            if (!data || !data->data)
+            {
+                Log(LOG_ERR, "%s NOT FOUND", HashMapGet(stanza->attrs, "from"));
+                return;
+            }
+
+            /* Get the base64, decode it, and shove it in a nicely put 
+             * MXC address */
+            base64 = data->data;
+            b64len = base64 ? strlen(base64) : 0;
+            length = Base64DecodedSize(base64, b64len);
+
+            bdata = Base64Decode(base64, b64len);
+            datastream = StrStreamReaderN(bdata, length);
+            mxc = ASUpload(
+                args->config, 
+                datastream, 
+                length,
+                tdata ? tdata->data : NULL
+            );
+            Free(bdata);
+            StreamClose(datastream);
+
+            room = ParseeGetBridgedRoom(args, stanza);
+            jid = ParseeLookupJID(HashMapGet(stanza->attrs, "from"));
+
+            resource = ParseeTrimJID(from);
+
+            /* TODO: More reliable system for telling the difference appart */
+            if (jid && !StrEquals(from, resource))
+            {
+                from_matrix = ParseeEncodeJID(args->config, jid, false);
+                ASSetAvatar(args->config, from_matrix, mxc);
+            }
+            else if (room)
+            {
+                char *mask = ParseeMXID(args);
+                HashMap *obj = HashMapCreate();
+
+                HashMapSet(obj, "url", JsonValueString(mxc));
+                ASSetState(
+                    args->config, 
+                    room, "m.room.avatar", "", 
+                    mask, obj
+                );
+                Free(mask);
+            }
+            
+            Free(from_matrix);
+            Free(resource);
+            Free(room);
+            Free(jid);
+            Free(mxc);
+        }
+    }
+}
+
+bool
+IQIsCommandList(ParseeData *args, XMLElement *stanza)
+{
+    char *parsee = NULL;
+    XMLElement *query = XMLookForTKV(
+        stanza, "query", "xmlns",
+        "http://jabber.org/protocol/disco#items"
+    );
+    bool ret = false;
+
+    if (!query || 
+        !StrEquals(HashMapGet(query->attrs, "node"),
+        "http://jabber.org/protocol/commands"))
+    {
+        return false;
+    }
+
+    parsee = ParseeJID(args);
+    ret = StrEquals(HashMapGet(stanza->attrs, "to"), parsee);
+    Free(parsee);
+
+    return ret;
+}
+void
+IQGet(ParseeData *args, XMLElement *stanza, XMPPThread *thr)
+{
+    XMPPComponent *jabber = args->jabber;
+    char *from = HashMapGet(stanza->attrs, "from");
+    char *to = HashMapGet(stanza->attrs, "to");
+    char *id = HashMapGet(stanza->attrs, "id");
+
+    (void) thr;
+
+    if (IQIsCommandList(args, stanza))
+    {
+        XMLElement *iq_reply = XMLCreateTag("iq");
+        XMLAddAttr(iq_reply, "type", "result");
+        XMLAddAttr(iq_reply, "from", to);
+        XMLAddAttr(iq_reply, "to", from);
+        XMLAddAttr(iq_reply, "id", id);
+        {
+            XMLElement *q = XMLCreateTag("query");
+            XMLAddAttr(q, "xmlns", "http://jabber.org/protocol/disco#items");
+            XMLAddAttr(q, "node", "http://jabber.org/protocol/commands");
+            XMPPShoveCommandList(thr->info->m, to, q);
+            XMLAddChild(iq_reply, q);
+        }
+        pthread_mutex_lock(&jabber->write_lock);
+        XMLEncode(jabber->stream, iq_reply);
+        StreamFlush(jabber->stream);
+        pthread_mutex_unlock(&jabber->write_lock);
+        XMLFreeElement(iq_reply);
+    }
+    else if (XMLookForTKV(stanza, "vCard", "xmlns", "vcard-temp"))
+    {
+        Log(LOG_INFO, "vCard information GET for %s", to);
+
+        /* TODO: "a compliant server MUST respond on behalf of the 
+         * requestor and not forward the IQ to the requestee's 
+         * connected resource". */
+        if (!strncmp(to, "parsee@", 7))
+        {
+            XMLElement *iqVCard = XMLCreateTag("iq");
+            XMLAddAttr(iqVCard, "from", to);
+            XMLAddAttr(iqVCard, "to", from);
+            XMLAddAttr(iqVCard, "id", id);
+            XMLAddAttr(iqVCard, "type", "result");
+            {
+                XMLElement *vCard = XMLCreateTag("vCard");
+                XMLAddAttr(vCard, "xmlns", "vcard-temp");
+                {
+                    XMLElement *fn = CreateTagWithText(
+                        "FN", "Parsee Mizuhashi"
+                    );
+                    XMLElement *nick = CreateTagWithText(
+                        "NICKNAME", "Parsee"
+                    );
+                    XMLElement *url = CreateTagWithText(
+                        "URL", REPOSITORY
+                    );
+                    /* TODO: Maybe abstract the vCard code. */
+                    XMLAddChild(vCard, nick);
+                    XMLAddChild(vCard, url);
+                    XMLAddChild(vCard, fn);
+                }
+                XMLAddChild(iqVCard, vCard);
+            }
+
+            pthread_mutex_lock(&jabber->write_lock);
+            XMLEncode(jabber->stream, iqVCard);
+            StreamFlush(jabber->stream);
+            pthread_mutex_unlock(&jabber->write_lock);
+            XMLFreeElement(iqVCard);
+        }
+    }
+    else if (XMLookForTKV(stanza, "query", "xmlns", DISCO))
+    {
+        IQDiscoGet(args, jabber, stanza);
+    }
+    else if (XMLookForTKV(stanza, "query", "xmlns", "jabber:iq:version"))
+    {
+        XMLElement *iq_reply, *query;
+        XMLElement *name, *version;
+
+        iq_reply = XMLCreateTag("iq");
+        XMLAddAttr(iq_reply, "to", from);
+        XMLAddAttr(iq_reply, "from", to);
+        XMLAddAttr(iq_reply, "type", "result");
+        XMLAddAttr(iq_reply, "id", id);
+
+        query = XMLCreateTag("query");
+        XMLAddAttr(query, "xmlns", "jabber:iq:version");
+        {
+            name = XMLCreateTag("name");
+            version = XMLCreateTag("version");
+
+            XMLAddChild(name, XMLCreateText(NAME));
+            XMLAddChild(version, XMLCreateText(VERSION));
+        }
+        XMLAddChild(query, name);
+        XMLAddChild(query, version);
+        XMLAddChild(iq_reply, query);
+
+        pthread_mutex_lock(&jabber->write_lock);
+        XMLEncode(jabber->stream, iq_reply);
+        StreamFlush(jabber->stream);
+        pthread_mutex_unlock(&jabber->write_lock);
+        XMLFreeElement(iq_reply);
+    }
+    else
+    {
+        Log(LOG_WARNING, "Unknown I/Q received:");
+        XMLEncode(StreamStdout(), stanza);
+        StreamPrintf(StreamStdout(),"\n");
+        StreamFlush(StreamStdout());
+    }
+
+}
+void
+IQError(ParseeData *args, XMLElement *stanza, XMPPThread *thr)
+{
+    /* TODO */
+}
+void
+IQSet(ParseeData *args, XMLElement *stanza, XMPPThread *thr)
+{
+    XMPPCommandManager *manager = thr->info->m;
+    XMPPManageCommand(manager, stanza, args);
+}
+#undef DISCO
+
+void IQStanza(ParseeData *args, XMLElement *stanza, XMPPThread *thr)
+{
+    char *type;
+    type = HashMapGet(stanza->attrs, "type");
+#define OnType(ctyp, callback)  do \
+                                { \
+                                    if (StrEquals(type, #ctyp)) \
+                                    { \
+                                        callback(args, stanza, thr); \
+                                        return; \
+                                    } \
+                                } \
+                                while (0)
+    
+    OnType(get, IQGet);
+    OnType(set, IQSet);
+    OnType(error, IQError);
+    OnType(result, IQResult);
+#undef OnType
+}

src/XMPPThread/Stanzas/Message.c

@@ -0,0 +1,375 @@
+#include "XMPPThread/internal.h"
+
+#include <Cytoplasm/Memory.h>
+#include <Cytoplasm/Str.h>
+
+#include <Matrix.h>
+#include <AS.h>
+
+#include <string.h>
+
+bool
+MessageStanza(ParseeData *args, XMLElement *stanza, XMPPThread *thr)
+{
+    XMPPComponent *jabber = args->jabber;
+
+    XMLElement *reactions = NULL;
+    XMLElement *body = NULL;
+    XMLElement *data = NULL;
+    XMLElement *event = NULL;
+
+    char *to, *room, *from, *from_matrix, *decode_from;
+    char *mroom_id = NULL;
+    char *replaced  = XMPPGetReplacedID(stanza);
+    char *retracted = XMPPGetRetractedID(stanza);
+    char *reply_to  = XMPPGetReply(stanza);
+    char *moderated = XMPPGetModeration(stanza);
+    size_t i;
+
+    to = NULL;
+    from = NULL;
+    decode_from = NULL;
+    from_matrix = NULL;
+
+    from = HashMapGet(stanza->attrs, "from");
+    if (ParseeManageBan(args, from, NULL))
+    {
+        XMLFreeElement(stanza);
+        return false;
+    }
+
+    if (moderated)
+    {
+        /* TODO: Parsee MUST check if it is a valid MUC */
+        char *resource = ParseeGetResource(from);
+        char *chat_id = ParseeGetFromMUCID(args, from);
+        char *event_id  = NULL;
+        char *encoded = ParseeMXID(args);
+        mroom_id = ParseeGetBridgedRoom(args, stanza);
+        if (!resource && chat_id)
+        {
+            event_id = ParseeGetEventFromID(args, stanza, moderated);
+            ASRedact(args->config, mroom_id, NULL, event_id);
+            ParseePushAllStanza(args, stanza, event_id);
+            pthread_mutex_unlock(&thr->info->chk_lock);
+
+            Free(event_id);
+        }
+        Free(mroom_id);
+        Free(resource);
+        Free(encoded);
+        Free(chat_id);
+    }
+    body = XMLookForUnique(stanza, "body");
+
+    event = XMLookForTKV(stanza, "event", 
+        "xmlns", "http://jabber.org/protocol/pubsub#event"
+    );
+    if (event)
+    {
+        size_t i;
+        XMLElement *items = 
+            XMLookForTKV(event, "items", "node", "urn:xmpp:avatar:metadata");
+        if (items)
+        {
+            for (i = 0; i < ArraySize(items->children); i++)
+            {
+                ManageProfileItem(
+                    args, ArrayGet(items->children, i), 
+                    stanza, thr
+                );
+            }
+        }
+    }
+
+#define CHAT_STATES "http://jabber.org/protocol/chatstates"
+    if (XMLookForTKV(stanza, "composing", "xmlns", CHAT_STATES))
+    {
+        decode_from = ParseeLookupJID(from);
+        from_matrix = ParseeEncodeJID(args->config, decode_from, true);
+        mroom_id = ParseeGetBridgedRoom(args, stanza);
+        
+        ASType(args->config, from_matrix, mroom_id, true);
+
+        Free(decode_from);
+        Free(from_matrix);
+        Free(mroom_id);
+        mroom_id = NULL;
+        decode_from = NULL;
+        from_matrix = NULL;
+    }
+    if (XMLookForTKV(stanza, "active", "xmlns", CHAT_STATES))
+    {
+        char *latest = NULL;
+        decode_from = ParseeLookupJID(from);
+        from_matrix = ParseeEncodeJID(args->config, decode_from, true);
+        mroom_id = ParseeGetBridgedRoom(args, stanza);
+
+        latest = ParseeLookupHead(mroom_id);
+
+        ASType(args->config, from_matrix, mroom_id, false);
+        ASPresence(args->config, from_matrix, mroom_id, latest);
+
+        Free(decode_from);
+        Free(from_matrix);
+        Free(latest);
+        Free(mroom_id);
+        mroom_id = NULL;
+        decode_from = NULL;
+        from_matrix = NULL;
+    }
+    if (XMLookForTKV(stanza, "paused", "xmlns", CHAT_STATES) ||
+        XMLookForTKV(stanza, "received", "xmlns", "urn:xmpp:receipts") ||
+        XMLookForTKV(stanza, "displayed", "xmlns", "urn:xmpp:chat-markers:0"))
+    {
+        /* TODO: Use stanza ID if possible */
+        char *latest = NULL;
+        decode_from = ParseeLookupJID(from);
+        from_matrix = ParseeEncodeJID(args->config, decode_from, true);
+        mroom_id = ParseeGetBridgedRoom(args, stanza);
+
+        latest = ParseeLookupHead(mroom_id);
+
+        ASPresence(args->config, from_matrix, mroom_id, latest);
+
+        Free(decode_from);
+        Free(from_matrix);
+        Free(latest);
+        Free(mroom_id);
+        mroom_id = NULL;
+        decode_from = NULL;
+        from_matrix = NULL;
+
+    }
+#undef CHAT_STATES
+    if (!body)
+    {
+        XMLFreeElement(stanza);
+        return false;
+    }
+
+    /* TODO: On semi-anonymous MUCs, it might be preferable to use a 
+     * form of the occupant ID as the base, as it is more unique, and 
+     * less prone to trigger the character limit on Matrix. 
+     *
+     * See: https://xmpp.org/extensions/xep-0421.html */
+    to = ParseeDecodeMXID(HashMapGet(stanza->attrs, "to"));
+    decode_from = ParseeLookupJID(from);
+    from_matrix = ParseeEncodeJID(args->config, decode_from, true);
+    room = ParseeFindDMRoom(args, to, from);
+    data = ArrayGet(body->children, 0);
+
+    /* TODO: CLEAN THAT UP */
+    mroom_id = ParseeGetBridgedRoom(args, stanza);
+    if (!mroom_id && !room && !XMPPIsParseeStanza(stanza) &&
+        to && *to == '@')
+    {
+        DbRef *room_ref;
+        HashMap *room_json;
+        char *from = HashMapGet(stanza->attrs, "from");
+
+        ASRegisterUser(args->config, from_matrix);
+        room = ASCreateDM(args->config, from_matrix, to);
+        mroom_id = StrDuplicate(room);
+        if (room)
+        {
+            room_ref = DbCreate(args->db, 3, "rooms", room, "data");
+            room_json = DbJson(room_ref);
+            HashMapSet(room_json, "is_direct", JsonValueBoolean(true));
+            HashMapSet(room_json, "xmpp_user", JsonValueString(from));
+            DbUnlock(args->db, room_ref);
+            ParseePushDMRoom(args, to, from, room);
+        }
+    }
+
+    /* TODO: THIS IS A HACK. THIS CODE IGNORES ALL MUC MESSAGES EVER 
+     * SENT TO NON-PARSEE PUPPETS, AS A "FIX" TO THE MULTITHREADED 
+     * ISSUE. 
+     *
+     * I HATE THIS. I NEED TO FIND A BETTER WAY. */
+    if (!room)
+    {
+        if (strncmp(HashMapGet(stanza->attrs, "to"), "parsee@", 7))
+        {
+            goto end;
+        }
+    }
+
+    if (mroom_id && !XMPPIsParseeStanza(stanza))
+    {
+        char *res = ParseeGetResource(from);
+        char *encoded   = ParseeEncodeJID(args->config, decode_from, false);
+        char *event_id  = NULL;
+        bool chat       = false;
+
+        if (StrEquals(HashMapGet(stanza->attrs, "type"), "chat"))
+        {
+            Free(encoded);
+            encoded = StrDuplicate(from_matrix);
+            chat = true;
+        }
+
+        {
+            char *parsee = ParseeJID(args);
+
+            /* Subscribe to the sender's metadata node. */
+            XMLElement *ps = CreatePubsubRequest(
+                parsee, decode_from, "urn:xmpp:avatar:metadata"
+            );
+            pthread_mutex_lock(&jabber->write_lock);
+            XMLEncode(jabber->stream, ps);
+            StreamFlush(jabber->stream);
+            pthread_mutex_unlock(&jabber->write_lock);
+
+            XMLFreeElement(ps);
+            Free(parsee);
+        }
+
+        pthread_mutex_lock(&thr->info->chk_lock);
+        if (ParseeVerifyAllStanza(args, stanza) && !replaced)
+        {
+            XMLElement *oob, *oob_data;
+
+            pthread_mutex_unlock(&thr->info->chk_lock);
+            ASRegisterUser(args->config, encoded);
+            if (!chat)
+            {
+                ASSetName(args->config, encoded, res);
+            }
+            ASInvite(args->config, mroom_id, encoded);
+            Free(ASJoin(args->config, mroom_id, encoded));
+
+            /* Check if it is a media link */
+            oob = XMLookForTKV(stanza, "x", "xmlns", "jabber:x:oob");
+            reactions = XMLookForTKV(stanza,
+                "reactions", "xmlns", "urn:xmpp:reactions:0"
+            );
+            if (oob)
+            {
+                char *mxc, *mime = NULL;
+                HashMap *content = NULL;
+                oob_data = XMLookForUnique(oob, "url");
+                oob_data = 
+                    oob_data ? ArrayGet(oob_data->children, 0) : NULL;
+
+                if (oob_data)
+                {
+                    mxc = ASReupload(args->config, oob_data->data, &mime);
+                    content = MatrixCreateMedia(mxc, data->data, mime);
+
+                    /* Yeah, no, I'm not modifying the media creation code. */
+                    HashMapSet(content, 
+                        "at.kappach.at.parsee.external", 
+                        JsonValueString(oob_data->data)
+                    );
+                    ShoveStanza(content, stanza);
+
+                    event_id = ASSend(
+                        args->config, mroom_id, encoded, 
+                        "m.room.message", content
+                    );
+                    Free(mime);
+                    Free(mxc);
+                }
+            }
+            else if (reactions)
+            {
+                Array *react_child = reactions->children;
+                size_t reacts = ArraySize(react_child);
+                event_id = ParseeGetReactedEvent(args, stanza);
+                for (i = 0; i < reacts; i++)
+                {
+                    XMLElement *reaction, *react_data;
+                    reaction = ArrayGet(react_child, i);
+                    react_data = ArrayGet(reaction->children, 0);
+
+                    /* TODO: We should manage removed reactions. */
+                    Free(ASSend(
+                        args->config, mroom_id, encoded, 
+                        "m.reaction", 
+                        ShoveStanza(
+                            MatrixCreateReact(event_id, react_data->data),
+                            stanza
+                        )
+                    ));
+                }
+                Free(event_id);
+                event_id = NULL;
+            }
+            else if (retracted)
+            {
+                event_id = ParseeGetEventFromID(args, stanza, retracted);
+                ASRedact(args->config, mroom_id, encoded, event_id);
+                ParseePushAllStanza(args, stanza, event_id);
+                pthread_mutex_unlock(&thr->info->chk_lock);
+
+                Free(event_id);
+                event_id = NULL;
+            }
+            else
+            {
+                /* TODO: Use HTML-formatted bodies, and respect the fallback 
+                 * trims the stanza provides us if possible. Element does not 
+                 * like raw bodies on replies too. Go figure. */
+                size_t off = 
+                    reply_to ? ParseeFindDatastart(data->data) : 0;
+                HashMap *ev = MatrixCreateMessage(data->data + off);
+                if (reply_to)
+                {
+                    char *reply_id = ParseeGetEventFromID(args, stanza, reply_to);
+                    MatrixSetReply(ev, reply_id);
+                    Free(reply_id);
+                }
+                ShoveStanza(ev, stanza);
+                event_id = ASSend(
+                    args->config, mroom_id, encoded, 
+                    "m.room.message", ev
+                );
+            }
+            pthread_mutex_lock(&thr->info->chk_lock);
+            ParseePushAllStanza(args, stanza, event_id);
+            Free(event_id);
+            pthread_mutex_unlock(&thr->info->chk_lock);
+        }
+        else if (replaced)
+        {
+            event_id = ParseeGetEventFromID(args, stanza, replaced);
+            Free(ASSend(
+                args->config, mroom_id, encoded, 
+                "m.room.message", 
+                ShoveStanza(MatrixCreateReplace(event_id, data->data), stanza)
+            ));
+            ParseePushAllStanza(args, stanza, event_id);
+            pthread_mutex_unlock(&thr->info->chk_lock);
+
+            Free(event_id);
+        }
+        else
+        {
+            pthread_mutex_unlock(&thr->info->chk_lock);
+        }
+        Free(res);
+        Free(encoded);
+    }
+    else
+    {
+        XMLElement *parsee = XMLookForUnique(stanza, "x-parsee");
+        XMLElement *event = XMLookForUnique(parsee, "event-id");
+        XMLElement *e_d = ArrayGet(event ? event->children : NULL, 0);
+
+        if (e_d)
+        {
+            ParseePushAllStanza(args, stanza, e_d->data);
+        }
+    }
+end:
+    Free(mroom_id);
+    mroom_id = NULL;
+    Free(from_matrix);
+    Free(decode_from);
+    Free(room);
+    Free(to);
+
+    return true;
+}
+

src/XMPPThread/Stanzas/Presence.c

@@ -0,0 +1,258 @@
+#include "XMPPThread/internal.h"
+
+#include <Cytoplasm/Memory.h>
+#include <Cytoplasm/Str.h>
+#include <Cytoplasm/Log.h>
+
+#include <Matrix.h>
+#include <AS.h>
+
+#include <string.h>
+
+static XMLElement *
+CreateVCardRequest(char *from, char *to)
+{
+    XMLElement *vcard_request, *vcard;
+    char *id;
+    vcard_request = XMLCreateTag("iq");
+    XMLAddAttr(vcard_request, "from", from);
+    XMLAddAttr(vcard_request, "to", to);
+    XMLAddAttr(vcard_request, "id", (id = StrRandom(16)));
+    XMLAddAttr(vcard_request, "type", "get");
+
+    vcard = XMLCreateTag("vCard");
+    XMLAddAttr(vcard, "xmlns", "vcard-temp");
+    XMLAddChild(vcard_request, vcard);
+
+    Free(id);
+
+    return vcard_request;
+}
+
+static UserStatus
+GuessStatus(XMLElement *stanza)
+{
+    /* C.F RFC3921: XMPP IM */
+    XMLElement *show = XMLookForUnique(stanza, "show");
+    XMLElement *data = show ? ArrayGet(show->children, 0) : NULL;
+
+    if (!show || !data)
+    {
+        return USER_STATUS_ONLINE;
+    }
+
+    if (StrEquals(data->data, "away") ||
+        StrEquals(data->data, "xa"))
+    {
+        return USER_STATUS_OFFLINE;
+    }
+    if (StrEquals(data->data, "chat"))
+    {
+        return USER_STATUS_ONLINE;
+    }
+    if (StrEquals(data->data, "dnd"))
+    {
+        return USER_STATUS_UNAVAILABLE;
+    }
+    return USER_STATUS_ONLINE;
+}
+void
+PresenceStanza(ParseeData *args, XMLElement *stanza)
+{
+#define MUC_USER_NS "http://jabber.org/protocol/muc#user"
+    XMLElement *user_info;
+    XMLElement *vc = XMLookForTKV(stanza, "x", "xmlns", "vcard-temp:x:update");
+    XMLElement *status = XMLookForUnique(stanza, "status");
+    char *oid = HashMapGet(stanza->attrs, "from");
+
+    if ((user_info = XMLookForTKV(stanza, "x", "xmlns", MUC_USER_NS)))
+    {
+        XMLElement *item = XMLookForUnique(user_info, "item");
+        XMLElement *status = XMLookForUnique(user_info, "status");
+#define IsStatus(code) (status && \
+                        StrEquals(HashMapGet(status->attrs, "code"), #code))
+        char *jid = item ? HashMapGet(item->attrs, "jid") : NULL;
+        char *trim = ParseeTrimJID(jid);
+        char *from = NULL;
+        char *type = HashMapGet(stanza->attrs, "type");
+        char *room = ParseeGetBridgedRoom(args, stanza);
+        char *decode_from = ParseeLookupJID(oid);
+        char *real_matrix = ParseeDecodeMXID(decode_from);
+        char *matrix_user_pl = ParseeEncodeJID(args->config, trim, false);
+        char *affiliation = HashMapGet(item->attrs, "affiliation");
+        int power_level = 0;
+        char *parsee = ParseeMXID(args);
+
+        Free(trim);
+
+        if (!real_matrix || *real_matrix != '@')
+        {
+            Free(real_matrix);
+            real_matrix = ParseeEncodeJID(args->config, decode_from, false);
+        }
+
+        if (StrEquals(affiliation, "owner"))
+        {
+            power_level = 98;
+        }
+        else if (StrEquals(affiliation, "admin"))
+        {
+            power_level = 50;
+        }
+        else if (StrEquals(affiliation, "member"))
+        {
+            /* TODO: Reconsider setting the PL if a member, as there's no 
+             * clear reason to do this in some cases. */
+            power_level = 0;
+        }
+        else if (StrEquals(affiliation, "outcast"))
+        {
+            power_level = -1;
+        }
+
+        /* Set the user's PL
+         * TODO: Do NOT change the PL of *real* people nilly-willy.
+         * In some scenarios, this is really bad behaviour. */
+        if (room)
+        {
+            HashMap *powers = ASGetPL(args->config, room);
+            HashMap *users = GrabObject(powers, 1, "users");
+            int64_t level = GrabInteger(powers, 2, "users", matrix_user_pl);
+
+            /* I may or may not have fucked up the state hard with this
+             * lacking any checking. (--gen) */
+            if (StrEquals(parsee, matrix_user_pl))
+            {
+                /* TODO: Give the user an achievement, this is goofy. */
+                Log(LOG_ERR, "BAD PL DOWNGRADE (%d->%d)", level, power_level);
+            }
+            if (users && level != power_level && 
+                !StrEquals(parsee, matrix_user_pl) &&
+                matrix_user_pl)
+            {
+                JsonValue *val = JsonValueInteger(power_level);
+                JsonValueFree(JsonSet(users, val, 1, matrix_user_pl));
+                ASSetPL(args->config, room, powers);
+            }
+            else
+            {
+                JsonFree(powers);
+            }
+        }
+
+
+        if (StrEquals(type, "unavailable") && !StrEquals(parsee, real_matrix))
+        {
+            /* If not an MXID, use the Parsee user */
+            if (IsStatus(301))
+            {
+                ASBan(args->config, room, real_matrix);
+            }
+            else if (IsStatus(307))
+            {
+                ASKick(args->config, room, real_matrix);
+            }
+            else if (IsStatus(303))
+            {
+                char *nick = HashMapGet(item->attrs, "nick");
+                ASSetName(args->config, real_matrix, nick);
+            }
+            else
+            {
+                ASLeave(args->config, room, real_matrix);
+            }
+        }
+
+        if (jid)
+        {
+            ParseePushJIDTable(oid, jid);
+        }
+
+        Free(from);
+        Free(decode_from);
+        Free(real_matrix);
+        Free(matrix_user_pl);
+        Free(parsee);
+        Free(room);
+    }
+    if (status)
+    {
+        XMLElement *status_data = ArrayGet(status->children, 0);
+        char *decode_from = ParseeLookupJID(oid);
+        char *trimmed = ParseeTrimJID(decode_from);
+        char *from_matrix = ParseeEncodeJID(args->config, trimmed, false);
+        char *status_str = NULL;
+        if (status_data)
+        {
+            status_str = status_data->data;
+        }
+
+        /* TODO: "The server will automatically set a user's presence to 
+         * unavailable if their last active time was over a threshold value 
+         * (e.g. 5 minutes)."
+         * We _will_ need to manage those cases properly(cronjob?) if we want 
+         * XMPP presences to sync properly */
+        ASSetStatus(
+            args->config, from_matrix, 
+            GuessStatus(stanza), status_str
+        );
+
+        Free(decode_from);
+        Free(from_matrix);
+        Free(trimmed);
+    }
+    if (vc)
+    {
+        XMLElement *photo = XMLookForUnique(vc, "photo");
+        XMLElement *p_dat = photo ? ArrayGet(photo->children, 0) : NULL;
+        XMLElement *vcard_request;
+        XMPPComponent *jabber = args->jabber;
+        char *from;
+
+        DbRef *avatars;
+        HashMap *json;
+        char *avatar_id;
+
+        if (!p_dat)
+        {
+            return;
+        }
+
+        avatars = DbLock(args->db, 1, "avatars");
+        if (!avatars)
+        {
+            avatars = DbCreate(args->db, 1, "avatars");
+        }
+        json = DbJson(avatars);
+
+        avatar_id = GrabString(json, 1, oid);
+        if (avatar_id && StrEquals(avatar_id, p_dat->data))
+        {
+            DbUnlock(args->db, avatars);
+            return;
+        }
+        JsonValueFree(JsonSet(
+            json, JsonValueString(p_dat->data),
+            1, oid)
+        );
+
+        DbUnlock(args->db, avatars);
+
+        from = ParseeJID(args);
+
+        vcard_request = CreateVCardRequest(
+            from, HashMapGet(stanza->attrs, "from")
+        );
+        pthread_mutex_lock(&jabber->write_lock);
+        XMLEncode(jabber->stream, vcard_request);
+        StreamFlush(jabber->stream);
+        pthread_mutex_unlock(&jabber->write_lock);
+
+        XMLFreeElement(vcard_request);
+        Free(from);
+    }
+
+    /* TODO: Sending VCard on presence is slow and stalls the thread */
+#undef MUC_USER_NS
+}
+