uaudio: more sophisticated choice of default playback API

[disorder] / lib / configuration.c

diff --git a/lib/configuration.c b/lib/configuration.c
index dc3d0092b6c8216081b4e794a848cf6f15362826..e7698ec533da6af5b4b61ac099a530d25c1f05e0 100644 (file)
--- a/lib/configuration.c
+++ b/lib/configuration.c
@@ -1,6 +1,6 @@
 /*
  * This file is part of DisOrder.
 /*
  * This file is part of DisOrder.

- * Copyright (C) 2004-2009 Richard Kettlewell
+ * Copyright (C) 2004-2010 Richard Kettlewell

  * Portions copyright (C) 2007 Mark Wooding
  *
  * This program is free software: you can redistribute it and/or modify
  * Portions copyright (C) 2007 Mark Wooding
  *
  * This program is free software: you can redistribute it and/or modify


@@ -52,7 +52,7 @@
 
 /** @brief Path to config file 
  *
 
 /** @brief Path to config file 
  *

- * set_configfile() sets the deafult if it is null.
+ * set_configfile() sets the default if it is null.

  */
 char *configfile;
 
  */
 char *configfile;
 


@@ -72,8 +72,10 @@ const struct uaudio *const *config_uaudio_apis;
 struct config_state {
   /** @brief Filename */
   const char *path;
 struct config_state {
   /** @brief Filename */
   const char *path;

+

   /** @brief Line number */
   int line;
   /** @brief Line number */
   int line;

+

   /** @brief Configuration object under construction */
   struct config *config;
 };
   /** @brief Configuration object under construction */
   struct config *config;
 };


@@ -85,22 +87,42 @@ struct config *config;
 struct conf {
   /** @brief Name as it appears in the config file */
   const char *name;
 struct conf {
   /** @brief Name as it appears in the config file */
   const char *name;

+

   /** @brief Offset in @ref config structure */
   size_t offset;
   /** @brief Offset in @ref config structure */
   size_t offset;

+

   /** @brief Pointer to item type */
   const struct conftype *type;
   /** @brief Pointer to item type */
   const struct conftype *type;

-  /** @brief Pointer to item-specific validation routine */
+
+  /** @brief Pointer to item-specific validation routine
+   * @param cs Configuration state
+   * @param nvec Length of (proposed) new value
+   * @param vec Elements of new value
+   * @return 0 on success, non-0 on error
+   *
+   * The validate function should report any error it detects.
+   */

   int (*validate)(const struct config_state *cs,
                  int nvec, char **vec);
 };
 
 /** @brief Type of a configuration item */
 struct conftype {
   int (*validate)(const struct config_state *cs,
                  int nvec, char **vec);
 };
 
 /** @brief Type of a configuration item */
 struct conftype {

-  /** @brief Pointer to function to set item */
+  /** @brief Pointer to function to set item
+   * @param cs Configuration state
+   * @param whoami Configuration item to set
+   * @param nvec Length of new value
+   * @param vec New value
+   * @return 0 on success, non-0 on error
+   */

   int (*set)(const struct config_state *cs,
             const struct conf *whoami,
             int nvec, char **vec);
   int (*set)(const struct config_state *cs,
             const struct conf *whoami,
             int nvec, char **vec);

-  /** @brief Pointer to function to free item */
+
+  /** @brief Pointer to function to free item
+   * @param c Configuration structure to free an item of
+   * @param whoami Configuration item to free
+   */

   void (*free)(struct config *c, const struct conf *whoami);
 };
 
   void (*free)(struct config *c, const struct conf *whoami);
 };
 


@@ -120,12 +142,12 @@ static int set_signal(const struct config_state *cs,
   int n;
   
   if(nvec != 1) {
   int n;
   
   if(nvec != 1) {

-    error(0, "%s:%d: '%s' requires one argument",
+    disorder_error(0, "%s:%d: '%s' requires one argument",

          cs->path, cs->line, whoami->name);
     return -1;
   }
   if((n = find_signal(vec[0])) == -1) {
          cs->path, cs->line, whoami->name);
     return -1;
   }
   if((n = find_signal(vec[0])) == -1) {

-    error(0, "%s:%d: unknown signal '%s'",
+    disorder_error(0, "%s:%d: unknown signal '%s'",

          cs->path, cs->line, vec[0]);
     return -1;
   }
          cs->path, cs->line, vec[0]);
     return -1;
   }


@@ -156,23 +178,23 @@ static int set_collections(const struct config_state *cs,
     root = vec[2];
     break;
   case 0:
     root = vec[2];
     break;
   case 0:

-    error(0, "%s:%d: '%s' requires at least one argument",
-         cs->path, cs->line, whoami->name);
+    disorder_error(0, "%s:%d: '%s' requires at least one argument",
+                  cs->path, cs->line, whoami->name);

     return -1;
   default:
     return -1;
   default:

-    error(0, "%s:%d: '%s' requires at most three arguments",
-         cs->path, cs->line, whoami->name);
+    disorder_error(0, "%s:%d: '%s' requires at most three arguments",
+                  cs->path, cs->line, whoami->name);

     return -1;
   }
   /* Sanity check root */
   if(root[0] != '/') {
     return -1;
   }
   /* Sanity check root */
   if(root[0] != '/') {

-    error(0, "%s:%d: collection root must start with '/'",
-         cs->path, cs->line);
+    disorder_error(0, "%s:%d: collection root must start with '/'",
+                  cs->path, cs->line);

     return -1;
   }
   if(root[1] && root[strlen(root)-1] == '/') {
     return -1;
   }
   if(root[1] && root[strlen(root)-1] == '/') {

-    error(0, "%s:%d: collection root must not end with '/'",
-         cs->path, cs->line);
+    disorder_error(0, "%s:%d: collection root must not end with '/'",
+                  cs->path, cs->line);

     return -1;
   }
   /* Defaults */
     return -1;
   }
   /* Defaults */


@@ -195,15 +217,15 @@ static int set_boolean(const struct config_state *cs,
   int state;
   
   if(nvec != 1) {
   int state;
   
   if(nvec != 1) {

-    error(0, "%s:%d: '%s' takes only one argument",
-         cs->path, cs->line, whoami->name);
+    disorder_error(0, "%s:%d: '%s' takes only one argument",
+                  cs->path, cs->line, whoami->name);

     return -1;
   }
   if(!strcmp(vec[0], "yes")) state = 1;
   else if(!strcmp(vec[0], "no")) state = 0;
   else {
     return -1;
   }
   if(!strcmp(vec[0], "yes")) state = 1;
   else if(!strcmp(vec[0], "no")) state = 0;
   else {

-    error(0, "%s:%d: argument to '%s' must be 'yes' or 'no'",
-         cs->path, cs->line, whoami->name);
+    disorder_error(0, "%s:%d: argument to '%s' must be 'yes' or 'no'",
+                  cs->path, cs->line, whoami->name);

     return -1;
   }
   VALUE(cs->config, int) = state;
     return -1;
   }
   VALUE(cs->config, int) = state;


@@ -214,10 +236,11 @@ static int set_string(const struct config_state *cs,
                      const struct conf *whoami,
                      int nvec, char **vec) {
   if(nvec != 1) {
                      const struct conf *whoami,
                      int nvec, char **vec) {
   if(nvec != 1) {

-    error(0, "%s:%d: '%s' takes only one argument",
-         cs->path, cs->line, whoami->name);
+    disorder_error(0, "%s:%d: '%s' takes only one argument",
+                  cs->path, cs->line, whoami->name);

     return -1;
   }
     return -1;
   }

+  xfree(VALUE(cs->config, char *));

   VALUE(cs->config, char *) = xstrdup(vec[0]);
   return 0;
 }
   VALUE(cs->config, char *) = xstrdup(vec[0]);
   return 0;
 }


