chiark / gitweb /
word break now comes from the table
[disorder] / lib / configuration.c
index 164f374..35ed090 100644 (file)
@@ -1,6 +1,6 @@
 /*
  * This file is part of DisOrder.
 /*
  * This file is part of DisOrder.
- * Copyright (C) 2004, 2005, 2006 Richard Kettlewell
+ * Copyright (C) 2004, 2005, 2006, 2007 Richard Kettlewell
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,6 +17,9 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  * USA
  */
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  * USA
  */
+/** @file lib/configuration.c
+ * @brief Configuration file support
+ */
 
 #include <config.h>
 #include "types.h"
 
 #include <config.h>
 #include "types.h"
 #include "printf.h"
 #include "regsub.h"
 #include "signame.h"
 #include "printf.h"
 #include "regsub.h"
 #include "signame.h"
+#include "authhash.h"
 
 
+/** @brief Path to config file 
+ *
+ * set_configfile() sets the deafult if it is null.
+ */
 char *configfile;
 
 char *configfile;
 
+/** @brief Config file parser state */
 struct config_state {
 struct config_state {
+  /** @brief Filename */
   const char *path;
   const char *path;
+  /** @brief Line number */
   int line;
   int line;
+  /** @brief Configuration object under construction */
   struct config *config;
 };
 
   struct config *config;
 };
 
+/** @brief Current configuration */
 struct config *config;
 
 struct config *config;
 
+/** @brief One configuration item */
 struct conf {
 struct conf {
+  /** @brief Name as it appears in the config file */
   const char *name;
   const char *name;
+  /** @brief Offset in @ref config structure */
   size_t offset;
   size_t offset;
+  /** @brief Pointer to item type */
   const struct conftype *type;
   const struct conftype *type;
+  /** @brief Pointer to item-specific validation routine */
   int (*validate)(const struct config_state *cs,
                  int nvec, char **vec);
 };
 
   int (*validate)(const struct config_state *cs,
                  int nvec, char **vec);
 };
 
+/** @brief Type of a configuration item */
 struct conftype {
 struct conftype {
+  /** @brief Pointer to function to set item */
   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 */
   void (*free)(struct config *c, const struct conf *whoami);
 };
 
   void (*free)(struct config *c, const struct conf *whoami);
 };
 
+/** @brief Compute the address of an item */
 #define ADDRESS(C, TYPE) ((TYPE *)((char *)(C) + whoami->offset))
 #define ADDRESS(C, TYPE) ((TYPE *)((char *)(C) + whoami->offset))
