chiark - git - mdw - disorder/blob - lib/trackdb.c

   1 /*
   2  * This file is part of DisOrder
   3  * Copyright (C) 2005-2008 Richard Kettlewell
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20 /** @file lib/trackdb.c
  21  * @brief Track database
  22  *
  23  * This file is getting in desparate need of splitting up...
  24  */
  25
  26 #include "common.h"
  27
  28 #include <db.h>
  29 #include <sys/socket.h>
  30 #include <pcre.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <stddef.h>
  34 #include <sys/time.h>
  35 #include <sys/resource.h>
  36 #include <time.h>
  37 #include <arpa/inet.h>
  38 #include <dirent.h>
  39 #include <sys/stat.h>
  40 #include <gcrypt.h>
  41
  42 #include "event.h"
  43 #include "mem.h"
  44 #include "kvp.h"
  45 #include "log.h"
  46 #include "vector.h"
  47 #include "rights.h"
  48 #include "trackdb.h"
  49 #include "configuration.h"
  50 #include "syscalls.h"
  51 #include "wstat.h"
  52 #include "printf.h"
  53 #include "filepart.h"
  54 #include "trackname.h"
  55 #include "trackdb-int.h"
  56 #include "logfd.h"
  57 #include "cache.h"
  58 #include "eventlog.h"
  59 #include "hash.h"
  60 #include "unicode.h"
  61 #include "unidata.h"
  62 #include "base64.h"
  63
  64 #define RESCAN "disorder-rescan"
  65 #define DEADLOCK "disorder-deadlock"
  66
  67 static const char *getpart(const char *track,
  68                            const char *context,
  69                            const char *part,
  70                            const struct kvp *p,
  71                            int *used_db);
  72 static char **trackdb_new_tid(int *ntracksp,
  73                               int maxtracks,
  74                               DB_TXN *tid);
  75 static int trackdb_expire_noticed_tid(time_t earliest, DB_TXN *tid);
  76 static char *normalize_tag(const char *s, size_t ns);
  77
  78 const struct cache_type cache_files_type = { 86400 };
  79 unsigned long cache_files_hits, cache_files_misses;
  80
  81 /** @brief Set by trackdb_open() */
  82 int trackdb_existing_database;
  83
  84 /* setup and teardown ********************************************************/
  85
  86 static const char *home;                /* home had better not change */
  87 DB_ENV *trackdb_env;                    /* db environment */
  88
  89 /** @brief The tracks database
  90  * - Keys are UTF-8(NFC(unicode(path name)))
  91  * - Values are encoded key-value pairs
  92  * - Data is reconstructable data about tracks that currently exist
  93  */
  94 DB *trackdb_tracksdb;
  95
  96 /** @brief The preferences database
  97  *
  98  * - Keys are UTF-8(NFC(unicode(path name)))
  99  * - Values are encoded key-value pairs
 100  * - Data is user data about tracks (that might not exist any more)
 101  * and cannot be reconstructed
 102  */
 103 DB *trackdb_prefsdb;
 104
 105 /** @brief The search database
 106  *
 107  * - Keys are UTF-8(NFKC(casefold(search term)))
 108  * - Values are UTF-8(NFC(unicode(path name)))
 109  * - There can be more than one value per key
 110  * - Presence of key,value means that path matches the search terms
 111  * - Only tracks fond in @ref trackdb_tracksdb are represented here
 112  * - This database can be reconstructed, it contains no user data
 113  */
 114 DB *trackdb_searchdb;
 115
 116 /** @brief The tags database
 117  *
 118  * - Keys are UTF-8(NFKC(casefold(tag)))
 119  * - Values are UTF-8(NFC(unicode(path name)))
 120  * - There can be more than one value per key
 121  * - Presence of key,value means that path matches the tag
 122  * - This is always in sync with the tags preference
 123  * - This database can be reconstructed, it contains no user data
 124  */
 125 DB *trackdb_tagsdb;                     /* the tags database */
 126
 127 /** @brief The global preferences database
 128  * - Keys are UTF-8(NFC(preference))
 129  * - Values are global preference values
 130  * - Data is user data and cannot be reconstructed
 131  */
 132 DB *trackdb_globaldb;                   /* global preferences */
 133
 134 /** @brief The noticed database
 135  * - Keys are 64-bit big-endian timestamps
 136  * - Values are UTF-8(NFC(unicode(path name)))
 137  * - There can be more than one value per key
 138  * - Presence of key,value means that path was added at the given time
 139  * - Data cannot be reconstructed (but isn't THAT important)
 140  */
 141 DB *trackdb_noticeddb;                   /* when track noticed */
 142
 143 /** @brief The schedule database
 144  *
 145  * - Keys are ID strings, generated at random
 146  * - Values are encoded key-value pairs
 147  * - There can be more than one value per key
 148  * - Data cannot be reconstructed
 149  *
 150  * See @ref server/schedule.c for further information.
 151  */
 152 DB *trackdb_scheduledb;
 153
 154 /** @brief The user database
 155  * - Keys are usernames
 156  * - Values are encoded key-value pairs
 157  * - Data is user data and cannot be reconstructed
 158  */
 159 DB *trackdb_usersdb;
 160
 161 static pid_t db_deadlock_pid = -1;      /* deadlock manager PID */
 162 static pid_t rescan_pid = -1;           /* rescanner PID */
 163 static int initialized, opened;         /* state */
 164
 165 /* comparison function for keys */
 166 static int compare(DB attribute((unused)) *db_,
 167                    const DBT *a, const DBT *b) {
 168   return compare_path_raw(a->data, a->size, b->data, b->size);
 169 }
 170
 171 /** @brief Test whether the track database can be read
 172  * @return 1 if it can, 0 if it cannot
 173  */
 174 int trackdb_readable(void) {
 175   char *usersdb;
 176
 177   byte_xasprintf(&usersdb, "%s/users.db", config->home);
 178   return access(usersdb, R_OK) == 0;
 179 }
 180
 181 /** @brief Open database environment
 182  * @param flags Flags word
 183  *
 184  * Flags should be one of:
 185  * - @ref TRACKDB_NO_RECOVER
 186  * - @ref TRACKDB_NORMAL_RECOVER
 187  * - @ref TRACKDB_FATAL_RECOVER
 188  * - @ref TRACKDB_MAY_CREATE
 189  */
 190 void trackdb_init(int flags) {
 191   int err;
 192   const int recover = flags & TRACKDB_RECOVER_MASK;
 193   static int recover_type[] = { 0, DB_RECOVER, DB_RECOVER_FATAL };
 194
 195   /* sanity checks */
 196   assert(initialized == 0);
 197   ++initialized;
 198   if(home) {
 199     if(strcmp(home, config->home))
 200       fatal(0, "cannot change db home without server restart");
 201     home = config->home;
 202   }
 203
 204   if(flags & TRACKDB_MAY_CREATE) {
 205     DIR *dp;
 206     struct dirent *de;
 207     struct stat st;
 208     char *p;
 209
 210     /* Remove world/group permissions on any regular files already in the
 211      * database directory.  Actually we don't care about all of them but it's
 212      * easier to just do the lot.  This can be revisited if it's a serious
 213      * practical inconvenience for anyone.
 214      *
 215      * The socket, not being a regular file, is excepted.
 216      */
 217     if(!(dp = opendir(config->home)))
 218       fatal(errno, "error reading %s", config->home);
 219     while((de = readdir(dp))) {
 220       byte_xasprintf(&p, "%s/%s", config->home, de->d_name);
 221       if(lstat(p, &st) == 0
 222          && S_ISREG(st.st_mode)
 223          && (st.st_mode & 077)) {
 224         if(chmod(p, st.st_mode & 07700) < 0)
 225           fatal(errno, "cannot chmod %s", p);
 226       }
 227       xfree(p);
 228     }
 229     closedir(dp);
 230   }
 231
 232   /* create environment */
 233   if((err = db_env_create(&trackdb_env, 0))) fatal(0, "db_env_create: %s",
 234                                                    db_strerror(err));
 235   if((err = trackdb_env->set_alloc(trackdb_env,
 236                                    xmalloc_noptr, xrealloc_noptr, xfree)))
 237     fatal(0, "trackdb_env->set_alloc: %s", db_strerror(err));
 238   if((err = trackdb_env->set_lk_max_locks(trackdb_env, 10000)))
 239     fatal(0, "trackdb_env->set_lk_max_locks: %s", db_strerror(err));
 240   if((err = trackdb_env->set_lk_max_objects(trackdb_env, 10000)))
 241     fatal(0, "trackdb_env->set_lk_max_objects: %s", db_strerror(err));
 242   if((err = trackdb_env->open(trackdb_env, config->home,
 243                               DB_INIT_LOG
 244                               |DB_INIT_LOCK
 245                               |DB_INIT_MPOOL
 246                               |DB_INIT_TXN
 247                               |DB_CREATE
 248                               |recover_type[recover],
 249                               0600)))
 250     fatal(0, "trackdb_env->open %s: %s", config->home, db_strerror(err));
 251   trackdb_env->set_errpfx(trackdb_env, "DB");
 252   trackdb_env->set_errfile(trackdb_env, stderr);
 253   trackdb_env->set_verbose(trackdb_env, DB_VERB_DEADLOCK, 1);
 254   trackdb_env->set_verbose(trackdb_env, DB_VERB_RECOVERY, 1);
 255   trackdb_env->set_verbose(trackdb_env, DB_VERB_REPLICATION, 1);
 256   D(("initialized database environment"));
 257 }
 258
 259 /* called when deadlock manager terminates */
 260 static int reap_db_deadlock(ev_source attribute((unused)) *ev,
 261                             pid_t attribute((unused)) pid,
 262                             int status,
 263                             const struct rusage attribute((unused)) *rusage,
 264                             void attribute((unused)) *u) {
 265   db_deadlock_pid = -1;
 266   if(initialized)
 267     fatal(0, "deadlock manager unexpectedly terminated: %s",
 268           wstat(status));
 269   else
 270     D(("deadlock manager terminated: %s", wstat(status)));
 271   return 0;
 272 }
 273
 274 static pid_t subprogram(ev_source *ev, int outputfd, const char *prog,
 275                         ...) {
 276   pid_t pid;
 277   va_list ap;
 278   const char *args[1024], **argp, *a;
 279
 280   argp = args;
 281   *argp++ = prog;
 282   *argp++ = "--config";
 283   *argp++ = configfile;
 284   *argp++ = debugging ? "--debug" : "--no-debug";
 285   *argp++ = log_default == &log_syslog ? "--syslog" : "--no-syslog";
 286   va_start(ap, prog);
 287   while((a = va_arg(ap, const char *)))
 288     *argp++ = a;
 289   va_end(ap);
 290   *argp = 0;
 291   /* If we're in the background then trap subprocess stdout/stderr */
 292   if(!(pid = xfork())) {
 293     exitfn = _exit;
 294     if(ev)
 295       ev_signal_atfork(ev);
 296     signal(SIGPIPE, SIG_DFL);
 297     if(outputfd != -1) {
 298       xdup2(outputfd, 1);
 299       xclose(outputfd);
 300     }
 301     /* ensure we don't leak privilege anywhere */
 302     if(setuid(geteuid()) < 0)
 303       fatal(errno, "error calling setuid");
 304     /* If we were negatively niced, undo it.  We don't bother checking for
 305     * error, it's not that important. */
 306     setpriority(PRIO_PROCESS, 0, 0);
 307     execvp(prog, (char **)args);
 308     fatal(errno, "error invoking %s", prog);
 309   }
 310   return pid;
 311 }
 312
 313 /* start deadlock manager */
 314 void trackdb_master(ev_source *ev) {
 315   assert(db_deadlock_pid == -1);
 316   db_deadlock_pid = subprogram(ev, -1, DEADLOCK, (char *)0);
 317   ev_child(ev, db_deadlock_pid, 0, reap_db_deadlock, 0);
 318   D(("started deadlock manager"));
 319 }
 320
 321 /* close environment */
 322 void trackdb_deinit(void) {
 323   int err;
 324
 325   /* sanity checks */
 326   assert(initialized == 1);
 327   --initialized;
 328
 329   /* close the environment */
 330   if((err = trackdb_env->close(trackdb_env, 0)))
 331     fatal(0, "trackdb_env->close: %s", db_strerror(err));
 332
 333   if(rescan_pid != -1) {
 334     /* shut down the rescanner */
 335     if(kill(rescan_pid, SIGTERM) < 0)
 336       fatal(errno, "error killing rescanner");
 337     /* wait for the rescanner to finish */
 338     while(waitpid(rescan_pid, &err, 0) == -1 && errno == EINTR)
 339       ;
 340   }
 341
 342   /* TODO kill any stats subprocesses */
 343
 344   /* finally terminate the deadlock manager */
 345   if(db_deadlock_pid != -1 && kill(db_deadlock_pid, SIGTERM) < 0)
 346     fatal(errno, "error killing deadlock manager");
 347   db_deadlock_pid = -1;
 348
 349   D(("deinitialized database environment"));
 350 }
 351
 352 /* open a specific database */
 353 static DB *open_db(const char *path,
 354                    u_int32_t dbflags,
 355                    DBTYPE dbtype,
 356                    u_int32_t openflags,
 357                    int mode) {
 358   int err;
 359   DB *db;
 360
 361   D(("open %s", path));
 362   path = config_get_file(path);
 363   if((err = db_create(&db, trackdb_env, 0)))
 364     fatal(0, "db_create %s: %s", path, db_strerror(err));
 365   if(dbflags)
 366     if((err = db->set_flags(db, dbflags)))
 367       fatal(0, "db->set_flags %s: %s", path, db_strerror(err));
 368   if(dbtype == DB_BTREE)
 369     if((err = db->set_bt_compare(db, compare)))
 370       fatal(0, "db->set_bt_compare %s: %s", path, db_strerror(err));
 371   if((err = db->open(db, 0, path, 0, dbtype,
 372                      openflags | DB_AUTO_COMMIT, mode))) {
 373     if((openflags & DB_CREATE) || errno != ENOENT)
 374       fatal(0, "db->open %s: %s", path, db_strerror(err));
 375     db->close(db, 0);
 376     db = 0;
 377   }
 378   return db;
 379 }
 380
 381 /** @brief Open track databases
 382  * @param flags Flags flags word
 383  *
 384  * @p flags should have one of:
 385  * - @p TRACKDB_NO_UPGRADE, if no upgrade should be attempted
 386  * - @p TRACKDB_CAN_UPGRADE, if an upgrade may be attempted
 387  * - @p TRACKDB_OPEN_FOR_UPGRADE, if this is disorder-dbupgrade
 388  * Also it may have:
 389  * - @p TRACKDB_READ_ONLY, read only access
 390  */
 391 void trackdb_open(int flags) {
 392   int err;
 393   pid_t pid;
 394   uint32_t dbflags = flags & TRACKDB_READ_ONLY ? DB_RDONLY : DB_CREATE;
 395
 396   /* sanity checks */
 397   assert(opened == 0);
 398   ++opened;
 399   /* check the database version first */
 400   trackdb_globaldb = open_db("global.db", 0, DB_HASH, DB_RDONLY, 0666);
 401   if(trackdb_globaldb) {
 402     /* This is an existing database */
 403     const char *s;
 404     long oldversion;
 405
 406     s = trackdb_get_global("_dbversion");
 407     /* Close the database again,  we'll open it property below */
 408     if((err = trackdb_globaldb->close(trackdb_globaldb, 0)))
 409       fatal(0, "error closing global.db: %s", db_strerror(err));
 410     trackdb_globaldb = 0;
 411     /* Convert version string to an integer */
 412     oldversion = s ? atol(s) : 1;
 413     if(oldversion > config->dbversion) {
 414       /* Database is from the future; we never allow this. */
 415       fatal(0, "this version of DisOrder is too old for database version %ld",
 416             oldversion);
 417     }
 418     if(oldversion < config->dbversion) {
 419       /* Database version is out of date */
 420       switch(flags & TRACKDB_UPGRADE_MASK) {
 421       case TRACKDB_NO_UPGRADE:
 422         /* This database needs upgrading but this is not permitted */
 423         fatal(0, "database needs upgrading from %ld to %ld",
 424               oldversion, config->dbversion);
 425       case TRACKDB_CAN_UPGRADE:
 426         /* This database needs upgrading */
 427         info("invoking disorder-dbupgrade to upgrade from %ld to %ld",
 428              oldversion, config->dbversion);
 429         pid = subprogram(0, -1, "disorder-dbupgrade", (char *)0);
 430         while(waitpid(pid, &err, 0) == -1 && errno == EINTR)
 431           ;
 432         if(err)
 433           fatal(0, "disorder-dbupgrade %s", wstat(err));
 434         info("disorder-dbupgrade succeeded");
 435         break;
 436       case TRACKDB_OPEN_FOR_UPGRADE:
 437         break;
 438       default:
 439         abort();
 440       }
 441     }
 442     if(oldversion == config->dbversion && (flags & TRACKDB_OPEN_FOR_UPGRADE)) {
 443       /* This doesn't make any sense */
 444       fatal(0, "database is already at current version");
 445     }
 446     trackdb_existing_database = 1;
 447   } else {
 448     if(flags & TRACKDB_OPEN_FOR_UPGRADE) {
 449       /* Cannot upgrade a new database */
 450       fatal(0, "cannot upgrade a database that does not exist");
 451     }
 452     /* This is a brand new database */
 453     trackdb_existing_database = 0;
 454   }
 455   /* open the databases */
 456   if(!(trackdb_usersdb = open_db("users.db",
 457                                  0, DB_HASH, dbflags, 0600)))
 458     fatal(0, "cannot open users.db");
 459   trackdb_tracksdb = open_db("tracks.db",
 460                              DB_RECNUM, DB_BTREE, dbflags, 0666);
 461   trackdb_searchdb = open_db("search.db",
 462                              DB_DUP|DB_DUPSORT, DB_HASH, dbflags, 0666);
 463   trackdb_tagsdb = open_db("tags.db",
 464                            DB_DUP|DB_DUPSORT, DB_HASH, dbflags, 0666);
 465   trackdb_prefsdb = open_db("prefs.db", 0, DB_HASH, dbflags, 0666);
 466   trackdb_globaldb = open_db("global.db", 0, DB_HASH, dbflags, 0666);
 467   trackdb_noticeddb = open_db("noticed.db",
 468                              DB_DUPSORT, DB_BTREE, dbflags, 0666);
 469   trackdb_scheduledb = open_db("schedule.db", 0, DB_HASH, dbflags, 0666);
 470   if(!trackdb_existing_database) {
 471     /* Stash the database version */
 472     char buf[32];
 473
 474     assert(!(flags & TRACKDB_OPEN_FOR_UPGRADE));
 475     snprintf(buf, sizeof buf, "%ld", config->dbversion);
 476     trackdb_set_global("_dbversion", buf, 0);
 477   }
 478   D(("opened databases"));
 479 }
 480
 481 /* close track databases */
 482 void trackdb_close(void) {
 483   int err;
 484
 485   /* sanity checks */
 486   assert(opened == 1);
 487   --opened;
 488   if((err = trackdb_tracksdb->close(trackdb_tracksdb, 0)))
 489     fatal(0, "error closing tracks.db: %s", db_strerror(err));
 490   if((err = trackdb_searchdb->close(trackdb_searchdb, 0)))
 491     fatal(0, "error closing search.db: %s", db_strerror(err));
 492   if((err = trackdb_tagsdb->close(trackdb_tagsdb, 0)))
 493     fatal(0, "error closing tags.db: %s", db_strerror(err));
 494   if((err = trackdb_prefsdb->close(trackdb_prefsdb, 0)))
 495     fatal(0, "error closing prefs.db: %s", db_strerror(err));
 496   if((err = trackdb_globaldb->close(trackdb_globaldb, 0)))
 497     fatal(0, "error closing global.db: %s", db_strerror(err));
 498   if((err = trackdb_noticeddb->close(trackdb_noticeddb, 0)))
 499     fatal(0, "error closing noticed.db: %s", db_strerror(err));
 500   if((err = trackdb_scheduledb->close(trackdb_scheduledb, 0)))
 501     fatal(0, "error closing schedule.db: %s", db_strerror(err));
 502   if((err = trackdb_usersdb->close(trackdb_usersdb, 0)))
 503     fatal(0, "error closing users.db: %s", db_strerror(err));
 504   trackdb_tracksdb = trackdb_searchdb = trackdb_prefsdb = 0;
 505   trackdb_tagsdb = trackdb_globaldb = 0;
 506   D(("closed databases"));
 507 }
 508
 509 /* generic db routines *******************************************************/
 510
 511 /* fetch and decode a database entry.  Returns 0, DB_NOTFOUND or
 512  * DB_LOCK_DEADLOCK. */
 513 int trackdb_getdata(DB *db,
 514                     const char *track,
 515                     struct kvp **kp,
 516                     DB_TXN *tid) {
 517   int err;
 518   DBT key, data;
 519
 520   switch(err = db->get(db, tid, make_key(&key, track),
 521                        prepare_data(&data), 0)) {
 522   case 0:
 523     *kp = kvp_urldecode(data.data, data.size);
 524     return 0;
 525   case DB_NOTFOUND:
 526     *kp = 0;
 527     return err;
 528   case DB_LOCK_DEADLOCK:
 529     error(0, "error querying database: %s", db_strerror(err));
 530     return err;
 531   default:
 532     fatal(0, "error querying database: %s", db_strerror(err));
 533   }
 534 }
 535
 536 /* encode and store a database entry.  Returns 0, DB_KEYEXIST or
 537  * DB_LOCK_DEADLOCK. */
 538 int trackdb_putdata(DB *db,
 539                     const char *track,
 540                     const struct kvp *k,
 541                     DB_TXN *tid,
 542                     u_int32_t flags) {
 543   int err;
 544   DBT key, data;
 545
 546   switch(err = db->put(db, tid, make_key(&key, track),
 547                        encode_data(&data, k), flags)) {
 548   case 0:
 549   case DB_KEYEXIST:
 550     return err;
 551   case DB_LOCK_DEADLOCK:
 552     error(0, "error updating database: %s", db_strerror(err));
 553     return err;
 554   default:
 555     fatal(0, "error updating database: %s", db_strerror(err));
 556   }
 557 }
 558
 559 /** @brief Delete a database entry
 560  * @param db Database
 561  * @param track Key to delete
 562  * @param tid Transaction ID
 563  * @return 0, DB_NOTFOUND or DB_LOCK_DEADLOCK
 564  */
 565 int trackdb_delkey(DB *db,
 566                    const char *track,
 567                    DB_TXN *tid) {
 568   int err;
 569
 570   DBT key;
 571   switch(err = db->del(db, tid, make_key(&key, track), 0)) {
 572   case 0:
 573   case DB_NOTFOUND:
 574     return 0;
 575   case DB_LOCK_DEADLOCK:
 576     error(0, "error updating database: %s", db_strerror(err));
 577     return err;
 578   default:
 579     fatal(0, "error updating database: %s", db_strerror(err));
 580   }
 581 }
 582
 583 /* open a database cursor */
 584 DBC *trackdb_opencursor(DB *db, DB_TXN *tid) {
 585   int err;
 586   DBC *c;
 587
 588   switch(err = db->cursor(db, tid, &c, 0)) {
 589   case 0: break;
 590   default: fatal(0, "error creating cursor: %s", db_strerror(err));
 591   }
 592   return c;
 593 }
 594
 595 /* close a database cursor; returns 0 or DB_LOCK_DEADLOCK */
 596 int trackdb_closecursor(DBC *c) {
 597   int err;
 598
 599   if(!c) return 0;
 600   switch(err = c->c_close(c)) {
 601   case 0:
 602     return err;
 603   case DB_LOCK_DEADLOCK:
 604     error(0, "error closing cursor: %s", db_strerror(err));
 605     return err;
 606   default:
 607     fatal(0, "error closing cursor: %s", db_strerror(err));
 608   }
 609 }
 610
 611 /* delete a (key,data) pair.  Returns 0, DB_NOTFOUND or DB_LOCK_DEADLOCK. */
 612 int trackdb_delkeydata(DB *db,
 613                        const char *word,
 614                        const char *track,
 615                        DB_TXN *tid) {
 616   int err;
 617   DBC *c;
 618   DBT key, data;
 619
 620   c = trackdb_opencursor(db, tid);
 621   switch(err = c->c_get(c, make_key(&key, word),
 622                         make_key(&data, track), DB_GET_BOTH)) {
 623   case 0:
 624     switch(err = c->c_del(c, 0)) {
 625     case 0:
 626       break;
 627     case DB_KEYEMPTY:
 628       err = 0;
 629       break;
 630     case DB_LOCK_DEADLOCK:
 631       error(0, "error updating database: %s", db_strerror(err));
 632       break;
 633     default:
 634       fatal(0, "c->c_del: %s", db_strerror(err));
 635     }
 636     break;
 637   case DB_NOTFOUND:
 638     break;
 639   case DB_LOCK_DEADLOCK:
 640     error(0, "error updating database: %s", db_strerror(err));
 641     break;
 642   default:
 643     fatal(0, "c->c_get: %s", db_strerror(err));
 644   }
 645   if(trackdb_closecursor(c)) err = DB_LOCK_DEADLOCK;
 646   return err;
 647 }
 648
 649 /* start a transaction */
 650 DB_TXN *trackdb_begin_transaction(void) {
 651   DB_TXN *tid;
 652   int err;
 653
 654   if((err = trackdb_env->txn_begin(trackdb_env, 0, &tid, 0)))
 655     fatal(0, "trackdb_env->txn_begin: %s", db_strerror(err));
 656   return tid;
 657 }
 658
 659 /* abort transaction */
 660 void trackdb_abort_transaction(DB_TXN *tid) {
 661   int err;
 662
 663   if(tid)
 664     if((err = tid->abort(tid)))
 665       fatal(0, "tid->abort: %s", db_strerror(err));
 666 }
 667
 668 /* commit transaction */
 669 void trackdb_commit_transaction(DB_TXN *tid) {
 670   int err;
 671
 672   if((err = tid->commit(tid, 0)))
 673     fatal(0, "tid->commit: %s", db_strerror(err));
 674 }
 675
 676 /* search/tags shared code ***************************************************/
 677
 678 /* comparison function used by dedupe() */
 679 static int wordcmp(const void *a, const void *b) {
 680   return strcmp(*(const char **)a, *(const char **)b);
 681 }
 682
 683 /* sort and de-dupe VEC */
 684 static char **dedupe(char **vec, int nvec) {
 685   int m, n;
 686
 687   qsort(vec, nvec, sizeof (char *), wordcmp);
 688   m = n = 0;
 689   if(nvec) {
 690     vec[m++] = vec[0];
 691     for(n = 1; n < nvec; ++n)
 692       if(strcmp(vec[n], vec[m - 1]))
 693         vec[m++] = vec[n];
 694   }
 695   vec[m] = 0;
 696   return vec;
 697 }
 698
 699 /* update a key/track database.  Returns 0 or DB_DEADLOCK. */
 700 static int register_word(DB *db, const char *what,
 701                          const char *track, const char *word,
 702                          DB_TXN *tid) {
 703   int err;
 704   DBT key, data;
 705
 706   switch(err = db->put(db, tid, make_key(&key, word),
 707                        make_key(&data, track), DB_NODUPDATA)) {
 708   case 0:
 709   case DB_KEYEXIST:
 710     return 0;
 711   case DB_LOCK_DEADLOCK:
 712     error(0, "error updating %s.db: %s", what, db_strerror(err));
 713     return err;
 714   default:
 715     fatal(0, "error updating %s.db: %s", what,  db_strerror(err));
 716   }
 717 }
 718
 719 /* search primitives *********************************************************/
 720
 721 /* return true iff NAME is a trackname_display_ pref */
 722 static int is_display_pref(const char *name) {
 723   static const char prefix[] = "trackname_display_";
 724   return !strncmp(name, prefix, (sizeof prefix) - 1);
 725 }
 726
 727 /** @brief Word_Break property tailor that treats underscores as spaces */
 728 static int tailor_underscore_Word_Break_Other(uint32_t c) {
 729   switch(c) {
 730   default:
 731     return -1;
 732   case 0x005F: /* LOW LINE (SPACING UNDERSCORE) */
 733     return unicode_Word_Break_Other;
 734   }
 735 }
 736
 737 /** @brief Remove all combining characters in-place
 738  * @param s Pointer to start of string
 739  * @param ns Length of string
 740  * @return New, possiblby reduced, length
 741  */
 742 static size_t remove_combining_chars(uint32_t *s, size_t ns) {
 743   uint32_t *start = s, *t = s, *end = s + ns;
 744
 745   while(s < end) {
 746     const uint32_t c = *s++;
 747     if(!utf32_combining_class(c))
 748       *t++ = c;
 749   }
 750   return t - start;
 751 }
 752
 753 /** @brief Normalize and split a string using a given tailoring */
 754 static void word_split(struct vector *v,
 755                        const char *s,
 756                        unicode_property_tailor *pt) {
 757   size_t nw, nt32, i;
 758   uint32_t *t32, **w32;
 759
 760   /* Convert to UTF-32 */
 761   if(!(t32 = utf8_to_utf32(s, strlen(s), &nt32)))
 762     return;
 763   /* Erase case distinctions */
 764   if(!(t32 = utf32_casefold_compat(t32, nt32, &nt32)))
 765     return;
 766   /* Drop combining characters */
 767   nt32 = remove_combining_chars(t32, nt32);
 768   /* Split into words, treating _ as a space */
 769   w32 = utf32_word_split(t32, nt32, &nw, pt);
 770   /* Convert words back to UTF-8 and append to result */
 771   for(i = 0; i < nw; ++i)
 772     vector_append(v, utf32_to_utf8(w32[i], utf32_len(w32[i]), 0));
 773 }
 774
 775 /** @brief Normalize a tag
 776  * @param s Tag
 777  * @param ns Length of tag
 778  * @return Normalized string or NULL on error
 779  *
 780  * The return value will be:
 781  * - case-folded
 782  * - have no leading or trailing space
 783  * - have no combining characters
 784  * - all spacing between words will be a single U+0020 SPACE
 785  */
 786 static char *normalize_tag(const char *s, size_t ns) {
 787   uint32_t *s32, **w32;
 788   size_t ns32, nw32, i;
 789   struct dynstr d[1];
 790
 791   if(!(s32 = utf8_to_utf32(s, ns, &ns32)))
 792     return 0;
 793   if(!(s32 = utf32_casefold_compat(s32, ns32, &ns32))) /* ->NFKD */
 794     return 0;
 795   ns32 = remove_combining_chars(s32, ns32);
 796   /* Split into words, no Word_Break tailoring */
 797   w32 = utf32_word_split(s32, ns32, &nw32, 0);
 798   /* Compose back into a string */
 799   dynstr_init(d);
 800   for(i = 0; i < nw32; ++i) {
 801     if(i)
 802       dynstr_append(d, ' ');
 803     dynstr_append_string(d, utf32_to_utf8(w32[i], utf32_len(w32[i]), 0));
 804   }
 805   dynstr_terminate(d);
 806   return d->vec;
 807 }
 808
 809 /* compute the words of a track name */
 810 static char **track_to_words(const char *track,
 811                              const struct kvp *p) {
 812   struct vector v;
 813   const char *rootless = track_rootless(track);
 814
 815   if(!rootless)
 816     rootless = track;                   /* bodge */
 817   vector_init(&v);
 818   rootless = strip_extension(rootless);
 819   word_split(&v, strip_extension(rootless), tailor_underscore_Word_Break_Other);
 820   for(; p; p = p->next)
 821     if(is_display_pref(p->name))
 822       word_split(&v, p->value, 0);
 823   vector_terminate(&v);
 824   return dedupe(v.vec, v.nvec);
 825 }
 826
 827 /* return nonzero iff WORD is a stopword */
 828 static int stopword(const char *word) {
 829   int n;
 830
 831   for(n = 0; n < config->stopword.n
 832         && strcmp(word, config->stopword.s[n]); ++n)
 833     ;
 834   return n < config->stopword.n;
 835 }
 836
 837 /* record that WORD appears in TRACK.  Returns 0 or DB_LOCK_DEADLOCK. */
 838 static int register_search_word(const char *track, const char *word,
 839                                 DB_TXN *tid) {
 840   if(stopword(word)) return 0;
 841   return register_word(trackdb_searchdb, "search", track, word, tid);
 842 }
 843
 844 /* Tags **********************************************************************/
 845
 846 /* Return nonzero if C is a valid tag character */
 847 static int tagchar(int c) {
 848   switch(c) {
 849   case ',':
 850     return 0;
 851   default:
 852     return c >= ' ';
 853   }
 854 }
 855
 856 /* Parse and de-dupe a tag list.  If S=0 then assumes "". */
 857 char **parsetags(const char *s) {
 858   const char *t;
 859   struct vector v;
 860
 861   vector_init(&v);
 862   if(s) {
 863     /* skip initial separators */
 864     while(*s && (!tagchar(*s) || *s == ' '))
 865       ++s;
 866     while(*s) {
 867       /* find the extent of the tag */
 868       t = s;
 869       while(*s && tagchar(*s))
 870         ++s;
 871       /* strip trailing spaces */
 872       while(s > t && s[-1] == ' ')
 873         --s;
 874       /* add tag to list */
 875       vector_append(&v, normalize_tag(t, (size_t)(s - t)));
 876       /* skip intermediate and trailing separators */
 877       while(*s && (!tagchar(*s) || *s == ' '))
 878         ++s;
 879     }
 880   }
 881   vector_terminate(&v);
 882   return dedupe(v.vec, v.nvec);
 883 }
 884
 885 /* Record that TRACK has TAG.  Returns 0 or DB_LOCK_DEADLOCK. */
 886 static int register_tag(const char *track, const char *tag, DB_TXN *tid) {
 887   return register_word(trackdb_tagsdb, "tags", track, tag, tid);
 888 }
 889
 890 /* aliases *******************************************************************/
 891
 892 /* compute the alias and store at aliasp.  Returns 0 or DB_LOCK_DEADLOCK.  If
 893  * there is no alias sets *aliasp to 0. */
 894 static int compute_alias(char **aliasp,
 895                          const char *track,
 896                          const struct kvp *p,
 897                          DB_TXN *tid) {
 898   struct dynstr d;
 899   const char *s = config->alias, *t, *expansion, *part;
 900   int c, used_db = 0, slash_prefix, err;
 901   struct kvp *at;
 902   const char *const root = find_track_root(track);
 903
 904   if(!root) {
 905     /* Bodge for tracks with no root */
 906     *aliasp = 0;
 907     return 0;
 908   }
 909   dynstr_init(&d);
 910   dynstr_append_string(&d, root);
 911   while((c = (unsigned char)*s++)) {
 912     if(c != '{') {
 913       dynstr_append(&d, c);
 914       continue;
 915     }
 916     if((slash_prefix = (*s == '/')))
 917       s++;
 918     t = strchr(s, '}');
 919     assert(t != 0);                     /* validated at startup */
 920     part = xstrndup(s, t - s);
 921     expansion = getpart(track, "display", part, p, &used_db);
 922     if(*expansion) {
 923       if(slash_prefix) dynstr_append(&d, '/');
 924       dynstr_append_string(&d, expansion);
 925     }
 926     s = t + 1;                          /* skip {part} */
 927   }
 928   /* only admit to the alias if we used the db... */
 929   if(!used_db) {
 930     *aliasp = 0;
 931     return 0;
 932   }
 933   dynstr_terminate(&d);
 934   /* ...and the answer differs from the original... */
 935   if(!strcmp(track, d.vec)) {
 936     *aliasp = 0;
 937     return 0;
 938   }
 939   /* ...and there isn't already a different track with that name (including as
 940    * an alias) */
 941   switch(err = trackdb_getdata(trackdb_tracksdb, d.vec, &at, tid)) {
 942   case 0:
 943     if((s = kvp_get(at, "_alias_for"))
 944        && !strcmp(s, track)) {
 945     case DB_NOTFOUND:
 946       *aliasp = d.vec;
 947     } else {
 948       *aliasp = 0;
 949     }
 950     return 0;
 951   default:
 952     return err;
 953   }
 954 }
 955
 956 /* get track and prefs data (if tp/pp not null pointers).  Returns 0 on
 957  * success, DB_NOTFOUND if the track does not exist or DB_LOCK_DEADLOCK.
 958  * Always sets the return values, even if only to null pointers. */
 959 static int gettrackdata(const char *track,
 960                         struct kvp **tp,
 961                         struct kvp **pp,
 962                         const char **actualp,
 963                         unsigned flags,
 964 #define GTD_NOALIAS 0x0001
 965                         DB_TXN *tid) {
 966   int err;
 967   const char *actual = track;
 968   struct kvp *t = 0, *p = 0;
 969
 970   if((err = trackdb_getdata(trackdb_tracksdb, track, &t, tid))) goto done;
 971   if((actual = kvp_get(t, "_alias_for"))) {
 972     if(flags & GTD_NOALIAS) {
 973       error(0, "alias passed to gettrackdata where real path required");
 974       abort();
 975     }
 976     if((err = trackdb_getdata(trackdb_tracksdb, actual, &t, tid))) goto done;
 977   } else
 978     actual = track;
 979   assert(actual != 0);
 980   if(pp) {
 981     if((err = trackdb_getdata(trackdb_prefsdb, actual, &p, tid)) == DB_LOCK_DEADLOCK)
 982       goto done;
 983   }
 984   err = 0;
 985 done:
 986   if(actualp) *actualp = actual;
 987   if(tp) *tp = t;
 988   if(pp) *pp = p;
 989   return err;
 990 }
 991
 992 /* trackdb_notice() **********************************************************/
 993
 994 /** @brief notice a possibly new track
 995  * @return @c DB_NOTFOUND if new, 0 if already known
 996  */
 997 int trackdb_notice(const char *track,
 998                    const char *path) {
 999   int err;
1000   DB_TXN *tid;
1001
1002   for(;;) {
1003     tid = trackdb_begin_transaction();
1004     err = trackdb_notice_tid(track, path, tid);
1005     if((err == DB_LOCK_DEADLOCK)) goto fail;
1006     break;
1007   fail:
1008     trackdb_abort_transaction(tid);
1009   }
1010   trackdb_commit_transaction(tid);
1011   return err;
1012 }
1013
1014 /** @brief notice a possibly new track
1015  * @param track NFC UTF-8 track name
1016  * @param path Raw path name
1017  * @param tid Transaction ID
1018  * @return @c DB_NOTFOUND if new, 0 if already known, @c DB_LOCK_DEADLOCK also
1019  */
1020 int trackdb_notice_tid(const char *track,
1021                        const char *path,
1022                        DB_TXN *tid) {
1023   int err, n;
1024   struct kvp *t, *a, *p;
1025   int t_changed, ret;
1026   char *alias, **w, *noticed;
1027   time_t now;
1028
1029   /* notice whether the tracks.db entry changes */
1030   t_changed = 0;
1031   /* get any existing tracks entry */
1032   if((err = gettrackdata(track, &t, &p, 0, 0, tid)) == DB_LOCK_DEADLOCK)
1033     return err;
1034   ret = err;                            /* 0 or DB_NOTFOUND */
1035   /* this is a real track */
1036   t_changed += kvp_set(&t, "_alias_for", 0);
1037   t_changed += kvp_set(&t, "_path", path);
1038   time(&now);
1039   if(ret == DB_NOTFOUND) {
1040     /* It's a new track; record the time */
1041     byte_xasprintf(&noticed, "%lld", (long long)now);
1042     t_changed += kvp_set(&t, "_noticed", noticed);
1043   }
1044   /* if we have an alias record it in the database */
1045   if((err = compute_alias(&alias, track, p, tid))) return err;
1046   if(alias) {
1047     /* won't overwrite someone else's alias as compute_alias() checks */
1048     D(("%s: alias %s", track, alias));
1049     a = 0;
1050     kvp_set(&a, "_alias_for", track);
1051     if((err = trackdb_putdata(trackdb_tracksdb, alias, a, tid, 0))) return err;
1052   }
1053   /* update search.db */
1054   w = track_to_words(track, p);
1055   for(n = 0; w[n]; ++n)
1056     if((err = register_search_word(track, w[n], tid)))
1057       return err;
1058   /* update tags.db */
1059   w = parsetags(kvp_get(p, "tags"));
1060   for(n = 0; w[n]; ++n)
1061     if((err = register_tag(track, w[n], tid)))
1062       return err;
1063   /* only store the tracks.db entry if it has changed */
1064   if(t_changed && (err = trackdb_putdata(trackdb_tracksdb, track, t, tid, 0)))
1065     return err;
1066   if(ret == DB_NOTFOUND) {
1067     uint32_t timestamp[2];
1068     DBT key, data;
1069
1070     timestamp[0] = htonl((uint64_t)now >> 32);
1071     timestamp[1] = htonl((uint32_t)now);
1072     memset(&key, 0, sizeof key);
1073     key.data = timestamp;
1074     key.size = sizeof timestamp;
1075     switch(err = trackdb_noticeddb->put(trackdb_noticeddb, tid, &key,
1076                                         make_key(&data, track), 0)) {
1077     case 0: break;
1078     case DB_LOCK_DEADLOCK: return err;
1079     default: fatal(0, "error updating noticed.db: %s", db_strerror(err));
1080     }
1081   }
1082   return ret;
1083 }
1084
1085 /* trackdb_obsolete() ********************************************************/
1086
1087 /* obsolete a track */
1088 int trackdb_obsolete(const char *track, DB_TXN *tid) {
1089   int err, n;
1090   struct kvp *p;
1091   char *alias, **w;
1092
1093   if((err = gettrackdata(track, 0, &p, 0,
1094                          GTD_NOALIAS, tid)) == DB_LOCK_DEADLOCK)
1095     return err;
1096   else if(err == DB_NOTFOUND) return 0;
1097   /* compute the alias, if any, and delete it */
1098   if((err = compute_alias(&alias, track, p, tid))) return err;
1099   if(alias) {
1100     /* if the alias points to some other track then compute_alias won't
1101      * return it */
1102     if((err = trackdb_delkey(trackdb_tracksdb, alias, tid))
1103        && err != DB_NOTFOUND)
1104       return err;
1105   }
1106   /* update search.db */
1107   w = track_to_words(track, p);
1108   for(n = 0; w[n]; ++n)
1109     if(trackdb_delkeydata(trackdb_searchdb,
1110                           w[n], track, tid) == DB_LOCK_DEADLOCK)
1111       return err;
1112   /* update tags.db */
1113   w = parsetags(kvp_get(p, "tags"));
1114   for(n = 0; w[n]; ++n)
1115     if(trackdb_delkeydata(trackdb_tagsdb,
1116                           w[n], track, tid) == DB_LOCK_DEADLOCK)
1117       return err;
1118   /* update tracks.db */
1119   if(trackdb_delkey(trackdb_tracksdb, track, tid) == DB_LOCK_DEADLOCK)
1120     return err;
1121   /* We don't delete the prefs, so they survive temporary outages of the
1122    * (possibly virtual) track filesystem */
1123   return 0;
1124 }
1125
1126 /* trackdb_stats() ***********************************************************/
1127
1128 #define H(name) { #name, offsetof(DB_HASH_STAT, name) }
1129 #define B(name) { #name, offsetof(DB_BTREE_STAT, name) }
1130
1131 static const struct statinfo {
1132   const char *name;
1133   size_t offset;
1134 } statinfo_hash[] = {
1135   H(hash_magic),
1136   H(hash_version),
1137   H(hash_nkeys),
1138   H(hash_ndata),
1139   H(hash_pagesize),
1140   H(hash_ffactor),
1141   H(hash_buckets),
1142   H(hash_free),
1143   H(hash_bfree),
1144   H(hash_bigpages),
1145   H(hash_big_bfree),
1146   H(hash_overflows),
1147   H(hash_ovfl_free),
1148   H(hash_dup),
1149   H(hash_dup_free),
1150 }, statinfo_btree[] = {
1151   B(bt_magic),
1152   B(bt_version),
1153   B(bt_nkeys),
1154   B(bt_ndata),
1155   B(bt_pagesize),
1156   B(bt_minkey),
1157   B(bt_re_len),
1158   B(bt_re_pad),
1159   B(bt_levels),
1160   B(bt_int_pg),
1161   B(bt_leaf_pg),
1162   B(bt_dup_pg),
1163   B(bt_over_pg),
1164   B(bt_free),
1165   B(bt_int_pgfree),
1166   B(bt_leaf_pgfree),
1167   B(bt_dup_pgfree),
1168   B(bt_over_pgfree),
1169 };
1170
1171 /* look up stats for DB */
1172 static int get_stats(struct vector *v,
1173                      DB *database,
1174                      const struct statinfo *si,
1175                      size_t nsi,
1176                      DB_TXN *tid) {
1177   void *sp;
1178   size_t n;
1179   char *str;
1180   int err;
1181
1182   if(database) {
1183     switch(err = database->stat(database, tid, &sp, 0)) {
1184     case 0:
1185       break;
1186     case DB_LOCK_DEADLOCK:
1187       error(0, "error querying database: %s", db_strerror(err));
1188       return err;
1189     default:
1190       fatal(0, "error querying database: %s", db_strerror(err));
1191     }
1192     for(n = 0; n < nsi; ++n) {
1193       byte_xasprintf(&str, "%s=%"PRIuMAX, si[n].name,
1194                      (uintmax_t)*(u_int32_t *)((char *)sp + si[n].offset));
1195       vector_append(v, str);
1196     }
1197   }
1198   return 0;
1199 }
1200
1201 /** @brief One entry in the search league */
1202 struct search_entry {
1203   char *word;
1204   int n;
1205 };
1206
1207 /** @brief Add a word to the search league
1208  * @param se Pointer to search league
1209  * @param count Maximum size for search league
1210  * @param nse Current size of search league
1211  * @param word New word, or NULL
1212  * @param n How often @p word appears
1213  * @return New size of search league
1214  */
1215 static int register_search_entry(struct search_entry *se,
1216                                  int count,
1217                                  int nse,
1218                                  char *word,
1219                                  int n) {
1220   int i;
1221
1222   if(word && (nse < count || n > se[nse - 1].n)) {
1223     /* Find the starting point */
1224     if(nse == count)
1225       i = nse - 1;
1226     else
1227       i = nse++;
1228     /* Find the insertion point */
1229     while(i > 0 && n > se[i - 1].n)
1230       --i;
1231     memmove(&se[i + 1], &se[i], (nse - i - 1) * sizeof *se);
1232     se[i].word = word;
1233     se[i].n = n;
1234   }
1235   return nse;
1236 }
1237
1238 /* find the top COUNT words in the search database */
1239 static int search_league(struct vector *v, int count, DB_TXN *tid) {
1240   struct search_entry *se;
1241   DBT k, d;
1242   DBC *cursor;
1243   int err, n = 0, nse = 0, i;
1244   char *word = 0;
1245   size_t wl = 0;
1246   char *str;
1247
1248   cursor = trackdb_opencursor(trackdb_searchdb, tid);
1249   se = xmalloc(count * sizeof *se);
1250   /* Walk across the whole database counting up the number of times each
1251    * word appears. */
1252   while(!(err = cursor->c_get(cursor, prepare_data(&k), prepare_data(&d),
1253                               DB_NEXT))) {
1254     if(word && wl == k.size && !strncmp(word, k.data, wl))
1255       ++n;                              /* same word again */
1256     else {
1257       nse = register_search_entry(se, count, nse, word, n);
1258       word = xstrndup(k.data, wl = k.size);
1259       n = 1;
1260     }
1261   }
1262   switch(err) {
1263   case DB_NOTFOUND:
1264     err = 0;
1265     break;
1266   case DB_LOCK_DEADLOCK:
1267     error(0, "error querying search database: %s", db_strerror(err));
1268     break;
1269   default:
1270     fatal(0, "error querying search database: %s", db_strerror(err));
1271   }
1272   if(trackdb_closecursor(cursor)) err = DB_LOCK_DEADLOCK;
1273   if(err) return err;
1274   nse = register_search_entry(se, count, nse, word, n);
1275   byte_xasprintf(&str, "Top %d search words:", nse);
1276   vector_append(v, str);
1277   for(i = 0; i < nse; ++i) {
1278     byte_xasprintf(&str, "%4d: %5d %s", i + 1, se[i].n, se[i].word);
1279     vector_append(v, str);
1280   }
1281   return 0;
1282 }
1283
1284 #define SI(what) statinfo_##what, \
1285                  sizeof statinfo_##what / sizeof (struct statinfo)
1286
1287 /* return a list of database stats */
1288 char **trackdb_stats(int *nstatsp) {
1289   DB_TXN *tid;
1290   struct vector v;
1291
1292   vector_init(&v);
1293   for(;;) {
1294     tid = trackdb_begin_transaction();
1295     v.nvec = 0;
1296     vector_append(&v, (char *)"Tracks database stats:");
1297     if(get_stats(&v, trackdb_tracksdb, SI(btree), tid)) goto fail;
1298     vector_append(&v, (char *)"");
1299     vector_append(&v, (char *)"Search database stats:");
1300     if(get_stats(&v, trackdb_searchdb, SI(hash), tid)) goto fail;
1301     vector_append(&v, (char *)"");
1302     vector_append(&v, (char *)"Prefs database stats:");
1303     if(get_stats(&v, trackdb_prefsdb, SI(hash), tid)) goto fail;
1304     vector_append(&v, (char *)"");
1305     if(search_league(&v, 10, tid)) goto fail;
1306     vector_terminate(&v);
1307     break;
1308 fail:
1309     trackdb_abort_transaction(tid);
1310   }
1311   trackdb_commit_transaction(tid);
1312   if(nstatsp) *nstatsp = v.nvec;
1313   return v.vec;
1314 }
1315
1316 struct stats_details {
1317   void (*done)(char *data, void *u);
1318   void *u;
1319   int exited;                           /* subprocess exited */
1320   int closed;                           /* pipe close */
1321   int wstat;                            /* wait status from subprocess */
1322   struct dynstr data[1];                /* data read from pipe */
1323 };
1324
1325 static void stats_complete(struct stats_details *d) {
1326   char *s;
1327
1328   if(!(d->exited && d->closed))
1329     return;
1330   byte_xasprintf(&s, "\n"
1331                  "Server stats:\n"
1332                  "track lookup cache hits: %lu\n"
1333                  "track lookup cache misses: %lu\n",
1334                  cache_files_hits,
1335                  cache_files_misses);
1336   dynstr_append_string(d->data, s);
1337   dynstr_terminate(d->data);
1338   d->done(d->data->vec, d->u);
1339 }
1340
1341 static int stats_finished(ev_source attribute((unused)) *ev,
1342                           pid_t attribute((unused)) pid,
1343                           int status,
1344                           const struct rusage attribute((unused)) *rusage,
1345                           void *u) {
1346   struct stats_details *const d = u;
1347
1348   d->exited = 1;
1349   if(status)
1350     error(0, "disorder-stats %s", wstat(status));
1351   stats_complete(d);
1352   return 0;
1353 }
1354
1355 static int stats_read(ev_source attribute((unused)) *ev,
1356                       ev_reader *reader,
1357                       void *ptr,
1358                       size_t bytes,
1359                       int eof,
1360                       void *u) {
1361   struct stats_details *const d = u;
1362
1363   dynstr_append_bytes(d->data, ptr, bytes);
1364   ev_reader_consume(reader, bytes);
1365   if(eof)
1366     d->closed = 1;
1367   stats_complete(d);
1368   return 0;
1369 }
1370
1371 static int stats_error(ev_source attribute((unused)) *ev,
1372                        int errno_value,
1373                        void *u) {
1374   struct stats_details *const d = u;
1375
1376   error(errno_value, "error reading from pipe to disorder-stats");
1377   d->closed = 1;
1378   stats_complete(d);
1379   return 0;
1380 }
1381
1382 void trackdb_stats_subprocess(ev_source *ev,
1383                               void (*done)(char *data, void *u),
1384                               void *u) {
1385   int p[2];
1386   pid_t pid;
1387   struct stats_details *d = xmalloc(sizeof *d);
1388
1389   dynstr_init(d->data);
1390   d->done = done;
1391   d->u = u;
1392   xpipe(p);
1393   pid = subprogram(ev, p[1], "disorder-stats", (char *)0);
1394   xclose(p[1]);
1395   ev_child(ev, pid, 0, stats_finished, d);
1396   ev_reader_new(ev, p[0], stats_read, stats_error, d, "disorder-stats reader");
1397 }
1398
1399 /** @brief Parse a track name part preference
1400  * @param name Preference name
1401  * @param partp Where to store part name
1402  * @param contextp Where to store context name
1403  * @return 0 on success, non-0 if parse fails
1404  */
1405 static int trackdb__parse_namepref(const char *name,
1406                                    char **partp,
1407                                    char **contextp) {
1408   char *c;
1409   static const char prefix[] = "trackname_";
1410
1411   if(strncmp(name, prefix, strlen(prefix)))
1412     return -1;                          /* not trackname_* at all */
1413   name += strlen(prefix);
1414   /* There had better be a _ between context and part */
1415   c = strchr(name, '_');
1416   if(!c)
1417     return -1;
1418   /* Context is first in the pref name even though most APIs have the part
1419    * first.  Confusing; sorry. */
1420   *contextp = xstrndup(name, c - name);
1421   ++c;
1422   /* There had better NOT be a second _ */
1423   if(strchr(c, '_'))
1424     return -1;
1425   *partp = xstrdup(c);
1426   return 0;
1427 }
1428
1429 /** @brief Compute the default value for a track preference
1430  * @param track Track name
1431  * @param name Preference name
1432  * @return Default value or 0 if none/not known
1433  */
1434 static const char *trackdb__default(const char *track, const char *name) {
1435   char *context, *part;
1436
1437   if(!trackdb__parse_namepref(name, &part, &context)) {
1438     /* We can work out the default for a trackname_ pref */
1439     return trackname_part(track, context, part);
1440   } else if(!strcmp(name, "weight")) {
1441     /* We know the default weight */
1442     return "90000";
1443   } else if(!strcmp(name, "pick_at_random")) {
1444     /* By default everything is eligible for picking at random */
1445     return "1";
1446   } else if(!strcmp(name, "tags")) {
1447     /* By default everything no track has any tags */
1448     return "";
1449   }
1450   return 0;
1451 }
1452
1453 /* set a pref (remove if value=0) */
1454 int trackdb_set(const char *track,
1455                 const char *name,
1456                 const char *value) {
1457   struct kvp *t, *p, *a;
1458   DB_TXN *tid;
1459   int err, cmp;
1460   char *oldalias, *newalias, **oldtags = 0, **newtags;
1461   const char *def;
1462
1463   /* If the value matches the default then unset instead, to keep the database
1464    * tidy.  Older versions did not have this feature so your database may yet
1465    * have some default values stored in it. */
1466   if(value) {
1467     def = trackdb__default(track, name);
1468     if(def && !strcmp(value, def))
1469       value = 0;
1470   }
1471
1472   for(;;) {
1473     tid = trackdb_begin_transaction();
1474     if((err = gettrackdata(track, &t, &p, 0,
1475                            0, tid)) == DB_LOCK_DEADLOCK)
1476       goto fail;
1477     if(err == DB_NOTFOUND) break;
1478     if(name[0] == '_') {
1479       if(kvp_set(&t, name, value))
1480         if(trackdb_putdata(trackdb_tracksdb, track, t, tid, 0))
1481           goto fail;
1482     } else {
1483       /* get the old alias name */
1484       if(compute_alias(&oldalias, track, p, tid)) goto fail;
1485       /* get the old tags */
1486       if(!strcmp(name, "tags"))
1487         oldtags = parsetags(kvp_get(p, "tags"));
1488       /* set the value */
1489       if(kvp_set(&p, name, value))
1490         if(trackdb_putdata(trackdb_prefsdb, track, p, tid, 0))
1491           goto fail;
1492       /* compute the new alias name */
1493       if((err = compute_alias(&newalias, track, p, tid))) goto fail;
1494       /* check whether alias has changed */
1495       if(!(oldalias == newalias
1496            || (oldalias && newalias && !strcmp(oldalias, newalias)))) {
1497         /* adjust alias records to fit change */
1498         if(oldalias
1499            && trackdb_delkey(trackdb_tracksdb, oldalias, tid) == DB_LOCK_DEADLOCK)
1500           goto fail;
1501         if(newalias) {
1502           a = 0;
1503           kvp_set(&a, "_alias_for", track);
1504           if(trackdb_putdata(trackdb_tracksdb, newalias, a, tid, 0)) goto fail;
1505         }
1506       }
1507       /* check whether tags have changed */
1508       if(!strcmp(name, "tags")) {
1509         newtags = parsetags(value);
1510         while(*oldtags || *newtags) {
1511           if(*oldtags && *newtags) {
1512             cmp = strcmp(*oldtags, *newtags);
1513             if(!cmp) {
1514               /* keeping this tag */
1515               ++oldtags;
1516               ++newtags;
1517             } else if(cmp < 0)
1518               /* old tag fits into a gap in the new list, so delete old */
1519               goto delete_old;
1520             else
1521               /* new tag fits into a gap in the old list, so insert new */
1522               goto insert_new;
1523           } else if(*oldtags) {
1524             /* we've run out of new tags, so remaining old ones are to be
1525              * deleted */
1526           delete_old:
1527             if(trackdb_delkeydata(trackdb_tagsdb,
1528                                   *oldtags, track, tid) == DB_LOCK_DEADLOCK)
1529               goto fail;
1530             ++oldtags;
1531           } else {
1532             /* we've run out of old tags, so remainig new ones are to be
1533              * inserted */
1534           insert_new:
1535             if(register_tag(track, *newtags, tid)) goto fail;
1536             ++newtags;
1537           }
1538         }
1539       }
1540     }
1541     err = 0;
1542     break;
1543 fail:
1544     trackdb_abort_transaction(tid);
1545   }
1546   trackdb_commit_transaction(tid);
1547   return err == 0 ? 0 : -1;
1548 }
1549
1550 /* get a pref */
1551 const char *trackdb_get(const char *track,
1552                         const char *name) {
1553   return kvp_get(trackdb_get_all(track), name);
1554 }
1555
1556 /* get all prefs as a 0-terminated array */
1557 struct kvp *trackdb_get_all(const char *track) {
1558   struct kvp *t, *p, **pp;
1559   DB_TXN *tid;
1560
1561   for(;;) {
1562     tid = trackdb_begin_transaction();
1563     if(gettrackdata(track, &t, &p, 0, 0, tid) == DB_LOCK_DEADLOCK)
1564       goto fail;
1565     break;
1566 fail:
1567     trackdb_abort_transaction(tid);
1568   }
1569   trackdb_commit_transaction(tid);
1570   for(pp = &p; *pp; pp = &(*pp)->next)
1571     ;
1572   *pp = t;
1573   return p;
1574 }
1575
1576 /* resolve alias */
1577 const char *trackdb_resolve(const char *track) {
1578   DB_TXN *tid;
1579   const char *actual;
1580
1581   for(;;) {
1582     tid = trackdb_begin_transaction();
1583     if(gettrackdata(track, 0, 0, &actual, 0, tid) == DB_LOCK_DEADLOCK)
1584       goto fail;
1585     break;
1586 fail:
1587     trackdb_abort_transaction(tid);
1588   }
1589   trackdb_commit_transaction(tid);
1590   return actual;
1591 }
1592
1593 int trackdb_isalias(const char *track) {
1594   const char *actual = trackdb_resolve(track);
1595
1596   return strcmp(actual, track);
1597 }
1598
1599 /* test whether a track exists (perhaps an alias) */
1600 int trackdb_exists(const char *track) {
1601   DB_TXN *tid;
1602   int err;
1603
1604   for(;;) {
1605     tid = trackdb_begin_transaction();
1606     /* unusually, here we want the return value */
1607     if((err = gettrackdata(track, 0, 0, 0, 0, tid)) == DB_LOCK_DEADLOCK)
1608       goto fail;
1609     break;
1610 fail:
1611     trackdb_abort_transaction(tid);
1612   }
1613   trackdb_commit_transaction(tid);
1614   return (err == 0);
1615 }
1616
1617 /* return the list of tags */
1618 char **trackdb_alltags(void) {
1619   int e;
1620   struct vector v[1];
1621
1622   vector_init(v);
1623   WITH_TRANSACTION(trackdb_listkeys(trackdb_tagsdb, v, tid));
1624   return v->vec;
1625 }
1626
1627 /** @brief List all the keys in @p db
1628  * @param db Database
1629  * @param v Vector to store keys in
1630  * @param tid Transaction ID
1631  * @return 0 or DB_LOCK_DEADLOCK
1632  */
1633 int trackdb_listkeys(DB *db, struct vector *v, DB_TXN *tid) {
1634   int e;
1635   DBT k, d;
1636   DBC *const c = trackdb_opencursor(db, tid);
1637
1638   v->nvec = 0;
1639   memset(&k, 0, sizeof k);
1640   while(!(e = c->c_get(c, &k, prepare_data(&d), DB_NEXT_NODUP)))
1641     vector_append(v, xstrndup(k.data, k.size));
1642   switch(e) {
1643   case DB_NOTFOUND:
1644     break;
1645   case DB_LOCK_DEADLOCK:
1646     return e;
1647   default:
1648     fatal(0, "c->c_get: %s", db_strerror(e));
1649   }
1650   if((e = trackdb_closecursor(c)))
1651     return e;
1652   vector_terminate(v);
1653   return 0;
1654 }
1655
1656 /* return 1 iff sorted tag lists A and B have at least one member in common */
1657 int tag_intersection(char **a, char **b) {
1658   int cmp;
1659
1660   /* Same sort of logic as trackdb_set() above */
1661   while(*a && *b) {
1662     if(!(cmp = strcmp(*a, *b))) return 1;
1663     else if(cmp < 0) ++a;
1664     else ++b;
1665   }
1666   return 0;
1667 }
1668
1669 static pid_t choose_pid = -1;
1670 static int choose_fd;
1671 static random_callback *choose_callback;
1672 static struct dynstr choose_output;
1673 static unsigned choose_complete;
1674 static int choose_status;
1675 #define CHOOSE_RUNNING 1
1676 #define CHOOSE_READING 2
1677
1678 static void choose_finished(ev_source *ev, unsigned which) {
1679   choose_complete |= which;
1680   if(choose_complete != (CHOOSE_RUNNING|CHOOSE_READING))
1681     return;
1682   choose_pid = -1;
1683   if(choose_status == 0 && choose_output.nvec > 0) {
1684     dynstr_terminate(&choose_output);
1685     choose_callback(ev, xstrdup(choose_output.vec));
1686   } else
1687     choose_callback(ev, 0);
1688 }
1689
1690 /** @brief Called when @c disorder-choose terminates */
1691 static int choose_exited(ev_source *ev,
1692                          pid_t attribute((unused)) pid,
1693                          int status,
1694                          const struct rusage attribute((unused)) *rusage,
1695                          void attribute((unused)) *u) {
1696   if(status)
1697     error(0, "disorder-choose %s", wstat(status));
1698   choose_status = status;
1699   choose_finished(ev, CHOOSE_RUNNING);
1700   return 0;
1701 }
1702
1703 /** @brief Called with data from @c disorder-choose pipe */
1704 static int choose_readable(ev_source *ev,
1705                            ev_reader *reader,
1706                            void *ptr,
1707                            size_t bytes,
1708                            int eof,
1709                            void attribute((unused)) *u) {
1710   dynstr_append_bytes(&choose_output, ptr, bytes);
1711   ev_reader_consume(reader, bytes);
1712   if(eof)
1713     choose_finished(ev, CHOOSE_READING);
1714   return 0;
1715 }
1716
1717 static int choose_read_error(ev_source *ev,
1718                              int errno_value,
1719                              void attribute((unused)) *u) {
1720   error(errno_value, "error reading disorder-choose pipe");
1721   choose_finished(ev, CHOOSE_READING);
1722   return 0;
1723 }
1724
1725 /** @brief Request a random track
1726  * @param ev Event source
1727  * @param callback Called with random track or NULL
1728  * @return 0 if a request was initiated, else -1
1729  *
1730  * Initiates a random track choice.  @p callback will later be called back with
1731  * the choice (or NULL on error).  If a choice is already underway then -1 is
1732  * returned and there will be no additional callback.
1733  *
1734  * The caller shouldn't assume that the track returned actually exists (it
1735  * might be removed between the choice and the callback, or between being added
1736  * to the queue and being played).
1737  */
1738 int trackdb_request_random(ev_source *ev,
1739                            random_callback *callback) {
1740   int p[2];
1741
1742   if(choose_pid != -1)
1743     return -1;                          /* don't run concurrent chooses */
1744   xpipe(p);
1745   cloexec(p[0]);
1746   choose_pid = subprogram(ev, p[1], "disorder-choose", (char *)0);
1747   choose_fd = p[0];
1748   xclose(p[1]);
1749   choose_callback = callback;
1750   choose_output.nvec = 0;
1751   choose_complete = 0;
1752   ev_reader_new(ev, p[0], choose_readable, choose_read_error, 0,
1753                 "disorder-choose reader"); /* owns p[0] */
1754   ev_child(ev, choose_pid, 0, choose_exited, 0); /* owns the subprocess */
1755   return 0;
1756 }
1757
1758 /* get a track name given the prefs.  Set *used_db to 1 if we got the answer
1759  * from the prefs. */
1760 static const char *getpart(const char *track,
1761                            const char *context,
1762                            const char *part,
1763                            const struct kvp *p,
1764                            int *used_db) {
1765   const char *result;
1766   char *pref;
1767
1768   byte_xasprintf(&pref, "trackname_%s_%s", context, part);
1769   if((result = kvp_get(p, pref)))
1770     *used_db = 1;
1771   else
1772     result = trackname_part(track, context, part);
1773   assert(result != 0);
1774   return result;
1775 }
1776
1777 /* get a track name part, like trackname_part(), but taking the database into
1778  * account. */
1779 const char *trackdb_getpart(const char *track,
1780                             const char *context,
1781                             const char *part) {
1782   struct kvp *p;
1783   DB_TXN *tid;
1784   char *pref;
1785   const char *actual;
1786   int used_db, err;
1787
1788   /* construct the full pref */
1789   byte_xasprintf(&pref, "trackname_%s_%s", context, part);
1790   for(;;) {
1791     tid = trackdb_begin_transaction();
1792     if((err = gettrackdata(track, 0, &p, &actual, 0, tid)) == DB_LOCK_DEADLOCK)
1793       goto fail;
1794     break;
1795 fail:
1796     trackdb_abort_transaction(tid);
1797   }
1798   trackdb_commit_transaction(tid);
1799   return getpart(actual, context, part, p, &used_db);
1800 }
1801
1802 /* get the raw path name for @track@ (might be an alias) */
1803 const char *trackdb_rawpath(const char *track) {
1804   DB_TXN *tid;
1805   struct kvp *t;
1806   const char *path;
1807
1808   for(;;) {
1809     tid = trackdb_begin_transaction();
1810     if(gettrackdata(track, &t, 0, 0, 0, tid) == DB_LOCK_DEADLOCK)
1811       goto fail;
1812     break;
1813 fail:
1814     trackdb_abort_transaction(tid);
1815   }
1816   trackdb_commit_transaction(tid);
1817   if(!(path = kvp_get(t, "_path"))) path = track;
1818   return path;
1819 }
1820
1821 /* trackdb_list **************************************************************/
1822
1823 /* this is incredibly ugly, sorry, perhaps it will be rewritten to be actually
1824  * readable at some point */
1825
1826 /* return true if the basename of TRACK[0..TL-1], as defined by DL, matches RE.
1827  * If RE is a null pointer then it matches everything. */
1828 static int track_matches(size_t dl, const char *track, size_t tl,
1829                          const pcre *re) {
1830   int ovec[3], rc;
1831
1832   if(!re)
1833     return 1;
1834   track += dl + 1;
1835   tl -= (dl + 1);
1836   switch(rc = pcre_exec(re, 0, track, tl, 0, 0, ovec, 3)) {
1837   case PCRE_ERROR_NOMATCH: return 0;
1838   default:
1839     if(rc < 0) {
1840       error(0, "pcre_exec returned %d, subject '%s'", rc, track);
1841       return 0;
1842     }
1843     return 1;
1844   }
1845 }
1846
1847 static int do_list(struct vector *v, const char *dir,
1848                    enum trackdb_listable what, const pcre *re, DB_TXN *tid) {
1849   DBC *cursor;
1850   DBT k, d;
1851   size_t dl;
1852   char *ptr;
1853   int err;
1854   size_t l, last_dir_len = 0;
1855   char *last_dir = 0, *track, *alias;
1856   struct kvp *p;
1857
1858   dl = strlen(dir);
1859   cursor = trackdb_opencursor(trackdb_tracksdb, tid);
1860   make_key(&k, dir);
1861   prepare_data(&d);
1862   /* find the first key >= dir */
1863   err = cursor->c_get(cursor, &k, &d, DB_SET_RANGE);
1864   /* keep going while we're dealing with <dir/anything> */
1865   while(err == 0
1866         && k.size > dl
1867         && ((char *)k.data)[dl] == '/'
1868         && !memcmp(k.data, dir, dl)) {
1869     ptr = memchr((char *)k.data + dl + 1, '/', k.size - (dl + 1));
1870     if(ptr) {
1871       /* we have <dir/component/anything>, so <dir/component> is a directory */
1872       l = ptr - (char *)k.data;
1873       if(what & trackdb_directories)
1874         if(!(last_dir
1875              && l == last_dir_len
1876              && !memcmp(last_dir, k.data, l))) {
1877           last_dir = xstrndup(k.data, last_dir_len = l);
1878           if(track_matches(dl, k.data, l, re))
1879             vector_append(v, last_dir);
1880         }
1881     } else {
1882       /* found a plain file */
1883       if((what & trackdb_files)) {
1884         track = xstrndup(k.data, k.size);
1885         if((err = trackdb_getdata(trackdb_prefsdb,
1886                                   track, &p, tid)) == DB_LOCK_DEADLOCK)
1887           goto deadlocked;
1888         /* if this file has an alias in the same directory then we skip it */
1889         if((err = compute_alias(&alias, track, p, tid)))
1890           goto deadlocked;
1891         if(!(alias && !strcmp(d_dirname(alias), d_dirname(track))))
1892           if(track_matches(dl, k.data, k.size, re))
1893             vector_append(v, track);
1894       }
1895     }
1896     err = cursor->c_get(cursor, &k, &d, DB_NEXT);
1897   }
1898   switch(err) {
1899   case 0:
1900     break;
1901   case DB_NOTFOUND:
1902     err = 0;
1903     break;
1904   case DB_LOCK_DEADLOCK:
1905     error(0, "error querying database: %s", db_strerror(err));
1906     break;
1907   default:
1908     fatal(0, "error querying database: %s", db_strerror(err));
1909   }
1910 deadlocked:
1911   if(trackdb_closecursor(cursor)) err = DB_LOCK_DEADLOCK;
1912   return err;
1913 }
1914
1915 /* return the directories or files below @dir@ */
1916 char **trackdb_list(const char *dir, int *np, enum trackdb_listable what,
1917                     const pcre *re) {
1918   DB_TXN *tid;
1919   int n;
1920   struct vector v;
1921
1922   vector_init(&v);
1923   for(;;) {
1924     tid = trackdb_begin_transaction();
1925     v.nvec = 0;
1926     if(dir) {
1927       if(do_list(&v, dir, what, re, tid))
1928         goto fail;
1929     } else {
1930       for(n = 0; n < config->collection.n; ++n)
1931         if(do_list(&v, config->collection.s[n].root, what, re, tid))
1932           goto fail;
1933     }
1934     break;
1935 fail:
1936     trackdb_abort_transaction(tid);
1937   }
1938   trackdb_commit_transaction(tid);
1939   vector_terminate(&v);
1940   if(np)
1941     *np = v.nvec;
1942   return v.vec;
1943 }
1944
1945 /* If S is tag:something, return something.  Else return 0. */
1946 static const char *checktag(const char *s) {
1947   if(!strncmp(s, "tag:", 4))
1948     return s + 4;
1949   else
1950     return 0;
1951 }
1952
1953 /* return a list of tracks containing all of the words given.  If you
1954  * ask for only stopwords you get no tracks. */
1955 char **trackdb_search(char **wordlist, int nwordlist, int *ntracks) {
1956   const char **w, *best = 0, *tag;
1957   char **twords, **tags;
1958   char *istag;
1959   int i, j, n, err, what;
1960   DBC *cursor = 0;
1961   DBT k, d;
1962   struct vector u, v;
1963   DB_TXN *tid;
1964   struct kvp *p;
1965   int ntags = 0;
1966   DB *db;
1967   const char *dbname;
1968
1969   *ntracks = 0;                         /* for early returns */
1970   /* normalize all the words */
1971   w = xmalloc(nwordlist * sizeof (char *));
1972   istag = xmalloc_noptr(nwordlist);
1973   for(n = 0; n < nwordlist; ++n) {
1974     uint32_t *w32;
1975     size_t nw32;
1976
1977     w[n] = utf8_casefold_compat(wordlist[n], strlen(wordlist[n]), 0);
1978     if(checktag(w[n])) {
1979       ++ntags;         /* count up tags */
1980       /* Normalize the tag */
1981       w[n] = normalize_tag(w[n] + 4, strlen(w[n] + 4));
1982       istag[n] = 1;
1983     } else {
1984       /* Normalize the search term by removing combining characters */
1985       if(!(w32 = utf8_to_utf32(w[n], strlen(w[n]), &nw32)))
1986         return 0;
1987       nw32 = remove_combining_chars(w32, nw32);
1988       if(!(w[n] = utf32_to_utf8(w32, nw32, 0)))
1989         return 0;
1990       istag[n] = 0;
1991     }
1992   }
1993   /* find the longest non-stopword */
1994   for(n = 0; n < nwordlist; ++n)
1995     if(!istag[n] && !stopword(w[n]))
1996       if(!best || strlen(w[n]) > strlen(best))
1997         best = w[n];
1998   /* TODO: we should at least in principal be able to identify the word or tag
1999    * with the least matches in log time, and choose that as our primary search
2000    * term. */
2001   if(ntags && !best) {
2002     /* Only tags are listed.  We limit to the first and narrow down with the
2003      * rest. */
2004     best = istag[0] ? w[0] : 0;
2005     db = trackdb_tagsdb;
2006     dbname = "tags";
2007   } else if(best) {
2008     /* We can limit to some word. */
2009     db = trackdb_searchdb;
2010     dbname = "search";
2011   } else {
2012     /* Only stopwords */
2013     return 0;
2014   }
2015   vector_init(&u);
2016   vector_init(&v);
2017   for(;;) {
2018     tid = trackdb_begin_transaction();
2019     /* find all the tracks that have that word */
2020     make_key(&k, best);
2021     prepare_data(&d);
2022     what = DB_SET;
2023     v.nvec = 0;
2024     cursor = trackdb_opencursor(db, tid);
2025     while(!(err = cursor->c_get(cursor, &k, &d, what))) {
2026       vector_append(&v, xstrndup(d.data, d.size));
2027       what = DB_NEXT_DUP;
2028     }
2029     switch(err) {
2030     case DB_NOTFOUND:
2031       err = 0;
2032       break;
2033     case DB_LOCK_DEADLOCK:
2034       error(0, "error querying %s database: %s", dbname, db_strerror(err));
2035       break;
2036     default:
2037       fatal(0, "error querying %s database: %s", dbname, db_strerror(err));
2038     }
2039     if(trackdb_closecursor(cursor)) err = DB_LOCK_DEADLOCK;
2040     cursor = 0;
2041     /* do a naive search over that (hopefuly fairly small) list of tracks */
2042     u.nvec = 0;
2043     for(n = 0; n < v.nvec; ++n) {
2044       if((err = gettrackdata(v.vec[n], 0, &p, 0, 0, tid) == DB_LOCK_DEADLOCK))
2045         goto fail;
2046       else if(err) {
2047         error(0, "track %s unexpected error: %s", v.vec[n], db_strerror(err));
2048         continue;
2049       }
2050       twords = track_to_words(v.vec[n], p);
2051       tags = parsetags(kvp_get(p, "tags"));
2052       for(i = 0; i < nwordlist; ++i) {
2053         if(istag[i]) {
2054           tag = w[i];
2055           /* Track must have this tag */
2056           for(j = 0; tags[j]; ++j)
2057             if(!strcmp(tag, tags[j])) break; /* tag found */
2058           if(!tags[j]) break;           /* tag not found */
2059         } else {
2060           /* Track must contain this word */
2061           for(j = 0; twords[j]; ++j)
2062             if(!strcmp(w[i], twords[j])) break; /* word found */
2063           if(!twords[j]) break;         /* word not found */
2064         }
2065       }
2066       if(i >= nwordlist)                /* all words found */
2067         vector_append(&u, v.vec[n]);
2068     }
2069     break;
2070   fail:
2071     trackdb_closecursor(cursor);
2072     cursor = 0;
2073     trackdb_abort_transaction(tid);
2074     info("retrying search");
2075   }
2076   trackdb_commit_transaction(tid);
2077   vector_terminate(&u);
2078   if(ntracks)
2079     *ntracks = u.nvec;
2080   return u.vec;
2081 }
2082
2083 /* trackdb_scan **************************************************************/
2084
2085 int trackdb_scan(const char *root,
2086                  int (*callback)(const char *track,
2087                                  struct kvp *data,
2088                                  struct kvp *prefs,
2089                                  void *u,
2090                                  DB_TXN *tid),
2091                  void *u,
2092                  DB_TXN *tid) {
2093   DBC *cursor;
2094   DBT k, d, pd;
2095   const size_t root_len = root ? strlen(root) : 0;
2096   int err, cberr;
2097   struct kvp *data, *prefs;
2098   const char *track;
2099
2100   cursor = trackdb_opencursor(trackdb_tracksdb, tid);
2101   if(root)
2102     err = cursor->c_get(cursor, make_key(&k, root), prepare_data(&d),
2103                         DB_SET_RANGE);
2104   else {
2105     memset(&k, 0, sizeof k);
2106     err = cursor->c_get(cursor, &k, prepare_data(&d),
2107                         DB_FIRST);
2108   }
2109   while(!err) {
2110     if(!root
2111        || (k.size > root_len
2112            && !strncmp(k.data, root, root_len)
2113            && ((char *)k.data)[root_len] == '/')) {
2114       data = kvp_urldecode(d.data, d.size);
2115       if(kvp_get(data, "_path")) {
2116         track = xstrndup(k.data, k.size);
2117         /* TODO: trackdb_prefsdb is currently a DB_HASH.  This means we have to
2118          * do a lookup for every single track.  In fact this is quite quick:
2119          * with around 10,000 tracks a complete scan is around 0.3s on my
2120          * 2.2GHz Athlon.  However, if it were a DB_BTREE, we could do the same
2121          * linear walk as we already do over trackdb_tracksdb, and probably get
2122          * even higher performance.  That would require upgrade logic to
2123          * translate old databases though.
2124          */
2125         switch(err = trackdb_prefsdb->get(trackdb_prefsdb, tid, &k,
2126                                           prepare_data(&pd), 0)) {
2127         case 0:
2128           prefs = kvp_urldecode(pd.data, pd.size);
2129           break;
2130         case DB_NOTFOUND:
2131           prefs = 0;
2132           break;
2133         case DB_LOCK_DEADLOCK:
2134           error(0, "getting prefs: %s", db_strerror(err));
2135           trackdb_closecursor(cursor);
2136           return err;
2137         default:
2138           fatal(0, "getting prefs: %s", db_strerror(err));
2139         }
2140         /* Advance to the next track before the callback so that the callback
2141          * may safely delete the track */
2142         err = cursor->c_get(cursor, &k, &d, DB_NEXT);
2143         if((cberr = callback(track, data, prefs, u, tid))) {
2144           err = cberr;
2145           break;
2146         }
2147       } else
2148         err = cursor->c_get(cursor, &k, &d, DB_NEXT);
2149     } else
2150       break;
2151   }
2152   trackdb_closecursor(cursor);
2153   switch(err) {
2154   case EINTR:
2155     return err;
2156   case 0:
2157   case DB_NOTFOUND:
2158     return 0;
2159   case DB_LOCK_DEADLOCK:
2160     error(0, "c->c_get: %s", db_strerror(err));
2161     return err;
2162   default:
2163     fatal(0, "c->c_get: %s", db_strerror(err));
2164   }
2165 }
2166
2167 /* trackdb_rescan ************************************************************/
2168
2169 /** @brief Node in the list of rescan-complete callbacks */
2170 struct rescanned_node {
2171   struct rescanned_node *next;
2172   void (*rescanned)(void *ru);
2173   void *ru;
2174 };
2175
2176 /** @brief List of rescan-complete callbacks */
2177 static struct rescanned_node *rescanned_list;
2178
2179 /** @brief Add a rescan completion callback */
2180 void trackdb_add_rescanned(void (*rescanned)(void *ru),
2181                            void *ru) {
2182   if(rescanned) {
2183     struct rescanned_node *n = xmalloc(sizeof *n);
2184     n->next = rescanned_list;
2185     n->rescanned = rescanned;
2186     n->ru = ru;
2187     rescanned_list = n;
2188   }
2189 }
2190
2191 /* called when the rescanner terminates */
2192 static int reap_rescan(ev_source attribute((unused)) *ev,
2193                        pid_t pid,
2194                        int status,
2195                        const struct rusage attribute((unused)) *rusage,
2196                        void attribute((unused)) *u) {
2197   if(pid == rescan_pid) rescan_pid = -1;
2198   if(status)
2199     error(0, RESCAN": %s", wstat(status));
2200   else
2201     D((RESCAN" terminated: %s", wstat(status)));
2202   /* Our cache of file lookups is out of date now */
2203   cache_clean(&cache_files_type);
2204   eventlog("rescanned", (char *)0);
2205   /* Call rescanned callbacks */
2206   while(rescanned_list) {
2207     void (*rescanned)(void *u_) = rescanned_list->rescanned;
2208     void *ru = rescanned_list->ru;
2209
2210     rescanned_list = rescanned_list->next;
2211     rescanned(ru);
2212   }
2213   return 0;
2214 }
2215
2216 /** @brief Initiate a rescan
2217  * @param ev Event loop or 0 to block
2218  * @param recheck 1 to recheck lengths, 0 to suppress check
2219  * @param rescanned Called on completion (if not NULL)
2220  * @param u Passed to @p rescanned
2221  */
2222 void trackdb_rescan(ev_source *ev, int recheck,
2223                     void (*rescanned)(void *ru),
2224                     void *ru) {
2225   int w;
2226
2227   if(rescan_pid != -1) {
2228     trackdb_add_rescanned(rescanned, ru);
2229     error(0, "rescan already underway");
2230     return;
2231   }
2232   rescan_pid = subprogram(ev, -1, RESCAN,
2233                           recheck ? "--check" : "--no-check",
2234                           (char *)0);
2235   trackdb_add_rescanned(rescanned, ru);
2236   if(ev) {
2237     ev_child(ev, rescan_pid, 0, reap_rescan, 0);
2238     D(("started rescanner"));
2239   } else {
2240     /* This is the first rescan, we block until it is complete */
2241     while(waitpid(rescan_pid, &w, 0) < 0 && errno == EINTR)
2242       ;
2243     reap_rescan(0, rescan_pid, w, 0, 0);
2244   }
2245 }
2246
2247 int trackdb_rescan_cancel(void) {
2248   if(rescan_pid == -1) return 0;
2249   if(kill(rescan_pid, SIGTERM) < 0)
2250     fatal(errno, "error killing rescanner");
2251   rescan_pid = -1;
2252   return 1;
2253 }
2254
2255 /** @brief Return true if a rescan is underway */
2256 int trackdb_rescan_underway(void) {
2257   return rescan_pid != -1;
2258 }
2259
2260 /* global prefs **************************************************************/
2261
2262 void trackdb_set_global(const char *name,
2263                         const char *value,
2264                         const char *who) {
2265   DB_TXN *tid;
2266   int err;
2267   int state;
2268
2269   for(;;) {
2270     tid = trackdb_begin_transaction();
2271     if(!(err = trackdb_set_global_tid(name, value, tid)))
2272       break;
2273     trackdb_abort_transaction(tid);
2274   }
2275   trackdb_commit_transaction(tid);
2276   /* log important state changes */
2277   if(!strcmp(name, "playing")) {
2278     state = !value || !strcmp(value, "yes");
2279     info("playing %s by %s",
2280          state ? "enabled" : "disabled",
2281          who ? who : "-");
2282     eventlog("state", state ? "enable_play" : "disable_play", (char *)0);
2283   }
2284   if(!strcmp(name, "random-play")) {
2285     state = !value || !strcmp(value, "yes");
2286     info("random play %s by %s",
2287          state ? "enabled" : "disabled",
2288          who ? who : "-");
2289     eventlog("state", state ? "enable_random" : "disable_random", (char *)0);
2290   }
2291 }
2292
2293 int trackdb_set_global_tid(const char *name,
2294                            const char *value,
2295                            DB_TXN *tid) {
2296   DBT k, d;
2297   int err;
2298
2299   memset(&k, 0, sizeof k);
2300   memset(&d, 0, sizeof d);
2301   k.data = (void *)name;
2302   k.size = strlen(name);
2303   if(value) {
2304     d.data = (void *)value;
2305     d.size = strlen(value);
2306   }
2307   if(value)
2308     err = trackdb_globaldb->put(trackdb_globaldb, tid, &k, &d, 0);
2309   else
2310     err = trackdb_globaldb->del(trackdb_globaldb, tid, &k, 0);
2311   if(err == DB_LOCK_DEADLOCK) return err;
2312   if(err)
2313     fatal(0, "error updating database: %s", db_strerror(err));
2314   return 0;
2315 }
2316
2317 const char *trackdb_get_global(const char *name) {
2318   DB_TXN *tid;
2319   int err;
2320   const char *r;
2321
2322   for(;;) {
2323     tid = trackdb_begin_transaction();
2324     if(!(err = trackdb_get_global_tid(name, tid, &r)))
2325       break;
2326     trackdb_abort_transaction(tid);
2327   }
2328   trackdb_commit_transaction(tid);
2329   return r;
2330 }
2331
2332 int trackdb_get_global_tid(const char *name,
2333                            DB_TXN *tid,
2334                            const char **rp) {
2335   DBT k, d;
2336   int err;
2337
2338   memset(&k, 0, sizeof k);
2339   k.data = (void *)name;
2340   k.size = strlen(name);
2341   switch(err = trackdb_globaldb->get(trackdb_globaldb, tid, &k,
2342                                      prepare_data(&d), 0)) {
2343   case 0:
2344     *rp = xstrndup(d.data, d.size);
2345     return 0;
2346   case DB_NOTFOUND:
2347     *rp = 0;
2348     return 0;
2349   case DB_LOCK_DEADLOCK:
2350     return err;
2351   default:
2352     fatal(0, "error reading database: %s", db_strerror(err));
2353   }
2354 }
2355
2356 /** @brief Retrieve the most recently added tracks
2357  * @param ntracksp Where to put count, or 0
2358  * @param maxtracks Maximum number of tracks to retrieve
2359  * @return null-terminated array of track names
2360  *
2361  * The most recently added track is first in the array.
2362  */
2363 char **trackdb_new(int *ntracksp,
2364                    int maxtracks) {
2365   DB_TXN *tid;
2366   char **tracks;
2367
2368   for(;;) {
2369     tid = trackdb_begin_transaction();
2370     tracks = trackdb_new_tid(ntracksp, maxtracks, tid);
2371     if(tracks)
2372       break;
2373     trackdb_abort_transaction(tid);
2374   }
2375   trackdb_commit_transaction(tid);
2376   return tracks;
2377 }
2378
2379 /** @brief Retrieve the most recently added tracks
2380  * @param ntracksp Where to put count, or 0
2381  * @param maxtracks Maximum number of tracks to retrieve, or 0 for all
2382  * @param tid Transaction ID
2383  * @return null-terminated array of track names, or NULL on deadlock
2384  *
2385  * The most recently added track is first in the array.
2386  */
2387 static char **trackdb_new_tid(int *ntracksp,
2388                               int maxtracks,
2389                               DB_TXN *tid) {
2390   DBC *c;
2391   DBT k, d;
2392   int err = 0;
2393   struct vector tracks[1];
2394
2395   vector_init(tracks);
2396   c = trackdb_opencursor(trackdb_noticeddb, tid);
2397   while((maxtracks <= 0 || tracks->nvec < maxtracks)
2398         && !(err = c->c_get(c, prepare_data(&k), prepare_data(&d), DB_PREV)))
2399     vector_append(tracks, xstrndup(d.data, d.size));
2400   switch(err) {
2401   case 0:                               /* hit maxtracks */
2402   case DB_NOTFOUND:                     /* ran out of tracks */
2403     break;
2404   case DB_LOCK_DEADLOCK:
2405     trackdb_closecursor(c);
2406     return 0;
2407   default:
2408     fatal(0, "error reading noticed.db: %s", db_strerror(err));
2409   }
2410   if((err = trackdb_closecursor(c)))
2411     return 0;                           /* deadlock */
2412   vector_terminate(tracks);
2413   if(ntracksp)
2414     *ntracksp = tracks->nvec;
2415   return tracks->vec;
2416 }
2417
2418 /** @brief Expire noticed.db
2419  * @param earliest Earliest timestamp to keep
2420  */
2421 void trackdb_expire_noticed(time_t earliest) {
2422   DB_TXN *tid;
2423
2424   for(;;) {
2425     tid = trackdb_begin_transaction();
2426     if(!trackdb_expire_noticed_tid(earliest, tid))
2427       break;
2428     trackdb_abort_transaction(tid);
2429   }
2430   trackdb_commit_transaction(tid);
2431 }
2432
2433 /** @brief Expire noticed.db
2434  * @param earliest Earliest timestamp to keep
2435  * @param tid Transaction ID
2436  * @return 0 or DB_LOCK_DEADLOCK
2437  */
2438 static int trackdb_expire_noticed_tid(time_t earliest, DB_TXN *tid) {
2439   DBC *c;
2440   DBT k, d;
2441   int err = 0, ret;
2442   time_t when;
2443   uint32_t *kk;
2444   int count = 0;
2445
2446   c = trackdb_opencursor(trackdb_noticeddb, tid);
2447   while(!(err = c->c_get(c, prepare_data(&k), prepare_data(&d), DB_NEXT))) {
2448     kk = k.data;
2449     when = (time_t)(((uint64_t)ntohl(kk[0]) << 32) + ntohl(kk[1]));
2450     if(when >= earliest)
2451       break;
2452     if((err = c->c_del(c, 0))) {
2453       if(err != DB_LOCK_DEADLOCK)
2454         fatal(0, "error deleting expired noticed.db entry: %s",
2455               db_strerror(err));
2456       break;
2457     }
2458     ++count;
2459   }
2460   if(err == DB_NOTFOUND)
2461     err = 0;
2462   if(err && err != DB_LOCK_DEADLOCK)
2463     fatal(0, "error expiring noticed.db: %s", db_strerror(err));
2464   ret = err;
2465   if((err = trackdb_closecursor(c))) {
2466     if(err != DB_LOCK_DEADLOCK)
2467       fatal(0, "error closing cursor: %s", db_strerror(err));
2468     ret = err;
2469   }
2470   if(!ret && count)
2471     info("expired %d tracks from noticed.db", count);
2472   return ret;
2473 }
2474
2475 /* tidying up ****************************************************************/
2476
2477 void trackdb_gc(void) {
2478   int err;
2479   char **logfiles;
2480
2481   if((err = trackdb_env->txn_checkpoint(trackdb_env,
2482                                         config->checkpoint_kbyte,
2483                                         config->checkpoint_min,
2484                                         0)))
2485     fatal(0, "trackdb_env->txn_checkpoint: %s", db_strerror(err));
2486   if((err = trackdb_env->log_archive(trackdb_env, &logfiles, DB_ARCH_REMOVE)))
2487     fatal(0, "trackdb_env->log_archive: %s", db_strerror(err));
2488   /* This makes catastrophic recovery impossible.  However, the user can still
2489    * preserve the important data by using disorder-dump to snapshot their
2490    * prefs, and later to restore it.  This is likely to have much small
2491    * long-term storage requirements than record the db logfiles. */
2492 }
2493
2494 /* user database *************************************************************/
2495
2496 /** @brief Return true if @p user is trusted */
2497 static int trusted(const char *user) {
2498   int n;
2499
2500   for(n = 0; (n < config->trust.n
2501               && strcmp(config->trust.s[n], user)); ++n)
2502     ;
2503   return n < config->trust.n;
2504 }
2505
2506 /** @brief Return non-zero for a valid username
2507  *
2508  * Currently we only allow the letters and digits in ASCII.  We could be more
2509  * liberal than this but it is a nice simple test.  It is critical that
2510  * semicolons are never allowed.
2511  */
2512 static int valid_username(const char *user) {
2513   if(!*user)
2514     return 0;
2515   while(*user) {
2516     const uint8_t c = *user++;
2517     /* For now we are very strict */
2518     if((c >= 'a' && c <= 'z')
2519        || (c >= 'A' && c <= 'Z')
2520        || (c >= '0' && c <= '9'))
2521       /* ok */;
2522     else
2523       return 0;
2524   }
2525   return 1;
2526 }
2527
2528 /** @brief Add a user */
2529 static int create_user(const char *user,
2530                        const char *password,
2531                        const char *rights,
2532                        const char *email,
2533                        const char *confirmation,
2534                        DB_TXN *tid,
2535                        uint32_t flags) {
2536   struct kvp *k = 0;
2537   char s[64];
2538
2539   /* sanity check user */
2540   if(!valid_username(user)) {
2541     error(0, "invalid username '%s'", user);
2542     return -1;
2543   }
2544   if(parse_rights(rights, 0, 1)) {
2545     error(0, "invalid rights string");
2546     return -1;
2547   }
2548   /* data for this user */
2549   if(password)
2550     kvp_set(&k, "password", password);
2551   kvp_set(&k, "rights", rights);
2552   if(email)
2553     kvp_set(&k, "email", email);
2554   if(confirmation)
2555     kvp_set(&k, "confirmation", confirmation);
2556   snprintf(s, sizeof s, "%jd", (intmax_t)time(0));
2557   kvp_set(&k, "created", s);
2558   return trackdb_putdata(trackdb_usersdb, user, k, tid, flags);
2559 }
2560
2561 /** @brief Add one pre-existing user */
2562 static int one_old_user(const char *user, const char *password,
2563                         DB_TXN *tid) {
2564   const char *rights;
2565
2566   /* www-data doesn't get added */
2567   if(!strcmp(user, "www-data")) {
2568     info("not adding www-data to user database");
2569     return 0;
2570   }
2571   /* pick rights */
2572   if(!strcmp(user, "root"))
2573     rights = "all";
2574   else if(trusted(user)) {
2575     rights_type r;
2576
2577     parse_rights(config->default_rights, &r, 1);
2578     r &= ~(rights_type)(RIGHT_SCRATCH__MASK|RIGHT_MOVE__MASK|RIGHT_REMOVE__MASK);
2579     r |= (RIGHT_ADMIN|RIGHT_RESCAN
2580           |RIGHT_SCRATCH_ANY|RIGHT_MOVE_ANY|RIGHT_REMOVE_ANY);
2581     rights = rights_string(r);
2582   } else
2583     rights = config->default_rights;
2584   return create_user(user, password, rights, 0/*email*/, 0/*confirmation*/,
2585                      tid, DB_NOOVERWRITE);
2586 }
2587
2588 static int trackdb_old_users_tid(DB_TXN *tid) {
2589   int n;
2590
2591   for(n = 0; n < config->allow.n; ++n) {
2592     switch(one_old_user(config->allow.s[n].s[0], config->allow.s[n].s[1],
2593                         tid)) {
2594     case 0:
2595       info("created user %s from 'allow' directive", config->allow.s[n].s[0]);
2596       break;
2597     case DB_KEYEXIST:
2598       error(0, "user %s already exists, delete 'allow' directive",
2599             config->allow.s[n].s[0]);
2600           /* This won't ever become fatal - eventually 'allow' will be
2601            * disabled. */
2602       break;
2603     case DB_LOCK_DEADLOCK:
2604       return DB_LOCK_DEADLOCK;
2605     }
2606   }
2607   return 0;
2608 }
2609
2610 /** @brief Read old 'allow' directives and copy them to the users database */
2611 void trackdb_old_users(void) {
2612   int e;
2613
2614   if(config->allow.n)
2615     WITH_TRANSACTION(trackdb_old_users_tid(tid));
2616 }
2617
2618 /** @brief Create a root user in the user database if there is none */
2619 void trackdb_create_root(void) {
2620   int e;
2621   uint8_t pwbin[12];
2622   char *pw;
2623
2624   /* Choose a new root password */
2625   gcry_randomize(pwbin, sizeof pwbin, GCRY_STRONG_RANDOM);
2626   pw = mime_to_base64(pwbin, sizeof pwbin);
2627   /* Create the root user if it does not exist */
2628   WITH_TRANSACTION(create_user("root", pw, "all",
2629                                0/*email*/, 0/*confirmation*/,
2630                                tid, DB_NOOVERWRITE));
2631   if(e == 0)
2632     info("created root user");
2633 }
2634
2635 /** @brief Find a user's password from the database
2636  * @param user Username
2637  * @return Password or NULL
2638  *
2639  * Only works if running as a user that can read the database!
2640  *
2641  * If the user exists but has no password, "" is returned.
2642  */
2643 const char *trackdb_get_password(const char *user) {
2644   int e;
2645   struct kvp *k;
2646   const char *password;
2647
2648   WITH_TRANSACTION(trackdb_getdata(trackdb_usersdb, user, &k, tid));
2649   if(e)
2650     return 0;
2651   password = kvp_get(k, "password");
2652   return password ? password : "";
2653 }
2654
2655 /** @brief Add a new user
2656  * @param user Username
2657  * @param password Password or NULL
2658  * @param rights Initial rights
2659  * @param email Email address or NULL
2660  * @param confirmation Confirmation string or NULL
2661  * @return 0 on success, non-0 on error
2662  */
2663 int trackdb_adduser(const char *user,
2664                     const char *password,
2665                     const char *rights,
2666                     const char *email,
2667                     const char *confirmation) {
2668   int e;
2669
2670   WITH_TRANSACTION(create_user(user, password, rights, email, confirmation,
2671                                tid, DB_NOOVERWRITE));
2672   if(e) {
2673     error(0, "cannot create user '%s' because they already exist", user);
2674     return -1;
2675   } else {
2676     if(email)
2677       info("created user '%s' with rights '%s' and email address '%s'",
2678            user, rights, email);
2679     else
2680       info("created user '%s' with rights '%s'", user, rights);
2681     return 0;
2682   }
2683 }
2684
2685 /** @brief Delete a user
2686  * @param user User to delete
2687  * @return 0 on success, non-0 if the user didn't exist anyway
2688  */
2689 int trackdb_deluser(const char *user) {
2690   int e;
2691
2692   WITH_TRANSACTION(trackdb_delkey(trackdb_usersdb, user, tid));
2693   if(e) {
2694     error(0, "cannot delete user '%s' because they do not exist", user);
2695     return -1;
2696   }
2697   info("deleted user '%s'", user);
2698   return 0;
2699 }
2700
2701 /** @brief Get user information
2702  * @param user User to query
2703  * @return Linked list of user information or NULL if user does not exist
2704  *
2705  * Every user has at least a @c rights entry so NULL can be used to mean no
2706  * such user safely.
2707  */
2708 struct kvp *trackdb_getuserinfo(const char *user) {
2709   int e;
2710   struct kvp *k;
2711
2712   WITH_TRANSACTION(trackdb_getdata(trackdb_usersdb, user, &k, tid));
2713   if(e)
2714     return 0;
2715   else
2716     return k;
2717 }
2718
2719 /** @brief Edit user information
2720  * @param user User to edit
2721  * @param key Key to change
2722  * @param value Value to set, or NULL to remove
2723  * @param tid Transaction ID
2724  * @return 0, DB_LOCK_DEADLOCK or DB_NOTFOUND
2725  */
2726 static int trackdb_edituserinfo_tid(const char *user, const char *key,
2727                                     const char *value, DB_TXN *tid) {
2728   struct kvp *k;
2729   int e;
2730
2731   if((e = trackdb_getdata(trackdb_usersdb, user, &k, tid)))
2732     return e;
2733   if(!kvp_set(&k, key, value))
2734     return 0;                           /* no change */
2735   return trackdb_putdata(trackdb_usersdb, user, k, tid, 0);
2736 }
2737
2738 /** @brief Edit user information
2739  * @param user User to edit
2740  * @param key Key to change
2741  * @param value Value to set, or NULL to remove
2742  * @return 0 on success, non-0 on error
2743  */
2744 int trackdb_edituserinfo(const char *user,
2745                          const char *key, const char *value) {
2746   int e;
2747
2748   if(!strcmp(key, "rights")) {
2749     if(!value) {
2750       error(0, "cannot remove 'rights' key from user '%s'", user);
2751       return -1;
2752     }
2753     if(parse_rights(value, 0, 1)) {
2754       error(0, "invalid rights string");
2755       return -1;
2756     }
2757   } else if(!strcmp(key, "email")) {
2758     if(*value) {
2759       if(!strchr(value, '@')) {
2760         error(0, "invalid email address '%s' for user '%s'", user, value);
2761         return -1;
2762       }
2763     } else
2764       value = 0;                        /* no email -> remove key */
2765   } else if(!strcmp(key, "created")) {
2766     error(0, "cannot change creation date for user '%s'", user);
2767     return -1;
2768   } else if(strcmp(key, "password")
2769             && !strcmp(key, "confirmation")) {
2770     error(0, "unknown user info key '%s' for user '%s'", key, user);
2771     return -1;
2772   }
2773   WITH_TRANSACTION(trackdb_edituserinfo_tid(user, key, value, tid));
2774   if(e) {
2775     error(0, "unknown user '%s'", user);
2776     return -1;
2777   } else
2778     return 0;
2779 }
2780
2781 /** @brief List all users
2782  * @return NULL-terminated list of users
2783  */
2784 char **trackdb_listusers(void) {
2785   int e;
2786   struct vector v[1];
2787
2788   vector_init(v);
2789   WITH_TRANSACTION(trackdb_listkeys(trackdb_usersdb, v, tid));
2790   return v->vec;
2791 }
2792
2793 /** @brief Confirm a user registration
2794  * @param user Username
2795  * @param confirmation Confirmation string
2796  * @param rightsp Where to put user rights
2797  * @param tid Transaction ID
2798  * @return 0 on success, non-0 on error
2799  */
2800 static int trackdb_confirm_tid(const char *user, const char *confirmation,
2801                                rights_type *rightsp,
2802                                DB_TXN *tid) {
2803   const char *stored_confirmation;
2804   struct kvp *k;
2805   int e;
2806   const char *rights;
2807
2808   if((e = trackdb_getdata(trackdb_usersdb, user, &k, tid)))
2809     return e;
2810   if(!(stored_confirmation = kvp_get(k, "confirmation"))) {
2811     error(0, "already confirmed user '%s'", user);
2812     /* DB claims -30,800 to -30,999 so -1 should be a safe bet */
2813     return -1;
2814   }
2815   if(!(rights = kvp_get(k, "rights"))) {
2816     error(0, "no rights for unconfirmed user '%s'", user);
2817     return -1;
2818   }
2819   if(parse_rights(rights, rightsp, 1))
2820     return -1;
2821   if(strcmp(confirmation, stored_confirmation)) {
2822     error(0, "wrong confirmation string for user '%s'", user);
2823     return -1;
2824   }
2825   /* 'sall good */
2826   kvp_set(&k, "confirmation", 0);
2827   return trackdb_putdata(trackdb_usersdb, user, k, tid, 0);
2828 }
2829
2830 /** @brief Confirm a user registration
2831  * @param user Username
2832  * @param confirmation Confirmation string
2833  * @param rightsp Where to put user rights
2834  * @return 0 on success, non-0 on error
2835  */
2836 int trackdb_confirm(const char *user, const char *confirmation,
2837                     rights_type *rightsp) {
2838   int e;
2839
2840   WITH_TRANSACTION(trackdb_confirm_tid(user, confirmation, rightsp, tid));
2841   switch(e) {
2842   case 0:
2843     info("registration confirmed for user '%s'", user);
2844     return 0;
2845   case DB_NOTFOUND:
2846     error(0, "confirmation for nonexistent user '%s'", user);
2847     return -1;
2848   default:                              /* already reported */
2849     return -1;
2850   }
2851 }
2852
2853 /*
2854 Local Variables:
2855 c-basic-offset:2
2856 comment-column:40
2857 fill-column:79
2858 indent-tabs-mode:nil
2859 End:
2860 */