@@ -244,16 +267,16 @@ static int set_integer(const struct config_state *cs,
   char *e;
 
   if(nvec != 1) {
   char *e;
 
   if(nvec != 1) {

-    error(0, "%s:%d: '%s' takes only one argument",
-         cs->path, cs->line, whoami->name);
+    disorder_error(0, "%s:%d: '%s' takes only one argument",
+                  cs->path, cs->line, whoami->name);

     return -1;
   }
   if(xstrtol(ADDRESS(cs->config, long), vec[0], &e, 0)) {
     return -1;
   }
   if(xstrtol(ADDRESS(cs->config, long), vec[0], &e, 0)) {

-    error(errno, "%s:%d: converting integer", cs->path, cs->line);
+    disorder_error(errno, "%s:%d: converting integer", cs->path, cs->line);

     return -1;
   }
   if(*e) {
     return -1;
   }
   if(*e) {

-    error(0, "%s:%d: invalid integer syntax", cs->path, cs->line);
+    disorder_error(0, "%s:%d: invalid integer syntax", cs->path, cs->line);

     return -1;
   }
   return 0;
     return -1;
   }
   return 0;


@@ -300,33 +323,6 @@ static int set_string_accum(const struct config_state *cs,
   return 0;
 }
 
   return 0;
 }
 

-static int set_restrict(const struct config_state *cs,
-                       const struct conf *whoami,
-                       int nvec, char **vec) {
-  unsigned r = 0;
-  int n, i;
-  
-  static const struct restriction {
-    const char *name;
-    unsigned bit;
-  } restrictions[] = {
-    { "remove", RESTRICT_REMOVE },
-    { "scratch", RESTRICT_SCRATCH },
-    { "move", RESTRICT_MOVE },
-  };
-
-  for(n = 0; n < nvec; ++n) {
-    if((i = TABLE_FIND(restrictions, name, vec[n])) < 0) {
-      error(0, "%s:%d: invalid restriction '%s'",
-           cs->path, cs->line, vec[n]);
-      return -1;
-    }
-    r |= restrictions[i].bit;
-  }
-  VALUE(cs->config, unsigned) = r;
-  return 0;
-}
-

 static int parse_sample_format(const struct config_state *cs,
                               struct stream_header *format,
                               int nvec, char **vec) {
 static int parse_sample_format(const struct config_state *cs,
                               struct stream_header *format,
                               int nvec, char **vec) {


@@ -334,15 +330,17 @@ static int parse_sample_format(const struct config_state *cs,
   long t;
 
   if(nvec != 1) {
   long t;
 
   if(nvec != 1) {

-    error(0, "%s:%d: wrong number of arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: wrong number of arguments", cs->path, cs->line);

     return -1;
   }
   if(xstrtol(&t, p, &p, 0)) {
     return -1;
   }
   if(xstrtol(&t, p, &p, 0)) {

-    error(errno, "%s:%d: converting bits-per-sample", cs->path, cs->line);
+    disorder_error(errno, "%s:%d: converting bits-per-sample",
+                  cs->path, cs->line);

     return -1;
   }
   if(t != 8 && t != 16) {
     return -1;
   }
   if(t != 8 && t != 16) {

-    error(0, "%s:%d: bad bite-per-sample (%ld)", cs->path, cs->line, t);
+    disorder_error(0, "%s:%d: bad bits-per-sample (%ld)",
+                  cs->path, cs->line, t);

     return -1;
   }
   if(format) format->bits = t;
     return -1;
   }
   if(format) format->bits = t;


@@ -353,37 +351,38 @@ static int parse_sample_format(const struct config_state *cs,
   }
   if(format) format->endian = t;
   if(*p != '/') {
   }
   if(format) format->endian = t;
   if(*p != '/') {

-    error(errno, "%s:%d: expected `/' after bits-per-sample",
+    disorder_error(errno, "%s:%d: expected `/' after bits-per-sample",

          cs->path, cs->line);
     return -1;
   }
   p++;
   if(xstrtol(&t, p, &p, 0)) {
          cs->path, cs->line);
     return -1;
   }
   p++;
   if(xstrtol(&t, p, &p, 0)) {

-    error(errno, "%s:%d: converting sample-rate", cs->path, cs->line);
+    disorder_error(errno, "%s:%d: converting sample-rate", cs->path, cs->line);

     return -1;
   }
   if(t < 1 || t > INT_MAX) {
     return -1;
   }
   if(t < 1 || t > INT_MAX) {

-    error(0, "%s:%d: silly sample-rate (%ld)", cs->path, cs->line, t);
+    disorder_error(0, "%s:%d: silly sample-rate (%ld)", cs->path, cs->line, t);

     return -1;
   }
   if(format) format->rate = t;
   if(*p != '/') {
     return -1;
   }
   if(format) format->rate = t;
   if(*p != '/') {

-    error(0, "%s:%d: expected `/' after sample-rate",
-         cs->path, cs->line);
+    disorder_error(0, "%s:%d: expected `/' after sample-rate",
+                  cs->path, cs->line);

     return -1;
   }
   p++;
   if(xstrtol(&t, p, &p, 0)) {
     return -1;
   }
   p++;
   if(xstrtol(&t, p, &p, 0)) {

-    error(errno, "%s:%d: converting channels", cs->path, cs->line);
+    disorder_error(errno, "%s:%d: converting channels", cs->path, cs->line);

     return -1;
   }
   if(t < 1 || t > 8) {
     return -1;
   }
   if(t < 1 || t > 8) {

-    error(0, "%s:%d: silly number (%ld) of channels", cs->path, cs->line, t);
+    disorder_error(0, "%s:%d: silly number (%ld) of channels",
+                  cs->path, cs->line, t);

     return -1;
   }
   if(format) format->channels = t;
   if(*p) {
     return -1;
   }
   if(format) format->channels = t;
   if(*p) {

-    error(0, "%s:%d: junk after channels", cs->path, cs->line);
+    disorder_error(0, "%s:%d: junk after channels", cs->path, cs->line);

     return -1;
   }
   return 0;
     return -1;
   }
   return 0;


@@ -406,11 +405,13 @@ static int set_namepart(const struct config_state *cs,
   pcre *re;
 
   if(nvec < 3) {
   pcre *re;
 
   if(nvec < 3) {

-    error(0, "%s:%d: namepart needs at least 3 arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: namepart needs at least 3 arguments",
+                  cs->path, cs->line);

     return -1;
   }
   if(nvec > 5) {
     return -1;
   }
   if(nvec > 5) {

-    error(0, "%s:%d: namepart needs at most 5 arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: namepart needs at most 5 arguments",
+                  cs->path, cs->line);

     return -1;
   }
   reflags = nvec >= 5 ? regsub_flags(vec[4]) : 0;
     return -1;
   }
   reflags = nvec >= 5 ? regsub_flags(vec[4]) : 0;


@@ -418,8 +419,8 @@ static int set_namepart(const struct config_state *cs,
                         PCRE_UTF8
                         |regsub_compile_options(reflags),
                         &errstr, &erroffset, 0))) {
                         PCRE_UTF8
                         |regsub_compile_options(reflags),
                         &errstr, &erroffset, 0))) {

-    error(0, "%s:%d: error compiling regexp /%s/: %s (offset %d)",
-         cs->path, cs->line, vec[1], errstr, erroffset);
+    disorder_error(0, "%s:%d: compiling regexp /%s/: %s (offset %d)",
+                  cs->path, cs->line, vec[1], errstr, erroffset);

     return -1;
   }
   npl->s = xrealloc(npl->s, (npl->n + 1) * sizeof (struct namepart));
     return -1;
   }
   npl->s = xrealloc(npl->s, (npl->n + 1) * sizeof (struct namepart));