+/** @brief Return the value of an item */
 #define VALUE(C, TYPE) (*ADDRESS(C, TYPE))
 
 static int set_signal(const struct config_state *cs,
 #define VALUE(C, TYPE) (*ADDRESS(C, TYPE))
 
 static int set_signal(const struct config_state *cs,
@@ -255,6 +278,75 @@ static int set_restrict(const struct config_state *cs,
   return 0;
 }
 
   return 0;
 }
 
+static int parse_sample_format(const struct config_state *cs,
+                              struct stream_header *format,
+                              int nvec, char **vec) {
+  char *p = vec[0];
+  long t;
+
+  if(nvec != 1) {
+    error(0, "%s:%d: wrong number of arguments", cs->path, cs->line);
+    return -1;
+  }
+  if(xstrtol(&t, p, &p, 0)) {
+    error(errno, "%s:%d: converting bits-per-sample", cs->path, cs->line);
+    return -1;
+  }
+  if(t != 8 && t != 16) {
+    error(0, "%s:%d: bad bite-per-sample (%ld)", cs->path, cs->line, t);
+    return -1;
+  }
+  if(format) format->bits = t;
+  switch (*p) {
+    case 'l': case 'L': t = ENDIAN_LITTLE; p++; break;
+    case 'b': case 'B': t = ENDIAN_BIG; p++; break;
+    default: t = ENDIAN_NATIVE; break;
+  }
+  if(format) format->endian = t;
+  if(*p != '/') {
+    error(errno, "%s:%d: expected `/' after bits-per-sample",
+         cs->path, cs->line);
+    return -1;
+  }
+  p++;
+  if(xstrtol(&t, p, &p, 0)) {
+    error(errno, "%s:%d: converting sample-rate", cs->path, cs->line);
+    return -1;
+  }
+  if(t < 1 || t > INT_MAX) {
+    error(0, "%s:%d: silly sample-rate (%ld)", cs->path, cs->line, t);
+    return -1;
+  }
+  if(format) format->rate = t;
+  if(*p != '/') {
+    error(0, "%s:%d: expected `/' after sample-rate",
+         cs->path, cs->line);
+    return -1;
+  }
+  p++;
+  if(xstrtol(&t, p, &p, 0)) {
+    error(errno, "%s:%d: converting channels", cs->path, cs->line);
+    return -1;
+  }
+  if(t < 1 || t > 8) {
+    error(0, "%s:%d: silly number (%ld) of channels", cs->path, cs->line, t);
+    return -1;
+  }
+  if(format) format->channels = t;
+  if(*p) {
+    error(0, "%s:%d: junk after channels", cs->path, cs->line);
+    return -1;
+  }
+  return 0;
+}
+
+static int set_sample_format(const struct config_state *cs,
+                            const struct conf *whoami,
+                            int nvec, char **vec) {
+  return parse_sample_format(cs, ADDRESS(cs->config, struct stream_header),
+                            nvec, vec);
+}
+
 static int set_namepart(const struct config_state *cs,
                        const struct conf *whoami,
                        int nvec, char **vec) {
 static int set_namepart(const struct config_state *cs,
                        const struct conf *whoami,
                        int nvec, char **vec) {
@@ -336,6 +428,52 @@ static int set_transform(const struct config_state *cs,
   return 0;
 }
 
   return 0;
 }
 
+static int set_backend(const struct config_state *cs,
+                      const struct conf *whoami,
+                      int nvec, char **vec) {
+  int *const valuep = ADDRESS(cs->config, int);
+  
+  if(nvec != 1) {
+    error(0, "%s:%d: '%s' requires one argument",
+         cs->path, cs->line, whoami->name);
+    return -1;
+  }
+  if(!strcmp(vec[0], "alsa")) {
+#if HAVE_ALSA_ASOUNDLIB_H
+    *valuep = BACKEND_ALSA;
+#else
+    error(0, "%s:%d: ALSA is not available on this platform",
+         cs->path, cs->line);
+    return -1;
+#endif
+  } else if(!strcmp(vec[0], "command"))
+    *valuep = BACKEND_COMMAND;
+  else if(!strcmp(vec[0], "network"))
+    *valuep = BACKEND_NETWORK;
+  else if(!strcmp(vec[0], "coreaudio")) {
+#if HAVE_COREAUDIO_AUDIOHARDWARE_H
+    *valuep = BACKEND_COREAUDIO;
+#else
+    error(0, "%s:%d: Core Audio is not available on this platform",
+         cs->path, cs->line);
+    return -1;
+#endif
+  } else if(!strcmp(vec[0], "oss")) {
+#if HAVE_SYS_SOUNDCARD_H
+    *valuep = BACKEND_OSS;
+#else
+    error(0, "%s:%d: OSS is not available on this platform",
+         cs->path, cs->line);
+    return -1;
+#endif
+  } else {
+    error(0, "%s:%d: invalid '%s' value '%s'",
+         cs->path, cs->line, whoami->name, vec[0]);
+    return -1;
+  }
+  return 0;
+}
+
 /* free functions */
 
 static void free_none(struct config attribute((unused)) *c,
 /* free functions */
 
 static void free_none(struct config attribute((unused)) *c,
@@ -430,9 +568,11 @@ static const struct conftype
   type_integer = { set_integer, free_none },
   type_stringlist_accum = { set_stringlist_accum, free_stringlistlist },
   type_string_accum = { set_string_accum, free_stringlist },
   type_integer = { set_integer, 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_restrict = { set_restrict, free_none },
   type_namepart = { set_namepart, free_namepartlist },
-  type_transform = { set_transform, free_transformlist };
+  type_transform = { set_transform, free_transformlist },
+  type_backend = { set_backend, free_none };
 
 /* specific validation routine */
 
 
 /* specific validation routine */
 
@@ -453,6 +593,19 @@ static const struct conftype
   }                                                            \
 } while(0)
 
   }                                                            \
 } while(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]);
