import openssl-0.9.7-beta1

20 files changed, 2749 insertions, 1403 deletions

diff --git a/src/lib/libcrypto/bio/b_dump.c b/src/lib/libcrypto/bio/b_dump.c
index db84ad3d47..8397cfab6a 100644
--- a/src/lib/libcrypto/bio/b_dump.c
+++ b/src/lib/libcrypto/bio/b_dump.c
@@ -62,64 +62,91 @@
 
 #include <stdio.h>
 #include "cryptlib.h"
-#include "bio.h"
+#include <openssl/bio.h>
 
 #define TRUNCATE
 #define DUMP_WIDTH      16
+#define DUMP_WIDTH_LESS_INDENT(i) (DUMP_WIDTH-((i-(i>6?6:i)+3)/4))
 
-int BIO_dump(bio,s,len)
-BIO *bio;
-char *s;
-int len;
-{
-  int ret=0;
-  char buf[160+1],tmp[20];
-  int i,j,rows,trunc;
-  unsigned char ch;
-
-  trunc=0;
+int BIO_dump(BIO *bio, const char *s, int len)
+        {
+        return BIO_dump_indent(bio, s, len, 0);
+        }
 
+int BIO_dump_indent(BIO *bio, const char *s, int len, int indent)
+        {
+        int ret=0;
+        char buf[288+1],tmp[20],str[128+1];
+        int i,j,rows,trunc;
+        unsigned char ch;
+        int dump_width;
+        
+        trunc=0;
+        
 #ifdef TRUNCATE
-  for(; (len > 0) && ((s[len-1] == ' ') || (s[len-1] == '\0')); len--) 
-    trunc++;
+        for(; (len > 0) && ((s[len-1] == ' ') || (s[len-1] == '\0')); len--) 
+                trunc++;
 #endif
 
-  rows=(len/DUMP_WIDTH);
-  if ((rows*DUMP_WIDTH)<len)
-    rows++;
-  for(i=0;i<rows;i++) {
-    buf[0]='\0';        /* start with empty string */
-    sprintf(tmp,"%04x - ",i*DUMP_WIDTH);
-    strcpy(buf,tmp);
-    for(j=0;j<DUMP_WIDTH;j++) {
-      if (((i*DUMP_WIDTH)+j)>=len) {
-        strcat(buf,"   ");
-      } else {
-        ch=((unsigned char)*((char *)(s)+i*DUMP_WIDTH+j)) & 0xff;
-        sprintf(tmp,"%02x%c",ch,j==7?'-':' ');
-        strcat(buf,tmp);
-      }
-    }
-    strcat(buf,"  ");
-    for(j=0;j<DUMP_WIDTH;j++) {
-      if (((i*DUMP_WIDTH)+j)>=len)
-        break;
-      ch=((unsigned char)*((char *)(s)+i*DUMP_WIDTH+j)) & 0xff;
-      sprintf(tmp,"%c",((ch>=' ')&&(ch<='~'))?ch:'.');
-      strcat(buf,tmp);
-    }
-    strcat(buf,"\n");
-    /* if this is the last call then update the ddt_dump thing so that
-     * we will move the selection point in the debug window 
-     */
-    ret+=BIO_write(bio,(char *)buf,strlen(buf));
-  }
+        if (indent < 0)
+                indent = 0;
+        if (indent)
+                {
+                if (indent > 128) indent=128;
+                memset(str,' ',indent);
+                }
+        str[indent]='\0';
+        
+        dump_width=DUMP_WIDTH_LESS_INDENT(indent);
+        rows=(len/dump_width);
+        if ((rows*dump_width)<len)
+                rows++;
+        for(i=0;i<rows;i++)
+                {
+                buf[0]='\0';    /* start with empty string */
+                strcpy(buf,str);
+                sprintf(tmp,"%04x - ",i*dump_width);
+                strcat(buf,tmp);
+                for(j=0;j<dump_width;j++)
+                        {
+                        if (((i*dump_width)+j)>=len)
+                                {
+                                strcat(buf,"   ");
+                                }
+                        else
+                                {
+                                ch=((unsigned char)*(s+i*dump_width+j)) & 0xff;
+                                sprintf(tmp,"%02x%c",ch,j==7?'-':' ');
+                                strcat(buf,tmp);
+                                }
+                        }
+                strcat(buf,"  ");
+                for(j=0;j<dump_width;j++)
+                        {
+                        if (((i*dump_width)+j)>=len)
+                                break;
+                        ch=((unsigned char)*(s+i*dump_width+j)) & 0xff;
+#ifndef CHARSET_EBCDIC
+                        sprintf(tmp,"%c",((ch>=' ')&&(ch<='~'))?ch:'.');
+#else
+                        sprintf(tmp,"%c",((ch>=os_toascii[' '])&&(ch<=os_toascii['~']))
+                                ? os_toebcdic[ch]
+                                : '.');
+#endif
+                        strcat(buf,tmp);
+                        }
+                strcat(buf,"\n");
+                /* if this is the last call then update the ddt_dump thing so that
+                 * we will move the selection point in the debug window 
+                 */
+                ret+=BIO_write(bio,(char *)buf,strlen(buf));
+                }
 #ifdef TRUNCATE
-  if (trunc > 0) {
-    sprintf(buf,"%04x - <SPACES/NULS>\n",len+trunc);
-    ret+=BIO_write(bio,(char *)buf,strlen(buf));
-  }
+        if (trunc > 0)
+                {
+                sprintf(buf,"%s%04x - <SPACES/NULS>\n",str,len+trunc);
+                ret+=BIO_write(bio,(char *)buf,strlen(buf));
+                }
 #endif
-  return(ret);
-}
-
+        return(ret);
+        }
diff --git a/src/lib/libcrypto/bio/b_print.c b/src/lib/libcrypto/bio/b_print.c
index cdadeb839a..3ce1290772 100644
--- a/src/lib/libcrypto/bio/b_print.c
+++ b/src/lib/libcrypto/bio/b_print.c
@@ -56,37 +56,774 @@
  * [including the GNU Public Licence.]
  */
 
+/* disable assert() unless BIO_DEBUG has been defined */
+#ifndef BIO_DEBUG
+# ifndef NDEBUG
+#  define NDEBUG
+# endif
+#endif
+
 /* 
  * Stolen from tjh's ssl/ssl_trc.c stuff.
  */
 
 #include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <limits.h>
 #include "cryptlib.h"
-#include "bio.h"
+#ifndef NO_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#include <openssl/bn.h>         /* To get BN_LLONG properly defined */
+#include <openssl/bio.h>
+
+#ifdef BN_LLONG
+# ifndef HAVE_LONG_LONG
+#  define HAVE_LONG_LONG 1
+# endif
+#endif
+
+/***************************************************************************/
+
+/*
+ * 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.
+ */
+
+/*
+ * This code contains numerious changes and enhancements which were
+ * made by lots of contributors over the last years to Patrick Powell's
+ * original code:
+ *
+ * o Patrick Powell <papowell@astart.com>      (1995)
+ * o Brandon Long <blong@fiction.net>          (1996, for Mutt)
+ * o Thomas Roessler <roessler@guug.de>        (1998, for Mutt)
+ * o Michael Elkins <me@cs.hmc.edu>            (1998, for Mutt)
+ * o Andrew Tridgell <tridge@samba.org>        (1998, for Samba)
+ * o Luke Mewburn <lukem@netbsd.org>           (1999, for LukemFTP)
+ * o Ralf S. Engelschall <rse@engelschall.com> (1999, for Pth)
+ * o ...                                       (for OpenSSL)
+ */
+
+#if HAVE_LONG_DOUBLE
+#define LDOUBLE long double
+#else
+#define LDOUBLE double
+#endif
+
+#if HAVE_LONG_LONG
+# if defined(OPENSSL_SYS_WIN32) && !defined(__GNUC__)
+# define LLONG _int64
+# else
+# define LLONG long long
+# endif
+#else
+#define LLONG long
+#endif
+
+static void fmtstr     (char **, char **, size_t *, size_t *,
+                        const char *, int, int, int);
+static void fmtint     (char **, char **, size_t *, size_t *,
+                        LLONG, int, int, int, int);
+static void fmtfp      (char **, char **, size_t *, size_t *,
+                        LDOUBLE, int, int, int);
+static void doapr_outch (char **, char **, size_t *, size_t *, int);
+static void _dopr(char **sbuffer, char **buffer,
+                  size_t *maxlen, size_t *retlen, int *truncated,
+                  const char *format, va_list args);
+
+/* 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_LLONG      4
+
+/* some handy macros */
+#define char_to_int(p) (p - '0')
+#define OSSL_MAX(p,q) ((p >= q) ? p : q)
+
+static void
+_dopr(
+    char **sbuffer,
+    char **buffer,
+    size_t *maxlen,
+    size_t *retlen,
+    int *truncated,
+    const char *format,
+    va_list args)
+{
+    char ch;
+    LLONG value;
+    LDOUBLE fvalue;
+    char *strvalue;
+    int min;
+    int max;
+    int state;
+    int flags;
+    int cflags;
+    size_t currlen;
+
+    state = DP_S_DEFAULT;
+    flags = currlen = cflags = min = 0;
+    max = -1;
+    ch = *format++;
+
+    while (state != DP_S_DONE) {
+        if (ch == '\0' || (buffer == NULL && currlen >= *maxlen))
+            state = DP_S_DONE;
+
+        switch (state) {
+        case DP_S_DEFAULT:
+            if (ch == '%')
+                state = DP_S_FLAGS;
+            else
+                doapr_outch(sbuffer,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':
+                if (*format == 'l') {
+                    cflags = DP_C_LLONG;
+                    format++;
+                } else
+                    cflags = DP_C_LONG;
+                ch = *format++;
+                break;
+            case 'q':
+                cflags = DP_C_LLONG;
+                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':
+                switch (cflags) {
+                case DP_C_SHORT:
+                    value = (short int)va_arg(args, int);
+                    break;
+                case DP_C_LONG:
+                    value = va_arg(args, long int);
+                    break;
+                case DP_C_LLONG:
+                    value = va_arg(args, LLONG);
+                    break;
+                default:
+                    value = va_arg(args, int);
+                    break;
+                }
+                fmtint(sbuffer, buffer, &currlen, maxlen,
+                       value, 10, min, max, flags);
+                break;
+            case 'X':
+                flags |= DP_F_UP;
+                /* FALLTHROUGH */
+            case 'x':
+            case 'o':
+            case 'u':
+                flags |= DP_F_UNSIGNED;
+                switch (cflags) {
+                case DP_C_SHORT:
+                    value = (unsigned short int)va_arg(args, unsigned int);
+                    break;
+                case DP_C_LONG:
+                    value = (LLONG) va_arg(args,
+                        unsigned long int);
+                    break;
+                case DP_C_LLONG:
+                    value = va_arg(args, unsigned LLONG);
+                    break;
+                default:
+                    value = (LLONG) va_arg(args,
+                        unsigned int);
+                    break;
+                }
+                fmtint(sbuffer, buffer, &currlen, maxlen, value,
+                       ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
+                       min, max, flags);
+                break;
+            case 'f':
+                if (cflags == DP_C_LDOUBLE)
+                    fvalue = va_arg(args, LDOUBLE);
+                else
+                    fvalue = va_arg(args, double);
+                fmtfp(sbuffer, 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, LDOUBLE);
+                else
+                    fvalue = va_arg(args, double);
+                break;
+            case 'G':
+                flags |= DP_F_UP;
+            case 'g':
+                if (cflags == DP_C_LDOUBLE)
+                    fvalue = va_arg(args, LDOUBLE);
+                else
+                    fvalue = va_arg(args, double);
+                break;
+            case 'c':
+                doapr_outch(sbuffer, buffer, &currlen, maxlen,
+                    va_arg(args, int));
+                break;
+            case 's':
+                strvalue = va_arg(args, char *);
+                if (max < 0) {
+                    if (buffer)
+                        max = INT_MAX;
+                    else
+                        max = *maxlen;
+                }
+                fmtstr(sbuffer, buffer, &currlen, maxlen, strvalue,
+                       flags, min, max);
+                break;
+            case 'p':
+                value = (long)va_arg(args, void *);
+                fmtint(sbuffer, buffer, &currlen, maxlen,
+                    value, 16, min, max, flags);
+                break;
+            case 'n': /* XXX */
+                if (cflags == DP_C_SHORT) {
+                    short int *num;
+                    num = va_arg(args, short int *);
+                    *num = currlen;
+                } else if (cflags == DP_C_LONG) { /* XXX */
+                    long int *num;
+                    num = va_arg(args, long int *);
+                    *num = (long int) currlen;
+                } else if (cflags == DP_C_LLONG) { /* XXX */
+                    LLONG *num;
+                    num = va_arg(args, LLONG *);
+                    *num = (LLONG) currlen;
+                } else {
+                    int    *num;
+                    num = va_arg(args, int *);
+                    *num = currlen;
+                }
+                break;
+            case '%':
+                doapr_outch(sbuffer, 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:
+            break;
+        }
+    }
+    *truncated = (currlen > *maxlen - 1);
+    if (*truncated)
+        currlen = *maxlen - 1;
+    doapr_outch(sbuffer, buffer, &currlen, maxlen, '\0');
+    *retlen = currlen - 1;
+    return;
+}
+
+static void
+fmtstr(
+    char **sbuffer,
+    char **buffer,
+    size_t *currlen,
+    size_t *maxlen,
+    const char *value,
+    int flags,
+    int min,
+    int max)
+{
+    int padlen, strln;
+    int cnt = 0;
+
+    if (value == 0)
+        value = "<NULL>";
+    for (strln = 0; value[strln]; ++strln)
+        ;
+    padlen = min - strln;
+    if (padlen < 0)
+        padlen = 0;
+    if (flags & DP_F_MINUS)
+        padlen = -padlen;
+
+    while ((padlen > 0) && (cnt < max)) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
+        --padlen;
+        ++cnt;
+    }
+    while (*value && (cnt < max)) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, *value++);
+        ++cnt;
+    }
+    while ((padlen < 0) && (cnt < max)) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
+        ++padlen;
+        ++cnt;
+    }
+}
+
+static void
+fmtint(
+    char **sbuffer,
+    char **buffer,
+    size_t *currlen,
+    size_t *maxlen,
+    LLONG value,
+    int base,
+    int min,
+    int max,
+    int flags)
+{
+    int signvalue = 0;
+    unsigned LLONG uvalue;
+    char convert[20];
+    int place = 0;
+    int spadlen = 0;
+    int zpadlen = 0;
+    int caps = 0;
+
+    if (max < 0)
+        max = 0;
+    uvalue = value;
+    if (!(flags & DP_F_UNSIGNED)) {
+        if (value < 0) {
+            signvalue = '-';
+            uvalue = -value;
+        } else if (flags & DP_F_PLUS)
+            signvalue = '+';
+        else if (flags & DP_F_SPACE)
+            signvalue = ' ';
+    }
+    if (flags & DP_F_UP)
+        caps = 1;
+    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 - OSSL_MAX(max, place) - (signvalue ? 1 : 0);
+    if (zpadlen < 0)
+        zpadlen = 0;
+    if (spadlen < 0)
+        spadlen = 0;
+    if (flags & DP_F_ZERO) {
+        zpadlen = OSSL_MAX(zpadlen, spadlen);
+        spadlen = 0;
+    }
+    if (flags & DP_F_MINUS)
+        spadlen = -spadlen;
+
+    /* spaces */
+    while (spadlen > 0) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
+        --spadlen;
+    }
+
+    /* sign */
+    if (signvalue)
+        doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
+
+    /* zeros */
+    if (zpadlen > 0) {
+        while (zpadlen > 0) {
+            doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
+            --zpadlen;
+        }
+    }
+    /* digits */
+    while (place > 0)
+        doapr_outch(sbuffer, buffer, currlen, maxlen, convert[--place]);
+
+    /* left justified spaces */
+    while (spadlen < 0) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
+        ++spadlen;
+    }
+    return;
+}
+
+static LDOUBLE
+abs_val(LDOUBLE value)
+{
+    LDOUBLE result = value;
+    if (value < 0)
+        result = -value;
+    return result;
+}
+
+static LDOUBLE
+pow10(int exp)
+{
+    LDOUBLE result = 1;
+    while (exp) {
+        result *= 10;
+        exp--;
+    }
+    return result;
+}
+
+static long
+roundv(LDOUBLE value)
+{
+    long intpart;
+    intpart = (long) value;
+    value = value - intpart;
+    if (value >= 0.5)
+        intpart++;
+    return intpart;
+}
+
+static void
+fmtfp(
+    char **sbuffer,
+    char **buffer,
+    size_t *currlen,
+    size_t *maxlen,
+    LDOUBLE fvalue,
+    int min,
+    int max,
+    int flags)
+{
+    int signvalue = 0;
+    LDOUBLE ufvalue;
+    char iconvert[20];
+    char fconvert[20];
+    int iplace = 0;
+    int fplace = 0;
+    int padlen = 0;
+    int zpadlen = 0;
+    int caps = 0;
+    long intpart;
+    long fracpart;
+
+    if (max < 0)
+        max = 6;
+    ufvalue = abs_val(fvalue);
+    if (fvalue < 0)
+        signvalue = '-';
+    else if (flags & DP_F_PLUS)
+        signvalue = '+';
+    else if (flags & DP_F_SPACE)
+        signvalue = ' ';
 
-int BIO_printf ( VAR_PLIST( BIO *, bio ) )
-VAR_ALIST
+    intpart = (long)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 = roundv((pow10(max)) * (ufvalue - intpart));
+
+    if (fracpart >= pow10(max)) {
+        intpart++;
+        fracpart -= (long)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 (fplace < max);
+    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;
+
+    if ((flags & DP_F_ZERO) && (padlen > 0)) {
+        if (signvalue) {
+            doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
+            --padlen;
+            signvalue = 0;
+        }
+        while (padlen > 0) {
+            doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
+            --padlen;
+        }
+    }
+    while (padlen > 0) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
+        --padlen;
+    }
+    if (signvalue)
+        doapr_outch(sbuffer, buffer, currlen, maxlen, signvalue);
+
+    while (iplace > 0)
+        doapr_outch(sbuffer, buffer, currlen, maxlen, iconvert[--iplace]);
+
+    /*
+     * Decimal point. This should probably use locale to find the correct
+     * char to print out.
+     */
+    if (max > 0) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, '.');
+
+        while (fplace > 0)
+            doapr_outch(sbuffer, buffer, currlen, maxlen, fconvert[--fplace]);
+    }
+    while (zpadlen > 0) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, '0');
+        --zpadlen;
+    }
+
+    while (padlen < 0) {
+        doapr_outch(sbuffer, buffer, currlen, maxlen, ' ');
+        ++padlen;
+    }
+}
+
+static void
+doapr_outch(
+    char **sbuffer,
+    char **buffer,
+    size_t *currlen,
+    size_t *maxlen,
+    int c)
+{
+    /* If we haven't at least one buffer, someone has doe a big booboo */
+    assert(*sbuffer != NULL || buffer != NULL);
+
+    if (buffer) {
+        while (*currlen >= *maxlen) {
+            if (*buffer == NULL) {
+                if (*maxlen == 0)
+                    *maxlen = 1024;
+                *buffer = OPENSSL_malloc(*maxlen);
+                if (*currlen > 0) {
+                    assert(*sbuffer != NULL);
+                    memcpy(*buffer, *sbuffer, *currlen);
+                }
+                *sbuffer = NULL;
+            } else {
+                *maxlen += 1024;
+                *buffer = OPENSSL_realloc(*buffer, *maxlen);
+            }
+        }
+        /* What to do if *buffer is NULL? */
+        assert(*sbuffer != NULL || *buffer != NULL);
+    }
+
+    if (*currlen < *maxlen) {
+        if (*sbuffer)
+            (*sbuffer)[(*currlen)++] = (char)c;
+        else
+            (*buffer)[(*currlen)++] = (char)c;
+    }
+
+    return;
+}
+
+/***************************************************************************/
+
+int BIO_printf (BIO *bio, const char *format, ...)
         {
-        VAR_BDEFN(args, BIO *, bio);
-        char *format;
+        va_list args;
         int ret;
-        MS_STATIC char hugebuf[1024*2]; /* 10k in one chunk is the limit */
 
-        VAR_INIT(args, BIO *, bio);
-        VAR_ARG(args, char *, format);
+        va_start(args, format);
 
-        hugebuf[0]='\0';
+        ret = BIO_vprintf(bio, format, args);
 
-/* no-one uses _doprnt anymore and it appears to be broken under SunOS 4.1.4 */
-#if 0 && defined(sun) && !defined(VAR_ANSI) /**/
-        _doprnt(hugebuf,format,args);
-#else /* !sun */
-        vsprintf(hugebuf,format,args);
-#endif /* sun */
+        va_end(args);
+        return(ret);
+        }
 
-        ret=BIO_write(bio,hugebuf,strlen(hugebuf));
+int BIO_vprintf (BIO *bio, const char *format, va_list args)
+        {
+        int ret;
+        size_t retlen;
+        char hugebuf[1024*2];   /* Was previously 10k, which is unreasonable
+                                   in small-stack environments, like threads
+                                   or DOS programs. */
+        char *hugebufp = hugebuf;
+        size_t hugebufsize = sizeof(hugebuf);
+        char *dynbuf = NULL;
+        int ignored;
 
-        VAR_END( args );
+        dynbuf = NULL;
+        CRYPTO_push_info("doapr()");
+        _dopr(&hugebufp, &dynbuf, &hugebufsize,
+                &retlen, &ignored, format, args);
+        if (dynbuf)
+                {
+                ret=BIO_write(bio, dynbuf, (int)retlen);
+                OPENSSL_free(dynbuf);
+                }
+        else
+                {
+                ret=BIO_write(bio, hugebuf, (int)retlen);
+                }
+        CRYPTO_pop_info();
         return(ret);
         }
 
+/* As snprintf is not available everywhere, we provide our own implementation.
+ * This function has nothing to do with BIOs, but it's closely related
+ * to BIO_printf, and we need *some* name prefix ...
+ * (XXX  the function should be renamed, but to what?) */
+int BIO_snprintf(char *buf, size_t n, const char *format, ...)
+        {
+        va_list args;
+        int ret;
+
+        va_start(args, format);
+
+        ret = BIO_vsnprintf(buf, n, format, args);
+
+        va_end(args);
+        return(ret);
+        }
+
+int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
+        {
+        size_t retlen;
+        int truncated;
+
+        _dopr(&buf, NULL, &n, &retlen, &truncated, format, args);
+
+        if (truncated)
+                /* In case of truncation, return -1 like traditional snprintf.
+                 * (Current drafts for ISO/IEC 9899 say snprintf should return
+                 * the number of characters that would have been written,
+                 * had the buffer been large enough.) */
+                return -1;
+        else
+                return (retlen <= INT_MAX) ? retlen : -1;
+        }
diff --git a/src/lib/libcrypto/bio/b_sock.c b/src/lib/libcrypto/bio/b_sock.c
index a45909527c..dcaef68ea7 100644
--- a/src/lib/libcrypto/bio/b_sock.c
+++ b/src/lib/libcrypto/bio/b_sock.c
@@ -56,32 +56,30 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef NO_SOCK
+#ifndef OPENSSL_NO_SOCK
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
-#include "bio.h"
+#include <openssl/bio.h>
 
-/*      BIOerr(BIO_F_WSASTARTUP,BIO_R_WSASTARTUP ); */
-
-#ifdef WIN16
+#ifdef OPENSSL_SYS_WIN16
 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
 #else
 #define SOCKET_PROTOCOL IPPROTO_TCP
 #endif
 
 #ifdef SO_MAXCONN
-#define MAX_LISTEN  SOMAXCONN
-#elif defined(SO_MAXCONN)
 #define MAX_LISTEN  SO_MAXCONN
+#elif defined(SOMAXCONN)
+#define MAX_LISTEN  SOMAXCONN
 #else
 #define MAX_LISTEN  32
 #endif
 
-#ifdef WINDOWS
+#ifdef OPENSSL_SYS_WINDOWS
 static int wsa_init_done=0;
 #endif
 
@@ -96,59 +94,67 @@ static struct ghbn_cache_st
         unsigned long order;
         } ghbn_cache[GHBN_NUM];
 
-#ifndef NOPROTO
-static int get_ip(char *str,unsigned char *ip);
+static int get_ip(const char *str,unsigned char *ip);
+#if 0
 static void ghbn_free(struct hostent *a);
 static struct hostent *ghbn_dup(struct hostent *a);
-#else
-static int get_ip();
-static void ghbn_free();
-static struct hostent *ghbn_dup();
 #endif
-
-int BIO_get_host_ip(str,ip)
-char *str;
-unsigned char *ip;
+int BIO_get_host_ip(const char *str, unsigned char *ip)
         {
         int i;
+        int err = 1;
+        int locked = 0;
         struct hostent *he;
 
         i=get_ip(str,ip);
-        if (i > 0) return(1);
         if (i < 0)
                 {
                 BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS);
-                ERR_add_error_data(2,"host=",str);
-                return(0);
+                goto err;
                 }
