Upstream tarball 2.2.22upstream/2.2.22

16 files changed, 1243 insertions, 84 deletions

diff --git a/srclib/apr-util/test/Makefile.in b/srclib/apr-util/test/Makefile.in
index 8a913197..cf89a548 100644
--- a/srclib/apr-util/test/Makefile.in
+++ b/srclib/apr-util/test/Makefile.in
@@ -17,7 +17,7 @@ STDTEST_PORTABLE = dbd testall
 TESTS = teststrmatch.lo testuri.lo testuuid.lo testbuckets.lo testpass.lo \
 	testmd4.lo testmd5.lo testldap.lo testdate.lo testdbm.lo testdbd.lo \
 	testxml.lo testrmm.lo testreslist.lo testqueue.lo testxlate.lo \
-	testmemcache.lo 
+	testmemcache.lo testcrypto.lo
 
 PROGRAMS = $(STDTEST_PORTABLE)
 
@@ -63,7 +63,7 @@ check: $(TESTALL_COMPONENTS) $(STDTEST_PORTABLE) $(STDTEST_NONPORTABLE)
 	        if test "$$prog" = 'dbd'; then \
 			for driver in none @apu_dbd_tests@; do \
 				if test "$$driver" != 'none'; then \
-					@apr_shlibpath_var@="`echo "../dbm/.libs:../dbd/.libs:../ldap/.libs:$$@apr_shlibpath_var@" | sed -e 's/::*$$//'`" \
+					@apr_shlibpath_var@="`echo "../crypto/.libs:../dbm/.libs:../dbd/.libs:../ldap/.libs:$$@apr_shlibpath_var@" | sed -e 's/::*$$//'`" \
 					./$$prog $$driver; \
 					status=$$?; \
 					if test $$status != 0; then \
@@ -73,7 +73,7 @@ check: $(TESTALL_COMPONENTS) $(STDTEST_PORTABLE) $(STDTEST_NONPORTABLE)
 				fi; \
 			done; \
 	        else \
-			@apr_shlibpath_var@="`echo "../dbm/.libs:../dbd/.libs:../ldap/.libs:$$@apr_shlibpath_var@" | sed -e 's/::*$$//'`" \
+			@apr_shlibpath_var@="`echo "../crypto/.libs:../dbm/.libs:../dbd/.libs:../ldap/.libs:$$@apr_shlibpath_var@" | sed -e 's/::*$$//'`" \
 			./$$prog; \
 			status=$$?; \
 			if test $$status != 0; then \
diff --git a/srclib/apr-util/test/NWGNUaputest b/srclib/apr-util/test/NWGNUaputest
index 3ad10983..6b710ad8 100644
--- a/srclib/apr-util/test/NWGNUaputest
+++ b/srclib/apr-util/test/NWGNUaputest
@@ -173,28 +173,29 @@ TARGET_lib = \
 FILES_nlm_objs = \
 	$(OBJDIR)/abts.o \
 	$(OBJDIR)/testbuckets.o \
+	$(OBJDIR)/testcrypto.o \
 	$(OBJDIR)/testdate.o \
 	$(OBJDIR)/testdbd.o \
 	$(OBJDIR)/testdbm.o \
-	$(OBJDIR)/testldap.o \
 	$(OBJDIR)/testmemcache.o \
 	$(OBJDIR)/testmd4.o \
 	$(OBJDIR)/testmd5.o \
+	$(OBJDIR)/testldap.o \
 	$(OBJDIR)/testpass.o \
 	$(OBJDIR)/testqueue.o \
 	$(OBJDIR)/testreslist.o \
 	$(OBJDIR)/testrmm.o \
 	$(OBJDIR)/teststrmatch.o \
 	$(OBJDIR)/testuri.o \
-	$(OBJDIR)/testuuid.o \
 	$(OBJDIR)/testutil.o \
-	$(OBJDIR)/testxlate.o \
+	$(OBJDIR)/testuuid.o \
 	$(OBJDIR)/testxml.o \
+	$(OBJDIR)/testxlate.o \
 	$(OBJDIR)/nw_misc.o \
 	$(EOLIST) 
 
 # Pending tests
-	
+
 #
 # These are the LIB files needed to create the NLM target above.
 # These will be added as a library command in the link.opt file.
@@ -234,7 +235,6 @@ FILE_nlm_copyright =
 #
 FILES_nlm_Ximports = \
 	@libc.imp \
-	@netware.imp \
 	@aprlib.imp \
 	@lldapsdk.imp \
 	@lldapssl.imp \
diff --git a/srclib/apr-util/test/NWGNUmakefile b/srclib/apr-util/test/NWGNUmakefile
index d589ebf9..a36d1784 100644
--- a/srclib/apr-util/test/NWGNUmakefile
+++ b/srclib/apr-util/test/NWGNUmakefile
@@ -3,7 +3,7 @@
 #
 
 SUBDIRS = \
-	$(EOLIST) 
+	$(EOLIST)
 
 #
 # Get the 'head' of the build environment.  This includes default targets and
@@ -101,16 +101,16 @@ endif
 NLM_NAME	=
 
 #
-# This is used by the link '-desc ' directive. 
+# This is used by the link '-desc ' directive.
 # If left blank, NLM_NAME will be used.
 #
-NLM_DESCRIPTION	=  NLM is to test the apu layer
+NLM_DESCRIPTION	=
 
 #
 # This is used by the '-threadname' directive.  If left blank,
 # NLM_NAME Thread will be used.
 #
-NLM_THREAD_NAME	= 
+NLM_THREAD_NAME	=
 
 #
 # This is used by the '-screenname' directive.  If left blank,
@@ -119,25 +119,25 @@ NLM_THREAD_NAME	=
 NLM_SCREEN_NAME =
 
 #
-# If this is specified, it will override VERSION value in 
-# $(APR_WORK)\build\NWGNUenvironment.inc
+# If this is specified, it will override VERSION value in
+# $(APR_WORK)/build/NWGNUenvironment.inc
 #
-NLM_VERSION	= 
+NLM_VERSION	=
 
 #
 # If this is specified, it will override the default of 64K
 #
-NLM_STACK_SIZE	= 
+NLM_STACK_SIZE	=
 
 #
 # If this is specified it will be used by the link '-entry' directive
 #
-NLM_ENTRY_SYM	= 
+NLM_ENTRY_SYM	=
 
 #
 # If this is specified it will be used by the link '-exit' directive
 #
-NLM_EXIT_SYM	= 
+NLM_EXIT_SYM	=
 
 #
 # If this is specified it will be used by the link '-check' directive
@@ -148,13 +148,13 @@ NLM_CHECK_SYM	=
 # If this is specified it will be used by the link '-flags' directive
 #
 NLM_FLAGS	=
- 
+
 #
-# If this is specified it will be linked in with the XDCData option in the def 
-# file instead of the default of $(APR)/misc/netware/apache.xdc.  XDCData can 
+# If this is specified it will be linked in with the XDCData option in the def
+# file instead of the default of $(APR)/misc/netware/apache.xdc.  XDCData can
 # be disabled by setting APACHE_UNIPROC in the environment
 #
-XDCDATA		= 
+XDCDATA		=
 
 #
 # Declare all target files (you must add your files here)
@@ -199,7 +199,7 @@ FILES_nlm_modules = \
 # If the nlm has a msg file, put it's path here
 #
 FILE_nlm_msg =
- 
+
 #
 # If the nlm has a hlp file put it's path here
 #
@@ -215,14 +215,14 @@ FILE_nlm_copyright =
 #
 FILES_nlm_Ximports = \
 	$(EOLIST)
- 
-#   
+
+#
 # Any symbols exported to here
 #
 FILES_nlm_exports = \
 	$(EOLIST)
 