@@ -452,11 +453,13 @@ static int set_transform(const struct config_state *cs,
   int erroffset;
 
   if(nvec < 3) {
   int erroffset;
 
   if(nvec < 3) {

-    error(0, "%s:%d: transform needs at least 3 arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: transform needs at least 3 arguments",
+                  cs->path, cs->line);

     return -1;
   }
   if(nvec > 5) {
     return -1;
   }
   if(nvec > 5) {

-    error(0, "%s:%d: transform needs at most 5 arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: transform needs at most 5 arguments",
+                  cs->path, cs->line);

     return -1;
   }
   reflags = (nvec >= 5 ? regsub_flags(vec[4]) : 0);
     return -1;
   }
   reflags = (nvec >= 5 ? regsub_flags(vec[4]) : 0);


@@ -464,8 +467,8 @@ static int set_transform(const struct config_state *cs,
                         PCRE_UTF8
                         |regsub_compile_options(reflags),
                         &errstr, &erroffset, 0))) {
                         PCRE_UTF8
                         |regsub_compile_options(reflags),
                         &errstr, &erroffset, 0))) {

-    error(0, "%s:%d: error compiling regexp /%s/: %s (offset %d)",
-         cs->path, cs->line, vec[1], errstr, erroffset);
+    disorder_error(0, "%s:%d: compiling regexp /%s/: %s (offset %d)",
+                  cs->path, cs->line, vec[1], errstr, erroffset);

     return -1;
   }
   tl->t = xrealloc(tl->t, (tl->n + 1) * sizeof (struct namepart));
     return -1;
   }
   tl->t = xrealloc(tl->t, (tl->n + 1) * sizeof (struct namepart));


@@ -482,17 +485,16 @@ static int set_rights(const struct config_state *cs,
                      const struct conf *whoami,
                      int nvec, char **vec) {
   if(nvec != 1) {
                      const struct conf *whoami,
                      int nvec, char **vec) {
   if(nvec != 1) {

-    error(0, "%s:%d: '%s' requires one argument",
-         cs->path, cs->line, whoami->name);
+    disorder_error(0, "%s:%d: '%s' requires one argument",
+                  cs->path, cs->line, whoami->name);

     return -1;
   }
   if(parse_rights(vec[0], 0, 1)) {
     return -1;
   }
   if(parse_rights(vec[0], 0, 1)) {

-    error(0, "%s:%d: invalid rights string '%s'",
-         cs->path, cs->line, vec[0]);
+    disorder_error(0, "%s:%d: invalid rights string '%s'",
+                  cs->path, cs->line, vec[0]);

     return -1;
   }
     return -1;
   }

-  *ADDRESS(cs->config, char *) = vec[0];
-  return 0;
+  return set_string(cs, whoami, nvec, vec);

 }
 
 static int set_netaddress(const struct config_state *cs,
 }
 
 static int set_netaddress(const struct config_state *cs,


@@ -501,7 +503,7 @@ static int set_netaddress(const struct config_state *cs,
   struct netaddress *na = ADDRESS(cs->config, struct netaddress);
 
   if(netaddress_parse(na, nvec, vec)) {
   struct netaddress *na = ADDRESS(cs->config, struct netaddress);
 
   if(netaddress_parse(na, nvec, vec)) {

-    error(0, "%s:%d: invalid network address", cs->path, cs->line);
+    disorder_error(0, "%s:%d: invalid network address", cs->path, cs->line);

     return -1;
   }
   return 0;
     return -1;
   }
   return 0;


@@ -611,158 +613,221 @@ static const struct conftype
   type_stringlist_accum = { set_stringlist_accum, free_stringlistlist },
   type_string_accum = { set_string_accum, free_stringlist },
   type_sample_format = { set_sample_format, free_none },
   type_stringlist_accum = { set_stringlist_accum, free_stringlistlist },
   type_string_accum = { set_string_accum, free_stringlist },
   type_sample_format = { set_sample_format, free_none },

-  type_restrict = { set_restrict, free_none },

   type_namepart = { set_namepart, free_namepartlist },
   type_transform = { set_transform, free_transformlist },
   type_netaddress = { set_netaddress, free_netaddress },
   type_namepart = { set_namepart, free_namepartlist },
   type_transform = { set_transform, free_transformlist },
   type_netaddress = { set_netaddress, free_netaddress },

-  type_rights = { set_rights, free_none };
+  type_rights = { set_rights, free_string };

 
 /* specific validation routine */
 
 
 /* specific validation routine */
 

-#define VALIDATE_FILE(test, what) do {                         \
-  struct stat sb;                                              \
-  int n;                                                       \
-                                                               \
-  for(n = 0; n < nvec; ++n) {                                  \
-    if(stat(vec[n], &sb) < 0) {                                        \
-      error(errno, "%s:%d: %s", cs->path, cs->line, vec[n]);   \
-      return -1;                                               \
-    }                                                          \
-    if(!test(sb.st_mode)) {                                    \
-      error(0, "%s:%d: %s is not a %s",                                \
-           cs->path, cs->line, vec[n], what);                  \
-      return -1;                                               \
-    }                                                          \
-  }                                                            \
+/** @brief Perform a test on a filename
+ * @param test Test function to call on mode bits
+ * @param what Type of file sought
+ *
+ * If @p test returns 0 then the file is not a @p what and an error
+ * is reported and -1 is returned.
+ */
+#define VALIDATE_FILE(test, what) do {                 \
+  struct stat sb;                                      \
+  int n;                                               \
+                                                       \
+  for(n = 0; n < nvec; ++n) {                          \
+    if(stat(vec[n], &sb) < 0) {                                \
+      disorder_error(errno, "%s:%d: %s",               \
+                     cs->path, cs->line, vec[n]);      \
+      return -1;                                       \
+    }                                                  \
+    if(!test(sb.st_mode)) {                            \
+      disorder_error(0, "%s:%d: %s is not a %s",       \
+                    cs->path, cs->line, vec[n], what); \
+      return -1;                                       \
+    }                                                  \
+  }                                                    \

 } while(0)
 
 } while(0)
 