-        else
-                { /* do a gethostbyname */
-                if (!BIO_sock_init()) return(0);
 
-                he=BIO_gethostbyname(str);
-                if (he == NULL)
-                        {
-                        BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP);
-                        ERR_add_error_data(2,"host=",str);
-                        return(0);
-                        }
+        /* At this point, we have something that is most probably correct
+           in some way, so let's init the socket. */
+        if (BIO_sock_init() != 1)
+                return 0; /* don't generate another error code here */
 
-                /* cast to short because of win16 winsock definition */
-                if ((short)he->h_addrtype != AF_INET)
-                        {
-                        BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
-                        ERR_add_error_data(2,"host=",str);
-                        return(0);
-                        }
-                for (i=0; i<4; i++)
-                        ip[i]=he->h_addr_list[0][i];
+        /* If the string actually contained an IP address, we need not do
+           anything more */
+        if (i > 0) return(1);
+
+        /* do a gethostbyname */
+        CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
+        locked = 1;
+        he=BIO_gethostbyname(str);
+        if (he == NULL)
+                {
+                BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP);
+                goto err;
                 }
-        return(1);
+
+        /* cast to short because of win16 winsock definition */
+        if ((short)he->h_addrtype != AF_INET)
+                {
+                BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
+                goto err;
+                }
+        for (i=0; i<4; i++)
+                ip[i]=he->h_addr_list[0][i];
+        err = 0;
+
+ err:
+        if (locked)
+                CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
+        if (err)
+                {
+                ERR_add_error_data(2,"host=",str);
+                return 0;
+                }
+        else
+                return 1;
         }
 
-int BIO_get_port(str,port_ptr)
-char *str;
-short *port_ptr;
+int BIO_get_port(const char *str, unsigned short *port_ptr)
         {
         int i;
         struct servent *s;
@@ -163,8 +169,19 @@ short *port_ptr;
                 *port_ptr=(unsigned short)i;
         else
                 {
-                s=getservbyname(str,"tcp");
-                if (s == NULL)
+                CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
+                /* Note: under VMS with SOCKETSHR, it seems like the first
+                 * parameter is 'char *', instead of 'const char *'
+                 */
+                s=getservbyname(
+#ifndef CONST_STRICT
+                    (char *)
+#endif
+                    str,"tcp");
+                if(s != NULL)
+                        *port_ptr=ntohs((unsigned short)s->s_port);
+                CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
+                if(s == NULL)
                         {
                         if (strcmp(str,"http") == 0)
                                 *port_ptr=80;
@@ -190,31 +207,30 @@ short *port_ptr;
                                 ERR_add_error_data(3,"service='",str,"'");
                                 return(0);
                                 }
-                        return(1);
                         }
-                *port_ptr=htons((unsigned short)s->s_port);
                 }
         return(1);
         }
 
-int BIO_sock_error(sock)
-int sock;
+int BIO_sock_error(int sock)
         {
-        int j,i,size;
+        int j,i;
+        int size;
                  
         size=sizeof(int);
-
-        i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(char *)&j,&size);
+        /* Note: under Windows the third parameter is of type (char *)
+         * whereas under other systems it is (void *) if you don't have
+         * a cast it will choke the compiler: if you do have a cast then
+         * you can either go for (char *) or (void *).
+         */
+        i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size);
         if (i < 0)
                 return(1);
         else
                 return(j);
         }
 
-long BIO_ghbn_ctrl(cmd,iarg,parg)
-int cmd;
-int iarg;
-char *parg;
+long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
         {
         int i;
         char **p;
@@ -223,13 +239,13 @@ char *parg;
                 {
         case BIO_GHBN_CTRL_HITS:
                 return(BIO_ghbn_hits);
-                break;
+                /* break; */
         case BIO_GHBN_CTRL_MISSES:
                 return(BIO_ghbn_miss);
-                break;
+                /* break; */
         case BIO_GHBN_CTRL_CACHE_SIZE:
                 return(GHBN_NUM);
-                break;
+                /* break; */
         case BIO_GHBN_CTRL_GET_ENTRY:
                 if ((iarg >= 0) && (iarg <GHBN_NUM) &&
                         (ghbn_cache[iarg].order > 0))
@@ -241,7 +257,7 @@ char *parg;
                         return(1);
                         }
                 return(0);
-                break;
+                /* break; */
         case BIO_GHBN_CTRL_FLUSH:
                 for (i=0; i<GHBN_NUM; i++)
                         ghbn_cache[i].order=0;
@@ -252,85 +268,105 @@ char *parg;
         return(1);
         }
 
-static struct hostent *ghbn_dup(a)
-struct hostent *a;
+#if 0
+static struct hostent *ghbn_dup(struct hostent *a)
         {
         struct hostent *ret;
         int i,j;
 
-        ret=(struct hostent *)malloc(sizeof(struct hostent));
+        MemCheck_off();
+        ret=(struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
         if (ret == NULL) return(NULL);
         memset(ret,0,sizeof(struct hostent));
 
         for (i=0; a->h_aliases[i] != NULL; i++)
                 ;
         i++;
-        ret->h_aliases=(char **)malloc(sizeof(char *)*i);
-        memset(ret->h_aliases,0,sizeof(char *)*i);
-        if (ret == NULL) goto err;
+        ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *));
+        if (ret->h_aliases == NULL)
+                goto err;
+        memset(ret->h_aliases, 0, i*sizeof(char *));
 
         for (i=0; a->h_addr_list[i] != NULL; i++)
                 ;
         i++;
-        ret->h_addr_list=(char **)malloc(sizeof(char *)*i);
-        memset(ret->h_addr_list,0,sizeof(char *)*i);
-        if (ret->h_addr_list == NULL) goto err;
+        ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *));
+        if (ret->h_addr_list == NULL)
+                goto err;
+        memset(ret->h_addr_list, 0, i*sizeof(char *));
 
         j=strlen(a->h_name)+1;
-        if ((ret->h_name=malloc(j)) == NULL) goto err;
+        if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err;
         memcpy((char *)ret->h_name,a->h_name,j);
         for (i=0; a->h_aliases[i] != NULL; i++)
                 {
                 j=strlen(a->h_aliases[i])+1;
-                if ((ret->h_aliases[i]=malloc(j)) == NULL) goto err;
+                if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err;
                 memcpy(ret->h_aliases[i],a->h_aliases[i],j);
                 }
         ret->h_length=a->h_length;
         ret->h_addrtype=a->h_addrtype;
         for (i=0; a->h_addr_list[i] != NULL; i++)
                 {
-                if ((ret->h_addr_list[i]=malloc(a->h_length)) == NULL)
+                if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL)
                         goto err;
                 memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length);
                 }
-        return(ret);
+        if (0)
+                {
 err:    
-        if (ret != NULL)
-                ghbn_free(ret);
-        return(NULL);
+                if (ret != NULL)
+                        ghbn_free(ret);
+                ret=NULL;
+                }
+        MemCheck_on();
+        return(ret);
         }
 
-static void ghbn_free(a)
-struct hostent *a;
+static void ghbn_free(struct hostent *a)
         {
         int i;
 
+        if(a == NULL)
+            return;
+
         if (a->h_aliases != NULL)
                 {
                 for (i=0; a->h_aliases[i] != NULL; i++)
-                        free(a->h_aliases[i]);
-                free(a->h_aliases);
+                        OPENSSL_free(a->h_aliases[i]);
+                OPENSSL_free(a->h_aliases);
                 }
         if (a->h_addr_list != NULL)
                 {
                 for (i=0; a->h_addr_list[i] != NULL; i++)
-                        free(a->h_addr_list[i]);
-                free(a->h_addr_list);
+                        OPENSSL_free(a->h_addr_list[i]);
+                OPENSSL_free(a->h_addr_list);
                 }
-        if (a->h_name != NULL) free((char *)a->h_name);
-        free(a);
+        if (a->h_name != NULL) OPENSSL_free(a->h_name);
+        OPENSSL_free(a);
         }
 
-struct hostent *BIO_gethostbyname(name)
-char *name;
+#endif
+
+struct hostent *BIO_gethostbyname(const char *name)
         {
+#if 1
+        /* Caching gethostbyname() results forever is wrong,
+         * so we have to let the true gethostbyname() worry about this */
+        return gethostbyname(name);
+#else
         struct hostent *ret;
         int i,lowi=0,j;
         unsigned long low= (unsigned long)-1;
 
-/*      return(gethostbyname(name)); */
 
-        CRYPTO_w_lock(CRYPTO_LOCK_BIO_GETHOSTBYNAME);
+#  if 0
+        /* It doesn't make sense to use locking here: The function interface
+         * is not thread-safe, because threads can never be sure when
+         * some other thread destroys the data they were given a pointer to.
+         */
+        CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
+#  endif
         j=strlen(name);
         if (j < 128)
                 {
@@ -354,17 +390,39 @@ char *name;
         if (i == GHBN_NUM) /* no hit*/
                 {
                 BIO_ghbn_miss++;
-                ret=gethostbyname(name);
-
-                if (ret == NULL) return(NULL);
-                if (j > 128) return(ret); /* too big to cache */
+                /* Note: under VMS with SOCKETSHR, it seems like the first
+                 * parameter is 'char *', instead of 'const char *'
+                 */
+                ret=gethostbyname(
+#  ifndef CONST_STRICT
+                    (char *)
+#  endif
+                    name);
+
+                if (ret == NULL)
+                        goto end;
+                if (j > 128) /* too big to cache */
+                        {
+#  if 0
+                        /* If we were trying to make this function thread-safe (which
+                         * is bound to fail), we'd have to give up in this case
+                         * (or allocate more memory). */
+                        ret = NULL;
+#  endif
+                        goto end;
+                        }
 
                 /* else add to cache */
                 if (ghbn_cache[lowi].ent != NULL)
-                        ghbn_free(ghbn_cache[lowi].ent);
+                        ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
+                ghbn_cache[lowi].name[0] = '\0';
 
+                if((ret=ghbn_cache[lowi].ent=ghbn_dup(ret)) == NULL)
+                        {
+                        BIOerr(BIO_F_BIO_GETHOSTBYNAME,ERR_R_MALLOC_FAILURE);
+                        goto end;
+                        }
                 strncpy(ghbn_cache[lowi].name,name,128);
-                ghbn_cache[lowi].ent=ghbn_dup(ret);
                 ghbn_cache[lowi].order=BIO_ghbn_miss+BIO_ghbn_hits;
                 }
         else
@@ -373,13 +431,18 @@ char *name;
                 ret= ghbn_cache[i].ent;
                 ghbn_cache[i].order=BIO_ghbn_miss+BIO_ghbn_hits;
                 }
-        CRYPTO_w_unlock(CRYPTO_LOCK_BIO_GETHOSTBYNAME);
+end:
+#  if 0
+        CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
+#  endif
         return(ret);
+#endif
         }
 
-int BIO_sock_init()
+
+int BIO_sock_init(void)
         {
-#ifdef WINDOWS
+#ifdef OPENSSL_SYS_WINDOWS
         static struct WSAData wsa_state;
 
         if (!wsa_init_done)
@@ -399,13 +462,13 @@ int BIO_sock_init()
                         return(-1);
                         }
                 }
-#endif /* WINDOWS */
+#endif /* OPENSSL_SYS_WINDOWS */
         return(1);
         }
 
-void BIO_sock_cleanup()
+void BIO_sock_cleanup(void)
         {
-#ifdef WINDOWS
+#ifdef OPENSSL_SYS_WINDOWS
         if (wsa_init_done)
                 {
                 wsa_init_done=0;
@@ -415,10 +478,9 @@ void BIO_sock_cleanup()
 #endif
         }
 
-int BIO_socket_ioctl(fd,type,arg)
-int fd;
-long type;
-unsigned long *arg;
+#if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000
+
+int BIO_socket_ioctl(int fd, long type, unsigned long *arg)
         {
         int i;
 
@@ -427,12 +489,11 @@ unsigned long *arg;
                 SYSerr(SYS_F_IOCTLSOCKET,get_last_socket_error());
         return(i);
         }
+#endif /* __VMS_VER */
 
 /* The reason I have implemented this instead of using sscanf is because
  * Visual C 1.52c gives an unresolved external when linking a DLL :-( */
-static int get_ip(str,ip)
-char *str;
-unsigned char ip[4];
+static int get_ip(const char *str, unsigned char ip[4])
         {
         unsigned int tmp[4];
         int num=0,c,ok=0;
@@ -446,16 +507,16 @@ unsigned char ip[4];
                         {
                         ok=1;
                         tmp[num]=tmp[num]*10+c-'0';
-                        if (tmp[num] > 255) return(-1);
+                        if (tmp[num] > 255) return(0);
                         }
                 else if (c == '.')
                         {
                         if (!ok) return(-1);
-                        if (num == 3) break;
+                        if (num == 3) return(0);
                         num++;
                         ok=0;
                         }
-                else if ((num == 3) && ok)
+                else if (c == '\0' && (num == 3) && ok)
                         break;
                 else
                         return(0);
@@ -467,18 +528,19 @@ unsigned char ip[4];
         return(1);
         }
 
-int BIO_get_accept_socket(host)
-char *host;
+int BIO_get_accept_socket(char *host, int bind_mode)
         {
         int ret=0;
-        struct sockaddr_in server;
-        int s= -1;
+        struct sockaddr_in server,client;
+        int s=INVALID_SOCKET,cs;
         unsigned char ip[4];
-        short port;
-        char *str,*h,*p,*e;
+        unsigned short port;
+        char *str=NULL,*e;
+        const char *h,*p;
         unsigned long l;
+        int err_num;
 
-        if (!BIO_sock_init()) return(INVALID_SOCKET);
+        if (BIO_sock_init() != 1) return(INVALID_SOCKET);
 
         if ((str=BUF_strdup(host)) == NULL) return(INVALID_SOCKET);
 
@@ -504,25 +566,26 @@ char *host;
                 h="*";
                 }
 
-        if (!BIO_get_port(p,&port)) return(INVALID_SOCKET);
+        if (!BIO_get_port(p,&port)) goto err;
 
         memset((char *)&server,0,sizeof(server));
         server.sin_family=AF_INET;
-        server.sin_port=htons((unsigned short)port);
+        server.sin_port=htons(port);
 
         if (strcmp(h,"*") == 0)
                 server.sin_addr.s_addr=INADDR_ANY;
         else
                 {
-                if (!BIO_get_host_ip(h,&(ip[0]))) return(INVALID_SOCKET);
+                if (!BIO_get_host_ip(h,&(ip[0]))) goto err;
                 l=(unsigned long)
                         ((unsigned long)ip[0]<<24L)|
-                        ((unsigned long)ip[0]<<16L)|
-                        ((unsigned long)ip[0]<< 8L)|
-                        ((unsigned long)ip[0]);
+                        ((unsigned long)ip[1]<<16L)|
+                        ((unsigned long)ip[2]<< 8L)|
+                        ((unsigned long)ip[3]);
                 server.sin_addr.s_addr=htonl(l);
                 }
 
+again:
         s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
         if (s == INVALID_SOCKET)
                 {
@@ -531,9 +594,45 @@ char *host;
                 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET);
                 goto err;
                 }
+
+#ifdef SO_REUSEADDR
+        if (bind_mode == BIO_BIND_REUSEADDR)
+                {
+                int i=1;
+
+                ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i));
+                bind_mode=BIO_BIND_NORMAL;
+                }
+#endif
         if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)
                 {
-                SYSerr(SYS_F_BIND,get_last_socket_error());
+#ifdef SO_REUSEADDR
+                err_num=get_last_socket_error();
+                if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
+                        (err_num == EADDRINUSE))
+                        {
+                        memcpy((char *)&client,(char *)&server,sizeof(server));
+                        if (strcmp(h,"*") == 0)
+                                client.sin_addr.s_addr=htonl(0x7F000001);
+                        cs=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
+                        if (cs != INVALID_SOCKET)
+                                {
+                                int ii;
+                                ii=connect(cs,(struct sockaddr *)&client,
+                                        sizeof(client));
+                                closesocket(cs);
+                                if (ii == INVALID_SOCKET)
+                                        {
+                                        bind_mode=BIO_BIND_REUSEADDR;
+                                        closesocket(s);
+                                        goto again;
+                                        }
+                                /* else error */
+                                }
+                        /* else error */
+                        }
+#endif
+                SYSerr(SYS_F_BIND,err_num);
                 ERR_add_error_data(3,"port='",host,"'");
                 BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_BIND_SOCKET);
                 goto err;
@@ -547,35 +646,35 @@ char *host;
                 }
         ret=1;
 err:
-        if (str != NULL) Free(str);
+        if (str != NULL) OPENSSL_free(str);
         if ((ret == 0) && (s != INVALID_SOCKET))
                 {
-#ifdef WINDOWS
                 closesocket(s);
-#else
-                close(s);
-#endif
                 s= INVALID_SOCKET;
                 }
         return(s);
         }
 
-int BIO_accept(sock,addr)
-int sock;
-char **addr;
+int BIO_accept(int sock, char **addr)
         {
         int ret=INVALID_SOCKET;
         static struct sockaddr_in from;
         unsigned long l;
-        short port;
+        unsigned short port;
         int len;
         char *p;
 
         memset((char *)&from,0,sizeof(from));
         len=sizeof(from);
-        ret=accept(sock,(struct sockaddr *)&from,&len);
+        /* Note: under VMS with SOCKETSHR the fourth parameter is currently
+         * of type (int *) whereas under other systems it is (void *) if
+         * you don't have a cast it will choke the compiler: if you do
+         * have a cast then you can either go for (int *) or (void *).
+         */
+        ret=accept(sock,(struct sockaddr *)&from,(void *)&len);
         if (ret == INVALID_SOCKET)
                 {
+                if(BIO_sock_should_retry(ret)) return -2;
                 SYSerr(SYS_F_ACCEPT,get_last_socket_error());
                 BIOerr(BIO_F_BIO_ACCEPT,BIO_R_ACCEPT_ERROR);
                 goto end;
@@ -587,7 +686,7 @@ char **addr;
         port=ntohs(from.sin_port);
         if (*addr == NULL)
                 {
-                if ((p=Malloc(24)) == NULL)
+                if ((p=OPENSSL_malloc(24)) == NULL)
                         {
                         BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
                         goto end;
@@ -604,9 +703,7 @@ end:
         return(ret);
         }
 
-int BIO_set_tcp_ndelay(s,on)
-int s;
-int on;
+int BIO_set_tcp_ndelay(int s, int on)
         {
         int ret=0;
 #if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
@@ -626,3 +723,14 @@ int on;
         }
 #endif
 
+int BIO_socket_nbio(int s, int mode)
+        {
+        int ret= -1;
+        unsigned long l;
+
+        l=mode;
+#ifdef FIONBIO
+        ret=BIO_socket_ioctl(s,FIONBIO,&l);
+#endif
+        return(ret == 0);
+        }
diff --git a/src/lib/libcrypto/bio/bf_buff.c b/src/lib/libcrypto/bio/bf_buff.c
index 7912b88473..6ccda06596 100644
--- a/src/lib/libcrypto/bio/bf_buff.c
+++ b/src/lib/libcrypto/bio/bf_buff.c
@@ -59,28 +59,17 @@
 #include <stdio.h>
 #include <errno.h>
 #include "cryptlib.h"
-#include "bio.h"
-#include "evp.h"
-
-#ifndef NOPROTO
-static int buffer_write(BIO *h,char *buf,int num);
-static int buffer_read(BIO *h,char *buf,int size);
-static int buffer_puts(BIO *h,char *str);
-static int buffer_gets(BIO *h,char *str,int size);
-static long buffer_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+#include <openssl/bio.h>
+
+static int buffer_write(BIO *h, const char *buf,int num);
+static int buffer_read(BIO *h, char *buf, int size);
+static int buffer_puts(BIO *h, const char *str);
+static int buffer_gets(BIO *h, char *str, int size);
+static long buffer_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int buffer_new(BIO *h);
 static int buffer_free(BIO *data);
-#else
-static int buffer_write();
-static int buffer_read();
-static int buffer_puts();
-static int buffer_gets();
-static long buffer_ctrl();
-static int buffer_new();
-static int buffer_free();
-#endif
-
-#define DEFAULT_BUFFER_SIZE     1024
+static long buffer_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
+#define DEFAULT_BUFFER_SIZE     4096
 
 static BIO_METHOD methods_buffer=
         {
@@ -93,24 +82,24 @@ static BIO_METHOD methods_buffer=
         buffer_ctrl,
         buffer_new,
         buffer_free,
+        buffer_callback_ctrl,
         };
 
-BIO_METHOD *BIO_f_buffer()
+BIO_METHOD *BIO_f_buffer(void)
         {
         return(&methods_buffer);
         }
 
-static int buffer_new(bi)
-BIO *bi;
+static int buffer_new(BIO *bi)
         {
         BIO_F_BUFFER_CTX *ctx;
 
-        ctx=(BIO_F_BUFFER_CTX *)Malloc(sizeof(BIO_F_BUFFER_CTX));
+        ctx=(BIO_F_BUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_F_BUFFER_CTX));
         if (ctx == NULL) return(0);
-        ctx->ibuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
-        if (ctx->ibuf == NULL) { Free(ctx); return(0); }
-        ctx->obuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
-        if (ctx->obuf == NULL) { Free(ctx->ibuf); Free(ctx); return(0); }
+        ctx->ibuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+        if (ctx->ibuf == NULL) { OPENSSL_free(ctx); return(0); }
+        ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_BUFFER_SIZE);
+        if (ctx->obuf == NULL) { OPENSSL_free(ctx->ibuf); OPENSSL_free(ctx); return(0); }
         ctx->ibuf_size=DEFAULT_BUFFER_SIZE;
         ctx->obuf_size=DEFAULT_BUFFER_SIZE;
         ctx->ibuf_len=0;
@@ -124,26 +113,22 @@ BIO *bi;
         return(1);
         }
 
-static int buffer_free(a)
-BIO *a;
+static int buffer_free(BIO *a)
         {
         BIO_F_BUFFER_CTX *b;
 
         if (a == NULL) return(0);
         b=(BIO_F_BUFFER_CTX *)a->ptr;
-        if (b->ibuf != NULL) Free(b->ibuf);
-        if (b->obuf != NULL) Free(b->obuf);
-        Free(a->ptr);
+        if (b->ibuf != NULL) OPENSSL_free(b->ibuf);
+        if (b->obuf != NULL) OPENSSL_free(b->obuf);
+        OPENSSL_free(a->ptr);
         a->ptr=NULL;
         a->init=0;
         a->flags=0;
         return(1);
         }
         
-static int buffer_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int buffer_read(BIO *b, char *out, int outl)
         {
         int i,num=0;
         BIO_F_BUFFER_CTX *ctx;
@@ -209,10 +194,7 @@ start:
         goto start;
         }
 
-static int buffer_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int buffer_write(BIO *b, const char *in, int inl)
         {
         int i,num=0;
         BIO_F_BUFFER_CTX *ctx;
@@ -285,11 +267,7 @@ start:
         goto start;
         }
 
-static long buffer_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long buffer_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         BIO *dbio;
         BIO_F_BUFFER_CTX *ctx;
@@ -307,6 +285,7 @@ char *ptr;
                 ctx->ibuf_len=0;
                 ctx->obuf_off=0;
                 ctx->obuf_len=0;
+                if (b->next_bio == NULL) return(0);
                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
                 break;
         case BIO_CTRL_INFO:
@@ -323,19 +302,25 @@ char *ptr;
         case BIO_CTRL_WPENDING:
                 ret=(long)ctx->obuf_len;
                 if (ret == 0)
+                        {
+                        if (b->next_bio == NULL) return(0);
                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+                        }
                 break;
         case BIO_CTRL_PENDING:
                 ret=(long)ctx->ibuf_len;
                 if (ret == 0)
+                        {
+                        if (b->next_bio == NULL) return(0);
                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+                        }
                 break;
         case BIO_C_SET_BUFF_READ_DATA:
                 if (num > ctx->ibuf_size)
                         {
-                        p1=Malloc((int)num);
+                        p1=OPENSSL_malloc((int)num);
                         if (p1 == NULL) goto malloc_error;
-                        if (ctx->ibuf != NULL) Free(ctx->ibuf);
+                        if (ctx->ibuf != NULL) OPENSSL_free(ctx->ibuf);
                         ctx->ibuf=p1;
                         }
                 ctx->ibuf_off=0;
@@ -367,21 +352,21 @@ char *ptr;
                 p2=ctx->obuf;
                 if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size))
                         {
-                        p1=(char *)Malloc((int)num);
+                        p1=(char *)OPENSSL_malloc((int)num);
                         if (p1 == NULL) goto malloc_error;
                         }
                 if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size))
                         {
-                        p2=(char *)Malloc((int)num);
+                        p2=(char *)OPENSSL_malloc((int)num);
                         if (p2 == NULL)
                                 {
-                                if (p1 != ctx->ibuf) Free(p1);
+                                if (p1 != ctx->ibuf) OPENSSL_free(p1);
                                 goto malloc_error;
                                 }
                         }
                 if (ctx->ibuf != p1)
                         {
-                        Free(ctx->ibuf);
+                        OPENSSL_free(ctx->ibuf);
                         ctx->ibuf=p1;
                         ctx->ibuf_off=0;
                         ctx->ibuf_len=0;
@@ -389,7 +374,7 @@ char *ptr;
                         }
                 if (ctx->obuf != p2)
                         {
-                        Free(ctx->obuf);
+                        OPENSSL_free(ctx->obuf);
                         ctx->obuf=p2;
                         ctx->obuf_off=0;
                         ctx->obuf_len=0;
@@ -397,12 +382,14 @@ char *ptr;
                         }
                 break;
         case BIO_C_DO_STATE_MACHINE:
