OpenSSL 0.9.5a merge

7 files changed, 378 insertions, 124 deletions

diff --git a/src/lib/libcrypto/bio/Makefile.ssl b/src/lib/libcrypto/bio/Makefile.ssl
index 2e7480ead9..755f255fe4 100644
--- a/src/lib/libcrypto/bio/Makefile.ssl
+++ b/src/lib/libcrypto/bio/Makefile.ssl
@@ -172,8 +172,10 @@ bss_acpt.o: ../../include/openssl/opensslconf.h
 bss_acpt.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
 bss_acpt.o: ../../include/openssl/stack.h ../cryptlib.h
 bss_bio.o: ../../include/openssl/bio.h ../../include/openssl/crypto.h
-bss_bio.o: ../../include/openssl/err.h ../../include/openssl/opensslv.h
-bss_bio.o: ../../include/openssl/safestack.h ../../include/openssl/stack.h
+bss_bio.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+bss_bio.o: ../../include/openssl/err.h ../../include/openssl/opensslconf.h
+bss_bio.o: ../../include/openssl/opensslv.h ../../include/openssl/safestack.h
+bss_bio.o: ../../include/openssl/stack.h
 bss_conn.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
 bss_conn.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
 bss_conn.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
diff --git a/src/lib/libcrypto/bio/b_print.c b/src/lib/libcrypto/bio/b_print.c
index 2a5e8b58c9..b11b501512 100644
--- a/src/lib/libcrypto/bio/b_print.c
+++ b/src/lib/libcrypto/bio/b_print.c
@@ -64,6 +64,8 @@
 #include <stdarg.h>
 #include <string.h>
 #include <ctype.h>
+#include <assert.h>
+#include <limits.h>
 #include "cryptlib.h"
 #ifndef NO_SYS_TYPES_H
 #include <sys/types.h>
@@ -72,12 +74,16 @@
 
 #ifdef BN_LLONG
 # ifndef HAVE_LONG_LONG
-#  define HAVE_LONG_LONG
+#  define HAVE_LONG_LONG 1
 # endif
 #endif
 
 static void dopr (char *buffer, size_t maxlen, size_t *retlen,
         const char *format, va_list args);
+#ifdef USE_ALLOCATING_PRINT
+static void doapr (char **buffer, size_t *retlen,
+        const char *format, va_list args);
+#endif
 
 int BIO_printf (BIO *bio, ...)
         {
@@ -85,15 +91,32 @@ int BIO_printf (BIO *bio, ...)
         char *format;
         int ret;
         size_t retlen;
+#ifdef USE_ALLOCATING_PRINT
+        char *hugebuf;
+#else
         MS_STATIC char hugebuf[1024*2]; /* 10k in one chunk is the limit */
+#endif
 
         va_start(args, bio);
         format=va_arg(args, char *);
 
+#ifndef USE_ALLOCATING_PRINT
         hugebuf[0]='\0';
         dopr(hugebuf, sizeof(hugebuf), &retlen, format, args);
-        ret=BIO_write(bio, hugebuf, (int)retlen);
+#else
+        hugebuf = NULL;
+        CRYPTO_push_info("doapr()");
+        doapr(&hugebuf, &retlen, format, args);
+        if (hugebuf)
+                {
+#endif
+                ret=BIO_write(bio, hugebuf, (int)retlen);
 
+#ifdef USE_ALLOCATING_PRINT
+                Free(hugebuf);
+                }
+        CRYPTO_pop_info();
+#endif
         va_end(args);
         return(ret);
         }
@@ -131,10 +154,26 @@ int BIO_printf (BIO *bio, ...)
 #define LLONG long
 #endif
 
