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

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2004, 2005, 2006, 2007 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   { C2(nice, nice_rescan), &type_integer,        validate_non_negative },
 950   { C(nice_rescan),      &type_integer,          validate_non_negative },
 951   { C(nice_server),      &type_integer,          validate_any },
 952   { C(nice_speaker),     &type_integer,          validate_any },
 953   { C(noticed_history),  &type_integer,          validate_positive },
 954   { C(password),         &type_string,           validate_any },
 955   { C(player),           &type_stringlist_accum, validate_player },
 956   { C(plugins),          &type_string_accum,     validate_isdir },
 957   { C(prefsync),         &type_integer,          validate_positive },
 958   { C(queue_pad),        &type_integer,          validate_positive },
 959   { C(refresh),          &type_integer,          validate_positive },
 960   { C2(restrict, restrictions),         &type_restrict,         validate_any },
 961   { C(sample_format),    &type_sample_format,    validate_sample_format },
 962   { C(scratch),          &type_string_accum,     validate_isreg },
 963   { C(short_display),    &type_integer,          validate_positive },
 964   { C(signal),           &type_signal,           validate_any },
 965   { C(smtp_server),      &type_string,           validate_any },
 966   { C(sox_generation),   &type_integer,          validate_non_negative },
 967   { C2(speaker_backend, api),  &type_backend,          validate_any },
 968   { C(speaker_command),  &type_string,           validate_any },
 969   { C(stopword),         &type_string_accum,     validate_any },
 970   { C(templates),        &type_string_accum,     validate_isdir },
 971   { C(tracklength),      &type_stringlist_accum, validate_tracklength },
 972   { C(transform),        &type_transform,        validate_any },
 973   { C(trust),            &type_string_accum,     validate_any },
 974   { C(url),              &type_string,           validate_url },
 975   { C(user),             &type_string,           validate_isauser },
 976   { C(username),         &type_string,           validate_any },
 977 };
 978
 979 /** @brief Find a configuration item's definition by key */
 980 static const struct conf *find(const char *key) {
 981   int n;
 982
 983   if((n = TABLE_FIND(conf, struct conf, name, key)) < 0)
 984     return 0;
 985   return &conf[n];
 986 }
 987
 988 /** @brief Set a new configuration value */
 989 static int config_set(const struct config_state *cs,
 990                       int nvec, char **vec) {
 991   const struct conf *which;
 992
 993   D(("config_set %s", vec[0]));
 994   if(!(which = find(vec[0]))) {
 995     error(0, "%s:%d: unknown configuration key '%s'",
 996           cs->path, cs->line, vec[0]);
 997     return -1;
 998   }
 999   return (which->validate(cs, nvec - 1, vec + 1)
1000           || which->type->set(cs, which, nvec - 1, vec + 1));
1001 }
1002
1003 static int config_set_args(const struct config_state *cs,
1004                            const char *which, ...) {
1005   va_list ap;
1006   struct vector v[1];
1007   char *s;
1008
1009   vector_init(v);
1010   vector_append(v, (char *)which);
1011   va_start(ap, which);
1012   while((s = va_arg(ap, char *)))
1013     vector_append(v, s);
1014   va_end(ap);
1015   vector_terminate(v);
1016   return config_set(cs, v->nvec, v->vec);
1017 }
1018
1019 /** @brief Error callback used by config_include() */
1020 static void config_error(const char *msg, void *u) {
1021   const struct config_state *cs = u;
1022
1023   error(0, "%s:%d: %s", cs->path, cs->line, msg);
1024 }
1025
1026 /** @brief Include a file by name */
1027 static int config_include(struct config *c, const char *path) {
1028   FILE *fp;
1029   char *buffer, *inputbuffer, **vec;
1030   int n, ret = 0;
1031   struct config_state cs;
1032
1033   cs.path = path;
1034   cs.line = 0;
1035   cs.config = c;
1036   D(("%s: reading configuration", path));
1037   if(!(fp = fopen(path, "r"))) {
1038     error(errno, "error opening %s", path);
1039     return -1;
1040   }
1041   while(!inputline(path, fp, &inputbuffer, '\n')) {
1042     ++cs.line;
1043     if(!(buffer = mb2utf8(inputbuffer))) {
1044       error(errno, "%s:%d: cannot convert to UTF-8", cs.path, cs.line);
1045       ret = -1;
1046       xfree(inputbuffer);
1047       continue;
1048     }
1049     xfree(inputbuffer);
1050     if(!(vec = split(buffer, &n, SPLIT_COMMENTS|SPLIT_QUOTES,
1051                      config_error, &cs))) {
1052       ret = -1;
1053       xfree(buffer);
1054       continue;
1055     }
1056     if(n) {
1057       if(!strcmp(vec[0], "include")) {
1058         if(n != 2) {
1059           error(0, "%s:%d: must be 'include PATH'", cs.path, cs.line);
1060           ret = -1;
1061         } else
1062           config_include(c, vec[1]);
1063       } else
1064         ret |= config_set(&cs, n, vec);
1065     }
1066     for(n = 0; vec[n]; ++n) xfree(vec[n]);
1067     xfree(vec);
1068     xfree(buffer);
1069   }
1070   if(ferror(fp)) {
1071     error(errno, "error reading %s", path);
1072     ret = -1;
1073   }
1074   fclose(fp);
1075   return ret;
1076 }
1077
1078 static const char *const default_stopwords[] = {
1079   "stopword",
1080
1081   "01",
1082   "02",
1083   "03",
1084   "04",
1085   "05",
1086   "06",
1087   "07",
1088   "08",
1089   "09",
1090   "1",
1091   "10",
1092   "11",
1093   "12",
1094   "13",
1095   "14",
1096   "15",
1097   "16",
1098   "17",
1099   "18",
1100   "19",
1101   "2",
1102   "20",
1103   "21",
1104   "22",
1105   "23",
1106   "24",
1107   "25",
1108   "26",
1109   "27",
1110   "28",
1111   "29",
1112   "3",
1113   "30",
1114   "4",
1115   "5",
1116   "6",
1117   "7",
1118   "8",
1119   "9",
1120   "a",
1121   "am",
1122   "an",
1123   "and",
1124   "as",
1125   "for",
1126   "i",
1127   "im",
1128   "in",
1129   "is",
1130   "of",
1131   "on",
1132   "the",
1133   "to",
1134   "too",
1135   "we",
1136 };
1137 #define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
1138
1139 static const char *const default_players[] = {
1140   "*.ogg",
1141   "*.flac",
1142   "*.mp3",
1143   "*.wav",
1144 };
1145 #define NDEFAULT_PLAYERS (sizeof default_players / sizeof *default_players)
1146
1147 /** @brief Make a new default configuration */
1148 static struct config *config_default(void) {
1149   struct config *c = xmalloc(sizeof *c);
1150   const char *logname;
1151   struct passwd *pw;
1152   struct config_state cs;
1153   size_t n;
1154
1155   cs.path = "<internal>";
1156   cs.line = 0;
1157   cs.config = c;
1158   /* Strings had better be xstrdup'd as they will get freed at some point. */
1159   c->gap = 0;
1160   c->history = 60;
1161   c->home = xstrdup(pkgstatedir);
1162   if(!(pw = getpwuid(getuid())))
1163     fatal(0, "cannot determine our username");
1164   logname = pw->pw_name;
1165   c->username = xstrdup(logname);
1166   c->refresh = 15;
1167   c->prefsync = 3600;
1168   c->signal = SIGKILL;
1169   c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
1170   c->lock = 1;
1171   c->device = xstrdup("default");
1172   c->nice_rescan = 10;
1173   c->speaker_command = 0;
1174   c->sample_format.bits = 16;
1175   c->sample_format.rate = 44100;
1176   c->sample_format.channels = 2;
1177   c->sample_format.endian = ENDIAN_NATIVE;
1178   c->queue_pad = 10;
1179   c->api = -1;
1180   c->multicast_ttl = 1;
1181   c->multicast_loop = 1;
1182   c->authorization_algorithm = xstrdup("sha1");
1183   c->noticed_history = 31;
1184   c->short_display = 32;
1185   c->mixer = 0;
1186   c->channel = 0;
1187   c->dbversion = 2;
1188   c->cookie_login_lifetime = 86400;
1189   c->cookie_key_lifetime = 86400 * 7;
1190   c->smtp_server = xstrdup("127.0.0.1");
1191   /* Default stopwords */
1192   if(config_set(&cs, (int)NDEFAULT_STOPWORDS, (char **)default_stopwords))
1193     exit(1);
1194   /* Default player configuration */
1195   for(n = 0; n < NDEFAULT_PLAYERS; ++n) {
1196     if(config_set_args(&cs, "player",
1197                        default_players[n], "execraw", "disorder-decode", (char *)0))
1198       exit(1);
1199     if(config_set_args(&cs, "tracklength",
1200                        default_players[n], "disorder-tracklength", (char *)0))
1201       exit(1);
1202   }
1203   return c;
1204 }
1205
1206 static char *get_file(struct config *c, const char *name) {
1207   char *s;
1208
1209   byte_xasprintf(&s, "%s/%s", c->home, name);
1210   return s;
1211 }
1212
1213 /** @brief Set the default configuration file */
1214 static void set_configfile(void) {
1215   if(!configfile)
1216     byte_xasprintf(&configfile, "%s/config", pkgconfdir);
1217 }
1218
1219 /** @brief Free a configuration object */
1220 static void config_free(struct config *c) {
1221   int n;
1222
1223   if(c) {
1224     for(n = 0; n < (int)(sizeof conf / sizeof *conf); ++n)
1225       conf[n].type->free(c, &conf[n]);
1226     for(n = 0; n < c->nparts; ++n)
1227       xfree(c->parts[n]);
1228     xfree(c->parts);
1229     xfree(c);
1230   }
1231 }
1232
1233 /** @brief Set post-parse defaults */
1234 static void config_postdefaults(struct config *c,
1235                                 int server) {
1236   struct config_state cs;
1237   const struct conf *whoami;
1238   int n;
1239
1240   static const char *namepart[][4] = {
1241     { "title",  "/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display" },
1242     { "title",  "/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort" },
1243     { "album",  "/([^/]+)/[^/]+$",                    "$1", "*" },
1244     { "artist", "/([^/]+)/[^/]+/[^/]+$",              "$1", "*" },
1245     { "ext",    "(\\.[a-zA-Z0-9]+)$",                 "$1", "*" },
1246   };
1247 #define NNAMEPART (int)(sizeof namepart / sizeof *namepart)
1248
1249   static const char *transform[][5] = {
1250     { "track", "^.*/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display", "" },
1251     { "track", "^.*/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort", "" },
1252     { "dir",   "^.*/([^/]+)$",                          "$1", "*", "" },
1253     { "dir",   "^(the) ([^/]*)",                        "$2, $1", "sort", "i", },
1254     { "dir",   "[[:punct:]]",                           "", "sort", "g", }
1255   };
1256 #define NTRANSFORM (int)(sizeof transform / sizeof *transform)
1257
1258   cs.path = "<internal>";
1259   cs.line = 0;
1260   cs.config = c;
1261   if(!c->namepart.n) {
1262     whoami = find("namepart");
1263     for(n = 0; n < NNAMEPART; ++n)
1264       set_namepart(&cs, whoami, 4, (char **)namepart[n]);
1265   }
1266   if(!c->transform.n) {
1267     whoami = find("transform");
1268     for(n = 0; n < NTRANSFORM; ++n)
1269       set_transform(&cs, whoami, 5, (char **)transform[n]);
1270   }
1271   if(c->api == -1) {
1272     if(c->speaker_command)
1273       c->api = BACKEND_COMMAND;
1274     else if(c->broadcast.n)
1275       c->api = BACKEND_NETWORK;
1276     else {
1277 #if HAVE_ALSA_ASOUNDLIB_H
1278       c->api = BACKEND_ALSA;
1279 #elif HAVE_SYS_SOUNDCARD_H
1280       c->api = BACKEND_OSS;
1281 #elif HAVE_COREAUDIO_AUDIOHARDWARE_H
1282       c->api = BACKEND_COREAUDIO;
1283 #else
1284       c->api = BACKEND_COMMAND;
1285 #endif
1286     }
1287   }
1288   if(server) {
1289     if(c->api == BACKEND_COMMAND && !c->speaker_command)
1290       fatal(0, "'api command' but speaker_command is not set");
1291     if(c->api == BACKEND_NETWORK && !c->broadcast.n)
1292       fatal(0, "'api network' but broadcast is not set");
1293   }
1294   /* Override sample format */
1295   switch(c->api) {
1296   case BACKEND_NETWORK:
1297     c->sample_format.rate = 44100;
1298     c->sample_format.channels = 2;
1299     c->sample_format.bits = 16;
1300     c->sample_format.endian = ENDIAN_BIG;
1301     break;
1302   case BACKEND_COREAUDIO:
1303     c->sample_format.rate = 44100;
1304     c->sample_format.channels = 2;
1305     c->sample_format.bits = 16;
1306     c->sample_format.endian = ENDIAN_NATIVE;
1307     break;
1308   }
1309   if(!c->default_rights) {
1310     rights_type r = RIGHTS__MASK & ~(RIGHT_ADMIN|RIGHT_REGISTER
1311                                      |RIGHT_MOVE__MASK
1312                                      |RIGHT_SCRATCH__MASK
1313                                      |RIGHT_REMOVE__MASK);
1314     /* The idea is to approximate the meaning of the old 'restrict' directive
1315      * in the default rights if they are not overridden. */
1316     if(c->restrictions & RESTRICT_SCRATCH)
1317       r |= RIGHT_SCRATCH_MINE|RIGHT_SCRATCH_RANDOM;
1318     else
1319       r |= RIGHT_SCRATCH_ANY;
1320     if(!(c->restrictions & RESTRICT_MOVE))
1321       r |= RIGHT_MOVE_ANY;
1322     if(c->restrictions & RESTRICT_REMOVE)
1323       r |= RIGHT_REMOVE_MINE;
1324     else
1325       r |= RIGHT_REMOVE_ANY;
1326     c->default_rights = rights_string(r);
1327   }
1328 }
1329
1330 /** @brief (Re-)read the config file
1331  * @param server If set, do extra checking
1332  */
1333 int config_read(int server) {
1334   struct config *c;
1335   char *privconf;
1336   struct passwd *pw;
1337
1338   set_configfile();
1339   c = config_default();
1340   /* standalone Disobedience installs might not have a global config file */
1341   if(access(configfile, F_OK) == 0)
1342     if(config_include(c, configfile))
1343       return -1;
1344   /* if we can read the private config file, do */
1345   if((privconf = config_private())
1346      && access(privconf, R_OK) == 0
1347      && config_include(c, privconf))
1348     return -1;
1349   xfree(privconf);
1350   /* if there's a per-user system config file for this user, read it */
1351   if(config_per_user) {
1352     if(!(pw = getpwuid(getuid())))
1353       fatal(0, "cannot determine our username");
1354     if((privconf = config_usersysconf(pw))
1355        && access(privconf, F_OK) == 0
1356        && config_include(c, privconf))
1357       return -1;
1358     xfree(privconf);
1359     /* if we have a password file, read it */
1360     if((privconf = config_userconf(getenv("HOME"), pw))
1361        && access(privconf, F_OK) == 0
1362        && config_include(c, privconf))
1363       return -1;
1364     xfree(privconf);
1365   }
1366   /* install default namepart and transform settings */
1367   config_postdefaults(c, server);
1368   /* everything is good so we shall use the new config */
1369   config_free(config);
1370   /* warn about obsolete directives */
1371   if(c->restrictions)
1372     error(0, "'restrict' will be removed in a future version");
1373   if(c->allow.n)
1374     error(0, "'allow' will be removed in a future version");
1375   if(c->trust.n)
1376     error(0, "'trust' will be removed in a future version");
1377   config = c;
1378   return 0;
1379 }
1380
1381 /** @brief Return the path to the private configuration file */
1382 char *config_private(void) {
1383   char *s;
1384
1385   set_configfile();
1386   byte_xasprintf(&s, "%s.private", configfile);
1387   return s;
1388 }
1389
1390 /** @brief Return the path to user's personal configuration file */
1391 char *config_userconf(const char *home, const struct passwd *pw) {
1392   char *s;
1393
1394   if(!home && !pw && !(pw = getpwuid(getuid())))
1395     fatal(0, "cannot determine our username");
1396   byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
1397   return s;
1398 }
1399
1400 /** @brief Return the path to user-specific system configuration */
1401 char *config_usersysconf(const struct passwd *pw) {
1402   char *s;
1403
1404   set_configfile();
1405   if(!strchr(pw->pw_name, '/')) {
1406     byte_xasprintf(&s, "%s.%s", configfile, pw->pw_name);
1407     return s;
1408   } else
1409     return 0;
1410 }
1411
1412 char *config_get_file(const char *name) {
1413   return get_file(config, name);
1414 }
1415
1416 /*
1417 Local Variables:
1418 c-basic-offset:2
1419 comment-column:40
1420 fill-column:79
1421 End:
1422 */