+                if (b->next_bio == NULL) return(0);
                 BIO_clear_retry_flags(b);
                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
                 BIO_copy_next_retry(b);
                 break;
 
         case BIO_CTRL_FLUSH:
+                if (b->next_bio == NULL) return(0);
                 if (ctx->obuf_len <= 0)
                         {
                         ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
@@ -432,6 +419,7 @@ fprintf(stderr,"FLUSH [%3d] %3d -> %3d\n",ctx->obuf_off,ctx->obuf_len-ctx->obuf_
                                 break;
                                 }
                         }
+                ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
                 break;
         case BIO_CTRL_DUP:
                 dbio=(BIO *)ptr;
@@ -440,6 +428,7 @@ fprintf(stderr,"FLUSH [%3d] %3d -> %3d\n",ctx->obuf_off,ctx->obuf_len-ctx->obuf_
                         ret=0;
                 break;
         default:
+                if (b->next_bio == NULL) return(0);
                 ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
                 break;
                 }
@@ -449,10 +438,21 @@ malloc_error:
         return(0);
         }
 
-static int buffer_gets(b,buf,size)
-BIO *b;
-char *buf;
-int size;
+static long buffer_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
+        {
+        long ret=1;
+
+        if (b->next_bio == NULL) return(0);
+        switch (cmd)
+                {
+        default:
+                ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
+                break;
+                }
+        return(ret);
+        }
+
+static int buffer_gets(BIO *b, char *buf, int size)
         {
         BIO_F_BUFFER_CTX *ctx;
         int num=0,i,flag;
@@ -503,10 +503,8 @@ int size;
                 }
         }
 
-static int buffer_puts(b,str)
-BIO *b;
-char *str;
+static int buffer_puts(BIO *b, const char *str)
         {
-        return(BIO_write(b,str,strlen(str)));
+        return(buffer_write(b,str,strlen(str)));
         }
 
diff --git a/src/lib/libcrypto/bio/bf_lbuf.c b/src/lib/libcrypto/bio/bf_lbuf.c
index 7bcf8ed941..ec0f7eb0b7 100644
--- a/src/lib/libcrypto/bio/bf_lbuf.c
+++ b/src/lib/libcrypto/bio/bf_lbuf.c
@@ -200,7 +200,7 @@ static int linebuffer_write(BIO *b, const char *in, int inl)
                                         }
                                 }
 
-#ifdef DEBUG
+#if 0
 BIO_write(b->next_bio, "<*<", 3);
 #endif
                         i=BIO_write(b->next_bio,
@@ -210,13 +210,13 @@ BIO_write(b->next_bio, "<*<", 3);
                                 ctx->obuf_len = orig_olen;
                                 BIO_copy_next_retry(b);
 
-#ifdef DEBUG
+#if 0
 BIO_write(b->next_bio, ">*>", 3);
 #endif
                                 if (i < 0) return((num > 0)?num:i);
                                 if (i == 0) return(num);
                                 }
-#ifdef DEBUG
+#if 0
 BIO_write(b->next_bio, ">*>", 3);
 #endif
                         if (i < ctx->obuf_len)
@@ -229,20 +229,20 @@ BIO_write(b->next_bio, ">*>", 3);
                    buffer if a NL was found and there is anything to write. */
                 if ((foundnl || p - in > ctx->obuf_size) && p - in > 0)
                         {
-#ifdef DEBUG
+#if 0
 BIO_write(b->next_bio, "<*<", 3);
 #endif
                         i=BIO_write(b->next_bio,in,p - in);
                         if (i <= 0)
                                 {
                                 BIO_copy_next_retry(b);
-#ifdef DEBUG
+#if 0
 BIO_write(b->next_bio, ">*>", 3);
 #endif
                                 if (i < 0) return((num > 0)?num:i);
                                 if (i == 0) return(num);
                                 }
-#ifdef DEBUG
+#if 0
 BIO_write(b->next_bio, ">*>", 3);
 #endif
                         num+=i;
diff --git a/src/lib/libcrypto/bio/bf_nbio.c b/src/lib/libcrypto/bio/bf_nbio.c
index 034b3024df..1ce2bfacc0 100644
--- a/src/lib/libcrypto/bio/bf_nbio.c
+++ b/src/lib/libcrypto/bio/bf_nbio.c
@@ -59,31 +59,20 @@
 #include <stdio.h>
 #include <errno.h>
 #include "cryptlib.h"
-#include "rand.h"
-#include "bio.h"
-#include "evp.h"
+#include <openssl/rand.h>
+#include <openssl/bio.h>
 
 /* BIO_put and BIO_get both add to the digest,
  * BIO_gets returns the digest */
 
-#ifndef NOPROTO
-static int nbiof_write(BIO *h,char *buf,int num);
+static int nbiof_write(BIO *h,const char *buf,int num);
 static int nbiof_read(BIO *h,char *buf,int size);
-static int nbiof_puts(BIO *h,char *str);
+static int nbiof_puts(BIO *h,const char *str);
 static int nbiof_gets(BIO *h,char *str,int size);
-static long nbiof_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static long nbiof_ctrl(BIO *h,int cmd,long arg1,void *arg2);
 static int nbiof_new(BIO *h);
 static int nbiof_free(BIO *data);
-#else
-static int nbiof_write();
-static int nbiof_read();
-static int nbiof_puts();
-static int nbiof_gets();
-static long nbiof_ctrl();
-static int nbiof_new();
-static int nbiof_free();
-#endif
-
+static long nbiof_callback_ctrl(BIO *h,int cmd,bio_info_cb *fp);
 typedef struct nbio_test_st
         {
         /* only set if we sent a 'should retry' error */
@@ -102,19 +91,19 @@ static BIO_METHOD methods_nbiof=
         nbiof_ctrl,
         nbiof_new,
         nbiof_free,
+        nbiof_callback_ctrl,
         };
 
-BIO_METHOD *BIO_f_nbio_test()
+BIO_METHOD *BIO_f_nbio_test(void)
         {
         return(&methods_nbiof);
         }
 
-static int nbiof_new(bi)
-BIO *bi;
+static int nbiof_new(BIO *bi)
         {
         NBIO_TEST *nt;
 
-        nt=(NBIO_TEST *)Malloc(sizeof(NBIO_TEST));
+        if (!(nt=(NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST)))) return(0);
         nt->lrn= -1;
         nt->lwn= -1;
         bi->ptr=(char *)nt;
@@ -123,22 +112,18 @@ BIO *bi;
         return(1);
         }
 
-static int nbiof_free(a)
-BIO *a;
+static int nbiof_free(BIO *a)
         {
         if (a == NULL) return(0);
         if (a->ptr != NULL)
-                Free(a->ptr);
+                OPENSSL_free(a->ptr);
         a->ptr=NULL;
         a->init=0;
         a->flags=0;
         return(1);
         }
         
-static int nbiof_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int nbiof_read(BIO *b, char *out, int outl)
         {
         NBIO_TEST *nt;
         int ret=0;
@@ -153,7 +138,7 @@ int outl;
 
         BIO_clear_retry_flags(b);
 #if 0
-        RAND_bytes(&n,1);
+        RAND_pseudo_bytes(&n,1);
         num=(n&0x07);
 
         if (outl > num) outl=num;
@@ -173,10 +158,7 @@ int outl;
         return(ret);
         }
 
-static int nbiof_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int nbiof_write(BIO *b, const char *in, int inl)
         {
         NBIO_TEST *nt;
         int ret=0;
@@ -197,7 +179,7 @@ int inl;
                 }
         else
                 {
-                RAND_bytes(&n,1);
+                RAND_pseudo_bytes(&n,1);
                 num=(n&7);
                 }
 
@@ -221,11 +203,7 @@ int inl;
         return(ret);
         }
 
-static long nbiof_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long nbiof_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         long ret;
 
@@ -247,19 +225,28 @@ char *ptr;
         return(ret);
         }
 
-static int nbiof_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static long nbiof_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
+        {
+        long ret=1;
+
+        if (b->next_bio == NULL) return(0);
+        switch (cmd)
+                {
+        default:
+                ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
+                break;
+                }
+        return(ret);
+        }
+
+static int nbiof_gets(BIO *bp, char *buf, int size)
         {
         if (bp->next_bio == NULL) return(0);
         return(BIO_gets(bp->next_bio,buf,size));
         }
 
 
-static int nbiof_puts(bp,str)
-BIO *bp;
-char *str;
+static int nbiof_puts(BIO *bp, const char *str)
         {
         if (bp->next_bio == NULL) return(0);
         return(BIO_puts(bp->next_bio,str));
diff --git a/src/lib/libcrypto/bio/bf_null.c b/src/lib/libcrypto/bio/bf_null.c
index a47a65741a..c1bf39a904 100644
--- a/src/lib/libcrypto/bio/bf_null.c
+++ b/src/lib/libcrypto/bio/bf_null.c
@@ -59,30 +59,19 @@
 #include <stdio.h>
 #include <errno.h>
 #include "cryptlib.h"
-#include "bio.h"
-#include "evp.h"
+#include <openssl/bio.h>
 
 /* BIO_put and BIO_get both add to the digest,
  * BIO_gets returns the digest */
 
-#ifndef NOPROTO
-static int nullf_write(BIO *h,char *buf,int num);
-static int nullf_read(BIO *h,char *buf,int size);
-static int nullf_puts(BIO *h,char *str);
-static int nullf_gets(BIO *h,char *str,int size);
-static long nullf_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int nullf_write(BIO *h, const char *buf, int num);
+static int nullf_read(BIO *h, char *buf, int size);
+static int nullf_puts(BIO *h, const char *str);
+static int nullf_gets(BIO *h, char *str, int size);
+static long nullf_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int nullf_new(BIO *h);
 static int nullf_free(BIO *data);
-#else
-static int nullf_write();
-static int nullf_read();
-static int nullf_puts();
-static int nullf_gets();
-static long nullf_ctrl();
-static int nullf_new();
-static int nullf_free();
-#endif
-
+static long nullf_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
 static BIO_METHOD methods_nullf=
         {
         BIO_TYPE_NULL_FILTER,
@@ -94,15 +83,15 @@ static BIO_METHOD methods_nullf=
         nullf_ctrl,
         nullf_new,
         nullf_free,
+        nullf_callback_ctrl,
         };
 
-BIO_METHOD *BIO_f_null()
+BIO_METHOD *BIO_f_null(void)
         {
         return(&methods_nullf);
         }
 
-static int nullf_new(bi)
-BIO *bi;
+static int nullf_new(BIO *bi)
         {
         bi->init=1;
         bi->ptr=NULL;
@@ -110,8 +99,7 @@ BIO *bi;
         return(1);
         }
 
-static int nullf_free(a)
-BIO *a;
+static int nullf_free(BIO *a)
         {
         if (a == NULL) return(0);
 /*      a->ptr=NULL;
@@ -120,10 +108,7 @@ BIO *a;
         return(1);
         }
         
-static int nullf_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int nullf_read(BIO *b, char *out, int outl)
         {
         int ret=0;
  
@@ -135,10 +120,7 @@ int outl;
         return(ret);
         }
 
-static int nullf_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int nullf_write(BIO *b, const char *in, int inl)
         {
         int ret=0;
 
@@ -150,11 +132,7 @@ int inl;
         return(ret);
         }
 
-static long nullf_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long nullf_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         long ret;
 
@@ -175,19 +153,28 @@ char *ptr;
         return(ret);
         }
 
-static int nullf_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static long nullf_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
+        {
+        long ret=1;
+
+        if (b->next_bio == NULL) return(0);
+        switch (cmd)
+                {
+        default:
+                ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
+                break;
+                }
+        return(ret);
+        }
+
+static int nullf_gets(BIO *bp, char *buf, int size)
         {
         if (bp->next_bio == NULL) return(0);
         return(BIO_gets(bp->next_bio,buf,size));
         }
 
 
-static int nullf_puts(bp,str)
-BIO *bp;
-char *str;
+static int nullf_puts(BIO *bp, const char *str)
         {
         if (bp->next_bio == NULL) return(0);
         return(BIO_puts(bp->next_bio,str));
diff --git a/src/lib/libcrypto/bio/bio.h b/src/lib/libcrypto/bio/bio.h
index 300b330e00..b122c7069d 100644
--- a/src/lib/libcrypto/bio/bio.h
+++ b/src/lib/libcrypto/bio/bio.h
@@ -59,12 +59,18 @@
 #ifndef HEADER_BIO_H
 #define HEADER_BIO_H
 
+#ifndef OPENSSL_NO_FP_API
+# include <stdio.h>
+#endif
+#include <stdarg.h>
+
+#include <openssl/crypto.h>
+#include <openssl/e_os2.h>
+
 #ifdef  __cplusplus
 extern "C" {
 #endif
 
-#include "crypto.h"
-
 /* These are the 'types' of BIOs */
 #define BIO_TYPE_NONE           0
 #define BIO_TYPE_MEM            (1|0x0400)
@@ -74,7 +80,7 @@ extern "C" {
 #define BIO_TYPE_SOCKET         (5|0x0400|0x0100)
 #define BIO_TYPE_NULL           (6|0x0400)
 #define BIO_TYPE_SSL            (7|0x0200)
-#define BIO_TYPE_MD             (8|0x0200)              /* pasive filter */
+#define BIO_TYPE_MD             (8|0x0200)              /* passive filter */
 #define BIO_TYPE_BUFFER         (9|0x0200)              /* filter */
 #define BIO_TYPE_CIPHER         (10|0x0200)             /* filter */
 #define BIO_TYPE_BASE64         (11|0x0200)             /* filter */
@@ -84,6 +90,9 @@ extern "C" {
 #define BIO_TYPE_PROXY_SERVER   (15|0x0200)             /* server proxy BIO */
 #define BIO_TYPE_NBIO_TEST      (16|0x0200)             /* server proxy BIO */
 #define BIO_TYPE_NULL_FILTER    (17|0x0200)
+#define BIO_TYPE_BER            (18|0x0200)             /* BER -> bin filter */
+#define BIO_TYPE_BIO            (19|0x0400)             /* (half a) BIO pair */
+#define BIO_TYPE_LINEBUFFER     (20|0x0200)             /* filter */
 
 #define BIO_TYPE_DESCRIPTOR     0x0100  /* socket, fd, connect or accept */
 #define BIO_TYPE_FILTER         0x0200
@@ -143,6 +152,11 @@ extern "C" {
 
 #define BIO_FLAGS_BASE64_NO_NL  0x100
 
+/* This is used with memory BIOs: it means we shouldn't free up or change the
+ * data in any way.
+ */
+#define BIO_FLAGS_MEM_RDONLY    0x200
+
 #define BIO_set_flags(b,f) ((b)->flags|=(f))
 #define BIO_get_flags(b) ((b)->flags)
 #define BIO_set_retry_special(b) \
@@ -159,14 +173,14 @@ extern "C" {
 #define BIO_get_retry_flags(b) \
                 ((b)->flags&(BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
 
-/* These shouldbe used by the application to tell why we should retry */
+/* These should be used by the application to tell why we should retry */
 #define BIO_should_read(a)              ((a)->flags & BIO_FLAGS_READ)
 #define BIO_should_write(a)             ((a)->flags & BIO_FLAGS_WRITE)
 #define BIO_should_io_special(a)        ((a)->flags & BIO_FLAGS_IO_SPECIAL)
 #define BIO_retry_type(a)               ((a)->flags & BIO_FLAGS_RWS)
 #define BIO_should_retry(a)             ((a)->flags & BIO_FLAGS_SHOULD_RETRY)
 
-/* The next two are used in conjunction with the
+/* The next three are used in conjunction with the
  * BIO_should_io_special() condition.  After this returns true,
  * BIO *BIO_get_retry_BIO(BIO *bio, int *reason); will walk the BIO 
  * stack and return the 'reason' for the special and the offending BIO.
@@ -175,6 +189,8 @@ extern "C" {
 #define BIO_RR_SSL_X509_LOOKUP          0x01
 /* Returned from the connect BIO when a connect would have blocked */
 #define BIO_RR_CONNECT                  0x02
+/* Returned from the accept BIO when an accept would have blocked */
+#define BIO_RR_ACCEPT                   0x03
 
 /* These are passed by the BIO callback */
 #define BIO_CB_FREE     0x01
@@ -198,24 +214,29 @@ extern "C" {
 #define BIO_method_name(b)              ((b)->method->name)
 #define BIO_method_type(b)              ((b)->method->type)
 
-#ifndef WIN16
+typedef struct bio_st BIO;
+
+typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long);
+
+#ifndef OPENSSL_SYS_WIN16
 typedef struct bio_method_st
         {
         int type;
-        char *name;
-        int (*bwrite)();
-        int (*bread)();
-        int (*bputs)();
-        int (*bgets)();
-        long (*ctrl)();
-        int (*create)();
-        int (*destroy)();
+        const char *name;
+        int (*bwrite)(BIO *, const char *, int);
+        int (*bread)(BIO *, char *, int);
+        int (*bputs)(BIO *, const char *);
+        int (*bgets)(BIO *, char *, int);
+        long (*ctrl)(BIO *, int, long, void *);
+        int (*create)(BIO *);
+        int (*destroy)(BIO *);
+        long (*callback_ctrl)(BIO *, int, bio_info_cb *);
         } BIO_METHOD;
 #else
 typedef struct bio_method_st
         {
         int type;
-        char *name;
+        const char *name;
         int (_far *bwrite)();
         int (_far *bread)();
         int (_far *bputs)();
@@ -223,18 +244,15 @@ typedef struct bio_method_st
         long (_far *ctrl)();
         int (_far *create)();
         int (_far *destroy)();
+        long (_fat *callback_ctrl)();
         } BIO_METHOD;
 #endif
 
-typedef struct bio_st
+struct bio_st
         {
         BIO_METHOD *method;
-#ifndef NOPROTO
         /* bio, mode, argp, argi, argl, ret */
-        long (*callback)(struct bio_st *,int,char *,int, long,long);
-#else
-        long (*callback)();
-#endif
+        long (*callback)(struct bio_st *,int,const char *,int, long,long);
         char *cb_arg; /* first argument for the callback */
 
         int init;
@@ -242,7 +260,7 @@ typedef struct bio_st
         int flags;      /* extra storage */
         int retry_reason;
         int num;
-        char *ptr;
+        void *ptr;
         struct bio_st *next_bio;        /* used by filter BIOs */
         struct bio_st *prev_bio;        /* used by filter BIOs */
         int references;
@@ -250,7 +268,9 @@ typedef struct bio_st
         unsigned long num_write;
 
         CRYPTO_EX_DATA ex_data;
-        } BIO;
+        };
+
+DECLARE_STACK_OF(BIO)
 
 typedef struct bio_f_buffer_ctx_struct
         {
@@ -276,10 +296,7 @@ typedef struct bio_f_buffer_ctx_struct
 #define BIO_CONN_S_OK                   6
 #define BIO_CONN_S_BLOCKED_CONNECT      7
 #define BIO_CONN_S_NBIO                 8
-#define BIO_CONN_get_param_hostname     BIO_ctrl
-
-#define BIO_number_read(b)      ((b)->num_read)
-#define BIO_number_written(b)   ((b)->num_write)
+/*#define BIO_CONN_get_param_hostname   BIO_ctrl */
 
 #define BIO_C_SET_CONNECT                       100
 #define BIO_C_DO_STATE_MACHINE                  101
@@ -309,26 +326,42 @@ typedef struct bio_f_buffer_ctx_struct
 #define BIO_C_SET_SSL_RENEGOTIATE_BYTES         125
 #define BIO_C_GET_SSL_NUM_RENEGOTIATES          126
 #define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT       127
-
-#define BIO_set_app_data(s,arg)         BIO_set_ex_data(s,0,(char *)arg)
+#define BIO_C_FILE_SEEK                         128
+#define BIO_C_GET_CIPHER_CTX                    129
+#define BIO_C_SET_BUF_MEM_EOF_RETURN            130/*return end of input value*/
+#define BIO_C_SET_BIND_MODE                     131
+#define BIO_C_GET_BIND_MODE                     132
+#define BIO_C_FILE_TELL                         133
+#define BIO_C_GET_SOCKS                         134
+#define BIO_C_SET_SOCKS                         135
+
+#define BIO_C_SET_WRITE_BUF_SIZE                136/* for BIO_s_bio */
+#define BIO_C_GET_WRITE_BUF_SIZE                137
+#define BIO_C_MAKE_BIO_PAIR                     138
+#define BIO_C_DESTROY_BIO_PAIR                  139
+#define BIO_C_GET_WRITE_GUARANTEE               140
+#define BIO_C_GET_READ_REQUEST                  141
+#define BIO_C_SHUTDOWN_WR                       142
+#define BIO_C_NREAD0                            143
+#define BIO_C_NREAD                             144
+#define BIO_C_NWRITE0                           145
+#define BIO_C_NWRITE                            146
+#define BIO_C_RESET_READ_REQUEST                147
+
+
+#define BIO_set_app_data(s,arg)         BIO_set_ex_data(s,0,arg)
 #define BIO_get_app_data(s)             BIO_get_ex_data(s,0)
 
-int BIO_get_ex_num(BIO *bio);
-int BIO_set_ex_data(BIO *bio,int idx,char *data);
-char *BIO_get_ex_data(BIO *bio,int idx);
-void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)());
-int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
-        int (*dup_func)(), void (*free_func)());
-
-/* BIO_s_connect_socket() */
+/* BIO_s_connect() and BIO_s_socks4a_connect() */
 #define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0,(char *)name)
 #define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1,(char *)port)
 #define BIO_set_conn_ip(b,ip)     BIO_ctrl(b,BIO_C_SET_CONNECT,2,(char *)ip)
 #define BIO_set_conn_int_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,3,(char *)port)
 #define BIO_get_conn_hostname(b)  BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0)
 #define BIO_get_conn_port(b)      BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1)
-#define BIO_get_conn_ip(b,ip) BIO_ptr_ctrl(b,BIO_C_SET_CONNECT,2)
-#define BIO_get_conn_int port(b,port) BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,port)
+#define BIO_get_conn_ip(b)               BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2)
+#define BIO_get_conn_int_port(b) BIO_int_ctrl(b,BIO_C_GET_CONNECT,3)
+
 
 #define BIO_set_nbio(b,n)       BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL)
 
@@ -339,6 +372,12 @@ int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
 #define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,1,(n)?"a":NULL)
 #define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(char *)bio)
 
+#define BIO_BIND_NORMAL                 0
+#define BIO_BIND_REUSEADDR_IF_UNUSED    1
+#define BIO_BIND_REUSEADDR              2
+#define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL)
+#define BIO_get_bind_mode(b,mode) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL)
+
 #define BIO_do_connect(b)       BIO_do_handshake(b)
 #define BIO_do_accept(b)        BIO_do_handshake(b)
 #define BIO_do_handshake(b)     BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL)
@@ -349,7 +388,7 @@ int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
 /* BIO_set_nbio(b,n) */
 #define BIO_set_filter_bio(b,s) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,2,(char *)(s))
 /* BIO *BIO_get_filter_bio(BIO *bio); */
-#define BIO_set_proxy_cb(b,cb) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,3,(char *)(cb))
+#define BIO_set_proxy_cb(b,cb) BIO_callback_ctrl(b,BIO_C_SET_PROXY_PARAM,3,(void *(*cb)()))
 #define BIO_set_proxy_header(b,sk) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,4,(char *)sk)
 #define BIO_set_no_connect_return(b,bool) BIO_int_ctrl(b,BIO_C_SET_PROXY_PARAM,5,bool)
 
@@ -364,12 +403,26 @@ int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
 #define BIO_set_fp(b,fp,c)      BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)fp)
 #define BIO_get_fp(b,fpp)       BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)fpp)
 
+#define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL)
+#define BIO_tell(b)     (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL)
+
+/* name is cast to lose const, but might be better to route through a function
+   so we can do it safely */
+#ifdef CONST_STRICT
+/* If you are wondering why this isn't defined, its because CONST_STRICT is
+ * purely a compile-time kludge to allow const to be checked.
+ */
+int BIO_read_filename(BIO *b,const char *name);
+#else
 #define BIO_read_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
-                BIO_CLOSE|BIO_FP_READ,name)
+                BIO_CLOSE|BIO_FP_READ,(char *)name)
+#endif
 #define BIO_write_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
                 BIO_CLOSE|BIO_FP_WRITE,name)
 #define BIO_append_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
                 BIO_CLOSE|BIO_FP_APPEND,name)
+#define BIO_rw_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
+                BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name)
 
 /* WARNING WARNING, this ups the reference count on the read bio of the
  * SSL structure.  This is because the ssl read BIO is now pointed to by
@@ -381,15 +434,18 @@ int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
 #define BIO_set_ssl_renegotiate_bytes(b,num) \
         BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL);
 #define BIO_get_num_renegotiates(b) \
-        BIO_ctrl(b,BIO_C_SET_SSL_NUM_RENEGOTIATES,0,NULL);
+        BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL);
 #define BIO_set_ssl_renegotiate_timeout(b,seconds) \
         BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL);
 
 /* defined in evp.h */
 /* #define BIO_set_md(b,md)     BIO_ctrl(b,BIO_C_SET_MD,1,(char *)md) */
 