+      return -1;
+    }
+  return 0;
+}
+
 static int validate_isdir(const struct config_state *cs,
                          int nvec, char **vec) {
   VALIDATE_FILE(S_ISDIR, "directory");
 static int validate_isdir(const struct config_state *cs,
                          int nvec, char **vec) {
   VALIDATE_FILE(S_ISDIR, "directory");
@@ -482,6 +635,17 @@ static int validate_player(const struct config_state *cs,
   return 0;
 }
 
   return 0;
 }
 
+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) {
 static int validate_allow(const struct config_state *cs,
                          int nvec,
                          char attribute((unused)) **vec) {
@@ -550,6 +714,12 @@ static int validate_isauser(const struct config_state *cs,
   return 0;
 }
 
   return 0;
 }
 
+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_channel(const struct config_state *cs,
                            int attribute((unused)) nvec,
                            char **vec) {
 static int validate_channel(const struct config_state *cs,
                            int attribute((unused)) nvec,
                            char **vec) {
@@ -644,41 +814,107 @@ static int validate_alias(const struct config_state *cs,
   return 0;
 }
 
   return 0;
 }
 
-/* configuration table */
+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;
+  }
+}
+
+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);
+    return -1;
+  }
+  if(!valid_authhash(vec[0])) {
+    error(0, "%s:%d: unsuported algorithm '%s'", cs->path, cs->line, vec[0]);
+    return -1;
+  }
+  return 0;
+}
+
+/** @brief Item name and and offset */
 #define C(x) #x, offsetof(struct config, x)
 #define C(x) #x, offsetof(struct config, x)
+/** @brief Item name and and offset */
 #define C2(x,y) #x, offsetof(struct config, y)
 
 #define C2(x,y) #x, offsetof(struct config, y)
 