+/** @brief Validate an absolute path
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_isabspath(const struct config_state *cs,
                              int nvec, char **vec) {
   int n;
 
   for(n = 0; n < nvec; ++n)
     if(vec[n][0] != '/') {
 static int validate_isabspath(const struct config_state *cs,
                              int nvec, char **vec) {
   int n;
 
   for(n = 0; n < nvec; ++n)
     if(vec[n][0] != '/') {

-      error(errno, "%s:%d: %s: not an absolute path", 
-           cs->path, cs->line, vec[n]);
+      disorder_error(errno, "%s:%d: %s: not an absolute path", 
+                    cs->path, cs->line, vec[n]);

       return -1;
     }
   return 0;
 }
 
       return -1;
     }
   return 0;
 }
 

+/** @brief Validate an existing directory
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_isdir(const struct config_state *cs,
                          int nvec, char **vec) {
   VALIDATE_FILE(S_ISDIR, "directory");
   return 0;
 }
 
 static int validate_isdir(const struct config_state *cs,
                          int nvec, char **vec) {
   VALIDATE_FILE(S_ISDIR, "directory");
   return 0;
 }
 

+/** @brief Validate an existing regular file
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_isreg(const struct config_state *cs,
                          int nvec, char **vec) {
   VALIDATE_FILE(S_ISREG, "regular file");
   return 0;
 }
 
 static int validate_isreg(const struct config_state *cs,
                          int nvec, char **vec) {
   VALIDATE_FILE(S_ISREG, "regular file");
   return 0;
 }
 

+/** @brief Validate a player pattern
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_player(const struct config_state *cs,
                           int nvec,
                           char attribute((unused)) **vec) {
 static int validate_player(const struct config_state *cs,
                           int nvec,
                           char attribute((unused)) **vec) {

-  if(nvec < 2) {
-    error(0, "%s:%d: should be at least 'player PATTERN MODULE'",
-         cs->path, cs->line);
+  if(nvec && nvec < 2) {
+    disorder_error(0, "%s:%d: should be at least 'player PATTERN MODULE'",
+                  cs->path, cs->line);

     return -1;
   }
   return 0;
 }
 
     return -1;
   }
   return 0;
 }
 

+/** @brief Validate a track length pattern
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_tracklength(const struct config_state *cs,
                                int nvec,
                                char attribute((unused)) **vec) {
 static int validate_tracklength(const struct config_state *cs,
                                int nvec,
                                char attribute((unused)) **vec) {

-  if(nvec < 2) {
-    error(0, "%s:%d: should be at least 'tracklength PATTERN MODULE'",
-         cs->path, cs->line);
-    return -1;
-  }
-  return 0;
-}
-
-static int validate_allow(const struct config_state *cs,
-                         int nvec,
-                         char attribute((unused)) **vec) {
-  if(nvec != 2) {
-    error(0, "%s:%d: must be 'allow NAME PASS'", cs->path, cs->line);
+  if(nvec && nvec < 2) {
+    disorder_error(0, "%s:%d: should be at least 'tracklength PATTERN MODULE'",
+                  cs->path, cs->line);

     return -1;
   }
   return 0;
 }
 
     return -1;
   }
   return 0;
 }
 

+/** @brief Validate a non-negative (@c long) integer
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_non_negative(const struct config_state *cs,
                                 int nvec, char **vec) {
   long n;
 
   if(nvec < 1) {
 static int validate_non_negative(const struct config_state *cs,
                                 int nvec, char **vec) {
   long n;
 
   if(nvec < 1) {

-    error(0, "%s:%d: missing argument", cs->path, cs->line);
+    disorder_error(0, "%s:%d: missing argument", cs->path, cs->line);

     return -1;
   }
   if(nvec > 1) {
     return -1;
   }
   if(nvec > 1) {

-    error(0, "%s:%d: too many arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: too many arguments", cs->path, cs->line);

     return -1;
   }
   if(xstrtol(&n, vec[0], 0, 0)) {
     return -1;
   }
   if(xstrtol(&n, vec[0], 0, 0)) {

-    error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
+    disorder_error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));

     return -1;
   }
   if(n < 0) {
     return -1;
   }
   if(n < 0) {

-    error(0, "%s:%d: must not be negative", cs->path, cs->line);
+    disorder_error(0, "%s:%d: must not be negative", cs->path, cs->line);

     return -1;
   }
   return 0;
 }
 
     return -1;
   }
   return 0;
 }
 

+/** @brief Validate a positive (@c long) integer
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_positive(const struct config_state *cs,
                          int nvec, char **vec) {
   long n;
 
   if(nvec < 1) {
 static int validate_positive(const struct config_state *cs,
                          int nvec, char **vec) {
   long n;
 
   if(nvec < 1) {

-    error(0, "%s:%d: missing argument", cs->path, cs->line);
+    disorder_error(0, "%s:%d: missing argument", cs->path, cs->line);

     return -1;
   }
   if(nvec > 1) {
     return -1;
   }
   if(nvec > 1) {

-    error(0, "%s:%d: too many arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: too many arguments", cs->path, cs->line);

     return -1;
   }
   if(xstrtol(&n, vec[0], 0, 0)) {
     return -1;
   }
   if(xstrtol(&n, vec[0], 0, 0)) {

-    error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
+    disorder_error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));

     return -1;
   }
   if(n <= 0) {
     return -1;
   }
   if(n <= 0) {

-    error(0, "%s:%d: must be positive", cs->path, cs->line);
+    disorder_error(0, "%s:%d: must be positive", cs->path, cs->line);

     return -1;
   }
   return 0;
 }
 
     return -1;
   }
   return 0;
 }
 

+/** @brief Validate a system username
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_isauser(const struct config_state *cs,
                            int attribute((unused)) nvec,
                            char **vec) {
 static int validate_isauser(const struct config_state *cs,
                            int attribute((unused)) nvec,
                            char **vec) {

-  struct passwd *pw;
-
-  if(!(pw = getpwnam(vec[0]))) {
-    error(0, "%s:%d: no such user as '%s'", cs->path, cs->line, vec[0]);
+  if(!getpwnam(vec[0])) {
+    disorder_error(0, "%s:%d: no such user as '%s'", cs->path, cs->line, vec[0]);

     return -1;
   }
   return 0;
 }
 
     return -1;
   }
   return 0;
 }
 

+/** @brief Validate a sample format string
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_sample_format(const struct config_state *cs,
                                  int attribute((unused)) nvec,
                                  char **vec) {
   return parse_sample_format(cs, 0, nvec, vec);
 }
 
 static int validate_sample_format(const struct config_state *cs,
                                  int attribute((unused)) nvec,
                                  char **vec) {
   return parse_sample_format(cs, 0, nvec, vec);
 }
 

+/** @brief Validate anything
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0
+ */

 static int validate_any(const struct config_state attribute((unused)) *cs,
                        int attribute((unused)) nvec,
                        char attribute((unused)) **vec) {
   return 0;
 }
 
 static int validate_any(const struct config_state attribute((unused)) *cs,
                        int attribute((unused)) nvec,
                        char attribute((unused)) **vec) {
   return 0;
 }
 

+/** @brief Validate a URL
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ *
+ * Rather cursory.
+ */

 static int validate_url(const struct config_state attribute((unused)) *cs,
                        int attribute((unused)) nvec,
                        char **vec) {
 static int validate_url(const struct config_state attribute((unused)) *cs,
                        int attribute((unused)) nvec,
                        char **vec) {


@@ -775,7 +840,7 @@ static int validate_url(const struct config_state attribute((unused)) *cs,
                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                 "0123456789"));
   if(s[n] != ':') {
                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                 "0123456789"));
   if(s[n] != ':') {

-    error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
+    disorder_error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);

     return -1;
   }
   if(!strncmp(s, "http:", 5)
     return -1;
   }
   if(!strncmp(s, "http:", 5)


@@ -783,13 +848,19 @@ static int validate_url(const struct config_state attribute((unused)) *cs,
     s += n + 1;
     /* we only do a rather cursory check */
     if(strncmp(s, "//", 2)) {
     s += n + 1;
     /* we only do a rather cursory check */
     if(strncmp(s, "//", 2)) {

-      error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
+      disorder_error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);

       return -1;
     }
   }
   return 0;
 }
 
       return -1;
     }
   }
   return 0;
 }
 

