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

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2004-2008 Richard Kettlewell
   4  * Portions copyright (C) 2007 Mark Wooding
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19  * USA
  20  */
  21 /** @file lib/configuration.c
  22  * @brief Configuration file support
  23  */
  24
  25 #include <config.h>
  26 #include "types.h"
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <errno.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <unistd.h>
  35 #include <ctype.h>
  36 #include <stddef.h>
  37 #include <pwd.h>
  38 #include <langinfo.h>
  39 #include <pcre.h>
  40 #include <signal.h>
  41
  42 #include "rights.h"
  43 #include "configuration.h"
  44 #include "mem.h"
  45 #include "log.h"
  46 #include "split.h"
  47 #include "syscalls.h"
  48 #include "table.h"
  49 #include "inputline.h"
  50 #include "charset.h"
  51 #include "defs.h"
  52 #include "mixer.h"
  53 #include "printf.h"
  54 #include "regsub.h"
  55 #include "signame.h"
  56 #include "authhash.h"
  57 #include "vector.h"
  58
  59 /** @brief Path to config file
  60  *
  61  * set_configfile() sets the deafult if it is null.
  62  */
  63 char *configfile;
  64
  65 /** @brief Read user configuration
  66  *
  67  * If clear, the user-specific configuration is not read.
  68  */
  69 int config_per_user = 1;
  70
  71 /** @brief Config file parser state */
  72 struct config_state {
  73   /** @brief Filename */
  74   const char *path;
  75   /** @brief Line number */
  76   int line;
  77   /** @brief Configuration object under construction */
  78   struct config *config;
  79 };
  80
  81 /** @brief Current configuration */
  82 struct config *config;
  83
  84 /** @brief One configuration item */
  85 struct conf {
  86   /** @brief Name as it appears in the config file */
  87   const char *name;
  88   /** @brief Offset in @ref config structure */
  89   size_t offset;
  90   /** @brief Pointer to item type */
  91   const struct conftype *type;
  92   /** @brief Pointer to item-specific validation routine */
  93   int (*validate)(const struct config_state *cs,
  94                   int nvec, char **vec);
  95 };
  96
  97 /** @brief Type of a configuration item */
  98 struct conftype {
  99   /** @brief Pointer to function to set item */
 100   int (*set)(const struct config_state *cs,
 101              const struct conf *whoami,
 102              int nvec, char **vec);
 103   /** @brief Pointer to function to free item */
 104   void (*free)(struct config *c, const struct conf *whoami);
 105 };
 106
 107 /** @brief Compute the address of an item */
 108 #define ADDRESS(C, TYPE) ((TYPE *)((char *)(C) + whoami->offset))
 109 /** @brief Return the value of an item */
 110 #define VALUE(C, TYPE) (*ADDRESS(C, TYPE))
 111
 112 static int set_signal(const struct config_state *cs,
 113                       const struct conf *whoami,
 114                       int nvec, char **vec) {
 115   int n;
 116
 117   if(nvec != 1) {
 118     error(0, "%s:%d: '%s' requires one argument",
 119           cs->path, cs->line, whoami->name);
 120     return -1;
 121   }
 122   if((n = find_signal(vec[0])) == -1) {
 123     error(0, "%s:%d: unknown signal '%s'",
 124           cs->path, cs->line, vec[0]);
 125     return -1;
 126   }
 127   VALUE(cs->config, int) = n;
 128   return 0;
 129 }
 130
 131 static int set_collections(const struct config_state *cs,
 132                            const struct conf *whoami,
 133                            int nvec, char **vec) {
 134   struct collectionlist *cl;
 135   const char *root, *encoding, *module;
 136
 137   switch(nvec) {
 138   case 1:
 139     module = 0;
 140     encoding = 0;
 141     root = vec[0];
 142     break;
 143   case 2:
 144     module = vec[0];
 145     encoding = 0;
 146     root = vec[1];
 147     break;
 148   case 3:
 149     module = vec[0];
 150     encoding = vec[1];
 151     root = vec[2];
 152     break;
 153   case 0:
 154     error(0, "%s:%d: '%s' requires at least one argument",
 155           cs->path, cs->line, whoami->name);
 156     return -1;
 157   default:
 158     error(0, "%s:%d: '%s' requires at most three arguments",
 159           cs->path, cs->line, whoami->name);
 160     return -1;
 161   }
 162   /* Sanity check root */
 163   if(root[0] != '/') {
 164     error(0, "%s:%d: collection root must start with '/'",
 165           cs->path, cs->line);
 166     return -1;
 167   }
 168   if(root[1] && root[strlen(root)-1] == '/') {
 169     error(0, "%s:%d: collection root must not end with '/'",
 170           cs->path, cs->line);
 171     return -1;
 172   }
 173   /* Defaults */
 174   if(!module)
 175     module = "fs";
 176   if(!encoding)
 177     encoding = nl_langinfo(CODESET);
 178   cl = ADDRESS(cs->config, struct collectionlist);
 179   ++cl->n;
 180   cl->s = xrealloc(cl->s, cl->n * sizeof (struct collection));
 181   cl->s[cl->n - 1].module = xstrdup(module);
 182   cl->s[cl->n - 1].encoding = xstrdup(encoding);
 183   cl->s[cl->n - 1].root = xstrdup(root);
 184   return 0;
 185 }
 186
 187 static int set_boolean(const struct config_state *cs,
 188                        const struct conf *whoami,
 189                        int nvec, char **vec) {
 190   int state;
 191
 192   if(nvec != 1) {
 193     error(0, "%s:%d: '%s' takes only one argument",
 194           cs->path, cs->line, whoami->name);
 195     return -1;
 196   }
 197   if(!strcmp(vec[0], "yes")) state = 1;
 198   else if(!strcmp(vec[0], "no")) state = 0;
 199   else {
 200     error(0, "%s:%d: argument to '%s' must be 'yes' or 'no'",
 201           cs->path, cs->line, whoami->name);
 202     return -1;
 203   }
 204   VALUE(cs->config, int) = state;
 205   return 0;
 206 }
 207
 208 static int set_string(const struct config_state *cs,
 209                       const struct conf *whoami,
 210                       int nvec, char **vec) {
 211   if(nvec != 1) {
 212     error(0, "%s:%d: '%s' takes only one argument",
 213           cs->path, cs->line, whoami->name);
 214     return -1;
 215   }
 216   VALUE(cs->config, char *) = xstrdup(vec[0]);
 217   return 0;
 218 }
 219
 220 static int set_stringlist(const struct config_state *cs,
 221                           const struct conf *whoami,
 222                           int nvec, char **vec) {
 223   int n;
 224   struct stringlist *sl;
 225
 226   sl = ADDRESS(cs->config, struct stringlist);
 227   sl->n = 0;
 228   for(n = 0; n < nvec; ++n) {
 229     sl->n++;
 230     sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));
 231     sl->s[sl->n - 1] = xstrdup(vec[n]);
 232   }
 233   return 0;
 234 }
 235
 236 static int set_integer(const struct config_state *cs,
 237                        const struct conf *whoami,
 238                        int nvec, char **vec) {
 239   char *e;
 240
 241   if(nvec != 1) {
 242     error(0, "%s:%d: '%s' takes only one argument",
 243           cs->path, cs->line, whoami->name);
 244     return -1;
 245   }
 246   if(xstrtol(ADDRESS(cs->config, long), vec[0], &e, 0)) {
 247     error(errno, "%s:%d: converting integer", cs->path, cs->line);
 248     return -1;
 249   }
 250   if(*e) {
 251     error(0, "%s:%d: invalid integer syntax", cs->path, cs->line);
 252     return -1;
 253   }
 254   return 0;
 255 }
 256
 257 static int set_stringlist_accum(const struct config_state *cs,
 258                                 const struct conf *whoami,
 259                                 int nvec, char **vec) {
 260   int n;
 261   struct stringlist *s;
 262   struct stringlistlist *sll;
 263
 264   sll = ADDRESS(cs->config, struct stringlistlist);
 265   if(nvec == 0) {
 266     sll->n = 0;
 267     return 0;
 268   }
 269   sll->n++;
 270   sll->s = xrealloc(sll->s, (sll->n * sizeof (struct stringlist)));
 271   s = &sll->s[sll->n - 1];
 272   s->n = nvec;
 273   s->s = xmalloc((nvec + 1) * sizeof (char *));
 274   for(n = 0; n < nvec; ++n)
 275     s->s[n] = xstrdup(vec[n]);
 276   return 0;
 277 }
 278
 279 static int set_string_accum(const struct config_state *cs,
 280                             const struct conf *whoami,
 281                             int nvec, char **vec) {
 282   int n;
 283   struct stringlist *sl;
 284
 285   sl = ADDRESS(cs->config, struct stringlist);
 286   if(nvec == 0) {
 287     sl->n = 0;
 288     return 0;
 289   }
 290   for(n = 0; n < nvec; ++n) {
 291     sl->n++;
 292     sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));
 293     sl->s[sl->n - 1] = xstrdup(vec[n]);
 294   }
 295   return 0;
 296 }
 297
 298 static int set_restrict(const struct config_state *cs,
 299                         const struct conf *whoami,
 300                         int nvec, char **vec) {
 301   unsigned r = 0;
 302   int n, i;
 303
 304   static const struct restriction {
 305     const char *name;
 306     unsigned bit;
 307   } restrictions[] = {
 308     { "remove", RESTRICT_REMOVE },
 309     { "scratch", RESTRICT_SCRATCH },
 310     { "move", RESTRICT_MOVE },
 311   };
 312
 313   for(n = 0; n < nvec; ++n) {
 314     if((i = TABLE_FIND(restrictions, struct restriction, name, vec[n])) < 0) {
 315       error(0, "%s:%d: invalid restriction '%s'",
 316             cs->path, cs->line, vec[n]);
 317       return -1;
 318     }
 319     r |= restrictions[i].bit;
 320   }
 321   VALUE(cs->config, unsigned) = r;
 322   return 0;
 323 }
 324
 325 static int parse_sample_format(const struct config_state *cs,
 326                                struct stream_header *format,
 327                                int nvec, char **vec) {
 328   char *p = vec[0];
 329   long t;
 330
 331   if(nvec != 1) {
 332     error(0, "%s:%d: wrong number of arguments", cs->path, cs->line);
 333     return -1;
 334   }
 335   if(xstrtol(&t, p, &p, 0)) {
 336     error(errno, "%s:%d: converting bits-per-sample", cs->path, cs->line);
 337     return -1;
 338   }
 339   if(t != 8 && t != 16) {
 340     error(0, "%s:%d: bad bite-per-sample (%ld)", cs->path, cs->line, t);
 341     return -1;
 342   }
 343   if(format) format->bits = t;
 344   switch (*p) {
 345     case 'l': case 'L': t = ENDIAN_LITTLE; p++; break;
 346     case 'b': case 'B': t = ENDIAN_BIG; p++; break;
 347     default: t = ENDIAN_NATIVE; break;
 348   }
 349   if(format) format->endian = t;
 350   if(*p != '/') {
 351     error(errno, "%s:%d: expected `/' after bits-per-sample",
 352           cs->path, cs->line);
 353     return -1;
 354   }
 355   p++;
 356   if(xstrtol(&t, p, &p, 0)) {
 357     error(errno, "%s:%d: converting sample-rate", cs->path, cs->line);
 358     return -1;
 359   }
 360   if(t < 1 || t > INT_MAX) {
 361     error(0, "%s:%d: silly sample-rate (%ld)", cs->path, cs->line, t);
 362     return -1;
 363   }
 364   if(format) format->rate = t;
 365   if(*p != '/') {
 366     error(0, "%s:%d: expected `/' after sample-rate",
 367           cs->path, cs->line);
 368     return -1;
 369   }
 370   p++;
 371   if(xstrtol(&t, p, &p, 0)) {
 372     error(errno, "%s:%d: converting channels", cs->path, cs->line);
 373     return -1;
 374   }
 375   if(t < 1 || t > 8) {
 376     error(0, "%s:%d: silly number (%ld) of channels", cs->path, cs->line, t);
 377     return -1;
 378   }
 379   if(format) format->channels = t;
 380   if(*p) {
 381     error(0, "%s:%d: junk after channels", cs->path, cs->line);
 382     return -1;
 383   }
 384   return 0;
 385 }
 386
 387 static int set_sample_format(const struct config_state *cs,
 388                              const struct conf *whoami,
 389                              int nvec, char **vec) {
 390   return parse_sample_format(cs, ADDRESS(cs->config, struct stream_header),
 391                              nvec, vec);
 392 }
 393
 394 static int set_namepart(const struct config_state *cs,
 395                         const struct conf *whoami,
 396                         int nvec, char **vec) {
 397   struct namepartlist *npl = ADDRESS(cs->config, struct namepartlist);
 398   unsigned reflags;
 399   const char *errstr;
 400   int erroffset, n;
 401   pcre *re;
 402
 403   if(nvec < 3) {
 404     error(0, "%s:%d: namepart needs at least 3 arguments", cs->path, cs->line);
 405     return -1;
 406   }
 407   if(nvec > 5) {
 408     error(0, "%s:%d: namepart needs at most 5 arguments", cs->path, cs->line);
 409     return -1;
 410   }
 411   reflags = nvec >= 5 ? regsub_flags(vec[4]) : 0;
 412   if(!(re = pcre_compile(vec[1],
 413                          PCRE_UTF8
 414                          |regsub_compile_options(reflags),
 415                          &errstr, &erroffset, 0))) {
 416     error(0, "%s:%d: error compiling regexp /%s/: %s (offset %d)",
 417           cs->path, cs->line, vec[1], errstr, erroffset);
 418     return -1;
 419   }
 420   npl->s = xrealloc(npl->s, (npl->n + 1) * sizeof (struct namepart));
 421   npl->s[npl->n].part = xstrdup(vec[0]);
 422   npl->s[npl->n].re = re;
 423   npl->s[npl->n].replace = xstrdup(vec[2]);
 424   npl->s[npl->n].context = xstrdup(vec[3]);
 425   npl->s[npl->n].reflags = reflags;
 426   ++npl->n;
 427   /* XXX a bit of a bodge; relies on there being very few parts. */
 428   for(n = 0; (n < cs->config->nparts
 429               && strcmp(cs->config->parts[n], vec[0])); ++n)
 430     ;
 431   if(n >= cs->config->nparts) {
 432     cs->config->parts = xrealloc(cs->config->parts,
 433                                  (cs->config->nparts + 1) * sizeof (char *));
 434     cs->config->parts[cs->config->nparts++] = xstrdup(vec[0]);
 435   }
 436   return 0;
 437 }
 438
 439 static int set_transform(const struct config_state *cs,
 440                          const struct conf *whoami,
 441                          int nvec, char **vec) {
 442   struct transformlist *tl = ADDRESS(cs->config, struct transformlist);
 443   pcre *re;
 444   unsigned reflags;
 445   const char *errstr;
 446   int erroffset;
 447
 448   if(nvec < 3) {
 449     error(0, "%s:%d: transform needs at least 3 arguments", cs->path, cs->line);
 450     return -1;
 451   }
 452   if(nvec > 5) {
 453     error(0, "%s:%d: transform needs at most 5 arguments", cs->path, cs->line);
 454     return -1;
 455   }
 456   reflags = (nvec >= 5 ? regsub_flags(vec[4]) : 0);
 457   if(!(re = pcre_compile(vec[1],
 458                          PCRE_UTF8
 459                          |regsub_compile_options(reflags),
 460                          &errstr, &erroffset, 0))) {
 461     error(0, "%s:%d: error compiling regexp /%s/: %s (offset %d)",
 462           cs->path, cs->line, vec[1], errstr, erroffset);
 463     return -1;
 464   }
 465   tl->t = xrealloc(tl->t, (tl->n + 1) * sizeof (struct namepart));
 466   tl->t[tl->n].type = xstrdup(vec[0]);
 467   tl->t[tl->n].context = xstrdup(vec[3] ? vec[3] : "*");
 468   tl->t[tl->n].re = re;
 469   tl->t[tl->n].replace = xstrdup(vec[2]);
 470   tl->t[tl->n].flags = reflags;
 471   ++tl->n;
 472   return 0;
 473 }
 474
 475 static int set_backend(const struct config_state *cs,
 476                        const struct conf *whoami,
 477                        int nvec, char **vec) {
 478   int *const valuep = ADDRESS(cs->config, int);
 479
 480   if(nvec != 1) {
 481     error(0, "%s:%d: '%s' requires one argument",
 482           cs->path, cs->line, whoami->name);
 483     return -1;
 484   }
 485   if(!strcmp(vec[0], "alsa")) {
 486 #if HAVE_ALSA_ASOUNDLIB_H
 487     *valuep = BACKEND_ALSA;
 488 #else
 489     error(0, "%s:%d: ALSA is not available on this platform",
 490           cs->path, cs->line);
 491     return -1;
 492 #endif
 493   } else if(!strcmp(vec[0], "command"))
 494     *valuep = BACKEND_COMMAND;
 495   else if(!strcmp(vec[0], "network"))
 496     *valuep = BACKEND_NETWORK;
 497   else if(!strcmp(vec[0], "coreaudio")) {
 498 #if HAVE_COREAUDIO_AUDIOHARDWARE_H
 499     *valuep = BACKEND_COREAUDIO;
 500 #else
 501     error(0, "%s:%d: Core Audio is not available on this platform",
 502           cs->path, cs->line);
 503     return -1;
 504 #endif
 505   } else if(!strcmp(vec[0], "oss")) {
 506 #if HAVE_SYS_SOUNDCARD_H
 507     *valuep = BACKEND_OSS;
 508 #else
 509     error(0, "%s:%d: OSS is not available on this platform",
 510           cs->path, cs->line);
 511     return -1;
 512 #endif
 513   } else {
 514     error(0, "%s:%d: invalid '%s' value '%s'",
 515           cs->path, cs->line, whoami->name, vec[0]);
 516     return -1;
 517   }
 518   return 0;
 519 }
 520
 521 static int set_rights(const struct config_state *cs,
 522                       const struct conf *whoami,
 523                       int nvec, char **vec) {
 524   if(nvec != 1) {
 525     error(0, "%s:%d: '%s' requires one argument",
 526           cs->path, cs->line, whoami->name);
 527     return -1;
 528   }
 529   if(parse_rights(vec[0], 0, 1)) {
 530     error(0, "%s:%d: invalid rights string '%s'",
 531           cs->path, cs->line, vec[0]);
 532     return -1;
 533   }
 534   *ADDRESS(cs->config, char *) = vec[0];
 535   return 0;
 536 }
 537
 538 /* free functions */
 539
 540 static void free_none(struct config attribute((unused)) *c,
 541                       const struct conf attribute((unused)) *whoami) {
 542 }
 543
 544 static void free_string(struct config *c,
 545                         const struct conf *whoami) {
 546   xfree(VALUE(c, char *));
 547 }
 548
 549 static void free_stringlist(struct config *c,
 550                             const struct conf *whoami) {
 551   int n;
 552   struct stringlist *sl = ADDRESS(c, struct stringlist);
 553
 554   for(n = 0; n < sl->n; ++n)
 555     xfree(sl->s[n]);
 556   xfree(sl->s);
 557 }
 558
 559 static void free_stringlistlist(struct config *c,
 560                                 const struct conf *whoami) {
 561   int n, m;
 562   struct stringlistlist *sll = ADDRESS(c, struct stringlistlist);
 563   struct stringlist *sl;
 564
 565   for(n = 0; n < sll->n; ++n) {
 566     sl = &sll->s[n];
 567     for(m = 0; m < sl->n; ++m)
 568       xfree(sl->s[m]);
 569     xfree(sl->s);
 570   }
 571   xfree(sll->s);
 572 }
 573
 574 static void free_collectionlist(struct config *c,
 575                                 const struct conf *whoami) {
 576   struct collectionlist *cll = ADDRESS(c, struct collectionlist);
 577   struct collection *cl;
 578   int n;
 579
 580   for(n = 0; n < cll->n; ++n) {
 581     cl = &cll->s[n];
 582     xfree(cl->module);
 583     xfree(cl->encoding);
 584     xfree(cl->root);
 585   }
 586   xfree(cll->s);
 587 }
 588
 589 static void free_namepartlist(struct config *c,
 590                               const struct conf *whoami) {
 591   struct namepartlist *npl = ADDRESS(c, struct namepartlist);
 592   struct namepart *np;
 593   int n;
 594
 595   for(n = 0; n < npl->n; ++n) {
 596     np = &npl->s[n];
 597     xfree(np->part);
 598     pcre_free(np->re);                  /* ...whatever pcre_free is set to. */
 599     xfree(np->replace);
 600     xfree(np->context);
 601   }
 602   xfree(npl->s);
 603 }
 604
 605 static void free_transformlist(struct config *c,
 606                                const struct conf *whoami) {
 607   struct transformlist *tl = ADDRESS(c, struct transformlist);
 608   struct transform *t;
 609   int n;
 610
 611   for(n = 0; n < tl->n; ++n) {
 612     t = &tl->t[n];
 613     xfree(t->type);
 614     pcre_free(t->re);                   /* ...whatever pcre_free is set to. */
 615     xfree(t->replace);
 616     xfree(t->context);
 617   }
 618   xfree(tl->t);
 619 }
 620
 621 /* configuration types */
 622
 623 static const struct conftype
 624   type_signal = { set_signal, free_none },
 625   type_collections = { set_collections, free_collectionlist },
 626   type_boolean = { set_boolean, free_none },
 627   type_string = { set_string, free_string },
 628   type_stringlist = { set_stringlist, free_stringlist },
 629   type_integer = { set_integer, free_none },
 630   type_stringlist_accum = { set_stringlist_accum, free_stringlistlist },
 631   type_string_accum = { set_string_accum, free_stringlist },
 632   type_sample_format = { set_sample_format, free_none },
 633   type_restrict = { set_restrict, free_none },
 634   type_namepart = { set_namepart, free_namepartlist },
 635   type_transform = { set_transform, free_transformlist },
 636   type_rights = { set_rights, free_none },
 637   type_backend = { set_backend, free_none };
 638
 639 /* specific validation routine */
 640
 641 #define VALIDATE_FILE(test, what) do {                          \
 642   struct stat sb;                                               \
 643   int n;                                                        \
 644                                                                 \
 645   for(n = 0; n < nvec; ++n) {                                   \
 646     if(stat(vec[n], &sb) < 0) {                                 \
 647       error(errno, "%s:%d: %s", cs->path, cs->line, vec[n]);    \
 648       return -1;                                                \
 649     }                                                           \
 650     if(!test(sb.st_mode)) {                                     \
 651       error(0, "%s:%d: %s is not a %s",                         \
 652             cs->path, cs->line, vec[n], what);                  \
 653       return -1;                                                \
 654     }                                                           \
 655   }                                                             \
 656 } while(0)
 657
 658 static int validate_isabspath(const struct config_state *cs,
 659                               int nvec, char **vec) {
 660   int n;
 661
 662   for(n = 0; n < nvec; ++n)
 663     if(vec[n][0] != '/') {
 664       error(errno, "%s:%d: %s: not an absolute path",
 665             cs->path, cs->line, vec[n]);
 666       return -1;
 667     }
 668   return 0;
 669 }
 670
 671 static int validate_isdir(const struct config_state *cs,
 672                           int nvec, char **vec) {
 673   VALIDATE_FILE(S_ISDIR, "directory");
 674   return 0;
 675 }
 676
 677 static int validate_isreg(const struct config_state *cs,
 678                           int nvec, char **vec) {
 679   VALIDATE_FILE(S_ISREG, "regular file");
 680   return 0;
 681 }
 682
 683 static int validate_player(const struct config_state *cs,
 684                            int nvec,
 685                            char attribute((unused)) **vec) {
 686   if(nvec < 2) {
 687     error(0, "%s:%d: should be at least 'player PATTERN MODULE'",
 688           cs->path, cs->line);
 689     return -1;
 690   }
 691   return 0;
 692 }
 693
 694 static int validate_tracklength(const struct config_state *cs,
 695                                 int nvec,
 696                                 char attribute((unused)) **vec) {
 697   if(nvec < 2) {
 698     error(0, "%s:%d: should be at least 'tracklength PATTERN MODULE'",
 699           cs->path, cs->line);
 700     return -1;
 701   }
 702   return 0;
 703 }
 704
 705 static int validate_allow(const struct config_state *cs,
 706                           int nvec,
 707                           char attribute((unused)) **vec) {
 708   if(nvec != 2) {
 709     error(0, "%s:%d: must be 'allow NAME PASS'", cs->path, cs->line);
 710     return -1;
 711   }
 712   return 0;
 713 }
 714
 715 static int validate_non_negative(const struct config_state *cs,
 716                                  int nvec, char **vec) {
 717   long n;
 718
 719   if(nvec < 1) {
 720     error(0, "%s:%d: missing argument", cs->path, cs->line);
 721     return -1;
 722   }
 723   if(nvec > 1) {
 724     error(0, "%s:%d: too many arguments", cs->path, cs->line);
 725     return -1;
 726   }
 727   if(xstrtol(&n, vec[0], 0, 0)) {
 728     error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
 729     return -1;
 730   }
 731   if(n < 0) {
 732     error(0, "%s:%d: must not be negative", cs->path, cs->line);
 733     return -1;
 734   }
 735   return 0;
 736 }
 737
 738 static int validate_positive(const struct config_state *cs,
 739                           int nvec, char **vec) {
 740   long n;
 741
 742   if(nvec < 1) {
 743     error(0, "%s:%d: missing argument", cs->path, cs->line);
 744     return -1;
 745   }
 746   if(nvec > 1) {
 747     error(0, "%s:%d: too many arguments", cs->path, cs->line);
 748     return -1;
 749   }
 750   if(xstrtol(&n, vec[0], 0, 0)) {
 751     error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
 752     return -1;
 753   }
 754   if(n <= 0) {
 755     error(0, "%s:%d: must be positive", cs->path, cs->line);
 756     return -1;
 757   }
 758   return 0;
 759 }
 760
 761 static int validate_isauser(const struct config_state *cs,
 762                             int attribute((unused)) nvec,
 763                             char **vec) {
 764   struct passwd *pw;
 765
 766   if(!(pw = getpwnam(vec[0]))) {
 767     error(0, "%s:%d: no such user as '%s'", cs->path, cs->line, vec[0]);
 768     return -1;
 769   }
 770   return 0;
 771 }
 772
 773 static int validate_sample_format(const struct config_state *cs,
 774                                   int attribute((unused)) nvec,
 775                                   char **vec) {
 776   return parse_sample_format(cs, 0, nvec, vec);
 777 }
 778
 779 static int validate_any(const struct config_state attribute((unused)) *cs,
 780                         int attribute((unused)) nvec,
 781                         char attribute((unused)) **vec) {
 782   return 0;
 783 }
 784
 785 static int validate_url(const struct config_state attribute((unused)) *cs,
 786                         int attribute((unused)) nvec,
 787                         char **vec) {
 788   const char *s;
 789   int n;
 790   /* absoluteURI   = scheme ":" ( hier_part | opaque_part )
 791      scheme        = alpha *( alpha | digit | "+" | "-" | "." ) */
 792   s = vec[0];
 793   n = strspn(s, ("abcdefghijklmnopqrstuvwxyz"
 794                  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 795                  "0123456789"));
 796   if(s[n] != ':') {
 797     error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
 798     return -1;
 799   }
 800   if(!strncmp(s, "http:", 5)
 801      || !strncmp(s, "https:", 6)) {
 802     s += n + 1;
 803     /* we only do a rather cursory check */
 804     if(strncmp(s, "//", 2)) {
 805       error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
 806       return -1;
 807     }
 808   }
 809   return 0;
 810 }
 811
 812 static int validate_alias(const struct config_state *cs,
 813                           int nvec,
 814                           char **vec) {
 815   const char *s;
 816   int in_brackets = 0, c;
 817
 818   if(nvec < 1) {
 819     error(0, "%s:%d: missing argument", cs->path, cs->line);
 820     return -1;
 821   }
 822   if(nvec > 1) {
 823     error(0, "%s:%d: too many arguments", cs->path, cs->line);
 824     return -1;
 825   }
 826   s = vec[0];
 827   while((c = (unsigned char)*s++)) {
 828     if(in_brackets) {
 829       if(c == '}')
 830         in_brackets = 0;
 831       else if(!isalnum(c)) {
 832         error(0, "%s:%d: invalid part name in alias expansion in '%s'",
 833               cs->path, cs->line, vec[0]);
 834           return -1;
 835       }
 836     } else {
 837       if(c == '{') {
 838         in_brackets = 1;
 839         if(*s == '/')
 840           ++s;
 841       } else if(c == '\\') {
 842         if(!(c = (unsigned char)*s++)) {
 843           error(0, "%s:%d: unterminated escape in alias expansion in '%s'",
 844                 cs->path, cs->line, vec[0]);
 845           return -1;
 846         } else if(c != '\\' && c != '{') {
 847           error(0, "%s:%d: invalid escape in alias expansion in '%s'",
 848                 cs->path, cs->line, vec[0]);
 849           return -1;
 850         }
 851       }
 852     }
 853     ++s;
 854   }
 855   if(in_brackets) {
 856     error(0, "%s:%d: unterminated part name in alias expansion in '%s'",
 857           cs->path, cs->line, vec[0]);
 858     return -1;
 859   }
 860   return 0;
 861 }
 862
 863 static int validate_addrport(const struct config_state attribute((unused)) *cs,
 864                              int nvec,
 865                              char attribute((unused)) **vec) {
 866   switch(nvec) {
 867   case 0:
 868     error(0, "%s:%d: missing address",
 869           cs->path, cs->line);
 870     return -1;
 871   case 1:
 872     error(0, "%s:%d: missing port name/number",
 873           cs->path, cs->line);
 874     return -1;
 875   case 2:
 876     return 0;
 877   default:
 878     error(0, "%s:%d: expected ADDRESS PORT",
 879           cs->path, cs->line);
 880     return -1;
 881   }
 882 }
 883
 884 static int validate_port(const struct config_state attribute((unused)) *cs,
 885                          int nvec,
 886                          char attribute((unused)) **vec) {
 887   switch(nvec) {
 888   case 0:
 889     error(0, "%s:%d: missing address",
 890           cs->path, cs->line);
 891     return -1;
 892   case 1:
 893   case 2:
 894     return 0;
 895   default:
 896     error(0, "%s:%d: expected [ADDRESS] PORT",
 897           cs->path, cs->line);
 898     return -1;
 899   }
 900 }
 901
 902 static int validate_algo(const struct config_state attribute((unused)) *cs,
 903                          int nvec,
 904                          char **vec) {
 905   if(nvec != 1) {
 906     error(0, "%s:%d: invalid algorithm specification", cs->path, cs->line);
 907     return -1;
 908   }
 909   if(!valid_authhash(vec[0])) {
 910     error(0, "%s:%d: unsuported algorithm '%s'", cs->path, cs->line, vec[0]);
 911     return -1;
 912   }
 913   return 0;
 914 }
 915
 916 /** @brief Item name and and offset */
 917 #define C(x) #x, offsetof(struct config, x)
 918 /** @brief Item name and and offset */
 919 #define C2(x,y) #x, offsetof(struct config, y)
 920
 921 /** @brief All configuration items */
 922 static const struct conf conf[] = {
 923   { C(alias),            &type_string,           validate_alias },
 924   { C(allow),            &type_stringlist_accum, validate_allow },
 925   { C(api),              &type_backend,          validate_any },
 926   { C(authorization_algorithm), &type_string,    validate_algo },
 927   { C(broadcast),        &type_stringlist,       validate_addrport },
 928   { C(broadcast_from),   &type_stringlist,       validate_addrport },
 929   { C(channel),          &type_string,           validate_any },
 930   { C(checkpoint_kbyte), &type_integer,          validate_non_negative },
 931   { C(checkpoint_min),   &type_integer,          validate_non_negative },
 932   { C(collection),       &type_collections,      validate_any },
 933   { C(connect),          &type_stringlist,       validate_addrport },
 934   { C(cookie_login_lifetime),  &type_integer,    validate_positive },
 935   { C(cookie_key_lifetime),  &type_integer,      validate_positive },
 936   { C(dbversion),        &type_integer,          validate_positive },
 937   { C(default_rights),   &type_rights,           validate_any },
 938   { C(device),           &type_string,           validate_any },
 939   { C(gap),              &type_integer,          validate_non_negative },
 940   { C(history),          &type_integer,          validate_positive },
 941   { C(home),             &type_string,           validate_isabspath },
 942   { C(listen),           &type_stringlist,       validate_port },
 943   { C(lock),             &type_boolean,          validate_any },
 944   { C(mail_sender),      &type_string,           validate_any },
 945   { C(mixer),            &type_string,           validate_any },
 946   { C(multicast_loop),   &type_boolean,          validate_any },
 947   { C(multicast_ttl),    &type_integer,          validate_non_negative },
 948   { C(namepart),         &type_namepart,         validate_any },
 949   { C(new_max),          &type_integer,          validate_positive },
 950   { C2(nice, nice_rescan), &type_integer,        validate_non_negative },
 951   { C(nice_rescan),      &type_integer,          validate_non_negative },
 952   { C(nice_server),      &type_integer,          validate_any },
 953   { C(nice_speaker),     &type_integer,          validate_any },
 954   { C(noticed_history),  &type_integer,          validate_positive },
 955   { C(password),         &type_string,           validate_any },
 956   { C(player),           &type_stringlist_accum, validate_player },
 957   { C(plugins),          &type_string_accum,     validate_isdir },
 958   { C(prefsync),         &type_integer,          validate_positive },
 959   { C(queue_pad),        &type_integer,          validate_positive },
 960   { C(refresh),          &type_integer,          validate_positive },
 961   { C(reminder_interval), &type_integer,         validate_positive },
 962   { C2(restrict, restrictions),         &type_restrict,         validate_any },
 963   { C(sample_format),    &type_sample_format,    validate_sample_format },
 964   { C(scratch),          &type_string_accum,     validate_isreg },
 965   { C(short_display),    &type_integer,          validate_positive },
 966   { C(signal),           &type_signal,           validate_any },
 967   { C(smtp_server),      &type_string,           validate_any },
 968   { C(sox_generation),   &type_integer,          validate_non_negative },
 969   { C2(speaker_backend, api),  &type_backend,          validate_any },
 970   { C(speaker_command),  &type_string,           validate_any },
 971   { C(stopword),         &type_string_accum,     validate_any },
 972   { C(templates),        &type_string_accum,     validate_isdir },
 973   { C(tracklength),      &type_stringlist_accum, validate_tracklength },
 974   { C(transform),        &type_transform,        validate_any },
 975   { C(trust),            &type_string_accum,     validate_any },
 976   { C(url),              &type_string,           validate_url },
 977   { C(user),             &type_string,           validate_isauser },
 978   { C(username),         &type_string,           validate_any },
 979 };
 980
 981 /** @brief Find a configuration item's definition by key */
 982 static const struct conf *find(const char *key) {
 983   int n;
 984
 985   if((n = TABLE_FIND(conf, struct conf, name, key)) < 0)
 986     return 0;
 987   return &conf[n];
 988 }
 989
 990 /** @brief Set a new configuration value */
 991 static int config_set(const struct config_state *cs,
 992                       int nvec, char **vec) {
 993   const struct conf *which;
 994
 995   D(("config_set %s", vec[0]));
 996   if(!(which = find(vec[0]))) {
 997     error(0, "%s:%d: unknown configuration key '%s'",
 998           cs->path, cs->line, vec[0]);
 999     return -1;
1000   }
1001   return (which->validate(cs, nvec - 1, vec + 1)
1002           || which->type->set(cs, which, nvec - 1, vec + 1));
1003 }
1004
1005 static int config_set_args(const struct config_state *cs,
1006                            const char *which, ...) {
1007   va_list ap;
1008   struct vector v[1];
1009   char *s;
1010
1011   vector_init(v);
1012   vector_append(v, (char *)which);
1013   va_start(ap, which);
1014   while((s = va_arg(ap, char *)))
1015     vector_append(v, s);
1016   va_end(ap);
1017   vector_terminate(v);
1018   return config_set(cs, v->nvec, v->vec);
1019 }
1020
1021 /** @brief Error callback used by config_include() */
1022 static void config_error(const char *msg, void *u) {
1023   const struct config_state *cs = u;
1024
1025   error(0, "%s:%d: %s", cs->path, cs->line, msg);
1026 }
1027
1028 /** @brief Include a file by name */
1029 static int config_include(struct config *c, const char *path) {
1030   FILE *fp;
1031   char *buffer, *inputbuffer, **vec;
1032   int n, ret = 0;
1033   struct config_state cs;
1034
1035   cs.path = path;
1036   cs.line = 0;
1037   cs.config = c;
1038   D(("%s: reading configuration", path));
1039   if(!(fp = fopen(path, "r"))) {
1040     error(errno, "error opening %s", path);
1041     return -1;
1042   }
1043   while(!inputline(path, fp, &inputbuffer, '\n')) {
1044     ++cs.line;
1045     if(!(buffer = mb2utf8(inputbuffer))) {
1046       error(errno, "%s:%d: cannot convert to UTF-8", cs.path, cs.line);
1047       ret = -1;
1048       xfree(inputbuffer);
1049       continue;
1050     }
1051     xfree(inputbuffer);
1052     if(!(vec = split(buffer, &n, SPLIT_COMMENTS|SPLIT_QUOTES,
1053                      config_error, &cs))) {
1054       ret = -1;
1055       xfree(buffer);
1056       continue;
1057     }
1058     if(n) {
1059       if(!strcmp(vec[0], "include")) {
1060         if(n != 2) {
1061           error(0, "%s:%d: must be 'include PATH'", cs.path, cs.line);
1062           ret = -1;
1063         } else
1064           config_include(c, vec[1]);
1065       } else
1066         ret |= config_set(&cs, n, vec);
1067     }
1068     for(n = 0; vec[n]; ++n) xfree(vec[n]);
1069     xfree(vec);
1070     xfree(buffer);
1071   }
1072   if(ferror(fp)) {
1073     error(errno, "error reading %s", path);
1074     ret = -1;
1075   }
1076   fclose(fp);
1077   return ret;
1078 }
1079
1080 static const char *const default_stopwords[] = {
1081   "stopword",
1082
1083   "01",
1084   "02",
1085   "03",
1086   "04",
1087   "05",
1088   "06",
1089   "07",
1090   "08",
1091   "09",
1092   "1",
1093   "10",
1094   "11",
1095   "12",
1096   "13",
1097   "14",
1098   "15",
1099   "16",
1100   "17",
1101   "18",
1102   "19",
1103   "2",
1104   "20",
1105   "21",
1106   "22",
1107   "23",
1108   "24",
1109   "25",
1110   "26",
1111   "27",
1112   "28",
1113   "29",
1114   "3",
1115   "30",
1116   "4",
1117   "5",
1118   "6",
1119   "7",
1120   "8",
1121   "9",
1122   "a",
1123   "am",
1124   "an",
1125   "and",
1126   "as",
1127   "for",
1128   "i",
1129   "im",
1130   "in",
1131   "is",
1132   "of",
1133   "on",
1134   "the",
1135   "to",
1136   "too",
1137   "we",
1138 };
1139 #define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
1140
1141 static const char *const default_players[] = {
1142   "*.ogg",
1143   "*.flac",
1144   "*.mp3",
1145   "*.wav",
1146 };
1147 #define NDEFAULT_PLAYERS (sizeof default_players / sizeof *default_players)
1148
1149 /** @brief Make a new default configuration */
1150 static struct config *config_default(void) {
1151   struct config *c = xmalloc(sizeof *c);
1152   const char *logname;
1153   struct passwd *pw;
1154   struct config_state cs;
1155   size_t n;
1156
1157   cs.path = "<internal>";
1158   cs.line = 0;
1159   cs.config = c;
1160   /* Strings had better be xstrdup'd as they will get freed at some point. */
1161   c->gap = 0;
1162   c->history = 60;
1163   c->home = xstrdup(pkgstatedir);
1164   if(!(pw = getpwuid(getuid())))
1165     fatal(0, "cannot determine our username");
1166   logname = pw->pw_name;
1167   c->username = xstrdup(logname);
1168   c->refresh = 15;
1169   c->prefsync = 3600;
1170   c->signal = SIGKILL;
1171   c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
1172   c->lock = 1;
1173   c->device = xstrdup("default");
1174   c->nice_rescan = 10;
1175   c->speaker_command = 0;
1176   c->sample_format.bits = 16;
1177   c->sample_format.rate = 44100;
1178   c->sample_format.channels = 2;
1179   c->sample_format.endian = ENDIAN_NATIVE;
1180   c->queue_pad = 10;
1181   c->api = -1;
1182   c->multicast_ttl = 1;
1183   c->multicast_loop = 1;
1184   c->authorization_algorithm = xstrdup("sha1");
1185   c->noticed_history = 31;
1186   c->short_display = 32;
1187   c->mixer = 0;
1188   c->channel = 0;
1189   c->dbversion = 2;
1190   c->cookie_login_lifetime = 86400;
1191   c->cookie_key_lifetime = 86400 * 7;
1192   c->smtp_server = xstrdup("127.0.0.1");
1193   c->new_max = 100;
1194   c->reminder_interval = 600;           /* 10m */
1195   /* Default stopwords */
1196   if(config_set(&cs, (int)NDEFAULT_STOPWORDS, (char **)default_stopwords))
1197     exit(1);
1198   /* Default player configuration */
1199   for(n = 0; n < NDEFAULT_PLAYERS; ++n) {
1200     if(config_set_args(&cs, "player",
1201                        default_players[n], "execraw", "disorder-decode", (char *)0))
1202       exit(1);
1203     if(config_set_args(&cs, "tracklength",
1204                        default_players[n], "disorder-tracklength", (char *)0))
1205       exit(1);
1206   }
1207   return c;
1208 }
1209
1210 static char *get_file(struct config *c, const char *name) {
1211   char *s;
1212
1213   byte_xasprintf(&s, "%s/%s", c->home, name);
1214   return s;
1215 }
1216
1217 /** @brief Set the default configuration file */
1218 static void set_configfile(void) {
1219   if(!configfile)
1220     byte_xasprintf(&configfile, "%s/config", pkgconfdir);
1221 }
1222
1223 /** @brief Free a configuration object */
1224 static void config_free(struct config *c) {
1225   int n;
1226
1227   if(c) {
1228     for(n = 0; n < (int)(sizeof conf / sizeof *conf); ++n)
1229       conf[n].type->free(c, &conf[n]);
1230     for(n = 0; n < c->nparts; ++n)
1231       xfree(c->parts[n]);
1232     xfree(c->parts);
1233     xfree(c);
1234   }
1235 }
1236
1237 /** @brief Set post-parse defaults */
1238 static void config_postdefaults(struct config *c,
1239                                 int server) {
1240   struct config_state cs;
1241   const struct conf *whoami;
1242   int n;
1243
1244   static const char *namepart[][4] = {
1245     { "title",  "/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display" },
1246     { "title",  "/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort" },
1247     { "album",  "/([^/]+)/[^/]+$",                    "$1", "*" },
1248     { "artist", "/([^/]+)/[^/]+/[^/]+$",              "$1", "*" },
1249     { "ext",    "(\\.[a-zA-Z0-9]+)$",                 "$1", "*" },
1250   };
1251 #define NNAMEPART (int)(sizeof namepart / sizeof *namepart)
1252
1253   static const char *transform[][5] = {
1254     { "track", "^.*/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display", "" },
1255     { "track", "^.*/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort", "" },
1256     { "dir",   "^.*/([^/]+)$",                          "$1", "*", "" },
1257     { "dir",   "^(the) ([^/]*)",                        "$2, $1", "sort", "i", },
1258     { "dir",   "[[:punct:]]",                           "", "sort", "g", }
1259   };
1260 #define NTRANSFORM (int)(sizeof transform / sizeof *transform)
1261
1262   cs.path = "<internal>";
1263   cs.line = 0;
1264   cs.config = c;
1265   if(!c->namepart.n) {
1266     whoami = find("namepart");
1267     for(n = 0; n < NNAMEPART; ++n)
1268       set_namepart(&cs, whoami, 4, (char **)namepart[n]);
1269   }
1270   if(!c->transform.n) {
1271     whoami = find("transform");
1272     for(n = 0; n < NTRANSFORM; ++n)
1273       set_transform(&cs, whoami, 5, (char **)transform[n]);
1274   }
1275   if(c->api == -1) {
1276     if(c->speaker_command)
1277       c->api = BACKEND_COMMAND;
1278     else if(c->broadcast.n)
1279       c->api = BACKEND_NETWORK;
1280     else {
1281 #if HAVE_ALSA_ASOUNDLIB_H
1282       c->api = BACKEND_ALSA;
1283 #elif HAVE_SYS_SOUNDCARD_H
1284       c->api = BACKEND_OSS;
1285 #elif HAVE_COREAUDIO_AUDIOHARDWARE_H
1286       c->api = BACKEND_COREAUDIO;
1287 #else
1288       c->api = BACKEND_COMMAND;
1289 #endif
1290     }
1291   }
1292   if(server) {
1293     if(c->api == BACKEND_COMMAND && !c->speaker_command)
1294       fatal(0, "'api command' but speaker_command is not set");
1295     if(c->api == BACKEND_NETWORK && !c->broadcast.n)
1296       fatal(0, "'api network' but broadcast is not set");
1297   }
1298   /* Override sample format */
1299   switch(c->api) {
1300   case BACKEND_NETWORK:
1301     c->sample_format.rate = 44100;
1302     c->sample_format.channels = 2;
1303     c->sample_format.bits = 16;
1304     c->sample_format.endian = ENDIAN_BIG;
1305     break;
1306   case BACKEND_COREAUDIO:
1307     c->sample_format.rate = 44100;
1308     c->sample_format.channels = 2;
1309     c->sample_format.bits = 16;
1310     c->sample_format.endian = ENDIAN_NATIVE;
1311     break;
1312   }
1313   if(!c->default_rights) {
1314     rights_type r = RIGHTS__MASK & ~(RIGHT_ADMIN|RIGHT_REGISTER
1315                                      |RIGHT_MOVE__MASK
1316                                      |RIGHT_SCRATCH__MASK
1317                                      |RIGHT_REMOVE__MASK);
1318     /* The idea is to approximate the meaning of the old 'restrict' directive
1319      * in the default rights if they are not overridden. */
1320     if(c->restrictions & RESTRICT_SCRATCH)
1321       r |= RIGHT_SCRATCH_MINE|RIGHT_SCRATCH_RANDOM;
1322     else
1323       r |= RIGHT_SCRATCH_ANY;
1324     if(!(c->restrictions & RESTRICT_MOVE))
1325       r |= RIGHT_MOVE_ANY;
1326     if(c->restrictions & RESTRICT_REMOVE)
1327       r |= RIGHT_REMOVE_MINE;
1328     else
1329       r |= RIGHT_REMOVE_ANY;
1330     c->default_rights = rights_string(r);
1331   }
1332 }
1333
1334 /** @brief (Re-)read the config file
1335  * @param server If set, do extra checking
1336  */
1337 int config_read(int server) {
1338   struct config *c;
1339   char *privconf;
1340   struct passwd *pw;
1341
1342   set_configfile();
1343   c = config_default();
1344   /* standalone Disobedience installs might not have a global config file */
1345   if(access(configfile, F_OK) == 0)
1346     if(config_include(c, configfile))
1347       return -1;
1348   /* if we can read the private config file, do */
1349   if((privconf = config_private())
1350      && access(privconf, R_OK) == 0
1351      && config_include(c, privconf))
1352     return -1;
1353   xfree(privconf);
1354   /* if there's a per-user system config file for this user, read it */
1355   if(config_per_user) {
1356     if(!(pw = getpwuid(getuid())))
1357       fatal(0, "cannot determine our username");
1358     if((privconf = config_usersysconf(pw))
1359        && access(privconf, F_OK) == 0
1360        && config_include(c, privconf))
1361       return -1;
1362     xfree(privconf);
1363     /* if we have a password file, read it */
1364     if((privconf = config_userconf(0, pw))
1365        && access(privconf, F_OK) == 0
1366        && config_include(c, privconf))
1367       return -1;
1368     xfree(privconf);
1369   }
1370   /* install default namepart and transform settings */
1371   config_postdefaults(c, server);
1372   /* everything is good so we shall use the new config */
1373   config_free(config);
1374   /* warn about obsolete directives */
1375   if(c->restrictions)
1376     error(0, "'restrict' will be removed in a future version");
1377   if(c->allow.n)
1378     error(0, "'allow' will be removed in a future version");
1379   if(c->trust.n)
1380     error(0, "'trust' will be removed in a future version");
1381   config = c;
1382   return 0;
1383 }
1384
1385 /** @brief Return the path to the private configuration file */
1386 char *config_private(void) {
1387   char *s;
1388
1389   set_configfile();
1390   byte_xasprintf(&s, "%s.private", configfile);
1391   return s;
1392 }
1393
1394 /** @brief Return the path to user's personal configuration file */
1395 char *config_userconf(const char *home, const struct passwd *pw) {
1396   char *s;
1397
1398   if(!home && !pw && !(pw = getpwuid(getuid())))
1399     fatal(0, "cannot determine our username");
1400   byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
1401   return s;
1402 }
1403
1404 /** @brief Return the path to user-specific system configuration */
1405 char *config_usersysconf(const struct passwd *pw) {
1406   char *s;
1407
1408   set_configfile();
1409   if(!strchr(pw->pw_name, '/')) {
1410     byte_xasprintf(&s, "%s.%s", configfile, pw->pw_name);
1411     return s;
1412   } else
1413     return 0;
1414 }
1415
1416 char *config_get_file(const char *name) {
1417   return get_file(config, name);
1418 }
1419
1420 /*
1421 Local Variables:
1422 c-basic-offset:2
1423 comment-column:40
1424 fill-column:79
1425 End:
1426 */