+#define BIO_get_mem_data(b,pp)  BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)pp)
 #define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)bm)
 #define BIO_get_mem_ptr(b,pp)   BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0,(char *)pp)
+#define BIO_set_mem_eof_return(b,v) \
+                                BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL)
 
 /* For the BIO_f_buffer() type */
 #define BIO_get_buffer_num_lines(b)     BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL)
@@ -407,19 +463,42 @@ int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
 #define BIO_get_close(b)        (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL)
 #define BIO_pending(b)          (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL)
 #define BIO_wpending(b)         (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL)
+/* ...pending macros have inappropriate return type */
+size_t BIO_ctrl_pending(BIO *b);
+size_t BIO_ctrl_wpending(BIO *b);
 #define BIO_flush(b)            (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL)
-#define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0,(char *)cbp)
-#define BIO_set_info_callback(b,cb) (int)BIO_ctrl(b,BIO_CTRL_SET_CALLBACK,0,(char *)cb)
+#define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \
+                                                   cbp)
+#define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb)
 
 /* For the BIO_f_buffer() type */
 #define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL)
 
-#ifdef NO_STDIO
-#define NO_FP_API
-#endif
-
-#ifndef NOPROTO
-#  if defined(WIN16) && defined(_WINDLL)
+/* For BIO_s_bio() */
+#define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL)
+#define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL)
+#define BIO_make_bio_pair(b1,b2)   (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2)
+#define BIO_destroy_bio_pair(b)    (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL)
+#define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL)
+/* macros with inappropriate type -- but ...pending macros use int too: */
+#define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL)
+#define BIO_get_read_request(b)    (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL)
+size_t BIO_ctrl_get_write_guarantee(BIO *b);
+size_t BIO_ctrl_get_read_request(BIO *b);
+int BIO_ctrl_reset_read_request(BIO *b);
+
+/* These two aren't currently implemented */
+/* int BIO_get_ex_num(BIO *bio); */
+/* void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)()); */
+int BIO_set_ex_data(BIO *bio,int idx,void *data);
+void *BIO_get_ex_data(BIO *bio,int idx);
+int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+        CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
+unsigned long BIO_number_read(BIO *bio);
+unsigned long BIO_number_written(BIO *bio);
+
+# ifndef OPENSSL_NO_FP_API
+#  if defined(OPENSSL_SYS_WIN16) && defined(_WINDLL)
 BIO_METHOD *BIO_s_file_internal(void);
 BIO *BIO_new_file_internal(char *filename, char *mode);
 BIO *BIO_new_fp_internal(FILE *stream, int close_flag);
@@ -428,261 +507,184 @@ BIO *BIO_new_fp_internal(FILE *stream, int close_flag);
 #    define BIO_new_fp  BIO_new_fp_internal
 #  else /* FP_API */
 BIO_METHOD *BIO_s_file(void );
-BIO *BIO_new_file(char *filename, char *mode);
+BIO *BIO_new_file(const char *filename, const char *mode);
 BIO *BIO_new_fp(FILE *stream, int close_flag);
 #    define BIO_s_file_internal         BIO_s_file
 #    define BIO_new_file_internal       BIO_new_file
 #    define BIO_new_fp_internal         BIO_s_file
 #  endif /* FP_API */
-#else
-#  if defined(WIN16) && defined(_WINDLL)
-BIO_METHOD *BIO_s_file_internal();
-BIO *BIO_new_file_internal();
-BIO *BIO_new_fp_internal();
-#    define BIO_s_file  BIO_s_file_internal
-#    define BIO_new_file        BIO_new_file_internal
-#    define BIO_new_fp  BIO_new_fp_internal
-#  else /* FP_API */
-BIO_METHOD *BIO_s_file();
-BIO *BIO_new_file();
-BIO *BIO_new_fp();
-#    define BIO_s_file_internal         BIO_s_file
-#    define BIO_new_file_internal       BIO_new_file
-#    define BIO_new_fp_internal         BIO_s_file
-#  endif /* FP_API */
-#endif
-
-#ifndef NOPROTO
+# endif
 BIO *   BIO_new(BIO_METHOD *type);
 int     BIO_set(BIO *a,BIO_METHOD *type);
 int     BIO_free(BIO *a);
-int     BIO_read(BIO *b, char *data, int len);
+void    BIO_vfree(BIO *a);
+int     BIO_read(BIO *b, void *data, int len);
 int     BIO_gets(BIO *bp,char *buf, int size);
-int     BIO_write(BIO *b, char *data, int len);
-int     BIO_puts(BIO *bp,char *buf);
-long    BIO_ctrl(BIO *bp,int cmd,long larg,char *parg);
+int     BIO_write(BIO *b, const void *data, int len);
+int     BIO_puts(BIO *bp,const char *buf);
+long    BIO_ctrl(BIO *bp,int cmd,long larg,void *parg);
+long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long));
 char *  BIO_ptr_ctrl(BIO *bp,int cmd,long larg);
 long    BIO_int_ctrl(BIO *bp,int cmd,long larg,int iarg);
 BIO *   BIO_push(BIO *b,BIO *append);
 BIO *   BIO_pop(BIO *b);
 void    BIO_free_all(BIO *a);
 BIO *   BIO_find_type(BIO *b,int bio_type);
+BIO *   BIO_next(BIO *b);
 BIO *   BIO_get_retry_BIO(BIO *bio, int *reason);
 int     BIO_get_retry_reason(BIO *bio);
 BIO *   BIO_dup_chain(BIO *in);
 
-#ifndef WIN16
-long BIO_debug_callback(BIO *bio,int cmd,char *argp,int argi,
+int BIO_nread0(BIO *bio, char **buf);
+int BIO_nread(BIO *bio, char **buf, int num);
+int BIO_nwrite0(BIO *bio, char **buf);
+int BIO_nwrite(BIO *bio, char **buf, int num);
+
+#ifndef OPENSSL_SYS_WIN16
+long BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi,
         long argl,long ret);
 #else
-long _far _loadds BIO_debug_callback(BIO *bio,int cmd,char *argp,int argi,
+long _far _loadds BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi,
         long argl,long ret);
 #endif
 
 BIO_METHOD *BIO_s_mem(void);
+BIO *BIO_new_mem_buf(void *buf, int len);
 BIO_METHOD *BIO_s_socket(void);
 BIO_METHOD *BIO_s_connect(void);
 BIO_METHOD *BIO_s_accept(void);
 BIO_METHOD *BIO_s_fd(void);
+BIO_METHOD *BIO_s_log(void);
+BIO_METHOD *BIO_s_bio(void);
 BIO_METHOD *BIO_s_null(void);
 BIO_METHOD *BIO_f_null(void);
-BIO_METHOD *BIO_f_nbio_test(void);
 BIO_METHOD *BIO_f_buffer(void);
+#ifdef OPENSSL_SYS_VMS
+BIO_METHOD *BIO_f_linebuffer(void);
+#endif
+BIO_METHOD *BIO_f_nbio_test(void);
+/* BIO_METHOD *BIO_f_ber(void); */
 
 int BIO_sock_should_retry(int i);
 int BIO_sock_non_fatal_error(int error);
 int BIO_fd_should_retry(int i);
 int BIO_fd_non_fatal_error(int error);
-int BIO_dump(BIO *b,char *bytes,int len);
-
-struct hostent *BIO_gethostbyname(char *name);
+int BIO_dump(BIO *b,const char *bytes,int len);
+int BIO_dump_indent(BIO *b,const char *bytes,int len,int indent);
+
+struct hostent *BIO_gethostbyname(const char *name);
+/* We might want a thread-safe interface too:
+ * struct hostent *BIO_gethostbyname_r(const char *name,
+ *     struct hostent *result, void *buffer, size_t buflen);
+ * or something similar (caller allocates a struct hostent,
+ * pointed to by "result", and additional buffer space for the various
+ * substructures; if the buffer does not suffice, NULL is returned
+ * and an appropriate error code is set).
+ */
 int BIO_sock_error(int sock);
 int BIO_socket_ioctl(int fd, long type, unsigned long *arg);
-int BIO_get_port(char *str, short *port_ptr);
-int BIO_get_host_ip(char *str, unsigned char *ip);
-int BIO_get_accept_socket(char *host_port);
+int BIO_socket_nbio(int fd,int mode);
+int BIO_get_port(const char *str, unsigned short *port_ptr);
+int BIO_get_host_ip(const char *str, unsigned char *ip);
+int BIO_get_accept_socket(char *host_port,int mode);
 int BIO_accept(int sock,char **ip_port);
 int BIO_sock_init(void );
 void BIO_sock_cleanup(void);
 int BIO_set_tcp_ndelay(int sock,int turn_on);
 
-void ERR_load_BIO_strings(void );
-
 BIO *BIO_new_socket(int sock, int close_flag);
 BIO *BIO_new_fd(int fd, int close_flag);
 BIO *BIO_new_connect(char *host_port);
 BIO *BIO_new_accept(char *host_port);
 
+int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
+        BIO **bio2, size_t writebuf2);
+/* If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
+ * Otherwise returns 0 and sets *bio1 and *bio2 to NULL.
+ * Size 0 uses default value.
+ */
+
 void BIO_copy_next_retry(BIO *b);
 
 long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
 
-#else
-
-BIO *   BIO_new();
-int     BIO_set();
-int     BIO_free();
-int     BIO_read();
-int     BIO_gets();
-int     BIO_write();
-int     BIO_puts();
-char *  BIO_ptr_ctrl();
-long    BIO_ctrl();
-long    BIO_int_ctrl();
-BIO *   BIO_push();
-BIO *   BIO_pop();
-void    BIO_free_all();
-BIO *   BIO_find_type();
-BIO *   BIO_get_retry_BIO();
-int     BIO_get_retry_reason();
-BIO *   BIO_dup_chain();
-
-#ifndef WIN16
-long BIO_debug_callback();
-#else
-long _far _loadds BIO_debug_callback();
-#endif
-
-BIO_METHOD *BIO_s_mem();
-BIO_METHOD *BIO_s_socket();
-BIO_METHOD *BIO_s_connect();
-BIO_METHOD *BIO_s_accept();
-BIO_METHOD *BIO_s_fd();
-BIO_METHOD *BIO_s_null();
-BIO_METHOD *BIO_f_null();
-BIO_METHOD *BIO_f_buffer();
-BIO_METHOD *BIO_f_nbio_test();
-
-int BIO_sock_should_retry();
-int BIO_sock_non_fatal_error();
-int BIO_fd_should_retry();
-int BIO_fd_non_fatal_error();
-int BIO_dump();
-
-struct hostent *BIO_gethostbyname();
-int BIO_sock_error();
-int BIO_socket_ioctl();
-int BIO_get_port();
-int BIO_get_host_ip();
-int BIO_get_accept_socket();
-int BIO_accept();
-int BIO_sock_init();
-void BIO_sock_cleanup();
-int BIO_set_tcp_ndelay();
-
-void ERR_load_BIO_strings();
-
-BIO *BIO_new_socket();
-BIO *BIO_new_fd();
-BIO *BIO_new_connect();
-BIO *BIO_new_accept();
-
-void BIO_copy_next_retry();
-
-int BIO_ghbn_ctrl();
-
-#endif
-
-/* Tim Hudson's portable varargs stuff */
-
-#ifndef NOPROTO
-#define VAR_ANSI        /* select ANSI version by default */
-#endif
-
-#ifdef VAR_ANSI
-/* ANSI version of a "portable" macro set for variable length args */
-#ifndef __STDARG_H__ /**/
-#include <stdarg.h>
-#endif /**/
-
-#define VAR_PLIST(arg1type,arg1)    arg1type arg1, ...
-#define VAR_PLIST2(arg1type,arg1,arg2type,arg2) arg1type arg1,arg2type arg2,...
-#define VAR_ALIST
-#define VAR_BDEFN(args,arg1type,arg1)   va_list args
-#define VAR_BDEFN2(args,arg1type,arg1,arg2type,arg2)    va_list args
-#define VAR_INIT(args,arg1type,arg1)    va_start(args,arg1);
-#define VAR_INIT2(args,arg1type,arg1,arg2type,arg2) va_start(args,arg2);
-#define VAR_ARG(args,type,arg)  arg=va_arg(args,type)
-#define VAR_END(args)           va_end(args);
-
-#else
-
-/* K&R version of a "portable" macro set for variable length args */
-#ifndef __VARARGS_H__
-#include <varargs.h>
-#endif
-
-#define VAR_PLIST(arg1type,arg1)        va_alist
-#define VAR_PLIST2(arg1type,arg1,arg2type,arg2) va_alist
-#define VAR_ALIST               va_dcl
-#define VAR_BDEFN(args,arg1type,arg1)   va_list args; arg1type arg1
-#define VAR_BDEFN2(args,arg1type,arg1,arg2type,arg2)    va_list args; \
-        arg1type arg1; arg2type arg2
-#define VAR_INIT(args,arg1type,arg1)    va_start(args); \
-        arg1=va_arg(args,arg1type);
-#define VAR_INIT2(args,arg1type,arg1,arg2type,arg2) va_start(args); \
-        arg1=va_arg(args,arg1type);     arg2=va_arg(args,arg2type);
-#define VAR_ARG(args,type,arg)          arg=va_arg(args,type)
-#define VAR_END(args)                   va_end(args);
-
-#endif
-
-#ifndef NOPROTO
-int BIO_printf( VAR_PLIST( BIO *, bio ) );
-#else
-int BIO_printf();
-#endif
+int BIO_printf(BIO *bio, const char *format, ...);
+int BIO_vprintf(BIO *bio, const char *format, va_list args);
+int BIO_snprintf(char *buf, size_t n, const char *format, ...);
+int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args);
 
 /* BEGIN ERROR CODES */
+/* The following lines are auto generated by the script mkerr.pl. Any changes
+ * made after this point may be overwritten when the script is next run.
+ */
+void ERR_load_BIO_strings(void);
+
 /* Error codes for the BIO functions. */
 
 /* Function codes. */
 #define BIO_F_ACPT_STATE                                 100
 #define BIO_F_BIO_ACCEPT                                 101
-#define BIO_F_BIO_CTRL                                   102
-#define BIO_F_BIO_GETS                                   103
-#define BIO_F_BIO_GET_ACCEPT_SOCKET                      104
-#define BIO_F_BIO_GET_HOST_IP                            105
-#define BIO_F_BIO_GET_PORT                               106
-#define BIO_F_BIO_NEW                                    107
-#define BIO_F_BIO_NEW_FILE                               108
-#define BIO_F_BIO_PUTS                                   109
-#define BIO_F_BIO_READ                                   110
-#define BIO_F_BIO_SOCK_INIT                              111
-#define BIO_F_BIO_WRITE                                  112
-#define BIO_F_BUFFER_CTRL                                113
-#define BIO_F_CONN_STATE                                 114
-#define BIO_F_FILE_CTRL                                  115
-#define BIO_F_MEM_WRITE                                  116
-#define BIO_F_SSL_NEW                                    117
-#define BIO_F_WSASTARTUP                                 118
+#define BIO_F_BIO_BER_GET_HEADER                         102
+#define BIO_F_BIO_CTRL                                   103
+#define BIO_F_BIO_GETHOSTBYNAME                          120
+#define BIO_F_BIO_GETS                                   104
+#define BIO_F_BIO_GET_ACCEPT_SOCKET                      105
+#define BIO_F_BIO_GET_HOST_IP                            106
+#define BIO_F_BIO_GET_PORT                               107
+#define BIO_F_BIO_MAKE_PAIR                              121
+#define BIO_F_BIO_NEW                                    108
+#define BIO_F_BIO_NEW_FILE                               109
+#define BIO_F_BIO_NEW_MEM_BUF                            126
+#define BIO_F_BIO_NREAD                                  123
+#define BIO_F_BIO_NREAD0                                 124
+#define BIO_F_BIO_NWRITE                                 125
+#define BIO_F_BIO_NWRITE0                                122
+#define BIO_F_BIO_PUTS                                   110
+#define BIO_F_BIO_READ                                   111
+#define BIO_F_BIO_SOCK_INIT                              112
+#define BIO_F_BIO_WRITE                                  113
+#define BIO_F_BUFFER_CTRL                                114
+#define BIO_F_CONN_CTRL                                  127
+#define BIO_F_CONN_STATE                                 115
+#define BIO_F_FILE_CTRL                                  116
+#define BIO_F_LINEBUFFER_CTRL                            129
+#define BIO_F_MEM_READ                                   128
+#define BIO_F_MEM_WRITE                                  117
+#define BIO_F_SSL_NEW                                    118
+#define BIO_F_WSASTARTUP                                 119
 
 /* Reason codes. */
 #define BIO_R_ACCEPT_ERROR                               100
 #define BIO_R_BAD_FOPEN_MODE                             101
 #define BIO_R_BAD_HOSTNAME_LOOKUP                        102
+#define BIO_R_BROKEN_PIPE                                124
 #define BIO_R_CONNECT_ERROR                              103
+#define BIO_R_EOF_ON_MEMORY_BIO                          127
 #define BIO_R_ERROR_SETTING_NBIO                         104
 #define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET      105
 #define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET        106
 #define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET          107
+#define BIO_R_INVALID_ARGUMENT                           125
 #define BIO_R_INVALID_IP_ADDRESS                         108
+#define BIO_R_IN_USE                                     123
 #define BIO_R_KEEPALIVE                                  109
 #define BIO_R_NBIO_CONNECT_ERROR                         110
 #define BIO_R_NO_ACCEPT_PORT_SPECIFIED                   111
-#define BIO_R_NO_HOSTHNAME_SPECIFIED                     112
+#define BIO_R_NO_HOSTNAME_SPECIFIED                      112
 #define BIO_R_NO_PORT_DEFINED                            113
 #define BIO_R_NO_PORT_SPECIFIED                          114
+#define BIO_R_NO_SUCH_FILE                               128
 #define BIO_R_NULL_PARAMETER                             115
-#define BIO_R_UNABLE_TO_BIND_SOCKET                      116
-#define BIO_R_UNABLE_TO_CREATE_SOCKET                    117
-#define BIO_R_UNABLE_TO_LISTEN_SOCKET                    118
-#define BIO_R_UNINITALISED                               119
-#define BIO_R_UNSUPPORTED_METHOD                         120
-#define BIO_R_WSASTARTUP                                 121
- 
+#define BIO_R_TAG_MISMATCH                               116
+#define BIO_R_UNABLE_TO_BIND_SOCKET                      117
+#define BIO_R_UNABLE_TO_CREATE_SOCKET                    118
+#define BIO_R_UNABLE_TO_LISTEN_SOCKET                    119
+#define BIO_R_UNINITIALIZED                              120
+#define BIO_R_UNSUPPORTED_METHOD                         121
+#define BIO_R_WRITE_TO_READ_ONLY_BIO                     126
+#define BIO_R_WSASTARTUP                                 122
+
 #ifdef  __cplusplus
 }
 #endif
 #endif
-
diff --git a/src/lib/libcrypto/bio/bio_cb.c b/src/lib/libcrypto/bio/bio_cb.c
index bc6ed9eda1..0ffa4d2136 100644
--- a/src/lib/libcrypto/bio/bio_cb.c
+++ b/src/lib/libcrypto/bio/bio_cb.c
@@ -60,16 +60,11 @@
 #include <string.h>
 #include <stdlib.h>
 #include "cryptlib.h"
-#include "bio.h"
-#include "err.h"
+#include <openssl/bio.h>
+#include <openssl/err.h>
 
-long MS_CALLBACK BIO_debug_callback(bio,cmd,argp,argi,argl,ret)
-BIO *bio;
-int cmd;
-char *argp;
-int argi;
-long argl;
-long ret;
+long MS_CALLBACK BIO_debug_callback(BIO *bio, int cmd, const char *argp,
+             int argi, long argl, long ret)
         {
         BIO *b;
         MS_STATIC char buf[256];
@@ -130,7 +125,7 @@ long ret;
         b=(BIO *)bio->cb_arg;
         if (b != NULL)
                 BIO_write(b,buf,strlen(buf));
-#if !defined(NO_STDIO) && !defined(WIN16)
+#if !defined(OPENSSL_NO_STDIO) && !defined(OPENSSL_SYS_WIN16)
         else
                 fputs(buf,stderr);
 #endif
diff --git a/src/lib/libcrypto/bio/bio_err.c b/src/lib/libcrypto/bio/bio_err.c
index 37e14ca107..99ca3cd0da 100644
--- a/src/lib/libcrypto/bio/bio_err.c
+++ b/src/lib/libcrypto/bio/bio_err.c
@@ -1,88 +1,102 @@
-/* lib/bio/bio_err.c */
-/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
+/* crypto/bio/bio_err.c */
+/* ====================================================================
+ * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
  *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- * 
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- * 
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- * 
  * 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 copyright
- *    notice, this list of conditions and the following disclaimer.
+ *
+ * 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. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from 
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- * 
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``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 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.
- * 
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. All advertising materials mentioning features or use of this
+ *    software must display the following acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
+ *
+ * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
+ *    endorse or promote products derived from this software without
+ *    prior written permission. For written permission, please contact
+ *    openssl-core@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ *    nor may "OpenSSL" appear in their names without prior written
+ *    permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ *    acknowledgment:
+ *    "This product includes software developed by the OpenSSL Project
+ *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED 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 OpenSSL PROJECT OR
+ * ITS 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.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com).  This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
  */
+
+/* NOTE: this file was auto generated by the mkerr.pl script: any changes
+ * made to it will be overwritten when the script next updates this file,
+ * only reason strings will be preserved.
+ */
+
 #include <stdio.h>
-#include "err.h"
-#include "bio.h"
+#include <openssl/err.h>
+#include <openssl/bio.h>
 
 /* BEGIN ERROR CODES */
-#ifndef NO_ERR
+#ifndef OPENSSL_NO_ERR
 static ERR_STRING_DATA BIO_str_functs[]=
         {
 {ERR_PACK(0,BIO_F_ACPT_STATE,0),        "ACPT_STATE"},
 {ERR_PACK(0,BIO_F_BIO_ACCEPT,0),        "BIO_accept"},
+{ERR_PACK(0,BIO_F_BIO_BER_GET_HEADER,0),        "BIO_BER_GET_HEADER"},
 {ERR_PACK(0,BIO_F_BIO_CTRL,0),  "BIO_ctrl"},
+{ERR_PACK(0,BIO_F_BIO_GETHOSTBYNAME,0), "BIO_gethostbyname"},
 {ERR_PACK(0,BIO_F_BIO_GETS,0),  "BIO_gets"},
 {ERR_PACK(0,BIO_F_BIO_GET_ACCEPT_SOCKET,0),     "BIO_get_accept_socket"},
 {ERR_PACK(0,BIO_F_BIO_GET_HOST_IP,0),   "BIO_get_host_ip"},
 {ERR_PACK(0,BIO_F_BIO_GET_PORT,0),      "BIO_get_port"},
+{ERR_PACK(0,BIO_F_BIO_MAKE_PAIR,0),     "BIO_MAKE_PAIR"},
 {ERR_PACK(0,BIO_F_BIO_NEW,0),   "BIO_new"},
 {ERR_PACK(0,BIO_F_BIO_NEW_FILE,0),      "BIO_new_file"},
+{ERR_PACK(0,BIO_F_BIO_NEW_MEM_BUF,0),   "BIO_new_mem_buf"},
+{ERR_PACK(0,BIO_F_BIO_NREAD,0), "BIO_nread"},
+{ERR_PACK(0,BIO_F_BIO_NREAD0,0),        "BIO_nread0"},
+{ERR_PACK(0,BIO_F_BIO_NWRITE,0),        "BIO_nwrite"},
+{ERR_PACK(0,BIO_F_BIO_NWRITE0,0),       "BIO_nwrite0"},
 {ERR_PACK(0,BIO_F_BIO_PUTS,0),  "BIO_puts"},
 {ERR_PACK(0,BIO_F_BIO_READ,0),  "BIO_read"},
 {ERR_PACK(0,BIO_F_BIO_SOCK_INIT,0),     "BIO_sock_init"},
 {ERR_PACK(0,BIO_F_BIO_WRITE,0), "BIO_write"},
 {ERR_PACK(0,BIO_F_BUFFER_CTRL,0),       "BUFFER_CTRL"},
+{ERR_PACK(0,BIO_F_CONN_CTRL,0), "CONN_CTRL"},
 {ERR_PACK(0,BIO_F_CONN_STATE,0),        "CONN_STATE"},
 {ERR_PACK(0,BIO_F_FILE_CTRL,0), "FILE_CTRL"},
+{ERR_PACK(0,BIO_F_LINEBUFFER_CTRL,0),   "LINEBUFFER_CTRL"},
+{ERR_PACK(0,BIO_F_MEM_READ,0),  "MEM_READ"},
 {ERR_PACK(0,BIO_F_MEM_WRITE,0), "MEM_WRITE"},
-{ERR_PACK(0,BIO_F_SSL_NEW,0),   "SSL_NEW"},
+{ERR_PACK(0,BIO_F_SSL_NEW,0),   "SSL_new"},
 {ERR_PACK(0,BIO_F_WSASTARTUP,0),        "WSASTARTUP"},
-{0,NULL},
+{0,NULL}
         };
 
 static ERR_STRING_DATA BIO_str_reasons[]=
@@ -90,38 +104,45 @@ static ERR_STRING_DATA BIO_str_reasons[]=
 {BIO_R_ACCEPT_ERROR                      ,"accept error"},
 {BIO_R_BAD_FOPEN_MODE                    ,"bad fopen mode"},
 {BIO_R_BAD_HOSTNAME_LOOKUP               ,"bad hostname lookup"},
+{BIO_R_BROKEN_PIPE                       ,"broken pipe"},
 {BIO_R_CONNECT_ERROR                     ,"connect error"},
+{BIO_R_EOF_ON_MEMORY_BIO                 ,"EOF on memory BIO"},
 {BIO_R_ERROR_SETTING_NBIO                ,"error setting nbio"},
 {BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET,"error setting nbio on accepted socket"},
 {BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET,"error setting nbio on accept socket"},
 {BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET ,"gethostbyname addr is not af inet"},
+{BIO_R_INVALID_ARGUMENT                  ,"invalid argument"},
 {BIO_R_INVALID_IP_ADDRESS                ,"invalid ip address"},
+{BIO_R_IN_USE                            ,"in use"},
 {BIO_R_KEEPALIVE                         ,"keepalive"},
 {BIO_R_NBIO_CONNECT_ERROR                ,"nbio connect error"},
 {BIO_R_NO_ACCEPT_PORT_SPECIFIED          ,"no accept port specified"},
-{BIO_R_NO_HOSTHNAME_SPECIFIED            ,"no hosthname specified"},
+{BIO_R_NO_HOSTNAME_SPECIFIED             ,"no hostname specified"},
 {BIO_R_NO_PORT_DEFINED                   ,"no port defined"},
 {BIO_R_NO_PORT_SPECIFIED                 ,"no port specified"},
+{BIO_R_NO_SUCH_FILE                      ,"no such file"},
 {BIO_R_NULL_PARAMETER                    ,"null parameter"},
+{BIO_R_TAG_MISMATCH                      ,"tag mismatch"},
 {BIO_R_UNABLE_TO_BIND_SOCKET             ,"unable to bind socket"},
 {BIO_R_UNABLE_TO_CREATE_SOCKET           ,"unable to create socket"},
 {BIO_R_UNABLE_TO_LISTEN_SOCKET           ,"unable to listen socket"},
-{BIO_R_UNINITALISED                      ,"uninitalised"},
+{BIO_R_UNINITIALIZED                     ,"uninitialized"},
 {BIO_R_UNSUPPORTED_METHOD                ,"unsupported method"},
-{BIO_R_WSASTARTUP                        ,"wsastartup"},
-{0,NULL},
+{BIO_R_WRITE_TO_READ_ONLY_BIO            ,"write to read only BIO"},
+{BIO_R_WSASTARTUP                        ,"WSAStartup"},
+{0,NULL}
         };
 
 #endif
 