+/** @brief All configuration items */
 static const struct conf conf[] = {
   { C(alias),            &type_string,           validate_alias },
   { C(allow),            &type_stringlist_accum, validate_allow },
 static const struct conf conf[] = {
   { C(alias),            &type_string,           validate_alias },
   { C(allow),            &type_stringlist_accum, validate_allow },
+  { C(authorization_algorithm), &type_string,    validate_algo },
+  { C(broadcast),        &type_stringlist,       validate_addrport },
+  { C(broadcast_from),   &type_stringlist,       validate_addrport },
   { C(channel),          &type_string,           validate_channel },
   { C(checkpoint_kbyte), &type_integer,          validate_non_negative },
   { C(checkpoint_min),   &type_integer,          validate_non_negative },
   { C(collection),       &type_collections,      validate_any },
   { C(channel),          &type_string,           validate_channel },
   { 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_any },
+  { C(connect),          &type_stringlist,       validate_addrport },
   { C(device),           &type_string,           validate_any },
   { C(gap),              &type_integer,          validate_non_negative },
   { C(history),          &type_integer,          validate_positive },
   { C(device),           &type_string,           validate_any },
   { C(gap),              &type_integer,          validate_non_negative },
   { C(history),          &type_integer,          validate_positive },
-  { C(home),             &type_string,           validate_isdir },
-  { C(listen),           &type_stringlist,       validate_any },
+  { C(home),             &type_string,           validate_isabspath },
+  { C(listen),           &type_stringlist,       validate_port },
   { C(lock),             &type_boolean,          validate_any },
   { C(mixer),            &type_string,           validate_ischr },
   { C(lock),             &type_boolean,          validate_any },
   { C(mixer),            &type_string,           validate_ischr },
+  { C(multicast_ttl),    &type_integer,          validate_non_negative },
   { C(namepart),         &type_namepart,         validate_any },
   { C2(nice, nice_rescan), &type_integer,        validate_non_negative },
   { C(nice_rescan),      &type_integer,          validate_non_negative },
   { C(nice_server),      &type_integer,          validate_any },
   { C(nice_speaker),     &type_integer,          validate_any },
   { C(namepart),         &type_namepart,         validate_any },
   { C2(nice, nice_rescan), &type_integer,        validate_non_negative },
   { C(nice_rescan),      &type_integer,          validate_non_negative },
   { C(nice_server),      &type_integer,          validate_any },
   { C(nice_speaker),     &type_integer,          validate_any },
+  { C(noticed_history),  &type_integer,          validate_positive },
   { C(password),         &type_string,           validate_any },
   { C(player),           &type_stringlist_accum, validate_player },
   { C(plugins),          &type_string_accum,     validate_isdir },
   { C(prefsync),         &type_integer,          validate_positive },
   { C(password),         &type_string,           validate_any },
   { C(player),           &type_stringlist_accum, validate_player },
   { C(plugins),          &type_string_accum,     validate_isdir },
   { C(prefsync),         &type_integer,          validate_positive },
+  { C(queue_pad),        &type_integer,          validate_positive },
   { C(refresh),          &type_integer,          validate_positive },
   { C2(restrict, restrictions),         &type_restrict,         validate_any },
   { C(refresh),          &type_integer,          validate_positive },
   { C2(restrict, restrictions),         &type_restrict,         validate_any },
+  { C(sample_format),    &type_sample_format,    validate_sample_format },
   { C(scratch),          &type_string_accum,     validate_isreg },
   { C(scratch),          &type_string_accum,     validate_isreg },
+  { C(short_display),    &type_integer,          validate_positive },
   { C(signal),           &type_signal,           validate_any },
   { C(signal),           &type_signal,           validate_any },
+  { C(sox_generation),   &type_integer,          validate_non_negative },
+  { C(speaker_backend),  &type_backend,          validate_any },
+  { C(speaker_command),  &type_string,           validate_any },
   { C(stopword),         &type_string_accum,     validate_any },
   { C(templates),        &type_string_accum,     validate_isdir },
   { C(stopword),         &type_string_accum,     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(transform),        &type_transform,        validate_any },
   { C(trust),            &type_string_accum,     validate_any },
   { C(url),              &type_string,           validate_url },
@@ -686,7 +922,7 @@ static const struct conf conf[] = {
   { C(username),         &type_string,           validate_any },
 };
 
   { C(username),         &type_string,           validate_any },
 };
 
-/* find a configuration item's definition by key */
+/** @brief Find a configuration item's definition by key */
 static const struct conf *find(const char *key) {
   int n;
 
 static const struct conf *find(const char *key) {
   int n;
 
@@ -695,7 +931,7 @@ static const struct conf *find(const char *key) {
   return &conf[n];
 }
 
   return &conf[n];
 }
 
-/* set a new configuration value */
+/** @brief Set a new configuration value */
 static int config_set(const struct config_state *cs,
                      int nvec, char **vec) {
   const struct conf *which;
 static int config_set(const struct config_state *cs,
                      int nvec, char **vec) {
   const struct conf *which;
@@ -710,13 +946,14 @@ 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 Error callback used by config_include() */
 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);
 }
 
 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);
 }
 
-/* include a file by name */
+/** @brief Include a file by name */
 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;
@@ -768,7 +1005,7 @@ static int config_include(struct config *c, const char *path) {
   return ret;
 }
 
   return ret;
 }
 
