Tue Feb 5 21:31:27 2013 UTC ()

merge changes


(christos)

--- src/crypto/external/bsd/openssl/dist/Configure 2012/07/26 19:58:36	1.3
+++ src/crypto/external/bsd/openssl/dist/Configure 2013/02/05 21:31:23	1.4

 @@ -161,40 +161,41 @@ my %table=(
 #"b",		"${tcc}:${tflags}::${tlib}:${bits1}:${tbn_mul}::",
 #"bl-4c-2c",	"${tcc}:${tflags}::${tlib}:${bits1}BN_LLONG RC4_CHAR MD2_CHAR:${tbn_mul}::",
 #"bl-4c-ri",	"${tcc}:${tflags}::${tlib}:${bits1}BN_LLONG RC4_CHAR RC4_INDEX:${tbn_mul}::",
 #"b2-is-ri-dp",	"${tcc}:${tflags}::${tlib}:${bits2}IDEA_SHORT RC4_INDEX DES_PTR:${tbn_mul}::",
 # Our development configs
 "purify",	"purify gcc:-g -DPURIFY -Wall::(unknown)::-lsocket -lnsl::::",
 "debug",	"gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DOPENSSL_NO_ASM -ggdb -g2 -Wformat -Wshadow -Wmissing-prototypes -Wmissing-declarations -Werror::(unknown)::-lefence::::",
 "debug-ben",	"gcc:$gcc_devteam_warn -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DDEBUG_SAFESTACK -O2 -pipe::(unknown):::::",
 "debug-ben-openbsd","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DPEDANTIC -DDEBUG_SAFESTACK -DOPENSSL_OPENBSD_DEV_CRYPTO -DOPENSSL_NO_ASM -O2 -pedantic -Wall -Wshadow -Werror -pipe::(unknown)::::",
 "debug-ben-openbsd-debug","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DPEDANTIC -DDEBUG_SAFESTACK -DOPENSSL_OPENBSD_DEV_CRYPTO -DOPENSSL_NO_ASM -g3 -O2 -pedantic -Wall -Wshadow -Werror -pipe::(unknown)::::",
 "debug-ben-debug",	"gcc44:$gcc_devteam_warn -DBN_DEBUG -DCONF_DEBUG -DDEBUG_SAFESTACK -DDEBUG_UNUSED -g3 -O2 -pipe::(unknown)::::::",
 "debug-ben-debug-64",	"gcc:$gcc_devteam_warn -Wno-error=overlength-strings -DBN_DEBUG -DCONF_DEBUG -DDEBUG_SAFESTACK -DDEBUG_UNUSED -g3 -O3 -pipe::${BSDthreads}:::SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL:${x86_64_asm}:elf:dlfcn:bsd-gcc-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-ben-macos",	"cc:$gcc_devteam_warn -arch i386 -DBN_DEBUG -DCONF_DEBUG -DDEBUG_SAFESTACK -DDEBUG_UNUSED -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -O3 -DL_ENDIAN -g3 -pipe::(unknown)::-Wl,-search_paths_first::::",
 "debug-ben-macos-gcc46",	"gcc-mp-4.6:$gcc_devteam_warn -Wconversion -DBN_DEBUG -DCONF_DEBUG -DDEBUG_SAFESTACK -DDEBUG_UNUSED -DOPENSSL_THREADS -D_REENTRANT -DDSO_DLFCN -DHAVE_DLFCN_H -O3 -DL_ENDIAN -g3 -pipe::(unknown)::::::",
 "debug-ben-no-opt",	"gcc: -Wall -Wmissing-prototypes -Wstrict-prototypes -Wmissing-declarations -DDEBUG_SAFESTACK -DCRYPTO_MDEBUG -Werror -DL_ENDIAN -DTERMIOS -Wall -g3::(unknown)::::::",
 "debug-ben-strict",	"gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DCONST_STRICT -O2 -Wall -Wshadow -Werror -Wpointer-arith -Wcast-qual -Wwrite-strings -pipe::(unknown)::::::",
 "debug-rse","cc:-DTERMIOS -DL_ENDIAN -pipe -O -g -ggdb3 -Wall::(unknown):::BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}",
 "debug-bodo",	"gcc:$gcc_devteam_warn -DBN_DEBUG -DBN_DEBUG_RAND -DCONF_DEBUG -DBIO_PAIR_DEBUG -m64 -DL_ENDIAN -DTERMIO -g -DMD32_REG_T=int::-D_REENTRANT::-ldl:SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL:${x86_64_asm}:elf:dlfcn:linux-shared:-fPIC:-m64:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):::64",
 "debug-ulf", "gcc:-DTERMIOS -DL_ENDIAN -march=i486 -Wall -DBN_DEBUG -DBN_DEBUG_RAND -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DOPENSSL_NO_ASM -g -Wformat -Wshadow -Wmissing-prototypes -Wmissing-declarations:::CYGWIN32:::${no_asm}:win32:cygwin-shared:::.dll",
-"debug-steve64", "gcc:$gcc_devteam_warn -m64 -DL_ENDIAN -DTERMIO -DCONF_DEBUG -DDEBUG_SAFESTACK -g::-D_REENTRANT::-ldl:SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL:${x86_64_asm}:elf:dlfcn:linux-shared:-fPIC:-m64:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
+"debug-steve64", "gcc:$gcc_devteam_warn -m64 -DL_ENDIAN -DTERMIO -DCONF_DEBUG -DDEBUG_SAFESTACK -Wno-overlength-strings -g::-D_REENTRANT::-ldl:SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL:${x86_64_asm}:elf:dlfcn:linux-shared:-fPIC:-m64:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-steve32", "gcc:$gcc_devteam_warn -m32 -DL_ENDIAN -DCONF_DEBUG -DDEBUG_SAFESTACK -g -pipe::-D_REENTRANT::-rdynamic -ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:linux-shared:-fPIC:-m32:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-steve-opt", "gcc:$gcc_devteam_warn -m64 -O3 -DL_ENDIAN -DTERMIO -DCONF_DEBUG -DDEBUG_SAFESTACK -g::-D_REENTRANT::-ldl:SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL:${x86_64_asm}:elf:dlfcn:linux-shared:-fPIC:-m64:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
-"debug-levitte-linux-elf","gcc:-DLEVITTE_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_DEBUG -DBN_DEBUG_RAND -DCRYPTO_MDEBUG -DENGINE_CONF_DEBUG -DL_ENDIAN -DTERMIO -D_POSIX_SOURCE -DPEDANTIC -ggdb -g3 -mcpu=i486 -pedantic -ansi -Wall -Wshadow -Wcast-align -Wstrict-prototypes -Wmissing-prototypes -Wno-long-long -Wundef -Wconversion -pipe::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
+"debug-levitte-linux-elf","gcc:-DLEVITTE_DEBUG -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DCRYPTO_MDEBUG -DL_ENDIAN -ggdb -g3 -Wall::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
-"debug-levitte-linux-noasm","gcc:-DLEVITTE_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_DEBUG -DBN_DEBUG_RAND -DCRYPTO_MDEBUG -DENGINE_CONF_DEBUG -DOPENSSL_NO_ASM -DL_ENDIAN -DTERMIO -D_POSIX_SOURCE -DPEDANTIC -ggdb -g3 -mcpu=i486 -pedantic -ansi -Wall -Wshadow -Wcast-align -Wstrict-prototypes -Wmissing-prototypes -Wno-long-long -Wundef -Wconversion -pipe::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
+"debug-levitte-linux-noasm","gcc:-DLEVITTE_DEBUG -DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DCRYPTO_MDEBUG -DOPENSSL_NO_ASM -DL_ENDIAN -ggdb -g3 -Wall::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
-"debug-levitte-linux-elf-extreme","gcc:-DLEVITTE_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_DEBUG -DBN_DEBUG_RAND -DCRYPTO_MDEBUG -DENGINE_CONF_DEBUG -DL_ENDIAN -DTERMIO -D_POSIX_SOURCE -DPEDANTIC -ggdb -g3 -mcpu=i486 -pedantic -ansi -Wall -W -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -Wmissing-prototypes -Wno-long-long -Wundef -Wconversion -pipe::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
+"debug-levitte-linux-elf-extreme","gcc:-DLEVITTE_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_DEBUG -DBN_DEBUG_RAND -DCRYPTO_MDEBUG -DENGINE_CONF_DEBUG -DL_ENDIAN -DTERMIO -DPEDANTIC -ggdb -g3 -pedantic -ansi -Wall -W -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -Wmissing-prototypes -Wno-long-long -Wundef -Wconversion -pipe::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
-"debug-levitte-linux-noasm-extreme","gcc:-DLEVITTE_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_DEBUG -DBN_DEBUG_RAND -DCRYPTO_MDEBUG -DENGINE_CONF_DEBUG -DOPENSSL_NO_ASM -DL_ENDIAN -DTERMIO -D_POSIX_SOURCE -DPEDANTIC -ggdb -g3 -mcpu=i486 -pedantic -ansi -Wall -W -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -Wmissing-prototypes -Wno-long-long -Wundef -Wconversion -pipe::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
+"debug-levitte-linux-noasm-extreme","gcc:-DLEVITTE_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_DEBUG -DBN_DEBUG_RAND -DCRYPTO_MDEBUG -DENGINE_CONF_DEBUG -DOPENSSL_NO_ASM -DL_ENDIAN -DTERMIO -DPEDANTIC -ggdb -g3 -pedantic -ansi -Wall -W -Wundef -Wshadow -Wcast-align -Wstrict-prototypes -Wmissing-prototypes -Wno-long-long -Wundef -Wconversion -pipe::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-geoff32","gcc:-DBN_DEBUG -DBN_DEBUG_RAND -DBN_STRICT -DPURIFY -DOPENSSL_NO_DEPRECATED -DOPENSSL_NO_ASM -DOPENSSL_NO_INLINE_ASM -DL_ENDIAN -DTERMIO -DPEDANTIC -O1 -ggdb2 -Wall -Werror -Wundef -pedantic -Wshadow -Wpointer-arith -Wbad-function-cast -Wcast-align -Wsign-compare -Wmissing-prototypes -Wmissing-declarations -Wno-long-long::-D_REENTRANT::-ldl:BN_LLONG:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-geoff64","gcc:-DBN_DEBUG -DBN_DEBUG_RAND -DBN_STRICT -DPURIFY -DOPENSSL_NO_DEPRECATED -DOPENSSL_NO_ASM -DOPENSSL_NO_INLINE_ASM -DL_ENDIAN -DTERMIO -DPEDANTIC -O1 -ggdb2 -Wall -Werror -Wundef -pedantic -Wshadow -Wpointer-arith -Wbad-function-cast -Wcast-align -Wsign-compare -Wmissing-prototypes -Wmissing-declarations -Wno-long-long::-D_REENTRANT::-ldl:SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-linux-pentium","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DL_ENDIAN -DTERMIO -g -mcpu=pentium -Wall::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn",
 "debug-linux-ppro","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DL_ENDIAN -DTERMIO -g -mcpu=pentiumpro -Wall::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn",
 "debug-linux-elf","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DL_ENDIAN -DTERMIO -g -march=i486 -Wall::-D_REENTRANT::-lefence -ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-linux-elf-noefence","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG -DL_ENDIAN -DTERMIO -g -march=i486 -Wall::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-linux-ia32-aes", "gcc:-DAES_EXPERIMENTAL -DL_ENDIAN -DTERMIO -O3 -fomit-frame-pointer -Wall::-D_REENTRANT::-ldl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:x86cpuid.o:bn-586.o co-586.o x86-mont.o:des-586.o crypt586.o:aes_x86core.o aes_cbc.o aesni-x86.o:bf-586.o:md5-586.o:sha1-586.o sha256-586.o sha512-586.o:cast-586.o:rc4-586.o:rmd-586.o:rc5-586.o:wp_block.o wp-mmx.o::ghash-x86.o::elf:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-linux-generic32","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DCRYPTO_MDEBUG -DTERMIO -g -Wall::-D_REENTRANT::-ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-linux-generic64","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DCRYPTO_MDEBUG -DTERMIO -g -Wall::-D_REENTRANT::-ldl:SIXTY_FOUR_BIT_LONG RC4_CHAR RC4_CHUNK DES_INT DES_UNROLL BF_PTR:${no_asm}:dlfcn:linux-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-linux-x86_64","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DCRYPTO_MDEBUG -m64 -DL_ENDIAN -DTERMIO -g -Wall::-D_REENTRANT::-ldl:SIXTY_FOUR_BIT_LONG RC4_CHUNK DES_INT DES_UNROLL:${x86_64_asm}:elf:dlfcn:linux-shared:-fPIC:-m64:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):::64",
 "dist",		"cc:-O::(unknown)::::::",
 # Basic configs that should work on any (32 and less bit) box
 @@ -233,27 +234,27 @@ my %table=(
 "solaris-sparcv9-gcc","gcc:-m32 -mcpu=ultrasparc -O3 -fomit-frame-pointer -Wall -DB_ENDIAN -DBN_DIV2W::-D_REENTRANT:ULTRASPARC:-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL BF_PTR:${sparcv9_asm}:dlfcn:solaris-shared:-fPIC:-shared:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "solaris64-sparcv9-gcc","gcc:-m64 -mcpu=ultrasparc -O3 -Wall -DB_ENDIAN::-D_REENTRANT:ULTRASPARC:-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${sparcv9_asm}:dlfcn:solaris-shared:-fPIC:-m64 -shared:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):::/64",
 ####
 "debug-solaris-sparcv8-gcc","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG_ALL -O -g -mv8 -Wall -DB_ENDIAN::-D_REENTRANT::-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL BF_PTR:${sparcv8_asm}:dlfcn:solaris-shared:-fPIC:-shared:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-solaris-sparcv9-gcc","gcc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG_ALL -DPEDANTIC -O -g -mcpu=ultrasparc -pedantic -ansi -Wall -Wshadow -Wno-long-long -D__EXTENSIONS__ -DB_ENDIAN -DBN_DIV2W::-D_REENTRANT:ULTRASPARC:-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL BF_PTR:${sparcv9_asm}:dlfcn:solaris-shared:-fPIC:-shared:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 #### SPARC Solaris with Sun C setups
 # SC4.0 doesn't pass 'make test', upgrade to SC5.0 or SC4.2.
 # SC4.2 is ok, better than gcc even on bn as long as you tell it -xarch=v8
 # SC5.0 note: Compiler common patch 107357-01 or later is required!
 "solaris-sparcv7-cc","cc:-xO5 -xstrconst -xdepend -Xa -DB_ENDIAN -DBN_DIV2W::-D_REENTRANT::-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${no_asm}:dlfcn:solaris-shared:-KPIC:-G -dy -z text:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "solaris-sparcv8-cc","cc:-xarch=v8 -xO5 -xstrconst -xdepend -Xa -DB_ENDIAN -DBN_DIV2W::-D_REENTRANT::-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${sparcv8_asm}:dlfcn:solaris-shared:-KPIC:-G -dy -z text:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "solaris-sparcv9-cc","cc:-xtarget=ultra -xarch=v8plus -xO5 -xstrconst -xdepend -Xa -DB_ENDIAN -DBN_DIV2W::-D_REENTRANT:ULTRASPARC:-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK_LL DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${sparcv9_asm}:dlfcn:solaris-shared:-KPIC:-G -dy -z text:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
-"solaris64-sparcv9-cc","cc:-xtarget=ultra -xarch=v9 -xO5 -xstrconst -xdepend -Xa -DB_ENDIAN::-D_REENTRANT:ULTRASPARC:-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${sparcv9_asm}:dlfcn:solaris-shared:-KPIC:-xarch=v9 -G -dy -z text:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):/usr/ccs/bin/ar rs::/64",
+"solaris64-sparcv9-cc","cc:-xtarget=ultra -xarch=v9 -xO5 -xstrconst -xdepend -Xa -DB_ENDIAN::-D_REENTRANT:ULTRASPARC:-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_INT DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${sparcv9_asm}:dlfcn:solaris-shared:-KPIC:-xarch=v9 -G -dy -z text:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR):::/64",
 ####
 "debug-solaris-sparcv8-cc","cc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG_ALL -xarch=v8 -g -O -xstrconst -Xa -DB_ENDIAN -DBN_DIV2W::-D_REENTRANT::-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${sparcv8_asm}:dlfcn:solaris-shared:-KPIC:-G -dy -z text:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "debug-solaris-sparcv9-cc","cc:-DBN_DEBUG -DREF_CHECK -DCONF_DEBUG -DBN_CTX_DEBUG -DCRYPTO_MDEBUG_ALL -xtarget=ultra -xarch=v8plus -g -O -xstrconst -Xa -DB_ENDIAN -DBN_DIV2W::-D_REENTRANT:ULTRASPARC:-lsocket -lnsl -ldl:BN_LLONG RC4_CHAR RC4_CHUNK_LL DES_PTR DES_RISC1 DES_UNROLL BF_PTR:${sparcv9_asm}:dlfcn:solaris-shared:-KPIC:-G -dy -z text:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 #### SunOS configs, assuming sparc for the gcc one.
 #"sunos-cc", "cc:-O4 -DNOPROTO -DNOCONST::(unknown):SUNOS::DES_UNROLL:${no_asm}::",
 "sunos-gcc","gcc:-O3 -mv8 -Dssize_t=int::(unknown):SUNOS::BN_LLONG RC4_CHAR RC4_CHUNK DES_UNROLL DES_PTR DES_RISC1:${no_asm}::",
 #### IRIX 5.x configs
 # -mips2 flag is added by ./config when appropriate.
 "irix-gcc","gcc:-O3 -DTERMIOS -DB_ENDIAN::(unknown):::BN_LLONG MD2_CHAR RC4_INDEX RC4_CHAR RC4_CHUNK DES_UNROLL DES_RISC2 DES_PTR BF_PTR:${mips32_asm}:o32:dlfcn:irix-shared:::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "irix-cc", "cc:-O2 -use_readonly_const -DTERMIOS -DB_ENDIAN::(unknown):::BN_LLONG RC4_CHAR RC4_CHUNK DES_PTR DES_RISC2 DES_UNROLL BF_PTR:${mips32_asm}:o32:dlfcn:irix-shared:::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 #### IRIX 6.x configs
 @@ -454,28 +455,28 @@ my %table=(
 "unixware-2.1","cc:-O -DFILIO_H::-Kthread::-lsocket -lnsl -lresolv -lx:${x86_gcc_des} ${x86_gcc_opts}:::",
 "unixware-7","cc:-O -DFILIO_H -Kalloca::-Kthread::-lsocket -lnsl:BN_LLONG MD2_CHAR RC4_INDEX ${x86_gcc_des}:${x86_elf_asm}:dlfcn:svr5-shared:-Kpic::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "unixware-7-gcc","gcc:-DL_ENDIAN -DFILIO_H -O3 -fomit-frame-pointer -march=pentium -Wall::-D_REENTRANT::-lsocket -lnsl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:gnu-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 # SCO 5 - Ben Laurie <ben@algroup.co.uk> says the -O breaks the SCO cc.
 "sco5-cc",  "cc:-belf::(unknown)::-lsocket -lnsl:${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:svr3-shared:-Kpic::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 "sco5-gcc",  "gcc:-O3 -fomit-frame-pointer::(unknown)::-lsocket -lnsl:BN_LLONG ${x86_gcc_des} ${x86_gcc_opts}:${x86_elf_asm}:dlfcn:svr3-shared:-fPIC::.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)",
 #### IBM's AIX.
 "aix3-cc",  "cc:-O -DB_ENDIAN -qmaxmem=16384::(unknown):AIX::BN_LLONG RC4_CHAR:::",
 "aix-gcc",  "gcc:-O -DB_ENDIAN::-pthread:AIX::BN_LLONG RC4_CHAR:${ppc32_asm}:aix32:dlfcn:aix-shared::-shared -Wl,-G:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)::-X32",
 "aix64-gcc","gcc:-maix64 -O -DB_ENDIAN::-pthread:AIX::SIXTY_FOUR_BIT_LONG RC4_CHAR:${ppc64_asm}:aix64:dlfcn:aix-shared::-maix64 -shared -Wl,-G:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)::-X64",
 # Below targets assume AIX 5. Idea is to effectively disregard $OBJECT_MODE
 # at build time. $OBJECT_MODE is respected at ./config stage!
-"aix-cc",   "cc:-q32 -O -DB_ENDIAN -qmaxmem=16384 -qro -qroconst::-qthreaded:AIX::BN_LLONG RC4_CHAR:${ppc32_asm}:aix32:dlfcn:aix-shared::-q32 -G:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)::-X 32",
+"aix-cc",   "cc:-q32 -O -DB_ENDIAN -qmaxmem=16384 -qro -qroconst::-qthreaded -D_THREAD_SAFE:AIX::BN_LLONG RC4_CHAR:${ppc32_asm}:aix32:dlfcn:aix-shared::-q32 -G:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)::-X 32",
-"aix64-cc", "cc:-q64 -O -DB_ENDIAN -qmaxmem=16384 -qro -qroconst::-qthreaded:AIX::SIXTY_FOUR_BIT_LONG RC4_CHAR:${ppc64_asm}:aix64:dlfcn:aix-shared::-q64 -G:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)::-X 64",
+"aix64-cc", "cc:-q64 -O -DB_ENDIAN -qmaxmem=16384 -qro -qroconst::-qthreaded -D_THREAD_SAFE:AIX::SIXTY_FOUR_BIT_LONG RC4_CHAR:${ppc64_asm}:aix64:dlfcn:aix-shared::-q64 -G:.so.\$(SHLIB_MAJOR).\$(SHLIB_MINOR)::-X 64",
+#
 # Cray T90 and similar (SDSC)
 # It's Big-endian, but the algorithms work properly when B_ENDIAN is NOT
 # defined.  The T90 ints and longs are 8 bytes long, and apparently the
 # B_ENDIAN code assumes 4 byte ints.  Fortunately, the non-B_ENDIAN and
 # non L_ENDIAN code aligns the bytes in each word correctly.
+#
 # The BIT_FIELD_LIMITS define is to avoid two fatal compiler errors:
 #'Taking the address of a bit field is not allowed. '
 #'An expression with bit field exists as the operand of "sizeof" '
 # (written by Wayne Schroeder <schroede@SDSC.EDU>)
+#

--- src/crypto/external/bsd/openssl/dist/apps/ca.c 2012/07/26 19:58:36	1.5
+++ src/crypto/external/bsd/openssl/dist/apps/ca.c 2013/02/05 21:31:24	1.6

	@@ -1398,26 +1398,27 @@ bad:		@@ -1398,26 +1398,27 @@ bad:
1398	{	1398	{
1399	BIO_printf(bio_err,"error while loading CRL number\n");	1399	BIO_printf(bio_err,"error while loading CRL number\n");
1400	goto err;	1400	goto err;
1401	}	1401	}
1402		1402
1403	if (!crldays && !crlhours && !crlsec)	1403	if (!crldays && !crlhours && !crlsec)
1404	{	1404	{
1405	if (!NCONF_get_number(conf,section,	1405	if (!NCONF_get_number(conf,section,
1406	ENV_DEFAULT_CRL_DAYS, &crldays))	1406	ENV_DEFAULT_CRL_DAYS, &crldays))
1407	crldays = 0;	1407	crldays = 0;
1408	if (!NCONF_get_number(conf,section,	1408	if (!NCONF_get_number(conf,section,
1409	ENV_DEFAULT_CRL_HOURS, &crlhours))	1409	ENV_DEFAULT_CRL_HOURS, &crlhours))
1410	crlhours = 0;	1410	crlhours = 0;
		1411	ERR_clear_error();
1411	}	1412	}
1412	if ((crldays == 0) && (crlhours == 0) && (crlsec == 0))	1413	if ((crldays == 0) && (crlhours == 0) && (crlsec == 0))
1413	{	1414	{
1414	BIO_printf(bio_err,"cannot lookup how long until the next CRL is issued\n");	1415	BIO_printf(bio_err,"cannot lookup how long until the next CRL is issued\n");
1415	goto err;	1416	goto err;
1416	}	1417	}
1417		1418
1418	if (verbose) BIO_printf(bio_err,"making CRL\n");	1419	if (verbose) BIO_printf(bio_err,"making CRL\n");
1419	if ((crl=X509_CRL_new()) == NULL) goto err;	1420	if ((crl=X509_CRL_new()) == NULL) goto err;
1420	if (!X509_CRL_set_issuer_name(crl, X509_get_subject_name(x509))) goto err;	1421	if (!X509_CRL_set_issuer_name(crl, X509_get_subject_name(x509))) goto err;
1421		1422
1422	tmptm = ASN1_TIME_new();	1423	tmptm = ASN1_TIME_new();
1423	if (!tmptm) goto err;	1424	if (!tmptm) goto err;

--- src/crypto/external/bsd/openssl/dist/apps/speed.c 2012/07/26 19:58:36	1.5
+++ src/crypto/external/bsd/openssl/dist/apps/speed.c 2013/02/05 21:31:24	1.6

 @@ -244,27 +244,27 @@ static int do_multi(int multi);
 #define RSA_NUM		4
 #define DSA_NUM		3
 #define EC_NUM       16
 #define MAX_ECDH_SIZE 256
 static const char *names[ALGOR_NUM]={
   "md2","mdc2","md4","md5","hmac(md5)","sha1","rmd160","rc4",
   "des cbc","des ede3","idea cbc","seed cbc",
   "rc2 cbc","rc5-32/12 cbc","blowfish cbc","cast cbc",
   "aes-128 cbc","aes-192 cbc","aes-256 cbc",
   "camellia-128 cbc","camellia-192 cbc","camellia-256 cbc",
   "evp","sha256","sha512","whirlpool",
-  "aes-128 ige","aes-192 ige","aes-256 ige","ghash"};
+  "aes-128 ige","aes-192 ige","aes-256 ige","ghash" };
 static double results[ALGOR_NUM][SIZE_NUM];
 static int lengths[SIZE_NUM]={16,64,256,1024,8*1024};
 #ifndef OPENSSL_NO_RSA
 static double rsa_results[RSA_NUM][2];
 #endif
 #ifndef OPENSSL_NO_DSA
 static double dsa_results[DSA_NUM][2];
 #endif
 #ifndef OPENSSL_NO_ECDSA
 static double ecdsa_results[EC_NUM][2];
 #endif
 #ifndef OPENSSL_NO_ECDH
 static double ecdh_results[EC_NUM][1];
 @@ -289,27 +289,27 @@ static SIGRETTYPE sig_done(int sig)
 	run=0;
 #ifdef LINT
 	sig=sig;
 #endif