-void ERR_load_BIO_strings()
+void ERR_load_BIO_strings(void)
         {
         static int init=1;
 
-        if (init);
-                {;
+        if (init)
+                {
                 init=0;
-#ifndef NO_ERR
+#ifndef OPENSSL_NO_ERR
                 ERR_load_strings(ERR_LIB_BIO,BIO_str_functs);
                 ERR_load_strings(ERR_LIB_BIO,BIO_str_reasons);
 #endif
diff --git a/src/lib/libcrypto/bio/bio_lib.c b/src/lib/libcrypto/bio/bio_lib.c
index 7a66b0892e..50df2238fa 100644
--- a/src/lib/libcrypto/bio/bio_lib.c
+++ b/src/lib/libcrypto/bio/bio_lib.c
@@ -58,20 +58,16 @@
 
 #include <stdio.h>
 #include <errno.h>
-#include "crypto.h"
+#include <openssl/crypto.h>
 #include "cryptlib.h"
-#include "bio.h"
-#include "stack.h"
+#include <openssl/bio.h>
+#include <openssl/stack.h>
 
-static STACK *bio_meth=NULL;
-static int bio_meth_num=0;
-
-BIO *BIO_new(method)
-BIO_METHOD *method;
+BIO *BIO_new(BIO_METHOD *method)
         {
         BIO *ret=NULL;
 
-        ret=(BIO *)Malloc(sizeof(BIO));
+        ret=(BIO *)OPENSSL_malloc(sizeof(BIO));
         if (ret == NULL)
                 {
                 BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
@@ -79,15 +75,13 @@ BIO_METHOD *method;
                 }
         if (!BIO_set(ret,method))
                 {
-                Free(ret);
+                OPENSSL_free(ret);
                 ret=NULL;
                 }
         return(ret);
         }
 
-int BIO_set(bio,method)
-BIO *bio;
-BIO_METHOD *method;
+int BIO_set(BIO *bio, BIO_METHOD *method)
         {
         bio->method=method;
         bio->callback=NULL;
@@ -103,15 +97,18 @@ BIO_METHOD *method;
         bio->references=1;
         bio->num_read=0L;
         bio->num_write=0L;
-        CRYPTO_new_ex_data(bio_meth,(char *)bio,&bio->ex_data);
+        CRYPTO_new_ex_data(CRYPTO_EX_INDEX_BIO, bio, &bio->ex_data);
         if (method->create != NULL)
                 if (!method->create(bio))
+                        {
+                        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, bio,
+                                        &bio->ex_data);
                         return(0);
+                        }
         return(1);
         }
 
-int BIO_free(a)
-BIO *a;
+int BIO_free(BIO *a)
         {
         int ret=0,i;
 
@@ -121,7 +118,7 @@ BIO *a;
 #ifdef REF_PRINT
         REF_PRINT("BIO",a);
 #endif
-        if (i > 0) return(1);
+        if (i > 0) return(1);
 #ifdef REF_CHECK
         if (i < 0)
                 {
@@ -133,18 +130,18 @@ BIO *a;
                 ((i=(int)a->callback(a,BIO_CB_FREE,NULL,0,0L,1L)) <= 0))
                         return(i);
 
-        CRYPTO_free_ex_data(bio_meth,(char *)a,&a->ex_data);
+        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_BIO, a, &a->ex_data);
 
         if ((a->method == NULL) || (a->method->destroy == NULL)) return(1);
         ret=a->method->destroy(a);
-        Free(a);
+        OPENSSL_free(a);
         return(1);
         }
 
-int BIO_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+void BIO_vfree(BIO *a)
+    { BIO_free(a); }
+
+int BIO_read(BIO *b, void *out, int outl)
         {
         int i;
         long (*cb)();
@@ -162,11 +159,12 @@ int outl;
 
         if (!b->init)
                 {
-                BIOerr(BIO_F_BIO_READ,BIO_R_UNINITALISED);
+                BIOerr(BIO_F_BIO_READ,BIO_R_UNINITIALIZED);
                 return(-2);
                 }
 
         i=b->method->bread(b,out,outl);
+
         if (i > 0) b->num_read+=(unsigned long)i;
 
         if (cb != NULL)
@@ -175,10 +173,7 @@ int outl;
         return(i);
         }
 
-int BIO_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+int BIO_write(BIO *b, const void *in, int inl)
         {
         int i;
         long (*cb)();
@@ -199,11 +194,12 @@ int inl;
 
         if (!b->init)
                 {
-                BIOerr(BIO_F_BIO_WRITE,BIO_R_UNINITALISED);
+                BIOerr(BIO_F_BIO_WRITE,BIO_R_UNINITIALIZED);
                 return(-2);
                 }
 
         i=b->method->bwrite(b,in,inl);
+
         if (i > 0) b->num_write+=(unsigned long)i;
 
         if (cb != NULL)
@@ -212,9 +208,7 @@ int inl;
         return(i);
         }
 
-int BIO_puts(b,in)
-BIO *b;
-char *in;
+int BIO_puts(BIO *b, const char *in)
         {
         int i;
         long (*cb)();
@@ -233,22 +227,21 @@ char *in;
 
         if (!b->init)
                 {
-                BIOerr(BIO_F_BIO_PUTS,BIO_R_UNINITALISED);
+                BIOerr(BIO_F_BIO_PUTS,BIO_R_UNINITIALIZED);
                 return(-2);
                 }
 
         i=b->method->bputs(b,in);
 
+        if (i > 0) b->num_write+=(unsigned long)i;
+
         if (cb != NULL)
                 i=(int)cb(b,BIO_CB_PUTS|BIO_CB_RETURN,in,0,
                         0L,(long)i);
         return(i);
         }
 
-int BIO_gets(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+int BIO_gets(BIO *b, char *in, int inl)
         {
         int i;
         long (*cb)();
@@ -267,7 +260,7 @@ int inl;
 
         if (!b->init)
                 {
-                BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITALISED);
+                BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITIALIZED);
                 return(-2);
                 }
 
@@ -279,11 +272,7 @@ int inl;
         return(i);
         }
 
-long BIO_int_ctrl(b,cmd,larg,iarg)
-BIO *b;
-int cmd;
-long larg;
-int iarg;
+long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
         {
         int i;
 
@@ -291,10 +280,7 @@ int iarg;
         return(BIO_ctrl(b,cmd,larg,(char *)&i));
         }
 
-char *BIO_ptr_ctrl(b,cmd,larg)
-BIO *b;
-int cmd;
-long larg;
+char *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
         {
         char *p=NULL;
 
@@ -304,11 +290,7 @@ long larg;
                 return(p);
         }
 
-long BIO_ctrl(b,cmd,larg,parg)
-BIO *b;
-int cmd;
-long larg;
-char *parg;
+long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
         {
         long ret;
         long (*cb)();
@@ -335,9 +317,49 @@ char *parg;
         return(ret);
         }
 
+long BIO_callback_ctrl(BIO *b, int cmd, void (*fp)(struct bio_st *, int, const char *, int, long, long))
+        {
+        long ret;
+        long (*cb)();
+
+        if (b == NULL) return(0);
+
+        if ((b->method == NULL) || (b->method->callback_ctrl == NULL))
+                {
+                BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD);
+                return(-2);
+                }
+
+        cb=b->callback;
+
+        if ((cb != NULL) &&
+                ((ret=cb(b,BIO_CB_CTRL,(void *)&fp,cmd,0,1L)) <= 0))
+                return(ret);
+
+        ret=b->method->callback_ctrl(b,cmd,fp);
+
+        if (cb != NULL)
+                ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,(void *)&fp,cmd,
+                        0,ret);
+        return(ret);
+        }
+
+/* It is unfortunate to duplicate in functions what the BIO_(w)pending macros
+ * do; but those macros have inappropriate return type, and for interfacing
+ * from other programming languages, C macros aren't much of a help anyway. */
+size_t BIO_ctrl_pending(BIO *bio)
+        {
+        return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
+        }
+
+size_t BIO_ctrl_wpending(BIO *bio)
+        {
+        return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
+        }
+
+
 /* put the 'bio' on the end of b's list of operators */
-BIO *BIO_push(b,bio)
-BIO *b,*bio;
+BIO *BIO_push(BIO *b, BIO *bio)
         {
         BIO *lb;
 
@@ -354,8 +376,7 @@ BIO *b,*bio;
         }
 
 /* Remove the first and return the rest */
-BIO *BIO_pop(b)
-BIO *b;
+BIO *BIO_pop(BIO *b)
         {
         BIO *ret;
 
@@ -373,9 +394,7 @@ BIO *b;
         return(ret);
         }
 
-BIO *BIO_get_retry_BIO(bio,reason)
-BIO *bio;
-int *reason;
+BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
         {
         BIO *b,*last;
 
@@ -391,18 +410,16 @@ int *reason;
         return(last);
         }
 
-int BIO_get_retry_reason(bio)
-BIO *bio;
+int BIO_get_retry_reason(BIO *bio)
         {
         return(bio->retry_reason);
         }
 
-BIO *BIO_find_type(bio,type)
-BIO *bio;
-int type;
+BIO *BIO_find_type(BIO *bio, int type)
         {
         int mt,mask;
 
+        if(!bio) return NULL;
         mask=type&0xff;
         do      {
                 if (bio->method != NULL)
@@ -421,8 +438,13 @@ int type;
         return(NULL);
         }
 
-void BIO_free_all(bio)
-BIO *bio;
+BIO *BIO_next(BIO *b)
+        {
+        if(!b) return NULL;
+        return b->next_bio;
+        }
+
+void BIO_free_all(BIO *bio)
         {
         BIO *b;
         int ref;
@@ -438,8 +460,7 @@ BIO *bio;
                 }
         }
 
-BIO *BIO_dup_chain(in)
-BIO *in;
+BIO *BIO_dup_chain(BIO *in)
         {
         BIO *ret=NULL,*eoc=NULL,*bio,*new;
 
@@ -461,9 +482,10 @@ BIO *in;
                         goto err;
                         }
 
-                /* copy app data */
-                if (!CRYPTO_dup_ex_data(bio_meth,&new->ex_data,&bio->ex_data))
-                        goto err;
+                /* copy app data */
+                if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_BIO, &new->ex_data,
+                                        &bio->ex_data))
+                        goto err;
 
                 if (ret == NULL)
                         {
@@ -483,37 +505,39 @@ err:
         return(NULL);   
         }
 
-void BIO_copy_next_retry(b)
-BIO *b;
+void BIO_copy_next_retry(BIO *b)
         {
         BIO_set_flags(b,BIO_get_retry_flags(b->next_bio));
         b->retry_reason=b->next_bio->retry_reason;
         }
 
-int BIO_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
-long argl;
-char *argp;
-int (*new_func)();
-int (*dup_func)();
-void (*free_func)();
-        {
-        bio_meth_num++;
-        return(CRYPTO_get_ex_new_index(bio_meth_num-1,&bio_meth,
-                argl,argp,new_func,dup_func,free_func));
-        }
-
-int BIO_set_ex_data(bio,idx,data)
-BIO *bio;
-int idx;
-char *data;
+int BIO_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
+             CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
+        {
+        return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, argl, argp,
+                                new_func, dup_func, free_func);
+        }
+
+int BIO_set_ex_data(BIO *bio, int idx, void *data)
         {
         return(CRYPTO_set_ex_data(&(bio->ex_data),idx,data));
         }
 
-char *BIO_get_ex_data(bio,idx)
-BIO *bio;
-int idx;
+void *BIO_get_ex_data(BIO *bio, int idx)
         {
         return(CRYPTO_get_ex_data(&(bio->ex_data),idx));
         }
 
+unsigned long BIO_number_read(BIO *bio)
+{
+        if(bio) return bio->num_read;
+        return 0;
+}
+
+unsigned long BIO_number_written(BIO *bio)
+{
+        if(bio) return bio->num_write;
+        return 0;
+}
+
+IMPLEMENT_STACK_OF(BIO)
diff --git a/src/lib/libcrypto/bio/bss_acpt.c b/src/lib/libcrypto/bio/bss_acpt.c
index e49902fa9f..8ea1db158b 100644
--- a/src/lib/libcrypto/bio/bss_acpt.c
+++ b/src/lib/libcrypto/bio/bss_acpt.c
@@ -56,22 +56,25 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef NO_SOCK
+#ifndef OPENSSL_NO_SOCK
 
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
-#include "bio.h"
+#include <openssl/bio.h>
 
-/*      BIOerr(BIO_F_WSASTARTUP,BIO_R_WSASTARTUP ); */
-
-#ifdef WIN16
+#ifdef OPENSSL_SYS_WIN16
 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
 #else
 #define SOCKET_PROTOCOL IPPROTO_TCP
 #endif
 
+#if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
+/* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
+#undef FIONBIO
+#endif
+
 typedef struct bio_accept_st
         {
         int state;
@@ -82,39 +85,24 @@ typedef struct bio_accept_st
 
         char *addr;
         int nbio;
+        /* If 0, it means normal, if 1, do a connect on bind failure,
+         * and if there is no-one listening, bind with SO_REUSEADDR.
+         * If 2, always use SO_REUSEADDR. */
+        int bind_mode;
         BIO *bio_chain;
         } BIO_ACCEPT;
 
-#ifndef NOPROTO
-static int acpt_write(BIO *h,char *buf,int num);
-static int acpt_read(BIO *h,char *buf,int size);
-static int acpt_puts(BIO *h,char *str);
-static long acpt_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int acpt_write(BIO *h, const char *buf, int num);
+static int acpt_read(BIO *h, char *buf, int size);
+static int acpt_puts(BIO *h, const char *str);
+static long acpt_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int acpt_new(BIO *h);
 static int acpt_free(BIO *data);
-#else
-static int acpt_write();
-static int acpt_read();
-static int acpt_puts();
-static long acpt_ctrl();
-static int acpt_new();
-static int acpt_free();
-#endif
-
-#ifndef NOPROTO
 static int acpt_state(BIO *b, BIO_ACCEPT *c);
 static void acpt_close_socket(BIO *data);
 BIO_ACCEPT *BIO_ACCEPT_new(void );
 void BIO_ACCEPT_free(BIO_ACCEPT *a);
 
-#else
-
-static int acpt_state();
-static void acpt_close_socket();
-BIO_ACCEPT *BIO_ACCEPT_new();
-void BIO_ACCEPT_free();
-#endif
-
 #define ACPT_S_BEFORE                   1
 #define ACPT_S_GET_ACCEPT_SOCKET        2
 #define ACPT_S_OK                       3
@@ -130,15 +118,15 @@ static BIO_METHOD methods_acceptp=
         acpt_ctrl,
         acpt_new,
         acpt_free,
+        NULL,
         };
 
-BIO_METHOD *BIO_s_accept()
+BIO_METHOD *BIO_s_accept(void)
         {
         return(&methods_acceptp);
         }
 
-static int acpt_new(bi)
-BIO *bi;
+static int acpt_new(BIO *bi)
         {
         BIO_ACCEPT *ba;
 
@@ -153,29 +141,31 @@ BIO *bi;
         return(1);
         }
 
-BIO_ACCEPT *BIO_ACCEPT_new()
+BIO_ACCEPT *BIO_ACCEPT_new(void)
         {
         BIO_ACCEPT *ret;
 
-        if ((ret=(BIO_ACCEPT *)Malloc(sizeof(BIO_ACCEPT))) == NULL)
+        if ((ret=(BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL)
                 return(NULL);
 
         memset(ret,0,sizeof(BIO_ACCEPT));
         ret->accept_sock=INVALID_SOCKET;
+        ret->bind_mode=BIO_BIND_NORMAL;
         return(ret);
         }
 
-void BIO_ACCEPT_free(a)
-BIO_ACCEPT *a;
+void BIO_ACCEPT_free(BIO_ACCEPT *a)
         {
-        if (a->param_addr != NULL) Free(a->param_addr);
-        if (a->addr != NULL) Free(a->addr);
+        if(a == NULL)
+            return;
+
+        if (a->param_addr != NULL) OPENSSL_free(a->param_addr);
+        if (a->addr != NULL) OPENSSL_free(a->addr);
         if (a->bio_chain != NULL) BIO_free(a->bio_chain);
-        Free(a);
+        OPENSSL_free(a);
         }
 
-static void acpt_close_socket(bio)
-BIO *bio;
+static void acpt_close_socket(BIO *bio)
         {
         BIO_ACCEPT *c;
 
@@ -183,18 +173,13 @@ BIO *bio;
         if (c->accept_sock != INVALID_SOCKET)
                 {
                 shutdown(c->accept_sock,2);
-# ifdef WINDOWS
                 closesocket(c->accept_sock);
-# else
-                close(c->accept_sock);
-# endif
                 c->accept_sock=INVALID_SOCKET;
                 bio->num=INVALID_SOCKET;
                 }
         }
 
-static int acpt_free(a)
-BIO *a;
+static int acpt_free(BIO *a)
         {
         BIO_ACCEPT *data;
 
@@ -212,12 +197,9 @@ BIO *a;
         return(1);
         }
         
-static int acpt_state(b,c)
-BIO *b;
-BIO_ACCEPT *c;
+static int acpt_state(BIO *b, BIO_ACCEPT *c)
         {
         BIO *bio=NULL,*dbio;
-        unsigned long l=1;
         int s= -1;
         int i;
 
@@ -230,56 +212,58 @@ again:
                         BIOerr(BIO_F_ACPT_STATE,BIO_R_NO_ACCEPT_PORT_SPECIFIED);
                         return(-1);
                         }
-                s=BIO_get_accept_socket(c->param_addr);
+                s=BIO_get_accept_socket(c->param_addr,c->bind_mode);
                 if (s == INVALID_SOCKET)
                         return(-1);
 
-#ifdef FIONBIO
                 if (c->accept_nbio)
                         {
-                        i=BIO_socket_ioctl(b->num,FIONBIO,&l);
-                        if (i < 0)
+                        if (!BIO_socket_nbio(s,1))
                                 {
-#ifdef WINDOWS
                                 closesocket(s);
-#else
-                                close(s);
-# endif
                                 BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET);
                                 return(-1);
                                 }
                         }
-#endif
                 c->accept_sock=s;
                 b->num=s;
                 c->state=ACPT_S_GET_ACCEPT_SOCKET;
                 return(1);
-                break;
+                /* break; */
         case ACPT_S_GET_ACCEPT_SOCKET:
                 if (b->next_bio != NULL)
                         {
                         c->state=ACPT_S_OK;
                         goto again;
                         }
+                BIO_clear_retry_flags(b);
+                b->retry_reason=0;
                 i=BIO_accept(c->accept_sock,&(c->addr));
+
+                /* -2 return means we should retry */
+                if(i == -2)
+                        {
+                        BIO_set_retry_special(b);
+                        b->retry_reason=BIO_RR_ACCEPT;
+                        return -1;
+                        }
+
                 if (i < 0) return(i);
+
                 bio=BIO_new_socket(i,BIO_CLOSE);
                 if (bio == NULL) goto err;
 
                 BIO_set_callback(bio,BIO_get_callback(b));
                 BIO_set_callback_arg(bio,BIO_get_callback_arg(b));
 
-#ifdef FIONBIO
                 if (c->nbio)
                         {
-                        i=BIO_socket_ioctl(i,FIONBIO,&l);
-                        if (i < 0)
+                        if (!BIO_socket_nbio(i,1))
                                 {
                                 BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET);
                                 goto err;
                                 }
                         }
-#endif
 
                 /* If the accept BIO has an bio_chain, we dup it and
                  * put the new socket at the end. */
@@ -298,15 +282,9 @@ err:
                 if (bio != NULL)
                         BIO_free(bio);
                 else if (s >= 0)
-                        {
-#ifdef WINDOWS
                         closesocket(s);
-#else
-                        close(s);
-# endif
-                        }
                 return(0);
-                break;
+                /* break; */
         case ACPT_S_OK:
                 if (b->next_bio == NULL)
                         {
@@ -314,23 +292,20 @@ err:
                         goto again;
                         }
                 return(1);
-                break;
+                /* break; */
         default:        
                 return(0);
-                break;
+                /* break; */
                 }
 
         }
 
-static int acpt_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int acpt_read(BIO *b, char *out, int outl)
         {
         int ret=0;
         BIO_ACCEPT *data;
 
-        BIO_clear_retry_flags(b);
+        BIO_clear_retry_flags(b);
         data=(BIO_ACCEPT *)b->ptr;
 
         while (b->next_bio == NULL)
@@ -344,10 +319,7 @@ int outl;
         return(ret);
         }
 
-static int acpt_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int acpt_write(BIO *b, const char *in, int inl)
         {
         int ret;
         BIO_ACCEPT *data;
@@ -366,11 +338,7 @@ int inl;
         return(ret);
         }
 
-static long acpt_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         BIO *dbio;
         int *ip;
@@ -399,7 +367,7 @@ char *ptr;
                                 {
                                 b->init=1;
                                 if (data->param_addr != NULL)
-                                        Free(data->param_addr);
+                                        OPENSSL_free(data->param_addr);
                                 data->param_addr=BUF_strdup(ptr);
                                 }
                         else if (num == 1)
