Gotweb

Blob

Date:: Wed Mar 8 09:27:14 2023 UTC
Message:: portable: configure: split out dependencies Rather than assume all dependencies are required for all programs, split them out. This will make packaging easier, as well as splitting the code to use subprojects. Note that due to the use of config.h semantics, in most cases the got_compat.h header file is now at the top of the .c file it is included in, so that it can handle the system header inclusion properly.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2018, 2019 Stefan Sperling <stsp@openbsd.org>
3  * Copyright (c) 2015 Theo de Raadt <deraadt@openbsd.org>
4  * Copyright (c) 1997 Todd C. Miller <millert@openbsd.org>
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 AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 
19 #include "got_compat.h"
20 
21 #include <sys/queue.h>
22 #include <sys/stat.h>
23 
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <limits.h>
27 #include <libgen.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <dirent.h>
33 #include <paths.h>
34 
35 #include "got_error.h"
36 #include "got_path.h"
37 
38 #ifndef MIN
39 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
40 #endif
41 
42 int
43 got_path_is_absolute(const char *path)
44 {
45 	return path[0] == '/';
46 }
47 
48 /* based on canonpath() from kern_pledge.c */
49 const struct got_error *
50 got_canonpath(const char *input, char *buf, size_t bufsize)
51 {
52 	const char *p;
53 	char *q;
54 
55 	/* can't canon relative paths, don't bother */
56 	if (!got_path_is_absolute(input)) {
57 		if (strlcpy(buf, input, bufsize) >= bufsize)
58 			return got_error(GOT_ERR_NO_SPACE);
59 		return NULL;
60 	}
61 
62 	p = input;
63 	q = buf;
64 	while (*p && (q - buf < bufsize)) {
65 		if (p[0] == '/' && (p[1] == '/' || p[1] == '\0')) {
66 			p += 1;
67 
68 		} else if (p[0] == '/' && p[1] == '.' &&
69 		    (p[2] == '/' || p[2] == '\0')) {
70 			p += 2;
71 
72 		} else if (p[0] == '/' && p[1] == '.' && p[2] == '.' &&
73 		    (p[3] == '/' || p[3] == '\0')) {
74 			p += 3;
75 			if (q != buf)	/* "/../" at start of buf */
76 				while (*--q != '/')
77 					continue;
78 
79 		} else {
80 			*q++ = *p++;
81 		}
82 	}
83 	if ((*p == '\0') && (q - buf < bufsize)) {
84 		*q = 0;
85 		return NULL;
86 	} else
87 		return got_error(GOT_ERR_NO_SPACE);
88 }
89 
90 const struct got_error *
91 got_path_skip_common_ancestor(char **child, const char *parent_abspath,
92     const char *abspath)
93 {
94 	const struct got_error *err = NULL;
95 	size_t len_parent, len, bufsize;
96 
97 	*child = NULL;
98 
99 	len_parent = strlen(parent_abspath);
100 	len = strlen(abspath);
101 	if (len_parent >= len)
102 		return got_error_path(abspath, GOT_ERR_BAD_PATH);
103 	if (strncmp(parent_abspath, abspath, len_parent) != 0)
104 		return got_error_path(abspath, GOT_ERR_BAD_PATH);
105 	if (!got_path_is_root_dir(parent_abspath) && abspath[len_parent] != '/')
106 		return got_error_path(abspath, GOT_ERR_BAD_PATH);
107 	while (abspath[len_parent] == '/')
108 		abspath++;
109 	bufsize = len - len_parent + 1;
110 	*child = malloc(bufsize);
111 	if (*child == NULL)
112 		return got_error_from_errno("malloc");
113 	if (strlcpy(*child, abspath + len_parent, bufsize) >= bufsize) {
114 		err = got_error_from_errno("strlcpy");
115 		free(*child);
116 		*child = NULL;
117 		return err;
118 	}
119 	return NULL;
120 }
121 
122 const struct got_error *
123 got_path_strip(char **out, const char *path, int n)
124 {
125 	const char *p, *c;
126 
127 	p = path;
128 	*out = NULL;
129 
130 	while (n > 0 && (c = strchr(p, '/')) != NULL) {
131 		p = c + 1;
132 		n--;
133 	}
134 
135 	if (n > 0)
136 		return got_error_fmt(GOT_ERR_BAD_PATH,
137 		    "can't strip %d path-components from %s", n, path);
138 
139 	if ((*out = strdup(p)) == NULL)
140 		return got_error_from_errno("strdup");
141 	return NULL;
142 }
143 
144 int
145 got_path_is_root_dir(const char *path)
146 {
147 	while (*path == '/')
148 		path++;
149 	return (*path == '\0');
150 }
151 
152 int
153 got_path_is_child(const char *child, const char *parent, size_t parent_len)
154 {
155 	if (parent_len == 0 || got_path_is_root_dir(parent))
156 		return 1;
157 
158 	if (strncmp(parent, child, parent_len) != 0)
159 		return 0;
160 	if (child[parent_len] != '/')
161 		return 0;
162 
163 	return 1;
164 }
165 
166 int
167 got_path_cmp(const char *path1, const char *path2, size_t len1, size_t len2)
168 {
169 	size_t min_len;
170 	size_t i = 0;
171 
172 	/* Leading directory separators are insignificant. */
173 	while (path1[0] == '/') {
174 		path1++;
175 		len1--;
176 	}
177 	while (path2[0] == '/') {
178 		path2++;
179 		len2--;
180 	}
181 
182 	min_len = MIN(len1, len2);
183 
184 	/* Skip over common prefix. */
185 	while (i < min_len && path1[i] == path2[i])
186 		i++;
187 
188 	/* Are the paths exactly equal (besides path separators)? */
189 	if (len1 == len2 && i >= min_len)
190 		return 0;
191 
192 	/* Skip over redundant trailing path seperators. */
193 	while (path1[i] == '/' && path1[i + 1] == '/')
194 		path1++;
195 	while (path2[i] == '/' && path2[i + 1] == '/')
196 		path2++;
197 
198 	/* Trailing path separators are insignificant. */
199 	if (path1[i] == '/' && path1[i + 1] == '\0' && path2[i] == '\0')
200 		return 0;
201 	if (path2[i] == '/' && path2[i + 1] == '\0' && path1[i] == '\0')
202 		return 0;
203 
204 	/* Order children in subdirectories directly after their parents. */
205 	if (path1[i] == '/' && path2[i] == '\0')
206 		return 1;
207 	if (path2[i] == '/' && path1[i] == '\0')
208 		return -1;
209 	if (path1[i] == '/' && path2[i] != '\0')
210 		return -1;
211 	if (path2[i] == '/' && path1[i] != '\0')
212 		return 1;
213 
214 	/* Next character following the common prefix determines order. */
215 	return (unsigned char)path1[i] < (unsigned char)path2[i] ? -1 : 1;
216 }
217 
218 const struct got_error *
219 got_pathlist_insert(struct got_pathlist_entry **inserted,
220     struct got_pathlist_head *pathlist, const char *path, void *data)
221 {
222 	struct got_pathlist_entry *new, *pe;
223 	size_t path_len = strlen(path);
224 
225 	if (inserted)
226 		*inserted = NULL;
227 
228 	/*
229 	 * Many callers will provide paths in a somewhat sorted order while
230 	 * constructing a path list from inputs such as tree objects or
231 	 * dirents. Iterating backwards from the tail of the list should
232 	 * be more efficient than traversing through the entire list each
233 	 * time an element is inserted.
234 	 */
235 	pe = TAILQ_LAST(pathlist, got_pathlist_head);
236 	while (pe) {
237 		int cmp = got_path_cmp(pe->path, path, pe->path_len, path_len);
238 		if (cmp == 0)
239 			return NULL;  /* duplicate */
240 		else if (cmp < 0)
241 			break;
242 		pe = TAILQ_PREV(pe, got_pathlist_head, entry);
243 	}
244 
245 	new = malloc(sizeof(*new));
246 	if (new == NULL)
247 		return got_error_from_errno("malloc");
248 	new->path = path;
249 	new->path_len = path_len;
250 	new->data = data;
251 	if (pe)
252 		TAILQ_INSERT_AFTER(pathlist, pe, new, entry);
253 	else
254 		TAILQ_INSERT_HEAD(pathlist, new, entry);
255 	if (inserted)
256 		*inserted = new;
257 	return NULL;
258 }
259 
260 const struct got_error *
261 got_pathlist_append(struct got_pathlist_head *pathlist,
262     const char *path, void *data)
263 {
264 	struct got_pathlist_entry *new;
265 
266 	new = malloc(sizeof(*new));
267 	if (new == NULL)
268 		return got_error_from_errno("malloc");
269 	new->path = path;
270 	new->path_len = strlen(path);
271 	new->data = data;
272 	TAILQ_INSERT_TAIL(pathlist, new, entry);
273 	return NULL;
274 }
275 
276 void
277 got_pathlist_free(struct got_pathlist_head *pathlist, int freemask)
278 {
279 	struct got_pathlist_entry *pe;
280 
281 	while ((pe = TAILQ_FIRST(pathlist)) != NULL) {
282 		if (freemask & GOT_PATHLIST_FREE_PATH) {
283 			free((char *)pe->path);
284 			pe->path = NULL;
285 		}
286 		if (freemask & GOT_PATHLIST_FREE_DATA) {
287 			free(pe->data);
288 			pe->data = NULL;
289 		}
290 		TAILQ_REMOVE(pathlist, pe, entry);
291 		free(pe);
292 	}
293 }
294 
295 static const struct got_error *
296 make_parent_dirs(const char *abspath)
297 {
298 	const struct got_error *err = NULL;
299 	char *parent;
300 
301 	err = got_path_dirname(&parent, abspath);
302 	if (err)
303 		return err;
304 
305 	if (mkdir(parent, GOT_DEFAULT_DIR_MODE) == -1) {
306 		if (errno == ENOENT) {
307 			err = make_parent_dirs(parent);
308 			if (err)
309 				goto done;
310 			if (mkdir(parent, GOT_DEFAULT_DIR_MODE) == -1) {
311 				err = got_error_from_errno2("mkdir", parent);
312 				goto done;
313 			}
314 		} else
315 			err = got_error_from_errno2("mkdir", parent);
316 	}
317 done:
318 	free(parent);
319 	return err;
320 }
321 
322 const struct got_error *
323 got_path_mkdir(const char *abspath)
324 {
325 	const struct got_error *err = NULL;
326 
327 	if (mkdir(abspath, GOT_DEFAULT_DIR_MODE) == -1) {
328 		if (errno == ENOENT) {
329 			err = make_parent_dirs(abspath);
330 			if (err)
331 				goto done;
332 			if (mkdir(abspath, GOT_DEFAULT_DIR_MODE) == -1)
333 				err = got_error_from_errno2("mkdir", abspath);
334 		} else
335 			err = got_error_from_errno2("mkdir", abspath);
336 	}
337 
338 done:
339 	return err;
340 }
341 
342 int
343 got_path_dir_is_empty(const char *dir)
344 {
345 	DIR *d;
346 	struct dirent *dent;
347 	int empty = 1;
348 
349 	d = opendir(dir);
350 	if (d == NULL)
351 		return 1;
352 
353 	while ((dent = readdir(d)) != NULL) {
354 		if (strcmp(dent->d_name, ".") == 0 ||
355 		    strcmp(dent->d_name, "..") == 0)
356 			continue;
357 
358 		empty = 0;
359 		break;
360 	}
361 
362 	closedir(d);
363 	return empty;
364 }
365 
366 const struct got_error *
367 got_path_dirname(char **parent, const char *path)
368 {
369 	char buf[PATH_MAX];
370 	char *p;
371 
372 	if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf))
373 		return got_error(GOT_ERR_NO_SPACE);
374 
375 	p = dirname(buf);
376 	if (p == NULL)
377 		return got_error_from_errno2("dirname", path);
378 
379 	if (p[0] == '.' && p[1] == '\0')
380 		return got_error_path(path, GOT_ERR_BAD_PATH);
381 
382 	*parent = strdup(p);
383 	if (*parent == NULL)
384 		return got_error_from_errno("strdup");
385 
386 	return NULL;
387 }
388 
389 const struct got_error *
390 got_path_dirent_type(int *type, const char *path_parent, struct dirent *dent)
391 {
392 	const struct got_error *err = NULL;
393 	char *path_child;
394 	struct stat sb;
395 
396 	if (dent->d_type != DT_UNKNOWN) {
397 		*type = dent->d_type;
398 		return NULL;
399 	}
400 
401 	*type = DT_UNKNOWN;
402 
403 	/*
404 	 * This is a fallback to accommodate filesystems which do not
405 	 * provide directory entry type information. DT_UNKNOWN directory
406 	 * entries occur on NFS mounts without "readdir plus" RPC.
407 	 */
408 
409 	if (asprintf(&path_child, "%s/%s", path_parent, dent->d_name) == -1)
410 		return got_error_from_errno("asprintf");
411 
412 	if (lstat(path_child, &sb) == -1) {
413 		err = got_error_from_errno2("lstat", path_child);
414 		goto done;
415 	}
416 
417 	if (S_ISFIFO(sb.st_mode))
418 		*type = DT_FIFO;
419 	else if (S_ISCHR(sb.st_mode))
420 		*type = DT_CHR;
421 	else if (S_ISDIR(sb.st_mode))
422 		*type = DT_DIR;
423 	else if (S_ISBLK(sb.st_mode))
424 		*type = DT_BLK;
425 	else if (S_ISLNK(sb.st_mode))
426 		*type = DT_LNK;
427 	else if (S_ISREG(sb.st_mode))
428 		*type = DT_REG;
429 	else if (S_ISSOCK(sb.st_mode))
430 		*type = DT_SOCK;
431 done:
432 	free(path_child);
433 	return err;
434 }
435 
436 const struct got_error *
437 got_path_basename(char **s, const char *path)
438 {
439 	char buf[PATH_MAX];
440 	char *base;
441 
442 	if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf))
443 		return got_error(GOT_ERR_NO_SPACE);
444 
445 	base = basename(buf);
446 	if (base == NULL)
447 		return got_error_from_errno2("basename", path);
448 
449 	*s = strdup(base);
450 	if (*s == NULL)
451 		return got_error_from_errno("strdup");
452 
453 	return NULL;
454 }
455 
456 void
457 got_path_strip_trailing_slashes(char *path)
458 {
459 	size_t x;
460 
461 	x = strlen(path);
462 	while (x-- > 0 && path[x] == '/')
463 		path[x] = '\0';
464 }
465 
466 /* based on findprog() from usr.bin/which/which.c */
467 const struct got_error *
468 got_path_find_prog(char **filename, const char *prog)
469 {
470 	const struct got_error *err = NULL;
471 	const char *path;
472 	char *p;
473 	int len;
474 	struct stat sbuf;
475 	char *pathcpy, *dup = NULL;
476 
477 	*filename = NULL;
478 
479 	path = getenv("PATH");
480 	if (path == NULL)
481 		path = _PATH_DEFPATH;
482 
483 	/* Special case if prog contains '/' */
484 	if (strchr(prog, '/')) {
485 		if ((stat(prog, &sbuf) == 0) && S_ISREG(sbuf.st_mode) &&
486 		    access(prog, X_OK) == 0) {
487 			*filename = strdup(prog);
488 			if (*filename == NULL)
489 				return got_error_from_errno("strdup");
490 		}
491 		return NULL;
492 	}
493 
494 	if ((dup = strdup(path)) == NULL)
495 		return got_error_from_errno("strdup");
496 	pathcpy = dup;
497 
498 	while ((p = strsep(&pathcpy, ":")) != NULL) {
499 		const char *d;
500 
501 		len = strlen(p);
502 		while (len > 0 && p[len-1] == '/')
503 			p[--len] = '\0';	/* strip trailing '/' */
504 
505 		d = p;
506 		if (*d == '\0')
507 			d = ".";
508 
509 		if (asprintf(filename, "%s/%s", d, prog) == -1) {
510 			err = got_error_from_errno("asprintf");
511 			break;
512 		}
513 		if ((stat(*filename, &sbuf) == 0) && S_ISREG(sbuf.st_mode) &&
514 		    access(*filename, X_OK) == 0)
515 			break;
516 		free(*filename);
517 		*filename = NULL;
518 	}
519 	free(dup);
520 	return err;
521 }
522 
523 const struct got_error *
524 got_path_create_file(const char *path, const char *content)
525 {
526 	const struct got_error *err = NULL;
527 	int fd = -1;
528 
529 	fd = open(path, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW | O_CLOEXEC,
530 	    GOT_DEFAULT_FILE_MODE);
531 	if (fd == -1) {
532 		err = got_error_from_errno2("open", path);
533 		goto done;
534 	}
535 
536 	if (content) {
537 		int len = dprintf(fd, "%s\n", content);
538 		if (len != strlen(content) + 1) {
539 			err = got_error_from_errno("dprintf");
540 			goto done;
541 		}
542 	}
543 
544 done:
545 	if (fd != -1 && close(fd) == -1 && err == NULL)
546 		err = got_error_from_errno("close");
547 	return err;
548 }
549 
550 const struct got_error *
551 got_path_move_file(const char *oldpath, const char *newpath)
552 {
553 	const struct got_error *err;
554 
555 	if (rename(oldpath, newpath) != -1)
556 		return NULL;
557 
558 	if (errno != ENOENT)
559 		return got_error_from_errno3("rename", oldpath, newpath);
560 
561 	err = make_parent_dirs(newpath);
562 	if (err)
563 		return err;
564 
565 	if (rename(oldpath, newpath) == -1)
566 		return got_error_from_errno3("rename", oldpath, newpath);
567 
568 	return NULL;
569 }