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