merge from disorder.dev

[disorder] / lib / configuration.c

diff --git a/lib/configuration.c b/lib/configuration.c
index 486a2ab817690ab016eff605b1d380494ceb49b5..d758751d3d061d1ac19aef263abcf67e865a0231 100644 (file)
--- a/lib/configuration.c
+++ b/lib/configuration.c
@@ -51,6 +51,7 @@
 #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 
  *
 
 /** @brief Path to config file 
  *


@@ -225,6 +226,10 @@ static int set_stringlist_accum(const struct config_state *cs,
   struct stringlistlist *sll;
 
   sll = ADDRESS(cs->config, struct stringlistlist);
   struct stringlistlist *sll;
 
   sll = ADDRESS(cs->config, struct stringlistlist);

+  if(nvec == 0) {
+    sll->n = 0;
+    return 0;
+  }

   sll->n++;
   sll->s = xrealloc(sll->s, (sll->n * sizeof (struct stringlist)));
   s = &sll->s[sll->n - 1];
   sll->n++;
   sll->s = xrealloc(sll->s, (sll->n * sizeof (struct stringlist)));
   s = &sll->s[sll->n - 1];


@@ -242,6 +247,10 @@ static int set_string_accum(const struct config_state *cs,
   struct stringlist *sl;
 
   sl = ADDRESS(cs->config, struct stringlist);
   struct stringlist *sl;
 
   sl = ADDRESS(cs->config, struct stringlist);

+  if(nvec == 0) {
+    sl->n = 0;
+    return 0;
+  }

   for(n = 0; n < nvec; ++n) {
     sl->n++;
     sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));
   for(n = 0; n < nvec; ++n) {
     sl->n++;
     sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));


@@ -438,7 +447,7 @@ static int set_backend(const struct config_state *cs,
     return -1;
   }
   if(!strcmp(vec[0], "alsa")) {
     return -1;
   }
   if(!strcmp(vec[0], "alsa")) {

-#if API_ALSA
+#if HAVE_ALSA_ASOUNDLIB_H

     *valuep = BACKEND_ALSA;
 #else
     error(0, "%s:%d: ALSA is not available on this platform",
     *valuep = BACKEND_ALSA;
 #else
     error(0, "%s:%d: ALSA is not available on this platform",


@@ -449,7 +458,23 @@ static int set_backend(const struct config_state *cs,
     *valuep = BACKEND_COMMAND;
   else if(!strcmp(vec[0], "network"))
     *valuep = BACKEND_NETWORK;
     *valuep = BACKEND_COMMAND;
   else if(!strcmp(vec[0], "network"))
     *valuep = BACKEND_NETWORK;

-  else {
+  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;
     error(0, "%s:%d: invalid '%s' value '%s'",
          cs->path, cs->line, whoami->name, vec[0]);
     return -1;


@@ -576,6 +601,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");


@@ -605,6 +643,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) {


@@ -812,6 +861,20 @@ static int validate_port(const struct config_state attribute((unused)) *cs,
   }
 }
 
   }
 }
 

+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)
 /** @brief Item name and and offset */
 /** @brief Item name and and offset */
 #define C(x) #x, offsetof(struct config, x)
 /** @brief Item name and and offset */


@@ -821,6 +884,7 @@ static int validate_port(const struct config_state attribute((unused)) *cs,
 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(broadcast),        &type_stringlist,       validate_addrport },
   { C(broadcast_from),   &type_stringlist,       validate_addrport },
   { C(channel),          &type_string,           validate_channel },


@@ -828,10 +892,11 @@ static const struct conf conf[] = {
   { C(checkpoint_min),   &type_integer,          validate_non_negative },
   { C(collection),       &type_collections,      validate_any },
   { C(connect),          &type_stringlist,       validate_addrport },
   { C(checkpoint_min),   &type_integer,          validate_non_negative },
   { C(collection),       &type_collections,      validate_any },
   { C(connect),          &type_stringlist,       validate_addrport },

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

   { 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(home),             &type_string,           validate_isabspath },

   { C(listen),           &type_stringlist,       validate_port },
   { C(lock),             &type_boolean,          validate_any },
   { C(mixer),            &type_string,           validate_ischr },
   { C(listen),           &type_stringlist,       validate_port },
   { C(lock),             &type_boolean,          validate_any },
   { C(mixer),            &type_string,           validate_ischr },


@@ -841,6 +906,7 @@ static const struct conf conf[] = {
   { C(nice_rescan),      &type_integer,          validate_non_negative },
   { C(nice_server),      &type_integer,          validate_any },
   { C(nice_speaker),     &type_integer,          validate_any },
   { 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(password),         &type_string,           validate_any },
   { C(player),           &type_stringlist_accum, validate_player },
   { C(plugins),          &type_string_accum,     validate_isdir },


@@ -850,12 +916,14 @@ static const struct conf conf[] = {
   { C2(restrict, restrictions),         &type_restrict,         validate_any },
   { C(sample_format),    &type_sample_format,    validate_sample_format },
   { C(scratch),          &type_string_accum,     validate_isreg },
   { C2(restrict, restrictions),         &type_restrict,         validate_any },
   { C(sample_format),    &type_sample_format,    validate_sample_format },
   { C(scratch),          &type_string_accum,     validate_isreg },

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

   { 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(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(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 },


@@ -975,6 +1043,12 @@ static struct config *config_default(void) {
   c->queue_pad = 10;
   c->speaker_backend = -1;
   c->multicast_ttl = 1;
   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");
+  c->dbversion = 2;

   return c;
 }
 
   return c;
 }
 


@@ -1006,13 +1080,14 @@ static void config_free(struct config *c) {
 }
 
 /** @brief Set post-parse defaults */
 }
 
 /** @brief Set post-parse defaults */

-static void config_postdefaults(struct config *c) {
+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", "*" },


@@ -1021,7 +1096,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", },


@@ -1048,28 +1123,44 @@ static void config_postdefaults(struct config *c) {
     else if(c->broadcast.n)
       c->speaker_backend = BACKEND_NETWORK;
     else {
     else if(c->broadcast.n)
       c->speaker_backend = BACKEND_NETWORK;
     else {

-#if API_ALSA
+#if HAVE_ALSA_ASOUNDLIB_H

       c->speaker_backend = BACKEND_ALSA;
       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
     }
   }
 #else
       c->speaker_backend = BACKEND_COMMAND;
 #endif
     }
   }

-  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");
-  if(c->speaker_backend) {
-    /* Override sample format */
+  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;
     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; 
+ }

 }
 
 }
 

-/** @brief (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;
   struct config *c;
   char *privconf;
   struct passwd *pw;


@@ -1101,7 +1192,7 @@ 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;
   /* everything is good so we shall use the new config */
   config_free(config);
   config = c;


@@ -1121,6 +1212,8 @@ char *config_private(void) {
 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;
 }