+	}
 #endif
 #define START	0
 #define STOP	1
 #if defined(_WIN32)
 #if !defined(SIGALRM)
-#define SIGALRM
+# define SIGALRM
 #endif
 static unsigned int lapse,schlock;
 static void alarm_win32(unsigned int secs) { lapse = secs*1000; }
 #define alarm alarm_win32
 static DWORD WINAPI sleepy(VOID *arg)
+	{
 	schlock = 1;
 	Sleep(lapse);
 	run = 0;
 	return 0;
+	}

--- src/crypto/external/bsd/openssl/dist/apps/ocsp.c 2009/12/27 00:48:55	1.3
+++ src/crypto/external/bsd/openssl/dist/apps/ocsp.c 2013/02/05 21:31:24	1.4

 @@ -607,27 +607,27 @@ int MAIN(int argc, char **argv)
 		BIO_printf (bio_err, "-no_chain          don't chain verify response\n");
 		BIO_printf (bio_err, "-no_cert_checks    don't do additional checks on signing certificate\n");
 		BIO_printf (bio_err, "-port num		 port to run responder on\n");
 		BIO_printf (bio_err, "-index file	 certificate status index file\n");
 		BIO_printf (bio_err, "-CA file		 CA certificate\n");
 		BIO_printf (bio_err, "-rsigner file	 responder certificate to sign responses with\n");
 		BIO_printf (bio_err, "-rkey file	 responder key to sign responses with\n");
 		BIO_printf (bio_err, "-rother file	 other certificates to include in response\n");
 		BIO_printf (bio_err, "-resp_no_certs     don't include any certificates in response\n");
 		BIO_printf (bio_err, "-nmin n	 	 number of minutes before next update\n");
 		BIO_printf (bio_err, "-ndays n	 	 number of days before next update\n");
 		BIO_printf (bio_err, "-resp_key_id       identify reponse by signing certificate key ID\n");
 		BIO_printf (bio_err, "-nrequest n        number of requests to accept (default unlimited)\n");
-		BIO_printf (bio_err, "-<dgst alg>     use specified digest in the request");
+		BIO_printf (bio_err, "-<dgst alg>     use specified digest in the request\n");
 		goto end;
+		}
 	if(outfile) out = BIO_new_file(outfile, "w");
 	else out = BIO_new_fp(stdout, BIO_NOCLOSE);
 	if(!out)
+		{
 		BIO_printf(bio_err, "Error opening output file\n");
 		goto end;
+		}
 	if (!req && (add_nonce != 2)) add_nonce = 0;

--- src/crypto/external/bsd/openssl/dist/apps/s_client.c 2012/07/26 19:58:36	1.3
+++ src/crypto/external/bsd/openssl/dist/apps/s_client.c 2013/02/05 21:31:24	1.4

 @@ -347,27 +347,27 @@ static void sc_usage(void)
 	BIO_printf(bio_err,"                 only \"smtp\", \"pop3\", \"imap\", \"ftp\" and \"xmpp\"\n");
 	BIO_printf(bio_err,"                 are supported.\n");
 #ifndef OPENSSL_NO_ENGINE
 	BIO_printf(bio_err," -engine id    - Initialise and use the specified engine\n");
 #endif
 	BIO_printf(bio_err," -rand file%cfile%c...\n", LIST_SEPARATOR_CHAR, LIST_SEPARATOR_CHAR);
 	BIO_printf(bio_err," -sess_out arg - file to write SSL session to\n");
 	BIO_printf(bio_err," -sess_in arg  - file to read SSL session from\n");
 #ifndef OPENSSL_NO_TLSEXT
 	BIO_printf(bio_err," -servername host  - Set TLS extension servername in ClientHello\n");
 	BIO_printf(bio_err," -tlsextdebug      - hex dump of all TLS extensions received\n");
 	BIO_printf(bio_err," -status           - request certificate status from server\n");
 	BIO_printf(bio_err," -no_ticket        - disable use of RFC4507bis session tickets\n");
-# if !defined(OPENSSL_NO_NEXTPROTONEG)
+# ifndef OPENSSL_NO_NEXTPROTONEG
 	BIO_printf(bio_err," -nextprotoneg arg - enable NPN extension, considering named protocols supported (comma-separated list)\n");
 # endif
 #endif
 	BIO_printf(bio_err," -legacy_renegotiation - enable use of legacy renegotiation (dangerous)\n");
 	BIO_printf(bio_err," -use_srtp profiles - Offer SRTP key management with a colon-separated profile list\n");
  	BIO_printf(bio_err," -keymatexport label   - Export keying material using label\n");
  	BIO_printf(bio_err," -keymatexportlen len  - Export len bytes of keying material (default 20)\n");
+	}
 #ifndef OPENSSL_NO_TLSEXT
 /* This is a context that we pass to callbacks */
 typedef struct tlsextctx_st {
 @@ -526,27 +526,27 @@ static int next_proto_cb(SSL *s, unsigne
 		for (i = 0; i < inlen; )
+			{
 			if (i)
 				BIO_write(bio_c_out, ", ", 2);
 			BIO_write(bio_c_out, &in[i + 1], in[i]);
 			i += in[i] + 1;
+			}
 		BIO_write(bio_c_out, "\n", 1);
+		}
 	ctx->status = SSL_select_next_proto(out, outlen, in, inlen, ctx->data, ctx->len);
 	return SSL_TLSEXT_ERR_OK;
+	}
-# endif
+# endif  /* ndef OPENSSL_NO_NEXTPROTONEG */
 #endif
 enum
+{
 	PROTO_OFF	= 0,
 	PROTO_SMTP,
 	PROTO_POP3,
 	PROTO_IMAP,
 	PROTO_FTP,
 	PROTO_XMPP
 };
 int MAIN(int, char **);
 @@ -1893,33 +1893,39 @@ printf("read=%d pending=%d peek=%d\n",k,
 	ret=0;
 shut:
 	if (in_init)
 		print_stuff(bio_c_out,con,full_log);
 	SSL_shutdown(con);
 	SHUTDOWN(SSL_get_fd(con));
 end:
 	if (con != NULL)
+		{
 		if (prexit != 0)
 			print_stuff(bio_c_out,con,1);
 		SSL_free(con);
+		}
 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
 	if (next_proto.data)
 		OPENSSL_free(next_proto.data);
 #endif
 	if (ctx != NULL) SSL_CTX_free(ctx);
 	if (cert)
 		X509_free(cert);
 	if (key)
 		EVP_PKEY_free(key);
 	if (pass)
 		OPENSSL_free(pass);
 	if (vpm)
 		X509_VERIFY_PARAM_free(vpm);
 	if (cbuf != NULL) { OPENSSL_cleanse(cbuf,BUFSIZZ); OPENSSL_free(cbuf); }
 	if (sbuf != NULL) { OPENSSL_cleanse(sbuf,BUFSIZZ); OPENSSL_free(sbuf); }
 	if (mbuf != NULL) { OPENSSL_cleanse(mbuf,BUFSIZZ); OPENSSL_free(mbuf); }
 	if (bio_c_out != NULL)
+		{
 		BIO_free(bio_c_out);
 		bio_c_out=NULL;
+		}
 	apps_shutdown();
 	OPENSSL_EXIT(ret);
+	}

--- src/crypto/external/bsd/openssl/dist/apps/s_server.c 2012/07/26 19:58:36	1.3
+++ src/crypto/external/bsd/openssl/dist/apps/s_server.c 2013/02/05 21:31:24	1.4

 @@ -1196,33 +1196,33 @@ int MAIN(int argc, char *argv[])
+				{
 				if (isxdigit((unsigned char)psk_key[i]))
 					continue;
 				BIO_printf(bio_err,"Not a hex number '%s'\n",*argv);
 				goto bad;
+				}
+			}
 #endif
 #ifndef OPENSSL_NO_SRP
 		else if (strcmp(*argv, "-srpvfile") == 0)
+			{
 			if (--argc < 1) goto bad;
 			srp_verifier_file = *(++argv);
-			meth=TLSv1_server_method();
+			meth = TLSv1_server_method();
+			}
 		else if (strcmp(*argv, "-srpuserseed") == 0)
+			{
 			if (--argc < 1) goto bad;
 			srpuserseed = *(++argv);
-			meth=TLSv1_server_method();
+			meth = TLSv1_server_method();
+			}
 #endif
 		else if	(strcmp(*argv,"-www") == 0)
 			{ www=1; }
 		else if	(strcmp(*argv,"-WWW") == 0)
 			{ www=2; }
 		else if	(strcmp(*argv,"-HTTP") == 0)
 			{ www=3; }
 		else if	(strcmp(*argv,"-no_ssl2") == 0)
 			{ off|=SSL_OP_NO_SSLv2; }
 		else if	(strcmp(*argv,"-no_ssl3") == 0)
 			{ off|=SSL_OP_NO_SSLv3; }
 		else if	(strcmp(*argv,"-no_tls1") == 0)
 @@ -1421,45 +1421,44 @@ bad:
 				ERR_print_errors(bio_err);
 				goto end;
+				}
 			s_cert2 = load_cert(bio_err,s_cert_file2,s_cert_format,
 				NULL, e, "second server certificate file");
 			if (!s_cert2)
+				{
 				ERR_print_errors(bio_err);
 				goto end;
+				}
+			}
 # ifndef OPENSSL_NO_NEXTPROTONEG
 		if (next_proto_neg_in)
 			unsigned short len;
 			next_proto.data = next_protos_parse(&len,
 				next_proto_neg_in);
 			if (next_proto.data == NULL)
 				goto end;
 			next_proto.len = len;
 		else
 			next_proto.data = NULL;
 # endif
 #endif
+		}
 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
 	if (next_proto_neg_in)
+		{
 		unsigned short len;
 		next_proto.data = next_protos_parse(&len, next_proto_neg_in);
 		if (next_proto.data == NULL)
 			goto end;
 		next_proto.len = len;
+		}
 	else
+		{
 		next_proto.data = NULL;
+		}
 #endif
 	if (s_dcert_file)
+		{
 		if (s_dkey_file == NULL)
 			s_dkey_file = s_dcert_file;
 		s_dkey = load_key(bio_err, s_dkey_file, s_dkey_format,
 , dpass, e,
 			       "second certificate private key file");
 		if (!s_dkey)
+			{
 			ERR_print_errors(bio_err);
 @@ -1720,35 +1719,35 @@ bad:
+				}
+			}
 		(void)BIO_flush(bio_s_out);
 		SSL_CTX_set_tmp_ecdh(ctx,ecdh);
 #ifndef OPENSSL_NO_TLSEXT
 		if (ctx2)
 			SSL_CTX_set_tmp_ecdh(ctx2,ecdh);
 #endif
 		EC_KEY_free(ecdh);
+		}
 #endif
-	if (!set_cert_key_stuff(ctx,s_cert,s_key))
+	if (!set_cert_key_stuff(ctx, s_cert, s_key))
 		goto end;
 #ifndef OPENSSL_NO_TLSEXT
 	if (ctx2 && !set_cert_key_stuff(ctx2,s_cert2,s_key2))
 		goto end;
 #endif
 	if (s_dcert != NULL)
+		{
-		if (!set_cert_key_stuff(ctx,s_dcert,s_dkey))
+		if (!set_cert_key_stuff(ctx, s_dcert, s_dkey))
 			goto end;
+		}
 #ifndef OPENSSL_NO_RSA
 #if 1
 	if (!no_tmp_rsa)
+		{
 		SSL_CTX_set_tmp_rsa_callback(ctx,tmp_rsa_cb);
 #ifndef OPENSSL_NO_TLSEXT
 		if (ctx2)
 			SSL_CTX_set_tmp_rsa_callback(ctx2,tmp_rsa_cb);
 #endif
+		}
 @@ -1883,27 +1882,35 @@ end:
 	if (ctx != NULL) SSL_CTX_free(ctx);
 	if (s_cert)
 		X509_free(s_cert);
 	if (s_dcert)
 		X509_free(s_dcert);
 	if (s_key)
 		EVP_PKEY_free(s_key);
 	if (s_dkey)
 		EVP_PKEY_free(s_dkey);
 	if (pass)
 		OPENSSL_free(pass);
 	if (dpass)
 		OPENSSL_free(dpass);
 	if (vpm)
 		X509_VERIFY_PARAM_free(vpm);
 #ifndef OPENSSL_NO_TLSEXT
 	if (tlscstatp.host)
 		OPENSSL_free(tlscstatp.host);
 	if (tlscstatp.port)
 		OPENSSL_free(tlscstatp.port);
 	if (tlscstatp.path)
 		OPENSSL_free(tlscstatp.path);
 	if (ctx2 != NULL) SSL_CTX_free(ctx2);
 	if (s_cert2)
 		X509_free(s_cert2);
 	if (s_key2)
 		EVP_PKEY_free(s_key2);
 #endif
 	if (bio_s_out != NULL)
+		{
         BIO_free(bio_s_out);
 		bio_s_out=NULL;
+		}
 	apps_shutdown();
 	OPENSSL_EXIT(ret);
 @@ -2429,26 +2436,27 @@ static int init_ssl_connection(SSL *con)
 		BIO_printf(bio_s_out,"Client certificate\n");
 		PEM_write_bio_X509(bio_s_out,peer);
 		X509_NAME_oneline(X509_get_subject_name(peer),buf,sizeof buf);
 		BIO_printf(bio_s_out,"subject=%s\n",buf);
 		X509_NAME_oneline(X509_get_issuer_name(peer),buf,sizeof buf);
 		BIO_printf(bio_s_out,"issuer=%s\n",buf);
 		X509_free(peer);
+		}
 	if (SSL_get_shared_ciphers(con,buf,sizeof buf) != NULL)
 		BIO_printf(bio_s_out,"Shared ciphers:%s\n",buf);
 	str=SSL_CIPHER_get_name(SSL_get_current_cipher(con));
 	BIO_printf(bio_s_out,"CIPHER is %s\n",(str != NULL)?str:"(NONE)");
 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
 	SSL_get0_next_proto_negotiated(con, &next_proto_neg, &next_proto_neg_len);
 	if (next_proto_neg)
+		{
 		BIO_printf(bio_s_out,"NEXTPROTO is ");
 		BIO_write(bio_s_out, next_proto_neg, next_proto_neg_len);
 		BIO_printf(bio_s_out, "\n");
+		}
 #endif
+	{
 	SRTP_PROTECTION_PROFILE *srtp_profile
 	  = SSL_get_selected_srtp_profile(con);
 @@ -2697,26 +2705,31 @@ static int www_body(char *hostname, int
 			BIO_puts(io,"HTTP/1.0 200 ok\r\nContent-type: text/html\r\n\r\n");
 			BIO_puts(io,"<HTML><BODY BGCOLOR=\"#ffffff\">\n");
 			BIO_puts(io,"<pre>\n");
 /*			BIO_puts(io,SSLeay_version(SSLEAY_VERSION));*/
 			BIO_puts(io,"\n");
 			for (i=0; i<local_argc; i++)
+				{
 				BIO_puts(io,local_argv[i]);
 				BIO_write(io," ",1);
+				}
 			BIO_puts(io,"\n");
 			BIO_printf(io,
 				"Secure Renegotiation IS%s supported\n",
 		      		SSL_get_secure_renegotiation_support(con) ?
 							"" : " NOT");
 			/* The following is evil and should not really
 			 * be done */
 			BIO_printf(io,"Ciphers supported in s_server binary\n");
 			sk=SSL_get_ciphers(con);
 			j=sk_SSL_CIPHER_num(sk);
 			for (i=0; i<j; i++)
+				{
 				c=sk_SSL_CIPHER_value(sk,i);
 				BIO_printf(io,"%-11s:%-25s",
 					SSL_CIPHER_get_version(c),
 					SSL_CIPHER_get_name(c));
 				if ((((i+1)%2) == 0) && (i+1 != j))
 					BIO_puts(io,"\n");

--- src/crypto/external/bsd/openssl/dist/crypto/cryptlib.c 2012/07/27 18:10:40	1.2
+++ src/crypto/external/bsd/openssl/dist/crypto/cryptlib.c 2013/02/05 21:31:24	1.3

 @@ -494,27 +494,27 @@ void CRYPTO_THREADID_current(CRYPTO_THRE
 		CRYPTO_THREADID_set_numeric(id, id_callback());
 		return;
+		}
 #endif
 	/* Else pick a backup */
 #ifdef OPENSSL_SYS_WIN16
 	CRYPTO_THREADID_set_numeric(id, (unsigned long)GetCurrentTask());
 #elif defined(OPENSSL_SYS_WIN32)
 	CRYPTO_THREADID_set_numeric(id, (unsigned long)GetCurrentThreadId());
 #elif defined(OPENSSL_SYS_BEOS)
 	CRYPTO_THREADID_set_numeric(id, (unsigned long)find_thread(NULL));
 #else
 	/* For everything else, default to using the address of 'errno' */
-	CRYPTO_THREADID_set_pointer(id, &errno);
+	CRYPTO_THREADID_set_pointer(id, (void*)&errno);
 #endif
+	}
 int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, const CRYPTO_THREADID *b)
+	{
 	return memcmp(a, b, sizeof(*a));
+	}
 void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, const CRYPTO_THREADID *src)
+	{
 	memcpy(dest, src, sizeof(*src));
+	}
 @@ -694,26 +694,27 @@ void OPENSSL_cpuid_setup(void)
     trigger=1;
     if ((env=getenv("OPENSSL_ia32cap"))) {
 	int off = (env[0]=='~')?1:0;
 #if defined(_WIN32)
 	if (!sscanf(env+off,"%I64i",&vec)) vec = strtoul(env+off,NULL,0);
 #else
 	if (!sscanf(env+off,"%lli",(long long *)&vec)) vec = strtoul(env+off,NULL,0);
 #endif
 	if (off) vec = OPENSSL_ia32_cpuid()&~vec;
+    }
     else
 	vec = OPENSSL_ia32_cpuid();
     /*
      * |(1<<10) sets a reserved bit to signal that variable
      * was initialized already... This is to avoid interference
      * with cpuid snippets in ELF .init segment.
      */
     OPENSSL_ia32cap_P[0] = (unsigned int)vec|(1<<10);
     OPENSSL_ia32cap_P[1] = (unsigned int)(vec>>32);
+}
 #endif
 #else
 unsigned long *OPENSSL_ia32cap_loc(void) { return NULL; }
 #endif
 @@ -914,13 +915,26 @@ void OpenSSLDie(const char *file,int lin
 	OPENSSL_showfatal(
 		"%s(%d): OpenSSL internal error, assertion failed: %s\n",
 		file,line,assertion);
 #if !defined(_WIN32) || defined(__CYGWIN__)
 	abort();
 #else
 	/* Win32 abort() customarily shows a dialog, but we just did that... */
 	raise(SIGABRT);
 	_exit(3);
 #endif
+	}
 void *OPENSSL_stderr(void)	{ return stderr; }
 int CRYPTO_memcmp(const void *in_a, const void *in_b, size_t len)
+	{
 	size_t i;
 	const unsigned char *a = in_a;
 	const unsigned char *b = in_b;
 	unsigned char x = 0;
 	for (i = 0; i < len; i++)
 		x |= a[i] ^ b[i];
 	return x;
+	}

--- src/crypto/external/bsd/openssl/dist/crypto/Attic/cryptlib.h 2012/07/26 20:21:20	1.2
+++ src/crypto/external/bsd/openssl/dist/crypto/Attic/cryptlib.h 2013/02/05 21:31:24	1.3

 @@ -90,22 +90,22 @@ extern "C" {
 #define X509_CERT_FILE		"SSLCERTS:cert.pem"
 #define X509_PRIVATE_DIR        "SSLPRIVATE:"
 #endif
 #define X509_CERT_DIR_EVP        "SSL_CERT_DIR"
 #define X509_CERT_FILE_EVP       "SSL_CERT_FILE"
 /* size of string representations */
 #define DECIMAL_SIZE(type)	((sizeof(type)*8+2)/3+1)
 #define HEX_SIZE(type)		(sizeof(type)*2)
 void OPENSSL_cpuid_setup(void);
 extern unsigned int OPENSSL_ia32cap_P[2];
-void OPENSSL_showfatal(const char *,...);
+void OPENSSL_showfatal(const char *, ...);
 void *OPENSSL_stderr(void);
 extern int OPENSSL_NONPIC_relocated;
 #ifdef  __cplusplus
+}
 #endif
 #endif

--- src/crypto/external/bsd/openssl/dist/crypto/ppccap.c 2012/07/27 23:01:23	1.2
+++ src/crypto/external/bsd/openssl/dist/crypto/ppccap.c 2013/02/05 21:31:24	1.3

 @@ -1,18 +1,19 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <setjmp.h>
 #include <signal.h>
 #include <unistd.h>
 #include <crypto.h>
 #include <openssl/bn.h>
 #define PPC_FPU64	(1<<0)
 #define PPC_ALTIVEC	(1<<1)
 static int OPENSSL_ppccap_P = 0;
 static sigset_t all_masked;
 #ifdef OPENSSL_BN_ASM_MONT
 int bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp, const BN_ULONG *np, const BN_ULONG *n0, int num)
