"); c = xs_str_cat(c, "
");
/* replace the :shortnames: */
c = replace_shortnames(c, xs_dict_get(msg, "tag"), 2, proxy);
/* Peertube videos content is in markdown */
const char *mtype = xs_dict_get(msg, "mediaType");
if (xs_type(mtype) == XSTYPE_STRING && strcmp(mtype, "text/markdown") == 0) {
/* a full conversion could be better */
c = xs_replace_i(c, "\r", "");
c = xs_replace_i(c, "\n", "
");
}
/* c contains sanitized HTML */
xs_html_add(snac_content,
xs_html_raw(c));
}
if (strcmp(type, "Question") == 0) { /** question content **/
const xs_list *oo = xs_dict_get(msg, "oneOf");
const xs_list *ao = xs_dict_get(msg, "anyOf");
const xs_list *p;
const xs_dict *v;
int closed = 0;
const char *f_closed = NULL;
xs_html *poll = xs_html_tag("div", NULL);
if (read_only)
closed = 1; /* non-identified page; show as closed */
else
if (user && xs_startswith(id, user->actor))
closed = 1; /* we questioned; closed for us */
else
if (user && was_question_voted(user, id))
closed = 1; /* we already voted; closed for us */
if ((f_closed = xs_dict_get(msg, "closed")) != NULL) {
/* it has a closed date... but is it in the past? */
time_t t0 = time(NULL);
time_t t1 = xs_parse_iso_date(f_closed, 0);
if (t1 < t0)
closed = 2;
}
/* get the appropriate list of options */
p = oo != NULL ? oo : ao;
if (closed || user == NULL) {
/* closed poll */
xs_html *poll_result = xs_html_tag("table",
xs_html_attr("class", "snac-poll-result"));
int c = 0;
while (xs_list_next(p, &v, &c)) {
const char *name = xs_dict_get(v, "name");
const xs_dict *replies = xs_dict_get(v, "replies");
if (name && replies) {
char *ti = (char *)xs_number_str(xs_dict_get(replies, "totalItems"));
xs_html_add(poll_result,
xs_html_tag("tr",
xs_html_tag("td",
xs_html_text(name),
xs_html_text(":")),
xs_html_tag("td",
xs_html_text(ti))));
}
}
xs_html_add(poll,
poll_result);
}
else {
/* poll still active */
xs *vote_action = xs_fmt("%s/admin/vote", user->actor);
xs_html *form;
xs_html *poll_form = xs_html_tag("div",
xs_html_attr("class", "snac-poll-form"),
form = xs_html_tag("form",
xs_html_attr("autocomplete", "off"),
xs_html_attr("method", "post"),
xs_html_attr("action", vote_action),
xs_html_sctag("input",
xs_html_attr("type", "hidden"),
xs_html_attr("name", "actor"),
xs_html_attr("value", actor)),
xs_html_sctag("input",
xs_html_attr("type", "hidden"),
xs_html_attr("name", "irt"),
xs_html_attr("value", id))));
int c = 0;
while (xs_list_next(p, &v, &c)) {
const char *name = xs_dict_get(v, "name");
const xs_dict *replies = xs_dict_get(v, "replies");
if (name) {
char *ti = (char *)xs_number_str(xs_dict_get(replies, "totalItems"));
xs_html *btn = xs_html_sctag("input",
xs_html_attr("id", name),
xs_html_attr("value", name),
xs_html_attr("name", "question"));
if (!xs_is_null(oo)) {
xs_html_add(btn,
xs_html_attr("type", "radio"),
xs_html_attr("required", "required"));
}
else
xs_html_add(btn,
xs_html_attr("type", "checkbox"));
xs_html_add(form,
btn,
xs_html_text(" "),
xs_html_tag("span",
xs_html_attr("title", ti),
xs_html_text(name)),
xs_html_sctag("br", NULL));
}
}
xs_html_add(form,
xs_html_tag("p", NULL),
xs_html_sctag("input",
xs_html_attr("type", "submit"),
xs_html_attr("class", "button"),
xs_html_attr("value", L("Vote"))));
xs_html_add(poll,
poll_form);
}
/* if it's *really* closed, say it */
if (closed == 2) {
xs_html_add(poll,
xs_html_tag("p",
xs_html_text(L("Closed"))));
}
else {
/* show when the poll closes */
const char *end_time = xs_dict_get(msg, "endTime");
/* Pleroma does not have an endTime field;
it has a closed time in the future */
if (xs_is_null(end_time))
end_time = xs_dict_get(msg, "closed");
if (!xs_is_null(end_time)) {
time_t t0 = time(NULL);
time_t t1 = xs_parse_iso_date(end_time, 0);
if (t1 > 0 && t1 > t0) {
time_t diff_time = t1 - t0;
xs *tf = xs_str_time_diff(diff_time);
char *p = tf;
/* skip leading zeros */
for (; *p == '0' || *p == ':'; p++);
xs_html_add(poll,
xs_html_tag("p",
xs_html_text(L("Closes in")),
xs_html_text(" "),
xs_html_text(p)));
}
}
}
xs_html_add(snac_content,
poll);
}
/** attachments **/
xs *attach = get_attachments(msg);
{
/* make custom css for attachments easier */
xs_html *content_attachments = xs_html_tag("div",
xs_html_attr("class", "snac-content-attachments"));
xs_html_add(snac_content,
content_attachments);
const char *content = xs_dict_get(msg, "content");
int c = 0;
const xs_dict *a;
while (xs_list_next(attach, &a, &c)) {
const char *type = xs_dict_get(a, "type");
const char *o_href = xs_dict_get(a, "href");
const char *name = xs_dict_get(a, "name");
/* if this image is already in the post content, skip */
if (content && xs_str_in(content, o_href) != -1)
continue;
xs *href = make_url(o_href, proxy, 0);
if (xs_startswith(type, "image/") || strcmp(type, "Image") == 0) {
xs_html_add(content_attachments,
xs_html_tag("a",
xs_html_attr("href", href),
xs_html_attr("target", "_blank"),
xs_html_sctag("img",
xs_html_attr("loading", "lazy"),
xs_html_attr("src", href),
xs_html_attr("alt", name),
xs_html_attr("title", name))));
}
else
if (xs_startswith(type, "video/")) {
xs_html_add(content_attachments,
xs_html_tag("video",
xs_html_attr("preload", "none"),
xs_html_attr("style", "width: 100%"),
xs_html_attr("class", "snac-embedded-video"),
xs_html_attr("controls", NULL),
xs_html_attr("src", href),
xs_html_text(L("Video")),
xs_html_text(": "),
xs_html_tag("a",
xs_html_attr("href", href),
xs_html_text(name))));
}
else
if (xs_startswith(type, "audio/")) {
xs_html_add(content_attachments,
xs_html_tag("audio",
xs_html_attr("preload", "none"),
xs_html_attr("style", "width: 100%"),
xs_html_attr("class", "snac-embedded-audio"),
xs_html_attr("controls", NULL),
xs_html_attr("src", href),
xs_html_text(L("Audio")),
xs_html_text(": "),
xs_html_tag("a",
xs_html_attr("href", href),
xs_html_text(name))));
}
else
if (strcmp(type, "Link") == 0) {
xs_html_add(content_attachments,
xs_html_tag("p",
xs_html_tag("a",
xs_html_attr("href", o_href),
xs_html_text(href))));
/* do not generate an Alt... */
name = NULL;
}
else {
xs_html_add(content_attachments,
xs_html_tag("p",
xs_html_tag("a",
xs_html_attr("href", o_href),
xs_html_text(L("Attachment")),
xs_html_text(": "),
xs_html_text(o_href))));
/* do not generate an Alt... */
name = NULL;
}
if (name != NULL && *name) {
xs_html_add(content_attachments,
xs_html_tag("p",
xs_html_attr("class", "snac-alt-text"),
xs_html_tag("details",
xs_html_tag("summary",
xs_html_text(L("Alt..."))),
xs_html_text(name))));
}
}
}
/* has this message an audience (i.e., comes from a channel or community)? */
const char *audience = xs_dict_get(msg, "audience");
if (strcmp(type, "Page") == 0 && !xs_is_null(audience)) {
xs_html *au_tag = xs_html_tag("p",
xs_html_text("("),
xs_html_tag("a",
xs_html_attr("href", audience),
xs_html_attr("title", L("Source channel or community")),
xs_html_text(audience)),
xs_html_text(")"));
xs_html_add(snac_content_wrap,
au_tag);
}
/** controls **/
if (!read_only && user) {
xs_html_add(entry,
html_entry_controls(user, actor, msg, md5));
}
/** children **/
if (!hide_children) {
xs *children = object_children(id);
int left = xs_list_len(children);
if (left) {
xs_html *ch_details = xs_html_tag("details",
xs_html_attr(collapse_threads ? "" : "open", NULL),
xs_html_tag("summary",
xs_html_text("...")));
xs_html_add(entry,
ch_details);
xs_html *ch_container = xs_html_tag("div",
xs_html_attr("class", level < 4 ? "snac-children" : "snac-children-too-deep"));
xs_html_add(ch_details,
ch_container);
xs_html *ch_older = NULL;
if (left > 3) {
xs_html_add(ch_container,
ch_older = xs_html_tag("details",
xs_html_tag("summary",
xs_html_text(L("Older...")))));
}
xs_list *p = children;
const char *cmd5;
int cnt = 0;
int o_cnt = 0;
while (xs_list_iter(&p, &cmd5)) {
xs *chd = NULL;
if (user)
timeline_get_by_md5(user, cmd5, &chd);
else
object_get_by_md5(cmd5, &chd);
if (chd != NULL) {
if (xs_is_null(xs_dict_get(chd, "name"))) {
xs_html *che = html_entry(user, chd, read_only,
level + 1, cmd5, hide_children);
if (che != NULL) {
if (left > 3) {
xs_html_add(ch_older,
che);
o_cnt++;
}
else
xs_html_add(ch_container,
che);
cnt++;
}
}
left--;
}
else
srv_debug(2, xs_fmt("cannot read child %s", cmd5));
}
/* if no children were finally added, hide the details */
if (cnt == 0)
xs_html_add(ch_details,
xs_html_attr("style", "display: none"));
if (o_cnt == 0 && ch_older)
xs_html_add(ch_older,
xs_html_attr("style", "display: none"));
}
}
return entry_top;
}
xs_html *html_footer(void)
{
return xs_html_tag("div",
xs_html_attr("class", "snac-footer"),
xs_html_tag("a",
xs_html_attr("href", srv_baseurl),
xs_html_text(L("about this site"))),
xs_html_text(" - "),
xs_html_text(L("powered by ")),
xs_html_tag("a",
xs_html_attr("href", WHAT_IS_SNAC_URL),
xs_html_tag("abbr",
xs_html_attr("title", "Social Networks Are Crap"),
xs_html_text("snac"))));
}
xs_str *html_timeline(snac *user, const xs_list *list, int read_only,
int skip, int show, int show_more,
const char *title, const char *page,
int utl, const char *error)
/* returns the HTML for the timeline */
{
xs_list *p = (xs_list *)list;
const char *v;
double t = ftime();
int hide_children = xs_is_true(xs_dict_get(srv_config, "strict_public_timelines")) && read_only;
xs *desc = NULL;
xs *alternate = NULL;
if (xs_list_len(list) == 1) {
/* only one element? pick the description from the source */
const char *id = xs_list_get(list, 0);
xs *d = NULL;
object_get_by_md5(id, &d);
const char *sc = xs_dict_get(d, "sourceContent");
if (d && sc != NULL)
desc = xs_dup(sc);
alternate = xs_dup(xs_dict_get(d, "id"));
}
xs_html *head;
xs_html *body;
if (user) {
head = html_user_head(user, desc, alternate);
body = html_user_body(user, read_only);
}
else {
head = html_instance_head();
body = html_instance_body();
}
xs_html *html = xs_html_tag("html",
head,
body);
if (user && !read_only)
xs_html_add(body,
html_top_controls(user));
if (error != NULL) {
xs_html_add(body,
xs_html_tag("dialog",
xs_html_attr("open", NULL),
xs_html_tag("p",
xs_html_text(error)),
xs_html_tag("form",
xs_html_attr("method", "dialog"),
xs_html_sctag("input",
xs_html_attr("type", "submit"),
xs_html_attr("value", L("Dismiss"))))));
}
/* show links to the available lists */
if (user && !read_only) {
xs_html *lol = xs_html_tag("ul",
xs_html_attr("class", "snac-list-of-lists"));
xs_html_add(body, lol);
xs *lists = list_maint(user, NULL, 0); /* get list of lists */
int ct = 0;
const char *v;
while (xs_list_next(lists, &v, &ct)) {
const char *lname = xs_list_get(v, 1);
xs *url = xs_fmt("%s/list/%s", user->actor, xs_list_get(v, 0));
xs *ttl = xs_fmt(L("Timeline for list '%s'"), lname);
xs_html_add(lol,
xs_html_tag("li",
xs_html_tag("a",
xs_html_attr("href", url),
xs_html_attr("class", "snac-list-link"),
xs_html_attr("title", ttl),
xs_html_text(lname))));
}
{
/* show the list of pinned posts */
xs *url = xs_fmt("%s/pinned", user->actor);
xs_html_add(lol,
xs_html_tag("li",
xs_html_tag("a",
xs_html_attr("href", url),
xs_html_attr("class", "snac-list-link"),
xs_html_attr("title", L("Pinned posts")),
xs_html_text("pinned"))));
}
{
/* show the list of bookmarked posts */
xs *url = xs_fmt("%s/bookmarks", user->actor);
xs_html_add(lol,
xs_html_tag("li",
xs_html_tag("a",
xs_html_attr("href", url),
xs_html_attr("class", "snac-list-link"),
xs_html_attr("title", L("Bookmarked posts")),
xs_html_text("bookmarks"))));
}
{
/* show the list of drafts */
xs *url = xs_fmt("%s/drafts", user->actor);
xs_html_add(lol,
xs_html_tag("li",
xs_html_tag("a",
xs_html_attr("href", url),
xs_html_attr("class", "snac-list-link"),
xs_html_attr("title", L("Post drafts")),
xs_html_text("drafts"))));
}
}
xs_html_add(body,
xs_html_tag("a",
xs_html_attr("name", "snac-posts")));
xs_html *posts = xs_html_tag("div",
xs_html_attr("class", "snac-posts"));
if (title) {
xs_html_add(posts,
xs_html_tag("h2",
xs_html_attr("class", "snac-header"),
xs_html_text(title)));
}
xs_html_add(body,
posts);
while (xs_list_iter(&p, &v)) {
xs *msg = NULL;
int status;
if (utl && user && !is_pinned_by_md5(user, v))
status = timeline_get_by_md5(user, v, &msg);
else
status = object_get_by_md5(v, &msg);
if (!valid_status(status))
continue;
/* if it's an instance page, discard messages from private users */
if (user == NULL && is_msg_from_private_user(msg))
continue;
/* is this message a non-public reply? */
if (user != NULL && !is_msg_public(msg)) {
const char *irt = get_in_reply_to(msg);
/* is it a reply to something not in the storage? */
if (!xs_is_null(irt) && !object_here(irt)) {
/* is it for me? */
const xs_list *to = xs_dict_get_def(msg, "to", xs_stock(XSTYPE_LIST));
const xs_list *cc = xs_dict_get_def(msg, "cc", xs_stock(XSTYPE_LIST));
if (xs_list_in(to, user->actor) == -1 && xs_list_in(cc, user->actor) == -1) {
snac_debug(user, 1, xs_fmt("skipping non-public reply to an unknown post %s", v));
continue;
}
}
}
xs_html *entry = html_entry(user, msg, read_only, 0, v, (user && !hide_children) ? 0 : 1);
if (entry != NULL)
xs_html_add(posts,
entry);
}
if (list && user && read_only) {
/** history **/
if (xs_type(xs_dict_get(srv_config, "disable_history")) != XSTYPE_TRUE) {
xs_html *ul = xs_html_tag("ul", NULL);
xs_html *history = xs_html_tag("div",
xs_html_attr("class", "snac-history"),
xs_html_tag("p",
xs_html_attr("class", "snac-history-title"),
xs_html_text(L("History"))),
ul);
xs *list = history_list(user);
xs_list *p = list;
const char *v;
while (xs_list_iter(&p, &v)) {
xs *fn = xs_replace(v, ".html", "");
xs *url = xs_fmt("%s/h/%s", user->actor, v);
xs_html_add(ul,
xs_html_tag("li",
xs_html_tag("a",
xs_html_attr("href", url),
xs_html_text(fn))));
}
xs_html_add(body,
history);
}
}
{
xs *s1 = xs_fmt("\n\n", ftime() - t);
xs_html_add(body,
xs_html_raw(s1));
}
if (show_more) {
xs *m = 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);
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_add(body,
more_links);
}
xs_html_add(body,
html_footer());
return xs_html_render_s(html, "\n");
}
xs_html *html_people_list(snac *snac, xs_list *list, char *header, char *t, const char *proxy)
{
xs_html *snac_posts;
xs_html *people = xs_html_tag("div",
xs_html_tag("h2",
xs_html_attr("class", "snac-header"),
xs_html_text(header)),
snac_posts = xs_html_tag("details",
xs_html_attr("open", NULL),
xs_html_tag("summary",
xs_html_text("..."))));
const char *actor_id;
xs_list_foreach(list, actor_id) {
xs *md5 = xs_md5_hex(actor_id, strlen(actor_id));
xs *actor = NULL;
if (valid_status(actor_get(actor_id, &actor))) {
xs_html *snac_post = xs_html_tag("div",
xs_html_attr("class", "snac-post"),
xs_html_tag("a",
xs_html_attr("name", md5)),
xs_html_tag("div",
xs_html_attr("class", "snac-post-header"),
html_actor_icon(snac, actor, xs_dict_get(actor, "published"),
NULL, NULL, 0, 1, proxy)));
/* content (user bio) */
const char *c = xs_dict_get(actor, "summary");
if (!xs_is_null(c)) {
xs *sc = sanitize(c);
xs_html *snac_content = xs_html_tag("div",
xs_html_attr("class", "snac-content"));
if (xs_startswith(sc, "
"))
xs_html_add(snac_content,
xs_html_raw(sc)); /* already sanitized */
else
xs_html_add(snac_content,
xs_html_tag("p",
xs_html_raw(sc))); /* already sanitized */
xs_html_add(snac_post, snac_content);
}
/* buttons */
xs *btn_form_action = xs_fmt("%s/admin/action", snac->actor);
xs_html *snac_controls = xs_html_tag("div",
xs_html_attr("class", "snac-controls"));
xs_html *form = xs_html_tag("form",
xs_html_attr("autocomplete", "off"),
xs_html_attr("method", "post"),
xs_html_attr("action", btn_form_action),
xs_html_sctag("input",
xs_html_attr("type", "hidden"),
xs_html_attr("name", "actor"),
xs_html_attr("value", actor_id)),
xs_html_sctag("input",
xs_html_attr("type", "hidden"),
xs_html_attr("name", "actor-form"),
xs_html_attr("value", "yes")));
xs_html_add(snac_controls, form);
if (following_check(snac, actor_id)) {
xs_html_add(form,
html_button("unfollow", L("Unfollow"),
L("Stop following this user's activity")));
if (is_limited(snac, actor_id))
xs_html_add(form,
html_button("unlimit", L("Unlimit"),
L("Allow announces (boosts) from this user")));
else
xs_html_add(form,
html_button("limit", L("Limit"),
L("Block announces (boosts) from this user")));
}
else {
xs_html_add(form,
html_button("follow", L("Follow"),
L("Start following this user's activity")));
if (follower_check(snac, actor_id))
xs_html_add(form,
html_button("delete", L("Delete"), L("Delete this user")));
}
if (pending_check(snac, actor_id)) {
xs_html_add(form,
html_button("approve", L("Approve"),
L("Approve this follow request")));
xs_html_add(form,
html_button("discard", L("Discard"), L("Discard this follow request")));
}
if (is_muted(snac, actor_id))
xs_html_add(form,
html_button("unmute", L("Unmute"),
L("Stop blocking activities from this user")));
else
xs_html_add(form,
html_button("mute", L("MUTE"),
L("Block any activity from this user")));
/* the post textarea */
xs *dm_div_id = xs_fmt("%s_%s_dm", md5, t);
xs *dm_form_id = xs_fmt("%s_reply_form", md5);
xs_html_add(snac_controls,
xs_html_tag("p", NULL),
html_note(snac, L("Direct Message..."),
dm_div_id, dm_form_id,
"", "",
NULL, actor_id,
xs_stock(XSTYPE_FALSE), "",
xs_stock(XSTYPE_FALSE), NULL,
NULL, 0, "", "", 0),
xs_html_tag("p", NULL));
xs_html_add(snac_post, snac_controls);
xs_html_add(snac_posts, snac_post);
}
}
return people;
}
xs_str *html_people(snac *user)
{
const char *proxy = NULL;
if (xs_is_true(xs_dict_get(srv_config, "proxy_media")))
proxy = user->actor;
xs *wing = following_list(user);
xs *wers = follower_list(user);
xs_html *lists = xs_html_tag("div",
xs_html_attr("class", "snac-posts"));
if (xs_is_true(xs_dict_get(user->config, "approve_followers"))) {
xs *pending = pending_list(user);
xs_html_add(lists,
html_people_list(user, pending, L("Pending follow confirmations"), "p", proxy));
}
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));
xs_html *html = xs_html_tag("html",
html_user_head(user, NULL, NULL),
xs_html_add(html_user_body(user, 0),
lists,
html_footer()));
return xs_html_render_s(html, "\n");
}
xs_str *html_notifications(snac *user, int skip, int show)
{
const char *proxy = NULL;
if (xs_is_true(xs_dict_get(srv_config, "proxy_media")))
proxy = user->actor;
xs *n_list = notify_list(user, skip, show);
xs *n_time = notify_check_time(user, 0);
xs_html *body = html_user_body(user, 0);
xs_html *html = xs_html_tag("html",
html_user_head(user, NULL, NULL),
body);
xs *clear_all_action = xs_fmt("%s/admin/clear-notifications", user->actor);
xs_html_add(body,
xs_html_tag("form",
xs_html_attr("autocomplete", "off"),
xs_html_attr("method", "post"),
xs_html_attr("action", clear_all_action),
xs_html_attr("id", "clear"),
xs_html_sctag("input",
xs_html_attr("type", "submit"),
xs_html_attr("class", "snac-btn-like"),
xs_html_attr("value", L("Clear all")))));
xs_html *noti_new = NULL;
xs_html *noti_seen = NULL;
xs_html *posts = xs_html_tag("div",
xs_html_attr("class", "snac-posts"));
xs_html_add(body, posts);
xs_list *p = n_list;
const xs_str *v;
while (xs_list_iter(&p, &v)) {
xs *noti = notify_get(user, v);
if (noti == NULL)
continue;
xs *obj = NULL;
const char *type = xs_dict_get(noti, "type");
const char *utype = xs_dict_get(noti, "utype");
const char *id = xs_dict_get(noti, "objid");
const char *date = xs_dict_get(noti, "date");
xs *wrk = NULL;
if (xs_is_null(id))
continue;
if (is_hidden(user, id))
continue;
object_get(id, &obj);
const char *actor_id = xs_dict_get(noti, "actor");
xs *actor = NULL;
if (!valid_status(actor_get(actor_id, &actor)))
continue;
xs *a_name = actor_name(actor, proxy);
const char *label = type;
if (strcmp(type, "Create") == 0)
label = L("Mention");
else
if (strcmp(type, "Update") == 0 && strcmp(utype, "Question") == 0)
label = L("Finished poll");
else
if (strcmp(type, "Undo") == 0 && strcmp(utype, "Follow") == 0)
label = L("Unfollow");
else
if (strcmp(type, "EmojiReact") == 0) {
const char *content = xs_dict_get_path(noti, "msg.content");
if (xs_type(content) == XSTYPE_STRING) {
wrk = xs_fmt("%s (%s)", type, content);
label = wrk;
}
}
else
if (strcmp(type, "Follow") == 0 && pending_check(user, actor_id))
label = L("Follow Request");
xs *s_date = xs_crop_i(xs_dup(date), 0, 10);
xs_html *entry = xs_html_tag("div",
xs_html_attr("class", "snac-post-with-desc"),
xs_html_tag("p",
xs_html_tag("b",
xs_html_text(label),
xs_html_text(" by "),
xs_html_tag("a",
xs_html_attr("href", actor_id),
xs_html_raw(a_name))), /* a_name is already sanitized */
xs_html_text(" "),
xs_html_tag("time",
xs_html_attr("class", "dt-published snac-pubdate"),
xs_html_attr("title", date),
xs_html_text(s_date))));
if (strcmp(type, "Follow") == 0 || strcmp(utype, "Follow") == 0 || strcmp(type, "Block") == 0) {
xs_html_add(entry,
xs_html_tag("div",
xs_html_attr("class", "snac-post"),
html_actor_icon(user, actor, NULL, NULL, NULL, 0, 0, proxy)));
}
else
if (strcmp(type, "Move") == 0) {
const xs_dict *o_msg = xs_dict_get(noti, "msg");
const char *target;
if (xs_type(o_msg) == XSTYPE_DICT && (target = xs_dict_get(o_msg, "target"))) {
xs *old_actor = NULL;
if (valid_status(actor_get(target, &old_actor))) {
xs_html_add(entry,
xs_html_tag("div",
xs_html_attr("class", "snac-post"),
html_actor_icon(user, old_actor, NULL, NULL, NULL, 0, 0, proxy)));
}
}
}
else
if (obj != NULL) {
xs *md5 = xs_md5_hex(id, strlen(id));
xs_html *h = html_entry(user, obj, 0, 0, md5, 1);
if (h != NULL) {
xs_html_add(entry,
h);
}
}
if (strcmp(v, n_time) > 0) {
/* unseen notification */
if (noti_new == NULL) {
noti_new = xs_html_tag("div",
xs_html_tag("h2",
xs_html_attr("class", "snac-header"),
xs_html_text(L("New"))));
xs_html_add(posts,
noti_new);
}
xs_html_add(noti_new,
entry);
}
else {
/* already seen notification */
if (noti_seen == NULL) {
noti_seen = xs_html_tag("div",
xs_html_tag("h2",
xs_html_attr("class", "snac-header"),
xs_html_text(L("Already seen"))));
xs_html_add(posts,
noti_seen);
}
xs_html_add(noti_seen,
entry);
}
}
if (noti_new == NULL && noti_seen == NULL)
xs_html_add(body,
xs_html_tag("h2",
xs_html_attr("class", "snac-header"),
xs_html_text(L("None"))));
/* add the navigation footer */
xs *next_p = notify_list(user, skip + show, 1);
if (xs_list_len(next_p)) {
xs *url = xs_fmt("%s/notifications?skip=%d&show=%d",
user->actor, skip + show, show);
xs_html_add(body,
xs_html_tag("p",
xs_html_tag("a",
xs_html_attr("href", url),
xs_html_text(L("More...")))));
}
xs_html_add(body,
html_footer());
/* set the check time to now */
xs *dummy = notify_check_time(user, 1);
dummy = xs_free(dummy);
timeline_touch(user);
return xs_html_render_s(html, "\n");
}
int html_get_handler(const xs_dict *req, const char *q_path,
char **body, int *b_size, char **ctype,
xs_str **etag, xs_str **last_modified)
{
const char *accept = xs_dict_get(req, "accept");
int status = HTTP_STATUS_NOT_FOUND;
snac snac;
xs *uid = NULL;
const char *p_path;
int cache = 1;
int save = 1;
int proxy = 0;
const char *v;
xs *l = xs_split_n(q_path, "/", 2);
v = xs_list_get(l, 1);
if (xs_is_null(v)) {
srv_log(xs_fmt("html_get_handler bad query '%s'", q_path));
return HTTP_STATUS_NOT_FOUND;
}
uid = xs_dup(v);
/* rss extension? */
if (xs_endswith(uid, ".rss")) {
uid = xs_crop_i(uid, 0, -4);
p_path = ".rss";
}
else
p_path = xs_list_get(l, 2);
if (!uid || !user_open(&snac, uid)) {
/* invalid user */
srv_debug(1, xs_fmt("html_get_handler bad user %s", uid));
return HTTP_STATUS_NOT_FOUND;
}
if (xs_is_true(xs_dict_get(srv_config, "proxy_media")))
proxy = 1;
/* return the RSS if requested by Accept header */
if (accept != NULL) {
if (xs_str_in(accept, "text/xml") != -1 ||
xs_str_in(accept, "application/rss+xml") != -1)
p_path = ".rss";
}
/* check if server config variable 'disable_cache' is set */
if ((v = xs_dict_get(srv_config, "disable_cache")) && xs_type(v) == XSTYPE_TRUE)
cache = 0;
int skip = 0;
int def_show = xs_number_get(xs_dict_get(srv_config, "max_timeline_entries"));
int show = def_show;
const xs_dict *q_vars = xs_dict_get(req, "q_vars");
if ((v = xs_dict_get(q_vars, "skip")) != NULL)
skip = atoi(v), cache = 0, save = 0;
if ((v = xs_dict_get(q_vars, "show")) != NULL)
show = atoi(v), cache = 0, save = 0;
if ((v = xs_dict_get(q_vars, "da")) != NULL) {
/* user dismissed an announcement */
if (login(&snac, req)) {
double ts = atof(v);
xs *timestamp = xs_number_new(ts);
srv_log(xs_fmt("user dismissed announcements until %d", ts));
snac.config = xs_dict_set(snac.config, "last_announcement", timestamp);
user_persist(&snac, 0);
}
}
/* get a possible error message */
const char *error = xs_dict_get(q_vars, "error");
if (error != NULL)
cache = 0;
/* a show of 0 has no sense */
if (show == 0)
show = def_show;
if (p_path == NULL) { /** public timeline **/
xs *h = xs_str_localtime(0, "%Y-%m.html");
if (xs_type(xs_dict_get(snac.config, "private")) == XSTYPE_TRUE) {
/** empty public timeline for private users **/
*body = html_timeline(&snac, NULL, 1, 0, 0, 0, NULL, "", 1, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
else
if (cache && history_mtime(&snac, h) > timeline_mtime(&snac)) {
snac_debug(&snac, 1, xs_fmt("serving cached local timeline"));
status = history_get(&snac, h, body, b_size,
xs_dict_get(req, "if-none-match"), etag);
}
else {
xs *list = NULL;
xs *next = NULL;
if (xs_is_true(xs_dict_get(srv_config, "strict_public_timelines"))) {
list = timeline_simple_list(&snac, "public", skip, show);
next = timeline_simple_list(&snac, "public", skip + show, 1);
}
else {
list = timeline_list(&snac, "public", skip, show);
next = timeline_list(&snac, "public", skip + show, 1);
}
xs *pins = pinned_list(&snac);
pins = xs_list_cat(pins, list);
*body = html_timeline(&snac, pins, 1, skip, show, xs_list_len(next), NULL, "", 1, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
if (save)
history_add(&snac, h, *body, *b_size, etag);
}
}
else
if (strcmp(p_path, "admin") == 0) { /** private timeline **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
const char *q = xs_dict_get(q_vars, "q");
xs *url_acct = NULL;
/* searching for an URL? */
if (q && xs_match(q, "https://*|http://*")) {
/* may by an actor; try a webfinger */
xs *actor_obj = NULL;
if (valid_status(webfinger_request(q, &actor_obj, &url_acct))) {
/* it's an actor; do the dirty trick of changing q to the account name */
q = url_acct;
}
else {
/* if it's not already here, try to bring it to the user's timeline */
xs *md5 = xs_md5_hex(q, strlen(q));
if (!timeline_here(&snac, md5)) {
xs *object = NULL;
int status;
status = activitypub_request(&snac, q, &object);
snac_debug(&snac, 1, xs_fmt("Request searched URL %s %d", q, status));
if (valid_status(status)) {
/* got it; also request the actor */
const char *attr_to = get_atto(object);
if (!xs_is_null(attr_to)) {
status = actor_request(&snac, attr_to, &actor_obj);
snac_debug(&snac, 1, xs_fmt("Request author %s of %s %d", attr_to, q, status));
if (valid_status(status)) {
/* add the actor */
actor_add(attr_to, actor_obj);
/* add the post to the timeline */
timeline_add(&snac, q, object);
}
}
}
}
}
/* fall through */
}
if (q && *q) {
if (xs_regex_match(q, "^@?[a-zA-Z0-9_]+@[a-zA-Z0-9-]+\\.")) {
/** search account **/
xs *actor = NULL;
xs *acct = NULL;
xs *l = xs_list_new();
xs_html *page = NULL;
if (valid_status(webfinger_request(q, &actor, &acct))) {
xs *actor_obj = NULL;
if (valid_status(actor_request(&snac, actor, &actor_obj))) {
actor_add(actor, actor_obj);
/* create a people list with only one element */
l = xs_list_append(xs_list_new(), actor);
xs *title = xs_fmt(L("Search results for account %s"), q);
page = html_people_list(&snac, l, title, "wf", NULL);
}
}
if (page == NULL) {
xs *title = xs_fmt(L("Account %s not found"), q);
page = xs_html_tag("div",
xs_html_tag("h2",
xs_html_attr("class", "snac-header"),
xs_html_text(title)));
}
xs_html *html = xs_html_tag("html",
html_user_head(&snac, NULL, NULL),
xs_html_add(html_user_body(&snac, 0),
page,
html_footer()));
*body = xs_html_render_s(html, "\n");
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
else
if (*q == '#') {
/** search by tag **/
xs *tl = tag_search(q, skip, show + 1);
int more = 0;
if (xs_list_len(tl) >= show + 1) {
/* drop the last one */
tl = xs_list_del(tl, -1);
more = 1;
}
xs *page = xs_fmt("/admin?q=%%23%s", q + 1);
xs *title = xs_fmt(xs_list_len(tl) ?
L("Search results for tag %s") : L("Nothing found for tag %s"), q);
*body = html_timeline(&snac, tl, 0, skip, show, more, title, page, 0, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
else {
/** search by content **/
int to = 0;
int msecs = atoi(xs_dict_get_def(q_vars, "msecs", "0"));
xs *tl = content_search(&snac, q, 1, skip, show, msecs, &to);
xs *title = NULL;
xs *page = xs_fmt("/admin?q=%s&msecs=%d", q, msecs + 10);
int tl_len = xs_list_len(tl);
if (to)
title = xs_fmt(L("Search results for '%s' (may be more)"), q);
else
if (tl_len)
title = xs_fmt(L("Search results for '%s'"), q);
else
if (skip)
title = xs_fmt(L("No more matches for '%s'"), q);
else
title = xs_fmt(L("Nothing found for '%s'"), q);
*body = html_timeline(&snac, tl, 0, skip, tl_len, to || tl_len == show,
title, page, 0, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else {
double t = history_mtime(&snac, "timeline.html_");
/* if enabled by admin, return a cached page if its timestamp is:
a) newer than the timeline timestamp
b) newer than the start time of the server
*/
if (cache && t > timeline_mtime(&snac) && t > p_state->srv_start_time) {
snac_debug(&snac, 1, xs_fmt("serving cached timeline"));
status = history_get(&snac, "timeline.html_", body, b_size,
xs_dict_get(req, "if-none-match"), etag);
}
else {
snac_debug(&snac, 1, xs_fmt("building timeline"));
xs *list = timeline_list(&snac, "private", skip, show);
xs *next = timeline_list(&snac, "private", skip + show, 1);
*body = html_timeline(&snac, list, 0, skip, show,
xs_list_len(next), NULL, "/admin", 1, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
if (save)
history_add(&snac, "timeline.html_", *body, *b_size, etag);
}
}
}
}
else
if (xs_startswith(p_path, "admin/p/")) { /** unique post by md5 **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
xs *l = xs_split(p_path, "/");
const char *md5 = xs_list_get(l, -1);
if (md5 && *md5 && timeline_here(&snac, md5)) {
xs *list = xs_list_append(xs_list_new(), md5);
*body = html_timeline(&snac, list, 0, 0, 0, 0, NULL, "/admin", 1, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
}
else
if (strcmp(p_path, "people") == 0) { /** the list of people **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
*body = html_people(&snac);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else
if (strcmp(p_path, "notifications") == 0) { /** the list of notifications **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
*body = html_notifications(&snac, skip, show);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else
if (strcmp(p_path, "instance") == 0) { /** instance timeline **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
xs *list = timeline_instance_list(skip, show);
xs *next = timeline_instance_list(skip + show, 1);
*body = html_timeline(&snac, list, 0, skip, show,
xs_list_len(next), L("Showing instance timeline"), "/instance", 0, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else
if (strcmp(p_path, "pinned") == 0) { /** list of pinned posts **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
xs *list = pinned_list(&snac);
*body = html_timeline(&snac, list, 0, skip, show,
0, L("Pinned posts"), "", 0, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else
if (strcmp(p_path, "bookmarks") == 0) { /** list of bookmarked posts **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
xs *list = bookmark_list(&snac);
*body = html_timeline(&snac, list, 0, skip, show,
0, L("Bookmarked posts"), "", 0, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else
if (strcmp(p_path, "drafts") == 0) { /** list of drafts **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
xs *list = draft_list(&snac);
*body = html_timeline(&snac, list, 0, skip, show,
0, L("Post drafts"), "", 0, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else
if (xs_startswith(p_path, "list/")) { /** list timelines **/
if (!login(&snac, req)) {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
else {
xs *l = xs_split(p_path, "/");
const char *lid = xs_list_get(l, -1);
xs *list = list_timeline(&snac, lid, skip, show);
xs *next = list_timeline(&snac, lid, skip + show, 1);
if (list != NULL) {
xs *ttl = timeline_top_level(&snac, list);
xs *base = xs_fmt("/list/%s", lid);
xs *name = list_maint(&snac, lid, 3);
xs *title = xs_fmt(L("Showing timeline for list '%s'"), name);
*body = html_timeline(&snac, ttl, 0, skip, show,
xs_list_len(next), title, base, 1, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
}
else
if (xs_startswith(p_path, "p/")) { /** a timeline with just one entry **/
if (xs_type(xs_dict_get(snac.config, "private")) == XSTYPE_TRUE)
return HTTP_STATUS_FORBIDDEN;
xs *id = xs_fmt("%s/%s", snac.actor, p_path);
xs *msg = NULL;
if (valid_status(object_get(id, &msg))) {
xs *md5 = xs_md5_hex(id, strlen(id));
xs *list = xs_list_new();
list = xs_list_append(list, md5);
*body = html_timeline(&snac, list, 1, 0, 0, 0, NULL, "", 1, error);
*b_size = strlen(*body);
status = HTTP_STATUS_OK;
}
}
else
if (xs_startswith(p_path, "s/")) { /** a static file **/
xs *l = xs_split(p_path, "/");
const char *id = xs_list_get(l, 1);
int sz;
if (id && *id) {
status = static_get(&snac, id, body, &sz,
xs_dict_get(req, "if-none-match"), etag);
if (valid_status(status)) {
*b_size = sz;
*ctype = (char *)xs_mime_by_ext(id);
}
}
}
else
if (xs_startswith(p_path, "h/")) { /** an entry from the history **/
if (xs_type(xs_dict_get(snac.config, "private")) == XSTYPE_TRUE)
return HTTP_STATUS_FORBIDDEN;
if (xs_type(xs_dict_get(srv_config, "disable_history")) == XSTYPE_TRUE)
return HTTP_STATUS_FORBIDDEN;
xs *l = xs_split(p_path, "/");
const char *id = xs_list_get(l, 1);
if (id && *id) {
if (xs_endswith(id, "timeline.html_")) {
/* Don't let them in */
*b_size = 0;
status = HTTP_STATUS_NOT_FOUND;
}
else
status = history_get(&snac, id, body, b_size,
xs_dict_get(req, "if-none-match"), etag);
}
}
else
if (strcmp(p_path, ".rss") == 0) { /** public timeline in RSS format **/
if (xs_type(xs_dict_get(snac.config, "private")) == XSTYPE_TRUE)
return HTTP_STATUS_FORBIDDEN;
xs *elems = timeline_simple_list(&snac, "public", 0, 20);
xs *bio = xs_dup(xs_dict_get(snac.config, "bio"));
xs *rss_title = xs_fmt("%s (@%s@%s)",
xs_dict_get(snac.config, "name"),
snac.uid,
xs_dict_get(srv_config, "host"));
xs *rss_link = xs_fmt("%s.rss", snac.actor);
*body = timeline_to_rss(&snac, elems, rss_title, rss_link, bio);
*b_size = strlen(*body);
*ctype = "application/rss+xml; charset=utf-8";
status = HTTP_STATUS_OK;
snac_debug(&snac, 1, xs_fmt("serving RSS"));
}
else
if (proxy && (xs_startswith(p_path, "x/") || xs_startswith(p_path, "y/"))) { /** remote media by proxy **/
xs *proxy_prefix = NULL;
if (xs_startswith(p_path, "x/")) {
/* proxy usage authorized by http basic auth */
if (login(&snac, req))
proxy_prefix = xs_str_new("x/");
else {
*body = xs_dup(uid);
status = HTTP_STATUS_UNAUTHORIZED;
}
}
else {
/* proxy usage authorized by proxy_token */
xs *tks = xs_fmt("%s:%s", srv_proxy_token_seed, snac.actor);
xs *tk = xs_md5_hex(tks, strlen(tks));
xs *p = xs_fmt("y/%s/", tk);
if (xs_startswith(p_path, p))
proxy_prefix = xs_dup(p);
}
if (proxy_prefix) {
/* pick the raw path (including optional ? arguments) */
const char *raw_path = xs_dict_get(req, "raw_path");
/* skip to where the proxy/ string starts */
raw_path += xs_str_in(raw_path, proxy_prefix);
xs *url = xs_replace_n(raw_path, proxy_prefix, "https:/" "/", 1);
xs *hdrs = xs_dict_new();
hdrs = xs_dict_append(hdrs, "user-agent", USER_AGENT);
const char *ims = xs_dict_get(req, "if-modified-since");
const char *inm = xs_dict_get(req, "if-none-match");
if (ims) hdrs = xs_dict_append(hdrs, "if-modified-since", ims);
if (inm) hdrs = xs_dict_append(hdrs, "if-none-match", inm);
xs *rsp = xs_http_request("GET", url, hdrs,
NULL, 0, &status, body, b_size, 0);
if (valid_status(status)) {
const char *ct = xs_or(xs_dict_get(rsp, "content-type"), "");
const char *lm = xs_dict_get(rsp, "last-modified");
const char *et = xs_dict_get(rsp, "etag");
if (lm) *last_modified = xs_dup(lm);
if (et) *etag = xs_dup(et);
/* find the content-type in the static mime types,
and return that value instead of ct, which will
be destroyed when out of scope */
for (int n = 0; xs_mime_types[n]; n += 2) {
if (strcmp(ct, xs_mime_types[n + 1]) == 0) {
*ctype = (char *)xs_mime_types[n + 1];
break;
}
}
}
snac_debug(&snac, 1, xs_fmt("Proxy for %s %d", url, status));
}
}
else
status = HTTP_STATUS_NOT_FOUND;
user_free(&snac);
if (valid_status(status) && *ctype == NULL) {
*ctype = "text/html; charset=utf-8";
}
return status;
}
int html_post_handler(const xs_dict *req, const char *q_path,
char *payload, int p_size,
char **body, int *b_size, char **ctype)
{
(void)p_size;
(void)ctype;
int status = 0;
snac snac;
const char *uid;
const char *p_path;
const xs_dict *p_vars;
xs *l = xs_split_n(q_path, "/", 2);
uid = xs_list_get(l, 1);
if (!uid || !user_open(&snac, uid)) {
/* invalid user */
srv_debug(1, xs_fmt("html_post_handler bad user %s", uid));
return HTTP_STATUS_NOT_FOUND;
}
p_path = xs_list_get(l, 2);
/* all posts must be authenticated */
if (!login(&snac, req)) {
user_free(&snac);
*body = xs_dup(uid);
return HTTP_STATUS_UNAUTHORIZED;
}
p_vars = xs_dict_get(req, "p_vars");
if (p_path && strcmp(p_path, "admin/note") == 0) { /** **/
snac_debug(&snac, 1, xs_fmt("web action '%s' received", p_path));
/* post note */
const xs_str *content = xs_dict_get(p_vars, "content");
const xs_str *in_reply_to = xs_dict_get(p_vars, "in_reply_to");
const xs_str *attach_url = xs_dict_get(p_vars, "attach_url");
const xs_list *attach_file = xs_dict_get(p_vars, "attach");
const xs_str *to = xs_dict_get(p_vars, "to");
const xs_str *sensitive = xs_dict_get(p_vars, "sensitive");
const xs_str *summary = xs_dict_get(p_vars, "summary");
const xs_str *edit_id = xs_dict_get(p_vars, "edit_id");
const xs_str *alt_text = xs_dict_get(p_vars, "alt_text");
int priv = !xs_is_null(xs_dict_get(p_vars, "mentioned_only"));
int store_as_draft = !xs_is_null(xs_dict_get(p_vars, "is_draft"));
xs *attach_list = xs_list_new();
/* default alt text */
if (xs_is_null(alt_text))
alt_text = "";
/* is attach_url set? */
if (!xs_is_null(attach_url) && *attach_url != '\0') {
xs *l = xs_list_new();
l = xs_list_append(l, attach_url);
l = xs_list_append(l, alt_text);
attach_list = xs_list_append(attach_list, l);
}
/* is attach_file set? */
if (!xs_is_null(attach_file) && xs_type(attach_file) == XSTYPE_LIST) {
const char *fn = xs_list_get(attach_file, 0);
if (*fn != '\0') {
char *ext = strrchr(fn, '.');
xs *hash = xs_md5_hex(fn, strlen(fn));
xs *id = xs_fmt("%s%s", hash, ext);
xs *url = xs_fmt("%s/s/%s", snac.actor, id);
int fo = xs_number_get(xs_list_get(attach_file, 1));
int fs = xs_number_get(xs_list_get(attach_file, 2));
/* store */
static_put(&snac, id, payload + fo, fs);
xs *l = xs_list_new();
l = xs_list_append(l, url);
l = xs_list_append(l, alt_text);
attach_list = xs_list_append(attach_list, l);
}
}
if (content != NULL) {
xs *msg = NULL;
xs *c_msg = NULL;
xs *content_2 = xs_replace(content, "\r", "");
xs *poll_opts = NULL;
/* is there a valid set of poll options? */
const char *v = xs_dict_get(p_vars, "poll_options");
if (!xs_is_null(v) && *v) {
xs *v2 = xs_strip_i(xs_replace(v, "\r", ""));
poll_opts = xs_split(v2, "\n");
}
if (!xs_is_null(poll_opts) && xs_list_len(poll_opts)) {
/* get the rest of poll configuration */
const char *p_multiple = xs_dict_get(p_vars, "poll_multiple");
const char *p_end_secs = xs_dict_get(p_vars, "poll_end_secs");
int multiple = 0;
int end_secs = atoi(!xs_is_null(p_end_secs) ? p_end_secs : "60");
if (!xs_is_null(p_multiple) && strcmp(p_multiple, "on") == 0)
multiple = 1;
msg = msg_question(&snac, content_2, attach_list,
poll_opts, multiple, end_secs);
enqueue_close_question(&snac, xs_dict_get(msg, "id"), end_secs);
}
else
msg = msg_note(&snac, content_2, to, in_reply_to, attach_list, priv);
if (sensitive != NULL) {
msg = xs_dict_set(msg, "sensitive", xs_stock(XSTYPE_TRUE));
msg = xs_dict_set(msg, "summary", xs_is_null(summary) ? "..." : summary);
}
if (xs_is_null(edit_id)) {
/* new message */
const char *id = xs_dict_get(msg, "id");
if (store_as_draft) {
draft_add(&snac, id, msg);
}
else {
c_msg = msg_create(&snac, msg);
timeline_add(&snac, id, msg);
}
}
else {
/* an edition of a previous message */
xs *p_msg = NULL;
if (valid_status(object_get(edit_id, &p_msg))) {
/* copy relevant fields from previous version */
char *fields[] = { "id", "context", "url", "published",
"to", "inReplyTo", NULL };
int n;
for (n = 0; fields[n]; n++) {
const char *v = xs_dict_get(p_msg, fields[n]);
msg = xs_dict_set(msg, fields[n], v);
}
if (store_as_draft) {
draft_add(&snac, edit_id, msg);
}
else
if (is_draft(&snac, edit_id)) {
/* message was previously a draft; it's a create activity */
/* set the published field to now */
xs *published = xs_str_utctime(0, ISO_DATE_SPEC);
msg = xs_dict_set(msg, "published", published);
/* overwrite object */
object_add_ow(edit_id, msg);
c_msg = msg_create(&snac, msg);
timeline_add(&snac, edit_id, msg);
draft_del(&snac, edit_id);
}
else {
/* set the updated field */
xs *updated = xs_str_utctime(0, ISO_DATE_SPEC);
msg = xs_dict_set(msg, "updated", updated);
/* overwrite object, not updating the indexes */
object_add_ow(edit_id, msg);
/* update message */
c_msg = msg_update(&snac, msg);
}
}
else
snac_log(&snac, xs_fmt("cannot get object '%s' for editing", edit_id));
}
if (c_msg != NULL)
enqueue_message(&snac, c_msg);
history_del(&snac, "timeline.html_");
}
status = HTTP_STATUS_SEE_OTHER;
}
else
if (p_path && strcmp(p_path, "admin/action") == 0) { /** **/
/* action on an entry */
const char *id = xs_dict_get(p_vars, "id");
const char *actor = xs_dict_get(p_vars, "actor");
const char *action = xs_dict_get(p_vars, "action");
const char *group = xs_dict_get(p_vars, "group");
if (action == NULL)
return HTTP_STATUS_NOT_FOUND;
snac_debug(&snac, 1, xs_fmt("web action '%s' received", action));
status = HTTP_STATUS_SEE_OTHER;
if (strcmp(action, L("Like")) == 0) { /** **/
xs *msg = msg_admiration(&snac, id, "Like");
if (msg != NULL) {
enqueue_message(&snac, msg);
timeline_admire(&snac, xs_dict_get(msg, "object"), snac.actor, 1);
}
}
else
if (strcmp(action, L("Boost")) == 0) { /** **/
xs *msg = msg_admiration(&snac, id, "Announce");
if (msg != NULL) {
enqueue_message(&snac, msg);
timeline_admire(&snac, xs_dict_get(msg, "object"), snac.actor, 0);
}
}
else
if (strcmp(action, L("Unlike")) == 0) { /** **/
xs *msg = msg_repulsion(&snac, id, "Like");
if (msg != NULL) {
enqueue_message(&snac, msg);
}
}
else
if (strcmp(action, L("Unboost")) == 0) { /** **/
xs *msg = msg_repulsion(&snac, id, "Announce");
if (msg != NULL) {
enqueue_message(&snac, msg);
}
}
else
if (strcmp(action, L("MUTE")) == 0) { /** **/
mute(&snac, actor);
}
else
if (strcmp(action, L("Unmute")) == 0) { /** **/
unmute(&snac, actor);
}
else
if (strcmp(action, L("Hide")) == 0) { /** **/
if (is_draft(&snac, id))
draft_del(&snac, id);
else
hide(&snac, id);
}
else
if (strcmp(action, L("Limit")) == 0) { /** **/
limit(&snac, actor);
}
else
if (strcmp(action, L("Unlimit")) == 0) { /** **/
unlimit(&snac, actor);
}
else
if (strcmp(action, L("Follow")) == 0) { /** **/
xs *msg = msg_follow(&snac, actor);
if (msg != NULL) {
/* reload the actor from the message, in may be different */
actor = xs_dict_get(msg, "object");
following_add(&snac, actor, msg);
enqueue_output_by_actor(&snac, msg, actor, 0);
}
}
else
if (strcmp(action, L("Unfollow")) == 0) { /** **/
/* get the following object */
xs *object = NULL;
if (valid_status(following_get(&snac, actor, &object))) {
xs *msg = msg_undo(&snac, xs_dict_get(object, "object"));
following_del(&snac, actor);
enqueue_output_by_actor(&snac, msg, actor, 0);
snac_log(&snac, xs_fmt("unfollowed actor %s", actor));
}
else
snac_log(&snac, xs_fmt("actor is not being followed %s", actor));
}
else
if (strcmp(action, L("Follow Group")) == 0) { /** **/
xs *msg = msg_follow(&snac, group);
if (msg != NULL) {
/* reload the group from the message, in may be different */
group = xs_dict_get(msg, "object");
following_add(&snac, group, msg);
enqueue_output_by_actor(&snac, msg, group, 0);
}
}
else
if (strcmp(action, L("Unfollow Group")) == 0) { /** **/
/* get the following object */
xs *object = NULL;
if (valid_status(following_get(&snac, group, &object))) {
xs *msg = msg_undo(&snac, xs_dict_get(object, "object"));
following_del(&snac, group);
enqueue_output_by_actor(&snac, msg, group, 0);
snac_log(&snac, xs_fmt("unfollowed group %s", group));
}
else
snac_log(&snac, xs_fmt("actor is not being followed %s", actor));
}
else
if (strcmp(action, L("Delete")) == 0) { /** **/
const char *actor_form = xs_dict_get(p_vars, "actor-form");
if (actor_form != NULL) {
/* delete follower */
if (valid_status(follower_del(&snac, actor)))
snac_log(&snac, xs_fmt("deleted follower %s", actor));
else
snac_log(&snac, xs_fmt("error deleting follower %s", actor));
}
else {
/* delete an entry */
if (xs_startswith(id, snac.actor) && !is_draft(&snac, id)) {
/* it's a post by us: generate a delete */
xs *msg = msg_delete(&snac, id);
enqueue_message(&snac, msg);
snac_log(&snac, xs_fmt("posted tombstone for %s", id));
}
timeline_del(&snac, id);
draft_del(&snac, id);
snac_log(&snac, xs_fmt("deleted entry %s", id));
}
}
else
if (strcmp(action, L("Pin")) == 0) { /** **/
pin(&snac, id);
timeline_touch(&snac);
}
else
if (strcmp(action, L("Unpin")) == 0) { /** **/
unpin(&snac, id);
timeline_touch(&snac);
}
else
if (strcmp(action, L("Bookmark")) == 0) { /** **/
bookmark(&snac, id);
timeline_touch(&snac);
}
else
if (strcmp(action, L("Unbookmark")) == 0) { /** **/
unbookmark(&snac, id);
timeline_touch(&snac);
}
else
if (strcmp(action, L("Approve")) == 0) { /** **/
xs *fwreq = pending_get(&snac, actor);
if (fwreq != NULL) {
xs *reply = msg_accept(&snac, fwreq, actor);
enqueue_message(&snac, reply);
if (xs_is_null(xs_dict_get(fwreq, "published"))) {
/* add a date if it doesn't include one (Mastodon) */
xs *date = xs_str_utctime(0, ISO_DATE_SPEC);
fwreq = xs_dict_set(fwreq, "published", date);
}
timeline_add(&snac, xs_dict_get(fwreq, "id"), fwreq);
follower_add(&snac, actor);
pending_del(&snac, actor);
snac_log(&snac, xs_fmt("new follower %s", actor));
}
}
else
if (strcmp(action, L("Discard")) == 0) { /** **/
pending_del(&snac, actor);
}
else
status = HTTP_STATUS_NOT_FOUND;
/* delete the cached timeline */
if (status == HTTP_STATUS_SEE_OTHER)
history_del(&snac, "timeline.html_");
}
else
if (p_path && strcmp(p_path, "admin/user-setup") == 0) { /** **/
/* change of user data */
const char *v;
const char *p1, *p2;
if ((v = xs_dict_get(p_vars, "name")) != NULL)
snac.config = xs_dict_set(snac.config, "name", v);
if ((v = xs_dict_get(p_vars, "avatar")) != NULL)
snac.config = xs_dict_set(snac.config, "avatar", v);
if ((v = xs_dict_get(p_vars, "bio")) != NULL)
snac.config = xs_dict_set(snac.config, "bio", v);
if ((v = xs_dict_get(p_vars, "cw")) != NULL &&
strcmp(v, "on") == 0) {
snac.config = xs_dict_set(snac.config, "cw", "open");
} else { /* if the checkbox is not set, the parameter is missing */
snac.config = xs_dict_set(snac.config, "cw", "");
}
if ((v = xs_dict_get(p_vars, "email")) != NULL)
snac.config = xs_dict_set(snac.config, "email", v);
if ((v = xs_dict_get(p_vars, "telegram_bot")) != NULL)
snac.config = xs_dict_set(snac.config, "telegram_bot", v);
if ((v = xs_dict_get(p_vars, "telegram_chat_id")) != NULL)
snac.config = xs_dict_set(snac.config, "telegram_chat_id", v);
if ((v = xs_dict_get(p_vars, "ntfy_server")) != NULL)
snac.config = xs_dict_set(snac.config, "ntfy_server", v);
if ((v = xs_dict_get(p_vars, "ntfy_token")) != NULL)
snac.config = xs_dict_set(snac.config, "ntfy_token", v);
if ((v = xs_dict_get(p_vars, "purge_days")) != NULL) {
xs *days = xs_number_new(atof(v));
snac.config = xs_dict_set(snac.config, "purge_days", days);
}
if ((v = xs_dict_get(p_vars, "drop_dm_from_unknown")) != NULL && strcmp(v, "on") == 0)
snac.config = xs_dict_set(snac.config, "drop_dm_from_unknown", xs_stock(XSTYPE_TRUE));
else
snac.config = xs_dict_set(snac.config, "drop_dm_from_unknown", xs_stock(XSTYPE_FALSE));
if ((v = xs_dict_get(p_vars, "bot")) != NULL && strcmp(v, "on") == 0)
snac.config = xs_dict_set(snac.config, "bot", xs_stock(XSTYPE_TRUE));
else
snac.config = xs_dict_set(snac.config, "bot", xs_stock(XSTYPE_FALSE));
if ((v = xs_dict_get(p_vars, "private")) != NULL && strcmp(v, "on") == 0)
snac.config = xs_dict_set(snac.config, "private", xs_stock(XSTYPE_TRUE));
else
snac.config = xs_dict_set(snac.config, "private", xs_stock(XSTYPE_FALSE));
if ((v = xs_dict_get(p_vars, "auto_boost")) != NULL && strcmp(v, "on") == 0)
snac.config = xs_dict_set(snac.config, "auto_boost", xs_stock(XSTYPE_TRUE));
else
snac.config = xs_dict_set(snac.config, "auto_boost", xs_stock(XSTYPE_FALSE));
if ((v = xs_dict_get(p_vars, "collapse_threads")) != NULL && strcmp(v, "on") == 0)
snac.config = xs_dict_set(snac.config, "collapse_threads", xs_stock(XSTYPE_TRUE));
else
snac.config = xs_dict_set(snac.config, "collapse_threads", xs_stock(XSTYPE_FALSE));
if ((v = xs_dict_get(p_vars, "approve_followers")) != NULL && strcmp(v, "on") == 0)
snac.config = xs_dict_set(snac.config, "approve_followers", xs_stock(XSTYPE_TRUE));
else
snac.config = xs_dict_set(snac.config, "approve_followers", xs_stock(XSTYPE_FALSE));
if ((v = xs_dict_get(p_vars, "show_contact_metrics")) != NULL && strcmp(v, "on") == 0)
snac.config = xs_dict_set(snac.config, "show_contact_metrics", xs_stock(XSTYPE_TRUE));
else
snac.config = xs_dict_set(snac.config, "show_contact_metrics", xs_stock(XSTYPE_FALSE));
if ((v = xs_dict_get(p_vars, "metadata")) != NULL)
snac.config = xs_dict_set(snac.config, "metadata", v);
/* uploads */
const char *uploads[] = { "avatar", "header", NULL };
int n;
for (n = 0; uploads[n]; n++) {
xs *var_name = xs_fmt("%s_file", uploads[n]);
const xs_list *uploaded_file = xs_dict_get(p_vars, var_name);
if (xs_type(uploaded_file) == XSTYPE_LIST) {
const char *fn = xs_list_get(uploaded_file, 0);
if (fn && *fn) {
const char *mimetype = xs_mime_by_ext(fn);
if (xs_startswith(mimetype, "image/")) {
const char *ext = strrchr(fn, '.');
xs *hash = xs_md5_hex(fn, strlen(fn));
xs *id = xs_fmt("%s%s", hash, ext);
xs *url = xs_fmt("%s/s/%s", snac.actor, id);
int fo = xs_number_get(xs_list_get(uploaded_file, 1));
int fs = xs_number_get(xs_list_get(uploaded_file, 2));
/* store */
static_put(&snac, id, payload + fo, fs);
snac.config = xs_dict_set(snac.config, uploads[n], url);
}
}
}
}
/* delete images by removing url from user.json */
for (n = 0; uploads[n]; n++) {
xs *var_name = xs_fmt("%s_delete", uploads[n]);
const char *delete_var = xs_dict_get(p_vars, var_name);
if (delete_var != NULL && strcmp(delete_var, "on") == 0) {
snac.config = xs_dict_set(snac.config, uploads[n], "");
}
}
/* password change? */
if ((p1 = xs_dict_get(p_vars, "passwd1")) != NULL &&
(p2 = xs_dict_get(p_vars, "passwd2")) != NULL &&
*p1 && strcmp(p1, p2) == 0) {
xs *pw = hash_password(snac.uid, p1, NULL);
snac.config = xs_dict_set(snac.config, "passwd", pw);
}
user_persist(&snac, 1);
status = HTTP_STATUS_SEE_OTHER;
}
else
if (p_path && strcmp(p_path, "admin/clear-notifications") == 0) { /** **/
notify_clear(&snac);
timeline_touch(&snac);
status = HTTP_STATUS_SEE_OTHER;
}
else
if (p_path && strcmp(p_path, "admin/vote") == 0) { /** **/
const char *irt = xs_dict_get(p_vars, "irt");
const char *opt = xs_dict_get(p_vars, "question");
const char *actor = xs_dict_get(p_vars, "actor");
xs *ls = NULL;
/* multiple choices? */
if (xs_type(opt) == XSTYPE_LIST)
ls = xs_dup(opt);
else
if (xs_type(opt) == XSTYPE_STRING) {
ls = xs_list_new();
ls = xs_list_append(ls, opt);
}
const xs_str *v;
int c = 0;
while (xs_list_next(ls, &v, &c)) {
xs *msg = msg_note(&snac, "", actor, irt, NULL, 1);
/* set the option */
msg = xs_dict_append(msg, "name", v);
xs *c_msg = msg_create(&snac, msg);
enqueue_message(&snac, c_msg);
timeline_add(&snac, xs_dict_get(msg, "id"), msg);
}
if (ls != NULL) {
/* get the poll object */
xs *poll = NULL;
if (valid_status(object_get(irt, &poll))) {
const char *date = xs_dict_get(poll, "endTime");
if (xs_is_null(date))
date = xs_dict_get(poll, "closed");
if (!xs_is_null(date)) {
time_t t = xs_parse_iso_date(date, 0) - time(NULL);
/* request the poll when it's closed;
Pleroma does not send and update when the poll closes */
enqueue_object_request(&snac, irt, t + 2);
}
}
}
status = HTTP_STATUS_SEE_OTHER;
}
if (status == HTTP_STATUS_SEE_OTHER) {
const char *redir = xs_dict_get(p_vars, "redir");
if (xs_is_null(redir))
redir = "top";
*body = xs_fmt("%s/admin#%s", snac.actor, redir);
*b_size = strlen(*body);
}
user_free(&snac);
return status;
}
xs_str *timeline_to_rss(snac *user, const xs_list *timeline,
const char *title, const char *link, const char *desc)
/* converts a timeline to rss */
{
xs_html *rss = xs_html_tag("rss",
xs_html_attr("xmlns:content", "http:/" "/purl.org/rss/1.0/modules/content/"),
xs_html_attr("version", "2.0"),
xs_html_attr("xmlns:atom", "http:/" "/www.w3.org/2005/Atom"));
xs_html *channel = xs_html_tag("channel",
xs_html_tag("title",
xs_html_text(title)),
xs_html_tag("language",
xs_html_text("en")),
xs_html_tag("link",
xs_html_text(link)),
xs_html_sctag("atom:link",
xs_html_attr("href", link),
xs_html_attr("rel", "self"),
xs_html_attr("type", "application/rss+xml")),
xs_html_tag("generator",
xs_html_text(USER_AGENT)),
xs_html_tag("description",
xs_html_text(desc)));
xs_html_add(rss, channel);
int cnt = 0;
const char *v;
xs_list_foreach(timeline, v) {
xs *msg = NULL;
if (user) {
if (!valid_status(timeline_get_by_md5(user, v, &msg)))
continue;
}
else {
if (!valid_status(object_get_by_md5(v, &msg)))
continue;
}
const char *id = xs_dict_get(msg, "id");
const char *content = xs_dict_get(msg, "content");
const char *published = xs_dict_get(msg, "published");
if (user && !xs_startswith(id, user->actor))
continue;
if (!id || !content || !published)
continue;
/* create a title with the first line of the content */
xs *title = xs_replace(content, "
", "\n");
title = xs_regex_replace_i(title, "<[^>]+>", " ");
title = xs_regex_replace_i(title, "&[^;]+;", " ");
int i;
for (i = 0; title[i] && title[i] != '\n' && i < 50; i++);
if (title[i] != '\0') {
title[i] = '\0';
title = xs_str_cat(title, "...");
}
title = xs_strip_i(title);
/* convert the date */
time_t t = xs_parse_iso_date(published, 0);
xs *rss_date = xs_str_utctime(t, "%a, %d %b %Y %T +0000");
/* if it's the first one, add it to the header */
if (cnt == 0)
xs_html_add(channel,
xs_html_tag("lastBuildDate",
xs_html_text(rss_date)));
xs_html_add(channel,
xs_html_tag("item",
xs_html_tag("title",
xs_html_text(title)),
xs_html_tag("link",
xs_html_text(id)),
xs_html_tag("guid",
xs_html_text(id)),
xs_html_tag("pubDate",
xs_html_text(rss_date)),
xs_html_tag("description",
xs_html_text(content))));
cnt++;
}
return xs_html_render_s(rss, "\n");
}