-/* make a new default config */
+/** @brief Make a new default 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;
@@ -789,6 +1026,19 @@ static struct config *config_default(void) {
   c->lock = 1;
   c->device = xstrdup("default");
   c->nice_rescan = 10;
   c->lock = 1;
   c->device = xstrdup("default");
   c->nice_rescan = 10;
+  c->speaker_command = 0;
+  c->sample_format.bits = 16;
+  c->sample_format.rate = 44100;
+  c->sample_format.channels = 2;
+  c->sample_format.endian = ENDIAN_NATIVE;
+  c->queue_pad = 10;
+  c->speaker_backend = -1;
+  c->multicast_ttl = 1;
+  c->authorization_algorithm = xstrdup("sha1");
+  c->noticed_history = 31;
+  c->short_display = 32;
+  c->mixer = xstrdup("/dev/mixer");
+  c->channel = xstrdup("pcm");
   return c;
 }
 
   return c;
 }
 
@@ -799,12 +1049,13 @@ static char *get_file(struct config *c, const char *name) {
   return s;
 }
 
   return s;
 }
 
+/** @brief Set the default configuration file */
 static void set_configfile(void) {
   if(!configfile)
     byte_xasprintf(&configfile, "%s/config", pkgconfdir);
 }
 
 static void set_configfile(void) {
   if(!configfile)
     byte_xasprintf(&configfile, "%s/config", pkgconfdir);
 }
 
-/* free the config file */
+/** @brief Free a configuration object */
 static void config_free(struct config *c) {
   int n;
 
 static void config_free(struct config *c) {
   int n;
 
@@ -818,13 +1069,15 @@ static void config_free(struct config *c) {
   }
 }
 
   }
 }
 