+	{
 @@ -43,26 +44,27 @@ int bn_mul_mont(BN_ULONG *rp, const BN_U
 	else if ((OPENSSL_ppccap_P&PPC_FPU64))
 		/* this is a "must" on POWER6, but run-time detection
 		 * is not implemented yet... */
 		return bn_mul_mont_fpu64(rp,ap,bp,np,n0,num);
 	return bn_mul_mont_int(rp,ap,bp,np,n0,num);
+	}
 #endif
 static sigjmp_buf ill_jmp;
 static void ill_handler (int sig) { siglongjmp(ill_jmp,sig); }
 void OPENSSL_ppc64_probe(void);
 void OPENSSL_altivec_probe(void);
 void OPENSSL_cpuid_setup(void)
+	{
 	char *e;
 	struct sigaction	ill_oact,ill_act;
 	sigset_t		oset;
 	static int trigger=0;
 	if (trigger) return;
 	trigger=1;
 	sigfillset(&all_masked);
 	sigdelset(&all_masked,SIGILL);
 @@ -72,26 +74,35 @@ void OPENSSL_cpuid_setup(void)
 #endif
 	sigdelset(&all_masked,SIGFPE);
 	sigdelset(&all_masked,SIGBUS);
 	sigdelset(&all_masked,SIGSEGV);
 	if ((e=getenv("OPENSSL_ppccap")) != NULL)
+		{
 		OPENSSL_ppccap_P=strtoul(e,NULL,0);
 		return;
+		}
 	OPENSSL_ppccap_P = 0;
 #if defined(_AIX)
 	if (sizeof(size_t)==4
 # if defined(_SC_AIX_KERNEL_BITMODE)
 	    && sysconf(_SC_AIX_KERNEL_BITMODE)!=64
 # endif
+	   )
 		return;
 #endif
 	memset(&ill_act,0,sizeof(ill_act));
 	ill_act.sa_handler = ill_handler;
 	ill_act.sa_mask    = all_masked;
 	sigprocmask(SIG_SETMASK,&ill_act.sa_mask,&oset);
 	sigaction(SIGILL,&ill_act,&ill_oact);
 	if (sizeof(size_t)==4)
+		{
 		if (sigsetjmp(ill_jmp,1) == 0)
+			{
 			OPENSSL_ppc64_probe();
 			OPENSSL_ppccap_P |= PPC_FPU64;

--- src/crypto/external/bsd/openssl/dist/crypto/Attic/crypto.h 2011/06/05 23:09:44	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/Attic/crypto.h 2013/02/05 21:31:24	1.4

 @@ -478,30 +478,30 @@ void CRYPTO_get_mem_functions(void *(**m
 void CRYPTO_get_locked_mem_functions(void *(**m)(size_t), void (**f)(void *));
 void CRYPTO_get_mem_ex_functions(void *(**m)(size_t,const char *,int),
                                  void *(**r)(void *, size_t,const char *,int),
                                  void (**f)(void *));
 void CRYPTO_get_locked_mem_ex_functions(void *(**m)(size_t,const char *,int),
                                         void (**f)(void *));
 void CRYPTO_get_mem_debug_functions(void (**m)(void *,int,const char *,int,int),
 				    void (**r)(void *,void *,int,const char *,int,int),
 				    void (**f)(void *,int),
 				    void (**so)(long),
 				    long (**go)(void));
 void *CRYPTO_malloc_locked(int num, const char *file, int line);
-void CRYPTO_free_locked(void *);
+void CRYPTO_free_locked(void *ptr);
 void *CRYPTO_malloc(int num, const char *file, int line);
 char *CRYPTO_strdup(const char *str, const char *file, int line);
-void CRYPTO_free(void *);
+void CRYPTO_free(void *ptr);
 void *CRYPTO_realloc(void *addr,int num, const char *file, int line);
 void *CRYPTO_realloc_clean(void *addr,int old_num,int num,const char *file,
 			   int line);
 void *CRYPTO_remalloc(void *addr,int num, const char *file, int line);
 void OPENSSL_cleanse(void *ptr, size_t len);
 void CRYPTO_set_mem_debug_options(long bits);
 long CRYPTO_get_mem_debug_options(void);
 #define CRYPTO_push_info(info) \
         CRYPTO_push_info_(info, __FILE__, __LINE__);
 int CRYPTO_push_info_(const char *info, const char *file, int line);
 @@ -564,26 +564,33 @@ void OPENSSL_init(void);
 	} \
 	int private_##alg##_Init(cx##_CTX *c)
 #define fips_cipher_abort(alg) \
 	if (FIPS_mode()) OpenSSLDie(__FILE__, __LINE__, \
 		"Low level API call to cipher " #alg " forbidden in FIPS mode!")
 #else
 #define fips_md_init_ctx(alg, cx) \
 	int alg##_Init(cx##_CTX *c)
 #define fips_cipher_abort(alg) while(0)
 #endif
 /* CRYPTO_memcmp returns zero iff the |len| bytes at |a| and |b| are equal. It
  * takes an amount of time dependent on |len|, but independent of the contents
  * of |a| and |b|. Unlike memcmp, it cannot be used to put elements into a
  * defined order as the return value when a != b is undefined, other than to be
  * non-zero. */
 int CRYPTO_memcmp(const void *a, const void *b, size_t len);
 /* BEGIN ERROR CODES */
 /* The following lines are auto generated by the script mkerr.pl. Any changes
  * made after this point may be overwritten when the script is next run.
  */
 void ERR_load_CRYPTO_strings(void);
 /* Error codes for the CRYPTO functions. */
 /* Function codes. */
 #define CRYPTO_F_CRYPTO_GET_EX_NEW_INDEX		 100
 #define CRYPTO_F_CRYPTO_GET_NEW_DYNLOCKID		 103
 #define CRYPTO_F_CRYPTO_GET_NEW_LOCKID			 101
 #define CRYPTO_F_CRYPTO_SET_EX_DATA			 102

--- src/crypto/external/bsd/openssl/dist/crypto/mem.c 2012/07/26 19:58:37	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/mem.c 2013/02/05 21:31:24	1.4

 @@ -111,30 +111,30 @@ static void (*free_debug_func)(void *,in
 static void (*set_debug_options_func)(long) = CRYPTO_dbg_set_options;
 static long (*get_debug_options_func)(void) = CRYPTO_dbg_get_options;
 #else
 /* applications can use CRYPTO_malloc_debug_init() to select above case
  * at run-time */
 static void (*malloc_debug_func)(void *,int,const char *,int,int) = NULL;
 static void (*realloc_debug_func)(void *,void *,int,const char *,int,int)
 	= NULL;
 static void (*free_debug_func)(void *,int) = NULL;
 static void (*set_debug_options_func)(long) = NULL;
 static long (*get_debug_options_func)(void) = NULL;
 #endif
 int CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t),
 	void (*f)(void *))
+	{
 	/* Dummy call just to ensure OPENSSL_init() gets linked in */
 	OPENSSL_init();
 	if (!allow_customize)
 		return 0;
 	if ((m == 0) || (r == 0) || (f == 0))
 		return 0;
 	malloc_func=m; malloc_ex_func=default_malloc_ex;
 	realloc_func=r; realloc_ex_func=default_realloc_ex;
 	free_func=f;
 	malloc_locked_func=m; malloc_locked_ex_func=default_malloc_locked_ex;
 	free_locked_func=f;
 	return 1;
+	}

--- src/crypto/external/bsd/openssl/dist/crypto/Attic/opensslv.h 2012/07/26 19:58:37	1.4
+++ src/crypto/external/bsd/openssl/dist/crypto/Attic/opensslv.h 2013/02/05 21:31:24	1.5

 @@ -15,31 +15,31 @@
  * 0.9.4 	  0x0090400f
  * 1.2.3z	  0x102031af
+ *
  * For continuity reasons (because 0.9.5 is already out, and is coded
  * 0x00905100), between 0.9.5 and 0.9.6 the coding of the patch level
  * part is slightly different, by setting the highest bit.  This means
  * that 0.9.5a looks like this: 0x0090581f.  At 0.9.6, we can start
  * with 0x0090600S...
+ *
  * (Prior to 0.9.3-dev a different scheme was used: 0.9.2b is 0x0922.)
  * (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for
  *  major minor fix final patch/beta)
  */
-#define OPENSSL_VERSION_NUMBER	0x1000103fL
+#define OPENSSL_VERSION_NUMBER	0x1000104fL
 #ifdef OPENSSL_FIPS
-#define OPENSSL_VERSION_TEXT	"OpenSSL 1.0.1c-fips 10 May 2012"
+#define OPENSSL_VERSION_TEXT	"OpenSSL 1.0.1d-fips 5 Feb 2013"
 #else
-#define OPENSSL_VERSION_TEXT	"OpenSSL 1.0.1c 10 May 2012"
+#define OPENSSL_VERSION_TEXT	"OpenSSL 1.0.1d 5 Feb 2013"
 #endif
 #define OPENSSL_VERSION_PTEXT	" part of " OPENSSL_VERSION_TEXT
 /* The macros below are to be used for shared library (.so, .dll, ...)
  * versioning.  That kind of versioning works a bit differently between
  * operating systems.  The most usual scheme is to set a major and a minor
  * number, and have the runtime loader check that the major number is equal
  * to what it was at application link time, while the minor number has to
  * be greater or equal to what it was at application link time.  With this
  * scheme, the version number is usually part of the file name, like this:
+ *
  *	libcrypto.so.0.9

--- src/crypto/external/bsd/openssl/dist/crypto/ec/Attic/ectest.c 2012/07/26 19:58:38	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/ec/Attic/ectest.c 2013/02/05 21:31:25	1.4

 @@ -226,27 +226,27 @@ static void group_order_tests(EC_GROUP *
 	if (!BN_mul(n2, n1, n2, ctx)) ABORT;
 	if(!EC_POINT_mul(group, Q, NULL, P, n2, ctx)) ABORT;
 	if (0 != EC_POINT_cmp(group, Q, P, ctx)) ABORT;
 	fprintf(stdout, "ok\n");
 	EC_POINT_free(P);
 	EC_POINT_free(Q);
 	BN_free(n1);
 	BN_free(n2);
 	BN_free(order);
 	BN_CTX_free(ctx);
+	}
 static void prime_field_tests(void)
+	{
 	BN_CTX *ctx = NULL;
 	BIGNUM *p, *a, *b;
 	EC_GROUP *group;
 	EC_GROUP *P_160 = NULL, *P_192 = NULL, *P_224 = NULL, *P_256 = NULL, *P_384 = NULL, *P_521 = NULL;
 	EC_POINT *P, *Q, *R;
 	BIGNUM *x, *y, *z;
 	unsigned char buf[100];
 	size_t i, len;
 	int k;
 #if 1 /* optional */
 	ctx = BN_CTX_new();
 	if (!ctx) ABORT;

--- src/crypto/external/bsd/openssl/dist/crypto/evp/Attic/m_sha1.c 2011/06/05 23:09:46	1.4
+++ src/crypto/external/bsd/openssl/dist/crypto/evp/Attic/m_sha1.c 2013/02/05 21:31:25	1.5

 @@ -55,27 +55,27 @@
  * copied and put under another distribution licence
  * [including the GNU Public Licence.]
  */
 #include <stdio.h>
 #include "cryptlib.h"
 #ifndef OPENSSL_FIPS
 #ifndef OPENSSL_NO_SHA
 #include <openssl/evp.h>
 #include <openssl/objects.h>
-#include <openssl/x509.h>
+#include <openssl/sha.h>
 #ifndef OPENSSL_NO_RSA
 #include <openssl/rsa.h>
 #endif
 static int init(EVP_MD_CTX *ctx)
 	{ return SHA1_Init(ctx->md_data); }
 static int update(EVP_MD_CTX *ctx,const void *data,size_t count)
 	{ return SHA1_Update(ctx->md_data,data,count); }
 static int final(EVP_MD_CTX *ctx,unsigned char *md)
 	{ return SHA1_Final(md,ctx->md_data); }

--- src/crypto/external/bsd/openssl/dist/crypto/md4/md4_dgst.c 2011/06/05 23:09:47	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/md4/md4_dgst.c 2013/02/05 21:31:25	1.4

 @@ -96,42 +96,43 @@ void md4_block_data_order (MD4_CTX *c, c
 # define X(i)	XX##i
 #else
 	MD4_LONG XX[MD4_LBLOCK];
 # define X(i)	XX[i]
 #endif
 	A=c->A;
 	B=c->B;
 	C=c->C;
 	D=c->D;
 	for (;num--;)
+		{
-	HOST_c2l(data,l); X( 0)=l;		HOST_c2l(data,l); X( 1)=l;
+	(void)HOST_c2l(data,l); X( 0)=l;
 	(void)HOST_c2l(data,l); X( 1)=l;
 	/* Round 0 */
-	R0(A,B,C,D,X( 0), 3,0);	HOST_c2l(data,l); X( 2)=l;
+	R0(A,B,C,D,X( 0), 3,0);	(void)HOST_c2l(data,l); X( 2)=l;
-	R0(D,A,B,C,X( 1), 7,0);	HOST_c2l(data,l); X( 3)=l;
+	R0(D,A,B,C,X( 1), 7,0);	(void)HOST_c2l(data,l); X( 3)=l;
-	R0(C,D,A,B,X( 2),11,0);	HOST_c2l(data,l); X( 4)=l;
+	R0(C,D,A,B,X( 2),11,0);	(void)HOST_c2l(data,l); X( 4)=l;
-	R0(B,C,D,A,X( 3),19,0);	HOST_c2l(data,l); X( 5)=l;
+	R0(B,C,D,A,X( 3),19,0);	(void)HOST_c2l(data,l); X( 5)=l;
-	R0(A,B,C,D,X( 4), 3,0);	HOST_c2l(data,l); X( 6)=l;
+	R0(A,B,C,D,X( 4), 3,0);	(void)HOST_c2l(data,l); X( 6)=l;
-	R0(D,A,B,C,X( 5), 7,0);	HOST_c2l(data,l); X( 7)=l;
+	R0(D,A,B,C,X( 5), 7,0);	(void)HOST_c2l(data,l); X( 7)=l;
-	R0(C,D,A,B,X( 6),11,0);	HOST_c2l(data,l); X( 8)=l;
+	R0(C,D,A,B,X( 6),11,0);	(void)HOST_c2l(data,l); X( 8)=l;
-	R0(B,C,D,A,X( 7),19,0);	HOST_c2l(data,l); X( 9)=l;
+	R0(B,C,D,A,X( 7),19,0);	(void)HOST_c2l(data,l); X( 9)=l;
-	R0(A,B,C,D,X( 8), 3,0);	HOST_c2l(data,l); X(10)=l;
+	R0(A,B,C,D,X( 8), 3,0);	(void)HOST_c2l(data,l); X(10)=l;
-	R0(D,A,B,C,X( 9), 7,0);	HOST_c2l(data,l); X(11)=l;
+	R0(D,A,B,C,X( 9), 7,0);	(void)HOST_c2l(data,l); X(11)=l;
-	R0(C,D,A,B,X(10),11,0);	HOST_c2l(data,l); X(12)=l;
+	R0(C,D,A,B,X(10),11,0);	(void)HOST_c2l(data,l); X(12)=l;
-	R0(B,C,D,A,X(11),19,0);	HOST_c2l(data,l); X(13)=l;
+	R0(B,C,D,A,X(11),19,0);	(void)HOST_c2l(data,l); X(13)=l;
-	R0(A,B,C,D,X(12), 3,0);	HOST_c2l(data,l); X(14)=l;
+	R0(A,B,C,D,X(12), 3,0);	(void)HOST_c2l(data,l); X(14)=l;
-	R0(D,A,B,C,X(13), 7,0);	HOST_c2l(data,l); X(15)=l;
+	R0(D,A,B,C,X(13), 7,0);	(void)HOST_c2l(data,l); X(15)=l;
 	R0(C,D,A,B,X(14),11,0);
 	R0(B,C,D,A,X(15),19,0);
 	/* Round 1 */
 	R1(A,B,C,D,X( 0), 3,0x5A827999L);
 	R1(D,A,B,C,X( 4), 5,0x5A827999L);
 	R1(C,D,A,B,X( 8), 9,0x5A827999L);
 	R1(B,C,D,A,X(12),13,0x5A827999L);
 	R1(A,B,C,D,X( 1), 3,0x5A827999L);
 	R1(D,A,B,C,X( 5), 5,0x5A827999L);
 	R1(C,D,A,B,X( 9), 9,0x5A827999L);
 	R1(B,C,D,A,X(13),13,0x5A827999L);
 	R1(A,B,C,D,X( 2), 3,0x5A827999L);
 	R1(D,A,B,C,X( 6), 5,0x5A827999L);

--- src/crypto/external/bsd/openssl/dist/crypto/md5/Attic/md5_locl.h 2009/07/19 23:30:40	1.2
+++ src/crypto/external/bsd/openssl/dist/crypto/md5/Attic/md5_locl.h 2013/02/05 21:31:25	1.3

 @@ -75,30 +75,30 @@
 void md5_block_data_order (MD5_CTX *c, const void *p,size_t num);
 #define DATA_ORDER_IS_LITTLE_ENDIAN
 #define HASH_LONG		MD5_LONG
 #define HASH_CTX		MD5_CTX
 #define HASH_CBLOCK		MD5_CBLOCK
 #define HASH_UPDATE		MD5_Update
 #define HASH_TRANSFORM		MD5_Transform
 #define HASH_FINAL		MD5_Final
 #define	HASH_MAKE_STRING(c,s)	do {	\
 	unsigned long ll;		\
-	ll=(c)->A; HOST_l2c(ll,(s));	\
+	ll=(c)->A; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->B; HOST_l2c(ll,(s));	\
+	ll=(c)->B; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->C; HOST_l2c(ll,(s));	\
+	ll=(c)->C; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->D; HOST_l2c(ll,(s));	\
+	ll=(c)->D; (void)HOST_l2c(ll,(s));	\
 	} while (0)
 #define	HASH_BLOCK_DATA_ORDER	md5_block_data_order
 #include "md32_common.h"
 /*
 #define	F(x,y,z)	(((x) & (y))  |  ((~(x)) & (z)))
 #define	G(x,y,z)	(((x) & (z))  |  ((y) & (~(z))))
 */
 /* As pointed out by Wei Dai <weidai@eskimo.com>, the above can be
  * simplified to the code below.  Wei attributes these optimizations
  * to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.

--- src/crypto/external/bsd/openssl/dist/crypto/objects/o_names.c 2009/07/19 23:30:40	1.2
+++ src/crypto/external/bsd/openssl/dist/crypto/objects/o_names.c 2013/02/05 21:31:25	1.3

	@@ -63,27 +63,27 @@ int OBJ_NAME_new_index(unsigned long (*h		@@ -63,27 +63,27 @@ int OBJ_NAME_new_index(unsigned long (*h
63	int (cmp_func)(const char , const char *),	63	int (cmp_func)(const char , const char *),
64	void (free_func)(const char , int, const char *))	64	void (free_func)(const char , int, const char *))
65	{	65	{
66	int ret;	66	int ret;
67	int i;	67	int i;
68	NAME_FUNCS *name_funcs;	68	NAME_FUNCS *name_funcs;
69		69
70	if (name_funcs_stack == NULL)	70	if (name_funcs_stack == NULL)
71	{	71	{
72	MemCheck_off();	72	MemCheck_off();
73	name_funcs_stack=sk_NAME_FUNCS_new_null();	73	name_funcs_stack=sk_NAME_FUNCS_new_null();
74	MemCheck_on();	74	MemCheck_on();
75	}	75	}
76	if ((name_funcs_stack == NULL))	76	if (name_funcs_stack == NULL)
77	{	77	{
78	/* ERROR */	78	/* ERROR */
79	return(0);	79	return(0);
80	}	80	}
81	ret=names_type_num;	81	ret=names_type_num;
82	names_type_num++;	82	names_type_num++;
83	for (i=sk_NAME_FUNCS_num(name_funcs_stack); i<names_type_num; i++)	83	for (i=sk_NAME_FUNCS_num(name_funcs_stack); i<names_type_num; i++)
84	{	84	{
85	MemCheck_off();	85	MemCheck_off();
86	name_funcs = OPENSSL_malloc(sizeof(NAME_FUNCS));	86	name_funcs = OPENSSL_malloc(sizeof(NAME_FUNCS));
87	MemCheck_on();	87	MemCheck_on();
88	if (!name_funcs)	88	if (!name_funcs)
89	{	89	{

--- src/crypto/external/bsd/openssl/dist/crypto/rand/Attic/md_rand.c 2012/03/07 10:17:47	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/rand/Attic/md_rand.c 2013/02/05 21:31:25	1.4

 @@ -113,30 +113,30 @@
 #ifdef MD_RAND_DEBUG
 # ifndef NDEBUG
 #   define NDEBUG
 # endif
 #endif
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include "e_os.h"
 #include <openssl/crypto.h>
 #include <openssl/rand.h>
 #include "rand_lcl.h"
 #include <openssl/crypto.h>
 #include <openssl/err.h>
 #ifdef BN_DEBUG
 # define PREDICT
 #endif
 /* #define PREDICT	1 */
 #define STATE_SIZE	1023
 static int state_num=0,state_index=0;
 static unsigned char state[STATE_SIZE+MD_DIGEST_LENGTH];
 static unsigned char md[MD_DIGEST_LENGTH];
 static long md_count[2]={0,0};

--- src/crypto/external/bsd/openssl/dist/crypto/rand/randfile.c 2012/07/26 19:58:38	1.4
+++ src/crypto/external/bsd/openssl/dist/crypto/rand/randfile.c 2013/02/05 21:31:25	1.5

 @@ -47,27 +47,29 @@
  * 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.]
  */
 /* We need to define this to get macros like S_IFBLK and S_IFCHR */
 #if !defined(OPENSSL_SYS_VXWORKS)
 #define _XOPEN_SOURCE 500
 #endif
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "e_os.h"
 #include <openssl/crypto.h>
 #include <openssl/rand.h>
 #include <openssl/buffer.h>
 #ifdef OPENSSL_SYS_VMS
 #include <unixio.h>

--- src/crypto/external/bsd/openssl/dist/crypto/ripemd/rmd_dgst.c 2011/06/05 23:09:47	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/ripemd/rmd_dgst.c 2013/02/05 21:31:25	1.4

 @@ -95,41 +95,41 @@ void ripemd160_block_data_order (RIPEMD1
 	MD32_REG_T	XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
 			XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
 # define X(i)	XX##i
 #else
 	RIPEMD160_LONG	XX[16];
 # define X(i)	XX[i]
 #endif
 	for (;num--;)
+		{
 	A=ctx->A; B=ctx->B; C=ctx->C; D=ctx->D; E=ctx->E;
-	HOST_c2l(data,l); X( 0)=l;	HOST_c2l(data,l); X( 1)=l;
+	(void)HOST_c2l(data,l); X( 0)=l;(void)HOST_c2l(data,l); X( 1)=l;
-	RIP1(A,B,C,D,E,WL00,SL00);	HOST_c2l(data,l); X( 2)=l;
+	RIP1(A,B,C,D,E,WL00,SL00);	(void)HOST_c2l(data,l); X( 2)=l;
-	RIP1(E,A,B,C,D,WL01,SL01);	HOST_c2l(data,l); X( 3)=l;
+	RIP1(E,A,B,C,D,WL01,SL01);	(void)HOST_c2l(data,l); X( 3)=l;
-	RIP1(D,E,A,B,C,WL02,SL02);	HOST_c2l(data,l); X( 4)=l;
+	RIP1(D,E,A,B,C,WL02,SL02);	(void)HOST_c2l(data,l); X( 4)=l;
-	RIP1(C,D,E,A,B,WL03,SL03);	HOST_c2l(data,l); X( 5)=l;
+	RIP1(C,D,E,A,B,WL03,SL03);	(void)HOST_c2l(data,l); X( 5)=l;
-	RIP1(B,C,D,E,A,WL04,SL04);	HOST_c2l(data,l); X( 6)=l;
+	RIP1(B,C,D,E,A,WL04,SL04);	(void)HOST_c2l(data,l); X( 6)=l;
-	RIP1(A,B,C,D,E,WL05,SL05);	HOST_c2l(data,l); X( 7)=l;
+	RIP1(A,B,C,D,E,WL05,SL05);	(void)HOST_c2l(data,l); X( 7)=l;
-	RIP1(E,A,B,C,D,WL06,SL06);	HOST_c2l(data,l); X( 8)=l;
+	RIP1(E,A,B,C,D,WL06,SL06);	(void)HOST_c2l(data,l); X( 8)=l;
-	RIP1(D,E,A,B,C,WL07,SL07);	HOST_c2l(data,l); X( 9)=l;
+	RIP1(D,E,A,B,C,WL07,SL07);	(void)HOST_c2l(data,l); X( 9)=l;
-	RIP1(C,D,E,A,B,WL08,SL08);	HOST_c2l(data,l); X(10)=l;
+	RIP1(C,D,E,A,B,WL08,SL08);	(void)HOST_c2l(data,l); X(10)=l;
-	RIP1(B,C,D,E,A,WL09,SL09);	HOST_c2l(data,l); X(11)=l;
+	RIP1(B,C,D,E,A,WL09,SL09);	(void)HOST_c2l(data,l); X(11)=l;
-	RIP1(A,B,C,D,E,WL10,SL10);	HOST_c2l(data,l); X(12)=l;
+	RIP1(A,B,C,D,E,WL10,SL10);	(void)HOST_c2l(data,l); X(12)=l;
-	RIP1(E,A,B,C,D,WL11,SL11);	HOST_c2l(data,l); X(13)=l;
+	RIP1(E,A,B,C,D,WL11,SL11);	(void)HOST_c2l(data,l); X(13)=l;
-	RIP1(D,E,A,B,C,WL12,SL12);	HOST_c2l(data,l); X(14)=l;
+	RIP1(D,E,A,B,C,WL12,SL12);	(void)HOST_c2l(data,l); X(14)=l;
-	RIP1(C,D,E,A,B,WL13,SL13);	HOST_c2l(data,l); X(15)=l;
+	RIP1(C,D,E,A,B,WL13,SL13);	(void)HOST_c2l(data,l); X(15)=l;
 	RIP1(B,C,D,E,A,WL14,SL14);
 	RIP1(A,B,C,D,E,WL15,SL15);
 	RIP2(E,A,B,C,D,WL16,SL16,KL1);
 	RIP2(D,E,A,B,C,WL17,SL17,KL1);
 	RIP2(C,D,E,A,B,WL18,SL18,KL1);
 	RIP2(B,C,D,E,A,WL19,SL19,KL1);
 	RIP2(A,B,C,D,E,WL20,SL20,KL1);
 	RIP2(E,A,B,C,D,WL21,SL21,KL1);
 	RIP2(D,E,A,B,C,WL22,SL22,KL1);
 	RIP2(C,D,E,A,B,WL23,SL23,KL1);
 	RIP2(B,C,D,E,A,WL24,SL24,KL1);
 	RIP2(A,B,C,D,E,WL25,SL25,KL1);

--- src/crypto/external/bsd/openssl/dist/crypto/ripemd/Attic/rmd_locl.h 2009/07/19 23:30:41	1.2
+++ src/crypto/external/bsd/openssl/dist/crypto/ripemd/Attic/rmd_locl.h 2013/02/05 21:31:25	1.3

 @@ -77,31 +77,31 @@
 void ripemd160_block_data_order (RIPEMD160_CTX *c, const void *p,size_t num);
 #define DATA_ORDER_IS_LITTLE_ENDIAN
 #define HASH_LONG               RIPEMD160_LONG
 #define HASH_CTX                RIPEMD160_CTX
 #define HASH_CBLOCK             RIPEMD160_CBLOCK
 #define HASH_UPDATE             RIPEMD160_Update
 #define HASH_TRANSFORM          RIPEMD160_Transform
 #define HASH_FINAL              RIPEMD160_Final
 #define	HASH_MAKE_STRING(c,s)	do {	\
 	unsigned long ll;		\
-	ll=(c)->A; HOST_l2c(ll,(s));	\
+	ll=(c)->A; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->B; HOST_l2c(ll,(s));	\
+	ll=(c)->B; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->C; HOST_l2c(ll,(s));	\
+	ll=(c)->C; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->D; HOST_l2c(ll,(s));	\
+	ll=(c)->D; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->E; HOST_l2c(ll,(s));	\
+	ll=(c)->E; (void)HOST_l2c(ll,(s));	\
 	} while (0)
 #define HASH_BLOCK_DATA_ORDER   ripemd160_block_data_order
 #include "md32_common.h"
 #if 0
 #define F1(x,y,z)	 ((x)^(y)^(z))
 #define F2(x,y,z)	(((x)&(y))|((~x)&z))
 #define F3(x,y,z)	(((x)|(~y))^(z))
 #define F4(x,y,z)	(((x)&(z))|((y)&(~(z))))
 #define F5(x,y,z)	 ((x)^((y)|(~(z))))
 #else
 /*

--- src/crypto/external/bsd/openssl/dist/crypto/rsa/Attic/rsa_eay.c 2012/07/26 19:58:39	1.4
+++ src/crypto/external/bsd/openssl/dist/crypto/rsa/Attic/rsa_eay.c 2013/02/05 21:31:26	1.5

 @@ -859,32 +859,32 @@ static int RSA_eay_mod_exp(BIGNUM *r0, c
 	if (!BN_mul(r1,r0,rsa->iqmp,ctx)) goto err;
 	/* Turn BN_FLG_CONSTTIME flag on before division operation */
 	if (!(rsa->flags & RSA_FLAG_NO_CONSTTIME))
+		{
 		pr1 = &local_r1;
 		BN_with_flags(pr1, r1, BN_FLG_CONSTTIME);
+		}
 	else
 		pr1 = r1;
 	if (!BN_mod(r0,pr1,rsa->p,ctx)) goto err;
 	/* If p < q it is occasionally possible for the correction of
-         * adding 'p' if r0 is negative above to leave the result still
+	 * adding 'p' if r0 is negative above to leave the result still
 	 * negative. This can break the private key operations: the following
 	 * second correction should *always* correct this rare occurrence.
 	 * This will *never* happen with OpenSSL generated keys because
-         * they ensure p > q [steve]
+	 * they ensure p > q [steve]
-         */
+	 */
 	if (BN_is_negative(r0))
 		if (!BN_add(r0,r0,rsa->p)) goto err;
 	if (!BN_mul(r1,r0,rsa->q,ctx)) goto err;
 	if (!BN_add(r0,r1,m1)) goto err;
 	if (rsa->e && rsa->n)
+		{
 		if (!rsa->meth->bn_mod_exp(vrfy,r0,rsa->e,rsa->n,ctx,rsa->_method_mod_n)) goto err;
 		/* If 'I' was greater than (or equal to) rsa->n, the operation
 		 * will be equivalent to using 'I mod n'. However, the result of
 		 * the verify will *always* be less than 'n' so we don't check
 		 * for absolute equality, just congruency. */
 		if (!BN_sub(vrfy, vrfy, I)) goto err;

--- src/crypto/external/bsd/openssl/dist/crypto/sha/sha256.c 2011/06/05 23:09:48	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/sha/sha256.c 2013/02/05 21:31:26	1.4

 @@ -78,37 +78,37 @@ int SHA224_Final (unsigned char *md, SHA
  * Note that FIPS180-2 discusses "Truncation of the Hash Function Output."
  * default: case below covers for it. It's not clear however if it's
  * permitted to truncate to amount of bytes not divisible by 4. I bet not,
  * but if it is, then default: case shall be extended. For reference.
  * Idea behind separate cases for pre-defined lenghts is to let the
  * compiler decide if it's appropriate to unroll small loops.
  */
 #define	HASH_MAKE_STRING(c,s)	do {	\
 	unsigned long ll;		\
 	unsigned int  nn;		\
 	switch ((c)->md_len)		\
 	{   case SHA224_DIGEST_LENGTH:	\
 		for (nn=0;nn<SHA224_DIGEST_LENGTH/4;nn++)	\
-		{   ll=(c)->h[nn]; HOST_l2c(ll,(s));   }	\
+		{   ll=(c)->h[nn]; (void)HOST_l2c(ll,(s));   }	\
 		break;			\
 	    case SHA256_DIGEST_LENGTH:	\
 		for (nn=0;nn<SHA256_DIGEST_LENGTH/4;nn++)	\
-		{   ll=(c)->h[nn]; HOST_l2c(ll,(s));   }	\
+		{   ll=(c)->h[nn]; (void)HOST_l2c(ll,(s));   }	\
 		break;			\
 	    default:			\
 		if ((c)->md_len > SHA256_DIGEST_LENGTH)	\
 		    return 0;				\
 		for (nn=0;nn<(c)->md_len/4;nn++)		\
-		{   ll=(c)->h[nn]; HOST_l2c(ll,(s));   }	\
+		{   ll=(c)->h[nn]; (void)HOST_l2c(ll,(s));   }	\
 		break;			\
 	}				\
 	} while (0)
 #define	HASH_UPDATE		SHA256_Update
 #define	HASH_TRANSFORM		SHA256_Transform
 #define	HASH_FINAL		SHA256_Final
 #define	HASH_BLOCK_DATA_ORDER	sha256_block_data_order
 #ifndef SHA256_ASM
 static
 #endif
 void sha256_block_data_order (SHA256_CTX *ctx, const void *in, size_t num);

--- src/crypto/external/bsd/openssl/dist/crypto/sha/Attic/sha_locl.h 2011/06/05 23:09:48	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/sha/Attic/sha_locl.h 2013/02/05 21:31:26	1.4

 @@ -59,31 +59,31 @@
 #include <stdlib.h>
 #include <string.h>
 #include <openssl/opensslconf.h>
 #include <openssl/sha.h>
 #define DATA_ORDER_IS_BIG_ENDIAN
 #define HASH_LONG               SHA_LONG
 #define HASH_CTX                SHA_CTX
 #define HASH_CBLOCK             SHA_CBLOCK
 #define HASH_MAKE_STRING(c,s)   do {	\
 	SHA_LONG ll;		\
-	ll=(c)->h0; HOST_l2c(ll,(s));	\
+	ll=(c)->h0; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->h1; HOST_l2c(ll,(s));	\
+	ll=(c)->h1; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->h2; HOST_l2c(ll,(s));	\
+	ll=(c)->h2; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->h3; HOST_l2c(ll,(s));	\
+	ll=(c)->h3; (void)HOST_l2c(ll,(s));	\
-	ll=(c)->h4; HOST_l2c(ll,(s));	\
+	ll=(c)->h4; (void)HOST_l2c(ll,(s));	\
 	} while (0)
 #if defined(SHA_0)
 # define HASH_UPDATE             	SHA_Update
 # define HASH_TRANSFORM          	SHA_Transform
 # define HASH_FINAL              	SHA_Final
 # define HASH_INIT			SHA_Init
 # define HASH_BLOCK_DATA_ORDER   	sha_block_data_order
 # define Xupdate(a,ix,ia,ib,ic,id)	(ix=(a)=(ia^ib^ic^id))
 static void sha_block_data_order (SHA_CTX *c, const void *p,size_t num);
 @@ -246,41 +246,41 @@ static void HASH_BLOCK_DATA_ORDER (SHA_C
 		BODY_00_15( 8,E,T,A,B,C,D,X( 8));	X(10) = W[10];
 		BODY_00_15( 9,D,E,T,A,B,C,X( 9));	X(11) = W[11];
 		BODY_00_15(10,C,D,E,T,A,B,X(10));	X(12) = W[12];
 		BODY_00_15(11,B,C,D,E,T,A,X(11));	X(13) = W[13];
 		BODY_00_15(12,A,B,C,D,E,T,X(12));	X(14) = W[14];
 		BODY_00_15(13,T,A,B,C,D,E,X(13));	X(15) = W[15];
 		BODY_00_15(14,E,T,A,B,C,D,X(14));
 		BODY_00_15(15,D,E,T,A,B,C,X(15));
 		data += SHA_CBLOCK;
+		}
 	else
+		{
-		HOST_c2l(data,l); X( 0)=l;		HOST_c2l(data,l); X( 1)=l;
+		(void)HOST_c2l(data,l); X( 0)=l;	(void)HOST_c2l(data,l); X( 1)=l;
-		BODY_00_15( 0,A,B,C,D,E,T,X( 0));	HOST_c2l(data,l); X( 2)=l;
+		BODY_00_15( 0,A,B,C,D,E,T,X( 0));	(void)HOST_c2l(data,l); X( 2)=l;
-		BODY_00_15( 1,T,A,B,C,D,E,X( 1));	HOST_c2l(data,l); X( 3)=l;
+		BODY_00_15( 1,T,A,B,C,D,E,X( 1));	(void)HOST_c2l(data,l); X( 3)=l;
-		BODY_00_15( 2,E,T,A,B,C,D,X( 2));	HOST_c2l(data,l); X( 4)=l;
+		BODY_00_15( 2,E,T,A,B,C,D,X( 2));	(void)HOST_c2l(data,l); X( 4)=l;
-		BODY_00_15( 3,D,E,T,A,B,C,X( 3));	HOST_c2l(data,l); X( 5)=l;
+		BODY_00_15( 3,D,E,T,A,B,C,X( 3));	(void)HOST_c2l(data,l); X( 5)=l;
-		BODY_00_15( 4,C,D,E,T,A,B,X( 4));	HOST_c2l(data,l); X( 6)=l;
+		BODY_00_15( 4,C,D,E,T,A,B,X( 4));	(void)HOST_c2l(data,l); X( 6)=l;
-		BODY_00_15( 5,B,C,D,E,T,A,X( 5));	HOST_c2l(data,l); X( 7)=l;
+		BODY_00_15( 5,B,C,D,E,T,A,X( 5));	(void)HOST_c2l(data,l); X( 7)=l;
-		BODY_00_15( 6,A,B,C,D,E,T,X( 6));	HOST_c2l(data,l); X( 8)=l;
+		BODY_00_15( 6,A,B,C,D,E,T,X( 6));	(void)HOST_c2l(data,l); X( 8)=l;
-		BODY_00_15( 7,T,A,B,C,D,E,X( 7));	HOST_c2l(data,l); X( 9)=l;
+		BODY_00_15( 7,T,A,B,C,D,E,X( 7));	(void)HOST_c2l(data,l); X( 9)=l;
-		BODY_00_15( 8,E,T,A,B,C,D,X( 8));	HOST_c2l(data,l); X(10)=l;
+		BODY_00_15( 8,E,T,A,B,C,D,X( 8));	(void)HOST_c2l(data,l); X(10)=l;
-		BODY_00_15( 9,D,E,T,A,B,C,X( 9));	HOST_c2l(data,l); X(11)=l;
+		BODY_00_15( 9,D,E,T,A,B,C,X( 9));	(void)HOST_c2l(data,l); X(11)=l;
-		BODY_00_15(10,C,D,E,T,A,B,X(10));	HOST_c2l(data,l); X(12)=l;
+		BODY_00_15(10,C,D,E,T,A,B,X(10));	(void)HOST_c2l(data,l); X(12)=l;
-		BODY_00_15(11,B,C,D,E,T,A,X(11));	HOST_c2l(data,l); X(13)=l;
+		BODY_00_15(11,B,C,D,E,T,A,X(11));	(void)HOST_c2l(data,l); X(13)=l;
-		BODY_00_15(12,A,B,C,D,E,T,X(12));	HOST_c2l(data,l); X(14)=l;
+		BODY_00_15(12,A,B,C,D,E,T,X(12));	(void)HOST_c2l(data,l); X(14)=l;
-		BODY_00_15(13,T,A,B,C,D,E,X(13));	HOST_c2l(data,l); X(15)=l;
+		BODY_00_15(13,T,A,B,C,D,E,X(13));	(void)HOST_c2l(data,l); X(15)=l;
 		BODY_00_15(14,E,T,A,B,C,D,X(14));
 		BODY_00_15(15,D,E,T,A,B,C,X(15));
+		}
 	BODY_16_19(16,C,D,E,T,A,B,X( 0),X( 0),X( 2),X( 8),X(13));
 	BODY_16_19(17,B,C,D,E,T,A,X( 1),X( 1),X( 3),X( 9),X(14));
 	BODY_16_19(18,A,B,C,D,E,T,X( 2),X( 2),X( 4),X(10),X(15));
 	BODY_16_19(19,T,A,B,C,D,E,X( 3),X( 3),X( 5),X(11),X( 0));
 	BODY_20_31(20,E,T,A,B,C,D,X( 4),X( 4),X( 6),X(12),X( 1));
 	BODY_20_31(21,D,E,T,A,B,C,X( 5),X( 5),X( 7),X(13),X( 2));
 	BODY_20_31(22,C,D,E,T,A,B,X( 6),X( 6),X( 8),X(14),X( 3));
 	BODY_20_31(23,B,C,D,E,T,A,X( 7),X( 7),X( 9),X(15),X( 4));

--- src/crypto/external/bsd/openssl/dist/crypto/ui/ui_openssl.c 2012/07/26 19:58:39	1.4
+++ src/crypto/external/bsd/openssl/dist/crypto/ui/ui_openssl.c 2013/02/05 21:31:26	1.5

 @@ -112,29 +112,35 @@
  * 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 <openssl/e_os2.h>
 /* need for #define _POSIX_C_SOURCE arises whenever you pass -ansi to gcc
  * [maybe others?], because it masks interfaces not discussed in standard,
  * sigaction and fileno included. -pedantic would be more appropriate for
  * the intended purposes, but we can't prevent users from adding -ansi.
  */
 #if defined(OPENSSL_SYSNAME_VXWORKS)
 #include <sys/types.h>
 #endif
 #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)
 #ifndef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 2
 #endif
 #endif
 #include <signal.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #if !defined(OPENSSL_SYS_MSDOS) && !defined(OPENSSL_SYS_VMS)
 #  include <unistd.h>
 /* If unistd.h defines _POSIX_VERSION, we conclude that we
  * are on a POSIX system and have sigaction and termios. */
 # if defined(_POSIX_VERSION)
 #  define SIGACTION
 #  if !defined(TERMIOS) && !defined(TERMIO) && !defined(SGTTY)

--- src/crypto/external/bsd/openssl/dist/crypto/x509/x509_vfy.c 2012/07/26 19:58:39	1.3
+++ src/crypto/external/bsd/openssl/dist/crypto/x509/x509_vfy.c 2013/02/05 21:31:26	1.4

 @@ -862,38 +862,38 @@ static int get_crl_sk(X509_STORE_CTX *ct
 		return 1;
 	return 0;
+	}
 /* Compare two CRL extensions for delta checking purposes. They should be
  * both present or both absent. If both present all fields must be identical.
  */
 static int crl_extension_match(X509_CRL *a, X509_CRL *b, int nid)
+	{
 	ASN1_OCTET_STRING *exta, *extb;
 	int i;
-	i = X509_CRL_get_ext_by_NID(a, nid, 0);
+	i = X509_CRL_get_ext_by_NID(a, nid, -1);
 	if (i >= 0)
+		{
 		/* Can't have multiple occurrences */
 		if (X509_CRL_get_ext_by_NID(a, nid, i) != -1)
 			return 0;
 		exta = X509_EXTENSION_get_data(X509_CRL_get_ext(a, i));
+		}
 	else
 		exta = NULL;
-	i = X509_CRL_get_ext_by_NID(b, nid, 0);
+	i = X509_CRL_get_ext_by_NID(b, nid, -1);
 	if (i >= 0)
+		{
 		if (X509_CRL_get_ext_by_NID(b, nid, i) != -1)
 			return 0;
 		extb = X509_EXTENSION_get_data(X509_CRL_get_ext(b, i));
+		}
 	else
 		extb = NULL;
 	if (!exta && !extb)
 		return 1;

--- src/crypto/external/bsd/openssl/dist/engines/ccgost/Attic/gost_eng.c 2013/02/04 01:44:47	1.2
+++ src/crypto/external/bsd/openssl/dist/engines/ccgost/Attic/gost_eng.c 2013/02/05 21:31:26	1.3

	@@ -68,26 +68,31 @@ static int gost_engine_destroy(ENGINE *e		@@ -68,26 +68,31 @@ static int gost_engine_destroy(ENGINE *e
68	pmeth_GostR3410_94 = NULL;	68	pmeth_GostR3410_94 = NULL;
69	pmeth_GostR3410_2001 = NULL;	69	pmeth_GostR3410_2001 = NULL;
70	pmeth_Gost28147_MAC = NULL;	70	pmeth_Gost28147_MAC = NULL;
71	ameth_GostR3410_94 = NULL;	71	ameth_GostR3410_94 = NULL;
72	ameth_GostR3410_2001 = NULL;	72	ameth_GostR3410_2001 = NULL;
73	ameth_Gost28147_MAC = NULL;	73	ameth_Gost28147_MAC = NULL;
74	return 1;	74	return 1;
75	}	75	}
76		76
77	static int bind_gost (ENGINE e,const char id)	77	static int bind_gost (ENGINE e,const char id)
78	{	78	{
79	int ret = 0;	79	int ret = 0;
80	if (id && strcmp(id, engine_gost_id)) return 0;	80	if (id && strcmp(id, engine_gost_id)) return 0;
		81	if (ameth_GostR3410_94)
		82	{
		83	printf("GOST engine already loaded\n");
		84	goto end;
		85	}
81		86
82	if (!ENGINE_set_id(e, engine_gost_id))	87	if (!ENGINE_set_id(e, engine_gost_id))
83	{	88	{
84	printf("ENGINE_set_id failed\n");	89	printf("ENGINE_set_id failed\n");
85	goto end;	90	goto end;
86	}	91	}
87	if (!ENGINE_set_name(e, engine_gost_name))	92	if (!ENGINE_set_name(e, engine_gost_name))
88	{	93	{
89	printf("ENGINE_set_name failed\n");	94	printf("ENGINE_set_name failed\n");
90	goto end;	95	goto end;
91	}	96	}
92	if (!ENGINE_set_digests(e, gost_digests))	97	if (!ENGINE_set_digests(e, gost_digests))
93	{	98	{

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/d1_enc.c 2012/05/11 18:07:33	1.2
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/d1_enc.c 2013/02/05 21:31:26	1.3

 @@ -116,67 +116,74 @@
 #include <stdio.h>
 #include "ssl_locl.h"
 #ifndef OPENSSL_NO_COMP
 #include <openssl/comp.h>
 #endif
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
 #include <openssl/md5.h>
 #include <openssl/rand.h>
 #ifdef KSSL_DEBUG
 #include <openssl/des.h>
 #endif
 /* dtls1_enc encrypts/decrypts the record in |s->wrec| / |s->rrec|, respectively.
+ *
  * Returns:
  *   0: (in non-constant time) if the record is publically invalid (i.e. too
  *       short etc).
  *   1: if the record's padding is valid / the encryption was successful.
  *   -1: if the record's padding/AEAD-authenticator is invalid or, if sending,
  *       an internal error occured. */
 int dtls1_enc(SSL *s, int send)
+	{
 	SSL3_RECORD *rec;
 	EVP_CIPHER_CTX *ds;
 	unsigned long l;
-	int bs,i,ii,j,k,n=0;
+	int bs,i,j,k,mac_size=0;
 	const EVP_CIPHER *enc;
 	if (send)
+		{
 		if (EVP_MD_CTX_md(s->write_hash))
+			{
-			n=EVP_MD_CTX_size(s->write_hash);
+			mac_size=EVP_MD_CTX_size(s->write_hash);
-			if (n < 0)
+			if (mac_size < 0)
 				return -1;
+			}
 		ds=s->enc_write_ctx;
 		rec= &(s->s3->wrec);
 		if (s->enc_write_ctx == NULL)
 			enc=NULL;
 		else
+			{
 			enc=EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
 			if ( rec->data != rec->input)
 				/* we can't write into the input stream */
 				fprintf(stderr, "%s:%d: rec->data != rec->input\n",
 					__FILE__, __LINE__);
 			else if ( EVP_CIPHER_block_size(ds->cipher) > 1)
+				{
 				if (RAND_bytes(rec->input, EVP_CIPHER_block_size(ds->cipher)) <= 0)
 					return -1;
+				}
+			}
+		}
 	else
+		{
 		if (EVP_MD_CTX_md(s->read_hash))
+			{
-			n=EVP_MD_CTX_size(s->read_hash);
+			mac_size=EVP_MD_CTX_size(s->read_hash);
-			if (n < 0)
+			OPENSSL_assert(mac_size >= 0);
 				return -1;
+			}
 		ds=s->enc_read_ctx;
 		rec= &(s->s3->rrec);
 		if (s->enc_read_ctx == NULL)
 			enc=NULL;
 		else
 			enc=EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
+		}
 #ifdef KSSL_DEBUG
 	printf("dtls1_enc(%d)\n", send);
 #endif    /* KSSL_DEBUG */
 @@ -221,69 +228,33 @@ int dtls1_enc(SSL *s, int send)
                         ds->cipher->iv_len);
 		printf("\t\tIV: ");
 		for (i=0; i<ds->cipher->iv_len; i++) printf("%02X", ds->iv[i]);
 		printf("\n");
 		printf("\trec->input=");
 		for (ui=0; ui<l; ui++) printf(" %02x", rec->input[ui]);
 		printf("\n");
+		}
 #endif	/* KSSL_DEBUG */
 		if (!send)
+			{
 			if (l == 0 || l%bs != 0)
-				return -1;
+				return 0;
+			}
 		EVP_Cipher(ds,rec->data,rec->input,l);
 #ifdef KSSL_DEBUG
+		{
                 unsigned long i;
                 printf("\trec->data=");
 		for (i=0; i<l; i++)
                         printf(" %02x", rec->data[i]);  printf("\n");
+                }
 #endif	/* KSSL_DEBUG */
 		if ((bs != 1) && !send)
 			return tls1_cbc_remove_padding(s, rec, bs, mac_size);
 			ii=i=rec->data[l-1]; /* padding_length */
 			i++;
 			if (s->options&SSL_OP_TLS_BLOCK_PADDING_BUG)
 				/* First packet is even in size, so check */
 				if ((memcmp(s->s3->read_sequence,
 					"\0\0\0\0\0\0\0\0",8) == 0) && !(ii & 1))
 					s->s3->flags|=TLS1_FLAGS_TLS_PADDING_BUG;
 				if (s->s3->flags & TLS1_FLAGS_TLS_PADDING_BUG)
 					i--;
 			/* TLS 1.0 does not bound the number of padding bytes by the block size.
 			 * All of them must have value 'padding_length'. */
 			if (i + bs > (int)rec->length)
 				/* Incorrect padding. SSLerr() and ssl3_alert are done
 				 * by caller: we don't want to reveal whether this is
 				 * a decryption error or a MAC verification failure
 				 * (see http://www.openssl.org/~bodo/tls-cbc.txt)
 				 */
 				return -1;
 			for (j=(int)(l-i); j<(int)l; j++)
 				if (rec->data[j] != ii)
 					/* Incorrect padding */
 					return -1;
 			rec->length-=i;
 			rec->data += bs;    /* skip the implicit IV */
 			rec->input += bs;
 			rec->length -= bs;
+		}
 	return(1);
+	}

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/d1_pkt.c 2012/07/26 19:58:39	1.4
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/d1_pkt.c 2013/02/05 21:31:26	1.5

 @@ -366,35 +366,31 @@ dtls1_get_buffered_record(SSL *s)
 		/* s->d1->next_expected_seq_num++; */
 		return(1);
+		}
 	return 0;
+	}
 #endif
 static int
 dtls1_process_record(SSL *s)
+{
 	int i,al;
 	int clear=0;
 	int enc_err;
 	SSL_SESSION *sess;
 	SSL3_RECORD *rr;
-	unsigned int mac_size;
+	unsigned int mac_size, orig_len;
 	unsigned char md[EVP_MAX_MD_SIZE];
 	int decryption_failed_or_bad_record_mac = 0;
 	unsigned char *mac = NULL;
 	rr= &(s->s3->rrec);
 	sess = s->session;
 	/* At this point, s->packet_length == SSL3_RT_HEADER_LNGTH + rr->length,
 	 * and we have that many bytes in s->packet
 	 */
 	rr->input= &(s->packet[DTLS1_RT_HEADER_LENGTH]);
 	/* ok, we can now read from 's->packet' data into 'rr'
 	 * rr->input points at rr->length bytes, which
 	 * need to be copied into rr->data by either
 	 * the decryption or by the decompression
 @@ -404,82 +400,101 @@ dtls1_process_record(SSL *s)
 	/* We now have - encrypted [ MAC [ compressed [ plain ] ] ]
 	 * rr->length bytes of encrypted compressed stuff. */
 	/* check is not needed I believe */
 	if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH)
+		{
 		al=SSL_AD_RECORD_OVERFLOW;
 		SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
 		goto f_err;
+		}
 	/* decrypt in place in 'rr->input' */
 	rr->data=rr->input;
 	orig_len=rr->length;
 	enc_err = s->method->ssl3_enc->enc(s,0);
-	if (enc_err <= 0)
+	/* enc_err is:
 	 *    0: (in non-constant time) if the record is publically invalid.
 	 *    1: if the padding is valid
 	 *    -1: if the padding is invalid */
 	if (enc_err == 0)
+		{
-		/* To minimize information leaked via timing, we will always
+		/* For DTLS we simply ignore bad packets. */
-		 * perform all computations before discarding the message.
+		rr->length = 0;
-		 */
+		s->packet_length = 0;
-		decryption_failed_or_bad_record_mac = 1;
+		goto err;
+		}
 #ifdef TLS_DEBUG
 printf("dec %d\n",rr->length);
 { unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); }
 printf("\n");
 #endif
 	/* r->length is now the compressed data plus mac */
-	if (	(sess == NULL) ||
+	if ((sess != NULL) &&
-		(s->enc_read_ctx == NULL) ||
+	    (s->enc_read_ctx != NULL) &&
-		(s->read_hash == NULL))
+	    (EVP_MD_CTX_md(s->read_hash) != NULL))
 		clear=1;
 		/* s->read_hash != NULL => mac_size != -1 */
-	if (!clear)
+		unsigned char *mac = NULL;
 		unsigned char mac_tmp[EVP_MAX_MD_SIZE];
-		/* !clear => s->read_hash != NULL => mac_size != -1 */
+		mac_size=EVP_MD_CTX_size(s->read_hash);
-		int t;
+		OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
 		t=EVP_MD_CTX_size(s->read_hash);
-		OPENSSL_assert(t >= 0);
+		/* orig_len is the length of the record before any padding was
-		mac_size=t;
+		 * removed. This is public information, as is the MAC in use,
 		 * therefore we can safely process the record in a different
-		if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+mac_size)
+		 * amount of time if it's too short to possibly contain a MAC.
 		 */
 		if (orig_len < mac_size ||
 		    /* CBC records must have a padding length byte too. */
 		    (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
 		     orig_len < mac_size+1))
+			{
-#if 0 /* OK only for stream ciphers (then rr->length is visible from ciphertext anyway) */
+			al=SSL_AD_DECODE_ERROR;
-			al=SSL_AD_RECORD_OVERFLOW;
+			SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_LENGTH_TOO_SHORT);
 			SSLerr(SSL_F_DTLS1_PROCESS_RECORD,SSL_R_PRE_MAC_LENGTH_TOO_LONG);
 			goto f_err;
 #else
 			decryption_failed_or_bad_record_mac = 1;
 #endif
+			}
 		/* check the MAC for rr->input (it's in mac_size bytes at the tail) */
-		if (rr->length >= mac_size)
+		if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE)
+			{
 			/* We update the length so that the TLS header bytes
 			 * can be constructed correctly but we need to extract
 			 * the MAC in constant time from within the record,
 			 * without leaking the contents of the padding bytes.
 			 * */
 			mac = mac_tmp;
 			ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len);
 			rr->length -= mac_size;
 			mac = &rr->data[rr->length];
+			}
 		else
 			rr->length = 0;
 		i=s->method->ssl3_enc->mac(s,md,0);
 		if (i < 0 || mac == NULL || memcmp(md, mac, mac_size) != 0)
+			{
-			decryption_failed_or_bad_record_mac = 1;
+			/* In this case there's no padding, so |orig_len|
 			 * equals |rec->length| and we checked that there's
 			 * enough bytes for |mac_size| above. */
 			rr->length -= mac_size;
 			mac = &rr->data[rr->length];
+			}
 		i=s->method->ssl3_enc->mac(s,md,0 /* not send */);
 		if (i < 0 || mac == NULL || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
 			enc_err = -1;
 		if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+mac_size)
 			enc_err = -1;
+		}
-	if (decryption_failed_or_bad_record_mac)
+	if (enc_err < 0)
+		{
 		/* decryption failed, silently discard message */
 		rr->length = 0;
 		s->packet_length = 0;
 		goto err;
+		}
 	/* r->length is now just compressed */
 	if (s->expand != NULL)
+		{
 		if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH)
+			{
 			al=SSL_AD_RECORD_OVERFLOW;

--- src/crypto/external/bsd/openssl/dist/ssl/s3_enc.c 2012/01/05 17:32:02	1.4
+++ src/crypto/external/bsd/openssl/dist/ssl/s3_enc.c 2013/02/05 21:31:26	1.5

 @@ -456,32 +456,41 @@ err:
 void ssl3_cleanup_key_block(SSL *s)
+	{
 	if (s->s3->tmp.key_block != NULL)
+		{
 		OPENSSL_cleanse(s->s3->tmp.key_block,
 			s->s3->tmp.key_block_length);
 		OPENSSL_free(s->s3->tmp.key_block);
 		s->s3->tmp.key_block=NULL;
+		}
 	s->s3->tmp.key_block_length=0;
+	}
 /* ssl3_enc encrypts/decrypts the record in |s->wrec| / |s->rrec|, respectively.
+ *
  * Returns:
  *   0: (in non-constant time) if the record is publically invalid (i.e. too
  *       short etc).
  *   1: if the record's padding is valid / the encryption was successful.
  *   -1: if the record's padding is invalid or, if sending, an internal error
  *       occured.
  */
 int ssl3_enc(SSL *s, int send)
+	{
 	SSL3_RECORD *rec;
 	EVP_CIPHER_CTX *ds;
 	unsigned long l;
-	int bs,i;
+	int bs,i,mac_size=0;
 	const EVP_CIPHER *enc;
 	if (send)
+		{
 		ds=s->enc_write_ctx;
 		rec= &(s->s3->wrec);
 		if (s->enc_write_ctx == NULL)
 			enc=NULL;
 		else
 			enc=EVP_CIPHER_CTX_cipher(s->enc_write_ctx);
+		}
 	else
+		{
 @@ -512,52 +521,36 @@ int ssl3_enc(SSL *s, int send)
 			/* we need to add 'i-1' padding bytes */
 			l+=i;
 			/* the last of these zero bytes will be overwritten
 			 * with the padding length. */
 			memset(&rec->input[rec->length], 0, i);
 			rec->length+=i;
 			rec->input[l-1]=(i-1);
+			}
 		if (!send)
+			{
 			if (l == 0 || l%bs != 0)
 				SSLerr(SSL_F_SSL3_ENC,SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
 				ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECRYPTION_FAILED);
 				return 0;
 			/* otherwise, rec->length >= bs */
+			}
 		EVP_Cipher(ds,rec->data,rec->input,l);
 		if (EVP_MD_CTX_md(s->read_hash) != NULL)
 			mac_size = EVP_MD_CTX_size(s->read_hash);
 		if ((bs != 1) && !send)
 			return ssl3_cbc_remove_padding(s, rec, bs, mac_size);
 			i=rec->data[l-1]+1;
 			/* SSL 3.0 bounds the number of padding bytes by the block size;
 			 * padding bytes (except the last one) are arbitrary */
 			if (i > bs)
 				/* Incorrect padding. SSLerr() and ssl3_alert are done
 				 * by caller: we don't want to reveal whether this is
 				 * a decryption error or a MAC verification failure
 				 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */
 				return -1;
 			/* now i <= bs <= rec->length */
 			rec->length-=i;
+		}
 	return(1);
+	}
 void ssl3_init_finished_mac(SSL *s)
+	{
 	if (s->s3->handshake_buffer) BIO_free(s->s3->handshake_buffer);
 	if (s->s3->handshake_dgst) ssl3_free_digest_list(s);
     s->s3->handshake_buffer=BIO_new(BIO_s_mem());
 	(void)BIO_set_close(s->s3->handshake_buffer,BIO_CLOSE);
+	}
 void ssl3_free_digest_list(SSL *s)
 @@ -706,73 +699,117 @@ static int ssl3_handshake_mac(SSL *s, in
 	EVP_MD_CTX_cleanup(&ctx);
 	return((int)ret);
+	}
 int n_ssl3_mac(SSL *ssl, unsigned char *md, int send)
+	{
 	SSL3_RECORD *rec;
 	unsigned char *mac_sec,*seq;
 	EVP_MD_CTX md_ctx;
 	const EVP_MD_CTX *hash;
 	unsigned char *p,rec_char;
-	unsigned int md_size;
+	size_t md_size, orig_len;
 	int npad;
 	int t;
 	if (send)
+		{
 		rec= &(ssl->s3->wrec);
 		mac_sec= &(ssl->s3->write_mac_secret[0]);
 		seq= &(ssl->s3->write_sequence[0]);
 		hash=ssl->write_hash;
+		}
 	else
+		{
 		rec= &(ssl->s3->rrec);
 		mac_sec= &(ssl->s3->read_mac_secret[0]);
 		seq= &(ssl->s3->read_sequence[0]);
 		hash=ssl->read_hash;
+		}
 	t=EVP_MD_CTX_size(hash);
 	if (t < 0)
 		return -1;
 	md_size=t;
 	npad=(48/md_size)*md_size;
-	/* Chop the digest off the end :-) */
+	/* kludge: ssl3_cbc_remove_padding passes padding length in rec->type */
-	EVP_MD_CTX_init(&md_ctx);
+	orig_len = rec->length+md_size+((unsigned int)rec->type>>8);
 	rec->type &= 0xff;
 	EVP_MD_CTX_copy_ex( &md_ctx,hash);
-	EVP_DigestUpdate(&md_ctx,mac_sec,md_size);
+	if (!send &&
-	EVP_DigestUpdate(&md_ctx,ssl3_pad_1,npad);
+	    EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
-	EVP_DigestUpdate(&md_ctx,seq,8);
+	    ssl3_cbc_record_digest_supported(hash))
 	rec_char=rec->type;
-	EVP_DigestUpdate(&md_ctx,&rec_char,1);
+		/* This is a CBC-encrypted record. We must avoid leaking any
-	p=md;
+		 * timing-side channel information about how many blocks of
-	s2n(rec->length,p);
+		 * data we are hashing because that gives an attacker a
-	EVP_DigestUpdate(&md_ctx,md,2);
+		 * timing-oracle. */
 	EVP_DigestUpdate(&md_ctx,rec->input,rec->length);
-	EVP_DigestFinal_ex( &md_ctx,md,NULL);
+		/* npad is, at most, 48 bytes and that's with MD5:
 		 *   16 + 48 + 8 (sequence bytes) + 1 + 2 = 75.
 	EVP_MD_CTX_copy_ex( &md_ctx,hash);
-	EVP_DigestUpdate(&md_ctx,mac_sec,md_size);
+		 * With SHA-1 (the largest hash speced for SSLv3) the hash size
-	EVP_DigestUpdate(&md_ctx,ssl3_pad_2,npad);
+		 * goes up 4, but npad goes down by 8, resulting in a smaller
-	EVP_DigestUpdate(&md_ctx,md,md_size);
+		 * total size. */
-	EVP_DigestFinal_ex( &md_ctx,md,&md_size);
+		unsigned char header[75];
 		unsigned j = 0;
 		memcpy(header+j, mac_sec, md_size);
 		j += md_size;
 		memcpy(header+j, ssl3_pad_1, npad);
 		j += npad;
 		memcpy(header+j, seq, 8);
 		j += 8;
 		header[j++] = rec->type;
 		header[j++] = rec->length >> 8;
 		header[j++] = rec->length & 0xff;
 		ssl3_cbc_digest_record(
 			hash,
 			md, &md_size,
 			header, rec->input,
 			rec->length + md_size, orig_len,
 			mac_sec, md_size,
 /* is SSLv3 */);
+		}
 	else
+		{
 		unsigned int md_size_u;
 		/* Chop the digest off the end :-) */
 		EVP_MD_CTX_init(&md_ctx);
 		EVP_MD_CTX_copy_ex( &md_ctx,hash);
 		EVP_DigestUpdate(&md_ctx,mac_sec,md_size);
 		EVP_DigestUpdate(&md_ctx,ssl3_pad_1,npad);
 		EVP_DigestUpdate(&md_ctx,seq,8);
 		rec_char=rec->type;
 		EVP_DigestUpdate(&md_ctx,&rec_char,1);
 		p=md;
 		s2n(rec->length,p);
 		EVP_DigestUpdate(&md_ctx,md,2);
 		EVP_DigestUpdate(&md_ctx,rec->input,rec->length);
 		EVP_DigestFinal_ex( &md_ctx,md,NULL);
 		EVP_MD_CTX_copy_ex( &md_ctx,hash);
 		EVP_DigestUpdate(&md_ctx,mac_sec,md_size);
 		EVP_DigestUpdate(&md_ctx,ssl3_pad_2,npad);
 		EVP_DigestUpdate(&md_ctx,md,md_size);
 		EVP_DigestFinal_ex( &md_ctx,md,&md_size_u);
 		md_size = md_size_u;
-	EVP_MD_CTX_cleanup(&md_ctx);
+		EVP_MD_CTX_cleanup(&md_ctx);
+	}
 	ssl3_record_sequence_update(seq);
 	return(md_size);
+	}
 void ssl3_record_sequence_update(unsigned char *seq)
+	{
 	int i;
 	for (i=7; i>=0; i--)
+		{
 		++seq[i];
 		if (seq[i] != 0) break;

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/ssltest.c 2012/07/26 19:58:39	1.4
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/ssltest.c 2013/02/05 21:31:27	1.5

 @@ -533,28 +533,28 @@ int main(int argc, char *argv[])
 	/* client */
 	SRP_CLIENT_ARG srp_client_arg = {NULL,NULL};
 	/* server */
 	SRP_SERVER_ARG srp_server_arg = {NULL,NULL};
 #endif
 	int no_dhe = 0;
 	int no_ecdhe = 0;
 	int no_psk = 0;
 	int print_time = 0;
 	clock_t s_time = 0, c_time = 0;
 	int comp = 0;
 #ifndef OPENSSL_NO_COMP
 	COMP_METHOD *cm = NULL;
 #endif
 	STACK_OF(SSL_COMP) *ssl_comp_methods = NULL;
 #endif
 	int test_cipherlist = 0;
 #ifdef OPENSSL_FIPS
 	int fips_mode=0;
 #endif
 	verbose = 0;
 	debug = 0;
 	cipher = 0;
 	bio_err=BIO_new_fp(stderr,BIO_NOCLOSE|BIO_FP_TEXT);
 	CRYPTO_set_locking_callback(lock_dbg_cb);

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/s3_clnt.c 2012/07/26 19:58:39	1.5
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/s3_clnt.c 2013/02/05 21:31:26	1.6

 @@ -449,27 +449,26 @@ int ssl3_connect(SSL *s)
 			ret=ssl3_send_client_verify(s);
 			if (ret <= 0) goto end;
 			s->state=SSL3_ST_CW_CHANGE_A;
 			s->init_num=0;
 			s->s3->change_cipher_spec=0;
 			break;
 		case SSL3_ST_CW_CHANGE_A:
 		case SSL3_ST_CW_CHANGE_B:
 			ret=ssl3_send_change_cipher_spec(s,
 				SSL3_ST_CW_CHANGE_A,SSL3_ST_CW_CHANGE_B);
 			if (ret <= 0) goto end;
 #if defined(OPENSSL_NO_TLSEXT) || defined(OPENSSL_NO_NEXTPROTONEG)
 			s->state=SSL3_ST_CW_FINISHED_A;
 #else
 			if (s->s3->next_proto_neg_seen)
 				s->state=SSL3_ST_CW_NEXT_PROTO_A;
 			else
 				s->state=SSL3_ST_CW_FINISHED_A;
 #endif
 			s->init_num=0;
 			s->session->cipher=s->s3->tmp.new_cipher;
 #ifdef OPENSSL_NO_COMP
 			s->session->compress_meth=0;

--- src/crypto/external/bsd/openssl/dist/ssl/ssl_ciph.c 2012/07/26 19:58:39	1.5
+++ src/crypto/external/bsd/openssl/dist/ssl/ssl_ciph.c 2013/02/05 21:31:27	1.6

 @@ -302,26 +302,27 @@ static const SSL_CIPHER cipher_aliases[]
 	/* MAC aliases */
 	{0,SSL_TXT_MD5,0,     0,0,0,SSL_MD5,   0,0,0,0,0},
 	{0,SSL_TXT_SHA1,0,    0,0,0,SSL_SHA1,  0,0,0,0,0},
 	{0,SSL_TXT_SHA,0,     0,0,0,SSL_SHA1,  0,0,0,0,0},
 	{0,SSL_TXT_GOST94,0,     0,0,0,SSL_GOST94,  0,0,0,0,0},
 	{0,SSL_TXT_GOST89MAC,0,     0,0,0,SSL_GOST89MAC,  0,0,0,0,0},
 	{0,SSL_TXT_SHA256,0,    0,0,0,SSL_SHA256,  0,0,0,0,0},
 	{0,SSL_TXT_SHA384,0,    0,0,0,SSL_SHA384,  0,0,0,0,0},
 	/* protocol version aliases */
 	{0,SSL_TXT_SSLV2,0,   0,0,0,0,SSL_SSLV2, 0,0,0,0},
 	{0,SSL_TXT_SSLV3,0,   0,0,0,0,SSL_SSLV3, 0,0,0,0},
 	{0,SSL_TXT_TLSV1,0,   0,0,0,0,SSL_TLSV1, 0,0,0,0},
 	{0,SSL_TXT_TLSV1_2,0, 0,0,0,0,SSL_TLSV1_2, 0,0,0,0},
 	/* export flag */
 	{0,SSL_TXT_EXP,0,     0,0,0,0,0,SSL_EXPORT,0,0,0},
 	{0,SSL_TXT_EXPORT,0,  0,0,0,0,0,SSL_EXPORT,0,0,0},
 	/* strength classes */
 	{0,SSL_TXT_EXP40,0,   0,0,0,0,0,SSL_EXP40, 0,0,0},
 	{0,SSL_TXT_EXP56,0,   0,0,0,0,0,SSL_EXP56, 0,0,0},
 	{0,SSL_TXT_LOW,0,     0,0,0,0,0,SSL_LOW,   0,0,0},
 	{0,SSL_TXT_MEDIUM,0,  0,0,0,0,0,SSL_MEDIUM,0,0,0},
 	{0,SSL_TXT_HIGH,0,    0,0,0,0,0,SSL_HIGH,  0,0,0},
 	/* FIPS 140-2 approved ciphersuite */
 	{0,SSL_TXT_FIPS,0,    0,0,~SSL_eNULL,0,0,SSL_FIPS,  0,0,0},
 @@ -1140,29 +1141,29 @@ static int ssl_cipher_process_rulestr(co
 		alg_mac = 0;
 		alg_ssl = 0;
 		algo_strength = 0;
 		for (;;)
+			{
 			ch = *l;
 			buf = l;
 			buflen = 0;
 #ifndef CHARSET_EBCDIC
 			while (	((ch >= 'A') && (ch <= 'Z')) ||
 				((ch >= '0') && (ch <= '9')) ||
 				((ch >= 'a') && (ch <= 'z')) ||
-				 (ch == '-'))
+				 (ch == '-') || (ch == '.'))
 #else
-			while (	isalnum(ch) || (ch == '-'))
+			while (	isalnum(ch) || (ch == '-') || (ch == '.'))
 #endif
+				 {
 				 ch = *(++l);
 				 buflen++;
+				 }
 			if (buflen == 0)
+				{
 				/*
 				 * We hit something we cannot deal with,
 				 * it is no command or separator nor
 				 * alphanumeric, so we call this an error.
 				 */

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/ssl_locl.h 2012/07/26 19:58:39	1.5
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/ssl_locl.h 2013/02/05 21:31:27	1.6

 @@ -205,26 +205,35 @@
 #define l2n(l,c)	(*((c)++)=(unsigned char)(((l)>>24)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
 			 *((c)++)=(unsigned char)(((l)    )&0xff))
 #define l2n6(l,c)	(*((c)++)=(unsigned char)(((l)>>40)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>32)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>24)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
 			 *((c)++)=(unsigned char)(((l)    )&0xff))
 #define l2n8(l,c)	(*((c)++)=(unsigned char)(((l)>>56)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>48)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>40)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>32)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>24)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
 			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
 			 *((c)++)=(unsigned char)(((l)    )&0xff))
 #define n2l6(c,l)	(l =((BN_ULLONG)(*((c)++)))<<40, \
 			 l|=((BN_ULLONG)(*((c)++)))<<32, \
 			 l|=((BN_ULLONG)(*((c)++)))<<24, \
 			 l|=((BN_ULLONG)(*((c)++)))<<16, \
 			 l|=((BN_ULLONG)(*((c)++)))<< 8, \
 			 l|=((BN_ULLONG)(*((c)++))))
 /* NOTE - c is not incremented as per l2c */
 #define l2cn(l1,l2,c,n)	{ \
 			c+=n; \
 			switch (n) { \
 			case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
 			case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
 @@ -820,27 +829,28 @@ int ssl_cipher_list_to_bytes(SSL *s,STAC
                              int (*put_cb)(const SSL_CIPHER *, unsigned char *));
 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *meth,
 					     STACK_OF(SSL_CIPHER) **pref,
 					     STACK_OF(SSL_CIPHER) **sorted,
 					     const char *rule_str);
 void ssl_update_cache(SSL *s, int mode);
 int ssl_cipher_get_evp(const SSL_SESSION *s,const EVP_CIPHER **enc,
 		       const EVP_MD **md,int *mac_pkey_type,int *mac_secret_size, SSL_COMP **comp);
 int ssl_get_handshake_digest(int i,long *mask,const EVP_MD **md);
 int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk);
 int ssl_undefined_function(SSL *s);
 int ssl_undefined_void_function(void);
 int ssl_undefined_const_function(const SSL *s);
-X509 *ssl_get_server_send_cert(SSL *);
+CERT_PKEY *ssl_get_server_send_pkey(const SSL *s);
 X509 *ssl_get_server_send_cert(const SSL *);
 EVP_PKEY *ssl_get_sign_pkey(SSL *s,const SSL_CIPHER *c, const EVP_MD **pmd);
 int ssl_cert_type(X509 *x,EVP_PKEY *pkey);
 void ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher);
 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s);
 int ssl_verify_alarm_type(long type);
 void ssl_load_ciphers(void);
 int ssl2_enc_init(SSL *s, int client);
 int ssl2_generate_key_material(SSL *s);
 void ssl2_enc(SSL *s,int send_data);
 void ssl2_mac(SSL *s,unsigned char *mac,int send_data);
 const SSL_CIPHER *ssl2_get_cipher_by_char(const unsigned char *p);
 int ssl2_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
 @@ -1078,27 +1088,28 @@ SSL_COMP *ssl3_comp_find(STACK_OF(SSL_CO
 #ifndef OPENSSL_NO_EC
 int tls1_ec_curve_id2nid(int curve_id);
 int tls1_ec_nid2curve_id(int nid);
 #endif /* OPENSSL_NO_EC */
 #ifndef OPENSSL_NO_TLSEXT
 unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *p, unsigned char *limit);
 unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *p, unsigned char *limit);
 int ssl_parse_clienthello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al);
 int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **data, unsigned char *d, int n, int *al);
 int ssl_prepare_clienthello_tlsext(SSL *s);
 int ssl_prepare_serverhello_tlsext(SSL *s);
