/*
* This file is part of DisOrder.
- * Copyright (C) 2004, 2005, 2006, 2007 Richard Kettlewell
+ * Copyright (C) 2004-2009 Richard Kettlewell
+ * Portions copyright (C) 2007 Mark Wooding
*
- * This program is free software; you can redistribute it and/or modify
+ * 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
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
- * USA
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+/** @file lib/configuration.c
+ * @brief Configuration file support
*/
-#include <config.h>
-#include "types.h"
+#include "common.h"
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pcre.h>
#include <signal.h>
+#include "rights.h"
#include "configuration.h"
#include "mem.h"
#include "log.h"
#include "inputline.h"
#include "charset.h"
#include "defs.h"
-#include "mixer.h"
#include "printf.h"
#include "regsub.h"
#include "signame.h"
+#include "authhash.h"
+#include "vector.h"
+#include "uaudio.h"
/** @brief Path to config file
*
*/
char *configfile;
+/** @brief Read user configuration
+ *
+ * If clear, the user-specific configuration is not read.
+ */
+int config_per_user = 1;
+
+/** @brief Table of audio APIs
+ *
+ * Only set in server processes.
+ */
+const struct uaudio *const *config_uaudio_apis;
+
/** @brief Config file parser state */
struct config_state {
/** @brief Filename */
/** @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) {
const struct conf *whoami,
int nvec, char **vec) {
struct collectionlist *cl;
+ const char *root, *encoding, *module;
- if(nvec != 3) {
- error(0, "%s:%d: '%s' requires three arguments",
+ switch(nvec) {
+ case 1:
+ module = 0;
+ encoding = 0;
+ root = vec[0];
+ break;
+ case 2:
+ module = vec[0];
+ encoding = 0;
+ root = vec[1];
+ break;
+ case 3:
+ module = vec[0];
+ encoding = vec[1];
+ root = vec[2];
+ break;
+ case 0:
+ error(0, "%s:%d: '%s' requires at least one argument",
+ cs->path, cs->line, whoami->name);
+ return -1;
+ default:
+ error(0, "%s:%d: '%s' requires at most three arguments",
cs->path, cs->line, whoami->name);
return -1;
}
- if(vec[2][0] != '/') {
+ /* Sanity check root */
+ if(root[0] != '/') {
error(0, "%s:%d: collection root must start with '/'",
cs->path, cs->line);
return -1;
}
- if(vec[2][1] && vec[2][strlen(vec[2])-1] == '/') {
+ if(root[1] && root[strlen(root)-1] == '/') {
error(0, "%s:%d: collection root must not end with '/'",
cs->path, cs->line);
return -1;
}
+ /* Defaults */
+ if(!module)
+ module = "fs";
+ if(!encoding)
+ encoding = nl_langinfo(CODESET);
cl = ADDRESS(cs->config, struct collectionlist);
++cl->n;
cl->s = xrealloc(cl->s, cl->n * sizeof (struct collection));
- cl->s[cl->n - 1].module = xstrdup(vec[0]);
- cl->s[cl->n - 1].encoding = xstrdup(vec[1]);
- cl->s[cl->n - 1].root = xstrdup(vec[2]);
+ cl->s[cl->n - 1].module = xstrdup(module);
+ cl->s[cl->n - 1].encoding = xstrdup(encoding);
+ cl->s[cl->n - 1].root = xstrdup(root);
return 0;
}
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];
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) {
- if((i = TABLE_FIND(restrictions, struct restriction, name, vec[n])) < 0) {
+ if((i = TABLE_FIND(restrictions, name, vec[n])) < 0) {
error(0, "%s:%d: invalid restriction '%s'",
cs->path, cs->line, vec[n]);
return -1;
}
static int parse_sample_format(const struct config_state *cs,
- ao_sample_format *ao,
+ struct stream_header *format,
int nvec, char **vec) {
char *p = vec[0];
long t;
- if (nvec != 1) {
+ if(nvec != 1) {
error(0, "%s:%d: wrong number of arguments", cs->path, cs->line);
return -1;
}
- if (xstrtol(&t, p, &p, 0)) {
+ 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) {
+ if(t != 8 && t != 16) {
error(0, "%s:%d: bad bite-per-sample (%ld)", cs->path, cs->line, t);
return -1;
}
- if (ao) ao->bits = t;
+ if(format) format->bits = t;
switch (*p) {
- case 'l': case 'L': t = AO_FMT_LITTLE; p++; break;
- case 'b': case 'B': t = AO_FMT_BIG; p++; break;
- default: t = AO_FMT_NATIVE; break;
+ case 'l': case 'L': t = ENDIAN_LITTLE; p++; break;
+ case 'b': case 'B': t = ENDIAN_BIG; p++; break;
+ default: t = ENDIAN_NATIVE; break;
}
- if (ao) ao->byte_format = t;
- if (*p != '/') {
+ 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)) {
+ 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) {
+ if(t < 1 || t > INT_MAX) {
error(0, "%s:%d: silly sample-rate (%ld)", cs->path, cs->line, t);
return -1;
}
- if (ao) ao->rate = t;
- if (*p != '/') {
+ 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)) {
+ if(xstrtol(&t, p, &p, 0)) {
error(errno, "%s:%d: converting channels", cs->path, cs->line);
return -1;
}
- if (t < 1 || t > 8) {
+ if(t < 1 || t > 8) {
error(0, "%s:%d: silly number (%ld) of channels", cs->path, cs->line, t);
return -1;
}
- if (ao) ao->channels = t;
- if (*p) {
+ if(format) format->channels = t;
+ if(*p) {
error(0, "%s:%d: junk after channels", cs->path, cs->line);
return -1;
}
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, ao_sample_format),
+ return parse_sample_format(cs, ADDRESS(cs->config, struct stream_header),
nvec, vec);
}
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;
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);
-
+static int set_rights(const struct config_state *cs,
+ 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);
return -1;
}
- if(!strcmp(vec[0], "alsa")) {
-#if API_ALSA
- *valuep = BACKEND_ALSA;
-#else
- error(0, "%s:%d: ALSA is not available on this platform",
- cs->path, cs->line);
+ if(parse_rights(vec[0], 0, 1)) {
+ error(0, "%s:%d: invalid rights string '%s'",
+ cs->path, cs->line, vec[0]);
return -1;
-#endif
- } else if(!strcmp(vec[0], "command"))
- *valuep = BACKEND_COMMAND;
- else if(!strcmp(vec[0], "network"))
- *valuep = BACKEND_NETWORK;
- else {
- error(0, "%s:%d: invalid '%s' value '%s'",
- cs->path, cs->line, whoami->name, vec[0]);
+ }
+ *ADDRESS(cs->config, char *) = vec[0];
+ 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;
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,
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);
}
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
type_restrict = { set_restrict, free_none },
type_namepart = { set_namepart, free_namepartlist },
type_transform = { set_transform, free_transformlist },
- type_backend = { set_backend, free_none };
+ type_netaddress = { set_netaddress, free_netaddress },
+ type_rights = { set_rights, free_none };
/* specific validation routine */
} \
} 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");
return 0;
}
-static int validate_ischr(const struct config_state *cs,
- int nvec, char **vec) {
- VALIDATE_FILE(S_ISCHR, "character device");
- return 0;
-}
-
static int validate_player(const struct config_state *cs,
int nvec,
char attribute((unused)) **vec) {
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) {
return parse_sample_format(cs, 0, nvec, vec);
}
-static int validate_channel(const struct config_state *cs,
- int attribute((unused)) nvec,
- char **vec) {
- if(mixer_channel(vec[0]) == -1) {
- error(0, "%s:%d: invalid channel '%s'", cs->path, cs->line, vec[0]);
- return -1;
- }
- 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_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);
+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;
- case 1:
- error(0, "%s:%d: missing port name/number",
- cs->path, cs->line);
+ }
+ if(!valid_authhash(vec[0])) {
+ error(0, "%s:%d: unsuported algorithm '%s'", cs->path, cs->line, vec[0]);
return -1;
- case 2:
+ }
+ return 0;
+}
+
+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);
+ return -1;
+ }
+ if(!strcmp(vec[0], "network")) {
+ error(0, "'api network' is deprecated; use 'api rtp'");
return 0;
- default:
- error(0, "%s:%d: expected ADDRESS PORT",
- cs->path, cs->line);
+ }
+ 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]);
return -1;
}
+ /* In non-server processes we have no idea what's valid */
+ return 0;
}
-static int validate_address(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:
+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;
- default:
- error(0, "%s:%d: expected ADDRESS PORT",
- cs->path, cs->line);
+ error(0, "%s:%d: invalid pause mode", cs->path, cs->line);
+ return -1;
+}
+
+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 */
static const struct conf conf[] = {
{ C(alias), &type_string, validate_alias },
{ C(allow), &type_stringlist_accum, validate_allow },
- { C(broadcast), &type_stringlist, validate_addrport },
- { C(broadcast_from), &type_stringlist, validate_address },
- { C(channel), &type_string, validate_channel },
+ { C(api), &type_string, validate_backend },
+ { C(authorization_algorithm), &type_string, validate_algo },
+ { 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 },
+ { 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_isdir },
- { C(listen), &type_stringlist, validate_addrport },
+ { C(home), &type_string, validate_isabspath },
+ { C(listen), &type_netaddress, validate_any },
{ C(lock), &type_boolean, validate_any },
- { C(mixer), &type_string, validate_ischr },
+ { C(mail_sender), &type_string, validate_any },
+ { C(mixer), &type_string, validate_any },
+ { C(multicast_loop), &type_boolean, validate_any },
+ { C(multicast_ttl), &type_integer, validate_non_negative },
{ C(namepart), &type_namepart, validate_any },
+ { C(new_bias), &type_integer, validate_positive },
+ { C(new_bias_age), &type_integer, validate_positive },
+ { C(new_max), &type_integer, validate_positive },
{ 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(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 },
+ { C(replay_min), &type_integer, validate_non_negative },
{ C(refresh), &type_integer, validate_positive },
+ { C(reminder_interval), &type_integer, validate_positive },
+ { C(remote_userman), &type_boolean, validate_any },
{ C2(restrict, restrictions), &type_restrict, validate_any },
+ { C(rtp_delay_threshold), &type_integer, validate_positive },
{ C(sample_format), &type_sample_format, validate_sample_format },
{ C(scratch), &type_string_accum, validate_isreg },
+ { C(sendmail), &type_string, validate_isabspath },
+ { C(short_display), &type_integer, validate_positive },
{ C(signal), &type_signal, validate_any },
+ { C(smtp_server), &type_string, validate_any },
{ C(sox_generation), &type_integer, validate_non_negative },
- { C(speaker_backend), &type_backend, validate_any },
+ { C2(speaker_backend, api), &type_string, validate_backend },
{ 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 },
static const struct conf *find(const char *key) {
int n;
- if((n = TABLE_FIND(conf, struct conf, name, key)) < 0)
+ if((n = TABLE_FIND(conf, name, key)) < 0)
return 0;
return &conf[n];
}
|| which->type->set(cs, which, nvec - 1, vec + 1));
}
+static int config_set_args(const struct config_state *cs,
+ const char *which, ...) {
+ va_list ap;
+ struct vector v[1];
+ char *s;
+
+ vector_init(v);
+ vector_append(v, (char *)which);
+ va_start(ap, which);
+ while((s = va_arg(ap, char *)))
+ vector_append(v, s);
+ va_end(ap);
+ vector_terminate(v);
+ return config_set(cs, v->nvec, v->vec);
+}
+
+/** @brief Error callback used by config_include() */
static void config_error(const char *msg, void *u) {
const struct config_state *cs = u;
return ret;
}
+static const char *const default_stopwords[] = {
+ "stopword",
+
+ "01",
+ "02",
+ "03",
+ "04",
+ "05",
+ "06",
+ "07",
+ "08",
+ "09",
+ "1",
+ "10",
+ "11",
+ "12",
+ "13",
+ "14",
+ "15",
+ "16",
+ "17",
+ "18",
+ "19",
+ "2",
+ "20",
+ "21",
+ "22",
+ "23",
+ "24",
+ "25",
+ "26",
+ "27",
+ "28",
+ "29",
+ "3",
+ "30",
+ "4",
+ "5",
+ "6",
+ "7",
+ "8",
+ "9",
+ "a",
+ "am",
+ "an",
+ "and",
+ "as",
+ "for",
+ "i",
+ "im",
+ "in",
+ "is",
+ "of",
+ "on",
+ "the",
+ "to",
+ "too",
+ "we",
+};
+#define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
+
+static const char *const default_players[] = {
+ "*.ogg",
+ "*.flac",
+ "*.mp3",
+ "*.wav",
+};
+#define NDEFAULT_PLAYERS (sizeof default_players / sizeof *default_players)
+
/** @brief Make a new default configuration */
static struct config *config_default(void) {
struct config *c = xmalloc(sizeof *c);
const char *logname;
struct passwd *pw;
+ struct config_state cs;
+ size_t n;
+ cs.path = "<internal>";
+ cs.line = 0;
+ cs.config = c;
/* Strings had better be xstrdup'd as they will get freed at some point. */
- c->gap = 2;
+ c->gap = 0;
c->history = 60;
c->home = xstrdup(pkgstatedir);
if(!(pw = getpwuid(getuid())))
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;
c->sample_format.bits = 16;
c->sample_format.rate = 44100;
c->sample_format.channels = 2;
- c->sample_format.byte_format = AO_FMT_NATIVE;
+ c->sample_format.endian = ENDIAN_NATIVE;
c->queue_pad = 10;
- c->speaker_backend = -1;
+ c->replay_min = 8 * 3600;
+ c->api = NULL;
+ c->multicast_ttl = 1;
+ c->multicast_loop = 1;
+ c->authorization_algorithm = xstrdup("sha1");
+ c->noticed_history = 31;
+ c->short_display = 32;
+ c->mixer = 0;
+ c->channel = 0;
+ c->dbversion = 2;
+ c->cookie_login_lifetime = 86400;
+ c->cookie_key_lifetime = 86400 * 7;
+ if(sendmail_binary[0] && strcmp(sendmail_binary, "none"))
+ c->sendmail = xstrdup(sendmail_binary);
+ c->smtp_server = xstrdup("127.0.0.1");
+ c->new_max = 100;
+ c->reminder_interval = 600; /* 10m */
+ 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);
+ /* Default player configuration */
+ for(n = 0; n < NDEFAULT_PLAYERS; ++n) {
+ if(config_set_args(&cs, "player",
+ default_players[n], "execraw", "disorder-decode", (char *)0))
+ exit(1);
+ if(config_set_args(&cs, "tracklength",
+ 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;
}
-static char *get_file(struct config *c, const char *name) {
+char *config_get_file2(struct config *c, const char *name) {
char *s;
byte_xasprintf(&s, "%s/%s", c->home, name);
}
/** @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] = {
- { "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", "*" },
#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", },
for(n = 0; n < NTRANSFORM; ++n)
set_transform(&cs, whoami, 5, (char **)transform[n]);
}
- if(c->speaker_backend == -1) {
+ if(!c->api) {
if(c->speaker_command)
- c->speaker_backend = BACKEND_COMMAND;
- else if(c->broadcast.n)
- c->speaker_backend = BACKEND_NETWORK;
- else {
-#if API_ALSA
- c->speaker_backend = BACKEND_ALSA;
-#else
- c->speaker_backend = BACKEND_COMMAND;
-#endif
- }
+ c->api = xstrdup("command");
+ else if(c->broadcast.af != -1)
+ c->api = xstrdup("rtp");
+ else if(config_uaudio_apis)
+ c->api = xstrdup(config_uaudio_apis[0]->name);
+ else
+ c->api = xstrdup("<none>");
+ }
+ if(!strcmp(c->api, "network"))
+ c->api = xstrdup("rtp");
+ 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.af == -1)
+ fatal(0, "'api rtp' but broadcast is not set");
+ }
+ /* Override sample format */
+ if(!strcmp(c->api, "rtp")) {
+ c->sample_format.rate = 44100;
+ c->sample_format.channels = 2;
+ c->sample_format.bits = 16;
+ c->sample_format.endian = ENDIAN_NATIVE;
+ }
+ if(!strcmp(c->api, "coreaudio")) {
+ c->sample_format.rate = 44100;
+ c->sample_format.channels = 2;
+ c->sample_format.bits = 16;
+ c->sample_format.endian = ENDIAN_NATIVE;
+ }
+ if(!c->default_rights) {
+ rights_type r = RIGHTS__MASK & ~(RIGHT_ADMIN|RIGHT_REGISTER
+ |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;
+ c->default_rights = rights_string(r);
}
- 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");
}
-/** @brief (Re-)read the config file */
-int config_read() {
+/** @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,
+ const struct config *oldconfig) {
struct config *c;
char *privconf;
struct passwd *pw;
return -1;
xfree(privconf);
/* if there's a per-user system config file for this user, read it */
- if(!(pw = getpwuid(getuid())))
- fatal(0, "cannot determine our username");
- if((privconf = config_usersysconf(pw))
- && access(privconf, F_OK) == 0
- && config_include(c, privconf))
+ if(config_per_user) {
+ if(!(pw = getpwuid(getuid())))
+ fatal(0, "cannot determine our username");
+ if((privconf = config_usersysconf(pw))
+ && access(privconf, F_OK) == 0
+ && config_include(c, privconf))
return -1;
- xfree(privconf);
- /* if we have a password file, read it */
- if((privconf = config_userconf(getenv("HOME"), pw))
- && access(privconf, F_OK) == 0
- && config_include(c, privconf))
- return -1;
- xfree(privconf);
+ xfree(privconf);
+ /* if we have a password file, read it */
+ if((privconf = config_userconf(0, pw))
+ && access(privconf, F_OK) == 0
+ && config_include(c, privconf))
+ return -1;
+ xfree(privconf);
+ }
/* install default namepart and transform settings */
- config_postdefaults(c);
+ 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 */
+ 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;
}
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;
}
}
char *config_get_file(const char *name) {
- return get_file(config, name);
+ return config_get_file2(config, name);
+}
+
+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;
+}
+
+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;
+}
+
+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;
}
/*
~mdw / disorder / blobdiff