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

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