xref: /dflybsd-src/crypto/openssh/misc.c (revision ba1276acd1c8c22d225b1bcf370a14c878644f44)
1*ba1276acSMatthew Dillon /* $OpenBSD: misc.c,v 1.196 2024/06/06 17:15:25 djm Exp $ */
218de8d7fSPeter Avalos /*
318de8d7fSPeter Avalos  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
450a69bb5SSascha Wildner  * Copyright (c) 2005-2020 Damien Miller.  All rights reserved.
550a69bb5SSascha Wildner  * Copyright (c) 2004 Henning Brauer <henning@openbsd.org>
618de8d7fSPeter Avalos  *
750a69bb5SSascha Wildner  * Permission to use, copy, modify, and distribute this software for any
850a69bb5SSascha Wildner  * purpose with or without fee is hereby granted, provided that the above
950a69bb5SSascha Wildner  * copyright notice and this permission notice appear in all copies.
1018de8d7fSPeter Avalos  *
1150a69bb5SSascha Wildner  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1250a69bb5SSascha Wildner  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1350a69bb5SSascha Wildner  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1450a69bb5SSascha Wildner  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1550a69bb5SSascha Wildner  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1650a69bb5SSascha Wildner  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1750a69bb5SSascha Wildner  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1818de8d7fSPeter Avalos  */
1918de8d7fSPeter Avalos 
2050a69bb5SSascha Wildner 
2118de8d7fSPeter Avalos #include "includes.h"
2218de8d7fSPeter Avalos 
2318de8d7fSPeter Avalos #include <sys/types.h>
2418de8d7fSPeter Avalos #include <sys/ioctl.h>
25*ba1276acSMatthew Dillon #include <sys/mman.h>
2618de8d7fSPeter Avalos #include <sys/socket.h>
27ce74bacaSMatthew Dillon #include <sys/stat.h>
28e9778795SPeter Avalos #include <sys/time.h>
29ce74bacaSMatthew Dillon #include <sys/wait.h>
3036e94dc5SPeter Avalos #include <sys/un.h>
3118de8d7fSPeter Avalos 
32e9778795SPeter Avalos #include <limits.h>
33ce74bacaSMatthew Dillon #ifdef HAVE_LIBGEN_H
34ce74bacaSMatthew Dillon # include <libgen.h>
35ce74bacaSMatthew Dillon #endif
360cbfa66cSDaniel Fojt #ifdef HAVE_POLL_H
37664f4763Szrj #include <poll.h>
380cbfa66cSDaniel Fojt #endif
39*ba1276acSMatthew Dillon #ifdef HAVE_NLIST_H
40*ba1276acSMatthew Dillon #include <nlist.h>
41*ba1276acSMatthew Dillon #endif
42ce74bacaSMatthew Dillon #include <signal.h>
4318de8d7fSPeter Avalos #include <stdarg.h>
4418de8d7fSPeter Avalos #include <stdio.h>
45*ba1276acSMatthew Dillon #ifdef HAVE_STDINT_H
46*ba1276acSMatthew Dillon # include <stdint.h>
47*ba1276acSMatthew Dillon #endif
4818de8d7fSPeter Avalos #include <stdlib.h>
4918de8d7fSPeter Avalos #include <string.h>
509f304aafSPeter Avalos #include <time.h>
5118de8d7fSPeter Avalos #include <unistd.h>
5218de8d7fSPeter Avalos 
5318de8d7fSPeter Avalos #include <netinet/in.h>
549f304aafSPeter Avalos #include <netinet/in_systm.h>
559f304aafSPeter Avalos #include <netinet/ip.h>
5618de8d7fSPeter Avalos #include <netinet/tcp.h>
57664f4763Szrj #include <arpa/inet.h>
5818de8d7fSPeter Avalos 
5936e94dc5SPeter Avalos #include <ctype.h>
6018de8d7fSPeter Avalos #include <errno.h>
6118de8d7fSPeter Avalos #include <fcntl.h>
6218de8d7fSPeter Avalos #include <netdb.h>
6318de8d7fSPeter Avalos #ifdef HAVE_PATHS_H
6418de8d7fSPeter Avalos # include <paths.h>
6518de8d7fSPeter Avalos #include <pwd.h>
6650a69bb5SSascha Wildner #include <grp.h>
6718de8d7fSPeter Avalos #endif
6818de8d7fSPeter Avalos #ifdef SSH_TUN_OPENBSD
6918de8d7fSPeter Avalos #include <net/if.h>
7018de8d7fSPeter Avalos #endif
7118de8d7fSPeter Avalos 
7218de8d7fSPeter Avalos #include "xmalloc.h"
7318de8d7fSPeter Avalos #include "misc.h"
7418de8d7fSPeter Avalos #include "log.h"
7518de8d7fSPeter Avalos #include "ssh.h"
76ce74bacaSMatthew Dillon #include "sshbuf.h"
77ce74bacaSMatthew Dillon #include "ssherr.h"
78ce74bacaSMatthew Dillon #include "platform.h"
7918de8d7fSPeter Avalos 
8018de8d7fSPeter Avalos /* remove newline at end of string */
8118de8d7fSPeter Avalos char *
chop(char * s)8218de8d7fSPeter Avalos chop(char *s)
8318de8d7fSPeter Avalos {
8418de8d7fSPeter Avalos 	char *t = s;
8518de8d7fSPeter Avalos 	while (*t) {
8618de8d7fSPeter Avalos 		if (*t == '\n' || *t == '\r') {
8718de8d7fSPeter Avalos 			*t = '\0';
8818de8d7fSPeter Avalos 			return s;
8918de8d7fSPeter Avalos 		}
9018de8d7fSPeter Avalos 		t++;
9118de8d7fSPeter Avalos 	}
9218de8d7fSPeter Avalos 	return s;
9318de8d7fSPeter Avalos 
9418de8d7fSPeter Avalos }
9518de8d7fSPeter Avalos 
9650a69bb5SSascha Wildner /* remove whitespace from end of string */
9750a69bb5SSascha Wildner void
rtrim(char * s)9850a69bb5SSascha Wildner rtrim(char *s)
9950a69bb5SSascha Wildner {
10050a69bb5SSascha Wildner 	size_t i;
10150a69bb5SSascha Wildner 
10250a69bb5SSascha Wildner 	if ((i = strlen(s)) == 0)
10350a69bb5SSascha Wildner 		return;
10450a69bb5SSascha Wildner 	for (i--; i > 0; i--) {
105*ba1276acSMatthew Dillon 		if (isspace((unsigned char)s[i]))
10650a69bb5SSascha Wildner 			s[i] = '\0';
10750a69bb5SSascha Wildner 	}
10850a69bb5SSascha Wildner }
10950a69bb5SSascha Wildner 
11018de8d7fSPeter Avalos /* set/unset filedescriptor to non-blocking */
11118de8d7fSPeter Avalos int
set_nonblock(int fd)11218de8d7fSPeter Avalos set_nonblock(int fd)
11318de8d7fSPeter Avalos {
11418de8d7fSPeter Avalos 	int val;
11518de8d7fSPeter Avalos 
116e9778795SPeter Avalos 	val = fcntl(fd, F_GETFL);
1170cbfa66cSDaniel Fojt 	if (val == -1) {
118e9778795SPeter Avalos 		error("fcntl(%d, F_GETFL): %s", fd, strerror(errno));
11918de8d7fSPeter Avalos 		return (-1);
12018de8d7fSPeter Avalos 	}
12118de8d7fSPeter Avalos 	if (val & O_NONBLOCK) {
12218de8d7fSPeter Avalos 		debug3("fd %d is O_NONBLOCK", fd);
12318de8d7fSPeter Avalos 		return (0);
12418de8d7fSPeter Avalos 	}
12518de8d7fSPeter Avalos 	debug2("fd %d setting O_NONBLOCK", fd);
12618de8d7fSPeter Avalos 	val |= O_NONBLOCK;
12718de8d7fSPeter Avalos 	if (fcntl(fd, F_SETFL, val) == -1) {
12818de8d7fSPeter Avalos 		debug("fcntl(%d, F_SETFL, O_NONBLOCK): %s", fd,
12918de8d7fSPeter Avalos 		    strerror(errno));
13018de8d7fSPeter Avalos 		return (-1);
13118de8d7fSPeter Avalos 	}
13218de8d7fSPeter Avalos 	return (0);
13318de8d7fSPeter Avalos }
13418de8d7fSPeter Avalos 
13518de8d7fSPeter Avalos int
unset_nonblock(int fd)13618de8d7fSPeter Avalos unset_nonblock(int fd)
13718de8d7fSPeter Avalos {
13818de8d7fSPeter Avalos 	int val;
13918de8d7fSPeter Avalos 
140e9778795SPeter Avalos 	val = fcntl(fd, F_GETFL);
1410cbfa66cSDaniel Fojt 	if (val == -1) {
142e9778795SPeter Avalos 		error("fcntl(%d, F_GETFL): %s", fd, strerror(errno));
14318de8d7fSPeter Avalos 		return (-1);
14418de8d7fSPeter Avalos 	}
14518de8d7fSPeter Avalos 	if (!(val & O_NONBLOCK)) {
14618de8d7fSPeter Avalos 		debug3("fd %d is not O_NONBLOCK", fd);
14718de8d7fSPeter Avalos 		return (0);
14818de8d7fSPeter Avalos 	}
14918de8d7fSPeter Avalos 	debug("fd %d clearing O_NONBLOCK", fd);
15018de8d7fSPeter Avalos 	val &= ~O_NONBLOCK;
15118de8d7fSPeter Avalos 	if (fcntl(fd, F_SETFL, val) == -1) {
15218de8d7fSPeter Avalos 		debug("fcntl(%d, F_SETFL, ~O_NONBLOCK): %s",
15318de8d7fSPeter Avalos 		    fd, strerror(errno));
15418de8d7fSPeter Avalos 		return (-1);
15518de8d7fSPeter Avalos 	}
15618de8d7fSPeter Avalos 	return (0);
15718de8d7fSPeter Avalos }
15818de8d7fSPeter Avalos 
15918de8d7fSPeter Avalos const char *
ssh_gai_strerror(int gaierr)16018de8d7fSPeter Avalos ssh_gai_strerror(int gaierr)
16118de8d7fSPeter Avalos {
16236e94dc5SPeter Avalos 	if (gaierr == EAI_SYSTEM && errno != 0)
16318de8d7fSPeter Avalos 		return strerror(errno);
16418de8d7fSPeter Avalos 	return gai_strerror(gaierr);
16518de8d7fSPeter Avalos }
16618de8d7fSPeter Avalos 
16718de8d7fSPeter Avalos /* disable nagle on socket */
16818de8d7fSPeter Avalos void
set_nodelay(int fd)16918de8d7fSPeter Avalos set_nodelay(int fd)
17018de8d7fSPeter Avalos {
17118de8d7fSPeter Avalos 	int opt;
17218de8d7fSPeter Avalos 	socklen_t optlen;
17318de8d7fSPeter Avalos 
17418de8d7fSPeter Avalos 	optlen = sizeof opt;
17518de8d7fSPeter Avalos 	if (getsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, &optlen) == -1) {
17618de8d7fSPeter Avalos 		debug("getsockopt TCP_NODELAY: %.100s", strerror(errno));
17718de8d7fSPeter Avalos 		return;
17818de8d7fSPeter Avalos 	}
17918de8d7fSPeter Avalos 	if (opt == 1) {
18018de8d7fSPeter Avalos 		debug2("fd %d is TCP_NODELAY", fd);
18118de8d7fSPeter Avalos 		return;
18218de8d7fSPeter Avalos 	}
18318de8d7fSPeter Avalos 	opt = 1;
18418de8d7fSPeter Avalos 	debug2("fd %d setting TCP_NODELAY", fd);
18518de8d7fSPeter Avalos 	if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof opt) == -1)
18618de8d7fSPeter Avalos 		error("setsockopt TCP_NODELAY: %.100s", strerror(errno));
18718de8d7fSPeter Avalos }
18818de8d7fSPeter Avalos 
189664f4763Szrj /* Allow local port reuse in TIME_WAIT */
190664f4763Szrj int
set_reuseaddr(int fd)191664f4763Szrj set_reuseaddr(int fd)
192664f4763Szrj {
193664f4763Szrj 	int on = 1;
194664f4763Szrj 
195664f4763Szrj 	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
196664f4763Szrj 		error("setsockopt SO_REUSEADDR fd %d: %s", fd, strerror(errno));
197664f4763Szrj 		return -1;
198664f4763Szrj 	}
199664f4763Szrj 	return 0;
200664f4763Szrj }
201664f4763Szrj 
202664f4763Szrj /* Get/set routing domain */
203664f4763Szrj char *
get_rdomain(int fd)204664f4763Szrj get_rdomain(int fd)
205664f4763Szrj {
206664f4763Szrj #if defined(HAVE_SYS_GET_RDOMAIN)
207664f4763Szrj 	return sys_get_rdomain(fd);
208664f4763Szrj #elif defined(__OpenBSD__)
209664f4763Szrj 	int rtable;
210664f4763Szrj 	char *ret;
211664f4763Szrj 	socklen_t len = sizeof(rtable);
212664f4763Szrj 
213664f4763Szrj 	if (getsockopt(fd, SOL_SOCKET, SO_RTABLE, &rtable, &len) == -1) {
214664f4763Szrj 		error("Failed to get routing domain for fd %d: %s",
215664f4763Szrj 		    fd, strerror(errno));
216664f4763Szrj 		return NULL;
217664f4763Szrj 	}
218664f4763Szrj 	xasprintf(&ret, "%d", rtable);
219664f4763Szrj 	return ret;
220664f4763Szrj #else /* defined(__OpenBSD__) */
221664f4763Szrj 	return NULL;
222664f4763Szrj #endif
223664f4763Szrj }
224664f4763Szrj 
225664f4763Szrj int
set_rdomain(int fd,const char * name)226664f4763Szrj set_rdomain(int fd, const char *name)
227664f4763Szrj {
228664f4763Szrj #if defined(HAVE_SYS_SET_RDOMAIN)
229664f4763Szrj 	return sys_set_rdomain(fd, name);
230664f4763Szrj #elif defined(__OpenBSD__)
231664f4763Szrj 	int rtable;
232664f4763Szrj 	const char *errstr;
233664f4763Szrj 
234664f4763Szrj 	if (name == NULL)
235664f4763Szrj 		return 0; /* default table */
236664f4763Szrj 
237664f4763Szrj 	rtable = (int)strtonum(name, 0, 255, &errstr);
238664f4763Szrj 	if (errstr != NULL) {
239664f4763Szrj 		/* Shouldn't happen */
240664f4763Szrj 		error("Invalid routing domain \"%s\": %s", name, errstr);
241664f4763Szrj 		return -1;
242664f4763Szrj 	}
243664f4763Szrj 	if (setsockopt(fd, SOL_SOCKET, SO_RTABLE,
244664f4763Szrj 	    &rtable, sizeof(rtable)) == -1) {
245664f4763Szrj 		error("Failed to set routing domain %d on fd %d: %s",
246664f4763Szrj 		    rtable, fd, strerror(errno));
247664f4763Szrj 		return -1;
248664f4763Szrj 	}
249664f4763Szrj 	return 0;
250664f4763Szrj #else /* defined(__OpenBSD__) */
251664f4763Szrj 	error("Setting routing domain is not supported on this platform");
252664f4763Szrj 	return -1;
253664f4763Szrj #endif
254664f4763Szrj }
255664f4763Szrj 
25650a69bb5SSascha Wildner int
get_sock_af(int fd)25750a69bb5SSascha Wildner get_sock_af(int fd)
25850a69bb5SSascha Wildner {
25950a69bb5SSascha Wildner 	struct sockaddr_storage to;
26050a69bb5SSascha Wildner 	socklen_t tolen = sizeof(to);
26150a69bb5SSascha Wildner 
26250a69bb5SSascha Wildner 	memset(&to, 0, sizeof(to));
26350a69bb5SSascha Wildner 	if (getsockname(fd, (struct sockaddr *)&to, &tolen) == -1)
26450a69bb5SSascha Wildner 		return -1;
26550a69bb5SSascha Wildner #ifdef IPV4_IN_IPV6
26650a69bb5SSascha Wildner 	if (to.ss_family == AF_INET6 &&
26750a69bb5SSascha Wildner 	    IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)&to)->sin6_addr))
26850a69bb5SSascha Wildner 		return AF_INET;
26950a69bb5SSascha Wildner #endif
27050a69bb5SSascha Wildner 	return to.ss_family;
27150a69bb5SSascha Wildner }
27250a69bb5SSascha Wildner 
27350a69bb5SSascha Wildner void
set_sock_tos(int fd,int tos)27450a69bb5SSascha Wildner set_sock_tos(int fd, int tos)
27550a69bb5SSascha Wildner {
27650a69bb5SSascha Wildner #ifndef IP_TOS_IS_BROKEN
27750a69bb5SSascha Wildner 	int af;
27850a69bb5SSascha Wildner 
27950a69bb5SSascha Wildner 	switch ((af = get_sock_af(fd))) {
28050a69bb5SSascha Wildner 	case -1:
28150a69bb5SSascha Wildner 		/* assume not a socket */
28250a69bb5SSascha Wildner 		break;
28350a69bb5SSascha Wildner 	case AF_INET:
28450a69bb5SSascha Wildner # ifdef IP_TOS
28550a69bb5SSascha Wildner 		debug3_f("set socket %d IP_TOS 0x%02x", fd, tos);
28650a69bb5SSascha Wildner 		if (setsockopt(fd, IPPROTO_IP, IP_TOS,
28750a69bb5SSascha Wildner 		    &tos, sizeof(tos)) == -1) {
288*ba1276acSMatthew Dillon 			error("setsockopt socket %d IP_TOS %d: %s",
28950a69bb5SSascha Wildner 			    fd, tos, strerror(errno));
29050a69bb5SSascha Wildner 		}
29150a69bb5SSascha Wildner # endif /* IP_TOS */
29250a69bb5SSascha Wildner 		break;
29350a69bb5SSascha Wildner 	case AF_INET6:
29450a69bb5SSascha Wildner # ifdef IPV6_TCLASS
29550a69bb5SSascha Wildner 		debug3_f("set socket %d IPV6_TCLASS 0x%02x", fd, tos);
29650a69bb5SSascha Wildner 		if (setsockopt(fd, IPPROTO_IPV6, IPV6_TCLASS,
29750a69bb5SSascha Wildner 		    &tos, sizeof(tos)) == -1) {
298*ba1276acSMatthew Dillon 			error("setsockopt socket %d IPV6_TCLASS %d: %s",
29950a69bb5SSascha Wildner 			    fd, tos, strerror(errno));
30050a69bb5SSascha Wildner 		}
30150a69bb5SSascha Wildner # endif /* IPV6_TCLASS */
30250a69bb5SSascha Wildner 		break;
30350a69bb5SSascha Wildner 	default:
30450a69bb5SSascha Wildner 		debug2_f("unsupported socket family %d", af);
30550a69bb5SSascha Wildner 		break;
30650a69bb5SSascha Wildner 	}
30750a69bb5SSascha Wildner #endif /* IP_TOS_IS_BROKEN */
30850a69bb5SSascha Wildner }
30950a69bb5SSascha Wildner 
310664f4763Szrj /*
3110cbfa66cSDaniel Fojt  * Wait up to *timeoutp milliseconds for events on fd. Updates
312664f4763Szrj  * *timeoutp with time remaining.
313664f4763Szrj  * Returns 0 if fd ready or -1 on timeout or error (see errno).
314664f4763Szrj  */
3150cbfa66cSDaniel Fojt static int
waitfd(int fd,int * timeoutp,short events,volatile sig_atomic_t * stop)316*ba1276acSMatthew Dillon waitfd(int fd, int *timeoutp, short events, volatile sig_atomic_t *stop)
317664f4763Szrj {
318664f4763Szrj 	struct pollfd pfd;
319*ba1276acSMatthew Dillon 	struct timespec timeout;
320664f4763Szrj 	int oerrno, r;
321*ba1276acSMatthew Dillon 	sigset_t nsigset, osigset;
322664f4763Szrj 
323*ba1276acSMatthew Dillon 	if (timeoutp && *timeoutp == -1)
324*ba1276acSMatthew Dillon 		timeoutp = NULL;
325664f4763Szrj 	pfd.fd = fd;
3260cbfa66cSDaniel Fojt 	pfd.events = events;
327*ba1276acSMatthew Dillon 	ptimeout_init(&timeout);
328*ba1276acSMatthew Dillon 	if (timeoutp != NULL)
329*ba1276acSMatthew Dillon 		ptimeout_deadline_ms(&timeout, *timeoutp);
330*ba1276acSMatthew Dillon 	if (stop != NULL)
331*ba1276acSMatthew Dillon 		sigfillset(&nsigset);
332*ba1276acSMatthew Dillon 	for (; timeoutp == NULL || *timeoutp >= 0;) {
333*ba1276acSMatthew Dillon 		if (stop != NULL) {
334*ba1276acSMatthew Dillon 			sigprocmask(SIG_BLOCK, &nsigset, &osigset);
335*ba1276acSMatthew Dillon 			if (*stop) {
336*ba1276acSMatthew Dillon 				sigprocmask(SIG_SETMASK, &osigset, NULL);
337*ba1276acSMatthew Dillon 				errno = EINTR;
338*ba1276acSMatthew Dillon 				return -1;
339*ba1276acSMatthew Dillon 			}
340*ba1276acSMatthew Dillon 		}
341*ba1276acSMatthew Dillon 		r = ppoll(&pfd, 1, ptimeout_get_tsp(&timeout),
342*ba1276acSMatthew Dillon 		    stop != NULL ? &osigset : NULL);
343664f4763Szrj 		oerrno = errno;
344*ba1276acSMatthew Dillon 		if (stop != NULL)
345*ba1276acSMatthew Dillon 			sigprocmask(SIG_SETMASK, &osigset, NULL);
346*ba1276acSMatthew Dillon 		if (timeoutp)
347*ba1276acSMatthew Dillon 			*timeoutp = ptimeout_get_ms(&timeout);
348664f4763Szrj 		errno = oerrno;
349664f4763Szrj 		if (r > 0)
350664f4763Szrj 			return 0;
35150a69bb5SSascha Wildner 		else if (r == -1 && errno != EAGAIN && errno != EINTR)
352664f4763Szrj 			return -1;
353664f4763Szrj 		else if (r == 0)
354664f4763Szrj 			break;
355664f4763Szrj 	}
356664f4763Szrj 	/* timeout */
357664f4763Szrj 	errno = ETIMEDOUT;
358664f4763Szrj 	return -1;
359664f4763Szrj }
360664f4763Szrj 
361664f4763Szrj /*
3620cbfa66cSDaniel Fojt  * Wait up to *timeoutp milliseconds for fd to be readable. Updates
3630cbfa66cSDaniel Fojt  * *timeoutp with time remaining.
3640cbfa66cSDaniel Fojt  * Returns 0 if fd ready or -1 on timeout or error (see errno).
3650cbfa66cSDaniel Fojt  */
3660cbfa66cSDaniel Fojt int
waitrfd(int fd,int * timeoutp,volatile sig_atomic_t * stop)367*ba1276acSMatthew Dillon waitrfd(int fd, int *timeoutp, volatile sig_atomic_t *stop) {
368*ba1276acSMatthew Dillon 	return waitfd(fd, timeoutp, POLLIN, stop);
3690cbfa66cSDaniel Fojt }
3700cbfa66cSDaniel Fojt 
3710cbfa66cSDaniel Fojt /*
372664f4763Szrj  * Attempt a non-blocking connect(2) to the specified address, waiting up to
373664f4763Szrj  * *timeoutp milliseconds for the connection to complete. If the timeout is
374664f4763Szrj  * <=0, then wait indefinitely.
375664f4763Szrj  *
376664f4763Szrj  * Returns 0 on success or -1 on failure.
377664f4763Szrj  */
378664f4763Szrj int
timeout_connect(int sockfd,const struct sockaddr * serv_addr,socklen_t addrlen,int * timeoutp)379664f4763Szrj timeout_connect(int sockfd, const struct sockaddr *serv_addr,
380664f4763Szrj     socklen_t addrlen, int *timeoutp)
381664f4763Szrj {
382664f4763Szrj 	int optval = 0;
383664f4763Szrj 	socklen_t optlen = sizeof(optval);
384664f4763Szrj 
385664f4763Szrj 	/* No timeout: just do a blocking connect() */
386664f4763Szrj 	if (timeoutp == NULL || *timeoutp <= 0)
387664f4763Szrj 		return connect(sockfd, serv_addr, addrlen);
388664f4763Szrj 
389664f4763Szrj 	set_nonblock(sockfd);
39050a69bb5SSascha Wildner 	for (;;) {
391664f4763Szrj 		if (connect(sockfd, serv_addr, addrlen) == 0) {
392664f4763Szrj 			/* Succeeded already? */
393664f4763Szrj 			unset_nonblock(sockfd);
394664f4763Szrj 			return 0;
39550a69bb5SSascha Wildner 		} else if (errno == EINTR)
39650a69bb5SSascha Wildner 			continue;
39750a69bb5SSascha Wildner 		else if (errno != EINPROGRESS)
398664f4763Szrj 			return -1;
39950a69bb5SSascha Wildner 		break;
40050a69bb5SSascha Wildner 	}
401664f4763Szrj 
402*ba1276acSMatthew Dillon 	if (waitfd(sockfd, timeoutp, POLLIN | POLLOUT, NULL) == -1)
403664f4763Szrj 		return -1;
404664f4763Szrj 
405664f4763Szrj 	/* Completed or failed */
406664f4763Szrj 	if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &optval, &optlen) == -1) {
407664f4763Szrj 		debug("getsockopt: %s", strerror(errno));
408664f4763Szrj 		return -1;
409664f4763Szrj 	}
410664f4763Szrj 	if (optval != 0) {
411664f4763Szrj 		errno = optval;
412664f4763Szrj 		return -1;
413664f4763Szrj 	}
414664f4763Szrj 	unset_nonblock(sockfd);
415664f4763Szrj 	return 0;
416664f4763Szrj }
417664f4763Szrj 
41818de8d7fSPeter Avalos /* Characters considered whitespace in strsep calls. */
41918de8d7fSPeter Avalos #define WHITESPACE " \t\r\n"
42018de8d7fSPeter Avalos #define QUOTE	"\""
42118de8d7fSPeter Avalos 
42218de8d7fSPeter Avalos /* return next token in configuration line */
423664f4763Szrj static char *
strdelim_internal(char ** s,int split_equals)424664f4763Szrj strdelim_internal(char **s, int split_equals)
42518de8d7fSPeter Avalos {
42618de8d7fSPeter Avalos 	char *old;
42718de8d7fSPeter Avalos 	int wspace = 0;
42818de8d7fSPeter Avalos 
42918de8d7fSPeter Avalos 	if (*s == NULL)
43018de8d7fSPeter Avalos 		return NULL;
43118de8d7fSPeter Avalos 
43218de8d7fSPeter Avalos 	old = *s;
43318de8d7fSPeter Avalos 
434664f4763Szrj 	*s = strpbrk(*s,
435664f4763Szrj 	    split_equals ? WHITESPACE QUOTE "=" : WHITESPACE QUOTE);
43618de8d7fSPeter Avalos 	if (*s == NULL)
43718de8d7fSPeter Avalos 		return (old);
43818de8d7fSPeter Avalos 
43918de8d7fSPeter Avalos 	if (*s[0] == '\"') {
44018de8d7fSPeter Avalos 		memmove(*s, *s + 1, strlen(*s)); /* move nul too */
44118de8d7fSPeter Avalos 		/* Find matching quote */
44218de8d7fSPeter Avalos 		if ((*s = strpbrk(*s, QUOTE)) == NULL) {
44318de8d7fSPeter Avalos 			return (NULL);		/* no matching quote */
44418de8d7fSPeter Avalos 		} else {
44518de8d7fSPeter Avalos 			*s[0] = '\0';
446856ea928SPeter Avalos 			*s += strspn(*s + 1, WHITESPACE) + 1;
44718de8d7fSPeter Avalos 			return (old);
44818de8d7fSPeter Avalos 		}
44918de8d7fSPeter Avalos 	}
45018de8d7fSPeter Avalos 
45118de8d7fSPeter Avalos 	/* Allow only one '=' to be skipped */
452664f4763Szrj 	if (split_equals && *s[0] == '=')
45318de8d7fSPeter Avalos 		wspace = 1;
45418de8d7fSPeter Avalos 	*s[0] = '\0';
45518de8d7fSPeter Avalos 
45618de8d7fSPeter Avalos 	/* Skip any extra whitespace after first token */
45718de8d7fSPeter Avalos 	*s += strspn(*s + 1, WHITESPACE) + 1;
458664f4763Szrj 	if (split_equals && *s[0] == '=' && !wspace)
45918de8d7fSPeter Avalos 		*s += strspn(*s + 1, WHITESPACE) + 1;
46018de8d7fSPeter Avalos 
46118de8d7fSPeter Avalos 	return (old);
46218de8d7fSPeter Avalos }
46318de8d7fSPeter Avalos 
464664f4763Szrj /*
465664f4763Szrj  * Return next token in configuration line; splts on whitespace or a
466664f4763Szrj  * single '=' character.
467664f4763Szrj  */
468664f4763Szrj char *
strdelim(char ** s)469664f4763Szrj strdelim(char **s)
470664f4763Szrj {
471664f4763Szrj 	return strdelim_internal(s, 1);
472664f4763Szrj }
473664f4763Szrj 
474664f4763Szrj /*
475664f4763Szrj  * Return next token in configuration line; splts on whitespace only.
476664f4763Szrj  */
477664f4763Szrj char *
strdelimw(char ** s)478664f4763Szrj strdelimw(char **s)
479664f4763Szrj {
480664f4763Szrj 	return strdelim_internal(s, 0);
481664f4763Szrj }
482664f4763Szrj 
48318de8d7fSPeter Avalos struct passwd *
pwcopy(struct passwd * pw)48418de8d7fSPeter Avalos pwcopy(struct passwd *pw)
48518de8d7fSPeter Avalos {
48618de8d7fSPeter Avalos 	struct passwd *copy = xcalloc(1, sizeof(*copy));
48718de8d7fSPeter Avalos 
48818de8d7fSPeter Avalos 	copy->pw_name = xstrdup(pw->pw_name);
48950a69bb5SSascha Wildner 	copy->pw_passwd = xstrdup(pw->pw_passwd == NULL ? "*" : pw->pw_passwd);
49036e94dc5SPeter Avalos #ifdef HAVE_STRUCT_PASSWD_PW_GECOS
49118de8d7fSPeter Avalos 	copy->pw_gecos = xstrdup(pw->pw_gecos);
49236e94dc5SPeter Avalos #endif
49318de8d7fSPeter Avalos 	copy->pw_uid = pw->pw_uid;
49418de8d7fSPeter Avalos 	copy->pw_gid = pw->pw_gid;
49536e94dc5SPeter Avalos #ifdef HAVE_STRUCT_PASSWD_PW_EXPIRE
49618de8d7fSPeter Avalos 	copy->pw_expire = pw->pw_expire;
49718de8d7fSPeter Avalos #endif
49836e94dc5SPeter Avalos #ifdef HAVE_STRUCT_PASSWD_PW_CHANGE
49918de8d7fSPeter Avalos 	copy->pw_change = pw->pw_change;
50018de8d7fSPeter Avalos #endif
50136e94dc5SPeter Avalos #ifdef HAVE_STRUCT_PASSWD_PW_CLASS
50218de8d7fSPeter Avalos 	copy->pw_class = xstrdup(pw->pw_class);
50318de8d7fSPeter Avalos #endif
50418de8d7fSPeter Avalos 	copy->pw_dir = xstrdup(pw->pw_dir);
50518de8d7fSPeter Avalos 	copy->pw_shell = xstrdup(pw->pw_shell);
50618de8d7fSPeter Avalos 	return copy;
50718de8d7fSPeter Avalos }
50818de8d7fSPeter Avalos 
50918de8d7fSPeter Avalos /*
51018de8d7fSPeter Avalos  * Convert ASCII string to TCP/IP port number.
511cb5eb4f1SPeter Avalos  * Port must be >=0 and <=65535.
512cb5eb4f1SPeter Avalos  * Return -1 if invalid.
51318de8d7fSPeter Avalos  */
51418de8d7fSPeter Avalos int
a2port(const char * s)51518de8d7fSPeter Avalos a2port(const char *s)
51618de8d7fSPeter Avalos {
517664f4763Szrj 	struct servent *se;
518cb5eb4f1SPeter Avalos 	long long port;
519cb5eb4f1SPeter Avalos 	const char *errstr;
52018de8d7fSPeter Avalos 
521cb5eb4f1SPeter Avalos 	port = strtonum(s, 0, 65535, &errstr);
522664f4763Szrj 	if (errstr == NULL)
523cb5eb4f1SPeter Avalos 		return (int)port;
524664f4763Szrj 	if ((se = getservbyname(s, "tcp")) != NULL)
525664f4763Szrj 		return ntohs(se->s_port);
526664f4763Szrj 	return -1;
52718de8d7fSPeter Avalos }
52818de8d7fSPeter Avalos 
52918de8d7fSPeter Avalos int
a2tun(const char * s,int * remote)53018de8d7fSPeter Avalos a2tun(const char *s, int *remote)
53118de8d7fSPeter Avalos {
53218de8d7fSPeter Avalos 	const char *errstr = NULL;
53318de8d7fSPeter Avalos 	char *sp, *ep;
53418de8d7fSPeter Avalos 	int tun;
53518de8d7fSPeter Avalos 
53618de8d7fSPeter Avalos 	if (remote != NULL) {
53718de8d7fSPeter Avalos 		*remote = SSH_TUNID_ANY;
53818de8d7fSPeter Avalos 		sp = xstrdup(s);
53918de8d7fSPeter Avalos 		if ((ep = strchr(sp, ':')) == NULL) {
54036e94dc5SPeter Avalos 			free(sp);
54118de8d7fSPeter Avalos 			return (a2tun(s, NULL));
54218de8d7fSPeter Avalos 		}
54318de8d7fSPeter Avalos 		ep[0] = '\0'; ep++;
54418de8d7fSPeter Avalos 		*remote = a2tun(ep, NULL);
54518de8d7fSPeter Avalos 		tun = a2tun(sp, NULL);
54636e94dc5SPeter Avalos 		free(sp);
54718de8d7fSPeter Avalos 		return (*remote == SSH_TUNID_ERR ? *remote : tun);
54818de8d7fSPeter Avalos 	}
54918de8d7fSPeter Avalos 
55018de8d7fSPeter Avalos 	if (strcasecmp(s, "any") == 0)
55118de8d7fSPeter Avalos 		return (SSH_TUNID_ANY);
55218de8d7fSPeter Avalos 
55318de8d7fSPeter Avalos 	tun = strtonum(s, 0, SSH_TUNID_MAX, &errstr);
55418de8d7fSPeter Avalos 	if (errstr != NULL)
55518de8d7fSPeter Avalos 		return (SSH_TUNID_ERR);
55618de8d7fSPeter Avalos 
55718de8d7fSPeter Avalos 	return (tun);
55818de8d7fSPeter Avalos }
55918de8d7fSPeter Avalos 
56018de8d7fSPeter Avalos #define SECONDS		1
56118de8d7fSPeter Avalos #define MINUTES		(SECONDS * 60)
56218de8d7fSPeter Avalos #define HOURS		(MINUTES * 60)
56318de8d7fSPeter Avalos #define DAYS		(HOURS * 24)
56418de8d7fSPeter Avalos #define WEEKS		(DAYS * 7)
56518de8d7fSPeter Avalos 
566*ba1276acSMatthew Dillon static char *
scandigits(char * s)567*ba1276acSMatthew Dillon scandigits(char *s)
568*ba1276acSMatthew Dillon {
569*ba1276acSMatthew Dillon 	while (isdigit((unsigned char)*s))
570*ba1276acSMatthew Dillon 		s++;
571*ba1276acSMatthew Dillon 	return s;
572*ba1276acSMatthew Dillon }
573*ba1276acSMatthew Dillon 
57418de8d7fSPeter Avalos /*
57518de8d7fSPeter Avalos  * Convert a time string into seconds; format is
57618de8d7fSPeter Avalos  * a sequence of:
57718de8d7fSPeter Avalos  *      time[qualifier]
57818de8d7fSPeter Avalos  *
57918de8d7fSPeter Avalos  * Valid time qualifiers are:
58018de8d7fSPeter Avalos  *      <none>  seconds
58118de8d7fSPeter Avalos  *      s|S     seconds
58218de8d7fSPeter Avalos  *      m|M     minutes
58318de8d7fSPeter Avalos  *      h|H     hours
58418de8d7fSPeter Avalos  *      d|D     days
58518de8d7fSPeter Avalos  *      w|W     weeks
58618de8d7fSPeter Avalos  *
58718de8d7fSPeter Avalos  * Examples:
58818de8d7fSPeter Avalos  *      90m     90 minutes
58918de8d7fSPeter Avalos  *      1h30m   90 minutes
59018de8d7fSPeter Avalos  *      2d      2 days
59118de8d7fSPeter Avalos  *      1w      1 week
59218de8d7fSPeter Avalos  *
59318de8d7fSPeter Avalos  * Return -1 if time string is invalid.
59418de8d7fSPeter Avalos  */
59550a69bb5SSascha Wildner int
convtime(const char * s)59618de8d7fSPeter Avalos convtime(const char *s)
59718de8d7fSPeter Avalos {
598*ba1276acSMatthew Dillon 	int secs, total = 0, multiplier;
599*ba1276acSMatthew Dillon 	char *p, *os, *np, c = 0;
600*ba1276acSMatthew Dillon 	const char *errstr;
60118de8d7fSPeter Avalos 
602*ba1276acSMatthew Dillon 	if (s == NULL || *s == '\0')
603*ba1276acSMatthew Dillon 		return -1;
604*ba1276acSMatthew Dillon 	p = os = strdup(s);	/* deal with const */
605*ba1276acSMatthew Dillon 	if (os == NULL)
60618de8d7fSPeter Avalos 		return -1;
60718de8d7fSPeter Avalos 
60818de8d7fSPeter Avalos 	while (*p) {
609*ba1276acSMatthew Dillon 		np = scandigits(p);
610*ba1276acSMatthew Dillon 		if (np) {
611*ba1276acSMatthew Dillon 			c = *np;
612*ba1276acSMatthew Dillon 			*np = '\0';
613*ba1276acSMatthew Dillon 		}
614*ba1276acSMatthew Dillon 		secs = (int)strtonum(p, 0, INT_MAX, &errstr);
615*ba1276acSMatthew Dillon 		if (errstr)
616*ba1276acSMatthew Dillon 			goto fail;
617*ba1276acSMatthew Dillon 		*np = c;
61818de8d7fSPeter Avalos 
61950a69bb5SSascha Wildner 		multiplier = 1;
620*ba1276acSMatthew Dillon 		switch (c) {
62118de8d7fSPeter Avalos 		case '\0':
622*ba1276acSMatthew Dillon 			np--;	/* back up */
62318de8d7fSPeter Avalos 			break;
62418de8d7fSPeter Avalos 		case 's':
62518de8d7fSPeter Avalos 		case 'S':
62618de8d7fSPeter Avalos 			break;
62718de8d7fSPeter Avalos 		case 'm':
62818de8d7fSPeter Avalos 		case 'M':
629ce74bacaSMatthew Dillon 			multiplier = MINUTES;
63018de8d7fSPeter Avalos 			break;
63118de8d7fSPeter Avalos 		case 'h':
63218de8d7fSPeter Avalos 		case 'H':
633ce74bacaSMatthew Dillon 			multiplier = HOURS;
63418de8d7fSPeter Avalos 			break;
63518de8d7fSPeter Avalos 		case 'd':
63618de8d7fSPeter Avalos 		case 'D':
637ce74bacaSMatthew Dillon 			multiplier = DAYS;
63818de8d7fSPeter Avalos 			break;
63918de8d7fSPeter Avalos 		case 'w':
64018de8d7fSPeter Avalos 		case 'W':
641ce74bacaSMatthew Dillon 			multiplier = WEEKS;
64218de8d7fSPeter Avalos 			break;
64318de8d7fSPeter Avalos 		default:
644*ba1276acSMatthew Dillon 			goto fail;
64518de8d7fSPeter Avalos 		}
64650a69bb5SSascha Wildner 		if (secs > INT_MAX / multiplier)
647*ba1276acSMatthew Dillon 			goto fail;
648ce74bacaSMatthew Dillon 		secs *= multiplier;
64950a69bb5SSascha Wildner 		if  (total > INT_MAX - secs)
650*ba1276acSMatthew Dillon 			goto fail;
65118de8d7fSPeter Avalos 		total += secs;
65218de8d7fSPeter Avalos 		if (total < 0)
653*ba1276acSMatthew Dillon 			goto fail;
654*ba1276acSMatthew Dillon 		p = ++np;
65518de8d7fSPeter Avalos 	}
656*ba1276acSMatthew Dillon 	free(os);
65718de8d7fSPeter Avalos 	return total;
658*ba1276acSMatthew Dillon fail:
659*ba1276acSMatthew Dillon 	free(os);
660*ba1276acSMatthew Dillon 	return -1;
66118de8d7fSPeter Avalos }
66218de8d7fSPeter Avalos 
66350a69bb5SSascha Wildner #define TF_BUFS	8
66450a69bb5SSascha Wildner #define TF_LEN	9
66550a69bb5SSascha Wildner 
66650a69bb5SSascha Wildner const char *
fmt_timeframe(time_t t)66750a69bb5SSascha Wildner fmt_timeframe(time_t t)
66850a69bb5SSascha Wildner {
66950a69bb5SSascha Wildner 	char		*buf;
67050a69bb5SSascha Wildner 	static char	 tfbuf[TF_BUFS][TF_LEN];	/* ring buffer */
67150a69bb5SSascha Wildner 	static int	 idx = 0;
67250a69bb5SSascha Wildner 	unsigned int	 sec, min, hrs, day;
67350a69bb5SSascha Wildner 	unsigned long long	week;
67450a69bb5SSascha Wildner 
67550a69bb5SSascha Wildner 	buf = tfbuf[idx++];
67650a69bb5SSascha Wildner 	if (idx == TF_BUFS)
67750a69bb5SSascha Wildner 		idx = 0;
67850a69bb5SSascha Wildner 
67950a69bb5SSascha Wildner 	week = t;
68050a69bb5SSascha Wildner 
68150a69bb5SSascha Wildner 	sec = week % 60;
68250a69bb5SSascha Wildner 	week /= 60;
68350a69bb5SSascha Wildner 	min = week % 60;
68450a69bb5SSascha Wildner 	week /= 60;
68550a69bb5SSascha Wildner 	hrs = week % 24;
68650a69bb5SSascha Wildner 	week /= 24;
68750a69bb5SSascha Wildner 	day = week % 7;
68850a69bb5SSascha Wildner 	week /= 7;
68950a69bb5SSascha Wildner 
69050a69bb5SSascha Wildner 	if (week > 0)
69150a69bb5SSascha Wildner 		snprintf(buf, TF_LEN, "%02lluw%01ud%02uh", week, day, hrs);
69250a69bb5SSascha Wildner 	else if (day > 0)
69350a69bb5SSascha Wildner 		snprintf(buf, TF_LEN, "%01ud%02uh%02um", day, hrs, min);
69450a69bb5SSascha Wildner 	else
69550a69bb5SSascha Wildner 		snprintf(buf, TF_LEN, "%02u:%02u:%02u", hrs, min, sec);
69650a69bb5SSascha Wildner 
69750a69bb5SSascha Wildner 	return (buf);
69850a69bb5SSascha Wildner }
69950a69bb5SSascha Wildner 
70018de8d7fSPeter Avalos /*
70118de8d7fSPeter Avalos  * Returns a standardized host+port identifier string.
70218de8d7fSPeter Avalos  * Caller must free returned string.
70318de8d7fSPeter Avalos  */
70418de8d7fSPeter Avalos char *
put_host_port(const char * host,u_short port)70518de8d7fSPeter Avalos put_host_port(const char *host, u_short port)
70618de8d7fSPeter Avalos {
70718de8d7fSPeter Avalos 	char *hoststr;
70818de8d7fSPeter Avalos 
70918de8d7fSPeter Avalos 	if (port == 0 || port == SSH_DEFAULT_PORT)
71018de8d7fSPeter Avalos 		return(xstrdup(host));
7110cbfa66cSDaniel Fojt 	if (asprintf(&hoststr, "[%s]:%d", host, (int)port) == -1)
71218de8d7fSPeter Avalos 		fatal("put_host_port: asprintf: %s", strerror(errno));
71318de8d7fSPeter Avalos 	debug3("put_host_port: %s", hoststr);
71418de8d7fSPeter Avalos 	return hoststr;
71518de8d7fSPeter Avalos }
71618de8d7fSPeter Avalos 
71718de8d7fSPeter Avalos /*
71818de8d7fSPeter Avalos  * Search for next delimiter between hostnames/addresses and ports.
71918de8d7fSPeter Avalos  * Argument may be modified (for termination).
72018de8d7fSPeter Avalos  * Returns *cp if parsing succeeds.
721664f4763Szrj  * *cp is set to the start of the next field, if one was found.
722664f4763Szrj  * The delimiter char, if present, is stored in delim.
72318de8d7fSPeter Avalos  * If this is the last field, *cp is set to NULL.
72418de8d7fSPeter Avalos  */
72518de8d7fSPeter Avalos char *
hpdelim2(char ** cp,char * delim)726664f4763Szrj hpdelim2(char **cp, char *delim)
72718de8d7fSPeter Avalos {
72818de8d7fSPeter Avalos 	char *s, *old;
72918de8d7fSPeter Avalos 
73018de8d7fSPeter Avalos 	if (cp == NULL || *cp == NULL)
73118de8d7fSPeter Avalos 		return NULL;
73218de8d7fSPeter Avalos 
73318de8d7fSPeter Avalos 	old = s = *cp;
73418de8d7fSPeter Avalos 	if (*s == '[') {
73518de8d7fSPeter Avalos 		if ((s = strchr(s, ']')) == NULL)
73618de8d7fSPeter Avalos 			return NULL;
73718de8d7fSPeter Avalos 		else
73818de8d7fSPeter Avalos 			s++;
73918de8d7fSPeter Avalos 	} else if ((s = strpbrk(s, ":/")) == NULL)
74018de8d7fSPeter Avalos 		s = *cp + strlen(*cp); /* skip to end (see first case below) */
74118de8d7fSPeter Avalos 
74218de8d7fSPeter Avalos 	switch (*s) {
74318de8d7fSPeter Avalos 	case '\0':
74418de8d7fSPeter Avalos 		*cp = NULL;	/* no more fields*/
74518de8d7fSPeter Avalos 		break;
74618de8d7fSPeter Avalos 
74718de8d7fSPeter Avalos 	case ':':
74818de8d7fSPeter Avalos 	case '/':
749664f4763Szrj 		if (delim != NULL)
750664f4763Szrj 			*delim = *s;
75118de8d7fSPeter Avalos 		*s = '\0';	/* terminate */
75218de8d7fSPeter Avalos 		*cp = s + 1;
75318de8d7fSPeter Avalos 		break;
75418de8d7fSPeter Avalos 
75518de8d7fSPeter Avalos 	default:
75618de8d7fSPeter Avalos 		return NULL;
75718de8d7fSPeter Avalos 	}
75818de8d7fSPeter Avalos 
75918de8d7fSPeter Avalos 	return old;
76018de8d7fSPeter Avalos }
76118de8d7fSPeter Avalos 
762ee116499SAntonio Huete Jimenez /* The common case: only accept colon as delimiter. */
76318de8d7fSPeter Avalos char *
hpdelim(char ** cp)764664f4763Szrj hpdelim(char **cp)
765664f4763Szrj {
766ee116499SAntonio Huete Jimenez 	char *r, delim = '\0';
767ee116499SAntonio Huete Jimenez 
768ee116499SAntonio Huete Jimenez 	r =  hpdelim2(cp, &delim);
769ee116499SAntonio Huete Jimenez 	if (delim == '/')
770ee116499SAntonio Huete Jimenez 		return NULL;
771ee116499SAntonio Huete Jimenez 	return r;
772664f4763Szrj }
773664f4763Szrj 
774664f4763Szrj char *
cleanhostname(char * host)77518de8d7fSPeter Avalos cleanhostname(char *host)
77618de8d7fSPeter Avalos {
77718de8d7fSPeter Avalos 	if (*host == '[' && host[strlen(host) - 1] == ']') {
77818de8d7fSPeter Avalos 		host[strlen(host) - 1] = '\0';
77918de8d7fSPeter Avalos 		return (host + 1);
78018de8d7fSPeter Avalos 	} else
78118de8d7fSPeter Avalos 		return host;
78218de8d7fSPeter Avalos }
78318de8d7fSPeter Avalos 
78418de8d7fSPeter Avalos char *
colon(char * cp)78518de8d7fSPeter Avalos colon(char *cp)
78618de8d7fSPeter Avalos {
78718de8d7fSPeter Avalos 	int flag = 0;
78818de8d7fSPeter Avalos 
78918de8d7fSPeter Avalos 	if (*cp == ':')		/* Leading colon is part of file name. */
790856ea928SPeter Avalos 		return NULL;
79118de8d7fSPeter Avalos 	if (*cp == '[')
79218de8d7fSPeter Avalos 		flag = 1;
79318de8d7fSPeter Avalos 
79418de8d7fSPeter Avalos 	for (; *cp; ++cp) {
79518de8d7fSPeter Avalos 		if (*cp == '@' && *(cp+1) == '[')
79618de8d7fSPeter Avalos 			flag = 1;
79718de8d7fSPeter Avalos 		if (*cp == ']' && *(cp+1) == ':' && flag)
79818de8d7fSPeter Avalos 			return (cp+1);
79918de8d7fSPeter Avalos 		if (*cp == ':' && !flag)
80018de8d7fSPeter Avalos 			return (cp);
80118de8d7fSPeter Avalos 		if (*cp == '/')
802856ea928SPeter Avalos 			return NULL;
80318de8d7fSPeter Avalos 	}
804856ea928SPeter Avalos 	return NULL;
80518de8d7fSPeter Avalos }
80618de8d7fSPeter Avalos 
807e9778795SPeter Avalos /*
808664f4763Szrj  * Parse a [user@]host:[path] string.
809664f4763Szrj  * Caller must free returned user, host and path.
810664f4763Szrj  * Any of the pointer return arguments may be NULL (useful for syntax checking).
811664f4763Szrj  * If user was not specified then *userp will be set to NULL.
812664f4763Szrj  * If host was not specified then *hostp will be set to NULL.
813664f4763Szrj  * If path was not specified then *pathp will be set to ".".
814664f4763Szrj  * Returns 0 on success, -1 on failure.
815664f4763Szrj  */
816664f4763Szrj int
parse_user_host_path(const char * s,char ** userp,char ** hostp,char ** pathp)817664f4763Szrj parse_user_host_path(const char *s, char **userp, char **hostp, char **pathp)
818664f4763Szrj {
819664f4763Szrj 	char *user = NULL, *host = NULL, *path = NULL;
820664f4763Szrj 	char *sdup, *tmp;
821664f4763Szrj 	int ret = -1;
822664f4763Szrj 
823664f4763Szrj 	if (userp != NULL)
824664f4763Szrj 		*userp = NULL;
825664f4763Szrj 	if (hostp != NULL)
826664f4763Szrj 		*hostp = NULL;
827664f4763Szrj 	if (pathp != NULL)
828664f4763Szrj 		*pathp = NULL;
829664f4763Szrj 
830664f4763Szrj 	sdup = xstrdup(s);
831664f4763Szrj 
832664f4763Szrj 	/* Check for remote syntax: [user@]host:[path] */
833664f4763Szrj 	if ((tmp = colon(sdup)) == NULL)
834664f4763Szrj 		goto out;
835664f4763Szrj 
836664f4763Szrj 	/* Extract optional path */
837664f4763Szrj 	*tmp++ = '\0';
838664f4763Szrj 	if (*tmp == '\0')
839664f4763Szrj 		tmp = ".";
840664f4763Szrj 	path = xstrdup(tmp);
841664f4763Szrj 
842664f4763Szrj 	/* Extract optional user and mandatory host */
843664f4763Szrj 	tmp = strrchr(sdup, '@');
844664f4763Szrj 	if (tmp != NULL) {
845664f4763Szrj 		*tmp++ = '\0';
846664f4763Szrj 		host = xstrdup(cleanhostname(tmp));
847664f4763Szrj 		if (*sdup != '\0')
848664f4763Szrj 			user = xstrdup(sdup);
849664f4763Szrj 	} else {
850664f4763Szrj 		host = xstrdup(cleanhostname(sdup));
851664f4763Szrj 		user = NULL;
852664f4763Szrj 	}
853664f4763Szrj 
854664f4763Szrj 	/* Success */
855664f4763Szrj 	if (userp != NULL) {
856664f4763Szrj 		*userp = user;
857664f4763Szrj 		user = NULL;
858664f4763Szrj 	}
859664f4763Szrj 	if (hostp != NULL) {
860664f4763Szrj 		*hostp = host;
861664f4763Szrj 		host = NULL;
862664f4763Szrj 	}
863664f4763Szrj 	if (pathp != NULL) {
864664f4763Szrj 		*pathp = path;
865664f4763Szrj 		path = NULL;
866664f4763Szrj 	}
867664f4763Szrj 	ret = 0;
868664f4763Szrj out:
869664f4763Szrj 	free(sdup);
870664f4763Szrj 	free(user);
871664f4763Szrj 	free(host);
872664f4763Szrj 	free(path);
873664f4763Szrj 	return ret;
874664f4763Szrj }
875664f4763Szrj 
876664f4763Szrj /*
877e9778795SPeter Avalos  * Parse a [user@]host[:port] string.
878e9778795SPeter Avalos  * Caller must free returned user and host.
879e9778795SPeter Avalos  * Any of the pointer return arguments may be NULL (useful for syntax checking).
880e9778795SPeter Avalos  * If user was not specified then *userp will be set to NULL.
881e9778795SPeter Avalos  * If port was not specified then *portp will be -1.
882e9778795SPeter Avalos  * Returns 0 on success, -1 on failure.
883e9778795SPeter Avalos  */
884e9778795SPeter Avalos int
parse_user_host_port(const char * s,char ** userp,char ** hostp,int * portp)885e9778795SPeter Avalos parse_user_host_port(const char *s, char **userp, char **hostp, int *portp)
886e9778795SPeter Avalos {
887e9778795SPeter Avalos 	char *sdup, *cp, *tmp;
888e9778795SPeter Avalos 	char *user = NULL, *host = NULL;
889e9778795SPeter Avalos 	int port = -1, ret = -1;
890e9778795SPeter Avalos 
891e9778795SPeter Avalos 	if (userp != NULL)
892e9778795SPeter Avalos 		*userp = NULL;
893e9778795SPeter Avalos 	if (hostp != NULL)
894e9778795SPeter Avalos 		*hostp = NULL;
895e9778795SPeter Avalos 	if (portp != NULL)
896e9778795SPeter Avalos 		*portp = -1;
897e9778795SPeter Avalos 
898e9778795SPeter Avalos 	if ((sdup = tmp = strdup(s)) == NULL)
899e9778795SPeter Avalos 		return -1;
900e9778795SPeter Avalos 	/* Extract optional username */
901664f4763Szrj 	if ((cp = strrchr(tmp, '@')) != NULL) {
902e9778795SPeter Avalos 		*cp = '\0';
903e9778795SPeter Avalos 		if (*tmp == '\0')
904e9778795SPeter Avalos 			goto out;
905e9778795SPeter Avalos 		if ((user = strdup(tmp)) == NULL)
906e9778795SPeter Avalos 			goto out;
907e9778795SPeter Avalos 		tmp = cp + 1;
908e9778795SPeter Avalos 	}
909e9778795SPeter Avalos 	/* Extract mandatory hostname */
910e9778795SPeter Avalos 	if ((cp = hpdelim(&tmp)) == NULL || *cp == '\0')
911e9778795SPeter Avalos 		goto out;
912e9778795SPeter Avalos 	host = xstrdup(cleanhostname(cp));
913e9778795SPeter Avalos 	/* Convert and verify optional port */
914e9778795SPeter Avalos 	if (tmp != NULL && *tmp != '\0') {
915e9778795SPeter Avalos 		if ((port = a2port(tmp)) <= 0)
916e9778795SPeter Avalos 			goto out;
917e9778795SPeter Avalos 	}
918e9778795SPeter Avalos 	/* Success */
919e9778795SPeter Avalos 	if (userp != NULL) {
920e9778795SPeter Avalos 		*userp = user;
921e9778795SPeter Avalos 		user = NULL;
922e9778795SPeter Avalos 	}
923e9778795SPeter Avalos 	if (hostp != NULL) {
924e9778795SPeter Avalos 		*hostp = host;
925e9778795SPeter Avalos 		host = NULL;
926e9778795SPeter Avalos 	}
927e9778795SPeter Avalos 	if (portp != NULL)
928e9778795SPeter Avalos 		*portp = port;
929e9778795SPeter Avalos 	ret = 0;
930e9778795SPeter Avalos  out:
931e9778795SPeter Avalos 	free(sdup);
932e9778795SPeter Avalos 	free(user);
933e9778795SPeter Avalos 	free(host);
934e9778795SPeter Avalos 	return ret;
935e9778795SPeter Avalos }
936e9778795SPeter Avalos 
937664f4763Szrj /*
938664f4763Szrj  * Converts a two-byte hex string to decimal.
939664f4763Szrj  * Returns the decimal value or -1 for invalid input.
940664f4763Szrj  */
941664f4763Szrj static int
hexchar(const char * s)942664f4763Szrj hexchar(const char *s)
943664f4763Szrj {
944664f4763Szrj 	unsigned char result[2];
945664f4763Szrj 	int i;
946664f4763Szrj 
947664f4763Szrj 	for (i = 0; i < 2; i++) {
948664f4763Szrj 		if (s[i] >= '0' && s[i] <= '9')
949664f4763Szrj 			result[i] = (unsigned char)(s[i] - '0');
950664f4763Szrj 		else if (s[i] >= 'a' && s[i] <= 'f')
951664f4763Szrj 			result[i] = (unsigned char)(s[i] - 'a') + 10;
952664f4763Szrj 		else if (s[i] >= 'A' && s[i] <= 'F')
953664f4763Szrj 			result[i] = (unsigned char)(s[i] - 'A') + 10;
954664f4763Szrj 		else
955664f4763Szrj 			return -1;
956664f4763Szrj 	}
957664f4763Szrj 	return (result[0] << 4) | result[1];
958664f4763Szrj }
959664f4763Szrj 
960664f4763Szrj /*
961664f4763Szrj  * Decode an url-encoded string.
962664f4763Szrj  * Returns a newly allocated string on success or NULL on failure.
963664f4763Szrj  */
964664f4763Szrj static char *
urldecode(const char * src)965664f4763Szrj urldecode(const char *src)
966664f4763Szrj {
967664f4763Szrj 	char *ret, *dst;
968664f4763Szrj 	int ch;
969*ba1276acSMatthew Dillon 	size_t srclen;
970664f4763Szrj 
971*ba1276acSMatthew Dillon 	if ((srclen = strlen(src)) >= SIZE_MAX)
972*ba1276acSMatthew Dillon 		fatal_f("input too large");
973*ba1276acSMatthew Dillon 	ret = xmalloc(srclen + 1);
974664f4763Szrj 	for (dst = ret; *src != '\0'; src++) {
975664f4763Szrj 		switch (*src) {
976664f4763Szrj 		case '+':
977664f4763Szrj 			*dst++ = ' ';
978664f4763Szrj 			break;
979664f4763Szrj 		case '%':
980664f4763Szrj 			if (!isxdigit((unsigned char)src[1]) ||
981664f4763Szrj 			    !isxdigit((unsigned char)src[2]) ||
982664f4763Szrj 			    (ch = hexchar(src + 1)) == -1) {
983664f4763Szrj 				free(ret);
984664f4763Szrj 				return NULL;
985664f4763Szrj 			}
986664f4763Szrj 			*dst++ = ch;
987664f4763Szrj 			src += 2;
988664f4763Szrj 			break;
989664f4763Szrj 		default:
990664f4763Szrj 			*dst++ = *src;
991664f4763Szrj 			break;
992664f4763Szrj 		}
993664f4763Szrj 	}
994664f4763Szrj 	*dst = '\0';
995664f4763Szrj 
996664f4763Szrj 	return ret;
997664f4763Szrj }
998664f4763Szrj 
999664f4763Szrj /*
1000664f4763Szrj  * Parse an (scp|ssh|sftp)://[user@]host[:port][/path] URI.
1001664f4763Szrj  * See https://tools.ietf.org/html/draft-ietf-secsh-scp-sftp-ssh-uri-04
1002664f4763Szrj  * Either user or path may be url-encoded (but not host or port).
1003664f4763Szrj  * Caller must free returned user, host and path.
1004664f4763Szrj  * Any of the pointer return arguments may be NULL (useful for syntax checking)
1005664f4763Szrj  * but the scheme must always be specified.
1006664f4763Szrj  * If user was not specified then *userp will be set to NULL.
1007664f4763Szrj  * If port was not specified then *portp will be -1.
1008664f4763Szrj  * If path was not specified then *pathp will be set to NULL.
1009664f4763Szrj  * Returns 0 on success, 1 if non-uri/wrong scheme, -1 on error/invalid uri.
1010664f4763Szrj  */
1011664f4763Szrj int
parse_uri(const char * scheme,const char * uri,char ** userp,char ** hostp,int * portp,char ** pathp)1012664f4763Szrj parse_uri(const char *scheme, const char *uri, char **userp, char **hostp,
1013664f4763Szrj     int *portp, char **pathp)
1014664f4763Szrj {
1015664f4763Szrj 	char *uridup, *cp, *tmp, ch;
1016664f4763Szrj 	char *user = NULL, *host = NULL, *path = NULL;
1017664f4763Szrj 	int port = -1, ret = -1;
1018664f4763Szrj 	size_t len;
1019664f4763Szrj 
1020664f4763Szrj 	len = strlen(scheme);
1021664f4763Szrj 	if (strncmp(uri, scheme, len) != 0 || strncmp(uri + len, "://", 3) != 0)
1022664f4763Szrj 		return 1;
1023664f4763Szrj 	uri += len + 3;
1024664f4763Szrj 
1025664f4763Szrj 	if (userp != NULL)
1026664f4763Szrj 		*userp = NULL;
1027664f4763Szrj 	if (hostp != NULL)
1028664f4763Szrj 		*hostp = NULL;
1029664f4763Szrj 	if (portp != NULL)
1030664f4763Szrj 		*portp = -1;
1031664f4763Szrj 	if (pathp != NULL)
1032664f4763Szrj 		*pathp = NULL;
1033664f4763Szrj 
1034664f4763Szrj 	uridup = tmp = xstrdup(uri);
1035664f4763Szrj 
1036664f4763Szrj 	/* Extract optional ssh-info (username + connection params) */
1037664f4763Szrj 	if ((cp = strchr(tmp, '@')) != NULL) {
1038664f4763Szrj 		char *delim;
1039664f4763Szrj 
1040664f4763Szrj 		*cp = '\0';
1041664f4763Szrj 		/* Extract username and connection params */
1042664f4763Szrj 		if ((delim = strchr(tmp, ';')) != NULL) {
1043664f4763Szrj 			/* Just ignore connection params for now */
1044664f4763Szrj 			*delim = '\0';
1045664f4763Szrj 		}
1046664f4763Szrj 		if (*tmp == '\0') {
1047664f4763Szrj 			/* Empty username */
1048664f4763Szrj 			goto out;
1049664f4763Szrj 		}
1050664f4763Szrj 		if ((user = urldecode(tmp)) == NULL)
1051664f4763Szrj 			goto out;
1052664f4763Szrj 		tmp = cp + 1;
1053664f4763Szrj 	}
1054664f4763Szrj 
1055664f4763Szrj 	/* Extract mandatory hostname */
1056664f4763Szrj 	if ((cp = hpdelim2(&tmp, &ch)) == NULL || *cp == '\0')
1057664f4763Szrj 		goto out;
1058664f4763Szrj 	host = xstrdup(cleanhostname(cp));
1059664f4763Szrj 	if (!valid_domain(host, 0, NULL))
1060664f4763Szrj 		goto out;
1061664f4763Szrj 
1062664f4763Szrj 	if (tmp != NULL && *tmp != '\0') {
1063664f4763Szrj 		if (ch == ':') {
1064664f4763Szrj 			/* Convert and verify port. */
1065664f4763Szrj 			if ((cp = strchr(tmp, '/')) != NULL)
1066664f4763Szrj 				*cp = '\0';
1067664f4763Szrj 			if ((port = a2port(tmp)) <= 0)
1068664f4763Szrj 				goto out;
1069664f4763Szrj 			tmp = cp ? cp + 1 : NULL;
1070664f4763Szrj 		}
1071664f4763Szrj 		if (tmp != NULL && *tmp != '\0') {
1072664f4763Szrj 			/* Extract optional path */
1073664f4763Szrj 			if ((path = urldecode(tmp)) == NULL)
1074664f4763Szrj 				goto out;
1075664f4763Szrj 		}
1076664f4763Szrj 	}
1077664f4763Szrj 
1078664f4763Szrj 	/* Success */
1079664f4763Szrj 	if (userp != NULL) {
1080664f4763Szrj 		*userp = user;
1081664f4763Szrj 		user = NULL;
1082664f4763Szrj 	}
1083664f4763Szrj 	if (hostp != NULL) {
1084664f4763Szrj 		*hostp = host;
1085664f4763Szrj 		host = NULL;
1086664f4763Szrj 	}
1087664f4763Szrj 	if (portp != NULL)
1088664f4763Szrj 		*portp = port;
1089664f4763Szrj 	if (pathp != NULL) {
1090664f4763Szrj 		*pathp = path;
1091664f4763Szrj 		path = NULL;
1092664f4763Szrj 	}
1093664f4763Szrj 	ret = 0;
1094664f4763Szrj  out:
1095664f4763Szrj 	free(uridup);
1096664f4763Szrj 	free(user);
1097664f4763Szrj 	free(host);
1098664f4763Szrj 	free(path);
1099664f4763Szrj 	return ret;
1100664f4763Szrj }
1101664f4763Szrj 
110218de8d7fSPeter Avalos /* function to assist building execv() arguments */
110318de8d7fSPeter Avalos void
addargs(arglist * args,char * fmt,...)110418de8d7fSPeter Avalos addargs(arglist *args, char *fmt, ...)
110518de8d7fSPeter Avalos {
110618de8d7fSPeter Avalos 	va_list ap;
110718de8d7fSPeter Avalos 	char *cp;
110818de8d7fSPeter Avalos 	u_int nalloc;
110918de8d7fSPeter Avalos 	int r;
111018de8d7fSPeter Avalos 
111118de8d7fSPeter Avalos 	va_start(ap, fmt);
111218de8d7fSPeter Avalos 	r = vasprintf(&cp, fmt, ap);
111318de8d7fSPeter Avalos 	va_end(ap);
111418de8d7fSPeter Avalos 	if (r == -1)
1115ee116499SAntonio Huete Jimenez 		fatal_f("argument too long");
111618de8d7fSPeter Avalos 
111718de8d7fSPeter Avalos 	nalloc = args->nalloc;
111818de8d7fSPeter Avalos 	if (args->list == NULL) {
111918de8d7fSPeter Avalos 		nalloc = 32;
112018de8d7fSPeter Avalos 		args->num = 0;
1121ee116499SAntonio Huete Jimenez 	} else if (args->num > (256 * 1024))
1122ee116499SAntonio Huete Jimenez 		fatal_f("too many arguments");
1123ee116499SAntonio Huete Jimenez 	else if (args->num >= args->nalloc)
1124ee116499SAntonio Huete Jimenez 		fatal_f("arglist corrupt");
1125ee116499SAntonio Huete Jimenez 	else if (args->num+2 >= nalloc)
112618de8d7fSPeter Avalos 		nalloc *= 2;
112718de8d7fSPeter Avalos 
1128ee116499SAntonio Huete Jimenez 	args->list = xrecallocarray(args->list, args->nalloc,
1129ee116499SAntonio Huete Jimenez 	    nalloc, sizeof(char *));
113018de8d7fSPeter Avalos 	args->nalloc = nalloc;
113118de8d7fSPeter Avalos 	args->list[args->num++] = cp;
113218de8d7fSPeter Avalos 	args->list[args->num] = NULL;
113318de8d7fSPeter Avalos }
113418de8d7fSPeter Avalos 
113518de8d7fSPeter Avalos void
replacearg(arglist * args,u_int which,char * fmt,...)113618de8d7fSPeter Avalos replacearg(arglist *args, u_int which, char *fmt, ...)
113718de8d7fSPeter Avalos {
113818de8d7fSPeter Avalos 	va_list ap;
113918de8d7fSPeter Avalos 	char *cp;
114018de8d7fSPeter Avalos 	int r;
114118de8d7fSPeter Avalos 
114218de8d7fSPeter Avalos 	va_start(ap, fmt);
114318de8d7fSPeter Avalos 	r = vasprintf(&cp, fmt, ap);
114418de8d7fSPeter Avalos 	va_end(ap);
114518de8d7fSPeter Avalos 	if (r == -1)
1146ee116499SAntonio Huete Jimenez 		fatal_f("argument too long");
1147ee116499SAntonio Huete Jimenez 	if (args->list == NULL || args->num >= args->nalloc)
1148ee116499SAntonio Huete Jimenez 		fatal_f("arglist corrupt");
114918de8d7fSPeter Avalos 
115018de8d7fSPeter Avalos 	if (which >= args->num)
1151ee116499SAntonio Huete Jimenez 		fatal_f("tried to replace invalid arg %d >= %d",
115218de8d7fSPeter Avalos 		    which, args->num);
115336e94dc5SPeter Avalos 	free(args->list[which]);
115418de8d7fSPeter Avalos 	args->list[which] = cp;
115518de8d7fSPeter Avalos }
115618de8d7fSPeter Avalos 
115718de8d7fSPeter Avalos void
freeargs(arglist * args)115818de8d7fSPeter Avalos freeargs(arglist *args)
115918de8d7fSPeter Avalos {
116018de8d7fSPeter Avalos 	u_int i;
116118de8d7fSPeter Avalos 
1162ee116499SAntonio Huete Jimenez 	if (args == NULL)
1163ee116499SAntonio Huete Jimenez 		return;
1164ee116499SAntonio Huete Jimenez 	if (args->list != NULL && args->num < args->nalloc) {
116518de8d7fSPeter Avalos 		for (i = 0; i < args->num; i++)
116636e94dc5SPeter Avalos 			free(args->list[i]);
116736e94dc5SPeter Avalos 		free(args->list);
1168ee116499SAntonio Huete Jimenez 	}
116918de8d7fSPeter Avalos 	args->nalloc = args->num = 0;
117018de8d7fSPeter Avalos 	args->list = NULL;
117118de8d7fSPeter Avalos }
117218de8d7fSPeter Avalos 
117318de8d7fSPeter Avalos /*
117418de8d7fSPeter Avalos  * Expands tildes in the file name.  Returns data allocated by xmalloc.
117518de8d7fSPeter Avalos  * Warning: this calls getpw*.
117618de8d7fSPeter Avalos  */
117750a69bb5SSascha Wildner int
tilde_expand(const char * filename,uid_t uid,char ** retp)117850a69bb5SSascha Wildner tilde_expand(const char *filename, uid_t uid, char **retp)
117918de8d7fSPeter Avalos {
1180ee116499SAntonio Huete Jimenez 	char *ocopy = NULL, *copy, *s = NULL;
1181ee116499SAntonio Huete Jimenez 	const char *path = NULL, *user = NULL;
118218de8d7fSPeter Avalos 	struct passwd *pw;
1183ee116499SAntonio Huete Jimenez 	size_t len;
1184ee116499SAntonio Huete Jimenez 	int ret = -1, r, slash;
118518de8d7fSPeter Avalos 
1186ee116499SAntonio Huete Jimenez 	*retp = NULL;
118750a69bb5SSascha Wildner 	if (*filename != '~') {
118850a69bb5SSascha Wildner 		*retp = xstrdup(filename);
118950a69bb5SSascha Wildner 		return 0;
119050a69bb5SSascha Wildner 	}
1191ee116499SAntonio Huete Jimenez 	ocopy = copy = xstrdup(filename + 1);
119218de8d7fSPeter Avalos 
1193ee116499SAntonio Huete Jimenez 	if (*copy == '\0')				/* ~ */
1194ee116499SAntonio Huete Jimenez 		path = NULL;
1195ee116499SAntonio Huete Jimenez 	else if (*copy == '/') {
1196ee116499SAntonio Huete Jimenez 		copy += strspn(copy, "/");
1197ee116499SAntonio Huete Jimenez 		if (*copy == '\0')
1198ee116499SAntonio Huete Jimenez 			path = NULL;			/* ~/ */
1199ee116499SAntonio Huete Jimenez 		else
1200ee116499SAntonio Huete Jimenez 			path = copy;			/* ~/path */
1201ee116499SAntonio Huete Jimenez 	} else {
1202ee116499SAntonio Huete Jimenez 		user = copy;
1203ee116499SAntonio Huete Jimenez 		if ((path = strchr(copy, '/')) != NULL) {
1204ee116499SAntonio Huete Jimenez 			copy[path - copy] = '\0';
1205ee116499SAntonio Huete Jimenez 			path++;
1206ee116499SAntonio Huete Jimenez 			path += strspn(path, "/");
1207ee116499SAntonio Huete Jimenez 			if (*path == '\0')		/* ~user/ */
1208ee116499SAntonio Huete Jimenez 				path = NULL;
1209ee116499SAntonio Huete Jimenez 			/* else				 ~user/path */
121050a69bb5SSascha Wildner 		}
1211ee116499SAntonio Huete Jimenez 		/* else					~user */
1212ee116499SAntonio Huete Jimenez 	}
1213ee116499SAntonio Huete Jimenez 	if (user != NULL) {
121450a69bb5SSascha Wildner 		if ((pw = getpwnam(user)) == NULL) {
121550a69bb5SSascha Wildner 			error_f("No such user %s", user);
1216ee116499SAntonio Huete Jimenez 			goto out;
121750a69bb5SSascha Wildner 		}
1218ee116499SAntonio Huete Jimenez 	} else if ((pw = getpwuid(uid)) == NULL) {
121950a69bb5SSascha Wildner 		error_f("No such uid %ld", (long)uid);
1220ee116499SAntonio Huete Jimenez 		goto out;
122150a69bb5SSascha Wildner 	}
122218de8d7fSPeter Avalos 
122318de8d7fSPeter Avalos 	/* Make sure directory has a trailing '/' */
1224ee116499SAntonio Huete Jimenez 	slash = (len = strlen(pw->pw_dir)) == 0 || pw->pw_dir[len - 1] != '/';
122518de8d7fSPeter Avalos 
1226ee116499SAntonio Huete Jimenez 	if ((r = xasprintf(&s, "%s%s%s", pw->pw_dir,
1227ee116499SAntonio Huete Jimenez 	    slash ? "/" : "", path != NULL ? path : "")) <= 0) {
1228ee116499SAntonio Huete Jimenez 		error_f("xasprintf failed");
1229ee116499SAntonio Huete Jimenez 		goto out;
123050a69bb5SSascha Wildner 	}
1231ee116499SAntonio Huete Jimenez 	if (r >= PATH_MAX) {
1232ee116499SAntonio Huete Jimenez 		error_f("Path too long");
1233ee116499SAntonio Huete Jimenez 		goto out;
1234ee116499SAntonio Huete Jimenez 	}
1235ee116499SAntonio Huete Jimenez 	/* success */
1236ee116499SAntonio Huete Jimenez 	ret = 0;
1237ee116499SAntonio Huete Jimenez 	*retp = s;
1238ee116499SAntonio Huete Jimenez 	s = NULL;
1239ee116499SAntonio Huete Jimenez  out:
1240ee116499SAntonio Huete Jimenez 	free(s);
1241ee116499SAntonio Huete Jimenez 	free(ocopy);
1242ee116499SAntonio Huete Jimenez 	return ret;
124350a69bb5SSascha Wildner }
124450a69bb5SSascha Wildner 
124550a69bb5SSascha Wildner char *
tilde_expand_filename(const char * filename,uid_t uid)124650a69bb5SSascha Wildner tilde_expand_filename(const char *filename, uid_t uid)
124750a69bb5SSascha Wildner {
124850a69bb5SSascha Wildner 	char *ret;
124950a69bb5SSascha Wildner 
125050a69bb5SSascha Wildner 	if (tilde_expand(filename, uid, &ret) != 0)
125150a69bb5SSascha Wildner 		cleanup_exit(255);
125250a69bb5SSascha Wildner 	return ret;
125318de8d7fSPeter Avalos }
125418de8d7fSPeter Avalos 
125518de8d7fSPeter Avalos /*
125650a69bb5SSascha Wildner  * Expand a string with a set of %[char] escapes and/or ${ENVIRONMENT}
125750a69bb5SSascha Wildner  * substitutions.  A number of escapes may be specified as
125850a69bb5SSascha Wildner  * (char *escape_chars, char *replacement) pairs. The list must be terminated
125950a69bb5SSascha Wildner  * by a NULL escape_char. Returns replaced string in memory allocated by
126050a69bb5SSascha Wildner  * xmalloc which the caller must free.
126118de8d7fSPeter Avalos  */
126250a69bb5SSascha Wildner static char *
vdollar_percent_expand(int * parseerror,int dollar,int percent,const char * string,va_list ap)126350a69bb5SSascha Wildner vdollar_percent_expand(int *parseerror, int dollar, int percent,
126450a69bb5SSascha Wildner     const char *string, va_list ap)
126518de8d7fSPeter Avalos {
1266*ba1276acSMatthew Dillon #define EXPAND_MAX_KEYS	64
126750a69bb5SSascha Wildner 	u_int num_keys = 0, i;
126818de8d7fSPeter Avalos 	struct {
126918de8d7fSPeter Avalos 		const char *key;
127018de8d7fSPeter Avalos 		const char *repl;
127118de8d7fSPeter Avalos 	} keys[EXPAND_MAX_KEYS];
12720cbfa66cSDaniel Fojt 	struct sshbuf *buf;
127350a69bb5SSascha Wildner 	int r, missingvar = 0;
127450a69bb5SSascha Wildner 	char *ret = NULL, *var, *varend, *val;
127550a69bb5SSascha Wildner 	size_t len;
12760cbfa66cSDaniel Fojt 
12770cbfa66cSDaniel Fojt 	if ((buf = sshbuf_new()) == NULL)
127850a69bb5SSascha Wildner 		fatal_f("sshbuf_new failed");
127950a69bb5SSascha Wildner 	if (parseerror == NULL)
128050a69bb5SSascha Wildner 		fatal_f("null parseerror arg");
128150a69bb5SSascha Wildner 	*parseerror = 1;
128218de8d7fSPeter Avalos 
128350a69bb5SSascha Wildner 	/* Gather keys if we're doing percent expansion. */
128450a69bb5SSascha Wildner 	if (percent) {
128518de8d7fSPeter Avalos 		for (num_keys = 0; num_keys < EXPAND_MAX_KEYS; num_keys++) {
128618de8d7fSPeter Avalos 			keys[num_keys].key = va_arg(ap, char *);
128718de8d7fSPeter Avalos 			if (keys[num_keys].key == NULL)
128818de8d7fSPeter Avalos 				break;
128918de8d7fSPeter Avalos 			keys[num_keys].repl = va_arg(ap, char *);
129050a69bb5SSascha Wildner 			if (keys[num_keys].repl == NULL) {
129150a69bb5SSascha Wildner 				fatal_f("NULL replacement for token %s",
129250a69bb5SSascha Wildner 				    keys[num_keys].key);
129350a69bb5SSascha Wildner 			}
129418de8d7fSPeter Avalos 		}
1295856ea928SPeter Avalos 		if (num_keys == EXPAND_MAX_KEYS && va_arg(ap, char *) != NULL)
129650a69bb5SSascha Wildner 			fatal_f("too many keys");
129750a69bb5SSascha Wildner 		if (num_keys == 0)
129850a69bb5SSascha Wildner 			fatal_f("percent expansion without token list");
129950a69bb5SSascha Wildner 	}
130018de8d7fSPeter Avalos 
130118de8d7fSPeter Avalos 	/* Expand string */
130218de8d7fSPeter Avalos 	for (i = 0; *string != '\0'; string++) {
130350a69bb5SSascha Wildner 		/* Optionally process ${ENVIRONMENT} expansions. */
130450a69bb5SSascha Wildner 		if (dollar && string[0] == '$' && string[1] == '{') {
130550a69bb5SSascha Wildner 			string += 2;  /* skip over '${' */
130650a69bb5SSascha Wildner 			if ((varend = strchr(string, '}')) == NULL) {
130750a69bb5SSascha Wildner 				error_f("environment variable '%s' missing "
130850a69bb5SSascha Wildner 				    "closing '}'", string);
130950a69bb5SSascha Wildner 				goto out;
13100cbfa66cSDaniel Fojt 			}
131150a69bb5SSascha Wildner 			len = varend - string;
131250a69bb5SSascha Wildner 			if (len == 0) {
131350a69bb5SSascha Wildner 				error_f("zero-length environment variable");
131450a69bb5SSascha Wildner 				goto out;
131550a69bb5SSascha Wildner 			}
131650a69bb5SSascha Wildner 			var = xmalloc(len + 1);
131750a69bb5SSascha Wildner 			(void)strlcpy(var, string, len + 1);
131850a69bb5SSascha Wildner 			if ((val = getenv(var)) == NULL) {
131950a69bb5SSascha Wildner 				error_f("env var ${%s} has no value", var);
132050a69bb5SSascha Wildner 				missingvar = 1;
132150a69bb5SSascha Wildner 			} else {
132250a69bb5SSascha Wildner 				debug3_f("expand ${%s} -> '%s'", var, val);
132350a69bb5SSascha Wildner 				if ((r = sshbuf_put(buf, val, strlen(val))) !=0)
132450a69bb5SSascha Wildner 					fatal_fr(r, "sshbuf_put ${}");
132550a69bb5SSascha Wildner 			}
132650a69bb5SSascha Wildner 			free(var);
132750a69bb5SSascha Wildner 			string += len;
132850a69bb5SSascha Wildner 			continue;
132950a69bb5SSascha Wildner 		}
133050a69bb5SSascha Wildner 
133150a69bb5SSascha Wildner 		/*
133250a69bb5SSascha Wildner 		 * Process percent expansions if we have a list of TOKENs.
133350a69bb5SSascha Wildner 		 * If we're not doing percent expansion everything just gets
133450a69bb5SSascha Wildner 		 * appended here.
133550a69bb5SSascha Wildner 		 */
133650a69bb5SSascha Wildner 		if (*string != '%' || !percent) {
133750a69bb5SSascha Wildner  append:
133850a69bb5SSascha Wildner 			if ((r = sshbuf_put_u8(buf, *string)) != 0)
133950a69bb5SSascha Wildner 				fatal_fr(r, "sshbuf_put_u8 %%");
134018de8d7fSPeter Avalos 			continue;
134118de8d7fSPeter Avalos 		}
134218de8d7fSPeter Avalos 		string++;
1343856ea928SPeter Avalos 		/* %% case */
134418de8d7fSPeter Avalos 		if (*string == '%')
134518de8d7fSPeter Avalos 			goto append;
134650a69bb5SSascha Wildner 		if (*string == '\0') {
134750a69bb5SSascha Wildner 			error_f("invalid format");
134850a69bb5SSascha Wildner 			goto out;
134950a69bb5SSascha Wildner 		}
13500cbfa66cSDaniel Fojt 		for (i = 0; i < num_keys; i++) {
13510cbfa66cSDaniel Fojt 			if (strchr(keys[i].key, *string) != NULL) {
13520cbfa66cSDaniel Fojt 				if ((r = sshbuf_put(buf, keys[i].repl,
135350a69bb5SSascha Wildner 				    strlen(keys[i].repl))) != 0)
135450a69bb5SSascha Wildner 					fatal_fr(r, "sshbuf_put %%-repl");
135518de8d7fSPeter Avalos 				break;
135618de8d7fSPeter Avalos 			}
135718de8d7fSPeter Avalos 		}
135850a69bb5SSascha Wildner 		if (i >= num_keys) {
135950a69bb5SSascha Wildner 			error_f("unknown key %%%c", *string);
136050a69bb5SSascha Wildner 			goto out;
136118de8d7fSPeter Avalos 		}
136250a69bb5SSascha Wildner 	}
136350a69bb5SSascha Wildner 	if (!missingvar && (ret = sshbuf_dup_string(buf)) == NULL)
136450a69bb5SSascha Wildner 		fatal_f("sshbuf_dup_string failed");
136550a69bb5SSascha Wildner 	*parseerror = 0;
136650a69bb5SSascha Wildner  out:
13670cbfa66cSDaniel Fojt 	sshbuf_free(buf);
136850a69bb5SSascha Wildner 	return *parseerror ? NULL : ret;
136918de8d7fSPeter Avalos #undef EXPAND_MAX_KEYS
137018de8d7fSPeter Avalos }
137118de8d7fSPeter Avalos 
137250a69bb5SSascha Wildner /*
137350a69bb5SSascha Wildner  * Expand only environment variables.
137450a69bb5SSascha Wildner  * Note that although this function is variadic like the other similar
137550a69bb5SSascha Wildner  * functions, any such arguments will be unused.
137650a69bb5SSascha Wildner  */
137750a69bb5SSascha Wildner 
137850a69bb5SSascha Wildner char *
dollar_expand(int * parseerr,const char * string,...)137950a69bb5SSascha Wildner dollar_expand(int *parseerr, const char *string, ...)
138050a69bb5SSascha Wildner {
138150a69bb5SSascha Wildner 	char *ret;
138250a69bb5SSascha Wildner 	int err;
138350a69bb5SSascha Wildner 	va_list ap;
138450a69bb5SSascha Wildner 
138550a69bb5SSascha Wildner 	va_start(ap, string);
138650a69bb5SSascha Wildner 	ret = vdollar_percent_expand(&err, 1, 0, string, ap);
138750a69bb5SSascha Wildner 	va_end(ap);
138850a69bb5SSascha Wildner 	if (parseerr != NULL)
138950a69bb5SSascha Wildner 		*parseerr = err;
139050a69bb5SSascha Wildner 	return ret;
139150a69bb5SSascha Wildner }
139250a69bb5SSascha Wildner 
139350a69bb5SSascha Wildner /*
139450a69bb5SSascha Wildner  * Returns expanded string or NULL if a specified environment variable is
139550a69bb5SSascha Wildner  * not defined, or calls fatal if the string is invalid.
139650a69bb5SSascha Wildner  */
139750a69bb5SSascha Wildner char *
percent_expand(const char * string,...)139850a69bb5SSascha Wildner percent_expand(const char *string, ...)
139950a69bb5SSascha Wildner {
140050a69bb5SSascha Wildner 	char *ret;
140150a69bb5SSascha Wildner 	int err;
140250a69bb5SSascha Wildner 	va_list ap;
140350a69bb5SSascha Wildner 
140450a69bb5SSascha Wildner 	va_start(ap, string);
140550a69bb5SSascha Wildner 	ret = vdollar_percent_expand(&err, 0, 1, string, ap);
140650a69bb5SSascha Wildner 	va_end(ap);
140750a69bb5SSascha Wildner 	if (err)
140850a69bb5SSascha Wildner 		fatal_f("failed");
140950a69bb5SSascha Wildner 	return ret;
141050a69bb5SSascha Wildner }
141150a69bb5SSascha Wildner 
141250a69bb5SSascha Wildner /*
141350a69bb5SSascha Wildner  * Returns expanded string or NULL if a specified environment variable is
141450a69bb5SSascha Wildner  * not defined, or calls fatal if the string is invalid.
141550a69bb5SSascha Wildner  */
141650a69bb5SSascha Wildner char *
percent_dollar_expand(const char * string,...)141750a69bb5SSascha Wildner percent_dollar_expand(const char *string, ...)
141850a69bb5SSascha Wildner {
141950a69bb5SSascha Wildner 	char *ret;
142050a69bb5SSascha Wildner 	int err;
142150a69bb5SSascha Wildner 	va_list ap;
142250a69bb5SSascha Wildner 
142350a69bb5SSascha Wildner 	va_start(ap, string);
142450a69bb5SSascha Wildner 	ret = vdollar_percent_expand(&err, 1, 1, string, ap);
142550a69bb5SSascha Wildner 	va_end(ap);
142650a69bb5SSascha Wildner 	if (err)
142750a69bb5SSascha Wildner 		fatal_f("failed");
142850a69bb5SSascha Wildner 	return ret;
142950a69bb5SSascha Wildner }
143050a69bb5SSascha Wildner 
143118de8d7fSPeter Avalos int
tun_open(int tun,int mode,char ** ifname)1432664f4763Szrj tun_open(int tun, int mode, char **ifname)
143318de8d7fSPeter Avalos {
143418de8d7fSPeter Avalos #if defined(CUSTOM_SYS_TUN_OPEN)
1435664f4763Szrj 	return (sys_tun_open(tun, mode, ifname));
143618de8d7fSPeter Avalos #elif defined(SSH_TUN_OPENBSD)
143718de8d7fSPeter Avalos 	struct ifreq ifr;
143818de8d7fSPeter Avalos 	char name[100];
143918de8d7fSPeter Avalos 	int fd = -1, sock;
1440e9778795SPeter Avalos 	const char *tunbase = "tun";
1441e9778795SPeter Avalos 
1442664f4763Szrj 	if (ifname != NULL)
1443664f4763Szrj 		*ifname = NULL;
1444664f4763Szrj 
1445e9778795SPeter Avalos 	if (mode == SSH_TUNMODE_ETHERNET)
1446e9778795SPeter Avalos 		tunbase = "tap";
144718de8d7fSPeter Avalos 
144818de8d7fSPeter Avalos 	/* Open the tunnel device */
144918de8d7fSPeter Avalos 	if (tun <= SSH_TUNID_MAX) {
1450e9778795SPeter Avalos 		snprintf(name, sizeof(name), "/dev/%s%d", tunbase, tun);
145118de8d7fSPeter Avalos 		fd = open(name, O_RDWR);
145218de8d7fSPeter Avalos 	} else if (tun == SSH_TUNID_ANY) {
145318de8d7fSPeter Avalos 		for (tun = 100; tun >= 0; tun--) {
1454e9778795SPeter Avalos 			snprintf(name, sizeof(name), "/dev/%s%d",
1455e9778795SPeter Avalos 			    tunbase, tun);
145618de8d7fSPeter Avalos 			if ((fd = open(name, O_RDWR)) >= 0)
145718de8d7fSPeter Avalos 				break;
145818de8d7fSPeter Avalos 		}
145918de8d7fSPeter Avalos 	} else {
146050a69bb5SSascha Wildner 		debug_f("invalid tunnel %u", tun);
1461e9778795SPeter Avalos 		return -1;
146218de8d7fSPeter Avalos 	}
146318de8d7fSPeter Avalos 
14640cbfa66cSDaniel Fojt 	if (fd == -1) {
146550a69bb5SSascha Wildner 		debug_f("%s open: %s", name, strerror(errno));
1466e9778795SPeter Avalos 		return -1;
146718de8d7fSPeter Avalos 	}
146818de8d7fSPeter Avalos 
146950a69bb5SSascha Wildner 	debug_f("%s mode %d fd %d", name, mode, fd);
147018de8d7fSPeter Avalos 
1471e9778795SPeter Avalos 	/* Bring interface up if it is not already */
1472e9778795SPeter Avalos 	snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s%d", tunbase, tun);
147318de8d7fSPeter Avalos 	if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) == -1)
147418de8d7fSPeter Avalos 		goto failed;
147518de8d7fSPeter Avalos 
1476e9778795SPeter Avalos 	if (ioctl(sock, SIOCGIFFLAGS, &ifr) == -1) {
147750a69bb5SSascha Wildner 		debug_f("get interface %s flags: %s", ifr.ifr_name,
147850a69bb5SSascha Wildner 		    strerror(errno));
147918de8d7fSPeter Avalos 		goto failed;
1480e9778795SPeter Avalos 	}
148118de8d7fSPeter Avalos 
1482e9778795SPeter Avalos 	if (!(ifr.ifr_flags & IFF_UP)) {
148318de8d7fSPeter Avalos 		ifr.ifr_flags |= IFF_UP;
1484e9778795SPeter Avalos 		if (ioctl(sock, SIOCSIFFLAGS, &ifr) == -1) {
148550a69bb5SSascha Wildner 			debug_f("activate interface %s: %s", ifr.ifr_name,
148650a69bb5SSascha Wildner 			    strerror(errno));
148718de8d7fSPeter Avalos 			goto failed;
1488e9778795SPeter Avalos 		}
1489e9778795SPeter Avalos 	}
149018de8d7fSPeter Avalos 
1491664f4763Szrj 	if (ifname != NULL)
1492664f4763Szrj 		*ifname = xstrdup(ifr.ifr_name);
1493664f4763Szrj 
149418de8d7fSPeter Avalos 	close(sock);
1495e9778795SPeter Avalos 	return fd;
149618de8d7fSPeter Avalos 
149718de8d7fSPeter Avalos  failed:
149818de8d7fSPeter Avalos 	if (fd >= 0)
149918de8d7fSPeter Avalos 		close(fd);
150018de8d7fSPeter Avalos 	if (sock >= 0)
150118de8d7fSPeter Avalos 		close(sock);
1502e9778795SPeter Avalos 	return -1;
150318de8d7fSPeter Avalos #else
150418de8d7fSPeter Avalos 	error("Tunnel interfaces are not supported on this platform");
150518de8d7fSPeter Avalos 	return (-1);
150618de8d7fSPeter Avalos #endif
150718de8d7fSPeter Avalos }
150818de8d7fSPeter Avalos 
150918de8d7fSPeter Avalos void
sanitise_stdfd(void)151018de8d7fSPeter Avalos sanitise_stdfd(void)
151118de8d7fSPeter Avalos {
151218de8d7fSPeter Avalos 	int nullfd, dupfd;
151318de8d7fSPeter Avalos 
151418de8d7fSPeter Avalos 	if ((nullfd = dupfd = open(_PATH_DEVNULL, O_RDWR)) == -1) {
1515cb5eb4f1SPeter Avalos 		fprintf(stderr, "Couldn't open /dev/null: %s\n",
1516cb5eb4f1SPeter Avalos 		    strerror(errno));
151718de8d7fSPeter Avalos 		exit(1);
151818de8d7fSPeter Avalos 	}
1519e9778795SPeter Avalos 	while (++dupfd <= STDERR_FILENO) {
1520e9778795SPeter Avalos 		/* Only populate closed fds. */
1521e9778795SPeter Avalos 		if (fcntl(dupfd, F_GETFL) == -1 && errno == EBADF) {
152218de8d7fSPeter Avalos 			if (dup2(nullfd, dupfd) == -1) {
1523cb5eb4f1SPeter Avalos 				fprintf(stderr, "dup2: %s\n", strerror(errno));
152418de8d7fSPeter Avalos 				exit(1);
152518de8d7fSPeter Avalos 			}
152618de8d7fSPeter Avalos 		}
1527e9778795SPeter Avalos 	}
1528e9778795SPeter Avalos 	if (nullfd > STDERR_FILENO)
152918de8d7fSPeter Avalos 		close(nullfd);
153018de8d7fSPeter Avalos }
153118de8d7fSPeter Avalos 
153218de8d7fSPeter Avalos char *
tohex(const void * vp,size_t l)153318de8d7fSPeter Avalos tohex(const void *vp, size_t l)
153418de8d7fSPeter Avalos {
153518de8d7fSPeter Avalos 	const u_char *p = (const u_char *)vp;
153618de8d7fSPeter Avalos 	char b[3], *r;
153718de8d7fSPeter Avalos 	size_t i, hl;
153818de8d7fSPeter Avalos 
153918de8d7fSPeter Avalos 	if (l > 65536)
154018de8d7fSPeter Avalos 		return xstrdup("tohex: length > 65536");
154118de8d7fSPeter Avalos 
154218de8d7fSPeter Avalos 	hl = l * 2 + 1;
154318de8d7fSPeter Avalos 	r = xcalloc(1, hl);
154418de8d7fSPeter Avalos 	for (i = 0; i < l; i++) {
154518de8d7fSPeter Avalos 		snprintf(b, sizeof(b), "%02x", p[i]);
154618de8d7fSPeter Avalos 		strlcat(r, b, hl);
154718de8d7fSPeter Avalos 	}
154818de8d7fSPeter Avalos 	return (r);
154918de8d7fSPeter Avalos }
155018de8d7fSPeter Avalos 
15510cbfa66cSDaniel Fojt /*
15520cbfa66cSDaniel Fojt  * Extend string *sp by the specified format. If *sp is not NULL (or empty),
15530cbfa66cSDaniel Fojt  * then the separator 'sep' will be prepended before the formatted arguments.
15540cbfa66cSDaniel Fojt  * Extended strings are heap allocated.
15550cbfa66cSDaniel Fojt  */
15560cbfa66cSDaniel Fojt void
xextendf(char ** sp,const char * sep,const char * fmt,...)15570cbfa66cSDaniel Fojt xextendf(char **sp, const char *sep, const char *fmt, ...)
15580cbfa66cSDaniel Fojt {
15590cbfa66cSDaniel Fojt 	va_list ap;
15600cbfa66cSDaniel Fojt 	char *tmp1, *tmp2;
15610cbfa66cSDaniel Fojt 
15620cbfa66cSDaniel Fojt 	va_start(ap, fmt);
15630cbfa66cSDaniel Fojt 	xvasprintf(&tmp1, fmt, ap);
15640cbfa66cSDaniel Fojt 	va_end(ap);
15650cbfa66cSDaniel Fojt 
15660cbfa66cSDaniel Fojt 	if (*sp == NULL || **sp == '\0') {
15670cbfa66cSDaniel Fojt 		free(*sp);
15680cbfa66cSDaniel Fojt 		*sp = tmp1;
15690cbfa66cSDaniel Fojt 		return;
15700cbfa66cSDaniel Fojt 	}
15710cbfa66cSDaniel Fojt 	xasprintf(&tmp2, "%s%s%s", *sp, sep == NULL ? "" : sep, tmp1);
15720cbfa66cSDaniel Fojt 	free(tmp1);
15730cbfa66cSDaniel Fojt 	free(*sp);
15740cbfa66cSDaniel Fojt 	*sp = tmp2;
15750cbfa66cSDaniel Fojt }
15760cbfa66cSDaniel Fojt 
15770cbfa66cSDaniel Fojt 
157818de8d7fSPeter Avalos u_int64_t
get_u64(const void * vp)157918de8d7fSPeter Avalos get_u64(const void *vp)
158018de8d7fSPeter Avalos {
158118de8d7fSPeter Avalos 	const u_char *p = (const u_char *)vp;
158218de8d7fSPeter Avalos 	u_int64_t v;
158318de8d7fSPeter Avalos 
158418de8d7fSPeter Avalos 	v  = (u_int64_t)p[0] << 56;
158518de8d7fSPeter Avalos 	v |= (u_int64_t)p[1] << 48;
158618de8d7fSPeter Avalos 	v |= (u_int64_t)p[2] << 40;
158718de8d7fSPeter Avalos 	v |= (u_int64_t)p[3] << 32;
158818de8d7fSPeter Avalos 	v |= (u_int64_t)p[4] << 24;
158918de8d7fSPeter Avalos 	v |= (u_int64_t)p[5] << 16;
159018de8d7fSPeter Avalos 	v |= (u_int64_t)p[6] << 8;
159118de8d7fSPeter Avalos 	v |= (u_int64_t)p[7];
159218de8d7fSPeter Avalos 
159318de8d7fSPeter Avalos 	return (v);
159418de8d7fSPeter Avalos }
159518de8d7fSPeter Avalos 
159618de8d7fSPeter Avalos u_int32_t
get_u32(const void * vp)159718de8d7fSPeter Avalos get_u32(const void *vp)
159818de8d7fSPeter Avalos {
159918de8d7fSPeter Avalos 	const u_char *p = (const u_char *)vp;
160018de8d7fSPeter Avalos 	u_int32_t v;
160118de8d7fSPeter Avalos 
160218de8d7fSPeter Avalos 	v  = (u_int32_t)p[0] << 24;
160318de8d7fSPeter Avalos 	v |= (u_int32_t)p[1] << 16;
160418de8d7fSPeter Avalos 	v |= (u_int32_t)p[2] << 8;
160518de8d7fSPeter Avalos 	v |= (u_int32_t)p[3];
160618de8d7fSPeter Avalos 
160718de8d7fSPeter Avalos 	return (v);
160818de8d7fSPeter Avalos }
160918de8d7fSPeter Avalos 
161036e94dc5SPeter Avalos u_int32_t
get_u32_le(const void * vp)161136e94dc5SPeter Avalos get_u32_le(const void *vp)
161236e94dc5SPeter Avalos {
161336e94dc5SPeter Avalos 	const u_char *p = (const u_char *)vp;
161436e94dc5SPeter Avalos 	u_int32_t v;
161536e94dc5SPeter Avalos 
161636e94dc5SPeter Avalos 	v  = (u_int32_t)p[0];
161736e94dc5SPeter Avalos 	v |= (u_int32_t)p[1] << 8;
161836e94dc5SPeter Avalos 	v |= (u_int32_t)p[2] << 16;
161936e94dc5SPeter Avalos 	v |= (u_int32_t)p[3] << 24;
162036e94dc5SPeter Avalos 
162136e94dc5SPeter Avalos 	return (v);
162236e94dc5SPeter Avalos }
162336e94dc5SPeter Avalos 
162418de8d7fSPeter Avalos u_int16_t
get_u16(const void * vp)162518de8d7fSPeter Avalos get_u16(const void *vp)
162618de8d7fSPeter Avalos {
162718de8d7fSPeter Avalos 	const u_char *p = (const u_char *)vp;
162818de8d7fSPeter Avalos 	u_int16_t v;
162918de8d7fSPeter Avalos 
163018de8d7fSPeter Avalos 	v  = (u_int16_t)p[0] << 8;
163118de8d7fSPeter Avalos 	v |= (u_int16_t)p[1];
163218de8d7fSPeter Avalos 
163318de8d7fSPeter Avalos 	return (v);
163418de8d7fSPeter Avalos }
163518de8d7fSPeter Avalos 
163618de8d7fSPeter Avalos void
put_u64(void * vp,u_int64_t v)163718de8d7fSPeter Avalos put_u64(void *vp, u_int64_t v)
163818de8d7fSPeter Avalos {
163918de8d7fSPeter Avalos 	u_char *p = (u_char *)vp;
164018de8d7fSPeter Avalos 
164118de8d7fSPeter Avalos 	p[0] = (u_char)(v >> 56) & 0xff;
164218de8d7fSPeter Avalos 	p[1] = (u_char)(v >> 48) & 0xff;
164318de8d7fSPeter Avalos 	p[2] = (u_char)(v >> 40) & 0xff;
164418de8d7fSPeter Avalos 	p[3] = (u_char)(v >> 32) & 0xff;
164518de8d7fSPeter Avalos 	p[4] = (u_char)(v >> 24) & 0xff;
164618de8d7fSPeter Avalos 	p[5] = (u_char)(v >> 16) & 0xff;
164718de8d7fSPeter Avalos 	p[6] = (u_char)(v >> 8) & 0xff;
164818de8d7fSPeter Avalos 	p[7] = (u_char)v & 0xff;
164918de8d7fSPeter Avalos }
165018de8d7fSPeter Avalos 
165118de8d7fSPeter Avalos void
put_u32(void * vp,u_int32_t v)165218de8d7fSPeter Avalos put_u32(void *vp, u_int32_t v)
165318de8d7fSPeter Avalos {
165418de8d7fSPeter Avalos 	u_char *p = (u_char *)vp;
165518de8d7fSPeter Avalos 
165618de8d7fSPeter Avalos 	p[0] = (u_char)(v >> 24) & 0xff;
165718de8d7fSPeter Avalos 	p[1] = (u_char)(v >> 16) & 0xff;
165818de8d7fSPeter Avalos 	p[2] = (u_char)(v >> 8) & 0xff;
165918de8d7fSPeter Avalos 	p[3] = (u_char)v & 0xff;
166018de8d7fSPeter Avalos }
166118de8d7fSPeter Avalos 
166236e94dc5SPeter Avalos void
put_u32_le(void * vp,u_int32_t v)166336e94dc5SPeter Avalos put_u32_le(void *vp, u_int32_t v)
166436e94dc5SPeter Avalos {
166536e94dc5SPeter Avalos 	u_char *p = (u_char *)vp;
166636e94dc5SPeter Avalos 
166736e94dc5SPeter Avalos 	p[0] = (u_char)v & 0xff;
166836e94dc5SPeter Avalos 	p[1] = (u_char)(v >> 8) & 0xff;
166936e94dc5SPeter Avalos 	p[2] = (u_char)(v >> 16) & 0xff;
167036e94dc5SPeter Avalos 	p[3] = (u_char)(v >> 24) & 0xff;
167136e94dc5SPeter Avalos }
167218de8d7fSPeter Avalos 
167318de8d7fSPeter Avalos void
put_u16(void * vp,u_int16_t v)167418de8d7fSPeter Avalos put_u16(void *vp, u_int16_t v)
167518de8d7fSPeter Avalos {
167618de8d7fSPeter Avalos 	u_char *p = (u_char *)vp;
167718de8d7fSPeter Avalos 
167818de8d7fSPeter Avalos 	p[0] = (u_char)(v >> 8) & 0xff;
167918de8d7fSPeter Avalos 	p[1] = (u_char)v & 0xff;
168018de8d7fSPeter Avalos }
168118de8d7fSPeter Avalos 
168218de8d7fSPeter Avalos void
ms_subtract_diff(struct timeval * start,int * ms)168318de8d7fSPeter Avalos ms_subtract_diff(struct timeval *start, int *ms)
168418de8d7fSPeter Avalos {
168518de8d7fSPeter Avalos 	struct timeval diff, finish;
168618de8d7fSPeter Avalos 
1687664f4763Szrj 	monotime_tv(&finish);
168818de8d7fSPeter Avalos 	timersub(&finish, start, &diff);
168918de8d7fSPeter Avalos 	*ms -= (diff.tv_sec * 1000) + (diff.tv_usec / 1000);
169018de8d7fSPeter Avalos }
169118de8d7fSPeter Avalos 
169218de8d7fSPeter Avalos void
ms_to_timespec(struct timespec * ts,int ms)1693ee116499SAntonio Huete Jimenez ms_to_timespec(struct timespec *ts, int ms)
169418de8d7fSPeter Avalos {
169518de8d7fSPeter Avalos 	if (ms < 0)
169618de8d7fSPeter Avalos 		ms = 0;
1697ee116499SAntonio Huete Jimenez 	ts->tv_sec = ms / 1000;
1698ee116499SAntonio Huete Jimenez 	ts->tv_nsec = (ms % 1000) * 1000 * 1000;
169918de8d7fSPeter Avalos }
170018de8d7fSPeter Avalos 
1701664f4763Szrj void
monotime_ts(struct timespec * ts)1702664f4763Szrj monotime_ts(struct timespec *ts)
170336e94dc5SPeter Avalos {
1704664f4763Szrj 	struct timeval tv;
1705664f4763Szrj #if defined(HAVE_CLOCK_GETTIME) && (defined(CLOCK_BOOTTIME) || \
1706664f4763Szrj     defined(CLOCK_MONOTONIC) || defined(CLOCK_REALTIME))
170736e94dc5SPeter Avalos 	static int gettime_failed = 0;
170836e94dc5SPeter Avalos 
170936e94dc5SPeter Avalos 	if (!gettime_failed) {
1710664f4763Szrj # ifdef CLOCK_BOOTTIME
1711664f4763Szrj 		if (clock_gettime(CLOCK_BOOTTIME, ts) == 0)
1712664f4763Szrj 			return;
1713664f4763Szrj # endif /* CLOCK_BOOTTIME */
1714664f4763Szrj # ifdef CLOCK_MONOTONIC
1715664f4763Szrj 		if (clock_gettime(CLOCK_MONOTONIC, ts) == 0)
1716664f4763Szrj 			return;
1717664f4763Szrj # endif /* CLOCK_MONOTONIC */
1718664f4763Szrj # ifdef CLOCK_REALTIME
1719664f4763Szrj 		/* Not monotonic, but we're almost out of options here. */
1720664f4763Szrj 		if (clock_gettime(CLOCK_REALTIME, ts) == 0)
1721664f4763Szrj 			return;
1722664f4763Szrj # endif /* CLOCK_REALTIME */
172336e94dc5SPeter Avalos 		debug3("clock_gettime: %s", strerror(errno));
172436e94dc5SPeter Avalos 		gettime_failed = 1;
172536e94dc5SPeter Avalos 	}
1726664f4763Szrj #endif /* HAVE_CLOCK_GETTIME && (BOOTTIME || MONOTONIC || REALTIME) */
1727664f4763Szrj 	gettimeofday(&tv, NULL);
1728664f4763Szrj 	ts->tv_sec = tv.tv_sec;
1729664f4763Szrj 	ts->tv_nsec = (long)tv.tv_usec * 1000;
1730664f4763Szrj }
173136e94dc5SPeter Avalos 
1732664f4763Szrj void
monotime_tv(struct timeval * tv)1733664f4763Szrj monotime_tv(struct timeval *tv)
1734664f4763Szrj {
1735664f4763Szrj 	struct timespec ts;
1736664f4763Szrj 
1737664f4763Szrj 	monotime_ts(&ts);
1738664f4763Szrj 	tv->tv_sec = ts.tv_sec;
1739664f4763Szrj 	tv->tv_usec = ts.tv_nsec / 1000;
1740664f4763Szrj }
1741664f4763Szrj 
1742664f4763Szrj time_t
monotime(void)1743664f4763Szrj monotime(void)
1744664f4763Szrj {
1745664f4763Szrj 	struct timespec ts;
1746664f4763Szrj 
1747664f4763Szrj 	monotime_ts(&ts);
1748664f4763Szrj 	return ts.tv_sec;
174936e94dc5SPeter Avalos }
175036e94dc5SPeter Avalos 
1751e9778795SPeter Avalos double
monotime_double(void)1752e9778795SPeter Avalos monotime_double(void)
1753e9778795SPeter Avalos {
1754e9778795SPeter Avalos 	struct timespec ts;
1755e9778795SPeter Avalos 
1756664f4763Szrj 	monotime_ts(&ts);
1757664f4763Szrj 	return ts.tv_sec + ((double)ts.tv_nsec / 1000000000);
1758e9778795SPeter Avalos }
1759e9778795SPeter Avalos 
17609f304aafSPeter Avalos void
bandwidth_limit_init(struct bwlimit * bw,u_int64_t kbps,size_t buflen)17619f304aafSPeter Avalos bandwidth_limit_init(struct bwlimit *bw, u_int64_t kbps, size_t buflen)
1762856ea928SPeter Avalos {
17639f304aafSPeter Avalos 	bw->buflen = buflen;
17649f304aafSPeter Avalos 	bw->rate = kbps;
1765664f4763Szrj 	bw->thresh = buflen;
17669f304aafSPeter Avalos 	bw->lamt = 0;
17679f304aafSPeter Avalos 	timerclear(&bw->bwstart);
17689f304aafSPeter Avalos 	timerclear(&bw->bwend);
1769856ea928SPeter Avalos }
17709f304aafSPeter Avalos 
17719f304aafSPeter Avalos /* Callback from read/write loop to insert bandwidth-limiting delays */
17729f304aafSPeter Avalos void
bandwidth_limit(struct bwlimit * bw,size_t read_len)17739f304aafSPeter Avalos bandwidth_limit(struct bwlimit *bw, size_t read_len)
17749f304aafSPeter Avalos {
17759f304aafSPeter Avalos 	u_int64_t waitlen;
17769f304aafSPeter Avalos 	struct timespec ts, rm;
17779f304aafSPeter Avalos 
1778664f4763Szrj 	bw->lamt += read_len;
17799f304aafSPeter Avalos 	if (!timerisset(&bw->bwstart)) {
1780664f4763Szrj 		monotime_tv(&bw->bwstart);
17819f304aafSPeter Avalos 		return;
17829f304aafSPeter Avalos 	}
17839f304aafSPeter Avalos 	if (bw->lamt < bw->thresh)
17849f304aafSPeter Avalos 		return;
17859f304aafSPeter Avalos 
1786664f4763Szrj 	monotime_tv(&bw->bwend);
17879f304aafSPeter Avalos 	timersub(&bw->bwend, &bw->bwstart, &bw->bwend);
17889f304aafSPeter Avalos 	if (!timerisset(&bw->bwend))
17899f304aafSPeter Avalos 		return;
17909f304aafSPeter Avalos 
17919f304aafSPeter Avalos 	bw->lamt *= 8;
17929f304aafSPeter Avalos 	waitlen = (double)1000000L * bw->lamt / bw->rate;
17939f304aafSPeter Avalos 
17949f304aafSPeter Avalos 	bw->bwstart.tv_sec = waitlen / 1000000L;
17959f304aafSPeter Avalos 	bw->bwstart.tv_usec = waitlen % 1000000L;
17969f304aafSPeter Avalos 
17979f304aafSPeter Avalos 	if (timercmp(&bw->bwstart, &bw->bwend, >)) {
17989f304aafSPeter Avalos 		timersub(&bw->bwstart, &bw->bwend, &bw->bwend);
17999f304aafSPeter Avalos 
18009f304aafSPeter Avalos 		/* Adjust the wait time */
18019f304aafSPeter Avalos 		if (bw->bwend.tv_sec) {
18029f304aafSPeter Avalos 			bw->thresh /= 2;
18039f304aafSPeter Avalos 			if (bw->thresh < bw->buflen / 4)
18049f304aafSPeter Avalos 				bw->thresh = bw->buflen / 4;
18059f304aafSPeter Avalos 		} else if (bw->bwend.tv_usec < 10000) {
18069f304aafSPeter Avalos 			bw->thresh *= 2;
18079f304aafSPeter Avalos 			if (bw->thresh > bw->buflen * 8)
18089f304aafSPeter Avalos 				bw->thresh = bw->buflen * 8;
18099f304aafSPeter Avalos 		}
18109f304aafSPeter Avalos 
18119f304aafSPeter Avalos 		TIMEVAL_TO_TIMESPEC(&bw->bwend, &ts);
18129f304aafSPeter Avalos 		while (nanosleep(&ts, &rm) == -1) {
18139f304aafSPeter Avalos 			if (errno != EINTR)
18149f304aafSPeter Avalos 				break;
18159f304aafSPeter Avalos 			ts = rm;
18169f304aafSPeter Avalos 		}
18179f304aafSPeter Avalos 	}
18189f304aafSPeter Avalos 
18199f304aafSPeter Avalos 	bw->lamt = 0;
1820664f4763Szrj 	monotime_tv(&bw->bwstart);
18219f304aafSPeter Avalos }
18229f304aafSPeter Avalos 
18239f304aafSPeter Avalos /* Make a template filename for mk[sd]temp() */
18249f304aafSPeter Avalos void
mktemp_proto(char * s,size_t len)18259f304aafSPeter Avalos mktemp_proto(char *s, size_t len)
18269f304aafSPeter Avalos {
18279f304aafSPeter Avalos 	const char *tmpdir;
18289f304aafSPeter Avalos 	int r;
18299f304aafSPeter Avalos 
18309f304aafSPeter Avalos 	if ((tmpdir = getenv("TMPDIR")) != NULL) {
18319f304aafSPeter Avalos 		r = snprintf(s, len, "%s/ssh-XXXXXXXXXXXX", tmpdir);
18329f304aafSPeter Avalos 		if (r > 0 && (size_t)r < len)
18339f304aafSPeter Avalos 			return;
18349f304aafSPeter Avalos 	}
18359f304aafSPeter Avalos 	r = snprintf(s, len, "/tmp/ssh-XXXXXXXXXXXX");
18369f304aafSPeter Avalos 	if (r < 0 || (size_t)r >= len)
183750a69bb5SSascha Wildner 		fatal_f("template string too short");
18389f304aafSPeter Avalos }
18399f304aafSPeter Avalos 
18409f304aafSPeter Avalos static const struct {
18419f304aafSPeter Avalos 	const char *name;
18429f304aafSPeter Avalos 	int value;
18439f304aafSPeter Avalos } ipqos[] = {
1844ce74bacaSMatthew Dillon 	{ "none", INT_MAX },		/* can't use 0 here; that's CS0 */
18459f304aafSPeter Avalos 	{ "af11", IPTOS_DSCP_AF11 },
18469f304aafSPeter Avalos 	{ "af12", IPTOS_DSCP_AF12 },
18479f304aafSPeter Avalos 	{ "af13", IPTOS_DSCP_AF13 },
184899e85e0dSPeter Avalos 	{ "af21", IPTOS_DSCP_AF21 },
18499f304aafSPeter Avalos 	{ "af22", IPTOS_DSCP_AF22 },
18509f304aafSPeter Avalos 	{ "af23", IPTOS_DSCP_AF23 },
18519f304aafSPeter Avalos 	{ "af31", IPTOS_DSCP_AF31 },
18529f304aafSPeter Avalos 	{ "af32", IPTOS_DSCP_AF32 },
18539f304aafSPeter Avalos 	{ "af33", IPTOS_DSCP_AF33 },
18549f304aafSPeter Avalos 	{ "af41", IPTOS_DSCP_AF41 },
18559f304aafSPeter Avalos 	{ "af42", IPTOS_DSCP_AF42 },
18569f304aafSPeter Avalos 	{ "af43", IPTOS_DSCP_AF43 },
18579f304aafSPeter Avalos 	{ "cs0", IPTOS_DSCP_CS0 },
18589f304aafSPeter Avalos 	{ "cs1", IPTOS_DSCP_CS1 },
18599f304aafSPeter Avalos 	{ "cs2", IPTOS_DSCP_CS2 },
18609f304aafSPeter Avalos 	{ "cs3", IPTOS_DSCP_CS3 },
18619f304aafSPeter Avalos 	{ "cs4", IPTOS_DSCP_CS4 },
18629f304aafSPeter Avalos 	{ "cs5", IPTOS_DSCP_CS5 },
18639f304aafSPeter Avalos 	{ "cs6", IPTOS_DSCP_CS6 },
18649f304aafSPeter Avalos 	{ "cs7", IPTOS_DSCP_CS7 },
18659f304aafSPeter Avalos 	{ "ef", IPTOS_DSCP_EF },
18660cbfa66cSDaniel Fojt 	{ "le", IPTOS_DSCP_LE },
18679f304aafSPeter Avalos 	{ "lowdelay", IPTOS_LOWDELAY },
18689f304aafSPeter Avalos 	{ "throughput", IPTOS_THROUGHPUT },
18699f304aafSPeter Avalos 	{ "reliability", IPTOS_RELIABILITY },
18709f304aafSPeter Avalos 	{ NULL, -1 }
18719f304aafSPeter Avalos };
18729f304aafSPeter Avalos 
18739f304aafSPeter Avalos int
parse_ipqos(const char * cp)18749f304aafSPeter Avalos parse_ipqos(const char *cp)
18759f304aafSPeter Avalos {
1876*ba1276acSMatthew Dillon 	const char *errstr;
18779f304aafSPeter Avalos 	u_int i;
1878*ba1276acSMatthew Dillon 	int val;
18799f304aafSPeter Avalos 
18809f304aafSPeter Avalos 	if (cp == NULL)
18819f304aafSPeter Avalos 		return -1;
18829f304aafSPeter Avalos 	for (i = 0; ipqos[i].name != NULL; i++) {
18839f304aafSPeter Avalos 		if (strcasecmp(cp, ipqos[i].name) == 0)
18849f304aafSPeter Avalos 			return ipqos[i].value;
18859f304aafSPeter Avalos 	}
18869f304aafSPeter Avalos 	/* Try parsing as an integer */
1887*ba1276acSMatthew Dillon 	val = (int)strtonum(cp, 0, 255, &errstr);
1888*ba1276acSMatthew Dillon 	if (errstr)
18899f304aafSPeter Avalos 		return -1;
18909f304aafSPeter Avalos 	return val;
18919f304aafSPeter Avalos }
18929f304aafSPeter Avalos 
18931c188a7fSPeter Avalos const char *
iptos2str(int iptos)18941c188a7fSPeter Avalos iptos2str(int iptos)
18951c188a7fSPeter Avalos {
18961c188a7fSPeter Avalos 	int i;
18971c188a7fSPeter Avalos 	static char iptos_str[sizeof "0xff"];
18981c188a7fSPeter Avalos 
18991c188a7fSPeter Avalos 	for (i = 0; ipqos[i].name != NULL; i++) {
19001c188a7fSPeter Avalos 		if (ipqos[i].value == iptos)
19011c188a7fSPeter Avalos 			return ipqos[i].name;
19021c188a7fSPeter Avalos 	}
19031c188a7fSPeter Avalos 	snprintf(iptos_str, sizeof iptos_str, "0x%02x", iptos);
19041c188a7fSPeter Avalos 	return iptos_str;
19051c188a7fSPeter Avalos }
190636e94dc5SPeter Avalos 
190736e94dc5SPeter Avalos void
lowercase(char * s)190836e94dc5SPeter Avalos lowercase(char *s)
190936e94dc5SPeter Avalos {
191036e94dc5SPeter Avalos 	for (; *s; s++)
191136e94dc5SPeter Avalos 		*s = tolower((u_char)*s);
191236e94dc5SPeter Avalos }
191336e94dc5SPeter Avalos 
191436e94dc5SPeter Avalos int
unix_listener(const char * path,int backlog,int unlink_first)191536e94dc5SPeter Avalos unix_listener(const char *path, int backlog, int unlink_first)
191636e94dc5SPeter Avalos {
191736e94dc5SPeter Avalos 	struct sockaddr_un sunaddr;
191836e94dc5SPeter Avalos 	int saved_errno, sock;
191936e94dc5SPeter Avalos 
192036e94dc5SPeter Avalos 	memset(&sunaddr, 0, sizeof(sunaddr));
192136e94dc5SPeter Avalos 	sunaddr.sun_family = AF_UNIX;
1922664f4763Szrj 	if (strlcpy(sunaddr.sun_path, path,
1923664f4763Szrj 	    sizeof(sunaddr.sun_path)) >= sizeof(sunaddr.sun_path)) {
192450a69bb5SSascha Wildner 		error_f("path \"%s\" too long for Unix domain socket", path);
192536e94dc5SPeter Avalos 		errno = ENAMETOOLONG;
192636e94dc5SPeter Avalos 		return -1;
192736e94dc5SPeter Avalos 	}
192836e94dc5SPeter Avalos 
192936e94dc5SPeter Avalos 	sock = socket(PF_UNIX, SOCK_STREAM, 0);
19300cbfa66cSDaniel Fojt 	if (sock == -1) {
193136e94dc5SPeter Avalos 		saved_errno = errno;
193250a69bb5SSascha Wildner 		error_f("socket: %.100s", strerror(errno));
193336e94dc5SPeter Avalos 		errno = saved_errno;
193436e94dc5SPeter Avalos 		return -1;
193536e94dc5SPeter Avalos 	}
193636e94dc5SPeter Avalos 	if (unlink_first == 1) {
193736e94dc5SPeter Avalos 		if (unlink(path) != 0 && errno != ENOENT)
193836e94dc5SPeter Avalos 			error("unlink(%s): %.100s", path, strerror(errno));
193936e94dc5SPeter Avalos 	}
19400cbfa66cSDaniel Fojt 	if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
194136e94dc5SPeter Avalos 		saved_errno = errno;
194250a69bb5SSascha Wildner 		error_f("cannot bind to path %s: %s", path, strerror(errno));
194336e94dc5SPeter Avalos 		close(sock);
194436e94dc5SPeter Avalos 		errno = saved_errno;
194536e94dc5SPeter Avalos 		return -1;
194636e94dc5SPeter Avalos 	}
19470cbfa66cSDaniel Fojt 	if (listen(sock, backlog) == -1) {
194836e94dc5SPeter Avalos 		saved_errno = errno;
194950a69bb5SSascha Wildner 		error_f("cannot listen on path %s: %s", path, strerror(errno));
195036e94dc5SPeter Avalos 		close(sock);
195136e94dc5SPeter Avalos 		unlink(path);
195236e94dc5SPeter Avalos 		errno = saved_errno;
195336e94dc5SPeter Avalos 		return -1;
195436e94dc5SPeter Avalos 	}
195536e94dc5SPeter Avalos 	return sock;
195636e94dc5SPeter Avalos }
195736e94dc5SPeter Avalos 
1958856ea928SPeter Avalos void
sock_set_v6only(int s)1959856ea928SPeter Avalos sock_set_v6only(int s)
1960856ea928SPeter Avalos {
1961e9778795SPeter Avalos #if defined(IPV6_V6ONLY) && !defined(__OpenBSD__)
1962856ea928SPeter Avalos 	int on = 1;
1963856ea928SPeter Avalos 
1964856ea928SPeter Avalos 	debug3("%s: set socket %d IPV6_V6ONLY", __func__, s);
1965856ea928SPeter Avalos 	if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) == -1)
1966856ea928SPeter Avalos 		error("setsockopt IPV6_V6ONLY: %s", strerror(errno));
1967856ea928SPeter Avalos #endif
1968856ea928SPeter Avalos }
1969e9778795SPeter Avalos 
1970e9778795SPeter Avalos /*
1971e9778795SPeter Avalos  * Compares two strings that maybe be NULL. Returns non-zero if strings
1972e9778795SPeter Avalos  * are both NULL or are identical, returns zero otherwise.
1973e9778795SPeter Avalos  */
1974e9778795SPeter Avalos static int
strcmp_maybe_null(const char * a,const char * b)1975e9778795SPeter Avalos strcmp_maybe_null(const char *a, const char *b)
1976e9778795SPeter Avalos {
1977e9778795SPeter Avalos 	if ((a == NULL && b != NULL) || (a != NULL && b == NULL))
1978e9778795SPeter Avalos 		return 0;
1979e9778795SPeter Avalos 	if (a != NULL && strcmp(a, b) != 0)
1980e9778795SPeter Avalos 		return 0;
1981e9778795SPeter Avalos 	return 1;
1982e9778795SPeter Avalos }
1983e9778795SPeter Avalos 
1984e9778795SPeter Avalos /*
1985e9778795SPeter Avalos  * Compare two forwards, returning non-zero if they are identical or
1986e9778795SPeter Avalos  * zero otherwise.
1987e9778795SPeter Avalos  */
1988e9778795SPeter Avalos int
forward_equals(const struct Forward * a,const struct Forward * b)1989e9778795SPeter Avalos forward_equals(const struct Forward *a, const struct Forward *b)
1990e9778795SPeter Avalos {
1991e9778795SPeter Avalos 	if (strcmp_maybe_null(a->listen_host, b->listen_host) == 0)
1992e9778795SPeter Avalos 		return 0;
1993e9778795SPeter Avalos 	if (a->listen_port != b->listen_port)
1994e9778795SPeter Avalos 		return 0;
1995e9778795SPeter Avalos 	if (strcmp_maybe_null(a->listen_path, b->listen_path) == 0)
1996e9778795SPeter Avalos 		return 0;
1997e9778795SPeter Avalos 	if (strcmp_maybe_null(a->connect_host, b->connect_host) == 0)
1998e9778795SPeter Avalos 		return 0;
1999e9778795SPeter Avalos 	if (a->connect_port != b->connect_port)
2000e9778795SPeter Avalos 		return 0;
2001e9778795SPeter Avalos 	if (strcmp_maybe_null(a->connect_path, b->connect_path) == 0)
2002e9778795SPeter Avalos 		return 0;
2003e9778795SPeter Avalos 	/* allocated_port and handle are not checked */
2004e9778795SPeter Avalos 	return 1;
2005e9778795SPeter Avalos }
2006e9778795SPeter Avalos 
2007*ba1276acSMatthew Dillon /* returns port number, FWD_PERMIT_ANY_PORT or -1 on error */
2008*ba1276acSMatthew Dillon int
permitopen_port(const char * p)2009*ba1276acSMatthew Dillon permitopen_port(const char *p)
2010*ba1276acSMatthew Dillon {
2011*ba1276acSMatthew Dillon 	int port;
2012*ba1276acSMatthew Dillon 
2013*ba1276acSMatthew Dillon 	if (strcmp(p, "*") == 0)
2014*ba1276acSMatthew Dillon 		return FWD_PERMIT_ANY_PORT;
2015*ba1276acSMatthew Dillon 	if ((port = a2port(p)) > 0)
2016*ba1276acSMatthew Dillon 		return port;
2017*ba1276acSMatthew Dillon 	return -1;
2018*ba1276acSMatthew Dillon }
2019*ba1276acSMatthew Dillon 
2020ce74bacaSMatthew Dillon /* returns 1 if process is already daemonized, 0 otherwise */
2021ce74bacaSMatthew Dillon int
daemonized(void)2022ce74bacaSMatthew Dillon daemonized(void)
2023ce74bacaSMatthew Dillon {
2024ce74bacaSMatthew Dillon 	int fd;
2025ce74bacaSMatthew Dillon 
2026ce74bacaSMatthew Dillon 	if ((fd = open(_PATH_TTY, O_RDONLY | O_NOCTTY)) >= 0) {
2027ce74bacaSMatthew Dillon 		close(fd);
2028ce74bacaSMatthew Dillon 		return 0;	/* have controlling terminal */
2029ce74bacaSMatthew Dillon 	}
2030ce74bacaSMatthew Dillon 	if (getppid() != 1)
2031ce74bacaSMatthew Dillon 		return 0;	/* parent is not init */
2032ce74bacaSMatthew Dillon 	if (getsid(0) != getpid())
2033ce74bacaSMatthew Dillon 		return 0;	/* not session leader */
2034ce74bacaSMatthew Dillon 	debug3("already daemonized");
2035ce74bacaSMatthew Dillon 	return 1;
2036ce74bacaSMatthew Dillon }
2037ce74bacaSMatthew Dillon 
2038ce74bacaSMatthew Dillon /*
2039ce74bacaSMatthew Dillon  * Splits 's' into an argument vector. Handles quoted string and basic
2040ce74bacaSMatthew Dillon  * escape characters (\\, \", \'). Caller must free the argument vector
2041ce74bacaSMatthew Dillon  * and its members.
2042ce74bacaSMatthew Dillon  */
2043ce74bacaSMatthew Dillon int
argv_split(const char * s,int * argcp,char *** argvp,int terminate_on_comment)204450a69bb5SSascha Wildner argv_split(const char *s, int *argcp, char ***argvp, int terminate_on_comment)
2045ce74bacaSMatthew Dillon {
2046ce74bacaSMatthew Dillon 	int r = SSH_ERR_INTERNAL_ERROR;
2047ce74bacaSMatthew Dillon 	int argc = 0, quote, i, j;
2048ce74bacaSMatthew Dillon 	char *arg, **argv = xcalloc(1, sizeof(*argv));
2049ce74bacaSMatthew Dillon 
2050ce74bacaSMatthew Dillon 	*argvp = NULL;
2051ce74bacaSMatthew Dillon 	*argcp = 0;
2052ce74bacaSMatthew Dillon 
2053ce74bacaSMatthew Dillon 	for (i = 0; s[i] != '\0'; i++) {
2054ce74bacaSMatthew Dillon 		/* Skip leading whitespace */
2055ce74bacaSMatthew Dillon 		if (s[i] == ' ' || s[i] == '\t')
2056ce74bacaSMatthew Dillon 			continue;
205750a69bb5SSascha Wildner 		if (terminate_on_comment && s[i] == '#')
205850a69bb5SSascha Wildner 			break;
2059ce74bacaSMatthew Dillon 		/* Start of a token */
2060ce74bacaSMatthew Dillon 		quote = 0;
2061ce74bacaSMatthew Dillon 
2062ce74bacaSMatthew Dillon 		argv = xreallocarray(argv, (argc + 2), sizeof(*argv));
2063ce74bacaSMatthew Dillon 		arg = argv[argc++] = xcalloc(1, strlen(s + i) + 1);
2064ce74bacaSMatthew Dillon 		argv[argc] = NULL;
2065ce74bacaSMatthew Dillon 
2066ce74bacaSMatthew Dillon 		/* Copy the token in, removing escapes */
2067ce74bacaSMatthew Dillon 		for (j = 0; s[i] != '\0'; i++) {
2068ce74bacaSMatthew Dillon 			if (s[i] == '\\') {
2069ce74bacaSMatthew Dillon 				if (s[i + 1] == '\'' ||
2070ce74bacaSMatthew Dillon 				    s[i + 1] == '\"' ||
207150a69bb5SSascha Wildner 				    s[i + 1] == '\\' ||
207250a69bb5SSascha Wildner 				    (quote == 0 && s[i + 1] == ' ')) {
2073ce74bacaSMatthew Dillon 					i++; /* Skip '\' */
2074ce74bacaSMatthew Dillon 					arg[j++] = s[i];
2075ce74bacaSMatthew Dillon 				} else {
2076ce74bacaSMatthew Dillon 					/* Unrecognised escape */
2077ce74bacaSMatthew Dillon 					arg[j++] = s[i];
2078ce74bacaSMatthew Dillon 				}
2079ce74bacaSMatthew Dillon 			} else if (quote == 0 && (s[i] == ' ' || s[i] == '\t'))
2080ce74bacaSMatthew Dillon 				break; /* done */
208150a69bb5SSascha Wildner 			else if (quote == 0 && (s[i] == '\"' || s[i] == '\''))
208250a69bb5SSascha Wildner 				quote = s[i]; /* quote start */
2083ce74bacaSMatthew Dillon 			else if (quote != 0 && s[i] == quote)
208450a69bb5SSascha Wildner 				quote = 0; /* quote end */
2085ce74bacaSMatthew Dillon 			else
2086ce74bacaSMatthew Dillon 				arg[j++] = s[i];
2087ce74bacaSMatthew Dillon 		}
2088ce74bacaSMatthew Dillon 		if (s[i] == '\0') {
2089ce74bacaSMatthew Dillon 			if (quote != 0) {
2090ce74bacaSMatthew Dillon 				/* Ran out of string looking for close quote */
2091ce74bacaSMatthew Dillon 				r = SSH_ERR_INVALID_FORMAT;
2092ce74bacaSMatthew Dillon 				goto out;
2093ce74bacaSMatthew Dillon 			}
2094ce74bacaSMatthew Dillon 			break;
2095ce74bacaSMatthew Dillon 		}
2096ce74bacaSMatthew Dillon 	}
2097ce74bacaSMatthew Dillon 	/* Success */
2098ce74bacaSMatthew Dillon 	*argcp = argc;
2099ce74bacaSMatthew Dillon 	*argvp = argv;
2100ce74bacaSMatthew Dillon 	argc = 0;
2101ce74bacaSMatthew Dillon 	argv = NULL;
2102ce74bacaSMatthew Dillon 	r = 0;
2103ce74bacaSMatthew Dillon  out:
2104ce74bacaSMatthew Dillon 	if (argc != 0 && argv != NULL) {
2105ce74bacaSMatthew Dillon 		for (i = 0; i < argc; i++)
2106ce74bacaSMatthew Dillon 			free(argv[i]);
2107ce74bacaSMatthew Dillon 		free(argv);
2108ce74bacaSMatthew Dillon 	}
2109ce74bacaSMatthew Dillon 	return r;
2110ce74bacaSMatthew Dillon }
2111ce74bacaSMatthew Dillon 
2112ce74bacaSMatthew Dillon /*
2113ce74bacaSMatthew Dillon  * Reassemble an argument vector into a string, quoting and escaping as
2114ce74bacaSMatthew Dillon  * necessary. Caller must free returned string.
2115ce74bacaSMatthew Dillon  */
2116ce74bacaSMatthew Dillon char *
argv_assemble(int argc,char ** argv)2117ce74bacaSMatthew Dillon argv_assemble(int argc, char **argv)
2118ce74bacaSMatthew Dillon {
2119ce74bacaSMatthew Dillon 	int i, j, ws, r;
2120ce74bacaSMatthew Dillon 	char c, *ret;
2121ce74bacaSMatthew Dillon 	struct sshbuf *buf, *arg;
2122ce74bacaSMatthew Dillon 
2123ce74bacaSMatthew Dillon 	if ((buf = sshbuf_new()) == NULL || (arg = sshbuf_new()) == NULL)
212450a69bb5SSascha Wildner 		fatal_f("sshbuf_new failed");
2125ce74bacaSMatthew Dillon 
2126ce74bacaSMatthew Dillon 	for (i = 0; i < argc; i++) {
2127ce74bacaSMatthew Dillon 		ws = 0;
2128ce74bacaSMatthew Dillon 		sshbuf_reset(arg);
2129ce74bacaSMatthew Dillon 		for (j = 0; argv[i][j] != '\0'; j++) {
2130ce74bacaSMatthew Dillon 			r = 0;
2131ce74bacaSMatthew Dillon 			c = argv[i][j];
2132ce74bacaSMatthew Dillon 			switch (c) {
2133ce74bacaSMatthew Dillon 			case ' ':
2134ce74bacaSMatthew Dillon 			case '\t':
2135ce74bacaSMatthew Dillon 				ws = 1;
2136ce74bacaSMatthew Dillon 				r = sshbuf_put_u8(arg, c);
2137ce74bacaSMatthew Dillon 				break;
2138ce74bacaSMatthew Dillon 			case '\\':
2139ce74bacaSMatthew Dillon 			case '\'':
2140ce74bacaSMatthew Dillon 			case '"':
2141ce74bacaSMatthew Dillon 				if ((r = sshbuf_put_u8(arg, '\\')) != 0)
2142ce74bacaSMatthew Dillon 					break;
2143ce74bacaSMatthew Dillon 				/* FALLTHROUGH */
2144ce74bacaSMatthew Dillon 			default:
2145ce74bacaSMatthew Dillon 				r = sshbuf_put_u8(arg, c);
2146ce74bacaSMatthew Dillon 				break;
2147ce74bacaSMatthew Dillon 			}
2148ce74bacaSMatthew Dillon 			if (r != 0)
214950a69bb5SSascha Wildner 				fatal_fr(r, "sshbuf_put_u8");
2150ce74bacaSMatthew Dillon 		}
2151ce74bacaSMatthew Dillon 		if ((i != 0 && (r = sshbuf_put_u8(buf, ' ')) != 0) ||
2152ce74bacaSMatthew Dillon 		    (ws != 0 && (r = sshbuf_put_u8(buf, '"')) != 0) ||
2153ce74bacaSMatthew Dillon 		    (r = sshbuf_putb(buf, arg)) != 0 ||
2154ce74bacaSMatthew Dillon 		    (ws != 0 && (r = sshbuf_put_u8(buf, '"')) != 0))
215550a69bb5SSascha Wildner 			fatal_fr(r, "assemble");
2156ce74bacaSMatthew Dillon 	}
2157ce74bacaSMatthew Dillon 	if ((ret = malloc(sshbuf_len(buf) + 1)) == NULL)
215850a69bb5SSascha Wildner 		fatal_f("malloc failed");
2159ce74bacaSMatthew Dillon 	memcpy(ret, sshbuf_ptr(buf), sshbuf_len(buf));
2160ce74bacaSMatthew Dillon 	ret[sshbuf_len(buf)] = '\0';
2161ce74bacaSMatthew Dillon 	sshbuf_free(buf);
2162ce74bacaSMatthew Dillon 	sshbuf_free(arg);
2163ce74bacaSMatthew Dillon 	return ret;
2164ce74bacaSMatthew Dillon }
2165ce74bacaSMatthew Dillon 
216650a69bb5SSascha Wildner char *
argv_next(int * argcp,char *** argvp)216750a69bb5SSascha Wildner argv_next(int *argcp, char ***argvp)
216850a69bb5SSascha Wildner {
216950a69bb5SSascha Wildner 	char *ret = (*argvp)[0];
217050a69bb5SSascha Wildner 
217150a69bb5SSascha Wildner 	if (*argcp > 0 && ret != NULL) {
217250a69bb5SSascha Wildner 		(*argcp)--;
217350a69bb5SSascha Wildner 		(*argvp)++;
217450a69bb5SSascha Wildner 	}
217550a69bb5SSascha Wildner 	return ret;
217650a69bb5SSascha Wildner }
217750a69bb5SSascha Wildner 
217850a69bb5SSascha Wildner void
argv_consume(int * argcp)217950a69bb5SSascha Wildner argv_consume(int *argcp)
218050a69bb5SSascha Wildner {
218150a69bb5SSascha Wildner 	*argcp = 0;
218250a69bb5SSascha Wildner }
218350a69bb5SSascha Wildner 
218450a69bb5SSascha Wildner void
argv_free(char ** av,int ac)218550a69bb5SSascha Wildner argv_free(char **av, int ac)
218650a69bb5SSascha Wildner {
218750a69bb5SSascha Wildner 	int i;
218850a69bb5SSascha Wildner 
218950a69bb5SSascha Wildner 	if (av == NULL)
219050a69bb5SSascha Wildner 		return;
219150a69bb5SSascha Wildner 	for (i = 0; i < ac; i++)
219250a69bb5SSascha Wildner 		free(av[i]);
219350a69bb5SSascha Wildner 	free(av);
219450a69bb5SSascha Wildner }
219550a69bb5SSascha Wildner 
2196ce74bacaSMatthew Dillon /* Returns 0 if pid exited cleanly, non-zero otherwise */
2197ce74bacaSMatthew Dillon int
exited_cleanly(pid_t pid,const char * tag,const char * cmd,int quiet)2198ce74bacaSMatthew Dillon exited_cleanly(pid_t pid, const char *tag, const char *cmd, int quiet)
2199ce74bacaSMatthew Dillon {
2200ce74bacaSMatthew Dillon 	int status;
2201ce74bacaSMatthew Dillon 
2202ce74bacaSMatthew Dillon 	while (waitpid(pid, &status, 0) == -1) {
2203ce74bacaSMatthew Dillon 		if (errno != EINTR) {
220450a69bb5SSascha Wildner 			error("%s waitpid: %s", tag, strerror(errno));
2205ce74bacaSMatthew Dillon 			return -1;
2206ce74bacaSMatthew Dillon 		}
2207ce74bacaSMatthew Dillon 	}
2208ce74bacaSMatthew Dillon 	if (WIFSIGNALED(status)) {
2209ce74bacaSMatthew Dillon 		error("%s %s exited on signal %d", tag, cmd, WTERMSIG(status));
2210ce74bacaSMatthew Dillon 		return -1;
2211ce74bacaSMatthew Dillon 	} else if (WEXITSTATUS(status) != 0) {
2212ce74bacaSMatthew Dillon 		do_log2(quiet ? SYSLOG_LEVEL_DEBUG1 : SYSLOG_LEVEL_INFO,
2213ce74bacaSMatthew Dillon 		    "%s %s failed, status %d", tag, cmd, WEXITSTATUS(status));
2214ce74bacaSMatthew Dillon 		return -1;
2215ce74bacaSMatthew Dillon 	}
2216ce74bacaSMatthew Dillon 	return 0;
2217ce74bacaSMatthew Dillon }
2218ce74bacaSMatthew Dillon 
2219ce74bacaSMatthew Dillon /*
2220ce74bacaSMatthew Dillon  * Check a given path for security. This is defined as all components
2221ce74bacaSMatthew Dillon  * of the path to the file must be owned by either the owner of
2222ce74bacaSMatthew Dillon  * of the file or root and no directories must be group or world writable.
2223ce74bacaSMatthew Dillon  *
2224ce74bacaSMatthew Dillon  * XXX Should any specific check be done for sym links ?
2225ce74bacaSMatthew Dillon  *
2226ce74bacaSMatthew Dillon  * Takes a file name, its stat information (preferably from fstat() to
2227ce74bacaSMatthew Dillon  * avoid races), the uid of the expected owner, their home directory and an
2228ce74bacaSMatthew Dillon  * error buffer plus max size as arguments.
2229ce74bacaSMatthew Dillon  *
2230ce74bacaSMatthew Dillon  * Returns 0 on success and -1 on failure
2231ce74bacaSMatthew Dillon  */
2232ce74bacaSMatthew Dillon int
safe_path(const char * name,struct stat * stp,const char * pw_dir,uid_t uid,char * err,size_t errlen)2233ce74bacaSMatthew Dillon safe_path(const char *name, struct stat *stp, const char *pw_dir,
2234ce74bacaSMatthew Dillon     uid_t uid, char *err, size_t errlen)
2235ce74bacaSMatthew Dillon {
2236ce74bacaSMatthew Dillon 	char buf[PATH_MAX], homedir[PATH_MAX];
2237ce74bacaSMatthew Dillon 	char *cp;
2238ce74bacaSMatthew Dillon 	int comparehome = 0;
2239ce74bacaSMatthew Dillon 	struct stat st;
2240ce74bacaSMatthew Dillon 
2241ce74bacaSMatthew Dillon 	if (realpath(name, buf) == NULL) {
2242ce74bacaSMatthew Dillon 		snprintf(err, errlen, "realpath %s failed: %s", name,
2243ce74bacaSMatthew Dillon 		    strerror(errno));
2244ce74bacaSMatthew Dillon 		return -1;
2245ce74bacaSMatthew Dillon 	}
2246ce74bacaSMatthew Dillon 	if (pw_dir != NULL && realpath(pw_dir, homedir) != NULL)
2247ce74bacaSMatthew Dillon 		comparehome = 1;
2248ce74bacaSMatthew Dillon 
2249ce74bacaSMatthew Dillon 	if (!S_ISREG(stp->st_mode)) {
2250ce74bacaSMatthew Dillon 		snprintf(err, errlen, "%s is not a regular file", buf);
2251ce74bacaSMatthew Dillon 		return -1;
2252ce74bacaSMatthew Dillon 	}
2253ce74bacaSMatthew Dillon 	if ((!platform_sys_dir_uid(stp->st_uid) && stp->st_uid != uid) ||
2254ce74bacaSMatthew Dillon 	    (stp->st_mode & 022) != 0) {
2255ce74bacaSMatthew Dillon 		snprintf(err, errlen, "bad ownership or modes for file %s",
2256ce74bacaSMatthew Dillon 		    buf);
2257ce74bacaSMatthew Dillon 		return -1;
2258ce74bacaSMatthew Dillon 	}
2259ce74bacaSMatthew Dillon 
2260ce74bacaSMatthew Dillon 	/* for each component of the canonical path, walking upwards */
2261ce74bacaSMatthew Dillon 	for (;;) {
2262ce74bacaSMatthew Dillon 		if ((cp = dirname(buf)) == NULL) {
2263ce74bacaSMatthew Dillon 			snprintf(err, errlen, "dirname() failed");
2264ce74bacaSMatthew Dillon 			return -1;
2265ce74bacaSMatthew Dillon 		}
2266ce74bacaSMatthew Dillon 		strlcpy(buf, cp, sizeof(buf));
2267ce74bacaSMatthew Dillon 
22680cbfa66cSDaniel Fojt 		if (stat(buf, &st) == -1 ||
2269ce74bacaSMatthew Dillon 		    (!platform_sys_dir_uid(st.st_uid) && st.st_uid != uid) ||
2270ce74bacaSMatthew Dillon 		    (st.st_mode & 022) != 0) {
2271ce74bacaSMatthew Dillon 			snprintf(err, errlen,
2272ce74bacaSMatthew Dillon 			    "bad ownership or modes for directory %s", buf);
2273ce74bacaSMatthew Dillon 			return -1;
2274ce74bacaSMatthew Dillon 		}
2275ce74bacaSMatthew Dillon 
2276ce74bacaSMatthew Dillon 		/* If are past the homedir then we can stop */
2277ce74bacaSMatthew Dillon 		if (comparehome && strcmp(homedir, buf) == 0)
2278ce74bacaSMatthew Dillon 			break;
2279ce74bacaSMatthew Dillon 
2280ce74bacaSMatthew Dillon 		/*
2281ce74bacaSMatthew Dillon 		 * dirname should always complete with a "/" path,
2282ce74bacaSMatthew Dillon 		 * but we can be paranoid and check for "." too
2283ce74bacaSMatthew Dillon 		 */
2284ce74bacaSMatthew Dillon 		if ((strcmp("/", buf) == 0) || (strcmp(".", buf) == 0))
2285ce74bacaSMatthew Dillon 			break;
2286ce74bacaSMatthew Dillon 	}
2287ce74bacaSMatthew Dillon 	return 0;
2288ce74bacaSMatthew Dillon }
2289ce74bacaSMatthew Dillon 
2290ce74bacaSMatthew Dillon /*
2291ce74bacaSMatthew Dillon  * Version of safe_path() that accepts an open file descriptor to
2292ce74bacaSMatthew Dillon  * avoid races.
2293ce74bacaSMatthew Dillon  *
2294ce74bacaSMatthew Dillon  * Returns 0 on success and -1 on failure
2295ce74bacaSMatthew Dillon  */
2296ce74bacaSMatthew Dillon int
safe_path_fd(int fd,const char * file,struct passwd * pw,char * err,size_t errlen)2297ce74bacaSMatthew Dillon safe_path_fd(int fd, const char *file, struct passwd *pw,
2298ce74bacaSMatthew Dillon     char *err, size_t errlen)
2299ce74bacaSMatthew Dillon {
2300ce74bacaSMatthew Dillon 	struct stat st;
2301ce74bacaSMatthew Dillon 
2302ce74bacaSMatthew Dillon 	/* check the open file to avoid races */
23030cbfa66cSDaniel Fojt 	if (fstat(fd, &st) == -1) {
2304ce74bacaSMatthew Dillon 		snprintf(err, errlen, "cannot stat file %s: %s",
2305ce74bacaSMatthew Dillon 		    file, strerror(errno));
2306ce74bacaSMatthew Dillon 		return -1;
2307ce74bacaSMatthew Dillon 	}
2308ce74bacaSMatthew Dillon 	return safe_path(file, &st, pw->pw_dir, pw->pw_uid, err, errlen);
2309ce74bacaSMatthew Dillon }
2310ce74bacaSMatthew Dillon 
2311ce74bacaSMatthew Dillon /*
2312ce74bacaSMatthew Dillon  * Sets the value of the given variable in the environment.  If the variable
2313ce74bacaSMatthew Dillon  * already exists, its value is overridden.
2314ce74bacaSMatthew Dillon  */
2315ce74bacaSMatthew Dillon void
child_set_env(char *** envp,u_int * envsizep,const char * name,const char * value)2316ce74bacaSMatthew Dillon child_set_env(char ***envp, u_int *envsizep, const char *name,
2317ce74bacaSMatthew Dillon 	const char *value)
2318ce74bacaSMatthew Dillon {
2319ce74bacaSMatthew Dillon 	char **env;
2320ce74bacaSMatthew Dillon 	u_int envsize;
2321ce74bacaSMatthew Dillon 	u_int i, namelen;
2322ce74bacaSMatthew Dillon 
2323ce74bacaSMatthew Dillon 	if (strchr(name, '=') != NULL) {
2324ce74bacaSMatthew Dillon 		error("Invalid environment variable \"%.100s\"", name);
2325ce74bacaSMatthew Dillon 		return;
2326ce74bacaSMatthew Dillon 	}
2327ce74bacaSMatthew Dillon 
2328ce74bacaSMatthew Dillon 	/*
2329ce74bacaSMatthew Dillon 	 * If we're passed an uninitialized list, allocate a single null
2330ce74bacaSMatthew Dillon 	 * entry before continuing.
2331ce74bacaSMatthew Dillon 	 */
2332*ba1276acSMatthew Dillon 	if ((*envp == NULL) != (*envsizep == 0))
2333*ba1276acSMatthew Dillon 		fatal_f("environment size mismatch");
2334ce74bacaSMatthew Dillon 	if (*envp == NULL && *envsizep == 0) {
2335ce74bacaSMatthew Dillon 		*envp = xmalloc(sizeof(char *));
2336ce74bacaSMatthew Dillon 		*envp[0] = NULL;
2337ce74bacaSMatthew Dillon 		*envsizep = 1;
2338ce74bacaSMatthew Dillon 	}
2339ce74bacaSMatthew Dillon 
2340ce74bacaSMatthew Dillon 	/*
2341ce74bacaSMatthew Dillon 	 * Find the slot where the value should be stored.  If the variable
2342ce74bacaSMatthew Dillon 	 * already exists, we reuse the slot; otherwise we append a new slot
2343ce74bacaSMatthew Dillon 	 * at the end of the array, expanding if necessary.
2344ce74bacaSMatthew Dillon 	 */
2345ce74bacaSMatthew Dillon 	env = *envp;
2346ce74bacaSMatthew Dillon 	namelen = strlen(name);
2347ce74bacaSMatthew Dillon 	for (i = 0; env[i]; i++)
2348ce74bacaSMatthew Dillon 		if (strncmp(env[i], name, namelen) == 0 && env[i][namelen] == '=')
2349ce74bacaSMatthew Dillon 			break;
2350ce74bacaSMatthew Dillon 	if (env[i]) {
2351ce74bacaSMatthew Dillon 		/* Reuse the slot. */
2352ce74bacaSMatthew Dillon 		free(env[i]);
2353ce74bacaSMatthew Dillon 	} else {
2354ce74bacaSMatthew Dillon 		/* New variable.  Expand if necessary. */
2355ce74bacaSMatthew Dillon 		envsize = *envsizep;
2356ce74bacaSMatthew Dillon 		if (i >= envsize - 1) {
2357ce74bacaSMatthew Dillon 			if (envsize >= 1000)
2358ce74bacaSMatthew Dillon 				fatal("child_set_env: too many env vars");
2359ce74bacaSMatthew Dillon 			envsize += 50;
2360ce74bacaSMatthew Dillon 			env = (*envp) = xreallocarray(env, envsize, sizeof(char *));
2361ce74bacaSMatthew Dillon 			*envsizep = envsize;
2362ce74bacaSMatthew Dillon 		}
2363ce74bacaSMatthew Dillon 		/* Need to set the NULL pointer at end of array beyond the new slot. */
2364ce74bacaSMatthew Dillon 		env[i + 1] = NULL;
2365ce74bacaSMatthew Dillon 	}
2366ce74bacaSMatthew Dillon 
2367ce74bacaSMatthew Dillon 	/* Allocate space and format the variable in the appropriate slot. */
2368664f4763Szrj 	/* XXX xasprintf */
2369ce74bacaSMatthew Dillon 	env[i] = xmalloc(strlen(name) + 1 + strlen(value) + 1);
2370ce74bacaSMatthew Dillon 	snprintf(env[i], strlen(name) + 1 + strlen(value) + 1, "%s=%s", name, value);
2371ce74bacaSMatthew Dillon }
2372ce74bacaSMatthew Dillon 
2373664f4763Szrj /*
2374664f4763Szrj  * Check and optionally lowercase a domain name, also removes trailing '.'
2375664f4763Szrj  * Returns 1 on success and 0 on failure, storing an error message in errstr.
2376664f4763Szrj  */
2377664f4763Szrj int
valid_domain(char * name,int makelower,const char ** errstr)2378664f4763Szrj valid_domain(char *name, int makelower, const char **errstr)
2379664f4763Szrj {
2380664f4763Szrj 	size_t i, l = strlen(name);
2381664f4763Szrj 	u_char c, last = '\0';
2382664f4763Szrj 	static char errbuf[256];
2383664f4763Szrj 
2384664f4763Szrj 	if (l == 0) {
2385664f4763Szrj 		strlcpy(errbuf, "empty domain name", sizeof(errbuf));
2386664f4763Szrj 		goto bad;
2387664f4763Szrj 	}
2388664f4763Szrj 	if (!isalpha((u_char)name[0]) && !isdigit((u_char)name[0])) {
2389664f4763Szrj 		snprintf(errbuf, sizeof(errbuf), "domain name \"%.100s\" "
2390664f4763Szrj 		    "starts with invalid character", name);
2391664f4763Szrj 		goto bad;
2392664f4763Szrj 	}
2393664f4763Szrj 	for (i = 0; i < l; i++) {
2394664f4763Szrj 		c = tolower((u_char)name[i]);
2395664f4763Szrj 		if (makelower)
2396664f4763Szrj 			name[i] = (char)c;
2397664f4763Szrj 		if (last == '.' && c == '.') {
2398664f4763Szrj 			snprintf(errbuf, sizeof(errbuf), "domain name "
2399664f4763Szrj 			    "\"%.100s\" contains consecutive separators", name);
2400664f4763Szrj 			goto bad;
2401664f4763Szrj 		}
2402664f4763Szrj 		if (c != '.' && c != '-' && !isalnum(c) &&
2403664f4763Szrj 		    c != '_') /* technically invalid, but common */ {
2404664f4763Szrj 			snprintf(errbuf, sizeof(errbuf), "domain name "
2405664f4763Szrj 			    "\"%.100s\" contains invalid characters", name);
2406664f4763Szrj 			goto bad;
2407664f4763Szrj 		}
2408664f4763Szrj 		last = c;
2409664f4763Szrj 	}
2410664f4763Szrj 	if (name[l - 1] == '.')
2411664f4763Szrj 		name[l - 1] = '\0';
2412664f4763Szrj 	if (errstr != NULL)
2413664f4763Szrj 		*errstr = NULL;
2414664f4763Szrj 	return 1;
2415664f4763Szrj bad:
2416664f4763Szrj 	if (errstr != NULL)
2417664f4763Szrj 		*errstr = errbuf;
2418664f4763Szrj 	return 0;
2419664f4763Szrj }
2420664f4763Szrj 
2421664f4763Szrj /*
2422664f4763Szrj  * Verify that a environment variable name (not including initial '$') is
2423664f4763Szrj  * valid; consisting of one or more alphanumeric or underscore characters only.
2424664f4763Szrj  * Returns 1 on valid, 0 otherwise.
2425664f4763Szrj  */
2426664f4763Szrj int
valid_env_name(const char * name)2427664f4763Szrj valid_env_name(const char *name)
2428664f4763Szrj {
2429664f4763Szrj 	const char *cp;
2430664f4763Szrj 
2431664f4763Szrj 	if (name[0] == '\0')
2432664f4763Szrj 		return 0;
2433664f4763Szrj 	for (cp = name; *cp != '\0'; cp++) {
2434664f4763Szrj 		if (!isalnum((u_char)*cp) && *cp != '_')
2435664f4763Szrj 			return 0;
2436664f4763Szrj 	}
2437664f4763Szrj 	return 1;
2438664f4763Szrj }
2439664f4763Szrj 
2440664f4763Szrj const char *
atoi_err(const char * nptr,int * val)2441664f4763Szrj atoi_err(const char *nptr, int *val)
2442664f4763Szrj {
2443664f4763Szrj 	const char *errstr = NULL;
2444664f4763Szrj 
2445664f4763Szrj 	if (nptr == NULL || *nptr == '\0')
2446664f4763Szrj 		return "missing";
2447*ba1276acSMatthew Dillon 	*val = strtonum(nptr, 0, INT_MAX, &errstr);
2448664f4763Szrj 	return errstr;
2449664f4763Szrj }
2450664f4763Szrj 
2451664f4763Szrj int
parse_absolute_time(const char * s,uint64_t * tp)2452664f4763Szrj parse_absolute_time(const char *s, uint64_t *tp)
2453664f4763Szrj {
2454664f4763Szrj 	struct tm tm;
2455664f4763Szrj 	time_t tt;
2456664f4763Szrj 	char buf[32], *fmt;
2457ee116499SAntonio Huete Jimenez 	const char *cp;
2458ee116499SAntonio Huete Jimenez 	size_t l;
2459ee116499SAntonio Huete Jimenez 	int is_utc = 0;
2460664f4763Szrj 
2461664f4763Szrj 	*tp = 0;
2462664f4763Szrj 
2463ee116499SAntonio Huete Jimenez 	l = strlen(s);
2464ee116499SAntonio Huete Jimenez 	if (l > 1 && strcasecmp(s + l - 1, "Z") == 0) {
2465ee116499SAntonio Huete Jimenez 		is_utc = 1;
2466ee116499SAntonio Huete Jimenez 		l--;
2467ee116499SAntonio Huete Jimenez 	} else if (l > 3 && strcasecmp(s + l - 3, "UTC") == 0) {
2468ee116499SAntonio Huete Jimenez 		is_utc = 1;
2469ee116499SAntonio Huete Jimenez 		l -= 3;
2470ee116499SAntonio Huete Jimenez 	}
2471664f4763Szrj 	/*
2472664f4763Szrj 	 * POSIX strptime says "The application shall ensure that there
2473664f4763Szrj 	 * is white-space or other non-alphanumeric characters between
2474664f4763Szrj 	 * any two conversion specifications" so arrange things this way.
2475664f4763Szrj 	 */
2476ee116499SAntonio Huete Jimenez 	switch (l) {
2477664f4763Szrj 	case 8: /* YYYYMMDD */
2478664f4763Szrj 		fmt = "%Y-%m-%d";
2479664f4763Szrj 		snprintf(buf, sizeof(buf), "%.4s-%.2s-%.2s", s, s + 4, s + 6);
2480664f4763Szrj 		break;
2481664f4763Szrj 	case 12: /* YYYYMMDDHHMM */
2482664f4763Szrj 		fmt = "%Y-%m-%dT%H:%M";
2483664f4763Szrj 		snprintf(buf, sizeof(buf), "%.4s-%.2s-%.2sT%.2s:%.2s",
2484664f4763Szrj 		    s, s + 4, s + 6, s + 8, s + 10);
2485664f4763Szrj 		break;
2486664f4763Szrj 	case 14: /* YYYYMMDDHHMMSS */
2487664f4763Szrj 		fmt = "%Y-%m-%dT%H:%M:%S";
2488664f4763Szrj 		snprintf(buf, sizeof(buf), "%.4s-%.2s-%.2sT%.2s:%.2s:%.2s",
2489664f4763Szrj 		    s, s + 4, s + 6, s + 8, s + 10, s + 12);
2490664f4763Szrj 		break;
2491664f4763Szrj 	default:
2492664f4763Szrj 		return SSH_ERR_INVALID_FORMAT;
2493664f4763Szrj 	}
2494664f4763Szrj 
2495664f4763Szrj 	memset(&tm, 0, sizeof(tm));
2496ee116499SAntonio Huete Jimenez 	if ((cp = strptime(buf, fmt, &tm)) == NULL || *cp != '\0')
2497664f4763Szrj 		return SSH_ERR_INVALID_FORMAT;
2498ee116499SAntonio Huete Jimenez 	if (is_utc) {
2499ee116499SAntonio Huete Jimenez 		if ((tt = timegm(&tm)) < 0)
2500ee116499SAntonio Huete Jimenez 			return SSH_ERR_INVALID_FORMAT;
2501ee116499SAntonio Huete Jimenez 	} else {
2502664f4763Szrj 		if ((tt = mktime(&tm)) < 0)
2503664f4763Szrj 			return SSH_ERR_INVALID_FORMAT;
2504ee116499SAntonio Huete Jimenez 	}
2505664f4763Szrj 	/* success */
2506664f4763Szrj 	*tp = (uint64_t)tt;
2507664f4763Szrj 	return 0;
2508664f4763Szrj }
2509664f4763Szrj 
2510664f4763Szrj void
format_absolute_time(uint64_t t,char * buf,size_t len)2511664f4763Szrj format_absolute_time(uint64_t t, char *buf, size_t len)
2512664f4763Szrj {
251350a69bb5SSascha Wildner 	time_t tt = t > SSH_TIME_T_MAX ? SSH_TIME_T_MAX : t;
2514664f4763Szrj 	struct tm tm;
2515664f4763Szrj 
2516664f4763Szrj 	localtime_r(&tt, &tm);
2517664f4763Szrj 	strftime(buf, len, "%Y-%m-%dT%H:%M:%S", &tm);
2518664f4763Szrj }
2519664f4763Szrj 
2520*ba1276acSMatthew Dillon /*
2521*ba1276acSMatthew Dillon  * Parse a "pattern=interval" clause (e.g. a ChannelTimeout).
2522*ba1276acSMatthew Dillon  * Returns 0 on success or non-zero on failure.
2523*ba1276acSMatthew Dillon  * Caller must free *typep.
2524*ba1276acSMatthew Dillon  */
2525*ba1276acSMatthew Dillon int
parse_pattern_interval(const char * s,char ** typep,int * secsp)2526*ba1276acSMatthew Dillon parse_pattern_interval(const char *s, char **typep, int *secsp)
2527*ba1276acSMatthew Dillon {
2528*ba1276acSMatthew Dillon 	char *cp, *sdup;
2529*ba1276acSMatthew Dillon 	int secs;
2530*ba1276acSMatthew Dillon 
2531*ba1276acSMatthew Dillon 	if (typep != NULL)
2532*ba1276acSMatthew Dillon 		*typep = NULL;
2533*ba1276acSMatthew Dillon 	if (secsp != NULL)
2534*ba1276acSMatthew Dillon 		*secsp = 0;
2535*ba1276acSMatthew Dillon 	if (s == NULL)
2536*ba1276acSMatthew Dillon 		return -1;
2537*ba1276acSMatthew Dillon 	sdup = xstrdup(s);
2538*ba1276acSMatthew Dillon 
2539*ba1276acSMatthew Dillon 	if ((cp = strchr(sdup, '=')) == NULL || cp == sdup) {
2540*ba1276acSMatthew Dillon 		free(sdup);
2541*ba1276acSMatthew Dillon 		return -1;
2542*ba1276acSMatthew Dillon 	}
2543*ba1276acSMatthew Dillon 	*cp++ = '\0';
2544*ba1276acSMatthew Dillon 	if ((secs = convtime(cp)) < 0) {
2545*ba1276acSMatthew Dillon 		free(sdup);
2546*ba1276acSMatthew Dillon 		return -1;
2547*ba1276acSMatthew Dillon 	}
2548*ba1276acSMatthew Dillon 	/* success */
2549*ba1276acSMatthew Dillon 	if (typep != NULL)
2550*ba1276acSMatthew Dillon 		*typep = xstrdup(sdup);
2551*ba1276acSMatthew Dillon 	if (secsp != NULL)
2552*ba1276acSMatthew Dillon 		*secsp = secs;
2553*ba1276acSMatthew Dillon 	free(sdup);
2554*ba1276acSMatthew Dillon 	return 0;
2555*ba1276acSMatthew Dillon }
2556*ba1276acSMatthew Dillon 
2557664f4763Szrj /* check if path is absolute */
2558664f4763Szrj int
path_absolute(const char * path)2559664f4763Szrj path_absolute(const char *path)
2560664f4763Szrj {
2561664f4763Szrj 	return (*path == '/') ? 1 : 0;
2562664f4763Szrj }
25630cbfa66cSDaniel Fojt 
25640cbfa66cSDaniel Fojt void
skip_space(char ** cpp)25650cbfa66cSDaniel Fojt skip_space(char **cpp)
25660cbfa66cSDaniel Fojt {
25670cbfa66cSDaniel Fojt 	char *cp;
25680cbfa66cSDaniel Fojt 
25690cbfa66cSDaniel Fojt 	for (cp = *cpp; *cp == ' ' || *cp == '\t'; cp++)
25700cbfa66cSDaniel Fojt 		;
25710cbfa66cSDaniel Fojt 	*cpp = cp;
25720cbfa66cSDaniel Fojt }
25730cbfa66cSDaniel Fojt 
25740cbfa66cSDaniel Fojt /* authorized_key-style options parsing helpers */
25750cbfa66cSDaniel Fojt 
25760cbfa66cSDaniel Fojt /*
25770cbfa66cSDaniel Fojt  * Match flag 'opt' in *optsp, and if allow_negate is set then also match
25780cbfa66cSDaniel Fojt  * 'no-opt'. Returns -1 if option not matched, 1 if option matches or 0
25790cbfa66cSDaniel Fojt  * if negated option matches.
25800cbfa66cSDaniel Fojt  * If the option or negated option matches, then *optsp is updated to
25810cbfa66cSDaniel Fojt  * point to the first character after the option.
25820cbfa66cSDaniel Fojt  */
25830cbfa66cSDaniel Fojt int
opt_flag(const char * opt,int allow_negate,const char ** optsp)25840cbfa66cSDaniel Fojt opt_flag(const char *opt, int allow_negate, const char **optsp)
25850cbfa66cSDaniel Fojt {
25860cbfa66cSDaniel Fojt 	size_t opt_len = strlen(opt);
25870cbfa66cSDaniel Fojt 	const char *opts = *optsp;
25880cbfa66cSDaniel Fojt 	int negate = 0;
25890cbfa66cSDaniel Fojt 
25900cbfa66cSDaniel Fojt 	if (allow_negate && strncasecmp(opts, "no-", 3) == 0) {
25910cbfa66cSDaniel Fojt 		opts += 3;
25920cbfa66cSDaniel Fojt 		negate = 1;
25930cbfa66cSDaniel Fojt 	}
25940cbfa66cSDaniel Fojt 	if (strncasecmp(opts, opt, opt_len) == 0) {
25950cbfa66cSDaniel Fojt 		*optsp = opts + opt_len;
25960cbfa66cSDaniel Fojt 		return negate ? 0 : 1;
25970cbfa66cSDaniel Fojt 	}
25980cbfa66cSDaniel Fojt 	return -1;
25990cbfa66cSDaniel Fojt }
26000cbfa66cSDaniel Fojt 
26010cbfa66cSDaniel Fojt char *
opt_dequote(const char ** sp,const char ** errstrp)26020cbfa66cSDaniel Fojt opt_dequote(const char **sp, const char **errstrp)
26030cbfa66cSDaniel Fojt {
26040cbfa66cSDaniel Fojt 	const char *s = *sp;
26050cbfa66cSDaniel Fojt 	char *ret;
26060cbfa66cSDaniel Fojt 	size_t i;
26070cbfa66cSDaniel Fojt 
26080cbfa66cSDaniel Fojt 	*errstrp = NULL;
26090cbfa66cSDaniel Fojt 	if (*s != '"') {
26100cbfa66cSDaniel Fojt 		*errstrp = "missing start quote";
26110cbfa66cSDaniel Fojt 		return NULL;
26120cbfa66cSDaniel Fojt 	}
26130cbfa66cSDaniel Fojt 	s++;
26140cbfa66cSDaniel Fojt 	if ((ret = malloc(strlen((s)) + 1)) == NULL) {
26150cbfa66cSDaniel Fojt 		*errstrp = "memory allocation failed";
26160cbfa66cSDaniel Fojt 		return NULL;
26170cbfa66cSDaniel Fojt 	}
26180cbfa66cSDaniel Fojt 	for (i = 0; *s != '\0' && *s != '"';) {
26190cbfa66cSDaniel Fojt 		if (s[0] == '\\' && s[1] == '"')
26200cbfa66cSDaniel Fojt 			s++;
26210cbfa66cSDaniel Fojt 		ret[i++] = *s++;
26220cbfa66cSDaniel Fojt 	}
26230cbfa66cSDaniel Fojt 	if (*s == '\0') {
26240cbfa66cSDaniel Fojt 		*errstrp = "missing end quote";
26250cbfa66cSDaniel Fojt 		free(ret);
26260cbfa66cSDaniel Fojt 		return NULL;
26270cbfa66cSDaniel Fojt 	}
26280cbfa66cSDaniel Fojt 	ret[i] = '\0';
26290cbfa66cSDaniel Fojt 	s++;
26300cbfa66cSDaniel Fojt 	*sp = s;
26310cbfa66cSDaniel Fojt 	return ret;
26320cbfa66cSDaniel Fojt }
26330cbfa66cSDaniel Fojt 
26340cbfa66cSDaniel Fojt int
opt_match(const char ** opts,const char * term)26350cbfa66cSDaniel Fojt opt_match(const char **opts, const char *term)
26360cbfa66cSDaniel Fojt {
26370cbfa66cSDaniel Fojt 	if (strncasecmp((*opts), term, strlen(term)) == 0 &&
26380cbfa66cSDaniel Fojt 	    (*opts)[strlen(term)] == '=') {
26390cbfa66cSDaniel Fojt 		*opts += strlen(term) + 1;
26400cbfa66cSDaniel Fojt 		return 1;
26410cbfa66cSDaniel Fojt 	}
26420cbfa66cSDaniel Fojt 	return 0;
26430cbfa66cSDaniel Fojt }
26440cbfa66cSDaniel Fojt 
264550a69bb5SSascha Wildner void
opt_array_append2(const char * file,const int line,const char * directive,char *** array,int ** iarray,u_int * lp,const char * s,int i)264650a69bb5SSascha Wildner opt_array_append2(const char *file, const int line, const char *directive,
264750a69bb5SSascha Wildner     char ***array, int **iarray, u_int *lp, const char *s, int i)
264850a69bb5SSascha Wildner {
264950a69bb5SSascha Wildner 
265050a69bb5SSascha Wildner 	if (*lp >= INT_MAX)
265150a69bb5SSascha Wildner 		fatal("%s line %d: Too many %s entries", file, line, directive);
265250a69bb5SSascha Wildner 
265350a69bb5SSascha Wildner 	if (iarray != NULL) {
265450a69bb5SSascha Wildner 		*iarray = xrecallocarray(*iarray, *lp, *lp + 1,
265550a69bb5SSascha Wildner 		    sizeof(**iarray));
265650a69bb5SSascha Wildner 		(*iarray)[*lp] = i;
265750a69bb5SSascha Wildner 	}
265850a69bb5SSascha Wildner 
265950a69bb5SSascha Wildner 	*array = xrecallocarray(*array, *lp, *lp + 1, sizeof(**array));
266050a69bb5SSascha Wildner 	(*array)[*lp] = xstrdup(s);
266150a69bb5SSascha Wildner 	(*lp)++;
266250a69bb5SSascha Wildner }
266350a69bb5SSascha Wildner 
266450a69bb5SSascha Wildner void
opt_array_append(const char * file,const int line,const char * directive,char *** array,u_int * lp,const char * s)266550a69bb5SSascha Wildner opt_array_append(const char *file, const int line, const char *directive,
266650a69bb5SSascha Wildner     char ***array, u_int *lp, const char *s)
266750a69bb5SSascha Wildner {
266850a69bb5SSascha Wildner 	opt_array_append2(file, line, directive, array, NULL, lp, s, 0);
266950a69bb5SSascha Wildner }
267050a69bb5SSascha Wildner 
2671*ba1276acSMatthew Dillon void
opt_array_free2(char ** array,int ** iarray,u_int l)2672*ba1276acSMatthew Dillon opt_array_free2(char **array, int **iarray, u_int l)
2673*ba1276acSMatthew Dillon {
2674*ba1276acSMatthew Dillon 	u_int i;
2675*ba1276acSMatthew Dillon 
2676*ba1276acSMatthew Dillon 	if (array == NULL || l == 0)
2677*ba1276acSMatthew Dillon 		return;
2678*ba1276acSMatthew Dillon 	for (i = 0; i < l; i++)
2679*ba1276acSMatthew Dillon 		free(array[i]);
2680*ba1276acSMatthew Dillon 	free(array);
2681*ba1276acSMatthew Dillon 	free(iarray);
2682*ba1276acSMatthew Dillon }
2683*ba1276acSMatthew Dillon 
26840cbfa66cSDaniel Fojt sshsig_t
ssh_signal(int signum,sshsig_t handler)26850cbfa66cSDaniel Fojt ssh_signal(int signum, sshsig_t handler)
26860cbfa66cSDaniel Fojt {
26870cbfa66cSDaniel Fojt 	struct sigaction sa, osa;
26880cbfa66cSDaniel Fojt 
26890cbfa66cSDaniel Fojt 	/* mask all other signals while in handler */
26900cbfa66cSDaniel Fojt 	memset(&sa, 0, sizeof(sa));
26910cbfa66cSDaniel Fojt 	sa.sa_handler = handler;
26920cbfa66cSDaniel Fojt 	sigfillset(&sa.sa_mask);
26930cbfa66cSDaniel Fojt #if defined(SA_RESTART) && !defined(NO_SA_RESTART)
26940cbfa66cSDaniel Fojt 	if (signum != SIGALRM)
26950cbfa66cSDaniel Fojt 		sa.sa_flags = SA_RESTART;
26960cbfa66cSDaniel Fojt #endif
26970cbfa66cSDaniel Fojt 	if (sigaction(signum, &sa, &osa) == -1) {
26980cbfa66cSDaniel Fojt 		debug3("sigaction(%s): %s", strsignal(signum), strerror(errno));
26990cbfa66cSDaniel Fojt 		return SIG_ERR;
27000cbfa66cSDaniel Fojt 	}
27010cbfa66cSDaniel Fojt 	return osa.sa_handler;
27020cbfa66cSDaniel Fojt }
270350a69bb5SSascha Wildner 
270450a69bb5SSascha Wildner int
stdfd_devnull(int do_stdin,int do_stdout,int do_stderr)270550a69bb5SSascha Wildner stdfd_devnull(int do_stdin, int do_stdout, int do_stderr)
270650a69bb5SSascha Wildner {
270750a69bb5SSascha Wildner 	int devnull, ret = 0;
270850a69bb5SSascha Wildner 
270950a69bb5SSascha Wildner 	if ((devnull = open(_PATH_DEVNULL, O_RDWR)) == -1) {
271050a69bb5SSascha Wildner 		error_f("open %s: %s", _PATH_DEVNULL,
271150a69bb5SSascha Wildner 		    strerror(errno));
271250a69bb5SSascha Wildner 		return -1;
271350a69bb5SSascha Wildner 	}
271450a69bb5SSascha Wildner 	if ((do_stdin && dup2(devnull, STDIN_FILENO) == -1) ||
271550a69bb5SSascha Wildner 	    (do_stdout && dup2(devnull, STDOUT_FILENO) == -1) ||
271650a69bb5SSascha Wildner 	    (do_stderr && dup2(devnull, STDERR_FILENO) == -1)) {
271750a69bb5SSascha Wildner 		error_f("dup2: %s", strerror(errno));
271850a69bb5SSascha Wildner 		ret = -1;
271950a69bb5SSascha Wildner 	}
272050a69bb5SSascha Wildner 	if (devnull > STDERR_FILENO)
272150a69bb5SSascha Wildner 		close(devnull);
272250a69bb5SSascha Wildner 	return ret;
272350a69bb5SSascha Wildner }
272450a69bb5SSascha Wildner 
272550a69bb5SSascha Wildner /*
272650a69bb5SSascha Wildner  * Runs command in a subprocess with a minimal environment.
272750a69bb5SSascha Wildner  * Returns pid on success, 0 on failure.
272850a69bb5SSascha Wildner  * The child stdout and stderr maybe captured, left attached or sent to
272950a69bb5SSascha Wildner  * /dev/null depending on the contents of flags.
273050a69bb5SSascha Wildner  * "tag" is prepended to log messages.
273150a69bb5SSascha Wildner  * NB. "command" is only used for logging; the actual command executed is
273250a69bb5SSascha Wildner  * av[0].
273350a69bb5SSascha Wildner  */
273450a69bb5SSascha Wildner pid_t
subprocess(const char * tag,const char * command,int ac,char ** av,FILE ** child,u_int flags,struct passwd * pw,privdrop_fn * drop_privs,privrestore_fn * restore_privs)273550a69bb5SSascha Wildner subprocess(const char *tag, const char *command,
273650a69bb5SSascha Wildner     int ac, char **av, FILE **child, u_int flags,
273750a69bb5SSascha Wildner     struct passwd *pw, privdrop_fn *drop_privs, privrestore_fn *restore_privs)
273850a69bb5SSascha Wildner {
273950a69bb5SSascha Wildner 	FILE *f = NULL;
274050a69bb5SSascha Wildner 	struct stat st;
274150a69bb5SSascha Wildner 	int fd, devnull, p[2], i;
274250a69bb5SSascha Wildner 	pid_t pid;
274350a69bb5SSascha Wildner 	char *cp, errmsg[512];
274450a69bb5SSascha Wildner 	u_int nenv = 0;
274550a69bb5SSascha Wildner 	char **env = NULL;
274650a69bb5SSascha Wildner 
274750a69bb5SSascha Wildner 	/* If dropping privs, then must specify user and restore function */
274850a69bb5SSascha Wildner 	if (drop_privs != NULL && (pw == NULL || restore_privs == NULL)) {
274950a69bb5SSascha Wildner 		error("%s: inconsistent arguments", tag); /* XXX fatal? */
275050a69bb5SSascha Wildner 		return 0;
275150a69bb5SSascha Wildner 	}
275250a69bb5SSascha Wildner 	if (pw == NULL && (pw = getpwuid(getuid())) == NULL) {
275350a69bb5SSascha Wildner 		error("%s: no user for current uid", tag);
275450a69bb5SSascha Wildner 		return 0;
275550a69bb5SSascha Wildner 	}
275650a69bb5SSascha Wildner 	if (child != NULL)
275750a69bb5SSascha Wildner 		*child = NULL;
275850a69bb5SSascha Wildner 
275950a69bb5SSascha Wildner 	debug3_f("%s command \"%s\" running as %s (flags 0x%x)",
276050a69bb5SSascha Wildner 	    tag, command, pw->pw_name, flags);
276150a69bb5SSascha Wildner 
276250a69bb5SSascha Wildner 	/* Check consistency */
276350a69bb5SSascha Wildner 	if ((flags & SSH_SUBPROCESS_STDOUT_DISCARD) != 0 &&
276450a69bb5SSascha Wildner 	    (flags & SSH_SUBPROCESS_STDOUT_CAPTURE) != 0) {
276550a69bb5SSascha Wildner 		error_f("inconsistent flags");
276650a69bb5SSascha Wildner 		return 0;
276750a69bb5SSascha Wildner 	}
276850a69bb5SSascha Wildner 	if (((flags & SSH_SUBPROCESS_STDOUT_CAPTURE) == 0) != (child == NULL)) {
276950a69bb5SSascha Wildner 		error_f("inconsistent flags/output");
277050a69bb5SSascha Wildner 		return 0;
277150a69bb5SSascha Wildner 	}
277250a69bb5SSascha Wildner 
277350a69bb5SSascha Wildner 	/*
277450a69bb5SSascha Wildner 	 * If executing an explicit binary, then verify the it exists
277550a69bb5SSascha Wildner 	 * and appears safe-ish to execute
277650a69bb5SSascha Wildner 	 */
277750a69bb5SSascha Wildner 	if (!path_absolute(av[0])) {
277850a69bb5SSascha Wildner 		error("%s path is not absolute", tag);
277950a69bb5SSascha Wildner 		return 0;
278050a69bb5SSascha Wildner 	}
278150a69bb5SSascha Wildner 	if (drop_privs != NULL)
278250a69bb5SSascha Wildner 		drop_privs(pw);
278350a69bb5SSascha Wildner 	if (stat(av[0], &st) == -1) {
278450a69bb5SSascha Wildner 		error("Could not stat %s \"%s\": %s", tag,
278550a69bb5SSascha Wildner 		    av[0], strerror(errno));
278650a69bb5SSascha Wildner 		goto restore_return;
278750a69bb5SSascha Wildner 	}
278850a69bb5SSascha Wildner 	if ((flags & SSH_SUBPROCESS_UNSAFE_PATH) == 0 &&
278950a69bb5SSascha Wildner 	    safe_path(av[0], &st, NULL, 0, errmsg, sizeof(errmsg)) != 0) {
279050a69bb5SSascha Wildner 		error("Unsafe %s \"%s\": %s", tag, av[0], errmsg);
279150a69bb5SSascha Wildner 		goto restore_return;
279250a69bb5SSascha Wildner 	}
279350a69bb5SSascha Wildner 	/* Prepare to keep the child's stdout if requested */
279450a69bb5SSascha Wildner 	if (pipe(p) == -1) {
279550a69bb5SSascha Wildner 		error("%s: pipe: %s", tag, strerror(errno));
279650a69bb5SSascha Wildner  restore_return:
279750a69bb5SSascha Wildner 		if (restore_privs != NULL)
279850a69bb5SSascha Wildner 			restore_privs();
279950a69bb5SSascha Wildner 		return 0;
280050a69bb5SSascha Wildner 	}
280150a69bb5SSascha Wildner 	if (restore_privs != NULL)
280250a69bb5SSascha Wildner 		restore_privs();
280350a69bb5SSascha Wildner 
280450a69bb5SSascha Wildner 	switch ((pid = fork())) {
280550a69bb5SSascha Wildner 	case -1: /* error */
280650a69bb5SSascha Wildner 		error("%s: fork: %s", tag, strerror(errno));
280750a69bb5SSascha Wildner 		close(p[0]);
280850a69bb5SSascha Wildner 		close(p[1]);
280950a69bb5SSascha Wildner 		return 0;
281050a69bb5SSascha Wildner 	case 0: /* child */
281150a69bb5SSascha Wildner 		/* Prepare a minimal environment for the child. */
281250a69bb5SSascha Wildner 		if ((flags & SSH_SUBPROCESS_PRESERVE_ENV) == 0) {
281350a69bb5SSascha Wildner 			nenv = 5;
281450a69bb5SSascha Wildner 			env = xcalloc(sizeof(*env), nenv);
281550a69bb5SSascha Wildner 			child_set_env(&env, &nenv, "PATH", _PATH_STDPATH);
281650a69bb5SSascha Wildner 			child_set_env(&env, &nenv, "USER", pw->pw_name);
281750a69bb5SSascha Wildner 			child_set_env(&env, &nenv, "LOGNAME", pw->pw_name);
281850a69bb5SSascha Wildner 			child_set_env(&env, &nenv, "HOME", pw->pw_dir);
281950a69bb5SSascha Wildner 			if ((cp = getenv("LANG")) != NULL)
282050a69bb5SSascha Wildner 				child_set_env(&env, &nenv, "LANG", cp);
282150a69bb5SSascha Wildner 		}
282250a69bb5SSascha Wildner 
282350a69bb5SSascha Wildner 		for (i = 1; i < NSIG; i++)
282450a69bb5SSascha Wildner 			ssh_signal(i, SIG_DFL);
282550a69bb5SSascha Wildner 
282650a69bb5SSascha Wildner 		if ((devnull = open(_PATH_DEVNULL, O_RDWR)) == -1) {
282750a69bb5SSascha Wildner 			error("%s: open %s: %s", tag, _PATH_DEVNULL,
282850a69bb5SSascha Wildner 			    strerror(errno));
282950a69bb5SSascha Wildner 			_exit(1);
283050a69bb5SSascha Wildner 		}
283150a69bb5SSascha Wildner 		if (dup2(devnull, STDIN_FILENO) == -1) {
283250a69bb5SSascha Wildner 			error("%s: dup2: %s", tag, strerror(errno));
283350a69bb5SSascha Wildner 			_exit(1);
283450a69bb5SSascha Wildner 		}
283550a69bb5SSascha Wildner 
283650a69bb5SSascha Wildner 		/* Set up stdout as requested; leave stderr in place for now. */
283750a69bb5SSascha Wildner 		fd = -1;
283850a69bb5SSascha Wildner 		if ((flags & SSH_SUBPROCESS_STDOUT_CAPTURE) != 0)
283950a69bb5SSascha Wildner 			fd = p[1];
284050a69bb5SSascha Wildner 		else if ((flags & SSH_SUBPROCESS_STDOUT_DISCARD) != 0)
284150a69bb5SSascha Wildner 			fd = devnull;
284250a69bb5SSascha Wildner 		if (fd != -1 && dup2(fd, STDOUT_FILENO) == -1) {
284350a69bb5SSascha Wildner 			error("%s: dup2: %s", tag, strerror(errno));
284450a69bb5SSascha Wildner 			_exit(1);
284550a69bb5SSascha Wildner 		}
284650a69bb5SSascha Wildner 		closefrom(STDERR_FILENO + 1);
284750a69bb5SSascha Wildner 
284850a69bb5SSascha Wildner 		if (geteuid() == 0 &&
284950a69bb5SSascha Wildner 		    initgroups(pw->pw_name, pw->pw_gid) == -1) {
285050a69bb5SSascha Wildner 			error("%s: initgroups(%s, %u): %s", tag,
285150a69bb5SSascha Wildner 			    pw->pw_name, (u_int)pw->pw_gid, strerror(errno));
285250a69bb5SSascha Wildner 			_exit(1);
285350a69bb5SSascha Wildner 		}
285450a69bb5SSascha Wildner 		if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) == -1) {
285550a69bb5SSascha Wildner 			error("%s: setresgid %u: %s", tag, (u_int)pw->pw_gid,
285650a69bb5SSascha Wildner 			    strerror(errno));
285750a69bb5SSascha Wildner 			_exit(1);
285850a69bb5SSascha Wildner 		}
285950a69bb5SSascha Wildner 		if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) == -1) {
286050a69bb5SSascha Wildner 			error("%s: setresuid %u: %s", tag, (u_int)pw->pw_uid,
286150a69bb5SSascha Wildner 			    strerror(errno));
286250a69bb5SSascha Wildner 			_exit(1);
286350a69bb5SSascha Wildner 		}
286450a69bb5SSascha Wildner 		/* stdin is pointed to /dev/null at this point */
286550a69bb5SSascha Wildner 		if ((flags & SSH_SUBPROCESS_STDOUT_DISCARD) != 0 &&
286650a69bb5SSascha Wildner 		    dup2(STDIN_FILENO, STDERR_FILENO) == -1) {
286750a69bb5SSascha Wildner 			error("%s: dup2: %s", tag, strerror(errno));
286850a69bb5SSascha Wildner 			_exit(1);
286950a69bb5SSascha Wildner 		}
287050a69bb5SSascha Wildner 		if (env != NULL)
287150a69bb5SSascha Wildner 			execve(av[0], av, env);
287250a69bb5SSascha Wildner 		else
287350a69bb5SSascha Wildner 			execv(av[0], av);
287450a69bb5SSascha Wildner 		error("%s %s \"%s\": %s", tag, env == NULL ? "execv" : "execve",
287550a69bb5SSascha Wildner 		    command, strerror(errno));
287650a69bb5SSascha Wildner 		_exit(127);
287750a69bb5SSascha Wildner 	default: /* parent */
287850a69bb5SSascha Wildner 		break;
287950a69bb5SSascha Wildner 	}
288050a69bb5SSascha Wildner 
288150a69bb5SSascha Wildner 	close(p[1]);
288250a69bb5SSascha Wildner 	if ((flags & SSH_SUBPROCESS_STDOUT_CAPTURE) == 0)
288350a69bb5SSascha Wildner 		close(p[0]);
288450a69bb5SSascha Wildner 	else if ((f = fdopen(p[0], "r")) == NULL) {
288550a69bb5SSascha Wildner 		error("%s: fdopen: %s", tag, strerror(errno));
288650a69bb5SSascha Wildner 		close(p[0]);
288750a69bb5SSascha Wildner 		/* Don't leave zombie child */
288850a69bb5SSascha Wildner 		kill(pid, SIGTERM);
288950a69bb5SSascha Wildner 		while (waitpid(pid, NULL, 0) == -1 && errno == EINTR)
289050a69bb5SSascha Wildner 			;
289150a69bb5SSascha Wildner 		return 0;
289250a69bb5SSascha Wildner 	}
289350a69bb5SSascha Wildner 	/* Success */
289450a69bb5SSascha Wildner 	debug3_f("%s pid %ld", tag, (long)pid);
289550a69bb5SSascha Wildner 	if (child != NULL)
289650a69bb5SSascha Wildner 		*child = f;
289750a69bb5SSascha Wildner 	return pid;
289850a69bb5SSascha Wildner }
289950a69bb5SSascha Wildner 
290050a69bb5SSascha Wildner const char *
lookup_env_in_list(const char * env,char * const * envs,size_t nenvs)290150a69bb5SSascha Wildner lookup_env_in_list(const char *env, char * const *envs, size_t nenvs)
290250a69bb5SSascha Wildner {
290350a69bb5SSascha Wildner 	size_t i, envlen;
290450a69bb5SSascha Wildner 
290550a69bb5SSascha Wildner 	envlen = strlen(env);
290650a69bb5SSascha Wildner 	for (i = 0; i < nenvs; i++) {
290750a69bb5SSascha Wildner 		if (strncmp(envs[i], env, envlen) == 0 &&
290850a69bb5SSascha Wildner 		    envs[i][envlen] == '=') {
290950a69bb5SSascha Wildner 			return envs[i] + envlen + 1;
291050a69bb5SSascha Wildner 		}
291150a69bb5SSascha Wildner 	}
291250a69bb5SSascha Wildner 	return NULL;
291350a69bb5SSascha Wildner }
2914ee116499SAntonio Huete Jimenez 
2915ee116499SAntonio Huete Jimenez const char *
lookup_setenv_in_list(const char * env,char * const * envs,size_t nenvs)2916ee116499SAntonio Huete Jimenez lookup_setenv_in_list(const char *env, char * const *envs, size_t nenvs)
2917ee116499SAntonio Huete Jimenez {
2918ee116499SAntonio Huete Jimenez 	char *name, *cp;
2919ee116499SAntonio Huete Jimenez 	const char *ret;
2920ee116499SAntonio Huete Jimenez 
2921ee116499SAntonio Huete Jimenez 	name = xstrdup(env);
2922ee116499SAntonio Huete Jimenez 	if ((cp = strchr(name, '=')) == NULL) {
2923ee116499SAntonio Huete Jimenez 		free(name);
2924ee116499SAntonio Huete Jimenez 		return NULL; /* not env=val */
2925ee116499SAntonio Huete Jimenez 	}
2926ee116499SAntonio Huete Jimenez 	*cp = '\0';
2927ee116499SAntonio Huete Jimenez 	ret = lookup_env_in_list(name, envs, nenvs);
2928ee116499SAntonio Huete Jimenez 	free(name);
2929ee116499SAntonio Huete Jimenez 	return ret;
2930ee116499SAntonio Huete Jimenez }
2931*ba1276acSMatthew Dillon 
2932*ba1276acSMatthew Dillon /*
2933*ba1276acSMatthew Dillon  * Helpers for managing poll(2)/ppoll(2) timeouts
2934*ba1276acSMatthew Dillon  * Will remember the earliest deadline and return it for use in poll/ppoll.
2935*ba1276acSMatthew Dillon  */
2936*ba1276acSMatthew Dillon 
2937*ba1276acSMatthew Dillon /* Initialise a poll/ppoll timeout with an indefinite deadline */
2938*ba1276acSMatthew Dillon void
ptimeout_init(struct timespec * pt)2939*ba1276acSMatthew Dillon ptimeout_init(struct timespec *pt)
2940*ba1276acSMatthew Dillon {
2941*ba1276acSMatthew Dillon 	/*
2942*ba1276acSMatthew Dillon 	 * Deliberately invalid for ppoll(2).
2943*ba1276acSMatthew Dillon 	 * Will be converted to NULL in ptimeout_get_tspec() later.
2944*ba1276acSMatthew Dillon 	 */
2945*ba1276acSMatthew Dillon 	pt->tv_sec = -1;
2946*ba1276acSMatthew Dillon 	pt->tv_nsec = 0;
2947*ba1276acSMatthew Dillon }
2948*ba1276acSMatthew Dillon 
2949*ba1276acSMatthew Dillon /* Specify a poll/ppoll deadline of at most 'sec' seconds */
2950*ba1276acSMatthew Dillon void
ptimeout_deadline_sec(struct timespec * pt,long sec)2951*ba1276acSMatthew Dillon ptimeout_deadline_sec(struct timespec *pt, long sec)
2952*ba1276acSMatthew Dillon {
2953*ba1276acSMatthew Dillon 	if (pt->tv_sec == -1 || pt->tv_sec >= sec) {
2954*ba1276acSMatthew Dillon 		pt->tv_sec = sec;
2955*ba1276acSMatthew Dillon 		pt->tv_nsec = 0;
2956*ba1276acSMatthew Dillon 	}
2957*ba1276acSMatthew Dillon }
2958*ba1276acSMatthew Dillon 
2959*ba1276acSMatthew Dillon /* Specify a poll/ppoll deadline of at most 'p' (timespec) */
2960*ba1276acSMatthew Dillon static void
ptimeout_deadline_tsp(struct timespec * pt,struct timespec * p)2961*ba1276acSMatthew Dillon ptimeout_deadline_tsp(struct timespec *pt, struct timespec *p)
2962*ba1276acSMatthew Dillon {
2963*ba1276acSMatthew Dillon 	if (pt->tv_sec == -1 || timespeccmp(pt, p, >=))
2964*ba1276acSMatthew Dillon 		*pt = *p;
2965*ba1276acSMatthew Dillon }
2966*ba1276acSMatthew Dillon 
2967*ba1276acSMatthew Dillon /* Specify a poll/ppoll deadline of at most 'ms' milliseconds */
2968*ba1276acSMatthew Dillon void
ptimeout_deadline_ms(struct timespec * pt,long ms)2969*ba1276acSMatthew Dillon ptimeout_deadline_ms(struct timespec *pt, long ms)
2970*ba1276acSMatthew Dillon {
2971*ba1276acSMatthew Dillon 	struct timespec p;
2972*ba1276acSMatthew Dillon 
2973*ba1276acSMatthew Dillon 	p.tv_sec = ms / 1000;
2974*ba1276acSMatthew Dillon 	p.tv_nsec = (ms % 1000) * 1000000;
2975*ba1276acSMatthew Dillon 	ptimeout_deadline_tsp(pt, &p);
2976*ba1276acSMatthew Dillon }
2977*ba1276acSMatthew Dillon 
2978*ba1276acSMatthew Dillon /* Specify a poll/ppoll deadline at wall clock monotime 'when' (timespec) */
2979*ba1276acSMatthew Dillon void
ptimeout_deadline_monotime_tsp(struct timespec * pt,struct timespec * when)2980*ba1276acSMatthew Dillon ptimeout_deadline_monotime_tsp(struct timespec *pt, struct timespec *when)
2981*ba1276acSMatthew Dillon {
2982*ba1276acSMatthew Dillon 	struct timespec now, t;
2983*ba1276acSMatthew Dillon 
2984*ba1276acSMatthew Dillon 	monotime_ts(&now);
2985*ba1276acSMatthew Dillon 
2986*ba1276acSMatthew Dillon 	if (timespeccmp(&now, when, >=)) {
2987*ba1276acSMatthew Dillon 		/* 'when' is now or in the past. Timeout ASAP */
2988*ba1276acSMatthew Dillon 		pt->tv_sec = 0;
2989*ba1276acSMatthew Dillon 		pt->tv_nsec = 0;
2990*ba1276acSMatthew Dillon 	} else {
2991*ba1276acSMatthew Dillon 		timespecsub(when, &now, &t);
2992*ba1276acSMatthew Dillon 		ptimeout_deadline_tsp(pt, &t);
2993*ba1276acSMatthew Dillon 	}
2994*ba1276acSMatthew Dillon }
2995*ba1276acSMatthew Dillon 
2996*ba1276acSMatthew Dillon /* Specify a poll/ppoll deadline at wall clock monotime 'when' */
2997*ba1276acSMatthew Dillon void
ptimeout_deadline_monotime(struct timespec * pt,time_t when)2998*ba1276acSMatthew Dillon ptimeout_deadline_monotime(struct timespec *pt, time_t when)
2999*ba1276acSMatthew Dillon {
3000*ba1276acSMatthew Dillon 	struct timespec t;
3001*ba1276acSMatthew Dillon 
3002*ba1276acSMatthew Dillon 	t.tv_sec = when;
3003*ba1276acSMatthew Dillon 	t.tv_nsec = 0;
3004*ba1276acSMatthew Dillon 	ptimeout_deadline_monotime_tsp(pt, &t);
3005*ba1276acSMatthew Dillon }
3006*ba1276acSMatthew Dillon 
3007*ba1276acSMatthew Dillon /* Get a poll(2) timeout value in milliseconds */
3008*ba1276acSMatthew Dillon int
ptimeout_get_ms(struct timespec * pt)3009*ba1276acSMatthew Dillon ptimeout_get_ms(struct timespec *pt)
3010*ba1276acSMatthew Dillon {
3011*ba1276acSMatthew Dillon 	if (pt->tv_sec == -1)
3012*ba1276acSMatthew Dillon 		return -1;
3013*ba1276acSMatthew Dillon 	if (pt->tv_sec >= (INT_MAX - (pt->tv_nsec / 1000000)) / 1000)
3014*ba1276acSMatthew Dillon 		return INT_MAX;
3015*ba1276acSMatthew Dillon 	return (pt->tv_sec * 1000) + (pt->tv_nsec / 1000000);
3016*ba1276acSMatthew Dillon }
3017*ba1276acSMatthew Dillon 
3018*ba1276acSMatthew Dillon /* Get a ppoll(2) timeout value as a timespec pointer */
3019*ba1276acSMatthew Dillon struct timespec *
ptimeout_get_tsp(struct timespec * pt)3020*ba1276acSMatthew Dillon ptimeout_get_tsp(struct timespec *pt)
3021*ba1276acSMatthew Dillon {
3022*ba1276acSMatthew Dillon 	return pt->tv_sec == -1 ? NULL : pt;
3023*ba1276acSMatthew Dillon }
3024*ba1276acSMatthew Dillon 
3025*ba1276acSMatthew Dillon /* Returns non-zero if a timeout has been set (i.e. is not indefinite) */
3026*ba1276acSMatthew Dillon int
ptimeout_isset(struct timespec * pt)3027*ba1276acSMatthew Dillon ptimeout_isset(struct timespec *pt)
3028*ba1276acSMatthew Dillon {
3029*ba1276acSMatthew Dillon 	return pt->tv_sec != -1;
3030*ba1276acSMatthew Dillon }
3031*ba1276acSMatthew Dillon 
3032*ba1276acSMatthew Dillon /*
3033*ba1276acSMatthew Dillon  * Returns zero if the library at 'path' contains symbol 's', nonzero
3034*ba1276acSMatthew Dillon  * otherwise.
3035*ba1276acSMatthew Dillon  */
3036*ba1276acSMatthew Dillon int
lib_contains_symbol(const char * path,const char * s)3037*ba1276acSMatthew Dillon lib_contains_symbol(const char *path, const char *s)
3038*ba1276acSMatthew Dillon {
3039*ba1276acSMatthew Dillon #ifdef HAVE_NLIST_H
3040*ba1276acSMatthew Dillon 	struct nlist nl[2];
3041*ba1276acSMatthew Dillon 	int ret = -1, r;
3042*ba1276acSMatthew Dillon 
3043*ba1276acSMatthew Dillon 	memset(nl, 0, sizeof(nl));
3044*ba1276acSMatthew Dillon 	nl[0].n_name = xstrdup(s);
3045*ba1276acSMatthew Dillon 	nl[1].n_name = NULL;
3046*ba1276acSMatthew Dillon 	if ((r = nlist(path, nl)) == -1) {
3047*ba1276acSMatthew Dillon 		error_f("nlist failed for %s", path);
3048*ba1276acSMatthew Dillon 		goto out;
3049*ba1276acSMatthew Dillon 	}
3050*ba1276acSMatthew Dillon 	if (r != 0 || nl[0].n_value == 0 || nl[0].n_type == 0) {
3051*ba1276acSMatthew Dillon 		error_f("library %s does not contain symbol %s", path, s);
3052*ba1276acSMatthew Dillon 		goto out;
3053*ba1276acSMatthew Dillon 	}
3054*ba1276acSMatthew Dillon 	/* success */
3055*ba1276acSMatthew Dillon 	ret = 0;
3056*ba1276acSMatthew Dillon  out:
3057*ba1276acSMatthew Dillon 	free(nl[0].n_name);
3058*ba1276acSMatthew Dillon 	return ret;
3059*ba1276acSMatthew Dillon #else /* HAVE_NLIST_H */
3060*ba1276acSMatthew Dillon 	int fd, ret = -1;
3061*ba1276acSMatthew Dillon 	struct stat st;
3062*ba1276acSMatthew Dillon 	void *m = NULL;
3063*ba1276acSMatthew Dillon 	size_t sz = 0;
3064*ba1276acSMatthew Dillon 
3065*ba1276acSMatthew Dillon 	memset(&st, 0, sizeof(st));
3066*ba1276acSMatthew Dillon 	if ((fd = open(path, O_RDONLY)) < 0) {
3067*ba1276acSMatthew Dillon 		error_f("open %s: %s", path, strerror(errno));
3068*ba1276acSMatthew Dillon 		return -1;
3069*ba1276acSMatthew Dillon 	}
3070*ba1276acSMatthew Dillon 	if (fstat(fd, &st) != 0) {
3071*ba1276acSMatthew Dillon 		error_f("fstat %s: %s", path, strerror(errno));
3072*ba1276acSMatthew Dillon 		goto out;
3073*ba1276acSMatthew Dillon 	}
3074*ba1276acSMatthew Dillon 	if (!S_ISREG(st.st_mode)) {
3075*ba1276acSMatthew Dillon 		error_f("%s is not a regular file", path);
3076*ba1276acSMatthew Dillon 		goto out;
3077*ba1276acSMatthew Dillon 	}
3078*ba1276acSMatthew Dillon 	if (st.st_size < 0 ||
3079*ba1276acSMatthew Dillon 	    (size_t)st.st_size < strlen(s) ||
3080*ba1276acSMatthew Dillon 	    st.st_size >= INT_MAX/2) {
3081*ba1276acSMatthew Dillon 		error_f("%s bad size %lld", path, (long long)st.st_size);
3082*ba1276acSMatthew Dillon 		goto out;
3083*ba1276acSMatthew Dillon 	}
3084*ba1276acSMatthew Dillon 	sz = (size_t)st.st_size;
3085*ba1276acSMatthew Dillon 	if ((m = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED ||
3086*ba1276acSMatthew Dillon 	    m == NULL) {
3087*ba1276acSMatthew Dillon 		error_f("mmap %s: %s", path, strerror(errno));
3088*ba1276acSMatthew Dillon 		goto out;
3089*ba1276acSMatthew Dillon 	}
3090*ba1276acSMatthew Dillon 	if (memmem(m, sz, s, strlen(s)) == NULL) {
3091*ba1276acSMatthew Dillon 		error_f("%s does not contain expected string %s", path, s);
3092*ba1276acSMatthew Dillon 		goto out;
3093*ba1276acSMatthew Dillon 	}
3094*ba1276acSMatthew Dillon 	/* success */
3095*ba1276acSMatthew Dillon 	ret = 0;
3096*ba1276acSMatthew Dillon  out:
3097*ba1276acSMatthew Dillon 	if (m != NULL && m != MAP_FAILED)
3098*ba1276acSMatthew Dillon 		munmap(m, sz);
3099*ba1276acSMatthew Dillon 	close(fd);
3100*ba1276acSMatthew Dillon 	return ret;
3101*ba1276acSMatthew Dillon #endif /* HAVE_NLIST_H */
3102*ba1276acSMatthew Dillon }
3103*ba1276acSMatthew Dillon 
3104*ba1276acSMatthew Dillon int
signal_is_crash(int sig)3105*ba1276acSMatthew Dillon signal_is_crash(int sig)
3106*ba1276acSMatthew Dillon {
3107*ba1276acSMatthew Dillon 	switch (sig) {
3108*ba1276acSMatthew Dillon 	case SIGSEGV:
3109*ba1276acSMatthew Dillon 	case SIGBUS:
3110*ba1276acSMatthew Dillon 	case SIGTRAP:
3111*ba1276acSMatthew Dillon 	case SIGSYS:
3112*ba1276acSMatthew Dillon 	case SIGFPE:
3113*ba1276acSMatthew Dillon 	case SIGILL:
3114*ba1276acSMatthew Dillon 	case SIGABRT:
3115*ba1276acSMatthew Dillon 		return 1;
3116*ba1276acSMatthew Dillon 	}
3117*ba1276acSMatthew Dillon 	return 0;
3118*ba1276acSMatthew Dillon }
3119