aboutsummaryrefslogtreecommitdiffstats
path: root/crypto/openssl/crypto/bio
diff options
context:
space:
mode:
authorKris Kennaway <kris@FreeBSD.org>2000-01-10 06:22:05 +0000
committerKris Kennaway <kris@FreeBSD.org>2000-01-10 06:22:05 +0000
commit74664626283603849f4acbd49e8c8288c08cff4d (patch)
treeb5683ff3d44c93978826763313683673904c6bd9 /crypto/openssl/crypto/bio
parentf5952845872443119d7617dd3ef63397853419c1 (diff)
downloadsrc-74664626283603849f4acbd49e8c8288c08cff4d.tar.gz
src-74664626283603849f4acbd49e8c8288c08cff4d.zip
Initial import of OpenSSL 0.9.4, sans IDEA and RSA code for patent
infringement reasons.
Notes
Notes: svn path=/vendor-crypto/openssl/dist/; revision=55714
Diffstat (limited to 'crypto/openssl/crypto/bio')
-rw-r--r--crypto/openssl/crypto/bio/Makefile.ssl210
-rw-r--r--crypto/openssl/crypto/bio/b_dump.c128
-rw-r--r--crypto/openssl/crypto/bio/b_print.c87
-rw-r--r--crypto/openssl/crypto/bio/b_sock.c703
-rw-r--r--crypto/openssl/crypto/bio/bf_buff.c485
-rw-r--r--crypto/openssl/crypto/bio/bf_nbio.c240
-rw-r--r--crypto/openssl/crypto/bio/bf_null.c168
-rw-r--r--crypto/openssl/crypto/bio/bio.h643
-rw-r--r--crypto/openssl/crypto/bio/bio_cb.c133
-rw-r--r--crypto/openssl/crypto/bio/bio_err.c139
-rw-r--r--crypto/openssl/crypto/bio/bio_lib.c496
-rw-r--r--crypto/openssl/crypto/bio/bss_acpt.c466
-rw-r--r--crypto/openssl/crypto/bio/bss_bio.c588
-rw-r--r--crypto/openssl/crypto/bio/bss_conn.c618
-rw-r--r--crypto/openssl/crypto/bio/bss_fd.c62
-rw-r--r--crypto/openssl/crypto/bio/bss_file.c309
-rw-r--r--crypto/openssl/crypto/bio/bss_log.c232
-rw-r--r--crypto/openssl/crypto/bio/bss_mem.c276
-rw-r--r--crypto/openssl/crypto/bio/bss_null.c149
-rw-r--r--crypto/openssl/crypto/bio/bss_rtcp.c293
-rw-r--r--crypto/openssl/crypto/bio/bss_sock.c423
21 files changed, 6848 insertions, 0 deletions
diff --git a/crypto/openssl/crypto/bio/Makefile.ssl b/crypto/openssl/crypto/bio/Makefile.ssl
new file mode 100644
index 000000000000..f54c7ee1f09e
--- /dev/null
+++ b/crypto/openssl/crypto/bio/Makefile.ssl
@@ -0,0 +1,210 @@
+#
+# SSLeay/crypto/bio/Makefile
+#
+
+DIR= bio
+TOP= ../..
+CC= cc
+INCLUDES= -I.. -I../../include
+CFLAG=-g
+INSTALL_PREFIX=
+OPENSSLDIR= /usr/local/ssl
+INSTALLTOP=/usr/local/ssl
+MAKE= make -f Makefile.ssl
+MAKEDEPEND= $(TOP)/util/domd $(TOP)
+MAKEFILE= Makefile.ssl
+AR= ar r
+
+CFLAGS= $(INCLUDES) $(CFLAG)
+
+GENERAL=Makefile
+TEST=
+APPS=
+
+LIB=$(TOP)/libcrypto.a
+LIBSRC= bio_lib.c bio_cb.c bio_err.c \
+ bss_mem.c bss_null.c bss_fd.c \
+ bss_file.c bss_sock.c bss_conn.c \
+ bf_null.c bf_buff.c b_print.c b_dump.c \
+ b_sock.c bss_acpt.c bf_nbio.c bss_log.c bss_bio.c
+LIBOBJ= bio_lib.o bio_cb.o bio_err.o \
+ bss_mem.o bss_null.o bss_fd.o \
+ bss_file.o bss_sock.o bss_conn.o \
+ bf_null.o bf_buff.o b_print.o b_dump.o \
+ b_sock.o bss_acpt.o bf_nbio.o bss_log.o bss_bio.o
+
+SRC= $(LIBSRC)
+
+EXHEADER= bio.h
+HEADER= bss_file.c $(EXHEADER)
+
+ALL= $(GENERAL) $(SRC) $(HEADER)
+
+top:
+ (cd ../..; $(MAKE) DIRS=crypto SDIRS=$(DIR) sub_all)
+
+all: lib
+
+lib: $(LIBOBJ)
+ $(AR) $(LIB) $(LIBOBJ)
+ $(RANLIB) $(LIB)
+ @touch lib
+
+files:
+ $(PERL) $(TOP)/util/files.pl Makefile.ssl >> $(TOP)/MINFO
+
+links:
+ @$(TOP)/util/point.sh Makefile.ssl Makefile
+ @$(PERL) $(TOP)/util/mklink.pl ../../include/openssl $(EXHEADER)
+ @$(PERL) $(TOP)/util/mklink.pl ../../test $(TEST)
+ @$(PERL) $(TOP)/util/mklink.pl ../../apps $(APPS)
+
+install:
+ @for i in $(EXHEADER); \
+ do \
+ (cp $$i $(INSTALL_PREFIX)$(INSTALLTOP)/include/openssl/$$i; \
+ chmod 644 $(INSTALL_PREFIX)$(INSTALLTOP)/include/openssl/$$i ); \
+ done;
+
+tags:
+ ctags $(SRC)
+
+tests:
+
+lint:
+ lint -DLINT $(INCLUDES) $(SRC)>fluff
+
+depend:
+ $(MAKEDEPEND) $(INCLUDES) $(DEPFLAG) $(PROGS) $(LIBSRC)
+
+dclean:
+ $(PERL) -pe 'if (/^# DO NOT DELETE THIS LINE/) {print; exit(0);}' $(MAKEFILE) >Makefile.new
+ mv -f Makefile.new $(MAKEFILE)
+
+clean:
+ rm -f *.o *.obj lib tags core .pure .nfs* *.old *.bak fluff
+
+# DO NOT DELETE THIS LINE -- make depend depends on it.
+
+b_dump.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+b_dump.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+b_dump.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+b_dump.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+b_dump.o: ../../include/openssl/stack.h ../cryptlib.h
+b_print.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+b_print.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+b_print.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+b_print.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+b_print.o: ../../include/openssl/stack.h ../cryptlib.h
+b_sock.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+b_sock.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+b_sock.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+b_sock.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+b_sock.o: ../../include/openssl/stack.h ../cryptlib.h
+bf_buff.o: ../../include/openssl/asn1.h ../../include/openssl/bio.h
+bf_buff.o: ../../include/openssl/blowfish.h ../../include/openssl/bn.h
+bf_buff.o: ../../include/openssl/buffer.h ../../include/openssl/cast.h
+bf_buff.o: ../../include/openssl/crypto.h ../../include/openssl/des.h
+bf_buff.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
+bf_buff.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+bf_buff.o: ../../include/openssl/err.h ../../include/openssl/evp.h
+bf_buff.o: ../../include/openssl/idea.h ../../include/openssl/md2.h
+bf_buff.o: ../../include/openssl/md5.h ../../include/openssl/mdc2.h
+bf_buff.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
+bf_buff.o: ../../include/openssl/opensslv.h ../../include/openssl/rc2.h
+bf_buff.o: ../../include/openssl/rc4.h ../../include/openssl/rc5.h
+bf_buff.o: ../../include/openssl/ripemd.h ../../include/openssl/rsa.h
+bf_buff.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
+bf_buff.o: ../../include/openssl/stack.h ../cryptlib.h
+bf_nbio.o: ../../include/openssl/asn1.h ../../include/openssl/bio.h
+bf_nbio.o: ../../include/openssl/blowfish.h ../../include/openssl/bn.h
+bf_nbio.o: ../../include/openssl/buffer.h ../../include/openssl/cast.h
+bf_nbio.o: ../../include/openssl/crypto.h ../../include/openssl/des.h
+bf_nbio.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
+bf_nbio.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+bf_nbio.o: ../../include/openssl/err.h ../../include/openssl/evp.h
+bf_nbio.o: ../../include/openssl/idea.h ../../include/openssl/md2.h
+bf_nbio.o: ../../include/openssl/md5.h ../../include/openssl/mdc2.h
+bf_nbio.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
+bf_nbio.o: ../../include/openssl/opensslv.h ../../include/openssl/rand.h
+bf_nbio.o: ../../include/openssl/rc2.h ../../include/openssl/rc4.h
+bf_nbio.o: ../../include/openssl/rc5.h ../../include/openssl/ripemd.h
+bf_nbio.o: ../../include/openssl/rsa.h ../../include/openssl/safestack.h
+bf_nbio.o: ../../include/openssl/sha.h ../../include/openssl/stack.h
+bf_nbio.o: ../cryptlib.h
+bf_null.o: ../../include/openssl/asn1.h ../../include/openssl/bio.h
+bf_null.o: ../../include/openssl/blowfish.h ../../include/openssl/bn.h
+bf_null.o: ../../include/openssl/buffer.h ../../include/openssl/cast.h
+bf_null.o: ../../include/openssl/crypto.h ../../include/openssl/des.h
+bf_null.o: ../../include/openssl/dh.h ../../include/openssl/dsa.h
+bf_null.o: ../../include/openssl/e_os.h ../../include/openssl/e_os2.h
+bf_null.o: ../../include/openssl/err.h ../../include/openssl/evp.h
+bf_null.o: ../../include/openssl/idea.h ../../include/openssl/md2.h
+bf_null.o: ../../include/openssl/md5.h ../../include/openssl/mdc2.h
+bf_null.o: ../../include/openssl/objects.h ../../include/openssl/opensslconf.h
+bf_null.o: ../../include/openssl/opensslv.h ../../include/openssl/rc2.h
+bf_null.o: ../../include/openssl/rc4.h ../../include/openssl/rc5.h
+bf_null.o: ../../include/openssl/ripemd.h ../../include/openssl/rsa.h
+bf_null.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
+bf_null.o: ../../include/openssl/stack.h ../cryptlib.h
+bio_cb.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bio_cb.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bio_cb.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bio_cb.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+bio_cb.o: ../../include/openssl/stack.h ../cryptlib.h
+bio_err.o: ../../include/openssl/bio.h ../../include/openssl/crypto.h
+bio_err.o: ../../include/openssl/err.h ../../include/openssl/opensslv.h
+bio_err.o: ../../include/openssl/stack.h
+bio_lib.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bio_lib.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bio_lib.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bio_lib.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+bio_lib.o: ../../include/openssl/stack.h ../cryptlib.h
+bss_acpt.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bss_acpt.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bss_acpt.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bss_acpt.o: ../../include/openssl/opensslconf.h
+bss_acpt.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
+bss_acpt.o: ../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/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
+bss_conn.o: ../../include/openssl/opensslconf.h
+bss_conn.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
+bss_conn.o: ../cryptlib.h
+bss_fd.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bss_fd.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bss_fd.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bss_fd.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+bss_fd.o: ../../include/openssl/stack.h ../cryptlib.h bss_sock.c
+bss_file.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bss_file.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bss_file.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bss_file.o: ../../include/openssl/opensslconf.h
+bss_file.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
+bss_file.o: ../cryptlib.h
+bss_log.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bss_log.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bss_log.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bss_log.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+bss_log.o: ../../include/openssl/stack.h ../cryptlib.h
+bss_mem.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bss_mem.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bss_mem.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bss_mem.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
+bss_mem.o: ../../include/openssl/stack.h ../cryptlib.h
+bss_null.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bss_null.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bss_null.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bss_null.o: ../../include/openssl/opensslconf.h
+bss_null.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
+bss_null.o: ../cryptlib.h
+bss_sock.o: ../../include/openssl/bio.h ../../include/openssl/buffer.h
+bss_sock.o: ../../include/openssl/crypto.h ../../include/openssl/e_os.h
+bss_sock.o: ../../include/openssl/e_os2.h ../../include/openssl/err.h
+bss_sock.o: ../../include/openssl/opensslconf.h
+bss_sock.o: ../../include/openssl/opensslv.h ../../include/openssl/stack.h
+bss_sock.o: ../cryptlib.h
diff --git a/crypto/openssl/crypto/bio/b_dump.c b/crypto/openssl/crypto/bio/b_dump.c
new file mode 100644
index 000000000000..a7cd82897850
--- /dev/null
+++ b/crypto/openssl/crypto/bio/b_dump.c
@@ -0,0 +1,128 @@
+/* crypto/bio/b_dump.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.]
+ */
+
+/*
+ * Stolen from tjh's ssl/ssl_trc.c stuff.
+ */
+
+#include <stdio.h>
+#include "cryptlib.h"
+#include <openssl/bio.h>
+
+#define TRUNCATE
+#define DUMP_WIDTH 16
+
+int BIO_dump(BIO *bio, const char *s, int len)
+{
+ int ret=0;
+ char buf[160+1],tmp[20];
+ int i,j,rows,trunc;
+ unsigned char ch;
+
+ trunc=0;
+
+#ifdef TRUNCATE
+ for(; (len > 0) && ((s[len-1] == ' ') || (s[len-1] == '\0')); len--)
+ trunc++;
+#endif
+
+ rows=(len/DUMP_WIDTH);
+ if ((rows*DUMP_WIDTH)<len)
+ rows++;
+ for(i=0;i<rows;i++) {
+ buf[0]='\0'; /* start with empty string */
+ sprintf(tmp,"%04x - ",i*DUMP_WIDTH);
+ strcpy(buf,tmp);
+ for(j=0;j<DUMP_WIDTH;j++) {
+ if (((i*DUMP_WIDTH)+j)>=len) {
+ strcat(buf," ");
+ } else {
+ ch=((unsigned char)*((char *)(s)+i*DUMP_WIDTH+j)) & 0xff;
+ sprintf(tmp,"%02x%c",ch,j==7?'-':' ');
+ strcat(buf,tmp);
+ }
+ }
+ strcat(buf," ");
+ for(j=0;j<DUMP_WIDTH;j++) {
+ if (((i*DUMP_WIDTH)+j)>=len)
+ break;
+ ch=((unsigned char)*((char *)(s)+i*DUMP_WIDTH+j)) & 0xff;
+#ifndef CHARSET_EBCDIC
+ sprintf(tmp,"%c",((ch>=' ')&&(ch<='~'))?ch:'.');
+#else
+ sprintf(tmp,"%c",((ch>=os_toascii[' '])&&(ch<=os_toascii['~']))
+ ? os_toebcdic[ch]
+ : '.');
+#endif
+ strcat(buf,tmp);
+ }
+ strcat(buf,"\n");
+ /* if this is the last call then update the ddt_dump thing so that
+ * we will move the selection point in the debug window
+ */
+ ret+=BIO_write(bio,(char *)buf,strlen(buf));
+ }
+#ifdef TRUNCATE
+ if (trunc > 0) {
+ sprintf(buf,"%04x - <SPACES/NULS>\n",len+trunc);
+ ret+=BIO_write(bio,(char *)buf,strlen(buf));
+ }
+#endif
+ return(ret);
+}
+
diff --git a/crypto/openssl/crypto/bio/b_print.c b/crypto/openssl/crypto/bio/b_print.c
new file mode 100644
index 000000000000..f448004298af
--- /dev/null
+++ b/crypto/openssl/crypto/bio/b_print.c
@@ -0,0 +1,87 @@
+/* crypto/bio/b_print.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.]
+ */
+
+/*
+ * Stolen from tjh's ssl/ssl_trc.c stuff.
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "cryptlib.h"
+#include <openssl/bio.h>
+
+int BIO_printf (BIO *bio, ...)
+ {
+ va_list args;
+ char *format;
+ int ret;
+ MS_STATIC char hugebuf[1024*2]; /* 10k in one chunk is the limit */
+
+ va_start(args, bio);
+ format=va_arg(args, char *);
+
+ hugebuf[0]='\0';
+
+ vsprintf(hugebuf,format,args);
+
+ ret=BIO_write(bio,hugebuf,strlen(hugebuf));
+
+ va_end(args);
+ return(ret);
+ }
+
diff --git a/crypto/openssl/crypto/bio/b_sock.c b/crypto/openssl/crypto/bio/b_sock.c
new file mode 100644
index 000000000000..d29b29ff8b32
--- /dev/null
+++ b/crypto/openssl/crypto/bio/b_sock.c
@@ -0,0 +1,703 @@
+/* crypto/bio/b_sock.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.]
+ */
+
+#ifndef NO_SOCK
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#define USE_SOCKETS
+#include "cryptlib.h"
+#include <openssl/bio.h>
+
+#ifdef WIN16
+#define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
+#else
+#define SOCKET_PROTOCOL IPPROTO_TCP
+#endif
+
+#ifdef SO_MAXCONN
+#define MAX_LISTEN SOMAXCONN
+#elif defined(SO_MAXCONN)
+#define MAX_LISTEN SO_MAXCONN
+#else
+#define MAX_LISTEN 32
+#endif
+
+#ifdef WINDOWS
+static int wsa_init_done=0;
+#endif
+
+static unsigned long BIO_ghbn_hits=0L;
+static unsigned long BIO_ghbn_miss=0L;
+
+#define GHBN_NUM 4
+static struct ghbn_cache_st
+ {
+ char name[129];
+ struct hostent *ent;
+ unsigned long order;
+ } ghbn_cache[GHBN_NUM];
+
+static int get_ip(const char *str,unsigned char *ip);
+static void ghbn_free(struct hostent *a);
+static struct hostent *ghbn_dup(struct hostent *a);
+int BIO_get_host_ip(const char *str, unsigned char *ip)
+ {
+ int i;
+ int err = 1;
+ int locked = 0;
+ struct hostent *he;
+
+ i=get_ip(str,ip);
+ if (i > 0) return(1);
+ if (i < 0)
+ {
+ BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS);
+ goto err;
+ }
+
+ /* do a gethostbyname */
+ if (!BIO_sock_init())
+ return(0); /* don't generate another error code here */
+
+ CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
+ locked = 1;
+ he=BIO_gethostbyname(str);
+ if (he == NULL)
+ {
+ BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP);
+ goto err;
+ }
+
+ /* cast to short because of win16 winsock definition */
+ if ((short)he->h_addrtype != AF_INET)
+ {
+ BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
+ goto err;
+ }
+ for (i=0; i<4; i++)
+ ip[i]=he->h_addr_list[0][i];
+ err = 0;
+
+ err:
+ if (locked)
+ CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
+ if (err)
+ {
+ ERR_add_error_data(2,"host=",str);
+ return 0;
+ }
+ else
+ return 1;
+ }
+
+int BIO_get_port(const char *str, unsigned short *port_ptr)
+ {
+ int i;
+ struct servent *s;
+
+ if (str == NULL)
+ {
+ BIOerr(BIO_F_BIO_GET_PORT,BIO_R_NO_PORT_DEFINED);
+ return(0);
+ }
+ i=atoi(str);
+ if (i != 0)
+ *port_ptr=(unsigned short)i;
+ else
+ {
+ CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
+ s=getservbyname(str,"tcp");
+ if(s != NULL)
+ *port_ptr=ntohs((unsigned short)s->s_port);
+ CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
+ if(s == NULL)
+ {
+ if (strcmp(str,"http") == 0)
+ *port_ptr=80;
+ else if (strcmp(str,"telnet") == 0)
+ *port_ptr=23;
+ else if (strcmp(str,"socks") == 0)
+ *port_ptr=1080;
+ else if (strcmp(str,"https") == 0)
+ *port_ptr=443;
+ else if (strcmp(str,"ssl") == 0)
+ *port_ptr=443;
+ else if (strcmp(str,"ftp") == 0)
+ *port_ptr=21;
+ else if (strcmp(str,"gopher") == 0)
+ *port_ptr=70;
+#if 0
+ else if (strcmp(str,"wais") == 0)
+ *port_ptr=21;
+#endif
+ else
+ {
+ SYSerr(SYS_F_GETSERVBYNAME,get_last_socket_error());
+ ERR_add_error_data(3,"service='",str,"'");
+ return(0);
+ }
+ }
+ }
+ return(1);
+ }
+
+int BIO_sock_error(int sock)
+ {
+ int j,i;
+ int size;
+
+ size=sizeof(int);
+ /* Note: under Windows the third parameter is of type (char *)
+ * whereas under other systems it is (void *) if you don't have
+ * a cast it will choke the compiler: if you do have a cast then
+ * you can either go for (char *) or (void *).
+ */
+ i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size);
+ if (i < 0)
+ return(1);
+ else
+ return(j);
+ }
+
+long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
+ {
+ int i;
+ char **p;
+
+ switch (cmd)
+ {
+ case BIO_GHBN_CTRL_HITS:
+ return(BIO_ghbn_hits);
+ /* break; */
+ case BIO_GHBN_CTRL_MISSES:
+ return(BIO_ghbn_miss);
+ /* break; */
+ case BIO_GHBN_CTRL_CACHE_SIZE:
+ return(GHBN_NUM);
+ /* break; */
+ case BIO_GHBN_CTRL_GET_ENTRY:
+ if ((iarg >= 0) && (iarg <GHBN_NUM) &&
+ (ghbn_cache[iarg].order > 0))
+ {
+ p=(char **)parg;
+ if (p == NULL) return(0);
+ *p=ghbn_cache[iarg].name;
+ ghbn_cache[iarg].name[128]='\0';
+ return(1);
+ }
+ return(0);
+ /* break; */
+ case BIO_GHBN_CTRL_FLUSH:
+ for (i=0; i<GHBN_NUM; i++)
+ ghbn_cache[i].order=0;
+ break;
+ default:
+ return(0);
+ }
+ return(1);
+ }
+
+static struct hostent *ghbn_dup(struct hostent *a)
+ {
+ struct hostent *ret;
+ int i,j;
+
+ MemCheck_off();
+ ret=(struct hostent *)Malloc(sizeof(struct hostent));
+ if (ret == NULL) return(NULL);
+ memset(ret,0,sizeof(struct hostent));
+
+ for (i=0; a->h_aliases[i] != NULL; i++)
+ ;
+ i++;
+ ret->h_aliases = (char **)Malloc(i*sizeof(char *));
+ if (ret->h_aliases == NULL)
+ goto err;
+ memset(ret->h_aliases, 0, i*sizeof(char *));
+
+ for (i=0; a->h_addr_list[i] != NULL; i++)
+ ;
+ i++;
+ ret->h_addr_list=(char **)Malloc(i*sizeof(char *));
+ if (ret->h_addr_list == NULL)
+ goto err;
+ memset(ret->h_addr_list, 0, i*sizeof(char *));
+
+ j=strlen(a->h_name)+1;
+ if ((ret->h_name=Malloc(j)) == NULL) goto err;
+ memcpy((char *)ret->h_name,a->h_name,j+1);
+ for (i=0; a->h_aliases[i] != NULL; i++)
+ {
+ j=strlen(a->h_aliases[i])+1;
+ if ((ret->h_aliases[i]=Malloc(j)) == NULL) goto err;
+ memcpy(ret->h_aliases[i],a->h_aliases[i],j+1);
+ }
+ ret->h_length=a->h_length;
+ ret->h_addrtype=a->h_addrtype;
+ for (i=0; a->h_addr_list[i] != NULL; i++)
+ {
+ if ((ret->h_addr_list[i]=Malloc(a->h_length)) == NULL)
+ goto err;
+ memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length);
+ }
+ if (0)
+ {
+err:
+ if (ret != NULL)
+ ghbn_free(ret);
+ ret=NULL;
+ }
+ MemCheck_on();
+ return(ret);
+ }
+
+static void ghbn_free(struct hostent *a)
+ {
+ int i;
+
+ if(a == NULL)
+ return;
+
+ if (a->h_aliases != NULL)
+ {
+ for (i=0; a->h_aliases[i] != NULL; i++)
+ Free(a->h_aliases[i]);
+ Free(a->h_aliases);
+ }
+ if (a->h_addr_list != NULL)
+ {
+ for (i=0; a->h_addr_list[i] != NULL; i++)
+ Free(a->h_addr_list[i]);
+ Free(a->h_addr_list);
+ }
+ if (a->h_name != NULL) Free((char *)a->h_name);
+ Free(a);
+ }
+
+struct hostent *BIO_gethostbyname(const char *name)
+ {
+ struct hostent *ret;
+ int i,lowi=0,j;
+ unsigned long low= (unsigned long)-1;
+
+/* return(gethostbyname(name)); */
+
+#if 0 /* It doesn't make sense to use locking here: The function interface
+ * is not thread-safe, because threads can never be sure when
+ * some other thread destroys the data they were given a pointer to.
+ */
+ CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
+#endif
+ j=strlen(name);
+ if (j < 128)
+ {
+ for (i=0; i<GHBN_NUM; i++)
+ {
+ if (low > ghbn_cache[i].order)
+ {
+ low=ghbn_cache[i].order;
+ lowi=i;
+ }
+ if (ghbn_cache[i].order > 0)
+ {
+ if (strncmp(name,ghbn_cache[i].name,128) == 0)
+ break;
+ }
+ }
+ }
+ else
+ i=GHBN_NUM;
+
+ if (i == GHBN_NUM) /* no hit*/
+ {
+ BIO_ghbn_miss++;
+ ret=gethostbyname(name);
+
+ if (ret == NULL)
+ goto end;
+ if (j > 128) /* too big to cache */
+ {
+#if 0 /* If we were trying to make this function thread-safe (which
+ * is bound to fail), we'd have to give up in this case
+ * (or allocate more memory). */
+ ret = NULL;
+#endif
+ goto end;
+ }
+
+ /* else add to cache */
+ if (ghbn_cache[lowi].ent != NULL)
+ ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
+ ghbn_cache[lowi].name[0] = '\0';
+
+ if((ret=ghbn_cache[lowi].ent=ghbn_dup(ret)) == NULL)
+ {
+ BIOerr(BIO_F_BIO_GETHOSTBYNAME,ERR_R_MALLOC_FAILURE);
+ goto end;
+ }
+ strncpy(ghbn_cache[lowi].name,name,128);
+ ghbn_cache[lowi].order=BIO_ghbn_miss+BIO_ghbn_hits;
+ }
+ else
+ {
+ BIO_ghbn_hits++;
+ ret= ghbn_cache[i].ent;
+ ghbn_cache[i].order=BIO_ghbn_miss+BIO_ghbn_hits;
+ }
+end:
+#if 0
+ CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
+#endif
+ return(ret);
+ }
+
+int BIO_sock_init(void)
+ {
+#ifdef WINDOWS
+ static struct WSAData wsa_state;
+
+ if (!wsa_init_done)
+ {
+ 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)
+ {
+ err=WSAGetLastError();
+ SYSerr(SYS_F_WSASTARTUP,err);
+ BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP);
+ return(-1);
+ }
+ }
+#endif /* WINDOWS */
+ return(1);
+ }
+
+void BIO_sock_cleanup(void)
+ {
+#ifdef WINDOWS
+ if (wsa_init_done)
+ {
+ wsa_init_done=0;
+ WSACancelBlockingCall();
+ WSACleanup();
+ }
+#endif
+ }
+
+#if !defined(VMS) || __VMS_VER >= 70000000
+
+int BIO_socket_ioctl(int fd, long type, unsigned long *arg)
+ {
+ int i;
+
+ i=ioctlsocket(fd,type,arg);
+ if (i < 0)
+ SYSerr(SYS_F_IOCTLSOCKET,get_last_socket_error());
+ return(i);
+ }
+#endif /* __VMS_VER */
+
+/* The reason I have implemented this instead of using sscanf is because
+ * Visual C 1.52c gives an unresolved external when linking a DLL :-( */
+static int get_ip(const char *str, unsigned char ip[4])
+ {
+ unsigned int tmp[4];
+ int num=0,c,ok=0;
+
+ tmp[0]=tmp[1]=tmp[2]=tmp[3]=0;
+
+ for (;;)
+ {
+ c= *(str++);
+ if ((c >= '0') && (c <= '9'))
+ {
+ ok=1;
+ tmp[num]=tmp[num]*10+c-'0';
+ if (tmp[num] > 255) return(-1);
+ }
+ else if (c == '.')
+ {
+ if (!ok) return(-1);
+ if (num == 3) break;
+ num++;
+ ok=0;
+ }
+ else if ((num == 3) && ok)
+ break;
+ else
+ return(0);
+ }
+ ip[0]=tmp[0];
+ ip[1]=tmp[1];
+ ip[2]=tmp[2];
+ ip[3]=tmp[3];
+ return(1);
+ }
+
+int BIO_get_accept_socket(char *host, int bind_mode)
+ {
+ int ret=0;
+ struct sockaddr_in server,client;
+ int s= -1,cs;
+ unsigned char ip[4];
+ unsigned short port;
+ char *str,*e;
+ const char *h,*p;
+ unsigned long l;
+ int err_num;
+
+ if (!BIO_sock_init()) return(INVALID_SOCKET);
+
+ if ((str=BUF_strdup(host)) == NULL) return(INVALID_SOCKET);
+
+ h=p=NULL;
+ h=str;
+ for (e=str; *e; e++)
+ {
+ if (*e == ':')
+ {
+ p= &(e[1]);
+ *e='\0';
+ }
+ else if (*e == '/')
+ {
+ *e='\0';
+ break;
+ }
+ }
+
+ if (p == NULL)
+ {
+ p=h;
+ h="*";
+ }
+
+ if (!BIO_get_port(p,&port)) return(INVALID_SOCKET);
+
+ memset((char *)&server,0,sizeof(server));
+ server.sin_family=AF_INET;
+ server.sin_port=htons(port);
+
+ if (strcmp(h,"*") == 0)
+ server.sin_addr.s_addr=INADDR_ANY;
+ else
+ {
+ if (!BIO_get_host_ip(h,&(ip[0]))) return(INVALID_SOCKET);
+ l=(unsigned long)
+ ((unsigned long)ip[0]<<24L)|
+ ((unsigned long)ip[1]<<16L)|
+ ((unsigned long)ip[2]<< 8L)|
+ ((unsigned long)ip[3]);
+ server.sin_addr.s_addr=htonl(l);
+ }
+
+again:
+ s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
+ if (s == INVALID_SOCKET)
+ {
+ SYSerr(SYS_F_SOCKET,get_last_socket_error());
+ ERR_add_error_data(3,"port='",host,"'");
+ BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET);
+ goto err;
+ }
+
+#ifdef SO_REUSEADDR
+ if (bind_mode == BIO_BIND_REUSEADDR)
+ {
+ int i=1;
+
+ ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i));
+ bind_mode=BIO_BIND_NORMAL;
+ }
+#endif
+ if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)
+ {
+#ifdef SO_REUSEADDR
+ err_num=get_last_socket_error();
+ if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
+ (err_num == EADDRINUSE))
+ {
+ memcpy((char *)&client,(char *)&server,sizeof(server));
+ if (strcmp(h,"*") == 0)
+ client.sin_addr.s_addr=htonl(0x7F000001);
+ cs=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
+ if (cs != INVALID_SOCKET)
+ {
+ int ii;
+ ii=connect(cs,(struct sockaddr *)&client,
+ sizeof(client));
+ closesocket(cs);
+ if (ii == INVALID_SOCKET)
+ {
+ bind_mode=BIO_BIND_REUSEADDR;
+ closesocket(s);
+ goto again;
+ }
+ /* else error */
+ }
+ /* else error */
+ }
+#endif
+ SYSerr(SYS_F_BIND,err_num);
+ ERR_add_error_data(3,"port='",host,"'");
+ BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_BIND_SOCKET);
+ goto err;
+ }
+ if (listen(s,MAX_LISTEN) == -1)
+ {
+ SYSerr(SYS_F_BIND,get_last_socket_error());
+ ERR_add_error_data(3,"port='",host,"'");
+ BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_LISTEN_SOCKET);
+ goto err;
+ }
+ ret=1;
+err:
+ if (str != NULL) Free(str);
+ if ((ret == 0) && (s != INVALID_SOCKET))
+ {
+ closesocket(s);
+ s= INVALID_SOCKET;
+ }
+ return(s);
+ }
+
+int BIO_accept(int sock, char **addr)
+ {
+ int ret=INVALID_SOCKET;
+ static struct sockaddr_in from;
+ unsigned long l;
+ unsigned short port;
+ int len;
+ char *p;
+
+ memset((char *)&from,0,sizeof(from));
+ len=sizeof(from);
+ /* Note: under VMS with SOCKETSHR the fourth parameter is currently
+ * of type (int *) whereas under other systems it is (void *) if
+ * you don't have a cast it will choke the compiler: if you do
+ * have a cast then you can either go for (int *) or (void *).
+ */
+ ret=accept(sock,(struct sockaddr *)&from,(void *)&len);
+ if (ret == INVALID_SOCKET)
+ {
+ SYSerr(SYS_F_ACCEPT,get_last_socket_error());
+ BIOerr(BIO_F_BIO_ACCEPT,BIO_R_ACCEPT_ERROR);
+ goto end;
+ }
+
+ if (addr == NULL) goto end;
+
+ l=ntohl(from.sin_addr.s_addr);
+ port=ntohs(from.sin_port);
+ if (*addr == NULL)
+ {
+ if ((p=Malloc(24)) == NULL)
+ {
+ BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
+ goto end;
+ }
+ *addr=p;
+ }
+ sprintf(*addr,"%d.%d.%d.%d:%d",
+ (unsigned char)(l>>24L)&0xff,
+ (unsigned char)(l>>16L)&0xff,
+ (unsigned char)(l>> 8L)&0xff,
+ (unsigned char)(l )&0xff,
+ port);
+end:
+ return(ret);
+ }
+
+int BIO_set_tcp_ndelay(int s, int on)
+ {
+ int ret=0;
+#if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
+ int opt;
+
+#ifdef SOL_TCP
+ opt=SOL_TCP;
+#else
+#ifdef IPPROTO_TCP
+ opt=IPPROTO_TCP;
+#endif
+#endif
+
+ ret=setsockopt(s,opt,TCP_NODELAY,(char *)&on,sizeof(on));
+#endif
+ return(ret == 0);
+ }
+#endif
+
+int BIO_socket_nbio(int s, int mode)
+ {
+ int ret= -1;
+ unsigned long l;
+
+ l=mode;
+#ifdef FIONBIO
+ ret=BIO_socket_ioctl(s,FIONBIO,&l);
+#endif
+ return(ret == 0);
+ }
diff --git a/crypto/openssl/crypto/bio/bf_buff.c b/crypto/openssl/crypto/bio/bf_buff.c
new file mode 100644
index 000000000000..acd814813892
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bf_buff.c
@@ -0,0 +1,485 @@
+/* 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 buffer_write(BIO *h,char *buf,int num);
+static int buffer_read(BIO *h,char *buf,int size);
+static int buffer_puts(BIO *h,char *str);
+static int buffer_gets(BIO *h,char *str,int size);
+static long buffer_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int buffer_new(BIO *h);
+static int buffer_free(BIO *data);
+#define DEFAULT_BUFFER_SIZE 1024
+
+static BIO_METHOD methods_buffer=
+ {
+ BIO_TYPE_BUFFER,
+ "buffer",
+ buffer_write,
+ buffer_read,
+ buffer_puts,
+ buffer_gets,
+ buffer_ctrl,
+ buffer_new,
+ buffer_free,
+ };
+
+BIO_METHOD *BIO_f_buffer(void)
+ {
+ return(&methods_buffer);
+ }
+
+static int buffer_new(BIO *bi)
+ {
+ BIO_F_BUFFER_CTX *ctx;
+
+ ctx=(BIO_F_BUFFER_CTX *)Malloc(sizeof(BIO_F_BUFFER_CTX));
+ if (ctx == NULL) return(0);
+ ctx->ibuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
+ if (ctx->ibuf == NULL) { Free(ctx); return(0); }
+ ctx->obuf=(char *)Malloc(DEFAULT_BUFFER_SIZE);
+ if (ctx->obuf == NULL) { Free(ctx->ibuf); Free(ctx); return(0); }
+ ctx->ibuf_size=DEFAULT_BUFFER_SIZE;
+ ctx->obuf_size=DEFAULT_BUFFER_SIZE;
+ ctx->ibuf_len=0;
+ ctx->ibuf_off=0;
+ ctx->obuf_len=0;
+ ctx->obuf_off=0;
+
+ bi->init=1;
+ bi->ptr=(char *)ctx;
+ bi->flags=0;
+ return(1);
+ }
+
+static int buffer_free(BIO *a)
+ {
+ BIO_F_BUFFER_CTX *b;
+
+ if (a == NULL) return(0);
+ b=(BIO_F_BUFFER_CTX *)a->ptr;
+ if (b->ibuf != NULL) Free(b->ibuf);
+ if (b->obuf != NULL) Free(b->obuf);
+ Free(a->ptr);
+ a->ptr=NULL;
+ a->init=0;
+ a->flags=0;
+ return(1);
+ }
+
+static int buffer_read(BIO *b, char *out, int outl)
+ {
+ int i,num=0;
+ BIO_F_BUFFER_CTX *ctx;
+
+ if (out == NULL) return(0);
+ ctx=(BIO_F_BUFFER_CTX *)b->ptr;
+
+ if ((ctx == NULL) || (b->next_bio == NULL)) return(0);
+ num=0;
+ BIO_clear_retry_flags(b);
+
+start:
+ i=ctx->ibuf_len;
+ /* If there is stuff left over, grab it */
+ if (i != 0)
+ {
+ if (i > outl) i=outl;
+ memcpy(out,&(ctx->ibuf[ctx->ibuf_off]),i);
+ ctx->ibuf_off+=i;
+ ctx->ibuf_len-=i;
+ num+=i;
+ if (outl == i) return(num);
+ outl-=i;
+ out+=i;
+ }
+
+ /* We may have done a partial read. try to do more.
+ * We have nothing in the buffer.
+ * If we get an error and have read some data, just return it
+ * and let them retry to get the error again.
+ * copy direct to parent address space */
+ if (outl > ctx->ibuf_size)
+ {
+ for (;;)
+ {
+ i=BIO_read(b->next_bio,out,outl);
+ if (i <= 0)
+ {
+ BIO_copy_next_retry(b);
+ if (i < 0) return((num > 0)?num:i);
+ if (i == 0) return(num);
+ }
+ num+=i;
+ if (outl == i) return(num);
+ out+=i;
+ outl-=i;
+ }
+ }
+ /* else */
+
+ /* we are going to be doing some buffering */
+ i=BIO_read(b->next_bio,ctx->ibuf,ctx->ibuf_size);
+ if (i <= 0)
+ {
+ BIO_copy_next_retry(b);
+ if (i < 0) return((num > 0)?num:i);
+ if (i == 0) return(num);
+ }
+ ctx->ibuf_off=0;
+ ctx->ibuf_len=i;
+
+ /* Lets re-read using ourselves :-) */
+ goto start;
+ }
+
+static int buffer_write(BIO *b, char *in, int inl)
+ {
+ int i,num=0;
+ BIO_F_BUFFER_CTX *ctx;
+
+ if ((in == NULL) || (inl <= 0)) return(0);
+ ctx=(BIO_F_BUFFER_CTX *)b->ptr;
+ if ((ctx == NULL) || (b->next_bio == NULL)) return(0);
+
+ BIO_clear_retry_flags(b);
+start:
+ i=ctx->obuf_size-(ctx->obuf_len+ctx->obuf_off);
+ /* add to buffer and return */
+ if (i >= inl)
+ {
+ memcpy(&(ctx->obuf[ctx->obuf_len]),in,inl);
+ ctx->obuf_len+=inl;
+ return(num+inl);
+ }
+ /* else */
+ /* stuff already in buffer, so add to it first, then flush */
+ if (ctx->obuf_len != 0)
+ {
+ if (i > 0) /* lets fill it up if we can */
+ {
+ memcpy(&(ctx->obuf[ctx->obuf_len]),in,i);
+ in+=i;
+ inl-=i;
+ num+=i;
+ ctx->obuf_len+=i;
+ }
+ /* we now have a full buffer needing flushing */
+ for (;;)
+ {
+ i=BIO_write(b->next_bio,&(ctx->obuf[ctx->obuf_off]),
+ ctx->obuf_len);
+ if (i <= 0)
+ {
+ BIO_copy_next_retry(b);
+
+ if (i < 0) return((num > 0)?num:i);
+ if (i == 0) return(num);
+ }
+ ctx->obuf_off+=i;
+ ctx->obuf_len-=i;
+ if (ctx->obuf_len == 0) break;
+ }
+ }
+ /* we only get here if the buffer has been flushed and we
+ * still have stuff to write */
+ ctx->obuf_off=0;
+
+ /* we now have inl bytes to write */
+ while (inl >= ctx->obuf_size)
+ {
+ i=BIO_write(b->next_bio,in,inl);
+ if (i <= 0)
+ {
+ BIO_copy_next_retry(b);
+ if (i < 0) return((num > 0)?num:i);
+ if (i == 0) return(num);
+ }
+ num+=i;
+ in+=i;
+ inl-=i;
+ if (inl == 0) return(num);
+ }
+
+ /* copy the rest into the buffer since we have only a small
+ * amount left */
+ goto start;
+ }
+
+static long buffer_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ BIO *dbio;
+ BIO_F_BUFFER_CTX *ctx;
+ long ret=1;
+ char *p1,*p2;
+ int r,i,*ip;
+ int ibs,obs;
+
+ ctx=(BIO_F_BUFFER_CTX *)b->ptr;
+
+ switch (cmd)
+ {
+ case BIO_CTRL_RESET:
+ ctx->ibuf_off=0;
+ ctx->ibuf_len=0;
+ ctx->obuf_off=0;
+ ctx->obuf_len=0;
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ break;
+ case BIO_CTRL_INFO:
+ ret=(long)ctx->obuf_len;
+ break;
+ case BIO_C_GET_BUFF_NUM_LINES:
+ ret=0;
+ p1=ctx->ibuf;
+ for (i=ctx->ibuf_off; i<ctx->ibuf_len; i++)
+ {
+ if (p1[i] == '\n') ret++;
+ }
+ break;
+ case BIO_CTRL_WPENDING:
+ ret=(long)ctx->obuf_len;
+ if (ret == 0)
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ break;
+ case BIO_CTRL_PENDING:
+ ret=(long)ctx->ibuf_len;
+ if (ret == 0)
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ break;
+ case BIO_C_SET_BUFF_READ_DATA:
+ if (num > ctx->ibuf_size)
+ {
+ p1=Malloc((int)num);
+ if (p1 == NULL) goto malloc_error;
+ if (ctx->ibuf != NULL) Free(ctx->ibuf);
+ ctx->ibuf=p1;
+ }
+ ctx->ibuf_off=0;
+ ctx->ibuf_len=(int)num;
+ memcpy(ctx->ibuf,ptr,(int)num);
+ ret=1;
+ break;
+ case BIO_C_SET_BUFF_SIZE:
+ if (ptr != NULL)
+ {
+ ip=(int *)ptr;
+ if (*ip == 0)
+ {
+ ibs=(int)num;
+ obs=ctx->obuf_size;
+ }
+ else /* if (*ip == 1) */
+ {
+ ibs=ctx->ibuf_size;
+ obs=(int)num;
+ }
+ }
+ else
+ {
+ ibs=(int)num;
+ obs=(int)num;
+ }
+ p1=ctx->ibuf;
+ p2=ctx->obuf;
+ if ((ibs > DEFAULT_BUFFER_SIZE) && (ibs != ctx->ibuf_size))
+ {
+ p1=(char *)Malloc((int)num);
+ if (p1 == NULL) goto malloc_error;
+ }
+ if ((obs > DEFAULT_BUFFER_SIZE) && (obs != ctx->obuf_size))
+ {
+ p2=(char *)Malloc((int)num);
+ if (p2 == NULL)
+ {
+ if (p1 != ctx->ibuf) Free(p1);
+ goto malloc_error;
+ }
+ }
+ if (ctx->ibuf != p1)
+ {
+ Free(ctx->ibuf);
+ ctx->ibuf=p1;
+ ctx->ibuf_off=0;
+ ctx->ibuf_len=0;
+ ctx->ibuf_size=ibs;
+ }
+ if (ctx->obuf != p2)
+ {
+ Free(ctx->obuf);
+ ctx->obuf=p2;
+ ctx->obuf_off=0;
+ ctx->obuf_len=0;
+ ctx->obuf_size=obs;
+ }
+ break;
+ case BIO_C_DO_STATE_MACHINE:
+ 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 (ctx->obuf_len <= 0)
+ {
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ break;
+ }
+
+ for (;;)
+ {
+ BIO_clear_retry_flags(b);
+ if (ctx->obuf_len > ctx->obuf_off)
+ {
+ r=BIO_write(b->next_bio,
+ &(ctx->obuf[ctx->obuf_off]),
+ ctx->obuf_len-ctx->obuf_off);
+#if 0
+fprintf(stderr,"FLUSH [%3d] %3d -> %3d\n",ctx->obuf_off,ctx->obuf_len-ctx->obuf_off,r);
+#endif
+ BIO_copy_next_retry(b);
+ if (r <= 0) return((long)r);
+ ctx->obuf_off+=r;
+ }
+ else
+ {
+ ctx->obuf_len=0;
+ ctx->obuf_off=0;
+ ret=1;
+ break;
+ }
+ }
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ break;
+ case BIO_CTRL_DUP:
+ dbio=(BIO *)ptr;
+ if ( !BIO_set_read_buffer_size(dbio,ctx->ibuf_size) ||
+ !BIO_set_write_buffer_size(dbio,ctx->obuf_size))
+ ret=0;
+ break;
+ default:
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ break;
+ }
+ return(ret);
+malloc_error:
+ BIOerr(BIO_F_BUFFER_CTRL,ERR_R_MALLOC_FAILURE);
+ return(0);
+ }
+
+static int buffer_gets(BIO *b, char *buf, int size)
+ {
+ BIO_F_BUFFER_CTX *ctx;
+ int num=0,i,flag;
+ char *p;
+
+ ctx=(BIO_F_BUFFER_CTX *)b->ptr;
+ size--; /* reserve space for a '\0' */
+ BIO_clear_retry_flags(b);
+
+ for (;;)
+ {
+ if (ctx->ibuf_len > 0)
+ {
+ p= &(ctx->ibuf[ctx->ibuf_off]);
+ flag=0;
+ for (i=0; (i<ctx->ibuf_len) && (i<size); i++)
+ {
+ *(buf++)=p[i];
+ if (p[i] == '\n')
+ {
+ flag=1;
+ i++;
+ break;
+ }
+ }
+ num+=i;
+ size-=i;
+ ctx->ibuf_len-=i;
+ ctx->ibuf_off+=i;
+ if ((flag) || (i == size))
+ {
+ *buf='\0';
+ return(num);
+ }
+ }
+ else /* read another chunk */
+ {
+ i=BIO_read(b->next_bio,ctx->ibuf,ctx->ibuf_size);
+ if (i <= 0)
+ {
+ BIO_copy_next_retry(b);
+ if (i < 0) return((num > 0)?num:i);
+ if (i == 0) return(num);
+ }
+ ctx->ibuf_len=i;
+ ctx->ibuf_off=0;
+ }
+ }
+ }
+
+static int buffer_puts(BIO *b, char *str)
+ {
+ return(BIO_write(b,str,strlen(str)));
+ }
+
diff --git a/crypto/openssl/crypto/bio/bf_nbio.c b/crypto/openssl/crypto/bio/bf_nbio.c
new file mode 100644
index 000000000000..cbec2bae29a8
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bf_nbio.c
@@ -0,0 +1,240 @@
+/* crypto/bio/bf_nbio.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/rand.h>
+#include <openssl/bio.h>
+#include <openssl/evp.h>
+
+/* BIO_put and BIO_get both add to the digest,
+ * BIO_gets returns the digest */
+
+static int nbiof_write(BIO *h,char *buf,int num);
+static int nbiof_read(BIO *h,char *buf,int size);
+static int nbiof_puts(BIO *h,char *str);
+static int nbiof_gets(BIO *h,char *str,int size);
+static long nbiof_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int nbiof_new(BIO *h);
+static int nbiof_free(BIO *data);
+typedef struct nbio_test_st
+ {
+ /* only set if we sent a 'should retry' error */
+ int lrn;
+ int lwn;
+ } NBIO_TEST;
+
+static BIO_METHOD methods_nbiof=
+ {
+ BIO_TYPE_NBIO_TEST,
+ "non-blocking IO test filter",
+ nbiof_write,
+ nbiof_read,
+ nbiof_puts,
+ nbiof_gets,
+ nbiof_ctrl,
+ nbiof_new,
+ nbiof_free,
+ };
+
+BIO_METHOD *BIO_f_nbio_test(void)
+ {
+ return(&methods_nbiof);
+ }
+
+static int nbiof_new(BIO *bi)
+ {
+ NBIO_TEST *nt;
+
+ nt=(NBIO_TEST *)Malloc(sizeof(NBIO_TEST));
+ nt->lrn= -1;
+ nt->lwn= -1;
+ bi->ptr=(char *)nt;
+ bi->init=1;
+ bi->flags=0;
+ return(1);
+ }
+
+static int nbiof_free(BIO *a)
+ {
+ if (a == NULL) return(0);
+ if (a->ptr != NULL)
+ Free(a->ptr);
+ a->ptr=NULL;
+ a->init=0;
+ a->flags=0;
+ return(1);
+ }
+
+static int nbiof_read(BIO *b, char *out, int outl)
+ {
+ NBIO_TEST *nt;
+ int ret=0;
+#if 0
+ int num;
+ unsigned char n;
+#endif
+
+ if (out == NULL) return(0);
+ if (b->next_bio == NULL) return(0);
+ nt=(NBIO_TEST *)b->ptr;
+
+ BIO_clear_retry_flags(b);
+#if 0
+ RAND_bytes(&n,1);
+ num=(n&0x07);
+
+ if (outl > num) outl=num;
+
+ if (num == 0)
+ {
+ ret= -1;
+ BIO_set_retry_read(b);
+ }
+ else
+#endif
+ {
+ ret=BIO_read(b->next_bio,out,outl);
+ if (ret < 0)
+ BIO_copy_next_retry(b);
+ }
+ return(ret);
+ }
+
+static int nbiof_write(BIO *b, char *in, int inl)
+ {
+ NBIO_TEST *nt;
+ int ret=0;
+ int num;
+ unsigned char n;
+
+ if ((in == NULL) || (inl <= 0)) return(0);
+ if (b->next_bio == NULL) return(0);
+ nt=(NBIO_TEST *)b->ptr;
+
+ BIO_clear_retry_flags(b);
+
+#if 1
+ if (nt->lwn > 0)
+ {
+ num=nt->lwn;
+ nt->lwn=0;
+ }
+ else
+ {
+ RAND_bytes(&n,1);
+ num=(n&7);
+ }
+
+ if (inl > num) inl=num;
+
+ if (num == 0)
+ {
+ ret= -1;
+ BIO_set_retry_write(b);
+ }
+ else
+#endif
+ {
+ ret=BIO_write(b->next_bio,in,inl);
+ if (ret < 0)
+ {
+ BIO_copy_next_retry(b);
+ nt->lwn=inl;
+ }
+ }
+ return(ret);
+ }
+
+static long nbiof_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ long ret;
+
+ if (b->next_bio == NULL) return(0);
+ switch (cmd)
+ {
+ case BIO_C_DO_STATE_MACHINE:
+ BIO_clear_retry_flags(b);
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ BIO_copy_next_retry(b);
+ break;
+ case BIO_CTRL_DUP:
+ ret=0L;
+ break;
+ default:
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ break;
+ }
+ return(ret);
+ }
+
+static int nbiof_gets(BIO *bp, char *buf, int size)
+ {
+ if (bp->next_bio == NULL) return(0);
+ return(BIO_gets(bp->next_bio,buf,size));
+ }
+
+
+static int nbiof_puts(BIO *bp, char *str)
+ {
+ if (bp->next_bio == NULL) return(0);
+ return(BIO_puts(bp->next_bio,str));
+ }
+
+
diff --git a/crypto/openssl/crypto/bio/bf_null.c b/crypto/openssl/crypto/bio/bf_null.c
new file mode 100644
index 000000000000..3254a55dce7f
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bf_null.c
@@ -0,0 +1,168 @@
+/* crypto/bio/bf_null.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>
+
+/* BIO_put and BIO_get both add to the digest,
+ * BIO_gets returns the digest */
+
+static int nullf_write(BIO *h,char *buf,int num);
+static int nullf_read(BIO *h,char *buf,int size);
+static int nullf_puts(BIO *h,char *str);
+static int nullf_gets(BIO *h,char *str,int size);
+static long nullf_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int nullf_new(BIO *h);
+static int nullf_free(BIO *data);
+static BIO_METHOD methods_nullf=
+ {
+ BIO_TYPE_NULL_FILTER,
+ "NULL filter",
+ nullf_write,
+ nullf_read,
+ nullf_puts,
+ nullf_gets,
+ nullf_ctrl,
+ nullf_new,
+ nullf_free,
+ };
+
+BIO_METHOD *BIO_f_null(void)
+ {
+ return(&methods_nullf);
+ }
+
+static int nullf_new(BIO *bi)
+ {
+ bi->init=1;
+ bi->ptr=NULL;
+ bi->flags=0;
+ return(1);
+ }
+
+static int nullf_free(BIO *a)
+ {
+ if (a == NULL) return(0);
+/* a->ptr=NULL;
+ a->init=0;
+ a->flags=0;*/
+ return(1);
+ }
+
+static int nullf_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 nullf_write(BIO *b, char *in, int inl)
+ {
+ int ret=0;
+
+ if ((in == NULL) || (inl <= 0)) return(0);
+ if (b->next_bio == NULL) return(0);
+ ret=BIO_write(b->next_bio,in,inl);
+ BIO_clear_retry_flags(b);
+ BIO_copy_next_retry(b);
+ return(ret);
+ }
+
+static long nullf_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ long ret;
+
+ if (b->next_bio == NULL) return(0);
+ switch(cmd)
+ {
+ case BIO_C_DO_STATE_MACHINE:
+ BIO_clear_retry_flags(b);
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ BIO_copy_next_retry(b);
+ break;
+ case BIO_CTRL_DUP:
+ ret=0L;
+ break;
+ default:
+ ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
+ }
+ return(ret);
+ }
+
+static int nullf_gets(BIO *bp, char *buf, int size)
+ {
+ if (bp->next_bio == NULL) return(0);
+ return(BIO_gets(bp->next_bio,buf,size));
+ }
+
+
+static int nullf_puts(BIO *bp, char *str)
+ {
+ if (bp->next_bio == NULL) return(0);
+ return(BIO_puts(bp->next_bio,str));
+ }
+
+
diff --git a/crypto/openssl/crypto/bio/bio.h b/crypto/openssl/crypto/bio/bio.h
new file mode 100644
index 000000000000..54bf622a3bd5
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bio.h
@@ -0,0 +1,643 @@
+/* crypto/bio/bio.h */
+/* 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.]
+ */
+
+#ifndef HEADER_BIO_H
+#define HEADER_BIO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <openssl/crypto.h>
+
+/* These are the 'types' of BIOs */
+#define BIO_TYPE_NONE 0
+#define BIO_TYPE_MEM (1|0x0400)
+#define BIO_TYPE_FILE (2|0x0400)
+
+#define BIO_TYPE_FD (4|0x0400|0x0100)
+#define BIO_TYPE_SOCKET (5|0x0400|0x0100)
+#define BIO_TYPE_NULL (6|0x0400)
+#define BIO_TYPE_SSL (7|0x0200)
+#define BIO_TYPE_MD (8|0x0200) /* pasive filter */
+#define BIO_TYPE_BUFFER (9|0x0200) /* filter */
+#define BIO_TYPE_CIPHER (10|0x0200) /* filter */
+#define BIO_TYPE_BASE64 (11|0x0200) /* filter */
+#define BIO_TYPE_CONNECT (12|0x0400|0x0100) /* socket - connect */
+#define BIO_TYPE_ACCEPT (13|0x0400|0x0100) /* socket for accept */
+#define BIO_TYPE_PROXY_CLIENT (14|0x0200) /* client proxy BIO */
+#define BIO_TYPE_PROXY_SERVER (15|0x0200) /* server proxy BIO */
+#define BIO_TYPE_NBIO_TEST (16|0x0200) /* server proxy BIO */
+#define BIO_TYPE_NULL_FILTER (17|0x0200)
+#define BIO_TYPE_BER (18|0x0200) /* BER -> bin filter */
+#define BIO_TYPE_BIO (19|0x0400) /* (half a) BIO pair */
+
+#define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */
+#define BIO_TYPE_FILTER 0x0200
+#define BIO_TYPE_SOURCE_SINK 0x0400
+
+/* BIO_FILENAME_READ|BIO_CLOSE to open or close on free.
+ * BIO_set_fp(in,stdin,BIO_NOCLOSE); */
+#define BIO_NOCLOSE 0x00
+#define BIO_CLOSE 0x01
+
+/* These are used in the following macros and are passed to
+ * BIO_ctrl() */
+#define BIO_CTRL_RESET 1 /* opt - rewind/zero etc */
+#define BIO_CTRL_EOF 2 /* opt - are we at the eof */
+#define BIO_CTRL_INFO 3 /* opt - extra tit-bits */
+#define BIO_CTRL_SET 4 /* man - set the 'IO' type */
+#define BIO_CTRL_GET 5 /* man - get the 'IO' type */
+#define BIO_CTRL_PUSH 6 /* opt - internal, used to signify change */
+#define BIO_CTRL_POP 7 /* opt - internal, used to signify change */
+#define BIO_CTRL_GET_CLOSE 8 /* man - set the 'close' on free */
+#define BIO_CTRL_SET_CLOSE 9 /* man - set the 'close' on free */
+#define BIO_CTRL_PENDING 10 /* opt - is their more data buffered */
+#define BIO_CTRL_FLUSH 11 /* opt - 'flush' buffered output */
+#define BIO_CTRL_DUP 12 /* man - extra stuff for 'duped' BIO */
+#define BIO_CTRL_WPENDING 13 /* opt - number of bytes still to write */
+/* callback is int cb(BIO *bio,state,ret); */
+#define BIO_CTRL_SET_CALLBACK 14 /* opt - set callback function */
+#define BIO_CTRL_GET_CALLBACK 15 /* opt - set callback function */
+
+#define BIO_CTRL_SET_FILENAME 30 /* BIO_s_file special */
+
+/* modifiers */
+#define BIO_FP_READ 0x02
+#define BIO_FP_WRITE 0x04
+#define BIO_FP_APPEND 0x08
+#define BIO_FP_TEXT 0x10
+
+#define BIO_FLAGS_READ 0x01
+#define BIO_FLAGS_WRITE 0x02
+#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
+
+/* Used in BIO_gethostbyname() */
+#define BIO_GHBN_CTRL_HITS 1
+#define BIO_GHBN_CTRL_MISSES 2
+#define BIO_GHBN_CTRL_CACHE_SIZE 3
+#define BIO_GHBN_CTRL_GET_ENTRY 4
+#define BIO_GHBN_CTRL_FLUSH 5
+
+/* Mostly used in the SSL BIO */
+/* Not used anymore
+ * #define BIO_FLAGS_PROTOCOL_DELAYED_READ 0x10
+ * #define BIO_FLAGS_PROTOCOL_DELAYED_WRITE 0x20
+ * #define BIO_FLAGS_PROTOCOL_STARTUP 0x40
+ */
+
+#define BIO_FLAGS_BASE64_NO_NL 0x100
+
+#define BIO_set_flags(b,f) ((b)->flags|=(f))
+#define BIO_get_flags(b) ((b)->flags)
+#define BIO_set_retry_special(b) \
+ ((b)->flags|=(BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
+#define BIO_set_retry_read(b) \
+ ((b)->flags|=(BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
+#define BIO_set_retry_write(b) \
+ ((b)->flags|=(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))
+#define BIO_get_retry_flags(b) \
+ ((b)->flags&(BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
+
+/* These shouldbe used by the application to tell why we should retry */
+#define BIO_should_read(a) ((a)->flags & BIO_FLAGS_READ)
+#define BIO_should_write(a) ((a)->flags & BIO_FLAGS_WRITE)
+#define BIO_should_io_special(a) ((a)->flags & BIO_FLAGS_IO_SPECIAL)
+#define BIO_retry_type(a) ((a)->flags & BIO_FLAGS_RWS)
+#define BIO_should_retry(a) ((a)->flags & BIO_FLAGS_SHOULD_RETRY)
+
+/* The next two are used in conjunction with the
+ * BIO_should_io_special() condition. After this returns true,
+ * BIO *BIO_get_retry_BIO(BIO *bio, int *reason); will walk the BIO
+ * stack and return the 'reason' for the special and the offending BIO.
+ * Given a BIO, BIO_get_retry_reason(bio) will return the code. */
+/* Returned from the SSL bio when the certificate retrieval code had an error */
+#define BIO_RR_SSL_X509_LOOKUP 0x01
+/* Returned from the connect BIO when a connect would have blocked */
+#define BIO_RR_CONNECT 0x02
+
+/* These are passed by the BIO callback */
+#define BIO_CB_FREE 0x01
+#define BIO_CB_READ 0x02
+#define BIO_CB_WRITE 0x03
+#define BIO_CB_PUTS 0x04
+#define BIO_CB_GETS 0x05
+#define BIO_CB_CTRL 0x06
+
+/* The callback is called before and after the underling operation,
+ * The BIO_CB_RETURN flag indicates if it is after the call */
+#define BIO_CB_RETURN 0x80
+#define BIO_CB_return(a) ((a)|BIO_CB_RETURN))
+#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)
+
+#ifndef WIN16
+typedef struct bio_method_st
+ {
+ int type;
+ const char *name;
+ int (*bwrite)();
+ int (*bread)();
+ int (*bputs)();
+ int (*bgets)();
+ long (*ctrl)();
+ int (*create)();
+ int (*destroy)();
+ } BIO_METHOD;
+#else
+typedef struct bio_method_st
+ {
+ int type;
+ const char *name;
+ int (_far *bwrite)();
+ int (_far *bread)();
+ int (_far *bputs)();
+ int (_far *bgets)();
+ long (_far *ctrl)();
+ int (_far *create)();
+ int (_far *destroy)();
+ } BIO_METHOD;
+#endif
+
+typedef struct bio_st
+ {
+ BIO_METHOD *method;
+ /* bio, mode, argp, argi, argl, ret */
+ long (*callback)(struct bio_st *,int,const char *,int, long,long);
+ char *cb_arg; /* first argument for the callback */
+
+ int init;
+ int shutdown;
+ int flags; /* extra storage */
+ int retry_reason;
+ int num;
+ void *ptr;
+ struct bio_st *next_bio; /* used by filter BIOs */
+ struct bio_st *prev_bio; /* used by filter BIOs */
+ int references;
+ unsigned long num_read;
+ unsigned long num_write;
+
+ CRYPTO_EX_DATA ex_data;
+ } BIO;
+
+typedef struct bio_f_buffer_ctx_struct
+ {
+ /* BIO *bio; */ /* this is now in the BIO struct */
+ int ibuf_size; /* how big is the input buffer */
+ int obuf_size; /* how big is the output buffer */
+
+ char *ibuf; /* the char array */
+ int ibuf_len; /* how many bytes are in it */
+ int ibuf_off; /* write/read offset */
+
+ char *obuf; /* the char array */
+ int obuf_len; /* how many bytes are in it */
+ int obuf_off; /* write/read offset */
+ } BIO_F_BUFFER_CTX;
+
+/* connect BIO stuff */
+#define BIO_CONN_S_BEFORE 1
+#define BIO_CONN_S_GET_IP 2
+#define BIO_CONN_S_GET_PORT 3
+#define BIO_CONN_S_CREATE_SOCKET 4
+#define BIO_CONN_S_CONNECT 5
+#define BIO_CONN_S_OK 6
+#define BIO_CONN_S_BLOCKED_CONNECT 7
+#define BIO_CONN_S_NBIO 8
+/*#define BIO_CONN_get_param_hostname BIO_ctrl */
+
+#define BIO_number_read(b) ((b)->num_read)
+#define BIO_number_written(b) ((b)->num_write)
+
+#define BIO_C_SET_CONNECT 100
+#define BIO_C_DO_STATE_MACHINE 101
+#define BIO_C_SET_NBIO 102
+#define BIO_C_SET_PROXY_PARAM 103
+#define BIO_C_SET_FD 104
+#define BIO_C_GET_FD 105
+#define BIO_C_SET_FILE_PTR 106
+#define BIO_C_GET_FILE_PTR 107
+#define BIO_C_SET_FILENAME 108
+#define BIO_C_SET_SSL 109
+#define BIO_C_GET_SSL 110
+#define BIO_C_SET_MD 111
+#define BIO_C_GET_MD 112
+#define BIO_C_GET_CIPHER_STATUS 113
+#define BIO_C_SET_BUF_MEM 114
+#define BIO_C_GET_BUF_MEM_PTR 115
+#define BIO_C_GET_BUFF_NUM_LINES 116
+#define BIO_C_SET_BUFF_SIZE 117
+#define BIO_C_SET_ACCEPT 118
+#define BIO_C_SSL_MODE 119
+#define BIO_C_GET_MD_CTX 120
+#define BIO_C_GET_PROXY_PARAM 121
+#define BIO_C_SET_BUFF_READ_DATA 122 /* data to read first */
+#define BIO_C_GET_CONNECT 123
+#define BIO_C_GET_ACCEPT 124
+#define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125
+#define BIO_C_GET_SSL_NUM_RENEGOTIATES 126
+#define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127
+#define BIO_C_FILE_SEEK 128
+#define BIO_C_GET_CIPHER_CTX 129
+#define BIO_C_SET_BUF_MEM_EOF_RETURN 130/*return end of input value*/
+#define BIO_C_SET_BIND_MODE 131
+#define BIO_C_GET_BIND_MODE 132
+#define BIO_C_FILE_TELL 133
+#define BIO_C_GET_SOCKS 134
+#define BIO_C_SET_SOCKS 135
+
+#define BIO_C_SET_WRITE_BUF_SIZE 136/* for BIO_s_bio */
+#define BIO_C_GET_WRITE_BUF_SIZE 137
+#define BIO_C_MAKE_BIO_PAIR 138
+#define BIO_C_DESTROY_BIO_PAIR 139
+#define BIO_C_GET_WRITE_GUARANTEE 140
+#define BIO_C_GET_READ_REQUEST 141
+#define BIO_C_SHUTDOWN_WR 142
+
+
+#define BIO_set_app_data(s,arg) BIO_set_ex_data(s,0,(char *)arg)
+#define BIO_get_app_data(s) BIO_get_ex_data(s,0)
+
+/* BIO_s_connect() and BIO_s_socks4a_connect() */
+#define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0,(char *)name)
+#define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1,(char *)port)
+#define BIO_set_conn_ip(b,ip) BIO_ctrl(b,BIO_C_SET_CONNECT,2,(char *)ip)
+#define BIO_set_conn_int_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,3,(char *)port)
+#define BIO_get_conn_hostname(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0)
+#define BIO_get_conn_port(b) BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1)
+#define BIO_get_conn_ip(b,ip) BIO_ptr_ctrl(b,BIO_C_SET_CONNECT,2)
+#define BIO_get_conn_int_port(b,port) BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,port)
+
+
+#define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL)
+
+/* BIO_s_accept_socket() */
+#define BIO_set_accept_port(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0,(char *)name)
+#define BIO_get_accept_port(b) BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0)
+/* #define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */
+#define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,1,(n)?"a":NULL)
+#define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(char *)bio)
+
+#define BIO_BIND_NORMAL 0
+#define BIO_BIND_REUSEADDR_IF_UNUSED 1
+#define BIO_BIND_REUSEADDR 2
+#define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL)
+#define BIO_get_bind_mode(b,mode) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL)
+
+#define BIO_do_connect(b) BIO_do_handshake(b)
+#define BIO_do_accept(b) BIO_do_handshake(b)
+#define BIO_do_handshake(b) BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL)
+
+/* BIO_s_proxy_client() */
+#define BIO_set_url(b,url) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,0,(char *)(url))
+#define BIO_set_proxies(b,p) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,1,(char *)(p))
+/* BIO_set_nbio(b,n) */
+#define BIO_set_filter_bio(b,s) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,2,(char *)(s))
+/* BIO *BIO_get_filter_bio(BIO *bio); */
+#define BIO_set_proxy_cb(b,cb) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,3,(char *)(cb))
+#define BIO_set_proxy_header(b,sk) BIO_ctrl(b,BIO_C_SET_PROXY_PARAM,4,(char *)sk)
+#define BIO_set_no_connect_return(b,bool) BIO_int_ctrl(b,BIO_C_SET_PROXY_PARAM,5,bool)
+
+#define BIO_get_proxy_header(b,skp) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,0,(char *)skp)
+#define BIO_get_proxies(b,pxy_p) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,1,(char *)(pxy_p))
+#define BIO_get_url(b,url) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,2,(char *)(url))
+#define BIO_get_no_connect_return(b) BIO_ctrl(b,BIO_C_GET_PROXY_PARAM,5,NULL)
+
+#define BIO_set_fd(b,fd,c) BIO_int_ctrl(b,BIO_C_SET_FD,c,fd)
+#define BIO_get_fd(b,c) BIO_ctrl(b,BIO_C_GET_FD,0,(char *)c)
+
+#define BIO_set_fp(b,fp,c) BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)fp)
+#define BIO_get_fp(b,fpp) BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)fpp)
+
+#define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL)
+#define BIO_tell(b) (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL)
+
+/* name is cast to lose const, but might be better to route through a function
+ so we can do it safely */
+#ifdef CONST_STRICT
+/* If you are wondering why this isn't defined, its because CONST_STRICT is
+ * purely a compile-time kludge to allow const to be checked.
+ */
+int BIO_read_filename(BIO *b,const char *name);
+#else
+#define BIO_read_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
+ BIO_CLOSE|BIO_FP_READ,(char *)name)
+#endif
+#define BIO_write_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
+ BIO_CLOSE|BIO_FP_WRITE,name)
+#define BIO_append_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
+ BIO_CLOSE|BIO_FP_APPEND,name)
+#define BIO_rw_filename(b,name) BIO_ctrl(b,BIO_C_SET_FILENAME, \
+ BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name)
+
+/* WARNING WARNING, this ups the reference count on the read bio of the
+ * SSL structure. This is because the ssl read BIO is now pointed to by
+ * the next_bio field in the bio. So when you free the BIO, make sure
+ * you are doing a BIO_free_all() to catch the underlying BIO. */
+#define BIO_set_ssl(b,ssl,c) BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)ssl)
+#define BIO_get_ssl(b,sslp) BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)sslp)
+#define BIO_set_ssl_mode(b,client) BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL)
+#define BIO_set_ssl_renegotiate_bytes(b,num) \
+ BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL);
+#define BIO_get_num_renegotiates(b) \
+ BIO_ctrl(b,BIO_C_SET_SSL_NUM_RENEGOTIATES,0,NULL);
+#define BIO_set_ssl_renegotiate_timeout(b,seconds) \
+ BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL);
+
+/* defined in evp.h */
+/* #define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,1,(char *)md) */
+
+#define BIO_get_mem_data(b,pp) BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)pp)
+#define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)bm)
+#define BIO_get_mem_ptr(b,pp) BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0,(char *)pp)
+#define BIO_set_mem_eof_return(b,v) \
+ BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL)
+
+/* For the BIO_f_buffer() type */
+#define BIO_get_buffer_num_lines(b) BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL)
+#define BIO_set_buffer_size(b,size) BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL)
+#define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0)
+#define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1)
+#define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf)
+
+/* Don't use the next one unless you know what you are doing :-) */
+#define BIO_dup_state(b,ret) BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret))
+
+#define BIO_reset(b) (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
+#define BIO_eof(b) (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL)
+#define BIO_set_close(b,c) (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL)
+#define BIO_get_close(b) (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL)
+#define BIO_pending(b) (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL)
+#define BIO_wpending(b) (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL)
+/* ...pending macros have inappropriate return type */
+size_t BIO_ctrl_pending(BIO *b);
+size_t BIO_ctrl_wpending(BIO *b);
+#define BIO_flush(b) (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL)
+#define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0,(char *)cbp)
+#define BIO_set_info_callback(b,cb) (int)BIO_ctrl(b,BIO_CTRL_SET_CALLBACK,0,(char *)cb)
+
+/* For the BIO_f_buffer() type */
+#define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL)
+
+/* For BIO_s_bio() */
+#define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL)
+#define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL)
+#define BIO_make_bio_pair(b1,b2) (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2)
+#define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL)
+/* macros with inappropriate type -- but ...pending macros use int too: */
+#define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL)
+#define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL)
+size_t BIO_ctrl_get_write_guarantee(BIO *b);
+size_t BIO_ctrl_get_read_request(BIO *b);
+
+
+
+#ifdef NO_STDIO
+#define NO_FP_API
+#endif
+
+
+/* These two aren't currently implemented */
+/* int BIO_get_ex_num(BIO *bio); */
+/* void BIO_set_ex_free_func(BIO *bio,int idx,void (*cb)()); */
+int BIO_set_ex_data(BIO *bio,int idx,char *data);
+char *BIO_get_ex_data(BIO *bio,int idx);
+int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
+ int (*dup_func)(), void (*free_func)());
+
+# if defined(WIN16) && defined(_WINDLL)
+BIO_METHOD *BIO_s_file_internal(void);
+BIO *BIO_new_file_internal(char *filename, char *mode);
+BIO *BIO_new_fp_internal(FILE *stream, int close_flag);
+# define BIO_s_file BIO_s_file_internal
+# define BIO_new_file BIO_new_file_internal
+# define BIO_new_fp BIO_new_fp_internal
+# else /* FP_API */
+BIO_METHOD *BIO_s_file(void );
+BIO *BIO_new_file(const char *filename, const char *mode);
+BIO *BIO_new_fp(FILE *stream, int close_flag);
+# define BIO_s_file_internal BIO_s_file
+# define BIO_new_file_internal BIO_new_file
+# define BIO_new_fp_internal BIO_s_file
+# endif /* FP_API */
+BIO * BIO_new(BIO_METHOD *type);
+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_puts(BIO *bp,const char *buf);
+long BIO_ctrl(BIO *bp,int cmd,long larg,void *parg);
+char * BIO_ptr_ctrl(BIO *bp,int cmd,long larg);
+long BIO_int_ctrl(BIO *bp,int cmd,long larg,int iarg);
+BIO * BIO_push(BIO *b,BIO *append);
+BIO * BIO_pop(BIO *b);
+void BIO_free_all(BIO *a);
+BIO * BIO_find_type(BIO *b,int bio_type);
+BIO * BIO_get_retry_BIO(BIO *bio, int *reason);
+int BIO_get_retry_reason(BIO *bio);
+BIO * BIO_dup_chain(BIO *in);
+
+#ifndef WIN16
+long BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi,
+ long argl,long ret);
+#else
+long _far _loadds BIO_debug_callback(BIO *bio,int cmd,const char *argp,int argi,
+ long argl,long ret);
+#endif
+
+BIO_METHOD *BIO_s_mem(void);
+BIO_METHOD *BIO_s_socket(void);
+BIO_METHOD *BIO_s_connect(void);
+BIO_METHOD *BIO_s_accept(void);
+BIO_METHOD *BIO_s_fd(void);
+BIO_METHOD *BIO_s_log(void);
+BIO_METHOD *BIO_s_bio(void);
+BIO_METHOD *BIO_s_null(void);
+BIO_METHOD *BIO_f_null(void);
+BIO_METHOD *BIO_f_buffer(void);
+BIO_METHOD *BIO_f_nbio_test(void);
+/* BIO_METHOD *BIO_f_ber(void); */
+
+int BIO_sock_should_retry(int i);
+int BIO_sock_non_fatal_error(int error);
+int BIO_fd_should_retry(int i);
+int BIO_fd_non_fatal_error(int error);
+int BIO_dump(BIO *b,const char *bytes,int len);
+
+struct hostent *BIO_gethostbyname(const char *name);
+/* We might want a thread-safe interface too:
+ * struct hostent *BIO_gethostbyname_r(const char *name,
+ * struct hostent *result, void *buffer, size_t buflen);
+ * or something similar (caller allocates a struct hostent,
+ * pointed to by "result", and additional buffer space for the various
+ * substructures; if the buffer does not suffice, NULL is returned
+ * and an appropriate error code is set).
+ */
+int BIO_sock_error(int sock);
+int BIO_socket_ioctl(int fd, long type, unsigned long *arg);
+int BIO_socket_nbio(int fd,int mode);
+int BIO_get_port(const char *str, unsigned short *port_ptr);
+int BIO_get_host_ip(const char *str, unsigned char *ip);
+int BIO_get_accept_socket(char *host_port,int mode);
+int BIO_accept(int sock,char **ip_port);
+int BIO_sock_init(void );
+void BIO_sock_cleanup(void);
+int BIO_set_tcp_ndelay(int sock,int turn_on);
+
+void ERR_load_BIO_strings(void );
+
+BIO *BIO_new_socket(int sock, int close_flag);
+BIO *BIO_new_fd(int fd, int close_flag);
+BIO *BIO_new_connect(char *host_port);
+BIO *BIO_new_accept(char *host_port);
+
+int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
+ BIO **bio2, size_t writebuf2);
+/* If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
+ * Otherwise returns 0 and sets *bio1 and *bio2 to NULL.
+ * Size 0 uses default value.
+ */
+
+void BIO_copy_next_retry(BIO *b);
+
+long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
+
+int BIO_printf(BIO *bio, ...);
+
+/* BEGIN ERROR CODES */
+/* The following lines are auto generated by the script mkerr.pl. Any changes
+ * made after this point may be overwritten when the script is next run.
+ */
+
+/* Error codes for the BIO functions. */
+
+/* Function codes. */
+#define BIO_F_ACPT_STATE 100
+#define BIO_F_BIO_ACCEPT 101
+#define BIO_F_BIO_BER_GET_HEADER 102
+#define BIO_F_BIO_CTRL 103
+#define BIO_F_BIO_GETHOSTBYNAME 120
+#define BIO_F_BIO_GETS 104
+#define BIO_F_BIO_GET_ACCEPT_SOCKET 105
+#define BIO_F_BIO_GET_HOST_IP 106
+#define BIO_F_BIO_GET_PORT 107
+#define BIO_F_BIO_MAKE_PAIR 121
+#define BIO_F_BIO_NEW 108
+#define BIO_F_BIO_NEW_FILE 109
+#define BIO_F_BIO_PUTS 110
+#define BIO_F_BIO_READ 111
+#define BIO_F_BIO_SOCK_INIT 112
+#define BIO_F_BIO_WRITE 113
+#define BIO_F_BUFFER_CTRL 114
+#define BIO_F_CONN_STATE 115
+#define BIO_F_FILE_CTRL 116
+#define BIO_F_MEM_WRITE 117
+#define BIO_F_SSL_NEW 118
+#define BIO_F_WSASTARTUP 119
+
+/* Reason codes. */
+#define BIO_R_ACCEPT_ERROR 100
+#define BIO_R_BAD_FOPEN_MODE 101
+#define BIO_R_BAD_HOSTNAME_LOOKUP 102
+#define BIO_R_BROKEN_PIPE 124
+#define BIO_R_CONNECT_ERROR 103
+#define BIO_R_ERROR_SETTING_NBIO 104
+#define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET 105
+#define BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET 106
+#define BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET 107
+#define BIO_R_INVALID_ARGUMENT 125
+#define BIO_R_INVALID_IP_ADDRESS 108
+#define BIO_R_IN_USE 123
+#define BIO_R_KEEPALIVE 109
+#define BIO_R_NBIO_CONNECT_ERROR 110
+#define BIO_R_NO_ACCEPT_PORT_SPECIFIED 111
+#define BIO_R_NO_HOSTNAME_SPECIFIED 112
+#define BIO_R_NO_PORT_DEFINED 113
+#define BIO_R_NO_PORT_SPECIFIED 114
+#define BIO_R_NULL_PARAMETER 115
+#define BIO_R_TAG_MISMATCH 116
+#define BIO_R_UNABLE_TO_BIND_SOCKET 117
+#define BIO_R_UNABLE_TO_CREATE_SOCKET 118
+#define BIO_R_UNABLE_TO_LISTEN_SOCKET 119
+#define BIO_R_UNINITIALIZED 120
+#define BIO_R_UNSUPPORTED_METHOD 121
+#define BIO_R_WSASTARTUP 122
+
+#ifdef __cplusplus
+}
+#endif
+#endif
+
diff --git a/crypto/openssl/crypto/bio/bio_cb.c b/crypto/openssl/crypto/bio/bio_cb.c
new file mode 100644
index 000000000000..37c7c2266683
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bio_cb.c
@@ -0,0 +1,133 @@
+/* crypto/bio/bio_cb.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 <string.h>
+#include <stdlib.h>
+#include "cryptlib.h"
+#include <openssl/bio.h>
+#include <openssl/err.h>
+
+long MS_CALLBACK BIO_debug_callback(BIO *bio, int cmd, const char *argp,
+ int argi, long argl, long ret)
+ {
+ BIO *b;
+ MS_STATIC char buf[256];
+ char *p;
+ long r=1;
+
+ if (BIO_CB_RETURN & cmd)
+ r=ret;
+
+ sprintf(buf,"BIO[%08lX]:",(unsigned long)bio);
+ p= &(buf[14]);
+ switch (cmd)
+ {
+ case BIO_CB_FREE:
+ sprintf(p,"Free - %s\n",bio->method->name);
+ break;
+ case BIO_CB_READ:
+ if (bio->method->type & BIO_TYPE_DESCRIPTOR)
+ sprintf(p,"read(%d,%d) - %s fd=%d\n",bio->num,argi,bio->method->name,bio->num);
+ else
+ sprintf(p,"read(%d,%d) - %s\n",bio->num,argi,bio->method->name);
+ break;
+ case BIO_CB_WRITE:
+ if (bio->method->type & BIO_TYPE_DESCRIPTOR)
+ sprintf(p,"write(%d,%d) - %s fd=%d\n",bio->num,argi,bio->method->name,bio->num);
+ else
+ sprintf(p,"write(%d,%d) - %s\n",bio->num,argi,bio->method->name);
+ break;
+ case BIO_CB_PUTS:
+ sprintf(p,"puts() - %s\n",bio->method->name);
+ break;
+ case BIO_CB_GETS:
+ sprintf(p,"gets(%d) - %s\n",argi,bio->method->name);
+ break;
+ case BIO_CB_CTRL:
+ sprintf(p,"ctrl(%d) - %s\n",argi,bio->method->name);
+ break;
+ case BIO_CB_RETURN|BIO_CB_READ:
+ sprintf(p,"read return %ld\n",ret);
+ break;
+ case BIO_CB_RETURN|BIO_CB_WRITE:
+ sprintf(p,"write return %ld\n",ret);
+ break;
+ case BIO_CB_RETURN|BIO_CB_GETS:
+ sprintf(p,"gets return %ld\n",ret);
+ break;
+ case BIO_CB_RETURN|BIO_CB_PUTS:
+ sprintf(p,"puts return %ld\n",ret);
+ break;
+ case BIO_CB_RETURN|BIO_CB_CTRL:
+ sprintf(p,"ctrl return %ld\n",ret);
+ break;
+ default:
+ sprintf(p,"bio callback - unknown type (%d)\n",cmd);
+ break;
+ }
+
+ b=(BIO *)bio->cb_arg;
+ if (b != NULL)
+ BIO_write(b,buf,strlen(buf));
+#if !defined(NO_STDIO) && !defined(WIN16)
+ else
+ fputs(buf,stderr);
+#endif
+ return(r);
+ }
diff --git a/crypto/openssl/crypto/bio/bio_err.c b/crypto/openssl/crypto/bio/bio_err.c
new file mode 100644
index 000000000000..712d98a3a1a9
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bio_err.c
@@ -0,0 +1,139 @@
+/* crypto/bio/bio_err.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
+ * openssl-core@OpenSSL.org.
+ *
+ * 5. Products derived from this software may not be called "OpenSSL"
+ * nor may "OpenSSL" appear in their names without prior written
+ * permission of the OpenSSL Project.
+ *
+ * 6. Redistributions of any form whatsoever must retain the following
+ * acknowledgment:
+ * "This product includes software developed by the OpenSSL Project
+ * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
+ * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This product includes cryptographic software written by Eric Young
+ * (eay@cryptsoft.com). This product includes software written by Tim
+ * Hudson (tjh@cryptsoft.com).
+ *
+ */
+
+/* NOTE: this file was auto generated by the mkerr.pl script: any changes
+ * made to it will be overwritten when the script next updates this file.
+ */
+
+#include <stdio.h>
+#include <openssl/err.h>
+#include <openssl/bio.h>
+
+/* BEGIN ERROR CODES */
+#ifndef NO_ERR
+static ERR_STRING_DATA BIO_str_functs[]=
+ {
+{ERR_PACK(0,BIO_F_ACPT_STATE,0), "ACPT_STATE"},
+{ERR_PACK(0,BIO_F_BIO_ACCEPT,0), "BIO_accept"},
+{ERR_PACK(0,BIO_F_BIO_BER_GET_HEADER,0), "BIO_BER_GET_HEADER"},
+{ERR_PACK(0,BIO_F_BIO_CTRL,0), "BIO_ctrl"},
+{ERR_PACK(0,BIO_F_BIO_GETHOSTBYNAME,0), "BIO_gethostbyname"},
+{ERR_PACK(0,BIO_F_BIO_GETS,0), "BIO_gets"},
+{ERR_PACK(0,BIO_F_BIO_GET_ACCEPT_SOCKET,0), "BIO_get_accept_socket"},
+{ERR_PACK(0,BIO_F_BIO_GET_HOST_IP,0), "BIO_get_host_ip"},
+{ERR_PACK(0,BIO_F_BIO_GET_PORT,0), "BIO_get_port"},
+{ERR_PACK(0,BIO_F_BIO_MAKE_PAIR,0), "BIO_MAKE_PAIR"},
+{ERR_PACK(0,BIO_F_BIO_NEW,0), "BIO_new"},
+{ERR_PACK(0,BIO_F_BIO_NEW_FILE,0), "BIO_new_file"},
+{ERR_PACK(0,BIO_F_BIO_PUTS,0), "BIO_puts"},
+{ERR_PACK(0,BIO_F_BIO_READ,0), "BIO_read"},
+{ERR_PACK(0,BIO_F_BIO_SOCK_INIT,0), "BIO_sock_init"},
+{ERR_PACK(0,BIO_F_BIO_WRITE,0), "BIO_write"},
+{ERR_PACK(0,BIO_F_BUFFER_CTRL,0), "BUFFER_CTRL"},
+{ERR_PACK(0,BIO_F_CONN_STATE,0), "CONN_STATE"},
+{ERR_PACK(0,BIO_F_FILE_CTRL,0), "FILE_CTRL"},
+{ERR_PACK(0,BIO_F_MEM_WRITE,0), "MEM_WRITE"},
+{ERR_PACK(0,BIO_F_SSL_NEW,0), "SSL_new"},
+{ERR_PACK(0,BIO_F_WSASTARTUP,0), "WSASTARTUP"},
+{0,NULL}
+ };
+
+static ERR_STRING_DATA BIO_str_reasons[]=
+ {
+{BIO_R_ACCEPT_ERROR ,"accept error"},
+{BIO_R_BAD_FOPEN_MODE ,"bad fopen mode"},
+{BIO_R_BAD_HOSTNAME_LOOKUP ,"bad hostname lookup"},
+{BIO_R_BROKEN_PIPE ,"broken pipe"},
+{BIO_R_CONNECT_ERROR ,"connect error"},
+{BIO_R_ERROR_SETTING_NBIO ,"error setting nbio"},
+{BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET,"error setting nbio on accepted socket"},
+{BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET,"error setting nbio on accept socket"},
+{BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET ,"gethostbyname addr is not af inet"},
+{BIO_R_INVALID_ARGUMENT ,"invalid argument"},
+{BIO_R_INVALID_IP_ADDRESS ,"invalid ip address"},
+{BIO_R_IN_USE ,"in use"},
+{BIO_R_KEEPALIVE ,"keepalive"},
+{BIO_R_NBIO_CONNECT_ERROR ,"nbio connect error"},
+{BIO_R_NO_ACCEPT_PORT_SPECIFIED ,"no accept port specified"},
+{BIO_R_NO_HOSTNAME_SPECIFIED ,"no hostname specified"},
+{BIO_R_NO_PORT_DEFINED ,"no port defined"},
+{BIO_R_NO_PORT_SPECIFIED ,"no port specified"},
+{BIO_R_NULL_PARAMETER ,"null parameter"},
+{BIO_R_TAG_MISMATCH ,"tag mismatch"},
+{BIO_R_UNABLE_TO_BIND_SOCKET ,"unable to bind socket"},
+{BIO_R_UNABLE_TO_CREATE_SOCKET ,"unable to create socket"},
+{BIO_R_UNABLE_TO_LISTEN_SOCKET ,"unable to listen socket"},
+{BIO_R_UNINITIALIZED ,"uninitialized"},
+{BIO_R_UNSUPPORTED_METHOD ,"unsupported method"},
+{BIO_R_WSASTARTUP ,"wsastartup"},
+{0,NULL}
+ };
+
+#endif
+
+void ERR_load_BIO_strings(void)
+ {
+ static int init=1;
+
+ if (init)
+ {
+ init=0;
+#ifndef NO_ERR
+ ERR_load_strings(ERR_LIB_BIO,BIO_str_functs);
+ ERR_load_strings(ERR_LIB_BIO,BIO_str_reasons);
+#endif
+
+ }
+ }
diff --git a/crypto/openssl/crypto/bio/bio_lib.c b/crypto/openssl/crypto/bio/bio_lib.c
new file mode 100644
index 000000000000..b72688ea901c
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bio_lib.c
@@ -0,0 +1,496 @@
+/* crypto/bio/bio_lib.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 <openssl/crypto.h>
+#include "cryptlib.h"
+#include <openssl/bio.h>
+#include <openssl/stack.h>
+
+static STACK *bio_meth=NULL;
+static int bio_meth_num=0;
+
+BIO *BIO_new(BIO_METHOD *method)
+ {
+ BIO *ret=NULL;
+
+ ret=(BIO *)Malloc(sizeof(BIO));
+ if (ret == NULL)
+ {
+ BIOerr(BIO_F_BIO_NEW,ERR_R_MALLOC_FAILURE);
+ return(NULL);
+ }
+ if (!BIO_set(ret,method))
+ {
+ Free(ret);
+ ret=NULL;
+ }
+ return(ret);
+ }
+
+int BIO_set(BIO *bio, BIO_METHOD *method)
+ {
+ bio->method=method;
+ bio->callback=NULL;
+ bio->cb_arg=NULL;
+ bio->init=0;
+ bio->shutdown=1;
+ bio->flags=0;
+ bio->retry_reason=0;
+ bio->num=0;
+ bio->ptr=NULL;
+ bio->prev_bio=NULL;
+ bio->next_bio=NULL;
+ bio->references=1;
+ bio->num_read=0L;
+ bio->num_write=0L;
+ CRYPTO_new_ex_data(bio_meth,(char *)bio,&bio->ex_data);
+ if (method->create != NULL)
+ if (!method->create(bio))
+ return(0);
+ return(1);
+ }
+
+int BIO_free(BIO *a)
+ {
+ int ret=0,i;
+
+ if (a == NULL) return(0);
+
+ i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_BIO);
+#ifdef REF_PRINT
+ REF_PRINT("BIO",a);
+#endif
+ if (i > 0) return(1);
+#ifdef REF_CHECK
+ if (i < 0)
+ {
+ fprintf(stderr,"BIO_free, bad reference count\n");
+ abort();
+ }
+#endif
+ if ((a->callback != NULL) &&
+ ((i=(int)a->callback(a,BIO_CB_FREE,NULL,0,0L,1L)) <= 0))
+ return(i);
+
+ CRYPTO_free_ex_data(bio_meth,(char *)a,&a->ex_data);
+
+ if ((a->method == NULL) || (a->method->destroy == NULL)) return(1);
+ ret=a->method->destroy(a);
+ Free(a);
+ return(1);
+ }
+
+int BIO_read(BIO *b, void *out, int outl)
+ {
+ int i;
+ long (*cb)();
+
+ if ((b == NULL) || (b->method == NULL) || (b->method->bread == NULL))
+ {
+ BIOerr(BIO_F_BIO_READ,BIO_R_UNSUPPORTED_METHOD);
+ return(-2);
+ }
+
+ cb=b->callback;
+ if ((cb != NULL) &&
+ ((i=(int)cb(b,BIO_CB_READ,out,outl,0L,1L)) <= 0))
+ return(i);
+
+ if (!b->init)
+ {
+ BIOerr(BIO_F_BIO_READ,BIO_R_UNINITIALIZED);
+ return(-2);
+ }
+
+ i=b->method->bread(b,out,outl);
+
+ if (i > 0) b->num_read+=(unsigned long)i;
+
+ if (cb != NULL)
+ i=(int)cb(b,BIO_CB_READ|BIO_CB_RETURN,out,outl,
+ 0L,(long)i);
+ return(i);
+ }
+
+int BIO_write(BIO *b, const char *in, int inl)
+ {
+ int i;
+ long (*cb)();
+
+ if (b == NULL)
+ return(0);
+
+ cb=b->callback;
+ if ((b->method == NULL) || (b->method->bwrite == NULL))
+ {
+ BIOerr(BIO_F_BIO_WRITE,BIO_R_UNSUPPORTED_METHOD);
+ return(-2);
+ }
+
+ if ((cb != NULL) &&
+ ((i=(int)cb(b,BIO_CB_WRITE,in,inl,0L,1L)) <= 0))
+ return(i);
+
+ if (!b->init)
+ {
+ BIOerr(BIO_F_BIO_WRITE,BIO_R_UNINITIALIZED);
+ return(-2);
+ }
+
+ i=b->method->bwrite(b,in,inl);
+
+ if (i > 0) b->num_write+=(unsigned long)i;
+
+ /* This is evil and not thread safe. If the BIO has been freed,
+ * we must not call the callback. The only way to be able to
+ * determine this is the reference count which is now invalid since
+ * the memory has been free()ed.
+ */
+ if (b->references <= 0) abort();
+ if (cb != NULL) /* && (b->references >= 1)) */
+ i=(int)cb(b,BIO_CB_WRITE|BIO_CB_RETURN,in,inl,
+ 0L,(long)i);
+ return(i);
+ }
+
+int BIO_puts(BIO *b, const char *in)
+ {
+ int i;
+ long (*cb)();
+
+ if ((b == NULL) || (b->method == NULL) || (b->method->bputs == NULL))
+ {
+ BIOerr(BIO_F_BIO_PUTS,BIO_R_UNSUPPORTED_METHOD);
+ return(-2);
+ }
+
+ cb=b->callback;
+
+ if ((cb != NULL) &&
+ ((i=(int)cb(b,BIO_CB_PUTS,in,0,0L,1L)) <= 0))
+ return(i);
+
+ if (!b->init)
+ {
+ BIOerr(BIO_F_BIO_PUTS,BIO_R_UNINITIALIZED);
+ return(-2);
+ }
+
+ i=b->method->bputs(b,in);
+
+ if (cb != NULL)
+ i=(int)cb(b,BIO_CB_PUTS|BIO_CB_RETURN,in,0,
+ 0L,(long)i);
+ return(i);
+ }
+
+int BIO_gets(BIO *b, char *in, int inl)
+ {
+ int i;
+ long (*cb)();
+
+ if ((b == NULL) || (b->method == NULL) || (b->method->bgets == NULL))
+ {
+ BIOerr(BIO_F_BIO_GETS,BIO_R_UNSUPPORTED_METHOD);
+ return(-2);
+ }
+
+ cb=b->callback;
+
+ if ((cb != NULL) &&
+ ((i=(int)cb(b,BIO_CB_GETS,in,inl,0L,1L)) <= 0))
+ return(i);
+
+ if (!b->init)
+ {
+ BIOerr(BIO_F_BIO_GETS,BIO_R_UNINITIALIZED);
+ return(-2);
+ }
+
+ i=b->method->bgets(b,in,inl);
+
+ if (cb != NULL)
+ i=(int)cb(b,BIO_CB_GETS|BIO_CB_RETURN,in,inl,
+ 0L,(long)i);
+ return(i);
+ }
+
+long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg)
+ {
+ int i;
+
+ i=iarg;
+ return(BIO_ctrl(b,cmd,larg,(char *)&i));
+ }
+
+char *BIO_ptr_ctrl(BIO *b, int cmd, long larg)
+ {
+ char *p=NULL;
+
+ if (BIO_ctrl(b,cmd,larg,(char *)&p) <= 0)
+ return(NULL);
+ else
+ return(p);
+ }
+
+long BIO_ctrl(BIO *b, int cmd, long larg, void *parg)
+ {
+ long ret;
+ long (*cb)();
+
+ if (b == NULL) return(0);
+
+ if ((b->method == NULL) || (b->method->ctrl == NULL))
+ {
+ BIOerr(BIO_F_BIO_CTRL,BIO_R_UNSUPPORTED_METHOD);
+ return(-2);
+ }
+
+ cb=b->callback;
+
+ if ((cb != NULL) &&
+ ((ret=cb(b,BIO_CB_CTRL,parg,cmd,larg,1L)) <= 0))
+ return(ret);
+
+ ret=b->method->ctrl(b,cmd,larg,parg);
+
+ if (cb != NULL)
+ ret=cb(b,BIO_CB_CTRL|BIO_CB_RETURN,parg,cmd,
+ larg,ret);
+ return(ret);
+ }
+
+/* It is unfortunate to duplicate in functions what the BIO_(w)pending macros
+ * do; but those macros have inappropriate return type, and for interfacing
+ * from other programming languages, C macros aren't much of a help anyway. */
+size_t BIO_ctrl_pending(BIO *bio)
+ {
+ return BIO_ctrl(bio, BIO_CTRL_PENDING, 0, NULL);
+ }
+
+size_t BIO_ctrl_wpending(BIO *bio)
+ {
+ return BIO_ctrl(bio, BIO_CTRL_WPENDING, 0, NULL);
+ }
+
+
+/* put the 'bio' on the end of b's list of operators */
+BIO *BIO_push(BIO *b, BIO *bio)
+ {
+ BIO *lb;
+
+ if (b == NULL) return(bio);
+ lb=b;
+ while (lb->next_bio != NULL)
+ lb=lb->next_bio;
+ lb->next_bio=bio;
+ if (bio != NULL)
+ bio->prev_bio=lb;
+ /* called to do internal processing */
+ BIO_ctrl(b,BIO_CTRL_PUSH,0,NULL);
+ return(b);
+ }
+
+/* Remove the first and return the rest */
+BIO *BIO_pop(BIO *b)
+ {
+ BIO *ret;
+
+ if (b == NULL) return(NULL);
+ ret=b->next_bio;
+
+ if (b->prev_bio != NULL)
+ b->prev_bio->next_bio=b->next_bio;
+ if (b->next_bio != NULL)
+ b->next_bio->prev_bio=b->prev_bio;
+
+ b->next_bio=NULL;
+ b->prev_bio=NULL;
+ BIO_ctrl(b,BIO_CTRL_POP,0,NULL);
+ return(ret);
+ }
+
+BIO *BIO_get_retry_BIO(BIO *bio, int *reason)
+ {
+ BIO *b,*last;
+
+ b=last=bio;
+ for (;;)
+ {
+ if (!BIO_should_retry(b)) break;
+ last=b;
+ b=b->next_bio;
+ if (b == NULL) break;
+ }
+ if (reason != NULL) *reason=last->retry_reason;
+ return(last);
+ }
+
+int BIO_get_retry_reason(BIO *bio)
+ {
+ return(bio->retry_reason);
+ }
+
+BIO *BIO_find_type(BIO *bio, int type)
+ {
+ int mt,mask;
+
+ mask=type&0xff;
+ do {
+ if (bio->method != NULL)
+ {
+ mt=bio->method->type;
+
+ if (!mask)
+ {
+ if (mt & type) return(bio);
+ }
+ else if (mt == type)
+ return(bio);
+ }
+ bio=bio->next_bio;
+ } while (bio != NULL);
+ return(NULL);
+ }
+
+void BIO_free_all(BIO *bio)
+ {
+ BIO *b;
+ int ref;
+
+ while (bio != NULL)
+ {
+ b=bio;
+ ref=b->references;
+ bio=bio->next_bio;
+ BIO_free(b);
+ /* Since ref count > 1, don't free anyone else. */
+ if (ref > 1) break;
+ }
+ }
+
+BIO *BIO_dup_chain(BIO *in)
+ {
+ BIO *ret=NULL,*eoc=NULL,*bio,*new;
+
+ for (bio=in; bio != NULL; bio=bio->next_bio)
+ {
+ if ((new=BIO_new(bio->method)) == NULL) goto err;
+ new->callback=bio->callback;
+ new->cb_arg=bio->cb_arg;
+ new->init=bio->init;
+ new->shutdown=bio->shutdown;
+ new->flags=bio->flags;
+
+ /* This will let SSL_s_sock() work with stdin/stdout */
+ new->num=bio->num;
+
+ if (!BIO_dup_state(bio,(char *)new))
+ {
+ BIO_free(new);
+ goto err;
+ }
+
+ /* copy app data */
+ if (!CRYPTO_dup_ex_data(bio_meth,&new->ex_data,&bio->ex_data))
+ goto err;
+
+ if (ret == NULL)
+ {
+ eoc=new;
+ ret=eoc;
+ }
+ else
+ {
+ BIO_push(eoc,new);
+ eoc=new;
+ }
+ }
+ return(ret);
+err:
+ if (ret != NULL)
+ BIO_free(ret);
+ return(NULL);
+ }
+
+void BIO_copy_next_retry(BIO *b)
+ {
+ BIO_set_flags(b,BIO_get_retry_flags(b->next_bio));
+ b->retry_reason=b->next_bio->retry_reason;
+ }
+
+int BIO_get_ex_new_index(long argl, char *argp, int (*new_func)(),
+ int (*dup_func)(), void (*free_func)())
+ {
+ bio_meth_num++;
+ return(CRYPTO_get_ex_new_index(bio_meth_num-1,&bio_meth,
+ argl,argp,new_func,dup_func,free_func));
+ }
+
+int BIO_set_ex_data(BIO *bio, int idx, char *data)
+ {
+ return(CRYPTO_set_ex_data(&(bio->ex_data),idx,data));
+ }
+
+char *BIO_get_ex_data(BIO *bio, int idx)
+ {
+ return(CRYPTO_get_ex_data(&(bio->ex_data),idx));
+ }
+
diff --git a/crypto/openssl/crypto/bio/bss_acpt.c b/crypto/openssl/crypto/bio/bss_acpt.c
new file mode 100644
index 000000000000..47af80f76d51
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_acpt.c
@@ -0,0 +1,466 @@
+/* crypto/bio/bss_acpt.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.]
+ */
+
+#ifndef NO_SOCK
+
+#include <stdio.h>
+#include <errno.h>
+#define USE_SOCKETS
+#include "cryptlib.h"
+#include <openssl/bio.h>
+
+#ifdef WIN16
+#define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
+#else
+#define SOCKET_PROTOCOL IPPROTO_TCP
+#endif
+
+#if (defined(VMS) && __VMS_VER < 70000000)
+/* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
+#undef FIONBIO
+#endif
+
+typedef struct bio_accept_st
+ {
+ int state;
+ char *param_addr;
+
+ int accept_sock;
+ int accept_nbio;
+
+ char *addr;
+ int nbio;
+ /* If 0, it means normal, if 1, do a connect on bind failure,
+ * and if there is no-one listening, bind with SO_REUSEADDR.
+ * If 2, always use SO_REUSEADDR. */
+ int bind_mode;
+ BIO *bio_chain;
+ } BIO_ACCEPT;
+
+static int acpt_write(BIO *h,char *buf,int num);
+static int acpt_read(BIO *h,char *buf,int size);
+static int acpt_puts(BIO *h,char *str);
+static long acpt_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int acpt_new(BIO *h);
+static int acpt_free(BIO *data);
+static int acpt_state(BIO *b, BIO_ACCEPT *c);
+static void acpt_close_socket(BIO *data);
+BIO_ACCEPT *BIO_ACCEPT_new(void );
+void BIO_ACCEPT_free(BIO_ACCEPT *a);
+
+#define ACPT_S_BEFORE 1
+#define ACPT_S_GET_ACCEPT_SOCKET 2
+#define ACPT_S_OK 3
+
+static BIO_METHOD methods_acceptp=
+ {
+ BIO_TYPE_ACCEPT,
+ "socket accept",
+ acpt_write,
+ acpt_read,
+ acpt_puts,
+ NULL, /* connect_gets, */
+ acpt_ctrl,
+ acpt_new,
+ acpt_free,
+ };
+
+BIO_METHOD *BIO_s_accept(void)
+ {
+ return(&methods_acceptp);
+ }
+
+static int acpt_new(BIO *bi)
+ {
+ BIO_ACCEPT *ba;
+
+ bi->init=0;
+ bi->num=INVALID_SOCKET;
+ bi->flags=0;
+ if ((ba=BIO_ACCEPT_new()) == NULL)
+ return(0);
+ bi->ptr=(char *)ba;
+ ba->state=ACPT_S_BEFORE;
+ bi->shutdown=1;
+ return(1);
+ }
+
+BIO_ACCEPT *BIO_ACCEPT_new(void)
+ {
+ BIO_ACCEPT *ret;
+
+ if ((ret=(BIO_ACCEPT *)Malloc(sizeof(BIO_ACCEPT))) == NULL)
+ return(NULL);
+
+ memset(ret,0,sizeof(BIO_ACCEPT));
+ ret->accept_sock=INVALID_SOCKET;
+ ret->bind_mode=BIO_BIND_NORMAL;
+ return(ret);
+ }
+
+void BIO_ACCEPT_free(BIO_ACCEPT *a)
+ {
+ if(a == NULL)
+ return;
+
+ if (a->param_addr != NULL) Free(a->param_addr);
+ if (a->addr != NULL) Free(a->addr);
+ if (a->bio_chain != NULL) BIO_free(a->bio_chain);
+ Free(a);
+ }
+
+static void acpt_close_socket(BIO *bio)
+ {
+ BIO_ACCEPT *c;
+
+ c=(BIO_ACCEPT *)bio->ptr;
+ if (c->accept_sock != INVALID_SOCKET)
+ {
+ shutdown(c->accept_sock,2);
+ closesocket(c->accept_sock);
+ c->accept_sock=INVALID_SOCKET;
+ bio->num=INVALID_SOCKET;
+ }
+ }
+
+static int acpt_free(BIO *a)
+ {
+ BIO_ACCEPT *data;
+
+ if (a == NULL) return(0);
+ data=(BIO_ACCEPT *)a->ptr;
+
+ if (a->shutdown)
+ {
+ acpt_close_socket(a);
+ BIO_ACCEPT_free(data);
+ a->ptr=NULL;
+ a->flags=0;
+ a->init=0;
+ }
+ return(1);
+ }
+
+static int acpt_state(BIO *b, BIO_ACCEPT *c)
+ {
+ BIO *bio=NULL,*dbio;
+ int s= -1;
+ int i;
+
+again:
+ switch (c->state)
+ {
+ case ACPT_S_BEFORE:
+ if (c->param_addr == NULL)
+ {
+ BIOerr(BIO_F_ACPT_STATE,BIO_R_NO_ACCEPT_PORT_SPECIFIED);
+ return(-1);
+ }
+ s=BIO_get_accept_socket(c->param_addr,c->bind_mode);
+ if (s == INVALID_SOCKET)
+ return(-1);
+
+ if (c->accept_nbio)
+ {
+ if (!BIO_socket_nbio(s,1))
+ {
+ closesocket(s);
+ BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET);
+ return(-1);
+ }
+ }
+ c->accept_sock=s;
+ b->num=s;
+ c->state=ACPT_S_GET_ACCEPT_SOCKET;
+ return(1);
+ /* break; */
+ case ACPT_S_GET_ACCEPT_SOCKET:
+ if (b->next_bio != NULL)
+ {
+ c->state=ACPT_S_OK;
+ goto again;
+ }
+ i=BIO_accept(c->accept_sock,&(c->addr));
+ if (i < 0) return(i);
+ bio=BIO_new_socket(i,BIO_CLOSE);
+ if (bio == NULL) goto err;
+
+ BIO_set_callback(bio,BIO_get_callback(b));
+ BIO_set_callback_arg(bio,BIO_get_callback_arg(b));
+
+ if (c->nbio)
+ {
+ if (!BIO_socket_nbio(i,1))
+ {
+ BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET);
+ goto err;
+ }
+ }
+
+ /* If the accept BIO has an bio_chain, we dup it and
+ * put the new socket at the end. */
+ if (c->bio_chain != NULL)
+ {
+ if ((dbio=BIO_dup_chain(c->bio_chain)) == NULL)
+ goto err;
+ if (!BIO_push(dbio,bio)) goto err;
+ bio=dbio;
+ }
+ if (BIO_push(b,bio) == NULL) goto err;
+
+ c->state=ACPT_S_OK;
+ return(1);
+err:
+ if (bio != NULL)
+ BIO_free(bio);
+ else if (s >= 0)
+ closesocket(s);
+ return(0);
+ /* break; */
+ case ACPT_S_OK:
+ if (b->next_bio == NULL)
+ {
+ c->state=ACPT_S_GET_ACCEPT_SOCKET;
+ goto again;
+ }
+ return(1);
+ /* break; */
+ default:
+ return(0);
+ /* break; */
+ }
+
+ }
+
+static int acpt_read(BIO *b, char *out, int outl)
+ {
+ int ret=0;
+ BIO_ACCEPT *data;
+
+ BIO_clear_retry_flags(b);
+ data=(BIO_ACCEPT *)b->ptr;
+
+ while (b->next_bio == NULL)
+ {
+ ret=acpt_state(b,data);
+ if (ret <= 0) return(ret);
+ }
+
+ ret=BIO_read(b->next_bio,out,outl);
+ BIO_copy_next_retry(b);
+ return(ret);
+ }
+
+static int acpt_write(BIO *b, char *in, int inl)
+ {
+ int ret;
+ BIO_ACCEPT *data;
+
+ BIO_clear_retry_flags(b);
+ data=(BIO_ACCEPT *)b->ptr;
+
+ while (b->next_bio == NULL)
+ {
+ ret=acpt_state(b,data);
+ if (ret <= 0) return(ret);
+ }
+
+ ret=BIO_write(b->next_bio,in,inl);
+ BIO_copy_next_retry(b);
+ return(ret);
+ }
+
+static long acpt_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ BIO *dbio;
+ int *ip;
+ long ret=1;
+ BIO_ACCEPT *data;
+ char **pp;
+
+ data=(BIO_ACCEPT *)b->ptr;
+
+ switch (cmd)
+ {
+ case BIO_CTRL_RESET:
+ ret=0;
+ data->state=ACPT_S_BEFORE;
+ acpt_close_socket(b);
+ b->flags=0;
+ break;
+ case BIO_C_DO_STATE_MACHINE:
+ /* use this one to start the connection */
+ ret=(long)acpt_state(b,data);
+ break;
+ case BIO_C_SET_ACCEPT:
+ if (ptr != NULL)
+ {
+ if (num == 0)
+ {
+ b->init=1;
+ if (data->param_addr != NULL)
+ Free(data->param_addr);
+ data->param_addr=BUF_strdup(ptr);
+ }
+ else if (num == 1)
+ {
+ data->accept_nbio=(ptr != NULL);
+ }
+ else if (num == 2)
+ {
+ if (data->bio_chain != NULL)
+ BIO_free(data->bio_chain);
+ data->bio_chain=(BIO *)ptr;
+ }
+ }
+ break;
+ case BIO_C_SET_NBIO:
+ data->nbio=(int)num;
+ break;
+ case BIO_C_SET_FD:
+ b->init=1;
+ b->num= *((int *)ptr);
+ data->accept_sock=b->num;
+ data->state=ACPT_S_GET_ACCEPT_SOCKET;
+ b->shutdown=(int)num;
+ b->init=1;
+ break;
+ case BIO_C_GET_FD:
+ if (b->init)
+ {
+ ip=(int *)ptr;
+ if (ip != NULL)
+ *ip=data->accept_sock;
+ ret=data->accept_sock;
+ }
+ else
+ ret= -1;
+ break;
+ case BIO_C_GET_ACCEPT:
+ if (b->init)
+ {
+ if (ptr != NULL)
+ {
+ pp=(char **)ptr;
+ *pp=data->param_addr;
+ }
+ else
+ ret= -1;
+ }
+ else
+ ret= -1;
+ break;
+ case BIO_CTRL_GET_CLOSE:
+ ret=b->shutdown;
+ break;
+ case BIO_CTRL_SET_CLOSE:
+ b->shutdown=(int)num;
+ break;
+ case BIO_CTRL_PENDING:
+ case BIO_CTRL_WPENDING:
+ ret=0;
+ break;
+ case BIO_CTRL_FLUSH:
+ break;
+ case BIO_C_SET_BIND_MODE:
+ data->bind_mode=(int)num;
+ break;
+ case BIO_C_GET_BIND_MODE:
+ ret=(long)data->bind_mode;
+ break;
+ case BIO_CTRL_DUP:
+ dbio=(BIO *)ptr;
+/* if (data->param_port) EAY EAY
+ BIO_set_port(dbio,data->param_port);
+ if (data->param_hostname)
+ BIO_set_hostname(dbio,data->param_hostname);
+ BIO_set_nbio(dbio,data->nbio); */
+ break;
+
+ default:
+ ret=0;
+ break;
+ }
+ return(ret);
+ }
+
+static int acpt_puts(BIO *bp, char *str)
+ {
+ int n,ret;
+
+ n=strlen(str);
+ ret=acpt_write(bp,str,n);
+ return(ret);
+ }
+
+BIO *BIO_new_accept(char *str)
+ {
+ BIO *ret;
+
+ ret=BIO_new(BIO_s_accept());
+ if (ret == NULL) return(NULL);
+ if (BIO_set_accept_port(ret,str))
+ return(ret);
+ else
+ {
+ BIO_free(ret);
+ return(NULL);
+ }
+ }
+
+#endif
diff --git a/crypto/openssl/crypto/bio/bss_bio.c b/crypto/openssl/crypto/bio/bss_bio.c
new file mode 100644
index 000000000000..562e9d8de274
--- /dev/null
+++ b/crypto/openssl/crypto/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/crypto/openssl/crypto/bio/bss_conn.c b/crypto/openssl/crypto/bio/bss_conn.c
new file mode 100644
index 000000000000..68c46e3d6994
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_conn.c
@@ -0,0 +1,618 @@
+/* crypto/bio/bss_conn.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.]
+ */
+
+#ifndef NO_SOCK
+
+#include <stdio.h>
+#include <errno.h>
+#define USE_SOCKETS
+#include "cryptlib.h"
+#include <openssl/bio.h>
+
+#ifdef WIN16
+#define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
+#else
+#define SOCKET_PROTOCOL IPPROTO_TCP
+#endif
+
+#if (defined(VMS) && __VMS_VER < 70000000)
+/* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
+#undef FIONBIO
+#endif
+
+
+typedef struct bio_connect_st
+ {
+ int state;
+
+ char *param_hostname;
+ char *param_port;
+ int nbio;
+
+ unsigned char ip[4];
+ unsigned short port;
+
+ struct sockaddr_in them;
+
+ /* int socket; this will be kept in bio->num so that it is
+ * compatable with the bss_sock bio */
+
+ /* called when the connection is initially made
+ * callback(BIO,state,ret); The callback should return
+ * 'ret'. state is for compatablity with the ssl info_callback */
+ int (*info_callback)();
+ } BIO_CONNECT;
+
+static int conn_write(BIO *h,char *buf,int num);
+static int conn_read(BIO *h,char *buf,int size);
+static int conn_puts(BIO *h,char *str);
+static long conn_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int conn_new(BIO *h);
+static int conn_free(BIO *data);
+
+static int conn_state(BIO *b, BIO_CONNECT *c);
+static void conn_close_socket(BIO *data);
+BIO_CONNECT *BIO_CONNECT_new(void );
+void BIO_CONNECT_free(BIO_CONNECT *a);
+
+static BIO_METHOD methods_connectp=
+ {
+ BIO_TYPE_CONNECT,
+ "socket connect",
+ conn_write,
+ conn_read,
+ conn_puts,
+ NULL, /* connect_gets, */
+ conn_ctrl,
+ conn_new,
+ conn_free,
+ };
+
+static int conn_state(BIO *b, BIO_CONNECT *c)
+ {
+ int ret= -1,i;
+ unsigned long l;
+ char *p,*q;
+ int (*cb)()=NULL;
+
+ if (c->info_callback != NULL)
+ cb=c->info_callback;
+
+ for (;;)
+ {
+ switch (c->state)
+ {
+ case BIO_CONN_S_BEFORE:
+ p=c->param_hostname;
+ if (p == NULL)
+ {
+ BIOerr(BIO_F_CONN_STATE,BIO_R_NO_HOSTNAME_SPECIFIED);
+ goto exit_loop;
+ }
+ for ( ; *p != '\0'; p++)
+ {
+ if ((*p == ':') || (*p == '/')) break;
+ }
+
+ i= *p;
+ if ((i == ':') || (i == '/'))
+ {
+
+ *(p++)='\0';
+ if (i == ':')
+ {
+ for (q=p; *q; q++)
+ if (*q == '/')
+ {
+ *q='\0';
+ break;
+ }
+ if (c->param_port != NULL)
+ Free(c->param_port);
+ c->param_port=BUF_strdup(p);
+ }
+ }
+
+ if (c->param_port == NULL)
+ {
+ BIOerr(BIO_F_CONN_STATE,BIO_R_NO_PORT_SPECIFIED);
+ ERR_add_error_data(2,"host=",c->param_hostname);
+ goto exit_loop;
+ }
+ c->state=BIO_CONN_S_GET_IP;
+ break;
+
+ case BIO_CONN_S_GET_IP:
+ if (BIO_get_host_ip(c->param_hostname,&(c->ip[0])) <= 0)
+ goto exit_loop;
+ c->state=BIO_CONN_S_GET_PORT;
+ break;
+
+ case BIO_CONN_S_GET_PORT:
+ if (c->param_port == NULL)
+ {
+ abort();
+ goto exit_loop;
+ }
+ else if (BIO_get_port(c->param_port,&c->port) <= 0)
+ goto exit_loop;
+ c->state=BIO_CONN_S_CREATE_SOCKET;
+ break;
+
+ case BIO_CONN_S_CREATE_SOCKET:
+ /* now setup address */
+ memset((char *)&c->them,0,sizeof(c->them));
+ c->them.sin_family=AF_INET;
+ c->them.sin_port=htons((unsigned short)c->port);
+ l=(unsigned long)
+ ((unsigned long)c->ip[0]<<24L)|
+ ((unsigned long)c->ip[1]<<16L)|
+ ((unsigned long)c->ip[2]<< 8L)|
+ ((unsigned long)c->ip[3]);
+ c->them.sin_addr.s_addr=htonl(l);
+ c->state=BIO_CONN_S_CREATE_SOCKET;
+
+ ret=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
+ if (ret == INVALID_SOCKET)
+ {
+ SYSerr(SYS_F_SOCKET,get_last_socket_error());
+ ERR_add_error_data(4,"host=",c->param_hostname,
+ ":",c->param_port);
+ BIOerr(BIO_F_CONN_STATE,BIO_R_UNABLE_TO_CREATE_SOCKET);
+ goto exit_loop;
+ }
+ b->num=ret;
+ c->state=BIO_CONN_S_NBIO;
+ break;
+
+ case BIO_CONN_S_NBIO:
+ if (c->nbio)
+ {
+ if (!BIO_socket_nbio(b->num,1))
+ {
+ BIOerr(BIO_F_CONN_STATE,BIO_R_ERROR_SETTING_NBIO);
+ ERR_add_error_data(4,"host=",
+ c->param_hostname,
+ ":",c->param_port);
+ goto exit_loop;
+ }
+ }
+ c->state=BIO_CONN_S_CONNECT;
+
+#ifdef SO_KEEPALIVE
+ i=1;
+ i=setsockopt(b->num,SOL_SOCKET,SO_KEEPALIVE,(char *)&i,sizeof(i));
+ if (i < 0)
+ {
+ SYSerr(SYS_F_SOCKET,get_last_socket_error());
+ ERR_add_error_data(4,"host=",c->param_hostname,
+ ":",c->param_port);
+ BIOerr(BIO_F_CONN_STATE,BIO_R_KEEPALIVE);
+ goto exit_loop;
+ }
+#endif
+ break;
+
+ case BIO_CONN_S_CONNECT:
+ BIO_clear_retry_flags(b);
+ ret=connect(b->num,
+ (struct sockaddr *)&c->them,
+ sizeof(c->them));
+ b->retry_reason=0;
+ if (ret < 0)
+ {
+ if (BIO_sock_should_retry(ret))
+ {
+ BIO_set_retry_special(b);
+ c->state=BIO_CONN_S_BLOCKED_CONNECT;
+ b->retry_reason=BIO_RR_CONNECT;
+ }
+ else
+ {
+ SYSerr(SYS_F_CONNECT,get_last_socket_error());
+ ERR_add_error_data(4,"host=",
+ c->param_hostname,
+ ":",c->param_port);
+ BIOerr(BIO_F_CONN_STATE,BIO_R_CONNECT_ERROR);
+ }
+ goto exit_loop;
+ }
+ else
+ c->state=BIO_CONN_S_OK;
+ break;
+
+ case BIO_CONN_S_BLOCKED_CONNECT:
+ i=BIO_sock_error(b->num);
+ if (i)
+ {
+ BIO_clear_retry_flags(b);
+ SYSerr(SYS_F_CONNECT,i);
+ ERR_add_error_data(4,"host=",
+ c->param_hostname,
+ ":",c->param_port);
+ BIOerr(BIO_F_CONN_STATE,BIO_R_NBIO_CONNECT_ERROR);
+ ret=0;
+ goto exit_loop;
+ }
+ else
+ c->state=BIO_CONN_S_OK;
+ break;
+
+ case BIO_CONN_S_OK:
+ ret=1;
+ goto exit_loop;
+ default:
+ abort();
+ goto exit_loop;
+ }
+
+ if (cb != NULL)
+ {
+ if (!(ret=cb((BIO *)b,c->state,ret)))
+ goto end;
+ }
+ }
+
+ /* Loop does not exit */
+exit_loop:
+ if (cb != NULL)
+ ret=cb((BIO *)b,c->state,ret);
+end:
+ return(ret);
+ }
+
+BIO_CONNECT *BIO_CONNECT_new(void)
+ {
+ BIO_CONNECT *ret;
+
+ if ((ret=(BIO_CONNECT *)Malloc(sizeof(BIO_CONNECT))) == NULL)
+ return(NULL);
+ ret->state=BIO_CONN_S_BEFORE;
+ ret->param_hostname=NULL;
+ ret->param_port=NULL;
+ ret->info_callback=NULL;
+ ret->nbio=0;
+ ret->ip[0]=0;
+ ret->ip[1]=0;
+ ret->ip[2]=0;
+ ret->ip[3]=0;
+ ret->port=0;
+ memset((char *)&ret->them,0,sizeof(ret->them));
+ return(ret);
+ }
+
+void BIO_CONNECT_free(BIO_CONNECT *a)
+ {
+ if(a == NULL)
+ return;
+
+ if (a->param_hostname != NULL)
+ Free(a->param_hostname);
+ if (a->param_port != NULL)
+ Free(a->param_port);
+ Free(a);
+ }
+
+BIO_METHOD *BIO_s_connect(void)
+ {
+ return(&methods_connectp);
+ }
+
+static int conn_new(BIO *bi)
+ {
+ bi->init=0;
+ bi->num=INVALID_SOCKET;
+ bi->flags=0;
+ if ((bi->ptr=(char *)BIO_CONNECT_new()) == NULL)
+ return(0);
+ else
+ return(1);
+ }
+
+static void conn_close_socket(BIO *bio)
+ {
+ BIO_CONNECT *c;
+
+ c=(BIO_CONNECT *)bio->ptr;
+ if (bio->num != INVALID_SOCKET)
+ {
+ /* Only do a shutdown if things were established */
+ if (c->state == BIO_CONN_S_OK)
+ shutdown(bio->num,2);
+ closesocket(bio->num);
+ bio->num=INVALID_SOCKET;
+ }
+ }
+
+static int conn_free(BIO *a)
+ {
+ BIO_CONNECT *data;
+
+ if (a == NULL) return(0);
+ data=(BIO_CONNECT *)a->ptr;
+
+ if (a->shutdown)
+ {
+ conn_close_socket(a);
+ BIO_CONNECT_free(data);
+ a->ptr=NULL;
+ a->flags=0;
+ a->init=0;
+ }
+ return(1);
+ }
+
+static int conn_read(BIO *b, char *out, int outl)
+ {
+ int ret=0;
+ BIO_CONNECT *data;
+
+ data=(BIO_CONNECT *)b->ptr;
+ if (data->state != BIO_CONN_S_OK)
+ {
+ ret=conn_state(b,data);
+ if (ret <= 0)
+ return(ret);
+ }
+
+ if (out != NULL)
+ {
+ clear_socket_error();
+ ret=readsocket(b->num,out,outl);
+ BIO_clear_retry_flags(b);
+ if (ret <= 0)
+ {
+ if (BIO_sock_should_retry(ret))
+ BIO_set_retry_read(b);
+ }
+ }
+ return(ret);
+ }
+
+static int conn_write(BIO *b, char *in, int inl)
+ {
+ int ret;
+ BIO_CONNECT *data;
+
+ data=(BIO_CONNECT *)b->ptr;
+ if (data->state != BIO_CONN_S_OK)
+ {
+ ret=conn_state(b,data);
+ if (ret <= 0) return(ret);
+ }
+
+ clear_socket_error();
+ ret=writesocket(b->num,in,inl);
+ BIO_clear_retry_flags(b);
+ if (ret <= 0)
+ {
+ if (BIO_sock_should_retry(ret))
+ BIO_set_retry_write(b);
+ }
+ return(ret);
+ }
+
+static long conn_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ BIO *dbio;
+ int *ip;
+ const char **pptr;
+ long ret=1;
+ BIO_CONNECT *data;
+
+ data=(BIO_CONNECT *)b->ptr;
+
+ switch (cmd)
+ {
+ case BIO_CTRL_RESET:
+ ret=0;
+ data->state=BIO_CONN_S_BEFORE;
+ conn_close_socket(b);
+ b->flags=0;
+ break;
+ case BIO_C_DO_STATE_MACHINE:
+ /* use this one to start the connection */
+ if (!data->state != BIO_CONN_S_OK)
+ ret=(long)conn_state(b,data);
+ else
+ ret=1;
+ break;
+ case BIO_C_GET_CONNECT:
+ if (ptr != NULL)
+ {
+ pptr=(const char **)ptr;
+ if (num == 0)
+ {
+ *pptr=data->param_hostname;
+
+ }
+ else if (num == 1)
+ {
+ *pptr=data->param_port;
+ }
+ else if (num == 2)
+ {
+ *pptr= (char *)&(data->ip[0]);
+ }
+ else if (num == 3)
+ {
+ *((int *)ptr)=data->port;
+ }
+ if ((!b->init) || (ptr == NULL))
+ *pptr="not initalised";
+ ret=1;
+ }
+ break;
+ case BIO_C_SET_CONNECT:
+ if (ptr != NULL)
+ {
+ b->init=1;
+ if (num == 0)
+ {
+ if (data->param_hostname != NULL)
+ Free(data->param_hostname);
+ data->param_hostname=BUF_strdup(ptr);
+ }
+ else if (num == 1)
+ {
+ if (data->param_port != NULL)
+ Free(data->param_port);
+ data->param_port=BUF_strdup(ptr);
+ }
+ else if (num == 2)
+ {
+ char buf[16];
+
+ sprintf(buf,"%d.%d.%d.%d",
+ ptr[0],ptr[1],ptr[2],ptr[3]);
+ if (data->param_hostname != NULL)
+ Free(data->param_hostname);
+ data->param_hostname=BUF_strdup(buf);
+ memcpy(&(data->ip[0]),ptr,4);
+ }
+ else if (num == 3)
+ {
+ char buf[16];
+
+ sprintf(buf,"%d",*(int *)ptr);
+ if (data->param_port != NULL)
+ Free(data->param_port);
+ data->param_port=BUF_strdup(buf);
+ data->port= *(int *)ptr;
+ }
+ }
+ break;
+ case BIO_C_SET_NBIO:
+ data->nbio=(int)num;
+ break;
+ case BIO_C_GET_FD:
+ if (b->init)
+ {
+ ip=(int *)ptr;
+ if (ip != NULL)
+ *ip=b->num;
+ ret=b->num;
+ }
+ else
+ ret= -1;
+ break;
+ case BIO_CTRL_GET_CLOSE:
+ ret=b->shutdown;
+ break;
+ case BIO_CTRL_SET_CLOSE:
+ b->shutdown=(int)num;
+ break;
+ case BIO_CTRL_PENDING:
+ case BIO_CTRL_WPENDING:
+ ret=0;
+ break;
+ case BIO_CTRL_FLUSH:
+ break;
+ case BIO_CTRL_DUP:
+ dbio=(BIO *)ptr;
+ if (data->param_port)
+ BIO_set_conn_port(dbio,data->param_port);
+ if (data->param_hostname)
+ BIO_set_conn_hostname(dbio,data->param_hostname);
+ BIO_set_nbio(dbio,data->nbio);
+ (void)BIO_set_info_callback(dbio,data->info_callback);
+ break;
+ case BIO_CTRL_SET_CALLBACK:
+ data->info_callback=(int (*)())ptr;
+ break;
+ case BIO_CTRL_GET_CALLBACK:
+ {
+ int (**fptr)();
+
+ fptr=(int (**)())ptr;
+ *fptr=data->info_callback;
+ }
+ break;
+ default:
+ ret=0;
+ break;
+ }
+ return(ret);
+ }
+
+static int conn_puts(BIO *bp, char *str)
+ {
+ int n,ret;
+
+ n=strlen(str);
+ ret=conn_write(bp,str,n);
+ return(ret);
+ }
+
+BIO *BIO_new_connect(char *str)
+ {
+ BIO *ret;
+
+ ret=BIO_new(BIO_s_connect());
+ if (ret == NULL) return(NULL);
+ if (BIO_set_conn_hostname(ret,str))
+ return(ret);
+ else
+ {
+ BIO_free(ret);
+ return(NULL);
+ }
+ }
+
+#endif
+
diff --git a/crypto/openssl/crypto/bio/bss_fd.c b/crypto/openssl/crypto/bio/bss_fd.c
new file mode 100644
index 000000000000..686c4909a2a8
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_fd.c
@@ -0,0 +1,62 @@
+/* crypto/bio/bss_fd.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.]
+ */
+
+#define BIO_FD
+#include "bss_sock.c"
+#undef BIO_FD
+
diff --git a/crypto/openssl/crypto/bio/bss_file.c b/crypto/openssl/crypto/bio/bss_file.c
new file mode 100644
index 000000000000..52c0c39df045
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_file.c
@@ -0,0 +1,309 @@
+/* crypto/bio/bss_file.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.]
+ */
+
+/*
+ * 03-Dec-1997 rdenny@dc3.com Fix bug preventing use of stdin/stdout
+ * with binary data (e.g. asn1parse -inform DER < xxx) under
+ * Windows
+ */
+
+#ifndef HEADER_BSS_FILE_C
+#define HEADER_BSS_FILE_C
+
+#include <stdio.h>
+#include <errno.h>
+#include "cryptlib.h"
+#include <openssl/bio.h>
+#include <openssl/err.h>
+
+#if !defined(NO_STDIO)
+
+static int MS_CALLBACK file_write(BIO *h,char *buf,int num);
+static int MS_CALLBACK file_read(BIO *h,char *buf,int size);
+static int MS_CALLBACK file_puts(BIO *h,char *str);
+static int MS_CALLBACK file_gets(BIO *h,char *str,int size);
+static long MS_CALLBACK file_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int MS_CALLBACK file_new(BIO *h);
+static int MS_CALLBACK file_free(BIO *data);
+static BIO_METHOD methods_filep=
+ {
+ BIO_TYPE_FILE,
+ "FILE pointer",
+ file_write,
+ file_read,
+ file_puts,
+ file_gets,
+ file_ctrl,
+ file_new,
+ file_free,
+ };
+
+BIO *BIO_new_file(const char *filename, const char *mode)
+ {
+ BIO *ret;
+ FILE *file;
+
+ if ((file=fopen(filename,mode)) == NULL)
+ {
+ SYSerr(SYS_F_FOPEN,get_last_sys_error());
+ ERR_add_error_data(5,"fopen('",filename,"','",mode,"')");
+ BIOerr(BIO_F_BIO_NEW_FILE,ERR_R_SYS_LIB);
+ return(NULL);
+ }
+ if ((ret=BIO_new(BIO_s_file_internal())) == NULL)
+ return(NULL);
+
+ BIO_set_fp(ret,file,BIO_CLOSE);
+ return(ret);
+ }
+
+BIO *BIO_new_fp(FILE *stream, int close_flag)
+ {
+ BIO *ret;
+
+ if ((ret=BIO_new(BIO_s_file())) == NULL)
+ return(NULL);
+
+ BIO_set_fp(ret,stream,close_flag);
+ return(ret);
+ }
+
+BIO_METHOD *BIO_s_file(void)
+ {
+ return(&methods_filep);
+ }
+
+static int MS_CALLBACK file_new(BIO *bi)
+ {
+ bi->init=0;
+ bi->num=0;
+ bi->ptr=NULL;
+ return(1);
+ }
+
+static int MS_CALLBACK file_free(BIO *a)
+ {
+ if (a == NULL) return(0);
+ if (a->shutdown)
+ {
+ if ((a->init) && (a->ptr != NULL))
+ {
+ fclose((FILE *)a->ptr);
+ a->ptr=NULL;
+ }
+ a->init=0;
+ }
+ return(1);
+ }
+
+static int MS_CALLBACK file_read(BIO *b, char *out, int outl)
+ {
+ int ret=0;
+
+ if (b->init && (out != NULL))
+ {
+ ret=fread(out,1,(int)outl,(FILE *)b->ptr);
+ }
+ return(ret);
+ }
+
+static int MS_CALLBACK file_write(BIO *b, char *in, int inl)
+ {
+ int ret=0;
+
+ if (b->init && (in != NULL))
+ {
+ if (fwrite(in,(int)inl,1,(FILE *)b->ptr))
+ ret=inl;
+ /* ret=fwrite(in,1,(int)inl,(FILE *)b->ptr); */
+ /* acording to Tim Hudson <tjh@cryptsoft.com>, the commented
+ * out version above can cause 'inl' write calls under
+ * some stupid stdio implementations (VMS) */
+ }
+ return(ret);
+ }
+
+static long MS_CALLBACK file_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ long ret=1;
+ FILE *fp=(FILE *)b->ptr;
+ FILE **fpp;
+ char p[4];
+
+ switch (cmd)
+ {
+ case BIO_C_FILE_SEEK:
+ case BIO_CTRL_RESET:
+ ret=(long)fseek(fp,num,0);
+ break;
+ case BIO_CTRL_EOF:
+ ret=(long)feof(fp);
+ break;
+ case BIO_C_FILE_TELL:
+ case BIO_CTRL_INFO:
+ ret=ftell(fp);
+ break;
+ case BIO_C_SET_FILE_PTR:
+ file_free(b);
+ b->shutdown=(int)num&BIO_CLOSE;
+ b->ptr=(char *)ptr;
+ b->init=1;
+#if defined(MSDOS) || defined(WINDOWS)
+ /* Set correct text/binary mode */
+ if (num & BIO_FP_TEXT)
+ _setmode(fileno((FILE *)ptr),_O_TEXT);
+ else
+ _setmode(fileno((FILE *)ptr),_O_BINARY);
+#endif
+ break;
+ case BIO_C_SET_FILENAME:
+ file_free(b);
+ b->shutdown=(int)num&BIO_CLOSE;
+ if (num & BIO_FP_APPEND)
+ {
+ if (num & BIO_FP_READ)
+ strcpy(p,"a+");
+ else strcpy(p,"a");
+ }
+ else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE))
+ strcpy(p,"r+");
+ else if (num & BIO_FP_WRITE)
+ strcpy(p,"w");
+ else if (num & BIO_FP_READ)
+ strcpy(p,"r");
+ else
+ {
+ BIOerr(BIO_F_FILE_CTRL,BIO_R_BAD_FOPEN_MODE);
+ ret=0;
+ break;
+ }
+#if defined(MSDOS) || defined(WINDOWS)
+ if (!(num & BIO_FP_TEXT))
+ strcat(p,"b");
+ else
+ strcat(p,"t");
+#endif
+ fp=fopen(ptr,p);
+ if (fp == NULL)
+ {
+ SYSerr(SYS_F_FOPEN,get_last_sys_error());
+ ERR_add_error_data(5,"fopen('",ptr,"','",p,"')");
+ BIOerr(BIO_F_FILE_CTRL,ERR_R_SYS_LIB);
+ ret=0;
+ break;
+ }
+ b->ptr=(char *)fp;
+ b->init=1;
+ break;
+ case BIO_C_GET_FILE_PTR:
+ /* the ptr parameter is actually a FILE ** in this case. */
+ if (ptr != NULL)
+ {
+ fpp=(FILE **)ptr;
+ *fpp=(FILE *)b->ptr;
+ }
+ break;
+ case BIO_CTRL_GET_CLOSE:
+ ret=(long)b->shutdown;
+ break;
+ case BIO_CTRL_SET_CLOSE:
+ b->shutdown=(int)num;
+ break;
+ case BIO_CTRL_FLUSH:
+ fflush((FILE *)b->ptr);
+ break;
+ case BIO_CTRL_DUP:
+ ret=1;
+ break;
+
+ case BIO_CTRL_WPENDING:
+ case BIO_CTRL_PENDING:
+ case BIO_CTRL_PUSH:
+ case BIO_CTRL_POP:
+ default:
+ ret=0;
+ break;
+ }
+ return(ret);
+ }
+
+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 (buf[0] != '\0')
+ ret=strlen(buf);
+ return(ret);
+ }
+
+static int MS_CALLBACK file_puts(BIO *bp, char *str)
+ {
+ int n,ret;
+
+ n=strlen(str);
+ ret=file_write(bp,str,n);
+ return(ret);
+ }
+
+#endif /* NO_STDIO */
+
+#endif /* HEADER_BSS_FILE_C */
+
+
diff --git a/crypto/openssl/crypto/bio/bss_log.c b/crypto/openssl/crypto/bio/bss_log.c
new file mode 100644
index 000000000000..db82e757e7a5
--- /dev/null
+++ b/crypto/openssl/crypto/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
diff --git a/crypto/openssl/crypto/bio/bss_mem.c b/crypto/openssl/crypto/bio/bss_mem.c
new file mode 100644
index 000000000000..7e749a503ef3
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_mem.c
@@ -0,0 +1,276 @@
+/* crypto/bio/bss_mem.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>
+
+static int mem_write(BIO *h,char *buf,int num);
+static int mem_read(BIO *h,char *buf,int size);
+static int mem_puts(BIO *h,char *str);
+static int mem_gets(BIO *h,char *str,int size);
+static long mem_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int mem_new(BIO *h);
+static int mem_free(BIO *data);
+static BIO_METHOD mem_method=
+ {
+ BIO_TYPE_MEM,
+ "memory buffer",
+ mem_write,
+ mem_read,
+ mem_puts,
+ mem_gets,
+ mem_ctrl,
+ mem_new,
+ mem_free,
+ };
+
+/* bio->num is used to hold the value to return on 'empty', if it is
+ * 0, should_retry is not set */
+
+BIO_METHOD *BIO_s_mem(void)
+ {
+ return(&mem_method);
+ }
+
+static int mem_new(BIO *bi)
+ {
+ BUF_MEM *b;
+
+ if ((b=BUF_MEM_new()) == NULL)
+ return(0);
+ bi->shutdown=1;
+ bi->init=1;
+ bi->num= -1;
+ bi->ptr=(char *)b;
+ return(1);
+ }
+
+static int mem_free(BIO *a)
+ {
+ if (a == NULL) return(0);
+ if (a->shutdown)
+ {
+ if ((a->init) && (a->ptr != NULL))
+ {
+ BUF_MEM_free((BUF_MEM *)a->ptr);
+ a->ptr=NULL;
+ }
+ }
+ return(1);
+ }
+
+static int mem_read(BIO *b, char *out, int outl)
+ {
+ int ret= -1;
+ BUF_MEM *bm;
+ int i;
+ char *from,*to;
+
+ bm=(BUF_MEM *)b->ptr;
+ BIO_clear_retry_flags(b);
+ ret=(outl > bm->length)?bm->length:outl;
+ if ((out != NULL) && (ret > 0))
+ {
+ memcpy(out,bm->data,ret);
+ bm->length-=ret;
+ /* memmove(&(bm->data[0]),&(bm->data[ret]), bm->length); */
+ from=(char *)&(bm->data[ret]);
+ to=(char *)&(bm->data[0]);
+ for (i=0; i<bm->length; i++)
+ to[i]=from[i];
+ }
+ else if (bm->length == 0)
+ {
+ if (b->num != 0)
+ BIO_set_retry_read(b);
+ ret= b->num;
+ }
+ return(ret);
+ }
+
+static int mem_write(BIO *b, char *in, int inl)
+ {
+ int ret= -1;
+ int blen;
+ BUF_MEM *bm;
+
+ bm=(BUF_MEM *)b->ptr;
+ if (in == NULL)
+ {
+ BIOerr(BIO_F_MEM_WRITE,BIO_R_NULL_PARAMETER);
+ goto end;
+ }
+
+ BIO_clear_retry_flags(b);
+ blen=bm->length;
+ if (BUF_MEM_grow(bm,blen+inl) != (blen+inl))
+ goto end;
+ memcpy(&(bm->data[blen]),in,inl);
+ ret=inl;
+end:
+ return(ret);
+ }
+
+static long mem_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ long ret=1;
+ char **pptr;
+
+ BUF_MEM *bm=(BUF_MEM *)b->ptr;
+
+ switch (cmd)
+ {
+ case BIO_CTRL_RESET:
+ if (bm->data != NULL)
+ memset(bm->data,0,bm->max);
+ bm->length=0;
+ break;
+ case BIO_CTRL_EOF:
+ ret=(long)(bm->length == 0);
+ break;
+ case BIO_C_SET_BUF_MEM_EOF_RETURN:
+ b->num=(int)num;
+ break;
+ case BIO_CTRL_INFO:
+ ret=(long)bm->length;
+ if (ptr != NULL)
+ {
+ pptr=(char **)ptr;
+ *pptr=(char *)&(bm->data[0]);
+ }
+ break;
+ case BIO_C_SET_BUF_MEM:
+ mem_free(b);
+ b->shutdown=(int)num;
+ b->ptr=ptr;
+ break;
+ case BIO_C_GET_BUF_MEM_PTR:
+ if (ptr != NULL)
+ {
+ pptr=(char **)ptr;
+ *pptr=(char *)bm;
+ }
+ break;
+ case BIO_CTRL_GET_CLOSE:
+ ret=(long)b->shutdown;
+ break;
+ case BIO_CTRL_SET_CLOSE:
+ b->shutdown=(int)num;
+ break;
+
+ case BIO_CTRL_WPENDING:
+ ret=0L;
+ break;
+ case BIO_CTRL_PENDING:
+ ret=(long)bm->length;
+ break;
+ case BIO_CTRL_DUP:
+ case BIO_CTRL_FLUSH:
+ ret=1;
+ break;
+ case BIO_CTRL_PUSH:
+ case BIO_CTRL_POP:
+ default:
+ ret=0;
+ break;
+ }
+ return(ret);
+ }
+
+static int mem_gets(BIO *bp, char *buf, int size)
+ {
+ int i,j;
+ int ret= -1;
+ char *p;
+ BUF_MEM *bm=(BUF_MEM *)bp->ptr;
+
+ BIO_clear_retry_flags(bp);
+ j=bm->length;
+ if (j <= 0) return(0);
+ p=bm->data;
+ for (i=0; i<j; i++)
+ {
+ if (p[i] == '\n') break;
+ }
+ if (i == j)
+ {
+ BIO_set_retry_read(bp);
+ /* return(-1); change the semantics 0.6.6a */
+ }
+ else
+ i++;
+ /* i is the max to copy */
+ if ((size-1) < i) i=size-1;
+ i=mem_read(bp,buf,i);
+ if (i > 0) buf[i]='\0';
+ ret=i;
+ return(ret);
+ }
+
+static int mem_puts(BIO *bp, char *str)
+ {
+ int n,ret;
+
+ n=strlen(str);
+ ret=mem_write(bp,str,n);
+ /* memory semantics is that it will always work */
+ return(ret);
+ }
+
diff --git a/crypto/openssl/crypto/bio/bss_null.c b/crypto/openssl/crypto/bio/bss_null.c
new file mode 100644
index 000000000000..d04be888e53f
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_null.c
@@ -0,0 +1,149 @@
+/* crypto/bio/bss_null.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>
+
+static int null_write(BIO *h,char *buf,int num);
+static int null_read(BIO *h,char *buf,int size);
+static int null_puts(BIO *h,char *str);
+static int null_gets(BIO *h,char *str,int size);
+static long null_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int null_new(BIO *h);
+static int null_free(BIO *data);
+static BIO_METHOD null_method=
+ {
+ BIO_TYPE_NULL,
+ "NULL",
+ null_write,
+ null_read,
+ null_puts,
+ null_gets,
+ null_ctrl,
+ null_new,
+ null_free,
+ };
+
+BIO_METHOD *BIO_s_null(void)
+ {
+ return(&null_method);
+ }
+
+static int null_new(BIO *bi)
+ {
+ bi->init=1;
+ bi->num=0;
+ bi->ptr=(NULL);
+ return(1);
+ }
+
+static int null_free(BIO *a)
+ {
+ if (a == NULL) return(0);
+ return(1);
+ }
+
+static int null_read(BIO *b, char *out, int outl)
+ {
+ return(0);
+ }
+
+static int null_write(BIO *b, char *in, int inl)
+ {
+ return(inl);
+ }
+
+static long null_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ long ret=1;
+
+ switch (cmd)
+ {
+ case BIO_CTRL_RESET:
+ case BIO_CTRL_EOF:
+ case BIO_CTRL_SET:
+ case BIO_CTRL_SET_CLOSE:
+ case BIO_CTRL_FLUSH:
+ case BIO_CTRL_DUP:
+ ret=1;
+ break;
+ case BIO_CTRL_GET_CLOSE:
+ case BIO_CTRL_INFO:
+ case BIO_CTRL_GET:
+ case BIO_CTRL_PENDING:
+ case BIO_CTRL_WPENDING:
+ default:
+ ret=0;
+ break;
+ }
+ return(ret);
+ }
+
+static int null_gets(BIO *bp, char *buf, int size)
+ {
+ return(0);
+ }
+
+static int null_puts(BIO *bp, char *str)
+ {
+ if (str == NULL) return(0);
+ return(strlen(str));
+ }
+
diff --git a/crypto/openssl/crypto/bio/bss_rtcp.c b/crypto/openssl/crypto/bio/bss_rtcp.c
new file mode 100644
index 000000000000..2ef040057e3f
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_rtcp.c
@@ -0,0 +1,293 @@
+/* crypto/bio/bss_rtcp.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.]
+ */
+
+/* Written by David L. Jones <jonesd@kcgl1.eng.ohio-state.edu>
+ * Date: 22-JUL-1996
+ * Revised: 25-SEP-1997 Update for 0.8.1, BIO_CTRL_SET -> BIO_C_SET_FD
+ */
+/* VMS */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "cryptlib.h"
+#include <openssl/bio.h>
+
+#include <iodef.h> /* VMS IO$_ definitions */
+#include <starlet.h>
+
+typedef unsigned short io_channel;
+/*************************************************************************/
+struct io_status { short status, count; long flags; };
+
+struct rpc_msg { /* Should have member alignment inhibited */
+ char channel; /* 'A'-app data. 'R'-remote client 'G'-global */
+ char function; /* 'G'-get, 'P'-put, 'C'-confirm, 'X'-close */
+ unsigned short int length; /* Amount of data returned or max to return */
+ char data[4092]; /* variable data */
+};
+#define RPC_HDR_SIZE (sizeof(struct rpc_msg) - 4092)
+
+struct rpc_ctx {
+ int filled, pos;
+ struct rpc_msg msg;
+};
+
+static int rtcp_write(BIO *h,char *buf,int num);
+static int rtcp_read(BIO *h,char *buf,int size);
+static int rtcp_puts(BIO *h,char *str);
+static int rtcp_gets(BIO *h,char *str,int size);
+static long rtcp_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int rtcp_new(BIO *h);
+static int rtcp_free(BIO *data);
+
+static BIO_METHOD rtcp_method=
+ {
+ BIO_TYPE_FD,
+ "RTCP",
+ rtcp_write,
+ rtcp_read,
+ rtcp_puts,
+ rtcp_gets,
+ rtcp_ctrl,
+ rtcp_new,
+ rtcp_free,
+ };
+
+BIO_METHOD *BIO_s_rtcp(void)
+ {
+ return(&rtcp_method);
+ }
+/*****************************************************************************/
+/* Decnet I/O routines.
+ */
+
+#ifdef __DECC
+#pragma message save
+#pragma message disable DOLLARID
+#endif
+
+static int get ( io_channel chan, char *buffer, int maxlen, int *length )
+{
+ int status;
+ struct io_status iosb;
+ status = sys$qiow ( 0, chan, IO$_READVBLK, &iosb, 0, 0,
+ buffer, maxlen, 0, 0, 0, 0 );
+ if ( (status&1) == 1 ) status = iosb.status;
+ if ( (status&1) == 1 ) *length = iosb.count;
+ return status;
+}
+
+static int put ( io_channel chan, char *buffer, int length )
+{
+ int status;
+ struct io_status iosb;
+ status = sys$qiow ( 0, chan, IO$_WRITEVBLK, &iosb, 0, 0,
+ buffer, length, 0, 0, 0, 0 );
+ if ( (status&1) == 1 ) status = iosb.status;
+ return status;
+}
+
+#ifdef __DECC
+#pragma message restore
+#endif
+
+/***************************************************************************/
+
+static int rtcp_new(BIO *bi)
+{
+ struct rpc_ctx *ctx;
+ bi->init=1;
+ bi->num=0;
+ bi->flags = 0;
+ bi->ptr=Malloc(sizeof(struct rpc_ctx));
+ ctx = (struct rpc_ctx *) bi->ptr;
+ ctx->filled = 0;
+ ctx->pos = 0;
+ return(1);
+}
+
+static int rtcp_free(BIO *a)
+{
+ if (a == NULL) return(0);
+ if ( a->ptr ) Free ( a->ptr );
+ a->ptr = NULL;
+ return(1);
+}
+
+static int rtcp_read(BIO *b, char *out, int outl)
+{
+ int status, length;
+ struct rpc_ctx *ctx;
+ /*
+ * read data, return existing.
+ */
+ ctx = (struct rpc_ctx *) b->ptr;
+ if ( ctx->pos < ctx->filled ) {
+ length = ctx->filled - ctx->pos;
+ if ( length > outl ) length = outl;
+ memmove ( out, &ctx->msg.data[ctx->pos], length );
+ ctx->pos += length;
+ return length;
+ }
+ /*
+ * Requst more data from R channel.
+ */
+ ctx->msg.channel = 'R';
+ ctx->msg.function = 'G';
+ ctx->msg.length = sizeof(ctx->msg.data);
+ status = put ( b->num, (char *) &ctx->msg, RPC_HDR_SIZE );
+ if ( (status&1) == 0 ) {
+ return -1;
+ }
+ /*
+ * Read.
+ */
+ ctx->pos = ctx->filled = 0;
+ status = get ( b->num, (char *) &ctx->msg, sizeof(ctx->msg), &length );
+ if ( (status&1) == 0 ) length = -1;
+ if ( ctx->msg.channel != 'R' || ctx->msg.function != 'C' ) {
+ length = -1;
+ }
+ ctx->filled = length - RPC_HDR_SIZE;
+
+ if ( ctx->pos < ctx->filled ) {
+ length = ctx->filled - ctx->pos;
+ if ( length > outl ) length = outl;
+ memmove ( out, ctx->msg.data, length );
+ ctx->pos += length;
+ return length;
+ }
+
+ return length;
+}
+
+static int rtcp_write(BIO *b, char *in, int inl)
+{
+ int status, i, segment, length;
+ struct rpc_ctx *ctx;
+ /*
+ * Output data, send in chunks no larger that sizeof(ctx->msg.data).
+ */
+ ctx = (struct rpc_ctx *) b->ptr;
+ for ( i = 0; i < inl; i += segment ) {
+ segment = inl - i;
+ if ( segment > sizeof(ctx->msg.data) ) segment = sizeof(ctx->msg.data);
+ ctx->msg.channel = 'R';
+ ctx->msg.function = 'P';
+ ctx->msg.length = segment;
+ memmove ( ctx->msg.data, &in[i], segment );
+ status = put ( b->num, (char *) &ctx->msg, segment + RPC_HDR_SIZE );
+ if ((status&1) == 0 ) { i = -1; break; }
+
+ status = get ( b->num, (char *) &ctx->msg, sizeof(ctx->msg), &length );
+ if ( ((status&1) == 0) || (length < RPC_HDR_SIZE) ) { i = -1; break; }
+ if ( (ctx->msg.channel != 'R') || (ctx->msg.function != 'C') ) {
+ printf("unexpected response when confirming put %c %c\n",
+ ctx->msg.channel, ctx->msg.function );
+
+ }
+ }
+ return(i);
+}
+
+static long rtcp_ctrl(BIO *b, int cmd, long num, char *ptr)
+ {
+ long ret=1;
+
+ switch (cmd)
+ {
+ case BIO_CTRL_RESET:
+ case BIO_CTRL_EOF:
+ ret = 1;
+ break;
+ case BIO_C_SET_FD:
+ b->num = num;
+ ret = 1;
+ break;
+ case BIO_CTRL_SET_CLOSE:
+ case BIO_CTRL_FLUSH:
+ case BIO_CTRL_DUP:
+ ret=1;
+ break;
+ case BIO_CTRL_GET_CLOSE:
+ case BIO_CTRL_INFO:
+ case BIO_CTRL_GET:
+ case BIO_CTRL_PENDING:
+ case BIO_CTRL_WPENDING:
+ default:
+ ret=0;
+ break;
+ }
+ return(ret);
+ }
+
+static int rtcp_gets(BIO *bp, char *buf, int size)
+ {
+ return(0);
+ }
+
+static int rtcp_puts(BIO *bp, char *str)
+{
+ int length;
+ if (str == NULL) return(0);
+ length = strlen ( str );
+ if ( length == 0 ) return (0);
+ return rtcp_write ( bp,str, length );
+}
+
diff --git a/crypto/openssl/crypto/bio/bss_sock.c b/crypto/openssl/crypto/bio/bss_sock.c
new file mode 100644
index 000000000000..d336b99fe81a
--- /dev/null
+++ b/crypto/openssl/crypto/bio/bss_sock.c
@@ -0,0 +1,423 @@
+/* crypto/bio/bss_sock.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.]
+ */
+
+#if !defined(NO_SOCK) || defined(BIO_FD)
+
+#include <stdio.h>
+#include <errno.h>
+#define USE_SOCKETS
+#include "cryptlib.h"
+#include <openssl/bio.h>
+
+#ifndef BIO_FD
+static int sock_write(BIO *h,char *buf,int num);
+static int sock_read(BIO *h,char *buf,int size);
+static int sock_puts(BIO *h,char *str);
+static long sock_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int sock_new(BIO *h);
+static int sock_free(BIO *data);
+int BIO_sock_should_retry(int s);
+#else
+
+static int fd_write(BIO *h,char *buf,int num);
+static int fd_read(BIO *h,char *buf,int size);
+static int fd_puts(BIO *h,char *str);
+static long fd_ctrl(BIO *h,int cmd,long arg1,char *arg2);
+static int fd_new(BIO *h);
+static int fd_free(BIO *data);
+int BIO_fd_should_retry(int s);
+#endif
+
+#ifndef BIO_FD
+static BIO_METHOD methods_sockp=
+ {
+ BIO_TYPE_SOCKET,
+ "socket",
+ sock_write,
+ sock_read,
+ sock_puts,
+ NULL, /* sock_gets, */
+ sock_ctrl,
+ sock_new,
+ sock_free,
+ };
+
+BIO_METHOD *BIO_s_socket(void)
+ {
+ return(&methods_sockp);
+ }
+#else
+static BIO_METHOD methods_fdp=
+ {
+ BIO_TYPE_FD,"file descriptor",
+ fd_write,
+ fd_read,
+ fd_puts,
+ NULL, /* fd_gets, */
+ fd_ctrl,
+ fd_new,
+ fd_free,
+ };
+
+BIO_METHOD *BIO_s_fd(void)
+ {
+ return(&methods_fdp);
+ }
+#endif
+
+#ifndef BIO_FD
+BIO *BIO_new_socket(int fd, int close_flag)
+#else
+BIO *BIO_new_fd(int fd,int close_flag)
+#endif
+ {
+ BIO *ret;
+
+#ifndef BIO_FD
+ ret=BIO_new(BIO_s_socket());
+#else
+ ret=BIO_new(BIO_s_fd());
+#endif
+ if (ret == NULL) return(NULL);
+ BIO_set_fd(ret,fd,close_flag);
+ return(ret);
+ }
+
+#ifndef BIO_FD
+static int sock_new(BIO *bi)
+#else
+static int fd_new(BIO *bi)
+#endif
+ {
+ bi->init=0;
+ bi->num=0;
+ bi->ptr=NULL;
+ bi->flags=0;
+ return(1);
+ }
+
+#ifndef BIO_FD
+static int sock_free(BIO *a)
+#else
+static int fd_free(BIO *a)
+#endif
+ {
+ if (a == NULL) return(0);
+ if (a->shutdown)
+ {
+ if (a->init)
+ {
+#ifndef BIO_FD
+ shutdown(a->num,2);
+ closesocket(a->num);
+#else /* BIO_FD */
+ close(a->num);
+#endif
+
+ }
+ a->init=0;
+ a->flags=0;
+ }
+ return(1);
+ }
+
+#ifndef BIO_FD
+static int sock_read(BIO *b, char *out, int outl)
+#else
+static int fd_read(BIO *b, char *out,int outl)
+#endif
+ {
+ int ret=0;
+
+ if (out != NULL)
+ {
+#ifndef BIO_FD
+ clear_socket_error();
+ ret=readsocket(b->num,out,outl);
+#else
+ clear_sys_error();
+ ret=read(b->num,out,outl);
+#endif
+ BIO_clear_retry_flags(b);
+ if (ret <= 0)
+ {
+#ifndef BIO_FD
+ if (BIO_sock_should_retry(ret))
+#else
+ if (BIO_fd_should_retry(ret))
+#endif
+ BIO_set_retry_read(b);
+ }
+ }
+ return(ret);
+ }
+
+#ifndef BIO_FD
+static int sock_write(BIO *b, char *in, int inl)
+#else
+static int fd_write(BIO *b, char *in, int inl)
+#endif
+ {
+ int ret;
+
+#ifndef BIO_FD
+ clear_socket_error();
+ ret=writesocket(b->num,in,inl);
+#else
+ clear_sys_error();
+ ret=write(b->num,in,inl);
+#endif
+ BIO_clear_retry_flags(b);
+ if (ret <= 0)
+ {
+#ifndef BIO_FD
+ if (BIO_sock_should_retry(ret))
+#else
+ if (BIO_fd_should_retry(ret))
+#endif
+ BIO_set_retry_write(b);
+ }
+ return(ret);
+ }
+
+#ifndef BIO_FD
+static long sock_ctrl(BIO *b, int cmd, long num, char *ptr)
+#else
+static long fd_ctrl(BIO *b, int cmd, long num, char *ptr)
+#endif
+ {
+ long ret=1;
+ int *ip;
+
+ switch (cmd)
+ {
+ case BIO_CTRL_RESET:
+ num=0;
+ case BIO_C_FILE_SEEK:
+#ifdef BIO_FD
+ ret=(long)lseek(b->num,num,0);
+#else
+ ret=0;
+#endif
+ break;
+ case BIO_C_FILE_TELL:
+ case BIO_CTRL_INFO:
+#ifdef BIO_FD
+ ret=(long)lseek(b->num,0,1);
+#else
+ ret=0;
+#endif
+ break;
+ case BIO_C_SET_FD:
+#ifndef BIO_FD
+ sock_free(b);
+#else
+ fd_free(b);
+#endif
+ b->num= *((int *)ptr);
+ b->shutdown=(int)num;
+ b->init=1;
+ break;
+ case BIO_C_GET_FD:
+ if (b->init)
+ {
+ ip=(int *)ptr;
+ if (ip != NULL) *ip=b->num;
+ ret=b->num;
+ }
+ else
+ ret= -1;
+ break;
+ case BIO_CTRL_GET_CLOSE:
+ ret=b->shutdown;
+ break;
+ case BIO_CTRL_SET_CLOSE:
+ b->shutdown=(int)num;
+ break;
+ case BIO_CTRL_PENDING:
+ case BIO_CTRL_WPENDING:
+ ret=0;
+ break;
+ case BIO_CTRL_DUP:
+ case BIO_CTRL_FLUSH:
+ ret=1;
+ break;
+ default:
+ ret=0;
+ break;
+ }
+ return(ret);
+ }
+
+#ifdef undef
+static int sock_gets(BIO *bp, char *buf,int size)
+ {
+ return(-1);
+ }
+#endif
+
+#ifndef BIO_FD
+static int sock_puts(BIO *bp, char *str)
+#else
+static int fd_puts(BIO *bp, char *str)
+#endif
+ {
+ int n,ret;
+
+ n=strlen(str);
+#ifndef BIO_FD
+ ret=sock_write(bp,str,n);
+#else
+ ret=fd_write(bp,str,n);
+#endif
+ return(ret);
+ }
+
+#ifndef BIO_FD
+int BIO_sock_should_retry(int i)
+#else
+int BIO_fd_should_retry(int i)
+#endif
+ {
+ int err;
+
+ if ((i == 0) || (i == -1))
+ {
+#ifndef BIO_FD
+ err=get_last_socket_error();
+#else
+ err=get_last_sys_error();
+#endif
+
+#if defined(WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */
+ if ((i == -1) && (err == 0))
+ return(1);
+#endif
+
+#ifndef BIO_FD
+ return(BIO_sock_non_fatal_error(err));
+#else
+ return(BIO_fd_non_fatal_error(err));
+#endif
+ }
+ return(0);
+ }
+
+#ifndef BIO_FD
+int BIO_sock_non_fatal_error(int err)
+#else
+int BIO_fd_non_fatal_error(int err)
+#endif
+ {
+ switch (err)
+ {
+#if !defined(BIO_FD) && defined(WINDOWS)
+# if defined(WSAEWOULDBLOCK)
+ case WSAEWOULDBLOCK:
+# endif
+
+# if 0 /* This appears to always be an error */
+# if defined(WSAENOTCONN)
+ case WSAENOTCONN:
+# endif
+# endif
+#endif
+
+#ifdef EWOULDBLOCK
+# ifdef WSAEWOULDBLOCK
+# if WSAEWOULDBLOCK != EWOULDBLOCK
+ case EWOULDBLOCK:
+# endif
+# else
+ case EWOULDBLOCK:
+# endif
+#endif
+
+#if defined(ENOTCONN)
+ case ENOTCONN:
+#endif
+
+#ifdef EINTR
+ case EINTR:
+#endif
+
+#ifdef EAGAIN
+#if EWOULDBLOCK != EAGAIN
+ case EAGAIN:
+# endif
+#endif
+
+#ifdef EPROTO
+ case EPROTO:
+#endif
+
+#ifdef EINPROGRESS
+ case EINPROGRESS:
+#endif
+
+#ifdef EALREADY
+ case EALREADY:
+#endif
+ return(1);
+ /* break; */
+ default:
+ break;
+ }
+ return(0);
+ }
+#endif