-int ssl_check_clienthello_tlsext(SSL *s);
+int ssl_check_clienthello_tlsext_early(SSL *s);
 int ssl_check_clienthello_tlsext_late(SSL *s);
 int ssl_check_serverhello_tlsext(SSL *s);
 #ifndef OPENSSL_NO_HEARTBEATS
 int tls1_heartbeat(SSL *s);
 int dtls1_heartbeat(SSL *s);
 int tls1_process_heartbeat(SSL *s);
 int dtls1_process_heartbeat(SSL *s);
 #endif
 #ifdef OPENSSL_NO_SHA256
 #define tlsext_tick_md	EVP_sha1
 #else
 #define tlsext_tick_md	EVP_sha256
 @@ -1121,14 +1132,43 @@ int ssl_parse_serverhello_renegotiate_ex
 int ssl_add_clienthello_renegotiate_ext(SSL *s, unsigned char *p, int *len,
 					int maxlen);
 int ssl_parse_clienthello_renegotiate_ext(SSL *s, unsigned char *d, int len,
 					  int *al);
 long ssl_get_algorithm2(SSL *s);
 int tls1_process_sigalgs(SSL *s, const unsigned char *data, int dsize);
 int tls12_get_req_sig_algs(SSL *s, unsigned char *p);
 int ssl_add_clienthello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen);
 int ssl_parse_clienthello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al);
 int ssl_add_serverhello_use_srtp_ext(SSL *s, unsigned char *p, int *len, int maxlen);
 int ssl_parse_serverhello_use_srtp_ext(SSL *s, unsigned char *d, int len,int *al);
 /* s3_cbc.c */
 void ssl3_cbc_copy_mac(unsigned char* out,
 		       const SSL3_RECORD *rec,
 		       unsigned md_size,unsigned orig_len);
 int ssl3_cbc_remove_padding(const SSL* s,
 			    SSL3_RECORD *rec,
 			    unsigned block_size,
 			    unsigned mac_size);
 int tls1_cbc_remove_padding(const SSL* s,
 			    SSL3_RECORD *rec,
 			    unsigned block_size,
 			    unsigned mac_size);
 char ssl3_cbc_record_digest_supported(const EVP_MD_CTX *ctx);
 void ssl3_cbc_digest_record(
 	const EVP_MD_CTX *ctx,
 	unsigned char* md_out,
 	size_t* md_out_size,
 	const unsigned char header[13],
 	const unsigned char *data,
 	size_t data_plus_mac_size,
 	size_t data_plus_mac_plus_padding_size,
 	const unsigned char *mac_secret,
 	unsigned mac_secret_length,
 	char is_sslv3);
 void tls_fips_digest_extra(
 	const EVP_CIPHER_CTX *cipher_ctx, EVP_MD_CTX *mac_ctx,
 	const unsigned char *data, size_t data_len, size_t orig_len);
 #endif

