snac2

data.c (109290B)

---

 /* snac - A simple, minimalistic ActivityPub instance */
 /* copyright (c) 2022 - 2025 grunfink et al. / MIT license */
 
 #include "xs.h"
 #include "xs_hex.h"
 #include "xs_io.h"
 #include "xs_json.h"
 #include "xs_openssl.h"
 #include "xs_glob.h"
 #include "xs_set.h"
 #include "xs_time.h"
 #include "xs_regex.h"
 #include "xs_match.h"
 #include "xs_unicode.h"
 #include "xs_random.h"
 #include "xs_po.h"
 
 #include "snac.h"
 
 #include <time.h>
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <sys/time.h>
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <dirent.h>
 
 double disk_layout = 2.7;
 
 /* storage serializer */
 pthread_mutex_t data_mutex = {0};
 
 int snac_upgrade(xs_str **error);
 
 #define md5_fn(input, suffix) _md5_fn((char[MD5_HEX_SIZE + sizeof(suffix) - 1]){ 0 }, input, "" suffix)
 
 const char *_md5_fn(char *buffer, const char *input, const char *suffix)
 {
     _xs_md5_buf(buffer, input, NULL);
     strcpy(buffer + MD5_HEX_SIZE - 1, suffix);
     return buffer;
 }
 
 int srv_open(const char *basedir, int auto_upgrade)
 /* opens a server */
 {
     int ret = 0;
     xs *cfg_file = NULL;
     FILE *f;
     xs_str *error = NULL;
 
     pthread_mutex_init(&data_mutex, NULL);
 
     srv_basedir = xs_str_new(basedir);
 
     if (xs_endswith(srv_basedir, "/"))
         srv_basedir = xs_crop_i(srv_basedir, 0, -1);
 
     cfg_file = xs_fmt("%s/server.json", basedir);
 
     if ((f = fopen(cfg_file, "r")) == NULL)
         error = xs_fmt("ERROR: cannot open '%s'", cfg_file);
     else {
         /* read full config file */
         srv_config = xs_json_load(f);
         fclose(f);
 
         /* parse */
 
         if (srv_config == NULL)
             error = xs_fmt("ERROR: cannot parse '%s'", cfg_file);
         else {
             const char *host;
             const char *prefix;
             const char *dbglvl;
             const char *proto;
 
             host   = xs_dict_get(srv_config, "host");
             prefix = xs_dict_get(srv_config, "prefix");
             dbglvl = xs_dict_get(srv_config, "dbglevel");
             proto  = xs_dict_get_def(srv_config, "protocol", "https");
 
             if (host == NULL || prefix == NULL)
                 error = xs_str_new("ERROR: cannot get server data");
             else {
                 srv_baseurl = xs_fmt("%s:/" "/%s%s", proto, host, prefix);
 
                 dbglevel = (int) xs_number_get(dbglvl);
 
                 if ((dbglvl = getenv("DEBUG")) != NULL) {
                     dbglevel = atoi(dbglvl);
                     error = xs_fmt("DEBUG level set to %d from environment", dbglevel);
                 }
 
                 if (auto_upgrade)
                     ret = snac_upgrade(&error);
                 else {
                     if (xs_number_get(xs_dict_get(srv_config, "layout")) < disk_layout)
                         error = xs_fmt("ERROR: disk layout changed - execute 'snac upgrade' first");
                     else
                         ret = 1;
                 }
             }
 
         }
     }
 
     if (error != NULL)
         srv_log(error);
 
     if (!ret)
         return ret;
 
     /* create the queue/ subdir, just in case */
     xs *qdir = xs_fmt("%s/queue", srv_basedir);
     mkdirx(qdir);
 
     xs *ibdir = xs_fmt("%s/inbox", srv_basedir);
     mkdirx(ibdir);
 
     xs *tmpdir = xs_fmt("%s/tmp", srv_basedir);
     mkdirx(tmpdir);
 
 #ifdef __APPLE__
 /* Apple uses st_atimespec instead of st_atim etc */
 #define st_atim st_atimespec
 #define st_ctim st_ctimespec
 #define st_mtim st_mtimespec
 #endif
 
     sbox_enter(srv_basedir);
 
     /* read (and drop) emojis.json, possibly creating it */
     xs_free(emojis());
 
     /* if style.css does not exist, create it */
     xs *css_fn = xs_fmt("%s/style.css", srv_basedir);
 
     if (mtime(css_fn) == 0) {
         srv_log(xs_fmt("Writing style.css"));
         write_default_css();
     }
 
     /* create the proxy token seed */
     {
         char rnd[16];
         xs_rnd_buf(rnd, sizeof(rnd));
 
         srv_proxy_token_seed = xs_hex_enc(rnd, sizeof(rnd));
     }
 
     /* ensure user directories include important subdirectories */
     xs *users = user_list();
     const char *uid;
 
     xs_list_foreach(users, uid) {
         xs *impdir = xs_fmt("%s/user/%s/import", srv_basedir, uid);
         xs *expdir = xs_fmt("%s/user/%s/export", srv_basedir, uid);
 
         mkdirx(impdir);
         mkdirx(expdir);
     }
 
     /* languages */
     srv_langs = xs_dict_new();
     srv_langs = xs_dict_set(srv_langs, "en", xs_stock(XSTYPE_NULL));
 
     xs *l_dir = xs_fmt("%s/lang/", srv_basedir);
     mkdirx(l_dir);
 
     l_dir = xs_str_cat(l_dir, "*.po");
     xs *pos = xs_glob(l_dir, 0, 0);
     const char *po;
 
     xs_list_foreach(pos, po) {
         xs *d = xs_po_to_dict(po);
 
         if (xs_is_dict(d)) {
             xs *l = xs_split(po, "/");
             xs *id = xs_dup(xs_list_get(l, -1));
             id = xs_replace_i(id, ".po", "");
 
             srv_langs = xs_dict_set(srv_langs, id, d);
         }
     }
 
     return ret;
 }
 
 
 void srv_free(void)
 {
     xs_free(srv_basedir);
     xs_free(srv_config);
     xs_free(srv_baseurl);
     xs_free(srv_langs);
     xs_free(srv_proxy_token_seed);
 
     pthread_mutex_destroy(&data_mutex);
 }
 
 
 void user_free(snac *snac)
 /* frees a user snac */
 {
     xs_free(snac->uid);
     xs_free(snac->basedir);
     xs_free(snac->config);
     xs_free(snac->config_o);
     xs_free(snac->key);
     xs_free(snac->links);
     xs_free(snac->actor);
     xs_free(snac->md5);
     close(snac->basedfd);
 }
 
 FILE *user_open_file(snac *user, const char *file, int wr)
 {
     int fd = openat(user->basedfd, file, wr ? O_RDWR | O_CREAT : O_RDONLY, 0660);
     if (fd < 0)
         return NULL;
     FILE *rv = fdopen(fd, wr ? "r+" : "r");
     if (rv)
         return rv;
 
     close(fd);
     return NULL;
 }
 
 int user_link_subfile(snac *user, const char *sub, const char *file, int todfd, const char *to)
 {
     int subfd;
     int ret;
 
     if (mkdiratx(user->basedfd, sub) || (subfd = openat(user->basedfd, sub, O_RDONLY | O_DIRECTORY)) < 0)
         return - 1;
 
     ret = linkat(todfd, to, subfd, file, 0);
     close(subfd);
 
     return ret;
 }
 
 int user_unlink_subfile(snac *user, const char *sub, const char *file)
 {
     int subfd;
     int ret;
 
     if ((subfd = openat(user->basedfd, sub, O_RDONLY | O_DIRECTORY)) < 0)
         return -1;
 
     ret = unlinkat(subfd, file, 0);
     close(subfd);
 
     return ret;
 }
 
 FILE *user_open_subfile(snac *user, const char *sub, const char *file, int wr)
 {
     int subfd;
     int fd;
 
     if (mkdiratx(user->basedfd, sub) || (subfd = openat(user->basedfd, sub, O_RDONLY | O_DIRECTORY)) < 0)
         return NULL;
 
     fd = openat(subfd, file, wr ? O_RDWR | O_CREAT : O_RDONLY, 0660);
     close(subfd);
     if (fd < 0)
         return NULL;
     FILE *rv = fdopen(fd, wr ? "r+" : "r");
     if (rv)
         return rv;
 
     close(fd);
     return NULL;
 }
 
 xs_val *user_parse_json(snac *user, const char *fn, xs_val *(*deflt)(void))
 {
     xs_val *rv;
     FILE *f;
     FILE *bf;
 
     struct stat cached;
     struct stat current;
 
     if ((f = user_open_file(user, fn, 0)) == NULL) {
         if (!deflt) {
             srv_debug(2, xs_fmt("error opening '%s/%s' %d", user->basedir, fn, errno));
             return NULL;
         }
         else {
             return deflt();
         }
     }
 
     if ((bf = user_open_subfile(user, "cache", fn, 0))) {
         if (fstat(fileno(bf), &cached) == 0 &&
             fstat(fileno(f), &current) == 0 &&
             cached.st_ctime > current.st_ctime) {
             rv = xs_realloc(NULL, cached.st_size);
             if (fread(rv, cached.st_size, 1, bf) == 1) {
                 fclose(bf);
                 fclose(f);
                 return rv;
             }
         }
         fclose(bf);
     }
 
     rv = xs_json_load(f);
     fclose(f);
 
     if (!rv) {
         srv_log(xs_fmt("error parsing '%s/%s'", user->basedir, fn));
         if (deflt)
             rv = deflt();
     }
 
     if ((bf = user_open_subfile(user, "cache", fn, 1))) {
         flock(fileno(bf), LOCK_EX);
         ftruncate(fileno(bf), 0);
         fwrite(rv, 1, xs_size(rv), bf);
         fclose(bf);
     }
 
     return rv;
 }
 
 int user_open(snac *user, const char *uid)
 /* opens a user */
 {
     int ret = 0;
 
     *user = (snac){0};
 
     if (validate_uid(uid)) {
         FILE *f;
 
         xs *t = xs_fmt("%s/user/%s", srv_basedir, uid);
 
         if (mtime(t) == 0.0) {
             /* user folder does not exist; try with a different case */
             xs *lcuid = xs_tolower_i(xs_dup(uid));
             xs *ulist = user_list();
             xs_list *p = ulist;
             const xs_str *v;
 
             while (xs_list_iter(&p, &v)) {
                 xs *v2 = xs_tolower_i(xs_dup(v));
 
                 if (strcmp(lcuid, v2) == 0) {
                     user->uid = xs_dup(v);
                     break;
                 }
             }
         }
         else
             user->uid = xs_str_new(uid);
 
         if (user->uid == NULL)
             return ret;
 
         user->basedir = xs_fmt("%s/user/%s", srv_basedir, user->uid);
         user->basedfd = open(user->basedir, O_DIRECTORY);
 
         do {
             /* read full config file */
             if ((user->config = user_parse_json(user, "user.json", NULL)) == NULL)
                 break;
 
             if ((user->key = user_parse_json(user, "key.json", NULL)) == NULL)
                 break;
 
             user->actor = xs_fmt("%s/%s", srv_baseurl, user->uid);
             user->md5   = xs_md5_hex(user->actor, strlen(user->actor));
 
             /* everything is ok right now */
             ret = 1;
 
             /* does it have a configuration override? */
             user->config_o = user_parse_json(user, "user_o.json", xs_dict_new);
 
             user->tz = xs_dict_get_def(user->config, "tz", "UTC");
         } while (0);
 
         /* verified links */
         if ((f = user_open_file(user, "links.json", 0)) != NULL) {
             user->links = xs_json_load(f);
             fclose(f);
         }
     }
     else
         srv_debug(1, xs_fmt("invalid user '%s'", uid));
 
     if (!ret)
         user_free(user);
 
     return ret;
 }
 
 struct user_iter {
     DIR *d;
     struct dirent de;
 };
 
 void user_iter(struct user_iter *i)
 {
     xs *d = xs_fmt("%s/user", srv_basedir);
     i->d = opendir(d);
 }
 
 const char *user_iter_next(struct user_iter *i)
 {
     struct dirent *d;
     do {
         if (readdir_r(i->d, &i->de, &d) != 0)
             return NULL;
     } while (d && (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")));
 
     if (d)
         return d->d_name;
     return NULL;
 }
 
 void user_iter_close(struct user_iter *i)
 {
     closedir(i->d);
 }
 
 xs_list *user_list(void)
 /* returns the list of user ids */
 {
     xs *spec = xs_fmt("%s/user/" "*", srv_basedir);
     return xs_glob(spec, 1, 0);
 }
 
 int user_open_by_md5(snac *snac, const char *md5)
 /* iterates all users searching by md5 */
 {
     __attribute__ ((__cleanup__(user_iter_close))) struct user_iter i = { NULL };
     const char *v;
     user_iter(&i);
     while ((v = user_iter_next(&i))) {
         user_open(snac, v);
 
         if (strcmp(snac->md5, md5) == 0)
             return 1;
 
         user_free(snac);
     }
 
     return 0;
 }
 
 int object_del_by_md5(const char *md5);
 int user_persist(snac *user, int publish)
 /* store user */
 {
     FILE *f;
 
     if (publish) {
         /* check if any of the relevant fields have really changed */
         if ((f = user_open_file(user, "user.json", 0)) != NULL) {
             xs *old = xs_json_load(f);
             fclose(f);
 
             if (old != NULL) {
                 int nw = 0;
                 const char *fields[] = { "header", "avatar", "name", "bio",
                                          "metadata", "latitude", "longitude", NULL };
 
                 for (int n = 0; fields[n]; n++) {
                     const char *of = xs_dict_get(old, fields[n]);
                     const char *nf = xs_dict_get(user->config, fields[n]);
 
                     if (of == NULL && nf == NULL)
                         continue;
 
                     if (xs_type(of) != XSTYPE_STRING || xs_type(nf) != XSTYPE_STRING || strcmp(of, nf)) {
                         nw = 1;
                         break;
                     }
                 }
 
                 if (!nw)
                     publish = 0;
                 else {
                     /* uncache the actor object */
                     object_del_by_md5(user->md5);
                 }
             }
         }
     }
 
     renameat(user->basedfd, "user.json", user->basedfd, "user.json.bak");
 
     if ((f = user_open_file(user, "user.json", 1)) != NULL) {
         xs_json_dump(user->config, 4, f);
         fclose(f);
     }
     else
         renameat(user->basedfd, "user.json.bak", user->basedfd, "user.json");
 
     history_del(user, "timeline.html_");
     timeline_touch(user);
 
     if (publish) {
         xs *a_msg = msg_actor(user);
         xs *u_msg = msg_update(user, a_msg);
 
         enqueue_message(user, u_msg);
 
         enqueue_verify_links(user);
     }
 
     return 0;
 }
 
 
 double mtime_f_nl(FILE *f, int *n_link)
 /* returns the mtime and number of links of a file or directory, or 0.0 */
 {
     struct stat st;
     double r = 0.0;
     int n = 0;
 
     if (f && fstat(fileno(f), &st) != -1) {
         r = (double) st.st_mtim.tv_sec;
         n = st.st_nlink;
     }
 
     if (n_link)
         *n_link = n;
 
     return r;
 }
 
 double mtime_nl(const char *fn, int *n_link)
 /* returns the mtime and number of links of a file or directory, or 0.0 */
 {
     struct stat st;
     double r = 0.0;
     int n = 0;
 
     if (fn && stat(fn, &st) != -1) {
         r = (double) st.st_mtim.tv_sec;
         n = st.st_nlink;
     }
 
     if (n_link)
         *n_link = n;
 
     return r;
 }
 
 
 #define MIN(v1, v2) ((v1) < (v2) ? (v1) : (v2))
 
 double f_ctime(const char *fn)
 /* returns the ctime of a file or directory, or 0.0 */
 {
     struct stat st;
     double r = 0.0;
 
     if (fn && stat(fn, &st) != -1) {
         /* return the lowest of ctime and mtime;
            there are operations that change the ctime, like link() */
         r = (double) MIN(st.st_ctim.tv_sec, st.st_mtim.tv_sec);
     }
 
     return r;
 }
 
 
 int is_md5_hex(const char *md5)
 {
     return xs_is_hex(md5) && strlen(md5) == MD5_HEX_SIZE - 1;
 }
 
 
 /** database 2.1+ **/
 
 /** indexes **/
 
 
 int index_add_md5(const char *fn, const char *md5)
 /* adds an md5 to an index */
 {
     int status = HTTP_STATUS_CREATED;
     FILE *f;
 
     if (!is_md5_hex(md5)) {
         srv_log(xs_fmt("index_add_md5: bad md5 %s %s", fn, md5));
         return HTTP_STATUS_BAD_REQUEST;
     }
 
     pthread_mutex_lock(&data_mutex);
 
     if ((f = fopen(fn, "a")) != NULL) {
         flock(fileno(f), LOCK_EX);
 
         /* ensure the position is at the end after getting the lock */
         fseek(f, 0, SEEK_END);
 
         fprintf(f, "%s\n", md5);
         fclose(f);
     }
     else
         status = HTTP_STATUS_INTERNAL_SERVER_ERROR;
 
     pthread_mutex_unlock(&data_mutex);
 
     return status;
 }
 
 
 int index_add(const char *fn, const char *id)
 /* adds an id to an index */
 {
     const char *md5 = xs_md5(id);
     return index_add_md5(fn, md5);
 }
 
 
 int index_del_md5(const char *fn, const char *md5)
 /* deletes an md5 from an index */
 {
     int status = HTTP_STATUS_NOT_FOUND;
     FILE *f;
 
     pthread_mutex_lock(&data_mutex);
 
     if ((f = fopen(fn, "r+")) != NULL) {
         char line[256];
 
         while (fgets(line, sizeof(line), f) != NULL) {
             line[MD5_HEX_SIZE - 1] = '\0';
 
             if (strcmp(line, md5) == 0) {
                 /* found! just rewind, overwrite it with garbage
                    and an eventual call to index_gc() will clean it
                    [yes: this breaks index_len()] */
                 fseek(f, -MD5_HEX_SIZE, SEEK_CUR);
                 fwrite("-", 1, 1, f);
                 status = HTTP_STATUS_OK;
 
                 break;
             }
         }
 
         fclose(f);
     }
     else
         status = HTTP_STATUS_GONE;
 
     pthread_mutex_unlock(&data_mutex);
 
     return status;
 }
 
 
 int index_del(const char *fn, const char *id)
 /* deletes an id from an index */
 {
     const char *md5 = xs_md5(id);
     return index_del_md5(fn, md5);
 }
 
 
 int index_gc(const char *fn)
 /* garbage-collects an index, deleting objects that are not here */
 {
     FILE *i, *o;
     int gc = -1;
 
     pthread_mutex_lock(&data_mutex);
 
     if ((i = fopen(fn, "r")) != NULL) {
         xs *nfn = xs_fmt("%s.new", fn);
         char line[256];
 
         if ((o = fopen(nfn, "w")) != NULL) {
             gc = 0;
 
             while (fgets(line, sizeof(line), i) != NULL) {
                 line[MD5_HEX_SIZE - 1] = '\0';
 
                 if (line[0] != '-' && object_here_by_md5(line))
                     fprintf(o, "%s\n", line);
                 else
                     gc++;
             }
 
             fclose(o);
 
             xs *ofn = xs_fmt("%s.bak", fn);
 
             unlink(ofn);
             if (link(fn, ofn) == -1 || rename(nfn, fn) == -1) {
                 fprintf(stderr, "Updating link during garbage collection failed: %s.\n", strerror(errno));
             }
         }
 
         fclose(i);
     }
 
     pthread_mutex_unlock(&data_mutex);
 
     return gc;
 }
 
 
 int index_in_md5(const char *fn, const char *md5)
 /* checks if the md5 is already in the index */
 {
     FILE *f;
     int ret = 0;
 
     if ((f = fopen(fn, "r")) != NULL) {
         flock(fileno(f), LOCK_SH);
 
         char line[256];
 
         while (!ret && fgets(line, sizeof(line), f) != NULL) {
             line[MD5_HEX_SIZE - 1] = '\0';
 
             if (strcmp(line, md5) == 0)
                 ret = 1;
         }
 
         fclose(f);
     }
 
     return ret;
 }
 
 
 int index_in(const char *fn, const char *id)
 /* checks if the object id is already in the index */
 {
     const char *md5 = xs_md5(id);
     return index_in_md5(fn, md5);
 }
 
 
 int index_first(const char *fn, char md5[MD5_HEX_SIZE])
 /* reads the first entry of an index */
 {
     FILE *f;
     int ret = 0;
 
     if ((f = fopen(fn, "r")) != NULL) {
         if (fread(md5, MD5_HEX_SIZE, 1, f)) {
             md5[MD5_HEX_SIZE - 1] = '\0';
             ret = 1;
         }
 
         fclose(f);
     }
 
     return ret;
 }
 
 
 int index_len(const char *fn)
 /* returns the number of elements in an index */
 {
     struct stat st;
     int len = 0;
 
     if (stat(fn, &st) != -1)
         len = st.st_size / MD5_HEX_SIZE;
 
     return len;
 }
 
 
 xs_list *index_list(const char *fn, int max)
 /* returns an index as a list */
 {
     xs_list *list = xs_list_new();
     FILE *f;
     int n = 0;
 
     if ((f = fopen(fn, "r")) != NULL) {
         flock(fileno(f), LOCK_SH);
 
         char line[256];
 
         while (n < max && fgets(line, sizeof(line), f) != NULL) {
             if (line[0] != '-') {
                 line[MD5_HEX_SIZE - 1] = '\0';
                 list = xs_list_append(list, line);
                 n++;
             }
         }
 
         fclose(f);
     }
 
     return list;
 }
 
 
 int index_desc_next(FILE *f, char md5[MD5_HEX_SIZE])
 /* reads the next entry of a desc index */
 {
     for (;;) {
         /* move backwards 2 entries */
         if (fseek(f, MD5_HEX_SIZE * -2, SEEK_CUR) == -1)
             return 0;
 
         /* read and md5 */
         if (!fread(md5, MD5_HEX_SIZE, 1, f))
             return 0;
 
         if (md5[0] != '-')
             break;
     }
 
     md5[MD5_HEX_SIZE - 1] = '\0';
 
     return 1;
 }
 
 
 int index_desc_first(FILE *f, char md5[MD5_HEX_SIZE], int skip)
 /* reads the first entry of a desc index */
 {
     /* try to position at the end and then back to the first element */
     if (fseek(f, 0, SEEK_END) || fseek(f, (skip + 1) * -MD5_HEX_SIZE, SEEK_CUR))
         return 0;
 
     /* try to read an md5 */
     if (!fread(md5, MD5_HEX_SIZE, 1, f))
         return 0;
 
     /* null-terminate */
     md5[MD5_HEX_SIZE - 1] = '\0';
 
     /* deleted? retry next */
     if (md5[0] == '-')
         return index_desc_next(f, md5);
 
     return 1;
 }
 
 int index_asc_first(FILE *f,char md5[MD5_HEX_SIZE], const char *seek_md5)
 /* reads the first entry of an ascending index, starting from a given md5 */
 {
     fseek(f, SEEK_SET, 0);
     while (fread(md5, MD5_HEX_SIZE, 1, f)) {
         md5[MD5_HEX_SIZE - 1] = '\0';
         if (strcmp(md5,seek_md5) == 0) {
             return index_asc_next(f, md5);
         }
     }
     return 0;
 }
 
 int index_asc_next(FILE *f, char md5[MD5_HEX_SIZE])
 /* reads the next entry of an ascending index */
 {
     for (;;) {
         /* read an md5 */
         if (!fread(md5, MD5_HEX_SIZE, 1, f))
             return 0;
 
         /* deleted, skip */
         if (md5[0] != '-')
             break;
     }
 
     md5[MD5_HEX_SIZE - 1] = '\0';
 
     return 1;
 }
 
 
 xs_list *index_list_desc(const char *fn, int skip, int show)
 /* returns an index as a list, in reverse order */
 {
     xs_list *list = xs_list_new();
     FILE *f;
 
     if ((f = fopen(fn, "r")) != NULL) {
         char md5[MD5_HEX_SIZE];
 
         if (index_desc_first(f, md5, skip)) {
             int n = 1;
 
             do {
                 list = xs_list_append(list, md5);
             } while (n++ < show && index_desc_next(f, md5));
         }
 
         fclose(f);
     }
 
     return list;
 }
 
 
 /** objects **/
 
 static xs_str *_object_fn_by_md5(const char *md5, const char *func)
 {
     xs *bfn = xs_fmt("%s/object/%c%c", srv_basedir, md5[0], md5[1]);
     xs_str *ret;
     int ok = 1;
 
     /* an object deleted from an index; fail but don't bark */
     if (md5[0] == '-')
         ok = 0;
     else
     if (!is_md5_hex(md5)) {
         srv_log(xs_fmt("_object_fn_by_md5() [from %s()]: bad md5 '%s'", func, md5));
         ok = 0;
     }
 
     if (ok) {
         mkdirx(bfn);
         ret = xs_fmt("%s/%s.json", bfn, md5);
     }
     else
         ret = xs_fmt("%s/object/invalid/invalid.json", srv_basedir);
 
     return ret;
 }
 
 
 static xs_str *_object_fn(const char *id)
 {
     const char *md5 = xs_md5(id);
     return _object_fn_by_md5(md5, "_object_fn");
 }
 
 
 int object_here_by_md5(const char *id)
 /* checks if an object is already downloaded */
 {
     xs *fn = _object_fn_by_md5(id, "object_here_by_md5");
     return mtime(fn) > 0.0;
 }
 
 
 int object_here(const char *id)
 /* checks if an object is already downloaded */
 {
     xs *fn = _object_fn(id);
     return mtime(fn) > 0.0;
 }
 
 
 int object_get_by_md5(const char *md5, xs_dict **obj)
 /* returns a stored object, optionally of the requested type */
 {
     int status = HTTP_STATUS_NOT_FOUND;
     xs *fn     = _object_fn_by_md5(md5, "object_get_by_md5");
     FILE *f;
 
     if ((f = fopen(fn, "r")) != NULL) {
         *obj = xs_json_load(f);
         fclose(f);
 
         if (*obj)
             status = HTTP_STATUS_OK;
     }
     else
         *obj = NULL;
 
     return status;
 }
 
 
 int object_get(const char *id, xs_dict **obj)
 /* returns a stored object, optionally of the requested type */
 {
     const char *md5 = xs_md5(id);
     return object_get_by_md5(md5, obj);
 }
 
 
 int _object_add(const char *id, const xs_dict *obj, int ow)
 /* stores an object */
 {
     int status = HTTP_STATUS_CREATED; /* Created */
     xs *fn     = _object_fn(id);
     FILE *f;
 
     if (mtime(fn) > 0.0) {
         if (!ow) {
             /* object already here */
             srv_debug(1, xs_fmt("object_add object already here %s", id));
             return HTTP_STATUS_NO_CONTENT;
         }
         else
             status = HTTP_STATUS_OK;
     }
 
     if ((f = fopen(fn, "w")) != NULL) {
         flock(fileno(f), LOCK_EX);
 
         xs_json_dump(obj, 4, f);
         fclose(f);
 
         /* does this object has a parent? */
         const char *in_reply_to = get_in_reply_to(obj);
 
         if (!xs_is_null(in_reply_to) && *in_reply_to) {
             /* update the children index of the parent */
             xs *c_idx = _object_fn(in_reply_to);
 
             c_idx = xs_replace_i(c_idx, ".json", "_c.idx");
 
             if (!index_in(c_idx, id)) {
                 index_add(c_idx, id);
                 srv_debug(1, xs_fmt("object_add added child %s to %s", id, c_idx));
             }
             else
                 srv_debug(1, xs_fmt("object_add %s child already in %s", id, c_idx));
 
             /* create a one-element index with the parent */
             xs *p_idx = xs_replace(fn, ".json", "_p.idx");
 
             if (mtime(p_idx) == 0.0) {
                 index_add(p_idx, in_reply_to);
                 srv_debug(1, xs_fmt("object_add added parent %s to %s", in_reply_to, p_idx));
             }
         }
     }
     else {
         srv_log(xs_fmt("object_add error writing %s (errno: %d)", fn, errno));
         status = HTTP_STATUS_INTERNAL_SERVER_ERROR;
     }
 
     srv_debug(1, xs_fmt("object_add %s %s %d", id, fn, status));
 
     return status;
 }
 
 
 int object_add(const char *id, const xs_dict *obj)
 /* stores an object */
 {
     return _object_add(id, obj, 0);
 }
 
 
 int object_add_ow(const char *id, const xs_dict *obj)
 /* stores an object (overwriting allowed) */
 {
     return _object_add(id, obj, 1);
 }
 
 
 int object_del_by_md5(const char *md5)
 /* deletes an object by its md5 */
 {
     int status = HTTP_STATUS_NOT_FOUND;
     xs *fn     = _object_fn_by_md5(md5, "object_del_by_md5");
 
     if (unlink(fn) != -1) {
         status = HTTP_STATUS_OK;
 
         /* also delete associated indexes */
         xs *spec  = xs_dup(fn);
         spec      = xs_replace_i(spec, ".json", "*.idx");
         xs *files = xs_glob(spec, 0, 0);
         char *p;
         const char *v;
 
         p = files;
         while (xs_list_iter(&p, &v)) {
             srv_debug(1, xs_fmt("object_del index %s", v));
             unlink(v);
         }
     }
 
     srv_debug(1, xs_fmt("object_del %s %d", fn, status));
 
     return status;
 }
 
 
 int object_del(const char *id)
 /* deletes an object */
 {
     const char *md5 = xs_md5(id);
     return object_del_by_md5(md5);
 }
 
 
 int object_del_if_unref(const char *id)
 /* deletes an object if its n_links < 2 */
 {
     xs *fn = _object_fn(id);
     int n_links;
     int ret = 0;
 
     if (mtime_nl(fn, &n_links) > 0.0 && n_links < 2)
         ret = object_del(id);
 
     return ret;
 }
 
 
 double object_ctime_by_md5(const char *md5)
 {
     xs *fn = _object_fn_by_md5(md5, "object_ctime_by_md5");
     return f_ctime(fn);
 }
 
 
 double object_ctime(const char *id)
 {
     const char *md5 = xs_md5(id);
     return object_ctime_by_md5(md5);
 }
 
 
 double object_mtime_by_md5(const char *md5)
 {
     xs *fn = _object_fn_by_md5(md5, "object_mtime_by_md5");
     return mtime(fn);
 }
 
 
 double object_mtime(const char *id)
 {
     const char *md5 = xs_md5(id);
     return object_mtime_by_md5(md5);
 }
 
 
 void object_touch(const char *id)
 {
     const char *md5 = xs_md5(id);
     xs *fn = _object_fn_by_md5(md5, "object_touch");
 
     if (mtime(fn))
         utimes(fn, NULL);
 }
 
 
 xs_str *_object_index_fn(const char *id, const char *idxsfx)
 /* returns the filename of an object's index */
 {
     xs_str *fn = _object_fn(id);
     return xs_replace_i(fn, ".json", idxsfx);
 }
 
 
 int object_likes_len(const char *id)
 /* returns the number of likes (without reading the index) */
 {
     xs *fn = _object_index_fn(id, "_l.idx");
     return index_len(fn);
 }
 
 
 int object_announces_len(const char *id)
 /* returns the number of announces (without reading the index) */
 {
     xs *fn = _object_index_fn(id, "_a.idx");
     return index_len(fn);
 }
 
 
 xs_list *object_children(const char *id)
 /* returns the list of an object's children */
 {
     xs *fn = _object_index_fn(id, "_c.idx");
     return index_list(fn, XS_ALL);
 }
 
 
 xs_list *object_likes(const char *id)
 {
     xs *fn = _object_index_fn(id, "_l.idx");
     return index_list(fn, XS_ALL);
 }
 
 
 xs_list *object_announces(const char *id)
 {
     xs *fn = _object_index_fn(id, "_a.idx");
     return index_list(fn, XS_ALL);
 }
 
 
 int object_parent(const char *md5, char parent[MD5_HEX_SIZE])
 /* returns the object parent, if any */
 {
     xs *fn = _object_fn_by_md5(md5, "object_parent");
 
     fn = xs_replace_i(fn, ".json", "_p.idx");
     return index_first(fn, parent);
 }
 
 
 int object_admire(const char *id, const char *actor, int like)
 /* actor likes or announces this object */
 {
     int status = HTTP_STATUS_OK;
     xs *fn     = _object_fn(id);
 
     fn = xs_replace_i(fn, ".json", like ? "_l.idx" : "_a.idx");
 
     if (!index_in(fn, actor)) {
         status = index_add(fn, actor);
 
         srv_debug(1, xs_fmt("object_admire (%s) %s %s", like ? "Like" : "Announce", actor, fn));
     }
 
     return status;
 }
 
 
 int object_unadmire(const char *id, const char *actor, int like)
 /* actor no longer likes or announces this object */
 {
     int status;
     xs *fn = _object_fn(id);
 
     fn = xs_replace_i(fn, ".json", like ? "_l.idx" : "_a.idx");
 
     status = index_del(fn, actor);
 
     if (valid_status(status))
         index_gc(fn);
 
     srv_debug(0,
         xs_fmt("object_unadmire (%s) %s %s %d", like ? "Like" : "Announce", actor, fn, status));
 
     return status;
 }
 
 
 xs_str *object_user_cache_fn_by_md5(snac *user, const char *md5, const char *cachedir)
 {
     return xs_fmt("%s/%s/%s.json", user->basedir, cachedir, md5);
 }
 
 
 xs_str *object_user_cache_fn(snac *user, const char *id, const char *cachedir)
 {
     const char *md5 = xs_md5(id);
     return object_user_cache_fn_by_md5(user, md5, cachedir);
 }
 
 
 xs_str *object_user_cache_index_fn(snac *user, const char *cachedir)
 {
     return xs_fmt("%s/%s.idx", user->basedir, cachedir);
 }
 
 
 int _object_user_cache(snac *user, const char *id, const char *cachedir, int del)
 /* adds or deletes from a user cache */
 {
     int ret;
     xs *idx = object_user_cache_index_fn(user, cachedir);
 
     if (del) {
         ret = user_unlink_subfile(user, cachedir, md5_fn(id, ".json"));
         index_del(idx, id);
     }
     else {
         xs *ofn = _object_fn(id);
         ret = user_link_subfile(user, cachedir, md5_fn(id, ".json"), AT_FDCWD, ofn);
         index_add(idx, id);
     }
 
     return ret;
 #if 0
     xs *ofn = _object_fn(id);
     xs *cfn = object_user_cache_fn(user, id, cachedir);
     xs *idx = object_user_cache_index_fn(user, cachedir);
     int ret;
 
     if (del) {
         ret = unlink(cfn);
         index_del(idx, id);
     }
     else {
         /* create the subfolder, if it does not exist */
         xs *dir = xs_fmt("%s/%s/", user->basedir, cachedir);
         mkdirx(dir);
 
         if ((ret = link(ofn, cfn)) != -1)
             index_add(idx, id);
     }
 
     return ret;
 #endif
 }
 
 
 int object_user_cache_add(snac *user, const char *id, const char *cachedir)
 /* caches an object into a user cache */
 {
     return _object_user_cache(user, id, cachedir, 0);
 }
 
 
 int object_user_cache_del(snac *user, const char *id, const char *cachedir)
 /* deletes an object from a user cache */
 {
     return _object_user_cache(user, id, cachedir, 1);
 }
 
 
 int object_user_cache_in(snac *user, const char *id, const char *cachedir)
 /* checks if an object is stored in a cache */
 {
     xs *cfn = object_user_cache_fn(user, id, cachedir);
     return !!(mtime(cfn) != 0.0);
 }
 
 
 int object_user_cache_in_by_md5(snac *user, const char *md5, const char *cachedir)
 /* checks if an object is stored in a cache */
 {
     xs *cfn = object_user_cache_fn_by_md5(user, md5, cachedir);
     return !!(mtime(cfn) != 0.0);
 }
 
 
 xs_list *object_user_cache_list(snac *user, const char *cachedir, int max, int inv)
 /* returns the objects in a cache as a list */
 {
     xs *idx = xs_fmt("%s/%s.idx", user->basedir, cachedir);
     return inv ? index_list_desc(idx, 0, max) : index_list(idx, max);
 }
 
 
 /** specialized functions **/
 
 /** followers **/
 
 int follower_add(snac *snac, const char *actor)
 /* adds a follower */
 {
     int ret = object_user_cache_add(snac, actor, "followers");
 
     snac_debug(snac, 2, xs_fmt("follower_add %s", actor));
 
     return ret == -1 ? HTTP_STATUS_INTERNAL_SERVER_ERROR : HTTP_STATUS_OK;
 }
 
 
 int follower_del(snac *snac, const char *actor)
 /* deletes a follower */
 {
     int ret = object_user_cache_del(snac, actor, "followers");
 
     snac_debug(snac, 2, xs_fmt("follower_del %s", actor));
 
     return ret == -1 ? HTTP_STATUS_NOT_FOUND : HTTP_STATUS_OK;
 }
 
 
 int follower_check(snac *snac, const char *actor)
 /* checks if someone is a follower */
 {
     return object_user_cache_in(snac, actor, "followers");
 }
 
 
 int follower_list_len(snac *snac)
 /* returns the number of followers */
 {
     xs *list = object_user_cache_list(snac, "followers", XS_ALL, 0);
     return xs_list_len(list);
 }
 
 
 xs_list *follower_list(snac *snac)
 /* returns the list of followers */
 {
     xs *list       = object_user_cache_list(snac, "followers", XS_ALL, 0);
     xs_list *fwers = xs_list_new();
     char *p;
     const char *v;
 
     /* resolve the list of md5 to be a list of actors */
     p = list;
     while (xs_list_iter(&p, &v)) {
         xs *a_obj = NULL;
 
         if (valid_status(object_get_by_md5(v, &a_obj))) {
             const char *actor = xs_dict_get(a_obj, "id");
 
             if (!xs_is_null(actor)) {
                 /* check if the actor is still cached */
                 xs *fn = xs_fmt("%s/followers/%s.json", snac->basedir, v);
 
                 if (mtime(fn) > 0.0)
                     fwers = xs_list_append(fwers, actor);
             }
         }
     }
 
     return fwers;
 }
 
 
 /** pending followers **/
 
 int pending_add(snac *user, const char *actor, const xs_dict *msg)
 /* stores the follow message for later confirmation */
 {
     xs *dir = xs_fmt("%s/pending", user->basedir);
     const char *md5 = xs_md5(actor);
     xs *fn  = xs_fmt("%s/%s.json", dir, md5);
     FILE *f;
 
     mkdirx(dir);
 
     if ((f = fopen(fn, "w")) == NULL)
         return -1;
 
     xs_json_dump(msg, 4, f);
     fclose(f);
 
     return 0;
 }
 
 
 int pending_check(snac *user, const char *actor)
 /* checks if there is a pending follow confirmation for the actor */
 {
     const char *md5 = xs_md5(actor);
     xs *fn = xs_fmt("%s/pending/%s.json", user->basedir, md5);
 
     return mtime(fn) != 0;
 }
 
 
 xs_dict *pending_get(snac *user, const char *actor)
 /* returns the pending follow confirmation for the actor */
 {
     const char *md5 = xs_md5(actor);
     xs *fn = xs_fmt("%s/pending/%s.json", user->basedir, md5);
     xs_dict *msg = NULL;
     FILE *f;
 
     if ((f = fopen(fn, "r")) != NULL) {
         msg = xs_json_load(f);
         fclose(f);
     }
 
     return msg;
 }
 
 
 void pending_del(snac *user, const char *actor)
 /* deletes a pending follow confirmation for the actor */
 {
     const char *md5 = xs_md5(actor);
     xs *fn = xs_fmt("%s/pending/%s.json", user->basedir, md5);
 
     unlink(fn);
 }
 
 
 xs_list *pending_list(snac *user)
 /* returns a list of pending follow confirmations */
 {
     xs *spec = xs_fmt("%s/pending/""*.json", user->basedir);
     xs *l = xs_glob(spec, 0, 0);
     xs_list *r = xs_list_new();
     const char *v;
 
     xs_list_foreach(l, v) {
         FILE *f;
         xs *msg = NULL;
 
         if ((f = fopen(v, "r")) == NULL)
             continue;
 
         msg = xs_json_load(f);
         fclose(f);
 
         if (msg == NULL)
             continue;
 
         const char *actor = xs_dict_get(msg, "actor");
 
         if (xs_type(actor) == XSTYPE_STRING)
             r = xs_list_append(r, actor);
     }
 
     return r;
 }
 
 
 int pending_count(snac *user)
 /* returns the number of pending follow confirmations */
 {
     xs *spec = xs_fmt("%s/pending/""*.json", user->basedir);
     xs *l = xs_glob(spec, 0, 0);
 
     return xs_list_len(l);
 }
 
 
 /** timeline **/
 
 double timeline_mtime(snac *snac)
 {
     xs *fn = xs_fmt("%s/private.idx", snac->basedir);
     return mtime(fn);
 }
 
 
 int timeline_touch(snac *snac)
 /* changes the date of the timeline index */
 {
     xs *fn = xs_fmt("%s/private.idx", snac->basedir);
     return utimes(fn, NULL);
 }
 
 
 xs_str *timeline_fn_by_md5(snac *snac, const char *md5)
 /* get the filename of an entry by md5 from any timeline */
 {
     xs_str *fn = NULL;
 
     if (is_md5_hex(md5)) {
         fn = xs_fmt("%s/private/%s.json", snac->basedir, md5);
 
         if (mtime(fn) == 0.0) {
             fn = xs_free(fn);
             fn = xs_fmt("%s/public/%s.json", snac->basedir, md5);
 
             if (mtime(fn) == 0.0)
                 fn = xs_free(fn);
         }
     }
 
     return fn;
 }
 
 
 int timeline_here_by_md5(snac *snac, const char *md5)
 /* checks if an object is in the user cache */
 {
     xs *fn = timeline_fn_by_md5(snac, md5);
 
     return !(fn == NULL);
 }
 
 
 int timeline_here(snac *user, const char *id)
 {
     const char *md5 = xs_md5(id);
 
     return timeline_here_by_md5(user, md5);
 }
 
 
 int timeline_get_by_md5(snac *snac, const char *md5, xs_dict **msg)
 /* gets a message from the timeline */
 {
     int status = HTTP_STATUS_NOT_FOUND;
     FILE *f    = NULL;
 
     xs *fn = timeline_fn_by_md5(snac, md5);
 
     if (fn != NULL && (f = fopen(fn, "r")) != NULL) {
         *msg = xs_json_load(f);
         fclose(f);
 
         if (*msg != NULL)
             status = HTTP_STATUS_OK;
     }
 
     return status;
 }
 
 
 int timeline_del(snac *snac, const char *id)
 /* deletes a message from the timeline */
 {
     /* delete from the user's caches */
     object_user_cache_del(snac, id, "public");
     object_user_cache_del(snac, id, "private");
 
     unpin(snac, id);
     unbookmark(snac, id);
 
     /* try to delete the object if it's not used elsewhere */
     return object_del_if_unref(id);
 }
 
 
 void timeline_update_indexes(snac *snac, const char *id)
 /* updates the indexes */
 {
     object_user_cache_add(snac, id, "private");
 
     if (xs_startswith(id, snac->actor)) {
         xs *msg = NULL;
 
         if (valid_status(object_get(id, &msg))) {
             /* if its ours and is public, also store in public */
             if (is_msg_public(msg)) {
                 if (object_user_cache_add(snac, id, "public") >= 0) {
                     /* also add it to the instance public timeline */
                     xs *ipt = xs_fmt("%s/public.idx", srv_basedir);
                     index_add(ipt, id);
                 }
                 else
                     srv_debug(1, xs_fmt("Not added to public instance index %s", id));
             }
         }
     }
 }
 
 
 int timeline_add(snac *snac, const char *id, const xs_dict *o_msg)
 /* adds a message to the timeline */
 {
     int ret = object_add(id, o_msg);
     timeline_update_indexes(snac, id);
 
     tag_index(id, o_msg);
 
     list_distribute(snac, NULL, o_msg);
 
     snac_debug(snac, 1, xs_fmt("timeline_add %s", id));
 
     return ret;
 }
 
 
 int timeline_admire(snac *snac, const char *id, const char *admirer, int like)
 /* updates a timeline entry with a new admiration */
 {
     /* if we are admiring this, add to both timelines */
     if (!like && strcmp(admirer, snac->actor) == 0) {
         object_user_cache_add(snac, id, "public");
         object_user_cache_add(snac, id, "private");
     }
 
     int ret = object_admire(id, admirer, like);
 
     snac_debug(snac, 1, xs_fmt("timeline_admire (%s) %s %s",
             like ? "Like" : "Announce", id, admirer));
 
     return ret;
 }
 
 
 xs_list *timeline_top_level(snac *snac, const xs_list *list)
 /* returns the top level md5 entries from this index */
 {
     xs_set seen;
     const xs_str *v;
 
     xs_set_init(&seen);
 
     int c = 0;
     while (xs_list_next(list, &v, &c)) {
         char line[MD5_HEX_SIZE] = "";
 
         strncpy(line, v, sizeof(line) - 1);
 
         for (;;) {
             char line2[MD5_HEX_SIZE];
 
             /* if it doesn't have a parent, use this */
             if (!object_parent(line, line2))
                 break;
 
             /* well, there is a parent... but is it here? */
             if (!timeline_here_by_md5(snac, line2))
                 break;
 
             /* it's here! try again with its own parent */
             memcpy(line, line2, sizeof(line));
         }
 
         xs_set_add(&seen, line);
     }
 
     return xs_set_result(&seen);
 }
 
 
 xs_str *user_index_fn(snac *user, const char *idx_name)
 /* returns the filename of a user index */
 {
     return xs_fmt("%s/%s.idx", user->basedir, idx_name);
 }
 
 
 xs_list *timeline_simple_list(snac *user, const char *idx_name, int skip, int show, int *more)
 /* returns a timeline (with all entries) */
 {
     xs *idx = user_index_fn(user, idx_name);
 
     /* if a more flag is sent, request one more */
     xs_list *lst = index_list_desc(idx, skip, show + (more != NULL ? 1 : 0));
 
     if (more != NULL) {
         if (xs_list_len(lst) > show) {
             *more = 1;
             lst = xs_list_del(lst, -1);
         }
         else
             *more = 0;
     }
 
     return lst;
 }
 
 
 xs_list *timeline_list(snac *snac, const char *idx_name, int skip, int show, int *more)
 /* returns a timeline (only top level entries) */
 {
     int c_max;
 
     /* maximum number of items in the timeline */
     c_max = xs_number_get(xs_dict_get(srv_config, "max_timeline_entries"));
 
     /* never more timeline entries than the configured maximum */
     if (show > c_max)
         show = c_max;
 
     xs *list = timeline_simple_list(snac, idx_name, skip, show, more);
 
     return timeline_top_level(snac, list);
 }
 
 
 void timeline_add_mark(snac *user)
 /* adds an "already seen" mark to the private timeline */
 {
     xs *fn = xs_fmt("%s/private.idx", user->basedir);
     char last_entry[MD5_HEX_SIZE] = "";
     FILE *f;
 
     /* get the last entry in the index */
     if ((f = fopen(fn, "r")) != NULL) {
         index_desc_first(f, last_entry, 0);
         fclose(f);
     }
 
     /* is the last entry *not* a mark? */
     if (strcmp(last_entry, MD5_ALREADY_SEEN_MARK) != 0) {
         /* add it */
         index_add_md5(fn, MD5_ALREADY_SEEN_MARK);
     }
 }
 
 
 xs_str *instance_index_fn(void)
 {
     return xs_fmt("%s/public.idx", srv_basedir);
 }
 
 
 xs_list *timeline_instance_list(int skip, int show)
 /* returns the timeline for the full instance */
 {
     xs *idx = instance_index_fn();
     xs *lst = index_list_desc(idx, skip, show);
 
     /* make the list unique */
     xs_set rep;
     xs_set_init(&rep);
     const char *md5;
 
     xs_list_foreach(lst, md5)
         xs_set_add(&rep, md5);
 
     return xs_set_result(&rep);
 }
 
 
 /** following **/
 
 /* this needs special treatment and cannot use the object db as is,
    with a link to a cached author, because we need the Follow object
    in case we need to unfollow (Undo + original Follow) */
 
 xs_str *_following_fn(snac *snac, const char *actor)
 {
     const char *md5 = xs_md5(actor);
     return xs_fmt("%s/following/%s.json", snac->basedir, md5);
 }
 
 
 int following_add(snac *snac, const char *actor, const xs_dict *msg)
 /* adds to the following list */
 {
     int ret = HTTP_STATUS_CREATED;
     xs *fn = _following_fn(snac, actor);
     FILE *f;
     xs *p_object = NULL;
 
     if (valid_status(following_get(snac, actor, &p_object))) {
         /* object already exists; if it's of type Accept,
            the actor is already being followed and confirmed,
            so do nothing */
         const char *type = xs_dict_get(p_object, "type");
 
         if (!xs_is_null(type) && strcmp(type, "Accept") == 0) {
             snac_debug(snac, 1, xs_fmt("following_add actor already confirmed %s", actor));
             return HTTP_STATUS_OK;
         }
     }
 
     if ((f = fopen(fn, "w")) != NULL) {
         xs_json_dump(msg, 4, f);
         fclose(f);
 
         /* get the filename of the actor object */
         xs *actor_fn = _object_fn(actor);
 
         /* increase its reference count */
         fn = xs_replace_i(fn, ".json", "_a.json");
         if (link(actor_fn, fn) == -1) {
             fprintf(stderr, "Failed to create actor link: %s\n", strerror(errno));
         }
     }
     else
         ret = HTTP_STATUS_INTERNAL_SERVER_ERROR;
 
     snac_debug(snac, 2, xs_fmt("following_add %s %s", actor, fn));
 
     return ret;
 }
 
 
 int following_del(snac *snac, const char *actor)
 /* we're not following this actor any longer */
 {
     xs *fn = _following_fn(snac, actor);
 
     snac_debug(snac, 2, xs_fmt("following_del %s %s", actor, fn));
 
     unlink(fn);
 
     /* also delete the reference to the author */
     fn = xs_replace_i(fn, ".json", "_a.json");
     unlink(fn);
 
     return HTTP_STATUS_OK;
 }
 
 
 int following_check(snac *snac, const char *actor)
 /* checks if we are following this actor */
 {
     xs *fn = _following_fn(snac, actor);
 
     return !!(mtime(fn) != 0.0);
 }
 
 
 int following_get(snac *snac, const char *actor, xs_dict **data)
 /* returns the 'Follow' object */
 {
     xs *fn = _following_fn(snac, actor);
     FILE *f;
     int status = HTTP_STATUS_OK;
 
     if ((f = fopen(fn, "r")) != NULL) {
         *data = xs_json_load(f);
         fclose(f);
     }
     else
         status = HTTP_STATUS_NOT_FOUND;
 
     return status;
 }
 
 
 int following_list_len(snac *snac)
 /* returns number of people being followed */
 {
     xs *spec = xs_fmt("%s/following/" "*_a.json", snac->basedir);
     xs *glist = xs_glob(spec, 0, 0);
     return xs_list_len(glist);
 }
 
 
 xs_list *following_list(snac *snac)
 /* returns the list of people being followed */
 {
     xs *spec = xs_fmt("%s/following/" "*.json", snac->basedir);
     xs *glist = xs_glob(spec, 0, 0);
     xs_list *p;
     const xs_str *v;
     xs_list *list = xs_list_new();
 
     /* iterate the list of files */
     p = glist;
     while (xs_list_iter(&p, &v)) {
         FILE *f;
 
         /* load the follower data */
         if ((f = fopen(v, "r")) != NULL) {
             xs *o = xs_json_load(f);
             fclose(f);
 
             if (o != NULL) {
                 const char *type = xs_dict_get(o, "type");
 
                 if (!xs_is_null(type) && strcmp(type, "Accept") == 0) {
                     const char *actor = xs_dict_get(o, "actor");
 
                     if (!xs_is_null(actor)) {
                         list = xs_list_append(list, actor);
 
                         /* check if there is a link to the actor object */
                         xs *v2 = xs_replace(v, ".json", "_a.json");
 
                         if (mtime(v2) == 0.0) {
                             /* no; add a link to it */
                             xs *actor_fn = _object_fn(actor);
                             if (link(actor_fn, v2) == -1) {
                                 fprintf(stderr, "Actor link creation failed: %s\n", strerror(errno));
                             }
                         }
                     }
                 }
             }
         }
     }
 
     return list;
 }
 
 
 xs_str *_muted_fn(snac *snac, const char *actor)
 {
     const char *md5 = xs_md5(actor);
     return xs_fmt("%s/muted/%s", snac->basedir, md5);
 }
 
 
 void mute(snac *snac, const char *actor)
 /* mutes a moron */
 {
     xs *fn = _muted_fn(snac, actor);
     FILE *f;
 
     if ((f = fopen(fn, "w")) != NULL) {
         fprintf(f, "%s\n", actor);
         fclose(f);
 
         snac_debug(snac, 2, xs_fmt("muted %s %s", actor, fn));
     }
 }
 
 
 void unmute(snac *snac, const char *actor)
 /* actor is no longer a moron */
 {
     xs *fn = _muted_fn(snac, actor);
 
     unlink(fn);
 
     snac_debug(snac, 2, xs_fmt("unmuted %s %s", actor, fn));
 }
 
 
 int is_muted(snac *snac, const char *actor)
 /* check if someone is muted */
 {
     xs *fn = _muted_fn(snac, actor);
 
     return !!(mtime(fn) != 0.0);
 }
 
 
 xs_list *muted_list(snac *user)
 /* returns the list (actor URLs) of the muted morons */
 {
     xs_list *l = xs_list_new();
     xs *spec = xs_fmt("%s/muted/" "*", user->basedir);
     xs *files = xs_glob(spec, 0, 0);
     const char *fn;
 
     xs_list_foreach(files, fn) {
         FILE *f;
 
         if ((f = fopen(fn, "r")) != NULL) {
             xs *actor = xs_strip_i(xs_readline(f));
             fclose(f);
 
             l = xs_list_append(l, actor);
         }
     }
 
     return l;
 }
 
 
 /** bookmarking **/
 
 int is_bookmarked(snac *user, const char *id)
 /* returns true if this note is bookmarked */
 {
     return object_user_cache_in(user, id, "bookmark");
 }
 
 
 int bookmark(snac *user, const char *id)
 /* bookmarks a post */
 {
     if (is_bookmarked(user, id))
         return -3;
 
     return object_user_cache_add(user, id, "bookmark");
 }
 
 
 int unbookmark(snac *user, const char *id)
 /* unbookmarks a post */
 {
     return object_user_cache_del(user, id, "bookmark");
 }
 
 
 xs_list *bookmark_list(snac *user)
 /* return the lists of bookmarked posts */
 {
     return object_user_cache_list(user, "bookmark", XS_ALL, 1);
 }
 
 
 xs_str *bookmark_index_fn(snac *user)
 {
     return object_user_cache_index_fn(user, "bookmark");
 }
 
 
 /** pinning **/
 
 int is_pinned(snac *user, const char *id)
 /* returns true if this note is pinned */
 {
     return object_user_cache_in(user, id, "pinned");
 }
 
 
 int is_pinned_by_md5(snac *user, const char *md5)
 {
     return object_user_cache_in_by_md5(user, md5, "pinned");
 }
 
 
 int pin(snac *user, const char *id)
 /* pins a message */
 {
     int ret = -2;
 
     if (xs_startswith(id, user->actor)) {
         if (is_pinned(user, id))
             ret = -3;
         else
             ret = object_user_cache_add(user, id, "pinned");
     }
 
     return ret;
 }
 
 
 int unpin(snac *user, const char *id)
 /* unpin a message */
 {
     return object_user_cache_del(user, id, "pinned");
 }
 
 
 xs_list *pinned_list(snac *user)
 /* return the lists of pinned posts */
 {
     return object_user_cache_list(user, "pinned", XS_ALL, 1);
 }
 
 
 /** drafts **/
 
 int is_draft(snac *user, const char *id)
 /* returns true if this note is a draft */
 {
     return object_user_cache_in(user, id, "draft");
 }
 
 
 void draft_del(snac *user, const char *id)
 /* delete a message from the draft cache */
 {
     object_user_cache_del(user, id, "draft");
 }
 
 
 void draft_add(snac *user, const char *id, const xs_dict *msg)
 /* store the message as a draft */
 {
     /* delete from the index, in case it was already there */
     draft_del(user, id);
 
     /* overwrite object */
     object_add_ow(id, msg);
 
     /* [re]add to the index */
     object_user_cache_add(user, id, "draft");
 }
 
 
 xs_list *draft_list(snac *user)
 /* return the lists of drafts */
 {
     return object_user_cache_list(user, "draft", XS_ALL, 1);
 }
 
 
 /** scheduled posts **/
 
 int is_scheduled(snac *user, const char *id)
 /* returns true if this note is scheduled for future sending */
 {
     return object_user_cache_in(user, id, "sched");
 }
 
 
 void schedule_del(snac *user, const char *id)
 /* deletes an scheduled post */
 {
     object_user_cache_del(user, id, "sched");
 }
 
 
 void schedule_add(snac *user, const char *id, const xs_dict *msg)
 /* schedules this post for later */
 {
     /* delete from the index, in case it was already there */
     schedule_del(user, id);
 
     /* overwrite object */
     object_add_ow(id, msg);
 
     /* [re]add to the index */
     object_user_cache_add(user, id, "sched");
 }
 
 
 xs_list *scheduled_list(snac *user)
 /* return the list of scheduled posts */
 {
     return object_user_cache_list(user, "sched", XS_ALL, 1);
 }
 
 
 void scheduled_process(snac *user)
 /* processes the scheduled list, sending those ready to be sent */
 {
     xs *posts = scheduled_list(user);
     const char *md5;
     xs *right_now = xs_str_utctime(0, ISO_DATE_SPEC);
 
     xs_list_foreach(posts, md5) {
         xs *msg = NULL;
 
         if (valid_status(object_get_by_md5(md5, &msg))) {
             if (strcmp(xs_dict_get(msg, "published"), right_now) < 0) {
                 /* due date! */
                 const char *id = xs_dict_get(msg, "id");
 
                 timeline_add(user, id, msg);
 
                 xs *c_msg = msg_create(user, msg);
                 enqueue_message(user, c_msg);
 
                 schedule_del(user, id);
             }
         }
     }
 }
 
 
 /** hiding **/
 
 xs_str *_hidden_fn(snac *snac, const char *id)
 {
     const char *md5 = xs_md5(id);
     return xs_fmt("%s/hidden/%s", snac->basedir, md5);
 }
 
 
 void hide(snac *snac, const char *id)
 /* hides a message tree */
 {
     xs *fn = _hidden_fn(snac, id);
     FILE *f;
 
     if ((f = fopen(fn, "w")) != NULL) {
         fprintf(f, "%s\n", id);
         fclose(f);
 
         snac_debug(snac, 2, xs_fmt("hidden %s %s", id, fn));
 
         /* hide all the children */
         xs *chld = object_children(id);
         char *p;
         const char *v;
 
         p = chld;
         while (xs_list_iter(&p, &v)) {
             xs *co = NULL;
 
             /* resolve to get the id */
             if (valid_status(object_get_by_md5(v, &co))) {
                 const char *id = xs_dict_get(co, "id");
                 if (id != NULL)
                     hide(snac, id);
             }
         }
     }
 }
 
 
 int is_hidden(snac *snac, const char *id)
 /* check is id is hidden */
 {
     xs *fn = _hidden_fn(snac, id);
 
     return !!(mtime(fn) != 0.0);
 }
 
 
 int actor_add(const char *actor, const xs_dict *msg)
 /* adds an actor */
 {
     return object_add_ow(actor, msg);
 }
 
 
 int actor_get(const char *actor, xs_dict **data)
 /* returns an already downloaded actor */
 {
     int status = HTTP_STATUS_OK;
     xs_dict *d = NULL;
 
     if (xs_startswith(actor, srv_baseurl)) {
         /* it's a (possible) local user */
         xs *l = xs_split(actor, "/");
         const char *uid = xs_list_get(l, -1);
         snac user;
 
         if (!xs_is_null(uid) && user_open(&user, uid)) {
             if (data)
                 *data = msg_actor(&user);
 
             user_free(&user);
             return HTTP_STATUS_OK;
         }
         else
             return HTTP_STATUS_NOT_FOUND;
     }
 
     /* read the object */
     if (!valid_status(status = object_get(actor, &d))) {
         d = xs_free(d);
         return status;
     }
 
     /* if the object is corrupted, discard it */
     if (xs_is_null(xs_dict_get(d, "id")) || xs_is_null(xs_dict_get(d, "type"))) {
         srv_debug(1, xs_fmt("corrupted actor object %s", actor));
         d = xs_free(d);
         return HTTP_STATUS_NOT_FOUND;
     }
 
     if (data)
         *data = d;
     else
         d = xs_free(d);
 
     xs *fn = _object_fn(actor);
     double max_time;
 
     /* maximum time for the actor data to be considered stale */
     max_time = 3600.0 * 36.0;
 
     if (mtime(fn) + max_time < (double) time(NULL)) {
         /* actor data exists but also stinks */
         status = HTTP_STATUS_RESET_CONTENT; /* "110: Response Is Stale" */
     }
 
     return status;
 }
 
 
 int actor_get_refresh(snac *user, const char *actor, xs_dict **data)
 /* gets an actor and requests a refresh if it's stale */
 {
     int status = actor_get(actor, data);
 
     if (status == HTTP_STATUS_RESET_CONTENT && user && !xs_startswith(actor, srv_baseurl))
         enqueue_actor_refresh(user, actor, 0);
 
     return status;
 }
 
 
 /** user limiting (announce blocks) **/
 
 int limited(snac *user, const char *id, int cmd)
 /* announce messages from a followed (0: check, 1: limit; 2: unlimit) */
 {
     int ret = 0;
     xs *dir = xs_fmt("%s/limited", user->basedir);
     const char *md5 = xs_md5(id);
     xs *fn  = xs_fmt("%s/%s", dir, md5);
 
     switch (cmd) {
     case 0: /** check **/
         ret = !!(mtime(fn) > 0.0);
         break;
 
     case 1: /** limit **/
         mkdirx(dir);
 
         if (mtime(fn) > 0.0)
             ret = -1;
         else {
             FILE *f;
 
             if ((f = fopen(fn, "w")) != NULL) {
                 fprintf(f, "%s\n", id);
                 fclose(f);
             }
             else
                 ret = -2;
         }
         break;
 
     case 2: /** unlimit **/
         if (mtime(fn) > 0.0)
             ret = unlink(fn);
         else
             ret = -1;
         break;
     }
 
     return ret;
 }
 
 
 /** tag indexing **/
 
 void tag_index(const char *id, const xs_dict *obj)
 /* update the tag indexes for this object */
 {
     const xs_list *tags = xs_dict_get(obj, "tag");
     const char *md5_id = xs_md5(id);
 
     if (is_msg_public(obj) && xs_type(tags) == XSTYPE_LIST && xs_list_len(tags) > 0) {
         xs *g_tag_dir = xs_fmt("%s/tag", srv_basedir);
 
         mkdirx(g_tag_dir);
 
         const xs_dict *v;
         int ct = 0;
         while (xs_list_next(tags, &v, &ct)) {
             const char *type = xs_dict_get(v, "type");
             const char *name = xs_dict_get(v, "name");
 
             if (!xs_is_null(type) && !xs_is_null(name) && strcmp(type, "Hashtag") == 0) {
                 while (*name == '#' || *name == '@')
                     name++;
 
                 if (*name == '\0')
                     continue;
 
                 name = xs_utf8_to_lower((xs_str *)name);
 
                 const char *md5_tag = xs_md5(name);
                 xs *tag_dir   = xs_fmt("%s/%c%c", g_tag_dir, md5_tag[0], md5_tag[1]);
                 mkdirx(tag_dir);
 
                 xs *g_tag_idx = xs_fmt("%s/%s.idx", tag_dir, md5_tag);
 
                 if (!index_in_md5(g_tag_idx, md5_id))
                     index_add_md5(g_tag_idx, md5_id);
 
                 FILE *f;
                 xs *g_tag_name = xs_replace(g_tag_idx, ".idx", ".tag");
                 if ((f = fopen(g_tag_name, "w")) != NULL) {
                     fprintf(f, "%s\n", name);
                     fclose(f);
                 }
 
                 srv_debug(1, xs_fmt("tagged %s #%s (#%s)", id, name, md5_tag));
             }
         }
     }
 }
 
 
 xs_str *tag_fn(const char *tag)
 {
     if (*tag == '#')
         tag++;
 
     xs *lw_tag = xs_utf8_to_lower(tag);
     const char *md5 = xs_md5(lw_tag);
 
     return xs_fmt("%s/tag/%c%c/%s.idx", srv_basedir, md5[0], md5[1], md5);
 }
 
 
 xs_list *tag_search(const char *tag, int skip, int show)
 /* returns the list of posts tagged with tag */
 {
     xs *idx = tag_fn(tag);
 
     return index_list_desc(idx, skip, show);
 }
 
 
 /** lists **/
 
 xs_val *list_maint(snac *user, const char *list, int op)
 /* list maintenance */
 {
     xs_val *l = NULL;
 
     switch (op) {
     case 0: /** list of lists **/
         {
             FILE *f;
             xs *spec = xs_fmt("%s/list/" "*.id", user->basedir);
             xs *ls   = xs_glob(spec, 0, 0);
             int c = 0;
             const char *v;
 
             l = xs_list_new();
 
             while (xs_list_next(ls, &v, &c)) {
                 if ((f = fopen(v, "r")) != NULL) {
                     xs *title = xs_readline(f);
                     fclose(f);
 
                     title = xs_strip_i(title);
 
                     xs *v2 = xs_replace(v, ".id", "");
                     xs *l2 = xs_split(v2, "/");
 
                     /* return [ list_id, list_title ] */
                     xs *tmp_list = xs_list_append(xs_list_new(), xs_list_get(l2, -1), title);
                     l = xs_list_append(l, tmp_list);
                 }
             }
         }
 
         break;
 
     case 1: /** create new list (list is the name) **/
         {
             xs *lol = list_maint(user, NULL, 0);
             int c = 0;
             const xs_list *v;
             int add = 1;
 
             /* check if this list name already exists */
             while (xs_list_next(lol, &v, &c)) {
                 if (strcmp(xs_list_get(v, 1), list) == 0) {
                     add = 0;
 
                     l = xs_dup(xs_list_get(v, 0));
 
                     break;
                 }
             }
 
             if (add) {
                 FILE *f;
                 xs *dir = xs_fmt("%s/list/", user->basedir);
 
                 l = xs_fmt("%010x", time(NULL));
 
                 mkdirx(dir);
 
                 xs *fn = xs_fmt("%s%s.id", dir, l);
 
                 if ((f = fopen(fn, "w")) != NULL) {
                     fprintf(f, "%s\n", list);
                     fclose(f);
                 }
             }
         }
 
         break;
 
     case 2: /** delete list (list is the id) **/
         {
             if (xs_is_hex(list)) {
                 xs *fn = xs_fmt("%s/list/%s.id", user->basedir, list);
                 unlink(fn);
 
                 fn = xs_replace_i(fn, ".id", ".lst");
                 unlink(fn);
 
                 fn = xs_replace_i(fn, ".lst", ".idx");
                 unlink(fn);
 
                 fn = xs_str_cat(fn, ".bak");
                 unlink(fn);
             }
         }
 
         break;
 
     case 3: /** get list name **/
         if (xs_is_hex(list)) {
             FILE *f;
             xs *fn = xs_fmt("%s/list/%s.id", user->basedir, list);
 
             if ((f = fopen(fn, "r")) != NULL) {
                 l = xs_strip_i(xs_readline(f));
                 fclose(f);
             }
         }
 
         break;
 
     case 4: /** find list id by name **/
         if (xs_is_string(list)) {
             xs *lol = list_maint(user, NULL, 0);
             const xs_list *li;
 
             xs_list_foreach(lol, li) {
                 if (strcmp(list, xs_list_get(li, 1)) == 0) {
                     l = xs_dup(xs_list_get(li, 0));
                     break;
                 }
             }
         }
     }
 
     return l;
 }
 
 
 xs_str *list_timeline_fn(snac *user, const char *list)
 {
     return xs_fmt("%s/list/%s.idx", user->basedir, list);
 }
 
 
 xs_list *list_timeline(snac *user, const char *list, int skip, int show)
 /* returns the timeline of a list */
 {
     xs_list *l = NULL;
 
     if (!xs_is_hex(list))
         return NULL;
 
     xs *fn = list_timeline_fn(user, list);
 
     if (mtime(fn) > 0.0)
         l = index_list_desc(fn, skip, show);
     else
         l = xs_list_new();
 
     return l;
 }
 
 
 xs_val *list_content(snac *user, const char *list, const char *actor_md5, int op)
 /* list content management */
 {
     xs_val *l = NULL;
 
     if (!xs_is_hex(list))
         return NULL;
 
     if (actor_md5 != NULL && !xs_is_hex(actor_md5))
         return NULL;
 
     xs *fn = xs_fmt("%s/list/%s.lst", user->basedir, list);
 
     switch (op) {
     case 0: /** list content **/
         l = index_list(fn, XS_ALL);
 
         break;
 
     case 1: /** append actor to list **/
         if (xs_is_string(actor_md5) && xs_is_hex(actor_md5)) {
             if (!index_in_md5(fn, actor_md5))
                 index_add_md5(fn, actor_md5);
         }
 
         break;
 
     case 2: /** delete actor from list **/
         if (xs_is_string(actor_md5) && xs_is_hex(actor_md5))
             index_del_md5(fn, actor_md5);
 
         break;
 
     default:
         srv_log(xs_fmt("ERROR: list_content: bad op %d", op));
         break;
     }
 
     return l;
 }
 
 
 void list_distribute(snac *user, const char *who, const xs_dict *post)
 /* distributes the post to all appropriate lists */
 {
     const char *id = xs_dict_get(post, "id");
 
     /* if who is not set, use the attributedTo in the message */
     if (xs_is_null(who))
         who = get_atto(post);
 
     if (xs_type(who) == XSTYPE_STRING && xs_type(id) == XSTYPE_STRING) {
         const char *a_md5 = xs_md5(who);
         const char *i_md5 = xs_md5(id);
         xs *spec  = xs_fmt("%s/list/" "*.lst", user->basedir);
         xs *ls    = xs_glob(spec, 0, 0);
         int c = 0;
         const char *v;
 
         while (xs_list_next(ls, &v, &c)) {
             /* is the actor in this list? */
             if (index_in_md5(v, a_md5)) {
                 /* it is; add post md5 to its timeline */
                 xs *idx = xs_replace(v, ".lst", ".idx");
                 index_add_md5(idx, i_md5);
 
                 snac_debug(user, 1, xs_fmt("listed post %s in %s", id, idx));
             }
         }
     }
 }
 
 
 /** static data **/
 
 static int _load_raw_file(FILE *f, xs_val **data, int *size,
                         const char *inm, xs_str **etag, int *mmapped)
 /* loads a cached file */
 {
     int status = HTTP_STATUS_NOT_FOUND;
     *mmapped = 0;
 
     if (f) {
         double tm = mtime_f(f);
 
         if (tm > 0.0) {
             /* file exists; build the etag */
             xs *e = xs_fmt("W/\"snac-%.0lf\"", tm);
 
             /* if if-none-match is set, check if it's the same */
             if (!xs_is_null(inm) && strcmp(e, inm) == 0) {
                 /* client has the newest version */
                 status = HTTP_STATUS_NOT_MODIFIED;
             }
             else {
                 struct stat st;
                 if (fstat(fileno(f), &st) == 0 && (*data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fileno(f), 0)) != MAP_FAILED) {
                     *mmapped = 1;
                     *size = st.st_size;
                 }
                 else {
                     *size = XS_ALL;
                     *data = xs_read(f, size);
                 }
                 /* newer or never downloaded; read the full file */
                 status = HTTP_STATUS_OK;
             }
 
             /* if caller wants the etag, return it */
             if (etag != NULL)
                 *etag = xs_dup(e);
         }
 	fclose(f);
     }
 
     return status;
 }
 
 static int _load_raw_file_partial(const char *fn, xs_val **data, int *size,
                                   const char *inm, xs_str **etag, int start, int *end)
 /* loads a cached file */
 {
     int status = HTTP_STATUS_NOT_FOUND;
 
     if (fn) {
         double tm = mtime(fn);
 
         if (tm > 0.0) {
             /* file exists; build the etag */
             xs *e = xs_fmt("W/\"snac-%.0lf\"", tm);
 
             /* if if-none-match is set, check if it's the same */
             if (!xs_is_null(inm) && strcmp(e, inm) == 0) {
                 /* client has the newest version */
                 status = HTTP_STATUS_NOT_MODIFIED;
             }
             else {
                 /* newer or never downloaded; read the full file */
                 FILE *f;
 
                 if ((f = fopen(fn, "rb")) != NULL) {
                     struct stat st;
                     int n;
                     if (fstat(fileno(f), &st) == 0) {
                         *size = st.st_size;
                         if (*end == XS_ALL)
                             *end = *size - 1;
                     } else {
                         *size = XS_ALL;
                     }
 
                     n = *end == XS_ALL ? XS_ALL : *end - start + 1;
 
                     if (*end != XS_ALL && *end > *size)
                         status = HTTP_STATUS_RANGE_NOT_SATISFIABLE;
                     else
                     if (start > *size || fseek(f, start, SEEK_SET) != 0)
                         status = HTTP_STATUS_RANGE_NOT_SATISFIABLE;
                     else
                         *data = xs_read(f, &n);
 
                     *end = (n + start - 1);
                     fclose(f);
 
                     if (status == HTTP_STATUS_NOT_FOUND)
                         status = HTTP_STATUS_PARTIAL_CONTENT;
                 }
             }
 
             /* if caller wants the etag, return it */
             if (etag != NULL)
                 *etag = xs_dup(e);
 
             srv_debug(1, xs_fmt("_load_raw_file(): %s %d", fn, status));
         }
     }
 
     return status;
 }
 
 
 xs_str *_static_fn(snac *snac, const char *id)
 /* gets the filename for a static file */
 {
     if (strchr(id, '/'))
         return NULL;
     else
         return xs_fmt("%s/static/%s", snac->basedir, id);
 }
 
 
 int static_get(snac *snac, const char *id, xs_val **data, int *size,
                 const char *inm, xs_str **etag, int *mmapped)
 /* returns static content */
 {
     return _load_raw_file(user_open_subfile(snac, "static", id, 0), data, size, inm, etag, mmapped);
 }
 
 int static_get_partial(snac *snac, const char *id, xs_val **data, int *size,
                        const char *inm, xs_str **etag, int start, int *end)
 /* returns static content */
 {
     xs *fn = _static_fn(snac, id);
 
     return _load_raw_file_partial(fn, data, size, inm, etag, start, end);
 }
 
 
 void static_put(snac *snac, const char *id, const char *data, int size)
 /* writes status content */
 {
     xs *fn = _static_fn(snac, id);
     FILE *f;
 
     if (fn && (f = fopen(fn, "wb")) != NULL) {
         fwrite(data, size, 1, f);
         fclose(f);
     }
 }
 
 
 void static_put_meta(snac *snac, const char *id, const char *str)
 /* puts metadata (i.e. a media description string) to id */
 {
     xs *fn = _static_fn(snac, id);
 
     if (fn) {
         fn = xs_str_cat(fn, ".txt");
         FILE *f;
 
         if ((f = fopen(fn, "w")) != NULL) {
             fprintf(f, "%s\n", str);
             fclose(f);
         }
     }
 }
 
 
 xs_str *static_get_meta(snac *snac, const char *id)
 /* gets metadata from a media */
 {
     xs *fn    = _static_fn(snac, id);
     xs_str *r = NULL;
 
     if (fn) {
         fn = xs_str_cat(fn, ".txt");
         FILE *f;
 
         if ((f = fopen(fn, "r")) != NULL) {
             r = xs_strip_i(xs_readline(f));
             fclose(f);
         }
     }
     else
         r = xs_str_new("");
 
     return r;
 }
 
 
 /** history **/
 
 xs_str *_history_fn(snac *snac, const char *id)
 /* gets the filename for the history */
 {
     if (strchr(id, '/'))
         return NULL;
     else
         return xs_fmt("%s/history/%s", snac->basedir, id);
 }
 
 
 double history_mtime(snac *snac, const char *id)
 {
     double t = 0.0;
     xs *fn = _history_fn(snac, id);
 
     if (fn != NULL)
         t = mtime(fn);
 
     return t;
 }
 
 
 void history_add(snac *snac, const char *id, const char *content, int size,
                     xs_str **etag)
 /* adds something to the history */
 {
     xs *fn = _history_fn(snac, id);
     FILE *f;
 
     if (fn && (f = fopen(fn, "w")) != NULL) {
         fwrite(content, size, 1, f);
         fclose(f);
 
         if (etag) {
             double tm = mtime(fn);
             *etag = xs_fmt("W/\"snac-%.0lf\"", tm);
         }
     }
 }
 
 
 int history_get(snac *snac, const char *id, xs_str **content, int *size,
                 const char *inm, xs_str **etag, int *mmapped)
 {
     return _load_raw_file(user_open_subfile(snac, "history", id, 0), content, size, inm, etag, mmapped);
 }
 
 
 int history_del(snac *snac, const char *id)
 {
     xs *fn = _history_fn(snac, id);
 
     if (fn)
         return unlink(fn);
     else
         return -1;
 }
 
 
 xs_list *history_list(snac *snac)
 {
     xs *spec = xs_fmt("%s/history/" "*.html", snac->basedir);
 
     return xs_glob(spec, 1, 1);
 }
 
 
 void lastlog_write(snac *snac, const char *source)
 /* writes the last time the user logged in */
 {
     xs *fn = xs_fmt("%s/lastlog.txt", snac->basedir);
     FILE *f;
 
     if ((f = fopen(fn, "w")) != NULL) {
         fprintf(f, "%lf %s\n", ftime(), source);
         fclose(f);
     }
 }
 
 
 /** inbox collection **/
 
 void inbox_add(const char *inbox)
 /* collects a shared inbox */
 {
     /* don't collect ourselves */
     if (xs_startswith(inbox, srv_baseurl))
         return;
 
     const char *md5 = xs_md5(inbox);
     xs *fn  = xs_fmt("%s/inbox/%s", srv_basedir, md5);
     FILE *f;
 
     if ((f = fopen(fn, "w")) != NULL) {
         fprintf(f, "%s\n", inbox);
         fclose(f);
     }
 }
 
 
 void inbox_add_by_actor(const xs_dict *actor)
 /* collects an actor's shared inbox, if it has one */
 {
     const char *v;
 
     if (!xs_is_null(v = xs_dict_get(actor, "endpoints")) &&
         !xs_is_null(v = xs_dict_get(v, "sharedInbox"))) {
         /* only collect this inbox if its instance is not blocked */
         if (!is_instance_blocked(v))
             inbox_add(v);
     }
 }
 
 
 xs_list *inbox_list(void)
 /* returns the collected inboxes as a list */
 {
     xs_list *ibl = xs_list_new();
     xs *spec     = xs_fmt("%s/inbox/" "*", srv_basedir);
     xs *files    = xs_glob(spec, 0, 0);
     const xs_val *v;
 
     xs_list_foreach(files, v) {
         FILE *f;
 
         if ((f = fopen(v, "r")) != NULL) {
             xs *line = xs_readline(f);
 
             if (line && *line) {
                 line = xs_strip_i(line);
 
                 if (!is_instance_blocked(line))
                     ibl = xs_list_append(ibl, line);
             }
 
             fclose(f);
         }
     }
 
     return ibl;
 }
 
 
 /** instance-wide operations **/
 
 xs_str *_instance_block_fn(const char *instance)
 {
     xs *s   = xs_replace(instance, "http:/" "/", "");
     xs *s1  = xs_replace(s, "https:/" "/", "");
     xs *l   = xs_split(s1, "/");
     const char *p = xs_list_get(l, 0);
     const char *md5 = xs_md5(p);
 
     return xs_fmt("%s/block/%s", srv_basedir, md5);
 }
 
 
 int is_instance_blocked(const char *instance)
 {
     xs *fn = _instance_block_fn(instance);
 
     return !!(mtime(fn) != 0.0);
 }
 
 
 int instance_block(const char *instance)
 /* blocks a full instance */
 {
     int ret;
 
     /* create the subdir */
     xs *dir = xs_fmt("%s/block/", srv_basedir);
     mkdirx(dir);
 
     if (!is_instance_blocked(instance)) {
         xs *fn = _instance_block_fn(instance);
         FILE *f;
 
         if ((f = fopen(fn, "w")) != NULL) {
             fprintf(f, "%s\n", instance);
             fclose(f);
 
             ret = 0;
         }
         else
             ret = -1;
     }
     else
         ret = -2;
 
     return ret;
 }
 
 
 int instance_unblock(const char *instance)
 /* unblocks a full instance */
 {
     int ret;
 
     if (is_instance_blocked(instance)) {
         xs *fn = _instance_block_fn(instance);
         ret = unlink(fn);
     }
     else
         ret = -2;
 
     return ret;
 }
 
 
 /** operations by content **/
 
 int content_match(const char *file, const xs_dict *msg)
 /* checks if a message's content matches any of the regexes in file */
 /* file format: one regex per line */
 {
     xs *fn = xs_fmt("%s/%s", srv_basedir, file);
     FILE *f;
     int r = 0;
     const char *v = xs_dict_get(msg, "content");
 
     if (xs_type(v) == XSTYPE_STRING && *v) {
         if ((f = fopen(fn, "r")) != NULL) {
             srv_debug(1, xs_fmt("content_match: loading regexes from %s", fn));
 
             /* massage content (strip HTML tags, etc.) */
             xs *c1 = xs_regex_replace(v, "<[^>]+>", " ");
             c1 = xs_regex_replace_i(c1, " {2,}", " ");
             xs *c = xs_utf8_to_lower(c1);
 
             while (!r && !feof(f)) {
                 xs *rx = xs_strip_i(xs_readline(f));
 
                 if (*rx && xs_regex_match(c, rx)) {
                     srv_debug(1, xs_fmt("content_match: match for '%s'", rx));
                     r = 1;
                 }
             }
 
             fclose(f);
         }
     }
 
     return r;
 }
 
 
 xs_list *content_search(snac *user, const char *regex,
                 int priv, int skip, int show, int max_secs, int *timeout)
 /* returns a list of posts which content matches the regex */
 {
     if (regex == NULL || *regex == '\0')
         return xs_list_new();
 
     xs *i_regex = xs_utf8_to_lower(regex);
 
     xs_set seen;
 
     xs_set_init(&seen);
 
     if (max_secs == 0)
         max_secs = 3;
 
     time_t t = time(NULL) + max_secs;
     *timeout = 0;
 
     /* iterate all timelines simultaneously */
     xs_list *tls[3] = {0};
     const char *md5s[3] = {0};
     int c[3] = {0};
 
     tls[0] = timeline_simple_list(user, "public", 0, XS_ALL, NULL);   /* public */
     tls[1] = timeline_instance_list(0, XS_ALL); /* instance */
     tls[2] = priv ? timeline_simple_list(user, "private", 0, XS_ALL, NULL) : xs_list_new(); /* private or none */
 
     /* first positioning */
     for (int n = 0; n < 3; n++)
         xs_list_next(tls[n], &md5s[n], &c[n]);
 
     show += skip;
 
     while (show > 0) {
         /* timeout? */
         if (time(NULL) > t) {
             *timeout = 1;
             break;
         }
 
         /* find the newest post */
         int newest = -1;
         double mtime = 0.0;
 
         for (int n = 0; n < 3; n++) {
             if (md5s[n] != NULL) {
                 xs *fn = _object_fn_by_md5(md5s[n], "content_search");
                 double mt;
 
                 while ((mt = mtime(fn)) == 0 && md5s[n] != NULL) {
                     /* object is not here: move to the next one */
                     if (xs_list_next(tls[n], &md5s[n], &c[n])) {
                         xs_free(fn);
                         fn = _object_fn_by_md5(md5s[n], "content_search_2");
                     }
                     else
                         md5s[n] = NULL;
                 }
 
                 if (mt > mtime) {
                     newest = n;
                     mtime = mt;
                 }
             }
         }
 
         if (newest == -1)
             break;
 
         const char *md5 = md5s[newest];
 
         /* advance the chosen timeline */
         if (!xs_list_next(tls[newest], &md5s[newest], &c[newest]))
             md5s[newest] = NULL;
 
         xs *post = NULL;
 
         if (!valid_status(object_get_by_md5(md5, &post)))
             continue;
 
         if (!xs_match(xs_dict_get_def(post, "type", "-"), POSTLIKE_OBJECT_TYPE))
             continue;
 
         const char *id = xs_dict_get(post, "id");
 
         if (id == NULL || is_hidden(user, id))
             continue;
 
         /* recalculate the md5 id to be sure it's not repeated
            (it may have been searched by the "url" field instead of "id") */
         md5 = xs_md5(id);
 
         /* test for the post URL */
         if (strcmp(id, regex) == 0) {
             if (xs_set_add(&seen, md5) == 1)
                 show--;
 
             continue;
         }
 
         /* test for the alternate post id */
         const char *url = xs_dict_get(post, "url");
         if (xs_type(url) == XSTYPE_STRING && strcmp(url, regex) == 0) {
             if (xs_set_add(&seen, md5) == 1)
                 show--;
 
             continue;
         }
 
         xs *c = xs_str_new(NULL);
         const char *content = xs_dict_get(post, "content");
         const char *name    = xs_dict_get(post, "name");
 
         if (!xs_is_null(content))
             c = xs_str_cat(c, content);
         if (!xs_is_null(name))
             c = xs_str_cat(c, " ", name);
 
         /* add alt-texts from attachments */
         const xs_list *atts = xs_dict_get(post, "attachment");
         int tc = 0;
         const xs_dict *att;
 
         while (xs_list_next(atts, &att, &tc)) {
             const char *name = xs_dict_get(att, "name");
 
             if (name != NULL)
                 c = xs_str_cat(c, " ", name);
         }
 
         /* strip HTML */
         c = xs_regex_replace_i(c, "<[^>]+>", " ");
         c = xs_regex_replace_i(c, " {2,}", " ");
 
         /* convert to lowercase */
         xs *lc = xs_utf8_to_lower(c);
 
         /* apply regex */
         if (xs_regex_match(lc, i_regex)) {
             if (xs_set_add(&seen, md5) == 1)
             show--;
         }
     }
 
     xs_list *r = xs_set_result(&seen);
 
     if (skip) {
         /* BAD */
         while (skip--) {
             r = xs_list_del(r, 0);
         }
     }
 
     xs_free(tls[0]);
     xs_free(tls[1]);
     xs_free(tls[2]);
 
     return r;
 }
 
 
 /** notifications **/
 
 xs_str *notify_check_time(snac *snac, int reset)
 /* gets or resets the latest notification check time */
 {
     xs_str *t = NULL;
     xs *fn    = xs_fmt("%s/notifydate.txt", snac->basedir);
     FILE *f;
 
     if (reset) {
         if ((f = fopen(fn, "w")) != NULL) {
             t = tid(0);
             fprintf(f, "%s\n", t);
             fclose(f);
         }
     }
     else {
         if ((f = fopen(fn, "r")) != NULL) {
             t = xs_readline(f);
             fclose(f);
         }
         else
             /* never set before */
             t = xs_fmt("%16.6f", 0.0);
     }
 
     return t;
 }
 
 xs_dict *markers_get(snac *snac, const xs_list *markers)
 {
     xs *data = NULL;
     xs_dict *returns = xs_dict_new();
     xs *fn = xs_fmt("%s/markers.json", snac->basedir);
     const xs_str *v = NULL;
     FILE *f;
 
     if ((f = fopen(fn, "r")) != NULL) {
         data = xs_json_load(f);
         fclose(f);
     }
 
     if (xs_is_null(data))
         data = xs_dict_new();
 
     xs_list_foreach(markers, v) {
         const xs_dict *mark = xs_dict_get(data, v);
         if (!xs_is_null(mark)) {
             returns = xs_dict_append(returns, v, mark);
         }
     }
     return returns;
 }
 
 xs_dict *markers_set(snac *snac, const char *home_marker, const char *notify_marker)
 /* gets or sets notification marker */
 {
     xs *data = NULL;
     xs_dict *written = xs_dict_new();
     xs *fn = xs_fmt("%s/markers.json", snac->basedir);
     FILE *f;
 
     if ((f = fopen(fn, "r")) != NULL) {
         data = xs_json_load(f);
         fclose(f);
     }
 
     if (xs_is_null(data))
         data = xs_dict_new();
 
     if (!xs_is_null(home_marker)) {
         xs *home = xs_dict_new();
         xs *s_tid = tid(0);
         home = xs_dict_append(home, "last_read_id", home_marker);
         home = xs_dict_append(home, "version", xs_stock(0));
         home = xs_dict_append(home, "updated_at", s_tid);
         data = xs_dict_set(data, "home", home);
         written = xs_dict_append(written, "home", home);
     }
 
     if (!xs_is_null(notify_marker)) {
         xs *notify = xs_dict_new();
         xs *s_tid = tid(0);
         notify = xs_dict_append(notify, "last_read_id", notify_marker);
         notify = xs_dict_append(notify, "version", xs_stock(0));
         notify = xs_dict_append(notify, "updated_at", s_tid);
         data = xs_dict_set(data, "notifications", notify);
         written = xs_dict_append(written, "notifications", notify);
     }
 
     if ((f = fopen(fn, "w")) != NULL) {
         xs_json_dump(data, 4, f);
         fclose(f);
     }
 
     return written;
 }
 
 void notify_add(snac *snac, const char *type, const char *utype,
                 const char *actor, const char *objid, const xs_dict *msg)
 /* adds a new notification */
 {
     xs *ntid = tid(0);
     xs *fn   = xs_fmt("%s/notify/", snac->basedir);
     xs *date = xs_str_utctime(0, ISO_DATE_SPEC);
     FILE *f;
 
     /* create the directory */
     mkdirx(fn);
     fn = xs_str_cat(fn, ntid);
     fn = xs_str_cat(fn, ".json");
 
     xs *noti = xs_dict_new();
 
     noti = xs_dict_append(noti, "id",    ntid);
     noti = xs_dict_append(noti, "type",  type);
     noti = xs_dict_append(noti, "utype", utype);
     noti = xs_dict_append(noti, "actor", actor);
     noti = xs_dict_append(noti, "date",  date);
     noti = xs_dict_append(noti, "msg",   msg);
 
     if (!xs_is_null(objid))
         noti = xs_dict_append(noti, "objid", objid);
 
     if ((f = fopen(fn, "w")) != NULL) {
         xs_json_dump(noti, 4, f);
         fclose(f);
     }
 
     /* add it to the index if it already exists */
     xs *idx = xs_fmt("%s/notify.idx", snac->basedir);
 
     if (mtime(idx) != 0.0) {
         pthread_mutex_lock(&data_mutex);
 
         if ((f = fopen(idx, "a")) != NULL) {
             fprintf(f, "%-32s\n", ntid);
             fclose(f);
         }
 
         pthread_mutex_unlock(&data_mutex);
     }
 
     if (!xs_is_true(xs_dict_get(srv_config, "disable_notify_webhook")))
         enqueue_notify_webhook(snac, noti, 0);
 }
 
 
 xs_dict *notify_get(snac *snac, const char *id)
 /* gets a notification */
 {
     /* base file */
     xs *fn = xs_fmt("%s/notify/%s", snac->basedir, id);
 
     /* strip spaces and add extension */
     fn = xs_strip_i(fn);
     fn = xs_str_cat(fn, ".json");
 
     FILE *f;
     xs_dict *out = NULL;
 
     if ((f = fopen(fn, "r")) != NULL) {
         out = xs_json_load(f);
         fclose(f);
     }
 
     return out;
 }
 
 
 xs_list *notify_list(snac *snac, int skip, int show)
 /* returns a list of notification ids */
 {
     xs *idx = xs_fmt("%s/notify.idx", snac->basedir);
 
     if (mtime(idx) == 0.0) {
         /* create the index from scratch */
         FILE *f;
 
         pthread_mutex_lock(&data_mutex);
 
         if ((f = fopen(idx, "w")) != NULL) {
             xs *spec = xs_fmt("%s/notify/" "*.json", snac->basedir);
             xs *lst  = xs_glob(spec, 1, 0);
             xs_list *p = lst;
             const char *v;
 
             while (xs_list_iter(&p, &v)) {
                 char *p = strrchr(v, '.');
                 if (p) {
                     *p = '\0';
                     fprintf(f, "%-32s\n", v);
                 }
             }
 
             fclose(f);
         }
 
         pthread_mutex_unlock(&data_mutex);
     }
 
     return index_list_desc(idx, skip, show);
 }
 
 
 int notify_new_num(snac *snac)
 /* counts the number of new notifications */
 {
     xs *t = notify_check_time(snac, 0);
     xs *lst = notify_list(snac, 0, XS_ALL);
     int cnt = 0;
 
     xs_list *p = lst;
     const xs_str *v;
 
     while (xs_list_iter(&p, &v)) {
         xs *id = xs_strip_i(xs_dup(v));
 
         /* old? count no more */
         if (strcmp(id, t) < 0)
             break;
 
         cnt++;
     }
 
     return cnt;
 }
 
 
 void notify_clear(snac *snac)
 /* clears all notifications */
 {
     xs *spec   = xs_fmt("%s/notify/" "*", snac->basedir);
     xs *lst    = xs_glob(spec, 0, 0);
     xs_list *p = lst;
     const xs_str *v;
 
     while (xs_list_iter(&p, &v))
         unlink(v);
 
     xs *idx = xs_fmt("%s/notify.idx", snac->basedir);
 
     if (mtime(idx) != 0.0) {
         pthread_mutex_lock(&data_mutex);
         if (truncate(idx, 0)) {
             fprintf(stderr, "Notification index truncation failed\n");
         }
         pthread_mutex_unlock(&data_mutex);
     }
 }
 
 
 /** the queue **/
 
 static xs_dict *_enqueue_put(const char *fn, xs_dict *msg)
 /* writes safely to the queue */
 {
     xs *tfn = xs_fmt("%s.tmp", fn);
     FILE *f;
 
     if ((f = fopen(tfn, "w")) != NULL) {
         xs_json_dump(msg, 4, f);
         fclose(f);
 
         rename(tfn, fn);
     }
 
     return msg;
 }
 
 
 static xs_dict *_new_qmsg(const char *type, const xs_val *msg, int retries)
 /* creates a queue message */
 {
     int qrt  = xs_number_get(xs_dict_get(srv_config, "queue_retry_minutes"));
     xs *ntid = tid(retries * 60 * qrt);
     xs *rn   = xs_number_new(retries);
 
     xs_dict *qmsg = xs_dict_new();
 
     qmsg = xs_dict_append(qmsg, "type",    type);
     qmsg = xs_dict_append(qmsg, "message", msg);
     qmsg = xs_dict_append(qmsg, "retries", rn);
     qmsg = xs_dict_append(qmsg, "ntid",    ntid);
 
     return qmsg;
 }
 
 
 void enqueue_input(snac *snac, const xs_dict *msg, const xs_dict *req, int retries)
 /* enqueues an input message */
 {
     xs *qmsg   = _new_qmsg("input", msg, retries);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", snac->basedir, ntid);
 
     qmsg = xs_dict_append(qmsg, "req", req);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     snac_debug(snac, 1, xs_fmt("enqueue_input %s", xs_dict_get(msg, "id")));
 }
 
 
 void enqueue_shared_input(const xs_dict *msg, const xs_dict *req, int retries)
 /* enqueues an input message from the shared input */
 {
     xs *qmsg   = _new_qmsg("input", msg, retries);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
 
     qmsg = xs_dict_append(qmsg, "req", req);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     srv_debug(1, xs_fmt("enqueue_shared_input %s", xs_dict_get(msg, "id")));
 }
 
 
 void enqueue_output_raw(const char *keyid, const char *seckey,
                         const xs_dict *msg, const xs_str *inbox,
                         int retries, int p_status)
 /* enqueues an output message to an inbox */
 {
     xs *qmsg   = _new_qmsg("output", msg, retries);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
 
     xs *ns = xs_number_new(p_status);
     qmsg = xs_dict_append(qmsg, "p_status", ns);
 
     qmsg = xs_dict_append(qmsg, "inbox",  inbox);
     qmsg = xs_dict_append(qmsg, "keyid",  keyid);
     qmsg = xs_dict_append(qmsg, "seckey", seckey);
 
     /* if it's to be sent right now, bypass the disk queue and post the job */
     if (retries == 0 && p_state != NULL)
         job_post(qmsg, 0);
     else {
         qmsg = _enqueue_put(fn, qmsg);
         srv_debug(1, xs_fmt("enqueue_output %s %s %d", inbox, fn, retries));
     }
 }
 
 
 void enqueue_output(snac *snac, const xs_dict *msg,
                     const xs_str *inbox, int retries, int p_status)
 /* enqueues an output message to an inbox */
 {
     if (xs_startswith(inbox, snac->actor)) {
         snac_debug(snac, 1, xs_str_new("refusing enqueue to myself"));
         return;
     }
 
     const char *seckey = xs_dict_get(snac->key, "secret");
 
     enqueue_output_raw(snac->actor, seckey, msg, inbox, retries, p_status);
 }
 
 
 void enqueue_output_by_actor(snac *snac, const xs_dict *msg,
                             const xs_str *actor, int retries)
 /* enqueues an output message for an actor */
 {
     xs *inbox = get_actor_inbox(actor, 1);
 
     if (!xs_is_null(inbox))
         enqueue_output(snac, msg, inbox, retries, 0);
     else
         snac_log(snac, xs_fmt("enqueue_output_by_actor cannot get inbox %s", actor));
 }
 
 
 void enqueue_email(const xs_dict *msg, int retries)
 /* enqueues an email message to be sent */
 {
     xs *qmsg   = _new_qmsg("email", msg, retries);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     srv_debug(1, xs_fmt("enqueue_email %d", retries));
 }
 
 
 void enqueue_telegram(const xs_str *msg, const char *bot, const char *chat_id)
 /* enqueues a message to be sent via Telegram */
 {
     xs *qmsg   = _new_qmsg("telegram", msg, 0);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
 
     qmsg = xs_dict_append(qmsg, "bot",      bot);
     qmsg = xs_dict_append(qmsg, "chat_id",  chat_id);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     srv_debug(1, xs_fmt("enqueue_telegram %s %s", bot, chat_id));
 }
 
 void enqueue_ntfy(const xs_str *msg, const char *ntfy_server, const char *ntfy_token)
 /* enqueues a message to be sent via ntfy */
 {
     xs *qmsg   = _new_qmsg("ntfy", msg, 0);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
 
     qmsg = xs_dict_append(qmsg, "ntfy_server", ntfy_server);
     qmsg = xs_dict_append(qmsg, "ntfy_token",  ntfy_token);
 
 
     qmsg = _enqueue_put(fn, qmsg);
 
     srv_debug(1, xs_fmt("enqueue_ntfy %s %s", ntfy_server, ntfy_token));
 }
 
 void enqueue_message(snac *snac, const xs_dict *msg)
 /* enqueues an output message */
 {
     xs *qmsg   = _new_qmsg("message", msg, 0);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", snac->basedir, ntid);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     snac_debug(snac, 0, xs_fmt("enqueue_message %s", xs_dict_get(msg, "id")));
 }
 
 
 void enqueue_close_question(snac *user, const char *id, int end_secs)
 /* enqueues the closing of a question */
 {
     xs *qmsg = _new_qmsg("close_question", id, 0);
     xs *ntid = tid(end_secs);
     xs *fn   = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
 
     qmsg = xs_dict_set(qmsg, "ntid", ntid);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     snac_debug(user, 0, xs_fmt("enqueue_close_question %s", id));
 }
 
 
 void enqueue_object_request(snac *user, const char *id, int forward_secs)
 /* enqueues the request of an object in the future */
 {
     xs *qmsg = _new_qmsg("object_request", id, 0);
     xs *ntid = tid(forward_secs);
     xs *fn   = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
 
     qmsg = xs_dict_set(qmsg, "ntid", ntid);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     snac_debug(user, 0, xs_fmt("enqueue_object_request %s %d", id, forward_secs));
 }
 
 
 void enqueue_verify_links(snac *user)
 /* enqueues a link verification */
 {
     xs *qmsg   = _new_qmsg("verify_links", "", 0);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     snac_debug(user, 1, xs_fmt("enqueue_verify_links %s", user->actor));
 }
 
 
 void enqueue_actor_refresh(snac *user, const char *actor, int forward_secs)
 /* enqueues an actor refresh */
 {
     xs *qmsg = _new_qmsg("actor_refresh", "", 0);
     xs *ntid = tid(forward_secs);
     xs *fn   = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
 
     qmsg = xs_dict_set(qmsg, "ntid", ntid);
     qmsg = xs_dict_append(qmsg, "actor", actor);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     snac_debug(user, 1, xs_fmt("enqueue_actor_refresh %s", actor));
 }
 
 
 void enqueue_webmention(const xs_dict *msg)
 /* enqueues a webmention for the post */
 {
     xs *qmsg   = _new_qmsg("webmention", msg, 0);
     const char *ntid = xs_dict_get(qmsg, "ntid");
     xs *fn     = xs_fmt("%s/queue/%s.json", srv_basedir, ntid);
 
     qmsg = _enqueue_put(fn, qmsg);
 
     srv_debug(1, xs_fmt("enqueue_webmention"));
 }
 
 
 void enqueue_notify_webhook(snac *user, const xs_dict *noti, int retries)
 /* enqueues a notification webhook */
 {
     const char *webhook = xs_dict_get(user->config, "notify_webhook");
 
     if (xs_is_string(webhook) && xs_match(webhook, "https://*|http://*")) { /** **/
         xs *msg = xs_dup(noti);
 
         /* add more data */
         msg = xs_dict_set(msg, "target", user->actor);
         msg = xs_dict_set(msg, "uid", user->uid);
         msg = xs_dict_set(msg, "basedir", srv_basedir);
         msg = xs_dict_set(msg, "baseurl", srv_baseurl);
 
         xs *actor_obj = NULL;
 
         if (valid_status(object_get(xs_dict_get(noti, "actor"), &actor_obj)) && actor_obj)
             msg = xs_dict_set(msg, "account", actor_obj);
 
         xs *qmsg = _new_qmsg("notify_webhook", msg, retries);
         const char *ntid = xs_dict_get(qmsg, "ntid");
         xs *fn   = xs_fmt("%s/queue/%s.json", user->basedir, ntid);
 
         qmsg = _enqueue_put(fn, qmsg);
 
         snac_debug(user, 1, xs_fmt("notify_webhook"));
     }
 }
 
 
 int was_question_voted(snac *user, const char *id)
 /* returns true if the user voted in this poll */
 {
     xs *children = object_children(id);
     int voted = 0;
     xs_list *p;
     const xs_str *md5;
 
     p = children;
     while (xs_list_iter(&p, &md5)) {
         xs *obj = NULL;
 
         if (valid_status(object_get_by_md5(md5, &obj))) {
             const char *atto = get_atto(obj);
             if (atto && strcmp(atto, user->actor) == 0 &&
                 !xs_is_null(xs_dict_get(obj, "name"))) {
                 voted = 1;
                 break;
             }
         }
     }
 
     return voted;
 }
 
 
 xs_list *user_queue(snac *snac)
 /* returns a list with filenames that can be dequeued */
 {
     xs *spec      = xs_fmt("%s/queue/" "*.json", snac->basedir);
     xs_list *list = xs_list_new();
     time_t t      = time(NULL);
     xs_list *p;
     const xs_val *v;
 
     xs *fns = xs_glob(spec, 0, 0);
 
     p = fns;
     while (xs_list_iter(&p, &v)) {
         /* get the retry time from the basename */
         char *bn  = strrchr(v, '/');
         time_t t2 = atol(bn + 1);
 
         if (t2 > t)
             snac_debug(snac, 2, xs_fmt("user_queue not yet time for %s [%ld]", v, t));
         else {
             list = xs_list_append(list, v);
             snac_debug(snac, 2, xs_fmt("user_queue ready for %s", v));
         }
     }
 
     return list;
 }
 
 
 xs_list *queue(void)
 /* returns a list with filenames that can be dequeued */
 {
     xs *spec      = xs_fmt("%s/queue/" "*.json", srv_basedir);
     xs_list *list = xs_list_new();
     time_t t      = time(NULL);
     xs_list *p;
     const xs_val *v;
 
     xs *fns = xs_glob(spec, 0, 0);
 
     p = fns;
     while (xs_list_iter(&p, &v)) {
         /* get the retry time from the basename */
         char *bn  = strrchr(v, '/');
         time_t t2 = atol(bn + 1);
 
         if (t2 > t)
             srv_debug(2, xs_fmt("queue not yet time for %s [%ld]", v, t));
         else {
             list = xs_list_append(list, v);
             srv_debug(2, xs_fmt("queue ready for %s", v));
         }
     }
 
     return list;
 }
 
 
 xs_dict *queue_get(const char *fn)
 /* gets a file from a queue */
 {
     FILE *f;
     xs_dict *obj = NULL;
 
     if ((f = fopen(fn, "r")) != NULL) {
         obj = xs_json_load(f);
         fclose(f);
     }
 
     return obj;
 }
 
 
 xs_dict *dequeue(const char *fn)
 /* dequeues a message */
 {
     xs_dict *obj = queue_get(fn);
 
     unlink(fn);
 
     return obj;
 }
 
 
 /** the purge **/
 
 static int _purge_file(const char *fn, time_t mt)
 /* purge fn if it's older than days */
 {
     int ret = 0;
 
     if (mtime(fn) < mt) {
         /* older than the minimum time: delete it */
         unlink(fn);
         srv_debug(2, xs_fmt("purged %s", fn));
         ret = 1;
     }
 
     return ret;
 }
 
 
 static void _purge_dir(const char *dir, int days)
 /* purges all files in a directory older than days */
 {
     int cnt = 0;
 
     if (days) {
         time_t mt = time(NULL) - days * 24 * 3600;
         xs *spec  = xs_fmt("%s/" "*", dir);
         xs *list  = xs_glob(spec, 0, 0);
         xs_list *p;
         const xs_str *v;
 
         p = list;
         while (xs_list_iter(&p, &v))
             cnt += _purge_file(v, mt);
 
         srv_debug(1, xs_fmt("purge: %s %d", dir, cnt));
     }
 }
 
 
 static void _purge_user_subdir(snac *snac, const char *subdir, int days)
 /* purges all files in a user subdir older than days */
 {
     xs *u_subdir = xs_fmt("%s/%s", snac->basedir, subdir);
 
     _purge_dir(u_subdir, days);
 }
 
 
 void purge_server(void)
 /* purge global server data */
 {
     xs *spec = xs_fmt("%s/object/??", srv_basedir);
     xs *dirs = xs_glob(spec, 0, 0);
     xs_list *p;
     const xs_str *v;
     int cnt = 0;
     int icnt = 0;
 
     time_t mt = time(NULL) - 7 * 24 * 3600;
 
     p = dirs;
     while (xs_list_iter(&p, &v)) {
         xs_list *p2;
         const xs_str *v2;
 
         {
             xs *spec2 = xs_fmt("%s/" "*.json", v);
             xs *files = xs_glob(spec2, 0, 0);
 
             p2 = files;
             while (xs_list_iter(&p2, &v2)) {
                 int n_link;
 
                 /* old and with no hard links? */
                 if (mtime_nl(v2, &n_link) < mt && n_link < 2) {
                     xs *s1    = xs_replace(v2, ".json", "");
                     xs *l     = xs_split(s1, "/");
                     const char *md5 = xs_list_get(l, -1);
 
                     object_del_by_md5(md5);
                     cnt++;
                 }
             }
         }
 
         {
             /* look for stray indexes */
             xs *speci = xs_fmt("%s/" "*_?.idx", v);
             xs *idxfs = xs_glob(speci, 0, 0);
 
             p2 = idxfs;
             while (xs_list_iter(&p2, &v2)) {
                 /* old enough to consider? */
                 if (mtime(v2) < mt) {
                     /* check if the indexed object is here */
                     xs *o = xs_dup(v2);
                     char *ext = strchr(o, '_');
 
                     if (ext) {
                         *ext = '\0';
                         o = xs_str_cat(o, ".json");
 
                         if (mtime(o) == 0.0) {
                             /* delete */
                             unlink(v2);
                             srv_debug(1, xs_fmt("purged %s", v2));
                             icnt++;
                         }
                     }
                 }
             }
 
             /* delete index backups */
             xs *specb = xs_fmt("%s/" "*.bak", v);
             xs *bakfs = xs_glob(specb, 0, 0);
 
             p2 = bakfs;
             while (xs_list_iter(&p2, &v2)) {
                 unlink(v2);
                 srv_debug(1, xs_fmt("purged %s", v2));
             }
         }
     }
 
     /* purge collected inboxes */
     xs *ib_dir = xs_fmt("%s/inbox", srv_basedir);
     _purge_dir(ib_dir, 7);
 
     /* purge the instance timeline */
     xs *itl_fn = xs_fmt("%s/public.idx", srv_basedir);
     int itl_gc = index_gc(itl_fn);
 
     /* purge tag indexes */
     xs *tag_spec = xs_fmt("%s/tag/??", srv_basedir);
     xs *tag_dirs = xs_glob(tag_spec, 0, 0);
     p = tag_dirs;
 
     int tag_gc = 0;
     while (xs_list_iter(&p, &v)) {
         xs *spec2 = xs_fmt("%s/" "*.idx", v);
         xs *files = xs_glob(spec2, 0, 0);
         xs_list *p2;
         const xs_str *v2;
 
         p2 = files;
         while (xs_list_iter(&p2, &v2)) {
             tag_gc += index_gc(v2);
             xs *bak = xs_fmt("%s.bak", v2);
             unlink(bak);
 
             if (index_len(v2) == 0) {
                 /* there are no longer any entry with this tag;
                    purge it completely */
                 unlink(v2);
                 xs *dottag = xs_replace(v2, ".idx", ".tag");
                 unlink(dottag);
             }
         }
     }
 
     srv_debug(1, xs_fmt("purge: global "
             "(obj: %d, idx: %d, itl: %d, tag: %d)", cnt, icnt, itl_gc, tag_gc));
 }
 
 
 void purge_user(snac *snac)
 /* do the purge for this user */
 {
     int priv_days, pub_days, user_days = 0;
     const char *v;
     int n;
 
     priv_days = xs_number_get(xs_dict_get(srv_config, "timeline_purge_days"));
     pub_days  = xs_number_get(xs_dict_get(srv_config, "local_purge_days"));
 
     if ((v = xs_dict_get(snac->config_o, "purge_days")) != NULL ||
         (v = xs_dict_get(snac->config, "purge_days")) != NULL)
         user_days = xs_number_get(v);
 
     if (user_days) {
         /* override admin settings only if they are lesser */
         if (priv_days == 0 || user_days < priv_days)
             priv_days = user_days;
 
         if (pub_days == 0 || user_days < pub_days)
             pub_days = user_days;
     }
 
     _purge_user_subdir(snac, "hidden",  priv_days);
     _purge_user_subdir(snac, "private", priv_days);
 
     _purge_user_subdir(snac, "public",  pub_days);
 
     const char *idxs[] = { "followers.idx", "private.idx", "public.idx",
                            "pinned.idx", "bookmark.idx", "draft.idx", "sched.idx", NULL };
 
     for (n = 0; idxs[n]; n++) {
         xs *idx = xs_fmt("%s/%s", snac->basedir, idxs[n]);
         int gc = index_gc(idx);
         srv_debug(1, xs_fmt("purge: %s %d", idx, gc));
     }
 
     /* purge lists */
     {
         xs *spec = xs_fmt("%s/list/" "*.idx", snac->basedir);
         xs *lol  = xs_glob(spec, 0, 0);
         int c = 0;
         const char *v;
 
         while (xs_list_next(lol, &v, &c)) {
             int gc = index_gc(v);
             srv_debug(1, xs_fmt("purge: %s %d", v, gc));
         }
     }
 
     /* unrelated to purging, but it's a janitorial process, so what the hell */
     verify_links(snac);
 }
 
 
 void purge_all(void)
 /* purge all users */
 {
     snac snac;
     xs *list = user_list();
     char *p;
     const char *uid;
 
     p = list;
     while (xs_list_iter(&p, &uid)) {
         if (user_open(&snac, uid)) {
             purge_user(&snac);
             user_free(&snac);
         }
     }
 
     purge_server();
 
 #ifndef NO_MASTODON_API
     mastoapi_purge();
 #endif
 }
 
 
 /** archive **/
 
 void srv_archive(const char *direction, const char *url, xs_dict *req,
                  const char *payload, int p_size,
                  int status, xs_dict *headers,
                  const char *body, int b_size)
 /* archives a connection */
 {
     /* obsessive archiving */
     xs *date = tid(0);
     xs *dir  = xs_fmt("%s/archive/%s_%s", srv_basedir, date, direction);
     FILE *f;
 
     if (mkdirx(dir) != -1) {
         xs *meta_fn = xs_fmt("%s/_META", dir);
 
         if ((f = fopen(meta_fn, "w")) != NULL) {
             xs *j1 = xs_json_dumps(req, 4);
             xs *j2 = xs_json_dumps(headers, 4);
 
             fprintf(f, "dir: %s\n", direction);
 
             if (url)
                 fprintf(f, "url: %s\n", url);
 
             fprintf(f, "req: %s\n", j1);
             fprintf(f, "p_size: %d\n", p_size);
             fprintf(f, "status: %d\n", status);
             fprintf(f, "response: %s\n", j2);
             fprintf(f, "b_size: %d\n", b_size);
             fclose(f);
         }
 
         if (p_size && payload) {
             xs *payload_fn = NULL;
             xs *payload_fn_raw = NULL;
             const char *v = xs_dict_get(req, "content-type");
 
             if (v && xs_str_in(v, "json") != -1) {
                 payload_fn = xs_fmt("%s/payload.json", dir);
 
                 if ((f = fopen(payload_fn, "w")) != NULL) {
                     xs *v1 = xs_json_loads(payload);
                     xs *j1 = NULL;
 
                     if (v1 != NULL)
                         j1 = xs_json_dumps(v1, 4);
 
                     if (j1 != NULL)
                         fwrite(j1, strlen(j1), 1, f);
                     else
                         fwrite(payload, p_size, 1, f);
 
                     fclose(f);
                 }
             }
 
             payload_fn_raw = xs_fmt("%s/payload", dir);
 
             if ((f = fopen(payload_fn_raw, "w")) != NULL) {
                 fwrite(payload, p_size, 1, f);
                 fclose(f);
             }
         }
 
         if (b_size && body) {
             xs *body_fn = NULL;
             const char *v = xs_dict_get(headers, "content-type");
 
             if (v && xs_str_in(v, "json") != -1) {
                 body_fn = xs_fmt("%s/body.json", dir);
 
                 if ((f = fopen(body_fn, "w")) != NULL) {
                     xs *v1 = xs_json_loads(body);
                     xs *j1 = NULL;
 
                     if (v1 != NULL)
                         j1 = xs_json_dumps(v1, 4);
 
                     if (j1 != NULL)
                         fwrite(j1, strlen(j1), 1, f);
                     else
                         fwrite(body, b_size, 1, f);
 
                     fclose(f);
                 }
             }
             else {
                 body_fn = xs_fmt("%s/body", dir);
 
                 if ((f = fopen(body_fn, "w")) != NULL) {
                     fwrite(body, b_size, 1, f);
                     fclose(f);
                 }
             }
         }
     }
 }
 
 
 void srv_archive_error(const char *prefix, const xs_str *err,
                        const xs_dict *req, const xs_val *data)
 /* archives an error */
 {
     xs *ntid = tid(0);
     xs *fn   = xs_fmt("%s/error/%s_%s", srv_basedir, ntid, prefix);
     FILE *f;
 
     if ((f = fopen(fn, "w")) != NULL) {
         fprintf(f, "Error: %s\n", err);
 
         if (req) {
             fprintf(f, "Request headers:\n");
 
             xs_json_dump(req, 4, f);
 
             fprintf(f, "\n");
         }
 
         if (data) {
             fprintf(f, "Data:\n");
 
             if (xs_type(data) == XSTYPE_LIST || xs_type(data) == XSTYPE_DICT) {
                 xs_json_dump(data, 4, f);
             }
             else
                 fprintf(f, "%s", data);
 
             fprintf(f, "\n");
         }
 
         fclose(f);
     }
 }
 
 
 void srv_archive_qitem(const char *prefix, xs_dict *q_item)
 /* archives a q_item in the error folder */
 {
     xs *ntid = tid(0);
     xs *fn   = xs_fmt("%s/error/%s_qitem_%s", srv_basedir, ntid, prefix);
     FILE *f;
 
     if ((f = fopen(fn, "w")) != NULL) {
         xs_json_dump(q_item, 4, f);
         fclose(f);
     }
 }
 
 
 t_announcement *announcement(const double after)
 /* returns announcement text or NULL if none exists or it is olde than "after" */
 {
     static const long int MAX_SIZE = 2048;
     static t_announcement a = {
         .text = NULL,
         .timestamp = 0.0,
     };
     static xs_str *fn = NULL;
     if (fn == NULL)
         fn = xs_fmt("%s/announcement.txt", srv_basedir);
 
     const double ts = mtime(fn);
 
     /* file does not exist or other than what was requested */
     if (ts == 0.0 || ts <= after)
         return NULL;
 
     /* nothing changed, just return the current announcement */
     if (a.text != NULL && ts <= a.timestamp)
         return &a;
 
     /* read and store new announcement */
     FILE *f;
 
     if ((f = fopen(fn, "r")) != NULL) {
         char buffer[MAX_SIZE];
         int r = fread(buffer, 1, MAX_SIZE, f);
 
         if (r == 0) {
             /* an empty file means no announcement */
             free(a.text);
             a.text = NULL;
             a.timestamp = 0.0;
         }
         else
         if (r <= 0 || !xs_is_string(buffer)) {
             /* this is probably unintentional */
             srv_log(xs_fmt("announcement.txt reading failed"));
         }
         else
         if (r > MAX_SIZE) {
             /* this is probably unintentional */
             srv_log(xs_fmt("announcement.txt too big: max is %ld, ignoring.", MAX_SIZE));
         }
         else {
             buffer[r] = '\0';
             free(a.text);
             a.text = xs_dup(buffer);
             a.timestamp = ts;
         }
 
         fclose (f);
     }
 
     if (a.text != NULL)
         return &a;
 
     return NULL;
 }
 
 
 xs_str *make_url(const char *href, const char *proxy, int by_token)
 /* makes an URL, possibly including proxying */
 {
     xs_str *url = NULL;
 
     if (proxy && !xs_startswith(href, srv_baseurl)) {
         xs *p = NULL;
 
         if (by_token) {
             const char *tk = xs_md5(srv_proxy_token_seed, ":", proxy);
 
             p = xs_fmt("%s/y/%s/", proxy, tk);
         }
         else
             p = xs_fmt("%s/x/", proxy);
 
         url = xs_replace(href, "https:/" "/", p);
     }
     else
         url = xs_dup(href);
 
     return url;
 }
 
 
 /** bad login throttle **/
 
 xs_str *_badlogin_fn(const char *addr)
 {
     const char *md5 = xs_md5(addr);
     xs *dir = xs_fmt("%s/badlogin", srv_basedir);
 
     mkdirx(dir);
 
     return xs_fmt("%s/%s", dir, md5);
 }
 
 
 int _badlogin_read(const char *fn, int *failures)
 /* reads a badlogin file */
 {
     int ok = 0;
     FILE *f;
 
     pthread_mutex_lock(&data_mutex);
 
     if ((f = fopen(fn, "r")) != NULL) {
         xs *l = xs_readline(f);
         fclose(f);
 
         if (sscanf(l, "%d", failures) == 1)
             ok = 1;
     }
 
     pthread_mutex_unlock(&data_mutex);
 
     return ok;
 }
 
 
 int badlogin_check(const char *user, const char *addr)
 /* checks if this address is authorized to try a login */
 {
     int valid = 1;
 
     if (xs_type(addr) == XSTYPE_STRING) {
         xs *fn = _badlogin_fn(addr);
         double mt = mtime(fn);
 
         if (mt > 0) {
             int badlogin_expire = xs_number_get(xs_dict_get_def(srv_config,
                                         "badlogin_expire", "300"));
 
             mt += badlogin_expire;
 
             /* if file is expired, delete and give pass */
             if (mt < time(NULL)) {
                 srv_debug(1, xs_fmt("Login from %s for %s allowed again", addr, user));
                 unlink(fn);
             }
             else {
                 int failures;
 
                 if (_badlogin_read(fn, &failures)) {
                     int badlogin_max = xs_number_get(xs_dict_get_def(srv_config,
                                             "badlogin_retries", "5"));
 
                     if (failures >= badlogin_max) {
                         valid = 0;
 
                         xs *d = xs_str_iso_date((time_t) mt);
 
                         srv_debug(1,
                             xs_fmt("Login from %s for %s forbidden until %s", addr, user, d));
                     }
                 }
             }
         }
     }
 
     return valid;
 }
 
 
 void badlogin_inc(const char *user, const char *addr)
 /* increments a bad login from this address */
 {
     if (xs_type(addr) == XSTYPE_STRING) {
         int failures = 0;
         xs *fn = _badlogin_fn(addr);
         FILE *f;
 
         _badlogin_read(fn, &failures);
 
         pthread_mutex_lock(&data_mutex);
 
         if ((f = fopen(fn, "w")) != NULL) {
             failures++;
 
             fprintf(f, "%d %s %s\n", failures, addr, user);
             fclose(f);
 
             srv_log(xs_fmt("Registered %d login failure(s) from %s for %s", failures, addr, user));
         }
 
         pthread_mutex_unlock(&data_mutex);
     }
 }
 
 
 /** language strings **/
 
 const char *lang_str(const char *str, const snac *user)
 /* returns a translated string */
 {
     const char *n_str = str;
 
     if (user && xs_is_dict(user->lang) && xs_is_string(str)) {
         n_str = xs_dict_get(user->lang, str);
 
         if (xs_is_null(n_str) || *n_str == '\0')
             n_str = str;
     }
 
     return n_str;
 }