Commit | Line | Data |
---|---|---|
7b8ff279 MW |
1 | /* -*-c-*- |
2 | * | |
3 | * Common functionality of a less principled nature | |
4 | * | |
5 | * (c) 2020 Mark Wooding | |
6 | */ | |
7 | ||
8 | /*----- Licensing notice --------------------------------------------------* | |
9 | * | |
10 | * This file is part of Runlisp, a tool for invoking Common Lisp scripts. | |
11 | * | |
12 | * Runlisp is free software: you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License as published by the | |
14 | * Free Software Foundation; either version 3 of the License, or (at your | |
15 | * option) any later version. | |
16 | * | |
17 | * Runlisp is distributed in the hope that it will be useful, but WITHOUT | |
18 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
19 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
20 | * for more details. | |
21 | * | |
22 | * You should have received a copy of the GNU General Public License | |
23 | * along with Runlisp. If not, see <https://www.gnu.org/licenses/>. | |
24 | */ | |
25 | ||
26 | /*----- Header files ------------------------------------------------------*/ | |
27 | ||
28 | #include "config.h" | |
29 | ||
30 | #include <assert.h> | |
31 | #include <ctype.h> | |
32 | #include <errno.h> | |
33 | #include <stdlib.h> | |
34 | #include <string.h> | |
35 | ||
36 | #include <dirent.h> | |
37 | #include <pwd.h> | |
38 | #include <unistd.h> | |
39 | ||
40 | #include <sys/stat.h> | |
41 | ||
42 | #include "common.h" | |
43 | #include "lib.h" | |
44 | ||
45 | /*----- Public variables --------------------------------------------------*/ | |
46 | ||
47 | struct config config = CONFIG_INIT; | |
48 | struct config_section *toplevel, *builtin, *common, *env; | |
49 | unsigned verbose = 1; | |
50 | ||
51 | /*----- Internal utilities ------------------------------------------------*/ | |
52 | ||
53 | static void escapify(struct dstr *d, const char *p) | |
54 | { | |
55 | size_t n; | |
56 | ||
57 | for (;;) { | |
58 | n = strcspn(p, "\"'\\"); | |
59 | if (n) { dstr_putm(d, p, n); p += n; } | |
60 | if (!*p) break; | |
61 | dstr_putc(d, '\\'); dstr_putc(d, *p++); | |
62 | } | |
63 | dstr_putz(d); | |
64 | } | |
65 | ||
66 | static void homedir(struct dstr *d) | |
67 | { | |
68 | static const char *home = 0; | |
69 | const char *p; | |
70 | struct passwd *pw; | |
71 | ||
72 | if (!home) { | |
73 | p = my_getenv("HOME", 0); | |
74 | if (p) home = p; | |
75 | else { | |
76 | pw = getpwuid(getuid()); | |
77 | if (!pw) lose("can't find user in password database"); | |
78 | home = xstrdup(pw->pw_dir); | |
79 | } | |
80 | } | |
81 | dstr_puts(d, home); | |
82 | } | |
83 | ||
84 | static void user_config_dir(struct dstr *d) | |
85 | { | |
86 | const char *p; | |
87 | ||
88 | p = my_getenv("XDG_CONFIG_HOME", 0); | |
89 | if (p) dstr_puts(d, p); | |
90 | else { homedir(d); dstr_puts(d, "/.config"); } | |
91 | } | |
92 | ||
93 | /*----- Miscellany --------------------------------------------------------*/ | |
94 | ||
95 | const char *my_getenv(const char *name, const char *dflt) | |
96 | { | |
97 | struct config_var *var; | |
98 | ||
99 | var = config_find_var(&config, env, 0, name); | |
100 | return (var ? var->val : dflt); | |
101 | } | |
102 | ||
103 | long parse_int(const char *what, const char *p, long min, long max) | |
104 | { | |
105 | long n; | |
106 | int oerr = errno; | |
107 | char *q; | |
108 | ||
109 | errno = 0; | |
110 | n = strtol(p, &q, 0); | |
111 | while (ISSPACE(*q)) q++; | |
112 | if (errno || *q) lose("invalid %s `%s'", what, p); | |
113 | if (n < min || n > max) | |
114 | lose("%s %ld out of range (must be between %ld and %ld)", | |
115 | what, n, min, max); | |
116 | errno = oerr; | |
117 | return (n); | |
118 | } | |
119 | ||
120 | void argv_string(struct dstr *d, const struct argv *av) | |
121 | { | |
122 | size_t i; | |
123 | ||
124 | for (i = 0; i < av->n; i++) { | |
125 | if (i) { dstr_putc(d, ','); dstr_putc(d, ' '); } | |
126 | dstr_putc(d, '`'); escapify(d, av->v[i]); dstr_putc(d, '\''); | |
127 | } | |
128 | dstr_putz(d); | |
129 | } | |
130 | ||
131 | /*----- File utilities ----------------------------------------------------*/ | |
132 | ||
133 | int file_exists_p(const char *path, unsigned f) | |
134 | { | |
135 | struct stat st; | |
136 | ||
137 | if (stat(path, &st)) { | |
138 | if (f&FEF_VERBOSE) moan("file `%s' not found", path); | |
139 | return (0); | |
140 | } else if (!(S_ISREG(st.st_mode))) { | |
141 | if (f&FEF_VERBOSE) moan("`%s' is not a regular file", path); | |
142 | return (0); | |
143 | } else if ((f&FEF_EXEC) && access(path, X_OK)) { | |
144 | if (f&FEF_VERBOSE) moan("file `%s' is not executable", path); | |
145 | return (0); | |
146 | } else { | |
147 | if (f&FEF_VERBOSE) moan("found file `%s'", path); | |
148 | return (1); | |
149 | } | |
150 | } | |
151 | ||
152 | int found_in_path_p(const char *prog, unsigned f) | |
153 | { | |
154 | struct dstr p = DSTR_INIT, d = DSTR_INIT; | |
155 | const char *path; | |
156 | char *q; | |
157 | size_t n, avail, proglen; | |
158 | int i, rc; | |
159 | ||
160 | if (strchr(prog, '/')) | |
161 | return (file_exists_p(prog, f)); | |
162 | path = my_getenv("PATH", 0); | |
163 | if (path) | |
164 | dstr_puts(&p, path); | |
165 | else { | |
166 | dstr_puts(&p, ".:"); | |
167 | i = 0; | |
168 | again: | |
169 | avail = p.sz - p.len; | |
170 | n = confstr(_CS_PATH, p.p + p.len, avail); | |
171 | if (avail > n) { i++; assert(i < 2); dstr_ensure(&p, n); goto again; } | |
172 | } | |
173 | ||
174 | q = p.p; proglen = strlen(prog); | |
175 | for (;;) { | |
176 | n = strcspn(q, ":"); | |
177 | dstr_reset(&d); | |
178 | if (n) dstr_putm(&d, q, n); | |
179 | else dstr_putc(&d, '.'); | |
180 | dstr_putc(&d, '/'); | |
181 | dstr_putm(&d, prog, proglen); | |
182 | dstr_putz(&d); | |
183 | if (file_exists_p(d.p, verbose >= 4 ? f : f&~FEF_VERBOSE)) { | |
184 | if (verbose == 2) moan("found program `%s'", d.p); | |
185 | rc = 1; goto end; | |
186 | } | |
187 | q += n; if (!*q) break; else q++; | |
188 | } | |
189 | ||
190 | rc = 0; | |
191 | end: | |
192 | dstr_release(&p); dstr_release(&d); | |
193 | return (rc); | |
194 | } | |
195 | ||
196 | int try_exec(struct argv *av, unsigned f) | |
197 | { | |
198 | struct dstr d = DSTR_INIT; | |
199 | int rc; | |
200 | ||
201 | assert(av->n); argv_appendz(av); | |
202 | if (verbose >= 2) { argv_string(&d, av); moan("trying %s...", d.p); } | |
203 | if (f&TEF_DRYRUN) { | |
204 | if (found_in_path_p(av->v[0], f&TEF_VERBOSE ? FEF_VERBOSE : 0)) | |
205 | { rc = 0; goto end; } | |
206 | } else { | |
207 | execvp(av->v[0], (/*unconst*/ char **)av->v); | |
208 | if (errno != ENOENT) { | |
209 | moan("failed to exec `%s': %s", av->v[0], strerror(errno)); | |
210 | _exit(2); | |
211 | } | |
212 | } | |
213 | ||
214 | if (verbose >= 2) moan("`%s' not found", av->v[0]); | |
215 | rc = -1; | |
216 | end: | |
217 | dstr_release(&d); | |
218 | return (rc); | |
219 | } | |
220 | ||
221 | /*----- Configuration -----------------------------------------------------*/ | |
222 | ||
223 | void read_config_file(const char *what, const char *file, unsigned f) | |
224 | { | |
225 | if (!config_read_file(&config, file, f)) { | |
226 | if (verbose >= 2) | |
227 | moan("read %s configuration file `%s'", what, file); | |
228 | } else { | |
229 | if (verbose >= 3) | |
230 | moan("ignoring missing %s configuration file `%s'", what, file); | |
231 | } | |
232 | } | |
233 | ||
234 | static int order_strings(const void *xx, const void *yy) | |
235 | { const char *const *x = xx, *const *y = yy; return (strcmp(*x, *y)); } | |
236 | ||
237 | void read_config_dir(const char *what, const char *path, unsigned f) | |
238 | { | |
239 | struct argv av = ARGV_INIT; | |
240 | struct dstr dd = DSTR_INIT; | |
241 | struct stat st; | |
242 | DIR *dir; | |
243 | struct dirent *d; | |
244 | size_t i, n, len; | |
245 | ||
246 | dir = opendir(path); | |
247 | if (!dir) { | |
248 | if (!(f&CF_NOENTOK) || errno != ENOENT) | |
249 | lose("failed to read %s configuration directory `%s': %s", | |
250 | what, path, strerror(errno)); | |
251 | if (verbose >= 3) | |
252 | moan("ignoring missing %s configuration directory `%s'", what, path); | |
253 | return; | |
254 | } | |
255 | ||
256 | dstr_puts(&dd, path); dstr_putc(&dd, '/'); n = dd.len; | |
257 | for (;;) { | |
258 | d = readdir(dir); if (!d) break; | |
259 | len = strlen(d->d_name); | |
260 | if (len < 5 || STRCMP(d->d_name + len - 5, !=, ".conf")) continue; | |
261 | dd.len = n; dstr_putm(&dd, d->d_name, len); dstr_putz(&dd); | |
262 | if (stat(dd.p, &st)) | |
263 | lose("failed to read file metadata for `%s': %s", | |
264 | dd.p, strerror(errno)); | |
265 | if (!S_ISREG(st.st_mode)) continue; | |
266 | argv_append(&av, xstrdup(d->d_name)); | |
267 | } | |
268 | ||
269 | qsort(av.v, av.n, sizeof(*av.v), order_strings); | |
270 | ||
271 | for (i = 0; i < av.n; i++) { | |
272 | dd.len = n; dstr_puts(&dd, av.v[i]); | |
273 | read_config_file(what, dd.p, f&~CF_NOENTOK); | |
274 | } | |
275 | ||
276 | for (i = 0; i < av.n; i++) free((/*unconst*/ char *)av.v[i]); | |
277 | argv_release(&av); dstr_release(&dd); closedir(dir); | |
278 | return; | |
279 | } | |
280 | ||
281 | void read_config_path(const char *path, unsigned f) | |
282 | { | |
283 | struct stat st; | |
284 | ||
285 | if (!stat(path, &st) && S_ISDIR(st.st_mode)) | |
286 | read_config_dir("command-line specified ", path, f); | |
287 | else | |
288 | read_config_file("command-line specified", path, f); | |
289 | } | |
290 | ||
291 | int set_config_var(const char *assign) | |
292 | { | |
293 | struct config_section *sect; | |
294 | const char *p, *q; | |
295 | ||
296 | p = strchr(assign, '='); | |
297 | if (!p) { moan("missing `=' in option assignment"); return (-1); } | |
298 | q = strchr(assign, ':'); | |
299 | if (!q || q > p) | |
300 | { sect = toplevel; q = assign; } | |
301 | else { | |
302 | sect = config_find_section_n(&config, CF_CREAT, assign, q - assign); | |
303 | q++; | |
304 | } | |
305 | config_set_var_n(&config, sect, CF_LITERAL | CF_OVERRIDE, | |
306 | q, p - q, p + 1, strlen(p + 1)); | |
307 | return (0); | |
308 | } | |
309 | ||
310 | void init_config(void) | |
311 | { | |
312 | toplevel = config_find_section(&config, CF_CREAT, "@CONFIG"); | |
313 | builtin = config_find_section(&config, CF_CREAT, "@BUILTIN"); | |
314 | common = config_find_section(&config, CF_CREAT, "@COMMON"); | |
315 | env = config_find_section(&config, CF_CREAT, "@ENV"); | |
316 | config_set_fallback(&config, common); | |
317 | config_set_parent(builtin, 0); | |
318 | config_set_parent(common, builtin); | |
319 | config_set_parent(toplevel, 0); | |
320 | config_read_env(&config, env); | |
321 | ||
322 | config_set_var(&config, toplevel, CF_LITERAL, "data-dir", | |
323 | my_getenv("RUNLISP_DATADIR", DATADIR)); | |
324 | config_set_var(&config, toplevel, CF_LITERAL, "image-dir", | |
325 | my_getenv("RUNLISP_IMAGEDIR", IMAGEDIR)); | |
326 | ||
327 | #ifdef ECL_OPTIONS_GNU | |
328 | config_set_var(&config, builtin, CF_LITERAL, "@ECLOPT", "--"); | |
329 | #else | |
330 | config_set_var(&config, builtin, CF_LITERAL, "@ECLOPT", "-"); | |
331 | #endif | |
332 | } | |
333 | ||
334 | void load_default_config(void) | |
335 | { | |
336 | const char *p; | |
337 | struct dstr d = DSTR_INIT; | |
338 | ||
339 | p = my_getenv("RUNLISP_SYSCONFIG", ETCDIR "/runlisp.conf"); | |
340 | read_config_file("system", p, 0); | |
341 | p = my_getenv("RUNLISP_SYSCONFIG_DIR", ETCDIR "/runlisp.d"); | |
342 | read_config_dir("system", p, CF_NOENTOK); | |
343 | p = my_getenv("RUNLISP_USERCONFIG", 0); | |
344 | if (p) | |
345 | read_config_file("user", p, CF_NOENTOK); | |
346 | else { | |
347 | dstr_reset(&d); homedir(&d); dstr_puts(&d, "/.runlisp.conf"); | |
348 | read_config_file("user", d.p, CF_NOENTOK); | |
349 | dstr_reset(&d); user_config_dir(&d); dstr_puts(&d, "/runlisp.conf"); | |
350 | read_config_file("user", d.p, CF_NOENTOK); | |
351 | } | |
352 | dstr_release(&d); | |
353 | } | |
354 | ||
355 | void dump_config(void) | |
356 | { | |
357 | struct config_section_iter si; | |
358 | struct config_section *sect; | |
359 | struct config_var_iter vi; | |
360 | struct config_var *var; | |
361 | struct dstr d = DSTR_INIT; | |
362 | ||
363 | for (config_start_section_iter(&config, &si); | |
364 | (sect = config_next_section(&si)); ) | |
365 | for (config_start_var_iter(sect, &vi); | |
366 | (var = config_next_var(&vi)); ) { | |
367 | dstr_reset(&d); escapify(&d, var->val); | |
368 | moan("config %s:%s = `%s'", | |
369 | CONFIG_SECTION_NAME(sect), CONFIG_VAR_NAME(var), d.p); | |
370 | } | |
371 | dstr_release(&d); | |
372 | } | |
373 | ||
374 | /*----- That's all, folks -------------------------------------------------*/ |