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