-static void config_postdefaults(struct config *c) {
+/** @brief Set post-parse defaults */
+static void config_postdefaults(struct config *c,
+                               int server) {
   struct config_state cs;
   const struct conf *whoami;
   int n;
 
   static const char *namepart[][4] = {
   struct config_state cs;
   const struct conf *whoami;
   int n;
 
   static const char *namepart[][4] = {
-    { "title",  "/([0-9]+:)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display" },
+    { "title",  "/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display" },
     { "title",  "/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort" },
     { "album",  "/([^/]+)/[^/]+$",                    "$1", "*" },
     { "artist", "/([^/]+)/[^/]+/[^/]+$",              "$1", "*" },
     { "title",  "/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort" },
     { "album",  "/([^/]+)/[^/]+$",                    "$1", "*" },
     { "artist", "/([^/]+)/[^/]+/[^/]+$",              "$1", "*" },
@@ -833,7 +1086,7 @@ static void config_postdefaults(struct config *c) {
 #define NNAMEPART (int)(sizeof namepart / sizeof *namepart)
 
   static const char *transform[][5] = {
 #define NNAMEPART (int)(sizeof namepart / sizeof *namepart)
 
   static const char *transform[][5] = {
-    { "track", "^.*/([0-9]+:)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display", "" },
+    { "track", "^.*/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display", "" },
     { "track", "^.*/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort", "" },
     { "dir",   "^.*/([^/]+)$",                          "$1", "*", "" },
     { "dir",   "^(the) ([^/]*)",                        "$2, $1", "sort", "i", },
     { "track", "^.*/([^/]+)\\.[a-zA-Z0-9]+$",           "$1", "sort", "" },
     { "dir",   "^.*/([^/]+)$",                          "$1", "*", "" },
     { "dir",   "^(the) ([^/]*)",                        "$2, $1", "sort", "i", },
@@ -854,18 +1107,60 @@ static void config_postdefaults(struct config *c) {
     for(n = 0; n < NTRANSFORM; ++n)
       set_transform(&cs, whoami, 5, (char **)transform[n]);
   }
     for(n = 0; n < NTRANSFORM; ++n)
       set_transform(&cs, whoami, 5, (char **)transform[n]);
   }
+  if(c->speaker_backend == -1) {
+    if(c->speaker_command)
+      c->speaker_backend = BACKEND_COMMAND;
+    else if(c->broadcast.n)
+      c->speaker_backend = BACKEND_NETWORK;
+    else {
+#if HAVE_ALSA_ASOUNDLIB_H
+      c->speaker_backend = BACKEND_ALSA;
+#elif HAVE_SYS_SOUNDCARD_H
+      c->speaker_backend = BACKEND_OSS;
+#elif HAVE_COREAUDIO_AUDIOHARDWARE_H
+      c->speaker_backend = BACKEND_COREAUDIO;
+#else
+      c->speaker_backend = BACKEND_COMMAND;
+#endif
+    }
+  }
+  if(server) {
+    if(c->speaker_backend == BACKEND_COMMAND && !c->speaker_command)
+      fatal(0, "speaker_backend is command but speaker_command is not set");
+    if(c->speaker_backend == BACKEND_NETWORK && !c->broadcast.n)
+      fatal(0, "speaker_backend is network but broadcast is not set");
+  }
+  /* Override sample format */
+  switch(c->speaker_backend) {
+  case BACKEND_NETWORK:
+    c->sample_format.rate = 44100;
+    c->sample_format.channels = 2;
+    c->sample_format.bits = 16;
+    c->sample_format.endian = ENDIAN_BIG;
+    break;
+  case BACKEND_COREAUDIO:
+    c->sample_format.rate = 44100;
+    c->sample_format.channels = 2;
+    c->sample_format.bits = 16;
+    c->sample_format.endian = ENDIAN_NATIVE;
+    break; 
+ }
 }
 
 }
 
-/* re-read the config file */
-int config_read() {
+/** @brief (Re-)read the config file
+ * @param server If set, do extra checking
+ */
+int config_read(int server) {
   struct config *c;
   char *privconf;
   struct passwd *pw;
 
   set_configfile();
   c = config_default();
   struct config *c;
   char *privconf;
   struct passwd *pw;
 
   set_configfile();
   c = config_default();
-  if(config_include(c, configfile))
-    return -1;
+  /* standalone Disobedience installs might not have a global config file */
+  if(access(configfile, F_OK) == 0)
+    if(config_include(c, configfile))
+      return -1;
   /* if we can read the private config file, do */
   if((privconf = config_private())
      && access(privconf, R_OK) == 0
   /* if we can read the private config file, do */
   if((privconf = config_private())
      && access(privconf, R_OK) == 0
@@ -887,13 +1182,14 @@ int config_read() {
     return -1;
   xfree(privconf);
   /* install default namepart and transform settings */
     return -1;
   xfree(privconf);
   /* install default namepart and transform settings */
-  config_postdefaults(c);
+  config_postdefaults(c, server);
   /* everything is good so we shall use the new config */
   config_free(config);
   config = c;
   return 0;
 }
 
   /* everything is good so we shall use the new config */
   config_free(config);
   config = c;
   return 0;
 }
 
+/** @brief Return the path to the private configuration file */
 char *config_private(void) {
   char *s;
 
 char *config_private(void) {
   char *s;
 
@@ -902,14 +1198,18 @@ char *config_private(void) {
   return s;
 }
 
   return s;
 }
 
+/** @brief Return the path to user's personal configuration file */
 char *config_userconf(const char *home, const struct passwd *pw) {
   char *s;
 
 char *config_userconf(const char *home, const struct passwd *pw) {
   char *s;
 
+  if(!home && !pw && !(pw = getpwuid(getuid())))
+    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;
 }
 
-char *config_usersysconf(const struct passwd *pw ) {
+/** @brief Return the path to user-specific system configuration */
+char *config_usersysconf(const struct passwd *pw) {
   char *s;
 
   set_configfile();
   char *s;
 
   set_configfile();
@@ -931,4 +1231,3 @@ comment-column:40
 fill-column:79
 End:
 */
 fill-column:79
 End:
 */
-/* arch-tag:ede19ed49dca6136ba864ed0a4988b34 */