-static void fmtstr     (char *, size_t *, size_t, char *, int, int, int);
-static void fmtint     (char *, size_t *, size_t, LLONG, int, int, int, int);
-static void fmtfp      (char *, size_t *, size_t, LDOUBLE, int, int, int);
-static void dopr_outch (char *, size_t *, size_t, int);
+static void fmtstr     (void (*)(char **, size_t *, size_t *, int),
+                        char **, size_t *, size_t *, const char *, int, int,
+                        int);
+static void fmtint     (void (*)(char **, size_t *, size_t *, int),
+                        char **, size_t *, size_t *, LLONG, int, int, int, int);
+static void fmtfp      (void (*)(char **, size_t *, size_t *, int),
+                        char **, size_t *, size_t *, LDOUBLE, int, int, int);
+#ifndef USE_ALLOCATING_PRINT
+static int dopr_isbig (size_t, size_t);
+static int dopr_copy (size_t);
+static void dopr_outch (char **, size_t *, size_t *, int);
+#else
+static int doapr_isbig (size_t, size_t);
+static int doapr_copy (size_t);
+static void doapr_outch (char **, size_t *, size_t *, int);
+#endif
+static void _dopr(void (*)(char **, size_t *, size_t *, int),
+                  int (*)(size_t, size_t), int (*)(size_t),
+                  char **buffer, size_t *maxlen, size_t *retlen,
+                  const char *format, va_list args);
 
 /* format read states */
 #define DP_S_DEFAULT    0
@@ -165,6 +204,7 @@ static void dopr_outch (char *, size_t *, size_t, int);
 #define char_to_int(p) (p - '0')
 #define MAX(p,q) ((p >= q) ? p : q)
 
