/*
* 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
#include "regsub.h"
#include "signame.h"
+/** @brief Path to config file
+ *
+ * set_configfile() sets the deafult if it is null.
+ */
char *configfile;
+/** @brief Config file parser state */
struct config_state {
+ /** @brief Filename */
const char *path;
+ /** @brief Line number */
int line;
+ /** @brief Configuration object under construction */
struct config *config;
};
+/** @brief Current configuration */
struct config *config;
+/** @brief One configuration item */
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 */
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 */
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);
};
+/** @brief Compute the address of an item */
#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,
return 0;
}
+static int parse_sample_format(const struct config_state *cs,
+ ao_sample_format *ao,
+ 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 (ao) ao->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;
+ }
+ if (ao) ao->byte_format = 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 (ao) ao->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 (ao) ao->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, ao_sample_format),
+ nvec, vec);
+}
+
static int set_namepart(const struct config_state *cs,
const struct conf *whoami,
int nvec, char **vec) {
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 API_ALSA
+ *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 {
+ 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,
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_transform = { set_transform, free_transformlist };
+ type_transform = { set_transform, free_transformlist },
+ type_backend = { set_backend, free_none };
/* specific validation routine */
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) {
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_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:
+ return 0;
+ default:
+ error(0, "%s:%d: expected ADDRESS PORT",
+ cs->path, cs->line);
+ return -1;
+ }
+}
+/** @brief Item name and and offset */
#define C(x) #x, offsetof(struct config, x)
+/** @brief Item name and and offset */
#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 },
+ { C(broadcast), &type_stringlist, validate_addrport },
+ { C(broadcast_from), &type_stringlist, validate_address },
{ 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(home), &type_string, validate_isdir },
- { C(listen), &type_stringlist, validate_any },
+ { C(listen), &type_stringlist, validate_addrport },
{ C(lock), &type_boolean, validate_any },
{ C(mixer), &type_string, validate_ischr },
{ C(namepart), &type_namepart, 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(sample_format), &type_sample_format, validate_sample_format },
{ C(scratch), &type_string_accum, validate_isreg },
{ 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(transform), &type_transform, 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;
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;
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;
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;
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.byte_format = AO_FMT_NATIVE;
+ c->queue_pad = 10;
+ c->speaker_backend = -1;
return c;
}
return s;
}
+/** @brief Set the default configuration file */
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;
}
}
+/** @brief Set post-parse defaults */
static void config_postdefaults(struct config *c) {
struct config_state cs;
const struct conf *whoami;
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 API_ALSA
+ c->speaker_backend = BACKEND_ALSA;
+#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");
}
-/* re-read the config file */
+/** @brief (Re-)read the config file */
int config_read() {
struct config *c;
char *privconf;
return 0;
}
+/** @brief Return the path to the private configuration file */
char *config_private(void) {
char *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;
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();
fill-column:79
End:
*/
-/* arch-tag:ede19ed49dca6136ba864ed0a4988b34 */
~mdw / disorder / blobdiff