apr_status_t WriteResponseCallback(request_rec *r, char *buf, unsigned int length) { REQUEST_STORED_CONTEXT *rsc = RetrieveIISContext(r); if(rsc == NULL || rsc->m_pRequestRec == NULL || rsc->m_pResponseBuffer == NULL) return APR_SUCCESS; IHttpContext *pHttpContext = rsc->m_pHttpContext; IHttpResponse *pHttpResponse = pHttpContext->GetResponse(); HTTP_RESPONSE *pRawHttpResponse = pHttpResponse->GetRawHttpResponse(); HTTP_DATA_CHUNK *pDataChunk = (HTTP_DATA_CHUNK *)apr_palloc(rsc->m_pRequestRec->pool, sizeof(HTTP_DATA_CHUNK)); pRawHttpResponse->EntityChunkCount = 0; // since we clean the APR pool at the end of OnSendRequest, we must get IIS-managed memory chunk // void *reqbuf = pHttpContext->AllocateRequestMemory(length); memcpy(reqbuf, buf, length); pDataChunk->DataChunkType = HttpDataChunkFromMemory; pDataChunk->FromMemory.pBuffer = reqbuf; pDataChunk->FromMemory.BufferLength = length; CHAR szLength[21]; //Max length for a 64 bit int is 20 ZeroMemory(szLength, sizeof(szLength)); HRESULT hr = StringCchPrintfA( szLength, sizeof(szLength) / sizeof(CHAR) - 1, "%d", length); if(FAILED(hr)) { // not possible } hr = pHttpResponse->SetHeader( HttpHeaderContentLength, szLength, (USHORT)strlen(szLength), TRUE); if(FAILED(hr)) { // possible, but there's nothing we can do } pHttpResponse->WriteEntityChunkByReference(pDataChunk); return APR_SUCCESS; }
REQUEST_NOTIFICATION_STATUS CMyHttpModule::OnSendResponse( IN IHttpContext * pHttpContext, IN ISendResponseProvider * pResponseProvider ) { REQUEST_STORED_CONTEXT *rsc = NULL; rsc = (REQUEST_STORED_CONTEXT *)pHttpContext->GetModuleContextContainer()->GetModuleContext(g_pModuleContext); EnterCriticalSection(&m_csLock); // here we must check if response body processing is enabled // if(rsc == NULL || rsc->m_pRequestRec == NULL || rsc->m_pResponseBuffer != NULL || !modsecIsResponseBodyAccessEnabled(rsc->m_pRequestRec)) { goto Exit; } HRESULT hr = S_OK; IHttpResponse *pHttpResponse = NULL; HTTP_RESPONSE *pRawHttpResponse = NULL; HTTP_BYTE_RANGE *pFileByteRange = NULL; HTTP_DATA_CHUNK *pSourceDataChunk = NULL; LARGE_INTEGER lFileSize; REQUEST_NOTIFICATION_STATUS ret = RQ_NOTIFICATION_CONTINUE; ULONGLONG ulTotalLength = 0; DWORD c; request_rec *r = rsc->m_pRequestRec; pHttpResponse = pHttpContext->GetResponse(); pRawHttpResponse = pHttpResponse->GetRawHttpResponse(); // here we must add handling of chunked response // apparently IIS 7 calls this handler once per chunk // see: http://stackoverflow.com/questions/4385249/how-to-buffer-and-process-chunked-data-before-sending-headers-in-iis7-native-mod if(pRawHttpResponse->EntityChunkCount == 0) goto Exit; // here we must transfer response headers // USHORT ctcch = 0; char *ct = (char *)pHttpResponse->GetHeader(HttpHeaderContentType, &ctcch); char *ctz = ZeroTerminate(ct, ctcch, r->pool); // assume HTML if content type not set // without this output filter would not buffer response and processing would hang // if(ctz[0] == 0) ctz = "text/html"; r->content_type = ctz; #define _TRANSHEADER(id,str) if(pRawHttpResponse->Headers.KnownHeaders[id].pRawValue != NULL) \ {\ apr_table_setn(r->headers_out, str, \ ZeroTerminate(pRawHttpResponse->Headers.KnownHeaders[id].pRawValue, pRawHttpResponse->Headers.KnownHeaders[id].RawValueLength, r->pool)); \ } _TRANSHEADER(HttpHeaderCacheControl, "Cache-Control"); _TRANSHEADER(HttpHeaderConnection, "Connection"); _TRANSHEADER(HttpHeaderDate, "Date"); _TRANSHEADER(HttpHeaderKeepAlive, "Keep-Alive"); _TRANSHEADER(HttpHeaderPragma, "Pragma"); _TRANSHEADER(HttpHeaderTrailer, "Trailer"); _TRANSHEADER(HttpHeaderTransferEncoding, "Transfer-Encoding"); _TRANSHEADER(HttpHeaderUpgrade, "Upgrade"); _TRANSHEADER(HttpHeaderVia, "Via"); _TRANSHEADER(HttpHeaderWarning, "Warning"); _TRANSHEADER(HttpHeaderAllow, "Allow"); _TRANSHEADER(HttpHeaderContentLength, "Content-Length"); _TRANSHEADER(HttpHeaderContentType, "Content-Type"); _TRANSHEADER(HttpHeaderContentEncoding, "Content-Encoding"); _TRANSHEADER(HttpHeaderContentLanguage, "Content-Language"); _TRANSHEADER(HttpHeaderContentLocation, "Content-Location"); _TRANSHEADER(HttpHeaderContentMd5, "Content-Md5"); _TRANSHEADER(HttpHeaderContentRange, "Content-Range"); _TRANSHEADER(HttpHeaderExpires, "Expires"); _TRANSHEADER(HttpHeaderLastModified, "Last-Modified"); _TRANSHEADER(HttpHeaderAcceptRanges, "Accept-Ranges"); _TRANSHEADER(HttpHeaderAge, "Age"); _TRANSHEADER(HttpHeaderEtag, "Etag"); _TRANSHEADER(HttpHeaderLocation, "Location"); _TRANSHEADER(HttpHeaderProxyAuthenticate, "Proxy-Authenticate"); _TRANSHEADER(HttpHeaderRetryAfter, "Retry-After"); _TRANSHEADER(HttpHeaderServer, "Server"); _TRANSHEADER(HttpHeaderSetCookie, "Set-Cookie"); _TRANSHEADER(HttpHeaderVary, "Vary"); _TRANSHEADER(HttpHeaderWwwAuthenticate, "Www-Authenticate"); #undef _TRANSHEADER for(int i = 0; i < pRawHttpResponse->Headers.UnknownHeaderCount; i++) { apr_table_setn(r->headers_out, ZeroTerminate(pRawHttpResponse->Headers.pUnknownHeaders[i].pName, pRawHttpResponse->Headers.pUnknownHeaders[i].NameLength, r->pool), ZeroTerminate(pRawHttpResponse->Headers.pUnknownHeaders[i].pRawValue, pRawHttpResponse->Headers.pUnknownHeaders[i].RawValueLength, r->pool)); } r->content_encoding = apr_table_get(r->headers_out, "Content-Encoding"); //r->content_type = apr_table_get(r->headers_out, "Content-Type"); -- already set above const char *lng = apr_table_get(r->headers_out, "Content-Languages"); if(lng != NULL) { r->content_languages = apr_array_make(r->pool, 1, sizeof(const char *)); *(const char **)apr_array_push(r->content_languages) = lng; } // Disable kernel caching for this response // Probably we don't have to do it for ModSecurity //pHttpContext->GetResponse()->DisableKernelCache( // IISCacheEvents::HTTPSYS_CACHEABLE::HANDLER_HTTPSYS_UNFRIENDLY); for(c = 0; c < pRawHttpResponse->EntityChunkCount; c++ ) { pSourceDataChunk = &pRawHttpResponse->pEntityChunks[ c ]; switch( pSourceDataChunk->DataChunkType ) { case HttpDataChunkFromMemory: ulTotalLength += pSourceDataChunk->FromMemory.BufferLength; break; case HttpDataChunkFromFileHandle: pFileByteRange = &pSourceDataChunk->FromFileHandle.ByteRange; // // File chunks may contain by ranges with unspecified length // (HTTP_BYTE_RANGE_TO_EOF). In order to send parts of such a chunk, // its necessary to know when the chunk is finished, and // we need to move to the next chunk. // if ( pFileByteRange->Length.QuadPart == HTTP_BYTE_RANGE_TO_EOF) { if ( GetFileType( pSourceDataChunk->FromFileHandle.FileHandle ) == FILE_TYPE_DISK ) { if ( !GetFileSizeEx( pSourceDataChunk->FromFileHandle.FileHandle, &lFileSize ) ) { DWORD dwError = GetLastError(); hr = HRESULT_FROM_WIN32(dwError); goto Finished; } // put the resolved file length in the chunk, replacing // HTTP_BYTE_RANGE_TO_EOF pFileByteRange->Length.QuadPart = lFileSize.QuadPart - pFileByteRange->StartingOffset.QuadPart; } else { hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); goto Finished; } } ulTotalLength += pFileByteRange->Length.QuadPart; break; default: // TBD: consider implementing HttpDataChunkFromFragmentCache, // and HttpDataChunkFromFragmentCacheEx hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); goto Finished; } } rsc->m_pResponseBuffer = (char *)apr_palloc(rsc->m_pRequestRec->pool, ulTotalLength); ulTotalLength = 0; for(c = 0; c < pRawHttpResponse->EntityChunkCount; c++ ) { pSourceDataChunk = &pRawHttpResponse->pEntityChunks[ c ]; switch( pSourceDataChunk->DataChunkType ) { case HttpDataChunkFromMemory: memcpy(rsc->m_pResponseBuffer + ulTotalLength, pSourceDataChunk->FromMemory.pBuffer, pSourceDataChunk->FromMemory.BufferLength); ulTotalLength += pSourceDataChunk->FromMemory.BufferLength; break; case HttpDataChunkFromFileHandle: pFileByteRange = &pSourceDataChunk->FromFileHandle.ByteRange; if(ReadFileChunk(pSourceDataChunk, rsc->m_pResponseBuffer + ulTotalLength) != S_OK) { DWORD dwErr = GetLastError(); hr = HRESULT_FROM_WIN32(dwErr); goto Finished; } ulTotalLength += pFileByteRange->Length.QuadPart; break; default: // TBD: consider implementing HttpDataChunkFromFragmentCache, // and HttpDataChunkFromFragmentCacheEx hr = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED); goto Finished; } } rsc->m_pResponseLength = ulTotalLength; // // If there's no content-length set, we need to set it to avoid chunked transfer mode // We can only do it if there is it's the only response to be sent. // DWORD dwFlags = pResponseProvider->GetFlags(); if (pResponseProvider->GetHeadersBeingSent() && (dwFlags & HTTP_SEND_RESPONSE_FLAG_MORE_DATA) == 0 && pHttpContext->GetResponse()->GetHeader(HttpHeaderContentLength) == NULL) { CHAR szLength[21]; //Max length for a 64 bit int is 20 ZeroMemory(szLength, sizeof(szLength)); hr = StringCchPrintfA( szLength, sizeof(szLength) / sizeof(CHAR) - 1, "%d", ulTotalLength); if(FAILED(hr)) { goto Finished; } hr = pHttpContext->GetResponse()->SetHeader( HttpHeaderContentLength, szLength, (USHORT)strlen(szLength), TRUE); if(FAILED(hr)) { goto Finished; } } Finished: int status = modsecProcessResponse(rsc->m_pRequestRec); // the logic here is temporary, needs clarification // if(status != 0 && status != -1) { pHttpContext->GetResponse()->Clear(); pHttpContext->GetResponse()->SetStatus(status, "ModSecurity Action"); pHttpContext->SetRequestHandled(); rsc->FinishRequest(); LeaveCriticalSection(&m_csLock); return RQ_NOTIFICATION_FINISH_REQUEST; } Exit: // temporary hack, in reality OnSendRequest theoretically could possibly come before OnEndRequest // if(rsc != NULL) rsc->FinishRequest(); LeaveCriticalSection(&m_csLock); return RQ_NOTIFICATION_CONTINUE; }
REQUEST_NOTIFICATION_STATUS CIISxpressHttpModule::OnSendResponse(IN IHttpContext* pHttpContext, IN ISendResponseProvider* pProvider) { const TCHAR* const pszMethodName = __FUNCTIONT__; // only proceed if filter is enabled if (m_Config.GetEnabled() == false) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("module is disabled\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::FilterDisabled); return RQ_NOTIFICATION_CONTINUE; } IHttpRequest* pHttpRequest = pHttpContext->GetRequest(); if (pHttpRequest == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetRequest() returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } IHttpResponse* pHttpResponse = pHttpContext->GetResponse(); if (pHttpResponse == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetResponse() returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } const HTTP_REQUEST* pRawRequest = pHttpRequest->GetRawHttpRequest(); if (pRawRequest == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetRawHttpRequest() returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } const HTTP_RESPONSE* pRawResponse = pHttpResponse->GetRawHttpResponse(); if (pRawResponse == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetRawHttpResponse() returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } // we only handle GET or POST (if POST handling is enabled) if (pRawRequest->Verb != HttpVerbGET && !(pRawRequest->Verb == HttpVerbPOST && m_Config.HandlePOSTResponses())) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("request was not GET or POST\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::RequestMethod); return RQ_NOTIFICATION_CONTINUE; } // only handle status code 200 if (pRawResponse->StatusCode != 200) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("response code is not 200 (%u)\n"), pRawResponse->StatusCode); PerfCountersAddRejectedResponse(IISxpressNativePerf::ResponseCode); return RQ_NOTIFICATION_CONTINUE; } // determine if the request came from localhost if (m_Config.GetCompressLocalhost() == false && IsUserLocalhost(pRawRequest) == true) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext,_T("localhost is disabled\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::LocalhostDisabled); return RQ_NOTIFICATION_CONTINUE; } // *********************************************************************************************************************************** const char* pszUserAgent = EnsureNotNull(pHttpRequest->GetHeader(HttpHeaderUserAgent)); bool excludedUserAgent = false; if (m_Config.GetUserAgentExclusionEnabled()) { DWORD dwUserAgentCacheCookie = m_Config.GetLoadCookie(); if (!m_UserAgentCache.GetUserAgentState(dwUserAgentCacheCookie, pszUserAgent, excludedUserAgent)) { HttpUserAgent::UserAgentProducts<std::string> agent; if (agent.ParseUserAgentString(pszUserAgent) == S_OK) { const HttpUserAgent::RuleUserAgents<std::string>& ruleAgents = m_Config.GetExcludedUserAgents(); if (ruleAgents.Compare(agent)) { excludedUserAgent = true; } m_UserAgentCache.AddUserAgentState(dwUserAgentCacheCookie, pszUserAgent, excludedUserAgent); } } } if (excludedUserAgent) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("the user agent '%s' has been excluded\n"), pszUserAgent); PerfCountersAddRejectedResponse(IISxpressNativePerf::NeverRuleMatch); return RQ_NOTIFICATION_CONTINUE; } // *********************************************************************************************************************************** // we must have only one chunk and data from memory or file if (pRawResponse->EntityChunkCount == 0) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext,_T("can't convert multi-entity buffer, incoming buffer is zero length\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::InvalidContentLength); return RQ_NOTIFICATION_CONTINUE; } else if (pRawResponse->EntityChunkCount != 1) { // turn the multi-chunk response into a single chunk - NB. the response // must all be in memory if (MakeResponseSingleEntityBlock(pHttpContext, pHttpResponse, pRawResponse) == false) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext,_T("can't convert multi-entity buffer\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::MemoryAllocationFailed); return RQ_NOTIFICATION_CONTINUE; } } else if (pRawResponse->pEntityChunks->DataChunkType != HttpDataChunkFromMemory && pRawResponse->pEntityChunks->DataChunkType != HttpDataChunkFromFileHandle) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext,_T("response isn't HttpDataChunkFromMemory or HttpDataChunkFromFileHandle\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } PHTTP_DATA_CHUNK pEntityChunk = pRawResponse->pEntityChunks; if (pEntityChunk == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("the response does not contain any data\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } // TODO: review max size here // we don't handle non-zero starting offsets or very large files (>250MB) if (pEntityChunk->DataChunkType == HttpDataChunkFromFileHandle && (pEntityChunk->FromFileHandle.ByteRange.StartingOffset.QuadPart > 0 || pEntityChunk->FromFileHandle.ByteRange.Length.QuadPart > (250 * 1024 * 1024))) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("response has offset > 0 or is too big\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } PCSTR pszContentEncoding = pHttpResponse->GetHeader(HttpHeaderContentEncoding); if (pszContentEncoding != NULL && pszContentEncoding[0] != '\0') { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("response already has content encoding\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::AlreadyEncoded); return RQ_NOTIFICATION_CONTINUE; } PCSTR pszTransferEncoding = pHttpResponse->GetHeader(HttpHeaderTransferEncoding); if (pszTransferEncoding != NULL && pszTransferEncoding[0] != '\0') { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("response already has transfer encoding\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::AlreadyEncoded); return RQ_NOTIFICATION_CONTINUE; } USHORT nContentTypeLength = 0; PCSTR pszContentType = pHttpResponse->GetHeader(HttpHeaderContentType, &nContentTypeLength); if (pszContentType == NULL || nContentTypeLength == 0) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetHeader(HttpHeaderContentType) returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::MissingContentType); return RQ_NOTIFICATION_CONTINUE; } USHORT nLastModifiedLength = 0; PCSTR pszLastModified = pHttpResponse->GetHeader(HttpHeaderLastModified, &nLastModifiedLength); // *********************************************************************** USHORT nAcceptEncodingLength = 0; PCSTR pszAcceptEncoding = pHttpRequest->GetHeader(HttpHeaderAcceptEncoding, &nAcceptEncodingLength); if (pszAcceptEncoding == NULL || nAcceptEncodingLength == 0 || (strstr(pszAcceptEncoding, "deflate") == NULL && strstr(pszAcceptEncoding, "gzip") == NULL && strstr(pszAcceptEncoding, "bzip2") == NULL)) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("the client does not accept compressed responses\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::IncompatibleClient); return RQ_NOTIFICATION_CONTINUE; } // *********************************************************************** const WCHAR* pszScriptTranslated = pHttpContext->GetScriptTranslated(); if (pszScriptTranslated == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetScriptTranslated() returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } // get the url CAtlStringA sScriptTranslated(pszScriptTranslated); // get the site id CAtlStringA sInstanceId; sInstanceId.Format("%u", pHttpRequest->GetSiteId()); // get the server name PCSTR pszServerName = NULL; DWORD dwServerNameLength = 0; pHttpContext->GetServerVariable("SERVER_NAME", &pszServerName, &dwServerNameLength); if (pszServerName == NULL || dwServerNameLength == 0) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetServerVariable(\"SERVER_NAME\") returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } // get the server port PCSTR pszServerPort = NULL; DWORD dwServerPortLength = 0; pHttpContext->GetServerVariable("SERVER_PORT", &pszServerPort, &dwServerPortLength); if (pszServerPort == NULL || dwServerPortLength == 0) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetServerVariable(\"SERVER_PORT\") returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } DWORD dwContentLength = 0; if (pEntityChunk->DataChunkType == HttpDataChunkFromMemory) { dwContentLength = pRawResponse->pEntityChunks->FromMemory.BufferLength; } else if (pEntityChunk->DataChunkType == HttpDataChunkFromFileHandle) { dwContentLength = pEntityChunk->FromFileHandle.ByteRange.Length.LowPart; } else { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("the DataChunkType (%u) is not supported\n"), pEntityChunk->DataChunkType); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } IISInfo iisinfo; iisinfo.pszInstanceId = sInstanceId; iisinfo.pszServerName = pszServerName; iisinfo.pszServerPort = pszServerPort; iisinfo.pszURLMapPath = sScriptTranslated; if (m_Config.GetDebugEnabled() || m_Config.GetLoggingLevel() >= IISXPRESS_LOGGINGLEVEL_ENH) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("IIS: server name='%hs'\n"), pszServerName); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("IIS: server port='%hs'\n"), pszServerPort); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("IIS: instance id='%hs'\n"), sInstanceId); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("IIS: URL map path='%hs'\n"), sScriptTranslated); } // *********************************************************************** const WCHAR* pszURI = pHttpContext->GetScriptName(); if (pszURI == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("GetScriptName() returned NULL\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::Internal); return RQ_NOTIFICATION_CONTINUE; } // get the uri CAtlStringA sURI(pszURI); // get the query string CAtlStringA sQueryString; if (pRawRequest->CookedUrl.pQueryString != NULL) { sQueryString = pRawRequest->CookedUrl.pQueryString + 1; } // get the remote address // TODO: consider using a cache lookup here CAtlStringA sRemoteAddress; if (pRawRequest != NULL && pRawRequest->Address.pRemoteAddress != NULL) { if (pRawRequest->Address.pRemoteAddress->sa_family == AF_INET) { struct sockaddr_in* paddrin = (struct sockaddr_in*) pRawRequest->Address.pRemoteAddress; // TODO: make this a bit more efficient sRemoteAddress.Format("%u.%u.%u.%u", (unsigned) paddrin->sin_addr.S_un.S_un_b.s_b1, (unsigned) paddrin->sin_addr.S_un.S_un_b.s_b2, (unsigned) paddrin->sin_addr.S_un.S_un_b.s_b3, (unsigned) paddrin->sin_addr.S_un.S_un_b.s_b4); } else if (pRawRequest->Address.pRemoteAddress->sa_family == AF_INET6) { SOCKADDR_IN6* paddrin = (SOCKADDR_IN6*) pRawRequest->Address.pRemoteAddress; // TODO: make this a bit more efficient sRemoteAddress.Format("%0x:%0x:%0x:%0x:%0x:%0x:%0x:%0x", ::htons(paddrin->sin6_addr.u.Word[0]), ::htons(paddrin->sin6_addr.u.Word[1]), ::htons(paddrin->sin6_addr.u.Word[2]), ::htons(paddrin->sin6_addr.u.Word[3]), ::htons(paddrin->sin6_addr.u.Word[4]), ::htons(paddrin->sin6_addr.u.Word[5]), ::htons(paddrin->sin6_addr.u.Word[6]), ::htons(paddrin->sin6_addr.u.Word[7])); } } RequestInfo requestinfo; requestinfo.pszAcceptEncoding = pszAcceptEncoding; requestinfo.pszHostname = EnsureNotNull(pHttpRequest->GetHeader(HttpHeaderHost)); requestinfo.pszQueryString = sQueryString; requestinfo.pszRemoteAddress = sRemoteAddress; requestinfo.pszURI = sURI; requestinfo.pszUserAgent = pszUserAgent; if (m_Config.GetDebugEnabled() || m_Config.GetLoggingLevel() >= IISXPRESS_LOGGINGLEVEL_BASIC) { char* pszMethod = "Unknown"; switch (pRawRequest->Verb) { case HttpVerbGET: pszMethod = "GET"; break; case HttpVerbPOST: pszMethod = "POST"; break; } AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: method='%hs'\n"), pszMethod); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: hostname='%hs'\n"), requestinfo.pszHostname); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: user agent='%hs'\n"), requestinfo.pszUserAgent); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: URI='%hs'\n"), requestinfo.pszURI); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: accept-encoding='%hs'\n"), requestinfo.pszAcceptEncoding); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: client address='%hs'\n"), requestinfo.pszRemoteAddress); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: query string='%hs'\n"), requestinfo.pszQueryString); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: content-type='%hs'\n"), pszContentType); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: content-length=%u\n"), dwContentLength); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: response code=%u\n"), pRawResponse->StatusCode); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("REQUEST: last-modified='%hs'\n"), pszLastModified != NULL ? pszLastModified : "null"); } // *********************************************************************** ResponseInfo responseinfo; responseinfo.dwContentLength = dwContentLength; responseinfo.dwResponseCode = pRawResponse->StatusCode; responseinfo.pszContentType = pszContentType; responseinfo.pszLastModified = pszLastModified; // get a connection to the server from the GIT (if it is connected) CComPtr<IIISxpressHTTPRequest> pIISxpressHTTPRequest; if (m_pGlobalIISxpressHTTPRequest.GetCookie() != 0) { m_pGlobalIISxpressHTTPRequest.CopyTo(&pIISxpressHTTPRequest); } if (pIISxpressHTTPRequest == NULL) { // revoke the pointer in the GIT m_pGlobalIISxpressHTTPRequest.Revoke(); // try to connect to the server if (GetHTTPRequestObject(pHttpContext, &pIISxpressHTTPRequest) == false || pIISxpressHTTPRequest == NULL) { AppendLogMessage(IISXPRESS_LOGGINGLEVEL_ENH, pszMethodName, pHttpContext, _T("unable to connect to server\n")); PerfCountersAddRejectedResponse(IISxpressNativePerf::NoCompressionServer); return RQ_NOTIFICATION_CONTINUE; } // store the resulting pointer in the GIT m_pGlobalIISxpressHTTPRequest = pIISxpressHTTPRequest; } const DWORD dwTimerLoggingLevel = IISXPRESS_LOGGINGLEVEL_FULL; bool useTimer = (m_Config.GetDebugEnabled() || m_Config.GetLoggingLevel() >= dwTimerLoggingLevel); // start timer __int64 nStartTimer = useTimer ? g_Timer.GetMicroSecTimerCount() : 0; CAtlStringA sCacheKey; if (m_nCacheEnabled != 0) { // update the cache perf counters based on the cache cookie PerfCountersUpdateCacheStatus(false); if (pszLastModified != NULL && sQueryString.GetLength() == 0) { ATLASSERT(pszAcceptEncoding != NULL); // create the unique key for the response ResponseCache::CreateResponseCacheKey( sInstanceId, sInstanceId.GetLength(), sURI, sURI.GetLength(), responseinfo.pszContentType, nContentTypeLength, dwContentLength, pszLastModified, nLastModifiedLength, pszAcceptEncoding, nAcceptEncodingLength, sCacheKey); // try to get a compressed response from the cache HCACHEITEM hCacheItem = NULL; HRESULT hr = m_ResponseCache.LookupEntry(sCacheKey, &hCacheItem); if (hr == S_OK) { // get the item from the cache ResponseCacheItem* pCacheItem; DWORD dwCacheItemSize = 0; hr = m_ResponseCache.GetData(hCacheItem, (void**) &pCacheItem, &dwCacheItemSize); void* pBuffer = pHttpContext->AllocateRequestMemory(pCacheItem->dwContentLength); if (pBuffer != NULL) { pHttpResponse->SetHeader(HttpHeaderContentLength, pCacheItem->sContentLength, (USHORT) pCacheItem->sContentLength.GetLength(), TRUE); pHttpResponse->SetHeader(HttpHeaderContentEncoding, pCacheItem->sContentEncoding, (USHORT) pCacheItem->sContentEncoding.GetLength(), TRUE); pEntityChunk->DataChunkType = HttpDataChunkFromMemory; pEntityChunk->FromMemory.pBuffer = pBuffer; pEntityChunk->FromMemory.BufferLength = pCacheItem->dwContentLength; memcpy(pEntityChunk->FromMemory.pBuffer, pCacheItem->pbyData, pCacheItem->dwContentLength); hr = m_ResponseCache.ReleaseEntry(hCacheItem); pIISxpressHTTPRequest->NotifyCacheHit(&iisinfo, &requestinfo, &responseinfo, pCacheItem->dwContentLength); PerfCountersAddCachedResponse(dwContentLength, pCacheItem->dwContentLength); // calculate timer duration __int64 nEndTimer = useTimer ? g_Timer.GetMicroSecTimerCount() : 0; __int64 nInterval = nEndTimer - nStartTimer; AppendLogMessage(dwTimerLoggingLevel, pszMethodName, pHttpContext, _T("response resolved from cache, call took %I64d us\n"), nInterval); return RQ_NOTIFICATION_CONTINUE; } // we failed to handle the cached response, so just proceed as normal (we need to free the // cache entry tho) hr = m_ResponseCache.ReleaseEntry(hCacheItem); } } } DWORD dwFilterContext = 0; HRESULT hr = pIISxpressHTTPRequest->OnSendResponse(&iisinfo, &requestinfo, &responseinfo, &dwFilterContext); // calculate timer duration __int64 nEndTimer = useTimer ? g_Timer.GetMicroSecTimerCount() : 0; __int64 nInterval = nEndTimer - nStartTimer; if (FAILED(hr) == TRUE) { // get the facility code of the failure DWORD dwFacility = HRESULT_FACILITY(hr); // if it isn't NULL or ITF then assume the server is now invalid if (dwFacility != FACILITY_NULL && dwFacility != FACILITY_ITF) { // the GIT is invalid, dump it m_pGlobalIISxpressHTTPRequest.Revoke(); // the server connection is invalid, dump it pIISxpressHTTPRequest = NULL; } } AppendLogMessage(dwTimerLoggingLevel, pszMethodName, pHttpContext, _T("OnSendResponse() returns 0x%08x, call took %I64d us\n"), hr, nInterval); if (FAILED(hr) == TRUE) { // TODO: need to handle generic HRs PerfCountersAddRejectedResponse(hr); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("won't handle response (0x%08x)\n"), hr); return RQ_NOTIFICATION_CONTINUE; } AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("will handle response (0x%08x)\n"), hr); if (pEntityChunk->DataChunkType == HttpDataChunkFromFileHandle) { DWORD dwAllocatedBlockSize = 0; BYTE* pbyData = AllocateMemoryBlockForOverlappedIO(pHttpContext, dwContentLength, dwAllocatedBlockSize); if (pbyData != NULL) { // we are about to perform overlapped IO, so setup the OVERLAPPED struct into a default state OVERLAPPED overlapped; memset(&overlapped, 0, sizeof(overlapped)); HandleObject FileEvent; bool bHandleFromPool = m_hEventHandlePool.GetHandleObject(FileEvent); // if we failed to get a handle from the pool then we need to make one if (bHandleFromPool == false) { HANDLE hReadOK = ::CreateEvent(NULL, TRUE, FALSE, NULL); FileEvent = HandleObject(hReadOK); } // use the event handle so we can track the IO completion overlapped.hEvent = FileEvent; // ask for a file read (asynchronous) DWORD dwStatus = ::ReadFile(pEntityChunk->FromFileHandle.FileHandle, pbyData, dwAllocatedBlockSize, NULL, &overlapped); // wait for the IO to complete (NB. don't really use this since INFINITE can block forever) ::WaitForSingleObject(FileEvent, INFINITE); // we must return the handle (if it came from the pool) if (bHandleFromPool == true) { m_hEventHandlePool.ReturnHandleObject(FileEvent); } pEntityChunk->DataChunkType = HttpDataChunkFromMemory; pEntityChunk->FromMemory.BufferLength = dwContentLength; pEntityChunk->FromMemory.pBuffer = pbyData; } else { hr = E_OUTOFMEMORY; } } else if (pEntityChunk->DataChunkType == HttpDataChunkFromMemory) { // allocate the memory block BYTE* pbyData = (BYTE*) pHttpContext->AllocateRequestMemory(dwContentLength); if (pbyData != NULL) { // copy the response data memcpy(pbyData, pEntityChunk->FromMemory.pBuffer, pEntityChunk->FromMemory.BufferLength); // change the buffer pointer pEntityChunk->FromMemory.pBuffer = pbyData; } else { hr = E_OUTOFMEMORY; } } // allocate the response stream CComPtr<IStream> pStream; CComObject<CResponseStream>* pResponseStream = NULL; if (hr == S_OK) { hr = CComObject<CResponseStream>::CreateInstance(&pResponseStream); if (hr == S_OK) { pStream = pResponseStream; } } // catch any memory issues if (FAILED(hr) == TRUE) { // abort the compression pIISxpressHTTPRequest->AbortRequest(dwFilterContext); // TODO: need to handle generic HRs PerfCountersAddRejectedResponse(hr); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("won't handle response (0x%08x)\n"), hr); return RQ_NOTIFICATION_CONTINUE; } pResponseStream->AttachBuffer(pEntityChunk->FromMemory.pBuffer, dwContentLength, 0); char szContentEncoding[32] = ""; hr = pIISxpressHTTPRequest->OnSendRawData(dwFilterContext, pStream, dwContentLength, FALSE, (signed char*) szContentEncoding, _countof(szContentEncoding)); if (hr == S_OK) { DWORD dwOriginalSize = dwContentLength; DWORD dwCompressedSize = pResponseStream->GetOffset(); // set the new content length into the header CAtlStringA sContentLength; sContentLength.Format("%u", dwCompressedSize); pHttpResponse->SetHeader(HttpHeaderContentLength, sContentLength, (USHORT) sContentLength.GetLength(), TRUE); // set the new size into the buffer pRawResponse->pEntityChunks->FromMemory.BufferLength = dwCompressedSize; pHttpResponse->SetHeader(HttpHeaderContentEncoding, szContentEncoding, (USHORT) strlen(szContentEncoding), TRUE); // add the item to the cache if we have a key (it means the data is cachable) if (dwCompressedSize < dwOriginalSize && m_nCacheEnabled != 0 && sCacheKey.GetLength() > 0) { ResponseCacheItem* pCacheItem = new ResponseCacheItem(); if (pCacheItem != NULL) { pCacheItem->sContentEncoding = szContentEncoding; pCacheItem->sContentLength = sContentLength; pCacheItem->dwContentLength = dwCompressedSize; pCacheItem->pbyData = new BYTE[dwCompressedSize]; if (pCacheItem->pbyData != NULL) { // copy the compressed data and add it to the cache memcpy(pCacheItem->pbyData, pEntityChunk->FromMemory.pBuffer, dwCompressedSize); m_ResponseCache.Add(sCacheKey, pCacheItem, pCacheItem->dwContentLength, NULL, NULL, NULL, m_ResponseCacheItemDeallocator); PerfCountersUpdateCacheStatus(true); } } } PerfCountersAddCompressedResponse(dwContentLength, dwCompressedSize); // make sure the context is released hr = pIISxpressHTTPRequest->OnEndOfRequest(dwFilterContext, NULL, 0, FALSE, NULL, 0); } else { // abort the compression pIISxpressHTTPRequest->AbortRequest(dwFilterContext); // TODO: need to handle generic HRs PerfCountersAddRejectedResponse(hr); AppendLogMessage(IISXPRESS_LOGGINGLEVEL_BASIC, pszMethodName, pHttpContext, _T("won't handle response (0x%08x)\n"), hr); } return RQ_NOTIFICATION_CONTINUE; }
HRESULT CHttpProtocol::ParseResponseHeaders(CNodeHttpStoredContext* context) { HRESULT hr; char* data = (char*)context->GetBuffer() + context->GetParsingOffset(); DWORD dataSize = context->GetDataSize() - context->GetParsingOffset(); DWORD offset = 0; DWORD nameEndOffset, valueEndOffset; IHttpResponse* response = context->GetHttpContext()->GetResponse(); BOOL needConnectionHeaderFixup = FALSE; while (offset < (dataSize - 1) && data[offset] != 0x0D) { // header name nameEndOffset = offset; while (nameEndOffset < dataSize && data[nameEndOffset] != ':') { nameEndOffset++; } ErrorIf(nameEndOffset == dataSize, ERROR_MORE_DATA); // header value valueEndOffset = nameEndOffset + 1; while (valueEndOffset < (dataSize - 1) && data[valueEndOffset] != 0x0D) { valueEndOffset++; } ErrorIf(valueEndOffset >= dataSize - 1, ERROR_MORE_DATA); ErrorIf(0x0A != data[valueEndOffset + 1], ERROR_BAD_FORMAT); // set header on response data[nameEndOffset] = 0; // zero-terminate name to reuse without copying // Skip the Connection header because it relates to the iisnode <-> node.exe communication over named pipes, // unless this is a 101 response to HTTP Upgrade request, in which case this is used to inform HTTP.SYS to keep the // connection open. if (context->GetIsUpgrade() || 0 != strcmpi("Connection", data + offset)) { data[valueEndOffset] = 0; // zero-terminate header value because this is what IHttpResponse::SetHeader expects // skip over ':' nameEndOffset++; // skip over leading whitespace in value while (*(data + nameEndOffset) == ' ') // data is already zero-terminated, so this loop has sentinel value nameEndOffset++; if (context->GetIsUpgrade() && 0 == strcmpi("Connection", data + offset)) { // Add the Connection header under a custom name to force it to be added to unknown headers collection. // Header name will subsequently be fixed up back to Connection. // The end result is that the Connection header ends up in the unknown headers collection rather then // known headers collection where it would get ignored by http.sys. CheckError(response->SetHeader("x-iisnode-connection", data + nameEndOffset, valueEndOffset - nameEndOffset, FALSE)); needConnectionHeaderFixup = TRUE; } else { CheckError(response->SetHeader(data + offset, data + nameEndOffset, valueEndOffset - nameEndOffset, FALSE)); } } else if ((valueEndOffset - nameEndOffset) >= 5 && 0 == memcmp((void*)(data + valueEndOffset - 5), "close", 5)) { context->SetCloseConnection(TRUE); } // adjust offsets context->SetParsingOffset(context->GetParsingOffset() + valueEndOffset - offset + 2); offset = valueEndOffset + 2; } ErrorIf(offset >= dataSize - 1, ERROR_MORE_DATA); ErrorIf(0x0A != data[offset + 1], ERROR_BAD_FORMAT); context->SetParsingOffset(context->GetParsingOffset() + 2); if (needConnectionHeaderFixup) { HTTP_RESPONSE* rawResponse = response->GetRawHttpResponse(); for (int i = 0; i < response->GetRawHttpResponse()->Headers.UnknownHeaderCount; i++) { if (20 == rawResponse->Headers.pUnknownHeaders[i].NameLength && 0 == _strnicmp("x-iisnode-connection", rawResponse->Headers.pUnknownHeaders[i].pName, 20)) { rawResponse->Headers.pUnknownHeaders[i].NameLength = 10; rawResponse->Headers.pUnknownHeaders[i].pName = "Connection"; break; } } } return S_OK; Error: return hr; }