@@ -417,13 +385,21 @@ char *ptr;
         case BIO_C_SET_NBIO:
                 data->nbio=(int)num;
                 break;
+        case BIO_C_SET_FD:
+                b->init=1;
+                b->num= *((int *)ptr);
+                data->accept_sock=b->num;
+                data->state=ACPT_S_GET_ACCEPT_SOCKET;
+                b->shutdown=(int)num;
+                b->init=1;
+                break;
         case BIO_C_GET_FD:
                 if (b->init)
                         {
                         ip=(int *)ptr;
                         if (ip != NULL)
                                 *ip=data->accept_sock;
-                        ret=b->num;
+                        ret=data->accept_sock;
                         }
                 else
                         ret= -1;
@@ -454,6 +430,12 @@ char *ptr;
                 break;
         case BIO_CTRL_FLUSH:
                 break;
+        case BIO_C_SET_BIND_MODE:
+                data->bind_mode=(int)num;
+                break;
+        case BIO_C_GET_BIND_MODE:
+                ret=(long)data->bind_mode;
+                break;
         case BIO_CTRL_DUP:
                 dbio=(BIO *)ptr;
 /*              if (data->param_port) EAY EAY
@@ -470,9 +452,7 @@ char *ptr;
         return(ret);
         }
 
-static int acpt_puts(bp,str)
-BIO *bp;
-char *str;
+static int acpt_puts(BIO *bp, const char *str)
         {
         int n,ret;
 
@@ -481,8 +461,7 @@ char *str;
         return(ret);
         }
 
-BIO *BIO_new_accept(str)
-char *str;
+BIO *BIO_new_accept(char *str)
         {
         BIO *ret;
 
diff --git a/src/lib/libcrypto/bio/bss_bio.c b/src/lib/libcrypto/bio/bss_bio.c
index 562e9d8de2..1c485a4479 100644
--- a/src/lib/libcrypto/bio/bss_bio.c
+++ b/src/lib/libcrypto/bio/bss_bio.c
@@ -7,25 +7,46 @@
  * for which no specific BIO method is available.
  * See ssl/ssltest.c for some hints on how this can be used. */
 
+/* BIO_DEBUG implies BIO_PAIR_DEBUG */
+#ifdef BIO_DEBUG
+# ifndef BIO_PAIR_DEBUG
+#  define BIO_PAIR_DEBUG
+# endif
+#endif
+
+/* disable assert() unless BIO_PAIR_DEBUG has been defined */
 #ifndef BIO_PAIR_DEBUG
-# undef NDEBUG /* avoid conflicting definitions */
-# define NDEBUG
+# ifndef NDEBUG
+#  define NDEBUG
+# endif
 #endif
 
 #include <assert.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <openssl/bio.h>
 #include <openssl/err.h>
+#include <openssl/err.h>
 #include <openssl/crypto.h>
 
+#include "e_os.h"
+
+/* VxWorks defines SSIZE_MAX with an empty value causing compile errors */
+#if defined(OPENSSL_SYS_VSWORKS)
+# undef SSIZE_MAX
+#endif
+#ifndef SSIZE_MAX
+# define SSIZE_MAX INT_MAX
+#endif
+
 static int bio_new(BIO *bio);
 static int bio_free(BIO *bio);
 static int bio_read(BIO *bio, char *buf, int size);
-static int bio_write(BIO *bio, char *buf, int num);
+static int bio_write(BIO *bio, const char *buf, int num);
 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr);
-static int bio_puts(BIO *bio, char *str);
+static int bio_puts(BIO *bio, const char *str);
 
 static int bio_make_pair(BIO *bio1, BIO *bio2);
 static void bio_destroy_pair(BIO *bio);
@@ -40,7 +61,8 @@ static BIO_METHOD methods_biop =
         NULL /* no bio_gets */,
         bio_ctrl,
         bio_new,
-        bio_free
+        bio_free,
+        NULL /* no bio_callback_ctrl */
 };
 
 BIO_METHOD *BIO_s_bio(void)
@@ -64,7 +86,7 @@ struct bio_bio_st
 
         size_t request; /* valid iff peer != NULL; 0 if len != 0,
                          * otherwise set by peer to number of bytes
-                         * it (unsuccesfully) tried to read,
+                         * it (unsuccessfully) tried to read,
                          * never more than buffer space (size-len) warrants. */
 };
 
@@ -72,7 +94,7 @@ static int bio_new(BIO *bio)
         {
         struct bio_bio_st *b;
         
-        b = Malloc(sizeof *b);
+        b = OPENSSL_malloc(sizeof *b);
         if (b == NULL)
                 return 0;
 
@@ -100,10 +122,10 @@ static int bio_free(BIO *bio)
         
         if (b->buf != NULL)
                 {
-                Free(b->buf);
+                OPENSSL_free(b->buf);
                 }
 
-        Free(b);
+        OPENSSL_free(b);
 
         return 1;
         }
@@ -195,7 +217,87 @@ static int bio_read(BIO *bio, char *buf, int size_)
         return size;
         }
 
-static int bio_write(BIO *bio, char *buf, int num_)
+/* non-copying interface: provide pointer to available data in buffer
+ *    bio_nread0:  return number of available bytes
+ *    bio_nread:   also advance index
+ * (example usage:  bio_nread0(), read from buffer, bio_nread()
+ *  or just         bio_nread(), read from buffer)
+ */
+/* WARNING: The non-copying interface is largely untested as of yet
+ * and may contain bugs. */
+static ssize_t bio_nread0(BIO *bio, char **buf)
+        {
+        struct bio_bio_st *b, *peer_b;
+        ssize_t num;
+        
+        BIO_clear_retry_flags(bio);
+
+        if (!bio->init)
+                return 0;
+        
+        b = bio->ptr;
+        assert(b != NULL);
+        assert(b->peer != NULL);
+        peer_b = b->peer->ptr;
+        assert(peer_b != NULL);
+        assert(peer_b->buf != NULL);
+        
+        peer_b->request = 0;
+        
+        if (peer_b->len == 0)
+                {
+                char dummy;
+                
+                /* avoid code duplication -- nothing available for reading */
+                return bio_read(bio, &dummy, 1); /* returns 0 or -1 */
+                }
+
+        num = peer_b->len;
+        if (peer_b->size < peer_b->offset + num)
+                /* no ring buffer wrap-around for non-copying interface */
+                num = peer_b->size - peer_b->offset;
+        assert(num > 0);
+
+        if (buf != NULL)
+                *buf = peer_b->buf + peer_b->offset;
+        return num;
+        }
+
+static ssize_t bio_nread(BIO *bio, char **buf, size_t num_)
+        {
+        struct bio_bio_st *b, *peer_b;
+        ssize_t num, available;
+
+        if (num_ > SSIZE_MAX)
+                num = SSIZE_MAX;
+        else
+                num = (ssize_t)num_;
+
+        available = bio_nread0(bio, buf);
+        if (num > available)
+                num = available;
+        if (num <= 0)
+                return num;
+
+        b = bio->ptr;
+        peer_b = b->peer->ptr;
+
+        peer_b->len -= num;
+        if (peer_b->len) 
+                {
+                peer_b->offset += num;
+                assert(peer_b->offset <= peer_b->size);
+                if (peer_b->offset == peer_b->size)
+                        peer_b->offset = 0;
+                }
+        else
+                peer_b->offset = 0;
+
+        return num;
+        }
+
+
+static int bio_write(BIO *bio, const char *buf, int num_)
         {
         size_t num = num_;
         size_t rest;
@@ -268,6 +370,83 @@ static int bio_write(BIO *bio, char *buf, int num_)
         return num;
         }
 
+/* non-copying interface: provide pointer to region to write to
+ *   bio_nwrite0:  check how much space is available
+ *   bio_nwrite:   also increase length
+ * (example usage:  bio_nwrite0(), write to buffer, bio_nwrite()
+ *  or just         bio_nwrite(), write to buffer)
+ */
+static ssize_t bio_nwrite0(BIO *bio, char **buf)
+        {
+        struct bio_bio_st *b;
+        size_t num;
+        size_t write_offset;
+
+        BIO_clear_retry_flags(bio);
+
+        if (!bio->init)
+                return 0;
+
+        b = bio->ptr;           
+        assert(b != NULL);
+        assert(b->peer != NULL);
+        assert(b->buf != NULL);
+
+        b->request = 0;
+        if (b->closed)
+                {
+                BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE);
+                return -1;
+                }
+
+        assert(b->len <= b->size);
+
+        if (b->len == b->size)
+                {
+                BIO_set_retry_write(bio);
+                return -1;
+                }
+
+        num = b->size - b->len;
+        write_offset = b->offset + b->len;
+        if (write_offset >= b->size)
+                write_offset -= b->size;
+        if (write_offset + num > b->size)
+                /* no ring buffer wrap-around for non-copying interface
+                 * (to fulfil the promise by BIO_ctrl_get_write_guarantee,
+                 * BIO_nwrite may have to be called twice) */
+                num = b->size - write_offset;
+
+        if (buf != NULL)
+                *buf = b->buf + write_offset;
+        assert(write_offset + num <= b->size);
+
+        return num;
+        }
+
+static ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_)
+        {
+        struct bio_bio_st *b;
+        ssize_t num, space;
+
+        if (num_ > SSIZE_MAX)
+                num = SSIZE_MAX;
+        else
+                num = (ssize_t)num_;
+
+        space = bio_nwrite0(bio, buf);
+        if (num > space)
+                num = space;
+        if (num <= 0)
+                return num;
+        b = bio->ptr;
+        assert(b != NULL);
+        b->len += num;
+        assert(b->len <= b->size);
+
+        return num;
+        }
+
 
 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
         {
@@ -299,7 +478,7 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
                                 {
                                 if (b->buf) 
                                         {
-                                        Free(b->buf);
+                                        OPENSSL_free(b->buf);
                                         b->buf = NULL;
                                         }
                                 b->size = new_size;
@@ -309,7 +488,8 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
                 break;
 
         case BIO_C_GET_WRITE_BUF_SIZE:
-                num = (long) b->size;
+                ret = (long) b->size;
+                break;
 
         case BIO_C_MAKE_BIO_PAIR:
                 {
@@ -331,7 +511,7 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
 
         case BIO_C_GET_WRITE_GUARANTEE:
                 /* How many bytes can the caller feed to the next write
-                 * withouth having to keep any? */
+                 * without having to keep any? */
                 if (b->peer == NULL || b->closed)
                         ret = 0;
                 else
@@ -339,18 +519,47 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
                 break;
 
         case BIO_C_GET_READ_REQUEST:
-                /* If the peer unsuccesfully tried to read, how many bytes
+                /* If the peer unsuccessfully tried to read, how many bytes
                  * were requested?  (As with BIO_CTRL_PENDING, that number
                  * can usually be treated as boolean.) */
                 ret = (long) b->request;
                 break;
 
+        case BIO_C_RESET_READ_REQUEST:
+                /* Reset request.  (Can be useful after read attempts
+                 * at the other side that are meant to be non-blocking,
+                 * e.g. when probing SSL_read to see if any data is
+                 * available.) */
+                b->request = 0;
+                ret = 1;
+                break;
+
         case BIO_C_SHUTDOWN_WR:
                 /* similar to shutdown(..., SHUT_WR) */
                 b->closed = 1;
                 ret = 1;
                 break;
 
+        case BIO_C_NREAD0:
+                /* prepare for non-copying read */
+                ret = (long) bio_nread0(bio, ptr);
+                break;
+                
+        case BIO_C_NREAD:
+                /* non-copying read */
+                ret = (long) bio_nread(bio, ptr, (size_t) num);
+                break;
+                
+        case BIO_C_NWRITE0:
+                /* prepare for non-copying write */
+                ret = (long) bio_nwrite0(bio, ptr);
+                break;
+
+        case BIO_C_NWRITE:
+                /* non-copying write */
+                ret = (long) bio_nwrite(bio, ptr, (size_t) num);
+                break;
+                
 
         /* standard CTRL codes follow */
 
@@ -434,7 +643,7 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
         return ret;
         }
 
-static int bio_puts(BIO *bio, char *str)
+static int bio_puts(BIO *bio, const char *str)
         {
         return bio_write(bio, str, strlen(str));
         }
@@ -458,7 +667,7 @@ static int bio_make_pair(BIO *bio1, BIO *bio2)
         
         if (b1->buf == NULL)
                 {
-                b1->buf = Malloc(b1->size);
+                b1->buf = OPENSSL_malloc(b1->size);
                 if (b1->buf == NULL)
                         {
                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
@@ -470,7 +679,7 @@ static int bio_make_pair(BIO *bio1, BIO *bio2)
         
         if (b2->buf == NULL)
                 {
-                b2->buf = Malloc(b2->size);
+                b2->buf = OPENSSL_malloc(b2->size);
                 if (b2->buf == NULL)
                         {
                         BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
@@ -586,3 +795,78 @@ size_t BIO_ctrl_get_read_request(BIO *bio)
         {
         return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);
         }
+
+int BIO_ctrl_reset_read_request(BIO *bio)
+        {
+        return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0);
+        }
+
+
+/* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now
+ * (conceivably some other BIOs could allow non-copying reads and writes too.)
+ */
+int BIO_nread0(BIO *bio, char **buf)
+        {
+        long ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf);
+        if (ret > INT_MAX)
+                return INT_MAX;
+        else
+                return (int) ret;
+        }
+
+int BIO_nread(BIO *bio, char **buf, int num)
+        {
+        int ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf);
+        if (ret > 0)
+                bio->num_read += ret;
+        return ret;
+        }
+
+int BIO_nwrite0(BIO *bio, char **buf)
+        {
+        long ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf);
+        if (ret > INT_MAX)
+                return INT_MAX;
+        else
+                return (int) ret;
+        }
+
+int BIO_nwrite(BIO *bio, char **buf, int num)
+        {
+        int ret;
+
+        if (!bio->init)
+                {
+                BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED);
+                return -2;
+                }
+
+        ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf);
+        if (ret > 0)
+                bio->num_read += ret;
+        return ret;
+        }
diff --git a/src/lib/libcrypto/bio/bss_conn.c b/src/lib/libcrypto/bio/bss_conn.c
index 6e547bf866..f91ae4c8c6 100644
--- a/src/lib/libcrypto/bio/bss_conn.c
+++ b/src/lib/libcrypto/bio/bss_conn.c
@@ -56,22 +56,26 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef NO_SOCK
+#ifndef OPENSSL_NO_SOCK
 
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
-#include "bio.h"
+#include <openssl/bio.h>
 
-/*      BIOerr(BIO_F_WSASTARTUP,BIO_R_WSASTARTUP ); */
-
-#ifdef WIN16
+#ifdef OPENSSL_SYS_WIN16
 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
 #else
 #define SOCKET_PROTOCOL IPPROTO_TCP
 #endif
 
+#if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
+/* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
+#undef FIONBIO
+#endif
+
+
 typedef struct bio_connect_st
         {
         int state;
@@ -81,52 +85,32 @@ typedef struct bio_connect_st
         int nbio;
 
         unsigned char ip[4];
-        short port;
+        unsigned short port;
 
         struct sockaddr_in them;
 
         /* int socket; this will be kept in bio->num so that it is
-         * compatable with the bss_sock bio */ 
-        int error;
+         * compatible with the bss_sock bio */ 
 
         /* called when the connection is initially made
          *  callback(BIO,state,ret);  The callback should return
-         * 'ret'.  state is for compatablity with the ssl info_callback */
-        int (*info_callback)();
+         * 'ret'.  state is for compatibility with the ssl info_callback */
+        int (*info_callback)(const BIO *bio,int state,int ret);
         } BIO_CONNECT;
 
-#ifndef NOPROTO
-static int conn_write(BIO *h,char *buf,int num);
-static int conn_read(BIO *h,char *buf,int size);
-static int conn_puts(BIO *h,char *str);
-static long conn_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int conn_write(BIO *h, const char *buf, int num);
+static int conn_read(BIO *h, char *buf, int size);
+static int conn_puts(BIO *h, const char *str);
+static long conn_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int conn_new(BIO *h);
 static int conn_free(BIO *data);
-#else
-static int conn_write();
-static int conn_read();
-static int conn_puts();
-static long conn_ctrl();
-static int conn_new();
-static int conn_free();
-#endif
-
-#ifndef NOPROTO
+static long conn_callback_ctrl(BIO *h, int cmd, bio_info_cb *);
 
 static int conn_state(BIO *b, BIO_CONNECT *c);
 static void conn_close_socket(BIO *data);
 BIO_CONNECT *BIO_CONNECT_new(void );
 void BIO_CONNECT_free(BIO_CONNECT *a);
 
-#else
-
-static int conn_state();
-static void conn_close_socket();
-BIO_CONNECT *BIO_CONNECT_new();
-void BIO_CONNECT_free();
-
-#endif
-
 static BIO_METHOD methods_connectp=
         {
         BIO_TYPE_CONNECT,
@@ -138,11 +122,10 @@ static BIO_METHOD methods_connectp=
         conn_ctrl,
         conn_new,
         conn_free,
+        conn_callback_ctrl,
         };
 
-static int conn_state(b,c)
-BIO *b;
-BIO_CONNECT *c;
+static int conn_state(BIO *b, BIO_CONNECT *c)
         {
         int ret= -1,i;
         unsigned long l;
@@ -160,7 +143,7 @@ BIO_CONNECT *c;
                         p=c->param_hostname;
                         if (p == NULL)
                                 {
-                                BIOerr(BIO_F_CONN_STATE,BIO_R_NO_HOSTHNAME_SPECIFIED);
+                                BIOerr(BIO_F_CONN_STATE,BIO_R_NO_HOSTNAME_SPECIFIED);
                                 goto exit_loop;
                                 }
                         for ( ; *p != '\0'; p++)
@@ -182,12 +165,12 @@ BIO_CONNECT *c;
                                                         break;
                                                         }
                                         if (c->param_port != NULL)
-                                                Free(c->param_port);
+                                                OPENSSL_free(c->param_port);
                                         c->param_port=BUF_strdup(p);
                                         }
                                 }
 
-                        if (p == NULL)
+                        if (c->param_port == NULL)
                                 {
                                 BIOerr(BIO_F_CONN_STATE,BIO_R_NO_PORT_SPECIFIED);
                                 ERR_add_error_data(2,"host=",c->param_hostname);
@@ -203,7 +186,12 @@ BIO_CONNECT *c;
                         break;
 
                 case BIO_CONN_S_GET_PORT:
-                        if (BIO_get_port(c->param_port,&c->port) <= 0)
+                        if (c->param_port == NULL)
+                                {
+                                /* abort(); */
+                                goto exit_loop;
+                                }
+                        else if (BIO_get_port(c->param_port,&c->port) <= 0)
                                 goto exit_loop;
                         c->state=BIO_CONN_S_CREATE_SOCKET;
                         break;
@@ -235,12 +223,9 @@ BIO_CONNECT *c;
                         break;
 
                 case BIO_CONN_S_NBIO:
-#ifdef FIONBIO
                         if (c->nbio)
                                 {
-                                l=1;
-                                ret=BIO_socket_ioctl(b->num,FIONBIO,&l);
-                                if (ret < 0)
+                                if (!BIO_socket_nbio(b->num,1))
                                         {
                                         BIOerr(BIO_F_CONN_STATE,BIO_R_ERROR_SETTING_NBIO);
                                         ERR_add_error_data(4,"host=",
@@ -249,10 +234,9 @@ BIO_CONNECT *c;
                                         goto exit_loop;
                                         }
                                 }
-#endif
                         c->state=BIO_CONN_S_CONNECT;
 
-#ifdef SO_KEEPALIVE
+#if defined(SO_KEEPALIVE) && !defined(OPENSSL_SYS_MPE)
                         i=1;
                         i=setsockopt(b->num,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
                         if (i < 0)
@@ -315,7 +299,7 @@ BIO_CONNECT *c;
                         ret=1;
                         goto exit_loop;
                 default:
-                        abort();
+                        /* abort(); */
                         goto exit_loop;
                         }
 
@@ -326,21 +310,19 @@ BIO_CONNECT *c;
                         }
                 }
 
-        if (1)
-                {
+        /* Loop does not exit */
 exit_loop:
-                if (cb != NULL)
-                        ret=cb((BIO *)b,c->state,ret);
-                }
+        if (cb != NULL)
+                ret=cb((BIO *)b,c->state,ret);
 end:
         return(ret);
         }
 
-BIO_CONNECT *BIO_CONNECT_new()
+BIO_CONNECT *BIO_CONNECT_new(void)
         {
         BIO_CONNECT *ret;
 
-        if ((ret=(BIO_CONNECT *)Malloc(sizeof(BIO_CONNECT))) == NULL)
+        if ((ret=(BIO_CONNECT *)OPENSSL_malloc(sizeof(BIO_CONNECT))) == NULL)
                 return(NULL);
         ret->state=BIO_CONN_S_BEFORE;
         ret->param_hostname=NULL;
@@ -353,27 +335,27 @@ BIO_CONNECT *BIO_CONNECT_new()
         ret->ip[3]=0;
         ret->port=0;
         memset((char *)&ret->them,0,sizeof(ret->them));
-        ret->error=0;
         return(ret);
         }
 
-void BIO_CONNECT_free(a)
-BIO_CONNECT *a;
+void BIO_CONNECT_free(BIO_CONNECT *a)
         {
+        if(a == NULL)
+            return;
+
         if (a->param_hostname != NULL)
-                Free(a->param_hostname);
+                OPENSSL_free(a->param_hostname);
         if (a->param_port != NULL)
-                Free(a->param_port);
-        Free(a);
+                OPENSSL_free(a->param_port);
+        OPENSSL_free(a);
         }
 
-BIO_METHOD *BIO_s_connect()
+BIO_METHOD *BIO_s_connect(void)
         {
         return(&methods_connectp);
         }
 
-static int conn_new(bi)
-BIO *bi;
+static int conn_new(BIO *bi)
         {
         bi->init=0;
         bi->num=INVALID_SOCKET;
@@ -384,8 +366,7 @@ BIO *bi;
                 return(1);
         }
 
-static void conn_close_socket(bio)
-BIO *bio;
+static void conn_close_socket(BIO *bio)
         {
         BIO_CONNECT *c;
 
@@ -395,17 +376,12 @@ BIO *bio;
                 /* Only do a shutdown if things were established */
                 if (c->state == BIO_CONN_S_OK)
                         shutdown(bio->num,2);
-# ifdef WINDOWS
                 closesocket(bio->num);
-# else
-                close(bio->num);
-# endif
                 bio->num=INVALID_SOCKET;
                 }
         }
 
-static int conn_free(a)
-BIO *a;
+static int conn_free(BIO *a)
         {
         BIO_CONNECT *data;
 
@@ -423,10 +399,7 @@ BIO *a;
         return(1);
         }
         
