1 files changed, 312 insertions, 21 deletions

diff --git a/html.c b/html.c
index 20ad839..3f5435c 100644
--- a/html.c
+++ b/html.c
@@ -1,5 +1,5 @@
 /* snac - A simple, minimalistic ActivityPub instance */
-/* copyright (c) 2022 - 2025 grunfink et al. / MIT license */
+/* copyright (c) 2022 - 2026 grunfink et al. / MIT license */
 
 #include "xs.h"
 #include "xs_io.h"
@@ -16,6 +16,7 @@
 #include "xs_url.h"
 #include "xs_random.h"
 #include "xs_http.h"
+#include "xs_list_tools.h"
 
 #include "snac.h"
 
@@ -161,6 +162,34 @@ xs_str *actor_name(xs_dict *actor, const char *proxy)
 }
 
 
+xs_str *actor_pronouns(xs_dict *actor)
+/* gets the actor name */
+{
+    const xs_list *attachment;
+    const xs_dict *d;
+    const char *v;
+    const char *pronouns = "";
+    xs_str *ret;
+
+    if (xs_is_list((attachment = xs_dict_get(actor, "attachment")))) {
+        xs_list_foreach(attachment, d) {
+            xs *prop = xs_utf8_to_lower(xs_dict_get(d, "name"));
+            /* make sure that we are reading the correct metadata */
+            if (strlen(prop) == 8 && strcmp(prop, "pronouns") == 0) {
+                /* safeguard from NULL values */
+                v = xs_dict_get(d, "value");
+                pronouns = v ? v : pronouns;
+                break;
+            }
+        }
+    }
+
+    /* strip all HTML tags */
+    ret = xs_regex_replace(pronouns, "</?[^>]+>", "");
+    return ret;
+}
+
+
 xs_str *format_text_with_emoji(snac *user, const char *text, int ems, const char *proxy)
 /* needed when we have local text with no tags attached */
 {
@@ -194,6 +223,7 @@ xs_html *html_actor_icon(snac *user, xs_dict *actor, const char *date,
     int fwer = 0;
 
     xs *name = actor_name(actor, proxy);
+    xs *pronouns = actor_pronouns(actor);
 
     /* get the avatar */
     if ((v = xs_dict_get(actor, "icon")) != NULL) {
@@ -221,23 +251,35 @@ xs_html *html_actor_icon(snac *user, xs_dict *actor, const char *date,
            anchored link to the people page instead of the actor url */
         if (fwer || fwing) {
             xs *md5 = xs_md5_hex(actor_id, strlen(actor_id));
-            href = xs_fmt("%s/people#%s", user->actor, md5);
+            href = xs_fmt("%s/people/%s", user->actor, md5);
         }
     }
 
     if (href == NULL)
         href = xs_dup(actor_id);
 
+    xs_html *name_link = xs_html_tag("a",
+            xs_html_attr("href",    href),
+            xs_html_attr("class",   "p-author h-card snac-author"),
+            xs_html_raw(name)); /* name is already html-escaped */
+
+    if (*pronouns) {
+        xs_html_add(name_link,
+            xs_html_text(" ["),
+            xs_html_tag("span",
+                xs_html_attr("class",   "snac-pronouns"),
+                xs_html_attr("title",   "user's pronouns"),
+                xs_html_raw(pronouns)),
+            xs_html_text("]"));
+    }
+
     xs_html_add(actor_icon,
         xs_html_sctag("img",
             xs_html_attr("loading", "lazy"),
             xs_html_attr("class",   "snac-avatar"),
             xs_html_attr("src",     avatar),
             xs_html_attr("alt",     "[?]")),
-        xs_html_tag("a",
-            xs_html_attr("href",    href),
-            xs_html_attr("class",   "p-author h-card snac-author"),
-            xs_html_raw(name))); /* name is already html-escaped */
+        name_link);
 
     if (!xs_is_null(url)) {
         xs *md5 = xs_md5_hex(url, strlen(url));
@@ -250,6 +292,7 @@ xs_html *html_actor_icon(snac *user, xs_dict *actor, const char *date,
                 xs_html_text("»")));
     }
 
+
     if (strcmp(xs_dict_get(actor, "type"), "Service") == 0) {
         xs_html_add(actor_icon,
             xs_html_text(" "),
@@ -1864,6 +1907,38 @@ xs_html *html_top_controls(snac *user)
                     xs_html_attr("class", "button"),
                     xs_html_attr("value", L("Update hashtags")))))));
 
