13 files changed, 406 insertions, 118 deletions

diff --git a/src/lib/libcrypto/bio/b_dump.c b/src/lib/libcrypto/bio/b_dump.c
index f671e722fa..c80ecc4295 100644
--- a/src/lib/libcrypto/bio/b_dump.c
+++ b/src/lib/libcrypto/bio/b_dump.c
@@ -62,30 +62,32 @@
 
 #include <stdio.h>
 #include "cryptlib.h"
-#include <openssl/bio.h>
+#include "bio_lcl.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 *bio, const char *s, int len)
+int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u),
+        void *u, const char *s, int len)
         {
-        return BIO_dump_indent(bio, s, len, 0);
+        return BIO_dump_indent_cb(cb, u, s, len, 0);
         }
 
-int BIO_dump_indent(BIO *bio, const char *s, int len, int indent)
+int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u),
+        void *u, const char *s, int len, int indent)
         {
         int ret=0;
         char buf[288+1],tmp[20],str[128+1];
-        int i,j,rows,trunc;
+        int i,j,rows,trc;
         unsigned char ch;
         int dump_width;
-        
-        trunc=0;
-        
+
+        trc=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--)
+                trc++;
 #endif
 
         if (indent < 0)
@@ -96,7 +98,7 @@ int BIO_dump_indent(BIO *bio, const char *s, int len, int indent)
                 memset(str,' ',indent);
                 }
         str[indent]='\0';
-        
+
         dump_width=DUMP_WIDTH_LESS_INDENT(indent);
         rows=(len/dump_width);
         if ((rows*dump_width)<len)
@@ -117,7 +119,7 @@ int BIO_dump_indent(BIO *bio, const char *s, int len, int indent)
                                 {
                                 ch=((unsigned char)*(s+i*dump_width+j)) & 0xff;
                                 BIO_snprintf(tmp,sizeof tmp,"%02x%c",ch,
-                                         j==7?'-':' ');
+                                        j==7?'-':' ');
                                 BUF_strlcat(buf,tmp,sizeof buf);
                                 }
                         }
@@ -129,28 +131,57 @@ int BIO_dump_indent(BIO *bio, const char *s, int len, int indent)
                         ch=((unsigned char)*(s+i*dump_width+j)) & 0xff;
 #ifndef CHARSET_EBCDIC
                         BIO_snprintf(tmp,sizeof tmp,"%c",
-                                 ((ch>=' ')&&(ch<='~'))?ch:'.');
+                                ((ch>=' ')&&(ch<='~'))?ch:'.');
 #else
                         BIO_snprintf(tmp,sizeof tmp,"%c",
-                                 ((ch>=os_toascii[' '])&&(ch<=os_toascii['~']))
-                                 ? os_toebcdic[ch]
-                                 : '.');
+                                ((ch>=os_toascii[' '])&&(ch<=os_toascii['~']))
+                                ? os_toebcdic[ch]
+                                : '.');
 #endif
                         BUF_strlcat(buf,tmp,sizeof buf);
                         }
                 BUF_strlcat(buf,"\n",sizeof buf);
-                /* if this is the last call then update the ddt_dump thing so that
-                 * we will move the selection point in the debug window 
+                /* 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));
+                ret+=cb((void *)buf,strlen(buf),u);
                 }
 #ifdef TRUNCATE
-        if (trunc > 0)
+        if (trc > 0)
                 {
                 BIO_snprintf(buf,sizeof buf,"%s%04x - <SPACES/NULS>\n",str,
-                         len+trunc);
-                ret+=BIO_write(bio,(char *)buf,strlen(buf));
+                        len+trc);
+                ret+=cb((void *)buf,strlen(buf),u);
                 }
 #endif
         return(ret);
         }
+
+#ifndef OPENSSL_NO_FP_API
+static int write_fp(const void *data, size_t len, void *fp)
+        {
+        return UP_fwrite(data, len, 1, fp);
+        }
+int BIO_dump_fp(FILE *fp, const char *s, int len)
+        {
+        return BIO_dump_cb(write_fp, fp, s, len);
+        }
+int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent)
+        {
+        return BIO_dump_indent_cb(write_fp, fp, s, len, indent);
+        }
+#endif
+
+static int write_bio(const void *data, size_t len, void *bp)
+        {
+        return BIO_write((BIO *)bp, (const char *)data, len);
+        }
+int BIO_dump(BIO *bp, const char *s, int len)
+        {
+        return BIO_dump_cb(write_bio, bp, s, len);
+        }
+int BIO_dump_indent(BIO *bp, const char *s, int len, int indent)
+        {
+        return BIO_dump_indent_cb(write_bio, bp, s, len, indent);
+        }
+
diff --git a/src/lib/libcrypto/bio/b_print.c b/src/lib/libcrypto/bio/b_print.c
index f2bd91d5a0..2fffcfc025 100644
--- a/src/lib/libcrypto/bio/b_print.c
+++ b/src/lib/libcrypto/bio/b_print.c
@@ -79,7 +79,7 @@
 #include <openssl/bn.h>         /* To get BN_LLONG properly defined */
 #include <openssl/bio.h>
 
-#ifdef BN_LLONG
+#if defined(BN_LLONG) || defined(SIXTY_FOUR_BIT)
 # ifndef HAVE_LONG_LONG
 #  define HAVE_LONG_LONG 1
 # endif
@@ -117,7 +117,7 @@
 
 #if HAVE_LONG_LONG
 # if defined(OPENSSL_SYS_WIN32) && !defined(__GNUC__)
