chiark / gitweb /
Update some copyright dates.
[disorder] / lib / configuration.c
CommitLineData
460b9539 1/*
2 * This file is part of DisOrder.
964e027d 3 * Copyright (C) 2004-2008 Richard Kettlewell
313acc77 4 * Portions copyright (C) 2007 Mark Wooding
460b9539 5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19 * USA
20 */
0e4472a0 21/** @file lib/configuration.c
22 * @brief Configuration file support
23 */
460b9539 24
25#include <config.h>
26#include "types.h"
27
28#include <stdio.h>
29#include <string.h>
30#include <stdlib.h>
31#include <errno.h>
32#include <sys/types.h>
33#include <sys/stat.h>
34#include <unistd.h>
35#include <ctype.h>
36#include <stddef.h>
37#include <pwd.h>
38#include <langinfo.h>
39#include <pcre.h>
40#include <signal.h>
41
04e1fa7c 42#include "rights.h"
460b9539 43#include "configuration.h"
44#include "mem.h"
45#include "log.h"
46#include "split.h"
47#include "syscalls.h"
48#include "table.h"
49#include "inputline.h"
50#include "charset.h"
51#include "defs.h"
52#include "mixer.h"
53#include "printf.h"
54#include "regsub.h"
55#include "signame.h"
637fdea3 56#include "authhash.h"
e6a35d1c 57#include "vector.h"
460b9539 58
3f3bb97b
RK
59/** @brief Path to config file
60 *
61 * set_configfile() sets the deafult if it is null.
62 */
460b9539 63char *configfile;
64
63ad732f
RK
65/** @brief Read user configuration
66 *
67 * If clear, the user-specific configuration is not read.
68 */
69int config_per_user = 1;
70
3f3bb97b 71/** @brief Config file parser state */
460b9539 72struct config_state {
3f3bb97b 73 /** @brief Filename */
460b9539 74 const char *path;
3f3bb97b 75 /** @brief Line number */
460b9539 76 int line;
3f3bb97b 77 /** @brief Configuration object under construction */
460b9539 78 struct config *config;
79};
80
3f3bb97b 81/** @brief Current configuration */
460b9539 82struct config *config;
83
3f3bb97b 84/** @brief One configuration item */
460b9539 85struct conf {
3f3bb97b 86 /** @brief Name as it appears in the config file */
460b9539 87 const char *name;
3f3bb97b 88 /** @brief Offset in @ref config structure */
460b9539 89 size_t offset;
3f3bb97b 90 /** @brief Pointer to item type */
460b9539 91 const struct conftype *type;
3f3bb97b 92 /** @brief Pointer to item-specific validation routine */
460b9539 93 int (*validate)(const struct config_state *cs,
94 int nvec, char **vec);
95};
96
3f3bb97b 97/** @brief Type of a configuration item */
460b9539 98struct conftype {
3f3bb97b 99 /** @brief Pointer to function to set item */
460b9539 100 int (*set)(const struct config_state *cs,
101 const struct conf *whoami,
102 int nvec, char **vec);
3f3bb97b 103 /** @brief Pointer to function to free item */
460b9539 104 void (*free)(struct config *c, const struct conf *whoami);
105};
106
3f3bb97b 107/** @brief Compute the address of an item */
460b9539 108#define ADDRESS(C, TYPE) ((TYPE *)((char *)(C) + whoami->offset))
3f3bb97b 109/** @brief Return the value of an item */
460b9539 110#define VALUE(C, TYPE) (*ADDRESS(C, TYPE))
111
112static int set_signal(const struct config_state *cs,
113 const struct conf *whoami,
114 int nvec, char **vec) {
115 int n;
116
117 if(nvec != 1) {
118 error(0, "%s:%d: '%s' requires one argument",
119 cs->path, cs->line, whoami->name);
120 return -1;
121 }
122 if((n = find_signal(vec[0])) == -1) {
123 error(0, "%s:%d: unknown signal '%s'",
124 cs->path, cs->line, vec[0]);
125 return -1;
126 }
127 VALUE(cs->config, int) = n;
128 return 0;
129}
130
131static int set_collections(const struct config_state *cs,
132 const struct conf *whoami,
133 int nvec, char **vec) {
134 struct collectionlist *cl;
01cef138 135 const char *root, *encoding, *module;
460b9539 136
01cef138
RK
137 switch(nvec) {
138 case 1:
139 module = 0;
140 encoding = 0;
141 root = vec[0];
142 break;
143 case 2:
144 module = vec[0];
145 encoding = 0;
146 root = vec[1];
147 break;
148 case 3:
149 module = vec[0];
150 encoding = vec[1];
151 root = vec[2];
152 break;
153 case 0:
154 error(0, "%s:%d: '%s' requires at least one argument",
155 cs->path, cs->line, whoami->name);
156 return -1;
157 default:
158 error(0, "%s:%d: '%s' requires at most three arguments",
460b9539 159 cs->path, cs->line, whoami->name);
160 return -1;
161 }
01cef138
RK
162 /* Sanity check root */
163 if(root[0] != '/') {
460b9539 164 error(0, "%s:%d: collection root must start with '/'",
165 cs->path, cs->line);
166 return -1;
167 }
01cef138 168 if(root[1] && root[strlen(root)-1] == '/') {
460b9539 169 error(0, "%s:%d: collection root must not end with '/'",
170 cs->path, cs->line);
171 return -1;
172 }
01cef138
RK
173 /* Defaults */
174 if(!module)
175 module = "fs";
176 if(!encoding)
177 encoding = nl_langinfo(CODESET);
460b9539 178 cl = ADDRESS(cs->config, struct collectionlist);
179 ++cl->n;
180 cl->s = xrealloc(cl->s, cl->n * sizeof (struct collection));
01cef138
RK
181 cl->s[cl->n - 1].module = xstrdup(module);
182 cl->s[cl->n - 1].encoding = xstrdup(encoding);
183 cl->s[cl->n - 1].root = xstrdup(root);
460b9539 184 return 0;
185}
186
187static int set_boolean(const struct config_state *cs,
188 const struct conf *whoami,
189 int nvec, char **vec) {
190 int state;
191
192 if(nvec != 1) {
193 error(0, "%s:%d: '%s' takes only one argument",
194 cs->path, cs->line, whoami->name);
195 return -1;
196 }
197 if(!strcmp(vec[0], "yes")) state = 1;
198 else if(!strcmp(vec[0], "no")) state = 0;
199 else {
200 error(0, "%s:%d: argument to '%s' must be 'yes' or 'no'",
201 cs->path, cs->line, whoami->name);
202 return -1;
203 }
204 VALUE(cs->config, int) = state;
205 return 0;
206}
207
208static int set_string(const struct config_state *cs,
209 const struct conf *whoami,
210 int nvec, char **vec) {
211 if(nvec != 1) {
212 error(0, "%s:%d: '%s' takes only one argument",
213 cs->path, cs->line, whoami->name);
214 return -1;
215 }
216 VALUE(cs->config, char *) = xstrdup(vec[0]);
217 return 0;
218}
219
220static int set_stringlist(const struct config_state *cs,
221 const struct conf *whoami,
222 int nvec, char **vec) {
223 int n;
224 struct stringlist *sl;
225
226 sl = ADDRESS(cs->config, struct stringlist);
227 sl->n = 0;
228 for(n = 0; n < nvec; ++n) {
229 sl->n++;
230 sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));
231 sl->s[sl->n - 1] = xstrdup(vec[n]);
232 }
233 return 0;
234}
235
236static int set_integer(const struct config_state *cs,
237 const struct conf *whoami,
238 int nvec, char **vec) {
239 char *e;
240
241 if(nvec != 1) {
242 error(0, "%s:%d: '%s' takes only one argument",
243 cs->path, cs->line, whoami->name);
244 return -1;
245 }
246 if(xstrtol(ADDRESS(cs->config, long), vec[0], &e, 0)) {
247 error(errno, "%s:%d: converting integer", cs->path, cs->line);
248 return -1;
249 }
250 if(*e) {
251 error(0, "%s:%d: invalid integer syntax", cs->path, cs->line);
252 return -1;
253 }
254 return 0;
255}
256
257static int set_stringlist_accum(const struct config_state *cs,
258 const struct conf *whoami,
259 int nvec, char **vec) {
260 int n;
261 struct stringlist *s;
262 struct stringlistlist *sll;
263
264 sll = ADDRESS(cs->config, struct stringlistlist);
40c30921
RK
265 if(nvec == 0) {
266 sll->n = 0;
267 return 0;
268 }
460b9539 269 sll->n++;
270 sll->s = xrealloc(sll->s, (sll->n * sizeof (struct stringlist)));
271 s = &sll->s[sll->n - 1];
272 s->n = nvec;
273 s->s = xmalloc((nvec + 1) * sizeof (char *));
274 for(n = 0; n < nvec; ++n)
275 s->s[n] = xstrdup(vec[n]);
276 return 0;
277}
278
279static int set_string_accum(const struct config_state *cs,
280 const struct conf *whoami,
281 int nvec, char **vec) {
282 int n;
283 struct stringlist *sl;
284
285 sl = ADDRESS(cs->config, struct stringlist);
40c30921
RK
286 if(nvec == 0) {
287 sl->n = 0;
288 return 0;
289 }
460b9539 290 for(n = 0; n < nvec; ++n) {
291 sl->n++;
292 sl->s = xrealloc(sl->s, (sl->n * sizeof (char *)));
293 sl->s[sl->n - 1] = xstrdup(vec[n]);
294 }
295 return 0;
296}
297
298static int set_restrict(const struct config_state *cs,
299 const struct conf *whoami,
300 int nvec, char **vec) {
301 unsigned r = 0;
302 int n, i;
303
304 static const struct restriction {
305 const char *name;
306 unsigned bit;
307 } restrictions[] = {
308 { "remove", RESTRICT_REMOVE },
309 { "scratch", RESTRICT_SCRATCH },
310 { "move", RESTRICT_MOVE },
311 };
312
313 for(n = 0; n < nvec; ++n) {
314 if((i = TABLE_FIND(restrictions, struct restriction, name, vec[n])) < 0) {
315 error(0, "%s:%d: invalid restriction '%s'",
316 cs->path, cs->line, vec[n]);
317 return -1;
318 }
319 r |= restrictions[i].bit;
320 }
321 VALUE(cs->config, unsigned) = r;
322 return 0;
323}
324
9d5da576 325static int parse_sample_format(const struct config_state *cs,
6d2d327c 326 struct stream_header *format,
9d5da576 327 int nvec, char **vec) {
328 char *p = vec[0];
329 long t;
330
6d2d327c 331 if(nvec != 1) {
9d5da576 332 error(0, "%s:%d: wrong number of arguments", cs->path, cs->line);
333 return -1;
334 }
6d2d327c 335 if(xstrtol(&t, p, &p, 0)) {
9d5da576 336 error(errno, "%s:%d: converting bits-per-sample", cs->path, cs->line);
337 return -1;
338 }
6d2d327c 339 if(t != 8 && t != 16) {
9d5da576 340 error(0, "%s:%d: bad bite-per-sample (%ld)", cs->path, cs->line, t);
341 return -1;
342 }
6d2d327c 343 if(format) format->bits = t;
9d5da576 344 switch (*p) {
6d2d327c
RK
345 case 'l': case 'L': t = ENDIAN_LITTLE; p++; break;
346 case 'b': case 'B': t = ENDIAN_BIG; p++; break;
347 default: t = ENDIAN_NATIVE; break;
9d5da576 348 }
6d2d327c
RK
349 if(format) format->endian = t;
350 if(*p != '/') {
9d5da576 351 error(errno, "%s:%d: expected `/' after bits-per-sample",
352 cs->path, cs->line);
353 return -1;
354 }
355 p++;
6d2d327c 356 if(xstrtol(&t, p, &p, 0)) {
9d5da576 357 error(errno, "%s:%d: converting sample-rate", cs->path, cs->line);
358 return -1;
359 }
6d2d327c 360 if(t < 1 || t > INT_MAX) {
9d5da576 361 error(0, "%s:%d: silly sample-rate (%ld)", cs->path, cs->line, t);
362 return -1;
363 }
6d2d327c
RK
364 if(format) format->rate = t;
365 if(*p != '/') {
9d5da576 366 error(0, "%s:%d: expected `/' after sample-rate",
367 cs->path, cs->line);
368 return -1;
369 }
370 p++;
6d2d327c 371 if(xstrtol(&t, p, &p, 0)) {
9d5da576 372 error(errno, "%s:%d: converting channels", cs->path, cs->line);
373 return -1;
374 }
6d2d327c 375 if(t < 1 || t > 8) {
9d5da576 376 error(0, "%s:%d: silly number (%ld) of channels", cs->path, cs->line, t);
377 return -1;
378 }
6d2d327c
RK
379 if(format) format->channels = t;
380 if(*p) {
9d5da576 381 error(0, "%s:%d: junk after channels", cs->path, cs->line);
382 return -1;
383 }
384 return 0;
385}
386
387static int set_sample_format(const struct config_state *cs,
388 const struct conf *whoami,
389 int nvec, char **vec) {
6d2d327c 390 return parse_sample_format(cs, ADDRESS(cs->config, struct stream_header),
9d5da576 391 nvec, vec);
392}
393
460b9539 394static int set_namepart(const struct config_state *cs,
395 const struct conf *whoami,
396 int nvec, char **vec) {
397 struct namepartlist *npl = ADDRESS(cs->config, struct namepartlist);
398 unsigned reflags;
399 const char *errstr;
400 int erroffset, n;
401 pcre *re;
402
403 if(nvec < 3) {
404 error(0, "%s:%d: namepart needs at least 3 arguments", cs->path, cs->line);
405 return -1;
406 }
407 if(nvec > 5) {
408 error(0, "%s:%d: namepart needs at most 5 arguments", cs->path, cs->line);
409 return -1;
410 }
411 reflags = nvec >= 5 ? regsub_flags(vec[4]) : 0;
412 if(!(re = pcre_compile(vec[1],
413 PCRE_UTF8
414 |regsub_compile_options(reflags),
415 &errstr, &erroffset, 0))) {
416 error(0, "%s:%d: error compiling regexp /%s/: %s (offset %d)",
417 cs->path, cs->line, vec[1], errstr, erroffset);
418 return -1;
419 }
420 npl->s = xrealloc(npl->s, (npl->n + 1) * sizeof (struct namepart));
421 npl->s[npl->n].part = xstrdup(vec[0]);
422 npl->s[npl->n].re = re;
423 npl->s[npl->n].replace = xstrdup(vec[2]);
424 npl->s[npl->n].context = xstrdup(vec[3]);
425 npl->s[npl->n].reflags = reflags;
426 ++npl->n;
427 /* XXX a bit of a bodge; relies on there being very few parts. */
428 for(n = 0; (n < cs->config->nparts
429 && strcmp(cs->config->parts[n], vec[0])); ++n)
430 ;
431 if(n >= cs->config->nparts) {
432 cs->config->parts = xrealloc(cs->config->parts,
433 (cs->config->nparts + 1) * sizeof (char *));
434 cs->config->parts[cs->config->nparts++] = xstrdup(vec[0]);
435 }
436 return 0;
437}
438
439static int set_transform(const struct config_state *cs,
440 const struct conf *whoami,
441 int nvec, char **vec) {
442 struct transformlist *tl = ADDRESS(cs->config, struct transformlist);
443 pcre *re;
444 unsigned reflags;
445 const char *errstr;
446 int erroffset;
447
448 if(nvec < 3) {
449 error(0, "%s:%d: transform needs at least 3 arguments", cs->path, cs->line);
450 return -1;
451 }
452 if(nvec > 5) {
453 error(0, "%s:%d: transform needs at most 5 arguments", cs->path, cs->line);
454 return -1;
455 }
456 reflags = (nvec >= 5 ? regsub_flags(vec[4]) : 0);
457 if(!(re = pcre_compile(vec[1],
458 PCRE_UTF8
459 |regsub_compile_options(reflags),
460 &errstr, &erroffset, 0))) {
461 error(0, "%s:%d: error compiling regexp /%s/: %s (offset %d)",
462 cs->path, cs->line, vec[1], errstr, erroffset);
463 return -1;
464 }
465 tl->t = xrealloc(tl->t, (tl->n + 1) * sizeof (struct namepart));
466 tl->t[tl->n].type = xstrdup(vec[0]);
467 tl->t[tl->n].context = xstrdup(vec[3] ? vec[3] : "*");
468 tl->t[tl->n].re = re;
469 tl->t[tl->n].replace = xstrdup(vec[2]);
470 tl->t[tl->n].flags = reflags;
471 ++tl->n;
472 return 0;
473}
474
e83d0967
RK
475static int set_backend(const struct config_state *cs,
476 const struct conf *whoami,
477 int nvec, char **vec) {
478 int *const valuep = ADDRESS(cs->config, int);
479
480 if(nvec != 1) {
481 error(0, "%s:%d: '%s' requires one argument",
482 cs->path, cs->line, whoami->name);
483 return -1;
484 }
485 if(!strcmp(vec[0], "alsa")) {
146e86fb 486#if HAVE_ALSA_ASOUNDLIB_H
e83d0967
RK
487 *valuep = BACKEND_ALSA;
488#else
489 error(0, "%s:%d: ALSA is not available on this platform",
490 cs->path, cs->line);
491 return -1;
492#endif
493 } else if(!strcmp(vec[0], "command"))
494 *valuep = BACKEND_COMMAND;
495 else if(!strcmp(vec[0], "network"))
496 *valuep = BACKEND_NETWORK;
937be4c0
RK
497 else if(!strcmp(vec[0], "coreaudio")) {
498#if HAVE_COREAUDIO_AUDIOHARDWARE_H
499 *valuep = BACKEND_COREAUDIO;
500#else
501 error(0, "%s:%d: Core Audio is not available on this platform",
502 cs->path, cs->line);
503 return -1;
504#endif
e99d42b1 505 } else if(!strcmp(vec[0], "oss")) {
506#if HAVE_SYS_SOUNDCARD_H
507 *valuep = BACKEND_OSS;
508#else
509 error(0, "%s:%d: OSS is not available on this platform",
510 cs->path, cs->line);
511 return -1;
512#endif
937be4c0 513 } else {
e83d0967
RK
514 error(0, "%s:%d: invalid '%s' value '%s'",
515 cs->path, cs->line, whoami->name, vec[0]);
516 return -1;
517 }
518 return 0;
519}
520
04e1fa7c
RK
521static int set_rights(const struct config_state *cs,
522 const struct conf *whoami,
523 int nvec, char **vec) {
04e1fa7c
RK
524 if(nvec != 1) {
525 error(0, "%s:%d: '%s' requires one argument",
526 cs->path, cs->line, whoami->name);
527 return -1;
528 }
0f55e905 529 if(parse_rights(vec[0], 0, 1)) {
04e1fa7c
RK
530 error(0, "%s:%d: invalid rights string '%s'",
531 cs->path, cs->line, vec[0]);
532 return -1;
533 }
0f55e905 534 *ADDRESS(cs->config, char *) = vec[0];
04e1fa7c
RK
535 return 0;
536}
537
460b9539 538/* free functions */
539
540static void free_none(struct config attribute((unused)) *c,
541 const struct conf attribute((unused)) *whoami) {
542}
543
544static void free_string(struct config *c,
545 const struct conf *whoami) {
546 xfree(VALUE(c, char *));
547}
548
549static void free_stringlist(struct config *c,
550 const struct conf *whoami) {
551 int n;
552 struct stringlist *sl = ADDRESS(c, struct stringlist);
553
554 for(n = 0; n < sl->n; ++n)
555 xfree(sl->s[n]);
556 xfree(sl->s);
557}
558
559static void free_stringlistlist(struct config *c,
560 const struct conf *whoami) {
561 int n, m;
562 struct stringlistlist *sll = ADDRESS(c, struct stringlistlist);
563 struct stringlist *sl;
564
565 for(n = 0; n < sll->n; ++n) {
566 sl = &sll->s[n];
567 for(m = 0; m < sl->n; ++m)
568 xfree(sl->s[m]);
569 xfree(sl->s);
570 }
571 xfree(sll->s);
572}
573
574static void free_collectionlist(struct config *c,
575 const struct conf *whoami) {
576 struct collectionlist *cll = ADDRESS(c, struct collectionlist);
577 struct collection *cl;
578 int n;
579
580 for(n = 0; n < cll->n; ++n) {
581 cl = &cll->s[n];
582 xfree(cl->module);
583 xfree(cl->encoding);
584 xfree(cl->root);
585 }
586 xfree(cll->s);
587}
588
589static void free_namepartlist(struct config *c,
590 const struct conf *whoami) {
591 struct namepartlist *npl = ADDRESS(c, struct namepartlist);
592 struct namepart *np;
593 int n;
594
595 for(n = 0; n < npl->n; ++n) {
596 np = &npl->s[n];
597 xfree(np->part);
598 pcre_free(np->re); /* ...whatever pcre_free is set to. */
599 xfree(np->replace);
600 xfree(np->context);
601 }
602 xfree(npl->s);
603}
604
605static void free_transformlist(struct config *c,
606 const struct conf *whoami) {
607 struct transformlist *tl = ADDRESS(c, struct transformlist);
608 struct transform *t;
609 int n;
610
611 for(n = 0; n < tl->n; ++n) {
612 t = &tl->t[n];
613 xfree(t->type);
614 pcre_free(t->re); /* ...whatever pcre_free is set to. */
615 xfree(t->replace);
616 xfree(t->context);
617 }
618 xfree(tl->t);
619}
620
621/* configuration types */
622
623static const struct conftype
624 type_signal = { set_signal, free_none },
625 type_collections = { set_collections, free_collectionlist },
626 type_boolean = { set_boolean, free_none },
627 type_string = { set_string, free_string },
628 type_stringlist = { set_stringlist, free_stringlist },
629 type_integer = { set_integer, free_none },
630 type_stringlist_accum = { set_stringlist_accum, free_stringlistlist },
631 type_string_accum = { set_string_accum, free_stringlist },
9d5da576 632 type_sample_format = { set_sample_format, free_none },
460b9539 633 type_restrict = { set_restrict, free_none },
634 type_namepart = { set_namepart, free_namepartlist },
e83d0967 635 type_transform = { set_transform, free_transformlist },
04e1fa7c 636 type_rights = { set_rights, free_none },
e83d0967 637 type_backend = { set_backend, free_none };
460b9539 638
639/* specific validation routine */
640
641#define VALIDATE_FILE(test, what) do { \
642 struct stat sb; \
643 int n; \
644 \
645 for(n = 0; n < nvec; ++n) { \
646 if(stat(vec[n], &sb) < 0) { \
647 error(errno, "%s:%d: %s", cs->path, cs->line, vec[n]); \
648 return -1; \
649 } \
650 if(!test(sb.st_mode)) { \
651 error(0, "%s:%d: %s is not a %s", \
652 cs->path, cs->line, vec[n], what); \
653 return -1; \
654 } \
655 } \
656} while(0)
657
659d87e8
RK
658static int validate_isabspath(const struct config_state *cs,
659 int nvec, char **vec) {
660 int n;
661
662 for(n = 0; n < nvec; ++n)
663 if(vec[n][0] != '/') {
664 error(errno, "%s:%d: %s: not an absolute path",
665 cs->path, cs->line, vec[n]);
666 return -1;
667 }
668 return 0;
669}
670
460b9539 671static int validate_isdir(const struct config_state *cs,
672 int nvec, char **vec) {
673 VALIDATE_FILE(S_ISDIR, "directory");
674 return 0;
675}
676
677static int validate_isreg(const struct config_state *cs,
678 int nvec, char **vec) {
679 VALIDATE_FILE(S_ISREG, "regular file");
680 return 0;
681}
682
460b9539 683static int validate_player(const struct config_state *cs,
684 int nvec,
685 char attribute((unused)) **vec) {
686 if(nvec < 2) {
687 error(0, "%s:%d: should be at least 'player PATTERN MODULE'",
688 cs->path, cs->line);
689 return -1;
690 }
691 return 0;
692}
693
62dc3748
RK
694static int validate_tracklength(const struct config_state *cs,
695 int nvec,
696 char attribute((unused)) **vec) {
697 if(nvec < 2) {
698 error(0, "%s:%d: should be at least 'tracklength PATTERN MODULE'",
699 cs->path, cs->line);
700 return -1;
701 }
702 return 0;
703}
704
460b9539 705static int validate_allow(const struct config_state *cs,
706 int nvec,
707 char attribute((unused)) **vec) {
708 if(nvec != 2) {
709 error(0, "%s:%d: must be 'allow NAME PASS'", cs->path, cs->line);
710 return -1;
711 }
712 return 0;
713}
714
715static int validate_non_negative(const struct config_state *cs,
716 int nvec, char **vec) {
717 long n;
718
719 if(nvec < 1) {
720 error(0, "%s:%d: missing argument", cs->path, cs->line);
721 return -1;
722 }
723 if(nvec > 1) {
724 error(0, "%s:%d: too many arguments", cs->path, cs->line);
725 return -1;
726 }
727 if(xstrtol(&n, vec[0], 0, 0)) {
728 error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
729 return -1;
730 }
731 if(n < 0) {
732 error(0, "%s:%d: must not be negative", cs->path, cs->line);
733 return -1;
734 }
735 return 0;
736}
737
738static int validate_positive(const struct config_state *cs,
739 int nvec, char **vec) {
740 long n;
741
742 if(nvec < 1) {
743 error(0, "%s:%d: missing argument", cs->path, cs->line);
744 return -1;
745 }
746 if(nvec > 1) {
747 error(0, "%s:%d: too many arguments", cs->path, cs->line);
748 return -1;
749 }
750 if(xstrtol(&n, vec[0], 0, 0)) {
751 error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
752 return -1;
753 }
754 if(n <= 0) {
755 error(0, "%s:%d: must be positive", cs->path, cs->line);
756 return -1;
757 }
758 return 0;
759}
760
761static int validate_isauser(const struct config_state *cs,
762 int attribute((unused)) nvec,
763 char **vec) {
764 struct passwd *pw;
765
766 if(!(pw = getpwnam(vec[0]))) {
767 error(0, "%s:%d: no such user as '%s'", cs->path, cs->line, vec[0]);
768 return -1;
769 }
770 return 0;
771}
772
9d5da576 773static int validate_sample_format(const struct config_state *cs,
774 int attribute((unused)) nvec,
775 char **vec) {
776 return parse_sample_format(cs, 0, nvec, vec);
777}
778
460b9539 779static int validate_any(const struct config_state attribute((unused)) *cs,
780 int attribute((unused)) nvec,
781 char attribute((unused)) **vec) {
782 return 0;
783}
784
785static int validate_url(const struct config_state attribute((unused)) *cs,
786 int attribute((unused)) nvec,
787 char **vec) {
788 const char *s;
789 int n;
790 /* absoluteURI = scheme ":" ( hier_part | opaque_part )
791 scheme = alpha *( alpha | digit | "+" | "-" | "." ) */
792 s = vec[0];
793 n = strspn(s, ("abcdefghijklmnopqrstuvwxyz"
794 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
795 "0123456789"));
796 if(s[n] != ':') {
797 error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
798 return -1;
799 }
800 if(!strncmp(s, "http:", 5)
801 || !strncmp(s, "https:", 6)) {
802 s += n + 1;
803 /* we only do a rather cursory check */
804 if(strncmp(s, "//", 2)) {
805 error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
806 return -1;
807 }
808 }
809 return 0;
810}
811
812static int validate_alias(const struct config_state *cs,
813 int nvec,
814 char **vec) {
815 const char *s;
816 int in_brackets = 0, c;
817
818 if(nvec < 1) {
819 error(0, "%s:%d: missing argument", cs->path, cs->line);
820 return -1;
821 }
822 if(nvec > 1) {
823 error(0, "%s:%d: too many arguments", cs->path, cs->line);
824 return -1;
825 }
826 s = vec[0];
827 while((c = (unsigned char)*s++)) {
828 if(in_brackets) {
829 if(c == '}')
830 in_brackets = 0;
831 else if(!isalnum(c)) {
832 error(0, "%s:%d: invalid part name in alias expansion in '%s'",
833 cs->path, cs->line, vec[0]);
834 return -1;
835 }
836 } else {
837 if(c == '{') {
838 in_brackets = 1;
839 if(*s == '/')
840 ++s;
841 } else if(c == '\\') {
842 if(!(c = (unsigned char)*s++)) {
843 error(0, "%s:%d: unterminated escape in alias expansion in '%s'",
844 cs->path, cs->line, vec[0]);
845 return -1;
846 } else if(c != '\\' && c != '{') {
847 error(0, "%s:%d: invalid escape in alias expansion in '%s'",
848 cs->path, cs->line, vec[0]);
849 return -1;
850 }
851 }
852 }
853 ++s;
854 }
855 if(in_brackets) {
856 error(0, "%s:%d: unterminated part name in alias expansion in '%s'",
857 cs->path, cs->line, vec[0]);
858 return -1;
859 }
860 return 0;
861}
862
e83d0967
RK
863static int validate_addrport(const struct config_state attribute((unused)) *cs,
864 int nvec,
865 char attribute((unused)) **vec) {
866 switch(nvec) {
867 case 0:
868 error(0, "%s:%d: missing address",
869 cs->path, cs->line);
870 return -1;
871 case 1:
872 error(0, "%s:%d: missing port name/number",
873 cs->path, cs->line);
874 return -1;
875 case 2:
876 return 0;
877 default:
878 error(0, "%s:%d: expected ADDRESS PORT",
879 cs->path, cs->line);
880 return -1;
881 }
882}
883
ccf0aafa 884static int validate_port(const struct config_state attribute((unused)) *cs,
e83d0967
RK
885 int nvec,
886 char attribute((unused)) **vec) {
887 switch(nvec) {
888 case 0:
889 error(0, "%s:%d: missing address",
890 cs->path, cs->line);
891 return -1;
892 case 1:
893 case 2:
894 return 0;
895 default:
ccf0aafa 896 error(0, "%s:%d: expected [ADDRESS] PORT",
e83d0967
RK
897 cs->path, cs->line);
898 return -1;
899 }
900}
901
637fdea3
RK
902static int validate_algo(const struct config_state attribute((unused)) *cs,
903 int nvec,
904 char **vec) {
905 if(nvec != 1) {
906 error(0, "%s:%d: invalid algorithm specification", cs->path, cs->line);
907 return -1;
908 }
909 if(!valid_authhash(vec[0])) {
910 error(0, "%s:%d: unsuported algorithm '%s'", cs->path, cs->line, vec[0]);
911 return -1;
912 }
913 return 0;
914}
915
3f3bb97b 916/** @brief Item name and and offset */
460b9539 917#define C(x) #x, offsetof(struct config, x)
3f3bb97b 918/** @brief Item name and and offset */
460b9539 919#define C2(x,y) #x, offsetof(struct config, y)
920
3f3bb97b 921/** @brief All configuration items */
460b9539 922static const struct conf conf[] = {
923 { C(alias), &type_string, validate_alias },
924 { C(allow), &type_stringlist_accum, validate_allow },
bd8895a8 925 { C(api), &type_backend, validate_any },
637fdea3 926 { C(authorization_algorithm), &type_string, validate_algo },
e83d0967 927 { C(broadcast), &type_stringlist, validate_addrport },
ccf0aafa 928 { C(broadcast_from), &type_stringlist, validate_addrport },
bd8895a8 929 { C(channel), &type_string, validate_any },
460b9539 930 { C(checkpoint_kbyte), &type_integer, validate_non_negative },
931 { C(checkpoint_min), &type_integer, validate_non_negative },
932 { C(collection), &type_collections, validate_any },
e83d0967 933 { C(connect), &type_stringlist, validate_addrport },
b12be54a
RK
934 { C(cookie_login_lifetime), &type_integer, validate_positive },
935 { C(cookie_key_lifetime), &type_integer, validate_positive },
8818b7fc 936 { C(dbversion), &type_integer, validate_positive },
04e1fa7c 937 { C(default_rights), &type_rights, validate_any },
460b9539 938 { C(device), &type_string, validate_any },
939 { C(gap), &type_integer, validate_non_negative },
940 { C(history), &type_integer, validate_positive },
659d87e8 941 { C(home), &type_string, validate_isabspath },
ccf0aafa 942 { C(listen), &type_stringlist, validate_port },
460b9539 943 { C(lock), &type_boolean, validate_any },
bb6ae3fb 944 { C(mail_sender), &type_string, validate_any },
bd8895a8 945 { C(mixer), &type_string, validate_any },
61941295 946 { C(multicast_loop), &type_boolean, validate_any },
23205f9c 947 { C(multicast_ttl), &type_integer, validate_non_negative },
460b9539 948 { C(namepart), &type_namepart, validate_any },
d742bb47 949 { C(new_max), &type_integer, validate_positive },
460b9539 950 { C2(nice, nice_rescan), &type_integer, validate_non_negative },
951 { C(nice_rescan), &type_integer, validate_non_negative },
952 { C(nice_server), &type_integer, validate_any },
953 { C(nice_speaker), &type_integer, validate_any },
2a10b70b 954 { C(noticed_history), &type_integer, validate_positive },
460b9539 955 { C(password), &type_string, validate_any },
956 { C(player), &type_stringlist_accum, validate_player },
957 { C(plugins), &type_string_accum, validate_isdir },
958 { C(prefsync), &type_integer, validate_positive },
459d4402 959 { C(queue_pad), &type_integer, validate_positive },
460b9539 960 { C(refresh), &type_integer, validate_positive },
961 { C2(restrict, restrictions), &type_restrict, validate_any },
9d5da576 962 { C(sample_format), &type_sample_format, validate_sample_format },
460b9539 963 { C(scratch), &type_string_accum, validate_isreg },
61507e3c 964 { C(short_display), &type_integer, validate_positive },
460b9539 965 { C(signal), &type_signal, validate_any },
bb6ae3fb 966 { C(smtp_server), &type_string, validate_any },
5330d674 967 { C(sox_generation), &type_integer, validate_non_negative },
bd8895a8 968 { C2(speaker_backend, api), &type_backend, validate_any },
9d5da576 969 { C(speaker_command), &type_string, validate_any },
460b9539 970 { C(stopword), &type_string_accum, validate_any },
971 { C(templates), &type_string_accum, validate_isdir },
62dc3748 972 { C(tracklength), &type_stringlist_accum, validate_tracklength },
460b9539 973 { C(transform), &type_transform, validate_any },
974 { C(trust), &type_string_accum, validate_any },
975 { C(url), &type_string, validate_url },
976 { C(user), &type_string, validate_isauser },
977 { C(username), &type_string, validate_any },
978};
979
3f3bb97b 980/** @brief Find a configuration item's definition by key */
460b9539 981static const struct conf *find(const char *key) {
982 int n;
983
984 if((n = TABLE_FIND(conf, struct conf, name, key)) < 0)
985 return 0;
986 return &conf[n];
987}
988
3f3bb97b 989/** @brief Set a new configuration value */
460b9539 990static int config_set(const struct config_state *cs,
991 int nvec, char **vec) {
992 const struct conf *which;
993
994 D(("config_set %s", vec[0]));
995 if(!(which = find(vec[0]))) {
996 error(0, "%s:%d: unknown configuration key '%s'",
997 cs->path, cs->line, vec[0]);
998 return -1;
999 }
1000 return (which->validate(cs, nvec - 1, vec + 1)
1001 || which->type->set(cs, which, nvec - 1, vec + 1));
1002}
1003
e6a35d1c
RK
1004static int config_set_args(const struct config_state *cs,
1005 const char *which, ...) {
1006 va_list ap;
1007 struct vector v[1];
1008 char *s;
1009
1010 vector_init(v);
1011 vector_append(v, (char *)which);
1012 va_start(ap, which);
1013 while((s = va_arg(ap, char *)))
1014 vector_append(v, s);
1015 va_end(ap);
1016 vector_terminate(v);
1017 return config_set(cs, v->nvec, v->vec);
1018}
1019
0e4472a0 1020/** @brief Error callback used by config_include() */
460b9539 1021static void config_error(const char *msg, void *u) {
1022 const struct config_state *cs = u;
1023
1024 error(0, "%s:%d: %s", cs->path, cs->line, msg);
1025}
1026
3f3bb97b 1027/** @brief Include a file by name */
460b9539 1028static int config_include(struct config *c, const char *path) {
1029 FILE *fp;
1030 char *buffer, *inputbuffer, **vec;
1031 int n, ret = 0;
1032 struct config_state cs;
1033
1034 cs.path = path;
1035 cs.line = 0;
1036 cs.config = c;
1037 D(("%s: reading configuration", path));
1038 if(!(fp = fopen(path, "r"))) {
1039 error(errno, "error opening %s", path);
1040 return -1;
1041 }
1042 while(!inputline(path, fp, &inputbuffer, '\n')) {
1043 ++cs.line;
1044 if(!(buffer = mb2utf8(inputbuffer))) {
1045 error(errno, "%s:%d: cannot convert to UTF-8", cs.path, cs.line);
1046 ret = -1;
1047 xfree(inputbuffer);
1048 continue;
1049 }
1050 xfree(inputbuffer);
1051 if(!(vec = split(buffer, &n, SPLIT_COMMENTS|SPLIT_QUOTES,
1052 config_error, &cs))) {
1053 ret = -1;
1054 xfree(buffer);
1055 continue;
1056 }
1057 if(n) {
1058 if(!strcmp(vec[0], "include")) {
1059 if(n != 2) {
1060 error(0, "%s:%d: must be 'include PATH'", cs.path, cs.line);
1061 ret = -1;
1062 } else
1063 config_include(c, vec[1]);
1064 } else
1065 ret |= config_set(&cs, n, vec);
1066 }
1067 for(n = 0; vec[n]; ++n) xfree(vec[n]);
1068 xfree(vec);
1069 xfree(buffer);
1070 }
1071 if(ferror(fp)) {
1072 error(errno, "error reading %s", path);
1073 ret = -1;
1074 }
1075 fclose(fp);
1076 return ret;
1077}
1078
86be0c30 1079static const char *const default_stopwords[] = {
1080 "stopword",
1081
1082 "01",
1083 "02",
1084 "03",
1085 "04",
1086 "05",
1087 "06",
1088 "07",
1089 "08",
1090 "09",
1091 "1",
1092 "10",
1093 "11",
1094 "12",
1095 "13",
1096 "14",
1097 "15",
1098 "16",
1099 "17",
1100 "18",
1101 "19",
1102 "2",
1103 "20",
1104 "21",
1105 "22",
1106 "23",
1107 "24",
1108 "25",
1109 "26",
1110 "27",
1111 "28",
1112 "29",
1113 "3",
1114 "30",
1115 "4",
1116 "5",
1117 "6",
1118 "7",
1119 "8",
1120 "9",
1121 "a",
1122 "am",
1123 "an",
1124 "and",
1125 "as",
1126 "for",
1127 "i",
1128 "im",
1129 "in",
1130 "is",
1131 "of",
1132 "on",
1133 "the",
1134 "to",
1135 "too",
1136 "we",
1137};
1138#define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
1139
e6a35d1c
RK
1140static const char *const default_players[] = {
1141 "*.ogg",
1142 "*.flac",
1143 "*.mp3",
1144 "*.wav",
1145};
1146#define NDEFAULT_PLAYERS (sizeof default_players / sizeof *default_players)
1147
3f3bb97b 1148/** @brief Make a new default configuration */
460b9539 1149static struct config *config_default(void) {
1150 struct config *c = xmalloc(sizeof *c);
1151 const char *logname;
1152 struct passwd *pw;
86be0c30 1153 struct config_state cs;
e6a35d1c 1154 size_t n;
460b9539 1155
86be0c30 1156 cs.path = "<internal>";
1157 cs.line = 0;
1158 cs.config = c;
460b9539 1159 /* Strings had better be xstrdup'd as they will get freed at some point. */
07bc035e 1160 c->gap = 0;
460b9539 1161 c->history = 60;
1162 c->home = xstrdup(pkgstatedir);
1163 if(!(pw = getpwuid(getuid())))
1164 fatal(0, "cannot determine our username");
1165 logname = pw->pw_name;
1166 c->username = xstrdup(logname);
1167 c->refresh = 15;
1168 c->prefsync = 3600;
1169 c->signal = SIGKILL;
1170 c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
1171 c->lock = 1;
1172 c->device = xstrdup("default");
1173 c->nice_rescan = 10;
9d5da576 1174 c->speaker_command = 0;
1175 c->sample_format.bits = 16;
1176 c->sample_format.rate = 44100;
1177 c->sample_format.channels = 2;
6d2d327c 1178 c->sample_format.endian = ENDIAN_NATIVE;
459d4402 1179 c->queue_pad = 10;
bd8895a8 1180 c->api = -1;
23205f9c 1181 c->multicast_ttl = 1;
61941295 1182 c->multicast_loop = 1;
637fdea3 1183 c->authorization_algorithm = xstrdup("sha1");
2a10b70b 1184 c->noticed_history = 31;
61507e3c 1185 c->short_display = 32;
bd8895a8 1186 c->mixer = 0;
1187 c->channel = 0;
8818b7fc 1188 c->dbversion = 2;
b12be54a
RK
1189 c->cookie_login_lifetime = 86400;
1190 c->cookie_key_lifetime = 86400 * 7;
bb6ae3fb 1191 c->smtp_server = xstrdup("127.0.0.1");
d742bb47 1192 c->new_max = 100;
e6a35d1c 1193 /* Default stopwords */
86be0c30 1194 if(config_set(&cs, (int)NDEFAULT_STOPWORDS, (char **)default_stopwords))
1195 exit(1);
e6a35d1c
RK
1196 /* Default player configuration */
1197 for(n = 0; n < NDEFAULT_PLAYERS; ++n) {
1198 if(config_set_args(&cs, "player",
1199 default_players[n], "execraw", "disorder-decode", (char *)0))
1200 exit(1);
1201 if(config_set_args(&cs, "tracklength",
1202 default_players[n], "disorder-tracklength", (char *)0))
1203 exit(1);
1204 }
460b9539 1205 return c;
1206}
1207
1208static char *get_file(struct config *c, const char *name) {
1209 char *s;
1210
1211 byte_xasprintf(&s, "%s/%s", c->home, name);
1212 return s;
1213}
1214
3f3bb97b 1215/** @brief Set the default configuration file */
460b9539 1216static void set_configfile(void) {
1217 if(!configfile)
1218 byte_xasprintf(&configfile, "%s/config", pkgconfdir);
1219}
1220
3f3bb97b 1221/** @brief Free a configuration object */
460b9539 1222static void config_free(struct config *c) {
1223 int n;
1224
1225 if(c) {
1226 for(n = 0; n < (int)(sizeof conf / sizeof *conf); ++n)
1227 conf[n].type->free(c, &conf[n]);
1228 for(n = 0; n < c->nparts; ++n)
1229 xfree(c->parts[n]);
1230 xfree(c->parts);
1231 xfree(c);
1232 }
1233}
1234
3f3bb97b 1235/** @brief Set post-parse defaults */
c00fce3a
RK
1236static void config_postdefaults(struct config *c,
1237 int server) {
460b9539 1238 struct config_state cs;
1239 const struct conf *whoami;
1240 int n;
1241
1242 static const char *namepart[][4] = {
88608992 1243 { "title", "/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display" },
460b9539 1244 { "title", "/([^/]+)\\.[a-zA-Z0-9]+$", "$1", "sort" },
1245 { "album", "/([^/]+)/[^/]+$", "$1", "*" },
1246 { "artist", "/([^/]+)/[^/]+/[^/]+$", "$1", "*" },
1247 { "ext", "(\\.[a-zA-Z0-9]+)$", "$1", "*" },
1248 };
1249#define NNAMEPART (int)(sizeof namepart / sizeof *namepart)
1250
1251 static const char *transform[][5] = {
88608992 1252 { "track", "^.*/([0-9]+ *[-:] *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display", "" },
460b9539 1253 { "track", "^.*/([^/]+)\\.[a-zA-Z0-9]+$", "$1", "sort", "" },
1254 { "dir", "^.*/([^/]+)$", "$1", "*", "" },
1255 { "dir", "^(the) ([^/]*)", "$2, $1", "sort", "i", },
1256 { "dir", "[[:punct:]]", "", "sort", "g", }
1257 };
1258#define NTRANSFORM (int)(sizeof transform / sizeof *transform)
1259
1260 cs.path = "<internal>";
1261 cs.line = 0;
1262 cs.config = c;
1263 if(!c->namepart.n) {
1264 whoami = find("namepart");
1265 for(n = 0; n < NNAMEPART; ++n)
1266 set_namepart(&cs, whoami, 4, (char **)namepart[n]);
1267 }
1268 if(!c->transform.n) {
1269 whoami = find("transform");
1270 for(n = 0; n < NTRANSFORM; ++n)
1271 set_transform(&cs, whoami, 5, (char **)transform[n]);
1272 }
bd8895a8 1273 if(c->api == -1) {
e83d0967 1274 if(c->speaker_command)
bd8895a8 1275 c->api = BACKEND_COMMAND;
e83d0967 1276 else if(c->broadcast.n)
bd8895a8 1277 c->api = BACKEND_NETWORK;
e83d0967 1278 else {
146e86fb 1279#if HAVE_ALSA_ASOUNDLIB_H
bd8895a8 1280 c->api = BACKEND_ALSA;
146e86fb 1281#elif HAVE_SYS_SOUNDCARD_H
bd8895a8 1282 c->api = BACKEND_OSS;
937be4c0 1283#elif HAVE_COREAUDIO_AUDIOHARDWARE_H
bd8895a8 1284 c->api = BACKEND_COREAUDIO;
e83d0967 1285#else
bd8895a8 1286 c->api = BACKEND_COMMAND;
e83d0967
RK
1287#endif
1288 }
1289 }
c00fce3a 1290 if(server) {
bd8895a8 1291 if(c->api == BACKEND_COMMAND && !c->speaker_command)
1292 fatal(0, "'api command' but speaker_command is not set");
1293 if(c->api == BACKEND_NETWORK && !c->broadcast.n)
1294 fatal(0, "'api network' but broadcast is not set");
c00fce3a 1295 }
e99d42b1 1296 /* Override sample format */
bd8895a8 1297 switch(c->api) {
e99d42b1 1298 case BACKEND_NETWORK:
6d2d327c
RK
1299 c->sample_format.rate = 44100;
1300 c->sample_format.channels = 2;
1301 c->sample_format.bits = 16;
1302 c->sample_format.endian = ENDIAN_BIG;
e99d42b1 1303 break;
1304 case BACKEND_COREAUDIO:
937be4c0
RK
1305 c->sample_format.rate = 44100;
1306 c->sample_format.channels = 2;
1307 c->sample_format.bits = 16;
1308 c->sample_format.endian = ENDIAN_NATIVE;
e99d42b1 1309 break;
04e1fa7c
RK
1310 }
1311 if(!c->default_rights) {
1312 rights_type r = RIGHTS__MASK & ~(RIGHT_ADMIN|RIGHT_REGISTER
1313 |RIGHT_MOVE__MASK
1314 |RIGHT_SCRATCH__MASK
1315 |RIGHT_REMOVE__MASK);
1316 /* The idea is to approximate the meaning of the old 'restrict' directive
1317 * in the default rights if they are not overridden. */
1318 if(c->restrictions & RESTRICT_SCRATCH)
1319 r |= RIGHT_SCRATCH_MINE|RIGHT_SCRATCH_RANDOM;
1320 else
1321 r |= RIGHT_SCRATCH_ANY;
1322 if(!(c->restrictions & RESTRICT_MOVE))
1323 r |= RIGHT_MOVE_ANY;
1324 if(c->restrictions & RESTRICT_REMOVE)
1325 r |= RIGHT_REMOVE_MINE;
1326 else
1327 r |= RIGHT_REMOVE_ANY;
0f55e905 1328 c->default_rights = rights_string(r);
04e1fa7c 1329 }
460b9539 1330}
1331
c00fce3a
RK
1332/** @brief (Re-)read the config file
1333 * @param server If set, do extra checking
1334 */
1335int config_read(int server) {
460b9539 1336 struct config *c;
1337 char *privconf;
1338 struct passwd *pw;
1339
1340 set_configfile();
1341 c = config_default();
9ade2319 1342 /* standalone Disobedience installs might not have a global config file */
1343 if(access(configfile, F_OK) == 0)
1344 if(config_include(c, configfile))
1345 return -1;
460b9539 1346 /* if we can read the private config file, do */
1347 if((privconf = config_private())
1348 && access(privconf, R_OK) == 0
1349 && config_include(c, privconf))
1350 return -1;
1351 xfree(privconf);
1352 /* if there's a per-user system config file for this user, read it */
63ad732f
RK
1353 if(config_per_user) {
1354 if(!(pw = getpwuid(getuid())))
1355 fatal(0, "cannot determine our username");
1356 if((privconf = config_usersysconf(pw))
1357 && access(privconf, F_OK) == 0
1358 && config_include(c, privconf))
460b9539 1359 return -1;
63ad732f
RK
1360 xfree(privconf);
1361 /* if we have a password file, read it */
1362 if((privconf = config_userconf(getenv("HOME"), pw))
1363 && access(privconf, F_OK) == 0
1364 && config_include(c, privconf))
1365 return -1;
1366 xfree(privconf);
1367 }
460b9539 1368 /* install default namepart and transform settings */
c00fce3a 1369 config_postdefaults(c, server);
460b9539 1370 /* everything is good so we shall use the new config */
1371 config_free(config);
04e1fa7c
RK
1372 /* warn about obsolete directives */
1373 if(c->restrictions)
1374 error(0, "'restrict' will be removed in a future version");
1375 if(c->allow.n)
1376 error(0, "'allow' will be removed in a future version");
1377 if(c->trust.n)
1378 error(0, "'trust' will be removed in a future version");
460b9539 1379 config = c;
1380 return 0;
1381}
1382
3f3bb97b 1383/** @brief Return the path to the private configuration file */
460b9539 1384char *config_private(void) {
1385 char *s;
1386
1387 set_configfile();
1388 byte_xasprintf(&s, "%s.private", configfile);
1389 return s;
1390}
1391
3f3bb97b 1392/** @brief Return the path to user's personal configuration file */
460b9539 1393char *config_userconf(const char *home, const struct passwd *pw) {
1394 char *s;
1395
73f1b9f3
RK
1396 if(!home && !pw && !(pw = getpwuid(getuid())))
1397 fatal(0, "cannot determine our username");
460b9539 1398 byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
1399 return s;
1400}
1401
3f3bb97b
RK
1402/** @brief Return the path to user-specific system configuration */
1403char *config_usersysconf(const struct passwd *pw) {
460b9539 1404 char *s;
1405
1406 set_configfile();
1407 if(!strchr(pw->pw_name, '/')) {
1408 byte_xasprintf(&s, "%s.%s", configfile, pw->pw_name);
1409 return s;
1410 } else
1411 return 0;
1412}
1413
1414char *config_get_file(const char *name) {
1415 return get_file(config, name);
1416}
1417
1418/*
1419Local Variables:
1420c-basic-offset:2
1421comment-column:40
1422fill-column:79
1423End:
1424*/