+    xs *muted_words_action = xs_fmt("%s/admin/muted-words", user->actor);
+    xs *muted_words = xs_join(xs_dict_get_def(user->config,
+                        "muted_words", xs_stock(XSTYPE_LIST)), "\n");
+
+    xs_html_add(top_controls,
+        xs_html_tag("details",
+        xs_html_tag("summary",
+            xs_html_text(L("Muted words..."))),
+        xs_html_tag("p",
+            xs_html_text(L("One word per line, partial matches count"))),
+        xs_html_tag("div",
+            xs_html_attr("class", "snac-muted-words"),
+            xs_html_tag("form",
+                xs_html_attr("autocomplete", "off"),
+                xs_html_attr("method", "post"),
+                xs_html_attr("action", muted_words_action),
+                xs_html_attr("enctype", "multipart/form-data"),
+
+                xs_html_tag("textarea",
+                    xs_html_attr("name", "muted_words"),
+                    xs_html_attr("cols", "40"),
+                    xs_html_attr("rows", "4"),
+                    xs_html_attr("placeholder", "nascar\nsuperbowl\nFIFA"),
+                    xs_html_text(muted_words)),
+
+                xs_html_tag("br", NULL),
+
+                xs_html_sctag("input",
+                    xs_html_attr("type", "submit"),
+                    xs_html_attr("class", "button"),
+                    xs_html_attr("value", L("Update muted words")))))));
+
     return top_controls;
 }
 
@@ -2103,7 +2178,7 @@ xs_html *html_entry_controls(snac *user, const char *actor,
             xs_html_tag("p", NULL));
     }
 
