1 #include "config.h"
2 #if !HAVE_ERR
3 /*
4  * Copyright (c) 1993
5  *      The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 
32 #include <errno.h>
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 
38 void
39 vwarnx(const char *fmt, va_list ap)
40 {
41 	fprintf(stderr, "%s: ", getprogname());
42 	if (fmt != NULL)
43 		vfprintf(stderr, fmt, ap);
44 	fprintf(stderr, "\n");
45 }
46 
47 void
48 vwarnc(int code, const char *fmt, va_list ap)
49 {
50 	fprintf(stderr, "%s: ", getprogname());
51 	if (fmt != NULL) {
52 		vfprintf(stderr, fmt, ap);
53 		fprintf(stderr, ": ");
54 	}
55 	fprintf(stderr, "%s\n", strerror(code));
56 }
57 
58 void
59 vwarn(const char *fmt, va_list ap)
60 {
61 	int sverrno;
62 
63 	sverrno = errno;
64 	fprintf(stderr, "%s: ", getprogname());
65 	if (fmt != NULL) {
66 		vfprintf(stderr, fmt, ap);
67 		fprintf(stderr, ": ");
68 	}
69 	fprintf(stderr, "%s\n", strerror(sverrno));
70 }
71 
72 void
73 verrc(int eval, int code, const char *fmt, va_list ap)
74 {
75 	fprintf(stderr, "%s: ", getprogname());
76 	if (fmt != NULL) {
77 		vfprintf(stderr, fmt, ap);
78 		fprintf(stderr, ": ");
79 	}
80 	fprintf(stderr, "%s\n", strerror(code));
81 	exit(eval);
82 }
83 
84 void
85 verrx(int eval, const char *fmt, va_list ap)
86 {
87 	fprintf(stderr, "%s: ", getprogname());
88 	if (fmt != NULL)
89 		vfprintf(stderr, fmt, ap);
90 	fprintf(stderr, "\n");
91 	exit(eval);
92 }
93 
94 void
95 verr(int eval, const char *fmt, va_list ap)
96 {
97 	int sverrno;
98 
99 	sverrno = errno;
100 	fprintf(stderr, "%s: ", getprogname());
101 	if (fmt != NULL) {
102 		vfprintf(stderr, fmt, ap);
103 		fprintf(stderr, ": ");
104 	}
105 	fprintf(stderr, "%s\n", strerror(sverrno));
106 	exit(eval);
107 }
108 
109 void
110 err(int eval, const char *fmt, ...)
111 {
112 	va_list ap;
113 
114 	va_start(ap, fmt);
115 	verr(eval, fmt, ap);
116 	va_end(ap);
117 }
118 
119 void
120 errc(int eval, int code, const char *fmt, ...)
121 {
122 	va_list ap;
123 
124 	va_start(ap, fmt);
125 	verrc(eval, code, fmt, ap);
126 	va_end(ap);
127 }
128 
129 void
130 errx(int eval, const char *fmt, ...)
131 {
132 	va_list ap;
133 
134 	va_start(ap, fmt);
135 	verrx(eval, fmt, ap);
136 	va_end(ap);
137 }
138 
139 void
140 warn(const char *fmt, ...)
141 {
142 	va_list ap;
143 
144 	va_start(ap, fmt);
145 	vwarn(fmt, ap);
146 	va_end(ap);
147 }
148 
149 void
150 warnc(int code, const char *fmt, ...)
151 {
152 	va_list ap;
153 
154 	va_start(ap, fmt);
155 	vwarnc(code, fmt, ap);
156 	va_end(ap);
157 }
158 
159 void
160 warnx(const char *fmt, ...)
161 {
162 	va_list ap;
163 
164 	va_start(ap, fmt);
165 	vwarnx(fmt, ap);
166 	va_end(ap);
167 }
168 #endif /* !HAVE_ERR */
169 #if !HAVE_GETPROGNAME
170 /*
171  * Copyright (c) 2016 Nicholas Marriott <nicholas.marriott@gmail.com>
172  * Copyright (c) 2017 Kristaps Dzonsons <kristaps@bsd.lv>
173  * Copyright (c) 2020 Stephen Gregoratto <dev@sgregoratto.me>
174  *
175  * Permission to use, copy, modify, and distribute this software for any
176  * purpose with or without fee is hereby granted, provided that the above
177  * copyright notice and this permission notice appear in all copies.
178  *
179  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
180  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
181  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
182  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
183  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
184  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
185  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
186  */
187 
188 #include <sys/types.h>
189 
190 #include <errno.h>
191 
192 #if HAVE_GETEXECNAME
193 #include <stdlib.h>
194 const char *
195 getprogname(void)
196 {
197 	return getexecname();
198 }
199 #elif HAVE_PROGRAM_INVOCATION_SHORT_NAME
200 const char *
201 getprogname(void)
202 {
203 	return (program_invocation_short_name);
204 }
205 #elif HAVE___PROGNAME
206 const char *
207 getprogname(void)
208 {
209 	extern char	*__progname;
210 
211 	return (__progname);
212 }
213 #else
214 #error No getprogname available.
215 #endif
216 #endif /* !HAVE_GETPROGNAME */
217 #if !HAVE_SETRESGID
218 /*
219  * Copyright (c) 2004, 2005 Darren Tucker (dtucker at zip com au).
220  *
221  * Permission to use, copy, modify, and distribute this software for any
222  * purpose with or without fee is hereby granted, provided that the above
223  * copyright notice and this permission notice appear in all copies.
224  *
225  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
226  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
227  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
228  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
229  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
230  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
231  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
232  */
233 
234 #include <sys/types.h>
235 #include <unistd.h>
236 
237 int
238 setresgid(gid_t rgid, gid_t egid, gid_t sgid)
239 {
240 	/* this is the only configuration tested */
241 
242 	if (rgid != egid || egid != sgid)
243 		return -1;
244 
245 	if (setregid(rgid, egid) == -1)
246 		return -1;
247 
248 	return 0;
249 }
250 #endif /* !HAVE_SETRESGID */
251 #if !HAVE_SETRESUID
252 /*
253  * Copyright (c) 2004, 2005 Darren Tucker (dtucker at zip com au).
254  *
255  * Permission to use, copy, modify, and distribute this software for any
256  * purpose with or without fee is hereby granted, provided that the above
257  * copyright notice and this permission notice appear in all copies.
258  *
259  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
260  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
261  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
262  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
263  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
264  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
265  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
266  */
267 
268 #include <sys/types.h>
269 
270 #include <errno.h>
271 #include <unistd.h>
272 
273 int
274 setresuid(uid_t ruid, uid_t euid, uid_t suid)
275 {
276 	uid_t ouid;
277 	int ret = -1;
278 
279 	/* Allow only the tested configuration. */
280 
281 	if (ruid != euid || euid != suid) {
282 		errno = ENOSYS;
283 		return -1;
284 	}
285 	ouid = getuid();
286 
287 	if ((ret = setreuid(euid, euid)) == -1)
288 		return -1;
289 
290 	/*
291 	 * When real, effective and saved uids are the same and we have
292 	 * changed uids, sanity check that we cannot restore the old uid.
293 	 */
294 
295 	if (ruid == euid && euid == suid && ouid != ruid &&
296 	    setuid(ouid) != -1 && seteuid(ouid) != -1) {
297 		errno = EINVAL;
298 		return -1;
299 	}
300 
301 	/*
302 	 * Finally, check that the real and effective uids are what we
303 	 * expect.
304 	 */
305 	if (getuid() != ruid || geteuid() != euid) {
306 		errno = EACCES;
307 		return -1;
308 	}
309 
310 	return ret;
311 }
312 #endif /* !HAVE_SETRESUID */
313 #if !HAVE_STRLCAT
314 /*
315  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
316  *
317  * Permission to use, copy, modify, and distribute this software for any
318  * purpose with or without fee is hereby granted, provided that the above
319  * copyright notice and this permission notice appear in all copies.
320  *
321  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
322  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
323  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
324  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
325  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
326  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
327  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
328  */
329 
330 #include <sys/types.h>
331 #include <string.h>
332 
333 /*
334  * Appends src to string dst of size siz (unlike strncat, siz is the
335  * full size of dst, not space left).  At most siz-1 characters
336  * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
337  * Returns strlen(src) + MIN(siz, strlen(initial dst)).
338  * If retval >= siz, truncation occurred.
339  */
340 size_t
341 strlcat(char *dst, const char *src, size_t siz)
342 {
343 	char *d = dst;
344 	const char *s = src;
345 	size_t n = siz;
346 	size_t dlen;
347 
348 	/* Find the end of dst and adjust bytes left but don't go past end */
349 	while (n-- != 0 && *d != '\0')
350 		d++;
351 	dlen = d - dst;
352 	n = siz - dlen;
353 
354 	if (n == 0)
355 		return(dlen + strlen(s));
356 	while (*s != '\0') {
357 		if (n != 1) {
358 			*d++ = *s;
359 			n--;
360 		}
361 		s++;
362 	}
363 	*d = '\0';
364 
365 	return(dlen + (s - src));	/* count does not include NUL */
366 }
367 #endif /* !HAVE_STRLCAT */
368 #if !HAVE_STRLCPY
369 /*
370  * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
371  *
372  * Permission to use, copy, modify, and distribute this software for any
373  * purpose with or without fee is hereby granted, provided that the above
374  * copyright notice and this permission notice appear in all copies.
375  *
376  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
377  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
378  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
379  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
380  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
381  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
382  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
383  */
384 
385 #include <sys/types.h>
386 #include <string.h>
387 
388 /*
389  * Copy src to string dst of size siz.  At most siz-1 characters
390  * will be copied.  Always NUL terminates (unless siz == 0).
391  * Returns strlen(src); if retval >= siz, truncation occurred.
392  */
393 size_t
394 strlcpy(char *dst, const char *src, size_t siz)
395 {
396 	char *d = dst;
397 	const char *s = src;
398 	size_t n = siz;
399 
400 	/* Copy as many bytes as will fit */
401 	if (n != 0) {
402 		while (--n != 0) {
403 			if ((*d++ = *s++) == '\0')
404 				break;
405 		}
406 	}
407 
408 	/* Not enough room in dst, add NUL and traverse rest of src */
409 	if (n == 0) {
410 		if (siz != 0)
411 			*d = '\0';		/* NUL-terminate dst */
412 		while (*s++)
413 			;
414 	}
415 
416 	return(s - src - 1);	/* count does not include NUL */
417 }
418 #endif /* !HAVE_STRLCPY */
419 #if !HAVE_STRNDUP
420 /*	$OpenBSD$	*/
421 /*
422  * Copyright (c) 2010 Todd C. Miller <Todd.Miller@courtesan.com>
423  *
424  * Permission to use, copy, modify, and distribute this software for any
425  * purpose with or without fee is hereby granted, provided that the above
426  * copyright notice and this permission notice appear in all copies.
427  *
428  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
429  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
430  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
431  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
432  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
433  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
434  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
435  */
436 
437 #include <sys/types.h>
438 
439 #include <stddef.h>
440 #include <stdlib.h>
441 #include <string.h>
442 
443 char *
444 strndup(const char *str, size_t maxlen)
445 {
446 	char *copy;
447 	size_t len;
448 
449 	len = strnlen(str, maxlen);
450 	copy = malloc(len + 1);
451 	if (copy != NULL) {
452 		(void)memcpy(copy, str, len);
453 		copy[len] = '\0';
454 	}
455 
456 	return copy;
457 }
458 #endif /* !HAVE_STRNDUP */
459 #if !HAVE_STRNLEN
460 /*	$OpenBSD$	*/
461 
462 /*
463  * Copyright (c) 2010 Todd C. Miller <Todd.Miller@courtesan.com>
464  *
465  * Permission to use, copy, modify, and distribute this software for any
466  * purpose with or without fee is hereby granted, provided that the above
467  * copyright notice and this permission notice appear in all copies.
468  *
469  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
470  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
471  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
472  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
473  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
474  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
475  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
476  */
477 
478 #include <sys/types.h>
479 #include <string.h>
480 
481 size_t
482 strnlen(const char *str, size_t maxlen)
483 {
484 	const char *cp;
485 
486 	for (cp = str; maxlen != 0 && *cp != '\0'; cp++, maxlen--)
487 		;
488 
489 	return (size_t)(cp - str);
490 }
491 #endif /* !HAVE_STRNLEN */
492 #if !HAVE_STRTONUM
493 /*
494  * Copyright (c) 2004 Ted Unangst and Todd Miller
495  * All rights reserved.
496  *
497  * Permission to use, copy, modify, and distribute this software for any
498  * purpose with or without fee is hereby granted, provided that the above
499  * copyright notice and this permission notice appear in all copies.
500  *
501  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
502  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
503  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
504  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
505  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
506  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
507  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
508  */
509 
510 #include <errno.h>
511 #include <limits.h>
512 #include <stdlib.h>
513 
514 #define	INVALID		1
515 #define	TOOSMALL	2
516 #define	TOOLARGE	3
517 
518 long long
519 strtonum(const char *numstr, long long minval, long long maxval,
520     const char **errstrp)
521 {
522 	long long ll = 0;
523 	int error = 0;
524 	char *ep;
525 	struct errval {
526 		const char *errstr;
527 		int err;
528 	} ev[4] = {
529 		{ NULL,		0 },
530 		{ "invalid",	EINVAL },
531 		{ "too small",	ERANGE },
532 		{ "too large",	ERANGE },
533 	};
534 
535 	ev[0].err = errno;
536 	errno = 0;
537 	if (minval > maxval) {
538 		error = INVALID;
539 	} else {
540 		ll = strtoll(numstr, &ep, 10);
541 		if (numstr == ep || *ep != '\0')
542 			error = INVALID;
543 		else if ((ll == LLONG_MIN && errno == ERANGE) || ll < minval)
544 			error = TOOSMALL;
545 		else if ((ll == LLONG_MAX && errno == ERANGE) || ll > maxval)
546 			error = TOOLARGE;
547 	}
548 	if (errstrp != NULL)
549 		*errstrp = ev[error].errstr;
550 	errno = ev[error].err;
551 	if (error)
552 		ll = 0;
553 
554 	return (ll);
555 }
556 #endif /* !HAVE_STRTONUM */