-# define LLONG _int64
+# define LLONG __int64
 # else
 # define LLONG long long
 # endif
@@ -482,7 +482,7 @@ fmtint(
     int flags)
 {
     int signvalue = 0;
-    char *prefix = "";
+    const char *prefix = "";
     unsigned LLONG uvalue;
     char convert[DECIMAL_SIZE(value)+3];
     int place = 0;
@@ -513,8 +513,8 @@ fmtint(
             (caps ? "0123456789ABCDEF" : "0123456789abcdef")
             [uvalue % (unsigned) base];
         uvalue = (uvalue / (unsigned) base);
-    } while (uvalue && (place < sizeof convert));
-    if (place == sizeof convert)
+    } while (uvalue && (place < (int)sizeof(convert)));
+    if (place == sizeof(convert))
         place--;
     convert[place] = 0;
 
@@ -619,6 +619,7 @@ fmtfp(
     int caps = 0;
     long intpart;
     long fracpart;
+    long max10;
 
     if (max < 0)
         max = 6;
@@ -639,11 +640,12 @@ fmtfp(
 
     /* we "cheat" by converting the fractional part to integer by
        multiplying by a factor of 10 */
-    fracpart = roundv((pow_10(max)) * (ufvalue - intpart));
+    max10 = roundv(pow_10(max));
+    fracpart = roundv(pow_10(max) * (ufvalue - intpart));
 
-    if (fracpart >= (long)pow_10(max)) {
+    if (fracpart >= max10) {
         intpart++;
-        fracpart -= (long)pow_10(max);
+        fracpart -= max10;
     }
 
     /* convert integer part */
@@ -652,7 +654,7 @@ fmtfp(
             (caps ? "0123456789ABCDEF"
               : "0123456789abcdef")[intpart % 10];
         intpart = (intpart / 10);
-    } while (intpart && (iplace < sizeof iconvert));
+    } while (intpart && (iplace < (int)sizeof(iconvert)));
     if (iplace == sizeof iconvert)
         iplace--;
     iconvert[iplace] = 0;
diff --git a/src/lib/libcrypto/bio/b_sock.c b/src/lib/libcrypto/bio/b_sock.c
index c851298d1e..ead477d8a2 100644
--- a/src/lib/libcrypto/bio/b_sock.c
+++ b/src/lib/libcrypto/bio/b_sock.c
@@ -56,14 +56,21 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef OPENSSL_NO_SOCK
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
 #include <openssl/bio.h>
+#if defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_BSDSOCK)
+#include <netdb.h>
+#if defined(NETWARE_CLIB)
+#include <sys/ioctl.h>
+NETDB_DEFINE_CONTEXT
+#endif
+#endif
+
+#ifndef OPENSSL_NO_SOCK
 
 #ifdef OPENSSL_SYS_WIN16
 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
@@ -79,7 +86,7 @@
 #define MAX_LISTEN  32
 #endif
 
-#ifdef OPENSSL_SYS_WINDOWS
+#if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
 static int wsa_init_done=0;
 #endif
 
@@ -175,11 +182,11 @@ int BIO_get_port(const char *str, unsigned short *port_ptr)
                 /* Note: under VMS with SOCKETSHR, it seems like the first
                  * parameter is 'char *', instead of 'const char *'
                  */
-                s=getservbyname(
 #ifndef CONST_STRICT
-                    (char *)
+                s=getservbyname((char *)str,"tcp");
+#else
+                s=getservbyname(str,"tcp");
 #endif
-                    str,"tcp");
                 if(s != NULL)
                         *port_ptr=ntohs((unsigned short)s->s_port);
                 CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
@@ -357,7 +364,11 @@ 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 */
+#if (defined(NETWARE_BSDSOCK) && !defined(__NOVELL_LIBC__))
+        return gethostbyname((char*)name);
+#else
         return gethostbyname(name);
+#endif
 #else
         struct hostent *ret;
         int i,lowi=0,j;
@@ -397,11 +408,11 @@ struct hostent *BIO_gethostbyname(const char *name)
                 /* Note: under VMS with SOCKETSHR, it seems like the first
                  * parameter is 'char *', instead of 'const char *'
                  */
-                ret=gethostbyname(
 #  ifndef CONST_STRICT
-                    (char *)
+                ret=gethostbyname((char *)name);
+#  else
+                ret=gethostbyname(name);
 #  endif
-                    name);
 
                 if (ret == NULL)
                         goto end;
@@ -453,9 +464,6 @@ int BIO_sock_init(void)
                 {
                 int err;
           
-#ifdef SIGINT
-                signal(SIGINT,(void (*)(int))BIO_sock_cleanup);
-#endif
                 wsa_init_done=1;
                 memset(&wsa_state,0,sizeof(wsa_state));
                 if (WSAStartup(0x0101,&wsa_state)!=0)
@@ -473,6 +481,26 @@ int BIO_sock_init(void)
         if (sock_init())
                 return (-1);
 #endif
+
+#if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
+    WORD wVerReq;
+    WSADATA wsaData;
+    int err;
+
+    if (!wsa_init_done)
+    {
+        wsa_init_done=1;
+        wVerReq = MAKEWORD( 2, 0 );
+        err = WSAStartup(wVerReq,&wsaData);
+        if (err != 0)
+        {
+            SYSerr(SYS_F_WSASTARTUP,err);
+            BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP);
+            return(-1);
+                        }
+                }
+#endif
+
         return(1);
         }
 
@@ -483,10 +511,16 @@ void BIO_sock_cleanup(void)
                 {
                 wsa_init_done=0;
 #ifndef OPENSSL_SYS_WINCE
-                WSACancelBlockingCall();
+                WSACancelBlockingCall();        /* Winsock 1.1 specific */
 #endif
                 WSACleanup();
                 }
+#elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
+   if (wsa_init_done)
+        {
+        wsa_init_done=0;
+        WSACleanup();
+                }
 #endif
         }
 
