/*
* This file is part of DisOrder.
- * Copyright (C) 2004-2010 Richard Kettlewell
+ * Copyright (C) 2004-2011, 2013 Richard Kettlewell
* Portions copyright (C) 2007 Mark Wooding
*
* This program is free software: you can redistribute it and/or modify
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include <unistd.h>
+#if HAVE_UNISTD_H
+# include <unistd.h>
+#endif
#include <ctype.h>
#include <stddef.h>
-#include <pwd.h>
-#include <langinfo.h>
-#include <pcre.h>
+#if HAVE_PWD_H
+# include <pwd.h>
+#endif
+#if HAVE_LANGINFO_H
+# include <langinfo.h>
+#endif
+
#include <signal.h>
#include "rights.h"
#include "log.h"
#include "split.h"
#include "syscalls.h"
+#include "home.h"
#include "table.h"
#include "inputline.h"
#include "charset.h"
#include "defs.h"
#include "printf.h"
+#include "regexp.h"
#include "regsub.h"
#include "signame.h"
#include "authhash.h"
#include "vector.h"
+#if !_WIN32
#include "uaudio.h"
+#endif
/** @brief Path to config file
*
*/
int config_per_user = 1;
+#if !_WIN32
/** @brief Table of audio APIs
*
* Only set in server processes.
*/
const struct uaudio *const *config_uaudio_apis;
+#endif
/** @brief Config file parser state */
struct config_state {
/* Defaults */
if(!module)
module = "fs";
+#if HAVE_LANGINFO_H
if(!encoding)
encoding = nl_langinfo(CODESET);
+#else
+ if(!encoding)
+ encoding = "ascii";
+#endif
cl = ADDRESS(cs->config, struct collectionlist);
++cl->n;
cl->s = xrealloc(cl->s, cl->n * sizeof (struct collection));
return 0;
}
-static int set_stringlist(const struct config_state *cs,
- const struct conf *whoami,
- int nvec, char **vec) {
- int n;
- struct stringlist *sl;
-
- sl = ADDRESS(cs->config, struct stringlist);
- sl->n = 0;
- for(n = 0; n < nvec; ++n) {
- sl->n++;
- sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));
- sl->s[sl->n - 1] = xstrdup(vec[n]);
- }
- return 0;
-}
-
static int set_integer(const struct config_state *cs,
const struct conf *whoami,
int nvec, char **vec) {
cs->path, cs->line, t);
return -1;
}
- if(format) format->bits = t;
+ if(format) format->bits = (uint8_t)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(format) format->endian = (uint8_t)t;
if(*p != '/') {
disorder_error(errno, "%s:%d: expected `/' after bits-per-sample",
cs->path, cs->line);
cs->path, cs->line, t);
return -1;
}
- if(format) format->channels = t;
+ if(format) format->channels = (uint8_t)t;
if(*p) {
disorder_error(0, "%s:%d: junk after channels", cs->path, cs->line);
return -1;
int nvec, char **vec) {
struct namepartlist *npl = ADDRESS(cs->config, struct namepartlist);
unsigned reflags;
- const char *errstr;
- int erroffset, n;
- pcre *re;
+ regexp *re;
+ char errstr[RXCERR_LEN];
+ size_t erroffset;
+ int n;
if(nvec < 3) {
disorder_error(0, "%s:%d: namepart needs at least 3 arguments",
return -1;
}
reflags = nvec >= 5 ? regsub_flags(vec[4]) : 0;
- if(!(re = pcre_compile(vec[1],
- PCRE_UTF8
- |regsub_compile_options(reflags),
- &errstr, &erroffset, 0))) {
- disorder_error(0, "%s:%d: compiling regexp /%s/: %s (offset %d)",
+ if(!(re = regexp_compile(vec[1], regsub_compile_options(reflags),
+ errstr, sizeof(errstr), &erroffset)))
+ {
+ disorder_error(0, "%s:%d: compiling regexp /%s/: %s (offset %zu)",
cs->path, cs->line, vec[1], errstr, erroffset);
return -1;
}
const struct conf *whoami,
int nvec, char **vec) {
struct transformlist *tl = ADDRESS(cs->config, struct transformlist);
- pcre *re;
+ regexp *re;
+ char errstr[RXCERR_LEN];
unsigned reflags;
- const char *errstr;
- int erroffset;
+ size_t erroffset;
if(nvec < 3) {
disorder_error(0, "%s:%d: transform needs at least 3 arguments",
return -1;
}
reflags = (nvec >= 5 ? regsub_flags(vec[4]) : 0);
- if(!(re = pcre_compile(vec[1],
- PCRE_UTF8
- |regsub_compile_options(reflags),
- &errstr, &erroffset, 0))) {
- disorder_error(0, "%s:%d: compiling regexp /%s/: %s (offset %d)",
+ if(!(re = regexp_compile(vec[1], regsub_compile_options(reflags),
+ errstr, sizeof(errstr), &erroffset)))
+ {
+ disorder_error(0, "%s:%d: compiling regexp /%s/: %s (offset %zu)",
cs->path, cs->line, vec[1], errstr, erroffset);
return -1;
}
for(n = 0; n < npl->n; ++n) {
np = &npl->s[n];
xfree(np->part);
- pcre_free(np->re); /* ...whatever pcre_free is set to. */
+ regexp_free(np->re);
xfree(np->res);
xfree(np->replace);
xfree(np->context);
for(n = 0; n < tl->n; ++n) {
t = &tl->t[n];
xfree(t->type);
- pcre_free(t->re); /* ...whatever pcre_free is set to. */
+ regexp_free(t->re);
xfree(t->replace);
xfree(t->context);
}
type_collections = { set_collections, free_collectionlist },
type_boolean = { set_boolean, free_none },
type_string = { set_string, free_string },
- type_stringlist = { set_stringlist, free_stringlist },
type_integer = { set_integer, free_none },
type_stringlist_accum = { set_stringlist_accum, free_stringlistlist },
type_string_accum = { set_string_accum, free_stringlist },
for(n = 0; n < nvec; ++n)
if(vec[n][0] != '/') {
- disorder_error(errno, "%s:%d: %s: not an absolute path",
+ disorder_error(0, "%s:%d: %s: not an absolute path",
cs->path, cs->line, vec[n]);
return -1;
}
return 0;
}
-/** @brief Validate a non-negative (@c long) integer
+/** @brief Common code for validating integer values
* @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
+ * @param n_out Where to put the value
*/
-static int validate_non_negative(const struct config_state *cs,
- int nvec, char **vec) {
- long n;
+static int common_validate_integer(const struct config_state *cs,
+ int nvec, char **vec, long *n_out) {
+ char errbuf[1024];
if(nvec < 1) {
disorder_error(0, "%s:%d: missing argument", cs->path, cs->line);
disorder_error(0, "%s:%d: too many arguments", cs->path, cs->line);
return -1;
}
- if(xstrtol(&n, vec[0], 0, 0)) {
- disorder_error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
+ if(xstrtol(n_out, vec[0], 0, 0)) {
+ disorder_error(0, "%s:%d: %s", cs->path, cs->line,
+ format_error(ec_errno, errno, errbuf, sizeof errbuf));
return -1;
}
+ return 0;
+}
+
+/** @brief Validate a non-negative (@c long) integer
+ * @param cs Configuration state
+ * @param nvec Length of (proposed) new value
+ * @param vec Elements of new value
+ * @return 0 on success, non-0 on error
+ */
+static int validate_non_negative(const struct config_state *cs,
+ int nvec, char **vec) {
+ long n;
+ if(common_validate_integer(cs, nvec, vec, &n)) return -1;
if(n < 0) {
disorder_error(0, "%s:%d: must not be negative", cs->path, cs->line);
return -1;
static int validate_positive(const struct config_state *cs,
int nvec, char **vec) {
long n;
-
- if(nvec < 1) {
- disorder_error(0, "%s:%d: missing argument", cs->path, cs->line);
- return -1;
- }
- if(nvec > 1) {
- disorder_error(0, "%s:%d: too many arguments", cs->path, cs->line);
- return -1;
- }
- if(xstrtol(&n, vec[0], 0, 0)) {
- disorder_error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
- return -1;
- }
+ if(common_validate_integer(cs, nvec, vec, &n)) return -1;
if(n <= 0) {
disorder_error(0, "%s:%d: must be positive", cs->path, cs->line);
return -1;
return 0;
}
+#if !_WIN32
/** @brief Validate a system username
* @param cs Configuration state
* @param nvec Length of (proposed) new value
}
return 0;
}
+#endif
/** @brief Validate a sample format string
* @param cs Configuration state
return 0;
}
+#if !_WIN32
/** @brief Validate a playback backend name
* @param cs Configuration state
* @param nvec Length of (proposed) new value
/* In non-server processes we have no idea what's valid */
return 0;
}
+#endif
/** @brief Validate a pause mode string
* @param cs Configuration state
return -1;
}
+/** @brief Validate an MTU-discovery setting
+ * @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_mtu_discovery(const struct config_state attribute((unused)) *cs,
+ int nvec,
+ char **vec) {
+ if (nvec == 1 &&
+ (!strcmp(vec[0], "default") ||
+ !strcmp(vec[0], "yes") ||
+ !strcmp(vec[0], "no")))
+ return 0;
+ disorder_error(0, "%s:%d: invalid MTU-discovery setting", cs->path, cs->line);
+ return -1;
+}
+
/** @brief Validate a destination network address
* @param cs Configuration state
* @param nvec Length of (proposed) new value
return 0;
}
+/** @brief Validate an internet 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 be either IPv4 or IPv6.
+ */
+static int validate_inetaddr(const struct config_state *cs,
+ int nvec, char **vec) {
+ struct netaddress na[1];
+
+ if(netaddress_parse(na, nvec, vec)) {
+ disorder_error(0, "%s:%d: invalid network address", cs->path, cs->line);
+ return -1;
+ }
+ switch(na->af) {
+ case AF_INET: case AF_INET6: case AF_UNSPEC: break;
+ default:
+ disorder_error(0, "%s:%d: must be an intenet address",
+ 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 */
/** @brief All configuration items */
static const struct conf conf[] = {
{ C(alias), &type_string, validate_alias },
+#if !_WIN32
{ C(api), &type_string, validate_backend },
+#endif
{ C(authorization_algorithm), &type_string, validate_algo },
{ C(broadcast), &type_netaddress, validate_destaddr },
{ C(broadcast_from), &type_netaddress, validate_any },
{ C(default_rights), &type_rights, validate_any },
{ C(device), &type_string, validate_any },
{ C(history), &type_integer, validate_positive },
+#if !_WIN32
{ C(home), &type_string, validate_isabspath },
+#endif
{ C(listen), &type_netaddress, validate_any },
{ C(mail_sender), &type_string, validate_any },
{ C(mixer), &type_string, validate_any },
{ C(reminder_interval), &type_integer, validate_positive },
{ C(remote_userman), &type_boolean, validate_any },
{ C(replay_min), &type_integer, validate_non_negative },
+ { C(rtp_always_request), &type_boolean, validate_any },
{ C(rtp_delay_threshold), &type_integer, validate_positive },
+ { C(rtp_instance_name), &type_string, validate_any },
+ { C(rtp_max_payload), &type_integer, validate_positive },
+ { C(rtp_maxbuffer), &type_integer, validate_non_negative },
+ { C(rtp_minbuffer), &type_integer, validate_non_negative },
+ { C(rtp_mode), &type_string, validate_any },
+ { C(rtp_mtu_discovery), &type_string, validate_mtu_discovery },
+ { C(rtp_rcvbuf), &type_integer, validate_non_negative },
+ { C(rtp_request_address), &type_netaddress, validate_inetaddr },
{ C(rtp_verbose), &type_boolean, validate_any },
{ C(sample_format), &type_sample_format, validate_sample_format },
{ C(scratch), &type_string_accum, validate_isreg },
+#if !_WIN32
{ C(sendmail), &type_string, validate_isabspath },
+#endif
{ 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 },
+#if !_WIN32
{ C2(speaker_backend, api), &type_string, validate_backend },
+#endif
{ 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(url), &type_string, validate_url },
+#if !_WIN32
{ C(user), &type_string, validate_isauser },
+#endif
{ C(username), &type_string, validate_any },
};
va_list ap;
struct vector v[1];
char *s;
+ int rc;
vector_init(v);
vector_append(v, (char *)which);
vector_append(v, s);
va_end(ap);
vector_terminate(v);
- int rc = config_set(cs, v->nvec, v->vec);
+ rc = config_set(cs, v->nvec, v->vec);
xfree(v->vec);
return rc;
}
*/
static struct config *config_default(void) {
struct config *c = xmalloc(sizeof *c);
+#if !_WIN32
const char *logname;
struct passwd *pw;
+#endif
struct config_state cs;
size_t n;
cs.config = c;
/* Strings had better be xstrdup'd as they will get freed at some point. */
c->history = 60;
+#if !_WIN32
c->home = xstrdup(pkgstatedir);
+#endif
+#if _WIN32
+ {
+ char buffer[128];
+ DWORD bufsize = sizeof buffer;
+ if(!GetUserNameA(buffer, &bufsize))
+ disorder_fatal(0, "cannot determine our username");
+ c->username = xstrdup(buffer);
+ }
+#else
if(!(pw = getpwuid(getuid())))
disorder_fatal(0, "cannot determine our username");
logname = pw->pw_name;
c->username = xstrdup(logname);
+#endif
c->refresh = 15;
c->refresh_min = 1;
+#ifdef SIGKILL
c->signal = SIGKILL;
+#else
+ c->signal = SIGTERM;
+#endif
c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
c->device = xstrdup("default");
c->nice_rescan = 10;
c->dbversion = 2;
c->cookie_login_lifetime = 86400;
c->cookie_key_lifetime = 86400 * 7;
+#if !_WIN32
if(sendmail_binary[0] && strcmp(sendmail_binary, "none"))
c->sendmail = xstrdup(sendmail_binary);
+#endif
c->smtp_server = xstrdup("127.0.0.1");
c->new_max = 100;
c->reminder_interval = 600; /* 10m */
c->broadcast_from.af = -1;
c->listen.af = -1;
c->connect.af = -1;
+ c->rtp_mode = xstrdup("auto");
+ c->rtp_max_payload = -1;
+ c->rtp_mtu_discovery = xstrdup("default");
return c;
}
+#if !_WIN32
/** @brief Construct a filename
* @param c Configuration
* @param name Base filename
byte_xasprintf(&s, "%s/%s", c->home, name);
return s;
}
+#endif
/** @brief Set the default configuration file */
static void set_configfile(void) {
- if(!configfile)
- byte_xasprintf(&configfile, "%s/config", pkgconfdir);
+#if !_WIN32
+ if(!configfile) {
+ configfile = getenv("DISORDER_CONFIG");
+ if(!configfile)
+ byte_xasprintf(&configfile, "%s/config", pkgconfdir);
+ }
+#endif
}
/** @brief Free a configuration object
c->api = xstrdup("command");
else if(c->broadcast.af != -1)
c->api = xstrdup("rtp");
+#if !_WIN32
else if(config_uaudio_apis)
- c->api = xstrdup(config_uaudio_apis[0]->name);
+ c->api = xstrdup(uaudio_default(config_uaudio_apis,
+ UAUDIO_API_SERVER)->name);
+#endif
else
c->api = xstrdup("<none>");
}
if(server) {
if(!strcmp(c->api, "command") && !c->speaker_command)
disorder_fatal(0, "'api command' but speaker_command is not set");
- if((!strcmp(c->api, "rtp")) && c->broadcast.af == -1)
- disorder_fatal(0, "'api rtp' but broadcast is not set");
+ if((!strcmp(c->api, "rtp")) &&
+ c->broadcast.af == -1 && strcmp(c->rtp_mode, "request"))
+ disorder_fatal(0, "'api rtp' but broadcast is not set "
+ "and mode is not not 'request'");
}
/* Override sample format */
if(!strcmp(c->api, "rtp")) {
const struct config *oldconfig) {
struct config *c;
char *privconf;
- struct passwd *pw;
+ struct passwd *pw = NULL;
set_configfile();
c = config_default();
- /* standalone Disobedience installs might not have a global config file */
- if(access(configfile, F_OK) == 0)
- if(config_include(c, configfile))
- return -1;
+ /* standalone client installs might not have a global config file */
+ if(configfile)
+ 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
xfree(privconf);
/* if there's a per-user system config file for this user, read it */
if(config_per_user) {
+#if !_WIN32
if(!(pw = getpwuid(getuid())))
disorder_fatal(0, "cannot determine our username");
if((privconf = config_usersysconf(pw))
&& config_include(c, privconf))
return -1;
xfree(privconf);
+#endif
/* if we have a password file, read it */
- if((privconf = config_userconf(0, pw))
+ if((privconf = config_userconf())
&& access(privconf, F_OK) == 0
&& config_include(c, privconf))
return -1;
config_postdefaults(c, server);
if(oldconfig) {
int failed = 0;
+#if !_WIN32
if(strcmp(c->home, oldconfig->home)) {
disorder_error(0, "'home' cannot be changed without a restart");
failed = 1;
}
+#endif
if(strcmp(c->alias, oldconfig->alias)) {
disorder_error(0, "'alias' cannot be changed without a restart");
failed = 1;
/** @brief Return the path to the private configuration file */
char *config_private(void) {
+#if _WIN32
+ return NULL;
+#else
char *s;
set_configfile();
byte_xasprintf(&s, "%s.private", configfile);
return s;
+#endif
}
/** @brief Return the path to user's personal configuration file */
-char *config_userconf(const char *home, const struct passwd *pw) {
- char *s;
-
- if(!home && !pw && !(pw = getpwuid(getuid())))
- disorder_fatal(0, "cannot determine our username");
- byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
- return s;
+char *config_userconf(void) {
+ char *t;
+ if((t = getenv("DISORDER_USERCONFIG"))) return xstrdup(t);
+ return profile_filename("passwd");
}
+#if !_WIN32
/** @brief Return the path to user-specific system configuration */
char *config_usersysconf(const struct passwd *pw) {
char *s;
set_configfile();
- if(!strchr(pw->pw_name, '/')) {
+ if((s = getenv("DISORDER_USERCONFIG_SYS")))
+ return xstrdup(s);
+ else if(!strchr(pw->pw_name, '/')) {
byte_xasprintf(&s, "%s.%s", configfile, pw->pw_name);
return s;
} else
char *config_get_file(const char *name) {
return config_get_file2(config, name);
}
+#endif
/** @brief Order two stringlists
* @param a First stringlist
*/
int config_verify(void) {
int fails = 0;
- for(size_t n = 1; n < sizeof conf / sizeof *conf; ++n)
+ size_t n;
+ for(n = 1; n < sizeof conf / sizeof *conf; ++n)
if(strcmp(conf[n-1].name, conf[n].name) >= 0) {
fprintf(stderr, "%s >= %s\n", conf[n-1].name, conf[n].name);
++fails;
~mdw / disorder / blobdiff