+#ifndef USE_ALLOCATING_PRINT
 static void
 dopr(
     char *buffer,
@@ -173,6 +213,35 @@ dopr(
     const char *format,
     va_list args)
 {
+    _dopr(dopr_outch, dopr_isbig, dopr_copy,
+          &buffer, &maxlen, retlen, format, args);
+}
+
+#else
+static void
+doapr(
+    char **buffer,
+    size_t *retlen,
+    const char *format,
+    va_list args)
+{
+    size_t dummy_maxlen = 0;
+    _dopr(doapr_outch, doapr_isbig, doapr_copy,
+          buffer, &dummy_maxlen, retlen, format, args);
+}
+#endif
+
+static void
+_dopr(
+    void (*outch_fn)(char **, size_t *, size_t *, int),
+    int (*isbig_fn)(size_t, size_t),
+    int (*copy_fn)(size_t),
+    char **buffer,
+    size_t *maxlen,
+    size_t *retlen,
+    const char *format,
+    va_list args)
+{
     char ch;
     LLONG value;
     LDOUBLE fvalue;
@@ -190,7 +259,7 @@ dopr(
     ch = *format++;
 
     while (state != DP_S_DONE) {
-        if ((ch == '\0') || (currlen >= maxlen))
+        if ((ch == '\0') || (*isbig_fn)(currlen, *maxlen))
             state = DP_S_DONE;
 
         switch (state) {
@@ -198,7 +267,7 @@ dopr(
             if (ch == '%')
                 state = DP_S_FLAGS;
             else
-                dopr_outch(buffer, &currlen, maxlen, ch);
+                (*outch_fn)(buffer, &currlen, maxlen, ch);
             ch = *format++;
             break;
         case DP_S_FLAGS:
@@ -304,7 +373,8 @@ dopr(
                     value = va_arg(args, int);
                     break;
                 }
-                fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
+                fmtint(outch_fn, buffer, &currlen, maxlen,
+                       value, 10, min, max, flags);
                 break;
             case 'X':
                 flags |= DP_F_UP;
@@ -329,7 +399,7 @@ dopr(
                         unsigned int);
                     break;
                 }
-                fmtint(buffer, &currlen, maxlen, value,
+                fmtint(outch_fn, buffer, &currlen, maxlen, value,
                        ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
                        min, max, flags);
                 break;
@@ -338,7 +408,8 @@ dopr(
                     fvalue = va_arg(args, LDOUBLE);
                 else
                     fvalue = va_arg(args, double);
-                fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
+                fmtfp(outch_fn, buffer, &currlen, maxlen,
+                      fvalue, min, max, flags);
                 break;
             case 'E':
                 flags |= DP_F_UP;
@@ -357,19 +428,19 @@ dopr(
                     fvalue = va_arg(args, double);
                 break;
             case 'c':
-                dopr_outch(buffer, &currlen, maxlen,
+                (*outch_fn)(buffer, &currlen, maxlen,
                     va_arg(args, int));
                 break;
             case 's':
                 strvalue = va_arg(args, char *);
                 if (max < 0)
-                    max = maxlen;
-                fmtstr(buffer, &currlen, maxlen, strvalue,
-                    flags, min, max);
+                    max = (*copy_fn)(*maxlen);
+                fmtstr(outch_fn, buffer, &currlen, maxlen, strvalue,
+                       flags, min, max);
                 break;
             case 'p':
                 value = (long)va_arg(args, void *);
-                fmtint(buffer, &currlen, maxlen,
+                fmtint(outch_fn, buffer, &currlen, maxlen,
                     value, 16, min, max, flags);
                 break;
             case 'n': /* XXX */
@@ -392,7 +463,7 @@ dopr(
                 }
                 break;
             case '%':
-                dopr_outch(buffer, &currlen, maxlen, ch);
+                (*outch_fn)(buffer, &currlen, maxlen, ch);
                 break;
             case 'w':
                 /* not supported yet, treat as next char */
@@ -413,19 +484,20 @@ dopr(
             break;
         }
     }
-    if (currlen >= maxlen - 1)
-        currlen = maxlen - 1;
-    buffer[currlen] = '\0';
+    if (currlen >= *maxlen - 1)
+        currlen = *maxlen - 1;
+    (*buffer)[currlen] = '\0';
     *retlen = currlen;
     return;
 }
 
 static void
 fmtstr(
-    char *buffer,
+    void (*outch_fn)(char **, size_t *, size_t *, int),
+    char **buffer,
     size_t *currlen,
-    size_t maxlen,
-    char *value,
+    size_t *maxlen,
+    const char *value,
     int flags,
     int min,
     int max)
@@ -444,16 +516,16 @@ fmtstr(
         padlen = -padlen;
 
     while ((padlen > 0) && (cnt < max)) {
-        dopr_outch(buffer, currlen, maxlen, ' ');
+        (*outch_fn)(buffer, currlen, maxlen, ' ');
         --padlen;
         ++cnt;
     }
     while (*value && (cnt < max)) {
-        dopr_outch(buffer, currlen, maxlen, *value++);
+        (*outch_fn)(buffer, currlen, maxlen, *value++);
         ++cnt;
     }
     while ((padlen < 0) && (cnt < max)) {
-        dopr_outch(buffer, currlen, maxlen, ' ');
+        (*outch_fn)(buffer, currlen, maxlen, ' ');
         ++padlen;
         ++cnt;
     }
@@ -461,9 +533,10 @@ fmtstr(
 
 static void
 fmtint(
-    char *buffer,
+    void (*outch_fn)(char **, size_t *, size_t *, int),
+    char **buffer,
     size_t *currlen,
-    size_t maxlen,
+    size_t *maxlen,
     LLONG value,
     int base,
     int min,
@@ -517,28 +590,28 @@ fmtint(
 
     /* spaces */
     while (spadlen > 0) {
-        dopr_outch(buffer, currlen, maxlen, ' ');
+        (*outch_fn)(buffer, currlen, maxlen, ' ');
         --spadlen;
     }
 
     /* sign */
     if (signvalue)
-        dopr_outch(buffer, currlen, maxlen, signvalue);
+        (*outch_fn)(buffer, currlen, maxlen, signvalue);
 
     /* zeros */
     if (zpadlen > 0) {
         while (zpadlen > 0) {
-            dopr_outch(buffer, currlen, maxlen, '0');
+            (*outch_fn)(buffer, currlen, maxlen, '0');
             --zpadlen;
         }
     }
     /* digits */
     while (place > 0)
-        dopr_outch(buffer, currlen, maxlen, convert[--place]);
+        (*outch_fn)(buffer, currlen, maxlen, convert[--place]);
 
     /* left justified spaces */
     while (spadlen < 0) {
-        dopr_outch(buffer, currlen, maxlen, ' ');
+        (*outch_fn)(buffer, currlen, maxlen, ' ');
         ++spadlen;
     }
     return;
@@ -577,9 +650,10 @@ round(LDOUBLE value)
 
 static void
 fmtfp(
-    char *buffer,
+    void (*outch_fn)(char **, size_t *, size_t *, int),
+    char **buffer,
     size_t *currlen,
-    size_t maxlen,
+    size_t *maxlen,
     LDOUBLE fvalue,
     int min,
     int max,
@@ -657,54 +731,114 @@ fmtfp(
 
     if ((flags & DP_F_ZERO) && (padlen > 0)) {
         if (signvalue) {
-            dopr_outch(buffer, currlen, maxlen, signvalue);
+            (*outch_fn)(buffer, currlen, maxlen, signvalue);
             --padlen;
             signvalue = 0;
         }
         while (padlen > 0) {
-            dopr_outch(buffer, currlen, maxlen, '0');
+            (*outch_fn)(buffer, currlen, maxlen, '0');
             --padlen;
         }
     }
     while (padlen > 0) {
-        dopr_outch(buffer, currlen, maxlen, ' ');
+        (*outch_fn)(buffer, currlen, maxlen, ' ');
         --padlen;
     }
     if (signvalue)
-        dopr_outch(buffer, currlen, maxlen, signvalue);
+        (*outch_fn)(buffer, currlen, maxlen, signvalue);
 
     while (iplace > 0)
-        dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]);
+        (*outch_fn)(buffer, currlen, maxlen, iconvert[--iplace]);
 
     /*
      * Decimal point. This should probably use locale to find the correct
      * char to print out.
      */
     if (max > 0) {
-        dopr_outch(buffer, currlen, maxlen, '.');
+        (*outch_fn)(buffer, currlen, maxlen, '.');
 
         while (fplace > 0)
-            dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]);
+            (*outch_fn)(buffer, currlen, maxlen, fconvert[--fplace]);
     }
     while (zpadlen > 0) {
-        dopr_outch(buffer, currlen, maxlen, '0');
+        (*outch_fn)(buffer, currlen, maxlen, '0');
         --zpadlen;
     }
 
     while (padlen < 0) {
-        dopr_outch(buffer, currlen, maxlen, ' ');
+        (*outch_fn)(buffer, currlen, maxlen, ' ');
         ++padlen;
     }
 }
 
+static int
+dopr_copy(
+    size_t len)
+{
+    return len;
+}
+
+#ifdef USE_ALLOCATING_PRINT
+static int
+doapr_copy(
+    size_t len)
+{
+    /* Return as high an integer as possible */
+    return INT_MAX;
+}
+#endif
+
+static int
+dopr_isbig(
+    size_t currlen,
+    size_t maxlen)
+{
+    return currlen > maxlen;
+}
+
+#ifdef USE_ALLOCATING_PRINT
+static int
+doapr_isbig(
+    size_t currlen,
+    size_t maxlen)
+{
+    return 0;
+}
+#endif
+
 static void
 dopr_outch(
-    char *buffer,
+    char **buffer,
     size_t *currlen,
-    size_t maxlen,
+    size_t *maxlen,
+    int c)
+{
+    if (*currlen < *maxlen)
+        (*buffer)[(*currlen)++] = (char)c;
+    return;
+}
+
+#ifdef USE_ALLOCATING_PRINT
+static void
+doapr_outch(
+    char **buffer,
+    size_t *currlen,
+    size_t *maxlen,
     int c)
 {
-    if (*currlen < maxlen)
-        buffer[(*currlen)++] = (char)c;
+    if (*buffer == NULL) {
+        if (*maxlen == 0)
+            *maxlen = 1024;
+        *buffer = Malloc(*maxlen);
+    }
+    while (*currlen >= *maxlen) {
+        *maxlen += 1024;
+        *buffer = Realloc(*buffer, *maxlen);
+    }
+    /* What to do if *buffer is NULL? */
+    assert(*buffer != NULL);
+
+    (*buffer)[(*currlen)++] = (char)c;
     return;
 }
+#endif
diff --git a/src/lib/libcrypto/bio/bio.h b/src/lib/libcrypto/bio/bio.h
index bc08401eeb..ebdb18170b 100644
--- a/src/lib/libcrypto/bio/bio.h
+++ b/src/lib/libcrypto/bio/bio.h
@@ -507,7 +507,7 @@ int	BIO_set(BIO *a,BIO_METHOD *type);
 int     BIO_free(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, const char *data, int len);
+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 *bp,int cmd,void (*fp)());
diff --git a/src/lib/libcrypto/bio/bio_err.c b/src/lib/libcrypto/bio/bio_err.c
index b5f07de5a0..f38e7b9178 100644
--- a/src/lib/libcrypto/bio/bio_err.c
+++ b/src/lib/libcrypto/bio/bio_err.c
@@ -54,7 +54,8 @@
  */
 
 /* 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.
+ * made to it will be overwritten when the script next updates this file,
+ * only reason strings will be preserved.
  */
 
 #include <stdio.h>
diff --git a/src/lib/libcrypto/bio/bio_lib.c b/src/lib/libcrypto/bio/bio_lib.c
index cf8e6150fd..e88dcc80f3 100644
--- a/src/lib/libcrypto/bio/bio_lib.c
+++ b/src/lib/libcrypto/bio/bio_lib.c
@@ -169,7 +169,7 @@ int BIO_read(BIO *b, void *out, int outl)
         return(i);
         }
 
-int BIO_write(BIO *b, const char *in, int inl)
+int BIO_write(BIO *b, const void *in, int inl)
         {
         int i;
         long (*cb)();
diff --git a/src/lib/libcrypto/bio/bss_bio.c b/src/lib/libcrypto/bio/bss_bio.c
index 0d0f9356f7..1e2d7491f2 100644
--- a/src/lib/libcrypto/bio/bss_bio.c
+++ b/src/lib/libcrypto/bio/bss_bio.c
@@ -19,8 +19,14 @@
 
 #include <openssl/bio.h>
 #include <openssl/err.h>
+#include <openssl/err.h>
 #include <openssl/crypto.h>
 
+#include "openssl/e_os.h"
+#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);
@@ -205,10 +211,10 @@ static int bio_read(BIO *bio, char *buf, int size_)
  */
 /* WARNING: The non-copying interface is largely untested as of yet
  * and may contain bugs. */
-static size_t bio_nread0(BIO *bio, char **buf)
+static ssize_t bio_nread0(BIO *bio, char **buf)
         {
         struct bio_bio_st *b, *peer_b;
-        size_t num;
+        ssize_t num;
         
         BIO_clear_retry_flags(bio);
 
@@ -243,15 +249,20 @@ static size_t bio_nread0(BIO *bio, char **buf)
         return num;
         }
 
-static size_t bio_nread(BIO *bio, char **buf, size_t num)
+static ssize_t bio_nread(BIO *bio, char **buf, size_t num_)
         {
         struct bio_bio_st *b, *peer_b;
-        size_t available;
+        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)
+        if (num <= 0)
                 return num;
 
         b = bio->ptr;
@@ -351,7 +362,7 @@ static int bio_write(BIO *bio, char *buf, int num_)
  * (example usage:  bio_nwrite0(), write to buffer, bio_nwrite()
  *  or just         bio_nwrite(), write to buffer)
  */
-static size_t bio_nwrite0(BIO *bio, char **buf)
+static ssize_t bio_nwrite0(BIO *bio, char **buf)
         {
         struct bio_bio_st *b;
         size_t num;
@@ -399,15 +410,20 @@ static size_t bio_nwrite0(BIO *bio, char **buf)
         return num;
         }
 
-static size_t bio_nwrite(BIO *bio, char **buf, size_t num)
+static ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_)
         {
         struct bio_bio_st *b;
-        size_t space;
+        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)
+        if (num <= 0)
                 return num;
         b = bio->ptr;
         assert(b != NULL);
@@ -509,6 +525,11 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
                 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);
diff --git a/src/lib/libcrypto/bio/bss_log.c b/src/lib/libcrypto/bio/bss_log.c
index 4308b19663..497eb1af72 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,29 +66,58 @@
 #include <stdio.h>
 #include <errno.h>
 
-#ifndef WIN32
-#ifdef __ultrix
-#include <sys/syslog.h>
-#else
-#include <syslog.h>
-#endif
-#else
-#include <process.h>
+#if defined(WIN32)
+#  include <process.h>
+#elif defined(VMS) || defined(__VMS)
+#  include <opcdef.h>
+#  include <descrip.h>
+#  include <lib$routines.h>
+#  include <starlet.h>
+#elif defined(__ultrix)
+#  include <sys/syslog.h>
+#elif !defined(MSDOS) /* Unix */
+#  include <syslog.h>
 #endif
 
 #include "cryptlib.h"
 #include <openssl/buffer.h>
 #include <openssl/err.h>
+
 #ifndef NO_SYSLOG
 
+#if defined(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
+
+#define LOG_DAEMON      (3<<3)
+#elif defined(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,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);
 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, const char* name, int level);
+static void xsyslog(BIO* bp, int priority, const char* string);
+static void xcloselog(BIO* bp);
 
 static BIO_METHOD methods_slg=
         {
@@ -113,11 +142,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);
         }
 
@@ -133,43 +158,14 @@ static int MS_CALLBACK slg_write(BIO *b, char *in, int inl)
         int ret= inl;
         char* buf= in;
         char* pp;
-#if defined(WIN32)
-        LPCSTR lpszStrings[2];
-        WORD evtype= EVENTLOG_ERROR_TYPE;
-        int pid = _getpid();
-        char pidbuf[20];
-#else
         int priority;
-#endif
 
         if((buf= (char *)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;
-        }
 
-        sprintf(pidbuf, "[%d] ", pid);
-        lpszStrings[0] = pidbuf;
-        lpszStrings[1] = pp;
-
-        if(b->ptr)
-                ReportEvent(b->ptr, evtype, 0, 1024, NULL, 2, 0,
-                                lpszStrings, NULL);
-#else
         if(strncmp(buf, "ERR ", 4) == 0){
                 priority= LOG_ERR;
                 pp= buf+ 4;
@@ -184,8 +180,8 @@ static int MS_CALLBACK slg_write(BIO *b, char *in, int inl)
                 pp= buf;
         }
 
-        syslog(priority, "%s", pp);
-#endif
+        xsyslog(b, priority, pp);
+
         Free(buf);
         return(ret);
         }
@@ -213,28 +209,128 @@ static int MS_CALLBACK slg_puts(BIO *bp, char *str)
         return(ret);
         }
 
-static int xopenlog(BIO* bp, const 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);
+
+static void xopenlog(BIO* bp, const char* name, int level)
+{
+        bp->ptr= (char *)RegisterEventSource(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_ERR:
+                evtype = EVENTLOG_ERROR_TYPE;
+                break;
+        case LOG_WARNING:
+                evtype = EVENTLOG_WARNING_TYPE;
+                break;
+        case LOG_INFO:
+                evtype = EVENTLOG_INFORMATION_TYPE;
+                break;
+        default:
+                evtype = EVENTLOG_ERROR_TYPE;
+                break;
+                }
+
+        sprintf(pidbuf, "[%d] ", pid);
+        lpszStrings[0] = pidbuf;
+        lpszStrings[1] = string;
+
+        if(bp->ptr)
+                ReportEvent(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));
         bp->ptr= NULL;
-#else
+}
+
+#elif defined(VMS)
+
+static int VMS_OPC_target = LOG_DAEMON;
+
+static void xopenlog(BIO* bp, const 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 *) 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);
+
+        Free(opcdef_p);
+}
+
+static void xcloselog(BIO* bp)
+{
+}
+
+#else /* Unix */
+
+static void xopenlog(BIO* bp, const 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 */