-static int conn_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int conn_read(BIO *b, char *out, int outl)
         {
         int ret=0;
         BIO_CONNECT *data;
@@ -442,11 +415,7 @@ int outl;
         if (out != NULL)
                 {
                 clear_socket_error();
-#if defined(WINDOWS)
-                ret=recv(b->num,out,outl,0);
-#else
-                ret=read(b->num,out,outl);
-#endif
+                ret=readsocket(b->num,out,outl);
                 BIO_clear_retry_flags(b);
                 if (ret <= 0)
                         {
@@ -457,10 +426,7 @@ int outl;
         return(ret);
         }
 
-static int conn_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int conn_write(BIO *b, const char *in, int inl)
         {
         int ret;
         BIO_CONNECT *data;
@@ -473,11 +439,7 @@ int inl;
                 }
 
         clear_socket_error();
-#if defined(WINDOWS)
-        ret=send(b->num,in,inl,0);
-#else
-        ret=write(b->num,in,inl);
-#endif
+        ret=writesocket(b->num,in,inl);
         BIO_clear_retry_flags(b);
         if (ret <= 0)
                 {
@@ -487,15 +449,11 @@ int inl;
         return(ret);
         }
 
-static long conn_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         BIO *dbio;
         int *ip;
-        char **pptr;
+        const char **pptr;
         long ret=1;
         BIO_CONNECT *data;
 
@@ -519,7 +477,7 @@ char *ptr;
         case BIO_C_GET_CONNECT:
                 if (ptr != NULL)
                         {
-                        pptr=(char **)ptr;
+                        pptr=(const char **)ptr;
                         if (num == 0)
                                 {
                                 *pptr=data->param_hostname;
@@ -538,7 +496,7 @@ char *ptr;
                                 *((int *)ptr)=data->port;
                                 }
                         if ((!b->init) || (ptr == NULL))
-                                *pptr="not initalised";
+                                *pptr="not initialized";
                         ret=1;
                         }
                 break;
@@ -549,19 +507,37 @@ char *ptr;
                         if (num == 0)
                                 {
                                 if (data->param_hostname != NULL)
-                                        Free(data->param_hostname);
+                                        OPENSSL_free(data->param_hostname);
                                 data->param_hostname=BUF_strdup(ptr);
                                 }
                         else if (num == 1)
                                 {
                                 if (data->param_port != NULL)
-                                        Free(data->param_port);
+                                        OPENSSL_free(data->param_port);
                                 data->param_port=BUF_strdup(ptr);
                                 }
                         else if (num == 2)
-                                memcpy(data->ip,ptr,4);
+                                {
+                                char buf[16];
+                                char *p = ptr;
+
+                                sprintf(buf,"%d.%d.%d.%d",
+                                        p[0],p[1],p[2],p[3]);
+                                if (data->param_hostname != NULL)
+                                        OPENSSL_free(data->param_hostname);
+                                data->param_hostname=BUF_strdup(buf);
+                                memcpy(&(data->ip[0]),ptr,4);
+                                }
                         else if (num == 3)
+                                {
+                                char buf[16];
+
+                                sprintf(buf,"%d",*(int *)ptr);
+                                if (data->param_port != NULL)
+                                        OPENSSL_free(data->param_port);
+                                data->param_port=BUF_strdup(buf);
                                 data->port= *(int *)ptr;
+                                }
                         }
                 break;
         case BIO_C_SET_NBIO:
@@ -591,16 +567,26 @@ char *ptr;
         case BIO_CTRL_FLUSH:
                 break;
         case BIO_CTRL_DUP:
+                {
                 dbio=(BIO *)ptr;
                 if (data->param_port)
                         BIO_set_conn_port(dbio,data->param_port);
                 if (data->param_hostname)
                         BIO_set_conn_hostname(dbio,data->param_hostname);
                 BIO_set_nbio(dbio,data->nbio);
-                BIO_set_info_callback(dbio,data->info_callback);
+                /* FIXME: the cast of the function seems unlikely to be a good idea */
+                (void)BIO_set_info_callback(dbio,(bio_info_cb *)data->info_callback);
+                }
                 break;
         case BIO_CTRL_SET_CALLBACK:
-                data->info_callback=(int (*)())ptr;
+                {
+#if 0 /* FIXME: Should this be used?  -- Richard Levitte */
+                BIOerr(BIO_F_CONN_CTRL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+                ret = -1;
+#else
+                ret=0;
+#endif
+                }
                 break;
         case BIO_CTRL_GET_CALLBACK:
                 {
@@ -617,9 +603,28 @@ char *ptr;
         return(ret);
         }
 
-static int conn_puts(bp,str)
-BIO *bp;
-char *str;
+static long conn_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
+        {
+        long ret=1;
+        BIO_CONNECT *data;
+
+        data=(BIO_CONNECT *)b->ptr;
+
+        switch (cmd)
+                {
+        case BIO_CTRL_SET_CALLBACK:
+                {
+                data->info_callback=(int (*)(const struct bio_st *, int, int))fp;
+                }
+                break;
+        default:
+                ret=0;
+                break;
+                }
+        return(ret);
+        }
+
+static int conn_puts(BIO *bp, const char *str)
         {
         int n,ret;
 
@@ -628,8 +633,7 @@ char *str;
         return(ret);
         }
 
-BIO *BIO_new_connect(str)
-char *str;
+BIO *BIO_new_connect(char *str)
         {
         BIO *ret;
 
diff --git a/src/lib/libcrypto/bio/bss_fd.c b/src/lib/libcrypto/bio/bss_fd.c
index 686c4909a2..5e3e187de6 100644
--- a/src/lib/libcrypto/bio/bss_fd.c
+++ b/src/lib/libcrypto/bio/bss_fd.c
@@ -56,7 +56,227 @@
  * [including the GNU Public Licence.]
  */
 
-#define BIO_FD
-#include "bss_sock.c"
-#undef BIO_FD
+#include <stdio.h>
+#include <errno.h>
+#define USE_SOCKETS
+#include "cryptlib.h"
+#include <openssl/bio.h>
 
+static int fd_write(BIO *h, const char *buf, int num);
+static int fd_read(BIO *h, char *buf, int size);
+static int fd_puts(BIO *h, const char *str);
+static long fd_ctrl(BIO *h, int cmd, long arg1, void *arg2);
+static int fd_new(BIO *h);
+static int fd_free(BIO *data);
+int BIO_fd_should_retry(int s);
+
+static BIO_METHOD methods_fdp=
+        {
+        BIO_TYPE_FD,"file descriptor",
+        fd_write,
+        fd_read,
+        fd_puts,
+        NULL, /* fd_gets, */
+        fd_ctrl,
+        fd_new,
+        fd_free,
+        NULL,
+        };
+
+BIO_METHOD *BIO_s_fd(void)
+        {
+        return(&methods_fdp);
+        }
+
+BIO *BIO_new_fd(int fd,int close_flag)
+        {
+        BIO *ret;
+        ret=BIO_new(BIO_s_fd());
+        if (ret == NULL) return(NULL);
+        BIO_set_fd(ret,fd,close_flag);
+        return(ret);
+        }
+
+static int fd_new(BIO *bi)
+        {
+        bi->init=0;
+        bi->num=0;
+        bi->ptr=NULL;
+        bi->flags=0;
+        return(1);
+        }
+
+static int fd_free(BIO *a)
+        {
+        if (a == NULL) return(0);
+        if (a->shutdown)
+                {
+                if (a->init)
+                        {
+                        close(a->num);
+                        }
+                a->init=0;
+                a->flags=0;
+                }
+        return(1);
+        }
+        
+static int fd_read(BIO *b, char *out,int outl)
+        {
+        int ret=0;
+
+        if (out != NULL)
+                {
+                clear_sys_error();
+                ret=read(b->num,out,outl);
+                BIO_clear_retry_flags(b);
+                if (ret <= 0)
+                        {
+                        if (BIO_fd_should_retry(ret))
+                                BIO_set_retry_read(b);
+                        }
+                }
+        return(ret);
+        }
+
+static int fd_write(BIO *b, const char *in, int inl)
+        {
+        int ret;
+        clear_sys_error();
+        ret=write(b->num,in,inl);
+        BIO_clear_retry_flags(b);
+        if (ret <= 0)
+                {
+                if (BIO_fd_should_retry(ret))
+                        BIO_set_retry_write(b);
+                }
+        return(ret);
+        }
+
+static long fd_ctrl(BIO *b, int cmd, long num, void *ptr)
+        {
+        long ret=1;
+        int *ip;
+
+        switch (cmd)
+                {
+        case BIO_CTRL_RESET:
+                num=0;
+        case BIO_C_FILE_SEEK:
+                ret=(long)lseek(b->num,num,0);
+                break;
+        case BIO_C_FILE_TELL:
+        case BIO_CTRL_INFO:
+                ret=(long)lseek(b->num,0,1);
+                break;
+        case BIO_C_SET_FD:
+                fd_free(b);
+                b->num= *((int *)ptr);
+                b->shutdown=(int)num;
+                b->init=1;
+                break;
+        case BIO_C_GET_FD:
+                if (b->init)
+                        {
+                        ip=(int *)ptr;
+                        if (ip != NULL) *ip=b->num;
+                        ret=b->num;
+                        }
+                else
+                        ret= -1;
+                break;
+        case BIO_CTRL_GET_CLOSE:
+                ret=b->shutdown;
+                break;
+        case BIO_CTRL_SET_CLOSE:
+                b->shutdown=(int)num;
+                break;
+        case BIO_CTRL_PENDING:
+        case BIO_CTRL_WPENDING:
+                ret=0;
+                break;
+        case BIO_CTRL_DUP:
+        case BIO_CTRL_FLUSH:
+                ret=1;
+                break;
+        default:
+                ret=0;
+                break;
+                }
+        return(ret);
+        }
+
+static int fd_puts(BIO *bp, const char *str)
+        {
+        int n,ret;
+
+        n=strlen(str);
+        ret=fd_write(bp,str,n);
+        return(ret);
+        }
+
+int BIO_fd_should_retry(int i)
+        {
+        int err;
+
+        if ((i == 0) || (i == -1))
+                {
+                err=get_last_sys_error();
+
+#if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */
+                if ((i == -1) && (err == 0))
+                        return(1);
+#endif
+
+                return(BIO_fd_non_fatal_error(err));
+                }
+        return(0);
+        }
+
+int BIO_fd_non_fatal_error(int err)
+        {
+        switch (err)
+                {
+
+#ifdef EWOULDBLOCK
+# ifdef WSAEWOULDBLOCK
+#  if WSAEWOULDBLOCK != EWOULDBLOCK
+        case EWOULDBLOCK:
+#  endif
+# else
+        case EWOULDBLOCK:
+# endif
+#endif
+
+#if defined(ENOTCONN)
+        case ENOTCONN:
+#endif
+
+#ifdef EINTR
+        case EINTR:
+#endif
+
+#ifdef EAGAIN
+#if EWOULDBLOCK != EAGAIN
+        case EAGAIN:
+# endif
+#endif
+
+#ifdef EPROTO
+        case EPROTO:
+#endif
+
+#ifdef EINPROGRESS
+        case EINPROGRESS:
+#endif
+
+#ifdef EALREADY
+        case EALREADY:
+#endif
+                return(1);
+                /* break; */
+        default:
+                break;
+                }
+        return(0);
+        }
diff --git a/src/lib/libcrypto/bio/bss_file.c b/src/lib/libcrypto/bio/bss_file.c
index 1484cf849e..8b3ff278d9 100644
--- a/src/lib/libcrypto/bio/bss_file.c
+++ b/src/lib/libcrypto/bio/bss_file.c
@@ -68,29 +68,18 @@
 #include <stdio.h>
 #include <errno.h>
 #include "cryptlib.h"
-#include "bio.h"
-#include "err.h"
+#include <openssl/bio.h>
+#include <openssl/err.h>
 
-#if !defined(NO_STDIO)
+#if !defined(OPENSSL_NO_STDIO)
 
-#ifndef NOPROTO
-static int MS_CALLBACK file_write(BIO *h,char *buf,int num);
-static int MS_CALLBACK file_read(BIO *h,char *buf,int size);
-static int MS_CALLBACK file_puts(BIO *h,char *str);
-static int MS_CALLBACK file_gets(BIO *h,char *str,int size);
-static long MS_CALLBACK file_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int MS_CALLBACK file_write(BIO *h, const char *buf, int num);
+static int MS_CALLBACK file_read(BIO *h, char *buf, int size);
+static int MS_CALLBACK file_puts(BIO *h, const char *str);
+static int MS_CALLBACK file_gets(BIO *h, char *str, int size);
+static long MS_CALLBACK file_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int MS_CALLBACK file_new(BIO *h);
 static int MS_CALLBACK file_free(BIO *data);
-#else
-static int MS_CALLBACK file_write();
-static int MS_CALLBACK file_read();
-static int MS_CALLBACK file_puts();
-static int MS_CALLBACK file_gets();
-static long MS_CALLBACK file_ctrl();
-static int MS_CALLBACK file_new();
-static int MS_CALLBACK file_free();
-#endif
-
 static BIO_METHOD methods_filep=
         {
         BIO_TYPE_FILE,
@@ -102,11 +91,10 @@ static BIO_METHOD methods_filep=
         file_ctrl,
         file_new,
         file_free,
+        NULL,
         };
 
-BIO *BIO_new_file(filename,mode)
-char *filename;
-char *mode;
+BIO *BIO_new_file(const char *filename, const char *mode)
         {
         BIO *ret;
         FILE *file;
@@ -115,7 +103,10 @@ char *mode;
                 {
                 SYSerr(SYS_F_FOPEN,get_last_sys_error());
                 ERR_add_error_data(5,"fopen('",filename,"','",mode,"')");
-                BIOerr(BIO_F_BIO_NEW_FILE,ERR_R_SYS_LIB);
+                if (errno == ENOENT)
+                        BIOerr(BIO_F_BIO_NEW_FILE,BIO_R_NO_SUCH_FILE);
+                else
+                        BIOerr(BIO_F_BIO_NEW_FILE,ERR_R_SYS_LIB);
                 return(NULL);
                 }
         if ((ret=BIO_new(BIO_s_file_internal())) == NULL)
@@ -125,9 +116,7 @@ char *mode;
         return(ret);
         }
 
-BIO *BIO_new_fp(stream,close_flag)
-FILE *stream;
-int close_flag;
+BIO *BIO_new_fp(FILE *stream, int close_flag)
         {
         BIO *ret;
 
@@ -138,13 +127,12 @@ int close_flag;
         return(ret);
         }
 
-BIO_METHOD *BIO_s_file()
+BIO_METHOD *BIO_s_file(void)
         {
         return(&methods_filep);
         }
 
-static int MS_CALLBACK file_new(bi)
-BIO *bi;
+static int MS_CALLBACK file_new(BIO *bi)
         {
         bi->init=0;
         bi->num=0;
@@ -152,8 +140,7 @@ BIO *bi;
         return(1);
         }
 
-static int MS_CALLBACK file_free(a)
-BIO *a;
+static int MS_CALLBACK file_free(BIO *a)
         {
         if (a == NULL) return(0);
         if (a->shutdown)
@@ -168,10 +155,7 @@ BIO *a;
         return(1);
         }
         
-static int MS_CALLBACK file_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int MS_CALLBACK file_read(BIO *b, char *out, int outl)
         {
         int ret=0;
 
@@ -182,10 +166,7 @@ int outl;
         return(ret);
         }
 
-static int MS_CALLBACK file_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int MS_CALLBACK file_write(BIO *b, const char *in, int inl)
         {
         int ret=0;
 
@@ -194,18 +175,14 @@ int inl;
                 if (fwrite(in,(int)inl,1,(FILE *)b->ptr))
                         ret=inl;
                 /* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */
-                /* acording to Tim Hudson <tjh@cryptsoft.com>, the commented
+                /* according to Tim Hudson <tjh@cryptsoft.com>, the commented
                  * out version above can cause 'inl' write calls under
                  * some stupid stdio implementations (VMS) */
                 }
         return(ret);
         }
 
-static long MS_CALLBACK file_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         long ret=1;
         FILE *fp=(FILE *)b->ptr;
@@ -214,26 +191,33 @@ char *ptr;
 
         switch (cmd)
                 {
+        case BIO_C_FILE_SEEK:
         case BIO_CTRL_RESET:
                 ret=(long)fseek(fp,num,0);
                 break;
         case BIO_CTRL_EOF:
                 ret=(long)feof(fp);
                 break;
+        case BIO_C_FILE_TELL:
         case BIO_CTRL_INFO:
                 ret=ftell(fp);
                 break;
         case BIO_C_SET_FILE_PTR:
                 file_free(b);
-                b->shutdown=(int)num;
+                b->shutdown=(int)num&BIO_CLOSE;
                 b->ptr=(char *)ptr;
                 b->init=1;
-#if defined(MSDOS) || defined(WINDOWS)
+#if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS)
                 /* Set correct text/binary mode */
                 if (num & BIO_FP_TEXT)
                         _setmode(fileno((FILE *)ptr),_O_TEXT);
                 else
                         _setmode(fileno((FILE *)ptr),_O_BINARY);
+#elif defined(OPENSSL_SYS_OS2)
+                if (num & BIO_FP_TEXT)
+                        setmode(fileno((FILE *)ptr), O_TEXT);
+                else
+                        setmode(fileno((FILE *)ptr), O_BINARY);
 #endif
                 break;
         case BIO_C_SET_FILENAME:
@@ -257,7 +241,7 @@ char *ptr;
                         ret=0;
                         break;
                         }
-#if defined(MSDOS) || defined(WINDOWS)
+#if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS)
                 if (!(num & BIO_FP_TEXT))
                         strcat(p,"b");
                 else
@@ -307,10 +291,7 @@ char *ptr;
         return(ret);
         }
 
-static int MS_CALLBACK file_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int MS_CALLBACK file_gets(BIO *bp, char *buf, int size)
         {
         int ret=0;
 
@@ -321,9 +302,7 @@ int size;
         return(ret);
         }
 
-static int MS_CALLBACK file_puts(bp,str)
-BIO *bp;
-char *str;
+static int MS_CALLBACK file_puts(BIO *bp, const char *str)
         {
         int n,ret;
 
@@ -332,7 +311,7 @@ char *str;
         return(ret);
         }
 
-#endif /* NO_STDIO */
+#endif /* OPENSSL_NO_STDIO */
 
 #endif /* HEADER_BSS_FILE_C */
 
diff --git a/src/lib/libcrypto/bio/bss_log.c b/src/lib/libcrypto/bio/bss_log.c
index db82e757e7..a39d95297c 100644
--- a/src/lib/libcrypto/bio/bss_log.c
+++ b/src/lib/libcrypto/bio/bss_log.c
@@ -57,8 +57,8 @@
         Why BIO_s_log?
 
         BIO_s_log is useful for system daemons (or services under NT).
-        It is one-way BIO, it sends all stuff to syslogd (or event log
-        under NT).
+        It is one-way BIO, it sends all stuff to syslogd (on system that
+        commonly use that), or event log (on NT), or OPCOM (on OpenVMS).
 
 */
 
@@ -66,27 +66,71 @@
 #include <stdio.h>
 #include <errno.h>
 
-#ifndef WIN32
-#ifdef __ultrix
-#include <sys/syslog.h>
-#else
-#include <syslog.h>
-#endif
+#include "cryptlib.h"
+
+#if defined(OPENSSL_SYS_WIN32)
+#  include <process.h>
+#elif defined(OPENSSL_SYS_VMS)
+#  include <opcdef.h>
+#  include <descrip.h>
+#  include <lib$routines.h>
+#  include <starlet.h>
+#elif defined(__ultrix)
+#  include <sys/syslog.h>
+#elif !defined(MSDOS) && !defined(OPENSSL_SYS_VXWORKS) && !defined(NO_SYSLOG) /* Unix */
+#  include <syslog.h>
 #endif
 
-#include "cryptlib.h"
 #include <openssl/buffer.h>
 #include <openssl/err.h>
+
 #ifndef NO_SYSLOG
 
+#if defined(OPENSSL_SYS_WIN32)
+#define LOG_EMERG       0
+#define LOG_ALERT       1
+#define LOG_CRIT        2
+#define LOG_ERR         3
+#define LOG_WARNING     4
+#define LOG_NOTICE      5
+#define LOG_INFO        6
+#define LOG_DEBUG       7
 
-static int MS_CALLBACK slg_write(BIO *h,char *buf,int num);
-static int MS_CALLBACK slg_puts(BIO *h,char *str);
-static long MS_CALLBACK slg_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+#define LOG_DAEMON      (3<<3)
+#elif defined(OPENSSL_SYS_VMS)
+/* On VMS, we don't really care about these, but we need them to compile */
+#define LOG_EMERG       0
+#define LOG_ALERT       1
+#define LOG_CRIT        2
+#define LOG_ERR         3
+#define LOG_WARNING     4
+#define LOG_NOTICE      5
+#define LOG_INFO        6
+#define LOG_DEBUG       7
+
+#define LOG_DAEMON      OPC$M_NM_NTWORK
+#endif
+
+static int MS_CALLBACK slg_write(BIO *h, const char *buf, int num);
+static int MS_CALLBACK slg_puts(BIO *h, const char *str);
+static long MS_CALLBACK slg_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int MS_CALLBACK slg_new(BIO *h);
 static int MS_CALLBACK slg_free(BIO *data);
-static int xopenlog(BIO* bp, const char* name, int level);
-static int xcloselog(BIO* bp);
+static void xopenlog(BIO* bp, char* name, int level);
+static void xsyslog(BIO* bp, int priority, const char* string);
+static void xcloselog(BIO* bp);
+#ifdef OPENSSL_SYS_WIN32
+LONG    (WINAPI *go_for_advapi)()       = RegOpenKeyEx;
+HANDLE  (WINAPI *register_event_source)()       = NULL;
+BOOL    (WINAPI *deregister_event_source)()     = NULL;
+BOOL    (WINAPI *report_event)()        = NULL;
+#define DL_PROC(m,f)    (GetProcAddress( m, f ))
+#ifdef UNICODE
+#define DL_PROC_X(m,f) DL_PROC( m, f "W" )
+#else
+#define DL_PROC_X(m,f) DL_PROC( m, f "A" )
+#endif
+#endif
 
 static BIO_METHOD methods_slg=
         {
@@ -98,6 +142,7 @@ static BIO_METHOD methods_slg=
         slg_ctrl,
         slg_new,
         slg_free,
+        NULL,
         };
 
 BIO_METHOD *BIO_s_log(void)
@@ -110,11 +155,7 @@ static int MS_CALLBACK slg_new(BIO *bi)
         bi->init=1;
         bi->num=0;
         bi->ptr=NULL;
-#ifndef WIN32
         xopenlog(bi, "application", LOG_DAEMON);
-#else
-        xopenlog(bi, "application", 0);
-#endif
         return(1);
         }
 
@@ -125,64 +166,60 @@ static int MS_CALLBACK slg_free(BIO *a)
         return(1);
         }
         
-static int MS_CALLBACK slg_write(BIO *b, char *in, int inl)
+static int MS_CALLBACK slg_write(BIO *b, const char *in, int inl)
         {
         int ret= inl;
-        char* buf= in;
+        char* buf;
         char* pp;
-#if defined(WIN32)
-        LPTSTR lpszStrings[1];
-        WORD evtype= EVENTLOG_ERROR_TYPE;
-#else
-        int priority;
-#endif
+        int priority, i;
+        static struct
+                {
+                int strl;
+                char str[10];
+                int log_level;
+                }
+        mapping[] =
+                {
+                { 6, "PANIC ", LOG_EMERG },
+                { 6, "EMERG ", LOG_EMERG },
+                { 4, "EMR ", LOG_EMERG },
+                { 6, "ALERT ", LOG_ALERT },
+                { 4, "ALR ", LOG_ALERT },
+                { 5, "CRIT ", LOG_CRIT },
+                { 4, "CRI ", LOG_CRIT },
+                { 6, "ERROR ", LOG_ERR },
+                { 4, "ERR ", LOG_ERR },
+                { 8, "WARNING ", LOG_WARNING },
+                { 5, "WARN ", LOG_WARNING },
+                { 4, "WAR ", LOG_WARNING },
+                { 7, "NOTICE ", LOG_NOTICE },
+                { 5, "NOTE ", LOG_NOTICE },
+                { 4, "NOT ", LOG_NOTICE },
+                { 5, "INFO ", LOG_INFO },
+                { 4, "INF ", LOG_INFO },
+                { 6, "DEBUG ", LOG_DEBUG },
+                { 4, "DBG ", LOG_DEBUG },
+                { 0, "", LOG_ERR } /* The default */
+                };
 
-        if((buf= (char *)Malloc(inl+ 1)) == NULL){
+        if((buf= (char *)OPENSSL_malloc(inl+ 1)) == NULL){
                 return(0);
         }
         strncpy(buf, in, inl);
         buf[inl]= '\0';
-#if defined(WIN32)
-        if(strncmp(buf, "ERR ", 4) == 0){
-                evtype= EVENTLOG_ERROR_TYPE;
-                pp= buf+ 4;
-        }else if(strncmp(buf, "WAR ", 4) == 0){
-                evtype= EVENTLOG_WARNING_TYPE;
-                pp= buf+ 4;
-        }else if(strncmp(buf, "INF ", 4) == 0){
-                evtype= EVENTLOG_INFORMATION_TYPE;
-                pp= buf+ 4;
-        }else{
-                evtype= EVENTLOG_ERROR_TYPE;
-                pp= buf;
-        }
-        lpszStrings[0]= pp;
 
-        if(b->ptr)
-                ReportEvent(b->ptr, evtype, 0, 1024, NULL, 1, 0,
-                                lpszStrings, NULL);
-#else
-        if(strncmp(buf, "ERR ", 4) == 0){
-                priority= LOG_ERR;
-                pp= buf+ 4;
-        }else if(strncmp(buf, "WAR ", 4) == 0){
-                priority= LOG_WARNING;
-                pp= buf+ 4;
-        }else if(strncmp(buf, "INF ", 4) == 0){
-                priority= LOG_INFO;
-                pp= buf+ 4;
-        }else{
-                priority= LOG_ERR;
-                pp= buf;
-        }
+        i = 0;
+        while(strncmp(buf, mapping[i].str, mapping[i].strl) != 0) i++;
+        priority = mapping[i].log_level;
+        pp = buf + mapping[i].strl;
 
-        syslog(priority, "%s", pp);
-#endif
-        Free(buf);
+        xsyslog(b, priority, pp);
+
+        OPENSSL_free(buf);
         return(ret);
         }
 
-static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, char *ptr)
+static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         switch (cmd)
                 {
@@ -196,7 +233,7 @@ static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, char *ptr)
         return(0);
         }
 
-static int MS_CALLBACK slg_puts(BIO *bp, char *str)
+static int MS_CALLBACK slg_puts(BIO *bp, const char *str)
         {
         int n,ret;
 
@@ -205,28 +242,154 @@ static int MS_CALLBACK slg_puts(BIO *bp, char *str)
         return(ret);
         }
 
