Import openssh_7.3p1.orig.tar.gz

1 files changed, 137 insertions, 13 deletions

diff --git a/misc.c b/misc.c
index de7e1facd..9421b4d39 100644
--- a/misc.c
+++ b/misc.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: misc.c,v 1.101 2016/01/20 09:22:39 dtucker Exp $ */
+/* $OpenBSD: misc.c,v 1.105 2016/07/15 00:24:30 djm Exp $ */
 /*
  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
  * Copyright (c) 2005,2006 Damien Miller.  All rights reserved.
@@ -84,9 +84,9 @@ set_nonblock(int fd)
 {
         int val;
 
-        val = fcntl(fd, F_GETFL, 0);
+        val = fcntl(fd, F_GETFL);
         if (val < 0) {
-                error("fcntl(%d, F_GETFL, 0): %s", fd, strerror(errno));
+                error("fcntl(%d, F_GETFL): %s", fd, strerror(errno));
                 return (-1);
         }
         if (val & O_NONBLOCK) {
@@ -108,9 +108,9 @@ unset_nonblock(int fd)
 {
         int val;
 
-        val = fcntl(fd, F_GETFL, 0);
+        val = fcntl(fd, F_GETFL);
         if (val < 0) {
-                error("fcntl(%d, F_GETFL, 0): %s", fd, strerror(errno));
+                error("fcntl(%d, F_GETFL): %s", fd, strerror(errno));
                 return (-1);
         }
         if (!(val & O_NONBLOCK)) {
@@ -451,6 +451,67 @@ colon(char *cp)
         return NULL;
 }
 
+/*
+ * Parse a [user@]host[:port] string.
+ * Caller must free returned user and host.
+ * Any of the pointer return arguments may be NULL (useful for syntax checking).
+ * If user was not specified then *userp will be set to NULL.
+ * If port was not specified then *portp will be -1.
+ * Returns 0 on success, -1 on failure.
+ */
+int
+parse_user_host_port(const char *s, char **userp, char **hostp, int *portp)
+{
+        char *sdup, *cp, *tmp;
+        char *user = NULL, *host = NULL;
+        int port = -1, ret = -1;
+
+        if (userp != NULL)
+                *userp = NULL;
+        if (hostp != NULL)
+                *hostp = NULL;
+        if (portp != NULL)
+                *portp = -1;
+
+        if ((sdup = tmp = strdup(s)) == NULL)
+                return -1;
+        /* Extract optional username */
+        if ((cp = strchr(tmp, '@')) != NULL) {
+                *cp = '\0';
+                if (*tmp == '\0')
+                        goto out;
+                if ((user = strdup(tmp)) == NULL)
+                        goto out;
+                tmp = cp + 1;
+        }
+        /* Extract mandatory hostname */
+        if ((cp = hpdelim(&tmp)) == NULL || *cp == '\0')
+                goto out;
+        host = xstrdup(cleanhostname(cp));
+        /* Convert and verify optional port */
+        if (tmp != NULL && *tmp != '\0') {
+                if ((port = a2port(tmp)) <= 0)
+                        goto out;
+        }
+        /* Success */
+        if (userp != NULL) {
+                *userp = user;
+                user = NULL;
+        }
+        if (hostp != NULL) {
+                *hostp = host;
+                host = NULL;
+        }
+        if (portp != NULL)
+                *portp = port;
+        ret = 0;
+ out:
+        free(sdup);
+        free(user);
+        free(host);
+        return ret;
+}
+
 /* function to assist building execv() arguments */
 void
 addargs(arglist *args, char *fmt, ...)
@@ -729,16 +790,16 @@ sanitise_stdfd(void)
                     strerror(errno));
                 exit(1);
         }
-        while (++dupfd <= 2) {
-                /* Only clobber closed fds */
-                if (fcntl(dupfd, F_GETFL, 0) >= 0)
-                        continue;
-                if (dup2(nullfd, dupfd) == -1) {
-                        fprintf(stderr, "dup2: %s\n", strerror(errno));
-                        exit(1);
+        while (++dupfd <= STDERR_FILENO) {
+                /* Only populate closed fds. */
+                if (fcntl(dupfd, F_GETFL) == -1 && errno == EBADF) {
+                        if (dup2(nullfd, dupfd) == -1) {
+                                fprintf(stderr, "dup2: %s\n", strerror(errno));
+                                exit(1);
+                        }
                 }
         }
-        if (nullfd > 2)
+        if (nullfd > STDERR_FILENO)
                 close(nullfd);
 }
 
@@ -909,6 +970,31 @@ monotime(void)
         return time(NULL);
 }
 
+double
+monotime_double(void)
+{
+#if defined(HAVE_CLOCK_GETTIME) && \
+    (defined(CLOCK_MONOTONIC) || defined(CLOCK_BOOTTIME))
+        struct timespec ts;
+        static int gettime_failed = 0;
+
+        if (!gettime_failed) {
+#if defined(CLOCK_BOOTTIME)
+                if (clock_gettime(CLOCK_BOOTTIME, &ts) == 0)
+                        return (ts.tv_sec + (double)ts.tv_nsec / 1000000000);
+#endif
+#if defined(CLOCK_MONOTONIC)
+                if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0)
+                        return (ts.tv_sec + (double)ts.tv_nsec / 1000000000);
+#endif
+                debug3("clock_gettime: %s", strerror(errno));
+                gettime_failed = 1;
+        }
+#endif /* HAVE_CLOCK_GETTIME && (CLOCK_MONOTONIC || CLOCK_BOOTTIME */
+
+        return (double)time(NULL);
+}
+
 void
 bandwidth_limit_init(struct bwlimit *bw, u_int64_t kbps, size_t buflen)
 {
@@ -1119,3 +1205,41 @@ sock_set_v6only(int s)
                 error("setsockopt IPV6_V6ONLY: %s", strerror(errno));
 #endif
 }
+
+/*
+ * Compares two strings that maybe be NULL. Returns non-zero if strings
+ * are both NULL or are identical, returns zero otherwise.
+ */
+static int
+strcmp_maybe_null(const char *a, const char *b)
+{
+        if ((a == NULL && b != NULL) || (a != NULL && b == NULL))
+                return 0;
+        if (a != NULL && strcmp(a, b) != 0)
+                return 0;
+        return 1;
+}
+
+/*
+ * Compare two forwards, returning non-zero if they are identical or
+ * zero otherwise.
+ */
+int
+forward_equals(const struct Forward *a, const struct Forward *b)
+{
+        if (strcmp_maybe_null(a->listen_host, b->listen_host) == 0)
+                return 0;
+        if (a->listen_port != b->listen_port)
+                return 0;
+        if (strcmp_maybe_null(a->listen_path, b->listen_path) == 0)
+                return 0;
+        if (strcmp_maybe_null(a->connect_host, b->connect_host) == 0)
+                return 0;
+        if (a->connect_port != b->connect_port)
+                return 0;
+        if (strcmp_maybe_null(a->connect_path, b->connect_path) == 0)
+                return 0;
+        /* allocated_port and handle are not checked */
+        return 1;
+}
+