--- src/crypto/external/bsd/openssl/dist/ssl/t1_enc.c 2012/07/26 19:58:39	1.5
+++ src/crypto/external/bsd/openssl/dist/ssl/t1_enc.c 2013/02/05 21:31:27	1.6

 @@ -351,27 +351,27 @@ int tls1_change_cipher_state(SSL *s, int
 #ifdef KSSL_DEBUG
 	printf("tls1_change_cipher_state(which= %d) w/\n", which);
 	printf("\talg= %ld/%ld, comp= %p\n",
 	       s->s3->tmp.new_cipher->algorithm_mkey,
 	       s->s3->tmp.new_cipher->algorithm_auth,
 	       comp);
 	printf("\tevp_cipher == %p ==? &d_cbc_ede_cipher3\n", c);
 	printf("\tevp_cipher: nid, blksz= %d, %d, keylen=%d, ivlen=%d\n",
                 c->nid,c->block_size,c->key_len,c->iv_len);
 	printf("\tkey_block: len= %d, data= ", s->s3->tmp.key_block_length);
+	{
         int i;
         for (i=0; i<s->s3->tmp.key_block_length; i++)
-		printf("%02x", key_block[i]);  printf("\n");
+		printf("%02x", s->s3->tmp.key_block[i]);  printf("\n");
+        }
 #endif	/* KSSL_DEBUG */
 	if (which & SSL3_CC_READ)
+		{
 		if (s->s3->tmp.new_cipher->algorithm2 & TLS1_STREAM_MAC)
 			s->mac_flags |= SSL_MAC_FLAG_READ_MAC_STREAM;
 		else
 			s->mac_flags &= ~SSL_MAC_FLAG_READ_MAC_STREAM;
 		if (s->enc_read_ctx != NULL)
 			reuse_dd = 1;
 		else if ((s->enc_read_ctx=OPENSSL_malloc(sizeof(EVP_CIPHER_CTX))) == NULL)
 @@ -657,32 +657,41 @@ printf("\nkey block\n");
+			}
+		}
 	ret = 1;
 err:
 	if (p2)
