Merge from vendor branch OPENSSH:
authorScott Ullrich <geekgod@dragonflybsd.org>
Sat, 31 Jul 2004 19:03:00 +0000 (19:03 +0000)
committerScott Ullrich <geekgod@dragonflybsd.org>
Sat, 31 Jul 2004 19:03:00 +0000 (19:03 +0000)
Import OpenSSH 3.8.1.p1 into base.

Patch-submitted-by: Simon 'corecode' Schubert
Reviewed-by: Chris Pressey
Parts-obtained-from: FreeBSD

57 files changed:
crypto/openssh-3.8.1p1/openbsd-compat/base64.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/base64.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/basename.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bindresvport.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-arc4random.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-cray.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-cray.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-cygwin_util.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-cygwin_util.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-getpeereid.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-misc.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-misc.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-nextstep.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-nextstep.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-openpty.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-snprintf.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-waitpid.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/bsd-waitpid.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/daemon.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/dirname.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/fake-rfc2553.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/fake-rfc2553.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/getcwd.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/getgrouplist.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/getopt.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/getrrsetbyname.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/getrrsetbyname.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/glob.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/glob.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/inet_aton.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/inet_ntoa.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/inet_ntop.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/mktemp.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/openbsd-compat.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/port-aix.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/port-aix.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/port-irix.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/port-irix.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/readpassphrase.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/readpassphrase.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/realpath.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/rresvport.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/setenv.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/setproctitle.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/sigact.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/sigact.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/strlcat.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/strlcpy.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/strmode.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/strsep.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/strtoul.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/sys-queue.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/sys-tree.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/vis.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/vis.h [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/xcrypt.c [new file with mode: 0644]
crypto/openssh-3.8.1p1/openbsd-compat/xmmap.c [new file with mode: 0644]

diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/base64.c b/crypto/openssh-3.8.1p1/openbsd-compat/base64.c
new file mode 100644 (file)
index 0000000..dcaa03e
--- /dev/null
@@ -0,0 +1,324 @@
+/* OPENBSD ORIGINAL: lib/libc/net/base64.c */
+
+/*     $OpenBSD: base64.c,v 1.4 2002/01/02 23:00:10 deraadt Exp $      */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+/*
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include "includes.h"
+
+#if (!defined(HAVE_B64_NTOP) && !defined(HAVE___B64_NTOP)) || (!defined(HAVE_B64_PTON) && !defined(HAVE___B64_PTON))
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <ctype.h>
+#include <stdio.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "base64.h"
+
+/* XXX abort illegal in library */
+#define Assert(Cond) if (!(Cond)) abort()
+
+static const char Base64[] =
+       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static const char Pad64 = '=';
+
+/* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
+   The following encoding technique is taken from RFC 1521 by Borenstein
+   and Freed.  It is reproduced here in a slightly edited form for
+   convenience.
+
+   A 65-character subset of US-ASCII is used, enabling 6 bits to be
+   represented per printable character. (The extra 65th character, "=",
+   is used to signify a special processing function.)
+
+   The encoding process represents 24-bit groups of input bits as output
+   strings of 4 encoded characters. Proceeding from left to right, a
+   24-bit input group is formed by concatenating 3 8-bit input groups.
+   These 24 bits are then treated as 4 concatenated 6-bit groups, each
+   of which is translated into a single digit in the base64 alphabet.
+
+   Each 6-bit group is used as an index into an array of 64 printable
+   characters. The character referenced by the index is placed in the
+   output string.
+
+                         Table 1: The Base64 Alphabet
+
+      Value Encoding  Value Encoding  Value Encoding  Value Encoding
+          0 A            17 R            34 i            51 z
+          1 B            18 S            35 j            52 0
+          2 C            19 T            36 k            53 1
+          3 D            20 U            37 l            54 2
+          4 E            21 V            38 m            55 3
+          5 F            22 W            39 n            56 4
+          6 G            23 X            40 o            57 5
+          7 H            24 Y            41 p            58 6
+          8 I            25 Z            42 q            59 7
+          9 J            26 a            43 r            60 8
+         10 K            27 b            44 s            61 9
+         11 L            28 c            45 t            62 +
+         12 M            29 d            46 u            63 /
+         13 N            30 e            47 v
+         14 O            31 f            48 w         (pad) =
+         15 P            32 g            49 x
+         16 Q            33 h            50 y
+
+   Special processing is performed if fewer than 24 bits are available
+   at the end of the data being encoded.  A full encoding quantum is
+   always completed at the end of a quantity.  When fewer than 24 input
+   bits are available in an input group, zero bits are added (on the
+   right) to form an integral number of 6-bit groups.  Padding at the
+   end of the data is performed using the '=' character.
+
+   Since all base64 input is an integral number of octets, only the
+         -------------------------------------------------                       
+   following cases can arise:
+   
+       (1) the final quantum of encoding input is an integral
+           multiple of 24 bits; here, the final unit of encoded
+          output will be an integral multiple of 4 characters
+          with no "=" padding,
+       (2) the final quantum of encoding input is exactly 8 bits;
+           here, the final unit of encoded output will be two
+          characters followed by two "=" padding characters, or
+       (3) the final quantum of encoding input is exactly 16 bits;
+           here, the final unit of encoded output will be three
+          characters followed by one "=" padding character.
+   */
+
+#if !defined(HAVE_B64_NTOP) && !defined(HAVE___B64_NTOP) 
+int
+b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize)
+{
+       size_t datalength = 0;
+       u_char input[3];
+       u_char output[4];
+       int i;
+
+       while (2 < srclength) {
+               input[0] = *src++;
+               input[1] = *src++;
+               input[2] = *src++;
+               srclength -= 3;
+
+               output[0] = input[0] >> 2;
+               output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+               output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+               output[3] = input[2] & 0x3f;
+               Assert(output[0] < 64);
+               Assert(output[1] < 64);
+               Assert(output[2] < 64);
+               Assert(output[3] < 64);
+
+               if (datalength + 4 > targsize)
+                       return (-1);
+               target[datalength++] = Base64[output[0]];
+               target[datalength++] = Base64[output[1]];
+               target[datalength++] = Base64[output[2]];
+               target[datalength++] = Base64[output[3]];
+       }
+    
+       /* Now we worry about padding. */
+       if (0 != srclength) {
+               /* Get what's left. */
+               input[0] = input[1] = input[2] = '\0';
+               for (i = 0; i < srclength; i++)
+                       input[i] = *src++;
+       
+               output[0] = input[0] >> 2;
+               output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
+               output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
+               Assert(output[0] < 64);
+               Assert(output[1] < 64);
+               Assert(output[2] < 64);
+
+               if (datalength + 4 > targsize)
+                       return (-1);
+               target[datalength++] = Base64[output[0]];
+               target[datalength++] = Base64[output[1]];
+               if (srclength == 1)
+                       target[datalength++] = Pad64;
+               else
+                       target[datalength++] = Base64[output[2]];
+               target[datalength++] = Pad64;
+       }
+       if (datalength >= targsize)
+               return (-1);
+       target[datalength] = '\0';      /* Returned value doesn't count \0. */
+       return (datalength);
+}
+#endif /* !defined(HAVE_B64_NTOP) && !defined(HAVE___B64_NTOP) */
+
+#if !defined(HAVE_B64_PTON) && !defined(HAVE___B64_PTON)
+
+/* skips all whitespace anywhere.
+   converts characters, four at a time, starting at (or after)
+   src from base - 64 numbers into three 8 bit bytes in the target area.
+   it returns the number of data bytes stored at the target, or -1 on error.
+ */
+
+int
+b64_pton(char const *src, u_char *target, size_t targsize)
+{
+       int tarindex, state, ch;
+       char *pos;
+
+       state = 0;
+       tarindex = 0;
+
+       while ((ch = *src++) != '\0') {
+               if (isspace(ch))        /* Skip whitespace anywhere. */
+                       continue;
+
+               if (ch == Pad64)
+                       break;
+
+               pos = strchr(Base64, ch);
+               if (pos == 0)           /* A non-base64 character. */
+                       return (-1);
+
+               switch (state) {
+               case 0:
+                       if (target) {
+                               if (tarindex >= targsize)
+                                       return (-1);
+                               target[tarindex] = (pos - Base64) << 2;
+                       }
+                       state = 1;
+                       break;
+               case 1:
+                       if (target) {
+                               if (tarindex + 1 >= targsize)
+                                       return (-1);
+                               target[tarindex]   |=  (pos - Base64) >> 4;
+                               target[tarindex+1]  = ((pos - Base64) & 0x0f)
+                                                       << 4 ;
+                       }
+                       tarindex++;
+                       state = 2;
+                       break;
+               case 2:
+                       if (target) {
+                               if (tarindex + 1 >= targsize)
+                                       return (-1);
+                               target[tarindex]   |=  (pos - Base64) >> 2;
+                               target[tarindex+1]  = ((pos - Base64) & 0x03)
+                                                       << 6;
+                       }
+                       tarindex++;
+                       state = 3;
+                       break;
+               case 3:
+                       if (target) {
+                               if (tarindex >= targsize)
+                                       return (-1);
+                               target[tarindex] |= (pos - Base64);
+                       }
+                       tarindex++;
+                       state = 0;
+                       break;
+               }
+       }
+
+       /*
+        * We are done decoding Base-64 chars.  Let's see if we ended
+        * on a byte boundary, and/or with erroneous trailing characters.
+        */
+
+       if (ch == Pad64) {              /* We got a pad char. */
+               ch = *src++;            /* Skip it, get next. */
+               switch (state) {
+               case 0:         /* Invalid = in first position */
+               case 1:         /* Invalid = in second position */
+                       return (-1);
+
+               case 2:         /* Valid, means one byte of info */
+                       /* Skip any number of spaces. */
+                       for (; ch != '\0'; ch = *src++)
+                               if (!isspace(ch))
+                                       break;
+                       /* Make sure there is another trailing = sign. */
+                       if (ch != Pad64)
+                               return (-1);
+                       ch = *src++;            /* Skip the = */
+                       /* Fall through to "single trailing =" case. */
+                       /* FALLTHROUGH */
+
+               case 3:         /* Valid, means two bytes of info */
+                       /*
+                        * We know this char is an =.  Is there anything but
+                        * whitespace after it?
+                        */
+                       for (; ch != '\0'; ch = *src++)
+                               if (!isspace(ch))
+                                       return (-1);
+
+                       /*
+                        * Now make sure for cases 2 and 3 that the "extra"
+                        * bits that slopped past the last full byte were
+                        * zeros.  If we don't check them, they become a
+                        * subliminal channel.
+                        */
+                       if (target && target[tarindex] != 0)
+                               return (-1);
+               }
+       } else {
+               /*
+                * We ended by seeing the end of the string.  Make sure we
+                * have no partial bytes lying around.
+                */
+               if (state != 0)
+                       return (-1);
+       }
+
+       return (tarindex);
+}
+
+#endif /* !defined(HAVE_B64_PTON) && !defined(HAVE___B64_PTON) */
+#endif 
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/base64.h b/crypto/openssh-3.8.1p1/openbsd-compat/base64.h
new file mode 100644 (file)
index 0000000..732c6b3
--- /dev/null
@@ -0,0 +1,65 @@
+/* $Id: base64.h,v 1.6 2003/08/29 16:59:52 mouring Exp $ */
+
+/*
+ * Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+/*
+ * Portions Copyright (c) 1995 by International Business Machines, Inc.
+ *
+ * International Business Machines, Inc. (hereinafter called IBM) grants
+ * permission under its copyrights to use, copy, modify, and distribute this
+ * Software with or without fee, provided that the above copyright notice and
+ * all paragraphs of this notice appear in all copies, and that the name of IBM
+ * not be used in connection with the marketing of any product incorporating
+ * the Software or modifications thereof, without specific, written prior
+ * permission.
+ *
+ * To the extent it has a right to do so, IBM grants an immunity from suit
+ * under its patents, if any, for the use, sale or manufacture of products to
+ * the extent that such products are used for performing Domain Name System
+ * dynamic updates in TCP/IP networks by means of the Software.  No immunity is
+ * granted for any product per se or for any other function of any product.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE.  IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL,
+ * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN
+ * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#ifndef _BSD_BASE64_H
+#define _BSD_BASE64_H
+
+#include "includes.h"
+
+#ifndef HAVE___B64_NTOP
+# ifndef HAVE_B64_NTOP
+int b64_ntop(u_char const *src, size_t srclength, char *target, 
+    size_t targsize);
+# endif /* !HAVE_B64_NTOP */
+# define __b64_ntop(a,b,c,d) b64_ntop(a,b,c,d)
+#endif /* HAVE___B64_NTOP */
+
+#ifndef HAVE___B64_PTON
+# ifndef HAVE_B64_PTON
+int b64_pton(char const *src, u_char *target, size_t targsize);
+# endif /* !HAVE_B64_PTON */
+# define __b64_pton(a,b,c) b64_pton(a,b,c)
+#endif /* HAVE___B64_PTON */
+
+#endif /* _BSD_BASE64_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/basename.c b/crypto/openssh-3.8.1p1/openbsd-compat/basename.c
new file mode 100644 (file)
index 0000000..552dc1e
--- /dev/null
@@ -0,0 +1,64 @@
+/* OPENBSD ORIGINAL: lib/libc/gen/basename.c */
+
+/*     $OpenBSD: basename.c,v 1.11 2003/06/17 21:56:23 millert Exp $   */
+
+/*
+ * Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "includes.h"
+#ifndef HAVE_BASENAME
+
+#ifndef lint
+static char rcsid[] = "$OpenBSD: basename.c,v 1.11 2003/06/17 21:56:23 millert Exp $";
+#endif /* not lint */
+
+char *
+basename(const char *path)
+{
+       static char bname[MAXPATHLEN];
+       register const char *endp, *startp;
+
+       /* Empty or NULL string gets treated as "." */
+       if (path == NULL || *path == '\0') {
+               (void)strlcpy(bname, ".", sizeof bname);
+               return(bname);
+       }
+
+       /* Strip trailing slashes */
+       endp = path + strlen(path) - 1;
+       while (endp > path && *endp == '/')
+               endp--;
+
+       /* All slashes become "/" */
+       if (endp == path && *endp == '/') {
+               (void)strlcpy(bname, "/", sizeof bname);
+               return(bname);
+       }
+
+       /* Find the start of the base */
+       startp = endp;
+       while (startp > path && *(startp - 1) != '/')
+               startp--;
+
+       if (endp - startp + 2 > sizeof(bname)) {
+               errno = ENAMETOOLONG;
+               return(NULL);
+       }
+       strlcpy(bname, startp, endp - startp + 2);
+       return(bname);
+}
+
+#endif /* !defined(HAVE_BASENAME) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bindresvport.c b/crypto/openssh-3.8.1p1/openbsd-compat/bindresvport.c
new file mode 100644 (file)
index 0000000..8a273f9
--- /dev/null
@@ -0,0 +1,112 @@
+/* This file has be substantially modified from the original OpenBSD source */
+
+/*     $OpenBSD: bindresvport.c,v 1.15 2003/05/20 22:42:35 deraadt Exp $       */
+
+/*
+ * Copyright 1996, Jason Downs.  All rights reserved.
+ * Copyright 1998, Theo de Raadt.  All rights reserved.
+ * Copyright 2000, Damien Miller.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#ifndef HAVE_BINDRESVPORT_SA
+
+#include "includes.h"
+
+#define STARTPORT 600
+#define ENDPORT (IPPORT_RESERVED - 1)
+#define NPORTS (ENDPORT - STARTPORT + 1)
+
+/*
+ * Bind a socket to a privileged IP port
+ */
+int
+bindresvport_sa(sd, sa)
+       int sd;
+       struct sockaddr *sa;
+{
+       int error, af;
+       struct sockaddr_storage myaddr;
+       struct sockaddr_in *sin;
+       struct sockaddr_in6 *sin6;
+       u_int16_t *portp;
+       u_int16_t port;
+       socklen_t salen;
+       int i;
+
+       if (sa == NULL) {
+               memset(&myaddr, 0, sizeof(myaddr));
+               sa = (struct sockaddr *)&myaddr;
+
+               if (getsockname(sd, sa, &salen) == -1)
+                       return -1;      /* errno is correctly set */
+
+               af = sa->sa_family;
+               memset(&myaddr, 0, salen);
+       } else
+               af = sa->sa_family;
+
+       if (af == AF_INET) {
+               sin = (struct sockaddr_in *)sa;
+               salen = sizeof(struct sockaddr_in);
+               portp = &sin->sin_port;
+       } else if (af == AF_INET6) {
+               sin6 = (struct sockaddr_in6 *)sa;
+               salen = sizeof(struct sockaddr_in6);
+               portp = &sin6->sin6_port;
+       } else {
+               errno = EPFNOSUPPORT;
+               return (-1);
+       }
+       sa->sa_family = af;
+
+       port = ntohs(*portp);
+       if (port == 0)
+               port = (arc4random() % NPORTS) + STARTPORT;
+
+       /* Avoid warning */
+       error = -1;
+
+       for(i = 0; i < NPORTS; i++) {
+               *portp = htons(port);
+               
+               error = bind(sd, sa, salen);
+
+               /* Terminate on success */
+               if (error == 0)
+                       break;
+                       
+               /* Terminate on errors, except "address already in use" */
+               if ((error < 0) && !((errno == EADDRINUSE) || (errno == EINVAL)))
+                       break;
+                       
+               port++;
+               if (port > ENDPORT)
+                       port = STARTPORT;
+       }
+
+       return (error);
+}
+
+#endif /* HAVE_BINDRESVPORT_SA */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-arc4random.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-arc4random.c
new file mode 100644 (file)
index 0000000..22003ff
--- /dev/null
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 1999,2000,2004 Damien Miller <djm@mindrot.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "includes.h"
+#include "log.h"
+
+RCSID("$Id: bsd-arc4random.c,v 1.8 2004/02/17 05:49:55 djm Exp $");
+
+#ifndef HAVE_ARC4RANDOM
+
+#include <openssl/rand.h>
+#include <openssl/rc4.h>
+#include <openssl/err.h>
+
+/* Size of key to use */
+#define SEED_SIZE 20
+
+/* Number of bytes to reseed after */
+#define REKEY_BYTES    (1 << 24)
+
+static int rc4_ready = 0;
+static RC4_KEY rc4;
+
+unsigned int arc4random(void)
+{
+       unsigned int r = 0;
+       static int first_time = 1;
+
+       if (rc4_ready <= 0) {
+               if (first_time)
+                       seed_rng();
+               first_time = 0;
+               arc4random_stir();
+       }
+
+       RC4(&rc4, sizeof(r), (unsigned char *)&r, (unsigned char *)&r);
+
+       rc4_ready -= sizeof(r);
+       
+       return(r);
+}
+
+void arc4random_stir(void)
+{
+       unsigned char rand_buf[SEED_SIZE];
+
+       memset(&rc4, 0, sizeof(rc4));
+       if (RAND_bytes(rand_buf, sizeof(rand_buf)) <= 0)
+               fatal("Couldn't obtain random bytes (error %ld)",
+                   ERR_get_error());
+       RC4_set_key(&rc4, sizeof(rand_buf), rand_buf);
+       RC4(&rc4, sizeof(rand_buf), rand_buf, rand_buf);
+       memset(rand_buf, 0, sizeof(rand_buf));
+
+       rc4_ready = REKEY_BYTES;
+}
+#endif /* !HAVE_ARC4RANDOM */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cray.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cray.c
new file mode 100644 (file)
index 0000000..f630366
--- /dev/null
@@ -0,0 +1,816 @@
+/* 
+ * $Id: bsd-cray.c,v 1.13 2004/01/30 03:34:22 dtucker Exp $
+ *
+ * bsd-cray.c
+ *
+ * Copyright (c) 2002, Cray Inc.  (Wendy Palm <wendyp@cray.com>)
+ * Significant portions provided by 
+ *          Wayne Schroeder, SDSC <schroeder@sdsc.edu>
+ *          William Jones, UTexas <jones@tacc.utexas.edu>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Created: Apr 22 16.34:00 2002 wp
+ *
+ * This file contains functions required for proper execution
+ * on UNICOS systems.
+ *
+ */
+#ifdef _UNICOS
+
+#include <udb.h>
+#include <tmpdir.h>
+#include <unistd.h>
+#include <sys/category.h>
+#include <utmp.h>
+#include <sys/jtab.h>
+#include <signal.h>
+#include <sys/priv.h>
+#include <sys/secparm.h>
+#include <sys/tfm.h>
+#include <sys/usrv.h>
+#include <sys/sysv.h>
+#include <sys/sectab.h>
+#include <sys/secstat.h>
+#include <sys/stat.h>
+#include <sys/session.h>
+#include <stdlib.h>
+#include <pwd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ia.h>
+#include <urm.h>
+#include "ssh.h"
+
+#include "includes.h"
+#include "sys/types.h"
+
+#ifndef HAVE_STRUCT_SOCKADDR_STORAGE
+# define      _SS_MAXSIZE     128     /* Implementation specific max size */
+# define       _SS_PADSIZE     (_SS_MAXSIZE - sizeof (struct sockaddr))
+
+# define ss_family ss_sa.sa_family
+#endif /* !HAVE_STRUCT_SOCKADDR_STORAGE */
+
+#ifndef IN6_IS_ADDR_LOOPBACK
+# define IN6_IS_ADDR_LOOPBACK(a) \
+       (((u_int32_t *) (a))[0] == 0 && ((u_int32_t *) (a))[1] == 0 && \
+        ((u_int32_t *) (a))[2] == 0 && ((u_int32_t *) (a))[3] == htonl (1))
+#endif /* !IN6_IS_ADDR_LOOPBACK */
+
+#ifndef AF_INET6
+/* Define it to something that should never appear */
+#define AF_INET6 AF_MAX
+#endif
+
+#include "log.h"
+#include "servconf.h"
+#include "bsd-cray.h"
+
+#define MAXACID 80
+
+extern ServerOptions options;
+
+char cray_tmpdir[TPATHSIZ + 1];                    /* job TMPDIR path */
+
+struct sysv sysv;      /* system security structure */
+struct usrv usrv;      /* user security structure */
+
+/*
+ * Functions.
+ */
+void cray_retain_utmp(struct utmp *, int);
+void cray_delete_tmpdir(char *, int, uid_t);
+void cray_init_job(struct passwd *);
+void cray_set_tmpdir(struct utmp *);
+void cray_login_failure(char *, int);
+int cray_setup(uid_t, char *, const char *);
+int cray_access_denied(char *);
+
+void
+cray_login_failure(char *username, int errcode)
+{
+       struct udb *ueptr;              /* UDB pointer for username */
+       ia_failure_t fsent;             /* ia_failure structure */
+       ia_failure_ret_t fret;          /* ia_failure return stuff */
+       struct jtab jtab;               /* job table structure */
+       int jid = 0;                    /* job id */
+
+       if ((jid = getjtab(&jtab)) < 0)
+               debug("cray_login_failure(): getjtab error");
+
+       getsysudb();
+       if ((ueptr = getudbnam(username)) == UDB_NULL)
+               debug("cray_login_failure(): getudbname() returned NULL");
+       endudb();
+
+       memset(&fsent, '\0', sizeof(fsent));
+       fsent.revision = 0;
+       fsent.uname = username;
+       fsent.host = (char *)get_canonical_hostname(options.use_dns);
+       fsent.ttyn = "sshd";
+       fsent.caller = IA_SSHD;
+       fsent.flags = IA_INTERACTIVE;
+       fsent.ueptr = ueptr;
+       fsent.jid = jid;
+       fsent.errcode = errcode;
+       fsent.pwdp = NULL;
+       fsent.exitcode = 0;     /* dont exit in ia_failure() */
+
+       fret.revision = 0;
+       fret.normal = 0;
+
+       /*
+        * Call ia_failure because of an login failure.
+        */
+       ia_failure(&fsent, &fret);
+}
+
+/*
+ *  Cray access denied
+ */
+int
+cray_access_denied(char *username)
+{
+       struct udb *ueptr;              /* UDB pointer for username */
+       int errcode;                    /* IA errorcode */
+
+       errcode = 0;
+       getsysudb();
+       if ((ueptr = getudbnam(username)) == UDB_NULL)
+               debug("cray_login_failure(): getudbname() returned NULL");
+       endudb();
+
+       if (ueptr != NULL && ueptr->ue_disabled)
+               errcode = IA_DISABLED;
+       if (errcode)
+               cray_login_failure(username, errcode);
+
+       return (errcode);
+}
+
+/*
+ * record_failed_login: generic "login failed" interface function
+ */
+void
+record_failed_login(const char *user, const char *ttyname)
+{
+       cray_login_failure((char *)user, IA_UDBERR);
+}
+
+int
+cray_setup (uid_t uid, char *username, const char *command)
+{
+       extern struct udb *getudb();
+       extern char *setlimits();
+
+       int err;                        /* error return */
+       time_t system_time;             /* current system clock */
+       time_t expiration_time;         /* password expiration time */
+       int maxattempts;                /* maximum no. of failed login attempts */
+       int SecureSys;                  /* unicos security flag */
+       int minslevel = 0;              /* system minimum security level */
+       int i, j;
+       int valid_acct = -1;            /* flag for reading valid acct */
+       char acct_name[MAXACID] = { "" }; /* used to read acct name */
+       struct jtab jtab;               /* Job table struct */
+       struct udb ue;                  /* udb entry for logging-in user */
+       struct udb *up;                 /* pointer to UDB entry */
+       struct secstat secinfo;         /* file  security attributes */
+       struct servprov init_info;      /* used for sesscntl() call */
+       int jid;                        /* job ID */
+       int pid;                        /* process ID */
+       char *sr;                       /* status return from setlimits() */
+       char *ttyn = NULL;              /* ttyname or command name*/
+       char hostname[MAXHOSTNAMELEN];
+       /* passwd stuff for ia_user */
+       passwd_t pwdacm, pwddialup, pwdudb, pwdwal, pwddce;
+       ia_user_ret_t uret;             /* stuff returned from ia_user */
+       ia_user_t usent;                /* ia_user main structure */
+       int ia_rcode;                   /* ia_user return code */
+       ia_failure_t fsent;             /* ia_failure structure */
+       ia_failure_ret_t fret;          /* ia_failure return stuff */
+       ia_success_t ssent;             /* ia_success structure */
+       ia_success_ret_t sret;          /* ia_success return stuff */
+       int ia_mlsrcode;                /* ia_mlsuser return code */
+       int secstatrc;                  /* [f]secstat return code */
+
+       if (SecureSys = (int)sysconf(_SC_CRAY_SECURE_SYS)) {
+               getsysv(&sysv, sizeof(struct sysv));
+               minslevel = sysv.sy_minlvl;
+               if (getusrv(&usrv) < 0)
+                       fatal("getusrv() failed, errno = %d", errno);
+       }
+       hostname[0] = '\0';
+       strlcpy(hostname,
+          (char *)get_canonical_hostname(options.use_dns),
+          MAXHOSTNAMELEN);
+       /*
+        *  Fetch user's UDB entry.
+        */
+       getsysudb();
+       if ((up = getudbnam(username)) == UDB_NULL)
+               fatal("cannot fetch user's UDB entry");
+
+       /*
+        *  Prevent any possible fudging so perform a data
+        *  safety check and compare the supplied uid against
+        *  the udb's uid.
+        */
+       if (up->ue_uid != uid)
+               fatal("IA uid missmatch");
+       endudb();
+
+       if ((jid = getjtab(&jtab)) < 0) {
+               debug("getjtab");
+               return(-1);
+       }
+       pid = getpid();
+       ttyn = ttyname(0);
+       if (SecureSys) {
+               if (ttyn != NULL)
+                       secstatrc = secstat(ttyn, &secinfo);
+               else
+                       secstatrc = fsecstat(1, &secinfo);
+
+               if (secstatrc == 0)
+                       debug("[f]secstat() successful");
+               else
+                       fatal("[f]secstat() error, rc = %d", secstatrc);
+       }
+       if ((ttyn == NULL) && ((char *)command != NULL))
+               ttyn = (char *)command;
+       /*
+        *  Initialize all structures to call ia_user
+        */
+       usent.revision = 0;
+       usent.uname = username;
+       usent.host = hostname;
+       usent.ttyn = ttyn;
+       usent.caller = IA_SSHD; 
+       usent.pswdlist = &pwdacm;
+       usent.ueptr = &ue;
+       usent.flags = IA_INTERACTIVE | IA_FFLAG;
+       pwdacm.atype = IA_SECURID;
+       pwdacm.pwdp = NULL;
+       pwdacm.next = &pwdudb;
+
+       pwdudb.atype = IA_UDB;
+       pwdudb.pwdp = NULL;
+       pwdudb.next = &pwddce;
+
+       pwddce.atype = IA_DCE;
+       pwddce.pwdp = NULL;
+       pwddce.next = &pwddialup;
+
+       pwddialup.atype = IA_DIALUP;
+       pwddialup.pwdp = NULL;
+       /* pwddialup.next = &pwdwal; */
+       pwddialup.next = NULL;
+
+       pwdwal.atype = IA_WAL;
+       pwdwal.pwdp = NULL;
+       pwdwal.next = NULL;
+
+       uret.revision = 0;
+       uret.pswd = NULL;
+       uret.normal = 0;
+
+       ia_rcode = ia_user(&usent, &uret);
+       switch (ia_rcode) {
+       /*
+        *  These are acceptable return codes from ia_user()
+        */
+       case IA_UDBWEEK:        /* Password Expires in 1 week */
+               expiration_time = ue.ue_pwage.time + ue.ue_pwage.maxage;
+               printf ("WARNING - your current password will expire %s\n",
+               ctime((const time_t *)&expiration_time));
+               break;
+       case IA_UDBEXPIRED:
+               if (ttyname(0) != NULL) {
+                       /* Force a password change */
+                       printf("Your password has expired; Choose a new one.\n");
+                       execl("/bin/passwd", "passwd", username, 0);
+                       exit(9);
+                       }
+               break;
+       case IA_NORMAL:         /* Normal Return Code */
+               break;
+       case IA_BACKDOOR:
+               /* XXX: can we memset it to zero here so save some of this */
+               strlcpy(ue.ue_name, "root", sizeof(ue.ue_name));
+               strlcpy(ue.ue_dir, "/", sizeof(ue.ue_dir));
+               strlcpy(ue.ue_shell, "/bin/sh", sizeof(ue.ue_shell));
+
+               ue.ue_passwd[0] = '\0';
+               ue.ue_age[0] = '\0';
+               ue.ue_comment[0] = '\0';
+               ue.ue_loghost[0] = '\0';
+               ue.ue_logline[0] = '\0';
+
+               ue.ue_uid = -1;
+               ue.ue_nice[UDBRC_INTER] = 0;
+
+               for (i = 0; i < MAXVIDS; i++)
+                       ue.ue_gids[i] = 0;
+
+               ue.ue_logfails = 0;
+               ue.ue_minlvl = ue.ue_maxlvl = ue.ue_deflvl = minslevel;
+               ue.ue_defcomps = 0;
+               ue.ue_comparts = 0;
+               ue.ue_permits = 0;
+               ue.ue_trap = 0;
+               ue.ue_disabled = 0;
+               ue.ue_logtime = 0;
+               break;
+       case IA_CONSOLE:        /* Superuser not from Console */
+       case IA_TRUSTED:        /* Trusted user */
+               if (options.permit_root_login > PERMIT_NO)
+                       break;  /* Accept root login */
+       default:
+       /*
+        *  These are failed return codes from ia_user()
+        */
+               switch (ia_rcode) 
+               {
+               case IA_BADAUTH:
+                       printf("Bad authorization, access denied.\n");
+                       break;
+               case IA_DISABLED:
+                       printf("Your login has been disabled. Contact the system ");
+                       printf("administrator for assistance.\n");
+                       break;
+               case IA_GETSYSV:
+                       printf("getsysv() failed - errno = %d\n", errno);
+                       break;
+               case IA_MAXLOGS:
+                       printf("Maximum number of failed login attempts exceeded.\n");
+                       printf("Access denied.\n");
+                       break;
+               case IA_UDBPWDNULL:
+                       if (SecureSys)
+                               printf("NULL Password not allowed on MLS systems.\n");
+                       break;
+               default:
+                       break;
+               }
+
+               /*
+                *  Authentication failed.
+                */
+               printf("sshd: Login incorrect, (0%o)\n",
+                   ia_rcode-IA_ERRORCODE);
+
+               /*
+                *  Initialize structure for ia_failure
+                *  which will exit.
+                */
+               fsent.revision = 0;
+               fsent.uname = username;
+               fsent.host = hostname;
+               fsent.ttyn = ttyn;
+               fsent.caller = IA_SSHD;
+               fsent.flags = IA_INTERACTIVE;
+               fsent.ueptr = &ue;
+               fsent.jid = jid;
+               fsent.errcode = ia_rcode;
+               fsent.pwdp = uret.pswd;
+               fsent.exitcode = 1;
+
+               fret.revision = 0;
+               fret.normal = 0;
+
+               /*
+               *  Call ia_failure because of an IA failure.
+               *  There is no return because ia_failure exits.
+               */
+               ia_failure(&fsent, &fret);
+
+               exit(1); 
+       }
+
+       ia_mlsrcode = IA_NORMAL;
+       if (SecureSys) {
+               debug("calling ia_mlsuser()");
+               ia_mlsrcode = ia_mlsuser(&ue, &secinfo, &usrv, NULL, 0);
+       }
+       if (ia_mlsrcode != IA_NORMAL) {
+               printf("sshd: Login incorrect, (0%o)\n",
+                   ia_mlsrcode-IA_ERRORCODE);
+               /*
+                *  Initialize structure for ia_failure
+                *  which will exit.
+                */
+               fsent.revision = 0;
+               fsent.uname = username;
+               fsent.host = hostname;
+               fsent.ttyn = ttyn;
+               fsent.caller = IA_SSHD;
+               fsent.flags = IA_INTERACTIVE;
+               fsent.ueptr = &ue;
+               fsent.jid  = jid;
+               fsent.errcode = ia_mlsrcode;
+               fsent.pwdp = uret.pswd;
+               fsent.exitcode = 1;
+               fret.revision = 0;
+               fret.normal = 0;
+
+               /*
+                *  Call ia_failure because of an IA failure.
+                *  There is no return because ia_failure exits.
+                */
+               ia_failure(&fsent,&fret);
+               exit(1); 
+       }
+
+       /* Provide login status information */
+       if (options.print_lastlog && ue.ue_logtime != 0) {
+               printf("Last successful login was : %.*s ", 19,
+                   (char *)ctime(&ue.ue_logtime));
+
+               if (*ue.ue_loghost != '\0') {
+                       printf("from %.*s\n", sizeof(ue.ue_loghost),
+                           ue.ue_loghost);
+               } else {
+                       printf("on %.*s\n", sizeof(ue.ue_logline),
+                           ue.ue_logline);
+               }
+
+               if (SecureSys && (ue.ue_logfails != 0)) {
+                       printf("  followed by %d failed attempts\n",
+                           ue.ue_logfails);
+               }
+       }
+
+       /*
+        * Call ia_success to process successful I/A.
+        */
+       ssent.revision = 0;
+       ssent.uname = username;
+       ssent.host = hostname;
+       ssent.ttyn = ttyn;
+       ssent.caller = IA_SSHD;
+       ssent.flags = IA_INTERACTIVE;
+       ssent.ueptr = &ue;
+       ssent.jid = jid;
+       ssent.errcode = ia_rcode;
+       ssent.us = NULL;
+       ssent.time = 1; /* Set ue_logtime */
+
+       sret.revision = 0;
+       sret.normal = 0;
+
+       ia_success(&ssent, &sret);
+
+       /*
+        * Query for account, iff > 1 valid acid & askacid permbit
+        */
+       if (((ue.ue_permbits & PERMBITS_ACCTID) ||
+           (ue.ue_acids[0] >= 0) && (ue.ue_acids[1] >= 0)) &&
+           ue.ue_permbits & PERMBITS_ASKACID) {
+               if (ttyname(0) != NULL) {
+                       debug("cray_setup: ttyname true case, %.100s", ttyname);
+                       while (valid_acct == -1) {
+                               printf("Account (? for available accounts)"
+                                   " [%s]: ", acid2nam(ue.ue_acids[0]));
+                               fgets(acct_name, MAXACID, stdin);
+                               switch (acct_name[0]) {
+                               case EOF:
+                                       exit(0);
+                                       break;
+                               case '\0':
+                                       valid_acct = ue.ue_acids[0];
+                                       strlcpy(acct_name, acid2nam(valid_acct), MAXACID);
+                                       break;
+                               case '?':
+                                       /* Print the list 3 wide */
+                                       for (i = 0, j = 0; i < MAXVIDS; i++) {
+                                               if (ue.ue_acids[i] == -1) {
+                                                       printf("\n");
+                                                       break;
+                                               }
+                                               if (++j == 4) {
+                                                       j = 1;
+                                                       printf("\n");
+                                               }
+                                               printf(" %s",
+                                                   acid2nam(ue.ue_acids[i]));
+                                       }
+                                       if (ue.ue_permbits & PERMBITS_ACCTID) {
+                                               printf("\"acctid\" permbit also allows"
+                                                   " you to select any valid "
+                                                   "account name.\n");
+                                       }
+                                       printf("\n");
+                                       break;
+                               default:
+                                       valid_acct = nam2acid(acct_name);
+                                       if (valid_acct == -1) 
+                                               printf(
+                                                   "Account id not found for"
+                                                   " account name \"%s\"\n\n",
+                                                   acct_name);
+                                       break;
+                               }
+                               /*
+                                * If an account was given, search the user's
+                                * acids array to verify they can use this account.
+                                */
+                               if ((valid_acct != -1) &&
+                                   !(ue.ue_permbits & PERMBITS_ACCTID)) {
+                                       for (i = 0; i < MAXVIDS; i++) {
+                                               if (ue.ue_acids[i] == -1)
+                                                       break;
+                                               if (valid_acct == ue.ue_acids[i])
+                                                       break;
+                                       }
+                                       if (i == MAXVIDS ||
+                                           ue.ue_acids[i] == -1) {
+                                               fprintf(stderr, "Cannot set"
+                                                   " account name to "
+                                                   "\"%s\", permission "
+                                                   "denied\n\n", acct_name);
+                                               valid_acct = -1;
+                                       }
+                               }
+                       }
+               } else {
+                       /*
+                        * The client isn't connected to a terminal and can't
+                        * respond to an acid prompt.  Use default acid.
+                        */
+                       debug("cray_setup: ttyname false case, %.100s",
+                           ttyname);
+                       valid_acct = ue.ue_acids[0];
+               }
+       } else {
+               /*
+                * The user doesn't have the askacid permbit set or
+                * only has one valid account to use.
+                */
+               valid_acct = ue.ue_acids[0];
+       }
+       if (acctid(0, valid_acct) < 0) {
+               printf ("Bad account id: %d\n", valid_acct);
+               exit(1);
+       }
+
+       /* 
+        * Now set shares, quotas, limits, including CPU time for the 
+        * (interactive) job and process, and set up permissions 
+        * (for chown etc), etc.
+        */
+       if (setshares(ue.ue_uid, valid_acct, printf, 0, 0)) {
+               printf("Unable to give %d shares to <%s>(%d/%d)\n",
+                   ue.ue_shares, ue.ue_name, ue.ue_uid, valid_acct);
+               exit(1);
+       }
+
+       sr = setlimits(username, C_PROC, pid, UDBRC_INTER);
+       if (sr != NULL) {
+               debug("%.200s", sr);
+               exit(1);
+       }
+       sr = setlimits(username, C_JOB, jid, UDBRC_INTER);
+       if (sr != NULL) {
+               debug("%.200s", sr);
+               exit(1);
+       }
+       /*
+        * Place the service provider information into
+        * the session table (Unicos) or job table (Unicos/mk).
+        * There exist double defines for the job/session table in
+        * unicos/mk (jtab.h) so no need for a compile time switch.
+        */
+       memset(&init_info, '\0', sizeof(init_info));
+       init_info.s_sessinit.si_id = URM_SPT_LOGIN;
+       init_info.s_sessinit.si_pid = getpid();
+       init_info.s_sessinit.si_sid = jid;
+       sesscntl(0, S_SETSERVPO, (int)&init_info);
+
+       /*
+        * Set user and controlling tty security attributes.
+        */
+       if (SecureSys) {
+               if (setusrv(&usrv) == -1) {
+                       debug("setusrv() failed, errno = %d",errno);
+                       exit(1);
+               }
+       }
+
+       return (0);
+}
+
+/*
+ * The rc.* and /etc/sdaemon methods of starting a program on unicos/unicosmk
+ * can have pal privileges that sshd can inherit which
+ * could allow a user to su to root with out a password.
+ * This subroutine clears all privileges.
+ */
+void
+drop_cray_privs()
+{
+#if defined(_SC_CRAY_PRIV_SU)
+       priv_proc_t *privstate;
+       int result;
+       extern int priv_set_proc();
+       extern priv_proc_t *priv_init_proc();
+
+       /*
+        * If ether of theses two flags are not set
+        * then don't allow this version of ssh to run.
+        */
+       if (!sysconf(_SC_CRAY_PRIV_SU))
+               fatal("Not PRIV_SU system.");
+       if (!sysconf(_SC_CRAY_POSIX_PRIV))
+               fatal("Not POSIX_PRIV.");
+
+       debug("Setting MLS labels.");;
+
+       if (sysconf(_SC_CRAY_SECURE_MAC)) {
+               usrv.sv_minlvl = SYSLOW;
+               usrv.sv_actlvl = SYSHIGH;
+               usrv.sv_maxlvl = SYSHIGH;
+       } else {
+               usrv.sv_minlvl = sysv.sy_minlvl;
+               usrv.sv_actlvl = sysv.sy_minlvl;
+               usrv.sv_maxlvl = sysv.sy_maxlvl;
+       }       
+       usrv.sv_actcmp = 0;
+       usrv.sv_valcmp = sysv.sy_valcmp;
+
+       usrv.sv_intcat = TFM_SYSTEM;
+       usrv.sv_valcat |= (TFM_SYSTEM | TFM_SYSFILE);
+
+       if (setusrv(&usrv) < 0) {
+               fatal("%s(%d): setusrv(): %s", __FILE__, __LINE__,
+                   strerror(errno));
+       }
+
+       if ((privstate = priv_init_proc()) != NULL) {
+               result = priv_set_proc(privstate);
+               if (result != 0 ) {
+                       fatal("%s(%d): priv_set_proc(): %s",
+                           __FILE__, __LINE__, strerror(errno));
+               }
+               priv_free_proc(privstate);
+       }
+       debug ("Privileges should be cleared...");
+#else
+       /* XXX: do this differently */
+#      error Cray systems must be run with _SC_CRAY_PRIV_SU on!
+#endif
+}
+
+
+/*
+ *  Retain utmp/wtmp information - used by cray accounting.
+ */
+void
+cray_retain_utmp(struct utmp *ut, int pid)
+{
+       int fd;
+       struct utmp utmp;
+
+       if ((fd = open(UTMP_FILE, O_RDONLY)) != -1) {
+               /* XXX use atomicio */
+               while (read(fd, (char *)&utmp, sizeof(utmp)) == sizeof(utmp)) {
+                       if (pid == utmp.ut_pid) {
+                               ut->ut_jid = utmp.ut_jid;
+                               strncpy(ut->ut_tpath, utmp.ut_tpath, sizeof(utmp.ut_tpath));
+                               strncpy(ut->ut_host, utmp.ut_host, sizeof(utmp.ut_host));
+                               strncpy(ut->ut_name, utmp.ut_name, sizeof(utmp.ut_name));
+                               break;
+                       }
+               }
+               close(fd);
+       } else
+               fatal("Unable to open utmp file");
+}
+
+/*
+ * tmpdir support.
+ */
+
+/*
+ * find and delete jobs tmpdir.
+ */
+void
+cray_delete_tmpdir(char *login, int jid, uid_t uid)
+{
+       static char jtmp[TPATHSIZ];
+       struct stat statbuf;
+       int child, c, wstat;
+
+       for (c = 'a'; c <= 'z'; c++) {
+               snprintf(jtmp, TPATHSIZ, "%s/jtmp.%06d%c", JTMPDIR, jid, c);
+               if (stat(jtmp, &statbuf) == 0 && statbuf.st_uid == uid)
+                       break;
+       }
+
+       if (c > 'z')
+               return;
+
+       if ((child = fork()) == 0) {
+               execl(CLEANTMPCMD, CLEANTMPCMD, login, jtmp, (char *)NULL);
+               fatal("cray_delete_tmpdir: execl of CLEANTMPCMD failed");
+       }
+
+       while (waitpid(child, &wstat, 0) == -1 && errno == EINTR)
+               ;
+}
+
+/*
+ * Remove tmpdir on job termination.
+ */
+void
+cray_job_termination_handler(int sig)
+{
+       int jid;
+       char *login = NULL;
+       struct jtab jtab;
+
+       debug("received signal %d",sig);
+
+       if ((jid = waitjob(&jtab)) == -1 ||
+           (login = uid2nam(jtab.j_uid)) == NULL)
+               return;
+
+       cray_delete_tmpdir(login, jid, jtab.j_uid);
+}
+
+/*
+ * Set job id and create tmpdir directory.
+ */
+void
+cray_init_job(struct passwd *pw)
+{
+       int jid;
+       int c;
+
+       jid = setjob(pw->pw_uid, WJSIGNAL);
+       if (jid < 0)
+               fatal("System call setjob failure");
+
+       for (c = 'a'; c <= 'z'; c++) {
+               snprintf(cray_tmpdir, TPATHSIZ, "%s/jtmp.%06d%c", JTMPDIR, jid, c);
+               if (mkdir(cray_tmpdir, JTMPMODE) != 0)
+                       continue;
+               if (chown(cray_tmpdir,  pw->pw_uid, pw->pw_gid) != 0) {
+                       rmdir(cray_tmpdir);
+                       continue;
+               }
+               break;
+       }
+
+       if (c > 'z')
+               cray_tmpdir[0] = '\0';
+}
+
+void
+cray_set_tmpdir(struct utmp *ut)
+{
+       int jid;
+       struct jtab jbuf;
+
+       if ((jid = getjtab(&jbuf)) < 0)
+               return;
+
+       /*
+        * Set jid and tmpdir in utmp record.
+        */
+       ut->ut_jid = jid;
+       strncpy(ut->ut_tpath, cray_tmpdir, TPATHSIZ);
+}
+#endif /* UNICOS */
+
+#ifdef _UNICOSMP
+#include <pwd.h>
+/*
+ * Set job id and create tmpdir directory.
+ */
+void
+cray_init_job(struct passwd *pw)
+{
+       initrm_silent(pw->pw_uid);
+       return;
+}
+#endif /* _UNICOSMP */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cray.h b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cray.h
new file mode 100644 (file)
index 0000000..de6ba1a
--- /dev/null
@@ -0,0 +1,61 @@
+/* $Id: bsd-cray.h,v 1.11 2004/01/30 03:34:22 dtucker Exp $ */
+
+/*
+ * Copyright (c) 2002, Cray Inc.  (Wendy Palm <wendyp@cray.com>)
+ * Significant portions provided by 
+ *          Wayne Schroeder, SDSC <schroeder@sdsc.edu>
+ *          William Jones, UTexas <jones@tacc.utexas.edu>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Created: Apr 22 16.34:00 2002 wp
+ *
+ * This file contains functions required for proper execution
+ * on UNICOS systems.
+ *
+ */
+
+#ifndef _BSD_CRAY_H
+#define _BSD_CRAY_H
+
+#ifdef _UNICOS
+
+void cray_init_job(struct passwd *);
+void cray_job_termination_handler(int);
+void cray_login_failure(char *, int );
+int cray_access_denied(char *);
+#define CUSTOM_FAILED_LOGIN 1
+void record_failed_login(const char *, const char *);
+extern char cray_tmpdir[];
+
+#ifndef IA_SSHD
+# define IA_SSHD IA_LOGIN
+#endif
+#ifndef MAXHOSTNAMELEN
+# define MAXHOSTNAMELEN  64
+#endif
+#ifndef _CRAYT3E
+# define TIOCGPGRP (tIOC|20)
+#endif
+
+#endif /* UNICOS */
+
+#endif /* _BSD_CRAY_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cygwin_util.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cygwin_util.c
new file mode 100644 (file)
index 0000000..92cdba6
--- /dev/null
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2000, 2001, Corinna Vinschen <vinschen@cygnus.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Created: Sat Sep 02 12:17:00 2000 cv
+ *
+ * This file contains functions for forcing opened file descriptors to
+ * binary mode on Windows systems.
+ */
+
+#include "includes.h"
+
+RCSID("$Id: bsd-cygwin_util.c,v 1.12 2004/04/18 11:15:45 djm Exp $");
+
+#ifdef HAVE_CYGWIN
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/utsname.h>
+#include <sys/vfs.h>
+#include <windows.h>
+#define is_winnt       (GetVersion() < 0x80000000)
+
+#define ntsec_on(c)    ((c) && strstr((c),"ntsec") && !strstr((c),"nontsec"))
+#define ntsec_off(c)   ((c) && strstr((c),"nontsec"))
+#define ntea_on(c)     ((c) && strstr((c),"ntea") && !strstr((c),"nontea"))
+
+#if defined(open) && open == binary_open
+# undef open
+#endif
+#if defined(pipe) && open == binary_pipe
+# undef pipe
+#endif
+
+int 
+binary_open(const char *filename, int flags, ...)
+{
+       va_list ap;
+       mode_t mode;
+       
+       va_start(ap, flags);
+       mode = va_arg(ap, mode_t);
+       va_end(ap);
+       return (open(filename, flags | O_BINARY, mode));
+}
+
+int 
+binary_pipe(int fd[2])
+{
+       int ret = pipe(fd);
+
+       if (!ret) {
+               setmode(fd[0], O_BINARY);
+               setmode(fd[1], O_BINARY);
+       }
+       return (ret);
+}
+
+#define HAS_CREATE_TOKEN 1
+#define HAS_NTSEC_BY_DEFAULT 2
+#define HAS_CREATE_TOKEN_WO_NTSEC 3
+
+static int 
+has_capability(int what)
+{
+       static int inited;
+       static int has_create_token;
+       static int has_ntsec_by_default;
+       static int has_create_token_wo_ntsec;
+
+       /* 
+        * has_capability() basically calls uname() and checks if
+        * specific capabilities of Cygwin can be evaluated from that.
+        * This simplifies the calling functions which only have to ask
+        * for a capability using has_capability() instead of having
+        * to figure that out by themselves.
+        */
+       if (!inited) {
+               struct utsname uts;
+               char *c;
+               
+               if (!uname(&uts)) {
+                       int major_high = 0, major_low = 0, minor = 0;
+                       int api_major_version = 0, api_minor_version = 0;
+                       char *c;
+
+                       sscanf(uts.release, "%d.%d.%d", &major_high,
+                           &major_low, &minor);
+                       if ((c = strchr(uts.release, '(')) != NULL) {
+                               sscanf(c + 1, "%d.%d", &api_major_version,
+                                   &api_minor_version);
+                       }
+                       if (major_high > 1 ||
+                           (major_high == 1 && (major_low > 3 ||
+                           (major_low == 3 && minor >= 2))))
+                               has_create_token = 1;
+                       if (api_major_version > 0 || api_minor_version >= 56)
+                               has_ntsec_by_default = 1;
+                       if (major_high > 1 ||
+                           (major_high == 1 && major_low >= 5))
+                               has_create_token_wo_ntsec = 1;
+                       inited = 1;
+               }
+       }
+       switch (what) {
+       case HAS_CREATE_TOKEN:
+               return (has_create_token);
+       case HAS_NTSEC_BY_DEFAULT:
+               return (has_ntsec_by_default);
+       case HAS_CREATE_TOKEN_WO_NTSEC:
+               return (has_create_token_wo_ntsec);
+       }
+       return (0);
+}
+
+int
+check_nt_auth(int pwd_authenticated, struct passwd *pw)
+{
+       /*
+       * The only authentication which is able to change the user
+       * context on NT systems is the password authentication. So
+       * we deny all requsts for changing the user context if another
+       * authentication method is used.
+       *
+       * This doesn't apply to Cygwin versions >= 1.3.2 anymore which
+       * uses the undocumented NtCreateToken() call to create a user
+       * token if the process has the appropriate privileges and if
+       * CYGWIN ntsec setting is on.
+       */
+       static int has_create_token = -1;
+
+       if (pw == NULL)
+               return 0;
+       if (is_winnt) {
+               if (has_create_token < 0) {
+                       char *cygwin = getenv("CYGWIN");
+
+                       has_create_token = 0;
+                       if (has_capability(HAS_CREATE_TOKEN) &&
+                           (ntsec_on(cygwin) ||
+                           (has_capability(HAS_NTSEC_BY_DEFAULT) &&
+                            !ntsec_off(cygwin)) ||
+                            has_capability(HAS_CREATE_TOKEN_WO_NTSEC)))
+                               has_create_token = 1;
+               }
+               if (has_create_token < 1 &&
+                   !pwd_authenticated && geteuid() != pw->pw_uid)
+                       return (0);
+       }
+       return (1);
+}
+
+int
+check_ntsec(const char *filename)
+{
+       char *cygwin;
+       int allow_ntea = 0, allow_ntsec = 0;
+       struct statfs fsstat;
+
+       /* Windows 95/98/ME don't support file system security at all. */
+       if (!is_winnt)
+               return (0);
+
+       /* Evaluate current CYGWIN settings. */
+       cygwin = getenv("CYGWIN");
+       allow_ntea = ntea_on(cygwin);
+       allow_ntsec = ntsec_on(cygwin) ||
+           (has_capability(HAS_NTSEC_BY_DEFAULT) && !ntsec_off(cygwin));
+
+       /*
+        * `ntea' is an emulation of POSIX attributes. It doesn't support
+        * real file level security as ntsec on NTFS file systems does
+        * but it supports FAT filesystems. `ntea' is minimum requirement
+        * for security checks.
+        */
+       if (allow_ntea)
+               return (1);
+
+       /*
+        * Retrieve file system flags. In Cygwin, file system flags are
+        * copied to f_type which has no meaning in Win32 itself.
+        */
+       if (statfs(filename, &fsstat))
+               return (1);
+
+       /*
+        * Only file systems supporting ACLs are able to set permissions.
+        * `ntsec' is the setting in Cygwin which switches using of NTFS
+        * ACLs to support POSIX permissions on files.
+        */
+       if (fsstat.f_type & FS_PERSISTENT_ACLS)
+               return (allow_ntsec);
+
+       return (0);
+}
+
+void
+register_9x_service(void)
+{
+        HINSTANCE kerneldll;
+        DWORD (*RegisterServiceProcess)(DWORD, DWORD);
+
+       /* The service register mechanism in 9x/Me is pretty different from
+        * NT/2K/XP.  In NT/2K/XP we're using a special service starter
+        * application to register and control sshd as service.  This method
+        * doesn't play nicely with 9x/Me.  For that reason we register here
+        * as service when running under 9x/Me.  This function is only called
+        * by the child sshd when it's going to daemonize.
+        */
+       if (is_winnt)
+               return;
+       if (!(kerneldll = LoadLibrary("KERNEL32.DLL")))
+               return;
+       if (!(RegisterServiceProcess = (DWORD (*)(DWORD, DWORD))
+               GetProcAddress(kerneldll, "RegisterServiceProcess")))
+               return;
+       RegisterServiceProcess(0, 1);
+}
+
+#endif /* HAVE_CYGWIN */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cygwin_util.h b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-cygwin_util.h
new file mode 100644 (file)
index 0000000..5ccb0fb
--- /dev/null
@@ -0,0 +1,55 @@
+/* $Id: bsd-cygwin_util.h,v 1.10 2003/08/07 06:28:16 dtucker Exp $ */
+
+/*
+ * Copyright (c) 2000, 2001, Corinna Vinschen <vinschen@cygnus.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Created: Sat Sep 02 12:17:00 2000 cv
+ *
+ * This file contains functions for forcing opened file descriptors to
+ * binary mode on Windows systems.
+ */
+
+#ifndef _BSD_CYGWIN_UTIL_H
+#define _BSD_CYGWIN_UTIL_H
+
+#ifdef HAVE_CYGWIN
+
+#undef ERROR
+#define is_winnt       (GetVersion() < 0x80000000)
+
+#include <windows.h>
+#include <sys/cygwin.h>
+#include <io.h>
+
+int binary_open(const char *, int , ...);
+int binary_pipe(int fd[2]);
+int check_nt_auth(int, struct passwd *);
+int check_ntsec(const char *);
+void register_9x_service(void);
+
+#define open binary_open
+#define pipe binary_pipe
+
+#endif /* HAVE_CYGWIN */
+
+#endif /* _BSD_CYGWIN_UTIL_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-getpeereid.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-getpeereid.c
new file mode 100644 (file)
index 0000000..fe2edad
--- /dev/null
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2002,2004 Damien Miller <djm@mindrot.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "includes.h"
+
+RCSID("$Id: bsd-getpeereid.c,v 1.3 2004/02/17 05:49:55 djm Exp $");
+
+#if !defined(HAVE_GETPEEREID)
+
+#if defined(SO_PEERCRED)
+int
+getpeereid(int s, uid_t *euid, gid_t *gid)
+{
+       struct ucred cred;
+       socklen_t len = sizeof(cred);
+
+       if (getsockopt(s, SOL_SOCKET, SO_PEERCRED, &cred, &len) < 0)
+               return (-1);
+       *euid = cred.uid;
+       *gid = cred.gid;
+
+       return (0);
+}
+#else
+int
+getpeereid(int s, uid_t *euid, gid_t *gid)
+{
+       *euid = geteuid();
+       *gid = getgid();
+
+       return (0);
+}
+#endif /* defined(SO_PEERCRED) */
+
+#endif /* !defined(HAVE_GETPEEREID) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-misc.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-misc.c
new file mode 100644 (file)
index 0000000..7b06786
--- /dev/null
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 1999-2004 Damien Miller <djm@mindrot.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "includes.h"
+#include "xmalloc.h"
+
+RCSID("$Id: bsd-misc.c,v 1.21 2004/02/17 05:49:55 djm Exp $");
+
+/*
+ * NB. duplicate __progname in case it is an alias for argv[0]
+ * Otherwise it may get clobbered by setproctitle()
+ */
+char *ssh_get_progname(char *argv0)
+{
+#ifdef HAVE___PROGNAME
+       extern char *__progname;
+
+       return xstrdup(__progname);
+#else
+       char *p;
+
+       if (argv0 == NULL)
+               return ("unknown");     /* XXX */
+       p = strrchr(argv0, '/');
+       if (p == NULL)
+               p = argv0;
+       else
+               p++;
+
+       return (xstrdup(p));
+#endif
+}
+
+#ifndef HAVE_SETLOGIN
+int setlogin(const char *name)
+{
+       return (0);
+}
+#endif /* !HAVE_SETLOGIN */
+
+#ifndef HAVE_INNETGR
+int innetgr(const char *netgroup, const char *host, 
+            const char *user, const char *domain)
+{
+       return (0);
+}
+#endif /* HAVE_INNETGR */
+
+#if !defined(HAVE_SETEUID) && defined(HAVE_SETREUID)
+int seteuid(uid_t euid)
+{
+       return (setreuid(-1, euid));
+}
+#endif /* !defined(HAVE_SETEUID) && defined(HAVE_SETREUID) */
+
+#if !defined(HAVE_SETEGID) && defined(HAVE_SETRESGID)
+int setegid(uid_t egid)
+{
+       return(setresgid(-1, egid, -1));
+}
+#endif /* !defined(HAVE_SETEGID) && defined(HAVE_SETRESGID) */
+
+#if !defined(HAVE_STRERROR) && defined(HAVE_SYS_ERRLIST) && defined(HAVE_SYS_NERR)
+const char *strerror(int e)
+{
+       extern int sys_nerr;
+       extern char *sys_errlist[];
+       
+       if ((e >= 0) && (e < sys_nerr))
+               return (sys_errlist[e]);
+
+       return ("unlisted error");
+}
+#endif
+
+#ifndef HAVE_UTIMES
+int utimes(char *filename, struct timeval *tvp)
+{
+       struct utimbuf ub;
+
+       ub.actime = tvp[0].tv_sec;
+       ub.modtime = tvp[1].tv_sec;
+       
+       return (utime(filename, &ub));
+}
+#endif 
+
+#ifndef HAVE_TRUNCATE
+int truncate(const char *path, off_t length)
+{
+       int fd, ret, saverrno;
+
+       fd = open(path, O_WRONLY);
+       if (fd < 0)
+               return (-1);
+
+       ret = ftruncate(fd, length);
+       saverrno = errno;
+       close(fd);
+       if (ret == -1)
+               errno = saverrno;
+
+       return(ret);
+}
+#endif /* HAVE_TRUNCATE */
+
+#if !defined(HAVE_SETGROUPS) && defined(SETGROUPS_NOOP)
+/*
+ * Cygwin setgroups should be a noop.
+ */
+int
+setgroups(size_t size, const gid_t *list)
+{
+       return (0);
+}
+#endif 
+
+#if !defined(HAVE_NANOSLEEP) && !defined(HAVE_NSLEEP)
+int nanosleep(const struct timespec *req, struct timespec *rem)
+{
+       int rc, saverrno;
+       extern int errno;
+       struct timeval tstart, tstop, tremain, time2wait;
+
+       TIMESPEC_TO_TIMEVAL(&time2wait, req)
+       (void) gettimeofday(&tstart, NULL);
+       rc = select(0, NULL, NULL, NULL, &time2wait);
+       if (rc == -1) {
+               saverrno = errno;
+               (void) gettimeofday (&tstop, NULL);
+               errno = saverrno;
+               tremain.tv_sec = time2wait.tv_sec - 
+                       (tstop.tv_sec - tstart.tv_sec);
+               tremain.tv_usec = time2wait.tv_usec - 
+                       (tstop.tv_usec - tstart.tv_usec);
+               tremain.tv_sec += tremain.tv_usec / 1000000L;
+               tremain.tv_usec %= 1000000L;
+       } else {
+               tremain.tv_sec = 0;
+               tremain.tv_usec = 0;
+       }
+       TIMEVAL_TO_TIMESPEC(&tremain, rem)
+
+       return(rc);
+}
+#endif
+
+#ifndef HAVE_TCGETPGRP
+pid_t
+tcgetpgrp(int fd)
+{
+       int ctty_pgrp;
+
+       if (ioctl(fd, TIOCGPGRP, &ctty_pgrp) == -1)
+               return(-1);
+       else
+               return(ctty_pgrp);
+}
+#endif /* HAVE_TCGETPGRP */
+
+#ifndef HAVE_TCSENDBREAK
+int
+tcsendbreak(int fd, int duration)
+{
+# if defined(TIOCSBRK) && defined(TIOCCBRK)
+       struct timeval sleepytime;
+
+       sleepytime.tv_sec = 0;
+       sleepytime.tv_usec = 400000;
+       if (ioctl(fd, TIOCSBRK, 0) == -1)
+               return (-1);
+       (void)select(0, 0, 0, 0, &sleepytime);
+       if (ioctl(fd, TIOCCBRK, 0) == -1)
+               return (-1);
+       return (0);
+# else
+       return -1;
+# endif
+}
+#endif /* HAVE_TCSENDBREAK */
+
+mysig_t
+mysignal(int sig, mysig_t act)
+{
+#ifdef HAVE_SIGACTION
+       struct sigaction sa, osa;
+
+       if (sigaction(sig, NULL, &osa) == -1)
+               return (mysig_t) -1;
+       if (osa.sa_handler != act) {
+               memset(&sa, 0, sizeof(sa));
+               sigemptyset(&sa.sa_mask);
+               sa.sa_flags = 0;
+#ifdef SA_INTERRUPT
+               if (sig == SIGALRM)
+                       sa.sa_flags |= SA_INTERRUPT;
+#endif
+               sa.sa_handler = act;
+               if (sigaction(sig, &sa, NULL) == -1)
+                       return (mysig_t) -1;
+       }
+       return (osa.sa_handler);
+#else
+       #undef signal
+       return (signal(sig, act));
+#endif
+}
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-misc.h b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-misc.h
new file mode 100644 (file)
index 0000000..009739b
--- /dev/null
@@ -0,0 +1,102 @@
+/* $Id: bsd-misc.h,v 1.15 2004/03/08 11:59:03 dtucker Exp $ */
+
+/*
+ * Copyright (c) 1999-2004 Damien Miller <djm@mindrot.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _BSD_MISC_H
+#define _BSD_MISC_H
+
+#include "includes.h"
+
+char *ssh_get_progname(char *);
+
+#ifndef HAVE_SETSID
+#define setsid() setpgrp(0, getpid())
+#endif /* !HAVE_SETSID */
+
+#ifndef HAVE_SETENV
+int setenv(const char *, const char *, int);
+#endif /* !HAVE_SETENV */
+
+#ifndef HAVE_SETLOGIN
+int setlogin(const char *);
+#endif /* !HAVE_SETLOGIN */
+
+#ifndef HAVE_INNETGR
+int innetgr(const char *, const char *, const char *, const char *);
+#endif /* HAVE_INNETGR */
+
+#if !defined(HAVE_SETEUID) && defined(HAVE_SETREUID)
+int seteuid(uid_t);
+#endif /* !defined(HAVE_SETEUID) && defined(HAVE_SETREUID) */
+
+#if !defined(HAVE_SETEGID) && defined(HAVE_SETRESGID)
+int setegid(uid_t);
+#endif /* !defined(HAVE_SETEGID) && defined(HAVE_SETRESGID) */
+
+#if !defined(HAVE_STRERROR) && defined(HAVE_SYS_ERRLIST) && defined(HAVE_SYS_NERR)
+const char *strerror(int);
+#endif 
+
+
+#ifndef HAVE_UTIMES
+#ifndef HAVE_STRUCT_TIMEVAL
+struct timeval {
+       long tv_sec;
+       long tv_usec;
+}
+#endif /* HAVE_STRUCT_TIMEVAL */
+
+int utimes(char *, struct timeval *);
+#endif /* HAVE_UTIMES */
+
+#ifndef HAVE_TRUNCATE
+int truncate (const char *, off_t);
+#endif /* HAVE_TRUNCATE */
+
+#if !defined(HAVE_SETGROUPS) && defined(SETGROUPS_NOOP)
+int setgroups(size_t, const gid_t *);
+#endif
+
+#if !defined(HAVE_NANOSLEEP) && !defined(HAVE_NSLEEP)
+#ifndef HAVE_STRUCT_TIMESPEC
+struct timespec {
+       time_t  tv_sec;
+       long    tv_nsec;
+};
+#endif
+int nanosleep(const struct timespec *, struct timespec *);
+#endif
+
+#ifndef HAVE_TCGETPGRP
+pid_t tcgetpgrp(int);
+#endif
+
+#ifndef HAVE_TCSENDBREAK
+int tcsendbreak(int, int);
+#endif
+
+#ifndef HAVE_UNSETENV
+void unsetenv(const char *);
+#endif
+
+/* wrapper for signal interface */
+typedef void (*mysig_t)(int);
+mysig_t mysignal(int sig, mysig_t act);
+
+#define signal(a,b) mysignal(a,b)
+
+#endif /* _BSD_MISC_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-nextstep.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-nextstep.c
new file mode 100644 (file)
index 0000000..bd35a3a
--- /dev/null
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2000,2001 Ben Lindstrom.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+RCSID("$Id: bsd-nextstep.c,v 1.6 2003/06/01 03:23:57 mouring Exp $");
+
+#ifdef HAVE_NEXT
+#include <errno.h>
+#include <sys/wait.h>
+#include "bsd-nextstep.h"
+
+pid_t 
+posix_wait(int *status)
+{
+       union wait statusp;
+       pid_t wait_pid;
+
+       #undef wait                     /* Use NeXT's wait() function */
+       wait_pid = wait(&statusp);
+       if (status)
+               *status = (int) statusp.w_status;
+
+       return (wait_pid);
+}
+
+int
+tcgetattr(int fd, struct termios *t)
+{
+       return (ioctl(fd, TIOCGETA, t));
+}
+
+int
+tcsetattr(int fd, int opt, const struct termios *t)
+{
+       struct termios localterm;
+
+       if (opt & TCSASOFT) {
+               localterm = *t;
+               localterm.c_cflag |= CIGNORE;
+               t = &localterm;
+       }
+       switch (opt & ~TCSASOFT) {
+       case TCSANOW:
+               return (ioctl(fd, TIOCSETA, t));
+       case TCSADRAIN:
+               return (ioctl(fd, TIOCSETAW, t));
+       case TCSAFLUSH:
+               return (ioctl(fd, TIOCSETAF, t));
+       default:
+               errno = EINVAL;
+               return (-1);
+       }
+}
+
+int tcsetpgrp(int fd, pid_t pgrp)
+{
+       return (ioctl(fd, TIOCSPGRP, &pgrp));
+}
+
+speed_t cfgetospeed(const struct termios *t)
+{
+       return (t->c_ospeed);
+}
+
+speed_t cfgetispeed(const struct termios *t)
+{
+       return (t->c_ispeed);
+}
+
+int
+cfsetospeed(struct termios *t,int speed)
+{
+       t->c_ospeed = speed;
+       return (0);
+}
+
+int
+cfsetispeed(struct termios *t, int speed)
+{
+       t->c_ispeed = speed;
+       return (0);
+}
+#endif /* HAVE_NEXT */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-nextstep.h b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-nextstep.h
new file mode 100644 (file)
index 0000000..ca5b4b5
--- /dev/null
@@ -0,0 +1,59 @@
+/* $Id: bsd-nextstep.h,v 1.9 2003/08/29 16:59:52 mouring Exp $ */
+
+/*
+ * Copyright (c) 2000,2001 Ben Lindstrom.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _NEXT_POSIX_H
+#define _NEXT_POSIX_H
+
+#ifdef HAVE_NEXT
+#include <sys/dir.h>
+
+/* NGROUPS_MAX is behind -lposix.  Use the BSD version which is NGROUPS */
+#undef NGROUPS_MAX
+#define NGROUPS_MAX NGROUPS
+
+/* NeXT's readdir() is BSD (struct direct) not POSIX (struct dirent) */
+#define dirent direct
+
+/* Swap out NeXT's BSD wait() for a more POSIX complient one */
+pid_t posix_wait(int *);
+#define wait(a) posix_wait(a)
+
+/* #ifdef wrapped functions that need defining for clean compiling */
+pid_t getppid(void);
+void vhangup(void);
+int innetgr(const char *, const char *, const char *, const char *);
+
+/* TERMCAP */
+int tcgetattr(int, struct termios *);
+int tcsetattr(int, int, const struct termios *);
+int tcsetpgrp(int, pid_t);
+speed_t cfgetospeed(const struct termios *);
+speed_t cfgetispeed(const struct termios *);
+int cfsetospeed(struct termios *, int);
+int cfsetispeed(struct termios *, int);
+#endif /* HAVE_NEXT */
+#endif /* _NEXT_POSIX_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-openpty.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-openpty.c
new file mode 100644 (file)
index 0000000..daf5f8b
--- /dev/null
@@ -0,0 +1,203 @@
+/*
+ * Please note: this implementation of openpty() is far from complete.
+ * it is just enough for portable OpenSSH's needs.
+ */
+
+/*
+ * Copyright (c) 2004 Damien Miller <djm@mindrot.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Author: Tatu Ylonen <ylo@cs.hut.fi>
+ * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
+ *                    All rights reserved
+ * Allocating a pseudo-terminal, and making it the controlling tty.
+ *
+ * As far as I am concerned, the code I have written for this software
+ * can be used freely for any purpose.  Any derived versions of this
+ * software must be clearly marked as such, and if the derived work is
+ * incompatible with the protocol description in the RFC file, it must be
+ * called by a name other than "ssh" or "Secure Shell".
+ */
+
+#include "includes.h"
+#if !defined(HAVE_OPENPTY)
+
+#ifdef HAVE_UTIL_H
+# include <util.h>
+#endif /* HAVE_UTIL_H */
+
+#ifdef HAVE_PTY_H
+# include <pty.h>
+#endif
+#if defined(HAVE_DEV_PTMX) && defined(HAVE_SYS_STROPTS_H)
+# include <sys/stropts.h>
+#endif
+
+#ifndef O_NOCTTY
+#define O_NOCTTY 0
+#endif
+
+int
+openpty(int *amaster, int *aslave, char *name, struct termios *termp,
+   struct winsize *winp)
+{
+#if defined(HAVE__GETPTY)
+       /*
+        * _getpty(3) exists in SGI Irix 4.x, 5.x & 6.x -- it generates more
+        * pty's automagically when needed
+        */
+       char *slave;
+
+       if ((slave = _getpty(amaster, O_RDWR, 0622, 0)) == NULL)
+               return (-1);
+
+       /* Open the slave side. */
+       if ((*aslave = open(slave, O_RDWR | O_NOCTTY)) == -1) {
+               close(*amaster);
+               return (-1);
+       }
+       return (0);
+
+#elif defined(HAVE_DEV_PTMX)
+       /*
+        * This code is used e.g. on Solaris 2.x.  (Note that Solaris 2.3
+        * also has bsd-style ptys, but they simply do not work.)
+        */
+       int ptm;
+       char *pts;
+       mysig_t old_signal;
+
+       if ((ptm = open("/dev/ptmx", O_RDWR | O_NOCTTY)) == -1)
+               return (-1);
+
+       /* XXX: need to close ptm on error? */
+       old_signal = signal(SIGCHLD, SIG_DFL);
+       if (grantpt(ptm) < 0)
+               return (-1);
+       signal(SIGCHLD, old_signal);
+
+       if (unlockpt(ptm) < 0)
+               return (-1);
+
+       if ((pts = ptsname(ptm)) == NULL)
+               return (-1);
+       *amaster = ptm;
+
+       /* Open the slave side. */
+       if ((*aslave = open(pts, O_RDWR | O_NOCTTY)) == -1) {
+               close(*amaster);
+               return (-1);
+       }
+
+#ifndef HAVE_CYGWIN
+       /*
+        * Try to push the appropriate streams modules, as described 
+        * in Solaris pts(7).
+        */
+       ioctl(*aslave, I_PUSH, "ptem");
+       ioctl(*aslave, I_PUSH, "ldterm");
+# ifndef __hpux
+       ioctl(*aslave, I_PUSH, "ttcompat");
+# endif /* __hpux */
+#endif /* HAVE_CYGWIN */
+
+       return (0);
+
+#elif defined(HAVE_DEV_PTS_AND_PTC)
+       /* AIX-style pty code. */
+       const char *ttname;
+
+       if ((*amaster = open("/dev/ptc", O_RDWR | O_NOCTTY)) == -1)
+               return (-1);
+       if ((ttname = ttyname(*amaster)) == NULL)
+               return (-1);
+       if ((*aslave = open(ttname, O_RDWR | O_NOCTTY)) == -1) {
+               close(*amaster);
+               return (-1);
+       }
+       return (0);
+
+#elif defined(_UNICOS)
+       char ptbuf[64], ttbuf[64];
+       int i;
+       int highpty;
+
+       highpty = 128;
+#ifdef _SC_CRAY_NPTY
+       if ((highpty = sysconf(_SC_CRAY_NPTY)) == -1)
+               highpty = 128;
+#endif /* _SC_CRAY_NPTY */
+
+       for (i = 0; i < highpty; i++) {
+               snprintf(ptbuf, sizeof(ptbuf), "/dev/pty/%03d", i);
+               snprintf(ttbuf, sizeof(ttbuf), "/dev/ttyp%03d", i);
+               if ((*amaster = open(ptbuf, O_RDWR|O_NOCTTY)) == -1)
+                       continue;
+               /* Open the slave side. */
+               if ((*aslave = open(ttbuf, O_RDWR|O_NOCTTY)) == -1) {
+                       close(*amaster);
+                       return (-1);
+               }
+               return (0);
+       }
+       return (-1);
+
+#else
+       /* BSD-style pty code. */
+       char ptbuf[64], ttbuf[64];
+       int i;
+       const char *ptymajors = "pqrstuvwxyzabcdefghijklmno"
+           "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+       const char *ptyminors = "0123456789abcdef";
+       int num_minors = strlen(ptyminors);
+       int num_ptys = strlen(ptymajors) * num_minors;
+       struct termios tio;
+
+       for (i = 0; i < num_ptys; i++) {
+               snprintf(ptbuf, sizeof(ptbuf), "/dev/pty%c%c", 
+                   ptymajors[i / num_minors], ptyminors[i % num_minors]);
+               snprintf(ttbuf, sizeof(ttbuf), "/dev/tty%c%c",
+                   ptymajors[i / num_minors], ptyminors[i % num_minors]);
+
+               if ((*amaster = open(ptbuf, O_RDWR | O_NOCTTY)) == -1) {
+                       /* Try SCO style naming */
+                       snprintf(ptbuf, sizeof(ptbuf), "/dev/ptyp%d", i);
+                       snprintf(ttbuf, sizeof(ttbuf), "/dev/ttyp%d", i);
+                       if ((*amaster = open(ptbuf, O_RDWR | O_NOCTTY)) == -1)
+                               continue;
+               }
+
+               /* Open the slave side. */
+               if ((*aslave = open(ttbuf, O_RDWR | O_NOCTTY)) == -1) {
+                       close(*amaster);
+                       return (-1);
+               }
+               /* set tty modes to a sane state for broken clients */
+               if (tcgetattr(*amaster, &tio) != -1) {
+                       tio.c_lflag |= (ECHO | ISIG | ICANON);
+                       tio.c_oflag |= (OPOST | ONLCR);
+                       tio.c_iflag |= ICRNL;
+                       tcsetattr(*amaster, TCSANOW, &tio);
+               }
+
+               return (0);
+       }
+       return (-1);
+#endif
+}
+
+#endif /* !defined(HAVE_OPENPTY) */
+
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-snprintf.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-snprintf.c
new file mode 100644 (file)
index 0000000..e4d8a43
--- /dev/null
@@ -0,0 +1,652 @@
+/*
+ * Copyright Patrick Powell 1995
+ * This code is based on code written by Patrick Powell (papowell@astart.com)
+ * It may be used for any purpose as long as this notice remains intact
+ * on all source code distributions
+ */
+
+/**************************************************************
+ * Original:
+ * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh.  This sort of thing is always nasty do deal with.  Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length.  This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ *
+ * More Recently:
+ *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
+ *  This was ugly.  It is still ugly.  I opted out of floating point
+ *  numbers, but the formatter understands just about everything
+ *  from the normal C string format, at least as far as I can tell from
+ *  the Solaris 2.5 printf(3S) man page.
+ *
+ *  Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
+ *    Ok, added some minimal floating point support, which means this
+ *    probably requires libm on most operating systems.  Don't yet
+ *    support the exponent (e,E) and sigfig (g,G).  Also, fmtint()
+ *    was pretty badly broken, it just wasn't being exercised in ways
+ *    which showed it, so that's been fixed.  Also, formated the code
+ *    to mutt conventions, and removed dead code left over from the
+ *    original.  Also, there is now a builtin-test, just compile with:
+ *           gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
+ *    and run snprintf for results.
+ * 
+ *  Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
+ *    The PGP code was using unsigned hexadecimal formats. 
+ *    Unfortunately, unsigned formats simply didn't work.
+ *
+ *  Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
+ *    The original code assumed that both snprintf() and vsnprintf() were
+ *    missing.  Some systems only have snprintf() but not vsnprintf(), so
+ *    the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
+ *
+ *  Ben Lindstrom <mouring@eviladmin.org> 09/27/00 for OpenSSH
+ *    Welcome to the world of %lld and %qd support.  With other
+ *    long long support.  This is needed for sftp-server to work
+ *    right.
+ *
+ *  Ben Lindstrom <mouring@eviladmin.org> 02/12/01 for OpenSSH
+ *    Removed all hint of VARARGS stuff and banished it to the void,
+ *    and did a bit of KNF style work to make things a bit more
+ *    acceptable.  Consider stealing from mutt or enlightenment.
+ **************************************************************/
+
+#include "includes.h"
+
+RCSID("$Id: bsd-snprintf.c,v 1.7 2003/05/18 14:13:39 djm Exp $");
+
+#if defined(BROKEN_SNPRINTF)           /* For those with broken snprintf() */
+# undef HAVE_SNPRINTF
+# undef HAVE_VSNPRINTF
+#endif
+
+#if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF)
+
+static void 
+dopr(char *buffer, size_t maxlen, const char *format, va_list args);
+
+static void 
+fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value, int flags, 
+    int min, int max);
+
+static void 
+fmtint(char *buffer, size_t *currlen, size_t maxlen, long value, int base, 
+    int min, int max, int flags);
+
+static void 
+fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue, 
+    int min, int max, int flags);
+
+static void
+dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+/* format read states */
+#define DP_S_DEFAULT 0
+#define DP_S_FLAGS   1
+#define DP_S_MIN     2
+#define DP_S_DOT     3
+#define DP_S_MAX     4
+#define DP_S_MOD     5
+#define DP_S_CONV    6
+#define DP_S_DONE    7
+
+/* format flags - Bits */
+#define DP_F_MINUS     (1 << 0)
+#define DP_F_PLUS      (1 << 1)
+#define DP_F_SPACE     (1 << 2)
+#define DP_F_NUM       (1 << 3)
+#define DP_F_ZERO      (1 << 4)
+#define DP_F_UP        (1 << 5)
+#define DP_F_UNSIGNED  (1 << 6)
+
+/* Conversion Flags */
+#define DP_C_SHORT     1
+#define DP_C_LONG      2
+#define DP_C_LDOUBLE   3
+#define DP_C_LONG_LONG 4
+
+#define char_to_int(p) (p - '0')
+#define abs_val(p) (p < 0 ? -p : p)
+
+
+static void 
+dopr(char *buffer, size_t maxlen, const char *format, va_list args)
+{
+       char *strvalue, ch;
+       long value;
+       long double fvalue;
+       int min = 0, max = -1, state = DP_S_DEFAULT, flags = 0, cflags = 0;
+       size_t currlen = 0;
+  
+       ch = *format++;
+
+       while (state != DP_S_DONE) {
+               if ((ch == '\0') || (currlen >= maxlen)) 
+                       state = DP_S_DONE;
+
+               switch(state) {
+               case DP_S_DEFAULT:
+                       if (ch == '%') 
+                               state = DP_S_FLAGS;
+                       else 
+                               dopr_outch(buffer, &currlen, maxlen, ch);
+                       ch = *format++;
+                       break;
+               case DP_S_FLAGS:
+                       switch (ch) {
+                       case '-':
+                               flags |= DP_F_MINUS;
+                               ch = *format++;
+                               break;
+                       case '+':
+                               flags |= DP_F_PLUS;
+                               ch = *format++;
+                               break;
+                       case ' ':
+                               flags |= DP_F_SPACE;
+                               ch = *format++;
+                               break;
+                       case '#':
+                               flags |= DP_F_NUM;
+                               ch = *format++;
+                               break;
+                       case '0':
+                               flags |= DP_F_ZERO;
+                               ch = *format++;
+                               break;
+                       default:
+                               state = DP_S_MIN;
+                               break;
+                       }
+                       break;
+               case DP_S_MIN:
+                       if (isdigit((unsigned char)ch)) {
+                               min = 10 * min + char_to_int (ch);
+                               ch = *format++;
+                       } else if (ch == '*') {
+                               min = va_arg (args, int);
+                               ch = *format++;
+                               state = DP_S_DOT;
+                       } else 
+                               state = DP_S_DOT;
+                       break;
+               case DP_S_DOT:
+                       if (ch == '.') {
+                               state = DP_S_MAX;
+                               ch = *format++;
+                       } else 
+                               state = DP_S_MOD;
+                       break;
+               case DP_S_MAX:
+                       if (isdigit((unsigned char)ch)) {
+                               if (max < 0)
+                                       max = 0;
+                               max = 10 * max + char_to_int(ch);
+                               ch = *format++;
+                       } else if (ch == '*') {
+                               max = va_arg (args, int);
+                               ch = *format++;
+                               state = DP_S_MOD;
+                       } else 
+                               state = DP_S_MOD;
+                       break;
+               case DP_S_MOD:
+                       switch (ch) {
+                       case 'h':
+                               cflags = DP_C_SHORT;
+                               ch = *format++;
+                               break;
+                       case 'l':
+                               cflags = DP_C_LONG;
+                               ch = *format++;
+                               if (ch == 'l') {
+                                       cflags = DP_C_LONG_LONG;
+                                       ch = *format++;
+                               }
+                               break;
+                       case 'q':
+                               cflags = DP_C_LONG_LONG;
+                               ch = *format++;
+                               break;
+                       case 'L':
+                               cflags = DP_C_LDOUBLE;
+                               ch = *format++;
+                               break;
+                       default:
+                               break;
+                       }
+                       state = DP_S_CONV;
+                       break;
+               case DP_S_CONV:
+                       switch (ch) {
+                       case 'd':
+                       case 'i':
+                               if (cflags == DP_C_SHORT) 
+                                       value = va_arg(args, int);
+                               else if (cflags == DP_C_LONG)
+                                       value = va_arg(args, long int);
+                               else if (cflags == DP_C_LONG_LONG)
+                                       value = va_arg (args, long long);
+                               else
+                                       value = va_arg (args, int);
+                               fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
+                               break;
+                       case 'o':
+                               flags |= DP_F_UNSIGNED;
+                               if (cflags == DP_C_SHORT)
+                                       value = va_arg(args, unsigned int);
+                               else if (cflags == DP_C_LONG)
+                                       value = va_arg(args, unsigned long int);
+                               else if (cflags == DP_C_LONG_LONG)
+                                       value = va_arg(args, unsigned long long);
+                               else
+                                       value = va_arg(args, unsigned int);
+                               fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
+                               break;
+                       case 'u':
+                               flags |= DP_F_UNSIGNED;
+                               if (cflags == DP_C_SHORT)
+                                       value = va_arg(args, unsigned int);
+                               else if (cflags == DP_C_LONG)
+                                       value = va_arg(args, unsigned long int);
+                               else if (cflags == DP_C_LONG_LONG)
+                                       value = va_arg(args, unsigned long long);
+                               else
+                                       value = va_arg(args, unsigned int);
+                               fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+                               break;
+                       case 'X':
+                               flags |= DP_F_UP;
+                       case 'x':
+                               flags |= DP_F_UNSIGNED;
+                               if (cflags == DP_C_SHORT)
+                                       value = va_arg(args, unsigned int);
+                               else if (cflags == DP_C_LONG)
+                                       value = va_arg(args, unsigned long int);
+                               else if (cflags == DP_C_LONG_LONG)
+                                       value = va_arg(args, unsigned long long);
+                               else
+                                       value = va_arg(args, unsigned int);
+                               fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
+                               break;
+                       case 'f':
+                               if (cflags == DP_C_LDOUBLE)
+                                       fvalue = va_arg(args, long double);
+                               else
+                                       fvalue = va_arg(args, double);
+                               /* um, floating point? */
+                               fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
+                               break;
+                       case 'E':
+                               flags |= DP_F_UP;
+                       case 'e':
+                               if (cflags == DP_C_LDOUBLE)
+                                       fvalue = va_arg(args, long double);
+                               else
+                                       fvalue = va_arg(args, double);
+                               break;
+                       case 'G':
+                               flags |= DP_F_UP;
+                       case 'g':
+                               if (cflags == DP_C_LDOUBLE)
+                                       fvalue = va_arg(args, long double);
+                               else
+                                       fvalue = va_arg(args, double);
+                               break;
+                       case 'c':
+                               dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
+                               break;
+                       case 's':
+                               strvalue = va_arg(args, char *);
+                               if (max < 0) 
+                                       max = maxlen; /* ie, no max */
+                               fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
+                               break;
+                       case 'p':
+                               strvalue = va_arg(args, void *);
+                               fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
+                               break;
+                       case 'n':
+                               if (cflags == DP_C_SHORT) {
+                                       short int *num;
+                                       num = va_arg(args, short int *);
+                                       *num = currlen;
+                               } else if (cflags == DP_C_LONG) {
+                                       long int *num;
+                                       num = va_arg(args, long int *);
+                                       *num = currlen;
+                               } else if (cflags == DP_C_LONG_LONG) {
+                                       long long *num;
+                                       num = va_arg(args, long long *);
+                                       *num = currlen;
+                               } else {
+                                       int *num;
+                                       num = va_arg(args, int *);
+                                       *num = currlen;
+                               }
+                               break;
+                       case '%':
+                               dopr_outch(buffer, &currlen, maxlen, ch);
+                               break;
+                       case 'w': /* not supported yet, treat as next char */
+                               ch = *format++;
+                               break;
+                       default: /* Unknown, skip */
+                       break;
+                       }
+                       ch = *format++;
+                       state = DP_S_DEFAULT;
+                       flags = cflags = min = 0;
+                       max = -1;
+                       break;
+               case DP_S_DONE:
+                       break;
+               default: /* hmm? */
+                       break; /* some picky compilers need this */
+               }
+       }
+       if (currlen < maxlen - 1) 
+               buffer[currlen] = '\0';
+       else 
+               buffer[maxlen - 1] = '\0';
+}
+
+static void
+fmtstr(char *buffer, size_t *currlen, size_t maxlen,
+    char *value, int flags, int min, int max)
+{
+       int cnt = 0, padlen, strln;     /* amount to pad */
+  
+       if (value == 0) 
+               value = "<NULL>";
+
+       for (strln = 0; value[strln]; ++strln); /* strlen */
+       padlen = min - strln;
+       if (padlen < 0) 
+               padlen = 0;
+       if (flags & DP_F_MINUS) 
+               padlen = -padlen; /* Left Justify */
+
+       while ((padlen > 0) && (cnt < max)) {
+               dopr_outch(buffer, currlen, maxlen, ' ');
+               --padlen;
+               ++cnt;
+       }
+       while (*value && (cnt < max)) {
+               dopr_outch(buffer, currlen, maxlen, *value++);
+               ++cnt;
+       }
+       while ((padlen < 0) && (cnt < max)) {
+               dopr_outch(buffer, currlen, maxlen, ' ');
+               ++padlen;
+               ++cnt;
+       }
+}
+
+/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
+
+static void 
+fmtint(char *buffer, size_t *currlen, size_t maxlen,
+    long value, int base, int min, int max, int flags)
+{
+       unsigned long uvalue;
+       char convert[20];
+       int signvalue = 0, place = 0, caps = 0;
+       int spadlen = 0; /* amount to space pad */
+       int zpadlen = 0; /* amount to zero pad */
+  
+       if (max < 0)
+               max = 0;
+
+       uvalue = value;
+
+       if (!(flags & DP_F_UNSIGNED)) {
+               if (value < 0) {
+                       signvalue = '-';
+                       uvalue = -value;
+               } else if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+                       signvalue = '+';
+               else if (flags & DP_F_SPACE)
+                       signvalue = ' ';
+       }
+  
+       if (flags & DP_F_UP) 
+               caps = 1; /* Should characters be upper case? */
+       do {
+               convert[place++] =
+                   (caps ? "0123456789ABCDEF" : "0123456789abcdef")
+                   [uvalue % (unsigned)base];
+               uvalue = (uvalue / (unsigned)base );
+       } while (uvalue && (place < 20));
+       if (place == 20) 
+               place--;
+       convert[place] = 0;
+
+       zpadlen = max - place;
+       spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
+       if (zpadlen < 0)
+               zpadlen = 0;
+       if (spadlen < 0)
+               spadlen = 0;
+       if (flags & DP_F_ZERO) {
+               zpadlen = MAX(zpadlen, spadlen);
+               spadlen = 0;
+       }
+       if (flags & DP_F_MINUS) 
+               spadlen = -spadlen; /* Left Justifty */
+
+       /* Spaces */
+       while (spadlen > 0) {
+               dopr_outch(buffer, currlen, maxlen, ' ');
+               --spadlen;
+       }
+
+       /* Sign */
+       if (signvalue) 
+               dopr_outch(buffer, currlen, maxlen, signvalue);
+
+       /* Zeros */
+       if (zpadlen > 0) {
+               while (zpadlen > 0) {
+                       dopr_outch(buffer, currlen, maxlen, '0');
+                       --zpadlen;
+               }
+       }
+
+       /* Digits */
+       while (place > 0) 
+               dopr_outch(buffer, currlen, maxlen, convert[--place]);
+  
+       /* Left Justified spaces */
+       while (spadlen < 0) {
+               dopr_outch (buffer, currlen, maxlen, ' ');
+               ++spadlen;
+       }
+}
+
+static long double 
+pow10(int exp)
+{
+       long double result = 1;
+
+       while (exp) {
+               result *= 10;
+               exp--;
+       }
+  
+       return result;
+}
+
+static long 
+round(long double value)
+{
+       long intpart = value;
+
+       value -= intpart;
+       if (value >= 0.5)
+               intpart++;
+
+       return intpart;
+}
+
+static void 
+fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue, 
+      int min, int max, int flags)
+{
+       char iconvert[20], fconvert[20];
+       int signvalue = 0, iplace = 0, fplace = 0;
+       int padlen = 0; /* amount to pad */
+       int zpadlen = 0, caps = 0;
+       long intpart, fracpart;
+       long double ufvalue;
+  
+       /* 
+        * AIX manpage says the default is 0, but Solaris says the default
+        * is 6, and sprintf on AIX defaults to 6
+        */
+       if (max < 0)
+               max = 6;
+
+       ufvalue = abs_val(fvalue);
+
+       if (fvalue < 0)
+               signvalue = '-';
+       else if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+               signvalue = '+';
+       else if (flags & DP_F_SPACE)
+               signvalue = ' ';
+
+       intpart = ufvalue;
+
+       /* 
+        * Sorry, we only support 9 digits past the decimal because of our 
+        * conversion method
+        */
+       if (max > 9)
+               max = 9;
+
+       /* We "cheat" by converting the fractional part to integer by
+        * multiplying by a factor of 10
+        */
+       fracpart = round((pow10 (max)) * (ufvalue - intpart));
+
+       if (fracpart >= pow10 (max)) {
+               intpart++;
+               fracpart -= pow10 (max);
+       }
+
+       /* Convert integer part */
+       do {
+               iconvert[iplace++] =
+                   (caps ? "0123456789ABCDEF" : "0123456789abcdef")
+                   [intpart % 10];
+               intpart = (intpart / 10);
+       } while(intpart && (iplace < 20));
+       if (iplace == 20) 
+               iplace--;
+       iconvert[iplace] = 0;
+
+       /* Convert fractional part */
+       do {
+               fconvert[fplace++] =
+                   (caps ? "0123456789ABCDEF" : "0123456789abcdef")
+                   [fracpart % 10];
+               fracpart = (fracpart / 10);
+       } while(fracpart && (fplace < 20));
+       if (fplace == 20) 
+               fplace--;
+       fconvert[fplace] = 0;
+
+       /* -1 for decimal point, another -1 if we are printing a sign */
+       padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); 
+       zpadlen = max - fplace;
+       if (zpadlen < 0)
+               zpadlen = 0;
+       if (padlen < 0) 
+               padlen = 0;
+       if (flags & DP_F_MINUS) 
+               padlen = -padlen; /* Left Justifty */
+
+       if ((flags & DP_F_ZERO) && (padlen > 0)) {
+               if (signvalue) {
+                       dopr_outch(buffer, currlen, maxlen, signvalue);
+                       --padlen;
+                       signvalue = 0;
+               }
+               while (padlen > 0) {
+                       dopr_outch(buffer, currlen, maxlen, '0');
+                       --padlen;
+               }
+       }
+       while (padlen > 0) {
+               dopr_outch(buffer, currlen, maxlen, ' ');
+               --padlen;
+       }
+       if (signvalue) 
+               dopr_outch(buffer, currlen, maxlen, signvalue);
+
+       while (iplace > 0) 
+               dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
+
+       /*
+        * Decimal point.  This should probably use locale to find the 
+        * correct char to print out.
+        */
+       dopr_outch(buffer, currlen, maxlen, '.');
+
+       while (fplace > 0) 
+               dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
+
+       while (zpadlen > 0) {
+               dopr_outch(buffer, currlen, maxlen, '0');
+               --zpadlen;
+       }
+
+       while (padlen < 0) {
+               dopr_outch(buffer, currlen, maxlen, ' ');
+               ++padlen;
+       }
+}
+
+static void 
+dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
+{
+       if (*currlen < maxlen)
+               buffer[(*currlen)++] = c;
+}
+#endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */
+
+#ifndef HAVE_VSNPRINTF
+int 
+vsnprintf(char *str, size_t count, const char *fmt, va_list args)
+{
+       str[0] = 0;
+       dopr(str, count, fmt, args);
+
+       return(strlen(str));
+}
+#endif /* !HAVE_VSNPRINTF */
+
+#ifndef HAVE_SNPRINTF
+int 
+snprintf(char *str,size_t count,const char *fmt,...)
+{
+       va_list ap;
+
+       va_start(ap, fmt);
+       (void) vsnprintf(str, count, fmt, ap);
+       va_end(ap);
+
+       return(strlen(str));
+}
+
+#endif /* !HAVE_SNPRINTF */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-waitpid.c b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-waitpid.c
new file mode 100644 (file)
index 0000000..93c9ec3
--- /dev/null
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2000 Ben Lindstrom.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+RCSID("$Id: bsd-waitpid.c,v 1.5 2003/06/01 03:23:57 mouring Exp $");
+
+#ifndef HAVE_WAITPID 
+#include <errno.h>
+#include <sys/wait.h>
+#include "bsd-waitpid.h"
+
+pid_t
+waitpid(int pid, int *stat_loc, int options)
+{
+       union wait statusp;
+       pid_t wait_pid;
+
+       if (pid <= 0) {
+               if (pid != -1) {
+                       errno = EINVAL;
+                       return (-1);
+               }
+               /* wait4() wants pid=0 for indiscriminate wait. */
+               pid = 0;
+       }
+        wait_pid = wait4(pid, &statusp, options, NULL);
+       if (stat_loc)
+               *stat_loc = (int) statusp.w_status;            
+
+        return (wait_pid);                               
+}
+
+#endif /* !HAVE_WAITPID */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/bsd-waitpid.h b/crypto/openssh-3.8.1p1/openbsd-compat/bsd-waitpid.h
new file mode 100644 (file)
index 0000000..2d853db
--- /dev/null
@@ -0,0 +1,51 @@
+/* $Id: bsd-waitpid.h,v 1.5 2003/08/29 16:59:52 mouring Exp $ */
+
+/*
+ * Copyright (c) 2000 Ben Lindstrom.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef _BSD_WAITPID_H
+#define _BSD_WAITPID_H
+
+#ifndef HAVE_WAITPID
+/* Clean out any potental issues */
+#undef WIFEXITED
+#undef WIFSTOPPED
+#undef WIFSIGNALED
+
+/* Define required functions to mimic a POSIX look and feel */
+#define _W_INT(w)      (*(int*)&(w))   /* convert union wait to int */
+#define WIFEXITED(w)   (!((_W_INT(w)) & 0377))
+#define WIFSTOPPED(w)  ((_W_INT(w)) & 0100)
+#define WIFSIGNALED(w) (!WIFEXITED(w) && !WIFSTOPPED(w))
+#define WEXITSTATUS(w) (int)(WIFEXITED(w) ? ((_W_INT(w) >> 8) & 0377) : -1)
+#define WTERMSIG(w)    (int)(WIFSIGNALED(w) ? (_W_INT(w) & 0177) : -1)
+#define WCOREFLAG      0x80
+#define WCOREDUMP(w)   ((_W_INT(w)) & WCOREFLAG)
+
+/* Prototype */
+pid_t waitpid(int, int *, int);
+
+#endif /* !HAVE_WAITPID */
+#endif /* _BSD_WAITPID_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/daemon.c b/crypto/openssh-3.8.1p1/openbsd-compat/daemon.c
new file mode 100644 (file)
index 0000000..c0be5ff
--- /dev/null
@@ -0,0 +1,81 @@
+/* OPENBSD ORIGINAL: lib/libc/gen/daemon.c */
+
+/*-
+ * Copyright (c) 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#ifndef HAVE_DAEMON
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: daemon.c,v 1.5 2003/07/15 17:32:41 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+int
+daemon(int nochdir, int noclose)
+{
+       int fd;
+
+       switch (fork()) {
+       case -1:
+               return (-1);
+       case 0:
+#ifdef HAVE_CYGWIN
+               register_9x_service();
+#endif
+               break;
+       default:
+#ifdef HAVE_CYGWIN
+               /*
+                * This sleep avoids a race condition which kills the
+                * child process if parent is started by a NT/W2K service.
+                */
+               sleep(1);
+#endif
+               _exit(0);
+       }
+
+       if (setsid() == -1)
+               return (-1);
+
+       if (!nochdir)
+               (void)chdir("/");
+
+       if (!noclose && (fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
+               (void)dup2(fd, STDIN_FILENO);
+               (void)dup2(fd, STDOUT_FILENO);
+               (void)dup2(fd, STDERR_FILENO);
+               if (fd > 2)
+                       (void)close (fd);
+       }
+       return (0);
+}
+
+#endif /* !HAVE_DAEMON */
+
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/dirname.c b/crypto/openssh-3.8.1p1/openbsd-compat/dirname.c
new file mode 100644 (file)
index 0000000..25ab34d
--- /dev/null
@@ -0,0 +1,70 @@
+/* OPENBSD ORIGINAL: lib/libc/gen/dirname.c */
+
+/*      $OpenBSD: dirname.c,v 1.10 2003/06/17 21:56:23 millert Exp $    */
+
+/*
+ * Copyright (c) 1997 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "includes.h"
+#ifndef HAVE_DIRNAME
+
+#ifndef lint
+static char rcsid[] = "$OpenBSD: dirname.c,v 1.10 2003/06/17 21:56:23 millert Exp $";
+#endif /* not lint */
+
+#include <errno.h>
+#include <string.h>
+#include <sys/param.h>
+
+char *
+dirname(const char *path)
+{
+       static char bname[MAXPATHLEN];
+       register const char *endp;
+
+       /* Empty or NULL string gets treated as "." */
+       if (path == NULL || *path == '\0') {
+               (void)strlcpy(bname, ".", sizeof bname);
+               return(bname);
+       }
+
+       /* Strip trailing slashes */
+       endp = path + strlen(path) - 1;
+       while (endp > path && *endp == '/')
+               endp--;
+
+       /* Find the start of the dir */
+       while (endp > path && *endp != '/')
+               endp--;
+
+       /* Either the dir is "/" or there are no slashes */
+       if (endp == path) {
+               (void)strlcpy(bname, *endp == '/' ? "/" : ".", sizeof bname);
+               return(bname);
+       } else {
+               do {
+                       endp--;
+               } while (endp > path && *endp == '/');
+       }
+
+       if (endp - path + 2 > sizeof(bname)) {
+               errno = ENAMETOOLONG;
+               return(NULL);
+       }
+       strlcpy(bname, path, endp - path + 2);
+       return(bname);
+}
+#endif
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/fake-rfc2553.c b/crypto/openssh-3.8.1p1/openbsd-compat/fake-rfc2553.c
new file mode 100644 (file)
index 0000000..0186b53
--- /dev/null
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2000-2003 Damien Miller.  All rights reserved.
+ * Copyright (C) 1999 WIDE Project.  All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Pseudo-implementation of RFC2553 name / address resolution functions
+ *
+ * But these functions are not implemented correctly. The minimum subset
+ * is implemented for ssh use only. For example, this routine assumes
+ * that ai_family is AF_INET. Don't use it for another purpose.
+ */
+
+#include "includes.h"
+
+RCSID("$Id: fake-rfc2553.c,v 1.5 2003/09/22 02:08:23 dtucker Exp $");
+
+#ifndef HAVE_GETNAMEINFO
+int getnameinfo(const struct sockaddr *sa, size_t salen, char *host, 
+                size_t hostlen, char *serv, size_t servlen, int flags)
+{
+       struct sockaddr_in *sin = (struct sockaddr_in *)sa;
+       struct hostent *hp;
+       char tmpserv[16];
+
+       if (serv != NULL) {
+               snprintf(tmpserv, sizeof(tmpserv), "%d", ntohs(sin->sin_port));
+               if (strlcpy(serv, tmpserv, servlen) >= servlen)
+                       return (EAI_MEMORY);
+       }
+
+       if (host != NULL) {
+               if (flags & NI_NUMERICHOST) {
+                       if (strlcpy(host, inet_ntoa(sin->sin_addr),
+                           hostlen) >= hostlen)
+                               return (EAI_MEMORY);
+                       else
+                               return (0);
+               } else {
+                       hp = gethostbyaddr((char *)&sin->sin_addr, 
+                           sizeof(struct in_addr), AF_INET);
+                       if (hp == NULL)
+                               return (EAI_NODATA);
+                       
+                       if (strlcpy(host, hp->h_name, hostlen) >= hostlen)
+                               return (EAI_MEMORY);
+                       else
+                               return (0);
+               }
+       }
+       return (0);
+}
+#endif /* !HAVE_GETNAMEINFO */
+
+#ifndef HAVE_GAI_STRERROR
+#ifdef HAVE_CONST_GAI_STRERROR_PROTO
+const char *
+#else
+char *
+#endif
+gai_strerror(int err)
+{
+       switch (err) {
+       case EAI_NODATA:
+               return ("no address associated with name");
+       case EAI_MEMORY:
+               return ("memory allocation failure.");
+       case EAI_NONAME:
+               return ("nodename nor servname provided, or not known");
+       default:
+               return ("unknown/invalid error.");
+       }
+}    
+#endif /* !HAVE_GAI_STRERROR */
+
+#ifndef HAVE_FREEADDRINFO
+void
+freeaddrinfo(struct addrinfo *ai)
+{
+       struct addrinfo *next;
+
+       for(; ai != NULL;) {
+               next = ai->ai_next;
+               free(ai);
+               ai = next;
+       }
+}
+#endif /* !HAVE_FREEADDRINFO */
+
+#ifndef HAVE_GETADDRINFO
+static struct
+addrinfo *malloc_ai(int port, u_long addr, const struct addrinfo *hints)
+{
+       struct addrinfo *ai;
+
+       ai = malloc(sizeof(*ai) + sizeof(struct sockaddr_in));
+       if (ai == NULL)
+               return (NULL);
+       
+       memset(ai, '\0', sizeof(*ai) + sizeof(struct sockaddr_in));
+       
+       ai->ai_addr = (struct sockaddr *)(ai + 1);
+       /* XXX -- ssh doesn't use sa_len */
+       ai->ai_addrlen = sizeof(struct sockaddr_in);
+       ai->ai_addr->sa_family = ai->ai_family = AF_INET;
+
+       ((struct sockaddr_in *)(ai)->ai_addr)->sin_port = port;
+       ((struct sockaddr_in *)(ai)->ai_addr)->sin_addr.s_addr = addr;
+       
+       /* XXX: the following is not generally correct, but does what we want */
+       if (hints->ai_socktype)
+               ai->ai_socktype = hints->ai_socktype;
+       else
+               ai->ai_socktype = SOCK_STREAM;
+
+       if (hints->ai_protocol)
+               ai->ai_protocol = hints->ai_protocol;
+
+       return (ai);
+}
+
+int
+getaddrinfo(const char *hostname, const char *servname, 
+    const struct addrinfo *hints, struct addrinfo **res)
+{
+       struct hostent *hp;
+       struct servent *sp;
+       struct in_addr in;
+       int i;
+       long int port;
+       u_long addr;
+
+       port = 0;
+       if (servname != NULL) {
+               char *cp;
+
+               port = strtol(servname, &cp, 10);
+               if (port > 0 && port <= 65535 && *cp == '\0')
+                       port = htons(port);
+               else if ((sp = getservbyname(servname, NULL)) != NULL)
+                       port = sp->s_port;
+               else
+                       port = 0;
+       }
+
+       if (hints && hints->ai_flags & AI_PASSIVE) {
+               addr = htonl(0x00000000);
+               if (hostname && inet_aton(hostname, &in) != 0)
+                       addr = in.s_addr;
+               *res = malloc_ai(port, addr, hints);
+               if (*res == NULL) 
+                       return (EAI_MEMORY);
+               return (0);
+       }
+               
+       if (!hostname) {
+               *res = malloc_ai(port, htonl(0x7f000001), hints);
+               if (*res == NULL) 
+                       return (EAI_MEMORY);
+               return (0);
+       }
+       
+       if (inet_aton(hostname, &in)) {
+               *res = malloc_ai(port, in.s_addr, hints);
+               if (*res == NULL) 
+                       return (EAI_MEMORY);
+               return (0);
+       }
+       
+       /* Don't try DNS if AI_NUMERICHOST is set */
+       if (hints && hints->ai_flags & AI_NUMERICHOST)
+               return (EAI_NONAME);
+       
+       hp = gethostbyname(hostname);
+       if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) {
+               struct addrinfo *cur, *prev;
+
+               cur = prev = *res = NULL;
+               for (i = 0; hp->h_addr_list[i]; i++) {
+                       struct in_addr *in = (struct in_addr *)hp->h_addr_list[i];
+
+                       cur = malloc_ai(port, in->s_addr, hints);
+                       if (cur == NULL) {
+                               if (*res != NULL)
+                                       freeaddrinfo(*res);
+                               return (EAI_MEMORY);
+                       }
+                       if (prev)
+                               prev->ai_next = cur;
+                       else
+                               *res = cur;
+
+                       prev = cur;
+               }
+               return (0);
+       }
+       
+       return (EAI_NODATA);
+}
+#endif /* !HAVE_GETADDRINFO */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/fake-rfc2553.h b/crypto/openssh-3.8.1p1/openbsd-compat/fake-rfc2553.h
new file mode 100644 (file)
index 0000000..baea070
--- /dev/null
@@ -0,0 +1,161 @@
+/* $Id: fake-rfc2553.h,v 1.9 2004/03/10 10:06:33 dtucker Exp $ */
+
+/*
+ * Copyright (C) 2000-2003 Damien Miller.  All rights reserved.
+ * Copyright (C) 1999 WIDE Project.  All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Pseudo-implementation of RFC2553 name / address resolution functions
+ *
+ * But these functions are not implemented correctly. The minimum subset
+ * is implemented for ssh use only. For example, this routine assumes
+ * that ai_family is AF_INET. Don't use it for another purpose.
+ */
+
+#ifndef _FAKE_RFC2553_H
+#define _FAKE_RFC2553_H
+
+#include "includes.h"
+#include "sys/types.h"
+
+/*
+ * First, socket and INET6 related definitions 
+ */
+#ifndef HAVE_STRUCT_SOCKADDR_STORAGE
+# define       _SS_MAXSIZE     128     /* Implementation specific max size */
+# define       _SS_PADSIZE     (_SS_MAXSIZE - sizeof (struct sockaddr))
+struct sockaddr_storage {
+       struct sockaddr ss_sa;
+       char            __ss_pad2[_SS_PADSIZE];
+};
+# define ss_family ss_sa.sa_family
+#endif /* !HAVE_STRUCT_SOCKADDR_STORAGE */
+
+#ifndef IN6_IS_ADDR_LOOPBACK
+# define IN6_IS_ADDR_LOOPBACK(a) \
+       (((u_int32_t *)(a))[0] == 0 && ((u_int32_t *)(a))[1] == 0 && \
+        ((u_int32_t *)(a))[2] == 0 && ((u_int32_t *)(a))[3] == htonl(1))
+#endif /* !IN6_IS_ADDR_LOOPBACK */
+
+#ifndef HAVE_STRUCT_IN6_ADDR
+struct in6_addr {
+       u_int8_t        s6_addr[16];
+};
+#endif /* !HAVE_STRUCT_IN6_ADDR */
+
+#ifndef HAVE_STRUCT_SOCKADDR_IN6
+struct sockaddr_in6 {
+       unsigned short  sin6_family;
+       u_int16_t       sin6_port;
+       u_int32_t       sin6_flowinfo;
+       struct in6_addr sin6_addr;
+};
+#endif /* !HAVE_STRUCT_SOCKADDR_IN6 */
+
+#ifndef AF_INET6
+/* Define it to something that should never appear */
+#define AF_INET6 AF_MAX
+#endif
+
+/*
+ * Next, RFC2553 name / address resolution API
+ */
+
+#ifndef NI_NUMERICHOST
+# define NI_NUMERICHOST    (1)
+#endif
+#ifndef NI_NAMEREQD
+# define NI_NAMEREQD       (1<<1)
+#endif
+#ifndef NI_NUMERICSERV
+# define NI_NUMERICSERV    (1<<2)
+#endif
+
+#ifndef AI_PASSIVE
+# define AI_PASSIVE            (1)
+#endif
+#ifndef AI_CANONNAME
+# define AI_CANONNAME          (1<<1)
+#endif
+#ifndef AI_NUMERICHOST
+# define AI_NUMERICHOST                (1<<2)
+#endif
+
+#ifndef NI_MAXSERV
+# define NI_MAXSERV 32
+#endif /* !NI_MAXSERV */
+#ifndef NI_MAXHOST
+# define NI_MAXHOST 1025
+#endif /* !NI_MAXHOST */
+
+#ifndef EAI_NODATA
+# define EAI_NODATA    1
+# define EAI_MEMORY    2
+# define EAI_NONAME    3
+#endif
+
+#ifndef HAVE_STRUCT_ADDRINFO
+struct addrinfo {
+       int     ai_flags;       /* AI_PASSIVE, AI_CANONNAME */
+       int     ai_family;      /* PF_xxx */
+       int     ai_socktype;    /* SOCK_xxx */
+       int     ai_protocol;    /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
+       size_t  ai_addrlen;     /* length of ai_addr */
+       char    *ai_canonname;  /* canonical name for hostname */
+       struct sockaddr *ai_addr;       /* binary address */
+       struct addrinfo *ai_next;       /* next structure in linked list */
+};
+#endif /* !HAVE_STRUCT_ADDRINFO */
+
+#ifndef HAVE_GETADDRINFO
+#ifdef getaddrinfo
+# undef getaddrinfo
+#endif
+#define getaddrinfo(a,b,c,d)   (ssh_getaddrinfo(a,b,c,d))
+int getaddrinfo(const char *, const char *, 
+    const struct addrinfo *, struct addrinfo **);
+#endif /* !HAVE_GETADDRINFO */
+
+#if !defined(HAVE_GAI_STRERROR) && !defined(HAVE_CONST_GAI_STRERROR_PROTO)
+#define gai_strerror(a)                (ssh_gai_strerror(a))
+char *gai_strerror(int);
+#endif /* !HAVE_GAI_STRERROR */
+
+#ifndef HAVE_FREEADDRINFO
+#define freeaddrinfo(a)                (ssh_freeaddrinfo(a))
+void freeaddrinfo(struct addrinfo *);
+#endif /* !HAVE_FREEADDRINFO */
+
+#ifndef HAVE_GETNAMEINFO
+#define getnameinfo(a,b,c,d,e,f,g) (ssh_getnameinfo(a,b,c,d,e,f,g))
+int getnameinfo(const struct sockaddr *, size_t, char *, size_t, 
+    char *, size_t, int);
+#endif /* !HAVE_GETNAMEINFO */
+
+#endif /* !_FAKE_RFC2553_H */
+
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/getcwd.c b/crypto/openssh-3.8.1p1/openbsd-compat/getcwd.c
new file mode 100644 (file)
index 0000000..19be591
--- /dev/null
@@ -0,0 +1,242 @@
+/* OPENBSD ORIGINAL: lib/libc/gen/getcwd.c */
+
+/*
+ * Copyright (c) 1989, 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#if !defined(HAVE_GETCWD)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: getcwd.c,v 1.9 2003/06/11 21:03:10 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <dirent.h>
+#include <sys/dir.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "includes.h"
+
+#define        ISDOT(dp) \
+       (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' || \
+           (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
+
+char *
+getcwd(char *pt, size_t size)
+{
+       register struct dirent *dp;
+       register DIR *dir = NULL;
+       register dev_t dev;
+       register ino_t ino;
+       register int first;
+       register char *bpt, *bup;
+       struct stat s;
+       dev_t root_dev;
+       ino_t root_ino;
+       size_t ptsize, upsize;
+       int save_errno;
+       char *ept, *eup, *up;
+
+       /*
+        * If no buffer specified by the user, allocate one as necessary.
+        * If a buffer is specified, the size has to be non-zero.  The path
+        * is built from the end of the buffer backwards.
+        */
+       if (pt) {
+               ptsize = 0;
+               if (!size) {
+                       errno = EINVAL;
+                       return (NULL);
+               }
+               ept = pt + size;
+       } else {
+               if ((pt = malloc(ptsize = 1024 - 4)) == NULL)
+                       return (NULL);
+               ept = pt + ptsize;
+       }
+       bpt = ept - 1;
+       *bpt = '\0';
+
+       /*
+        * Allocate bytes (1024 - malloc space) for the string of "../"'s.
+        * Should always be enough (it's 340 levels).  If it's not, allocate
+        * as necessary.  Special * case the first stat, it's ".", not "..".
+        */
+       if ((up = malloc(upsize = 1024 - 4)) == NULL)
+               goto err;
+       eup = up + MAXPATHLEN;
+       bup = up;
+       up[0] = '.';
+       up[1] = '\0';
+
+       /* Save root values, so know when to stop. */
+       if (stat("/", &s))
+               goto err;
+       root_dev = s.st_dev;
+       root_ino = s.st_ino;
+
+       errno = 0;                      /* XXX readdir has no error return. */
+
+       for (first = 1;; first = 0) {
+               /* Stat the current level. */
+               if (lstat(up, &s))
+                       goto err;
+
+               /* Save current node values. */
+               ino = s.st_ino;
+               dev = s.st_dev;
+
+               /* Check for reaching root. */
+               if (root_dev == dev && root_ino == ino) {
+                       *--bpt = '/';
+                       /*
+                        * It's unclear that it's a requirement to copy the
+                        * path to the beginning of the buffer, but it's always
+                        * been that way and stuff would probably break.
+                        */
+                       memmove(pt, bpt, ept - bpt);
+                       free(up);
+                       return (pt);
+               }
+
+               /*
+                * Build pointer to the parent directory, allocating memory
+                * as necessary.  Max length is 3 for "../", the largest
+                * possible component name, plus a trailing NUL.
+                */
+               if (bup + 3  + MAXNAMLEN + 1 >= eup) {
+                       char *nup;
+
+                       if ((nup = realloc(up, upsize *= 2)) == NULL)
+                               goto err;
+                       up = nup;
+                       bup = up;
+                       eup = up + upsize;
+               }
+               *bup++ = '.';
+               *bup++ = '.';
+               *bup = '\0';
+
+               /* Open and stat parent directory. 
+                * RACE?? - replaced fstat(dirfd(dir), &s) w/ lstat(up,&s) 
+                 */
+               if (!(dir = opendir(up)) || lstat(up,&s))
+                       goto err;
+
+               /* Add trailing slash for next directory. */
+               *bup++ = '/';
+
+               /*
+                * If it's a mount point, have to stat each element because
+                * the inode number in the directory is for the entry in the
+                * parent directory, not the inode number of the mounted file.
+                */
+               save_errno = 0;
+               if (s.st_dev == dev) {
+                       for (;;) {
+                               if (!(dp = readdir(dir)))
+                                       goto notfound;
+                               if (dp->d_fileno == ino)
+                                       break;
+                       }
+               } else
+                       for (;;) {
+                               if (!(dp = readdir(dir)))
+                                       goto notfound;
+                               if (ISDOT(dp))
+                                       continue;
+                               memmove(bup, dp->d_name, dp->d_namlen + 1);
+
+                               /* Save the first error for later. */
+                               if (lstat(up, &s)) {
+                                       if (!save_errno)
+                                               save_errno = errno;
+                                       errno = 0;
+                                       continue;
+                               }
+                               if (s.st_dev == dev && s.st_ino == ino)
+                                       break;
+                       }
+
+               /*
+                * Check for length of the current name, preceding slash,
+                * leading slash.
+                */
+               if (bpt - pt < dp->d_namlen + (first ? 1 : 2)) {
+                       size_t len, off;
+                       char *npt;
+
+                       if (!ptsize) {
+                               errno = ERANGE;
+                               goto err;
+                       }
+                       off = bpt - pt;
+                       len = ept - bpt;
+                       if ((npt = realloc(pt, ptsize *= 2)) == NULL)
+                               goto err;
+                       pt = npt;
+                       bpt = pt + off;
+                       ept = pt + ptsize;
+                       memmove(ept - len, bpt, len);
+                       bpt = ept - len;
+               }
+               if (!first)
+                       *--bpt = '/';
+               bpt -= dp->d_namlen;
+               memmove(bpt, dp->d_name, dp->d_namlen);
+               (void)closedir(dir);
+
+               /* Truncate any file name. */
+               *bup = '\0';
+       }
+
+notfound:
+       /*
+        * If readdir set errno, use it, not any saved error; otherwise,
+        * didn't find the current directory in its parent directory, set
+        * errno to ENOENT.
+        */
+       if (!errno)
+               errno = save_errno ? save_errno : ENOENT;
+       /* FALLTHROUGH */
+err:
+       if (ptsize)
+               free(pt);
+       if (up)
+               free(up);
+       if (dir)
+               (void)closedir(dir);
+       return (NULL);
+}
+
+#endif /* !defined(HAVE_GETCWD) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/getgrouplist.c b/crypto/openssh-3.8.1p1/openbsd-compat/getgrouplist.c
new file mode 100644 (file)
index 0000000..59c164f
--- /dev/null
@@ -0,0 +1,102 @@
+/* OPENBSD ORIGINAL: lib/libc/gen/getgrouplist.c */
+
+/*
+ * Copyright (c) 1991, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#ifndef HAVE_GETGROUPLIST
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: getgrouplist.c,v 1.9 2003/06/25 21:16:47 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * get credential
+ */
+#include <sys/types.h>
+#include <string.h>
+#include <unistd.h>
+#include <grp.h>
+
+int
+getgrouplist(uname, agroup, groups, grpcnt)
+       const char *uname;
+       gid_t agroup;
+       register gid_t *groups;
+       int *grpcnt;
+{
+       register struct group *grp;
+       register int i, ngroups;
+       int ret, maxgroups;
+       int bail;
+
+       ret = 0;
+       ngroups = 0;
+       maxgroups = *grpcnt;
+
+       /*
+        * install primary group
+        */
+       if (ngroups >= maxgroups) {
+               *grpcnt = ngroups;
+               return (-1);
+       }
+       groups[ngroups++] = agroup;
+
+       /*
+        * Scan the group file to find additional groups.
+        */
+       setgrent();
+       while ((grp = getgrent())) {
+               if (grp->gr_gid == agroup)
+                       continue;
+               for (bail = 0, i = 0; bail == 0 && i < ngroups; i++)
+                       if (groups[i] == grp->gr_gid)
+                               bail = 1;
+               if (bail)
+                       continue;
+               for (i = 0; grp->gr_mem[i]; i++) {
+                       if (!strcmp(grp->gr_mem[i], uname)) {
+                               if (ngroups >= maxgroups) {
+                                       ret = -1;
+                                       goto out;
+                               }
+                               groups[ngroups++] = grp->gr_gid;
+                               break;
+                       }
+               }
+       }
+out:
+       endgrent();
+       *grpcnt = ngroups;
+       return (ret);
+}
+
+#endif /* HAVE_GETGROUPLIST */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/getopt.c b/crypto/openssh-3.8.1p1/openbsd-compat/getopt.c
new file mode 100644 (file)
index 0000000..f5ee677
--- /dev/null
@@ -0,0 +1,123 @@
+/* OPENBSD ORIGINAL: lib/libc/stdlib/getopt.c */
+
+/*
+ * Copyright (c) 1987, 1993, 1994
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+#if !defined(HAVE_GETOPT) || !defined(HAVE_GETOPT_OPTRESET)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: getopt.c,v 1.5 2003/06/02 20:18:37 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int    BSDopterr = 1,          /* if error message should be printed */
+       BSDoptind = 1,          /* index into parent argv vector */
+       BSDoptopt,              /* character checked for validity */
+       BSDoptreset;            /* reset getopt */
+char   *BSDoptarg;             /* argument associated with option */
+
+#define        BADCH   (int)'?'
+#define        BADARG  (int)':'
+#define        EMSG    ""
+
+/*
+ * getopt --
+ *     Parse argc/argv argument vector.
+ */
+int
+BSDgetopt(nargc, nargv, ostr)
+       int nargc;
+       char * const *nargv;
+       const char *ostr;
+{
+       extern char *__progname;
+       static char *place = EMSG;              /* option letter processing */
+       char *oli;                              /* option letter list index */
+
+       if (ostr == NULL)
+               return (-1);
+
+       if (BSDoptreset || !*place) {           /* update scanning pointer */
+               BSDoptreset = 0;
+               if (BSDoptind >= nargc || *(place = nargv[BSDoptind]) != '-') {
+                       place = EMSG;
+                       return (-1);
+               }
+               if (place[1] && *++place == '-') {      /* found "--" */
+                       ++BSDoptind;
+                       place = EMSG;
+                       return (-1);
+               }
+       }                                       /* option letter okay? */
+       if ((BSDoptopt = (int)*place++) == (int)':' ||
+           !(oli = strchr(ostr, BSDoptopt))) {
+               /*
+                * if the user didn't specify '-' as an option,
+                * assume it means -1.
+                */
+               if (BSDoptopt == (int)'-')
+                       return (-1);
+               if (!*place)
+                       ++BSDoptind;
+               if (BSDopterr && *ostr != ':')
+                       (void)fprintf(stderr,
+                           "%s: illegal option -- %c\n", __progname, BSDoptopt);
+               return (BADCH);
+       }
+       if (*++oli != ':') {                    /* don't need argument */
+               BSDoptarg = NULL;
+               if (!*place)
+                       ++BSDoptind;
+       }
+       else {                                  /* need an argument */
+               if (*place)                     /* no white space */
+                       BSDoptarg = place;
+               else if (nargc <= ++BSDoptind) {        /* no arg */
+                       place = EMSG;
+                       if (*ostr == ':')
+                               return (BADARG);
+                       if (BSDopterr)
+                               (void)fprintf(stderr,
+                                   "%s: option requires an argument -- %c\n",
+                                   __progname, BSDoptopt);
+                       return (BADCH);
+               }
+               else                            /* white space */
+                       BSDoptarg = nargv[BSDoptind];
+               place = EMSG;
+               ++BSDoptind;
+       }
+       return (BSDoptopt);                     /* dump back option letter */
+}
+
+#endif /* !defined(HAVE_GETOPT) || !defined(HAVE_OPTRESET) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/getrrsetbyname.c b/crypto/openssh-3.8.1p1/openbsd-compat/getrrsetbyname.c
new file mode 100644 (file)
index 0000000..66d1814
--- /dev/null
@@ -0,0 +1,577 @@
+/* OPENBSD ORIGINAL: lib/libc/net/getrrsetbyname.c */
+
+/* $OpenBSD: getrrsetbyname.c,v 1.7 2003/03/07 07:34:14 itojun Exp $ */
+
+/*
+ * Copyright (c) 2001 Jakob Schlyter. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Portions Copyright (c) 1999-2001 Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "includes.h"
+
+#ifndef HAVE_GETRRSETBYNAME
+
+#include "getrrsetbyname.h"
+
+#define ANSWER_BUFFER_SIZE 1024*64
+
+struct dns_query {
+       char                    *name;
+       u_int16_t               type;
+       u_int16_t               class;
+       struct dns_query        *next;
+};
+
+struct dns_rr {
+       char                    *name;
+       u_int16_t               type;
+       u_int16_t               class;
+       u_int16_t               ttl;
+       u_int16_t               size;
+       void                    *rdata;
+       struct dns_rr           *next;
+};
+
+struct dns_response {
+       HEADER                  header;
+       struct dns_query        *query;
+       struct dns_rr           *answer;
+       struct dns_rr           *authority;
+       struct dns_rr           *additional;
+};
+
+static struct dns_response *parse_dns_response(const u_char *, int);
+static struct dns_query *parse_dns_qsection(const u_char *, int,
+    const u_char **, int);
+static struct dns_rr *parse_dns_rrsection(const u_char *, int, const u_char **,
+    int);
+
+static void free_dns_query(struct dns_query *);
+static void free_dns_rr(struct dns_rr *);
+static void free_dns_response(struct dns_response *);
+
+static int count_dns_rr(struct dns_rr *, u_int16_t, u_int16_t);
+
+/*
+ * Inline versions of get/put short/long.  Pointer is advanced.
+ *
+ * These macros demonstrate the property of C whereby it can be
+ * portable or it can be elegant but rarely both.
+ */
+
+#ifndef INT32SZ
+# define INT32SZ       4
+#endif
+#ifndef INT16SZ
+# define INT16SZ       2
+#endif
+
+#ifndef GETSHORT
+#define GETSHORT(s, cp) { \
+       register u_char *t_cp = (u_char *)(cp); \
+       (s) = ((u_int16_t)t_cp[0] << 8) \
+           | ((u_int16_t)t_cp[1]) \
+           ; \
+       (cp) += INT16SZ; \
+}
+#endif
+
+#ifndef GETLONG
+#define GETLONG(l, cp) { \
+       register u_char *t_cp = (u_char *)(cp); \
+       (l) = ((u_int32_t)t_cp[0] << 24) \
+           | ((u_int32_t)t_cp[1] << 16) \
+           | ((u_int32_t)t_cp[2] << 8) \
+           | ((u_int32_t)t_cp[3]) \
+           ; \
+       (cp) += INT32SZ; \
+}
+#endif
+
+/*
+ * Routines to insert/extract short/long's.
+ */
+
+#ifndef HAVE__GETSHORT
+static u_int16_t
+_getshort(msgp)
+       register const u_char *msgp;
+{
+       register u_int16_t u;
+
+       GETSHORT(u, msgp);
+       return (u);
+}
+#endif
+
+#ifndef HAVE__GETLONG
+static u_int32_t
+_getlong(msgp)
+       register const u_char *msgp;
+{
+       register u_int32_t u;
+
+       GETLONG(u, msgp);
+       return (u);
+}
+#endif
+
+int
+getrrsetbyname(const char *hostname, unsigned int rdclass,
+    unsigned int rdtype, unsigned int flags,
+    struct rrsetinfo **res)
+{
+       int result;
+       struct rrsetinfo *rrset = NULL;
+       struct dns_response *response;
+       struct dns_rr *rr;
+       struct rdatainfo *rdata;
+       int length;
+       unsigned int index_ans, index_sig;
+       u_char answer[ANSWER_BUFFER_SIZE];
+
+       /* check for invalid class and type */
+       if (rdclass > 0xffff || rdtype > 0xffff) {
+               result = ERRSET_INVAL;
+               goto fail;
+       }
+
+       /* don't allow queries of class or type ANY */
+       if (rdclass == 0xff || rdtype == 0xff) {
+               result = ERRSET_INVAL;
+               goto fail;
+       }
+
+       /* don't allow flags yet, unimplemented */
+       if (flags) {
+               result = ERRSET_INVAL;
+               goto fail;
+       }
+
+       /* initialize resolver */
+       if ((_res.options & RES_INIT) == 0 && res_init() == -1) {
+               result = ERRSET_FAIL;
+               goto fail;
+       }
+
+#ifdef DEBUG
+       _res.options |= RES_DEBUG;
+#endif /* DEBUG */
+
+#ifdef RES_USE_DNSSEC
+       /* turn on DNSSEC if EDNS0 is configured */
+       if (_res.options & RES_USE_EDNS0)
+               _res.options |= RES_USE_DNSSEC;
+#endif /* RES_USE_DNSEC */
+
+       /* make query */
+       length = res_query(hostname, (signed int) rdclass, (signed int) rdtype,
+           answer, sizeof(answer));
+       if (length < 0) {
+               switch(h_errno) {
+               case HOST_NOT_FOUND:
+                       result = ERRSET_NONAME;
+                       goto fail;
+               case NO_DATA:
+                       result = ERRSET_NODATA;
+                       goto fail;
+               default:
+                       result = ERRSET_FAIL;
+                       goto fail;
+               }
+       }
+
+       /* parse result */
+       response = parse_dns_response(answer, length);
+       if (response == NULL) {
+               result = ERRSET_FAIL;
+               goto fail;
+       }
+
+       if (response->header.qdcount != 1) {
+               result = ERRSET_FAIL;
+               goto fail;
+       }
+
+       /* initialize rrset */
+       rrset = calloc(1, sizeof(struct rrsetinfo));
+       if (rrset == NULL) {
+               result = ERRSET_NOMEMORY;
+               goto fail;
+       }
+       rrset->rri_rdclass = response->query->class;
+       rrset->rri_rdtype = response->query->type;
+       rrset->rri_ttl = response->answer->ttl;
+       rrset->rri_nrdatas = response->header.ancount;
+
+#ifdef HAVE_HEADER_AD
+       /* check for authenticated data */
+       if (response->header.ad == 1)
+               rrset->rri_flags |= RRSET_VALIDATED;
+#endif
+
+       /* copy name from answer section */
+       length = strlen(response->answer->name);
+       rrset->rri_name = malloc(length + 1);
+       if (rrset->rri_name == NULL) {
+               result = ERRSET_NOMEMORY;
+               goto fail;
+       }
+       strlcpy(rrset->rri_name, response->answer->name, length + 1);
+
+       /* count answers */
+       rrset->rri_nrdatas = count_dns_rr(response->answer, rrset->rri_rdclass,
+           rrset->rri_rdtype);
+       rrset->rri_nsigs = count_dns_rr(response->answer, rrset->rri_rdclass,
+           T_SIG);
+
+       /* allocate memory for answers */
+       rrset->rri_rdatas = calloc(rrset->rri_nrdatas,
+           sizeof(struct rdatainfo));
+       if (rrset->rri_rdatas == NULL) {
+               result = ERRSET_NOMEMORY;
+               goto fail;
+       }
+
+       /* allocate memory for signatures */
+       rrset->rri_sigs = calloc(rrset->rri_nsigs, sizeof(struct rdatainfo));
+       if (rrset->rri_sigs == NULL) {
+               result = ERRSET_NOMEMORY;
+               goto fail;
+       }
+
+       /* copy answers & signatures */
+       for (rr = response->answer, index_ans = 0, index_sig = 0;
+           rr; rr = rr->next) {
+
+               rdata = NULL;
+
+               if (rr->class == rrset->rri_rdclass &&
+                   rr->type  == rrset->rri_rdtype)
+                       rdata = &rrset->rri_rdatas[index_ans++];
+
+               if (rr->class == rrset->rri_rdclass &&
+                   rr->type  == T_SIG)
+                       rdata = &rrset->rri_sigs[index_sig++];
+
+               if (rdata) {
+                       rdata->rdi_length = rr->size;
+                       rdata->rdi_data   = malloc(rr->size);
+
+                       if (rdata->rdi_data == NULL) {
+                               result = ERRSET_NOMEMORY;
+                               goto fail;
+                       }
+                       memcpy(rdata->rdi_data, rr->rdata, rr->size);
+               }
+       }
+
+       *res = rrset;
+       return (ERRSET_SUCCESS);
+
+fail:
+       if (rrset != NULL)
+               freerrset(rrset);
+       return (result);
+}
+
+void
+freerrset(struct rrsetinfo *rrset)
+{
+       u_int16_t i;
+
+       if (rrset == NULL)
+               return;
+
+       if (rrset->rri_rdatas) {
+               for (i = 0; i < rrset->rri_nrdatas; i++) {
+                       if (rrset->rri_rdatas[i].rdi_data == NULL)
+                               break;
+                       free(rrset->rri_rdatas[i].rdi_data);
+               }
+               free(rrset->rri_rdatas);
+       }
+
+       if (rrset->rri_sigs) {
+               for (i = 0; i < rrset->rri_nsigs; i++) {
+                       if (rrset->rri_sigs[i].rdi_data == NULL)
+                               break;
+                       free(rrset->rri_sigs[i].rdi_data);
+               }
+               free(rrset->rri_sigs);
+       }
+
+       if (rrset->rri_name)
+               free(rrset->rri_name);
+       free(rrset);
+}
+
+/*
+ * DNS response parsing routines
+ */
+static struct dns_response *
+parse_dns_response(const u_char *answer, int size)
+{
+       struct dns_response *resp;
+       const u_char *cp;
+
+       /* allocate memory for the response */
+       resp = calloc(1, sizeof(*resp));
+       if (resp == NULL)
+               return (NULL);
+
+       /* initialize current pointer */
+       cp = answer;
+
+       /* copy header */
+       memcpy(&resp->header, cp, HFIXEDSZ);
+       cp += HFIXEDSZ;
+
+       /* fix header byte order */
+       resp->header.qdcount = ntohs(resp->header.qdcount);
+       resp->header.ancount = ntohs(resp->header.ancount);
+       resp->header.nscount = ntohs(resp->header.nscount);
+       resp->header.arcount = ntohs(resp->header.arcount);
+
+       /* there must be at least one query */
+       if (resp->header.qdcount < 1) {
+               free_dns_response(resp);
+               return (NULL);
+       }
+
+       /* parse query section */
+       resp->query = parse_dns_qsection(answer, size, &cp,
+           resp->header.qdcount);
+       if (resp->header.qdcount && resp->query == NULL) {
+               free_dns_response(resp);
+               return (NULL);
+       }
+
+       /* parse answer section */
+       resp->answer = parse_dns_rrsection(answer, size, &cp,
+           resp->header.ancount);
+       if (resp->header.ancount && resp->answer == NULL) {
+               free_dns_response(resp);
+               return (NULL);
+       }
+
+       /* parse authority section */
+       resp->authority = parse_dns_rrsection(answer, size, &cp,
+           resp->header.nscount);
+       if (resp->header.nscount && resp->authority == NULL) {
+               free_dns_response(resp);
+               return (NULL);
+       }
+
+       /* parse additional section */
+       resp->additional = parse_dns_rrsection(answer, size, &cp,
+           resp->header.arcount);
+       if (resp->header.arcount && resp->additional == NULL) {
+               free_dns_response(resp);
+               return (NULL);
+       }
+
+       return (resp);
+}
+
+static struct dns_query *
+parse_dns_qsection(const u_char *answer, int size, const u_char **cp, int count)
+{
+       struct dns_query *head, *curr, *prev;
+       int i, length;
+       char name[MAXDNAME];
+
+       for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
+
+               /* allocate and initialize struct */
+               curr = calloc(1, sizeof(struct dns_query));
+               if (curr == NULL) {
+                       free_dns_query(head);
+                       return (NULL);
+               }
+               if (head == NULL)
+                       head = curr;
+               if (prev != NULL)
+                       prev->next = curr;
+
+               /* name */
+               length = dn_expand(answer, answer + size, *cp, name,
+                   sizeof(name));
+               if (length < 0) {
+                       free_dns_query(head);
+                       return (NULL);
+               }
+               curr->name = strdup(name);
+               if (curr->name == NULL) {
+                       free_dns_query(head);
+                       return (NULL);
+               }
+               *cp += length;
+
+               /* type */
+               curr->type = _getshort(*cp);
+               *cp += INT16SZ;
+
+               /* class */
+               curr->class = _getshort(*cp);
+               *cp += INT16SZ;
+       }
+
+       return (head);
+}
+
+static struct dns_rr *
+parse_dns_rrsection(const u_char *answer, int size, const u_char **cp, int count)
+{
+       struct dns_rr *head, *curr, *prev;
+       int i, length;
+       char name[MAXDNAME];
+
+       for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
+
+               /* allocate and initialize struct */
+               curr = calloc(1, sizeof(struct dns_rr));
+               if (curr == NULL) {
+                       free_dns_rr(head);
+                       return (NULL);
+               }
+               if (head == NULL)
+                       head = curr;
+               if (prev != NULL)
+                       prev->next = curr;
+
+               /* name */
+               length = dn_expand(answer, answer + size, *cp, name,
+                   sizeof(name));
+               if (length < 0) {
+                       free_dns_rr(head);
+                       return (NULL);
+               }
+               curr->name = strdup(name);
+               if (curr->name == NULL) {
+                       free_dns_rr(head);
+                       return (NULL);
+               }
+               *cp += length;
+
+               /* type */
+               curr->type = _getshort(*cp);
+               *cp += INT16SZ;
+
+               /* class */
+               curr->class = _getshort(*cp);
+               *cp += INT16SZ;
+
+               /* ttl */
+               curr->ttl = _getlong(*cp);
+               *cp += INT32SZ;
+
+               /* rdata size */
+               curr->size = _getshort(*cp);
+               *cp += INT16SZ;
+
+               /* rdata itself */
+               curr->rdata = malloc(curr->size);
+               if (curr->rdata == NULL) {
+                       free_dns_rr(head);
+                       return (NULL);
+               }
+               memcpy(curr->rdata, *cp, curr->size);
+               *cp += curr->size;
+       }
+
+       return (head);
+}
+
+static void
+free_dns_query(struct dns_query *p)
+{
+       if (p == NULL)
+               return;
+
+       if (p->name)
+               free(p->name);
+       free_dns_query(p->next);
+       free(p);
+}
+
+static void
+free_dns_rr(struct dns_rr *p)
+{
+       if (p == NULL)
+               return;
+
+       if (p->name)
+               free(p->name);
+       if (p->rdata)
+               free(p->rdata);
+       free_dns_rr(p->next);
+       free(p);
+}
+
+static void
+free_dns_response(struct dns_response *p)
+{
+       if (p == NULL)
+               return;
+
+       free_dns_query(p->query);
+       free_dns_rr(p->answer);
+       free_dns_rr(p->authority);
+       free_dns_rr(p->additional);
+       free(p);
+}
+
+static int
+count_dns_rr(struct dns_rr *p, u_int16_t class, u_int16_t type)
+{
+       int n = 0;
+
+       while(p) {
+               if (p->class == class && p->type == type)
+                       n++;
+               p = p->next;
+       }
+
+       return (n);
+}
+
+#endif /* !defined(HAVE_GETRRSETBYNAME) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/getrrsetbyname.h b/crypto/openssh-3.8.1p1/openbsd-compat/getrrsetbyname.h
new file mode 100644 (file)
index 0000000..39995b6
--- /dev/null
@@ -0,0 +1,110 @@
+/* OPENBSD BASED ON : include/netdb.h */
+
+/* $OpenBSD: getrrsetbyname.c,v 1.4 2001/08/16 18:16:43 ho Exp $ */
+
+/*
+ * Copyright (c) 2001 Jakob Schlyter. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Portions Copyright (c) 1999-2001 Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
+ * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
+ * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
+ * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
+ * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#ifndef _GETRRSETBYNAME_H
+#define _GETRRSETBYNAME_H
+
+#include "includes.h"
+
+#ifndef HAVE_GETRRSETBYNAME
+
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
+#include <resolv.h>
+
+#ifndef HFIXEDSZ
+#define HFIXEDSZ 12
+#endif
+
+#ifndef T_SIG
+#define T_SIG 24
+#endif
+
+/*
+ * Flags for getrrsetbyname()
+ */
+#ifndef RRSET_VALIDATED
+# define RRSET_VALIDATED       1
+#endif
+
+/*
+ * Return codes for getrrsetbyname()
+ */
+#ifndef ERRSET_SUCCESS
+# define ERRSET_SUCCESS                0
+# define ERRSET_NOMEMORY       1
+# define ERRSET_FAIL           2
+# define ERRSET_INVAL          3
+# define ERRSET_NONAME         4
+# define ERRSET_NODATA         5
+#endif
+
+struct rdatainfo {
+       unsigned int            rdi_length;     /* length of data */
+       unsigned char           *rdi_data;      /* record data */
+};
+
+struct rrsetinfo {
+       unsigned int            rri_flags;      /* RRSET_VALIDATED ... */
+       unsigned int            rri_rdclass;    /* class number */
+       unsigned int            rri_rdtype;     /* RR type number */
+       unsigned int            rri_ttl;        /* time to live */
+       unsigned int            rri_nrdatas;    /* size of rdatas array */
+       unsigned int            rri_nsigs;      /* size of sigs array */
+       char                    *rri_name;      /* canonical name */
+       struct rdatainfo        *rri_rdatas;    /* individual records */
+       struct rdatainfo        *rri_sigs;      /* individual signatures */
+};
+
+int            getrrsetbyname(const char *, unsigned int, unsigned int, unsigned int, struct rrsetinfo **);
+void           freerrset(struct rrsetinfo *);
+
+#endif /* !defined(HAVE_GETRRSETBYNAME) */
+
+#endif /* _GETRRSETBYNAME_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/glob.c b/crypto/openssh-3.8.1p1/openbsd-compat/glob.c
new file mode 100644 (file)
index 0000000..7fafc8c
--- /dev/null
@@ -0,0 +1,914 @@
+/* OPENBSD ORIGINAL: lib/libc/gen/glob.c */
+
+/*
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+#include <ctype.h>
+
+static long
+get_arg_max(void)
+{
+#ifdef ARG_MAX
+       return(ARG_MAX);
+#elif defined(HAVE_SYSCONF) && defined(_SC_ARG_MAX)
+       return(sysconf(_SC_ARG_MAX));
+#else
+       return(256); /* XXX: arbitrary */
+#endif
+}
+
+#if !defined(HAVE_GLOB) || !defined(GLOB_HAS_ALTDIRFUNC) || \
+    !defined(GLOB_HAS_GL_MATCHC)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)glob.c     8.3 (Berkeley) 10/13/93";
+#else
+static char rcsid[] = "$OpenBSD: glob.c,v 1.22 2003/06/25 21:16:47 deraadt Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * glob(3) -- a superset of the one defined in POSIX 1003.2.
+ *
+ * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
+ *
+ * Optional extra services, controlled by flags not defined by POSIX:
+ *
+ * GLOB_QUOTE:
+ *     Escaping convention: \ inhibits any special meaning the following
+ *     character might have (except \ at end of string is retained).
+ * GLOB_MAGCHAR:
+ *     Set in gl_flags if pattern contained a globbing character.
+ * GLOB_NOMAGIC:
+ *     Same as GLOB_NOCHECK, but it will only append pattern if it did
+ *     not contain any magic characters.  [Used in csh style globbing]
+ * GLOB_ALTDIRFUNC:
+ *     Use alternately specified directory access functions.
+ * GLOB_TILDE:
+ *     expand ~user/foo to the /home/dir/of/user/foo
+ * GLOB_BRACE:
+ *     expand {1,2}{a,b} to 1a 1b 2a 2b
+ * gl_matchc:
+ *     Number of matches in the current invocation of glob.
+ */
+
+
+#define        DOLLAR          '$'
+#define        DOT             '.'
+#define        EOS             '\0'
+#define        LBRACKET        '['
+#define        NOT             '!'
+#define        QUESTION        '?'
+#define        QUOTE           '\\'
+#define        RANGE           '-'
+#define        RBRACKET        ']'
+#define        SEP             '/'
+#define        STAR            '*'
+#undef TILDE                   /* Some platforms may already define it */
+#define        TILDE           '~'
+#define        UNDERSCORE      '_'
+#define        LBRACE          '{'
+#define        RBRACE          '}'
+#define        SLASH           '/'
+#define        COMMA           ','
+
+#ifndef DEBUG
+
+#define        M_QUOTE         0x8000
+#define        M_PROTECT       0x4000
+#define        M_MASK          0xffff
+#define        M_ASCII         0x00ff
+
+typedef u_short Char;
+
+#else
+
+#define        M_QUOTE         0x80
+#define        M_PROTECT       0x40
+#define        M_MASK          0xff
+#define        M_ASCII         0x7f
+
+typedef char Char;
+
+#endif
+
+
+#define        CHAR(c)         ((Char)((c)&M_ASCII))
+#define        META(c)         ((Char)((c)|M_QUOTE))
+#define        M_ALL           META('*')
+#define        M_END           META(']')
+#define        M_NOT           META('!')
+#define        M_ONE           META('?')
+#define        M_RNG           META('-')
+#define        M_SET           META('[')
+#define        ismeta(c)       (((c)&M_QUOTE) != 0)
+
+
+static int      compare(const void *, const void *);
+static int      g_Ctoc(const Char *, char *, u_int);
+static int      g_lstat(Char *, struct stat *, glob_t *);
+static DIR     *g_opendir(Char *, glob_t *);
+static Char    *g_strchr(Char *, int);
+static int      g_stat(Char *, struct stat *, glob_t *);
+static int      glob0(const Char *, glob_t *);
+static int      glob1(Char *, Char *, glob_t *, size_t *);
+static int      glob2(Char *, Char *, Char *, Char *, Char *, Char *,
+                   glob_t *, size_t *);
+static int      glob3(Char *, Char *, Char *, Char *, Char *, Char *,
+                   Char *, Char *, glob_t *, size_t *);
+static int      globextend(const Char *, glob_t *, size_t *);
+static const Char *
+                globtilde(const Char *, Char *, size_t, glob_t *);
+static int      globexp1(const Char *, glob_t *);
+static int      globexp2(const Char *, const Char *, glob_t *, int *);
+static int      match(Char *, Char *, Char *);
+#ifdef DEBUG
+static void     qprintf(const char *, Char *);
+#endif
+
+int
+glob(pattern, flags, errfunc, pglob)
+       const char *pattern;
+       int flags, (*errfunc)(const char *, int);
+       glob_t *pglob;
+{
+       const u_char *patnext;
+       int c;
+       Char *bufnext, *bufend, patbuf[MAXPATHLEN];
+
+       patnext = (u_char *) pattern;
+       if (!(flags & GLOB_APPEND)) {
+               pglob->gl_pathc = 0;
+               pglob->gl_pathv = NULL;
+               if (!(flags & GLOB_DOOFFS))
+                       pglob->gl_offs = 0;
+       }
+       pglob->gl_flags = flags & ~GLOB_MAGCHAR;
+       pglob->gl_errfunc = errfunc;
+       pglob->gl_matchc = 0;
+
+       bufnext = patbuf;
+       bufend = bufnext + MAXPATHLEN - 1;
+       if (flags & GLOB_NOESCAPE)
+               while (bufnext < bufend && (c = *patnext++) != EOS)
+                       *bufnext++ = c;
+       else {
+               /* Protect the quoted characters. */
+               while (bufnext < bufend && (c = *patnext++) != EOS)
+                       if (c == QUOTE) {
+                               if ((c = *patnext++) == EOS) {
+                                       c = QUOTE;
+                                       --patnext;
+                               }
+                               *bufnext++ = c | M_PROTECT;
+                       } else
+                               *bufnext++ = c;
+       }
+       *bufnext = EOS;
+
+       if (flags & GLOB_BRACE)
+               return globexp1(patbuf, pglob);
+       else
+               return glob0(patbuf, pglob);
+}
+
+/*
+ * Expand recursively a glob {} pattern. When there is no more expansion
+ * invoke the standard globbing routine to glob the rest of the magic
+ * characters
+ */
+static int
+globexp1(pattern, pglob)
+       const Char *pattern;
+       glob_t *pglob;
+{
+       const Char* ptr = pattern;
+       int rv;
+
+       /* Protect a single {}, for find(1), like csh */
+       if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS)
+               return glob0(pattern, pglob);
+
+       while ((ptr = (const Char *) g_strchr((Char *) ptr, LBRACE)) != NULL)
+               if (!globexp2(ptr, pattern, pglob, &rv))
+                       return rv;
+
+       return glob0(pattern, pglob);
+}
+
+
+/*
+ * Recursive brace globbing helper. Tries to expand a single brace.
+ * If it succeeds then it invokes globexp1 with the new pattern.
+ * If it fails then it tries to glob the rest of the pattern and returns.
+ */
+static int
+globexp2(ptr, pattern, pglob, rv)
+       const Char *ptr, *pattern;
+       glob_t *pglob;
+       int *rv;
+{
+       int     i;
+       Char   *lm, *ls;
+       const Char *pe, *pm, *pl;
+       Char    patbuf[MAXPATHLEN];
+
+       /* copy part up to the brace */
+       for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
+               ;
+       *lm = EOS;
+       ls = lm;
+
+       /* Find the balanced brace */
+       for (i = 0, pe = ++ptr; *pe; pe++)
+               if (*pe == LBRACKET) {
+                       /* Ignore everything between [] */
+                       for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)
+                               ;
+                       if (*pe == EOS) {
+                               /*
+                                * We could not find a matching RBRACKET.
+                                * Ignore and just look for RBRACE
+                                */
+                               pe = pm;
+                       }
+               } else if (*pe == LBRACE)
+                       i++;
+               else if (*pe == RBRACE) {
+                       if (i == 0)
+                               break;
+                       i--;
+               }
+
+       /* Non matching braces; just glob the pattern */
+       if (i != 0 || *pe == EOS) {
+               *rv = glob0(patbuf, pglob);
+               return 0;
+       }
+
+       for (i = 0, pl = pm = ptr; pm <= pe; pm++) {
+               switch (*pm) {
+               case LBRACKET:
+                       /* Ignore everything between [] */
+                       for (pl = pm++; *pm != RBRACKET && *pm != EOS; pm++)
+                               ;
+                       if (*pm == EOS) {
+                               /*
+                                * We could not find a matching RBRACKET.
+                                * Ignore and just look for RBRACE
+                                */
+                               pm = pl;
+                       }
+                       break;
+
+               case LBRACE:
+                       i++;
+                       break;
+
+               case RBRACE:
+                       if (i) {
+                               i--;
+                               break;
+                       }
+                       /* FALLTHROUGH */
+               case COMMA:
+                       if (i && *pm == COMMA)
+                               break;
+                       else {
+                               /* Append the current string */
+                               for (lm = ls; (pl < pm); *lm++ = *pl++)
+                                       ;
+
+                               /*
+                                * Append the rest of the pattern after the
+                                * closing brace
+                                */
+                               for (pl = pe + 1; (*lm++ = *pl++) != EOS; )
+                                       ;
+
+                               /* Expand the current pattern */
+#ifdef DEBUG
+                               qprintf("globexp2:", patbuf);
+#endif
+                               *rv = globexp1(patbuf, pglob);
+
+                               /* move after the comma, to the next string */
+                               pl = pm + 1;
+                       }
+                       break;
+
+               default:
+                       break;
+               }
+       }
+       *rv = 0;
+       return 0;
+}
+
+
+
+/*
+ * expand tilde from the passwd file.
+ */
+static const Char *
+globtilde(pattern, patbuf, patbuf_len, pglob)
+       const Char *pattern;
+       Char *patbuf;
+       size_t patbuf_len;
+       glob_t *pglob;
+{
+       struct passwd *pwd;
+       char *h;
+       const Char *p;
+       Char *b, *eb;
+
+       if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))
+               return pattern;
+
+       /* Copy up to the end of the string or / */
+       eb = &patbuf[patbuf_len - 1];
+       for (p = pattern + 1, h = (char *) patbuf;
+           h < (char *)eb && *p && *p != SLASH; *h++ = *p++)
+               ;
+
+       *h = EOS;
+
+#if 0
+       if (h == (char *)eb)
+               return what;
+#endif
+
+       if (((char *) patbuf)[0] == EOS) {
+               /*
+                * handle a plain ~ or ~/ by expanding $HOME
+                * first and then trying the password file
+                */
+#if 0
+               if (issetugid() != 0 || (h = getenv("HOME")) == NULL) {
+#endif
+               if ((getuid() != geteuid()) || (h = getenv("HOME")) == NULL) {
+                       if ((pwd = getpwuid(getuid())) == NULL)
+                               return pattern;
+                       else
+                               h = pwd->pw_dir;
+               }
+       } else {
+               /*
+                * Expand a ~user
+                */
+               if ((pwd = getpwnam((char*) patbuf)) == NULL)
+                       return pattern;
+               else
+                       h = pwd->pw_dir;
+       }
+
+       /* Copy the home directory */
+       for (b = patbuf; b < eb && *h; *b++ = *h++)
+               ;
+
+       /* Append the rest of the pattern */
+       while (b < eb && (*b++ = *p++) != EOS)
+               ;
+       *b = EOS;
+
+       return patbuf;
+}
+
+
+/*
+ * The main glob() routine: compiles the pattern (optionally processing
+ * quotes), calls glob1() to do the real pattern matching, and finally
+ * sorts the list (unless unsorted operation is requested).  Returns 0
+ * if things went well, nonzero if errors occurred.  It is not an error
+ * to find no matches.
+ */
+static int
+glob0(pattern, pglob)
+       const Char *pattern;
+       glob_t *pglob;
+{
+       const Char *qpatnext;
+       int c, err, oldpathc;
+       Char *bufnext, patbuf[MAXPATHLEN];
+       size_t limit = 0;
+
+       qpatnext = globtilde(pattern, patbuf, MAXPATHLEN, pglob);
+       oldpathc = pglob->gl_pathc;
+       bufnext = patbuf;
+
+       /* We don't need to check for buffer overflow any more. */
+       while ((c = *qpatnext++) != EOS) {
+               switch (c) {
+               case LBRACKET:
+                       c = *qpatnext;
+                       if (c == NOT)
+                               ++qpatnext;
+                       if (*qpatnext == EOS ||
+                           g_strchr((Char *) qpatnext+1, RBRACKET) == NULL) {
+                               *bufnext++ = LBRACKET;
+                               if (c == NOT)
+                                       --qpatnext;
+                               break;
+                       }
+                       *bufnext++ = M_SET;
+                       if (c == NOT)
+                               *bufnext++ = M_NOT;
+                       c = *qpatnext++;
+                       do {
+                               *bufnext++ = CHAR(c);
+                               if (*qpatnext == RANGE &&
+                                   (c = qpatnext[1]) != RBRACKET) {
+                                       *bufnext++ = M_RNG;
+                                       *bufnext++ = CHAR(c);
+                                       qpatnext += 2;
+                               }
+                       } while ((c = *qpatnext++) != RBRACKET);
+                       pglob->gl_flags |= GLOB_MAGCHAR;
+                       *bufnext++ = M_END;
+                       break;
+               case QUESTION:
+                       pglob->gl_flags |= GLOB_MAGCHAR;
+                       *bufnext++ = M_ONE;
+                       break;
+               case STAR:
+                       pglob->gl_flags |= GLOB_MAGCHAR;
+                       /* collapse adjacent stars to one,
+                        * to avoid exponential behavior
+                        */
+                       if (bufnext == patbuf || bufnext[-1] != M_ALL)
+                               *bufnext++ = M_ALL;
+                       break;
+               default:
+                       *bufnext++ = CHAR(c);
+                       break;
+               }
+       }
+       *bufnext = EOS;
+#ifdef DEBUG
+       qprintf("glob0:", patbuf);
+#endif
+
+       if ((err = glob1(patbuf, patbuf+MAXPATHLEN-1, pglob, &limit)) != 0)
+               return(err);
+
+       /*
+        * If there was no match we are going to append the pattern
+        * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
+        * and the pattern did not contain any magic characters
+        * GLOB_NOMAGIC is there just for compatibility with csh.
+        */
+       if (pglob->gl_pathc == oldpathc) {
+               if ((pglob->gl_flags & GLOB_NOCHECK) ||
+                   ((pglob->gl_flags & GLOB_NOMAGIC) &&
+                   !(pglob->gl_flags & GLOB_MAGCHAR)))
+                       return(globextend(pattern, pglob, &limit));
+               else
+                       return(GLOB_NOMATCH);
+       }
+       if (!(pglob->gl_flags & GLOB_NOSORT))
+               qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
+                   pglob->gl_pathc - oldpathc, sizeof(char *), compare);
+       return(0);
+}
+
+static int
+compare(p, q)
+       const void *p, *q;
+{
+       return(strcmp(*(char **)p, *(char **)q));
+}
+
+static int
+glob1(pattern, pattern_last, pglob, limitp)
+       Char *pattern, *pattern_last;
+       glob_t *pglob;
+       size_t *limitp;
+{
+       Char pathbuf[MAXPATHLEN];
+
+       /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
+       if (*pattern == EOS)
+               return(0);
+       return(glob2(pathbuf, pathbuf+MAXPATHLEN-1,
+           pathbuf, pathbuf+MAXPATHLEN-1,
+           pattern, pattern_last, pglob, limitp));
+}
+
+/*
+ * The functions glob2 and glob3 are mutually recursive; there is one level
+ * of recursion for each segment in the pattern that contains one or more
+ * meta characters.
+ */
+static int
+glob2(pathbuf, pathbuf_last, pathend, pathend_last, pattern,
+    pattern_last, pglob, limitp)
+       Char *pathbuf, *pathbuf_last, *pathend, *pathend_last;
+       Char *pattern, *pattern_last;
+       glob_t *pglob;
+       size_t *limitp;
+{
+       struct stat sb;
+       Char *p, *q;
+       int anymeta;
+
+       /*
+        * Loop over pattern segments until end of pattern or until
+        * segment with meta character found.
+        */
+       for (anymeta = 0;;) {
+               if (*pattern == EOS) {          /* End of pattern? */
+                       *pathend = EOS;
+                       if (g_lstat(pathbuf, &sb, pglob))
+                               return(0);
+
+                       if (((pglob->gl_flags & GLOB_MARK) &&
+                           pathend[-1] != SEP) && (S_ISDIR(sb.st_mode) ||
+                           (S_ISLNK(sb.st_mode) &&
+                           (g_stat(pathbuf, &sb, pglob) == 0) &&
+                           S_ISDIR(sb.st_mode)))) {
+                               if (pathend+1 > pathend_last)
+                                       return (1);
+                               *pathend++ = SEP;
+                               *pathend = EOS;
+                       }
+                       ++pglob->gl_matchc;
+                       return(globextend(pathbuf, pglob, limitp));
+               }
+
+               /* Find end of next segment, copy tentatively to pathend. */
+               q = pathend;
+               p = pattern;
+               while (*p != EOS && *p != SEP) {
+                       if (ismeta(*p))
+                               anymeta = 1;
+                       if (q+1 > pathend_last)
+                               return (1);
+                       *q++ = *p++;
+               }
+
+               if (!anymeta) {         /* No expansion, do next segment. */
+                       pathend = q;
+                       pattern = p;
+                       while (*pattern == SEP) {
+                               if (pathend+1 > pathend_last)
+                                       return (1);
+                               *pathend++ = *pattern++;
+                       }
+               } else
+                       /* Need expansion, recurse. */
+                       return(glob3(pathbuf, pathbuf_last, pathend,
+                           pathend_last, pattern, pattern_last,
+                           p, pattern_last, pglob, limitp));
+       }
+       /* NOTREACHED */
+}
+
+static int
+glob3(pathbuf, pathbuf_last, pathend, pathend_last, pattern, pattern_last,
+    restpattern, restpattern_last, pglob, limitp)
+       Char *pathbuf, *pathbuf_last, *pathend, *pathend_last;
+       Char *pattern, *pattern_last, *restpattern, *restpattern_last;
+       glob_t *pglob;
+       size_t *limitp;
+{
+       register struct dirent *dp;
+       DIR *dirp;
+       int err;
+       char buf[MAXPATHLEN];
+
+       /*
+        * The readdirfunc declaration can't be prototyped, because it is
+        * assigned, below, to two functions which are prototyped in glob.h
+        * and dirent.h as taking pointers to differently typed opaque
+        * structures.
+        */
+       struct dirent *(*readdirfunc)(void *);
+
+       if (pathend > pathend_last)
+               return (1);
+       *pathend = EOS;
+       errno = 0;
+
+       if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
+               /* TODO: don't call for ENOENT or ENOTDIR? */
+               if (pglob->gl_errfunc) {
+                       if (g_Ctoc(pathbuf, buf, sizeof(buf)))
+                               return(GLOB_ABORTED);
+                       if (pglob->gl_errfunc(buf, errno) ||
+                           pglob->gl_flags & GLOB_ERR)
+                               return(GLOB_ABORTED);
+               }
+               return(0);
+       }
+
+       err = 0;
+
+       /* Search directory for matching names. */
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               readdirfunc = pglob->gl_readdir;
+       else
+               readdirfunc = (struct dirent *(*)(void *))readdir;
+       while ((dp = (*readdirfunc)(dirp))) {
+               register u_char *sc;
+               register Char *dc;
+
+               /* Initial DOT must be matched literally. */
+               if (dp->d_name[0] == DOT && *pattern != DOT)
+                       continue;
+               dc = pathend;
+               sc = (u_char *) dp->d_name;
+               while (dc < pathend_last && (*dc++ = *sc++) != EOS)
+                       ;
+               if (dc >= pathend_last) {
+                       *dc = EOS;
+                       err = 1;
+                       break;
+               }
+
+               if (!match(pathend, pattern, restpattern)) {
+                       *pathend = EOS;
+                       continue;
+               }
+               err = glob2(pathbuf, pathbuf_last, --dc, pathend_last,
+                   restpattern, restpattern_last, pglob, limitp);
+               if (err)
+                       break;
+       }
+
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               (*pglob->gl_closedir)(dirp);
+       else
+               closedir(dirp);
+       return(err);
+}
+
+
+/*
+ * Extend the gl_pathv member of a glob_t structure to accommodate a new item,
+ * add the new item, and update gl_pathc.
+ *
+ * This assumes the BSD realloc, which only copies the block when its size
+ * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
+ * behavior.
+ *
+ * Return 0 if new item added, error code if memory couldn't be allocated.
+ *
+ * Invariant of the glob_t structure:
+ *     Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
+ *     gl_pathv points to (gl_offs + gl_pathc + 1) items.
+ */
+static int
+globextend(path, pglob, limitp)
+       const Char *path;
+       glob_t *pglob;
+       size_t *limitp;
+{
+       register char **pathv;
+       register int i;
+       u_int newsize, len;
+       char *copy;
+       const Char *p;
+
+       newsize = sizeof(*pathv) * (2 + pglob->gl_pathc + pglob->gl_offs);
+       pathv = pglob->gl_pathv ? realloc((char *)pglob->gl_pathv, newsize) :
+           malloc(newsize);
+       if (pathv == NULL) {
+               if (pglob->gl_pathv) {
+                       free(pglob->gl_pathv);
+                       pglob->gl_pathv = NULL;
+               }
+               return(GLOB_NOSPACE);
+       }
+
+       if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
+               /* first time around -- clear initial gl_offs items */
+               pathv += pglob->gl_offs;
+               for (i = pglob->gl_offs; --i >= 0; )
+                       *--pathv = NULL;
+       }
+       pglob->gl_pathv = pathv;
+
+       for (p = path; *p++;)
+               ;
+       len = (size_t)(p - path);
+       *limitp += len;
+       if ((copy = malloc(len)) != NULL) {
+               if (g_Ctoc(path, copy, len)) {
+                       free(copy);
+                       return(GLOB_NOSPACE);
+               }
+               pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
+       }
+       pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
+
+       if ((pglob->gl_flags & GLOB_LIMIT) &&
+           newsize + *limitp >= (u_int) get_arg_max()) {
+               errno = 0;
+               return(GLOB_NOSPACE);
+       }
+
+       return(copy == NULL ? GLOB_NOSPACE : 0);
+}
+
+
+/*
+ * pattern matching function for filenames.  Each occurrence of the *
+ * pattern causes a recursion level.
+ */
+static int
+match(name, pat, patend)
+       register Char *name, *pat, *patend;
+{
+       int ok, negate_range;
+       Char c, k;
+
+       while (pat < patend) {
+               c = *pat++;
+               switch (c & M_MASK) {
+               case M_ALL:
+                       if (pat == patend)
+                               return(1);
+                       do
+                           if (match(name, pat, patend))
+                                   return(1);
+                       while (*name++ != EOS)
+                               ;
+                       return(0);
+               case M_ONE:
+                       if (*name++ == EOS)
+                               return(0);
+                       break;
+               case M_SET:
+                       ok = 0;
+                       if ((k = *name++) == EOS)
+                               return(0);
+                       if ((negate_range = ((*pat & M_MASK) == M_NOT)) != EOS)
+                               ++pat;
+                       while (((c = *pat++) & M_MASK) != M_END)
+                               if ((*pat & M_MASK) == M_RNG) {
+                                       if (c <= k && k <= pat[1])
+                                               ok = 1;
+                                       pat += 2;
+                               } else if (c == k)
+                                       ok = 1;
+                       if (ok == negate_range)
+                               return(0);
+                       break;
+               default:
+                       if (*name++ != c)
+                               return(0);
+                       break;
+               }
+       }
+       return(*name == EOS);
+}
+
+/* Free allocated data belonging to a glob_t structure. */
+void
+globfree(pglob)
+       glob_t *pglob;
+{
+       register int i;
+       register char **pp;
+
+       if (pglob->gl_pathv != NULL) {
+               pp = pglob->gl_pathv + pglob->gl_offs;
+               for (i = pglob->gl_pathc; i--; ++pp)
+                       if (*pp)
+                               free(*pp);
+               free(pglob->gl_pathv);
+               pglob->gl_pathv = NULL;
+       }
+}
+
+static DIR *
+g_opendir(str, pglob)
+       register Char *str;
+       glob_t *pglob;
+{
+       char buf[MAXPATHLEN];
+
+       if (!*str)
+               strlcpy(buf, ".", sizeof buf);
+       else {
+               if (g_Ctoc(str, buf, sizeof(buf)))
+                       return(NULL);
+       }
+
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               return((*pglob->gl_opendir)(buf));
+
+       return(opendir(buf));
+}
+
+static int
+g_lstat(fn, sb, pglob)
+       register Char *fn;
+       struct stat *sb;
+       glob_t *pglob;
+{
+       char buf[MAXPATHLEN];
+
+       if (g_Ctoc(fn, buf, sizeof(buf)))
+               return(-1);
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               return((*pglob->gl_lstat)(buf, sb));
+       return(lstat(buf, sb));
+}
+
+static int
+g_stat(fn, sb, pglob)
+       register Char *fn;
+       struct stat *sb;
+       glob_t *pglob;
+{
+       char buf[MAXPATHLEN];
+
+       if (g_Ctoc(fn, buf, sizeof(buf)))
+               return(-1);
+       if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+               return((*pglob->gl_stat)(buf, sb));
+       return(stat(buf, sb));
+}
+
+static Char *
+g_strchr(str, ch)
+       Char *str;
+       int ch;
+{
+       do {
+               if (*str == ch)
+                       return (str);
+       } while (*str++);
+       return (NULL);
+}
+
+static int
+g_Ctoc(str, buf, len)
+       register const Char *str;
+       char *buf;
+       u_int len;
+{
+
+       while (len--) {
+               if ((*buf++ = *str++) == EOS)
+                       return (0);
+       }
+       return (1);
+}
+
+#ifdef DEBUG
+static void
+qprintf(str, s)
+       const char *str;
+       register Char *s;
+{
+       register Char *p;
+
+       (void)printf("%s:\n", str);
+       for (p = s; *p; p++)
+               (void)printf("%c", CHAR(*p));
+       (void)printf("\n");
+       for (p = s; *p; p++)
+               (void)printf("%c", *p & M_PROTECT ? '"' : ' ');
+       (void)printf("\n");
+       for (p = s; *p; p++)
+               (void)printf("%c", ismeta(*p) ? '_' : ' ');
+       (void)printf("\n");
+}
+#endif
+
+#endif /* !defined(HAVE_GLOB) || !defined(GLOB_HAS_ALTDIRFUNC) ||
+          !defined(GLOB_HAS_GL_MATCHC) */
+
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/glob.h b/crypto/openssh-3.8.1p1/openbsd-compat/glob.h
new file mode 100644 (file)
index 0000000..3428b20
--- /dev/null
@@ -0,0 +1,99 @@
+/* OPENBSD ORIGINAL: include/glob.h */
+
+/*     $OpenBSD: glob.h,v 1.8 2003/06/02 19:34:12 millert Exp $        */
+/*     $NetBSD: glob.h,v 1.5 1994/10/26 00:55:56 cgd Exp $     */
+
+/*
+ * Copyright (c) 1989, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)glob.h      8.1 (Berkeley) 6/2/93
+ */
+
+#if !defined(HAVE_GLOB_H) || !defined(GLOB_HAS_ALTDIRFUNC) || \
+    !defined(GLOB_HAS_GL_MATCHC)
+
+#ifndef _GLOB_H_
+#define        _GLOB_H_
+
+struct stat;
+typedef struct {
+       int gl_pathc;           /* Count of total paths so far. */
+       int gl_matchc;          /* Count of paths matching pattern. */
+       int gl_offs;            /* Reserved at beginning of gl_pathv. */
+       int gl_flags;           /* Copy of flags parameter to glob. */
+       char **gl_pathv;        /* List of paths matching pattern. */
+                               /* Copy of errfunc parameter to glob. */
+       int (*gl_errfunc)(const char *, int);
+
+       /*
+        * Alternate filesystem access methods for glob; replacement
+        * versions of closedir(3), readdir(3), opendir(3), stat(2)
+        * and lstat(2).
+        */
+       void (*gl_closedir)(void *);
+       struct dirent *(*gl_readdir)(void *);   
+       void *(*gl_opendir)(const char *);
+       int (*gl_lstat)(const char *, struct stat *);
+       int (*gl_stat)(const char *, struct stat *);
+} glob_t;
+
+/* Flags */
+#define        GLOB_APPEND     0x0001  /* Append to output from previous call. */
+#define        GLOB_DOOFFS     0x0002  /* Use gl_offs. */
+#define        GLOB_ERR        0x0004  /* Return on error. */
+#define        GLOB_MARK       0x0008  /* Append / to matching directories. */
+#define        GLOB_NOCHECK    0x0010  /* Return pattern itself if nothing matches. */
+#define        GLOB_NOSORT     0x0020  /* Don't sort. */
+
+#define        GLOB_ALTDIRFUNC 0x0040  /* Use alternately specified directory funcs. */
+#define        GLOB_BRACE      0x0080  /* Expand braces ala csh. */
+#define        GLOB_MAGCHAR    0x0100  /* Pattern had globbing characters. */
+#define        GLOB_NOMAGIC    0x0200  /* GLOB_NOCHECK without magic chars (csh). */
+#define        GLOB_QUOTE      0x0400  /* Quote special chars with \. */
+#define        GLOB_TILDE      0x0800  /* Expand tilde names from the passwd file. */
+#define        GLOB_NOESCAPE   0x1000  /* Disable backslash escaping. */
+#define GLOB_LIMIT     0x2000  /* Limit pattern match output to ARG_MAX */
+
+/* Error values returned by glob(3) */
+#define        GLOB_NOSPACE    (-1)    /* Malloc call failed. */
+#define        GLOB_ABORTED    (-2)    /* Unignored error. */
+#define        GLOB_NOMATCH    (-3)    /* No match and GLOB_NOCHECK not set. */
+#define        GLOB_NOSYS      (-4)    /* Function not supported. */
+#define GLOB_ABEND     GLOB_ABORTED
+
+int    glob(const char *, int, int (*)(const char *, int), glob_t *);
+void   globfree(glob_t *);
+
+#endif /* !_GLOB_H_ */
+
+#endif /* !defined(HAVE_GLOB_H) || !defined(GLOB_HAS_ALTDIRFUNC)  ||
+         !defined(GLOB_HAS_GL_MATCHC */
+
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/inet_aton.c b/crypto/openssh-3.8.1p1/openbsd-compat/inet_aton.c
new file mode 100644 (file)
index 0000000..c141bcc
--- /dev/null
@@ -0,0 +1,189 @@
+/* OPENBSD ORIGINAL: lib/libc/net/inet_addr.c */
+
+/*     $OpenBSD: inet_addr.c,v 1.7 2003/06/02 20:18:35 millert Exp $   */
+
+/*
+ * Copyright (c) 1983, 1990, 1993
+ *    The Regents of the University of California.  All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * -
+ * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ * 
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies, and that
+ * the name of Digital Equipment Corporation not be used in advertising or
+ * publicity pertaining to distribution of the document or software without
+ * specific, written prior permission.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
+ * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ * -
+ * --Copyright--
+ */
+
+#include "includes.h"
+
+#if !defined(HAVE_INET_ATON)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char sccsid[] = "@(#)inet_addr.c        8.1 (Berkeley) 6/17/93";
+static char rcsid[] = "$From: inet_addr.c,v 8.5 1996/08/05 08:31:35 vixie Exp $";
+#else
+static char rcsid[] = "$OpenBSD: inet_addr.c,v 1.7 2003/06/02 20:18:35 millert Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <ctype.h>
+
+#if 0
+/*
+ * Ascii internet address interpretation routine.
+ * The value returned is in network order.
+ */
+in_addr_t
+inet_addr(cp)
+       register const char *cp;
+{
+       struct in_addr val;
+
+       if (inet_aton(cp, &val))
+               return (val.s_addr);
+       return (INADDR_NONE);
+}
+#endif
+
+/* 
+ * Check whether "cp" is a valid ascii representation
+ * of an Internet address and convert to a binary address.
+ * Returns 1 if the address is valid, 0 if not.
+ * This replaces inet_addr, the return value from which
+ * cannot distinguish between failure and a local broadcast address.
+ */
+int
+inet_aton(const char *cp, struct in_addr *addr)
+{
+       register u_int32_t val;
+       register int base, n;
+       register char c;
+       unsigned int parts[4];
+       register unsigned int *pp = parts;
+
+       c = *cp;
+       for (;;) {
+               /*
+                * Collect number up to ``.''.
+                * Values are specified as for C:
+                * 0x=hex, 0=octal, isdigit=decimal.
+                */
+               if (!isdigit(c))
+                       return (0);
+               val = 0; base = 10;
+               if (c == '0') {
+                       c = *++cp;
+                       if (c == 'x' || c == 'X')
+                               base = 16, c = *++cp;
+                       else
+                               base = 8;
+               }
+               for (;;) {
+                       if (isascii(c) && isdigit(c)) {
+                               val = (val * base) + (c - '0');
+                               c = *++cp;
+                       } else if (base == 16 && isascii(c) && isxdigit(c)) {
+                               val = (val << 4) |
+                                       (c + 10 - (islower(c) ? 'a' : 'A'));
+                               c = *++cp;
+                       } else
+                               break;
+               }
+               if (c == '.') {
+                       /*
+                        * Internet format:
+                        *      a.b.c.d
+                        *      a.b.c   (with c treated as 16 bits)
+                        *      a.b     (with b treated as 24 bits)
+                        */
+                       if (pp >= parts + 3)
+                               return (0);
+                       *pp++ = val;
+                       c = *++cp;
+               } else
+                       break;
+       }
+       /*
+        * Check for trailing characters.
+        */
+       if (c != '\0' && (!isascii(c) || !isspace(c)))
+               return (0);
+       /*
+        * Concoct the address according to
+        * the number of parts specified.
+        */
+       n = pp - parts + 1;
+       switch (n) {
+
+       case 0:
+               return (0);             /* initial nondigit */
+
+       case 1:                         /* a -- 32 bits */
+               break;
+
+       case 2:                         /* a.b -- 8.24 bits */
+               if ((val > 0xffffff) || (parts[0] > 0xff))
+                       return (0);
+               val |= parts[0] << 24;
+               break;
+
+       case 3:                         /* a.b.c -- 8.8.16 bits */
+               if ((val > 0xffff) || (parts[0] > 0xff) || (parts[1] > 0xff))
+                       return (0);
+               val |= (parts[0] << 24) | (parts[1] << 16);
+               break;
+
+       case 4:                         /* a.b.c.d -- 8.8.8.8 bits */
+               if ((val > 0xff) || (parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff))
+                       return (0);
+               val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
+               break;
+       }
+       if (addr)
+               addr->s_addr = htonl(val);
+       return (1);
+}
+
+#endif /* !defined(HAVE_INET_ATON) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/inet_ntoa.c b/crypto/openssh-3.8.1p1/openbsd-compat/inet_ntoa.c
new file mode 100644 (file)
index 0000000..dc010dc
--- /dev/null
@@ -0,0 +1,61 @@
+/* OPENBSD ORIGINAL: lib/libc/net/inet_ntoa.c */
+
+/*
+ * Copyright (c) 1983, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#if defined(BROKEN_INET_NTOA) || !defined(HAVE_INET_NTOA)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: inet_ntoa.c,v 1.4 2003/06/02 20:18:35 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+/*
+ * Convert network-format internet address
+ * to base 256 d.d.d.d representation.
+ */
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+
+char *inet_ntoa(struct in_addr in)
+{
+       static char b[18];
+       register char *p;
+
+       p = (char *)&in;
+#define        UC(b)   (((int)b)&0xff)
+       (void)snprintf(b, sizeof(b),
+           "%u.%u.%u.%u", UC(p[0]), UC(p[1]), UC(p[2]), UC(p[3]));
+       return (b);
+}
+
+#endif /* defined(BROKEN_INET_NTOA) || !defined(HAVE_INET_NTOA) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/inet_ntop.c b/crypto/openssh-3.8.1p1/openbsd-compat/inet_ntop.c
new file mode 100644 (file)
index 0000000..7031625
--- /dev/null
@@ -0,0 +1,231 @@
+/* OPENBSD ORIGINAL: lib/libc/net/inet_ntop.c */
+
+/*     $OpenBSD: inet_ntop.c,v 1.5 2002/08/23 16:27:31 itojun Exp $    */
+
+/* Copyright (c) 1996 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
+ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
+ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+#include "includes.h"
+
+#ifndef HAVE_INET_NTOP
+
+#if defined(LIBC_SCCS) && !defined(lint)
+#if 0
+static char rcsid[] = "$From: inet_ntop.c,v 8.7 1996/08/05 08:41:18 vixie Exp $";
+#else
+static char rcsid[] = "$OpenBSD: inet_ntop.c,v 1.5 2002/08/23 16:27:31 itojun Exp $";
+#endif
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/param.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#ifndef HAVE_CYGWIN
+#include <arpa/nameser.h>
+#endif
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+
+#ifndef IN6ADDRSZ
+#define IN6ADDRSZ   16   /* IPv6 T_AAAA */                 
+#endif
+
+#ifndef INT16SZ
+#define INT16SZ     2    /* for systems without 16-bit ints */
+#endif
+
+/*
+ * WARNING: Don't even consider trying to compile this on a system where
+ * sizeof(int) < 4.  sizeof(int) > 4 is fine; all the world's not a VAX.
+ */
+
+static const char *inet_ntop4(const u_char *src, char *dst, size_t size);
+static const char *inet_ntop6(const u_char *src, char *dst, size_t size);
+
+/* char *
+ * inet_ntop(af, src, dst, size)
+ *     convert a network format address to presentation format.
+ * return:
+ *     pointer to presentation format address (`dst'), or NULL (see errno).
+ * author:
+ *     Paul Vixie, 1996.
+ */
+const char *
+inet_ntop(af, src, dst, size)
+       int af;
+       const void *src;
+       char *dst;
+       size_t size;
+{
+       switch (af) {
+       case AF_INET:
+               return (inet_ntop4(src, dst, size));
+       case AF_INET6:
+               return (inet_ntop6(src, dst, size));
+       default:
+               errno = EAFNOSUPPORT;
+               return (NULL);
+       }
+       /* NOTREACHED */
+}
+
+/* const char *
+ * inet_ntop4(src, dst, size)
+ *     format an IPv4 address, more or less like inet_ntoa()
+ * return:
+ *     `dst' (as a const)
+ * notes:
+ *     (1) uses no statics
+ *     (2) takes a u_char* not an in_addr as input
+ * author:
+ *     Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop4(src, dst, size)
+       const u_char *src;
+       char *dst;
+       size_t size;
+{
+       static const char fmt[] = "%u.%u.%u.%u";
+       char tmp[sizeof "255.255.255.255"];
+       int l;
+
+       l = snprintf(tmp, size, fmt, src[0], src[1], src[2], src[3]);
+       if (l <= 0 || l >= size) {
+               errno = ENOSPC;
+               return (NULL);
+       }
+       strlcpy(dst, tmp, size);
+       return (dst);
+}
+
+/* const char *
+ * inet_ntop6(src, dst, size)
+ *     convert IPv6 binary address into presentation (printable) format
+ * author:
+ *     Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop6(src, dst, size)
+       const u_char *src;
+       char *dst;
+       size_t size;
+{
+       /*
+        * Note that int32_t and int16_t need only be "at least" large enough
+        * to contain a value of the specified size.  On some systems, like
+        * Crays, there is no such thing as an integer variable with 16 bits.
+        * Keep this in mind if you think this function should have been coded
+        * to use pointer overlays.  All the world's not a VAX.
+        */
+       char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255"];
+       char *tp, *ep;
+       struct { int base, len; } best, cur;
+       u_int words[IN6ADDRSZ / INT16SZ];
+       int i;
+       int advance;
+
+       /*
+        * Preprocess:
+        *      Copy the input (bytewise) array into a wordwise array.
+        *      Find the longest run of 0x00's in src[] for :: shorthanding.
+        */
+       memset(words, '\0', sizeof words);
+       for (i = 0; i < IN6ADDRSZ; i++)
+               words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
+       best.base = -1;
+       cur.base = -1;
+       for (i = 0; i < (IN6ADDRSZ / INT16SZ); i++) {
+               if (words[i] == 0) {
+                       if (cur.base == -1)
+                               cur.base = i, cur.len = 1;
+                       else
+                               cur.len++;
+               } else {
+                       if (cur.base != -1) {
+                               if (best.base == -1 || cur.len > best.len)
+                                       best = cur;
+                               cur.base = -1;
+                       }
+               }
+       }
+       if (cur.base != -1) {
+               if (best.base == -1 || cur.len > best.len)
+                       best = cur;
+       }
+       if (best.base != -1 && best.len < 2)
+               best.base = -1;
+
+       /*
+        * Format the result.
+        */
+       tp = tmp;
+       ep = tmp + sizeof(tmp);
+       for (i = 0; i < (IN6ADDRSZ / INT16SZ) && tp < ep; i++) {
+               /* Are we inside the best run of 0x00's? */
+               if (best.base != -1 && i >= best.base &&
+                   i < (best.base + best.len)) {
+                       if (i == best.base) {
+                               if (tp + 1 >= ep)
+                                       return (NULL);
+                               *tp++ = ':';
+                       }
+                       continue;
+               }
+               /* Are we following an initial run of 0x00s or any real hex? */
+               if (i != 0) {
+                       if (tp + 1 >= ep)
+                               return (NULL);
+                       *tp++ = ':';
+               }
+               /* Is this address an encapsulated IPv4? */
+               if (i == 6 && best.base == 0 &&
+                   (best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
+                       if (!inet_ntop4(src+12, tp, (size_t)(ep - tp)))
+                               return (NULL);
+                       tp += strlen(tp);
+                       break;
+               }
+               advance = snprintf(tp, ep - tp, "%x", words[i]);
+               if (advance <= 0 || advance >= ep - tp)
+                       return (NULL);
+               tp += advance;
+       }
+       /* Was it a trailing run of 0x00's? */
+       if (best.base != -1 && (best.base + best.len) == (IN6ADDRSZ / INT16SZ)) {
+               if (tp + 1 >= ep)
+                       return (NULL);
+               *tp++ = ':';
+       }
+       if (tp + 1 >= ep)
+               return (NULL);
+       *tp++ = '\0';
+
+       /*
+        * Check for overflow, copy, and we're done.
+        */
+       if ((size_t)(tp - tmp) > size) {
+               errno = ENOSPC;
+               return (NULL);
+       }
+       strlcpy(dst, tmp, size);
+       return (dst);
+}
+
+#endif /* !HAVE_INET_NTOP */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/mktemp.c b/crypto/openssh-3.8.1p1/openbsd-compat/mktemp.c
new file mode 100644 (file)
index 0000000..aff8d20
--- /dev/null
@@ -0,0 +1,182 @@
+/* OPENBSD ORIGINAL: lib/libc/stdio/mktemp.c */
+
+/* THIS FILE HAS BEEN MODIFIED FROM THE ORIGINAL OPENBSD SOURCE */
+/* Changes: Removed mktemp */
+
+/*
+ * Copyright (c) 1987, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#if !defined(HAVE_MKDTEMP) || defined(HAVE_STRICT_MKSTEMP)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char rcsid[] = "$OpenBSD: mktemp.c,v 1.17 2003/06/02 20:18:37 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#ifdef HAVE_CYGWIN
+#define open binary_open
+extern int binary_open();
+#endif
+
+static int _gettemp(char *, int *, int, int);
+
+int
+mkstemps(path, slen)
+       char *path;
+       int slen;
+{
+       int fd;
+
+       return (_gettemp(path, &fd, 0, slen) ? fd : -1);
+}
+
+int
+mkstemp(path)
+       char *path;
+{
+       int fd;
+
+       return (_gettemp(path, &fd, 0, 0) ? fd : -1);
+}
+
+char *
+mkdtemp(path)
+       char *path;
+{
+       return(_gettemp(path, (int *)NULL, 1, 0) ? path : (char *)NULL);
+}
+
+static int
+_gettemp(path, doopen, domkdir, slen)
+       char *path;
+       register int *doopen;
+       int domkdir;
+       int slen;
+{
+       register char *start, *trv, *suffp;
+       struct stat sbuf;
+       int rval;
+       pid_t pid;
+
+       if (doopen && domkdir) {
+               errno = EINVAL;
+               return(0);
+       }
+
+       for (trv = path; *trv; ++trv)
+               ;
+       trv -= slen;
+       suffp = trv;
+       --trv;
+       if (trv < path) {
+               errno = EINVAL;
+               return (0);
+       }
+       pid = getpid();
+       while (trv >= path && *trv == 'X' && pid != 0) {
+               *trv-- = (pid % 10) + '0';
+               pid /= 10;
+       }
+       while (trv >= path && *trv == 'X') {
+               char c;
+
+               pid = (arc4random() & 0xffff) % (26+26);
+               if (pid < 26)
+                       c = pid + 'A';
+               else
+                       c = (pid - 26) + 'a';
+               *trv-- = c;
+       }
+       start = trv + 1;
+
+       /*
+        * check the target directory; if you have six X's and it
+        * doesn't exist this runs for a *very* long time.
+        */
+       if (doopen || domkdir) {
+               for (;; --trv) {
+                       if (trv <= path)
+                               break;
+                       if (*trv == '/') {
+                               *trv = '\0';
+                               rval = stat(path, &sbuf);
+                               *trv = '/';
+                               if (rval != 0)
+                                       return(0);
+                               if (!S_ISDIR(sbuf.st_mode)) {
+                                       errno = ENOTDIR;
+                                       return(0);
+                               }
+                               break;
+                       }
+               }
+       }
+
+       for (;;) {
+               if (doopen) {
+                       if ((*doopen =
+                           open(path, O_CREAT|O_EXCL|O_RDWR, 0600)) >= 0)
+                               return(1);
+                       if (errno != EEXIST)
+                               return(0);
+               } else if (domkdir) {
+                       if (mkdir(path, 0700) == 0)
+                               return(1);
+                       if (errno != EEXIST)
+                               return(0);
+               } else if (lstat(path, &sbuf))
+                       return(errno == ENOENT ? 1 : 0);
+
+               /* tricky little algorithm for backward compatibility */
+               for (trv = start;;) {
+                       if (!*trv)
+                               return (0);
+                       if (*trv == 'Z') {
+                               if (trv == suffp)
+                                       return (0);
+                               *trv++ = 'a';
+                       } else {
+                               if (isdigit(*trv))
+                                       *trv = 'a';
+                               else if (*trv == 'z')   /* inc from z to A */
+                                       *trv = 'A';
+                               else {
+                                       if (trv == suffp)
+                                               return (0);
+                                       ++*trv;
+                               }
+                               break;
+                       }
+               }
+       }
+       /*NOTREACHED*/
+}
+
+#endif /* !defined(HAVE_MKDTEMP) || defined(HAVE_STRICT_MKSTEMP) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/openbsd-compat.h b/crypto/openssh-3.8.1p1/openbsd-compat/openbsd-compat.h
new file mode 100644 (file)
index 0000000..6be1bcd
--- /dev/null
@@ -0,0 +1,169 @@
+/* $Id: openbsd-compat.h,v 1.25 2004/01/21 06:07:23 djm Exp $ */
+
+/*
+ * Copyright (c) 1999-2003 Damien Miller.  All rights reserved.
+ * Copyright (c) 2003 Ben Lindstrom. All rights reserved.
+ * Copyright (c) 2002 Tim Rice.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _OPENBSD_COMPAT_H
+#define _OPENBSD_COMPAT_H
+
+#include "includes.h"
+
+/* OpenBSD function replacements */
+#include "base64.h"
+#include "sigact.h"
+#include "glob.h"
+#include "readpassphrase.h"
+#include "vis.h"
+#include "getrrsetbyname.h"
+
+
+#ifndef HAVE_BASENAME
+char *basename(const char *path);
+#endif
+
+#ifndef HAVE_BINDRESVPORT_SA
+int bindresvport_sa(int sd, struct sockaddr *sa);
+#endif
+
+#ifndef HAVE_GETCWD
+char *getcwd(char *pt, size_t size);
+#endif 
+
+#if !defined(HAVE_REALPATH) || defined(BROKEN_REALPATH)
+char *realpath(const char *path, char *resolved);
+#endif 
+
+#ifndef HAVE_RRESVPORT_AF
+int rresvport_af(int *alport, sa_family_t af);
+#endif
+
+#ifndef HAVE_STRLCPY
+/* #include <sys/types.h> XXX Still needed? */
+size_t strlcpy(char *dst, const char *src, size_t siz);
+#endif
+
+#ifndef HAVE_STRLCAT
+/* #include <sys/types.h> XXX Still needed? */
+size_t strlcat(char *dst, const char *src, size_t siz);
+#endif 
+
+#ifndef HAVE_SETENV
+int setenv(register const char *name, register const char *value, int rewrite);
+#endif
+
+#ifndef HAVE_STRMODE
+void strmode(int mode, char *p);
+#endif
+
+#if !defined(HAVE_MKDTEMP) || defined(HAVE_STRICT_MKSTEMP)
+int mkstemps(char *path, int slen);
+int mkstemp(char *path);
+char *mkdtemp(char *path);
+#endif 
+
+#ifndef HAVE_DAEMON
+int daemon(int nochdir, int noclose);
+#endif 
+
+#ifndef HAVE_DIRNAME
+char *dirname(const char *path);
+#endif
+
+#if defined(BROKEN_INET_NTOA) || !defined(HAVE_INET_NTOA)
+char *inet_ntoa(struct in_addr in);
+#endif
+
+#ifndef HAVE_INET_NTOP
+const char *inet_ntop(int af, const void *src, char *dst, size_t size);
+#endif
+
+#ifndef HAVE_INET_ATON
+int inet_aton(const char *cp, struct in_addr *addr);
+#endif 
+
+#ifndef HAVE_STRSEP
+char *strsep(char **stringp, const char *delim);
+#endif
+
+#ifndef HAVE_SETPROCTITLE
+void setproctitle(const char *fmt, ...);
+void compat_init_setproctitle(int argc, char *argv[]);
+#endif
+
+#ifndef HAVE_GETGROUPLIST
+/* #include <grp.h> XXXX Still needed ? */
+int getgrouplist(const char *, gid_t, gid_t *, int *);
+#endif
+
+#if !defined(HAVE_GETOPT) || !defined(HAVE_GETOPT_OPTRESET)
+int BSDgetopt(int argc, char * const *argv, const char *opts);
+#endif
+
+
+/* Home grown routines */
+#include "bsd-misc.h"
+#include "bsd-waitpid.h"
+
+/*#include <sys/types.h> XXX Still needed? * For uid_t, gid_t * */
+
+#ifndef HAVE_GETPEEREID
+int getpeereid(int , uid_t *, gid_t *);
+#endif 
+
+#ifndef HAVE_ARC4RANDOM
+unsigned int arc4random(void);
+void arc4random_stir(void);
+#endif /* !HAVE_ARC4RANDOM */
+
+#ifndef HAVE_OPENPTY
+int openpty(int *, int *, char *, struct termios *, struct winsize *);
+#endif /* HAVE_OPENPTY */
+
+/* #include <sys/types.h> XXX needed? For size_t */
+
+#ifndef HAVE_SNPRINTF
+int snprintf(char *, size_t, const char *, ...);
+#endif 
+
+#ifndef HAVE_VSNPRINTF
+int vsnprintf(char *, size_t, const char *, va_list);
+#endif
+
+void *xmmap(size_t size);
+char *xcrypt(const char *password, const char *salt);
+char *shadow_pw(struct passwd *pw);
+
+
+/* rfc2553 socket API replacements */
+#include "fake-rfc2553.h"
+
+/* Routines for a single OS platform */
+#include "bsd-cray.h"
+#include "bsd-cygwin_util.h"
+#include "port-irix.h"
+#include "port-aix.h"
+
+#endif /* _OPENBSD_COMPAT_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/port-aix.c b/crypto/openssh-3.8.1p1/openbsd-compat/port-aix.c
new file mode 100644 (file)
index 0000000..2895f0d
--- /dev/null
@@ -0,0 +1,240 @@
+/*
+ *
+ * Copyright (c) 2001 Gert Doering.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include "includes.h"
+#include "auth.h"
+#include "ssh.h"
+#include "log.h"
+#include "servconf.h"
+#include "canohost.h"
+#include "xmalloc.h"
+#include "buffer.h"
+
+#ifdef _AIX
+
+#include <uinfo.h>
+#include "port-aix.h"
+
+extern ServerOptions options;
+extern Buffer loginmsg;
+
+# ifdef HAVE_SETAUTHDB
+static char old_registry[REGISTRY_SIZE] = "";
+# endif
+
+/*
+ * AIX has a "usrinfo" area where logname and other stuff is stored - 
+ * a few applications actually use this and die if it's not set
+ *
+ * NOTE: TTY= should be set, but since no one uses it and it's hard to
+ * acquire due to privsep code.  We will just drop support.
+ */
+void
+aix_usrinfo(struct passwd *pw)
+{
+       u_int i;
+       size_t len;
+       char *cp;
+
+       len = sizeof("LOGNAME= NAME= ") + (2 * strlen(pw->pw_name));
+       cp = xmalloc(len);
+
+       i = snprintf(cp, len, "LOGNAME=%s%cNAME=%s%c", pw->pw_name, '\0', 
+           pw->pw_name, '\0');
+       if (usrinfo(SETUINFO, cp, i) == -1)
+               fatal("Couldn't set usrinfo: %s", strerror(errno));
+       debug3("AIX/UsrInfo: set len %d", i);
+
+       xfree(cp);
+}
+
+# ifdef WITH_AIXAUTHENTICATE
+/*
+ * Remove embedded newlines in string (if any).
+ * Used before logging messages returned by AIX authentication functions
+ * so the message is logged on one line.
+ */
+void
+aix_remove_embedded_newlines(char *p)
+{
+       if (p == NULL)
+               return;
+
+       for (; *p; p++) {
+               if (*p == '\n')
+                       *p = ' ';
+       }
+       /* Remove trailing whitespace */
+       if (*--p == ' ')
+               *p = '\0';
+}
+
+/*
+ * Do authentication via AIX's authenticate routine.  We loop until the
+ * reenter parameter is 0, but normally authenticate is called only once.
+ *
+ * Note: this function returns 1 on success, whereas AIX's authenticate()
+ * returns 0.
+ */
+int
+sys_auth_passwd(Authctxt *ctxt, const char *password)
+{
+       char *authmsg = NULL, *host, *msg, *name = ctxt->pw->pw_name;
+       int authsuccess = 0, expired, reenter, result;
+
+       do {
+               result = authenticate((char *)name, (char *)password, &reenter,
+                   &authmsg);
+               aix_remove_embedded_newlines(authmsg);  
+               debug3("AIX/authenticate result %d, msg %.100s", result,
+                   authmsg);
+       } while (reenter);
+
+       if (result == 0) {
+               authsuccess = 1;
+
+               host = (char *)get_canonical_hostname(options.use_dns);
+
+               /*
+                * Record successful login.  We don't have a pty yet, so just
+                * label the line as "ssh"
+                */
+               aix_setauthdb(name);
+               if (loginsuccess((char *)name, (char *)host, "ssh", &msg) == 0) {
+                       if (msg != NULL) {
+                               debug("%s: msg %s", __func__, msg);
+                               buffer_append(&loginmsg, msg, strlen(msg));
+                               xfree(msg);
+                       }
+               }
+
+               /*
+                * Check if the user's password is expired.
+                */
+                expired = passwdexpired(name, &msg);
+                if (msg && *msg) {
+                        buffer_append(&loginmsg, msg, strlen(msg));
+                        aix_remove_embedded_newlines(msg);
+                }
+                debug3("AIX/passwdexpired returned %d msg %.100s", expired, msg);
+
+               switch (expired) {
+               case 0: /* password not expired */
+                       break;
+               case 1: /* expired, password change required */
+                       ctxt->force_pwchange = 1;
+                       disable_forwarding();
+                       break;
+               default: /* user can't change(2) or other error (-1) */
+                       logit("Password can't be changed for user %s: %.100s",
+                           name, msg);
+                       if (msg)
+                               xfree(msg);
+                       authsuccess = 0;
+               }
+
+               aix_restoreauthdb();
+       }
+
+       if (authmsg != NULL)
+               xfree(authmsg);
+
+       return authsuccess;
+}
+  
+#  ifdef CUSTOM_FAILED_LOGIN
+/*
+ * record_failed_login: generic "login failed" interface function
+ */
+void
+record_failed_login(const char *user, const char *ttyname)
+{
+       char *hostname = (char *)get_canonical_hostname(options.use_dns);
+
+       if (geteuid() != 0)
+               return;
+
+       aix_setauthdb(user);
+#   ifdef AIX_LOGINFAILED_4ARG
+       loginfailed((char *)user, hostname, (char *)ttyname, AUDIT_FAIL_AUTH);
+#   else
+       loginfailed((char *)user, hostname, (char *)ttyname);
+#   endif
+       aix_restoreauthdb();
+}
+#  endif /* CUSTOM_FAILED_LOGIN */
+
+/*
+ * If we have setauthdb, retrieve the password registry for the user's
+ * account then feed it to setauthdb.  This will mean that subsequent AIX auth
+ * functions will only use the specified loadable module.  If we don't have
+ * setauthdb this is a no-op.
+ */
+void
+aix_setauthdb(const char *user)
+{
+#  ifdef HAVE_SETAUTHDB
+       char *registry;
+
+       if (setuserdb(S_READ) == -1) {
+               debug3("%s: Could not open userdb to read", __func__);
+               return;
+       }
+       
+       if (getuserattr((char *)user, S_REGISTRY, &registry, SEC_CHAR) == 0) {
+               if (setauthdb(registry, old_registry) == 0)
+                       debug3("AIX/setauthdb set registry '%s'", registry);
+               else 
+                       debug3("AIX/setauthdb set registry '%s' failed: %s",
+                           registry, strerror(errno));
+       } else
+               debug3("%s: Could not read S_REGISTRY for user: %s", __func__,
+                   strerror(errno));
+       enduserdb();
+#  endif /* HAVE_SETAUTHDB */
+}
+
+/*
+ * Restore the user's registry settings from old_registry.
+ * Note that if the first aix_setauthdb fails, setauthdb("") is still safe
+ * (it restores the system default behaviour).  If we don't have setauthdb,
+ * this is a no-op.
+ */
+void
+aix_restoreauthdb(void)
+{
+#  ifdef HAVE_SETAUTHDB
+       if (setauthdb(old_registry, NULL) == 0)
+               debug3("%s: restoring old registry '%s'", __func__,
+                   old_registry);
+       else
+               debug3("%s: failed to restore old registry %s", __func__,
+                   old_registry);
+#  endif /* HAVE_SETAUTHDB */
+}
+
+# endif /* WITH_AIXAUTHENTICATE */
+
+#endif /* _AIX */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/port-aix.h b/crypto/openssh-3.8.1p1/openbsd-compat/port-aix.h
new file mode 100644 (file)
index 0000000..3118af9
--- /dev/null
@@ -0,0 +1,73 @@
+/* $Id: port-aix.h,v 1.19 2004/02/10 04:27:35 dtucker Exp $ */
+
+/*
+ *
+ * Copyright (c) 2001 Gert Doering.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifdef _AIX
+
+#ifdef WITH_AIXAUTHENTICATE
+# include <login.h>
+# include <userpw.h>
+# if defined(HAVE_SYS_AUDIT_H) && defined(AIX_LOGINFAILED_4ARG)
+#  include <sys/audit.h>
+# endif
+# include <usersec.h>
+#endif
+
+/* Some versions define r_type in the above headers, which causes a conflict */
+#ifdef r_type
+# undef r_type
+#endif
+
+/* AIX 4.2.x doesn't have nanosleep but does have nsleep which is equivalent */
+#if !defined(HAVE_NANOSLEEP) && defined(HAVE_NSLEEP)
+# define nanosleep(a,b) nsleep(a,b)
+#endif
+
+/* For struct timespec on AIX 4.2.x */
+#ifdef HAVE_SYS_TIMERS_H
+# include <sys/timers.h>
+#endif
+
+/*
+ * According to the setauthdb man page, AIX password registries must be 15
+ * chars or less plus terminating NUL.
+ */
+#ifdef HAVE_SETAUTHDB
+# define REGISTRY_SIZE 16
+#endif
+
+void aix_usrinfo(struct passwd *);
+
+#ifdef WITH_AIXAUTHENTICATE
+# define CUSTOM_SYS_AUTH_PASSWD 1
+# define CUSTOM_FAILED_LOGIN 1
+void record_failed_login(const char *, const char *);
+#endif
+
+void aix_setauthdb(const char *);
+void aix_restoreauthdb(void);
+void aix_remove_embedded_newlines(char *);
+#endif /* _AIX */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/port-irix.c b/crypto/openssh-3.8.1p1/openbsd-compat/port-irix.c
new file mode 100644 (file)
index 0000000..aa6db1c
--- /dev/null
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2000 Denis Parker.  All rights reserved.
+ * Copyright (c) 2000 Michael Stone.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#if defined(WITH_IRIX_PROJECT) || \
+    defined(WITH_IRIX_JOBS) || \
+    defined(WITH_IRIX_ARRAY)
+
+#ifdef WITH_IRIX_PROJECT
+# include <proj.h>
+#endif /* WITH_IRIX_PROJECT */
+#ifdef WITH_IRIX_JOBS
+# include <sys/resource.h>
+#endif
+#ifdef WITH_IRIX_AUDIT
+# include <sat.h>
+#endif /* WITH_IRIX_AUDIT */
+
+void
+irix_setusercontext(struct passwd *pw)
+{
+#ifdef WITH_IRIX_PROJECT
+        prid_t projid;
+#endif
+#ifdef WITH_IRIX_JOBS
+        jid_t jid = 0;
+#elif defined(WITH_IRIX_ARRAY)
+        int jid = 0;
+#endif
+
+#ifdef WITH_IRIX_JOBS
+        jid = jlimit_startjob(pw->pw_name, pw->pw_uid, "interactive");
+        if (jid == -1)
+                fatal("Failed to create job container: %.100s",
+                    strerror(errno));
+#endif /* WITH_IRIX_JOBS */
+#ifdef WITH_IRIX_ARRAY
+        /* initialize array session */
+        if (jid == 0  && newarraysess() != 0)
+                fatal("Failed to set up new array session: %.100s",
+                    strerror(errno));
+#endif /* WITH_IRIX_ARRAY */
+#ifdef WITH_IRIX_PROJECT
+        /* initialize irix project info */
+        if ((projid = getdfltprojuser(pw->pw_name)) == -1) {
+                debug("Failed to get project id, using projid 0");
+                projid = 0;
+        }
+        if (setprid(projid))
+                fatal("Failed to initialize project %d for %s: %.100s",
+                    (int)projid, pw->pw_name, strerror(errno));
+#endif /* WITH_IRIX_PROJECT */
+#ifdef WITH_IRIX_AUDIT
+        if (sysconf(_SC_AUDIT)) {
+                debug("Setting sat id to %d", (int) pw->pw_uid);
+                if (satsetid(pw->pw_uid))
+                        debug("error setting satid: %.100s", strerror(errno));
+        }
+#endif /* WITH_IRIX_AUDIT */
+}
+
+
+#endif /* defined(WITH_IRIX_PROJECT) || defined(WITH_IRIX_JOBS) || defined(WITH_IRIX_ARRAY) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/port-irix.h b/crypto/openssh-3.8.1p1/openbsd-compat/port-irix.h
new file mode 100644 (file)
index 0000000..67c4863
--- /dev/null
@@ -0,0 +1,39 @@
+/* $Id: port-irix.h,v 1.4 2003/08/29 16:59:52 mouring Exp $ */
+
+/*
+ * Copyright (c) 2000 Denis Parker.  All rights reserved.
+ * Copyright (c) 2000 Michael Stone.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _PORT_IRIX_H
+#define _PORT_IRIX_H
+
+#if defined(WITH_IRIX_PROJECT) || \
+    defined(WITH_IRIX_JOBS) || \
+    defined(WITH_IRIX_ARRAY)
+
+void irix_setusercontext(struct passwd *pw);
+
+#endif /* defined(WITH_IRIX_PROJECT) || defined(WITH_IRIX_JOBS) || defined(WITH_IRIX_ARRAY) */
+
+#endif /* ! _PORT_IRIX_H */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/readpassphrase.c b/crypto/openssh-3.8.1p1/openbsd-compat/readpassphrase.c
new file mode 100644 (file)
index 0000000..4ee1be5
--- /dev/null
@@ -0,0 +1,186 @@
+/* OPENBSD ORIGINAL: lib/libc/gen/readpassphrase.c */
+
+/*     $OpenBSD: readpassphrase.c,v 1.16 2003/06/17 21:56:23 millert Exp $     */
+
+/*
+ * Copyright (c) 2000-2002 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ *
+ * Sponsored in part by the Defense Advanced Research Projects
+ * Agency (DARPA) and Air Force Research Laboratory, Air Force
+ * Materiel Command, USAF, under agreement number F39502-99-1-0512.
+ */
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static const char rcsid[] = "$OpenBSD: readpassphrase.c,v 1.16 2003/06/17 21:56:23 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include "includes.h"
+
+#ifndef HAVE_READPASSPHRASE
+
+#include <termios.h>
+#include <readpassphrase.h>
+
+#ifdef TCSASOFT
+# define _T_FLUSH      (TCSAFLUSH|TCSASOFT)
+#else
+# define _T_FLUSH      (TCSAFLUSH)
+#endif
+
+/* SunOS 4.x which lacks _POSIX_VDISABLE, but has VDISABLE */
+#if !defined(_POSIX_VDISABLE) && defined(VDISABLE)
+#  define _POSIX_VDISABLE       VDISABLE
+#endif
+
+static volatile sig_atomic_t signo;
+
+static void handler(int);
+
+char *
+readpassphrase(const char *prompt, char *buf, size_t bufsiz, int flags)
+{
+       ssize_t nr;
+       int input, output, save_errno;
+       char ch, *p, *end;
+       struct termios term, oterm;
+       struct sigaction sa, savealrm, saveint, savehup, savequit, saveterm;
+       struct sigaction savetstp, savettin, savettou, savepipe;
+
+       /* I suppose we could alloc on demand in this case (XXX). */
+       if (bufsiz == 0) {
+               errno = EINVAL;
+               return(NULL);
+       }
+
+restart:
+       signo = 0;
+       /*
+        * Read and write to /dev/tty if available.  If not, read from
+        * stdin and write to stderr unless a tty is required.
+        */
+       if ((flags & RPP_STDIN) ||
+           (input = output = open(_PATH_TTY, O_RDWR)) == -1) {
+               if (flags & RPP_REQUIRE_TTY) {
+                       errno = ENOTTY;
+                       return(NULL);
+               }
+               input = STDIN_FILENO;
+               output = STDERR_FILENO;
+       }
+
+       /*
+        * Catch signals that would otherwise cause the user to end
+        * up with echo turned off in the shell.  Don't worry about
+        * things like SIGXCPU and SIGVTALRM for now.
+        */
+       sigemptyset(&sa.sa_mask);
+       sa.sa_flags = 0;                /* don't restart system calls */
+       sa.sa_handler = handler;
+       (void)sigaction(SIGALRM, &sa, &savealrm);
+       (void)sigaction(SIGHUP, &sa, &savehup);
+       (void)sigaction(SIGINT, &sa, &saveint);
+       (void)sigaction(SIGPIPE, &sa, &savepipe);
+       (void)sigaction(SIGQUIT, &sa, &savequit);
+       (void)sigaction(SIGTERM, &sa, &saveterm);
+       (void)sigaction(SIGTSTP, &sa, &savetstp);
+       (void)sigaction(SIGTTIN, &sa, &savettin);
+       (void)sigaction(SIGTTOU, &sa, &savettou);
+
+       /* Turn off echo if possible. */
+       if (input != STDIN_FILENO && tcgetattr(input, &oterm) == 0) {
+               memcpy(&term, &oterm, sizeof(term));
+               if (!(flags & RPP_ECHO_ON))
+                       term.c_lflag &= ~(ECHO | ECHONL);
+#ifdef VSTATUS
+               if (term.c_cc[VSTATUS] != _POSIX_VDISABLE)
+                       term.c_cc[VSTATUS] = _POSIX_VDISABLE;
+#endif
+               (void)tcsetattr(input, _T_FLUSH, &term);
+       } else {
+               memset(&term, 0, sizeof(term));
+               term.c_lflag |= ECHO;
+               memset(&oterm, 0, sizeof(oterm));
+               oterm.c_lflag |= ECHO;
+       }
+
+       if (!(flags & RPP_STDIN))
+               (void)write(output, prompt, strlen(prompt));
+       end = buf + bufsiz - 1;
+       for (p = buf; (nr = read(input, &ch, 1)) == 1 && ch != '\n' && ch != '\r';) {
+               if (p < end) {
+                       if ((flags & RPP_SEVENBIT))
+                               ch &= 0x7f;
+                       if (isalpha(ch)) {
+                               if ((flags & RPP_FORCELOWER))
+                                       ch = tolower(ch);
+                               if ((flags & RPP_FORCEUPPER))
+                                       ch = toupper(ch);
+                       }
+                       *p++ = ch;
+               }
+       }
+       *p = '\0';
+       save_errno = errno;
+       if (!(term.c_lflag & ECHO))
+               (void)write(output, "\n", 1);
+
+       /* Restore old terminal settings and signals. */
+       if (memcmp(&term, &oterm, sizeof(term)) != 0)
+               (void)tcsetattr(input, _T_FLUSH, &oterm);
+       (void)sigaction(SIGALRM, &savealrm, NULL);
+       (void)sigaction(SIGHUP, &savehup, NULL);
+       (void)sigaction(SIGINT, &saveint, NULL);
+       (void)sigaction(SIGQUIT, &savequit, NULL);
+       (void)sigaction(SIGPIPE, &savepipe, NULL);
+       (void)sigaction(SIGTERM, &saveterm, NULL);
+       (void)sigaction(SIGTSTP, &savetstp, NULL);
+       (void)sigaction(SIGTTIN, &savettin, NULL);
+       if (input != STDIN_FILENO)
+               (void)close(input);
+
+       /*
+        * If we were interrupted by a signal, resend it to ourselves
+        * now that we have restored the signal handlers.
+        */
+       if (signo) {
+               kill(getpid(), signo);
+               switch (signo) {
+               case SIGTSTP:
+               case SIGTTIN:
+               case SIGTTOU:
+                       goto restart;
+               }
+       }
+
+       errno = save_errno;
+       return(nr == -1 ? NULL : buf);
+}
+  
+#if 0
+char *
+getpass(const char *prompt)
+{
+       static char buf[_PASSWORD_LEN + 1];
+
+       return(readpassphrase(prompt, buf, sizeof(buf), RPP_ECHO_OFF));
+}
+#endif
+
+static void handler(int s)
+{
+
+       signo = s;
+}
+#endif /* HAVE_READPASSPHRASE */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/readpassphrase.h b/crypto/openssh-3.8.1p1/openbsd-compat/readpassphrase.h
new file mode 100644 (file)
index 0000000..178edf3
--- /dev/null
@@ -0,0 +1,51 @@
+/* OPENBSD ORIGINAL: include/readpassphrase.h */
+
+/*     $OpenBSD: readpassphrase.h,v 1.3 2002/06/28 12:32:22 millert Exp $      */
+
+/*
+ * Copyright (c) 2000 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _READPASSPHRASE_H_
+#define _READPASSPHRASE_H_
+
+#include "includes.h"
+
+#ifndef HAVE_READPASSPHRASE
+
+#define RPP_ECHO_OFF    0x00           /* Turn off echo (default). */
+#define RPP_ECHO_ON     0x01           /* Leave echo on. */
+#define RPP_REQUIRE_TTY 0x02           /* Fail if there is no tty. */
+#define RPP_FORCELOWER  0x04           /* Force input to lower case. */
+#define RPP_FORCEUPPER  0x08           /* Force input to upper case. */
+#define RPP_SEVENBIT    0x10           /* Strip the high bit from input. */
+#define RPP_STDIN       0x20           /* Read from stdin, not /dev/tty */
+
+char * readpassphrase(const char *, char *, size_t, int);
+
+#endif /* HAVE_READPASSPHRASE */
+
+#endif /* !_READPASSPHRASE_H_ */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/realpath.c b/crypto/openssh-3.8.1p1/openbsd-compat/realpath.c
new file mode 100644 (file)
index 0000000..218fbec
--- /dev/null
@@ -0,0 +1,171 @@
+/* OPENBSD ORIGINAL: lib/libc/stdlib/realpath.c */
+
+/*
+ * Copyright (c) 1994
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Jan-Simon Pendry.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#if !defined(HAVE_REALPATH) || defined(BROKEN_REALPATH)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: realpath.c,v 1.10 2003/08/01 21:04:59 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*
+ * MAXSYMLINKS
+ */
+#ifndef MAXSYMLINKS
+#define MAXSYMLINKS 5
+#endif
+
+/*
+ * char *realpath(const char *path, char resolved_path[MAXPATHLEN]);
+ *
+ * Find the real name of path, by removing all ".", ".." and symlink
+ * components.  Returns (resolved) on success, or (NULL) on failure,
+ * in which case the path which caused trouble is left in (resolved).
+ */
+char *
+realpath(const char *path, char *resolved)
+{
+       struct stat sb;
+       int fd, n, needslash, serrno = 0;
+       char *p, *q, wbuf[MAXPATHLEN], start[MAXPATHLEN];
+       int symlinks = 0;
+
+       /* Save the starting point. */
+       getcwd(start,MAXPATHLEN);       
+       if ((fd = open(".", O_RDONLY)) < 0) {
+               (void)strlcpy(resolved, ".", MAXPATHLEN);
+               return (NULL);
+       }
+       close(fd);
+
+       /* Convert "." -> "" to optimize away a needless lstat() and chdir() */
+       if (path[0] == '.' && path[1] == '\0')
+               path = "";
+
+       /*
+        * Find the dirname and basename from the path to be resolved.
+        * Change directory to the dirname component.
+        * lstat the basename part.
+        *     if it is a symlink, read in the value and loop.
+        *     if it is a directory, then change to that directory.
+        * get the current directory name and append the basename.
+        */
+       strlcpy(resolved, path, MAXPATHLEN);
+loop:
+       q = strrchr(resolved, '/');
+       if (q != NULL) {
+               p = q + 1;
+               if (q == resolved)
+                       q = "/";
+               else {
+                       do {
+                               --q;
+                       } while (q > resolved && *q == '/');
+                       q[1] = '\0';
+                       q = resolved;
+               }
+               if (chdir(q) < 0)
+                       goto err1;
+       } else
+               p = resolved;
+
+       /* Deal with the last component. */
+       if (*p != '\0' && lstat(p, &sb) == 0) {
+               if (S_ISLNK(sb.st_mode)) {
+                       if (++symlinks > MAXSYMLINKS) {
+                               serrno = ELOOP;
+                               goto err1;
+                       }
+                       n = readlink(p, resolved, MAXPATHLEN-1);
+                       if (n < 0)
+                               goto err1;
+                       resolved[n] = '\0';
+                       goto loop;
+               }
+               if (S_ISDIR(sb.st_mode)) {
+                       if (chdir(p) < 0)
+                               goto err1;
+                       p = "";
+               }
+       }
+
+       /*
+        * Save the last component name and get the full pathname of
+        * the current directory.
+        */
+       (void)strlcpy(wbuf, p, sizeof wbuf);
+       if (getcwd(resolved, MAXPATHLEN) == 0)
+               goto err1;
+
+       /*
+        * Join the two strings together, ensuring that the right thing
+        * happens if the last component is empty, or the dirname is root.
+        */
+       if (resolved[0] == '/' && resolved[1] == '\0')
+               needslash = 0;
+       else
+               needslash = 1;
+
+       if (*wbuf) {
+               if (strlen(resolved) + strlen(wbuf) + needslash >= MAXPATHLEN) {
+                       serrno = ENAMETOOLONG;
+                       goto err1;
+               }
+               if (needslash)
+                       strlcat(resolved, "/", MAXPATHLEN);
+               strlcat(resolved, wbuf, MAXPATHLEN);
+       }
+
+       /* Go back to where we came from. */
+       if (chdir(start) < 0) {
+               serrno = errno;
+               goto err2;
+       }
+       return (resolved);
+
+err1:  chdir(start);
+err2:  errno = serrno;
+       return (NULL);
+}
+#endif /* !defined(HAVE_REALPATH) || defined(BROKEN_REALPATH) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/rresvport.c b/crypto/openssh-3.8.1p1/openbsd-compat/rresvport.c
new file mode 100644 (file)
index 0000000..7516706
--- /dev/null
@@ -0,0 +1,103 @@
+/* OPENBSD ORIGINAL: lib/libc/net/rresvport.c */
+
+/*
+ * Copyright (c) 1995, 1996, 1998 Theo de Raadt.  All rights reserved.
+ * Copyright (c) 1983, 1993, 1994
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#ifndef HAVE_RRESVPORT_AF
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: rresvport.c,v 1.6 2003/06/03 02:11:35 deraadt Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include "includes.h"
+
+#if 0
+int
+rresvport(alport)
+       int *alport;
+{
+       return rresvport_af(alport, AF_INET);
+}
+#endif
+
+int 
+rresvport_af(int *alport, sa_family_t af)
+{
+       struct sockaddr_storage ss;
+       struct sockaddr *sa;
+       u_int16_t *portp;
+       int s;
+       socklen_t salen;
+
+       memset(&ss, '\0', sizeof ss);
+       sa = (struct sockaddr *)&ss;
+
+       switch (af) {
+       case AF_INET:
+               salen = sizeof(struct sockaddr_in);
+               portp = &((struct sockaddr_in *)sa)->sin_port;
+               break;
+       case AF_INET6:
+               salen = sizeof(struct sockaddr_in6);
+               portp = &((struct sockaddr_in6 *)sa)->sin6_port;
+               break;
+       default:
+               errno = EPFNOSUPPORT;
+               return (-1);
+       }
+       sa->sa_family = af;
+       
+       s = socket(af, SOCK_STREAM, 0);
+       if (s < 0)
+               return (-1);
+
+       *portp = htons(*alport);
+       if (*alport < IPPORT_RESERVED - 1) {
+               if (bind(s, sa, salen) >= 0)
+                       return (s);
+               if (errno != EADDRINUSE) {
+                       (void)close(s);
+                       return (-1);
+               }
+       }
+
+       *portp = 0;
+       sa->sa_family = af;
+       if (bindresvport_sa(s, sa) == -1) {
+               (void)close(s);
+               return (-1);
+       }
+       *alport = ntohs(*portp);
+       return (s);
+}
+
+#endif /* HAVE_RRESVPORT_AF */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/setenv.c b/crypto/openssh-3.8.1p1/openbsd-compat/setenv.c
new file mode 100644 (file)
index 0000000..c3a86c6
--- /dev/null
@@ -0,0 +1,165 @@
+/* OPENBSD ORIGINAL: lib/libc/stdlib/setenv.c */
+
+/*
+ * Copyright (c) 1987 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+#if !defined(HAVE_SETENV) || !defined(HAVE_UNSETENV)
+
+#if defined(LIBC_SCCS) && !defined(lint)
+static char *rcsid = "$OpenBSD: setenv.c,v 1.6 2003/06/02 20:18:38 millert Exp $";
+#endif /* LIBC_SCCS and not lint */
+
+#include <stdlib.h>
+#include <string.h>
+
+char *__findenv(const char *name, int *offset);
+
+/*
+ * __findenv --
+ *     Returns pointer to value associated with name, if any, else NULL.
+ *     Sets offset to be the offset of the name/value combination in the
+ *     environmental array, for use by setenv(3) and unsetenv(3).
+ *     Explicitly removes '=' in argument name.
+ *
+ *     This routine *should* be a static; don't use it.
+ */
+char *
+__findenv(name, offset)
+       register const char *name;
+       int *offset;
+{
+       extern char **environ;
+       register int len, i;
+       register const char *np;
+       register char **p, *cp;
+
+       if (name == NULL || environ == NULL)
+               return (NULL);
+       for (np = name; *np && *np != '='; ++np)
+               ;
+       len = np - name;
+       for (p = environ; (cp = *p) != NULL; ++p) {
+               for (np = name, i = len; i && *cp; i--)
+                       if (*cp++ != *np++)
+                               break;
+               if (i == 0 && *cp++ == '=') {
+                       *offset = p - environ;
+                       return (cp);
+               }
+       }
+       return (NULL);
+}
+
+#ifndef HAVE_SETENV
+/*
+ * setenv --
+ *     Set the value of the environmental variable "name" to be
+ *     "value".  If rewrite is set, replace any current value.
+ */
+int
+setenv(name, value, rewrite)
+       register const char *name;
+       register const char *value;
+       int rewrite;
+{
+       extern char **environ;
+       static int alloced;                     /* if allocated space before */
+       register char *C;
+       int l_value, offset;
+
+       if (*value == '=')                      /* no `=' in value */
+               ++value;
+       l_value = strlen(value);
+       if ((C = __findenv(name, &offset))) {   /* find if already exists */
+               if (!rewrite)
+                       return (0);
+               if (strlen(C) >= l_value) {     /* old larger; copy over */
+                       while ((*C++ = *value++))
+                               ;
+                       return (0);
+               }
+       } else {                                        /* create new slot */
+               register int    cnt;
+               register char   **P;
+
+               for (P = environ, cnt = 0; *P; ++P, ++cnt);
+               if (alloced) {                  /* just increase size */
+                       P = (char **)realloc((void *)environ,
+                           (size_t)(sizeof(char *) * (cnt + 2)));
+                       if (!P)
+                               return (-1);
+                       environ = P;
+               }
+               else {                          /* get new space */
+                       alloced = 1;            /* copy old entries into it */
+                       P = (char **)malloc((size_t)(sizeof(char *) *
+                           (cnt + 2)));
+                       if (!P)
+                               return (-1);
+                       memmove(P, environ, cnt * sizeof(char *));
+                       environ = P;
+               }
+               environ[cnt + 1] = NULL;
+               offset = cnt;
+       }
+       for (C = (char *)name; *C && *C != '='; ++C);   /* no `=' in name */
+       if (!(environ[offset] =                 /* name + `=' + value */
+           malloc((size_t)((int)(C - name) + l_value + 2))))
+               return (-1);
+       for (C = environ[offset]; (*C = *name++) && *C != '='; ++C)
+               ;
+       for (*C++ = '='; (*C++ = *value++); )
+               ;
+       return (0);
+}
+#endif /* HAVE_SETENV */
+
+#ifndef HAVE_UNSETENV
+/*
+ * unsetenv(name) --
+ *     Delete environmental variable "name".
+ */
+void
+unsetenv(name)
+       const char      *name;
+{
+       extern char **environ;
+       register char **P;
+       int offset;
+       char *__findenv();
+
+       while (__findenv(name, &offset))                /* if set multiple times */
+               for (P = &environ[offset];; ++P)
+                       if (!(*P = *(P + 1)))
+                               break;
+}
+#endif /* HAVE_UNSETENV */
+
+#endif /* !defined(HAVE_SETENV) || !defined(HAVE_UNSETENV) */
diff --git a/crypto/openssh-3.8.1p1/openbsd-compat/setproctitle.c b/crypto/openssh-3.8.1p1/openbsd-compat/setproctitle.c
new file mode 100644 (file)
index 0000000..6e2b19b
--- /dev/null
@@ -0,0 +1,157 @@
+/* Based on conf.c from UCB sendmail 8.8.8 */
+
+/*
+ * Copyright 2003 Damien Miller
+ * Copyright (c) 1983, 1995-1997 Eric P. Allman
+ * Copyright (c) 1988, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "includes.h"
+
+#ifndef HAVE_SETPROCTITLE
+
+#include <unistd.h>
+#ifdef HAVE_SYS_PSTAT_H
+#include <sys/pstat.h>
+#endif
+
+#define SPT_NONE       0       /* don't use it at all */
+#define SPT_PSTAT      1       /* use pstat(PSTAT_SETCMD, ...) */
+#define SPT_REUSEARGV  2       /* cover argv with title information */
+
+#ifndef SPT_TYPE
+# define SPT_TYPE      SPT_NONE
+#endif
+
+#ifndef SPT_PADCHAR
+#