chiark / gitweb /
~mdw / disorder / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
The command backend now supports the old (suspending) and new
[disorder] / lib / configuration.c
CommitLineData
460b9539 1/*
2 * This file is part of DisOrder.
b50cfb8a 3 * Copyright (C) 2004-2009 Richard Kettlewell
313acc77 4 * Portions copyright (C) 2007 Mark Wooding
460b9539 5 *
e7eb3a27 6 * This program is free software: you can redistribute it and/or modify
460b9539 7 * it under the terms of the GNU General Public License as published by
e7eb3a27 8 * the Free Software Foundation, either version 3 of the License, or
460b9539 9 * (at your option) any later version.
e7eb3a27
RK		 10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
460b9539 16 * You should have received a copy of the GNU General Public License
e7eb3a27 17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
460b9539 18 */
0e4472a0 19/** @file lib/configuration.c
20 * @brief Configuration file support
21 */
460b9539 22
05b75f8d 23#include "common.h"
460b9539 24
460b9539 25#include <errno.h>
26#include <sys/types.h>
27#include <sys/stat.h>
28#include <unistd.h>
29#include <ctype.h>
30#include <stddef.h>
31#include <pwd.h>
32#include <langinfo.h>
33#include <pcre.h>
34#include <signal.h>
35
04e1fa7c 36#include "rights.h"
460b9539 37#include "configuration.h"
38#include "mem.h"
39#include "log.h"
40#include "split.h"
41#include "syscalls.h"
42#include "table.h"
43#include "inputline.h"
44#include "charset.h"
45#include "defs.h"
460b9539 46#include "printf.h"
47#include "regsub.h"
48#include "signame.h"
637fdea3 49#include "authhash.h"
e6a35d1c 50#include "vector.h"
b50cfb8a 51#include "uaudio.h"
460b9539 52
3f3bb97b
RK		 53/** @brief Path to config file
54 *
55 * set_configfile() sets the deafult if it is null.
56 */
460b9539 57char *configfile;
58
63ad732f
RK		 59/** @brief Read user configuration
60 *
61 * If clear, the user-specific configuration is not read.
62 */
63int config_per_user = 1;
64
b50cfb8a
RK		 65/** @brief Table of audio APIs
66 *
67 * Only set in server processes.
68 */
69const struct uaudio *const *config_uaudio_apis;
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) {
ba937f01 314 if((i = TABLE_FIND(restrictions, name, vec[n])) < 0) {
460b9539 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
04e1fa7c
RK		 475static int set_rights(const struct config_state *cs,
476 const struct conf *whoami,
477 int nvec, char **vec) {
04e1fa7c
RK		 478 if(nvec != 1) {
479 error(0, "%s:%d: '%s' requires one argument",
480 cs->path, cs->line, whoami->name);
481 return -1;
482 }
0f55e905 483 if(parse_rights(vec[0], 0, 1)) {
04e1fa7c
RK		 484 error(0, "%s:%d: invalid rights string '%s'",
485 cs->path, cs->line, vec[0]);
486 return -1;
487 }
0f55e905 488 *ADDRESS(cs->config, char *) = vec[0];
04e1fa7c
RK		 489 return 0;
490}
491
460b9539 492/* free functions */
493
494static void free_none(struct config attribute((unused)) *c,
495 const struct conf attribute((unused)) *whoami) {
496}
497
498static void free_string(struct config *c,
499 const struct conf *whoami) {
500 xfree(VALUE(c, char *));
501}
502
503static void free_stringlist(struct config *c,
504 const struct conf *whoami) {
505 int n;
506 struct stringlist *sl = ADDRESS(c, struct stringlist);
507
508 for(n = 0; n < sl->n; ++n)
509 xfree(sl->s[n]);
510 xfree(sl->s);
511}
512
513static void free_stringlistlist(struct config *c,
514 const struct conf *whoami) {
515 int n, m;
516 struct stringlistlist *sll = ADDRESS(c, struct stringlistlist);
517 struct stringlist *sl;
518
519 for(n = 0; n < sll->n; ++n) {
520 sl = &sll->s[n];
521 for(m = 0; m < sl->n; ++m)
522 xfree(sl->s[m]);
523 xfree(sl->s);
524 }
525 xfree(sll->s);
526}
527
528static void free_collectionlist(struct config *c,
529 const struct conf *whoami) {
530 struct collectionlist *cll = ADDRESS(c, struct collectionlist);
531 struct collection *cl;
532 int n;
533
534 for(n = 0; n < cll->n; ++n) {
535 cl = &cll->s[n];
536 xfree(cl->module);
537 xfree(cl->encoding);
538 xfree(cl->root);
539 }
540 xfree(cll->s);
541}
542
543static void free_namepartlist(struct config *c,
544 const struct conf *whoami) {
545 struct namepartlist *npl = ADDRESS(c, struct namepartlist);
546 struct namepart *np;
547 int n;
548
549 for(n = 0; n < npl->n; ++n) {
550 np = &npl->s[n];
551 xfree(np->part);
552 pcre_free(np->re); /* ...whatever pcre_free is set to. */
553 xfree(np->replace);
554 xfree(np->context);
555 }
556 xfree(npl->s);
557}
558
559static void free_transformlist(struct config *c,
560 const struct conf *whoami) {
561 struct transformlist *tl = ADDRESS(c, struct transformlist);
562 struct transform *t;
563 int n;
564
565 for(n = 0; n < tl->n; ++n) {
566 t = &tl->t[n];
567 xfree(t->type);
568 pcre_free(t->re); /* ...whatever pcre_free is set to. */
569 xfree(t->replace);
570 xfree(t->context);
571 }
572 xfree(tl->t);
573}
574
575/* configuration types */
576
577static const struct conftype
578 type_signal = { set_signal, free_none },
579 type_collections = { set_collections, free_collectionlist },
580 type_boolean = { set_boolean, free_none },
581 type_string = { set_string, free_string },
582 type_stringlist = { set_stringlist, free_stringlist },
583 type_integer = { set_integer, free_none },
584 type_stringlist_accum = { set_stringlist_accum, free_stringlistlist },
585 type_string_accum = { set_string_accum, free_stringlist },
9d5da576 586 type_sample_format = { set_sample_format, free_none },
460b9539 587 type_restrict = { set_restrict, free_none },
588 type_namepart = { set_namepart, free_namepartlist },
e83d0967 589 type_transform = { set_transform, free_transformlist },
b50cfb8a 590 type_rights = { set_rights, free_none };
460b9539 591
592/* specific validation routine */
593
594#define VALIDATE_FILE(test, what) do { \
595 struct stat sb; \
596 int n; \
597 \
598 for(n = 0; n < nvec; ++n) { \
599 if(stat(vec[n], &sb) < 0) { \
600 error(errno, "%s:%d: %s", cs->path, cs->line, vec[n]); \
601 return -1; \
602 } \
603 if(!test(sb.st_mode)) { \
604 error(0, "%s:%d: %s is not a %s", \
605 cs->path, cs->line, vec[n], what); \
606 return -1; \
607 } \
608 } \
609} while(0)
610
659d87e8
RK		 611static int validate_isabspath(const struct config_state *cs,
612 int nvec, char **vec) {
613 int n;
614
615 for(n = 0; n < nvec; ++n)
616 if(vec[n][0] != '/') {
617 error(errno, "%s:%d: %s: not an absolute path",
618 cs->path, cs->line, vec[n]);
619 return -1;
620 }
621 return 0;
622}
623
460b9539 624static int validate_isdir(const struct config_state *cs,
625 int nvec, char **vec) {
626 VALIDATE_FILE(S_ISDIR, "directory");
627 return 0;
628}
629
630static int validate_isreg(const struct config_state *cs,
631 int nvec, char **vec) {
632 VALIDATE_FILE(S_ISREG, "regular file");
633 return 0;
634}
635
460b9539 636static int validate_player(const struct config_state *cs,
637 int nvec,
638 char attribute((unused)) **vec) {
639 if(nvec < 2) {
640 error(0, "%s:%d: should be at least 'player PATTERN MODULE'",
641 cs->path, cs->line);
642 return -1;
643 }
644 return 0;
645}
646
62dc3748
RK		 647static int validate_tracklength(const struct config_state *cs,
648 int nvec,
649 char attribute((unused)) **vec) {
650 if(nvec < 2) {
651 error(0, "%s:%d: should be at least 'tracklength PATTERN MODULE'",
652 cs->path, cs->line);
653 return -1;
654 }
655 return 0;
656}
657
460b9539 658static int validate_allow(const struct config_state *cs,
659 int nvec,
660 char attribute((unused)) **vec) {
661 if(nvec != 2) {
662 error(0, "%s:%d: must be 'allow NAME PASS'", cs->path, cs->line);
663 return -1;
664 }
665 return 0;
666}
667
668static int validate_non_negative(const struct config_state *cs,
669 int nvec, char **vec) {
670 long n;
671
672 if(nvec < 1) {
673 error(0, "%s:%d: missing argument", cs->path, cs->line);
674 return -1;
675 }
676 if(nvec > 1) {
677 error(0, "%s:%d: too many arguments", cs->path, cs->line);
678 return -1;
679 }
680 if(xstrtol(&n, vec[0], 0, 0)) {
681 error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
682 return -1;
683 }
684 if(n < 0) {
685 error(0, "%s:%d: must not be negative", cs->path, cs->line);
686 return -1;
687 }
688 return 0;
689}
690
691static int validate_positive(const struct config_state *cs,
692 int nvec, char **vec) {
693 long n;
694
695 if(nvec < 1) {
696 error(0, "%s:%d: missing argument", cs->path, cs->line);
697 return -1;
698 }
699 if(nvec > 1) {
700 error(0, "%s:%d: too many arguments", cs->path, cs->line);
701 return -1;
702 }
703 if(xstrtol(&n, vec[0], 0, 0)) {
704 error(0, "%s:%d: %s", cs->path, cs->line, strerror(errno));
705 return -1;
706 }
707 if(n <= 0) {
708 error(0, "%s:%d: must be positive", cs->path, cs->line);
709 return -1;
710 }
711 return 0;
712}
713
714static int validate_isauser(const struct config_state *cs,
715 int attribute((unused)) nvec,
716 char **vec) {
717 struct passwd *pw;
718
719 if(!(pw = getpwnam(vec[0]))) {
720 error(0, "%s:%d: no such user as '%s'", cs->path, cs->line, vec[0]);
721 return -1;
722 }
723 return 0;
724}
725
9d5da576 726static int validate_sample_format(const struct config_state *cs,
727 int attribute((unused)) nvec,
728 char **vec) {
729 return parse_sample_format(cs, 0, nvec, vec);
730}
731
460b9539 732static int validate_any(const struct config_state attribute((unused)) *cs,
733 int attribute((unused)) nvec,
734 char attribute((unused)) **vec) {
735 return 0;
736}
737
738static int validate_url(const struct config_state attribute((unused)) *cs,
739 int attribute((unused)) nvec,
740 char **vec) {
741 const char *s;
742 int n;
743 /* absoluteURI = scheme ":" ( hier_part | opaque_part )
744 scheme = alpha *( alpha | digit | "+" | "-" | "." ) */
745 s = vec[0];
746 n = strspn(s, ("abcdefghijklmnopqrstuvwxyz"
747 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
748 "0123456789"));
749 if(s[n] != ':') {
750 error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
751 return -1;
752 }
753 if(!strncmp(s, "http:", 5)
754 || !strncmp(s, "https:", 6)) {
755 s += n + 1;
756 /* we only do a rather cursory check */
757 if(strncmp(s, "//", 2)) {
758 error(0, "%s:%d: invalid url '%s'", cs->path, cs->line, vec[0]);
759 return -1;
760 }
761 }
762 return 0;
763}
764
765static int validate_alias(const struct config_state *cs,
766 int nvec,
767 char **vec) {
768 const char *s;
769 int in_brackets = 0, c;
770
771 if(nvec < 1) {
772 error(0, "%s:%d: missing argument", cs->path, cs->line);
773 return -1;
774 }
775 if(nvec > 1) {
776 error(0, "%s:%d: too many arguments", cs->path, cs->line);
777 return -1;
778 }
779 s = vec[0];
780 while((c = (unsigned char)*s++)) {
781 if(in_brackets) {
782 if(c == '}')
783 in_brackets = 0;
784 else if(!isalnum(c)) {
785 error(0, "%s:%d: invalid part name in alias expansion in '%s'",
786 cs->path, cs->line, vec[0]);
787 return -1;
788 }
789 } else {
790 if(c == '{') {
791 in_brackets = 1;
792 if(*s == '/')
793 ++s;
794 } else if(c == '\\') {
795 if(!(c = (unsigned char)*s++)) {
796 error(0, "%s:%d: unterminated escape in alias expansion in '%s'",
797 cs->path, cs->line, vec[0]);
798 return -1;
799 } else if(c != '\\' && c != '{') {
800 error(0, "%s:%d: invalid escape in alias expansion in '%s'",
801 cs->path, cs->line, vec[0]);
802 return -1;
803 }
804 }
805 }
806 ++s;
807 }
808 if(in_brackets) {
809 error(0, "%s:%d: unterminated part name in alias expansion in '%s'",
810 cs->path, cs->line, vec[0]);
811 return -1;
812 }
813 return 0;
814}
815
e83d0967
RK		 816static int validate_addrport(const struct config_state attribute((unused)) *cs,
817 int nvec,
818 char attribute((unused)) **vec) {
819 switch(nvec) {
820 case 0:
821 error(0, "%s:%d: missing address",
822 cs->path, cs->line);
823 return -1;
824 case 1:
825 error(0, "%s:%d: missing port name/number",
826 cs->path, cs->line);
827 return -1;
828 case 2:
829 return 0;
830 default:
831 error(0, "%s:%d: expected ADDRESS PORT",
832 cs->path, cs->line);
833 return -1;
834 }
835}
836
ccf0aafa 837static int validate_port(const struct config_state attribute((unused)) *cs,
e83d0967
RK		 838 int nvec,
839 char attribute((unused)) **vec) {
840 switch(nvec) {
841 case 0:
842 error(0, "%s:%d: missing address",
843 cs->path, cs->line);
844 return -1;
845 case 1:
846 case 2:
847 return 0;
848 default:
ccf0aafa 849 error(0, "%s:%d: expected [ADDRESS] PORT",
e83d0967
RK		 850 cs->path, cs->line);
851 return -1;
852 }
853}
854
637fdea3
RK		 855static int validate_algo(const struct config_state attribute((unused)) *cs,
856 int nvec,
857 char **vec) {
858 if(nvec != 1) {
859 error(0, "%s:%d: invalid algorithm specification", cs->path, cs->line);
860 return -1;
861 }
862 if(!valid_authhash(vec[0])) {
863 error(0, "%s:%d: unsuported algorithm '%s'", cs->path, cs->line, vec[0]);
864 return -1;
865 }
866 return 0;
867}
868
b50cfb8a
RK		 869static int validate_backend(const struct config_state attribute((unused)) *cs,
870 int nvec,
871 char **vec) {
872 int n;
873 if(nvec != 1) {
874 error(0, "%s:%d: invalid sound API specification", cs->path, cs->line);
875 return -1;
876 }
877 if(!strcmp(vec[0], "network")) {
878 error(0, "'api network' is deprecated; use 'api rtp'");
879 return 0;
880 }
881 if(config_uaudio_apis) {
882 for(n = 0; config_uaudio_apis[n]; ++n)
883 if(!strcmp(vec[0], config_uaudio_apis[n]->name))
884 return 0;
885 error(0, "%s:%d: unrecognized sound API '%s'", cs->path, cs->line, vec[0]);
886 return -1;
887 }
888 /* In non-server processes we have no idea what's valid */
889 return 0;
890}
891
3f3bb97b 892/** @brief Item name and and offset */
460b9539 893#define C(x) #x, offsetof(struct config, x)
3f3bb97b 894/** @brief Item name and and offset */
460b9539 895#define C2(x,y) #x, offsetof(struct config, y)
896
3f3bb97b 897/** @brief All configuration items */
460b9539 898static const struct conf conf[] = {
899 { C(alias), &type_string, validate_alias },
900 { C(allow), &type_stringlist_accum, validate_allow },
b50cfb8a 901 { C(api), &type_string, validate_backend },
637fdea3 902 { C(authorization_algorithm), &type_string, validate_algo },
e83d0967 903 { C(broadcast), &type_stringlist, validate_addrport },
ccf0aafa 904 { C(broadcast_from), &type_stringlist, validate_addrport },
bd8895a8 905 { C(channel), &type_string, validate_any },
460b9539 906 { C(checkpoint_kbyte), &type_integer, validate_non_negative },
907 { C(checkpoint_min), &type_integer, validate_non_negative },
908 { C(collection), &type_collections, validate_any },
e83d0967 909 { C(connect), &type_stringlist, validate_addrport },
b12be54a
RK		 910 { C(cookie_login_lifetime), &type_integer, validate_positive },
911 { C(cookie_key_lifetime), &type_integer, validate_positive },
8818b7fc 912 { C(dbversion), &type_integer, validate_positive },
04e1fa7c 913 { C(default_rights), &type_rights, validate_any },
460b9539 914 { C(device), &type_string, validate_any },
915 { C(gap), &type_integer, validate_non_negative },
916 { C(history), &type_integer, validate_positive },
659d87e8 917 { C(home), &type_string, validate_isabspath },
ccf0aafa 918 { C(listen), &type_stringlist, validate_port },
460b9539 919 { C(lock), &type_boolean, validate_any },
bb6ae3fb 920 { C(mail_sender), &type_string, validate_any },
bd8895a8 921 { C(mixer), &type_string, validate_any },
61941295 922 { C(multicast_loop), &type_boolean, validate_any },
23205f9c 923 { C(multicast_ttl), &type_integer, validate_non_negative },
460b9539 924 { C(namepart), &type_namepart, validate_any },
05dcfac6
RK		 925 { C(new_bias), &type_integer, validate_positive },
926 { C(new_bias_age), &type_integer, validate_positive },
d742bb47 927 { C(new_max), &type_integer, validate_positive },
460b9539 928 { C2(nice, nice_rescan), &type_integer, validate_non_negative },
929 { C(nice_rescan), &type_integer, validate_non_negative },
930 { C(nice_server), &type_integer, validate_any },
931 { C(nice_speaker), &type_integer, validate_any },
2a10b70b 932 { C(noticed_history), &type_integer, validate_positive },
460b9539 933 { C(password), &type_string, validate_any },
934 { C(player), &type_stringlist_accum, validate_player },
935 { C(plugins), &type_string_accum, validate_isdir },
936 { C(prefsync), &type_integer, validate_positive },
459d4402 937 { C(queue_pad), &type_integer, validate_positive },
cebe3127 938 { C(replay_min), &type_integer, validate_non_negative },
460b9539 939 { C(refresh), &type_integer, validate_positive },
6207d2f3 940 { C(reminder_interval), &type_integer, validate_positive },
810b8083 941 { C(remote_userman), &type_boolean, validate_any },
460b9539 942 { C2(restrict, restrictions), &type_restrict, validate_any },
ba70caca 943 { C(rtp_delay_threshold), &type_integer, validate_positive },
9d5da576 944 { C(sample_format), &type_sample_format, validate_sample_format },
460b9539 945 { C(scratch), &type_string_accum, validate_isreg },
2eee4b0c 946 { C(sendmail), &type_string, validate_isabspath },
61507e3c 947 { C(short_display), &type_integer, validate_positive },
460b9539 948 { C(signal), &type_signal, validate_any },
bb6ae3fb 949 { C(smtp_server), &type_string, validate_any },
5330d674 950 { C(sox_generation), &type_integer, validate_non_negative },
b50cfb8a 951 { C2(speaker_backend, api), &type_string, validate_backend },
9d5da576 952 { C(speaker_command), &type_string, validate_any },
460b9539 953 { C(stopword), &type_string_accum, validate_any },
954 { C(templates), &type_string_accum, validate_isdir },
62dc3748 955 { C(tracklength), &type_stringlist_accum, validate_tracklength },
460b9539 956 { C(transform), &type_transform, validate_any },
957 { C(trust), &type_string_accum, validate_any },
958 { C(url), &type_string, validate_url },
959 { C(user), &type_string, validate_isauser },
960 { C(username), &type_string, validate_any },
961};
962
3f3bb97b 963/** @brief Find a configuration item's definition by key */
460b9539 964static const struct conf *find(const char *key) {
965 int n;
966
ba937f01 967 if((n = TABLE_FIND(conf, name, key)) < 0)
460b9539 968 return 0;
969 return &conf[n];
970}
971
3f3bb97b 972/** @brief Set a new configuration value */
460b9539 973static int config_set(const struct config_state *cs,
974 int nvec, char **vec) {
975 const struct conf *which;
976
977 D(("config_set %s", vec[0]));
978 if(!(which = find(vec[0]))) {
979 error(0, "%s:%d: unknown configuration key '%s'",
980 cs->path, cs->line, vec[0]);
981 return -1;
982 }
983 return (which->validate(cs, nvec - 1, vec + 1)
984 || which->type->set(cs, which, nvec - 1, vec + 1));
985}
986
e6a35d1c
RK		 987static int config_set_args(const struct config_state *cs,
988 const char *which, ...) {
989 va_list ap;
990 struct vector v[1];
991 char *s;
992
993 vector_init(v);
994 vector_append(v, (char *)which);
995 va_start(ap, which);
996 while((s = va_arg(ap, char *)))
997 vector_append(v, s);
998 va_end(ap);
999 vector_terminate(v);
1000 return config_set(cs, v->nvec, v->vec);
1001}
1002
0e4472a0 1003/** @brief Error callback used by config_include() */
460b9539 1004static void config_error(const char *msg, void *u) {
1005 const struct config_state *cs = u;
1006
1007 error(0, "%s:%d: %s", cs->path, cs->line, msg);
1008}
1009
3f3bb97b 1010/** @brief Include a file by name */
460b9539 1011static int config_include(struct config *c, const char *path) {
1012 FILE *fp;
1013 char *buffer, *inputbuffer, **vec;
1014 int n, ret = 0;
1015 struct config_state cs;
1016
1017 cs.path = path;
1018 cs.line = 0;
1019 cs.config = c;
1020 D(("%s: reading configuration", path));
1021 if(!(fp = fopen(path, "r"))) {
1022 error(errno, "error opening %s", path);
1023 return -1;
1024 }
1025 while(!inputline(path, fp, &inputbuffer, '\n')) {
1026 ++cs.line;
1027 if(!(buffer = mb2utf8(inputbuffer))) {
1028 error(errno, "%s:%d: cannot convert to UTF-8", cs.path, cs.line);
1029 ret = -1;
1030 xfree(inputbuffer);
1031 continue;
1032 }
1033 xfree(inputbuffer);
1034 if(!(vec = split(buffer, &n, SPLIT_COMMENTS|SPLIT_QUOTES,
1035 config_error, &cs))) {
1036 ret = -1;
1037 xfree(buffer);
1038 continue;
1039 }
1040 if(n) {
1041 if(!strcmp(vec[0], "include")) {
1042 if(n != 2) {
1043 error(0, "%s:%d: must be 'include PATH'", cs.path, cs.line);
1044 ret = -1;
1045 } else
1046 config_include(c, vec[1]);
1047 } else
1048 ret |= config_set(&cs, n, vec);
1049 }
1050 for(n = 0; vec[n]; ++n) xfree(vec[n]);
1051 xfree(vec);
1052 xfree(buffer);
1053 }
1054 if(ferror(fp)) {
1055 error(errno, "error reading %s", path);
1056 ret = -1;
1057 }
1058 fclose(fp);
1059 return ret;
1060}
1061
86be0c30 1062static const char *const default_stopwords[] = {
1063 "stopword",
1064
1065 "01",
1066 "02",
1067 "03",
1068 "04",
1069 "05",
1070 "06",
1071 "07",
1072 "08",
1073 "09",
1074 "1",
1075 "10",
1076 "11",
1077 "12",
1078 "13",
1079 "14",
1080 "15",
1081 "16",
1082 "17",
1083 "18",
1084 "19",
1085 "2",
1086 "20",
1087 "21",
1088 "22",
1089 "23",
1090 "24",
1091 "25",
1092 "26",
1093 "27",
1094 "28",
1095 "29",
1096 "3",
1097 "30",
1098 "4",
1099 "5",
1100 "6",
1101 "7",
1102 "8",
1103 "9",
1104 "a",
1105 "am",
1106 "an",
1107 "and",
1108 "as",
1109 "for",
1110 "i",
1111 "im",
1112 "in",
1113 "is",
1114 "of",
1115 "on",
1116 "the",
1117 "to",
1118 "too",
1119 "we",
1120};
1121#define NDEFAULT_STOPWORDS (sizeof default_stopwords / sizeof *default_stopwords)
1122
e6a35d1c
RK		 1123static const char *const default_players[] = {
1124 "*.ogg",
1125 "*.flac",
1126 "*.mp3",
1127 "*.wav",
1128};
1129#define NDEFAULT_PLAYERS (sizeof default_players / sizeof *default_players)
1130
3f3bb97b 1131/** @brief Make a new default configuration */
460b9539 1132static struct config *config_default(void) {
1133 struct config *c = xmalloc(sizeof *c);
1134 const char *logname;
1135 struct passwd *pw;
86be0c30 1136 struct config_state cs;
e6a35d1c 1137 size_t n;
460b9539 1138
86be0c30 1139 cs.path = "<internal>";
1140 cs.line = 0;
1141 cs.config = c;
460b9539 1142 /* Strings had better be xstrdup'd as they will get freed at some point. */
07bc035e 1143 c->gap = 0;
460b9539 1144 c->history = 60;
1145 c->home = xstrdup(pkgstatedir);
1146 if(!(pw = getpwuid(getuid())))
1147 fatal(0, "cannot determine our username");
1148 logname = pw->pw_name;
1149 c->username = xstrdup(logname);
1150 c->refresh = 15;
1151 c->prefsync = 3600;
1152 c->signal = SIGKILL;
1153 c->alias = xstrdup("{/artist}{/album}{/title}{ext}");
1154 c->lock = 1;
1155 c->device = xstrdup("default");
1156 c->nice_rescan = 10;
9d5da576 1157 c->speaker_command = 0;
1158 c->sample_format.bits = 16;
1159 c->sample_format.rate = 44100;
1160 c->sample_format.channels = 2;
6d2d327c 1161 c->sample_format.endian = ENDIAN_NATIVE;
459d4402 1162 c->queue_pad = 10;
cebe3127 1163 c->replay_min = 8 * 3600;
b50cfb8a 1164 c->api = NULL;
23205f9c 1165 c->multicast_ttl = 1;
61941295 1166 c->multicast_loop = 1;
637fdea3 1167 c->authorization_algorithm = xstrdup("sha1");
2a10b70b 1168 c->noticed_history = 31;
61507e3c 1169 c->short_display = 32;
bd8895a8 1170 c->mixer = 0;
1171 c->channel = 0;
8818b7fc 1172 c->dbversion = 2;
b12be54a
RK		 1173 c->cookie_login_lifetime = 86400;
1174 c->cookie_key_lifetime = 86400 * 7;
2eee4b0c
RK		 1175 if(sendmail_binary[0] && strcmp(sendmail_binary, "none"))
1176 c->sendmail = xstrdup(sendmail_binary);
bb6ae3fb 1177 c->smtp_server = xstrdup("127.0.0.1");
d742bb47 1178 c->new_max = 100;
6207d2f3 1179 c->reminder_interval = 600; /* 10m */
05dcfac6 1180 c->new_bias_age = 7 * 86400; /* 1 week */
6151ae7e 1181 c->new_bias = 4500000; /* 50 times the base weight */
419893d7 1182 c->sox_generation = DEFAULT_SOX_GENERATION;
e6a35d1c 1183 /* Default stopwords */
86be0c30 1184 if(config_set(&cs, (int)NDEFAULT_STOPWORDS, (char **)default_stopwords))
1185 exit(1);
e6a35d1c
RK		 1186 /* Default player configuration */
1187 for(n = 0; n < NDEFAULT_PLAYERS; ++n) {
1188 if(config_set_args(&cs, "player",
1189 default_players[n], "execraw", "disorder-decode", (char *)0))
1190 exit(1);
1191 if(config_set_args(&cs, "tracklength",
1192 default_players[n], "disorder-tracklength", (char *)0))
1193 exit(1);
1194 }
460b9539 1195 return c;
1196}
1197
319d7107 1198char *config_get_file2(struct config *c, const char *name) {
460b9539 1199 char *s;
1200
1201 byte_xasprintf(&s, "%s/%s", c->home, name);
1202 return s;
1203}
1204
3f3bb97b 1205/** @brief Set the default configuration file */
460b9539 1206static void set_configfile(void) {
1207 if(!configfile)
1208 byte_xasprintf(&configfile, "%s/config", pkgconfdir);
1209}
1210
3f3bb97b 1211/** @brief Free a configuration object */
460b9539 1212static void config_free(struct config *c) {
1213 int n;
1214
1215 if(c) {
1216 for(n = 0; n < (int)(sizeof conf / sizeof *conf); ++n)
1217 conf[n].type->free(c, &conf[n]);
1218 for(n = 0; n < c->nparts; ++n)
1219 xfree(c->parts[n]);
1220 xfree(c->parts);
1221 xfree(c);
1222 }
1223}
1224
3f3bb97b 1225/** @brief Set post-parse defaults */
c00fce3a
RK		 1226static void config_postdefaults(struct config *c,
1227 int server) {
460b9539 1228 struct config_state cs;
1229 const struct conf *whoami;
1230 int n;
1231
1232 static const char *namepart[][4] = {
bcf50f5c 1233 { "title", "/([0-9]+ *[-:]? *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display" },
460b9539 1234 { "title", "/([^/]+)\\.[a-zA-Z0-9]+$", "$1", "sort" },
1235 { "album", "/([^/]+)/[^/]+$", "$1", "*" },
1236 { "artist", "/([^/]+)/[^/]+/[^/]+$", "$1", "*" },
1237 { "ext", "(\\.[a-zA-Z0-9]+)$", "$1", "*" },
1238 };
1239#define NNAMEPART (int)(sizeof namepart / sizeof *namepart)
1240
1241 static const char *transform[][5] = {
bcf50f5c 1242 { "track", "^.*/([0-9]+ *[-:]? *)?([^/]+)\\.[a-zA-Z0-9]+$", "$2", "display", "" },
460b9539 1243 { "track", "^.*/([^/]+)\\.[a-zA-Z0-9]+$", "$1", "sort", "" },
1244 { "dir", "^.*/([^/]+)$", "$1", "*", "" },
1245 { "dir", "^(the) ([^/]*)", "$2, $1", "sort", "i", },
1246 { "dir", "[[:punct:]]", "", "sort", "g", }
1247 };
1248#define NTRANSFORM (int)(sizeof transform / sizeof *transform)
1249
1250 cs.path = "<internal>";
1251 cs.line = 0;
1252 cs.config = c;
1253 if(!c->namepart.n) {
1254 whoami = find("namepart");
1255 for(n = 0; n < NNAMEPART; ++n)
1256 set_namepart(&cs, whoami, 4, (char **)namepart[n]);
1257 }
1258 if(!c->transform.n) {
1259 whoami = find("transform");
1260 for(n = 0; n < NTRANSFORM; ++n)
1261 set_transform(&cs, whoami, 5, (char **)transform[n]);
1262 }
b50cfb8a 1263 if(!c->api) {
e83d0967 1264 if(c->speaker_command)
b50cfb8a 1265 c->api = xstrdup("command");
e83d0967 1266 else if(c->broadcast.n)
b50cfb8a
RK		 1267 c->api = xstrdup("rtp");
1268 else if(config_uaudio_apis)
1269 c->api = xstrdup(config_uaudio_apis[0]->name);
8aae240b 1270 else
b50cfb8a 1271 c->api = xstrdup("<none>");
e83d0967 1272 }
b50cfb8a
RK		 1273 if(!strcmp(c->api, "network"))
1274 c->api = xstrdup("rtp");
c00fce3a 1275 if(server) {
b50cfb8a 1276 if(!strcmp(c->api, "command") && !c->speaker_command)
bd8895a8 1277 fatal(0, "'api command' but speaker_command is not set");
b50cfb8a
RK		 1278 if((!strcmp(c->api, "rtp")) && !c->broadcast.n)
1279 fatal(0, "'api rtp' but broadcast is not set");
c00fce3a 1280 }
e99d42b1 1281 /* Override sample format */
b50cfb8a 1282 if(!strcmp(c->api, "rtp")) {
6d2d327c
RK		 1283 c->sample_format.rate = 44100;
1284 c->sample_format.channels = 2;
1285 c->sample_format.bits = 16;
b50cfb8a
RK		 1286 c->sample_format.endian = ENDIAN_NATIVE;
1287 }
1288 if(!strcmp(c->api, "coreaudio")) {
937be4c0
RK		 1289 c->sample_format.rate = 44100;
1290 c->sample_format.channels = 2;
1291 c->sample_format.bits = 16;
1292 c->sample_format.endian = ENDIAN_NATIVE;
04e1fa7c
RK		 1293 }
1294 if(!c->default_rights) {
1295 rights_type r = RIGHTS__MASK & ~(RIGHT_ADMIN|RIGHT_REGISTER
1296 |RIGHT_MOVE__MASK
1297 |RIGHT_SCRATCH__MASK
1298 |RIGHT_REMOVE__MASK);
1299 /* The idea is to approximate the meaning of the old 'restrict' directive
1300 * in the default rights if they are not overridden. */
1301 if(c->restrictions & RESTRICT_SCRATCH)
1302 r |= RIGHT_SCRATCH_MINE|RIGHT_SCRATCH_RANDOM;
1303 else
1304 r |= RIGHT_SCRATCH_ANY;
1305 if(!(c->restrictions & RESTRICT_MOVE))
1306 r |= RIGHT_MOVE_ANY;
1307 if(c->restrictions & RESTRICT_REMOVE)
1308 r |= RIGHT_REMOVE_MINE;
1309 else
1310 r |= RIGHT_REMOVE_ANY;
0f55e905 1311 c->default_rights = rights_string(r);
04e1fa7c 1312 }
460b9539 1313}
1314
c00fce3a
RK		 1315/** @brief (Re-)read the config file
1316 * @param server If set, do extra checking
1317 */
1318int config_read(int server) {
460b9539 1319 struct config *c;
1320 char *privconf;
1321 struct passwd *pw;
1322
1323 set_configfile();
1324 c = config_default();
9ade2319 1325 /* standalone Disobedience installs might not have a global config file */
1326 if(access(configfile, F_OK) == 0)
1327 if(config_include(c, configfile))
1328 return -1;
460b9539 1329 /* if we can read the private config file, do */
1330 if((privconf = config_private())
1331 && access(privconf, R_OK) == 0
1332 && config_include(c, privconf))
1333 return -1;
1334 xfree(privconf);
1335 /* if there's a per-user system config file for this user, read it */
63ad732f
RK		 1336 if(config_per_user) {
1337 if(!(pw = getpwuid(getuid())))
1338 fatal(0, "cannot determine our username");
1339 if((privconf = config_usersysconf(pw))
1340 && access(privconf, F_OK) == 0
1341 && config_include(c, privconf))
460b9539 1342 return -1;
63ad732f
RK		 1343 xfree(privconf);
1344 /* if we have a password file, read it */
5b14453f 1345 if((privconf = config_userconf(0, pw))
63ad732f
RK		 1346 && access(privconf, F_OK) == 0
1347 && config_include(c, privconf))
1348 return -1;
1349 xfree(privconf);
1350 }
460b9539 1351 /* install default namepart and transform settings */
c00fce3a 1352 config_postdefaults(c, server);
460b9539 1353 /* everything is good so we shall use the new config */
1354 config_free(config);
04e1fa7c
RK		 1355 /* warn about obsolete directives */
1356 if(c->restrictions)
1357 error(0, "'restrict' will be removed in a future version");
1358 if(c->allow.n)
1359 error(0, "'allow' will be removed in a future version");
1360 if(c->trust.n)
1361 error(0, "'trust' will be removed in a future version");
460b9539 1362 config = c;
1363 return 0;
1364}
1365
3f3bb97b 1366/** @brief Return the path to the private configuration file */
460b9539 1367char *config_private(void) {
1368 char *s;
1369
1370 set_configfile();
1371 byte_xasprintf(&s, "%s.private", configfile);
1372 return s;
1373}
1374
3f3bb97b 1375/** @brief Return the path to user's personal configuration file */
460b9539 1376char *config_userconf(const char *home, const struct passwd *pw) {
1377 char *s;
1378
73f1b9f3
RK		 1379 if(!home && !pw && !(pw = getpwuid(getuid())))
1380 fatal(0, "cannot determine our username");
460b9539 1381 byte_xasprintf(&s, "%s/.disorder/passwd", home ? home : pw->pw_dir);
1382 return s;
1383}
1384
3f3bb97b
RK		 1385/** @brief Return the path to user-specific system configuration */
1386char *config_usersysconf(const struct passwd *pw) {
460b9539 1387 char *s;
1388
1389 set_configfile();
1390 if(!strchr(pw->pw_name, '/')) {
1391 byte_xasprintf(&s, "%s.%s", configfile, pw->pw_name);
1392 return s;
1393 } else
1394 return 0;
1395}
1396
1397char *config_get_file(const char *name) {
319d7107 1398 return config_get_file2(config, name);
460b9539 1399}
1400
1401/*
1402Local Variables:
1403c-basic-offset:2
1404comment-column:40
1405fill-column:79
1406End:
1407*/
Multi-user software jukebox -- https://www.greenend.org.uk/rjk/disorder/