This commit was manufactured by cvs2git to create branch 'unlabeled-1.1.1'.

3 files changed, 1217 insertions, 0 deletions

diff --git a/src/lib/libcrypto/bio/bf_lbuf.c b/src/lib/libcrypto/bio/bf_lbuf.c
new file mode 100644
index 0000000000..7bcf8ed941
--- /dev/null
+++ b/src/lib/libcrypto/bio/bf_lbuf.c
@@ -0,0 +1,397 @@
+/* crypto/bio/bf_buff.c */
+/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
+ * 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.
+ * 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.]
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include "cryptlib.h"
+#include <openssl/bio.h>
+#include <openssl/evp.h>
+
+static int linebuffer_write(BIO *h, const char *buf,int num);
+static int linebuffer_read(BIO *h, char *buf, int size);
+static int linebuffer_puts(BIO *h, const char *str);
+static int linebuffer_gets(BIO *h, char *str, int size);
+static long linebuffer_ctrl(BIO *h, int cmd, long arg1, void *arg2);
+static int linebuffer_new(BIO *h);
+static int linebuffer_free(BIO *data);
+static long linebuffer_callback_ctrl(BIO *h, int cmd, bio_info_cb *fp);
+
+/* A 10k maximum should be enough for most purposes */
+#define DEFAULT_LINEBUFFER_SIZE 1024*10
+
+/* #define DEBUG */
+
+static BIO_METHOD methods_linebuffer=
+        {
+        BIO_TYPE_LINEBUFFER,
+        "linebuffer",
+        linebuffer_write,
+        linebuffer_read,
+        linebuffer_puts,
+        linebuffer_gets,
+        linebuffer_ctrl,
+        linebuffer_new,
+        linebuffer_free,
+        linebuffer_callback_ctrl,
+        };
+
+BIO_METHOD *BIO_f_linebuffer(void)
+        {
+        return(&methods_linebuffer);
+        }
+
+typedef struct bio_linebuffer_ctx_struct
+        {
+        char *obuf;             /* the output char array */
+        int obuf_size;          /* how big is the output buffer */
+        int obuf_len;           /* how many bytes are in it */
+        } BIO_LINEBUFFER_CTX;
+
+static int linebuffer_new(BIO *bi)
+        {
+        BIO_LINEBUFFER_CTX *ctx;
+
+        ctx=(BIO_LINEBUFFER_CTX *)OPENSSL_malloc(sizeof(BIO_LINEBUFFER_CTX));
+        if (ctx == NULL) return(0);
+        ctx->obuf=(char *)OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE);
+        if (ctx->obuf == NULL) { OPENSSL_free(ctx); return(0); }
+        ctx->obuf_size=DEFAULT_LINEBUFFER_SIZE;
+        ctx->obuf_len=0;
+
+        bi->init=1;
+        bi->ptr=(char *)ctx;
+        bi->flags=0;
+        return(1);
+        }
+
+static int linebuffer_free(BIO *a)
+        {
+        BIO_LINEBUFFER_CTX *b;
+
+        if (a == NULL) return(0);
+        b=(BIO_LINEBUFFER_CTX *)a->ptr;
+        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 linebuffer_read(BIO *b, char *out, int outl)
+        {
+        int ret=0;
+ 
+        if (out == NULL) return(0);
+        if (b->next_bio == NULL) return(0);
+        ret=BIO_read(b->next_bio,out,outl);
+        BIO_clear_retry_flags(b);
+        BIO_copy_next_retry(b);
+        return(ret);
+        }
+
+static int linebuffer_write(BIO *b, const char *in, int inl)
+        {
+        int i,num=0,foundnl;
+        BIO_LINEBUFFER_CTX *ctx;
+
+        if ((in == NULL) || (inl <= 0)) return(0);
+        ctx=(BIO_LINEBUFFER_CTX *)b->ptr;
+        if ((ctx == NULL) || (b->next_bio == NULL)) return(0);
+
+        BIO_clear_retry_flags(b);
+
+        do
+                {
+                const char *p;
+
+                for(p = in; p < in + inl && *p != '\n'; p++)
+                        ;
+                if (*p == '\n')
+                        {
+                        p++;
+                        foundnl = 1;
+                        }
+                else
+                        foundnl = 0;
+
+                /* If a NL was found and we already have text in the save
+                   buffer, concatenate them and write */
+                while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len)
+                        && ctx->obuf_len > 0)
+                        {
+                        int orig_olen = ctx->obuf_len;
+                        
+                        i = ctx->obuf_size - ctx->obuf_len;
+                        if (p - in > 0)
+                                {
+                                if (i >= p - in)
+                                        {
+                                        memcpy(&(ctx->obuf[ctx->obuf_len]),
+                                                in,p - in);
+                                        ctx->obuf_len += p - in;
+                                        inl -= p - in;
+                                        num += p - in;
+                                        in = p;
+                                        }
+                                else
+                                        {
+                                        memcpy(&(ctx->obuf[ctx->obuf_len]),
+                                                in,i);
+                                        ctx->obuf_len += i;
+                                        inl -= i;
+                                        in += i;
+                                        num += i;
+                                        }
+                                }
+
+#ifdef DEBUG
+BIO_write(b->next_bio, "<*<", 3);
+#endif
+                        i=BIO_write(b->next_bio,
+                                ctx->obuf, ctx->obuf_len);
+                        if (i <= 0)
+                                {
+                                ctx->obuf_len = orig_olen;
+                                BIO_copy_next_retry(b);
+
+#ifdef DEBUG
+BIO_write(b->next_bio, ">*>", 3);
+#endif
+                                if (i < 0) return((num > 0)?num:i);
+                                if (i == 0) return(num);
+                                }
+#ifdef DEBUG
+BIO_write(b->next_bio, ">*>", 3);
+#endif
+                        if (i < ctx->obuf_len)
+                                memmove(ctx->obuf, ctx->obuf + i,
+                                        ctx->obuf_len - i);
+                        ctx->obuf_len-=i;
+                        }
+
+                /* Now that the save buffer is emptied, let's write the input
+                   buffer if a NL was found and there is anything to write. */
+                if ((foundnl || p - in > ctx->obuf_size) && p - in > 0)
+                        {
+#ifdef DEBUG
+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
+BIO_write(b->next_bio, ">*>", 3);
+#endif
+                                if (i < 0) return((num > 0)?num:i);
+                                if (i == 0) return(num);
+                                }
+#ifdef DEBUG
+BIO_write(b->next_bio, ">*>", 3);
+#endif
+                        num+=i;
+                        in+=i;
+                        inl-=i;
+                        }
+                }
+        while(foundnl && inl > 0);
+        /* We've written as much as we can.  The rest of the input buffer, if
+           any, is text that doesn't and with a NL and therefore needs to be
+           saved for the next trip. */
+        if (inl > 0)
+                {
+                memcpy(&(ctx->obuf[ctx->obuf_len]), in, inl);
+                ctx->obuf_len += inl;
+                num += inl;
+                }
+        return num;
+        }
+
+static long linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr)
+        {
+        BIO *dbio;
+        BIO_LINEBUFFER_CTX *ctx;
+        long ret=1;
+        char *p;
+        int r;
+        int obs;
+
+        ctx=(BIO_LINEBUFFER_CTX *)b->ptr;
+
+        switch (cmd)
+                {
+        case BIO_CTRL_RESET:
+                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:
+                ret=(long)ctx->obuf_len;
+                break;
+        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_C_SET_BUFF_SIZE:
+                obs=(int)num;
+                p=ctx->obuf;
+                if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size))
+                        {
+                        p=(char *)OPENSSL_malloc((int)num);
+                        if (p == NULL)
+                                goto malloc_error;
+                        }
+                if (ctx->obuf != p)
+                        {
+                        if (ctx->obuf_len > obs)
+                                {
+                                ctx->obuf_len = obs;
+                                }
+                        memcpy(p, ctx->obuf, ctx->obuf_len);
+                        OPENSSL_free(ctx->obuf);
+                        ctx->obuf=p;
+                        ctx->obuf_size=obs;
+                        }
+                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);
+                        break;
+                        }
+
+                for (;;)
+                        {
+                        BIO_clear_retry_flags(b);
+                        if (ctx->obuf_len > 0)
+                                {
+                                r=BIO_write(b->next_bio,
+                                        ctx->obuf, ctx->obuf_len);
+#if 0
+fprintf(stderr,"FLUSH %3d -> %3d\n",ctx->obuf_len,r);
+#endif
+                                BIO_copy_next_retry(b);
+                                if (r <= 0) return((long)r);
+                                if (r < ctx->obuf_len)
+                                        memmove(ctx->obuf, ctx->obuf + r,
+                                                ctx->obuf_len - r);
+                                ctx->obuf_len-=r;
+                                }
+                        else
+                                {
+                                ctx->obuf_len=0;
+                                ret=1;
+                                break;
+                                }
+                        }
+                ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+                break;
+        case BIO_CTRL_DUP:
+                dbio=(BIO *)ptr;
+                if (    !BIO_set_write_buffer_size(dbio,ctx->obuf_size))
+                        ret=0;
+                break;
+        default:
+                if (b->next_bio == NULL) return(0);
+                ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+                break;
+                }
+        return(ret);
+malloc_error:
+        BIOerr(BIO_F_LINEBUFFER_CTRL,ERR_R_MALLOC_FAILURE);
+        return(0);
+        }
+
+static long linebuffer_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 linebuffer_gets(BIO *b, char *buf, int size)
+        {
+        if (b->next_bio == NULL) return(0);
+        return(BIO_gets(b->next_bio,buf,size));
+        }
+
+static int linebuffer_puts(BIO *b, const char *str)
+        {
+        return(linebuffer_write(b,str,strlen(str)));
+        }
+
diff --git a/src/lib/libcrypto/bio/bss_bio.c b/src/lib/libcrypto/bio/bss_bio.c
new file mode 100644
index 0000000000..562e9d8de2
--- /dev/null
+++ b/src/lib/libcrypto/bio/bss_bio.c
@@ -0,0 +1,588 @@
+/* crypto/bio/bss_bio.c  -*- Mode: C; c-file-style: "eay" -*- */
+
+/* Special method for a BIO where the other endpoint is also a BIO
+ * of this kind, handled by the same thread (i.e. the "peer" is actually
+ * ourselves, wearing a different hat).
+ * Such "BIO pairs" are mainly for using the SSL library with I/O interfaces
+ * for which no specific BIO method is available.
+ * See ssl/ssltest.c for some hints on how this can be used. */
+
+#ifndef BIO_PAIR_DEBUG
+# undef NDEBUG /* avoid conflicting definitions */
+# define NDEBUG
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <openssl/bio.h>
+#include <openssl/err.h>
+#include <openssl/crypto.h>
+
+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 long bio_ctrl(BIO *bio, int cmd, long num, void *ptr);
+static int bio_puts(BIO *bio, char *str);
+
+static int bio_make_pair(BIO *bio1, BIO *bio2);
+static void bio_destroy_pair(BIO *bio);
+
+static BIO_METHOD methods_biop =
+{
+        BIO_TYPE_BIO,
+        "BIO pair",
+        bio_write,
+        bio_read,
+        bio_puts,
+        NULL /* no bio_gets */,
+        bio_ctrl,
+        bio_new,
+        bio_free
+};
+
+BIO_METHOD *BIO_s_bio(void)
+        {
+        return &methods_biop;
+        }
+
+struct bio_bio_st
+{
+        BIO *peer;     /* NULL if buf == NULL.
+                        * If peer != NULL, then peer->ptr is also a bio_bio_st,
+                        * and its "peer" member points back to us.
+                        * peer != NULL iff init != 0 in the BIO. */
+        
+        /* This is for what we write (i.e. reading uses peer's struct): */
+        int closed;     /* valid iff peer != NULL */
+        size_t len;     /* valid iff buf != NULL; 0 if peer == NULL */
+        size_t offset;  /* valid iff buf != NULL; 0 if len == 0 */
+        size_t size;
+        char *buf;      /* "size" elements (if != NULL) */
+
+        size_t request; /* valid iff peer != NULL; 0 if len != 0,
+                         * otherwise set by peer to number of bytes
+                         * it (unsuccesfully) tried to read,
+                         * never more than buffer space (size-len) warrants. */
+};
+
+static int bio_new(BIO *bio)
+        {
+        struct bio_bio_st *b;
+        
+        b = Malloc(sizeof *b);
+        if (b == NULL)
+                return 0;
+
+        b->peer = NULL;
+        b->size = 17*1024; /* enough for one TLS record (just a default) */
+        b->buf = NULL;
+
+        bio->ptr = b;
+        return 1;
+        }
+
+
+static int bio_free(BIO *bio)
+        {
+        struct bio_bio_st *b;
+
+        if (bio == NULL)
+                return 0;
+        b = bio->ptr;
+
+        assert(b != NULL);
+
+        if (b->peer)
+                bio_destroy_pair(bio);
+        
+        if (b->buf != NULL)
+                {
+                Free(b->buf);
+                }
+
+        Free(b);
+
+        return 1;
+        }
+
+
+
+static int bio_read(BIO *bio, char *buf, int size_)
+        {
+        size_t size = size_;
+        size_t rest;
+        struct bio_bio_st *b, *peer_b;
+
+        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; /* will be set in "retry_read" situation */
+
+        if (buf == NULL || size == 0)
+                return 0;
+
+        if (peer_b->len == 0)
+                {
+                if (peer_b->closed)
+                        return 0; /* writer has closed, and no data is left */
+                else
+                        {
+                        BIO_set_retry_read(bio); /* buffer is empty */
+                        if (size <= peer_b->size)
+                                peer_b->request = size;
+                        else
+                                /* don't ask for more than the peer can
+                                 * deliver in one write */
+                                peer_b->request = peer_b->size;
+                        return -1;
+                        }
+                }
+
+        /* we can read */
+        if (peer_b->len < size)
+                size = peer_b->len;
+
+        /* now read "size" bytes */
+        
+        rest = size;
+        
+        assert(rest > 0);
+        do /* one or two iterations */
+                {
+                size_t chunk;
+                
+                assert(rest <= peer_b->len);
+                if (peer_b->offset + rest <= peer_b->size)
+                        chunk = rest;
+                else
+                        /* wrap around ring buffer */
+                        chunk = peer_b->size - peer_b->offset;
+                assert(peer_b->offset + chunk <= peer_b->size);
+                
+                memcpy(buf, peer_b->buf + peer_b->offset, chunk);
+                
+                peer_b->len -= chunk;
+                if (peer_b->len)
+                        {
+                        peer_b->offset += chunk;
+                        assert(peer_b->offset <= peer_b->size);
+                        if (peer_b->offset == peer_b->size)
+                                peer_b->offset = 0;
+                        buf += chunk;
+                        }
+                else
+                        {
+                        /* buffer now empty, no need to advance "buf" */
+                        assert(chunk == rest);
+                        peer_b->offset = 0;
+                        }
+                rest -= chunk;
+                }
+        while (rest);
+        
+        return size;
+        }
+
+static int bio_write(BIO *bio, char *buf, int num_)
+        {
+        size_t num = num_;
+        size_t rest;
+        struct bio_bio_st *b;
+
+        BIO_clear_retry_flags(bio);
+
+        if (!bio->init || buf == NULL || num == 0)
+                return 0;
+
+        b = bio->ptr;           
+        assert(b != NULL);
+        assert(b->peer != NULL);
+        assert(b->buf != NULL);
+
+        b->request = 0;
+        if (b->closed)
+                {
+                /* we already closed */
+                BIOerr(BIO_F_BIO_WRITE, BIO_R_BROKEN_PIPE);
+                return -1;
+                }
+
+        assert(b->len <= b->size);
+
+        if (b->len == b->size)
+                {
+                BIO_set_retry_write(bio); /* buffer is full */
+                return -1;
+                }
+
+        /* we can write */
+        if (num > b->size - b->len)
+                num = b->size - b->len;
+        
+        /* now write "num" bytes */
+
+        rest = num;
+        
+        assert(rest > 0);
+        do /* one or two iterations */
+                {
+                size_t write_offset;
+                size_t chunk;
+
+                assert(b->len + rest <= b->size);
+
+                write_offset = b->offset + b->len;
+                if (write_offset >= b->size)
+                        write_offset -= b->size;
+                /* b->buf[write_offset] is the first byte we can write to. */
+
+                if (write_offset + rest <= b->size)
+                        chunk = rest;
+                else
+                        /* wrap around ring buffer */
+                        chunk = b->size - write_offset;
+                
+                memcpy(b->buf + write_offset, buf, chunk);
+                
+                b->len += chunk;
+
+                assert(b->len <= b->size);
+                
+                rest -= chunk;
+                buf += chunk;
+                }
+        while (rest);
+
+        return num;
+        }
+
+
+static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
+        {
+        long ret;
+        struct bio_bio_st *b = bio->ptr;
+        
+        assert(b != NULL);
+
+        switch (cmd)
+                {
+        /* specific CTRL codes */
+
+        case BIO_C_SET_WRITE_BUF_SIZE:
+                if (b->peer)
+                        {
+                        BIOerr(BIO_F_BIO_CTRL, BIO_R_IN_USE);
+                        ret = 0;
+                        }
+                else if (num == 0)
+                        {
+                        BIOerr(BIO_F_BIO_CTRL, BIO_R_INVALID_ARGUMENT);
+                        ret = 0;
+                        }
+                else
+                        {
+                        size_t new_size = num;
+
+                        if (b->size != new_size)
+                                {
+                                if (b->buf) 
+                                        {
+                                        Free(b->buf);
+                                        b->buf = NULL;
+                                        }
+                                b->size = new_size;
+                                }
+                        ret = 1;
+                        }
+                break;
+
+        case BIO_C_GET_WRITE_BUF_SIZE:
+                num = (long) b->size;
+
+        case BIO_C_MAKE_BIO_PAIR:
+                {
+                BIO *other_bio = ptr;
+                
+                if (bio_make_pair(bio, other_bio))
+                        ret = 1;
+                else
+                        ret = 0;
+                }
+                break;
+                
+        case BIO_C_DESTROY_BIO_PAIR:
+                /* Effects both BIOs in the pair -- call just once!
+                 * Or let BIO_free(bio1); BIO_free(bio2); do the job. */
+                bio_destroy_pair(bio);
+                ret = 1;
+                break;
+
+        case BIO_C_GET_WRITE_GUARANTEE:
+                /* How many bytes can the caller feed to the next write
+                 * withouth having to keep any? */
+                if (b->peer == NULL || b->closed)
+                        ret = 0;
+                else
+                        ret = (long) b->size - b->len;
+                break;
+
+        case BIO_C_GET_READ_REQUEST:
+                /* If the peer unsuccesfully 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_SHUTDOWN_WR:
+                /* similar to shutdown(..., SHUT_WR) */
+                b->closed = 1;
+                ret = 1;
+                break;
+
+
+        /* standard CTRL codes follow */
+
+        case BIO_CTRL_RESET:
+                if (b->buf != NULL)
+                        {
+                        b->len = 0;
+                        b->offset = 0;
+                        }
+                ret = 0;
+                break;          
+
+        case BIO_CTRL_GET_CLOSE:
+                ret = bio->shutdown;
+                break;
+
+        case BIO_CTRL_SET_CLOSE:
+                bio->shutdown = (int) num;
+                ret = 1;
+                break;
+
+        case BIO_CTRL_PENDING:
+                if (b->peer != NULL)
+                        {
+                        struct bio_bio_st *peer_b = b->peer->ptr;
+                        
+                        ret = (long) peer_b->len;
+                        }
+                else
+                        ret = 0;
+                break;
+
+        case BIO_CTRL_WPENDING:
+                if (b->buf != NULL)
+                        ret = (long) b->len;
+                else
+                        ret = 0;
+                break;
+
+        case BIO_CTRL_DUP:
+                /* See BIO_dup_chain for circumstances we have to expect. */
+                {
+                BIO *other_bio = ptr;
+                struct bio_bio_st *other_b;
+                
+                assert(other_bio != NULL);
+                other_b = other_bio->ptr;
+                assert(other_b != NULL);
+                
+                assert(other_b->buf == NULL); /* other_bio is always fresh */
+
+                other_b->size = b->size;
+                }
+
+                ret = 1;
+                break;
+
+        case BIO_CTRL_FLUSH:
+                ret = 1;
+                break;
+
+        case BIO_CTRL_EOF:
+                {
+                BIO *other_bio = ptr;
+                
+                if (other_bio)
+                        {
+                        struct bio_bio_st *other_b = other_bio->ptr;
+                        
+                        assert(other_b != NULL);
+                        ret = other_b->len == 0 && other_b->closed;
+                        }
+                else
+                        ret = 1;
+                }
+                break;
+
+        default:
+                ret = 0;
+                }
+        return ret;
+        }
+
+static int bio_puts(BIO *bio, char *str)
+        {
+        return bio_write(bio, str, strlen(str));
+        }
+
+
+static int bio_make_pair(BIO *bio1, BIO *bio2)
+        {
+        struct bio_bio_st *b1, *b2;
+
+        assert(bio1 != NULL);
+        assert(bio2 != NULL);
+
+        b1 = bio1->ptr;
+        b2 = bio2->ptr;
+        
+        if (b1->peer != NULL || b2->peer != NULL)
+                {
+                BIOerr(BIO_F_BIO_MAKE_PAIR, BIO_R_IN_USE);
+                return 0;
+                }
+        
+        if (b1->buf == NULL)
+                {
+                b1->buf = Malloc(b1->size);
+                if (b1->buf == NULL)
+                        {
+                        BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
+                        return 0;
+                        }
+                b1->len = 0;
+                b1->offset = 0;
+                }
+        
+        if (b2->buf == NULL)
+                {
+                b2->buf = Malloc(b2->size);
+                if (b2->buf == NULL)
+                        {
+                        BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
+                        return 0;
+                        }
+                b2->len = 0;
+                b2->offset = 0;
+                }
+        
+        b1->peer = bio2;
+        b1->closed = 0;
+        b1->request = 0;
+        b2->peer = bio1;
+        b2->closed = 0;
+        b2->request = 0;
+
+        bio1->init = 1;
+        bio2->init = 1;
+
+        return 1;
+        }
+
+static void bio_destroy_pair(BIO *bio)
+        {
+        struct bio_bio_st *b = bio->ptr;
+
+        if (b != NULL)
+                {
+                BIO *peer_bio = b->peer;
+
+                if (peer_bio != NULL)
+                        {
+                        struct bio_bio_st *peer_b = peer_bio->ptr;
+
+                        assert(peer_b != NULL);
+                        assert(peer_b->peer == bio);
+
+                        peer_b->peer = NULL;
+                        peer_bio->init = 0;
+                        assert(peer_b->buf != NULL);
+                        peer_b->len = 0;
+                        peer_b->offset = 0;
+                        
+                        b->peer = NULL;
+                        bio->init = 0;
+                        assert(b->buf != NULL);
+                        b->len = 0;
+                        b->offset = 0;
+                        }
+                }
+        }
+ 
+
+/* Exported convenience functions */
+int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1,
+        BIO **bio2_p, size_t writebuf2)
+         {
+         BIO *bio1 = NULL, *bio2 = NULL;
+         long r;
+         int ret = 0;
+
+         bio1 = BIO_new(BIO_s_bio());
+         if (bio1 == NULL)
+                 goto err;
+         bio2 = BIO_new(BIO_s_bio());
+         if (bio2 == NULL)
+                 goto err;
+
+         if (writebuf1)
+                 {
+                 r = BIO_set_write_buf_size(bio1, writebuf1);
+                 if (!r)
+                         goto err;
+                 }
+         if (writebuf2)
+                 {
+                 r = BIO_set_write_buf_size(bio2, writebuf2);
+                 if (!r)
+                         goto err;
+                 }
+
+         r = BIO_make_bio_pair(bio1, bio2);
+         if (!r)
+                 goto err;
+         ret = 1;
+
+ err:
+         if (ret == 0)
+                 {
+                 if (bio1)
+                         {
+                         BIO_free(bio1);
+                         bio1 = NULL;
+                         }
+                 if (bio2)
+                         {
+                         BIO_free(bio2);
+                         bio2 = NULL;
+                         }
+                 }
+
+         *bio1_p = bio1;
+         *bio2_p = bio2;
+         return ret;
+         }
+
+size_t BIO_ctrl_get_write_guarantee(BIO *bio)
+        {
+        return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL);
+        }
+
+size_t BIO_ctrl_get_read_request(BIO *bio)
+        {
+        return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);
+        }
diff --git a/src/lib/libcrypto/bio/bss_log.c b/src/lib/libcrypto/bio/bss_log.c
new file mode 100644
index 0000000000..db82e757e7
--- /dev/null
+++ b/src/lib/libcrypto/bio/bss_log.c
@@ -0,0 +1,232 @@
+/* crypto/bio/bss_log.c */
+/* ====================================================================
+ * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer. 
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. 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
+ *    licensing@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).
+ *
+ */
+
+/*
+        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).
+
+*/
+
+
+#include <stdio.h>
+#include <errno.h>
+
+#ifndef WIN32
+#ifdef __ultrix
+#include <sys/syslog.h>
+#else
+#include <syslog.h>
+#endif
+#endif
+
+#include "cryptlib.h"
+#include <openssl/buffer.h>
+#include <openssl/err.h>
+#ifndef NO_SYSLOG
+
+
+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 BIO_METHOD methods_slg=
+        {
+        BIO_TYPE_MEM,"syslog",
+        slg_write,
+        NULL,
+        slg_puts,
+        NULL,
+        slg_ctrl,
+        slg_new,
+        slg_free,
+        };
+
+BIO_METHOD *BIO_s_log(void)
+        {
+        return(&methods_slg);
+        }
+
+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);
+        }
+
+static int MS_CALLBACK slg_free(BIO *a)
+        {
+        if (a == NULL) return(0);
+        xcloselog(a);
+        return(1);
+        }
+        
+static int MS_CALLBACK slg_write(BIO *b, char *in, int inl)
+        {
+        int ret= inl;
+        char* buf= in;
+        char* pp;
+#if defined(WIN32)
+        LPTSTR lpszStrings[1];
+        WORD evtype= EVENTLOG_ERROR_TYPE;
+#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;
+        }
+        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;
+        }
+
+        syslog(priority, "%s", pp);
+#endif
+        Free(buf);
+        return(ret);
+        }
+
+static long MS_CALLBACK slg_ctrl(BIO *b, int cmd, long num, char *ptr)
+        {
+        switch (cmd)
+                {
+        case BIO_CTRL_SET:
+                xcloselog(b);
+                xopenlog(b, ptr, num);
+                break;
+        default:
+                break;
+                }
+        return(0);
+        }
+
+static int MS_CALLBACK slg_puts(BIO *bp, char *str)
+        {
+        int n,ret;
+
+        n=strlen(str);
+        ret=slg_write(bp,str,n);
+        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 int xcloselog(BIO* bp)
+{
+#if defined(WIN32)
+        if(bp->ptr)
+                DeregisterEventSource((HANDLE)(bp->ptr));
+        bp->ptr= NULL;
+#else
+        closelog();
+#endif
+        return(1);
+}
+
+#endif