Adding upstream version 2.4.56.upstream/2.4.56upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

7 files changed, 1108 insertions, 0 deletions

diff --git a/os/win32/BaseAddr.ref b/os/win32/BaseAddr.ref
new file mode 100644
index 0000000..569552a
--- /dev/null
+++ b/os/win32/BaseAddr.ref
@@ -0,0 +1,135 @@
+; os/win32/BaseAddr.ref contains the central repository
+;                       of all module base addresses
+;                       to avoid relocation
+
+; WARNING: Update this file by reviewing the image size
+;          of the debug-generated dll files; release images
+;          should fit in the larger debug-sized space.
+
+; module name             base-address      max-size
+
+libhttpd.dll                0x6FF00000    0x000E0000
+mod_auth_basic.so           0x6FFE0000    0x00020000
+mod_auth_digest.so          0x70000000    0x00020000
+mod_cern_meta.so            0x70020000    0x00010000
+mod_expires.so              0x70030000    0x00010000
+mod_headers.so              0x70040000    0x00020000
+mod_info.so                 0x70060000    0x00020000
+mod_rewrite.so              0x70080000    0x00030000
+mod_speling.so              0x700B0000    0x00010000
+mod_status.so               0x700C0000    0x00020000
+mod_usertrack.so            0x700E0000    0x00010000
+mod_file_cache.so           0x700F0000    0x00020000
+mod_unique_id.so            0x70110000    0x00010000
+mod_vhost_alias.so          0x70120000    0x00010000
+mod_mime_magic.so           0x70130000    0x00020000
+mod_dav.so                  0x70150000    0x00040000
+mod_dav_fs.so               0x70190000    0x00030000
+mod_proxy_connect.so        0x701C0000    0x00020000
+mod_proxy_ftp.so            0x701E0000    0x00020000
+mod_proxy_http.so           0x70200000    0x00020000
+mod_ssl.so                  0x70220000    0x00070000
+mod_actions.so              0x70290000    0x00010000
+mod_alias.so                0x702A0000    0x00020000
+mod_asis.so                 0x702C0000    0x00010000
+mod_autoindex.so            0x702D0000    0x00020000
+mod_cgi.so                  0x702F0000    0x00020000
+mod_dir.so                  0x70310000    0x00010000
+mod_env.so                  0x70320000    0x00010000
+mod_imagemap.so             0x70330000    0x00020000
+mod_include.so              0x70350000    0x00030000
+mod_isapi.so                0x70380000    0x00020000
+mod_log_config.so           0x703A0000    0x00020000
+mod_mime.so                 0x703C0000    0x00020000
+mod_negotiation.so          0x703E0000    0x00020000
+mod_setenvif.so             0x70400000    0x00020000
+mod_userdir.so              0x70420000    0x00010000
+mod_cache.so                0x70430000    0x00030000
+mod_cache_disk.so           0x70460000    0x00020000
+mod_buffer.so               0x70480000    0x00010000
+mod_deflate.so              0x70490000    0x00020000
+mod_ext_filter.so           0x704B0000    0x00020000
+mod_charset_lite.so         0x704D0000    0x00010000
+mod_authn_anon.so           0x704E0000    0x00010000
+mod_authn_dbm.so            0x704F0000    0x00010000
+mod_authn_file.so           0x70500000    0x00010000
+mod_authz_dbm.so            0x70510000    0x00010000
+mod_authz_groupfile.so      0x70520000    0x00010000
+mod_authz_host.so           0x70530000    0x00010000
+mod_authz_user.so           0x70540000    0x00010000
+mod_logio.so                0x70550000    0x00010000
+mod_ldap.so                 0x70560000    0x00030000
+mod_authnz_ldap.so          0x70590000    0x00020000
+mod_ident.so                0x705B0000    0x00010000
+mod_proxy_ajp.so            0x705C0000    0x00020000
+mod_proxy_balancer.so       0x705E0000    0x00020000
+mod_log_forensic.so         0x70600000    0x00010000
+mod_version.so              0x70610000    0x00010000
+mod_bucketeer.so            0x70620000    0x00010000
+mod_dumpio.so               0x70630000    0x00010000
+mod_echo.so                 0x70640000    0x00010000
+mod_authn_dbd.so            0x70650000    0x00010000
+mod_dbd.so                  0x70660000    0x00020000
+mod_proxy.so                0x70680000    0x00040000
+mod_access_compat.so        0x706C0000    0x00010000
+mod_authz_core.so           0x706D0000    0x00020000
+mod_proxy_fcgi.so           0x706F0000    0x00020000
+mod_authn_core.so           0x70710000    0x00010000
+mod_authz_dbd.so            0x70720000    0x00010000
+mod_authz_owner.so          0x70730000    0x00010000
+mod_example_hooks.so        0x70740000    0x00020000
+mod_case_filter.so          0x70760000    0x00010000
+mod_case_filter_in.so       0x70770000    0x00010000
+mod_substitute.so           0x70780000    0x00020000
+mod_filter.so               0x707A0000    0x00020000
+mod_dav_lock.so             0x707C0000    0x00020000
+mod_auth_form.so            0x707E0000    0x00020000
+mod_example_ipc.so          0x70800000    0x00010000
+mod_request.so              0x70810000    0x00010000
+mod_session.so              0x70830000    0x00020000
+mod_session_cookie.so       0x70850000    0x00010000
+mod_session_crypto.so       0x70860000    0x00020000
+mod_session_dbd.so          0x70880000    0x00020000
+mod_socache_dbm.so          0x708A0000    0x00020000
+mod_socache_dc.so           0x708C0000    0x00010000
+mod_socache_memcache.so     0x708D0000    0x00010000
+mod_socache_shmcb.so        0x708E0000    0x00020000
+mod_sed.so                  0x70900000    0x00020000
+mod_lua.so                  0x70920000    0x00040000
+mod_ratelimit.so            0x70960000    0x00010000
+mod_remoteip.so             0x70970000    0x00010000
+mod_lbmethod_bybusyness.so  0x70980000    0x00010000
+mod_lbmethod_byrequests.so  0x70990000    0x00010000
+mod_lbmethod_bytraffic.so   0x709A0000    0x00010000
+mod_lbmethod_heartbeat.so   0x709B0000    0x00020000
+mod_heartbeat.so            0x709D0000    0x00010000
+mod_heartmonitor.so         0x709E0000    0x00020000
+mod_watchdog.so             0x70A00000    0x00020000
+mod_proxy_scgi.so           0x70A20000    0x00020000
+mod_reqtimeout.so           0x70A40000    0x00020000
+mod_reflector.so            0x70A60000    0x00010000
+mod_slotmem_plain.so        0x70A70000    0x00010000
+mod_slotmem_shm.so          0x70A80000    0x00020000
+mod_authn_socache.so        0x70AA0000    0x00020000
+mod_proxy_express.so        0x70AC0000    0x00010000
+mod_log_debug.so            0x70AD0000    0x00010000
+mod_proxy_html.so           0x70AE0000    0x00020000
+mod_xml2enc.so              0x70B00000    0x00020000
+mod_data.so                 0x70B20000    0x00010000
+mod_allowmethods.so         0x70B30000    0x00010000
+mod_macro.so                0x70B40000    0x00020000
+mod_cache_socache.so        0x70B60000    0x00020000
+mod_proxy_wstunnel.so       0x70B80000    0x00020000
+mod_dialup.so               0x70BA0000    0x00010000
+mod_optional_fn_export.so   0x70BB0000    0x00010000
+mod_optional_fn_import.so   0x70BC0000    0x00010000
+mod_optional_hook_export.so 0x70BD0000    0x00010000
+mod_optional_hook_import.so 0x70BE0000    0x00010000
+mod_authnz_fcgi.so          0x70BF0000    0x00020000
+mod_proxy_hcheck.so         0x70C10000    0x00020000
+mod_proxy_http2.so          0x70C30000    0x00020000
+mod_http2.so                0x70C50000    0x00040000
+mod_brotli.so               0x70C90000    0x000C0000
+mod_md.so                   0x70D50000    0x00030000
+mod_proxy_uwsgi.so          0x70D80000    0x00020000
+mod_socache_redis.so        0x70DA0000    0x00010000
\ No newline at end of file
diff --git a/os/win32/Makefile.in b/os/win32/Makefile.in
new file mode 100644
index 0000000..8a16bb8
--- /dev/null
+++ b/os/win32/Makefile.in
@@ -0,0 +1,5 @@
+
+LTLIBRARY_NAME    = libos.la
+LTLIBRARY_SOURCES = util_win32.c ap_regkey.c modules.c
+
+include $(top_srcdir)/build/ltlib.mk
diff --git a/os/win32/ap_regkey.c b/os/win32/ap_regkey.c
new file mode 100644
index 0000000..13c2377
--- /dev/null
+++ b/os/win32/ap_regkey.c
@@ -0,0 +1,642 @@
+/* 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.
+ */
+
+#ifdef WIN32
+
+#include "apr.h"
+#include "arch/win32/apr_arch_file_io.h"
+#include "arch/win32/apr_arch_misc.h"
+#include "ap_regkey.h"
+
+struct ap_regkey_t {
+    apr_pool_t *pool;
+    HKEY        hkey;
+};
+
+
+AP_DECLARE(const ap_regkey_t *) ap_regkey_const(int i)
+{
+    static struct ap_regkey_t ap_regkey_consts[7] =
+    {
+        {NULL, HKEY_CLASSES_ROOT},
+        {NULL, HKEY_CURRENT_CONFIG},
+        {NULL, HKEY_CURRENT_USER},
+        {NULL, HKEY_LOCAL_MACHINE},
+        {NULL, HKEY_USERS},
+        {NULL, HKEY_PERFORMANCE_DATA},
+        {NULL, HKEY_DYN_DATA}
+    };
+    return ap_regkey_consts + i;
+}
+
+
+static apr_status_t regkey_cleanup(void *key)
+{
+    ap_regkey_t *regkey = key;
+
+    if (regkey->hkey && regkey->hkey != INVALID_HANDLE_VALUE) {
+        RegCloseKey(regkey->hkey);
+        regkey->hkey = INVALID_HANDLE_VALUE;
+    }
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_open(ap_regkey_t **newkey,
+                                        const ap_regkey_t *parentkey,
+                                        const char *keyname,
+                                        apr_int32_t flags,
+                                        apr_pool_t *pool)
+{
+    DWORD access = KEY_QUERY_VALUE;
+    DWORD exists;
+    HKEY hkey;
+    LONG rc;
+
+    if (flags & APR_READ)
+        access |= KEY_READ;
+    if (flags & APR_WRITE)
+        access |= KEY_WRITE;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t keylen = strlen(keyname) + 1;
+        apr_size_t wkeylen = 256;
+        apr_wchar_t wkeyname[256];
+        apr_status_t rv = apr_conv_utf8_to_ucs2(keyname, &keylen, wkeyname, &wkeylen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (keylen)
+            return APR_ENAMETOOLONG;
+
+        if (flags & APR_CREATE)
+            rc = RegCreateKeyExW(parentkey->hkey, wkeyname, 0, NULL, 0,
+                                 access, NULL, &hkey, &exists);
+        else
+            rc = RegOpenKeyExW(parentkey->hkey, wkeyname, 0, access, &hkey);
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        if (flags & APR_CREATE)
+            rc = RegCreateKeyEx(parentkey->hkey, keyname, 0, NULL, 0,
+                                access, NULL, &hkey, &exists);
+        else
+            rc = RegOpenKeyEx(parentkey->hkey, keyname, 0, access, &hkey);
+    }
+#endif
+    if (rc != ERROR_SUCCESS) {
+        return APR_FROM_OS_ERROR(rc);
+    }
+    if ((flags & APR_EXCL) && (exists == REG_OPENED_EXISTING_KEY)) {
+        RegCloseKey(hkey);
+        return APR_EEXIST;
+    }
+
+    *newkey = apr_palloc(pool, sizeof(**newkey));
+    (*newkey)->pool = pool;
+    (*newkey)->hkey = hkey;
+    apr_pool_cleanup_register((*newkey)->pool, (void *)(*newkey),
+                              regkey_cleanup, apr_pool_cleanup_null);
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_close(ap_regkey_t *regkey)
+{
+    apr_status_t stat;
+    if ((stat = regkey_cleanup(regkey)) == APR_SUCCESS) {
+        apr_pool_cleanup_kill(regkey->pool, regkey, regkey_cleanup);
+    }
+    return stat;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_remove(const ap_regkey_t *parent,
+                                          const char *keyname,
+                                          apr_pool_t *pool)
+{
+    LONG rc;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t keylen = strlen(keyname) + 1;
+        apr_size_t wkeylen = 256;
+        apr_wchar_t wkeyname[256];
+        apr_status_t rv = apr_conv_utf8_to_ucs2(keyname, &keylen, wkeyname, &wkeylen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (keylen)
+            return APR_ENAMETOOLONG;
+        rc = RegDeleteKeyW(parent->hkey, wkeyname);
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* We need to determine if subkeys exist on Win9x, to provide
+         * consistent behavior with NT, which returns access denied
+         * if subkeys exist when attempting to delete a key.
+         */
+        DWORD subkeys;
+        HKEY hkey;
+        rc = RegOpenKeyEx(parent->hkey, keyname, 0, KEY_READ, &hkey);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+        rc = RegQueryInfoKey(hkey, NULL, NULL, NULL, &subkeys, NULL, NULL,
+                             NULL, NULL, NULL, NULL, NULL);
+        RegCloseKey(hkey);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+        else if (subkeys)
+            return APR_FROM_OS_ERROR(ERROR_ACCESS_DENIED);
+        rc = RegDeleteKey(parent->hkey, keyname);
+    }
+#endif
+    if (rc != ERROR_SUCCESS) {
+        return APR_FROM_OS_ERROR(rc);
+    }
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_value_get(char **result,
+                                             ap_regkey_t *key,
+                                             const char *valuename,
+                                             apr_pool_t *pool)
+{
+    /* Retrieve a registry string value, and explode any envvars
+     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
+     */
+    LONG rc;
+    DWORD type;
+    apr_size_t size = 0;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t valuelen = strlen(valuename) + 1;
+        apr_size_t wvallen = 256;
+        apr_wchar_t wvalname[256];
+        apr_wchar_t *wvalue;
+        apr_status_t rv;
+        rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (valuelen)
+            return APR_ENAMETOOLONG;
+        /* Read to NULL buffer to determine value size */
+        rc = RegQueryValueExW(key->hkey, wvalname, 0, &type, NULL, (DWORD *)&size);
+        if (rc != ERROR_SUCCESS) {
+            return APR_FROM_OS_ERROR(rc);
+        }
+        if ((size < 2) || (type != REG_SZ && type != REG_EXPAND_SZ)) {
+            return APR_FROM_OS_ERROR(ERROR_INVALID_PARAMETER);
+        }
+
+        wvalue = apr_palloc(pool, size);
+        /* Read value based on size query above */
+        rc = RegQueryValueExW(key->hkey, wvalname, 0, &type,
+                              (LPBYTE)wvalue, (DWORD *)&size);
+        if (rc != ERROR_SUCCESS) {
+            return APR_FROM_OS_ERROR(rc);
+        }
+        if (type == REG_EXPAND_SZ) {
+            apr_wchar_t zbuf[1];
+            size = ExpandEnvironmentStringsW(wvalue, zbuf, 0);
+            if (size) {
+                apr_wchar_t *tmp = wvalue;
+                /* The size returned by ExpandEnvironmentStringsW is wchars */
+                wvalue = apr_palloc(pool, size * 2);
+                size = ExpandEnvironmentStringsW(tmp, wvalue, (DWORD)size);
+            }
+        }
+        else {
+            /* count wchars from RegQueryValueExW, rather than bytes */
+            size /= 2;
+        }
+        /* ###: deliberately overallocate all but the trailing null.
+         * We could precalculate the exact buffer here instead, the question
+         * is a matter of storage v.s. cpu cycles.
+         */
+        valuelen = (size - 1) * 3 + 1;
+        *result = apr_palloc(pool, valuelen);
+        rv = apr_conv_ucs2_to_utf8(wvalue, &size, *result, &valuelen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (size)
+            return APR_ENAMETOOLONG;
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* Read to NULL buffer to determine value size */
+        rc = RegQueryValueEx(key->hkey, valuename, 0, &type, NULL, (DWORD *)&size);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+
+        if ((size < 1) || (type != REG_SZ && type != REG_EXPAND_SZ)) {
+            return APR_FROM_OS_ERROR(ERROR_INVALID_PARAMETER);
+        }
+
+        *result = apr_palloc(pool, size);
+        /* Read value based on size query above */
+        rc = RegQueryValueEx(key->hkey, valuename, 0, &type, *result, (DWORD *)&size);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+
+        if (type == REG_EXPAND_SZ) {
+            /* Advise ExpandEnvironmentStrings that we have a zero char
+             * buffer to force computation of the required length.
+             */
+            char zbuf[1];
+            size = ExpandEnvironmentStrings(*result, zbuf, 0);
+            if (size) {
+                char *tmp = *result;
+                *result = apr_palloc(pool, size);
+                size = ExpandEnvironmentStrings(tmp, *result, (DWORD)size);
+            }
+        }
+    }
+#endif
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_value_set(ap_regkey_t *key,
+                                             const char *valuename,
+                                             const char *value,
+                                             apr_int32_t flags,
+                                             apr_pool_t *pool)
+{
+    /* Retrieve a registry string value, and explode any envvars
+     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
+     */
+    LONG rc;
+    apr_size_t size = strlen(value) + 1;
+    DWORD type = (flags & AP_REGKEY_EXPAND) ? REG_EXPAND_SZ : REG_SZ;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t alloclen;
+        apr_size_t valuelen = strlen(valuename) + 1;
+        apr_size_t wvallen = 256;
+        apr_wchar_t wvalname[256];
+        apr_wchar_t *wvalue;
+        apr_status_t rv;
+        rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (valuelen)
+            return APR_ENAMETOOLONG;
+
+        wvallen = alloclen = size;
+        wvalue = apr_palloc(pool, alloclen * 2);
+        rv = apr_conv_utf8_to_ucs2(value, &size, wvalue, &wvallen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (size)
+            return APR_ENAMETOOLONG;
+
+        /* The size is the number of wchars consumed by apr_conv_utf8_to_ucs2
+         * converted to bytes; the trailing L'\0' continues to be counted.
+         */
+        size = (alloclen - wvallen) * 2;
+        rc = RegSetValueExW(key->hkey, wvalname, 0, type,
+                            (LPBYTE)wvalue, (DWORD)size);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        rc = RegSetValueEx(key->hkey, valuename, 0, type, value, (DWORD)size);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+    }
+#endif
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_value_raw_get(void **result,
+                                                 apr_size_t *resultsize,
+                                                 apr_int32_t *resulttype,
+                                                 ap_regkey_t *key,
+                                                 const char *valuename,
+                                                 apr_pool_t *pool)
+{
+    /* Retrieve a registry string value, and explode any envvars
+     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
+     */
+    LONG rc;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t valuelen = strlen(valuename) + 1;
+        apr_size_t wvallen = 256;
+        apr_wchar_t wvalname[256];
+        apr_status_t rv;
+        rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (valuelen)
+            return APR_ENAMETOOLONG;
+        /* Read to NULL buffer to determine value size */
+        rc = RegQueryValueExW(key->hkey, wvalname, 0, (LPDWORD)resulttype,
+                              NULL, (LPDWORD)resultsize);
+        if (rc != ERROR_SUCCESS) {
+            return APR_FROM_OS_ERROR(rc);
+        }
+
+        /* Read value based on size query above */
+        *result = apr_palloc(pool, *resultsize);
+        rc = RegQueryValueExW(key->hkey, wvalname, 0, (LPDWORD)resulttype,
+                             (LPBYTE)*result, (LPDWORD)resultsize);
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* Read to NULL buffer to determine value size */
+        rc = RegQueryValueEx(key->hkey, valuename, 0, (LPDWORD)resulttype,
+                             NULL, (LPDWORD)resultsize);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+
+        /* Read value based on size query above */
+        *result = apr_palloc(pool, *resultsize);
+        rc = RegQueryValueEx(key->hkey, valuename, 0, (LPDWORD)resulttype,
+                             (LPBYTE)*result, (LPDWORD)resultsize);
+        if (rc != ERROR_SUCCESS)
+            return APR_FROM_OS_ERROR(rc);
+    }
+#endif
+    if (rc != ERROR_SUCCESS) {
+        return APR_FROM_OS_ERROR(rc);
+    }
+
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_value_raw_set(ap_regkey_t *key,
+                                                 const char *valuename,
+                                                 const void *value,
+                                                 apr_size_t valuesize,
+                                                 apr_int32_t valuetype,
+                                                 apr_pool_t *pool)
+{
+    LONG rc;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t valuelen = strlen(valuename) + 1;
+        apr_size_t wvallen = 256;
+        apr_wchar_t wvalname[256];
+        apr_status_t rv;
+        rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (valuelen)
+            return APR_ENAMETOOLONG;
+
+        rc = RegSetValueExW(key->hkey, wvalname, 0, valuetype,
+                            (LPBYTE)value, (DWORD)valuesize);
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        rc = RegSetValueEx(key->hkey, valuename, 0, valuetype,
+                            (LPBYTE)value, (DWORD)valuesize);
+    }
+#endif
+    if (rc != ERROR_SUCCESS) {
+        return APR_FROM_OS_ERROR(rc);
+    }
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_value_array_get(apr_array_header_t **result,
+                                                   ap_regkey_t *key,
+                                                   const char *valuename,
+                                                   apr_pool_t *pool)
+{
+    /* Retrieve a registry string value, and explode any envvars
+     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
+     */
+    apr_status_t rv;
+    void *value;
+    char *buf;
+    char *tmp;
+    apr_int32_t type;
+    apr_size_t size = 0;
+
+    rv = ap_regkey_value_raw_get(&value, &size, &type, key, valuename, pool);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+    else if (type != REG_MULTI_SZ) {
+        return APR_EINVAL;
+    }
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t alloclen;
+        apr_size_t valuelen = strlen(valuename) + 1;
+
+        /* ###: deliberately overallocate plus two extra nulls.
+         * We could precalculate the exact buffer here instead, the question
+         * is a matter of storage v.s. cpu cycles.
+         */
+        size /= 2;
+        alloclen = valuelen = size * 3 + 2;
+        buf = apr_palloc(pool, valuelen);
+        rv = apr_conv_ucs2_to_utf8(value, &size, buf, &valuelen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (size)
+            return APR_ENAMETOOLONG;
+        buf[(alloclen - valuelen)] = '\0';
+        buf[(alloclen - valuelen) + 1] = '\0';
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* Small possibility the array is either unterminated
+         * or single NULL terminated.  Avert.
+         */
+        buf = (char *)value;
+        if (size < 2 || buf[size - 1] != '\0' || buf[size - 2] != '\0') {
+            buf = apr_palloc(pool, size + 2);
+            memcpy(buf, value, size);
+            buf[size + 1] = '\0';
+            buf[size] = '\0';
+        }
+    }
+#endif
+
+    size = 0;    /* Element Count */
+    for (tmp = buf; *tmp; ++tmp) {
+        ++size;
+        while (*tmp) {
+            ++tmp;
+        }
+    }
+
+    *result = apr_array_make(pool, (int)size, sizeof(char *));
+    for (tmp = buf; *tmp; ++tmp) {
+        char **newelem = (char **) apr_array_push(*result);
+        *newelem = tmp;
+        while (*tmp) {
+            ++tmp;
+        }
+    }
+
+   return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_value_array_set(ap_regkey_t *key,
+                                                   const char *valuename,
+                                                   int nelts,
+                                                   const char * const * elts,
+                                                   apr_pool_t *pool)
+{
+    /* Retrieve a registry string value, and explode any envvars
+     * that the system has configured (e.g. %SystemRoot%/someapp.exe)
+     */
+    int i;
+    const void *value;
+    apr_size_t bufsize;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_status_t rv;
+        apr_wchar_t *buf;
+        apr_wchar_t *tmp;
+        apr_size_t bufrem;
+
+        bufsize = 1; /* For trailing second null */
+        for (i = 0; i < nelts; ++i) {
+            bufsize += strlen(elts[i]) + 1;
+        }
+        if (!nelts) {
+            ++bufsize;
+        }
+
+        bufrem = bufsize;
+        buf = apr_palloc(pool, bufsize * 2);
+        tmp = buf;
+        for (i = 0; i < nelts; ++i) {
+            apr_size_t eltsize = strlen(elts[i]) + 1;
+            apr_size_t size = eltsize;
+            rv = apr_conv_utf8_to_ucs2(elts[i], &size, tmp, &bufrem);
+            if (rv != APR_SUCCESS)
+                return rv;
+            else if (size)
+                return APR_ENAMETOOLONG;
+            tmp += eltsize;
+        }
+        if (!nelts) {
+            --bufrem;
+            (*tmp++) = L'\0';
+        }
+        --bufrem;
+        *tmp = L'\0'; /* Trailing second null */
+
+        bufsize = (bufsize - bufrem) * 2;
+        value = (void*)buf;
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        char *buf;
+        char *tmp;
+
+        bufsize = 1; /* For trailing second null */
+        for (i = 0; i < nelts; ++i) {
+            bufsize += strlen(elts[i]) + 1;
+        }
+        if (!nelts) {
+            ++bufsize;
+        }
+        buf = apr_palloc(pool, bufsize);
+        tmp = buf;
+        for (i = 0; i < nelts; ++i) {
+            apr_size_t len = strlen(elts[i]) + 1;
+            memcpy(tmp, elts[i], len);
+            tmp += len;
+        }
+        if (!nelts) {
+            (*tmp++) = '\0';
+        }
+        *tmp = '\0'; /* Trailing second null */
+        value = buf;
+    }
+#endif
+    return ap_regkey_value_raw_set(key, valuename, value,
+                                   bufsize, REG_MULTI_SZ, pool);
+}
+
+
+AP_DECLARE(apr_status_t) ap_regkey_value_remove(const ap_regkey_t *key,
+                                                const char *valuename,
+                                                apr_pool_t *pool)
+{
+    LONG rc;
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t valuelen = strlen(valuename) + 1;
+        apr_size_t wvallen = 256;
+        apr_wchar_t wvalname[256];
+        apr_status_t rv = apr_conv_utf8_to_ucs2(valuename, &valuelen, wvalname, &wvallen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (valuelen)
+            return APR_ENAMETOOLONG;
+        rc = RegDeleteValueW(key->hkey, wvalname);
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        rc = RegDeleteValue(key->hkey, valuename);
+    }
+#endif
+    if (rc != ERROR_SUCCESS) {
+        return APR_FROM_OS_ERROR(rc);
+    }
+    return APR_SUCCESS;
+}
+
+#endif /* defined WIN32 */
diff --git a/os/win32/modules.c b/os/win32/modules.c
new file mode 100644
index 0000000..9c3410e
--- /dev/null
+++ b/os/win32/modules.c
@@ -0,0 +1,56 @@
+/* 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.
+ */
+
+/* modules.c --- major modules compiled into Apache for Win32.
+ * Only insert an entry for a module if it must be compiled into
+ * the core server
+ */
+
+#include "httpd.h"
+#include "http_config.h"
+
+extern module core_module;
+extern module win32_module;
+extern module mpm_winnt_module;
+extern module http_module;
+extern module so_module;
+
+AP_DECLARE_DATA module *ap_prelinked_modules[] = {
+  &core_module, /* core must come first */
+  &win32_module,
+  &mpm_winnt_module,
+  &http_module,
+  &so_module,
+  NULL
+};
+
+ap_module_symbol_t ap_prelinked_module_symbols[] = {
+  {"core_module", &core_module},
+  {"win32_module", &win32_module},
+  {"mpm_winnt_module", &mpm_winnt_module},
+  {"http_module", &http_module},
+  {"so_module", &so_module},
+  {NULL, NULL}
+};
+
+AP_DECLARE_DATA module *ap_preloaded_modules[] = {
+  &core_module,
+  &win32_module,
+  &mpm_winnt_module,
+  &http_module,
+  &so_module,
+  NULL
+};
diff --git a/os/win32/os.h b/os/win32/os.h
new file mode 100644
index 0000000..3a32af5
--- /dev/null
+++ b/os/win32/os.h
@@ -0,0 +1,136 @@
+/* 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.
+ */
+
+/**
+ * @file win32/os.h
+ * @brief This file in included in all Apache source code. It contains definitions
+ * of facilities available on _this_ operating system (HAVE_* macros),
+ * and prototypes of OS specific functions defined in os.c or os-inline.c
+ *
+ * @defgroup APACHE_OS_WIN32 win32
+ * @ingroup  APACHE_OS
+ * @{
+ */
+
+#ifdef WIN32
+
+#ifndef AP_OS_H
+#define AP_OS_H
+/* Delegate windows include to the apr.h header, if USER or GDI declarations
+ * are required (for a window rather than console application), include
+ * windows.h prior to any other Apache header files.
+ */
+#include "apr_pools.h"
+
+#include <io.h>
+#include <fcntl.h>
+
+#ifdef _WIN64
+#define PLATFORM "Win64"
+#else
+#define PLATFORM "Win32"
+#endif
+
+/* Define command-line rewriting for this platform, handled by core.
+ * For Windows, this is currently handled inside the WinNT MPM.
+ * XXX To support a choice of MPMs, extract common platform behavior
+ * into a function specified here.
+ */
+#define AP_PLATFORM_REWRITE_ARGS_HOOK NULL
+
+/* going away shortly... */
+#define HAVE_DRIVE_LETTERS
+#define HAVE_UNC_PATHS
+#define CASE_BLIND_FILESYSTEM
+
+#include <stddef.h>
+#include <stdlib.h> /* for exit() */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BIG RED WARNING: exit() is mapped to allow us to capture the exit
+ * status.  This header must only be included from modules linked into
+ * the ApacheCore.dll - since it's a horrible behavior to exit() from
+ * any module outside the main() block, and we -will- assume it's a
+ * fatal error.
+ */
+
+AP_DECLARE_DATA extern int ap_real_exit_code;
+
+#define exit(status) ((exit)((ap_real_exit_code==2) \
+                                ? (ap_real_exit_code = (status)) \
+                                : ((ap_real_exit_code = 0), (status))))
+
+#ifdef AP_DECLARE_EXPORT
+
+/* Defined in util_win32.c and available only to the core module for
+ * win32 MPM design.
+ */
+
+AP_DECLARE(apr_status_t) ap_os_proc_filepath(char **binpath, apr_pool_t *p);
+
+typedef enum {
+    AP_DLL_WINBASEAPI = 0,    /* kernel32 From WinBase.h      */
+    AP_DLL_WINADVAPI = 1,     /* advapi32 From WinBase.h      */
+    AP_DLL_WINSOCKAPI = 2,    /* mswsock  From WinSock.h      */
+    AP_DLL_WINSOCK2API = 3,   /* ws2_32   From WinSock2.h     */
+    AP_DLL_defined = 4        /* must define as last idx_ + 1 */
+} ap_dlltoken_e;
+
+FARPROC ap_load_dll_func(ap_dlltoken_e fnLib, char* fnName, int ordinal);
+
+#define AP_DECLARE_LATE_DLL_FUNC(lib, rettype, calltype, fn, ord, args, names) \
+    typedef rettype (calltype *ap_winapi_fpt_##fn) args; \
+    static ap_winapi_fpt_##fn ap_winapi_pfn_##fn = NULL; \
+    static APR_INLINE rettype ap_winapi_##fn args \
+    {   if (!ap_winapi_pfn_##fn) \
+            ap_winapi_pfn_##fn = (ap_winapi_fpt_##fn) ap_load_dll_func(lib, #fn, ord); \
+        return (*(ap_winapi_pfn_##fn)) names; }; \
+
+/* Win2K kernel only */
+AP_DECLARE_LATE_DLL_FUNC(AP_DLL_WINADVAPI, BOOL, WINAPI, ChangeServiceConfig2A, 0, (
+    SC_HANDLE hService,
+    DWORD dwInfoLevel,
+    LPVOID lpInfo),
+    (hService, dwInfoLevel, lpInfo));
+#undef ChangeServiceConfig2
+#define ChangeServiceConfig2 ap_winapi_ChangeServiceConfig2A
+
+/* WinNT kernel only */
+AP_DECLARE_LATE_DLL_FUNC(AP_DLL_WINBASEAPI, BOOL, WINAPI, CancelIo, 0, (
+    IN HANDLE hFile),
+    (hFile));
+#undef CancelIo
+#define CancelIo ap_winapi_CancelIo
+
+/* Win9x kernel only */
+AP_DECLARE_LATE_DLL_FUNC(AP_DLL_WINBASEAPI, DWORD, WINAPI, RegisterServiceProcess, 0, (
+    DWORD dwProcessId,
+    DWORD dwType),
+    (dwProcessId, dwType));
+#define RegisterServiceProcess ap_winapi_RegisterServiceProcess
+
+#endif /* def AP_DECLARE_EXPORT */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* ndef AP_OS_H */
+#endif  /* def WIN32 */
+/** @} */
diff --git a/os/win32/util_win32.c b/os/win32/util_win32.c
new file mode 100644
index 0000000..728e4b5
--- /dev/null
+++ b/os/win32/util_win32.c
@@ -0,0 +1,103 @@
+/* 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 "apr_strings.h"
+#include "arch/win32/apr_arch_file_io.h"
+#include "arch/win32/apr_arch_misc.h"
+
+#include "httpd.h"
+#include "http_log.h"
+#include "ap_mpm.h"
+
+#include <stdarg.h>
+#include <time.h>
+#include <stdlib.h>
+
+
+AP_DECLARE(apr_status_t) ap_os_proc_filepath(char **binpath, apr_pool_t *p)
+{
+    apr_wchar_t wbinpath[APR_PATH_MAX];
+
+#if APR_HAS_UNICODE_FS
+    IF_WIN_OS_IS_UNICODE
+    {
+        apr_size_t binlen;
+        apr_size_t wbinlen;
+        apr_status_t rv;
+        if (!GetModuleFileNameW(NULL, wbinpath, sizeof(wbinpath)
+                                              / sizeof(apr_wchar_t))) {
+            return apr_get_os_error();
+        }
+        wbinlen = wcslen(wbinpath) + 1;
+        binlen = (wbinlen - 1) * 3 + 1;
+        *binpath = apr_palloc(p, binlen);
+        rv = apr_conv_ucs2_to_utf8(wbinpath, &wbinlen, *binpath, &binlen);
+        if (rv != APR_SUCCESS)
+            return rv;
+        else if (wbinlen)
+            return APR_ENAMETOOLONG;
+    }
+#endif /* APR_HAS_UNICODE_FS */
+#if APR_HAS_ANSI_FS
+    ELSE_WIN_OS_IS_ANSI
+    {
+        /* share the same scratch buffer */
+        char *pathbuf = (char*) wbinpath;
+        if (!GetModuleFileName(NULL, pathbuf, sizeof(wbinpath))) {
+            return apr_get_os_error();
+        }
+        *binpath = apr_pstrdup(p, pathbuf);
+    }
+#endif
+    return APR_SUCCESS;
+}
+
+
+AP_DECLARE(apr_status_t) ap_os_create_privileged_process(
+    const request_rec *r,
+    apr_proc_t *newproc, const char *progname,
+    const char * const *args,
+    const char * const *env,
+    apr_procattr_t *attr, apr_pool_t *p)
+{
+    return apr_proc_create(newproc, progname, args, env, attr, p);
+}
+
+
+/* This code is stolen from misc/win32/misc.c and apr_private.h
+ * This helper code resolves late bound entry points
+ * missing from one or more releases of the Win32 API...
+ * but it sure would be nice if we didn't duplicate this code
+ * from the APR ;-)
+ */
+static const char* const lateDllName[DLL_defined] = {
+    "kernel32", "advapi32", "mswsock",  "ws2_32"  };
+static HMODULE lateDllHandle[DLL_defined] = {
+    NULL,       NULL,       NULL,       NULL      };
+
+
+FARPROC ap_load_dll_func(ap_dlltoken_e fnLib, char* fnName, int ordinal)
+{
+    if (!lateDllHandle[fnLib]) {
+        lateDllHandle[fnLib] = LoadLibrary(lateDllName[fnLib]);
+        if (!lateDllHandle[fnLib])
+            return NULL;
+    }
+    if (ordinal)
+        return GetProcAddress(lateDllHandle[fnLib], (char *) ordinal);
+    else
+        return GetProcAddress(lateDllHandle[fnLib], fnName);
+}
diff --git a/os/win32/win32_config_layout.h b/os/win32/win32_config_layout.h
new file mode 100644
index 0000000..5f770a2
--- /dev/null
+++ b/os/win32/win32_config_layout.h
@@ -0,0 +1,31 @@
+/* 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.
+ */
+
+/**
+ * @file win32/win32_config_layout.h
+ * @brief This provides layout definitions for non-autoconf-based Windows
+ * builds, and is copied to include/ap_config_layout.h during the build.
+ */
+
+#ifndef AP_CONFIG_LAYOUT_H
+#define AP_CONFIG_LAYOUT_H
+
+/* Check for definition of DEFAULT_REL_RUNTIMEDIR */
+#ifndef DEFAULT_REL_RUNTIMEDIR
+#define DEFAULT_REL_RUNTIMEDIR "logs"
+#endif
+
+#endif /* AP_CONFIG_LAYOUT_H */