+/** @brief Validate an alias pattern
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_alias(const struct config_state *cs,
                          int nvec,
                          char **vec) {
 static int validate_alias(const struct config_state *cs,
                          int nvec,
                          char **vec) {


@@ -797,11 +868,11 @@ static int validate_alias(const struct config_state *cs,
   int in_brackets = 0, c;
 
   if(nvec < 1) {
   int in_brackets = 0, c;
 
   if(nvec < 1) {

-    error(0, "%s:%d: missing argument", cs->path, cs->line);
+    disorder_error(0, "%s:%d: missing argument", cs->path, cs->line);

     return -1;
   }
   if(nvec > 1) {
     return -1;
   }
   if(nvec > 1) {

-    error(0, "%s:%d: too many arguments", cs->path, cs->line);
+    disorder_error(0, "%s:%d: too many arguments", cs->path, cs->line);

     return -1;
   }
   s = vec[0];
     return -1;
   }
   s = vec[0];


@@ -810,8 +881,8 @@ static int validate_alias(const struct config_state *cs,
       if(c == '}')
        in_brackets = 0;
       else if(!isalnum(c)) {
       if(c == '}')
        in_brackets = 0;
       else if(!isalnum(c)) {

-       error(0, "%s:%d: invalid part name in alias expansion in '%s'",
-             cs->path, cs->line, vec[0]);
+       disorder_error(0, "%s:%d: invalid part name in alias expansion in '%s'",
+                      cs->path, cs->line, vec[0]);

          return -1;
       }
     } else {
          return -1;
       }
     } else {


@@ -821,12 +892,12 @@ static int validate_alias(const struct config_state *cs,
          ++s;
       } else if(c == '\\') {
        if(!(c = (unsigned char)*s++)) {
          ++s;
       } else if(c == '\\') {
        if(!(c = (unsigned char)*s++)) {

-         error(0, "%s:%d: unterminated escape in alias expansion in '%s'",
-               cs->path, cs->line, vec[0]);
+         disorder_error(0, "%s:%d: unterminated escape in alias expansion in '%s'",
+                        cs->path, cs->line, vec[0]);

          return -1;
        } else if(c != '\\' && c != '{') {
          return -1;
        } else if(c != '\\' && c != '{') {

-         error(0, "%s:%d: invalid escape in alias expansion in '%s'",
-               cs->path, cs->line, vec[0]);
+         disorder_error(0, "%s:%d: invalid escape in alias expansion in '%s'",
+                        cs->path, cs->line, vec[0]);

          return -1;
        }
       }
          return -1;
        }
       }


@@ -834,72 +905,101 @@ static int validate_alias(const struct config_state *cs,
     ++s;
   }
   if(in_brackets) {
     ++s;
   }
   if(in_brackets) {

-    error(0, "%s:%d: unterminated part name in alias expansion in '%s'",
-         cs->path, cs->line, vec[0]);
+    disorder_error(0,
+                  "%s:%d: unterminated part name in alias expansion in '%s'",
+                  cs->path, cs->line, vec[0]);

     return -1;
   }
   return 0;
 }
 
     return -1;
   }
   return 0;
 }
 

+/** @brief Validate a hash algorithm name
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_algo(const struct config_state attribute((unused)) *cs,
                         int nvec,
                         char **vec) {
   if(nvec != 1) {
 static int validate_algo(const struct config_state attribute((unused)) *cs,
                         int nvec,
                         char **vec) {
   if(nvec != 1) {

-    error(0, "%s:%d: invalid algorithm specification", cs->path, cs->line);
+    disorder_error(0, "%s:%d: invalid algorithm specification", cs->path, cs->line);

     return -1;
   }
   if(!valid_authhash(vec[0])) {
     return -1;
   }
   if(!valid_authhash(vec[0])) {

-    error(0, "%s:%d: unsuported algorithm '%s'", cs->path, cs->line, vec[0]);
+    disorder_error(0, "%s:%d: unsuported algorithm '%s'", cs->path, cs->line, vec[0]);

     return -1;
   }
   return 0;
 }
 
     return -1;
   }
   return 0;
 }
 

+/** @brief Validate a playback backend name
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_backend(const struct config_state attribute((unused)) *cs,
                             int nvec,
                             char **vec) {
   int n;
   if(nvec != 1) {
 static int validate_backend(const struct config_state attribute((unused)) *cs,
                             int nvec,
                             char **vec) {
   int n;
   if(nvec != 1) {

-    error(0, "%s:%d: invalid sound API specification", cs->path, cs->line);
+    disorder_error(0, "%s:%d: invalid sound API specification", cs->path, cs->line);

     return -1;
   }
   if(!strcmp(vec[0], "network")) {
     return -1;
   }
   if(!strcmp(vec[0], "network")) {

-    error(0, "'api network' is deprecated; use 'api rtp'");
+    disorder_error(0, "'api network' is deprecated; use 'api rtp'");

     return 0;
   }
   if(config_uaudio_apis) {
     for(n = 0; config_uaudio_apis[n]; ++n)
       if(!strcmp(vec[0], config_uaudio_apis[n]->name))
         return 0;
     return 0;
   }
   if(config_uaudio_apis) {
     for(n = 0; config_uaudio_apis[n]; ++n)
       if(!strcmp(vec[0], config_uaudio_apis[n]->name))
         return 0;

-    error(0, "%s:%d: unrecognized sound API '%s'", cs->path, cs->line, vec[0]);
+    disorder_error(0, "%s:%d: unrecognized sound API '%s'", cs->path, cs->line, vec[0]);

     return -1;
   }
   /* In non-server processes we have no idea what's valid */
   return 0;
 }
 
     return -1;
   }
   /* In non-server processes we have no idea what's valid */
   return 0;
 }
 

+/** @brief Validate a pause mode string
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */

 static int validate_pausemode(const struct config_state attribute((unused)) *cs,
                               int nvec,
                               char **vec) {
   if(nvec == 1 && (!strcmp(vec[0], "silence") || !strcmp(vec[0], "suspend")))
     return 0;
 static int validate_pausemode(const struct config_state attribute((unused)) *cs,
                               int nvec,
                               char **vec) {
   if(nvec == 1 && (!strcmp(vec[0], "silence") || !strcmp(vec[0], "suspend")))
     return 0;

-  error(0, "%s:%d: invalid pause mode", cs->path, cs->line);
+  disorder_error(0, "%s:%d: invalid pause mode", cs->path, cs->line);

   return -1;
 }
 
   return -1;
 }
 

+/** @brief Validate a destination network address
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ *
+ * By a destination address, it is meant that it must not be a wildcard
+ * address.
+ */

 static int validate_destaddr(const struct config_state attribute((unused)) *cs,
                             int nvec,
                             char **vec) {
   struct netaddress na[1];
 
   if(netaddress_parse(na, nvec, vec)) {
 static int validate_destaddr(const struct config_state attribute((unused)) *cs,
                             int nvec,
                             char **vec) {
   struct netaddress na[1];
 
   if(netaddress_parse(na, nvec, vec)) {

-    error(0, "%s:%d: invalid network address", cs->path, cs->line);
+    disorder_error(0, "%s:%d: invalid network address", cs->path, cs->line);

     return -1;
   }
   if(!na->address) {
     return -1;
   }
   if(!na->address) {

-    error(0, "%s:%d: destination address required", cs->path, cs->line);
+    disorder_error(0, "%s:%d: destination address required", cs->path, cs->line);

     return -1;
   }
     return -1;
   }

+  xfree(na->address);

   return 0;
 }
 
   return 0;
 }
 


