From 30ab960e20117ee6002a3297791427023440e0a7 Mon Sep 17 00:00:00 2001 From: "William A. Rowe Jr" Date: Tue, 14 May 2002 05:23:54 +0000 Subject: [PATCH] Now for the major refactoring. Introduce mod_isapi.h, as we have had untold problems with compatibility between different Visual Studio and PlatformSDK users [based on their generation of the MS ISAPI header.] This header is coded from scratch in native APR types. Replace the apr_array_t with an apr_hash_t, mutex protected, to allow us to preload and late-load isapi modules. This closes a significant bug with trafficed sites using uncached isapi modules, where one would be closing the module just as another request is opening it [as if for the first time.] This would cause some ISAPI modules to crash. Now that we load modules for the lifetime of the server, a simple graceful restart is all that's required to unload all the non-precached modules. Crack out all FAKE_ASYNC code while we complete it. Total support for the Completion Context callback and end-of-request termination is required before we can toggle this on. My next commit; complete fake async support. But this was all I'd had in me for one night. git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@95077 13f79535-47bb-0310-9956-ffa450edef68 --- modules/arch/win32/mod_isapi.c | 730 +++++++++++++++++++------------ modules/arch/win32/mod_isapi.dsp | 4 + modules/arch/win32/mod_isapi.h | 280 ++++++++++++ 3 files changed, 730 insertions(+), 284 deletions(-) create mode 100644 modules/arch/win32/mod_isapi.h diff --git a/modules/arch/win32/mod_isapi.c b/modules/arch/win32/mod_isapi.c index e1abcedc97..29e759449a 100644 --- a/modules/arch/win32/mod_isapi.c +++ b/modules/arch/win32/mod_isapi.c @@ -58,26 +58,25 @@ /* * mod_isapi.c - Internet Server Application (ISA) module for Apache - * by Alexei Kosut + * by Alexei Kosut , significant overhauls and + * redesign by William Rowe , and hints from many + * other developer/users who have hit on specific flaws. * - * This module implements Microsoft's ISAPI, allowing Apache (when running - * under Windows) to load Internet Server Applications (ISAPI extensions). - * It implements all of the ISAPI 2.0 specification, except for the - * "Microsoft-only" extensions dealing with asynchronous I/O. All ISAPI - * extensions that use only synchronous I/O and are compatible with the - * ISAPI 2.0 specification should work (most ISAPI 1.0 extensions should - * function as well). + * This module implements the ISAPI Handler architecture, allowing + * Apache to load Internet Server Applications (ISAPI extensions), + * similar to the support in IIS, Zope, O'Reilly's WebSite and others. * - * To load, simply place the ISA in a location in the document tree. - * Then add an "AddHandler isapi-isa dll" into your config file. - * You should now be able to load ISAPI DLLs just be reffering to their - * URLs. Make sure the ExecCGI option is active in the directory - * the ISA is in. + * It is a complete implementation of the ISAPI 2.0 specification, + * except for "Microsoft extensions" to the API which provide + * asynchronous I/O. It is further extended to include additional + * "Microsoft extentions" through IIS 5.0, with some deficiencies + * where one-to-one mappings don't exist. + * + * Refer to /manual/mod/mod_isapi.html for additional details on + * configuration and use, but check this source for specific support + * of the API, */ -#include "apr_strings.h" -#include "apr_portable.h" -#include "apr_buckets.h" #include "ap_config.h" #include "httpd.h" #include "http_config.h" @@ -87,18 +86,17 @@ #include "http_log.h" #include "util_script.h" #include "mod_core.h" +#include "apr_strings.h" +#include "apr_portable.h" +#include "apr_buckets.h" +#include "apr_thread_mutex.h" +#include "apr_thread_rwlock.h" +#include "apr_hash.h" +#include "mod_isapi.h" -/* We use the exact same header file as the original */ -#include +/* Retry frequency for a failed-to-load isapi .dll */ +#define ISAPI_RETRY ( 30 * APR_USEC_PER_SEC ) -#if !defined(HSE_REQ_MAP_URL_TO_PATH_EX) \ - || !defined(HSE_REQ_SEND_RESPONSE_HEADER_EX) -#pragma message("WARNING: This build of Apache is missing the recent changes") -#pragma message("in the Microsoft Win32 Platform SDK; some mod_isapi features") -#pragma message("will be disabled. To obtain the latest Platform SDK files,") -#pragma message("please refer to:") -#pragma message("http://msdn.microsoft.com/downloads/sdks/platform/platform.asp") -#endif /********************************************************** * @@ -110,12 +108,6 @@ module AP_MODULE_DECLARE_DATA isapi_module; #define ISAPI_UNDEF -1 -/* Our isapi global config values */ -static struct isapi_global_conf { - apr_pool_t *pool; - apr_array_header_t *modules; -} loaded; - /* Our isapi per-dir config structure */ typedef struct isapi_dir_conf { int read_ahead_buflen; @@ -126,8 +118,8 @@ typedef struct isapi_dir_conf { typedef struct isapi_loaded isapi_loaded; -static apr_status_t isapi_load(apr_pool_t *p, request_rec *r, - const char *fpath, isapi_loaded** isa); +apr_status_t isapi_lookup(apr_pool_t *p, server_rec *s, request_rec *r, + const char *fpath, isapi_loaded** isa); static void *create_isapi_dir_config(apr_pool_t *p, char *dummy) { @@ -166,41 +158,45 @@ static void *merge_isapi_dir_configs(apr_pool_t *p, void *base_, void *add_) static const char *isapi_cmd_cachefile(cmd_parms *cmd, void *dummy, const char *filename) { - isapi_loaded *isa, **newisa; + isapi_loaded *isa; apr_finfo_t tmp; apr_status_t rv; char *fspec; - + + /* ### Just an observation ... it would be terribly cool to be + * able to use this per-dir, relative to the directory block being + * defined. The hash result remains global, but shorthand of + * + * ISAPICacheFile myapp.dll anotherapp.dll thirdapp.dll + * + * would be very convienent. + */ fspec = ap_server_root_relative(cmd->pool, filename); if (!fspec) { ap_log_error(APLOG_MARK, APLOG_WARNING, APR_EBADPATH, cmd->server, - "ISAPI: Invalid module path %s, skipping", filename); + "ISAPI: invalid module path, skipping %s", filename); return NULL; } if ((rv = apr_stat(&tmp, fspec, APR_FINFO_TYPE, cmd->temp_pool)) != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_WARNING, rv, cmd->server, - "ISAPI: unable to stat(%s), skipping", fspec); + "ISAPI: unable to stat, skipping %s", fspec); return NULL; } if (tmp.filetype != APR_REG) { ap_log_error(APLOG_MARK, APLOG_WARNING|APLOG_NOERRNO, 0, cmd->server, - "ISAPI: %s isn't a regular file, skipping", fspec); + "ISAPI: not a regular file, skipping %s", fspec); return NULL; } - /* Load the extention as cached (passing NULL for r) */ - rv = isapi_load(loaded.pool, NULL, fspec, &isa); + /* Load the extention as cached (with null request_rec) */ + rv = isapi_lookup(cmd->pool, cmd->server, NULL, fspec, &isa); if (rv != APR_SUCCESS) { ap_log_error(APLOG_MARK, APLOG_WARNING, rv, cmd->server, - "ISAPI: unable to cache %s, skipping", fspec); + "ISAPI: unable to cache, skipping %s", fspec); return NULL; } - /* Add to cached list of loaded modules */ - newisa = apr_array_push(loaded.modules); - *newisa = isa; - return NULL; } @@ -228,142 +224,283 @@ static const command_rec isapi_cmds[] = { * **********************************************************/ +/* Our isapi global config values */ +static struct isapi_global_conf { + apr_pool_t *pool; + apr_thread_mutex_t *lock; + apr_hash_t *hash; +} loaded; + /* Our loaded isapi module description structure */ struct isapi_loaded { - const char *filename; - apr_dso_handle_t *handle; - HSE_VERSION_INFO *pVer; + const char *filename; + apr_thread_rwlock_t *in_progress; + apr_status_t last_load_rv; + apr_time_t last_load_time; + apr_dso_handle_t *handle; + HSE_VERSION_INFO *isapi_version; + apr_uint32_t report_version; PFN_GETEXTENSIONVERSION GetExtensionVersion; PFN_HTTPEXTENSIONPROC HttpExtensionProc; PFN_TERMINATEEXTENSION TerminateExtension; - int refcount; - DWORD timeout; - BOOL fakeasync; - DWORD report_version; +#ifdef FAKE_ASYNC + int fakeasync; + apr_uint32_t timeout; +#endif }; -static apr_status_t isapi_unload(isapi_loaded* isa, int force) +static apr_status_t isapi_unload(isapi_loaded *isa, int force) { /* All done with the DLL... get rid of it... * - * If optionally cached, pass HSE_TERM_ADVISORY_UNLOAD, - * and if it returns TRUE, unload, otherwise, cache it. + * If optionally cached, and we weren't asked to force the unload, + * pass HSE_TERM_ADVISORY_UNLOAD, and if it returns 1, unload, + * otherwise, leave it alone (it didn't choose to cooperate.) */ - if (((--isa->refcount > 0) && !force) || !isa->handle) + if (!isa->handle) { return APR_SUCCESS; + } if (isa->TerminateExtension) { - if (force) + if (force) { (*isa->TerminateExtension)(HSE_TERM_MUST_UNLOAD); - else if (!(*isa->TerminateExtension)(HSE_TERM_ADVISORY_UNLOAD)) + } + else if (!(*isa->TerminateExtension)(HSE_TERM_ADVISORY_UNLOAD)) { return APR_EGENERAL; + } } apr_dso_unload(isa->handle); isa->handle = NULL; return APR_SUCCESS; } -static apr_status_t cleanup_isapi(void *isa) +static apr_status_t cleanup_isapi(void *isa_) { - return isapi_unload((isapi_loaded*) isa, TRUE); + isapi_loaded* isa = (isapi_loaded*) isa_; + + /* We must force the module to unload, we are about + * to lose the isapi structure's allocation entirely. + */ + return isapi_unload(isa, 1); } -static apr_status_t isapi_load(apr_pool_t *p, request_rec *r, - const char *fpath, isapi_loaded** isa) +static apr_status_t isapi_load(apr_pool_t *p, server_rec *s, request_rec *r, isapi_loaded *isa) { - isapi_loaded **found = (isapi_loaded **)loaded.modules->elts; apr_status_t rv; - int n; - for (n = 0; n < loaded.modules->nelts; ++n) { - if (strcasecmp(fpath, (*found)->filename) == 0) { - break; - } - ++found; - } - - if (n < loaded.modules->nelts) - { - *isa = *found; - if ((*isa)->handle) - { - ++(*isa)->refcount; - return APR_SUCCESS; - } - /* Otherwise we fall through and have to reload the resource - * into this existing mod_isapi cache bucket. - */ - } - else - { - *isa = apr_pcalloc(p, sizeof(isapi_module)); - (*isa)->filename = fpath; - (*isa)->pVer = apr_pcalloc(p, sizeof(HSE_VERSION_INFO)); - - /* TODO: These need to become overrideable, so that we - * assure a given isapi can be fooled into behaving well. - */ - (*isa)->timeout = INFINITE; /* microsecs */ - (*isa)->fakeasync = TRUE; - (*isa)->report_version = MAKELONG(0, 5); /* Revision 5.0 */ - } + isa->isapi_version = apr_pcalloc(p, sizeof(HSE_VERSION_INFO)); + + /* TODO: These aught to become overrideable, so that we + * assure a given isapi can be fooled into behaving well. + * + * The tricky bit, they aren't really a per-dir sort of + * config, they will always be constant across every + * reference to the .dll no matter what context (vhost, + * location, etc) they apply to. + */ + isa->report_version = MAKELONG(0, 5); /* Revision 5.0 */ +#ifdef FAKE_ASYNC + isa->timeout = INFINITE; /* microsecs */ + isa->fakeasync = 1; +#endif - rv = apr_dso_load(&(*isa)->handle, fpath, p); + rv = apr_dso_load(&isa->handle, isa->filename, p); if (rv) { - ap_log_rerror(APLOG_MARK, APLOG_ALERT, rv, r, - "ISAPI: %s failed to load", fpath); - (*isa)->handle = NULL; + ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, + "ISAPI: failed to load %s", isa->filename); + isa->handle = NULL; return rv; } - rv = apr_dso_sym((void**)&(*isa)->GetExtensionVersion, (*isa)->handle, + rv = apr_dso_sym((void**)&isa->GetExtensionVersion, isa->handle, "GetExtensionVersion"); if (rv) { - ap_log_rerror(APLOG_MARK, APLOG_ALERT, rv, r, - "ISAPI: %s is missing GetExtensionVersion()", - fpath); - apr_dso_unload((*isa)->handle); - (*isa)->handle = NULL; + ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, + "ISAPI: missing GetExtensionVersion() in %s", + isa->filename); + apr_dso_unload(isa->handle); + isa->handle = NULL; return rv; } - rv = apr_dso_sym((void**)&(*isa)->HttpExtensionProc, (*isa)->handle, + rv = apr_dso_sym((void**)&isa->HttpExtensionProc, isa->handle, "HttpExtensionProc"); if (rv) { - ap_log_rerror(APLOG_MARK, APLOG_ALERT, rv, r, - "ISAPI: %s is missing HttpExtensionProc()", - fpath); - apr_dso_unload((*isa)->handle); - (*isa)->handle = NULL; + ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, + "ISAPI: missing HttpExtensionProc() in %s", + isa->filename); + apr_dso_unload(isa->handle); + isa->handle = NULL; return rv; } /* TerminateExtension() is an optional interface */ - rv = apr_dso_sym((void**)&(*isa)->TerminateExtension, (*isa)->handle, + rv = apr_dso_sym((void**)&isa->TerminateExtension, isa->handle, "TerminateExtension"); SetLastError(0); /* Run GetExtensionVersion() */ - if (!((*isa)->GetExtensionVersion)((*isa)->pVer)) { + if (!(isa->GetExtensionVersion)(isa->isapi_version)) { apr_status_t rv = apr_get_os_error(); - ap_log_rerror(APLOG_MARK, APLOG_ALERT, rv, r, - "ISAPI: %s call GetExtensionVersion() failed", - fpath); - apr_dso_unload((*isa)->handle); - (*isa)->handle = NULL; + ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, + "ISAPI: failed call to GetExtensionVersion() in %s", + isa->filename); + apr_dso_unload(isa->handle); + isa->handle = NULL; return rv; } - ++(*isa)->refcount; - - apr_pool_cleanup_register(p, *isa, cleanup_isapi, - apr_pool_cleanup_null); + apr_pool_cleanup_register(p, isa, cleanup_isapi, + apr_pool_cleanup_null); return APR_SUCCESS; } +apr_status_t isapi_lookup(apr_pool_t *p, server_rec *s, request_rec *r, + const char *fpath, isapi_loaded** isa) +{ + apr_status_t rv; + const char *key; + + if ((rv = apr_thread_mutex_lock(loaded.lock)) != APR_SUCCESS) { + return rv; + } + + *isa = apr_hash_get(loaded.hash, fpath, APR_HASH_KEY_STRING); + + if (*isa) { + + /* If we find this lock exists, use a set-aside copy of gainlock + * to avoid race conditions on NULLing the in_progress variable + * when the load has completed. Release the global isapi hash + * lock so other requests can proceed, then rdlock for completion + * of loading our desired dll or wrlock if we would like to retry + * loading the dll (because last_load_rv failed and retry is up.) + */ + apr_thread_rwlock_t *gainlock = (*isa)->in_progress; + + /* gainlock is NULLed after the module loads successfully. + * This free-threaded module can be used without any locking. + */ + if (!gainlock) { + rv = (*isa)->last_load_rv; + apr_thread_mutex_unlock(loaded.lock); + return rv; + } + + + if ((*isa)->last_load_rv == APR_SUCCESS) { + apr_thread_mutex_unlock(loaded.lock); + if ((rv = apr_thread_rwlock_rdlock(gainlock)) + != APR_SUCCESS) { + return rv; + } + rv = (*isa)->last_load_rv; + apr_thread_rwlock_unlock(gainlock); + return rv; + } + + if (apr_time_now() > (*isa)->last_load_time + ISAPI_RETRY) { + + /* Remember last_load_time before releasing the global + * hash lock to avoid colliding with another thread + * that hit this exception at the same time as our + * retry attempt, since we unlock the global mutex + * before attempting a write lock for this module. + */ + apr_time_t check_time = (*isa)->last_load_time; + apr_thread_mutex_unlock(loaded.lock); + + if ((rv = apr_thread_rwlock_wrlock(gainlock)) + != APR_SUCCESS) { + return rv; + } + + /* If last_load_time is unchanged, we still own this + * retry, otherwise presume another thread provided + * our retry (for good or ill). Relock the global + * hash for updating last_load_ vars, so their update + * is always atomic to the global lock. + */ + if (check_time == (*isa)->last_load_time) { + + rv = isapi_load(loaded.pool, r->server, r, *isa); + + apr_thread_mutex_lock(loaded.lock); + (*isa)->last_load_rv = rv; + (*isa)->last_load_time = apr_time_now(); + apr_thread_mutex_unlock(loaded.lock); + } + else { + rv = (*isa)->last_load_rv; + } + apr_thread_rwlock_unlock(gainlock); + + return rv; + } + + /* We haven't hit timeup on retry, let's grab the last_rv + * within the hash mutex before unlocking. + */ + rv = (*isa)->last_load_rv; + apr_thread_mutex_unlock(loaded.lock); + + return rv; + } + + /* If the module was not found, it's time to create a hash key entry + * before releasing the hash lock to avoid multiple threads from + * loading the same module. + */ + key = apr_pstrdup(loaded.pool, fpath); + *isa = apr_pcalloc(loaded.pool, sizeof(isapi_loaded)); + (*isa)->filename = key; + if (r) { + /* A mutex that exists only long enough to attempt to + * load this isapi dll, the release this module to all + * other takers that came along during the one-time + * load process. Short lifetime for this lock would + * be great, however, using r->pool is nasty if those + * blocked on the lock haven't all unlocked before we + * attempt to destroy. A nastier race condition than + * I want to deal with at this moment... + */ + apr_thread_rwlock_create(&(*isa)->in_progress, loaded.pool); + apr_thread_rwlock_wrlock((*isa)->in_progress); + } + + apr_hash_set(loaded.hash, key, APR_HASH_KEY_STRING, *isa); + + /* Now attempt to load the isapi on our own time, + * allow other isapi processing to resume. + */ + apr_thread_mutex_unlock(loaded.lock); + + rv = isapi_load(loaded.pool, r->server, r, *isa); + (*isa)->last_load_time = apr_time_now(); + (*isa)->last_load_rv = rv; + + if (r && (rv == APR_SUCCESS)) { + /* Let others who are blocked on this particular + * module resume their requests, for better or worse. + */ + apr_thread_rwlock_t *unlock = (*isa)->in_progress; + (*isa)->in_progress = NULL; + apr_thread_rwlock_unlock(unlock); + } + else if (!r && (rv != APR_SUCCESS)) { + /* We must leave a rwlock around for requests to retry + * loading this dll after timeup... since we were in + * the setup code we had avoided creating this lock. + */ + apr_thread_rwlock_create(&(*isa)->in_progress, loaded.pool); + } + + return (*isa)->last_load_rv; +} + /********************************************************** * * ISAPI Module request callbacks section @@ -372,21 +509,25 @@ static apr_status_t isapi_load(apr_pool_t *p, request_rec *r, /* Our "Connection ID" structure */ typedef struct isapi_cid { - LPEXTENSION_CONTROL_BLOCK ecb; + EXTENSION_CONTROL_BLOCK *ecb; isapi_dir_conf dconf; isapi_loaded *isa; request_rec *r; +#ifdef FAKE_ASYNC PFN_HSE_IO_COMPLETION completion; PVOID completion_arg; HANDLE complete; +#endif } isapi_cid; -BOOL WINAPI GetServerVariable (HCONN hConn, LPSTR lpszVariableName, - LPVOID lpvBuffer, LPDWORD lpdwSizeofBuffer) +int APR_THREAD_FUNC GetServerVariable (isapi_cid *cid, + char *lpszVariableName, + void *lpvBuffer, + apr_uint32_t *lpdwSizeofBuffer) { - request_rec *r = ((isapi_cid *)hConn)->r; + request_rec *r = cid->r; const char *result; - DWORD len; + apr_uint32_t len; if (!strcmp(lpszVariableName, "ALL_HTTP")) { @@ -406,7 +547,7 @@ BOOL WINAPI GetServerVariable (HCONN hConn, LPSTR lpszVariableName, if (*lpdwSizeofBuffer < len + 1) { *lpdwSizeofBuffer = len + 1; SetLastError(ERROR_INSUFFICIENT_BUFFER); - return FALSE; + return 0; } for (i = 0; i < arr->nelts; i++) { @@ -422,7 +563,7 @@ BOOL WINAPI GetServerVariable (HCONN hConn, LPSTR lpszVariableName, *(((char*)lpvBuffer)++) = '\0'; *lpdwSizeofBuffer = len; - return TRUE; + return 1; } if (!strcmp(lpszVariableName, "ALL_RAW")) @@ -441,7 +582,7 @@ BOOL WINAPI GetServerVariable (HCONN hConn, LPSTR lpszVariableName, if (*lpdwSizeofBuffer < len + 1) { *lpdwSizeofBuffer = len + 1; SetLastError(ERROR_INSUFFICIENT_BUFFER); - return FALSE; + return 0; } for (i = 0; i < arr->nelts; i++) { @@ -455,7 +596,7 @@ BOOL WINAPI GetServerVariable (HCONN hConn, LPSTR lpszVariableName, } *(((char*)lpvBuffer)++) = '\0'; *lpdwSizeofBuffer = len; - return TRUE; + return 1; } /* Not a special case */ @@ -466,20 +607,22 @@ BOOL WINAPI GetServerVariable (HCONN hConn, LPSTR lpszVariableName, if (*lpdwSizeofBuffer < len + 1) { *lpdwSizeofBuffer = len + 1; SetLastError(ERROR_INSUFFICIENT_BUFFER); - return FALSE; + return 0; } strcpy(lpvBuffer, result); *lpdwSizeofBuffer = len; - return TRUE; + return 1; } /* Not Found */ SetLastError(ERROR_INVALID_INDEX); - return FALSE; + return 0; } -BOOL WINAPI WriteClient (HCONN ConnID, LPVOID Buffer, LPDWORD lpdwBytes, - DWORD dwReserved) +int APR_THREAD_FUNC WriteClient(isapi_cid *ConnID, + void *Buffer, + apr_uint32_t *lpdwBytes, + apr_uint32_t dwReserved) { request_rec *r = ((isapi_cid *)ConnID)->r; conn_rec *c = r->connection; @@ -496,13 +639,15 @@ BOOL WINAPI WriteClient (HCONN ConnID, LPVOID Buffer, LPDWORD lpdwBytes, APR_BRIGADE_INSERT_TAIL(bb, b); ap_pass_brigade(r->output_filters, bb); - return TRUE; + return 1; } -BOOL WINAPI ReadClient (HCONN ConnID, LPVOID lpvBuffer, LPDWORD lpdwSize) +int APR_THREAD_FUNC ReadClient(isapi_cid *ConnID, + void *lpvBuffer, + apr_uint32_t *lpdwSize) { request_rec *r = ((isapi_cid *)ConnID)->r; - DWORD read = 0; + apr_uint32_t read = 0; int res; if (r->remaining < *lpdwSize) { @@ -516,11 +661,16 @@ BOOL WINAPI ReadClient (HCONN ConnID, LPVOID lpvBuffer, LPDWORD lpdwSize) } *lpdwSize = read; - return TRUE; + return 1; } -static apr_ssize_t send_response_header(isapi_cid *cid, const char *stat, - const char *head, apr_size_t statlen, +/* Common code invoked for both HSE_REQ_SEND_RESPONSE_HEADER and + * the newer HSE_REQ_SEND_RESPONSE_HEADER_EX ServerSupportFunction(s) + */ +static apr_ssize_t send_response_header(isapi_cid *cid, + const char *stat, + const char *head, + apr_size_t statlen, apr_size_t headlen) { int termarg; @@ -548,7 +698,12 @@ static apr_ssize_t send_response_header(isapi_cid *cid, const char *stat, } } - /* Parse them out, or die trying */ + /* Seems IIS does not enforce the requirement for \r\n termination + * on HSE_REQ_SEND_RESPONSE_HEADER, but we won't panic... + * ap_scan_script_header_err_strs handles this aspect for us. + * + * Parse them out, or die trying + */ cid->r->status= ap_scan_script_header_err_strs(cid->r, NULL, &termch, &termarg, stat, head, NULL); cid->ecb->dwHttpStatusCode = cid->r->status; @@ -570,11 +725,12 @@ static apr_ssize_t send_response_header(isapi_cid *cid, const char *stat, return 0; } -BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, - LPVOID lpvBuffer, LPDWORD lpdwSize, - LPDWORD lpdwDataType) +int APR_THREAD_FUNC ServerSupportFunction(isapi_cid *cid, + apr_uint32_t dwHSERequest, + void *lpvBuffer, + apr_uint32_t *lpdwSize, + apr_uint32_t *lpdwDataType) { - isapi_cid *cid = (isapi_cid *)hConn; request_rec *r = cid->r; conn_rec *c = r->connection; request_rec *subreq; @@ -590,9 +746,9 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, apr_table_set (r->headers_out, "Location", lpvBuffer); cid->r->status = cid->ecb->dwHttpStatusCode = HTTP_MOVED_TEMPORARILY; - return TRUE; + return 1; - case 2: /* HSE_REQ_SEND_URL */ + case HSE_REQ_SEND_URL: /* Soak up remaining input */ if (r->remaining > 0) { char argsbuffer[HUGE_STRING_LEN]; @@ -609,9 +765,9 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, /* AV fault per PR3598 - redirected path is lost! */ (char*)lpvBuffer = apr_pstrdup(r->pool, (char*)lpvBuffer); ap_internal_redirect((char*)lpvBuffer, r); - return TRUE; + return 1; - case 3: /* HSE_REQ_SEND_RESPONSE_HEADER */ + case HSE_REQ_SEND_RESPONSE_HEADER: { /* Parse them out, or die trying */ apr_size_t statlen = 0, headlen = 0; @@ -625,7 +781,7 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, statlen, headlen); if (ate < 0) { SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; } else if ((apr_size_t)ate < headlen) { apr_bucket_brigade *bb; @@ -638,21 +794,23 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, APR_BRIGADE_INSERT_TAIL(bb, b); ap_pass_brigade(cid->r->output_filters, bb); } - return TRUE; + return 1; } - case 4: /* HSE_REQ_DONE_WITH_SESSION */ + case HSE_REQ_DONE_WITH_SESSION: /* Signal to resume the thread completing this request */ +#ifdef FAKE_ASYNC if (cid->complete) - SetEvent(cid->complete); - return TRUE; + SetEvent(cid->complete); +#endif + return 1; - case 1001: /* HSE_REQ_MAP_URL_TO_PATH */ + case HSE_REQ_MAP_URL_TO_PATH: { /* Map a URL to a filename */ char *file = (char *)lpvBuffer; - DWORD len; + apr_uint32_t len; subreq = ap_sub_req_lookup_uri(apr_pstrndup(r->pool, file, *lpdwSize), r, NULL); @@ -667,18 +825,18 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, } } *lpdwSize = len; - return TRUE; + return 1; } - case 1002: /* HSE_REQ_GET_SSPI_INFO */ + case HSE_REQ_GET_SSPI_INFO: if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: ServerSupportFunction HSE_REQ_GET_SSPI_INFO " "is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; - case 1003: /* HSE_APPEND_LOG_PARAMETER */ + case HSE_APPEND_LOG_PARAMETER: /* Log lpvBuffer, of lpdwSize bytes, in the URI Query (cs-uri-query) field */ apr_table_set(r->notes, "isapi-parameter", (char*) lpvBuffer); @@ -692,28 +850,30 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, 0, r, "ISAPI: %s: %s", cid->r->filename, (char*) lpvBuffer); - return TRUE; + return 1; - case 1005: /* HSE_REQ_IO_COMPLETION */ + case HSE_REQ_IO_COMPLETION: /* Emulates a completion port... Record callback address and * user defined arg, we will call this after any async request * (e.g. transmitfile) as if the request executed async. * Per MS docs... HSE_REQ_IO_COMPLETION replaces any prior call * to HSE_REQ_IO_COMPLETION, and lpvBuffer may be set to NULL. */ - if (!cid->isa->fakeasync) { - if (cid->dconf.log_unsupported) - ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, - "ISAPI: ServerSupportFunction HSE_REQ_IO_COMPLETION " - "is not supported: %s", r->filename); - SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; +#ifdef FAKE_ASYNC + if (cid->isa->fakeasync) { + cid->completion = (PFN_HSE_IO_COMPLETION) lpvBuffer; + cid->completion_arg = (PVOID) lpdwDataType; + return 1; } - cid->completion = (PFN_HSE_IO_COMPLETION) lpvBuffer; - cid->completion_arg = (PVOID) lpdwDataType; - return TRUE; +#endif + if (cid->dconf.log_unsupported) + ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, + "ISAPI: ServerSupportFunction HSE_REQ_IO_COMPLETION " + "is not supported: %s", r->filename); + SetLastError(ERROR_INVALID_PARAMETER); + return 0; - case 1006: /* HSE_REQ_TRANSMIT_FILE */ + case HSE_REQ_TRANSMIT_FILE: { HSE_TF_INFO *tf = (HSE_TF_INFO*)lpvBuffer; apr_status_t rv; @@ -721,17 +881,24 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, apr_bucket *b; apr_file_t *fd; - if (!cid->isa->fakeasync && (tf->dwFlags & HSE_IO_ASYNC)) { +#ifdef FAKE_ASYNC + if ((tf->dwFlags & HSE_IO_ASYNC) && cid->isa->fakeasync) { + /* TBD */ + } + else /* if (!cid->isa->fakeasync && ... */ +#endif + if (tf->dwFlags & HSE_IO_ASYNC) + { if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: ServerSupportFunction HSE_REQ_TRANSMIT_FILE " "as HSE_IO_ASYNC is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; } if ((rv = apr_os_file_put(&fd, tf->hFile, 0, r->pool)) != APR_SUCCESS) { - return FALSE; + return 0; } /* apr_dupfile_oshandle (&fd, tf->hFile, r->pool); */ @@ -756,7 +923,7 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, { apr_brigade_destroy(bb); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; } if ((apr_size_t)ate < tf->HeadLength) { @@ -790,56 +957,61 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, /* we do nothing with (tf->dwFlags & HSE_DISCONNECT_AFTER_SEND) */ +#ifdef FAKE_ASYNC if (tf->dwFlags & HSE_IO_ASYNC) { /* XXX: Fake async response, * use tf->pfnHseIO, or if NULL, then use cid->fnIOComplete * pass pContect to the HseIO callback. */ } - return TRUE; +#endif + return 1; } - case 1007: /* HSE_REQ_REFRESH_ISAPI_ACL */ + case HSE_REQ_REFRESH_ISAPI_ACL: if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: ServerSupportFunction " "HSE_REQ_REFRESH_ISAPI_ACL " "is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; - case 1008: /* HSE_REQ_IS_KEEP_CONN */ - *((LPBOOL) lpvBuffer) = (r->connection->keepalive == 1); - return TRUE; + case HSE_REQ_IS_KEEP_CONN: + *((int *)lpvBuffer) = (r->connection->keepalive == 1); + return 1; - case 1010: /* XXX: Fake it : HSE_REQ_ASYNC_READ_CLIENT */ + case HSE_REQ_ASYNC_READ_CLIENT: +#ifdef FAKE_ASYNC + /* TBD: Fake it */ +#else if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: asynchronous I/O not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; +#endif - case 1011: /* HSE_REQ_GET_IMPERSONATION_TOKEN Added in ISAPI 4.0 */ + case HSE_REQ_GET_IMPERSONATION_TOKEN: /* Added in ISAPI 4.0 */ if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: ServerSupportFunction " "HSE_REQ_GET_IMPERSONATION_TOKEN " "is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; -#ifdef HSE_REQ_MAP_URL_TO_PATH_EX - case 1012: /* HSE_REQ_MAP_URL_TO_PATH_EX */ + case HSE_REQ_MAP_URL_TO_PATH_EX: { /* Map a URL to a filename */ - LPHSE_URL_MAPEX_INFO info = (LPHSE_URL_MAPEX_INFO) lpdwDataType; + HSE_URL_MAPEX_INFO *info = (HSE_URL_MAPEX_INFO*)lpdwDataType; char* test_uri = apr_pstrndup(r->pool, (char *)lpvBuffer, *lpdwSize); subreq = ap_sub_req_lookup_uri(test_uri, r, NULL); info->cchMatchingURL = strlen(test_uri); info->cchMatchingPath = apr_cpystrn(info->lpszPath, subreq->filename, - MAX_PATH) - info->lpszPath; + sizeof(info->lpszPath)) - info->lpszPath; /* Mapping started with assuming both strings matched. * Now roll on the path_info as a mismatch and handle @@ -896,41 +1068,40 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, info->dwFlags = (subreq->finfo.protection & APR_UREAD ? 0x001 : 0) | (subreq->finfo.protection & APR_UWRITE ? 0x002 : 0) | (subreq->finfo.protection & APR_UEXECUTE ? 0x204 : 0); - return TRUE; + return 1; } -#endif - case 1014: /* HSE_REQ_ABORTIVE_CLOSE */ + case HSE_REQ_ABORTIVE_CLOSE: if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: ServerSupportFunction HSE_REQ_ABORTIVE_CLOSE" " is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; - case 1015: /* HSE_REQ_GET_CERT_INFO_EX Added in ISAPI 4.0 */ + case HSE_REQ_GET_CERT_INFO_EX: /* Added in ISAPI 4.0 */ if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: ServerSupportFunction " "HSE_REQ_GET_CERT_INFO_EX " "is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; -#ifdef HSE_REQ_SEND_RESPONSE_HEADER_EX - case 1016: /* HSE_REQ_SEND_RESPONSE_HEADER_EX Added in ISAPI 4.0 */ + case HSE_REQ_SEND_RESPONSE_HEADER_EX: /* Added in ISAPI 4.0 */ { - LPHSE_SEND_HEADER_EX_INFO shi - = (LPHSE_SEND_HEADER_EX_INFO) lpvBuffer; - /* XXX: ignore shi->fKeepConn? We shouldn't need the advise */ - /* r->connection->keepalive = shi->fKeepConn; */ + HSE_SEND_HEADER_EX_INFO *shi = (HSE_SEND_HEADER_EX_INFO*)lpvBuffer; + + /* XXX: ignore shi->fKeepConn? We shouldn't need the advise + * r->connection->keepalive = shi->fKeepConn; + */ apr_ssize_t ate = send_response_header(cid, shi->pszStatus, shi->pszHeader, shi->cchStatus, shi->cchHeader); if (ate < 0) { SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; } else if ((apr_size_t)ate < shi->cchHeader) { apr_bucket_brigade *bb; @@ -944,28 +1115,26 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, APR_BRIGADE_INSERT_TAIL(bb, b); ap_pass_brigade(cid->r->output_filters, bb); } - return TRUE; - + return 1; } -#endif - case 1017: /* HSE_REQ_CLOSE_CONNECTION Added after ISAPI 4.0 */ + case HSE_REQ_CLOSE_CONNECTION: /* Added after ISAPI 4.0 */ if (cid->dconf.log_unsupported) ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, "ISAPI: ServerSupportFunction " "HSE_REQ_CLOSE_CONNECTION " "is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; - case 1018: /* HSE_REQ_IS_CONNECTED Added after ISAPI 4.0 */ + case HSE_REQ_IS_CONNECTED: /* Added after ISAPI 4.0 */ /* Returns True if client is connected c.f. MSKB Q188346 * assuming the identical return mechanism as HSE_REQ_IS_KEEP_CONN */ - *((LPBOOL) lpvBuffer) = (r->connection->aborted == 0); - return TRUE; + *((int *)lpvBuffer) = (r->connection->aborted == 0); + return 1; - case 1020: /* HSE_REQ_EXTENSION_TRIGGER Added after ISAPI 4.0 */ + case HSE_REQ_EXTENSION_TRIGGER: /* Added after ISAPI 4.0 */ /* Undocumented - defined by the Microsoft Jan '00 Platform SDK */ if (cid->dconf.log_unsupported) @@ -974,7 +1143,7 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, "HSE_REQ_EXTENSION_TRIGGER " "is not supported: %s", r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; default: if (cid->dconf.log_unsupported) @@ -982,7 +1151,7 @@ BOOL WINAPI ServerSupportFunction(HCONN hConn, DWORD dwHSERequest, "ISAPI: ServerSupportFunction (%d) not supported: " "%s", dwHSERequest, r->filename); SetLastError(ERROR_INVALID_PARAMETER); - return FALSE; + return 0; } } @@ -1000,12 +1169,17 @@ apr_status_t isapi_handler (request_rec *r) isapi_loaded *isa; isapi_cid *cid; const char *val; - DWORD read; + apr_uint32_t read; int res; - if(strcmp(r->handler, "isapi-isa")) + if(strcmp(r->handler, "isapi-isa") + && strcmp(r->handler, "isapi-handler")) { + /* Hang on to the isapi-isa for compatibility with older docs + * (wtf did '-isa' mean in the first place?) but introduce + * a newer and clearer "isapi-handler" name. + */ return DECLINED; - + } dconf = ap_get_module_config(r->per_dir_config, &isapi_module); e = r->subprocess_env; @@ -1013,28 +1187,25 @@ apr_status_t isapi_handler (request_rec *r) * * If this fails, it's pointless to load the isapi dll. */ - if (!(ap_allow_options(r) & OPT_EXECCGI)) + if (!(ap_allow_options(r) & OPT_EXECCGI)) { return HTTP_FORBIDDEN; - - if (r->finfo.filetype == APR_NOFILE) + } + if (r->finfo.filetype == APR_NOFILE) { return HTTP_NOT_FOUND; - - if (r->finfo.filetype != APR_REG) + } + if (r->finfo.filetype != APR_REG) { return HTTP_FORBIDDEN; - + } if ((r->used_path_info == AP_REQ_REJECT_PATH_INFO) && - r->path_info && *r->path_info) - { + r->path_info && *r->path_info) { /* default to accept */ return HTTP_NOT_FOUND; } - /* Load the isapi extention without caching (pass r value) - * but note that we will recover an existing cached module. - */ - if (isapi_load(loaded.pool, r, r->filename, &isa) != APR_SUCCESS) + if (isapi_lookup(r->pool, r->server, r, r->filename, &isa) + != APR_SUCCESS) { return HTTP_INTERNAL_SERVER_ERROR; - + } /* Set up variables */ ap_add_common_vars(r); ap_add_cgi_vars(r); @@ -1047,7 +1218,7 @@ apr_status_t isapi_handler (request_rec *r) /* Set up connection structure and ecb */ cid = apr_pcalloc(r->pool, sizeof(isapi_cid)); - + /* Fixup defaults for dconf */ cid->dconf.read_ahead_buflen = (dconf->read_ahead_buflen == ISAPI_UNDEF) ? 48192 : dconf->read_ahead_buflen; @@ -1058,13 +1229,15 @@ apr_status_t isapi_handler (request_rec *r) cid->dconf.log_to_query = (dconf->log_to_query == ISAPI_UNDEF) ? 1 : dconf->log_to_query; - cid->ecb = apr_pcalloc(r->pool, sizeof(struct _EXTENSION_CONTROL_BLOCK)); - cid->ecb->ConnID = (HCONN)cid; + cid->ecb = apr_pcalloc(r->pool, sizeof(EXTENSION_CONTROL_BLOCK)); + cid->ecb->ConnID = cid; cid->isa = isa; cid->r = r; cid->r->status = 0; +#ifdef FAKE_ASYNC cid->complete = NULL; cid->completion = NULL; +#endif cid->ecb->cbSize = sizeof(EXTENSION_CONTROL_BLOCK); cid->ecb->dwVersion = isa->report_version; @@ -1090,18 +1263,17 @@ apr_status_t isapi_handler (request_rec *r) /* Set up client input */ res = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR); if (res) { - isapi_unload(isa, FALSE); + isapi_unload(isa, 0); return res; } if (ap_should_client_block(r)) { /* Time to start reading the appropriate amount of data, * and allow the administrator to tweak the number - * TODO: add the httpd.conf option for read_ahead_buflen. */ if (r->remaining) { cid->ecb->cbTotalBytes = (apr_size_t)r->remaining; - if (cid->ecb->cbTotalBytes > (DWORD)cid->dconf.read_ahead_buflen) + if (cid->ecb->cbTotalBytes > (apr_uint32_t)cid->dconf.read_ahead_buflen) cid->ecb->cbAvailable = cid->dconf.read_ahead_buflen; else cid->ecb->cbAvailable = cid->ecb->cbTotalBytes; @@ -1122,7 +1294,7 @@ apr_status_t isapi_handler (request_rec *r) } if (res < 0) { - isapi_unload(isa, FALSE); + isapi_unload(isa, 0); return HTTP_INTERNAL_SERVER_ERROR; } @@ -1154,7 +1326,7 @@ apr_status_t isapi_handler (request_rec *r) case HSE_STATUS_SUCCESS: case HSE_STATUS_SUCCESS_AND_KEEP_CONN: /* Ignore the keepalive stuff; Apache handles it just fine without - * the ISA's "advice". + * the ISAPI Handler's "advice". * Per Microsoft: "In IIS versions 4.0 and later, the return * values HSE_STATUS_SUCCESS and HSE_STATUS_SUCCESS_AND_KEEP_CONN * are functionally identical: Keep-Alive connections are @@ -1163,7 +1335,8 @@ apr_status_t isapi_handler (request_rec *r) */ break; - case HSE_STATUS_PENDING: + case HSE_STATUS_PENDING: +#ifdef FAKE_ASYNC /* emulating async behavior... * * Create a cid->completed event and wait on it for some timeout @@ -1171,25 +1344,29 @@ apr_status_t isapi_handler (request_rec *r) * * All async ServerSupportFunction calls will be handled through * the registered IO_COMPLETION hook. + * + * This request completes upon a notification through + * ServerSupportFunction(HSE_REQ_DONE_WITH_SESSION) */ - - if (!isa->fakeasync) { - if (cid->dconf.log_unsupported) - { - ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, - "ISAPI: %s asynch I/O request refused", - r->filename); - cid->r->status = HTTP_INTERNAL_SERVER_ERROR; - } - } - else { - cid->complete = CreateEvent(NULL, FALSE, FALSE, NULL); + if (isa->fakeasync) + { + cid->complete = CreateEvent(NULL, 0, 0, NULL); if (WaitForSingleObject(cid->complete, isa->timeout) == WAIT_TIMEOUT) { /* TODO: Now what... if this hung, then do we kill our own * thread to force its death? For now leave timeout = -1 */ } + break; + } +#endif + if (cid->dconf.log_unsupported) + { + ap_log_rerror(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, 0, r, + "ISAPI: asynch I/O result HSE_STATUS_PENDING " + "from HttpExtensionProc() is not supported: %s", + r->filename); + cid->r->status = HTTP_INTERNAL_SERVER_ERROR; } break; @@ -1211,9 +1388,6 @@ apr_status_t isapi_handler (request_rec *r) cid->r->status = cid->ecb->dwHttpStatusCode; } - /* All done with the DLL... get rid of it... */ - isapi_unload(isa, FALSE); - return OK; /* NOT r->status, even if it has changed. */ } @@ -1225,6 +1399,8 @@ apr_status_t isapi_handler (request_rec *r) static int isapi_pre_config(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp) { + apr_status_t rv; + apr_pool_sub_make(&loaded.pool, pconf, NULL); if (!loaded.pool) { ap_log_error(APLOG_MARK, APLOG_ERR, APR_EGENERAL, NULL, @@ -1232,40 +1408,26 @@ static int isapi_pre_config(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *pte return APR_EGENERAL; } - loaded.modules = apr_array_make(loaded.pool, 20, sizeof(isapi_loaded*)); - if (!loaded.modules) { - ap_log_error(APLOG_MARK, APLOG_ERR, APR_EGENERAL, NULL, - "ISAPI: could not create the isapi cache"); + loaded.hash = apr_hash_make(loaded.pool); + if (!loaded.hash) { + ap_log_error(APLOG_MARK, APLOG_NOERRNO, 0, NULL, + "ISAPI: Failed to create module cache"); return APR_EGENERAL; } - return OK; -} - -static int compare_loaded(const void *av, const void *bv) -{ - const isapi_loaded **a = av; - const isapi_loaded **b = bv; - - return strcmp((*a)->filename, (*b)->filename); -} - -static int isapi_post_config(apr_pool_t *p, apr_pool_t *plog, - apr_pool_t *ptemp, server_rec *s) -{ - isapi_loaded **elts = (isapi_loaded **)loaded.modules->elts; - int nelts = loaded.modules->nelts; - - /* sort the elements of the main_server, by filename */ - qsort(elts, nelts, sizeof(isapi_loaded*), compare_loaded); - + rv = apr_thread_mutex_create(&loaded.lock, APR_THREAD_MUTEX_DEFAULT, + loaded.pool); + if (rv != APR_SUCCESS) { + ap_log_error(APLOG_MARK, rv, 0, NULL, + "ISAPI: Failed to create module cache lock"); + return rv; + } return OK; } static void isapi_hooks(apr_pool_t *cont) { ap_hook_pre_config(isapi_pre_config, NULL, NULL, APR_HOOK_MIDDLE); - ap_hook_post_config(isapi_post_config, NULL, NULL, APR_HOOK_MIDDLE); ap_hook_handler(isapi_handler, NULL, NULL, APR_HOOK_MIDDLE); } diff --git a/modules/arch/win32/mod_isapi.dsp b/modules/arch/win32/mod_isapi.dsp index bf9fb802fa..4c0959192e 100644 --- a/modules/arch/win32/mod_isapi.dsp +++ b/modules/arch/win32/mod_isapi.dsp @@ -93,6 +93,10 @@ SOURCE=.\mod_isapi.c # End Source File # Begin Source File +SOURCE=.\mod_isapi.h +# End Source File +# Begin Source File + SOURCE=.\mod_isapi.rc # End Source File # Begin Source File diff --git a/modules/arch/win32/mod_isapi.h b/modules/arch/win32/mod_isapi.h new file mode 100644 index 0000000000..3a4ffd951b --- /dev/null +++ b/modules/arch/win32/mod_isapi.h @@ -0,0 +1,280 @@ +/* ==================================================================== + * The Apache Software License, Version 1.1 + * + * Copyright (c) 2000-2002 The Apache Software Foundation. All rights + * reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. The end-user documentation included with the redistribution, + * if any, must include the following acknowledgment: + * "This product includes software developed by the + * Apache Software Foundation (http://www.apache.org/)." + * Alternately, this acknowledgment may appear in the software itself, + * if and wherever such third-party acknowledgments normally appear. + * + * 4. The names "Apache" and "Apache Software Foundation" must + * not be used to endorse or promote products derived from this + * software without prior written permission. For written + * permission, please contact apache@apache.org. + * + * 5. Products derived from this software may not be called "Apache", + * nor may "Apache" appear in their name, without prior written + * permission of the Apache Software Foundation. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * ==================================================================== + * + * This software consists of voluntary contributions made by many + * individuals on behalf of the Apache Software Foundation. For more + * information on the Apache Software Foundation, please see + * . + * + * Portions of this software are based upon public domain software + * originally written at the National Center for Supercomputing Applications, + * University of Illinois, Urbana-Champaign. + */ + +#ifndef MOD_ISAPI_H +#define MOD_ISAPI_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* The Version Information storage passed to a module on startup + * via the GetExtensionVersion() entry point. + */ +typedef struct HSE_VERSION_INFO { + apr_uint32_t dwExtensionVersion; + char lpszExtensionDesc[256]; +} HSE_VERSION_INFO; + +/* The startup entry point that must be exported by every ISAPI handler + */ +int APR_THREAD_FUNC GetExtensionVersion(HSE_VERSION_INFO *ver_info); +typedef (APR_THREAD_FUNC *PFN_GETEXTENSIONVERSION)(HSE_VERSION_INFO *ver_info); + +/* Our internal 'HCONN' representation, always opaque to the user. + */ +typedef struct isapi_cid isapi_cid, *HCONN; + +/* Prototypes of the essential functions exposed by mod_isapi + * for the module to communicate with Apache. + */ +typedef int (APR_THREAD_FUNC + *PFN_GETSERVERVARIABLE)(HCONN cid, + char *variable_name, + void *buf_data, + apr_uint32_t *buf_size); +typedef int (APR_THREAD_FUNC + *PFN_WRITECLIENT)(HCONN cid, + void *buf_data, + apr_uint32_t *buf_size, + apr_uint32_t flags); +typedef int (APR_THREAD_FUNC + *PFN_READCLIENT)(HCONN cid, + void *buf_data, + apr_uint32_t *buf_size); +typedef int (APR_THREAD_FUNC + *PFN_SERVERSUPPORTFUNCTION)(HCONN cid, + apr_uint32_t HSE_code, + void *buf_data, + apr_uint32_t *buf_size, + apr_uint32_t *flags); + +/* The ecb structure is passed on each invocation of the module + */ +typedef struct EXTENSION_CONTROL_BLOCK { + apr_uint32_t cbSize; + apr_uint32_t dwVersion; + HCONN ConnID; + apr_uint32_t dwHttpStatusCode; + char lpszLogData[80]; + char *lpszMethod; + char *lpszQueryString; + char *lpszPathInfo; + char *lpszPathTranslated; + apr_uint32_t cbTotalBytes; + apr_uint32_t cbAvailable; + unsigned char *lpbData; + char *lpszContentType; + + PFN_GETSERVERVARIABLE GetServerVariable; + PFN_WRITECLIENT WriteClient; + PFN_READCLIENT ReadClient; + PFN_SERVERSUPPORTFUNCTION ServerSupportFunction; +} EXTENSION_CONTROL_BLOCK; + +/* Status/Headers structure to pass to HSE_SEND_HEADER_EX, + * an MS extension to ServerSupportFunction + */ +typedef struct HSE_SEND_HEADER_EX_INFO { + const char * pszStatus; /* HTTP status text, such as "200 OK" */ + const char * pszHeader; /* HTTP header lines text, such as + * "Content-type: text/plain\r\n" + * "Content-Language: en\r\n" + * Note that (in spite of cchFoo lengths below) + * NULL characters will interfere in headers. + */ + apr_uint32_t cchStatus; /* length of pszStatus text */ + apr_uint32_t cchHeader; /* length of pszHeader text */ + int fKeepConn; /* Ignored: used to set keep-alive status, + * but Apache follows the client's negotiated + * HTTP contract to decide. + */ +} HSE_SEND_HEADER_EX_INFO; + +/* Our only 'supported' MS extended flag bit for TransmitFile, + * HSE_IO_SEND_HEADERS indicates that Status+Headers are present + * in the pszStatusCode member of the HSE_TF_INFO structure. + */ +#define HSE_IO_SEND_HEADERS 8 + +/* The remaining flags are MS extended flag bits that bear little + * relation to Apache; the rules that the Apache server obeys follow + * its own design and HTTP protocol filter rules. + * + * We do not support async, however, we fake it. If HSE_IO_SYNC is + * not passed, and a completion context was defined, we will invoke the + * completion function immediately following the transfer, and then + * return to the caller. If HSE_IO_SYNC is passed, there is no call + * neccessary to the completion context. + */ +#define HSE_IO_SYNC 1 +#define HSE_IO_ASYNC 2 +#define HSE_IO_DISCONNECT_AFTER_SEND 4 +#define HSE_IO_NODELAY 4096 + +/* The Completion function prototype. This callback may be fixed with + * the HSE_REQ_IO_COMPLETION ServerSupportFunction call, or overriden + * for the HSE_REQ_TRANSMIT_FILE call. + */ +typedef void (APR_THREAD_FUNC *PFN_HSE_IO_COMPLETION) + (EXTENSION_CONTROL_BLOCK *ecb, + void *ctxt, + apr_uint32_t cbIO, + apr_uint32_t dwError); + +/* TransmitFile structure to pass to HSE_REQ_TRANSMIT_FILE, an MS extension + */ +typedef struct HSE_TF_INFO { + PFN_HSE_IO_COMPLETION pfnHseIO; /* Overrides the default setting of + * HSE_REQ_IO_COMPLETION if not NULL + */ + void *pContext; + apr_os_file_t hFile; /* HANDLE/fd to transmit */ + const char *pszStatusCode; /* Ignored if HSE_IO_SEND_HEADERS is + * not set. Includes HTTP status text + * plus header text lines, such as + * "200 OK\r\n" + * "Content-type: text/plain\r\n" + */ + apr_uint32_t BytesToWrite; /* 0 is write-all */ + apr_uint32_t Offset; /* File Offset */ + void *pHead; /* Prefix with *pHead body text */ + apr_uint32_t HeadLength; /* Length of *pHead body text */ + void *pTail; /* Prefix with *pTail body text */ + apr_uint32_t TailLength; /* Length of *pTail body text */ + apr_uint32_t dwFlags; /* bit flags described above */ +} HSE_TF_INFO; + +typedef struct HSE_URL_MAPEX_INFO { + char lpszPath[MAX_PATH]; + apr_uint32_t dwFlags; + apr_uint32_t cchMatchingPath; + apr_uint32_t cchMatchingURL; + apr_uint32_t dwReserved1; + apr_uint32_t dwReserved2; +} HSE_URL_MAPEX_INFO; + +/* Original ISAPI ServerSupportFunction() HSE_code methods */ +#define HSE_REQ_SEND_URL_REDIRECT_RESP 1 +#define HSE_REQ_SEND_URL 2 +#define HSE_REQ_SEND_RESPONSE_HEADER 3 +#define HSE_REQ_DONE_WITH_SESSION 4 + +/* MS Extented methods to ISAPI ServerSupportFunction() HSE_code */ +#define HSE_REQ_MAP_URL_TO_PATH 1001 /* Emulated */ +#define HSE_REQ_GET_SSPI_INFO 1002 /* Not Supported */ +#define HSE_APPEND_LOG_PARAMETER 1003 /* Supported */ +#define HSE_REQ_IO_COMPLETION 1005 /* Emulated */ +#define HSE_REQ_TRANSMIT_FILE 1006 /* Async Emulated */ +#define HSE_REQ_REFRESH_ISAPI_ACL 1007 /* Not Supported */ +#define HSE_REQ_IS_KEEP_CONN 1008 /* Supported */ +#define HSE_REQ_ASYNC_READ_CLIENT 1010 /* Emulated */ +/* Added with ISAPI 4.0 */ +#define HSE_REQ_GET_IMPERSONATION_TOKEN 1011 /* Not Supported */ +#define HSE_REQ_MAP_URL_TO_PATH_EX 1012 /* Emulated */ +#define HSE_REQ_ABORTIVE_CLOSE 1014 /* Ignored */ +/* Added after ISAPI 4.0 in IIS 5.0 */ +#define HSE_REQ_GET_CERT_INFO_EX 1015 /* Not Supported */ +#define HSE_REQ_SEND_RESPONSE_HEADER_EX 1016 /* Supported (no nulls!) */ +#define HSE_REQ_CLOSE_CONNECTION 1017 /* Ignored */ +#define HSE_REQ_IS_CONNECTED 1018 /* Supported */ +#define HSE_REQ_EXTENSION_TRIGGER 1020 /* Not Supported */ + +/* The request entry point that must be exported by every ISAPI handler + */ +apr_uint32_t APR_THREAD_FUNC HttpExtensionProc(EXTENSION_CONTROL_BLOCK *ecb); +typedef apr_uint32_t (APR_THREAD_FUNC + *PFN_HTTPEXTENSIONPROC)(EXTENSION_CONTROL_BLOCK *ecb); + +/* Allowable return values from HttpExtensionProc (apparently 0 is also + * accepted by MS IIS, and we will respect it as Success.) + * If the HttpExtensionProc returns HSE_STATUS_PENDING, we will create + * a wait mutex and lock on it, until HSE_REQ_DONE_WITH_SESSION is called. + */ +#define HSE_STATUS_SUCCESS 1 +#define HSE_STATUS_SUCCESS_AND_KEEP_CONN 2 /* 1 vs 2 Ignored, we choose */ +#define HSE_STATUS_PENDING 3 /* Emulated (thread lock) */ +#define HSE_STATUS_ERROR 4 + +/* Valid flags passed with TerminateExtension() + */ +#define HSE_TERM_MUST_UNLOAD 1 +#define HSE_TERM_ADVISORY_UNLOAD 2 + +/* The shutdown entry point óptionally exported by an ISAPI handler, passed + * HSE_TERM_MUST_UNLOAD or HSE_TERM_ADVISORY_UNLOAD. The module may return + * if passed HSE_TERM_ADVISORY_UNLOAD, and the module will remain loaded. + * If the module returns 1 to HSE_TERM_ADVISORY_UNLOAD it is immediately + * unloaded. If the module is passed HSE_TERM_MUST_UNLOAD, its return value + * is ignored. + */ +int APR_THREAD_FUNC TerminateExtension(apr_uint32_t flags); +typedef int (APR_THREAD_FUNC *PFN_TERMINATEEXTENSION)(apr_uint32_t flags); + +/* Module may return 0 if passed HSE_TERM_ADVISORY_UNLOAD, and the module + * will remain loaded, or 1 if it consents to being unloaded. If the module + * is passed HSE_TERM_MUST_UNLOAD, it's return value is ignored. + */ +#define HSE_TERM_MUST_UNLOAD 1 +#define HSE_TERM_ADVISORY_UNLOAD 2 + +#ifdef __cplusplus +} +#endif + +#endif /* !MOD_ISAPI_H */ -- 2.40.0