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

   1 /*
   2  * This file is part of DisOrder
   3  * Copyright (C) 2005, 2006, 2007 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
  21 #include <config.h>
  22 #include "types.h"
  23
  24 #include <string.h>
  25 #include <stdio.h>
  26 #include <db.h>
  27 #include <sys/socket.h>
  28 #include <pcre.h>
  29 #include <assert.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <stddef.h>
  33 #include <sys/time.h>
  34 #include <sys/resource.h>
  35 #include <time.h>
  36 #include <arpa/inet.h>
  37
  38 #include "event.h"
  39 #include "mem.h"
  40 #include "kvp.h"
  41 #include "log.h"
  42 #include "vector.h"
  43 #include "trackdb.h"
  44 #include "configuration.h"
  45 #include "syscalls.h"
  46 #include "wstat.h"
  47 #include "words.h"
  48 #include "printf.h"
  49 #include "filepart.h"
  50 #include "trackname.h"
  51 #include "trackdb-int.h"
  52 #include "logfd.h"
  53 #include "cache.h"
  54 #include "eventlog.h"
  55 #include "hash.h"
  56
  57 #define RESCAN "disorder-rescan"
  58 #define DEADLOCK "disorder-deadlock"
  59
  60 static const char *getpart(const char *track,
  61                            const char *context,
  62                            const char *part,
  63                            const struct kvp *p,
  64                            int *used_db);
  65 static int trackdb_alltags_tid(DB_TXN *tid, char ***taglistp);
  66 static int trackdb_get_global_tid(const char *name,
  67                                   DB_TXN *tid,
  68                                   const char **rp);
  69 static char **trackdb_new_tid(int *ntracksp,
  70                               int maxtracks,
  71                               DB_TXN *tid);
  72
  73 const struct cache_type cache_files_type = { 86400 };
  74 unsigned long cache_files_hits, cache_files_misses;
  75
  76 /* setup and teardown ********************************************************/
  77
  78 static const char *home;                /* home had better not change */
  79 DB_ENV *trackdb_env;                    /* db environment */
  80 DB *trackdb_tracksdb;                   /* the db itself */
  81 DB *trackdb_prefsdb;                    /* preferences */
  82 DB *trackdb_searchdb;                   /* the search database */
  83 DB *trackdb_tagsdb;                     /* the tags database */
  84 DB *trackdb_globaldb;                   /* global preferences */
  85 DB *trackdb_noticeddb;                   /* when track noticed */
  86 static pid_t db_deadlock_pid = -1;      /* deadlock manager PID */
  87 static pid_t rescan_pid = -1;           /* rescanner PID */
  88 static int initialized, opened;         /* state */
  89
  90 /* tracks matched by required_tags */
  91 static char **reqtracks;
  92 static size_t nreqtracks;
  93
  94 /* comparison function for keys */
  95 static int compare(DB attribute((unused)) *db_,
  96                    const DBT *a, const DBT *b) {
  97   return compare_path_raw(a->data, a->size, b->data, b->size);
  98 }
  99
 100 /* open environment */
 101 void trackdb_init(int recover) {
 102   int err;
 103   static int recover_type[] = { 0, DB_RECOVER, DB_RECOVER_FATAL };
 104
 105   /* sanity checks */
 106   assert(initialized == 0);
 107   ++initialized;
 108   if(home) {
 109     if(strcmp(home, config->home))
 110       fatal(0, "cannot change db home without server restart");
 111     home = config->home;
 112   }
 113
 114   /* create environment */
 115   if((err = db_env_create(&trackdb_env, 0))) fatal(0, "db_env_create: %s",
 116                                                    db_strerror(err));
 117   if((err = trackdb_env->set_alloc(trackdb_env,
 118                                    xmalloc_noptr, xrealloc_noptr, xfree)))
 119     fatal(0, "trackdb_env->set_alloc: %s", db_strerror(err));
 120   if((err = trackdb_env->set_lk_max_locks(trackdb_env, 10000)))
 121     fatal(0, "trackdb_env->set_lk_max_locks: %s", db_strerror(err));
 122   if((err = trackdb_env->set_lk_max_objects(trackdb_env, 10000)))
 123     fatal(0, "trackdb_env->set_lk_max_objects: %s", db_strerror(err));
 124   if((err = trackdb_env->open(trackdb_env, config->home,
 125                               DB_INIT_LOG
 126                               |DB_INIT_LOCK
 127                               |DB_INIT_MPOOL
 128                               |DB_INIT_TXN
 129                               |DB_CREATE
 130                               |recover_type[recover],
 131                               0666)))
 132     fatal(0, "trackdb_env->open %s: %s", config->home, db_strerror(err));
 133   trackdb_env->set_errpfx(trackdb_env, "DB");
 134   trackdb_env->set_errfile(trackdb_env, stderr);
 135   trackdb_env->set_verbose(trackdb_env, DB_VERB_DEADLOCK, 1);
 136   trackdb_env->set_verbose(trackdb_env, DB_VERB_RECOVERY, 1);
 137   trackdb_env->set_verbose(trackdb_env, DB_VERB_REPLICATION, 1);
 138   D(("initialized database environment"));
 139 }
 140
 141 /* called when deadlock manager terminates */
 142 static int reap_db_deadlock(ev_source attribute((unused)) *ev,
 143                             pid_t attribute((unused)) pid,
 144                             int status,
 145                             const struct rusage attribute((unused)) *rusage,
 146                             void attribute((unused)) *u) {
 147   db_deadlock_pid = -1;
 148   if(initialized)
 149     fatal(0, "deadlock manager unexpectedly terminated: %s",
 150           wstat(status));
 151   else
 152     D(("deadlock manager terminated: %s", wstat(status)));
 153   return 0;
 154 }
 155
 156 static pid_t subprogram(ev_source *ev, const char *prog) {
 157   pid_t pid;
 158   int lfd;
 159
 160   /* If we're in the background then trap subprocess stdout/stderr */
 161   if(!isatty(2))
 162     lfd = logfd(ev, prog);
 163   else
 164     lfd = -1;
 165   if(!(pid = xfork())) {
 166     exitfn = _exit;
 167     ev_signal_atfork(ev);
 168     signal(SIGPIPE, SIG_DFL);
 169     if(lfd != -1) {
 170       xdup2(lfd, 1);
 171       xdup2(lfd, 2);
 172     }
 173     /* If we were negatively niced, undo it.  We don't bother checking for
 174      * error, it's not that important. */
 175     setpriority(PRIO_PROCESS, 0, 0);
 176     execlp(prog, prog, "--config", configfile,
 177            debugging ? "--debug" : "--no-debug",
 178            (char *)0);
 179     fatal(errno, "error invoking %s", prog);
 180   }
 181   if(lfd != -1) xclose(lfd);
 182   return pid;
 183 }
 184
 185 /* start deadlock manager */
 186 void trackdb_master(ev_source *ev) {
 187   assert(db_deadlock_pid == -1);
 188   db_deadlock_pid = subprogram(ev, DEADLOCK);
 189   ev_child(ev, db_deadlock_pid, 0, reap_db_deadlock, 0);
 190   D(("started deadlock manager"));
 191 }
 192
 193 /* close environment */
 194 void trackdb_deinit(void) {
 195   int err;
 196
 197   /* sanity checks */
 198   assert(initialized == 1);
 199   --initialized;
 200
 201   /* close the environment */
 202   if((err = trackdb_env->close(trackdb_env, 0)))
 203     fatal(0, "trackdb_env->close: %s", db_strerror(err));
 204
 205   if(rescan_pid != -1 && kill(rescan_pid, SIGTERM) < 0)
 206     fatal(errno, "error killing rescanner");
 207
 208   /* terminate the deadlock manager */
 209   if(db_deadlock_pid != -1 && kill(db_deadlock_pid, SIGTERM) < 0)
 210     fatal(errno, "error killing deadlock manager");
 211   db_deadlock_pid = -1;
 212
 213   D(("deinitialized database environment"));
 214 }
 215
 216 /* open a specific database */
 217 static DB *open_db(const char *path,
 218                    u_int32_t dbflags,
 219                    DBTYPE dbtype,
 220                    u_int32_t openflags,
 221                    int mode) {
 222   int err;
 223   DB *db;
 224
 225   D(("open %s", path));
 226   path = config_get_file(path);
 227   if((err = db_create(&db, trackdb_env, 0)))
 228     fatal(0, "db_create %s: %s", path, db_strerror(err));
 229   if(dbflags)
 230     if((err = db->set_flags(db, dbflags)))
 231       fatal(0, "db->set_flags %s: %s", path, db_strerror(err));
 232   if(dbtype == DB_BTREE)
 233     if((err = db->set_bt_compare(db, compare)))
 234       fatal(0, "db->set_bt_compare %s: %s", path, db_strerror(err));
 235   if((err = db->open(db, 0, path, 0, dbtype,
 236                      openflags | DB_AUTO_COMMIT, mode)))
 237     fatal(0, "db->open %s: %s", path, db_strerror(err));
 238   return db;
 239 }
 240
 241 /* open track databases */
 242 void trackdb_open(void) {
 243   /* sanity checks */
 244   assert(opened == 0);
 245   ++opened;
 246   /* open the databases */
 247   trackdb_tracksdb = open_db("tracks.db",
 248                              DB_RECNUM, DB_BTREE, DB_CREATE, 0666);
 249   trackdb_searchdb = open_db("search.db",
 250                              DB_DUP|DB_DUPSORT, DB_HASH, DB_CREATE, 0666);
 251   trackdb_tagsdb = open_db("tags.db",
 252                            DB_DUP|DB_DUPSORT, DB_HASH, DB_CREATE, 0666);
 253   trackdb_prefsdb = open_db("prefs.db", 0, DB_HASH, DB_CREATE, 0666);
 254   trackdb_globaldb = open_db("global.db", 0, DB_HASH, DB_CREATE, 0666);
 255   trackdb_noticeddb = open_db("noticed.db",
 256                              DB_DUPSORT, DB_BTREE, DB_CREATE, 0666);
 257   D(("opened databases"));
 258 }
 259
 260 /* close track databases */
 261 void trackdb_close(void) {
 262   int err;
 263
 264   /* sanity checks */
 265   assert(opened == 1);
 266   --opened;
 267   if((err = trackdb_tracksdb->close(trackdb_tracksdb, 0)))
 268     fatal(0, "error closing tracks.db: %s", db_strerror(err));
 269   if((err = trackdb_searchdb->close(trackdb_searchdb, 0)))
 270     fatal(0, "error closing search.db: %s", db_strerror(err));
 271   if((err = trackdb_tagsdb->close(trackdb_tagsdb, 0)))
 272     fatal(0, "error closing tags.db: %s", db_strerror(err));
 273   if((err = trackdb_prefsdb->close(trackdb_prefsdb, 0)))
 274     fatal(0, "error closing prefs.db: %s", db_strerror(err));
 275   if((err = trackdb_globaldb->close(trackdb_globaldb, 0)))
 276     fatal(0, "error closing global.db: %s", db_strerror(err));
 277   if((err = trackdb_noticeddb->close(trackdb_noticeddb, 0)))
 278     fatal(0, "error closing noticed.db: %s", db_strerror(err));
 279   trackdb_tracksdb = trackdb_searchdb = trackdb_prefsdb = 0;
 280   trackdb_tagsdb = trackdb_globaldb = 0;
 281   D(("closed databases"));
 282 }
 283
 284 /* generic db routines *******************************************************/
 285
 286 /* fetch and decode a database entry.  Returns 0, DB_NOTFOUND or
 287  * DB_LOCK_DEADLOCK. */
 288 int trackdb_getdata(DB *db,
 289                     const char *track,
 290                     struct kvp **kp,
 291                     DB_TXN *tid) {
 292   int err;
 293   DBT key, data;
 294
 295   switch(err = db->get(db, tid, make_key(&key, track),
 296                        prepare_data(&data), 0)) {
 297   case 0:
 298     *kp = kvp_urldecode(data.data, data.size);
 299     return 0;
 300   case DB_NOTFOUND:
 301     *kp = 0;
 302     return err;
 303   case DB_LOCK_DEADLOCK:
 304     error(0, "error querying database: %s", db_strerror(err));
 305     return err;
 306   default:
 307     fatal(0, "error querying database: %s", db_strerror(err));
 308   }
 309 }
 310
 311 /* encode and store a database entry.  Returns 0, DB_KEYEXIST or
 312  * DB_LOCK_DEADLOCK. */
 313 int trackdb_putdata(DB *db,
 314                     const char *track,
 315                     const struct kvp *k,
 316                     DB_TXN *tid,
 317                     u_int32_t flags) {
 318   int err;
 319   DBT key, data;
 320
 321   switch(err = db->put(db, tid, make_key(&key, track),
 322                        encode_data(&data, k), flags)) {
 323   case 0:
 324   case DB_KEYEXIST:
 325     return err;
 326   case DB_LOCK_DEADLOCK:
 327     error(0, "error updating database: %s", db_strerror(err));
 328     return err;
 329   default:
 330     fatal(0, "error updating database: %s", db_strerror(err));
 331   }
 332 }
 333
 334 /* delete a database entry */
 335 int trackdb_delkey(DB *db,
 336                    const char *track,
 337                    DB_TXN *tid) {
 338   int err;
 339
 340   DBT key;
 341   switch(err = db->del(db, tid, make_key(&key, track), 0)) {
 342   case 0:
 343   case DB_NOTFOUND:
 344     return 0;
 345   case DB_LOCK_DEADLOCK:
 346     error(0, "error updating database: %s", db_strerror(err));
 347     return err;
 348   default:
 349     fatal(0, "error updating database: %s", db_strerror(err));
 350   }
 351 }
 352
 353 /* open a database cursor */
 354 DBC *trackdb_opencursor(DB *db, DB_TXN *tid) {
 355   int err;
 356   DBC *c;
 357
 358   switch(err = db->cursor(db, tid, &c, 0)) {
 359   case 0: break;
 360   default: fatal(0, "error creating cursor: %s", db_strerror(err));
 361   }
 362   return c;
 363 }
 364
 365 /* close a database cursor; returns 0 or DB_LOCK_DEADLOCK */
 366 int trackdb_closecursor(DBC *c) {
 367   int err;
 368
 369   if(!c) return 0;
 370   switch(err = c->c_close(c)) {
 371   case 0:
 372     return err;
 373   case DB_LOCK_DEADLOCK:
 374     error(0, "error closing cursor: %s", db_strerror(err));
 375     return err;
 376   default:
 377     fatal(0, "error closing cursor: %s", db_strerror(err));
 378   }
 379 }
 380
 381 /* delete a (key,data) pair.  Returns 0, DB_NOTFOUND or DB_LOCK_DEADLOCK. */
 382 int trackdb_delkeydata(DB *db,
 383                        const char *word,
 384                        const char *track,
 385                        DB_TXN *tid) {
 386   int err;
 387   DBC *c;
 388   DBT key, data;
 389
 390   c = trackdb_opencursor(db, tid);
 391   switch(err = c->c_get(c, make_key(&key, word),
 392                         make_key(&data, track), DB_GET_BOTH)) {
 393   case 0:
 394     switch(err = c->c_del(c, 0)) {
 395     case 0:
 396       break;
 397     case DB_KEYEMPTY:
 398       err = 0;
 399       break;
 400     case DB_LOCK_DEADLOCK:
 401       error(0, "error updating database: %s", db_strerror(err));
 402       break;
 403     default:
 404       fatal(0, "c->c_del: %s", db_strerror(err));
 405     }
 406     break;
 407   case DB_NOTFOUND:
 408     break;
 409   case DB_LOCK_DEADLOCK:
 410     error(0, "error updating database: %s", db_strerror(err));
 411     break;
 412   default:
 413     fatal(0, "c->c_get: %s", db_strerror(err));
 414   }
 415   if(trackdb_closecursor(c)) err = DB_LOCK_DEADLOCK;
 416   return err;
 417 }
 418
 419 /* start a transaction */
 420 DB_TXN *trackdb_begin_transaction(void) {
 421   DB_TXN *tid;
 422   int err;
 423
 424   if((err = trackdb_env->txn_begin(trackdb_env, 0, &tid, 0)))
 425     fatal(0, "trackdb_env->txn_begin: %s", db_strerror(err));
 426   return tid;
 427 }
 428
 429 /* abort transaction */
 430 void trackdb_abort_transaction(DB_TXN *tid) {
 431   int err;
 432
 433   if(tid)
 434     if((err = tid->abort(tid)))
 435       fatal(0, "tid->abort: %s", db_strerror(err));
 436 }
 437
 438 /* commit transaction */
 439 void trackdb_commit_transaction(DB_TXN *tid) {
 440   int err;
 441
 442   if((err = tid->commit(tid, 0)))
 443     fatal(0, "tid->commit: %s", db_strerror(err));
 444 }
 445
 446 /* search/tags shared code ***************************************************/
 447
 448 /* comparison function used by dedupe() */
 449 static int wordcmp(const void *a, const void *b) {
 450   return strcmp(*(const char **)a, *(const char **)b);
 451 }
 452
 453 /* sort and de-dupe VEC */
 454 static char **dedupe(char **vec, int nvec) {
 455   int m, n;
 456
 457   qsort(vec, nvec, sizeof (char *), wordcmp);
 458   m = n = 0;
 459   if(nvec) {
 460     vec[m++] = vec[0];
 461     for(n = 1; n < nvec; ++n)
 462       if(strcmp(vec[n], vec[m - 1]))
 463         vec[m++] = vec[n];
 464   }
 465   vec[m] = 0;
 466   return vec;
 467 }
 468
 469 /* update a key/track database.  Returns 0 or DB_DEADLOCK. */
 470 static int register_word(DB *db, const char *what,
 471                          const char *track, const char *word,
 472                          DB_TXN *tid) {
 473   int err;
 474   DBT key, data;
 475
 476   switch(err = db->put(db, tid, make_key(&key, word),
 477                        make_key(&data, track), DB_NODUPDATA)) {
 478   case 0:
 479   case DB_KEYEXIST:
 480     return 0;
 481   case DB_LOCK_DEADLOCK:
 482     error(0, "error updating %s.db: %s", what, db_strerror(err));
 483     return err;
 484   default:
 485     fatal(0, "error updating %s.db: %s", what,  db_strerror(err));
 486   }
 487 }
 488
 489 /* search primitives *********************************************************/
 490
 491 /* return true iff NAME is a trackname_display_ pref */
 492 static int is_display_pref(const char *name) {
 493   static const char prefix[] = "trackname_display_";
 494   return !strncmp(name, prefix, (sizeof prefix) - 1);
 495 }
 496
 497 /* compute the words of a track name */
 498 static char **track_to_words(const char *track,
 499                              const struct kvp *p) {
 500   struct vector v;
 501   char **w;
 502   int nw;
 503   const char *rootless = track_rootless(track);
 504
 505   if(!rootless)
 506     rootless = track;                   /* bodge */
 507   vector_init(&v);
 508   if((w = words(casefold(strip_extension(rootless)), &nw)))
 509     vector_append_many(&v, w, nw);
 510
 511   for(; p; p = p->next)
 512     if(is_display_pref(p->name))
 513       if((w = words(casefold(p->value), &nw)))
 514         vector_append_many(&v, w, nw);
 515   vector_terminate(&v);
 516   return dedupe(v.vec, v.nvec);
 517 }
 518
 519 /* return nonzero iff WORD is a stopword */
 520 static int stopword(const char *word) {
 521   int n;
 522
 523   for(n = 0; n < config->stopword.n
 524         && strcmp(word, config->stopword.s[n]); ++n)
 525     ;
 526   return n < config->stopword.n;
 527 }
 528
 529 /* record that WORD appears in TRACK.  Returns 0 or DB_LOCK_DEADLOCK. */
 530 static int register_search_word(const char *track, const char *word,
 531                                 DB_TXN *tid) {
 532   if(stopword(word)) return 0;
 533   return register_word(trackdb_searchdb, "search", track, word, tid);
 534 }
 535
 536 /* Tags **********************************************************************/
 537
 538 /* Return nonzero if C is a valid tag character */
 539 static int tagchar(int c) {
 540   switch(c) {
 541   case ',':
 542     return 0;
 543   default:
 544     return c >= ' ';
 545   }
 546 }
 547
 548 /* Parse and de-dupe a tag list.  If S=0 then assumes "". */
 549 static char **parsetags(const char *s) {
 550   const char *t;
 551   struct vector v;
 552
 553   vector_init(&v);
 554   if(s) {
 555     /* skip initial separators */
 556     while(*s && (!tagchar(*s) || *s == ' '))
 557       ++s;
 558     while(*s) {
 559       /* find the extent of the tag */
 560       t = s;
 561       while(*s && tagchar(*s))
 562         ++s;
 563       /* strip trailing spaces */
 564       while(s > t && s[-1] == ' ')
 565         --s;
 566       vector_append(&v, xstrndup(t, s - t));
 567       /* skip intermediate and trailing separators */
 568       while(*s && (!tagchar(*s) || *s == ' '))
 569         ++s;
 570     }
 571   }
 572   vector_terminate(&v);
 573   return dedupe(v.vec, v.nvec);
 574 }
 575
 576 /* Record that TRACK has TAG.  Returns 0 or DB_LOCK_DEADLOCK. */
 577 static int register_tag(const char *track, const char *tag, DB_TXN *tid) {
 578   return register_word(trackdb_tagsdb, "tags", track, tag, tid);
 579 }
 580
 581 /* aliases *******************************************************************/
 582
 583 /* compute the alias and store at aliasp.  Returns 0 or DB_LOCK_DEADLOCK.  If
 584  * there is no alias sets *aliasp to 0. */
 585 static int compute_alias(char **aliasp,
 586                          const char *track,
 587                          const struct kvp *p,
 588                          DB_TXN *tid) {
 589   struct dynstr d;
 590   const char *s = config->alias, *t, *expansion, *part;
 591   int c, used_db = 0, slash_prefix, err;
 592   struct kvp *at;
 593   const char *const root = find_track_root(track);
 594
 595   if(!root) {
 596     /* Bodge for tracks with no root */
 597     *aliasp = 0;
 598     return 0;
 599   }
 600   dynstr_init(&d);
 601   dynstr_append_string(&d, root);
 602   while((c = (unsigned char)*s++)) {
 603     if(c != '{') {
 604       dynstr_append(&d, c);
 605       continue;
 606     }
 607     if((slash_prefix = (*s == '/')))
 608       s++;
 609     t = strchr(s, '}');
 610     assert(t != 0);                     /* validated at startup */
 611     part = xstrndup(s, t - s);
 612     expansion = getpart(track, "display", part, p, &used_db);
 613     if(*expansion) {
 614       if(slash_prefix) dynstr_append(&d, '/');
 615       dynstr_append_string(&d, expansion);
 616     }
 617     s = t + 1;                          /* skip {part} */
 618   }
 619   /* only admit to the alias if we used the db... */
 620   if(!used_db) {
 621     *aliasp = 0;
 622     return 0;
 623   }
 624   dynstr_terminate(&d);
 625   /* ...and the answer differs from the original... */
 626   if(!strcmp(track, d.vec)) {
 627     *aliasp = 0;
 628     return 0;
 629   }
 630   /* ...and there isn't already a different track with that name (including as
 631    * an alias) */
 632   switch(err = trackdb_getdata(trackdb_tracksdb, d.vec, &at, tid)) {
 633   case 0:
 634     if((s = kvp_get(at, "_alias_for"))
 635        && !strcmp(s, track)) {
 636     case DB_NOTFOUND:
 637       *aliasp = d.vec;
 638     } else {
 639       *aliasp = 0;
 640     }
 641     return 0;
 642   default:
 643     return err;
 644   }
 645 }
 646
 647 /* get track and prefs data (if tp/pp not null pointers).  Returns 0 on
 648  * success, DB_NOTFOUND if the track does not exist or DB_LOCK_DEADLOCK.
 649  * Always sets the return values, even if only to null pointers. */
 650 static int gettrackdata(const char *track,
 651                         struct kvp **tp,
 652                         struct kvp **pp,
 653                         const char **actualp,
 654                         unsigned flags,
 655 #define GTD_NOALIAS 0x0001
 656                         DB_TXN *tid) {
 657   int err;
 658   const char *actual = track;
 659   struct kvp *t = 0, *p = 0;
 660
 661   if((err = trackdb_getdata(trackdb_tracksdb, track, &t, tid))) goto done;
 662   if((actual = kvp_get(t, "_alias_for"))) {
 663     if(flags & GTD_NOALIAS) {
 664       error(0, "alias passed to gettrackdata where real path required");
 665       abort();
 666     }
 667     if((err = trackdb_getdata(trackdb_tracksdb, actual, &t, tid))) goto done;
 668   } else
 669     actual = track;
 670   assert(actual != 0);
 671   if(pp) {
 672     if((err = trackdb_getdata(trackdb_prefsdb, actual, &p, tid)) == DB_LOCK_DEADLOCK)
 673       goto done;
 674   }
 675   err = 0;
 676 done:
 677   if(actualp) *actualp = actual;
 678   if(tp) *tp = t;
 679   if(pp) *pp = p;
 680   return err;
 681 }
 682
 683 /* trackdb_notice() **********************************************************/
 684
 685 /** @brief notice a possiby new  track
 686  * @return @c DB_NOTFOUND if new, 0 if already known
 687  */
 688 int trackdb_notice(const char *track,
 689                    const char *path) {
 690   int err;
 691   DB_TXN *tid;
 692
 693   for(;;) {
 694     tid = trackdb_begin_transaction();
 695     err = trackdb_notice_tid(track, path, tid);
 696     if((err == DB_LOCK_DEADLOCK)) goto fail;
 697     break;
 698   fail:
 699     trackdb_abort_transaction(tid);
 700   }
 701   trackdb_commit_transaction(tid);
 702   return err;
 703 }
 704
 705 /** @brief notice a possiby new  track
 706  * @return @c DB_NOTFOUND if new, 0 if already known, @c DB_LOCK_DEADLOCK also
 707  */
 708 int trackdb_notice_tid(const char *track,
 709                        const char *path,
 710                        DB_TXN *tid) {
 711   int err, n;
 712   struct kvp *t, *a, *p;
 713   int t_changed, ret;
 714   char *alias, **w;
 715
 716   /* notice whether the tracks.db entry changes */
 717   t_changed = 0;
 718   /* get any existing tracks entry */
 719   if((err = gettrackdata(track, &t, &p, 0, 0, tid)) == DB_LOCK_DEADLOCK)
 720     return err;
 721   ret = err;                            /* 0 or DB_NOTFOUND */
 722   /* this is a real track */
 723   t_changed += kvp_set(&t, "_alias_for", 0);
 724   t_changed += kvp_set(&t, "_path", path);
 725   /* if we have an alias record it in the database */
 726   if((err = compute_alias(&alias, track, p, tid))) return err;
 727   if(alias) {
 728     /* won't overwrite someone else's alias as compute_alias() checks */
 729     D(("%s: alias %s", track, alias));
 730     a = 0;
 731     kvp_set(&a, "_alias_for", track);
 732     if((err = trackdb_putdata(trackdb_tracksdb, alias, a, tid, 0))) return err;
 733   }
 734   /* update search.db */
 735   w = track_to_words(track, p);
 736   for(n = 0; w[n]; ++n)
 737     if((err = register_search_word(track, w[n], tid)))
 738       return err;
 739   /* update tags.db */
 740   w = parsetags(kvp_get(p, "tags"));
 741   for(n = 0; w[n]; ++n)
 742     if((err = register_tag(track, w[n], tid)))
 743       return err;
 744   reqtracks = 0;
 745   /* only store the tracks.db entry if it has changed */
 746   if(t_changed && (err = trackdb_putdata(trackdb_tracksdb, track, t, tid, 0)))
 747     return err;
 748   if(ret == DB_NOTFOUND) {
 749     uint32_t timestamp[2];
 750     time_t now;
 751     DBT key, data;
 752
 753     time(&now);
 754     timestamp[0] = htonl((uint64_t)now >> 32);
 755     timestamp[1] = htonl((uint32_t)now);
 756     memset(&key, 0, sizeof key);
 757     key.data = timestamp;
 758     key.size = sizeof timestamp;
 759     switch(err = trackdb_noticeddb->put(trackdb_noticeddb, tid, &key,
 760                                         make_key(&data, track), 0)) {
 761     case 0: break;
 762     case DB_LOCK_DEADLOCK: return err;
 763     default: fatal(0, "error updating noticed.db: %s", db_strerror(err));
 764     }
 765   }
 766   return ret;
 767 }
 768
 769 /* trackdb_obsolete() ********************************************************/
 770
 771 /* obsolete a track */
 772 int trackdb_obsolete(const char *track, DB_TXN *tid) {
 773   int err, n;
 774   struct kvp *p;
 775   char *alias, **w;
 776
 777   if((err = gettrackdata(track, 0, &p, 0,
 778                          GTD_NOALIAS, tid)) == DB_LOCK_DEADLOCK)
 779     return err;
 780   else if(err == DB_NOTFOUND) return 0;
 781   /* compute the alias, if any, and delete it */
 782   if(compute_alias(&alias, track, p, tid)) return err;
 783   if(alias) {
 784     /* if the alias points to some other track then compute_alias won't
 785      * return it */
 786     if(trackdb_delkey(trackdb_tracksdb, alias, tid))
 787       return err;
 788   }
 789   /* update search.db */
 790   w = track_to_words(track, p);
 791   for(n = 0; w[n]; ++n)
 792     if(trackdb_delkeydata(trackdb_searchdb,
 793                           w[n], track, tid) == DB_LOCK_DEADLOCK)
 794       return err;
 795   /* update tags.db */
 796   w = parsetags(kvp_get(p, "tags"));
 797   for(n = 0; w[n]; ++n)
 798     if(trackdb_delkeydata(trackdb_tagsdb,
 799                           w[n], track, tid) == DB_LOCK_DEADLOCK)
 800       return err;
 801   reqtracks = 0;
 802   /* update tracks.db */
 803   if(trackdb_delkey(trackdb_tracksdb, track, tid) == DB_LOCK_DEADLOCK)
 804     return err;
 805   /* We don't delete the prefs, so they survive temporary outages of the
 806    * (possibly virtual) track filesystem */
 807   return 0;
 808 }
 809
 810 /* trackdb_stats() ***********************************************************/
 811
 812 #define H(name) { #name, offsetof(DB_HASH_STAT, name) }
 813 #define B(name) { #name, offsetof(DB_BTREE_STAT, name) }
 814
 815 static const struct statinfo {
 816   const char *name;
 817   size_t offset;
 818 } statinfo_hash[] = {
 819   H(hash_magic),
 820   H(hash_version),
 821   H(hash_nkeys),
 822   H(hash_ndata),
 823   H(hash_pagesize),
 824   H(hash_ffactor),
 825   H(hash_buckets),
 826   H(hash_free),
 827   H(hash_bfree),
 828   H(hash_bigpages),
 829   H(hash_big_bfree),
 830   H(hash_overflows),
 831   H(hash_ovfl_free),
 832   H(hash_dup),
 833   H(hash_dup_free),
 834 }, statinfo_btree[] = {
 835   B(bt_magic),
 836   B(bt_version),
 837   B(bt_nkeys),
 838   B(bt_ndata),
 839   B(bt_pagesize),
 840   B(bt_minkey),
 841   B(bt_re_len),
 842   B(bt_re_pad),
 843   B(bt_levels),
 844   B(bt_int_pg),
 845   B(bt_leaf_pg),
 846   B(bt_dup_pg),
 847   B(bt_over_pg),
 848   B(bt_free),
 849   B(bt_int_pgfree),
 850   B(bt_leaf_pgfree),
 851   B(bt_dup_pgfree),
 852   B(bt_over_pgfree),
 853 };
 854
 855 /* look up stats for DB */
 856 static int get_stats(struct vector *v,
 857                      DB *database,
 858                      const struct statinfo *si,
 859                      size_t nsi,
 860                      DB_TXN *tid) {
 861   void *sp;
 862   size_t n;
 863   char *str;
 864   int err;
 865
 866   if(database) {
 867     switch(err = database->stat(database, tid, &sp, 0)) {
 868     case 0:
 869       break;
 870     case DB_LOCK_DEADLOCK:
 871       error(0, "error querying database: %s", db_strerror(err));
 872       return err;
 873     default:
 874       fatal(0, "error querying database: %s", db_strerror(err));
 875     }
 876     for(n = 0; n < nsi; ++n) {
 877       byte_xasprintf(&str, "%s=%"PRIuMAX, si[n].name,
 878                      (uintmax_t)*(u_int32_t *)((char *)sp + si[n].offset));
 879       vector_append(v, str);
 880     }
 881   }
 882   return 0;
 883 }
 884
 885 struct search_entry {
 886   char *word;
 887   int n;
 888 };
 889
 890 /* find the top COUNT words in the search database */
 891 static int search_league(struct vector *v, int count, DB_TXN *tid) {
 892   struct search_entry *se;
 893   DBT k, d;
 894   DBC *cursor;
 895   int err, n = 0, nse = 0, i;
 896   char *word = 0;
 897   size_t wl = 0;
 898   char *str;
 899
 900   cursor = trackdb_opencursor(trackdb_searchdb, tid);
 901   se = xmalloc(count * sizeof *se);
 902   while(!(err = cursor->c_get(cursor, prepare_data(&k), prepare_data(&d),
 903                               DB_NEXT))) {
 904     if(word && wl == k.size && !strncmp(word, k.data, wl))
 905       ++n;
 906     else {
 907 #define FINALIZE() do {                                         \
 908   if(word && (nse < count || n > se[nse - 1].n)) {              \
 909     if(nse == count)                                            \
 910       i = nse - 1;                                              \
 911     else                                                        \
 912       i = nse++;                                                \
 913     while(i > 0 && n > se[i - 1].n)                             \
 914       --i;                                                      \
 915     memmove(&se[i + 1], &se[i], (nse - i) * sizeof *se);        \
 916     se[i].word = word;                                          \
 917     se[i].n = n;                                                \
 918   }                                                             \
 919 } while(0)
 920       FINALIZE();
 921       word = xstrndup(k.data, wl = k.size);
 922       n = 1;
 923     }
 924   }
 925   switch(err) {
 926   case DB_NOTFOUND:
 927     err = 0;
 928     break;
 929   case DB_LOCK_DEADLOCK:
 930     error(0, "error querying search database: %s", db_strerror(err));
 931     break;
 932   default:
 933     fatal(0, "error querying search database: %s", db_strerror(err));
 934   }
 935   if(trackdb_closecursor(cursor)) err = DB_LOCK_DEADLOCK;
 936   if(err) return err;
 937   FINALIZE();
 938   byte_xasprintf(&str, "Top %d search words:", nse);
 939   vector_append(v, str);
 940   for(i = 0; i < nse; ++i) {
 941     byte_xasprintf(&str, "%4d: %5d %s", i + 1, se[i].n, se[i].word);
 942     vector_append(v, str);
 943   }
 944   return 0;
 945 }
 946
 947 #define SI(what) statinfo_##what, \
 948                  sizeof statinfo_##what / sizeof (struct statinfo)
 949
 950 /* return a list of database stats */
 951 char **trackdb_stats(int *nstatsp) {
 952   DB_TXN *tid;
 953   struct vector v;
 954   char *s;
 955
 956   vector_init(&v);
 957   for(;;) {
 958     tid = trackdb_begin_transaction();
 959     v.nvec = 0;
 960     vector_append(&v, (char *)"Tracks database stats:");
 961     if(get_stats(&v, trackdb_tracksdb, SI(btree), tid)) goto fail;
 962     vector_append(&v, (char *)"");
 963     vector_append(&v, (char *)"Search database stats:");
 964     if(get_stats(&v, trackdb_searchdb, SI(hash), tid)) goto fail;
 965     vector_append(&v, (char *)"");
 966     vector_append(&v, (char *)"Prefs database stats:");
 967     if(get_stats(&v, trackdb_prefsdb, SI(hash), tid)) goto fail;
 968     vector_append(&v, (char *)"");
 969     if(search_league(&v, 10, tid)) goto fail;
 970     vector_append(&v, (char *)"");
 971     vector_append(&v, (char *)"Server stats:");
 972     byte_xasprintf(&s, "track lookup cache hits: %lu", cache_files_hits);
 973     vector_append(&v, (char *)s);
 974     byte_xasprintf(&s, "track lookup cache misses: %lu", cache_files_misses);
 975     vector_append(&v, (char *)s);
 976     vector_terminate(&v);
 977     break;
 978 fail:
 979     trackdb_abort_transaction(tid);
 980   }
 981   trackdb_commit_transaction(tid);
 982   if(nstatsp) *nstatsp = v.nvec;
 983   return v.vec;
 984 }
 985
 986 /* set a pref (remove if value=0) */
 987 int trackdb_set(const char *track,
 988                 const char *name,
 989                 const char *value) {
 990   struct kvp *t, *p, *a;
 991   DB_TXN *tid;
 992   int err, cmp;
 993   char *oldalias, *newalias, **oldtags = 0, **newtags;
 994
 995   if(value) {
 996     /* TODO: if value matches default then set value=0 */
 997   }
 998
 999   for(;;) {
1000     tid = trackdb_begin_transaction();
1001     if((err = gettrackdata(track, &t, &p, 0,
1002                            0, tid)) == DB_LOCK_DEADLOCK)
1003       goto fail;
1004     if(err == DB_NOTFOUND) break;
1005     if(name[0] == '_') {
1006       if(kvp_set(&t, name, value))
1007         if(trackdb_putdata(trackdb_tracksdb, track, t, tid, 0))
1008           goto fail;
1009     } else {
1010       /* get the old alias name */
1011       if(compute_alias(&oldalias, track, p, tid)) goto fail;
1012       /* get the old tags */
1013       if(!strcmp(name, "tags"))
1014         oldtags = parsetags(kvp_get(p, "tags"));
1015       /* set the value */
1016       if(kvp_set(&p, name, value))
1017         if(trackdb_putdata(trackdb_prefsdb, track, p, tid, 0))
1018           goto fail;
1019       /* compute the new alias name */
1020       if((err = compute_alias(&newalias, track, p, tid))) goto fail;
1021       /* check whether alias has changed */
1022       if(!(oldalias == newalias
1023            || (oldalias && newalias && !strcmp(oldalias, newalias)))) {
1024         /* adjust alias records to fit change */
1025         if(oldalias
1026            && trackdb_delkey(trackdb_tracksdb, oldalias, tid)) goto fail;
1027         if(newalias) {
1028           a = 0;
1029           kvp_set(&a, "_alias_for", track);
1030           if(trackdb_putdata(trackdb_tracksdb, newalias, a, tid, 0)) goto fail;
1031         }
1032       }
1033       /* check whether tags have changed */
1034       if(!strcmp(name, "tags")) {
1035         newtags = parsetags(value);
1036         while(*oldtags || *newtags) {
1037           if(*oldtags && *newtags) {
1038             cmp = strcmp(*oldtags, *newtags);
1039             if(!cmp) {
1040               /* keeping this tag */
1041               ++oldtags;
1042               ++newtags;
1043             } else if(cmp < 0)
1044               /* old tag fits into a gap in the new list, so delete old */
1045               goto delete_old;
1046             else
1047               /* new tag fits into a gap in the old list, so insert new */
1048               goto insert_new;
1049           } else if(*oldtags) {
1050             /* we've run out of new tags, so remaining old ones are to be
1051              * deleted */
1052           delete_old:
1053             if(trackdb_delkeydata(trackdb_tagsdb,
1054                                   *oldtags, track, tid) == DB_LOCK_DEADLOCK)
1055               goto fail;
1056             ++oldtags;
1057           } else {
1058             /* we've run out of old tags, so remainig new ones are to be
1059              * inserted */
1060           insert_new:
1061             if(register_tag(track, *newtags, tid)) goto fail;
1062             ++newtags;
1063           }
1064         }
1065         reqtracks = 0;
1066       }
1067     }
1068     err = 0;
1069     break;
1070 fail:
1071     trackdb_abort_transaction(tid);
1072   }
1073   trackdb_commit_transaction(tid);
1074   return err == 0 ? 0 : -1;
1075 }
1076
1077 /* get a pref */
1078 const char *trackdb_get(const char *track,
1079                         const char *name) {
1080   return kvp_get(trackdb_get_all(track), name);
1081 }
1082
1083 /* get all prefs as a 0-terminated array */
1084 struct kvp *trackdb_get_all(const char *track) {
1085   struct kvp *t, *p, **pp;
1086   DB_TXN *tid;
1087
1088   for(;;) {
1089     tid = trackdb_begin_transaction();
1090     if(gettrackdata(track, &t, &p, 0, 0, tid) == DB_LOCK_DEADLOCK)
1091       goto fail;
1092     break;
1093 fail:
1094     trackdb_abort_transaction(tid);
1095   }
1096   trackdb_commit_transaction(tid);
1097   for(pp = &p; *pp; pp = &(*pp)->next)
1098     ;
1099   *pp = t;
1100   return p;
1101 }
1102
1103 /* resolve alias */
1104 const char *trackdb_resolve(const char *track) {
1105   DB_TXN *tid;
1106   const char *actual;
1107
1108   for(;;) {
1109     tid = trackdb_begin_transaction();
1110     if(gettrackdata(track, 0, 0, &actual, 0, tid) == DB_LOCK_DEADLOCK)
1111       goto fail;
1112     break;
1113 fail:
1114     trackdb_abort_transaction(tid);
1115   }
1116   trackdb_commit_transaction(tid);
1117   return actual;
1118 }
1119
1120 int trackdb_isalias(const char *track) {
1121   const char *actual = trackdb_resolve(track);
1122
1123   return strcmp(actual, track);
1124 }
1125
1126 /* test whether a track exists (perhaps an alias) */
1127 int trackdb_exists(const char *track) {
1128   DB_TXN *tid;
1129   int err;
1130
1131   for(;;) {
1132     tid = trackdb_begin_transaction();
1133     /* unusually, here we want the return value */
1134     if((err = gettrackdata(track, 0, 0, 0, 0, tid)) == DB_LOCK_DEADLOCK)
1135       goto fail;
1136     break;
1137 fail:
1138     trackdb_abort_transaction(tid);
1139   }
1140   trackdb_commit_transaction(tid);
1141   return (err == 0);
1142 }
1143
1144 /* return the list of tags */
1145 char **trackdb_alltags(void) {
1146   DB_TXN *tid;
1147   int err;
1148   char **taglist;
1149
1150   for(;;) {
1151     tid = trackdb_begin_transaction();
1152     err = trackdb_alltags_tid(tid, &taglist);
1153     if(!err) break;
1154     trackdb_abort_transaction(tid);
1155   }
1156   trackdb_commit_transaction(tid);
1157   return taglist;
1158 }
1159
1160 static int trackdb_alltags_tid(DB_TXN *tid, char ***taglistp) {
1161   struct vector v;
1162   DBC *c;
1163   DBT k, d;
1164   int err;
1165
1166   vector_init(&v);
1167   c = trackdb_opencursor(trackdb_tagsdb, tid);
1168   memset(&k, 0, sizeof k);
1169   while(!(err = c->c_get(c, &k, prepare_data(&d), DB_NEXT_NODUP)))
1170     vector_append(&v, xstrndup(k.data, k.size));
1171   switch(err) {
1172   case DB_NOTFOUND:
1173     break;
1174   case DB_LOCK_DEADLOCK:
1175       return err;
1176   default:
1177     fatal(0, "c->c_get: %s", db_strerror(err));
1178   }
1179   if((err = trackdb_closecursor(c))) return err;
1180   vector_terminate(&v);
1181   *taglistp = v.vec;
1182   return 0;
1183 }
1184
1185 /* return 1 iff sorted tag lists A and B have at least one member in common */
1186 static int tag_intersection(char **a, char **b) {
1187   int cmp;
1188
1189   /* Same sort of logic as trackdb_set() above */
1190   while(*a && *b) {
1191     if(!(cmp = strcmp(*a, *b))) return 1;
1192     else if(cmp < 0) ++a;
1193     else ++b;
1194   }
1195   return 0;
1196 }
1197
1198 /* Check whether a track is suitable for random play.  Returns 0 if it is,
1199  * DB_NOTFOUND if it is not or DB_LOCK_DEADLOCK if the database gave us
1200  * that. */
1201 static int check_suitable(const char *track,
1202                           DB_TXN *tid,
1203                           char **required_tags,
1204                           char **prohibited_tags) {
1205   char **track_tags;
1206   time_t last, now;
1207   struct kvp *p, *t;
1208   const char *pick_at_random, *played_time;
1209
1210   /* don't pick tracks that aren't in any surviving collection (for instance
1211    * you've edited the config but the rescan hasn't done its job yet) */
1212   if(!find_track_root(track)) {
1213     info("found track not in any collection: %s", track);
1214     return DB_NOTFOUND;
1215   }
1216   /* don't pick aliases - only pick the canonical form */
1217   if(gettrackdata(track, &t, &p, 0, 0, tid) == DB_LOCK_DEADLOCK)
1218     return DB_LOCK_DEADLOCK;
1219   if(kvp_get(t, "_alias_for"))
1220     return DB_NOTFOUND;
1221   /* check that random play is not suppressed for this track */
1222   if((pick_at_random = kvp_get(p, "pick_at_random"))
1223      && !strcmp(pick_at_random, "0"))
1224     return DB_NOTFOUND;
1225   /* don't pick a track that's been played in the last 8 hours */
1226   if((played_time = kvp_get(p, "played_time"))) {
1227     last = atoll(played_time);
1228     now = time(0);
1229     if(now < last + 8 * 3600)       /* TODO configurable */
1230       return DB_NOTFOUND;
1231   }
1232   track_tags = parsetags(kvp_get(p, "tags"));
1233   /* check that no prohibited tag is present for this track */
1234   if(prohibited_tags && tag_intersection(track_tags, prohibited_tags))
1235     return DB_NOTFOUND;
1236   /* check that at least one required tags is present for this track */
1237   if(*required_tags && !tag_intersection(track_tags, required_tags))
1238     return DB_NOTFOUND;
1239   return 0;
1240 }
1241
1242 /* attempt to pick a random non-alias track */
1243 const char *trackdb_random(int tries) {
1244   DBT key, data;
1245   DB_BTREE_STAT *sp;
1246   int err, n;
1247   DB_TXN *tid;
1248   const char *track, *candidate;
1249   db_recno_t r;
1250   const char *tags;
1251   char **required_tags, **prohibited_tags, **tp;
1252   hash *h;
1253   DBC *c = 0;
1254
1255   for(;;) {
1256     tid = trackdb_begin_transaction();
1257     if((err = trackdb_get_global_tid("required-tags", tid, &tags)))
1258       goto fail;
1259     required_tags = parsetags(tags);
1260     if((err = trackdb_get_global_tid("prohibited-tags", tid, &tags)))
1261       goto fail;
1262     prohibited_tags = parsetags(tags);
1263     track = 0;
1264     if(*required_tags) {
1265       /* Bung all the suitable tracks into a hash and convert to a list of keys
1266        * (to eliminate duplicates).  We cache this list since it is possible
1267        * that it will be very large. */
1268       if(!reqtracks) {
1269         h = hash_new(0);
1270         for(tp = required_tags; *tp; ++tp) {
1271           c = trackdb_opencursor(trackdb_tagsdb, tid);
1272           memset(&key, 0, sizeof key);
1273           key.data = *tp;
1274           key.size = strlen(*tp);
1275           n = 0;
1276           err = c->c_get(c, &key, prepare_data(&data), DB_SET);
1277           while(err == 0) {
1278             hash_add(h, xstrndup(data.data, data.size), 0,
1279                      HASH_INSERT_OR_REPLACE);
1280             ++n;
1281             err = c->c_get(c, &key, prepare_data(&data), DB_NEXT_DUP);
1282           }
1283           switch(err) {
1284           case 0:
1285           case DB_NOTFOUND:
1286             break;
1287           case DB_LOCK_DEADLOCK:
1288             goto fail;
1289           default:
1290             fatal(0, "error querying tags.db: %s", db_strerror(err));
1291           }
1292           trackdb_closecursor(c);
1293           c = 0;
1294           if(!n)
1295             error(0, "required tag %s does not match any tracks", *tp);
1296         }
1297         nreqtracks = hash_count(h);
1298         reqtracks = hash_keys(h);
1299       }
1300       while(nreqtracks && !track && tries-- > 0) {
1301         r = (rand() * (double)nreqtracks / (RAND_MAX + 1.0));
1302         candidate = reqtracks[r];
1303         switch(check_suitable(candidate, tid,
1304                               required_tags, prohibited_tags)) {
1305         case 0:
1306           track = candidate;
1307           break;
1308         case DB_NOTFOUND:
1309           break;
1310         case DB_LOCK_DEADLOCK:
1311           goto fail;
1312         }
1313       }
1314     } else {
1315       /* No required tags.  We pick random record numbers in the database
1316        * instead. */
1317       switch(err = trackdb_tracksdb->stat(trackdb_tracksdb, tid, &sp, 0)) {
1318       case 0:
1319         break;
1320       case DB_LOCK_DEADLOCK:
1321         error(0, "error querying tracks.db: %s", db_strerror(err));
1322         goto fail;
1323       default:
1324         fatal(0, "error querying tracks.db: %s", db_strerror(err));
1325       }
1326       if(!sp->bt_nkeys)
1327         error(0, "cannot pick tracks at random from an empty database");
1328       while(sp->bt_nkeys && !track && tries-- > 0) {
1329         /* record numbers count from 1 upwards */
1330         r = 1 + (rand() * (double)sp->bt_nkeys / (RAND_MAX + 1.0));
1331         memset(&key, sizeof key, 0);
1332         key.flags = DB_DBT_MALLOC;
1333         key.size = sizeof r;
1334         key.data = &r;
1335         switch(err = trackdb_tracksdb->get(trackdb_tracksdb, tid, &key, prepare_data(&data),
1336                                            DB_SET_RECNO)) {
1337         case 0:
1338           break;
1339         case DB_LOCK_DEADLOCK:
1340           error(0, "error querying tracks.db: %s", db_strerror(err));
1341           goto fail;
1342         default:
1343           fatal(0, "error querying tracks.db: %s", db_strerror(err));
1344         }
1345         candidate = xstrndup(key.data, key.size);
1346         switch(check_suitable(candidate, tid,
1347                               required_tags, prohibited_tags)) {
1348         case 0:
1349           track = candidate;
1350           break;
1351         case DB_NOTFOUND:
1352           break;
1353         case DB_LOCK_DEADLOCK:
1354           goto fail;
1355         }
1356       }
1357     }
1358     break;
1359 fail:
1360     trackdb_closecursor(c);
1361     c = 0;
1362     trackdb_abort_transaction(tid);
1363   }
1364   trackdb_commit_transaction(tid);
1365   if(!track)
1366     error(0, "could not pick a random track");
1367   return track;
1368 }
1369
1370 /* get a track name given the prefs.  Set *used_db to 1 if we got the answer
1371  * from the prefs. */
1372 static const char *getpart(const char *track,
1373                            const char *context,
1374                            const char *part,
1375                            const struct kvp *p,
1376                            int *used_db) {
1377   const char *result;
1378   char *pref;
1379
1380   byte_xasprintf(&pref, "trackname_%s_%s", context, part);
1381   if((result = kvp_get(p, pref)))
1382     *used_db = 1;
1383   else
1384     result = trackname_part(track, context, part);
1385   assert(result != 0);
1386   return result;
1387 }
1388
1389 /* get a track name part, like trackname_part(), but taking the database into
1390  * account. */
1391 const char *trackdb_getpart(const char *track,
1392                             const char *context,
1393                             const char *part) {
1394   struct kvp *p;
1395   DB_TXN *tid;
1396   char *pref;
1397   const char *actual;
1398   int used_db, err;
1399
1400   /* construct the full pref */
1401   byte_xasprintf(&pref, "trackname_%s_%s", context, part);
1402   for(;;) {
1403     tid = trackdb_begin_transaction();
1404     if((err = gettrackdata(track, 0, &p, &actual, 0, tid)) == DB_LOCK_DEADLOCK)
1405       goto fail;
1406     break;
1407 fail:
1408     trackdb_abort_transaction(tid);
1409   }
1410   trackdb_commit_transaction(tid);
1411   return getpart(actual, context, part, p, &used_db);
1412 }
1413
1414 /* get the raw path name for @track@ (might be an alias) */
1415 const char *trackdb_rawpath(const char *track) {
1416   DB_TXN *tid;
1417   struct kvp *t;
1418   const char *path;
1419
1420   for(;;) {
1421     tid = trackdb_begin_transaction();
1422     if(gettrackdata(track, &t, 0, 0, 0, tid) == DB_LOCK_DEADLOCK)
1423       goto fail;
1424     break;
1425 fail:
1426     trackdb_abort_transaction(tid);
1427   }
1428   trackdb_commit_transaction(tid);
1429   if(!(path = kvp_get(t, "_path"))) path = track;
1430   return path;
1431 }
1432
1433 /* trackdb_list **************************************************************/
1434
1435 /* this is incredibly ugly, sorry, perhaps it will be rewritten to be actually
1436  * readable at some point */
1437
1438 /* return true if the basename of TRACK[0..TL-1], as defined by DL, matches RE.
1439  * If RE is a null pointer then it matches everything. */
1440 static int track_matches(size_t dl, const char *track, size_t tl,
1441                          const pcre *re) {
1442   int ovec[3], rc;
1443
1444   if(!re)
1445     return 1;
1446   track += dl + 1;
1447   tl -= (dl + 1);
1448   switch(rc = pcre_exec(re, 0, track, tl, 0, 0, ovec, 3)) {
1449   case PCRE_ERROR_NOMATCH: return 0;
1450   default:
1451     if(rc < 0) {
1452       error(0, "pcre_exec returned %d, subject '%s'", rc, track);
1453       return 0;
1454     }
1455     return 1;
1456   }
1457 }
1458
1459 static int do_list(struct vector *v, const char *dir,
1460                    enum trackdb_listable what, const pcre *re, DB_TXN *tid) {
1461   DBC *cursor;
1462   DBT k, d;
1463   size_t dl;
1464   char *ptr;
1465   int err;
1466   size_t l, last_dir_len = 0;
1467   char *last_dir = 0, *track, *alias;
1468   struct kvp *p;
1469
1470   dl = strlen(dir);
1471   cursor = trackdb_opencursor(trackdb_tracksdb, tid);
1472   make_key(&k, dir);
1473   prepare_data(&d);
1474   /* find the first key >= dir */
1475   err = cursor->c_get(cursor, &k, &d, DB_SET_RANGE);
1476   /* keep going while we're dealing with <dir/anything> */
1477   while(err == 0
1478         && k.size > dl
1479         && ((char *)k.data)[dl] == '/'
1480         && !memcmp(k.data, dir, dl)) {
1481     ptr = memchr((char *)k.data + dl + 1, '/', k.size - (dl + 1));
1482     if(ptr) {
1483       /* we have <dir/component/anything>, so <dir/component> is a directory */
1484       l = ptr - (char *)k.data;
1485       if(what & trackdb_directories)
1486         if(!(last_dir
1487              && l == last_dir_len
1488              && !memcmp(last_dir, k.data, l))) {
1489           last_dir = xstrndup(k.data, last_dir_len = l);
1490           if(track_matches(dl, k.data, l, re))
1491             vector_append(v, last_dir);
1492         }
1493     } else {
1494       /* found a plain file */
1495       if((what & trackdb_files)) {
1496         track = xstrndup(k.data, k.size);
1497         if((err = trackdb_getdata(trackdb_prefsdb,
1498                                   track, &p, tid)) == DB_LOCK_DEADLOCK)
1499           goto deadlocked;
1500         /* if this file has an alias in the same directory then we skip it */
1501         if((err = compute_alias(&alias, track, p, tid)))
1502           goto deadlocked;
1503         if(!(alias && !strcmp(d_dirname(alias), d_dirname(track))))
1504           if(track_matches(dl, k.data, k.size, re))
1505             vector_append(v, track);
1506       }
1507     }
1508     err = cursor->c_get(cursor, &k, &d, DB_NEXT);
1509   }
1510   switch(err) {
1511   case 0:
1512     break;
1513   case DB_NOTFOUND:
1514     err = 0;
1515     break;
1516   case DB_LOCK_DEADLOCK:
1517     error(0, "error querying database: %s", db_strerror(err));
1518     break;
1519   default:
1520     fatal(0, "error querying database: %s", db_strerror(err));
1521   }
1522 deadlocked:
1523   if(trackdb_closecursor(cursor)) err = DB_LOCK_DEADLOCK;
1524   return err;
1525 }
1526
1527 /* return the directories or files below @dir@ */
1528 char **trackdb_list(const char *dir, int *np, enum trackdb_listable what,
1529                     const pcre *re) {
1530   DB_TXN *tid;
1531   int n;
1532   struct vector v;
1533
1534   vector_init(&v);
1535   for(;;) {
1536     tid = trackdb_begin_transaction();
1537     v.nvec = 0;
1538     if(dir) {
1539       if(do_list(&v, dir, what, re, tid))
1540         goto fail;
1541     } else {
1542       for(n = 0; n < config->collection.n; ++n)
1543         if(do_list(&v, config->collection.s[n].root, what, re, tid))
1544           goto fail;
1545     }
1546     break;
1547 fail:
1548     trackdb_abort_transaction(tid);
1549   }
1550   trackdb_commit_transaction(tid);
1551   vector_terminate(&v);
1552   if(np)
1553     *np = v.nvec;
1554   return v.vec;
1555 }
1556
1557 /* If S is tag:something, return something.  Else return 0. */
1558 static const char *checktag(const char *s) {
1559   if(!strncmp(s, "tag:", 4))
1560     return s + 4;
1561   else
1562     return 0;
1563 }
1564
1565 /* return a list of tracks containing all of the words given.  If you
1566  * ask for only stopwords you get no tracks. */
1567 char **trackdb_search(char **wordlist, int nwordlist, int *ntracks) {
1568   const char **w, *best = 0, *tag;
1569   char **twords, **tags;
1570   int i, j, n, err, what;
1571   DBC *cursor = 0;
1572   DBT k, d;
1573   struct vector u, v;
1574   DB_TXN *tid;
1575   struct kvp *p;
1576   int ntags = 0;
1577   DB *db;
1578   const char *dbname;
1579
1580   *ntracks = 0;                         /* for early returns */
1581   /* casefold all the words */
1582   w = xmalloc(nwordlist * sizeof (char *));
1583   for(n = 0; n < nwordlist; ++n) {
1584     w[n] = casefold(wordlist[n]);
1585     if(checktag(w[n])) ++ntags;         /* count up tags */
1586   }
1587   /* find the longest non-stopword */
1588   for(n = 0; n < nwordlist; ++n)
1589     if(!stopword(w[n]) && !checktag(w[n]))
1590       if(!best || strlen(w[n]) > strlen(best))
1591         best = w[n];
1592   /* TODO: we should at least in principal be able to identify the word or tag
1593    * with the least matches in log time, and choose that as our primary search
1594    * term. */
1595   if(ntags && !best) {
1596     /* Only tags are listed.  We limit to the first and narrow down with the
1597      * rest. */
1598     best = checktag(w[0]);
1599     db = trackdb_tagsdb;
1600     dbname = "tags";
1601   } else if(best) {
1602     /* We can limit to some word. */
1603     db = trackdb_searchdb;
1604     dbname = "search";
1605   } else {
1606     /* Only stopwords */
1607     return 0;
1608   }
1609   vector_init(&u);
1610   vector_init(&v);
1611   for(;;) {
1612     tid = trackdb_begin_transaction();
1613     /* find all the tracks that have that word */
1614     make_key(&k, best);
1615     prepare_data(&d);
1616     what = DB_SET;
1617     v.nvec = 0;
1618     cursor = trackdb_opencursor(db, tid);
1619     while(!(err = cursor->c_get(cursor, &k, &d, what))) {
1620       vector_append(&v, xstrndup(d.data, d.size));
1621       what = DB_NEXT_DUP;
1622     }
1623     switch(err) {
1624     case DB_NOTFOUND:
1625       err = 0;
1626       break;
1627     case DB_LOCK_DEADLOCK:
1628       error(0, "error querying %s database: %s", dbname, db_strerror(err));
1629       break;
1630     default:
1631       fatal(0, "error querying %s database: %s", dbname, db_strerror(err));
1632     }
1633     if(trackdb_closecursor(cursor)) err = DB_LOCK_DEADLOCK;
1634     cursor = 0;
1635     /* do a naive search over that (hopefuly fairly small) list of tracks */
1636     u.nvec = 0;
1637     for(n = 0; n < v.nvec; ++n) {
1638       if((err = gettrackdata(v.vec[n], 0, &p, 0, 0, tid) == DB_LOCK_DEADLOCK))
1639         goto fail;
1640       else if(err) {
1641         error(0, "track %s unexpected error: %s", v.vec[n], db_strerror(err));
1642         continue;
1643       }
1644       twords = track_to_words(v.vec[n], p);
1645       tags = parsetags(kvp_get(p, "tags"));
1646       for(i = 0; i < nwordlist; ++i) {
1647         if((tag = checktag(w[i]))) {
1648           /* Track must have this tag */
1649           for(j = 0; tags[j]; ++j)
1650             if(!strcmp(tag, tags[j])) break; /* tag found */
1651           if(!tags[j]) break;           /* tag not found */
1652         } else {
1653           /* Track must contain this word */
1654           for(j = 0; twords[j]; ++j)
1655             if(!strcmp(w[i], twords[j])) break; /* word found */
1656           if(!twords[j]) break;         /* word not found */
1657         }
1658       }
1659       if(i >= nwordlist)                /* all words found */
1660         vector_append(&u, v.vec[n]);
1661     }
1662     break;
1663   fail:
1664     trackdb_closecursor(cursor);
1665     cursor = 0;
1666     trackdb_abort_transaction(tid);
1667     info("retrying search");
1668   }
1669   trackdb_commit_transaction(tid);
1670   vector_terminate(&u);
1671   if(ntracks)
1672     *ntracks = u.nvec;
1673   return u.vec;
1674 }
1675
1676 /* trackdb_scan **************************************************************/
1677
1678 int trackdb_scan(const char *root,
1679                  int (*callback)(const char *track,
1680                                  struct kvp *data,
1681                                  void *u,
1682                                  DB_TXN *tid),
1683                  void *u,
1684                  DB_TXN *tid) {
1685   DBC *cursor;
1686   DBT k, d;
1687   const size_t root_len = root ? strlen(root) : 0;
1688   int err, cberr;
1689   struct kvp *data;
1690   const char *track;
1691
1692   cursor = trackdb_opencursor(trackdb_tracksdb, tid);
1693   if(root)
1694     err = cursor->c_get(cursor, make_key(&k, root), prepare_data(&d),
1695                         DB_SET_RANGE);
1696   else {
1697     memset(&k, 0, sizeof k);
1698     err = cursor->c_get(cursor, &k, prepare_data(&d),
1699                         DB_FIRST);
1700   }
1701   while(!err) {
1702     if(!root
1703        || (k.size > root_len
1704            && !strncmp(k.data, root, root_len)
1705            && ((char *)k.data)[root_len] == '/')) {
1706       data = kvp_urldecode(d.data, d.size);
1707       if(kvp_get(data, "_path")) {
1708         track = xstrndup(k.data, k.size);
1709         /* Advance to the next track before the callback so that the callback
1710          * may safely delete the track */
1711         err = cursor->c_get(cursor, &k, &d, DB_NEXT);
1712         if((cberr = callback(track, data, u, tid))) {
1713           err = cberr;
1714           break;
1715         }
1716       } else
1717         err = cursor->c_get(cursor, &k, &d, DB_NEXT);
1718     } else
1719       break;
1720   }
1721   trackdb_closecursor(cursor);
1722   switch(err) {
1723   case EINTR:
1724     return err;
1725   case 0:
1726   case DB_NOTFOUND:
1727     return 0;
1728   case DB_LOCK_DEADLOCK:
1729     error(0, "c->c_get: %s", db_strerror(err));
1730     return err;
1731   default:
1732     fatal(0, "c->c_get: %s", db_strerror(err));
1733   }
1734 }
1735
1736 /* trackdb_rescan ************************************************************/
1737
1738 /* called when the rescanner terminates */
1739 static int reap_rescan(ev_source attribute((unused)) *ev,
1740                        pid_t pid,
1741                        int status,
1742                        const struct rusage attribute((unused)) *rusage,
1743                        void attribute((unused)) *u) {
1744   if(pid == rescan_pid) rescan_pid = -1;
1745   if(status)
1746     error(0, "disorderd-rescan: %s", wstat(status));
1747   else
1748     D(("disorderd-rescan terminate: %s", wstat(status)));
1749   /* Our cache of file lookups is out of date now */
1750   cache_clean(&cache_files_type);
1751   eventlog("rescanned", (char *)0);
1752   return 0;
1753 }
1754
1755 void trackdb_rescan(ev_source *ev) {
1756   if(rescan_pid != -1) {
1757     error(0, "rescan already underway");
1758     return;
1759   }
1760   rescan_pid = subprogram(ev, RESCAN);
1761   ev_child(ev, rescan_pid, 0, reap_rescan, 0);
1762   D(("started rescanner"));
1763
1764 }
1765
1766 int trackdb_rescan_cancel(void) {
1767   if(rescan_pid == -1) return 0;
1768   if(kill(rescan_pid, SIGTERM) < 0)
1769     fatal(errno, "error killing rescanner");
1770   rescan_pid = -1;
1771   return 1;
1772 }
1773
1774 /* global prefs **************************************************************/
1775
1776 void trackdb_set_global(const char *name,
1777                         const char *value,
1778                         const char *who) {
1779   DB_TXN *tid;
1780   DBT k, d;
1781   int err;
1782   int state;
1783
1784   memset(&k, 0, sizeof k);
1785   memset(&d, 0, sizeof d);
1786   k.data = (void *)name;
1787   k.size = strlen(name);
1788   if(value) {
1789     d.data = (void *)value;
1790     d.size = strlen(value);
1791   }
1792   for(;;) {
1793     tid = trackdb_begin_transaction();
1794     if(value)
1795       err = trackdb_globaldb->put(trackdb_globaldb, tid, &k, &d, 0);
1796     else
1797       err = trackdb_globaldb->del(trackdb_globaldb, tid, &k, 0);
1798     if(!err || err == DB_NOTFOUND) break;
1799     if(err != DB_LOCK_DEADLOCK)
1800       fatal(0, "error updating database: %s", db_strerror(err));
1801     trackdb_abort_transaction(tid);
1802   }
1803   trackdb_commit_transaction(tid);
1804   /* log important state changes */
1805   if(!strcmp(name, "playing")) {
1806     state = !value || !strcmp(value, "yes");
1807     info("playing %s by %s",
1808          state ? "enabled" : "disabled",
1809          who ? who : "-");
1810     eventlog("state", state ? "enable_play" : "disable_play", (char *)0);
1811   }
1812   if(!strcmp(name, "random-play")) {
1813     state = !value || !strcmp(value, "yes");
1814     info("random play %s by %s",
1815          state ? "enabled" : "disabled",
1816          who ? who : "-");
1817     eventlog("state", state ? "enable_random" : "disable_random", (char *)0);
1818   }
1819   if(!strcmp(name, "required-tags"))
1820     reqtracks = 0;
1821 }
1822
1823 const char *trackdb_get_global(const char *name) {
1824   DB_TXN *tid;
1825   int err;
1826   const char *r;
1827
1828   for(;;) {
1829     tid = trackdb_begin_transaction();
1830     if(!(err = trackdb_get_global_tid(name, tid, &r)))
1831       break;
1832     trackdb_abort_transaction(tid);
1833   }
1834   trackdb_commit_transaction(tid);
1835   return r;
1836 }
1837
1838 static int trackdb_get_global_tid(const char *name,
1839                                   DB_TXN *tid,
1840                                   const char **rp) {
1841   DBT k, d;
1842   int err;
1843
1844   memset(&k, 0, sizeof k);
1845   k.data = (void *)name;
1846   k.size = strlen(name);
1847   switch(err = trackdb_globaldb->get(trackdb_globaldb, tid, &k,
1848                                      prepare_data(&d), 0)) {
1849   case 0:
1850     *rp = xstrndup(d.data, d.size);
1851     return 0;
1852   case DB_NOTFOUND:
1853     *rp = 0;
1854     return 0;
1855   case DB_LOCK_DEADLOCK:
1856     return err;
1857   default:
1858     fatal(0, "error updating database: %s", db_strerror(err));
1859   }
1860 }
1861
1862 /** @brief Retrieve the most recently added tracks
1863  * @param ntracksp Where to put count, or 0
1864  * @param maxtracks Maximum number of tracks to retrieve
1865  * @return null-terminated array of track names
1866  *
1867  * The most recently added track is first in the array.
1868  */
1869 char **trackdb_new(int *ntracksp,
1870                    int maxtracks) {
1871   DB_TXN *tid;
1872   char **tracks;
1873
1874   for(;;) {
1875     tid = trackdb_begin_transaction();
1876     tracks = trackdb_new_tid(ntracksp, maxtracks, tid);
1877     if(tracks)
1878       break;
1879     trackdb_abort_transaction(tid);
1880   }
1881   trackdb_commit_transaction(tid);
1882   return tracks;
1883 }
1884
1885 /** @brief Retrieve the most recently added tracks
1886  * @param ntracksp Where to put count, or 0
1887  * @param maxtracks Maximum number of tracks to retrieve, or 0 for all
1888  * @param tid Transaction ID
1889  * @return null-terminated array of track names, or NULL on deadlock
1890  *
1891  * The most recently added track is first in the array.
1892  */
1893 static char **trackdb_new_tid(int *ntracksp,
1894                               int maxtracks,
1895                               DB_TXN *tid) {
1896   DBC *c;
1897   DBT k, d;
1898   int err = 0;
1899   struct vector tracks[1];
1900
1901   vector_init(tracks);
1902   c = trackdb_opencursor(trackdb_noticeddb, tid);
1903   while((maxtracks <= 0 || tracks->nvec < maxtracks)
1904         && !(err = c->c_get(c, prepare_data(&k), prepare_data(&d), DB_PREV)))
1905     vector_append(tracks, xstrndup(d.data, d.size));
1906   switch(err) {
1907   case 0:                               /* hit maxtracks */
1908   case DB_NOTFOUND:                     /* ran out of tracks */
1909     break;
1910   case DB_LOCK_DEADLOCK:
1911     trackdb_closecursor(c);
1912     return 0;
1913   default:
1914     fatal(0, "error reading noticed.db: %s", db_strerror(err));
1915   }
1916   if((err = trackdb_closecursor(c)))
1917     return 0;                           /* deadlock */
1918   vector_terminate(tracks);
1919   if(ntracksp)
1920     *ntracksp = tracks->nvec;
1921   return tracks->vec;
1922 }
1923
1924 /* tidying up ****************************************************************/
1925
1926 void trackdb_gc(void) {
1927   int err;
1928   char **logfiles;
1929
1930   if((err = trackdb_env->txn_checkpoint(trackdb_env,
1931                                         config->checkpoint_kbyte,
1932                                         config->checkpoint_min,
1933                                         0)))
1934     fatal(0, "trackdb_env->txn_checkpoint: %s", db_strerror(err));
1935   if((err = trackdb_env->log_archive(trackdb_env, &logfiles, DB_ARCH_REMOVE)))
1936     fatal(0, "trackdb_env->log_archive: %s", db_strerror(err));
1937   /* This makes catastrophic recovery impossible.  However, the user can still
1938    * preserve the important data by using disorder-dump to snapshot their
1939    * prefs, and later to restore it.  This is likely to have much small
1940    * long-term storage requirements than record the db logfiles. */
1941 }
1942
1943 /*
1944 Local Variables:
1945 c-basic-offset:2
1946 comment-column:40
1947 fill-column:79
1948 indent-tabs-mode:nil
1949 End:
1950 */