REQUEST_NOTIFICATION_STATUS CNodeHttpModule::OnExecuteRequestHandler( IN IHttpContext* pHttpContext, IN IHttpEventProvider* pProvider) { UNREFERENCED_PARAMETER( pProvider ); // Create an HRESULT to receive return values from methods. HRESULT hr; // Retrieve a pointer to the response. IHttpResponse * pHttpResponse = pHttpContext->GetResponse(); // Test for an error. if (pHttpResponse != NULL) { // Clear the existing response. pHttpResponse->Clear(); // Set the MIME type to plain text. pHttpResponse->SetHeader( HttpHeaderContentType,"text/plain", (USHORT)strlen("text/plain"),TRUE); // Create a string with the response. PCSTR pszBuffer = "Hello World!"; // Create a data chunk. HTTP_DATA_CHUNK dataChunk; // Set the chunk to a chunk in memory. dataChunk.DataChunkType = HttpDataChunkFromMemory; // Buffer for bytes written of data chunk. DWORD cbSent; // Set the chunk to the buffer. dataChunk.FromMemory.pBuffer = (PVOID) pszBuffer; // Set the chunk size to the buffer size. dataChunk.FromMemory.BufferLength = (USHORT) strlen(pszBuffer); // Insert the data chunk into the response. hr = pHttpResponse->WriteEntityChunks( &dataChunk,1,FALSE,TRUE,&cbSent); // Test for an error. if (FAILED(hr)) { // Set the HTTP status. pHttpResponse->SetStatus(500,"Server Error",0,hr); } // End additional processing. return RQ_NOTIFICATION_FINISH_REQUEST; } // Return processing to the pipeline. return RQ_NOTIFICATION_CONTINUE; }
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; }
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(); 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 data[valueEndOffset] = 0; // zero-terminate header value because this is what IHttpResponse::SetHeader expects CheckError(response->SetHeader(data + offset, data + nameEndOffset + 1, valueEndOffset - nameEndOffset - 1, TRUE)); //CheckError(response->SetHeader(data + offset, data + nameEndOffset + 2, valueEndOffset - nameEndOffset - 2, 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); return S_OK; Error: return hr; }
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; }
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(); 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 if (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++; CheckError(response->SetHeader(data + offset, data + nameEndOffset, valueEndOffset - nameEndOffset, TRUE)); } 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); return S_OK; Error: return hr; }