@@ -911,7 +1011,6 @@ static int validate_destaddr(const struct config_state attribute((unused)) *cs,
 /** @brief All configuration items */
 static const struct conf conf[] = {
   { C(alias),            &type_string,           validate_alias },
 /** @brief All configuration items */
 static const struct conf conf[] = {
   { C(alias),            &type_string,           validate_alias },

-  { C(allow),            &type_stringlist_accum, validate_allow },

   { C(api),              &type_string,           validate_backend },
   { C(authorization_algorithm), &type_string,    validate_algo },
   { C(broadcast),        &type_netaddress,       validate_destaddr },
   { C(api),              &type_string,           validate_backend },
   { C(authorization_algorithm), &type_string,    validate_algo },
   { C(broadcast),        &type_netaddress,       validate_destaddr },


@@ -921,18 +1020,17 @@ static const struct conf conf[] = {
   { C(checkpoint_min),   &type_integer,          validate_non_negative },
   { C(collection),       &type_collections,      validate_any },
   { C(connect),          &type_netaddress,       validate_destaddr },
   { C(checkpoint_min),   &type_integer,          validate_non_negative },
   { C(collection),       &type_collections,      validate_any },
   { C(connect),          &type_netaddress,       validate_destaddr },

-  { C(cookie_login_lifetime),  &type_integer,    validate_positive },

   { C(cookie_key_lifetime),  &type_integer,      validate_positive },
   { C(cookie_key_lifetime),  &type_integer,      validate_positive },

+  { C(cookie_login_lifetime),  &type_integer,    validate_positive },

   { C(dbversion),        &type_integer,          validate_positive },
   { C(default_rights),   &type_rights,           validate_any },
   { C(device),           &type_string,           validate_any },
   { C(dbversion),        &type_integer,          validate_positive },
   { C(default_rights),   &type_rights,           validate_any },
   { C(device),           &type_string,           validate_any },

-  { C(gap),              &type_integer,          validate_non_negative },

   { C(history),          &type_integer,          validate_positive },
   { C(home),             &type_string,           validate_isabspath },
   { C(listen),           &type_netaddress,       validate_any },
   { C(history),          &type_integer,          validate_positive },
   { C(home),             &type_string,           validate_isabspath },
   { C(listen),           &type_netaddress,       validate_any },

-  { C(lock),             &type_boolean,          validate_any },

   { C(mail_sender),      &type_string,           validate_any },
   { C(mixer),            &type_string,           validate_any },
   { C(mail_sender),      &type_string,           validate_any },
   { C(mixer),            &type_string,           validate_any },

+  { C(mount_rescan),     &type_boolean,          validate_any },

   { C(multicast_loop),   &type_boolean,          validate_any },
   { C(multicast_ttl),    &type_integer,          validate_non_negative },
   { C(namepart),         &type_namepart,         validate_any },
   { C(multicast_loop),   &type_boolean,          validate_any },
   { C(multicast_ttl),    &type_integer,          validate_non_negative },
   { C(namepart),         &type_namepart,         validate_any },


@@ -947,15 +1045,17 @@ static const struct conf conf[] = {
   { C(password),         &type_string,           validate_any },
   { C(pause_mode),       &type_string,           validate_pausemode },
   { C(player),           &type_stringlist_accum, validate_player },
   { C(password),         &type_string,           validate_any },
   { C(pause_mode),       &type_string,           validate_pausemode },
   { C(player),           &type_stringlist_accum, validate_player },

+  { C(playlist_lock_timeout), &type_integer,     validate_positive },
+  { C(playlist_max) ,    &type_integer,          validate_positive },

   { C(plugins),          &type_string_accum,     validate_isdir },
   { C(plugins),          &type_string_accum,     validate_isdir },

-  { C(prefsync),         &type_integer,          validate_positive },

   { C(queue_pad),        &type_integer,          validate_positive },
   { C(queue_pad),        &type_integer,          validate_positive },

-  { C(replay_min),       &type_integer,          validate_non_negative },

   { C(refresh),          &type_integer,          validate_positive },
   { C(refresh),          &type_integer,          validate_positive },

+  { C(refresh_min),      &type_integer,          validate_non_negative },

   { C(reminder_interval), &type_integer,         validate_positive },
   { C(remote_userman),   &type_boolean,          validate_any },
   { C(reminder_interval), &type_integer,         validate_positive },
   { C(remote_userman),   &type_boolean,          validate_any },

-  { C2(restrict, restrictions),         &type_restrict,         validate_any },
+  { C(replay_min),       &type_integer,          validate_non_negative },

   { C(rtp_delay_threshold), &type_integer,       validate_positive },
   { C(rtp_delay_threshold), &type_integer,       validate_positive },

+  { C(rtp_verbose),      &type_boolean,          validate_any },

   { C(sample_format),    &type_sample_format,    validate_sample_format },
   { C(scratch),          &type_string_accum,     validate_isreg },
   { C(sendmail),         &type_string,           validate_isabspath },
   { C(sample_format),    &type_sample_format,    validate_sample_format },
   { C(scratch),          &type_string_accum,     validate_isreg },
   { C(sendmail),         &type_string,           validate_isabspath },


@@ -969,7 +1069,6 @@ static const struct conf conf[] = {
   { C(templates),        &type_string_accum,     validate_isdir },
   { C(tracklength),      &type_stringlist_accum, validate_tracklength },
   { C(transform),        &type_transform,        validate_any },
   { C(templates),        &type_string_accum,     validate_isdir },
   { C(tracklength),      &type_stringlist_accum, validate_tracklength },
   { C(transform),        &type_transform,        validate_any },

-  { C(trust),            &type_string_accum,     validate_any },

   { C(url),              &type_string,           validate_url },
   { C(user),             &type_string,           validate_isauser },
   { C(username),         &type_string,           validate_any },
   { C(url),              &type_string,           validate_url },
   { C(user),             &type_string,           validate_isauser },
   { C(username),         &type_string,           validate_any },


@@ -984,14 +1083,21 @@ static const struct conf *find(const char *key) {
   return &conf[n];
 }
 
   return &conf[n];
 }
 

-/** @brief Set a new configuration value */
+/** @brief Set a new configuration value
+ * @param cs Configuration state
+ * @param nvec Length of @p vec
+ * @param vec Name and new value
+ * @return 0 on success, non-0 on error.
+ *
+ * @c vec[0] is the name, the rest is the value.
+ */

 static int config_set(const struct config_state *cs,
                      int nvec, char **vec) {
   const struct conf *which;
 
   D(("config_set %s", vec[0]));
   if(!(which = find(vec[0]))) {
 static int config_set(const struct config_state *cs,
                      int nvec, char **vec) {
   const struct conf *which;
 
   D(("config_set %s", vec[0]));
   if(!(which = find(vec[0]))) {

-    error(0, "%s:%d: unknown configuration key '%s'",
+    disorder_error(0, "%s:%d: unknown configuration key '%s'",

          cs->path, cs->line, vec[0]);
     return -1;
   }
          cs->path, cs->line, vec[0]);
     return -1;
   }


@@ -999,6 +1105,12 @@ static int config_set(const struct config_state *cs,
          || which->type->set(cs, which, nvec - 1, vec + 1));
 }
 
          || which->type->set(cs, which, nvec - 1, vec + 1));
 }
 

+/** @brief Set a configuration item from parameters
+ * @param cs Configuration state
+ * @param which Item to set
+ * @param ... Value as strings, terminated by (char *)NULL
+ * @return 0 on success, non-0 on error
+ */

 static int config_set_args(const struct config_state *cs,
                           const char *which, ...) {
   va_list ap;
 static int config_set_args(const struct config_state *cs,
                           const char *which, ...) {
   va_list ap;


@@ -1012,17 +1124,26 @@ static int config_set_args(const struct config_state *cs,
     vector_append(v, s);
   va_end(ap);
   vector_terminate(v);
     vector_append(v, s);
   va_end(ap);
   vector_terminate(v);

-  return config_set(cs, v->nvec, v->vec);
+  int rc = config_set(cs, v->nvec, v->vec);
+  xfree(v->vec);
+  return rc;

 }
 
 }
 

-/** @brief Error callback used by config_include() */
+/** @brief Error callback used by config_include()
+ * @param msg Error message
+ * @param u User data (@ref config_state)
+ */

 static void config_error(const char *msg, void *u) {
   const struct config_state *cs = u;
 
 static void config_error(const char *msg, void *u) {
   const struct config_state *cs = u;
 

-  error(0, "%s:%d: %s", cs->path, cs->line, msg);
+  disorder_error(0, "%s:%d: %s", cs->path, cs->line, msg);

 }
 
 }
 

-/** @brief Include a file by name */
+/** @brief Include a file by name
+ * @param c Configuration to update
+ * @param path Path to read
+ * @return 0 on success, non-0 on error
+ */

 static int config_include(struct config *c, const char *path) {
   FILE *fp;
   char *buffer, *inputbuffer, **vec;
 static int config_include(struct config *c, const char *path) {
   FILE *fp;
   char *buffer, *inputbuffer, **vec;


@@ -1034,13 +1155,13 @@ static int config_include(struct config *c, const char *path) {
   cs.config = c;
   D(("%s: reading configuration", path));
   if(!(fp = fopen(path, "r"))) {
   cs.config = c;
   D(("%s: reading configuration", path));
   if(!(fp = fopen(path, "r"))) {

-    error(errno, "error opening %s", path);
+    disorder_error(errno, "error opening %s", path);

     return -1;
   }
   while(!inputline(path, fp, &inputbuffer, '\n')) {
     ++cs.line;
     if(!(buffer = mb2utf8(inputbuffer))) {
     return -1;
   }
   while(!inputline(path, fp, &inputbuffer, '\n')) {
     ++cs.line;
     if(!(buffer = mb2utf8(inputbuffer))) {

-      error(errno, "%s:%d: cannot convert to UTF-8", cs.path, cs.line);
+      disorder_error(errno, "%s:%d: cannot convert to UTF-8", cs.path, cs.line);

       ret = -1;
       xfree(inputbuffer);
       continue;
       ret = -1;
       xfree(inputbuffer);
       continue;


@@ -1053,9 +1174,10 @@ static int config_include(struct config *c, const char *path) {
       continue;
     }
     if(n) {
       continue;
     }
     if(n) {

+      /* 'include' is special-cased */

       if(!strcmp(vec[0], "include")) {
        if(n != 2) {
       if(!strcmp(vec[0], "include")) {
        if(n != 2) {

-         error(0, "%s:%d: must be 'include PATH'", cs.path, cs.line);
+         disorder_error(0, "%s:%d: must be 'include PATH'", cs.path, cs.line);

          ret = -1;
        } else
          config_include(c, vec[1]);
          ret = -1;
        } else
          config_include(c, vec[1]);


@@ -1067,13 +1189,14 @@ static int config_include(struct config *c, const char *path) {
     xfree(buffer);
   }
   if(ferror(fp)) {
     xfree(buffer);
   }
   if(ferror(fp)) {

-    error(errno, "error reading %s", path);
+    disorder_error(errno, "error reading %s", path);

     ret = -1;
   }
   fclose(fp);
   return ret;
 }
 
     ret = -1;
   }
   fclose(fp);
   return ret;
 }
 

+/** @brief Default stopword setting */

 static const char *const default_stopwords[] = {
   "stopword",
 
 static const char *const default_stopwords[] = {
   "stopword",
 


@@ -1135,6 +1258,7 @@ static const char *const default_stopwords[] = {
 };
 #define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
 
 };
 #define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
 

+/** @brief Default player patterns */

 static const char *const default_players[] = {
   "*.ogg",
   "*.flac",
 static const char *const default_players[] = {
   "*.ogg",
   "*.flac",


@@ -1143,7 +1267,9 @@ static const char *const default_players[] = {
 };
 #define NDEFAULT_PLAYERS (sizeof default_players / sizeof *default_players)
 
 };
 #define NDEFAULT_PLAYERS (sizeof default_players / sizeof *default_players)
 

-/** @brief Make a new default configuration */
+/** @brief Make a new default configuration
+ * @return New configuration
+ */

 static struct config *config_default(void) {
   struct config *c = xmalloc(sizeof *c);
   const char *logname;
 static struct config *config_default(void) {
   struct config *c = xmalloc(sizeof *c);
   const char *logname;


@@ -1155,18 +1281,16 @@ static struct config *config_default(void) {
   cs.line = 0;
   cs.config = c;
   /* Strings had better be xstrdup'd as they will get freed at some point. */
   cs.line = 0;
   cs.config = c;
   /* Strings had better be xstrdup'd as they will get freed at some point. */

-  c->gap = 0;

   c->history = 60;
   c->home = xstrdup(pkgstatedir);
   if(!(pw = getpwuid(getuid())))
   c->history = 60;
   c->home = xstrdup(pkgstatedir);
   if(!(pw = getpwuid(getuid())))

-    fatal(0, "cannot determine our username");
+    disorder_fatal(0, "cannot determine our username");

   logname = pw->pw_name;
   c->username = xstrdup(logname);
   c->refresh = 15;
   logname = pw->pw_name;
   c->username = xstrdup(logname);
   c->refresh = 15;

-  c->prefsync = 0;
+  c->refresh_min = 1;

   c->signal = SIGKILL;
   c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
   c->signal = SIGKILL;
   c->alias = xstrdup("{/artist}{/album}{/title}{ext}");

-  c->lock = 1;

   c->device = xstrdup("default");
   c->nice_rescan = 10;
   c->speaker_command = 0;
   c->device = xstrdup("default");
   c->nice_rescan = 10;
   c->speaker_command = 0;


@@ -1195,6 +1319,9 @@ static struct config *config_default(void) {
   c->new_bias_age = 7 * 86400;         /* 1 week */
   c->new_bias = 4500000;               /* 50 times the base weight */
   c->sox_generation = DEFAULT_SOX_GENERATION;
   c->new_bias_age = 7 * 86400;         /* 1 week */
   c->new_bias = 4500000;               /* 50 times the base weight */
   c->sox_generation = DEFAULT_SOX_GENERATION;

+  c->playlist_max = INT_MAX;            /* effectively no limit */
+  c->playlist_lock_timeout = 10;        /* 10s */
+  c->mount_rescan = 1;

   /* Default stopwords */
   if(config_set(&cs, (int)NDEFAULT_STOPWORDS, (char **)default_stopwords))
     exit(1);
   /* Default stopwords */
   if(config_set(&cs, (int)NDEFAULT_STOPWORDS, (char **)default_stopwords))
     exit(1);


@@ -1214,6 +1341,13 @@ static struct config *config_default(void) {
   return c;
 }
 
   return c;
 }
 

+/** @brief Construct a filename
+ * @param c Configuration
+ * @param name Base filename
+ * @return Full filename
+ *
+ * Usually use config_get_file() instead.
+ */

 char *config_get_file2(struct config *c, const char *name) {
   char *s;
 
 char *config_get_file2(struct config *c, const char *name) {
   char *s;
 


@@ -1227,8 +1361,12 @@ static void set_configfile(void) {
     byte_xasprintf(&configfile, "%s/config", pkgconfdir);
 }
 
     byte_xasprintf(&configfile, "%s/config", pkgconfdir);
 }
 

-/** @brief Free a configuration object */
-static void config_free(struct config *c) {
+/** @brief Free a configuration object
+ * @param c Configuration to free
+ *
+ * @p c is indeterminate after this function is called.
+ */
+void config_free(struct config *c) {

   int n;
 
   if(c) {
   int n;
 
   if(c) {


@@ -1241,7 +1379,13 @@ static void config_free(struct config *c) {
   }
 }
 
   }
 }
 

-/** @brief Set post-parse defaults */
+/** @brief Set post-parse defaults
+ * @param c Configuration to update
+ * @param server True when running in the server
+ *
+ * If @p server is set then certain parts of the configuration are more
+ * strictly validated.
+ */

 static void config_postdefaults(struct config *c,
                                int server) {
   struct config_state cs;
 static void config_postdefaults(struct config *c,
                                int server) {
   struct config_state cs;


@@ -1285,7 +1429,8 @@ static void config_postdefaults(struct config *c,
     else if(c->broadcast.af != -1)
       c->api = xstrdup("rtp");
     else if(config_uaudio_apis)
     else if(c->broadcast.af != -1)
       c->api = xstrdup("rtp");
     else if(config_uaudio_apis)

-      c->api = xstrdup(config_uaudio_apis[0]->name);
+      c->api = xstrdup(uaudio_default(config_uaudio_apis,
+                                      UAUDIO_API_SERVER)->name);

     else
       c->api = xstrdup("<none>");
   }
     else
       c->api = xstrdup("<none>");
   }


@@ -1293,9 +1438,9 @@ static void config_postdefaults(struct config *c,
     c->api = xstrdup("rtp");
   if(server) {
     if(!strcmp(c->api, "command") && !c->speaker_command)
     c->api = xstrdup("rtp");
   if(server) {
     if(!strcmp(c->api, "command") && !c->speaker_command)

-      fatal(0, "'api command' but speaker_command is not set");
+      disorder_fatal(0, "'api command' but speaker_command is not set");

     if((!strcmp(c->api, "rtp")) && c->broadcast.af == -1)
     if((!strcmp(c->api, "rtp")) && c->broadcast.af == -1)

-      fatal(0, "'api rtp' but broadcast is not set");
+      disorder_fatal(0, "'api rtp' but broadcast is not set");

   }
   /* Override sample format */
   if(!strcmp(c->api, "rtp")) {
   }
   /* Override sample format */
   if(!strcmp(c->api, "rtp")) {


@@ -1315,18 +1460,7 @@ static void config_postdefaults(struct config *c,
                                     |RIGHT_MOVE__MASK
                                     |RIGHT_SCRATCH__MASK
                                     |RIGHT_REMOVE__MASK);
                                     |RIGHT_MOVE__MASK
                                     |RIGHT_SCRATCH__MASK
                                     |RIGHT_REMOVE__MASK);

-    /* The idea is to approximate the meaning of the old 'restrict' directive
-     * in the default rights if they are not overridden. */
-    if(c->restrictions & RESTRICT_SCRATCH)
-      r |= RIGHT_SCRATCH_MINE|RIGHT_SCRATCH_RANDOM;
-    else
-      r |= RIGHT_SCRATCH_ANY;
-    if(!(c->restrictions & RESTRICT_MOVE))
-      r |= RIGHT_MOVE_ANY;
-    if(c->restrictions & RESTRICT_REMOVE)
-      r |= RIGHT_REMOVE_MINE;
-    else
-      r |= RIGHT_REMOVE_ANY;
+    r |= RIGHT_SCRATCH_ANY|RIGHT_MOVE_ANY|RIGHT_REMOVE_ANY;

     c->default_rights = rights_string(r);
   }
 }
     c->default_rights = rights_string(r);
   }
 }


@@ -1360,7 +1494,7 @@ int config_read(int server,
   /* if there's a per-user system config file for this user, read it */
   if(config_per_user) {
     if(!(pw = getpwuid(getuid())))
   /* if there's a per-user system config file for this user, read it */
   if(config_per_user) {
     if(!(pw = getpwuid(getuid())))

-      fatal(0, "cannot determine our username");
+      disorder_fatal(0, "cannot determine our username");

     if((privconf = config_usersysconf(pw))
        && access(privconf, F_OK) == 0
        && config_include(c, privconf))
     if((privconf = config_usersysconf(pw))
        && access(privconf, F_OK) == 0
        && config_include(c, privconf))


@@ -1378,53 +1512,41 @@ int config_read(int server,
   if(oldconfig)  {
     int failed = 0;
     if(strcmp(c->home, oldconfig->home)) {
   if(oldconfig)  {
     int failed = 0;
     if(strcmp(c->home, oldconfig->home)) {

-      error(0, "'home' cannot be changed without a restart");
+      disorder_error(0, "'home' cannot be changed without a restart");

       failed = 1;
     }
     if(strcmp(c->alias, oldconfig->alias)) {
       failed = 1;
     }
     if(strcmp(c->alias, oldconfig->alias)) {

-      error(0, "'alias' cannot be changed without a restart");
+      disorder_error(0, "'alias' cannot be changed without a restart");

       failed = 1;
     }
     if(strcmp(c->user, oldconfig->user)) {
       failed = 1;
     }
     if(strcmp(c->user, oldconfig->user)) {

-      error(0, "'user' cannot be changed without a restart");
+      disorder_error(0, "'user' cannot be changed without a restart");

       failed = 1;
     }
     if(c->nice_speaker != oldconfig->nice_speaker) {
       failed = 1;
     }
     if(c->nice_speaker != oldconfig->nice_speaker) {

-      error(0, "'nice_speaker' cannot be changed without a restart");
+      disorder_error(0, "'nice_speaker' cannot be changed without a restart");

       /* ...but we accept the new config anyway */
     }
     if(c->nice_server != oldconfig->nice_server) {
       /* ...but we accept the new config anyway */
     }
     if(c->nice_server != oldconfig->nice_server) {

-      error(0, "'nice_server' cannot be changed without a restart");
+      disorder_error(0, "'nice_server' cannot be changed without a restart");

       /* ...but we accept the new config anyway */
     }
     if(namepartlist_compare(&c->namepart, &oldconfig->namepart)) {
       /* ...but we accept the new config anyway */
     }
     if(namepartlist_compare(&c->namepart, &oldconfig->namepart)) {

-      error(0, "'namepart' settings cannot be changed without a restart");
+      disorder_error(0, "'namepart' settings cannot be changed without a restart");

       failed = 1;
     }
     if(stringlist_compare(&c->stopword, &oldconfig->stopword)) {
       failed = 1;
     }
     if(stringlist_compare(&c->stopword, &oldconfig->stopword)) {

-      error(0, "'stopword' settings cannot be changed without a restart");
+      disorder_error(0, "'stopword' settings cannot be changed without a restart");

       failed = 1;
     }
     if(failed) {
       failed = 1;
     }
     if(failed) {

-      error(0, "not installing incompatible new configuration");
+      disorder_error(0, "not installing incompatible new configuration");

       return -1;
     }
   }
   /* everything is good so we shall use the new config */
   config_free(config);
   /* warn about obsolete directives */
       return -1;
     }
   }
   /* everything is good so we shall use the new config */
   config_free(config);
   /* warn about obsolete directives */

-  if(c->restrictions)
-    error(0, "'restrict' will be removed in a future version");
-  if(c->allow.n)
-    error(0, "'allow' will be removed in a future version");
-  if(c->trust.n)
-    error(0, "'trust' will be removed in a future version");
-  if(!c->lock)
-    error(0, "'lock' will be removed in a future version");
-  if(c->gap)
-    error(0, "'gap' will be removed in a future version");
-  if(c->prefsync)
-    error(0, "'prefsync' will be removed in a future version");

   config = c;
   return 0;
 }
   config = c;
   return 0;
 }


@@ -1443,7 +1565,7 @@ char *config_userconf(const char *home, const struct passwd *pw) {
   char *s;
 
   if(!home && !pw && !(pw = getpwuid(getuid())))
   char *s;
 
   if(!home && !pw && !(pw = getpwuid(getuid())))

-    fatal(0, "cannot determine our username");
+    disorder_fatal(0, "cannot determine our username");

   byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
   return s;
 }
   byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
   return s;
 }


@@ -1460,10 +1582,19 @@ char *config_usersysconf(const struct passwd *pw) {
     return 0;
 }
 
     return 0;
 }
 

+/** @brief Get a filename within the home directory
+ * @param name Relative name
+ * @return Full path
+ */

 char *config_get_file(const char *name) {
   return config_get_file2(config, name);
 }
 
 char *config_get_file(const char *name) {
   return config_get_file2(config, name);
 }
 

+/** @brief Order two stringlists
+ * @param a First stringlist
+ * @param b Second stringlist
+ * @return <0, 0 or >0 if a<b, a=b or a>b
+ */

 static int stringlist_compare(const struct stringlist *a,
                               const struct stringlist *b) {
   int n = 0, c;
 static int stringlist_compare(const struct stringlist *a,
                               const struct stringlist *b) {
   int n = 0, c;


@@ -1481,6 +1612,11 @@ static int stringlist_compare(const struct stringlist *a,
     return 0;
 }
 
     return 0;
 }
 

+/** @brief Order two namepart definitions
+ * @param a First namepart definition
+ * @param b Second namepart definition
+ * @return <0, 0 or >0 if a<b, a=b or a>b
+ */

 static int namepart_compare(const struct namepart *a,
                             const struct namepart *b) {
   int c;
 static int namepart_compare(const struct namepart *a,
                             const struct namepart *b) {
   int c;


@@ -1500,6 +1636,11 @@ static int namepart_compare(const struct namepart *a,
   return 0;
 }
 
   return 0;
 }
 

+/** @brief Order two lists of namepart definitions
+ * @param a First list of namepart definitions
+ * @param b Second list of namepart definitions
+ * @return <0, 0 or >0 if a<b, a=b or a>b
+ */

 static int namepartlist_compare(const struct namepartlist *a,
                                 const struct namepartlist *b) {
   int n = 0, c;
 static int namepartlist_compare(const struct namepartlist *a,
                                 const struct namepartlist *b) {
   int n = 0, c;


@@ -1517,6 +1658,19 @@ static int namepartlist_compare(const struct namepartlist *a,
     return 0;
 }
 
     return 0;
 }
 

+/** @brief Verify configuration table.
+ * @return The number of problems found
+*/
+int config_verify(void) {
+  int fails = 0;
+  for(size_t n = 1; n < sizeof conf / sizeof *conf; ++n)
+    if(strcmp(conf[n-1].name, conf[n].name) >= 0) {
+      fprintf(stderr, "%s >= %s\n", conf[n-1].name, conf[n].name);
+      ++fails;
+    }
+  return fails;
+}
+

 /*
 Local Variables:
 c-basic-offset:2
 /*
 Local Variables:
 c-basic-offset:2