+		{
 		OPENSSL_cleanse(p2,num);
 		OPENSSL_free(p2);
+		}
 	return(ret);
+	}
 /* tls1_enc encrypts/decrypts the record in |s->wrec| / |s->rrec|, respectively.
+ *
  * Returns:
  *   0: (in non-constant time) if the record is publically invalid (i.e. too
  *       short etc).
  *   1: if the record's padding is valid / the encryption was successful.
  *   -1: if the record's padding/AEAD-authenticator is invalid or, if sending,
  *       an internal error occured.
  */
 int tls1_enc(SSL *s, int send)
+	{
 	SSL3_RECORD *rec;
 	EVP_CIPHER_CTX *ds;
 	unsigned long l;
-	int bs,i,ii,j,k,pad=0;
+	int bs,i,j,k,pad=0,ret,mac_size=0;
 	const EVP_CIPHER *enc;
 	if (send)
+		{
 		if (EVP_MD_CTX_md(s->write_hash))
+			{
 			int n=EVP_MD_CTX_size(s->write_hash);
 			OPENSSL_assert(n >= 0);
+			}
 		ds=s->enc_write_ctx;
 		rec= &(s->s3->wrec);
 		if (s->enc_write_ctx == NULL)
 			enc=NULL;
 @@ -719,31 +728,31 @@ int tls1_enc(SSL *s, int send)
+			}
 		ds=s->enc_read_ctx;
 		rec= &(s->s3->rrec);
 		if (s->enc_read_ctx == NULL)
 			enc=NULL;
 		else
 			enc=EVP_CIPHER_CTX_cipher(s->enc_read_ctx);
+		}
 #ifdef KSSL_DEBUG
 	printf("tls1_enc(%d)\n", send);
 #endif    /* KSSL_DEBUG */
-	if ((s->session == NULL) || (ds == NULL) ||
+	if ((s->session == NULL) || (ds == NULL) || (enc == NULL))
 		(enc == NULL))
+		{
 		memmove(rec->data,rec->input,rec->length);
 		rec->input=rec->data;
 		ret = 1;
+		}
 	else
+		{
 		l=rec->length;
 		bs=EVP_CIPHER_block_size(ds->cipher);
 		if (EVP_CIPHER_flags(ds->cipher)&EVP_CIPH_FLAG_AEAD_CIPHER)
+			{
 			unsigned char buf[13],*seq;
 			seq = send?s->s3->write_sequence:s->s3->read_sequence;
 			if (s->version == DTLS1_VERSION || s->version == DTLS1_BAD_VER)
 @@ -787,130 +796,80 @@ int tls1_enc(SSL *s, int send)
 			if (s->options & SSL_OP_TLS_BLOCK_PADDING_BUG)
+				{
 				if (s->s3->flags & TLS1_FLAGS_TLS_PADDING_BUG)
 					j++;
+				}
 			for (k=(int)l; k<(int)(l+i); k++)
 				rec->input[k]=j;
 			l+=i;
 			rec->length+=i;
+			}
 #ifdef KSSL_DEBUG
+		{
-                unsigned long ui;
+		unsigned long ui;
 		printf("EVP_Cipher(ds=%p,rec->data=%p,rec->input=%p,l=%ld) ==>\n",
-                        ds,rec->data,rec->input,l);
+			ds,rec->data,rec->input,l);
 		printf("\tEVP_CIPHER_CTX: %d buf_len, %d key_len [%d %d], %d iv_len\n",
-                        ds->buf_len, ds->cipher->key_len,
+			ds->buf_len, ds->cipher->key_len,
-                        DES_KEY_SZ, DES_SCHEDULE_SZ,
+			DES_KEY_SZ, DES_SCHEDULE_SZ,
-                        ds->cipher->iv_len);
+			ds->cipher->iv_len);
 		printf("\t\tIV: ");
 		for (i=0; i<ds->cipher->iv_len; i++) printf("%02X", ds->iv[i]);
 		printf("\n");
 		printf("\trec->input=");
 		for (ui=0; ui<l; ui++) printf(" %02x", rec->input[ui]);
 		printf("\n");
+		}
 #endif	/* KSSL_DEBUG */
 		if (!send)
+			{
 			if (l == 0 || l%bs != 0)
 				if (s->version >= TLS1_1_VERSION)
 					return -1;
 				SSLerr(SSL_F_TLS1_ENC,SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
 				ssl3_send_alert(s,SSL3_AL_FATAL,SSL_AD_DECRYPTION_FAILED);
 				return 0;
+			}
 		i = EVP_Cipher(ds,rec->data,rec->input,l);
 		if ((EVP_CIPHER_flags(ds->cipher)&EVP_CIPH_FLAG_CUSTOM_CIPHER)
 						?(i<0)
 						:(i==0))
 			return -1;	/* AEAD can fail to verify MAC */
 		if (EVP_CIPHER_mode(enc) == EVP_CIPH_GCM_MODE && !send)
+			{
 			rec->data += EVP_GCM_TLS_EXPLICIT_IV_LEN;
 			rec->input += EVP_GCM_TLS_EXPLICIT_IV_LEN;
 			rec->length -= EVP_GCM_TLS_EXPLICIT_IV_LEN;
+			}
 #ifdef KSSL_DEBUG
+		{
-                unsigned long i;
+		unsigned long i;
-                printf("\trec->data=");
+		printf("\trec->data=");
 		for (i=0; i<l; i++)
-                        printf(" %02x", rec->data[i]);  printf("\n");
+			printf(" %02x", rec->data[i]);  printf("\n");
+		}
 #endif	/* KSSL_DEBUG */
 		ret = 1;
 		if (EVP_MD_CTX_md(s->read_hash) != NULL)
 			mac_size = EVP_MD_CTX_size(s->read_hash);
 		if ((bs != 1) && !send)
 			ret = tls1_cbc_remove_padding(s, rec, bs, mac_size);
 			ii=i=rec->data[l-1]; /* padding_length */
 			i++;
 			/* NB: if compression is in operation the first packet
 			 * may not be of even length so the padding bug check
 			 * cannot be performed. This bug workaround has been
 			 * around since SSLeay so hopefully it is either fixed
 			 * now or no buggy implementation supports compression
 			 * [steve]
 			 */
 			if ( (s->options&SSL_OP_TLS_BLOCK_PADDING_BUG)
 				&& !s->expand)
 				/* First packet is even in size, so check */
 				if ((memcmp(s->s3->read_sequence,
 					"\0\0\0\0\0\0\0\0",8) == 0) && !(ii & 1))
 					s->s3->flags|=TLS1_FLAGS_TLS_PADDING_BUG;
 				if (s->s3->flags & TLS1_FLAGS_TLS_PADDING_BUG)
 					i--;
 			/* TLS 1.0 does not bound the number of padding bytes by the block size.
 			 * All of them must have value 'padding_length'. */
 			if (i > (int)rec->length)
 				/* Incorrect padding. SSLerr() and ssl3_alert are done
 				 * by caller: we don't want to reveal whether this is
 				 * a decryption error or a MAC verification failure
 				 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */
 				return -1;
 			for (j=(int)(l-i); j<(int)l; j++)
 				if (rec->data[j] != ii)
 					/* Incorrect padding */
 					return -1;
 			rec->length -=i;
 			if (s->version >= TLS1_1_VERSION
 				&& EVP_CIPHER_CTX_mode(ds) == EVP_CIPH_CBC_MODE)
 				if (bs > (int)rec->length)
 					return -1;
 				rec->data += bs;    /* skip the explicit IV */
 				rec->input += bs;
 				rec->length -= bs;
 		if (pad && !send)
 			rec->length -= pad;
+		}
-	return(1);
+	return ret;
+	}
 int tls1_cert_verify_mac(SSL *s, int md_nid, unsigned char *out)
+	{
 	unsigned int ret;
 	EVP_MD_CTX ctx, *d=NULL;
 	int i;
 	if (s->s3->handshake_buffer)
 		if (!ssl3_digest_cached_records(s))
 			return 0;
 	if (s->s3->handshake_dgst) {
 		for (i=0;i<SSL_MAX_DIGEST;i++)
+			{
 @@ -982,85 +941,117 @@ int tls1_final_finish_mac(SSL *s,
 	EVP_MD_CTX_cleanup(&ctx);
 	if (err)
 		return 0;
 	else
 		return sizeof buf2;
+	}
 int tls1_mac(SSL *ssl, unsigned char *md, int send)
+	{
 	SSL3_RECORD *rec;
 	unsigned char *seq;
 	EVP_MD_CTX *hash;
-	size_t md_size;
+	size_t md_size, orig_len;
 	int i;
 	EVP_MD_CTX hmac, *mac_ctx;
-	unsigned char buf[5];
+	unsigned char header[13];
 	int stream_mac = (send?(ssl->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM):(ssl->mac_flags&SSL_MAC_FLAG_READ_MAC_STREAM));
 	int t;
 	if (send)
+		{
 		rec= &(ssl->s3->wrec);
 		seq= &(ssl->s3->write_sequence[0]);
 		hash=ssl->write_hash;
+		}
 	else
+		{
 		rec= &(ssl->s3->rrec);
 		seq= &(ssl->s3->read_sequence[0]);
 		hash=ssl->read_hash;
+		}
 	t=EVP_MD_CTX_size(hash);
 	OPENSSL_assert(t >= 0);
 	md_size=t;
 	buf[0]=rec->type;
 	buf[1]=(unsigned char)(ssl->version>>8);
 	buf[2]=(unsigned char)(ssl->version);
 	buf[3]=rec->length>>8;
 	buf[4]=rec->length&0xff;
 	/* I should fix this up TLS TLS TLS TLS TLS XXXXXXXX */
 	if (stream_mac)
+		{
 			mac_ctx = hash;
+		}
 		else
+		{
 			EVP_MD_CTX_copy(&hmac,hash);
 			mac_ctx = &hmac;
+		}
 	if (ssl->version == DTLS1_VERSION || ssl->version == DTLS1_BAD_VER)
+		{
 		unsigned char dtlsseq[8],*p=dtlsseq;
 		s2n(send?ssl->d1->w_epoch:ssl->d1->r_epoch, p);
 		memcpy (p,&seq[2],6);
-		EVP_DigestSignUpdate(mac_ctx,dtlsseq,8);
+		memcpy(header, dtlsseq, 8);
+		}
 	else
-		EVP_DigestSignUpdate(mac_ctx,seq,8);
+		memcpy(header, seq, 8);
-	EVP_DigestSignUpdate(mac_ctx,buf,5);
+	/* kludge: tls1_cbc_remove_padding passes padding length in rec->type */
-	EVP_DigestSignUpdate(mac_ctx,rec->input,rec->length);
+	orig_len = rec->length+md_size+((unsigned int)rec->type>>8);
-	t=EVP_DigestSignFinal(mac_ctx,md,&md_size);
+	rec->type &= 0xff;
 	OPENSSL_assert(t > 0);
 	header[8]=rec->type;
 	header[9]=(unsigned char)(ssl->version>>8);
 	header[10]=(unsigned char)(ssl->version);
 	header[11]=(rec->length)>>8;
 	header[12]=(rec->length)&0xff;
 	if (!send &&
 	    EVP_CIPHER_CTX_mode(ssl->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
 	    ssl3_cbc_record_digest_supported(mac_ctx))
+		{
 		/* This is a CBC-encrypted record. We must avoid leaking any
 		 * timing-side channel information about how many blocks of
 		 * data we are hashing because that gives an attacker a
 		 * timing-oracle. */
 		ssl3_cbc_digest_record(
 			mac_ctx,
 			md, &md_size,
 			header, rec->input,
 			rec->length + md_size, orig_len,
 			ssl->s3->read_mac_secret,
 			ssl->s3->read_mac_secret_size,
 /* not SSLv3 */);
+		}
 	else
+		{
 		EVP_DigestSignUpdate(mac_ctx,header,sizeof(header));
 		EVP_DigestSignUpdate(mac_ctx,rec->input,rec->length);
 		t=EVP_DigestSignFinal(mac_ctx,md,&md_size);
 		OPENSSL_assert(t > 0);
 #ifdef OPENSSL_FIPS
 		if (!send && FIPS_mode())
 			tls_fips_digest_extra(
 	    				ssl->enc_read_ctx,
 					mac_ctx, rec->input,
 					rec->length, orig_len);
 #endif
+		}
-	if (!stream_mac) EVP_MD_CTX_cleanup(&hmac);
+	if (!stream_mac)
 		EVP_MD_CTX_cleanup(&hmac);
 #ifdef TLS_DEBUG
 printf("sec=");
 {unsigned int z; for (z=0; z<md_size; z++) printf("%02X ",mac_sec[z]); printf("\n"); }
 printf("seq=");
 {int z; for (z=0; z<8; z++) printf("%02X ",seq[z]); printf("\n"); }
 printf("buf=");
 {int z; for (z=0; z<5; z++) printf("%02X ",buf[z]); printf("\n"); }
 printf("rec=");
 {unsigned int z; for (z=0; z<rec->length; z++) printf("%02X ",buf[z]); printf("\n"); }
 #endif
 	if (ssl->version != DTLS1_VERSION && ssl->version != DTLS1_BAD_VER)
+		{

--- src/crypto/external/bsd/openssl/dist/ssl/s3_lib.c 2012/07/26 19:58:39	1.8
+++ src/crypto/external/bsd/openssl/dist/ssl/s3_lib.c 2013/02/05 21:31:26	1.9

 @@ -1115,27 +1115,27 @@ OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]
 	SSL_SHA256,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_DEFAULT|TLS1_PRF,
 ,
 ,
 	},
 	/* Cipher 3E */
+	{
 , /* not implemented (non-ephemeral DH) */
 	TLS1_TXT_DH_DSS_WITH_AES_128_SHA256,
 	TLS1_CK_DH_DSS_WITH_AES_128_SHA256,
-	SSL_kDHr,
+	SSL_kDHd,
 	SSL_aDH,
 	SSL_AES128,
 	SSL_SHA256,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_DEFAULT|TLS1_PRF,
 ,
 ,
 	},
 	/* Cipher 3F */
+	{
 , /* not implemented (non-ephemeral DH) */
 @@ -1397,27 +1397,27 @@ OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]
 	SSL_SHA256,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_DEFAULT|TLS1_PRF,
 ,
 ,
 	},
 	/* Cipher 68 */
+	{
 , /* not implemented (non-ephemeral DH) */
 	TLS1_TXT_DH_DSS_WITH_AES_256_SHA256,
 	TLS1_CK_DH_DSS_WITH_AES_256_SHA256,
-	SSL_kDHr,
+	SSL_kDHd,
 	SSL_aDH,
 	SSL_AES256,
 	SSL_SHA256,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_DEFAULT|TLS1_PRF,
 ,
 ,
 	},
 	/* Cipher 69 */
+	{
 , /* not implemented (non-ephemeral DH) */
 @@ -1948,43 +1948,43 @@ OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]
 	SSL_AEAD,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA384|TLS1_PRF_SHA384,
 ,
 ,
 	},
 	/* Cipher A4 */
+	{
 ,
 	TLS1_TXT_DH_DSS_WITH_AES_128_GCM_SHA256,
 	TLS1_CK_DH_DSS_WITH_AES_128_GCM_SHA256,
-	SSL_kDHr,
+	SSL_kDHd,
 	SSL_aDH,
 	SSL_AES128GCM,
 	SSL_AEAD,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA256|TLS1_PRF_SHA256,
 ,
 ,
 	},
 	/* Cipher A5 */
+	{
 ,
 	TLS1_TXT_DH_DSS_WITH_AES_256_GCM_SHA384,
 	TLS1_CK_DH_DSS_WITH_AES_256_GCM_SHA384,
-	SSL_kDHr,
+	SSL_kDHd,
 	SSL_aDH,
 	SSL_AES256GCM,
 	SSL_AEAD,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA384|TLS1_PRF_SHA384,
 ,
 ,
 	},
 	/* Cipher A6 */
+	{
 ,
 @@ -2659,43 +2659,43 @@ OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]
 	SSL_SHA384,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA384|TLS1_PRF_SHA384,
 ,
 ,
 	},
 	/* Cipher C029 */
+	{
 ,
 	TLS1_TXT_ECDH_RSA_WITH_AES_128_SHA256,
 	TLS1_CK_ECDH_RSA_WITH_AES_128_SHA256,
-	SSL_kECDHe,
+	SSL_kECDHr,
 	SSL_aECDH,
 	SSL_AES128,
 	SSL_SHA256,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA256|TLS1_PRF_SHA256,
 ,
 ,
 	},
 	/* Cipher C02A */
+	{
 ,
 	TLS1_TXT_ECDH_RSA_WITH_AES_256_SHA384,
 	TLS1_CK_ECDH_RSA_WITH_AES_256_SHA384,
-	SSL_kECDHe,
+	SSL_kECDHr,
 	SSL_aECDH,
 	SSL_AES256,
 	SSL_SHA384,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA384|TLS1_PRF_SHA384,
 ,
 ,
 	},
 	/* GCM based TLS v1.2 ciphersuites from RFC5289 */
 	/* Cipher C02B */
 @@ -2789,43 +2789,43 @@ OPENSSL_GLOBAL SSL_CIPHER ssl3_ciphers[]
 	SSL_AEAD,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA384|TLS1_PRF_SHA384,
 ,
 ,
 	},
 	/* Cipher C031 */
