diff options
Diffstat (limited to 'os/win32')
| -rw-r--r-- | os/win32/BaseAddr.ref | 134 | ||||
| -rw-r--r-- | os/win32/Makefile.in | 5 | ||||
| -rw-r--r-- | os/win32/ap_regkey.c | 642 | ||||
| -rw-r--r-- | os/win32/modules.c | 56 | ||||
| -rw-r--r-- | os/win32/os.h | 139 | ||||
| -rw-r--r-- | os/win32/util_win32.c | 148 | ||||
| -rw-r--r-- | os/win32/win32_config_layout.h | 31 |
7 files changed, 1155 insertions, 0 deletions
diff --git a/os/win32/BaseAddr.ref b/os/win32/BaseAddr.ref new file mode 100644 index 0000000..7a9678a --- /dev/null +++ b/os/win32/BaseAddr.ref @@ -0,0 +1,134 @@ +; 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
\ 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..407c144 --- /dev/null +++ b/os/win32/os.h @@ -0,0 +1,139 @@ +/* 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); + +PSECURITY_ATTRIBUTES GetNullACL(void); +void CleanNullACL(void *sa); + +#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..86bd419 --- /dev/null +++ b/os/win32/util_win32.c @@ -0,0 +1,148 @@ +/* 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); +} + + +/* To share the semaphores with other processes, we need a NULL ACL + * Code from MS KB Q106387 + */ +PSECURITY_ATTRIBUTES GetNullACL(void) +{ + PSECURITY_DESCRIPTOR pSD; + PSECURITY_ATTRIBUTES sa; + + sa = (PSECURITY_ATTRIBUTES) LocalAlloc(LPTR, sizeof(SECURITY_ATTRIBUTES)); + sa->nLength = sizeof(SECURITY_ATTRIBUTES); + + pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, SECURITY_DESCRIPTOR_MIN_LENGTH); + sa->lpSecurityDescriptor = pSD; + + if (pSD == NULL || sa == NULL) { + return NULL; + } + apr_set_os_error(0); + if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION) + || apr_get_os_error()) { + LocalFree( pSD ); + LocalFree( sa ); + return NULL; + } + if (!SetSecurityDescriptorDacl(pSD, TRUE, (PACL) NULL, FALSE) + || apr_get_os_error()) { + LocalFree( pSD ); + LocalFree( sa ); + return NULL; + } + + sa->bInheritHandle = FALSE; + return sa; +} + + +void CleanNullACL(void *sa) +{ + if (sa) { + LocalFree(((PSECURITY_ATTRIBUTES)sa)->lpSecurityDescriptor); + LocalFree(sa); + } +} 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 */ |