X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/67895023d60fc492720d2f575045ed0173948947..006827074fe1dc0b85de76982e1b9bf5cda07e34:/lib/configuration.c

diff --git a/lib/configuration.c b/lib/configuration.c
index 8f04e7d..e1cb830 100644
--- a/lib/configuration.c
+++ b/lib/configuration.c
@@ -72,8 +72,10 @@ const struct uaudio *const *config_uaudio_apis;
 struct config_state {
   /** @brief Filename */
   const char *path;
+
   /** @brief Line number */
   int line;
+
   /** @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;
+
   /** @brief Offset in @ref config structure */
   size_t offset;
+
   /** @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 {
-  /** @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);
-  /** @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);
 };
 
@@ -109,6 +131,11 @@ struct conftype {
 /** @brief Return the value of an item */
 #define VALUE(C, TYPE) (*ADDRESS(C, TYPE))
 
+static int stringlist_compare(const struct stringlist *a,
+                              const struct stringlist *b);
+static int namepartlist_compare(const struct namepartlist *a,
+                                const struct namepartlist *b);
+
 static int set_signal(const struct config_state *cs,
 		      const struct conf *whoami,
 		      int nvec, char **vec) {
@@ -420,6 +447,7 @@ static int set_namepart(const struct config_state *cs,
   npl->s = xrealloc(npl->s, (npl->n + 1) * sizeof (struct namepart));
   npl->s[npl->n].part = xstrdup(vec[0]);
   npl->s[npl->n].re = re;
+  npl->s[npl->n].res = xstrdup(vec[1]);
   npl->s[npl->n].replace = xstrdup(vec[2]);
   npl->s[npl->n].context = xstrdup(vec[3]);
   npl->s[npl->n].reflags = reflags;
@@ -489,6 +517,18 @@ static int set_rights(const struct config_state *cs,
   return 0;
 }
 
+static int set_netaddress(const struct config_state *cs,
+			  const struct conf *whoami,
+			  int nvec, char **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);
+    return -1;
+  }
+  return 0;
+}
+
 /* free functions */
 
 static void free_none(struct config attribute((unused)) *c,
@@ -498,6 +538,7 @@ static void free_none(struct config attribute((unused)) *c,
 static void free_string(struct config *c,
 			const struct conf *whoami) {
   xfree(VALUE(c, char *));
+  VALUE(c, char *) = 0;
 }
 
 static void free_stringlist(struct config *c,
@@ -550,6 +591,7 @@ static void free_namepartlist(struct config *c,
     np = &npl->s[n];
     xfree(np->part);
     pcre_free(np->re);			/* ...whatever pcre_free is set to. */
+    xfree(np->res);
     xfree(np->replace);
     xfree(np->context);
   }
@@ -572,6 +614,13 @@ static void free_transformlist(struct config *c,
   xfree(tl->t);
 }
 
+static void free_netaddress(struct config *c,
+			    const struct conf *whoami) {
+  struct netaddress *na = ADDRESS(c, struct netaddress);
+
+  xfree(na->address);
+}
+
 /* configuration types */
 
 static const struct conftype
@@ -587,10 +636,18 @@ static const struct conftype
   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_rights = { set_rights, free_none };
 
 /* specific validation routine */
 
+/** @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;							\
@@ -608,6 +665,12 @@ static const struct conftype
   }								\
 } 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;
@@ -621,18 +684,36 @@ static int validate_isabspath(const struct config_state *cs,
   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;
 }
 
+/** @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;
 }
 
+/** @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) {
@@ -644,6 +725,12 @@ static int validate_player(const struct config_state *cs,
   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) {
@@ -655,6 +742,14 @@ static int validate_tracklength(const struct config_state *cs,
   return 0;
 }
 
+/** @brief Validate an allow directive
+ * @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
+ *
+ * Obsolete - only used for parsing legacy configuration.
+ */
 static int validate_allow(const struct config_state *cs,
 			  int nvec,
 			  char attribute((unused)) **vec) {
@@ -665,6 +760,12 @@ static int validate_allow(const struct config_state *cs,
   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;
@@ -688,6 +789,12 @@ static int validate_non_negative(const struct config_state *cs,
   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;
@@ -711,6 +818,12 @@ static int validate_positive(const struct config_state *cs,
   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) {
@@ -723,18 +836,38 @@ static int validate_isauser(const struct config_state *cs,
   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);
 }
 
+/** @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;
 }
 
+/** @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) {
@@ -762,6 +895,12 @@ static int validate_url(const struct config_state attribute((unused)) *cs,
   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) {
@@ -813,45 +952,12 @@ static int validate_alias(const struct config_state *cs,
   return 0;
 }
 
-static int validate_addrport(const struct config_state attribute((unused)) *cs,
-			     int nvec,
-			     char attribute((unused)) **vec) {
-  switch(nvec) {
-  case 0:
-    error(0, "%s:%d: missing address",
-	  cs->path, cs->line);
-    return -1;
-  case 1:
-    error(0, "%s:%d: missing port name/number",
-	  cs->path, cs->line);
-    return -1;
-  case 2:
-    return 0;
-  default:
-    error(0, "%s:%d: expected ADDRESS PORT",
-	  cs->path, cs->line);
-    return -1;
-  }
-}
-
-static int validate_port(const struct config_state attribute((unused)) *cs,
-			 int nvec,
-			 char attribute((unused)) **vec) {
-  switch(nvec) {
-  case 0:
-    error(0, "%s:%d: missing address",
-	  cs->path, cs->line);
-    return -1;
-  case 1:
-  case 2:
-    return 0;
-  default:
-    error(0, "%s:%d: expected [ADDRESS] PORT",
-	  cs->path, cs->line);
-    return -1;
-  }
-}
-
+/** @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) {
@@ -866,6 +972,12 @@ static int validate_algo(const struct config_state attribute((unused)) *cs,
   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) {
@@ -889,6 +1001,46 @@ static int validate_backend(const struct config_state attribute((unused)) *cs,
   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;
+  error(0, "%s:%d: invalid pause mode", cs->path, cs->line);
+  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)) {
+    error(0, "%s:%d: invalid network address", cs->path, cs->line);
+    return -1;
+  }
+  if(!na->address) {
+    error(0, "%s:%d: destination address required", cs->path, cs->line);
+    return -1;
+  }
+  return 0;
+}
+
 /** @brief Item name and and offset */
 #define C(x) #x, offsetof(struct config, x)
 /** @brief Item name and and offset */
@@ -900,13 +1052,13 @@ static const struct conf conf[] = {
   { C(allow),            &type_stringlist_accum, validate_allow },
   { C(api),              &type_string,           validate_backend },
   { C(authorization_algorithm), &type_string,    validate_algo },
-  { C(broadcast),        &type_stringlist,       validate_addrport },
-  { C(broadcast_from),   &type_stringlist,       validate_addrport },
+  { C(broadcast),        &type_netaddress,       validate_destaddr },
+  { C(broadcast_from),   &type_netaddress,       validate_any },
   { C(channel),          &type_string,           validate_any },
   { C(checkpoint_kbyte), &type_integer,          validate_non_negative },
   { C(checkpoint_min),   &type_integer,          validate_non_negative },
   { C(collection),       &type_collections,      validate_any },
-  { C(connect),          &type_stringlist,       validate_addrport },
+  { C(connect),          &type_netaddress,       validate_destaddr },
   { C(cookie_login_lifetime),  &type_integer,    validate_positive },
   { C(cookie_key_lifetime),  &type_integer,      validate_positive },
   { C(dbversion),        &type_integer,          validate_positive },
@@ -915,7 +1067,7 @@ static const struct conf conf[] = {
   { C(gap),              &type_integer,          validate_non_negative },
   { C(history),          &type_integer,          validate_positive },
   { C(home),             &type_string,           validate_isabspath },
-  { C(listen),           &type_stringlist,       validate_port },
+  { 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 },
@@ -931,7 +1083,10 @@ static const struct conf conf[] = {
   { C(nice_speaker),     &type_integer,          validate_any },
   { C(noticed_history),  &type_integer,          validate_positive },
   { 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(prefsync),         &type_integer,          validate_positive },
   { C(queue_pad),        &type_integer,          validate_positive },
@@ -969,7 +1124,14 @@ static const struct conf *find(const char *key) {
   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;
@@ -984,6 +1146,12 @@ static int config_set(const struct config_state *cs,
 	  || 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;
@@ -1000,14 +1168,21 @@ static int config_set_args(const struct config_state *cs,
   return config_set(cs, v->nvec, v->vec);
 }
 
-/** @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;
 
   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;
@@ -1038,6 +1213,7 @@ static int config_include(struct config *c, const char *path) {
       continue;
     }
     if(n) {
+      /* 'include' is special-cased */
       if(!strcmp(vec[0], "include")) {
 	if(n != 2) {
 	  error(0, "%s:%d: must be 'include PATH'", cs.path, cs.line);
@@ -1059,6 +1235,7 @@ static int config_include(struct config *c, const char *path) {
   return ret;
 }
 
+/** @brief Default stopword setting */
 static const char *const default_stopwords[] = {
   "stopword",
 
@@ -1120,6 +1297,7 @@ static const char *const default_stopwords[] = {
 };
 #define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
 
+/** @brief Default player patterns */
 static const char *const default_players[] = {
   "*.ogg",
   "*.flac",
@@ -1128,7 +1306,9 @@ static const char *const 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;
@@ -1148,7 +1328,7 @@ static struct config *config_default(void) {
   logname = pw->pw_name;
   c->username = xstrdup(logname);
   c->refresh = 15;
-  c->prefsync = 3600;
+  c->prefsync = 0;
   c->signal = SIGKILL;
   c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
   c->lock = 1;
@@ -1180,6 +1360,8 @@ 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->playlist_max = INT_MAX;            /* effectively no limit */
+  c->playlist_lock_timeout = 10;        /* 10s */
   /* Default stopwords */
   if(config_set(&cs, (int)NDEFAULT_STOPWORDS, (char **)default_stopwords))
     exit(1);
@@ -1192,9 +1374,20 @@ static struct config *config_default(void) {
 		       default_players[n], "disorder-tracklength", (char *)0))
       exit(1);
   }
+  c->broadcast.af = -1;
+  c->broadcast_from.af = -1;
+  c->listen.af = -1;
+  c->connect.af = -1;
   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;
 
@@ -1208,7 +1401,11 @@ static void set_configfile(void) {
     byte_xasprintf(&configfile, "%s/config", pkgconfdir);
 }
 
-/** @brief Free a configuration object */
+/** @brief Free a configuration object
+ * @param c Configuration to free
+ *
+ * @p c is indeterminate after this function is called.
+ */
 static void config_free(struct config *c) {
   int n;
 
@@ -1222,7 +1419,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;
@@ -1263,7 +1466,7 @@ static void config_postdefaults(struct config *c,
   if(!c->api) {
     if(c->speaker_command)
       c->api = xstrdup("command");
-    else if(c->broadcast.n)
+    else if(c->broadcast.af != -1)
       c->api = xstrdup("rtp");
     else if(config_uaudio_apis)
       c->api = xstrdup(config_uaudio_apis[0]->name);
@@ -1275,7 +1478,7 @@ static void config_postdefaults(struct config *c,
   if(server) {
     if(!strcmp(c->api, "command") && !c->speaker_command)
       fatal(0, "'api command' but speaker_command is not set");
-    if((!strcmp(c->api, "rtp")) && !c->broadcast.n)
+    if((!strcmp(c->api, "rtp")) && c->broadcast.af == -1)
       fatal(0, "'api rtp' but broadcast is not set");
   }
   /* Override sample format */
@@ -1314,8 +1517,14 @@ static void config_postdefaults(struct config *c,
 
 /** @brief (Re-)read the config file
  * @param server If set, do extra checking
+ * @param oldconfig Old configuration for compatibility check
+ * @return 0 on success, non-0 on error
+ *
+ * If @p oldconfig is set, then certain compatibility checks are done between
+ * the old and new configurations.
  */
-int config_read(int server) {
+int config_read(int server,
+                const struct config *oldconfig) {
   struct config *c;
   char *privconf;
   struct passwd *pw;
@@ -1350,6 +1559,41 @@ int config_read(int server) {
   }
   /* install default namepart and transform settings */
   config_postdefaults(c, server);
+  if(oldconfig)  {
+    int failed = 0;
+    if(strcmp(c->home, oldconfig->home)) {
+      error(0, "'home' cannot be changed without a restart");
+      failed = 1;
+    }
+    if(strcmp(c->alias, oldconfig->alias)) {
+      error(0, "'alias' cannot be changed without a restart");
+      failed = 1;
+    }
+    if(strcmp(c->user, oldconfig->user)) {
+      error(0, "'user' cannot be changed without a restart");
+      failed = 1;
+    }
+    if(c->nice_speaker != oldconfig->nice_speaker) {
+      error(0, "'nice_speaker' cannot be changed without a restart");
+      /* ...but we accept the new config anyway */
+    }
+    if(c->nice_server != oldconfig->nice_server) {
+      error(0, "'nice_server' cannot be changed without a restart");
+      /* ...but we accept the new config anyway */
+    }
+    if(namepartlist_compare(&c->namepart, &oldconfig->namepart)) {
+      error(0, "'namepart' settings cannot be changed without a restart");
+      failed = 1;
+    }
+    if(stringlist_compare(&c->stopword, &oldconfig->stopword)) {
+      error(0, "'stopword' settings cannot be changed without a restart");
+      failed = 1;
+    }
+    if(failed) {
+      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 */
@@ -1359,6 +1603,12 @@ int config_read(int server) {
     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;
 }
@@ -1394,10 +1644,82 @@ char *config_usersysconf(const struct passwd *pw) {
     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);
 }
 
+/** @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;
+
+  while(n < a->n && n < b->n) {
+    if((c = strcmp(a->s[n], b->s[n])))
+      return c;
+    ++n;
+  }
+  if(a->n < b->n)
+    return -1;
+  else if(a->n > b->n)
+    return 1;
+  else
+    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;
+
+  if((c = strcmp(a->part, b->part)))
+    return c;
+  if((c = strcmp(a->res, b->res)))
+    return c;
+  if((c = strcmp(a->replace, b->replace)))
+    return c;
+  if((c = strcmp(a->context, b->context)))
+    return c;
+  if(a->reflags > b->reflags)
+    return 1;
+  if(a->reflags < b->reflags)
+    return -1;
+  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;
+
+  while(n < a->n && n < b->n) {
+    if((c = namepart_compare(&a->s[n], &b->s[n])))
+      return c;
+    ++n;
+  }
+  if(a->n > b->n)
+    return 1;
+  else if(a->n < b->n)
+    return -1;
+  else
+    return 0;
+}
+
 /*
 Local Variables:
 c-basic-offset:2