-static int xopenlog(BIO* bp, const char* name, int level)
+#if defined(OPENSSL_SYS_WIN32)
+
+static void xopenlog(BIO* bp, char* name, int level)
 {
-#if defined(WIN32)
-        if((bp->ptr= (char *)RegisterEventSource(NULL, name)) == NULL){
-                return(0);
-        }
-#else
-        openlog(name, LOG_PID|LOG_CONS, level);
-#endif
-        return(1);
+        if ( !register_event_source )
+                {
+                HANDLE  advapi;
+                if ( !(advapi = GetModuleHandle("advapi32")) )
+                        return;
+                register_event_source = (HANDLE (WINAPI *)())DL_PROC_X(advapi,
+                        "RegisterEventSource" );
+                deregister_event_source = (BOOL (WINAPI *)())DL_PROC(advapi,
+                        "DeregisterEventSource");
+                report_event = (BOOL (WINAPI *)())DL_PROC_X(advapi,
+                        "ReportEvent" );
+                if ( !(register_event_source && deregister_event_source &&
+                                report_event) )
+                        {
+                        register_event_source = NULL;
+                        deregister_event_source = NULL;
+                        report_event = NULL;
+                        return;
+                        }
+                }
+        bp->ptr= (char *)register_event_source(NULL, name);
 }
 
-static int xcloselog(BIO* bp)
+static void xsyslog(BIO *bp, int priority, const char *string)
+{
+        LPCSTR lpszStrings[2];
+        WORD evtype= EVENTLOG_ERROR_TYPE;
+        int pid = _getpid();
+        char pidbuf[20];
+
+        switch (priority)
+                {
+        case LOG_EMERG:
+        case LOG_ALERT:
+        case LOG_CRIT:
+        case LOG_ERR:
+                evtype = EVENTLOG_ERROR_TYPE;
+                break;
+        case LOG_WARNING:
+                evtype = EVENTLOG_WARNING_TYPE;
+                break;
+        case LOG_NOTICE:
+        case LOG_INFO:
+        case LOG_DEBUG:
+                evtype = EVENTLOG_INFORMATION_TYPE;
+                break;
+        default:                /* Should never happen, but set it
+                                   as error anyway. */
+                evtype = EVENTLOG_ERROR_TYPE;
+                break;
+                }
+
+        sprintf(pidbuf, "[%d] ", pid);
+        lpszStrings[0] = pidbuf;
+        lpszStrings[1] = string;
+
+        if(report_event && bp->ptr)
+                report_event(bp->ptr, evtype, 0, 1024, NULL, 2, 0,
+                                lpszStrings, NULL);
+}
+        
+static void xcloselog(BIO* bp)
 {
-#if defined(WIN32)
-        if(bp->ptr)
-                DeregisterEventSource((HANDLE)(bp->ptr));
+        if(deregister_event_source && bp->ptr)
+                deregister_event_source((HANDLE)(bp->ptr));
         bp->ptr= NULL;
-#else
+}
+
+#elif defined(OPENSSL_SYS_VMS)
+
+static int VMS_OPC_target = LOG_DAEMON;
+
+static void xopenlog(BIO* bp, char* name, int level)
+{
+        VMS_OPC_target = level; 
+}
+
+static void xsyslog(BIO *bp, int priority, const char *string)
+{
+        struct dsc$descriptor_s opc_dsc;
+        struct opcdef *opcdef_p;
+        char buf[10240];
+        unsigned int len;
+        struct dsc$descriptor_s buf_dsc;
+        $DESCRIPTOR(fao_cmd, "!AZ: !AZ");
+        char *priority_tag;
+
+        switch (priority)
+          {
+          case LOG_EMERG: priority_tag = "Emergency"; break;
+          case LOG_ALERT: priority_tag = "Alert"; break;
+          case LOG_CRIT: priority_tag = "Critical"; break;
+          case LOG_ERR: priority_tag = "Error"; break;
+          case LOG_WARNING: priority_tag = "Warning"; break;
+          case LOG_NOTICE: priority_tag = "Notice"; break;
+          case LOG_INFO: priority_tag = "Info"; break;
+          case LOG_DEBUG: priority_tag = "DEBUG"; break;
+          }
+
+        buf_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
+        buf_dsc.dsc$b_class = DSC$K_CLASS_S;
+        buf_dsc.dsc$a_pointer = buf;
+        buf_dsc.dsc$w_length = sizeof(buf) - 1;
+
+        lib$sys_fao(&fao_cmd, &len, &buf_dsc, priority_tag, string);
+
+        /* we know there's an 8 byte header.  That's documented */
+        opcdef_p = (struct opcdef *) OPENSSL_malloc(8 + len);
+        opcdef_p->opc$b_ms_type = OPC$_RQ_RQST;
+        memcpy(opcdef_p->opc$z_ms_target_classes, &VMS_OPC_target, 3);
+        opcdef_p->opc$l_ms_rqstid = 0;
+        memcpy(&opcdef_p->opc$l_ms_text, buf, len);
+
+        opc_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
+        opc_dsc.dsc$b_class = DSC$K_CLASS_S;
+        opc_dsc.dsc$a_pointer = (char *)opcdef_p;
+        opc_dsc.dsc$w_length = len + 8;
+
+        sys$sndopr(opc_dsc, 0);
+
+        OPENSSL_free(opcdef_p);
+}
+
+static void xcloselog(BIO* bp)
+{
+}
+
+#else /* Unix */
+
+static void xopenlog(BIO* bp, char* name, int level)
+{
+        openlog(name, LOG_PID|LOG_CONS, level);
+}
+
+static void xsyslog(BIO *bp, int priority, const char *string)
+{
+        syslog(priority, "%s", string);
+}
+
+static void xcloselog(BIO* bp)
+{
         closelog();
-#endif
-        return(1);
 }
 
-#endif
+#endif /* Unix */
+
+#endif /* NO_SYSLOG */
diff --git a/src/lib/libcrypto/bio/bss_mem.c b/src/lib/libcrypto/bio/bss_mem.c
index 40c4e39f02..28ff7582bf 100644
--- a/src/lib/libcrypto/bio/bss_mem.c
+++ b/src/lib/libcrypto/bio/bss_mem.c
@@ -59,26 +59,15 @@
 #include <stdio.h>
 #include <errno.h>
 #include "cryptlib.h"
-#include "bio.h"
+#include <openssl/bio.h>
 
-#ifndef NOPROTO
-static int mem_write(BIO *h,char *buf,int num);
-static int mem_read(BIO *h,char *buf,int size);
-static int mem_puts(BIO *h,char *str);
-static int mem_gets(BIO *h,char *str,int size);
-static long mem_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int mem_write(BIO *h, const char *buf, int num);
+static int mem_read(BIO *h, char *buf, int size);
+static int mem_puts(BIO *h, const char *str);
+static int mem_gets(BIO *h, char *str, int size);
+static long mem_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int mem_new(BIO *h);
 static int mem_free(BIO *data);
-#else
-static int mem_write();
-static int mem_read();
-static int mem_puts();
-static int mem_gets();
-static long mem_ctrl();
-static int mem_new();
-static int mem_free();
-#endif
-
 static BIO_METHOD mem_method=
         {
         BIO_TYPE_MEM,
@@ -90,15 +79,38 @@ static BIO_METHOD mem_method=
         mem_ctrl,
         mem_new,
         mem_free,
+        NULL,
         };
 
-BIO_METHOD *BIO_s_mem()
+/* bio->num is used to hold the value to return on 'empty', if it is
+ * 0, should_retry is not set */
+
+BIO_METHOD *BIO_s_mem(void)
         {
         return(&mem_method);
         }
 
-static int mem_new(bi)
-BIO *bi;
+BIO *BIO_new_mem_buf(void *buf, int len)
+{
+        BIO *ret;
+        BUF_MEM *b;
+        if (!buf) {
+                BIOerr(BIO_F_BIO_NEW_MEM_BUF,BIO_R_NULL_PARAMETER);
+                return NULL;
+        }
+        if(len == -1) len = strlen(buf);
+        if(!(ret = BIO_new(BIO_s_mem())) ) return NULL;
+        b = (BUF_MEM *)ret->ptr;
+        b->data = buf;
+        b->length = len;
+        b->max = len;
+        ret->flags |= BIO_FLAGS_MEM_RDONLY;
+        /* Since this is static data retrying wont help */
+        ret->num = 0;
+        return ret;
+}
+
+static int mem_new(BIO *bi)
         {
         BUF_MEM *b;
 
@@ -106,30 +118,29 @@ BIO *bi;
                 return(0);
         bi->shutdown=1;
         bi->init=1;
-        bi->num=0;
+        bi->num= -1;
         bi->ptr=(char *)b;
         return(1);
         }
 
-static int mem_free(a)
-BIO *a;
+static int mem_free(BIO *a)
         {
         if (a == NULL) return(0);
         if (a->shutdown)
                 {
                 if ((a->init) && (a->ptr != NULL))
                         {
-                        BUF_MEM_free((BUF_MEM *)a->ptr);
+                        BUF_MEM *b;
+                        b = (BUF_MEM *)a->ptr;
+                        if(a->flags & BIO_FLAGS_MEM_RDONLY) b->data = NULL;
+                        BUF_MEM_free(b);
                         a->ptr=NULL;
                         }
                 }
         return(1);
         }
         
-static int mem_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int mem_read(BIO *b, char *out, int outl)
         {
         int ret= -1;
         BUF_MEM *bm;
@@ -139,28 +150,27 @@ int outl;
         bm=(BUF_MEM *)b->ptr;
         BIO_clear_retry_flags(b);
         ret=(outl > bm->length)?bm->length:outl;
-        if ((out != NULL) && (ret > 0))
-                {
+        if ((out != NULL) && (ret > 0)) {
                 memcpy(out,bm->data,ret);
                 bm->length-=ret;
                 /* memmove(&(bm->data[0]),&(bm->data[ret]), bm->length); */
-                from=(char *)&(bm->data[ret]);
-                to=(char *)&(bm->data[0]);
-                for (i=0; i<bm->length; i++)
-                        to[i]=from[i];
+                if(b->flags & BIO_FLAGS_MEM_RDONLY) bm->data += ret;
+                else {
+                        from=(char *)&(bm->data[ret]);
+                        to=(char *)&(bm->data[0]);
+                        for (i=0; i<bm->length; i++)
+                                to[i]=from[i];
                 }
-        else if (bm->length == 0)
+        } else if (bm->length == 0)
                 {
-                BIO_set_retry_read(b);
-                ret= -1;
+                ret = b->num;
+                if (ret != 0)
+                        BIO_set_retry_read(b);
                 }
         return(ret);
         }
 
-static int mem_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int mem_write(BIO *b, const char *in, int inl)
         {
         int ret= -1;
         int blen;
@@ -173,6 +183,11 @@ int inl;
                 goto end;
                 }
 
+        if(b->flags & BIO_FLAGS_MEM_RDONLY) {
+                BIOerr(BIO_F_MEM_WRITE,BIO_R_WRITE_TO_READ_ONLY_BIO);
+                goto end;
+        }
+
         BIO_clear_retry_flags(b);
         blen=bm->length;
         if (BUF_MEM_grow(bm,blen+inl) != (blen+inl))
@@ -183,11 +198,7 @@ end:
         return(ret);
         }
 
-static long mem_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long mem_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         long ret=1;
         char **pptr;
@@ -198,12 +209,26 @@ char *ptr;
                 {
         case BIO_CTRL_RESET:
                 if (bm->data != NULL)
-                        memset(bm->data,0,bm->max);
-                bm->length=0;
+                        {
+                        /* For read only case reset to the start again */
+                        if(b->flags & BIO_FLAGS_MEM_RDONLY) 
+                                {
+                                bm->data -= bm->max - bm->length;
+                                bm->length = bm->max;
+                                }
+                        else
+                                {
+                                memset(bm->data,0,bm->max);
+                                bm->length=0;
+                                }
+                        }
                 break;
         case BIO_CTRL_EOF:
                 ret=(long)(bm->length == 0);
                 break;
+        case BIO_C_SET_BUF_MEM_EOF_RETURN:
+                b->num=(int)num;
+                break;
         case BIO_CTRL_INFO:
                 ret=(long)bm->length;
                 if (ptr != NULL)
@@ -250,10 +275,7 @@ char *ptr;
         return(ret);
         }
 
-static int mem_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int mem_gets(BIO *bp, char *buf, int size)
         {
         int i,j;
         int ret= -1;
@@ -283,9 +305,7 @@ int size;
         return(ret);
         }
 
-static int mem_puts(bp,str)
-BIO *bp;
-char *str;
+static int mem_puts(BIO *bp, const char *str)
         {
         int n,ret;
 
diff --git a/src/lib/libcrypto/bio/bss_null.c b/src/lib/libcrypto/bio/bss_null.c
index 0791a2471a..46b73339df 100644
--- a/src/lib/libcrypto/bio/bss_null.c
+++ b/src/lib/libcrypto/bio/bss_null.c
@@ -59,26 +59,15 @@
 #include <stdio.h>
 #include <errno.h>
 #include "cryptlib.h"
-#include "bio.h"
+#include <openssl/bio.h>
 
-#ifndef NOPROTO
-static int null_write(BIO *h,char *buf,int num);
-static int null_read(BIO *h,char *buf,int size);
-static int null_puts(BIO *h,char *str);
-static int null_gets(BIO *h,char *str,int size);
-static long null_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int null_write(BIO *h, const char *buf, int num);
+static int null_read(BIO *h, char *buf, int size);
+static int null_puts(BIO *h, const char *str);
+static int null_gets(BIO *h, char *str, int size);
+static long null_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int null_new(BIO *h);
 static int null_free(BIO *data);
-#else
-static int null_write();
-static int null_read();
-static int null_puts();
-static int null_gets();
-static long null_ctrl();
-static int null_new();
-static int null_free();
-#endif
-
 static BIO_METHOD null_method=
         {
         BIO_TYPE_NULL,
@@ -90,15 +79,15 @@ static BIO_METHOD null_method=
         null_ctrl,
         null_new,
         null_free,
+        NULL,
         };
 
-BIO_METHOD *BIO_s_null()
+BIO_METHOD *BIO_s_null(void)
         {
         return(&null_method);
         }
 
-static int null_new(bi)
-BIO *bi;
+static int null_new(BIO *bi)
         {
         bi->init=1;
         bi->num=0;
@@ -106,34 +95,23 @@ BIO *bi;
         return(1);
         }
 
-static int null_free(a)
-BIO *a;
+static int null_free(BIO *a)
         {
         if (a == NULL) return(0);
         return(1);
         }
         
-static int null_read(b,out,outl)
-BIO *b;
-char *out;
-int outl;
+static int null_read(BIO *b, char *out, int outl)
         {
         return(0);
         }
 
-static int null_write(b,in,inl)
-BIO *b;
-char *in;
-int inl;
+static int null_write(BIO *b, const char *in, int inl)
         {
         return(inl);
         }
 
-static long null_ctrl(b,cmd,num,ptr)
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long null_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         long ret=1;
 
@@ -159,17 +137,12 @@ char *ptr;
         return(ret);
         }
 
-static int null_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
+static int null_gets(BIO *bp, char *buf, int size)
         {
         return(0);
         }
 
-static int null_puts(bp,str)
-BIO *bp;
-char *str;
+static int null_puts(BIO *bp, const char *str)
         {
         if (str == NULL) return(0);
         return(strlen(str));
diff --git a/src/lib/libcrypto/bio/bss_sock.c b/src/lib/libcrypto/bio/bss_sock.c
index d907a2867b..fdabd16d7e 100644
--- a/src/lib/libcrypto/bio/bss_sock.c
+++ b/src/lib/libcrypto/bio/bss_sock.c
@@ -56,55 +56,22 @@
  * [including the GNU Public Licence.]
  */
 
-#if !defined(NO_SOCK) || defined(BIO_FD)
+#ifndef OPENSSL_NO_SOCK
 
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
-#include "bio.h"
+#include <openssl/bio.h>
 
-#ifndef BIO_FD
-#ifndef NOPROTO
-static int sock_write(BIO *h,char *buf,int num);
-static int sock_read(BIO *h,char *buf,int size);
-static int sock_puts(BIO *h,char *str);
-static long sock_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int sock_write(BIO *h, const char *buf, int num);
+static int sock_read(BIO *h, char *buf, int size);
+static int sock_puts(BIO *h, const char *str);
+static long sock_ctrl(BIO *h, int cmd, long arg1, void *arg2);
 static int sock_new(BIO *h);
 static int sock_free(BIO *data);
 int BIO_sock_should_retry(int s);
-#else
-static int sock_write();
-static int sock_read();
-static int sock_puts();
-static long sock_ctrl();
-static int sock_new();
-static int sock_free();
-int BIO_sock_should_retry();
-#endif
-
-#else
-
-#ifndef NOPROTO
-static int fd_write(BIO *h,char *buf,int num);
-static int fd_read(BIO *h,char *buf,int size);
-static int fd_puts(BIO *h,char *str);
-static long fd_ctrl(BIO *h,int cmd,long arg1,char *arg2);
-static int fd_new(BIO *h);
-static int fd_free(BIO *data);
-int BIO_fd_should_retry(int s);
-#else
-static int fd_write();
-static int fd_read();
-static int fd_puts();
-static long fd_ctrl();
-static int fd_new();
-static int fd_free();
-int BIO_fd_should_retry();
-#endif
-#endif
 
-#ifndef BIO_FD
 static BIO_METHOD methods_sockp=
         {
         BIO_TYPE_SOCKET,
@@ -116,57 +83,25 @@ static BIO_METHOD methods_sockp=
         sock_ctrl,
         sock_new,
         sock_free,
+        NULL,
         };
 
-BIO_METHOD *BIO_s_socket()
+BIO_METHOD *BIO_s_socket(void)
         {
         return(&methods_sockp);
         }
-#else
-static BIO_METHOD methods_fdp=
-        {
-        BIO_TYPE_FD,"file descriptor",
-        fd_write,
-        fd_read,
-        fd_puts,
-        NULL, /* fd_gets, */
-        fd_ctrl,
-        fd_new,
-        fd_free,
-        };
 
-BIO_METHOD *BIO_s_fd()
-        {
-        return(&methods_fdp);
-        }
-#endif
-
-#ifndef BIO_FD
-BIO *BIO_new_socket(fd,close_flag)
-#else
-BIO *BIO_new_fd(fd,close_flag)
-#endif
-int fd;
-int close_flag;
+BIO *BIO_new_socket(int fd, int close_flag)
         {
         BIO *ret;
 
-#ifndef BIO_FD
         ret=BIO_new(BIO_s_socket());
-#else
-        ret=BIO_new(BIO_s_fd());
-#endif
         if (ret == NULL) return(NULL);
         BIO_set_fd(ret,fd,close_flag);
         return(ret);
         }
 
-#ifndef BIO_FD
-static int sock_new(bi)
-#else
-static int fd_new(bi)
-#endif
-BIO *bi;
+static int sock_new(BIO *bi)
         {
         bi->init=0;
         bi->num=0;
@@ -175,29 +110,14 @@ BIO *bi;
         return(1);
         }
 
-#ifndef BIO_FD
-static int sock_free(a)
-#else
-static int fd_free(a)
-#endif
-BIO *a;
+static int sock_free(BIO *a)
         {
         if (a == NULL) return(0);
         if (a->shutdown)
                 {
                 if (a->init)
                         {
-#ifndef BIO_FD
-                        shutdown(a->num,2);
-# ifdef WINDOWS
-                        closesocket(a->num);
-# else
-                        close(a->num);
-# endif
-#else                   /* BIO_FD */
-                        close(a->num);
-#endif
-
+                        SHUTDOWN2(a->num);
                         }
                 a->init=0;
                 a->flags=0;
@@ -205,80 +125,40 @@ BIO *a;
         return(1);
         }
         
-#ifndef BIO_FD
-static int sock_read(b,out,outl)
-#else
-static int fd_read(b,out,outl)
-#endif
-BIO *b;
-char *out;
-int outl;
+static int sock_read(BIO *b, char *out, int outl)
         {
         int ret=0;
 
         if (out != NULL)
                 {
-#if defined(WINDOWS) && !defined(BIO_FD)
                 clear_socket_error();
-                ret=recv(b->num,out,outl,0);
-#else
-                clear_sys_error();
-                ret=read(b->num,out,outl);
-#endif
+                ret=readsocket(b->num,out,outl);
                 BIO_clear_retry_flags(b);
                 if (ret <= 0)
                         {
-#ifndef BIO_FD
                         if (BIO_sock_should_retry(ret))
-#else
-                        if (BIO_fd_should_retry(ret))
-#endif
                                 BIO_set_retry_read(b);
                         }
                 }
         return(ret);
         }
 
-#ifndef BIO_FD
-static int sock_write(b,in,inl)
-#else
-static int fd_write(b,in,inl)
-#endif
-BIO *b;
-char *in;
-int inl;
+static int sock_write(BIO *b, const char *in, int inl)
         {
         int ret;
         
-#if defined(WINDOWS) && !defined(BIO_FD)
         clear_socket_error();
-        ret=send(b->num,in,inl,0);
-#else
-        clear_sys_error();
-        ret=write(b->num,in,inl);
-#endif
+        ret=writesocket(b->num,in,inl);
         BIO_clear_retry_flags(b);
         if (ret <= 0)
                 {
-#ifndef BIO_FD
                 if (BIO_sock_should_retry(ret))
-#else
-                if (BIO_fd_should_retry(ret))
-#endif
                         BIO_set_retry_write(b);
                 }
         return(ret);
         }
 
-#ifndef BIO_FD
-static long sock_ctrl(b,cmd,num,ptr)
-#else
-static long fd_ctrl(b,cmd,num,ptr)
-#endif
-BIO *b;
-int cmd;
-long num;
-char *ptr;
+static long sock_ctrl(BIO *b, int cmd, long num, void *ptr)
         {
         long ret=1;
         int *ip;
@@ -286,21 +166,16 @@ char *ptr;
         switch (cmd)
                 {
         case BIO_CTRL_RESET:
-#ifdef BIO_FD
-                ret=(long)lseek(b->num,0,0);
-#else
+                num=0;
+        case BIO_C_FILE_SEEK:
                 ret=0;
-#endif
                 break;
+        case BIO_C_FILE_TELL:
         case BIO_CTRL_INFO:
                 ret=0;
                 break;
         case BIO_C_SET_FD:
-#ifndef BIO_FD
                 sock_free(b);
-#else
-                fd_free(b);
-#endif
                 b->num= *((int *)ptr);
                 b->shutdown=(int)num;
                 b->init=1;
@@ -329,7 +204,6 @@ char *ptr;
         case BIO_CTRL_FLUSH:
                 ret=1;
                 break;
-                break;
         default:
                 ret=0;
                 break;
@@ -337,82 +211,46 @@ char *ptr;
         return(ret);
         }
 
-#ifdef undef
-static int sock_gets(bp,buf,size)
-BIO *bp;
-char *buf;
-int size;
-        {
-        return(-1);
-        }
-#endif
-
-#ifndef BIO_FD
-static int sock_puts(bp,str)
-#else
-static int fd_puts(bp,str)
-#endif
-BIO *bp;
-char *str;
+static int sock_puts(BIO *bp, const char *str)
         {
         int n,ret;
 
         n=strlen(str);
-#ifndef BIO_FD
         ret=sock_write(bp,str,n);
-#else
-        ret=fd_write(bp,str,n);
-#endif
         return(ret);
         }
 
-#ifndef BIO_FD
-int BIO_sock_should_retry(i)
-#else
-int BIO_fd_should_retry(i)
-#endif
-int i;
+int BIO_sock_should_retry(int i)
         {
         int err;
 
         if ((i == 0) || (i == -1))
                 {
-#if !defined(BIO_FD) && defined(WINDOWS)
                 err=get_last_socket_error();
-#else
-                err=get_last_sys_error();
-#endif
 
-#if defined(WINDOWS) /* more microsoft stupidity */
+#if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */
                 if ((i == -1) && (err == 0))
                         return(1);
 #endif
 
-#ifndef BIO_FD
                 return(BIO_sock_non_fatal_error(err));
-#else
-                return(BIO_fd_non_fatal_error(err));
-#endif
                 }
         return(0);
         }
 
-#ifndef BIO_FD
-int BIO_sock_non_fatal_error(err)
-#else
-int BIO_fd_non_fatal_error(err)
-#endif
-int err;
+int BIO_sock_non_fatal_error(int err)
         {
         switch (err)
                 {
-#if !defined(BIO_FD) && defined(WINDOWS)
+#if defined(OPENSSL_SYS_WINDOWS)
 # if defined(WSAEWOULDBLOCK)
         case WSAEWOULDBLOCK:
 # endif
 
-# if defined(WSAENOTCONN)
+# if 0 /* This appears to always be an error */
+#  if defined(WSAENOTCONN)
         case WSAENOTCONN:
+#  endif
 # endif
 #endif
 
@@ -452,7 +290,7 @@ int err;
         case EALREADY:
 #endif
                 return(1);
-                break;
+                /* break; */
         default:
                 break;
                 }