-#   
+#
 # These are the OBJ files needed to create the LIB target above.
 # Paths must all use the '/' character
 #
@@ -238,7 +238,7 @@ libs :: $(OBJDIR) $(TARGET_lib)
 nlms :: libs $(TARGET_nlm)
 
 #
-# Updated this target to create necessary directories and copy files to the 
+# Updated this target to create necessary directories and copy files to the
 # correct place.  (See $(APR_WORK)/build/NWGNUhead.inc for examples)
 #
 install :: nlms FORCE
diff --git a/srclib/apr-util/test/abts_tests.h b/srclib/apr-util/test/abts_tests.h
index 040d02db..b612d31b 100644
--- a/srclib/apr-util/test/abts_tests.h
+++ b/srclib/apr-util/test/abts_tests.h
@@ -30,6 +30,7 @@ const struct testlist {
     {testpass},
     {testmd4},
     {testmd5},
+    {testcrypto},
     {testldap},
     {testdbd},
     {testdate},
diff --git a/srclib/apr-util/test/nw_misc.c b/srclib/apr-util/test/nw_misc.c
index 8e94598a..b45f9516 100644
--- a/srclib/apr-util/test/nw_misc.c
+++ b/srclib/apr-util/test/nw_misc.c
@@ -1,6 +1,5 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <netware.h>
 #include <screen.h>
 /*
 #include "testutil.h"
@@ -10,11 +9,7 @@
 void _NonAppStop( void )
 {
   if (getenv("_IN_NETWARE_BASH_") == NULL) {
-    uint16_t row, col;
-
-    GetScreenSize(&row, &col);
-    gotorowcol(row-1, 0);
-    printf("<Press any key to close screen> ");
+    printf("\r\n<Press any key to close screen> ");
     getcharacter();
   }
 }
diff --git a/srclib/apr-util/test/testall.dsw b/srclib/apr-util/test/testall.dsw
index 0d71a0ed..0a640c8b 100644
--- a/srclib/apr-util/test/testall.dsw
+++ b/srclib/apr-util/test/testall.dsw
@@ -219,7 +219,7 @@ Package=<5>
 Package=<4>
 {{{
     Begin Project Dependency
-    Project_Dep_Name apr
+    Project_Dep_Name preapriconv
     End Project Dependency
 }}}
 
@@ -234,6 +234,9 @@ Package=<5>
 Package=<4>
 {{{
     Begin Project Dependency
+    Project_Dep_Name preaprutil
+    End Project Dependency
+    Begin Project Dependency
     Project_Dep_Name apriconv
     End Project Dependency
     Begin Project Dependency
@@ -333,6 +336,9 @@ Package=<4>
     Project_Dep_Name libapr
     End Project Dependency
     Begin Project Dependency
+    Project_Dep_Name libaprapp
+    End Project Dependency
+    Begin Project Dependency
     Project_Dep_Name libapriconv
     End Project Dependency
     Begin Project Dependency
@@ -363,6 +369,39 @@ Package=<4>
 
 ###############################################################################
 
+Project: "preapriconv"="..\..\apr-iconv\build\preapriconv.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name apr
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "preaprutil"="..\build\preaprutil.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name apr
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name aprapp
+    End Project Dependency
+}}}
+
+###############################################################################
+
 Project: "prelibaprapp"="..\..\apr\build\prelibaprapp.dsp" - Package Owner=<4>
 
 Package=<5>
@@ -387,10 +426,13 @@ Package=<5>
 Package=<4>
 {{{
     Begin Project Dependency
+    Project_Dep_Name apr_ldap
+    End Project Dependency
+    Begin Project Dependency
     Project_Dep_Name libapr
     End Project Dependency
     Begin Project Dependency
-    Project_Dep_Name libapr_app
+    Project_Dep_Name libaprapp
     End Project Dependency
 }}}
 
@@ -408,7 +450,7 @@ Package=<4>
     Project_Dep_Name apr
     End Project Dependency
     Begin Project Dependency
-    Project_Dep_Name apr_app
+    Project_Dep_Name aprapp
     End Project Dependency
 }}}
 
@@ -423,10 +465,10 @@ Package=<5>
 Package=<4>
 {{{
     Begin Project Dependency
-    Project_Dep_Name apr_ldap
+    Project_Dep_Name libapr
     End Project Dependency
     Begin Project Dependency
-    Project_Dep_Name libapr
+    Project_Dep_Name libaprapp
     End Project Dependency
     Begin Project Dependency
     Project_Dep_Name libapriconv
@@ -434,9 +476,6 @@ Package=<4>
     Begin Project Dependency
     Project_Dep_Name libaprutil
     End Project Dependency
-    Begin Project Dependency
-    Project_Dep_Name libapr_app
-    End Project Dependency
 }}}
 
 ###############################################################################
@@ -453,13 +492,13 @@ Package=<4>
     Project_Dep_Name apr
     End Project Dependency
     Begin Project Dependency
-    Project_Dep_Name apriconv
+    Project_Dep_Name aprapp
     End Project Dependency
     Begin Project Dependency
-    Project_Dep_Name aprutil
+    Project_Dep_Name apriconv
     End Project Dependency
     Begin Project Dependency
-    Project_Dep_Name apr_app
+    Project_Dep_Name aprutil
     End Project Dependency
 }}}
 
diff --git a/srclib/apr-util/test/testbuckets.c b/srclib/apr-util/test/testbuckets.c
index 6c3653ff..807b2a59 100644
--- a/srclib/apr-util/test/testbuckets.c
+++ b/srclib/apr-util/test/testbuckets.c
@@ -368,7 +368,7 @@ static apr_file_t *make_test_file(abts_case *tc, const char *fname,
 
     ABTS_ASSERT(tc, "create test file",
                 apr_file_open(&f, fname,
-                              APR_READ|APR_WRITE|APR_TRUNCATE|APR_CREATE,
+                              APR_FOPEN_READ|APR_FOPEN_WRITE|APR_FOPEN_TRUNCATE|APR_FOPEN_CREATE,
                               APR_OS_DEFAULT, p) == APR_SUCCESS);
     
     ABTS_ASSERT(tc, "write test file contents",
diff --git a/srclib/apr-util/test/testcrypto.c b/srclib/apr-util/test/testcrypto.c
new file mode 100644
index 00000000..335c3ae6
--- /dev/null
+++ b/srclib/apr-util/test/testcrypto.c
@@ -0,0 +1,888 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "testutil.h"
+#include "apr.h"
+#include "apu.h"
+#include "apu_errno.h"
+#include "apr_pools.h"
+#include "apr_dso.h"
+#include "apr_crypto.h"
+#include "apr_strings.h"
+
+#if APU_HAVE_CRYPTO
+
+#define TEST_STRING "12345"
+#define ALIGNED_STRING "123456789012345"
+
+static const apr_crypto_driver_t *get_driver(abts_case *tc, apr_pool_t *pool,
+        const char *name, const char *params)
+{
+
+    const apr_crypto_driver_t *driver = NULL;
+    const apu_err_t *err = NULL;
+    apr_status_t rv;
+
+    rv = apr_crypto_init(pool);
+    ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
+
+    rv = apr_crypto_get_driver(&driver, name, params, &err, pool);
+    if (APR_SUCCESS != rv && err) {
+        ABTS_NOT_IMPL(tc, err->msg);
+        return NULL;
+    }
+    if (APR_ENOTIMPL == rv) {
+        ABTS_NOT_IMPL(tc, (char *)driver);
+        return NULL;
+    }
+    ABTS_ASSERT(tc, "failed to apr_crypto_get_driver", rv == APR_SUCCESS);
+    ABTS_ASSERT(tc, "apr_crypto_get_driver returned NULL", driver != NULL);
+    if (!driver || rv) {
+        return NULL;
+    }
+
+    return driver;
+
+}
+
+static const apr_crypto_driver_t *get_nss_driver(abts_case *tc,
+        apr_pool_t *pool)
+{
+
+    /* initialise NSS */
+    return get_driver(tc, pool, "nss", "dir=data");
+
+}
+
+static const apr_crypto_driver_t *get_openssl_driver(abts_case *tc,
+        apr_pool_t *pool)
+{
+
+    return get_driver(tc, pool, "openssl", NULL);
+
+}
+
+static apr_crypto_t *make(abts_case *tc, apr_pool_t *pool,
+        const apr_crypto_driver_t *driver)
+{
+
+    apr_crypto_t *f = NULL;
+
+    if (!driver) {
+        return NULL;
+    }
+
+    /* get the context */
+    apr_crypto_make(&f, driver, "engine=openssl", pool);
+    ABTS_ASSERT(tc, "apr_crypto_make returned NULL", f != NULL);
+
+    return f;
+
+}
+
+static const apr_crypto_key_t *passphrase(abts_case *tc, apr_pool_t *pool,
+        const apr_crypto_driver_t *driver, const apr_crypto_t *f,
+        apr_crypto_block_key_type_e type, apr_crypto_block_key_mode_e mode,
+        int doPad, const char *description)
+{
+
+    apr_crypto_key_t *key = NULL;
+    const apu_err_t *result = NULL;
+    const char *pass = "secret";
+    const char *salt = "salt";
+    apr_status_t rv;
+
+    if (!f) {
+        return NULL;
+    }
+
+    /* init the passphrase */
+    rv = apr_crypto_passphrase(&key, NULL, pass, strlen(pass),
+            (unsigned char *) salt, strlen(salt), type, mode, doPad, 4096, f,
+            pool);
+    if (APR_ENOCIPHER == rv) {
+        apr_crypto_error(&result, f);
+        ABTS_NOT_IMPL(tc, apr_psprintf(pool,
+                        "skipped: %s %s passphrase return APR_ENOCIPHER: error %d: %s (%s)\n",
+                        description, apr_crypto_driver_name(driver), result->rc,
+                        result->reason ? result->reason : "", result->msg ? result->msg : ""));
+        return NULL;
+    }
+    else {
+        if (APR_SUCCESS != rv) {
+            apr_crypto_error(&result, f);
+            fprintf(stderr, "passphrase: %s %s native error %d: %s (%s)\n",
+                    description, apr_crypto_driver_name(driver), result->rc,
+                    result->reason ? result->reason : "",
+                    result->msg ? result->msg : "");
+        }
+        ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_ENOKEY", rv != APR_ENOKEY);
+        ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EPADDING", rv != APR_EPADDING);
+        ABTS_ASSERT(tc, "apr_crypto_passphrase returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
+        ABTS_ASSERT(tc, "failed to apr_crypto_passphrase", rv == APR_SUCCESS);
+        ABTS_ASSERT(tc, "apr_crypto_passphrase returned NULL context", key != NULL);
+    }
+    if (rv) {
+        return NULL;
+    }
+    return key;
+
+}
+
+static unsigned char *encrypt_block(abts_case *tc, apr_pool_t *pool,
+        const apr_crypto_driver_t *driver, const apr_crypto_t *f,
+        const apr_crypto_key_t *key, const unsigned char *in,
+        const apr_size_t inlen, unsigned char **cipherText,
+        apr_size_t *cipherTextLen, const unsigned char **iv,
+        apr_size_t *blockSize, const char *description)
+{
+
+    apr_crypto_block_t *block = NULL;
+    const apu_err_t *result = NULL;
+    apr_size_t len = 0;
+    apr_status_t rv;
+
+    if (!driver || !f || !key || !in) {
+        return NULL;
+    }
+
+    /* init the encryption */
+    rv = apr_crypto_block_encrypt_init(&block, iv, key, blockSize, pool);
+    if (APR_ENOTIMPL == rv) {
+        ABTS_NOT_IMPL(tc, "apr_crypto_block_encrypt_init returned APR_ENOTIMPL");
+    }
+    else {
+        if (APR_SUCCESS != rv) {
+            apr_crypto_error(&result, f);
+            fprintf(stderr, "encrypt_init: %s %s native error %d: %s (%s)\n",
+                    description, apr_crypto_driver_name(driver), result->rc,
+                    result->reason ? result->reason : "",
+                    result->msg ? result->msg : "");
+        }
+        ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOKEY", rv != APR_ENOKEY);
+        ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_ENOIV", rv != APR_ENOIV);
+        ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
+        ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH);
+        ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_init", rv == APR_SUCCESS);
+        ABTS_ASSERT(tc, "apr_crypto_block_encrypt_init returned NULL context", block != NULL);
+    }
+    if (!block || rv) {
+        return NULL;
+    }
+
+    /* encrypt the block */
+    rv = apr_crypto_block_encrypt(cipherText, cipherTextLen, in, inlen, block);
+    if (APR_SUCCESS != rv) {
+        apr_crypto_error(&result, f);
+        fprintf(stderr, "encrypt: %s %s native error %d: %s (%s)\n",
+                description, apr_crypto_driver_name(driver), result->rc,
+                result->reason ? result->reason : "", result->msg ? result->msg
+                        : "");
+    }
+    ABTS_ASSERT(tc, "apr_crypto_block_encrypt returned APR_ECRYPT", rv != APR_ECRYPT);
+    ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt", rv == APR_SUCCESS);
+    ABTS_ASSERT(tc, "apr_crypto_block_encrypt failed to allocate buffer", *cipherText != NULL);
+    if (rv) {
+        return NULL;
+    }
+
+    /* finalise the encryption */
+    rv = apr_crypto_block_encrypt_finish(*cipherText + *cipherTextLen, &len,
+            block);
+    if (APR_SUCCESS != rv) {
+        apr_crypto_error(&result, f);
+        fprintf(stderr, "encrypt_finish: %s %s native error %d: %s (%s)\n",
+                description, apr_crypto_driver_name(driver), result->rc,
+                result->reason ? result->reason : "", result->msg ? result->msg
+                        : "");
+    }
+    ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT);
+    ABTS_ASSERT(tc, "apr_crypto_block_encrypt_finish returned APR_EPADDING", rv != APR_EPADDING);
+    ABTS_ASSERT(tc, "failed to apr_crypto_block_encrypt_finish", rv == APR_SUCCESS);
+    *cipherTextLen += len;
+    apr_crypto_block_cleanup(block);
+    if (rv) {
+        return NULL;
+    }
+
+    return *cipherText;
+
+}
+
+static unsigned char *decrypt_block(abts_case *tc, apr_pool_t *pool,
+        const apr_crypto_driver_t *driver, const apr_crypto_t *f,
+        const apr_crypto_key_t *key, unsigned char *cipherText,
+        apr_size_t cipherTextLen, unsigned char **plainText,
+        apr_size_t *plainTextLen, const unsigned char *iv,
+        apr_size_t *blockSize, const char *description)
+{
+
+    apr_crypto_block_t *block = NULL;
+    const apu_err_t *result = NULL;
+    apr_size_t len = 0;
+    apr_status_t rv;
+
+    if (!driver || !f || !key || !cipherText) {
+        return NULL;
+    }
+
+    /* init the decryption */
+    rv = apr_crypto_block_decrypt_init(&block, blockSize, iv, key, pool);
+    if (APR_ENOTIMPL == rv) {
+        ABTS_NOT_IMPL(tc, "apr_crypto_block_decrypt_init returned APR_ENOTIMPL");
+    }
+    else {
+        if (APR_SUCCESS != rv) {
+            apr_crypto_error(&result, f);
+            fprintf(stderr, "decrypt_init: %s %s native error %d: %s (%s)\n",
+                    description, apr_crypto_driver_name(driver), result->rc,
+                    result->reason ? result->reason : "",
+                    result->msg ? result->msg : "");
+        }
+        ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOKEY", rv != APR_ENOKEY);
+        ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_ENOIV", rv != APR_ENOIV);
+        ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYTYPE", rv != APR_EKEYTYPE);
+        ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned APR_EKEYLENGTH", rv != APR_EKEYLENGTH);
+        ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_init", rv == APR_SUCCESS);
+        ABTS_ASSERT(tc, "apr_crypto_block_decrypt_init returned NULL context", block != NULL);
+    }
+    if (!block || rv) {
+        return NULL;
+    }
+
+    /* decrypt the block */
+    rv = apr_crypto_block_decrypt(plainText, plainTextLen, cipherText,
+            cipherTextLen, block);
+    if (APR_SUCCESS != rv) {
+        apr_crypto_error(&result, f);
+        fprintf(stderr, "decrypt: %s %s native error %d: %s (%s)\n",
+                description, apr_crypto_driver_name(driver), result->rc,
+                result->reason ? result->reason : "", result->msg ? result->msg
+                        : "");
+    }
+    ABTS_ASSERT(tc, "apr_crypto_block_decrypt returned APR_ECRYPT", rv != APR_ECRYPT);
+    ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt", rv == APR_SUCCESS);
+    ABTS_ASSERT(tc, "apr_crypto_block_decrypt failed to allocate buffer", *plainText != NULL);
+    if (rv) {
+        return NULL;
+    }
+
+    /* finalise the decryption */
+    rv = apr_crypto_block_decrypt_finish(*plainText + *plainTextLen, &len,
+            block);
+    if (APR_SUCCESS != rv) {
+        apr_crypto_error(&result, f);
+        fprintf(stderr, "decrypt_finish: %s %s native error %d: %s (%s)\n",
+                description, apr_crypto_driver_name(driver), result->rc,
+                result->reason ? result->reason : "", result->msg ? result->msg
+                        : "");
+    }
+    ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_ECRYPT", rv != APR_ECRYPT);
+    ABTS_ASSERT(tc, "apr_crypto_block_decrypt_finish returned APR_EPADDING", rv != APR_EPADDING);
+    ABTS_ASSERT(tc, "failed to apr_crypto_block_decrypt_finish", rv == APR_SUCCESS);
+    if (rv) {
+        return NULL;
+    }
+
+    *plainTextLen += len;
+    apr_crypto_block_cleanup(block);
+
+    return *plainText;
+
+}
+
+/**
+ * Interoperability test.
+ *
+ * data must point at an array of two driver structures. Data will be encrypted
+ * with the first driver, and decrypted with the second.
+ *
+ * If the two drivers interoperate, the test passes.
+ */
+static void crypto_block_cross(abts_case *tc, apr_pool_t *pool,
+        const apr_crypto_driver_t **drivers,
+        const apr_crypto_block_key_type_e type,
+        const apr_crypto_block_key_mode_e mode, int doPad,
+        const unsigned char *in, apr_size_t inlen, const char *description)
+{
+    const apr_crypto_driver_t *driver1 = drivers[0];
+    const apr_crypto_driver_t *driver2 = drivers[1];
+    apr_crypto_t *f1 = NULL;
+    apr_crypto_t *f2 = NULL;
+    const apr_crypto_key_t *key1 = NULL;
+    const apr_crypto_key_t *key2 = NULL;
+
+    unsigned char *cipherText = NULL;
+    apr_size_t cipherTextLen = 0;
+    unsigned char *plainText = NULL;
+    apr_size_t plainTextLen = 0;
+    const unsigned char *iv = NULL;
+    apr_size_t blockSize = 0;
+
+    f1 = make(tc, pool, driver1);
+    f2 = make(tc, pool, driver2);
+    key1 = passphrase(tc, pool, driver1, f1, type, mode, doPad, description);
+    key2 = passphrase(tc, pool, driver2, f2, type, mode, doPad, description);
+
+    cipherText = encrypt_block(tc, pool, driver1, f1, key1, in, inlen,
+            &cipherText, &cipherTextLen, &iv, &blockSize, description);
+    plainText = decrypt_block(tc, pool, driver2, f2, key2, cipherText,
+            cipherTextLen, &plainText, &plainTextLen, iv, &blockSize,
+            description);
+
+    if (cipherText && plainText) {
+        if (memcmp(in, plainText, inlen)) {
+            fprintf(stderr, "cross mismatch: %s %s/%s\n", description,
+                    apr_crypto_driver_name(driver1), apr_crypto_driver_name(
+                            driver2));
+        }
+        ABTS_STR_EQUAL(tc, (char *)in, (char *)plainText);
+    }
+
+}
+
+/**
+ * Test initialisation.
+ */
+static void test_crypto_init(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    apr_status_t rv;
+
+    apr_pool_create(&pool, NULL);
+
+    rv = apr_crypto_init(pool);
+    ABTS_ASSERT(tc, "failed to init apr_crypto", rv == APR_SUCCESS);
+
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Simple test of OpenSSL block crypt.
+ */
+static void test_crypto_block_openssl(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] = { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
+    apr_size_t inlen = sizeof(ALIGNED_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_openssl_driver(tc, pool);
+    drivers[1] = get_openssl_driver(tc, pool);
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 0,
+            in, inlen, "KEY_3DES_192/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_256/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_192/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_192/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_128/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_128/MODE_ECB");
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Simple test of NSS block crypt.
+ */
+static void test_crypto_block_nss(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] = { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
+    apr_size_t inlen = sizeof(ALIGNED_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_nss_driver(tc, pool);
+    drivers[1] = get_nss_driver(tc, pool);
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+    /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
+    /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_256/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_192/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_192/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_128/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_128/MODE_ECB");
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Encrypt NSS, decrypt OpenSSL.
+ */
+static void test_crypto_block_nss_openssl(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] = { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
+    apr_size_t inlen = sizeof(ALIGNED_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_nss_driver(tc, pool);
+    drivers[1] = get_openssl_driver(tc, pool);
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+
+    /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
+    /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_256/MODE_ECB");
+
+    /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
+     * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
+     * investigated.
+     */
+    /*
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 0, in, inlen, "KEY_AES_192/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 0, in, inlen, "KEY_AES_192/MODE_ECB");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 0, in, inlen, "KEY_AES_128/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 0, in, inlen, "KEY_AES_128/MODE_ECB");
+     */
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Encrypt OpenSSL, decrypt NSS.
+ */
+static void test_crypto_block_openssl_nss(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] = { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) ALIGNED_STRING;
+    apr_size_t inlen = sizeof(ALIGNED_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_openssl_driver(tc, pool);
+    drivers[1] = get_nss_driver(tc, pool);
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 0,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+
+    /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
+    /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 0, in, inlen, "KEY_3DES_192/MODE_ECB"); */
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 0, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 0, in,
+            inlen, "KEY_AES_256/MODE_ECB");
+
+    /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
+     * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
+     * investigated.
+     */
+    /*
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 0, in, inlen, "KEY_AES_192/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 0, in, inlen, "KEY_AES_192/MODE_ECB");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 0, in, inlen, "KEY_AES_128/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 0, in, inlen, "KEY_AES_128/MODE_ECB");
+     */
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Simple test of OpenSSL block crypt.
+ */
+static void test_crypto_block_openssl_pad(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] = { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) TEST_STRING;
+    apr_size_t inlen = sizeof(TEST_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_openssl_driver(tc, pool);
+    drivers[1] = get_openssl_driver(tc, pool);
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_ECB, 1,
+            in, inlen, "KEY_3DES_192/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_ECB, 1, in,
+            inlen, "KEY_AES_256/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_192/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_ECB, 1, in,
+            inlen, "KEY_AES_192/MODE_ECB");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_128/MODE_CBC");
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_ECB, 1, in,
+            inlen, "KEY_AES_128/MODE_ECB");
+
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Simple test of NSS block crypt.
+ */
+static void test_crypto_block_nss_pad(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] =
+    { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) TEST_STRING;
+    apr_size_t inlen = sizeof(TEST_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_nss_driver(tc, pool);
+    drivers[1] = get_nss_driver(tc, pool);
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+    /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
+    /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+
+    /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
+    /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_192, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_192/MODE_CBC");
+
+    /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
+    /*crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB");*/
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_128, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_128/MODE_CBC");
+
+    /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
+    /*crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB");*/
+
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Encrypt NSS, decrypt OpenSSL.
+ */
+static void test_crypto_block_nss_openssl_pad(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] = { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) TEST_STRING;
+    apr_size_t inlen = sizeof(TEST_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_nss_driver(tc, pool);
+    drivers[1] = get_openssl_driver(tc, pool);
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+
+    /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
+    /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+
+    /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
+    /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/
+
+    /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
+     * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
+     * investigated.
+     */
+    /*
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 1, in, inlen, "KEY_AES_192/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 1, in, inlen, "KEY_AES_128/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB");
+     */
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Encrypt OpenSSL, decrypt NSS.
+ */
+static void test_crypto_block_openssl_nss_pad(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *drivers[] = { NULL, NULL };
+
+    const unsigned char *in = (const unsigned char *) TEST_STRING;
+    apr_size_t inlen = sizeof(TEST_STRING);
+
+    apr_pool_create(&pool, NULL);
+    drivers[0] = get_openssl_driver(tc, pool);
+    drivers[1] = get_nss_driver(tc, pool);
+    crypto_block_cross(tc, pool, drivers, APR_KEY_3DES_192, APR_MODE_CBC, 1,
+            in, inlen, "KEY_3DES_192/MODE_CBC");
+
+    /* KEY_3DES_192 / MODE_ECB doesn't work on NSS */
+    /* crypto_block_cross(tc, pool, drivers, KEY_3DES_192, MODE_ECB, 1, in, inlen, "KEY_3DES_192/MODE_ECB"); */
+
+    crypto_block_cross(tc, pool, drivers, APR_KEY_AES_256, APR_MODE_CBC, 1, in,
+            inlen, "KEY_AES_256/MODE_CBC");
+
+    /* KEY_AES_256 / MODE_ECB doesn't support padding on NSS */
+    /*crypto_block_cross(tc, pool, drivers, KEY_AES_256, MODE_ECB, 1, in, inlen, "KEY_AES_256/MODE_ECB");*/
+
+    /* all 4 of these tests fail to interoperate - a clue from the xml-security code is that
+     * NSS cannot distinguish between the 128 and 192 bit versions of AES. Will need to be
+     * investigated.
+     */
+    /*
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_CBC, 1, in, inlen, "KEY_AES_192/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_192, MODE_ECB, 1, in, inlen, "KEY_AES_192/MODE_ECB");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_CBC, 1, in, inlen, "KEY_AES_128/MODE_CBC");
+     crypto_block_cross(tc, pool, drivers, KEY_AES_128, MODE_ECB, 1, in, inlen, "KEY_AES_128/MODE_ECB");
+     */
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Get Types, OpenSSL.
+ */
+static void test_crypto_get_block_key_types_openssl(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *driver;
+    apr_crypto_t *f;
+    apr_hash_t *types;
+    int *key_3des_192;
+    int *key_aes_128;
+    int *key_aes_192;
+    int *key_aes_256;
+
+    apr_pool_create(&pool, NULL);
+    driver = get_openssl_driver(tc, pool);
+    if (driver) {
+
+        f = make(tc, pool, driver);
+        apr_crypto_get_block_key_types(&types, f);
+
+        key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_3des_192);
+        ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192);
+
+        key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_aes_128);
+        ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128);
+
+        key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_aes_192);
+        ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192);
+
+        key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_aes_256);
+        ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256);
+
+    }
+
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Get Types, NSS.
+ */
+static void test_crypto_get_block_key_types_nss(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *driver;
+    apr_crypto_t *f;
+    apr_hash_t *types;
+    int *key_3des_192;
+    int *key_aes_128;
+    int *key_aes_192;
+    int *key_aes_256;
+
+    apr_pool_create(&pool, NULL);
+    driver = get_nss_driver(tc, pool);
+    if (driver) {
+
+        f = make(tc, pool, driver);
+        apr_crypto_get_block_key_types(&types, f);
+
+        key_3des_192 = apr_hash_get(types, "3des192", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_3des_192);
+        ABTS_INT_EQUAL(tc, *key_3des_192, APR_KEY_3DES_192);
+
+        key_aes_128 = apr_hash_get(types, "aes128", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_aes_128);
+        ABTS_INT_EQUAL(tc, *key_aes_128, APR_KEY_AES_128);
+
+        key_aes_192 = apr_hash_get(types, "aes192", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_aes_192);
+        ABTS_INT_EQUAL(tc, *key_aes_192, APR_KEY_AES_192);
+
+        key_aes_256 = apr_hash_get(types, "aes256", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, key_aes_256);
+        ABTS_INT_EQUAL(tc, *key_aes_256, APR_KEY_AES_256);
+
+    }
+
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Get Modes, OpenSSL.
+ */
+static void test_crypto_get_block_key_modes_openssl(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *driver;
+    apr_crypto_t *f;
+    apr_hash_t *modes;
+    int *mode_ecb;
+    int *mode_cbc;
+
+    apr_pool_create(&pool, NULL);
+    driver = get_openssl_driver(tc, pool);
+    if (driver) {
+
+        f = make(tc, pool, driver);
+        apr_crypto_get_block_key_modes(&modes, f);
+
+        mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, mode_ecb);
+        ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB);
+
+        mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, mode_cbc);
+        ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
+
+    }
+
+    apr_pool_destroy(pool);
+
+}
+
+/**
+ * Get Modes, NSS.
+ */
+static void test_crypto_get_block_key_modes_nss(abts_case *tc, void *data)
+{
+    apr_pool_t *pool = NULL;
+    const apr_crypto_driver_t *driver;
+    apr_crypto_t *f;
+    apr_hash_t *modes;
+    int *mode_ecb;
+    int *mode_cbc;
+
+    apr_pool_create(&pool, NULL);
+    driver = get_nss_driver(tc, pool);
+    if (driver) {
+
+        f = make(tc, pool, driver);
+        apr_crypto_get_block_key_modes(&modes, f);
+
+        mode_ecb = apr_hash_get(modes, "ecb", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, mode_ecb);
+        ABTS_INT_EQUAL(tc, *mode_ecb, APR_MODE_ECB);
+
+        mode_cbc = apr_hash_get(modes, "cbc", APR_HASH_KEY_STRING);
+        ABTS_PTR_NOTNULL(tc, mode_cbc);
+        ABTS_INT_EQUAL(tc, *mode_cbc, APR_MODE_CBC);
+
+    }
+
+    apr_pool_destroy(pool);
+
+}
+
+abts_suite *testcrypto(abts_suite *suite)
+{
+    suite = ADD_SUITE(suite);
+
+    /* test simple init and shutdown */
+    abts_run_test(suite, test_crypto_init, NULL);
+
+    /* test a simple encrypt / decrypt operation - openssl */
+    abts_run_test(suite, test_crypto_block_openssl, NULL);
+
+    /* test a padded encrypt / decrypt operation - openssl */
+    abts_run_test(suite, test_crypto_block_openssl_pad, NULL);
+
+    /* test a simple encrypt / decrypt operation - nss */
+    abts_run_test(suite, test_crypto_block_nss, NULL);
+
+    /* test a padded encrypt / decrypt operation - nss */
+    abts_run_test(suite, test_crypto_block_nss_pad, NULL);
+
+    /* test encrypt nss / decrypt openssl */
+    abts_run_test(suite, test_crypto_block_nss_openssl, NULL);
+
+    /* test padded encrypt nss / decrypt openssl */
+    abts_run_test(suite, test_crypto_block_nss_openssl_pad, NULL);
+
+    /* test encrypt openssl / decrypt nss */
+    abts_run_test(suite, test_crypto_block_openssl_nss, NULL);
+
+    /* test padded encrypt openssl / decrypt nss */
+    abts_run_test(suite, test_crypto_block_openssl_nss_pad, NULL);
+
+    /* test block key types openssl */
+    abts_run_test(suite, test_crypto_get_block_key_types_openssl, NULL);
+
+    /* test block key types nss */
+    abts_run_test(suite, test_crypto_get_block_key_types_nss, NULL);
+
+    /* test block key modes openssl */
+    abts_run_test(suite, test_crypto_get_block_key_modes_openssl, NULL);
+
+    /* test block key modes nss */
+    abts_run_test(suite, test_crypto_get_block_key_modes_nss, NULL);
+
+    return suite;
+}
+
+#else
+
+/**
+ * Dummy test suite when crypto is turned off.
+ */
+abts_suite *testcrypto(abts_suite *suite)
+{
+    return ADD_SUITE(suite);
+}
+
+#endif /* APU_HAVE_CRYPTO */
diff --git a/srclib/apr-util/test/testldap.c b/srclib/apr-util/test/testldap.c
index 7595a55f..4f4fef90 100644
--- a/srclib/apr-util/test/testldap.c
+++ b/srclib/apr-util/test/testldap.c
@@ -80,7 +80,7 @@ static int get_ldap_host(void)
 
     ldap_host[0] = '\0';
     rv = apr_file_open(&thefile, FILENAME, 
-                       APR_READ, 
+                       APR_FOPEN_READ,
                        APR_UREAD | APR_UWRITE | APR_GREAD, p);
     if (rv != APR_SUCCESS) {
         return 0;
diff --git a/srclib/apr-util/test/testmemcache.c b/srclib/apr-util/test/testmemcache.c
index 80bc10bd..49476210 100644
--- a/srclib/apr-util/test/testmemcache.c
+++ b/srclib/apr-util/test/testmemcache.c
@@ -433,7 +433,6 @@ static void test_memcache_multiget(abts_case * tc, void *data)
   rv = apr_memcache_add_server(memcache, server);
   ABTS_ASSERT(tc, "server add failed", rv == APR_SUCCESS);
   
-  values = apr_hash_make(p);
   tdata = apr_hash_make(p);
   
   create_test_hash(pool, tdata);
@@ -487,7 +486,7 @@ static void test_memcache_setget(abts_case * tc, void *data)
     apr_status_t rv;
     apr_memcache_t *memcache;
     apr_memcache_server_t *server;
-    apr_hash_t *tdata, *values;
+    apr_hash_t *tdata;
     apr_hash_index_t *hi;
     char *result;
     apr_size_t len;
@@ -502,7 +501,6 @@ static void test_memcache_setget(abts_case * tc, void *data)
     ABTS_ASSERT(tc, "server add failed", rv == APR_SUCCESS);
 
     tdata = apr_hash_make(pool);
-    values = apr_hash_make(pool);
 
     create_test_hash(pool, tdata);
 
diff --git a/srclib/apr-util/test/testreslist.c b/srclib/apr-util/test/testreslist.c
index aa248152..36333a15 100644
--- a/srclib/apr-util/test/testreslist.c
+++ b/srclib/apr-util/test/testreslist.c
@@ -142,7 +142,6 @@ static void test_timeout(abts_case *tc, apr_reslist_t *rl)
 {
     apr_status_t rv;
     my_resource_t *resources[RESLIST_HMAX];
-    my_resource_t *res;
     void *vp;
     int i;
 
@@ -163,8 +162,6 @@ static void test_timeout(abts_case *tc, apr_reslist_t *rl)
     rv = apr_reslist_acquire(rl, &vp);
     ABTS_TRUE(tc, APR_STATUS_IS_TIMEUP(rv));
 
-    res = vp;
-
     /* release the resources; otherwise the destroy operation
      * will blow
      */
diff --git a/srclib/apr-util/test/testssl.c b/srclib/apr-util/test/testssl.c
new file mode 100644
index 00000000..e7f090e1
--- /dev/null
+++ b/srclib/apr-util/test/testssl.c
@@ -0,0 +1,240 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * testssl: Simple APR SSL sockets test.
+ */
+
+#include "apr.h"
+#include "apr_general.h"
+#include "apr_pools.h"
+#include "apr_errno.h"
+#include "apr_getopt.h"
+#include "apr_time.h"
+#define APR_WANT_STRFUNC
+#include "apr_want.h"
+
+#include "apr_ssl.h"
+#include "apr_network_io.h"
+
+#if APR_HAVE_STDIO_H
+#include <stdio.h>
+#endif
+#if APR_HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <stdlib.h>     /* for atexit(), malloc() */
+#include <string.h>
+
+struct sslTestCase {
+    char *host;
+    int port;
+    const char *request;
+    int result;
+} tests[] = {
+    { "svn.apache.org", 443, "GET / HTTP/1.0\n\n", 1 },
+    { NULL }
+};
+
+static apr_ssl_socket_t *createSocket(apr_ssl_factory_t *asf, 
+                                      apr_pollset_t *pollset,
+                                      apr_pool_t *pool, int blocking)
+{
+    apr_ssl_socket_t *sock;
+    apr_status_t rv;
+    printf("::Creating SSL socket\n");
+    rv = apr_ssl_socket_create(&sock, AF_INET, SOCK_STREAM, 0, asf, NULL);
+    if (rv != APR_SUCCESS) {
+        printf("\tFailed to create socket\n");
+        return NULL;
+    }
+    rv = apr_pollset_add_ssl_socket(pollset, sock);
+    if (rv != APR_SUCCESS) {
+        printf("\tFailed to add to pollset\n");
+        return NULL;
+    }
+    printf("\tOK\n");
+    return sock;
+}
+
+static apr_status_t connectSocket(apr_ssl_socket_t *sock,
+                                  const char *host, int port,
+                                  apr_pool_t *pool)
+{
+    apr_status_t rv;
+    apr_sockaddr_t *remoteSA;
+
+    printf("::Connecting socket\n");
+    rv = apr_sockaddr_info_get(&remoteSA, host, APR_UNSPEC, port, 0, pool);
+    if (rv != APR_SUCCESS) {
+        printf("\tFailed to get address for '%s', port %d\n", host, port);
+        return rv;
+    }
+    rv = apr_ssl_socket_connect(sock, remoteSA);
+    if (rv != APR_SUCCESS) {
+        printf("\tFailed to connect to '%s' port %d\n", host, port);
+        return rv;
+    }
+    printf("\tOK\n");
+    return rv;
+}
+
+static apr_status_t socketRead(apr_ssl_socket_t *sock,
+                               apr_pollset_t *pollset,
+                               char *buf, apr_size_t *len)
+{
+    int lrv;
+    const apr_pollfd_t *descs = NULL;
+    apr_status_t rv;
+
+    printf("::Reading from socket\n");
+    rv = apr_ssl_socket_set_poll_events(sock, APR_POLLIN);
+    if (rv != APR_SUCCESS) {
+        printf("\tUnable to change socket poll events!\n");
+        return rv;
+    }
+
+    rv = apr_pollset_poll(pollset, 30 * APR_USEC_PER_SEC, &lrv, &descs);
+    if (APR_STATUS_IS_TIMEUP(rv)) {
+        printf("\tTime up!\n");
+        return rv;
+    }
+
+    if (lrv != 1) {
+        printf("\tIncorrect return count, %d\n", lrv);
+        return rv;
+    }
+    if (descs[0].client_data != sock) {
+        printf("\tWrong socket returned?!\n");
+        return rv;
+    }
+    if ((descs[0].rtnevents & APR_POLLIN) == 0) {
+        printf("\tSocket wasn't ready? huh? req [%08x] vs rtn [%08x]\n",
+               descs[0].reqevents, descs[0].rtnevents);
+        return rv;
+    }
+    rv = apr_ssl_socket_recv(sock, buf, len);
+    if (rv == APR_SUCCESS)
+        printf("\tOK, read %d bytes\n", *len);
+    else
+        printf("\tFailed\n");
+    return rv;
+}
+
+static apr_status_t socketWrite(apr_ssl_socket_t *sock,
+                                apr_pollset_t *pollset,
+                                const char *buf, apr_size_t *len)
+{
+    int lrv;
+    const apr_pollfd_t *descs = NULL;
+    apr_status_t rv;
+
+    printf("::Writing to socket\n");
+    rv = apr_ssl_socket_set_poll_events(sock, APR_POLLOUT);
+    if (rv != APR_SUCCESS) {
+        printf("\tUnable to change socket poll events!\n");
+        return rv;
+    }
+
+    rv = apr_pollset_poll(pollset, 30 * APR_USEC_PER_SEC, &lrv, &descs);
+    if (APR_STATUS_IS_TIMEUP(rv)) {
+        printf("\tTime up!\n");
+        return rv;
+    }
+    if (lrv != 1) {
+        printf("\tIncorrect return count, %d\n", lrv);
+        return rv;
+    }
+    if (descs[0].client_data != sock) {
+        printf("\tWrong socket returned?!\n");
+        return rv;
+    }
+    if ((descs[0].rtnevents & APR_POLLOUT) == 0) {
+        printf("\tSocket wasn't ready? huh?\n");
+        return rv;
+    }
+    rv = apr_ssl_socket_send(sock, buf, len);
+    if (rv == APR_SUCCESS)
+        printf("\tOK, wrote %d bytes\n", *len);
+    else
+        printf("\tFailed\n");
+    return rv;
+}
+
+apr_status_t socketClose(apr_ssl_socket_t *sock, apr_pollset_t *pollset)
+{
+    apr_status_t rv;
+    printf("::Closing socket\n");
+    rv = apr_pollset_remove_ssl_socket(sock);
+    if (rv != APR_SUCCESS)
+        printf("\tUnable to remove socket from pollset?\n");
+    rv = apr_ssl_socket_close(sock);
+    if (rv != APR_SUCCESS)
+        printf("\tFailed to close SSL socket\n");
+    else
+        printf("\tOK\n");
+    return rv;
+}
+
+
+int main(int argc, const char * const * argv)
+{
+    apr_pool_t *pool;
+    apr_ssl_factory_t *asf = NULL;
+    apr_status_t rv;
+    apr_pollset_t *pollset;
+
+    (void) apr_initialize();
+    apr_pool_create(&pool, NULL);
+    atexit(apr_terminate);
+
+    printf("SSL Library: %s\n", apr_ssl_library_name());
+
+    if (apr_pollset_create(&pollset, 1, pool, 0) != APR_SUCCESS) {
+        printf("Failed to create pollset!\n");
+        exit(1);
+    }
+
+    if (apr_ssl_factory_create(&asf, NULL, NULL, NULL, 
+                               APR_SSL_FACTORY_CLIENT, pool) != APR_SUCCESS) {
+        fprintf(stderr, "Unable to create client factory\n");
+    } else {
+        int i;
+        for(i = 0; tests[i].host; i++) {
+            apr_ssl_socket_t *sslSock = createSocket(asf, pollset, pool, 0);
+            if (!sslSock)
+                continue;
+
+            rv = connectSocket(sslSock, tests[i].host, tests[i].port, pool);
+            if (rv == APR_SUCCESS) {
+                apr_size_t len = strlen(tests[i].request);
+                rv = socketWrite(sslSock, pollset, tests[i].request, &len);
+                if (rv == APR_SUCCESS) {
+                    char buffer[4096];
+                    len = 4096;
+                    rv = socketRead(sslSock, pollset, buffer, &len);
+                }
+            }
+            socketClose(sslSock, pollset);
+        }
+    }
+
+    apr_pollset_destroy(pollset);
+    apr_pool_destroy(pool);
+
+    return 0;
+}
+
+
diff --git a/srclib/apr-util/test/testutil.h b/srclib/apr-util/test/testutil.h
index 6b8e5f84..07b34a84 100644
--- a/srclib/apr-util/test/testutil.h
+++ b/srclib/apr-util/test/testutil.h
@@ -50,6 +50,7 @@ abts_suite *testbuckets(abts_suite *suite);
 abts_suite *testpass(abts_suite *suite);
 abts_suite *testmd4(abts_suite *suite);
 abts_suite *testmd5(abts_suite *suite);
+abts_suite *testcrypto(abts_suite *suite);
 abts_suite *testldap(abts_suite *suite);
 abts_suite *testdbd(abts_suite *suite);
 abts_suite *testdate(abts_suite *suite);
diff --git a/srclib/apr-util/test/testutildll.dsp b/srclib/apr-util/test/testutildll.dsp
index b529ddd4..9c90a16d 100644
--- a/srclib/apr-util/test/testutildll.dsp
+++ b/srclib/apr-util/test/testutildll.dsp
@@ -19,8 +19,8 @@ CFG=testutildll - Win32 Release
 !MESSAGE 
 !MESSAGE "testutildll - Win32 Release" (based on "Win32 (x86) External Target")
 !MESSAGE "testutildll - Win32 Debug" (based on "Win32 (x86) External Target")
-!MESSAGE "testutildll - Win32 ReleaseNT" (based on "Win32 (x86) External Target")
-!MESSAGE "testutildll - Win32 DebugNT" (based on "Win32 (x86) External Target")
+!MESSAGE "testutildll - Win32 Release9x" (based on "Win32 (x86) External Target")
+!MESSAGE "testutildll - Win32 Debug9x" (based on "Win32 (x86) External Target")
 !MESSAGE "testutildll - x64 Release" (based on "Win32 (x86) External Target")
 !MESSAGE "testutildll - x64 Debug" (based on "Win32 (x86) External Target")
 !MESSAGE 
@@ -72,45 +72,45 @@ CFG=testutildll - Win32 Release
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
-!ELSEIF  "$(CFG)" == "testutildll - Win32 ReleaseNT"
+!ELSEIF  "$(CFG)" == "testutildll - Win32 Release9x"
 
 # PROP BASE Use_MFC 0
 # PROP BASE Use_Debug_Libraries 0
 # PROP BASE Output_Dir ""
 # PROP BASE Intermediate_Dir ""
-# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\Release OUTDIR=NT\Release MODEL=dynamic all check"
+# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\Release OUTDIR=9x\Release MODEL=dynamic all check"
 # PROP BASE Rebuild_Opt "/a"
-# PROP BASE Target_File "NT\Release\testall.exe"
+# PROP BASE Target_File "9x\Release\testall.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 0
 # PROP Output_Dir ""
 # PROP Intermediate_Dir ""
-# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\Release OUTDIR=NT\Release MODEL=dynamic all check"
+# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\Release OUTDIR=9x\Release MODEL=dynamic all check"
 # PROP Rebuild_Opt "/a"
-# PROP Target_File "NT\Release\testall.exe"
+# PROP Target_File "9x\Release\testall.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
-!ELSEIF  "$(CFG)" == "testutildll - Win32 DebugNT"
+!ELSEIF  "$(CFG)" == "testutildll - Win32 Debug9x"
 
 # PROP BASE Use_MFC 0
 # PROP BASE Use_Debug_Libraries 1
 # PROP BASE Output_Dir ""
 # PROP BASE Intermediate_Dir ""
-# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\Debug OUTDIR=NT\Debug MODEL=dynamic _DEBUG=1 all check"
+# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\Debug OUTDIR=9x\Debug MODEL=dynamic _DEBUG=1 all check"
 # PROP BASE Rebuild_Opt "/a"
-# PROP BASE Target_File "NT\Debug\testall.exe"
+# PROP BASE Target_File "9x\Debug\testall.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 1
 # PROP Output_Dir ""
 # PROP Intermediate_Dir ""
-# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\Debug OUTDIR=NT\Debug MODEL=dynamic _DEBUG=1 all check"
+# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\Debug OUTDIR=9x\Debug MODEL=dynamic _DEBUG=1 all check"
 # PROP Rebuild_Opt "/a"
-# PROP Target_File "NT\Debug\testall.exe"
+# PROP Target_File "9x\Debug\testall.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
@@ -162,8 +162,8 @@ CFG=testutildll - Win32 Release
 
 # Name "testutildll - Win32 Release"
 # Name "testutildll - Win32 Debug"
-# Name "testutildll - Win32 ReleaseNT"
-# Name "testutildll - Win32 DebugNT"
+# Name "testutildll - Win32 Release9x"
+# Name "testutildll - Win32 Debug9x"
 # Name "testutildll - x64 Release"
 # Name "testutildll - x64 Debug"
 # Begin Group "testall Source Files"
diff --git a/srclib/apr-util/test/testutillib.dsp b/srclib/apr-util/test/testutillib.dsp
index efb516de..6df114ca 100644
--- a/srclib/apr-util/test/testutillib.dsp
+++ b/srclib/apr-util/test/testutillib.dsp
@@ -19,8 +19,8 @@ CFG=testutillib - Win32 Release
 !MESSAGE 
 !MESSAGE "testutillib - Win32 Release" (based on "Win32 (x86) External Target")
 !MESSAGE "testutillib - Win32 Debug" (based on "Win32 (x86) External Target")
-!MESSAGE "testutillib - Win32 ReleaseNT" (based on "Win32 (x86) External Target")
-!MESSAGE "testutillib - Win32 DebugNT" (based on "Win32 (x86) External Target")
+!MESSAGE "testutillib - Win32 Release9x" (based on "Win32 (x86) External Target")
+!MESSAGE "testutillib - Win32 Debug9x" (based on "Win32 (x86) External Target")
 !MESSAGE "testutillib - x64 Release" (based on "Win32 (x86) External Target")
 !MESSAGE "testutillib - x64 Debug" (based on "Win32 (x86) External Target")
 !MESSAGE 
@@ -72,45 +72,45 @@ CFG=testutillib - Win32 Release
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
-!ELSEIF  "$(CFG)" == "testutillib - Win32 ReleaseNT"
+!ELSEIF  "$(CFG)" == "testutillib - Win32 Release9x"
 
 # PROP BASE Use_MFC 0
 # PROP BASE Use_Debug_Libraries 0
 # PROP BASE Output_Dir ""
 # PROP BASE Intermediate_Dir ""
-# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\LibR OUTDIR=NT\LibR MODEL=static all check"
+# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\LibR OUTDIR=9x\LibR MODEL=static all check"
 # PROP BASE Rebuild_Opt "/a"
-# PROP BASE Target_File "NT\LibR\testall.exe"
+# PROP BASE Target_File "9x\LibR\testall.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 0
 # PROP Output_Dir ""
 # PROP Intermediate_Dir ""
-# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\LibR OUTDIR=NT\LibR MODEL=static all check"
+# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\LibR OUTDIR=9x\LibR MODEL=static all check"
 # PROP Rebuild_Opt "/a"
-# PROP Target_File "NT\LibR\testall.exe"
+# PROP Target_File "9x\LibR\testall.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
-!ELSEIF  "$(CFG)" == "testutillib - Win32 DebugNT"
+!ELSEIF  "$(CFG)" == "testutillib - Win32 Debug9x"
 
 # PROP BASE Use_MFC 0
 # PROP BASE Use_Debug_Libraries 1
 # PROP BASE Output_Dir ""
 # PROP BASE Intermediate_Dir ""
-# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\LibD OUTDIR=NT\LibD MODEL=static _DEBUG=1 all check"
+# PROP BASE Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\LibD OUTDIR=9x\LibD MODEL=static _DEBUG=1 all check"
 # PROP BASE Rebuild_Opt "/a"
-# PROP BASE Target_File "NT\LibD\testall.exe"
+# PROP BASE Target_File "9x\LibD\testall.exe"
 # PROP BASE Bsc_Name ""
 # PROP BASE Target_Dir ""
 # PROP Use_MFC 0
 # PROP Use_Debug_Libraries 1
 # PROP Output_Dir ""
 # PROP Intermediate_Dir ""
-# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=NT\LibD OUTDIR=NT\LibD MODEL=static _DEBUG=1 all check"
+# PROP Cmd_Line "NMAKE /f Makefile.win INTDIR=9x\LibD OUTDIR=9x\LibD MODEL=static _DEBUG=1 all check"
 # PROP Rebuild_Opt "/a"
-# PROP Target_File "NT\LibD\testall.exe"
+# PROP Target_File "9x\LibD\testall.exe"
 # PROP Bsc_Name ""
 # PROP Target_Dir ""
 
@@ -162,8 +162,8 @@ CFG=testutillib - Win32 Release
 
 # Name "testutillib - Win32 Release"
 # Name "testutillib - Win32 Debug"
-# Name "testutillib - Win32 ReleaseNT"
-# Name "testutillib - Win32 DebugNT"
+# Name "testutillib - Win32 Release9x"
+# Name "testutillib - Win32 Debug9x"
 # Name "testutillib - x64 Release"
 # Name "testutillib - x64 Debug"
 # Begin Group "testall Source Files"
diff --git a/srclib/apr-util/test/testxml.c b/srclib/apr-util/test/testxml.c
index c9554de8..eed10672 100644
--- a/srclib/apr-util/test/testxml.c
+++ b/srclib/apr-util/test/testxml.c
@@ -28,8 +28,8 @@ static apr_status_t create_dummy_file_error(abts_case *tc, apr_pool_t *p,
     apr_off_t off = 0L;
     char template[] = "data/testxmldummyerrorXXXXXX";
 
-    rv = apr_file_mktemp(fd, template, APR_CREATE | APR_TRUNCATE | APR_DELONCLOSE |
-                         APR_READ | APR_WRITE | APR_EXCL, p);
+    rv = apr_file_mktemp(fd, template, APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE | APR_FOPEN_DELONCLOSE |
+                         APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_EXCL, p);
     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 
     if (rv != APR_SUCCESS)
@@ -62,8 +62,8 @@ static apr_status_t create_dummy_file(abts_case *tc, apr_pool_t *p,
     apr_off_t off = 0L;
     char template[] = "data/testxmldummyXXXXXX";
 
-    rv = apr_file_mktemp(fd, template, APR_CREATE | APR_TRUNCATE | APR_DELONCLOSE |
-                         APR_READ | APR_WRITE | APR_EXCL, p);
+    rv = apr_file_mktemp(fd, template, APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE | APR_FOPEN_DELONCLOSE |
+                         APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_EXCL, p);
     ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
 
     if (rv != APR_SUCCESS)