+	{
 ,
 	TLS1_TXT_ECDH_RSA_WITH_AES_128_GCM_SHA256,
 	TLS1_CK_ECDH_RSA_WITH_AES_128_GCM_SHA256,
-	SSL_kECDHe,
+	SSL_kECDHr,
 	SSL_aECDH,
 	SSL_AES128GCM,
 	SSL_AEAD,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA256|TLS1_PRF_SHA256,
 ,
 ,
 	},
 	/* Cipher C032 */
+	{
 ,
 	TLS1_TXT_ECDH_RSA_WITH_AES_256_GCM_SHA384,
 	TLS1_CK_ECDH_RSA_WITH_AES_256_GCM_SHA384,
-	SSL_kECDHe,
+	SSL_kECDHr,
 	SSL_aECDH,
 	SSL_AES256GCM,
 	SSL_AEAD,
 	SSL_TLSV1_2,
 	SSL_NOT_EXP|SSL_HIGH|SSL_FIPS,
 	SSL_HANDSHAKE_MAC_SHA384|TLS1_PRF_SHA384,
 ,
 ,
 	},
 #endif /* OPENSSL_NO_ECDH */

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/s3_pkt.c 2012/07/26 19:58:39	1.10
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/s3_pkt.c 2013/02/05 21:31:26	1.11

 @@ -280,31 +280,28 @@ int ssl3_read_n(SSL *s, int n, int max,
  * ssl->s3->rrec.data, 	 - data
  * ssl->s3->rrec.length, - number of bytes
  */
 /* used only by ssl3_read_bytes */
 static int ssl3_get_record(SSL *s)
+	{
 	int ssl_major,ssl_minor,al;
 	int enc_err,n,i,ret= -1;
 	SSL3_RECORD *rr;
 	SSL_SESSION *sess;
 	unsigned char *p;
 	unsigned char md[EVP_MAX_MD_SIZE];
 	short version;
-	int mac_size;
+	unsigned mac_size, orig_len;
 	int clear=0;
 	size_t extra;
 	int decryption_failed_or_bad_record_mac = 0;
 	unsigned char *mac = NULL;
 	rr= &(s->s3->rrec);
 	sess=s->session;
 	if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
 		extra=SSL3_RT_MAX_EXTRA;
 	else
 		extra=0;
 	if (extra && !s->s3->init_extra)
+		{
 		/* An application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER
 		 * set after ssl3_setup_buffers() was done */
 		SSLerr(SSL_F_SSL3_GET_RECORD, ERR_R_INTERNAL_ERROR);
 @@ -391,95 +388,100 @@ fprintf(stderr, "Record type=%d, Length=
 	/* We now have - encrypted [ MAC [ compressed [ plain ] ] ]
 	 * rr->length bytes of encrypted compressed stuff. */
 	/* check is not needed I believe */
 	if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
+		{
 		al=SSL_AD_RECORD_OVERFLOW;
 		SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
 		goto f_err;
+		}
 	/* decrypt in place in 'rr->input' */
 	rr->data=rr->input;
 	orig_len=rr->length;
 	enc_err = s->method->ssl3_enc->enc(s,0);
-	if (enc_err <= 0)
+	/* enc_err is:
 	 *    0: (in non-constant time) if the record is publically invalid.
 	 *    1: if the padding is valid
 	 *    -1: if the padding is invalid */
 	if (enc_err == 0)
+		{
-		if (enc_err == 0)
+		al=SSL_AD_DECRYPTION_FAILED;
-			/* SSLerr() and ssl3_send_alert() have been called */
+		SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BLOCK_CIPHER_PAD_IS_WRONG);
-			goto err;
+		goto f_err;
 		/* Otherwise enc_err == -1, which indicates bad padding
 		 * (rec->length has not been changed in this case).
 		 * To minimize information leaked via timing, we will perform
 		 * the MAC computation anyway. */
 		decryption_failed_or_bad_record_mac = 1;
+		}
 #ifdef TLS_DEBUG
 printf("dec %d\n",rr->length);
 { unsigned int z; for (z=0; z<rr->length; z++) printf("%02X%c",rr->data[z],((z+1)%16)?' ':'\n'); }
 printf("\n");
 #endif
 	/* r->length is now the compressed data plus mac */
-	if (	(sess == NULL) ||
+	if ((sess != NULL) &&
-		(s->enc_read_ctx == NULL) ||
+	    (s->enc_read_ctx != NULL) &&
-		(EVP_MD_CTX_md(s->read_hash) == NULL))
+	    (EVP_MD_CTX_md(s->read_hash) != NULL))
 		clear=1;
 		/* s->read_hash != NULL => mac_size != -1 */
-	if (!clear)
+		unsigned char *mac = NULL;
 		unsigned char mac_tmp[EVP_MAX_MD_SIZE];
 		/* !clear => s->read_hash != NULL => mac_size != -1 */
 		mac_size=EVP_MD_CTX_size(s->read_hash);
-		OPENSSL_assert(mac_size >= 0);
+		OPENSSL_assert(mac_size <= EVP_MAX_MD_SIZE);
-		if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra+mac_size)
+		/* orig_len is the length of the record before any padding was
 		 * removed. This is public information, as is the MAC in use,
 		 * therefore we can safely process the record in a different
 		 * amount of time if it's too short to possibly contain a MAC.
 		 */
 		if (orig_len < mac_size ||
 		    /* CBC records must have a padding length byte too. */
 		    (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE &&
 		     orig_len < mac_size+1))
+			{
-#if 0 /* OK only for stream ciphers (then rr->length is visible from ciphertext anyway) */
+			al=SSL_AD_DECODE_ERROR;
-			al=SSL_AD_RECORD_OVERFLOW;
+			SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
 			SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PRE_MAC_LENGTH_TOO_LONG);
 			goto f_err;
 #else
 			decryption_failed_or_bad_record_mac = 1;
 #endif
+			}
 		/* check the MAC for rr->input (it's in mac_size bytes at the tail) */
-		if (rr->length >= (unsigned int)mac_size)
+		if (EVP_CIPHER_CTX_mode(s->enc_read_ctx) == EVP_CIPH_CBC_MODE)
+			{
 			/* We update the length so that the TLS header bytes
 			 * can be constructed correctly but we need to extract
 			 * the MAC in constant time from within the record,
 			 * without leaking the contents of the padding bytes.
 			 * */
 			mac = mac_tmp;
 			ssl3_cbc_copy_mac(mac_tmp, rr, mac_size, orig_len);
 			rr->length -= mac_size;
 			mac = &rr->data[rr->length];
+			}
 		else
+			{
-			/* record (minus padding) is too short to contain a MAC */
+			/* In this case there's no padding, so |orig_len|
-#if 0 /* OK only for stream ciphers */
+			 * equals |rec->length| and we checked that there's
-			al=SSL_AD_DECODE_ERROR;
+			 * enough bytes for |mac_size| above. */
-			SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_LENGTH_TOO_SHORT);
+			rr->length -= mac_size;
-			goto f_err;
+			mac = &rr->data[rr->length];
 #else
 			decryption_failed_or_bad_record_mac = 1;
 			rr->length = 0;
 #endif
 		i=s->method->ssl3_enc->mac(s,md,0);
 		if (i < 0 || mac == NULL || memcmp(md, mac, (size_t)mac_size) != 0)
 			decryption_failed_or_bad_record_mac = 1;
+			}
 		i=s->method->ssl3_enc->mac(s,md,0 /* not send */);
 		if (i < 0 || mac == NULL || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0)
 			enc_err = -1;
 		if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra+mac_size)
 			enc_err = -1;
+		}
-	if (decryption_failed_or_bad_record_mac)
+	if (enc_err < 0)
+		{
 		/* A separate 'decryption_failed' alert was introduced with TLS 1.0,
 		 * SSL 3.0 only has 'bad_record_mac'.  But unless a decryption
 		 * failure is directly visible from the ciphertext anyway,
 		 * we should not reveal which kind of error occured -- this
 		 * might become visible to an attacker (e.g. via a logfile) */
 		al=SSL_AD_BAD_RECORD_MAC;
 		SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
 		goto f_err;
+		}
 	/* r->length is now just compressed */
 	if (s->expand != NULL)
 @@ -735,26 +737,27 @@ static int do_ssl3_write(SSL *s, int typ
 		wb->offset  = align;
+		}
 	/* write the header */
 	*(p++)=type&0xff;
 	wr->type=type;
 	*(p++)=(s->version>>8);
 	/* Some servers hang if iniatial client hello is larger than 256
 	 * bytes and record version number > TLS 1.0
 	 */
 	if (s->state == SSL3_ST_CW_CLNT_HELLO_B
 				&& !s->renegotiate
 				&& TLS1_get_version(s) > TLS1_VERSION)
 		*(p++) = 0x1;
 	else
 		*(p++)=s->version&0xff;
 	/* field where we are to write out packet length */
 	plen=p;
 	p+=2;
 	/* Explicit IV length, block ciphers and TLS version 1.1 or later */
 	if (s->enc_write_ctx && s->version >= TLS1_1_VERSION)
+		{
 		int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx);
 		if (mode == EVP_CIPH_CBC_MODE)
 @@ -1229,27 +1232,27 @@ start:
 			 * renegotiatie it presumably had a good reason and
 			 * expects it to succeed.
+			 *
 			 * In future we might have a renegotiation where we
 			 * don't care if the peer refused it where we carry on.
 			 */
 			else if (alert_descr == SSL_AD_NO_RENEGOTIATION)
+				{
 				al = SSL_AD_HANDSHAKE_FAILURE;
 				SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_NO_RENEGOTIATION);
 				goto f_err;
+				}
 #ifdef SSL_AD_MISSING_SRP_USERNAME
-			if (alert_descr == SSL_AD_MISSING_SRP_USERNAME)
+			else if (alert_descr == SSL_AD_MISSING_SRP_USERNAME)
 				return(0);
 #endif
+			}
 		else if (alert_level == 2) /* fatal */
+			{
 			char tmp[16];
 			s->rwstate=SSL_NOTHING;
 			s->s3->fatal_alert = alert_descr;
 			SSLerr(SSL_F_SSL3_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);
 			BIO_snprintf(tmp,sizeof tmp,"%d",alert_descr);
 			ERR_add_error_data(2,"SSL alert number ",tmp);
 			s->shutdown|=SSL_RECEIVED_SHUTDOWN;

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/s3_srvr.c 2012/07/26 19:58:39	1.11
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/s3_srvr.c 2013/02/05 21:31:27	1.12

	@@ -181,27 +181,28 @@ static const SSL_METHOD *ssl3_get_server		@@ -181,27 +181,28 @@ static const SSL_METHOD *ssl3_get_server
181		181
182	#ifndef OPENSSL_NO_SRP	182	#ifndef OPENSSL_NO_SRP
183	static int ssl_check_srp_ext_ClientHello(SSL s, int al)	183	static int ssl_check_srp_ext_ClientHello(SSL s, int al)
184	{	184	{
185	int ret = SSL_ERROR_NONE;	185	int ret = SSL_ERROR_NONE;
186		186
187	*al = SSL_AD_UNRECOGNIZED_NAME;	187	*al = SSL_AD_UNRECOGNIZED_NAME;
188		188
189	if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&	189	if ((s->s3->tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
190	(s->srp_ctx.TLS_ext_srp_username_callback != NULL))	190	(s->srp_ctx.TLS_ext_srp_username_callback != NULL))
191	{	191	{
192	if(s->srp_ctx.login == NULL)	192	if(s->srp_ctx.login == NULL)
193	{	193	{
194	/* There isn't any srp login extension !!! */	194	/* RFC 5054 says SHOULD reject,
		195	we do so if There is no srp login name */
195	ret = SSL3_AL_FATAL;	196	ret = SSL3_AL_FATAL;
196	*al = SSL_AD_UNKNOWN_PSK_IDENTITY;	197	*al = SSL_AD_UNKNOWN_PSK_IDENTITY;
197	}	198	}
198	else	199	else
199	{	200	{
200	ret = SSL_srp_server_param_with_username(s,al);	201	ret = SSL_srp_server_param_with_username(s,al);
201	}	202	}
202	}	203	}
203	return ret;	204	return ret;
204	}	205	}
205	#endif	206	#endif
206		207
207	IMPLEMENT_ssl3_meth_func(SSLv3_server_method,	208	IMPLEMENT_ssl3_meth_func(SSLv3_server_method,
	@@ -368,26 +369,27 @@ int ssl3_accept(SSL *s)		@@ -368,26 +369,27 @@ int ssl3_accept(SSL *s)
368	if (ret != SSL_ERROR_NONE)	369	if (ret != SSL_ERROR_NONE)
369	{	370	{
370	ssl3_send_alert(s,SSL3_AL_FATAL,al);	371	ssl3_send_alert(s,SSL3_AL_FATAL,al);
371	/* This is not really an error but the only means to	372	/* This is not really an error but the only means to
372	for a client to detect whether srp is supported. */	373	for a client to detect whether srp is supported. */
373	if (al != TLS1_AD_UNKNOWN_PSK_IDENTITY)	374	if (al != TLS1_AD_UNKNOWN_PSK_IDENTITY)
374	SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_CLIENTHELLO_TLSEXT);	375	SSLerr(SSL_F_SSL3_ACCEPT,SSL_R_CLIENTHELLO_TLSEXT);
375	ret = SSL_TLSEXT_ERR_ALERT_FATAL;	376	ret = SSL_TLSEXT_ERR_ALERT_FATAL;
376	ret= -1;	377	ret= -1;
377	goto end;	378	goto end;
378	}	379	}
379	}	380	}
380	#endif	381	#endif
		382