diff --git a/src/lib/libcrypto/bio/bf_nbio.c b/src/lib/libcrypto/bio/bf_nbio.c
index 1ce2bfacc0..c72a23c2e1 100644
--- a/src/lib/libcrypto/bio/bf_nbio.c
+++ b/src/lib/libcrypto/bio/bf_nbio.c
@@ -127,7 +127,7 @@ static int nbiof_read(BIO *b, char *out, int outl)
         {
         NBIO_TEST *nt;
         int ret=0;
-#if 0
+#if 1
         int num;
         unsigned char n;
 #endif
@@ -137,7 +137,7 @@ static int nbiof_read(BIO *b, char *out, int outl)
         nt=(NBIO_TEST *)b->ptr;
 
         BIO_clear_retry_flags(b);
-#if 0
+#if 1
         RAND_pseudo_bytes(&n,1);
         num=(n&0x07);
 
diff --git a/src/lib/libcrypto/bio/bio.h b/src/lib/libcrypto/bio/bio.h
index 2eb703830f..cecb6a7207 100644
--- a/src/lib/libcrypto/bio/bio.h
+++ b/src/lib/libcrypto/bio/bio.h
@@ -59,13 +59,14 @@
 #ifndef HEADER_BIO_H
 #define HEADER_BIO_H
 
+#include <openssl/e_os2.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" {
@@ -93,6 +94,8 @@ extern "C" {
 #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_DGRAM          (21|0x0400|0x0100)
+#define BIO_TYPE_COMP           (23|0x0200)             /* filter */
 
 #define BIO_TYPE_DESCRIPTOR     0x0100  /* socket, fd, connect or accept */
 #define BIO_TYPE_FILTER         0x0200
@@ -124,6 +127,38 @@ extern "C" {
 
 #define BIO_CTRL_SET_FILENAME   30      /* BIO_s_file special */
 
+/* dgram BIO stuff */
+#define BIO_CTRL_DGRAM_CONNECT       31  /* BIO dgram special */
+#define BIO_CTRL_DGRAM_SET_CONNECTED 32  /* allow for an externally
+                                          * connected socket to be
+                                          * passed in */ 
+#define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33 /* setsockopt, essentially */
+#define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34 /* getsockopt, essentially */
+#define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35 /* setsockopt, essentially */
+#define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36 /* getsockopt, essentially */
+
+#define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37 /* flag whether the last */
+#define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38 /* I/O operation tiemd out */
+                                        
+/* #ifdef IP_MTU_DISCOVER */
+#define BIO_CTRL_DGRAM_MTU_DISCOVER       39 /* set DF bit on egress packets */
+/* #endif */
+
+#define BIO_CTRL_DGRAM_QUERY_MTU          40 /* as kernel for current MTU */
+#define BIO_CTRL_DGRAM_GET_MTU            41 /* get cached value for MTU */
+#define BIO_CTRL_DGRAM_SET_MTU            42 /* set cached value for
+                                              * MTU. want to use this
+                                              * if asking the kernel
+                                              * fails */
+
+#define BIO_CTRL_DGRAM_MTU_EXCEEDED       43 /* check whether the MTU
+                                              * was exceed in the
+                                              * previous write
+                                              * operation */
+
+#define BIO_CTRL_DGRAM_SET_PEER           44 /* Destination for the data */
+
+
 /* modifiers */
 #define BIO_FP_READ             0x02
 #define BIO_FP_WRITE            0x04
@@ -135,6 +170,11 @@ extern "C" {
 #define BIO_FLAGS_IO_SPECIAL    0x04
 #define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL)
 #define BIO_FLAGS_SHOULD_RETRY  0x08
+#ifndef BIO_FLAGS_UPLINK
+/* "UPLINK" flag denotes file descriptors provided by application.
+   It defaults to 0, as most platforms don't require UPLINK interface. */
+#define BIO_FLAGS_UPLINK        0
+#endif
 
 /* Used in BIO_gethostbyname() */
 #define BIO_GHBN_CTRL_HITS              1
@@ -157,28 +197,32 @@ extern "C" {
  */
 #define BIO_FLAGS_MEM_RDONLY    0x200
 
-#define BIO_set_flags(b,f) ((b)->flags|=(f))
-#define BIO_get_flags(b) ((b)->flags)
+typedef struct bio_st BIO;
+
+void BIO_set_flags(BIO *b, int flags);
+int  BIO_test_flags(const BIO *b, int flags);
+void BIO_clear_flags(BIO *b, int flags);
+
+#define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
 #define BIO_set_retry_special(b) \
-                ((b)->flags|=(BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
+                BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
 #define BIO_set_retry_read(b) \
-                ((b)->flags|=(BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
+                BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
 #define BIO_set_retry_write(b) \
-                ((b)->flags|=(BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
+                BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
 
 /* These are normally used internally in BIOs */
-#define BIO_clear_flags(b,f) ((b)->flags&= ~(f))
 #define BIO_clear_retry_flags(b) \
-                ((b)->flags&= ~(BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+                BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
 #define BIO_get_retry_flags(b) \
-                ((b)->flags&(BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+                BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_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)
+#define BIO_should_read(a)              BIO_test_flags(a, BIO_FLAGS_READ)
+#define BIO_should_write(a)             BIO_test_flags(a, BIO_FLAGS_WRITE)
+#define BIO_should_io_special(a)        BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
+#define BIO_retry_type(a)               BIO_test_flags(a, BIO_FLAGS_RWS)
+#define BIO_should_retry(a)             BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
 
 /* The next three are used in conjunction with the
  * BIO_should_io_special() condition.  After this returns true,
@@ -207,14 +251,14 @@ extern "C" {
 #define BIO_cb_pre(a)   (!((a)&BIO_CB_RETURN))
 #define BIO_cb_post(a)  ((a)&BIO_CB_RETURN)
 
-#define BIO_set_callback(b,cb)          ((b)->callback=(cb))
-#define BIO_set_callback_arg(b,arg)     ((b)->cb_arg=(char *)(arg))
-#define BIO_get_callback_arg(b)         ((b)->cb_arg)
-#define BIO_get_callback(b)             ((b)->callback)
-#define BIO_method_name(b)              ((b)->method->name)
-#define BIO_method_type(b)              ((b)->method->type)
+long (*BIO_get_callback(const BIO *b)) (struct bio_st *,int,const char *,int, long,long);
+void BIO_set_callback(BIO *b, 
+        long (*callback)(struct bio_st *,int,const char *,int, long,long));
+char *BIO_get_callback_arg(const BIO *b);
+void BIO_set_callback_arg(BIO *b, char *arg);
 
-typedef struct bio_st BIO;
+const char * BIO_method_name(const BIO *b);
+int BIO_method_type(const BIO *b);
 
 typedef void bio_info_cb(struct bio_st *, int, const char *, int, long, long);
 
@@ -488,6 +532,18 @@ 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);
 
+/* ctrl macros for dgram */
+#define BIO_ctrl_dgram_connect(b,peer)  \
+                     (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)peer)
+#define BIO_ctrl_set_connected(b, state, peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, state, (char *)peer)
+#define BIO_dgram_recv_timedout(b) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL)
+#define BIO_dgram_send_timedout(b) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL)
+#define BIO_dgram_set_peer(b,peer) \
+         (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)peer)
+
 /* 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)()); */
@@ -567,15 +623,28 @@ BIO_METHOD *BIO_f_buffer(void);
 BIO_METHOD *BIO_f_linebuffer(void);
 #endif
 BIO_METHOD *BIO_f_nbio_test(void);
+#ifndef OPENSSL_NO_DGRAM
+BIO_METHOD *BIO_s_datagram(void);
+#endif
+
 /* BIO_METHOD *BIO_f_ber(void); */
 
 int BIO_sock_should_retry(int i);
 int BIO_sock_non_fatal_error(int error);
+int BIO_dgram_non_fatal_error(int error);
+
 int BIO_fd_should_retry(int i);
 int BIO_fd_non_fatal_error(int error);
+int BIO_dump_cb(int (*cb)(const void *data, size_t len, void *u),
+                void *u, const char *s, int len);
+int BIO_dump_indent_cb(int (*cb)(const void *data, size_t len, void *u),
+                       void *u, const char *s, int len, int indent);
 int BIO_dump(BIO *b,const char *bytes,int len);
 int BIO_dump_indent(BIO *b,const char *bytes,int len,int indent);
-
+#ifndef OPENSSL_NO_FP_API
+int BIO_dump_fp(FILE *fp, const char *s, int len);
+int BIO_dump_indent_fp(FILE *fp, const char *s, int len, int indent);
+#endif
 struct hostent *BIO_gethostbyname(const char *name);
 /* We might want a thread-safe interface too:
  * struct hostent *BIO_gethostbyname_r(const char *name,
@@ -597,6 +666,7 @@ void BIO_sock_cleanup(void);
 int BIO_set_tcp_ndelay(int sock,int turn_on);
 
 BIO *BIO_new_socket(int sock, int close_flag);
+BIO *BIO_new_dgram(int fd, 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);
@@ -612,10 +682,20 @@ void BIO_copy_next_retry(BIO *b);
 
 /*long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);*/
 
-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);
+#ifdef __GNUC__
+#  define __bio_h__attr__ __attribute__
+#else
+#  define __bio_h__attr__(x)
+#endif
+int BIO_printf(BIO *bio, const char *format, ...)
+        __bio_h__attr__((__format__(__printf__,2,3)));
+int BIO_vprintf(BIO *bio, const char *format, va_list args)
+        __bio_h__attr__((__format__(__printf__,2,0)));
+int BIO_snprintf(char *buf, size_t n, const char *format, ...)
+        __bio_h__attr__((__format__(__printf__,3,4)));
+int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
+        __bio_h__attr__((__format__(__printf__,3,0)));
+#undef __bio_h__attr__
 
 /* BEGIN ERROR CODES */
 /* The following lines are auto generated by the script mkerr.pl. Any changes
@@ -629,6 +709,7 @@ void ERR_load_BIO_strings(void);
 #define BIO_F_ACPT_STATE                                 100
 #define BIO_F_BIO_ACCEPT                                 101
 #define BIO_F_BIO_BER_GET_HEADER                         102
+#define BIO_F_BIO_CALLBACK_CTRL                          131
 #define BIO_F_BIO_CTRL                                   103
 #define BIO_F_BIO_GETHOSTBYNAME                          120
 #define BIO_F_BIO_GETS                                   104
diff --git a/src/lib/libcrypto/bio/bio_err.c b/src/lib/libcrypto/bio/bio_err.c
index 8859a58ae4..6603f1c74d 100644
--- a/src/lib/libcrypto/bio/bio_err.c
+++ b/src/lib/libcrypto/bio/bio_err.c
@@ -73,6 +73,7 @@ static ERR_STRING_DATA BIO_str_functs[]=
 {ERR_FUNC(BIO_F_ACPT_STATE),    "ACPT_STATE"},
 {ERR_FUNC(BIO_F_BIO_ACCEPT),    "BIO_accept"},
 {ERR_FUNC(BIO_F_BIO_BER_GET_HEADER),    "BIO_BER_GET_HEADER"},
+{ERR_FUNC(BIO_F_BIO_CALLBACK_CTRL),     "BIO_callback_ctrl"},
 {ERR_FUNC(BIO_F_BIO_CTRL),      "BIO_ctrl"},
 {ERR_FUNC(BIO_F_BIO_GETHOSTBYNAME),     "BIO_gethostbyname"},
 {ERR_FUNC(BIO_F_BIO_GETS),      "BIO_gets"},
@@ -142,15 +143,12 @@ static ERR_STRING_DATA BIO_str_reasons[]=
 
 void ERR_load_BIO_strings(void)
         {
-        static int init=1;
+#ifndef OPENSSL_NO_ERR
 
-        if (init)
+        if (ERR_func_error_string(BIO_str_functs[0].error) == NULL)
                 {
-                init=0;
-#ifndef OPENSSL_NO_ERR
                 ERR_load_strings(0,BIO_str_functs);
                 ERR_load_strings(0,BIO_str_reasons);
-#endif
-
                 }
+#endif
         }
diff --git a/src/lib/libcrypto/bio/bio_lib.c b/src/lib/libcrypto/bio/bio_lib.c
index 692c8fb5c6..3f52ae953c 100644
--- a/src/lib/libcrypto/bio/bio_lib.c
+++ b/src/lib/libcrypto/bio/bio_lib.c
@@ -141,10 +141,56 @@ int BIO_free(BIO *a)
 void BIO_vfree(BIO *a)
     { BIO_free(a); }
 
+void BIO_clear_flags(BIO *b, int flags)
+        {
+        b->flags &= ~flags;
+        }
+
+int     BIO_test_flags(const BIO *b, int flags)
+        {
+        return (b->flags & flags);
+        }
+
+void    BIO_set_flags(BIO *b, int flags)
+        {
+        b->flags |= flags;
+        }
+
+long (*BIO_get_callback(const BIO *b))(struct bio_st *,int,const char *,int, long,long)
+        {
+        return b->callback;
+        }
+
+void BIO_set_callback(BIO *b, long (*cb)(struct bio_st *,int,const char *,int, long,long))
+        {
+        b->callback = cb;
+        }
+
+void BIO_set_callback_arg(BIO *b, char *arg)
+        {
+        b->cb_arg = arg;
+        }
+
+char * BIO_get_callback_arg(const BIO *b)
+        {
+        return b->cb_arg;
+        }
+
+const char * BIO_method_name(const BIO *b)
+        {
+        return b->method->name;
+        }
+
+int BIO_method_type(const BIO *b)
+        {
+        return b->method->type;
+        }
+
+
 int BIO_read(BIO *b, void *out, int outl)
         {
         int i;
-        long (*cb)();
+        long (*cb)(BIO *,int,const char *,int,long,long);
 
         if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL))
                 {
@@ -176,7 +222,7 @@ int BIO_read(BIO *b, void *out, int outl)
 int BIO_write(BIO *b, const void *in, int inl)
         {
         int i;
-        long (*cb)();
+        long (*cb)(BIO *,int,const char *,int,long,long);
 
         if (b == NULL)
                 return(0);
@@ -211,7 +257,7 @@ int BIO_write(BIO *b, const void *in, int inl)
 int BIO_puts(BIO *b, const char *in)
         {
         int i;
-        long (*cb)();
+        long (*cb)(BIO *,int,const char *,int,long,long);
 
         if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL))
                 {
@@ -244,7 +290,7 @@ int BIO_puts(BIO *b, const char *in)
 int BIO_gets(BIO *b, char *in, int inl)
         {
         int i;
-        long (*cb)();
+        long (*cb)(BIO *,int,const char *,int,long,long);
 
         if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL))
                 {
@@ -305,7 +351,7 @@ char *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
 long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
         {
         long ret;
-        long (*cb)();
+        long (*cb)(BIO *,int,const char *,int,long,long);
 
         if (b == NULL) return(0);
 
@@ -332,13 +378,13 @@ long BIO_ctrl(BIO *b, 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))
         {
         long ret;
-        long (*cb)();
+        long (*cb)(BIO *,int,const char *,int,long,long);
 
         if (b == NULL) return(0);
 
         if ((b->method == NULL) || (b->method->callback_ctrl == NULL))
                 {
-                BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD);
+                BIOerr(BIO_F_BIO_CALLBACK_CTRL,BIO_R_UNSUPPORTED_METHOD);
                 return(-2);
                 }
 
diff --git a/src/lib/libcrypto/bio/bss_acpt.c b/src/lib/libcrypto/bio/bss_acpt.c
index 8ea1db158b..d090b7272f 100644
--- a/src/lib/libcrypto/bio/bss_acpt.c
+++ b/src/lib/libcrypto/bio/bss_acpt.c
@@ -56,14 +56,14 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef OPENSSL_NO_SOCK
-
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
 #include <openssl/bio.h>
 
+#ifndef OPENSSL_NO_SOCK
+
 #ifdef OPENSSL_SYS_WIN16
 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
 #else
diff --git a/src/lib/libcrypto/bio/bss_conn.c b/src/lib/libcrypto/bio/bss_conn.c
index 216780ed5e..c14727855b 100644
--- a/src/lib/libcrypto/bio/bss_conn.c
+++ b/src/lib/libcrypto/bio/bss_conn.c
@@ -56,14 +56,14 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef OPENSSL_NO_SOCK
-
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
 #include <openssl/bio.h>
 
+#ifndef OPENSSL_NO_SOCK
+
 #ifdef OPENSSL_SYS_WIN16
 #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
 #else
@@ -130,7 +130,7 @@ static int conn_state(BIO *b, BIO_CONNECT *c)
         int ret= -1,i;
         unsigned long l;
         char *p,*q;
-        int (*cb)()=NULL;
+        int (*cb)(const BIO *,int,int)=NULL;
 
         if (c->info_callback != NULL)
                 cb=c->info_callback;
@@ -590,9 +590,9 @@ static long conn_ctrl(BIO *b, int cmd, long num, void *ptr)
                 break;
         case BIO_CTRL_GET_CALLBACK:
                 {
-                int (**fptr)();
+                int (**fptr)(const BIO *bio,int state,int xret);
 
-                fptr=(int (**)())ptr;
+                fptr=(int (**)(const BIO *bio,int state,int xret))ptr;
                 *fptr=data->info_callback;
                 }
                 break;
diff --git a/src/lib/libcrypto/bio/bss_fd.c b/src/lib/libcrypto/bio/bss_fd.c
index 5e3e187de6..4c229bf641 100644
--- a/src/lib/libcrypto/bio/bss_fd.c
+++ b/src/lib/libcrypto/bio/bss_fd.c
@@ -60,7 +60,19 @@
 #include <errno.h>
 #define USE_SOCKETS
 #include "cryptlib.h"
-#include <openssl/bio.h>
+/*
+ * As for unconditional usage of "UPLINK" interface in this module.
+ * Trouble is that unlike Unix file descriptors [which are indexes
+ * in kernel-side per-process table], corresponding descriptors on
+ * platforms which require "UPLINK" interface seem to be indexes
+ * in a user-land, non-global table. Well, in fact they are indexes
+ * in stdio _iob[], and recall that _iob[] was the very reason why
+ * "UPLINK" interface was introduced in first place. But one way on
+ * another. Neither libcrypto or libssl use this BIO meaning that
+ * file descriptors can only be provided by application. Therefore
+ * "UPLINK" calls are due...
+ */
+#include "bio_lcl.h"
 
 static int fd_write(BIO *h, const char *buf, int num);
 static int fd_read(BIO *h, char *buf, int size);
@@ -100,9 +112,9 @@ BIO *BIO_new_fd(int fd,int close_flag)
 static int fd_new(BIO *bi)
         {
         bi->init=0;
-        bi->num=0;
+        bi->num=-1;
         bi->ptr=NULL;
-        bi->flags=0;
+        bi->flags=BIO_FLAGS_UPLINK; /* essentially redundant */
         return(1);
         }
 
@@ -113,10 +125,10 @@ static int fd_free(BIO *a)
                 {
                 if (a->init)
                         {
-                        close(a->num);
+                        UP_close(a->num);
                         }
                 a->init=0;
-                a->flags=0;
+                a->flags=BIO_FLAGS_UPLINK;
                 }
         return(1);
         }
@@ -128,7 +140,7 @@ static int fd_read(BIO *b, char *out,int outl)
         if (out != NULL)
                 {
                 clear_sys_error();
-                ret=read(b->num,out,outl);
+                ret=UP_read(b->num,out,outl);
                 BIO_clear_retry_flags(b);
                 if (ret <= 0)
                         {
@@ -143,7 +155,7 @@ static int fd_write(BIO *b, const char *in, int inl)
         {
         int ret;
         clear_sys_error();
-        ret=write(b->num,in,inl);
+        ret=UP_write(b->num,in,inl);
         BIO_clear_retry_flags(b);
         if (ret <= 0)
                 {
@@ -163,11 +175,11 @@ static long fd_ctrl(BIO *b, int cmd, long num, void *ptr)
         case BIO_CTRL_RESET:
                 num=0;
         case BIO_C_FILE_SEEK:
-                ret=(long)lseek(b->num,num,0);
+                ret=(long)UP_lseek(b->num,num,0);
                 break;
         case BIO_C_FILE_TELL:
         case BIO_CTRL_INFO:
-                ret=(long)lseek(b->num,0,1);
+                ret=(long)UP_lseek(b->num,0,1);
                 break;
         case BIO_C_SET_FD:
                 fd_free(b);
diff --git a/src/lib/libcrypto/bio/bss_file.c b/src/lib/libcrypto/bio/bss_file.c
index 58fade9f29..0c8c8115fa 100644
--- a/src/lib/libcrypto/bio/bss_file.c
+++ b/src/lib/libcrypto/bio/bss_file.c
@@ -65,12 +65,34 @@
 #ifndef HEADER_BSS_FILE_C
 #define HEADER_BSS_FILE_C
 
+#if defined(__linux) || defined(__sun) || defined(__hpux)
+/* Following definition aliases fopen to fopen64 on above mentioned
+ * platforms. This makes it possible to open and sequentially access
+ * files larger than 2GB from 32-bit application. It does not allow to
+ * traverse them beyond 2GB with fseek/ftell, but on the other hand *no*
+ * 32-bit platform permits that, not with fseek/ftell. Not to mention
+ * that breaking 2GB limit for seeking would require surgery to *our*
+ * API. But sequential access suffices for practical cases when you
+ * can run into large files, such as fingerprinting, so we can let API
+ * alone. For reference, the list of 32-bit platforms which allow for
+ * sequential access of large files without extra "magic" comprise *BSD,
+ * Darwin, IRIX...
+ */
+#ifndef _FILE_OFFSET_BITS
+#define _FILE_OFFSET_BITS 64
+#endif
+#endif
+
 #include <stdio.h>
 #include <errno.h>
 #include "cryptlib.h"
-#include <openssl/bio.h>
+#include "bio_lcl.h"
 #include <openssl/err.h>
 
+#if defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_CLIB)
+#include <nwfileio.h>
+#endif
+
 #if !defined(OPENSSL_NO_STDIO)
 
 static int MS_CALLBACK file_write(BIO *h, const char *buf, int num);
@@ -110,8 +132,12 @@ BIO *BIO_new_file(const char *filename, const char *mode)
                 return(NULL);
                 }
         if ((ret=BIO_new(BIO_s_file_internal())) == NULL)
+                {
+                fclose(file);
                 return(NULL);
+                }
 
+        BIO_clear_flags(ret,BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */
         BIO_set_fp(ret,file,BIO_CLOSE);
         return(ret);
         }
@@ -123,6 +149,7 @@ BIO *BIO_new_fp(FILE *stream, int close_flag)
         if ((ret=BIO_new(BIO_s_file())) == NULL)
                 return(NULL);
 
+        BIO_set_flags(ret,BIO_FLAGS_UPLINK); /* redundant, left for documentation puposes */
         BIO_set_fp(ret,stream,close_flag);
         return(ret);
         }
@@ -137,6 +164,7 @@ static int MS_CALLBACK file_new(BIO *bi)
         bi->init=0;
         bi->num=0;
         bi->ptr=NULL;
+        bi->flags=BIO_FLAGS_UPLINK; /* default to UPLINK */
         return(1);
         }
 
@@ -147,8 +175,12 @@ static int MS_CALLBACK file_free(BIO *a)
                 {
                 if ((a->init) && (a->ptr != NULL))
                         {
-                        fclose((FILE *)a->ptr);
+                        if (a->flags&BIO_FLAGS_UPLINK)
+                                UP_fclose (a->ptr);
+                        else
+                                fclose (a->ptr);
                         a->ptr=NULL;
+                        a->flags=BIO_FLAGS_UPLINK;
                         }
                 a->init=0;
                 }
@@ -161,8 +193,11 @@ static int MS_CALLBACK file_read(BIO *b, char *out, int outl)
 
         if (b->init && (out != NULL))
                 {
-                ret=fread(out,1,(int)outl,(FILE *)b->ptr);
-                if(ret == 0 && ferror((FILE *)b->ptr))
+                if (b->flags&BIO_FLAGS_UPLINK)
+                        ret=UP_fread(out,1,(int)outl,b->ptr);
+                else
+                        ret=fread(out,1,(int)outl,(FILE *)b->ptr);
+                if(ret == 0 && (b->flags&BIO_FLAGS_UPLINK)?UP_ferror((FILE *)b->ptr):ferror((FILE *)b->ptr))
                         {
                         SYSerr(SYS_F_FREAD,get_last_sys_error());
                         BIOerr(BIO_F_FILE_READ,ERR_R_SYS_LIB);
@@ -178,7 +213,11 @@ static int MS_CALLBACK file_write(BIO *b, const char *in, int inl)
 
         if (b->init && (in != NULL))
                 {
-                if (fwrite(in,(int)inl,1,(FILE *)b->ptr))
+                if (b->flags&BIO_FLAGS_UPLINK)
+                        ret=UP_fwrite(in,(int)inl,1,b->ptr);
+                else
+                        ret=fwrite(in,(int)inl,1,(FILE *)b->ptr);
+                if (ret)
                         ret=inl;
                 /* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */
                 /* according to Tim Hudson <tjh@cryptsoft.com>, the commented
@@ -199,20 +238,45 @@ static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr)
                 {
         case BIO_C_FILE_SEEK:
         case BIO_CTRL_RESET:
-                ret=(long)fseek(fp,num,SEEK_SET);
+                if (b->flags&BIO_FLAGS_UPLINK)
+                        ret=(long)UP_fseek(b->ptr,num,0);
+                else
+                        ret=(long)fseek(fp,num,SEEK_SET);
                 break;
         case BIO_CTRL_EOF:
-                ret=(long)feof(fp);
+                if (b->flags&BIO_FLAGS_UPLINK)
+                        ret=(long)UP_feof(fp);
+                else
+                        ret=(long)feof(fp);
                 break;
         case BIO_C_FILE_TELL:
         case BIO_CTRL_INFO:
-                ret=ftell(fp);
+                if (b->flags&BIO_FLAGS_UPLINK)
+                        ret=UP_ftell(b->ptr);
+                else
+                        ret=ftell(fp);
                 break;
         case BIO_C_SET_FILE_PTR:
                 file_free(b);
                 b->shutdown=(int)num&BIO_CLOSE;
-                b->ptr=(char *)ptr;
+                b->ptr=ptr;
                 b->init=1;
+#if BIO_FLAGS_UPLINK!=0
+#if defined(__MINGW32__) && defined(__MSVCRT__) && !defined(_IOB_ENTRIES)
+#define _IOB_ENTRIES 20
+#endif
+#if defined(_IOB_ENTRIES)
+                /* Safety net to catch purely internal BIO_set_fp calls */
+                if ((size_t)ptr >= (size_t)stdin &&
+                    (size_t)ptr <  (size_t)(stdin+_IOB_ENTRIES))
+                        BIO_clear_flags(b,BIO_FLAGS_UPLINK);
+#endif
+#endif
+#ifdef UP_fsetmode
+                if (b->flags&BIO_FLAGS_UPLINK)
+                        UP_fsetmode(b->ptr,num&BIO_FP_TEXT?'t':'b');
+                else
+#endif
                 {
 #if defined(OPENSSL_SYS_WINDOWS)
                 int fd = fileno((FILE*)ptr);
@@ -220,6 +284,14 @@ static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr)
                         _setmode(fd,_O_TEXT);
                 else
                         _setmode(fd,_O_BINARY);
+#elif defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_CLIB)
+                int fd = fileno((FILE*)ptr);
+         /* Under CLib there are differences in file modes
+         */
+                if (num & BIO_FP_TEXT)
+                        setmode(fd,O_TEXT);
+                else
+                        setmode(fd,O_BINARY);
 #elif defined(OPENSSL_SYS_MSDOS)
                 int fd = fileno((FILE*)ptr);
                 /* Set correct text/binary mode */
@@ -272,6 +344,12 @@ static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr)
                 else
                         strcat(p,"t");
 #endif
+#if defined(OPENSSL_SYS_NETWARE)
+                if (!(num & BIO_FP_TEXT))
+                        strcat(p,"b");
+                else
+                        strcat(p,"t");
+#endif
                 fp=fopen(ptr,p);
                 if (fp == NULL)
                         {
@@ -281,8 +359,9 @@ static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr)
                         ret=0;
                         break;
                         }
-                b->ptr=(char *)fp;
+                b->ptr=fp;
                 b->init=1;
+                BIO_clear_flags(b,BIO_FLAGS_UPLINK); /* we did fopen -> we disengage UPLINK */
                 break;
         case BIO_C_GET_FILE_PTR:
                 /* the ptr parameter is actually a FILE ** in this case. */
@@ -299,7 +378,10 @@ static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, void *ptr)
                 b->shutdown=(int)num;
                 break;
         case BIO_CTRL_FLUSH:
-                fflush((FILE *)b->ptr);
+                if (b->flags&BIO_FLAGS_UPLINK)
+                        UP_fflush(b->ptr);
+                else
+                        fflush((FILE *)b->ptr);
                 break;
         case BIO_CTRL_DUP:
                 ret=1;
@@ -321,7 +403,10 @@ static int MS_CALLBACK file_gets(BIO *bp, char *buf, int size)
         int ret=0;
 
         buf[0]='\0';
-        fgets(buf,size,(FILE *)bp->ptr);
+        if (bp->flags&BIO_FLAGS_UPLINK)
+                UP_fgets(buf,size,bp->ptr);
+        else
+                fgets(buf,size,(FILE *)bp->ptr);
         if (buf[0] != '\0')
                 ret=strlen(buf);
         return(ret);
diff --git a/src/lib/libcrypto/bio/bss_log.c b/src/lib/libcrypto/bio/bss_log.c
index 1eb678cac0..6360dbc820 100644
--- a/src/lib/libcrypto/bio/bss_log.c
+++ b/src/lib/libcrypto/bio/bss_log.c
@@ -78,6 +78,8 @@
 #  include <starlet.h>
 #elif defined(__ultrix)
 #  include <sys/syslog.h>
+#elif defined(OPENSSL_SYS_NETWARE)
+#  define NO_SYSLOG
 #elif (!defined(MSDOS) || defined(WATT32)) && !defined(OPENSSL_SYS_VXWORKS) && !defined(NO_SYSLOG)
 #  include <syslog.h>
 #endif
diff --git a/src/lib/libcrypto/bio/bss_sock.c b/src/lib/libcrypto/bio/bss_sock.c
index 2c1c405ec7..472dd75821 100644
--- a/src/lib/libcrypto/bio/bss_sock.c
+++ b/src/lib/libcrypto/bio/bss_sock.c
@@ -56,8 +56,6 @@
  * [including the GNU Public Licence.]
  */
 
-#ifndef OPENSSL_NO_SOCK
-
 #include <stdio.h>
 #include <errno.h>
 #define USE_SOCKETS
@@ -248,7 +246,7 @@ int BIO_sock_non_fatal_error(int err)
         {
         switch (err)
                 {
-#if defined(OPENSSL_SYS_WINDOWS)
+#if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_NETWARE)
 # if defined(WSAEWOULDBLOCK)
         case WSAEWOULDBLOCK:
 # endif
@@ -279,7 +277,7 @@ int BIO_sock_non_fatal_error(int err)
 #endif
 
 #ifdef EAGAIN
-#if EWOULDBLOCK != EAGAIN
+# if EWOULDBLOCK != EAGAIN
         case EAGAIN:
 # endif
 #endif
@@ -302,4 +300,3 @@ int BIO_sock_non_fatal_error(int err)
                 }
         return(0);
         }
-#endif