2.71
utils.c
1/* snac - A simple, minimalistic ActivityPub instance */
2/* copyright (c) 2022 - 2025 grunfink et al. / MIT license */
3
4#include "xs.h"
5#include "xs_io.h"
6#include "xs_json.h"
7#include "xs_time.h"
8#include "xs_openssl.h"
9#include "xs_random.h"
10#include "xs_glob.h"
11#include "xs_curl.h"
12#include "xs_regex.h"
13
14#include "snac.h"
15
16#include <sys/stat.h>
17#include <stdlib.h>
18
19static const char *default_srv_config = "{"
20 "\"host\": \"\","
21 "\"prefix\": \"\","
22 "\"address\": \"127.0.0.1\","
23 "\"port\": 8001,"
24 "\"layout\": 0.0,"
25 "\"dbglevel\": 0,"
26 "\"queue_retry_minutes\": 2,"
27 "\"queue_retry_max\": 10,"
28 "\"queue_timeout\": 6,"
29 "\"queue_timeout_2\": 8,"
30 "\"cssurls\": [\"\"],"
31 "\"max_timeline_entries\": 50,"
32 "\"timeline_purge_days\": 120,"
33 "\"local_purge_days\": 0,"
34 "\"min_account_age\": 0,"
35 "\"admin_email\": \"\","
36 "\"admin_account\": \"\","
37 "\"title\": \"\","
38 "\"short_description\": \"\","
39 "\"protocol\": \"https\","
40 "\"fastcgi\": false"
41 "}";
42
43static const char *default_css =
44 "body { max-width: 48em; margin: auto; line-height: 1.5; padding: 0.8em; word-wrap: break-word; }\n"
45 "pre { overflow-x: scroll; }\n"
46 ".snac-embedded-video, img { max-width: 100% }\n"
47 ".snac-origin { font-size: 85% }\n"
48 ".snac-score { float: right; font-size: 85% }\n"
49 ".snac-top-user { text-align: center; padding-bottom: 2em }\n"
50 ".snac-top-user-name { font-size: 200% }\n"
51 ".snac-top-user-id { font-size: 150% }\n"
52 ".snac-announcement { border: black 1px solid; padding: 0.5em }\n"
53 ".snac-avatar { float: left; height: 2.5em; width: 2.5em; padding: 0.25em }\n"
54 ".snac-author { font-size: 90%; text-decoration: none }\n"
55 ".snac-author-tag { font-size: 80% }\n"
56 ".snac-pubdate { color: #a0a0a0; font-size: 90% }\n"
57 ".snac-top-controls { padding-bottom: 1.5em }\n"
58 ".snac-post { border-top: 1px solid #a0a0a0; padding-top: 0.5em; padding-bottom: 0.5em; }\n"
59 ".snac-children { padding-left: 1em; border-left: 1px solid #a0a0a0; }\n"
60 ".snac-textarea { font-family: inherit; width: 100% }\n"
61 ".snac-history { border: 1px solid #606060; border-radius: 3px; margin: 2.5em 0; padding: 0 2em }\n"
62 ".snac-btn-mute { float: right; margin-left: 0.5em }\n"
63 ".snac-btn-unmute { float: right; margin-left: 0.5em }\n"
64 ".snac-btn-follow { float: right; margin-left: 0.5em }\n"
65 ".snac-btn-unfollow { float: right; margin-left: 0.5em }\n"
66 ".snac-btn-hide { float: right; margin-left: 0.5em }\n"
67 ".snac-btn-delete { float: right; margin-left: 0.5em }\n"
68 ".snac-btn-limit { float: right; margin-left: 0.5em }\n"
69 ".snac-btn-unlimit { float: right; margin-left: 0.5em }\n"
70 ".snac-footer { margin-top: 2em; font-size: 75% }\n"
71 ".snac-poll-result { margin-left: auto; margin-right: auto; }\n"
72 ".snac-list-of-lists { padding-left: 0; }\n"
73 ".snac-list-of-lists li { display: inline; border: 1px solid #a0a0a0; border-radius: 25px;\n"
74 " margin-right: 0.5em; padding-left: 0.5em; padding-right: 0.5em; }\n"
75 ".snac-no-more-unseen-posts { border-top: 1px solid #a0a0a0; border-bottom: 1px solid #a0a0a0; padding: 0.5em 0; margin: 1em 0; }\n"
76 "@media (prefers-color-scheme: dark) { \n"
77 " body, input, textarea { background-color: #000; color: #fff; }\n"
78 " a { color: #7799dd }\n"
79 " a:visited { color: #aa99dd }\n"
80 "}\n"
81;
82
83const char *snac_blurb =
84 "<p><b>%host%</b> is a <a href=\"https:/"
85 "/en.wikipedia.org/wiki/Fediverse\">Fediverse</a> "
86 "instance that uses the <a href=\"https:/"
87 "/en.wikipedia.org/wiki/ActivityPub\">ActivityPub</a> "
88 "protocol. In other words, users at this host can communicate with people "
89 "that use software like Mastodon, Pleroma, Friendica, etc. "
90 "all around the world.</p>\n"
91 "<p>This server runs the "
92 "<a href=\"" WHAT_IS_SNAC_URL "\">snac</a> software and there is no "
93 "automatic sign-up process.</p>\n"
94;
95
96static const char *greeting_html =
97 "<!DOCTYPE html>\n"
98 "<html><head>\n"
99 "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"/>\n"
100 "<link rel=\"icon\" type=\"image/x-icon\" href=\"https://%host%/favicon.ico\"/>\n"
101 "<title>Welcome to %host%</title>\n</head>\n"
102 "<body style=\"margin: auto; max-width: 50em\">\n"
103 "%blurb%"
104 "<p>The following users are part of this community:</p>\n"
105 "\n"
106 "%userlist%\n"
107 "\n"
108 "<p>This site is powered by <abbr title=\"Social Networks Are Crap\">snac</abbr>.</p>\n"
109 "</body></html>\n";
110
111
112int write_default_css(void)
113{
114 FILE *f;
115
116 xs *sfn = xs_fmt("%s/style.css", srv_basedir);
117 if ((f = fopen(sfn, "w")) == NULL)
118 return 1;
119
120 fwrite(default_css, strlen(default_css), 1, f);
121 fclose(f);
122
123 return 0;
124}
125
126
127int snac_init(const char *basedir)
128{
129 FILE *f;
130
131 if (basedir == NULL) {
132 printf("Base directory: "); fflush(stdout);
133 srv_basedir = xs_strip_i(xs_readline(stdin));
134 }
135 else
136 srv_basedir = xs_str_new(basedir);
137
138 if (srv_basedir == NULL || *srv_basedir == '\0')
139 return 1;
140
141 if (xs_endswith(srv_basedir, "/"))
142 srv_basedir = xs_crop_i(srv_basedir, 0, -1);
143
144 if (mtime(srv_basedir) != 0.0) {
145 printf("ERROR: directory '%s' must not exist.\n", srv_basedir);
146 return 1;
147 }
148
149 srv_config = xs_json_loads(default_srv_config);
150
151 xs *layout = xs_number_new(disk_layout);
152 srv_config = xs_dict_set(srv_config, "layout", layout);
153
154 int is_unix_socket = 0;
155
156 printf("Network address or full path to unix socket [%s]: ", xs_dict_get(srv_config, "address")); fflush(stdout);
157 {
158 xs *i = xs_strip_i(xs_readline(stdin));
159 if (*i) {
160 srv_config = xs_dict_set(srv_config, "address", i);
161
162 if (*i == '/')
163 is_unix_socket = 1;
164 }
165 }
166
167 if (!is_unix_socket) {
168 printf("Network port [%d]: ", (int)xs_number_get(xs_dict_get(srv_config, "port"))); fflush(stdout);
169 {
170 xs *i = xs_strip_i(xs_readline(stdin));
171 if (*i) {
172 xs *n = xs_number_new(atoi(i));
173 srv_config = xs_dict_set(srv_config, "port", n);
174 }
175 }
176 }
177 else {
178 xs *n = xs_number_new(0);
179 srv_config = xs_dict_set(srv_config, "port", n);
180 }
181
182 printf("Host name: "); fflush(stdout);
183 {
184 xs *i = xs_strip_i(xs_readline(stdin));
185 if (*i == '\0')
186 return 1;
187
188 srv_config = xs_dict_set(srv_config, "host", i);
189 }
190
191 printf("URL prefix: "); fflush(stdout);
192 {
193 xs *i = xs_strip_i(xs_readline(stdin));
194
195 if (*i) {
196 if (xs_endswith(i, "/"))
197 i = xs_crop_i(i, 0, -1);
198
199 srv_config = xs_dict_set(srv_config, "prefix", i);
200 }
201 }
202
203 printf("Admin email address (optional): "); fflush(stdout);
204 {
205 xs *i = xs_strip_i(xs_readline(stdin));
206
207 srv_config = xs_dict_set(srv_config, "admin_email", i);
208 }
209
210 if (mkdirx(srv_basedir) == -1) {
211 printf("ERROR: cannot create directory '%s'\n", srv_basedir);
212 return 1;
213 }
214
215 xs *udir = xs_fmt("%s/user", srv_basedir);
216 mkdirx(udir);
217
218 xs *odir = xs_fmt("%s/object", srv_basedir);
219 mkdirx(odir);
220
221 xs *qdir = xs_fmt("%s/queue", srv_basedir);
222 mkdirx(qdir);
223
224 xs *ibdir = xs_fmt("%s/inbox", srv_basedir);
225 mkdirx(ibdir);
226
227 xs *gfn = xs_fmt("%s/greeting.html", srv_basedir);
228 if ((f = fopen(gfn, "w")) == NULL) {
229 printf("ERROR: cannot create '%s'\n", gfn);
230 return 1;
231 }
232
233 xs *gh = xs_replace(greeting_html, "%blurb%", snac_blurb);
234 fwrite(gh, strlen(gh), 1, f);
235 fclose(f);
236
237 if (write_default_css()) {
238 printf("ERROR: cannot create style.css\n");
239 return 1;
240 }
241
242 xs *cfn = xs_fmt("%s/server.json", srv_basedir);
243 if ((f = fopen(cfn, "w")) == NULL) {
244 printf("ERROR: cannot create '%s'\n", cfn);
245 return 1;
246 }
247
248 xs_json_dump(srv_config, 4, f);
249 fclose(f);
250
251 printf("Done.\n");
252 return 0;
253}
254
255
256void new_password(const char *uid, xs_str **clear_pwd, xs_str **hashed_pwd)
257/* creates a random password */
258{
259 int rndbuf[3];
260
261 xs_rnd_buf(rndbuf, sizeof(rndbuf));
262
263 *clear_pwd = xs_base64_enc((char *)rndbuf, sizeof(rndbuf));
264 *hashed_pwd = hash_password(uid, *clear_pwd, NULL);
265}
266
267
268int adduser(const char *uid)
269/* creates a new user */
270{
271 snac snac;
272 xs *config = xs_dict_new();
273 xs *date = xs_str_utctime(0, ISO_DATE_SPEC);
274 xs *pwd = NULL;
275 xs *pwd_f = NULL;
276 xs *key = NULL;
277 FILE *f;
278
279 if (uid == NULL) {
280 printf("Username: "); fflush(stdout);
281 uid = xs_strip_i(xs_readline(stdin));
282 }
283
284 if (!validate_uid(uid)) {
285 printf("ERROR: only alphanumeric characters and _ are allowed in user ids.\n");
286 return 1;
287 }
288
289 if (user_open(&snac, uid)) {
290 printf("ERROR: user '%s' already exists\n", snac.uid);
291 return 1;
292 }
293
294 new_password(uid, &pwd, &pwd_f);
295
296 config = xs_dict_append(config, "uid", uid);
297 config = xs_dict_append(config, "name", uid);
298 config = xs_dict_append(config, "avatar", "");
299 config = xs_dict_append(config, "bio", "");
300 config = xs_dict_append(config, "cw", "");
301 config = xs_dict_append(config, "published", date);
302 config = xs_dict_append(config, "passwd", pwd_f);
303
304 xs *basedir = xs_fmt("%s/user/%s", srv_basedir, uid);
305
306 if (mkdirx(basedir) == -1) {
307 printf("ERROR: cannot create directory '%s'\n", basedir);
308 return 0;
309 }
310
311 const char *dirs[] = {
312 "followers", "following", "muted", "hidden",
313 "public", "private", "queue", "history",
314 "static", NULL };
315 int n;
316
317 for (n = 0; dirs[n]; n++) {
318 xs *d = xs_fmt("%s/%s", basedir, dirs[n]);
319 mkdirx(d);
320 }
321
322 /* add a specially short data retention time for the relay */
323 if (strcmp(uid, "relay") == 0)
324 config = xs_dict_set(config, "purge_days", xs_stock(1));
325
326 xs *cfn = xs_fmt("%s/user.json", basedir);
327
328 if ((f = fopen(cfn, "w")) == NULL) {
329 printf("ERROR: cannot create '%s'\n", cfn);
330 return 1;
331 }
332 else {
333 xs_json_dump(config, 4, f);
334 fclose(f);
335 }
336
337 printf("\nCreating RSA key...\n");
338 key = xs_evp_genkey(2048);
339 printf("Done.\n");
340
341 xs *kfn = xs_fmt("%s/key.json", basedir);
342
343 if ((f = fopen(kfn, "w")) == NULL) {
344 printf("ERROR: cannot create '%s'\n", kfn);
345 return 1;
346 }
347 else {
348 xs_json_dump(key, 4, f);
349 fclose(f);
350 }
351
352 printf("\nUser password is %s\n", pwd);
353
354 printf("\nGo to %s/%s and continue configuring your user there.\n", srv_baseurl, uid);
355
356 return 0;
357}
358
359
360int resetpwd(snac *snac)
361/* creates a new password for the user */
362{
363 xs *clear_pwd = NULL;
364 xs *hashed_pwd = NULL;
365 xs *fn = xs_fmt("%s/user.json", snac->basedir);
366 FILE *f;
367 int ret = 0;
368
369 new_password(snac->uid, &clear_pwd, &hashed_pwd);
370
371 snac->config = xs_dict_set(snac->config, "passwd", hashed_pwd);
372
373 if ((f = fopen(fn, "w")) != NULL) {
374 xs_json_dump(snac->config, 4, f);
375 fclose(f);
376
377 printf("New password for user %s is %s\n", snac->uid, clear_pwd);
378 }
379 else {
380 printf("ERROR: cannot write to %s\n", fn);
381 ret = 1;
382 }
383
384 return ret;
385}
386
387
388void rm_rf(const char *dir)
389/* does an rm -rf (yes, I'm also scared) */
390{
391 xs *d = xs_str_cat(xs_dup(dir), "/" "*");
392 xs *l = xs_glob(d, 0, 0);
393 xs_list *p = l;
394 const xs_str *v;
395
396 if (dbglevel >= 1)
397 printf("Deleting directory %s\n", dir);
398
399 while (xs_list_iter(&p, &v)) {
400 struct stat st;
401
402 if (stat(v, &st) != -1) {
403 if (st.st_mode & S_IFDIR) {
404 rm_rf(v);
405 }
406 else {
407 if (dbglevel >= 1)
408 printf("Deleting file %s\n", v);
409
410 if (unlink(v) == -1)
411 printf("ERROR: cannot delete file %s\n", v);
412 }
413 }
414 else
415 printf("ERROR: stat() fail for %s\n", v);
416 }
417
418 if (rmdir(dir) == -1)
419 printf("ERROR: cannot delete directory %s\n", dir);
420}
421
422
423int deluser(snac *user)
424/* deletes a user */
425{
426 int ret = 0;
427 xs *fwers = following_list(user);
428 xs_list *p = fwers;
429 const xs_str *v;
430
431 while (xs_list_iter(&p, &v)) {
432 xs *object = NULL;
433
434 if (valid_status(following_get(user, v, &object))) {
435 xs *msg = msg_undo(user, xs_dict_get(object, "object"));
436
437 following_del(user, v);
438
439 enqueue_output_by_actor(user, msg, v, 0);
440
441 printf("Unfollowing actor %s\n", v);
442 }
443 }
444
445 rm_rf(user->basedir);
446
447 return ret;
448}
449
450
451void verify_links(snac *user)
452/* verifies a user's links */
453{
454 xs *metadata = NULL;
455 const xs_dict *md = xs_dict_get(user->config, "metadata");
456 const char *k, *v;
457 int changed = 0;
458
459 xs *headers = xs_dict_new();
460 headers = xs_dict_append(headers, "accept", "text/html");
461 headers = xs_dict_append(headers, "user-agent", USER_AGENT " (link verify)");
462
463 if (xs_type(md) == XSTYPE_DICT)
464 metadata = xs_dup(md);
465 else
466 if (xs_type(md) == XSTYPE_STRING) {
467 /* convert to dict for easier iteration */
468 metadata = xs_dict_new();
469 xs *l = xs_split(md, "\n");
470 const char *ll;
471
472 xs_list_foreach(l, ll) {
473 xs *kv = xs_split_n(ll, "=", 1);
474 const char *k = xs_list_get(kv, 0);
475 const char *v = xs_list_get(kv, 1);
476
477 if (k && v) {
478 xs *kk = xs_strip_i(xs_dup(k));
479 xs *vv = xs_strip_i(xs_dup(v));
480 metadata = xs_dict_set(metadata, kk, vv);
481 }
482 }
483 }
484
485 int c = 0;
486 while (metadata && xs_dict_next(metadata, &k, &v, &c)) {
487 /* not an https link? skip */
488 if (!xs_startswith(v, "https:/" "/"))
489 continue;
490
491 int status;
492 xs *req = NULL;
493 xs *payload = NULL;
494 int p_size = 0;
495
496 req = xs_http_request("GET", v, headers, NULL, 0, &status,
497 &payload, &p_size, 0);
498
499 if (!valid_status(status)) {
500 snac_log(user, xs_fmt("link %s verify error %d", v, status));
501 continue;
502 }
503
504 /* extract the links */
505 xs *ls = xs_regex_select(payload, "< *(a|link) +[^>]+>");
506
507 xs_list *lp = ls;
508 const char *ll;
509 int vfied = 0;
510
511 while (!vfied && xs_list_iter(&lp, &ll)) {
512 /* extract href and rel */
513 xs *r = xs_regex_select(ll, "(href|rel) *= *(\"[^\"]*\"|'[^']*')");
514
515 /* must have both attributes */
516 if (xs_list_len(r) != 2)
517 continue;
518
519 xs *href = NULL;
520 int is_rel_me = 0;
521 xs_list *pr = r;
522 const char *ar;
523
524 while (xs_list_iter(&pr, &ar)) {
525 xs *nq = xs_dup(ar);
526
527 nq = xs_replace_i(nq, "\"", "");
528 nq = xs_replace_i(nq, "'", "");
529
530 xs *r2 = xs_split_n(nq, "=", 1);
531 if (xs_list_len(r2) != 2)
532 continue;
533
534 xs *ak = xs_strip_i(xs_dup(xs_list_get(r2, 0)));
535 xs *av = xs_strip_i(xs_dup(xs_list_get(r2, 1)));
536
537 if (strcmp(ak, "href") == 0)
538 href = xs_dup(av);
539 else
540 if (strcmp(ak, "rel") == 0) {
541 /* split the value by spaces */
542 xs *vbs = xs_split(av, " ");
543
544 /* is any of it "me"? */
545 if (xs_list_in(vbs, "me") != -1)
546 is_rel_me = 1;
547 }
548 }
549
550 /* after all this acrobatics, do we have an href and a rel="me"? */
551 if (href != NULL && is_rel_me) {
552 /* is it the same as the actor? */
553 if (strcmp(href, user->actor) == 0) {
554 /* got it! */
555 xs *verified_time = xs_number_new((double)time(NULL));
556
557 if (user->links == NULL)
558 user->links = xs_dict_new();
559
560 user->links = xs_dict_set(user->links, v, verified_time);
561
562 vfied = 1;
563 }
564 else
565 snac_debug(user, 1,
566 xs_fmt("verify link %s rel='me' found but not related (%s)", v, href));
567 }
568 }
569
570 if (vfied) {
571 changed++;
572 snac_log(user, xs_fmt("link %s verified", v));
573 }
574 else {
575 snac_log(user, xs_fmt("link %s not verified (rel='me' not found)", v));
576 }
577 }
578
579 if (changed) {
580 FILE *f;
581
582 /* update the links.json file */
583 xs *fn = xs_fmt("%s/links.json", user->basedir);
584 xs *bfn = xs_fmt("%s.bak", fn);
585
586 rename(fn, bfn);
587
588 if ((f = fopen(fn, "w")) != NULL) {
589 xs_json_dump(user->links, 4, f);
590 fclose(f);
591 }
592 else
593 rename(bfn, fn);
594 }
595}
596
597
598void export_csv(snac *user)
599/* exports user data to current directory in a way that pleases Mastodon */
600{
601 FILE *f;
602 xs *fn = NULL;
603
604 fn = xs_fmt("%s/export/bookmarks.csv", user->basedir);
605 if ((f = fopen(fn, "w")) != NULL) {
606 snac_log(user, xs_fmt("Creating %s...", fn));
607
608 xs *l = bookmark_list(user);
609 const char *md5;
610
611 xs_list_foreach(l, md5) {
612 xs *post = NULL;
613
614 if (valid_status(object_get_by_md5(md5, &post))) {
615 const char *id = xs_dict_get(post, "id");
616
617 if (xs_type(id) == XSTYPE_STRING)
618 fprintf(f, "%s\n", id);
619 }
620 }
621
622 fclose(f);
623 }
624 else
625 snac_log(user, xs_fmt("Cannot create file %s", fn));
626
627 xs_free(fn);
628 fn = xs_fmt("%s/export/blocked_accounts.csv", user->basedir);
629 if ((f = fopen(fn, "w")) != NULL) {
630 snac_log(user, xs_fmt("Creating %s...", fn));
631
632 xs *l = muted_list(user);
633 const char *actor;
634
635 xs_list_foreach(l, actor) {
636 xs *uid = NULL;
637
638 webfinger_request_fake(actor, NULL, &uid);
639 fprintf(f, "%s\n", uid);
640 }
641
642 fclose(f);
643 }
644 else
645 snac_log(user, xs_fmt("Cannot create file %s", fn));
646
647 xs_free(fn);
648 fn = xs_fmt("%s/export/lists.csv", user->basedir);
649 if ((f = fopen(fn, "w")) != NULL) {
650 snac_log(user, xs_fmt("Creating %s...", fn));
651
652 xs *lol = list_maint(user, NULL, 0);
653 const xs_list *li;
654
655 xs_list_foreach(lol, li) {
656 const char *lid = xs_list_get(li, 0);
657 const char *ltitle = xs_list_get(li, 1);
658
659 xs *actors = list_content(user, lid, NULL, 0);
660 const char *md5;
661
662 xs_list_foreach(actors, md5) {
663 xs *actor = NULL;
664
665 if (valid_status(object_get_by_md5(md5, &actor))) {
666 const char *id = xs_dict_get(actor, "id");
667 xs *uid = NULL;
668
669 webfinger_request_fake(id, NULL, &uid);
670 fprintf(f, "%s,%s\n", ltitle, uid);
671 }
672 }
673 }
674
675 fclose(f);
676 }
677 else
678 snac_log(user, xs_fmt("Cannot create file %s", fn));
679
680 xs_free(fn);
681 fn = xs_fmt("%s/export/following_accounts.csv", user->basedir);
682 if ((f = fopen(fn, "w")) != NULL) {
683 snac_log(user, xs_fmt("Creating %s...", fn));
684
685 fprintf(f, "Account address,Show boosts,Notify on new posts,Languages\n");
686
687 xs *fwing = following_list(user);
688 const char *actor;
689
690 xs_list_foreach(fwing, actor) {
691 xs *uid = NULL;
692
693 webfinger_request_fake(actor, NULL, &uid);
694 fprintf(f, "%s,%s,false,\n", uid, limited(user, actor, 0) ? "false" : "true");
695 }
696
697 fclose(f);
698 }
699 else
700 snac_log(user, xs_fmt("Cannot create file %s", fn));
701}
702
703
704void import_blocked_accounts_csv(snac *user, const char *ifn)
705/* imports a Mastodon CSV file of blocked accounts */
706{
707 FILE *f;
708 xs *l = xs_split(ifn, "/");
709 xs *fn = xs_fmt("%s/import/%s", user->basedir, xs_list_get(l, -1));
710
711 if ((f = fopen(fn, "r")) != NULL) {
712 snac_log(user, xs_fmt("Importing from %s...", fn));
713
714 while (!feof(f)) {
715 xs *l = xs_strip_i(xs_readline(f));
716
717 if (*l && strchr(l, '@') != NULL) {
718 xs *url = NULL;
719 xs *uid = NULL;
720
721 if (valid_status(webfinger_request(l, &url, &uid))) {
722 if (is_muted(user, url))
723 snac_log(user, xs_fmt("Actor %s already MUTEd", url));
724 else {
725 mute(user, url);
726 snac_log(user, xs_fmt("MUTEd actor %s", url));
727 }
728 }
729 else
730 snac_log(user, xs_fmt("Webfinger error for account %s", l));
731 }
732 }
733
734 fclose(f);
735 }
736 else
737 snac_log(user, xs_fmt("Cannot open file %s", fn));
738}
739
740
741void import_following_accounts_csv(snac *user, const char *ifn)
742/* imports a Mastodon CSV file of accounts to follow */
743{
744 FILE *f;
745 xs *l = xs_split(ifn, "/");
746 xs *fn = xs_fmt("%s/import/%s", user->basedir, xs_list_get(l, -1));
747
748 if ((f = fopen(fn, "r")) != NULL) {
749 snac_log(user, xs_fmt("Importing from %s...", fn));
750
751 while (!feof(f)) {
752 xs *l = xs_strip_i(xs_readline(f));
753
754 if (*l) {
755 xs *l2 = xs_split(l, ",");
756 const char *acct = xs_list_get(l2, 0);
757 const char *show = xs_list_get(l2, 1);
758
759 if (acct) {
760 /* not a valid account? skip (probably the CSV header) */
761 if (strchr(acct, '@') == NULL)
762 continue;
763
764 xs *msg = msg_follow(user, acct);
765
766 if (msg == NULL) {
767 snac_log(user, xs_fmt("Cannot follow %s -- server down?", acct));
768 continue;
769 }
770
771 const char *actor = xs_dict_get(msg, "object");
772
773 if (following_check(user, actor))
774 snac_log(user, xs_fmt("Actor %s already followed", actor));
775 else {
776 following_add(user, actor, msg);
777
778 enqueue_output_by_actor(user, msg, actor, 0);
779
780 snac_log(user, xs_fmt("Following %s", actor));
781 }
782
783 if (show && strcmp(show, "false") == 0) {
784 limit(user, actor);
785 snac_log(user, xs_fmt("Limiting boosts from actor %s", actor));
786 }
787 else {
788 unlimit(user, actor);
789 snac_log(user, xs_fmt("Unlimiting boosts from actor %s", actor));
790 }
791 }
792 }
793 }
794
795 fclose(f);
796 }
797 else
798 snac_log(user, xs_fmt("Cannot open file %s", fn));
799}
800
801
802void import_list_csv(snac *user, const char *ifn)
803/* imports a Mastodon CSV file list */
804{
805 FILE *f;
806 xs *l = xs_split(ifn, "/");
807 xs *fn = xs_fmt("%s/import/%s", user->basedir, xs_list_get(l, -1));
808
809 if ((f = fopen(fn, "r")) != NULL) {
810 snac_log(user, xs_fmt("Importing from %s...", fn));
811
812 while (!feof(f)) {
813 xs *l = xs_strip_i(xs_readline(f));
814
815 if (*l) {
816 xs *l2 = xs_split(l, ",");
817 const char *lname = xs_list_get(l2, 0);
818 const char *acct = xs_list_get(l2, 1);
819
820 if (lname && acct) {
821 /* create the list */
822 xs *list_id = list_maint(user, lname, 1);
823
824 xs *url = NULL;
825 xs *uid = NULL;
826
827 if (valid_status(webfinger_request(acct, &url, &uid))) {
828 xs *actor_md5 = xs_md5_hex(url, strlen(url));
829
830 list_content(user, list_id, actor_md5, 1);
831 snac_log(user, xs_fmt("Added %s to list %s", url, lname));
832
833 if (!following_check(user, url)) {
834 xs *msg = msg_follow(user, url);
835
836 if (msg == NULL) {
837 snac_log(user, xs_fmt("Cannot follow %s -- server down?", acct));
838 continue;
839 }
840
841 following_add(user, url, msg);
842
843 enqueue_output_by_actor(user, msg, url, 0);
844
845 snac_log(user, xs_fmt("Following %s", url));
846 }
847 }
848 else
849 snac_log(user, xs_fmt("Webfinger error while adding %s to list %s", acct, lname));
850 }
851 }
852 }
853
854 fclose(f);
855 }
856 else
857 snac_log(user, xs_fmt("Cannot open file %s", fn));
858}
859
860
861void import_csv(snac *user)
862/* import CSV files from Mastodon */
863{
864 FILE *f;
865
866 import_blocked_accounts_csv(user, "blocked_accounts.csv");
867
868 import_following_accounts_csv(user, "following_accounts.csv");
869
870 import_list_csv(user, "lists.csv");
871
872 xs *fn = xs_fmt("%s/import/bookmarks.csv", user->basedir);
873 if ((f = fopen(fn, "r")) != NULL) {
874 snac_log(user, xs_fmt("Importing from %s...", fn));
875
876 while (!feof(f)) {
877 xs *l = xs_strip_i(xs_readline(f));
878
879 if (*l) {
880 xs *post = NULL;
881
882 if (!object_get(l, &post)) {
883 if (!valid_status(activitypub_request(user, l, &post))) {
884 snac_log(user, xs_fmt("Error getting object %s for bookmarking", l));
885 continue;
886 }
887 }
888
889 if (post == NULL)
890 continue;
891
892 /* request the actor that created the post */
893 const char *actor = get_atto(post);
894
895 if (xs_type(actor) == XSTYPE_STRING)
896 actor_request(user, actor, NULL);
897
898 object_add_ow(l, post);
899 timeline_add(user, l, post);
900
901 bookmark(user, l);
902
903 snac_log(user, xs_fmt("Bookmarked %s", l));
904 }
905 }
906
907 fclose(f);
908 }
909 else
910 snac_log(user, xs_fmt("Cannot open file %s", fn));
911}
