1/*	$Id: manpath.c,v 1.29 2015/11/07 17:58:55 schwarze Exp $	*/
2/*
3 * Copyright (c) 2011, 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
4 * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18#include "config.h"
19
20#include <sys/types.h>
21#include <sys/stat.h>
22
23#include <ctype.h>
24#if HAVE_ERR
25#include <err.h>
26#endif
27#include <limits.h>
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31
32#include "mandoc_aux.h"
33#include "manconf.h"
34
35#if !HAVE_MANPATH
36static	void	 manconf_file(struct manconf *, const char *);
37#endif
38static	void	 manpath_add(struct manpaths *, const char *, int);
39static	void	 manpath_parseline(struct manpaths *, char *, int);
40
41
42void
43manconf_parse(struct manconf *conf, const char *file,
44		char *defp, char *auxp)
45{
46#if HAVE_MANPATH
47	char		 cmd[(PATH_MAX * 3) + 20];
48	FILE		*stream;
49	char		*buf;
50	size_t		 sz, bsz;
51
52	strlcpy(cmd, "manpath", sizeof(cmd));
53	if (file) {
54		strlcat(cmd, " -C ", sizeof(cmd));
55		strlcat(cmd, file, sizeof(cmd));
56	}
57	if (auxp) {
58		strlcat(cmd, " -m ", sizeof(cmd));
59		strlcat(cmd, auxp, sizeof(cmd));
60	}
61	if (defp) {
62		strlcat(cmd, " -M ", sizeof(cmd));
63		strlcat(cmd, defp, sizeof(cmd));
64	}
65
66	/* Open manpath(1).  Ignore errors. */
67
68	stream = popen(cmd, "r");
69	if (NULL == stream)
70		return;
71
72	buf = NULL;
73	bsz = 0;
74
75	/* Read in as much output as we can. */
76
77	do {
78		buf = mandoc_realloc(buf, bsz + 1024);
79		sz = fread(buf + bsz, 1, 1024, stream);
80		bsz += sz;
81	} while (sz > 0);
82
83	if ( ! ferror(stream) && feof(stream) &&
84			bsz && '\n' == buf[bsz - 1]) {
85		buf[bsz - 1] = '\0';
86		manpath_parseline(&conf->manpath, buf, 1);
87	}
88
89	free(buf);
90	pclose(stream);
91#else
92	char		*insert;
93
94	/* Always prepend -m. */
95	manpath_parseline(&conf->manpath, auxp, 1);
96
97	/* If -M is given, it overrides everything else. */
98	if (NULL != defp) {
99		manpath_parseline(&conf->manpath, defp, 1);
100		return;
101	}
102
103	/* MANPATH and man.conf(5) cooperate. */
104	defp = getenv("MANPATH");
105	if (NULL == file)
106		file = MAN_CONF_FILE;
107
108	/* No MANPATH; use man.conf(5) only. */
109	if (NULL == defp || '\0' == defp[0]) {
110		manconf_file(conf, file);
111		return;
112	}
113
114	/* Prepend man.conf(5) to MANPATH. */
115	if (':' == defp[0]) {
116		manconf_file(conf, file);
117		manpath_parseline(&conf->manpath, defp, 0);
118		return;
119	}
120
121	/* Append man.conf(5) to MANPATH. */
122	if (':' == defp[strlen(defp) - 1]) {
123		manpath_parseline(&conf->manpath, defp, 0);
124		manconf_file(conf, file);
125		return;
126	}
127
128	/* Insert man.conf(5) into MANPATH. */
129	insert = strstr(defp, "::");
130	if (NULL != insert) {
131		*insert++ = '\0';
132		manpath_parseline(&conf->manpath, defp, 0);
133		manconf_file(conf, file);
134		manpath_parseline(&conf->manpath, insert + 1, 0);
135		return;
136	}
137
138	/* MANPATH overrides man.conf(5) completely. */
139	manpath_parseline(&conf->manpath, defp, 0);
140#endif
141}
142
143/*
144 * Parse a FULL pathname from a colon-separated list of arrays.
145 */
146static void
147manpath_parseline(struct manpaths *dirs, char *path, int complain)
148{
149	char	*dir;
150
151	if (NULL == path)
152		return;
153
154	for (dir = strtok(path, ":"); dir; dir = strtok(NULL, ":"))
155		manpath_add(dirs, dir, complain);
156}
157
158/*
159 * Add a directory to the array, ignoring bad directories.
160 * Grow the array one-by-one for simplicity's sake.
161 */
162static void
163manpath_add(struct manpaths *dirs, const char *dir, int complain)
164{
165	char		 buf[PATH_MAX];
166	struct stat	 sb;
167	char		*cp;
168	size_t		 i;
169
170	if (NULL == (cp = realpath(dir, buf))) {
171		if (complain)
172			warn("manpath: %s", dir);
173		return;
174	}
175
176	for (i = 0; i < dirs->sz; i++)
177		if (0 == strcmp(dirs->paths[i], dir))
178			return;
179
180	if (stat(cp, &sb) == -1) {
181		if (complain)
182			warn("manpath: %s", dir);
183		return;
184	}
185
186	dirs->paths = mandoc_reallocarray(dirs->paths,
187	    dirs->sz + 1, sizeof(char *));
188
189	dirs->paths[dirs->sz++] = mandoc_strdup(cp);
190}
191
192void
193manconf_free(struct manconf *conf)
194{
195	size_t		 i;
196
197	for (i = 0; i < conf->manpath.sz; i++)
198		free(conf->manpath.paths[i]);
199
200	free(conf->manpath.paths);
201	free(conf->output.includes);
202	free(conf->output.man);
203	free(conf->output.paper);
204	free(conf->output.style);
205}
206
207#if !HAVE_MANPATH
208static void
209manconf_file(struct manconf *conf, const char *file)
210{
211	const char *const toks[] = { "manpath", "output", "_whatdb" };
212	char manpath_default[] = MANPATH_DEFAULT;
213
214	FILE		*stream;
215	char		*line, *cp, *ep;
216	size_t		 linesz, tok, toklen;
217	ssize_t		 linelen;
218
219	if ((stream = fopen(file, "r")) == NULL)
220		goto out;
221
222	line = NULL;
223	linesz = 0;
224
225	while ((linelen = getline(&line, &linesz, stream)) != -1) {
226		cp = line;
227		ep = cp + linelen;
228		if (ep[-1] != '\n')
229			break;
230		*--ep = '\0';
231		while (isspace((unsigned char)*cp))
232			cp++;
233		if (*cp == '#')
234			continue;
235
236		for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {
237			toklen = strlen(toks[tok]);
238			if (cp + toklen < ep &&
239			    isspace((unsigned char)cp[toklen]) &&
240			    strncmp(cp, toks[tok], toklen) == 0) {
241				cp += toklen;
242				while (isspace((unsigned char)*cp))
243					cp++;
244				break;
245			}
246		}
247
248		switch (tok) {
249		case 2:  /* _whatdb */
250			while (ep > cp && ep[-1] != '/')
251				ep--;
252			if (ep == cp)
253				continue;
254			*ep = '\0';
255			/* FALLTHROUGH */
256		case 0:  /* manpath */
257			manpath_add(&conf->manpath, cp, 0);
258			*manpath_default = '\0';
259			break;
260		case 1:  /* output */
261			manconf_output(&conf->output, cp);
262			break;
263		default:
264			break;
265		}
266	}
267	free(line);
268	fclose(stream);
269
270out:
271	if (*manpath_default != '\0')
272		manpath_parseline(&conf->manpath, manpath_default, 0);
273}
274#endif
275
276void
277manconf_output(struct manoutput *conf, const char *cp)
278{
279	const char *const toks[] = {
280	    "includes", "man", "paper", "style",
281	    "indent", "width", "fragment", "mdoc"
282	};
283
284	size_t	 len, tok;
285
286	for (tok = 0; tok < sizeof(toks)/sizeof(toks[0]); tok++) {
287		len = strlen(toks[tok]);
288		if ( ! strncmp(cp, toks[tok], len) &&
289		    strchr(" =	", cp[len]) != NULL) {
290			cp += len;
291			if (*cp == '=')
292				cp++;
293			while (isspace((unsigned char)*cp))
294				cp++;
295			break;
296		}
297	}
298
299	if (tok < 6 && *cp == '\0')
300		return;
301
302	switch (tok) {
303	case 0:
304		if (conf->includes == NULL)
305			conf->includes = mandoc_strdup(cp);
306		break;
307	case 1:
308		if (conf->man == NULL)
309			conf->man = mandoc_strdup(cp);
310		break;
311	case 2:
312		if (conf->paper == NULL)
313			conf->paper = mandoc_strdup(cp);
314		break;
315	case 3:
316		if (conf->style == NULL)
317			conf->style = mandoc_strdup(cp);
318		break;
319	case 4:
320		if (conf->indent == 0)
321			conf->indent = strtonum(cp, 0, 1000, NULL);
322		break;
323	case 5:
324		if (conf->width == 0)
325			conf->width = strtonum(cp, 58, 1000, NULL);
326		break;
327	case 6:
328		conf->fragment = 1;
329		break;
330	case 7:
331		conf->mdoc = 1;
332		break;
333	default:
334		break;
335	}
336}
337