mirrors/snac2
3
0
Fork 0
mirror of https://codeberg.org/grunfink/snac2.git synced 2024-11-09 19:50:26 +03:00
Code Issues Packages Projects Releases Wiki Activity
c9c9b0bfdc
snac2/mastoapi.c

3113 lines
101 KiB
C
Raw Normal View History

New file mastoapi.c.
2023-04-08 07:09:05 +03:00
/* snac - A simple, minimalistic ActivityPub instance */
Updated copyright year.
2024-01-04 11:22:03 +03:00
/* copyright (c) 2022 - 2024 grunfink et al. / MIT license */
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
Added a new compilation variable NO_MASTODON_API. The Mastodon API is a big and ugly beast; if you don't want it in your snac, you can compile it out by running make CFLAGS=-DNO_MASTODON_API And your snac binary will be as slim as always.
2023-04-22 00:17:58 +03:00
#ifndef NO_MASTODON_API
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
#include "xs.h"
Backport from xs.
2023-11-17 10:51:53 +03:00
#include "xs_hex.h"
More mastoapi work.
2023-04-10 01:08:51 +03:00
#include "xs_openssl.h"
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
#include "xs_json.h"
More mastoapi work.
2023-04-08 11:29:33 +03:00
#include "xs_io.h"
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
#include "xs_time.h"
Incomplete mastoapi apps are purged.
2023-04-28 09:58:33 +03:00
#include "xs_glob.h"
Don't repeat accounts when searching.
2023-05-15 12:23:36 +03:00
#include "xs_set.h"
Replaced usage of random() with xs_rnd_buf().
2023-06-05 19:29:25 +03:00
#include "xs_random.h"
Backport from xs.
2023-09-25 19:25:09 +03:00
#include "xs_url.h"
mastoapi: in instance, return the list of supported mime types from the internal list.
2023-08-17 19:06:36 +03:00
#include "xs_mime.h"
mastoapi: Don't exclude posts of type Page or Article.
2023-10-16 21:49:58 +03:00
#include "xs_match.h"
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
#include "snac.h"
More mastoapi work.
2023-04-08 10:09:43 +03:00
static xs_str *random_str(void)
/* just what is says in the tin */
{
unsigned int data[4] = {0};
Replaced usage of random() with xs_rnd_buf().
2023-06-05 19:29:25 +03:00
xs_rnd_buf(data, sizeof(data));
More mastoapi work.
2023-04-08 10:09:43 +03:00
return xs_hex_enc((char *)data, sizeof(data));
}
More mastoapi work.
2023-04-08 11:29:33 +03:00
int app_add(const char *id, const xs_dict *app)
/* stores an app */
{
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
if (!xs_is_hex(id))
return 500;
More mastoapi work.
2023-04-08 11:29:33 +03:00
int status = 201;
xs *fn = xs_fmt("%s/app/", srv_basedir);
FILE *f;
mkdirx(fn);
fn = xs_str_cat(fn, id);
fn = xs_str_cat(fn, ".json");
if ((f = fopen(fn, "w")) != NULL) {
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
xs_json_dump(app, 4, f);
More mastoapi work.
2023-04-08 11:29:33 +03:00
fclose(f);
}
else
status = 500;
return status;
}
Incomplete mastoapi apps are purged.
2023-04-28 09:58:33 +03:00
xs_str *_app_fn(const char *id)
{
return xs_fmt("%s/app/%s.json", srv_basedir, id);
}
More mastoapi work.
2023-04-08 11:29:33 +03:00
xs_dict *app_get(const char *id)
/* gets an app */
{
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
if (!xs_is_hex(id))
return NULL;
Incomplete mastoapi apps are purged.
2023-04-28 09:58:33 +03:00
xs *fn = _app_fn(id);
More mastoapi work.
2023-04-08 11:29:33 +03:00
xs_dict *app = NULL;
FILE *f;
if ((f = fopen(fn, "r")) != NULL) {
Added xs_json_load() wherever possible.
2023-08-05 15:56:07 +03:00
app = xs_json_load(f);
More mastoapi work.
2023-04-08 11:29:33 +03:00
fclose(f);
}
return app;
}
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
int app_del(const char *id)
/* deletes an app */
{
if (!xs_is_hex(id))
return -1;
Incomplete mastoapi apps are purged.
2023-04-28 09:58:33 +03:00
xs *fn = _app_fn(id);
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
return unlink(fn);
}
More mastoapi work.
2023-04-09 22:31:56 +03:00
int token_add(const char *id, const xs_dict *token)
/* stores a token */
{
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
if (!xs_is_hex(id))
return 500;
More mastoapi work.
2023-04-09 22:31:56 +03:00
int status = 201;
xs *fn = xs_fmt("%s/token/", srv_basedir);
FILE *f;
mkdirx(fn);
fn = xs_str_cat(fn, id);
fn = xs_str_cat(fn, ".json");
if ((f = fopen(fn, "w")) != NULL) {
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
xs_json_dump(token, 4, f);
More mastoapi work.
2023-04-09 22:31:56 +03:00
fclose(f);
}
else
status = 500;
return status;
}
xs_dict *token_get(const char *id)
/* gets a token */
{
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
if (!xs_is_hex(id))
return NULL;
More mastoapi work.
2023-04-09 22:31:56 +03:00
xs *fn = xs_fmt("%s/token/%s.json", srv_basedir, id);
xs_dict *token = NULL;
FILE *f;
if ((f = fopen(fn, "r")) != NULL) {
Added xs_json_load() wherever possible.
2023-08-05 15:56:07 +03:00
token = xs_json_load(f);
More mastoapi work.
2023-04-09 22:31:56 +03:00
fclose(f);
}
return token;
}
int token_del(const char *id)
/* deletes a token */
{
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
if (!xs_is_hex(id))
return -1;
More mastoapi work.
2023-04-09 22:31:56 +03:00
xs *fn = xs_fmt("%s/token/%s.json", srv_basedir, id);
return unlink(fn);
}
The /oauth/authorize URL generates a login page.
2023-04-08 10:27:22 +03:00
const char *login_page = ""
"<!DOCTYPE html>\n"
Explicitly support dark mode to fix mismatched colors in clients like Tusky
2023-09-21 04:03:57 +03:00
"<html>\n"
"<head>\n"
Put hostname in OAuth page title for web-based clients like Elk
2023-09-21 04:16:13 +03:00
"<title>%s OAuth - Snac2</title>\n"
Explicitly support dark mode to fix mismatched colors in clients like Tusky
2023-09-21 04:03:57 +03:00
"<style>:root {color-scheme: light dark}</style>\n"
"</head>\n"
OAuth login now works.
2023-04-09 21:34:05 +03:00
"<body><h1>%s OAuth identify</h1>\n"
"<div style=\"background-color: red; color: white\">%s</div>\n"
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
"<form method=\"post\" action=\"%s:/" "/%s/%s\">\n"
The /oauth/authorize URL generates a login page.
2023-04-08 10:27:22 +03:00
"<p>Login: <input type=\"text\" name=\"login\"></p>\n"
"<p>Password: <input type=\"password\" name=\"passwd\"></p>\n"
"<input type=\"hidden\" name=\"redir\" value=\"%s\">\n"
More mastoapi work.
2023-04-08 11:29:33 +03:00
"<input type=\"hidden\" name=\"cid\" value=\"%s\">\n"
Added some tweaks for AndStatus, that does some things different (still non-working). AndStatus expects a 'state' field to be propagated and doesn't send the 'client_secret' as a GET argument, but in a Basic authorization header.
2023-04-10 13:55:03 +03:00
"<input type=\"hidden\" name=\"state\" value=\"%s\">\n"
OAuth login now works.
2023-04-09 21:34:05 +03:00
"<input type=\"submit\" value=\"OK\">\n"
Explicitly support dark mode to fix mismatched colors in clients like Tusky
2023-09-21 04:03:57 +03:00
"</form><p>%s</p></body></html>\n"
The /oauth/authorize URL generates a login page.
2023-04-08 10:27:22 +03:00
"";
More mastoapi work.
2023-04-08 10:09:43 +03:00
int oauth_get_handler(const xs_dict *req, const char *q_path,
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
char **body, int *b_size, char **ctype)
{
Added -Wextra to C flags.
2023-05-04 10:28:36 +03:00
(void)b_size;
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
if (!xs_startswith(q_path, "/oauth/"))
return 0;
int status = 404;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_dict *msg = xs_dict_get(req, "q_vars");
Use xs_replace_n() where it suits.
2023-05-02 07:49:00 +03:00
xs *cmd = xs_replace_n(q_path, "/oauth", "", 1);
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_debug(1, xs_fmt("oauth_get_handler %s", q_path));
OAuth login now works.
2023-04-09 21:34:05 +03:00
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/authorize") == 0) { /** **/
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
const char *cid = xs_dict_get(msg, "client_id");
const char *ruri = xs_dict_get(msg, "redirect_uri");
const char *rtype = xs_dict_get(msg, "response_type");
Added some tweaks for AndStatus, that does some things different (still non-working). AndStatus expects a 'state' field to be propagated and doesn't send the 'client_secret' as a GET argument, but in a Basic authorization header.
2023-04-10 13:55:03 +03:00
const char *state = xs_dict_get(msg, "state");
More mastoapi work.
2023-04-08 11:29:33 +03:00
status = 400;
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
if (cid && ruri && rtype && strcmp(rtype, "code") == 0) {
More mastoapi work.
2023-04-08 11:29:33 +03:00
xs *app = app_get(cid);
The /oauth/authorize URL generates a login page.
2023-04-08 10:27:22 +03:00
More mastoapi work.
2023-04-08 11:29:33 +03:00
if (app != NULL) {
const char *host = xs_dict_get(srv_config, "host");
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
const char *proto = xs_dict_get_def(srv_config, "protocol", "https");
More mastoapi work.
2023-04-08 11:29:33 +03:00
Added some tweaks for AndStatus, that does some things different (still non-working). AndStatus expects a 'state' field to be propagated and doesn't send the 'client_secret' as a GET argument, but in a Basic authorization header.
2023-04-10 13:55:03 +03:00
if (xs_is_null(state))
state = "";
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
*body = xs_fmt(login_page, host, host, "", proto, host, "oauth/x-snac-login",
Made the post action configurable in login_page.
2023-05-04 12:08:35 +03:00
ruri, cid, state, USER_AGENT);
More mastoapi work.
2023-04-08 11:29:33 +03:00
*ctype = "text/html";
status = 200;
OAuth login now works.
2023-04-09 21:34:05 +03:00
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("oauth authorize: generating login page"));
More mastoapi work.
2023-04-08 11:29:33 +03:00
}
OAuth login now works.
2023-04-09 21:34:05 +03:00
else
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("oauth authorize: bad client_id %s", cid));
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
}
OAuth login now works.
2023-04-09 21:34:05 +03:00
else
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("oauth authorize: invalid or unset arguments"));
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
}
New url /oauth/x-snac-get-token.
2023-05-04 12:52:04 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/x-snac-get-token") == 0) { /** **/
New url /oauth/x-snac-get-token.
2023-05-04 12:52:04 +03:00
const char *host = xs_dict_get(srv_config, "host");
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
const char *proto = xs_dict_get_def(srv_config, "protocol", "https");
New url /oauth/x-snac-get-token.
2023-05-04 12:52:04 +03:00
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
*body = xs_fmt(login_page, host, host, "", proto, host, "oauth/x-snac-get-token",
New url /oauth/x-snac-get-token.
2023-05-04 12:52:04 +03:00
"", "", "", USER_AGENT);
*ctype = "text/html";
status = 200;
}
More mastoapi work.
2023-04-08 10:09:43 +03:00
return status;
}
int oauth_post_handler(const xs_dict *req, const char *q_path,
OAuth login now works.
2023-04-09 21:34:05 +03:00
const char *payload, int p_size,
char **body, int *b_size, char **ctype)
More mastoapi work.
2023-04-08 10:09:43 +03:00
{
Added -Wextra to C flags.
2023-05-04 10:28:36 +03:00
(void)p_size;
(void)b_size;
More mastoapi work.
2023-04-08 10:09:43 +03:00
if (!xs_startswith(q_path, "/oauth/"))
return 0;
int status = 404;
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *i_ctype = xs_dict_get(req, "content-type");
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
xs *args = NULL;
mastoapi: avoid crashing on empty payloads.
2024-01-26 21:01:59 +03:00
if (i_ctype && xs_startswith(i_ctype, "application/json")) {
if (!xs_is_null(payload))
args = xs_json_loads(payload);
}
Some mastoapi tweaks to support the semaphore.social web client.
2023-08-12 22:46:54 +03:00
else
if (i_ctype && xs_startswith(i_ctype, "application/x-www-form-urlencoded") && payload) {
xs *upl = xs_url_dec(payload);
args = xs_url_vars(upl);
}
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
else
args = xs_dup(xs_dict_get(req, "p_vars"));
mastoapi: avoid crashing on empty payloads.
2024-01-26 21:01:59 +03:00
if (args == NULL)
return 400;
Use xs_replace_n() where it suits.
2023-05-02 07:49:00 +03:00
xs *cmd = xs_replace_n(q_path, "/oauth", "", 1);
More mastoapi work.
2023-04-08 10:09:43 +03:00
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_debug(1, xs_fmt("oauth_post_handler %s", q_path));
OAuth login now works.
2023-04-09 21:34:05 +03:00
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/x-snac-login") == 0) { /** **/
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
const char *login = xs_dict_get(args, "login");
const char *passwd = xs_dict_get(args, "passwd");
const char *redir = xs_dict_get(args, "redir");
const char *cid = xs_dict_get(args, "cid");
const char *state = xs_dict_get(args, "state");
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
const char *host = xs_dict_get(srv_config, "host");
const char *proto = xs_dict_get_def(srv_config, "protocol", "https");
OAuth login now works.
2023-04-09 21:34:05 +03:00
/* by default, generate another login form with an error */
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
*body = xs_fmt(login_page, host, host, "LOGIN INCORRECT", proto, host, "oauth/x-snac-login",
Made the post action configurable in login_page.
2023-05-04 12:08:35 +03:00
redir, cid, state, USER_AGENT);
OAuth login now works.
2023-04-09 21:34:05 +03:00
*ctype = "text/html";
status = 200;
if (login && passwd && redir && cid) {
snac snac;
More mastoapi work.
2023-04-08 10:09:43 +03:00
OAuth login now works.
2023-04-09 21:34:05 +03:00
if (user_open(&snac, login)) {
/* check the login + password */
Made the post action configurable in login_page.
2023-05-04 12:08:35 +03:00
if (check_password(login, passwd, xs_dict_get(snac.config, "passwd"))) {
OAuth login now works.
2023-04-09 21:34:05 +03:00
/* success! redirect to the desired uri */
xs *code = random_str();
xs_free(*body);
mastoapi: correctly print the auth key in the sepcial urn:ietf... case.
2023-12-05 07:47:53 +03:00
if (strcmp(redir, "urn:ietf:wg:oauth:2.0:oob") == 0) {
*body = xs_dup(code);
}
else {
mastoapi: Fixed login bug.
2024-04-27 09:30:56 +03:00
if (xs_str_in(redir, "?") != -1)
Better redirection URL building in oauth_post_handler().
2024-04-14 20:24:06 +03:00
*body = xs_fmt("%s&code=%s", redir, code);
else
*body = xs_fmt("%s?code=%s", redir, code);
mastoapi: correctly print the auth key in the sepcial urn:ietf... case.
2023-12-05 07:47:53 +03:00
status = 303;
}
OAuth login now works.
2023-04-09 21:34:05 +03:00
Added some tweaks for AndStatus, that does some things different (still non-working). AndStatus expects a 'state' field to be propagated and doesn't send the 'client_secret' as a GET argument, but in a Basic authorization header.
2023-04-10 13:55:03 +03:00
/* if there is a state, add it */
if (!xs_is_null(state) && *state) {
*body = xs_str_cat(*body, "&state=");
*body = xs_str_cat(*body, state);
}
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_log(xs_fmt("oauth x-snac-login: '%s' success, redirect to %s",
login, *body));
More mastoapi work.
2023-04-09 22:31:56 +03:00
/* assign the login to the app */
xs *app = app_get(cid);
if (app != NULL) {
app = xs_dict_set(app, "uid", login);
app = xs_dict_set(app, "code", code);
app_add(cid, app);
}
else
srv_log(xs_fmt("oauth x-snac-login: error getting app %s", cid));
OAuth login now works.
2023-04-09 21:34:05 +03:00
}
else
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_debug(1, xs_fmt("oauth x-snac-login: login '%s' incorrect", login));
OAuth login now works.
2023-04-09 21:34:05 +03:00
user_free(&snac);
}
else
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_debug(1, xs_fmt("oauth x-snac-login: bad user '%s'", login));
OAuth login now works.
2023-04-09 21:34:05 +03:00
}
else
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_debug(1, xs_fmt("oauth x-snac-login: invalid or unset arguments"));
OAuth login now works.
2023-04-09 21:34:05 +03:00
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/token") == 0) { /** **/
Force failure in Mastodon API before it gets to a crash-on-startup situation.
2023-04-15 19:14:24 +03:00
xs *wrk = NULL;
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
const char *gtype = xs_dict_get(args, "grant_type");
const char *code = xs_dict_get(args, "code");
const char *cid = xs_dict_get(args, "client_id");
const char *csec = xs_dict_get(args, "client_secret");
const char *ruri = xs_dict_get(args, "redirect_uri");
Force failure in Mastodon API before it gets to a crash-on-startup situation.
2023-04-15 19:14:24 +03:00
/* FIXME: this 'scope' parameter is mandatory for the official Mastodon API,
but if it's enabled, it makes it crash after some more steps, which
is FAR WORSE */
const char *scope = NULL;
mastoapi: added more dummy fields to accounts.
2024-03-13 12:30:03 +03:00
// scope = xs_dict_get(args, "scope");
Added some tweaks for AndStatus, that does some things different (still non-working). AndStatus expects a 'state' field to be propagated and doesn't send the 'client_secret' as a GET argument, but in a Basic authorization header.
2023-04-10 13:55:03 +03:00
/* no client_secret? check if it's inside an authorization header
(AndStatus does it this way) */
if (xs_is_null(csec)) {
const char *auhdr = xs_dict_get(req, "authorization");
if (!xs_is_null(auhdr) && xs_startswith(auhdr, "Basic ")) {
Use xs_replace_n() where it suits.
2023-05-02 07:49:00 +03:00
xs *s1 = xs_replace_n(auhdr, "Basic ", "", 1);
Added some tweaks for AndStatus, that does some things different (still non-working). AndStatus expects a 'state' field to be propagated and doesn't send the 'client_secret' as a GET argument, but in a Basic authorization header.
2023-04-10 13:55:03 +03:00
int size;
xs *s2 = xs_base64_dec(s1, &size);
if (!xs_is_null(s2)) {
xs *l1 = xs_split(s2, ":");
if (xs_list_len(l1) == 2) {
wrk = xs_dup(xs_list_get(l1, 1));
csec = wrk;
}
}
}
}
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
Some formatting tweaks.
2024-03-12 09:03:44 +03:00
/* no code?
I'm not sure of the impacts of this right now, but Subway Tooter does not
provide a code so one must be generated */
formatting
2024-01-29 00:14:46 +03:00
if (xs_is_null(code)){
code = random_str();
}
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
if (gtype && code && cid && csec && ruri) {
More mastoapi work.
2023-04-09 22:31:56 +03:00
xs *app = app_get(cid);
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
More mastoapi work.
2023-04-09 22:31:56 +03:00
if (app == NULL) {
status = 401;
srv_log(xs_fmt("oauth token: invalid app %s", cid));
}
else
if (strcmp(csec, xs_dict_get(app, "client_secret")) != 0) {
status = 401;
srv_log(xs_fmt("oauth token: invalid client_secret for app %s", cid));
}
else {
xs *rsp = xs_dict_new();
xs *cat = xs_number_new(time(NULL));
xs *tokid = random_str();
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
More mastoapi work.
2023-04-09 22:31:56 +03:00
rsp = xs_dict_append(rsp, "access_token", tokid);
rsp = xs_dict_append(rsp, "token_type", "Bearer");
rsp = xs_dict_append(rsp, "created_at", cat);
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
if (!xs_is_null(scope))
rsp = xs_dict_append(rsp, "scope", scope);
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(rsp, 4);
More mastoapi work.
2023-04-09 22:31:56 +03:00
*ctype = "application/json";
status = 200;
const char *uid = xs_dict_get(app, "uid");
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("oauth token: "
More mastoapi work.
2023-04-09 22:31:56 +03:00
"successful login for %s, new token %s", uid, tokid));
xs *token = xs_dict_new();
token = xs_dict_append(token, "token", tokid);
token = xs_dict_append(token, "client_id", cid);
token = xs_dict_append(token, "client_secret", csec);
token = xs_dict_append(token, "uid", uid);
token = xs_dict_append(token, "code", code);
OAuth login now works.
2023-04-09 21:34:05 +03:00
More mastoapi work.
2023-04-09 22:31:56 +03:00
token_add(tokid, token);
}
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
}
OAuth login now works.
2023-04-09 21:34:05 +03:00
else {
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("oauth token: invalid or unset arguments"));
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
status = 400;
OAuth login now works.
2023-04-09 21:34:05 +03:00
}
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/revoke") == 0) { /** **/
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
const char *cid = xs_dict_get(args, "client_id");
const char *csec = xs_dict_get(args, "client_secret");
const char *tokid = xs_dict_get(args, "token");
More mastoapi work.
2023-04-09 22:31:56 +03:00
if (cid && csec && tokid) {
xs *token = token_get(tokid);
More mastoapi work.
2023-04-08 10:09:43 +03:00
*body = xs_str_new("{}");
*ctype = "application/json";
More mastoapi work.
2023-04-09 22:31:56 +03:00
if (token == NULL || strcmp(csec, xs_dict_get(token, "client_secret")) != 0) {
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_debug(1, xs_fmt("oauth revoke: bad secret for token %s", tokid));
More mastoapi work.
2023-04-09 22:31:56 +03:00
status = 403;
}
else {
token_del(tokid);
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("oauth revoke: revoked token %s", tokid));
More mastoapi work.
2023-04-09 22:31:56 +03:00
status = 200;
Also delete the app in token revokation.
2023-04-10 10:21:14 +03:00
/* also delete the app, as it serves no purpose from now on */
app_del(cid);
More mastoapi work.
2023-04-09 22:31:56 +03:00
}
}
else {
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("oauth revoke: invalid or unset arguments"));
More mastoapi work.
2023-04-09 22:31:56 +03:00
status = 403;
More mastoapi work.
2023-04-08 10:09:43 +03:00
}
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
}
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/x-snac-get-token") == 0) { /** **/
New url /oauth/x-snac-get-token.
2023-05-04 12:52:04 +03:00
const char *login = xs_dict_get(args, "login");
const char *passwd = xs_dict_get(args, "passwd");
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
const char *host = xs_dict_get(srv_config, "host");
const char *proto = xs_dict_get_def(srv_config, "protocol", "https");
New url /oauth/x-snac-get-token.
2023-05-04 12:52:04 +03:00
/* by default, generate another login form with an error */
Some tweaks to previous patch.
2024-04-18 18:13:31 +03:00
*body = xs_fmt(login_page, host, host, "LOGIN INCORRECT", proto, host, "oauth/x-snac-get-token",
New url /oauth/x-snac-get-token.
2023-05-04 12:52:04 +03:00
"", "", "", USER_AGENT);
*ctype = "text/html";
status = 200;
if (login && passwd) {
snac user;
if (user_open(&user, login)) {
/* check the login + password */
if (check_password(login, passwd, xs_dict_get(user.config, "passwd"))) {
/* success! create a new token */
xs *tokid = random_str();
srv_debug(1, xs_fmt("x-snac-new-token: "
"successful login for %s, new token %s", login, tokid));
xs *token = xs_dict_new();
token = xs_dict_append(token, "token", tokid);
token = xs_dict_append(token, "client_id", "snac-client");
token = xs_dict_append(token, "client_secret", "");
token = xs_dict_append(token, "uid", login);
token = xs_dict_append(token, "code", "");
token_add(tokid, token);
*ctype = "text/plain";
xs_free(*body);
*body = xs_dup(tokid);
}
user_free(&user);
}
}
}
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
return status;
}
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
New function mastoapi_id(), that creates mostly-compatible Ids. Most apps (all?) sort entries by status Id, so they must be time-sorted (somewhat).
2023-04-10 13:14:16 +03:00
xs_str *mastoapi_id(const xs_dict *msg)
/* returns a somewhat Mastodon-compatible status id */
{
Use the ctime instead of the published date in mastoapi_id().
2023-04-12 11:19:43 +03:00
const char *id = xs_dict_get(msg, "id");
xs *md5 = xs_md5_hex(id, strlen(id));
New function mastoapi_id(), that creates mostly-compatible Ids. Most apps (all?) sort entries by status Id, so they must be time-sorted (somewhat).
2023-04-10 13:14:16 +03:00
Use the ctime instead of the published date in mastoapi_id().
2023-04-12 11:19:43 +03:00
return xs_fmt("%10.0f%s", object_ctime_by_md5(md5), md5);
New function mastoapi_id(), that creates mostly-compatible Ids. Most apps (all?) sort entries by status Id, so they must be time-sorted (somewhat).
2023-04-10 13:14:16 +03:00
}
Use the ctime instead of the published date in mastoapi_id().
2023-04-12 11:19:43 +03:00
#define MID_TO_MD5(id) (id + 10)
New function mastoapi_id(), that creates mostly-compatible Ids. Most apps (all?) sort entries by status Id, so they must be time-sorted (somewhat).
2023-04-10 13:14:16 +03:00
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
xs_dict *mastoapi_account(const xs_dict *actor)
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
/* converts an ActivityPub actor to a Mastodon account */
New function mastodon_status().
2023-04-11 10:50:12 +03:00
{
Minor tweak for better corruption detection.
2024-01-12 13:03:29 +03:00
const char *id = xs_dict_get(actor, "id");
const char *pub = xs_dict_get(actor, "published");
if (xs_type(id) != XSTYPE_STRING)
return NULL;
Deleted repeated code.
2023-05-15 12:38:29 +03:00
const char *prefu = xs_dict_get(actor, "preferredUsername");
New function mastodon_status().
2023-04-11 10:50:12 +03:00
const char *display_name = xs_dict_get(actor, "name");
if (xs_is_null(display_name) || *display_name == '\0')
Deleted repeated code.
2023-05-15 12:38:29 +03:00
display_name = prefu;
New function mastodon_status().
2023-04-11 10:50:12 +03:00
More tries to fix crashes in mastoapi_account().
2024-01-11 23:33:41 +03:00
xs_dict *acct = xs_dict_new();
xs *acct_md5 = xs_md5_hex(id, strlen(id));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
acct = xs_dict_append(acct, "id", acct_md5);
Deleted repeated code.
2023-05-15 12:38:29 +03:00
acct = xs_dict_append(acct, "username", prefu);
New function mastodon_status().
2023-04-11 10:50:12 +03:00
acct = xs_dict_append(acct, "display_name", display_name);
Backport from xs.
2024-03-15 06:10:11 +03:00
acct = xs_dict_append(acct, "discoverable", xs_stock(XSTYPE_TRUE));
acct = xs_dict_append(acct, "group", xs_stock(XSTYPE_FALSE));
acct = xs_dict_append(acct, "hide_collections", xs_stock(XSTYPE_FALSE));
acct = xs_dict_append(acct, "indexable", xs_stock(XSTYPE_TRUE));
acct = xs_dict_append(acct, "noindex", xs_stock(XSTYPE_FALSE));
acct = xs_dict_append(acct, "roles", xs_stock(XSTYPE_LIST));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
mastoapi_account() returns the acct field as user@host.
2023-05-15 12:36:09 +03:00
{
/* create the acct field as user@host */
xs *l = xs_split(id, "/");
Deleted repeated code.
2023-05-15 12:38:29 +03:00
xs *fquid = xs_fmt("%s@%s", prefu, xs_list_get(l, 2));
mastoapi_account() returns the acct field as user@host.
2023-05-15 12:36:09 +03:00
acct = xs_dict_append(acct, "acct", fquid);
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
if (pub)
acct = xs_dict_append(acct, "created_at", pub);
Added a dummy 'created_at' field for accounts that don't have a date. This avoid a crash in Tusky.
2023-04-14 09:14:11 +03:00
else {
/* unset created_at crashes Tusky, so lie like a mf */
New macro ISO_DATE_SPEC.
2023-05-29 10:07:27 +03:00
xs *date = xs_str_utctime(0, ISO_DATE_SPEC);
Added a dummy 'created_at' field for accounts that don't have a date. This avoid a crash in Tusky.
2023-04-14 09:14:11 +03:00
acct = xs_dict_append(acct, "created_at", date);
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
mastoapi: minor tweaks.
2024-04-27 09:02:47 +03:00
xs *last_status_at = xs_str_utctime(0, "%Y-%m-%d");
acct = xs_dict_append(acct, "last_status_at", last_status_at);
Fixed bad JSON for accounts that do not have a 'summary' field.
2023-04-23 16:23:20 +03:00
const char *note = xs_dict_get(actor, "summary");
if (xs_is_null(note))
note = "";
set bot to true in mastodon account if user type is service
2023-06-11 17:53:50 +03:00
if (strcmp(xs_dict_get(actor, "type"), "Service") == 0)
Backport from xs.
2024-03-15 06:10:11 +03:00
acct = xs_dict_append(acct, "bot", xs_stock(XSTYPE_TRUE));
set bot to true in mastodon account if user type is service
2023-06-11 17:53:50 +03:00
else
Backport from xs.
2024-03-15 06:10:11 +03:00
acct = xs_dict_append(acct, "bot", xs_stock(XSTYPE_FALSE));
set bot to true in mastodon account if user type is service
2023-06-11 17:53:50 +03:00
Fixed bad JSON for accounts that do not have a 'summary' field.
2023-04-23 16:23:20 +03:00
acct = xs_dict_append(acct, "note", note);
Added emojis to mastoapi_account().
2023-04-24 18:37:59 +03:00
acct = xs_dict_append(acct, "url", id);
mastoapi: added more dummy fields to accounts.
2024-03-13 12:30:03 +03:00
acct = xs_dict_append(acct, "uri", id);
New function mastodon_status().
2023-04-11 10:50:12 +03:00
xs *avatar = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_dict *av = xs_dict_get(actor, "icon");
New function mastodon_status().
2023-04-11 10:50:12 +03:00
Fixed crash.
2023-10-16 19:40:43 +03:00
if (xs_type(av) == XSTYPE_DICT) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *url = xs_dict_get(av, "url");
Fixed crash.
2023-10-16 19:40:43 +03:00
if (url != NULL)
avatar = xs_dup(url);
}
if (avatar == NULL)
New function mastodon_status().
2023-04-11 10:50:12 +03:00
avatar = xs_fmt("%s/susie.png", srv_baseurl);
acct = xs_dict_append(acct, "avatar", avatar);
add mastodon profile header to mastodon api
2023-06-12 11:42:59 +03:00
acct = xs_dict_append(acct, "avatar_static", avatar);
xs *header = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_dict *hd = xs_dict_get(actor, "image");
add mastodon profile header to mastodon api
2023-06-12 11:42:59 +03:00
if (xs_type(hd) == XSTYPE_DICT)
header = xs_dup(xs_dict_get(hd, "url"));
Avoid writing a NULL header in mastoapi_account().
2023-06-12 20:39:15 +03:00
if (xs_is_null(header))
mastoapi: return a dummy header field in accounts.
2024-03-13 12:07:02 +03:00
header = xs_fmt("%s/header.png", srv_baseurl);
Avoid writing a NULL header in mastoapi_account().
2023-06-12 20:39:15 +03:00
add mastodon profile header to mastodon api
2023-06-12 11:42:59 +03:00
acct = xs_dict_append(acct, "header", header);
acct = xs_dict_append(acct, "header_static", header);
New function mastodon_status().
2023-04-11 10:50:12 +03:00
Added emojis to mastoapi_account().
2023-04-24 18:37:59 +03:00
/* emojis */
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *p;
Added emojis to mastoapi_account().
2023-04-24 18:37:59 +03:00
if (!xs_is_null(p = xs_dict_get(actor, "tag"))) {
xs *eml = xs_list_new();
xs_dict *v;
Added const everywhere.
2024-05-21 15:12:15 +03:00
int c = 0;
Added emojis to mastoapi_account().
2023-04-24 18:37:59 +03:00
Added const everywhere.
2024-05-21 15:12:15 +03:00
while (xs_list_next(p, &v, &c)) {
Added emojis to mastoapi_account().
2023-04-24 18:37:59 +03:00
const char *type = xs_dict_get(v, "type");
if (!xs_is_null(type) && strcmp(type, "Emoji") == 0) {
const char *name = xs_dict_get(v, "name");
const xs_dict *icon = xs_dict_get(v, "icon");
if (!xs_is_null(name) && !xs_is_null(icon)) {
const char *url = xs_dict_get(icon, "url");
if (!xs_is_null(url)) {
xs *nm = xs_strip_chars_i(xs_dup(name), ":");
xs *d1 = xs_dict_new();
d1 = xs_dict_append(d1, "shortcode", nm);
d1 = xs_dict_append(d1, "url", url);
d1 = xs_dict_append(d1, "static_url", url);
Backport from xs.
2024-03-15 06:10:11 +03:00
d1 = xs_dict_append(d1, "visible_in_picker", xs_stock(XSTYPE_TRUE));
Added emojis to mastoapi_account().
2023-04-24 18:37:59 +03:00
eml = xs_list_append(eml, d1);
}
}
}
}
acct = xs_dict_append(acct, "emojis", eml);
}
Backport from xs.
2024-03-15 06:10:11 +03:00
acct = xs_dict_append(acct, "locked", xs_stock(XSTYPE_FALSE));
acct = xs_dict_append(acct, "followers_count", xs_stock(0));
acct = xs_dict_append(acct, "following_count", xs_stock(0));
acct = xs_dict_append(acct, "statuses_count", xs_stock(0));
mastoapi: patched dates to match the funny timezone Mastodon uses.
2023-12-03 12:05:04 +03:00
Fill the 'fields' list in mastoapi_account().
2023-12-03 12:57:54 +03:00
xs *fields = xs_list_new();
p = xs_dict_get(actor, "attachment");
xs_dict *v;
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
/* dict of validated links */
xs_dict *val_links = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_dict *metadata = xs_stock(XSTYPE_DICT);
Moved verified links to its own json file.
2024-02-15 19:34:46 +03:00
snac user = {0};
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
if (xs_startswith(id, srv_baseurl)) {
/* if it's a local user, open it and pick its validated links */
mastoapi: fixed a bug in validated links.
2024-02-28 17:16:28 +03:00
if (user_open(&user, prefu)) {
Moved verified links to its own json file.
2024-02-15 19:34:46 +03:00
val_links = user.links;
Backport from xs.
2024-03-15 06:10:11 +03:00
metadata = xs_dict_get_def(user.config, "metadata", xs_stock(XSTYPE_DICT));
mastoapi: fixed a bug in validated links.
2024-02-28 17:16:28 +03:00
}
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
}
if (xs_is_null(val_links))
Backport from xs.
2024-03-15 06:10:11 +03:00
val_links = xs_stock(XSTYPE_DICT);
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
Added const everywhere.
2024-05-21 15:12:15 +03:00
int c = 0;
while (xs_list_next(p, &v, &c)) {
const char *type = xs_dict_get(v, "type");
const char *name = xs_dict_get(v, "name");
const char *value = xs_dict_get(v, "value");
Fill the 'fields' list in mastoapi_account().
2023-12-03 12:57:54 +03:00
if (!xs_is_null(type) && !xs_is_null(name) &&
!xs_is_null(value) && strcmp(type, "PropertyValue") == 0) {
The link verification time is stored as a time_t. This way, it will be easier in an eventual future to test if a link verification is too old to be trusted.
2024-02-20 08:10:42 +03:00
xs *val_date = NULL;
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *url = xs_dict_get(metadata, name);
mastoapi: fixed a bug in validated links.
2024-02-28 17:16:28 +03:00
mastoapi: check the url before checking.
2024-02-28 17:20:21 +03:00
if (!xs_is_null(url) && xs_startswith(url, "https:/" "/")) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_number *verified_time = xs_dict_get(val_links, url);
The link verification time is stored as a time_t. This way, it will be easier in an eventual future to test if a link verification is too old to be trusted.
2024-02-20 08:10:42 +03:00
if (xs_type(verified_time) == XSTYPE_NUMBER) {
time_t t = xs_number_get(verified_time);
if (t > 0)
val_date = xs_str_utctime(t, ISO_DATE_SPEC);
}
}
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
Fill the 'fields' list in mastoapi_account().
2023-12-03 12:57:54 +03:00
xs *d = xs_dict_new();
d = xs_dict_append(d, "name", name);
d = xs_dict_append(d, "value", value);
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
d = xs_dict_append(d, "verified_at",
xs_type(val_date) == XSTYPE_STRING && *val_date ?
Backport from xs.
2024-03-15 06:10:11 +03:00
val_date : xs_stock(XSTYPE_NULL));
Fill the 'fields' list in mastoapi_account().
2023-12-03 12:57:54 +03:00
fields = xs_list_append(fields, d);
}
}
Moved verified links to its own json file.
2024-02-15 19:34:46 +03:00
user_free(&user);
Fill the 'fields' list in mastoapi_account().
2023-12-03 12:57:54 +03:00
acct = xs_dict_append(acct, "fields", fields);
mastoapi: patched dates to match the funny timezone Mastodon uses.
2023-12-03 12:05:04 +03:00
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
return acct;
}
Added const everywhere.
2024-05-21 15:12:15 +03:00
xs_str *mastoapi_date(const char *date)
mastoapi: patched dates to match the funny timezone Mastodon uses.
2023-12-03 12:05:04 +03:00
/* converts an ISO 8601 date to whatever format Mastodon uses */
{
xs_str *s = xs_crop_i(xs_dup(date), 0, 19);
s = xs_str_cat(s, ".000Z");
return s;
}
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
xs_dict *mastoapi_poll(snac *snac, const xs_dict *msg)
/* creates a mastoapi Poll object */
{
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
xs_dict *poll = xs_dict_new();
xs *mid = mastoapi_id(msg);
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *opts = NULL;
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
xs_val *v;
int num_votes = 0;
xs *options = xs_list_new();
poll = xs_dict_append(poll, "id", mid);
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *date = xs_dict_get(msg, "endTime");
mastoapi: also fix polls from Pleroma.
2024-05-06 06:54:46 +03:00
if (date == NULL)
date = xs_dict_get(msg, "closed");
if (date == NULL)
return NULL;
xs *fd = mastoapi_date(date);
mastoapi: patched dates to match the funny timezone Mastodon uses.
2023-12-03 12:05:04 +03:00
poll = xs_dict_append(poll, "expires_at", fd);
mastoapi: also fix polls from Pleroma.
2024-05-06 06:54:46 +03:00
date = xs_dict_get(msg, "closed");
time_t t = 0;
if (date != NULL)
t = xs_parse_iso_date(date, 0);
Use xs_stock_* values wherever possible.
2023-06-15 18:51:24 +03:00
poll = xs_dict_append(poll, "expired",
mastoapi: also fix polls from Pleroma.
2024-05-06 06:54:46 +03:00
t < time(NULL) ? xs_stock(XSTYPE_FALSE) : xs_stock(XSTYPE_TRUE));
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
if ((opts = xs_dict_get(msg, "oneOf")) != NULL)
Backport from xs.
2024-03-15 06:10:11 +03:00
poll = xs_dict_append(poll, "multiple", xs_stock(XSTYPE_FALSE));
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
else {
opts = xs_dict_get(msg, "anyOf");
Backport from xs.
2024-03-15 06:10:11 +03:00
poll = xs_dict_append(poll, "multiple", xs_stock(XSTYPE_TRUE));
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
}
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
Added const everywhere.
2024-05-21 15:12:15 +03:00
int c = 0;
while (xs_list_next(opts, &v, &c)) {
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
const char *title = xs_dict_get(v, "name");
const char *replies = xs_dict_get(v, "replies");
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
if (title && replies) {
const char *votes_count = xs_dict_get(replies, "totalItems");
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
if (xs_type(votes_count) == XSTYPE_NUMBER) {
xs *d = xs_dict_new();
d = xs_dict_append(d, "title", title);
d = xs_dict_append(d, "votes_count", votes_count);
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
options = xs_list_append(options, d);
num_votes += xs_number_get(votes_count);
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
}
}
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
}
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
poll = xs_dict_append(poll, "options", options);
xs *vc = xs_number_new(num_votes);
poll = xs_dict_append(poll, "votes_count", vc);
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
poll = xs_dict_append(poll, "voted",
mastoapi: fixed /api/timelines/public to not need a bearer token.
2023-08-12 13:10:42 +03:00
(snac && was_question_voted(snac, xs_dict_get(msg, "id"))) ?
Backport from xs.
2024-03-15 06:10:11 +03:00
xs_stock(XSTYPE_TRUE) : xs_stock(XSTYPE_FALSE));
New function mastoapi_poll().
2023-05-31 19:35:50 +03:00
return poll;
}
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
xs_dict *mastoapi_status(snac *snac, const xs_dict *msg)
/* converts an ActivityPub note to a Mastodon status */
{
xs *actor = NULL;
Added actor refreshing via the user queue.
2024-03-12 19:54:54 +03:00
actor_get_refresh(snac, get_atto(msg), &actor);
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
/* if the author is not here, discard */
if (actor == NULL)
return NULL;
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
const char *type = xs_dict_get(msg, "type");
const char *id = xs_dict_get(msg, "id");
Avoid invalid actors in mastoapi_status().
2024-01-11 22:20:01 +03:00
/* fail if it's not a valid actor */
if (xs_is_null(type) || xs_is_null(id))
return NULL;
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
xs *acct = mastoapi_account(actor);
More tries to fix crashes in mastoapi_account().
2024-01-11 23:33:41 +03:00
if (acct == NULL)
return NULL;
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
New function mastodon_status().
2023-04-11 10:50:12 +03:00
xs *idx = NULL;
xs *ixc = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *tmp;
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
xs *mid = mastoapi_id(msg);
New function mastodon_status().
2023-04-11 10:50:12 +03:00
xs_dict *st = xs_dict_new();
st = xs_dict_append(st, "id", mid);
st = xs_dict_append(st, "uri", id);
st = xs_dict_append(st, "url", id);
st = xs_dict_append(st, "account", acct);
mastoapi: Some tweaks to process posts with 'name' and 'image' fields.
2023-08-14 21:11:03 +03:00
mastoapi: patched dates to match the funny timezone Mastodon uses.
2023-12-03 12:05:04 +03:00
xs *fd = mastoapi_date(xs_dict_get(msg, "published"));
st = xs_dict_append(st, "created_at", fd);
mastoapi: Some tweaks to process posts with 'name' and 'image' fields.
2023-08-14 21:11:03 +03:00
{
const char *content = xs_dict_get(msg, "content");
const char *name = xs_dict_get(msg, "name");
xs *s1 = NULL;
mastoapi: some tweaks for posts from lemmy.
2023-08-20 17:03:46 +03:00
if (name && content)
mastoapi: Some tweaks to process posts with 'name' and 'image' fields.
2023-08-14 21:11:03 +03:00
s1 = xs_fmt("%s<br><br>%s", name, content);
else
mastoapi: some tweaks for posts from lemmy.
2023-08-20 17:03:46 +03:00
if (name)
s1 = xs_dup(name);
else
if (content)
mastoapi: Some tweaks to process posts with 'name' and 'image' fields.
2023-08-14 21:11:03 +03:00
s1 = xs_dup(content);
mastoapi: some tweaks for posts from lemmy.
2023-08-20 17:03:46 +03:00
else
s1 = xs_str_new(NULL);
mastoapi: Some tweaks to process posts with 'name' and 'image' fields.
2023-08-14 21:11:03 +03:00
st = xs_dict_append(st, "content", s1);
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
st = xs_dict_append(st, "visibility",
Rewritten is_msg_public() to not depend on a user.
2023-08-12 10:43:01 +03:00
is_msg_public(msg) ? "public" : "private");
New function mastodon_status().
2023-04-11 10:50:12 +03:00
tmp = xs_dict_get(msg, "sensitive");
if (xs_is_null(tmp))
Backport from xs.
2024-03-15 06:10:11 +03:00
tmp = xs_stock(XSTYPE_FALSE);
New function mastodon_status().
2023-04-11 10:50:12 +03:00
st = xs_dict_append(st, "sensitive", tmp);
tmp = xs_dict_get(msg, "summary");
if (xs_is_null(tmp))
tmp = "";
st = xs_dict_append(st, "spoiler_text", tmp);
/* create the list of attachments */
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
xs *attach = get_attachments(msg);
{
xs_list *p = attach;
xs_dict *v;
mastoapi: some tweaks for posts from lemmy.
2023-08-20 17:03:46 +03:00
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
xs *matt = xs_list_new();
while (xs_list_iter(&p, &v)) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *type = xs_dict_get(v, "type");
const char *href = xs_dict_get(v, "href");
const char *name = xs_dict_get(v, "name");
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
if (xs_match(type, "image/*|video/*|Image|Video")) { /* */
Fixed video attachments.
2023-04-26 22:07:00 +03:00
xs *matteid = xs_fmt("%s_%d", id, xs_list_len(matt));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
xs *d = xs_dict_new();
Don't generate invalid JSON if an attachment has no description.
2023-04-12 11:41:15 +03:00
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
d = xs_dict_append(d, "id", matteid);
d = xs_dict_append(d, "url", href);
d = xs_dict_append(d, "preview_url", href);
d = xs_dict_append(d, "remote_url", href);
d = xs_dict_append(d, "description", name);
Don't generate invalid JSON if an attachment has no description.
2023-04-12 11:41:15 +03:00
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
d = xs_dict_append(d, "type", (*type == 'v' || *type == 'V') ? "video" : "image");
New function mastodon_status().
2023-04-11 10:50:12 +03:00
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
matt = xs_list_append(matt, d);
Fixed video attachments.
2023-04-26 22:07:00 +03:00
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
}
Use get_attachments() in mastoapi_status().
2024-01-24 21:58:51 +03:00
st = xs_dict_append(st, "media_attachments", matt);
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
Added mentions to mastoapi_status().
2023-04-24 18:05:34 +03:00
{
xs *ml = xs_list_new();
xs *htl = xs_list_new();
xs *eml = xs_list_new();
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *tag = xs_dict_get(msg, "tag");
Added mentions to mastoapi_status().
2023-04-24 18:05:34 +03:00
int n = 0;
mastoapi: process tag lists that are not lists correctly.
2023-08-23 19:32:08 +03:00
xs *tag_list = NULL;
if (xs_type(tag) == XSTYPE_DICT) {
tag_list = xs_list_new();
tag_list = xs_list_append(tag_list, tag);
}
else
mastoapi: ensure attachment and tag lists are tags.
2023-08-25 08:47:18 +03:00
if (xs_type(tag) == XSTYPE_LIST)
mastoapi: process tag lists that are not lists correctly.
2023-08-23 19:32:08 +03:00
tag_list = xs_dup(tag);
mastoapi: ensure attachment and tag lists are tags.
2023-08-25 08:47:18 +03:00
else
tag_list = xs_list_new();
mastoapi: process tag lists that are not lists correctly.
2023-08-23 19:32:08 +03:00
tag = tag_list;
xs_dict *v;
Added const everywhere.
2024-05-21 15:12:15 +03:00
int c = 0;
while (xs_list_next(tag, &v, &c)) {
Added mentions to mastoapi_status().
2023-04-24 18:05:34 +03:00
const char *type = xs_dict_get(v, "type");
if (xs_is_null(type))
continue;
xs *d1 = xs_dict_new();
if (strcmp(type, "Mention") == 0) {
const char *name = xs_dict_get(v, "name");
const char *href = xs_dict_get(v, "href");
if (!xs_is_null(name) && !xs_is_null(href) &&
mastoapi: fixed /api/timelines/public to not need a bearer token.
2023-08-12 13:10:42 +03:00
(snac == NULL || strcmp(href, snac->actor) != 0)) {
Added mentions to mastoapi_status().
2023-04-24 18:05:34 +03:00
xs *nm = xs_strip_chars_i(xs_dup(name), "@");
xs *id = xs_fmt("%d", n++);
d1 = xs_dict_append(d1, "id", id);
d1 = xs_dict_append(d1, "username", nm);
d1 = xs_dict_append(d1, "acct", nm);
d1 = xs_dict_append(d1, "url", href);
ml = xs_list_append(ml, d1);
}
}
Added the hashtag list to mastoapi_status(). What is this for?
2023-04-24 18:11:12 +03:00
else
if (strcmp(type, "Hashtag") == 0) {
const char *name = xs_dict_get(v, "name");
const char *href = xs_dict_get(v, "href");
if (!xs_is_null(name) && !xs_is_null(href)) {
xs *nm = xs_strip_chars_i(xs_dup(name), "#");
d1 = xs_dict_append(d1, "name", nm);
d1 = xs_dict_append(d1, "url", href);
htl = xs_list_append(htl, d1);
}
}
Added custom emojis to Statuses.
2023-04-24 18:25:32 +03:00
else
if (strcmp(type, "Emoji") == 0) {
const char *name = xs_dict_get(v, "name");
const xs_dict *icon = xs_dict_get(v, "icon");
if (!xs_is_null(name) && !xs_is_null(icon)) {
const char *url = xs_dict_get(icon, "url");
if (!xs_is_null(url)) {
xs *nm = xs_strip_chars_i(xs_dup(name), ":");
d1 = xs_dict_append(d1, "shortcode", nm);
d1 = xs_dict_append(d1, "url", url);
d1 = xs_dict_append(d1, "static_url", url);
Backport from xs.
2024-03-15 06:10:11 +03:00
d1 = xs_dict_append(d1, "visible_in_picker", xs_stock(XSTYPE_TRUE));
Added custom emojis to Statuses.
2023-04-24 18:25:32 +03:00
d1 = xs_dict_append(d1, "category", "Emojis");
eml = xs_list_append(eml, d1);
}
}
}
Added mentions to mastoapi_status().
2023-04-24 18:05:34 +03:00
}
st = xs_dict_append(st, "mentions", ml);
st = xs_dict_append(st, "tags", htl);
st = xs_dict_append(st, "emojis", eml);
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
xs_free(idx);
xs_free(ixc);
idx = object_likes(id);
ixc = xs_number_new(xs_list_len(idx));
st = xs_dict_append(st, "favourites_count", ixc);
st = xs_dict_append(st, "favourited",
Backport from xs.
2024-03-15 06:10:11 +03:00
(snac && xs_list_in(idx, snac->md5) != -1) ? xs_stock(XSTYPE_TRUE) : xs_stock(XSTYPE_FALSE));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
xs_free(idx);
xs_free(ixc);
idx = object_announces(id);
ixc = xs_number_new(xs_list_len(idx));
st = xs_dict_append(st, "reblogs_count", ixc);
st = xs_dict_append(st, "reblogged",
Backport from xs.
2024-03-15 06:10:11 +03:00
(snac && xs_list_in(idx, snac->md5) != -1) ? xs_stock(XSTYPE_TRUE) : xs_stock(XSTYPE_FALSE));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
mastoapi: boosted posts by others are correctly returned.
2023-10-13 10:01:07 +03:00
/* get the last person who boosted this */
xs *boosted_by_md5 = NULL;
if (xs_list_len(idx))
boosted_by_md5 = xs_dup(xs_list_get(idx, -1));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
xs_free(idx);
xs_free(ixc);
idx = object_children(id);
ixc = xs_number_new(xs_list_len(idx));
st = xs_dict_append(st, "replies_count", ixc);
/* default in_reply_to values */
Backport from xs.
2024-03-15 06:10:11 +03:00
st = xs_dict_append(st, "in_reply_to_id", xs_stock(XSTYPE_NULL));
st = xs_dict_append(st, "in_reply_to_account_id", xs_stock(XSTYPE_NULL));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
tmp = xs_dict_get(msg, "inReplyTo");
if (!xs_is_null(tmp)) {
xs *irto = NULL;
if (valid_status(object_get(tmp, &irto))) {
xs *irt_mid = mastoapi_id(irto);
st = xs_dict_set(st, "in_reply_to_id", irt_mid);
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *at = NULL;
New function get_atto(), to get the attributedTo field.
2024-01-19 01:04:37 +03:00
if (!xs_is_null(at = get_atto(irto))) {
New function mastodon_status().
2023-04-11 10:50:12 +03:00
xs *at_md5 = xs_md5_hex(at, strlen(at));
st = xs_dict_set(st, "in_reply_to_account_id", at_md5);
}
}
}
Backport from xs.
2024-03-15 06:10:11 +03:00
st = xs_dict_append(st, "reblog", xs_stock(XSTYPE_NULL));
st = xs_dict_append(st, "card", xs_stock(XSTYPE_NULL));
mastoapi: minor tweaks.
2024-04-27 09:02:47 +03:00
st = xs_dict_append(st, "language", "en");
st = xs_dict_append(st, "filtered", xs_stock(XSTYPE_LIST));
st = xs_dict_append(st, "muted", xs_stock(XSTYPE_FALSE));
New function mastodon_status().
2023-04-11 10:50:12 +03:00
tmp = xs_dict_get(msg, "sourceContent");
if (xs_is_null(tmp))
tmp = "";
st = xs_dict_append(st, "text", tmp);
tmp = xs_dict_get(msg, "updated");
mastoapi: patched dates to match the funny timezone Mastodon uses.
2023-12-03 12:05:04 +03:00
xs *fd2 = NULL;
New function mastodon_status().
2023-04-11 10:50:12 +03:00
if (xs_is_null(tmp))
Backport from xs.
2024-03-15 06:10:11 +03:00
tmp = xs_stock(XSTYPE_NULL);
mastoapi: patched dates to match the funny timezone Mastodon uses.
2023-12-03 12:05:04 +03:00
else {
fd2 = mastoapi_date(tmp);
tmp = fd2;
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
Mastoapi: fixed an error the edited_at field.
2024-01-19 11:35:42 +03:00
st = xs_dict_append(st, "edited_at", tmp);
New function mastodon_status().
2023-04-11 10:50:12 +03:00
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
if (strcmp(type, "Question") == 0) {
xs *poll = mastoapi_poll(snac, msg);
Votes are shown in mastoapi.
2023-05-31 11:49:08 +03:00
st = xs_dict_append(st, "poll", poll);
Minor refactoring to mastoapi_poll().
2023-06-01 09:13:58 +03:00
}
Added some lost fields in mastoapi_status().
2023-06-28 20:53:25 +03:00
else
Backport from xs.
2024-03-15 06:10:11 +03:00
st = xs_dict_append(st, "poll", xs_stock(XSTYPE_NULL));
Added some lost fields in mastoapi_status().
2023-06-28 20:53:25 +03:00
Backport from xs.
2024-03-15 06:10:11 +03:00
st = xs_dict_append(st, "bookmarked", xs_stock(XSTYPE_FALSE));
In mastoapi, notes can be pinned / unpinned.
2023-06-28 21:36:23 +03:00
mastoapi: fixed /api/timelines/public to not need a bearer token.
2023-08-12 13:10:42 +03:00
st = xs_dict_append(st, "pinned",
Backport from xs.
2024-03-15 06:10:11 +03:00
(snac && is_pinned(snac, id)) ? xs_stock(XSTYPE_TRUE) : xs_stock(XSTYPE_FALSE));
Votes are shown in mastoapi.
2023-05-31 11:49:08 +03:00
mastoapi: boosted posts by others are correctly returned.
2023-10-13 10:01:07 +03:00
/* is it a boost? */
if (!xs_is_null(boosted_by_md5)) {
/* create a new dummy status, using st as the 'reblog' field */
Fixed bug that crashed Tusky.
2023-10-13 10:29:55 +03:00
xs_dict *bst = xs_dup(st);
mastoapi: boosted posts by others are correctly returned.
2023-10-13 10:01:07 +03:00
xs *b_actor = NULL;
if (valid_status(object_get_by_md5(boosted_by_md5, &b_actor))) {
xs *b_acct = mastoapi_account(b_actor);
Minor URI tweak.
2023-10-13 10:14:11 +03:00
xs *fake_uri = NULL;
if (snac)
fake_uri = xs_fmt("%s/d/%s/Announce", snac->actor, mid);
else
fake_uri = xs_fmt("%s#%s", srv_baseurl, mid);
mastoapi: boosted posts by others are correctly returned.
2023-10-13 10:01:07 +03:00
Fixed bug that crashed Tusky.
2023-10-13 10:29:55 +03:00
bst = xs_dict_set(bst, "uri", fake_uri);
bst = xs_dict_set(bst, "url", fake_uri);
bst = xs_dict_set(bst, "account", b_acct);
bst = xs_dict_set(bst, "content", "");
bst = xs_dict_set(bst, "reblog", st);
mastoapi: boosted posts by others are correctly returned.
2023-10-13 10:01:07 +03:00
xs_free(st);
st = bst;
}
}
New function mastodon_status().
2023-04-11 10:50:12 +03:00
return st;
}
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
xs_dict *mastoapi_relationship(snac *snac, const char *md5)
{
xs_dict *rel = NULL;
xs *actor_o = NULL;
if (valid_status(object_get_by_md5(md5, &actor_o))) {
rel = xs_dict_new();
const char *actor = xs_dict_get(actor_o, "id");
rel = xs_dict_append(rel, "id", md5);
rel = xs_dict_append(rel, "following",
Backport from xs.
2024-03-15 06:10:11 +03:00
following_check(snac, actor) ? xs_stock(XSTYPE_TRUE) : xs_stock(XSTYPE_FALSE));
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
Backport from xs.
2024-03-15 06:10:11 +03:00
rel = xs_dict_append(rel, "showing_reblogs", xs_stock(XSTYPE_TRUE));
rel = xs_dict_append(rel, "notifying", xs_stock(XSTYPE_FALSE));
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
rel = xs_dict_append(rel, "followed_by",
Backport from xs.
2024-03-15 06:10:11 +03:00
follower_check(snac, actor) ? xs_stock(XSTYPE_TRUE) : xs_stock(XSTYPE_FALSE));
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
rel = xs_dict_append(rel, "blocking",
Backport from xs.
2024-03-15 06:10:11 +03:00
is_muted(snac, actor) ? xs_stock(XSTYPE_TRUE) : xs_stock(XSTYPE_FALSE));
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
Backport from xs.
2024-03-15 06:10:11 +03:00
rel = xs_dict_append(rel, "muting", xs_stock(XSTYPE_FALSE));
rel = xs_dict_append(rel, "muting_notifications", xs_stock(XSTYPE_FALSE));
rel = xs_dict_append(rel, "requested", xs_stock(XSTYPE_FALSE));
rel = xs_dict_append(rel, "domain_blocking", xs_stock(XSTYPE_FALSE));
rel = xs_dict_append(rel, "endorsed", xs_stock(XSTYPE_FALSE));
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
rel = xs_dict_append(rel, "note", "");
}
return rel;
}
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
int process_auth_token(snac *snac, const xs_dict *req)
/* processes an authorization token, if there is one */
OAuth login now works.
2023-04-09 21:34:05 +03:00
{
More mastoapi work.
2023-04-09 22:31:56 +03:00
int logged_in = 0;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *v;
More mastoapi work.
2023-04-09 22:31:56 +03:00
/* if there is an authorization field, try to validate it */
if (!xs_is_null(v = xs_dict_get(req, "authorization")) && xs_startswith(v, "Bearer ")) {
Use xs_replace_n() where it suits.
2023-05-02 07:49:00 +03:00
xs *tokid = xs_replace_n(v, "Bearer ", "", 1);
More mastoapi work.
2023-04-09 22:31:56 +03:00
xs *token = token_get(tokid);
if (token != NULL) {
const char *uid = xs_dict_get(token, "uid");
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
if (!xs_is_null(uid) && user_open(snac, uid)) {
More mastoapi work.
2023-04-09 22:31:56 +03:00
logged_in = 1;
Update lastlog.txt everytime a Bearer token is validated.
2023-04-26 07:37:37 +03:00
/* this counts as a 'login' */
Added a source (web, mastoapi, etc) to lastlog_write().
2023-05-08 10:02:45 +03:00
lastlog_write(snac, "mastoapi");
Update lastlog.txt everytime a Bearer token is validated.
2023-04-26 07:37:37 +03:00
Tag indexes are also purged.
2023-11-08 20:15:51 +03:00
srv_debug(2, xs_fmt("mastoapi auth: valid token for user '%s'", uid));
More mastoapi work.
2023-04-09 22:31:56 +03:00
}
else
Tag indexes are also purged.
2023-11-08 20:15:51 +03:00
srv_log(xs_fmt("mastoapi auth: corrupted token '%s'", tokid));
More mastoapi work.
2023-04-09 22:31:56 +03:00
}
else
Tag indexes are also purged.
2023-11-08 20:15:51 +03:00
srv_log(xs_fmt("mastoapi auth: invalid token '%s'", tokid));
More mastoapi work.
2023-04-09 22:31:56 +03:00
}
OAuth login now works.
2023-04-09 21:34:05 +03:00
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
return logged_in;
}
int mastoapi_get_handler(const xs_dict *req, const char *q_path,
char **body, int *b_size, char **ctype)
{
Added -Wextra to C flags.
2023-05-04 10:28:36 +03:00
(void)b_size;
Also accept /api/v2 urls.
2023-04-16 09:13:45 +03:00
if (!xs_startswith(q_path, "/api/v1/") && !xs_startswith(q_path, "/api/v2/"))
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
return 0;
int status = 404;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_dict *args = xs_dict_get(req, "q_vars");
Use xs_replace_n() where it suits.
2023-05-02 07:49:00 +03:00
xs *cmd = xs_replace_n(q_path, "/api", "", 1);
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
snac snac1 = {0};
int logged_in = process_auth_token(&snac1, req);
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/accounts/verify_credentials") == 0) { /** **/
More mastoapi work.
2023-04-09 22:31:56 +03:00
if (logged_in) {
More mastoapi work.
2023-04-10 01:08:51 +03:00
xs *acct = xs_dict_new();
More mastoapi work.
2023-04-09 22:31:56 +03:00
mastoapi: minor fix in verify_credentials.
2023-08-16 19:18:46 +03:00
acct = xs_dict_append(acct, "id", snac1.md5);
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
acct = xs_dict_append(acct, "username", xs_dict_get(snac1.config, "uid"));
acct = xs_dict_append(acct, "acct", xs_dict_get(snac1.config, "uid"));
acct = xs_dict_append(acct, "display_name", xs_dict_get(snac1.config, "name"));
acct = xs_dict_append(acct, "created_at", xs_dict_get(snac1.config, "published"));
Add missing fields to account verification This allows the Mona iOS app to successfully sign in. I wasn't sure what a suitable value for `last_status_at` would be so I just copied `published` since it's the right format. This also just sets the `bot` field to false regardless of the user's configuration, which probably isn't ideal.
2024-01-11 16:36:16 +03:00
acct = xs_dict_append(acct, "last_status_at", xs_dict_get(snac1.config, "published"));
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
acct = xs_dict_append(acct, "note", xs_dict_get(snac1.config, "bio"));
acct = xs_dict_append(acct, "url", snac1.actor);
Backport from xs.
2024-03-15 06:10:11 +03:00
acct = xs_dict_append(acct, "locked", xs_stock(XSTYPE_FALSE));
Set the 'bot' field in verify_credentials to the matching value.
2024-01-11 20:49:26 +03:00
acct = xs_dict_append(acct, "bot", xs_dict_get(snac1.config, "bot"));
Fixed avatar.
2023-04-09 23:10:49 +03:00
Some mastoapi tweaks to support the semaphore.social web client.
2023-08-12 22:46:54 +03:00
xs *src = xs_json_loads("{\"privacy\":\"public\","
"\"sensitive\":false,\"fields\":[],\"note\":\"\"}");
acct = xs_dict_append(acct, "source", src);
More mastoapi work.
2023-04-10 01:08:51 +03:00
xs *avatar = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *av = xs_dict_get(snac1.config, "avatar");
Fixed avatar.
2023-04-09 23:10:49 +03:00
More mastoapi work.
2023-04-10 01:08:51 +03:00
if (xs_is_null(av) || *av == '\0')
Fixed avatar.
2023-04-09 23:10:49 +03:00
avatar = xs_fmt("%s/susie.png", srv_baseurl);
More mastoapi work.
2023-04-10 01:08:51 +03:00
else
avatar = xs_dup(av);
Fixed avatar.
2023-04-09 23:10:49 +03:00
acct = xs_dict_append(acct, "avatar", avatar);
Added avatar_static to validate_credentials object.
2023-08-12 22:53:35 +03:00
acct = xs_dict_append(acct, "avatar_static", avatar);
More mastoapi work.
2023-04-09 22:31:56 +03:00
mastoapi: return a dummy header field in accounts.
2024-03-13 12:07:02 +03:00
xs *header = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *hd = xs_dict_get(snac1.config, "header");
mastoapi: return a dummy header field in accounts.
2024-03-13 12:07:02 +03:00
if (!xs_is_null(hd))
header = xs_dup(hd);
else
header = xs_fmt("%s/header.png", srv_baseurl);
acct = xs_dict_append(acct, "header", header);
acct = xs_dict_append(acct, "header_static", header);
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_dict *metadata = xs_dict_get(snac1.config, "metadata");
mastoapi: Added fields list in verify_credentials.
2023-09-18 12:57:55 +03:00
if (xs_type(metadata) == XSTYPE_DICT) {
xs *fields = xs_list_new();
xs_str *k;
xs_str *v;
Moved verified links to its own json file.
2024-02-15 19:34:46 +03:00
xs_dict *val_links = snac1.links;
Renamed validated_metadata to validated_links.
2024-02-15 12:33:33 +03:00
if (xs_is_null(val_links))
Backport from xs.
2024-03-15 06:10:11 +03:00
val_links = xs_stock(XSTYPE_DICT);
mastoapi: added verified_at dates for verified links.
2024-02-15 01:03:32 +03:00
Replaced most xs_dict_iter() with xs_dict_next().
2024-03-09 10:44:48 +03:00
int c = 0;
while (xs_dict_next(metadata, &k, &v, &c)) {
The link verification time is stored as a time_t. This way, it will be easier in an eventual future to test if a link verification is too old to be trusted.
2024-02-20 08:10:42 +03:00
xs *val_date = NULL;
mastoapi: added verified_at dates for verified links.
2024-02-15 01:03:32 +03:00
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_number *verified_time = xs_dict_get(val_links, v);
The link verification time is stored as a time_t. This way, it will be easier in an eventual future to test if a link verification is too old to be trusted.
2024-02-20 08:10:42 +03:00
if (xs_type(verified_time) == XSTYPE_NUMBER) {
time_t t = xs_number_get(verified_time);
if (t > 0)
val_date = xs_str_utctime(t, ISO_DATE_SPEC);
}
mastoapi: added verified_at dates for verified links.
2024-02-15 01:03:32 +03:00
mastoapi: Added fields list in verify_credentials.
2023-09-18 12:57:55 +03:00
xs *d = xs_dict_new();
d = xs_dict_append(d, "name", k);
d = xs_dict_append(d, "value", v);
mastoapi: added verified_at dates for verified links.
2024-02-15 01:03:32 +03:00
d = xs_dict_append(d, "verified_at",
mastoapi: fill the verified_at fields in mastoapi_account() for local users.
2024-02-15 12:46:16 +03:00
xs_type(val_date) == XSTYPE_STRING && *val_date ?
Backport from xs.
2024-03-15 06:10:11 +03:00
val_date : xs_stock(XSTYPE_NULL));
mastoapi: Added fields list in verify_credentials.
2023-09-18 12:57:55 +03:00
fields = xs_list_append(fields, d);
}
acct = xs_dict_set(acct, "fields", fields);
}
Backport from xs.
2024-03-15 06:10:11 +03:00
acct = xs_dict_append(acct, "followers_count", xs_stock(0));
acct = xs_dict_append(acct, "following_count", xs_stock(0));
acct = xs_dict_append(acct, "statuses_count", xs_stock(0));
mastoapi: return some dummy values in verify_credentials.
2023-12-03 11:24:02 +03:00
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(acct, 4);
More mastoapi work.
2023-04-09 22:31:56 +03:00
*ctype = "application/json";
status = 200;
}
else {
status = 422; // "Unprocessable entity" (no login)
}
OAuth login now works.
2023-04-09 21:34:05 +03:00
}
More mastoapi work.
2023-04-10 01:08:51 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/accounts/relationships") == 0) { /** **/
Dummy /accounts/relationships.
2023-04-12 21:25:41 +03:00
/* find if an account is followed, blocked, etc. */
Relationships can only be queried if logged in.
2023-04-12 21:33:42 +03:00
/* the account to get relationships about is in args "id[]" */
Attend mastoapi relationships. Now, the follow/unfollow buttons appear on each account's page.
2023-04-23 07:05:35 +03:00
Relationships can only be queried if logged in.
2023-04-12 21:33:42 +03:00
if (logged_in) {
Attend mastoapi relationships. Now, the follow/unfollow buttons appear on each account's page.
2023-04-23 07:05:35 +03:00
xs *res = xs_list_new();
const char *md5 = xs_dict_get(args, "id[]");
More mastoapi tweaks.
2023-08-13 14:00:36 +03:00
if (xs_is_null(md5))
md5 = xs_dict_get(args, "id");
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
if (!xs_is_null(md5)) {
In /relationship, the id[] can be a list.
2023-05-11 11:44:27 +03:00
if (xs_type(md5) == XSTYPE_LIST)
md5 = xs_list_get(md5, 0);
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
xs *rel = mastoapi_relationship(&snac1, md5);
Attend mastoapi relationships. Now, the follow/unfollow buttons appear on each account's page.
2023-04-23 07:05:35 +03:00
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
if (rel != NULL)
res = xs_list_append(res, rel);
Attend mastoapi relationships. Now, the follow/unfollow buttons appear on each account's page.
2023-04-23 07:05:35 +03:00
}
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(res, 4);
Relationships can only be queried if logged in.
2023-04-12 21:33:42 +03:00
*ctype = "application/json";
status = 200;
}
Attend mastoapi relationships. Now, the follow/unfollow buttons appear on each account's page.
2023-04-23 07:05:35 +03:00
else
status = 422;
Dummy /accounts/relationships.
2023-04-12 21:25:41 +03:00
}
else
mastoapi: implemented /api/v1/accounts/lookup.
2023-10-28 08:10:21 +03:00
if (strcmp(cmd, "/v1/accounts/lookup") == 0) { /** **/
/* lookup an account */
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *acct = xs_dict_get(args, "acct");
mastoapi: implemented /api/v1/accounts/lookup.
2023-10-28 08:10:21 +03:00
if (!xs_is_null(acct)) {
xs *s = xs_strip_chars_i(xs_dup(acct), "@");
xs *l = xs_split_n(s, "@", 1);
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *uid = xs_list_get(l, 0);
const char *host = xs_list_get(l, 1);
mastoapi: implemented /api/v1/accounts/lookup.
2023-10-28 08:10:21 +03:00
if (uid && (!host || strcmp(host, xs_dict_get(srv_config, "host")) == 0)) {
snac user;
if (user_open(&user, uid)) {
xs *actor = msg_actor(&user);
xs *macct = mastoapi_account(actor);
*body = xs_json_dumps(macct, 4);
*ctype = "application/json";
status = 200;
user_free(&user);
}
}
}
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (xs_startswith(cmd, "/v1/accounts/")) { /** **/
Added the mastodon account data.
2023-04-12 19:54:20 +03:00
/* account-related information */
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
xs *l = xs_split(cmd, "/");
Fixed use-after-free in reply messages.
2023-04-16 08:12:57 +03:00
const char *uid = xs_list_get(l, 3);
const char *opt = xs_list_get(l, 4);
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
if (uid != NULL) {
snac snac2;
xs *out = NULL;
xs *actor = NULL;
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
if (logged_in && strcmp(uid, "search") == 0) { /** **/
/* search for accounts starting with q */
Made mastoapi account search case-insensitive.
2023-05-15 12:28:59 +03:00
const char *aq = xs_dict_get(args, "q");
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
Made mastoapi account search case-insensitive.
2023-05-15 12:28:59 +03:00
if (!xs_is_null(aq)) {
xs *q = xs_tolower_i(xs_dup(aq));
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
out = xs_list_new();
xs *wing = following_list(&snac1);
xs *wers = follower_list(&snac1);
Also find local users in /api/v1/search.
2023-05-15 14:04:30 +03:00
xs *ulst = user_list();
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
xs_list *p;
Also find local users in /api/v1/search.
2023-05-15 14:04:30 +03:00
xs_str *v;
Don't repeat accounts when searching.
2023-05-15 12:23:36 +03:00
xs_set seen;
xs_set_init(&seen);
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
Also find local users in /api/v1/search.
2023-05-15 14:04:30 +03:00
/* user relations */
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
xs_list *lsts[] = { wing, wers, NULL };
int n;
for (n = 0; (p = lsts[n]) != NULL; n++) {
while (xs_list_iter(&p, &v)) {
Don't repeat accounts when searching.
2023-05-15 12:23:36 +03:00
/* already seen? skip */
if (xs_set_add(&seen, v) == 0)
continue;
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
xs *actor = NULL;
if (valid_status(object_get(v, &actor))) {
const char *uname = xs_dict_get(actor, "preferredUsername");
Made mastoapi account search case-insensitive.
2023-05-15 12:28:59 +03:00
if (!xs_is_null(uname)) {
xs *luname = xs_tolower_i(xs_dup(uname));
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
Made mastoapi account search case-insensitive.
2023-05-15 12:28:59 +03:00
if (xs_startswith(luname, q)) {
xs *acct = mastoapi_account(actor);
out = xs_list_append(out, acct);
}
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
}
}
}
}
Don't repeat accounts when searching.
2023-05-15 12:23:36 +03:00
In mastoapi account search, return local users at the end.
2023-05-17 08:27:08 +03:00
/* local users */
p = ulst;
while (xs_list_iter(&p, &v)) {
snac user;
Don't autocomplete local users if they are already added.
2023-05-17 09:03:46 +03:00
/* skip this same user */
In mastoapi account search, return local users at the end.
2023-05-17 08:27:08 +03:00
if (strcmp(v, xs_dict_get(snac1.config, "uid")) == 0)
continue;
Don't autocomplete local users if they are already added.
2023-05-17 09:03:46 +03:00
/* skip if the uid does not start with the query */
xs *v2 = xs_tolower_i(xs_dup(v));
if (!xs_startswith(v2, q))
continue;
In mastoapi account search, return local users at the end.
2023-05-17 08:27:08 +03:00
Don't autocomplete local users if they are already added.
2023-05-17 09:03:46 +03:00
if (user_open(&user, v)) {
/* if it's not already seen, add it */
if (xs_set_add(&seen, user.actor) == 1) {
In mastoapi account search, return local users at the end.
2023-05-17 08:27:08 +03:00
xs *actor = msg_actor(&user);
xs *acct = mastoapi_account(actor);
out = xs_list_append(out, acct);
}
user_free(&user);
}
}
Don't repeat accounts when searching.
2023-05-15 12:23:36 +03:00
xs_set_free(&seen);
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
}
}
else
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
/* is it a local user? */
New function user_open_by_md5().
2023-04-16 08:43:41 +03:00
if (user_open(&snac2, uid) || user_open_by_md5(&snac2, uid)) {
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
if (opt == NULL) {
/* account information */
actor = msg_actor(&snac2);
out = mastoapi_account(actor);
}
else
Add /v1/account/search support.
2023-05-15 12:15:28 +03:00
if (strcmp(opt, "statuses") == 0) { /** **/
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
/* the public list of posts of a user */
xs *timeline = timeline_simple_list(&snac2, "public", 0, 256);
xs_list *p = timeline;
xs_str *v;
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
out = xs_list_new();
Added the mastodon account data.
2023-04-12 19:54:20 +03:00
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
while (xs_list_iter(&p, &v)) {
xs *msg = NULL;
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
if (valid_status(timeline_get_by_md5(&snac2, v, &msg))) {
/* add only posts by the author */
if (strcmp(xs_dict_get(msg, "type"), "Note") == 0 &&
xs_startswith(xs_dict_get(msg, "id"), snac2.actor)) {
xs *st = mastoapi_status(&snac2, msg);
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
Fixed some mastoapi minor errors.
2023-08-10 20:37:33 +03:00
if (st)
out = xs_list_append(out, st);
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
}
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
}
}
}
Also return (some) information for non-local users.
2023-04-12 21:20:46 +03:00
user_free(&snac2);
}
else {
/* try the uid as the md5 of a possibly loaded actor */
if (logged_in && valid_status(object_get_by_md5(uid, &actor))) {
if (opt == NULL) {
/* account information */
out = mastoapi_account(actor);
}
else
if (strcmp(opt, "statuses") == 0) {
/* we don't serve statuses of others; return the empty list */
out = xs_list_new();
}
}
Added the mastodon account data.
2023-04-12 19:54:20 +03:00
}
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
Added the mastodon account data.
2023-04-12 19:54:20 +03:00
if (out != NULL) {
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(out, 4);
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
*ctype = "application/json";
status = 200;
}
}
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/timelines/home") == 0) { /** **/
More mastoapi work.
2023-04-10 01:08:51 +03:00
/* the private timeline */
if (logged_in) {
const char *max_id = xs_dict_get(args, "max_id");
More mastoapi timeline work.
2023-04-10 11:23:14 +03:00
const char *since_id = xs_dict_get(args, "since_id");
New function mastoapi_id(), that creates mostly-compatible Ids. Most apps (all?) sort entries by status Id, so they must be time-sorted (somewhat).
2023-04-10 13:14:16 +03:00
const char *min_id = xs_dict_get(args, "min_id");
More mastoapi work.
2023-04-10 01:08:51 +03:00
const char *limit_s = xs_dict_get(args, "limit");
Some timeline fixes.
2023-04-10 12:30:00 +03:00
int limit = 0;
int cnt = 0;
More mastoapi work.
2023-04-10 01:08:51 +03:00
if (!xs_is_null(limit_s))
limit = atoi(limit_s);
Some timeline fixes.
2023-04-10 12:30:00 +03:00
if (limit == 0)
limit = 20;
mastoapi: some tweaks to better match the returned data in timelines.
2023-10-09 12:49:45 +03:00
xs *timeline = timeline_simple_list(&snac1, "private", 0, 2048);
More work in status entries.
2023-04-10 09:52:04 +03:00
xs *out = xs_list_new();
Limit the number of entries returned using the max_id.
2023-04-10 01:40:48 +03:00
xs_list *p = timeline;
More mastoapi work.
2023-04-10 01:08:51 +03:00
xs_str *v;
while (xs_list_iter(&p, &v) && cnt < limit) {
xs *msg = NULL;
Limit the number of entries returned using the max_id.
2023-04-10 01:40:48 +03:00
/* only return entries older that max_id */
if (max_id) {
Use MID_TO_MD5 for ID comparison
2023-06-10 09:35:16 +03:00
if (strcmp(v, MID_TO_MD5(max_id)) == 0)
Limit the number of entries returned using the max_id.
2023-04-10 01:40:48 +03:00
max_id = NULL;
continue;
}
More mastoapi work.
2023-04-10 01:08:51 +03:00
More mastoapi timeline work.
2023-04-10 11:23:14 +03:00
/* only returns entries newer than since_id */
if (since_id) {
Use MID_TO_MD5 for ID comparison
2023-06-10 09:35:16 +03:00
if (strcmp(v, MID_TO_MD5(since_id)) == 0)
More mastoapi timeline work.
2023-04-10 11:23:14 +03:00
break;
}
New function mastoapi_id(), that creates mostly-compatible Ids. Most apps (all?) sort entries by status Id, so they must be time-sorted (somewhat).
2023-04-10 13:14:16 +03:00
/* only returns entries newer than min_id */
/* what does really "Return results immediately newer than ID" mean? */
if (min_id) {
Use MID_TO_MD5 for ID comparison
2023-06-10 09:35:16 +03:00
if (strcmp(v, MID_TO_MD5(min_id)) == 0)
New function mastoapi_id(), that creates mostly-compatible Ids. Most apps (all?) sort entries by status Id, so they must be time-sorted (somewhat).
2023-04-10 13:14:16 +03:00
break;
}
More mastoapi work.
2023-04-10 01:08:51 +03:00
/* get the entry */
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
if (!valid_status(timeline_get_by_md5(&snac1, v, &msg)))
More mastoapi work.
2023-04-10 01:08:51 +03:00
continue;
More mastoapi timeline work.
2023-04-10 11:23:14 +03:00
/* discard non-Notes */
mastoapi: Don't exclude posts of type Page or Article.
2023-10-16 21:49:58 +03:00
const char *id = xs_dict_get(msg, "id");
Votes are shown in mastoapi.
2023-05-31 11:49:08 +03:00
const char *type = xs_dict_get(msg, "type");
Unified post-like object type match.
2024-05-11 19:46:15 +03:00
if (!xs_match(type, POSTLIKE_OBJECT_TYPE))
More mastoapi work.
2023-04-10 01:08:51 +03:00
continue;
cleanup
2024-01-29 00:04:11 +03:00
mastoapi: fixed crash processing kbin boosts.
2023-12-05 21:37:27 +03:00
const char *from = NULL;
mastoapi: Don't exclude posts of type Page or Article.
2023-10-16 21:49:58 +03:00
if (strcmp(type, "Page") == 0)
from = xs_dict_get(msg, "audience");
mastoapi: fixed crash processing kbin boosts.
2023-12-05 21:37:27 +03:00
if (from == NULL)
New function get_atto(), to get the attributedTo field.
2024-01-19 01:04:37 +03:00
from = get_atto(msg);
mastoapi: some tweaks to better match the returned data in timelines.
2023-10-09 12:49:45 +03:00
mastoapi: fixed crash processing kbin boosts.
2023-12-05 21:37:27 +03:00
if (from == NULL)
continue;
mastoapi: some tweaks to better match the returned data in timelines.
2023-10-09 12:49:45 +03:00
/* is this message from a person we don't follow? */
mastoapi: Don't exclude posts of type Page or Article.
2023-10-16 21:49:58 +03:00
if (strcmp(from, snac1.actor) && !following_check(&snac1, from)) {
mastoapi: show any boosted note, not only by us.
2023-10-13 09:33:57 +03:00
/* discard if it was not boosted */
mastoapi: some tweaks to better match the returned data in timelines.
2023-10-09 12:49:45 +03:00
xs *idx = object_announces(id);
mastoapi: show any boosted note, not only by us.
2023-10-13 09:33:57 +03:00
if (xs_list_len(idx) == 0)
mastoapi: some tweaks to better match the returned data in timelines.
2023-10-09 12:49:45 +03:00
continue;
}
Ignore non-followed users' notes without boosts in private timeline
2023-06-10 09:07:58 +03:00
Hide hidden posts from timelines.
2023-04-27 09:35:23 +03:00
/* discard notes from muted morons */
mastoapi: Don't exclude posts of type Page or Article.
2023-10-16 21:49:58 +03:00
if (is_muted(&snac1, from))
Skip muted morons from timelines and statuses.
2023-04-24 18:49:08 +03:00
continue;
Hide hidden posts from timelines.
2023-04-27 09:35:23 +03:00
/* discard hidden notes */
mastoapi: some tweaks to better match the returned data in timelines.
2023-10-09 12:49:45 +03:00
if (is_hidden(&snac1, id))
Hide hidden posts from timelines.
2023-04-27 09:35:23 +03:00
continue;
mastoapi: Correctly show 'Video' objects in /timelines/home.
2024-03-01 17:34:50 +03:00
/* if it has a name and it's not a Page or a Video,
it's a poll vote, so discard it */
if (!xs_is_null(xs_dict_get(msg, "name")) && !xs_match(type, "Page|Video"))
In mastoapi, don't show poll votes in timelines.
2023-05-24 15:12:21 +03:00
continue;
New function mastodon_status().
2023-04-11 10:50:12 +03:00
/* convert the Note into a Mastodon status */
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
xs *st = mastoapi_status(&snac1, msg);
More mastoapi work.
2023-04-10 01:08:51 +03:00
New function mastodon_status().
2023-04-11 10:50:12 +03:00
if (st != NULL)
out = xs_list_append(out, st);
More mastoapi work.
2023-04-10 01:08:51 +03:00
cnt++;
}
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(out, 4);
More mastoapi work.
2023-04-10 01:08:51 +03:00
*ctype = "application/json";
status = 200;
Some timeline fixes.
2023-04-10 12:30:00 +03:00
Changed mastoapi log levels.
2023-04-13 10:59:00 +03:00
srv_debug(2, xs_fmt("mastoapi timeline: returned %d entries", xs_list_len(out)));
More mastoapi work.
2023-04-10 01:08:51 +03:00
}
else {
status = 401; // unauthorized
}
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/timelines/public") == 0) { /** **/
The instance timeline now works.
2023-04-30 08:00:49 +03:00
/* the instance public timeline (public timelines for all users) */
Some instance timeline work.
2023-04-30 07:39:55 +03:00
const char *limit_s = xs_dict_get(args, "limit");
Added an instance timeline.
2023-04-23 10:41:43 +03:00
int limit = 0;
int cnt = 0;
if (!xs_is_null(limit_s))
limit = atoi(limit_s);
if (limit == 0)
limit = 20;
Some instance timeline work.
2023-04-30 07:39:55 +03:00
xs *timeline = timeline_instance_list(0, limit);
xs *out = xs_list_new();
xs_list *p = timeline;
xs_str *md5;
Added an instance timeline.
2023-04-23 10:41:43 +03:00
mastoapi: fixed /api/timelines/public to not need a bearer token.
2023-08-12 13:10:42 +03:00
snac *user = NULL;
if (logged_in)
user = &snac1;
while (xs_list_iter(&p, &md5) && cnt < limit) {
Some instance timeline work.
2023-04-30 07:39:55 +03:00
xs *msg = NULL;
Added an instance timeline.
2023-04-23 10:41:43 +03:00
Some instance timeline work.
2023-04-30 07:39:55 +03:00
/* get the entry */
if (!valid_status(object_get_by_md5(md5, &msg)))
continue;
Added an instance timeline.
2023-04-23 10:41:43 +03:00
Some instance timeline work.
2023-04-30 07:39:55 +03:00
/* discard non-Notes */
Votes are shown in mastoapi.
2023-05-31 11:49:08 +03:00
const char *type = xs_dict_get(msg, "type");
if (strcmp(type, "Note") != 0 && strcmp(type, "Question") != 0)
Some instance timeline work.
2023-04-30 07:39:55 +03:00
continue;
Added an instance timeline.
2023-04-23 10:41:43 +03:00
New function is_msg_from_private_user().
2024-02-10 11:08:09 +03:00
/* discard messages from private users */
if (is_msg_from_private_user(msg))
continue;
Hide posts from the public web for accounts with 'private' == true.
2023-10-08 01:06:37 +03:00
The instance timeline now works.
2023-04-30 08:00:49 +03:00
/* convert the Note into a Mastodon status */
mastoapi: fixed /api/timelines/public to not need a bearer token.
2023-08-12 13:10:42 +03:00
xs *st = mastoapi_status(user, msg);
Added an instance timeline.
2023-04-23 10:41:43 +03:00
The instance timeline now works.
2023-04-30 08:00:49 +03:00
if (st != NULL) {
out = xs_list_append(out, st);
Some instance timeline work.
2023-04-30 07:39:55 +03:00
cnt++;
Added an instance timeline.
2023-04-23 10:41:43 +03:00
}
}
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(out, 4);
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*ctype = "application/json";
status = 200;
}
else
mastoapi: added support for /api/v1/timelines/tag/.
2024-02-09 23:24:44 +03:00
if (xs_startswith(cmd, "/v1/timelines/tag/")) { /** **/
const char *limit_s = xs_dict_get(args, "limit");
int limit = 0;
int cnt = 0;
if (!xs_is_null(limit_s))
limit = atoi(limit_s);
if (limit == 0)
limit = 20;
/* get the tag */
xs *l = xs_split(cmd, "/");
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *tag = xs_list_get(l, -1);
mastoapi: added support for /api/v1/timelines/tag/.
2024-02-09 23:24:44 +03:00
xs *timeline = tag_search(tag, 0, limit);
xs *out = xs_list_new();
xs_list *p = timeline;
xs_str *md5;
while (xs_list_iter(&p, &md5) && cnt < limit) {
xs *msg = NULL;
/* get the entry */
if (!valid_status(object_get_by_md5(md5, &msg)))
continue;
mastoapi: Skip non-public posts from timelines by tag.
2024-02-10 10:49:55 +03:00
/* skip non-public messages */
if (!is_msg_public(msg))
continue;
New function is_msg_from_private_user().
2024-02-10 11:08:09 +03:00
/* discard messages from private users */
if (is_msg_from_private_user(msg))
continue;
mastoapi: added support for /api/v1/timelines/tag/.
2024-02-09 23:24:44 +03:00
/* convert the Note into a Mastodon status */
xs *st = mastoapi_status(NULL, msg);
if (st != NULL) {
out = xs_list_append(out, st);
cnt++;
}
}
*body = xs_json_dumps(out, 4);
*ctype = "application/json";
status = 200;
}
else
More work in lists.
2024-04-29 11:15:04 +03:00
if (xs_startswith(cmd, "/v1/timelines/list/")) { /** **/
/* get the list id */
if (logged_in) {
xs *l = xs_split(cmd, "/");
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *list = xs_list_get(l, -1);
More work in lists.
2024-04-29 11:15:04 +03:00
List timelines can now be (manually) navigated from the web UI. URLs are {srv_baseurl}/{user}/list/{list_id} (you must know the list id).
2024-05-07 20:40:28 +03:00
xs *timeline = list_timeline(&snac1, list, 0, 2048);
More work in lists.
2024-04-29 11:15:04 +03:00
xs *out = xs_list_new();
int c = 0;
char *md5;
while (xs_list_next(timeline, &md5, &c)) {
xs *msg = NULL;
/* get the entry */
if (!valid_status(timeline_get_by_md5(&snac1, md5, &msg)))
continue;
/* discard non-Notes */
const char *id = xs_dict_get(msg, "id");
const char *type = xs_dict_get(msg, "type");
Unified post-like object type match.
2024-05-11 19:46:15 +03:00
if (!xs_match(type, POSTLIKE_OBJECT_TYPE))
More work in lists.
2024-04-29 11:15:04 +03:00
continue;
const char *from = NULL;
if (strcmp(type, "Page") == 0)
from = xs_dict_get(msg, "audience");
if (from == NULL)
from = get_atto(msg);
if (from == NULL)
continue;
/* is this message from a person we don't follow? */
if (strcmp(from, snac1.actor) && !following_check(&snac1, from)) {
/* discard if it was not boosted */
xs *idx = object_announces(id);
if (xs_list_len(idx) == 0)
continue;
}
/* discard notes from muted morons */
if (is_muted(&snac1, from))
continue;
/* discard hidden notes */
if (is_hidden(&snac1, id))
continue;
/* if it has a name and it's not a Page or a Video,
it's a poll vote, so discard it */
if (!xs_is_null(xs_dict_get(msg, "name")) && !xs_match(type, "Page|Video"))
continue;
/* convert the Note into a Mastodon status */
xs *st = mastoapi_status(&snac1, msg);
if (st != NULL)
out = xs_list_append(out, st);
}
*body = xs_json_dumps(out, 4);
*ctype = "application/json";
status = 200;
}
else
status = 421;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/conversations") == 0) { /** **/
Added many dummy lists.
2023-04-11 21:10:24 +03:00
/* TBD */
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/notifications") == 0) { /** **/
New functions notify_get() and notify_list().
2023-04-13 18:34:48 +03:00
if (logged_in) {
Added paging to notify_list(), and use it in the notifications page.
2024-02-05 21:34:27 +03:00
xs *l = notify_list(&snac1, 0, 64);
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
xs *out = xs_list_new();
xs_list *p = l;
xs_dict *v;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *excl = xs_dict_get(args, "exclude_types[]");
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
while (xs_list_iter(&p, &v)) {
Fixed crash in notification list.
2023-04-14 09:37:33 +03:00
xs *noti = notify_get(&snac1, v);
if (noti == NULL)
continue;
const char *type = xs_dict_get(noti, "type");
Show the finished poll notification correctly in mastoapi.
2023-05-30 16:01:45 +03:00
const char *utype = xs_dict_get(noti, "utype");
Fixed crash in notification list.
2023-04-14 09:37:33 +03:00
const char *objid = xs_dict_get(noti, "objid");
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
xs *actor = NULL;
xs *entry = NULL;
Rewritten actor_get() to not depend on a user.
2023-08-12 12:23:01 +03:00
if (!valid_status(actor_get(xs_dict_get(noti, "actor"), &actor)))
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
continue;
New functions notify_get() and notify_list().
2023-04-13 18:34:48 +03:00
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
if (objid != NULL && !valid_status(object_get(objid, &entry)))
continue;
New notifications web page.
2023-04-14 13:23:32 +03:00
if (is_hidden(&snac1, objid))
continue;
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
/* convert the type */
if (strcmp(type, "Like") == 0)
type = "favourite";
else
if (strcmp(type, "Announce") == 0)
type = "reblog";
else
if (strcmp(type, "Follow") == 0)
type = "follow";
else
if (strcmp(type, "Create") == 0)
type = "mention";
Show the finished poll notification correctly in mastoapi.
2023-05-30 16:01:45 +03:00
else
if (strcmp(type, "Update") == 0 && strcmp(utype, "Question") == 0)
type = "poll";
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
else
continue;
Added support from exclude notification types.
2023-05-11 11:54:56 +03:00
/* excluded type? */
if (!xs_is_null(excl) && xs_list_in(excl, type) != -1)
continue;
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
xs *mn = xs_dict_new();
mn = xs_dict_append(mn, "type", type);
Fixed crash in notification list.
2023-04-14 09:37:33 +03:00
xs *id = xs_replace(xs_dict_get(noti, "id"), ".", "");
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
mn = xs_dict_append(mn, "id", id);
Fixed crash in notification list.
2023-04-14 09:37:33 +03:00
mn = xs_dict_append(mn, "created_at", xs_dict_get(noti, "date"));
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
xs *acct = mastoapi_account(actor);
mn = xs_dict_append(mn, "account", acct);
Fixed crash in notification list.
2023-04-14 09:37:33 +03:00
if (strcmp(type, "follow") != 0 && !xs_is_null(objid)) {
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
xs *st = mastoapi_status(&snac1, entry);
Fixed some mastoapi minor errors.
2023-08-10 20:37:33 +03:00
if (st)
mn = xs_dict_append(mn, "status", st);
Implemented mastoapi notifications.
2023-04-13 18:56:00 +03:00
}
out = xs_list_append(out, mn);
}
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(out, 4);
New functions notify_get() and notify_list().
2023-04-13 18:34:48 +03:00
*ctype = "application/json";
status = 200;
}
else
status = 401;
Added many dummy lists.
2023-04-11 21:10:24 +03:00
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/filters") == 0) { /** **/
Added some comments.
2023-04-11 21:16:12 +03:00
/* snac will never have filters */
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
make compatible with subway tooter app
2024-01-28 23:55:43 +03:00
if (strcmp(cmd, "/v2/filters") == 0) { /** **/
/* snac will never have filters
Some formatting tweaks.
2024-03-12 09:03:44 +03:00
* but still, without a v2 endpoint a short delay is introduced
* in some apps */
make compatible with subway tooter app
2024-01-28 23:55:43 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/favourites") == 0) { /** **/
Added some comments.
2023-04-11 21:16:12 +03:00
/* snac will never support a list of favourites */
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/bookmarks") == 0) { /** **/
Added some comments.
2023-04-11 21:16:12 +03:00
/* snac does not support bookmarks */
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
More work in lists.
2024-04-29 10:26:37 +03:00
if (strcmp(cmd, "/v1/lists") == 0) { /** list of lists **/
Start of list support.
2024-04-29 08:43:01 +03:00
if (logged_in) {
xs *lol = list_maint(&snac1, NULL, 0);
xs *l = xs_list_new();
int c = 0;
xs_list *li;
while (xs_list_next(lol, &li, &c)) {
xs *d = xs_dict_new();
d = xs_dict_append(d, "id", xs_list_get(li, 0));
d = xs_dict_append(d, "title", xs_list_get(li, 1));
d = xs_dict_append(d, "replies_policy", "list");
d = xs_dict_append(d, "exclusive", xs_stock(XSTYPE_FALSE));
l = xs_list_append(l, d);
}
*body = xs_json_dumps(l, 4);
*ctype = "application/json";
status = 200;
}
Added many dummy lists.
2023-04-11 21:10:24 +03:00
}
else
More work in lists.
2024-04-29 10:26:37 +03:00
if (xs_startswith(cmd, "/v1/lists/")) { /** list information **/
if (logged_in) {
xs *l = xs_split(cmd, "/");
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *p = xs_list_get(l, -1);
More work in lists.
2024-04-29 10:26:37 +03:00
More tweaks to mastoapi lists.
2024-04-29 11:48:48 +03:00
if (p) {
if (strcmp(p, "accounts") == 0) {
p = xs_list_get(l, -2);
if (p && xs_is_hex(p)) {
xs *actors = list_content(&snac1, p, NULL, 0);
xs *out = xs_list_new();
int c = 0;
char *v;
while (xs_list_next(actors, &v, &c)) {
xs *actor = NULL;
if (valid_status(object_get_by_md5(v, &actor))) {
xs *acct = mastoapi_account(actor);
out = xs_list_append(out, acct);
}
}
*body = xs_json_dumps(out, 4);
*ctype = "application/json";
status = 200;
}
}
else
if (xs_is_hex(p)) {
More work in lists.
2024-04-29 10:26:37 +03:00
xs *out = xs_list_new();
More tweaks to mastoapi lists.
2024-04-29 11:48:48 +03:00
xs *lol = list_maint(&snac1, NULL, 0);
More work in lists.
2024-04-29 10:26:37 +03:00
int c = 0;
More tweaks to mastoapi lists.
2024-04-29 11:48:48 +03:00
xs_list *v;
while (xs_list_next(lol, &v, &c)) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *id = xs_list_get(v, 0);
More tweaks to mastoapi lists.
2024-04-29 11:48:48 +03:00
if (id && strcmp(id, p) == 0) {
xs *d = xs_dict_new();
More work in lists.
2024-04-29 10:26:37 +03:00
More tweaks to mastoapi lists.
2024-04-29 11:48:48 +03:00
d = xs_dict_append(d, "id", p);
d = xs_dict_append(d, "title", xs_list_get(v, 1));
d = xs_dict_append(d, "replies_policy", "list");
d = xs_dict_append(d, "exclusive", xs_stock(XSTYPE_FALSE));
More work in lists.
2024-04-29 10:26:37 +03:00
More tweaks to mastoapi lists.
2024-04-29 11:48:48 +03:00
out = xs_list_append(out, d);
break;
More work in lists.
2024-04-29 10:26:37 +03:00
}
}
*body = xs_json_dumps(out, 4);
*ctype = "application/json";
status = 200;
}
}
}
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/scheduled_statuses") == 0) { /** **/
/* snac does not schedule notes */
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/follow_requests") == 0) { /** **/
Added some comments.
2023-04-11 21:16:12 +03:00
/* snac does not support optional follow confirmations */
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/announcements") == 0) { /** **/
Added some comments.
2023-04-11 21:16:12 +03:00
/* snac has no announcements (yet?) */
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/custom_emojis") == 0) { /** **/
Added some comments.
2023-04-11 21:16:12 +03:00
/* are you kidding me? */
Added many dummy lists.
2023-04-11 21:10:24 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
status = 200;
More mastoapi work.
2023-04-10 01:08:51 +03:00
}
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/instance") == 0) { /** **/
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
/* returns an instance object */
xs *ins = xs_dict_new();
mastoapi: show the instance's title and short_description, if they exist.
2023-08-14 12:31:11 +03:00
const char *host = xs_dict_get(srv_config, "host");
const char *title = xs_dict_get(srv_config, "title");
const char *sdesc = xs_dict_get(srv_config, "short_description");
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
ins = xs_dict_append(ins, "uri", host);
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
ins = xs_dict_append(ins, "domain", host);
mastoapi: show the instance's title and short_description, if they exist.
2023-08-14 12:31:11 +03:00
ins = xs_dict_append(ins, "title", title && *title ? title : host);
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
ins = xs_dict_append(ins, "version", "4.0.0 (not true; really " USER_AGENT ")");
Store the what-is-snac URL as a CPP constant.
2023-04-25 07:40:46 +03:00
ins = xs_dict_append(ins, "source_url", WHAT_IS_SNAC_URL);
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
ins = xs_dict_append(ins, "description", host);
mastoapi: show the instance's title and short_description, if they exist.
2023-08-14 12:31:11 +03:00
ins = xs_dict_append(ins, "short_description", sdesc && *sdesc ? sdesc : host);
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
xs *susie = xs_fmt("%s/susie.png", srv_baseurl);
Some fixes to allow Megalodon to work. The instance object was wrong and the oauth args can appear as JSON.
2023-04-15 10:44:09 +03:00
ins = xs_dict_append(ins, "thumbnail", susie);
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
Use server.json "admin_email" in mastoapi instance object.
2023-04-20 18:59:09 +03:00
const char *v = xs_dict_get(srv_config, "admin_email");
if (xs_is_null(v) || *v == '\0')
v = "admin@localhost";
ins = xs_dict_append(ins, "email", v);
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
Backport from xs.
2024-03-15 06:10:11 +03:00
ins = xs_dict_append(ins, "rules", xs_stock(XSTYPE_LIST));
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
Use some new xs_stock values.
2023-08-13 13:09:35 +03:00
xs *l1 = xs_list_append(xs_list_new(), "en");
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
ins = xs_dict_append(ins, "languages", l1);
mastoapi: Added a dummy streaming_api URL.
2024-03-06 20:13:16 +03:00
xs *wss = xs_fmt("wss:/" "/%s", xs_dict_get(srv_config, "host"));
xs *urls = xs_dict_new();
urls = xs_dict_append(urls, "streaming_api", wss);
ins = xs_dict_append(ins, "urls", urls);
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
Backport from xs.
2024-03-15 06:10:11 +03:00
xs *d2 = xs_dict_append(xs_dict_new(), "user_count", xs_stock(0));
d2 = xs_dict_append(d2, "status_count", xs_stock(0));
d2 = xs_dict_append(d2, "domain_count", xs_stock(0));
Fixed crash.
2023-08-12 19:42:11 +03:00
ins = xs_dict_append(ins, "stats", d2);
More complete mastodon api instance object. But Megalodon keeps crashing.
2023-04-20 19:37:09 +03:00
Backport from xs.
2024-03-15 06:10:11 +03:00
ins = xs_dict_append(ins, "registrations", xs_stock(XSTYPE_FALSE));
ins = xs_dict_append(ins, "approval_required", xs_stock(XSTYPE_FALSE));
ins = xs_dict_append(ins, "invites_enabled", xs_stock(XSTYPE_FALSE));
More complete mastodon api instance object. But Megalodon keeps crashing.
2023-04-20 19:37:09 +03:00
Added snac limits (no real limits) to the Instance object.
2023-04-24 17:29:21 +03:00
xs *cfg = xs_dict_new();
{
Some mastoapi instance object tweaks.
2023-08-12 19:38:55 +03:00
xs *d11 = xs_json_loads("{\"characters_reserved_per_url\":32,"
"\"max_characters\":100000,\"max_media_attachments\":8}");
Added snac limits (no real limits) to the Instance object.
2023-04-24 17:29:21 +03:00
cfg = xs_dict_append(cfg, "statuses", d11);
Some mastoapi instance object tweaks.
2023-08-12 19:38:55 +03:00
xs *d12 = xs_json_loads("{\"max_featured_tags\":10}");
cfg = xs_dict_append(cfg, "accounts", d12);
xs *d13 = xs_json_loads("{\"image_matrix_limit\":33177600,"
"\"image_size_limit\":16777216,"
"\"video_frame_rate_limit\":120,"
"\"video_matrix_limit\":8294400,"
"\"video_size_limit\":103809024}"
);
mastoapi: in instance, return the list of supported mime types from the internal list.
2023-08-17 19:06:36 +03:00
{
/* get the supported mime types from the internal list */
const char **p = xs_mime_types;
xs_set mtypes;
xs_set_init(&mtypes);
while (*p) {
const char *type = p[1];
if (xs_startswith(type, "image/") ||
xs_startswith(type, "video/") ||
xs_startswith(type, "audio/"))
xs_set_add(&mtypes, type);
p += 2;
}
xs *l = xs_set_result(&mtypes);
d13 = xs_dict_append(d13, "supported_mime_types", l);
}
Some mastoapi instance object tweaks.
2023-08-12 19:38:55 +03:00
cfg = xs_dict_append(cfg, "media_attachments", d13);
xs *d14 = xs_json_loads("{\"max_characters_per_option\":50,"
"\"max_expiration\":2629746,"
"\"max_options\":8,\"min_expiration\":300}");
cfg = xs_dict_append(cfg, "polls", d14);
Added snac limits (no real limits) to the Instance object.
2023-04-24 17:29:21 +03:00
}
ins = xs_dict_append(ins, "configuration", cfg);
Fill the mastoapi instance contact_account field, if possible.
2023-05-08 11:13:43 +03:00
const char *admin_account = xs_dict_get(srv_config, "admin_account");
if (!xs_is_null(admin_account) && *admin_account) {
snac admin;
if (user_open(&admin, admin_account)) {
xs *actor = msg_actor(&admin);
xs *acct = mastoapi_account(actor);
ins = xs_dict_append(ins, "contact_account", acct);
user_free(&admin);
}
}
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(ins, 4);
Added /api/v1/instance.
2023-04-10 17:08:26 +03:00
*ctype = "application/json";
status = 200;
}
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (xs_startswith(cmd, "/v1/statuses/")) { /** **/
Skip muted morons from timelines and statuses.
2023-04-24 18:49:08 +03:00
/* information about a status */
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (logged_in) {
xs *l = xs_split(cmd, "/");
const char *id = xs_list_get(l, 3);
const char *op = xs_list_get(l, 4);
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (!xs_is_null(id)) {
xs *msg = NULL;
xs *out = NULL;
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
/* skip the 'fake' part of the id */
id = MID_TO_MD5(id);
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (valid_status(object_get_by_md5(id, &msg))) {
if (op == NULL) {
New function get_atto(), to get the attributedTo field.
2024-01-19 01:04:37 +03:00
if (!is_muted(&snac1, get_atto(msg))) {
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
/* return the status itself */
out = mastoapi_status(&snac1, msg);
}
Skip muted morons from timelines and statuses.
2023-04-24 18:49:08 +03:00
}
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
else
if (strcmp(op, "context") == 0) { /** **/
/* return ancestors and children */
xs *anc = xs_list_new();
xs *des = xs_list_new();
xs_list *p;
xs_str *v;
char pid[64];
Added support for statuses/:id and statuses/:id/context.
2023-04-11 20:59:02 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
/* build the [grand]parent list, moving up */
strncpy(pid, id, sizeof(pid));
Added support for statuses/:id and statuses/:id/context.
2023-04-11 20:59:02 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
while (object_parent(pid, pid, sizeof(pid))) {
xs *m2 = NULL;
Added support for statuses/:id and statuses/:id/context.
2023-04-11 20:59:02 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (valid_status(timeline_get_by_md5(&snac1, pid, &m2))) {
xs *st = mastoapi_status(&snac1, m2);
Fixed some mastoapi minor errors.
2023-08-10 20:37:33 +03:00
if (st)
anc = xs_list_insert(anc, 0, st);
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
}
else
break;
Added support for statuses/:id and statuses/:id/context.
2023-04-11 20:59:02 +03:00
}
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
/* build the children list */
xs *children = object_children(xs_dict_get(msg, "id"));
p = children;
Use the ctime instead of the published date in mastoapi_id().
2023-04-12 11:19:43 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
while (xs_list_iter(&p, &v)) {
xs *m2 = NULL;
Added support for statuses/:id and statuses/:id/context.
2023-04-11 20:59:02 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (valid_status(timeline_get_by_md5(&snac1, v, &m2))) {
if (xs_is_null(xs_dict_get(m2, "name"))) {
xs *st = mastoapi_status(&snac1, m2);
Fixed some mastoapi minor errors.
2023-08-10 20:37:33 +03:00
if (st)
des = xs_list_append(des, st);
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
}
Don't show votes to polls as descendants in mastoapi.
2023-05-31 11:51:37 +03:00
}
Added support for statuses/:id and statuses/:id/context.
2023-04-11 20:59:02 +03:00
}
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
out = xs_dict_new();
out = xs_dict_append(out, "ancestors", anc);
out = xs_dict_append(out, "descendants", des);
}
else
if (strcmp(op, "reblogged_by") == 0 || /** **/
strcmp(op, "favourited_by") == 0) { /** **/
/* return the list of people who liked or boosted this */
out = xs_list_new();
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
xs *l = NULL;
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (op[0] == 'r')
l = object_announces(xs_dict_get(msg, "id"));
else
l = object_likes(xs_dict_get(msg, "id"));
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
xs_list *p = l;
xs_str *v;
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
while (xs_list_iter(&p, &v)) {
xs *actor2 = NULL;
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (valid_status(object_get_by_md5(v, &actor2))) {
xs *acct2 = mastoapi_account(actor2);
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
out = xs_list_append(out, acct2);
}
Added support for like and boost lists.
2023-04-12 16:28:43 +03:00
}
}
mastoapi: added support for status/.../source.
2024-01-23 17:40:25 +03:00
else
if (strcmp(op, "source") == 0) { /** **/
out = xs_dict_new();
/* get the mastoapi status id */
out = xs_dict_append(out, "id", xs_list_get(l, 3));
out = xs_dict_append(out, "text", xs_dict_get(msg, "sourceContent"));
out = xs_dict_append(out, "spoiler_text", xs_dict_get(msg, "summary"));
}
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
}
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
else
srv_debug(1, xs_fmt("mastoapi status: bad id %s", id));
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
if (out != NULL) {
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(out, 4);
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
*ctype = "application/json";
status = 200;
}
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
}
}
Only allow logged-in user to use statuses API
2023-06-11 07:06:37 +03:00
else
status = 401;
Started work in /api/v1/statuses.
2023-04-11 12:00:06 +03:00
}
Updated RELEASE_NOTES.
2023-04-13 07:38:05 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/preferences") == 0) { /** **/
Added some more dummy entry points.
2023-04-15 17:40:48 +03:00
*body = xs_dup("{}");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/markers") == 0) { /** **/
Added some more dummy entry points.
2023-04-15 17:40:48 +03:00
*body = xs_dup("{}");
*ctype = "application/json";
status = 200;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/followed_tags") == 0) { /** **/
Added some more dummy entry points.
2023-04-15 17:40:48 +03:00
*body = xs_dup("[]");
*ctype = "application/json";
Updated RELEASE_NOTES.
2023-04-13 07:38:05 +03:00
status = 200;
}
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v2/search") == 0) { /** **/
Only allow logged-in user to use search API
2023-06-10 22:04:08 +03:00
if (logged_in) {
const char *q = xs_dict_get(args, "q");
const char *type = xs_dict_get(args, "type");
const char *offset = xs_dict_get(args, "offset");
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
Only allow logged-in user to use search API
2023-06-10 22:04:08 +03:00
xs *acl = xs_list_new();
xs *stl = xs_list_new();
xs *htl = xs_list_new();
xs *res = xs_dict_new();
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
Only allow logged-in user to use search API
2023-06-10 22:04:08 +03:00
if (xs_is_null(offset) || strcmp(offset, "0") == 0) {
/* reply something only for offset 0; otherwise,
apps like Tusky keep asking again and again */
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
mastoapi: Added content search.
2024-05-09 10:09:22 +03:00
if (!xs_is_null(q)) {
if (xs_is_null(type) || strcmp(type, "accounts") == 0) {
mastoapi: added search by tag.
2024-03-02 07:56:02 +03:00
/* do a webfinger query */
char *actor = NULL;
char *user = NULL;
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
mastoapi: added search by tag.
2024-03-02 07:56:02 +03:00
if (valid_status(webfinger_request(q, &actor, &user)) && actor) {
xs *actor_o = NULL;
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
mastoapi: added search by tag.
2024-03-02 07:56:02 +03:00
if (valid_status(actor_request(&snac1, actor, &actor_o))) {
xs *acct = mastoapi_account(actor_o);
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
mastoapi: added search by tag.
2024-03-02 07:56:02 +03:00
acl = xs_list_append(acl, acct);
}
}
}
mastoapi: Added content search.
2024-05-09 10:09:22 +03:00
if (xs_is_null(type) || strcmp(type, "hashtags") == 0) {
mastoapi: added search by tag.
2024-03-02 07:56:02 +03:00
/* search this tag */
xs *tl = tag_search((char *)q, 0, 1);
if (xs_list_len(tl)) {
xs *d = xs_dict_new();
d = xs_dict_append(d, "name", q);
xs *url = xs_fmt("%s?t=%s", srv_baseurl, q);
d = xs_dict_append(d, "url", url);
Backport from xs.
2024-03-15 06:10:11 +03:00
d = xs_dict_append(d, "history", xs_stock(XSTYPE_LIST));
mastoapi: added search by tag.
2024-03-02 07:56:02 +03:00
htl = xs_list_append(htl, d);
Only allow logged-in user to use search API
2023-06-10 22:04:08 +03:00
}
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
}
mastoapi: Added content search.
2024-05-09 10:09:22 +03:00
if (xs_is_null(type) || strcmp(type, "statuses") == 0) {
int to = 0;
Added a maximum results argument to content_search().
2024-05-09 10:31:10 +03:00
int cnt = 40;
Added a skip argument to content_search().
2024-05-10 12:29:18 +03:00
xs *tl = content_search(&snac1, q, 1, 0, cnt, 0, &to);
mastoapi: Added content search.
2024-05-09 10:09:22 +03:00
int c = 0;
char *v;
mastoapi: some search by content tweaks.
2024-05-09 10:24:39 +03:00
while (xs_list_next(tl, &v, &c) && --cnt) {
mastoapi: Added content search.
2024-05-09 10:09:22 +03:00
xs *post = NULL;
if (!valid_status(timeline_get_by_md5(&snac1, v, &post)))
continue;
xs *s = mastoapi_status(&snac1, post);
mastoapi: some search by content tweaks.
2024-05-09 10:24:39 +03:00
if (!xs_is_null(s))
stl = xs_list_append(stl, s);
mastoapi: Added content search.
2024-05-09 10:09:22 +03:00
}
}
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
}
}
Only allow logged-in user to use search API
2023-06-10 22:04:08 +03:00
res = xs_dict_append(res, "accounts", acl);
res = xs_dict_append(res, "statuses", stl);
res = xs_dict_append(res, "hashtags", htl);
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(res, 4);
Only allow logged-in user to use search API
2023-06-10 22:04:08 +03:00
*ctype = "application/json";
status = 200;
}
else
status = 401;
Added mastoapi code for account search.
2023-04-23 06:33:54 +03:00
}
OAuth login now works.
2023-04-09 21:34:05 +03:00
More mastoapi work.
2023-04-09 22:31:56 +03:00
/* user cleanup */
if (logged_in)
Added the mastodon personal timeline.
2023-04-12 19:44:15 +03:00
user_free(&snac1);
More mastoapi work.
2023-04-09 22:31:56 +03:00
mastoapi: implemented /api/v1/accounts/lookup.
2023-10-28 08:10:21 +03:00
srv_debug(1, xs_fmt("mastoapi_get_handler %s %d", q_path, status));
OAuth login now works.
2023-04-09 21:34:05 +03:00
return status;
}
More mastoapi work.
2023-04-08 10:09:43 +03:00
int mastoapi_post_handler(const xs_dict *req, const char *q_path,
OAuth login now works.
2023-04-09 21:34:05 +03:00
const char *payload, int p_size,
char **body, int *b_size, char **ctype)
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
{
Added -Wextra to C flags.
2023-05-04 10:28:36 +03:00
(void)p_size;
(void)b_size;
Also accept /api/v2 urls.
2023-04-16 09:13:45 +03:00
if (!xs_startswith(q_path, "/api/v1/") && !xs_startswith(q_path, "/api/v2/"))
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
return 0;
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
int status = 404;
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
xs *args = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *i_ctype = xs_dict_get(req, "content-type");
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
mastoapi: avoid crashing on empty payloads.
2024-01-26 21:01:59 +03:00
if (i_ctype && xs_startswith(i_ctype, "application/json")) {
if (!xs_is_null(payload))
args = xs_json_loads(payload);
}
make compatible with subway tooter app
2024-01-28 23:55:43 +03:00
else if (i_ctype && xs_startswith(i_ctype, "application/x-www-form-urlencoded"))
{
Some formatting tweaks.
2024-03-12 09:03:44 +03:00
// Some apps send form data instead of json so we should cater for those
cleanup
2024-01-29 00:07:31 +03:00
if (!xs_is_null(payload)) {
make compatible with subway tooter app
2024-01-28 23:55:43 +03:00
xs *upl = xs_url_dec(payload);
args = xs_url_vars(upl);
cleanup
2024-01-29 00:07:31 +03:00
}
make compatible with subway tooter app
2024-01-28 23:55:43 +03:00
}
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
else
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
args = xs_dup(xs_dict_get(req, "p_vars"));
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
if (args == NULL)
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
return 400;
Use xs_replace_n() where it suits.
2023-05-02 07:49:00 +03:00
xs *cmd = xs_replace_n(q_path, "/api", "", 1);
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
snac snac = {0};
Added forgotten user cleanup in mastoapi_post_handler().
2023-04-12 13:16:23 +03:00
int logged_in = process_auth_token(&snac, req);
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/apps") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
const char *name = xs_dict_get(args, "client_name");
const char *ruri = xs_dict_get(args, "redirect_uris");
const char *scope = xs_dict_get(args, "scope");
Fixed avatar.
2023-04-09 23:10:49 +03:00
if (xs_type(ruri) == XSTYPE_LIST)
ruri = xs_dict_get(ruri, 0);
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
if (name && ruri) {
More mastoapi work.
2023-04-08 10:09:43 +03:00
xs *app = xs_dict_new();
xs *id = xs_replace_i(tid(0), ".", "");
xs *csec = random_str();
xs *vkey = random_str();
Ensure the new app client_id is unique.
2023-04-28 09:28:17 +03:00
xs *cid = NULL;
/* pick a non-existent random cid */
for (;;) {
cid = random_str();
xs *p_app = app_get(cid);
if (p_app == NULL)
break;
xs_free(cid);
}
More mastoapi work.
2023-04-08 10:09:43 +03:00
app = xs_dict_append(app, "name", name);
app = xs_dict_append(app, "redirect_uri", ruri);
app = xs_dict_append(app, "client_id", cid);
app = xs_dict_append(app, "client_secret", csec);
app = xs_dict_append(app, "vapid_key", vkey);
app = xs_dict_append(app, "id", id);
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(app, 4);
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
*ctype = "application/json";
status = 200;
More mastoapi work.
2023-04-08 11:29:33 +03:00
app = xs_dict_append(app, "code", "");
Fixed avatar.
2023-04-09 23:10:49 +03:00
if (scope)
app = xs_dict_append(app, "scope", scope);
More mastoapi work.
2023-04-08 11:29:33 +03:00
app_add(cid, app);
Fixed avatar.
2023-04-09 23:10:49 +03:00
Fixed mastoapi debug levels.
2023-05-04 12:53:17 +03:00
srv_debug(1, xs_fmt("mastoapi apps: new app %s", cid));
Added some OAuth scaffold code.
2023-04-08 08:04:40 +03:00
}
}
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/statuses") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
if (logged_in) {
/* post a new Note */
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
const char *content = xs_dict_get(args, "status");
const char *mid = xs_dict_get(args, "in_reply_to_id");
const char *visibility = xs_dict_get(args, "visibility");
const char *summary = xs_dict_get(args, "spoiler_text");
Added mastoapi support for adding images.
2023-04-22 01:17:42 +03:00
const char *media_ids = xs_dict_get(args, "media_ids");
if (xs_is_null(media_ids))
media_ids = xs_dict_get(args, "media_ids[]");
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
More mastoapi tweaks.
2023-08-13 14:00:36 +03:00
if (xs_is_null(media_ids))
media_ids = xs_dict_get(args, "media_ids");
Avoid crash in optional mastoapi argument.
2023-05-04 07:27:13 +03:00
if (xs_is_null(visibility))
visibility = "public";
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
xs *attach_list = xs_list_new();
Fixed use-after-free in reply messages.
2023-04-16 08:12:57 +03:00
xs *irt = NULL;
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
/* is it a reply? */
if (mid != NULL) {
xs *r_msg = NULL;
const char *md5 = MID_TO_MD5(mid);
if (valid_status(object_get_by_md5(md5, &r_msg)))
Fixed use-after-free in reply messages.
2023-04-16 08:12:57 +03:00
irt = xs_dup(xs_dict_get(r_msg, "id"));
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
}
Added mastoapi support for adding images.
2023-04-22 01:17:42 +03:00
/* does it have attachments? */
if (!xs_is_null(media_ids)) {
xs *mi = NULL;
if (xs_type(media_ids) == XSTYPE_LIST)
mi = xs_dup(media_ids);
else {
mi = xs_list_new();
mi = xs_list_append(mi, media_ids);
}
xs_list *p = mi;
xs_str *v;
while (xs_list_iter(&p, &v)) {
Use static_get_meta() when preparing the attachment.
2023-04-22 01:51:06 +03:00
xs *l = xs_list_new();
xs *url = xs_fmt("%s/s/%s", snac.actor, v);
xs *desc = static_get_meta(&snac, v);
Added mastoapi support for adding images.
2023-04-22 01:17:42 +03:00
l = xs_list_append(l, url);
Use static_get_meta() when preparing the attachment.
2023-04-22 01:51:06 +03:00
l = xs_list_append(l, desc);
Added mastoapi support for adding images.
2023-04-22 01:17:42 +03:00
attach_list = xs_list_append(attach_list, l);
}
}
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
/* prepare the message */
xs *msg = msg_note(&snac, content, NULL, irt, attach_list,
strcmp(visibility, "public") == 0 ? 0 : 1);
if (!xs_is_null(summary) && *summary) {
Backport from xs.
2024-03-15 06:10:11 +03:00
msg = xs_dict_set(msg, "sensitive", xs_stock(XSTYPE_TRUE));
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
msg = xs_dict_set(msg, "summary", summary);
}
/* store */
timeline_add(&snac, xs_dict_get(msg, "id"), msg);
/* 'Create' message */
xs *c_msg = msg_create(&snac, msg);
enqueue_message(&snac, c_msg);
timeline_touch(&snac);
/* convert to a mastodon status as a response code */
xs *st = mastoapi_status(&snac, msg);
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(st, 4);
Posts can now be sent (still no images).
2023-04-15 20:05:26 +03:00
*ctype = "application/json";
status = 200;
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
}
else
status = 401;
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (xs_startswith(cmd, "/v1/statuses")) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
if (logged_in) {
/* operations on a status */
xs *l = xs_split(cmd, "/");
Fixed use-after-free in reply messages.
2023-04-16 08:12:57 +03:00
const char *mid = xs_list_get(l, 3);
const char *op = xs_list_get(l, 4);
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
if (!xs_is_null(mid)) {
xs *msg = NULL;
xs *out = NULL;
Added forgotten user cleanup in mastoapi_post_handler().
2023-04-12 13:16:23 +03:00
/* skip the 'fake' part of the id */
Use the ctime instead of the published date in mastoapi_id().
2023-04-12 11:19:43 +03:00
mid = MID_TO_MD5(mid);
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
if (valid_status(timeline_get_by_md5(&snac, mid, &msg))) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *id = xs_dict_get(msg, "id");
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
if (op == NULL) {
/* no operation (?) */
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "favourite") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
xs *n_msg = msg_admiration(&snac, id, "Like");
if (n_msg != NULL) {
enqueue_message(&snac, n_msg);
timeline_admire(&snac, xs_dict_get(n_msg, "object"), snac.actor, 1);
out = mastoapi_status(&snac, msg);
}
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "unfavourite") == 0) { /** **/
mastoapi: 'unfavourite' and 'unreblog' actions now fully work.
2024-04-11 06:12:13 +03:00
xs *n_msg = msg_repulsion(&snac, id, "Like");
if (n_msg != NULL) {
enqueue_message(&snac, n_msg);
out = mastoapi_status(&snac, msg);
}
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "reblog") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
xs *n_msg = msg_admiration(&snac, id, "Announce");
if (n_msg != NULL) {
enqueue_message(&snac, n_msg);
timeline_admire(&snac, xs_dict_get(n_msg, "object"), snac.actor, 0);
out = mastoapi_status(&snac, msg);
}
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "unreblog") == 0) { /** **/
mastoapi: 'unfavourite' and 'unreblog' actions now fully work.
2024-04-11 06:12:13 +03:00
xs *n_msg = msg_repulsion(&snac, id, "Announce");
if (n_msg != NULL) {
enqueue_message(&snac, n_msg);
out = mastoapi_status(&snac, msg);
}
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "bookmark") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
/* snac does not support bookmarks */
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "unbookmark") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
/* snac does not support bookmarks */
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "pin") == 0) { /** **/
In mastoapi, notes can be pinned / unpinned.
2023-06-28 21:36:23 +03:00
/* pin this message */
if (pin(&snac, id))
out = mastoapi_status(&snac, msg);
else
status = 422;
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "unpin") == 0) { /** **/
In mastoapi, notes can be pinned / unpinned.
2023-06-28 21:36:23 +03:00
/* unpin this message */
unpin(&snac, id);
out = mastoapi_status(&snac, msg);
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "mute") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
/* Mastodon's mute is snac's hide */
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(op, "unmute") == 0) { /** **/
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
/* Mastodon's unmute is snac's unhide */
}
}
if (out != NULL) {
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(out, 4);
Added support for likes and boosts.
2023-04-11 22:07:47 +03:00
*ctype = "application/json";
status = 200;
}
}
}
else
status = 401;
}
New mastoapi to clear all notifications.
2023-04-14 20:39:31 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/notifications/clear") == 0) { /** **/
New mastoapi to clear all notifications.
2023-04-14 20:39:31 +03:00
if (logged_in) {
notify_clear(&snac);
timeline_touch(&snac);
*body = xs_dup("{}");
*ctype = "application/json";
status = 200;
}
else
status = 401;
}
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/push/subscription") == 0) { /** **/
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
/* I don't know what I'm doing */
if (logged_in) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *v;
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
xs *wpush = xs_dict_new();
wpush = xs_dict_append(wpush, "id", "1");
v = xs_dict_get(args, "data");
v = xs_dict_get(v, "alerts");
wpush = xs_dict_append(wpush, "alerts", v);
v = xs_dict_get(args, "subscription");
v = xs_dict_get(v, "endpoint");
wpush = xs_dict_append(wpush, "endpoint", v);
xs *server_key = random_str();
wpush = xs_dict_append(wpush, "server_key", server_key);
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(wpush, 4);
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
*ctype = "application/json";
status = 200;
}
else
status = 401;
Also accept /api/v2 urls.
2023-04-16 09:13:45 +03:00
}
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (strcmp(cmd, "/v1/media") == 0 || strcmp(cmd, "/v2/media") == 0) { /** **/
Also accept /api/v2 urls.
2023-04-16 09:13:45 +03:00
if (logged_in) {
Added mastoapi support for adding images.
2023-04-22 01:17:42 +03:00
const xs_list *file = xs_dict_get(args, "file");
const char *desc = xs_dict_get(args, "description");
if (xs_is_null(desc))
desc = "";
status = 400;
if (xs_type(file) == XSTYPE_LIST) {
const char *fn = xs_list_get(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(file, 1));
int fs = xs_number_get(xs_list_get(file, 2));
/* store */
static_put(&snac, id, payload + fo, fs);
Use static_get_meta() when preparing the attachment.
2023-04-22 01:51:06 +03:00
static_put_meta(&snac, id, desc);
Added mastoapi support for adding images.
2023-04-22 01:17:42 +03:00
/* prepare a response */
xs *rsp = xs_dict_new();
rsp = xs_dict_append(rsp, "id", id);
rsp = xs_dict_append(rsp, "type", "image");
rsp = xs_dict_append(rsp, "url", url);
rsp = xs_dict_append(rsp, "preview_url", url);
rsp = xs_dict_append(rsp, "remote_url", url);
rsp = xs_dict_append(rsp, "description", desc);
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(rsp, 4);
Added mastoapi support for adding images.
2023-04-22 01:17:42 +03:00
*ctype = "application/json";
status = 200;
}
}
Also accept /api/v2 urls.
2023-04-16 09:13:45 +03:00
}
else
status = 401;
Added entrypoint /push/subscription. The returned object is just wild guessing, I don't understand all this things. Anyway, the offical app keeps crashing.
2023-04-15 19:06:18 +03:00
}
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
else
Added some code comments.
2023-05-12 13:29:24 +03:00
if (xs_startswith(cmd, "/v1/accounts")) { /** **/
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
if (logged_in) {
/* account-related information */
xs *l = xs_split(cmd, "/");
const char *md5 = xs_list_get(l, 3);
const char *opt = xs_list_get(l, 4);
xs *rsp = NULL;
if (!xs_is_null(md5) && *md5) {
xs *actor_o = NULL;
if (xs_is_null(opt)) {
/* ? */
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(opt, "follow") == 0) { /** **/
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
if (valid_status(object_get_by_md5(md5, &actor_o))) {
const char *actor = xs_dict_get(actor_o, "id");
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);
rsp = mastoapi_relationship(&snac, md5);
}
}
}
else
Added more comment marks.
2023-05-12 14:06:38 +03:00
if (strcmp(opt, "unfollow") == 0) { /** **/
Added mastoapi unfollow.
2023-04-23 09:51:02 +03:00
if (valid_status(object_get_by_md5(md5, &actor_o))) {
const char *actor = xs_dict_get(actor_o, "id");
/* 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);
rsp = mastoapi_relationship(&snac, md5);
}
}
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
}
Mastoapi: added block / unblock.
2023-05-18 10:46:21 +03:00
else
if (strcmp(opt, "block") == 0) { /** **/
if (valid_status(object_get_by_md5(md5, &actor_o))) {
const char *actor = xs_dict_get(actor_o, "id");
mute(&snac, actor);
rsp = mastoapi_relationship(&snac, md5);
}
}
else
if (strcmp(opt, "unblock") == 0) { /** **/
if (valid_status(object_get_by_md5(md5, &actor_o))) {
const char *actor = xs_dict_get(actor_o, "id");
unmute(&snac, actor);
rsp = mastoapi_relationship(&snac, md5);
}
}
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
}
if (rsp != NULL) {
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(rsp, 4);
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
*ctype = "application/json";
status = 200;
}
}
else
status = 401;
Started voting on mastoapi (non-working).
2023-05-31 12:13:06 +03:00
}
else
if (xs_startswith(cmd, "/v1/polls")) { /** **/
if (logged_in) {
/* operations on a status */
xs *l = xs_split(cmd, "/");
const char *mid = xs_list_get(l, 3);
const char *op = xs_list_get(l, 4);
if (!xs_is_null(mid)) {
xs *msg = NULL;
xs *out = NULL;
/* skip the 'fake' part of the id */
mid = MID_TO_MD5(mid);
if (valid_status(timeline_get_by_md5(&snac, mid, &msg))) {
Now you can vote from the mastoapi.
2023-06-01 09:40:08 +03:00
const char *id = xs_dict_get(msg, "id");
New function get_atto(), to get the attributedTo field.
2024-01-19 01:04:37 +03:00
const char *atto = get_atto(msg);
Now you can vote from the mastoapi.
2023-06-01 09:40:08 +03:00
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *opts = xs_dict_get(msg, "oneOf");
Now you can vote from the mastoapi.
2023-06-01 09:40:08 +03:00
if (opts == NULL)
opts = xs_dict_get(msg, "anyOf");
Started voting on mastoapi (non-working).
2023-05-31 12:13:06 +03:00
if (op == NULL) {
}
else
if (strcmp(op, "votes") == 0) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *choices = xs_dict_get(args, "choices[]");
Now you can vote from the mastoapi.
2023-06-01 09:40:08 +03:00
More mastoapi tweaks.
2023-08-13 14:00:36 +03:00
if (xs_is_null(choices))
choices = xs_dict_get(args, "choices");
Now you can vote from the mastoapi.
2023-06-01 09:40:08 +03:00
if (xs_type(choices) == XSTYPE_LIST) {
xs_str *v;
Added const everywhere.
2024-05-21 15:12:15 +03:00
int c = 0;
while (xs_list_next(choices, &v, &c)) {
Now you can vote from the mastoapi.
2023-06-01 09:40:08 +03:00
int io = atoi(v);
const xs_dict *o = xs_list_get(opts, io);
if (o) {
const char *name = xs_dict_get(o, "name");
xs *msg = msg_note(&snac, "", atto, (char *)id, NULL, 1);
msg = xs_dict_append(msg, "name", name);
xs *c_msg = msg_create(&snac, msg);
enqueue_message(&snac, c_msg);
timeline_add(&snac, xs_dict_get(msg, "id"), msg);
}
}
Started voting on mastoapi (non-working).
2023-05-31 12:13:06 +03:00
Now you can vote from the mastoapi.
2023-06-01 09:40:08 +03:00
out = mastoapi_poll(&snac, msg);
Started voting on mastoapi (non-working).
2023-05-31 12:13:06 +03:00
}
}
}
if (out != NULL) {
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(out, 4);
Started voting on mastoapi (non-working).
2023-05-31 12:13:06 +03:00
*ctype = "application/json";
status = 200;
}
}
}
else
status = 401;
Added mastoapi follow.
2023-04-23 09:44:26 +03:00
}
Start of list support.
2024-04-29 08:43:01 +03:00
else
if (strcmp(cmd, "/v1/lists") == 0) {
if (logged_in) {
const char *title = xs_dict_get(args, "title");
if (xs_type(title) == XSTYPE_STRING) {
/* add the list */
xs *out = xs_dict_new();
More work in lists.
2024-04-29 09:29:18 +03:00
if (xs_type(list_maint(&snac, title, 1)) == XSTYPE_TRUE) {
out = xs_dict_append(out, "title", title);
out = xs_dict_append(out, "replies_policy", xs_dict_get_def(args, "replies_policy", "list"));
out = xs_dict_append(out, "exclusive", xs_stock(XSTYPE_FALSE));
status = 200;
}
else {
out = xs_dict_append(out, "error", "cannot create list");
status = 422;
}
Start of list support.
2024-04-29 08:43:01 +03:00
*body = xs_json_dumps(out, 4);
*ctype = "application/json";
}
else
status = 422;
}
}
More work in lists.
2024-04-29 10:26:37 +03:00
if (xs_startswith(cmd, "/v1/lists/")) { /** list maintenance **/
if (logged_in) {
xs *l = xs_split(cmd, "/");
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *op = xs_list_get(l, -1);
const char *id = xs_list_get(l, -2);
More work in lists.
2024-04-29 10:26:37 +03:00
if (op && id && xs_is_hex(id)) {
if (strcmp(op, "accounts") == 0) {
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *accts = xs_dict_get(args, "account_ids[]");
More work in lists.
2024-04-29 10:26:37 +03:00
int c = 0;
char *v;
while (xs_list_next(accts, &v, &c)) {
list_content(&snac, id, v, 1);
}
status = 200;
}
}
}
else
status = 422;
}
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
Added forgotten user cleanup in mastoapi_post_handler().
2023-04-12 13:16:23 +03:00
/* user cleanup */
if (logged_in)
user_free(&snac);
Log status in mastoapi_post_handler().
2024-04-14 19:31:53 +03:00
srv_debug(1, xs_fmt("mastoapi_post_handler %s %d", q_path, status));
New file mastoapi.c.
2023-04-08 07:09:05 +03:00
return status;
}
Added a new compilation variable NO_MASTODON_API. The Mastodon API is a big and ugly beast; if you don't want it in your snac, you can compile it out by running make CFLAGS=-DNO_MASTODON_API And your snac binary will be as slim as always.
2023-04-22 00:17:58 +03:00
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
Support DELETE for Mastodon subscriptions While testing Mona, I noticed that after deleting my account entry for my snac server, Mona would repeatedly try to delete the subscription it thought it had created, resulting in many unhandled DELETE calls. This accepts the call and returns 200 for it, which makes Mona happy.
2024-01-11 16:38:08 +03:00
int mastoapi_delete_handler(const xs_dict *req, const char *q_path,
More work in lists.
2024-04-29 10:26:37 +03:00
const char *payload, int p_size,
char **body, int *b_size, char **ctype)
{
(void)p_size;
Silenced some unused argument warnings.
2024-01-11 20:55:09 +03:00
(void)body;
(void)b_size;
(void)ctype;
Support DELETE for Mastodon subscriptions While testing Mona, I noticed that after deleting my account entry for my snac server, Mona would repeatedly try to delete the subscription it thought it had created, resulting in many unhandled DELETE calls. This accepts the call and returns 200 for it, which makes Mona happy.
2024-01-11 16:38:08 +03:00
if (!xs_startswith(q_path, "/api/v1/") && !xs_startswith(q_path, "/api/v2/"))
return 0;
More work in lists.
2024-04-29 10:26:37 +03:00
int status = 404;
xs *args = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *i_ctype = xs_dict_get(req, "content-type");
More work in lists.
2024-04-29 10:26:37 +03:00
if (i_ctype && xs_startswith(i_ctype, "application/json")) {
if (!xs_is_null(payload))
args = xs_json_loads(payload);
}
else if (i_ctype && xs_startswith(i_ctype, "application/x-www-form-urlencoded"))
{
// Some apps send form data instead of json so we should cater for those
if (!xs_is_null(payload)) {
xs *upl = xs_url_dec(payload);
args = xs_url_vars(upl);
}
}
else
args = xs_dup(xs_dict_get(req, "p_vars"));
if (args == NULL)
return 400;
More work in lists.
2024-04-29 09:29:18 +03:00
snac snac = {0};
int logged_in = process_auth_token(&snac, req);
Support DELETE for Mastodon subscriptions While testing Mona, I noticed that after deleting my account entry for my snac server, Mona would repeatedly try to delete the subscription it thought it had created, resulting in many unhandled DELETE calls. This accepts the call and returns 200 for it, which makes Mona happy.
2024-01-11 16:38:08 +03:00
xs *cmd = xs_replace_n(q_path, "/api", "", 1);
More work in lists.
2024-04-29 09:29:18 +03:00
Support DELETE for Mastodon subscriptions While testing Mona, I noticed that after deleting my account entry for my snac server, Mona would repeatedly try to delete the subscription it thought it had created, resulting in many unhandled DELETE calls. This accepts the call and returns 200 for it, which makes Mona happy.
2024-01-11 16:38:08 +03:00
if (xs_startswith(cmd, "/v1/push/subscription") || xs_startswith(cmd, "/v2/push/subscription")) { /** **/
// pretend we deleted it, since it doesn't exist anyway
More work in lists.
2024-04-29 09:29:18 +03:00
status = 200;
Support DELETE for Mastodon subscriptions While testing Mona, I noticed that after deleting my account entry for my snac server, Mona would repeatedly try to delete the subscription it thought it had created, resulting in many unhandled DELETE calls. This accepts the call and returns 200 for it, which makes Mona happy.
2024-01-11 16:38:08 +03:00
}
More work in lists.
2024-04-29 09:29:18 +03:00
else
if (xs_startswith(cmd, "/v1/lists/")) {
if (logged_in) {
xs *l = xs_split(cmd, "/");
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *p = xs_list_get(l, -1);
More work in lists.
2024-04-29 10:26:37 +03:00
if (p) {
if (strcmp(p, "accounts") == 0) {
/* delete account from list */
p = xs_list_get(l, -2);
Added const everywhere.
2024-05-21 15:12:15 +03:00
const xs_list *accts = xs_dict_get(args, "account_ids[]");
More work in lists.
2024-04-29 10:26:37 +03:00
int c = 0;
char *v;
while (xs_list_next(accts, &v, &c)) {
list_content(&snac, p, v, 2);
}
}
else {
/* delete list */
if (xs_is_hex(p)) {
list_maint(&snac, p, 2);
}
}
More work in lists.
2024-04-29 09:29:18 +03:00
}
status = 200;
}
else
status = 401;
}
/* user cleanup */
if (logged_in)
user_free(&snac);
srv_debug(1, xs_fmt("mastoapi_delete_handler %s %d", q_path, status));
return status;
Support DELETE for Mastodon subscriptions While testing Mona, I noticed that after deleting my account entry for my snac server, Mona would repeatedly try to delete the subscription it thought it had created, resulting in many unhandled DELETE calls. This accepts the call and returns 200 for it, which makes Mona happy.
2024-01-11 16:38:08 +03:00
}
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
int mastoapi_put_handler(const xs_dict *req, const char *q_path,
const char *payload, int p_size,
char **body, int *b_size, char **ctype)
{
Added -Wextra to C flags.
2023-05-04 10:28:36 +03:00
(void)p_size;
(void)b_size;
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
if (!xs_startswith(q_path, "/api/v1/") && !xs_startswith(q_path, "/api/v2/"))
return 0;
int status = 404;
xs *args = NULL;
Added const everywhere.
2024-05-21 15:12:15 +03:00
const char *i_ctype = xs_dict_get(req, "content-type");
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
mastoapi: avoid crashing on empty payloads.
2024-01-26 21:01:59 +03:00
if (i_ctype && xs_startswith(i_ctype, "application/json")) {
if (!xs_is_null(payload))
args = xs_json_loads(payload);
}
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
else
args = xs_dup(xs_dict_get(req, "p_vars"));
if (args == NULL)
return 400;
Use xs_replace_n() where it suits.
2023-05-02 07:49:00 +03:00
xs *cmd = xs_replace_n(q_path, "/api", "", 1);
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
snac snac = {0};
int logged_in = process_auth_token(&snac, req);
Added some code comments.
2023-05-12 13:29:24 +03:00
if (xs_startswith(cmd, "/v1/media") || xs_startswith(cmd, "/v2/media")) { /** **/
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
if (logged_in) {
xs *l = xs_split(cmd, "/");
const char *stid = xs_list_get(l, 3);
if (!xs_is_null(stid)) {
const char *desc = xs_dict_get(args, "description");
/* set the image metadata */
static_put_meta(&snac, stid, desc);
/* prepare a response */
xs *rsp = xs_dict_new();
xs *url = xs_fmt("%s/s/%s", snac.actor, stid);
rsp = xs_dict_append(rsp, "id", stid);
rsp = xs_dict_append(rsp, "type", "image");
rsp = xs_dict_append(rsp, "url", url);
rsp = xs_dict_append(rsp, "preview_url", url);
rsp = xs_dict_append(rsp, "remote_url", url);
rsp = xs_dict_append(rsp, "description", desc);
Renamed json dump functions to new xs spec.
2023-08-08 20:29:34 +03:00
*body = xs_json_dumps(rsp, 4);
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
*ctype = "application/json";
status = 200;
}
}
else
status = 401;
}
mastoapi: added /v1/statuses put support (note edit).
2024-01-23 18:21:48 +03:00
else
if (xs_startswith(cmd, "/v1/statuses")) {
if (logged_in) {
xs *l = xs_split(cmd, "/");
const char *mid = xs_list_get(l, 3);
if (!xs_is_null(mid)) {
const char *md5 = MID_TO_MD5(mid);
xs *rsp = NULL;
xs *msg = NULL;
if (valid_status(timeline_get_by_md5(&snac, md5, &msg))) {
const char *content = xs_dict_get(args, "status");
xs *atls = xs_list_new();
If an emoji in emojis.json is an URL to an image, it's stored in the tag list.
2024-03-25 18:15:09 +03:00
xs *f_content = not_really_markdown(content, &atls, NULL);
mastoapi: added /v1/statuses put support (note edit).
2024-01-23 18:21:48 +03:00
/* replace fields with new content */
msg = xs_dict_set(msg, "sourceContent", content);
msg = xs_dict_set(msg, "content", f_content);
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(xs_dict_get(msg, "id"), msg);
/* update message */
xs *c_msg = msg_update(&snac, msg);
enqueue_message(&snac, c_msg);
rsp = mastoapi_status(&snac, msg);
}
if (rsp != NULL) {
*body = xs_json_dumps(rsp, 4);
*ctype = "application/json";
status = 200;
}
}
}
else
status = 401;
}
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
/* user cleanup */
if (logged_in)
user_free(&snac);
mastoapi: added /v1/statuses put support (note edit).
2024-01-23 18:21:48 +03:00
srv_debug(1, xs_fmt("mastoapi_put_handler %s %d", q_path, status));
New function mastoapi_put_handler().
2023-04-22 02:21:09 +03:00
return status;
}
New function mastoapi_purge() (still dummy).
2023-04-28 09:33:02 +03:00
void mastoapi_purge(void)
{
Incomplete mastoapi apps are purged.
2023-04-28 09:58:33 +03:00
xs *spec = xs_fmt("%s/app/" "*.json", srv_basedir);
xs *files = xs_glob(spec, 1, 0);
xs_list *p = files;
xs_str *v;
time_t mt = time(NULL) - 3600;
while (xs_list_iter(&p, &v)) {
xs *cid = xs_replace(v, ".json", "");
xs *fn = _app_fn(cid);
if (mtime(fn) < mt) {
/* get the app */
xs *app = app_get(cid);
if (app) {
/* old apps with no uid are incomplete cruft */
const char *uid = xs_dict_get(app, "uid");
if (xs_is_null(uid) || *uid == '\0') {
unlink(fn);
srv_debug(2, xs_fmt("purged %s", fn));
}
}
}
}
New function mastoapi_purge() (still dummy).
2023-04-28 09:33:02 +03:00
}
Added a new compilation variable NO_MASTODON_API. The Mastodon API is a big and ugly beast; if you don't want it in your snac, you can compile it out by running make CFLAGS=-DNO_MASTODON_API And your snac binary will be as slim as always.
2023-04-22 00:17:58 +03:00
#endif /* #ifndef NO_MASTODON_API */
Reference in New Issue Copy Permalink