381	s->renegotiate = 2;	383	s->renegotiate = 2;
382	s->state=SSL3_ST_SW_SRVR_HELLO_A;	384	s->state=SSL3_ST_SW_SRVR_HELLO_A;
383	s->init_num=0;	385	s->init_num=0;
384	break;	386	break;
385		387
386	case SSL3_ST_SW_SRVR_HELLO_A:	388	case SSL3_ST_SW_SRVR_HELLO_A:
387	case SSL3_ST_SW_SRVR_HELLO_B:	389	case SSL3_ST_SW_SRVR_HELLO_B:
388	ret=ssl3_send_server_hello(s);	390	ret=ssl3_send_server_hello(s);
389	if (ret <= 0) goto end;	391	if (ret <= 0) goto end;
390	#ifndef OPENSSL_NO_TLSEXT	392	#ifndef OPENSSL_NO_TLSEXT
391	if (s->hit)	393	if (s->hit)
392	{	394	{
393	if (s->tlsext_ticket_expected)	395	if (s->tlsext_ticket_expected)
	@@ -1181,27 +1183,27 @@ int ssl3_get_client_hello(SSL *s)		@@ -1181,27 +1183,27 @@ int ssl3_get_client_hello(SSL *s)
1181	}	1183	}
1182		1184
1183	#ifndef OPENSSL_NO_TLSEXT	1185	#ifndef OPENSSL_NO_TLSEXT
1184	/* TLS extensions*/	1186	/* TLS extensions*/
1185	if (s->version >= SSL3_VERSION)	1187	if (s->version >= SSL3_VERSION)
1186	{	1188	{
1187	if (!ssl_parse_clienthello_tlsext(s,&p,d,n, &al))	1189	if (!ssl_parse_clienthello_tlsext(s,&p,d,n, &al))
1188	{	1190	{
1189	/* 'al' set by ssl_parse_clienthello_tlsext */	1191	/* 'al' set by ssl_parse_clienthello_tlsext */
1190	SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_PARSE_TLSEXT);	1192	SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_PARSE_TLSEXT);
1191	goto f_err;	1193	goto f_err;
1192	}	1194	}
1193	}	1195	}
1194	if (ssl_check_clienthello_tlsext(s) <= 0) {	1196	if (ssl_check_clienthello_tlsext_early(s) <= 0) {
1195	SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT);	1197	SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO,SSL_R_CLIENTHELLO_TLSEXT);
1196	goto err;	1198	goto err;
1197	}	1199	}
1198		1200
1199	/* Check if we want to use external pre-shared secret for this	1201	/* Check if we want to use external pre-shared secret for this
1200	* handshake for not reused session only. We need to generate	1202	* handshake for not reused session only. We need to generate
1201	* server_random before calling tls_session_secret_cb in order to allow	1203	* server_random before calling tls_session_secret_cb in order to allow
1202	* SessionTicket processing to use it in key derivation. */	1204	* SessionTicket processing to use it in key derivation. */
1203	{	1205	{
1204	unsigned long Time;	1206	unsigned long Time;
1205	unsigned char *pos;	1207	unsigned char *pos;
1206	Time=(unsigned long)time(NULL); /* Time */	1208	Time=(unsigned long)time(NULL); /* Time */
1207	pos=s->s3->server_random;	1209	pos=s->s3->server_random;
	@@ -1403,26 +1405,36 @@ int ssl3_get_client_hello(SSL *s)		@@ -1403,26 +1405,36 @@ int ssl3_get_client_hello(SSL *s)
1403	}	1405	}
1404		1406
1405	/* we now have the following setup.	1407	/* we now have the following setup.
1406	* client_random	1408	* client_random
1407	* cipher_list - our prefered list of ciphers	1409	* cipher_list - our prefered list of ciphers
1408	* ciphers - the clients prefered list of ciphers	1410	* ciphers - the clients prefered list of ciphers
1409	* compression - basically ignored right now	1411	* compression - basically ignored right now
1410	* ssl version is set - sslv3	1412	* ssl version is set - sslv3
1411	* s->session - The ssl session has been setup.	1413	* s->session - The ssl session has been setup.
1412	* s->hit - session reuse flag	1414	* s->hit - session reuse flag
1413	* s->tmp.new_cipher - the new cipher to use.	1415	* s->tmp.new_cipher - the new cipher to use.
1414	*/	1416	*/
1415		1417
		1418	/* Handles TLS extensions that we couldn't check earlier */
		1419	if (s->version >= SSL3_VERSION)
		1420	{
		1421	if (ssl_check_clienthello_tlsext_late(s) <= 0)
		1422	{
		1423	SSLerr(SSL_F_SSL3_GET_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
		1424	goto err;
		1425	}
		1426	}
		1427
1416	if (ret < 0) ret=1;	1428	if (ret < 0) ret=1;
1417	if (0)	1429	if (0)
1418	{	1430	{
1419	f_err:	1431	f_err:
1420	ssl3_send_alert(s,SSL3_AL_FATAL,al);	1432	ssl3_send_alert(s,SSL3_AL_FATAL,al);
1421	}	1433	}
1422	err:	1434	err:
1423	if (ciphers != NULL) sk_SSL_CIPHER_free(ciphers);	1435	if (ciphers != NULL) sk_SSL_CIPHER_free(ciphers);
1424	return(ret);	1436	return(ret);
1425	}	1437	}
1426		1438
1427	int ssl3_send_server_hello(SSL *s)	1439	int ssl3_send_server_hello(SSL *s)
1428	{	1440	{

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/ssl.h 2012/07/26 19:58:39	1.3
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/ssl.h 2013/02/05 21:31:27	1.4

 @@ -483,26 +483,29 @@ struct ssl_session_st
 	 * the appropriate context. It is up to the application to set this,
 	 * via SSL_new */
 	unsigned int sid_ctx_length;
 	unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
 #ifndef OPENSSL_NO_KRB5
         unsigned int krb5_client_princ_len;
         unsigned char krb5_client_princ[SSL_MAX_KRB5_PRINCIPAL_LENGTH];
 #endif /* OPENSSL_NO_KRB5 */
 #ifndef OPENSSL_NO_PSK
 	char *psk_identity_hint;
 	char *psk_identity;
 #endif
 	/* Used to indicate that session resumption is not allowed.
 	 * Applications can also set this bit for a new session via
 	 * not_resumable_session_cb to disable session caching and tickets. */
 	int not_resumable;
 	/* The cert is the certificate used to establish this connection */
 	struct sess_cert_st /* SESS_CERT */ *sess_cert;
 	/* This is the cert for the other end.
 	 * On clients, it will be the same as sess_cert->peer_key->x509
 	 * (the latter is not enough as sess_cert is not retained
 	 * in the external representation of sessions, see ssl_asn1.c). */
 	X509 *peer;
 	/* when app_verify_callback accepts a session where the peer's certificate
 	 * is not ok, we must remember the error for session reuse: */
 	long verify_result; /* only for servers */
 @@ -525,27 +528,27 @@ struct ssl_session_st
 	/* These are used to make removal of session-ids more
 	 * efficient and to implement a maximum cache size. */
 	struct ssl_session_st *prev,*next;
 #ifndef OPENSSL_NO_TLSEXT
 	char *tlsext_hostname;
 #ifndef OPENSSL_NO_EC
 	size_t tlsext_ecpointformatlist_length;
 	unsigned char *tlsext_ecpointformatlist; /* peer's list */
 	size_t tlsext_ellipticcurvelist_length;
 	unsigned char *tlsext_ellipticcurvelist; /* peer's list */
 #endif /* OPENSSL_NO_EC */
 	/* RFC4507 info */
 	unsigned char *tlsext_tick;	/* Session ticket */
-	size_t	tlsext_ticklen;		/* Session ticket length */
+	size_t tlsext_ticklen;		/* Session ticket length */
 	long tlsext_tick_lifetime_hint;	/* Session lifetime hint in seconds */
 #endif
 #ifndef OPENSSL_NO_SRP
 	char *srp_username;
 #endif
 	};
 #endif
 #define SSL_OP_MICROSOFT_SESS_ID_BUG			0x00000001L
 #define SSL_OP_NETSCAPE_CHALLENGE_BUG			0x00000002L
 /* Allow initial connection to servers that don't support RI */
 #define SSL_OP_LEGACY_SERVER_CONNECT			0x00000004L
 @@ -917,51 +920,53 @@ struct ssl_ctx_st
 	unsigned char tlsext_tick_key_name[16];
 	unsigned char tlsext_tick_hmac_key[16];
 	unsigned char tlsext_tick_aes_key[16];
 	/* Callback to support customisation of ticket key setting */
 	int (*tlsext_ticket_key_cb)(SSL *ssl,
 					unsigned char *name, unsigned char *iv,
 					EVP_CIPHER_CTX *ectx,
  					HMAC_CTX *hctx, int enc);
 	/* certificate status request info */
 	/* Callback for status request */
 	int (*tlsext_status_cb)(SSL *ssl, void *arg);
 	void *tlsext_status_arg;
 	/* draft-rescorla-tls-opaque-prf-input-00.txt information */
 	int (*tlsext_opaque_prf_input_callback)(SSL *, void *peerinput, size_t len, void *arg);
 	void *tlsext_opaque_prf_input_callback_arg;
 #endif
 #ifndef OPENSSL_NO_PSK
 	char *psk_identity_hint;
 	unsigned int (*psk_client_callback)(SSL *ssl, const char *hint, char *identity,
 		unsigned int max_identity_len, unsigned char *psk,
 		unsigned int max_psk_len);
 	unsigned int (*psk_server_callback)(SSL *ssl, const char *identity,
 		unsigned char *psk, unsigned int max_psk_len);
 #endif
 #ifndef OPENSSL_NO_BUF_FREELISTS
 #define SSL_MAX_BUF_FREELIST_LEN_DEFAULT 32
 	unsigned int freelist_max_len;
 	struct ssl3_buf_freelist_st *wbuf_freelist;
 	struct ssl3_buf_freelist_st *rbuf_freelist;
 #endif
 #ifndef OPENSSL_NO_SRP
 	SRP_CTX srp_ctx; /* ctx for SRP authentication */
 #endif
 #ifndef OPENSSL_NO_TLSEXT
 # ifndef OPENSSL_NO_NEXTPROTONEG
 	/* Next protocol negotiation information */
 	/* (for experimental NPN extension). */
 	/* For a server, this contains a callback function by which the set of
 	 * advertised protocols can be provided. */
 	int (*next_protos_advertised_cb)(SSL *s, const unsigned char **buf,
 			                 unsigned int *len, void *arg);
 	void *next_protos_advertised_cb_arg;
 	/* For a client, this contains a callback function that selects the
 	 * next protocol from the list provided by the server. */
 	int (*next_proto_select_cb)(SSL *s, unsigned char **out,
 				    unsigned char *outlen,
 @@ -2196,26 +2201,27 @@ void ERR_load_SSL_strings(void);
 #define SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE	 220
 #define SSL_F_SSL_CTX_USE_CERTIFICATE_FILE		 173
 #define SSL_F_SSL_CTX_USE_PRIVATEKEY			 174
 #define SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1		 175
 #define SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE		 176
 #define SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT		 272
 #define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY			 177
 #define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1		 178
 #define SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE		 179
 #define SSL_F_SSL_DO_HANDSHAKE				 180
 #define SSL_F_SSL_GET_NEW_SESSION			 181
 #define SSL_F_SSL_GET_PREV_SESSION			 217
 #define SSL_F_SSL_GET_SERVER_SEND_CERT			 182
 #define SSL_F_SSL_GET_SERVER_SEND_PKEY			 317
 #define SSL_F_SSL_GET_SIGN_PKEY				 183
 #define SSL_F_SSL_INIT_WBIO_BUFFER			 184
 #define SSL_F_SSL_LOAD_CLIENT_CA_FILE			 185
 #define SSL_F_SSL_NEW					 186
 #define SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT	 300
 #define SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT		 302
 #define SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT	 310
 #define SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT	 301
 #define SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT		 303
 #define SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT	 311
 #define SSL_F_SSL_PEEK					 270
 #define SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT		 281
 #define SSL_F_SSL_PREPARE_SERVERHELLO_TLSEXT		 282

--- src/crypto/external/bsd/openssl/dist/ssl/Attic/ssl3.h 2012/07/26 19:58:39	1.3
+++ src/crypto/external/bsd/openssl/dist/ssl/Attic/ssl3.h 2013/02/05 21:31:27	1.4

 @@ -568,28 +568,30 @@ typedef struct ssl3_state_st
 #define SSL3_ST_CR_SRVR_DONE_A		(0x160|SSL_ST_CONNECT)
 #define SSL3_ST_CR_SRVR_DONE_B		(0x161|SSL_ST_CONNECT)
 /* write to server */
 #define SSL3_ST_CW_CERT_A		(0x170|SSL_ST_CONNECT)
 #define SSL3_ST_CW_CERT_B		(0x171|SSL_ST_CONNECT)
 #define SSL3_ST_CW_CERT_C		(0x172|SSL_ST_CONNECT)
 #define SSL3_ST_CW_CERT_D		(0x173|SSL_ST_CONNECT)
 #define SSL3_ST_CW_KEY_EXCH_A		(0x180|SSL_ST_CONNECT)
 #define SSL3_ST_CW_KEY_EXCH_B		(0x181|SSL_ST_CONNECT)
 #define SSL3_ST_CW_CERT_VRFY_A		(0x190|SSL_ST_CONNECT)
 #define SSL3_ST_CW_CERT_VRFY_B		(0x191|SSL_ST_CONNECT)
 #define SSL3_ST_CW_CHANGE_A		(0x1A0|SSL_ST_CONNECT)
 #define SSL3_ST_CW_CHANGE_B		(0x1A1|SSL_ST_CONNECT)
 #ifndef OPENSSL_NO_NEXTPROTONEG
 #define SSL3_ST_CW_NEXT_PROTO_A		(0x200|SSL_ST_CONNECT)
 #define SSL3_ST_CW_NEXT_PROTO_B		(0x201|SSL_ST_CONNECT)
 #endif
 #define SSL3_ST_CW_FINISHED_A		(0x1B0|SSL_ST_CONNECT)
 #define SSL3_ST_CW_FINISHED_B		(0x1B1|SSL_ST_CONNECT)
 /* read from server */
 #define SSL3_ST_CR_CHANGE_A		(0x1C0|SSL_ST_CONNECT)
 #define SSL3_ST_CR_CHANGE_B		(0x1C1|SSL_ST_CONNECT)
 #define SSL3_ST_CR_FINISHED_A		(0x1D0|SSL_ST_CONNECT)
 #define SSL3_ST_CR_FINISHED_B		(0x1D1|SSL_ST_CONNECT)
 #define SSL3_ST_CR_SESSION_TICKET_A	(0x1E0|SSL_ST_CONNECT)
 #define SSL3_ST_CR_SESSION_TICKET_B	(0x1E1|SSL_ST_CONNECT)
 #define SSL3_ST_CR_CERT_STATUS_A	(0x1F0|SSL_ST_CONNECT)
 #define SSL3_ST_CR_CERT_STATUS_B	(0x1F1|SSL_ST_CONNECT)
 /* server */
 @@ -619,53 +621,57 @@ typedef struct ssl3_state_st
 #define SSL3_ST_SW_CERT_REQ_A		(0x160|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_CERT_REQ_B		(0x161|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_SRVR_DONE_A		(0x170|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_SRVR_DONE_B		(0x171|SSL_ST_ACCEPT)
 /* read from client */
 #define SSL3_ST_SR_CERT_A		(0x180|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_CERT_B		(0x181|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_KEY_EXCH_A		(0x190|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_KEY_EXCH_B		(0x191|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_CERT_VRFY_A		(0x1A0|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_CERT_VRFY_B		(0x1A1|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_CHANGE_A		(0x1B0|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_CHANGE_B		(0x1B1|SSL_ST_ACCEPT)
 #ifndef OPENSSL_NO_NEXTPROTONEG
 #define SSL3_ST_SR_NEXT_PROTO_A		(0x210|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_NEXT_PROTO_B		(0x211|SSL_ST_ACCEPT)
 #endif
 #define SSL3_ST_SR_FINISHED_A		(0x1C0|SSL_ST_ACCEPT)
 #define SSL3_ST_SR_FINISHED_B		(0x1C1|SSL_ST_ACCEPT)
 /* write to client */
 #define SSL3_ST_SW_CHANGE_A		(0x1D0|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_CHANGE_B		(0x1D1|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_FINISHED_A		(0x1E0|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_FINISHED_B		(0x1E1|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_SESSION_TICKET_A	(0x1F0|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_SESSION_TICKET_B	(0x1F1|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_CERT_STATUS_A	(0x200|SSL_ST_ACCEPT)
 #define SSL3_ST_SW_CERT_STATUS_B	(0x201|SSL_ST_ACCEPT)
 #define SSL3_MT_HELLO_REQUEST			0
 #define SSL3_MT_CLIENT_HELLO			1
 #define SSL3_MT_SERVER_HELLO			2
 #define	SSL3_MT_NEWSESSION_TICKET		4
 #define SSL3_MT_CERTIFICATE			11
 #define SSL3_MT_SERVER_KEY_EXCHANGE		12
 #define SSL3_MT_CERTIFICATE_REQUEST		13
 #define SSL3_MT_SERVER_DONE			14
 #define SSL3_MT_CERTIFICATE_VERIFY		15
 #define SSL3_MT_CLIENT_KEY_EXCHANGE		16
 #define SSL3_MT_FINISHED			20
 #define SSL3_MT_CERTIFICATE_STATUS		22
 #ifndef OPENSSL_NO_NEXTPROTONEG
 #define SSL3_MT_NEXT_PROTO			67
 #endif
 #define DTLS1_MT_HELLO_VERIFY_REQUEST    3
 #define SSL3_MT_CCS				1
 /* These are used when changing over to a new cipher */
 #define SSL3_CC_READ		0x01
 #define SSL3_CC_WRITE		0x02
 #define SSL3_CC_CLIENT		0x10
 #define SSL3_CC_SERVER		0x20
 #define SSL3_CHANGE_CIPHER_CLIENT_WRITE	(SSL3_CC_CLIENT|SSL3_CC_WRITE)
 #define SSL3_CHANGE_CIPHER_SERVER_READ	(SSL3_CC_SERVER|SSL3_CC_READ)
 #define SSL3_CHANGE_CIPHER_CLIENT_READ	(SSL3_CC_CLIENT|SSL3_CC_READ)

--- src/crypto/external/bsd/openssl/dist/ssl/ssl_err.c 2012/07/26 19:58:39	1.3
+++ src/crypto/external/bsd/openssl/dist/ssl/ssl_err.c 2013/02/05 21:31:27	1.4

 @@ -218,26 +218,27 @@ static ERR_STRING_DATA SSL_str_functs[]=
 {ERR_FUNC(SSL_F_SSL_CTX_USE_CERTIFICATE_CHAIN_FILE),	"SSL_CTX_use_certificate_chain_file"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_CERTIFICATE_FILE),	"SSL_CTX_use_certificate_file"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_PRIVATEKEY),	"SSL_CTX_use_PrivateKey"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_PRIVATEKEY_ASN1),	"SSL_CTX_use_PrivateKey_ASN1"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_PRIVATEKEY_FILE),	"SSL_CTX_use_PrivateKey_file"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT),	"SSL_CTX_use_psk_identity_hint"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY),	"SSL_CTX_use_RSAPrivateKey"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_ASN1),	"SSL_CTX_use_RSAPrivateKey_ASN1"},
 {ERR_FUNC(SSL_F_SSL_CTX_USE_RSAPRIVATEKEY_FILE),	"SSL_CTX_use_RSAPrivateKey_file"},
 {ERR_FUNC(SSL_F_SSL_DO_HANDSHAKE),	"SSL_do_handshake"},
 {ERR_FUNC(SSL_F_SSL_GET_NEW_SESSION),	"SSL_GET_NEW_SESSION"},
 {ERR_FUNC(SSL_F_SSL_GET_PREV_SESSION),	"SSL_GET_PREV_SESSION"},
 {ERR_FUNC(SSL_F_SSL_GET_SERVER_SEND_CERT),	"SSL_GET_SERVER_SEND_CERT"},
 {ERR_FUNC(SSL_F_SSL_GET_SERVER_SEND_PKEY),	"SSL_GET_SERVER_SEND_PKEY"},
 {ERR_FUNC(SSL_F_SSL_GET_SIGN_PKEY),	"SSL_GET_SIGN_PKEY"},
 {ERR_FUNC(SSL_F_SSL_INIT_WBIO_BUFFER),	"SSL_INIT_WBIO_BUFFER"},
 {ERR_FUNC(SSL_F_SSL_LOAD_CLIENT_CA_FILE),	"SSL_load_client_CA_file"},
 {ERR_FUNC(SSL_F_SSL_NEW),	"SSL_new"},
 {ERR_FUNC(SSL_F_SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT),	"SSL_PARSE_CLIENTHELLO_RENEGOTIATE_EXT"},
 {ERR_FUNC(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT),	"SSL_PARSE_CLIENTHELLO_TLSEXT"},
 {ERR_FUNC(SSL_F_SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT),	"SSL_PARSE_CLIENTHELLO_USE_SRTP_EXT"},
 {ERR_FUNC(SSL_F_SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT),	"SSL_PARSE_SERVERHELLO_RENEGOTIATE_EXT"},
 {ERR_FUNC(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT),	"SSL_PARSE_SERVERHELLO_TLSEXT"},
 {ERR_FUNC(SSL_F_SSL_PARSE_SERVERHELLO_USE_SRTP_EXT),	"SSL_PARSE_SERVERHELLO_USE_SRTP_EXT"},
 {ERR_FUNC(SSL_F_SSL_PEEK),	"SSL_peek"},
 {ERR_FUNC(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT),	"SSL_PREPARE_CLIENTHELLO_TLSEXT"},
 {ERR_FUNC(SSL_F_SSL_PREPARE_SERVERHELLO_TLSEXT),	"SSL_PREPARE_SERVERHELLO_TLSEXT"},

--- src/crypto/external/bsd/openssl/dist/ssl/t1_lib.c 2012/07/27 21:22:55	1.7
+++ src/crypto/external/bsd/openssl/dist/ssl/t1_lib.c 2013/02/05 21:31:27	1.8

 @@ -1067,27 +1067,28 @@ int ssl_parse_clienthello_tlsext(SSL *s,
 			sdata = s->session->tlsext_ecpointformatlist;
 			for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++)
 				fprintf(stderr,"%i ",*(sdata++));
 			fprintf(stderr,"\n");
 #endif
+			}
 		else if (type == TLSEXT_TYPE_elliptic_curves &&
 	             s->version != DTLS1_VERSION)
+			{
 			unsigned char *sdata = data;
 			int ellipticcurvelist_length = (*(sdata++) << 8);
 			ellipticcurvelist_length += (*(sdata++));
-			if (ellipticcurvelist_length != size - 2)
+			if (ellipticcurvelist_length != size - 2 ||
 				ellipticcurvelist_length < 1)
+				{
 				*al = TLS1_AD_DECODE_ERROR;
 				return 0;
+				}
 			if (!s->hit)
+				{
 				if(s->session->tlsext_ellipticcurvelist)
+					{
 					*al = TLS1_AD_DECODE_ERROR;
 					return 0;
+					}
 				s->session->tlsext_ellipticcurvelist_length = 0;
 				if ((s->session->tlsext_ellipticcurvelist = OPENSSL_malloc(ellipticcurvelist_length)) == NULL)
 @@ -1423,27 +1424,28 @@ int ssl_parse_serverhello_tlsext(SSL *s,
 				*al = TLS1_AD_UNRECOGNIZED_NAME;
 				return 0;
+				}
 			tlsext_servername = 1;
+			}
 #ifndef OPENSSL_NO_EC
 		else if (type == TLSEXT_TYPE_ec_point_formats &&
 	             s->version != DTLS1_VERSION)
+			{
 			unsigned char *sdata = data;
 			int ecpointformatlist_length = *(sdata++);
-			if (ecpointformatlist_length != size - 1)
+			if (ecpointformatlist_length != size - 1 ||
 				ecpointformatlist_length < 1)
+				{
 				*al = TLS1_AD_DECODE_ERROR;
 				return 0;
+				}
 			s->session->tlsext_ecpointformatlist_length = 0;
 			if (s->session->tlsext_ecpointformatlist != NULL) OPENSSL_free(s->session->tlsext_ecpointformatlist);
 			if ((s->session->tlsext_ecpointformatlist = OPENSSL_malloc(ecpointformatlist_length)) == NULL)
+				{
 				*al = TLS1_AD_INTERNAL_ERROR;
 				return 0;
+				}
 			s->session->tlsext_ecpointformatlist_length = ecpointformatlist_length;
 			memcpy(s->session->tlsext_ecpointformatlist, sdata, ecpointformatlist_length);
 @@ -1753,81 +1755,51 @@ int ssl_prepare_serverhello_tlsext(SSL *
 			SSLerr(SSL_F_SSL_PREPARE_SERVERHELLO_TLSEXT,ERR_R_MALLOC_FAILURE);
 			return -1;
+			}
 		s->tlsext_ecpointformatlist_length = 3;
 		s->tlsext_ecpointformatlist[0] = TLSEXT_ECPOINTFORMAT_uncompressed;
 		s->tlsext_ecpointformatlist[1] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
 		s->tlsext_ecpointformatlist[2] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
+		}
 #endif /* OPENSSL_NO_EC */
 	return 1;
+	}
-int ssl_check_clienthello_tlsext(SSL *s)
+int ssl_check_clienthello_tlsext_early(SSL *s)
+	{
 	int ret=SSL_TLSEXT_ERR_NOACK;
 	int al = SSL_AD_UNRECOGNIZED_NAME;
 #ifndef OPENSSL_NO_EC
 	/* The handling of the ECPointFormats extension is done elsewhere, namely in
 	 * ssl3_choose_cipher in s3_lib.c.
 	 */
 	/* The handling of the EllipticCurves extension is done elsewhere, namely in
 	 * ssl3_choose_cipher in s3_lib.c.
 	 */
 #endif
 	if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
 		ret = s->ctx->tlsext_servername_callback(s, &al, s->ctx->tlsext_servername_arg);
 	else if (s->initial_ctx != NULL && s->initial_ctx->tlsext_servername_callback != 0)
 		ret = s->initial_ctx->tlsext_servername_callback(s, &al, s->initial_ctx->tlsext_servername_arg);
 	/* If status request then ask callback what to do.
  	 * Note: this must be called after servername callbacks in case
  	 * the certificate has changed.
  	 */
 	if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb)
 		int r;
 		r = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
 		switch (r)
 			/* We don't want to send a status request response */
 			case SSL_TLSEXT_ERR_NOACK:
 				s->tlsext_status_expected = 0;
 				break;
 			/* status request response should be sent */
 			case SSL_TLSEXT_ERR_OK:
 				if (s->tlsext_ocsp_resp)
 					s->tlsext_status_expected = 1;
 				else
 					s->tlsext_status_expected = 0;
 				break;
 			/* something bad happened */
 			case SSL_TLSEXT_ERR_ALERT_FATAL:
 				ret = SSL_TLSEXT_ERR_ALERT_FATAL;
 				al = SSL_AD_INTERNAL_ERROR;
 				goto err;
 	else
 		s->tlsext_status_expected = 0;
 #ifdef TLSEXT_TYPE_opaque_prf_input
+ 	{
 		/* This sort of belongs into ssl_prepare_serverhello_tlsext(),
 		 * but we might be sending an alert in response to the client hello,
-		 * so this has to happen here in ssl_check_clienthello_tlsext(). */
+		 * so this has to happen here in
 		 * ssl_check_clienthello_tlsext_early(). */
 		int r = 1;
 		if (s->ctx->tlsext_opaque_prf_input_callback != 0)
+			{
 			r = s->ctx->tlsext_opaque_prf_input_callback(s, NULL, 0, s->ctx->tlsext_opaque_prf_input_callback_arg);
 			if (!r)
+				{
 				ret = SSL_TLSEXT_ERR_ALERT_FATAL;
 				al = SSL_AD_INTERNAL_ERROR;
 				goto err;
+				}
+			}
 @@ -1859,45 +1831,110 @@ int ssl_check_clienthello_tlsext(SSL *s)
+			}
 		if (r == 2 && s->s3->server_opaque_prf_input == NULL)
+			{
 			/* The callback wants to enforce use of the extension,
 			 * but we can't do that with the client opaque PRF input;
 			 * abort the handshake.
 			 */
 			ret = SSL_TLSEXT_ERR_ALERT_FATAL;
 			al = SSL_AD_HANDSHAKE_FAILURE;
+			}
+	}
 #endif
  err:
 #endif
 	switch (ret)
+		{
 		case SSL_TLSEXT_ERR_ALERT_FATAL:
 			ssl3_send_alert(s,SSL3_AL_FATAL,al);
 			return -1;
 		case SSL_TLSEXT_ERR_ALERT_WARNING:
 			ssl3_send_alert(s,SSL3_AL_WARNING,al);
 			return 1;
 		case SSL_TLSEXT_ERR_NOACK:
 			s->servername_done=0;
 			default:
 		return 1;
+		}
+	}
 int ssl_check_clienthello_tlsext_late(SSL *s)
+	{
 	int ret = SSL_TLSEXT_ERR_OK;
 	int al;
 	/* If status request then ask callback what to do.
  	 * Note: this must be called after servername callbacks in case
  	 * the certificate has changed, and must be called after the cipher
 	 * has been chosen because this may influence which certificate is sent
  	 */
 	if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb)
+		{
 		int r;
 		CERT_PKEY *certpkey;
 		certpkey = ssl_get_server_send_pkey(s);
 		/* If no certificate can't return certificate status */
 		if (certpkey == NULL)
+			{
 			s->tlsext_status_expected = 0;
 			return 1;
+			}
 		/* Set current certificate to one we will use so
 		 * SSL_get_certificate et al can pick it up.
 		 */
 		s->cert->key = certpkey;
 		r = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
 		switch (r)
+			{
 			/* We don't want to send a status request response */
 			case SSL_TLSEXT_ERR_NOACK:
 				s->tlsext_status_expected = 0;
 				break;
 			/* status request response should be sent */
 			case SSL_TLSEXT_ERR_OK:
 				if (s->tlsext_ocsp_resp)
 					s->tlsext_status_expected = 1;
 				else
 					s->tlsext_status_expected = 0;
 				break;
 			/* something bad happened */
 			case SSL_TLSEXT_ERR_ALERT_FATAL:
 				ret = SSL_TLSEXT_ERR_ALERT_FATAL;
 				al = SSL_AD_INTERNAL_ERROR;
 				goto err;
+			}
+		}
 	else
 		s->tlsext_status_expected = 0;
  err:
 	switch (ret)
+		{
 		case SSL_TLSEXT_ERR_ALERT_FATAL:
 			ssl3_send_alert(s,SSL3_AL_FATAL,al);
 			return -1;
 		case SSL_TLSEXT_ERR_ALERT_WARNING:
 			ssl3_send_alert(s,SSL3_AL_WARNING,al);
 			return 1;
 		default:
 			return 1;
+		}
+	}
 int ssl_check_serverhello_tlsext(SSL *s)
+	{
 	int ret=SSL_TLSEXT_ERR_NOACK;
 	int al = SSL_AD_UNRECOGNIZED_NAME;
 #ifndef OPENSSL_NO_EC
 	/* If we are client and using an elliptic curve cryptography cipher
 	 * suite, then if server returns an EC point formats lists extension
 	 * it must contain uncompressed.
 	 */
 	unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
 	unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
 	if ((s->tlsext_ecpointformatlist != NULL) && (s->tlsext_ecpointformatlist_length > 0) &&
 @@ -2179,27 +2216,27 @@ static int tls_decrypt_ticket(SSL *s, co
 	 * integrity checks on ticket.
 	 */
 	mlen = HMAC_size(&hctx);
 	if (mlen < 0)
+		{
 		EVP_CIPHER_CTX_cleanup(&ctx);
 		return -1;
+		}
 	eticklen -= mlen;
 	/* Check HMAC of encrypted ticket */
 	HMAC_Update(&hctx, etick, eticklen);
 	HMAC_Final(&hctx, tick_hmac, NULL);
 	HMAC_CTX_cleanup(&hctx);
-	if (memcmp(tick_hmac, etick + eticklen, mlen))
+	if (CRYPTO_memcmp(tick_hmac, etick + eticklen, mlen))
 		return 2;
 	/* Attempt to decrypt session data */
 	/* Move p after IV to start of encrypted ticket, update length */
 	p = etick + 16 + EVP_CIPHER_CTX_iv_length(&ctx);
 	eticklen -= 16 + EVP_CIPHER_CTX_iv_length(&ctx);
 	sdec = OPENSSL_malloc(eticklen);
 	if (!sdec)
+		{
 		EVP_CIPHER_CTX_cleanup(&ctx);
 		return -1;
+		}
 	EVP_DecryptUpdate(&ctx, sdec, &slen, p, eticklen);
 	if (EVP_DecryptFinal(&ctx, sdec + slen, &mlen) <= 0)
 @@ -2404,38 +2441,38 @@ int tls1_process_sigalgs(SSL *s, const u
 				if (idx == SSL_PKEY_RSA_SIGN)
 					c->pkeys[SSL_PKEY_RSA_ENC].digest = md;
+				}
+			}
+		}
 	/* Set any remaining keys to default values. NOTE: if alg is not
 	 * supported it stays as NULL.
 	 */
 #ifndef OPENSSL_NO_DSA
 	if (!c->pkeys[SSL_PKEY_DSA_SIGN].digest)
-		c->pkeys[SSL_PKEY_DSA_SIGN].digest = EVP_dss1();
+		c->pkeys[SSL_PKEY_DSA_SIGN].digest = EVP_sha1();
 #endif
 #ifndef OPENSSL_NO_RSA
 	if (!c->pkeys[SSL_PKEY_RSA_SIGN].digest)
+		{
 		c->pkeys[SSL_PKEY_RSA_SIGN].digest = EVP_sha1();
 		c->pkeys[SSL_PKEY_RSA_ENC].digest = EVP_sha1();
+		}
 #endif
 #ifndef OPENSSL_NO_ECDSA
 	if (!c->pkeys[SSL_PKEY_ECC].digest)
-		c->pkeys[SSL_PKEY_ECC].digest = EVP_ecdsa();
+		c->pkeys[SSL_PKEY_ECC].digest = EVP_sha1();
 #endif
 	return 1;
+	}
 #endif
 #ifndef OPENSSL_NO_HEARTBEATS
 int
 tls1_process_heartbeat(SSL *s)
+	{
 	unsigned char *p = &s->s3->rrec.data[0], *pl;
 	unsigned short hbtype;
 	unsigned int payload;