-    { /** emoji react **/
+    if (!xs_is_true(xs_dict_get(srv_config, "disable_emojireact"))) { /** emoji react **/
         /* the post textarea */
         xs *div_id  = xs_fmt("%s_reply", md5);
         xs *form_id = xs_fmt("%s_reply_form", md5);
@@ -2144,6 +2219,30 @@ xs_html *html_entry_controls(snac *user, const char *actor,
 }
 
 
+static const xs_str* words_in_content(const xs_list *words, const xs_val *content)
+/* returns a word that matches any of the words in content */
+{
+    if (!xs_is_list(words) || !xs_is_string(content)) {
+            return NULL;
+    }
+    xs *c = xs_split(content, " ");
+    xs *sc = xs_list_sort(c, NULL);
+
+    const xs_str *wv;
+    const xs_str *cv;
+    xs_list_foreach(words, wv) {
+        xs_list_foreach(sc, cv) {
+            xs_tolower_i((xs_str*)cv);
+            if(xs_str_in(cv, wv) != -1){
+                return wv;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+
 xs_html *html_entry(snac *user, xs_dict *msg, int read_only,
                    int level, const char *md5, int hide_children)
 {
@@ -2355,7 +2454,7 @@ xs_html *html_entry(snac *user, xs_dict *msg, int read_only,
                 }
 
                 if (!read_only && (fwers || fwing))
-                    href = xs_fmt("%s/people#%s", user->actor, p);
+                    href = xs_fmt("%s/people/%s", user->actor, p);
                 else
                     href = xs_dup(id);
 
@@ -2438,6 +2537,17 @@ xs_html *html_entry(snac *user, xs_dict *msg, int read_only,
                 xs_html_text(v),
                 xs_html_text(L(" [SENSITIVE CONTENT]"))));
     }
+    else
+    if (user &&
+        /* muted_words is all lowercase and sorted for performance */
+        (v = words_in_content(xs_dict_get(user->config, "muted_words"),
+                              xs_dict_get(msg, "content"))) != NULL) {
+        snac_debug(user, 1, xs_fmt("word %s muted by user preferences: %s", v, id));
+        snac_content = xs_html_tag("details",
+            xs_html_tag("summary",
+                xs_html_text(L("Muted: ")),
+                xs_html_text(v)));
+    }
     else {
         snac_content = xs_html_tag("div", NULL);
     }
@@ -2447,7 +2557,7 @@ xs_html *html_entry(snac *user, xs_dict *msg, int read_only,
 
     /* add all emoji reacts */
     int is_emoji = 0;
-    {
+    if (!xs_is_true(xs_dict_get(srv_config, "disable_emojireact"))) {
         int c = 0;
         const xs_dict *k;
         xs *ls = xs_list_new();
@@ -2460,6 +2570,10 @@ xs_html *html_entry(snac *user, xs_dict *msg, int read_only,
                 const char *content = xs_dict_get(m, "content");
                 const char *actor = xs_dict_get(m, "actor");
                 const xs_list *contentl = xs_dict_get(sfrl, content);
+
+                if ((user && is_muted(user, actor)) || is_instance_blocked(actor))
+                    continue;
+
                 xs *actors = xs_list_new();
                 actors = xs_list_append(actors, actor);
                 char me = actor && user && strcmp(actor, user->actor) == 0;
@@ -3593,13 +3707,19 @@ xs_str *html_timeline(snac *user, const xs_list *list, int read_only,
 }
 
 
-xs_html *html_people_list(snac *user, xs_list *list, const char *header, const char *t, const char *proxy)
+xs_html *html_people_list(snac *user, xs_list *list, const char *header, const char *t, const char *proxy, int do_count)
 {
     xs_html *snac_posts;
+    xs *header_cnt;
+    if (do_count)
+        header_cnt = xs_fmt("%s - %d\n", header, xs_list_len(list));
+    else
+        header_cnt = xs_fmt("%s\n", header);
+
     xs_html *people = xs_html_tag("div",
         xs_html_tag("h2",
             xs_html_attr("class", "snac-header"),
-            xs_html_text(header)),
+            xs_html_text(header_cnt)),
         snac_posts = xs_html_tag("details",
                 xs_html_attr("open", NULL),
                 xs_html_tag("summary",
@@ -3840,12 +3960,12 @@ xs_str *html_people(snac *user)
 
     if (xs_list_len(pending) || xs_is_true(xs_dict_get(user->config, "approve_followers"))) {
         xs_html_add(lists,
-            html_people_list(user, pending, L("Pending follow confirmations"), "p", proxy));
+            html_people_list(user, pending, L("Pending follow confirmations"), "p", proxy, 1));
     }
 
     xs_html_add(lists,
-        html_people_list(user, wing, L("People you follow"), "i", proxy),
-        html_people_list(user, wers, L("People that follow you"), "e", proxy));
+        html_people_list(user, wing, L("People you follow"), "i", proxy, 1),
+        html_people_list(user, wers, L("People that follow you"), "e", proxy, 1));
 
     xs_html *html = xs_html_tag("html",
         html_user_head(user, NULL, NULL),
@@ -3856,6 +3976,108 @@ xs_str *html_people(snac *user)
     return xs_html_render_s(html, "<!DOCTYPE html>\n");
 }
 
+/* Filter list to display only posts by actor.  We'll probably show
+   fewer than show posts.  Should we try harder to find some?  */
+xs_str *html_people_one(snac *user, const char *actor, const xs_list *list,
+                        int skip, int show, int show_more, const char *page)
+{
+    const char *proxy = NULL;
+    xs_list *p = (xs_list *)list;
+    const char *v;
+
+    if (xs_is_true(xs_dict_get(srv_config, "proxy_media")))
+        proxy = user->actor;
+
+    xs_html *body = html_user_body(user, 0);
+
+    xs_html *lists = xs_html_tag("div",
+        xs_html_attr("class", "snac-posts"));
+
+    xs *foll = xs_list_append(xs_list_new(), actor);
+
+    xs_html_add(lists,
+        html_people_list(user, foll, L("Contact's posts"), "p", proxy, 0));
+
+    xs_html_add(body, lists);
+
+    while (xs_list_iter(&p, &v)) {
+        xs *msg = NULL;
+        int status;
+
+        status = timeline_get_by_md5(user, v, &msg);
+
+        if (!valid_status(status))
+            continue;
+
+        const char *id = xs_dict_get(msg, "id");
+        const char *by = get_atto(msg);
+        xs *actor_md5 = NULL;
+        xs_list *boosts = NULL;
+        xs_list *likes = NULL;
+        xs_list *reacts = NULL;
+        /* Besides actor's posts, also show actor's boosts, and also
+           posts by user with likes or reacts by actor.  I.e., any
+           actor's actions that user could have seen in the timeline
+           or in notifications.  */
+        if (!(by && strcmp(actor, by) == 0) &&
+            xs_list_in((boosts = object_announces(id)),
+                       (actor_md5 = xs_md5_hex(actor, strlen(actor)))) == -1 &&
+            (!(by && strcmp(user->actor, by) == 0) ||
+             (xs_list_in((likes = object_likes(id)), actor_md5) == -1 &&
+              xs_list_in((reacts = object_get_emoji_reacts(id)), actor_md5) == -1)))
+            continue;
+
+        xs_html *entry = html_entry(user, msg, 0, 0, v, 1);
+
+        if (entry != NULL)
+            xs_html_add(lists,
+                entry);
+    }
+
+    if (show_more) {
+        xs *m  = NULL;
+        xs *m10  = NULL;
+        xs *ss = xs_fmt("skip=%d&show=%d", skip + show, show);
+
+        xs *url = xs_dup(user == NULL ? srv_baseurl : user->actor);
+
+        if (page != NULL)
+            url = xs_str_cat(url, page);
+
+        if (xs_str_in(url, "?") != -1)
+            m = xs_fmt("%s&%s", url, ss);
+        else
+            m = xs_fmt("%s?%s", url, ss);
+
+        m10 = xs_fmt("%s0", m);
+
+        xs_html *more_links = xs_html_tag("p",
+            xs_html_tag("a",
+                xs_html_attr("href", url),
+                xs_html_attr("name", "snac-more"),
+                xs_html_text(L("Back to top"))),
+            xs_html_text(" - "),
+            xs_html_tag("a",
+                xs_html_attr("href", m),
+                xs_html_attr("name", "snac-more"),
+                xs_html_text(L("More..."))),
+            xs_html_text(" - "),
+            xs_html_tag("a",
+                xs_html_attr("href", m10),
+                xs_html_attr("name", "snac-more"),
+                xs_html_text(L("More (x 10)..."))));
+
+        xs_html_add(body,
+            more_links);
+    }
+
+    xs_html *html = xs_html_tag("html",
+        html_user_head(user, NULL, NULL),
+        xs_html_add(body,
+            html_footer(user)));
+
+    return xs_html_render_s(html, "<!DOCTYPE html>\n");
+}
 
 xs_str *html_notifications(snac *user, int skip, int show)
 {
@@ -3924,6 +4146,9 @@ xs_str *html_notifications(snac *user, int skip, int show)
         if (xs_is_string(id2) && xs_set_add(&rep, id2) != 1)
             continue;
 
+        if (strcmp(type, "EmojiReact") == 0 && xs_is_true(xs_dict_get(srv_config, "disable_emojireact")))
+            continue;
+
         object_get(id, &obj);
 
         const char *msg_id = NULL;
@@ -4271,8 +4496,12 @@ int html_get_handler(const xs_dict *req, const char *q_path,
         cache = 0;
 
     int skip = 0;
+    const char *max_show_default = "50";
+    int max_show = xs_number_get(xs_dict_get_def(srv_config, "max_timeline_entries",
+                                 max_show_default));
     int def_show = xs_number_get(xs_dict_get_def(srv_config, "def_timeline_entries",
-                                 xs_dict_get_def(srv_config, "max_timeline_entries", "50")));
+                                 xs_dict_get_def(srv_config, "max_timeline_entries",
+                                 max_show_default)));
     int show = def_show;
 
     if ((v = xs_dict_get(q_vars, "skip")) != NULL)
@@ -4298,6 +4527,8 @@ int html_get_handler(const xs_dict *req, const char *q_path,
     /* a show of 0 has no sense */
     if (show == 0)
         show = def_show;
+    if (show > max_show)
+        show = max_show;
 
     if (p_path == NULL) { /** public timeline **/
         xs *h = xs_str_localtime(0, "%Y-%m.html");
@@ -4343,12 +4574,14 @@ int html_get_handler(const xs_dict *req, const char *q_path,
             status = HTTP_STATUS_UNAUTHORIZED;
         }
         else {
-            xs *q = NULL;
-            const char *q1 = xs_dict_get(q_vars, "q");
+            const char *q = NULL;
+            xs *cq = xs_dup(xs_dict_get(q_vars, "q"));
             xs *url_acct = NULL;
 
-            if (xs_is_string(q1))
-                q = xs_strip_i(xs_dup(q1));
+            if (xs_is_string(cq)) {
+                cq = xs_strip_i(cq);
+                q = cq;
+            }
 
             /* searching for an URL? */
             if (q && xs_match(q, "https://*|http://*")) {
@@ -4413,11 +4646,11 @@ int html_get_handler(const xs_dict *req, const char *q_path,
                             actor_add(actor, actor_obj);
 
                             /* create a people list with only one element */
-                            l = xs_list_append(xs_list_new(), actor);
+                            l = xs_list_append(l, actor);
 
                             xs *title = xs_fmt(L("Search results for account %s"), q);
 
-                            page = html_people_list(&snac, l, title, "wf", NULL);
+                            page = html_people_list(&snac, l, title, "wf", NULL, 1);
                         }
                     }
 
@@ -4553,6 +4786,37 @@ int html_get_handler(const xs_dict *req, const char *q_path,
         }
     }
     else
+    if (xs_startswith(p_path, "people/")) { /** a single actor **/
+        if (!login(&snac, req)) {
+            *body  = xs_dup(uid);
+            status = HTTP_STATUS_UNAUTHORIZED;
+        }
+        else {
+            xs *actor_dict = NULL;
+            const char *actor_id = NULL;
+            xs *actor = NULL;
+            xs_list *page_lst = xs_split_n(p_path, "?", 2);
+            xs *page = xs_str_cat(xs_str_new("/"), xs_list_get(page_lst, 0));
+            xs_list *l = xs_split_n(page, "/", 3);
+            const char *actor_md5 = xs_list_get(l, 2);
+
+            if (valid_status(object_get_by_md5(actor_md5, &actor_dict)) &&
+               (actor_id = xs_dict_get(actor_dict, "id")) != NULL &&
+               valid_status(actor_get(actor_id, &actor))) {
+                int more = 0;
+                xs *list = timeline_simple_list(&snac, "private", skip, show, &more);
+
+                *body   = html_people_one(&snac, actor_id, list, skip, show, more, page);
+                *b_size = strlen(*body);
+                status  = HTTP_STATUS_OK;
+            }
+            else {
+                *body = xs_dup(uid);
+                status = HTTP_STATUS_NOT_FOUND;
+            }
+        }
+    }
+    else
     if (strcmp(p_path, "notifications") == 0) { /** the list of notifications **/
         if (!login(&snac, req)) {
             *body  = xs_dup(uid);
@@ -5665,6 +5929,33 @@ int html_post_handler(const xs_dict *req, const char *q_path,
 
         status = HTTP_STATUS_SEE_OTHER;
     }
+    else
+    if (p_path && strcmp(p_path, "admin/muted-words") == 0) {
+        const char *words = xs_dict_get(p_vars, "muted_words");
+
+        if (xs_is_string(words)) {
+            xs *new_words = xs_list_new();
+            xs *l = xs_split(words, "\n");
+            const char *v;
+
+            xs_list_foreach(l, v) {
+                xs *s1 = xs_strip_i(xs_dup(v));
+                s1 = xs_replace_i(s1, " ", "");
+
+                if (*s1 == '\0')
+                    continue;
+
+                xs *s2 = xs_utf8_to_lower(s1);
+
+                new_words = xs_list_insert_sorted(new_words, s2);
+            }
+
+            snac.config = xs_dict_set(snac.config, "muted_words", new_words);
+            user_persist(&snac, 0);
+        }
+
+        status = HTTP_STATUS_SEE_OTHER;
+    }
 
     if (status == HTTP_STATUS_SEE_OTHER) {
         const char *hard_redir = xs_dict_get(p_vars, "hard-redir");